gas/config/tc-arm.c

   1 /* tc-arm.c -- Assemble for the ARM
   2    Copyright (C) 1994-2019 Free Software Foundation, Inc.
   3    Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
   4         Modified by David Taylor (dtaylor@armltd.co.uk)
   5         Cirrus coprocessor mods by Aldy Hernandez (aldyh@redhat.com)
   6         Cirrus coprocessor fixes by Petko Manolov (petkan@nucleusys.com)
   7         Cirrus coprocessor fixes by Vladimir Ivanov (vladitx@nucleusys.com)
   8
   9    This file is part of GAS, the GNU Assembler.
  10
  11    GAS is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3, or (at your option)
  14    any later version.
  15
  16    GAS is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with GAS; see the file COPYING.  If not, write to the Free
  23    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  24    02110-1301, USA.  */
  25
  26 #include "as.h"
  27 #include <limits.h>
  28 #include <stdarg.h>
  29 #define  NO_RELOC 0
  30 #include "safe-ctype.h"
  31 #include "subsegs.h"
  32 #include "obstack.h"
  33 #include "libiberty.h"
  34 #include "opcode/arm.h"
  35
  36 #ifdef OBJ_ELF
  37 #include "elf/arm.h"
  38 #include "dw2gencfi.h"
  39 #endif
  40
  41 #include "dwarf2dbg.h"
  42
  43 #ifdef OBJ_ELF
  44 /* Must be at least the size of the largest unwind opcode (currently two).  */
  45 #define ARM_OPCODE_CHUNK_SIZE 8
  46
  47 /* This structure holds the unwinding state.  */
  48
  49 static struct
  50 {
  51   symbolS *       proc_start;
  52   symbolS *       table_entry;
  53   symbolS *       personality_routine;
  54   int             personality_index;
  55   /* The segment containing the function.  */
  56   segT            saved_seg;
  57   subsegT         saved_subseg;
  58   /* Opcodes generated from this function.  */
  59   unsigned char * opcodes;
  60   int             opcode_count;
  61   int             opcode_alloc;
  62   /* The number of bytes pushed to the stack.  */
  63   offsetT         frame_size;
  64   /* We don't add stack adjustment opcodes immediately so that we can merge
  65      multiple adjustments.  We can also omit the final adjustment
  66      when using a frame pointer.  */
  67   offsetT         pending_offset;
  68   /* These two fields are set by both unwind_movsp and unwind_setfp.  They
  69      hold the reg+offset to use when restoring sp from a frame pointer.  */
  70   offsetT         fp_offset;
  71   int             fp_reg;
  72   /* Nonzero if an unwind_setfp directive has been seen.  */
  73   unsigned        fp_used:1;
  74   /* Nonzero if the last opcode restores sp from fp_reg.  */
  75   unsigned        sp_restored:1;
  76 } unwind;
  77
  78 /* Whether --fdpic was given.  */
  79 static int arm_fdpic;
  80
  81 #endif /* OBJ_ELF */
  82
  83 /* Results from operand parsing worker functions.  */
  84
  85 typedef enum
  86 {
  87   PARSE_OPERAND_SUCCESS,
  88   PARSE_OPERAND_FAIL,
  89   PARSE_OPERAND_FAIL_NO_BACKTRACK
  90 } parse_operand_result;
  91
  92 enum arm_float_abi
  93 {
  94   ARM_FLOAT_ABI_HARD,
  95   ARM_FLOAT_ABI_SOFTFP,
  96   ARM_FLOAT_ABI_SOFT
  97 };
  98
  99 /* Types of processor to assemble for.  */
 100 #ifndef CPU_DEFAULT
 101 /* The code that was here used to select a default CPU depending on compiler
 102    pre-defines which were only present when doing native builds, thus
 103    changing gas' default behaviour depending upon the build host.
 104
 105    If you have a target that requires a default CPU option then the you
 106    should define CPU_DEFAULT here.  */
 107 #endif
 108
 109 #ifndef FPU_DEFAULT
 110 # ifdef TE_LINUX
 111 #  define FPU_DEFAULT FPU_ARCH_FPA
 112 # elif defined (TE_NetBSD)
 113 #  ifdef OBJ_ELF
 114 #   define FPU_DEFAULT FPU_ARCH_VFP     /* Soft-float, but VFP order.  */
 115 #  else
 116     /* Legacy a.out format.  */
 117 #   define FPU_DEFAULT FPU_ARCH_FPA     /* Soft-float, but FPA order.  */
 118 #  endif
 119 # elif defined (TE_VXWORKS)
 120 #  define FPU_DEFAULT FPU_ARCH_VFP      /* Soft-float, VFP order.  */
 121 # else
 122    /* For backwards compatibility, default to FPA.  */
 123 #  define FPU_DEFAULT FPU_ARCH_FPA
 124 # endif
 125 #endif /* ifndef FPU_DEFAULT */
 126
 127 #define streq(a, b)           (strcmp (a, b) == 0)
 128
 129 /* Current set of feature bits available (CPU+FPU).  Different from
 130    selected_cpu + selected_fpu in case of autodetection since the CPU
 131    feature bits are then all set.  */
 132 static arm_feature_set cpu_variant;
 133 /* Feature bits used in each execution state.  Used to set build attribute
 134    (in particular Tag_*_ISA_use) in CPU autodetection mode.  */
 135 static arm_feature_set arm_arch_used;
 136 static arm_feature_set thumb_arch_used;
 137
 138 /* Flags stored in private area of BFD structure.  */
 139 static int uses_apcs_26      = FALSE;
 140 static int atpcs             = FALSE;
 141 static int support_interwork = FALSE;
 142 static int uses_apcs_float   = FALSE;
 143 static int pic_code          = FALSE;
 144 static int fix_v4bx          = FALSE;
 145 /* Warn on using deprecated features.  */
 146 static int warn_on_deprecated = TRUE;
 147
 148 /* Understand CodeComposer Studio assembly syntax.  */
 149 bfd_boolean codecomposer_syntax = FALSE;
 150
 151 /* Variables that we set while parsing command-line options.  Once all
 152    options have been read we re-process these values to set the real
 153    assembly flags.  */
 154
 155 /* CPU and FPU feature bits set for legacy CPU and FPU options (eg. -marm1
 156    instead of -mcpu=arm1).  */
 157 static const arm_feature_set *legacy_cpu = NULL;
 158 static const arm_feature_set *legacy_fpu = NULL;
 159
 160 /* CPU, extension and FPU feature bits selected by -mcpu.  */
 161 static const arm_feature_set *mcpu_cpu_opt = NULL;
 162 static arm_feature_set *mcpu_ext_opt = NULL;
 163 static const arm_feature_set *mcpu_fpu_opt = NULL;
 164
 165 /* CPU, extension and FPU feature bits selected by -march.  */
 166 static const arm_feature_set *march_cpu_opt = NULL;
 167 static arm_feature_set *march_ext_opt = NULL;
 168 static const arm_feature_set *march_fpu_opt = NULL;
 169
 170 /* Feature bits selected by -mfpu.  */
 171 static const arm_feature_set *mfpu_opt = NULL;
 172
 173 /* Constants for known architecture features.  */
 174 static const arm_feature_set fpu_default = FPU_DEFAULT;
 175 static const arm_feature_set fpu_arch_vfp_v1 ATTRIBUTE_UNUSED = FPU_ARCH_VFP_V1;
 176 static const arm_feature_set fpu_arch_vfp_v2 = FPU_ARCH_VFP_V2;
 177 static const arm_feature_set fpu_arch_vfp_v3 ATTRIBUTE_UNUSED = FPU_ARCH_VFP_V3;
 178 static const arm_feature_set fpu_arch_neon_v1 ATTRIBUTE_UNUSED = FPU_ARCH_NEON_V1;
 179 static const arm_feature_set fpu_arch_fpa = FPU_ARCH_FPA;
 180 static const arm_feature_set fpu_any_hard = FPU_ANY_HARD;
 181 #ifdef OBJ_ELF
 182 static const arm_feature_set fpu_arch_maverick = FPU_ARCH_MAVERICK;
 183 #endif
 184 static const arm_feature_set fpu_endian_pure = FPU_ARCH_ENDIAN_PURE;
 185
 186 #ifdef CPU_DEFAULT
 187 static const arm_feature_set cpu_default = CPU_DEFAULT;
 188 #endif
 189
 190 static const arm_feature_set arm_ext_v1 = ARM_FEATURE_CORE_LOW (ARM_EXT_V1);
 191 static const arm_feature_set arm_ext_v2 = ARM_FEATURE_CORE_LOW (ARM_EXT_V2);
 192 static const arm_feature_set arm_ext_v2s = ARM_FEATURE_CORE_LOW (ARM_EXT_V2S);
 193 static const arm_feature_set arm_ext_v3 = ARM_FEATURE_CORE_LOW (ARM_EXT_V3);
 194 static const arm_feature_set arm_ext_v3m = ARM_FEATURE_CORE_LOW (ARM_EXT_V3M);
 195 static const arm_feature_set arm_ext_v4 = ARM_FEATURE_CORE_LOW (ARM_EXT_V4);
 196 static const arm_feature_set arm_ext_v4t = ARM_FEATURE_CORE_LOW (ARM_EXT_V4T);
 197 static const arm_feature_set arm_ext_v5 = ARM_FEATURE_CORE_LOW (ARM_EXT_V5);
 198 static const arm_feature_set arm_ext_v4t_5 =
 199   ARM_FEATURE_CORE_LOW (ARM_EXT_V4T | ARM_EXT_V5);
 200 static const arm_feature_set arm_ext_v5t = ARM_FEATURE_CORE_LOW (ARM_EXT_V5T);
 201 static const arm_feature_set arm_ext_v5e = ARM_FEATURE_CORE_LOW (ARM_EXT_V5E);
 202 static const arm_feature_set arm_ext_v5exp = ARM_FEATURE_CORE_LOW (ARM_EXT_V5ExP);
 203 static const arm_feature_set arm_ext_v5j = ARM_FEATURE_CORE_LOW (ARM_EXT_V5J);
 204 static const arm_feature_set arm_ext_v6 = ARM_FEATURE_CORE_LOW (ARM_EXT_V6);
 205 static const arm_feature_set arm_ext_v6k = ARM_FEATURE_CORE_LOW (ARM_EXT_V6K);
 206 static const arm_feature_set arm_ext_v6t2 = ARM_FEATURE_CORE_LOW (ARM_EXT_V6T2);
 207 /* Only for compatability of hint instructions.  */
 208 static const arm_feature_set arm_ext_v6k_v6t2 =
 209   ARM_FEATURE_CORE_LOW (ARM_EXT_V6K | ARM_EXT_V6T2);
 210 static const arm_feature_set arm_ext_v6_notm =
 211   ARM_FEATURE_CORE_LOW (ARM_EXT_V6_NOTM);
 212 static const arm_feature_set arm_ext_v6_dsp =
 213   ARM_FEATURE_CORE_LOW (ARM_EXT_V6_DSP);
 214 static const arm_feature_set arm_ext_barrier =
 215   ARM_FEATURE_CORE_LOW (ARM_EXT_BARRIER);
 216 static const arm_feature_set arm_ext_msr =
 217   ARM_FEATURE_CORE_LOW (ARM_EXT_THUMB_MSR);
 218 static const arm_feature_set arm_ext_div = ARM_FEATURE_CORE_LOW (ARM_EXT_DIV);
 219 static const arm_feature_set arm_ext_v7 = ARM_FEATURE_CORE_LOW (ARM_EXT_V7);
 220 static const arm_feature_set arm_ext_v7a = ARM_FEATURE_CORE_LOW (ARM_EXT_V7A);
 221 static const arm_feature_set arm_ext_v7r = ARM_FEATURE_CORE_LOW (ARM_EXT_V7R);
 222 #ifdef OBJ_ELF
 223 static const arm_feature_set ATTRIBUTE_UNUSED arm_ext_v7m = ARM_FEATURE_CORE_LOW (ARM_EXT_V7M);
 224 #endif
 225 static const arm_feature_set arm_ext_v8 = ARM_FEATURE_CORE_LOW (ARM_EXT_V8);
 226 static const arm_feature_set arm_ext_m =
 227   ARM_FEATURE_CORE (ARM_EXT_V6M | ARM_EXT_V7M,
 228                     ARM_EXT2_V8M | ARM_EXT2_V8M_MAIN);
 229 static const arm_feature_set arm_ext_mp = ARM_FEATURE_CORE_LOW (ARM_EXT_MP);
 230 static const arm_feature_set arm_ext_sec = ARM_FEATURE_CORE_LOW (ARM_EXT_SEC);
 231 static const arm_feature_set arm_ext_os = ARM_FEATURE_CORE_LOW (ARM_EXT_OS);
 232 static const arm_feature_set arm_ext_adiv = ARM_FEATURE_CORE_LOW (ARM_EXT_ADIV);
 233 static const arm_feature_set arm_ext_virt = ARM_FEATURE_CORE_LOW (ARM_EXT_VIRT);
 234 static const arm_feature_set arm_ext_pan = ARM_FEATURE_CORE_HIGH (ARM_EXT2_PAN);
 235 static const arm_feature_set arm_ext_v8m = ARM_FEATURE_CORE_HIGH (ARM_EXT2_V8M);
 236 static const arm_feature_set arm_ext_v8m_main =
 237   ARM_FEATURE_CORE_HIGH (ARM_EXT2_V8M_MAIN);
 238 static const arm_feature_set arm_ext_v8_1m_main =
 239 ARM_FEATURE_CORE_HIGH (ARM_EXT2_V8_1M_MAIN);
 240 /* Instructions in ARMv8-M only found in M profile architectures.  */
 241 static const arm_feature_set arm_ext_v8m_m_only =
 242   ARM_FEATURE_CORE_HIGH (ARM_EXT2_V8M | ARM_EXT2_V8M_MAIN);
 243 static const arm_feature_set arm_ext_v6t2_v8m =
 244   ARM_FEATURE_CORE_HIGH (ARM_EXT2_V6T2_V8M);
 245 /* Instructions shared between ARMv8-A and ARMv8-M.  */
 246 static const arm_feature_set arm_ext_atomics =
 247   ARM_FEATURE_CORE_HIGH (ARM_EXT2_ATOMICS);
 248 #ifdef OBJ_ELF
 249 /* DSP instructions Tag_DSP_extension refers to.  */
 250 static const arm_feature_set arm_ext_dsp =
 251   ARM_FEATURE_CORE_LOW (ARM_EXT_V5E | ARM_EXT_V5ExP | ARM_EXT_V6_DSP);
 252 #endif
 253 static const arm_feature_set arm_ext_ras =
 254   ARM_FEATURE_CORE_HIGH (ARM_EXT2_RAS);
 255 /* FP16 instructions.  */
 256 static const arm_feature_set arm_ext_fp16 =
 257   ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_INST);
 258 static const arm_feature_set arm_ext_fp16_fml =
 259   ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_FML);
 260 static const arm_feature_set arm_ext_v8_2 =
 261   ARM_FEATURE_CORE_HIGH (ARM_EXT2_V8_2A);
 262 static const arm_feature_set arm_ext_v8_3 =
 263   ARM_FEATURE_CORE_HIGH (ARM_EXT2_V8_3A);
 264 static const arm_feature_set arm_ext_sb =
 265   ARM_FEATURE_CORE_HIGH (ARM_EXT2_SB);
 266 static const arm_feature_set arm_ext_predres =
 267   ARM_FEATURE_CORE_HIGH (ARM_EXT2_PREDRES);
 268
 269 static const arm_feature_set arm_arch_any = ARM_ANY;
 270 #ifdef OBJ_ELF
 271 static const arm_feature_set fpu_any = FPU_ANY;
 272 #endif
 273 static const arm_feature_set arm_arch_full ATTRIBUTE_UNUSED = ARM_FEATURE (-1, -1, -1);
 274 static const arm_feature_set arm_arch_t2 = ARM_ARCH_THUMB2;
 275 static const arm_feature_set arm_arch_none = ARM_ARCH_NONE;
 276
 277 static const arm_feature_set arm_cext_iwmmxt2 =
 278   ARM_FEATURE_COPROC (ARM_CEXT_IWMMXT2);
 279 static const arm_feature_set arm_cext_iwmmxt =
 280   ARM_FEATURE_COPROC (ARM_CEXT_IWMMXT);
 281 static const arm_feature_set arm_cext_xscale =
 282   ARM_FEATURE_COPROC (ARM_CEXT_XSCALE);
 283 static const arm_feature_set arm_cext_maverick =
 284   ARM_FEATURE_COPROC (ARM_CEXT_MAVERICK);
 285 static const arm_feature_set fpu_fpa_ext_v1 =
 286   ARM_FEATURE_COPROC (FPU_FPA_EXT_V1);
 287 static const arm_feature_set fpu_fpa_ext_v2 =
 288   ARM_FEATURE_COPROC (FPU_FPA_EXT_V2);
 289 static const arm_feature_set fpu_vfp_ext_v1xd =
 290   ARM_FEATURE_COPROC (FPU_VFP_EXT_V1xD);
 291 static const arm_feature_set fpu_vfp_ext_v1 =
 292   ARM_FEATURE_COPROC (FPU_VFP_EXT_V1);
 293 static const arm_feature_set fpu_vfp_ext_v2 =
 294   ARM_FEATURE_COPROC (FPU_VFP_EXT_V2);
 295 static const arm_feature_set fpu_vfp_ext_v3xd =
 296   ARM_FEATURE_COPROC (FPU_VFP_EXT_V3xD);
 297 static const arm_feature_set fpu_vfp_ext_v3 =
 298   ARM_FEATURE_COPROC (FPU_VFP_EXT_V3);
 299 static const arm_feature_set fpu_vfp_ext_d32 =
 300   ARM_FEATURE_COPROC (FPU_VFP_EXT_D32);
 301 static const arm_feature_set fpu_neon_ext_v1 =
 302   ARM_FEATURE_COPROC (FPU_NEON_EXT_V1);
 303 static const arm_feature_set fpu_vfp_v3_or_neon_ext =
 304   ARM_FEATURE_COPROC (FPU_NEON_EXT_V1 | FPU_VFP_EXT_V3);
 305 #ifdef OBJ_ELF
 306 static const arm_feature_set fpu_vfp_fp16 =
 307   ARM_FEATURE_COPROC (FPU_VFP_EXT_FP16);
 308 static const arm_feature_set fpu_neon_ext_fma =
 309   ARM_FEATURE_COPROC (FPU_NEON_EXT_FMA);
 310 #endif
 311 static const arm_feature_set fpu_vfp_ext_fma =
 312   ARM_FEATURE_COPROC (FPU_VFP_EXT_FMA);
 313 static const arm_feature_set fpu_vfp_ext_armv8 =
 314   ARM_FEATURE_COPROC (FPU_VFP_EXT_ARMV8);
 315 static const arm_feature_set fpu_vfp_ext_armv8xd =
 316   ARM_FEATURE_COPROC (FPU_VFP_EXT_ARMV8xD);
 317 static const arm_feature_set fpu_neon_ext_armv8 =
 318   ARM_FEATURE_COPROC (FPU_NEON_EXT_ARMV8);
 319 static const arm_feature_set fpu_crypto_ext_armv8 =
 320   ARM_FEATURE_COPROC (FPU_CRYPTO_EXT_ARMV8);
 321 static const arm_feature_set crc_ext_armv8 =
 322   ARM_FEATURE_COPROC (CRC_EXT_ARMV8);
 323 static const arm_feature_set fpu_neon_ext_v8_1 =
 324   ARM_FEATURE_COPROC (FPU_NEON_EXT_RDMA);
 325 static const arm_feature_set fpu_neon_ext_dotprod =
 326   ARM_FEATURE_COPROC (FPU_NEON_EXT_DOTPROD);
 327
 328 static int mfloat_abi_opt = -1;
 329 /* Architecture feature bits selected by the last -mcpu/-march or .cpu/.arch
 330    directive.  */
 331 static arm_feature_set selected_arch = ARM_ARCH_NONE;
 332 /* Extension feature bits selected by the last -mcpu/-march or .arch_extension
 333    directive.  */
 334 static arm_feature_set selected_ext = ARM_ARCH_NONE;
 335 /* Feature bits selected by the last -mcpu/-march or by the combination of the
 336    last .cpu/.arch directive .arch_extension directives since that
 337    directive.  */
 338 static arm_feature_set selected_cpu = ARM_ARCH_NONE;
 339 /* FPU feature bits selected by the last -mfpu or .fpu directive.  */
 340 static arm_feature_set selected_fpu = FPU_NONE;
 341 /* Feature bits selected by the last .object_arch directive.  */
 342 static arm_feature_set selected_object_arch = ARM_ARCH_NONE;
 343 /* Must be long enough to hold any of the names in arm_cpus.  */
 344 static char selected_cpu_name[20];
 345
 346 extern FLONUM_TYPE generic_floating_point_number;
 347
 348 /* Return if no cpu was selected on command-line.  */
 349 static bfd_boolean
 350 no_cpu_selected (void)
 351 {
 352   return ARM_FEATURE_EQUAL (selected_cpu, arm_arch_none);
 353 }
 354
 355 #ifdef OBJ_ELF
 356 # ifdef EABI_DEFAULT
 357 static int meabi_flags = EABI_DEFAULT;
 358 # else
 359 static int meabi_flags = EF_ARM_EABI_UNKNOWN;
 360 # endif
 361
 362 static int attributes_set_explicitly[NUM_KNOWN_OBJ_ATTRIBUTES];
 363
 364 bfd_boolean
 365 arm_is_eabi (void)
 366 {
 367   return (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4);
 368 }
 369 #endif
 370
 371 #ifdef OBJ_ELF
 372 /* Pre-defined "_GLOBAL_OFFSET_TABLE_"  */
 373 symbolS * GOT_symbol;
 374 #endif
 375
 376 /* 0: assemble for ARM,
 377    1: assemble for Thumb,
 378    2: assemble for Thumb even though target CPU does not support thumb
 379       instructions.  */
 380 static int thumb_mode = 0;
 381 /* A value distinct from the possible values for thumb_mode that we
 382    can use to record whether thumb_mode has been copied into the
 383    tc_frag_data field of a frag.  */
 384 #define MODE_RECORDED (1 << 4)
 385
 386 /* Specifies the intrinsic IT insn behavior mode.  */
 387 enum implicit_it_mode
 388 {
 389   IMPLICIT_IT_MODE_NEVER  = 0x00,
 390   IMPLICIT_IT_MODE_ARM    = 0x01,
 391   IMPLICIT_IT_MODE_THUMB  = 0x02,
 392   IMPLICIT_IT_MODE_ALWAYS = (IMPLICIT_IT_MODE_ARM | IMPLICIT_IT_MODE_THUMB)
 393 };
 394 static int implicit_it_mode = IMPLICIT_IT_MODE_ARM;
 395
 396 /* If unified_syntax is true, we are processing the new unified
 397    ARM/Thumb syntax.  Important differences from the old ARM mode:
 398
 399      - Immediate operands do not require a # prefix.
 400      - Conditional affixes always appear at the end of the
 401        instruction.  (For backward compatibility, those instructions
 402        that formerly had them in the middle, continue to accept them
 403        there.)
 404      - The IT instruction may appear, and if it does is validated
 405        against subsequent conditional affixes.  It does not generate
 406        machine code.
 407
 408    Important differences from the old Thumb mode:
 409
 410      - Immediate operands do not require a # prefix.
 411      - Most of the V6T2 instructions are only available in unified mode.
 412      - The .N and .W suffixes are recognized and honored (it is an error
 413        if they cannot be honored).
 414      - All instructions set the flags if and only if they have an 's' affix.
 415      - Conditional affixes may be used.  They are validated against
 416        preceding IT instructions.  Unlike ARM mode, you cannot use a
 417        conditional affix except in the scope of an IT instruction.  */
 418
 419 static bfd_boolean unified_syntax = FALSE;
 420
 421 /* An immediate operand can start with #, and ld*, st*, pld operands
 422    can contain [ and ].  We need to tell APP not to elide whitespace
 423    before a [, which can appear as the first operand for pld.
 424    Likewise, a { can appear as the first operand for push, pop, vld*, etc.  */
 425 const char arm_symbol_chars[] = "#[]{}";
 426
 427 enum neon_el_type
 428 {
 429   NT_invtype,
 430   NT_untyped,
 431   NT_integer,
 432   NT_float,
 433   NT_poly,
 434   NT_signed,
 435   NT_unsigned
 436 };
 437
 438 struct neon_type_el
 439 {
 440   enum neon_el_type type;
 441   unsigned size;
 442 };
 443
 444 #define NEON_MAX_TYPE_ELS 4
 445
 446 struct neon_type
 447 {
 448   struct neon_type_el el[NEON_MAX_TYPE_ELS];
 449   unsigned elems;
 450 };
 451
 452 enum it_instruction_type
 453 {
 454    OUTSIDE_IT_INSN,
 455    INSIDE_IT_INSN,
 456    INSIDE_IT_LAST_INSN,
 457    IF_INSIDE_IT_LAST_INSN, /* Either outside or inside;
 458                               if inside, should be the last one.  */
 459    NEUTRAL_IT_INSN,        /* This could be either inside or outside,
 460                               i.e. BKPT and NOP.  */
 461    IT_INSN                 /* The IT insn has been parsed.  */
 462 };
 463
 464 /* The maximum number of operands we need.  */
 465 #define ARM_IT_MAX_OPERANDS 6
 466 #define ARM_IT_MAX_RELOCS 3
 467
 468 struct arm_it
 469 {
 470   const char *  error;
 471   unsigned long instruction;
 472   int           size;
 473   int           size_req;
 474   int           cond;
 475   /* "uncond_value" is set to the value in place of the conditional field in
 476      unconditional versions of the instruction, or -1 if nothing is
 477      appropriate.  */
 478   int           uncond_value;
 479   struct neon_type vectype;
 480   /* This does not indicate an actual NEON instruction, only that
 481      the mnemonic accepts neon-style type suffixes.  */
 482   int           is_neon;
 483   /* Set to the opcode if the instruction needs relaxation.
 484      Zero if the instruction is not relaxed.  */
 485   unsigned long relax;
 486   struct
 487   {
 488     bfd_reloc_code_real_type type;
 489     expressionS              exp;
 490     int                      pc_rel;
 491   } relocs[ARM_IT_MAX_RELOCS];
 492
 493   enum it_instruction_type it_insn_type;
 494
 495   struct
 496   {
 497     unsigned reg;
 498     signed int imm;
 499     struct neon_type_el vectype;
 500     unsigned present    : 1;  /* Operand present.  */
 501     unsigned isreg      : 1;  /* Operand was a register.  */
 502     unsigned immisreg   : 1;  /* .imm field is a second register.  */
 503     unsigned isscalar   : 1;  /* Operand is a (Neon) scalar.  */
 504     unsigned immisalign : 1;  /* Immediate is an alignment specifier.  */
 505     unsigned immisfloat : 1;  /* Immediate was parsed as a float.  */
 506     /* Note: we abuse "regisimm" to mean "is Neon register" in VMOV
 507        instructions. This allows us to disambiguate ARM <-> vector insns.  */
 508     unsigned regisimm   : 1;  /* 64-bit immediate, reg forms high 32 bits.  */
 509     unsigned isvec      : 1;  /* Is a single, double or quad VFP/Neon reg.  */
 510     unsigned isquad     : 1;  /* Operand is Neon quad-precision register.  */
 511     unsigned issingle   : 1;  /* Operand is VFP single-precision register.  */
 512     unsigned hasreloc   : 1;  /* Operand has relocation suffix.  */
 513     unsigned writeback  : 1;  /* Operand has trailing !  */
 514     unsigned preind     : 1;  /* Preindexed address.  */
 515     unsigned postind    : 1;  /* Postindexed address.  */
 516     unsigned negative   : 1;  /* Index register was negated.  */
 517     unsigned shifted    : 1;  /* Shift applied to operation.  */
 518     unsigned shift_kind : 3;  /* Shift operation (enum shift_kind).  */
 519   } operands[ARM_IT_MAX_OPERANDS];
 520 };
 521
 522 static struct arm_it inst;
 523
 524 #define NUM_FLOAT_VALS 8
 525
 526 const char * fp_const[] =
 527 {
 528   "0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0", 0
 529 };
 530
 531 /* Number of littlenums required to hold an extended precision number.  */
 532 #define MAX_LITTLENUMS 6
 533
 534 LITTLENUM_TYPE fp_values[NUM_FLOAT_VALS][MAX_LITTLENUMS];
 535
 536 #define FAIL    (-1)
 537 #define SUCCESS (0)
 538
 539 #define SUFF_S 1
 540 #define SUFF_D 2
 541 #define SUFF_E 3
 542 #define SUFF_P 4
 543
 544 #define CP_T_X   0x00008000
 545 #define CP_T_Y   0x00400000
 546
 547 #define CONDS_BIT        0x00100000
 548 #define LOAD_BIT         0x00100000
 549
 550 #define DOUBLE_LOAD_FLAG 0x00000001
 551
 552 struct asm_cond
 553 {
 554   const char *   template_name;
 555   unsigned long  value;
 556 };
 557
 558 #define COND_ALWAYS 0xE
 559
 560 struct asm_psr
 561 {
 562   const char *   template_name;
 563   unsigned long  field;
 564 };
 565
 566 struct asm_barrier_opt
 567 {
 568   const char *    template_name;
 569   unsigned long   value;
 570   const arm_feature_set arch;
 571 };
 572
 573 /* The bit that distinguishes CPSR and SPSR.  */
 574 #define SPSR_BIT   (1 << 22)
 575
 576 /* The individual PSR flag bits.  */
 577 #define PSR_c   (1 << 16)
 578 #define PSR_x   (1 << 17)
 579 #define PSR_s   (1 << 18)
 580 #define PSR_f   (1 << 19)
 581
 582 struct reloc_entry
 583 {
 584   const char *              name;
 585   bfd_reloc_code_real_type  reloc;
 586 };
 587
 588 enum vfp_reg_pos
 589 {
 590   VFP_REG_Sd, VFP_REG_Sm, VFP_REG_Sn,
 591   VFP_REG_Dd, VFP_REG_Dm, VFP_REG_Dn
 592 };
 593
 594 enum vfp_ldstm_type
 595 {
 596   VFP_LDSTMIA, VFP_LDSTMDB, VFP_LDSTMIAX, VFP_LDSTMDBX
 597 };
 598
 599 /* Bits for DEFINED field in neon_typed_alias.  */
 600 #define NTA_HASTYPE  1
 601 #define NTA_HASINDEX 2
 602
 603 struct neon_typed_alias
 604 {
 605   unsigned char        defined;
 606   unsigned char        index;
 607   struct neon_type_el  eltype;
 608 };
 609
 610 /* ARM register categories.  This includes coprocessor numbers and various
 611    architecture extensions' registers.  Each entry should have an error message
 612    in reg_expected_msgs below.  */
 613 enum arm_reg_type
 614 {
 615   REG_TYPE_RN,
 616   REG_TYPE_CP,
 617   REG_TYPE_CN,
 618   REG_TYPE_FN,
 619   REG_TYPE_VFS,
 620   REG_TYPE_VFD,
 621   REG_TYPE_NQ,
 622   REG_TYPE_VFSD,
 623   REG_TYPE_NDQ,
 624   REG_TYPE_NSD,
 625   REG_TYPE_NSDQ,
 626   REG_TYPE_VFC,
 627   REG_TYPE_MVF,
 628   REG_TYPE_MVD,
 629   REG_TYPE_MVFX,
 630   REG_TYPE_MVDX,
 631   REG_TYPE_MVAX,
 632   REG_TYPE_DSPSC,
 633   REG_TYPE_MMXWR,
 634   REG_TYPE_MMXWC,
 635   REG_TYPE_MMXWCG,
 636   REG_TYPE_XSCALE,
 637   REG_TYPE_RNB
 638 };
 639
 640 /* Structure for a hash table entry for a register.
 641    If TYPE is REG_TYPE_VFD or REG_TYPE_NQ, the NEON field can point to extra
 642    information which states whether a vector type or index is specified (for a
 643    register alias created with .dn or .qn). Otherwise NEON should be NULL.  */
 644 struct reg_entry
 645 {
 646   const char *               name;
 647   unsigned int               number;
 648   unsigned char              type;
 649   unsigned char              builtin;
 650   struct neon_typed_alias *  neon;
 651 };
 652
 653 /* Diagnostics used when we don't get a register of the expected type.  */
 654 const char * const reg_expected_msgs[] =
 655 {
 656   [REG_TYPE_RN]     = N_("ARM register expected"),
 657   [REG_TYPE_CP]     = N_("bad or missing co-processor number"),
 658   [REG_TYPE_CN]     = N_("co-processor register expected"),
 659   [REG_TYPE_FN]     = N_("FPA register expected"),
 660   [REG_TYPE_VFS]    = N_("VFP single precision register expected"),
 661   [REG_TYPE_VFD]    = N_("VFP/Neon double precision register expected"),
 662   [REG_TYPE_NQ]     = N_("Neon quad precision register expected"),
 663   [REG_TYPE_VFSD]   = N_("VFP single or double precision register expected"),
 664   [REG_TYPE_NDQ]    = N_("Neon double or quad precision register expected"),
 665   [REG_TYPE_NSD]    = N_("Neon single or double precision register expected"),
 666   [REG_TYPE_NSDQ]   = N_("VFP single, double or Neon quad precision register"
 667                          " expected"),
 668   [REG_TYPE_VFC]    = N_("VFP system register expected"),
 669   [REG_TYPE_MVF]    = N_("Maverick MVF register expected"),
 670   [REG_TYPE_MVD]    = N_("Maverick MVD register expected"),
 671   [REG_TYPE_MVFX]   = N_("Maverick MVFX register expected"),
 672   [REG_TYPE_MVDX]   = N_("Maverick MVDX register expected"),
 673   [REG_TYPE_MVAX]   = N_("Maverick MVAX register expected"),
 674   [REG_TYPE_DSPSC]  = N_("Maverick DSPSC register expected"),
 675   [REG_TYPE_MMXWR]  = N_("iWMMXt data register expected"),
 676   [REG_TYPE_MMXWC]  = N_("iWMMXt control register expected"),
 677   [REG_TYPE_MMXWCG] = N_("iWMMXt scalar register expected"),
 678   [REG_TYPE_XSCALE] = N_("XScale accumulator register expected"),
 679   [REG_TYPE_RNB]    = N_("")
 680 };
 681
 682 /* Some well known registers that we refer to directly elsewhere.  */
 683 #define REG_R12 12
 684 #define REG_SP  13
 685 #define REG_LR  14
 686 #define REG_PC  15
 687
 688 /* ARM instructions take 4bytes in the object file, Thumb instructions
 689    take 2:  */
 690 #define INSN_SIZE       4
 691
 692 struct asm_opcode
 693 {
 694   /* Basic string to match.  */
 695   const char * template_name;
 696
 697   /* Parameters to instruction.  */
 698   unsigned int operands[8];
 699
 700   /* Conditional tag - see opcode_lookup.  */
 701   unsigned int tag : 4;
 702
 703   /* Basic instruction code.  */
 704   unsigned int avalue : 28;
 705
 706   /* Thumb-format instruction code.  */
 707   unsigned int tvalue;
 708
 709   /* Which architecture variant provides this instruction.  */
 710   const arm_feature_set * avariant;
 711   const arm_feature_set * tvariant;
 712
 713   /* Function to call to encode instruction in ARM format.  */
 714   void (* aencode) (void);
 715
 716   /* Function to call to encode instruction in Thumb format.  */
 717   void (* tencode) (void);
 718 };
 719
 720 /* Defines for various bits that we will want to toggle.  */
 721 #define INST_IMMEDIATE  0x02000000
 722 #define OFFSET_REG      0x02000000
 723 #define HWOFFSET_IMM    0x00400000
 724 #define SHIFT_BY_REG    0x00000010
 725 #define PRE_INDEX       0x01000000
 726 #define INDEX_UP        0x00800000
 727 #define WRITE_BACK      0x00200000
 728 #define LDM_TYPE_2_OR_3 0x00400000
 729 #define CPSI_MMOD       0x00020000
 730
 731 #define LITERAL_MASK    0xf000f000
 732 #define OPCODE_MASK     0xfe1fffff
 733 #define V4_STR_BIT      0x00000020
 734 #define VLDR_VMOV_SAME  0x0040f000
 735
 736 #define T2_SUBS_PC_LR   0xf3de8f00
 737
 738 #define DATA_OP_SHIFT   21
 739 #define SBIT_SHIFT      20
 740
 741 #define T2_OPCODE_MASK  0xfe1fffff
 742 #define T2_DATA_OP_SHIFT 21
 743 #define T2_SBIT_SHIFT    20
 744
 745 #define A_COND_MASK         0xf0000000
 746 #define A_PUSH_POP_OP_MASK  0x0fff0000
 747
 748 /* Opcodes for pushing/poping registers to/from the stack.  */
 749 #define A1_OPCODE_PUSH    0x092d0000
 750 #define A2_OPCODE_PUSH    0x052d0004
 751 #define A2_OPCODE_POP     0x049d0004
 752
 753 /* Codes to distinguish the arithmetic instructions.  */
 754 #define OPCODE_AND      0
 755 #define OPCODE_EOR      1
 756 #define OPCODE_SUB      2
 757 #define OPCODE_RSB      3
 758 #define OPCODE_ADD      4
 759 #define OPCODE_ADC      5
 760 #define OPCODE_SBC      6
 761 #define OPCODE_RSC      7
 762 #define OPCODE_TST      8
 763 #define OPCODE_TEQ      9
 764 #define OPCODE_CMP      10
 765 #define OPCODE_CMN      11
 766 #define OPCODE_ORR      12
 767 #define OPCODE_MOV      13
 768 #define OPCODE_BIC      14
 769 #define OPCODE_MVN      15
 770
 771 #define T2_OPCODE_AND   0
 772 #define T2_OPCODE_BIC   1
 773 #define T2_OPCODE_ORR   2
 774 #define T2_OPCODE_ORN   3
 775 #define T2_OPCODE_EOR   4
 776 #define T2_OPCODE_ADD   8
 777 #define T2_OPCODE_ADC   10
 778 #define T2_OPCODE_SBC   11
 779 #define T2_OPCODE_SUB   13
 780 #define T2_OPCODE_RSB   14
 781
 782 #define T_OPCODE_MUL 0x4340
 783 #define T_OPCODE_TST 0x4200
 784 #define T_OPCODE_CMN 0x42c0
 785 #define T_OPCODE_NEG 0x4240
 786 #define T_OPCODE_MVN 0x43c0
 787
 788 #define T_OPCODE_ADD_R3 0x1800
 789 #define T_OPCODE_SUB_R3 0x1a00
 790 #define T_OPCODE_ADD_HI 0x4400
 791 #define T_OPCODE_ADD_ST 0xb000
 792 #define T_OPCODE_SUB_ST 0xb080
 793 #define T_OPCODE_ADD_SP 0xa800
 794 #define T_OPCODE_ADD_PC 0xa000
 795 #define T_OPCODE_ADD_I8 0x3000
 796 #define T_OPCODE_SUB_I8 0x3800
 797 #define T_OPCODE_ADD_I3 0x1c00
 798 #define T_OPCODE_SUB_I3 0x1e00
 799
 800 #define T_OPCODE_ASR_R  0x4100
 801 #define T_OPCODE_LSL_R  0x4080
 802 #define T_OPCODE_LSR_R  0x40c0
 803 #define T_OPCODE_ROR_R  0x41c0
 804 #define T_OPCODE_ASR_I  0x1000
 805 #define T_OPCODE_LSL_I  0x0000
 806 #define T_OPCODE_LSR_I  0x0800
 807
 808 #define T_OPCODE_MOV_I8 0x2000
 809 #define T_OPCODE_CMP_I8 0x2800
 810 #define T_OPCODE_CMP_LR 0x4280
 811 #define T_OPCODE_MOV_HR 0x4600
 812 #define T_OPCODE_CMP_HR 0x4500
 813
 814 #define T_OPCODE_LDR_PC 0x4800
 815 #define T_OPCODE_LDR_SP 0x9800
 816 #define T_OPCODE_STR_SP 0x9000
 817 #define T_OPCODE_LDR_IW 0x6800
 818 #define T_OPCODE_STR_IW 0x6000
 819 #define T_OPCODE_LDR_IH 0x8800
 820 #define T_OPCODE_STR_IH 0x8000
 821 #define T_OPCODE_LDR_IB 0x7800
 822 #define T_OPCODE_STR_IB 0x7000
 823 #define T_OPCODE_LDR_RW 0x5800
 824 #define T_OPCODE_STR_RW 0x5000
 825 #define T_OPCODE_LDR_RH 0x5a00
 826 #define T_OPCODE_STR_RH 0x5200
 827 #define T_OPCODE_LDR_RB 0x5c00
 828 #define T_OPCODE_STR_RB 0x5400
 829
 830 #define T_OPCODE_PUSH   0xb400
 831 #define T_OPCODE_POP    0xbc00
 832
 833 #define T_OPCODE_BRANCH 0xe000
 834
 835 #define THUMB_SIZE      2       /* Size of thumb instruction.  */
 836 #define THUMB_PP_PC_LR 0x0100
 837 #define THUMB_LOAD_BIT 0x0800
 838 #define THUMB2_LOAD_BIT 0x00100000
 839
 840 #define BAD_ARGS        _("bad arguments to instruction")
 841 #define BAD_SP          _("r13 not allowed here")
 842 #define BAD_PC          _("r15 not allowed here")
 843 #define BAD_COND        _("instruction cannot be conditional")
 844 #define BAD_OVERLAP     _("registers may not be the same")
 845 #define BAD_HIREG       _("lo register required")
 846 #define BAD_THUMB32     _("instruction not supported in Thumb16 mode")
 847 #define BAD_ADDR_MODE   _("instruction does not accept this addressing mode");
 848 #define BAD_BRANCH      _("branch must be last instruction in IT block")
 849 #define BAD_BRANCH_OFF  _("branch out of range or not a multiple of 2")
 850 #define BAD_NOT_IT      _("instruction not allowed in IT block")
 851 #define BAD_FPU         _("selected FPU does not support instruction")
 852 #define BAD_OUT_IT      _("thumb conditional instruction should be in IT block")
 853 #define BAD_IT_COND     _("incorrect condition in IT block")
 854 #define BAD_IT_IT       _("IT falling in the range of a previous IT block")
 855 #define MISSING_FNSTART _("missing .fnstart before unwinding directive")
 856 #define BAD_PC_ADDRESSING \
 857         _("cannot use register index with PC-relative addressing")
 858 #define BAD_PC_WRITEBACK \
 859         _("cannot use writeback with PC-relative addressing")
 860 #define BAD_RANGE       _("branch out of range")
 861 #define BAD_FP16        _("selected processor does not support fp16 instruction")
 862 #define UNPRED_REG(R)   _("using " R " results in unpredictable behaviour")
 863 #define THUMB1_RELOC_ONLY  _("relocation valid in thumb1 code only")
 864
 865 static struct hash_control * arm_ops_hsh;
 866 static struct hash_control * arm_cond_hsh;
 867 static struct hash_control * arm_shift_hsh;
 868 static struct hash_control * arm_psr_hsh;
 869 static struct hash_control * arm_v7m_psr_hsh;
 870 static struct hash_control * arm_reg_hsh;
 871 static struct hash_control * arm_reloc_hsh;
 872 static struct hash_control * arm_barrier_opt_hsh;
 873
 874 /* Stuff needed to resolve the label ambiguity
 875    As:
 876      ...
 877      label:   <insn>
 878    may differ from:
 879      ...
 880      label:
 881               <insn>  */
 882
 883 symbolS *  last_label_seen;
 884 static int label_is_thumb_function_name = FALSE;
 885
 886 /* Literal pool structure.  Held on a per-section
 887    and per-sub-section basis.  */
 888
 889 #define MAX_LITERAL_POOL_SIZE 1024
 890 typedef struct literal_pool
 891 {
 892   expressionS            literals [MAX_LITERAL_POOL_SIZE];
 893   unsigned int           next_free_entry;
 894   unsigned int           id;
 895   symbolS *              symbol;
 896   segT                   section;
 897   subsegT                sub_section;
 898 #ifdef OBJ_ELF
 899   struct dwarf2_line_info locs [MAX_LITERAL_POOL_SIZE];
 900 #endif
 901   struct literal_pool *  next;
 902   unsigned int           alignment;
 903 } literal_pool;
 904
 905 /* Pointer to a linked list of literal pools.  */
 906 literal_pool * list_of_pools = NULL;
 907
 908 typedef enum asmfunc_states
 909 {
 910   OUTSIDE_ASMFUNC,
 911   WAITING_ASMFUNC_NAME,
 912   WAITING_ENDASMFUNC
 913 } asmfunc_states;
 914
 915 static asmfunc_states asmfunc_state = OUTSIDE_ASMFUNC;
 916
 917 #ifdef OBJ_ELF
 918 #  define now_it seg_info (now_seg)->tc_segment_info_data.current_it
 919 #else
 920 static struct current_it now_it;
 921 #endif
 922
 923 static inline int
 924 now_it_compatible (int cond)
 925 {
 926   return (cond & ~1) == (now_it.cc & ~1);
 927 }
 928
 929 static inline int
 930 conditional_insn (void)
 931 {
 932   return inst.cond != COND_ALWAYS;
 933 }
 934
 935 static int in_it_block (void);
 936
 937 static int handle_it_state (void);
 938
 939 static void force_automatic_it_block_close (void);
 940
 941 static void it_fsm_post_encode (void);
 942
 943 #define set_it_insn_type(type)                  \
 944   do                                            \
 945     {                                           \
 946       inst.it_insn_type = type;                 \
 947       if (handle_it_state () == FAIL)           \
 948         return;                                 \
 949     }                                           \
 950   while (0)
 951
 952 #define set_it_insn_type_nonvoid(type, failret) \
 953   do                                            \
 954     {                                           \
 955       inst.it_insn_type = type;                 \
 956       if (handle_it_state () == FAIL)           \
 957         return failret;                         \
 958     }                                           \
 959   while(0)
 960
 961 #define set_it_insn_type_last()                         \
 962   do                                                    \
 963     {                                                   \
 964       if (inst.cond == COND_ALWAYS)                     \
 965         set_it_insn_type (IF_INSIDE_IT_LAST_INSN);      \
 966       else                                              \
 967         set_it_insn_type (INSIDE_IT_LAST_INSN);         \
 968     }                                                   \
 969   while (0)
 970
 971 /* Pure syntax.  */
 972
 973 /* This array holds the chars that always start a comment.  If the
 974    pre-processor is disabled, these aren't very useful.  */
 975 char arm_comment_chars[] = "@";
 976
 977 /* This array holds the chars that only start a comment at the beginning of
 978    a line.  If the line seems to have the form '# 123 filename'
 979    .line and .file directives will appear in the pre-processed output.  */
 980 /* Note that input_file.c hand checks for '#' at the beginning of the
 981    first line of the input file.  This is because the compiler outputs
 982    #NO_APP at the beginning of its output.  */
 983 /* Also note that comments like this one will always work.  */
 984 const char line_comment_chars[] = "#";
 985
 986 char arm_line_separator_chars[] = ";";
 987
 988 /* Chars that can be used to separate mant
 989    from exp in floating point numbers.  */
 990 const char EXP_CHARS[] = "eE";
 991
 992 /* Chars that mean this number is a floating point constant.  */
 993 /* As in 0f12.456  */
 994 /* or    0d1.2345e12  */
 995
 996 const char FLT_CHARS[] = "rRsSfFdDxXeEpP";
 997
 998 /* Prefix characters that indicate the start of an immediate
 999    value.  */
1000 #define is_immediate_prefix(C) ((C) == '#' || (C) == '$')
1001
1002 /* Separator character handling.  */
1003
1004 #define skip_whitespace(str)  do { if (*(str) == ' ') ++(str); } while (0)
1005
1006 static inline int
1007 skip_past_char (char ** str, char c)
1008 {
1009   /* PR gas/14987: Allow for whitespace before the expected character.  */
1010   skip_whitespace (*str);
1011
1012   if (**str == c)
1013     {
1014       (*str)++;
1015       return SUCCESS;
1016     }
1017   else
1018     return FAIL;
1019 }
1020
1021 #define skip_past_comma(str) skip_past_char (str, ',')
1022
1023 /* Arithmetic expressions (possibly involving symbols).  */
1024
1025 /* Return TRUE if anything in the expression is a bignum.  */
1026
1027 static bfd_boolean
1028 walk_no_bignums (symbolS * sp)
1029 {
1030   if (symbol_get_value_expression (sp)->X_op == O_big)
1031     return TRUE;
1032
1033   if (symbol_get_value_expression (sp)->X_add_symbol)
1034     {
1035       return (walk_no_bignums (symbol_get_value_expression (sp)->X_add_symbol)
1036               || (symbol_get_value_expression (sp)->X_op_symbol
1037                   && walk_no_bignums (symbol_get_value_expression (sp)->X_op_symbol)));
1038     }
1039
1040   return FALSE;
1041 }
1042
1043 static bfd_boolean in_my_get_expression = FALSE;
1044
1045 /* Third argument to my_get_expression.  */
1046 #define GE_NO_PREFIX 0
1047 #define GE_IMM_PREFIX 1
1048 #define GE_OPT_PREFIX 2
1049 /* This is a bit of a hack. Use an optional prefix, and also allow big (64-bit)
1050    immediates, as can be used in Neon VMVN and VMOV immediate instructions.  */
1051 #define GE_OPT_PREFIX_BIG 3
1052
1053 static int
1054 my_get_expression (expressionS * ep, char ** str, int prefix_mode)
1055 {
1056   char * save_in;
1057
1058   /* In unified syntax, all prefixes are optional.  */
1059   if (unified_syntax)
1060     prefix_mode = (prefix_mode == GE_OPT_PREFIX_BIG) ? prefix_mode
1061                   : GE_OPT_PREFIX;
1062
1063   switch (prefix_mode)
1064     {
1065     case GE_NO_PREFIX: break;
1066     case GE_IMM_PREFIX:
1067       if (!is_immediate_prefix (**str))
1068         {
1069           inst.error = _("immediate expression requires a # prefix");
1070           return FAIL;
1071         }
1072       (*str)++;
1073       break;
1074     case GE_OPT_PREFIX:
1075     case GE_OPT_PREFIX_BIG:
1076       if (is_immediate_prefix (**str))
1077         (*str)++;
1078       break;
1079     default:
1080       abort ();
1081     }
1082
1083   memset (ep, 0, sizeof (expressionS));
1084
1085   save_in = input_line_pointer;
1086   input_line_pointer = *str;
1087   in_my_get_expression = TRUE;
1088   expression (ep);
1089   in_my_get_expression = FALSE;
1090
1091   if (ep->X_op == O_illegal || ep->X_op == O_absent)
1092     {
1093       /* We found a bad or missing expression in md_operand().  */
1094       *str = input_line_pointer;
1095       input_line_pointer = save_in;
1096       if (inst.error == NULL)
1097         inst.error = (ep->X_op == O_absent
1098                       ? _("missing expression") :_("bad expression"));
1099       return 1;
1100     }
1101
1102   /* Get rid of any bignums now, so that we don't generate an error for which
1103      we can't establish a line number later on.  Big numbers are never valid
1104      in instructions, which is where this routine is always called.  */
1105   if (prefix_mode != GE_OPT_PREFIX_BIG
1106       && (ep->X_op == O_big
1107           || (ep->X_add_symbol
1108               && (walk_no_bignums (ep->X_add_symbol)
1109                   || (ep->X_op_symbol
1110                       && walk_no_bignums (ep->X_op_symbol))))))
1111     {
1112       inst.error = _("invalid constant");
1113       *str = input_line_pointer;
1114       input_line_pointer = save_in;
1115       return 1;
1116     }
1117
1118   *str = input_line_pointer;
1119   input_line_pointer = save_in;
1120   return SUCCESS;
1121 }
1122
1123 /* Turn a string in input_line_pointer into a floating point constant
1124    of type TYPE, and store the appropriate bytes in *LITP.  The number
1125    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
1126    returned, or NULL on OK.
1127
1128    Note that fp constants aren't represent in the normal way on the ARM.
1129    In big endian mode, things are as expected.  However, in little endian
1130    mode fp constants are big-endian word-wise, and little-endian byte-wise
1131    within the words.  For example, (double) 1.1 in big endian mode is
1132    the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is
1133    the byte sequence 99 99 f1 3f 9a 99 99 99.
1134
1135    ??? The format of 12 byte floats is uncertain according to gcc's arm.h.  */
1136
1137 const char *
1138 md_atof (int type, char * litP, int * sizeP)
1139 {
1140   int prec;
1141   LITTLENUM_TYPE words[MAX_LITTLENUMS];
1142   char *t;
1143   int i;
1144
1145   switch (type)
1146     {
1147     case 'f':
1148     case 'F':
1149     case 's':
1150     case 'S':
1151       prec = 2;
1152       break;
1153
1154     case 'd':
1155     case 'D':
1156     case 'r':
1157     case 'R':
1158       prec = 4;
1159       break;
1160
1161     case 'x':
1162     case 'X':
1163       prec = 5;
1164       break;
1165
1166     case 'p':
1167     case 'P':
1168       prec = 5;
1169       break;
1170
1171     default:
1172       *sizeP = 0;
1173       return _("Unrecognized or unsupported floating point constant");
1174     }
1175
1176   t = atof_ieee (input_line_pointer, type, words);
1177   if (t)
1178     input_line_pointer = t;
1179   *sizeP = prec * sizeof (LITTLENUM_TYPE);
1180
1181   if (target_big_endian)
1182     {
1183       for (i = 0; i < prec; i++)
1184         {
1185           md_number_to_chars (litP, (valueT) words[i], sizeof (LITTLENUM_TYPE));
1186           litP += sizeof (LITTLENUM_TYPE);
1187         }
1188     }
1189   else
1190     {
1191       if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_endian_pure))
1192         for (i = prec - 1; i >= 0; i--)
1193           {
1194             md_number_to_chars (litP, (valueT) words[i], sizeof (LITTLENUM_TYPE));
1195             litP += sizeof (LITTLENUM_TYPE);
1196           }
1197       else
1198         /* For a 4 byte float the order of elements in `words' is 1 0.
1199            For an 8 byte float the order is 1 0 3 2.  */
1200         for (i = 0; i < prec; i += 2)
1201           {
1202             md_number_to_chars (litP, (valueT) words[i + 1],
1203                                 sizeof (LITTLENUM_TYPE));
1204             md_number_to_chars (litP + sizeof (LITTLENUM_TYPE),
1205                                 (valueT) words[i], sizeof (LITTLENUM_TYPE));
1206             litP += 2 * sizeof (LITTLENUM_TYPE);
1207           }
1208     }
1209
1210   return NULL;
1211 }
1212
1213 /* We handle all bad expressions here, so that we can report the faulty
1214    instruction in the error message.  */
1215
1216 void
1217 md_operand (expressionS * exp)
1218 {
1219   if (in_my_get_expression)
1220     exp->X_op = O_illegal;
1221 }
1222
1223 /* Immediate values.  */
1224
1225 #ifdef OBJ_ELF
1226 /* Generic immediate-value read function for use in directives.
1227    Accepts anything that 'expression' can fold to a constant.
1228    *val receives the number.  */
1229
1230 static int
1231 immediate_for_directive (int *val)
1232 {
1233   expressionS exp;
1234   exp.X_op = O_illegal;
1235
1236   if (is_immediate_prefix (*input_line_pointer))
1237     {
1238       input_line_pointer++;
1239       expression (&exp);
1240     }
1241
1242   if (exp.X_op != O_constant)
1243     {
1244       as_bad (_("expected #constant"));
1245       ignore_rest_of_line ();
1246       return FAIL;
1247     }
1248   *val = exp.X_add_number;
1249   return SUCCESS;
1250 }
1251 #endif
1252
1253 /* Register parsing.  */
1254
1255 /* Generic register parser.  CCP points to what should be the
1256    beginning of a register name.  If it is indeed a valid register
1257    name, advance CCP over it and return the reg_entry structure;
1258    otherwise return NULL.  Does not issue diagnostics.  */
1259
1260 static struct reg_entry *
1261 arm_reg_parse_multi (char **ccp)
1262 {
1263   char *start = *ccp;
1264   char *p;
1265   struct reg_entry *reg;
1266
1267   skip_whitespace (start);
1268
1269 #ifdef REGISTER_PREFIX
1270   if (*start != REGISTER_PREFIX)
1271     return NULL;
1272   start++;
1273 #endif
1274 #ifdef OPTIONAL_REGISTER_PREFIX
1275   if (*start == OPTIONAL_REGISTER_PREFIX)
1276     start++;
1277 #endif
1278
1279   p = start;
1280   if (!ISALPHA (*p) || !is_name_beginner (*p))
1281     return NULL;
1282
1283   do
1284     p++;
1285   while (ISALPHA (*p) || ISDIGIT (*p) || *p == '_');
1286
1287   reg = (struct reg_entry *) hash_find_n (arm_reg_hsh, start, p - start);
1288
1289   if (!reg)
1290     return NULL;
1291
1292   *ccp = p;
1293   return reg;
1294 }
1295
1296 static int
1297 arm_reg_alt_syntax (char **ccp, char *start, struct reg_entry *reg,
1298                     enum arm_reg_type type)
1299 {
1300   /* Alternative syntaxes are accepted for a few register classes.  */
1301   switch (type)
1302     {
1303     case REG_TYPE_MVF:
1304     case REG_TYPE_MVD:
1305     case REG_TYPE_MVFX:
1306     case REG_TYPE_MVDX:
1307       /* Generic coprocessor register names are allowed for these.  */
1308       if (reg && reg->type == REG_TYPE_CN)
1309         return reg->number;
1310       break;
1311
1312     case REG_TYPE_CP:
1313       /* For backward compatibility, a bare number is valid here.  */
1314       {
1315         unsigned long processor = strtoul (start, ccp, 10);
1316         if (*ccp != start && processor <= 15)
1317           return processor;
1318       }
1319       /* Fall through.  */
1320
1321     case REG_TYPE_MMXWC:
1322       /* WC includes WCG.  ??? I'm not sure this is true for all
1323          instructions that take WC registers.  */
1324       if (reg && reg->type == REG_TYPE_MMXWCG)
1325         return reg->number;
1326       break;
1327
1328     default:
1329       break;
1330     }
1331
1332   return FAIL;
1333 }
1334
1335 /* As arm_reg_parse_multi, but the register must be of type TYPE, and the
1336    return value is the register number or FAIL.  */
1337
1338 static int
1339 arm_reg_parse (char **ccp, enum arm_reg_type type)
1340 {
1341   char *start = *ccp;
1342   struct reg_entry *reg = arm_reg_parse_multi (ccp);
1343   int ret;
1344
1345   /* Do not allow a scalar (reg+index) to parse as a register.  */
1346   if (reg && reg->neon && (reg->neon->defined & NTA_HASINDEX))
1347     return FAIL;
1348
1349   if (reg && reg->type == type)
1350     return reg->number;
1351
1352   if ((ret = arm_reg_alt_syntax (ccp, start, reg, type)) != FAIL)
1353     return ret;
1354
1355   *ccp = start;
1356   return FAIL;
1357 }
1358
1359 /* Parse a Neon type specifier. *STR should point at the leading '.'
1360    character. Does no verification at this stage that the type fits the opcode
1361    properly. E.g.,
1362
1363      .i32.i32.s16
1364      .s32.f32
1365      .u16
1366
1367    Can all be legally parsed by this function.
1368
1369    Fills in neon_type struct pointer with parsed information, and updates STR
1370    to point after the parsed type specifier. Returns SUCCESS if this was a legal
1371    type, FAIL if not.  */
1372
1373 static int
1374 parse_neon_type (struct neon_type *type, char **str)
1375 {
1376   char *ptr = *str;
1377
1378   if (type)
1379     type->elems = 0;
1380
1381   while (type->elems < NEON_MAX_TYPE_ELS)
1382     {
1383       enum neon_el_type thistype = NT_untyped;
1384       unsigned thissize = -1u;
1385
1386       if (*ptr != '.')
1387         break;
1388
1389       ptr++;
1390
1391       /* Just a size without an explicit type.  */
1392       if (ISDIGIT (*ptr))
1393         goto parsesize;
1394
1395       switch (TOLOWER (*ptr))
1396         {
1397         case 'i': thistype = NT_integer; break;
1398         case 'f': thistype = NT_float; break;
1399         case 'p': thistype = NT_poly; break;
1400         case 's': thistype = NT_signed; break;
1401         case 'u': thistype = NT_unsigned; break;
1402         case 'd':
1403           thistype = NT_float;
1404           thissize = 64;
1405           ptr++;
1406           goto done;
1407         default:
1408           as_bad (_("unexpected character `%c' in type specifier"), *ptr);
1409           return FAIL;
1410         }
1411
1412       ptr++;
1413
1414       /* .f is an abbreviation for .f32.  */
1415       if (thistype == NT_float && !ISDIGIT (*ptr))
1416         thissize = 32;
1417       else
1418         {
1419         parsesize:
1420           thissize = strtoul (ptr, &ptr, 10);
1421
1422           if (thissize != 8 && thissize != 16 && thissize != 32
1423               && thissize != 64)
1424             {
1425               as_bad (_("bad size %d in type specifier"), thissize);
1426               return FAIL;
1427             }
1428         }
1429
1430       done:
1431       if (type)
1432         {
1433           type->el[type->elems].type = thistype;
1434           type->el[type->elems].size = thissize;
1435           type->elems++;
1436         }
1437     }
1438
1439   /* Empty/missing type is not a successful parse.  */
1440   if (type->elems == 0)
1441     return FAIL;
1442
1443   *str = ptr;
1444
1445   return SUCCESS;
1446 }
1447
1448 /* Errors may be set multiple times during parsing or bit encoding
1449    (particularly in the Neon bits), but usually the earliest error which is set
1450    will be the most meaningful. Avoid overwriting it with later (cascading)
1451    errors by calling this function.  */
1452
1453 static void
1454 first_error (const char *err)
1455 {
1456   if (!inst.error)
1457     inst.error = err;
1458 }
1459
1460 /* Parse a single type, e.g. ".s32", leading period included.  */
1461 static int
1462 parse_neon_operand_type (struct neon_type_el *vectype, char **ccp)
1463 {
1464   char *str = *ccp;
1465   struct neon_type optype;
1466
1467   if (*str == '.')
1468     {
1469       if (parse_neon_type (&optype, &str) == SUCCESS)
1470         {
1471           if (optype.elems == 1)
1472             *vectype = optype.el[0];
1473           else
1474             {
1475               first_error (_("only one type should be specified for operand"));
1476               return FAIL;
1477             }
1478         }
1479       else
1480         {
1481           first_error (_("vector type expected"));
1482           return FAIL;
1483         }
1484     }
1485   else
1486     return FAIL;
1487
1488   *ccp = str;
1489
1490   return SUCCESS;
1491 }
1492
1493 /* Special meanings for indices (which have a range of 0-7), which will fit into
1494    a 4-bit integer.  */
1495
1496 #define NEON_ALL_LANES          15
1497 #define NEON_INTERLEAVE_LANES   14
1498
1499 /* Parse either a register or a scalar, with an optional type. Return the
1500    register number, and optionally fill in the actual type of the register
1501    when multiple alternatives were given (NEON_TYPE_NDQ) in *RTYPE, and
1502    type/index information in *TYPEINFO.  */
1503
1504 static int
1505 parse_typed_reg_or_scalar (char **ccp, enum arm_reg_type type,
1506                            enum arm_reg_type *rtype,
1507                            struct neon_typed_alias *typeinfo)
1508 {
1509   char *str = *ccp;
1510   struct reg_entry *reg = arm_reg_parse_multi (&str);
1511   struct neon_typed_alias atype;
1512   struct neon_type_el parsetype;
1513
1514   atype.defined = 0;
1515   atype.index = -1;
1516   atype.eltype.type = NT_invtype;
1517   atype.eltype.size = -1;
1518
1519   /* Try alternate syntax for some types of register. Note these are mutually
1520      exclusive with the Neon syntax extensions.  */
1521   if (reg == NULL)
1522     {
1523       int altreg = arm_reg_alt_syntax (&str, *ccp, reg, type);
1524       if (altreg != FAIL)
1525         *ccp = str;
1526       if (typeinfo)
1527         *typeinfo = atype;
1528       return altreg;
1529     }
1530
1531   /* Undo polymorphism when a set of register types may be accepted.  */
1532   if ((type == REG_TYPE_NDQ
1533        && (reg->type == REG_TYPE_NQ || reg->type == REG_TYPE_VFD))
1534       || (type == REG_TYPE_VFSD
1535           && (reg->type == REG_TYPE_VFS || reg->type == REG_TYPE_VFD))
1536       || (type == REG_TYPE_NSDQ
1537           && (reg->type == REG_TYPE_VFS || reg->type == REG_TYPE_VFD
1538               || reg->type == REG_TYPE_NQ))
1539       || (type == REG_TYPE_NSD
1540           && (reg->type == REG_TYPE_VFS || reg->type == REG_TYPE_VFD))
1541       || (type == REG_TYPE_MMXWC
1542           && (reg->type == REG_TYPE_MMXWCG)))
1543     type = (enum arm_reg_type) reg->type;
1544
1545   if (type != reg->type)
1546     return FAIL;
1547
1548   if (reg->neon)
1549     atype = *reg->neon;
1550
1551   if (parse_neon_operand_type (&parsetype, &str) == SUCCESS)
1552     {
1553       if ((atype.defined & NTA_HASTYPE) != 0)
1554         {
1555           first_error (_("can't redefine type for operand"));
1556           return FAIL;
1557         }
1558       atype.defined |= NTA_HASTYPE;
1559       atype.eltype = parsetype;
1560     }
1561
1562   if (skip_past_char (&str, '[') == SUCCESS)
1563     {
1564       if (type != REG_TYPE_VFD
1565           && !(type == REG_TYPE_VFS
1566                && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8_2)))
1567         {
1568           first_error (_("only D registers may be indexed"));
1569           return FAIL;
1570         }
1571
1572       if ((atype.defined & NTA_HASINDEX) != 0)
1573         {
1574           first_error (_("can't change index for operand"));
1575           return FAIL;
1576         }
1577
1578       atype.defined |= NTA_HASINDEX;
1579
1580       if (skip_past_char (&str, ']') == SUCCESS)
1581         atype.index = NEON_ALL_LANES;
1582       else
1583         {
1584           expressionS exp;
1585
1586           my_get_expression (&exp, &str, GE_NO_PREFIX);
1587
1588           if (exp.X_op != O_constant)
1589             {
1590               first_error (_("constant expression required"));
1591               return FAIL;
1592             }
1593
1594           if (skip_past_char (&str, ']') == FAIL)
1595             return FAIL;
1596
1597           atype.index = exp.X_add_number;
1598         }
1599     }
1600
1601   if (typeinfo)
1602     *typeinfo = atype;
1603
1604   if (rtype)
1605     *rtype = type;
1606
1607   *ccp = str;
1608
1609   return reg->number;
1610 }
1611
1612 /* Like arm_reg_parse, but allow allow the following extra features:
1613     - If RTYPE is non-zero, return the (possibly restricted) type of the
1614       register (e.g. Neon double or quad reg when either has been requested).
1615     - If this is a Neon vector type with additional type information, fill
1616       in the struct pointed to by VECTYPE (if non-NULL).
1617    This function will fault on encountering a scalar.  */
1618
1619 static int
1620 arm_typed_reg_parse (char **ccp, enum arm_reg_type type,
1621                      enum arm_reg_type *rtype, struct neon_type_el *vectype)
1622 {
1623   struct neon_typed_alias atype;
1624   char *str = *ccp;
1625   int reg = parse_typed_reg_or_scalar (&str, type, rtype, &atype);
1626
1627   if (reg == FAIL)
1628     return FAIL;
1629
1630   /* Do not allow regname(... to parse as a register.  */
1631   if (*str == '(')
1632     return FAIL;
1633
1634   /* Do not allow a scalar (reg+index) to parse as a register.  */
1635   if ((atype.defined & NTA_HASINDEX) != 0)
1636     {
1637       first_error (_("register operand expected, but got scalar"));
1638       return FAIL;
1639     }
1640
1641   if (vectype)
1642     *vectype = atype.eltype;
1643
1644   *ccp = str;
1645
1646   return reg;
1647 }
1648
1649 #define NEON_SCALAR_REG(X)      ((X) >> 4)
1650 #define NEON_SCALAR_INDEX(X)    ((X) & 15)
1651
1652 /* Parse a Neon scalar. Most of the time when we're parsing a scalar, we don't
1653    have enough information to be able to do a good job bounds-checking. So, we
1654    just do easy checks here, and do further checks later.  */
1655
1656 static int
1657 parse_scalar (char **ccp, int elsize, struct neon_type_el *type)
1658 {
1659   int reg;
1660   char *str = *ccp;
1661   struct neon_typed_alias atype;
1662   enum arm_reg_type reg_type = REG_TYPE_VFD;
1663
1664   if (elsize == 4)
1665     reg_type = REG_TYPE_VFS;
1666
1667   reg = parse_typed_reg_or_scalar (&str, reg_type, NULL, &atype);
1668
1669   if (reg == FAIL || (atype.defined & NTA_HASINDEX) == 0)
1670     return FAIL;
1671
1672   if (atype.index == NEON_ALL_LANES)
1673     {
1674       first_error (_("scalar must have an index"));
1675       return FAIL;
1676     }
1677   else if (atype.index >= 64 / elsize)
1678     {
1679       first_error (_("scalar index out of range"));
1680       return FAIL;
1681     }
1682
1683   if (type)
1684     *type = atype.eltype;
1685
1686   *ccp = str;
1687
1688   return reg * 16 + atype.index;
1689 }
1690
1691 /* Parse an ARM register list.  Returns the bitmask, or FAIL.  */
1692
1693 static long
1694 parse_reg_list (char ** strp)
1695 {
1696   char * str = * strp;
1697   long   range = 0;
1698   int    another_range;
1699
1700   /* We come back here if we get ranges concatenated by '+' or '|'.  */
1701   do
1702     {
1703       skip_whitespace (str);
1704
1705       another_range = 0;
1706
1707       if (*str == '{')
1708         {
1709           int in_range = 0;
1710           int cur_reg = -1;
1711
1712           str++;
1713           do
1714             {
1715               int reg;
1716
1717               if ((reg = arm_reg_parse (&str, REG_TYPE_RN)) == FAIL)
1718                 {
1719                   first_error (_(reg_expected_msgs[REG_TYPE_RN]));
1720                   return FAIL;
1721                 }
1722
1723               if (in_range)
1724                 {
1725                   int i;
1726
1727                   if (reg <= cur_reg)
1728                     {
1729                       first_error (_("bad range in register list"));
1730                       return FAIL;
1731                     }
1732
1733                   for (i = cur_reg + 1; i < reg; i++)
1734                     {
1735                       if (range & (1 << i))
1736                         as_tsktsk
1737                           (_("Warning: duplicated register (r%d) in register list"),
1738                            i);
1739                       else
1740                         range |= 1 << i;
1741                     }
1742                   in_range = 0;
1743                 }
1744
1745               if (range & (1 << reg))
1746                 as_tsktsk (_("Warning: duplicated register (r%d) in register list"),
1747                            reg);
1748               else if (reg <= cur_reg)
1749                 as_tsktsk (_("Warning: register range not in ascending order"));
1750
1751               range |= 1 << reg;
1752               cur_reg = reg;
1753             }
1754           while (skip_past_comma (&str) != FAIL
1755                  || (in_range = 1, *str++ == '-'));
1756           str--;
1757
1758           if (skip_past_char (&str, '}') == FAIL)
1759             {
1760               first_error (_("missing `}'"));
1761               return FAIL;
1762             }
1763         }
1764       else
1765         {
1766           expressionS exp;
1767
1768           if (my_get_expression (&exp, &str, GE_NO_PREFIX))
1769             return FAIL;
1770
1771           if (exp.X_op == O_constant)
1772             {
1773               if (exp.X_add_number
1774                   != (exp.X_add_number & 0x0000ffff))
1775                 {
1776                   inst.error = _("invalid register mask");
1777                   return FAIL;
1778                 }
1779
1780               if ((range & exp.X_add_number) != 0)
1781                 {
1782                   int regno = range & exp.X_add_number;
1783
1784                   regno &= -regno;
1785                   regno = (1 << regno) - 1;
1786                   as_tsktsk
1787                     (_("Warning: duplicated register (r%d) in register list"),
1788                      regno);
1789                 }
1790
1791               range |= exp.X_add_number;
1792             }
1793           else
1794             {
1795               if (inst.relocs[0].type != 0)
1796                 {
1797                   inst.error = _("expression too complex");
1798                   return FAIL;
1799                 }
1800
1801               memcpy (&inst.relocs[0].exp, &exp, sizeof (expressionS));
1802               inst.relocs[0].type = BFD_RELOC_ARM_MULTI;
1803               inst.relocs[0].pc_rel = 0;
1804             }
1805         }
1806
1807       if (*str == '|' || *str == '+')
1808         {
1809           str++;
1810           another_range = 1;
1811         }
1812     }
1813   while (another_range);
1814
1815   *strp = str;
1816   return range;
1817 }
1818
1819 /* Types of registers in a list.  */
1820
1821 enum reg_list_els
1822 {
1823   REGLIST_VFP_S,
1824   REGLIST_VFP_D,
1825   REGLIST_NEON_D
1826 };
1827
1828 /* Parse a VFP register list.  If the string is invalid return FAIL.
1829    Otherwise return the number of registers, and set PBASE to the first
1830    register.  Parses registers of type ETYPE.
1831    If REGLIST_NEON_D is used, several syntax enhancements are enabled:
1832      - Q registers can be used to specify pairs of D registers
1833      - { } can be omitted from around a singleton register list
1834          FIXME: This is not implemented, as it would require backtracking in
1835          some cases, e.g.:
1836            vtbl.8 d3,d4,d5
1837          This could be done (the meaning isn't really ambiguous), but doesn't
1838          fit in well with the current parsing framework.
1839      - 32 D registers may be used (also true for VFPv3).
1840    FIXME: Types are ignored in these register lists, which is probably a
1841    bug.  */
1842
1843 static int
1844 parse_vfp_reg_list (char **ccp, unsigned int *pbase, enum reg_list_els etype)
1845 {
1846   char *str = *ccp;
1847   int base_reg;
1848   int new_base;
1849   enum arm_reg_type regtype = (enum arm_reg_type) 0;
1850   int max_regs = 0;
1851   int count = 0;
1852   int warned = 0;
1853   unsigned long mask = 0;
1854   int i;
1855
1856   if (skip_past_char (&str, '{') == FAIL)
1857     {
1858       inst.error = _("expecting {");
1859       return FAIL;
1860     }
1861
1862   switch (etype)
1863     {
1864     case REGLIST_VFP_S:
1865       regtype = REG_TYPE_VFS;
1866       max_regs = 32;
1867       break;
1868
1869     case REGLIST_VFP_D:
1870       regtype = REG_TYPE_VFD;
1871       break;
1872
1873     case REGLIST_NEON_D:
1874       regtype = REG_TYPE_NDQ;
1875       break;
1876     }
1877
1878   if (etype != REGLIST_VFP_S)
1879     {
1880       /* VFPv3 allows 32 D registers, except for the VFPv3-D16 variant.  */
1881       if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_d32))
1882         {
1883           max_regs = 32;
1884           if (thumb_mode)
1885             ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
1886                                     fpu_vfp_ext_d32);
1887           else
1888             ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used,
1889                                     fpu_vfp_ext_d32);
1890         }
1891       else
1892         max_regs = 16;
1893     }
1894
1895   base_reg = max_regs;
1896
1897   do
1898     {
1899       int setmask = 1, addregs = 1;
1900
1901       new_base = arm_typed_reg_parse (&str, regtype, &regtype, NULL);
1902
1903       if (new_base == FAIL)
1904         {
1905           first_error (_(reg_expected_msgs[regtype]));
1906           return FAIL;
1907         }
1908
1909       if (new_base >= max_regs)
1910         {
1911           first_error (_("register out of range in list"));
1912           return FAIL;
1913         }
1914
1915       /* Note: a value of 2 * n is returned for the register Q<n>.  */
1916       if (regtype == REG_TYPE_NQ)
1917         {
1918           setmask = 3;
1919           addregs = 2;
1920         }
1921
1922       if (new_base < base_reg)
1923         base_reg = new_base;
1924
1925       if (mask & (setmask << new_base))
1926         {
1927           first_error (_("invalid register list"));
1928           return FAIL;
1929         }
1930
1931       if ((mask >> new_base) != 0 && ! warned)
1932         {
1933           as_tsktsk (_("register list not in ascending order"));
1934           warned = 1;
1935         }
1936
1937       mask |= setmask << new_base;
1938       count += addregs;
1939
1940       if (*str == '-') /* We have the start of a range expression */
1941         {
1942           int high_range;
1943
1944           str++;
1945
1946           if ((high_range = arm_typed_reg_parse (&str, regtype, NULL, NULL))
1947               == FAIL)
1948             {
1949               inst.error = gettext (reg_expected_msgs[regtype]);
1950               return FAIL;
1951             }
1952
1953           if (high_range >= max_regs)
1954             {
1955               first_error (_("register out of range in list"));
1956               return FAIL;
1957             }
1958
1959           if (regtype == REG_TYPE_NQ)
1960             high_range = high_range + 1;
1961
1962           if (high_range <= new_base)
1963             {
1964               inst.error = _("register range not in ascending order");
1965               return FAIL;
1966             }
1967
1968           for (new_base += addregs; new_base <= high_range; new_base += addregs)
1969             {
1970               if (mask & (setmask << new_base))
1971                 {
1972                   inst.error = _("invalid register list");
1973                   return FAIL;
1974                 }
1975
1976               mask |= setmask << new_base;
1977               count += addregs;
1978             }
1979         }
1980     }
1981   while (skip_past_comma (&str) != FAIL);
1982
1983   str++;
1984
1985   /* Sanity check -- should have raised a parse error above.  */
1986   if (count == 0 || count > max_regs)
1987     abort ();
1988
1989   *pbase = base_reg;
1990
1991   /* Final test -- the registers must be consecutive.  */
1992   mask >>= base_reg;
1993   for (i = 0; i < count; i++)
1994     {
1995       if ((mask & (1u << i)) == 0)
1996         {
1997           inst.error = _("non-contiguous register range");
1998           return FAIL;
1999         }
2000     }
2001
2002   *ccp = str;
2003
2004   return count;
2005 }
2006
2007 /* True if two alias types are the same.  */
2008
2009 static bfd_boolean
2010 neon_alias_types_same (struct neon_typed_alias *a, struct neon_typed_alias *b)
2011 {
2012   if (!a && !b)
2013     return TRUE;
2014
2015   if (!a || !b)
2016     return FALSE;
2017
2018   if (a->defined != b->defined)
2019     return FALSE;
2020
2021   if ((a->defined & NTA_HASTYPE) != 0
2022       && (a->eltype.type != b->eltype.type
2023           || a->eltype.size != b->eltype.size))
2024     return FALSE;
2025
2026   if ((a->defined & NTA_HASINDEX) != 0
2027       && (a->index != b->index))
2028     return FALSE;
2029
2030   return TRUE;
2031 }
2032
2033 /* Parse element/structure lists for Neon VLD<n> and VST<n> instructions.
2034    The base register is put in *PBASE.
2035    The lane (or one of the NEON_*_LANES constants) is placed in bits [3:0] of
2036    the return value.
2037    The register stride (minus one) is put in bit 4 of the return value.
2038    Bits [6:5] encode the list length (minus one).
2039    The type of the list elements is put in *ELTYPE, if non-NULL.  */
2040
2041 #define NEON_LANE(X)            ((X) & 0xf)
2042 #define NEON_REG_STRIDE(X)      ((((X) >> 4) & 1) + 1)
2043 #define NEON_REGLIST_LENGTH(X)  ((((X) >> 5) & 3) + 1)
2044
2045 static int
2046 parse_neon_el_struct_list (char **str, unsigned *pbase,
2047                            struct neon_type_el *eltype)
2048 {
2049   char *ptr = *str;
2050   int base_reg = -1;
2051   int reg_incr = -1;
2052   int count = 0;
2053   int lane = -1;
2054   int leading_brace = 0;
2055   enum arm_reg_type rtype = REG_TYPE_NDQ;
2056   const char *const incr_error = _("register stride must be 1 or 2");
2057   const char *const type_error = _("mismatched element/structure types in list");
2058   struct neon_typed_alias firsttype;
2059   firsttype.defined = 0;
2060   firsttype.eltype.type = NT_invtype;
2061   firsttype.eltype.size = -1;
2062   firsttype.index = -1;
2063
2064   if (skip_past_char (&ptr, '{') == SUCCESS)
2065     leading_brace = 1;
2066
2067   do
2068     {
2069       struct neon_typed_alias atype;
2070       int getreg = parse_typed_reg_or_scalar (&ptr, rtype, &rtype, &atype);
2071
2072       if (getreg == FAIL)
2073         {
2074           first_error (_(reg_expected_msgs[rtype]));
2075           return FAIL;
2076         }
2077
2078       if (base_reg == -1)
2079         {
2080           base_reg = getreg;
2081           if (rtype == REG_TYPE_NQ)
2082             {
2083               reg_incr = 1;
2084             }
2085           firsttype = atype;
2086         }
2087       else if (reg_incr == -1)
2088         {
2089           reg_incr = getreg - base_reg;
2090           if (reg_incr < 1 || reg_incr > 2)
2091             {
2092               first_error (_(incr_error));
2093               return FAIL;
2094             }
2095         }
2096       else if (getreg != base_reg + reg_incr * count)
2097         {
2098           first_error (_(incr_error));
2099           return FAIL;
2100         }
2101
2102       if (! neon_alias_types_same (&atype, &firsttype))
2103         {
2104           first_error (_(type_error));
2105           return FAIL;
2106         }
2107
2108       /* Handle Dn-Dm or Qn-Qm syntax. Can only be used with non-indexed list
2109          modes.  */
2110       if (ptr[0] == '-')
2111         {
2112           struct neon_typed_alias htype;
2113           int hireg, dregs = (rtype == REG_TYPE_NQ) ? 2 : 1;
2114           if (lane == -1)
2115             lane = NEON_INTERLEAVE_LANES;
2116           else if (lane != NEON_INTERLEAVE_LANES)
2117             {
2118               first_error (_(type_error));
2119               return FAIL;
2120             }
2121           if (reg_incr == -1)
2122             reg_incr = 1;
2123           else if (reg_incr != 1)
2124             {
2125               first_error (_("don't use Rn-Rm syntax with non-unit stride"));
2126               return FAIL;
2127             }
2128           ptr++;
2129           hireg = parse_typed_reg_or_scalar (&ptr, rtype, NULL, &htype);
2130           if (hireg == FAIL)
2131             {
2132               first_error (_(reg_expected_msgs[rtype]));
2133               return FAIL;
2134             }
2135           if (! neon_alias_types_same (&htype, &firsttype))
2136             {
2137               first_error (_(type_error));
2138               return FAIL;
2139             }
2140           count += hireg + dregs - getreg;
2141           continue;
2142         }
2143
2144       /* If we're using Q registers, we can't use [] or [n] syntax.  */
2145       if (rtype == REG_TYPE_NQ)
2146         {
2147           count += 2;
2148           continue;
2149         }
2150
2151       if ((atype.defined & NTA_HASINDEX) != 0)
2152         {
2153           if (lane == -1)
2154             lane = atype.index;
2155           else if (lane != atype.index)
2156             {
2157               first_error (_(type_error));
2158               return FAIL;
2159             }
2160         }
2161       else if (lane == -1)
2162         lane = NEON_INTERLEAVE_LANES;
2163       else if (lane != NEON_INTERLEAVE_LANES)
2164         {
2165           first_error (_(type_error));
2166           return FAIL;
2167         }
2168       count++;
2169     }
2170   while ((count != 1 || leading_brace) && skip_past_comma (&ptr) != FAIL);
2171
2172   /* No lane set by [x]. We must be interleaving structures.  */
2173   if (lane == -1)
2174     lane = NEON_INTERLEAVE_LANES;
2175
2176   /* Sanity check.  */
2177   if (lane == -1 || base_reg == -1 || count < 1 || count > 4
2178       || (count > 1 && reg_incr == -1))
2179     {
2180       first_error (_("error parsing element/structure list"));
2181       return FAIL;
2182     }
2183
2184   if ((count > 1 || leading_brace) && skip_past_char (&ptr, '}') == FAIL)
2185     {
2186       first_error (_("expected }"));
2187       return FAIL;
2188     }
2189
2190   if (reg_incr == -1)
2191     reg_incr = 1;
2192
2193   if (eltype)
2194     *eltype = firsttype.eltype;
2195
2196   *pbase = base_reg;
2197   *str = ptr;
2198
2199   return lane | ((reg_incr - 1) << 4) | ((count - 1) << 5);
2200 }
2201
2202 /* Parse an explicit relocation suffix on an expression.  This is
2203    either nothing, or a word in parentheses.  Note that if !OBJ_ELF,
2204    arm_reloc_hsh contains no entries, so this function can only
2205    succeed if there is no () after the word.  Returns -1 on error,
2206    BFD_RELOC_UNUSED if there wasn't any suffix.  */
2207
2208 static int
2209 parse_reloc (char **str)
2210 {
2211   struct reloc_entry *r;
2212   char *p, *q;
2213
2214   if (**str != '(')
2215     return BFD_RELOC_UNUSED;
2216
2217   p = *str + 1;
2218   q = p;
2219
2220   while (*q && *q != ')' && *q != ',')
2221     q++;
2222   if (*q != ')')
2223     return -1;
2224
2225   if ((r = (struct reloc_entry *)
2226        hash_find_n (arm_reloc_hsh, p, q - p)) == NULL)
2227     return -1;
2228
2229   *str = q + 1;
2230   return r->reloc;
2231 }
2232
2233 /* Directives: register aliases.  */
2234
2235 static struct reg_entry *
2236 insert_reg_alias (char *str, unsigned number, int type)
2237 {
2238   struct reg_entry *new_reg;
2239   const char *name;
2240
2241   if ((new_reg = (struct reg_entry *) hash_find (arm_reg_hsh, str)) != 0)
2242     {
2243       if (new_reg->builtin)
2244         as_warn (_("ignoring attempt to redefine built-in register '%s'"), str);
2245
2246       /* Only warn about a redefinition if it's not defined as the
2247          same register.  */
2248       else if (new_reg->number != number || new_reg->type != type)
2249         as_warn (_("ignoring redefinition of register alias '%s'"), str);
2250
2251       return NULL;
2252     }
2253
2254   name = xstrdup (str);
2255   new_reg = XNEW (struct reg_entry);
2256
2257   new_reg->name = name;
2258   new_reg->number = number;
2259   new_reg->type = type;
2260   new_reg->builtin = FALSE;
2261   new_reg->neon = NULL;
2262
2263   if (hash_insert (arm_reg_hsh, name, (void *) new_reg))
2264     abort ();
2265
2266   return new_reg;
2267 }
2268
2269 static void
2270 insert_neon_reg_alias (char *str, int number, int type,
2271                        struct neon_typed_alias *atype)
2272 {
2273   struct reg_entry *reg = insert_reg_alias (str, number, type);
2274
2275   if (!reg)
2276     {
2277       first_error (_("attempt to redefine typed alias"));
2278       return;
2279     }
2280
2281   if (atype)
2282     {
2283       reg->neon = XNEW (struct neon_typed_alias);
2284       *reg->neon = *atype;
2285     }
2286 }
2287
2288 /* Look for the .req directive.  This is of the form:
2289
2290         new_register_name .req existing_register_name
2291
2292    If we find one, or if it looks sufficiently like one that we want to
2293    handle any error here, return TRUE.  Otherwise return FALSE.  */
2294
2295 static bfd_boolean
2296 create_register_alias (char * newname, char *p)
2297 {
2298   struct reg_entry *old;
2299   char *oldname, *nbuf;
2300   size_t nlen;
2301
2302   /* The input scrubber ensures that whitespace after the mnemonic is
2303      collapsed to single spaces.  */
2304   oldname = p;
2305   if (strncmp (oldname, " .req ", 6) != 0)
2306     return FALSE;
2307
2308   oldname += 6;
2309   if (*oldname == '\0')
2310     return FALSE;
2311
2312   old = (struct reg_entry *) hash_find (arm_reg_hsh, oldname);
2313   if (!old)
2314     {
2315       as_warn (_("unknown register '%s' -- .req ignored"), oldname);
2316       return TRUE;
2317     }
2318
2319   /* If TC_CASE_SENSITIVE is defined, then newname already points to
2320      the desired alias name, and p points to its end.  If not, then
2321      the desired alias name is in the global original_case_string.  */
2322 #ifdef TC_CASE_SENSITIVE
2323   nlen = p - newname;
2324 #else
2325   newname = original_case_string;
2326   nlen = strlen (newname);
2327 #endif
2328
2329   nbuf = xmemdup0 (newname, nlen);
2330
2331   /* Create aliases under the new name as stated; an all-lowercase
2332      version of the new name; and an all-uppercase version of the new
2333      name.  */
2334   if (insert_reg_alias (nbuf, old->number, old->type) != NULL)
2335     {
2336       for (p = nbuf; *p; p++)
2337         *p = TOUPPER (*p);
2338
2339       if (strncmp (nbuf, newname, nlen))
2340         {
2341           /* If this attempt to create an additional alias fails, do not bother
2342              trying to create the all-lower case alias.  We will fail and issue
2343              a second, duplicate error message.  This situation arises when the
2344              programmer does something like:
2345                foo .req r0
2346                Foo .req r1
2347              The second .req creates the "Foo" alias but then fails to create
2348              the artificial FOO alias because it has already been created by the
2349              first .req.  */
2350           if (insert_reg_alias (nbuf, old->number, old->type) == NULL)
2351             {
2352               free (nbuf);
2353               return TRUE;
2354             }
2355         }
2356
2357       for (p = nbuf; *p; p++)
2358         *p = TOLOWER (*p);
2359
2360       if (strncmp (nbuf, newname, nlen))
2361         insert_reg_alias (nbuf, old->number, old->type);
2362     }
2363
2364   free (nbuf);
2365   return TRUE;
2366 }
2367
2368 /* Create a Neon typed/indexed register alias using directives, e.g.:
2369      X .dn d5.s32[1]
2370      Y .qn 6.s16
2371      Z .dn d7
2372      T .dn Z[0]
2373    These typed registers can be used instead of the types specified after the
2374    Neon mnemonic, so long as all operands given have types. Types can also be
2375    specified directly, e.g.:
2376      vadd d0.s32, d1.s32, d2.s32  */
2377
2378 static bfd_boolean
2379 create_neon_reg_alias (char *newname, char *p)
2380 {
2381   enum arm_reg_type basetype;
2382   struct reg_entry *basereg;
2383   struct reg_entry mybasereg;
2384   struct neon_type ntype;
2385   struct neon_typed_alias typeinfo;
2386   char *namebuf, *nameend ATTRIBUTE_UNUSED;
2387   int namelen;
2388
2389   typeinfo.defined = 0;
2390   typeinfo.eltype.type = NT_invtype;
2391   typeinfo.eltype.size = -1;
2392   typeinfo.index = -1;
2393
2394   nameend = p;
2395
2396   if (strncmp (p, " .dn ", 5) == 0)
2397     basetype = REG_TYPE_VFD;
2398   else if (strncmp (p, " .qn ", 5) == 0)
2399     basetype = REG_TYPE_NQ;
2400   else
2401     return FALSE;
2402
2403   p += 5;
2404
2405   if (*p == '\0')
2406     return FALSE;
2407
2408   basereg = arm_reg_parse_multi (&p);
2409
2410   if (basereg && basereg->type != basetype)
2411     {
2412       as_bad (_("bad type for register"));
2413       return FALSE;
2414     }
2415
2416   if (basereg == NULL)
2417     {
2418       expressionS exp;
2419       /* Try parsing as an integer.  */
2420       my_get_expression (&exp, &p, GE_NO_PREFIX);
2421       if (exp.X_op != O_constant)
2422         {
2423           as_bad (_("expression must be constant"));
2424           return FALSE;
2425         }
2426       basereg = &mybasereg;
2427       basereg->number = (basetype == REG_TYPE_NQ) ? exp.X_add_number * 2
2428                                                   : exp.X_add_number;
2429       basereg->neon = 0;
2430     }
2431
2432   if (basereg->neon)
2433     typeinfo = *basereg->neon;
2434
2435   if (parse_neon_type (&ntype, &p) == SUCCESS)
2436     {
2437       /* We got a type.  */
2438       if (typeinfo.defined & NTA_HASTYPE)
2439         {
2440           as_bad (_("can't redefine the type of a register alias"));
2441           return FALSE;
2442         }
2443
2444       typeinfo.defined |= NTA_HASTYPE;
2445       if (ntype.elems != 1)
2446         {
2447           as_bad (_("you must specify a single type only"));
2448           return FALSE;
2449         }
2450       typeinfo.eltype = ntype.el[0];
2451     }
2452
2453   if (skip_past_char (&p, '[') == SUCCESS)
2454     {
2455       expressionS exp;
2456       /* We got a scalar index.  */
2457
2458       if (typeinfo.defined & NTA_HASINDEX)
2459         {
2460           as_bad (_("can't redefine the index of a scalar alias"));
2461           return FALSE;
2462         }
2463
2464       my_get_expression (&exp, &p, GE_NO_PREFIX);
2465
2466       if (exp.X_op != O_constant)
2467         {
2468           as_bad (_("scalar index must be constant"));
2469           return FALSE;
2470         }
2471
2472       typeinfo.defined |= NTA_HASINDEX;
2473       typeinfo.index = exp.X_add_number;
2474
2475       if (skip_past_char (&p, ']') == FAIL)
2476         {
2477           as_bad (_("expecting ]"));
2478           return FALSE;
2479         }
2480     }
2481
2482   /* If TC_CASE_SENSITIVE is defined, then newname already points to
2483      the desired alias name, and p points to its end.  If not, then
2484      the desired alias name is in the global original_case_string.  */
2485 #ifdef TC_CASE_SENSITIVE
2486   namelen = nameend - newname;
2487 #else
2488   newname = original_case_string;
2489   namelen = strlen (newname);
2490 #endif
2491
2492   namebuf = xmemdup0 (newname, namelen);
2493
2494   insert_neon_reg_alias (namebuf, basereg->number, basetype,
2495                          typeinfo.defined != 0 ? &typeinfo : NULL);
2496
2497   /* Insert name in all uppercase.  */
2498   for (p = namebuf; *p; p++)
2499     *p = TOUPPER (*p);
2500
2501   if (strncmp (namebuf, newname, namelen))
2502     insert_neon_reg_alias (namebuf, basereg->number, basetype,
2503                            typeinfo.defined != 0 ? &typeinfo : NULL);
2504
2505   /* Insert name in all lowercase.  */
2506   for (p = namebuf; *p; p++)
2507     *p = TOLOWER (*p);
2508
2509   if (strncmp (namebuf, newname, namelen))
2510     insert_neon_reg_alias (namebuf, basereg->number, basetype,
2511                            typeinfo.defined != 0 ? &typeinfo : NULL);
2512
2513   free (namebuf);
2514   return TRUE;
2515 }
2516
2517 /* Should never be called, as .req goes between the alias and the
2518    register name, not at the beginning of the line.  */
2519
2520 static void
2521 s_req (int a ATTRIBUTE_UNUSED)
2522 {
2523   as_bad (_("invalid syntax for .req directive"));
2524 }
2525
2526 static void
2527 s_dn (int a ATTRIBUTE_UNUSED)
2528 {
2529   as_bad (_("invalid syntax for .dn directive"));
2530 }
2531
2532 static void
2533 s_qn (int a ATTRIBUTE_UNUSED)
2534 {
2535   as_bad (_("invalid syntax for .qn directive"));
2536 }
2537
2538 /* The .unreq directive deletes an alias which was previously defined
2539    by .req.  For example:
2540
2541        my_alias .req r11
2542        .unreq my_alias    */
2543
2544 static void
2545 s_unreq (int a ATTRIBUTE_UNUSED)
2546 {
2547   char * name;
2548   char saved_char;
2549
2550   name = input_line_pointer;
2551
2552   while (*input_line_pointer != 0
2553          && *input_line_pointer != ' '
2554          && *input_line_pointer != '\n')
2555     ++input_line_pointer;
2556
2557   saved_char = *input_line_pointer;
2558   *input_line_pointer = 0;
2559
2560   if (!*name)
2561     as_bad (_("invalid syntax for .unreq directive"));
2562   else
2563     {
2564       struct reg_entry *reg = (struct reg_entry *) hash_find (arm_reg_hsh,
2565                                                               name);
2566
2567       if (!reg)
2568         as_bad (_("unknown register alias '%s'"), name);
2569       else if (reg->builtin)
2570         as_warn (_("ignoring attempt to use .unreq on fixed register name: '%s'"),
2571                  name);
2572       else
2573         {
2574           char * p;
2575           char * nbuf;
2576
2577           hash_delete (arm_reg_hsh, name, FALSE);
2578           free ((char *) reg->name);
2579           if (reg->neon)
2580             free (reg->neon);
2581           free (reg);
2582
2583           /* Also locate the all upper case and all lower case versions.
2584              Do not complain if we cannot find one or the other as it
2585              was probably deleted above.  */
2586
2587           nbuf = strdup (name);
2588           for (p = nbuf; *p; p++)
2589             *p = TOUPPER (*p);
2590           reg = (struct reg_entry *) hash_find (arm_reg_hsh, nbuf);
2591           if (reg)
2592             {
2593               hash_delete (arm_reg_hsh, nbuf, FALSE);
2594               free ((char *) reg->name);
2595               if (reg->neon)
2596                 free (reg->neon);
2597               free (reg);
2598             }
2599
2600           for (p = nbuf; *p; p++)
2601             *p = TOLOWER (*p);
2602           reg = (struct reg_entry *) hash_find (arm_reg_hsh, nbuf);
2603           if (reg)
2604             {
2605               hash_delete (arm_reg_hsh, nbuf, FALSE);
2606               free ((char *) reg->name);
2607               if (reg->neon)
2608                 free (reg->neon);
2609               free (reg);
2610             }
2611
2612           free (nbuf);
2613         }
2614     }
2615
2616   *input_line_pointer = saved_char;
2617   demand_empty_rest_of_line ();
2618 }
2619
2620 /* Directives: Instruction set selection.  */
2621
2622 #ifdef OBJ_ELF
2623 /* This code is to handle mapping symbols as defined in the ARM ELF spec.
2624    (See "Mapping symbols", section 4.5.5, ARM AAELF version 1.0).
2625    Note that previously, $a and $t has type STT_FUNC (BSF_OBJECT flag),
2626    and $d has type STT_OBJECT (BSF_OBJECT flag). Now all three are untyped.  */
2627
2628 /* Create a new mapping symbol for the transition to STATE.  */
2629
2630 static void
2631 make_mapping_symbol (enum mstate state, valueT value, fragS *frag)
2632 {
2633   symbolS * symbolP;
2634   const char * symname;
2635   int type;
2636
2637   switch (state)
2638     {
2639     case MAP_DATA:
2640       symname = "$d";
2641       type = BSF_NO_FLAGS;
2642       break;
2643     case MAP_ARM:
2644       symname = "$a";
2645       type = BSF_NO_FLAGS;
2646       break;
2647     case MAP_THUMB:
2648       symname = "$t";
2649       type = BSF_NO_FLAGS;
2650       break;
2651     default:
2652       abort ();
2653     }
2654
2655   symbolP = symbol_new (symname, now_seg, value, frag);
2656   symbol_get_bfdsym (symbolP)->flags |= type | BSF_LOCAL;
2657
2658   switch (state)
2659     {
2660     case MAP_ARM:
2661       THUMB_SET_FUNC (symbolP, 0);
2662       ARM_SET_THUMB (symbolP, 0);
2663       ARM_SET_INTERWORK (symbolP, support_interwork);
2664       break;
2665
2666     case MAP_THUMB:
2667       THUMB_SET_FUNC (symbolP, 1);
2668       ARM_SET_THUMB (symbolP, 1);
2669       ARM_SET_INTERWORK (symbolP, support_interwork);
2670       break;
2671
2672     case MAP_DATA:
2673     default:
2674       break;
2675     }
2676
2677   /* Save the mapping symbols for future reference.  Also check that
2678      we do not place two mapping symbols at the same offset within a
2679      frag.  We'll handle overlap between frags in
2680      check_mapping_symbols.
2681
2682      If .fill or other data filling directive generates zero sized data,
2683      the mapping symbol for the following code will have the same value
2684      as the one generated for the data filling directive.  In this case,
2685      we replace the old symbol with the new one at the same address.  */
2686   if (value == 0)
2687     {
2688       if (frag->tc_frag_data.first_map != NULL)
2689         {
2690           know (S_GET_VALUE (frag->tc_frag_data.first_map) == 0);
2691           symbol_remove (frag->tc_frag_data.first_map, &symbol_rootP, &symbol_lastP);
2692         }
2693       frag->tc_frag_data.first_map = symbolP;
2694     }
2695   if (frag->tc_frag_data.last_map != NULL)
2696     {
2697       know (S_GET_VALUE (frag->tc_frag_data.last_map) <= S_GET_VALUE (symbolP));
2698       if (S_GET_VALUE (frag->tc_frag_data.last_map) == S_GET_VALUE (symbolP))
2699         symbol_remove (frag->tc_frag_data.last_map, &symbol_rootP, &symbol_lastP);
2700     }
2701   frag->tc_frag_data.last_map = symbolP;
2702 }
2703
2704 /* We must sometimes convert a region marked as code to data during
2705    code alignment, if an odd number of bytes have to be padded.  The
2706    code mapping symbol is pushed to an aligned address.  */
2707
2708 static void
2709 insert_data_mapping_symbol (enum mstate state,
2710                             valueT value, fragS *frag, offsetT bytes)
2711 {
2712   /* If there was already a mapping symbol, remove it.  */
2713   if (frag->tc_frag_data.last_map != NULL
2714       && S_GET_VALUE (frag->tc_frag_data.last_map) == frag->fr_address + value)
2715     {
2716       symbolS *symp = frag->tc_frag_data.last_map;
2717
2718       if (value == 0)
2719         {
2720           know (frag->tc_frag_data.first_map == symp);
2721           frag->tc_frag_data.first_map = NULL;
2722         }
2723       frag->tc_frag_data.last_map = NULL;
2724       symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2725     }
2726
2727   make_mapping_symbol (MAP_DATA, value, frag);
2728   make_mapping_symbol (state, value + bytes, frag);
2729 }
2730
2731 static void mapping_state_2 (enum mstate state, int max_chars);
2732
2733 /* Set the mapping state to STATE.  Only call this when about to
2734    emit some STATE bytes to the file.  */
2735
2736 #define TRANSITION(from, to) (mapstate == (from) && state == (to))
2737 void
2738 mapping_state (enum mstate state)
2739 {
2740   enum mstate mapstate = seg_info (now_seg)->tc_segment_info_data.mapstate;
2741
2742   if (mapstate == state)
2743     /* The mapping symbol has already been emitted.
2744        There is nothing else to do.  */
2745     return;
2746
2747   if (state == MAP_ARM || state == MAP_THUMB)
2748     /*  PR gas/12931
2749         All ARM instructions require 4-byte alignment.
2750         (Almost) all Thumb instructions require 2-byte alignment.
2751
2752         When emitting instructions into any section, mark the section
2753         appropriately.
2754
2755         Some Thumb instructions are alignment-sensitive modulo 4 bytes,
2756         but themselves require 2-byte alignment; this applies to some
2757         PC- relative forms.  However, these cases will involve implicit
2758         literal pool generation or an explicit .align >=2, both of
2759         which will cause the section to me marked with sufficient
2760         alignment.  Thus, we don't handle those cases here.  */
2761     record_alignment (now_seg, state == MAP_ARM ? 2 : 1);
2762
2763   if (TRANSITION (MAP_UNDEFINED, MAP_DATA))
2764     /* This case will be evaluated later.  */
2765     return;
2766
2767   mapping_state_2 (state, 0);
2768 }
2769
2770 /* Same as mapping_state, but MAX_CHARS bytes have already been
2771    allocated.  Put the mapping symbol that far back.  */
2772
2773 static void
2774 mapping_state_2 (enum mstate state, int max_chars)
2775 {
2776   enum mstate mapstate = seg_info (now_seg)->tc_segment_info_data.mapstate;
2777
2778   if (!SEG_NORMAL (now_seg))
2779     return;
2780
2781   if (mapstate == state)
2782     /* The mapping symbol has already been emitted.
2783        There is nothing else to do.  */
2784     return;
2785
2786   if (TRANSITION (MAP_UNDEFINED, MAP_ARM)
2787           || TRANSITION (MAP_UNDEFINED, MAP_THUMB))
2788     {
2789       struct frag * const frag_first = seg_info (now_seg)->frchainP->frch_root;
2790       const int add_symbol = (frag_now != frag_first) || (frag_now_fix () > 0);
2791
2792       if (add_symbol)
2793         make_mapping_symbol (MAP_DATA, (valueT) 0, frag_first);
2794     }
2795
2796   seg_info (now_seg)->tc_segment_info_data.mapstate = state;
2797   make_mapping_symbol (state, (valueT) frag_now_fix () - max_chars, frag_now);
2798 }
2799 #undef TRANSITION
2800 #else
2801 #define mapping_state(x) ((void)0)
2802 #define mapping_state_2(x, y) ((void)0)
2803 #endif
2804
2805 /* Find the real, Thumb encoded start of a Thumb function.  */
2806
2807 #ifdef OBJ_COFF
2808 static symbolS *
2809 find_real_start (symbolS * symbolP)
2810 {
2811   char *       real_start;
2812   const char * name = S_GET_NAME (symbolP);
2813   symbolS *    new_target;
2814
2815   /* This definition must agree with the one in gcc/config/arm/thumb.c.  */
2816 #define STUB_NAME ".real_start_of"
2817
2818   if (name == NULL)
2819     abort ();
2820
2821   /* The compiler may generate BL instructions to local labels because
2822      it needs to perform a branch to a far away location. These labels
2823      do not have a corresponding ".real_start_of" label.  We check
2824      both for S_IS_LOCAL and for a leading dot, to give a way to bypass
2825      the ".real_start_of" convention for nonlocal branches.  */
2826   if (S_IS_LOCAL (symbolP) || name[0] == '.')
2827     return symbolP;
2828
2829   real_start = concat (STUB_NAME, name, NULL);
2830   new_target = symbol_find (real_start);
2831   free (real_start);
2832
2833   if (new_target == NULL)
2834     {
2835       as_warn (_("Failed to find real start of function: %s\n"), name);
2836       new_target = symbolP;
2837     }
2838
2839   return new_target;
2840 }
2841 #endif
2842
2843 static void
2844 opcode_select (int width)
2845 {
2846   switch (width)
2847     {
2848     case 16:
2849       if (! thumb_mode)
2850         {
2851           if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
2852             as_bad (_("selected processor does not support THUMB opcodes"));
2853
2854           thumb_mode = 1;
2855           /* No need to force the alignment, since we will have been
2856              coming from ARM mode, which is word-aligned.  */
2857           record_alignment (now_seg, 1);
2858         }
2859       break;
2860
2861     case 32:
2862       if (thumb_mode)
2863         {
2864           if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
2865             as_bad (_("selected processor does not support ARM opcodes"));
2866
2867           thumb_mode = 0;
2868
2869           if (!need_pass_2)
2870             frag_align (2, 0, 0);
2871
2872           record_alignment (now_seg, 1);
2873         }
2874       break;
2875
2876     default:
2877       as_bad (_("invalid instruction size selected (%d)"), width);
2878     }
2879 }
2880
2881 static void
2882 s_arm (int ignore ATTRIBUTE_UNUSED)
2883 {
2884   opcode_select (32);
2885   demand_empty_rest_of_line ();
2886 }
2887
2888 static void
2889 s_thumb (int ignore ATTRIBUTE_UNUSED)
2890 {
2891   opcode_select (16);
2892   demand_empty_rest_of_line ();
2893 }
2894
2895 static void
2896 s_code (int unused ATTRIBUTE_UNUSED)
2897 {
2898   int temp;
2899
2900   temp = get_absolute_expression ();
2901   switch (temp)
2902     {
2903     case 16:
2904     case 32:
2905       opcode_select (temp);
2906       break;
2907
2908     default:
2909       as_bad (_("invalid operand to .code directive (%d) (expecting 16 or 32)"), temp);
2910     }
2911 }
2912
2913 static void
2914 s_force_thumb (int ignore ATTRIBUTE_UNUSED)
2915 {
2916   /* If we are not already in thumb mode go into it, EVEN if
2917      the target processor does not support thumb instructions.
2918      This is used by gcc/config/arm/lib1funcs.asm for example
2919      to compile interworking support functions even if the
2920      target processor should not support interworking.  */
2921   if (! thumb_mode)
2922     {
2923       thumb_mode = 2;
2924       record_alignment (now_seg, 1);
2925     }
2926
2927   demand_empty_rest_of_line ();
2928 }
2929
2930 static void
2931 s_thumb_func (int ignore ATTRIBUTE_UNUSED)
2932 {
2933   s_thumb (0);
2934
2935   /* The following label is the name/address of the start of a Thumb function.
2936      We need to know this for the interworking support.  */
2937   label_is_thumb_function_name = TRUE;
2938 }
2939
2940 /* Perform a .set directive, but also mark the alias as
2941    being a thumb function.  */
2942
2943 static void
2944 s_thumb_set (int equiv)
2945 {
2946   /* XXX the following is a duplicate of the code for s_set() in read.c
2947      We cannot just call that code as we need to get at the symbol that
2948      is created.  */
2949   char *    name;
2950   char      delim;
2951   char *    end_name;
2952   symbolS * symbolP;
2953
2954   /* Especial apologies for the random logic:
2955      This just grew, and could be parsed much more simply!
2956      Dean - in haste.  */
2957   delim     = get_symbol_name (& name);
2958   end_name  = input_line_pointer;
2959   (void) restore_line_pointer (delim);
2960
2961   if (*input_line_pointer != ',')
2962     {
2963       *end_name = 0;
2964       as_bad (_("expected comma after name \"%s\""), name);
2965       *end_name = delim;
2966       ignore_rest_of_line ();
2967       return;
2968     }
2969
2970   input_line_pointer++;
2971   *end_name = 0;
2972
2973   if (name[0] == '.' && name[1] == '\0')
2974     {
2975       /* XXX - this should not happen to .thumb_set.  */
2976       abort ();
2977     }
2978
2979   if ((symbolP = symbol_find (name)) == NULL
2980       && (symbolP = md_undefined_symbol (name)) == NULL)
2981     {
2982 #ifndef NO_LISTING
2983       /* When doing symbol listings, play games with dummy fragments living
2984          outside the normal fragment chain to record the file and line info
2985          for this symbol.  */
2986       if (listing & LISTING_SYMBOLS)
2987         {
2988           extern struct list_info_struct * listing_tail;
2989           fragS * dummy_frag = (fragS * ) xmalloc (sizeof (fragS));
2990
2991           memset (dummy_frag, 0, sizeof (fragS));
2992           dummy_frag->fr_type = rs_fill;
2993           dummy_frag->line = listing_tail;
2994           symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
2995           dummy_frag->fr_symbol = symbolP;
2996         }
2997       else
2998 #endif
2999         symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
3000
3001 #ifdef OBJ_COFF
3002       /* "set" symbols are local unless otherwise specified.  */
3003       SF_SET_LOCAL (symbolP);
3004 #endif /* OBJ_COFF  */
3005     }                           /* Make a new symbol.  */
3006
3007   symbol_table_insert (symbolP);
3008
3009   * end_name = delim;
3010
3011   if (equiv
3012       && S_IS_DEFINED (symbolP)
3013       && S_GET_SEGMENT (symbolP) != reg_section)
3014     as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
3015
3016   pseudo_set (symbolP);
3017
3018   demand_empty_rest_of_line ();
3019
3020   /* XXX Now we come to the Thumb specific bit of code.  */
3021
3022   THUMB_SET_FUNC (symbolP, 1);
3023   ARM_SET_THUMB (symbolP, 1);
3024 #if defined OBJ_ELF || defined OBJ_COFF
3025   ARM_SET_INTERWORK (symbolP, support_interwork);
3026 #endif
3027 }
3028
3029 /* Directives: Mode selection.  */
3030
3031 /* .syntax [unified|divided] - choose the new unified syntax
3032    (same for Arm and Thumb encoding, modulo slight differences in what
3033    can be represented) or the old divergent syntax for each mode.  */
3034 static void
3035 s_syntax (int unused ATTRIBUTE_UNUSED)
3036 {
3037   char *name, delim;
3038
3039   delim = get_symbol_name (& name);
3040
3041   if (!strcasecmp (name, "unified"))
3042     unified_syntax = TRUE;
3043   else if (!strcasecmp (name, "divided"))
3044     unified_syntax = FALSE;
3045   else
3046     {
3047       as_bad (_("unrecognized syntax mode \"%s\""), name);
3048       return;
3049     }
3050   (void) restore_line_pointer (delim);
3051   demand_empty_rest_of_line ();
3052 }
3053
3054 /* Directives: sectioning and alignment.  */
3055
3056 static void
3057 s_bss (int ignore ATTRIBUTE_UNUSED)
3058 {
3059   /* We don't support putting frags in the BSS segment, we fake it by
3060      marking in_bss, then looking at s_skip for clues.  */
3061   subseg_set (bss_section, 0);
3062   demand_empty_rest_of_line ();
3063
3064 #ifdef md_elf_section_change_hook
3065   md_elf_section_change_hook ();
3066 #endif
3067 }
3068
3069 static void
3070 s_even (int ignore ATTRIBUTE_UNUSED)
3071 {
3072   /* Never make frag if expect extra pass.  */
3073   if (!need_pass_2)
3074     frag_align (1, 0, 0);
3075
3076   record_alignment (now_seg, 1);
3077
3078   demand_empty_rest_of_line ();
3079 }
3080
3081 /* Directives: CodeComposer Studio.  */
3082
3083 /*  .ref  (for CodeComposer Studio syntax only).  */
3084 static void
3085 s_ccs_ref (int unused ATTRIBUTE_UNUSED)
3086 {
3087   if (codecomposer_syntax)
3088     ignore_rest_of_line ();
3089   else
3090     as_bad (_(".ref pseudo-op only available with -mccs flag."));
3091 }
3092
3093 /*  If name is not NULL, then it is used for marking the beginning of a
3094     function, whereas if it is NULL then it means the function end.  */
3095 static void
3096 asmfunc_debug (const char * name)
3097 {
3098   static const char * last_name = NULL;
3099
3100   if (name != NULL)
3101     {
3102       gas_assert (last_name == NULL);
3103       last_name = name;
3104
3105       if (debug_type == DEBUG_STABS)
3106          stabs_generate_asm_func (name, name);
3107     }
3108   else
3109     {
3110       gas_assert (last_name != NULL);
3111
3112       if (debug_type == DEBUG_STABS)
3113         stabs_generate_asm_endfunc (last_name, last_name);
3114
3115       last_name = NULL;
3116     }
3117 }
3118
3119 static void
3120 s_ccs_asmfunc (int unused ATTRIBUTE_UNUSED)
3121 {
3122   if (codecomposer_syntax)
3123     {
3124       switch (asmfunc_state)
3125         {
3126         case OUTSIDE_ASMFUNC:
3127           asmfunc_state = WAITING_ASMFUNC_NAME;
3128           break;
3129
3130         case WAITING_ASMFUNC_NAME:
3131           as_bad (_(".asmfunc repeated."));
3132           break;
3133
3134         case WAITING_ENDASMFUNC:
3135           as_bad (_(".asmfunc without function."));
3136           break;
3137         }
3138       demand_empty_rest_of_line ();
3139     }
3140   else
3141     as_bad (_(".asmfunc pseudo-op only available with -mccs flag."));
3142 }
3143
3144 static void
3145 s_ccs_endasmfunc (int unused ATTRIBUTE_UNUSED)
3146 {
3147   if (codecomposer_syntax)
3148     {
3149       switch (asmfunc_state)
3150         {
3151         case OUTSIDE_ASMFUNC:
3152           as_bad (_(".endasmfunc without a .asmfunc."));
3153           break;
3154
3155         case WAITING_ASMFUNC_NAME:
3156           as_bad (_(".endasmfunc without function."));
3157           break;
3158
3159         case WAITING_ENDASMFUNC:
3160           asmfunc_state = OUTSIDE_ASMFUNC;
3161           asmfunc_debug (NULL);
3162           break;
3163         }
3164       demand_empty_rest_of_line ();
3165     }
3166   else
3167     as_bad (_(".endasmfunc pseudo-op only available with -mccs flag."));
3168 }
3169
3170 static void
3171 s_ccs_def (int name)
3172 {
3173   if (codecomposer_syntax)
3174     s_globl (name);
3175   else
3176     as_bad (_(".def pseudo-op only available with -mccs flag."));
3177 }
3178
3179 /* Directives: Literal pools.  */
3180
3181 static literal_pool *
3182 find_literal_pool (void)
3183 {
3184   literal_pool * pool;
3185
3186   for (pool = list_of_pools; pool != NULL; pool = pool->next)
3187     {
3188       if (pool->section == now_seg
3189           && pool->sub_section == now_subseg)
3190         break;
3191     }
3192
3193   return pool;
3194 }
3195
3196 static literal_pool *
3197 find_or_make_literal_pool (void)
3198 {
3199   /* Next literal pool ID number.  */
3200   static unsigned int latest_pool_num = 1;
3201   literal_pool *      pool;
3202
3203   pool = find_literal_pool ();
3204
3205   if (pool == NULL)
3206     {
3207       /* Create a new pool.  */
3208       pool = XNEW (literal_pool);
3209       if (! pool)
3210         return NULL;
3211
3212       pool->next_free_entry = 0;
3213       pool->section         = now_seg;
3214       pool->sub_section     = now_subseg;
3215       pool->next            = list_of_pools;
3216       pool->symbol          = NULL;
3217       pool->alignment       = 2;
3218
3219       /* Add it to the list.  */
3220       list_of_pools = pool;
3221     }
3222
3223   /* New pools, and emptied pools, will have a NULL symbol.  */
3224   if (pool->symbol == NULL)
3225     {
3226       pool->symbol = symbol_create (FAKE_LABEL_NAME, undefined_section,
3227                                     (valueT) 0, &zero_address_frag);
3228       pool->id = latest_pool_num ++;
3229     }
3230
3231   /* Done.  */
3232   return pool;
3233 }
3234
3235 /* Add the literal in the global 'inst'
3236    structure to the relevant literal pool.  */
3237
3238 static int
3239 add_to_lit_pool (unsigned int nbytes)
3240 {
3241 #define PADDING_SLOT 0x1
3242 #define LIT_ENTRY_SIZE_MASK 0xFF
3243   literal_pool * pool;
3244   unsigned int entry, pool_size = 0;
3245   bfd_boolean padding_slot_p = FALSE;
3246   unsigned imm1 = 0;
3247   unsigned imm2 = 0;
3248
3249   if (nbytes == 8)
3250     {
3251       imm1 = inst.operands[1].imm;
3252       imm2 = (inst.operands[1].regisimm ? inst.operands[1].reg
3253                : inst.relocs[0].exp.X_unsigned ? 0
3254                : ((bfd_int64_t) inst.operands[1].imm) >> 32);
3255       if (target_big_endian)
3256         {
3257           imm1 = imm2;
3258           imm2 = inst.operands[1].imm;
3259         }
3260     }
3261
3262   pool = find_or_make_literal_pool ();
3263
3264   /* Check if this literal value is already in the pool.  */
3265   for (entry = 0; entry < pool->next_free_entry; entry ++)
3266     {
3267       if (nbytes == 4)
3268         {
3269           if ((pool->literals[entry].X_op == inst.relocs[0].exp.X_op)
3270               && (inst.relocs[0].exp.X_op == O_constant)
3271               && (pool->literals[entry].X_add_number
3272                   == inst.relocs[0].exp.X_add_number)
3273               && (pool->literals[entry].X_md == nbytes)
3274               && (pool->literals[entry].X_unsigned
3275                   == inst.relocs[0].exp.X_unsigned))
3276             break;
3277
3278           if ((pool->literals[entry].X_op == inst.relocs[0].exp.X_op)
3279               && (inst.relocs[0].exp.X_op == O_symbol)
3280               && (pool->literals[entry].X_add_number
3281                   == inst.relocs[0].exp.X_add_number)
3282               && (pool->literals[entry].X_add_symbol
3283                   == inst.relocs[0].exp.X_add_symbol)
3284               && (pool->literals[entry].X_op_symbol
3285                   == inst.relocs[0].exp.X_op_symbol)
3286               && (pool->literals[entry].X_md == nbytes))
3287             break;
3288         }
3289       else if ((nbytes == 8)
3290                && !(pool_size & 0x7)
3291                && ((entry + 1) != pool->next_free_entry)
3292                && (pool->literals[entry].X_op == O_constant)
3293                && (pool->literals[entry].X_add_number == (offsetT) imm1)
3294                && (pool->literals[entry].X_unsigned
3295                    == inst.relocs[0].exp.X_unsigned)
3296                && (pool->literals[entry + 1].X_op == O_constant)
3297                && (pool->literals[entry + 1].X_add_number == (offsetT) imm2)
3298                && (pool->literals[entry + 1].X_unsigned
3299                    == inst.relocs[0].exp.X_unsigned))
3300         break;
3301
3302       padding_slot_p = ((pool->literals[entry].X_md >> 8) == PADDING_SLOT);
3303       if (padding_slot_p && (nbytes == 4))
3304         break;
3305
3306       pool_size += 4;
3307     }
3308
3309   /* Do we need to create a new entry?  */
3310   if (entry == pool->next_free_entry)
3311     {
3312       if (entry >= MAX_LITERAL_POOL_SIZE)
3313         {
3314           inst.error = _("literal pool overflow");
3315           return FAIL;
3316         }
3317
3318       if (nbytes == 8)
3319         {
3320           /* For 8-byte entries, we align to an 8-byte boundary,
3321              and split it into two 4-byte entries, because on 32-bit
3322              host, 8-byte constants are treated as big num, thus
3323              saved in "generic_bignum" which will be overwritten
3324              by later assignments.
3325
3326              We also need to make sure there is enough space for
3327              the split.
3328
3329              We also check to make sure the literal operand is a
3330              constant number.  */
3331           if (!(inst.relocs[0].exp.X_op == O_constant
3332                 || inst.relocs[0].exp.X_op == O_big))
3333             {
3334               inst.error = _("invalid type for literal pool");
3335               return FAIL;
3336             }
3337           else if (pool_size & 0x7)
3338             {
3339               if ((entry + 2) >= MAX_LITERAL_POOL_SIZE)
3340                 {
3341                   inst.error = _("literal pool overflow");
3342                   return FAIL;
3343                 }
3344
3345               pool->literals[entry] = inst.relocs[0].exp;
3346               pool->literals[entry].X_op = O_constant;
3347               pool->literals[entry].X_add_number = 0;
3348               pool->literals[entry++].X_md = (PADDING_SLOT << 8) | 4;
3349               pool->next_free_entry += 1;
3350               pool_size += 4;
3351             }
3352           else if ((entry + 1) >= MAX_LITERAL_POOL_SIZE)
3353             {
3354               inst.error = _("literal pool overflow");
3355               return FAIL;
3356             }
3357
3358           pool->literals[entry] = inst.relocs[0].exp;
3359           pool->literals[entry].X_op = O_constant;
3360           pool->literals[entry].X_add_number = imm1;
3361           pool->literals[entry].X_unsigned = inst.relocs[0].exp.X_unsigned;
3362           pool->literals[entry++].X_md = 4;
3363           pool->literals[entry] = inst.relocs[0].exp;
3364           pool->literals[entry].X_op = O_constant;
3365           pool->literals[entry].X_add_number = imm2;
3366           pool->literals[entry].X_unsigned = inst.relocs[0].exp.X_unsigned;
3367           pool->literals[entry].X_md = 4;
3368           pool->alignment = 3;
3369           pool->next_free_entry += 1;
3370         }
3371       else
3372         {
3373           pool->literals[entry] = inst.relocs[0].exp;
3374           pool->literals[entry].X_md = 4;
3375         }
3376
3377 #ifdef OBJ_ELF
3378       /* PR ld/12974: Record the location of the first source line to reference
3379          this entry in the literal pool.  If it turns out during linking that the
3380          symbol does not exist we will be able to give an accurate line number for
3381          the (first use of the) missing reference.  */
3382       if (debug_type == DEBUG_DWARF2)
3383         dwarf2_where (pool->locs + entry);
3384 #endif
3385       pool->next_free_entry += 1;
3386     }
3387   else if (padding_slot_p)
3388     {
3389       pool->literals[entry] = inst.relocs[0].exp;
3390       pool->literals[entry].X_md = nbytes;
3391     }
3392
3393   inst.relocs[0].exp.X_op             = O_symbol;
3394   inst.relocs[0].exp.X_add_number = pool_size;
3395   inst.relocs[0].exp.X_add_symbol = pool->symbol;
3396
3397   return SUCCESS;
3398 }
3399
3400 bfd_boolean
3401 tc_start_label_without_colon (void)
3402 {
3403   bfd_boolean ret = TRUE;
3404
3405   if (codecomposer_syntax && asmfunc_state == WAITING_ASMFUNC_NAME)
3406     {
3407       const char *label = input_line_pointer;
3408
3409       while (!is_end_of_line[(int) label[-1]])
3410         --label;
3411
3412       if (*label == '.')
3413         {
3414           as_bad (_("Invalid label '%s'"), label);
3415           ret = FALSE;
3416         }
3417
3418       asmfunc_debug (label);
3419
3420       asmfunc_state = WAITING_ENDASMFUNC;
3421     }
3422
3423   return ret;
3424 }
3425
3426 /* Can't use symbol_new here, so have to create a symbol and then at
3427    a later date assign it a value. That's what these functions do.  */
3428
3429 static void
3430 symbol_locate (symbolS *    symbolP,
3431                const char * name,       /* It is copied, the caller can modify.  */
3432                segT         segment,    /* Segment identifier (SEG_<something>).  */
3433                valueT       valu,       /* Symbol value.  */
3434                fragS *      frag)       /* Associated fragment.  */
3435 {
3436   size_t name_length;
3437   char * preserved_copy_of_name;
3438
3439   name_length = strlen (name) + 1;   /* +1 for \0.  */
3440   obstack_grow (&notes, name, name_length);
3441   preserved_copy_of_name = (char *) obstack_finish (&notes);
3442
3443 #ifdef tc_canonicalize_symbol_name
3444   preserved_copy_of_name =
3445     tc_canonicalize_symbol_name (preserved_copy_of_name);
3446 #endif
3447
3448   S_SET_NAME (symbolP, preserved_copy_of_name);
3449
3450   S_SET_SEGMENT (symbolP, segment);
3451   S_SET_VALUE (symbolP, valu);
3452   symbol_clear_list_pointers (symbolP);
3453
3454   symbol_set_frag (symbolP, frag);
3455
3456   /* Link to end of symbol chain.  */
3457   {
3458     extern int symbol_table_frozen;
3459
3460     if (symbol_table_frozen)
3461       abort ();
3462   }
3463
3464   symbol_append (symbolP, symbol_lastP, & symbol_rootP, & symbol_lastP);
3465
3466   obj_symbol_new_hook (symbolP);
3467
3468 #ifdef tc_symbol_new_hook
3469   tc_symbol_new_hook (symbolP);
3470 #endif
3471
3472 #ifdef DEBUG_SYMS
3473   verify_symbol_chain (symbol_rootP, symbol_lastP);
3474 #endif /* DEBUG_SYMS  */
3475 }
3476
3477 static void
3478 s_ltorg (int ignored ATTRIBUTE_UNUSED)
3479 {
3480   unsigned int entry;
3481   literal_pool * pool;
3482   char sym_name[20];
3483
3484   pool = find_literal_pool ();
3485   if (pool == NULL
3486       || pool->symbol == NULL
3487       || pool->next_free_entry == 0)
3488     return;
3489
3490   /* Align pool as you have word accesses.
3491      Only make a frag if we have to.  */
3492   if (!need_pass_2)
3493     frag_align (pool->alignment, 0, 0);
3494
3495   record_alignment (now_seg, 2);
3496
3497 #ifdef OBJ_ELF
3498   seg_info (now_seg)->tc_segment_info_data.mapstate = MAP_DATA;
3499   make_mapping_symbol (MAP_DATA, (valueT) frag_now_fix (), frag_now);
3500 #endif
3501   sprintf (sym_name, "$$lit_\002%x", pool->id);
3502
3503   symbol_locate (pool->symbol, sym_name, now_seg,
3504                  (valueT) frag_now_fix (), frag_now);
3505   symbol_table_insert (pool->symbol);
3506
3507   ARM_SET_THUMB (pool->symbol, thumb_mode);
3508
3509 #if defined OBJ_COFF || defined OBJ_ELF
3510   ARM_SET_INTERWORK (pool->symbol, support_interwork);
3511 #endif
3512
3513   for (entry = 0; entry < pool->next_free_entry; entry ++)
3514     {
3515 #ifdef OBJ_ELF
3516       if (debug_type == DEBUG_DWARF2)
3517         dwarf2_gen_line_info (frag_now_fix (), pool->locs + entry);
3518 #endif
3519       /* First output the expression in the instruction to the pool.  */
3520       emit_expr (&(pool->literals[entry]),
3521                  pool->literals[entry].X_md & LIT_ENTRY_SIZE_MASK);
3522     }
3523
3524   /* Mark the pool as empty.  */
3525   pool->next_free_entry = 0;
3526   pool->symbol = NULL;
3527 }
3528
3529 #ifdef OBJ_ELF
3530 /* Forward declarations for functions below, in the MD interface
3531    section.  */
3532 static void fix_new_arm (fragS *, int, short, expressionS *, int, int);
3533 static valueT create_unwind_entry (int);
3534 static void start_unwind_section (const segT, int);
3535 static void add_unwind_opcode (valueT, int);
3536 static void flush_pending_unwind (void);
3537
3538 /* Directives: Data.  */
3539
3540 static void
3541 s_arm_elf_cons (int nbytes)
3542 {
3543   expressionS exp;
3544
3545 #ifdef md_flush_pending_output
3546   md_flush_pending_output ();
3547 #endif
3548
3549   if (is_it_end_of_statement ())
3550     {
3551       demand_empty_rest_of_line ();
3552       return;
3553     }
3554
3555 #ifdef md_cons_align
3556   md_cons_align (nbytes);
3557 #endif
3558
3559   mapping_state (MAP_DATA);
3560   do
3561     {
3562       int reloc;
3563       char *base = input_line_pointer;
3564
3565       expression (& exp);
3566
3567       if (exp.X_op != O_symbol)
3568         emit_expr (&exp, (unsigned int) nbytes);
3569       else
3570         {
3571           char *before_reloc = input_line_pointer;
3572           reloc = parse_reloc (&input_line_pointer);
3573           if (reloc == -1)
3574             {
3575               as_bad (_("unrecognized relocation suffix"));
3576               ignore_rest_of_line ();
3577               return;
3578             }
3579           else if (reloc == BFD_RELOC_UNUSED)
3580             emit_expr (&exp, (unsigned int) nbytes);
3581           else
3582             {
3583               reloc_howto_type *howto = (reloc_howto_type *)
3584                   bfd_reloc_type_lookup (stdoutput,
3585                                          (bfd_reloc_code_real_type) reloc);
3586               int size = bfd_get_reloc_size (howto);
3587
3588               if (reloc == BFD_RELOC_ARM_PLT32)
3589                 {
3590                   as_bad (_("(plt) is only valid on branch targets"));
3591                   reloc = BFD_RELOC_UNUSED;
3592                   size = 0;
3593                 }
3594
3595               if (size > nbytes)
3596                 as_bad (ngettext ("%s relocations do not fit in %d byte",
3597                                   "%s relocations do not fit in %d bytes",
3598                                   nbytes),
3599                         howto->name, nbytes);
3600               else
3601                 {
3602                   /* We've parsed an expression stopping at O_symbol.
3603                      But there may be more expression left now that we
3604                      have parsed the relocation marker.  Parse it again.
3605                      XXX Surely there is a cleaner way to do this.  */
3606                   char *p = input_line_pointer;
3607                   int offset;
3608                   char *save_buf = XNEWVEC (char, input_line_pointer - base);
3609
3610                   memcpy (save_buf, base, input_line_pointer - base);
3611                   memmove (base + (input_line_pointer - before_reloc),
3612                            base, before_reloc - base);
3613
3614                   input_line_pointer = base + (input_line_pointer-before_reloc);
3615                   expression (&exp);
3616                   memcpy (base, save_buf, p - base);
3617
3618                   offset = nbytes - size;
3619                   p = frag_more (nbytes);
3620                   memset (p, 0, nbytes);
3621                   fix_new_exp (frag_now, p - frag_now->fr_literal + offset,
3622                                size, &exp, 0, (enum bfd_reloc_code_real) reloc);
3623                   free (save_buf);
3624                 }
3625             }
3626         }
3627     }
3628   while (*input_line_pointer++ == ',');
3629
3630   /* Put terminator back into stream.  */
3631   input_line_pointer --;
3632   demand_empty_rest_of_line ();
3633 }
3634
3635 /* Emit an expression containing a 32-bit thumb instruction.
3636    Implementation based on put_thumb32_insn.  */
3637
3638 static void
3639 emit_thumb32_expr (expressionS * exp)
3640 {
3641   expressionS exp_high = *exp;
3642
3643   exp_high.X_add_number = (unsigned long)exp_high.X_add_number >> 16;
3644   emit_expr (& exp_high, (unsigned int) THUMB_SIZE);
3645   exp->X_add_number &= 0xffff;
3646   emit_expr (exp, (unsigned int) THUMB_SIZE);
3647 }
3648
3649 /*  Guess the instruction size based on the opcode.  */
3650
3651 static int
3652 thumb_insn_size (int opcode)
3653 {
3654   if ((unsigned int) opcode < 0xe800u)
3655     return 2;
3656   else if ((unsigned int) opcode >= 0xe8000000u)
3657     return 4;
3658   else
3659     return 0;
3660 }
3661
3662 static bfd_boolean
3663 emit_insn (expressionS *exp, int nbytes)
3664 {
3665   int size = 0;
3666
3667   if (exp->X_op == O_constant)
3668     {
3669       size = nbytes;
3670
3671       if (size == 0)
3672         size = thumb_insn_size (exp->X_add_number);
3673
3674       if (size != 0)
3675         {
3676           if (size == 2 && (unsigned int)exp->X_add_number > 0xffffu)
3677             {
3678               as_bad (_(".inst.n operand too big. "\
3679                         "Use .inst.w instead"));
3680               size = 0;
3681             }
3682           else
3683             {
3684               if (now_it.state == AUTOMATIC_IT_BLOCK)
3685                 set_it_insn_type_nonvoid (OUTSIDE_IT_INSN, 0);
3686               else
3687                 set_it_insn_type_nonvoid (NEUTRAL_IT_INSN, 0);
3688
3689               if (thumb_mode && (size > THUMB_SIZE) && !target_big_endian)
3690                 emit_thumb32_expr (exp);
3691               else
3692                 emit_expr (exp, (unsigned int) size);
3693
3694               it_fsm_post_encode ();
3695             }
3696         }
3697       else
3698         as_bad (_("cannot determine Thumb instruction size. "   \
3699                   "Use .inst.n/.inst.w instead"));
3700     }
3701   else
3702     as_bad (_("constant expression required"));
3703
3704   return (size != 0);
3705 }
3706
3707 /* Like s_arm_elf_cons but do not use md_cons_align and
3708    set the mapping state to MAP_ARM/MAP_THUMB.  */
3709
3710 static void
3711 s_arm_elf_inst (int nbytes)
3712 {
3713   if (is_it_end_of_statement ())
3714     {
3715       demand_empty_rest_of_line ();
3716       return;
3717     }
3718
3719   /* Calling mapping_state () here will not change ARM/THUMB,
3720      but will ensure not to be in DATA state.  */
3721
3722   if (thumb_mode)
3723     mapping_state (MAP_THUMB);
3724   else
3725     {
3726       if (nbytes != 0)
3727         {
3728           as_bad (_("width suffixes are invalid in ARM mode"));
3729           ignore_rest_of_line ();
3730           return;
3731         }
3732
3733       nbytes = 4;
3734
3735       mapping_state (MAP_ARM);
3736     }
3737
3738   do
3739     {
3740       expressionS exp;
3741
3742       expression (& exp);
3743
3744       if (! emit_insn (& exp, nbytes))
3745         {
3746           ignore_rest_of_line ();
3747           return;
3748         }
3749     }
3750   while (*input_line_pointer++ == ',');
3751
3752   /* Put terminator back into stream.  */
3753   input_line_pointer --;
3754   demand_empty_rest_of_line ();
3755 }
3756
3757 /* Parse a .rel31 directive.  */
3758
3759 static void
3760 s_arm_rel31 (int ignored ATTRIBUTE_UNUSED)
3761 {
3762   expressionS exp;
3763   char *p;
3764   valueT highbit;
3765
3766   highbit = 0;
3767   if (*input_line_pointer == '1')
3768     highbit = 0x80000000;
3769   else if (*input_line_pointer != '0')
3770     as_bad (_("expected 0 or 1"));
3771
3772   input_line_pointer++;
3773   if (*input_line_pointer != ',')
3774     as_bad (_("missing comma"));
3775   input_line_pointer++;
3776
3777 #ifdef md_flush_pending_output
3778   md_flush_pending_output ();
3779 #endif
3780
3781 #ifdef md_cons_align
3782   md_cons_align (4);
3783 #endif
3784
3785   mapping_state (MAP_DATA);
3786
3787   expression (&exp);
3788
3789   p = frag_more (4);
3790   md_number_to_chars (p, highbit, 4);
3791   fix_new_arm (frag_now, p - frag_now->fr_literal, 4, &exp, 1,
3792                BFD_RELOC_ARM_PREL31);
3793
3794   demand_empty_rest_of_line ();
3795 }
3796
3797 /* Directives: AEABI stack-unwind tables.  */
3798
3799 /* Parse an unwind_fnstart directive.  Simply records the current location.  */
3800
3801 static void
3802 s_arm_unwind_fnstart (int ignored ATTRIBUTE_UNUSED)
3803 {
3804   demand_empty_rest_of_line ();
3805   if (unwind.proc_start)
3806     {
3807       as_bad (_("duplicate .fnstart directive"));
3808       return;
3809     }
3810
3811   /* Mark the start of the function.  */
3812   unwind.proc_start = expr_build_dot ();
3813
3814   /* Reset the rest of the unwind info.  */
3815   unwind.opcode_count = 0;
3816   unwind.table_entry = NULL;
3817   unwind.personality_routine = NULL;
3818   unwind.personality_index = -1;
3819   unwind.frame_size = 0;
3820   unwind.fp_offset = 0;
3821   unwind.fp_reg = REG_SP;
3822   unwind.fp_used = 0;
3823   unwind.sp_restored = 0;
3824 }
3825
3826
3827 /* Parse a handlerdata directive.  Creates the exception handling table entry
3828    for the function.  */
3829
3830 static void
3831 s_arm_unwind_handlerdata (int ignored ATTRIBUTE_UNUSED)
3832 {
3833   demand_empty_rest_of_line ();
3834   if (!unwind.proc_start)
3835     as_bad (MISSING_FNSTART);
3836
3837   if (unwind.table_entry)
3838     as_bad (_("duplicate .handlerdata directive"));
3839
3840   create_unwind_entry (1);
3841 }
3842
3843 /* Parse an unwind_fnend directive.  Generates the index table entry.  */
3844
3845 static void
3846 s_arm_unwind_fnend (int ignored ATTRIBUTE_UNUSED)
3847 {
3848   long where;
3849   char *ptr;
3850   valueT val;
3851   unsigned int marked_pr_dependency;
3852
3853   demand_empty_rest_of_line ();
3854
3855   if (!unwind.proc_start)
3856     {
3857       as_bad (_(".fnend directive without .fnstart"));
3858       return;
3859     }
3860
3861   /* Add eh table entry.  */
3862   if (unwind.table_entry == NULL)
3863     val = create_unwind_entry (0);
3864   else
3865     val = 0;
3866
3867   /* Add index table entry.  This is two words.  */
3868   start_unwind_section (unwind.saved_seg, 1);
3869   frag_align (2, 0, 0);
3870   record_alignment (now_seg, 2);
3871
3872   ptr = frag_more (8);
3873   memset (ptr, 0, 8);
3874   where = frag_now_fix () - 8;
3875
3876   /* Self relative offset of the function start.  */
3877   fix_new (frag_now, where, 4, unwind.proc_start, 0, 1,
3878            BFD_RELOC_ARM_PREL31);
3879
3880   /* Indicate dependency on EHABI-defined personality routines to the
3881      linker, if it hasn't been done already.  */
3882   marked_pr_dependency
3883     = seg_info (now_seg)->tc_segment_info_data.marked_pr_dependency;
3884   if (unwind.personality_index >= 0 && unwind.personality_index < 3
3885       && !(marked_pr_dependency & (1 << unwind.personality_index)))
3886     {
3887       static const char *const name[] =
3888         {
3889           "__aeabi_unwind_cpp_pr0",
3890           "__aeabi_unwind_cpp_pr1",
3891           "__aeabi_unwind_cpp_pr2"
3892         };
3893       symbolS *pr = symbol_find_or_make (name[unwind.personality_index]);
3894       fix_new (frag_now, where, 0, pr, 0, 1, BFD_RELOC_NONE);
3895       seg_info (now_seg)->tc_segment_info_data.marked_pr_dependency
3896         |= 1 << unwind.personality_index;
3897     }
3898
3899   if (val)
3900     /* Inline exception table entry.  */
3901     md_number_to_chars (ptr + 4, val, 4);
3902   else
3903     /* Self relative offset of the table entry.  */
3904     fix_new (frag_now, where + 4, 4, unwind.table_entry, 0, 1,
3905              BFD_RELOC_ARM_PREL31);
3906
3907   /* Restore the original section.  */
3908   subseg_set (unwind.saved_seg, unwind.saved_subseg);
3909
3910   unwind.proc_start = NULL;
3911 }
3912
3913
3914 /* Parse an unwind_cantunwind directive.  */
3915
3916 static void
3917 s_arm_unwind_cantunwind (int ignored ATTRIBUTE_UNUSED)
3918 {
3919   demand_empty_rest_of_line ();
3920   if (!unwind.proc_start)
3921     as_bad (MISSING_FNSTART);
3922
3923   if (unwind.personality_routine || unwind.personality_index != -1)
3924     as_bad (_("personality routine specified for cantunwind frame"));
3925
3926   unwind.personality_index = -2;
3927 }
3928
3929
3930 /* Parse a personalityindex directive.  */
3931
3932 static void
3933 s_arm_unwind_personalityindex (int ignored ATTRIBUTE_UNUSED)
3934 {
3935   expressionS exp;
3936
3937   if (!unwind.proc_start)
3938     as_bad (MISSING_FNSTART);
3939
3940   if (unwind.personality_routine || unwind.personality_index != -1)
3941     as_bad (_("duplicate .personalityindex directive"));
3942
3943   expression (&exp);
3944
3945   if (exp.X_op != O_constant
3946       || exp.X_add_number < 0 || exp.X_add_number > 15)
3947     {
3948       as_bad (_("bad personality routine number"));
3949       ignore_rest_of_line ();
3950       return;
3951     }
3952
3953   unwind.personality_index = exp.X_add_number;
3954
3955   demand_empty_rest_of_line ();
3956 }
3957
3958
3959 /* Parse a personality directive.  */
3960
3961 static void
3962 s_arm_unwind_personality (int ignored ATTRIBUTE_UNUSED)
3963 {
3964   char *name, *p, c;
3965
3966   if (!unwind.proc_start)
3967     as_bad (MISSING_FNSTART);
3968
3969   if (unwind.personality_routine || unwind.personality_index != -1)
3970     as_bad (_("duplicate .personality directive"));
3971
3972   c = get_symbol_name (& name);
3973   p = input_line_pointer;
3974   if (c == '"')
3975     ++ input_line_pointer;
3976   unwind.personality_routine = symbol_find_or_make (name);
3977   *p = c;
3978   demand_empty_rest_of_line ();
3979 }
3980
3981
3982 /* Parse a directive saving core registers.  */
3983
3984 static void
3985 s_arm_unwind_save_core (void)
3986 {
3987   valueT op;
3988   long range;
3989   int n;
3990
3991   range = parse_reg_list (&input_line_pointer);
3992   if (range == FAIL)
3993     {
3994       as_bad (_("expected register list"));
3995       ignore_rest_of_line ();
3996       return;
3997     }
3998
3999   demand_empty_rest_of_line ();
4000
4001   /* Turn .unwind_movsp ip followed by .unwind_save {..., ip, ...}
4002      into .unwind_save {..., sp...}.  We aren't bothered about the value of
4003      ip because it is clobbered by calls.  */
4004   if (unwind.sp_restored && unwind.fp_reg == 12
4005       && (range & 0x3000) == 0x1000)
4006     {
4007       unwind.opcode_count--;
4008       unwind.sp_restored = 0;
4009       range = (range | 0x2000) & ~0x1000;
4010       unwind.pending_offset = 0;
4011     }
4012
4013   /* Pop r4-r15.  */
4014   if (range & 0xfff0)
4015     {
4016       /* See if we can use the short opcodes.  These pop a block of up to 8
4017          registers starting with r4, plus maybe r14.  */
4018       for (n = 0; n < 8; n++)
4019         {
4020           /* Break at the first non-saved register.      */
4021           if ((range & (1 << (n + 4))) == 0)
4022             break;
4023         }
4024       /* See if there are any other bits set.  */
4025       if (n == 0 || (range & (0xfff0 << n) & 0xbff0) != 0)
4026         {
4027           /* Use the long form.  */
4028           op = 0x8000 | ((range >> 4) & 0xfff);
4029           add_unwind_opcode (op, 2);
4030         }
4031       else
4032         {
4033           /* Use the short form.  */
4034           if (range & 0x4000)
4035             op = 0xa8; /* Pop r14.      */
4036           else
4037             op = 0xa0; /* Do not pop r14.  */
4038           op |= (n - 1);
4039           add_unwind_opcode (op, 1);
4040         }
4041     }
4042
4043   /* Pop r0-r3.  */
4044   if (range & 0xf)
4045     {
4046       op = 0xb100 | (range & 0xf);
4047       add_unwind_opcode (op, 2);
4048     }
4049
4050   /* Record the number of bytes pushed.  */
4051   for (n = 0; n < 16; n++)
4052     {
4053       if (range & (1 << n))
4054         unwind.frame_size += 4;
4055     }
4056 }
4057
4058
4059 /* Parse a directive saving FPA registers.  */
4060
4061 static void
4062 s_arm_unwind_save_fpa (int reg)
4063 {
4064   expressionS exp;
4065   int num_regs;
4066   valueT op;
4067
4068   /* Get Number of registers to transfer.  */
4069   if (skip_past_comma (&input_line_pointer) != FAIL)
4070     expression (&exp);
4071   else
4072     exp.X_op = O_illegal;
4073
4074   if (exp.X_op != O_constant)
4075     {
4076       as_bad (_("expected , <constant>"));
4077       ignore_rest_of_line ();
4078       return;
4079     }
4080
4081   num_regs = exp.X_add_number;
4082
4083   if (num_regs < 1 || num_regs > 4)
4084     {
4085       as_bad (_("number of registers must be in the range [1:4]"));
4086       ignore_rest_of_line ();
4087       return;
4088     }
4089
4090   demand_empty_rest_of_line ();
4091
4092   if (reg == 4)
4093     {
4094       /* Short form.  */
4095       op = 0xb4 | (num_regs - 1);
4096       add_unwind_opcode (op, 1);
4097     }
4098   else
4099     {
4100       /* Long form.  */
4101       op = 0xc800 | (reg << 4) | (num_regs - 1);
4102       add_unwind_opcode (op, 2);
4103     }
4104   unwind.frame_size += num_regs * 12;
4105 }
4106
4107
4108 /* Parse a directive saving VFP registers for ARMv6 and above.  */
4109
4110 static void
4111 s_arm_unwind_save_vfp_armv6 (void)
4112 {
4113   int count;
4114   unsigned int start;
4115   valueT op;
4116   int num_vfpv3_regs = 0;
4117   int num_regs_below_16;
4118
4119   count = parse_vfp_reg_list (&input_line_pointer, &start, REGLIST_VFP_D);
4120   if (count == FAIL)
4121     {
4122       as_bad (_("expected register list"));
4123       ignore_rest_of_line ();
4124       return;
4125     }
4126
4127   demand_empty_rest_of_line ();
4128
4129   /* We always generate FSTMD/FLDMD-style unwinding opcodes (rather
4130      than FSTMX/FLDMX-style ones).  */
4131
4132   /* Generate opcode for (VFPv3) registers numbered in the range 16 .. 31.  */
4133   if (start >= 16)
4134     num_vfpv3_regs = count;
4135   else if (start + count > 16)
4136     num_vfpv3_regs = start + count - 16;
4137
4138   if (num_vfpv3_regs > 0)
4139     {
4140       int start_offset = start > 16 ? start - 16 : 0;
4141       op = 0xc800 | (start_offset << 4) | (num_vfpv3_regs - 1);
4142       add_unwind_opcode (op, 2);
4143     }
4144
4145   /* Generate opcode for registers numbered in the range 0 .. 15.  */
4146   num_regs_below_16 = num_vfpv3_regs > 0 ? 16 - (int) start : count;
4147   gas_assert (num_regs_below_16 + num_vfpv3_regs == count);
4148   if (num_regs_below_16 > 0)
4149     {
4150       op = 0xc900 | (start << 4) | (num_regs_below_16 - 1);
4151       add_unwind_opcode (op, 2);
4152     }
4153
4154   unwind.frame_size += count * 8;
4155 }
4156
4157
4158 /* Parse a directive saving VFP registers for pre-ARMv6.  */
4159
4160 static void
4161 s_arm_unwind_save_vfp (void)
4162 {
4163   int count;
4164   unsigned int reg;
4165   valueT op;
4166
4167   count = parse_vfp_reg_list (&input_line_pointer, &reg, REGLIST_VFP_D);
4168   if (count == FAIL)
4169     {
4170       as_bad (_("expected register list"));
4171       ignore_rest_of_line ();
4172       return;
4173     }
4174
4175   demand_empty_rest_of_line ();
4176
4177   if (reg == 8)
4178     {
4179       /* Short form.  */
4180       op = 0xb8 | (count - 1);
4181       add_unwind_opcode (op, 1);
4182     }
4183   else
4184     {
4185       /* Long form.  */
4186       op = 0xb300 | (reg << 4) | (count - 1);
4187       add_unwind_opcode (op, 2);
4188     }
4189   unwind.frame_size += count * 8 + 4;
4190 }
4191
4192
4193 /* Parse a directive saving iWMMXt data registers.  */
4194
4195 static void
4196 s_arm_unwind_save_mmxwr (void)
4197 {
4198   int reg;
4199   int hi_reg;
4200   int i;
4201   unsigned mask = 0;
4202   valueT op;
4203
4204   if (*input_line_pointer == '{')
4205     input_line_pointer++;
4206
4207   do
4208     {
4209       reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWR);
4210
4211       if (reg == FAIL)
4212         {
4213           as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWR]));
4214           goto error;
4215         }
4216
4217       if (mask >> reg)
4218         as_tsktsk (_("register list not in ascending order"));
4219       mask |= 1 << reg;
4220
4221       if (*input_line_pointer == '-')
4222         {
4223           input_line_pointer++;
4224           hi_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWR);
4225           if (hi_reg == FAIL)
4226             {
4227               as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWR]));
4228               goto error;
4229             }
4230           else if (reg >= hi_reg)
4231             {
4232               as_bad (_("bad register range"));
4233               goto error;
4234             }
4235           for (; reg < hi_reg; reg++)
4236             mask |= 1 << reg;
4237         }
4238     }
4239   while (skip_past_comma (&input_line_pointer) != FAIL);
4240
4241   skip_past_char (&input_line_pointer, '}');
4242
4243   demand_empty_rest_of_line ();
4244
4245   /* Generate any deferred opcodes because we're going to be looking at
4246      the list.  */
4247   flush_pending_unwind ();
4248
4249   for (i = 0; i < 16; i++)
4250     {
4251       if (mask & (1 << i))
4252         unwind.frame_size += 8;
4253     }
4254
4255   /* Attempt to combine with a previous opcode.  We do this because gcc
4256      likes to output separate unwind directives for a single block of
4257      registers.  */
4258   if (unwind.opcode_count > 0)
4259     {
4260       i = unwind.opcodes[unwind.opcode_count - 1];
4261       if ((i & 0xf8) == 0xc0)
4262         {
4263           i &= 7;
4264           /* Only merge if the blocks are contiguous.  */
4265           if (i < 6)
4266             {
4267               if ((mask & 0xfe00) == (1 << 9))
4268                 {
4269                   mask |= ((1 << (i + 11)) - 1) & 0xfc00;
4270                   unwind.opcode_count--;
4271                 }
4272             }
4273           else if (i == 6 && unwind.opcode_count >= 2)
4274             {
4275               i = unwind.opcodes[unwind.opcode_count - 2];
4276               reg = i >> 4;
4277               i &= 0xf;
4278
4279               op = 0xffff << (reg - 1);
4280               if (reg > 0
4281                   && ((mask & op) == (1u << (reg - 1))))
4282                 {
4283                   op = (1 << (reg + i + 1)) - 1;
4284                   op &= ~((1 << reg) - 1);
4285                   mask |= op;
4286                   unwind.opcode_count -= 2;
4287                 }
4288             }
4289         }
4290     }
4291
4292   hi_reg = 15;
4293   /* We want to generate opcodes in the order the registers have been
4294      saved, ie. descending order.  */
4295   for (reg = 15; reg >= -1; reg--)
4296     {
4297       /* Save registers in blocks.  */
4298       if (reg < 0
4299           || !(mask & (1 << reg)))
4300         {
4301           /* We found an unsaved reg.  Generate opcodes to save the
4302              preceding block.   */
4303           if (reg != hi_reg)
4304             {
4305               if (reg == 9)
4306                 {
4307                   /* Short form.  */
4308                   op = 0xc0 | (hi_reg - 10);
4309                   add_unwind_opcode (op, 1);
4310                 }
4311               else
4312                 {
4313                   /* Long form.  */
4314                   op = 0xc600 | ((reg + 1) << 4) | ((hi_reg - reg) - 1);
4315                   add_unwind_opcode (op, 2);
4316                 }
4317             }
4318           hi_reg = reg - 1;
4319         }
4320     }
4321
4322   return;
4323 error:
4324   ignore_rest_of_line ();
4325 }
4326
4327 static void
4328 s_arm_unwind_save_mmxwcg (void)
4329 {
4330   int reg;
4331   int hi_reg;
4332   unsigned mask = 0;
4333   valueT op;
4334
4335   if (*input_line_pointer == '{')
4336     input_line_pointer++;
4337
4338   skip_whitespace (input_line_pointer);
4339
4340   do
4341     {
4342       reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWCG);
4343
4344       if (reg == FAIL)
4345         {
4346           as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWCG]));
4347           goto error;
4348         }
4349
4350       reg -= 8;
4351       if (mask >> reg)
4352         as_tsktsk (_("register list not in ascending order"));
4353       mask |= 1 << reg;
4354
4355       if (*input_line_pointer == '-')
4356         {
4357           input_line_pointer++;
4358           hi_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWCG);
4359           if (hi_reg == FAIL)
4360             {
4361               as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWCG]));
4362               goto error;
4363             }
4364           else if (reg >= hi_reg)
4365             {
4366               as_bad (_("bad register range"));
4367               goto error;
4368             }
4369           for (; reg < hi_reg; reg++)
4370             mask |= 1 << reg;
4371         }
4372     }
4373   while (skip_past_comma (&input_line_pointer) != FAIL);
4374
4375   skip_past_char (&input_line_pointer, '}');
4376
4377   demand_empty_rest_of_line ();
4378
4379   /* Generate any deferred opcodes because we're going to be looking at
4380      the list.  */
4381   flush_pending_unwind ();
4382
4383   for (reg = 0; reg < 16; reg++)
4384     {
4385       if (mask & (1 << reg))
4386         unwind.frame_size += 4;
4387     }
4388   op = 0xc700 | mask;
4389   add_unwind_opcode (op, 2);
4390   return;
4391 error:
4392   ignore_rest_of_line ();
4393 }
4394
4395
4396 /* Parse an unwind_save directive.
4397    If the argument is non-zero, this is a .vsave directive.  */
4398
4399 static void
4400 s_arm_unwind_save (int arch_v6)
4401 {
4402   char *peek;
4403   struct reg_entry *reg;
4404   bfd_boolean had_brace = FALSE;
4405
4406   if (!unwind.proc_start)
4407     as_bad (MISSING_FNSTART);
4408
4409   /* Figure out what sort of save we have.  */
4410   peek = input_line_pointer;
4411
4412   if (*peek == '{')
4413     {
4414       had_brace = TRUE;
4415       peek++;
4416     }
4417
4418   reg = arm_reg_parse_multi (&peek);
4419
4420   if (!reg)
4421     {
4422       as_bad (_("register expected"));
4423       ignore_rest_of_line ();
4424       return;
4425     }
4426
4427   switch (reg->type)
4428     {
4429     case REG_TYPE_FN:
4430       if (had_brace)
4431         {
4432           as_bad (_("FPA .unwind_save does not take a register list"));
4433           ignore_rest_of_line ();
4434           return;
4435         }
4436       input_line_pointer = peek;
4437       s_arm_unwind_save_fpa (reg->number);
4438       return;
4439
4440     case REG_TYPE_RN:
4441       s_arm_unwind_save_core ();
4442       return;
4443
4444     case REG_TYPE_VFD:
4445       if (arch_v6)
4446         s_arm_unwind_save_vfp_armv6 ();
4447       else
4448         s_arm_unwind_save_vfp ();
4449       return;
4450
4451     case REG_TYPE_MMXWR:
4452       s_arm_unwind_save_mmxwr ();
4453       return;
4454
4455     case REG_TYPE_MMXWCG:
4456       s_arm_unwind_save_mmxwcg ();
4457       return;
4458
4459     default:
4460       as_bad (_(".unwind_save does not support this kind of register"));
4461       ignore_rest_of_line ();
4462     }
4463 }
4464
4465
4466 /* Parse an unwind_movsp directive.  */
4467
4468 static void
4469 s_arm_unwind_movsp (int ignored ATTRIBUTE_UNUSED)
4470 {
4471   int reg;
4472   valueT op;
4473   int offset;
4474
4475   if (!unwind.proc_start)
4476     as_bad (MISSING_FNSTART);
4477
4478   reg = arm_reg_parse (&input_line_pointer, REG_TYPE_RN);
4479   if (reg == FAIL)
4480     {
4481       as_bad ("%s", _(reg_expected_msgs[REG_TYPE_RN]));
4482       ignore_rest_of_line ();
4483       return;
4484     }
4485
4486   /* Optional constant.  */
4487   if (skip_past_comma (&input_line_pointer) != FAIL)
4488     {
4489       if (immediate_for_directive (&offset) == FAIL)
4490         return;
4491     }
4492   else
4493     offset = 0;
4494
4495   demand_empty_rest_of_line ();
4496
4497   if (reg == REG_SP || reg == REG_PC)
4498     {
4499       as_bad (_("SP and PC not permitted in .unwind_movsp directive"));
4500       return;
4501     }
4502
4503   if (unwind.fp_reg != REG_SP)
4504     as_bad (_("unexpected .unwind_movsp directive"));
4505
4506   /* Generate opcode to restore the value.  */
4507   op = 0x90 | reg;
4508   add_unwind_opcode (op, 1);
4509
4510   /* Record the information for later.  */
4511   unwind.fp_reg = reg;
4512   unwind.fp_offset = unwind.frame_size - offset;
4513   unwind.sp_restored = 1;
4514 }
4515
4516 /* Parse an unwind_pad directive.  */
4517
4518 static void
4519 s_arm_unwind_pad (int ignored ATTRIBUTE_UNUSED)
4520 {
4521   int offset;
4522
4523   if (!unwind.proc_start)
4524     as_bad (MISSING_FNSTART);
4525
4526   if (immediate_for_directive (&offset) == FAIL)
4527     return;
4528
4529   if (offset & 3)
4530     {
4531       as_bad (_("stack increment must be multiple of 4"));
4532       ignore_rest_of_line ();
4533       return;
4534     }
4535
4536   /* Don't generate any opcodes, just record the details for later.  */
4537   unwind.frame_size += offset;
4538   unwind.pending_offset += offset;
4539
4540   demand_empty_rest_of_line ();
4541 }
4542
4543 /* Parse an unwind_setfp directive.  */
4544
4545 static void
4546 s_arm_unwind_setfp (int ignored ATTRIBUTE_UNUSED)
4547 {
4548   int sp_reg;
4549   int fp_reg;
4550   int offset;
4551
4552   if (!unwind.proc_start)
4553     as_bad (MISSING_FNSTART);
4554
4555   fp_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_RN);
4556   if (skip_past_comma (&input_line_pointer) == FAIL)
4557     sp_reg = FAIL;
4558   else
4559     sp_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_RN);
4560
4561   if (fp_reg == FAIL || sp_reg == FAIL)
4562     {
4563       as_bad (_("expected <reg>, <reg>"));
4564       ignore_rest_of_line ();
4565       return;
4566     }
4567
4568   /* Optional constant.  */
4569   if (skip_past_comma (&input_line_pointer) != FAIL)
4570     {
4571       if (immediate_for_directive (&offset) == FAIL)
4572         return;
4573     }
4574   else
4575     offset = 0;
4576
4577   demand_empty_rest_of_line ();
4578
4579   if (sp_reg != REG_SP && sp_reg != unwind.fp_reg)
4580     {
4581       as_bad (_("register must be either sp or set by a previous"
4582                 "unwind_movsp directive"));
4583       return;
4584     }
4585
4586   /* Don't generate any opcodes, just record the information for later.  */
4587   unwind.fp_reg = fp_reg;
4588   unwind.fp_used = 1;
4589   if (sp_reg == REG_SP)
4590     unwind.fp_offset = unwind.frame_size - offset;
4591   else
4592     unwind.fp_offset -= offset;
4593 }
4594
4595 /* Parse an unwind_raw directive.  */
4596
4597 static void
4598 s_arm_unwind_raw (int ignored ATTRIBUTE_UNUSED)
4599 {
4600   expressionS exp;
4601   /* This is an arbitrary limit.         */
4602   unsigned char op[16];
4603   int count;
4604
4605   if (!unwind.proc_start)
4606     as_bad (MISSING_FNSTART);
4607
4608   expression (&exp);
4609   if (exp.X_op == O_constant
4610       && skip_past_comma (&input_line_pointer) != FAIL)
4611     {
4612       unwind.frame_size += exp.X_add_number;
4613       expression (&exp);
4614     }
4615   else
4616     exp.X_op = O_illegal;
4617
4618   if (exp.X_op != O_constant)
4619     {
4620       as_bad (_("expected <offset>, <opcode>"));
4621       ignore_rest_of_line ();
4622       return;
4623     }
4624
4625   count = 0;
4626
4627   /* Parse the opcode.  */
4628   for (;;)
4629     {
4630       if (count >= 16)
4631         {
4632           as_bad (_("unwind opcode too long"));
4633           ignore_rest_of_line ();
4634         }
4635       if (exp.X_op != O_constant || exp.X_add_number & ~0xff)
4636         {
4637           as_bad (_("invalid unwind opcode"));
4638           ignore_rest_of_line ();
4639           return;
4640         }
4641       op[count++] = exp.X_add_number;
4642
4643       /* Parse the next byte.  */
4644       if (skip_past_comma (&input_line_pointer) == FAIL)
4645         break;
4646
4647       expression (&exp);
4648     }
4649
4650   /* Add the opcode bytes in reverse order.  */
4651   while (count--)
4652     add_unwind_opcode (op[count], 1);
4653
4654   demand_empty_rest_of_line ();
4655 }
4656
4657
4658 /* Parse a .eabi_attribute directive.  */
4659
4660 static void
4661 s_arm_eabi_attribute (int ignored ATTRIBUTE_UNUSED)
4662 {
4663   int tag = obj_elf_vendor_attribute (OBJ_ATTR_PROC);
4664
4665   if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
4666     attributes_set_explicitly[tag] = 1;
4667 }
4668
4669 /* Emit a tls fix for the symbol.  */
4670
4671 static void
4672 s_arm_tls_descseq (int ignored ATTRIBUTE_UNUSED)
4673 {
4674   char *p;
4675   expressionS exp;
4676 #ifdef md_flush_pending_output
4677   md_flush_pending_output ();
4678 #endif
4679
4680 #ifdef md_cons_align
4681   md_cons_align (4);
4682 #endif
4683
4684   /* Since we're just labelling the code, there's no need to define a
4685      mapping symbol.  */
4686   expression (&exp);
4687   p = obstack_next_free (&frchain_now->frch_obstack);
4688   fix_new_arm (frag_now, p - frag_now->fr_literal, 4, &exp, 0,
4689                thumb_mode ? BFD_RELOC_ARM_THM_TLS_DESCSEQ
4690                : BFD_RELOC_ARM_TLS_DESCSEQ);
4691 }
4692 #endif /* OBJ_ELF */
4693
4694 static void s_arm_arch (int);
4695 static void s_arm_object_arch (int);
4696 static void s_arm_cpu (int);
4697 static void s_arm_fpu (int);
4698 static void s_arm_arch_extension (int);
4699
4700 #ifdef TE_PE
4701
4702 static void
4703 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED)
4704 {
4705   expressionS exp;
4706
4707   do
4708     {
4709       expression (&exp);
4710       if (exp.X_op == O_symbol)
4711         exp.X_op = O_secrel;
4712
4713       emit_expr (&exp, 4);
4714     }
4715   while (*input_line_pointer++ == ',');
4716
4717   input_line_pointer--;
4718   demand_empty_rest_of_line ();
4719 }
4720 #endif /* TE_PE */
4721
4722 /* This table describes all the machine specific pseudo-ops the assembler
4723    has to support.  The fields are:
4724      pseudo-op name without dot
4725      function to call to execute this pseudo-op
4726      Integer arg to pass to the function.  */
4727
4728 const pseudo_typeS md_pseudo_table[] =
4729 {
4730   /* Never called because '.req' does not start a line.  */
4731   { "req",         s_req,         0 },
4732   /* Following two are likewise never called.  */
4733   { "dn",          s_dn,          0 },
4734   { "qn",          s_qn,          0 },
4735   { "unreq",       s_unreq,       0 },
4736   { "bss",         s_bss,         0 },
4737   { "align",       s_align_ptwo,  2 },
4738   { "arm",         s_arm,         0 },
4739   { "thumb",       s_thumb,       0 },
4740   { "code",        s_code,        0 },
4741   { "force_thumb", s_force_thumb, 0 },
4742   { "thumb_func",  s_thumb_func,  0 },
4743   { "thumb_set",   s_thumb_set,   0 },
4744   { "even",        s_even,        0 },
4745   { "ltorg",       s_ltorg,       0 },
4746   { "pool",        s_ltorg,       0 },
4747   { "syntax",      s_syntax,      0 },
4748   { "cpu",         s_arm_cpu,     0 },
4749   { "arch",        s_arm_arch,    0 },
4750   { "object_arch", s_arm_object_arch,   0 },
4751   { "fpu",         s_arm_fpu,     0 },
4752   { "arch_extension", s_arm_arch_extension, 0 },
4753 #ifdef OBJ_ELF
4754   { "word",             s_arm_elf_cons, 4 },
4755   { "long",             s_arm_elf_cons, 4 },
4756   { "inst.n",           s_arm_elf_inst, 2 },
4757   { "inst.w",           s_arm_elf_inst, 4 },
4758   { "inst",             s_arm_elf_inst, 0 },
4759   { "rel31",            s_arm_rel31,      0 },
4760   { "fnstart",          s_arm_unwind_fnstart,   0 },
4761   { "fnend",            s_arm_unwind_fnend,     0 },
4762   { "cantunwind",       s_arm_unwind_cantunwind, 0 },
4763   { "personality",      s_arm_unwind_personality, 0 },
4764   { "personalityindex", s_arm_unwind_personalityindex, 0 },
4765   { "handlerdata",      s_arm_unwind_handlerdata, 0 },
4766   { "save",             s_arm_unwind_save,      0 },
4767   { "vsave",            s_arm_unwind_save,      1 },
4768   { "movsp",            s_arm_unwind_movsp,     0 },
4769   { "pad",              s_arm_unwind_pad,       0 },
4770   { "setfp",            s_arm_unwind_setfp,     0 },
4771   { "unwind_raw",       s_arm_unwind_raw,       0 },
4772   { "eabi_attribute",   s_arm_eabi_attribute,   0 },
4773   { "tlsdescseq",       s_arm_tls_descseq,      0 },
4774 #else
4775   { "word",        cons, 4},
4776
4777   /* These are used for dwarf.  */
4778   {"2byte", cons, 2},
4779   {"4byte", cons, 4},
4780   {"8byte", cons, 8},
4781   /* These are used for dwarf2.  */
4782   { "file", dwarf2_directive_file, 0 },
4783   { "loc",  dwarf2_directive_loc,  0 },
4784   { "loc_mark_labels", dwarf2_directive_loc_mark_labels, 0 },
4785 #endif
4786   { "extend",      float_cons, 'x' },
4787   { "ldouble",     float_cons, 'x' },
4788   { "packed",      float_cons, 'p' },
4789 #ifdef TE_PE
4790   {"secrel32", pe_directive_secrel, 0},
4791 #endif
4792
4793   /* These are for compatibility with CodeComposer Studio.  */
4794   {"ref",          s_ccs_ref,        0},
4795   {"def",          s_ccs_def,        0},
4796   {"asmfunc",      s_ccs_asmfunc,    0},
4797   {"endasmfunc",   s_ccs_endasmfunc, 0},
4798
4799   { 0, 0, 0 }
4800 };
4801 \f
4802 /* Parser functions used exclusively in instruction operands.  */
4803
4804 /* Generic immediate-value read function for use in insn parsing.
4805    STR points to the beginning of the immediate (the leading #);
4806    VAL receives the value; if the value is outside [MIN, MAX]
4807    issue an error.  PREFIX_OPT is true if the immediate prefix is
4808    optional.  */
4809
4810 static int
4811 parse_immediate (char **str, int *val, int min, int max,
4812                  bfd_boolean prefix_opt)
4813 {
4814   expressionS exp;
4815
4816   my_get_expression (&exp, str, prefix_opt ? GE_OPT_PREFIX : GE_IMM_PREFIX);
4817   if (exp.X_op != O_constant)
4818     {
4819       inst.error = _("constant expression required");
4820       return FAIL;
4821     }
4822
4823   if (exp.X_add_number < min || exp.X_add_number > max)
4824     {
4825       inst.error = _("immediate value out of range");
4826       return FAIL;
4827     }
4828
4829   *val = exp.X_add_number;
4830   return SUCCESS;
4831 }
4832
4833 /* Less-generic immediate-value read function with the possibility of loading a
4834    big (64-bit) immediate, as required by Neon VMOV, VMVN and logic immediate
4835    instructions. Puts the result directly in inst.operands[i].  */
4836
4837 static int
4838 parse_big_immediate (char **str, int i, expressionS *in_exp,
4839                      bfd_boolean allow_symbol_p)
4840 {
4841   expressionS exp;
4842   expressionS *exp_p = in_exp ? in_exp : &exp;
4843   char *ptr = *str;
4844
4845   my_get_expression (exp_p, &ptr, GE_OPT_PREFIX_BIG);
4846
4847   if (exp_p->X_op == O_constant)
4848     {
4849       inst.operands[i].imm = exp_p->X_add_number & 0xffffffff;
4850       /* If we're on a 64-bit host, then a 64-bit number can be returned using
4851          O_constant.  We have to be careful not to break compilation for
4852          32-bit X_add_number, though.  */
4853       if ((exp_p->X_add_number & ~(offsetT)(0xffffffffU)) != 0)
4854         {
4855           /* X >> 32 is illegal if sizeof (exp_p->X_add_number) == 4.  */
4856           inst.operands[i].reg = (((exp_p->X_add_number >> 16) >> 16)
4857                                   & 0xffffffff);
4858           inst.operands[i].regisimm = 1;
4859         }
4860     }
4861   else if (exp_p->X_op == O_big
4862            && LITTLENUM_NUMBER_OF_BITS * exp_p->X_add_number > 32)
4863     {
4864       unsigned parts = 32 / LITTLENUM_NUMBER_OF_BITS, j, idx = 0;
4865
4866       /* Bignums have their least significant bits in
4867          generic_bignum[0]. Make sure we put 32 bits in imm and
4868          32 bits in reg,  in a (hopefully) portable way.  */
4869       gas_assert (parts != 0);
4870
4871       /* Make sure that the number is not too big.
4872          PR 11972: Bignums can now be sign-extended to the
4873          size of a .octa so check that the out of range bits
4874          are all zero or all one.  */
4875       if (LITTLENUM_NUMBER_OF_BITS * exp_p->X_add_number > 64)
4876         {
4877           LITTLENUM_TYPE m = -1;
4878
4879           if (generic_bignum[parts * 2] != 0
4880               && generic_bignum[parts * 2] != m)
4881             return FAIL;
4882
4883           for (j = parts * 2 + 1; j < (unsigned) exp_p->X_add_number; j++)
4884             if (generic_bignum[j] != generic_bignum[j-1])
4885               return FAIL;
4886         }
4887
4888       inst.operands[i].imm = 0;
4889       for (j = 0; j < parts; j++, idx++)
4890         inst.operands[i].imm |= generic_bignum[idx]
4891                                 << (LITTLENUM_NUMBER_OF_BITS * j);
4892       inst.operands[i].reg = 0;
4893       for (j = 0; j < parts; j++, idx++)
4894         inst.operands[i].reg |= generic_bignum[idx]
4895                                 << (LITTLENUM_NUMBER_OF_BITS * j);
4896       inst.operands[i].regisimm = 1;
4897     }
4898   else if (!(exp_p->X_op == O_symbol && allow_symbol_p))
4899     return FAIL;
4900
4901   *str = ptr;
4902
4903   return SUCCESS;
4904 }
4905
4906 /* Returns the pseudo-register number of an FPA immediate constant,
4907    or FAIL if there isn't a valid constant here.  */
4908
4909 static int
4910 parse_fpa_immediate (char ** str)
4911 {
4912   LITTLENUM_TYPE words[MAX_LITTLENUMS];
4913   char *         save_in;
4914   expressionS    exp;
4915   int            i;
4916   int            j;
4917
4918   /* First try and match exact strings, this is to guarantee
4919      that some formats will work even for cross assembly.  */
4920
4921   for (i = 0; fp_const[i]; i++)
4922     {
4923       if (strncmp (*str, fp_const[i], strlen (fp_const[i])) == 0)
4924         {
4925           char *start = *str;
4926
4927           *str += strlen (fp_const[i]);
4928           if (is_end_of_line[(unsigned char) **str])
4929             return i + 8;
4930           *str = start;
4931         }
4932     }
4933
4934   /* Just because we didn't get a match doesn't mean that the constant
4935      isn't valid, just that it is in a format that we don't
4936      automatically recognize.  Try parsing it with the standard
4937      expression routines.  */
4938
4939   memset (words, 0, MAX_LITTLENUMS * sizeof (LITTLENUM_TYPE));
4940
4941   /* Look for a raw floating point number.  */
4942   if ((save_in = atof_ieee (*str, 'x', words)) != NULL
4943       && is_end_of_line[(unsigned char) *save_in])
4944     {
4945       for (i = 0; i < NUM_FLOAT_VALS; i++)
4946         {
4947           for (j = 0; j < MAX_LITTLENUMS; j++)
4948             {
4949               if (words[j] != fp_values[i][j])
4950                 break;
4951             }
4952
4953           if (j == MAX_LITTLENUMS)
4954             {
4955               *str = save_in;
4956               return i + 8;
4957             }
4958         }
4959     }
4960
4961   /* Try and parse a more complex expression, this will probably fail
4962      unless the code uses a floating point prefix (eg "0f").  */
4963   save_in = input_line_pointer;
4964   input_line_pointer = *str;
4965   if (expression (&exp) == absolute_section
4966       && exp.X_op == O_big
4967       && exp.X_add_number < 0)
4968     {
4969       /* FIXME: 5 = X_PRECISION, should be #define'd where we can use it.
4970          Ditto for 15.  */
4971 #define X_PRECISION 5
4972 #define E_PRECISION 15L
4973       if (gen_to_words (words, X_PRECISION, E_PRECISION) == 0)
4974         {
4975           for (i = 0; i < NUM_FLOAT_VALS; i++)
4976             {
4977               for (j = 0; j < MAX_LITTLENUMS; j++)
4978                 {
4979                   if (words[j] != fp_values[i][j])
4980                     break;
4981                 }
4982
4983               if (j == MAX_LITTLENUMS)
4984                 {
4985                   *str = input_line_pointer;
4986                   input_line_pointer = save_in;
4987                   return i + 8;
4988                 }
4989             }
4990         }
4991     }
4992
4993   *str = input_line_pointer;
4994   input_line_pointer = save_in;
4995   inst.error = _("invalid FPA immediate expression");
4996   return FAIL;
4997 }
4998
4999 /* Returns 1 if a number has "quarter-precision" float format
5000    0baBbbbbbc defgh000 00000000 00000000.  */
5001
5002 static int
5003 is_quarter_float (unsigned imm)
5004 {
5005   int bs = (imm & 0x20000000) ? 0x3e000000 : 0x40000000;
5006   return (imm & 0x7ffff) == 0 && ((imm & 0x7e000000) ^ bs) == 0;
5007 }
5008
5009
5010 /* Detect the presence of a floating point or integer zero constant,
5011    i.e. #0.0 or #0.  */
5012
5013 static bfd_boolean
5014 parse_ifimm_zero (char **in)
5015 {
5016   int error_code;
5017
5018   if (!is_immediate_prefix (**in))
5019     {
5020       /* In unified syntax, all prefixes are optional.  */
5021       if (!unified_syntax)
5022         return FALSE;
5023     }
5024   else
5025     ++*in;
5026
5027   /* Accept #0x0 as a synonym for #0.  */
5028   if (strncmp (*in, "0x", 2) == 0)
5029     {
5030       int val;
5031       if (parse_immediate (in, &val, 0, 0, TRUE) == FAIL)
5032         return FALSE;
5033       return TRUE;
5034     }
5035
5036   error_code = atof_generic (in, ".", EXP_CHARS,
5037                              &generic_floating_point_number);
5038
5039   if (!error_code
5040       && generic_floating_point_number.sign == '+'
5041       && (generic_floating_point_number.low
5042           > generic_floating_point_number.leader))
5043     return TRUE;
5044
5045   return FALSE;
5046 }
5047
5048 /* Parse an 8-bit "quarter-precision" floating point number of the form:
5049    0baBbbbbbc defgh000 00000000 00000000.
5050    The zero and minus-zero cases need special handling, since they can't be
5051    encoded in the "quarter-precision" float format, but can nonetheless be
5052    loaded as integer constants.  */
5053
5054 static unsigned
5055 parse_qfloat_immediate (char **ccp, int *immed)
5056 {
5057   char *str = *ccp;
5058   char *fpnum;
5059   LITTLENUM_TYPE words[MAX_LITTLENUMS];
5060   int found_fpchar = 0;
5061
5062   skip_past_char (&str, '#');
5063
5064   /* We must not accidentally parse an integer as a floating-point number. Make
5065      sure that the value we parse is not an integer by checking for special
5066      characters '.' or 'e'.
5067      FIXME: This is a horrible hack, but doing better is tricky because type
5068      information isn't in a very usable state at parse time.  */
5069   fpnum = str;
5070   skip_whitespace (fpnum);
5071
5072   if (strncmp (fpnum, "0x", 2) == 0)
5073     return FAIL;
5074   else
5075     {
5076       for (; *fpnum != '\0' && *fpnum != ' ' && *fpnum != '\n'; fpnum++)
5077         if (*fpnum == '.' || *fpnum == 'e' || *fpnum == 'E')
5078           {
5079             found_fpchar = 1;
5080             break;
5081           }
5082
5083       if (!found_fpchar)
5084         return FAIL;
5085     }
5086
5087   if ((str = atof_ieee (str, 's', words)) != NULL)
5088     {
5089       unsigned fpword = 0;
5090       int i;
5091
5092       /* Our FP word must be 32 bits (single-precision FP).  */
5093       for (i = 0; i < 32 / LITTLENUM_NUMBER_OF_BITS; i++)
5094         {
5095           fpword <<= LITTLENUM_NUMBER_OF_BITS;
5096           fpword |= words[i];
5097         }
5098
5099       if (is_quarter_float (fpword) || (fpword & 0x7fffffff) == 0)
5100         *immed = fpword;
5101       else
5102         return FAIL;
5103
5104       *ccp = str;
5105
5106       return SUCCESS;
5107     }
5108
5109   return FAIL;
5110 }
5111
5112 /* Shift operands.  */
5113 enum shift_kind
5114 {
5115   SHIFT_LSL, SHIFT_LSR, SHIFT_ASR, SHIFT_ROR, SHIFT_RRX
5116 };
5117
5118 struct asm_shift_name
5119 {
5120   const char      *name;
5121   enum shift_kind  kind;
5122 };
5123
5124 /* Third argument to parse_shift.  */
5125 enum parse_shift_mode
5126 {
5127   NO_SHIFT_RESTRICT,            /* Any kind of shift is accepted.  */
5128   SHIFT_IMMEDIATE,              /* Shift operand must be an immediate.  */
5129   SHIFT_LSL_OR_ASR_IMMEDIATE,   /* Shift must be LSL or ASR immediate.  */
5130   SHIFT_ASR_IMMEDIATE,          /* Shift must be ASR immediate.  */
5131   SHIFT_LSL_IMMEDIATE,          /* Shift must be LSL immediate.  */
5132 };
5133
5134 /* Parse a <shift> specifier on an ARM data processing instruction.
5135    This has three forms:
5136
5137      (LSL|LSR|ASL|ASR|ROR) Rs
5138      (LSL|LSR|ASL|ASR|ROR) #imm
5139      RRX
5140
5141    Note that ASL is assimilated to LSL in the instruction encoding, and
5142    RRX to ROR #0 (which cannot be written as such).  */
5143
5144 static int
5145 parse_shift (char **str, int i, enum parse_shift_mode mode)
5146 {
5147   const struct asm_shift_name *shift_name;
5148   enum shift_kind shift;
5149   char *s = *str;
5150   char *p = s;
5151   int reg;
5152
5153   for (p = *str; ISALPHA (*p); p++)
5154     ;
5155
5156   if (p == *str)
5157     {
5158       inst.error = _("shift expression expected");
5159       return FAIL;
5160     }
5161
5162   shift_name = (const struct asm_shift_name *) hash_find_n (arm_shift_hsh, *str,
5163                                                             p - *str);
5164
5165   if (shift_name == NULL)
5166     {
5167       inst.error = _("shift expression expected");
5168       return FAIL;
5169     }
5170
5171   shift = shift_name->kind;
5172
5173   switch (mode)
5174     {
5175     case NO_SHIFT_RESTRICT:
5176     case SHIFT_IMMEDIATE:   break;
5177
5178     case SHIFT_LSL_OR_ASR_IMMEDIATE:
5179       if (shift != SHIFT_LSL && shift != SHIFT_ASR)
5180         {
5181           inst.error = _("'LSL' or 'ASR' required");
5182           return FAIL;
5183         }
5184       break;
5185
5186     case SHIFT_LSL_IMMEDIATE:
5187       if (shift != SHIFT_LSL)
5188         {
5189           inst.error = _("'LSL' required");
5190           return FAIL;
5191         }
5192       break;
5193
5194     case SHIFT_ASR_IMMEDIATE:
5195       if (shift != SHIFT_ASR)
5196         {
5197           inst.error = _("'ASR' required");
5198           return FAIL;
5199         }
5200       break;
5201
5202     default: abort ();
5203     }
5204
5205   if (shift != SHIFT_RRX)
5206     {
5207       /* Whitespace can appear here if the next thing is a bare digit.  */
5208       skip_whitespace (p);
5209
5210       if (mode == NO_SHIFT_RESTRICT
5211           && (reg = arm_reg_parse (&p, REG_TYPE_RN)) != FAIL)
5212         {
5213           inst.operands[i].imm = reg;
5214           inst.operands[i].immisreg = 1;
5215         }
5216       else if (my_get_expression (&inst.relocs[0].exp, &p, GE_IMM_PREFIX))
5217         return FAIL;
5218     }
5219   inst.operands[i].shift_kind = shift;
5220   inst.operands[i].shifted = 1;
5221   *str = p;
5222   return SUCCESS;
5223 }
5224
5225 /* Parse a <shifter_operand> for an ARM data processing instruction:
5226
5227       #<immediate>
5228       #<immediate>, <rotate>
5229       <Rm>
5230       <Rm>, <shift>
5231
5232    where <shift> is defined by parse_shift above, and <rotate> is a
5233    multiple of 2 between 0 and 30.  Validation of immediate operands
5234    is deferred to md_apply_fix.  */
5235
5236 static int
5237 parse_shifter_operand (char **str, int i)
5238 {
5239   int value;
5240   expressionS exp;
5241
5242   if ((value = arm_reg_parse (str, REG_TYPE_RN)) != FAIL)
5243     {
5244       inst.operands[i].reg = value;
5245       inst.operands[i].isreg = 1;
5246
5247       /* parse_shift will override this if appropriate */
5248       inst.relocs[0].exp.X_op = O_constant;
5249       inst.relocs[0].exp.X_add_number = 0;
5250
5251       if (skip_past_comma (str) == FAIL)
5252         return SUCCESS;
5253
5254       /* Shift operation on register.  */
5255       return parse_shift (str, i, NO_SHIFT_RESTRICT);
5256     }
5257
5258   if (my_get_expression (&inst.relocs[0].exp, str, GE_IMM_PREFIX))
5259     return FAIL;
5260
5261   if (skip_past_comma (str) == SUCCESS)
5262     {
5263       /* #x, y -- ie explicit rotation by Y.  */
5264       if (my_get_expression (&exp, str, GE_NO_PREFIX))
5265         return FAIL;
5266
5267       if (exp.X_op != O_constant || inst.relocs[0].exp.X_op != O_constant)
5268         {
5269           inst.error = _("constant expression expected");
5270           return FAIL;
5271         }
5272
5273       value = exp.X_add_number;
5274       if (value < 0 || value > 30 || value % 2 != 0)
5275         {
5276           inst.error = _("invalid rotation");
5277           return FAIL;
5278         }
5279       if (inst.relocs[0].exp.X_add_number < 0
5280           || inst.relocs[0].exp.X_add_number > 255)
5281         {
5282           inst.error = _("invalid constant");
5283           return FAIL;
5284         }
5285
5286       /* Encode as specified.  */
5287       inst.operands[i].imm = inst.relocs[0].exp.X_add_number | value << 7;
5288       return SUCCESS;
5289     }
5290
5291   inst.relocs[0].type = BFD_RELOC_ARM_IMMEDIATE;
5292   inst.relocs[0].pc_rel = 0;
5293   return SUCCESS;
5294 }
5295
5296 /* Group relocation information.  Each entry in the table contains the
5297    textual name of the relocation as may appear in assembler source
5298    and must end with a colon.
5299    Along with this textual name are the relocation codes to be used if
5300    the corresponding instruction is an ALU instruction (ADD or SUB only),
5301    an LDR, an LDRS, or an LDC.  */
5302
5303 struct group_reloc_table_entry
5304 {
5305   const char *name;
5306   int alu_code;
5307   int ldr_code;
5308   int ldrs_code;
5309   int ldc_code;
5310 };
5311
5312 typedef enum
5313 {
5314   /* Varieties of non-ALU group relocation.  */
5315
5316   GROUP_LDR,
5317   GROUP_LDRS,
5318   GROUP_LDC
5319 } group_reloc_type;
5320
5321 static struct group_reloc_table_entry group_reloc_table[] =
5322   { /* Program counter relative: */
5323     { "pc_g0_nc",
5324       BFD_RELOC_ARM_ALU_PC_G0_NC,       /* ALU */
5325       0,                                /* LDR */
5326       0,                                /* LDRS */
5327       0 },                              /* LDC */
5328     { "pc_g0",
5329       BFD_RELOC_ARM_ALU_PC_G0,          /* ALU */
5330       BFD_RELOC_ARM_LDR_PC_G0,          /* LDR */
5331       BFD_RELOC_ARM_LDRS_PC_G0,         /* LDRS */
5332       BFD_RELOC_ARM_LDC_PC_G0 },        /* LDC */
5333     { "pc_g1_nc",
5334       BFD_RELOC_ARM_ALU_PC_G1_NC,       /* ALU */
5335       0,                                /* LDR */
5336       0,                                /* LDRS */
5337       0 },                              /* LDC */
5338     { "pc_g1",
5339       BFD_RELOC_ARM_ALU_PC_G1,          /* ALU */
5340       BFD_RELOC_ARM_LDR_PC_G1,          /* LDR */
5341       BFD_RELOC_ARM_LDRS_PC_G1,         /* LDRS */
5342       BFD_RELOC_ARM_LDC_PC_G1 },        /* LDC */
5343     { "pc_g2",
5344       BFD_RELOC_ARM_ALU_PC_G2,          /* ALU */
5345       BFD_RELOC_ARM_LDR_PC_G2,          /* LDR */
5346       BFD_RELOC_ARM_LDRS_PC_G2,         /* LDRS */
5347       BFD_RELOC_ARM_LDC_PC_G2 },        /* LDC */
5348     /* Section base relative */
5349     { "sb_g0_nc",
5350       BFD_RELOC_ARM_ALU_SB_G0_NC,       /* ALU */
5351       0,                                /* LDR */
5352       0,                                /* LDRS */
5353       0 },                              /* LDC */
5354     { "sb_g0",
5355       BFD_RELOC_ARM_ALU_SB_G0,          /* ALU */
5356       BFD_RELOC_ARM_LDR_SB_G0,          /* LDR */
5357       BFD_RELOC_ARM_LDRS_SB_G0,         /* LDRS */
5358       BFD_RELOC_ARM_LDC_SB_G0 },        /* LDC */
5359     { "sb_g1_nc",
5360       BFD_RELOC_ARM_ALU_SB_G1_NC,       /* ALU */
5361       0,                                /* LDR */
5362       0,                                /* LDRS */
5363       0 },                              /* LDC */
5364     { "sb_g1",
5365       BFD_RELOC_ARM_ALU_SB_G1,          /* ALU */
5366       BFD_RELOC_ARM_LDR_SB_G1,          /* LDR */
5367       BFD_RELOC_ARM_LDRS_SB_G1,         /* LDRS */
5368       BFD_RELOC_ARM_LDC_SB_G1 },        /* LDC */
5369     { "sb_g2",
5370       BFD_RELOC_ARM_ALU_SB_G2,          /* ALU */
5371       BFD_RELOC_ARM_LDR_SB_G2,          /* LDR */
5372       BFD_RELOC_ARM_LDRS_SB_G2,         /* LDRS */
5373       BFD_RELOC_ARM_LDC_SB_G2 },        /* LDC */
5374     /* Absolute thumb alu relocations.  */
5375     { "lower0_7",
5376       BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC,/* ALU.  */
5377       0,                                /* LDR.  */
5378       0,                                /* LDRS.  */
5379       0 },                              /* LDC.  */
5380     { "lower8_15",
5381       BFD_RELOC_ARM_THUMB_ALU_ABS_G1_NC,/* ALU.  */
5382       0,                                /* LDR.  */
5383       0,                                /* LDRS.  */
5384       0 },                              /* LDC.  */
5385     { "upper0_7",
5386       BFD_RELOC_ARM_THUMB_ALU_ABS_G2_NC,/* ALU.  */
5387       0,                                /* LDR.  */
5388       0,                                /* LDRS.  */
5389       0 },                              /* LDC.  */
5390     { "upper8_15",
5391       BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC,/* ALU.  */
5392       0,                                /* LDR.  */
5393       0,                                /* LDRS.  */
5394       0 } };                            /* LDC.  */
5395
5396 /* Given the address of a pointer pointing to the textual name of a group
5397    relocation as may appear in assembler source, attempt to find its details
5398    in group_reloc_table.  The pointer will be updated to the character after
5399    the trailing colon.  On failure, FAIL will be returned; SUCCESS
5400    otherwise.  On success, *entry will be updated to point at the relevant
5401    group_reloc_table entry. */
5402
5403 static int
5404 find_group_reloc_table_entry (char **str, struct group_reloc_table_entry **out)
5405 {
5406   unsigned int i;
5407   for (i = 0; i < ARRAY_SIZE (group_reloc_table); i++)
5408     {
5409       int length = strlen (group_reloc_table[i].name);
5410
5411       if (strncasecmp (group_reloc_table[i].name, *str, length) == 0
5412           && (*str)[length] == ':')
5413         {
5414           *out = &group_reloc_table[i];
5415           *str += (length + 1);
5416           return SUCCESS;
5417         }
5418     }
5419
5420   return FAIL;
5421 }
5422
5423 /* Parse a <shifter_operand> for an ARM data processing instruction
5424    (as for parse_shifter_operand) where group relocations are allowed:
5425
5426       #<immediate>
5427       #<immediate>, <rotate>
5428       #:<group_reloc>:<expression>
5429       <Rm>
5430       <Rm>, <shift>
5431
5432    where <group_reloc> is one of the strings defined in group_reloc_table.
5433    The hashes are optional.
5434
5435    Everything else is as for parse_shifter_operand.  */
5436
5437 static parse_operand_result
5438 parse_shifter_operand_group_reloc (char **str, int i)
5439 {
5440   /* Determine if we have the sequence of characters #: or just :
5441      coming next.  If we do, then we check for a group relocation.
5442      If we don't, punt the whole lot to parse_shifter_operand.  */
5443
5444   if (((*str)[0] == '#' && (*str)[1] == ':')
5445       || (*str)[0] == ':')
5446     {
5447       struct group_reloc_table_entry *entry;
5448
5449       if ((*str)[0] == '#')
5450         (*str) += 2;
5451       else
5452         (*str)++;
5453
5454       /* Try to parse a group relocation.  Anything else is an error.  */
5455       if (find_group_reloc_table_entry (str, &entry) == FAIL)
5456         {
5457           inst.error = _("unknown group relocation");
5458           return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5459         }
5460
5461       /* We now have the group relocation table entry corresponding to
5462          the name in the assembler source.  Next, we parse the expression.  */
5463       if (my_get_expression (&inst.relocs[0].exp, str, GE_NO_PREFIX))
5464         return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5465
5466       /* Record the relocation type (always the ALU variant here).  */
5467       inst.relocs[0].type = (bfd_reloc_code_real_type) entry->alu_code;
5468       gas_assert (inst.relocs[0].type != 0);
5469
5470       return PARSE_OPERAND_SUCCESS;
5471     }
5472   else
5473     return parse_shifter_operand (str, i) == SUCCESS
5474            ? PARSE_OPERAND_SUCCESS : PARSE_OPERAND_FAIL;
5475
5476   /* Never reached.  */
5477 }
5478
5479 /* Parse a Neon alignment expression.  Information is written to
5480    inst.operands[i].  We assume the initial ':' has been skipped.
5481
5482    align        .imm = align << 8, .immisalign=1, .preind=0  */
5483 static parse_operand_result
5484 parse_neon_alignment (char **str, int i)
5485 {
5486   char *p = *str;
5487   expressionS exp;
5488
5489   my_get_expression (&exp, &p, GE_NO_PREFIX);
5490
5491   if (exp.X_op != O_constant)
5492     {
5493       inst.error = _("alignment must be constant");
5494       return PARSE_OPERAND_FAIL;
5495     }
5496
5497   inst.operands[i].imm = exp.X_add_number << 8;
5498   inst.operands[i].immisalign = 1;
5499   /* Alignments are not pre-indexes.  */
5500   inst.operands[i].preind = 0;
5501
5502   *str = p;
5503   return PARSE_OPERAND_SUCCESS;
5504 }
5505
5506 /* Parse all forms of an ARM address expression.  Information is written
5507    to inst.operands[i] and/or inst.relocs[0].
5508
5509    Preindexed addressing (.preind=1):
5510
5511    [Rn, #offset]       .reg=Rn .relocs[0].exp=offset
5512    [Rn, +/-Rm]         .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5513    [Rn, +/-Rm, shift]  .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5514                        .shift_kind=shift .relocs[0].exp=shift_imm
5515
5516    These three may have a trailing ! which causes .writeback to be set also.
5517
5518    Postindexed addressing (.postind=1, .writeback=1):
5519
5520    [Rn], #offset       .reg=Rn .relocs[0].exp=offset
5521    [Rn], +/-Rm         .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5522    [Rn], +/-Rm, shift  .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5523                        .shift_kind=shift .relocs[0].exp=shift_imm
5524
5525    Unindexed addressing (.preind=0, .postind=0):
5526
5527    [Rn], {option}      .reg=Rn .imm=option .immisreg=0
5528
5529    Other:
5530
5531    [Rn]{!}             shorthand for [Rn,#0]{!}
5532    =immediate          .isreg=0 .relocs[0].exp=immediate
5533    label               .reg=PC .relocs[0].pc_rel=1 .relocs[0].exp=label
5534
5535   It is the caller's responsibility to check for addressing modes not
5536   supported by the instruction, and to set inst.relocs[0].type.  */
5537
5538 static parse_operand_result
5539 parse_address_main (char **str, int i, int group_relocations,
5540                     group_reloc_type group_type)
5541 {
5542   char *p = *str;
5543   int reg;
5544
5545   if (skip_past_char (&p, '[') == FAIL)
5546     {
5547       if (skip_past_char (&p, '=') == FAIL)
5548         {
5549           /* Bare address - translate to PC-relative offset.  */
5550           inst.relocs[0].pc_rel = 1;
5551           inst.operands[i].reg = REG_PC;
5552           inst.operands[i].isreg = 1;
5553           inst.operands[i].preind = 1;
5554
5555           if (my_get_expression (&inst.relocs[0].exp, &p, GE_OPT_PREFIX_BIG))
5556             return PARSE_OPERAND_FAIL;
5557         }
5558       else if (parse_big_immediate (&p, i, &inst.relocs[0].exp,
5559                                     /*allow_symbol_p=*/TRUE))
5560         return PARSE_OPERAND_FAIL;
5561
5562       *str = p;
5563       return PARSE_OPERAND_SUCCESS;
5564     }
5565
5566   /* PR gas/14887: Allow for whitespace after the opening bracket.  */
5567   skip_whitespace (p);
5568
5569   if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) == FAIL)
5570     {
5571       inst.error = _(reg_expected_msgs[REG_TYPE_RN]);
5572       return PARSE_OPERAND_FAIL;
5573     }
5574   inst.operands[i].reg = reg;
5575   inst.operands[i].isreg = 1;
5576
5577   if (skip_past_comma (&p) == SUCCESS)
5578     {
5579       inst.operands[i].preind = 1;
5580
5581       if (*p == '+') p++;
5582       else if (*p == '-') p++, inst.operands[i].negative = 1;
5583
5584       if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) != FAIL)
5585         {
5586           inst.operands[i].imm = reg;
5587           inst.operands[i].immisreg = 1;
5588
5589           if (skip_past_comma (&p) == SUCCESS)
5590             if (parse_shift (&p, i, SHIFT_IMMEDIATE) == FAIL)
5591               return PARSE_OPERAND_FAIL;
5592         }
5593       else if (skip_past_char (&p, ':') == SUCCESS)
5594         {
5595           /* FIXME: '@' should be used here, but it's filtered out by generic
5596              code before we get to see it here. This may be subject to
5597              change.  */
5598           parse_operand_result result = parse_neon_alignment (&p, i);
5599
5600           if (result != PARSE_OPERAND_SUCCESS)
5601             return result;
5602         }
5603       else
5604         {
5605           if (inst.operands[i].negative)
5606             {
5607               inst.operands[i].negative = 0;
5608               p--;
5609             }
5610
5611           if (group_relocations
5612               && ((*p == '#' && *(p + 1) == ':') || *p == ':'))
5613             {
5614               struct group_reloc_table_entry *entry;
5615
5616               /* Skip over the #: or : sequence.  */
5617               if (*p == '#')
5618                 p += 2;
5619               else
5620                 p++;
5621
5622               /* Try to parse a group relocation.  Anything else is an
5623                  error.  */
5624               if (find_group_reloc_table_entry (&p, &entry) == FAIL)
5625                 {
5626                   inst.error = _("unknown group relocation");
5627                   return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5628                 }
5629
5630               /* We now have the group relocation table entry corresponding to
5631                  the name in the assembler source.  Next, we parse the
5632                  expression.  */
5633               if (my_get_expression (&inst.relocs[0].exp, &p, GE_NO_PREFIX))
5634                 return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5635
5636               /* Record the relocation type.  */
5637               switch (group_type)
5638                 {
5639                   case GROUP_LDR:
5640                     inst.relocs[0].type
5641                         = (bfd_reloc_code_real_type) entry->ldr_code;
5642                     break;
5643
5644                   case GROUP_LDRS:
5645                     inst.relocs[0].type
5646                         = (bfd_reloc_code_real_type) entry->ldrs_code;
5647                     break;
5648
5649                   case GROUP_LDC:
5650                     inst.relocs[0].type
5651                         = (bfd_reloc_code_real_type) entry->ldc_code;
5652                     break;
5653
5654                   default:
5655                     gas_assert (0);
5656                 }
5657
5658               if (inst.relocs[0].type == 0)
5659                 {
5660                   inst.error = _("this group relocation is not allowed on this instruction");
5661                   return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5662                 }
5663             }
5664           else
5665             {
5666               char *q = p;
5667
5668               if (my_get_expression (&inst.relocs[0].exp, &p, GE_IMM_PREFIX))
5669                 return PARSE_OPERAND_FAIL;
5670               /* If the offset is 0, find out if it's a +0 or -0.  */
5671               if (inst.relocs[0].exp.X_op == O_constant
5672                   && inst.relocs[0].exp.X_add_number == 0)
5673                 {
5674                   skip_whitespace (q);
5675                   if (*q == '#')
5676                     {
5677                       q++;
5678                       skip_whitespace (q);
5679                     }
5680                   if (*q == '-')
5681                     inst.operands[i].negative = 1;
5682                 }
5683             }
5684         }
5685     }
5686   else if (skip_past_char (&p, ':') == SUCCESS)
5687     {
5688       /* FIXME: '@' should be used here, but it's filtered out by generic code
5689          before we get to see it here. This may be subject to change.  */
5690       parse_operand_result result = parse_neon_alignment (&p, i);
5691
5692       if (result != PARSE_OPERAND_SUCCESS)
5693         return result;
5694     }
5695
5696   if (skip_past_char (&p, ']') == FAIL)
5697     {
5698       inst.error = _("']' expected");
5699       return PARSE_OPERAND_FAIL;
5700     }
5701
5702   if (skip_past_char (&p, '!') == SUCCESS)
5703     inst.operands[i].writeback = 1;
5704
5705   else if (skip_past_comma (&p) == SUCCESS)
5706     {
5707       if (skip_past_char (&p, '{') == SUCCESS)
5708         {
5709           /* [Rn], {expr} - unindexed, with option */
5710           if (parse_immediate (&p, &inst.operands[i].imm,
5711                                0, 255, TRUE) == FAIL)
5712             return PARSE_OPERAND_FAIL;
5713
5714           if (skip_past_char (&p, '}') == FAIL)
5715             {
5716               inst.error = _("'}' expected at end of 'option' field");
5717               return PARSE_OPERAND_FAIL;
5718             }
5719           if (inst.operands[i].preind)
5720             {
5721               inst.error = _("cannot combine index with option");
5722               return PARSE_OPERAND_FAIL;
5723             }
5724           *str = p;
5725           return PARSE_OPERAND_SUCCESS;
5726         }
5727       else
5728         {
5729           inst.operands[i].postind = 1;
5730           inst.operands[i].writeback = 1;
5731
5732           if (inst.operands[i].preind)
5733             {
5734               inst.error = _("cannot combine pre- and post-indexing");
5735               return PARSE_OPERAND_FAIL;
5736             }
5737
5738           if (*p == '+') p++;
5739           else if (*p == '-') p++, inst.operands[i].negative = 1;
5740
5741           if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) != FAIL)
5742             {
5743               /* We might be using the immediate for alignment already. If we
5744                  are, OR the register number into the low-order bits.  */
5745               if (inst.operands[i].immisalign)
5746                 inst.operands[i].imm |= reg;
5747               else
5748                 inst.operands[i].imm = reg;
5749               inst.operands[i].immisreg = 1;
5750
5751               if (skip_past_comma (&p) == SUCCESS)
5752                 if (parse_shift (&p, i, SHIFT_IMMEDIATE) == FAIL)
5753                   return PARSE_OPERAND_FAIL;
5754             }
5755           else
5756             {
5757               char *q = p;
5758
5759               if (inst.operands[i].negative)
5760                 {
5761                   inst.operands[i].negative = 0;
5762                   p--;
5763                 }
5764               if (my_get_expression (&inst.relocs[0].exp, &p, GE_IMM_PREFIX))
5765                 return PARSE_OPERAND_FAIL;
5766               /* If the offset is 0, find out if it's a +0 or -0.  */
5767               if (inst.relocs[0].exp.X_op == O_constant
5768                   && inst.relocs[0].exp.X_add_number == 0)
5769                 {
5770                   skip_whitespace (q);
5771                   if (*q == '#')
5772                     {
5773                       q++;
5774                       skip_whitespace (q);
5775                     }
5776                   if (*q == '-')
5777                     inst.operands[i].negative = 1;
5778                 }
5779             }
5780         }
5781     }
5782
5783   /* If at this point neither .preind nor .postind is set, we have a
5784      bare [Rn]{!}, which is shorthand for [Rn,#0]{!}.  */
5785   if (inst.operands[i].preind == 0 && inst.operands[i].postind == 0)
5786     {
5787       inst.operands[i].preind = 1;
5788       inst.relocs[0].exp.X_op = O_constant;
5789       inst.relocs[0].exp.X_add_number = 0;
5790     }
5791   *str = p;
5792   return PARSE_OPERAND_SUCCESS;
5793 }
5794
5795 static int
5796 parse_address (char **str, int i)
5797 {
5798   return parse_address_main (str, i, 0, GROUP_LDR) == PARSE_OPERAND_SUCCESS
5799          ? SUCCESS : FAIL;
5800 }
5801
5802 static parse_operand_result
5803 parse_address_group_reloc (char **str, int i, group_reloc_type type)
5804 {
5805   return parse_address_main (str, i, 1, type);
5806 }
5807
5808 /* Parse an operand for a MOVW or MOVT instruction.  */
5809 static int
5810 parse_half (char **str)
5811 {
5812   char * p;
5813
5814   p = *str;
5815   skip_past_char (&p, '#');
5816   if (strncasecmp (p, ":lower16:", 9) == 0)
5817     inst.relocs[0].type = BFD_RELOC_ARM_MOVW;
5818   else if (strncasecmp (p, ":upper16:", 9) == 0)
5819     inst.relocs[0].type = BFD_RELOC_ARM_MOVT;
5820
5821   if (inst.relocs[0].type != BFD_RELOC_UNUSED)
5822     {
5823       p += 9;
5824       skip_whitespace (p);
5825     }
5826
5827   if (my_get_expression (&inst.relocs[0].exp, &p, GE_NO_PREFIX))
5828     return FAIL;
5829
5830   if (inst.relocs[0].type == BFD_RELOC_UNUSED)
5831     {
5832       if (inst.relocs[0].exp.X_op != O_constant)
5833         {
5834           inst.error = _("constant expression expected");
5835           return FAIL;
5836         }
5837       if (inst.relocs[0].exp.X_add_number < 0
5838           || inst.relocs[0].exp.X_add_number > 0xffff)
5839         {
5840           inst.error = _("immediate value out of range");
5841           return FAIL;
5842         }
5843     }
5844   *str = p;
5845   return SUCCESS;
5846 }
5847
5848 /* Miscellaneous. */
5849
5850 /* Parse a PSR flag operand.  The value returned is FAIL on syntax error,
5851    or a bitmask suitable to be or-ed into the ARM msr instruction.  */
5852 static int
5853 parse_psr (char **str, bfd_boolean lhs)
5854 {
5855   char *p;
5856   unsigned long psr_field;
5857   const struct asm_psr *psr;
5858   char *start;
5859   bfd_boolean is_apsr = FALSE;
5860   bfd_boolean m_profile = ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_m);
5861
5862   /* PR gas/12698:  If the user has specified -march=all then m_profile will
5863      be TRUE, but we want to ignore it in this case as we are building for any
5864      CPU type, including non-m variants.  */
5865   if (ARM_FEATURE_CORE_EQUAL (selected_cpu, arm_arch_any))
5866     m_profile = FALSE;
5867
5868   /* CPSR's and SPSR's can now be lowercase.  This is just a convenience
5869      feature for ease of use and backwards compatibility.  */
5870   p = *str;
5871   if (strncasecmp (p, "SPSR", 4) == 0)
5872     {
5873       if (m_profile)
5874         goto unsupported_psr;
5875
5876       psr_field = SPSR_BIT;
5877     }
5878   else if (strncasecmp (p, "CPSR", 4) == 0)
5879     {
5880       if (m_profile)
5881         goto unsupported_psr;
5882
5883       psr_field = 0;
5884     }
5885   else if (strncasecmp (p, "APSR", 4) == 0)
5886     {
5887       /* APSR[_<bits>] can be used as a synonym for CPSR[_<flags>] on ARMv7-A
5888          and ARMv7-R architecture CPUs.  */
5889       is_apsr = TRUE;
5890       psr_field = 0;
5891     }
5892   else if (m_profile)
5893     {
5894       start = p;
5895       do
5896         p++;
5897       while (ISALNUM (*p) || *p == '_');
5898
5899       if (strncasecmp (start, "iapsr", 5) == 0
5900           || strncasecmp (start, "eapsr", 5) == 0
5901           || strncasecmp (start, "xpsr", 4) == 0
5902           || strncasecmp (start, "psr", 3) == 0)
5903         p = start + strcspn (start, "rR") + 1;
5904
5905       psr = (const struct asm_psr *) hash_find_n (arm_v7m_psr_hsh, start,
5906                                                   p - start);
5907
5908       if (!psr)
5909         return FAIL;
5910
5911       /* If APSR is being written, a bitfield may be specified.  Note that
5912          APSR itself is handled above.  */
5913       if (psr->field <= 3)
5914         {
5915           psr_field = psr->field;
5916           is_apsr = TRUE;
5917           goto check_suffix;
5918         }
5919
5920       *str = p;
5921       /* M-profile MSR instructions have the mask field set to "10", except
5922          *PSR variants which modify APSR, which may use a different mask (and
5923          have been handled already).  Do that by setting the PSR_f field
5924          here.  */
5925       return psr->field | (lhs ? PSR_f : 0);
5926     }
5927   else
5928     goto unsupported_psr;
5929
5930   p += 4;
5931 check_suffix:
5932   if (*p == '_')
5933     {
5934       /* A suffix follows.  */
5935       p++;
5936       start = p;
5937
5938       do
5939         p++;
5940       while (ISALNUM (*p) || *p == '_');
5941
5942       if (is_apsr)
5943         {
5944           /* APSR uses a notation for bits, rather than fields.  */
5945           unsigned int nzcvq_bits = 0;
5946           unsigned int g_bit = 0;
5947           char *bit;
5948
5949           for (bit = start; bit != p; bit++)
5950             {
5951               switch (TOLOWER (*bit))
5952                 {
5953                 case 'n':
5954                   nzcvq_bits |= (nzcvq_bits & 0x01) ? 0x20 : 0x01;
5955                   break;
5956
5957                 case 'z':
5958                   nzcvq_bits |= (nzcvq_bits & 0x02) ? 0x20 : 0x02;
5959                   break;
5960
5961                 case 'c':
5962                   nzcvq_bits |= (nzcvq_bits & 0x04) ? 0x20 : 0x04;
5963                   break;
5964
5965                 case 'v':
5966                   nzcvq_bits |= (nzcvq_bits & 0x08) ? 0x20 : 0x08;
5967                   break;
5968
5969                 case 'q':
5970                   nzcvq_bits |= (nzcvq_bits & 0x10) ? 0x20 : 0x10;
5971                   break;
5972
5973                 case 'g':
5974                   g_bit |= (g_bit & 0x1) ? 0x2 : 0x1;
5975                   break;
5976
5977                 default:
5978                   inst.error = _("unexpected bit specified after APSR");
5979                   return FAIL;
5980                 }
5981             }
5982
5983           if (nzcvq_bits == 0x1f)
5984             psr_field |= PSR_f;
5985
5986           if (g_bit == 0x1)
5987             {
5988               if (!ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6_dsp))
5989                 {
5990                   inst.error = _("selected processor does not "
5991                                  "support DSP extension");
5992                   return FAIL;
5993                 }
5994
5995               psr_field |= PSR_s;
5996             }
5997
5998           if ((nzcvq_bits & 0x20) != 0
5999               || (nzcvq_bits != 0x1f && nzcvq_bits != 0)
6000               || (g_bit & 0x2) != 0)
6001             {
6002               inst.error = _("bad bitmask specified after APSR");
6003               return FAIL;
6004             }
6005         }
6006       else
6007         {
6008           psr = (const struct asm_psr *) hash_find_n (arm_psr_hsh, start,
6009                                                       p - start);
6010           if (!psr)
6011             goto error;
6012
6013           psr_field |= psr->field;
6014         }
6015     }
6016   else
6017     {
6018       if (ISALNUM (*p))
6019         goto error;    /* Garbage after "[CS]PSR".  */
6020
6021       /* Unadorned APSR is equivalent to APSR_nzcvq/CPSR_f (for writes).  This
6022          is deprecated, but allow it anyway.  */
6023       if (is_apsr && lhs)
6024         {
6025           psr_field |= PSR_f;
6026           as_tsktsk (_("writing to APSR without specifying a bitmask is "
6027                        "deprecated"));
6028         }
6029       else if (!m_profile)
6030         /* These bits are never right for M-profile devices: don't set them
6031            (only code paths which read/write APSR reach here).  */
6032         psr_field |= (PSR_c | PSR_f);
6033     }
6034   *str = p;
6035   return psr_field;
6036
6037  unsupported_psr:
6038   inst.error = _("selected processor does not support requested special "
6039                  "purpose register");
6040   return FAIL;
6041
6042  error:
6043   inst.error = _("flag for {c}psr instruction expected");
6044   return FAIL;
6045 }
6046
6047 /* Parse the flags argument to CPSI[ED].  Returns FAIL on error, or a
6048    value suitable for splatting into the AIF field of the instruction.  */
6049
6050 static int
6051 parse_cps_flags (char **str)
6052 {
6053   int val = 0;
6054   int saw_a_flag = 0;
6055   char *s = *str;
6056
6057   for (;;)
6058     switch (*s++)
6059       {
6060       case '\0': case ',':
6061         goto done;
6062
6063       case 'a': case 'A': saw_a_flag = 1; val |= 0x4; break;
6064       case 'i': case 'I': saw_a_flag = 1; val |= 0x2; break;
6065       case 'f': case 'F': saw_a_flag = 1; val |= 0x1; break;
6066
6067       default:
6068         inst.error = _("unrecognized CPS flag");
6069         return FAIL;
6070       }
6071
6072  done:
6073   if (saw_a_flag == 0)
6074     {
6075       inst.error = _("missing CPS flags");
6076       return FAIL;
6077     }
6078
6079   *str = s - 1;
6080   return val;
6081 }
6082
6083 /* Parse an endian specifier ("BE" or "LE", case insensitive);
6084    returns 0 for big-endian, 1 for little-endian, FAIL for an error.  */
6085
6086 static int
6087 parse_endian_specifier (char **str)
6088 {
6089   int little_endian;
6090   char *s = *str;
6091
6092   if (strncasecmp (s, "BE", 2))
6093     little_endian = 0;
6094   else if (strncasecmp (s, "LE", 2))
6095     little_endian = 1;
6096   else
6097     {
6098       inst.error = _("valid endian specifiers are be or le");
6099       return FAIL;
6100     }
6101
6102   if (ISALNUM (s[2]) || s[2] == '_')
6103     {
6104       inst.error = _("valid endian specifiers are be or le");
6105       return FAIL;
6106     }
6107
6108   *str = s + 2;
6109   return little_endian;
6110 }
6111
6112 /* Parse a rotation specifier: ROR #0, #8, #16, #24.  *val receives a
6113    value suitable for poking into the rotate field of an sxt or sxta
6114    instruction, or FAIL on error.  */
6115
6116 static int
6117 parse_ror (char **str)
6118 {
6119   int rot;
6120   char *s = *str;
6121
6122   if (strncasecmp (s, "ROR", 3) == 0)
6123     s += 3;
6124   else
6125     {
6126       inst.error = _("missing rotation field after comma");
6127       return FAIL;
6128     }
6129
6130   if (parse_immediate (&s, &rot, 0, 24, FALSE) == FAIL)
6131     return FAIL;
6132
6133   switch (rot)
6134     {
6135     case  0: *str = s; return 0x0;
6136     case  8: *str = s; return 0x1;
6137     case 16: *str = s; return 0x2;
6138     case 24: *str = s; return 0x3;
6139
6140     default:
6141       inst.error = _("rotation can only be 0, 8, 16, or 24");
6142       return FAIL;
6143     }
6144 }
6145
6146 /* Parse a conditional code (from conds[] below).  The value returned is in the
6147    range 0 .. 14, or FAIL.  */
6148 static int
6149 parse_cond (char **str)
6150 {
6151   char *q;
6152   const struct asm_cond *c;
6153   int n;
6154   /* Condition codes are always 2 characters, so matching up to
6155      3 characters is sufficient.  */
6156   char cond[3];
6157
6158   q = *str;
6159   n = 0;
6160   while (ISALPHA (*q) && n < 3)
6161     {
6162       cond[n] = TOLOWER (*q);
6163       q++;
6164       n++;
6165     }
6166
6167   c = (const struct asm_cond *) hash_find_n (arm_cond_hsh, cond, n);
6168   if (!c)
6169     {
6170       inst.error = _("condition required");
6171       return FAIL;
6172     }
6173
6174   *str = q;
6175   return c->value;
6176 }
6177
6178 /* Record a use of the given feature.  */
6179 static void
6180 record_feature_use (const arm_feature_set *feature)
6181 {
6182   if (thumb_mode)
6183     ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used, *feature);
6184   else
6185     ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used, *feature);
6186 }
6187
6188 /* If the given feature is currently allowed, mark it as used and return TRUE.
6189    Return FALSE otherwise.  */
6190 static bfd_boolean
6191 mark_feature_used (const arm_feature_set *feature)
6192 {
6193   /* Ensure the option is currently allowed.  */
6194   if (!ARM_CPU_HAS_FEATURE (cpu_variant, *feature))
6195     return FALSE;
6196
6197   /* Add the appropriate architecture feature for the barrier option used.  */
6198   record_feature_use (feature);
6199
6200   return TRUE;
6201 }
6202
6203 /* Parse an option for a barrier instruction.  Returns the encoding for the
6204    option, or FAIL.  */
6205 static int
6206 parse_barrier (char **str)
6207 {
6208   char *p, *q;
6209   const struct asm_barrier_opt *o;
6210
6211   p = q = *str;
6212   while (ISALPHA (*q))
6213     q++;
6214
6215   o = (const struct asm_barrier_opt *) hash_find_n (arm_barrier_opt_hsh, p,
6216                                                     q - p);
6217   if (!o)
6218     return FAIL;
6219
6220   if (!mark_feature_used (&o->arch))
6221     return FAIL;
6222
6223   *str = q;
6224   return o->value;
6225 }
6226
6227 /* Parse the operands of a table branch instruction.  Similar to a memory
6228    operand.  */
6229 static int
6230 parse_tb (char **str)
6231 {
6232   char * p = *str;
6233   int reg;
6234
6235   if (skip_past_char (&p, '[') == FAIL)
6236     {
6237       inst.error = _("'[' expected");
6238       return FAIL;
6239     }
6240
6241   if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) == FAIL)
6242     {
6243       inst.error = _(reg_expected_msgs[REG_TYPE_RN]);
6244       return FAIL;
6245     }
6246   inst.operands[0].reg = reg;
6247
6248   if (skip_past_comma (&p) == FAIL)
6249     {
6250       inst.error = _("',' expected");
6251       return FAIL;
6252     }
6253
6254   if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) == FAIL)
6255     {
6256       inst.error = _(reg_expected_msgs[REG_TYPE_RN]);
6257       return FAIL;
6258     }
6259   inst.operands[0].imm = reg;
6260
6261   if (skip_past_comma (&p) == SUCCESS)
6262     {
6263       if (parse_shift (&p, 0, SHIFT_LSL_IMMEDIATE) == FAIL)
6264         return FAIL;
6265       if (inst.relocs[0].exp.X_add_number != 1)
6266         {
6267           inst.error = _("invalid shift");
6268           return FAIL;
6269         }
6270       inst.operands[0].shifted = 1;
6271     }
6272
6273   if (skip_past_char (&p, ']') == FAIL)
6274     {
6275       inst.error = _("']' expected");
6276       return FAIL;
6277     }
6278   *str = p;
6279   return SUCCESS;
6280 }
6281
6282 /* Parse the operands of a Neon VMOV instruction. See do_neon_mov for more
6283    information on the types the operands can take and how they are encoded.
6284    Up to four operands may be read; this function handles setting the
6285    ".present" field for each read operand itself.
6286    Updates STR and WHICH_OPERAND if parsing is successful and returns SUCCESS,
6287    else returns FAIL.  */
6288
6289 static int
6290 parse_neon_mov (char **str, int *which_operand)
6291 {
6292   int i = *which_operand, val;
6293   enum arm_reg_type rtype;
6294   char *ptr = *str;
6295   struct neon_type_el optype;
6296
6297   if ((val = parse_scalar (&ptr, 8, &optype)) != FAIL)
6298     {
6299       /* Case 4: VMOV<c><q>.<size> <Dn[x]>, <Rd>.  */
6300       inst.operands[i].reg = val;
6301       inst.operands[i].isscalar = 1;
6302       inst.operands[i].vectype = optype;
6303       inst.operands[i++].present = 1;
6304
6305       if (skip_past_comma (&ptr) == FAIL)
6306         goto wanted_comma;
6307
6308       if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
6309         goto wanted_arm;
6310
6311       inst.operands[i].reg = val;
6312       inst.operands[i].isreg = 1;
6313       inst.operands[i].present = 1;
6314     }
6315   else if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_NSDQ, &rtype, &optype))
6316            != FAIL)
6317     {
6318       /* Cases 0, 1, 2, 3, 5 (D only).  */
6319       if (skip_past_comma (&ptr) == FAIL)
6320         goto wanted_comma;
6321
6322       inst.operands[i].reg = val;
6323       inst.operands[i].isreg = 1;
6324       inst.operands[i].isquad = (rtype == REG_TYPE_NQ);
6325       inst.operands[i].issingle = (rtype == REG_TYPE_VFS);
6326       inst.operands[i].isvec = 1;
6327       inst.operands[i].vectype = optype;
6328       inst.operands[i++].present = 1;
6329
6330       if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) != FAIL)
6331         {
6332           /* Case 5: VMOV<c><q> <Dm>, <Rd>, <Rn>.
6333              Case 13: VMOV <Sd>, <Rm>  */
6334           inst.operands[i].reg = val;
6335           inst.operands[i].isreg = 1;
6336           inst.operands[i].present = 1;
6337
6338           if (rtype == REG_TYPE_NQ)
6339             {
6340               first_error (_("can't use Neon quad register here"));
6341               return FAIL;
6342             }
6343           else if (rtype != REG_TYPE_VFS)
6344             {
6345               i++;
6346               if (skip_past_comma (&ptr) == FAIL)
6347                 goto wanted_comma;
6348               if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
6349                 goto wanted_arm;
6350               inst.operands[i].reg = val;
6351               inst.operands[i].isreg = 1;
6352               inst.operands[i].present = 1;
6353             }
6354         }
6355       else if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_NSDQ, &rtype,
6356                                            &optype)) != FAIL)
6357         {
6358           /* Case 0: VMOV<c><q> <Qd>, <Qm>
6359              Case 1: VMOV<c><q> <Dd>, <Dm>
6360              Case 8: VMOV.F32 <Sd>, <Sm>
6361              Case 15: VMOV <Sd>, <Se>, <Rn>, <Rm>  */
6362
6363           inst.operands[i].reg = val;
6364           inst.operands[i].isreg = 1;
6365           inst.operands[i].isquad = (rtype == REG_TYPE_NQ);
6366           inst.operands[i].issingle = (rtype == REG_TYPE_VFS);
6367           inst.operands[i].isvec = 1;
6368           inst.operands[i].vectype = optype;
6369           inst.operands[i].present = 1;
6370
6371           if (skip_past_comma (&ptr) == SUCCESS)
6372             {
6373               /* Case 15.  */
6374               i++;
6375
6376               if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
6377                 goto wanted_arm;
6378
6379               inst.operands[i].reg = val;
6380               inst.operands[i].isreg = 1;
6381               inst.operands[i++].present = 1;
6382
6383               if (skip_past_comma (&ptr) == FAIL)
6384                 goto wanted_comma;
6385
6386               if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
6387                 goto wanted_arm;
6388
6389               inst.operands[i].reg = val;
6390               inst.operands[i].isreg = 1;
6391               inst.operands[i].present = 1;
6392             }
6393         }
6394       else if (parse_qfloat_immediate (&ptr, &inst.operands[i].imm) == SUCCESS)
6395           /* Case 2: VMOV<c><q>.<dt> <Qd>, #<float-imm>
6396              Case 3: VMOV<c><q>.<dt> <Dd>, #<float-imm>
6397              Case 10: VMOV.F32 <Sd>, #<imm>
6398              Case 11: VMOV.F64 <Dd>, #<imm>  */
6399         inst.operands[i].immisfloat = 1;
6400       else if (parse_big_immediate (&ptr, i, NULL, /*allow_symbol_p=*/FALSE)
6401                == SUCCESS)
6402           /* Case 2: VMOV<c><q>.<dt> <Qd>, #<imm>
6403              Case 3: VMOV<c><q>.<dt> <Dd>, #<imm>  */
6404         ;
6405       else
6406         {
6407           first_error (_("expected <Rm> or <Dm> or <Qm> operand"));
6408           return FAIL;
6409         }
6410     }
6411   else if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) != FAIL)
6412     {
6413       /* Cases 6, 7.  */
6414       inst.operands[i].reg = val;
6415       inst.operands[i].isreg = 1;
6416       inst.operands[i++].present = 1;
6417
6418       if (skip_past_comma (&ptr) == FAIL)
6419         goto wanted_comma;
6420
6421       if ((val = parse_scalar (&ptr, 8, &optype)) != FAIL)
6422         {
6423           /* Case 6: VMOV<c><q>.<dt> <Rd>, <Dn[x]>  */
6424           inst.operands[i].reg = val;
6425           inst.operands[i].isscalar = 1;
6426           inst.operands[i].present = 1;
6427           inst.operands[i].vectype = optype;
6428         }
6429       else if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) != FAIL)
6430         {
6431           /* Case 7: VMOV<c><q> <Rd>, <Rn>, <Dm>  */
6432           inst.operands[i].reg = val;
6433           inst.operands[i].isreg = 1;
6434           inst.operands[i++].present = 1;
6435
6436           if (skip_past_comma (&ptr) == FAIL)
6437             goto wanted_comma;
6438
6439           if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_VFSD, &rtype, &optype))
6440               == FAIL)
6441             {
6442               first_error (_(reg_expected_msgs[REG_TYPE_VFSD]));
6443               return FAIL;
6444             }
6445
6446           inst.operands[i].reg = val;
6447           inst.operands[i].isreg = 1;
6448           inst.operands[i].isvec = 1;
6449           inst.operands[i].issingle = (rtype == REG_TYPE_VFS);
6450           inst.operands[i].vectype = optype;
6451           inst.operands[i].present = 1;
6452
6453           if (rtype == REG_TYPE_VFS)
6454             {
6455               /* Case 14.  */
6456               i++;
6457               if (skip_past_comma (&ptr) == FAIL)
6458                 goto wanted_comma;
6459               if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_VFS, NULL,
6460                                               &optype)) == FAIL)
6461                 {
6462                   first_error (_(reg_expected_msgs[REG_TYPE_VFS]));
6463                   return FAIL;
6464                 }
6465               inst.operands[i].reg = val;
6466               inst.operands[i].isreg = 1;
6467               inst.operands[i].isvec = 1;
6468               inst.operands[i].issingle = 1;
6469               inst.operands[i].vectype = optype;
6470               inst.operands[i].present = 1;
6471             }
6472         }
6473       else if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_VFS, NULL, &optype))
6474                != FAIL)
6475         {
6476           /* Case 13.  */
6477           inst.operands[i].reg = val;
6478           inst.operands[i].isreg = 1;
6479           inst.operands[i].isvec = 1;
6480           inst.operands[i].issingle = 1;
6481           inst.operands[i].vectype = optype;
6482           inst.operands[i].present = 1;
6483         }
6484     }
6485   else
6486     {
6487       first_error (_("parse error"));
6488       return FAIL;
6489     }
6490
6491   /* Successfully parsed the operands. Update args.  */
6492   *which_operand = i;
6493   *str = ptr;
6494   return SUCCESS;
6495
6496  wanted_comma:
6497   first_error (_("expected comma"));
6498   return FAIL;
6499
6500  wanted_arm:
6501   first_error (_(reg_expected_msgs[REG_TYPE_RN]));
6502   return FAIL;
6503 }
6504
6505 /* Use this macro when the operand constraints are different
6506    for ARM and THUMB (e.g. ldrd).  */
6507 #define MIX_ARM_THUMB_OPERANDS(arm_operand, thumb_operand) \
6508         ((arm_operand) | ((thumb_operand) << 16))
6509
6510 /* Matcher codes for parse_operands.  */
6511 enum operand_parse_code
6512 {
6513   OP_stop,      /* end of line */
6514
6515   OP_RR,        /* ARM register */
6516   OP_RRnpc,     /* ARM register, not r15 */
6517   OP_RRnpcsp,   /* ARM register, neither r15 nor r13 (a.k.a. 'BadReg') */
6518   OP_RRnpcb,    /* ARM register, not r15, in square brackets */
6519   OP_RRnpctw,   /* ARM register, not r15 in Thumb-state or with writeback,
6520                    optional trailing ! */
6521   OP_RRw,       /* ARM register, not r15, optional trailing ! */
6522   OP_RCP,       /* Coprocessor number */
6523   OP_RCN,       /* Coprocessor register */
6524   OP_RF,        /* FPA register */
6525   OP_RVS,       /* VFP single precision register */
6526   OP_RVD,       /* VFP double precision register (0..15) */
6527   OP_RND,       /* Neon double precision register (0..31) */
6528   OP_RNQ,       /* Neon quad precision register */
6529   OP_RVSD,      /* VFP single or double precision register */
6530   OP_RNSD,      /* Neon single or double precision register */
6531   OP_RNDQ,      /* Neon double or quad precision register */
6532   OP_RNSDQ,     /* Neon single, double or quad precision register */
6533   OP_RNSC,      /* Neon scalar D[X] */
6534   OP_RVC,       /* VFP control register */
6535   OP_RMF,       /* Maverick F register */
6536   OP_RMD,       /* Maverick D register */
6537   OP_RMFX,      /* Maverick FX register */
6538   OP_RMDX,      /* Maverick DX register */
6539   OP_RMAX,      /* Maverick AX register */
6540   OP_RMDS,      /* Maverick DSPSC register */
6541   OP_RIWR,      /* iWMMXt wR register */
6542   OP_RIWC,      /* iWMMXt wC register */
6543   OP_RIWG,      /* iWMMXt wCG register */
6544   OP_RXA,       /* XScale accumulator register */
6545
6546   OP_REGLST,    /* ARM register list */
6547   OP_VRSLST,    /* VFP single-precision register list */
6548   OP_VRDLST,    /* VFP double-precision register list */
6549   OP_VRSDLST,   /* VFP single or double-precision register list (& quad) */
6550   OP_NRDLST,    /* Neon double-precision register list (d0-d31, qN aliases) */
6551   OP_NSTRLST,   /* Neon element/structure list */
6552
6553   OP_RNDQ_I0,   /* Neon D or Q reg, or immediate zero.  */
6554   OP_RVSD_I0,   /* VFP S or D reg, or immediate zero.  */
6555   OP_RSVD_FI0, /* VFP S or D reg, or floating point immediate zero.  */
6556   OP_RR_RNSC,   /* ARM reg or Neon scalar.  */
6557   OP_RNSD_RNSC, /* Neon S or D reg, or Neon scalar.  */
6558   OP_RNSDQ_RNSC, /* Vector S, D or Q reg, or Neon scalar.  */
6559   OP_RNDQ_RNSC, /* Neon D or Q reg, or Neon scalar.  */
6560   OP_RND_RNSC,  /* Neon D reg, or Neon scalar.  */
6561   OP_VMOV,      /* Neon VMOV operands.  */
6562   OP_RNDQ_Ibig, /* Neon D or Q reg, or big immediate for logic and VMVN.  */
6563   OP_RNDQ_I63b, /* Neon D or Q reg, or immediate for shift.  */
6564   OP_RIWR_I32z, /* iWMMXt wR register, or immediate 0 .. 32 for iWMMXt2.  */
6565
6566   OP_I0,        /* immediate zero */
6567   OP_I7,        /* immediate value 0 .. 7 */
6568   OP_I15,       /*                 0 .. 15 */
6569   OP_I16,       /*                 1 .. 16 */
6570   OP_I16z,      /*                 0 .. 16 */
6571   OP_I31,       /*                 0 .. 31 */
6572   OP_I31w,      /*                 0 .. 31, optional trailing ! */
6573   OP_I32,       /*                 1 .. 32 */
6574   OP_I32z,      /*                 0 .. 32 */
6575   OP_I63,       /*                 0 .. 63 */
6576   OP_I63s,      /*               -64 .. 63 */
6577   OP_I64,       /*                 1 .. 64 */
6578   OP_I64z,      /*                 0 .. 64 */
6579   OP_I255,      /*                 0 .. 255 */
6580
6581   OP_I4b,       /* immediate, prefix optional, 1 .. 4 */
6582   OP_I7b,       /*                             0 .. 7 */
6583   OP_I15b,      /*                             0 .. 15 */
6584   OP_I31b,      /*                             0 .. 31 */
6585
6586   OP_SH,        /* shifter operand */
6587   OP_SHG,       /* shifter operand with possible group relocation */
6588   OP_ADDR,      /* Memory address expression (any mode) */
6589   OP_ADDRGLDR,  /* Mem addr expr (any mode) with possible LDR group reloc */
6590   OP_ADDRGLDRS, /* Mem addr expr (any mode) with possible LDRS group reloc */
6591   OP_ADDRGLDC,  /* Mem addr expr (any mode) with possible LDC group reloc */
6592   OP_EXP,       /* arbitrary expression */
6593   OP_EXPi,      /* same, with optional immediate prefix */
6594   OP_EXPr,      /* same, with optional relocation suffix */
6595   OP_EXPs,      /* same, with optional non-first operand relocation suffix */
6596   OP_HALF,      /* 0 .. 65535 or low/high reloc.  */
6597   OP_IROT1,     /* VCADD rotate immediate: 90, 270.  */
6598   OP_IROT2,     /* VCMLA rotate immediate: 0, 90, 180, 270.  */
6599
6600   OP_CPSF,      /* CPS flags */
6601   OP_ENDI,      /* Endianness specifier */
6602   OP_wPSR,      /* CPSR/SPSR/APSR mask for msr (writing).  */
6603   OP_rPSR,      /* CPSR/SPSR/APSR mask for msr (reading).  */
6604   OP_COND,      /* conditional code */
6605   OP_TB,        /* Table branch.  */
6606
6607   OP_APSR_RR,   /* ARM register or "APSR_nzcv".  */
6608
6609   OP_RRnpc_I0,  /* ARM register or literal 0 */
6610   OP_RR_EXr,    /* ARM register or expression with opt. reloc stuff. */
6611   OP_RR_EXi,    /* ARM register or expression with imm prefix */
6612   OP_RF_IF,     /* FPA register or immediate */
6613   OP_RIWR_RIWC, /* iWMMXt R or C reg */
6614   OP_RIWC_RIWG, /* iWMMXt wC or wCG reg */
6615
6616   /* Optional operands.  */
6617   OP_oI7b,       /* immediate, prefix optional, 0 .. 7 */
6618   OP_oI31b,      /*                             0 .. 31 */
6619   OP_oI32b,      /*                             1 .. 32 */
6620   OP_oI32z,      /*                             0 .. 32 */
6621   OP_oIffffb,    /*                             0 .. 65535 */
6622   OP_oI255c,     /*       curly-brace enclosed, 0 .. 255 */
6623
6624   OP_oRR,        /* ARM register */
6625   OP_oRRnpc,     /* ARM register, not the PC */
6626   OP_oRRnpcsp,   /* ARM register, neither the PC nor the SP (a.k.a. BadReg) */
6627   OP_oRRw,       /* ARM register, not r15, optional trailing ! */
6628   OP_oRND,       /* Optional Neon double precision register */
6629   OP_oRNQ,       /* Optional Neon quad precision register */
6630   OP_oRNDQ,      /* Optional Neon double or quad precision register */
6631   OP_oRNSDQ,     /* Optional single, double or quad precision vector register */
6632   OP_oSHll,      /* LSL immediate */
6633   OP_oSHar,      /* ASR immediate */
6634   OP_oSHllar,    /* LSL or ASR immediate */
6635   OP_oROR,       /* ROR 0/8/16/24 */
6636   OP_oBARRIER_I15, /* Option argument for a barrier instruction.  */
6637
6638   /* Some pre-defined mixed (ARM/THUMB) operands.  */
6639   OP_RR_npcsp           = MIX_ARM_THUMB_OPERANDS (OP_RR, OP_RRnpcsp),
6640   OP_RRnpc_npcsp        = MIX_ARM_THUMB_OPERANDS (OP_RRnpc, OP_RRnpcsp),
6641   OP_oRRnpc_npcsp       = MIX_ARM_THUMB_OPERANDS (OP_oRRnpc, OP_oRRnpcsp),
6642
6643   OP_FIRST_OPTIONAL = OP_oI7b
6644 };
6645
6646 /* Generic instruction operand parser.  This does no encoding and no
6647    semantic validation; it merely squirrels values away in the inst
6648    structure.  Returns SUCCESS or FAIL depending on whether the
6649    specified grammar matched.  */
6650 static int
6651 parse_operands (char *str, const unsigned int *pattern, bfd_boolean thumb)
6652 {
6653   unsigned const int *upat = pattern;
6654   char *backtrack_pos = 0;
6655   const char *backtrack_error = 0;
6656   int i, val = 0, backtrack_index = 0;
6657   enum arm_reg_type rtype;
6658   parse_operand_result result;
6659   unsigned int op_parse_code;
6660
6661 #define po_char_or_fail(chr)                    \
6662   do                                            \
6663     {                                           \
6664       if (skip_past_char (&str, chr) == FAIL)   \
6665         goto bad_args;                          \
6666     }                                           \
6667   while (0)
6668
6669 #define po_reg_or_fail(regtype)                                 \
6670   do                                                            \
6671     {                                                           \
6672       val = arm_typed_reg_parse (& str, regtype, & rtype,       \
6673                                  & inst.operands[i].vectype);   \
6674       if (val == FAIL)                                          \
6675         {                                                       \
6676           first_error (_(reg_expected_msgs[regtype]));          \
6677           goto failure;                                         \
6678         }                                                       \
6679       inst.operands[i].reg = val;                               \
6680       inst.operands[i].isreg = 1;                               \
6681       inst.operands[i].isquad = (rtype == REG_TYPE_NQ);         \
6682       inst.operands[i].issingle = (rtype == REG_TYPE_VFS);      \
6683       inst.operands[i].isvec = (rtype == REG_TYPE_VFS           \
6684                              || rtype == REG_TYPE_VFD           \
6685                              || rtype == REG_TYPE_NQ);          \
6686     }                                                           \
6687   while (0)
6688
6689 #define po_reg_or_goto(regtype, label)                          \
6690   do                                                            \
6691     {                                                           \
6692       val = arm_typed_reg_parse (& str, regtype, & rtype,       \
6693                                  & inst.operands[i].vectype);   \
6694       if (val == FAIL)                                          \
6695         goto label;                                             \
6696                                                                 \
6697       inst.operands[i].reg = val;                               \
6698       inst.operands[i].isreg = 1;                               \
6699       inst.operands[i].isquad = (rtype == REG_TYPE_NQ);         \
6700       inst.operands[i].issingle = (rtype == REG_TYPE_VFS);      \
6701       inst.operands[i].isvec = (rtype == REG_TYPE_VFS           \
6702                              || rtype == REG_TYPE_VFD           \
6703                              || rtype == REG_TYPE_NQ);          \
6704     }                                                           \
6705   while (0)
6706
6707 #define po_imm_or_fail(min, max, popt)                          \
6708   do                                                            \
6709     {                                                           \
6710       if (parse_immediate (&str, &val, min, max, popt) == FAIL) \
6711         goto failure;                                           \
6712       inst.operands[i].imm = val;                               \
6713     }                                                           \
6714   while (0)
6715
6716 #define po_scalar_or_goto(elsz, label)                                  \
6717   do                                                                    \
6718     {                                                                   \
6719       val = parse_scalar (& str, elsz, & inst.operands[i].vectype);     \
6720       if (val == FAIL)                                                  \
6721         goto label;                                                     \
6722       inst.operands[i].reg = val;                                       \
6723       inst.operands[i].isscalar = 1;                                    \
6724     }                                                                   \
6725   while (0)
6726
6727 #define po_misc_or_fail(expr)                   \
6728   do                                            \
6729     {                                           \
6730       if (expr)                                 \
6731         goto failure;                           \
6732     }                                           \
6733   while (0)
6734
6735 #define po_misc_or_fail_no_backtrack(expr)              \
6736   do                                                    \
6737     {                                                   \
6738       result = expr;                                    \
6739       if (result == PARSE_OPERAND_FAIL_NO_BACKTRACK)    \
6740         backtrack_pos = 0;                              \
6741       if (result != PARSE_OPERAND_SUCCESS)              \
6742         goto failure;                                   \
6743     }                                                   \
6744   while (0)
6745
6746 #define po_barrier_or_imm(str)                             \
6747   do                                                       \
6748     {                                                      \
6749       val = parse_barrier (&str);                          \
6750       if (val == FAIL && ! ISALPHA (*str))                 \
6751         goto immediate;                                    \
6752       if (val == FAIL                                      \
6753           /* ISB can only take SY as an option.  */        \
6754           || ((inst.instruction & 0xf0) == 0x60            \
6755                && val != 0xf))                             \
6756         {                                                  \
6757            inst.error = _("invalid barrier type");         \
6758            backtrack_pos = 0;                              \
6759            goto failure;                                   \
6760         }                                                  \
6761     }                                                      \
6762   while (0)
6763
6764   skip_whitespace (str);
6765
6766   for (i = 0; upat[i] != OP_stop; i++)
6767     {
6768       op_parse_code = upat[i];
6769       if (op_parse_code >= 1<<16)
6770         op_parse_code = thumb ? (op_parse_code >> 16)
6771                                 : (op_parse_code & ((1<<16)-1));
6772
6773       if (op_parse_code >= OP_FIRST_OPTIONAL)
6774         {
6775           /* Remember where we are in case we need to backtrack.  */
6776           gas_assert (!backtrack_pos);
6777           backtrack_pos = str;
6778           backtrack_error = inst.error;
6779           backtrack_index = i;
6780         }
6781
6782       if (i > 0 && (i > 1 || inst.operands[0].present))
6783         po_char_or_fail (',');
6784
6785       switch (op_parse_code)
6786         {
6787           /* Registers */
6788         case OP_oRRnpc:
6789         case OP_oRRnpcsp:
6790         case OP_RRnpc:
6791         case OP_RRnpcsp:
6792         case OP_oRR:
6793         case OP_RR:    po_reg_or_fail (REG_TYPE_RN);      break;
6794         case OP_RCP:   po_reg_or_fail (REG_TYPE_CP);      break;
6795         case OP_RCN:   po_reg_or_fail (REG_TYPE_CN);      break;
6796         case OP_RF:    po_reg_or_fail (REG_TYPE_FN);      break;
6797         case OP_RVS:   po_reg_or_fail (REG_TYPE_VFS);     break;
6798         case OP_RVD:   po_reg_or_fail (REG_TYPE_VFD);     break;
6799         case OP_oRND:
6800         case OP_RND:   po_reg_or_fail (REG_TYPE_VFD);     break;
6801         case OP_RVC:
6802           po_reg_or_goto (REG_TYPE_VFC, coproc_reg);
6803           break;
6804           /* Also accept generic coprocessor regs for unknown registers.  */
6805           coproc_reg:
6806           po_reg_or_fail (REG_TYPE_CN);
6807           break;
6808         case OP_RMF:   po_reg_or_fail (REG_TYPE_MVF);     break;
6809         case OP_RMD:   po_reg_or_fail (REG_TYPE_MVD);     break;
6810         case OP_RMFX:  po_reg_or_fail (REG_TYPE_MVFX);    break;
6811         case OP_RMDX:  po_reg_or_fail (REG_TYPE_MVDX);    break;
6812         case OP_RMAX:  po_reg_or_fail (REG_TYPE_MVAX);    break;
6813         case OP_RMDS:  po_reg_or_fail (REG_TYPE_DSPSC);   break;
6814         case OP_RIWR:  po_reg_or_fail (REG_TYPE_MMXWR);   break;
6815         case OP_RIWC:  po_reg_or_fail (REG_TYPE_MMXWC);   break;
6816         case OP_RIWG:  po_reg_or_fail (REG_TYPE_MMXWCG);  break;
6817         case OP_RXA:   po_reg_or_fail (REG_TYPE_XSCALE);  break;
6818         case OP_oRNQ:
6819         case OP_RNQ:   po_reg_or_fail (REG_TYPE_NQ);      break;
6820         case OP_RNSD:  po_reg_or_fail (REG_TYPE_NSD);     break;
6821         case OP_oRNDQ:
6822         case OP_RNDQ:  po_reg_or_fail (REG_TYPE_NDQ);     break;
6823         case OP_RVSD:  po_reg_or_fail (REG_TYPE_VFSD);    break;
6824         case OP_oRNSDQ:
6825         case OP_RNSDQ: po_reg_or_fail (REG_TYPE_NSDQ);    break;
6826
6827         /* Neon scalar. Using an element size of 8 means that some invalid
6828            scalars are accepted here, so deal with those in later code.  */
6829         case OP_RNSC:  po_scalar_or_goto (8, failure);    break;
6830
6831         case OP_RNDQ_I0:
6832           {
6833             po_reg_or_goto (REG_TYPE_NDQ, try_imm0);
6834             break;
6835             try_imm0:
6836             po_imm_or_fail (0, 0, TRUE);
6837           }
6838           break;
6839
6840         case OP_RVSD_I0:
6841           po_reg_or_goto (REG_TYPE_VFSD, try_imm0);
6842           break;
6843
6844         case OP_RSVD_FI0:
6845           {
6846             po_reg_or_goto (REG_TYPE_VFSD, try_ifimm0);
6847             break;
6848             try_ifimm0:
6849             if (parse_ifimm_zero (&str))
6850               inst.operands[i].imm = 0;
6851             else
6852             {
6853               inst.error
6854                 = _("only floating point zero is allowed as immediate value");
6855               goto failure;
6856             }
6857           }
6858           break;
6859
6860         case OP_RR_RNSC:
6861           {
6862             po_scalar_or_goto (8, try_rr);
6863             break;
6864             try_rr:
6865             po_reg_or_fail (REG_TYPE_RN);
6866           }
6867           break;
6868
6869         case OP_RNSDQ_RNSC:
6870           {
6871             po_scalar_or_goto (8, try_nsdq);
6872             break;
6873             try_nsdq:
6874             po_reg_or_fail (REG_TYPE_NSDQ);
6875           }
6876           break;
6877
6878         case OP_RNSD_RNSC:
6879           {
6880             po_scalar_or_goto (8, try_s_scalar);
6881             break;
6882             try_s_scalar:
6883             po_scalar_or_goto (4, try_nsd);
6884             break;
6885             try_nsd:
6886             po_reg_or_fail (REG_TYPE_NSD);
6887           }
6888           break;
6889
6890         case OP_RNDQ_RNSC:
6891           {
6892             po_scalar_or_goto (8, try_ndq);
6893             break;
6894             try_ndq:
6895             po_reg_or_fail (REG_TYPE_NDQ);
6896           }
6897           break;
6898
6899         case OP_RND_RNSC:
6900           {
6901             po_scalar_or_goto (8, try_vfd);
6902             break;
6903             try_vfd:
6904             po_reg_or_fail (REG_TYPE_VFD);
6905           }
6906           break;
6907
6908         case OP_VMOV:
6909           /* WARNING: parse_neon_mov can move the operand counter, i. If we're
6910              not careful then bad things might happen.  */
6911           po_misc_or_fail (parse_neon_mov (&str, &i) == FAIL);
6912           break;
6913
6914         case OP_RNDQ_Ibig:
6915           {
6916             po_reg_or_goto (REG_TYPE_NDQ, try_immbig);
6917             break;
6918             try_immbig:
6919             /* There's a possibility of getting a 64-bit immediate here, so
6920                we need special handling.  */
6921             if (parse_big_immediate (&str, i, NULL, /*allow_symbol_p=*/FALSE)
6922                 == FAIL)
6923               {
6924                 inst.error = _("immediate value is out of range");
6925                 goto failure;
6926               }
6927           }
6928           break;
6929
6930         case OP_RNDQ_I63b:
6931           {
6932             po_reg_or_goto (REG_TYPE_NDQ, try_shimm);
6933             break;
6934             try_shimm:
6935             po_imm_or_fail (0, 63, TRUE);
6936           }
6937           break;
6938
6939         case OP_RRnpcb:
6940           po_char_or_fail ('[');
6941           po_reg_or_fail  (REG_TYPE_RN);
6942           po_char_or_fail (']');
6943           break;
6944
6945         case OP_RRnpctw:
6946         case OP_RRw:
6947         case OP_oRRw:
6948           po_reg_or_fail (REG_TYPE_RN);
6949           if (skip_past_char (&str, '!') == SUCCESS)
6950             inst.operands[i].writeback = 1;
6951           break;
6952
6953           /* Immediates */
6954         case OP_I7:      po_imm_or_fail (  0,      7, FALSE);   break;
6955         case OP_I15:     po_imm_or_fail (  0,     15, FALSE);   break;
6956         case OP_I16:     po_imm_or_fail (  1,     16, FALSE);   break;
6957         case OP_I16z:    po_imm_or_fail (  0,     16, FALSE);   break;
6958         case OP_I31:     po_imm_or_fail (  0,     31, FALSE);   break;
6959         case OP_I32:     po_imm_or_fail (  1,     32, FALSE);   break;
6960         case OP_I32z:    po_imm_or_fail (  0,     32, FALSE);   break;
6961         case OP_I63s:    po_imm_or_fail (-64,     63, FALSE);   break;
6962         case OP_I63:     po_imm_or_fail (  0,     63, FALSE);   break;
6963         case OP_I64:     po_imm_or_fail (  1,     64, FALSE);   break;
6964         case OP_I64z:    po_imm_or_fail (  0,     64, FALSE);   break;
6965         case OP_I255:    po_imm_or_fail (  0,    255, FALSE);   break;
6966
6967         case OP_I4b:     po_imm_or_fail (  1,      4, TRUE);    break;
6968         case OP_oI7b:
6969         case OP_I7b:     po_imm_or_fail (  0,      7, TRUE);    break;
6970         case OP_I15b:    po_imm_or_fail (  0,     15, TRUE);    break;
6971         case OP_oI31b:
6972         case OP_I31b:    po_imm_or_fail (  0,     31, TRUE);    break;
6973         case OP_oI32b:   po_imm_or_fail (  1,     32, TRUE);    break;
6974         case OP_oI32z:   po_imm_or_fail (  0,     32, TRUE);    break;
6975         case OP_oIffffb: po_imm_or_fail (  0, 0xffff, TRUE);    break;
6976
6977           /* Immediate variants */
6978         case OP_oI255c:
6979           po_char_or_fail ('{');
6980           po_imm_or_fail (0, 255, TRUE);
6981           po_char_or_fail ('}');
6982           break;
6983
6984         case OP_I31w:
6985           /* The expression parser chokes on a trailing !, so we have
6986              to find it first and zap it.  */
6987           {
6988             char *s = str;
6989             while (*s && *s != ',')
6990               s++;
6991             if (s[-1] == '!')
6992               {
6993                 s[-1] = '\0';
6994                 inst.operands[i].writeback = 1;
6995               }
6996             po_imm_or_fail (0, 31, TRUE);
6997             if (str == s - 1)
6998               str = s;
6999           }
7000           break;
7001
7002           /* Expressions */
7003         case OP_EXPi:   EXPi:
7004           po_misc_or_fail (my_get_expression (&inst.relocs[0].exp, &str,
7005                                               GE_OPT_PREFIX));
7006           break;
7007
7008         case OP_EXP:
7009           po_misc_or_fail (my_get_expression (&inst.relocs[0].exp, &str,
7010                                               GE_NO_PREFIX));
7011           break;
7012
7013         case OP_EXPr:   EXPr:
7014           po_misc_or_fail (my_get_expression (&inst.relocs[0].exp, &str,
7015                                               GE_NO_PREFIX));
7016           if (inst.relocs[0].exp.X_op == O_symbol)
7017             {
7018               val = parse_reloc (&str);
7019               if (val == -1)
7020                 {
7021                   inst.error = _("unrecognized relocation suffix");
7022                   goto failure;
7023                 }
7024               else if (val != BFD_RELOC_UNUSED)
7025                 {
7026                   inst.operands[i].imm = val;
7027                   inst.operands[i].hasreloc = 1;
7028                 }
7029             }
7030           break;
7031
7032         case OP_EXPs:
7033           po_misc_or_fail (my_get_expression (&inst.relocs[i].exp, &str,
7034                                               GE_NO_PREFIX));
7035           if (inst.relocs[i].exp.X_op == O_symbol)
7036             {
7037               inst.operands[i].hasreloc = 1;
7038             }
7039           else if (inst.relocs[i].exp.X_op == O_constant)
7040             {
7041               inst.operands[i].imm = inst.relocs[i].exp.X_add_number;
7042               inst.operands[i].hasreloc = 0;
7043             }
7044           break;
7045
7046           /* Operand for MOVW or MOVT.  */
7047         case OP_HALF:
7048           po_misc_or_fail (parse_half (&str));
7049           break;
7050
7051           /* Register or expression.  */
7052         case OP_RR_EXr:   po_reg_or_goto (REG_TYPE_RN, EXPr); break;
7053         case OP_RR_EXi:   po_reg_or_goto (REG_TYPE_RN, EXPi); break;
7054
7055           /* Register or immediate.  */
7056         case OP_RRnpc_I0: po_reg_or_goto (REG_TYPE_RN, I0);   break;
7057         I0:               po_imm_or_fail (0, 0, FALSE);       break;
7058
7059         case OP_RF_IF:    po_reg_or_goto (REG_TYPE_FN, IF);   break;
7060         IF:
7061           if (!is_immediate_prefix (*str))
7062             goto bad_args;
7063           str++;
7064           val = parse_fpa_immediate (&str);
7065           if (val == FAIL)
7066             goto failure;
7067           /* FPA immediates are encoded as registers 8-15.
7068              parse_fpa_immediate has already applied the offset.  */
7069           inst.operands[i].reg = val;
7070           inst.operands[i].isreg = 1;
7071           break;
7072
7073         case OP_RIWR_I32z: po_reg_or_goto (REG_TYPE_MMXWR, I32z); break;
7074         I32z:             po_imm_or_fail (0, 32, FALSE);          break;
7075
7076           /* Two kinds of register.  */
7077         case OP_RIWR_RIWC:
7078           {
7079             struct reg_entry *rege = arm_reg_parse_multi (&str);
7080             if (!rege
7081                 || (rege->type != REG_TYPE_MMXWR
7082                     && rege->type != REG_TYPE_MMXWC
7083                     && rege->type != REG_TYPE_MMXWCG))
7084               {
7085                 inst.error = _("iWMMXt data or control register expected");
7086                 goto failure;
7087               }
7088             inst.operands[i].reg = rege->number;
7089             inst.operands[i].isreg = (rege->type == REG_TYPE_MMXWR);
7090           }
7091           break;
7092
7093         case OP_RIWC_RIWG:
7094           {
7095             struct reg_entry *rege = arm_reg_parse_multi (&str);
7096             if (!rege
7097                 || (rege->type != REG_TYPE_MMXWC
7098                     && rege->type != REG_TYPE_MMXWCG))
7099               {
7100                 inst.error = _("iWMMXt control register expected");
7101                 goto failure;
7102               }
7103             inst.operands[i].reg = rege->number;
7104             inst.operands[i].isreg = 1;
7105           }
7106           break;
7107
7108           /* Misc */
7109         case OP_CPSF:    val = parse_cps_flags (&str);          break;
7110         case OP_ENDI:    val = parse_endian_specifier (&str);   break;
7111         case OP_oROR:    val = parse_ror (&str);                break;
7112         case OP_COND:    val = parse_cond (&str);               break;
7113         case OP_oBARRIER_I15:
7114           po_barrier_or_imm (str); break;
7115           immediate:
7116           if (parse_immediate (&str, &val, 0, 15, TRUE) == FAIL)
7117             goto failure;
7118           break;
7119
7120         case OP_wPSR:
7121         case OP_rPSR:
7122           po_reg_or_goto (REG_TYPE_RNB, try_psr);
7123           if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_virt))
7124             {
7125               inst.error = _("Banked registers are not available with this "
7126                              "architecture.");
7127               goto failure;
7128             }
7129           break;
7130           try_psr:
7131           val = parse_psr (&str, op_parse_code == OP_wPSR);
7132           break;
7133
7134         case OP_APSR_RR:
7135           po_reg_or_goto (REG_TYPE_RN, try_apsr);
7136           break;
7137           try_apsr:
7138           /* Parse "APSR_nvzc" operand (for FMSTAT-equivalent MRS
7139              instruction).  */
7140           if (strncasecmp (str, "APSR_", 5) == 0)
7141             {
7142               unsigned found = 0;
7143               str += 5;
7144               while (found < 15)
7145                 switch (*str++)
7146                   {
7147                   case 'c': found = (found & 1) ? 16 : found | 1; break;
7148                   case 'n': found = (found & 2) ? 16 : found | 2; break;
7149                   case 'z': found = (found & 4) ? 16 : found | 4; break;
7150                   case 'v': found = (found & 8) ? 16 : found | 8; break;
7151                   default: found = 16;
7152                   }
7153               if (found != 15)
7154                 goto failure;
7155               inst.operands[i].isvec = 1;
7156               /* APSR_nzcv is encoded in instructions as if it were the REG_PC.  */
7157               inst.operands[i].reg = REG_PC;
7158             }
7159           else
7160             goto failure;
7161           break;
7162
7163         case OP_TB:
7164           po_misc_or_fail (parse_tb (&str));
7165           break;
7166
7167           /* Register lists.  */
7168         case OP_REGLST:
7169           val = parse_reg_list (&str);
7170           if (*str == '^')
7171             {
7172               inst.operands[i].writeback = 1;
7173               str++;
7174             }
7175           break;
7176
7177         case OP_VRSLST:
7178           val = parse_vfp_reg_list (&str, &inst.operands[i].reg, REGLIST_VFP_S);
7179           break;
7180
7181         case OP_VRDLST:
7182           val = parse_vfp_reg_list (&str, &inst.operands[i].reg, REGLIST_VFP_D);
7183           break;
7184
7185         case OP_VRSDLST:
7186           /* Allow Q registers too.  */
7187           val = parse_vfp_reg_list (&str, &inst.operands[i].reg,
7188                                     REGLIST_NEON_D);
7189           if (val == FAIL)
7190             {
7191               inst.error = NULL;
7192               val = parse_vfp_reg_list (&str, &inst.operands[i].reg,
7193                                         REGLIST_VFP_S);
7194               inst.operands[i].issingle = 1;
7195             }
7196           break;
7197
7198         case OP_NRDLST:
7199           val = parse_vfp_reg_list (&str, &inst.operands[i].reg,
7200                                     REGLIST_NEON_D);
7201           break;
7202
7203         case OP_NSTRLST:
7204           val = parse_neon_el_struct_list (&str, &inst.operands[i].reg,
7205                                            &inst.operands[i].vectype);
7206           break;
7207
7208           /* Addressing modes */
7209         case OP_ADDR:
7210           po_misc_or_fail (parse_address (&str, i));
7211           break;
7212
7213         case OP_ADDRGLDR:
7214           po_misc_or_fail_no_backtrack (
7215             parse_address_group_reloc (&str, i, GROUP_LDR));
7216           break;
7217
7218         case OP_ADDRGLDRS:
7219           po_misc_or_fail_no_backtrack (
7220             parse_address_group_reloc (&str, i, GROUP_LDRS));
7221           break;
7222
7223         case OP_ADDRGLDC:
7224           po_misc_or_fail_no_backtrack (
7225             parse_address_group_reloc (&str, i, GROUP_LDC));
7226           break;
7227
7228         case OP_SH:
7229           po_misc_or_fail (parse_shifter_operand (&str, i));
7230           break;
7231
7232         case OP_SHG:
7233           po_misc_or_fail_no_backtrack (
7234             parse_shifter_operand_group_reloc (&str, i));
7235           break;
7236
7237         case OP_oSHll:
7238           po_misc_or_fail (parse_shift (&str, i, SHIFT_LSL_IMMEDIATE));
7239           break;
7240
7241         case OP_oSHar:
7242           po_misc_or_fail (parse_shift (&str, i, SHIFT_ASR_IMMEDIATE));
7243           break;
7244
7245         case OP_oSHllar:
7246           po_misc_or_fail (parse_shift (&str, i, SHIFT_LSL_OR_ASR_IMMEDIATE));
7247           break;
7248
7249         default:
7250           as_fatal (_("unhandled operand code %d"), op_parse_code);
7251         }
7252
7253       /* Various value-based sanity checks and shared operations.  We
7254          do not signal immediate failures for the register constraints;
7255          this allows a syntax error to take precedence.  */
7256       switch (op_parse_code)
7257         {
7258         case OP_oRRnpc:
7259         case OP_RRnpc:
7260         case OP_RRnpcb:
7261         case OP_RRw:
7262         case OP_oRRw:
7263         case OP_RRnpc_I0:
7264           if (inst.operands[i].isreg && inst.operands[i].reg == REG_PC)
7265             inst.error = BAD_PC;
7266           break;
7267
7268         case OP_oRRnpcsp:
7269         case OP_RRnpcsp:
7270           if (inst.operands[i].isreg)
7271             {
7272               if (inst.operands[i].reg == REG_PC)
7273                 inst.error = BAD_PC;
7274               else if (inst.operands[i].reg == REG_SP
7275                        /* The restriction on Rd/Rt/Rt2 on Thumb mode has been
7276                           relaxed since ARMv8-A.  */
7277                        && !ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
7278                 {
7279                   gas_assert (thumb);
7280                   inst.error = BAD_SP;
7281                 }
7282             }
7283           break;
7284
7285         case OP_RRnpctw:
7286           if (inst.operands[i].isreg
7287               && inst.operands[i].reg == REG_PC
7288               && (inst.operands[i].writeback || thumb))
7289             inst.error = BAD_PC;
7290           break;
7291
7292         case OP_CPSF:
7293         case OP_ENDI:
7294         case OP_oROR:
7295         case OP_wPSR:
7296         case OP_rPSR:
7297         case OP_COND:
7298         case OP_oBARRIER_I15:
7299         case OP_REGLST:
7300         case OP_VRSLST:
7301         case OP_VRDLST:
7302         case OP_VRSDLST:
7303         case OP_NRDLST:
7304         case OP_NSTRLST:
7305           if (val == FAIL)
7306             goto failure;
7307           inst.operands[i].imm = val;
7308           break;
7309
7310         default:
7311           break;
7312         }
7313
7314       /* If we get here, this operand was successfully parsed.  */
7315       inst.operands[i].present = 1;
7316       continue;
7317
7318     bad_args:
7319       inst.error = BAD_ARGS;
7320
7321     failure:
7322       if (!backtrack_pos)
7323         {
7324           /* The parse routine should already have set inst.error, but set a
7325              default here just in case.  */
7326           if (!inst.error)
7327             inst.error = _("syntax error");
7328           return FAIL;
7329         }
7330
7331       /* Do not backtrack over a trailing optional argument that
7332          absorbed some text.  We will only fail again, with the
7333          'garbage following instruction' error message, which is
7334          probably less helpful than the current one.  */
7335       if (backtrack_index == i && backtrack_pos != str
7336           && upat[i+1] == OP_stop)
7337         {
7338           if (!inst.error)
7339             inst.error = _("syntax error");
7340           return FAIL;
7341         }
7342
7343       /* Try again, skipping the optional argument at backtrack_pos.  */
7344       str = backtrack_pos;
7345       inst.error = backtrack_error;
7346       inst.operands[backtrack_index].present = 0;
7347       i = backtrack_index;
7348       backtrack_pos = 0;
7349     }
7350
7351   /* Check that we have parsed all the arguments.  */
7352   if (*str != '\0' && !inst.error)
7353     inst.error = _("garbage following instruction");
7354
7355   return inst.error ? FAIL : SUCCESS;
7356 }
7357
7358 #undef po_char_or_fail
7359 #undef po_reg_or_fail
7360 #undef po_reg_or_goto
7361 #undef po_imm_or_fail
7362 #undef po_scalar_or_fail
7363 #undef po_barrier_or_imm
7364
7365 /* Shorthand macro for instruction encoding functions issuing errors.  */
7366 #define constraint(expr, err)                   \
7367   do                                            \
7368     {                                           \
7369       if (expr)                                 \
7370         {                                       \
7371           inst.error = err;                     \
7372           return;                               \
7373         }                                       \
7374     }                                           \
7375   while (0)
7376
7377 /* Reject "bad registers" for Thumb-2 instructions.  Many Thumb-2
7378    instructions are unpredictable if these registers are used.  This
7379    is the BadReg predicate in ARM's Thumb-2 documentation.
7380
7381    Before ARMv8-A, REG_PC and REG_SP were not allowed in quite a few
7382    places, while the restriction on REG_SP was relaxed since ARMv8-A.  */
7383 #define reject_bad_reg(reg)                                     \
7384   do                                                            \
7385    if (reg == REG_PC)                                           \
7386      {                                                          \
7387        inst.error = BAD_PC;                                     \
7388        return;                                                  \
7389      }                                                          \
7390    else if (reg == REG_SP                                       \
7391             && !ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))  \
7392      {                                                          \
7393        inst.error = BAD_SP;                                     \
7394        return;                                                  \
7395      }                                                          \
7396   while (0)
7397
7398 /* If REG is R13 (the stack pointer), warn that its use is
7399    deprecated.  */
7400 #define warn_deprecated_sp(reg)                 \
7401   do                                            \
7402     if (warn_on_deprecated && reg == REG_SP)    \
7403        as_tsktsk (_("use of r13 is deprecated"));       \
7404   while (0)
7405
7406 /* Functions for operand encoding.  ARM, then Thumb.  */
7407
7408 #define rotate_left(v, n) (v << (n & 31) | v >> ((32 - n) & 31))
7409
7410 /* If the current inst is scalar ARMv8.2 fp16 instruction, do special encoding.
7411
7412    The only binary encoding difference is the Coprocessor number.  Coprocessor
7413    9 is used for half-precision calculations or conversions.  The format of the
7414    instruction is the same as the equivalent Coprocessor 10 instruction that
7415    exists for Single-Precision operation.  */
7416
7417 static void
7418 do_scalar_fp16_v82_encode (void)
7419 {
7420   if (inst.cond != COND_ALWAYS)
7421     as_warn (_("ARMv8.2 scalar fp16 instruction cannot be conditional,"
7422                " the behaviour is UNPREDICTABLE"));
7423   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_fp16),
7424               _(BAD_FP16));
7425
7426   inst.instruction = (inst.instruction & 0xfffff0ff) | 0x900;
7427   mark_feature_used (&arm_ext_fp16);
7428 }
7429
7430 /* If VAL can be encoded in the immediate field of an ARM instruction,
7431    return the encoded form.  Otherwise, return FAIL.  */
7432
7433 static unsigned int
7434 encode_arm_immediate (unsigned int val)
7435 {
7436   unsigned int a, i;
7437
7438   if (val <= 0xff)
7439     return val;
7440
7441   for (i = 2; i < 32; i += 2)
7442     if ((a = rotate_left (val, i)) <= 0xff)
7443       return a | (i << 7); /* 12-bit pack: [shift-cnt,const].  */
7444
7445   return FAIL;
7446 }
7447
7448 /* If VAL can be encoded in the immediate field of a Thumb32 instruction,
7449    return the encoded form.  Otherwise, return FAIL.  */
7450 static unsigned int
7451 encode_thumb32_immediate (unsigned int val)
7452 {
7453   unsigned int a, i;
7454
7455   if (val <= 0xff)
7456     return val;
7457
7458   for (i = 1; i <= 24; i++)
7459     {
7460       a = val >> i;
7461       if ((val & ~(0xff << i)) == 0)
7462         return ((val >> i) & 0x7f) | ((32 - i) << 7);
7463     }
7464
7465   a = val & 0xff;
7466   if (val == ((a << 16) | a))
7467     return 0x100 | a;
7468   if (val == ((a << 24) | (a << 16) | (a << 8) | a))
7469     return 0x300 | a;
7470
7471   a = val & 0xff00;
7472   if (val == ((a << 16) | a))
7473     return 0x200 | (a >> 8);
7474
7475   return FAIL;
7476 }
7477 /* Encode a VFP SP or DP register number into inst.instruction.  */
7478
7479 static void
7480 encode_arm_vfp_reg (int reg, enum vfp_reg_pos pos)
7481 {
7482   if ((pos == VFP_REG_Dd || pos == VFP_REG_Dn || pos == VFP_REG_Dm)
7483       && reg > 15)
7484     {
7485       if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_d32))
7486         {
7487           if (thumb_mode)
7488             ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
7489                                     fpu_vfp_ext_d32);
7490           else
7491             ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used,
7492                                     fpu_vfp_ext_d32);
7493         }
7494       else
7495         {
7496           first_error (_("D register out of range for selected VFP version"));
7497           return;
7498         }
7499     }
7500
7501   switch (pos)
7502     {
7503     case VFP_REG_Sd:
7504       inst.instruction |= ((reg >> 1) << 12) | ((reg & 1) << 22);
7505       break;
7506
7507     case VFP_REG_Sn:
7508       inst.instruction |= ((reg >> 1) << 16) | ((reg & 1) << 7);
7509       break;
7510
7511     case VFP_REG_Sm:
7512       inst.instruction |= ((reg >> 1) << 0) | ((reg & 1) << 5);
7513       break;
7514
7515     case VFP_REG_Dd:
7516       inst.instruction |= ((reg & 15) << 12) | ((reg >> 4) << 22);
7517       break;
7518
7519     case VFP_REG_Dn:
7520       inst.instruction |= ((reg & 15) << 16) | ((reg >> 4) << 7);
7521       break;
7522
7523     case VFP_REG_Dm:
7524       inst.instruction |= (reg & 15) | ((reg >> 4) << 5);
7525       break;
7526
7527     default:
7528       abort ();
7529     }
7530 }
7531
7532 /* Encode a <shift> in an ARM-format instruction.  The immediate,
7533    if any, is handled by md_apply_fix.   */
7534 static void
7535 encode_arm_shift (int i)
7536 {
7537   /* register-shifted register.  */
7538   if (inst.operands[i].immisreg)
7539     {
7540       int op_index;
7541       for (op_index = 0; op_index <= i; ++op_index)
7542         {
7543           /* Check the operand only when it's presented.  In pre-UAL syntax,
7544              if the destination register is the same as the first operand, two
7545              register form of the instruction can be used.  */
7546           if (inst.operands[op_index].present && inst.operands[op_index].isreg
7547               && inst.operands[op_index].reg == REG_PC)
7548             as_warn (UNPRED_REG ("r15"));
7549         }
7550
7551       if (inst.operands[i].imm == REG_PC)
7552         as_warn (UNPRED_REG ("r15"));
7553     }
7554
7555   if (inst.operands[i].shift_kind == SHIFT_RRX)
7556     inst.instruction |= SHIFT_ROR << 5;
7557   else
7558     {
7559       inst.instruction |= inst.operands[i].shift_kind << 5;
7560       if (inst.operands[i].immisreg)
7561         {
7562           inst.instruction |= SHIFT_BY_REG;
7563           inst.instruction |= inst.operands[i].imm << 8;
7564         }
7565       else
7566         inst.relocs[0].type = BFD_RELOC_ARM_SHIFT_IMM;
7567     }
7568 }
7569
7570 static void
7571 encode_arm_shifter_operand (int i)
7572 {
7573   if (inst.operands[i].isreg)
7574     {
7575       inst.instruction |= inst.operands[i].reg;
7576       encode_arm_shift (i);
7577     }
7578   else
7579     {
7580       inst.instruction |= INST_IMMEDIATE;
7581       if (inst.relocs[0].type != BFD_RELOC_ARM_IMMEDIATE)
7582         inst.instruction |= inst.operands[i].imm;
7583     }
7584 }
7585
7586 /* Subroutine of encode_arm_addr_mode_2 and encode_arm_addr_mode_3.  */
7587 static void
7588 encode_arm_addr_mode_common (int i, bfd_boolean is_t)
7589 {
7590   /* PR 14260:
7591      Generate an error if the operand is not a register.  */
7592   constraint (!inst.operands[i].isreg,
7593               _("Instruction does not support =N addresses"));
7594
7595   inst.instruction |= inst.operands[i].reg << 16;
7596
7597   if (inst.operands[i].preind)
7598     {
7599       if (is_t)
7600         {
7601           inst.error = _("instruction does not accept preindexed addressing");
7602           return;
7603         }
7604       inst.instruction |= PRE_INDEX;
7605       if (inst.operands[i].writeback)
7606         inst.instruction |= WRITE_BACK;
7607
7608     }
7609   else if (inst.operands[i].postind)
7610     {
7611       gas_assert (inst.operands[i].writeback);
7612       if (is_t)
7613         inst.instruction |= WRITE_BACK;
7614     }
7615   else /* unindexed - only for coprocessor */
7616     {
7617       inst.error = _("instruction does not accept unindexed addressing");
7618       return;
7619     }
7620
7621   if (((inst.instruction & WRITE_BACK) || !(inst.instruction & PRE_INDEX))
7622       && (((inst.instruction & 0x000f0000) >> 16)
7623           == ((inst.instruction & 0x0000f000) >> 12)))
7624     as_warn ((inst.instruction & LOAD_BIT)
7625              ? _("destination register same as write-back base")
7626              : _("source register same as write-back base"));
7627 }
7628
7629 /* inst.operands[i] was set up by parse_address.  Encode it into an
7630    ARM-format mode 2 load or store instruction.  If is_t is true,
7631    reject forms that cannot be used with a T instruction (i.e. not
7632    post-indexed).  */
7633 static void
7634 encode_arm_addr_mode_2 (int i, bfd_boolean is_t)
7635 {
7636   const bfd_boolean is_pc = (inst.operands[i].reg == REG_PC);
7637
7638   encode_arm_addr_mode_common (i, is_t);
7639
7640   if (inst.operands[i].immisreg)
7641     {
7642       constraint ((inst.operands[i].imm == REG_PC
7643                    || (is_pc && inst.operands[i].writeback)),
7644                   BAD_PC_ADDRESSING);
7645       inst.instruction |= INST_IMMEDIATE;  /* yes, this is backwards */
7646       inst.instruction |= inst.operands[i].imm;
7647       if (!inst.operands[i].negative)
7648         inst.instruction |= INDEX_UP;
7649       if (inst.operands[i].shifted)
7650         {
7651           if (inst.operands[i].shift_kind == SHIFT_RRX)
7652             inst.instruction |= SHIFT_ROR << 5;
7653           else
7654             {
7655               inst.instruction |= inst.operands[i].shift_kind << 5;
7656               inst.relocs[0].type = BFD_RELOC_ARM_SHIFT_IMM;
7657             }
7658         }
7659     }
7660   else /* immediate offset in inst.relocs[0] */
7661     {
7662       if (is_pc && !inst.relocs[0].pc_rel)
7663         {
7664           const bfd_boolean is_load = ((inst.instruction & LOAD_BIT) != 0);
7665
7666           /* If is_t is TRUE, it's called from do_ldstt.  ldrt/strt
7667              cannot use PC in addressing.
7668              PC cannot be used in writeback addressing, either.  */
7669           constraint ((is_t || inst.operands[i].writeback),
7670                       BAD_PC_ADDRESSING);
7671
7672           /* Use of PC in str is deprecated for ARMv7.  */
7673           if (warn_on_deprecated
7674               && !is_load
7675               && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v7))
7676             as_tsktsk (_("use of PC in this instruction is deprecated"));
7677         }
7678
7679       if (inst.relocs[0].type == BFD_RELOC_UNUSED)
7680         {
7681           /* Prefer + for zero encoded value.  */
7682           if (!inst.operands[i].negative)
7683             inst.instruction |= INDEX_UP;
7684           inst.relocs[0].type = BFD_RELOC_ARM_OFFSET_IMM;
7685         }
7686     }
7687 }
7688
7689 /* inst.operands[i] was set up by parse_address.  Encode it into an
7690    ARM-format mode 3 load or store instruction.  Reject forms that
7691    cannot be used with such instructions.  If is_t is true, reject
7692    forms that cannot be used with a T instruction (i.e. not
7693    post-indexed).  */
7694 static void
7695 encode_arm_addr_mode_3 (int i, bfd_boolean is_t)
7696 {
7697   if (inst.operands[i].immisreg && inst.operands[i].shifted)
7698     {
7699       inst.error = _("instruction does not accept scaled register index");
7700       return;
7701     }
7702
7703   encode_arm_addr_mode_common (i, is_t);
7704
7705   if (inst.operands[i].immisreg)
7706     {
7707       constraint ((inst.operands[i].imm == REG_PC
7708                    || (is_t && inst.operands[i].reg == REG_PC)),
7709                   BAD_PC_ADDRESSING);
7710       constraint (inst.operands[i].reg == REG_PC && inst.operands[i].writeback,
7711                   BAD_PC_WRITEBACK);
7712       inst.instruction |= inst.operands[i].imm;
7713       if (!inst.operands[i].negative)
7714         inst.instruction |= INDEX_UP;
7715     }
7716   else /* immediate offset in inst.relocs[0] */
7717     {
7718       constraint ((inst.operands[i].reg == REG_PC && !inst.relocs[0].pc_rel
7719                    && inst.operands[i].writeback),
7720                   BAD_PC_WRITEBACK);
7721       inst.instruction |= HWOFFSET_IMM;
7722       if (inst.relocs[0].type == BFD_RELOC_UNUSED)
7723         {
7724           /* Prefer + for zero encoded value.  */
7725           if (!inst.operands[i].negative)
7726             inst.instruction |= INDEX_UP;
7727
7728           inst.relocs[0].type = BFD_RELOC_ARM_OFFSET_IMM8;
7729         }
7730     }
7731 }
7732
7733 /* Write immediate bits [7:0] to the following locations:
7734
7735   |28/24|23     19|18 16|15                    4|3     0|
7736   |  a  |x x x x x|b c d|x x x x x x x x x x x x|e f g h|
7737
7738   This function is used by VMOV/VMVN/VORR/VBIC.  */
7739
7740 static void
7741 neon_write_immbits (unsigned immbits)
7742 {
7743   inst.instruction |= immbits & 0xf;
7744   inst.instruction |= ((immbits >> 4) & 0x7) << 16;
7745   inst.instruction |= ((immbits >> 7) & 0x1) << (thumb_mode ? 28 : 24);
7746 }
7747
7748 /* Invert low-order SIZE bits of XHI:XLO.  */
7749
7750 static void
7751 neon_invert_size (unsigned *xlo, unsigned *xhi, int size)
7752 {
7753   unsigned immlo = xlo ? *xlo : 0;
7754   unsigned immhi = xhi ? *xhi : 0;
7755
7756   switch (size)
7757     {
7758     case 8:
7759       immlo = (~immlo) & 0xff;
7760       break;
7761
7762     case 16:
7763       immlo = (~immlo) & 0xffff;
7764       break;
7765
7766     case 64:
7767       immhi = (~immhi) & 0xffffffff;
7768       /* fall through.  */
7769
7770     case 32:
7771       immlo = (~immlo) & 0xffffffff;
7772       break;
7773
7774     default:
7775       abort ();
7776     }
7777
7778   if (xlo)
7779     *xlo = immlo;
7780
7781   if (xhi)
7782     *xhi = immhi;
7783 }
7784
7785 /* True if IMM has form 0bAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD for bits
7786    A, B, C, D.  */
7787
7788 static int
7789 neon_bits_same_in_bytes (unsigned imm)
7790 {
7791   return ((imm & 0x000000ff) == 0 || (imm & 0x000000ff) == 0x000000ff)
7792          && ((imm & 0x0000ff00) == 0 || (imm & 0x0000ff00) == 0x0000ff00)
7793          && ((imm & 0x00ff0000) == 0 || (imm & 0x00ff0000) == 0x00ff0000)
7794          && ((imm & 0xff000000) == 0 || (imm & 0xff000000) == 0xff000000);
7795 }
7796
7797 /* For immediate of above form, return 0bABCD.  */
7798
7799 static unsigned
7800 neon_squash_bits (unsigned imm)
7801 {
7802   return (imm & 0x01) | ((imm & 0x0100) >> 7) | ((imm & 0x010000) >> 14)
7803          | ((imm & 0x01000000) >> 21);
7804 }
7805
7806 /* Compress quarter-float representation to 0b...000 abcdefgh.  */
7807
7808 static unsigned
7809 neon_qfloat_bits (unsigned imm)
7810 {
7811   return ((imm >> 19) & 0x7f) | ((imm >> 24) & 0x80);
7812 }
7813
7814 /* Returns CMODE. IMMBITS [7:0] is set to bits suitable for inserting into
7815    the instruction. *OP is passed as the initial value of the op field, and
7816    may be set to a different value depending on the constant (i.e.
7817    "MOV I64, 0bAAAAAAAABBBB..." which uses OP = 1 despite being MOV not
7818    MVN).  If the immediate looks like a repeated pattern then also
7819    try smaller element sizes.  */
7820
7821 static int
7822 neon_cmode_for_move_imm (unsigned immlo, unsigned immhi, int float_p,
7823                          unsigned *immbits, int *op, int size,
7824                          enum neon_el_type type)
7825 {
7826   /* Only permit float immediates (including 0.0/-0.0) if the operand type is
7827      float.  */
7828   if (type == NT_float && !float_p)
7829     return FAIL;
7830
7831   if (type == NT_float && is_quarter_float (immlo) && immhi == 0)
7832     {
7833       if (size != 32 || *op == 1)
7834         return FAIL;
7835       *immbits = neon_qfloat_bits (immlo);
7836       return 0xf;
7837     }
7838
7839   if (size == 64)
7840     {
7841       if (neon_bits_same_in_bytes (immhi)
7842           && neon_bits_same_in_bytes (immlo))
7843         {
7844           if (*op == 1)
7845             return FAIL;
7846           *immbits = (neon_squash_bits (immhi) << 4)
7847                      | neon_squash_bits (immlo);
7848           *op = 1;
7849           return 0xe;
7850         }
7851
7852       if (immhi != immlo)
7853         return FAIL;
7854     }
7855
7856   if (size >= 32)
7857     {
7858       if (immlo == (immlo & 0x000000ff))
7859         {
7860           *immbits = immlo;
7861           return 0x0;
7862         }
7863       else if (immlo == (immlo & 0x0000ff00))
7864         {
7865           *immbits = immlo >> 8;
7866           return 0x2;
7867         }
7868       else if (immlo == (immlo & 0x00ff0000))
7869         {
7870           *immbits = immlo >> 16;
7871           return 0x4;
7872         }
7873       else if (immlo == (immlo & 0xff000000))
7874         {
7875           *immbits = immlo >> 24;
7876           return 0x6;
7877         }
7878       else if (immlo == ((immlo & 0x0000ff00) | 0x000000ff))
7879         {
7880           *immbits = (immlo >> 8) & 0xff;
7881           return 0xc;
7882         }
7883       else if (immlo == ((immlo & 0x00ff0000) | 0x0000ffff))
7884         {
7885           *immbits = (immlo >> 16) & 0xff;
7886           return 0xd;
7887         }
7888
7889       if ((immlo & 0xffff) != (immlo >> 16))
7890         return FAIL;
7891       immlo &= 0xffff;
7892     }
7893
7894   if (size >= 16)
7895     {
7896       if (immlo == (immlo & 0x000000ff))
7897         {
7898           *immbits = immlo;
7899           return 0x8;
7900         }
7901       else if (immlo == (immlo & 0x0000ff00))
7902         {
7903           *immbits = immlo >> 8;
7904           return 0xa;
7905         }
7906
7907       if ((immlo & 0xff) != (immlo >> 8))
7908         return FAIL;
7909       immlo &= 0xff;
7910     }
7911
7912   if (immlo == (immlo & 0x000000ff))
7913     {
7914       /* Don't allow MVN with 8-bit immediate.  */
7915       if (*op == 1)
7916         return FAIL;
7917       *immbits = immlo;
7918       return 0xe;
7919     }
7920
7921   return FAIL;
7922 }
7923
7924 #if defined BFD_HOST_64_BIT
7925 /* Returns TRUE if double precision value V may be cast
7926    to single precision without loss of accuracy.  */
7927
7928 static bfd_boolean
7929 is_double_a_single (bfd_int64_t v)
7930 {
7931   int exp = (int)((v >> 52) & 0x7FF);
7932   bfd_int64_t mantissa = (v & (bfd_int64_t)0xFFFFFFFFFFFFFULL);
7933
7934   return (exp == 0 || exp == 0x7FF
7935           || (exp >= 1023 - 126 && exp <= 1023 + 127))
7936     && (mantissa & 0x1FFFFFFFl) == 0;
7937 }
7938
7939 /* Returns a double precision value casted to single precision
7940    (ignoring the least significant bits in exponent and mantissa).  */
7941
7942 static int
7943 double_to_single (bfd_int64_t v)
7944 {
7945   int sign = (int) ((v >> 63) & 1l);
7946   int exp = (int) ((v >> 52) & 0x7FF);
7947   bfd_int64_t mantissa = (v & (bfd_int64_t)0xFFFFFFFFFFFFFULL);
7948
7949   if (exp == 0x7FF)
7950     exp = 0xFF;
7951   else
7952     {
7953       exp = exp - 1023 + 127;
7954       if (exp >= 0xFF)
7955         {
7956           /* Infinity.  */
7957           exp = 0x7F;
7958           mantissa = 0;
7959         }
7960       else if (exp < 0)
7961         {
7962           /* No denormalized numbers.  */
7963           exp = 0;
7964           mantissa = 0;
7965         }
7966     }
7967   mantissa >>= 29;
7968   return (sign << 31) | (exp << 23) | mantissa;
7969 }
7970 #endif /* BFD_HOST_64_BIT */
7971
7972 enum lit_type
7973 {
7974   CONST_THUMB,
7975   CONST_ARM,
7976   CONST_VEC
7977 };
7978
7979 static void do_vfp_nsyn_opcode (const char *);
7980
7981 /* inst.relocs[0].exp describes an "=expr" load pseudo-operation.
7982    Determine whether it can be performed with a move instruction; if
7983    it can, convert inst.instruction to that move instruction and
7984    return TRUE; if it can't, convert inst.instruction to a literal-pool
7985    load and return FALSE.  If this is not a valid thing to do in the
7986    current context, set inst.error and return TRUE.
7987
7988    inst.operands[i] describes the destination register.  */
7989
7990 static bfd_boolean
7991 move_or_literal_pool (int i, enum lit_type t, bfd_boolean mode_3)
7992 {
7993   unsigned long tbit;
7994   bfd_boolean thumb_p = (t == CONST_THUMB);
7995   bfd_boolean arm_p   = (t == CONST_ARM);
7996
7997   if (thumb_p)
7998     tbit = (inst.instruction > 0xffff) ? THUMB2_LOAD_BIT : THUMB_LOAD_BIT;
7999   else
8000     tbit = LOAD_BIT;
8001
8002   if ((inst.instruction & tbit) == 0)
8003     {
8004       inst.error = _("invalid pseudo operation");
8005       return TRUE;
8006     }
8007
8008   if (inst.relocs[0].exp.X_op != O_constant
8009       && inst.relocs[0].exp.X_op != O_symbol
8010       && inst.relocs[0].exp.X_op != O_big)
8011     {
8012       inst.error = _("constant expression expected");
8013       return TRUE;
8014     }
8015
8016   if (inst.relocs[0].exp.X_op == O_constant
8017       || inst.relocs[0].exp.X_op == O_big)
8018     {
8019 #if defined BFD_HOST_64_BIT
8020       bfd_int64_t v;
8021 #else
8022       offsetT v;
8023 #endif
8024       if (inst.relocs[0].exp.X_op == O_big)
8025         {
8026           LITTLENUM_TYPE w[X_PRECISION];
8027           LITTLENUM_TYPE * l;
8028
8029           if (inst.relocs[0].exp.X_add_number == -1)
8030             {
8031               gen_to_words (w, X_PRECISION, E_PRECISION);
8032               l = w;
8033               /* FIXME: Should we check words w[2..5] ?  */
8034             }
8035           else
8036             l = generic_bignum;
8037
8038 #if defined BFD_HOST_64_BIT
8039           v =
8040             ((((((((bfd_int64_t) l[3] & LITTLENUM_MASK)
8041                   << LITTLENUM_NUMBER_OF_BITS)
8042                  | ((bfd_int64_t) l[2] & LITTLENUM_MASK))
8043                 << LITTLENUM_NUMBER_OF_BITS)
8044                | ((bfd_int64_t) l[1] & LITTLENUM_MASK))
8045               << LITTLENUM_NUMBER_OF_BITS)
8046              | ((bfd_int64_t) l[0] & LITTLENUM_MASK));
8047 #else
8048           v = ((l[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
8049             |  (l[0] & LITTLENUM_MASK);
8050 #endif
8051         }
8052       else
8053         v = inst.relocs[0].exp.X_add_number;
8054
8055       if (!inst.operands[i].issingle)
8056         {
8057           if (thumb_p)
8058             {
8059               /* LDR should not use lead in a flag-setting instruction being
8060                  chosen so we do not check whether movs can be used.  */
8061
8062               if ((ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6t2)
8063                   || ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6t2_v8m))
8064                   && inst.operands[i].reg != 13
8065                   && inst.operands[i].reg != 15)
8066                 {
8067                   /* Check if on thumb2 it can be done with a mov.w, mvn or
8068                      movw instruction.  */
8069                   unsigned int newimm;
8070                   bfd_boolean isNegated;
8071
8072                   newimm = encode_thumb32_immediate (v);
8073                   if (newimm != (unsigned int) FAIL)
8074                     isNegated = FALSE;
8075                   else
8076                     {
8077                       newimm = encode_thumb32_immediate (~v);
8078                       if (newimm != (unsigned int) FAIL)
8079                         isNegated = TRUE;
8080                     }
8081
8082                   /* The number can be loaded with a mov.w or mvn
8083                      instruction.  */
8084                   if (newimm != (unsigned int) FAIL
8085                       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6t2))
8086                     {
8087                       inst.instruction = (0xf04f0000  /*  MOV.W.  */
8088                                           | (inst.operands[i].reg << 8));
8089                       /* Change to MOVN.  */
8090                       inst.instruction |= (isNegated ? 0x200000 : 0);
8091                       inst.instruction |= (newimm & 0x800) << 15;
8092                       inst.instruction |= (newimm & 0x700) << 4;
8093                       inst.instruction |= (newimm & 0x0ff);
8094                       return TRUE;
8095                     }
8096                   /* The number can be loaded with a movw instruction.  */
8097                   else if ((v & ~0xFFFF) == 0
8098                            && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6t2_v8m))
8099                     {
8100                       int imm = v & 0xFFFF;
8101
8102                       inst.instruction = 0xf2400000;  /* MOVW.  */
8103                       inst.instruction |= (inst.operands[i].reg << 8);
8104                       inst.instruction |= (imm & 0xf000) << 4;
8105                       inst.instruction |= (imm & 0x0800) << 15;
8106                       inst.instruction |= (imm & 0x0700) << 4;
8107                       inst.instruction |= (imm & 0x00ff);
8108                       return TRUE;
8109                     }
8110                 }
8111             }
8112           else if (arm_p)
8113             {
8114               int value = encode_arm_immediate (v);
8115
8116               if (value != FAIL)
8117                 {
8118                   /* This can be done with a mov instruction.  */
8119                   inst.instruction &= LITERAL_MASK;
8120                   inst.instruction |= INST_IMMEDIATE | (OPCODE_MOV << DATA_OP_SHIFT);
8121                   inst.instruction |= value & 0xfff;
8122                   return TRUE;
8123                 }
8124
8125               value = encode_arm_immediate (~ v);
8126               if (value != FAIL)
8127                 {
8128                   /* This can be done with a mvn instruction.  */
8129                   inst.instruction &= LITERAL_MASK;
8130                   inst.instruction |= INST_IMMEDIATE | (OPCODE_MVN << DATA_OP_SHIFT);
8131                   inst.instruction |= value & 0xfff;
8132                   return TRUE;
8133                 }
8134             }
8135           else if (t == CONST_VEC && ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_v1))
8136             {
8137               int op = 0;
8138               unsigned immbits = 0;
8139               unsigned immlo = inst.operands[1].imm;
8140               unsigned immhi = inst.operands[1].regisimm
8141                 ? inst.operands[1].reg
8142                 : inst.relocs[0].exp.X_unsigned
8143                 ? 0
8144                 : ((bfd_int64_t)((int) immlo)) >> 32;
8145               int cmode = neon_cmode_for_move_imm (immlo, immhi, FALSE, &immbits,
8146                                                    &op, 64, NT_invtype);
8147
8148               if (cmode == FAIL)
8149                 {
8150                   neon_invert_size (&immlo, &immhi, 64);
8151                   op = !op;
8152                   cmode = neon_cmode_for_move_imm (immlo, immhi, FALSE, &immbits,
8153                                                    &op, 64, NT_invtype);
8154                 }
8155
8156               if (cmode != FAIL)
8157                 {
8158                   inst.instruction = (inst.instruction & VLDR_VMOV_SAME)
8159                     | (1 << 23)
8160                     | (cmode << 8)
8161                     | (op << 5)
8162                     | (1 << 4);
8163
8164                   /* Fill other bits in vmov encoding for both thumb and arm.  */
8165                   if (thumb_mode)
8166                     inst.instruction |= (0x7U << 29) | (0xF << 24);
8167                   else
8168                     inst.instruction |= (0xFU << 28) | (0x1 << 25);
8169                   neon_write_immbits (immbits);
8170                   return TRUE;
8171                 }
8172             }
8173         }
8174
8175       if (t == CONST_VEC)
8176         {
8177           /* Check if vldr Rx, =constant could be optimized to vmov Rx, #constant.  */
8178           if (inst.operands[i].issingle
8179               && is_quarter_float (inst.operands[1].imm)
8180               && ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v3xd))
8181             {
8182               inst.operands[1].imm =
8183                 neon_qfloat_bits (v);
8184               do_vfp_nsyn_opcode ("fconsts");
8185               return TRUE;
8186             }
8187
8188           /* If our host does not support a 64-bit type then we cannot perform
8189              the following optimization.  This mean that there will be a
8190              discrepancy between the output produced by an assembler built for
8191              a 32-bit-only host and the output produced from a 64-bit host, but
8192              this cannot be helped.  */
8193 #if defined BFD_HOST_64_BIT
8194           else if (!inst.operands[1].issingle
8195                    && ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v3))
8196             {
8197               if (is_double_a_single (v)
8198                   && is_quarter_float (double_to_single (v)))
8199                 {
8200                   inst.operands[1].imm =
8201                     neon_qfloat_bits (double_to_single (v));
8202                   do_vfp_nsyn_opcode ("fconstd");
8203                   return TRUE;
8204                 }
8205             }
8206 #endif
8207         }
8208     }
8209
8210   if (add_to_lit_pool ((!inst.operands[i].isvec
8211                         || inst.operands[i].issingle) ? 4 : 8) == FAIL)
8212     return TRUE;
8213
8214   inst.operands[1].reg = REG_PC;
8215   inst.operands[1].isreg = 1;
8216   inst.operands[1].preind = 1;
8217   inst.relocs[0].pc_rel = 1;
8218   inst.relocs[0].type = (thumb_p
8219                      ? BFD_RELOC_ARM_THUMB_OFFSET
8220                      : (mode_3
8221                         ? BFD_RELOC_ARM_HWLITERAL
8222                         : BFD_RELOC_ARM_LITERAL));
8223   return FALSE;
8224 }
8225
8226 /* inst.operands[i] was set up by parse_address.  Encode it into an
8227    ARM-format instruction.  Reject all forms which cannot be encoded
8228    into a coprocessor load/store instruction.  If wb_ok is false,
8229    reject use of writeback; if unind_ok is false, reject use of
8230    unindexed addressing.  If reloc_override is not 0, use it instead
8231    of BFD_ARM_CP_OFF_IMM, unless the initial relocation is a group one
8232    (in which case it is preserved).  */
8233
8234 static int
8235 encode_arm_cp_address (int i, int wb_ok, int unind_ok, int reloc_override)
8236 {
8237   if (!inst.operands[i].isreg)
8238     {
8239       /* PR 18256 */
8240       if (! inst.operands[0].isvec)
8241         {
8242           inst.error = _("invalid co-processor operand");
8243           return FAIL;
8244         }
8245       if (move_or_literal_pool (0, CONST_VEC, /*mode_3=*/FALSE))
8246         return SUCCESS;
8247     }
8248
8249   inst.instruction |= inst.operands[i].reg << 16;
8250
8251   gas_assert (!(inst.operands[i].preind && inst.operands[i].postind));
8252
8253   if (!inst.operands[i].preind && !inst.operands[i].postind) /* unindexed */
8254     {
8255       gas_assert (!inst.operands[i].writeback);
8256       if (!unind_ok)
8257         {
8258           inst.error = _("instruction does not support unindexed addressing");
8259           return FAIL;
8260         }
8261       inst.instruction |= inst.operands[i].imm;
8262       inst.instruction |= INDEX_UP;
8263       return SUCCESS;
8264     }
8265
8266   if (inst.operands[i].preind)
8267     inst.instruction |= PRE_INDEX;
8268
8269   if (inst.operands[i].writeback)
8270     {
8271       if (inst.operands[i].reg == REG_PC)
8272         {
8273           inst.error = _("pc may not be used with write-back");
8274           return FAIL;
8275         }
8276       if (!wb_ok)
8277         {
8278           inst.error = _("instruction does not support writeback");
8279           return FAIL;
8280         }
8281       inst.instruction |= WRITE_BACK;
8282     }
8283
8284   if (reloc_override)
8285     inst.relocs[0].type = (bfd_reloc_code_real_type) reloc_override;
8286   else if ((inst.relocs[0].type < BFD_RELOC_ARM_ALU_PC_G0_NC
8287             || inst.relocs[0].type > BFD_RELOC_ARM_LDC_SB_G2)
8288            && inst.relocs[0].type != BFD_RELOC_ARM_LDR_PC_G0)
8289     {
8290       if (thumb_mode)
8291         inst.relocs[0].type = BFD_RELOC_ARM_T32_CP_OFF_IMM;
8292       else
8293         inst.relocs[0].type = BFD_RELOC_ARM_CP_OFF_IMM;
8294     }
8295
8296   /* Prefer + for zero encoded value.  */
8297   if (!inst.operands[i].negative)
8298     inst.instruction |= INDEX_UP;
8299
8300   return SUCCESS;
8301 }
8302
8303 /* Functions for instruction encoding, sorted by sub-architecture.
8304    First some generics; their names are taken from the conventional
8305    bit positions for register arguments in ARM format instructions.  */
8306
8307 static void
8308 do_noargs (void)
8309 {
8310 }
8311
8312 static void
8313 do_rd (void)
8314 {
8315   inst.instruction |= inst.operands[0].reg << 12;
8316 }
8317
8318 static void
8319 do_rn (void)
8320 {
8321   inst.instruction |= inst.operands[0].reg << 16;
8322 }
8323
8324 static void
8325 do_rd_rm (void)
8326 {
8327   inst.instruction |= inst.operands[0].reg << 12;
8328   inst.instruction |= inst.operands[1].reg;
8329 }
8330
8331 static void
8332 do_rm_rn (void)
8333 {
8334   inst.instruction |= inst.operands[0].reg;
8335   inst.instruction |= inst.operands[1].reg << 16;
8336 }
8337
8338 static void
8339 do_rd_rn (void)
8340 {
8341   inst.instruction |= inst.operands[0].reg << 12;
8342   inst.instruction |= inst.operands[1].reg << 16;
8343 }
8344
8345 static void
8346 do_rn_rd (void)
8347 {
8348   inst.instruction |= inst.operands[0].reg << 16;
8349   inst.instruction |= inst.operands[1].reg << 12;
8350 }
8351
8352 static void
8353 do_tt (void)
8354 {
8355   inst.instruction |= inst.operands[0].reg << 8;
8356   inst.instruction |= inst.operands[1].reg << 16;
8357 }
8358
8359 static bfd_boolean
8360 check_obsolete (const arm_feature_set *feature, const char *msg)
8361 {
8362   if (ARM_CPU_IS_ANY (cpu_variant))
8363     {
8364       as_tsktsk ("%s", msg);
8365       return TRUE;
8366     }
8367   else if (ARM_CPU_HAS_FEATURE (cpu_variant, *feature))
8368     {
8369       as_bad ("%s", msg);
8370       return TRUE;
8371     }
8372
8373   return FALSE;
8374 }
8375
8376 static void
8377 do_rd_rm_rn (void)
8378 {
8379   unsigned Rn = inst.operands[2].reg;
8380   /* Enforce restrictions on SWP instruction.  */
8381   if ((inst.instruction & 0x0fbfffff) == 0x01000090)
8382     {
8383       constraint (Rn == inst.operands[0].reg || Rn == inst.operands[1].reg,
8384                   _("Rn must not overlap other operands"));
8385
8386       /* SWP{b} is obsolete for ARMv8-A, and deprecated for ARMv6* and ARMv7.
8387        */
8388       if (!check_obsolete (&arm_ext_v8,
8389                            _("swp{b} use is obsoleted for ARMv8 and later"))
8390           && warn_on_deprecated
8391           && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6))
8392         as_tsktsk (_("swp{b} use is deprecated for ARMv6 and ARMv7"));
8393     }
8394
8395   inst.instruction |= inst.operands[0].reg << 12;
8396   inst.instruction |= inst.operands[1].reg;
8397   inst.instruction |= Rn << 16;
8398 }
8399
8400 static void
8401 do_rd_rn_rm (void)
8402 {
8403   inst.instruction |= inst.operands[0].reg << 12;
8404   inst.instruction |= inst.operands[1].reg << 16;
8405   inst.instruction |= inst.operands[2].reg;
8406 }
8407
8408 static void
8409 do_rm_rd_rn (void)
8410 {
8411   constraint ((inst.operands[2].reg == REG_PC), BAD_PC);
8412   constraint (((inst.relocs[0].exp.X_op != O_constant
8413                 && inst.relocs[0].exp.X_op != O_illegal)
8414                || inst.relocs[0].exp.X_add_number != 0),
8415               BAD_ADDR_MODE);
8416   inst.instruction |= inst.operands[0].reg;
8417   inst.instruction |= inst.operands[1].reg << 12;
8418   inst.instruction |= inst.operands[2].reg << 16;
8419 }
8420
8421 static void
8422 do_imm0 (void)
8423 {
8424   inst.instruction |= inst.operands[0].imm;
8425 }
8426
8427 static void
8428 do_rd_cpaddr (void)
8429 {
8430   inst.instruction |= inst.operands[0].reg << 12;
8431   encode_arm_cp_address (1, TRUE, TRUE, 0);
8432 }
8433
8434 /* ARM instructions, in alphabetical order by function name (except
8435    that wrapper functions appear immediately after the function they
8436    wrap).  */
8437
8438 /* This is a pseudo-op of the form "adr rd, label" to be converted
8439    into a relative address of the form "add rd, pc, #label-.-8".  */
8440
8441 static void
8442 do_adr (void)
8443 {
8444   inst.instruction |= (inst.operands[0].reg << 12);  /* Rd */
8445
8446   /* Frag hacking will turn this into a sub instruction if the offset turns
8447      out to be negative.  */
8448   inst.relocs[0].type = BFD_RELOC_ARM_IMMEDIATE;
8449   inst.relocs[0].pc_rel = 1;
8450   inst.relocs[0].exp.X_add_number -= 8;
8451
8452   if (support_interwork
8453       && inst.relocs[0].exp.X_op == O_symbol
8454       && inst.relocs[0].exp.X_add_symbol != NULL
8455       && S_IS_DEFINED (inst.relocs[0].exp.X_add_symbol)
8456       && THUMB_IS_FUNC (inst.relocs[0].exp.X_add_symbol))
8457     inst.relocs[0].exp.X_add_number |= 1;
8458 }
8459
8460 /* This is a pseudo-op of the form "adrl rd, label" to be converted
8461    into a relative address of the form:
8462    add rd, pc, #low(label-.-8)"
8463    add rd, rd, #high(label-.-8)"  */
8464
8465 static void
8466 do_adrl (void)
8467 {
8468   inst.instruction |= (inst.operands[0].reg << 12);  /* Rd */
8469
8470   /* Frag hacking will turn this into a sub instruction if the offset turns
8471      out to be negative.  */
8472   inst.relocs[0].type          = BFD_RELOC_ARM_ADRL_IMMEDIATE;
8473   inst.relocs[0].pc_rel        = 1;
8474   inst.size                    = INSN_SIZE * 2;
8475   inst.relocs[0].exp.X_add_number -= 8;
8476
8477   if (support_interwork
8478       && inst.relocs[0].exp.X_op == O_symbol
8479       && inst.relocs[0].exp.X_add_symbol != NULL
8480       && S_IS_DEFINED (inst.relocs[0].exp.X_add_symbol)
8481       && THUMB_IS_FUNC (inst.relocs[0].exp.X_add_symbol))
8482     inst.relocs[0].exp.X_add_number |= 1;
8483 }
8484
8485 static void
8486 do_arit (void)
8487 {
8488   constraint (inst.relocs[0].type >= BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC
8489               && inst.relocs[0].type <= BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC ,
8490               THUMB1_RELOC_ONLY);
8491   if (!inst.operands[1].present)
8492     inst.operands[1].reg = inst.operands[0].reg;
8493   inst.instruction |= inst.operands[0].reg << 12;
8494   inst.instruction |= inst.operands[1].reg << 16;
8495   encode_arm_shifter_operand (2);
8496 }
8497
8498 static void
8499 do_barrier (void)
8500 {
8501   if (inst.operands[0].present)
8502     inst.instruction |= inst.operands[0].imm;
8503   else
8504     inst.instruction |= 0xf;
8505 }
8506
8507 static void
8508 do_bfc (void)
8509 {
8510   unsigned int msb = inst.operands[1].imm + inst.operands[2].imm;
8511   constraint (msb > 32, _("bit-field extends past end of register"));
8512   /* The instruction encoding stores the LSB and MSB,
8513      not the LSB and width.  */
8514   inst.instruction |= inst.operands[0].reg << 12;
8515   inst.instruction |= inst.operands[1].imm << 7;
8516   inst.instruction |= (msb - 1) << 16;
8517 }
8518
8519 static void
8520 do_bfi (void)
8521 {
8522   unsigned int msb;
8523
8524   /* #0 in second position is alternative syntax for bfc, which is
8525      the same instruction but with REG_PC in the Rm field.  */
8526   if (!inst.operands[1].isreg)
8527     inst.operands[1].reg = REG_PC;
8528
8529   msb = inst.operands[2].imm + inst.operands[3].imm;
8530   constraint (msb > 32, _("bit-field extends past end of register"));
8531   /* The instruction encoding stores the LSB and MSB,
8532      not the LSB and width.  */
8533   inst.instruction |= inst.operands[0].reg << 12;
8534   inst.instruction |= inst.operands[1].reg;
8535   inst.instruction |= inst.operands[2].imm << 7;
8536   inst.instruction |= (msb - 1) << 16;
8537 }
8538
8539 static void
8540 do_bfx (void)
8541 {
8542   constraint (inst.operands[2].imm + inst.operands[3].imm > 32,
8543               _("bit-field extends past end of register"));
8544   inst.instruction |= inst.operands[0].reg << 12;
8545   inst.instruction |= inst.operands[1].reg;
8546   inst.instruction |= inst.operands[2].imm << 7;
8547   inst.instruction |= (inst.operands[3].imm - 1) << 16;
8548 }
8549
8550 /* ARM V5 breakpoint instruction (argument parse)
8551      BKPT <16 bit unsigned immediate>
8552      Instruction is not conditional.
8553         The bit pattern given in insns[] has the COND_ALWAYS condition,
8554         and it is an error if the caller tried to override that.  */
8555
8556 static void
8557 do_bkpt (void)
8558 {
8559   /* Top 12 of 16 bits to bits 19:8.  */
8560   inst.instruction |= (inst.operands[0].imm & 0xfff0) << 4;
8561
8562   /* Bottom 4 of 16 bits to bits 3:0.  */
8563   inst.instruction |= inst.operands[0].imm & 0xf;
8564 }
8565
8566 static void
8567 encode_branch (int default_reloc)
8568 {
8569   if (inst.operands[0].hasreloc)
8570     {
8571       constraint (inst.operands[0].imm != BFD_RELOC_ARM_PLT32
8572                   && inst.operands[0].imm != BFD_RELOC_ARM_TLS_CALL,
8573                   _("the only valid suffixes here are '(plt)' and '(tlscall)'"));
8574       inst.relocs[0].type = inst.operands[0].imm == BFD_RELOC_ARM_PLT32
8575         ? BFD_RELOC_ARM_PLT32
8576         : thumb_mode ? BFD_RELOC_ARM_THM_TLS_CALL : BFD_RELOC_ARM_TLS_CALL;
8577     }
8578   else
8579     inst.relocs[0].type = (bfd_reloc_code_real_type) default_reloc;
8580   inst.relocs[0].pc_rel = 1;
8581 }
8582
8583 static void
8584 do_branch (void)
8585 {
8586 #ifdef OBJ_ELF
8587   if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
8588     encode_branch (BFD_RELOC_ARM_PCREL_JUMP);
8589   else
8590 #endif
8591     encode_branch (BFD_RELOC_ARM_PCREL_BRANCH);
8592 }
8593
8594 static void
8595 do_bl (void)
8596 {
8597 #ifdef OBJ_ELF
8598   if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
8599     {
8600       if (inst.cond == COND_ALWAYS)
8601         encode_branch (BFD_RELOC_ARM_PCREL_CALL);
8602       else
8603         encode_branch (BFD_RELOC_ARM_PCREL_JUMP);
8604     }
8605   else
8606 #endif
8607     encode_branch (BFD_RELOC_ARM_PCREL_BRANCH);
8608 }
8609
8610 /* ARM V5 branch-link-exchange instruction (argument parse)
8611      BLX <target_addr>          ie BLX(1)
8612      BLX{<condition>} <Rm>      ie BLX(2)
8613    Unfortunately, there are two different opcodes for this mnemonic.
8614    So, the insns[].value is not used, and the code here zaps values
8615         into inst.instruction.
8616    Also, the <target_addr> can be 25 bits, hence has its own reloc.  */
8617
8618 static void
8619 do_blx (void)
8620 {
8621   if (inst.operands[0].isreg)
8622     {
8623       /* Arg is a register; the opcode provided by insns[] is correct.
8624          It is not illegal to do "blx pc", just useless.  */
8625       if (inst.operands[0].reg == REG_PC)
8626         as_tsktsk (_("use of r15 in blx in ARM mode is not really useful"));
8627
8628       inst.instruction |= inst.operands[0].reg;
8629     }
8630   else
8631     {
8632       /* Arg is an address; this instruction cannot be executed
8633          conditionally, and the opcode must be adjusted.
8634          We retain the BFD_RELOC_ARM_PCREL_BLX till the very end
8635          where we generate out a BFD_RELOC_ARM_PCREL_CALL instead.  */
8636       constraint (inst.cond != COND_ALWAYS, BAD_COND);
8637       inst.instruction = 0xfa000000;
8638       encode_branch (BFD_RELOC_ARM_PCREL_BLX);
8639     }
8640 }
8641
8642 static void
8643 do_bx (void)
8644 {
8645   bfd_boolean want_reloc;
8646
8647   if (inst.operands[0].reg == REG_PC)
8648     as_tsktsk (_("use of r15 in bx in ARM mode is not really useful"));
8649
8650   inst.instruction |= inst.operands[0].reg;
8651   /* Output R_ARM_V4BX relocations if is an EABI object that looks like
8652      it is for ARMv4t or earlier.  */
8653   want_reloc = !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5);
8654   if (!ARM_FEATURE_ZERO (selected_object_arch)
8655       && !ARM_CPU_HAS_FEATURE (selected_object_arch, arm_ext_v5))
8656       want_reloc = TRUE;
8657
8658 #ifdef OBJ_ELF
8659   if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
8660 #endif
8661     want_reloc = FALSE;
8662
8663   if (want_reloc)
8664     inst.relocs[0].type = BFD_RELOC_ARM_V4BX;
8665 }
8666
8667
8668 /* ARM v5TEJ.  Jump to Jazelle code.  */
8669
8670 static void
8671 do_bxj (void)
8672 {
8673   if (inst.operands[0].reg == REG_PC)
8674     as_tsktsk (_("use of r15 in bxj is not really useful"));
8675
8676   inst.instruction |= inst.operands[0].reg;
8677 }
8678
8679 /* Co-processor data operation:
8680       CDP{cond} <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>{, <opcode_2>}
8681       CDP2      <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>{, <opcode_2>}  */
8682 static void
8683 do_cdp (void)
8684 {
8685   inst.instruction |= inst.operands[0].reg << 8;
8686   inst.instruction |= inst.operands[1].imm << 20;
8687   inst.instruction |= inst.operands[2].reg << 12;
8688   inst.instruction |= inst.operands[3].reg << 16;
8689   inst.instruction |= inst.operands[4].reg;
8690   inst.instruction |= inst.operands[5].imm << 5;
8691 }
8692
8693 static void
8694 do_cmp (void)
8695 {
8696   inst.instruction |= inst.operands[0].reg << 16;
8697   encode_arm_shifter_operand (1);
8698 }
8699
8700 /* Transfer between coprocessor and ARM registers.
8701    MRC{cond} <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>{, <opcode_2>}
8702    MRC2
8703    MCR{cond}
8704    MCR2
8705
8706    No special properties.  */
8707
8708 struct deprecated_coproc_regs_s
8709 {
8710   unsigned cp;
8711   int opc1;
8712   unsigned crn;
8713   unsigned crm;
8714   int opc2;
8715   arm_feature_set deprecated;
8716   arm_feature_set obsoleted;
8717   const char *dep_msg;
8718   const char *obs_msg;
8719 };
8720
8721 #define DEPR_ACCESS_V8 \
8722   N_("This coprocessor register access is deprecated in ARMv8")
8723
8724 /* Table of all deprecated coprocessor registers.  */
8725 static struct deprecated_coproc_regs_s deprecated_coproc_regs[] =
8726 {
8727     {15, 0, 7, 10, 5,                                   /* CP15DMB.  */
8728      ARM_FEATURE_CORE_LOW (ARM_EXT_V8), ARM_ARCH_NONE,
8729      DEPR_ACCESS_V8, NULL},
8730     {15, 0, 7, 10, 4,                                   /* CP15DSB.  */
8731      ARM_FEATURE_CORE_LOW (ARM_EXT_V8), ARM_ARCH_NONE,
8732      DEPR_ACCESS_V8, NULL},
8733     {15, 0, 7,  5, 4,                                   /* CP15ISB.  */
8734      ARM_FEATURE_CORE_LOW (ARM_EXT_V8), ARM_ARCH_NONE,
8735      DEPR_ACCESS_V8, NULL},
8736     {14, 6, 1,  0, 0,                                   /* TEEHBR.  */
8737      ARM_FEATURE_CORE_LOW (ARM_EXT_V8), ARM_ARCH_NONE,
8738      DEPR_ACCESS_V8, NULL},
8739     {14, 6, 0,  0, 0,                                   /* TEECR.  */
8740      ARM_FEATURE_CORE_LOW (ARM_EXT_V8), ARM_ARCH_NONE,
8741      DEPR_ACCESS_V8, NULL},
8742 };
8743
8744 #undef DEPR_ACCESS_V8
8745
8746 static const size_t deprecated_coproc_reg_count =
8747   sizeof (deprecated_coproc_regs) / sizeof (deprecated_coproc_regs[0]);
8748
8749 static void
8750 do_co_reg (void)
8751 {
8752   unsigned Rd;
8753   size_t i;
8754
8755   Rd = inst.operands[2].reg;
8756   if (thumb_mode)
8757     {
8758       if (inst.instruction == 0xee000010
8759           || inst.instruction == 0xfe000010)
8760         /* MCR, MCR2  */
8761         reject_bad_reg (Rd);
8762       else if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
8763         /* MRC, MRC2  */
8764         constraint (Rd == REG_SP, BAD_SP);
8765     }
8766   else
8767     {
8768       /* MCR */
8769       if (inst.instruction == 0xe000010)
8770         constraint (Rd == REG_PC, BAD_PC);
8771     }
8772
8773     for (i = 0; i < deprecated_coproc_reg_count; ++i)
8774       {
8775         const struct deprecated_coproc_regs_s *r =
8776           deprecated_coproc_regs + i;
8777
8778         if (inst.operands[0].reg == r->cp
8779             && inst.operands[1].imm == r->opc1
8780             && inst.operands[3].reg == r->crn
8781             && inst.operands[4].reg == r->crm
8782             && inst.operands[5].imm == r->opc2)
8783           {
8784             if (! ARM_CPU_IS_ANY (cpu_variant)
8785                 && warn_on_deprecated
8786                 && ARM_CPU_HAS_FEATURE (cpu_variant, r->deprecated))
8787               as_tsktsk ("%s", r->dep_msg);
8788           }
8789       }
8790
8791   inst.instruction |= inst.operands[0].reg << 8;
8792   inst.instruction |= inst.operands[1].imm << 21;
8793   inst.instruction |= Rd << 12;
8794   inst.instruction |= inst.operands[3].reg << 16;
8795   inst.instruction |= inst.operands[4].reg;
8796   inst.instruction |= inst.operands[5].imm << 5;
8797 }
8798
8799 /* Transfer between coprocessor register and pair of ARM registers.
8800    MCRR{cond} <coproc>, <opcode>, <Rd>, <Rn>, <CRm>.
8801    MCRR2
8802    MRRC{cond}
8803    MRRC2
8804
8805    Two XScale instructions are special cases of these:
8806
8807      MAR{cond} acc0, <RdLo>, <RdHi> == MCRR{cond} p0, #0, <RdLo>, <RdHi>, c0
8808      MRA{cond} acc0, <RdLo>, <RdHi> == MRRC{cond} p0, #0, <RdLo>, <RdHi>, c0
8809
8810    Result unpredictable if Rd or Rn is R15.  */
8811
8812 static void
8813 do_co_reg2c (void)
8814 {
8815   unsigned Rd, Rn;
8816
8817   Rd = inst.operands[2].reg;
8818   Rn = inst.operands[3].reg;
8819
8820   if (thumb_mode)
8821     {
8822       reject_bad_reg (Rd);
8823       reject_bad_reg (Rn);
8824     }
8825   else
8826     {
8827       constraint (Rd == REG_PC, BAD_PC);
8828       constraint (Rn == REG_PC, BAD_PC);
8829     }
8830
8831   /* Only check the MRRC{2} variants.  */
8832   if ((inst.instruction & 0x0FF00000) == 0x0C500000)
8833     {
8834        /* If Rd == Rn, error that the operation is
8835           unpredictable (example MRRC p3,#1,r1,r1,c4).  */
8836        constraint (Rd == Rn, BAD_OVERLAP);
8837     }
8838
8839   inst.instruction |= inst.operands[0].reg << 8;
8840   inst.instruction |= inst.operands[1].imm << 4;
8841   inst.instruction |= Rd << 12;
8842   inst.instruction |= Rn << 16;
8843   inst.instruction |= inst.operands[4].reg;
8844 }
8845
8846 static void
8847 do_cpsi (void)
8848 {
8849   inst.instruction |= inst.operands[0].imm << 6;
8850   if (inst.operands[1].present)
8851     {
8852       inst.instruction |= CPSI_MMOD;
8853       inst.instruction |= inst.operands[1].imm;
8854     }
8855 }
8856
8857 static void
8858 do_dbg (void)
8859 {
8860   inst.instruction |= inst.operands[0].imm;
8861 }
8862
8863 static void
8864 do_div (void)
8865 {
8866   unsigned Rd, Rn, Rm;
8867
8868   Rd = inst.operands[0].reg;
8869   Rn = (inst.operands[1].present
8870         ? inst.operands[1].reg : Rd);
8871   Rm = inst.operands[2].reg;
8872
8873   constraint ((Rd == REG_PC), BAD_PC);
8874   constraint ((Rn == REG_PC), BAD_PC);
8875   constraint ((Rm == REG_PC), BAD_PC);
8876
8877   inst.instruction |= Rd << 16;
8878   inst.instruction |= Rn << 0;
8879   inst.instruction |= Rm << 8;
8880 }
8881
8882 static void
8883 do_it (void)
8884 {
8885   /* There is no IT instruction in ARM mode.  We
8886      process it to do the validation as if in
8887      thumb mode, just in case the code gets
8888      assembled for thumb using the unified syntax.  */
8889
8890   inst.size = 0;
8891   if (unified_syntax)
8892     {
8893       set_it_insn_type (IT_INSN);
8894       now_it.mask = (inst.instruction & 0xf) | 0x10;
8895       now_it.cc = inst.operands[0].imm;
8896     }
8897 }
8898
8899 /* If there is only one register in the register list,
8900    then return its register number.  Otherwise return -1.  */
8901 static int
8902 only_one_reg_in_list (int range)
8903 {
8904   int i = ffs (range) - 1;
8905   return (i > 15 || range != (1 << i)) ? -1 : i;
8906 }
8907
8908 static void
8909 encode_ldmstm(int from_push_pop_mnem)
8910 {
8911   int base_reg = inst.operands[0].reg;
8912   int range = inst.operands[1].imm;
8913   int one_reg;
8914
8915   inst.instruction |= base_reg << 16;
8916   inst.instruction |= range;
8917
8918   if (inst.operands[1].writeback)
8919     inst.instruction |= LDM_TYPE_2_OR_3;
8920
8921   if (inst.operands[0].writeback)
8922     {
8923       inst.instruction |= WRITE_BACK;
8924       /* Check for unpredictable uses of writeback.  */
8925       if (inst.instruction & LOAD_BIT)
8926         {
8927           /* Not allowed in LDM type 2.  */
8928           if ((inst.instruction & LDM_TYPE_2_OR_3)
8929               && ((range & (1 << REG_PC)) == 0))
8930             as_warn (_("writeback of base register is UNPREDICTABLE"));
8931           /* Only allowed if base reg not in list for other types.  */
8932           else if (range & (1 << base_reg))
8933             as_warn (_("writeback of base register when in register list is UNPREDICTABLE"));
8934         }
8935       else /* STM.  */
8936         {
8937           /* Not allowed for type 2.  */
8938           if (inst.instruction & LDM_TYPE_2_OR_3)
8939             as_warn (_("writeback of base register is UNPREDICTABLE"));
8940           /* Only allowed if base reg not in list, or first in list.  */
8941           else if ((range & (1 << base_reg))
8942                    && (range & ((1 << base_reg) - 1)))
8943             as_warn (_("if writeback register is in list, it must be the lowest reg in the list"));
8944         }
8945     }
8946
8947   /* If PUSH/POP has only one register, then use the A2 encoding.  */
8948   one_reg = only_one_reg_in_list (range);
8949   if (from_push_pop_mnem && one_reg >= 0)
8950     {
8951       int is_push = (inst.instruction & A_PUSH_POP_OP_MASK) == A1_OPCODE_PUSH;
8952
8953       if (is_push && one_reg == 13 /* SP */)
8954         /* PR 22483: The A2 encoding cannot be used when
8955            pushing the stack pointer as this is UNPREDICTABLE.  */
8956         return;
8957
8958       inst.instruction &= A_COND_MASK;
8959       inst.instruction |= is_push ? A2_OPCODE_PUSH : A2_OPCODE_POP;
8960       inst.instruction |= one_reg << 12;
8961     }
8962 }
8963
8964 static void
8965 do_ldmstm (void)
8966 {
8967   encode_ldmstm (/*from_push_pop_mnem=*/FALSE);
8968 }
8969
8970 /* ARMv5TE load-consecutive (argument parse)
8971    Mode is like LDRH.
8972
8973      LDRccD R, mode
8974      STRccD R, mode.  */
8975
8976 static void
8977 do_ldrd (void)
8978 {
8979   constraint (inst.operands[0].reg % 2 != 0,
8980               _("first transfer register must be even"));
8981   constraint (inst.operands[1].present
8982               && inst.operands[1].reg != inst.operands[0].reg + 1,
8983               _("can only transfer two consecutive registers"));
8984   constraint (inst.operands[0].reg == REG_LR, _("r14 not allowed here"));
8985   constraint (!inst.operands[2].isreg, _("'[' expected"));
8986
8987   if (!inst.operands[1].present)
8988     inst.operands[1].reg = inst.operands[0].reg + 1;
8989
8990   /* encode_arm_addr_mode_3 will diagnose overlap between the base
8991      register and the first register written; we have to diagnose
8992      overlap between the base and the second register written here.  */
8993
8994   if (inst.operands[2].reg == inst.operands[1].reg
8995       && (inst.operands[2].writeback || inst.operands[2].postind))
8996     as_warn (_("base register written back, and overlaps "
8997                "second transfer register"));
8998
8999   if (!(inst.instruction & V4_STR_BIT))
9000     {
9001       /* For an index-register load, the index register must not overlap the
9002         destination (even if not write-back).  */
9003       if (inst.operands[2].immisreg
9004               && ((unsigned) inst.operands[2].imm == inst.operands[0].reg
9005               || (unsigned) inst.operands[2].imm == inst.operands[1].reg))
9006         as_warn (_("index register overlaps transfer register"));
9007     }
9008   inst.instruction |= inst.operands[0].reg << 12;
9009   encode_arm_addr_mode_3 (2, /*is_t=*/FALSE);
9010 }
9011
9012 static void
9013 do_ldrex (void)
9014 {
9015   constraint (!inst.operands[1].isreg || !inst.operands[1].preind
9016               || inst.operands[1].postind || inst.operands[1].writeback
9017               || inst.operands[1].immisreg || inst.operands[1].shifted
9018               || inst.operands[1].negative
9019               /* This can arise if the programmer has written
9020                    strex rN, rM, foo
9021                  or if they have mistakenly used a register name as the last
9022                  operand,  eg:
9023                    strex rN, rM, rX
9024                  It is very difficult to distinguish between these two cases
9025                  because "rX" might actually be a label. ie the register
9026                  name has been occluded by a symbol of the same name. So we
9027                  just generate a general 'bad addressing mode' type error
9028                  message and leave it up to the programmer to discover the
9029                  true cause and fix their mistake.  */
9030               || (inst.operands[1].reg == REG_PC),
9031               BAD_ADDR_MODE);
9032
9033   constraint (inst.relocs[0].exp.X_op != O_constant
9034               || inst.relocs[0].exp.X_add_number != 0,
9035               _("offset must be zero in ARM encoding"));
9036
9037   constraint ((inst.operands[1].reg == REG_PC), BAD_PC);
9038
9039   inst.instruction |= inst.operands[0].reg << 12;
9040   inst.instruction |= inst.operands[1].reg << 16;
9041   inst.relocs[0].type = BFD_RELOC_UNUSED;
9042 }
9043
9044 static void
9045 do_ldrexd (void)
9046 {
9047   constraint (inst.operands[0].reg % 2 != 0,
9048               _("even register required"));
9049   constraint (inst.operands[1].present
9050               && inst.operands[1].reg != inst.operands[0].reg + 1,
9051               _("can only load two consecutive registers"));
9052   /* If op 1 were present and equal to PC, this function wouldn't
9053      have been called in the first place.  */
9054   constraint (inst.operands[0].reg == REG_LR, _("r14 not allowed here"));
9055
9056   inst.instruction |= inst.operands[0].reg << 12;
9057   inst.instruction |= inst.operands[2].reg << 16;
9058 }
9059
9060 /* In both ARM and thumb state 'ldr pc, #imm'  with an immediate
9061    which is not a multiple of four is UNPREDICTABLE.  */
9062 static void
9063 check_ldr_r15_aligned (void)
9064 {
9065   constraint (!(inst.operands[1].immisreg)
9066               && (inst.operands[0].reg == REG_PC
9067               && inst.operands[1].reg == REG_PC
9068               && (inst.relocs[0].exp.X_add_number & 0x3)),
9069               _("ldr to register 15 must be 4-byte aligned"));
9070 }
9071
9072 static void
9073 do_ldst (void)
9074 {
9075   inst.instruction |= inst.operands[0].reg << 12;
9076   if (!inst.operands[1].isreg)
9077     if (move_or_literal_pool (0, CONST_ARM, /*mode_3=*/FALSE))
9078       return;
9079   encode_arm_addr_mode_2 (1, /*is_t=*/FALSE);
9080   check_ldr_r15_aligned ();
9081 }
9082
9083 static void
9084 do_ldstt (void)
9085 {
9086   /* ldrt/strt always use post-indexed addressing.  Turn [Rn] into [Rn]! and
9087      reject [Rn,...].  */
9088   if (inst.operands[1].preind)
9089     {
9090       constraint (inst.relocs[0].exp.X_op != O_constant
9091                   || inst.relocs[0].exp.X_add_number != 0,
9092                   _("this instruction requires a post-indexed address"));
9093
9094       inst.operands[1].preind = 0;
9095       inst.operands[1].postind = 1;
9096       inst.operands[1].writeback = 1;
9097     }
9098   inst.instruction |= inst.operands[0].reg << 12;
9099   encode_arm_addr_mode_2 (1, /*is_t=*/TRUE);
9100 }
9101
9102 /* Halfword and signed-byte load/store operations.  */
9103
9104 static void
9105 do_ldstv4 (void)
9106 {
9107   constraint (inst.operands[0].reg == REG_PC, BAD_PC);
9108   inst.instruction |= inst.operands[0].reg << 12;
9109   if (!inst.operands[1].isreg)
9110     if (move_or_literal_pool (0, CONST_ARM, /*mode_3=*/TRUE))
9111       return;
9112   encode_arm_addr_mode_3 (1, /*is_t=*/FALSE);
9113 }
9114
9115 static void
9116 do_ldsttv4 (void)
9117 {
9118   /* ldrt/strt always use post-indexed addressing.  Turn [Rn] into [Rn]! and
9119      reject [Rn,...].  */
9120   if (inst.operands[1].preind)
9121     {
9122       constraint (inst.relocs[0].exp.X_op != O_constant
9123                   || inst.relocs[0].exp.X_add_number != 0,
9124                   _("this instruction requires a post-indexed address"));
9125
9126       inst.operands[1].preind = 0;
9127       inst.operands[1].postind = 1;
9128       inst.operands[1].writeback = 1;
9129     }
9130   inst.instruction |= inst.operands[0].reg << 12;
9131   encode_arm_addr_mode_3 (1, /*is_t=*/TRUE);
9132 }
9133
9134 /* Co-processor register load/store.
9135    Format: <LDC|STC>{cond}[L] CP#,CRd,<address>  */
9136 static void
9137 do_lstc (void)
9138 {
9139   inst.instruction |= inst.operands[0].reg << 8;
9140   inst.instruction |= inst.operands[1].reg << 12;
9141   encode_arm_cp_address (2, TRUE, TRUE, 0);
9142 }
9143
9144 static void
9145 do_mlas (void)
9146 {
9147   /* This restriction does not apply to mls (nor to mla in v6 or later).  */
9148   if (inst.operands[0].reg == inst.operands[1].reg
9149       && !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6)
9150       && !(inst.instruction & 0x00400000))
9151     as_tsktsk (_("Rd and Rm should be different in mla"));
9152
9153   inst.instruction |= inst.operands[0].reg << 16;
9154   inst.instruction |= inst.operands[1].reg;
9155   inst.instruction |= inst.operands[2].reg << 8;
9156   inst.instruction |= inst.operands[3].reg << 12;
9157 }
9158
9159 static void
9160 do_mov (void)
9161 {
9162   constraint (inst.relocs[0].type >= BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC
9163               && inst.relocs[0].type <= BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC ,
9164               THUMB1_RELOC_ONLY);
9165   inst.instruction |= inst.operands[0].reg << 12;
9166   encode_arm_shifter_operand (1);
9167 }
9168
9169 /* ARM V6T2 16-bit immediate register load: MOV[WT]{cond} Rd, #<imm16>.  */
9170 static void
9171 do_mov16 (void)
9172 {
9173   bfd_vma imm;
9174   bfd_boolean top;
9175
9176   top = (inst.instruction & 0x00400000) != 0;
9177   constraint (top && inst.relocs[0].type == BFD_RELOC_ARM_MOVW,
9178               _(":lower16: not allowed in this instruction"));
9179   constraint (!top && inst.relocs[0].type == BFD_RELOC_ARM_MOVT,
9180               _(":upper16: not allowed in this instruction"));
9181   inst.instruction |= inst.operands[0].reg << 12;
9182   if (inst.relocs[0].type == BFD_RELOC_UNUSED)
9183     {
9184       imm = inst.relocs[0].exp.X_add_number;
9185       /* The value is in two pieces: 0:11, 16:19.  */
9186       inst.instruction |= (imm & 0x00000fff);
9187       inst.instruction |= (imm & 0x0000f000) << 4;
9188     }
9189 }
9190
9191 static int
9192 do_vfp_nsyn_mrs (void)
9193 {
9194   if (inst.operands[0].isvec)
9195     {
9196       if (inst.operands[1].reg != 1)
9197         first_error (_("operand 1 must be FPSCR"));
9198       memset (&inst.operands[0], '\0', sizeof (inst.operands[0]));
9199       memset (&inst.operands[1], '\0', sizeof (inst.operands[1]));
9200       do_vfp_nsyn_opcode ("fmstat");
9201     }
9202   else if (inst.operands[1].isvec)
9203     do_vfp_nsyn_opcode ("fmrx");
9204   else
9205     return FAIL;
9206
9207   return SUCCESS;
9208 }
9209
9210 static int
9211 do_vfp_nsyn_msr (void)
9212 {
9213   if (inst.operands[0].isvec)
9214     do_vfp_nsyn_opcode ("fmxr");
9215   else
9216     return FAIL;
9217
9218   return SUCCESS;
9219 }
9220
9221 static void
9222 do_vmrs (void)
9223 {
9224   unsigned Rt = inst.operands[0].reg;
9225
9226   if (thumb_mode && Rt == REG_SP)
9227     {
9228       inst.error = BAD_SP;
9229       return;
9230     }
9231
9232   /* MVFR2 is only valid at ARMv8-A.  */
9233   if (inst.operands[1].reg == 5)
9234     constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
9235                 _(BAD_FPU));
9236
9237   /* APSR_ sets isvec. All other refs to PC are illegal.  */
9238   if (!inst.operands[0].isvec && Rt == REG_PC)
9239     {
9240       inst.error = BAD_PC;
9241       return;
9242     }
9243
9244   /* If we get through parsing the register name, we just insert the number
9245      generated into the instruction without further validation.  */
9246   inst.instruction |= (inst.operands[1].reg << 16);
9247   inst.instruction |= (Rt << 12);
9248 }
9249
9250 static void
9251 do_vmsr (void)
9252 {
9253   unsigned Rt = inst.operands[1].reg;
9254
9255   if (thumb_mode)
9256     reject_bad_reg (Rt);
9257   else if (Rt == REG_PC)
9258     {
9259       inst.error = BAD_PC;
9260       return;
9261     }
9262
9263   /* MVFR2 is only valid for ARMv8-A.  */
9264   if (inst.operands[0].reg == 5)
9265     constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
9266                 _(BAD_FPU));
9267
9268   /* If we get through parsing the register name, we just insert the number
9269      generated into the instruction without further validation.  */
9270   inst.instruction |= (inst.operands[0].reg << 16);
9271   inst.instruction |= (Rt << 12);
9272 }
9273
9274 static void
9275 do_mrs (void)
9276 {
9277   unsigned br;
9278
9279   if (do_vfp_nsyn_mrs () == SUCCESS)
9280     return;
9281
9282   constraint (inst.operands[0].reg == REG_PC, BAD_PC);
9283   inst.instruction |= inst.operands[0].reg << 12;
9284
9285   if (inst.operands[1].isreg)
9286     {
9287       br = inst.operands[1].reg;
9288       if (((br & 0x200) == 0) && ((br & 0xf0000) != 0xf0000))
9289         as_bad (_("bad register for mrs"));
9290     }
9291   else
9292     {
9293       /* mrs only accepts CPSR/SPSR/CPSR_all/SPSR_all.  */
9294       constraint ((inst.operands[1].imm & (PSR_c|PSR_x|PSR_s|PSR_f))
9295                   != (PSR_c|PSR_f),
9296                   _("'APSR', 'CPSR' or 'SPSR' expected"));
9297       br = (15<<16) | (inst.operands[1].imm & SPSR_BIT);
9298     }
9299
9300   inst.instruction |= br;
9301 }
9302
9303 /* Two possible forms:
9304       "{C|S}PSR_<field>, Rm",
9305       "{C|S}PSR_f, #expression".  */
9306
9307 static void
9308 do_msr (void)
9309 {
9310   if (do_vfp_nsyn_msr () == SUCCESS)
9311     return;
9312
9313   inst.instruction |= inst.operands[0].imm;
9314   if (inst.operands[1].isreg)
9315     inst.instruction |= inst.operands[1].reg;
9316   else
9317     {
9318       inst.instruction |= INST_IMMEDIATE;
9319       inst.relocs[0].type = BFD_RELOC_ARM_IMMEDIATE;
9320       inst.relocs[0].pc_rel = 0;
9321     }
9322 }
9323
9324 static void
9325 do_mul (void)
9326 {
9327   constraint (inst.operands[2].reg == REG_PC, BAD_PC);
9328
9329   if (!inst.operands[2].present)
9330     inst.operands[2].reg = inst.operands[0].reg;
9331   inst.instruction |= inst.operands[0].reg << 16;
9332   inst.instruction |= inst.operands[1].reg;
9333   inst.instruction |= inst.operands[2].reg << 8;
9334
9335   if (inst.operands[0].reg == inst.operands[1].reg
9336       && !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6))
9337     as_tsktsk (_("Rd and Rm should be different in mul"));
9338 }
9339
9340 /* Long Multiply Parser
9341    UMULL RdLo, RdHi, Rm, Rs
9342    SMULL RdLo, RdHi, Rm, Rs
9343    UMLAL RdLo, RdHi, Rm, Rs
9344    SMLAL RdLo, RdHi, Rm, Rs.  */
9345
9346 static void
9347 do_mull (void)
9348 {
9349   inst.instruction |= inst.operands[0].reg << 12;
9350   inst.instruction |= inst.operands[1].reg << 16;
9351   inst.instruction |= inst.operands[2].reg;
9352   inst.instruction |= inst.operands[3].reg << 8;
9353
9354   /* rdhi and rdlo must be different.  */
9355   if (inst.operands[0].reg == inst.operands[1].reg)
9356     as_tsktsk (_("rdhi and rdlo must be different"));
9357
9358   /* rdhi, rdlo and rm must all be different before armv6.  */
9359   if ((inst.operands[0].reg == inst.operands[2].reg
9360       || inst.operands[1].reg == inst.operands[2].reg)
9361       && !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6))
9362     as_tsktsk (_("rdhi, rdlo and rm must all be different"));
9363 }
9364
9365 static void
9366 do_nop (void)
9367 {
9368   if (inst.operands[0].present
9369       || ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6k))
9370     {
9371       /* Architectural NOP hints are CPSR sets with no bits selected.  */
9372       inst.instruction &= 0xf0000000;
9373       inst.instruction |= 0x0320f000;
9374       if (inst.operands[0].present)
9375         inst.instruction |= inst.operands[0].imm;
9376     }
9377 }
9378
9379 /* ARM V6 Pack Halfword Bottom Top instruction (argument parse).
9380    PKHBT {<cond>} <Rd>, <Rn>, <Rm> {, LSL #<shift_imm>}
9381    Condition defaults to COND_ALWAYS.
9382    Error if Rd, Rn or Rm are R15.  */
9383
9384 static void
9385 do_pkhbt (void)
9386 {
9387   inst.instruction |= inst.operands[0].reg << 12;
9388   inst.instruction |= inst.operands[1].reg << 16;
9389   inst.instruction |= inst.operands[2].reg;
9390   if (inst.operands[3].present)
9391     encode_arm_shift (3);
9392 }
9393
9394 /* ARM V6 PKHTB (Argument Parse).  */
9395
9396 static void
9397 do_pkhtb (void)
9398 {
9399   if (!inst.operands[3].present)
9400     {
9401       /* If the shift specifier is omitted, turn the instruction
9402          into pkhbt rd, rm, rn. */
9403       inst.instruction &= 0xfff00010;
9404       inst.instruction |= inst.operands[0].reg << 12;
9405       inst.instruction |= inst.operands[1].reg;
9406       inst.instruction |= inst.operands[2].reg << 16;
9407     }
9408   else
9409     {
9410       inst.instruction |= inst.operands[0].reg << 12;
9411       inst.instruction |= inst.operands[1].reg << 16;
9412       inst.instruction |= inst.operands[2].reg;
9413       encode_arm_shift (3);
9414     }
9415 }
9416
9417 /* ARMv5TE: Preload-Cache
9418    MP Extensions: Preload for write
9419
9420     PLD(W) <addr_mode>
9421
9422   Syntactically, like LDR with B=1, W=0, L=1.  */
9423
9424 static void
9425 do_pld (void)
9426 {
9427   constraint (!inst.operands[0].isreg,
9428               _("'[' expected after PLD mnemonic"));
9429   constraint (inst.operands[0].postind,
9430               _("post-indexed expression used in preload instruction"));
9431   constraint (inst.operands[0].writeback,
9432               _("writeback used in preload instruction"));
9433   constraint (!inst.operands[0].preind,
9434               _("unindexed addressing used in preload instruction"));
9435   encode_arm_addr_mode_2 (0, /*is_t=*/FALSE);
9436 }
9437
9438 /* ARMv7: PLI <addr_mode>  */
9439 static void
9440 do_pli (void)
9441 {
9442   constraint (!inst.operands[0].isreg,
9443               _("'[' expected after PLI mnemonic"));
9444   constraint (inst.operands[0].postind,
9445               _("post-indexed expression used in preload instruction"));
9446   constraint (inst.operands[0].writeback,
9447               _("writeback used in preload instruction"));
9448   constraint (!inst.operands[0].preind,
9449               _("unindexed addressing used in preload instruction"));
9450   encode_arm_addr_mode_2 (0, /*is_t=*/FALSE);
9451   inst.instruction &= ~PRE_INDEX;
9452 }
9453
9454 static void
9455 do_push_pop (void)
9456 {
9457   constraint (inst.operands[0].writeback,
9458               _("push/pop do not support {reglist}^"));
9459   inst.operands[1] = inst.operands[0];
9460   memset (&inst.operands[0], 0, sizeof inst.operands[0]);
9461   inst.operands[0].isreg = 1;
9462   inst.operands[0].writeback = 1;
9463   inst.operands[0].reg = REG_SP;
9464   encode_ldmstm (/*from_push_pop_mnem=*/TRUE);
9465 }
9466
9467 /* ARM V6 RFE (Return from Exception) loads the PC and CPSR from the
9468    word at the specified address and the following word
9469    respectively.
9470    Unconditionally executed.
9471    Error if Rn is R15.  */
9472
9473 static void
9474 do_rfe (void)
9475 {
9476   inst.instruction |= inst.operands[0].reg << 16;
9477   if (inst.operands[0].writeback)
9478     inst.instruction |= WRITE_BACK;
9479 }
9480
9481 /* ARM V6 ssat (argument parse).  */
9482
9483 static void
9484 do_ssat (void)
9485 {
9486   inst.instruction |= inst.operands[0].reg << 12;
9487   inst.instruction |= (inst.operands[1].imm - 1) << 16;
9488   inst.instruction |= inst.operands[2].reg;
9489
9490   if (inst.operands[3].present)
9491     encode_arm_shift (3);
9492 }
9493
9494 /* ARM V6 usat (argument parse).  */
9495
9496 static void
9497 do_usat (void)
9498 {
9499   inst.instruction |= inst.operands[0].reg << 12;
9500   inst.instruction |= inst.operands[1].imm << 16;
9501   inst.instruction |= inst.operands[2].reg;
9502
9503   if (inst.operands[3].present)
9504     encode_arm_shift (3);
9505 }
9506
9507 /* ARM V6 ssat16 (argument parse).  */
9508
9509 static void
9510 do_ssat16 (void)
9511 {
9512   inst.instruction |= inst.operands[0].reg << 12;
9513   inst.instruction |= ((inst.operands[1].imm - 1) << 16);
9514   inst.instruction |= inst.operands[2].reg;
9515 }
9516
9517 static void
9518 do_usat16 (void)
9519 {
9520   inst.instruction |= inst.operands[0].reg << 12;
9521   inst.instruction |= inst.operands[1].imm << 16;
9522   inst.instruction |= inst.operands[2].reg;
9523 }
9524
9525 /* ARM V6 SETEND (argument parse).  Sets the E bit in the CPSR while
9526    preserving the other bits.
9527
9528    setend <endian_specifier>, where <endian_specifier> is either
9529    BE or LE.  */
9530
9531 static void
9532 do_setend (void)
9533 {
9534   if (warn_on_deprecated
9535       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
9536       as_tsktsk (_("setend use is deprecated for ARMv8"));
9537
9538   if (inst.operands[0].imm)
9539     inst.instruction |= 0x200;
9540 }
9541
9542 static void
9543 do_shift (void)
9544 {
9545   unsigned int Rm = (inst.operands[1].present
9546                      ? inst.operands[1].reg
9547                      : inst.operands[0].reg);
9548
9549   inst.instruction |= inst.operands[0].reg << 12;
9550   inst.instruction |= Rm;
9551   if (inst.operands[2].isreg)  /* Rd, {Rm,} Rs */
9552     {
9553       inst.instruction |= inst.operands[2].reg << 8;
9554       inst.instruction |= SHIFT_BY_REG;
9555       /* PR 12854: Error on extraneous shifts.  */
9556       constraint (inst.operands[2].shifted,
9557                   _("extraneous shift as part of operand to shift insn"));
9558     }
9559   else
9560     inst.relocs[0].type = BFD_RELOC_ARM_SHIFT_IMM;
9561 }
9562
9563 static void
9564 do_smc (void)
9565 {
9566   inst.relocs[0].type = BFD_RELOC_ARM_SMC;
9567   inst.relocs[0].pc_rel = 0;
9568 }
9569
9570 static void
9571 do_hvc (void)
9572 {
9573   inst.relocs[0].type = BFD_RELOC_ARM_HVC;
9574   inst.relocs[0].pc_rel = 0;
9575 }
9576
9577 static void
9578 do_swi (void)
9579 {
9580   inst.relocs[0].type = BFD_RELOC_ARM_SWI;
9581   inst.relocs[0].pc_rel = 0;
9582 }
9583
9584 static void
9585 do_setpan (void)
9586 {
9587   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_pan),
9588               _("selected processor does not support SETPAN instruction"));
9589
9590   inst.instruction |= ((inst.operands[0].imm & 1) << 9);
9591 }
9592
9593 static void
9594 do_t_setpan (void)
9595 {
9596   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_pan),
9597               _("selected processor does not support SETPAN instruction"));
9598
9599   inst.instruction |= (inst.operands[0].imm << 3);
9600 }
9601
9602 /* ARM V5E (El Segundo) signed-multiply-accumulate (argument parse)
9603    SMLAxy{cond} Rd,Rm,Rs,Rn
9604    SMLAWy{cond} Rd,Rm,Rs,Rn
9605    Error if any register is R15.  */
9606
9607 static void
9608 do_smla (void)
9609 {
9610   inst.instruction |= inst.operands[0].reg << 16;
9611   inst.instruction |= inst.operands[1].reg;
9612   inst.instruction |= inst.operands[2].reg << 8;
9613   inst.instruction |= inst.operands[3].reg << 12;
9614 }
9615
9616 /* ARM V5E (El Segundo) signed-multiply-accumulate-long (argument parse)
9617    SMLALxy{cond} Rdlo,Rdhi,Rm,Rs
9618    Error if any register is R15.
9619    Warning if Rdlo == Rdhi.  */
9620
9621 static void
9622 do_smlal (void)
9623 {
9624   inst.instruction |= inst.operands[0].reg << 12;
9625   inst.instruction |= inst.operands[1].reg << 16;
9626   inst.instruction |= inst.operands[2].reg;
9627   inst.instruction |= inst.operands[3].reg << 8;
9628
9629   if (inst.operands[0].reg == inst.operands[1].reg)
9630     as_tsktsk (_("rdhi and rdlo must be different"));
9631 }
9632
9633 /* ARM V5E (El Segundo) signed-multiply (argument parse)
9634    SMULxy{cond} Rd,Rm,Rs
9635    Error if any register is R15.  */
9636
9637 static void
9638 do_smul (void)
9639 {
9640   inst.instruction |= inst.operands[0].reg << 16;
9641   inst.instruction |= inst.operands[1].reg;
9642   inst.instruction |= inst.operands[2].reg << 8;
9643 }
9644
9645 /* ARM V6 srs (argument parse).  The variable fields in the encoding are
9646    the same for both ARM and Thumb-2.  */
9647
9648 static void
9649 do_srs (void)
9650 {
9651   int reg;
9652
9653   if (inst.operands[0].present)
9654     {
9655       reg = inst.operands[0].reg;
9656       constraint (reg != REG_SP, _("SRS base register must be r13"));
9657     }
9658   else
9659     reg = REG_SP;
9660
9661   inst.instruction |= reg << 16;
9662   inst.instruction |= inst.operands[1].imm;
9663   if (inst.operands[0].writeback || inst.operands[1].writeback)
9664     inst.instruction |= WRITE_BACK;
9665 }
9666
9667 /* ARM V6 strex (argument parse).  */
9668
9669 static void
9670 do_strex (void)
9671 {
9672   constraint (!inst.operands[2].isreg || !inst.operands[2].preind
9673               || inst.operands[2].postind || inst.operands[2].writeback
9674               || inst.operands[2].immisreg || inst.operands[2].shifted
9675               || inst.operands[2].negative
9676               /* See comment in do_ldrex().  */
9677               || (inst.operands[2].reg == REG_PC),
9678               BAD_ADDR_MODE);
9679
9680   constraint (inst.operands[0].reg == inst.operands[1].reg
9681               || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
9682
9683   constraint (inst.relocs[0].exp.X_op != O_constant
9684               || inst.relocs[0].exp.X_add_number != 0,
9685               _("offset must be zero in ARM encoding"));
9686
9687   inst.instruction |= inst.operands[0].reg << 12;
9688   inst.instruction |= inst.operands[1].reg;
9689   inst.instruction |= inst.operands[2].reg << 16;
9690   inst.relocs[0].type = BFD_RELOC_UNUSED;
9691 }
9692
9693 static void
9694 do_t_strexbh (void)
9695 {
9696   constraint (!inst.operands[2].isreg || !inst.operands[2].preind
9697               || inst.operands[2].postind || inst.operands[2].writeback
9698               || inst.operands[2].immisreg || inst.operands[2].shifted
9699               || inst.operands[2].negative,
9700               BAD_ADDR_MODE);
9701
9702   constraint (inst.operands[0].reg == inst.operands[1].reg
9703               || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
9704
9705   do_rm_rd_rn ();
9706 }
9707
9708 static void
9709 do_strexd (void)
9710 {
9711   constraint (inst.operands[1].reg % 2 != 0,
9712               _("even register required"));
9713   constraint (inst.operands[2].present
9714               && inst.operands[2].reg != inst.operands[1].reg + 1,
9715               _("can only store two consecutive registers"));
9716   /* If op 2 were present and equal to PC, this function wouldn't
9717      have been called in the first place.  */
9718   constraint (inst.operands[1].reg == REG_LR, _("r14 not allowed here"));
9719
9720   constraint (inst.operands[0].reg == inst.operands[1].reg
9721               || inst.operands[0].reg == inst.operands[1].reg + 1
9722               || inst.operands[0].reg == inst.operands[3].reg,
9723               BAD_OVERLAP);
9724
9725   inst.instruction |= inst.operands[0].reg << 12;
9726   inst.instruction |= inst.operands[1].reg;
9727   inst.instruction |= inst.operands[3].reg << 16;
9728 }
9729
9730 /* ARM V8 STRL.  */
9731 static void
9732 do_stlex (void)
9733 {
9734   constraint (inst.operands[0].reg == inst.operands[1].reg
9735               || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
9736
9737   do_rd_rm_rn ();
9738 }
9739
9740 static void
9741 do_t_stlex (void)
9742 {
9743   constraint (inst.operands[0].reg == inst.operands[1].reg
9744               || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
9745
9746   do_rm_rd_rn ();
9747 }
9748
9749 /* ARM V6 SXTAH extracts a 16-bit value from a register, sign
9750    extends it to 32-bits, and adds the result to a value in another
9751    register.  You can specify a rotation by 0, 8, 16, or 24 bits
9752    before extracting the 16-bit value.
9753    SXTAH{<cond>} <Rd>, <Rn>, <Rm>{, <rotation>}
9754    Condition defaults to COND_ALWAYS.
9755    Error if any register uses R15.  */
9756
9757 static void
9758 do_sxtah (void)
9759 {
9760   inst.instruction |= inst.operands[0].reg << 12;
9761   inst.instruction |= inst.operands[1].reg << 16;
9762   inst.instruction |= inst.operands[2].reg;
9763   inst.instruction |= inst.operands[3].imm << 10;
9764 }
9765
9766 /* ARM V6 SXTH.
9767
9768    SXTH {<cond>} <Rd>, <Rm>{, <rotation>}
9769    Condition defaults to COND_ALWAYS.
9770    Error if any register uses R15.  */
9771
9772 static void
9773 do_sxth (void)
9774 {
9775   inst.instruction |= inst.operands[0].reg << 12;
9776   inst.instruction |= inst.operands[1].reg;
9777   inst.instruction |= inst.operands[2].imm << 10;
9778 }
9779 \f
9780 /* VFP instructions.  In a logical order: SP variant first, monad
9781    before dyad, arithmetic then move then load/store.  */
9782
9783 static void
9784 do_vfp_sp_monadic (void)
9785 {
9786   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9787   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sm);
9788 }
9789
9790 static void
9791 do_vfp_sp_dyadic (void)
9792 {
9793   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9794   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sn);
9795   encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Sm);
9796 }
9797
9798 static void
9799 do_vfp_sp_compare_z (void)
9800 {
9801   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9802 }
9803
9804 static void
9805 do_vfp_dp_sp_cvt (void)
9806 {
9807   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9808   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sm);
9809 }
9810
9811 static void
9812 do_vfp_sp_dp_cvt (void)
9813 {
9814   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9815   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dm);
9816 }
9817
9818 static void
9819 do_vfp_reg_from_sp (void)
9820 {
9821   inst.instruction |= inst.operands[0].reg << 12;
9822   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sn);
9823 }
9824
9825 static void
9826 do_vfp_reg2_from_sp2 (void)
9827 {
9828   constraint (inst.operands[2].imm != 2,
9829               _("only two consecutive VFP SP registers allowed here"));
9830   inst.instruction |= inst.operands[0].reg << 12;
9831   inst.instruction |= inst.operands[1].reg << 16;
9832   encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Sm);
9833 }
9834
9835 static void
9836 do_vfp_sp_from_reg (void)
9837 {
9838   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sn);
9839   inst.instruction |= inst.operands[1].reg << 12;
9840 }
9841
9842 static void
9843 do_vfp_sp2_from_reg2 (void)
9844 {
9845   constraint (inst.operands[0].imm != 2,
9846               _("only two consecutive VFP SP registers allowed here"));
9847   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sm);
9848   inst.instruction |= inst.operands[1].reg << 12;
9849   inst.instruction |= inst.operands[2].reg << 16;
9850 }
9851
9852 static void
9853 do_vfp_sp_ldst (void)
9854 {
9855   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9856   encode_arm_cp_address (1, FALSE, TRUE, 0);
9857 }
9858
9859 static void
9860 do_vfp_dp_ldst (void)
9861 {
9862   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9863   encode_arm_cp_address (1, FALSE, TRUE, 0);
9864 }
9865
9866
9867 static void
9868 vfp_sp_ldstm (enum vfp_ldstm_type ldstm_type)
9869 {
9870   if (inst.operands[0].writeback)
9871     inst.instruction |= WRITE_BACK;
9872   else
9873     constraint (ldstm_type != VFP_LDSTMIA,
9874                 _("this addressing mode requires base-register writeback"));
9875   inst.instruction |= inst.operands[0].reg << 16;
9876   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sd);
9877   inst.instruction |= inst.operands[1].imm;
9878 }
9879
9880 static void
9881 vfp_dp_ldstm (enum vfp_ldstm_type ldstm_type)
9882 {
9883   int count;
9884
9885   if (inst.operands[0].writeback)
9886     inst.instruction |= WRITE_BACK;
9887   else
9888     constraint (ldstm_type != VFP_LDSTMIA && ldstm_type != VFP_LDSTMIAX,
9889                 _("this addressing mode requires base-register writeback"));
9890
9891   inst.instruction |= inst.operands[0].reg << 16;
9892   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dd);
9893
9894   count = inst.operands[1].imm << 1;
9895   if (ldstm_type == VFP_LDSTMIAX || ldstm_type == VFP_LDSTMDBX)
9896     count += 1;
9897
9898   inst.instruction |= count;
9899 }
9900
9901 static void
9902 do_vfp_sp_ldstmia (void)
9903 {
9904   vfp_sp_ldstm (VFP_LDSTMIA);
9905 }
9906
9907 static void
9908 do_vfp_sp_ldstmdb (void)
9909 {
9910   vfp_sp_ldstm (VFP_LDSTMDB);
9911 }
9912
9913 static void
9914 do_vfp_dp_ldstmia (void)
9915 {
9916   vfp_dp_ldstm (VFP_LDSTMIA);
9917 }
9918
9919 static void
9920 do_vfp_dp_ldstmdb (void)
9921 {
9922   vfp_dp_ldstm (VFP_LDSTMDB);
9923 }
9924
9925 static void
9926 do_vfp_xp_ldstmia (void)
9927 {
9928   vfp_dp_ldstm (VFP_LDSTMIAX);
9929 }
9930
9931 static void
9932 do_vfp_xp_ldstmdb (void)
9933 {
9934   vfp_dp_ldstm (VFP_LDSTMDBX);
9935 }
9936
9937 static void
9938 do_vfp_dp_rd_rm (void)
9939 {
9940   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9941   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dm);
9942 }
9943
9944 static void
9945 do_vfp_dp_rn_rd (void)
9946 {
9947   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dn);
9948   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dd);
9949 }
9950
9951 static void
9952 do_vfp_dp_rd_rn (void)
9953 {
9954   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9955   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dn);
9956 }
9957
9958 static void
9959 do_vfp_dp_rd_rn_rm (void)
9960 {
9961   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9962   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dn);
9963   encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Dm);
9964 }
9965
9966 static void
9967 do_vfp_dp_rd (void)
9968 {
9969   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9970 }
9971
9972 static void
9973 do_vfp_dp_rm_rd_rn (void)
9974 {
9975   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dm);
9976   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dd);
9977   encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Dn);
9978 }
9979
9980 /* VFPv3 instructions.  */
9981 static void
9982 do_vfp_sp_const (void)
9983 {
9984   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9985   inst.instruction |= (inst.operands[1].imm & 0xf0) << 12;
9986   inst.instruction |= (inst.operands[1].imm & 0x0f);
9987 }
9988
9989 static void
9990 do_vfp_dp_const (void)
9991 {
9992   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9993   inst.instruction |= (inst.operands[1].imm & 0xf0) << 12;
9994   inst.instruction |= (inst.operands[1].imm & 0x0f);
9995 }
9996
9997 static void
9998 vfp_conv (int srcsize)
9999 {
10000   int immbits = srcsize - inst.operands[1].imm;
10001
10002   if (srcsize == 16 && !(immbits >= 0 && immbits <= srcsize))
10003     {
10004       /* If srcsize is 16, inst.operands[1].imm must be in the range 0-16.
10005          i.e. immbits must be in range 0 - 16.  */
10006       inst.error = _("immediate value out of range, expected range [0, 16]");
10007       return;
10008     }
10009   else if (srcsize == 32 && !(immbits >= 0 && immbits < srcsize))
10010     {
10011       /* If srcsize is 32, inst.operands[1].imm must be in the range 1-32.
10012          i.e. immbits must be in range 0 - 31.  */
10013       inst.error = _("immediate value out of range, expected range [1, 32]");
10014       return;
10015     }
10016
10017   inst.instruction |= (immbits & 1) << 5;
10018   inst.instruction |= (immbits >> 1);
10019 }
10020
10021 static void
10022 do_vfp_sp_conv_16 (void)
10023 {
10024   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
10025   vfp_conv (16);
10026 }
10027
10028 static void
10029 do_vfp_dp_conv_16 (void)
10030 {
10031   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
10032   vfp_conv (16);
10033 }
10034
10035 static void
10036 do_vfp_sp_conv_32 (void)
10037 {
10038   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
10039   vfp_conv (32);
10040 }
10041
10042 static void
10043 do_vfp_dp_conv_32 (void)
10044 {
10045   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
10046   vfp_conv (32);
10047 }
10048 \f
10049 /* FPA instructions.  Also in a logical order.  */
10050
10051 static void
10052 do_fpa_cmp (void)
10053 {
10054   inst.instruction |= inst.operands[0].reg << 16;
10055   inst.instruction |= inst.operands[1].reg;
10056 }
10057
10058 static void
10059 do_fpa_ldmstm (void)
10060 {
10061   inst.instruction |= inst.operands[0].reg << 12;
10062   switch (inst.operands[1].imm)
10063     {
10064     case 1: inst.instruction |= CP_T_X;          break;
10065     case 2: inst.instruction |= CP_T_Y;          break;
10066     case 3: inst.instruction |= CP_T_Y | CP_T_X; break;
10067     case 4:                                      break;
10068     default: abort ();
10069     }
10070
10071   if (inst.instruction & (PRE_INDEX | INDEX_UP))
10072     {
10073       /* The instruction specified "ea" or "fd", so we can only accept
10074          [Rn]{!}.  The instruction does not really support stacking or
10075          unstacking, so we have to emulate these by setting appropriate
10076          bits and offsets.  */
10077       constraint (inst.relocs[0].exp.X_op != O_constant
10078                   || inst.relocs[0].exp.X_add_number != 0,
10079                   _("this instruction does not support indexing"));
10080
10081       if ((inst.instruction & PRE_INDEX) || inst.operands[2].writeback)
10082         inst.relocs[0].exp.X_add_number = 12 * inst.operands[1].imm;
10083
10084       if (!(inst.instruction & INDEX_UP))
10085         inst.relocs[0].exp.X_add_number = -inst.relocs[0].exp.X_add_number;
10086
10087       if (!(inst.instruction & PRE_INDEX) && inst.operands[2].writeback)
10088         {
10089           inst.operands[2].preind = 0;
10090           inst.operands[2].postind = 1;
10091         }
10092     }
10093
10094   encode_arm_cp_address (2, TRUE, TRUE, 0);
10095 }
10096 \f
10097 /* iWMMXt instructions: strictly in alphabetical order.  */
10098
10099 static void
10100 do_iwmmxt_tandorc (void)
10101 {
10102   constraint (inst.operands[0].reg != REG_PC, _("only r15 allowed here"));
10103 }
10104
10105 static void
10106 do_iwmmxt_textrc (void)
10107 {
10108   inst.instruction |= inst.operands[0].reg << 12;
10109   inst.instruction |= inst.operands[1].imm;
10110 }
10111
10112 static void
10113 do_iwmmxt_textrm (void)
10114 {
10115   inst.instruction |= inst.operands[0].reg << 12;
10116   inst.instruction |= inst.operands[1].reg << 16;
10117   inst.instruction |= inst.operands[2].imm;
10118 }
10119
10120 static void
10121 do_iwmmxt_tinsr (void)
10122 {
10123   inst.instruction |= inst.operands[0].reg << 16;
10124   inst.instruction |= inst.operands[1].reg << 12;
10125   inst.instruction |= inst.operands[2].imm;
10126 }
10127
10128 static void
10129 do_iwmmxt_tmia (void)
10130 {
10131   inst.instruction |= inst.operands[0].reg << 5;
10132   inst.instruction |= inst.operands[1].reg;
10133   inst.instruction |= inst.operands[2].reg << 12;
10134 }
10135
10136 static void
10137 do_iwmmxt_waligni (void)
10138 {
10139   inst.instruction |= inst.operands[0].reg << 12;
10140   inst.instruction |= inst.operands[1].reg << 16;
10141   inst.instruction |= inst.operands[2].reg;
10142   inst.instruction |= inst.operands[3].imm << 20;
10143 }
10144
10145 static void
10146 do_iwmmxt_wmerge (void)
10147 {
10148   inst.instruction |= inst.operands[0].reg << 12;
10149   inst.instruction |= inst.operands[1].reg << 16;
10150   inst.instruction |= inst.operands[2].reg;
10151   inst.instruction |= inst.operands[3].imm << 21;
10152 }
10153
10154 static void
10155 do_iwmmxt_wmov (void)
10156 {
10157   /* WMOV rD, rN is an alias for WOR rD, rN, rN.  */
10158   inst.instruction |= inst.operands[0].reg << 12;
10159   inst.instruction |= inst.operands[1].reg << 16;
10160   inst.instruction |= inst.operands[1].reg;
10161 }
10162
10163 static void
10164 do_iwmmxt_wldstbh (void)
10165 {
10166   int reloc;
10167   inst.instruction |= inst.operands[0].reg << 12;
10168   if (thumb_mode)
10169     reloc = BFD_RELOC_ARM_T32_CP_OFF_IMM_S2;
10170   else
10171     reloc = BFD_RELOC_ARM_CP_OFF_IMM_S2;
10172   encode_arm_cp_address (1, TRUE, FALSE, reloc);
10173 }
10174
10175 static void
10176 do_iwmmxt_wldstw (void)
10177 {
10178   /* RIWR_RIWC clears .isreg for a control register.  */
10179   if (!inst.operands[0].isreg)
10180     {
10181       constraint (inst.cond != COND_ALWAYS, BAD_COND);
10182       inst.instruction |= 0xf0000000;
10183     }
10184
10185   inst.instruction |= inst.operands[0].reg << 12;
10186   encode_arm_cp_address (1, TRUE, TRUE, 0);
10187 }
10188
10189 static void
10190 do_iwmmxt_wldstd (void)
10191 {
10192   inst.instruction |= inst.operands[0].reg << 12;
10193   if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt2)
10194       && inst.operands[1].immisreg)
10195     {
10196       inst.instruction &= ~0x1a000ff;
10197       inst.instruction |= (0xfU << 28);
10198       if (inst.operands[1].preind)
10199         inst.instruction |= PRE_INDEX;
10200       if (!inst.operands[1].negative)
10201         inst.instruction |= INDEX_UP;
10202       if (inst.operands[1].writeback)
10203         inst.instruction |= WRITE_BACK;
10204       inst.instruction |= inst.operands[1].reg << 16;
10205       inst.instruction |= inst.relocs[0].exp.X_add_number << 4;
10206       inst.instruction |= inst.operands[1].imm;
10207     }
10208   else
10209     encode_arm_cp_address (1, TRUE, FALSE, 0);
10210 }
10211
10212 static void
10213 do_iwmmxt_wshufh (void)
10214 {
10215   inst.instruction |= inst.operands[0].reg << 12;
10216   inst.instruction |= inst.operands[1].reg << 16;
10217   inst.instruction |= ((inst.operands[2].imm & 0xf0) << 16);
10218   inst.instruction |= (inst.operands[2].imm & 0x0f);
10219 }
10220
10221 static void
10222 do_iwmmxt_wzero (void)
10223 {
10224   /* WZERO reg is an alias for WANDN reg, reg, reg.  */
10225   inst.instruction |= inst.operands[0].reg;
10226   inst.instruction |= inst.operands[0].reg << 12;
10227   inst.instruction |= inst.operands[0].reg << 16;
10228 }
10229
10230 static void
10231 do_iwmmxt_wrwrwr_or_imm5 (void)
10232 {
10233   if (inst.operands[2].isreg)
10234     do_rd_rn_rm ();
10235   else {
10236     constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt2),
10237                 _("immediate operand requires iWMMXt2"));
10238     do_rd_rn ();
10239     if (inst.operands[2].imm == 0)
10240       {
10241         switch ((inst.instruction >> 20) & 0xf)
10242           {
10243           case 4:
10244           case 5:
10245           case 6:
10246           case 7:
10247             /* w...h wrd, wrn, #0 -> wrorh wrd, wrn, #16.  */
10248             inst.operands[2].imm = 16;
10249             inst.instruction = (inst.instruction & 0xff0fffff) | (0x7 << 20);
10250             break;
10251           case 8:
10252           case 9:
10253           case 10:
10254           case 11:
10255             /* w...w wrd, wrn, #0 -> wrorw wrd, wrn, #32.  */
10256             inst.operands[2].imm = 32;
10257             inst.instruction = (inst.instruction & 0xff0fffff) | (0xb << 20);
10258             break;
10259           case 12:
10260           case 13:
10261           case 14:
10262           case 15:
10263             {
10264               /* w...d wrd, wrn, #0 -> wor wrd, wrn, wrn.  */
10265               unsigned long wrn;
10266               wrn = (inst.instruction >> 16) & 0xf;
10267               inst.instruction &= 0xff0fff0f;
10268               inst.instruction |= wrn;
10269               /* Bail out here; the instruction is now assembled.  */
10270               return;
10271             }
10272           }
10273       }
10274     /* Map 32 -> 0, etc.  */
10275     inst.operands[2].imm &= 0x1f;
10276     inst.instruction |= (0xfU << 28) | ((inst.operands[2].imm & 0x10) << 4) | (inst.operands[2].imm & 0xf);
10277   }
10278 }
10279 \f
10280 /* Cirrus Maverick instructions.  Simple 2-, 3-, and 4-register
10281    operations first, then control, shift, and load/store.  */
10282
10283 /* Insns like "foo X,Y,Z".  */
10284
10285 static void
10286 do_mav_triple (void)
10287 {
10288   inst.instruction |= inst.operands[0].reg << 16;
10289   inst.instruction |= inst.operands[1].reg;
10290   inst.instruction |= inst.operands[2].reg << 12;
10291 }
10292
10293 /* Insns like "foo W,X,Y,Z".
10294     where W=MVAX[0:3] and X,Y,Z=MVFX[0:15].  */
10295
10296 static void
10297 do_mav_quad (void)
10298 {
10299   inst.instruction |= inst.operands[0].reg << 5;
10300   inst.instruction |= inst.operands[1].reg << 12;
10301   inst.instruction |= inst.operands[2].reg << 16;
10302   inst.instruction |= inst.operands[3].reg;
10303 }
10304
10305 /* cfmvsc32<cond> DSPSC,MVDX[15:0].  */
10306 static void
10307 do_mav_dspsc (void)
10308 {
10309   inst.instruction |= inst.operands[1].reg << 12;
10310 }
10311
10312 /* Maverick shift immediate instructions.
10313    cfsh32<cond> MVFX[15:0],MVFX[15:0],Shift[6:0].
10314    cfsh64<cond> MVDX[15:0],MVDX[15:0],Shift[6:0].  */
10315
10316 static void
10317 do_mav_shift (void)
10318 {
10319   int imm = inst.operands[2].imm;
10320
10321   inst.instruction |= inst.operands[0].reg << 12;
10322   inst.instruction |= inst.operands[1].reg << 16;
10323
10324   /* Bits 0-3 of the insn should have bits 0-3 of the immediate.
10325      Bits 5-7 of the insn should have bits 4-6 of the immediate.
10326      Bit 4 should be 0.  */
10327   imm = (imm & 0xf) | ((imm & 0x70) << 1);
10328
10329   inst.instruction |= imm;
10330 }
10331 \f
10332 /* XScale instructions.  Also sorted arithmetic before move.  */
10333
10334 /* Xscale multiply-accumulate (argument parse)
10335      MIAcc   acc0,Rm,Rs
10336      MIAPHcc acc0,Rm,Rs
10337      MIAxycc acc0,Rm,Rs.  */
10338
10339 static void
10340 do_xsc_mia (void)
10341 {
10342   inst.instruction |= inst.operands[1].reg;
10343   inst.instruction |= inst.operands[2].reg << 12;
10344 }
10345
10346 /* Xscale move-accumulator-register (argument parse)
10347
10348      MARcc   acc0,RdLo,RdHi.  */
10349
10350 static void
10351 do_xsc_mar (void)
10352 {
10353   inst.instruction |= inst.operands[1].reg << 12;
10354   inst.instruction |= inst.operands[2].reg << 16;
10355 }
10356
10357 /* Xscale move-register-accumulator (argument parse)
10358
10359      MRAcc   RdLo,RdHi,acc0.  */
10360
10361 static void
10362 do_xsc_mra (void)
10363 {
10364   constraint (inst.operands[0].reg == inst.operands[1].reg, BAD_OVERLAP);
10365   inst.instruction |= inst.operands[0].reg << 12;
10366   inst.instruction |= inst.operands[1].reg << 16;
10367 }
10368 \f
10369 /* Encoding functions relevant only to Thumb.  */
10370
10371 /* inst.operands[i] is a shifted-register operand; encode
10372    it into inst.instruction in the format used by Thumb32.  */
10373
10374 static void
10375 encode_thumb32_shifted_operand (int i)
10376 {
10377   unsigned int value = inst.relocs[0].exp.X_add_number;
10378   unsigned int shift = inst.operands[i].shift_kind;
10379
10380   constraint (inst.operands[i].immisreg,
10381               _("shift by register not allowed in thumb mode"));
10382   inst.instruction |= inst.operands[i].reg;
10383   if (shift == SHIFT_RRX)
10384     inst.instruction |= SHIFT_ROR << 4;
10385   else
10386     {
10387       constraint (inst.relocs[0].exp.X_op != O_constant,
10388                   _("expression too complex"));
10389
10390       constraint (value > 32
10391                   || (value == 32 && (shift == SHIFT_LSL
10392                                       || shift == SHIFT_ROR)),
10393                   _("shift expression is too large"));
10394
10395       if (value == 0)
10396         shift = SHIFT_LSL;
10397       else if (value == 32)
10398         value = 0;
10399
10400       inst.instruction |= shift << 4;
10401       inst.instruction |= (value & 0x1c) << 10;
10402       inst.instruction |= (value & 0x03) << 6;
10403     }
10404 }
10405
10406
10407 /* inst.operands[i] was set up by parse_address.  Encode it into a
10408    Thumb32 format load or store instruction.  Reject forms that cannot
10409    be used with such instructions.  If is_t is true, reject forms that
10410    cannot be used with a T instruction; if is_d is true, reject forms
10411    that cannot be used with a D instruction.  If it is a store insn,
10412    reject PC in Rn.  */
10413
10414 static void
10415 encode_thumb32_addr_mode (int i, bfd_boolean is_t, bfd_boolean is_d)
10416 {
10417   const bfd_boolean is_pc = (inst.operands[i].reg == REG_PC);
10418
10419   constraint (!inst.operands[i].isreg,
10420               _("Instruction does not support =N addresses"));
10421
10422   inst.instruction |= inst.operands[i].reg << 16;
10423   if (inst.operands[i].immisreg)
10424     {
10425       constraint (is_pc, BAD_PC_ADDRESSING);
10426       constraint (is_t || is_d, _("cannot use register index with this instruction"));
10427       constraint (inst.operands[i].negative,
10428                   _("Thumb does not support negative register indexing"));
10429       constraint (inst.operands[i].postind,
10430                   _("Thumb does not support register post-indexing"));
10431       constraint (inst.operands[i].writeback,
10432                   _("Thumb does not support register indexing with writeback"));
10433       constraint (inst.operands[i].shifted && inst.operands[i].shift_kind != SHIFT_LSL,
10434                   _("Thumb supports only LSL in shifted register indexing"));
10435
10436       inst.instruction |= inst.operands[i].imm;
10437       if (inst.operands[i].shifted)
10438         {
10439           constraint (inst.relocs[0].exp.X_op != O_constant,
10440                       _("expression too complex"));
10441           constraint (inst.relocs[0].exp.X_add_number < 0
10442                       || inst.relocs[0].exp.X_add_number > 3,
10443                       _("shift out of range"));
10444           inst.instruction |= inst.relocs[0].exp.X_add_number << 4;
10445         }
10446       inst.relocs[0].type = BFD_RELOC_UNUSED;
10447     }
10448   else if (inst.operands[i].preind)
10449     {
10450       constraint (is_pc && inst.operands[i].writeback, BAD_PC_WRITEBACK);
10451       constraint (is_t && inst.operands[i].writeback,
10452                   _("cannot use writeback with this instruction"));
10453       constraint (is_pc && ((inst.instruction & THUMB2_LOAD_BIT) == 0),
10454                   BAD_PC_ADDRESSING);
10455
10456       if (is_d)
10457         {
10458           inst.instruction |= 0x01000000;
10459           if (inst.operands[i].writeback)
10460             inst.instruction |= 0x00200000;
10461         }
10462       else
10463         {
10464           inst.instruction |= 0x00000c00;
10465           if (inst.operands[i].writeback)
10466             inst.instruction |= 0x00000100;
10467         }
10468       inst.relocs[0].type = BFD_RELOC_ARM_T32_OFFSET_IMM;
10469     }
10470   else if (inst.operands[i].postind)
10471     {
10472       gas_assert (inst.operands[i].writeback);
10473       constraint (is_pc, _("cannot use post-indexing with PC-relative addressing"));
10474       constraint (is_t, _("cannot use post-indexing with this instruction"));
10475
10476       if (is_d)
10477         inst.instruction |= 0x00200000;
10478       else
10479         inst.instruction |= 0x00000900;
10480       inst.relocs[0].type = BFD_RELOC_ARM_T32_OFFSET_IMM;
10481     }
10482   else /* unindexed - only for coprocessor */
10483     inst.error = _("instruction does not accept unindexed addressing");
10484 }
10485
10486 /* Table of Thumb instructions which exist in both 16- and 32-bit
10487    encodings (the latter only in post-V6T2 cores).  The index is the
10488    value used in the insns table below.  When there is more than one
10489    possible 16-bit encoding for the instruction, this table always
10490    holds variant (1).
10491    Also contains several pseudo-instructions used during relaxation.  */
10492 #define T16_32_TAB                              \
10493   X(_adc,   4140, eb400000),                    \
10494   X(_adcs,  4140, eb500000),                    \
10495   X(_add,   1c00, eb000000),                    \
10496   X(_adds,  1c00, eb100000),                    \
10497   X(_addi,  0000, f1000000),                    \
10498   X(_addis, 0000, f1100000),                    \
10499   X(_add_pc,000f, f20f0000),                    \
10500   X(_add_sp,000d, f10d0000),                    \
10501   X(_adr,   000f, f20f0000),                    \
10502   X(_and,   4000, ea000000),                    \
10503   X(_ands,  4000, ea100000),                    \
10504   X(_asr,   1000, fa40f000),                    \
10505   X(_asrs,  1000, fa50f000),                    \
10506   X(_b,     e000, f000b000),                    \
10507   X(_bcond, d000, f0008000),                    \
10508   X(_bf,    0000, f040e001),                    \
10509   X(_bfx,   0000, f060e001),                    \
10510   X(_bflx,  0000, f070e001),                    \
10511   X(_bic,   4380, ea200000),                    \
10512   X(_bics,  4380, ea300000),                    \
10513   X(_cmn,   42c0, eb100f00),                    \
10514   X(_cmp,   2800, ebb00f00),                    \
10515   X(_cpsie, b660, f3af8400),                    \
10516   X(_cpsid, b670, f3af8600),                    \
10517   X(_cpy,   4600, ea4f0000),                    \
10518   X(_dec_sp,80dd, f1ad0d00),                    \
10519   X(_eor,   4040, ea800000),                    \
10520   X(_eors,  4040, ea900000),                    \
10521   X(_inc_sp,00dd, f10d0d00),                    \
10522   X(_ldmia, c800, e8900000),                    \
10523   X(_ldr,   6800, f8500000),                    \
10524   X(_ldrb,  7800, f8100000),                    \
10525   X(_ldrh,  8800, f8300000),                    \
10526   X(_ldrsb, 5600, f9100000),                    \
10527   X(_ldrsh, 5e00, f9300000),                    \
10528   X(_ldr_pc,4800, f85f0000),                    \
10529   X(_ldr_pc2,4800, f85f0000),                   \
10530   X(_ldr_sp,9800, f85d0000),                    \
10531   X(_lsl,   0000, fa00f000),                    \
10532   X(_lsls,  0000, fa10f000),                    \
10533   X(_lsr,   0800, fa20f000),                    \
10534   X(_lsrs,  0800, fa30f000),                    \
10535   X(_mov,   2000, ea4f0000),                    \
10536   X(_movs,  2000, ea5f0000),                    \
10537   X(_mul,   4340, fb00f000),                     \
10538   X(_muls,  4340, ffffffff), /* no 32b muls */  \
10539   X(_mvn,   43c0, ea6f0000),                    \
10540   X(_mvns,  43c0, ea7f0000),                    \
10541   X(_neg,   4240, f1c00000), /* rsb #0 */       \
10542   X(_negs,  4240, f1d00000), /* rsbs #0 */      \
10543   X(_orr,   4300, ea400000),                    \
10544   X(_orrs,  4300, ea500000),                    \
10545   X(_pop,   bc00, e8bd0000), /* ldmia sp!,... */        \
10546   X(_push,  b400, e92d0000), /* stmdb sp!,... */        \
10547   X(_rev,   ba00, fa90f080),                    \
10548   X(_rev16, ba40, fa90f090),                    \
10549   X(_revsh, bac0, fa90f0b0),                    \
10550   X(_ror,   41c0, fa60f000),                    \
10551   X(_rors,  41c0, fa70f000),                    \
10552   X(_sbc,   4180, eb600000),                    \
10553   X(_sbcs,  4180, eb700000),                    \
10554   X(_stmia, c000, e8800000),                    \
10555   X(_str,   6000, f8400000),                    \
10556   X(_strb,  7000, f8000000),                    \
10557   X(_strh,  8000, f8200000),                    \
10558   X(_str_sp,9000, f84d0000),                    \
10559   X(_sub,   1e00, eba00000),                    \
10560   X(_subs,  1e00, ebb00000),                    \
10561   X(_subi,  8000, f1a00000),                    \
10562   X(_subis, 8000, f1b00000),                    \
10563   X(_sxtb,  b240, fa4ff080),                    \
10564   X(_sxth,  b200, fa0ff080),                    \
10565   X(_tst,   4200, ea100f00),                    \
10566   X(_uxtb,  b2c0, fa5ff080),                    \
10567   X(_uxth,  b280, fa1ff080),                    \
10568   X(_nop,   bf00, f3af8000),                    \
10569   X(_yield, bf10, f3af8001),                    \
10570   X(_wfe,   bf20, f3af8002),                    \
10571   X(_wfi,   bf30, f3af8003),                    \
10572   X(_sev,   bf40, f3af8004),                    \
10573   X(_sevl,  bf50, f3af8005),                    \
10574   X(_udf,   de00, f7f0a000)
10575
10576 /* To catch errors in encoding functions, the codes are all offset by
10577    0xF800, putting them in one of the 32-bit prefix ranges, ergo undefined
10578    as 16-bit instructions.  */
10579 #define X(a,b,c) T_MNEM##a
10580 enum t16_32_codes { T16_32_OFFSET = 0xF7FF, T16_32_TAB };
10581 #undef X
10582
10583 #define X(a,b,c) 0x##b
10584 static const unsigned short thumb_op16[] = { T16_32_TAB };
10585 #define THUMB_OP16(n) (thumb_op16[(n) - (T16_32_OFFSET + 1)])
10586 #undef X
10587
10588 #define X(a,b,c) 0x##c
10589 static const unsigned int thumb_op32[] = { T16_32_TAB };
10590 #define THUMB_OP32(n)        (thumb_op32[(n) - (T16_32_OFFSET + 1)])
10591 #define THUMB_SETS_FLAGS(n)  (THUMB_OP32 (n) & 0x00100000)
10592 #undef X
10593 #undef T16_32_TAB
10594
10595 /* Thumb instruction encoders, in alphabetical order.  */
10596
10597 /* ADDW or SUBW.  */
10598
10599 static void
10600 do_t_add_sub_w (void)
10601 {
10602   int Rd, Rn;
10603
10604   Rd = inst.operands[0].reg;
10605   Rn = inst.operands[1].reg;
10606
10607   /* If Rn is REG_PC, this is ADR; if Rn is REG_SP, then this
10608      is the SP-{plus,minus}-immediate form of the instruction.  */
10609   if (Rn == REG_SP)
10610     constraint (Rd == REG_PC, BAD_PC);
10611   else
10612     reject_bad_reg (Rd);
10613
10614   inst.instruction |= (Rn << 16) | (Rd << 8);
10615   inst.relocs[0].type = BFD_RELOC_ARM_T32_IMM12;
10616 }
10617
10618 /* Parse an add or subtract instruction.  We get here with inst.instruction
10619    equaling any of THUMB_OPCODE_add, adds, sub, or subs.  */
10620
10621 static void
10622 do_t_add_sub (void)
10623 {
10624   int Rd, Rs, Rn;
10625
10626   Rd = inst.operands[0].reg;
10627   Rs = (inst.operands[1].present
10628         ? inst.operands[1].reg    /* Rd, Rs, foo */
10629         : inst.operands[0].reg);  /* Rd, foo -> Rd, Rd, foo */
10630
10631   if (Rd == REG_PC)
10632     set_it_insn_type_last ();
10633
10634   if (unified_syntax)
10635     {
10636       bfd_boolean flags;
10637       bfd_boolean narrow;
10638       int opcode;
10639
10640       flags = (inst.instruction == T_MNEM_adds
10641                || inst.instruction == T_MNEM_subs);
10642       if (flags)
10643         narrow = !in_it_block ();
10644       else
10645         narrow = in_it_block ();
10646       if (!inst.operands[2].isreg)
10647         {
10648           int add;
10649
10650           if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
10651             constraint (Rd == REG_SP && Rs != REG_SP, BAD_SP);
10652
10653           add = (inst.instruction == T_MNEM_add
10654                  || inst.instruction == T_MNEM_adds);
10655           opcode = 0;
10656           if (inst.size_req != 4)
10657             {
10658               /* Attempt to use a narrow opcode, with relaxation if
10659                  appropriate.  */
10660               if (Rd == REG_SP && Rs == REG_SP && !flags)
10661                 opcode = add ? T_MNEM_inc_sp : T_MNEM_dec_sp;
10662               else if (Rd <= 7 && Rs == REG_SP && add && !flags)
10663                 opcode = T_MNEM_add_sp;
10664               else if (Rd <= 7 && Rs == REG_PC && add && !flags)
10665                 opcode = T_MNEM_add_pc;
10666               else if (Rd <= 7 && Rs <= 7 && narrow)
10667                 {
10668                   if (flags)
10669                     opcode = add ? T_MNEM_addis : T_MNEM_subis;
10670                   else
10671                     opcode = add ? T_MNEM_addi : T_MNEM_subi;
10672                 }
10673               if (opcode)
10674                 {
10675                   inst.instruction = THUMB_OP16(opcode);
10676                   inst.instruction |= (Rd << 4) | Rs;
10677                   if (inst.relocs[0].type < BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC
10678                       || (inst.relocs[0].type
10679                           > BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC))
10680                   {
10681                     if (inst.size_req == 2)
10682                       inst.relocs[0].type = BFD_RELOC_ARM_THUMB_ADD;
10683                     else
10684                       inst.relax = opcode;
10685                   }
10686                 }
10687               else
10688                 constraint (inst.size_req == 2, BAD_HIREG);
10689             }
10690           if (inst.size_req == 4
10691               || (inst.size_req != 2 && !opcode))
10692             {
10693               constraint ((inst.relocs[0].type
10694                            >= BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC)
10695                           && (inst.relocs[0].type
10696                               <= BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC) ,
10697                           THUMB1_RELOC_ONLY);
10698               if (Rd == REG_PC)
10699                 {
10700                   constraint (add, BAD_PC);
10701                   constraint (Rs != REG_LR || inst.instruction != T_MNEM_subs,
10702                              _("only SUBS PC, LR, #const allowed"));
10703                   constraint (inst.relocs[0].exp.X_op != O_constant,
10704                               _("expression too complex"));
10705                   constraint (inst.relocs[0].exp.X_add_number < 0
10706                               || inst.relocs[0].exp.X_add_number > 0xff,
10707                              _("immediate value out of range"));
10708                   inst.instruction = T2_SUBS_PC_LR
10709                                      | inst.relocs[0].exp.X_add_number;
10710                   inst.relocs[0].type = BFD_RELOC_UNUSED;
10711                   return;
10712                 }
10713               else if (Rs == REG_PC)
10714                 {
10715                   /* Always use addw/subw.  */
10716                   inst.instruction = add ? 0xf20f0000 : 0xf2af0000;
10717                   inst.relocs[0].type = BFD_RELOC_ARM_T32_IMM12;
10718                 }
10719               else
10720                 {
10721                   inst.instruction = THUMB_OP32 (inst.instruction);
10722                   inst.instruction = (inst.instruction & 0xe1ffffff)
10723                                      | 0x10000000;
10724                   if (flags)
10725                     inst.relocs[0].type = BFD_RELOC_ARM_T32_IMMEDIATE;
10726                   else
10727                     inst.relocs[0].type = BFD_RELOC_ARM_T32_ADD_IMM;
10728                 }
10729               inst.instruction |= Rd << 8;
10730               inst.instruction |= Rs << 16;
10731             }
10732         }
10733       else
10734         {
10735           unsigned int value = inst.relocs[0].exp.X_add_number;
10736           unsigned int shift = inst.operands[2].shift_kind;
10737
10738           Rn = inst.operands[2].reg;
10739           /* See if we can do this with a 16-bit instruction.  */
10740           if (!inst.operands[2].shifted && inst.size_req != 4)
10741             {
10742               if (Rd > 7 || Rs > 7 || Rn > 7)
10743                 narrow = FALSE;
10744
10745               if (narrow)
10746                 {
10747                   inst.instruction = ((inst.instruction == T_MNEM_adds
10748                                        || inst.instruction == T_MNEM_add)
10749                                       ? T_OPCODE_ADD_R3
10750                                       : T_OPCODE_SUB_R3);
10751                   inst.instruction |= Rd | (Rs << 3) | (Rn << 6);
10752                   return;
10753                 }
10754
10755               if (inst.instruction == T_MNEM_add && (Rd == Rs || Rd == Rn))
10756                 {
10757                   /* Thumb-1 cores (except v6-M) require at least one high
10758                      register in a narrow non flag setting add.  */
10759                   if (Rd > 7 || Rn > 7
10760                       || ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6t2)
10761                       || ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_msr))
10762                     {
10763                       if (Rd == Rn)
10764                         {
10765                           Rn = Rs;
10766                           Rs = Rd;
10767                         }
10768                       inst.instruction = T_OPCODE_ADD_HI;
10769                       inst.instruction |= (Rd & 8) << 4;
10770                       inst.instruction |= (Rd & 7);
10771                       inst.instruction |= Rn << 3;
10772                       return;
10773                     }
10774                 }
10775             }
10776
10777           constraint (Rd == REG_PC, BAD_PC);
10778           if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
10779             constraint (Rd == REG_SP && Rs != REG_SP, BAD_SP);
10780           constraint (Rs == REG_PC, BAD_PC);
10781           reject_bad_reg (Rn);
10782
10783           /* If we get here, it can't be done in 16 bits.  */
10784           constraint (inst.operands[2].shifted && inst.operands[2].immisreg,
10785                       _("shift must be constant"));
10786           inst.instruction = THUMB_OP32 (inst.instruction);
10787           inst.instruction |= Rd << 8;
10788           inst.instruction |= Rs << 16;
10789           constraint (Rd == REG_SP && Rs == REG_SP && value > 3,
10790                       _("shift value over 3 not allowed in thumb mode"));
10791           constraint (Rd == REG_SP && Rs == REG_SP && shift != SHIFT_LSL,
10792                       _("only LSL shift allowed in thumb mode"));
10793           encode_thumb32_shifted_operand (2);
10794         }
10795     }
10796   else
10797     {
10798       constraint (inst.instruction == T_MNEM_adds
10799                   || inst.instruction == T_MNEM_subs,
10800                   BAD_THUMB32);
10801
10802       if (!inst.operands[2].isreg) /* Rd, Rs, #imm */
10803         {
10804           constraint ((Rd > 7 && (Rd != REG_SP || Rs != REG_SP))
10805                       || (Rs > 7 && Rs != REG_SP && Rs != REG_PC),
10806                       BAD_HIREG);
10807
10808           inst.instruction = (inst.instruction == T_MNEM_add
10809                               ? 0x0000 : 0x8000);
10810           inst.instruction |= (Rd << 4) | Rs;
10811           inst.relocs[0].type = BFD_RELOC_ARM_THUMB_ADD;
10812           return;
10813         }
10814
10815       Rn = inst.operands[2].reg;
10816       constraint (inst.operands[2].shifted, _("unshifted register required"));
10817
10818       /* We now have Rd, Rs, and Rn set to registers.  */
10819       if (Rd > 7 || Rs > 7 || Rn > 7)
10820         {
10821           /* Can't do this for SUB.      */
10822           constraint (inst.instruction == T_MNEM_sub, BAD_HIREG);
10823           inst.instruction = T_OPCODE_ADD_HI;
10824           inst.instruction |= (Rd & 8) << 4;
10825           inst.instruction |= (Rd & 7);
10826           if (Rs == Rd)
10827             inst.instruction |= Rn << 3;
10828           else if (Rn == Rd)
10829             inst.instruction |= Rs << 3;
10830           else
10831             constraint (1, _("dest must overlap one source register"));
10832         }
10833       else
10834         {
10835           inst.instruction = (inst.instruction == T_MNEM_add
10836                               ? T_OPCODE_ADD_R3 : T_OPCODE_SUB_R3);
10837           inst.instruction |= Rd | (Rs << 3) | (Rn << 6);
10838         }
10839     }
10840 }
10841
10842 static void
10843 do_t_adr (void)
10844 {
10845   unsigned Rd;
10846
10847   Rd = inst.operands[0].reg;
10848   reject_bad_reg (Rd);
10849
10850   if (unified_syntax && inst.size_req == 0 && Rd <= 7)
10851     {
10852       /* Defer to section relaxation.  */
10853       inst.relax = inst.instruction;
10854       inst.instruction = THUMB_OP16 (inst.instruction);
10855       inst.instruction |= Rd << 4;
10856     }
10857   else if (unified_syntax && inst.size_req != 2)
10858     {
10859       /* Generate a 32-bit opcode.  */
10860       inst.instruction = THUMB_OP32 (inst.instruction);
10861       inst.instruction |= Rd << 8;
10862       inst.relocs[0].type = BFD_RELOC_ARM_T32_ADD_PC12;
10863       inst.relocs[0].pc_rel = 1;
10864     }
10865   else
10866     {
10867       /* Generate a 16-bit opcode.  */
10868       inst.instruction = THUMB_OP16 (inst.instruction);
10869       inst.relocs[0].type = BFD_RELOC_ARM_THUMB_ADD;
10870       inst.relocs[0].exp.X_add_number -= 4; /* PC relative adjust.  */
10871       inst.relocs[0].pc_rel = 1;
10872       inst.instruction |= Rd << 4;
10873     }
10874
10875   if (inst.relocs[0].exp.X_op == O_symbol
10876       && inst.relocs[0].exp.X_add_symbol != NULL
10877       && S_IS_DEFINED (inst.relocs[0].exp.X_add_symbol)
10878       && THUMB_IS_FUNC (inst.relocs[0].exp.X_add_symbol))
10879     inst.relocs[0].exp.X_add_number += 1;
10880 }
10881
10882 /* Arithmetic instructions for which there is just one 16-bit
10883    instruction encoding, and it allows only two low registers.
10884    For maximal compatibility with ARM syntax, we allow three register
10885    operands even when Thumb-32 instructions are not available, as long
10886    as the first two are identical.  For instance, both "sbc r0,r1" and
10887    "sbc r0,r0,r1" are allowed.  */
10888 static void
10889 do_t_arit3 (void)
10890 {
10891   int Rd, Rs, Rn;
10892
10893   Rd = inst.operands[0].reg;
10894   Rs = (inst.operands[1].present
10895         ? inst.operands[1].reg    /* Rd, Rs, foo */
10896         : inst.operands[0].reg);  /* Rd, foo -> Rd, Rd, foo */
10897   Rn = inst.operands[2].reg;
10898
10899   reject_bad_reg (Rd);
10900   reject_bad_reg (Rs);
10901   if (inst.operands[2].isreg)
10902     reject_bad_reg (Rn);
10903
10904   if (unified_syntax)
10905     {
10906       if (!inst.operands[2].isreg)
10907         {
10908           /* For an immediate, we always generate a 32-bit opcode;
10909              section relaxation will shrink it later if possible.  */
10910           inst.instruction = THUMB_OP32 (inst.instruction);
10911           inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
10912           inst.instruction |= Rd << 8;
10913           inst.instruction |= Rs << 16;
10914           inst.relocs[0].type = BFD_RELOC_ARM_T32_IMMEDIATE;
10915         }
10916       else
10917         {
10918           bfd_boolean narrow;
10919
10920           /* See if we can do this with a 16-bit instruction.  */
10921           if (THUMB_SETS_FLAGS (inst.instruction))
10922             narrow = !in_it_block ();
10923           else
10924             narrow = in_it_block ();
10925
10926           if (Rd > 7 || Rn > 7 || Rs > 7)
10927             narrow = FALSE;
10928           if (inst.operands[2].shifted)
10929             narrow = FALSE;
10930           if (inst.size_req == 4)
10931             narrow = FALSE;
10932
10933           if (narrow
10934               && Rd == Rs)
10935             {
10936               inst.instruction = THUMB_OP16 (inst.instruction);
10937               inst.instruction |= Rd;
10938               inst.instruction |= Rn << 3;
10939               return;
10940             }
10941
10942           /* If we get here, it can't be done in 16 bits.  */
10943           constraint (inst.operands[2].shifted
10944                       && inst.operands[2].immisreg,
10945                       _("shift must be constant"));
10946           inst.instruction = THUMB_OP32 (inst.instruction);
10947           inst.instruction |= Rd << 8;
10948           inst.instruction |= Rs << 16;
10949           encode_thumb32_shifted_operand (2);
10950         }
10951     }
10952   else
10953     {
10954       /* On its face this is a lie - the instruction does set the
10955          flags.  However, the only supported mnemonic in this mode
10956          says it doesn't.  */
10957       constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
10958
10959       constraint (!inst.operands[2].isreg || inst.operands[2].shifted,
10960                   _("unshifted register required"));
10961       constraint (Rd > 7 || Rs > 7 || Rn > 7, BAD_HIREG);
10962       constraint (Rd != Rs,
10963                   _("dest and source1 must be the same register"));
10964
10965       inst.instruction = THUMB_OP16 (inst.instruction);
10966       inst.instruction |= Rd;
10967       inst.instruction |= Rn << 3;
10968     }
10969 }
10970
10971 /* Similarly, but for instructions where the arithmetic operation is
10972    commutative, so we can allow either of them to be different from
10973    the destination operand in a 16-bit instruction.  For instance, all
10974    three of "adc r0,r1", "adc r0,r0,r1", and "adc r0,r1,r0" are
10975    accepted.  */
10976 static void
10977 do_t_arit3c (void)
10978 {
10979   int Rd, Rs, Rn;
10980
10981   Rd = inst.operands[0].reg;
10982   Rs = (inst.operands[1].present
10983         ? inst.operands[1].reg    /* Rd, Rs, foo */
10984         : inst.operands[0].reg);  /* Rd, foo -> Rd, Rd, foo */
10985   Rn = inst.operands[2].reg;
10986
10987   reject_bad_reg (Rd);
10988   reject_bad_reg (Rs);
10989   if (inst.operands[2].isreg)
10990     reject_bad_reg (Rn);
10991
10992   if (unified_syntax)
10993     {
10994       if (!inst.operands[2].isreg)
10995         {
10996           /* For an immediate, we always generate a 32-bit opcode;
10997              section relaxation will shrink it later if possible.  */
10998           inst.instruction = THUMB_OP32 (inst.instruction);
10999           inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
11000           inst.instruction |= Rd << 8;
11001           inst.instruction |= Rs << 16;
11002           inst.relocs[0].type = BFD_RELOC_ARM_T32_IMMEDIATE;
11003         }
11004       else
11005         {
11006           bfd_boolean narrow;
11007
11008           /* See if we can do this with a 16-bit instruction.  */
11009           if (THUMB_SETS_FLAGS (inst.instruction))
11010             narrow = !in_it_block ();
11011           else
11012             narrow = in_it_block ();
11013
11014           if (Rd > 7 || Rn > 7 || Rs > 7)
11015             narrow = FALSE;
11016           if (inst.operands[2].shifted)
11017             narrow = FALSE;
11018           if (inst.size_req == 4)
11019             narrow = FALSE;
11020
11021           if (narrow)
11022             {
11023               if (Rd == Rs)
11024                 {
11025                   inst.instruction = THUMB_OP16 (inst.instruction);
11026                   inst.instruction |= Rd;
11027                   inst.instruction |= Rn << 3;
11028                   return;
11029                 }
11030               if (Rd == Rn)
11031                 {
11032                   inst.instruction = THUMB_OP16 (inst.instruction);
11033                   inst.instruction |= Rd;
11034                   inst.instruction |= Rs << 3;
11035                   return;
11036                 }
11037             }
11038
11039           /* If we get here, it can't be done in 16 bits.  */
11040           constraint (inst.operands[2].shifted
11041                       && inst.operands[2].immisreg,
11042                       _("shift must be constant"));
11043           inst.instruction = THUMB_OP32 (inst.instruction);
11044           inst.instruction |= Rd << 8;
11045           inst.instruction |= Rs << 16;
11046           encode_thumb32_shifted_operand (2);
11047         }
11048     }
11049   else
11050     {
11051       /* On its face this is a lie - the instruction does set the
11052          flags.  However, the only supported mnemonic in this mode
11053          says it doesn't.  */
11054       constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
11055
11056       constraint (!inst.operands[2].isreg || inst.operands[2].shifted,
11057                   _("unshifted register required"));
11058       constraint (Rd > 7 || Rs > 7 || Rn > 7, BAD_HIREG);
11059
11060       inst.instruction = THUMB_OP16 (inst.instruction);
11061       inst.instruction |= Rd;
11062
11063       if (Rd == Rs)
11064         inst.instruction |= Rn << 3;
11065       else if (Rd == Rn)
11066         inst.instruction |= Rs << 3;
11067       else
11068         constraint (1, _("dest must overlap one source register"));
11069     }
11070 }
11071
11072 static void
11073 do_t_bfc (void)
11074 {
11075   unsigned Rd;
11076   unsigned int msb = inst.operands[1].imm + inst.operands[2].imm;
11077   constraint (msb > 32, _("bit-field extends past end of register"));
11078   /* The instruction encoding stores the LSB and MSB,
11079      not the LSB and width.  */
11080   Rd = inst.operands[0].reg;
11081   reject_bad_reg (Rd);
11082   inst.instruction |= Rd << 8;
11083   inst.instruction |= (inst.operands[1].imm & 0x1c) << 10;
11084   inst.instruction |= (inst.operands[1].imm & 0x03) << 6;
11085   inst.instruction |= msb - 1;
11086 }
11087
11088 static void
11089 do_t_bfi (void)
11090 {
11091   int Rd, Rn;
11092   unsigned int msb;
11093
11094   Rd = inst.operands[0].reg;
11095   reject_bad_reg (Rd);
11096
11097   /* #0 in second position is alternative syntax for bfc, which is
11098      the same instruction but with REG_PC in the Rm field.  */
11099   if (!inst.operands[1].isreg)
11100     Rn = REG_PC;
11101   else
11102     {
11103       Rn = inst.operands[1].reg;
11104       reject_bad_reg (Rn);
11105     }
11106
11107   msb = inst.operands[2].imm + inst.operands[3].imm;
11108   constraint (msb > 32, _("bit-field extends past end of register"));
11109   /* The instruction encoding stores the LSB and MSB,
11110      not the LSB and width.  */
11111   inst.instruction |= Rd << 8;
11112   inst.instruction |= Rn << 16;
11113   inst.instruction |= (inst.operands[2].imm & 0x1c) << 10;
11114   inst.instruction |= (inst.operands[2].imm & 0x03) << 6;
11115   inst.instruction |= msb - 1;
11116 }
11117
11118 static void
11119 do_t_bfx (void)
11120 {
11121   unsigned Rd, Rn;
11122
11123   Rd = inst.operands[0].reg;
11124   Rn = inst.operands[1].reg;
11125
11126   reject_bad_reg (Rd);
11127   reject_bad_reg (Rn);
11128
11129   constraint (inst.operands[2].imm + inst.operands[3].imm > 32,
11130               _("bit-field extends past end of register"));
11131   inst.instruction |= Rd << 8;
11132   inst.instruction |= Rn << 16;
11133   inst.instruction |= (inst.operands[2].imm & 0x1c) << 10;
11134   inst.instruction |= (inst.operands[2].imm & 0x03) << 6;
11135   inst.instruction |= inst.operands[3].imm - 1;
11136 }
11137
11138 /* ARM V5 Thumb BLX (argument parse)
11139         BLX <target_addr>       which is BLX(1)
11140         BLX <Rm>                which is BLX(2)
11141    Unfortunately, there are two different opcodes for this mnemonic.
11142    So, the insns[].value is not used, and the code here zaps values
11143         into inst.instruction.
11144
11145    ??? How to take advantage of the additional two bits of displacement
11146    available in Thumb32 mode?  Need new relocation?  */
11147
11148 static void
11149 do_t_blx (void)
11150 {
11151   set_it_insn_type_last ();
11152
11153   if (inst.operands[0].isreg)
11154     {
11155       constraint (inst.operands[0].reg == REG_PC, BAD_PC);
11156       /* We have a register, so this is BLX(2).  */
11157       inst.instruction |= inst.operands[0].reg << 3;
11158     }
11159   else
11160     {
11161       /* No register.  This must be BLX(1).  */
11162       inst.instruction = 0xf000e800;
11163       encode_branch (BFD_RELOC_THUMB_PCREL_BLX);
11164     }
11165 }
11166
11167 static void
11168 do_t_branch (void)
11169 {
11170   int opcode;
11171   int cond;
11172   bfd_reloc_code_real_type reloc;
11173
11174   cond = inst.cond;
11175   set_it_insn_type (IF_INSIDE_IT_LAST_INSN);
11176
11177   if (in_it_block ())
11178     {
11179       /* Conditional branches inside IT blocks are encoded as unconditional
11180          branches.  */
11181       cond = COND_ALWAYS;
11182     }
11183   else
11184     cond = inst.cond;
11185
11186   if (cond != COND_ALWAYS)
11187     opcode = T_MNEM_bcond;
11188   else
11189     opcode = inst.instruction;
11190
11191   if (unified_syntax
11192       && (inst.size_req == 4
11193           || (inst.size_req != 2
11194               && (inst.operands[0].hasreloc
11195                   || inst.relocs[0].exp.X_op == O_constant))))
11196     {
11197       inst.instruction = THUMB_OP32(opcode);
11198       if (cond == COND_ALWAYS)
11199         reloc = BFD_RELOC_THUMB_PCREL_BRANCH25;
11200       else
11201         {
11202           constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6t2),
11203                       _("selected architecture does not support "
11204                         "wide conditional branch instruction"));
11205
11206           gas_assert (cond != 0xF);
11207           inst.instruction |= cond << 22;
11208           reloc = BFD_RELOC_THUMB_PCREL_BRANCH20;
11209         }
11210     }
11211   else
11212     {
11213       inst.instruction = THUMB_OP16(opcode);
11214       if (cond == COND_ALWAYS)
11215         reloc = BFD_RELOC_THUMB_PCREL_BRANCH12;
11216       else
11217         {
11218           inst.instruction |= cond << 8;
11219           reloc = BFD_RELOC_THUMB_PCREL_BRANCH9;
11220         }
11221       /* Allow section relaxation.  */
11222       if (unified_syntax && inst.size_req != 2)
11223         inst.relax = opcode;
11224     }
11225   inst.relocs[0].type = reloc;
11226   inst.relocs[0].pc_rel = 1;
11227 }
11228
11229 /* Actually do the work for Thumb state bkpt and hlt.  The only difference
11230    between the two is the maximum immediate allowed - which is passed in
11231    RANGE.  */
11232 static void
11233 do_t_bkpt_hlt1 (int range)
11234 {
11235   constraint (inst.cond != COND_ALWAYS,
11236               _("instruction is always unconditional"));
11237   if (inst.operands[0].present)
11238     {
11239       constraint (inst.operands[0].imm > range,
11240                   _("immediate value out of range"));
11241       inst.instruction |= inst.operands[0].imm;
11242     }
11243
11244   set_it_insn_type (NEUTRAL_IT_INSN);
11245 }
11246
11247 static void
11248 do_t_hlt (void)
11249 {
11250   do_t_bkpt_hlt1 (63);
11251 }
11252
11253 static void
11254 do_t_bkpt (void)
11255 {
11256   do_t_bkpt_hlt1 (255);
11257 }
11258
11259 static void
11260 do_t_branch23 (void)
11261 {
11262   set_it_insn_type_last ();
11263   encode_branch (BFD_RELOC_THUMB_PCREL_BRANCH23);
11264
11265   /* md_apply_fix blows up with 'bl foo(PLT)' where foo is defined in
11266      this file.  We used to simply ignore the PLT reloc type here --
11267      the branch encoding is now needed to deal with TLSCALL relocs.
11268      So if we see a PLT reloc now, put it back to how it used to be to
11269      keep the preexisting behaviour.  */
11270   if (inst.relocs[0].type == BFD_RELOC_ARM_PLT32)
11271     inst.relocs[0].type = BFD_RELOC_THUMB_PCREL_BRANCH23;
11272
11273 #if defined(OBJ_COFF)
11274   /* If the destination of the branch is a defined symbol which does not have
11275      the THUMB_FUNC attribute, then we must be calling a function which has
11276      the (interfacearm) attribute.  We look for the Thumb entry point to that
11277      function and change the branch to refer to that function instead.  */
11278   if (   inst.relocs[0].exp.X_op == O_symbol
11279       && inst.relocs[0].exp.X_add_symbol != NULL
11280       && S_IS_DEFINED (inst.relocs[0].exp.X_add_symbol)
11281       && ! THUMB_IS_FUNC (inst.relocs[0].exp.X_add_symbol))
11282     inst.relocs[0].exp.X_add_symbol
11283       = find_real_start (inst.relocs[0].exp.X_add_symbol);
11284 #endif
11285 }
11286
11287 static void
11288 do_t_bx (void)
11289 {
11290   set_it_insn_type_last ();
11291   inst.instruction |= inst.operands[0].reg << 3;
11292   /* ??? FIXME: Should add a hacky reloc here if reg is REG_PC.  The reloc
11293      should cause the alignment to be checked once it is known.  This is
11294      because BX PC only works if the instruction is word aligned.  */
11295 }
11296
11297 static void
11298 do_t_bxj (void)
11299 {
11300   int Rm;
11301
11302   set_it_insn_type_last ();
11303   Rm = inst.operands[0].reg;
11304   reject_bad_reg (Rm);
11305   inst.instruction |= Rm << 16;
11306 }
11307
11308 static void
11309 do_t_clz (void)
11310 {
11311   unsigned Rd;
11312   unsigned Rm;
11313
11314   Rd = inst.operands[0].reg;
11315   Rm = inst.operands[1].reg;
11316
11317   reject_bad_reg (Rd);
11318   reject_bad_reg (Rm);
11319
11320   inst.instruction |= Rd << 8;
11321   inst.instruction |= Rm << 16;
11322   inst.instruction |= Rm;
11323 }
11324
11325 static void
11326 do_t_csdb (void)
11327 {
11328   set_it_insn_type (OUTSIDE_IT_INSN);
11329 }
11330
11331 static void
11332 do_t_cps (void)
11333 {
11334   set_it_insn_type (OUTSIDE_IT_INSN);
11335   inst.instruction |= inst.operands[0].imm;
11336 }
11337
11338 static void
11339 do_t_cpsi (void)
11340 {
11341   set_it_insn_type (OUTSIDE_IT_INSN);
11342   if (unified_syntax
11343       && (inst.operands[1].present || inst.size_req == 4)
11344       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6_notm))
11345     {
11346       unsigned int imod = (inst.instruction & 0x0030) >> 4;
11347       inst.instruction = 0xf3af8000;
11348       inst.instruction |= imod << 9;
11349       inst.instruction |= inst.operands[0].imm << 5;
11350       if (inst.operands[1].present)
11351         inst.instruction |= 0x100 | inst.operands[1].imm;
11352     }
11353   else
11354     {
11355       constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1)
11356                   && (inst.operands[0].imm & 4),
11357                   _("selected processor does not support 'A' form "
11358                     "of this instruction"));
11359       constraint (inst.operands[1].present || inst.size_req == 4,
11360                   _("Thumb does not support the 2-argument "
11361                     "form of this instruction"));
11362       inst.instruction |= inst.operands[0].imm;
11363     }
11364 }
11365
11366 /* THUMB CPY instruction (argument parse).  */
11367
11368 static void
11369 do_t_cpy (void)
11370 {
11371   if (inst.size_req == 4)
11372     {
11373       inst.instruction = THUMB_OP32 (T_MNEM_mov);
11374       inst.instruction |= inst.operands[0].reg << 8;
11375       inst.instruction |= inst.operands[1].reg;
11376     }
11377   else
11378     {
11379       inst.instruction |= (inst.operands[0].reg & 0x8) << 4;
11380       inst.instruction |= (inst.operands[0].reg & 0x7);
11381       inst.instruction |= inst.operands[1].reg << 3;
11382     }
11383 }
11384
11385 static void
11386 do_t_cbz (void)
11387 {
11388   set_it_insn_type (OUTSIDE_IT_INSN);
11389   constraint (inst.operands[0].reg > 7, BAD_HIREG);
11390   inst.instruction |= inst.operands[0].reg;
11391   inst.relocs[0].pc_rel = 1;
11392   inst.relocs[0].type = BFD_RELOC_THUMB_PCREL_BRANCH7;
11393 }
11394
11395 static void
11396 do_t_dbg (void)
11397 {
11398   inst.instruction |= inst.operands[0].imm;
11399 }
11400
11401 static void
11402 do_t_div (void)
11403 {
11404   unsigned Rd, Rn, Rm;
11405
11406   Rd = inst.operands[0].reg;
11407   Rn = (inst.operands[1].present
11408         ? inst.operands[1].reg : Rd);
11409   Rm = inst.operands[2].reg;
11410
11411   reject_bad_reg (Rd);
11412   reject_bad_reg (Rn);
11413   reject_bad_reg (Rm);
11414
11415   inst.instruction |= Rd << 8;
11416   inst.instruction |= Rn << 16;
11417   inst.instruction |= Rm;
11418 }
11419
11420 static void
11421 do_t_hint (void)
11422 {
11423   if (unified_syntax && inst.size_req == 4)
11424     inst.instruction = THUMB_OP32 (inst.instruction);
11425   else
11426     inst.instruction = THUMB_OP16 (inst.instruction);
11427 }
11428
11429 static void
11430 do_t_it (void)
11431 {
11432   unsigned int cond = inst.operands[0].imm;
11433
11434   set_it_insn_type (IT_INSN);
11435   now_it.mask = (inst.instruction & 0xf) | 0x10;
11436   now_it.cc = cond;
11437   now_it.warn_deprecated = FALSE;
11438
11439   /* If the condition is a negative condition, invert the mask.  */
11440   if ((cond & 0x1) == 0x0)
11441     {
11442       unsigned int mask = inst.instruction & 0x000f;
11443
11444       if ((mask & 0x7) == 0)
11445         {
11446           /* No conversion needed.  */
11447           now_it.block_length = 1;
11448         }
11449       else if ((mask & 0x3) == 0)
11450         {
11451           mask ^= 0x8;
11452           now_it.block_length = 2;
11453         }
11454       else if ((mask & 0x1) == 0)
11455         {
11456           mask ^= 0xC;
11457           now_it.block_length = 3;
11458         }
11459       else
11460         {
11461           mask ^= 0xE;
11462           now_it.block_length = 4;
11463         }
11464
11465       inst.instruction &= 0xfff0;
11466       inst.instruction |= mask;
11467     }
11468
11469   inst.instruction |= cond << 4;
11470 }
11471
11472 /* Helper function used for both push/pop and ldm/stm.  */
11473 static void
11474 encode_thumb2_ldmstm (int base, unsigned mask, bfd_boolean writeback)
11475 {
11476   bfd_boolean load;
11477
11478   load = (inst.instruction & (1 << 20)) != 0;
11479
11480   if (mask & (1 << 13))
11481     inst.error =  _("SP not allowed in register list");
11482
11483   if ((mask & (1 << base)) != 0
11484       && writeback)
11485     inst.error = _("having the base register in the register list when "
11486                    "using write back is UNPREDICTABLE");
11487
11488   if (load)
11489     {
11490       if (mask & (1 << 15))
11491         {
11492           if (mask & (1 << 14))
11493             inst.error = _("LR and PC should not both be in register list");
11494           else
11495             set_it_insn_type_last ();
11496         }
11497     }
11498   else
11499     {
11500       if (mask & (1 << 15))
11501         inst.error = _("PC not allowed in register list");
11502     }
11503
11504   if ((mask & (mask - 1)) == 0)
11505     {
11506       /* Single register transfers implemented as str/ldr.  */
11507       if (writeback)
11508         {
11509           if (inst.instruction & (1 << 23))
11510             inst.instruction = 0x00000b04; /* ia! -> [base], #4 */
11511           else
11512             inst.instruction = 0x00000d04; /* db! -> [base, #-4]! */
11513         }
11514       else
11515         {
11516           if (inst.instruction & (1 << 23))
11517             inst.instruction = 0x00800000; /* ia -> [base] */
11518           else
11519             inst.instruction = 0x00000c04; /* db -> [base, #-4] */
11520         }
11521
11522       inst.instruction |= 0xf8400000;
11523       if (load)
11524         inst.instruction |= 0x00100000;
11525
11526       mask = ffs (mask) - 1;
11527       mask <<= 12;
11528     }
11529   else if (writeback)
11530     inst.instruction |= WRITE_BACK;
11531
11532   inst.instruction |= mask;
11533   inst.instruction |= base << 16;
11534 }
11535
11536 static void
11537 do_t_ldmstm (void)
11538 {
11539   /* This really doesn't seem worth it.  */
11540   constraint (inst.relocs[0].type != BFD_RELOC_UNUSED,
11541               _("expression too complex"));
11542   constraint (inst.operands[1].writeback,
11543               _("Thumb load/store multiple does not support {reglist}^"));
11544
11545   if (unified_syntax)
11546     {
11547       bfd_boolean narrow;
11548       unsigned mask;
11549
11550       narrow = FALSE;
11551       /* See if we can use a 16-bit instruction.  */
11552       if (inst.instruction < 0xffff /* not ldmdb/stmdb */
11553           && inst.size_req != 4
11554           && !(inst.operands[1].imm & ~0xff))
11555         {
11556           mask = 1 << inst.operands[0].reg;
11557
11558           if (inst.operands[0].reg <= 7)
11559             {
11560               if (inst.instruction == T_MNEM_stmia
11561                   ? inst.operands[0].writeback
11562                   : (inst.operands[0].writeback
11563                      == !(inst.operands[1].imm & mask)))
11564                 {
11565                   if (inst.instruction == T_MNEM_stmia
11566                       && (inst.operands[1].imm & mask)
11567                       && (inst.operands[1].imm & (mask - 1)))
11568                     as_warn (_("value stored for r%d is UNKNOWN"),
11569                              inst.operands[0].reg);
11570
11571                   inst.instruction = THUMB_OP16 (inst.instruction);
11572                   inst.instruction |= inst.operands[0].reg << 8;
11573                   inst.instruction |= inst.operands[1].imm;
11574                   narrow = TRUE;
11575                 }
11576               else if ((inst.operands[1].imm & (inst.operands[1].imm-1)) == 0)
11577                 {
11578                   /* This means 1 register in reg list one of 3 situations:
11579                      1. Instruction is stmia, but without writeback.
11580                      2. lmdia without writeback, but with Rn not in
11581                         reglist.
11582                      3. ldmia with writeback, but with Rn in reglist.
11583                      Case 3 is UNPREDICTABLE behaviour, so we handle
11584                      case 1 and 2 which can be converted into a 16-bit
11585                      str or ldr. The SP cases are handled below.  */
11586                   unsigned long opcode;
11587                   /* First, record an error for Case 3.  */
11588                   if (inst.operands[1].imm & mask
11589                       && inst.operands[0].writeback)
11590                     inst.error =
11591                         _("having the base register in the register list when "
11592                           "using write back is UNPREDICTABLE");
11593
11594                   opcode = (inst.instruction == T_MNEM_stmia ? T_MNEM_str
11595                                                              : T_MNEM_ldr);
11596                   inst.instruction = THUMB_OP16 (opcode);
11597                   inst.instruction |= inst.operands[0].reg << 3;
11598                   inst.instruction |= (ffs (inst.operands[1].imm)-1);
11599                   narrow = TRUE;
11600                 }
11601             }
11602           else if (inst.operands[0] .reg == REG_SP)
11603             {
11604               if (inst.operands[0].writeback)
11605                 {
11606                   inst.instruction =
11607                         THUMB_OP16 (inst.instruction == T_MNEM_stmia
11608                                     ? T_MNEM_push : T_MNEM_pop);
11609                   inst.instruction |= inst.operands[1].imm;
11610                   narrow = TRUE;
11611                 }
11612               else if ((inst.operands[1].imm & (inst.operands[1].imm-1)) == 0)
11613                 {
11614                   inst.instruction =
11615                         THUMB_OP16 (inst.instruction == T_MNEM_stmia
11616                                     ? T_MNEM_str_sp : T_MNEM_ldr_sp);
11617                   inst.instruction |= ((ffs (inst.operands[1].imm)-1) << 8);
11618                   narrow = TRUE;
11619                 }
11620             }
11621         }
11622
11623       if (!narrow)
11624         {
11625           if (inst.instruction < 0xffff)
11626             inst.instruction = THUMB_OP32 (inst.instruction);
11627
11628           encode_thumb2_ldmstm (inst.operands[0].reg, inst.operands[1].imm,
11629                                 inst.operands[0].writeback);
11630         }
11631     }
11632   else
11633     {
11634       constraint (inst.operands[0].reg > 7
11635                   || (inst.operands[1].imm & ~0xff), BAD_HIREG);
11636       constraint (inst.instruction != T_MNEM_ldmia
11637                   && inst.instruction != T_MNEM_stmia,
11638                   _("Thumb-2 instruction only valid in unified syntax"));
11639       if (inst.instruction == T_MNEM_stmia)
11640         {
11641           if (!inst.operands[0].writeback)
11642             as_warn (_("this instruction will write back the base register"));
11643           if ((inst.operands[1].imm & (1 << inst.operands[0].reg))
11644               && (inst.operands[1].imm & ((1 << inst.operands[0].reg) - 1)))
11645             as_warn (_("value stored for r%d is UNKNOWN"),
11646                      inst.operands[0].reg);
11647         }
11648       else
11649         {
11650           if (!inst.operands[0].writeback
11651               && !(inst.operands[1].imm & (1 << inst.operands[0].reg)))
11652             as_warn (_("this instruction will write back the base register"));
11653           else if (inst.operands[0].writeback
11654                    && (inst.operands[1].imm & (1 << inst.operands[0].reg)))
11655             as_warn (_("this instruction will not write back the base register"));
11656         }
11657
11658       inst.instruction = THUMB_OP16 (inst.instruction);
11659       inst.instruction |= inst.operands[0].reg << 8;
11660       inst.instruction |= inst.operands[1].imm;
11661     }
11662 }
11663
11664 static void
11665 do_t_ldrex (void)
11666 {
11667   constraint (!inst.operands[1].isreg || !inst.operands[1].preind
11668               || inst.operands[1].postind || inst.operands[1].writeback
11669               || inst.operands[1].immisreg || inst.operands[1].shifted
11670               || inst.operands[1].negative,
11671               BAD_ADDR_MODE);
11672
11673   constraint ((inst.operands[1].reg == REG_PC), BAD_PC);
11674
11675   inst.instruction |= inst.operands[0].reg << 12;
11676   inst.instruction |= inst.operands[1].reg << 16;
11677   inst.relocs[0].type = BFD_RELOC_ARM_T32_OFFSET_U8;
11678 }
11679
11680 static void
11681 do_t_ldrexd (void)
11682 {
11683   if (!inst.operands[1].present)
11684     {
11685       constraint (inst.operands[0].reg == REG_LR,
11686                   _("r14 not allowed as first register "
11687                     "when second register is omitted"));
11688       inst.operands[1].reg = inst.operands[0].reg + 1;
11689     }
11690   constraint (inst.operands[0].reg == inst.operands[1].reg,
11691               BAD_OVERLAP);
11692
11693   inst.instruction |= inst.operands[0].reg << 12;
11694   inst.instruction |= inst.operands[1].reg << 8;
11695   inst.instruction |= inst.operands[2].reg << 16;
11696 }
11697
11698 static void
11699 do_t_ldst (void)
11700 {
11701   unsigned long opcode;
11702   int Rn;
11703
11704   if (inst.operands[0].isreg
11705       && !inst.operands[0].preind
11706       && inst.operands[0].reg == REG_PC)
11707     set_it_insn_type_last ();
11708
11709   opcode = inst.instruction;
11710   if (unified_syntax)
11711     {
11712       if (!inst.operands[1].isreg)
11713         {
11714           if (opcode <= 0xffff)
11715             inst.instruction = THUMB_OP32 (opcode);
11716           if (move_or_literal_pool (0, CONST_THUMB, /*mode_3=*/FALSE))
11717             return;
11718         }
11719       if (inst.operands[1].isreg
11720           && !inst.operands[1].writeback
11721           && !inst.operands[1].shifted && !inst.operands[1].postind
11722           && !inst.operands[1].negative && inst.operands[0].reg <= 7
11723           && opcode <= 0xffff
11724           && inst.size_req != 4)
11725         {
11726           /* Insn may have a 16-bit form.  */
11727           Rn = inst.operands[1].reg;
11728           if (inst.operands[1].immisreg)
11729             {
11730               inst.instruction = THUMB_OP16 (opcode);
11731               /* [Rn, Rik] */
11732               if (Rn <= 7 && inst.operands[1].imm <= 7)
11733                 goto op16;
11734               else if (opcode != T_MNEM_ldr && opcode != T_MNEM_str)
11735                 reject_bad_reg (inst.operands[1].imm);
11736             }
11737           else if ((Rn <= 7 && opcode != T_MNEM_ldrsh
11738                     && opcode != T_MNEM_ldrsb)
11739                    || ((Rn == REG_PC || Rn == REG_SP) && opcode == T_MNEM_ldr)
11740                    || (Rn == REG_SP && opcode == T_MNEM_str))
11741             {
11742               /* [Rn, #const] */
11743               if (Rn > 7)
11744                 {
11745                   if (Rn == REG_PC)
11746                     {
11747                       if (inst.relocs[0].pc_rel)
11748                         opcode = T_MNEM_ldr_pc2;
11749                       else
11750                         opcode = T_MNEM_ldr_pc;
11751                     }
11752                   else
11753                     {
11754                       if (opcode == T_MNEM_ldr)
11755                         opcode = T_MNEM_ldr_sp;
11756                       else
11757                         opcode = T_MNEM_str_sp;
11758                     }
11759                   inst.instruction = inst.operands[0].reg << 8;
11760                 }
11761               else
11762                 {
11763                   inst.instruction = inst.operands[0].reg;
11764                   inst.instruction |= inst.operands[1].reg << 3;
11765                 }
11766               inst.instruction |= THUMB_OP16 (opcode);
11767               if (inst.size_req == 2)
11768                 inst.relocs[0].type = BFD_RELOC_ARM_THUMB_OFFSET;
11769               else
11770                 inst.relax = opcode;
11771               return;
11772             }
11773         }
11774       /* Definitely a 32-bit variant.  */
11775
11776       /* Warning for Erratum 752419.  */
11777       if (opcode == T_MNEM_ldr
11778           && inst.operands[0].reg == REG_SP
11779           && inst.operands[1].writeback == 1
11780           && !inst.operands[1].immisreg)
11781         {
11782           if (no_cpu_selected ()
11783               || (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7)
11784                   && !ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7a)
11785                   && !ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7r)))
11786             as_warn (_("This instruction may be unpredictable "
11787                        "if executed on M-profile cores "
11788                        "with interrupts enabled."));
11789         }
11790
11791       /* Do some validations regarding addressing modes.  */
11792       if (inst.operands[1].immisreg)
11793         reject_bad_reg (inst.operands[1].imm);
11794
11795       constraint (inst.operands[1].writeback == 1
11796                   && inst.operands[0].reg == inst.operands[1].reg,
11797                   BAD_OVERLAP);
11798
11799       inst.instruction = THUMB_OP32 (opcode);
11800       inst.instruction |= inst.operands[0].reg << 12;
11801       encode_thumb32_addr_mode (1, /*is_t=*/FALSE, /*is_d=*/FALSE);
11802       check_ldr_r15_aligned ();
11803       return;
11804     }
11805
11806   constraint (inst.operands[0].reg > 7, BAD_HIREG);
11807
11808   if (inst.instruction == T_MNEM_ldrsh || inst.instruction == T_MNEM_ldrsb)
11809     {
11810       /* Only [Rn,Rm] is acceptable.  */
11811       constraint (inst.operands[1].reg > 7 || inst.operands[1].imm > 7, BAD_HIREG);
11812       constraint (!inst.operands[1].isreg || !inst.operands[1].immisreg
11813                   || inst.operands[1].postind || inst.operands[1].shifted
11814                   || inst.operands[1].negative,
11815                   _("Thumb does not support this addressing mode"));
11816       inst.instruction = THUMB_OP16 (inst.instruction);
11817       goto op16;
11818     }
11819
11820   inst.instruction = THUMB_OP16 (inst.instruction);
11821   if (!inst.operands[1].isreg)
11822     if (move_or_literal_pool (0, CONST_THUMB, /*mode_3=*/FALSE))
11823       return;
11824
11825   constraint (!inst.operands[1].preind
11826               || inst.operands[1].shifted
11827               || inst.operands[1].writeback,
11828               _("Thumb does not support this addressing mode"));
11829   if (inst.operands[1].reg == REG_PC || inst.operands[1].reg == REG_SP)
11830     {
11831       constraint (inst.instruction & 0x0600,
11832                   _("byte or halfword not valid for base register"));
11833       constraint (inst.operands[1].reg == REG_PC
11834                   && !(inst.instruction & THUMB_LOAD_BIT),
11835                   _("r15 based store not allowed"));
11836       constraint (inst.operands[1].immisreg,
11837                   _("invalid base register for register offset"));
11838
11839       if (inst.operands[1].reg == REG_PC)
11840         inst.instruction = T_OPCODE_LDR_PC;
11841       else if (inst.instruction & THUMB_LOAD_BIT)
11842         inst.instruction = T_OPCODE_LDR_SP;
11843       else
11844         inst.instruction = T_OPCODE_STR_SP;
11845
11846       inst.instruction |= inst.operands[0].reg << 8;
11847       inst.relocs[0].type = BFD_RELOC_ARM_THUMB_OFFSET;
11848       return;
11849     }
11850
11851   constraint (inst.operands[1].reg > 7, BAD_HIREG);
11852   if (!inst.operands[1].immisreg)
11853     {
11854       /* Immediate offset.  */
11855       inst.instruction |= inst.operands[0].reg;
11856       inst.instruction |= inst.operands[1].reg << 3;
11857       inst.relocs[0].type = BFD_RELOC_ARM_THUMB_OFFSET;
11858       return;
11859     }
11860
11861   /* Register offset.  */
11862   constraint (inst.operands[1].imm > 7, BAD_HIREG);
11863   constraint (inst.operands[1].negative,
11864               _("Thumb does not support this addressing mode"));
11865
11866  op16:
11867   switch (inst.instruction)
11868     {
11869     case T_OPCODE_STR_IW: inst.instruction = T_OPCODE_STR_RW; break;
11870     case T_OPCODE_STR_IH: inst.instruction = T_OPCODE_STR_RH; break;
11871     case T_OPCODE_STR_IB: inst.instruction = T_OPCODE_STR_RB; break;
11872     case T_OPCODE_LDR_IW: inst.instruction = T_OPCODE_LDR_RW; break;
11873     case T_OPCODE_LDR_IH: inst.instruction = T_OPCODE_LDR_RH; break;
11874     case T_OPCODE_LDR_IB: inst.instruction = T_OPCODE_LDR_RB; break;
11875     case 0x5600 /* ldrsb */:
11876     case 0x5e00 /* ldrsh */: break;
11877     default: abort ();
11878     }
11879
11880   inst.instruction |= inst.operands[0].reg;
11881   inst.instruction |= inst.operands[1].reg << 3;
11882   inst.instruction |= inst.operands[1].imm << 6;
11883 }
11884
11885 static void
11886 do_t_ldstd (void)
11887 {
11888   if (!inst.operands[1].present)
11889     {
11890       inst.operands[1].reg = inst.operands[0].reg + 1;
11891       constraint (inst.operands[0].reg == REG_LR,
11892                   _("r14 not allowed here"));
11893       constraint (inst.operands[0].reg == REG_R12,
11894                   _("r12 not allowed here"));
11895     }
11896
11897   if (inst.operands[2].writeback
11898       && (inst.operands[0].reg == inst.operands[2].reg
11899       || inst.operands[1].reg == inst.operands[2].reg))
11900     as_warn (_("base register written back, and overlaps "
11901                "one of transfer registers"));
11902
11903   inst.instruction |= inst.operands[0].reg << 12;
11904   inst.instruction |= inst.operands[1].reg << 8;
11905   encode_thumb32_addr_mode (2, /*is_t=*/FALSE, /*is_d=*/TRUE);
11906 }
11907
11908 static void
11909 do_t_ldstt (void)
11910 {
11911   inst.instruction |= inst.operands[0].reg << 12;
11912   encode_thumb32_addr_mode (1, /*is_t=*/TRUE, /*is_d=*/FALSE);
11913 }
11914
11915 static void
11916 do_t_mla (void)
11917 {
11918   unsigned Rd, Rn, Rm, Ra;
11919
11920   Rd = inst.operands[0].reg;
11921   Rn = inst.operands[1].reg;
11922   Rm = inst.operands[2].reg;
11923   Ra = inst.operands[3].reg;
11924
11925   reject_bad_reg (Rd);
11926   reject_bad_reg (Rn);
11927   reject_bad_reg (Rm);
11928   reject_bad_reg (Ra);
11929
11930   inst.instruction |= Rd << 8;
11931   inst.instruction |= Rn << 16;
11932   inst.instruction |= Rm;
11933   inst.instruction |= Ra << 12;
11934 }
11935
11936 static void
11937 do_t_mlal (void)
11938 {
11939   unsigned RdLo, RdHi, Rn, Rm;
11940
11941   RdLo = inst.operands[0].reg;
11942   RdHi = inst.operands[1].reg;
11943   Rn = inst.operands[2].reg;
11944   Rm = inst.operands[3].reg;
11945
11946   reject_bad_reg (RdLo);
11947   reject_bad_reg (RdHi);
11948   reject_bad_reg (Rn);
11949   reject_bad_reg (Rm);
11950
11951   inst.instruction |= RdLo << 12;
11952   inst.instruction |= RdHi << 8;
11953   inst.instruction |= Rn << 16;
11954   inst.instruction |= Rm;
11955 }
11956
11957 static void
11958 do_t_mov_cmp (void)
11959 {
11960   unsigned Rn, Rm;
11961
11962   Rn = inst.operands[0].reg;
11963   Rm = inst.operands[1].reg;
11964
11965   if (Rn == REG_PC)
11966     set_it_insn_type_last ();
11967
11968   if (unified_syntax)
11969     {
11970       int r0off = (inst.instruction == T_MNEM_mov
11971                    || inst.instruction == T_MNEM_movs) ? 8 : 16;
11972       unsigned long opcode;
11973       bfd_boolean narrow;
11974       bfd_boolean low_regs;
11975
11976       low_regs = (Rn <= 7 && Rm <= 7);
11977       opcode = inst.instruction;
11978       if (in_it_block ())
11979         narrow = opcode != T_MNEM_movs;
11980       else
11981         narrow = opcode != T_MNEM_movs || low_regs;
11982       if (inst.size_req == 4
11983           || inst.operands[1].shifted)
11984         narrow = FALSE;
11985
11986       /* MOVS PC, LR is encoded as SUBS PC, LR, #0.  */
11987       if (opcode == T_MNEM_movs && inst.operands[1].isreg
11988           && !inst.operands[1].shifted
11989           && Rn == REG_PC
11990           && Rm == REG_LR)
11991         {
11992           inst.instruction = T2_SUBS_PC_LR;
11993           return;
11994         }
11995
11996       if (opcode == T_MNEM_cmp)
11997         {
11998           constraint (Rn == REG_PC, BAD_PC);
11999           if (narrow)
12000             {
12001               /* In the Thumb-2 ISA, use of R13 as Rm is deprecated,
12002                  but valid.  */
12003               warn_deprecated_sp (Rm);
12004               /* R15 was documented as a valid choice for Rm in ARMv6,
12005                  but as UNPREDICTABLE in ARMv7.  ARM's proprietary
12006                  tools reject R15, so we do too.  */
12007               constraint (Rm == REG_PC, BAD_PC);
12008             }
12009           else
12010             reject_bad_reg (Rm);
12011         }
12012       else if (opcode == T_MNEM_mov
12013                || opcode == T_MNEM_movs)
12014         {
12015           if (inst.operands[1].isreg)
12016             {
12017               if (opcode == T_MNEM_movs)
12018                 {
12019                   reject_bad_reg (Rn);
12020                   reject_bad_reg (Rm);
12021                 }
12022               else if (narrow)
12023                 {
12024                   /* This is mov.n.  */
12025                   if ((Rn == REG_SP || Rn == REG_PC)
12026                       && (Rm == REG_SP || Rm == REG_PC))
12027                     {
12028                       as_tsktsk (_("Use of r%u as a source register is "
12029                                  "deprecated when r%u is the destination "
12030                                  "register."), Rm, Rn);
12031                     }
12032                 }
12033               else
12034                 {
12035                   /* This is mov.w.  */
12036                   constraint (Rn == REG_PC, BAD_PC);
12037                   constraint (Rm == REG_PC, BAD_PC);
12038                   if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
12039                     constraint (Rn == REG_SP && Rm == REG_SP, BAD_SP);
12040                 }
12041             }
12042           else
12043             reject_bad_reg (Rn);
12044         }
12045
12046       if (!inst.operands[1].isreg)
12047         {
12048           /* Immediate operand.  */
12049           if (!in_it_block () && opcode == T_MNEM_mov)
12050             narrow = 0;
12051           if (low_regs && narrow)
12052             {
12053               inst.instruction = THUMB_OP16 (opcode);
12054               inst.instruction |= Rn << 8;
12055               if (inst.relocs[0].type < BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC
12056                   || inst.relocs[0].type > BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC)
12057                 {
12058                   if (inst.size_req == 2)
12059                     inst.relocs[0].type = BFD_RELOC_ARM_THUMB_IMM;
12060                   else
12061                     inst.relax = opcode;
12062                 }
12063             }
12064           else
12065             {
12066               constraint ((inst.relocs[0].type
12067                            >= BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC)
12068                           && (inst.relocs[0].type
12069                               <= BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC) ,
12070                           THUMB1_RELOC_ONLY);
12071
12072               inst.instruction = THUMB_OP32 (inst.instruction);
12073               inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
12074               inst.instruction |= Rn << r0off;
12075               inst.relocs[0].type = BFD_RELOC_ARM_T32_IMMEDIATE;
12076             }
12077         }
12078       else if (inst.operands[1].shifted && inst.operands[1].immisreg
12079                && (inst.instruction == T_MNEM_mov
12080                    || inst.instruction == T_MNEM_movs))
12081         {
12082           /* Register shifts are encoded as separate shift instructions.  */
12083           bfd_boolean flags = (inst.instruction == T_MNEM_movs);
12084
12085           if (in_it_block ())
12086             narrow = !flags;
12087           else
12088             narrow = flags;
12089
12090           if (inst.size_req == 4)
12091             narrow = FALSE;
12092
12093           if (!low_regs || inst.operands[1].imm > 7)
12094             narrow = FALSE;
12095
12096           if (Rn != Rm)
12097             narrow = FALSE;
12098
12099           switch (inst.operands[1].shift_kind)
12100             {
12101             case SHIFT_LSL:
12102               opcode = narrow ? T_OPCODE_LSL_R : THUMB_OP32 (T_MNEM_lsl);
12103               break;
12104             case SHIFT_ASR:
12105               opcode = narrow ? T_OPCODE_ASR_R : THUMB_OP32 (T_MNEM_asr);
12106               break;
12107             case SHIFT_LSR:
12108               opcode = narrow ? T_OPCODE_LSR_R : THUMB_OP32 (T_MNEM_lsr);
12109               break;
12110             case SHIFT_ROR:
12111               opcode = narrow ? T_OPCODE_ROR_R : THUMB_OP32 (T_MNEM_ror);
12112               break;
12113             default:
12114               abort ();
12115             }
12116
12117           inst.instruction = opcode;
12118           if (narrow)
12119             {
12120               inst.instruction |= Rn;
12121               inst.instruction |= inst.operands[1].imm << 3;
12122             }
12123           else
12124             {
12125               if (flags)
12126                 inst.instruction |= CONDS_BIT;
12127
12128               inst.instruction |= Rn << 8;
12129               inst.instruction |= Rm << 16;
12130               inst.instruction |= inst.operands[1].imm;
12131             }
12132         }
12133       else if (!narrow)
12134         {
12135           /* Some mov with immediate shift have narrow variants.
12136              Register shifts are handled above.  */
12137           if (low_regs && inst.operands[1].shifted
12138               && (inst.instruction == T_MNEM_mov
12139                   || inst.instruction == T_MNEM_movs))
12140             {
12141               if (in_it_block ())
12142                 narrow = (inst.instruction == T_MNEM_mov);
12143               else
12144                 narrow = (inst.instruction == T_MNEM_movs);
12145             }
12146
12147           if (narrow)
12148             {
12149               switch (inst.operands[1].shift_kind)
12150                 {
12151                 case SHIFT_LSL: inst.instruction = T_OPCODE_LSL_I; break;
12152                 case SHIFT_LSR: inst.instruction = T_OPCODE_LSR_I; break;
12153                 case SHIFT_ASR: inst.instruction = T_OPCODE_ASR_I; break;
12154                 default: narrow = FALSE; break;
12155                 }
12156             }
12157
12158           if (narrow)
12159             {
12160               inst.instruction |= Rn;
12161               inst.instruction |= Rm << 3;
12162               inst.relocs[0].type = BFD_RELOC_ARM_THUMB_SHIFT;
12163             }
12164           else
12165             {
12166               inst.instruction = THUMB_OP32 (inst.instruction);
12167               inst.instruction |= Rn << r0off;
12168               encode_thumb32_shifted_operand (1);
12169             }
12170         }
12171       else
12172         switch (inst.instruction)
12173           {
12174           case T_MNEM_mov:
12175             /* In v4t or v5t a move of two lowregs produces unpredictable
12176                results. Don't allow this.  */
12177             if (low_regs)
12178               {
12179                 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6),
12180                             "MOV Rd, Rs with two low registers is not "
12181                             "permitted on this architecture");
12182                 ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
12183                                         arm_ext_v6);
12184               }
12185
12186             inst.instruction = T_OPCODE_MOV_HR;
12187             inst.instruction |= (Rn & 0x8) << 4;
12188             inst.instruction |= (Rn & 0x7);
12189             inst.instruction |= Rm << 3;
12190             break;
12191
12192           case T_MNEM_movs:
12193             /* We know we have low registers at this point.
12194                Generate LSLS Rd, Rs, #0.  */
12195             inst.instruction = T_OPCODE_LSL_I;
12196             inst.instruction |= Rn;
12197             inst.instruction |= Rm << 3;
12198             break;
12199
12200           case T_MNEM_cmp:
12201             if (low_regs)
12202               {
12203                 inst.instruction = T_OPCODE_CMP_LR;
12204                 inst.instruction |= Rn;
12205                 inst.instruction |= Rm << 3;
12206               }
12207             else
12208               {
12209                 inst.instruction = T_OPCODE_CMP_HR;
12210                 inst.instruction |= (Rn & 0x8) << 4;
12211                 inst.instruction |= (Rn & 0x7);
12212                 inst.instruction |= Rm << 3;
12213               }
12214             break;
12215           }
12216       return;
12217     }
12218
12219   inst.instruction = THUMB_OP16 (inst.instruction);
12220
12221   /* PR 10443: Do not silently ignore shifted operands.  */
12222   constraint (inst.operands[1].shifted,
12223               _("shifts in CMP/MOV instructions are only supported in unified syntax"));
12224
12225   if (inst.operands[1].isreg)
12226     {
12227       if (Rn < 8 && Rm < 8)
12228         {
12229           /* A move of two lowregs is encoded as ADD Rd, Rs, #0
12230              since a MOV instruction produces unpredictable results.  */
12231           if (inst.instruction == T_OPCODE_MOV_I8)
12232             inst.instruction = T_OPCODE_ADD_I3;
12233           else
12234             inst.instruction = T_OPCODE_CMP_LR;
12235
12236           inst.instruction |= Rn;
12237           inst.instruction |= Rm << 3;
12238         }
12239       else
12240         {
12241           if (inst.instruction == T_OPCODE_MOV_I8)
12242             inst.instruction = T_OPCODE_MOV_HR;
12243           else
12244             inst.instruction = T_OPCODE_CMP_HR;
12245           do_t_cpy ();
12246         }
12247     }
12248   else
12249     {
12250       constraint (Rn > 7,
12251                   _("only lo regs allowed with immediate"));
12252       inst.instruction |= Rn << 8;
12253       inst.relocs[0].type = BFD_RELOC_ARM_THUMB_IMM;
12254     }
12255 }
12256
12257 static void
12258 do_t_mov16 (void)
12259 {
12260   unsigned Rd;
12261   bfd_vma imm;
12262   bfd_boolean top;
12263
12264   top = (inst.instruction & 0x00800000) != 0;
12265   if (inst.relocs[0].type == BFD_RELOC_ARM_MOVW)
12266     {
12267       constraint (top, _(":lower16: not allowed in this instruction"));
12268       inst.relocs[0].type = BFD_RELOC_ARM_THUMB_MOVW;
12269     }
12270   else if (inst.relocs[0].type == BFD_RELOC_ARM_MOVT)
12271     {
12272       constraint (!top, _(":upper16: not allowed in this instruction"));
12273       inst.relocs[0].type = BFD_RELOC_ARM_THUMB_MOVT;
12274     }
12275
12276   Rd = inst.operands[0].reg;
12277   reject_bad_reg (Rd);
12278
12279   inst.instruction |= Rd << 8;
12280   if (inst.relocs[0].type == BFD_RELOC_UNUSED)
12281     {
12282       imm = inst.relocs[0].exp.X_add_number;
12283       inst.instruction |= (imm & 0xf000) << 4;
12284       inst.instruction |= (imm & 0x0800) << 15;
12285       inst.instruction |= (imm & 0x0700) << 4;
12286       inst.instruction |= (imm & 0x00ff);
12287     }
12288 }
12289
12290 static void
12291 do_t_mvn_tst (void)
12292 {
12293   unsigned Rn, Rm;
12294
12295   Rn = inst.operands[0].reg;
12296   Rm = inst.operands[1].reg;
12297
12298   if (inst.instruction == T_MNEM_cmp
12299       || inst.instruction == T_MNEM_cmn)
12300     constraint (Rn == REG_PC, BAD_PC);
12301   else
12302     reject_bad_reg (Rn);
12303   reject_bad_reg (Rm);
12304
12305   if (unified_syntax)
12306     {
12307       int r0off = (inst.instruction == T_MNEM_mvn
12308                    || inst.instruction == T_MNEM_mvns) ? 8 : 16;
12309       bfd_boolean narrow;
12310
12311       if (inst.size_req == 4
12312           || inst.instruction > 0xffff
12313           || inst.operands[1].shifted
12314           || Rn > 7 || Rm > 7)
12315         narrow = FALSE;
12316       else if (inst.instruction == T_MNEM_cmn
12317                || inst.instruction == T_MNEM_tst)
12318         narrow = TRUE;
12319       else if (THUMB_SETS_FLAGS (inst.instruction))
12320         narrow = !in_it_block ();
12321       else
12322         narrow = in_it_block ();
12323
12324       if (!inst.operands[1].isreg)
12325         {
12326           /* For an immediate, we always generate a 32-bit opcode;
12327              section relaxation will shrink it later if possible.  */
12328           if (inst.instruction < 0xffff)
12329             inst.instruction = THUMB_OP32 (inst.instruction);
12330           inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
12331           inst.instruction |= Rn << r0off;
12332           inst.relocs[0].type = BFD_RELOC_ARM_T32_IMMEDIATE;
12333         }
12334       else
12335         {
12336           /* See if we can do this with a 16-bit instruction.  */
12337           if (narrow)
12338             {
12339               inst.instruction = THUMB_OP16 (inst.instruction);
12340               inst.instruction |= Rn;
12341               inst.instruction |= Rm << 3;
12342             }
12343           else
12344             {
12345               constraint (inst.operands[1].shifted
12346                           && inst.operands[1].immisreg,
12347                           _("shift must be constant"));
12348               if (inst.instruction < 0xffff)
12349                 inst.instruction = THUMB_OP32 (inst.instruction);
12350               inst.instruction |= Rn << r0off;
12351               encode_thumb32_shifted_operand (1);
12352             }
12353         }
12354     }
12355   else
12356     {
12357       constraint (inst.instruction > 0xffff
12358                   || inst.instruction == T_MNEM_mvns, BAD_THUMB32);
12359       constraint (!inst.operands[1].isreg || inst.operands[1].shifted,
12360                   _("unshifted register required"));
12361       constraint (Rn > 7 || Rm > 7,
12362                   BAD_HIREG);
12363
12364       inst.instruction = THUMB_OP16 (inst.instruction);
12365       inst.instruction |= Rn;
12366       inst.instruction |= Rm << 3;
12367     }
12368 }
12369
12370 static void
12371 do_t_mrs (void)
12372 {
12373   unsigned Rd;
12374
12375   if (do_vfp_nsyn_mrs () == SUCCESS)
12376     return;
12377
12378   Rd = inst.operands[0].reg;
12379   reject_bad_reg (Rd);
12380   inst.instruction |= Rd << 8;
12381
12382   if (inst.operands[1].isreg)
12383     {
12384       unsigned br = inst.operands[1].reg;
12385       if (((br & 0x200) == 0) && ((br & 0xf000) != 0xf000))
12386         as_bad (_("bad register for mrs"));
12387
12388       inst.instruction |= br & (0xf << 16);
12389       inst.instruction |= (br & 0x300) >> 4;
12390       inst.instruction |= (br & SPSR_BIT) >> 2;
12391     }
12392   else
12393     {
12394       int flags = inst.operands[1].imm & (PSR_c|PSR_x|PSR_s|PSR_f|SPSR_BIT);
12395
12396       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_m))
12397         {
12398           /* PR gas/12698:  The constraint is only applied for m_profile.
12399              If the user has specified -march=all, we want to ignore it as
12400              we are building for any CPU type, including non-m variants.  */
12401           bfd_boolean m_profile =
12402             !ARM_FEATURE_CORE_EQUAL (selected_cpu, arm_arch_any);
12403           constraint ((flags != 0) && m_profile, _("selected processor does "
12404                                                    "not support requested special purpose register"));
12405         }
12406       else
12407         /* mrs only accepts APSR/CPSR/SPSR/CPSR_all/SPSR_all (for non-M profile
12408            devices).  */
12409         constraint ((flags & ~SPSR_BIT) != (PSR_c|PSR_f),
12410                     _("'APSR', 'CPSR' or 'SPSR' expected"));
12411
12412       inst.instruction |= (flags & SPSR_BIT) >> 2;
12413       inst.instruction |= inst.operands[1].imm & 0xff;
12414       inst.instruction |= 0xf0000;
12415     }
12416 }
12417
12418 static void
12419 do_t_msr (void)
12420 {
12421   int flags;
12422   unsigned Rn;
12423
12424   if (do_vfp_nsyn_msr () == SUCCESS)
12425     return;
12426
12427   constraint (!inst.operands[1].isreg,
12428               _("Thumb encoding does not support an immediate here"));
12429
12430   if (inst.operands[0].isreg)
12431     flags = (int)(inst.operands[0].reg);
12432   else
12433     flags = inst.operands[0].imm;
12434
12435   if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_m))
12436     {
12437       int bits = inst.operands[0].imm & (PSR_c|PSR_x|PSR_s|PSR_f|SPSR_BIT);
12438
12439       /* PR gas/12698:  The constraint is only applied for m_profile.
12440          If the user has specified -march=all, we want to ignore it as
12441          we are building for any CPU type, including non-m variants.  */
12442       bfd_boolean m_profile =
12443         !ARM_FEATURE_CORE_EQUAL (selected_cpu, arm_arch_any);
12444       constraint (((ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6_dsp)
12445            && (bits & ~(PSR_s | PSR_f)) != 0)
12446           || (!ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6_dsp)
12447               && bits != PSR_f)) && m_profile,
12448           _("selected processor does not support requested special "
12449             "purpose register"));
12450     }
12451   else
12452      constraint ((flags & 0xff) != 0, _("selected processor does not support "
12453                  "requested special purpose register"));
12454
12455   Rn = inst.operands[1].reg;
12456   reject_bad_reg (Rn);
12457
12458   inst.instruction |= (flags & SPSR_BIT) >> 2;
12459   inst.instruction |= (flags & 0xf0000) >> 8;
12460   inst.instruction |= (flags & 0x300) >> 4;
12461   inst.instruction |= (flags & 0xff);
12462   inst.instruction |= Rn << 16;
12463 }
12464
12465 static void
12466 do_t_mul (void)
12467 {
12468   bfd_boolean narrow;
12469   unsigned Rd, Rn, Rm;
12470
12471   if (!inst.operands[2].present)
12472     inst.operands[2].reg = inst.operands[0].reg;
12473
12474   Rd = inst.operands[0].reg;
12475   Rn = inst.operands[1].reg;
12476   Rm = inst.operands[2].reg;
12477
12478   if (unified_syntax)
12479     {
12480       if (inst.size_req == 4
12481           || (Rd != Rn
12482               && Rd != Rm)
12483           || Rn > 7
12484           || Rm > 7)
12485         narrow = FALSE;
12486       else if (inst.instruction == T_MNEM_muls)
12487         narrow = !in_it_block ();
12488       else
12489         narrow = in_it_block ();
12490     }
12491   else
12492     {
12493       constraint (inst.instruction == T_MNEM_muls, BAD_THUMB32);
12494       constraint (Rn > 7 || Rm > 7,
12495                   BAD_HIREG);
12496       narrow = TRUE;
12497     }
12498
12499   if (narrow)
12500     {
12501       /* 16-bit MULS/Conditional MUL.  */
12502       inst.instruction = THUMB_OP16 (inst.instruction);
12503       inst.instruction |= Rd;
12504
12505       if (Rd == Rn)
12506         inst.instruction |= Rm << 3;
12507       else if (Rd == Rm)
12508         inst.instruction |= Rn << 3;
12509       else
12510         constraint (1, _("dest must overlap one source register"));
12511     }
12512   else
12513     {
12514       constraint (inst.instruction != T_MNEM_mul,
12515                   _("Thumb-2 MUL must not set flags"));
12516       /* 32-bit MUL.  */
12517       inst.instruction = THUMB_OP32 (inst.instruction);
12518       inst.instruction |= Rd << 8;
12519       inst.instruction |= Rn << 16;
12520       inst.instruction |= Rm << 0;
12521
12522       reject_bad_reg (Rd);
12523       reject_bad_reg (Rn);
12524       reject_bad_reg (Rm);
12525     }
12526 }
12527
12528 static void
12529 do_t_mull (void)
12530 {
12531   unsigned RdLo, RdHi, Rn, Rm;
12532
12533   RdLo = inst.operands[0].reg;
12534   RdHi = inst.operands[1].reg;
12535   Rn = inst.operands[2].reg;
12536   Rm = inst.operands[3].reg;
12537
12538   reject_bad_reg (RdLo);
12539   reject_bad_reg (RdHi);
12540   reject_bad_reg (Rn);
12541   reject_bad_reg (Rm);
12542
12543   inst.instruction |= RdLo << 12;
12544   inst.instruction |= RdHi << 8;
12545   inst.instruction |= Rn << 16;
12546   inst.instruction |= Rm;
12547
12548  if (RdLo == RdHi)
12549     as_tsktsk (_("rdhi and rdlo must be different"));
12550 }
12551
12552 static void
12553 do_t_nop (void)
12554 {
12555   set_it_insn_type (NEUTRAL_IT_INSN);
12556
12557   if (unified_syntax)
12558     {
12559       if (inst.size_req == 4 || inst.operands[0].imm > 15)
12560         {
12561           inst.instruction = THUMB_OP32 (inst.instruction);
12562           inst.instruction |= inst.operands[0].imm;
12563         }
12564       else
12565         {
12566           /* PR9722: Check for Thumb2 availability before
12567              generating a thumb2 nop instruction.  */
12568           if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6t2))
12569             {
12570               inst.instruction = THUMB_OP16 (inst.instruction);
12571               inst.instruction |= inst.operands[0].imm << 4;
12572             }
12573           else
12574             inst.instruction = 0x46c0;
12575         }
12576     }
12577   else
12578     {
12579       constraint (inst.operands[0].present,
12580                   _("Thumb does not support NOP with hints"));
12581       inst.instruction = 0x46c0;
12582     }
12583 }
12584
12585 static void
12586 do_t_neg (void)
12587 {
12588   if (unified_syntax)
12589     {
12590       bfd_boolean narrow;
12591
12592       if (THUMB_SETS_FLAGS (inst.instruction))
12593         narrow = !in_it_block ();
12594       else
12595         narrow = in_it_block ();
12596       if (inst.operands[0].reg > 7 || inst.operands[1].reg > 7)
12597         narrow = FALSE;
12598       if (inst.size_req == 4)
12599         narrow = FALSE;
12600
12601       if (!narrow)
12602         {
12603           inst.instruction = THUMB_OP32 (inst.instruction);
12604           inst.instruction |= inst.operands[0].reg << 8;
12605           inst.instruction |= inst.operands[1].reg << 16;
12606         }
12607       else
12608         {
12609           inst.instruction = THUMB_OP16 (inst.instruction);
12610           inst.instruction |= inst.operands[0].reg;
12611           inst.instruction |= inst.operands[1].reg << 3;
12612         }
12613     }
12614   else
12615     {
12616       constraint (inst.operands[0].reg > 7 || inst.operands[1].reg > 7,
12617                   BAD_HIREG);
12618       constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
12619
12620       inst.instruction = THUMB_OP16 (inst.instruction);
12621       inst.instruction |= inst.operands[0].reg;
12622       inst.instruction |= inst.operands[1].reg << 3;
12623     }
12624 }
12625
12626 static void
12627 do_t_orn (void)
12628 {
12629   unsigned Rd, Rn;
12630
12631   Rd = inst.operands[0].reg;
12632   Rn = inst.operands[1].present ? inst.operands[1].reg : Rd;
12633
12634   reject_bad_reg (Rd);
12635   /* Rn == REG_SP is unpredictable; Rn == REG_PC is MVN.  */
12636   reject_bad_reg (Rn);
12637
12638   inst.instruction |= Rd << 8;
12639   inst.instruction |= Rn << 16;
12640
12641   if (!inst.operands[2].isreg)
12642     {
12643       inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
12644       inst.relocs[0].type = BFD_RELOC_ARM_T32_IMMEDIATE;
12645     }
12646   else
12647     {
12648       unsigned Rm;
12649
12650       Rm = inst.operands[2].reg;
12651       reject_bad_reg (Rm);
12652
12653       constraint (inst.operands[2].shifted
12654                   && inst.operands[2].immisreg,
12655                   _("shift must be constant"));
12656       encode_thumb32_shifted_operand (2);
12657     }
12658 }
12659
12660 static void
12661 do_t_pkhbt (void)
12662 {
12663   unsigned Rd, Rn, Rm;
12664
12665   Rd = inst.operands[0].reg;
12666   Rn = inst.operands[1].reg;
12667   Rm = inst.operands[2].reg;
12668
12669   reject_bad_reg (Rd);
12670   reject_bad_reg (Rn);
12671   reject_bad_reg (Rm);
12672
12673   inst.instruction |= Rd << 8;
12674   inst.instruction |= Rn << 16;
12675   inst.instruction |= Rm;
12676   if (inst.operands[3].present)
12677     {
12678       unsigned int val = inst.relocs[0].exp.X_add_number;
12679       constraint (inst.relocs[0].exp.X_op != O_constant,
12680                   _("expression too complex"));
12681       inst.instruction |= (val & 0x1c) << 10;
12682       inst.instruction |= (val & 0x03) << 6;
12683     }
12684 }
12685
12686 static void
12687 do_t_pkhtb (void)
12688 {
12689   if (!inst.operands[3].present)
12690     {
12691       unsigned Rtmp;
12692
12693       inst.instruction &= ~0x00000020;
12694
12695       /* PR 10168.  Swap the Rm and Rn registers.  */
12696       Rtmp = inst.operands[1].reg;
12697       inst.operands[1].reg = inst.operands[2].reg;
12698       inst.operands[2].reg = Rtmp;
12699     }
12700   do_t_pkhbt ();
12701 }
12702
12703 static void
12704 do_t_pld (void)
12705 {
12706   if (inst.operands[0].immisreg)
12707     reject_bad_reg (inst.operands[0].imm);
12708
12709   encode_thumb32_addr_mode (0, /*is_t=*/FALSE, /*is_d=*/FALSE);
12710 }
12711
12712 static void
12713 do_t_push_pop (void)
12714 {
12715   unsigned mask;
12716
12717   constraint (inst.operands[0].writeback,
12718               _("push/pop do not support {reglist}^"));
12719   constraint (inst.relocs[0].type != BFD_RELOC_UNUSED,
12720               _("expression too complex"));
12721
12722   mask = inst.operands[0].imm;
12723   if (inst.size_req != 4 && (mask & ~0xff) == 0)
12724     inst.instruction = THUMB_OP16 (inst.instruction) | mask;
12725   else if (inst.size_req != 4
12726            && (mask & ~0xff) == (1U << (inst.instruction == T_MNEM_push
12727                                        ? REG_LR : REG_PC)))
12728     {
12729       inst.instruction = THUMB_OP16 (inst.instruction);
12730       inst.instruction |= THUMB_PP_PC_LR;
12731       inst.instruction |= mask & 0xff;
12732     }
12733   else if (unified_syntax)
12734     {
12735       inst.instruction = THUMB_OP32 (inst.instruction);
12736       encode_thumb2_ldmstm (13, mask, TRUE);
12737     }
12738   else
12739     {
12740       inst.error = _("invalid register list to push/pop instruction");
12741       return;
12742     }
12743 }
12744
12745 static void
12746 do_t_rbit (void)
12747 {
12748   unsigned Rd, Rm;
12749
12750   Rd = inst.operands[0].reg;
12751   Rm = inst.operands[1].reg;
12752
12753   reject_bad_reg (Rd);
12754   reject_bad_reg (Rm);
12755
12756   inst.instruction |= Rd << 8;
12757   inst.instruction |= Rm << 16;
12758   inst.instruction |= Rm;
12759 }
12760
12761 static void
12762 do_t_rev (void)
12763 {
12764   unsigned Rd, Rm;
12765
12766   Rd = inst.operands[0].reg;
12767   Rm = inst.operands[1].reg;
12768
12769   reject_bad_reg (Rd);
12770   reject_bad_reg (Rm);
12771
12772   if (Rd <= 7 && Rm <= 7
12773       && inst.size_req != 4)
12774     {
12775       inst.instruction = THUMB_OP16 (inst.instruction);
12776       inst.instruction |= Rd;
12777       inst.instruction |= Rm << 3;
12778     }
12779   else if (unified_syntax)
12780     {
12781       inst.instruction = THUMB_OP32 (inst.instruction);
12782       inst.instruction |= Rd << 8;
12783       inst.instruction |= Rm << 16;
12784       inst.instruction |= Rm;
12785     }
12786   else
12787     inst.error = BAD_HIREG;
12788 }
12789
12790 static void
12791 do_t_rrx (void)
12792 {
12793   unsigned Rd, Rm;
12794
12795   Rd = inst.operands[0].reg;
12796   Rm = inst.operands[1].reg;
12797
12798   reject_bad_reg (Rd);
12799   reject_bad_reg (Rm);
12800
12801   inst.instruction |= Rd << 8;
12802   inst.instruction |= Rm;
12803 }
12804
12805 static void
12806 do_t_rsb (void)
12807 {
12808   unsigned Rd, Rs;
12809
12810   Rd = inst.operands[0].reg;
12811   Rs = (inst.operands[1].present
12812         ? inst.operands[1].reg    /* Rd, Rs, foo */
12813         : inst.operands[0].reg);  /* Rd, foo -> Rd, Rd, foo */
12814
12815   reject_bad_reg (Rd);
12816   reject_bad_reg (Rs);
12817   if (inst.operands[2].isreg)
12818     reject_bad_reg (inst.operands[2].reg);
12819
12820   inst.instruction |= Rd << 8;
12821   inst.instruction |= Rs << 16;
12822   if (!inst.operands[2].isreg)
12823     {
12824       bfd_boolean narrow;
12825
12826       if ((inst.instruction & 0x00100000) != 0)
12827         narrow = !in_it_block ();
12828       else
12829         narrow = in_it_block ();
12830
12831       if (Rd > 7 || Rs > 7)
12832         narrow = FALSE;
12833
12834       if (inst.size_req == 4 || !unified_syntax)
12835         narrow = FALSE;
12836
12837       if (inst.relocs[0].exp.X_op != O_constant
12838           || inst.relocs[0].exp.X_add_number != 0)
12839         narrow = FALSE;
12840
12841       /* Turn rsb #0 into 16-bit neg.  We should probably do this via
12842          relaxation, but it doesn't seem worth the hassle.  */
12843       if (narrow)
12844         {
12845           inst.relocs[0].type = BFD_RELOC_UNUSED;
12846           inst.instruction = THUMB_OP16 (T_MNEM_negs);
12847           inst.instruction |= Rs << 3;
12848           inst.instruction |= Rd;
12849         }
12850       else
12851         {
12852           inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
12853           inst.relocs[0].type = BFD_RELOC_ARM_T32_IMMEDIATE;
12854         }
12855     }
12856   else
12857     encode_thumb32_shifted_operand (2);
12858 }
12859
12860 static void
12861 do_t_setend (void)
12862 {
12863   if (warn_on_deprecated
12864       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
12865       as_tsktsk (_("setend use is deprecated for ARMv8"));
12866
12867   set_it_insn_type (OUTSIDE_IT_INSN);
12868   if (inst.operands[0].imm)
12869     inst.instruction |= 0x8;
12870 }
12871
12872 static void
12873 do_t_shift (void)
12874 {
12875   if (!inst.operands[1].present)
12876     inst.operands[1].reg = inst.operands[0].reg;
12877
12878   if (unified_syntax)
12879     {
12880       bfd_boolean narrow;
12881       int shift_kind;
12882
12883       switch (inst.instruction)
12884         {
12885         case T_MNEM_asr:
12886         case T_MNEM_asrs: shift_kind = SHIFT_ASR; break;
12887         case T_MNEM_lsl:
12888         case T_MNEM_lsls: shift_kind = SHIFT_LSL; break;
12889         case T_MNEM_lsr:
12890         case T_MNEM_lsrs: shift_kind = SHIFT_LSR; break;
12891         case T_MNEM_ror:
12892         case T_MNEM_rors: shift_kind = SHIFT_ROR; break;
12893         default: abort ();
12894         }
12895
12896       if (THUMB_SETS_FLAGS (inst.instruction))
12897         narrow = !in_it_block ();
12898       else
12899         narrow = in_it_block ();
12900       if (inst.operands[0].reg > 7 || inst.operands[1].reg > 7)
12901         narrow = FALSE;
12902       if (!inst.operands[2].isreg && shift_kind == SHIFT_ROR)
12903         narrow = FALSE;
12904       if (inst.operands[2].isreg
12905           && (inst.operands[1].reg != inst.operands[0].reg
12906               || inst.operands[2].reg > 7))
12907         narrow = FALSE;
12908       if (inst.size_req == 4)
12909         narrow = FALSE;
12910
12911       reject_bad_reg (inst.operands[0].reg);
12912       reject_bad_reg (inst.operands[1].reg);
12913
12914       if (!narrow)
12915         {
12916           if (inst.operands[2].isreg)
12917             {
12918               reject_bad_reg (inst.operands[2].reg);
12919               inst.instruction = THUMB_OP32 (inst.instruction);
12920               inst.instruction |= inst.operands[0].reg << 8;
12921               inst.instruction |= inst.operands[1].reg << 16;
12922               inst.instruction |= inst.operands[2].reg;
12923
12924               /* PR 12854: Error on extraneous shifts.  */
12925               constraint (inst.operands[2].shifted,
12926                           _("extraneous shift as part of operand to shift insn"));
12927             }
12928           else
12929             {
12930               inst.operands[1].shifted = 1;
12931               inst.operands[1].shift_kind = shift_kind;
12932               inst.instruction = THUMB_OP32 (THUMB_SETS_FLAGS (inst.instruction)
12933                                              ? T_MNEM_movs : T_MNEM_mov);
12934               inst.instruction |= inst.operands[0].reg << 8;
12935               encode_thumb32_shifted_operand (1);
12936               /* Prevent the incorrect generation of an ARM_IMMEDIATE fixup.  */
12937               inst.relocs[0].type = BFD_RELOC_UNUSED;
12938             }
12939         }
12940       else
12941         {
12942           if (inst.operands[2].isreg)
12943             {
12944               switch (shift_kind)
12945                 {
12946                 case SHIFT_ASR: inst.instruction = T_OPCODE_ASR_R; break;
12947                 case SHIFT_LSL: inst.instruction = T_OPCODE_LSL_R; break;
12948                 case SHIFT_LSR: inst.instruction = T_OPCODE_LSR_R; break;
12949                 case SHIFT_ROR: inst.instruction = T_OPCODE_ROR_R; break;
12950                 default: abort ();
12951                 }
12952
12953               inst.instruction |= inst.operands[0].reg;
12954               inst.instruction |= inst.operands[2].reg << 3;
12955
12956               /* PR 12854: Error on extraneous shifts.  */
12957               constraint (inst.operands[2].shifted,
12958                           _("extraneous shift as part of operand to shift insn"));
12959             }
12960           else
12961             {
12962               switch (shift_kind)
12963                 {
12964                 case SHIFT_ASR: inst.instruction = T_OPCODE_ASR_I; break;
12965                 case SHIFT_LSL: inst.instruction = T_OPCODE_LSL_I; break;
12966                 case SHIFT_LSR: inst.instruction = T_OPCODE_LSR_I; break;
12967                 default: abort ();
12968                 }
12969               inst.relocs[0].type = BFD_RELOC_ARM_THUMB_SHIFT;
12970               inst.instruction |= inst.operands[0].reg;
12971               inst.instruction |= inst.operands[1].reg << 3;
12972             }
12973         }
12974     }
12975   else
12976     {
12977       constraint (inst.operands[0].reg > 7
12978                   || inst.operands[1].reg > 7, BAD_HIREG);
12979       constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
12980
12981       if (inst.operands[2].isreg)  /* Rd, {Rs,} Rn */
12982         {
12983           constraint (inst.operands[2].reg > 7, BAD_HIREG);
12984           constraint (inst.operands[0].reg != inst.operands[1].reg,
12985                       _("source1 and dest must be same register"));
12986
12987           switch (inst.instruction)
12988             {
12989             case T_MNEM_asr: inst.instruction = T_OPCODE_ASR_R; break;
12990             case T_MNEM_lsl: inst.instruction = T_OPCODE_LSL_R; break;
12991             case T_MNEM_lsr: inst.instruction = T_OPCODE_LSR_R; break;
12992             case T_MNEM_ror: inst.instruction = T_OPCODE_ROR_R; break;
12993             default: abort ();
12994             }
12995
12996           inst.instruction |= inst.operands[0].reg;
12997           inst.instruction |= inst.operands[2].reg << 3;
12998
12999           /* PR 12854: Error on extraneous shifts.  */
13000           constraint (inst.operands[2].shifted,
13001                       _("extraneous shift as part of operand to shift insn"));
13002         }
13003       else
13004         {
13005           switch (inst.instruction)
13006             {
13007             case T_MNEM_asr: inst.instruction = T_OPCODE_ASR_I; break;
13008             case T_MNEM_lsl: inst.instruction = T_OPCODE_LSL_I; break;
13009             case T_MNEM_lsr: inst.instruction = T_OPCODE_LSR_I; break;
13010             case T_MNEM_ror: inst.error = _("ror #imm not supported"); return;
13011             default: abort ();
13012             }
13013           inst.relocs[0].type = BFD_RELOC_ARM_THUMB_SHIFT;
13014           inst.instruction |= inst.operands[0].reg;
13015           inst.instruction |= inst.operands[1].reg << 3;
13016         }
13017     }
13018 }
13019
13020 static void
13021 do_t_simd (void)
13022 {
13023   unsigned Rd, Rn, Rm;
13024
13025   Rd = inst.operands[0].reg;
13026   Rn = inst.operands[1].reg;
13027   Rm = inst.operands[2].reg;
13028
13029   reject_bad_reg (Rd);
13030   reject_bad_reg (Rn);
13031   reject_bad_reg (Rm);
13032
13033   inst.instruction |= Rd << 8;
13034   inst.instruction |= Rn << 16;
13035   inst.instruction |= Rm;
13036 }
13037
13038 static void
13039 do_t_simd2 (void)
13040 {
13041   unsigned Rd, Rn, Rm;
13042
13043   Rd = inst.operands[0].reg;
13044   Rm = inst.operands[1].reg;
13045   Rn = inst.operands[2].reg;
13046
13047   reject_bad_reg (Rd);
13048   reject_bad_reg (Rn);
13049   reject_bad_reg (Rm);
13050
13051   inst.instruction |= Rd << 8;
13052   inst.instruction |= Rn << 16;
13053   inst.instruction |= Rm;
13054 }
13055
13056 static void
13057 do_t_smc (void)
13058 {
13059   unsigned int value = inst.relocs[0].exp.X_add_number;
13060   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7a),
13061               _("SMC is not permitted on this architecture"));
13062   constraint (inst.relocs[0].exp.X_op != O_constant,
13063               _("expression too complex"));
13064   inst.relocs[0].type = BFD_RELOC_UNUSED;
13065   inst.instruction |= (value & 0xf000) >> 12;
13066   inst.instruction |= (value & 0x0ff0);
13067   inst.instruction |= (value & 0x000f) << 16;
13068   /* PR gas/15623: SMC instructions must be last in an IT block.  */
13069   set_it_insn_type_last ();
13070 }
13071
13072 static void
13073 do_t_hvc (void)
13074 {
13075   unsigned int value = inst.relocs[0].exp.X_add_number;
13076
13077   inst.relocs[0].type = BFD_RELOC_UNUSED;
13078   inst.instruction |= (value & 0x0fff);
13079   inst.instruction |= (value & 0xf000) << 4;
13080 }
13081
13082 static void
13083 do_t_ssat_usat (int bias)
13084 {
13085   unsigned Rd, Rn;
13086
13087   Rd = inst.operands[0].reg;
13088   Rn = inst.operands[2].reg;
13089
13090   reject_bad_reg (Rd);
13091   reject_bad_reg (Rn);
13092
13093   inst.instruction |= Rd << 8;
13094   inst.instruction |= inst.operands[1].imm - bias;
13095   inst.instruction |= Rn << 16;
13096
13097   if (inst.operands[3].present)
13098     {
13099       offsetT shift_amount = inst.relocs[0].exp.X_add_number;
13100
13101       inst.relocs[0].type = BFD_RELOC_UNUSED;
13102
13103       constraint (inst.relocs[0].exp.X_op != O_constant,
13104                   _("expression too complex"));
13105
13106       if (shift_amount != 0)
13107         {
13108           constraint (shift_amount > 31,
13109                       _("shift expression is too large"));
13110
13111           if (inst.operands[3].shift_kind == SHIFT_ASR)
13112             inst.instruction |= 0x00200000;  /* sh bit.  */
13113
13114           inst.instruction |= (shift_amount & 0x1c) << 10;
13115           inst.instruction |= (shift_amount & 0x03) << 6;
13116         }
13117     }
13118 }
13119
13120 static void
13121 do_t_ssat (void)
13122 {
13123   do_t_ssat_usat (1);
13124 }
13125
13126 static void
13127 do_t_ssat16 (void)
13128 {
13129   unsigned Rd, Rn;
13130
13131   Rd = inst.operands[0].reg;
13132   Rn = inst.operands[2].reg;
13133
13134   reject_bad_reg (Rd);
13135   reject_bad_reg (Rn);
13136
13137   inst.instruction |= Rd << 8;
13138   inst.instruction |= inst.operands[1].imm - 1;
13139   inst.instruction |= Rn << 16;
13140 }
13141
13142 static void
13143 do_t_strex (void)
13144 {
13145   constraint (!inst.operands[2].isreg || !inst.operands[2].preind
13146               || inst.operands[2].postind || inst.operands[2].writeback
13147               || inst.operands[2].immisreg || inst.operands[2].shifted
13148               || inst.operands[2].negative,
13149               BAD_ADDR_MODE);
13150
13151   constraint (inst.operands[2].reg == REG_PC, BAD_PC);
13152
13153   inst.instruction |= inst.operands[0].reg << 8;
13154   inst.instruction |= inst.operands[1].reg << 12;
13155   inst.instruction |= inst.operands[2].reg << 16;
13156   inst.relocs[0].type = BFD_RELOC_ARM_T32_OFFSET_U8;
13157 }
13158
13159 static void
13160 do_t_strexd (void)
13161 {
13162   if (!inst.operands[2].present)
13163     inst.operands[2].reg = inst.operands[1].reg + 1;
13164
13165   constraint (inst.operands[0].reg == inst.operands[1].reg
13166               || inst.operands[0].reg == inst.operands[2].reg
13167               || inst.operands[0].reg == inst.operands[3].reg,
13168               BAD_OVERLAP);
13169
13170   inst.instruction |= inst.operands[0].reg;
13171   inst.instruction |= inst.operands[1].reg << 12;
13172   inst.instruction |= inst.operands[2].reg << 8;
13173   inst.instruction |= inst.operands[3].reg << 16;
13174 }
13175
13176 static void
13177 do_t_sxtah (void)
13178 {
13179   unsigned Rd, Rn, Rm;
13180
13181   Rd = inst.operands[0].reg;
13182   Rn = inst.operands[1].reg;
13183   Rm = inst.operands[2].reg;
13184
13185   reject_bad_reg (Rd);
13186   reject_bad_reg (Rn);
13187   reject_bad_reg (Rm);
13188
13189   inst.instruction |= Rd << 8;
13190   inst.instruction |= Rn << 16;
13191   inst.instruction |= Rm;
13192   inst.instruction |= inst.operands[3].imm << 4;
13193 }
13194
13195 static void
13196 do_t_sxth (void)
13197 {
13198   unsigned Rd, Rm;
13199
13200   Rd = inst.operands[0].reg;
13201   Rm = inst.operands[1].reg;
13202
13203   reject_bad_reg (Rd);
13204   reject_bad_reg (Rm);
13205
13206   if (inst.instruction <= 0xffff
13207       && inst.size_req != 4
13208       && Rd <= 7 && Rm <= 7
13209       && (!inst.operands[2].present || inst.operands[2].imm == 0))
13210     {
13211       inst.instruction = THUMB_OP16 (inst.instruction);
13212       inst.instruction |= Rd;
13213       inst.instruction |= Rm << 3;
13214     }
13215   else if (unified_syntax)
13216     {
13217       if (inst.instruction <= 0xffff)
13218         inst.instruction = THUMB_OP32 (inst.instruction);
13219       inst.instruction |= Rd << 8;
13220       inst.instruction |= Rm;
13221       inst.instruction |= inst.operands[2].imm << 4;
13222     }
13223   else
13224     {
13225       constraint (inst.operands[2].present && inst.operands[2].imm != 0,
13226                   _("Thumb encoding does not support rotation"));
13227       constraint (1, BAD_HIREG);
13228     }
13229 }
13230
13231 static void
13232 do_t_swi (void)
13233 {
13234   inst.relocs[0].type = BFD_RELOC_ARM_SWI;
13235 }
13236
13237 static void
13238 do_t_tb (void)
13239 {
13240   unsigned Rn, Rm;
13241   int half;
13242
13243   half = (inst.instruction & 0x10) != 0;
13244   set_it_insn_type_last ();
13245   constraint (inst.operands[0].immisreg,
13246               _("instruction requires register index"));
13247
13248   Rn = inst.operands[0].reg;
13249   Rm = inst.operands[0].imm;
13250
13251   if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
13252     constraint (Rn == REG_SP, BAD_SP);
13253   reject_bad_reg (Rm);
13254
13255   constraint (!half && inst.operands[0].shifted,
13256               _("instruction does not allow shifted index"));
13257   inst.instruction |= (Rn << 16) | Rm;
13258 }
13259
13260 static void
13261 do_t_udf (void)
13262 {
13263   if (!inst.operands[0].present)
13264     inst.operands[0].imm = 0;
13265
13266   if ((unsigned int) inst.operands[0].imm > 255 || inst.size_req == 4)
13267     {
13268       constraint (inst.size_req == 2,
13269                   _("immediate value out of range"));
13270       inst.instruction = THUMB_OP32 (inst.instruction);
13271       inst.instruction |= (inst.operands[0].imm & 0xf000u) << 4;
13272       inst.instruction |= (inst.operands[0].imm & 0x0fffu) << 0;
13273     }
13274   else
13275     {
13276       inst.instruction = THUMB_OP16 (inst.instruction);
13277       inst.instruction |= inst.operands[0].imm;
13278     }
13279
13280   set_it_insn_type (NEUTRAL_IT_INSN);
13281 }
13282
13283
13284 static void
13285 do_t_usat (void)
13286 {
13287   do_t_ssat_usat (0);
13288 }
13289
13290 static void
13291 do_t_usat16 (void)
13292 {
13293   unsigned Rd, Rn;
13294
13295   Rd = inst.operands[0].reg;
13296   Rn = inst.operands[2].reg;
13297
13298   reject_bad_reg (Rd);
13299   reject_bad_reg (Rn);
13300
13301   inst.instruction |= Rd << 8;
13302   inst.instruction |= inst.operands[1].imm;
13303   inst.instruction |= Rn << 16;
13304 }
13305
13306 /* Checking the range of the branch offset (VAL) with NBITS bits
13307    and IS_SIGNED signedness.  Also checks the LSB to be 0.  */
13308 static int
13309 v8_1_branch_value_check (int val, int nbits, int is_signed)
13310 {
13311   gas_assert (nbits > 0 && nbits <= 32);
13312   if (is_signed)
13313     {
13314       int cmp = (1 << (nbits - 1));
13315       if ((val < -cmp) || (val >= cmp) || (val & 0x01))
13316         return FAIL;
13317     }
13318   else
13319     {
13320       if ((val <= 0) || (val >= (1 << nbits)) || (val & 0x1))
13321         return FAIL;
13322     }
13323     return SUCCESS;
13324 }
13325
13326 /* For branches in Armv8.1-M Mainline.  */
13327 static void
13328 do_t_branch_future (void)
13329 {
13330   unsigned long insn = inst.instruction;
13331
13332   inst.instruction = THUMB_OP32 (inst.instruction);
13333   if (inst.operands[0].hasreloc == 0)
13334     {
13335       if (v8_1_branch_value_check (inst.operands[0].imm, 5, FALSE) == FAIL)
13336         as_bad (BAD_BRANCH_OFF);
13337
13338       inst.instruction |= ((inst.operands[0].imm & 0x1f) >> 1) << 23;
13339     }
13340   else
13341     {
13342       inst.relocs[0].type = BFD_RELOC_THUMB_PCREL_BRANCH5;
13343       inst.relocs[0].pc_rel = 1;
13344     }
13345
13346   switch (insn)
13347     {
13348       case T_MNEM_bf:
13349         if (inst.operands[1].hasreloc == 0)
13350           {
13351             int val = inst.operands[1].imm;
13352             if (v8_1_branch_value_check (inst.operands[1].imm, 17, TRUE) == FAIL)
13353               as_bad (BAD_BRANCH_OFF);
13354
13355             int immA = (val & 0x0001f000) >> 12;
13356             int immB = (val & 0x00000ffc) >> 2;
13357             int immC = (val & 0x00000002) >> 1;
13358             inst.instruction |= (immA << 16) | (immB << 1) | (immC << 11);
13359           }
13360         else
13361           {
13362             inst.relocs[1].type = BFD_RELOC_ARM_THUMB_BF17;
13363             inst.relocs[1].pc_rel = 1;
13364           }
13365         break;
13366
13367       case T_MNEM_bfx:
13368       case T_MNEM_bflx:
13369         inst.instruction |= inst.operands[1].reg << 16;
13370         break;
13371
13372       default: abort ();
13373     }
13374 }
13375
13376 /* Neon instruction encoder helpers.  */
13377
13378 /* Encodings for the different types for various Neon opcodes.  */
13379
13380 /* An "invalid" code for the following tables.  */
13381 #define N_INV -1u
13382
13383 struct neon_tab_entry
13384 {
13385   unsigned integer;
13386   unsigned float_or_poly;
13387   unsigned scalar_or_imm;
13388 };
13389
13390 /* Map overloaded Neon opcodes to their respective encodings.  */
13391 #define NEON_ENC_TAB                                    \
13392   X(vabd,       0x0000700, 0x1200d00, N_INV),           \
13393   X(vmax,       0x0000600, 0x0000f00, N_INV),           \
13394   X(vmin,       0x0000610, 0x0200f00, N_INV),           \
13395   X(vpadd,      0x0000b10, 0x1000d00, N_INV),           \
13396   X(vpmax,      0x0000a00, 0x1000f00, N_INV),           \
13397   X(vpmin,      0x0000a10, 0x1200f00, N_INV),           \
13398   X(vadd,       0x0000800, 0x0000d00, N_INV),           \
13399   X(vsub,       0x1000800, 0x0200d00, N_INV),           \
13400   X(vceq,       0x1000810, 0x0000e00, 0x1b10100),       \
13401   X(vcge,       0x0000310, 0x1000e00, 0x1b10080),       \
13402   X(vcgt,       0x0000300, 0x1200e00, 0x1b10000),       \
13403   /* Register variants of the following two instructions are encoded as
13404      vcge / vcgt with the operands reversed.  */        \
13405   X(vclt,       0x0000300, 0x1200e00, 0x1b10200),       \
13406   X(vcle,       0x0000310, 0x1000e00, 0x1b10180),       \
13407   X(vfma,       N_INV, 0x0000c10, N_INV),               \
13408   X(vfms,       N_INV, 0x0200c10, N_INV),               \
13409   X(vmla,       0x0000900, 0x0000d10, 0x0800040),       \
13410   X(vmls,       0x1000900, 0x0200d10, 0x0800440),       \
13411   X(vmul,       0x0000910, 0x1000d10, 0x0800840),       \
13412   X(vmull,      0x0800c00, 0x0800e00, 0x0800a40), /* polynomial not float.  */ \
13413   X(vmlal,      0x0800800, N_INV,     0x0800240),       \
13414   X(vmlsl,      0x0800a00, N_INV,     0x0800640),       \
13415   X(vqdmlal,    0x0800900, N_INV,     0x0800340),       \
13416   X(vqdmlsl,    0x0800b00, N_INV,     0x0800740),       \
13417   X(vqdmull,    0x0800d00, N_INV,     0x0800b40),       \
13418   X(vqdmulh,    0x0000b00, N_INV,     0x0800c40),       \
13419   X(vqrdmulh,   0x1000b00, N_INV,     0x0800d40),       \
13420   X(vqrdmlah,   0x3000b10, N_INV,     0x0800e40),       \
13421   X(vqrdmlsh,   0x3000c10, N_INV,     0x0800f40),       \
13422   X(vshl,       0x0000400, N_INV,     0x0800510),       \
13423   X(vqshl,      0x0000410, N_INV,     0x0800710),       \
13424   X(vand,       0x0000110, N_INV,     0x0800030),       \
13425   X(vbic,       0x0100110, N_INV,     0x0800030),       \
13426   X(veor,       0x1000110, N_INV,     N_INV),           \
13427   X(vorn,       0x0300110, N_INV,     0x0800010),       \
13428   X(vorr,       0x0200110, N_INV,     0x0800010),       \
13429   X(vmvn,       0x1b00580, N_INV,     0x0800030),       \
13430   X(vshll,      0x1b20300, N_INV,     0x0800a10), /* max shift, immediate.  */ \
13431   X(vcvt,       0x1b30600, N_INV,     0x0800e10), /* integer, fixed-point.  */ \
13432   X(vdup,       0xe800b10, N_INV,     0x1b00c00), /* arm, scalar.  */ \
13433   X(vld1,       0x0200000, 0x0a00000, 0x0a00c00), /* interlv, lane, dup.  */ \
13434   X(vst1,       0x0000000, 0x0800000, N_INV),           \
13435   X(vld2,       0x0200100, 0x0a00100, 0x0a00d00),       \
13436   X(vst2,       0x0000100, 0x0800100, N_INV),           \
13437   X(vld3,       0x0200200, 0x0a00200, 0x0a00e00),       \
13438   X(vst3,       0x0000200, 0x0800200, N_INV),           \
13439   X(vld4,       0x0200300, 0x0a00300, 0x0a00f00),       \
13440   X(vst4,       0x0000300, 0x0800300, N_INV),           \
13441   X(vmovn,      0x1b20200, N_INV,     N_INV),           \
13442   X(vtrn,       0x1b20080, N_INV,     N_INV),           \
13443   X(vqmovn,     0x1b20200, N_INV,     N_INV),           \
13444   X(vqmovun,    0x1b20240, N_INV,     N_INV),           \
13445   X(vnmul,      0xe200a40, 0xe200b40, N_INV),           \
13446   X(vnmla,      0xe100a40, 0xe100b40, N_INV),           \
13447   X(vnmls,      0xe100a00, 0xe100b00, N_INV),           \
13448   X(vfnma,      0xe900a40, 0xe900b40, N_INV),           \
13449   X(vfnms,      0xe900a00, 0xe900b00, N_INV),           \
13450   X(vcmp,       0xeb40a40, 0xeb40b40, N_INV),           \
13451   X(vcmpz,      0xeb50a40, 0xeb50b40, N_INV),           \
13452   X(vcmpe,      0xeb40ac0, 0xeb40bc0, N_INV),           \
13453   X(vcmpez,     0xeb50ac0, 0xeb50bc0, N_INV),           \
13454   X(vseleq,     0xe000a00, N_INV,     N_INV),           \
13455   X(vselvs,     0xe100a00, N_INV,     N_INV),           \
13456   X(vselge,     0xe200a00, N_INV,     N_INV),           \
13457   X(vselgt,     0xe300a00, N_INV,     N_INV),           \
13458   X(vmaxnm,     0xe800a00, 0x3000f10, N_INV),           \
13459   X(vminnm,     0xe800a40, 0x3200f10, N_INV),           \
13460   X(vcvta,      0xebc0a40, 0x3bb0000, N_INV),           \
13461   X(vrintr,     0xeb60a40, 0x3ba0400, N_INV),           \
13462   X(vrinta,     0xeb80a40, 0x3ba0400, N_INV),           \
13463   X(aes,        0x3b00300, N_INV,     N_INV),           \
13464   X(sha3op,     0x2000c00, N_INV,     N_INV),           \
13465   X(sha1h,      0x3b902c0, N_INV,     N_INV),           \
13466   X(sha2op,     0x3ba0380, N_INV,     N_INV)
13467
13468 enum neon_opc
13469 {
13470 #define X(OPC,I,F,S) N_MNEM_##OPC
13471 NEON_ENC_TAB
13472 #undef X
13473 };
13474
13475 static const struct neon_tab_entry neon_enc_tab[] =
13476 {
13477 #define X(OPC,I,F,S) { (I), (F), (S) }
13478 NEON_ENC_TAB
13479 #undef X
13480 };
13481
13482 /* Do not use these macros; instead, use NEON_ENCODE defined below.  */
13483 #define NEON_ENC_INTEGER_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
13484 #define NEON_ENC_ARMREG_(X)  (neon_enc_tab[(X) & 0x0fffffff].integer)
13485 #define NEON_ENC_POLY_(X)    (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
13486 #define NEON_ENC_FLOAT_(X)   (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
13487 #define NEON_ENC_SCALAR_(X)  (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
13488 #define NEON_ENC_IMMED_(X)   (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
13489 #define NEON_ENC_INTERLV_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
13490 #define NEON_ENC_LANE_(X)    (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
13491 #define NEON_ENC_DUP_(X)     (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
13492 #define NEON_ENC_SINGLE_(X) \
13493   ((neon_enc_tab[(X) & 0x0fffffff].integer) | ((X) & 0xf0000000))
13494 #define NEON_ENC_DOUBLE_(X) \
13495   ((neon_enc_tab[(X) & 0x0fffffff].float_or_poly) | ((X) & 0xf0000000))
13496 #define NEON_ENC_FPV8_(X) \
13497   ((neon_enc_tab[(X) & 0x0fffffff].integer) | ((X) & 0xf000000))
13498
13499 #define NEON_ENCODE(type, inst)                                 \
13500   do                                                            \
13501     {                                                           \
13502       inst.instruction = NEON_ENC_##type##_ (inst.instruction); \
13503       inst.is_neon = 1;                                         \
13504     }                                                           \
13505   while (0)
13506
13507 #define check_neon_suffixes                                             \
13508   do                                                                    \
13509     {                                                                   \
13510       if (!inst.error && inst.vectype.elems > 0 && !inst.is_neon)       \
13511         {                                                               \
13512           as_bad (_("invalid neon suffix for non neon instruction"));   \
13513           return;                                                       \
13514         }                                                               \
13515     }                                                                   \
13516   while (0)
13517
13518 /* Define shapes for instruction operands. The following mnemonic characters
13519    are used in this table:
13520
13521      F - VFP S<n> register
13522      D - Neon D<n> register
13523      Q - Neon Q<n> register
13524      I - Immediate
13525      S - Scalar
13526      R - ARM register
13527      L - D<n> register list
13528
13529    This table is used to generate various data:
13530      - enumerations of the form NS_DDR to be used as arguments to
13531        neon_select_shape.
13532      - a table classifying shapes into single, double, quad, mixed.
13533      - a table used to drive neon_select_shape.  */
13534
13535 #define NEON_SHAPE_DEF                  \
13536   X(3, (D, D, D), DOUBLE),              \
13537   X(3, (Q, Q, Q), QUAD),                \
13538   X(3, (D, D, I), DOUBLE),              \
13539   X(3, (Q, Q, I), QUAD),                \
13540   X(3, (D, D, S), DOUBLE),              \
13541   X(3, (Q, Q, S), QUAD),                \
13542   X(2, (D, D), DOUBLE),                 \
13543   X(2, (Q, Q), QUAD),                   \
13544   X(2, (D, S), DOUBLE),                 \
13545   X(2, (Q, S), QUAD),                   \
13546   X(2, (D, R), DOUBLE),                 \
13547   X(2, (Q, R), QUAD),                   \
13548   X(2, (D, I), DOUBLE),                 \
13549   X(2, (Q, I), QUAD),                   \
13550   X(3, (D, L, D), DOUBLE),              \
13551   X(2, (D, Q), MIXED),                  \
13552   X(2, (Q, D), MIXED),                  \
13553   X(3, (D, Q, I), MIXED),               \
13554   X(3, (Q, D, I), MIXED),               \
13555   X(3, (Q, D, D), MIXED),               \
13556   X(3, (D, Q, Q), MIXED),               \
13557   X(3, (Q, Q, D), MIXED),               \
13558   X(3, (Q, D, S), MIXED),               \
13559   X(3, (D, Q, S), MIXED),               \
13560   X(4, (D, D, D, I), DOUBLE),           \
13561   X(4, (Q, Q, Q, I), QUAD),             \
13562   X(4, (D, D, S, I), DOUBLE),           \
13563   X(4, (Q, Q, S, I), QUAD),             \
13564   X(2, (F, F), SINGLE),                 \
13565   X(3, (F, F, F), SINGLE),              \
13566   X(2, (F, I), SINGLE),                 \
13567   X(2, (F, D), MIXED),                  \
13568   X(2, (D, F), MIXED),                  \
13569   X(3, (F, F, I), MIXED),               \
13570   X(4, (R, R, F, F), SINGLE),           \
13571   X(4, (F, F, R, R), SINGLE),           \
13572   X(3, (D, R, R), DOUBLE),              \
13573   X(3, (R, R, D), DOUBLE),              \
13574   X(2, (S, R), SINGLE),                 \
13575   X(2, (R, S), SINGLE),                 \
13576   X(2, (F, R), SINGLE),                 \
13577   X(2, (R, F), SINGLE),                 \
13578 /* Half float shape supported so far.  */\
13579   X (2, (H, D), MIXED),                 \
13580   X (2, (D, H), MIXED),                 \
13581   X (2, (H, F), MIXED),                 \
13582   X (2, (F, H), MIXED),                 \
13583   X (2, (H, H), HALF),                  \
13584   X (2, (H, R), HALF),                  \
13585   X (2, (R, H), HALF),                  \
13586   X (2, (H, I), HALF),                  \
13587   X (3, (H, H, H), HALF),               \
13588   X (3, (H, F, I), MIXED),              \
13589   X (3, (F, H, I), MIXED),              \
13590   X (3, (D, H, H), MIXED),              \
13591   X (3, (D, H, S), MIXED)
13592
13593 #define S2(A,B)         NS_##A##B
13594 #define S3(A,B,C)       NS_##A##B##C
13595 #define S4(A,B,C,D)     NS_##A##B##C##D
13596
13597 #define X(N, L, C) S##N L
13598
13599 enum neon_shape
13600 {
13601   NEON_SHAPE_DEF,
13602   NS_NULL
13603 };
13604
13605 #undef X
13606 #undef S2
13607 #undef S3
13608 #undef S4
13609
13610 enum neon_shape_class
13611 {
13612   SC_HALF,
13613   SC_SINGLE,
13614   SC_DOUBLE,
13615   SC_QUAD,
13616   SC_MIXED
13617 };
13618
13619 #define X(N, L, C) SC_##C
13620
13621 static enum neon_shape_class neon_shape_class[] =
13622 {
13623   NEON_SHAPE_DEF
13624 };
13625
13626 #undef X
13627
13628 enum neon_shape_el
13629 {
13630   SE_H,
13631   SE_F,
13632   SE_D,
13633   SE_Q,
13634   SE_I,
13635   SE_S,
13636   SE_R,
13637   SE_L
13638 };
13639
13640 /* Register widths of above.  */
13641 static unsigned neon_shape_el_size[] =
13642 {
13643   16,
13644   32,
13645   64,
13646   128,
13647   0,
13648   32,
13649   32,
13650   0
13651 };
13652
13653 struct neon_shape_info
13654 {
13655   unsigned els;
13656   enum neon_shape_el el[NEON_MAX_TYPE_ELS];
13657 };
13658
13659 #define S2(A,B)         { SE_##A, SE_##B }
13660 #define S3(A,B,C)       { SE_##A, SE_##B, SE_##C }
13661 #define S4(A,B,C,D)     { SE_##A, SE_##B, SE_##C, SE_##D }
13662
13663 #define X(N, L, C) { N, S##N L }
13664
13665 static struct neon_shape_info neon_shape_tab[] =
13666 {
13667   NEON_SHAPE_DEF
13668 };
13669
13670 #undef X
13671 #undef S2
13672 #undef S3
13673 #undef S4
13674
13675 /* Bit masks used in type checking given instructions.
13676   'N_EQK' means the type must be the same as (or based on in some way) the key
13677    type, which itself is marked with the 'N_KEY' bit. If the 'N_EQK' bit is
13678    set, various other bits can be set as well in order to modify the meaning of
13679    the type constraint.  */
13680
13681 enum neon_type_mask
13682 {
13683   N_S8   = 0x0000001,
13684   N_S16  = 0x0000002,
13685   N_S32  = 0x0000004,
13686   N_S64  = 0x0000008,
13687   N_U8   = 0x0000010,
13688   N_U16  = 0x0000020,
13689   N_U32  = 0x0000040,
13690   N_U64  = 0x0000080,
13691   N_I8   = 0x0000100,
13692   N_I16  = 0x0000200,
13693   N_I32  = 0x0000400,
13694   N_I64  = 0x0000800,
13695   N_8    = 0x0001000,
13696   N_16   = 0x0002000,
13697   N_32   = 0x0004000,
13698   N_64   = 0x0008000,
13699   N_P8   = 0x0010000,
13700   N_P16  = 0x0020000,
13701   N_F16  = 0x0040000,
13702   N_F32  = 0x0080000,
13703   N_F64  = 0x0100000,
13704   N_P64  = 0x0200000,
13705   N_KEY  = 0x1000000, /* Key element (main type specifier).  */
13706   N_EQK  = 0x2000000, /* Given operand has the same type & size as the key.  */
13707   N_VFP  = 0x4000000, /* VFP mode: operand size must match register width.  */
13708   N_UNT  = 0x8000000, /* Must be explicitly untyped.  */
13709   N_DBL  = 0x0000001, /* If N_EQK, this operand is twice the size.  */
13710   N_HLF  = 0x0000002, /* If N_EQK, this operand is half the size.  */
13711   N_SGN  = 0x0000004, /* If N_EQK, this operand is forced to be signed.  */
13712   N_UNS  = 0x0000008, /* If N_EQK, this operand is forced to be unsigned.  */
13713   N_INT  = 0x0000010, /* If N_EQK, this operand is forced to be integer.  */
13714   N_FLT  = 0x0000020, /* If N_EQK, this operand is forced to be float.  */
13715   N_SIZ  = 0x0000040, /* If N_EQK, this operand is forced to be size-only.  */
13716   N_UTYP = 0,
13717   N_MAX_NONSPECIAL = N_P64
13718 };
13719
13720 #define N_ALLMODS  (N_DBL | N_HLF | N_SGN | N_UNS | N_INT | N_FLT | N_SIZ)
13721
13722 #define N_SU_ALL   (N_S8 | N_S16 | N_S32 | N_S64 | N_U8 | N_U16 | N_U32 | N_U64)
13723 #define N_SU_32    (N_S8 | N_S16 | N_S32 | N_U8 | N_U16 | N_U32)
13724 #define N_SU_16_64 (N_S16 | N_S32 | N_S64 | N_U16 | N_U32 | N_U64)
13725 #define N_S_32     (N_S8 | N_S16 | N_S32)
13726 #define N_F_16_32  (N_F16 | N_F32)
13727 #define N_SUF_32   (N_SU_32 | N_F_16_32)
13728 #define N_I_ALL    (N_I8 | N_I16 | N_I32 | N_I64)
13729 #define N_IF_32    (N_I8 | N_I16 | N_I32 | N_F16 | N_F32)
13730 #define N_F_ALL    (N_F16 | N_F32 | N_F64)
13731
13732 /* Pass this as the first type argument to neon_check_type to ignore types
13733    altogether.  */
13734 #define N_IGNORE_TYPE (N_KEY | N_EQK)
13735
13736 /* Select a "shape" for the current instruction (describing register types or
13737    sizes) from a list of alternatives. Return NS_NULL if the current instruction
13738    doesn't fit. For non-polymorphic shapes, checking is usually done as a
13739    function of operand parsing, so this function doesn't need to be called.
13740    Shapes should be listed in order of decreasing length.  */
13741
13742 static enum neon_shape
13743 neon_select_shape (enum neon_shape shape, ...)
13744 {
13745   va_list ap;
13746   enum neon_shape first_shape = shape;
13747
13748   /* Fix missing optional operands. FIXME: we don't know at this point how
13749      many arguments we should have, so this makes the assumption that we have
13750      > 1. This is true of all current Neon opcodes, I think, but may not be
13751      true in the future.  */
13752   if (!inst.operands[1].present)
13753     inst.operands[1] = inst.operands[0];
13754
13755   va_start (ap, shape);
13756
13757   for (; shape != NS_NULL; shape = (enum neon_shape) va_arg (ap, int))
13758     {
13759       unsigned j;
13760       int matches = 1;
13761
13762       for (j = 0; j < neon_shape_tab[shape].els; j++)
13763         {
13764           if (!inst.operands[j].present)
13765             {
13766               matches = 0;
13767               break;
13768             }
13769
13770           switch (neon_shape_tab[shape].el[j])
13771             {
13772               /* If a  .f16,  .16,  .u16,  .s16 type specifier is given over
13773                  a VFP single precision register operand, it's essentially
13774                  means only half of the register is used.
13775
13776                  If the type specifier is given after the mnemonics, the
13777                  information is stored in inst.vectype.  If the type specifier
13778                  is given after register operand, the information is stored
13779                  in inst.operands[].vectype.
13780
13781                  When there is only one type specifier, and all the register
13782                  operands are the same type of hardware register, the type
13783                  specifier applies to all register operands.
13784
13785                  If no type specifier is given, the shape is inferred from
13786                  operand information.
13787
13788                  for example:
13789                  vadd.f16 s0, s1, s2:           NS_HHH
13790                  vabs.f16 s0, s1:               NS_HH
13791                  vmov.f16 s0, r1:               NS_HR
13792                  vmov.f16 r0, s1:               NS_RH
13793                  vcvt.f16 r0, s1:               NS_RH
13794                  vcvt.f16.s32   s2, s2, #29:    NS_HFI
13795                  vcvt.f16.s32   s2, s2:         NS_HF
13796               */
13797             case SE_H:
13798               if (!(inst.operands[j].isreg
13799                     && inst.operands[j].isvec
13800                     && inst.operands[j].issingle
13801                     && !inst.operands[j].isquad
13802                     && ((inst.vectype.elems == 1
13803                          && inst.vectype.el[0].size == 16)
13804                         || (inst.vectype.elems > 1
13805                             && inst.vectype.el[j].size == 16)
13806                         || (inst.vectype.elems == 0
13807                             && inst.operands[j].vectype.type != NT_invtype
13808                             && inst.operands[j].vectype.size == 16))))
13809                 matches = 0;
13810               break;
13811
13812             case SE_F:
13813               if (!(inst.operands[j].isreg
13814                     && inst.operands[j].isvec
13815                     && inst.operands[j].issingle
13816                     && !inst.operands[j].isquad
13817                     && ((inst.vectype.elems == 1 && inst.vectype.el[0].size == 32)
13818                         || (inst.vectype.elems > 1 && inst.vectype.el[j].size == 32)
13819                         || (inst.vectype.elems == 0
13820                             && (inst.operands[j].vectype.size == 32
13821                                 || inst.operands[j].vectype.type == NT_invtype)))))
13822                 matches = 0;
13823               break;
13824
13825             case SE_D:
13826               if (!(inst.operands[j].isreg
13827                     && inst.operands[j].isvec
13828                     && !inst.operands[j].isquad
13829                     && !inst.operands[j].issingle))
13830                 matches = 0;
13831               break;
13832
13833             case SE_R:
13834               if (!(inst.operands[j].isreg
13835                     && !inst.operands[j].isvec))
13836                 matches = 0;
13837               break;
13838
13839             case SE_Q:
13840               if (!(inst.operands[j].isreg
13841                     && inst.operands[j].isvec
13842                     && inst.operands[j].isquad
13843                     && !inst.operands[j].issingle))
13844                 matches = 0;
13845               break;
13846
13847             case SE_I:
13848               if (!(!inst.operands[j].isreg
13849                     && !inst.operands[j].isscalar))
13850                 matches = 0;
13851               break;
13852
13853             case SE_S:
13854               if (!(!inst.operands[j].isreg
13855                     && inst.operands[j].isscalar))
13856                 matches = 0;
13857               break;
13858
13859             case SE_L:
13860               break;
13861             }
13862           if (!matches)
13863             break;
13864         }
13865       if (matches && (j >= ARM_IT_MAX_OPERANDS || !inst.operands[j].present))
13866         /* We've matched all the entries in the shape table, and we don't
13867            have any left over operands which have not been matched.  */
13868         break;
13869     }
13870
13871   va_end (ap);
13872
13873   if (shape == NS_NULL && first_shape != NS_NULL)
13874     first_error (_("invalid instruction shape"));
13875
13876   return shape;
13877 }
13878
13879 /* True if SHAPE is predominantly a quadword operation (most of the time, this
13880    means the Q bit should be set).  */
13881
13882 static int
13883 neon_quad (enum neon_shape shape)
13884 {
13885   return neon_shape_class[shape] == SC_QUAD;
13886 }
13887
13888 static void
13889 neon_modify_type_size (unsigned typebits, enum neon_el_type *g_type,
13890                        unsigned *g_size)
13891 {
13892   /* Allow modification to be made to types which are constrained to be
13893      based on the key element, based on bits set alongside N_EQK.  */
13894   if ((typebits & N_EQK) != 0)
13895     {
13896       if ((typebits & N_HLF) != 0)
13897         *g_size /= 2;
13898       else if ((typebits & N_DBL) != 0)
13899         *g_size *= 2;
13900       if ((typebits & N_SGN) != 0)
13901         *g_type = NT_signed;
13902       else if ((typebits & N_UNS) != 0)
13903         *g_type = NT_unsigned;
13904       else if ((typebits & N_INT) != 0)
13905         *g_type = NT_integer;
13906       else if ((typebits & N_FLT) != 0)
13907         *g_type = NT_float;
13908       else if ((typebits & N_SIZ) != 0)
13909         *g_type = NT_untyped;
13910     }
13911 }
13912
13913 /* Return operand OPNO promoted by bits set in THISARG. KEY should be the "key"
13914    operand type, i.e. the single type specified in a Neon instruction when it
13915    is the only one given.  */
13916
13917 static struct neon_type_el
13918 neon_type_promote (struct neon_type_el *key, unsigned thisarg)
13919 {
13920   struct neon_type_el dest = *key;
13921
13922   gas_assert ((thisarg & N_EQK) != 0);
13923
13924   neon_modify_type_size (thisarg, &dest.type, &dest.size);
13925
13926   return dest;
13927 }
13928
13929 /* Convert Neon type and size into compact bitmask representation.  */
13930
13931 static enum neon_type_mask
13932 type_chk_of_el_type (enum neon_el_type type, unsigned size)
13933 {
13934   switch (type)
13935     {
13936     case NT_untyped:
13937       switch (size)
13938         {
13939         case 8:  return N_8;
13940         case 16: return N_16;
13941         case 32: return N_32;
13942         case 64: return N_64;
13943         default: ;
13944         }
13945       break;
13946
13947     case NT_integer:
13948       switch (size)
13949         {
13950         case 8:  return N_I8;
13951         case 16: return N_I16;
13952         case 32: return N_I32;
13953         case 64: return N_I64;
13954         default: ;
13955         }
13956       break;
13957
13958     case NT_float:
13959       switch (size)
13960         {
13961         case 16: return N_F16;
13962         case 32: return N_F32;
13963         case 64: return N_F64;
13964         default: ;
13965         }
13966       break;
13967
13968     case NT_poly:
13969       switch (size)
13970         {
13971         case 8:  return N_P8;
13972         case 16: return N_P16;
13973         case 64: return N_P64;
13974         default: ;
13975         }
13976       break;
13977
13978     case NT_signed:
13979       switch (size)
13980         {
13981         case 8:  return N_S8;
13982         case 16: return N_S16;
13983         case 32: return N_S32;
13984         case 64: return N_S64;
13985         default: ;
13986         }
13987       break;
13988
13989     case NT_unsigned:
13990       switch (size)
13991         {
13992         case 8:  return N_U8;
13993         case 16: return N_U16;
13994         case 32: return N_U32;
13995         case 64: return N_U64;
13996         default: ;
13997         }
13998       break;
13999
14000     default: ;
14001     }
14002
14003   return N_UTYP;
14004 }
14005
14006 /* Convert compact Neon bitmask type representation to a type and size. Only
14007    handles the case where a single bit is set in the mask.  */
14008
14009 static int
14010 el_type_of_type_chk (enum neon_el_type *type, unsigned *size,
14011                      enum neon_type_mask mask)
14012 {
14013   if ((mask & N_EQK) != 0)
14014     return FAIL;
14015
14016   if ((mask & (N_S8 | N_U8 | N_I8 | N_8 | N_P8)) != 0)
14017     *size = 8;
14018   else if ((mask & (N_S16 | N_U16 | N_I16 | N_16 | N_F16 | N_P16)) != 0)
14019     *size = 16;
14020   else if ((mask & (N_S32 | N_U32 | N_I32 | N_32 | N_F32)) != 0)
14021     *size = 32;
14022   else if ((mask & (N_S64 | N_U64 | N_I64 | N_64 | N_F64 | N_P64)) != 0)
14023     *size = 64;
14024   else
14025     return FAIL;
14026
14027   if ((mask & (N_S8 | N_S16 | N_S32 | N_S64)) != 0)
14028     *type = NT_signed;
14029   else if ((mask & (N_U8 | N_U16 | N_U32 | N_U64)) != 0)
14030     *type = NT_unsigned;
14031   else if ((mask & (N_I8 | N_I16 | N_I32 | N_I64)) != 0)
14032     *type = NT_integer;
14033   else if ((mask & (N_8 | N_16 | N_32 | N_64)) != 0)
14034     *type = NT_untyped;
14035   else if ((mask & (N_P8 | N_P16 | N_P64)) != 0)
14036     *type = NT_poly;
14037   else if ((mask & (N_F_ALL)) != 0)
14038     *type = NT_float;
14039   else
14040     return FAIL;
14041
14042   return SUCCESS;
14043 }
14044
14045 /* Modify a bitmask of allowed types. This is only needed for type
14046    relaxation.  */
14047
14048 static unsigned
14049 modify_types_allowed (unsigned allowed, unsigned mods)
14050 {
14051   unsigned size;
14052   enum neon_el_type type;
14053   unsigned destmask;
14054   int i;
14055
14056   destmask = 0;
14057
14058   for (i = 1; i <= N_MAX_NONSPECIAL; i <<= 1)
14059     {
14060       if (el_type_of_type_chk (&type, &size,
14061                                (enum neon_type_mask) (allowed & i)) == SUCCESS)
14062         {
14063           neon_modify_type_size (mods, &type, &size);
14064           destmask |= type_chk_of_el_type (type, size);
14065         }
14066     }
14067
14068   return destmask;
14069 }
14070
14071 /* Check type and return type classification.
14072    The manual states (paraphrase): If one datatype is given, it indicates the
14073    type given in:
14074     - the second operand, if there is one
14075     - the operand, if there is no second operand
14076     - the result, if there are no operands.
14077    This isn't quite good enough though, so we use a concept of a "key" datatype
14078    which is set on a per-instruction basis, which is the one which matters when
14079    only one data type is written.
14080    Note: this function has side-effects (e.g. filling in missing operands). All
14081    Neon instructions should call it before performing bit encoding.  */
14082
14083 static struct neon_type_el
14084 neon_check_type (unsigned els, enum neon_shape ns, ...)
14085 {
14086   va_list ap;
14087   unsigned i, pass, key_el = 0;
14088   unsigned types[NEON_MAX_TYPE_ELS];
14089   enum neon_el_type k_type = NT_invtype;
14090   unsigned k_size = -1u;
14091   struct neon_type_el badtype = {NT_invtype, -1};
14092   unsigned key_allowed = 0;
14093
14094   /* Optional registers in Neon instructions are always (not) in operand 1.
14095      Fill in the missing operand here, if it was omitted.  */
14096   if (els > 1 && !inst.operands[1].present)
14097     inst.operands[1] = inst.operands[0];
14098
14099   /* Suck up all the varargs.  */
14100   va_start (ap, ns);
14101   for (i = 0; i < els; i++)
14102     {
14103       unsigned thisarg = va_arg (ap, unsigned);
14104       if (thisarg == N_IGNORE_TYPE)
14105         {
14106           va_end (ap);
14107           return badtype;
14108         }
14109       types[i] = thisarg;
14110       if ((thisarg & N_KEY) != 0)
14111         key_el = i;
14112     }
14113   va_end (ap);
14114
14115   if (inst.vectype.elems > 0)
14116     for (i = 0; i < els; i++)
14117       if (inst.operands[i].vectype.type != NT_invtype)
14118         {
14119           first_error (_("types specified in both the mnemonic and operands"));
14120           return badtype;
14121         }
14122
14123   /* Duplicate inst.vectype elements here as necessary.
14124      FIXME: No idea if this is exactly the same as the ARM assembler,
14125      particularly when an insn takes one register and one non-register
14126      operand. */
14127   if (inst.vectype.elems == 1 && els > 1)
14128     {
14129       unsigned j;
14130       inst.vectype.elems = els;
14131       inst.vectype.el[key_el] = inst.vectype.el[0];
14132       for (j = 0; j < els; j++)
14133         if (j != key_el)
14134           inst.vectype.el[j] = neon_type_promote (&inst.vectype.el[key_el],
14135                                                   types[j]);
14136     }
14137   else if (inst.vectype.elems == 0 && els > 0)
14138     {
14139       unsigned j;
14140       /* No types were given after the mnemonic, so look for types specified
14141          after each operand. We allow some flexibility here; as long as the
14142          "key" operand has a type, we can infer the others.  */
14143       for (j = 0; j < els; j++)
14144         if (inst.operands[j].vectype.type != NT_invtype)
14145           inst.vectype.el[j] = inst.operands[j].vectype;
14146
14147       if (inst.operands[key_el].vectype.type != NT_invtype)
14148         {
14149           for (j = 0; j < els; j++)
14150             if (inst.operands[j].vectype.type == NT_invtype)
14151               inst.vectype.el[j] = neon_type_promote (&inst.vectype.el[key_el],
14152                                                       types[j]);
14153         }
14154       else
14155         {
14156           first_error (_("operand types can't be inferred"));
14157           return badtype;
14158         }
14159     }
14160   else if (inst.vectype.elems != els)
14161     {
14162       first_error (_("type specifier has the wrong number of parts"));
14163       return badtype;
14164     }
14165
14166   for (pass = 0; pass < 2; pass++)
14167     {
14168       for (i = 0; i < els; i++)
14169         {
14170           unsigned thisarg = types[i];
14171           unsigned types_allowed = ((thisarg & N_EQK) != 0 && pass != 0)
14172             ? modify_types_allowed (key_allowed, thisarg) : thisarg;
14173           enum neon_el_type g_type = inst.vectype.el[i].type;
14174           unsigned g_size = inst.vectype.el[i].size;
14175
14176           /* Decay more-specific signed & unsigned types to sign-insensitive
14177              integer types if sign-specific variants are unavailable.  */
14178           if ((g_type == NT_signed || g_type == NT_unsigned)
14179               && (types_allowed & N_SU_ALL) == 0)
14180             g_type = NT_integer;
14181
14182           /* If only untyped args are allowed, decay any more specific types to
14183              them. Some instructions only care about signs for some element
14184              sizes, so handle that properly.  */
14185           if (((types_allowed & N_UNT) == 0)
14186               && ((g_size == 8 && (types_allowed & N_8) != 0)
14187                   || (g_size == 16 && (types_allowed & N_16) != 0)
14188                   || (g_size == 32 && (types_allowed & N_32) != 0)
14189                   || (g_size == 64 && (types_allowed & N_64) != 0)))
14190             g_type = NT_untyped;
14191
14192           if (pass == 0)
14193             {
14194               if ((thisarg & N_KEY) != 0)
14195                 {
14196                   k_type = g_type;
14197                   k_size = g_size;
14198                   key_allowed = thisarg & ~N_KEY;
14199
14200                   /* Check architecture constraint on FP16 extension.  */
14201                   if (k_size == 16
14202                       && k_type == NT_float
14203                       && ! ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_fp16))
14204                     {
14205                       inst.error = _(BAD_FP16);
14206                       return badtype;
14207                     }
14208                 }
14209             }
14210           else
14211             {
14212               if ((thisarg & N_VFP) != 0)
14213                 {
14214                   enum neon_shape_el regshape;
14215                   unsigned regwidth, match;
14216
14217                   /* PR 11136: Catch the case where we are passed a shape of NS_NULL.  */
14218                   if (ns == NS_NULL)
14219                     {
14220                       first_error (_("invalid instruction shape"));
14221                       return badtype;
14222                     }
14223                   regshape = neon_shape_tab[ns].el[i];
14224                   regwidth = neon_shape_el_size[regshape];
14225
14226                   /* In VFP mode, operands must match register widths. If we
14227                      have a key operand, use its width, else use the width of
14228                      the current operand.  */
14229                   if (k_size != -1u)
14230                     match = k_size;
14231                   else
14232                     match = g_size;
14233
14234                   /* FP16 will use a single precision register.  */
14235                   if (regwidth == 32 && match == 16)
14236                     {
14237                       if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_fp16))
14238                         match = regwidth;
14239                       else
14240                         {
14241                           inst.error = _(BAD_FP16);
14242                           return badtype;
14243                         }
14244                     }
14245
14246                   if (regwidth != match)
14247                     {
14248                       first_error (_("operand size must match register width"));
14249                       return badtype;
14250                     }
14251                 }
14252
14253               if ((thisarg & N_EQK) == 0)
14254                 {
14255                   unsigned given_type = type_chk_of_el_type (g_type, g_size);
14256
14257                   if ((given_type & types_allowed) == 0)
14258                     {
14259                       first_error (_("bad type in Neon instruction"));
14260                       return badtype;
14261                     }
14262                 }
14263               else
14264                 {
14265                   enum neon_el_type mod_k_type = k_type;
14266                   unsigned mod_k_size = k_size;
14267                   neon_modify_type_size (thisarg, &mod_k_type, &mod_k_size);
14268                   if (g_type != mod_k_type || g_size != mod_k_size)
14269                     {
14270                       first_error (_("inconsistent types in Neon instruction"));
14271                       return badtype;
14272                     }
14273                 }
14274             }
14275         }
14276     }
14277
14278   return inst.vectype.el[key_el];
14279 }
14280
14281 /* Neon-style VFP instruction forwarding.  */
14282
14283 /* Thumb VFP instructions have 0xE in the condition field.  */
14284
14285 static void
14286 do_vfp_cond_or_thumb (void)
14287 {
14288   inst.is_neon = 1;
14289
14290   if (thumb_mode)
14291     inst.instruction |= 0xe0000000;
14292   else
14293     inst.instruction |= inst.cond << 28;
14294 }
14295
14296 /* Look up and encode a simple mnemonic, for use as a helper function for the
14297    Neon-style VFP syntax.  This avoids duplication of bits of the insns table,
14298    etc.  It is assumed that operand parsing has already been done, and that the
14299    operands are in the form expected by the given opcode (this isn't necessarily
14300    the same as the form in which they were parsed, hence some massaging must
14301    take place before this function is called).
14302    Checks current arch version against that in the looked-up opcode.  */
14303
14304 static void
14305 do_vfp_nsyn_opcode (const char *opname)
14306 {
14307   const struct asm_opcode *opcode;
14308
14309   opcode = (const struct asm_opcode *) hash_find (arm_ops_hsh, opname);
14310
14311   if (!opcode)
14312     abort ();
14313
14314   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant,
14315                 thumb_mode ? *opcode->tvariant : *opcode->avariant),
14316               _(BAD_FPU));
14317
14318   inst.is_neon = 1;
14319
14320   if (thumb_mode)
14321     {
14322       inst.instruction = opcode->tvalue;
14323       opcode->tencode ();
14324     }
14325   else
14326     {
14327       inst.instruction = (inst.cond << 28) | opcode->avalue;
14328       opcode->aencode ();
14329     }
14330 }
14331
14332 static void
14333 do_vfp_nsyn_add_sub (enum neon_shape rs)
14334 {
14335   int is_add = (inst.instruction & 0x0fffffff) == N_MNEM_vadd;
14336
14337   if (rs == NS_FFF || rs == NS_HHH)
14338     {
14339       if (is_add)
14340         do_vfp_nsyn_opcode ("fadds");
14341       else
14342         do_vfp_nsyn_opcode ("fsubs");
14343
14344       /* ARMv8.2 fp16 instruction.  */
14345       if (rs == NS_HHH)
14346         do_scalar_fp16_v82_encode ();
14347     }
14348   else
14349     {
14350       if (is_add)
14351         do_vfp_nsyn_opcode ("faddd");
14352       else
14353         do_vfp_nsyn_opcode ("fsubd");
14354     }
14355 }
14356
14357 /* Check operand types to see if this is a VFP instruction, and if so call
14358    PFN ().  */
14359
14360 static int
14361 try_vfp_nsyn (int args, void (*pfn) (enum neon_shape))
14362 {
14363   enum neon_shape rs;
14364   struct neon_type_el et;
14365
14366   switch (args)
14367     {
14368     case 2:
14369       rs = neon_select_shape (NS_HH, NS_FF, NS_DD, NS_NULL);
14370       et = neon_check_type (2, rs, N_EQK | N_VFP, N_F_ALL | N_KEY | N_VFP);
14371       break;
14372
14373     case 3:
14374       rs = neon_select_shape (NS_HHH, NS_FFF, NS_DDD, NS_NULL);
14375       et = neon_check_type (3, rs, N_EQK | N_VFP, N_EQK | N_VFP,
14376                             N_F_ALL | N_KEY | N_VFP);
14377       break;
14378
14379     default:
14380       abort ();
14381     }
14382
14383   if (et.type != NT_invtype)
14384     {
14385       pfn (rs);
14386       return SUCCESS;
14387     }
14388
14389   inst.error = NULL;
14390   return FAIL;
14391 }
14392
14393 static void
14394 do_vfp_nsyn_mla_mls (enum neon_shape rs)
14395 {
14396   int is_mla = (inst.instruction & 0x0fffffff) == N_MNEM_vmla;
14397
14398   if (rs == NS_FFF || rs == NS_HHH)
14399     {
14400       if (is_mla)
14401         do_vfp_nsyn_opcode ("fmacs");
14402       else
14403         do_vfp_nsyn_opcode ("fnmacs");
14404
14405       /* ARMv8.2 fp16 instruction.  */
14406       if (rs == NS_HHH)
14407         do_scalar_fp16_v82_encode ();
14408     }
14409   else
14410     {
14411       if (is_mla)
14412         do_vfp_nsyn_opcode ("fmacd");
14413       else
14414         do_vfp_nsyn_opcode ("fnmacd");
14415     }
14416 }
14417
14418 static void
14419 do_vfp_nsyn_fma_fms (enum neon_shape rs)
14420 {
14421   int is_fma = (inst.instruction & 0x0fffffff) == N_MNEM_vfma;
14422
14423   if (rs == NS_FFF || rs == NS_HHH)
14424     {
14425       if (is_fma)
14426         do_vfp_nsyn_opcode ("ffmas");
14427       else
14428         do_vfp_nsyn_opcode ("ffnmas");
14429
14430       /* ARMv8.2 fp16 instruction.  */
14431       if (rs == NS_HHH)
14432         do_scalar_fp16_v82_encode ();
14433     }
14434   else
14435     {
14436       if (is_fma)
14437         do_vfp_nsyn_opcode ("ffmad");
14438       else
14439         do_vfp_nsyn_opcode ("ffnmad");
14440     }
14441 }
14442
14443 static void
14444 do_vfp_nsyn_mul (enum neon_shape rs)
14445 {
14446   if (rs == NS_FFF || rs == NS_HHH)
14447     {
14448       do_vfp_nsyn_opcode ("fmuls");
14449
14450       /* ARMv8.2 fp16 instruction.  */
14451       if (rs == NS_HHH)
14452         do_scalar_fp16_v82_encode ();
14453     }
14454   else
14455     do_vfp_nsyn_opcode ("fmuld");
14456 }
14457
14458 static void
14459 do_vfp_nsyn_abs_neg (enum neon_shape rs)
14460 {
14461   int is_neg = (inst.instruction & 0x80) != 0;
14462   neon_check_type (2, rs, N_EQK | N_VFP, N_F_ALL | N_VFP | N_KEY);
14463
14464   if (rs == NS_FF || rs == NS_HH)
14465     {
14466       if (is_neg)
14467         do_vfp_nsyn_opcode ("fnegs");
14468       else
14469         do_vfp_nsyn_opcode ("fabss");
14470
14471       /* ARMv8.2 fp16 instruction.  */
14472       if (rs == NS_HH)
14473         do_scalar_fp16_v82_encode ();
14474     }
14475   else
14476     {
14477       if (is_neg)
14478         do_vfp_nsyn_opcode ("fnegd");
14479       else
14480         do_vfp_nsyn_opcode ("fabsd");
14481     }
14482 }
14483
14484 /* Encode single-precision (only!) VFP fldm/fstm instructions. Double precision
14485    insns belong to Neon, and are handled elsewhere.  */
14486
14487 static void
14488 do_vfp_nsyn_ldm_stm (int is_dbmode)
14489 {
14490   int is_ldm = (inst.instruction & (1 << 20)) != 0;
14491   if (is_ldm)
14492     {
14493       if (is_dbmode)
14494         do_vfp_nsyn_opcode ("fldmdbs");
14495       else
14496         do_vfp_nsyn_opcode ("fldmias");
14497     }
14498   else
14499     {
14500       if (is_dbmode)
14501         do_vfp_nsyn_opcode ("fstmdbs");
14502       else
14503         do_vfp_nsyn_opcode ("fstmias");
14504     }
14505 }
14506
14507 static void
14508 do_vfp_nsyn_sqrt (void)
14509 {
14510   enum neon_shape rs = neon_select_shape (NS_HH, NS_FF, NS_DD, NS_NULL);
14511   neon_check_type (2, rs, N_EQK | N_VFP, N_F_ALL | N_KEY | N_VFP);
14512
14513   if (rs == NS_FF || rs == NS_HH)
14514     {
14515       do_vfp_nsyn_opcode ("fsqrts");
14516
14517       /* ARMv8.2 fp16 instruction.  */
14518       if (rs == NS_HH)
14519         do_scalar_fp16_v82_encode ();
14520     }
14521   else
14522     do_vfp_nsyn_opcode ("fsqrtd");
14523 }
14524
14525 static void
14526 do_vfp_nsyn_div (void)
14527 {
14528   enum neon_shape rs = neon_select_shape (NS_HHH, NS_FFF, NS_DDD, NS_NULL);
14529   neon_check_type (3, rs, N_EQK | N_VFP, N_EQK | N_VFP,
14530                    N_F_ALL | N_KEY | N_VFP);
14531
14532   if (rs == NS_FFF || rs == NS_HHH)
14533     {
14534       do_vfp_nsyn_opcode ("fdivs");
14535
14536       /* ARMv8.2 fp16 instruction.  */
14537       if (rs == NS_HHH)
14538         do_scalar_fp16_v82_encode ();
14539     }
14540   else
14541     do_vfp_nsyn_opcode ("fdivd");
14542 }
14543
14544 static void
14545 do_vfp_nsyn_nmul (void)
14546 {
14547   enum neon_shape rs = neon_select_shape (NS_HHH, NS_FFF, NS_DDD, NS_NULL);
14548   neon_check_type (3, rs, N_EQK | N_VFP, N_EQK | N_VFP,
14549                    N_F_ALL | N_KEY | N_VFP);
14550
14551   if (rs == NS_FFF || rs == NS_HHH)
14552     {
14553       NEON_ENCODE (SINGLE, inst);
14554       do_vfp_sp_dyadic ();
14555
14556       /* ARMv8.2 fp16 instruction.  */
14557       if (rs == NS_HHH)
14558         do_scalar_fp16_v82_encode ();
14559     }
14560   else
14561     {
14562       NEON_ENCODE (DOUBLE, inst);
14563       do_vfp_dp_rd_rn_rm ();
14564     }
14565   do_vfp_cond_or_thumb ();
14566
14567 }
14568
14569 static void
14570 do_vfp_nsyn_cmp (void)
14571 {
14572   enum neon_shape rs;
14573   if (inst.operands[1].isreg)
14574     {
14575       rs = neon_select_shape (NS_HH, NS_FF, NS_DD, NS_NULL);
14576       neon_check_type (2, rs, N_EQK | N_VFP, N_F_ALL | N_KEY | N_VFP);
14577
14578       if (rs == NS_FF || rs == NS_HH)
14579         {
14580           NEON_ENCODE (SINGLE, inst);
14581           do_vfp_sp_monadic ();
14582         }
14583       else
14584         {
14585           NEON_ENCODE (DOUBLE, inst);
14586           do_vfp_dp_rd_rm ();
14587         }
14588     }
14589   else
14590     {
14591       rs = neon_select_shape (NS_HI, NS_FI, NS_DI, NS_NULL);
14592       neon_check_type (2, rs, N_F_ALL | N_KEY | N_VFP, N_EQK);
14593
14594       switch (inst.instruction & 0x0fffffff)
14595         {
14596         case N_MNEM_vcmp:
14597           inst.instruction += N_MNEM_vcmpz - N_MNEM_vcmp;
14598           break;
14599         case N_MNEM_vcmpe:
14600           inst.instruction += N_MNEM_vcmpez - N_MNEM_vcmpe;
14601           break;
14602         default:
14603           abort ();
14604         }
14605
14606       if (rs == NS_FI || rs == NS_HI)
14607         {
14608           NEON_ENCODE (SINGLE, inst);
14609           do_vfp_sp_compare_z ();
14610         }
14611       else
14612         {
14613           NEON_ENCODE (DOUBLE, inst);
14614           do_vfp_dp_rd ();
14615         }
14616     }
14617   do_vfp_cond_or_thumb ();
14618
14619   /* ARMv8.2 fp16 instruction.  */
14620   if (rs == NS_HI || rs == NS_HH)
14621     do_scalar_fp16_v82_encode ();
14622 }
14623
14624 static void
14625 nsyn_insert_sp (void)
14626 {
14627   inst.operands[1] = inst.operands[0];
14628   memset (&inst.operands[0], '\0', sizeof (inst.operands[0]));
14629   inst.operands[0].reg = REG_SP;
14630   inst.operands[0].isreg = 1;
14631   inst.operands[0].writeback = 1;
14632   inst.operands[0].present = 1;
14633 }
14634
14635 static void
14636 do_vfp_nsyn_push (void)
14637 {
14638   nsyn_insert_sp ();
14639
14640   constraint (inst.operands[1].imm < 1 || inst.operands[1].imm > 16,
14641               _("register list must contain at least 1 and at most 16 "
14642                 "registers"));
14643
14644   if (inst.operands[1].issingle)
14645     do_vfp_nsyn_opcode ("fstmdbs");
14646   else
14647     do_vfp_nsyn_opcode ("fstmdbd");
14648 }
14649
14650 static void
14651 do_vfp_nsyn_pop (void)
14652 {
14653   nsyn_insert_sp ();
14654
14655   constraint (inst.operands[1].imm < 1 || inst.operands[1].imm > 16,
14656               _("register list must contain at least 1 and at most 16 "
14657                 "registers"));
14658
14659   if (inst.operands[1].issingle)
14660     do_vfp_nsyn_opcode ("fldmias");
14661   else
14662     do_vfp_nsyn_opcode ("fldmiad");
14663 }
14664
14665 /* Fix up Neon data-processing instructions, ORing in the correct bits for
14666    ARM mode or Thumb mode and moving the encoded bit 24 to bit 28.  */
14667
14668 static void
14669 neon_dp_fixup (struct arm_it* insn)
14670 {
14671   unsigned int i = insn->instruction;
14672   insn->is_neon = 1;
14673
14674   if (thumb_mode)
14675     {
14676       /* The U bit is at bit 24 by default. Move to bit 28 in Thumb mode.  */
14677       if (i & (1 << 24))
14678         i |= 1 << 28;
14679
14680       i &= ~(1 << 24);
14681
14682       i |= 0xef000000;
14683     }
14684   else
14685     i |= 0xf2000000;
14686
14687   insn->instruction = i;
14688 }
14689
14690 /* Turn a size (8, 16, 32, 64) into the respective bit number minus 3
14691    (0, 1, 2, 3).  */
14692
14693 static unsigned
14694 neon_logbits (unsigned x)
14695 {
14696   return ffs (x) - 4;
14697 }
14698
14699 #define LOW4(R) ((R) & 0xf)
14700 #define HI1(R) (((R) >> 4) & 1)
14701
14702 /* Encode insns with bit pattern:
14703
14704   |28/24|23|22 |21 20|19 16|15 12|11    8|7|6|5|4|3  0|
14705   |  U  |x |D  |size | Rn  | Rd  |x x x x|N|Q|M|x| Rm |
14706
14707   SIZE is passed in bits. -1 means size field isn't changed, in case it has a
14708   different meaning for some instruction.  */
14709
14710 static void
14711 neon_three_same (int isquad, int ubit, int size)
14712 {
14713   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14714   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14715   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
14716   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
14717   inst.instruction |= LOW4 (inst.operands[2].reg);
14718   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
14719   inst.instruction |= (isquad != 0) << 6;
14720   inst.instruction |= (ubit != 0) << 24;
14721   if (size != -1)
14722     inst.instruction |= neon_logbits (size) << 20;
14723
14724   neon_dp_fixup (&inst);
14725 }
14726
14727 /* Encode instructions of the form:
14728
14729   |28/24|23|22|21 20|19 18|17 16|15 12|11      7|6|5|4|3  0|
14730   |  U  |x |D |x  x |size |x  x | Rd  |x x x x x|Q|M|x| Rm |
14731
14732   Don't write size if SIZE == -1.  */
14733
14734 static void
14735 neon_two_same (int qbit, int ubit, int size)
14736 {
14737   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14738   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14739   inst.instruction |= LOW4 (inst.operands[1].reg);
14740   inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14741   inst.instruction |= (qbit != 0) << 6;
14742   inst.instruction |= (ubit != 0) << 24;
14743
14744   if (size != -1)
14745     inst.instruction |= neon_logbits (size) << 18;
14746
14747   neon_dp_fixup (&inst);
14748 }
14749
14750 /* Neon instruction encoders, in approximate order of appearance.  */
14751
14752 static void
14753 do_neon_dyadic_i_su (void)
14754 {
14755   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14756   struct neon_type_el et = neon_check_type (3, rs,
14757     N_EQK, N_EQK, N_SU_32 | N_KEY);
14758   neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
14759 }
14760
14761 static void
14762 do_neon_dyadic_i64_su (void)
14763 {
14764   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14765   struct neon_type_el et = neon_check_type (3, rs,
14766     N_EQK, N_EQK, N_SU_ALL | N_KEY);
14767   neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
14768 }
14769
14770 static void
14771 neon_imm_shift (int write_ubit, int uval, int isquad, struct neon_type_el et,
14772                 unsigned immbits)
14773 {
14774   unsigned size = et.size >> 3;
14775   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14776   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14777   inst.instruction |= LOW4 (inst.operands[1].reg);
14778   inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14779   inst.instruction |= (isquad != 0) << 6;
14780   inst.instruction |= immbits << 16;
14781   inst.instruction |= (size >> 3) << 7;
14782   inst.instruction |= (size & 0x7) << 19;
14783   if (write_ubit)
14784     inst.instruction |= (uval != 0) << 24;
14785
14786   neon_dp_fixup (&inst);
14787 }
14788
14789 static void
14790 do_neon_shl_imm (void)
14791 {
14792   if (!inst.operands[2].isreg)
14793     {
14794       enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14795       struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_KEY | N_I_ALL);
14796       int imm = inst.operands[2].imm;
14797
14798       constraint (imm < 0 || (unsigned)imm >= et.size,
14799                   _("immediate out of range for shift"));
14800       NEON_ENCODE (IMMED, inst);
14801       neon_imm_shift (FALSE, 0, neon_quad (rs), et, imm);
14802     }
14803   else
14804     {
14805       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14806       struct neon_type_el et = neon_check_type (3, rs,
14807         N_EQK, N_SU_ALL | N_KEY, N_EQK | N_SGN);
14808       unsigned int tmp;
14809
14810       /* VSHL/VQSHL 3-register variants have syntax such as:
14811            vshl.xx Dd, Dm, Dn
14812          whereas other 3-register operations encoded by neon_three_same have
14813          syntax like:
14814            vadd.xx Dd, Dn, Dm
14815          (i.e. with Dn & Dm reversed). Swap operands[1].reg and operands[2].reg
14816          here.  */
14817       tmp = inst.operands[2].reg;
14818       inst.operands[2].reg = inst.operands[1].reg;
14819       inst.operands[1].reg = tmp;
14820       NEON_ENCODE (INTEGER, inst);
14821       neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
14822     }
14823 }
14824
14825 static void
14826 do_neon_qshl_imm (void)
14827 {
14828   if (!inst.operands[2].isreg)
14829     {
14830       enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14831       struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_ALL | N_KEY);
14832       int imm = inst.operands[2].imm;
14833
14834       constraint (imm < 0 || (unsigned)imm >= et.size,
14835                   _("immediate out of range for shift"));
14836       NEON_ENCODE (IMMED, inst);
14837       neon_imm_shift (TRUE, et.type == NT_unsigned, neon_quad (rs), et, imm);
14838     }
14839   else
14840     {
14841       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14842       struct neon_type_el et = neon_check_type (3, rs,
14843         N_EQK, N_SU_ALL | N_KEY, N_EQK | N_SGN);
14844       unsigned int tmp;
14845
14846       /* See note in do_neon_shl_imm.  */
14847       tmp = inst.operands[2].reg;
14848       inst.operands[2].reg = inst.operands[1].reg;
14849       inst.operands[1].reg = tmp;
14850       NEON_ENCODE (INTEGER, inst);
14851       neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
14852     }
14853 }
14854
14855 static void
14856 do_neon_rshl (void)
14857 {
14858   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14859   struct neon_type_el et = neon_check_type (3, rs,
14860     N_EQK, N_EQK, N_SU_ALL | N_KEY);
14861   unsigned int tmp;
14862
14863   tmp = inst.operands[2].reg;
14864   inst.operands[2].reg = inst.operands[1].reg;
14865   inst.operands[1].reg = tmp;
14866   neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
14867 }
14868
14869 static int
14870 neon_cmode_for_logic_imm (unsigned immediate, unsigned *immbits, int size)
14871 {
14872   /* Handle .I8 pseudo-instructions.  */
14873   if (size == 8)
14874     {
14875       /* Unfortunately, this will make everything apart from zero out-of-range.
14876          FIXME is this the intended semantics? There doesn't seem much point in
14877          accepting .I8 if so.  */
14878       immediate |= immediate << 8;
14879       size = 16;
14880     }
14881
14882   if (size >= 32)
14883     {
14884       if (immediate == (immediate & 0x000000ff))
14885         {
14886           *immbits = immediate;
14887           return 0x1;
14888         }
14889       else if (immediate == (immediate & 0x0000ff00))
14890         {
14891           *immbits = immediate >> 8;
14892           return 0x3;
14893         }
14894       else if (immediate == (immediate & 0x00ff0000))
14895         {
14896           *immbits = immediate >> 16;
14897           return 0x5;
14898         }
14899       else if (immediate == (immediate & 0xff000000))
14900         {
14901           *immbits = immediate >> 24;
14902           return 0x7;
14903         }
14904       if ((immediate & 0xffff) != (immediate >> 16))
14905         goto bad_immediate;
14906       immediate &= 0xffff;
14907     }
14908
14909   if (immediate == (immediate & 0x000000ff))
14910     {
14911       *immbits = immediate;
14912       return 0x9;
14913     }
14914   else if (immediate == (immediate & 0x0000ff00))
14915     {
14916       *immbits = immediate >> 8;
14917       return 0xb;
14918     }
14919
14920   bad_immediate:
14921   first_error (_("immediate value out of range"));
14922   return FAIL;
14923 }
14924
14925 static void
14926 do_neon_logic (void)
14927 {
14928   if (inst.operands[2].present && inst.operands[2].isreg)
14929     {
14930       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14931       neon_check_type (3, rs, N_IGNORE_TYPE);
14932       /* U bit and size field were set as part of the bitmask.  */
14933       NEON_ENCODE (INTEGER, inst);
14934       neon_three_same (neon_quad (rs), 0, -1);
14935     }
14936   else
14937     {
14938       const int three_ops_form = (inst.operands[2].present
14939                                   && !inst.operands[2].isreg);
14940       const int immoperand = (three_ops_form ? 2 : 1);
14941       enum neon_shape rs = (three_ops_form
14942                             ? neon_select_shape (NS_DDI, NS_QQI, NS_NULL)
14943                             : neon_select_shape (NS_DI, NS_QI, NS_NULL));
14944       struct neon_type_el et = neon_check_type (2, rs,
14945         N_I8 | N_I16 | N_I32 | N_I64 | N_F32 | N_KEY, N_EQK);
14946       enum neon_opc opcode = (enum neon_opc) inst.instruction & 0x0fffffff;
14947       unsigned immbits;
14948       int cmode;
14949
14950       if (et.type == NT_invtype)
14951         return;
14952
14953       if (three_ops_form)
14954         constraint (inst.operands[0].reg != inst.operands[1].reg,
14955                     _("first and second operands shall be the same register"));
14956
14957       NEON_ENCODE (IMMED, inst);
14958
14959       immbits = inst.operands[immoperand].imm;
14960       if (et.size == 64)
14961         {
14962           /* .i64 is a pseudo-op, so the immediate must be a repeating
14963              pattern.  */
14964           if (immbits != (inst.operands[immoperand].regisimm ?
14965                           inst.operands[immoperand].reg : 0))
14966             {
14967               /* Set immbits to an invalid constant.  */
14968               immbits = 0xdeadbeef;
14969             }
14970         }
14971
14972       switch (opcode)
14973         {
14974         case N_MNEM_vbic:
14975           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
14976           break;
14977
14978         case N_MNEM_vorr:
14979           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
14980           break;
14981
14982         case N_MNEM_vand:
14983           /* Pseudo-instruction for VBIC.  */
14984           neon_invert_size (&immbits, 0, et.size);
14985           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
14986           break;
14987
14988         case N_MNEM_vorn:
14989           /* Pseudo-instruction for VORR.  */
14990           neon_invert_size (&immbits, 0, et.size);
14991           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
14992           break;
14993
14994         default:
14995           abort ();
14996         }
14997
14998       if (cmode == FAIL)
14999         return;
15000
15001       inst.instruction |= neon_quad (rs) << 6;
15002       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15003       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15004       inst.instruction |= cmode << 8;
15005       neon_write_immbits (immbits);
15006
15007       neon_dp_fixup (&inst);
15008     }
15009 }
15010
15011 static void
15012 do_neon_bitfield (void)
15013 {
15014   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
15015   neon_check_type (3, rs, N_IGNORE_TYPE);
15016   neon_three_same (neon_quad (rs), 0, -1);
15017 }
15018
15019 static void
15020 neon_dyadic_misc (enum neon_el_type ubit_meaning, unsigned types,
15021                   unsigned destbits)
15022 {
15023   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
15024   struct neon_type_el et = neon_check_type (3, rs, N_EQK | destbits, N_EQK,
15025                                             types | N_KEY);
15026   if (et.type == NT_float)
15027     {
15028       NEON_ENCODE (FLOAT, inst);
15029       neon_three_same (neon_quad (rs), 0, et.size == 16 ? (int) et.size : -1);
15030     }
15031   else
15032     {
15033       NEON_ENCODE (INTEGER, inst);
15034       neon_three_same (neon_quad (rs), et.type == ubit_meaning, et.size);
15035     }
15036 }
15037
15038 static void
15039 do_neon_dyadic_if_su (void)
15040 {
15041   neon_dyadic_misc (NT_unsigned, N_SUF_32, 0);
15042 }
15043
15044 static void
15045 do_neon_dyadic_if_su_d (void)
15046 {
15047   /* This version only allow D registers, but that constraint is enforced during
15048      operand parsing so we don't need to do anything extra here.  */
15049   neon_dyadic_misc (NT_unsigned, N_SUF_32, 0);
15050 }
15051
15052 static void
15053 do_neon_dyadic_if_i_d (void)
15054 {
15055   /* The "untyped" case can't happen. Do this to stop the "U" bit being
15056      affected if we specify unsigned args.  */
15057   neon_dyadic_misc (NT_untyped, N_IF_32, 0);
15058 }
15059
15060 enum vfp_or_neon_is_neon_bits
15061 {
15062   NEON_CHECK_CC = 1,
15063   NEON_CHECK_ARCH = 2,
15064   NEON_CHECK_ARCH8 = 4
15065 };
15066
15067 /* Call this function if an instruction which may have belonged to the VFP or
15068    Neon instruction sets, but turned out to be a Neon instruction (due to the
15069    operand types involved, etc.). We have to check and/or fix-up a couple of
15070    things:
15071
15072      - Make sure the user hasn't attempted to make a Neon instruction
15073        conditional.
15074      - Alter the value in the condition code field if necessary.
15075      - Make sure that the arch supports Neon instructions.
15076
15077    Which of these operations take place depends on bits from enum
15078    vfp_or_neon_is_neon_bits.
15079
15080    WARNING: This function has side effects! If NEON_CHECK_CC is used and the
15081    current instruction's condition is COND_ALWAYS, the condition field is
15082    changed to inst.uncond_value. This is necessary because instructions shared
15083    between VFP and Neon may be conditional for the VFP variants only, and the
15084    unconditional Neon version must have, e.g., 0xF in the condition field.  */
15085
15086 static int
15087 vfp_or_neon_is_neon (unsigned check)
15088 {
15089   /* Conditions are always legal in Thumb mode (IT blocks).  */
15090   if (!thumb_mode && (check & NEON_CHECK_CC))
15091     {
15092       if (inst.cond != COND_ALWAYS)
15093         {
15094           first_error (_(BAD_COND));
15095           return FAIL;
15096         }
15097       if (inst.uncond_value != -1)
15098         inst.instruction |= inst.uncond_value << 28;
15099     }
15100
15101   if ((check & NEON_CHECK_ARCH)
15102       && !mark_feature_used (&fpu_neon_ext_v1))
15103     {
15104       first_error (_(BAD_FPU));
15105       return FAIL;
15106     }
15107
15108   if ((check & NEON_CHECK_ARCH8)
15109       && !mark_feature_used (&fpu_neon_ext_armv8))
15110     {
15111       first_error (_(BAD_FPU));
15112       return FAIL;
15113     }
15114
15115   return SUCCESS;
15116 }
15117
15118 static void
15119 do_neon_addsub_if_i (void)
15120 {
15121   if (try_vfp_nsyn (3, do_vfp_nsyn_add_sub) == SUCCESS)
15122     return;
15123
15124   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15125     return;
15126
15127   /* The "untyped" case can't happen. Do this to stop the "U" bit being
15128      affected if we specify unsigned args.  */
15129   neon_dyadic_misc (NT_untyped, N_IF_32 | N_I64, 0);
15130 }
15131
15132 /* Swaps operands 1 and 2. If operand 1 (optional arg) was omitted, we want the
15133    result to be:
15134      V<op> A,B     (A is operand 0, B is operand 2)
15135    to mean:
15136      V<op> A,B,A
15137    not:
15138      V<op> A,B,B
15139    so handle that case specially.  */
15140
15141 static void
15142 neon_exchange_operands (void)
15143 {
15144   if (inst.operands[1].present)
15145     {
15146       void *scratch = xmalloc (sizeof (inst.operands[0]));
15147
15148       /* Swap operands[1] and operands[2].  */
15149       memcpy (scratch, &inst.operands[1], sizeof (inst.operands[0]));
15150       inst.operands[1] = inst.operands[2];
15151       memcpy (&inst.operands[2], scratch, sizeof (inst.operands[0]));
15152       free (scratch);
15153     }
15154   else
15155     {
15156       inst.operands[1] = inst.operands[2];
15157       inst.operands[2] = inst.operands[0];
15158     }
15159 }
15160
15161 static void
15162 neon_compare (unsigned regtypes, unsigned immtypes, int invert)
15163 {
15164   if (inst.operands[2].isreg)
15165     {
15166       if (invert)
15167         neon_exchange_operands ();
15168       neon_dyadic_misc (NT_unsigned, regtypes, N_SIZ);
15169     }
15170   else
15171     {
15172       enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
15173       struct neon_type_el et = neon_check_type (2, rs,
15174         N_EQK | N_SIZ, immtypes | N_KEY);
15175
15176       NEON_ENCODE (IMMED, inst);
15177       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15178       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15179       inst.instruction |= LOW4 (inst.operands[1].reg);
15180       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15181       inst.instruction |= neon_quad (rs) << 6;
15182       inst.instruction |= (et.type == NT_float) << 10;
15183       inst.instruction |= neon_logbits (et.size) << 18;
15184
15185       neon_dp_fixup (&inst);
15186     }
15187 }
15188
15189 static void
15190 do_neon_cmp (void)
15191 {
15192   neon_compare (N_SUF_32, N_S_32 | N_F_16_32, FALSE);
15193 }
15194
15195 static void
15196 do_neon_cmp_inv (void)
15197 {
15198   neon_compare (N_SUF_32, N_S_32 | N_F_16_32, TRUE);
15199 }
15200
15201 static void
15202 do_neon_ceq (void)
15203 {
15204   neon_compare (N_IF_32, N_IF_32, FALSE);
15205 }
15206
15207 /* For multiply instructions, we have the possibility of 16-bit or 32-bit
15208    scalars, which are encoded in 5 bits, M : Rm.
15209    For 16-bit scalars, the register is encoded in Rm[2:0] and the index in
15210    M:Rm[3], and for 32-bit scalars, the register is encoded in Rm[3:0] and the
15211    index in M.
15212
15213    Dot Product instructions are similar to multiply instructions except elsize
15214    should always be 32.
15215
15216    This function translates SCALAR, which is GAS's internal encoding of indexed
15217    scalar register, to raw encoding.  There is also register and index range
15218    check based on ELSIZE.  */
15219
15220 static unsigned
15221 neon_scalar_for_mul (unsigned scalar, unsigned elsize)
15222 {
15223   unsigned regno = NEON_SCALAR_REG (scalar);
15224   unsigned elno = NEON_SCALAR_INDEX (scalar);
15225
15226   switch (elsize)
15227     {
15228     case 16:
15229       if (regno > 7 || elno > 3)
15230         goto bad_scalar;
15231       return regno | (elno << 3);
15232
15233     case 32:
15234       if (regno > 15 || elno > 1)
15235         goto bad_scalar;
15236       return regno | (elno << 4);
15237
15238     default:
15239     bad_scalar:
15240       first_error (_("scalar out of range for multiply instruction"));
15241     }
15242
15243   return 0;
15244 }
15245
15246 /* Encode multiply / multiply-accumulate scalar instructions.  */
15247
15248 static void
15249 neon_mul_mac (struct neon_type_el et, int ubit)
15250 {
15251   unsigned scalar;
15252
15253   /* Give a more helpful error message if we have an invalid type.  */
15254   if (et.type == NT_invtype)
15255     return;
15256
15257   scalar = neon_scalar_for_mul (inst.operands[2].reg, et.size);
15258   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15259   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15260   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15261   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15262   inst.instruction |= LOW4 (scalar);
15263   inst.instruction |= HI1 (scalar) << 5;
15264   inst.instruction |= (et.type == NT_float) << 8;
15265   inst.instruction |= neon_logbits (et.size) << 20;
15266   inst.instruction |= (ubit != 0) << 24;
15267
15268   neon_dp_fixup (&inst);
15269 }
15270
15271 static void
15272 do_neon_mac_maybe_scalar (void)
15273 {
15274   if (try_vfp_nsyn (3, do_vfp_nsyn_mla_mls) == SUCCESS)
15275     return;
15276
15277   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15278     return;
15279
15280   if (inst.operands[2].isscalar)
15281     {
15282       enum neon_shape rs = neon_select_shape (NS_DDS, NS_QQS, NS_NULL);
15283       struct neon_type_el et = neon_check_type (3, rs,
15284         N_EQK, N_EQK, N_I16 | N_I32 | N_F_16_32 | N_KEY);
15285       NEON_ENCODE (SCALAR, inst);
15286       neon_mul_mac (et, neon_quad (rs));
15287     }
15288   else
15289     {
15290       /* The "untyped" case can't happen.  Do this to stop the "U" bit being
15291          affected if we specify unsigned args.  */
15292       neon_dyadic_misc (NT_untyped, N_IF_32, 0);
15293     }
15294 }
15295
15296 static void
15297 do_neon_fmac (void)
15298 {
15299   if (try_vfp_nsyn (3, do_vfp_nsyn_fma_fms) == SUCCESS)
15300     return;
15301
15302   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15303     return;
15304
15305   neon_dyadic_misc (NT_untyped, N_IF_32, 0);
15306 }
15307
15308 static void
15309 do_neon_tst (void)
15310 {
15311   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
15312   struct neon_type_el et = neon_check_type (3, rs,
15313     N_EQK, N_EQK, N_8 | N_16 | N_32 | N_KEY);
15314   neon_three_same (neon_quad (rs), 0, et.size);
15315 }
15316
15317 /* VMUL with 3 registers allows the P8 type. The scalar version supports the
15318    same types as the MAC equivalents. The polynomial type for this instruction
15319    is encoded the same as the integer type.  */
15320
15321 static void
15322 do_neon_mul (void)
15323 {
15324   if (try_vfp_nsyn (3, do_vfp_nsyn_mul) == SUCCESS)
15325     return;
15326
15327   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15328     return;
15329
15330   if (inst.operands[2].isscalar)
15331     do_neon_mac_maybe_scalar ();
15332   else
15333     neon_dyadic_misc (NT_poly, N_I8 | N_I16 | N_I32 | N_F16 | N_F32 | N_P8, 0);
15334 }
15335
15336 static void
15337 do_neon_qdmulh (void)
15338 {
15339   if (inst.operands[2].isscalar)
15340     {
15341       enum neon_shape rs = neon_select_shape (NS_DDS, NS_QQS, NS_NULL);
15342       struct neon_type_el et = neon_check_type (3, rs,
15343         N_EQK, N_EQK, N_S16 | N_S32 | N_KEY);
15344       NEON_ENCODE (SCALAR, inst);
15345       neon_mul_mac (et, neon_quad (rs));
15346     }
15347   else
15348     {
15349       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
15350       struct neon_type_el et = neon_check_type (3, rs,
15351         N_EQK, N_EQK, N_S16 | N_S32 | N_KEY);
15352       NEON_ENCODE (INTEGER, inst);
15353       /* The U bit (rounding) comes from bit mask.  */
15354       neon_three_same (neon_quad (rs), 0, et.size);
15355     }
15356 }
15357
15358 static void
15359 do_neon_qrdmlah (void)
15360 {
15361   /* Check we're on the correct architecture.  */
15362   if (!mark_feature_used (&fpu_neon_ext_armv8))
15363     inst.error =
15364       _("instruction form not available on this architecture.");
15365   else if (!mark_feature_used (&fpu_neon_ext_v8_1))
15366     {
15367       as_warn (_("this instruction implies use of ARMv8.1 AdvSIMD."));
15368       record_feature_use (&fpu_neon_ext_v8_1);
15369     }
15370
15371   if (inst.operands[2].isscalar)
15372     {
15373       enum neon_shape rs = neon_select_shape (NS_DDS, NS_QQS, NS_NULL);
15374       struct neon_type_el et = neon_check_type (3, rs,
15375         N_EQK, N_EQK, N_S16 | N_S32 | N_KEY);
15376       NEON_ENCODE (SCALAR, inst);
15377       neon_mul_mac (et, neon_quad (rs));
15378     }
15379   else
15380     {
15381       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
15382       struct neon_type_el et = neon_check_type (3, rs,
15383         N_EQK, N_EQK, N_S16 | N_S32 | N_KEY);
15384       NEON_ENCODE (INTEGER, inst);
15385       /* The U bit (rounding) comes from bit mask.  */
15386       neon_three_same (neon_quad (rs), 0, et.size);
15387     }
15388 }
15389
15390 static void
15391 do_neon_fcmp_absolute (void)
15392 {
15393   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
15394   struct neon_type_el et = neon_check_type (3, rs, N_EQK, N_EQK,
15395                                             N_F_16_32 | N_KEY);
15396   /* Size field comes from bit mask.  */
15397   neon_three_same (neon_quad (rs), 1, et.size == 16 ? (int) et.size : -1);
15398 }
15399
15400 static void
15401 do_neon_fcmp_absolute_inv (void)
15402 {
15403   neon_exchange_operands ();
15404   do_neon_fcmp_absolute ();
15405 }
15406
15407 static void
15408 do_neon_step (void)
15409 {
15410   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
15411   struct neon_type_el et = neon_check_type (3, rs, N_EQK, N_EQK,
15412                                             N_F_16_32 | N_KEY);
15413   neon_three_same (neon_quad (rs), 0, et.size == 16 ? (int) et.size : -1);
15414 }
15415
15416 static void
15417 do_neon_abs_neg (void)
15418 {
15419   enum neon_shape rs;
15420   struct neon_type_el et;
15421
15422   if (try_vfp_nsyn (2, do_vfp_nsyn_abs_neg) == SUCCESS)
15423     return;
15424
15425   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15426     return;
15427
15428   rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15429   et = neon_check_type (2, rs, N_EQK, N_S_32 | N_F_16_32 | N_KEY);
15430
15431   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15432   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15433   inst.instruction |= LOW4 (inst.operands[1].reg);
15434   inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15435   inst.instruction |= neon_quad (rs) << 6;
15436   inst.instruction |= (et.type == NT_float) << 10;
15437   inst.instruction |= neon_logbits (et.size) << 18;
15438
15439   neon_dp_fixup (&inst);
15440 }
15441
15442 static void
15443 do_neon_sli (void)
15444 {
15445   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
15446   struct neon_type_el et = neon_check_type (2, rs,
15447     N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
15448   int imm = inst.operands[2].imm;
15449   constraint (imm < 0 || (unsigned)imm >= et.size,
15450               _("immediate out of range for insert"));
15451   neon_imm_shift (FALSE, 0, neon_quad (rs), et, imm);
15452 }
15453
15454 static void
15455 do_neon_sri (void)
15456 {
15457   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
15458   struct neon_type_el et = neon_check_type (2, rs,
15459     N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
15460   int imm = inst.operands[2].imm;
15461   constraint (imm < 1 || (unsigned)imm > et.size,
15462               _("immediate out of range for insert"));
15463   neon_imm_shift (FALSE, 0, neon_quad (rs), et, et.size - imm);
15464 }
15465
15466 static void
15467 do_neon_qshlu_imm (void)
15468 {
15469   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
15470   struct neon_type_el et = neon_check_type (2, rs,
15471     N_EQK | N_UNS, N_S8 | N_S16 | N_S32 | N_S64 | N_KEY);
15472   int imm = inst.operands[2].imm;
15473   constraint (imm < 0 || (unsigned)imm >= et.size,
15474               _("immediate out of range for shift"));
15475   /* Only encodes the 'U present' variant of the instruction.
15476      In this case, signed types have OP (bit 8) set to 0.
15477      Unsigned types have OP set to 1.  */
15478   inst.instruction |= (et.type == NT_unsigned) << 8;
15479   /* The rest of the bits are the same as other immediate shifts.  */
15480   neon_imm_shift (FALSE, 0, neon_quad (rs), et, imm);
15481 }
15482
15483 static void
15484 do_neon_qmovn (void)
15485 {
15486   struct neon_type_el et = neon_check_type (2, NS_DQ,
15487     N_EQK | N_HLF, N_SU_16_64 | N_KEY);
15488   /* Saturating move where operands can be signed or unsigned, and the
15489      destination has the same signedness.  */
15490   NEON_ENCODE (INTEGER, inst);
15491   if (et.type == NT_unsigned)
15492     inst.instruction |= 0xc0;
15493   else
15494     inst.instruction |= 0x80;
15495   neon_two_same (0, 1, et.size / 2);
15496 }
15497
15498 static void
15499 do_neon_qmovun (void)
15500 {
15501   struct neon_type_el et = neon_check_type (2, NS_DQ,
15502     N_EQK | N_HLF | N_UNS, N_S16 | N_S32 | N_S64 | N_KEY);
15503   /* Saturating move with unsigned results. Operands must be signed.  */
15504   NEON_ENCODE (INTEGER, inst);
15505   neon_two_same (0, 1, et.size / 2);
15506 }
15507
15508 static void
15509 do_neon_rshift_sat_narrow (void)
15510 {
15511   /* FIXME: Types for narrowing. If operands are signed, results can be signed
15512      or unsigned. If operands are unsigned, results must also be unsigned.  */
15513   struct neon_type_el et = neon_check_type (2, NS_DQI,
15514     N_EQK | N_HLF, N_SU_16_64 | N_KEY);
15515   int imm = inst.operands[2].imm;
15516   /* This gets the bounds check, size encoding and immediate bits calculation
15517      right.  */
15518   et.size /= 2;
15519
15520   /* VQ{R}SHRN.I<size> <Dd>, <Qm>, #0 is a synonym for
15521      VQMOVN.I<size> <Dd>, <Qm>.  */
15522   if (imm == 0)
15523     {
15524       inst.operands[2].present = 0;
15525       inst.instruction = N_MNEM_vqmovn;
15526       do_neon_qmovn ();
15527       return;
15528     }
15529
15530   constraint (imm < 1 || (unsigned)imm > et.size,
15531               _("immediate out of range"));
15532   neon_imm_shift (TRUE, et.type == NT_unsigned, 0, et, et.size - imm);
15533 }
15534
15535 static void
15536 do_neon_rshift_sat_narrow_u (void)
15537 {
15538   /* FIXME: Types for narrowing. If operands are signed, results can be signed
15539      or unsigned. If operands are unsigned, results must also be unsigned.  */
15540   struct neon_type_el et = neon_check_type (2, NS_DQI,
15541     N_EQK | N_HLF | N_UNS, N_S16 | N_S32 | N_S64 | N_KEY);
15542   int imm = inst.operands[2].imm;
15543   /* This gets the bounds check, size encoding and immediate bits calculation
15544      right.  */
15545   et.size /= 2;
15546
15547   /* VQSHRUN.I<size> <Dd>, <Qm>, #0 is a synonym for
15548      VQMOVUN.I<size> <Dd>, <Qm>.  */
15549   if (imm == 0)
15550     {
15551       inst.operands[2].present = 0;
15552       inst.instruction = N_MNEM_vqmovun;
15553       do_neon_qmovun ();
15554       return;
15555     }
15556
15557   constraint (imm < 1 || (unsigned)imm > et.size,
15558               _("immediate out of range"));
15559   /* FIXME: The manual is kind of unclear about what value U should have in
15560      VQ{R}SHRUN instructions, but U=0, op=0 definitely encodes VRSHR, so it
15561      must be 1.  */
15562   neon_imm_shift (TRUE, 1, 0, et, et.size - imm);
15563 }
15564
15565 static void
15566 do_neon_movn (void)
15567 {
15568   struct neon_type_el et = neon_check_type (2, NS_DQ,
15569     N_EQK | N_HLF, N_I16 | N_I32 | N_I64 | N_KEY);
15570   NEON_ENCODE (INTEGER, inst);
15571   neon_two_same (0, 1, et.size / 2);
15572 }
15573
15574 static void
15575 do_neon_rshift_narrow (void)
15576 {
15577   struct neon_type_el et = neon_check_type (2, NS_DQI,
15578     N_EQK | N_HLF, N_I16 | N_I32 | N_I64 | N_KEY);
15579   int imm = inst.operands[2].imm;
15580   /* This gets the bounds check, size encoding and immediate bits calculation
15581      right.  */
15582   et.size /= 2;
15583
15584   /* If immediate is zero then we are a pseudo-instruction for
15585      VMOVN.I<size> <Dd>, <Qm>  */
15586   if (imm == 0)
15587     {
15588       inst.operands[2].present = 0;
15589       inst.instruction = N_MNEM_vmovn;
15590       do_neon_movn ();
15591       return;
15592     }
15593
15594   constraint (imm < 1 || (unsigned)imm > et.size,
15595               _("immediate out of range for narrowing operation"));
15596   neon_imm_shift (FALSE, 0, 0, et, et.size - imm);
15597 }
15598
15599 static void
15600 do_neon_shll (void)
15601 {
15602   /* FIXME: Type checking when lengthening.  */
15603   struct neon_type_el et = neon_check_type (2, NS_QDI,
15604     N_EQK | N_DBL, N_I8 | N_I16 | N_I32 | N_KEY);
15605   unsigned imm = inst.operands[2].imm;
15606
15607   if (imm == et.size)
15608     {
15609       /* Maximum shift variant.  */
15610       NEON_ENCODE (INTEGER, inst);
15611       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15612       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15613       inst.instruction |= LOW4 (inst.operands[1].reg);
15614       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15615       inst.instruction |= neon_logbits (et.size) << 18;
15616
15617       neon_dp_fixup (&inst);
15618     }
15619   else
15620     {
15621       /* A more-specific type check for non-max versions.  */
15622       et = neon_check_type (2, NS_QDI,
15623         N_EQK | N_DBL, N_SU_32 | N_KEY);
15624       NEON_ENCODE (IMMED, inst);
15625       neon_imm_shift (TRUE, et.type == NT_unsigned, 0, et, imm);
15626     }
15627 }
15628
15629 /* Check the various types for the VCVT instruction, and return which version
15630    the current instruction is.  */
15631
15632 #define CVT_FLAVOUR_VAR                                                       \
15633   CVT_VAR (s32_f32, N_S32, N_F32, whole_reg,   "ftosls", "ftosis", "ftosizs") \
15634   CVT_VAR (u32_f32, N_U32, N_F32, whole_reg,   "ftouls", "ftouis", "ftouizs") \
15635   CVT_VAR (f32_s32, N_F32, N_S32, whole_reg,   "fsltos", "fsitos", NULL)      \
15636   CVT_VAR (f32_u32, N_F32, N_U32, whole_reg,   "fultos", "fuitos", NULL)      \
15637   /* Half-precision conversions.  */                                          \
15638   CVT_VAR (s16_f16, N_S16, N_F16 | N_KEY, whole_reg, NULL, NULL, NULL)        \
15639   CVT_VAR (u16_f16, N_U16, N_F16 | N_KEY, whole_reg, NULL, NULL, NULL)        \
15640   CVT_VAR (f16_s16, N_F16 | N_KEY, N_S16, whole_reg, NULL, NULL, NULL)        \
15641   CVT_VAR (f16_u16, N_F16 | N_KEY, N_U16, whole_reg, NULL, NULL, NULL)        \
15642   CVT_VAR (f32_f16, N_F32, N_F16, whole_reg,   NULL,     NULL,     NULL)      \
15643   CVT_VAR (f16_f32, N_F16, N_F32, whole_reg,   NULL,     NULL,     NULL)      \
15644   /* New VCVT instructions introduced by ARMv8.2 fp16 extension.              \
15645      Compared with single/double precision variants, only the co-processor    \
15646      field is different, so the encoding flow is reused here.  */             \
15647   CVT_VAR (f16_s32, N_F16 | N_KEY, N_S32, N_VFP, "fsltos", "fsitos", NULL)    \
15648   CVT_VAR (f16_u32, N_F16 | N_KEY, N_U32, N_VFP, "fultos", "fuitos", NULL)    \
15649   CVT_VAR (u32_f16, N_U32, N_F16 | N_KEY, N_VFP, "ftouls", "ftouis", "ftouizs")\
15650   CVT_VAR (s32_f16, N_S32, N_F16 | N_KEY, N_VFP, "ftosls", "ftosis", "ftosizs")\
15651   /* VFP instructions.  */                                                    \
15652   CVT_VAR (f32_f64, N_F32, N_F64, N_VFP,       NULL,     "fcvtsd", NULL)      \
15653   CVT_VAR (f64_f32, N_F64, N_F32, N_VFP,       NULL,     "fcvtds", NULL)      \
15654   CVT_VAR (s32_f64, N_S32, N_F64 | key, N_VFP, "ftosld", "ftosid", "ftosizd") \
15655   CVT_VAR (u32_f64, N_U32, N_F64 | key, N_VFP, "ftould", "ftouid", "ftouizd") \
15656   CVT_VAR (f64_s32, N_F64 | key, N_S32, N_VFP, "fsltod", "fsitod", NULL)      \
15657   CVT_VAR (f64_u32, N_F64 | key, N_U32, N_VFP, "fultod", "fuitod", NULL)      \
15658   /* VFP instructions with bitshift.  */                                      \
15659   CVT_VAR (f32_s16, N_F32 | key, N_S16, N_VFP, "fshtos", NULL,     NULL)      \
15660   CVT_VAR (f32_u16, N_F32 | key, N_U16, N_VFP, "fuhtos", NULL,     NULL)      \
15661   CVT_VAR (f64_s16, N_F64 | key, N_S16, N_VFP, "fshtod", NULL,     NULL)      \
15662   CVT_VAR (f64_u16, N_F64 | key, N_U16, N_VFP, "fuhtod", NULL,     NULL)      \
15663   CVT_VAR (s16_f32, N_S16, N_F32 | key, N_VFP, "ftoshs", NULL,     NULL)      \
15664   CVT_VAR (u16_f32, N_U16, N_F32 | key, N_VFP, "ftouhs", NULL,     NULL)      \
15665   CVT_VAR (s16_f64, N_S16, N_F64 | key, N_VFP, "ftoshd", NULL,     NULL)      \
15666   CVT_VAR (u16_f64, N_U16, N_F64 | key, N_VFP, "ftouhd", NULL,     NULL)
15667
15668 #define CVT_VAR(C, X, Y, R, BSN, CN, ZN) \
15669   neon_cvt_flavour_##C,
15670
15671 /* The different types of conversions we can do.  */
15672 enum neon_cvt_flavour
15673 {
15674   CVT_FLAVOUR_VAR
15675   neon_cvt_flavour_invalid,
15676   neon_cvt_flavour_first_fp = neon_cvt_flavour_f32_f64
15677 };
15678
15679 #undef CVT_VAR
15680
15681 static enum neon_cvt_flavour
15682 get_neon_cvt_flavour (enum neon_shape rs)
15683 {
15684 #define CVT_VAR(C,X,Y,R,BSN,CN,ZN)                      \
15685   et = neon_check_type (2, rs, (R) | (X), (R) | (Y));   \
15686   if (et.type != NT_invtype)                            \
15687     {                                                   \
15688       inst.error = NULL;                                \
15689       return (neon_cvt_flavour_##C);                    \
15690     }
15691
15692   struct neon_type_el et;
15693   unsigned whole_reg = (rs == NS_FFI || rs == NS_FD || rs == NS_DF
15694                         || rs == NS_FF) ? N_VFP : 0;
15695   /* The instruction versions which take an immediate take one register
15696      argument, which is extended to the width of the full register. Thus the
15697      "source" and "destination" registers must have the same width.  Hack that
15698      here by making the size equal to the key (wider, in this case) operand.  */
15699   unsigned key = (rs == NS_QQI || rs == NS_DDI || rs == NS_FFI) ? N_KEY : 0;
15700
15701   CVT_FLAVOUR_VAR;
15702
15703   return neon_cvt_flavour_invalid;
15704 #undef CVT_VAR
15705 }
15706
15707 enum neon_cvt_mode
15708 {
15709   neon_cvt_mode_a,
15710   neon_cvt_mode_n,
15711   neon_cvt_mode_p,
15712   neon_cvt_mode_m,
15713   neon_cvt_mode_z,
15714   neon_cvt_mode_x,
15715   neon_cvt_mode_r
15716 };
15717
15718 /* Neon-syntax VFP conversions.  */
15719
15720 static void
15721 do_vfp_nsyn_cvt (enum neon_shape rs, enum neon_cvt_flavour flavour)
15722 {
15723   const char *opname = 0;
15724
15725   if (rs == NS_DDI || rs == NS_QQI || rs == NS_FFI
15726       || rs == NS_FHI || rs == NS_HFI)
15727     {
15728       /* Conversions with immediate bitshift.  */
15729       const char *enc[] =
15730         {
15731 #define CVT_VAR(C,A,B,R,BSN,CN,ZN) BSN,
15732           CVT_FLAVOUR_VAR
15733           NULL
15734 #undef CVT_VAR
15735         };
15736
15737       if (flavour < (int) ARRAY_SIZE (enc))
15738         {
15739           opname = enc[flavour];
15740           constraint (inst.operands[0].reg != inst.operands[1].reg,
15741                       _("operands 0 and 1 must be the same register"));
15742           inst.operands[1] = inst.operands[2];
15743           memset (&inst.operands[2], '\0', sizeof (inst.operands[2]));
15744         }
15745     }
15746   else
15747     {
15748       /* Conversions without bitshift.  */
15749       const char *enc[] =
15750         {
15751 #define CVT_VAR(C,A,B,R,BSN,CN,ZN) CN,
15752           CVT_FLAVOUR_VAR
15753           NULL
15754 #undef CVT_VAR
15755         };
15756
15757       if (flavour < (int) ARRAY_SIZE (enc))
15758         opname = enc[flavour];
15759     }
15760
15761   if (opname)
15762     do_vfp_nsyn_opcode (opname);
15763
15764   /* ARMv8.2 fp16 VCVT instruction.  */
15765   if (flavour == neon_cvt_flavour_s32_f16
15766       || flavour == neon_cvt_flavour_u32_f16
15767       || flavour == neon_cvt_flavour_f16_u32
15768       || flavour == neon_cvt_flavour_f16_s32)
15769     do_scalar_fp16_v82_encode ();
15770 }
15771
15772 static void
15773 do_vfp_nsyn_cvtz (void)
15774 {
15775   enum neon_shape rs = neon_select_shape (NS_FH, NS_FF, NS_FD, NS_NULL);
15776   enum neon_cvt_flavour flavour = get_neon_cvt_flavour (rs);
15777   const char *enc[] =
15778     {
15779 #define CVT_VAR(C,A,B,R,BSN,CN,ZN) ZN,
15780       CVT_FLAVOUR_VAR
15781       NULL
15782 #undef CVT_VAR
15783     };
15784
15785   if (flavour < (int) ARRAY_SIZE (enc) && enc[flavour])
15786     do_vfp_nsyn_opcode (enc[flavour]);
15787 }
15788
15789 static void
15790 do_vfp_nsyn_cvt_fpv8 (enum neon_cvt_flavour flavour,
15791                       enum neon_cvt_mode mode)
15792 {
15793   int sz, op;
15794   int rm;
15795
15796   /* Targets like FPv5-SP-D16 don't support FP v8 instructions with
15797      D register operands.  */
15798   if (flavour == neon_cvt_flavour_s32_f64
15799       || flavour == neon_cvt_flavour_u32_f64)
15800     constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
15801                 _(BAD_FPU));
15802
15803   if (flavour == neon_cvt_flavour_s32_f16
15804       || flavour == neon_cvt_flavour_u32_f16)
15805     constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_fp16),
15806                 _(BAD_FP16));
15807
15808   set_it_insn_type (OUTSIDE_IT_INSN);
15809
15810   switch (flavour)
15811     {
15812     case neon_cvt_flavour_s32_f64:
15813       sz = 1;
15814       op = 1;
15815       break;
15816     case neon_cvt_flavour_s32_f32:
15817       sz = 0;
15818       op = 1;
15819       break;
15820     case neon_cvt_flavour_s32_f16:
15821       sz = 0;
15822       op = 1;
15823       break;
15824     case neon_cvt_flavour_u32_f64:
15825       sz = 1;
15826       op = 0;
15827       break;
15828     case neon_cvt_flavour_u32_f32:
15829       sz = 0;
15830       op = 0;
15831       break;
15832     case neon_cvt_flavour_u32_f16:
15833       sz = 0;
15834       op = 0;
15835       break;
15836     default:
15837       first_error (_("invalid instruction shape"));
15838       return;
15839     }
15840
15841   switch (mode)
15842     {
15843     case neon_cvt_mode_a: rm = 0; break;
15844     case neon_cvt_mode_n: rm = 1; break;
15845     case neon_cvt_mode_p: rm = 2; break;
15846     case neon_cvt_mode_m: rm = 3; break;
15847     default: first_error (_("invalid rounding mode")); return;
15848     }
15849
15850   NEON_ENCODE (FPV8, inst);
15851   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
15852   encode_arm_vfp_reg (inst.operands[1].reg, sz == 1 ? VFP_REG_Dm : VFP_REG_Sm);
15853   inst.instruction |= sz << 8;
15854
15855   /* ARMv8.2 fp16 VCVT instruction.  */
15856   if (flavour == neon_cvt_flavour_s32_f16
15857       ||flavour == neon_cvt_flavour_u32_f16)
15858     do_scalar_fp16_v82_encode ();
15859   inst.instruction |= op << 7;
15860   inst.instruction |= rm << 16;
15861   inst.instruction |= 0xf0000000;
15862   inst.is_neon = TRUE;
15863 }
15864
15865 static void
15866 do_neon_cvt_1 (enum neon_cvt_mode mode)
15867 {
15868   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_FFI, NS_DD, NS_QQ,
15869                                           NS_FD, NS_DF, NS_FF, NS_QD, NS_DQ,
15870                                           NS_FH, NS_HF, NS_FHI, NS_HFI,
15871                                           NS_NULL);
15872   enum neon_cvt_flavour flavour = get_neon_cvt_flavour (rs);
15873
15874   if (flavour == neon_cvt_flavour_invalid)
15875     return;
15876
15877   /* PR11109: Handle round-to-zero for VCVT conversions.  */
15878   if (mode == neon_cvt_mode_z
15879       && ARM_CPU_HAS_FEATURE (cpu_variant, fpu_arch_vfp_v2)
15880       && (flavour == neon_cvt_flavour_s16_f16
15881           || flavour == neon_cvt_flavour_u16_f16
15882           || flavour == neon_cvt_flavour_s32_f32
15883           || flavour == neon_cvt_flavour_u32_f32
15884           || flavour == neon_cvt_flavour_s32_f64
15885           || flavour == neon_cvt_flavour_u32_f64)
15886       && (rs == NS_FD || rs == NS_FF))
15887     {
15888       do_vfp_nsyn_cvtz ();
15889       return;
15890     }
15891
15892   /* ARMv8.2 fp16 VCVT conversions.  */
15893   if (mode == neon_cvt_mode_z
15894       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_fp16)
15895       && (flavour == neon_cvt_flavour_s32_f16
15896           || flavour == neon_cvt_flavour_u32_f16)
15897       && (rs == NS_FH))
15898     {
15899       do_vfp_nsyn_cvtz ();
15900       do_scalar_fp16_v82_encode ();
15901       return;
15902     }
15903
15904   /* VFP rather than Neon conversions.  */
15905   if (flavour >= neon_cvt_flavour_first_fp)
15906     {
15907       if (mode == neon_cvt_mode_x || mode == neon_cvt_mode_z)
15908         do_vfp_nsyn_cvt (rs, flavour);
15909       else
15910         do_vfp_nsyn_cvt_fpv8 (flavour, mode);
15911
15912       return;
15913     }
15914
15915   switch (rs)
15916     {
15917     case NS_DDI:
15918     case NS_QQI:
15919       {
15920         unsigned immbits;
15921         unsigned enctab[] = {0x0000100, 0x1000100, 0x0, 0x1000000,
15922                              0x0000100, 0x1000100, 0x0, 0x1000000};
15923
15924         if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15925           return;
15926
15927         /* Fixed-point conversion with #0 immediate is encoded as an
15928            integer conversion.  */
15929         if (inst.operands[2].present && inst.operands[2].imm == 0)
15930           goto int_encode;
15931         NEON_ENCODE (IMMED, inst);
15932         if (flavour != neon_cvt_flavour_invalid)
15933           inst.instruction |= enctab[flavour];
15934         inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15935         inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15936         inst.instruction |= LOW4 (inst.operands[1].reg);
15937         inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15938         inst.instruction |= neon_quad (rs) << 6;
15939         inst.instruction |= 1 << 21;
15940         if (flavour < neon_cvt_flavour_s16_f16)
15941           {
15942             inst.instruction |= 1 << 21;
15943             immbits = 32 - inst.operands[2].imm;
15944             inst.instruction |= immbits << 16;
15945           }
15946         else
15947           {
15948             inst.instruction |= 3 << 20;
15949             immbits = 16 - inst.operands[2].imm;
15950             inst.instruction |= immbits << 16;
15951             inst.instruction &= ~(1 << 9);
15952           }
15953
15954         neon_dp_fixup (&inst);
15955       }
15956       break;
15957
15958     case NS_DD:
15959     case NS_QQ:
15960       if (mode != neon_cvt_mode_x && mode != neon_cvt_mode_z)
15961         {
15962           NEON_ENCODE (FLOAT, inst);
15963           set_it_insn_type (OUTSIDE_IT_INSN);
15964
15965           if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH8) == FAIL)
15966             return;
15967
15968           inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15969           inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15970           inst.instruction |= LOW4 (inst.operands[1].reg);
15971           inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15972           inst.instruction |= neon_quad (rs) << 6;
15973           inst.instruction |= (flavour == neon_cvt_flavour_u16_f16
15974                                || flavour == neon_cvt_flavour_u32_f32) << 7;
15975           inst.instruction |= mode << 8;
15976           if (flavour == neon_cvt_flavour_u16_f16
15977               || flavour == neon_cvt_flavour_s16_f16)
15978             /* Mask off the original size bits and reencode them.  */
15979             inst.instruction = ((inst.instruction & 0xfff3ffff) | (1 << 18));
15980
15981           if (thumb_mode)
15982             inst.instruction |= 0xfc000000;
15983           else
15984             inst.instruction |= 0xf0000000;
15985         }
15986       else
15987         {
15988     int_encode:
15989           {
15990             unsigned enctab[] = { 0x100, 0x180, 0x0, 0x080,
15991                                   0x100, 0x180, 0x0, 0x080};
15992
15993             NEON_ENCODE (INTEGER, inst);
15994
15995             if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15996               return;
15997
15998             if (flavour != neon_cvt_flavour_invalid)
15999               inst.instruction |= enctab[flavour];
16000
16001             inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16002             inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16003             inst.instruction |= LOW4 (inst.operands[1].reg);
16004             inst.instruction |= HI1 (inst.operands[1].reg) << 5;
16005             inst.instruction |= neon_quad (rs) << 6;
16006             if (flavour >= neon_cvt_flavour_s16_f16
16007                 && flavour <= neon_cvt_flavour_f16_u16)
16008               /* Half precision.  */
16009               inst.instruction |= 1 << 18;
16010             else
16011               inst.instruction |= 2 << 18;
16012
16013             neon_dp_fixup (&inst);
16014           }
16015         }
16016       break;
16017
16018     /* Half-precision conversions for Advanced SIMD -- neon.  */
16019     case NS_QD:
16020     case NS_DQ:
16021       if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
16022         return;
16023
16024       if ((rs == NS_DQ)
16025           && (inst.vectype.el[0].size != 16 || inst.vectype.el[1].size != 32))
16026           {
16027             as_bad (_("operand size must match register width"));
16028             break;
16029           }
16030
16031       if ((rs == NS_QD)
16032           && ((inst.vectype.el[0].size != 32 || inst.vectype.el[1].size != 16)))
16033           {
16034             as_bad (_("operand size must match register width"));
16035             break;
16036           }
16037
16038       if (rs == NS_DQ)
16039         inst.instruction = 0x3b60600;
16040       else
16041         inst.instruction = 0x3b60700;
16042
16043       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16044       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16045       inst.instruction |= LOW4 (inst.operands[1].reg);
16046       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
16047       neon_dp_fixup (&inst);
16048       break;
16049
16050     default:
16051       /* Some VFP conversions go here (s32 <-> f32, u32 <-> f32).  */
16052       if (mode == neon_cvt_mode_x || mode == neon_cvt_mode_z)
16053         do_vfp_nsyn_cvt (rs, flavour);
16054       else
16055         do_vfp_nsyn_cvt_fpv8 (flavour, mode);
16056     }
16057 }
16058
16059 static void
16060 do_neon_cvtr (void)
16061 {
16062   do_neon_cvt_1 (neon_cvt_mode_x);
16063 }
16064
16065 static void
16066 do_neon_cvt (void)
16067 {
16068   do_neon_cvt_1 (neon_cvt_mode_z);
16069 }
16070
16071 static void
16072 do_neon_cvta (void)
16073 {
16074   do_neon_cvt_1 (neon_cvt_mode_a);
16075 }
16076
16077 static void
16078 do_neon_cvtn (void)
16079 {
16080   do_neon_cvt_1 (neon_cvt_mode_n);
16081 }
16082
16083 static void
16084 do_neon_cvtp (void)
16085 {
16086   do_neon_cvt_1 (neon_cvt_mode_p);
16087 }
16088
16089 static void
16090 do_neon_cvtm (void)
16091 {
16092   do_neon_cvt_1 (neon_cvt_mode_m);
16093 }
16094
16095 static void
16096 do_neon_cvttb_2 (bfd_boolean t, bfd_boolean to, bfd_boolean is_double)
16097 {
16098   if (is_double)
16099     mark_feature_used (&fpu_vfp_ext_armv8);
16100
16101   encode_arm_vfp_reg (inst.operands[0].reg,
16102                       (is_double && !to) ? VFP_REG_Dd : VFP_REG_Sd);
16103   encode_arm_vfp_reg (inst.operands[1].reg,
16104                       (is_double && to) ? VFP_REG_Dm : VFP_REG_Sm);
16105   inst.instruction |= to ? 0x10000 : 0;
16106   inst.instruction |= t ? 0x80 : 0;
16107   inst.instruction |= is_double ? 0x100 : 0;
16108   do_vfp_cond_or_thumb ();
16109 }
16110
16111 static void
16112 do_neon_cvttb_1 (bfd_boolean t)
16113 {
16114   enum neon_shape rs = neon_select_shape (NS_HF, NS_HD, NS_FH, NS_FF, NS_FD,
16115                                           NS_DF, NS_DH, NS_NULL);
16116
16117   if (rs == NS_NULL)
16118     return;
16119   else if (neon_check_type (2, rs, N_F16, N_F32 | N_VFP).type != NT_invtype)
16120     {
16121       inst.error = NULL;
16122       do_neon_cvttb_2 (t, /*to=*/TRUE, /*is_double=*/FALSE);
16123     }
16124   else if (neon_check_type (2, rs, N_F32 | N_VFP, N_F16).type != NT_invtype)
16125     {
16126       inst.error = NULL;
16127       do_neon_cvttb_2 (t, /*to=*/FALSE, /*is_double=*/FALSE);
16128     }
16129   else if (neon_check_type (2, rs, N_F16, N_F64 | N_VFP).type != NT_invtype)
16130     {
16131       /* The VCVTB and VCVTT instructions with D-register operands
16132          don't work for SP only targets.  */
16133       constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
16134                   _(BAD_FPU));
16135
16136       inst.error = NULL;
16137       do_neon_cvttb_2 (t, /*to=*/TRUE, /*is_double=*/TRUE);
16138     }
16139   else if (neon_check_type (2, rs, N_F64 | N_VFP, N_F16).type != NT_invtype)
16140     {
16141       /* The VCVTB and VCVTT instructions with D-register operands
16142          don't work for SP only targets.  */
16143       constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
16144                   _(BAD_FPU));
16145
16146       inst.error = NULL;
16147       do_neon_cvttb_2 (t, /*to=*/FALSE, /*is_double=*/TRUE);
16148     }
16149   else
16150     return;
16151 }
16152
16153 static void
16154 do_neon_cvtb (void)
16155 {
16156   do_neon_cvttb_1 (FALSE);
16157 }
16158
16159
16160 static void
16161 do_neon_cvtt (void)
16162 {
16163   do_neon_cvttb_1 (TRUE);
16164 }
16165
16166 static void
16167 neon_move_immediate (void)
16168 {
16169   enum neon_shape rs = neon_select_shape (NS_DI, NS_QI, NS_NULL);
16170   struct neon_type_el et = neon_check_type (2, rs,
16171     N_I8 | N_I16 | N_I32 | N_I64 | N_F32 | N_KEY, N_EQK);
16172   unsigned immlo, immhi = 0, immbits;
16173   int op, cmode, float_p;
16174
16175   constraint (et.type == NT_invtype,
16176               _("operand size must be specified for immediate VMOV"));
16177
16178   /* We start out as an MVN instruction if OP = 1, MOV otherwise.  */
16179   op = (inst.instruction & (1 << 5)) != 0;
16180
16181   immlo = inst.operands[1].imm;
16182   if (inst.operands[1].regisimm)
16183     immhi = inst.operands[1].reg;
16184
16185   constraint (et.size < 32 && (immlo & ~((1 << et.size) - 1)) != 0,
16186               _("immediate has bits set outside the operand size"));
16187
16188   float_p = inst.operands[1].immisfloat;
16189
16190   if ((cmode = neon_cmode_for_move_imm (immlo, immhi, float_p, &immbits, &op,
16191                                         et.size, et.type)) == FAIL)
16192     {
16193       /* Invert relevant bits only.  */
16194       neon_invert_size (&immlo, &immhi, et.size);
16195       /* Flip from VMOV/VMVN to VMVN/VMOV. Some immediate types are unavailable
16196          with one or the other; those cases are caught by
16197          neon_cmode_for_move_imm.  */
16198       op = !op;
16199       if ((cmode = neon_cmode_for_move_imm (immlo, immhi, float_p, &immbits,
16200                                             &op, et.size, et.type)) == FAIL)
16201         {
16202           first_error (_("immediate out of range"));
16203           return;
16204         }
16205     }
16206
16207   inst.instruction &= ~(1 << 5);
16208   inst.instruction |= op << 5;
16209
16210   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16211   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16212   inst.instruction |= neon_quad (rs) << 6;
16213   inst.instruction |= cmode << 8;
16214
16215   neon_write_immbits (immbits);
16216 }
16217
16218 static void
16219 do_neon_mvn (void)
16220 {
16221   if (inst.operands[1].isreg)
16222     {
16223       enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
16224
16225       NEON_ENCODE (INTEGER, inst);
16226       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16227       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16228       inst.instruction |= LOW4 (inst.operands[1].reg);
16229       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
16230       inst.instruction |= neon_quad (rs) << 6;
16231     }
16232   else
16233     {
16234       NEON_ENCODE (IMMED, inst);
16235       neon_move_immediate ();
16236     }
16237
16238   neon_dp_fixup (&inst);
16239 }
16240
16241 /* Encode instructions of form:
16242
16243   |28/24|23|22|21 20|19 16|15 12|11    8|7|6|5|4|3  0|
16244   |  U  |x |D |size | Rn  | Rd  |x x x x|N|x|M|x| Rm |  */
16245
16246 static void
16247 neon_mixed_length (struct neon_type_el et, unsigned size)
16248 {
16249   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16250   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16251   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
16252   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
16253   inst.instruction |= LOW4 (inst.operands[2].reg);
16254   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
16255   inst.instruction |= (et.type == NT_unsigned) << 24;
16256   inst.instruction |= neon_logbits (size) << 20;
16257
16258   neon_dp_fixup (&inst);
16259 }
16260
16261 static void
16262 do_neon_dyadic_long (void)
16263 {
16264   /* FIXME: Type checking for lengthening op.  */
16265   struct neon_type_el et = neon_check_type (3, NS_QDD,
16266     N_EQK | N_DBL, N_EQK, N_SU_32 | N_KEY);
16267   neon_mixed_length (et, et.size);
16268 }
16269
16270 static void
16271 do_neon_abal (void)
16272 {
16273   struct neon_type_el et = neon_check_type (3, NS_QDD,
16274     N_EQK | N_INT | N_DBL, N_EQK, N_SU_32 | N_KEY);
16275   neon_mixed_length (et, et.size);
16276 }
16277
16278 static void
16279 neon_mac_reg_scalar_long (unsigned regtypes, unsigned scalartypes)
16280 {
16281   if (inst.operands[2].isscalar)
16282     {
16283       struct neon_type_el et = neon_check_type (3, NS_QDS,
16284         N_EQK | N_DBL, N_EQK, regtypes | N_KEY);
16285       NEON_ENCODE (SCALAR, inst);
16286       neon_mul_mac (et, et.type == NT_unsigned);
16287     }
16288   else
16289     {
16290       struct neon_type_el et = neon_check_type (3, NS_QDD,
16291         N_EQK | N_DBL, N_EQK, scalartypes | N_KEY);
16292       NEON_ENCODE (INTEGER, inst);
16293       neon_mixed_length (et, et.size);
16294     }
16295 }
16296
16297 static void
16298 do_neon_mac_maybe_scalar_long (void)
16299 {
16300   neon_mac_reg_scalar_long (N_S16 | N_S32 | N_U16 | N_U32, N_SU_32);
16301 }
16302
16303 /* Like neon_scalar_for_mul, this function generate Rm encoding from GAS's
16304    internal SCALAR.  QUAD_P is 1 if it's for Q format, otherwise it's 0.  */
16305
16306 static unsigned
16307 neon_scalar_for_fmac_fp16_long (unsigned scalar, unsigned quad_p)
16308 {
16309   unsigned regno = NEON_SCALAR_REG (scalar);
16310   unsigned elno = NEON_SCALAR_INDEX (scalar);
16311
16312   if (quad_p)
16313     {
16314       if (regno > 7 || elno > 3)
16315         goto bad_scalar;
16316
16317       return ((regno & 0x7)
16318               | ((elno & 0x1) << 3)
16319               | (((elno >> 1) & 0x1) << 5));
16320     }
16321   else
16322     {
16323       if (regno > 15 || elno > 1)
16324         goto bad_scalar;
16325
16326       return (((regno & 0x1) << 5)
16327               | ((regno >> 1) & 0x7)
16328               | ((elno & 0x1) << 3));
16329     }
16330
16331 bad_scalar:
16332   first_error (_("scalar out of range for multiply instruction"));
16333   return 0;
16334 }
16335
16336 static void
16337 do_neon_fmac_maybe_scalar_long (int subtype)
16338 {
16339   enum neon_shape rs;
16340   int high8;
16341   /* NOTE: vfmal/vfmsl use slightly different NEON three-same encoding.  'size"
16342      field (bits[21:20]) has different meaning.  For scalar index variant, it's
16343      used to differentiate add and subtract, otherwise it's with fixed value
16344      0x2.  */
16345   int size = -1;
16346
16347   if (inst.cond != COND_ALWAYS)
16348     as_warn (_("vfmal/vfmsl with FP16 type cannot be conditional, the "
16349                "behaviour is UNPREDICTABLE"));
16350
16351   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_fp16_fml),
16352               _(BAD_FP16));
16353
16354   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_armv8),
16355               _(BAD_FPU));
16356
16357   /* vfmal/vfmsl are in three-same D/Q register format or the third operand can
16358      be a scalar index register.  */
16359   if (inst.operands[2].isscalar)
16360     {
16361       high8 = 0xfe000000;
16362       if (subtype)
16363         size = 16;
16364       rs = neon_select_shape (NS_DHS, NS_QDS, NS_NULL);
16365     }
16366   else
16367     {
16368       high8 = 0xfc000000;
16369       size = 32;
16370       if (subtype)
16371         inst.instruction |= (0x1 << 23);
16372       rs = neon_select_shape (NS_DHH, NS_QDD, NS_NULL);
16373     }
16374
16375   neon_check_type (3, rs, N_EQK, N_EQK, N_KEY | N_F16);
16376
16377   /* "opcode" from template has included "ubit", so simply pass 0 here.  Also,
16378      the "S" bit in size field has been reused to differentiate vfmal and vfmsl,
16379      so we simply pass -1 as size.  */
16380   unsigned quad_p = (rs == NS_QDD || rs == NS_QDS);
16381   neon_three_same (quad_p, 0, size);
16382
16383   /* Undo neon_dp_fixup.  Redo the high eight bits.  */
16384   inst.instruction &= 0x00ffffff;
16385   inst.instruction |= high8;
16386
16387 #define LOW1(R) ((R) & 0x1)
16388 #define HI4(R) (((R) >> 1) & 0xf)
16389   /* Unlike usually NEON three-same, encoding for Vn and Vm will depend on
16390      whether the instruction is in Q form and whether Vm is a scalar indexed
16391      operand.  */
16392   if (inst.operands[2].isscalar)
16393     {
16394       unsigned rm
16395         = neon_scalar_for_fmac_fp16_long (inst.operands[2].reg, quad_p);
16396       inst.instruction &= 0xffffffd0;
16397       inst.instruction |= rm;
16398
16399       if (!quad_p)
16400         {
16401           /* Redo Rn as well.  */
16402           inst.instruction &= 0xfff0ff7f;
16403           inst.instruction |= HI4 (inst.operands[1].reg) << 16;
16404           inst.instruction |= LOW1 (inst.operands[1].reg) << 7;
16405         }
16406     }
16407   else if (!quad_p)
16408     {
16409       /* Redo Rn and Rm.  */
16410       inst.instruction &= 0xfff0ff50;
16411       inst.instruction |= HI4 (inst.operands[1].reg) << 16;
16412       inst.instruction |= LOW1 (inst.operands[1].reg) << 7;
16413       inst.instruction |= HI4 (inst.operands[2].reg);
16414       inst.instruction |= LOW1 (inst.operands[2].reg) << 5;
16415     }
16416 }
16417
16418 static void
16419 do_neon_vfmal (void)
16420 {
16421   return do_neon_fmac_maybe_scalar_long (0);
16422 }
16423
16424 static void
16425 do_neon_vfmsl (void)
16426 {
16427   return do_neon_fmac_maybe_scalar_long (1);
16428 }
16429
16430 static void
16431 do_neon_dyadic_wide (void)
16432 {
16433   struct neon_type_el et = neon_check_type (3, NS_QQD,
16434     N_EQK | N_DBL, N_EQK | N_DBL, N_SU_32 | N_KEY);
16435   neon_mixed_length (et, et.size);
16436 }
16437
16438 static void
16439 do_neon_dyadic_narrow (void)
16440 {
16441   struct neon_type_el et = neon_check_type (3, NS_QDD,
16442     N_EQK | N_DBL, N_EQK, N_I16 | N_I32 | N_I64 | N_KEY);
16443   /* Operand sign is unimportant, and the U bit is part of the opcode,
16444      so force the operand type to integer.  */
16445   et.type = NT_integer;
16446   neon_mixed_length (et, et.size / 2);
16447 }
16448
16449 static void
16450 do_neon_mul_sat_scalar_long (void)
16451 {
16452   neon_mac_reg_scalar_long (N_S16 | N_S32, N_S16 | N_S32);
16453 }
16454
16455 static void
16456 do_neon_vmull (void)
16457 {
16458   if (inst.operands[2].isscalar)
16459     do_neon_mac_maybe_scalar_long ();
16460   else
16461     {
16462       struct neon_type_el et = neon_check_type (3, NS_QDD,
16463         N_EQK | N_DBL, N_EQK, N_SU_32 | N_P8 | N_P64 | N_KEY);
16464
16465       if (et.type == NT_poly)
16466         NEON_ENCODE (POLY, inst);
16467       else
16468         NEON_ENCODE (INTEGER, inst);
16469
16470       /* For polynomial encoding the U bit must be zero, and the size must
16471          be 8 (encoded as 0b00) or, on ARMv8 or later 64 (encoded, non
16472          obviously, as 0b10).  */
16473       if (et.size == 64)
16474         {
16475           /* Check we're on the correct architecture.  */
16476           if (!mark_feature_used (&fpu_crypto_ext_armv8))
16477             inst.error =
16478               _("Instruction form not available on this architecture.");
16479
16480           et.size = 32;
16481         }
16482
16483       neon_mixed_length (et, et.size);
16484     }
16485 }
16486
16487 static void
16488 do_neon_ext (void)
16489 {
16490   enum neon_shape rs = neon_select_shape (NS_DDDI, NS_QQQI, NS_NULL);
16491   struct neon_type_el et = neon_check_type (3, rs,
16492     N_EQK, N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
16493   unsigned imm = (inst.operands[3].imm * et.size) / 8;
16494
16495   constraint (imm >= (unsigned) (neon_quad (rs) ? 16 : 8),
16496               _("shift out of range"));
16497   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16498   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16499   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
16500   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
16501   inst.instruction |= LOW4 (inst.operands[2].reg);
16502   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
16503   inst.instruction |= neon_quad (rs) << 6;
16504   inst.instruction |= imm << 8;
16505
16506   neon_dp_fixup (&inst);
16507 }
16508
16509 static void
16510 do_neon_rev (void)
16511 {
16512   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
16513   struct neon_type_el et = neon_check_type (2, rs,
16514     N_EQK, N_8 | N_16 | N_32 | N_KEY);
16515   unsigned op = (inst.instruction >> 7) & 3;
16516   /* N (width of reversed regions) is encoded as part of the bitmask. We
16517      extract it here to check the elements to be reversed are smaller.
16518      Otherwise we'd get a reserved instruction.  */
16519   unsigned elsize = (op == 2) ? 16 : (op == 1) ? 32 : (op == 0) ? 64 : 0;
16520   gas_assert (elsize != 0);
16521   constraint (et.size >= elsize,
16522               _("elements must be smaller than reversal region"));
16523   neon_two_same (neon_quad (rs), 1, et.size);
16524 }
16525
16526 static void
16527 do_neon_dup (void)
16528 {
16529   if (inst.operands[1].isscalar)
16530     {
16531       enum neon_shape rs = neon_select_shape (NS_DS, NS_QS, NS_NULL);
16532       struct neon_type_el et = neon_check_type (2, rs,
16533         N_EQK, N_8 | N_16 | N_32 | N_KEY);
16534       unsigned sizebits = et.size >> 3;
16535       unsigned dm = NEON_SCALAR_REG (inst.operands[1].reg);
16536       int logsize = neon_logbits (et.size);
16537       unsigned x = NEON_SCALAR_INDEX (inst.operands[1].reg) << logsize;
16538
16539       if (vfp_or_neon_is_neon (NEON_CHECK_CC) == FAIL)
16540         return;
16541
16542       NEON_ENCODE (SCALAR, inst);
16543       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16544       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16545       inst.instruction |= LOW4 (dm);
16546       inst.instruction |= HI1 (dm) << 5;
16547       inst.instruction |= neon_quad (rs) << 6;
16548       inst.instruction |= x << 17;
16549       inst.instruction |= sizebits << 16;
16550
16551       neon_dp_fixup (&inst);
16552     }
16553   else
16554     {
16555       enum neon_shape rs = neon_select_shape (NS_DR, NS_QR, NS_NULL);
16556       struct neon_type_el et = neon_check_type (2, rs,
16557         N_8 | N_16 | N_32 | N_KEY, N_EQK);
16558       /* Duplicate ARM register to lanes of vector.  */
16559       NEON_ENCODE (ARMREG, inst);
16560       switch (et.size)
16561         {
16562         case 8:  inst.instruction |= 0x400000; break;
16563         case 16: inst.instruction |= 0x000020; break;
16564         case 32: inst.instruction |= 0x000000; break;
16565         default: break;
16566         }
16567       inst.instruction |= LOW4 (inst.operands[1].reg) << 12;
16568       inst.instruction |= LOW4 (inst.operands[0].reg) << 16;
16569       inst.instruction |= HI1 (inst.operands[0].reg) << 7;
16570       inst.instruction |= neon_quad (rs) << 21;
16571       /* The encoding for this instruction is identical for the ARM and Thumb
16572          variants, except for the condition field.  */
16573       do_vfp_cond_or_thumb ();
16574     }
16575 }
16576
16577 /* VMOV has particularly many variations. It can be one of:
16578      0. VMOV<c><q> <Qd>, <Qm>
16579      1. VMOV<c><q> <Dd>, <Dm>
16580    (Register operations, which are VORR with Rm = Rn.)
16581      2. VMOV<c><q>.<dt> <Qd>, #<imm>
16582      3. VMOV<c><q>.<dt> <Dd>, #<imm>
16583    (Immediate loads.)
16584      4. VMOV<c><q>.<size> <Dn[x]>, <Rd>
16585    (ARM register to scalar.)
16586      5. VMOV<c><q> <Dm>, <Rd>, <Rn>
16587    (Two ARM registers to vector.)
16588      6. VMOV<c><q>.<dt> <Rd>, <Dn[x]>
16589    (Scalar to ARM register.)
16590      7. VMOV<c><q> <Rd>, <Rn>, <Dm>
16591    (Vector to two ARM registers.)
16592      8. VMOV.F32 <Sd>, <Sm>
16593      9. VMOV.F64 <Dd>, <Dm>
16594    (VFP register moves.)
16595     10. VMOV.F32 <Sd>, #imm
16596     11. VMOV.F64 <Dd>, #imm
16597    (VFP float immediate load.)
16598     12. VMOV <Rd>, <Sm>
16599    (VFP single to ARM reg.)
16600     13. VMOV <Sd>, <Rm>
16601    (ARM reg to VFP single.)
16602     14. VMOV <Rd>, <Re>, <Sn>, <Sm>
16603    (Two ARM regs to two VFP singles.)
16604     15. VMOV <Sd>, <Se>, <Rn>, <Rm>
16605    (Two VFP singles to two ARM regs.)
16606
16607    These cases can be disambiguated using neon_select_shape, except cases 1/9
16608    and 3/11 which depend on the operand type too.
16609
16610    All the encoded bits are hardcoded by this function.
16611
16612    Cases 4, 6 may be used with VFPv1 and above (only 32-bit transfers!).
16613    Cases 5, 7 may be used with VFPv2 and above.
16614
16615    FIXME: Some of the checking may be a bit sloppy (in a couple of cases you
16616    can specify a type where it doesn't make sense to, and is ignored).  */
16617
16618 static void
16619 do_neon_mov (void)
16620 {
16621   enum neon_shape rs = neon_select_shape (NS_RRFF, NS_FFRR, NS_DRR, NS_RRD,
16622                                           NS_QQ, NS_DD, NS_QI, NS_DI, NS_SR,
16623                                           NS_RS, NS_FF, NS_FI, NS_RF, NS_FR,
16624                                           NS_HR, NS_RH, NS_HI, NS_NULL);
16625   struct neon_type_el et;
16626   const char *ldconst = 0;
16627
16628   switch (rs)
16629     {
16630     case NS_DD:  /* case 1/9.  */
16631       et = neon_check_type (2, rs, N_EQK, N_F64 | N_KEY);
16632       /* It is not an error here if no type is given.  */
16633       inst.error = NULL;
16634       if (et.type == NT_float && et.size == 64)
16635         {
16636           do_vfp_nsyn_opcode ("fcpyd");
16637           break;
16638         }
16639       /* fall through.  */
16640
16641     case NS_QQ:  /* case 0/1.  */
16642       {
16643         if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
16644           return;
16645         /* The architecture manual I have doesn't explicitly state which
16646            value the U bit should have for register->register moves, but
16647            the equivalent VORR instruction has U = 0, so do that.  */
16648         inst.instruction = 0x0200110;
16649         inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16650         inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16651         inst.instruction |= LOW4 (inst.operands[1].reg);
16652         inst.instruction |= HI1 (inst.operands[1].reg) << 5;
16653         inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
16654         inst.instruction |= HI1 (inst.operands[1].reg) << 7;
16655         inst.instruction |= neon_quad (rs) << 6;
16656
16657         neon_dp_fixup (&inst);
16658       }
16659       break;
16660
16661     case NS_DI:  /* case 3/11.  */
16662       et = neon_check_type (2, rs, N_EQK, N_F64 | N_KEY);
16663       inst.error = NULL;
16664       if (et.type == NT_float && et.size == 64)
16665         {
16666           /* case 11 (fconstd).  */
16667           ldconst = "fconstd";
16668           goto encode_fconstd;
16669         }
16670       /* fall through.  */
16671
16672     case NS_QI:  /* case 2/3.  */
16673       if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
16674         return;
16675       inst.instruction = 0x0800010;
16676       neon_move_immediate ();
16677       neon_dp_fixup (&inst);
16678       break;
16679
16680     case NS_SR:  /* case 4.  */
16681       {
16682         unsigned bcdebits = 0;
16683         int logsize;
16684         unsigned dn = NEON_SCALAR_REG (inst.operands[0].reg);
16685         unsigned x = NEON_SCALAR_INDEX (inst.operands[0].reg);
16686
16687         /* .<size> is optional here, defaulting to .32. */
16688         if (inst.vectype.elems == 0
16689             && inst.operands[0].vectype.type == NT_invtype
16690             && inst.operands[1].vectype.type == NT_invtype)
16691           {
16692             inst.vectype.el[0].type = NT_untyped;
16693             inst.vectype.el[0].size = 32;
16694             inst.vectype.elems = 1;
16695           }
16696
16697         et = neon_check_type (2, NS_NULL, N_8 | N_16 | N_32 | N_KEY, N_EQK);
16698         logsize = neon_logbits (et.size);
16699
16700         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v1),
16701                     _(BAD_FPU));
16702         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_v1)
16703                     && et.size != 32, _(BAD_FPU));
16704         constraint (et.type == NT_invtype, _("bad type for scalar"));
16705         constraint (x >= 64 / et.size, _("scalar index out of range"));
16706
16707         switch (et.size)
16708           {
16709           case 8:  bcdebits = 0x8; break;
16710           case 16: bcdebits = 0x1; break;
16711           case 32: bcdebits = 0x0; break;
16712           default: ;
16713           }
16714
16715         bcdebits |= x << logsize;
16716
16717         inst.instruction = 0xe000b10;
16718         do_vfp_cond_or_thumb ();
16719         inst.instruction |= LOW4 (dn) << 16;
16720         inst.instruction |= HI1 (dn) << 7;
16721         inst.instruction |= inst.operands[1].reg << 12;
16722         inst.instruction |= (bcdebits & 3) << 5;
16723         inst.instruction |= (bcdebits >> 2) << 21;
16724       }
16725       break;
16726
16727     case NS_DRR:  /* case 5 (fmdrr).  */
16728       constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v2),
16729                   _(BAD_FPU));
16730
16731       inst.instruction = 0xc400b10;
16732       do_vfp_cond_or_thumb ();
16733       inst.instruction |= LOW4 (inst.operands[0].reg);
16734       inst.instruction |= HI1 (inst.operands[0].reg) << 5;
16735       inst.instruction |= inst.operands[1].reg << 12;
16736       inst.instruction |= inst.operands[2].reg << 16;
16737       break;
16738
16739     case NS_RS:  /* case 6.  */
16740       {
16741         unsigned logsize;
16742         unsigned dn = NEON_SCALAR_REG (inst.operands[1].reg);
16743         unsigned x = NEON_SCALAR_INDEX (inst.operands[1].reg);
16744         unsigned abcdebits = 0;
16745
16746         /* .<dt> is optional here, defaulting to .32. */
16747         if (inst.vectype.elems == 0
16748             && inst.operands[0].vectype.type == NT_invtype
16749             && inst.operands[1].vectype.type == NT_invtype)
16750           {
16751             inst.vectype.el[0].type = NT_untyped;
16752             inst.vectype.el[0].size = 32;
16753             inst.vectype.elems = 1;
16754           }
16755
16756         et = neon_check_type (2, NS_NULL,
16757                               N_EQK, N_S8 | N_S16 | N_U8 | N_U16 | N_32 | N_KEY);
16758         logsize = neon_logbits (et.size);
16759
16760         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v1),
16761                     _(BAD_FPU));
16762         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_v1)
16763                     && et.size != 32, _(BAD_FPU));
16764         constraint (et.type == NT_invtype, _("bad type for scalar"));
16765         constraint (x >= 64 / et.size, _("scalar index out of range"));
16766
16767         switch (et.size)
16768           {
16769           case 8:  abcdebits = (et.type == NT_signed) ? 0x08 : 0x18; break;
16770           case 16: abcdebits = (et.type == NT_signed) ? 0x01 : 0x11; break;
16771           case 32: abcdebits = 0x00; break;
16772           default: ;
16773           }
16774
16775         abcdebits |= x << logsize;
16776         inst.instruction = 0xe100b10;
16777         do_vfp_cond_or_thumb ();
16778         inst.instruction |= LOW4 (dn) << 16;
16779         inst.instruction |= HI1 (dn) << 7;
16780         inst.instruction |= inst.operands[0].reg << 12;
16781         inst.instruction |= (abcdebits & 3) << 5;
16782         inst.instruction |= (abcdebits >> 2) << 21;
16783       }
16784       break;
16785
16786     case NS_RRD:  /* case 7 (fmrrd).  */
16787       constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v2),
16788                   _(BAD_FPU));
16789
16790       inst.instruction = 0xc500b10;
16791       do_vfp_cond_or_thumb ();
16792       inst.instruction |= inst.operands[0].reg << 12;
16793       inst.instruction |= inst.operands[1].reg << 16;
16794       inst.instruction |= LOW4 (inst.operands[2].reg);
16795       inst.instruction |= HI1 (inst.operands[2].reg) << 5;
16796       break;
16797
16798     case NS_FF:  /* case 8 (fcpys).  */
16799       do_vfp_nsyn_opcode ("fcpys");
16800       break;
16801
16802     case NS_HI:
16803     case NS_FI:  /* case 10 (fconsts).  */
16804       ldconst = "fconsts";
16805     encode_fconstd:
16806       if (!inst.operands[1].immisfloat)
16807         {
16808           unsigned new_imm;
16809           /* Immediate has to fit in 8 bits so float is enough.  */
16810           float imm = (float) inst.operands[1].imm;
16811           memcpy (&new_imm, &imm, sizeof (float));
16812           /* But the assembly may have been written to provide an integer
16813              bit pattern that equates to a float, so check that the
16814              conversion has worked.  */
16815           if (is_quarter_float (new_imm))
16816             {
16817               if (is_quarter_float (inst.operands[1].imm))
16818                 as_warn (_("immediate constant is valid both as a bit-pattern and a floating point value (using the fp value)"));
16819
16820               inst.operands[1].imm = new_imm;
16821               inst.operands[1].immisfloat = 1;
16822             }
16823         }
16824
16825       if (is_quarter_float (inst.operands[1].imm))
16826         {
16827           inst.operands[1].imm = neon_qfloat_bits (inst.operands[1].imm);
16828           do_vfp_nsyn_opcode (ldconst);
16829
16830           /* ARMv8.2 fp16 vmov.f16 instruction.  */
16831           if (rs == NS_HI)
16832             do_scalar_fp16_v82_encode ();
16833         }
16834       else
16835         first_error (_("immediate out of range"));
16836       break;
16837
16838     case NS_RH:
16839     case NS_RF:  /* case 12 (fmrs).  */
16840       do_vfp_nsyn_opcode ("fmrs");
16841       /* ARMv8.2 fp16 vmov.f16 instruction.  */
16842       if (rs == NS_RH)
16843         do_scalar_fp16_v82_encode ();
16844       break;
16845
16846     case NS_HR:
16847     case NS_FR:  /* case 13 (fmsr).  */
16848       do_vfp_nsyn_opcode ("fmsr");
16849       /* ARMv8.2 fp16 vmov.f16 instruction.  */
16850       if (rs == NS_HR)
16851         do_scalar_fp16_v82_encode ();
16852       break;
16853
16854     /* The encoders for the fmrrs and fmsrr instructions expect three operands
16855        (one of which is a list), but we have parsed four.  Do some fiddling to
16856        make the operands what do_vfp_reg2_from_sp2 and do_vfp_sp2_from_reg2
16857        expect.  */
16858     case NS_RRFF:  /* case 14 (fmrrs).  */
16859       constraint (inst.operands[3].reg != inst.operands[2].reg + 1,
16860                   _("VFP registers must be adjacent"));
16861       inst.operands[2].imm = 2;
16862       memset (&inst.operands[3], '\0', sizeof (inst.operands[3]));
16863       do_vfp_nsyn_opcode ("fmrrs");
16864       break;
16865
16866     case NS_FFRR:  /* case 15 (fmsrr).  */
16867       constraint (inst.operands[1].reg != inst.operands[0].reg + 1,
16868                   _("VFP registers must be adjacent"));
16869       inst.operands[1] = inst.operands[2];
16870       inst.operands[2] = inst.operands[3];
16871       inst.operands[0].imm = 2;
16872       memset (&inst.operands[3], '\0', sizeof (inst.operands[3]));
16873       do_vfp_nsyn_opcode ("fmsrr");
16874       break;
16875
16876     case NS_NULL:
16877       /* neon_select_shape has determined that the instruction
16878          shape is wrong and has already set the error message.  */
16879       break;
16880
16881     default:
16882       abort ();
16883     }
16884 }
16885
16886 static void
16887 do_neon_rshift_round_imm (void)
16888 {
16889   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
16890   struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_ALL | N_KEY);
16891   int imm = inst.operands[2].imm;
16892
16893   /* imm == 0 case is encoded as VMOV for V{R}SHR.  */
16894   if (imm == 0)
16895     {
16896       inst.operands[2].present = 0;
16897       do_neon_mov ();
16898       return;
16899     }
16900
16901   constraint (imm < 1 || (unsigned)imm > et.size,
16902               _("immediate out of range for shift"));
16903   neon_imm_shift (TRUE, et.type == NT_unsigned, neon_quad (rs), et,
16904                   et.size - imm);
16905 }
16906
16907 static void
16908 do_neon_movhf (void)
16909 {
16910   enum neon_shape rs = neon_select_shape (NS_HH, NS_NULL);
16911   constraint (rs != NS_HH, _("invalid suffix"));
16912
16913   if (inst.cond != COND_ALWAYS)
16914     {
16915       if (thumb_mode)
16916         {
16917           as_warn (_("ARMv8.2 scalar fp16 instruction cannot be conditional,"
16918                      " the behaviour is UNPREDICTABLE"));
16919         }
16920       else
16921         {
16922           inst.error = BAD_COND;
16923           return;
16924         }
16925     }
16926
16927   do_vfp_sp_monadic ();
16928
16929   inst.is_neon = 1;
16930   inst.instruction |= 0xf0000000;
16931 }
16932
16933 static void
16934 do_neon_movl (void)
16935 {
16936   struct neon_type_el et = neon_check_type (2, NS_QD,
16937     N_EQK | N_DBL, N_SU_32 | N_KEY);
16938   unsigned sizebits = et.size >> 3;
16939   inst.instruction |= sizebits << 19;
16940   neon_two_same (0, et.type == NT_unsigned, -1);
16941 }
16942
16943 static void
16944 do_neon_trn (void)
16945 {
16946   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
16947   struct neon_type_el et = neon_check_type (2, rs,
16948     N_EQK, N_8 | N_16 | N_32 | N_KEY);
16949   NEON_ENCODE (INTEGER, inst);
16950   neon_two_same (neon_quad (rs), 1, et.size);
16951 }
16952
16953 static void
16954 do_neon_zip_uzp (void)
16955 {
16956   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
16957   struct neon_type_el et = neon_check_type (2, rs,
16958     N_EQK, N_8 | N_16 | N_32 | N_KEY);
16959   if (rs == NS_DD && et.size == 32)
16960     {
16961       /* Special case: encode as VTRN.32 <Dd>, <Dm>.  */
16962       inst.instruction = N_MNEM_vtrn;
16963       do_neon_trn ();
16964       return;
16965     }
16966   neon_two_same (neon_quad (rs), 1, et.size);
16967 }
16968
16969 static void
16970 do_neon_sat_abs_neg (void)
16971 {
16972   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
16973   struct neon_type_el et = neon_check_type (2, rs,
16974     N_EQK, N_S8 | N_S16 | N_S32 | N_KEY);
16975   neon_two_same (neon_quad (rs), 1, et.size);
16976 }
16977
16978 static void
16979 do_neon_pair_long (void)
16980 {
16981   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
16982   struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_32 | N_KEY);
16983   /* Unsigned is encoded in OP field (bit 7) for these instruction.  */
16984   inst.instruction |= (et.type == NT_unsigned) << 7;
16985   neon_two_same (neon_quad (rs), 1, et.size);
16986 }
16987
16988 static void
16989 do_neon_recip_est (void)
16990 {
16991   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
16992   struct neon_type_el et = neon_check_type (2, rs,
16993     N_EQK | N_FLT, N_F_16_32 | N_U32 | N_KEY);
16994   inst.instruction |= (et.type == NT_float) << 8;
16995   neon_two_same (neon_quad (rs), 1, et.size);
16996 }
16997
16998 static void
16999 do_neon_cls (void)
17000 {
17001   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
17002   struct neon_type_el et = neon_check_type (2, rs,
17003     N_EQK, N_S8 | N_S16 | N_S32 | N_KEY);
17004   neon_two_same (neon_quad (rs), 1, et.size);
17005 }
17006
17007 static void
17008 do_neon_clz (void)
17009 {
17010   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
17011   struct neon_type_el et = neon_check_type (2, rs,
17012     N_EQK, N_I8 | N_I16 | N_I32 | N_KEY);
17013   neon_two_same (neon_quad (rs), 1, et.size);
17014 }
17015
17016 static void
17017 do_neon_cnt (void)
17018 {
17019   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
17020   struct neon_type_el et = neon_check_type (2, rs,
17021     N_EQK | N_INT, N_8 | N_KEY);
17022   neon_two_same (neon_quad (rs), 1, et.size);
17023 }
17024
17025 static void
17026 do_neon_swp (void)
17027 {
17028   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
17029   neon_two_same (neon_quad (rs), 1, -1);
17030 }
17031
17032 static void
17033 do_neon_tbl_tbx (void)
17034 {
17035   unsigned listlenbits;
17036   neon_check_type (3, NS_DLD, N_EQK, N_EQK, N_8 | N_KEY);
17037
17038   if (inst.operands[1].imm < 1 || inst.operands[1].imm > 4)
17039     {
17040       first_error (_("bad list length for table lookup"));
17041       return;
17042     }
17043
17044   listlenbits = inst.operands[1].imm - 1;
17045   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
17046   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
17047   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
17048   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
17049   inst.instruction |= LOW4 (inst.operands[2].reg);
17050   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
17051   inst.instruction |= listlenbits << 8;
17052
17053   neon_dp_fixup (&inst);
17054 }
17055
17056 static void
17057 do_neon_ldm_stm (void)
17058 {
17059   /* P, U and L bits are part of bitmask.  */
17060   int is_dbmode = (inst.instruction & (1 << 24)) != 0;
17061   unsigned offsetbits = inst.operands[1].imm * 2;
17062
17063   if (inst.operands[1].issingle)
17064     {
17065       do_vfp_nsyn_ldm_stm (is_dbmode);
17066       return;
17067     }
17068
17069   constraint (is_dbmode && !inst.operands[0].writeback,
17070               _("writeback (!) must be used for VLDMDB and VSTMDB"));
17071
17072   constraint (inst.operands[1].imm < 1 || inst.operands[1].imm > 16,
17073               _("register list must contain at least 1 and at most 16 "
17074                 "registers"));
17075
17076   inst.instruction |= inst.operands[0].reg << 16;
17077   inst.instruction |= inst.operands[0].writeback << 21;
17078   inst.instruction |= LOW4 (inst.operands[1].reg) << 12;
17079   inst.instruction |= HI1 (inst.operands[1].reg) << 22;
17080
17081   inst.instruction |= offsetbits;
17082
17083   do_vfp_cond_or_thumb ();
17084 }
17085
17086 static void
17087 do_neon_ldr_str (void)
17088 {
17089   int is_ldr = (inst.instruction & (1 << 20)) != 0;
17090
17091   /* Use of PC in vstr in ARM mode is deprecated in ARMv7.
17092      And is UNPREDICTABLE in thumb mode.  */
17093   if (!is_ldr
17094       && inst.operands[1].reg == REG_PC
17095       && (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v7) || thumb_mode))
17096     {
17097       if (thumb_mode)
17098         inst.error = _("Use of PC here is UNPREDICTABLE");
17099       else if (warn_on_deprecated)
17100         as_tsktsk (_("Use of PC here is deprecated"));
17101     }
17102
17103   if (inst.operands[0].issingle)
17104     {
17105       if (is_ldr)
17106         do_vfp_nsyn_opcode ("flds");
17107       else
17108         do_vfp_nsyn_opcode ("fsts");
17109
17110       /* ARMv8.2 vldr.16/vstr.16 instruction.  */
17111       if (inst.vectype.el[0].size == 16)
17112         do_scalar_fp16_v82_encode ();
17113     }
17114   else
17115     {
17116       if (is_ldr)
17117         do_vfp_nsyn_opcode ("fldd");
17118       else
17119         do_vfp_nsyn_opcode ("fstd");
17120     }
17121 }
17122
17123 /* "interleave" version also handles non-interleaving register VLD1/VST1
17124    instructions.  */
17125
17126 static void
17127 do_neon_ld_st_interleave (void)
17128 {
17129   struct neon_type_el et = neon_check_type (1, NS_NULL,
17130                                             N_8 | N_16 | N_32 | N_64);
17131   unsigned alignbits = 0;
17132   unsigned idx;
17133   /* The bits in this table go:
17134      0: register stride of one (0) or two (1)
17135      1,2: register list length, minus one (1, 2, 3, 4).
17136      3,4: <n> in instruction type, minus one (VLD<n> / VST<n>).
17137      We use -1 for invalid entries.  */
17138   const int typetable[] =
17139     {
17140       0x7,  -1, 0xa,  -1, 0x6,  -1, 0x2,  -1, /* VLD1 / VST1.  */
17141        -1,  -1, 0x8, 0x9,  -1,  -1, 0x3,  -1, /* VLD2 / VST2.  */
17142        -1,  -1,  -1,  -1, 0x4, 0x5,  -1,  -1, /* VLD3 / VST3.  */
17143        -1,  -1,  -1,  -1,  -1,  -1, 0x0, 0x1  /* VLD4 / VST4.  */
17144     };
17145   int typebits;
17146
17147   if (et.type == NT_invtype)
17148     return;
17149
17150   if (inst.operands[1].immisalign)
17151     switch (inst.operands[1].imm >> 8)
17152       {
17153       case 64: alignbits = 1; break;
17154       case 128:
17155         if (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 2
17156             && NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4)
17157           goto bad_alignment;
17158         alignbits = 2;
17159         break;
17160       case 256:
17161         if (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4)
17162           goto bad_alignment;
17163         alignbits = 3;
17164         break;
17165       default:
17166       bad_alignment:
17167         first_error (_("bad alignment"));
17168         return;
17169       }
17170
17171   inst.instruction |= alignbits << 4;
17172   inst.instruction |= neon_logbits (et.size) << 6;
17173
17174   /* Bits [4:6] of the immediate in a list specifier encode register stride
17175      (minus 1) in bit 4, and list length in bits [5:6]. We put the <n> of
17176      VLD<n>/VST<n> in bits [9:8] of the initial bitmask. Suck it out here, look
17177      up the right value for "type" in a table based on this value and the given
17178      list style, then stick it back.  */
17179   idx = ((inst.operands[0].imm >> 4) & 7)
17180         | (((inst.instruction >> 8) & 3) << 3);
17181
17182   typebits = typetable[idx];
17183
17184   constraint (typebits == -1, _("bad list type for instruction"));
17185   constraint (((inst.instruction >> 8) & 3) && et.size == 64,
17186               _("bad element type for instruction"));
17187
17188   inst.instruction &= ~0xf00;
17189   inst.instruction |= typebits << 8;
17190 }
17191
17192 /* Check alignment is valid for do_neon_ld_st_lane and do_neon_ld_dup.
17193    *DO_ALIGN is set to 1 if the relevant alignment bit should be set, 0
17194    otherwise. The variable arguments are a list of pairs of legal (size, align)
17195    values, terminated with -1.  */
17196
17197 static int
17198 neon_alignment_bit (int size, int align, int *do_alignment, ...)
17199 {
17200   va_list ap;
17201   int result = FAIL, thissize, thisalign;
17202
17203   if (!inst.operands[1].immisalign)
17204     {
17205       *do_alignment = 0;
17206       return SUCCESS;
17207     }
17208
17209   va_start (ap, do_alignment);
17210
17211   do
17212     {
17213       thissize = va_arg (ap, int);
17214       if (thissize == -1)
17215         break;
17216       thisalign = va_arg (ap, int);
17217
17218       if (size == thissize && align == thisalign)
17219         result = SUCCESS;
17220     }
17221   while (result != SUCCESS);
17222
17223   va_end (ap);
17224
17225   if (result == SUCCESS)
17226     *do_alignment = 1;
17227   else
17228     first_error (_("unsupported alignment for instruction"));
17229
17230   return result;
17231 }
17232
17233 static void
17234 do_neon_ld_st_lane (void)
17235 {
17236   struct neon_type_el et = neon_check_type (1, NS_NULL, N_8 | N_16 | N_32);
17237   int align_good, do_alignment = 0;
17238   int logsize = neon_logbits (et.size);
17239   int align = inst.operands[1].imm >> 8;
17240   int n = (inst.instruction >> 8) & 3;
17241   int max_el = 64 / et.size;
17242
17243   if (et.type == NT_invtype)
17244     return;
17245
17246   constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != n + 1,
17247               _("bad list length"));
17248   constraint (NEON_LANE (inst.operands[0].imm) >= max_el,
17249               _("scalar index out of range"));
17250   constraint (n != 0 && NEON_REG_STRIDE (inst.operands[0].imm) == 2
17251               && et.size == 8,
17252               _("stride of 2 unavailable when element size is 8"));
17253
17254   switch (n)
17255     {
17256     case 0:  /* VLD1 / VST1.  */
17257       align_good = neon_alignment_bit (et.size, align, &do_alignment, 16, 16,
17258                                        32, 32, -1);
17259       if (align_good == FAIL)
17260         return;
17261       if (do_alignment)
17262         {
17263           unsigned alignbits = 0;
17264           switch (et.size)
17265             {
17266             case 16: alignbits = 0x1; break;
17267             case 32: alignbits = 0x3; break;
17268             default: ;
17269             }
17270           inst.instruction |= alignbits << 4;
17271         }
17272       break;
17273
17274     case 1:  /* VLD2 / VST2.  */
17275       align_good = neon_alignment_bit (et.size, align, &do_alignment, 8, 16,
17276                       16, 32, 32, 64, -1);
17277       if (align_good == FAIL)
17278         return;
17279       if (do_alignment)
17280         inst.instruction |= 1 << 4;
17281       break;
17282
17283     case 2:  /* VLD3 / VST3.  */
17284       constraint (inst.operands[1].immisalign,
17285                   _("can't use alignment with this instruction"));
17286       break;
17287
17288     case 3:  /* VLD4 / VST4.  */
17289       align_good = neon_alignment_bit (et.size, align, &do_alignment, 8, 32,
17290                                        16, 64, 32, 64, 32, 128, -1);
17291       if (align_good == FAIL)
17292         return;
17293       if (do_alignment)
17294         {
17295           unsigned alignbits = 0;
17296           switch (et.size)
17297             {
17298             case 8:  alignbits = 0x1; break;
17299             case 16: alignbits = 0x1; break;
17300             case 32: alignbits = (align == 64) ? 0x1 : 0x2; break;
17301             default: ;
17302             }
17303           inst.instruction |= alignbits << 4;
17304         }
17305       break;
17306
17307     default: ;
17308     }
17309
17310   /* Reg stride of 2 is encoded in bit 5 when size==16, bit 6 when size==32.  */
17311   if (n != 0 && NEON_REG_STRIDE (inst.operands[0].imm) == 2)
17312     inst.instruction |= 1 << (4 + logsize);
17313
17314   inst.instruction |= NEON_LANE (inst.operands[0].imm) << (logsize + 5);
17315   inst.instruction |= logsize << 10;
17316 }
17317
17318 /* Encode single n-element structure to all lanes VLD<n> instructions.  */
17319
17320 static void
17321 do_neon_ld_dup (void)
17322 {
17323   struct neon_type_el et = neon_check_type (1, NS_NULL, N_8 | N_16 | N_32);
17324   int align_good, do_alignment = 0;
17325
17326   if (et.type == NT_invtype)
17327     return;
17328
17329   switch ((inst.instruction >> 8) & 3)
17330     {
17331     case 0:  /* VLD1.  */
17332       gas_assert (NEON_REG_STRIDE (inst.operands[0].imm) != 2);
17333       align_good = neon_alignment_bit (et.size, inst.operands[1].imm >> 8,
17334                                        &do_alignment, 16, 16, 32, 32, -1);
17335       if (align_good == FAIL)
17336         return;
17337       switch (NEON_REGLIST_LENGTH (inst.operands[0].imm))
17338         {
17339         case 1: break;
17340         case 2: inst.instruction |= 1 << 5; break;
17341         default: first_error (_("bad list length")); return;
17342         }
17343       inst.instruction |= neon_logbits (et.size) << 6;
17344       break;
17345
17346     case 1:  /* VLD2.  */
17347       align_good = neon_alignment_bit (et.size, inst.operands[1].imm >> 8,
17348                                        &do_alignment, 8, 16, 16, 32, 32, 64,
17349                                        -1);
17350       if (align_good == FAIL)
17351         return;
17352       constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 2,
17353                   _("bad list length"));
17354       if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
17355         inst.instruction |= 1 << 5;
17356       inst.instruction |= neon_logbits (et.size) << 6;
17357       break;
17358
17359     case 2:  /* VLD3.  */
17360       constraint (inst.operands[1].immisalign,
17361                   _("can't use alignment with this instruction"));
17362       constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 3,
17363                   _("bad list length"));
17364       if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
17365         inst.instruction |= 1 << 5;
17366       inst.instruction |= neon_logbits (et.size) << 6;
17367       break;
17368
17369     case 3:  /* VLD4.  */
17370       {
17371         int align = inst.operands[1].imm >> 8;
17372         align_good = neon_alignment_bit (et.size, align, &do_alignment, 8, 32,
17373                                          16, 64, 32, 64, 32, 128, -1);
17374         if (align_good == FAIL)
17375           return;
17376         constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4,
17377                     _("bad list length"));
17378         if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
17379           inst.instruction |= 1 << 5;
17380         if (et.size == 32 && align == 128)
17381           inst.instruction |= 0x3 << 6;
17382         else
17383           inst.instruction |= neon_logbits (et.size) << 6;
17384       }
17385       break;
17386
17387     default: ;
17388     }
17389
17390   inst.instruction |= do_alignment << 4;
17391 }
17392
17393 /* Disambiguate VLD<n> and VST<n> instructions, and fill in common bits (those
17394    apart from bits [11:4].  */
17395
17396 static void
17397 do_neon_ldx_stx (void)
17398 {
17399   if (inst.operands[1].isreg)
17400     constraint (inst.operands[1].reg == REG_PC, BAD_PC);
17401
17402   switch (NEON_LANE (inst.operands[0].imm))
17403     {
17404     case NEON_INTERLEAVE_LANES:
17405       NEON_ENCODE (INTERLV, inst);
17406       do_neon_ld_st_interleave ();
17407       break;
17408
17409     case NEON_ALL_LANES:
17410       NEON_ENCODE (DUP, inst);
17411       if (inst.instruction == N_INV)
17412         {
17413           first_error ("only loads support such operands");
17414           break;
17415         }
17416       do_neon_ld_dup ();
17417       break;
17418
17419     default:
17420       NEON_ENCODE (LANE, inst);
17421       do_neon_ld_st_lane ();
17422     }
17423
17424   /* L bit comes from bit mask.  */
17425   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
17426   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
17427   inst.instruction |= inst.operands[1].reg << 16;
17428
17429   if (inst.operands[1].postind)
17430     {
17431       int postreg = inst.operands[1].imm & 0xf;
17432       constraint (!inst.operands[1].immisreg,
17433                   _("post-index must be a register"));
17434       constraint (postreg == 0xd || postreg == 0xf,
17435                   _("bad register for post-index"));
17436       inst.instruction |= postreg;
17437     }
17438   else
17439     {
17440       constraint (inst.operands[1].immisreg, BAD_ADDR_MODE);
17441       constraint (inst.relocs[0].exp.X_op != O_constant
17442                   || inst.relocs[0].exp.X_add_number != 0,
17443                   BAD_ADDR_MODE);
17444
17445       if (inst.operands[1].writeback)
17446         {
17447           inst.instruction |= 0xd;
17448         }
17449       else
17450         inst.instruction |= 0xf;
17451     }
17452
17453   if (thumb_mode)
17454     inst.instruction |= 0xf9000000;
17455   else
17456     inst.instruction |= 0xf4000000;
17457 }
17458
17459 /* FP v8.  */
17460 static void
17461 do_vfp_nsyn_fpv8 (enum neon_shape rs)
17462 {
17463   /* Targets like FPv5-SP-D16 don't support FP v8 instructions with
17464      D register operands.  */
17465   if (neon_shape_class[rs] == SC_DOUBLE)
17466     constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
17467                 _(BAD_FPU));
17468
17469   NEON_ENCODE (FPV8, inst);
17470
17471   if (rs == NS_FFF || rs == NS_HHH)
17472     {
17473       do_vfp_sp_dyadic ();
17474
17475       /* ARMv8.2 fp16 instruction.  */
17476       if (rs == NS_HHH)
17477         do_scalar_fp16_v82_encode ();
17478     }
17479   else
17480     do_vfp_dp_rd_rn_rm ();
17481
17482   if (rs == NS_DDD)
17483     inst.instruction |= 0x100;
17484
17485   inst.instruction |= 0xf0000000;
17486 }
17487
17488 static void
17489 do_vsel (void)
17490 {
17491   set_it_insn_type (OUTSIDE_IT_INSN);
17492
17493   if (try_vfp_nsyn (3, do_vfp_nsyn_fpv8) != SUCCESS)
17494     first_error (_("invalid instruction shape"));
17495 }
17496
17497 static void
17498 do_vmaxnm (void)
17499 {
17500   set_it_insn_type (OUTSIDE_IT_INSN);
17501
17502   if (try_vfp_nsyn (3, do_vfp_nsyn_fpv8) == SUCCESS)
17503     return;
17504
17505   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH8) == FAIL)
17506     return;
17507
17508   neon_dyadic_misc (NT_untyped, N_F_16_32, 0);
17509 }
17510
17511 static void
17512 do_vrint_1 (enum neon_cvt_mode mode)
17513 {
17514   enum neon_shape rs = neon_select_shape (NS_HH, NS_FF, NS_DD, NS_QQ, NS_NULL);
17515   struct neon_type_el et;
17516
17517   if (rs == NS_NULL)
17518     return;
17519
17520   /* Targets like FPv5-SP-D16 don't support FP v8 instructions with
17521      D register operands.  */
17522   if (neon_shape_class[rs] == SC_DOUBLE)
17523     constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
17524                 _(BAD_FPU));
17525
17526   et = neon_check_type (2, rs, N_EQK | N_VFP, N_F_ALL | N_KEY
17527                         | N_VFP);
17528   if (et.type != NT_invtype)
17529     {
17530       /* VFP encodings.  */
17531       if (mode == neon_cvt_mode_a || mode == neon_cvt_mode_n
17532           || mode == neon_cvt_mode_p || mode == neon_cvt_mode_m)
17533         set_it_insn_type (OUTSIDE_IT_INSN);
17534
17535       NEON_ENCODE (FPV8, inst);
17536       if (rs == NS_FF || rs == NS_HH)
17537         do_vfp_sp_monadic ();
17538       else
17539         do_vfp_dp_rd_rm ();
17540
17541       switch (mode)
17542         {
17543         case neon_cvt_mode_r: inst.instruction |= 0x00000000; break;
17544         case neon_cvt_mode_z: inst.instruction |= 0x00000080; break;
17545         case neon_cvt_mode_x: inst.instruction |= 0x00010000; break;
17546         case neon_cvt_mode_a: inst.instruction |= 0xf0000000; break;
17547         case neon_cvt_mode_n: inst.instruction |= 0xf0010000; break;
17548         case neon_cvt_mode_p: inst.instruction |= 0xf0020000; break;
17549         case neon_cvt_mode_m: inst.instruction |= 0xf0030000; break;
17550         default: abort ();
17551         }
17552
17553       inst.instruction |= (rs == NS_DD) << 8;
17554       do_vfp_cond_or_thumb ();
17555
17556       /* ARMv8.2 fp16 vrint instruction.  */
17557       if (rs == NS_HH)
17558       do_scalar_fp16_v82_encode ();
17559     }
17560   else
17561     {
17562       /* Neon encodings (or something broken...).  */
17563       inst.error = NULL;
17564       et = neon_check_type (2, rs, N_EQK, N_F_16_32 | N_KEY);
17565
17566       if (et.type == NT_invtype)
17567         return;
17568
17569       set_it_insn_type (OUTSIDE_IT_INSN);
17570       NEON_ENCODE (FLOAT, inst);
17571
17572       if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH8) == FAIL)
17573         return;
17574
17575       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
17576       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
17577       inst.instruction |= LOW4 (inst.operands[1].reg);
17578       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
17579       inst.instruction |= neon_quad (rs) << 6;
17580       /* Mask off the original size bits and reencode them.  */
17581       inst.instruction = ((inst.instruction & 0xfff3ffff)
17582                           | neon_logbits (et.size) << 18);
17583
17584       switch (mode)
17585         {
17586         case neon_cvt_mode_z: inst.instruction |= 3 << 7; break;
17587         case neon_cvt_mode_x: inst.instruction |= 1 << 7; break;
17588         case neon_cvt_mode_a: inst.instruction |= 2 << 7; break;
17589         case neon_cvt_mode_n: inst.instruction |= 0 << 7; break;
17590         case neon_cvt_mode_p: inst.instruction |= 7 << 7; break;
17591         case neon_cvt_mode_m: inst.instruction |= 5 << 7; break;
17592         case neon_cvt_mode_r: inst.error = _("invalid rounding mode"); break;
17593         default: abort ();
17594         }
17595
17596       if (thumb_mode)
17597         inst.instruction |= 0xfc000000;
17598       else
17599         inst.instruction |= 0xf0000000;
17600     }
17601 }
17602
17603 static void
17604 do_vrintx (void)
17605 {
17606   do_vrint_1 (neon_cvt_mode_x);
17607 }
17608
17609 static void
17610 do_vrintz (void)
17611 {
17612   do_vrint_1 (neon_cvt_mode_z);
17613 }
17614
17615 static void
17616 do_vrintr (void)
17617 {
17618   do_vrint_1 (neon_cvt_mode_r);
17619 }
17620
17621 static void
17622 do_vrinta (void)
17623 {
17624   do_vrint_1 (neon_cvt_mode_a);
17625 }
17626
17627 static void
17628 do_vrintn (void)
17629 {
17630   do_vrint_1 (neon_cvt_mode_n);
17631 }
17632
17633 static void
17634 do_vrintp (void)
17635 {
17636   do_vrint_1 (neon_cvt_mode_p);
17637 }
17638
17639 static void
17640 do_vrintm (void)
17641 {
17642   do_vrint_1 (neon_cvt_mode_m);
17643 }
17644
17645 static unsigned
17646 neon_scalar_for_vcmla (unsigned opnd, unsigned elsize)
17647 {
17648   unsigned regno = NEON_SCALAR_REG (opnd);
17649   unsigned elno = NEON_SCALAR_INDEX (opnd);
17650
17651   if (elsize == 16 && elno < 2 && regno < 16)
17652     return regno | (elno << 4);
17653   else if (elsize == 32 && elno == 0)
17654     return regno;
17655
17656   first_error (_("scalar out of range"));
17657   return 0;
17658 }
17659
17660 static void
17661 do_vcmla (void)
17662 {
17663   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_armv8),
17664               _(BAD_FPU));
17665   constraint (inst.relocs[0].exp.X_op != O_constant,
17666               _("expression too complex"));
17667   unsigned rot = inst.relocs[0].exp.X_add_number;
17668   constraint (rot != 0 && rot != 90 && rot != 180 && rot != 270,
17669               _("immediate out of range"));
17670   rot /= 90;
17671   if (inst.operands[2].isscalar)
17672     {
17673       enum neon_shape rs = neon_select_shape (NS_DDSI, NS_QQSI, NS_NULL);
17674       unsigned size = neon_check_type (3, rs, N_EQK, N_EQK,
17675                                        N_KEY | N_F16 | N_F32).size;
17676       unsigned m = neon_scalar_for_vcmla (inst.operands[2].reg, size);
17677       inst.is_neon = 1;
17678       inst.instruction = 0xfe000800;
17679       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
17680       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
17681       inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
17682       inst.instruction |= HI1 (inst.operands[1].reg) << 7;
17683       inst.instruction |= LOW4 (m);
17684       inst.instruction |= HI1 (m) << 5;
17685       inst.instruction |= neon_quad (rs) << 6;
17686       inst.instruction |= rot << 20;
17687       inst.instruction |= (size == 32) << 23;
17688     }
17689   else
17690     {
17691       enum neon_shape rs = neon_select_shape (NS_DDDI, NS_QQQI, NS_NULL);
17692       unsigned size = neon_check_type (3, rs, N_EQK, N_EQK,
17693                                        N_KEY | N_F16 | N_F32).size;
17694       neon_three_same (neon_quad (rs), 0, -1);
17695       inst.instruction &= 0x00ffffff; /* Undo neon_dp_fixup.  */
17696       inst.instruction |= 0xfc200800;
17697       inst.instruction |= rot << 23;
17698       inst.instruction |= (size == 32) << 20;
17699     }
17700 }
17701
17702 static void
17703 do_vcadd (void)
17704 {
17705   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_armv8),
17706               _(BAD_FPU));
17707   constraint (inst.relocs[0].exp.X_op != O_constant,
17708               _("expression too complex"));
17709   unsigned rot = inst.relocs[0].exp.X_add_number;
17710   constraint (rot != 90 && rot != 270, _("immediate out of range"));
17711   enum neon_shape rs = neon_select_shape (NS_DDDI, NS_QQQI, NS_NULL);
17712   unsigned size = neon_check_type (3, rs, N_EQK, N_EQK,
17713                                    N_KEY | N_F16 | N_F32).size;
17714   neon_three_same (neon_quad (rs), 0, -1);
17715   inst.instruction &= 0x00ffffff; /* Undo neon_dp_fixup.  */
17716   inst.instruction |= 0xfc800800;
17717   inst.instruction |= (rot == 270) << 24;
17718   inst.instruction |= (size == 32) << 20;
17719 }
17720
17721 /* Dot Product instructions encoding support.  */
17722
17723 static void
17724 do_neon_dotproduct (int unsigned_p)
17725 {
17726   enum neon_shape rs;
17727   unsigned scalar_oprd2 = 0;
17728   int high8;
17729
17730   if (inst.cond != COND_ALWAYS)
17731     as_warn (_("Dot Product instructions cannot be conditional,  the behaviour "
17732                "is UNPREDICTABLE"));
17733
17734   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_armv8),
17735               _(BAD_FPU));
17736
17737   /* Dot Product instructions are in three-same D/Q register format or the third
17738      operand can be a scalar index register.  */
17739   if (inst.operands[2].isscalar)
17740     {
17741       scalar_oprd2 = neon_scalar_for_mul (inst.operands[2].reg, 32);
17742       high8 = 0xfe000000;
17743       rs = neon_select_shape (NS_DDS, NS_QQS, NS_NULL);
17744     }
17745   else
17746     {
17747       high8 = 0xfc000000;
17748       rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
17749     }
17750
17751   if (unsigned_p)
17752     neon_check_type (3, rs, N_EQK, N_EQK, N_KEY | N_U8);
17753   else
17754     neon_check_type (3, rs, N_EQK, N_EQK, N_KEY | N_S8);
17755
17756   /* The "U" bit in traditional Three Same encoding is fixed to 0 for Dot
17757      Product instruction, so we pass 0 as the "ubit" parameter.  And the
17758      "Size" field are fixed to 0x2, so we pass 32 as the "size" parameter.  */
17759   neon_three_same (neon_quad (rs), 0, 32);
17760
17761   /* Undo neon_dp_fixup.  Dot Product instructions are using a slightly
17762      different NEON three-same encoding.  */
17763   inst.instruction &= 0x00ffffff;
17764   inst.instruction |= high8;
17765   /* Encode 'U' bit which indicates signedness.  */
17766   inst.instruction |= (unsigned_p ? 1 : 0) << 4;
17767   /* Re-encode operand2 if it's indexed scalar operand.  What has been encoded
17768      from inst.operand[2].reg in neon_three_same is GAS's internal encoding, not
17769      the instruction encoding.  */
17770   if (inst.operands[2].isscalar)
17771     {
17772       inst.instruction &= 0xffffffd0;
17773       inst.instruction |= LOW4 (scalar_oprd2);
17774       inst.instruction |= HI1 (scalar_oprd2) << 5;
17775     }
17776 }
17777
17778 /* Dot Product instructions for signed integer.  */
17779
17780 static void
17781 do_neon_dotproduct_s (void)
17782 {
17783   return do_neon_dotproduct (0);
17784 }
17785
17786 /* Dot Product instructions for unsigned integer.  */
17787
17788 static void
17789 do_neon_dotproduct_u (void)
17790 {
17791   return do_neon_dotproduct (1);
17792 }
17793
17794 /* Crypto v1 instructions.  */
17795 static void
17796 do_crypto_2op_1 (unsigned elttype, int op)
17797 {
17798   set_it_insn_type (OUTSIDE_IT_INSN);
17799
17800   if (neon_check_type (2, NS_QQ, N_EQK | N_UNT, elttype | N_UNT | N_KEY).type
17801       == NT_invtype)
17802     return;
17803
17804   inst.error = NULL;
17805
17806   NEON_ENCODE (INTEGER, inst);
17807   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
17808   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
17809   inst.instruction |= LOW4 (inst.operands[1].reg);
17810   inst.instruction |= HI1 (inst.operands[1].reg) << 5;
17811   if (op != -1)
17812     inst.instruction |= op << 6;
17813
17814   if (thumb_mode)
17815     inst.instruction |= 0xfc000000;
17816   else
17817     inst.instruction |= 0xf0000000;
17818 }
17819
17820 static void
17821 do_crypto_3op_1 (int u, int op)
17822 {
17823   set_it_insn_type (OUTSIDE_IT_INSN);
17824
17825   if (neon_check_type (3, NS_QQQ, N_EQK | N_UNT, N_EQK | N_UNT,
17826                        N_32 | N_UNT | N_KEY).type == NT_invtype)
17827     return;
17828
17829   inst.error = NULL;
17830
17831   NEON_ENCODE (INTEGER, inst);
17832   neon_three_same (1, u, 8 << op);
17833 }
17834
17835 static void
17836 do_aese (void)
17837 {
17838   do_crypto_2op_1 (N_8, 0);
17839 }
17840
17841 static void
17842 do_aesd (void)
17843 {
17844   do_crypto_2op_1 (N_8, 1);
17845 }
17846
17847 static void
17848 do_aesmc (void)
17849 {
17850   do_crypto_2op_1 (N_8, 2);
17851 }
17852
17853 static void
17854 do_aesimc (void)
17855 {
17856   do_crypto_2op_1 (N_8, 3);
17857 }
17858
17859 static void
17860 do_sha1c (void)
17861 {
17862   do_crypto_3op_1 (0, 0);
17863 }
17864
17865 static void
17866 do_sha1p (void)
17867 {
17868   do_crypto_3op_1 (0, 1);
17869 }
17870
17871 static void
17872 do_sha1m (void)
17873 {
17874   do_crypto_3op_1 (0, 2);
17875 }
17876
17877 static void
17878 do_sha1su0 (void)
17879 {
17880   do_crypto_3op_1 (0, 3);
17881 }
17882
17883 static void
17884 do_sha256h (void)
17885 {
17886   do_crypto_3op_1 (1, 0);
17887 }
17888
17889 static void
17890 do_sha256h2 (void)
17891 {
17892   do_crypto_3op_1 (1, 1);
17893 }
17894
17895 static void
17896 do_sha256su1 (void)
17897 {
17898   do_crypto_3op_1 (1, 2);
17899 }
17900
17901 static void
17902 do_sha1h (void)
17903 {
17904   do_crypto_2op_1 (N_32, -1);
17905 }
17906
17907 static void
17908 do_sha1su1 (void)
17909 {
17910   do_crypto_2op_1 (N_32, 0);
17911 }
17912
17913 static void
17914 do_sha256su0 (void)
17915 {
17916   do_crypto_2op_1 (N_32, 1);
17917 }
17918
17919 static void
17920 do_crc32_1 (unsigned int poly, unsigned int sz)
17921 {
17922   unsigned int Rd = inst.operands[0].reg;
17923   unsigned int Rn = inst.operands[1].reg;
17924   unsigned int Rm = inst.operands[2].reg;
17925
17926   set_it_insn_type (OUTSIDE_IT_INSN);
17927   inst.instruction |= LOW4 (Rd) << (thumb_mode ? 8 : 12);
17928   inst.instruction |= LOW4 (Rn) << 16;
17929   inst.instruction |= LOW4 (Rm);
17930   inst.instruction |= sz << (thumb_mode ? 4 : 21);
17931   inst.instruction |= poly << (thumb_mode ? 20 : 9);
17932
17933   if (Rd == REG_PC || Rn == REG_PC || Rm == REG_PC)
17934     as_warn (UNPRED_REG ("r15"));
17935 }
17936
17937 static void
17938 do_crc32b (void)
17939 {
17940   do_crc32_1 (0, 0);
17941 }
17942
17943 static void
17944 do_crc32h (void)
17945 {
17946   do_crc32_1 (0, 1);
17947 }
17948
17949 static void
17950 do_crc32w (void)
17951 {
17952   do_crc32_1 (0, 2);
17953 }
17954
17955 static void
17956 do_crc32cb (void)
17957 {
17958   do_crc32_1 (1, 0);
17959 }
17960
17961 static void
17962 do_crc32ch (void)
17963 {
17964   do_crc32_1 (1, 1);
17965 }
17966
17967 static void
17968 do_crc32cw (void)
17969 {
17970   do_crc32_1 (1, 2);
17971 }
17972
17973 static void
17974 do_vjcvt (void)
17975 {
17976   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
17977               _(BAD_FPU));
17978   neon_check_type (2, NS_FD, N_S32, N_F64);
17979   do_vfp_sp_dp_cvt ();
17980   do_vfp_cond_or_thumb ();
17981 }
17982
17983 \f
17984 /* Overall per-instruction processing.  */
17985
17986 /* We need to be able to fix up arbitrary expressions in some statements.
17987    This is so that we can handle symbols that are an arbitrary distance from
17988    the pc.  The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
17989    which returns part of an address in a form which will be valid for
17990    a data instruction.  We do this by pushing the expression into a symbol
17991    in the expr_section, and creating a fix for that.  */
17992
17993 static void
17994 fix_new_arm (fragS *       frag,
17995              int           where,
17996              short int     size,
17997              expressionS * exp,
17998              int           pc_rel,
17999              int           reloc)
18000 {
18001   fixS *           new_fix;
18002
18003   switch (exp->X_op)
18004     {
18005     case O_constant:
18006       if (pc_rel)
18007         {
18008           /* Create an absolute valued symbol, so we have something to
18009              refer to in the object file.  Unfortunately for us, gas's
18010              generic expression parsing will already have folded out
18011              any use of .set foo/.type foo %function that may have
18012              been used to set type information of the target location,
18013              that's being specified symbolically.  We have to presume
18014              the user knows what they are doing.  */
18015           char name[16 + 8];
18016           symbolS *symbol;
18017
18018           sprintf (name, "*ABS*0x%lx", (unsigned long)exp->X_add_number);
18019
18020           symbol = symbol_find_or_make (name);
18021           S_SET_SEGMENT (symbol, absolute_section);
18022           symbol_set_frag (symbol, &zero_address_frag);
18023           S_SET_VALUE (symbol, exp->X_add_number);
18024           exp->X_op = O_symbol;
18025           exp->X_add_symbol = symbol;
18026           exp->X_add_number = 0;
18027         }
18028       /* FALLTHROUGH */
18029     case O_symbol:
18030     case O_add:
18031     case O_subtract:
18032       new_fix = fix_new_exp (frag, where, size, exp, pc_rel,
18033                              (enum bfd_reloc_code_real) reloc);
18034       break;
18035
18036     default:
18037       new_fix = (fixS *) fix_new (frag, where, size, make_expr_symbol (exp), 0,
18038                                   pc_rel, (enum bfd_reloc_code_real) reloc);
18039       break;
18040     }
18041
18042   /* Mark whether the fix is to a THUMB instruction, or an ARM
18043      instruction.  */
18044   new_fix->tc_fix_data = thumb_mode;
18045 }
18046
18047 /* Create a frg for an instruction requiring relaxation.  */
18048 static void
18049 output_relax_insn (void)
18050 {
18051   char * to;
18052   symbolS *sym;
18053   int offset;
18054
18055   /* The size of the instruction is unknown, so tie the debug info to the
18056      start of the instruction.  */
18057   dwarf2_emit_insn (0);
18058
18059   switch (inst.relocs[0].exp.X_op)
18060     {
18061     case O_symbol:
18062       sym = inst.relocs[0].exp.X_add_symbol;
18063       offset = inst.relocs[0].exp.X_add_number;
18064       break;
18065     case O_constant:
18066       sym = NULL;
18067       offset = inst.relocs[0].exp.X_add_number;
18068       break;
18069     default:
18070       sym = make_expr_symbol (&inst.relocs[0].exp);
18071       offset = 0;
18072       break;
18073   }
18074   to = frag_var (rs_machine_dependent, INSN_SIZE, THUMB_SIZE,
18075                  inst.relax, sym, offset, NULL/*offset, opcode*/);
18076   md_number_to_chars (to, inst.instruction, THUMB_SIZE);
18077 }
18078
18079 /* Write a 32-bit thumb instruction to buf.  */
18080 static void
18081 put_thumb32_insn (char * buf, unsigned long insn)
18082 {
18083   md_number_to_chars (buf, insn >> 16, THUMB_SIZE);
18084   md_number_to_chars (buf + THUMB_SIZE, insn, THUMB_SIZE);
18085 }
18086
18087 static void
18088 output_inst (const char * str)
18089 {
18090   char * to = NULL;
18091
18092   if (inst.error)
18093     {
18094       as_bad ("%s -- `%s'", inst.error, str);
18095       return;
18096     }
18097   if (inst.relax)
18098     {
18099       output_relax_insn ();
18100       return;
18101     }
18102   if (inst.size == 0)
18103     return;
18104
18105   to = frag_more (inst.size);
18106   /* PR 9814: Record the thumb mode into the current frag so that we know
18107      what type of NOP padding to use, if necessary.  We override any previous
18108      setting so that if the mode has changed then the NOPS that we use will
18109      match the encoding of the last instruction in the frag.  */
18110   frag_now->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
18111
18112   if (thumb_mode && (inst.size > THUMB_SIZE))
18113     {
18114       gas_assert (inst.size == (2 * THUMB_SIZE));
18115       put_thumb32_insn (to, inst.instruction);
18116     }
18117   else if (inst.size > INSN_SIZE)
18118     {
18119       gas_assert (inst.size == (2 * INSN_SIZE));
18120       md_number_to_chars (to, inst.instruction, INSN_SIZE);
18121       md_number_to_chars (to + INSN_SIZE, inst.instruction, INSN_SIZE);
18122     }
18123   else
18124     md_number_to_chars (to, inst.instruction, inst.size);
18125
18126   int r;
18127   for (r = 0; r < ARM_IT_MAX_RELOCS; r++)
18128     {
18129       if (inst.relocs[r].type != BFD_RELOC_UNUSED)
18130         fix_new_arm (frag_now, to - frag_now->fr_literal,
18131                      inst.size, & inst.relocs[r].exp, inst.relocs[r].pc_rel,
18132                      inst.relocs[r].type);
18133     }
18134
18135   dwarf2_emit_insn (inst.size);
18136 }
18137
18138 static char *
18139 output_it_inst (int cond, int mask, char * to)
18140 {
18141   unsigned long instruction = 0xbf00;
18142
18143   mask &= 0xf;
18144   instruction |= mask;
18145   instruction |= cond << 4;
18146
18147   if (to == NULL)
18148     {
18149       to = frag_more (2);
18150 #ifdef OBJ_ELF
18151       dwarf2_emit_insn (2);
18152 #endif
18153     }
18154
18155   md_number_to_chars (to, instruction, 2);
18156
18157   return to;
18158 }
18159
18160 /* Tag values used in struct asm_opcode's tag field.  */
18161 enum opcode_tag
18162 {
18163   OT_unconditional,     /* Instruction cannot be conditionalized.
18164                            The ARM condition field is still 0xE.  */
18165   OT_unconditionalF,    /* Instruction cannot be conditionalized
18166                            and carries 0xF in its ARM condition field.  */
18167   OT_csuffix,           /* Instruction takes a conditional suffix.  */
18168   OT_csuffixF,          /* Some forms of the instruction take a conditional
18169                            suffix, others place 0xF where the condition field
18170                            would be.  */
18171   OT_cinfix3,           /* Instruction takes a conditional infix,
18172                            beginning at character index 3.  (In
18173                            unified mode, it becomes a suffix.)  */
18174   OT_cinfix3_deprecated, /* The same as OT_cinfix3.  This is used for
18175                             tsts, cmps, cmns, and teqs. */
18176   OT_cinfix3_legacy,    /* Legacy instruction takes a conditional infix at
18177                            character index 3, even in unified mode.  Used for
18178                            legacy instructions where suffix and infix forms
18179                            may be ambiguous.  */
18180   OT_csuf_or_in3,       /* Instruction takes either a conditional
18181                            suffix or an infix at character index 3.  */
18182   OT_odd_infix_unc,     /* This is the unconditional variant of an
18183                            instruction that takes a conditional infix
18184                            at an unusual position.  In unified mode,
18185                            this variant will accept a suffix.  */
18186   OT_odd_infix_0        /* Values greater than or equal to OT_odd_infix_0
18187                            are the conditional variants of instructions that
18188                            take conditional infixes in unusual positions.
18189                            The infix appears at character index
18190                            (tag - OT_odd_infix_0).  These are not accepted
18191                            in unified mode.  */
18192 };
18193
18194 /* Subroutine of md_assemble, responsible for looking up the primary
18195    opcode from the mnemonic the user wrote.  STR points to the
18196    beginning of the mnemonic.
18197
18198    This is not simply a hash table lookup, because of conditional
18199    variants.  Most instructions have conditional variants, which are
18200    expressed with a _conditional affix_ to the mnemonic.  If we were
18201    to encode each conditional variant as a literal string in the opcode
18202    table, it would have approximately 20,000 entries.
18203
18204    Most mnemonics take this affix as a suffix, and in unified syntax,
18205    'most' is upgraded to 'all'.  However, in the divided syntax, some
18206    instructions take the affix as an infix, notably the s-variants of
18207    the arithmetic instructions.  Of those instructions, all but six
18208    have the infix appear after the third character of the mnemonic.
18209
18210    Accordingly, the algorithm for looking up primary opcodes given
18211    an identifier is:
18212
18213    1. Look up the identifier in the opcode table.
18214       If we find a match, go to step U.
18215
18216    2. Look up the last two characters of the identifier in the
18217       conditions table.  If we find a match, look up the first N-2
18218       characters of the identifier in the opcode table.  If we
18219       find a match, go to step CE.
18220
18221    3. Look up the fourth and fifth characters of the identifier in
18222       the conditions table.  If we find a match, extract those
18223       characters from the identifier, and look up the remaining
18224       characters in the opcode table.  If we find a match, go
18225       to step CM.
18226
18227    4. Fail.
18228
18229    U. Examine the tag field of the opcode structure, in case this is
18230       one of the six instructions with its conditional infix in an
18231       unusual place.  If it is, the tag tells us where to find the
18232       infix; look it up in the conditions table and set inst.cond
18233       accordingly.  Otherwise, this is an unconditional instruction.
18234       Again set inst.cond accordingly.  Return the opcode structure.
18235
18236   CE. Examine the tag field to make sure this is an instruction that
18237       should receive a conditional suffix.  If it is not, fail.
18238       Otherwise, set inst.cond from the suffix we already looked up,
18239       and return the opcode structure.
18240
18241   CM. Examine the tag field to make sure this is an instruction that
18242       should receive a conditional infix after the third character.
18243       If it is not, fail.  Otherwise, undo the edits to the current
18244       line of input and proceed as for case CE.  */
18245
18246 static const struct asm_opcode *
18247 opcode_lookup (char **str)
18248 {
18249   char *end, *base;
18250   char *affix;
18251   const struct asm_opcode *opcode;
18252   const struct asm_cond *cond;
18253   char save[2];
18254
18255   /* Scan up to the end of the mnemonic, which must end in white space,
18256      '.' (in unified mode, or for Neon/VFP instructions), or end of string.  */
18257   for (base = end = *str; *end != '\0'; end++)
18258     if (*end == ' ' || *end == '.')
18259       break;
18260
18261   if (end == base)
18262     return NULL;
18263
18264   /* Handle a possible width suffix and/or Neon type suffix.  */
18265   if (end[0] == '.')
18266     {
18267       int offset = 2;
18268
18269       /* The .w and .n suffixes are only valid if the unified syntax is in
18270          use.  */
18271       if (unified_syntax && end[1] == 'w')
18272         inst.size_req = 4;
18273       else if (unified_syntax && end[1] == 'n')
18274         inst.size_req = 2;
18275       else
18276         offset = 0;
18277
18278       inst.vectype.elems = 0;
18279
18280       *str = end + offset;
18281
18282       if (end[offset] == '.')
18283         {
18284           /* See if we have a Neon type suffix (possible in either unified or
18285              non-unified ARM syntax mode).  */
18286           if (parse_neon_type (&inst.vectype, str) == FAIL)
18287             return NULL;
18288         }
18289       else if (end[offset] != '\0' && end[offset] != ' ')
18290         return NULL;
18291     }
18292   else
18293     *str = end;
18294
18295   /* Look for unaffixed or special-case affixed mnemonic.  */
18296   opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
18297                                                     end - base);
18298   if (opcode)
18299     {
18300       /* step U */
18301       if (opcode->tag < OT_odd_infix_0)
18302         {
18303           inst.cond = COND_ALWAYS;
18304           return opcode;
18305         }
18306
18307       if (warn_on_deprecated && unified_syntax)
18308         as_tsktsk (_("conditional infixes are deprecated in unified syntax"));
18309       affix = base + (opcode->tag - OT_odd_infix_0);
18310       cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
18311       gas_assert (cond);
18312
18313       inst.cond = cond->value;
18314       return opcode;
18315     }
18316
18317   /* Cannot have a conditional suffix on a mnemonic of less than two
18318      characters.  */
18319   if (end - base < 3)
18320     return NULL;
18321
18322   /* Look for suffixed mnemonic.  */
18323   affix = end - 2;
18324   cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
18325   opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
18326                                                     affix - base);
18327   if (opcode && cond)
18328     {
18329       /* step CE */
18330       switch (opcode->tag)
18331         {
18332         case OT_cinfix3_legacy:
18333           /* Ignore conditional suffixes matched on infix only mnemonics.  */
18334           break;
18335
18336         case OT_cinfix3:
18337         case OT_cinfix3_deprecated:
18338         case OT_odd_infix_unc:
18339           if (!unified_syntax)
18340             return NULL;
18341           /* Fall through.  */
18342
18343         case OT_csuffix:
18344         case OT_csuffixF:
18345         case OT_csuf_or_in3:
18346           inst.cond = cond->value;
18347           return opcode;
18348
18349         case OT_unconditional:
18350         case OT_unconditionalF:
18351           if (thumb_mode)
18352             inst.cond = cond->value;
18353           else
18354             {
18355               /* Delayed diagnostic.  */
18356               inst.error = BAD_COND;
18357               inst.cond = COND_ALWAYS;
18358             }
18359           return opcode;
18360
18361         default:
18362           return NULL;
18363         }
18364     }
18365
18366   /* Cannot have a usual-position infix on a mnemonic of less than
18367      six characters (five would be a suffix).  */
18368   if (end - base < 6)
18369     return NULL;
18370
18371   /* Look for infixed mnemonic in the usual position.  */
18372   affix = base + 3;
18373   cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
18374   if (!cond)
18375     return NULL;
18376
18377   memcpy (save, affix, 2);
18378   memmove (affix, affix + 2, (end - affix) - 2);
18379   opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
18380                                                     (end - base) - 2);
18381   memmove (affix + 2, affix, (end - affix) - 2);
18382   memcpy (affix, save, 2);
18383
18384   if (opcode
18385       && (opcode->tag == OT_cinfix3
18386           || opcode->tag == OT_cinfix3_deprecated
18387           || opcode->tag == OT_csuf_or_in3
18388           || opcode->tag == OT_cinfix3_legacy))
18389     {
18390       /* Step CM.  */
18391       if (warn_on_deprecated && unified_syntax
18392           && (opcode->tag == OT_cinfix3
18393               || opcode->tag == OT_cinfix3_deprecated))
18394         as_tsktsk (_("conditional infixes are deprecated in unified syntax"));
18395
18396       inst.cond = cond->value;
18397       return opcode;
18398     }
18399
18400   return NULL;
18401 }
18402
18403 /* This function generates an initial IT instruction, leaving its block
18404    virtually open for the new instructions. Eventually,
18405    the mask will be updated by now_it_add_mask () each time
18406    a new instruction needs to be included in the IT block.
18407    Finally, the block is closed with close_automatic_it_block ().
18408    The block closure can be requested either from md_assemble (),
18409    a tencode (), or due to a label hook.  */
18410
18411 static void
18412 new_automatic_it_block (int cond)
18413 {
18414   now_it.state = AUTOMATIC_IT_BLOCK;
18415   now_it.mask = 0x18;
18416   now_it.cc = cond;
18417   now_it.block_length = 1;
18418   mapping_state (MAP_THUMB);
18419   now_it.insn = output_it_inst (cond, now_it.mask, NULL);
18420   now_it.warn_deprecated = FALSE;
18421   now_it.insn_cond = TRUE;
18422 }
18423
18424 /* Close an automatic IT block.
18425    See comments in new_automatic_it_block ().  */
18426
18427 static void
18428 close_automatic_it_block (void)
18429 {
18430   now_it.mask = 0x10;
18431   now_it.block_length = 0;
18432 }
18433
18434 /* Update the mask of the current automatically-generated IT
18435    instruction. See comments in new_automatic_it_block ().  */
18436
18437 static void
18438 now_it_add_mask (int cond)
18439 {
18440 #define CLEAR_BIT(value, nbit)  ((value) & ~(1 << (nbit)))
18441 #define SET_BIT_VALUE(value, bitvalue, nbit)  (CLEAR_BIT (value, nbit) \
18442                                               | ((bitvalue) << (nbit)))
18443   const int resulting_bit = (cond & 1);
18444
18445   now_it.mask &= 0xf;
18446   now_it.mask = SET_BIT_VALUE (now_it.mask,
18447                                    resulting_bit,
18448                                   (5 - now_it.block_length));
18449   now_it.mask = SET_BIT_VALUE (now_it.mask,
18450                                    1,
18451                                    ((5 - now_it.block_length) - 1) );
18452   output_it_inst (now_it.cc, now_it.mask, now_it.insn);
18453
18454 #undef CLEAR_BIT
18455 #undef SET_BIT_VALUE
18456 }
18457
18458 /* The IT blocks handling machinery is accessed through the these functions:
18459      it_fsm_pre_encode ()               from md_assemble ()
18460      set_it_insn_type ()                optional, from the tencode functions
18461      set_it_insn_type_last ()           ditto
18462      in_it_block ()                     ditto
18463      it_fsm_post_encode ()              from md_assemble ()
18464      force_automatic_it_block_close ()  from label handling functions
18465
18466    Rationale:
18467      1) md_assemble () calls it_fsm_pre_encode () before calling tencode (),
18468         initializing the IT insn type with a generic initial value depending
18469         on the inst.condition.
18470      2) During the tencode function, two things may happen:
18471         a) The tencode function overrides the IT insn type by
18472            calling either set_it_insn_type (type) or set_it_insn_type_last ().
18473         b) The tencode function queries the IT block state by
18474            calling in_it_block () (i.e. to determine narrow/not narrow mode).
18475
18476         Both set_it_insn_type and in_it_block run the internal FSM state
18477         handling function (handle_it_state), because: a) setting the IT insn
18478         type may incur in an invalid state (exiting the function),
18479         and b) querying the state requires the FSM to be updated.
18480         Specifically we want to avoid creating an IT block for conditional
18481         branches, so it_fsm_pre_encode is actually a guess and we can't
18482         determine whether an IT block is required until the tencode () routine
18483         has decided what type of instruction this actually it.
18484         Because of this, if set_it_insn_type and in_it_block have to be used,
18485         set_it_insn_type has to be called first.
18486
18487         set_it_insn_type_last () is a wrapper of set_it_insn_type (type), that
18488         determines the insn IT type depending on the inst.cond code.
18489         When a tencode () routine encodes an instruction that can be
18490         either outside an IT block, or, in the case of being inside, has to be
18491         the last one, set_it_insn_type_last () will determine the proper
18492         IT instruction type based on the inst.cond code. Otherwise,
18493         set_it_insn_type can be called for overriding that logic or
18494         for covering other cases.
18495
18496         Calling handle_it_state () may not transition the IT block state to
18497         OUTSIDE_IT_BLOCK immediately, since the (current) state could be
18498         still queried. Instead, if the FSM determines that the state should
18499         be transitioned to OUTSIDE_IT_BLOCK, a flag is marked to be closed
18500         after the tencode () function: that's what it_fsm_post_encode () does.
18501
18502         Since in_it_block () calls the state handling function to get an
18503         updated state, an error may occur (due to invalid insns combination).
18504         In that case, inst.error is set.
18505         Therefore, inst.error has to be checked after the execution of
18506         the tencode () routine.
18507
18508      3) Back in md_assemble(), it_fsm_post_encode () is called to commit
18509         any pending state change (if any) that didn't take place in
18510         handle_it_state () as explained above.  */
18511
18512 static void
18513 it_fsm_pre_encode (void)
18514 {
18515   if (inst.cond != COND_ALWAYS)
18516     inst.it_insn_type = INSIDE_IT_INSN;
18517   else
18518     inst.it_insn_type = OUTSIDE_IT_INSN;
18519
18520   now_it.state_handled = 0;
18521 }
18522
18523 /* IT state FSM handling function.  */
18524
18525 static int
18526 handle_it_state (void)
18527 {
18528   now_it.state_handled = 1;
18529   now_it.insn_cond = FALSE;
18530
18531   switch (now_it.state)
18532     {
18533     case OUTSIDE_IT_BLOCK:
18534       switch (inst.it_insn_type)
18535         {
18536         case OUTSIDE_IT_INSN:
18537           break;
18538
18539         case INSIDE_IT_INSN:
18540         case INSIDE_IT_LAST_INSN:
18541           if (thumb_mode == 0)
18542             {
18543               if (unified_syntax
18544                   && !(implicit_it_mode & IMPLICIT_IT_MODE_ARM))
18545                 as_tsktsk (_("Warning: conditional outside an IT block"\
18546                              " for Thumb."));
18547             }
18548           else
18549             {
18550               if ((implicit_it_mode & IMPLICIT_IT_MODE_THUMB)
18551                   && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6t2))
18552                 {
18553                   /* Automatically generate the IT instruction.  */
18554                   new_automatic_it_block (inst.cond);
18555                   if (inst.it_insn_type == INSIDE_IT_LAST_INSN)
18556                     close_automatic_it_block ();
18557                 }
18558               else
18559                 {
18560                   inst.error = BAD_OUT_IT;
18561                   return FAIL;
18562                 }
18563             }
18564           break;
18565
18566         case IF_INSIDE_IT_LAST_INSN:
18567         case NEUTRAL_IT_INSN:
18568           break;
18569
18570         case IT_INSN:
18571           now_it.state = MANUAL_IT_BLOCK;
18572           now_it.block_length = 0;
18573           break;
18574         }
18575       break;
18576
18577     case AUTOMATIC_IT_BLOCK:
18578       /* Three things may happen now:
18579          a) We should increment current it block size;
18580          b) We should close current it block (closing insn or 4 insns);
18581          c) We should close current it block and start a new one (due
18582          to incompatible conditions or
18583          4 insns-length block reached).  */
18584
18585       switch (inst.it_insn_type)
18586         {
18587         case OUTSIDE_IT_INSN:
18588           /* The closure of the block shall happen immediately,
18589              so any in_it_block () call reports the block as closed.  */
18590           force_automatic_it_block_close ();
18591           break;
18592
18593         case INSIDE_IT_INSN:
18594         case INSIDE_IT_LAST_INSN:
18595         case IF_INSIDE_IT_LAST_INSN:
18596           now_it.block_length++;
18597
18598           if (now_it.block_length > 4
18599               || !now_it_compatible (inst.cond))
18600             {
18601               force_automatic_it_block_close ();
18602               if (inst.it_insn_type != IF_INSIDE_IT_LAST_INSN)
18603                 new_automatic_it_block (inst.cond);
18604             }
18605           else
18606             {
18607               now_it.insn_cond = TRUE;
18608               now_it_add_mask (inst.cond);
18609             }
18610
18611           if (now_it.state == AUTOMATIC_IT_BLOCK
18612               && (inst.it_insn_type == INSIDE_IT_LAST_INSN
18613                   || inst.it_insn_type == IF_INSIDE_IT_LAST_INSN))
18614             close_automatic_it_block ();
18615           break;
18616
18617         case NEUTRAL_IT_INSN:
18618           now_it.block_length++;
18619           now_it.insn_cond = TRUE;
18620
18621           if (now_it.block_length > 4)
18622             force_automatic_it_block_close ();
18623           else
18624             now_it_add_mask (now_it.cc & 1);
18625           break;
18626
18627         case IT_INSN:
18628           close_automatic_it_block ();
18629           now_it.state = MANUAL_IT_BLOCK;
18630           break;
18631         }
18632       break;
18633
18634     case MANUAL_IT_BLOCK:
18635       {
18636         /* Check conditional suffixes.  */
18637         const int cond = now_it.cc ^ ((now_it.mask >> 4) & 1) ^ 1;
18638         int is_last;
18639         now_it.mask <<= 1;
18640         now_it.mask &= 0x1f;
18641         is_last = (now_it.mask == 0x10);
18642         now_it.insn_cond = TRUE;
18643
18644         switch (inst.it_insn_type)
18645           {
18646           case OUTSIDE_IT_INSN:
18647             inst.error = BAD_NOT_IT;
18648             return FAIL;
18649
18650           case INSIDE_IT_INSN:
18651             if (cond != inst.cond)
18652               {
18653                 inst.error = BAD_IT_COND;
18654                 return FAIL;
18655               }
18656             break;
18657
18658           case INSIDE_IT_LAST_INSN:
18659           case IF_INSIDE_IT_LAST_INSN:
18660             if (cond != inst.cond)
18661               {
18662                 inst.error = BAD_IT_COND;
18663                 return FAIL;
18664               }
18665             if (!is_last)
18666               {
18667                 inst.error = BAD_BRANCH;
18668                 return FAIL;
18669               }
18670             break;
18671
18672           case NEUTRAL_IT_INSN:
18673             /* The BKPT instruction is unconditional even in an IT block.  */
18674             break;
18675
18676           case IT_INSN:
18677             inst.error = BAD_IT_IT;
18678             return FAIL;
18679           }
18680       }
18681       break;
18682     }
18683
18684   return SUCCESS;
18685 }
18686
18687 struct depr_insn_mask
18688 {
18689   unsigned long pattern;
18690   unsigned long mask;
18691   const char* description;
18692 };
18693
18694 /* List of 16-bit instruction patterns deprecated in an IT block in
18695    ARMv8.  */
18696 static const struct depr_insn_mask depr_it_insns[] = {
18697   { 0xc000, 0xc000, N_("Short branches, Undefined, SVC, LDM/STM") },
18698   { 0xb000, 0xb000, N_("Miscellaneous 16-bit instructions") },
18699   { 0xa000, 0xb800, N_("ADR") },
18700   { 0x4800, 0xf800, N_("Literal loads") },
18701   { 0x4478, 0xf478, N_("Hi-register ADD, MOV, CMP, BX, BLX using pc") },
18702   { 0x4487, 0xfc87, N_("Hi-register ADD, MOV, CMP using pc") },
18703   /* NOTE: 0x00dd is not the real encoding, instead, it is the 'tvalue'
18704      field in asm_opcode. 'tvalue' is used at the stage this check happen.  */
18705   { 0x00dd, 0x7fff, N_("ADD/SUB sp, sp #imm") },
18706   { 0, 0, NULL }
18707 };
18708
18709 static void
18710 it_fsm_post_encode (void)
18711 {
18712   int is_last;
18713
18714   if (!now_it.state_handled)
18715     handle_it_state ();
18716
18717   if (now_it.insn_cond
18718       && !now_it.warn_deprecated
18719       && warn_on_deprecated
18720       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8)
18721       && !ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_m))
18722     {
18723       if (inst.instruction >= 0x10000)
18724         {
18725           as_tsktsk (_("IT blocks containing 32-bit Thumb instructions are "
18726                      "performance deprecated in ARMv8-A and ARMv8-R"));
18727           now_it.warn_deprecated = TRUE;
18728         }
18729       else
18730         {
18731           const struct depr_insn_mask *p = depr_it_insns;
18732
18733           while (p->mask != 0)
18734             {
18735               if ((inst.instruction & p->mask) == p->pattern)
18736                 {
18737                   as_tsktsk (_("IT blocks containing 16-bit Thumb "
18738                                "instructions of the following class are "
18739                                "performance deprecated in ARMv8-A and "
18740                                "ARMv8-R: %s"), p->description);
18741                   now_it.warn_deprecated = TRUE;
18742                   break;
18743                 }
18744
18745               ++p;
18746             }
18747         }
18748
18749       if (now_it.block_length > 1)
18750         {
18751           as_tsktsk (_("IT blocks containing more than one conditional "
18752                      "instruction are performance deprecated in ARMv8-A and "
18753                      "ARMv8-R"));
18754           now_it.warn_deprecated = TRUE;
18755         }
18756     }
18757
18758   is_last = (now_it.mask == 0x10);
18759   if (is_last)
18760     {
18761       now_it.state = OUTSIDE_IT_BLOCK;
18762       now_it.mask = 0;
18763     }
18764 }
18765
18766 static void
18767 force_automatic_it_block_close (void)
18768 {
18769   if (now_it.state == AUTOMATIC_IT_BLOCK)
18770     {
18771       close_automatic_it_block ();
18772       now_it.state = OUTSIDE_IT_BLOCK;
18773       now_it.mask = 0;
18774     }
18775 }
18776
18777 static int
18778 in_it_block (void)
18779 {
18780   if (!now_it.state_handled)
18781     handle_it_state ();
18782
18783   return now_it.state != OUTSIDE_IT_BLOCK;
18784 }
18785
18786 /* Whether OPCODE only has T32 encoding.  Since this function is only used by
18787    t32_insn_ok, OPCODE enabled by v6t2 extension bit do not need to be listed
18788    here, hence the "known" in the function name.  */
18789
18790 static bfd_boolean
18791 known_t32_only_insn (const struct asm_opcode *opcode)
18792 {
18793   /* Original Thumb-1 wide instruction.  */
18794   if (opcode->tencode == do_t_blx
18795       || opcode->tencode == do_t_branch23
18796       || ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_msr)
18797       || ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_barrier))
18798     return TRUE;
18799
18800   /* Wide-only instruction added to ARMv8-M Baseline.  */
18801   if (ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_v8m_m_only)
18802       || ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_atomics)
18803       || ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_v6t2_v8m)
18804       || ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_div))
18805     return TRUE;
18806
18807   return FALSE;
18808 }
18809
18810 /* Whether wide instruction variant can be used if available for a valid OPCODE
18811    in ARCH.  */
18812
18813 static bfd_boolean
18814 t32_insn_ok (arm_feature_set arch, const struct asm_opcode *opcode)
18815 {
18816   if (known_t32_only_insn (opcode))
18817     return TRUE;
18818
18819   /* Instruction with narrow and wide encoding added to ARMv8-M.  Availability
18820      of variant T3 of B.W is checked in do_t_branch.  */
18821   if (ARM_CPU_HAS_FEATURE (arch, arm_ext_v8m)
18822       && opcode->tencode == do_t_branch)
18823     return TRUE;
18824
18825   /* MOV accepts T1/T3 encodings under Baseline, T3 encoding is 32bit.  */
18826   if (ARM_CPU_HAS_FEATURE (arch, arm_ext_v8m)
18827       && opcode->tencode == do_t_mov_cmp
18828       /* Make sure CMP instruction is not affected.  */
18829       && opcode->aencode == do_mov)
18830     return TRUE;
18831
18832   /* Wide instruction variants of all instructions with narrow *and* wide
18833      variants become available with ARMv6t2.  Other opcodes are either
18834      narrow-only or wide-only and are thus available if OPCODE is valid.  */
18835   if (ARM_CPU_HAS_FEATURE (arch, arm_ext_v6t2))
18836     return TRUE;
18837
18838   /* OPCODE with narrow only instruction variant or wide variant not
18839      available.  */
18840   return FALSE;
18841 }
18842
18843 void
18844 md_assemble (char *str)
18845 {
18846   char *p = str;
18847   const struct asm_opcode * opcode;
18848
18849   /* Align the previous label if needed.  */
18850   if (last_label_seen != NULL)
18851     {
18852       symbol_set_frag (last_label_seen, frag_now);
18853       S_SET_VALUE (last_label_seen, (valueT) frag_now_fix ());
18854       S_SET_SEGMENT (last_label_seen, now_seg);
18855     }
18856
18857   memset (&inst, '\0', sizeof (inst));
18858   int r;
18859   for (r = 0; r < ARM_IT_MAX_RELOCS; r++)
18860     inst.relocs[r].type = BFD_RELOC_UNUSED;
18861
18862   opcode = opcode_lookup (&p);
18863   if (!opcode)
18864     {
18865       /* It wasn't an instruction, but it might be a register alias of
18866          the form alias .req reg, or a Neon .dn/.qn directive.  */
18867       if (! create_register_alias (str, p)
18868           && ! create_neon_reg_alias (str, p))
18869         as_bad (_("bad instruction `%s'"), str);
18870
18871       return;
18872     }
18873
18874   if (warn_on_deprecated && opcode->tag == OT_cinfix3_deprecated)
18875     as_tsktsk (_("s suffix on comparison instruction is deprecated"));
18876
18877   /* The value which unconditional instructions should have in place of the
18878      condition field.  */
18879   inst.uncond_value = (opcode->tag == OT_csuffixF) ? 0xf : -1;
18880
18881   if (thumb_mode)
18882     {
18883       arm_feature_set variant;
18884
18885       variant = cpu_variant;
18886       /* Only allow coprocessor instructions on Thumb-2 capable devices.  */
18887       if (!ARM_CPU_HAS_FEATURE (variant, arm_arch_t2))
18888         ARM_CLEAR_FEATURE (variant, variant, fpu_any_hard);
18889       /* Check that this instruction is supported for this CPU.  */
18890       if (!opcode->tvariant
18891           || (thumb_mode == 1
18892               && !ARM_CPU_HAS_FEATURE (variant, *opcode->tvariant)))
18893         {
18894           if (opcode->tencode == do_t_swi)
18895             as_bad (_("SVC is not permitted on this architecture"));
18896           else
18897             as_bad (_("selected processor does not support `%s' in Thumb mode"), str);
18898           return;
18899         }
18900       if (inst.cond != COND_ALWAYS && !unified_syntax
18901           && opcode->tencode != do_t_branch)
18902         {
18903           as_bad (_("Thumb does not support conditional execution"));
18904           return;
18905         }
18906
18907       /* Two things are addressed here:
18908          1) Implicit require narrow instructions on Thumb-1.
18909             This avoids relaxation accidentally introducing Thumb-2
18910             instructions.
18911          2) Reject wide instructions in non Thumb-2 cores.
18912
18913          Only instructions with narrow and wide variants need to be handled
18914          but selecting all non wide-only instructions is easier.  */
18915       if (!ARM_CPU_HAS_FEATURE (variant, arm_ext_v6t2)
18916           && !t32_insn_ok (variant, opcode))
18917         {
18918           if (inst.size_req == 0)
18919             inst.size_req = 2;
18920           else if (inst.size_req == 4)
18921             {
18922               if (ARM_CPU_HAS_FEATURE (variant, arm_ext_v8m))
18923                 as_bad (_("selected processor does not support 32bit wide "
18924                           "variant of instruction `%s'"), str);
18925               else
18926                 as_bad (_("selected processor does not support `%s' in "
18927                           "Thumb-2 mode"), str);
18928               return;
18929             }
18930         }
18931
18932       inst.instruction = opcode->tvalue;
18933
18934       if (!parse_operands (p, opcode->operands, /*thumb=*/TRUE))
18935         {
18936           /* Prepare the it_insn_type for those encodings that don't set
18937              it.  */
18938           it_fsm_pre_encode ();
18939
18940           opcode->tencode ();
18941
18942           it_fsm_post_encode ();
18943         }
18944
18945       if (!(inst.error || inst.relax))
18946         {
18947           gas_assert (inst.instruction < 0xe800 || inst.instruction > 0xffff);
18948           inst.size = (inst.instruction > 0xffff ? 4 : 2);
18949           if (inst.size_req && inst.size_req != inst.size)
18950             {
18951               as_bad (_("cannot honor width suffix -- `%s'"), str);
18952               return;
18953             }
18954         }
18955
18956       /* Something has gone badly wrong if we try to relax a fixed size
18957          instruction.  */
18958       gas_assert (inst.size_req == 0 || !inst.relax);
18959
18960       ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
18961                               *opcode->tvariant);
18962       /* Many Thumb-2 instructions also have Thumb-1 variants, so explicitly
18963          set those bits when Thumb-2 32-bit instructions are seen.  The impact
18964          of relaxable instructions will be considered later after we finish all
18965          relaxation.  */
18966       if (ARM_FEATURE_CORE_EQUAL (cpu_variant, arm_arch_any))
18967         variant = arm_arch_none;
18968       else
18969         variant = cpu_variant;
18970       if (inst.size == 4 && !t32_insn_ok (variant, opcode))
18971         ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
18972                                 arm_ext_v6t2);
18973
18974       check_neon_suffixes;
18975
18976       if (!inst.error)
18977         {
18978           mapping_state (MAP_THUMB);
18979         }
18980     }
18981   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
18982     {
18983       bfd_boolean is_bx;
18984
18985       /* bx is allowed on v5 cores, and sometimes on v4 cores.  */
18986       is_bx = (opcode->aencode == do_bx);
18987
18988       /* Check that this instruction is supported for this CPU.  */
18989       if (!(is_bx && fix_v4bx)
18990           && !(opcode->avariant &&
18991                ARM_CPU_HAS_FEATURE (cpu_variant, *opcode->avariant)))
18992         {
18993           as_bad (_("selected processor does not support `%s' in ARM mode"), str);
18994           return;
18995         }
18996       if (inst.size_req)
18997         {
18998           as_bad (_("width suffixes are invalid in ARM mode -- `%s'"), str);
18999           return;
19000         }
19001
19002       inst.instruction = opcode->avalue;
19003       if (opcode->tag == OT_unconditionalF)
19004         inst.instruction |= 0xFU << 28;
19005       else
19006         inst.instruction |= inst.cond << 28;
19007       inst.size = INSN_SIZE;
19008       if (!parse_operands (p, opcode->operands, /*thumb=*/FALSE))
19009         {
19010           it_fsm_pre_encode ();
19011           opcode->aencode ();
19012           it_fsm_post_encode ();
19013         }
19014       /* Arm mode bx is marked as both v4T and v5 because it's still required
19015          on a hypothetical non-thumb v5 core.  */
19016       if (is_bx)
19017         ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used, arm_ext_v4t);
19018       else
19019         ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used,
19020                                 *opcode->avariant);
19021
19022       check_neon_suffixes;
19023
19024       if (!inst.error)
19025         {
19026           mapping_state (MAP_ARM);
19027         }
19028     }
19029   else
19030     {
19031       as_bad (_("attempt to use an ARM instruction on a Thumb-only processor "
19032                 "-- `%s'"), str);
19033       return;
19034     }
19035   output_inst (str);
19036 }
19037
19038 static void
19039 check_it_blocks_finished (void)
19040 {
19041 #ifdef OBJ_ELF
19042   asection *sect;
19043
19044   for (sect = stdoutput->sections; sect != NULL; sect = sect->next)
19045     if (seg_info (sect)->tc_segment_info_data.current_it.state
19046         == MANUAL_IT_BLOCK)
19047       {
19048         as_warn (_("section '%s' finished with an open IT block."),
19049                  sect->name);
19050       }
19051 #else
19052   if (now_it.state == MANUAL_IT_BLOCK)
19053     as_warn (_("file finished with an open IT block."));
19054 #endif
19055 }
19056
19057 /* Various frobbings of labels and their addresses.  */
19058
19059 void
19060 arm_start_line_hook (void)
19061 {
19062   last_label_seen = NULL;
19063 }
19064
19065 void
19066 arm_frob_label (symbolS * sym)
19067 {
19068   last_label_seen = sym;
19069
19070   ARM_SET_THUMB (sym, thumb_mode);
19071
19072 #if defined OBJ_COFF || defined OBJ_ELF
19073   ARM_SET_INTERWORK (sym, support_interwork);
19074 #endif
19075
19076   force_automatic_it_block_close ();
19077
19078   /* Note - do not allow local symbols (.Lxxx) to be labelled
19079      as Thumb functions.  This is because these labels, whilst
19080      they exist inside Thumb code, are not the entry points for
19081      possible ARM->Thumb calls.  Also, these labels can be used
19082      as part of a computed goto or switch statement.  eg gcc
19083      can generate code that looks like this:
19084
19085                 ldr  r2, [pc, .Laaa]
19086                 lsl  r3, r3, #2
19087                 ldr  r2, [r3, r2]
19088                 mov  pc, r2
19089
19090        .Lbbb:  .word .Lxxx
19091        .Lccc:  .word .Lyyy
19092        ..etc...
19093        .Laaa:   .word Lbbb
19094
19095      The first instruction loads the address of the jump table.
19096      The second instruction converts a table index into a byte offset.
19097      The third instruction gets the jump address out of the table.
19098      The fourth instruction performs the jump.
19099
19100      If the address stored at .Laaa is that of a symbol which has the
19101      Thumb_Func bit set, then the linker will arrange for this address
19102      to have the bottom bit set, which in turn would mean that the
19103      address computation performed by the third instruction would end
19104      up with the bottom bit set.  Since the ARM is capable of unaligned
19105      word loads, the instruction would then load the incorrect address
19106      out of the jump table, and chaos would ensue.  */
19107   if (label_is_thumb_function_name
19108       && (S_GET_NAME (sym)[0] != '.' || S_GET_NAME (sym)[1] != 'L')
19109       && (bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
19110     {
19111       /* When the address of a Thumb function is taken the bottom
19112          bit of that address should be set.  This will allow
19113          interworking between Arm and Thumb functions to work
19114          correctly.  */
19115
19116       THUMB_SET_FUNC (sym, 1);
19117
19118       label_is_thumb_function_name = FALSE;
19119     }
19120
19121   dwarf2_emit_label (sym);
19122 }
19123
19124 bfd_boolean
19125 arm_data_in_code (void)
19126 {
19127   if (thumb_mode && ! strncmp (input_line_pointer + 1, "data:", 5))
19128     {
19129       *input_line_pointer = '/';
19130       input_line_pointer += 5;
19131       *input_line_pointer = 0;
19132       return TRUE;
19133     }
19134
19135   return FALSE;
19136 }
19137
19138 char *
19139 arm_canonicalize_symbol_name (char * name)
19140 {
19141   int len;
19142
19143   if (thumb_mode && (len = strlen (name)) > 5
19144       && streq (name + len - 5, "/data"))
19145     *(name + len - 5) = 0;
19146
19147   return name;
19148 }
19149 \f
19150 /* Table of all register names defined by default.  The user can
19151    define additional names with .req.  Note that all register names
19152    should appear in both upper and lowercase variants.  Some registers
19153    also have mixed-case names.  */
19154
19155 #define REGDEF(s,n,t) { #s, n, REG_TYPE_##t, TRUE, 0 }
19156 #define REGNUM(p,n,t) REGDEF(p##n, n, t)
19157 #define REGNUM2(p,n,t) REGDEF(p##n, 2 * n, t)
19158 #define REGSET(p,t) \
19159   REGNUM(p, 0,t), REGNUM(p, 1,t), REGNUM(p, 2,t), REGNUM(p, 3,t), \
19160   REGNUM(p, 4,t), REGNUM(p, 5,t), REGNUM(p, 6,t), REGNUM(p, 7,t), \
19161   REGNUM(p, 8,t), REGNUM(p, 9,t), REGNUM(p,10,t), REGNUM(p,11,t), \
19162   REGNUM(p,12,t), REGNUM(p,13,t), REGNUM(p,14,t), REGNUM(p,15,t)
19163 #define REGSETH(p,t) \
19164   REGNUM(p,16,t), REGNUM(p,17,t), REGNUM(p,18,t), REGNUM(p,19,t), \
19165   REGNUM(p,20,t), REGNUM(p,21,t), REGNUM(p,22,t), REGNUM(p,23,t), \
19166   REGNUM(p,24,t), REGNUM(p,25,t), REGNUM(p,26,t), REGNUM(p,27,t), \
19167   REGNUM(p,28,t), REGNUM(p,29,t), REGNUM(p,30,t), REGNUM(p,31,t)
19168 #define REGSET2(p,t) \
19169   REGNUM2(p, 0,t), REGNUM2(p, 1,t), REGNUM2(p, 2,t), REGNUM2(p, 3,t), \
19170   REGNUM2(p, 4,t), REGNUM2(p, 5,t), REGNUM2(p, 6,t), REGNUM2(p, 7,t), \
19171   REGNUM2(p, 8,t), REGNUM2(p, 9,t), REGNUM2(p,10,t), REGNUM2(p,11,t), \
19172   REGNUM2(p,12,t), REGNUM2(p,13,t), REGNUM2(p,14,t), REGNUM2(p,15,t)
19173 #define SPLRBANK(base,bank,t) \
19174   REGDEF(lr_##bank, 768|((base+0)<<16), t), \
19175   REGDEF(sp_##bank, 768|((base+1)<<16), t), \
19176   REGDEF(spsr_##bank, 768|(base<<16)|SPSR_BIT, t), \
19177   REGDEF(LR_##bank, 768|((base+0)<<16), t), \
19178   REGDEF(SP_##bank, 768|((base+1)<<16), t), \
19179   REGDEF(SPSR_##bank, 768|(base<<16)|SPSR_BIT, t)
19180
19181 static const struct reg_entry reg_names[] =
19182 {
19183   /* ARM integer registers.  */
19184   REGSET(r, RN), REGSET(R, RN),
19185
19186   /* ATPCS synonyms.  */
19187   REGDEF(a1,0,RN), REGDEF(a2,1,RN), REGDEF(a3, 2,RN), REGDEF(a4, 3,RN),
19188   REGDEF(v1,4,RN), REGDEF(v2,5,RN), REGDEF(v3, 6,RN), REGDEF(v4, 7,RN),
19189   REGDEF(v5,8,RN), REGDEF(v6,9,RN), REGDEF(v7,10,RN), REGDEF(v8,11,RN),
19190
19191   REGDEF(A1,0,RN), REGDEF(A2,1,RN), REGDEF(A3, 2,RN), REGDEF(A4, 3,RN),
19192   REGDEF(V1,4,RN), REGDEF(V2,5,RN), REGDEF(V3, 6,RN), REGDEF(V4, 7,RN),
19193   REGDEF(V5,8,RN), REGDEF(V6,9,RN), REGDEF(V7,10,RN), REGDEF(V8,11,RN),
19194
19195   /* Well-known aliases.  */
19196   REGDEF(wr, 7,RN), REGDEF(sb, 9,RN), REGDEF(sl,10,RN), REGDEF(fp,11,RN),
19197   REGDEF(ip,12,RN), REGDEF(sp,13,RN), REGDEF(lr,14,RN), REGDEF(pc,15,RN),
19198
19199   REGDEF(WR, 7,RN), REGDEF(SB, 9,RN), REGDEF(SL,10,RN), REGDEF(FP,11,RN),
19200   REGDEF(IP,12,RN), REGDEF(SP,13,RN), REGDEF(LR,14,RN), REGDEF(PC,15,RN),
19201
19202   /* Coprocessor numbers.  */
19203   REGSET(p, CP), REGSET(P, CP),
19204
19205   /* Coprocessor register numbers.  The "cr" variants are for backward
19206      compatibility.  */
19207   REGSET(c,  CN), REGSET(C, CN),
19208   REGSET(cr, CN), REGSET(CR, CN),
19209
19210   /* ARM banked registers.  */
19211   REGDEF(R8_usr,512|(0<<16),RNB), REGDEF(r8_usr,512|(0<<16),RNB),
19212   REGDEF(R9_usr,512|(1<<16),RNB), REGDEF(r9_usr,512|(1<<16),RNB),
19213   REGDEF(R10_usr,512|(2<<16),RNB), REGDEF(r10_usr,512|(2<<16),RNB),
19214   REGDEF(R11_usr,512|(3<<16),RNB), REGDEF(r11_usr,512|(3<<16),RNB),
19215   REGDEF(R12_usr,512|(4<<16),RNB), REGDEF(r12_usr,512|(4<<16),RNB),
19216   REGDEF(SP_usr,512|(5<<16),RNB), REGDEF(sp_usr,512|(5<<16),RNB),
19217   REGDEF(LR_usr,512|(6<<16),RNB), REGDEF(lr_usr,512|(6<<16),RNB),
19218
19219   REGDEF(R8_fiq,512|(8<<16),RNB), REGDEF(r8_fiq,512|(8<<16),RNB),
19220   REGDEF(R9_fiq,512|(9<<16),RNB), REGDEF(r9_fiq,512|(9<<16),RNB),
19221   REGDEF(R10_fiq,512|(10<<16),RNB), REGDEF(r10_fiq,512|(10<<16),RNB),
19222   REGDEF(R11_fiq,512|(11<<16),RNB), REGDEF(r11_fiq,512|(11<<16),RNB),
19223   REGDEF(R12_fiq,512|(12<<16),RNB), REGDEF(r12_fiq,512|(12<<16),RNB),
19224   REGDEF(SP_fiq,512|(13<<16),RNB), REGDEF(sp_fiq,512|(13<<16),RNB),
19225   REGDEF(LR_fiq,512|(14<<16),RNB), REGDEF(lr_fiq,512|(14<<16),RNB),
19226   REGDEF(SPSR_fiq,512|(14<<16)|SPSR_BIT,RNB), REGDEF(spsr_fiq,512|(14<<16)|SPSR_BIT,RNB),
19227
19228   SPLRBANK(0,IRQ,RNB), SPLRBANK(0,irq,RNB),
19229   SPLRBANK(2,SVC,RNB), SPLRBANK(2,svc,RNB),
19230   SPLRBANK(4,ABT,RNB), SPLRBANK(4,abt,RNB),
19231   SPLRBANK(6,UND,RNB), SPLRBANK(6,und,RNB),
19232   SPLRBANK(12,MON,RNB), SPLRBANK(12,mon,RNB),
19233   REGDEF(elr_hyp,768|(14<<16),RNB), REGDEF(ELR_hyp,768|(14<<16),RNB),
19234   REGDEF(sp_hyp,768|(15<<16),RNB), REGDEF(SP_hyp,768|(15<<16),RNB),
19235   REGDEF(spsr_hyp,768|(14<<16)|SPSR_BIT,RNB),
19236   REGDEF(SPSR_hyp,768|(14<<16)|SPSR_BIT,RNB),
19237
19238   /* FPA registers.  */
19239   REGNUM(f,0,FN), REGNUM(f,1,FN), REGNUM(f,2,FN), REGNUM(f,3,FN),
19240   REGNUM(f,4,FN), REGNUM(f,5,FN), REGNUM(f,6,FN), REGNUM(f,7, FN),
19241
19242   REGNUM(F,0,FN), REGNUM(F,1,FN), REGNUM(F,2,FN), REGNUM(F,3,FN),
19243   REGNUM(F,4,FN), REGNUM(F,5,FN), REGNUM(F,6,FN), REGNUM(F,7, FN),
19244
19245   /* VFP SP registers.  */
19246   REGSET(s,VFS),  REGSET(S,VFS),
19247   REGSETH(s,VFS), REGSETH(S,VFS),
19248
19249   /* VFP DP Registers.  */
19250   REGSET(d,VFD),  REGSET(D,VFD),
19251   /* Extra Neon DP registers.  */
19252   REGSETH(d,VFD), REGSETH(D,VFD),
19253
19254   /* Neon QP registers.  */
19255   REGSET2(q,NQ),  REGSET2(Q,NQ),
19256
19257   /* VFP control registers.  */
19258   REGDEF(fpsid,0,VFC), REGDEF(fpscr,1,VFC), REGDEF(fpexc,8,VFC),
19259   REGDEF(FPSID,0,VFC), REGDEF(FPSCR,1,VFC), REGDEF(FPEXC,8,VFC),
19260   REGDEF(fpinst,9,VFC), REGDEF(fpinst2,10,VFC),
19261   REGDEF(FPINST,9,VFC), REGDEF(FPINST2,10,VFC),
19262   REGDEF(mvfr0,7,VFC), REGDEF(mvfr1,6,VFC),
19263   REGDEF(MVFR0,7,VFC), REGDEF(MVFR1,6,VFC),
19264   REGDEF(mvfr2,5,VFC), REGDEF(MVFR2,5,VFC),
19265
19266   /* Maverick DSP coprocessor registers.  */
19267   REGSET(mvf,MVF),  REGSET(mvd,MVD),  REGSET(mvfx,MVFX),  REGSET(mvdx,MVDX),
19268   REGSET(MVF,MVF),  REGSET(MVD,MVD),  REGSET(MVFX,MVFX),  REGSET(MVDX,MVDX),
19269
19270   REGNUM(mvax,0,MVAX), REGNUM(mvax,1,MVAX),
19271   REGNUM(mvax,2,MVAX), REGNUM(mvax,3,MVAX),
19272   REGDEF(dspsc,0,DSPSC),
19273
19274   REGNUM(MVAX,0,MVAX), REGNUM(MVAX,1,MVAX),
19275   REGNUM(MVAX,2,MVAX), REGNUM(MVAX,3,MVAX),
19276   REGDEF(DSPSC,0,DSPSC),
19277
19278   /* iWMMXt data registers - p0, c0-15.  */
19279   REGSET(wr,MMXWR), REGSET(wR,MMXWR), REGSET(WR, MMXWR),
19280
19281   /* iWMMXt control registers - p1, c0-3.  */
19282   REGDEF(wcid,  0,MMXWC),  REGDEF(wCID,  0,MMXWC),  REGDEF(WCID,  0,MMXWC),
19283   REGDEF(wcon,  1,MMXWC),  REGDEF(wCon,  1,MMXWC),  REGDEF(WCON,  1,MMXWC),
19284   REGDEF(wcssf, 2,MMXWC),  REGDEF(wCSSF, 2,MMXWC),  REGDEF(WCSSF, 2,MMXWC),
19285   REGDEF(wcasf, 3,MMXWC),  REGDEF(wCASF, 3,MMXWC),  REGDEF(WCASF, 3,MMXWC),
19286
19287   /* iWMMXt scalar (constant/offset) registers - p1, c8-11.  */
19288   REGDEF(wcgr0, 8,MMXWCG),  REGDEF(wCGR0, 8,MMXWCG),  REGDEF(WCGR0, 8,MMXWCG),
19289   REGDEF(wcgr1, 9,MMXWCG),  REGDEF(wCGR1, 9,MMXWCG),  REGDEF(WCGR1, 9,MMXWCG),
19290   REGDEF(wcgr2,10,MMXWCG),  REGDEF(wCGR2,10,MMXWCG),  REGDEF(WCGR2,10,MMXWCG),
19291   REGDEF(wcgr3,11,MMXWCG),  REGDEF(wCGR3,11,MMXWCG),  REGDEF(WCGR3,11,MMXWCG),
19292
19293   /* XScale accumulator registers.  */
19294   REGNUM(acc,0,XSCALE), REGNUM(ACC,0,XSCALE),
19295 };
19296 #undef REGDEF
19297 #undef REGNUM
19298 #undef REGSET
19299
19300 /* Table of all PSR suffixes.  Bare "CPSR" and "SPSR" are handled
19301    within psr_required_here.  */
19302 static const struct asm_psr psrs[] =
19303 {
19304   /* Backward compatibility notation.  Note that "all" is no longer
19305      truly all possible PSR bits.  */
19306   {"all",  PSR_c | PSR_f},
19307   {"flg",  PSR_f},
19308   {"ctl",  PSR_c},
19309
19310   /* Individual flags.  */
19311   {"f",    PSR_f},
19312   {"c",    PSR_c},
19313   {"x",    PSR_x},
19314   {"s",    PSR_s},
19315
19316   /* Combinations of flags.  */
19317   {"fs",   PSR_f | PSR_s},
19318   {"fx",   PSR_f | PSR_x},
19319   {"fc",   PSR_f | PSR_c},
19320   {"sf",   PSR_s | PSR_f},
19321   {"sx",   PSR_s | PSR_x},
19322   {"sc",   PSR_s | PSR_c},
19323   {"xf",   PSR_x | PSR_f},
19324   {"xs",   PSR_x | PSR_s},
19325   {"xc",   PSR_x | PSR_c},
19326   {"cf",   PSR_c | PSR_f},
19327   {"cs",   PSR_c | PSR_s},
19328   {"cx",   PSR_c | PSR_x},
19329   {"fsx",  PSR_f | PSR_s | PSR_x},
19330   {"fsc",  PSR_f | PSR_s | PSR_c},
19331   {"fxs",  PSR_f | PSR_x | PSR_s},
19332   {"fxc",  PSR_f | PSR_x | PSR_c},
19333   {"fcs",  PSR_f | PSR_c | PSR_s},
19334   {"fcx",  PSR_f | PSR_c | PSR_x},
19335   {"sfx",  PSR_s | PSR_f | PSR_x},
19336   {"sfc",  PSR_s | PSR_f | PSR_c},
19337   {"sxf",  PSR_s | PSR_x | PSR_f},
19338   {"sxc",  PSR_s | PSR_x | PSR_c},
19339   {"scf",  PSR_s | PSR_c | PSR_f},
19340   {"scx",  PSR_s | PSR_c | PSR_x},
19341   {"xfs",  PSR_x | PSR_f | PSR_s},
19342   {"xfc",  PSR_x | PSR_f | PSR_c},
19343   {"xsf",  PSR_x | PSR_s | PSR_f},
19344   {"xsc",  PSR_x | PSR_s | PSR_c},
19345   {"xcf",  PSR_x | PSR_c | PSR_f},
19346   {"xcs",  PSR_x | PSR_c | PSR_s},
19347   {"cfs",  PSR_c | PSR_f | PSR_s},
19348   {"cfx",  PSR_c | PSR_f | PSR_x},
19349   {"csf",  PSR_c | PSR_s | PSR_f},
19350   {"csx",  PSR_c | PSR_s | PSR_x},
19351   {"cxf",  PSR_c | PSR_x | PSR_f},
19352   {"cxs",  PSR_c | PSR_x | PSR_s},
19353   {"fsxc", PSR_f | PSR_s | PSR_x | PSR_c},
19354   {"fscx", PSR_f | PSR_s | PSR_c | PSR_x},
19355   {"fxsc", PSR_f | PSR_x | PSR_s | PSR_c},
19356   {"fxcs", PSR_f | PSR_x | PSR_c | PSR_s},
19357   {"fcsx", PSR_f | PSR_c | PSR_s | PSR_x},
19358   {"fcxs", PSR_f | PSR_c | PSR_x | PSR_s},
19359   {"sfxc", PSR_s | PSR_f | PSR_x | PSR_c},
19360   {"sfcx", PSR_s | PSR_f | PSR_c | PSR_x},
19361   {"sxfc", PSR_s | PSR_x | PSR_f | PSR_c},
19362   {"sxcf", PSR_s | PSR_x | PSR_c | PSR_f},
19363   {"scfx", PSR_s | PSR_c | PSR_f | PSR_x},
19364   {"scxf", PSR_s | PSR_c | PSR_x | PSR_f},
19365   {"xfsc", PSR_x | PSR_f | PSR_s | PSR_c},
19366   {"xfcs", PSR_x | PSR_f | PSR_c | PSR_s},
19367   {"xsfc", PSR_x | PSR_s | PSR_f | PSR_c},
19368   {"xscf", PSR_x | PSR_s | PSR_c | PSR_f},
19369   {"xcfs", PSR_x | PSR_c | PSR_f | PSR_s},
19370   {"xcsf", PSR_x | PSR_c | PSR_s | PSR_f},
19371   {"cfsx", PSR_c | PSR_f | PSR_s | PSR_x},
19372   {"cfxs", PSR_c | PSR_f | PSR_x | PSR_s},
19373   {"csfx", PSR_c | PSR_s | PSR_f | PSR_x},
19374   {"csxf", PSR_c | PSR_s | PSR_x | PSR_f},
19375   {"cxfs", PSR_c | PSR_x | PSR_f | PSR_s},
19376   {"cxsf", PSR_c | PSR_x | PSR_s | PSR_f},
19377 };
19378
19379 /* Table of V7M psr names.  */
19380 static const struct asm_psr v7m_psrs[] =
19381 {
19382   {"apsr",         0x0 }, {"APSR",         0x0 },
19383   {"iapsr",        0x1 }, {"IAPSR",        0x1 },
19384   {"eapsr",        0x2 }, {"EAPSR",        0x2 },
19385   {"psr",          0x3 }, {"PSR",          0x3 },
19386   {"xpsr",         0x3 }, {"XPSR",         0x3 }, {"xPSR",        3 },
19387   {"ipsr",         0x5 }, {"IPSR",         0x5 },
19388   {"epsr",         0x6 }, {"EPSR",         0x6 },
19389   {"iepsr",        0x7 }, {"IEPSR",        0x7 },
19390   {"msp",          0x8 }, {"MSP",          0x8 },
19391   {"psp",          0x9 }, {"PSP",          0x9 },
19392   {"msplim",       0xa }, {"MSPLIM",       0xa },
19393   {"psplim",       0xb }, {"PSPLIM",       0xb },
19394   {"primask",      0x10}, {"PRIMASK",      0x10},
19395   {"basepri",      0x11}, {"BASEPRI",      0x11},
19396   {"basepri_max",  0x12}, {"BASEPRI_MAX",  0x12},
19397   {"faultmask",    0x13}, {"FAULTMASK",    0x13},
19398   {"control",      0x14}, {"CONTROL",      0x14},
19399   {"msp_ns",       0x88}, {"MSP_NS",       0x88},
19400   {"psp_ns",       0x89}, {"PSP_NS",       0x89},
19401   {"msplim_ns",    0x8a}, {"MSPLIM_NS",    0x8a},
19402   {"psplim_ns",    0x8b}, {"PSPLIM_NS",    0x8b},
19403   {"primask_ns",   0x90}, {"PRIMASK_NS",   0x90},
19404   {"basepri_ns",   0x91}, {"BASEPRI_NS",   0x91},
19405   {"faultmask_ns", 0x93}, {"FAULTMASK_NS", 0x93},
19406   {"control_ns",   0x94}, {"CONTROL_NS",   0x94},
19407   {"sp_ns",        0x98}, {"SP_NS",        0x98 }
19408 };
19409
19410 /* Table of all shift-in-operand names.  */
19411 static const struct asm_shift_name shift_names [] =
19412 {
19413   { "asl", SHIFT_LSL },  { "ASL", SHIFT_LSL },
19414   { "lsl", SHIFT_LSL },  { "LSL", SHIFT_LSL },
19415   { "lsr", SHIFT_LSR },  { "LSR", SHIFT_LSR },
19416   { "asr", SHIFT_ASR },  { "ASR", SHIFT_ASR },
19417   { "ror", SHIFT_ROR },  { "ROR", SHIFT_ROR },
19418   { "rrx", SHIFT_RRX },  { "RRX", SHIFT_RRX }
19419 };
19420
19421 /* Table of all explicit relocation names.  */
19422 #ifdef OBJ_ELF
19423 static struct reloc_entry reloc_names[] =
19424 {
19425   { "got",     BFD_RELOC_ARM_GOT32   },  { "GOT",     BFD_RELOC_ARM_GOT32   },
19426   { "gotoff",  BFD_RELOC_ARM_GOTOFF  },  { "GOTOFF",  BFD_RELOC_ARM_GOTOFF  },
19427   { "plt",     BFD_RELOC_ARM_PLT32   },  { "PLT",     BFD_RELOC_ARM_PLT32   },
19428   { "target1", BFD_RELOC_ARM_TARGET1 },  { "TARGET1", BFD_RELOC_ARM_TARGET1 },
19429   { "target2", BFD_RELOC_ARM_TARGET2 },  { "TARGET2", BFD_RELOC_ARM_TARGET2 },
19430   { "sbrel",   BFD_RELOC_ARM_SBREL32 },  { "SBREL",   BFD_RELOC_ARM_SBREL32 },
19431   { "tlsgd",   BFD_RELOC_ARM_TLS_GD32},  { "TLSGD",   BFD_RELOC_ARM_TLS_GD32},
19432   { "tlsldm",  BFD_RELOC_ARM_TLS_LDM32}, { "TLSLDM",  BFD_RELOC_ARM_TLS_LDM32},
19433   { "tlsldo",  BFD_RELOC_ARM_TLS_LDO32}, { "TLSLDO",  BFD_RELOC_ARM_TLS_LDO32},
19434   { "gottpoff",BFD_RELOC_ARM_TLS_IE32},  { "GOTTPOFF",BFD_RELOC_ARM_TLS_IE32},
19435   { "tpoff",   BFD_RELOC_ARM_TLS_LE32},  { "TPOFF",   BFD_RELOC_ARM_TLS_LE32},
19436   { "got_prel", BFD_RELOC_ARM_GOT_PREL}, { "GOT_PREL", BFD_RELOC_ARM_GOT_PREL},
19437   { "tlsdesc", BFD_RELOC_ARM_TLS_GOTDESC},
19438         { "TLSDESC", BFD_RELOC_ARM_TLS_GOTDESC},
19439   { "tlscall", BFD_RELOC_ARM_TLS_CALL},
19440         { "TLSCALL", BFD_RELOC_ARM_TLS_CALL},
19441   { "tlsdescseq", BFD_RELOC_ARM_TLS_DESCSEQ},
19442         { "TLSDESCSEQ", BFD_RELOC_ARM_TLS_DESCSEQ},
19443   { "gotfuncdesc", BFD_RELOC_ARM_GOTFUNCDESC },
19444         { "GOTFUNCDESC", BFD_RELOC_ARM_GOTFUNCDESC },
19445   { "gotofffuncdesc", BFD_RELOC_ARM_GOTOFFFUNCDESC },
19446         { "GOTOFFFUNCDESC", BFD_RELOC_ARM_GOTOFFFUNCDESC },
19447   { "funcdesc", BFD_RELOC_ARM_FUNCDESC },
19448         { "FUNCDESC", BFD_RELOC_ARM_FUNCDESC },
19449    { "tlsgd_fdpic", BFD_RELOC_ARM_TLS_GD32_FDPIC },      { "TLSGD_FDPIC", BFD_RELOC_ARM_TLS_GD32_FDPIC },
19450    { "tlsldm_fdpic", BFD_RELOC_ARM_TLS_LDM32_FDPIC },    { "TLSLDM_FDPIC", BFD_RELOC_ARM_TLS_LDM32_FDPIC },
19451    { "gottpoff_fdpic", BFD_RELOC_ARM_TLS_IE32_FDPIC },   { "GOTTPOFF_FDIC", BFD_RELOC_ARM_TLS_IE32_FDPIC },
19452 };
19453 #endif
19454
19455 /* Table of all conditional affixes.  0xF is not defined as a condition code.  */
19456 static const struct asm_cond conds[] =
19457 {
19458   {"eq", 0x0},
19459   {"ne", 0x1},
19460   {"cs", 0x2}, {"hs", 0x2},
19461   {"cc", 0x3}, {"ul", 0x3}, {"lo", 0x3},
19462   {"mi", 0x4},
19463   {"pl", 0x5},
19464   {"vs", 0x6},
19465   {"vc", 0x7},
19466   {"hi", 0x8},
19467   {"ls", 0x9},
19468   {"ge", 0xa},
19469   {"lt", 0xb},
19470   {"gt", 0xc},
19471   {"le", 0xd},
19472   {"al", 0xe}
19473 };
19474
19475 #define UL_BARRIER(L,U,CODE,FEAT) \
19476   { L, CODE, ARM_FEATURE_CORE_LOW (FEAT) }, \
19477   { U, CODE, ARM_FEATURE_CORE_LOW (FEAT) }
19478
19479 static struct asm_barrier_opt barrier_opt_names[] =
19480 {
19481   UL_BARRIER ("sy",     "SY",    0xf, ARM_EXT_BARRIER),
19482   UL_BARRIER ("st",     "ST",    0xe, ARM_EXT_BARRIER),
19483   UL_BARRIER ("ld",     "LD",    0xd, ARM_EXT_V8),
19484   UL_BARRIER ("ish",    "ISH",   0xb, ARM_EXT_BARRIER),
19485   UL_BARRIER ("sh",     "SH",    0xb, ARM_EXT_BARRIER),
19486   UL_BARRIER ("ishst",  "ISHST", 0xa, ARM_EXT_BARRIER),
19487   UL_BARRIER ("shst",   "SHST",  0xa, ARM_EXT_BARRIER),
19488   UL_BARRIER ("ishld",  "ISHLD", 0x9, ARM_EXT_V8),
19489   UL_BARRIER ("un",     "UN",    0x7, ARM_EXT_BARRIER),
19490   UL_BARRIER ("nsh",    "NSH",   0x7, ARM_EXT_BARRIER),
19491   UL_BARRIER ("unst",   "UNST",  0x6, ARM_EXT_BARRIER),
19492   UL_BARRIER ("nshst",  "NSHST", 0x6, ARM_EXT_BARRIER),
19493   UL_BARRIER ("nshld",  "NSHLD", 0x5, ARM_EXT_V8),
19494   UL_BARRIER ("osh",    "OSH",   0x3, ARM_EXT_BARRIER),
19495   UL_BARRIER ("oshst",  "OSHST", 0x2, ARM_EXT_BARRIER),
19496   UL_BARRIER ("oshld",  "OSHLD", 0x1, ARM_EXT_V8)
19497 };
19498
19499 #undef UL_BARRIER
19500
19501 /* Table of ARM-format instructions.    */
19502
19503 /* Macros for gluing together operand strings.  N.B. In all cases
19504    other than OPS0, the trailing OP_stop comes from default
19505    zero-initialization of the unspecified elements of the array.  */
19506 #define OPS0()            { OP_stop, }
19507 #define OPS1(a)           { OP_##a, }
19508 #define OPS2(a,b)         { OP_##a,OP_##b, }
19509 #define OPS3(a,b,c)       { OP_##a,OP_##b,OP_##c, }
19510 #define OPS4(a,b,c,d)     { OP_##a,OP_##b,OP_##c,OP_##d, }
19511 #define OPS5(a,b,c,d,e)   { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e, }
19512 #define OPS6(a,b,c,d,e,f) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e,OP_##f, }
19513
19514 /* These macros are similar to the OPSn, but do not prepend the OP_ prefix.
19515    This is useful when mixing operands for ARM and THUMB, i.e. using the
19516    MIX_ARM_THUMB_OPERANDS macro.
19517    In order to use these macros, prefix the number of operands with _
19518    e.g. _3.  */
19519 #define OPS_1(a)           { a, }
19520 #define OPS_2(a,b)         { a,b, }
19521 #define OPS_3(a,b,c)       { a,b,c, }
19522 #define OPS_4(a,b,c,d)     { a,b,c,d, }
19523 #define OPS_5(a,b,c,d,e)   { a,b,c,d,e, }
19524 #define OPS_6(a,b,c,d,e,f) { a,b,c,d,e,f, }
19525
19526 /* These macros abstract out the exact format of the mnemonic table and
19527    save some repeated characters.  */
19528
19529 /* The normal sort of mnemonic; has a Thumb variant; takes a conditional suffix.  */
19530 #define TxCE(mnem, op, top, nops, ops, ae, te) \
19531   { mnem, OPS##nops ops, OT_csuffix, 0x##op, top, ARM_VARIANT, \
19532     THUMB_VARIANT, do_##ae, do_##te }
19533
19534 /* Two variants of the above - TCE for a numeric Thumb opcode, tCE for
19535    a T_MNEM_xyz enumerator.  */
19536 #define TCE(mnem, aop, top, nops, ops, ae, te) \
19537       TxCE (mnem, aop, 0x##top, nops, ops, ae, te)
19538 #define tCE(mnem, aop, top, nops, ops, ae, te) \
19539       TxCE (mnem, aop, T_MNEM##top, nops, ops, ae, te)
19540
19541 /* Second most common sort of mnemonic: has a Thumb variant, takes a conditional
19542    infix after the third character.  */
19543 #define TxC3(mnem, op, top, nops, ops, ae, te) \
19544   { mnem, OPS##nops ops, OT_cinfix3, 0x##op, top, ARM_VARIANT, \
19545     THUMB_VARIANT, do_##ae, do_##te }
19546 #define TxC3w(mnem, op, top, nops, ops, ae, te) \
19547   { mnem, OPS##nops ops, OT_cinfix3_deprecated, 0x##op, top, ARM_VARIANT, \
19548     THUMB_VARIANT, do_##ae, do_##te }
19549 #define TC3(mnem, aop, top, nops, ops, ae, te) \
19550       TxC3 (mnem, aop, 0x##top, nops, ops, ae, te)
19551 #define TC3w(mnem, aop, top, nops, ops, ae, te) \
19552       TxC3w (mnem, aop, 0x##top, nops, ops, ae, te)
19553 #define tC3(mnem, aop, top, nops, ops, ae, te) \
19554       TxC3 (mnem, aop, T_MNEM##top, nops, ops, ae, te)
19555 #define tC3w(mnem, aop, top, nops, ops, ae, te) \
19556       TxC3w (mnem, aop, T_MNEM##top, nops, ops, ae, te)
19557
19558 /* Mnemonic that cannot be conditionalized.  The ARM condition-code
19559    field is still 0xE.  Many of the Thumb variants can be executed
19560    conditionally, so this is checked separately.  */
19561 #define TUE(mnem, op, top, nops, ops, ae, te)                           \
19562   { mnem, OPS##nops ops, OT_unconditional, 0x##op, 0x##top, ARM_VARIANT, \
19563     THUMB_VARIANT, do_##ae, do_##te }
19564
19565 /* Same as TUE but the encoding function for ARM and Thumb modes is the same.
19566    Used by mnemonics that have very minimal differences in the encoding for
19567    ARM and Thumb variants and can be handled in a common function.  */
19568 #define TUEc(mnem, op, top, nops, ops, en) \
19569   { mnem, OPS##nops ops, OT_unconditional, 0x##op, 0x##top, ARM_VARIANT, \
19570     THUMB_VARIANT, do_##en, do_##en }
19571
19572 /* Mnemonic that cannot be conditionalized, and bears 0xF in its ARM
19573    condition code field.  */
19574 #define TUF(mnem, op, top, nops, ops, ae, te)                           \
19575   { mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##top, ARM_VARIANT, \
19576     THUMB_VARIANT, do_##ae, do_##te }
19577
19578 /* ARM-only variants of all the above.  */
19579 #define CE(mnem,  op, nops, ops, ae)    \
19580   { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
19581
19582 #define C3(mnem, op, nops, ops, ae)     \
19583   { #mnem, OPS##nops ops, OT_cinfix3, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
19584
19585 /* Thumb-only variants of TCE and TUE.  */
19586 #define ToC(mnem, top, nops, ops, te) \
19587   { mnem, OPS##nops ops, OT_csuffix, 0x0, 0x##top, 0, THUMB_VARIANT, NULL, \
19588     do_##te }
19589
19590 #define ToU(mnem, top, nops, ops, te) \
19591   { mnem, OPS##nops ops, OT_unconditional, 0x0, 0x##top, 0, THUMB_VARIANT, \
19592     NULL, do_##te }
19593
19594 /* T_MNEM_xyz enumerator variants of ToC.  */
19595 #define toC(mnem, top, nops, ops, te) \
19596   { mnem, OPS##nops ops, OT_csuffix, 0x0, T_MNEM##top, 0, THUMB_VARIANT, NULL, \
19597     do_##te }
19598
19599 /* Legacy mnemonics that always have conditional infix after the third
19600    character.  */
19601 #define CL(mnem, op, nops, ops, ae)     \
19602   { mnem, OPS##nops ops, OT_cinfix3_legacy, \
19603     0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
19604
19605 /* Coprocessor instructions.  Isomorphic between Arm and Thumb-2.  */
19606 #define cCE(mnem,  op, nops, ops, ae)   \
19607   { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
19608
19609 /* Legacy coprocessor instructions where conditional infix and conditional
19610    suffix are ambiguous.  For consistency this includes all FPA instructions,
19611    not just the potentially ambiguous ones.  */
19612 #define cCL(mnem, op, nops, ops, ae)    \
19613   { mnem, OPS##nops ops, OT_cinfix3_legacy, \
19614     0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
19615
19616 /* Coprocessor, takes either a suffix or a position-3 infix
19617    (for an FPA corner case). */
19618 #define C3E(mnem, op, nops, ops, ae) \
19619   { mnem, OPS##nops ops, OT_csuf_or_in3, \
19620     0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
19621
19622 #define xCM_(m1, m2, m3, op, nops, ops, ae)     \
19623   { m1 #m2 m3, OPS##nops ops, \
19624     sizeof (#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof (m1) - 1, \
19625     0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
19626
19627 #define CM(m1, m2, op, nops, ops, ae)   \
19628   xCM_ (m1,   , m2, op, nops, ops, ae), \
19629   xCM_ (m1, eq, m2, op, nops, ops, ae), \
19630   xCM_ (m1, ne, m2, op, nops, ops, ae), \
19631   xCM_ (m1, cs, m2, op, nops, ops, ae), \
19632   xCM_ (m1, hs, m2, op, nops, ops, ae), \
19633   xCM_ (m1, cc, m2, op, nops, ops, ae), \
19634   xCM_ (m1, ul, m2, op, nops, ops, ae), \
19635   xCM_ (m1, lo, m2, op, nops, ops, ae), \
19636   xCM_ (m1, mi, m2, op, nops, ops, ae), \
19637   xCM_ (m1, pl, m2, op, nops, ops, ae), \
19638   xCM_ (m1, vs, m2, op, nops, ops, ae), \
19639   xCM_ (m1, vc, m2, op, nops, ops, ae), \
19640   xCM_ (m1, hi, m2, op, nops, ops, ae), \
19641   xCM_ (m1, ls, m2, op, nops, ops, ae), \
19642   xCM_ (m1, ge, m2, op, nops, ops, ae), \
19643   xCM_ (m1, lt, m2, op, nops, ops, ae), \
19644   xCM_ (m1, gt, m2, op, nops, ops, ae), \
19645   xCM_ (m1, le, m2, op, nops, ops, ae), \
19646   xCM_ (m1, al, m2, op, nops, ops, ae)
19647
19648 #define UE(mnem, op, nops, ops, ae)     \
19649   { #mnem, OPS##nops ops, OT_unconditional, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
19650
19651 #define UF(mnem, op, nops, ops, ae)     \
19652   { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
19653
19654 /* Neon data-processing. ARM versions are unconditional with cond=0xf.
19655    The Thumb and ARM variants are mostly the same (bits 0-23 and 24/28), so we
19656    use the same encoding function for each.  */
19657 #define NUF(mnem, op, nops, ops, enc)                                   \
19658   { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##op,            \
19659     ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
19660
19661 /* Neon data processing, version which indirects through neon_enc_tab for
19662    the various overloaded versions of opcodes.  */
19663 #define nUF(mnem, op, nops, ops, enc)                                   \
19664   { #mnem, OPS##nops ops, OT_unconditionalF, N_MNEM##op, N_MNEM##op,    \
19665     ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
19666
19667 /* Neon insn with conditional suffix for the ARM version, non-overloaded
19668    version.  */
19669 #define NCE_tag(mnem, op, nops, ops, enc, tag)                          \
19670   { #mnem, OPS##nops ops, tag, 0x##op, 0x##op, ARM_VARIANT,             \
19671     THUMB_VARIANT, do_##enc, do_##enc }
19672
19673 #define NCE(mnem, op, nops, ops, enc)                                   \
19674    NCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
19675
19676 #define NCEF(mnem, op, nops, ops, enc)                                  \
19677     NCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
19678
19679 /* Neon insn with conditional suffix for the ARM version, overloaded types.  */
19680 #define nCE_tag(mnem, op, nops, ops, enc, tag)                          \
19681   { #mnem, OPS##nops ops, tag, N_MNEM##op, N_MNEM##op,          \
19682     ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
19683
19684 #define nCE(mnem, op, nops, ops, enc)                                   \
19685    nCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
19686
19687 #define nCEF(mnem, op, nops, ops, enc)                                  \
19688     nCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
19689
19690 #define do_0 0
19691
19692 static const struct asm_opcode insns[] =
19693 {
19694 #define ARM_VARIANT    & arm_ext_v1 /* Core ARM Instructions.  */
19695 #define THUMB_VARIANT  & arm_ext_v4t
19696  tCE("and",     0000000, _and,     3, (RR, oRR, SH), arit, t_arit3c),
19697  tC3("ands",    0100000, _ands,    3, (RR, oRR, SH), arit, t_arit3c),
19698  tCE("eor",     0200000, _eor,     3, (RR, oRR, SH), arit, t_arit3c),
19699  tC3("eors",    0300000, _eors,    3, (RR, oRR, SH), arit, t_arit3c),
19700  tCE("sub",     0400000, _sub,     3, (RR, oRR, SH), arit, t_add_sub),
19701  tC3("subs",    0500000, _subs,    3, (RR, oRR, SH), arit, t_add_sub),
19702  tCE("add",     0800000, _add,     3, (RR, oRR, SHG), arit, t_add_sub),
19703  tC3("adds",    0900000, _adds,    3, (RR, oRR, SHG), arit, t_add_sub),
19704  tCE("adc",     0a00000, _adc,     3, (RR, oRR, SH), arit, t_arit3c),
19705  tC3("adcs",    0b00000, _adcs,    3, (RR, oRR, SH), arit, t_arit3c),
19706  tCE("sbc",     0c00000, _sbc,     3, (RR, oRR, SH), arit, t_arit3),
19707  tC3("sbcs",    0d00000, _sbcs,    3, (RR, oRR, SH), arit, t_arit3),
19708  tCE("orr",     1800000, _orr,     3, (RR, oRR, SH), arit, t_arit3c),
19709  tC3("orrs",    1900000, _orrs,    3, (RR, oRR, SH), arit, t_arit3c),
19710  tCE("bic",     1c00000, _bic,     3, (RR, oRR, SH), arit, t_arit3),
19711  tC3("bics",    1d00000, _bics,    3, (RR, oRR, SH), arit, t_arit3),
19712
19713  /* The p-variants of tst/cmp/cmn/teq (below) are the pre-V6 mechanism
19714     for setting PSR flag bits.  They are obsolete in V6 and do not
19715     have Thumb equivalents. */
19716  tCE("tst",     1100000, _tst,     2, (RR, SH),      cmp,  t_mvn_tst),
19717  tC3w("tsts",   1100000, _tst,     2, (RR, SH),      cmp,  t_mvn_tst),
19718   CL("tstp",    110f000,           2, (RR, SH),      cmp),
19719  tCE("cmp",     1500000, _cmp,     2, (RR, SH),      cmp,  t_mov_cmp),
19720  tC3w("cmps",   1500000, _cmp,     2, (RR, SH),      cmp,  t_mov_cmp),
19721   CL("cmpp",    150f000,           2, (RR, SH),      cmp),
19722  tCE("cmn",     1700000, _cmn,     2, (RR, SH),      cmp,  t_mvn_tst),
19723  tC3w("cmns",   1700000, _cmn,     2, (RR, SH),      cmp,  t_mvn_tst),
19724   CL("cmnp",    170f000,           2, (RR, SH),      cmp),
19725
19726  tCE("mov",     1a00000, _mov,     2, (RR, SH),      mov,  t_mov_cmp),
19727  tC3("movs",    1b00000, _movs,    2, (RR, SHG),     mov,  t_mov_cmp),
19728  tCE("mvn",     1e00000, _mvn,     2, (RR, SH),      mov,  t_mvn_tst),
19729  tC3("mvns",    1f00000, _mvns,    2, (RR, SH),      mov,  t_mvn_tst),
19730
19731  tCE("ldr",     4100000, _ldr,     2, (RR, ADDRGLDR),ldst, t_ldst),
19732  tC3("ldrb",    4500000, _ldrb,    2, (RRnpc_npcsp, ADDRGLDR),ldst, t_ldst),
19733  tCE("str",     4000000, _str,     _2, (MIX_ARM_THUMB_OPERANDS (OP_RR,
19734                                                                 OP_RRnpc),
19735                                         OP_ADDRGLDR),ldst, t_ldst),
19736  tC3("strb",    4400000, _strb,    2, (RRnpc_npcsp, ADDRGLDR),ldst, t_ldst),
19737
19738  tCE("stm",     8800000, _stmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
19739  tC3("stmia",   8800000, _stmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
19740  tC3("stmea",   8800000, _stmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
19741  tCE("ldm",     8900000, _ldmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
19742  tC3("ldmia",   8900000, _ldmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
19743  tC3("ldmfd",   8900000, _ldmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
19744
19745  tCE("b",       a000000, _b,       1, (EXPr),        branch, t_branch),
19746  TCE("bl",      b000000, f000f800, 1, (EXPr),        bl, t_branch23),
19747
19748   /* Pseudo ops.  */
19749  tCE("adr",     28f0000, _adr,     2, (RR, EXP),     adr,  t_adr),
19750   C3(adrl,      28f0000,           2, (RR, EXP),     adrl),
19751  tCE("nop",     1a00000, _nop,     1, (oI255c),      nop,  t_nop),
19752  tCE("udf",     7f000f0, _udf,     1, (oIffffb),     bkpt, t_udf),
19753
19754   /* Thumb-compatibility pseudo ops.  */
19755  tCE("lsl",     1a00000, _lsl,     3, (RR, oRR, SH), shift, t_shift),
19756  tC3("lsls",    1b00000, _lsls,    3, (RR, oRR, SH), shift, t_shift),
19757  tCE("lsr",     1a00020, _lsr,     3, (RR, oRR, SH), shift, t_shift),
19758  tC3("lsrs",    1b00020, _lsrs,    3, (RR, oRR, SH), shift, t_shift),
19759  tCE("asr",     1a00040, _asr,     3, (RR, oRR, SH), shift, t_shift),
19760  tC3("asrs",      1b00040, _asrs,     3, (RR, oRR, SH), shift, t_shift),
19761  tCE("ror",     1a00060, _ror,     3, (RR, oRR, SH), shift, t_shift),
19762  tC3("rors",    1b00060, _rors,    3, (RR, oRR, SH), shift, t_shift),
19763  tCE("neg",     2600000, _neg,     2, (RR, RR),      rd_rn, t_neg),
19764  tC3("negs",    2700000, _negs,    2, (RR, RR),      rd_rn, t_neg),
19765  tCE("push",    92d0000, _push,     1, (REGLST),             push_pop, t_push_pop),
19766  tCE("pop",     8bd0000, _pop,     1, (REGLST),      push_pop, t_push_pop),
19767
19768  /* These may simplify to neg.  */
19769  TCE("rsb",     0600000, ebc00000, 3, (RR, oRR, SH), arit, t_rsb),
19770  TC3("rsbs",    0700000, ebd00000, 3, (RR, oRR, SH), arit, t_rsb),
19771
19772 #undef THUMB_VARIANT
19773 #define THUMB_VARIANT  & arm_ext_os
19774
19775  TCE("swi",     f000000, df00,     1, (EXPi),        swi, t_swi),
19776  TCE("svc",     f000000, df00,     1, (EXPi),        swi, t_swi),
19777
19778 #undef  THUMB_VARIANT
19779 #define THUMB_VARIANT  & arm_ext_v6
19780
19781  TCE("cpy",       1a00000, 4600,     2, (RR, RR),      rd_rm, t_cpy),
19782
19783  /* V1 instructions with no Thumb analogue prior to V6T2.  */
19784 #undef  THUMB_VARIANT
19785 #define THUMB_VARIANT  & arm_ext_v6t2
19786
19787  TCE("teq",     1300000, ea900f00, 2, (RR, SH),      cmp,  t_mvn_tst),
19788  TC3w("teqs",   1300000, ea900f00, 2, (RR, SH),      cmp,  t_mvn_tst),
19789   CL("teqp",    130f000,           2, (RR, SH),      cmp),
19790
19791  TC3("ldrt",    4300000, f8500e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
19792  TC3("ldrbt",   4700000, f8100e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
19793  TC3("strt",    4200000, f8400e00, 2, (RR_npcsp, ADDR),   ldstt, t_ldstt),
19794  TC3("strbt",   4600000, f8000e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
19795
19796  TC3("stmdb",   9000000, e9000000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
19797  TC3("stmfd",     9000000, e9000000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
19798
19799  TC3("ldmdb",   9100000, e9100000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
19800  TC3("ldmea",   9100000, e9100000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
19801
19802  /* V1 instructions with no Thumb analogue at all.  */
19803   CE("rsc",     0e00000,           3, (RR, oRR, SH), arit),
19804   C3(rscs,      0f00000,           3, (RR, oRR, SH), arit),
19805
19806   C3(stmib,     9800000,           2, (RRw, REGLST), ldmstm),
19807   C3(stmfa,     9800000,           2, (RRw, REGLST), ldmstm),
19808   C3(stmda,     8000000,           2, (RRw, REGLST), ldmstm),
19809   C3(stmed,     8000000,           2, (RRw, REGLST), ldmstm),
19810   C3(ldmib,     9900000,           2, (RRw, REGLST), ldmstm),
19811   C3(ldmed,     9900000,           2, (RRw, REGLST), ldmstm),
19812   C3(ldmda,     8100000,           2, (RRw, REGLST), ldmstm),
19813   C3(ldmfa,     8100000,           2, (RRw, REGLST), ldmstm),
19814
19815 #undef  ARM_VARIANT
19816 #define ARM_VARIANT    & arm_ext_v2     /* ARM 2 - multiplies.  */
19817 #undef  THUMB_VARIANT
19818 #define THUMB_VARIANT  & arm_ext_v4t
19819
19820  tCE("mul",     0000090, _mul,     3, (RRnpc, RRnpc, oRR), mul, t_mul),
19821  tC3("muls",    0100090, _muls,    3, (RRnpc, RRnpc, oRR), mul, t_mul),
19822
19823 #undef  THUMB_VARIANT
19824 #define THUMB_VARIANT  & arm_ext_v6t2
19825
19826  TCE("mla",     0200090, fb000000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas, t_mla),
19827   C3(mlas,      0300090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas),
19828
19829   /* Generic coprocessor instructions.  */
19830  TCE("cdp",     e000000, ee000000, 6, (RCP, I15b, RCN, RCN, RCN, oI7b), cdp,    cdp),
19831  TCE("ldc",     c100000, ec100000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
19832  TC3("ldcl",    c500000, ec500000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
19833  TCE("stc",     c000000, ec000000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
19834  TC3("stcl",    c400000, ec400000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
19835  TCE("mcr",     e000010, ee000010, 6, (RCP, I7b, RR, RCN, RCN, oI7b),   co_reg, co_reg),
19836  TCE("mrc",     e100010, ee100010, 6, (RCP, I7b, APSR_RR, RCN, RCN, oI7b),   co_reg, co_reg),
19837
19838 #undef  ARM_VARIANT
19839 #define ARM_VARIANT  & arm_ext_v2s /* ARM 3 - swp instructions.  */
19840
19841   CE("swp",     1000090,           3, (RRnpc, RRnpc, RRnpcb), rd_rm_rn),
19842   C3(swpb,      1400090,           3, (RRnpc, RRnpc, RRnpcb), rd_rm_rn),
19843
19844 #undef  ARM_VARIANT
19845 #define ARM_VARIANT    & arm_ext_v3     /* ARM 6 Status register instructions.  */
19846 #undef  THUMB_VARIANT
19847 #define THUMB_VARIANT  & arm_ext_msr
19848
19849  TCE("mrs",     1000000, f3e08000, 2, (RRnpc, rPSR), mrs, t_mrs),
19850  TCE("msr",     120f000, f3808000, 2, (wPSR, RR_EXi), msr, t_msr),
19851
19852 #undef  ARM_VARIANT
19853 #define ARM_VARIANT    & arm_ext_v3m     /* ARM 7M long multiplies.  */
19854 #undef  THUMB_VARIANT
19855 #define THUMB_VARIANT  & arm_ext_v6t2
19856
19857  TCE("smull",   0c00090, fb800000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
19858   CM("smull","s",       0d00090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
19859  TCE("umull",   0800090, fba00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
19860   CM("umull","s",       0900090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
19861  TCE("smlal",   0e00090, fbc00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
19862   CM("smlal","s",       0f00090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
19863  TCE("umlal",   0a00090, fbe00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
19864   CM("umlal","s",       0b00090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
19865
19866 #undef  ARM_VARIANT
19867 #define ARM_VARIANT    & arm_ext_v4     /* ARM Architecture 4.  */
19868 #undef  THUMB_VARIANT
19869 #define THUMB_VARIANT  & arm_ext_v4t
19870
19871  tC3("ldrh",    01000b0, _ldrh,     2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
19872  tC3("strh",    00000b0, _strh,     2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
19873  tC3("ldrsh",   01000f0, _ldrsh,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
19874  tC3("ldrsb",   01000d0, _ldrsb,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
19875  tC3("ldsh",    01000f0, _ldrsh,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
19876  tC3("ldsb",    01000d0, _ldrsb,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
19877
19878 #undef  ARM_VARIANT
19879 #define ARM_VARIANT  & arm_ext_v4t_5
19880
19881   /* ARM Architecture 4T.  */
19882   /* Note: bx (and blx) are required on V5, even if the processor does
19883      not support Thumb.  */
19884  TCE("bx",      12fff10, 4700, 1, (RR), bx, t_bx),
19885
19886 #undef  ARM_VARIANT
19887 #define ARM_VARIANT    & arm_ext_v5 /*  ARM Architecture 5T.     */
19888 #undef  THUMB_VARIANT
19889 #define THUMB_VARIANT  & arm_ext_v5t
19890
19891   /* Note: blx has 2 variants; the .value coded here is for
19892      BLX(2).  Only this variant has conditional execution.  */
19893  TCE("blx",     12fff30, 4780, 1, (RR_EXr),                         blx,  t_blx),
19894  TUE("bkpt",    1200070, be00, 1, (oIffffb),                        bkpt, t_bkpt),
19895
19896 #undef  THUMB_VARIANT
19897 #define THUMB_VARIANT  & arm_ext_v6t2
19898
19899  TCE("clz",     16f0f10, fab0f080, 2, (RRnpc, RRnpc),                   rd_rm,  t_clz),
19900  TUF("ldc2",    c100000, fc100000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
19901  TUF("ldc2l",   c500000, fc500000, 3, (RCP, RCN, ADDRGLDC),                     lstc,   lstc),
19902  TUF("stc2",    c000000, fc000000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
19903  TUF("stc2l",   c400000, fc400000, 3, (RCP, RCN, ADDRGLDC),                     lstc,   lstc),
19904  TUF("cdp2",    e000000, fe000000, 6, (RCP, I15b, RCN, RCN, RCN, oI7b), cdp,    cdp),
19905  TUF("mcr2",    e000010, fe000010, 6, (RCP, I7b, RR, RCN, RCN, oI7b),   co_reg, co_reg),
19906  TUF("mrc2",    e100010, fe100010, 6, (RCP, I7b, RR, RCN, RCN, oI7b),   co_reg, co_reg),
19907
19908 #undef  ARM_VARIANT
19909 #define ARM_VARIANT    & arm_ext_v5exp /*  ARM Architecture 5TExP.  */
19910 #undef  THUMB_VARIANT
19911 #define THUMB_VARIANT  & arm_ext_v5exp
19912
19913  TCE("smlabb",  1000080, fb100000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
19914  TCE("smlatb",  10000a0, fb100020, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
19915  TCE("smlabt",  10000c0, fb100010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
19916  TCE("smlatt",  10000e0, fb100030, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
19917
19918  TCE("smlawb",  1200080, fb300000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
19919  TCE("smlawt",  12000c0, fb300010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
19920
19921  TCE("smlalbb", 1400080, fbc00080, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
19922  TCE("smlaltb", 14000a0, fbc000a0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
19923  TCE("smlalbt", 14000c0, fbc00090, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
19924  TCE("smlaltt", 14000e0, fbc000b0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
19925
19926  TCE("smulbb",  1600080, fb10f000, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
19927  TCE("smultb",  16000a0, fb10f020, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
19928  TCE("smulbt",  16000c0, fb10f010, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
19929  TCE("smultt",  16000e0, fb10f030, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
19930
19931  TCE("smulwb",  12000a0, fb30f000, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
19932  TCE("smulwt",  12000e0, fb30f010, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
19933
19934  TCE("qadd",    1000050, fa80f080, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
19935  TCE("qdadd",   1400050, fa80f090, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
19936  TCE("qsub",    1200050, fa80f0a0, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
19937  TCE("qdsub",   1600050, fa80f0b0, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
19938
19939 #undef  ARM_VARIANT
19940 #define ARM_VARIANT    & arm_ext_v5e /*  ARM Architecture 5TE.  */
19941 #undef  THUMB_VARIANT
19942 #define THUMB_VARIANT  & arm_ext_v6t2
19943
19944  TUF("pld",     450f000, f810f000, 1, (ADDR),                pld,  t_pld),
19945  TC3("ldrd",    00000d0, e8500000, 3, (RRnpc_npcsp, oRRnpc_npcsp, ADDRGLDRS),
19946      ldrd, t_ldstd),
19947  TC3("strd",    00000f0, e8400000, 3, (RRnpc_npcsp, oRRnpc_npcsp,
19948                                        ADDRGLDRS), ldrd, t_ldstd),
19949
19950  TCE("mcrr",    c400000, ec400000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
19951  TCE("mrrc",    c500000, ec500000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
19952
19953 #undef  ARM_VARIANT
19954 #define ARM_VARIANT  & arm_ext_v5j /*  ARM Architecture 5TEJ.  */
19955
19956  TCE("bxj",     12fff20, f3c08f00, 1, (RR),                       bxj, t_bxj),
19957
19958 #undef  ARM_VARIANT
19959 #define ARM_VARIANT    & arm_ext_v6 /*  ARM V6.  */
19960 #undef  THUMB_VARIANT
19961 #define THUMB_VARIANT  & arm_ext_v6
19962
19963  TUF("cpsie",     1080000, b660,     2, (CPSF, oI31b),              cpsi,   t_cpsi),
19964  TUF("cpsid",     10c0000, b670,     2, (CPSF, oI31b),              cpsi,   t_cpsi),
19965  tCE("rev",       6bf0f30, _rev,      2, (RRnpc, RRnpc),             rd_rm,  t_rev),
19966  tCE("rev16",     6bf0fb0, _rev16,    2, (RRnpc, RRnpc),             rd_rm,  t_rev),
19967  tCE("revsh",     6ff0fb0, _revsh,    2, (RRnpc, RRnpc),             rd_rm,  t_rev),
19968  tCE("sxth",      6bf0070, _sxth,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
19969  tCE("uxth",      6ff0070, _uxth,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
19970  tCE("sxtb",      6af0070, _sxtb,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
19971  tCE("uxtb",      6ef0070, _uxtb,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
19972  TUF("setend",    1010000, b650,     1, (ENDI),                     setend, t_setend),
19973
19974 #undef  THUMB_VARIANT
19975 #define THUMB_VARIANT  & arm_ext_v6t2_v8m
19976
19977  TCE("ldrex",   1900f9f, e8500f00, 2, (RRnpc_npcsp, ADDR),        ldrex, t_ldrex),
19978  TCE("strex",   1800f90, e8400000, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
19979                                       strex,  t_strex),
19980 #undef  THUMB_VARIANT
19981 #define THUMB_VARIANT  & arm_ext_v6t2
19982
19983  TUF("mcrr2",   c400000, fc400000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
19984  TUF("mrrc2",   c500000, fc500000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
19985
19986  TCE("ssat",    6a00010, f3000000, 4, (RRnpc, I32, RRnpc, oSHllar),ssat,   t_ssat),
19987  TCE("usat",    6e00010, f3800000, 4, (RRnpc, I31, RRnpc, oSHllar),usat,   t_usat),
19988
19989 /*  ARM V6 not included in V7M.  */
19990 #undef  THUMB_VARIANT
19991 #define THUMB_VARIANT  & arm_ext_v6_notm
19992  TUF("rfeia",   8900a00, e990c000, 1, (RRw),                       rfe, rfe),
19993  TUF("rfe",     8900a00, e990c000, 1, (RRw),                       rfe, rfe),
19994   UF(rfeib,     9900a00,           1, (RRw),                       rfe),
19995   UF(rfeda,     8100a00,           1, (RRw),                       rfe),
19996  TUF("rfedb",   9100a00, e810c000, 1, (RRw),                       rfe, rfe),
19997  TUF("rfefd",   8900a00, e990c000, 1, (RRw),                       rfe, rfe),
19998   UF(rfefa,     8100a00,           1, (RRw),                       rfe),
19999  TUF("rfeea",   9100a00, e810c000, 1, (RRw),                       rfe, rfe),
20000   UF(rfeed,     9900a00,           1, (RRw),                       rfe),
20001  TUF("srsia",   8c00500, e980c000, 2, (oRRw, I31w),                srs,  srs),
20002  TUF("srs",     8c00500, e980c000, 2, (oRRw, I31w),                srs,  srs),
20003  TUF("srsea",   8c00500, e980c000, 2, (oRRw, I31w),                srs,  srs),
20004   UF(srsib,     9c00500,           2, (oRRw, I31w),                srs),
20005   UF(srsfa,     9c00500,           2, (oRRw, I31w),                srs),
20006   UF(srsda,     8400500,           2, (oRRw, I31w),                srs),
20007   UF(srsed,     8400500,           2, (oRRw, I31w),                srs),
20008  TUF("srsdb",   9400500, e800c000, 2, (oRRw, I31w),                srs,  srs),
20009  TUF("srsfd",   9400500, e800c000, 2, (oRRw, I31w),                srs,  srs),
20010  TUF("cps",     1020000, f3af8100, 1, (I31b),                     imm0, t_cps),
20011
20012 /*  ARM V6 not included in V7M (eg. integer SIMD).  */
20013 #undef  THUMB_VARIANT
20014 #define THUMB_VARIANT  & arm_ext_v6_dsp
20015  TCE("pkhbt",   6800010, eac00000, 4, (RRnpc, RRnpc, RRnpc, oSHll),   pkhbt, t_pkhbt),
20016  TCE("pkhtb",   6800050, eac00020, 4, (RRnpc, RRnpc, RRnpc, oSHar),   pkhtb, t_pkhtb),
20017  TCE("qadd16",  6200f10, fa90f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20018  TCE("qadd8",   6200f90, fa80f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20019  TCE("qasx",    6200f30, faa0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20020  /* Old name for QASX.  */
20021  TCE("qaddsubx",6200f30, faa0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20022  TCE("qsax",    6200f50, fae0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20023  /* Old name for QSAX.  */
20024  TCE("qsubaddx",6200f50, fae0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20025  TCE("qsub16",  6200f70, fad0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20026  TCE("qsub8",   6200ff0, fac0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20027  TCE("sadd16",  6100f10, fa90f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20028  TCE("sadd8",   6100f90, fa80f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20029  TCE("sasx",    6100f30, faa0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20030  /* Old name for SASX.  */
20031  TCE("saddsubx",6100f30, faa0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20032  TCE("shadd16", 6300f10, fa90f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20033  TCE("shadd8",  6300f90, fa80f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20034  TCE("shasx",   6300f30, faa0f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20035  /* Old name for SHASX.  */
20036  TCE("shaddsubx", 6300f30, faa0f020, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
20037  TCE("shsax",     6300f50, fae0f020, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
20038  /* Old name for SHSAX.  */
20039  TCE("shsubaddx", 6300f50, fae0f020, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
20040  TCE("shsub16", 6300f70, fad0f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20041  TCE("shsub8",  6300ff0, fac0f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20042  TCE("ssax",    6100f50, fae0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20043  /* Old name for SSAX.  */
20044  TCE("ssubaddx",6100f50, fae0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20045  TCE("ssub16",  6100f70, fad0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20046  TCE("ssub8",   6100ff0, fac0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20047  TCE("uadd16",  6500f10, fa90f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20048  TCE("uadd8",   6500f90, fa80f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20049  TCE("uasx",    6500f30, faa0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20050  /* Old name for UASX.  */
20051  TCE("uaddsubx",6500f30, faa0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20052  TCE("uhadd16", 6700f10, fa90f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20053  TCE("uhadd8",  6700f90, fa80f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20054  TCE("uhasx",   6700f30, faa0f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20055  /* Old name for UHASX.  */
20056  TCE("uhaddsubx", 6700f30, faa0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
20057  TCE("uhsax",     6700f50, fae0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
20058  /* Old name for UHSAX.  */
20059  TCE("uhsubaddx", 6700f50, fae0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
20060  TCE("uhsub16", 6700f70, fad0f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20061  TCE("uhsub8",  6700ff0, fac0f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20062  TCE("uqadd16", 6600f10, fa90f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20063  TCE("uqadd8",  6600f90, fa80f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20064  TCE("uqasx",   6600f30, faa0f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20065  /* Old name for UQASX.  */
20066  TCE("uqaddsubx", 6600f30, faa0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
20067  TCE("uqsax",     6600f50, fae0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
20068  /* Old name for UQSAX.  */
20069  TCE("uqsubaddx", 6600f50, fae0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
20070  TCE("uqsub16", 6600f70, fad0f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20071  TCE("uqsub8",  6600ff0, fac0f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20072  TCE("usub16",  6500f70, fad0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20073  TCE("usax",    6500f50, fae0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20074  /* Old name for USAX.  */
20075  TCE("usubaddx",6500f50, fae0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20076  TCE("usub8",   6500ff0, fac0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20077  TCE("sxtah",   6b00070, fa00f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
20078  TCE("sxtab16", 6800070, fa20f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
20079  TCE("sxtab",   6a00070, fa40f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
20080  TCE("sxtb16",  68f0070, fa2ff080, 3, (RRnpc, RRnpc, oROR),        sxth,  t_sxth),
20081  TCE("uxtah",   6f00070, fa10f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
20082  TCE("uxtab16", 6c00070, fa30f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
20083  TCE("uxtab",   6e00070, fa50f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
20084  TCE("uxtb16",  6cf0070, fa3ff080, 3, (RRnpc, RRnpc, oROR),        sxth,  t_sxth),
20085  TCE("sel",     6800fb0, faa0f080, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
20086  TCE("smlad",   7000010, fb200000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
20087  TCE("smladx",  7000030, fb200010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
20088  TCE("smlald",  7400010, fbc000c0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
20089  TCE("smlaldx", 7400030, fbc000d0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
20090  TCE("smlsd",   7000050, fb400000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
20091  TCE("smlsdx",  7000070, fb400010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
20092  TCE("smlsld",  7400050, fbd000c0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
20093  TCE("smlsldx", 7400070, fbd000d0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
20094  TCE("smmla",   7500010, fb500000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
20095  TCE("smmlar",  7500030, fb500010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
20096  TCE("smmls",   75000d0, fb600000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
20097  TCE("smmlsr",  75000f0, fb600010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
20098  TCE("smmul",   750f010, fb50f000, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
20099  TCE("smmulr",  750f030, fb50f010, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
20100  TCE("smuad",   700f010, fb20f000, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
20101  TCE("smuadx",  700f030, fb20f010, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
20102  TCE("smusd",   700f050, fb40f000, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
20103  TCE("smusdx",  700f070, fb40f010, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
20104  TCE("ssat16",  6a00f30, f3200000, 3, (RRnpc, I16, RRnpc),         ssat16, t_ssat16),
20105  TCE("umaal",   0400090, fbe00060, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,  t_mlal),
20106  TCE("usad8",   780f010, fb70f000, 3, (RRnpc, RRnpc, RRnpc),       smul,   t_simd),
20107  TCE("usada8",  7800010, fb700000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla,   t_mla),
20108  TCE("usat16",  6e00f30, f3a00000, 3, (RRnpc, I15, RRnpc),         usat16, t_usat16),
20109
20110 #undef  ARM_VARIANT
20111 #define ARM_VARIANT   & arm_ext_v6k_v6t2
20112 #undef  THUMB_VARIANT
20113 #define THUMB_VARIANT & arm_ext_v6k_v6t2
20114
20115  tCE("yield",   320f001, _yield,    0, (), noargs, t_hint),
20116  tCE("wfe",     320f002, _wfe,      0, (), noargs, t_hint),
20117  tCE("wfi",     320f003, _wfi,      0, (), noargs, t_hint),
20118  tCE("sev",     320f004, _sev,      0, (), noargs, t_hint),
20119
20120 #undef  THUMB_VARIANT
20121 #define THUMB_VARIANT  & arm_ext_v6_notm
20122  TCE("ldrexd",  1b00f9f, e8d0007f, 3, (RRnpc_npcsp, oRRnpc_npcsp, RRnpcb),
20123                                       ldrexd, t_ldrexd),
20124  TCE("strexd",  1a00f90, e8c00070, 4, (RRnpc_npcsp, RRnpc_npcsp, oRRnpc_npcsp,
20125                                        RRnpcb), strexd, t_strexd),
20126
20127 #undef  THUMB_VARIANT
20128 #define THUMB_VARIANT  & arm_ext_v6t2_v8m
20129  TCE("ldrexb",  1d00f9f, e8d00f4f, 2, (RRnpc_npcsp,RRnpcb),
20130      rd_rn,  rd_rn),
20131  TCE("ldrexh",  1f00f9f, e8d00f5f, 2, (RRnpc_npcsp, RRnpcb),
20132      rd_rn,  rd_rn),
20133  TCE("strexb",  1c00f90, e8c00f40, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
20134      strex, t_strexbh),
20135  TCE("strexh",  1e00f90, e8c00f50, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
20136      strex, t_strexbh),
20137  TUF("clrex",   57ff01f, f3bf8f2f, 0, (),                             noargs, noargs),
20138
20139 #undef  ARM_VARIANT
20140 #define ARM_VARIANT    & arm_ext_sec
20141 #undef  THUMB_VARIANT
20142 #define THUMB_VARIANT  & arm_ext_sec
20143
20144  TCE("smc",     1600070, f7f08000, 1, (EXPi), smc, t_smc),
20145
20146 #undef  ARM_VARIANT
20147 #define ARM_VARIANT    & arm_ext_virt
20148 #undef  THUMB_VARIANT
20149 #define THUMB_VARIANT    & arm_ext_virt
20150
20151  TCE("hvc",     1400070, f7e08000, 1, (EXPi), hvc, t_hvc),
20152  TCE("eret",    160006e, f3de8f00, 0, (), noargs, noargs),
20153
20154 #undef  ARM_VARIANT
20155 #define ARM_VARIANT    & arm_ext_pan
20156 #undef  THUMB_VARIANT
20157 #define THUMB_VARIANT  & arm_ext_pan
20158
20159  TUF("setpan",  1100000, b610, 1, (I7), setpan, t_setpan),
20160
20161 #undef  ARM_VARIANT
20162 #define ARM_VARIANT    & arm_ext_v6t2
20163 #undef  THUMB_VARIANT
20164 #define THUMB_VARIANT  & arm_ext_v6t2
20165
20166  TCE("bfc",     7c0001f, f36f0000, 3, (RRnpc, I31, I32),           bfc, t_bfc),
20167  TCE("bfi",     7c00010, f3600000, 4, (RRnpc, RRnpc_I0, I31, I32), bfi, t_bfi),
20168  TCE("sbfx",    7a00050, f3400000, 4, (RR, RR, I31, I32),          bfx, t_bfx),
20169  TCE("ubfx",    7e00050, f3c00000, 4, (RR, RR, I31, I32),          bfx, t_bfx),
20170
20171  TCE("mls",     0600090, fb000010, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas, t_mla),
20172  TCE("rbit",    6ff0f30, fa90f0a0, 2, (RR, RR),                     rd_rm, t_rbit),
20173
20174  TC3("ldrht",   03000b0, f8300e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
20175  TC3("ldrsht",  03000f0, f9300e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
20176  TC3("ldrsbt",  03000d0, f9100e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
20177  TC3("strht",   02000b0, f8200e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
20178
20179 #undef  ARM_VARIANT
20180 #define ARM_VARIANT    & arm_ext_v3
20181 #undef  THUMB_VARIANT
20182 #define THUMB_VARIANT  & arm_ext_v6t2
20183
20184  TUE("csdb",    320f014, f3af8014, 0, (), noargs, t_csdb),
20185  TUF("ssbb",    57ff040, f3bf8f40, 0, (), noargs, t_csdb),
20186  TUF("pssbb",   57ff044, f3bf8f44, 0, (), noargs, t_csdb),
20187
20188 #undef  ARM_VARIANT
20189 #define ARM_VARIANT    & arm_ext_v6t2
20190 #undef  THUMB_VARIANT
20191 #define THUMB_VARIANT  & arm_ext_v6t2_v8m
20192  TCE("movw",    3000000, f2400000, 2, (RRnpc, HALF),                mov16, t_mov16),
20193  TCE("movt",    3400000, f2c00000, 2, (RRnpc, HALF),                mov16, t_mov16),
20194
20195  /* Thumb-only instructions.  */
20196 #undef  ARM_VARIANT
20197 #define ARM_VARIANT NULL
20198   TUE("cbnz",     0,           b900,     2, (RR, EXP), 0, t_cbz),
20199   TUE("cbz",      0,           b100,     2, (RR, EXP), 0, t_cbz),
20200
20201  /* ARM does not really have an IT instruction, so always allow it.
20202     The opcode is copied from Thumb in order to allow warnings in
20203     -mimplicit-it=[never | arm] modes.  */
20204 #undef  ARM_VARIANT
20205 #define ARM_VARIANT  & arm_ext_v1
20206 #undef  THUMB_VARIANT
20207 #define THUMB_VARIANT  & arm_ext_v6t2
20208
20209  TUE("it",        bf08,        bf08,     1, (COND),   it,    t_it),
20210  TUE("itt",       bf0c,        bf0c,     1, (COND),   it,    t_it),
20211  TUE("ite",       bf04,        bf04,     1, (COND),   it,    t_it),
20212  TUE("ittt",      bf0e,        bf0e,     1, (COND),   it,    t_it),
20213  TUE("itet",      bf06,        bf06,     1, (COND),   it,    t_it),
20214  TUE("itte",      bf0a,        bf0a,     1, (COND),   it,    t_it),
20215  TUE("itee",      bf02,        bf02,     1, (COND),   it,    t_it),
20216  TUE("itttt",     bf0f,        bf0f,     1, (COND),   it,    t_it),
20217  TUE("itett",     bf07,        bf07,     1, (COND),   it,    t_it),
20218  TUE("ittet",     bf0b,        bf0b,     1, (COND),   it,    t_it),
20219  TUE("iteet",     bf03,        bf03,     1, (COND),   it,    t_it),
20220  TUE("ittte",     bf0d,        bf0d,     1, (COND),   it,    t_it),
20221  TUE("itete",     bf05,        bf05,     1, (COND),   it,    t_it),
20222  TUE("ittee",     bf09,        bf09,     1, (COND),   it,    t_it),
20223  TUE("iteee",     bf01,        bf01,     1, (COND),   it,    t_it),
20224  /* ARM/Thumb-2 instructions with no Thumb-1 equivalent.  */
20225  TC3("rrx",       01a00060, ea4f0030, 2, (RR, RR), rd_rm, t_rrx),
20226  TC3("rrxs",      01b00060, ea5f0030, 2, (RR, RR), rd_rm, t_rrx),
20227
20228  /* Thumb2 only instructions.  */
20229 #undef  ARM_VARIANT
20230 #define ARM_VARIANT  NULL
20231
20232  TCE("addw",    0, f2000000, 3, (RR, RR, EXPi), 0, t_add_sub_w),
20233  TCE("subw",    0, f2a00000, 3, (RR, RR, EXPi), 0, t_add_sub_w),
20234  TCE("orn",       0, ea600000, 3, (RR, oRR, SH),  0, t_orn),
20235  TCE("orns",      0, ea700000, 3, (RR, oRR, SH),  0, t_orn),
20236  TCE("tbb",       0, e8d0f000, 1, (TB), 0, t_tb),
20237  TCE("tbh",       0, e8d0f010, 1, (TB), 0, t_tb),
20238
20239  /* Hardware division instructions.  */
20240 #undef  ARM_VARIANT
20241 #define ARM_VARIANT    & arm_ext_adiv
20242 #undef  THUMB_VARIANT
20243 #define THUMB_VARIANT  & arm_ext_div
20244
20245  TCE("sdiv",    710f010, fb90f0f0, 3, (RR, oRR, RR), div, t_div),
20246  TCE("udiv",    730f010, fbb0f0f0, 3, (RR, oRR, RR), div, t_div),
20247
20248  /* ARM V6M/V7 instructions.  */
20249 #undef  ARM_VARIANT
20250 #define ARM_VARIANT    & arm_ext_barrier
20251 #undef  THUMB_VARIANT
20252 #define THUMB_VARIANT  & arm_ext_barrier
20253
20254  TUF("dmb",     57ff050, f3bf8f50, 1, (oBARRIER_I15), barrier, barrier),
20255  TUF("dsb",     57ff040, f3bf8f40, 1, (oBARRIER_I15), barrier, barrier),
20256  TUF("isb",     57ff060, f3bf8f60, 1, (oBARRIER_I15), barrier, barrier),
20257
20258  /* ARM V7 instructions.  */
20259 #undef  ARM_VARIANT
20260 #define ARM_VARIANT    & arm_ext_v7
20261 #undef  THUMB_VARIANT
20262 #define THUMB_VARIANT  & arm_ext_v7
20263
20264  TUF("pli",     450f000, f910f000, 1, (ADDR),     pli,      t_pld),
20265  TCE("dbg",     320f0f0, f3af80f0, 1, (I15),      dbg,      t_dbg),
20266
20267 #undef  ARM_VARIANT
20268 #define ARM_VARIANT    & arm_ext_mp
20269 #undef  THUMB_VARIANT
20270 #define THUMB_VARIANT  & arm_ext_mp
20271
20272  TUF("pldw",    410f000, f830f000, 1, (ADDR),   pld,    t_pld),
20273
20274  /* AArchv8 instructions.  */
20275 #undef  ARM_VARIANT
20276 #define ARM_VARIANT   & arm_ext_v8
20277
20278 /* Instructions shared between armv8-a and armv8-m.  */
20279 #undef  THUMB_VARIANT
20280 #define THUMB_VARIANT & arm_ext_atomics
20281
20282  TCE("lda",     1900c9f, e8d00faf, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
20283  TCE("ldab",    1d00c9f, e8d00f8f, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
20284  TCE("ldah",    1f00c9f, e8d00f9f, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
20285  TCE("stl",     180fc90, e8c00faf, 2, (RRnpc, RRnpcb),  rm_rn,  rd_rn),
20286  TCE("stlb",    1c0fc90, e8c00f8f, 2, (RRnpc, RRnpcb),  rm_rn,  rd_rn),
20287  TCE("stlh",    1e0fc90, e8c00f9f, 2, (RRnpc, RRnpcb),  rm_rn,  rd_rn),
20288  TCE("ldaex",   1900e9f, e8d00fef, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
20289  TCE("ldaexb",  1d00e9f, e8d00fcf, 2, (RRnpc,RRnpcb),   rd_rn,  rd_rn),
20290  TCE("ldaexh",  1f00e9f, e8d00fdf, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
20291  TCE("stlex",   1800e90, e8c00fe0, 3, (RRnpc, RRnpc, RRnpcb),
20292                                                         stlex,  t_stlex),
20293  TCE("stlexb",  1c00e90, e8c00fc0, 3, (RRnpc, RRnpc, RRnpcb),
20294                                                         stlex, t_stlex),
20295  TCE("stlexh",  1e00e90, e8c00fd0, 3, (RRnpc, RRnpc, RRnpcb),
20296                                                         stlex, t_stlex),
20297 #undef  THUMB_VARIANT
20298 #define THUMB_VARIANT & arm_ext_v8
20299
20300  tCE("sevl",    320f005, _sevl,    0, (),               noargs, t_hint),
20301  TCE("ldaexd",  1b00e9f, e8d000ff, 3, (RRnpc, oRRnpc, RRnpcb),
20302                                                         ldrexd, t_ldrexd),
20303  TCE("stlexd",  1a00e90, e8c000f0, 4, (RRnpc, RRnpc, oRRnpc, RRnpcb),
20304                                                         strexd, t_strexd),
20305
20306 /* Defined in V8 but is in undefined encoding space for earlier
20307    architectures.  However earlier architectures are required to treat
20308    this instuction as a semihosting trap as well.  Hence while not explicitly
20309    defined as such, it is in fact correct to define the instruction for all
20310    architectures.  */
20311 #undef  THUMB_VARIANT
20312 #define THUMB_VARIANT  & arm_ext_v1
20313 #undef  ARM_VARIANT
20314 #define ARM_VARIANT  & arm_ext_v1
20315  TUE("hlt",     1000070, ba80,     1, (oIffffb),        bkpt,   t_hlt),
20316
20317  /* ARMv8 T32 only.  */
20318 #undef  ARM_VARIANT
20319 #define ARM_VARIANT  NULL
20320  TUF("dcps1",   0,       f78f8001, 0, (),       noargs, noargs),
20321  TUF("dcps2",   0,       f78f8002, 0, (),       noargs, noargs),
20322  TUF("dcps3",   0,       f78f8003, 0, (),       noargs, noargs),
20323
20324   /* FP for ARMv8.  */
20325 #undef  ARM_VARIANT
20326 #define ARM_VARIANT   & fpu_vfp_ext_armv8xd
20327 #undef  THUMB_VARIANT
20328 #define THUMB_VARIANT & fpu_vfp_ext_armv8xd
20329
20330   nUF(vseleq, _vseleq, 3, (RVSD, RVSD, RVSD),           vsel),
20331   nUF(vselvs, _vselvs, 3, (RVSD, RVSD, RVSD),           vsel),
20332   nUF(vselge, _vselge, 3, (RVSD, RVSD, RVSD),           vsel),
20333   nUF(vselgt, _vselgt, 3, (RVSD, RVSD, RVSD),           vsel),
20334   nUF(vmaxnm, _vmaxnm, 3, (RNSDQ, oRNSDQ, RNSDQ),       vmaxnm),
20335   nUF(vminnm, _vminnm, 3, (RNSDQ, oRNSDQ, RNSDQ),       vmaxnm),
20336   nUF(vcvta,  _vcvta,  2, (RNSDQ, oRNSDQ),              neon_cvta),
20337   nUF(vcvtn,  _vcvta,  2, (RNSDQ, oRNSDQ),              neon_cvtn),
20338   nUF(vcvtp,  _vcvta,  2, (RNSDQ, oRNSDQ),              neon_cvtp),
20339   nUF(vcvtm,  _vcvta,  2, (RNSDQ, oRNSDQ),              neon_cvtm),
20340   nCE(vrintr, _vrintr, 2, (RNSDQ, oRNSDQ),              vrintr),
20341   nCE(vrintz, _vrintr, 2, (RNSDQ, oRNSDQ),              vrintz),
20342   nCE(vrintx, _vrintr, 2, (RNSDQ, oRNSDQ),              vrintx),
20343   nUF(vrinta, _vrinta, 2, (RNSDQ, oRNSDQ),              vrinta),
20344   nUF(vrintn, _vrinta, 2, (RNSDQ, oRNSDQ),              vrintn),
20345   nUF(vrintp, _vrinta, 2, (RNSDQ, oRNSDQ),              vrintp),
20346   nUF(vrintm, _vrinta, 2, (RNSDQ, oRNSDQ),              vrintm),
20347
20348   /* Crypto v1 extensions.  */
20349 #undef  ARM_VARIANT
20350 #define ARM_VARIANT & fpu_crypto_ext_armv8
20351 #undef  THUMB_VARIANT
20352 #define THUMB_VARIANT & fpu_crypto_ext_armv8
20353
20354   nUF(aese, _aes, 2, (RNQ, RNQ), aese),
20355   nUF(aesd, _aes, 2, (RNQ, RNQ), aesd),
20356   nUF(aesmc, _aes, 2, (RNQ, RNQ), aesmc),
20357   nUF(aesimc, _aes, 2, (RNQ, RNQ), aesimc),
20358   nUF(sha1c, _sha3op, 3, (RNQ, RNQ, RNQ), sha1c),
20359   nUF(sha1p, _sha3op, 3, (RNQ, RNQ, RNQ), sha1p),
20360   nUF(sha1m, _sha3op, 3, (RNQ, RNQ, RNQ), sha1m),
20361   nUF(sha1su0, _sha3op, 3, (RNQ, RNQ, RNQ), sha1su0),
20362   nUF(sha256h, _sha3op, 3, (RNQ, RNQ, RNQ), sha256h),
20363   nUF(sha256h2, _sha3op, 3, (RNQ, RNQ, RNQ), sha256h2),
20364   nUF(sha256su1, _sha3op, 3, (RNQ, RNQ, RNQ), sha256su1),
20365   nUF(sha1h, _sha1h, 2, (RNQ, RNQ), sha1h),
20366   nUF(sha1su1, _sha2op, 2, (RNQ, RNQ), sha1su1),
20367   nUF(sha256su0, _sha2op, 2, (RNQ, RNQ), sha256su0),
20368
20369 #undef  ARM_VARIANT
20370 #define ARM_VARIANT   & crc_ext_armv8
20371 #undef  THUMB_VARIANT
20372 #define THUMB_VARIANT & crc_ext_armv8
20373   TUEc("crc32b", 1000040, fac0f080, 3, (RR, oRR, RR), crc32b),
20374   TUEc("crc32h", 1200040, fac0f090, 3, (RR, oRR, RR), crc32h),
20375   TUEc("crc32w", 1400040, fac0f0a0, 3, (RR, oRR, RR), crc32w),
20376   TUEc("crc32cb",1000240, fad0f080, 3, (RR, oRR, RR), crc32cb),
20377   TUEc("crc32ch",1200240, fad0f090, 3, (RR, oRR, RR), crc32ch),
20378   TUEc("crc32cw",1400240, fad0f0a0, 3, (RR, oRR, RR), crc32cw),
20379
20380  /* ARMv8.2 RAS extension.  */
20381 #undef  ARM_VARIANT
20382 #define ARM_VARIANT   & arm_ext_ras
20383 #undef  THUMB_VARIANT
20384 #define THUMB_VARIANT & arm_ext_ras
20385  TUE ("esb", 320f010, f3af8010, 0, (), noargs,  noargs),
20386
20387 #undef  ARM_VARIANT
20388 #define ARM_VARIANT   & arm_ext_v8_3
20389 #undef  THUMB_VARIANT
20390 #define THUMB_VARIANT & arm_ext_v8_3
20391  NCE (vjcvt, eb90bc0, 2, (RVS, RVD), vjcvt),
20392  NUF (vcmla, 0, 4, (RNDQ, RNDQ, RNDQ_RNSC, EXPi), vcmla),
20393  NUF (vcadd, 0, 4, (RNDQ, RNDQ, RNDQ, EXPi), vcadd),
20394
20395 #undef  ARM_VARIANT
20396 #define ARM_VARIANT   & fpu_neon_ext_dotprod
20397 #undef  THUMB_VARIANT
20398 #define THUMB_VARIANT & fpu_neon_ext_dotprod
20399  NUF (vsdot, d00, 3, (RNDQ, RNDQ, RNDQ_RNSC), neon_dotproduct_s),
20400  NUF (vudot, d00, 3, (RNDQ, RNDQ, RNDQ_RNSC), neon_dotproduct_u),
20401
20402 #undef  ARM_VARIANT
20403 #define ARM_VARIANT  & fpu_fpa_ext_v1  /* Core FPA instruction set (V1).  */
20404 #undef  THUMB_VARIANT
20405 #define THUMB_VARIANT NULL
20406
20407  cCE("wfs",     e200110, 1, (RR),            rd),
20408  cCE("rfs",     e300110, 1, (RR),            rd),
20409  cCE("wfc",     e400110, 1, (RR),            rd),
20410  cCE("rfc",     e500110, 1, (RR),            rd),
20411
20412  cCL("ldfs",    c100100, 2, (RF, ADDRGLDC),  rd_cpaddr),
20413  cCL("ldfd",    c108100, 2, (RF, ADDRGLDC),  rd_cpaddr),
20414  cCL("ldfe",    c500100, 2, (RF, ADDRGLDC),  rd_cpaddr),
20415  cCL("ldfp",    c508100, 2, (RF, ADDRGLDC),  rd_cpaddr),
20416
20417  cCL("stfs",    c000100, 2, (RF, ADDRGLDC),  rd_cpaddr),
20418  cCL("stfd",    c008100, 2, (RF, ADDRGLDC),  rd_cpaddr),
20419  cCL("stfe",    c400100, 2, (RF, ADDRGLDC),  rd_cpaddr),
20420  cCL("stfp",    c408100, 2, (RF, ADDRGLDC),  rd_cpaddr),
20421
20422  cCL("mvfs",    e008100, 2, (RF, RF_IF),     rd_rm),
20423  cCL("mvfsp",   e008120, 2, (RF, RF_IF),     rd_rm),
20424  cCL("mvfsm",   e008140, 2, (RF, RF_IF),     rd_rm),
20425  cCL("mvfsz",   e008160, 2, (RF, RF_IF),     rd_rm),
20426  cCL("mvfd",    e008180, 2, (RF, RF_IF),     rd_rm),
20427  cCL("mvfdp",   e0081a0, 2, (RF, RF_IF),     rd_rm),
20428  cCL("mvfdm",   e0081c0, 2, (RF, RF_IF),     rd_rm),
20429  cCL("mvfdz",   e0081e0, 2, (RF, RF_IF),     rd_rm),
20430  cCL("mvfe",    e088100, 2, (RF, RF_IF),     rd_rm),
20431  cCL("mvfep",   e088120, 2, (RF, RF_IF),     rd_rm),
20432  cCL("mvfem",   e088140, 2, (RF, RF_IF),     rd_rm),
20433  cCL("mvfez",   e088160, 2, (RF, RF_IF),     rd_rm),
20434
20435  cCL("mnfs",    e108100, 2, (RF, RF_IF),     rd_rm),
20436  cCL("mnfsp",   e108120, 2, (RF, RF_IF),     rd_rm),
20437  cCL("mnfsm",   e108140, 2, (RF, RF_IF),     rd_rm),
20438  cCL("mnfsz",   e108160, 2, (RF, RF_IF),     rd_rm),
20439  cCL("mnfd",    e108180, 2, (RF, RF_IF),     rd_rm),
20440  cCL("mnfdp",   e1081a0, 2, (RF, RF_IF),     rd_rm),
20441  cCL("mnfdm",   e1081c0, 2, (RF, RF_IF),     rd_rm),
20442  cCL("mnfdz",   e1081e0, 2, (RF, RF_IF),     rd_rm),
20443  cCL("mnfe",    e188100, 2, (RF, RF_IF),     rd_rm),
20444  cCL("mnfep",   e188120, 2, (RF, RF_IF),     rd_rm),
20445  cCL("mnfem",   e188140, 2, (RF, RF_IF),     rd_rm),
20446  cCL("mnfez",   e188160, 2, (RF, RF_IF),     rd_rm),
20447
20448  cCL("abss",    e208100, 2, (RF, RF_IF),     rd_rm),
20449  cCL("abssp",   e208120, 2, (RF, RF_IF),     rd_rm),
20450  cCL("abssm",   e208140, 2, (RF, RF_IF),     rd_rm),
20451  cCL("abssz",   e208160, 2, (RF, RF_IF),     rd_rm),
20452  cCL("absd",    e208180, 2, (RF, RF_IF),     rd_rm),
20453  cCL("absdp",   e2081a0, 2, (RF, RF_IF),     rd_rm),
20454  cCL("absdm",   e2081c0, 2, (RF, RF_IF),     rd_rm),
20455  cCL("absdz",   e2081e0, 2, (RF, RF_IF),     rd_rm),
20456  cCL("abse",    e288100, 2, (RF, RF_IF),     rd_rm),
20457  cCL("absep",   e288120, 2, (RF, RF_IF),     rd_rm),
20458  cCL("absem",   e288140, 2, (RF, RF_IF),     rd_rm),
20459  cCL("absez",   e288160, 2, (RF, RF_IF),     rd_rm),
20460
20461  cCL("rnds",    e308100, 2, (RF, RF_IF),     rd_rm),
20462  cCL("rndsp",   e308120, 2, (RF, RF_IF),     rd_rm),
20463  cCL("rndsm",   e308140, 2, (RF, RF_IF),     rd_rm),
20464  cCL("rndsz",   e308160, 2, (RF, RF_IF),     rd_rm),
20465  cCL("rndd",    e308180, 2, (RF, RF_IF),     rd_rm),
20466  cCL("rnddp",   e3081a0, 2, (RF, RF_IF),     rd_rm),
20467  cCL("rnddm",   e3081c0, 2, (RF, RF_IF),     rd_rm),
20468  cCL("rnddz",   e3081e0, 2, (RF, RF_IF),     rd_rm),
20469  cCL("rnde",    e388100, 2, (RF, RF_IF),     rd_rm),
20470  cCL("rndep",   e388120, 2, (RF, RF_IF),     rd_rm),
20471  cCL("rndem",   e388140, 2, (RF, RF_IF),     rd_rm),
20472  cCL("rndez",   e388160, 2, (RF, RF_IF),     rd_rm),
20473
20474  cCL("sqts",    e408100, 2, (RF, RF_IF),     rd_rm),
20475  cCL("sqtsp",   e408120, 2, (RF, RF_IF),     rd_rm),
20476  cCL("sqtsm",   e408140, 2, (RF, RF_IF),     rd_rm),
20477  cCL("sqtsz",   e408160, 2, (RF, RF_IF),     rd_rm),
20478  cCL("sqtd",    e408180, 2, (RF, RF_IF),     rd_rm),
20479  cCL("sqtdp",   e4081a0, 2, (RF, RF_IF),     rd_rm),
20480  cCL("sqtdm",   e4081c0, 2, (RF, RF_IF),     rd_rm),
20481  cCL("sqtdz",   e4081e0, 2, (RF, RF_IF),     rd_rm),
20482  cCL("sqte",    e488100, 2, (RF, RF_IF),     rd_rm),
20483  cCL("sqtep",   e488120, 2, (RF, RF_IF),     rd_rm),
20484  cCL("sqtem",   e488140, 2, (RF, RF_IF),     rd_rm),
20485  cCL("sqtez",   e488160, 2, (RF, RF_IF),     rd_rm),
20486
20487  cCL("logs",    e508100, 2, (RF, RF_IF),     rd_rm),
20488  cCL("logsp",   e508120, 2, (RF, RF_IF),     rd_rm),
20489  cCL("logsm",   e508140, 2, (RF, RF_IF),     rd_rm),
20490  cCL("logsz",   e508160, 2, (RF, RF_IF),     rd_rm),
20491  cCL("logd",    e508180, 2, (RF, RF_IF),     rd_rm),
20492  cCL("logdp",   e5081a0, 2, (RF, RF_IF),     rd_rm),
20493  cCL("logdm",   e5081c0, 2, (RF, RF_IF),     rd_rm),
20494  cCL("logdz",   e5081e0, 2, (RF, RF_IF),     rd_rm),
20495  cCL("loge",    e588100, 2, (RF, RF_IF),     rd_rm),
20496  cCL("logep",   e588120, 2, (RF, RF_IF),     rd_rm),
20497  cCL("logem",   e588140, 2, (RF, RF_IF),     rd_rm),
20498  cCL("logez",   e588160, 2, (RF, RF_IF),     rd_rm),
20499
20500  cCL("lgns",    e608100, 2, (RF, RF_IF),     rd_rm),
20501  cCL("lgnsp",   e608120, 2, (RF, RF_IF),     rd_rm),
20502  cCL("lgnsm",   e608140, 2, (RF, RF_IF),     rd_rm),
20503  cCL("lgnsz",   e608160, 2, (RF, RF_IF),     rd_rm),
20504  cCL("lgnd",    e608180, 2, (RF, RF_IF),     rd_rm),
20505  cCL("lgndp",   e6081a0, 2, (RF, RF_IF),     rd_rm),
20506  cCL("lgndm",   e6081c0, 2, (RF, RF_IF),     rd_rm),
20507  cCL("lgndz",   e6081e0, 2, (RF, RF_IF),     rd_rm),
20508  cCL("lgne",    e688100, 2, (RF, RF_IF),     rd_rm),
20509  cCL("lgnep",   e688120, 2, (RF, RF_IF),     rd_rm),
20510  cCL("lgnem",   e688140, 2, (RF, RF_IF),     rd_rm),
20511  cCL("lgnez",   e688160, 2, (RF, RF_IF),     rd_rm),
20512
20513  cCL("exps",    e708100, 2, (RF, RF_IF),     rd_rm),
20514  cCL("expsp",   e708120, 2, (RF, RF_IF),     rd_rm),
20515  cCL("expsm",   e708140, 2, (RF, RF_IF),     rd_rm),
20516  cCL("expsz",   e708160, 2, (RF, RF_IF),     rd_rm),
20517  cCL("expd",    e708180, 2, (RF, RF_IF),     rd_rm),
20518  cCL("expdp",   e7081a0, 2, (RF, RF_IF),     rd_rm),
20519  cCL("expdm",   e7081c0, 2, (RF, RF_IF),     rd_rm),
20520  cCL("expdz",   e7081e0, 2, (RF, RF_IF),     rd_rm),
20521  cCL("expe",    e788100, 2, (RF, RF_IF),     rd_rm),
20522  cCL("expep",   e788120, 2, (RF, RF_IF),     rd_rm),
20523  cCL("expem",   e788140, 2, (RF, RF_IF),     rd_rm),
20524  cCL("expdz",   e788160, 2, (RF, RF_IF),     rd_rm),
20525
20526  cCL("sins",    e808100, 2, (RF, RF_IF),     rd_rm),
20527  cCL("sinsp",   e808120, 2, (RF, RF_IF),     rd_rm),
20528  cCL("sinsm",   e808140, 2, (RF, RF_IF),     rd_rm),
20529  cCL("sinsz",   e808160, 2, (RF, RF_IF),     rd_rm),
20530  cCL("sind",    e808180, 2, (RF, RF_IF),     rd_rm),
20531  cCL("sindp",   e8081a0, 2, (RF, RF_IF),     rd_rm),
20532  cCL("sindm",   e8081c0, 2, (RF, RF_IF),     rd_rm),
20533  cCL("sindz",   e8081e0, 2, (RF, RF_IF),     rd_rm),
20534  cCL("sine",    e888100, 2, (RF, RF_IF),     rd_rm),
20535  cCL("sinep",   e888120, 2, (RF, RF_IF),     rd_rm),
20536  cCL("sinem",   e888140, 2, (RF, RF_IF),     rd_rm),
20537  cCL("sinez",   e888160, 2, (RF, RF_IF),     rd_rm),
20538
20539  cCL("coss",    e908100, 2, (RF, RF_IF),     rd_rm),
20540  cCL("cossp",   e908120, 2, (RF, RF_IF),     rd_rm),
20541  cCL("cossm",   e908140, 2, (RF, RF_IF),     rd_rm),
20542  cCL("cossz",   e908160, 2, (RF, RF_IF),     rd_rm),
20543  cCL("cosd",    e908180, 2, (RF, RF_IF),     rd_rm),
20544  cCL("cosdp",   e9081a0, 2, (RF, RF_IF),     rd_rm),
20545  cCL("cosdm",   e9081c0, 2, (RF, RF_IF),     rd_rm),
20546  cCL("cosdz",   e9081e0, 2, (RF, RF_IF),     rd_rm),
20547  cCL("cose",    e988100, 2, (RF, RF_IF),     rd_rm),
20548  cCL("cosep",   e988120, 2, (RF, RF_IF),     rd_rm),
20549  cCL("cosem",   e988140, 2, (RF, RF_IF),     rd_rm),
20550  cCL("cosez",   e988160, 2, (RF, RF_IF),     rd_rm),
20551
20552  cCL("tans",    ea08100, 2, (RF, RF_IF),     rd_rm),
20553  cCL("tansp",   ea08120, 2, (RF, RF_IF),     rd_rm),
20554  cCL("tansm",   ea08140, 2, (RF, RF_IF),     rd_rm),
20555  cCL("tansz",   ea08160, 2, (RF, RF_IF),     rd_rm),
20556  cCL("tand",    ea08180, 2, (RF, RF_IF),     rd_rm),
20557  cCL("tandp",   ea081a0, 2, (RF, RF_IF),     rd_rm),
20558  cCL("tandm",   ea081c0, 2, (RF, RF_IF),     rd_rm),
20559  cCL("tandz",   ea081e0, 2, (RF, RF_IF),     rd_rm),
20560  cCL("tane",    ea88100, 2, (RF, RF_IF),     rd_rm),
20561  cCL("tanep",   ea88120, 2, (RF, RF_IF),     rd_rm),
20562  cCL("tanem",   ea88140, 2, (RF, RF_IF),     rd_rm),
20563  cCL("tanez",   ea88160, 2, (RF, RF_IF),     rd_rm),
20564
20565  cCL("asns",    eb08100, 2, (RF, RF_IF),     rd_rm),
20566  cCL("asnsp",   eb08120, 2, (RF, RF_IF),     rd_rm),
20567  cCL("asnsm",   eb08140, 2, (RF, RF_IF),     rd_rm),
20568  cCL("asnsz",   eb08160, 2, (RF, RF_IF),     rd_rm),
20569  cCL("asnd",    eb08180, 2, (RF, RF_IF),     rd_rm),
20570  cCL("asndp",   eb081a0, 2, (RF, RF_IF),     rd_rm),
20571  cCL("asndm",   eb081c0, 2, (RF, RF_IF),     rd_rm),
20572  cCL("asndz",   eb081e0, 2, (RF, RF_IF),     rd_rm),
20573  cCL("asne",    eb88100, 2, (RF, RF_IF),     rd_rm),
20574  cCL("asnep",   eb88120, 2, (RF, RF_IF),     rd_rm),
20575  cCL("asnem",   eb88140, 2, (RF, RF_IF),     rd_rm),
20576  cCL("asnez",   eb88160, 2, (RF, RF_IF),     rd_rm),
20577
20578  cCL("acss",    ec08100, 2, (RF, RF_IF),     rd_rm),
20579  cCL("acssp",   ec08120, 2, (RF, RF_IF),     rd_rm),
20580  cCL("acssm",   ec08140, 2, (RF, RF_IF),     rd_rm),
20581  cCL("acssz",   ec08160, 2, (RF, RF_IF),     rd_rm),
20582  cCL("acsd",    ec08180, 2, (RF, RF_IF),     rd_rm),
20583  cCL("acsdp",   ec081a0, 2, (RF, RF_IF),     rd_rm),
20584  cCL("acsdm",   ec081c0, 2, (RF, RF_IF),     rd_rm),
20585  cCL("acsdz",   ec081e0, 2, (RF, RF_IF),     rd_rm),
20586  cCL("acse",    ec88100, 2, (RF, RF_IF),     rd_rm),
20587  cCL("acsep",   ec88120, 2, (RF, RF_IF),     rd_rm),
20588  cCL("acsem",   ec88140, 2, (RF, RF_IF),     rd_rm),
20589  cCL("acsez",   ec88160, 2, (RF, RF_IF),     rd_rm),
20590
20591  cCL("atns",    ed08100, 2, (RF, RF_IF),     rd_rm),
20592  cCL("atnsp",   ed08120, 2, (RF, RF_IF),     rd_rm),
20593  cCL("atnsm",   ed08140, 2, (RF, RF_IF),     rd_rm),
20594  cCL("atnsz",   ed08160, 2, (RF, RF_IF),     rd_rm),
20595  cCL("atnd",    ed08180, 2, (RF, RF_IF),     rd_rm),
20596  cCL("atndp",   ed081a0, 2, (RF, RF_IF),     rd_rm),
20597  cCL("atndm",   ed081c0, 2, (RF, RF_IF),     rd_rm),
20598  cCL("atndz",   ed081e0, 2, (RF, RF_IF),     rd_rm),
20599  cCL("atne",    ed88100, 2, (RF, RF_IF),     rd_rm),
20600  cCL("atnep",   ed88120, 2, (RF, RF_IF),     rd_rm),
20601  cCL("atnem",   ed88140, 2, (RF, RF_IF),     rd_rm),
20602  cCL("atnez",   ed88160, 2, (RF, RF_IF),     rd_rm),
20603
20604  cCL("urds",    ee08100, 2, (RF, RF_IF),     rd_rm),
20605  cCL("urdsp",   ee08120, 2, (RF, RF_IF),     rd_rm),
20606  cCL("urdsm",   ee08140, 2, (RF, RF_IF),     rd_rm),
20607  cCL("urdsz",   ee08160, 2, (RF, RF_IF),     rd_rm),
20608  cCL("urdd",    ee08180, 2, (RF, RF_IF),     rd_rm),
20609  cCL("urddp",   ee081a0, 2, (RF, RF_IF),     rd_rm),
20610  cCL("urddm",   ee081c0, 2, (RF, RF_IF),     rd_rm),
20611  cCL("urddz",   ee081e0, 2, (RF, RF_IF),     rd_rm),
20612  cCL("urde",    ee88100, 2, (RF, RF_IF),     rd_rm),
20613  cCL("urdep",   ee88120, 2, (RF, RF_IF),     rd_rm),
20614  cCL("urdem",   ee88140, 2, (RF, RF_IF),     rd_rm),
20615  cCL("urdez",   ee88160, 2, (RF, RF_IF),     rd_rm),
20616
20617  cCL("nrms",    ef08100, 2, (RF, RF_IF),     rd_rm),
20618  cCL("nrmsp",   ef08120, 2, (RF, RF_IF),     rd_rm),
20619  cCL("nrmsm",   ef08140, 2, (RF, RF_IF),     rd_rm),
20620  cCL("nrmsz",   ef08160, 2, (RF, RF_IF),     rd_rm),
20621  cCL("nrmd",    ef08180, 2, (RF, RF_IF),     rd_rm),
20622  cCL("nrmdp",   ef081a0, 2, (RF, RF_IF),     rd_rm),
20623  cCL("nrmdm",   ef081c0, 2, (RF, RF_IF),     rd_rm),
20624  cCL("nrmdz",   ef081e0, 2, (RF, RF_IF),     rd_rm),
20625  cCL("nrme",    ef88100, 2, (RF, RF_IF),     rd_rm),
20626  cCL("nrmep",   ef88120, 2, (RF, RF_IF),     rd_rm),
20627  cCL("nrmem",   ef88140, 2, (RF, RF_IF),     rd_rm),
20628  cCL("nrmez",   ef88160, 2, (RF, RF_IF),     rd_rm),
20629
20630  cCL("adfs",    e000100, 3, (RF, RF, RF_IF), rd_rn_rm),
20631  cCL("adfsp",   e000120, 3, (RF, RF, RF_IF), rd_rn_rm),
20632  cCL("adfsm",   e000140, 3, (RF, RF, RF_IF), rd_rn_rm),
20633  cCL("adfsz",   e000160, 3, (RF, RF, RF_IF), rd_rn_rm),
20634  cCL("adfd",    e000180, 3, (RF, RF, RF_IF), rd_rn_rm),
20635  cCL("adfdp",   e0001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20636  cCL("adfdm",   e0001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20637  cCL("adfdz",   e0001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20638  cCL("adfe",    e080100, 3, (RF, RF, RF_IF), rd_rn_rm),
20639  cCL("adfep",   e080120, 3, (RF, RF, RF_IF), rd_rn_rm),
20640  cCL("adfem",   e080140, 3, (RF, RF, RF_IF), rd_rn_rm),
20641  cCL("adfez",   e080160, 3, (RF, RF, RF_IF), rd_rn_rm),
20642
20643  cCL("sufs",    e200100, 3, (RF, RF, RF_IF), rd_rn_rm),
20644  cCL("sufsp",   e200120, 3, (RF, RF, RF_IF), rd_rn_rm),
20645  cCL("sufsm",   e200140, 3, (RF, RF, RF_IF), rd_rn_rm),
20646  cCL("sufsz",   e200160, 3, (RF, RF, RF_IF), rd_rn_rm),
20647  cCL("sufd",    e200180, 3, (RF, RF, RF_IF), rd_rn_rm),
20648  cCL("sufdp",   e2001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20649  cCL("sufdm",   e2001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20650  cCL("sufdz",   e2001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20651  cCL("sufe",    e280100, 3, (RF, RF, RF_IF), rd_rn_rm),
20652  cCL("sufep",   e280120, 3, (RF, RF, RF_IF), rd_rn_rm),
20653  cCL("sufem",   e280140, 3, (RF, RF, RF_IF), rd_rn_rm),
20654  cCL("sufez",   e280160, 3, (RF, RF, RF_IF), rd_rn_rm),
20655
20656  cCL("rsfs",    e300100, 3, (RF, RF, RF_IF), rd_rn_rm),
20657  cCL("rsfsp",   e300120, 3, (RF, RF, RF_IF), rd_rn_rm),
20658  cCL("rsfsm",   e300140, 3, (RF, RF, RF_IF), rd_rn_rm),
20659  cCL("rsfsz",   e300160, 3, (RF, RF, RF_IF), rd_rn_rm),
20660  cCL("rsfd",    e300180, 3, (RF, RF, RF_IF), rd_rn_rm),
20661  cCL("rsfdp",   e3001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20662  cCL("rsfdm",   e3001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20663  cCL("rsfdz",   e3001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20664  cCL("rsfe",    e380100, 3, (RF, RF, RF_IF), rd_rn_rm),
20665  cCL("rsfep",   e380120, 3, (RF, RF, RF_IF), rd_rn_rm),
20666  cCL("rsfem",   e380140, 3, (RF, RF, RF_IF), rd_rn_rm),
20667  cCL("rsfez",   e380160, 3, (RF, RF, RF_IF), rd_rn_rm),
20668
20669  cCL("mufs",    e100100, 3, (RF, RF, RF_IF), rd_rn_rm),
20670  cCL("mufsp",   e100120, 3, (RF, RF, RF_IF), rd_rn_rm),
20671  cCL("mufsm",   e100140, 3, (RF, RF, RF_IF), rd_rn_rm),
20672  cCL("mufsz",   e100160, 3, (RF, RF, RF_IF), rd_rn_rm),
20673  cCL("mufd",    e100180, 3, (RF, RF, RF_IF), rd_rn_rm),
20674  cCL("mufdp",   e1001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20675  cCL("mufdm",   e1001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20676  cCL("mufdz",   e1001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20677  cCL("mufe",    e180100, 3, (RF, RF, RF_IF), rd_rn_rm),
20678  cCL("mufep",   e180120, 3, (RF, RF, RF_IF), rd_rn_rm),
20679  cCL("mufem",   e180140, 3, (RF, RF, RF_IF), rd_rn_rm),
20680  cCL("mufez",   e180160, 3, (RF, RF, RF_IF), rd_rn_rm),
20681
20682  cCL("dvfs",    e400100, 3, (RF, RF, RF_IF), rd_rn_rm),
20683  cCL("dvfsp",   e400120, 3, (RF, RF, RF_IF), rd_rn_rm),
20684  cCL("dvfsm",   e400140, 3, (RF, RF, RF_IF), rd_rn_rm),
20685  cCL("dvfsz",   e400160, 3, (RF, RF, RF_IF), rd_rn_rm),
20686  cCL("dvfd",    e400180, 3, (RF, RF, RF_IF), rd_rn_rm),
20687  cCL("dvfdp",   e4001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20688  cCL("dvfdm",   e4001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20689  cCL("dvfdz",   e4001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20690  cCL("dvfe",    e480100, 3, (RF, RF, RF_IF), rd_rn_rm),
20691  cCL("dvfep",   e480120, 3, (RF, RF, RF_IF), rd_rn_rm),
20692  cCL("dvfem",   e480140, 3, (RF, RF, RF_IF), rd_rn_rm),
20693  cCL("dvfez",   e480160, 3, (RF, RF, RF_IF), rd_rn_rm),
20694
20695  cCL("rdfs",    e500100, 3, (RF, RF, RF_IF), rd_rn_rm),
20696  cCL("rdfsp",   e500120, 3, (RF, RF, RF_IF), rd_rn_rm),
20697  cCL("rdfsm",   e500140, 3, (RF, RF, RF_IF), rd_rn_rm),
20698  cCL("rdfsz",   e500160, 3, (RF, RF, RF_IF), rd_rn_rm),
20699  cCL("rdfd",    e500180, 3, (RF, RF, RF_IF), rd_rn_rm),
20700  cCL("rdfdp",   e5001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20701  cCL("rdfdm",   e5001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20702  cCL("rdfdz",   e5001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20703  cCL("rdfe",    e580100, 3, (RF, RF, RF_IF), rd_rn_rm),
20704  cCL("rdfep",   e580120, 3, (RF, RF, RF_IF), rd_rn_rm),
20705  cCL("rdfem",   e580140, 3, (RF, RF, RF_IF), rd_rn_rm),
20706  cCL("rdfez",   e580160, 3, (RF, RF, RF_IF), rd_rn_rm),
20707
20708  cCL("pows",    e600100, 3, (RF, RF, RF_IF), rd_rn_rm),
20709  cCL("powsp",   e600120, 3, (RF, RF, RF_IF), rd_rn_rm),
20710  cCL("powsm",   e600140, 3, (RF, RF, RF_IF), rd_rn_rm),
20711  cCL("powsz",   e600160, 3, (RF, RF, RF_IF), rd_rn_rm),
20712  cCL("powd",    e600180, 3, (RF, RF, RF_IF), rd_rn_rm),
20713  cCL("powdp",   e6001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20714  cCL("powdm",   e6001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20715  cCL("powdz",   e6001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20716  cCL("powe",    e680100, 3, (RF, RF, RF_IF), rd_rn_rm),
20717  cCL("powep",   e680120, 3, (RF, RF, RF_IF), rd_rn_rm),
20718  cCL("powem",   e680140, 3, (RF, RF, RF_IF), rd_rn_rm),
20719  cCL("powez",   e680160, 3, (RF, RF, RF_IF), rd_rn_rm),
20720
20721  cCL("rpws",    e700100, 3, (RF, RF, RF_IF), rd_rn_rm),
20722  cCL("rpwsp",   e700120, 3, (RF, RF, RF_IF), rd_rn_rm),
20723  cCL("rpwsm",   e700140, 3, (RF, RF, RF_IF), rd_rn_rm),
20724  cCL("rpwsz",   e700160, 3, (RF, RF, RF_IF), rd_rn_rm),
20725  cCL("rpwd",    e700180, 3, (RF, RF, RF_IF), rd_rn_rm),
20726  cCL("rpwdp",   e7001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20727  cCL("rpwdm",   e7001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20728  cCL("rpwdz",   e7001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20729  cCL("rpwe",    e780100, 3, (RF, RF, RF_IF), rd_rn_rm),
20730  cCL("rpwep",   e780120, 3, (RF, RF, RF_IF), rd_rn_rm),
20731  cCL("rpwem",   e780140, 3, (RF, RF, RF_IF), rd_rn_rm),
20732  cCL("rpwez",   e780160, 3, (RF, RF, RF_IF), rd_rn_rm),
20733
20734  cCL("rmfs",    e800100, 3, (RF, RF, RF_IF), rd_rn_rm),
20735  cCL("rmfsp",   e800120, 3, (RF, RF, RF_IF), rd_rn_rm),
20736  cCL("rmfsm",   e800140, 3, (RF, RF, RF_IF), rd_rn_rm),
20737  cCL("rmfsz",   e800160, 3, (RF, RF, RF_IF), rd_rn_rm),
20738  cCL("rmfd",    e800180, 3, (RF, RF, RF_IF), rd_rn_rm),
20739  cCL("rmfdp",   e8001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20740  cCL("rmfdm",   e8001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20741  cCL("rmfdz",   e8001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20742  cCL("rmfe",    e880100, 3, (RF, RF, RF_IF), rd_rn_rm),
20743  cCL("rmfep",   e880120, 3, (RF, RF, RF_IF), rd_rn_rm),
20744  cCL("rmfem",   e880140, 3, (RF, RF, RF_IF), rd_rn_rm),
20745  cCL("rmfez",   e880160, 3, (RF, RF, RF_IF), rd_rn_rm),
20746
20747  cCL("fmls",    e900100, 3, (RF, RF, RF_IF), rd_rn_rm),
20748  cCL("fmlsp",   e900120, 3, (RF, RF, RF_IF), rd_rn_rm),
20749  cCL("fmlsm",   e900140, 3, (RF, RF, RF_IF), rd_rn_rm),
20750  cCL("fmlsz",   e900160, 3, (RF, RF, RF_IF), rd_rn_rm),
20751  cCL("fmld",    e900180, 3, (RF, RF, RF_IF), rd_rn_rm),
20752  cCL("fmldp",   e9001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20753  cCL("fmldm",   e9001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20754  cCL("fmldz",   e9001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20755  cCL("fmle",    e980100, 3, (RF, RF, RF_IF), rd_rn_rm),
20756  cCL("fmlep",   e980120, 3, (RF, RF, RF_IF), rd_rn_rm),
20757  cCL("fmlem",   e980140, 3, (RF, RF, RF_IF), rd_rn_rm),
20758  cCL("fmlez",   e980160, 3, (RF, RF, RF_IF), rd_rn_rm),
20759
20760  cCL("fdvs",    ea00100, 3, (RF, RF, RF_IF), rd_rn_rm),
20761  cCL("fdvsp",   ea00120, 3, (RF, RF, RF_IF), rd_rn_rm),
20762  cCL("fdvsm",   ea00140, 3, (RF, RF, RF_IF), rd_rn_rm),
20763  cCL("fdvsz",   ea00160, 3, (RF, RF, RF_IF), rd_rn_rm),
20764  cCL("fdvd",    ea00180, 3, (RF, RF, RF_IF), rd_rn_rm),
20765  cCL("fdvdp",   ea001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20766  cCL("fdvdm",   ea001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20767  cCL("fdvdz",   ea001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20768  cCL("fdve",    ea80100, 3, (RF, RF, RF_IF), rd_rn_rm),
20769  cCL("fdvep",   ea80120, 3, (RF, RF, RF_IF), rd_rn_rm),
20770  cCL("fdvem",   ea80140, 3, (RF, RF, RF_IF), rd_rn_rm),
20771  cCL("fdvez",   ea80160, 3, (RF, RF, RF_IF), rd_rn_rm),
20772
20773  cCL("frds",    eb00100, 3, (RF, RF, RF_IF), rd_rn_rm),
20774  cCL("frdsp",   eb00120, 3, (RF, RF, RF_IF), rd_rn_rm),
20775  cCL("frdsm",   eb00140, 3, (RF, RF, RF_IF), rd_rn_rm),
20776  cCL("frdsz",   eb00160, 3, (RF, RF, RF_IF), rd_rn_rm),
20777  cCL("frdd",    eb00180, 3, (RF, RF, RF_IF), rd_rn_rm),
20778  cCL("frddp",   eb001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20779  cCL("frddm",   eb001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20780  cCL("frddz",   eb001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20781  cCL("frde",    eb80100, 3, (RF, RF, RF_IF), rd_rn_rm),
20782  cCL("frdep",   eb80120, 3, (RF, RF, RF_IF), rd_rn_rm),
20783  cCL("frdem",   eb80140, 3, (RF, RF, RF_IF), rd_rn_rm),
20784  cCL("frdez",   eb80160, 3, (RF, RF, RF_IF), rd_rn_rm),
20785
20786  cCL("pols",    ec00100, 3, (RF, RF, RF_IF), rd_rn_rm),
20787  cCL("polsp",   ec00120, 3, (RF, RF, RF_IF), rd_rn_rm),
20788  cCL("polsm",   ec00140, 3, (RF, RF, RF_IF), rd_rn_rm),
20789  cCL("polsz",   ec00160, 3, (RF, RF, RF_IF), rd_rn_rm),
20790  cCL("pold",    ec00180, 3, (RF, RF, RF_IF), rd_rn_rm),
20791  cCL("poldp",   ec001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
20792  cCL("poldm",   ec001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
20793  cCL("poldz",   ec001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
20794  cCL("pole",    ec80100, 3, (RF, RF, RF_IF), rd_rn_rm),
20795  cCL("polep",   ec80120, 3, (RF, RF, RF_IF), rd_rn_rm),
20796  cCL("polem",   ec80140, 3, (RF, RF, RF_IF), rd_rn_rm),
20797  cCL("polez",   ec80160, 3, (RF, RF, RF_IF), rd_rn_rm),
20798
20799  cCE("cmf",     e90f110, 2, (RF, RF_IF),     fpa_cmp),
20800  C3E("cmfe",    ed0f110, 2, (RF, RF_IF),     fpa_cmp),
20801  cCE("cnf",     eb0f110, 2, (RF, RF_IF),     fpa_cmp),
20802  C3E("cnfe",    ef0f110, 2, (RF, RF_IF),     fpa_cmp),
20803
20804  cCL("flts",    e000110, 2, (RF, RR),        rn_rd),
20805  cCL("fltsp",   e000130, 2, (RF, RR),        rn_rd),
20806  cCL("fltsm",   e000150, 2, (RF, RR),        rn_rd),
20807  cCL("fltsz",   e000170, 2, (RF, RR),        rn_rd),
20808  cCL("fltd",    e000190, 2, (RF, RR),        rn_rd),
20809  cCL("fltdp",   e0001b0, 2, (RF, RR),        rn_rd),
20810  cCL("fltdm",   e0001d0, 2, (RF, RR),        rn_rd),
20811  cCL("fltdz",   e0001f0, 2, (RF, RR),        rn_rd),
20812  cCL("flte",    e080110, 2, (RF, RR),        rn_rd),
20813  cCL("fltep",   e080130, 2, (RF, RR),        rn_rd),
20814  cCL("fltem",   e080150, 2, (RF, RR),        rn_rd),
20815  cCL("fltez",   e080170, 2, (RF, RR),        rn_rd),
20816
20817   /* The implementation of the FIX instruction is broken on some
20818      assemblers, in that it accepts a precision specifier as well as a
20819      rounding specifier, despite the fact that this is meaningless.
20820      To be more compatible, we accept it as well, though of course it
20821      does not set any bits.  */
20822  cCE("fix",     e100110, 2, (RR, RF),        rd_rm),
20823  cCL("fixp",    e100130, 2, (RR, RF),        rd_rm),
20824  cCL("fixm",    e100150, 2, (RR, RF),        rd_rm),
20825  cCL("fixz",    e100170, 2, (RR, RF),        rd_rm),
20826  cCL("fixsp",   e100130, 2, (RR, RF),        rd_rm),
20827  cCL("fixsm",   e100150, 2, (RR, RF),        rd_rm),
20828  cCL("fixsz",   e100170, 2, (RR, RF),        rd_rm),
20829  cCL("fixdp",   e100130, 2, (RR, RF),        rd_rm),
20830  cCL("fixdm",   e100150, 2, (RR, RF),        rd_rm),
20831  cCL("fixdz",   e100170, 2, (RR, RF),        rd_rm),
20832  cCL("fixep",   e100130, 2, (RR, RF),        rd_rm),
20833  cCL("fixem",   e100150, 2, (RR, RF),        rd_rm),
20834  cCL("fixez",   e100170, 2, (RR, RF),        rd_rm),
20835
20836   /* Instructions that were new with the real FPA, call them V2.  */
20837 #undef  ARM_VARIANT
20838 #define ARM_VARIANT  & fpu_fpa_ext_v2
20839
20840  cCE("lfm",     c100200, 3, (RF, I4b, ADDR), fpa_ldmstm),
20841  cCL("lfmfd",   c900200, 3, (RF, I4b, ADDR), fpa_ldmstm),
20842  cCL("lfmea",   d100200, 3, (RF, I4b, ADDR), fpa_ldmstm),
20843  cCE("sfm",     c000200, 3, (RF, I4b, ADDR), fpa_ldmstm),
20844  cCL("sfmfd",   d000200, 3, (RF, I4b, ADDR), fpa_ldmstm),
20845  cCL("sfmea",   c800200, 3, (RF, I4b, ADDR), fpa_ldmstm),
20846
20847 #undef  ARM_VARIANT
20848 #define ARM_VARIANT  & fpu_vfp_ext_v1xd  /* VFP V1xD (single precision).  */
20849
20850   /* Moves and type conversions.  */
20851  cCE("fcpys",   eb00a40, 2, (RVS, RVS),       vfp_sp_monadic),
20852  cCE("fmrs",    e100a10, 2, (RR, RVS),        vfp_reg_from_sp),
20853  cCE("fmsr",    e000a10, 2, (RVS, RR),        vfp_sp_from_reg),
20854  cCE("fmstat",  ef1fa10, 0, (),               noargs),
20855  cCE("vmrs",    ef00a10, 2, (APSR_RR, RVC),   vmrs),
20856  cCE("vmsr",    ee00a10, 2, (RVC, RR),        vmsr),
20857  cCE("fsitos",  eb80ac0, 2, (RVS, RVS),       vfp_sp_monadic),
20858  cCE("fuitos",  eb80a40, 2, (RVS, RVS),       vfp_sp_monadic),
20859  cCE("ftosis",  ebd0a40, 2, (RVS, RVS),       vfp_sp_monadic),
20860  cCE("ftosizs", ebd0ac0, 2, (RVS, RVS),       vfp_sp_monadic),
20861  cCE("ftouis",  ebc0a40, 2, (RVS, RVS),       vfp_sp_monadic),
20862  cCE("ftouizs", ebc0ac0, 2, (RVS, RVS),       vfp_sp_monadic),
20863  cCE("fmrx",    ef00a10, 2, (RR, RVC),        rd_rn),
20864  cCE("fmxr",    ee00a10, 2, (RVC, RR),        rn_rd),
20865
20866   /* Memory operations.  */
20867  cCE("flds",    d100a00, 2, (RVS, ADDRGLDC),  vfp_sp_ldst),
20868  cCE("fsts",    d000a00, 2, (RVS, ADDRGLDC),  vfp_sp_ldst),
20869  cCE("fldmias", c900a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
20870  cCE("fldmfds", c900a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
20871  cCE("fldmdbs", d300a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
20872  cCE("fldmeas", d300a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
20873  cCE("fldmiax", c900b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
20874  cCE("fldmfdx", c900b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
20875  cCE("fldmdbx", d300b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
20876  cCE("fldmeax", d300b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
20877  cCE("fstmias", c800a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
20878  cCE("fstmeas", c800a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
20879  cCE("fstmdbs", d200a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
20880  cCE("fstmfds", d200a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
20881  cCE("fstmiax", c800b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
20882  cCE("fstmeax", c800b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
20883  cCE("fstmdbx", d200b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
20884  cCE("fstmfdx", d200b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
20885
20886   /* Monadic operations.  */
20887  cCE("fabss",   eb00ac0, 2, (RVS, RVS),       vfp_sp_monadic),
20888  cCE("fnegs",   eb10a40, 2, (RVS, RVS),       vfp_sp_monadic),
20889  cCE("fsqrts",  eb10ac0, 2, (RVS, RVS),       vfp_sp_monadic),
20890
20891   /* Dyadic operations.  */
20892  cCE("fadds",   e300a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
20893  cCE("fsubs",   e300a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
20894  cCE("fmuls",   e200a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
20895  cCE("fdivs",   e800a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
20896  cCE("fmacs",   e000a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
20897  cCE("fmscs",   e100a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
20898  cCE("fnmuls",  e200a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
20899  cCE("fnmacs",  e000a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
20900  cCE("fnmscs",  e100a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
20901
20902   /* Comparisons.  */
20903  cCE("fcmps",   eb40a40, 2, (RVS, RVS),       vfp_sp_monadic),
20904  cCE("fcmpzs",  eb50a40, 1, (RVS),            vfp_sp_compare_z),
20905  cCE("fcmpes",  eb40ac0, 2, (RVS, RVS),       vfp_sp_monadic),
20906  cCE("fcmpezs", eb50ac0, 1, (RVS),            vfp_sp_compare_z),
20907
20908  /* Double precision load/store are still present on single precision
20909     implementations.  */
20910  cCE("fldd",    d100b00, 2, (RVD, ADDRGLDC),  vfp_dp_ldst),
20911  cCE("fstd",    d000b00, 2, (RVD, ADDRGLDC),  vfp_dp_ldst),
20912  cCE("fldmiad", c900b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
20913  cCE("fldmfdd", c900b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
20914  cCE("fldmdbd", d300b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
20915  cCE("fldmead", d300b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
20916  cCE("fstmiad", c800b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
20917  cCE("fstmead", c800b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
20918  cCE("fstmdbd", d200b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
20919  cCE("fstmfdd", d200b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
20920
20921 #undef  ARM_VARIANT
20922 #define ARM_VARIANT  & fpu_vfp_ext_v1 /* VFP V1 (Double precision).  */
20923
20924   /* Moves and type conversions.  */
20925  cCE("fcpyd",   eb00b40, 2, (RVD, RVD),       vfp_dp_rd_rm),
20926  cCE("fcvtds",  eb70ac0, 2, (RVD, RVS),       vfp_dp_sp_cvt),
20927  cCE("fcvtsd",  eb70bc0, 2, (RVS, RVD),       vfp_sp_dp_cvt),
20928  cCE("fmdhr",   e200b10, 2, (RVD, RR),        vfp_dp_rn_rd),
20929  cCE("fmdlr",   e000b10, 2, (RVD, RR),        vfp_dp_rn_rd),
20930  cCE("fmrdh",   e300b10, 2, (RR, RVD),        vfp_dp_rd_rn),
20931  cCE("fmrdl",   e100b10, 2, (RR, RVD),        vfp_dp_rd_rn),
20932  cCE("fsitod",  eb80bc0, 2, (RVD, RVS),       vfp_dp_sp_cvt),
20933  cCE("fuitod",  eb80b40, 2, (RVD, RVS),       vfp_dp_sp_cvt),
20934  cCE("ftosid",  ebd0b40, 2, (RVS, RVD),       vfp_sp_dp_cvt),
20935  cCE("ftosizd", ebd0bc0, 2, (RVS, RVD),       vfp_sp_dp_cvt),
20936  cCE("ftouid",  ebc0b40, 2, (RVS, RVD),       vfp_sp_dp_cvt),
20937  cCE("ftouizd", ebc0bc0, 2, (RVS, RVD),       vfp_sp_dp_cvt),
20938
20939   /* Monadic operations.  */
20940  cCE("fabsd",   eb00bc0, 2, (RVD, RVD),       vfp_dp_rd_rm),
20941  cCE("fnegd",   eb10b40, 2, (RVD, RVD),       vfp_dp_rd_rm),
20942  cCE("fsqrtd",  eb10bc0, 2, (RVD, RVD),       vfp_dp_rd_rm),
20943
20944   /* Dyadic operations.  */
20945  cCE("faddd",   e300b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
20946  cCE("fsubd",   e300b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
20947  cCE("fmuld",   e200b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
20948  cCE("fdivd",   e800b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
20949  cCE("fmacd",   e000b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
20950  cCE("fmscd",   e100b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
20951  cCE("fnmuld",  e200b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
20952  cCE("fnmacd",  e000b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
20953  cCE("fnmscd",  e100b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
20954
20955   /* Comparisons.  */
20956  cCE("fcmpd",   eb40b40, 2, (RVD, RVD),       vfp_dp_rd_rm),
20957  cCE("fcmpzd",  eb50b40, 1, (RVD),            vfp_dp_rd),
20958  cCE("fcmped",  eb40bc0, 2, (RVD, RVD),       vfp_dp_rd_rm),
20959  cCE("fcmpezd", eb50bc0, 1, (RVD),            vfp_dp_rd),
20960
20961 #undef  ARM_VARIANT
20962 #define ARM_VARIANT  & fpu_vfp_ext_v2
20963
20964  cCE("fmsrr",   c400a10, 3, (VRSLST, RR, RR), vfp_sp2_from_reg2),
20965  cCE("fmrrs",   c500a10, 3, (RR, RR, VRSLST), vfp_reg2_from_sp2),
20966  cCE("fmdrr",   c400b10, 3, (RVD, RR, RR),    vfp_dp_rm_rd_rn),
20967  cCE("fmrrd",   c500b10, 3, (RR, RR, RVD),    vfp_dp_rd_rn_rm),
20968
20969 /* Instructions which may belong to either the Neon or VFP instruction sets.
20970    Individual encoder functions perform additional architecture checks.  */
20971 #undef  ARM_VARIANT
20972 #define ARM_VARIANT    & fpu_vfp_ext_v1xd
20973 #undef  THUMB_VARIANT
20974 #define THUMB_VARIANT  & fpu_vfp_ext_v1xd
20975
20976   /* These mnemonics are unique to VFP.  */
20977  NCE(vsqrt,     0,       2, (RVSD, RVSD),       vfp_nsyn_sqrt),
20978  NCE(vdiv,      0,       3, (RVSD, RVSD, RVSD), vfp_nsyn_div),
20979  nCE(vnmul,     _vnmul,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
20980  nCE(vnmla,     _vnmla,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
20981  nCE(vnmls,     _vnmls,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
20982  nCE(vcmp,      _vcmp,    2, (RVSD, RSVD_FI0),    vfp_nsyn_cmp),
20983  nCE(vcmpe,     _vcmpe,   2, (RVSD, RSVD_FI0),    vfp_nsyn_cmp),
20984  NCE(vpush,     0,       1, (VRSDLST),          vfp_nsyn_push),
20985  NCE(vpop,      0,       1, (VRSDLST),          vfp_nsyn_pop),
20986  NCE(vcvtz,     0,       2, (RVSD, RVSD),       vfp_nsyn_cvtz),
20987
20988   /* Mnemonics shared by Neon and VFP.  */
20989  nCEF(vmul,     _vmul,    3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mul),
20990  nCEF(vmla,     _vmla,    3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mac_maybe_scalar),
20991  nCEF(vmls,     _vmls,    3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mac_maybe_scalar),
20992
20993  nCEF(vadd,     _vadd,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_addsub_if_i),
20994  nCEF(vsub,     _vsub,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_addsub_if_i),
20995
20996  NCEF(vabs,     1b10300, 2, (RNSDQ, RNSDQ), neon_abs_neg),
20997  NCEF(vneg,     1b10380, 2, (RNSDQ, RNSDQ), neon_abs_neg),
20998
20999  NCE(vldm,      c900b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
21000  NCE(vldmia,    c900b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
21001  NCE(vldmdb,    d100b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
21002  NCE(vstm,      c800b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
21003  NCE(vstmia,    c800b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
21004  NCE(vstmdb,    d000b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
21005  NCE(vldr,      d100b00, 2, (RVSD, ADDRGLDC), neon_ldr_str),
21006  NCE(vstr,      d000b00, 2, (RVSD, ADDRGLDC), neon_ldr_str),
21007
21008  nCEF(vcvt,     _vcvt,   3, (RNSDQ, RNSDQ, oI32z), neon_cvt),
21009  nCEF(vcvtr,    _vcvt,   2, (RNSDQ, RNSDQ), neon_cvtr),
21010  NCEF(vcvtb,    eb20a40, 2, (RVSD, RVSD), neon_cvtb),
21011  NCEF(vcvtt,    eb20a40, 2, (RVSD, RVSD), neon_cvtt),
21012
21013
21014   /* NOTE: All VMOV encoding is special-cased!  */
21015  NCE(vmov,      0,       1, (VMOV), neon_mov),
21016  NCE(vmovq,     0,       1, (VMOV), neon_mov),
21017
21018 #undef  ARM_VARIANT
21019 #define ARM_VARIANT    & arm_ext_fp16
21020 #undef  THUMB_VARIANT
21021 #define THUMB_VARIANT  & arm_ext_fp16
21022  /* New instructions added from v8.2, allowing the extraction and insertion of
21023     the upper 16 bits of a 32-bit vector register.  */
21024  NCE (vmovx,     eb00a40,       2, (RVS, RVS), neon_movhf),
21025  NCE (vins,      eb00ac0,       2, (RVS, RVS), neon_movhf),
21026
21027  /* New backported fma/fms instructions optional in v8.2.  */
21028  NCE (vfmal, 810, 3, (RNDQ, RNSD, RNSD_RNSC), neon_vfmal),
21029  NCE (vfmsl, 810, 3, (RNDQ, RNSD, RNSD_RNSC), neon_vfmsl),
21030
21031 #undef  THUMB_VARIANT
21032 #define THUMB_VARIANT  & fpu_neon_ext_v1
21033 #undef  ARM_VARIANT
21034 #define ARM_VARIANT    & fpu_neon_ext_v1
21035
21036   /* Data processing with three registers of the same length.  */
21037   /* integer ops, valid types S8 S16 S32 U8 U16 U32.  */
21038  NUF(vaba,      0000710, 3, (RNDQ, RNDQ,  RNDQ), neon_dyadic_i_su),
21039  NUF(vabaq,     0000710, 3, (RNQ,  RNQ,   RNQ),  neon_dyadic_i_su),
21040  NUF(vhadd,     0000000, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
21041  NUF(vhaddq,    0000000, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i_su),
21042  NUF(vrhadd,    0000100, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
21043  NUF(vrhaddq,   0000100, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i_su),
21044  NUF(vhsub,     0000200, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
21045  NUF(vhsubq,    0000200, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i_su),
21046   /* integer ops, valid types S8 S16 S32 S64 U8 U16 U32 U64.  */
21047  NUF(vqadd,     0000010, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i64_su),
21048  NUF(vqaddq,    0000010, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i64_su),
21049  NUF(vqsub,     0000210, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i64_su),
21050  NUF(vqsubq,    0000210, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i64_su),
21051  NUF(vrshl,     0000500, 3, (RNDQ, oRNDQ, RNDQ), neon_rshl),
21052  NUF(vrshlq,    0000500, 3, (RNQ,  oRNQ,  RNQ),  neon_rshl),
21053  NUF(vqrshl,    0000510, 3, (RNDQ, oRNDQ, RNDQ), neon_rshl),
21054  NUF(vqrshlq,   0000510, 3, (RNQ,  oRNQ,  RNQ),  neon_rshl),
21055   /* If not immediate, fall back to neon_dyadic_i64_su.
21056      shl_imm should accept I8 I16 I32 I64,
21057      qshl_imm should accept S8 S16 S32 S64 U8 U16 U32 U64.  */
21058  nUF(vshl,      _vshl,    3, (RNDQ, oRNDQ, RNDQ_I63b), neon_shl_imm),
21059  nUF(vshlq,     _vshl,    3, (RNQ,  oRNQ,  RNDQ_I63b), neon_shl_imm),
21060  nUF(vqshl,     _vqshl,   3, (RNDQ, oRNDQ, RNDQ_I63b), neon_qshl_imm),
21061  nUF(vqshlq,    _vqshl,   3, (RNQ,  oRNQ,  RNDQ_I63b), neon_qshl_imm),
21062   /* Logic ops, types optional & ignored.  */
21063  nUF(vand,      _vand,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
21064  nUF(vandq,     _vand,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
21065  nUF(vbic,      _vbic,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
21066  nUF(vbicq,     _vbic,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
21067  nUF(vorr,      _vorr,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
21068  nUF(vorrq,     _vorr,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
21069  nUF(vorn,      _vorn,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
21070  nUF(vornq,     _vorn,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
21071  nUF(veor,      _veor,    3, (RNDQ, oRNDQ, RNDQ),      neon_logic),
21072  nUF(veorq,     _veor,    3, (RNQ,  oRNQ,  RNQ),       neon_logic),
21073   /* Bitfield ops, untyped.  */
21074  NUF(vbsl,      1100110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
21075  NUF(vbslq,     1100110, 3, (RNQ,  RNQ,  RNQ),  neon_bitfield),
21076  NUF(vbit,      1200110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
21077  NUF(vbitq,     1200110, 3, (RNQ,  RNQ,  RNQ),  neon_bitfield),
21078  NUF(vbif,      1300110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
21079  NUF(vbifq,     1300110, 3, (RNQ,  RNQ,  RNQ),  neon_bitfield),
21080   /* Int and float variants, types S8 S16 S32 U8 U16 U32 F16 F32.  */
21081  nUF(vabd,      _vabd,    3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
21082  nUF(vabdq,     _vabd,    3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_if_su),
21083  nUF(vmax,      _vmax,    3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
21084  nUF(vmaxq,     _vmax,    3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_if_su),
21085  nUF(vmin,      _vmin,    3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
21086  nUF(vminq,     _vmin,    3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_if_su),
21087   /* Comparisons. Types S8 S16 S32 U8 U16 U32 F32. Non-immediate versions fall
21088      back to neon_dyadic_if_su.  */
21089  nUF(vcge,      _vcge,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp),
21090  nUF(vcgeq,     _vcge,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp),
21091  nUF(vcgt,      _vcgt,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp),
21092  nUF(vcgtq,     _vcgt,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp),
21093  nUF(vclt,      _vclt,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp_inv),
21094  nUF(vcltq,     _vclt,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp_inv),
21095  nUF(vcle,      _vcle,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp_inv),
21096  nUF(vcleq,     _vcle,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp_inv),
21097   /* Comparison. Type I8 I16 I32 F32.  */
21098  nUF(vceq,      _vceq,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_ceq),
21099  nUF(vceqq,     _vceq,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_ceq),
21100   /* As above, D registers only.  */
21101  nUF(vpmax,     _vpmax,   3, (RND, oRND, RND), neon_dyadic_if_su_d),
21102  nUF(vpmin,     _vpmin,   3, (RND, oRND, RND), neon_dyadic_if_su_d),
21103   /* Int and float variants, signedness unimportant.  */
21104  nUF(vmlaq,     _vmla,    3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_mac_maybe_scalar),
21105  nUF(vmlsq,     _vmls,    3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_mac_maybe_scalar),
21106  nUF(vpadd,     _vpadd,   3, (RND,  oRND,  RND),       neon_dyadic_if_i_d),
21107   /* Add/sub take types I8 I16 I32 I64 F32.  */
21108  nUF(vaddq,     _vadd,    3, (RNQ,  oRNQ,  RNQ),  neon_addsub_if_i),
21109  nUF(vsubq,     _vsub,    3, (RNQ,  oRNQ,  RNQ),  neon_addsub_if_i),
21110   /* vtst takes sizes 8, 16, 32.  */
21111  NUF(vtst,      0000810, 3, (RNDQ, oRNDQ, RNDQ), neon_tst),
21112  NUF(vtstq,     0000810, 3, (RNQ,  oRNQ,  RNQ),  neon_tst),
21113   /* VMUL takes I8 I16 I32 F32 P8.  */
21114  nUF(vmulq,     _vmul,     3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_mul),
21115   /* VQD{R}MULH takes S16 S32.  */
21116  nUF(vqdmulh,   _vqdmulh,  3, (RNDQ, oRNDQ, RNDQ_RNSC), neon_qdmulh),
21117  nUF(vqdmulhq,  _vqdmulh,  3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_qdmulh),
21118  nUF(vqrdmulh,  _vqrdmulh, 3, (RNDQ, oRNDQ, RNDQ_RNSC), neon_qdmulh),
21119  nUF(vqrdmulhq, _vqrdmulh, 3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_qdmulh),
21120  NUF(vacge,     0000e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute),
21121  NUF(vacgeq,    0000e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute),
21122  NUF(vacgt,     0200e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute),
21123  NUF(vacgtq,    0200e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute),
21124  NUF(vaclt,     0200e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute_inv),
21125  NUF(vacltq,    0200e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute_inv),
21126  NUF(vacle,     0000e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute_inv),
21127  NUF(vacleq,    0000e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute_inv),
21128  NUF(vrecps,    0000f10,  3, (RNDQ, oRNDQ, RNDQ), neon_step),
21129  NUF(vrecpsq,   0000f10,  3, (RNQ,  oRNQ,  RNQ),  neon_step),
21130  NUF(vrsqrts,   0200f10,  3, (RNDQ, oRNDQ, RNDQ), neon_step),
21131  NUF(vrsqrtsq,  0200f10,  3, (RNQ,  oRNQ,  RNQ),  neon_step),
21132  /* ARM v8.1 extension.  */
21133  nUF (vqrdmlah,  _vqrdmlah, 3, (RNDQ, oRNDQ, RNDQ_RNSC), neon_qrdmlah),
21134  nUF (vqrdmlahq, _vqrdmlah, 3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_qrdmlah),
21135  nUF (vqrdmlsh,  _vqrdmlsh, 3, (RNDQ, oRNDQ, RNDQ_RNSC), neon_qrdmlah),
21136  nUF (vqrdmlshq, _vqrdmlsh, 3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_qrdmlah),
21137
21138   /* Two address, int/float. Types S8 S16 S32 F32.  */
21139  NUF(vabsq,     1b10300, 2, (RNQ,  RNQ),      neon_abs_neg),
21140  NUF(vnegq,     1b10380, 2, (RNQ,  RNQ),      neon_abs_neg),
21141
21142   /* Data processing with two registers and a shift amount.  */
21143   /* Right shifts, and variants with rounding.
21144      Types accepted S8 S16 S32 S64 U8 U16 U32 U64.  */
21145  NUF(vshr,      0800010, 3, (RNDQ, oRNDQ, I64z), neon_rshift_round_imm),
21146  NUF(vshrq,     0800010, 3, (RNQ,  oRNQ,  I64z), neon_rshift_round_imm),
21147  NUF(vrshr,     0800210, 3, (RNDQ, oRNDQ, I64z), neon_rshift_round_imm),
21148  NUF(vrshrq,    0800210, 3, (RNQ,  oRNQ,  I64z), neon_rshift_round_imm),
21149  NUF(vsra,      0800110, 3, (RNDQ, oRNDQ, I64),  neon_rshift_round_imm),
21150  NUF(vsraq,     0800110, 3, (RNQ,  oRNQ,  I64),  neon_rshift_round_imm),
21151  NUF(vrsra,     0800310, 3, (RNDQ, oRNDQ, I64),  neon_rshift_round_imm),
21152  NUF(vrsraq,    0800310, 3, (RNQ,  oRNQ,  I64),  neon_rshift_round_imm),
21153   /* Shift and insert. Sizes accepted 8 16 32 64.  */
21154  NUF(vsli,      1800510, 3, (RNDQ, oRNDQ, I63), neon_sli),
21155  NUF(vsliq,     1800510, 3, (RNQ,  oRNQ,  I63), neon_sli),
21156  NUF(vsri,      1800410, 3, (RNDQ, oRNDQ, I64), neon_sri),
21157  NUF(vsriq,     1800410, 3, (RNQ,  oRNQ,  I64), neon_sri),
21158   /* QSHL{U} immediate accepts S8 S16 S32 S64 U8 U16 U32 U64.  */
21159  NUF(vqshlu,    1800610, 3, (RNDQ, oRNDQ, I63), neon_qshlu_imm),
21160  NUF(vqshluq,   1800610, 3, (RNQ,  oRNQ,  I63), neon_qshlu_imm),
21161   /* Right shift immediate, saturating & narrowing, with rounding variants.
21162      Types accepted S16 S32 S64 U16 U32 U64.  */
21163  NUF(vqshrn,    0800910, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow),
21164  NUF(vqrshrn,   0800950, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow),
21165   /* As above, unsigned. Types accepted S16 S32 S64.  */
21166  NUF(vqshrun,   0800810, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow_u),
21167  NUF(vqrshrun,  0800850, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow_u),
21168   /* Right shift narrowing. Types accepted I16 I32 I64.  */
21169  NUF(vshrn,     0800810, 3, (RND, RNQ, I32z), neon_rshift_narrow),
21170  NUF(vrshrn,    0800850, 3, (RND, RNQ, I32z), neon_rshift_narrow),
21171   /* Special case. Types S8 S16 S32 U8 U16 U32. Handles max shift variant.  */
21172  nUF(vshll,     _vshll,   3, (RNQ, RND, I32),  neon_shll),
21173   /* CVT with optional immediate for fixed-point variant.  */
21174  nUF(vcvtq,     _vcvt,    3, (RNQ, RNQ, oI32b), neon_cvt),
21175
21176  nUF(vmvn,      _vmvn,    2, (RNDQ, RNDQ_Ibig), neon_mvn),
21177  nUF(vmvnq,     _vmvn,    2, (RNQ,  RNDQ_Ibig), neon_mvn),
21178
21179   /* Data processing, three registers of different lengths.  */
21180   /* Dyadic, long insns. Types S8 S16 S32 U8 U16 U32.  */
21181  NUF(vabal,     0800500, 3, (RNQ, RND, RND),  neon_abal),
21182  NUF(vabdl,     0800700, 3, (RNQ, RND, RND),  neon_dyadic_long),
21183  NUF(vaddl,     0800000, 3, (RNQ, RND, RND),  neon_dyadic_long),
21184  NUF(vsubl,     0800200, 3, (RNQ, RND, RND),  neon_dyadic_long),
21185   /* If not scalar, fall back to neon_dyadic_long.
21186      Vector types as above, scalar types S16 S32 U16 U32.  */
21187  nUF(vmlal,     _vmlal,   3, (RNQ, RND, RND_RNSC), neon_mac_maybe_scalar_long),
21188  nUF(vmlsl,     _vmlsl,   3, (RNQ, RND, RND_RNSC), neon_mac_maybe_scalar_long),
21189   /* Dyadic, widening insns. Types S8 S16 S32 U8 U16 U32.  */
21190  NUF(vaddw,     0800100, 3, (RNQ, oRNQ, RND), neon_dyadic_wide),
21191  NUF(vsubw,     0800300, 3, (RNQ, oRNQ, RND), neon_dyadic_wide),
21192   /* Dyadic, narrowing insns. Types I16 I32 I64.  */
21193  NUF(vaddhn,    0800400, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
21194  NUF(vraddhn,   1800400, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
21195  NUF(vsubhn,    0800600, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
21196  NUF(vrsubhn,   1800600, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
21197   /* Saturating doubling multiplies. Types S16 S32.  */
21198  nUF(vqdmlal,   _vqdmlal, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
21199  nUF(vqdmlsl,   _vqdmlsl, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
21200  nUF(vqdmull,   _vqdmull, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
21201   /* VMULL. Vector types S8 S16 S32 U8 U16 U32 P8, scalar types
21202      S16 S32 U16 U32.  */
21203  nUF(vmull,     _vmull,   3, (RNQ, RND, RND_RNSC), neon_vmull),
21204
21205   /* Extract. Size 8.  */
21206  NUF(vext,      0b00000, 4, (RNDQ, oRNDQ, RNDQ, I15), neon_ext),
21207  NUF(vextq,     0b00000, 4, (RNQ,  oRNQ,  RNQ,  I15), neon_ext),
21208
21209   /* Two registers, miscellaneous.  */
21210   /* Reverse. Sizes 8 16 32 (must be < size in opcode).  */
21211  NUF(vrev64,    1b00000, 2, (RNDQ, RNDQ),     neon_rev),
21212  NUF(vrev64q,   1b00000, 2, (RNQ,  RNQ),      neon_rev),
21213  NUF(vrev32,    1b00080, 2, (RNDQ, RNDQ),     neon_rev),
21214  NUF(vrev32q,   1b00080, 2, (RNQ,  RNQ),      neon_rev),
21215  NUF(vrev16,    1b00100, 2, (RNDQ, RNDQ),     neon_rev),
21216  NUF(vrev16q,   1b00100, 2, (RNQ,  RNQ),      neon_rev),
21217   /* Vector replicate. Sizes 8 16 32.  */
21218  nCE(vdup,      _vdup,    2, (RNDQ, RR_RNSC),  neon_dup),
21219  nCE(vdupq,     _vdup,    2, (RNQ,  RR_RNSC),  neon_dup),
21220   /* VMOVL. Types S8 S16 S32 U8 U16 U32.  */
21221  NUF(vmovl,     0800a10, 2, (RNQ, RND),       neon_movl),
21222   /* VMOVN. Types I16 I32 I64.  */
21223  nUF(vmovn,     _vmovn,   2, (RND, RNQ),       neon_movn),
21224   /* VQMOVN. Types S16 S32 S64 U16 U32 U64.  */
21225  nUF(vqmovn,    _vqmovn,  2, (RND, RNQ),       neon_qmovn),
21226   /* VQMOVUN. Types S16 S32 S64.  */
21227  nUF(vqmovun,   _vqmovun, 2, (RND, RNQ),       neon_qmovun),
21228   /* VZIP / VUZP. Sizes 8 16 32.  */
21229  NUF(vzip,      1b20180, 2, (RNDQ, RNDQ),     neon_zip_uzp),
21230  NUF(vzipq,     1b20180, 2, (RNQ,  RNQ),      neon_zip_uzp),
21231  NUF(vuzp,      1b20100, 2, (RNDQ, RNDQ),     neon_zip_uzp),
21232  NUF(vuzpq,     1b20100, 2, (RNQ,  RNQ),      neon_zip_uzp),
21233   /* VQABS / VQNEG. Types S8 S16 S32.  */
21234  NUF(vqabs,     1b00700, 2, (RNDQ, RNDQ),     neon_sat_abs_neg),
21235  NUF(vqabsq,    1b00700, 2, (RNQ,  RNQ),      neon_sat_abs_neg),
21236  NUF(vqneg,     1b00780, 2, (RNDQ, RNDQ),     neon_sat_abs_neg),
21237  NUF(vqnegq,    1b00780, 2, (RNQ,  RNQ),      neon_sat_abs_neg),
21238   /* Pairwise, lengthening. Types S8 S16 S32 U8 U16 U32.  */
21239  NUF(vpadal,    1b00600, 2, (RNDQ, RNDQ),     neon_pair_long),
21240  NUF(vpadalq,   1b00600, 2, (RNQ,  RNQ),      neon_pair_long),
21241  NUF(vpaddl,    1b00200, 2, (RNDQ, RNDQ),     neon_pair_long),
21242  NUF(vpaddlq,   1b00200, 2, (RNQ,  RNQ),      neon_pair_long),
21243   /* Reciprocal estimates.  Types U32 F16 F32.  */
21244  NUF(vrecpe,    1b30400, 2, (RNDQ, RNDQ),     neon_recip_est),
21245  NUF(vrecpeq,   1b30400, 2, (RNQ,  RNQ),      neon_recip_est),
21246  NUF(vrsqrte,   1b30480, 2, (RNDQ, RNDQ),     neon_recip_est),
21247  NUF(vrsqrteq,  1b30480, 2, (RNQ,  RNQ),      neon_recip_est),
21248   /* VCLS. Types S8 S16 S32.  */
21249  NUF(vcls,      1b00400, 2, (RNDQ, RNDQ),     neon_cls),
21250  NUF(vclsq,     1b00400, 2, (RNQ,  RNQ),      neon_cls),
21251   /* VCLZ. Types I8 I16 I32.  */
21252  NUF(vclz,      1b00480, 2, (RNDQ, RNDQ),     neon_clz),
21253  NUF(vclzq,     1b00480, 2, (RNQ,  RNQ),      neon_clz),
21254   /* VCNT. Size 8.  */
21255  NUF(vcnt,      1b00500, 2, (RNDQ, RNDQ),     neon_cnt),
21256  NUF(vcntq,     1b00500, 2, (RNQ,  RNQ),      neon_cnt),
21257   /* Two address, untyped.  */
21258  NUF(vswp,      1b20000, 2, (RNDQ, RNDQ),     neon_swp),
21259  NUF(vswpq,     1b20000, 2, (RNQ,  RNQ),      neon_swp),
21260   /* VTRN. Sizes 8 16 32.  */
21261  nUF(vtrn,      _vtrn,    2, (RNDQ, RNDQ),     neon_trn),
21262  nUF(vtrnq,     _vtrn,    2, (RNQ,  RNQ),      neon_trn),
21263
21264   /* Table lookup. Size 8.  */
21265  NUF(vtbl,      1b00800, 3, (RND, NRDLST, RND), neon_tbl_tbx),
21266  NUF(vtbx,      1b00840, 3, (RND, NRDLST, RND), neon_tbl_tbx),
21267
21268 #undef  THUMB_VARIANT
21269 #define THUMB_VARIANT  & fpu_vfp_v3_or_neon_ext
21270 #undef  ARM_VARIANT
21271 #define ARM_VARIANT    & fpu_vfp_v3_or_neon_ext
21272
21273   /* Neon element/structure load/store.  */
21274  nUF(vld1,      _vld1,    2, (NSTRLST, ADDR),  neon_ldx_stx),
21275  nUF(vst1,      _vst1,    2, (NSTRLST, ADDR),  neon_ldx_stx),
21276  nUF(vld2,      _vld2,    2, (NSTRLST, ADDR),  neon_ldx_stx),
21277  nUF(vst2,      _vst2,    2, (NSTRLST, ADDR),  neon_ldx_stx),
21278  nUF(vld3,      _vld3,    2, (NSTRLST, ADDR),  neon_ldx_stx),
21279  nUF(vst3,      _vst3,    2, (NSTRLST, ADDR),  neon_ldx_stx),
21280  nUF(vld4,      _vld4,    2, (NSTRLST, ADDR),  neon_ldx_stx),
21281  nUF(vst4,      _vst4,    2, (NSTRLST, ADDR),  neon_ldx_stx),
21282
21283 #undef  THUMB_VARIANT
21284 #define THUMB_VARIANT & fpu_vfp_ext_v3xd
21285 #undef  ARM_VARIANT
21286 #define ARM_VARIANT   & fpu_vfp_ext_v3xd
21287  cCE("fconsts",   eb00a00, 2, (RVS, I255),      vfp_sp_const),
21288  cCE("fshtos",    eba0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
21289  cCE("fsltos",    eba0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
21290  cCE("fuhtos",    ebb0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
21291  cCE("fultos",    ebb0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
21292  cCE("ftoshs",    ebe0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
21293  cCE("ftosls",    ebe0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
21294  cCE("ftouhs",    ebf0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
21295  cCE("ftouls",    ebf0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
21296
21297 #undef  THUMB_VARIANT
21298 #define THUMB_VARIANT  & fpu_vfp_ext_v3
21299 #undef  ARM_VARIANT
21300 #define ARM_VARIANT    & fpu_vfp_ext_v3
21301
21302  cCE("fconstd",   eb00b00, 2, (RVD, I255),      vfp_dp_const),
21303  cCE("fshtod",    eba0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
21304  cCE("fsltod",    eba0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
21305  cCE("fuhtod",    ebb0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
21306  cCE("fultod",    ebb0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
21307  cCE("ftoshd",    ebe0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
21308  cCE("ftosld",    ebe0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
21309  cCE("ftouhd",    ebf0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
21310  cCE("ftould",    ebf0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
21311
21312 #undef  ARM_VARIANT
21313 #define ARM_VARIANT    & fpu_vfp_ext_fma
21314 #undef  THUMB_VARIANT
21315 #define THUMB_VARIANT  & fpu_vfp_ext_fma
21316  /* Mnemonics shared by Neon and VFP.  These are included in the
21317     VFP FMA variant; NEON and VFP FMA always includes the NEON
21318     FMA instructions.  */
21319  nCEF(vfma,     _vfma,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_fmac),
21320  nCEF(vfms,     _vfms,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_fmac),
21321  /* ffmas/ffmad/ffmss/ffmsd are dummy mnemonics to satisfy gas;
21322     the v form should always be used.  */
21323  cCE("ffmas",   ea00a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
21324  cCE("ffnmas",  ea00a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
21325  cCE("ffmad",   ea00b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
21326  cCE("ffnmad",  ea00b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
21327  nCE(vfnma,     _vfnma,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
21328  nCE(vfnms,     _vfnms,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
21329
21330 #undef THUMB_VARIANT
21331 #undef  ARM_VARIANT
21332 #define ARM_VARIANT  & arm_cext_xscale /* Intel XScale extensions.  */
21333
21334  cCE("mia",     e200010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
21335  cCE("miaph",   e280010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
21336  cCE("miabb",   e2c0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
21337  cCE("miabt",   e2d0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
21338  cCE("miatb",   e2e0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
21339  cCE("miatt",   e2f0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
21340  cCE("mar",     c400000, 3, (RXA, RRnpc, RRnpc), xsc_mar),
21341  cCE("mra",     c500000, 3, (RRnpc, RRnpc, RXA), xsc_mra),
21342
21343 #undef  ARM_VARIANT
21344 #define ARM_VARIANT  & arm_cext_iwmmxt /* Intel Wireless MMX technology.  */
21345
21346  cCE("tandcb",  e13f130, 1, (RR),                   iwmmxt_tandorc),
21347  cCE("tandch",  e53f130, 1, (RR),                   iwmmxt_tandorc),
21348  cCE("tandcw",  e93f130, 1, (RR),                   iwmmxt_tandorc),
21349  cCE("tbcstb",  e400010, 2, (RIWR, RR),             rn_rd),
21350  cCE("tbcsth",  e400050, 2, (RIWR, RR),             rn_rd),
21351  cCE("tbcstw",  e400090, 2, (RIWR, RR),             rn_rd),
21352  cCE("textrcb", e130170, 2, (RR, I7),               iwmmxt_textrc),
21353  cCE("textrch", e530170, 2, (RR, I7),               iwmmxt_textrc),
21354  cCE("textrcw", e930170, 2, (RR, I7),               iwmmxt_textrc),
21355  cCE("textrmub",e100070, 3, (RR, RIWR, I7),         iwmmxt_textrm),
21356  cCE("textrmuh",e500070, 3, (RR, RIWR, I7),         iwmmxt_textrm),
21357  cCE("textrmuw",e900070, 3, (RR, RIWR, I7),         iwmmxt_textrm),
21358  cCE("textrmsb",e100078, 3, (RR, RIWR, I7),         iwmmxt_textrm),
21359  cCE("textrmsh",e500078, 3, (RR, RIWR, I7),         iwmmxt_textrm),
21360  cCE("textrmsw",e900078, 3, (RR, RIWR, I7),         iwmmxt_textrm),
21361  cCE("tinsrb",  e600010, 3, (RIWR, RR, I7),         iwmmxt_tinsr),
21362  cCE("tinsrh",  e600050, 3, (RIWR, RR, I7),         iwmmxt_tinsr),
21363  cCE("tinsrw",  e600090, 3, (RIWR, RR, I7),         iwmmxt_tinsr),
21364  cCE("tmcr",    e000110, 2, (RIWC_RIWG, RR),        rn_rd),
21365  cCE("tmcrr",   c400000, 3, (RIWR, RR, RR),         rm_rd_rn),
21366  cCE("tmia",    e200010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
21367  cCE("tmiaph",  e280010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
21368  cCE("tmiabb",  e2c0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
21369  cCE("tmiabt",  e2d0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
21370  cCE("tmiatb",  e2e0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
21371  cCE("tmiatt",  e2f0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
21372  cCE("tmovmskb",e100030, 2, (RR, RIWR),             rd_rn),
21373  cCE("tmovmskh",e500030, 2, (RR, RIWR),             rd_rn),
21374  cCE("tmovmskw",e900030, 2, (RR, RIWR),             rd_rn),
21375  cCE("tmrc",    e100110, 2, (RR, RIWC_RIWG),        rd_rn),
21376  cCE("tmrrc",   c500000, 3, (RR, RR, RIWR),         rd_rn_rm),
21377  cCE("torcb",   e13f150, 1, (RR),                   iwmmxt_tandorc),
21378  cCE("torch",   e53f150, 1, (RR),                   iwmmxt_tandorc),
21379  cCE("torcw",   e93f150, 1, (RR),                   iwmmxt_tandorc),
21380  cCE("waccb",   e0001c0, 2, (RIWR, RIWR),           rd_rn),
21381  cCE("wacch",   e4001c0, 2, (RIWR, RIWR),           rd_rn),
21382  cCE("waccw",   e8001c0, 2, (RIWR, RIWR),           rd_rn),
21383  cCE("waddbss", e300180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21384  cCE("waddb",   e000180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21385  cCE("waddbus", e100180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21386  cCE("waddhss", e700180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21387  cCE("waddh",   e400180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21388  cCE("waddhus", e500180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21389  cCE("waddwss", eb00180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21390  cCE("waddw",   e800180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21391  cCE("waddwus", e900180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21392  cCE("waligni", e000020, 4, (RIWR, RIWR, RIWR, I7), iwmmxt_waligni),
21393  cCE("walignr0",e800020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21394  cCE("walignr1",e900020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21395  cCE("walignr2",ea00020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21396  cCE("walignr3",eb00020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21397  cCE("wand",    e200000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21398  cCE("wandn",   e300000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21399  cCE("wavg2b",  e800000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21400  cCE("wavg2br", e900000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21401  cCE("wavg2h",  ec00000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21402  cCE("wavg2hr", ed00000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21403  cCE("wcmpeqb", e000060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21404  cCE("wcmpeqh", e400060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21405  cCE("wcmpeqw", e800060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21406  cCE("wcmpgtub",e100060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21407  cCE("wcmpgtuh",e500060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21408  cCE("wcmpgtuw",e900060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21409  cCE("wcmpgtsb",e300060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21410  cCE("wcmpgtsh",e700060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21411  cCE("wcmpgtsw",eb00060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21412  cCE("wldrb",   c100000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
21413  cCE("wldrh",   c500000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
21414  cCE("wldrw",   c100100, 2, (RIWR_RIWC, ADDR),      iwmmxt_wldstw),
21415  cCE("wldrd",   c500100, 2, (RIWR, ADDR),           iwmmxt_wldstd),
21416  cCE("wmacs",   e600100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21417  cCE("wmacsz",  e700100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21418  cCE("wmacu",   e400100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21419  cCE("wmacuz",  e500100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21420  cCE("wmadds",  ea00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21421  cCE("wmaddu",  e800100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21422  cCE("wmaxsb",  e200160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21423  cCE("wmaxsh",  e600160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21424  cCE("wmaxsw",  ea00160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21425  cCE("wmaxub",  e000160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21426  cCE("wmaxuh",  e400160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21427  cCE("wmaxuw",  e800160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21428  cCE("wminsb",  e300160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21429  cCE("wminsh",  e700160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21430  cCE("wminsw",  eb00160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21431  cCE("wminub",  e100160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21432  cCE("wminuh",  e500160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21433  cCE("wminuw",  e900160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21434  cCE("wmov",    e000000, 2, (RIWR, RIWR),           iwmmxt_wmov),
21435  cCE("wmulsm",  e300100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21436  cCE("wmulsl",  e200100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21437  cCE("wmulum",  e100100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21438  cCE("wmulul",  e000100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21439  cCE("wor",     e000000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21440  cCE("wpackhss",e700080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21441  cCE("wpackhus",e500080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21442  cCE("wpackwss",eb00080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21443  cCE("wpackwus",e900080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21444  cCE("wpackdss",ef00080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21445  cCE("wpackdus",ed00080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21446  cCE("wrorh",   e700040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21447  cCE("wrorhg",  e700148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21448  cCE("wrorw",   eb00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21449  cCE("wrorwg",  eb00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21450  cCE("wrord",   ef00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21451  cCE("wrordg",  ef00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21452  cCE("wsadb",   e000120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21453  cCE("wsadbz",  e100120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21454  cCE("wsadh",   e400120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21455  cCE("wsadhz",  e500120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21456  cCE("wshufh",  e0001e0, 3, (RIWR, RIWR, I255),     iwmmxt_wshufh),
21457  cCE("wsllh",   e500040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21458  cCE("wsllhg",  e500148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21459  cCE("wsllw",   e900040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21460  cCE("wsllwg",  e900148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21461  cCE("wslld",   ed00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21462  cCE("wslldg",  ed00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21463  cCE("wsrah",   e400040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21464  cCE("wsrahg",  e400148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21465  cCE("wsraw",   e800040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21466  cCE("wsrawg",  e800148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21467  cCE("wsrad",   ec00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21468  cCE("wsradg",  ec00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21469  cCE("wsrlh",   e600040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21470  cCE("wsrlhg",  e600148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21471  cCE("wsrlw",   ea00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21472  cCE("wsrlwg",  ea00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21473  cCE("wsrld",   ee00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
21474  cCE("wsrldg",  ee00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
21475  cCE("wstrb",   c000000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
21476  cCE("wstrh",   c400000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
21477  cCE("wstrw",   c000100, 2, (RIWR_RIWC, ADDR),      iwmmxt_wldstw),
21478  cCE("wstrd",   c400100, 2, (RIWR, ADDR),           iwmmxt_wldstd),
21479  cCE("wsubbss", e3001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21480  cCE("wsubb",   e0001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21481  cCE("wsubbus", e1001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21482  cCE("wsubhss", e7001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21483  cCE("wsubh",   e4001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21484  cCE("wsubhus", e5001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21485  cCE("wsubwss", eb001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21486  cCE("wsubw",   e8001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21487  cCE("wsubwus", e9001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21488  cCE("wunpckehub",e0000c0, 2, (RIWR, RIWR),         rd_rn),
21489  cCE("wunpckehuh",e4000c0, 2, (RIWR, RIWR),         rd_rn),
21490  cCE("wunpckehuw",e8000c0, 2, (RIWR, RIWR),         rd_rn),
21491  cCE("wunpckehsb",e2000c0, 2, (RIWR, RIWR),         rd_rn),
21492  cCE("wunpckehsh",e6000c0, 2, (RIWR, RIWR),         rd_rn),
21493  cCE("wunpckehsw",ea000c0, 2, (RIWR, RIWR),         rd_rn),
21494  cCE("wunpckihb", e1000c0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
21495  cCE("wunpckihh", e5000c0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
21496  cCE("wunpckihw", e9000c0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
21497  cCE("wunpckelub",e0000e0, 2, (RIWR, RIWR),         rd_rn),
21498  cCE("wunpckeluh",e4000e0, 2, (RIWR, RIWR),         rd_rn),
21499  cCE("wunpckeluw",e8000e0, 2, (RIWR, RIWR),         rd_rn),
21500  cCE("wunpckelsb",e2000e0, 2, (RIWR, RIWR),         rd_rn),
21501  cCE("wunpckelsh",e6000e0, 2, (RIWR, RIWR),         rd_rn),
21502  cCE("wunpckelsw",ea000e0, 2, (RIWR, RIWR),         rd_rn),
21503  cCE("wunpckilb", e1000e0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
21504  cCE("wunpckilh", e5000e0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
21505  cCE("wunpckilw", e9000e0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
21506  cCE("wxor",    e100000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21507  cCE("wzero",   e300000, 1, (RIWR),                 iwmmxt_wzero),
21508
21509 #undef  ARM_VARIANT
21510 #define ARM_VARIANT  & arm_cext_iwmmxt2 /* Intel Wireless MMX technology, version 2.  */
21511
21512  cCE("torvscb",   e12f190, 1, (RR),                 iwmmxt_tandorc),
21513  cCE("torvsch",   e52f190, 1, (RR),                 iwmmxt_tandorc),
21514  cCE("torvscw",   e92f190, 1, (RR),                 iwmmxt_tandorc),
21515  cCE("wabsb",     e2001c0, 2, (RIWR, RIWR),           rd_rn),
21516  cCE("wabsh",     e6001c0, 2, (RIWR, RIWR),           rd_rn),
21517  cCE("wabsw",     ea001c0, 2, (RIWR, RIWR),           rd_rn),
21518  cCE("wabsdiffb", e1001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21519  cCE("wabsdiffh", e5001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21520  cCE("wabsdiffw", e9001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21521  cCE("waddbhusl", e2001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21522  cCE("waddbhusm", e6001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21523  cCE("waddhc",    e600180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21524  cCE("waddwc",    ea00180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21525  cCE("waddsubhx", ea001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21526  cCE("wavg4",   e400000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21527  cCE("wavg4r",    e500000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21528  cCE("wmaddsn",   ee00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21529  cCE("wmaddsx",   eb00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21530  cCE("wmaddun",   ec00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21531  cCE("wmaddux",   e900100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21532  cCE("wmerge",    e000080, 4, (RIWR, RIWR, RIWR, I7), iwmmxt_wmerge),
21533  cCE("wmiabb",    e0000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21534  cCE("wmiabt",    e1000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21535  cCE("wmiatb",    e2000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21536  cCE("wmiatt",    e3000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21537  cCE("wmiabbn",   e4000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21538  cCE("wmiabtn",   e5000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21539  cCE("wmiatbn",   e6000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21540  cCE("wmiattn",   e7000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21541  cCE("wmiawbb",   e800120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21542  cCE("wmiawbt",   e900120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21543  cCE("wmiawtb",   ea00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21544  cCE("wmiawtt",   eb00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21545  cCE("wmiawbbn",  ec00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21546  cCE("wmiawbtn",  ed00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21547  cCE("wmiawtbn",  ee00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21548  cCE("wmiawttn",  ef00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21549  cCE("wmulsmr",   ef00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21550  cCE("wmulumr",   ed00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21551  cCE("wmulwumr",  ec000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21552  cCE("wmulwsmr",  ee000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21553  cCE("wmulwum",   ed000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21554  cCE("wmulwsm",   ef000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21555  cCE("wmulwl",    eb000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21556  cCE("wqmiabb",   e8000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21557  cCE("wqmiabt",   e9000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21558  cCE("wqmiatb",   ea000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21559  cCE("wqmiatt",   eb000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21560  cCE("wqmiabbn",  ec000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21561  cCE("wqmiabtn",  ed000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21562  cCE("wqmiatbn",  ee000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21563  cCE("wqmiattn",  ef000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21564  cCE("wqmulm",    e100080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21565  cCE("wqmulmr",   e300080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21566  cCE("wqmulwm",   ec000e0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21567  cCE("wqmulwmr",  ee000e0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21568  cCE("wsubaddhx", ed001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
21569
21570 #undef  ARM_VARIANT
21571 #define ARM_VARIANT  & arm_cext_maverick /* Cirrus Maverick instructions.  */
21572
21573  cCE("cfldrs",  c100400, 2, (RMF, ADDRGLDC),          rd_cpaddr),
21574  cCE("cfldrd",  c500400, 2, (RMD, ADDRGLDC),          rd_cpaddr),
21575  cCE("cfldr32", c100500, 2, (RMFX, ADDRGLDC),         rd_cpaddr),
21576  cCE("cfldr64", c500500, 2, (RMDX, ADDRGLDC),         rd_cpaddr),
21577  cCE("cfstrs",  c000400, 2, (RMF, ADDRGLDC),          rd_cpaddr),
21578  cCE("cfstrd",  c400400, 2, (RMD, ADDRGLDC),          rd_cpaddr),
21579  cCE("cfstr32", c000500, 2, (RMFX, ADDRGLDC),         rd_cpaddr),
21580  cCE("cfstr64", c400500, 2, (RMDX, ADDRGLDC),         rd_cpaddr),
21581  cCE("cfmvsr",  e000450, 2, (RMF, RR),                rn_rd),
21582  cCE("cfmvrs",  e100450, 2, (RR, RMF),                rd_rn),
21583  cCE("cfmvdlr", e000410, 2, (RMD, RR),                rn_rd),
21584  cCE("cfmvrdl", e100410, 2, (RR, RMD),                rd_rn),
21585  cCE("cfmvdhr", e000430, 2, (RMD, RR),                rn_rd),
21586  cCE("cfmvrdh", e100430, 2, (RR, RMD),                rd_rn),
21587  cCE("cfmv64lr",e000510, 2, (RMDX, RR),               rn_rd),
21588  cCE("cfmvr64l",e100510, 2, (RR, RMDX),               rd_rn),
21589  cCE("cfmv64hr",e000530, 2, (RMDX, RR),               rn_rd),
21590  cCE("cfmvr64h",e100530, 2, (RR, RMDX),               rd_rn),
21591  cCE("cfmval32",e200440, 2, (RMAX, RMFX),             rd_rn),
21592  cCE("cfmv32al",e100440, 2, (RMFX, RMAX),             rd_rn),
21593  cCE("cfmvam32",e200460, 2, (RMAX, RMFX),             rd_rn),
21594  cCE("cfmv32am",e100460, 2, (RMFX, RMAX),             rd_rn),
21595  cCE("cfmvah32",e200480, 2, (RMAX, RMFX),             rd_rn),
21596  cCE("cfmv32ah",e100480, 2, (RMFX, RMAX),             rd_rn),
21597  cCE("cfmva32", e2004a0, 2, (RMAX, RMFX),             rd_rn),
21598  cCE("cfmv32a", e1004a0, 2, (RMFX, RMAX),             rd_rn),
21599  cCE("cfmva64", e2004c0, 2, (RMAX, RMDX),             rd_rn),
21600  cCE("cfmv64a", e1004c0, 2, (RMDX, RMAX),             rd_rn),
21601  cCE("cfmvsc32",e2004e0, 2, (RMDS, RMDX),             mav_dspsc),
21602  cCE("cfmv32sc",e1004e0, 2, (RMDX, RMDS),             rd),
21603  cCE("cfcpys",  e000400, 2, (RMF, RMF),               rd_rn),
21604  cCE("cfcpyd",  e000420, 2, (RMD, RMD),               rd_rn),
21605  cCE("cfcvtsd", e000460, 2, (RMD, RMF),               rd_rn),
21606  cCE("cfcvtds", e000440, 2, (RMF, RMD),               rd_rn),
21607  cCE("cfcvt32s",e000480, 2, (RMF, RMFX),              rd_rn),
21608  cCE("cfcvt32d",e0004a0, 2, (RMD, RMFX),              rd_rn),
21609  cCE("cfcvt64s",e0004c0, 2, (RMF, RMDX),              rd_rn),
21610  cCE("cfcvt64d",e0004e0, 2, (RMD, RMDX),              rd_rn),
21611  cCE("cfcvts32",e100580, 2, (RMFX, RMF),              rd_rn),
21612  cCE("cfcvtd32",e1005a0, 2, (RMFX, RMD),              rd_rn),
21613  cCE("cftruncs32",e1005c0, 2, (RMFX, RMF),            rd_rn),
21614  cCE("cftruncd32",e1005e0, 2, (RMFX, RMD),            rd_rn),
21615  cCE("cfrshl32",e000550, 3, (RMFX, RMFX, RR),         mav_triple),
21616  cCE("cfrshl64",e000570, 3, (RMDX, RMDX, RR),         mav_triple),
21617  cCE("cfsh32",  e000500, 3, (RMFX, RMFX, I63s),       mav_shift),
21618  cCE("cfsh64",  e200500, 3, (RMDX, RMDX, I63s),       mav_shift),
21619  cCE("cfcmps",  e100490, 3, (RR, RMF, RMF),           rd_rn_rm),
21620  cCE("cfcmpd",  e1004b0, 3, (RR, RMD, RMD),           rd_rn_rm),
21621  cCE("cfcmp32", e100590, 3, (RR, RMFX, RMFX),         rd_rn_rm),
21622  cCE("cfcmp64", e1005b0, 3, (RR, RMDX, RMDX),         rd_rn_rm),
21623  cCE("cfabss",  e300400, 2, (RMF, RMF),               rd_rn),
21624  cCE("cfabsd",  e300420, 2, (RMD, RMD),               rd_rn),
21625  cCE("cfnegs",  e300440, 2, (RMF, RMF),               rd_rn),
21626  cCE("cfnegd",  e300460, 2, (RMD, RMD),               rd_rn),
21627  cCE("cfadds",  e300480, 3, (RMF, RMF, RMF),          rd_rn_rm),
21628  cCE("cfaddd",  e3004a0, 3, (RMD, RMD, RMD),          rd_rn_rm),
21629  cCE("cfsubs",  e3004c0, 3, (RMF, RMF, RMF),          rd_rn_rm),
21630  cCE("cfsubd",  e3004e0, 3, (RMD, RMD, RMD),          rd_rn_rm),
21631  cCE("cfmuls",  e100400, 3, (RMF, RMF, RMF),          rd_rn_rm),
21632  cCE("cfmuld",  e100420, 3, (RMD, RMD, RMD),          rd_rn_rm),
21633  cCE("cfabs32", e300500, 2, (RMFX, RMFX),             rd_rn),
21634  cCE("cfabs64", e300520, 2, (RMDX, RMDX),             rd_rn),
21635  cCE("cfneg32", e300540, 2, (RMFX, RMFX),             rd_rn),
21636  cCE("cfneg64", e300560, 2, (RMDX, RMDX),             rd_rn),
21637  cCE("cfadd32", e300580, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
21638  cCE("cfadd64", e3005a0, 3, (RMDX, RMDX, RMDX),       rd_rn_rm),
21639  cCE("cfsub32", e3005c0, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
21640  cCE("cfsub64", e3005e0, 3, (RMDX, RMDX, RMDX),       rd_rn_rm),
21641  cCE("cfmul32", e100500, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
21642  cCE("cfmul64", e100520, 3, (RMDX, RMDX, RMDX),       rd_rn_rm),
21643  cCE("cfmac32", e100540, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
21644  cCE("cfmsc32", e100560, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
21645  cCE("cfmadd32",e000600, 4, (RMAX, RMFX, RMFX, RMFX), mav_quad),
21646  cCE("cfmsub32",e100600, 4, (RMAX, RMFX, RMFX, RMFX), mav_quad),
21647  cCE("cfmadda32", e200600, 4, (RMAX, RMAX, RMFX, RMFX), mav_quad),
21648  cCE("cfmsuba32", e300600, 4, (RMAX, RMAX, RMFX, RMFX), mav_quad),
21649
21650  /* ARMv8.5-A instructions.  */
21651 #undef  ARM_VARIANT
21652 #define ARM_VARIANT   & arm_ext_sb
21653 #undef  THUMB_VARIANT
21654 #define THUMB_VARIANT & arm_ext_sb
21655  TUF("sb", 57ff070, f3bf8f70, 0, (), noargs, noargs),
21656
21657 #undef  ARM_VARIANT
21658 #define ARM_VARIANT   & arm_ext_predres
21659 #undef  THUMB_VARIANT
21660 #define THUMB_VARIANT & arm_ext_predres
21661  CE("cfprctx", e070f93, 1, (RRnpc), rd),
21662  CE("dvprctx", e070fb3, 1, (RRnpc), rd),
21663  CE("cpprctx", e070ff3, 1, (RRnpc), rd),
21664
21665  /* ARMv8-M instructions.  */
21666 #undef  ARM_VARIANT
21667 #define ARM_VARIANT NULL
21668 #undef  THUMB_VARIANT
21669 #define THUMB_VARIANT & arm_ext_v8m
21670  ToU("sg",    e97fe97f, 0, (),             noargs),
21671  ToC("blxns", 4784,     1, (RRnpc),        t_blx),
21672  ToC("bxns",  4704,     1, (RRnpc),        t_bx),
21673  ToC("tt",    e840f000, 2, (RRnpc, RRnpc), tt),
21674  ToC("ttt",   e840f040, 2, (RRnpc, RRnpc), tt),
21675  ToC("tta",   e840f080, 2, (RRnpc, RRnpc), tt),
21676  ToC("ttat",  e840f0c0, 2, (RRnpc, RRnpc), tt),
21677
21678  /* FP for ARMv8-M Mainline.  Enabled for ARMv8-M Mainline because the
21679     instructions behave as nop if no VFP is present.  */
21680 #undef  THUMB_VARIANT
21681 #define THUMB_VARIANT & arm_ext_v8m_main
21682  ToC("vlldm", ec300a00, 1, (RRnpc), rn),
21683  ToC("vlstm", ec200a00, 1, (RRnpc), rn),
21684
21685  /* Armv8.1-M Mainline instructions.  */
21686 #undef  THUMB_VARIANT
21687 #define THUMB_VARIANT & arm_ext_v8_1m_main
21688  toC("bf",     _bf,     2, (EXPs, EXPs),             t_branch_future),
21689  toC("bfx",    _bfx,    2, (EXPs, RRnpcsp),          t_branch_future),
21690  toC("bflx",   _bflx,   2, (EXPs, RRnpcsp),          t_branch_future),
21691 };
21692 #undef ARM_VARIANT
21693 #undef THUMB_VARIANT
21694 #undef TCE
21695 #undef TUE
21696 #undef TUF
21697 #undef TCC
21698 #undef cCE
21699 #undef cCL
21700 #undef C3E
21701 #undef C3
21702 #undef CE
21703 #undef CM
21704 #undef CL
21705 #undef UE
21706 #undef UF
21707 #undef UT
21708 #undef NUF
21709 #undef nUF
21710 #undef NCE
21711 #undef nCE
21712 #undef OPS0
21713 #undef OPS1
21714 #undef OPS2
21715 #undef OPS3
21716 #undef OPS4
21717 #undef OPS5
21718 #undef OPS6
21719 #undef do_0
21720 #undef ToC
21721 #undef toC
21722 #undef ToU
21723 \f
21724 /* MD interface: bits in the object file.  */
21725
21726 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
21727    for use in the a.out file, and stores them in the array pointed to by buf.
21728    This knows about the endian-ness of the target machine and does
21729    THE RIGHT THING, whatever it is.  Possible values for n are 1 (byte)
21730    2 (short) and 4 (long)  Floating numbers are put out as a series of
21731    LITTLENUMS (shorts, here at least).  */
21732
21733 void
21734 md_number_to_chars (char * buf, valueT val, int n)
21735 {
21736   if (target_big_endian)
21737     number_to_chars_bigendian (buf, val, n);
21738   else
21739     number_to_chars_littleendian (buf, val, n);
21740 }
21741
21742 static valueT
21743 md_chars_to_number (char * buf, int n)
21744 {
21745   valueT result = 0;
21746   unsigned char * where = (unsigned char *) buf;
21747
21748   if (target_big_endian)
21749     {
21750       while (n--)
21751         {
21752           result <<= 8;
21753           result |= (*where++ & 255);
21754         }
21755     }
21756   else
21757     {
21758       while (n--)
21759         {
21760           result <<= 8;
21761           result |= (where[n] & 255);
21762         }
21763     }
21764
21765   return result;
21766 }
21767
21768 /* MD interface: Sections.  */
21769
21770 /* Calculate the maximum variable size (i.e., excluding fr_fix)
21771    that an rs_machine_dependent frag may reach.  */
21772
21773 unsigned int
21774 arm_frag_max_var (fragS *fragp)
21775 {
21776   /* We only use rs_machine_dependent for variable-size Thumb instructions,
21777      which are either THUMB_SIZE (2) or INSN_SIZE (4).
21778
21779      Note that we generate relaxable instructions even for cases that don't
21780      really need it, like an immediate that's a trivial constant.  So we're
21781      overestimating the instruction size for some of those cases.  Rather
21782      than putting more intelligence here, it would probably be better to
21783      avoid generating a relaxation frag in the first place when it can be
21784      determined up front that a short instruction will suffice.  */
21785
21786   gas_assert (fragp->fr_type == rs_machine_dependent);
21787   return INSN_SIZE;
21788 }
21789
21790 /* Estimate the size of a frag before relaxing.  Assume everything fits in
21791    2 bytes.  */
21792
21793 int
21794 md_estimate_size_before_relax (fragS * fragp,
21795                                segT    segtype ATTRIBUTE_UNUSED)
21796 {
21797   fragp->fr_var = 2;
21798   return 2;
21799 }
21800
21801 /* Convert a machine dependent frag.  */
21802
21803 void
21804 md_convert_frag (bfd *abfd, segT asec ATTRIBUTE_UNUSED, fragS *fragp)
21805 {
21806   unsigned long insn;
21807   unsigned long old_op;
21808   char *buf;
21809   expressionS exp;
21810   fixS *fixp;
21811   int reloc_type;
21812   int pc_rel;
21813   int opcode;
21814
21815   buf = fragp->fr_literal + fragp->fr_fix;
21816
21817   old_op = bfd_get_16(abfd, buf);
21818   if (fragp->fr_symbol)
21819     {
21820       exp.X_op = O_symbol;
21821       exp.X_add_symbol = fragp->fr_symbol;
21822     }
21823   else
21824     {
21825       exp.X_op = O_constant;
21826     }
21827   exp.X_add_number = fragp->fr_offset;
21828   opcode = fragp->fr_subtype;
21829   switch (opcode)
21830     {
21831     case T_MNEM_ldr_pc:
21832     case T_MNEM_ldr_pc2:
21833     case T_MNEM_ldr_sp:
21834     case T_MNEM_str_sp:
21835     case T_MNEM_ldr:
21836     case T_MNEM_ldrb:
21837     case T_MNEM_ldrh:
21838     case T_MNEM_str:
21839     case T_MNEM_strb:
21840     case T_MNEM_strh:
21841       if (fragp->fr_var == 4)
21842         {
21843           insn = THUMB_OP32 (opcode);
21844           if ((old_op >> 12) == 4 || (old_op >> 12) == 9)
21845             {
21846               insn |= (old_op & 0x700) << 4;
21847             }
21848           else
21849             {
21850               insn |= (old_op & 7) << 12;
21851               insn |= (old_op & 0x38) << 13;
21852             }
21853           insn |= 0x00000c00;
21854           put_thumb32_insn (buf, insn);
21855           reloc_type = BFD_RELOC_ARM_T32_OFFSET_IMM;
21856         }
21857       else
21858         {
21859           reloc_type = BFD_RELOC_ARM_THUMB_OFFSET;
21860         }
21861       pc_rel = (opcode == T_MNEM_ldr_pc2);
21862       break;
21863     case T_MNEM_adr:
21864       if (fragp->fr_var == 4)
21865         {
21866           insn = THUMB_OP32 (opcode);
21867           insn |= (old_op & 0xf0) << 4;
21868           put_thumb32_insn (buf, insn);
21869           reloc_type = BFD_RELOC_ARM_T32_ADD_PC12;
21870         }
21871       else
21872         {
21873           reloc_type = BFD_RELOC_ARM_THUMB_ADD;
21874           exp.X_add_number -= 4;
21875         }
21876       pc_rel = 1;
21877       break;
21878     case T_MNEM_mov:
21879     case T_MNEM_movs:
21880     case T_MNEM_cmp:
21881     case T_MNEM_cmn:
21882       if (fragp->fr_var == 4)
21883         {
21884           int r0off = (opcode == T_MNEM_mov
21885                        || opcode == T_MNEM_movs) ? 0 : 8;
21886           insn = THUMB_OP32 (opcode);
21887           insn = (insn & 0xe1ffffff) | 0x10000000;
21888           insn |= (old_op & 0x700) << r0off;
21889           put_thumb32_insn (buf, insn);
21890           reloc_type = BFD_RELOC_ARM_T32_IMMEDIATE;
21891         }
21892       else
21893         {
21894           reloc_type = BFD_RELOC_ARM_THUMB_IMM;
21895         }
21896       pc_rel = 0;
21897       break;
21898     case T_MNEM_b:
21899       if (fragp->fr_var == 4)
21900         {
21901           insn = THUMB_OP32(opcode);
21902           put_thumb32_insn (buf, insn);
21903           reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH25;
21904         }
21905       else
21906         reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH12;
21907       pc_rel = 1;
21908       break;
21909     case T_MNEM_bcond:
21910       if (fragp->fr_var == 4)
21911         {
21912           insn = THUMB_OP32(opcode);
21913           insn |= (old_op & 0xf00) << 14;
21914           put_thumb32_insn (buf, insn);
21915           reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH20;
21916         }
21917       else
21918         reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH9;
21919       pc_rel = 1;
21920       break;
21921     case T_MNEM_add_sp:
21922     case T_MNEM_add_pc:
21923     case T_MNEM_inc_sp:
21924     case T_MNEM_dec_sp:
21925       if (fragp->fr_var == 4)
21926         {
21927           /* ??? Choose between add and addw.  */
21928           insn = THUMB_OP32 (opcode);
21929           insn |= (old_op & 0xf0) << 4;
21930           put_thumb32_insn (buf, insn);
21931           if (opcode == T_MNEM_add_pc)
21932             reloc_type = BFD_RELOC_ARM_T32_IMM12;
21933           else
21934             reloc_type = BFD_RELOC_ARM_T32_ADD_IMM;
21935         }
21936       else
21937         reloc_type = BFD_RELOC_ARM_THUMB_ADD;
21938       pc_rel = 0;
21939       break;
21940
21941     case T_MNEM_addi:
21942     case T_MNEM_addis:
21943     case T_MNEM_subi:
21944     case T_MNEM_subis:
21945       if (fragp->fr_var == 4)
21946         {
21947           insn = THUMB_OP32 (opcode);
21948           insn |= (old_op & 0xf0) << 4;
21949           insn |= (old_op & 0xf) << 16;
21950           put_thumb32_insn (buf, insn);
21951           if (insn & (1 << 20))
21952             reloc_type = BFD_RELOC_ARM_T32_ADD_IMM;
21953           else
21954             reloc_type = BFD_RELOC_ARM_T32_IMMEDIATE;
21955         }
21956       else
21957         reloc_type = BFD_RELOC_ARM_THUMB_ADD;
21958       pc_rel = 0;
21959       break;
21960     default:
21961       abort ();
21962     }
21963   fixp = fix_new_exp (fragp, fragp->fr_fix, fragp->fr_var, &exp, pc_rel,
21964                       (enum bfd_reloc_code_real) reloc_type);
21965   fixp->fx_file = fragp->fr_file;
21966   fixp->fx_line = fragp->fr_line;
21967   fragp->fr_fix += fragp->fr_var;
21968
21969   /* Set whether we use thumb-2 ISA based on final relaxation results.  */
21970   if (thumb_mode && fragp->fr_var == 4 && no_cpu_selected ()
21971       && !ARM_CPU_HAS_FEATURE (thumb_arch_used, arm_arch_t2))
21972     ARM_MERGE_FEATURE_SETS (arm_arch_used, thumb_arch_used, arm_ext_v6t2);
21973 }
21974
21975 /* Return the size of a relaxable immediate operand instruction.
21976    SHIFT and SIZE specify the form of the allowable immediate.  */
21977 static int
21978 relax_immediate (fragS *fragp, int size, int shift)
21979 {
21980   offsetT offset;
21981   offsetT mask;
21982   offsetT low;
21983
21984   /* ??? Should be able to do better than this.  */
21985   if (fragp->fr_symbol)
21986     return 4;
21987
21988   low = (1 << shift) - 1;
21989   mask = (1 << (shift + size)) - (1 << shift);
21990   offset = fragp->fr_offset;
21991   /* Force misaligned offsets to 32-bit variant.  */
21992   if (offset & low)
21993     return 4;
21994   if (offset & ~mask)
21995     return 4;
21996   return 2;
21997 }
21998
21999 /* Get the address of a symbol during relaxation.  */
22000 static addressT
22001 relaxed_symbol_addr (fragS *fragp, long stretch)
22002 {
22003   fragS *sym_frag;
22004   addressT addr;
22005   symbolS *sym;
22006
22007   sym = fragp->fr_symbol;
22008   sym_frag = symbol_get_frag (sym);
22009   know (S_GET_SEGMENT (sym) != absolute_section
22010         || sym_frag == &zero_address_frag);
22011   addr = S_GET_VALUE (sym) + fragp->fr_offset;
22012
22013   /* If frag has yet to be reached on this pass, assume it will
22014      move by STRETCH just as we did.  If this is not so, it will
22015      be because some frag between grows, and that will force
22016      another pass.  */
22017
22018   if (stretch != 0
22019       && sym_frag->relax_marker != fragp->relax_marker)
22020     {
22021       fragS *f;
22022
22023       /* Adjust stretch for any alignment frag.  Note that if have
22024          been expanding the earlier code, the symbol may be
22025          defined in what appears to be an earlier frag.  FIXME:
22026          This doesn't handle the fr_subtype field, which specifies
22027          a maximum number of bytes to skip when doing an
22028          alignment.  */
22029       for (f = fragp; f != NULL && f != sym_frag; f = f->fr_next)
22030         {
22031           if (f->fr_type == rs_align || f->fr_type == rs_align_code)
22032             {
22033               if (stretch < 0)
22034                 stretch = - ((- stretch)
22035                              & ~ ((1 << (int) f->fr_offset) - 1));
22036               else
22037                 stretch &= ~ ((1 << (int) f->fr_offset) - 1);
22038               if (stretch == 0)
22039                 break;
22040             }
22041         }
22042       if (f != NULL)
22043         addr += stretch;
22044     }
22045
22046   return addr;
22047 }
22048
22049 /* Return the size of a relaxable adr pseudo-instruction or PC-relative
22050    load.  */
22051 static int
22052 relax_adr (fragS *fragp, asection *sec, long stretch)
22053 {
22054   addressT addr;
22055   offsetT val;
22056
22057   /* Assume worst case for symbols not known to be in the same section.  */
22058   if (fragp->fr_symbol == NULL
22059       || !S_IS_DEFINED (fragp->fr_symbol)
22060       || sec != S_GET_SEGMENT (fragp->fr_symbol)
22061       || S_IS_WEAK (fragp->fr_symbol))
22062     return 4;
22063
22064   val = relaxed_symbol_addr (fragp, stretch);
22065   addr = fragp->fr_address + fragp->fr_fix;
22066   addr = (addr + 4) & ~3;
22067   /* Force misaligned targets to 32-bit variant.  */
22068   if (val & 3)
22069     return 4;
22070   val -= addr;
22071   if (val < 0 || val > 1020)
22072     return 4;
22073   return 2;
22074 }
22075
22076 /* Return the size of a relaxable add/sub immediate instruction.  */
22077 static int
22078 relax_addsub (fragS *fragp, asection *sec)
22079 {
22080   char *buf;
22081   int op;
22082
22083   buf = fragp->fr_literal + fragp->fr_fix;
22084   op = bfd_get_16(sec->owner, buf);
22085   if ((op & 0xf) == ((op >> 4) & 0xf))
22086     return relax_immediate (fragp, 8, 0);
22087   else
22088     return relax_immediate (fragp, 3, 0);
22089 }
22090
22091 /* Return TRUE iff the definition of symbol S could be pre-empted
22092    (overridden) at link or load time.  */
22093 static bfd_boolean
22094 symbol_preemptible (symbolS *s)
22095 {
22096   /* Weak symbols can always be pre-empted.  */
22097   if (S_IS_WEAK (s))
22098     return TRUE;
22099
22100   /* Non-global symbols cannot be pre-empted. */
22101   if (! S_IS_EXTERNAL (s))
22102     return FALSE;
22103
22104 #ifdef OBJ_ELF
22105   /* In ELF, a global symbol can be marked protected, or private.  In that
22106      case it can't be pre-empted (other definitions in the same link unit
22107      would violate the ODR).  */
22108   if (ELF_ST_VISIBILITY (S_GET_OTHER (s)) > STV_DEFAULT)
22109     return FALSE;
22110 #endif
22111
22112   /* Other global symbols might be pre-empted.  */
22113   return TRUE;
22114 }
22115
22116 /* Return the size of a relaxable branch instruction.  BITS is the
22117    size of the offset field in the narrow instruction.  */
22118
22119 static int
22120 relax_branch (fragS *fragp, asection *sec, int bits, long stretch)
22121 {
22122   addressT addr;
22123   offsetT val;
22124   offsetT limit;
22125
22126   /* Assume worst case for symbols not known to be in the same section.  */
22127   if (!S_IS_DEFINED (fragp->fr_symbol)
22128       || sec != S_GET_SEGMENT (fragp->fr_symbol)
22129       || S_IS_WEAK (fragp->fr_symbol))
22130     return 4;
22131
22132 #ifdef OBJ_ELF
22133   /* A branch to a function in ARM state will require interworking.  */
22134   if (S_IS_DEFINED (fragp->fr_symbol)
22135       && ARM_IS_FUNC (fragp->fr_symbol))
22136       return 4;
22137 #endif
22138
22139   if (symbol_preemptible (fragp->fr_symbol))
22140     return 4;
22141
22142   val = relaxed_symbol_addr (fragp, stretch);
22143   addr = fragp->fr_address + fragp->fr_fix + 4;
22144   val -= addr;
22145
22146   /* Offset is a signed value *2 */
22147   limit = 1 << bits;
22148   if (val >= limit || val < -limit)
22149     return 4;
22150   return 2;
22151 }
22152
22153
22154 /* Relax a machine dependent frag.  This returns the amount by which
22155    the current size of the frag should change.  */
22156
22157 int
22158 arm_relax_frag (asection *sec, fragS *fragp, long stretch)
22159 {
22160   int oldsize;
22161   int newsize;
22162
22163   oldsize = fragp->fr_var;
22164   switch (fragp->fr_subtype)
22165     {
22166     case T_MNEM_ldr_pc2:
22167       newsize = relax_adr (fragp, sec, stretch);
22168       break;
22169     case T_MNEM_ldr_pc:
22170     case T_MNEM_ldr_sp:
22171     case T_MNEM_str_sp:
22172       newsize = relax_immediate (fragp, 8, 2);
22173       break;
22174     case T_MNEM_ldr:
22175     case T_MNEM_str:
22176       newsize = relax_immediate (fragp, 5, 2);
22177       break;
22178     case T_MNEM_ldrh:
22179     case T_MNEM_strh:
22180       newsize = relax_immediate (fragp, 5, 1);
22181       break;
22182     case T_MNEM_ldrb:
22183     case T_MNEM_strb:
22184       newsize = relax_immediate (fragp, 5, 0);
22185       break;
22186     case T_MNEM_adr:
22187       newsize = relax_adr (fragp, sec, stretch);
22188       break;
22189     case T_MNEM_mov:
22190     case T_MNEM_movs:
22191     case T_MNEM_cmp:
22192     case T_MNEM_cmn:
22193       newsize = relax_immediate (fragp, 8, 0);
22194       break;
22195     case T_MNEM_b:
22196       newsize = relax_branch (fragp, sec, 11, stretch);
22197       break;
22198     case T_MNEM_bcond:
22199       newsize = relax_branch (fragp, sec, 8, stretch);
22200       break;
22201     case T_MNEM_add_sp:
22202     case T_MNEM_add_pc:
22203       newsize = relax_immediate (fragp, 8, 2);
22204       break;
22205     case T_MNEM_inc_sp:
22206     case T_MNEM_dec_sp:
22207       newsize = relax_immediate (fragp, 7, 2);
22208       break;
22209     case T_MNEM_addi:
22210     case T_MNEM_addis:
22211     case T_MNEM_subi:
22212     case T_MNEM_subis:
22213       newsize = relax_addsub (fragp, sec);
22214       break;
22215     default:
22216       abort ();
22217     }
22218
22219   fragp->fr_var = newsize;
22220   /* Freeze wide instructions that are at or before the same location as
22221      in the previous pass.  This avoids infinite loops.
22222      Don't freeze them unconditionally because targets may be artificially
22223      misaligned by the expansion of preceding frags.  */
22224   if (stretch <= 0 && newsize > 2)
22225     {
22226       md_convert_frag (sec->owner, sec, fragp);
22227       frag_wane (fragp);
22228     }
22229
22230   return newsize - oldsize;
22231 }
22232
22233 /* Round up a section size to the appropriate boundary.  */
22234
22235 valueT
22236 md_section_align (segT   segment ATTRIBUTE_UNUSED,
22237                   valueT size)
22238 {
22239   return size;
22240 }
22241
22242 /* This is called from HANDLE_ALIGN in write.c.  Fill in the contents
22243    of an rs_align_code fragment.  */
22244
22245 void
22246 arm_handle_align (fragS * fragP)
22247 {
22248   static unsigned char const arm_noop[2][2][4] =
22249     {
22250       {  /* ARMv1 */
22251         {0x00, 0x00, 0xa0, 0xe1},  /* LE */
22252         {0xe1, 0xa0, 0x00, 0x00},  /* BE */
22253       },
22254       {  /* ARMv6k */
22255         {0x00, 0xf0, 0x20, 0xe3},  /* LE */
22256         {0xe3, 0x20, 0xf0, 0x00},  /* BE */
22257       },
22258     };
22259   static unsigned char const thumb_noop[2][2][2] =
22260     {
22261       {  /* Thumb-1 */
22262         {0xc0, 0x46},  /* LE */
22263         {0x46, 0xc0},  /* BE */
22264       },
22265       {  /* Thumb-2 */
22266         {0x00, 0xbf},  /* LE */
22267         {0xbf, 0x00}   /* BE */
22268       }
22269     };
22270   static unsigned char const wide_thumb_noop[2][4] =
22271     {  /* Wide Thumb-2 */
22272       {0xaf, 0xf3, 0x00, 0x80},  /* LE */
22273       {0xf3, 0xaf, 0x80, 0x00},  /* BE */
22274     };
22275
22276   unsigned bytes, fix, noop_size;
22277   char * p;
22278   const unsigned char * noop;
22279   const unsigned char *narrow_noop = NULL;
22280 #ifdef OBJ_ELF
22281   enum mstate state;
22282 #endif
22283
22284   if (fragP->fr_type != rs_align_code)
22285     return;
22286
22287   bytes = fragP->fr_next->fr_address - fragP->fr_address - fragP->fr_fix;
22288   p = fragP->fr_literal + fragP->fr_fix;
22289   fix = 0;
22290
22291   if (bytes > MAX_MEM_FOR_RS_ALIGN_CODE)
22292     bytes &= MAX_MEM_FOR_RS_ALIGN_CODE;
22293
22294   gas_assert ((fragP->tc_frag_data.thumb_mode & MODE_RECORDED) != 0);
22295
22296   if (fragP->tc_frag_data.thumb_mode & (~ MODE_RECORDED))
22297     {
22298       if (ARM_CPU_HAS_FEATURE (selected_cpu_name[0]
22299                                ? selected_cpu : arm_arch_none, arm_ext_v6t2))
22300         {
22301           narrow_noop = thumb_noop[1][target_big_endian];
22302           noop = wide_thumb_noop[target_big_endian];
22303         }
22304       else
22305         noop = thumb_noop[0][target_big_endian];
22306       noop_size = 2;
22307 #ifdef OBJ_ELF
22308       state = MAP_THUMB;
22309 #endif
22310     }
22311   else
22312     {
22313       noop = arm_noop[ARM_CPU_HAS_FEATURE (selected_cpu_name[0]
22314                                            ? selected_cpu : arm_arch_none,
22315                                            arm_ext_v6k) != 0]
22316                      [target_big_endian];
22317       noop_size = 4;
22318 #ifdef OBJ_ELF
22319       state = MAP_ARM;
22320 #endif
22321     }
22322
22323   fragP->fr_var = noop_size;
22324
22325   if (bytes & (noop_size - 1))
22326     {
22327       fix = bytes & (noop_size - 1);
22328 #ifdef OBJ_ELF
22329       insert_data_mapping_symbol (state, fragP->fr_fix, fragP, fix);
22330 #endif
22331       memset (p, 0, fix);
22332       p += fix;
22333       bytes -= fix;
22334     }
22335
22336   if (narrow_noop)
22337     {
22338       if (bytes & noop_size)
22339         {
22340           /* Insert a narrow noop.  */
22341           memcpy (p, narrow_noop, noop_size);
22342           p += noop_size;
22343           bytes -= noop_size;
22344           fix += noop_size;
22345         }
22346
22347       /* Use wide noops for the remainder */
22348       noop_size = 4;
22349     }
22350
22351   while (bytes >= noop_size)
22352     {
22353       memcpy (p, noop, noop_size);
22354       p += noop_size;
22355       bytes -= noop_size;
22356       fix += noop_size;
22357     }
22358
22359   fragP->fr_fix += fix;
22360 }
22361
22362 /* Called from md_do_align.  Used to create an alignment
22363    frag in a code section.  */
22364
22365 void
22366 arm_frag_align_code (int n, int max)
22367 {
22368   char * p;
22369
22370   /* We assume that there will never be a requirement
22371      to support alignments greater than MAX_MEM_FOR_RS_ALIGN_CODE bytes.  */
22372   if (max > MAX_MEM_FOR_RS_ALIGN_CODE)
22373     {
22374       char err_msg[128];
22375
22376       sprintf (err_msg,
22377         _("alignments greater than %d bytes not supported in .text sections."),
22378         MAX_MEM_FOR_RS_ALIGN_CODE + 1);
22379       as_fatal ("%s", err_msg);
22380     }
22381
22382   p = frag_var (rs_align_code,
22383                 MAX_MEM_FOR_RS_ALIGN_CODE,
22384                 1,
22385                 (relax_substateT) max,
22386                 (symbolS *) NULL,
22387                 (offsetT) n,
22388                 (char *) NULL);
22389   *p = 0;
22390 }
22391
22392 /* Perform target specific initialisation of a frag.
22393    Note - despite the name this initialisation is not done when the frag
22394    is created, but only when its type is assigned.  A frag can be created
22395    and used a long time before its type is set, so beware of assuming that
22396    this initialisation is performed first.  */
22397
22398 #ifndef OBJ_ELF
22399 void
22400 arm_init_frag (fragS * fragP, int max_chars ATTRIBUTE_UNUSED)
22401 {
22402   /* Record whether this frag is in an ARM or a THUMB area.  */
22403   fragP->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
22404 }
22405
22406 #else /* OBJ_ELF is defined.  */
22407 void
22408 arm_init_frag (fragS * fragP, int max_chars)
22409 {
22410   bfd_boolean frag_thumb_mode;
22411
22412   /* If the current ARM vs THUMB mode has not already
22413      been recorded into this frag then do so now.  */
22414   if ((fragP->tc_frag_data.thumb_mode & MODE_RECORDED) == 0)
22415     fragP->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
22416
22417   /* PR 21809: Do not set a mapping state for debug sections
22418      - it just confuses other tools.  */
22419   if (bfd_get_section_flags (NULL, now_seg) & SEC_DEBUGGING)
22420     return;
22421
22422   frag_thumb_mode = fragP->tc_frag_data.thumb_mode ^ MODE_RECORDED;
22423
22424   /* Record a mapping symbol for alignment frags.  We will delete this
22425      later if the alignment ends up empty.  */
22426   switch (fragP->fr_type)
22427     {
22428     case rs_align:
22429     case rs_align_test:
22430     case rs_fill:
22431       mapping_state_2 (MAP_DATA, max_chars);
22432       break;
22433     case rs_align_code:
22434       mapping_state_2 (frag_thumb_mode ? MAP_THUMB : MAP_ARM, max_chars);
22435       break;
22436     default:
22437       break;
22438     }
22439 }
22440
22441 /* When we change sections we need to issue a new mapping symbol.  */
22442
22443 void
22444 arm_elf_change_section (void)
22445 {
22446   /* Link an unlinked unwind index table section to the .text section.  */
22447   if (elf_section_type (now_seg) == SHT_ARM_EXIDX
22448       && elf_linked_to_section (now_seg) == NULL)
22449     elf_linked_to_section (now_seg) = text_section;
22450 }
22451
22452 int
22453 arm_elf_section_type (const char * str, size_t len)
22454 {
22455   if (len == 5 && strncmp (str, "exidx", 5) == 0)
22456     return SHT_ARM_EXIDX;
22457
22458   return -1;
22459 }
22460 \f
22461 /* Code to deal with unwinding tables.  */
22462
22463 static void add_unwind_adjustsp (offsetT);
22464
22465 /* Generate any deferred unwind frame offset.  */
22466
22467 static void
22468 flush_pending_unwind (void)
22469 {
22470   offsetT offset;
22471
22472   offset = unwind.pending_offset;
22473   unwind.pending_offset = 0;
22474   if (offset != 0)
22475     add_unwind_adjustsp (offset);
22476 }
22477
22478 /* Add an opcode to this list for this function.  Two-byte opcodes should
22479    be passed as op[0] << 8 | op[1].  The list of opcodes is built in reverse
22480    order.  */
22481
22482 static void
22483 add_unwind_opcode (valueT op, int length)
22484 {
22485   /* Add any deferred stack adjustment.  */
22486   if (unwind.pending_offset)
22487     flush_pending_unwind ();
22488
22489   unwind.sp_restored = 0;
22490
22491   if (unwind.opcode_count + length > unwind.opcode_alloc)
22492     {
22493       unwind.opcode_alloc += ARM_OPCODE_CHUNK_SIZE;
22494       if (unwind.opcodes)
22495         unwind.opcodes = XRESIZEVEC (unsigned char, unwind.opcodes,
22496                                      unwind.opcode_alloc);
22497       else
22498         unwind.opcodes = XNEWVEC (unsigned char, unwind.opcode_alloc);
22499     }
22500   while (length > 0)
22501     {
22502       length--;
22503       unwind.opcodes[unwind.opcode_count] = op & 0xff;
22504       op >>= 8;
22505       unwind.opcode_count++;
22506     }
22507 }
22508
22509 /* Add unwind opcodes to adjust the stack pointer.  */
22510
22511 static void
22512 add_unwind_adjustsp (offsetT offset)
22513 {
22514   valueT op;
22515
22516   if (offset > 0x200)
22517     {
22518       /* We need at most 5 bytes to hold a 32-bit value in a uleb128.  */
22519       char bytes[5];
22520       int n;
22521       valueT o;
22522
22523       /* Long form: 0xb2, uleb128.  */
22524       /* This might not fit in a word so add the individual bytes,
22525          remembering the list is built in reverse order.  */
22526       o = (valueT) ((offset - 0x204) >> 2);
22527       if (o == 0)
22528         add_unwind_opcode (0, 1);
22529
22530       /* Calculate the uleb128 encoding of the offset.  */
22531       n = 0;
22532       while (o)
22533         {
22534           bytes[n] = o & 0x7f;
22535           o >>= 7;
22536           if (o)
22537             bytes[n] |= 0x80;
22538           n++;
22539         }
22540       /* Add the insn.  */
22541       for (; n; n--)
22542         add_unwind_opcode (bytes[n - 1], 1);
22543       add_unwind_opcode (0xb2, 1);
22544     }
22545   else if (offset > 0x100)
22546     {
22547       /* Two short opcodes.  */
22548       add_unwind_opcode (0x3f, 1);
22549       op = (offset - 0x104) >> 2;
22550       add_unwind_opcode (op, 1);
22551     }
22552   else if (offset > 0)
22553     {
22554       /* Short opcode.  */
22555       op = (offset - 4) >> 2;
22556       add_unwind_opcode (op, 1);
22557     }
22558   else if (offset < 0)
22559     {
22560       offset = -offset;
22561       while (offset > 0x100)
22562         {
22563           add_unwind_opcode (0x7f, 1);
22564           offset -= 0x100;
22565         }
22566       op = ((offset - 4) >> 2) | 0x40;
22567       add_unwind_opcode (op, 1);
22568     }
22569 }
22570
22571 /* Finish the list of unwind opcodes for this function.  */
22572
22573 static void
22574 finish_unwind_opcodes (void)
22575 {
22576   valueT op;
22577
22578   if (unwind.fp_used)
22579     {
22580       /* Adjust sp as necessary.  */
22581       unwind.pending_offset += unwind.fp_offset - unwind.frame_size;
22582       flush_pending_unwind ();
22583
22584       /* After restoring sp from the frame pointer.  */
22585       op = 0x90 | unwind.fp_reg;
22586       add_unwind_opcode (op, 1);
22587     }
22588   else
22589     flush_pending_unwind ();
22590 }
22591
22592
22593 /* Start an exception table entry.  If idx is nonzero this is an index table
22594    entry.  */
22595
22596 static void
22597 start_unwind_section (const segT text_seg, int idx)
22598 {
22599   const char * text_name;
22600   const char * prefix;
22601   const char * prefix_once;
22602   const char * group_name;
22603   char * sec_name;
22604   int type;
22605   int flags;
22606   int linkonce;
22607
22608   if (idx)
22609     {
22610       prefix = ELF_STRING_ARM_unwind;
22611       prefix_once = ELF_STRING_ARM_unwind_once;
22612       type = SHT_ARM_EXIDX;
22613     }
22614   else
22615     {
22616       prefix = ELF_STRING_ARM_unwind_info;
22617       prefix_once = ELF_STRING_ARM_unwind_info_once;
22618       type = SHT_PROGBITS;
22619     }
22620
22621   text_name = segment_name (text_seg);
22622   if (streq (text_name, ".text"))
22623     text_name = "";
22624
22625   if (strncmp (text_name, ".gnu.linkonce.t.",
22626                strlen (".gnu.linkonce.t.")) == 0)
22627     {
22628       prefix = prefix_once;
22629       text_name += strlen (".gnu.linkonce.t.");
22630     }
22631
22632   sec_name = concat (prefix, text_name, (char *) NULL);
22633
22634   flags = SHF_ALLOC;
22635   linkonce = 0;
22636   group_name = 0;
22637
22638   /* Handle COMDAT group.  */
22639   if (prefix != prefix_once && (text_seg->flags & SEC_LINK_ONCE) != 0)
22640     {
22641       group_name = elf_group_name (text_seg);
22642       if (group_name == NULL)
22643         {
22644           as_bad (_("Group section `%s' has no group signature"),
22645                   segment_name (text_seg));
22646           ignore_rest_of_line ();
22647           return;
22648         }
22649       flags |= SHF_GROUP;
22650       linkonce = 1;
22651     }
22652
22653   obj_elf_change_section (sec_name, type, 0, flags, 0, group_name,
22654                           linkonce, 0);
22655
22656   /* Set the section link for index tables.  */
22657   if (idx)
22658     elf_linked_to_section (now_seg) = text_seg;
22659 }
22660
22661
22662 /* Start an unwind table entry.  HAVE_DATA is nonzero if we have additional
22663    personality routine data.  Returns zero, or the index table value for
22664    an inline entry.  */
22665
22666 static valueT
22667 create_unwind_entry (int have_data)
22668 {
22669   int size;
22670   addressT where;
22671   char *ptr;
22672   /* The current word of data.  */
22673   valueT data;
22674   /* The number of bytes left in this word.  */
22675   int n;
22676
22677   finish_unwind_opcodes ();
22678
22679   /* Remember the current text section.  */
22680   unwind.saved_seg = now_seg;
22681   unwind.saved_subseg = now_subseg;
22682
22683   start_unwind_section (now_seg, 0);
22684
22685   if (unwind.personality_routine == NULL)
22686     {
22687       if (unwind.personality_index == -2)
22688         {
22689           if (have_data)
22690             as_bad (_("handlerdata in cantunwind frame"));
22691           return 1; /* EXIDX_CANTUNWIND.  */
22692         }
22693
22694       /* Use a default personality routine if none is specified.  */
22695       if (unwind.personality_index == -1)
22696         {
22697           if (unwind.opcode_count > 3)
22698             unwind.personality_index = 1;
22699           else
22700             unwind.personality_index = 0;
22701         }
22702
22703       /* Space for the personality routine entry.  */
22704       if (unwind.personality_index == 0)
22705         {
22706           if (unwind.opcode_count > 3)
22707             as_bad (_("too many unwind opcodes for personality routine 0"));
22708
22709           if (!have_data)
22710             {
22711               /* All the data is inline in the index table.  */
22712               data = 0x80;
22713               n = 3;
22714               while (unwind.opcode_count > 0)
22715                 {
22716                   unwind.opcode_count--;
22717                   data = (data << 8) | unwind.opcodes[unwind.opcode_count];
22718                   n--;
22719                 }
22720
22721               /* Pad with "finish" opcodes.  */
22722               while (n--)
22723                 data = (data << 8) | 0xb0;
22724
22725               return data;
22726             }
22727           size = 0;
22728         }
22729       else
22730         /* We get two opcodes "free" in the first word.  */
22731         size = unwind.opcode_count - 2;
22732     }
22733   else
22734     {
22735       /* PR 16765: Missing or misplaced unwind directives can trigger this.  */
22736       if (unwind.personality_index != -1)
22737         {
22738           as_bad (_("attempt to recreate an unwind entry"));
22739           return 1;
22740         }
22741
22742       /* An extra byte is required for the opcode count.        */
22743       size = unwind.opcode_count + 1;
22744     }
22745
22746   size = (size + 3) >> 2;
22747   if (size > 0xff)
22748     as_bad (_("too many unwind opcodes"));
22749
22750   frag_align (2, 0, 0);
22751   record_alignment (now_seg, 2);
22752   unwind.table_entry = expr_build_dot ();
22753
22754   /* Allocate the table entry.  */
22755   ptr = frag_more ((size << 2) + 4);
22756   /* PR 13449: Zero the table entries in case some of them are not used.  */
22757   memset (ptr, 0, (size << 2) + 4);
22758   where = frag_now_fix () - ((size << 2) + 4);
22759
22760   switch (unwind.personality_index)
22761     {
22762     case -1:
22763       /* ??? Should this be a PLT generating relocation?  */
22764       /* Custom personality routine.  */
22765       fix_new (frag_now, where, 4, unwind.personality_routine, 0, 1,
22766                BFD_RELOC_ARM_PREL31);
22767
22768       where += 4;
22769       ptr += 4;
22770
22771       /* Set the first byte to the number of additional words.  */
22772       data = size > 0 ? size - 1 : 0;
22773       n = 3;
22774       break;
22775
22776     /* ABI defined personality routines.  */
22777     case 0:
22778       /* Three opcodes bytes are packed into the first word.  */
22779       data = 0x80;
22780       n = 3;
22781       break;
22782
22783     case 1:
22784     case 2:
22785       /* The size and first two opcode bytes go in the first word.  */
22786       data = ((0x80 + unwind.personality_index) << 8) | size;
22787       n = 2;
22788       break;
22789
22790     default:
22791       /* Should never happen.  */
22792       abort ();
22793     }
22794
22795   /* Pack the opcodes into words (MSB first), reversing the list at the same
22796      time.  */
22797   while (unwind.opcode_count > 0)
22798     {
22799       if (n == 0)
22800         {
22801           md_number_to_chars (ptr, data, 4);
22802           ptr += 4;
22803           n = 4;
22804           data = 0;
22805         }
22806       unwind.opcode_count--;
22807       n--;
22808       data = (data << 8) | unwind.opcodes[unwind.opcode_count];
22809     }
22810
22811   /* Finish off the last word.  */
22812   if (n < 4)
22813     {
22814       /* Pad with "finish" opcodes.  */
22815       while (n--)
22816         data = (data << 8) | 0xb0;
22817
22818       md_number_to_chars (ptr, data, 4);
22819     }
22820
22821   if (!have_data)
22822     {
22823       /* Add an empty descriptor if there is no user-specified data.   */
22824       ptr = frag_more (4);
22825       md_number_to_chars (ptr, 0, 4);
22826     }
22827
22828   return 0;
22829 }
22830
22831
22832 /* Initialize the DWARF-2 unwind information for this procedure.  */
22833
22834 void
22835 tc_arm_frame_initial_instructions (void)
22836 {
22837   cfi_add_CFA_def_cfa (REG_SP, 0);
22838 }
22839 #endif /* OBJ_ELF */
22840
22841 /* Convert REGNAME to a DWARF-2 register number.  */
22842
22843 int
22844 tc_arm_regname_to_dw2regnum (char *regname)
22845 {
22846   int reg = arm_reg_parse (&regname, REG_TYPE_RN);
22847   if (reg != FAIL)
22848     return reg;
22849
22850   /* PR 16694: Allow VFP registers as well.  */
22851   reg = arm_reg_parse (&regname, REG_TYPE_VFS);
22852   if (reg != FAIL)
22853     return 64 + reg;
22854
22855   reg = arm_reg_parse (&regname, REG_TYPE_VFD);
22856   if (reg != FAIL)
22857     return reg + 256;
22858
22859   return FAIL;
22860 }
22861
22862 #ifdef TE_PE
22863 void
22864 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
22865 {
22866   expressionS exp;
22867
22868   exp.X_op = O_secrel;
22869   exp.X_add_symbol = symbol;
22870   exp.X_add_number = 0;
22871   emit_expr (&exp, size);
22872 }
22873 #endif
22874
22875 /* MD interface: Symbol and relocation handling.  */
22876
22877 /* Return the address within the segment that a PC-relative fixup is
22878    relative to.  For ARM, PC-relative fixups applied to instructions
22879    are generally relative to the location of the fixup plus 8 bytes.
22880    Thumb branches are offset by 4, and Thumb loads relative to PC
22881    require special handling.  */
22882
22883 long
22884 md_pcrel_from_section (fixS * fixP, segT seg)
22885 {
22886   offsetT base = fixP->fx_where + fixP->fx_frag->fr_address;
22887
22888   /* If this is pc-relative and we are going to emit a relocation
22889      then we just want to put out any pipeline compensation that the linker
22890      will need.  Otherwise we want to use the calculated base.
22891      For WinCE we skip the bias for externals as well, since this
22892      is how the MS ARM-CE assembler behaves and we want to be compatible.  */
22893   if (fixP->fx_pcrel
22894       && ((fixP->fx_addsy && S_GET_SEGMENT (fixP->fx_addsy) != seg)
22895           || (arm_force_relocation (fixP)
22896 #ifdef TE_WINCE
22897               && !S_IS_EXTERNAL (fixP->fx_addsy)
22898 #endif
22899               )))
22900     base = 0;
22901
22902
22903   switch (fixP->fx_r_type)
22904     {
22905       /* PC relative addressing on the Thumb is slightly odd as the
22906          bottom two bits of the PC are forced to zero for the
22907          calculation.  This happens *after* application of the
22908          pipeline offset.  However, Thumb adrl already adjusts for
22909          this, so we need not do it again.  */
22910     case BFD_RELOC_ARM_THUMB_ADD:
22911       return base & ~3;
22912
22913     case BFD_RELOC_ARM_THUMB_OFFSET:
22914     case BFD_RELOC_ARM_T32_OFFSET_IMM:
22915     case BFD_RELOC_ARM_T32_ADD_PC12:
22916     case BFD_RELOC_ARM_T32_CP_OFF_IMM:
22917       return (base + 4) & ~3;
22918
22919       /* Thumb branches are simply offset by +4.  */
22920     case BFD_RELOC_THUMB_PCREL_BRANCH5:
22921     case BFD_RELOC_THUMB_PCREL_BRANCH7:
22922     case BFD_RELOC_THUMB_PCREL_BRANCH9:
22923     case BFD_RELOC_THUMB_PCREL_BRANCH12:
22924     case BFD_RELOC_THUMB_PCREL_BRANCH20:
22925     case BFD_RELOC_THUMB_PCREL_BRANCH25:
22926     case BFD_RELOC_ARM_THUMB_BF17:
22927     case BFD_RELOC_ARM_THUMB_BF19:
22928       return base + 4;
22929
22930     case BFD_RELOC_THUMB_PCREL_BRANCH23:
22931       if (fixP->fx_addsy
22932           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22933           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
22934           && ARM_IS_FUNC (fixP->fx_addsy)
22935           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
22936         base = fixP->fx_where + fixP->fx_frag->fr_address;
22937        return base + 4;
22938
22939       /* BLX is like branches above, but forces the low two bits of PC to
22940          zero.  */
22941     case BFD_RELOC_THUMB_PCREL_BLX:
22942       if (fixP->fx_addsy
22943           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22944           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
22945           && THUMB_IS_FUNC (fixP->fx_addsy)
22946           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
22947         base = fixP->fx_where + fixP->fx_frag->fr_address;
22948       return (base + 4) & ~3;
22949
22950       /* ARM mode branches are offset by +8.  However, the Windows CE
22951          loader expects the relocation not to take this into account.  */
22952     case BFD_RELOC_ARM_PCREL_BLX:
22953       if (fixP->fx_addsy
22954           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22955           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
22956           && ARM_IS_FUNC (fixP->fx_addsy)
22957           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
22958         base = fixP->fx_where + fixP->fx_frag->fr_address;
22959       return base + 8;
22960
22961     case BFD_RELOC_ARM_PCREL_CALL:
22962       if (fixP->fx_addsy
22963           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22964           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
22965           && THUMB_IS_FUNC (fixP->fx_addsy)
22966           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
22967         base = fixP->fx_where + fixP->fx_frag->fr_address;
22968       return base + 8;
22969
22970     case BFD_RELOC_ARM_PCREL_BRANCH:
22971     case BFD_RELOC_ARM_PCREL_JUMP:
22972     case BFD_RELOC_ARM_PLT32:
22973 #ifdef TE_WINCE
22974       /* When handling fixups immediately, because we have already
22975          discovered the value of a symbol, or the address of the frag involved
22976          we must account for the offset by +8, as the OS loader will never see the reloc.
22977          see fixup_segment() in write.c
22978          The S_IS_EXTERNAL test handles the case of global symbols.
22979          Those need the calculated base, not just the pipe compensation the linker will need.  */
22980       if (fixP->fx_pcrel
22981           && fixP->fx_addsy != NULL
22982           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22983           && (S_IS_EXTERNAL (fixP->fx_addsy) || !arm_force_relocation (fixP)))
22984         return base + 8;
22985       return base;
22986 #else
22987       return base + 8;
22988 #endif
22989
22990
22991       /* ARM mode loads relative to PC are also offset by +8.  Unlike
22992          branches, the Windows CE loader *does* expect the relocation
22993          to take this into account.  */
22994     case BFD_RELOC_ARM_OFFSET_IMM:
22995     case BFD_RELOC_ARM_OFFSET_IMM8:
22996     case BFD_RELOC_ARM_HWLITERAL:
22997     case BFD_RELOC_ARM_LITERAL:
22998     case BFD_RELOC_ARM_CP_OFF_IMM:
22999       return base + 8;
23000
23001
23002       /* Other PC-relative relocations are un-offset.  */
23003     default:
23004       return base;
23005     }
23006 }
23007
23008 static bfd_boolean flag_warn_syms = TRUE;
23009
23010 bfd_boolean
23011 arm_tc_equal_in_insn (int c ATTRIBUTE_UNUSED, char * name)
23012 {
23013   /* PR 18347 - Warn if the user attempts to create a symbol with the same
23014      name as an ARM instruction.  Whilst strictly speaking it is allowed, it
23015      does mean that the resulting code might be very confusing to the reader.
23016      Also this warning can be triggered if the user omits an operand before
23017      an immediate address, eg:
23018
23019        LDR =foo
23020
23021      GAS treats this as an assignment of the value of the symbol foo to a
23022      symbol LDR, and so (without this code) it will not issue any kind of
23023      warning or error message.
23024
23025      Note - ARM instructions are case-insensitive but the strings in the hash
23026      table are all stored in lower case, so we must first ensure that name is
23027      lower case too.  */
23028   if (flag_warn_syms && arm_ops_hsh)
23029     {
23030       char * nbuf = strdup (name);
23031       char * p;
23032
23033       for (p = nbuf; *p; p++)
23034         *p = TOLOWER (*p);
23035       if (hash_find (arm_ops_hsh, nbuf) != NULL)
23036         {
23037           static struct hash_control * already_warned = NULL;
23038
23039           if (already_warned == NULL)
23040             already_warned = hash_new ();
23041           /* Only warn about the symbol once.  To keep the code
23042              simple we let hash_insert do the lookup for us.  */
23043           if (hash_insert (already_warned, name, NULL) == NULL)
23044             as_warn (_("[-mwarn-syms]: Assignment makes a symbol match an ARM instruction: %s"), name);
23045         }
23046       else
23047         free (nbuf);
23048     }
23049
23050   return FALSE;
23051 }
23052
23053 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
23054    Otherwise we have no need to default values of symbols.  */
23055
23056 symbolS *
23057 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
23058 {
23059 #ifdef OBJ_ELF
23060   if (name[0] == '_' && name[1] == 'G'
23061       && streq (name, GLOBAL_OFFSET_TABLE_NAME))
23062     {
23063       if (!GOT_symbol)
23064         {
23065           if (symbol_find (name))
23066             as_bad (_("GOT already in the symbol table"));
23067
23068           GOT_symbol = symbol_new (name, undefined_section,
23069                                    (valueT) 0, & zero_address_frag);
23070         }
23071
23072       return GOT_symbol;
23073     }
23074 #endif
23075
23076   return NULL;
23077 }
23078
23079 /* Subroutine of md_apply_fix.   Check to see if an immediate can be
23080    computed as two separate immediate values, added together.  We
23081    already know that this value cannot be computed by just one ARM
23082    instruction.  */
23083
23084 static unsigned int
23085 validate_immediate_twopart (unsigned int   val,
23086                             unsigned int * highpart)
23087 {
23088   unsigned int a;
23089   unsigned int i;
23090
23091   for (i = 0; i < 32; i += 2)
23092     if (((a = rotate_left (val, i)) & 0xff) != 0)
23093       {
23094         if (a & 0xff00)
23095           {
23096             if (a & ~ 0xffff)
23097               continue;
23098             * highpart = (a  >> 8) | ((i + 24) << 7);
23099           }
23100         else if (a & 0xff0000)
23101           {
23102             if (a & 0xff000000)
23103               continue;
23104             * highpart = (a >> 16) | ((i + 16) << 7);
23105           }
23106         else
23107           {
23108             gas_assert (a & 0xff000000);
23109             * highpart = (a >> 24) | ((i + 8) << 7);
23110           }
23111
23112         return (a & 0xff) | (i << 7);
23113       }
23114
23115   return FAIL;
23116 }
23117
23118 static int
23119 validate_offset_imm (unsigned int val, int hwse)
23120 {
23121   if ((hwse && val > 255) || val > 4095)
23122     return FAIL;
23123   return val;
23124 }
23125
23126 /* Subroutine of md_apply_fix.   Do those data_ops which can take a
23127    negative immediate constant by altering the instruction.  A bit of
23128    a hack really.
23129         MOV <-> MVN
23130         AND <-> BIC
23131         ADC <-> SBC
23132         by inverting the second operand, and
23133         ADD <-> SUB
23134         CMP <-> CMN
23135         by negating the second operand.  */
23136
23137 static int
23138 negate_data_op (unsigned long * instruction,
23139                 unsigned long   value)
23140 {
23141   int op, new_inst;
23142   unsigned long negated, inverted;
23143
23144   negated = encode_arm_immediate (-value);
23145   inverted = encode_arm_immediate (~value);
23146
23147   op = (*instruction >> DATA_OP_SHIFT) & 0xf;
23148   switch (op)
23149     {
23150       /* First negates.  */
23151     case OPCODE_SUB:             /* ADD <-> SUB  */
23152       new_inst = OPCODE_ADD;
23153       value = negated;
23154       break;
23155
23156     case OPCODE_ADD:
23157       new_inst = OPCODE_SUB;
23158       value = negated;
23159       break;
23160
23161     case OPCODE_CMP:             /* CMP <-> CMN  */
23162       new_inst = OPCODE_CMN;
23163       value = negated;
23164       break;
23165
23166     case OPCODE_CMN:
23167       new_inst = OPCODE_CMP;
23168       value = negated;
23169       break;
23170
23171       /* Now Inverted ops.  */
23172     case OPCODE_MOV:             /* MOV <-> MVN  */
23173       new_inst = OPCODE_MVN;
23174       value = inverted;
23175       break;
23176
23177     case OPCODE_MVN:
23178       new_inst = OPCODE_MOV;
23179       value = inverted;
23180       break;
23181
23182     case OPCODE_AND:             /* AND <-> BIC  */
23183       new_inst = OPCODE_BIC;
23184       value = inverted;
23185       break;
23186
23187     case OPCODE_BIC:
23188       new_inst = OPCODE_AND;
23189       value = inverted;
23190       break;
23191
23192     case OPCODE_ADC:              /* ADC <-> SBC  */
23193       new_inst = OPCODE_SBC;
23194       value = inverted;
23195       break;
23196
23197     case OPCODE_SBC:
23198       new_inst = OPCODE_ADC;
23199       value = inverted;
23200       break;
23201
23202       /* We cannot do anything.  */
23203     default:
23204       return FAIL;
23205     }
23206
23207   if (value == (unsigned) FAIL)
23208     return FAIL;
23209
23210   *instruction &= OPCODE_MASK;
23211   *instruction |= new_inst << DATA_OP_SHIFT;
23212   return value;
23213 }
23214
23215 /* Like negate_data_op, but for Thumb-2.   */
23216
23217 static unsigned int
23218 thumb32_negate_data_op (offsetT *instruction, unsigned int value)
23219 {
23220   int op, new_inst;
23221   int rd;
23222   unsigned int negated, inverted;
23223
23224   negated = encode_thumb32_immediate (-value);
23225   inverted = encode_thumb32_immediate (~value);
23226
23227   rd = (*instruction >> 8) & 0xf;
23228   op = (*instruction >> T2_DATA_OP_SHIFT) & 0xf;
23229   switch (op)
23230     {
23231       /* ADD <-> SUB.  Includes CMP <-> CMN.  */
23232     case T2_OPCODE_SUB:
23233       new_inst = T2_OPCODE_ADD;
23234       value = negated;
23235       break;
23236
23237     case T2_OPCODE_ADD:
23238       new_inst = T2_OPCODE_SUB;
23239       value = negated;
23240       break;
23241
23242       /* ORR <-> ORN.  Includes MOV <-> MVN.  */
23243     case T2_OPCODE_ORR:
23244       new_inst = T2_OPCODE_ORN;
23245       value = inverted;
23246       break;
23247
23248     case T2_OPCODE_ORN:
23249       new_inst = T2_OPCODE_ORR;
23250       value = inverted;
23251       break;
23252
23253       /* AND <-> BIC.  TST has no inverted equivalent.  */
23254     case T2_OPCODE_AND:
23255       new_inst = T2_OPCODE_BIC;
23256       if (rd == 15)
23257         value = FAIL;
23258       else
23259         value = inverted;
23260       break;
23261
23262     case T2_OPCODE_BIC:
23263       new_inst = T2_OPCODE_AND;
23264       value = inverted;
23265       break;
23266
23267       /* ADC <-> SBC  */
23268     case T2_OPCODE_ADC:
23269       new_inst = T2_OPCODE_SBC;
23270       value = inverted;
23271       break;
23272
23273     case T2_OPCODE_SBC:
23274       new_inst = T2_OPCODE_ADC;
23275       value = inverted;
23276       break;
23277
23278       /* We cannot do anything.  */
23279     default:
23280       return FAIL;
23281     }
23282
23283   if (value == (unsigned int)FAIL)
23284     return FAIL;
23285
23286   *instruction &= T2_OPCODE_MASK;
23287   *instruction |= new_inst << T2_DATA_OP_SHIFT;
23288   return value;
23289 }
23290
23291 /* Read a 32-bit thumb instruction from buf.  */
23292
23293 static unsigned long
23294 get_thumb32_insn (char * buf)
23295 {
23296   unsigned long insn;
23297   insn = md_chars_to_number (buf, THUMB_SIZE) << 16;
23298   insn |= md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
23299
23300   return insn;
23301 }
23302
23303 /* We usually want to set the low bit on the address of thumb function
23304    symbols.  In particular .word foo - . should have the low bit set.
23305    Generic code tries to fold the difference of two symbols to
23306    a constant.  Prevent this and force a relocation when the first symbols
23307    is a thumb function.  */
23308
23309 bfd_boolean
23310 arm_optimize_expr (expressionS *l, operatorT op, expressionS *r)
23311 {
23312   if (op == O_subtract
23313       && l->X_op == O_symbol
23314       && r->X_op == O_symbol
23315       && THUMB_IS_FUNC (l->X_add_symbol))
23316     {
23317       l->X_op = O_subtract;
23318       l->X_op_symbol = r->X_add_symbol;
23319       l->X_add_number -= r->X_add_number;
23320       return TRUE;
23321     }
23322
23323   /* Process as normal.  */
23324   return FALSE;
23325 }
23326
23327 /* Encode Thumb2 unconditional branches and calls. The encoding
23328    for the 2 are identical for the immediate values.  */
23329
23330 static void
23331 encode_thumb2_b_bl_offset (char * buf, offsetT value)
23332 {
23333 #define T2I1I2MASK  ((1 << 13) | (1 << 11))
23334   offsetT newval;
23335   offsetT newval2;
23336   addressT S, I1, I2, lo, hi;
23337
23338   S = (value >> 24) & 0x01;
23339   I1 = (value >> 23) & 0x01;
23340   I2 = (value >> 22) & 0x01;
23341   hi = (value >> 12) & 0x3ff;
23342   lo = (value >> 1) & 0x7ff;
23343   newval   = md_chars_to_number (buf, THUMB_SIZE);
23344   newval2  = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
23345   newval  |= (S << 10) | hi;
23346   newval2 &=  ~T2I1I2MASK;
23347   newval2 |= (((I1 ^ S) << 13) | ((I2 ^ S) << 11) | lo) ^ T2I1I2MASK;
23348   md_number_to_chars (buf, newval, THUMB_SIZE);
23349   md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
23350 }
23351
23352 void
23353 md_apply_fix (fixS *    fixP,
23354                valueT * valP,
23355                segT     seg)
23356 {
23357   offsetT        value = * valP;
23358   offsetT        newval;
23359   unsigned int   newimm;
23360   unsigned long  temp;
23361   int            sign;
23362   char *         buf = fixP->fx_where + fixP->fx_frag->fr_literal;
23363
23364   gas_assert (fixP->fx_r_type <= BFD_RELOC_UNUSED);
23365
23366   /* Note whether this will delete the relocation.  */
23367
23368   if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
23369     fixP->fx_done = 1;
23370
23371   /* On a 64-bit host, silently truncate 'value' to 32 bits for
23372      consistency with the behaviour on 32-bit hosts.  Remember value
23373      for emit_reloc.  */
23374   value &= 0xffffffff;
23375   value ^= 0x80000000;
23376   value -= 0x80000000;
23377
23378   *valP = value;
23379   fixP->fx_addnumber = value;
23380
23381   /* Same treatment for fixP->fx_offset.  */
23382   fixP->fx_offset &= 0xffffffff;
23383   fixP->fx_offset ^= 0x80000000;
23384   fixP->fx_offset -= 0x80000000;
23385
23386   switch (fixP->fx_r_type)
23387     {
23388     case BFD_RELOC_NONE:
23389       /* This will need to go in the object file.  */
23390       fixP->fx_done = 0;
23391       break;
23392
23393     case BFD_RELOC_ARM_IMMEDIATE:
23394       /* We claim that this fixup has been processed here,
23395          even if in fact we generate an error because we do
23396          not have a reloc for it, so tc_gen_reloc will reject it.  */
23397       fixP->fx_done = 1;
23398
23399       if (fixP->fx_addsy)
23400         {
23401           const char *msg = 0;
23402
23403           if (! S_IS_DEFINED (fixP->fx_addsy))
23404             msg = _("undefined symbol %s used as an immediate value");
23405           else if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
23406             msg = _("symbol %s is in a different section");
23407           else if (S_IS_WEAK (fixP->fx_addsy))
23408             msg = _("symbol %s is weak and may be overridden later");
23409
23410           if (msg)
23411             {
23412               as_bad_where (fixP->fx_file, fixP->fx_line,
23413                             msg, S_GET_NAME (fixP->fx_addsy));
23414               break;
23415             }
23416         }
23417
23418       temp = md_chars_to_number (buf, INSN_SIZE);
23419
23420       /* If the offset is negative, we should use encoding A2 for ADR.  */
23421       if ((temp & 0xfff0000) == 0x28f0000 && value < 0)
23422         newimm = negate_data_op (&temp, value);
23423       else
23424         {
23425           newimm = encode_arm_immediate (value);
23426
23427           /* If the instruction will fail, see if we can fix things up by
23428              changing the opcode.  */
23429           if (newimm == (unsigned int) FAIL)
23430             newimm = negate_data_op (&temp, value);
23431           /* MOV accepts both ARM modified immediate (A1 encoding) and
23432              UINT16 (A2 encoding) when possible, MOVW only accepts UINT16.
23433              When disassembling, MOV is preferred when there is no encoding
23434              overlap.  */
23435           if (newimm == (unsigned int) FAIL
23436               && ((temp >> DATA_OP_SHIFT) & 0xf) == OPCODE_MOV
23437               && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6t2)
23438               && !((temp >> SBIT_SHIFT) & 0x1)
23439               && value >= 0 && value <= 0xffff)
23440             {
23441               /* Clear bits[23:20] to change encoding from A1 to A2.  */
23442               temp &= 0xff0fffff;
23443               /* Encoding high 4bits imm.  Code below will encode the remaining
23444                  low 12bits.  */
23445               temp |= (value & 0x0000f000) << 4;
23446               newimm = value & 0x00000fff;
23447             }
23448         }
23449
23450       if (newimm == (unsigned int) FAIL)
23451         {
23452           as_bad_where (fixP->fx_file, fixP->fx_line,
23453                         _("invalid constant (%lx) after fixup"),
23454                         (unsigned long) value);
23455           break;
23456         }
23457
23458       newimm |= (temp & 0xfffff000);
23459       md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
23460       break;
23461
23462     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
23463       {
23464         unsigned int highpart = 0;
23465         unsigned int newinsn  = 0xe1a00000; /* nop.  */
23466
23467         if (fixP->fx_addsy)
23468           {
23469             const char *msg = 0;
23470
23471             if (! S_IS_DEFINED (fixP->fx_addsy))
23472               msg = _("undefined symbol %s used as an immediate value");
23473             else if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
23474               msg = _("symbol %s is in a different section");
23475             else if (S_IS_WEAK (fixP->fx_addsy))
23476               msg = _("symbol %s is weak and may be overridden later");
23477
23478             if (msg)
23479               {
23480                 as_bad_where (fixP->fx_file, fixP->fx_line,
23481                               msg, S_GET_NAME (fixP->fx_addsy));
23482                 break;
23483               }
23484           }
23485
23486         newimm = encode_arm_immediate (value);
23487         temp = md_chars_to_number (buf, INSN_SIZE);
23488
23489         /* If the instruction will fail, see if we can fix things up by
23490            changing the opcode.  */
23491         if (newimm == (unsigned int) FAIL
23492             && (newimm = negate_data_op (& temp, value)) == (unsigned int) FAIL)
23493           {
23494             /* No ?  OK - try using two ADD instructions to generate
23495                the value.  */
23496             newimm = validate_immediate_twopart (value, & highpart);
23497
23498             /* Yes - then make sure that the second instruction is
23499                also an add.  */
23500             if (newimm != (unsigned int) FAIL)
23501               newinsn = temp;
23502             /* Still No ?  Try using a negated value.  */
23503             else if ((newimm = validate_immediate_twopart (- value, & highpart)) != (unsigned int) FAIL)
23504               temp = newinsn = (temp & OPCODE_MASK) | OPCODE_SUB << DATA_OP_SHIFT;
23505             /* Otherwise - give up.  */
23506             else
23507               {
23508                 as_bad_where (fixP->fx_file, fixP->fx_line,
23509                               _("unable to compute ADRL instructions for PC offset of 0x%lx"),
23510                               (long) value);
23511                 break;
23512               }
23513
23514             /* Replace the first operand in the 2nd instruction (which
23515                is the PC) with the destination register.  We have
23516                already added in the PC in the first instruction and we
23517                do not want to do it again.  */
23518             newinsn &= ~ 0xf0000;
23519             newinsn |= ((newinsn & 0x0f000) << 4);
23520           }
23521
23522         newimm |= (temp & 0xfffff000);
23523         md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
23524
23525         highpart |= (newinsn & 0xfffff000);
23526         md_number_to_chars (buf + INSN_SIZE, (valueT) highpart, INSN_SIZE);
23527       }
23528       break;
23529
23530     case BFD_RELOC_ARM_OFFSET_IMM:
23531       if (!fixP->fx_done && seg->use_rela_p)
23532         value = 0;
23533       /* Fall through.  */
23534
23535     case BFD_RELOC_ARM_LITERAL:
23536       sign = value > 0;
23537
23538       if (value < 0)
23539         value = - value;
23540
23541       if (validate_offset_imm (value, 0) == FAIL)
23542         {
23543           if (fixP->fx_r_type == BFD_RELOC_ARM_LITERAL)
23544             as_bad_where (fixP->fx_file, fixP->fx_line,
23545                           _("invalid literal constant: pool needs to be closer"));
23546           else
23547             as_bad_where (fixP->fx_file, fixP->fx_line,
23548                           _("bad immediate value for offset (%ld)"),
23549                           (long) value);
23550           break;
23551         }
23552
23553       newval = md_chars_to_number (buf, INSN_SIZE);
23554       if (value == 0)
23555         newval &= 0xfffff000;
23556       else
23557         {
23558           newval &= 0xff7ff000;
23559           newval |= value | (sign ? INDEX_UP : 0);
23560         }
23561       md_number_to_chars (buf, newval, INSN_SIZE);
23562       break;
23563
23564     case BFD_RELOC_ARM_OFFSET_IMM8:
23565     case BFD_RELOC_ARM_HWLITERAL:
23566       sign = value > 0;
23567
23568       if (value < 0)
23569         value = - value;
23570
23571       if (validate_offset_imm (value, 1) == FAIL)
23572         {
23573           if (fixP->fx_r_type == BFD_RELOC_ARM_HWLITERAL)
23574             as_bad_where (fixP->fx_file, fixP->fx_line,
23575                           _("invalid literal constant: pool needs to be closer"));
23576           else
23577             as_bad_where (fixP->fx_file, fixP->fx_line,
23578                           _("bad immediate value for 8-bit offset (%ld)"),
23579                           (long) value);
23580           break;
23581         }
23582
23583       newval = md_chars_to_number (buf, INSN_SIZE);
23584       if (value == 0)
23585         newval &= 0xfffff0f0;
23586       else
23587         {
23588           newval &= 0xff7ff0f0;
23589           newval |= ((value >> 4) << 8) | (value & 0xf) | (sign ? INDEX_UP : 0);
23590         }
23591       md_number_to_chars (buf, newval, INSN_SIZE);
23592       break;
23593
23594     case BFD_RELOC_ARM_T32_OFFSET_U8:
23595       if (value < 0 || value > 1020 || value % 4 != 0)
23596         as_bad_where (fixP->fx_file, fixP->fx_line,
23597                       _("bad immediate value for offset (%ld)"), (long) value);
23598       value /= 4;
23599
23600       newval = md_chars_to_number (buf+2, THUMB_SIZE);
23601       newval |= value;
23602       md_number_to_chars (buf+2, newval, THUMB_SIZE);
23603       break;
23604
23605     case BFD_RELOC_ARM_T32_OFFSET_IMM:
23606       /* This is a complicated relocation used for all varieties of Thumb32
23607          load/store instruction with immediate offset:
23608
23609          1110 100P u1WL NNNN XXXX YYYY iiii iiii - +/-(U) pre/post(P) 8-bit,
23610                                                    *4, optional writeback(W)
23611                                                    (doubleword load/store)
23612
23613          1111 100S uTTL 1111 XXXX iiii iiii iiii - +/-(U) 12-bit PC-rel
23614          1111 100S 0TTL NNNN XXXX 1Pu1 iiii iiii - +/-(U) pre/post(P) 8-bit
23615          1111 100S 0TTL NNNN XXXX 1110 iiii iiii - positive 8-bit (T instruction)
23616          1111 100S 1TTL NNNN XXXX iiii iiii iiii - positive 12-bit
23617          1111 100S 0TTL NNNN XXXX 1100 iiii iiii - negative 8-bit
23618
23619          Uppercase letters indicate bits that are already encoded at
23620          this point.  Lowercase letters are our problem.  For the
23621          second block of instructions, the secondary opcode nybble
23622          (bits 8..11) is present, and bit 23 is zero, even if this is
23623          a PC-relative operation.  */
23624       newval = md_chars_to_number (buf, THUMB_SIZE);
23625       newval <<= 16;
23626       newval |= md_chars_to_number (buf+THUMB_SIZE, THUMB_SIZE);
23627
23628       if ((newval & 0xf0000000) == 0xe0000000)
23629         {
23630           /* Doubleword load/store: 8-bit offset, scaled by 4.  */
23631           if (value >= 0)
23632             newval |= (1 << 23);
23633           else
23634             value = -value;
23635           if (value % 4 != 0)
23636             {
23637               as_bad_where (fixP->fx_file, fixP->fx_line,
23638                             _("offset not a multiple of 4"));
23639               break;
23640             }
23641           value /= 4;
23642           if (value > 0xff)
23643             {
23644               as_bad_where (fixP->fx_file, fixP->fx_line,
23645                             _("offset out of range"));
23646               break;
23647             }
23648           newval &= ~0xff;
23649         }
23650       else if ((newval & 0x000f0000) == 0x000f0000)
23651         {
23652           /* PC-relative, 12-bit offset.  */
23653           if (value >= 0)
23654             newval |= (1 << 23);
23655           else
23656             value = -value;
23657           if (value > 0xfff)
23658             {
23659               as_bad_where (fixP->fx_file, fixP->fx_line,
23660                             _("offset out of range"));
23661               break;
23662             }
23663           newval &= ~0xfff;
23664         }
23665       else if ((newval & 0x00000100) == 0x00000100)
23666         {
23667           /* Writeback: 8-bit, +/- offset.  */
23668           if (value >= 0)
23669             newval |= (1 << 9);
23670           else
23671             value = -value;
23672           if (value > 0xff)
23673             {
23674               as_bad_where (fixP->fx_file, fixP->fx_line,
23675                             _("offset out of range"));
23676               break;
23677             }
23678           newval &= ~0xff;
23679         }
23680       else if ((newval & 0x00000f00) == 0x00000e00)
23681         {
23682           /* T-instruction: positive 8-bit offset.  */
23683           if (value < 0 || value > 0xff)
23684             {
23685               as_bad_where (fixP->fx_file, fixP->fx_line,
23686                             _("offset out of range"));
23687               break;
23688             }
23689           newval &= ~0xff;
23690           newval |= value;
23691         }
23692       else
23693         {
23694           /* Positive 12-bit or negative 8-bit offset.  */
23695           int limit;
23696           if (value >= 0)
23697             {
23698               newval |= (1 << 23);
23699               limit = 0xfff;
23700             }
23701           else
23702             {
23703               value = -value;
23704               limit = 0xff;
23705             }
23706           if (value > limit)
23707             {
23708               as_bad_where (fixP->fx_file, fixP->fx_line,
23709                             _("offset out of range"));
23710               break;
23711             }
23712           newval &= ~limit;
23713         }
23714
23715       newval |= value;
23716       md_number_to_chars (buf, (newval >> 16) & 0xffff, THUMB_SIZE);
23717       md_number_to_chars (buf + THUMB_SIZE, newval & 0xffff, THUMB_SIZE);
23718       break;
23719
23720     case BFD_RELOC_ARM_SHIFT_IMM:
23721       newval = md_chars_to_number (buf, INSN_SIZE);
23722       if (((unsigned long) value) > 32
23723           || (value == 32
23724               && (((newval & 0x60) == 0) || (newval & 0x60) == 0x60)))
23725         {
23726           as_bad_where (fixP->fx_file, fixP->fx_line,
23727                         _("shift expression is too large"));
23728           break;
23729         }
23730
23731       if (value == 0)
23732         /* Shifts of zero must be done as lsl.  */
23733         newval &= ~0x60;
23734       else if (value == 32)
23735         value = 0;
23736       newval &= 0xfffff07f;
23737       newval |= (value & 0x1f) << 7;
23738       md_number_to_chars (buf, newval, INSN_SIZE);
23739       break;
23740
23741     case BFD_RELOC_ARM_T32_IMMEDIATE:
23742     case BFD_RELOC_ARM_T32_ADD_IMM:
23743     case BFD_RELOC_ARM_T32_IMM12:
23744     case BFD_RELOC_ARM_T32_ADD_PC12:
23745       /* We claim that this fixup has been processed here,
23746          even if in fact we generate an error because we do
23747          not have a reloc for it, so tc_gen_reloc will reject it.  */
23748       fixP->fx_done = 1;
23749
23750       if (fixP->fx_addsy
23751           && ! S_IS_DEFINED (fixP->fx_addsy))
23752         {
23753           as_bad_where (fixP->fx_file, fixP->fx_line,
23754                         _("undefined symbol %s used as an immediate value"),
23755                         S_GET_NAME (fixP->fx_addsy));
23756           break;
23757         }
23758
23759       newval = md_chars_to_number (buf, THUMB_SIZE);
23760       newval <<= 16;
23761       newval |= md_chars_to_number (buf+2, THUMB_SIZE);
23762
23763       newimm = FAIL;
23764       if ((fixP->fx_r_type == BFD_RELOC_ARM_T32_IMMEDIATE
23765            /* ARMv8-M Baseline MOV will reach here, but it doesn't support
23766               Thumb2 modified immediate encoding (T2).  */
23767            && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6t2))
23768           || fixP->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM)
23769         {
23770           newimm = encode_thumb32_immediate (value);
23771           if (newimm == (unsigned int) FAIL)
23772             newimm = thumb32_negate_data_op (&newval, value);
23773         }
23774       if (newimm == (unsigned int) FAIL)
23775         {
23776           if (fixP->fx_r_type != BFD_RELOC_ARM_T32_IMMEDIATE)
23777             {
23778               /* Turn add/sum into addw/subw.  */
23779               if (fixP->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM)
23780                 newval = (newval & 0xfeffffff) | 0x02000000;
23781               /* No flat 12-bit imm encoding for addsw/subsw.  */
23782               if ((newval & 0x00100000) == 0)
23783                 {
23784                   /* 12 bit immediate for addw/subw.  */
23785                   if (value < 0)
23786                     {
23787                       value = -value;
23788                       newval ^= 0x00a00000;
23789                     }
23790                   if (value > 0xfff)
23791                     newimm = (unsigned int) FAIL;
23792                   else
23793                     newimm = value;
23794                 }
23795             }
23796           else
23797             {
23798               /* MOV accepts both Thumb2 modified immediate (T2 encoding) and
23799                  UINT16 (T3 encoding), MOVW only accepts UINT16.  When
23800                  disassembling, MOV is preferred when there is no encoding
23801                  overlap.  */
23802               if (((newval >> T2_DATA_OP_SHIFT) & 0xf) == T2_OPCODE_ORR
23803                   /* NOTE: MOV uses the ORR opcode in Thumb 2 mode
23804                      but with the Rn field [19:16] set to 1111.  */
23805                   && (((newval >> 16) & 0xf) == 0xf)
23806                   && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6t2_v8m)
23807                   && !((newval >> T2_SBIT_SHIFT) & 0x1)
23808                   && value >= 0 && value <= 0xffff)
23809                 {
23810                   /* Toggle bit[25] to change encoding from T2 to T3.  */
23811                   newval ^= 1 << 25;
23812                   /* Clear bits[19:16].  */
23813                   newval &= 0xfff0ffff;
23814                   /* Encoding high 4bits imm.  Code below will encode the
23815                      remaining low 12bits.  */
23816                   newval |= (value & 0x0000f000) << 4;
23817                   newimm = value & 0x00000fff;
23818                 }
23819             }
23820         }
23821
23822       if (newimm == (unsigned int)FAIL)
23823         {
23824           as_bad_where (fixP->fx_file, fixP->fx_line,
23825                         _("invalid constant (%lx) after fixup"),
23826                         (unsigned long) value);
23827           break;
23828         }
23829
23830       newval |= (newimm & 0x800) << 15;
23831       newval |= (newimm & 0x700) << 4;
23832       newval |= (newimm & 0x0ff);
23833
23834       md_number_to_chars (buf,   (valueT) ((newval >> 16) & 0xffff), THUMB_SIZE);
23835       md_number_to_chars (buf+2, (valueT) (newval & 0xffff), THUMB_SIZE);
23836       break;
23837
23838     case BFD_RELOC_ARM_SMC:
23839       if (((unsigned long) value) > 0xffff)
23840         as_bad_where (fixP->fx_file, fixP->fx_line,
23841                       _("invalid smc expression"));
23842       newval = md_chars_to_number (buf, INSN_SIZE);
23843       newval |= (value & 0xf) | ((value & 0xfff0) << 4);
23844       md_number_to_chars (buf, newval, INSN_SIZE);
23845       break;
23846
23847     case BFD_RELOC_ARM_HVC:
23848       if (((unsigned long) value) > 0xffff)
23849         as_bad_where (fixP->fx_file, fixP->fx_line,
23850                       _("invalid hvc expression"));
23851       newval = md_chars_to_number (buf, INSN_SIZE);
23852       newval |= (value & 0xf) | ((value & 0xfff0) << 4);
23853       md_number_to_chars (buf, newval, INSN_SIZE);
23854       break;
23855
23856     case BFD_RELOC_ARM_SWI:
23857       if (fixP->tc_fix_data != 0)
23858         {
23859           if (((unsigned long) value) > 0xff)
23860             as_bad_where (fixP->fx_file, fixP->fx_line,
23861                           _("invalid swi expression"));
23862           newval = md_chars_to_number (buf, THUMB_SIZE);
23863           newval |= value;
23864           md_number_to_chars (buf, newval, THUMB_SIZE);
23865         }
23866       else
23867         {
23868           if (((unsigned long) value) > 0x00ffffff)
23869             as_bad_where (fixP->fx_file, fixP->fx_line,
23870                           _("invalid swi expression"));
23871           newval = md_chars_to_number (buf, INSN_SIZE);
23872           newval |= value;
23873           md_number_to_chars (buf, newval, INSN_SIZE);
23874         }
23875       break;
23876
23877     case BFD_RELOC_ARM_MULTI:
23878       if (((unsigned long) value) > 0xffff)
23879         as_bad_where (fixP->fx_file, fixP->fx_line,
23880                       _("invalid expression in load/store multiple"));
23881       newval = value | md_chars_to_number (buf, INSN_SIZE);
23882       md_number_to_chars (buf, newval, INSN_SIZE);
23883       break;
23884
23885 #ifdef OBJ_ELF
23886     case BFD_RELOC_ARM_PCREL_CALL:
23887
23888       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
23889           && fixP->fx_addsy
23890           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
23891           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
23892           && THUMB_IS_FUNC (fixP->fx_addsy))
23893         /* Flip the bl to blx. This is a simple flip
23894            bit here because we generate PCREL_CALL for
23895            unconditional bls.  */
23896         {
23897           newval = md_chars_to_number (buf, INSN_SIZE);
23898           newval = newval | 0x10000000;
23899           md_number_to_chars (buf, newval, INSN_SIZE);
23900           temp = 1;
23901           fixP->fx_done = 1;
23902         }
23903       else
23904         temp = 3;
23905       goto arm_branch_common;
23906
23907     case BFD_RELOC_ARM_PCREL_JUMP:
23908       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
23909           && fixP->fx_addsy
23910           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
23911           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
23912           && THUMB_IS_FUNC (fixP->fx_addsy))
23913         {
23914           /* This would map to a bl<cond>, b<cond>,
23915              b<always> to a Thumb function. We
23916              need to force a relocation for this particular
23917              case.  */
23918           newval = md_chars_to_number (buf, INSN_SIZE);
23919           fixP->fx_done = 0;
23920         }
23921       /* Fall through.  */
23922
23923     case BFD_RELOC_ARM_PLT32:
23924 #endif
23925     case BFD_RELOC_ARM_PCREL_BRANCH:
23926       temp = 3;
23927       goto arm_branch_common;
23928
23929     case BFD_RELOC_ARM_PCREL_BLX:
23930
23931       temp = 1;
23932       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
23933           && fixP->fx_addsy
23934           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
23935           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
23936           && ARM_IS_FUNC (fixP->fx_addsy))
23937         {
23938           /* Flip the blx to a bl and warn.  */
23939           const char *name = S_GET_NAME (fixP->fx_addsy);
23940           newval = 0xeb000000;
23941           as_warn_where (fixP->fx_file, fixP->fx_line,
23942                          _("blx to '%s' an ARM ISA state function changed to bl"),
23943                           name);
23944           md_number_to_chars (buf, newval, INSN_SIZE);
23945           temp = 3;
23946           fixP->fx_done = 1;
23947         }
23948
23949 #ifdef OBJ_ELF
23950        if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
23951          fixP->fx_r_type = BFD_RELOC_ARM_PCREL_CALL;
23952 #endif
23953
23954     arm_branch_common:
23955       /* We are going to store value (shifted right by two) in the
23956          instruction, in a 24 bit, signed field.  Bits 26 through 32 either
23957          all clear or all set and bit 0 must be clear.  For B/BL bit 1 must
23958          also be clear.  */
23959       if (value & temp)
23960         as_bad_where (fixP->fx_file, fixP->fx_line,
23961                       _("misaligned branch destination"));
23962       if ((value & (offsetT)0xfe000000) != (offsetT)0
23963           && (value & (offsetT)0xfe000000) != (offsetT)0xfe000000)
23964         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
23965
23966       if (fixP->fx_done || !seg->use_rela_p)
23967         {
23968           newval = md_chars_to_number (buf, INSN_SIZE);
23969           newval |= (value >> 2) & 0x00ffffff;
23970           /* Set the H bit on BLX instructions.  */
23971           if (temp == 1)
23972             {
23973               if (value & 2)
23974                 newval |= 0x01000000;
23975               else
23976                 newval &= ~0x01000000;
23977             }
23978           md_number_to_chars (buf, newval, INSN_SIZE);
23979         }
23980       break;
23981
23982     case BFD_RELOC_THUMB_PCREL_BRANCH7: /* CBZ */
23983       /* CBZ can only branch forward.  */
23984
23985       /* Attempts to use CBZ to branch to the next instruction
23986          (which, strictly speaking, are prohibited) will be turned into
23987          no-ops.
23988
23989          FIXME: It may be better to remove the instruction completely and
23990          perform relaxation.  */
23991       if (value == -2)
23992         {
23993           newval = md_chars_to_number (buf, THUMB_SIZE);
23994           newval = 0xbf00; /* NOP encoding T1 */
23995           md_number_to_chars (buf, newval, THUMB_SIZE);
23996         }
23997       else
23998         {
23999           if (value & ~0x7e)
24000             as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
24001
24002           if (fixP->fx_done || !seg->use_rela_p)
24003             {
24004               newval = md_chars_to_number (buf, THUMB_SIZE);
24005               newval |= ((value & 0x3e) << 2) | ((value & 0x40) << 3);
24006               md_number_to_chars (buf, newval, THUMB_SIZE);
24007             }
24008         }
24009       break;
24010
24011     case BFD_RELOC_THUMB_PCREL_BRANCH9: /* Conditional branch.  */
24012       if ((value & ~0xff) && ((value & ~0xff) != ~0xff))
24013         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
24014
24015       if (fixP->fx_done || !seg->use_rela_p)
24016         {
24017           newval = md_chars_to_number (buf, THUMB_SIZE);
24018           newval |= (value & 0x1ff) >> 1;
24019           md_number_to_chars (buf, newval, THUMB_SIZE);
24020         }
24021       break;
24022
24023     case BFD_RELOC_THUMB_PCREL_BRANCH12: /* Unconditional branch.  */
24024       if ((value & ~0x7ff) && ((value & ~0x7ff) != ~0x7ff))
24025         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
24026
24027       if (fixP->fx_done || !seg->use_rela_p)
24028         {
24029           newval = md_chars_to_number (buf, THUMB_SIZE);
24030           newval |= (value & 0xfff) >> 1;
24031           md_number_to_chars (buf, newval, THUMB_SIZE);
24032         }
24033       break;
24034
24035     case BFD_RELOC_THUMB_PCREL_BRANCH20:
24036       if (fixP->fx_addsy
24037           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
24038           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
24039           && ARM_IS_FUNC (fixP->fx_addsy)
24040           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
24041         {
24042           /* Force a relocation for a branch 20 bits wide.  */
24043           fixP->fx_done = 0;
24044         }
24045       if ((value & ~0x1fffff) && ((value & ~0x0fffff) != ~0x0fffff))
24046         as_bad_where (fixP->fx_file, fixP->fx_line,
24047                       _("conditional branch out of range"));
24048
24049       if (fixP->fx_done || !seg->use_rela_p)
24050         {
24051           offsetT newval2;
24052           addressT S, J1, J2, lo, hi;
24053
24054           S  = (value & 0x00100000) >> 20;
24055           J2 = (value & 0x00080000) >> 19;
24056           J1 = (value & 0x00040000) >> 18;
24057           hi = (value & 0x0003f000) >> 12;
24058           lo = (value & 0x00000ffe) >> 1;
24059
24060           newval   = md_chars_to_number (buf, THUMB_SIZE);
24061           newval2  = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
24062           newval  |= (S << 10) | hi;
24063           newval2 |= (J1 << 13) | (J2 << 11) | lo;
24064           md_number_to_chars (buf, newval, THUMB_SIZE);
24065           md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
24066         }
24067       break;
24068
24069     case BFD_RELOC_THUMB_PCREL_BLX:
24070       /* If there is a blx from a thumb state function to
24071          another thumb function flip this to a bl and warn
24072          about it.  */
24073
24074       if (fixP->fx_addsy
24075           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
24076           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
24077           && THUMB_IS_FUNC (fixP->fx_addsy))
24078         {
24079           const char *name = S_GET_NAME (fixP->fx_addsy);
24080           as_warn_where (fixP->fx_file, fixP->fx_line,
24081                          _("blx to Thumb func '%s' from Thumb ISA state changed to bl"),
24082                          name);
24083           newval = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
24084           newval = newval | 0x1000;
24085           md_number_to_chars (buf+THUMB_SIZE, newval, THUMB_SIZE);
24086           fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BRANCH23;
24087           fixP->fx_done = 1;
24088         }
24089
24090
24091       goto thumb_bl_common;
24092
24093     case BFD_RELOC_THUMB_PCREL_BRANCH23:
24094       /* A bl from Thumb state ISA to an internal ARM state function
24095          is converted to a blx.  */
24096       if (fixP->fx_addsy
24097           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
24098           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
24099           && ARM_IS_FUNC (fixP->fx_addsy)
24100           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
24101         {
24102           newval = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
24103           newval = newval & ~0x1000;
24104           md_number_to_chars (buf+THUMB_SIZE, newval, THUMB_SIZE);
24105           fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BLX;
24106           fixP->fx_done = 1;
24107         }
24108
24109     thumb_bl_common:
24110
24111       if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX)
24112         /* For a BLX instruction, make sure that the relocation is rounded up
24113            to a word boundary.  This follows the semantics of the instruction
24114            which specifies that bit 1 of the target address will come from bit
24115            1 of the base address.  */
24116         value = (value + 3) & ~ 3;
24117
24118 #ifdef OBJ_ELF
24119        if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4
24120            && fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX)
24121          fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BRANCH23;
24122 #endif
24123
24124       if ((value & ~0x3fffff) && ((value & ~0x3fffff) != ~0x3fffff))
24125         {
24126           if (!(ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6t2)))
24127             as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
24128           else if ((value & ~0x1ffffff)
24129                    && ((value & ~0x1ffffff) != ~0x1ffffff))
24130             as_bad_where (fixP->fx_file, fixP->fx_line,
24131                           _("Thumb2 branch out of range"));
24132         }
24133
24134       if (fixP->fx_done || !seg->use_rela_p)
24135         encode_thumb2_b_bl_offset (buf, value);
24136
24137       break;
24138
24139     case BFD_RELOC_THUMB_PCREL_BRANCH25:
24140       if ((value & ~0x0ffffff) && ((value & ~0x0ffffff) != ~0x0ffffff))
24141         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
24142
24143       if (fixP->fx_done || !seg->use_rela_p)
24144           encode_thumb2_b_bl_offset (buf, value);
24145
24146       break;
24147
24148     case BFD_RELOC_8:
24149       if (fixP->fx_done || !seg->use_rela_p)
24150         *buf = value;
24151       break;
24152
24153     case BFD_RELOC_16:
24154       if (fixP->fx_done || !seg->use_rela_p)
24155         md_number_to_chars (buf, value, 2);
24156       break;
24157
24158 #ifdef OBJ_ELF
24159     case BFD_RELOC_ARM_TLS_CALL:
24160     case BFD_RELOC_ARM_THM_TLS_CALL:
24161     case BFD_RELOC_ARM_TLS_DESCSEQ:
24162     case BFD_RELOC_ARM_THM_TLS_DESCSEQ:
24163     case BFD_RELOC_ARM_TLS_GOTDESC:
24164     case BFD_RELOC_ARM_TLS_GD32:
24165     case BFD_RELOC_ARM_TLS_LE32:
24166     case BFD_RELOC_ARM_TLS_IE32:
24167     case BFD_RELOC_ARM_TLS_LDM32:
24168     case BFD_RELOC_ARM_TLS_LDO32:
24169       S_SET_THREAD_LOCAL (fixP->fx_addsy);
24170       break;
24171
24172       /* Same handling as above, but with the arm_fdpic guard.  */
24173     case BFD_RELOC_ARM_TLS_GD32_FDPIC:
24174     case BFD_RELOC_ARM_TLS_IE32_FDPIC:
24175     case BFD_RELOC_ARM_TLS_LDM32_FDPIC:
24176       if (arm_fdpic)
24177         {
24178           S_SET_THREAD_LOCAL (fixP->fx_addsy);
24179         }
24180       else
24181         {
24182           as_bad_where (fixP->fx_file, fixP->fx_line,
24183                         _("Relocation supported only in FDPIC mode"));
24184         }
24185       break;
24186
24187     case BFD_RELOC_ARM_GOT32:
24188     case BFD_RELOC_ARM_GOTOFF:
24189       break;
24190
24191     case BFD_RELOC_ARM_GOT_PREL:
24192       if (fixP->fx_done || !seg->use_rela_p)
24193         md_number_to_chars (buf, value, 4);
24194       break;
24195
24196     case BFD_RELOC_ARM_TARGET2:
24197       /* TARGET2 is not partial-inplace, so we need to write the
24198          addend here for REL targets, because it won't be written out
24199          during reloc processing later.  */
24200       if (fixP->fx_done || !seg->use_rela_p)
24201         md_number_to_chars (buf, fixP->fx_offset, 4);
24202       break;
24203
24204       /* Relocations for FDPIC.  */
24205     case BFD_RELOC_ARM_GOTFUNCDESC:
24206     case BFD_RELOC_ARM_GOTOFFFUNCDESC:
24207     case BFD_RELOC_ARM_FUNCDESC:
24208       if (arm_fdpic)
24209         {
24210           if (fixP->fx_done || !seg->use_rela_p)
24211             md_number_to_chars (buf, 0, 4);
24212         }
24213       else
24214         {
24215           as_bad_where (fixP->fx_file, fixP->fx_line,
24216                         _("Relocation supported only in FDPIC mode"));
24217       }
24218       break;
24219 #endif
24220
24221     case BFD_RELOC_RVA:
24222     case BFD_RELOC_32:
24223     case BFD_RELOC_ARM_TARGET1:
24224     case BFD_RELOC_ARM_ROSEGREL32:
24225     case BFD_RELOC_ARM_SBREL32:
24226     case BFD_RELOC_32_PCREL:
24227 #ifdef TE_PE
24228     case BFD_RELOC_32_SECREL:
24229 #endif
24230       if (fixP->fx_done || !seg->use_rela_p)
24231 #ifdef TE_WINCE
24232         /* For WinCE we only do this for pcrel fixups.  */
24233         if (fixP->fx_done || fixP->fx_pcrel)
24234 #endif
24235           md_number_to_chars (buf, value, 4);
24236       break;
24237
24238 #ifdef OBJ_ELF
24239     case BFD_RELOC_ARM_PREL31:
24240       if (fixP->fx_done || !seg->use_rela_p)
24241         {
24242           newval = md_chars_to_number (buf, 4) & 0x80000000;
24243           if ((value ^ (value >> 1)) & 0x40000000)
24244             {
24245               as_bad_where (fixP->fx_file, fixP->fx_line,
24246                             _("rel31 relocation overflow"));
24247             }
24248           newval |= value & 0x7fffffff;
24249           md_number_to_chars (buf, newval, 4);
24250         }
24251       break;
24252 #endif
24253
24254     case BFD_RELOC_ARM_CP_OFF_IMM:
24255     case BFD_RELOC_ARM_T32_CP_OFF_IMM:
24256       if (fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM)
24257         newval = md_chars_to_number (buf, INSN_SIZE);
24258       else
24259         newval = get_thumb32_insn (buf);
24260       if ((newval & 0x0f200f00) == 0x0d000900)
24261         {
24262           /* This is a fp16 vstr/vldr.  The immediate offset in the mnemonic
24263              has permitted values that are multiples of 2, in the range 0
24264              to 510.  */
24265           if (value < -510 || value > 510 || (value & 1))
24266             as_bad_where (fixP->fx_file, fixP->fx_line,
24267                           _("co-processor offset out of range"));
24268         }
24269       else if (value < -1023 || value > 1023 || (value & 3))
24270         as_bad_where (fixP->fx_file, fixP->fx_line,
24271                       _("co-processor offset out of range"));
24272     cp_off_common:
24273       sign = value > 0;
24274       if (value < 0)
24275         value = -value;
24276       if (fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
24277           || fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2)
24278         newval = md_chars_to_number (buf, INSN_SIZE);
24279       else
24280         newval = get_thumb32_insn (buf);
24281       if (value == 0)
24282         newval &= 0xffffff00;
24283       else
24284         {
24285           newval &= 0xff7fff00;
24286           if ((newval & 0x0f200f00) == 0x0d000900)
24287             {
24288               /* This is a fp16 vstr/vldr.
24289
24290                  It requires the immediate offset in the instruction is shifted
24291                  left by 1 to be a half-word offset.
24292
24293                  Here, left shift by 1 first, and later right shift by 2
24294                  should get the right offset.  */
24295               value <<= 1;
24296             }
24297           newval |= (value >> 2) | (sign ? INDEX_UP : 0);
24298         }
24299       if (fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
24300           || fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2)
24301         md_number_to_chars (buf, newval, INSN_SIZE);
24302       else
24303         put_thumb32_insn (buf, newval);
24304       break;
24305
24306     case BFD_RELOC_ARM_CP_OFF_IMM_S2:
24307     case BFD_RELOC_ARM_T32_CP_OFF_IMM_S2:
24308       if (value < -255 || value > 255)
24309         as_bad_where (fixP->fx_file, fixP->fx_line,
24310                       _("co-processor offset out of range"));
24311       value *= 4;
24312       goto cp_off_common;
24313
24314     case BFD_RELOC_ARM_THUMB_OFFSET:
24315       newval = md_chars_to_number (buf, THUMB_SIZE);
24316       /* Exactly what ranges, and where the offset is inserted depends
24317          on the type of instruction, we can establish this from the
24318          top 4 bits.  */
24319       switch (newval >> 12)
24320         {
24321         case 4: /* PC load.  */
24322           /* Thumb PC loads are somewhat odd, bit 1 of the PC is
24323              forced to zero for these loads; md_pcrel_from has already
24324              compensated for this.  */
24325           if (value & 3)
24326             as_bad_where (fixP->fx_file, fixP->fx_line,
24327                           _("invalid offset, target not word aligned (0x%08lX)"),
24328                           (((unsigned long) fixP->fx_frag->fr_address
24329                             + (unsigned long) fixP->fx_where) & ~3)
24330                           + (unsigned long) value);
24331
24332           if (value & ~0x3fc)
24333             as_bad_where (fixP->fx_file, fixP->fx_line,
24334                           _("invalid offset, value too big (0x%08lX)"),
24335                           (long) value);
24336
24337           newval |= value >> 2;
24338           break;
24339
24340         case 9: /* SP load/store.  */
24341           if (value & ~0x3fc)
24342             as_bad_where (fixP->fx_file, fixP->fx_line,
24343                           _("invalid offset, value too big (0x%08lX)"),
24344                           (long) value);
24345           newval |= value >> 2;
24346           break;
24347
24348         case 6: /* Word load/store.  */
24349           if (value & ~0x7c)
24350             as_bad_where (fixP->fx_file, fixP->fx_line,
24351                           _("invalid offset, value too big (0x%08lX)"),
24352                           (long) value);
24353           newval |= value << 4; /* 6 - 2.  */
24354           break;
24355
24356         case 7: /* Byte load/store.  */
24357           if (value & ~0x1f)
24358             as_bad_where (fixP->fx_file, fixP->fx_line,
24359                           _("invalid offset, value too big (0x%08lX)"),
24360                           (long) value);
24361           newval |= value << 6;
24362           break;
24363
24364         case 8: /* Halfword load/store.  */
24365           if (value & ~0x3e)
24366             as_bad_where (fixP->fx_file, fixP->fx_line,
24367                           _("invalid offset, value too big (0x%08lX)"),
24368                           (long) value);
24369           newval |= value << 5; /* 6 - 1.  */
24370           break;
24371
24372         default:
24373           as_bad_where (fixP->fx_file, fixP->fx_line,
24374                         "Unable to process relocation for thumb opcode: %lx",
24375                         (unsigned long) newval);
24376           break;
24377         }
24378       md_number_to_chars (buf, newval, THUMB_SIZE);
24379       break;
24380
24381     case BFD_RELOC_ARM_THUMB_ADD:
24382       /* This is a complicated relocation, since we use it for all of
24383          the following immediate relocations:
24384
24385             3bit ADD/SUB
24386             8bit ADD/SUB
24387             9bit ADD/SUB SP word-aligned
24388            10bit ADD PC/SP word-aligned
24389
24390          The type of instruction being processed is encoded in the
24391          instruction field:
24392
24393            0x8000  SUB
24394            0x00F0  Rd
24395            0x000F  Rs
24396       */
24397       newval = md_chars_to_number (buf, THUMB_SIZE);
24398       {
24399         int rd = (newval >> 4) & 0xf;
24400         int rs = newval & 0xf;
24401         int subtract = !!(newval & 0x8000);
24402
24403         /* Check for HI regs, only very restricted cases allowed:
24404            Adjusting SP, and using PC or SP to get an address.  */
24405         if ((rd > 7 && (rd != REG_SP || rs != REG_SP))
24406             || (rs > 7 && rs != REG_SP && rs != REG_PC))
24407           as_bad_where (fixP->fx_file, fixP->fx_line,
24408                         _("invalid Hi register with immediate"));
24409
24410         /* If value is negative, choose the opposite instruction.  */
24411         if (value < 0)
24412           {
24413             value = -value;
24414             subtract = !subtract;
24415             if (value < 0)
24416               as_bad_where (fixP->fx_file, fixP->fx_line,
24417                             _("immediate value out of range"));
24418           }
24419
24420         if (rd == REG_SP)
24421           {
24422             if (value & ~0x1fc)
24423               as_bad_where (fixP->fx_file, fixP->fx_line,
24424                             _("invalid immediate for stack address calculation"));
24425             newval = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
24426             newval |= value >> 2;
24427           }
24428         else if (rs == REG_PC || rs == REG_SP)
24429           {
24430             /* PR gas/18541.  If the addition is for a defined symbol
24431                within range of an ADR instruction then accept it.  */
24432             if (subtract
24433                 && value == 4
24434                 && fixP->fx_addsy != NULL)
24435               {
24436                 subtract = 0;
24437
24438                 if (! S_IS_DEFINED (fixP->fx_addsy)
24439                     || S_GET_SEGMENT (fixP->fx_addsy) != seg
24440                     || S_IS_WEAK (fixP->fx_addsy))
24441                   {
24442                     as_bad_where (fixP->fx_file, fixP->fx_line,
24443                                   _("address calculation needs a strongly defined nearby symbol"));
24444                   }
24445                 else
24446                   {
24447                     offsetT v = fixP->fx_where + fixP->fx_frag->fr_address;
24448
24449                     /* Round up to the next 4-byte boundary.  */
24450                     if (v & 3)
24451                       v = (v + 3) & ~ 3;
24452                     else
24453                       v += 4;
24454                     v = S_GET_VALUE (fixP->fx_addsy) - v;
24455
24456                     if (v & ~0x3fc)
24457                       {
24458                         as_bad_where (fixP->fx_file, fixP->fx_line,
24459                                       _("symbol too far away"));
24460                       }
24461                     else
24462                       {
24463                         fixP->fx_done = 1;
24464                         value = v;
24465                       }
24466                   }
24467               }
24468
24469             if (subtract || value & ~0x3fc)
24470               as_bad_where (fixP->fx_file, fixP->fx_line,
24471                             _("invalid immediate for address calculation (value = 0x%08lX)"),
24472                             (unsigned long) (subtract ? - value : value));
24473             newval = (rs == REG_PC ? T_OPCODE_ADD_PC : T_OPCODE_ADD_SP);
24474             newval |= rd << 8;
24475             newval |= value >> 2;
24476           }
24477         else if (rs == rd)
24478           {
24479             if (value & ~0xff)
24480               as_bad_where (fixP->fx_file, fixP->fx_line,
24481                             _("immediate value out of range"));
24482             newval = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
24483             newval |= (rd << 8) | value;
24484           }
24485         else
24486           {
24487             if (value & ~0x7)
24488               as_bad_where (fixP->fx_file, fixP->fx_line,
24489                             _("immediate value out of range"));
24490             newval = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
24491             newval |= rd | (rs << 3) | (value << 6);
24492           }
24493       }
24494       md_number_to_chars (buf, newval, THUMB_SIZE);
24495       break;
24496
24497     case BFD_RELOC_ARM_THUMB_IMM:
24498       newval = md_chars_to_number (buf, THUMB_SIZE);
24499       if (value < 0 || value > 255)
24500         as_bad_where (fixP->fx_file, fixP->fx_line,
24501                       _("invalid immediate: %ld is out of range"),
24502                       (long) value);
24503       newval |= value;
24504       md_number_to_chars (buf, newval, THUMB_SIZE);
24505       break;
24506
24507     case BFD_RELOC_ARM_THUMB_SHIFT:
24508       /* 5bit shift value (0..32).  LSL cannot take 32.  */
24509       newval = md_chars_to_number (buf, THUMB_SIZE) & 0xf83f;
24510       temp = newval & 0xf800;
24511       if (value < 0 || value > 32 || (value == 32 && temp == T_OPCODE_LSL_I))
24512         as_bad_where (fixP->fx_file, fixP->fx_line,
24513                       _("invalid shift value: %ld"), (long) value);
24514       /* Shifts of zero must be encoded as LSL.  */
24515       if (value == 0)
24516         newval = (newval & 0x003f) | T_OPCODE_LSL_I;
24517       /* Shifts of 32 are encoded as zero.  */
24518       else if (value == 32)
24519         value = 0;
24520       newval |= value << 6;
24521       md_number_to_chars (buf, newval, THUMB_SIZE);
24522       break;
24523
24524     case BFD_RELOC_VTABLE_INHERIT:
24525     case BFD_RELOC_VTABLE_ENTRY:
24526       fixP->fx_done = 0;
24527       return;
24528
24529     case BFD_RELOC_ARM_MOVW:
24530     case BFD_RELOC_ARM_MOVT:
24531     case BFD_RELOC_ARM_THUMB_MOVW:
24532     case BFD_RELOC_ARM_THUMB_MOVT:
24533       if (fixP->fx_done || !seg->use_rela_p)
24534         {
24535           /* REL format relocations are limited to a 16-bit addend.  */
24536           if (!fixP->fx_done)
24537             {
24538               if (value < -0x8000 || value > 0x7fff)
24539                   as_bad_where (fixP->fx_file, fixP->fx_line,
24540                                 _("offset out of range"));
24541             }
24542           else if (fixP->fx_r_type == BFD_RELOC_ARM_MOVT
24543                    || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT)
24544             {
24545               value >>= 16;
24546             }
24547
24548           if (fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW
24549               || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT)
24550             {
24551               newval = get_thumb32_insn (buf);
24552               newval &= 0xfbf08f00;
24553               newval |= (value & 0xf000) << 4;
24554               newval |= (value & 0x0800) << 15;
24555               newval |= (value & 0x0700) << 4;
24556               newval |= (value & 0x00ff);
24557               put_thumb32_insn (buf, newval);
24558             }
24559           else
24560             {
24561               newval = md_chars_to_number (buf, 4);
24562               newval &= 0xfff0f000;
24563               newval |= value & 0x0fff;
24564               newval |= (value & 0xf000) << 4;
24565               md_number_to_chars (buf, newval, 4);
24566             }
24567         }
24568       return;
24569
24570    case BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC:
24571    case BFD_RELOC_ARM_THUMB_ALU_ABS_G1_NC:
24572    case BFD_RELOC_ARM_THUMB_ALU_ABS_G2_NC:
24573    case BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC:
24574       gas_assert (!fixP->fx_done);
24575       {
24576         bfd_vma insn;
24577         bfd_boolean is_mov;
24578         bfd_vma encoded_addend = value;
24579
24580         /* Check that addend can be encoded in instruction.  */
24581         if (!seg->use_rela_p && (value < 0 || value > 255))
24582           as_bad_where (fixP->fx_file, fixP->fx_line,
24583                         _("the offset 0x%08lX is not representable"),
24584                         (unsigned long) encoded_addend);
24585
24586         /* Extract the instruction.  */
24587         insn = md_chars_to_number (buf, THUMB_SIZE);
24588         is_mov = (insn & 0xf800) == 0x2000;
24589
24590         /* Encode insn.  */
24591         if (is_mov)
24592           {
24593             if (!seg->use_rela_p)
24594               insn |= encoded_addend;
24595           }
24596         else
24597           {
24598             int rd, rs;
24599
24600             /* Extract the instruction.  */
24601              /* Encoding is the following
24602                 0x8000  SUB
24603                 0x00F0  Rd
24604                 0x000F  Rs
24605              */
24606              /* The following conditions must be true :
24607                 - ADD
24608                 - Rd == Rs
24609                 - Rd <= 7
24610              */
24611             rd = (insn >> 4) & 0xf;
24612             rs = insn & 0xf;
24613             if ((insn & 0x8000) || (rd != rs) || rd > 7)
24614               as_bad_where (fixP->fx_file, fixP->fx_line,
24615                         _("Unable to process relocation for thumb opcode: %lx"),
24616                         (unsigned long) insn);
24617
24618             /* Encode as ADD immediate8 thumb 1 code.  */
24619             insn = 0x3000 | (rd << 8);
24620
24621             /* Place the encoded addend into the first 8 bits of the
24622                instruction.  */
24623             if (!seg->use_rela_p)
24624               insn |= encoded_addend;
24625           }
24626
24627         /* Update the instruction.  */
24628         md_number_to_chars (buf, insn, THUMB_SIZE);
24629       }
24630       break;
24631
24632    case BFD_RELOC_ARM_ALU_PC_G0_NC:
24633    case BFD_RELOC_ARM_ALU_PC_G0:
24634    case BFD_RELOC_ARM_ALU_PC_G1_NC:
24635    case BFD_RELOC_ARM_ALU_PC_G1:
24636    case BFD_RELOC_ARM_ALU_PC_G2:
24637    case BFD_RELOC_ARM_ALU_SB_G0_NC:
24638    case BFD_RELOC_ARM_ALU_SB_G0:
24639    case BFD_RELOC_ARM_ALU_SB_G1_NC:
24640    case BFD_RELOC_ARM_ALU_SB_G1:
24641    case BFD_RELOC_ARM_ALU_SB_G2:
24642      gas_assert (!fixP->fx_done);
24643      if (!seg->use_rela_p)
24644        {
24645          bfd_vma insn;
24646          bfd_vma encoded_addend;
24647          bfd_vma addend_abs = llabs (value);
24648
24649          /* Check that the absolute value of the addend can be
24650             expressed as an 8-bit constant plus a rotation.  */
24651          encoded_addend = encode_arm_immediate (addend_abs);
24652          if (encoded_addend == (unsigned int) FAIL)
24653            as_bad_where (fixP->fx_file, fixP->fx_line,
24654                          _("the offset 0x%08lX is not representable"),
24655                          (unsigned long) addend_abs);
24656
24657          /* Extract the instruction.  */
24658          insn = md_chars_to_number (buf, INSN_SIZE);
24659
24660          /* If the addend is positive, use an ADD instruction.
24661             Otherwise use a SUB.  Take care not to destroy the S bit.  */
24662          insn &= 0xff1fffff;
24663          if (value < 0)
24664            insn |= 1 << 22;
24665          else
24666            insn |= 1 << 23;
24667
24668          /* Place the encoded addend into the first 12 bits of the
24669             instruction.  */
24670          insn &= 0xfffff000;
24671          insn |= encoded_addend;
24672
24673          /* Update the instruction.  */
24674          md_number_to_chars (buf, insn, INSN_SIZE);
24675        }
24676      break;
24677
24678     case BFD_RELOC_ARM_LDR_PC_G0:
24679     case BFD_RELOC_ARM_LDR_PC_G1:
24680     case BFD_RELOC_ARM_LDR_PC_G2:
24681     case BFD_RELOC_ARM_LDR_SB_G0:
24682     case BFD_RELOC_ARM_LDR_SB_G1:
24683     case BFD_RELOC_ARM_LDR_SB_G2:
24684       gas_assert (!fixP->fx_done);
24685       if (!seg->use_rela_p)
24686         {
24687           bfd_vma insn;
24688           bfd_vma addend_abs = llabs (value);
24689
24690           /* Check that the absolute value of the addend can be
24691              encoded in 12 bits.  */
24692           if (addend_abs >= 0x1000)
24693             as_bad_where (fixP->fx_file, fixP->fx_line,
24694                           _("bad offset 0x%08lX (only 12 bits available for the magnitude)"),
24695                           (unsigned long) addend_abs);
24696
24697           /* Extract the instruction.  */
24698           insn = md_chars_to_number (buf, INSN_SIZE);
24699
24700           /* If the addend is negative, clear bit 23 of the instruction.
24701              Otherwise set it.  */
24702           if (value < 0)
24703             insn &= ~(1 << 23);
24704           else
24705             insn |= 1 << 23;
24706
24707           /* Place the absolute value of the addend into the first 12 bits
24708              of the instruction.  */
24709           insn &= 0xfffff000;
24710           insn |= addend_abs;
24711
24712           /* Update the instruction.  */
24713           md_number_to_chars (buf, insn, INSN_SIZE);
24714         }
24715       break;
24716
24717     case BFD_RELOC_ARM_LDRS_PC_G0:
24718     case BFD_RELOC_ARM_LDRS_PC_G1:
24719     case BFD_RELOC_ARM_LDRS_PC_G2:
24720     case BFD_RELOC_ARM_LDRS_SB_G0:
24721     case BFD_RELOC_ARM_LDRS_SB_G1:
24722     case BFD_RELOC_ARM_LDRS_SB_G2:
24723       gas_assert (!fixP->fx_done);
24724       if (!seg->use_rela_p)
24725         {
24726           bfd_vma insn;
24727           bfd_vma addend_abs = llabs (value);
24728
24729           /* Check that the absolute value of the addend can be
24730              encoded in 8 bits.  */
24731           if (addend_abs >= 0x100)
24732             as_bad_where (fixP->fx_file, fixP->fx_line,
24733                           _("bad offset 0x%08lX (only 8 bits available for the magnitude)"),
24734                           (unsigned long) addend_abs);
24735
24736           /* Extract the instruction.  */
24737           insn = md_chars_to_number (buf, INSN_SIZE);
24738
24739           /* If the addend is negative, clear bit 23 of the instruction.
24740              Otherwise set it.  */
24741           if (value < 0)
24742             insn &= ~(1 << 23);
24743           else
24744             insn |= 1 << 23;
24745
24746           /* Place the first four bits of the absolute value of the addend
24747              into the first 4 bits of the instruction, and the remaining
24748              four into bits 8 .. 11.  */
24749           insn &= 0xfffff0f0;
24750           insn |= (addend_abs & 0xf) | ((addend_abs & 0xf0) << 4);
24751
24752           /* Update the instruction.  */
24753           md_number_to_chars (buf, insn, INSN_SIZE);
24754         }
24755       break;
24756
24757     case BFD_RELOC_ARM_LDC_PC_G0:
24758     case BFD_RELOC_ARM_LDC_PC_G1:
24759     case BFD_RELOC_ARM_LDC_PC_G2:
24760     case BFD_RELOC_ARM_LDC_SB_G0:
24761     case BFD_RELOC_ARM_LDC_SB_G1:
24762     case BFD_RELOC_ARM_LDC_SB_G2:
24763       gas_assert (!fixP->fx_done);
24764       if (!seg->use_rela_p)
24765         {
24766           bfd_vma insn;
24767           bfd_vma addend_abs = llabs (value);
24768
24769           /* Check that the absolute value of the addend is a multiple of
24770              four and, when divided by four, fits in 8 bits.  */
24771           if (addend_abs & 0x3)
24772             as_bad_where (fixP->fx_file, fixP->fx_line,
24773                           _("bad offset 0x%08lX (must be word-aligned)"),
24774                           (unsigned long) addend_abs);
24775
24776           if ((addend_abs >> 2) > 0xff)
24777             as_bad_where (fixP->fx_file, fixP->fx_line,
24778                           _("bad offset 0x%08lX (must be an 8-bit number of words)"),
24779                           (unsigned long) addend_abs);
24780
24781           /* Extract the instruction.  */
24782           insn = md_chars_to_number (buf, INSN_SIZE);
24783
24784           /* If the addend is negative, clear bit 23 of the instruction.
24785              Otherwise set it.  */
24786           if (value < 0)
24787             insn &= ~(1 << 23);
24788           else
24789             insn |= 1 << 23;
24790
24791           /* Place the addend (divided by four) into the first eight
24792              bits of the instruction.  */
24793           insn &= 0xfffffff0;
24794           insn |= addend_abs >> 2;
24795
24796           /* Update the instruction.  */
24797           md_number_to_chars (buf, insn, INSN_SIZE);
24798         }
24799       break;
24800
24801     case BFD_RELOC_THUMB_PCREL_BRANCH5:
24802       if (fixP->fx_addsy
24803           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
24804           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
24805           && ARM_IS_FUNC (fixP->fx_addsy)
24806           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v8_1m_main))
24807         {
24808           /* Force a relocation for a branch 5 bits wide.  */
24809           fixP->fx_done = 0;
24810         }
24811       if (v8_1_branch_value_check (value, 5, FALSE) == FAIL)
24812         as_bad_where (fixP->fx_file, fixP->fx_line,
24813                       BAD_BRANCH_OFF);
24814
24815       if (fixP->fx_done || !seg->use_rela_p)
24816         {
24817           addressT boff = value >> 1;
24818
24819           newval  = md_chars_to_number (buf, THUMB_SIZE);
24820           newval |= (boff << 7);
24821           md_number_to_chars (buf, newval, THUMB_SIZE);
24822         }
24823       break;
24824
24825     case BFD_RELOC_ARM_THUMB_BF17:
24826       if (fixP->fx_addsy
24827           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
24828           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
24829           && ARM_IS_FUNC (fixP->fx_addsy)
24830           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v8_1m_main))
24831         {
24832           /* Force a relocation for a branch 17 bits wide.  */
24833           fixP->fx_done = 0;
24834         }
24835
24836       if (v8_1_branch_value_check (value, 17, TRUE) == FAIL)
24837         as_bad_where (fixP->fx_file, fixP->fx_line,
24838                       BAD_BRANCH_OFF);
24839
24840       if (fixP->fx_done || !seg->use_rela_p)
24841         {
24842           offsetT newval2;
24843           addressT immA, immB, immC;
24844
24845           immA = (value & 0x0001f000) >> 12;
24846           immB = (value & 0x00000ffc) >> 2;
24847           immC = (value & 0x00000002) >> 1;
24848
24849           newval   = md_chars_to_number (buf, THUMB_SIZE);
24850           newval2  = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
24851           newval  |= immA;
24852           newval2 |= (immC << 11) | (immB << 1);
24853           md_number_to_chars (buf, newval, THUMB_SIZE);
24854           md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
24855         }
24856       break;
24857
24858     case BFD_RELOC_ARM_THUMB_BF19:
24859       if (fixP->fx_addsy
24860           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
24861           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
24862           && ARM_IS_FUNC (fixP->fx_addsy)
24863           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v8_1m_main))
24864         {
24865           /* Force a relocation for a branch 19 bits wide.  */
24866           fixP->fx_done = 0;
24867         }
24868
24869       if (v8_1_branch_value_check (value, 19, TRUE) == FAIL)
24870         as_bad_where (fixP->fx_file, fixP->fx_line,
24871                       BAD_BRANCH_OFF);
24872
24873       if (fixP->fx_done || !seg->use_rela_p)
24874         {
24875           offsetT newval2;
24876           addressT immA, immB, immC;
24877
24878           immA = (value & 0x0007f000) >> 12;
24879           immB = (value & 0x00000ffc) >> 2;
24880           immC = (value & 0x00000002) >> 1;
24881
24882           newval   = md_chars_to_number (buf, THUMB_SIZE);
24883           newval2  = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
24884           newval  |= immA;
24885           newval2 |= (immC << 11) | (immB << 1);
24886           md_number_to_chars (buf, newval, THUMB_SIZE);
24887           md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
24888         }
24889       break;
24890
24891     case BFD_RELOC_ARM_V4BX:
24892       /* This will need to go in the object file.  */
24893       fixP->fx_done = 0;
24894       break;
24895
24896     case BFD_RELOC_UNUSED:
24897     default:
24898       as_bad_where (fixP->fx_file, fixP->fx_line,
24899                     _("bad relocation fixup type (%d)"), fixP->fx_r_type);
24900     }
24901 }
24902
24903 /* Translate internal representation of relocation info to BFD target
24904    format.  */
24905
24906 arelent *
24907 tc_gen_reloc (asection *section, fixS *fixp)
24908 {
24909   arelent * reloc;
24910   bfd_reloc_code_real_type code;
24911
24912   reloc = XNEW (arelent);
24913
24914   reloc->sym_ptr_ptr = XNEW (asymbol *);
24915   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
24916   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
24917
24918   if (fixp->fx_pcrel)
24919     {
24920       if (section->use_rela_p)
24921         fixp->fx_offset -= md_pcrel_from_section (fixp, section);
24922       else
24923         fixp->fx_offset = reloc->address;
24924     }
24925   reloc->addend = fixp->fx_offset;
24926
24927   switch (fixp->fx_r_type)
24928     {
24929     case BFD_RELOC_8:
24930       if (fixp->fx_pcrel)
24931         {
24932           code = BFD_RELOC_8_PCREL;
24933           break;
24934         }
24935       /* Fall through.  */
24936
24937     case BFD_RELOC_16:
24938       if (fixp->fx_pcrel)
24939         {
24940           code = BFD_RELOC_16_PCREL;
24941           break;
24942         }
24943       /* Fall through.  */
24944
24945     case BFD_RELOC_32:
24946       if (fixp->fx_pcrel)
24947         {
24948           code = BFD_RELOC_32_PCREL;
24949           break;
24950         }
24951       /* Fall through.  */
24952
24953     case BFD_RELOC_ARM_MOVW:
24954       if (fixp->fx_pcrel)
24955         {
24956           code = BFD_RELOC_ARM_MOVW_PCREL;
24957           break;
24958         }
24959       /* Fall through.  */
24960
24961     case BFD_RELOC_ARM_MOVT:
24962       if (fixp->fx_pcrel)
24963         {
24964           code = BFD_RELOC_ARM_MOVT_PCREL;
24965           break;
24966         }
24967       /* Fall through.  */
24968
24969     case BFD_RELOC_ARM_THUMB_MOVW:
24970       if (fixp->fx_pcrel)
24971         {
24972           code = BFD_RELOC_ARM_THUMB_MOVW_PCREL;
24973           break;
24974         }
24975       /* Fall through.  */
24976
24977     case BFD_RELOC_ARM_THUMB_MOVT:
24978       if (fixp->fx_pcrel)
24979         {
24980           code = BFD_RELOC_ARM_THUMB_MOVT_PCREL;
24981           break;
24982         }
24983       /* Fall through.  */
24984
24985     case BFD_RELOC_NONE:
24986     case BFD_RELOC_ARM_PCREL_BRANCH:
24987     case BFD_RELOC_ARM_PCREL_BLX:
24988     case BFD_RELOC_RVA:
24989     case BFD_RELOC_THUMB_PCREL_BRANCH7:
24990     case BFD_RELOC_THUMB_PCREL_BRANCH9:
24991     case BFD_RELOC_THUMB_PCREL_BRANCH12:
24992     case BFD_RELOC_THUMB_PCREL_BRANCH20:
24993     case BFD_RELOC_THUMB_PCREL_BRANCH23:
24994     case BFD_RELOC_THUMB_PCREL_BRANCH25:
24995     case BFD_RELOC_VTABLE_ENTRY:
24996     case BFD_RELOC_VTABLE_INHERIT:
24997 #ifdef TE_PE
24998     case BFD_RELOC_32_SECREL:
24999 #endif
25000       code = fixp->fx_r_type;
25001       break;
25002
25003     case BFD_RELOC_THUMB_PCREL_BLX:
25004 #ifdef OBJ_ELF
25005       if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
25006         code = BFD_RELOC_THUMB_PCREL_BRANCH23;
25007       else
25008 #endif
25009         code = BFD_RELOC_THUMB_PCREL_BLX;
25010       break;
25011
25012     case BFD_RELOC_ARM_LITERAL:
25013     case BFD_RELOC_ARM_HWLITERAL:
25014       /* If this is called then the a literal has
25015          been referenced across a section boundary.  */
25016       as_bad_where (fixp->fx_file, fixp->fx_line,
25017                     _("literal referenced across section boundary"));
25018       return NULL;
25019
25020 #ifdef OBJ_ELF
25021     case BFD_RELOC_ARM_TLS_CALL:
25022     case BFD_RELOC_ARM_THM_TLS_CALL:
25023     case BFD_RELOC_ARM_TLS_DESCSEQ:
25024     case BFD_RELOC_ARM_THM_TLS_DESCSEQ:
25025     case BFD_RELOC_ARM_GOT32:
25026     case BFD_RELOC_ARM_GOTOFF:
25027     case BFD_RELOC_ARM_GOT_PREL:
25028     case BFD_RELOC_ARM_PLT32:
25029     case BFD_RELOC_ARM_TARGET1:
25030     case BFD_RELOC_ARM_ROSEGREL32:
25031     case BFD_RELOC_ARM_SBREL32:
25032     case BFD_RELOC_ARM_PREL31:
25033     case BFD_RELOC_ARM_TARGET2:
25034     case BFD_RELOC_ARM_TLS_LDO32:
25035     case BFD_RELOC_ARM_PCREL_CALL:
25036     case BFD_RELOC_ARM_PCREL_JUMP:
25037     case BFD_RELOC_ARM_ALU_PC_G0_NC:
25038     case BFD_RELOC_ARM_ALU_PC_G0:
25039     case BFD_RELOC_ARM_ALU_PC_G1_NC:
25040     case BFD_RELOC_ARM_ALU_PC_G1:
25041     case BFD_RELOC_ARM_ALU_PC_G2:
25042     case BFD_RELOC_ARM_LDR_PC_G0:
25043     case BFD_RELOC_ARM_LDR_PC_G1:
25044     case BFD_RELOC_ARM_LDR_PC_G2:
25045     case BFD_RELOC_ARM_LDRS_PC_G0:
25046     case BFD_RELOC_ARM_LDRS_PC_G1:
25047     case BFD_RELOC_ARM_LDRS_PC_G2:
25048     case BFD_RELOC_ARM_LDC_PC_G0:
25049     case BFD_RELOC_ARM_LDC_PC_G1:
25050     case BFD_RELOC_ARM_LDC_PC_G2:
25051     case BFD_RELOC_ARM_ALU_SB_G0_NC:
25052     case BFD_RELOC_ARM_ALU_SB_G0:
25053     case BFD_RELOC_ARM_ALU_SB_G1_NC:
25054     case BFD_RELOC_ARM_ALU_SB_G1:
25055     case BFD_RELOC_ARM_ALU_SB_G2:
25056     case BFD_RELOC_ARM_LDR_SB_G0:
25057     case BFD_RELOC_ARM_LDR_SB_G1:
25058     case BFD_RELOC_ARM_LDR_SB_G2:
25059     case BFD_RELOC_ARM_LDRS_SB_G0:
25060     case BFD_RELOC_ARM_LDRS_SB_G1:
25061     case BFD_RELOC_ARM_LDRS_SB_G2:
25062     case BFD_RELOC_ARM_LDC_SB_G0:
25063     case BFD_RELOC_ARM_LDC_SB_G1:
25064     case BFD_RELOC_ARM_LDC_SB_G2:
25065     case BFD_RELOC_ARM_V4BX:
25066     case BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC:
25067     case BFD_RELOC_ARM_THUMB_ALU_ABS_G1_NC:
25068     case BFD_RELOC_ARM_THUMB_ALU_ABS_G2_NC:
25069     case BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC:
25070     case BFD_RELOC_ARM_GOTFUNCDESC:
25071     case BFD_RELOC_ARM_GOTOFFFUNCDESC:
25072     case BFD_RELOC_ARM_FUNCDESC:
25073     case BFD_RELOC_ARM_THUMB_BF17:
25074     case BFD_RELOC_ARM_THUMB_BF19:
25075       code = fixp->fx_r_type;
25076       break;
25077
25078     case BFD_RELOC_ARM_TLS_GOTDESC:
25079     case BFD_RELOC_ARM_TLS_GD32:
25080     case BFD_RELOC_ARM_TLS_GD32_FDPIC:
25081     case BFD_RELOC_ARM_TLS_LE32:
25082     case BFD_RELOC_ARM_TLS_IE32:
25083     case BFD_RELOC_ARM_TLS_IE32_FDPIC:
25084     case BFD_RELOC_ARM_TLS_LDM32:
25085     case BFD_RELOC_ARM_TLS_LDM32_FDPIC:
25086       /* BFD will include the symbol's address in the addend.
25087          But we don't want that, so subtract it out again here.  */
25088       if (!S_IS_COMMON (fixp->fx_addsy))
25089         reloc->addend -= (*reloc->sym_ptr_ptr)->value;
25090       code = fixp->fx_r_type;
25091       break;
25092 #endif
25093
25094     case BFD_RELOC_ARM_IMMEDIATE:
25095       as_bad_where (fixp->fx_file, fixp->fx_line,
25096                     _("internal relocation (type: IMMEDIATE) not fixed up"));
25097       return NULL;
25098
25099     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
25100       as_bad_where (fixp->fx_file, fixp->fx_line,
25101                     _("ADRL used for a symbol not defined in the same file"));
25102       return NULL;
25103
25104     case BFD_RELOC_THUMB_PCREL_BRANCH5:
25105       as_bad_where (fixp->fx_file, fixp->fx_line,
25106                     _("%s used for a symbol not defined in the same file"),
25107                     bfd_get_reloc_code_name (fixp->fx_r_type));
25108       return NULL;
25109
25110     case BFD_RELOC_ARM_OFFSET_IMM:
25111       if (section->use_rela_p)
25112         {
25113           code = fixp->fx_r_type;
25114           break;
25115         }
25116
25117       if (fixp->fx_addsy != NULL
25118           && !S_IS_DEFINED (fixp->fx_addsy)
25119           && S_IS_LOCAL (fixp->fx_addsy))
25120         {
25121           as_bad_where (fixp->fx_file, fixp->fx_line,
25122                         _("undefined local label `%s'"),
25123                         S_GET_NAME (fixp->fx_addsy));
25124           return NULL;
25125         }
25126
25127       as_bad_where (fixp->fx_file, fixp->fx_line,
25128                     _("internal_relocation (type: OFFSET_IMM) not fixed up"));
25129       return NULL;
25130
25131     default:
25132       {
25133         const char * type;
25134
25135         switch (fixp->fx_r_type)
25136           {
25137           case BFD_RELOC_NONE:             type = "NONE";         break;
25138           case BFD_RELOC_ARM_OFFSET_IMM8:  type = "OFFSET_IMM8";  break;
25139           case BFD_RELOC_ARM_SHIFT_IMM:    type = "SHIFT_IMM";    break;
25140           case BFD_RELOC_ARM_SMC:          type = "SMC";          break;
25141           case BFD_RELOC_ARM_SWI:          type = "SWI";          break;
25142           case BFD_RELOC_ARM_MULTI:        type = "MULTI";        break;
25143           case BFD_RELOC_ARM_CP_OFF_IMM:   type = "CP_OFF_IMM";   break;
25144           case BFD_RELOC_ARM_T32_OFFSET_IMM: type = "T32_OFFSET_IMM"; break;
25145           case BFD_RELOC_ARM_T32_CP_OFF_IMM: type = "T32_CP_OFF_IMM"; break;
25146           case BFD_RELOC_ARM_THUMB_ADD:    type = "THUMB_ADD";    break;
25147           case BFD_RELOC_ARM_THUMB_SHIFT:  type = "THUMB_SHIFT";  break;
25148           case BFD_RELOC_ARM_THUMB_IMM:    type = "THUMB_IMM";    break;
25149           case BFD_RELOC_ARM_THUMB_OFFSET: type = "THUMB_OFFSET"; break;
25150           default:                         type = _("<unknown>"); break;
25151           }
25152         as_bad_where (fixp->fx_file, fixp->fx_line,
25153                       _("cannot represent %s relocation in this object file format"),
25154                       type);
25155         return NULL;
25156       }
25157     }
25158
25159 #ifdef OBJ_ELF
25160   if ((code == BFD_RELOC_32_PCREL || code == BFD_RELOC_32)
25161       && GOT_symbol
25162       && fixp->fx_addsy == GOT_symbol)
25163     {
25164       code = BFD_RELOC_ARM_GOTPC;
25165       reloc->addend = fixp->fx_offset = reloc->address;
25166     }
25167 #endif
25168
25169   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
25170
25171   if (reloc->howto == NULL)
25172     {
25173       as_bad_where (fixp->fx_file, fixp->fx_line,
25174                     _("cannot represent %s relocation in this object file format"),
25175                     bfd_get_reloc_code_name (code));
25176       return NULL;
25177     }
25178
25179   /* HACK: Since arm ELF uses Rel instead of Rela, encode the
25180      vtable entry to be used in the relocation's section offset.  */
25181   if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
25182     reloc->address = fixp->fx_offset;
25183
25184   return reloc;
25185 }
25186
25187 /* This fix_new is called by cons via TC_CONS_FIX_NEW.  */
25188
25189 void
25190 cons_fix_new_arm (fragS *       frag,
25191                   int           where,
25192                   int           size,
25193                   expressionS * exp,
25194                   bfd_reloc_code_real_type reloc)
25195 {
25196   int pcrel = 0;
25197
25198   /* Pick a reloc.
25199      FIXME: @@ Should look at CPU word size.  */
25200   switch (size)
25201     {
25202     case 1:
25203       reloc = BFD_RELOC_8;
25204       break;
25205     case 2:
25206       reloc = BFD_RELOC_16;
25207       break;
25208     case 4:
25209     default:
25210       reloc = BFD_RELOC_32;
25211       break;
25212     case 8:
25213       reloc = BFD_RELOC_64;
25214       break;
25215     }
25216
25217 #ifdef TE_PE
25218   if (exp->X_op == O_secrel)
25219   {
25220     exp->X_op = O_symbol;
25221     reloc = BFD_RELOC_32_SECREL;
25222   }
25223 #endif
25224
25225   fix_new_exp (frag, where, size, exp, pcrel, reloc);
25226 }
25227
25228 #if defined (OBJ_COFF)
25229 void
25230 arm_validate_fix (fixS * fixP)
25231 {
25232   /* If the destination of the branch is a defined symbol which does not have
25233      the THUMB_FUNC attribute, then we must be calling a function which has
25234      the (interfacearm) attribute.  We look for the Thumb entry point to that
25235      function and change the branch to refer to that function instead.  */
25236   if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23
25237       && fixP->fx_addsy != NULL
25238       && S_IS_DEFINED (fixP->fx_addsy)
25239       && ! THUMB_IS_FUNC (fixP->fx_addsy))
25240     {
25241       fixP->fx_addsy = find_real_start (fixP->fx_addsy);
25242     }
25243 }
25244 #endif
25245
25246
25247 int
25248 arm_force_relocation (struct fix * fixp)
25249 {
25250 #if defined (OBJ_COFF) && defined (TE_PE)
25251   if (fixp->fx_r_type == BFD_RELOC_RVA)
25252     return 1;
25253 #endif
25254
25255   /* In case we have a call or a branch to a function in ARM ISA mode from
25256      a thumb function or vice-versa force the relocation. These relocations
25257      are cleared off for some cores that might have blx and simple transformations
25258      are possible.  */
25259
25260 #ifdef OBJ_ELF
25261   switch (fixp->fx_r_type)
25262     {
25263     case BFD_RELOC_ARM_PCREL_JUMP:
25264     case BFD_RELOC_ARM_PCREL_CALL:
25265     case BFD_RELOC_THUMB_PCREL_BLX:
25266       if (THUMB_IS_FUNC (fixp->fx_addsy))
25267         return 1;
25268       break;
25269
25270     case BFD_RELOC_ARM_PCREL_BLX:
25271     case BFD_RELOC_THUMB_PCREL_BRANCH25:
25272     case BFD_RELOC_THUMB_PCREL_BRANCH20:
25273     case BFD_RELOC_THUMB_PCREL_BRANCH23:
25274       if (ARM_IS_FUNC (fixp->fx_addsy))
25275         return 1;
25276       break;
25277
25278     default:
25279       break;
25280     }
25281 #endif
25282
25283   /* Resolve these relocations even if the symbol is extern or weak.
25284      Technically this is probably wrong due to symbol preemption.
25285      In practice these relocations do not have enough range to be useful
25286      at dynamic link time, and some code (e.g. in the Linux kernel)
25287      expects these references to be resolved.  */
25288   if (fixp->fx_r_type == BFD_RELOC_ARM_IMMEDIATE
25289       || fixp->fx_r_type == BFD_RELOC_ARM_OFFSET_IMM
25290       || fixp->fx_r_type == BFD_RELOC_ARM_OFFSET_IMM8
25291       || fixp->fx_r_type == BFD_RELOC_ARM_ADRL_IMMEDIATE
25292       || fixp->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
25293       || fixp->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2
25294       || fixp->fx_r_type == BFD_RELOC_ARM_THUMB_OFFSET
25295       || fixp->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM
25296       || fixp->fx_r_type == BFD_RELOC_ARM_T32_IMMEDIATE
25297       || fixp->fx_r_type == BFD_RELOC_ARM_T32_IMM12
25298       || fixp->fx_r_type == BFD_RELOC_ARM_T32_OFFSET_IMM
25299       || fixp->fx_r_type == BFD_RELOC_ARM_T32_ADD_PC12
25300       || fixp->fx_r_type == BFD_RELOC_ARM_T32_CP_OFF_IMM
25301       || fixp->fx_r_type == BFD_RELOC_ARM_T32_CP_OFF_IMM_S2)
25302     return 0;
25303
25304   /* Always leave these relocations for the linker.  */
25305   if ((fixp->fx_r_type >= BFD_RELOC_ARM_ALU_PC_G0_NC
25306        && fixp->fx_r_type <= BFD_RELOC_ARM_LDC_SB_G2)
25307       || fixp->fx_r_type == BFD_RELOC_ARM_LDR_PC_G0)
25308     return 1;
25309
25310   /* Always generate relocations against function symbols.  */
25311   if (fixp->fx_r_type == BFD_RELOC_32
25312       && fixp->fx_addsy
25313       && (symbol_get_bfdsym (fixp->fx_addsy)->flags & BSF_FUNCTION))
25314     return 1;
25315
25316   return generic_force_reloc (fixp);
25317 }
25318
25319 #if defined (OBJ_ELF) || defined (OBJ_COFF)
25320 /* Relocations against function names must be left unadjusted,
25321    so that the linker can use this information to generate interworking
25322    stubs.  The MIPS version of this function
25323    also prevents relocations that are mips-16 specific, but I do not
25324    know why it does this.
25325
25326    FIXME:
25327    There is one other problem that ought to be addressed here, but
25328    which currently is not:  Taking the address of a label (rather
25329    than a function) and then later jumping to that address.  Such
25330    addresses also ought to have their bottom bit set (assuming that
25331    they reside in Thumb code), but at the moment they will not.  */
25332
25333 bfd_boolean
25334 arm_fix_adjustable (fixS * fixP)
25335 {
25336   if (fixP->fx_addsy == NULL)
25337     return 1;
25338
25339   /* Preserve relocations against symbols with function type.  */
25340   if (symbol_get_bfdsym (fixP->fx_addsy)->flags & BSF_FUNCTION)
25341     return FALSE;
25342
25343   if (THUMB_IS_FUNC (fixP->fx_addsy)
25344       && fixP->fx_subsy == NULL)
25345     return FALSE;
25346
25347   /* We need the symbol name for the VTABLE entries.  */
25348   if (   fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
25349       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
25350     return FALSE;
25351
25352   /* Don't allow symbols to be discarded on GOT related relocs.  */
25353   if (fixP->fx_r_type == BFD_RELOC_ARM_PLT32
25354       || fixP->fx_r_type == BFD_RELOC_ARM_GOT32
25355       || fixP->fx_r_type == BFD_RELOC_ARM_GOTOFF
25356       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_GD32
25357       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_GD32_FDPIC
25358       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LE32
25359       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_IE32
25360       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_IE32_FDPIC
25361       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDM32
25362       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDM32_FDPIC
25363       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDO32
25364       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_GOTDESC
25365       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_CALL
25366       || fixP->fx_r_type == BFD_RELOC_ARM_THM_TLS_CALL
25367       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_DESCSEQ
25368       || fixP->fx_r_type == BFD_RELOC_ARM_THM_TLS_DESCSEQ
25369       || fixP->fx_r_type == BFD_RELOC_ARM_TARGET2)
25370     return FALSE;
25371
25372   /* Similarly for group relocations.  */
25373   if ((fixP->fx_r_type >= BFD_RELOC_ARM_ALU_PC_G0_NC
25374        && fixP->fx_r_type <= BFD_RELOC_ARM_LDC_SB_G2)
25375       || fixP->fx_r_type == BFD_RELOC_ARM_LDR_PC_G0)
25376     return FALSE;
25377
25378   /* MOVW/MOVT REL relocations have limited offsets, so keep the symbols.  */
25379   if (fixP->fx_r_type == BFD_RELOC_ARM_MOVW
25380       || fixP->fx_r_type == BFD_RELOC_ARM_MOVT
25381       || fixP->fx_r_type == BFD_RELOC_ARM_MOVW_PCREL
25382       || fixP->fx_r_type == BFD_RELOC_ARM_MOVT_PCREL
25383       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW
25384       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT
25385       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW_PCREL
25386       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT_PCREL)
25387     return FALSE;
25388
25389   /* BFD_RELOC_ARM_THUMB_ALU_ABS_Gx_NC relocations have VERY limited
25390      offsets, so keep these symbols.  */
25391   if (fixP->fx_r_type >= BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC
25392       && fixP->fx_r_type <= BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC)
25393     return FALSE;
25394
25395   return TRUE;
25396 }
25397 #endif /* defined (OBJ_ELF) || defined (OBJ_COFF) */
25398
25399 #ifdef OBJ_ELF
25400 const char *
25401 elf32_arm_target_format (void)
25402 {
25403 #ifdef TE_SYMBIAN
25404   return (target_big_endian
25405           ? "elf32-bigarm-symbian"
25406           : "elf32-littlearm-symbian");
25407 #elif defined (TE_VXWORKS)
25408   return (target_big_endian
25409           ? "elf32-bigarm-vxworks"
25410           : "elf32-littlearm-vxworks");
25411 #elif defined (TE_NACL)
25412   return (target_big_endian
25413           ? "elf32-bigarm-nacl"
25414           : "elf32-littlearm-nacl");
25415 #else
25416   if (arm_fdpic)
25417     {
25418       if (target_big_endian)
25419         return "elf32-bigarm-fdpic";
25420       else
25421         return "elf32-littlearm-fdpic";
25422     }
25423   else
25424     {
25425       if (target_big_endian)
25426         return "elf32-bigarm";
25427       else
25428         return "elf32-littlearm";
25429     }
25430 #endif
25431 }
25432
25433 void
25434 armelf_frob_symbol (symbolS * symp,
25435                     int *     puntp)
25436 {
25437   elf_frob_symbol (symp, puntp);
25438 }
25439 #endif
25440
25441 /* MD interface: Finalization.  */
25442
25443 void
25444 arm_cleanup (void)
25445 {
25446   literal_pool * pool;
25447
25448   /* Ensure that all the IT blocks are properly closed.  */
25449   check_it_blocks_finished ();
25450
25451   for (pool = list_of_pools; pool; pool = pool->next)
25452     {
25453       /* Put it at the end of the relevant section.  */
25454       subseg_set (pool->section, pool->sub_section);
25455 #ifdef OBJ_ELF
25456       arm_elf_change_section ();
25457 #endif
25458       s_ltorg (0);
25459     }
25460 }
25461
25462 #ifdef OBJ_ELF
25463 /* Remove any excess mapping symbols generated for alignment frags in
25464    SEC.  We may have created a mapping symbol before a zero byte
25465    alignment; remove it if there's a mapping symbol after the
25466    alignment.  */
25467 static void
25468 check_mapping_symbols (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
25469                        void *dummy ATTRIBUTE_UNUSED)
25470 {
25471   segment_info_type *seginfo = seg_info (sec);
25472   fragS *fragp;
25473
25474   if (seginfo == NULL || seginfo->frchainP == NULL)
25475     return;
25476
25477   for (fragp = seginfo->frchainP->frch_root;
25478        fragp != NULL;
25479        fragp = fragp->fr_next)
25480     {
25481       symbolS *sym = fragp->tc_frag_data.last_map;
25482       fragS *next = fragp->fr_next;
25483
25484       /* Variable-sized frags have been converted to fixed size by
25485          this point.  But if this was variable-sized to start with,
25486          there will be a fixed-size frag after it.  So don't handle
25487          next == NULL.  */
25488       if (sym == NULL || next == NULL)
25489         continue;
25490
25491       if (S_GET_VALUE (sym) < next->fr_address)
25492         /* Not at the end of this frag.  */
25493         continue;
25494       know (S_GET_VALUE (sym) == next->fr_address);
25495
25496       do
25497         {
25498           if (next->tc_frag_data.first_map != NULL)
25499             {
25500               /* Next frag starts with a mapping symbol.  Discard this
25501                  one.  */
25502               symbol_remove (sym, &symbol_rootP, &symbol_lastP);
25503               break;
25504             }
25505
25506           if (next->fr_next == NULL)
25507             {
25508               /* This mapping symbol is at the end of the section.  Discard
25509                  it.  */
25510               know (next->fr_fix == 0 && next->fr_var == 0);
25511               symbol_remove (sym, &symbol_rootP, &symbol_lastP);
25512               break;
25513             }
25514
25515           /* As long as we have empty frags without any mapping symbols,
25516              keep looking.  */
25517           /* If the next frag is non-empty and does not start with a
25518              mapping symbol, then this mapping symbol is required.  */
25519           if (next->fr_address != next->fr_next->fr_address)
25520             break;
25521
25522           next = next->fr_next;
25523         }
25524       while (next != NULL);
25525     }
25526 }
25527 #endif
25528
25529 /* Adjust the symbol table.  This marks Thumb symbols as distinct from
25530    ARM ones.  */
25531
25532 void
25533 arm_adjust_symtab (void)
25534 {
25535 #ifdef OBJ_COFF
25536   symbolS * sym;
25537
25538   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
25539     {
25540       if (ARM_IS_THUMB (sym))
25541         {
25542           if (THUMB_IS_FUNC (sym))
25543             {
25544               /* Mark the symbol as a Thumb function.  */
25545               if (   S_GET_STORAGE_CLASS (sym) == C_STAT
25546                   || S_GET_STORAGE_CLASS (sym) == C_LABEL)  /* This can happen!  */
25547                 S_SET_STORAGE_CLASS (sym, C_THUMBSTATFUNC);
25548
25549               else if (S_GET_STORAGE_CLASS (sym) == C_EXT)
25550                 S_SET_STORAGE_CLASS (sym, C_THUMBEXTFUNC);
25551               else
25552                 as_bad (_("%s: unexpected function type: %d"),
25553                         S_GET_NAME (sym), S_GET_STORAGE_CLASS (sym));
25554             }
25555           else switch (S_GET_STORAGE_CLASS (sym))
25556             {
25557             case C_EXT:
25558               S_SET_STORAGE_CLASS (sym, C_THUMBEXT);
25559               break;
25560             case C_STAT:
25561               S_SET_STORAGE_CLASS (sym, C_THUMBSTAT);
25562               break;
25563             case C_LABEL:
25564               S_SET_STORAGE_CLASS (sym, C_THUMBLABEL);
25565               break;
25566             default:
25567               /* Do nothing.  */
25568               break;
25569             }
25570         }
25571
25572       if (ARM_IS_INTERWORK (sym))
25573         coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_flags = 0xFF;
25574     }
25575 #endif
25576 #ifdef OBJ_ELF
25577   symbolS * sym;
25578   char      bind;
25579
25580   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
25581     {
25582       if (ARM_IS_THUMB (sym))
25583         {
25584           elf_symbol_type * elf_sym;
25585
25586           elf_sym = elf_symbol (symbol_get_bfdsym (sym));
25587           bind = ELF_ST_BIND (elf_sym->internal_elf_sym.st_info);
25588
25589           if (! bfd_is_arm_special_symbol_name (elf_sym->symbol.name,
25590                 BFD_ARM_SPECIAL_SYM_TYPE_ANY))
25591             {
25592               /* If it's a .thumb_func, declare it as so,
25593                  otherwise tag label as .code 16.  */
25594               if (THUMB_IS_FUNC (sym))
25595                 ARM_SET_SYM_BRANCH_TYPE (elf_sym->internal_elf_sym.st_target_internal,
25596                                          ST_BRANCH_TO_THUMB);
25597               else if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
25598                 elf_sym->internal_elf_sym.st_info =
25599                   ELF_ST_INFO (bind, STT_ARM_16BIT);
25600             }
25601         }
25602     }
25603
25604   /* Remove any overlapping mapping symbols generated by alignment frags.  */
25605   bfd_map_over_sections (stdoutput, check_mapping_symbols, (char *) 0);
25606   /* Now do generic ELF adjustments.  */
25607   elf_adjust_symtab ();
25608 #endif
25609 }
25610
25611 /* MD interface: Initialization.  */
25612
25613 static void
25614 set_constant_flonums (void)
25615 {
25616   int i;
25617
25618   for (i = 0; i < NUM_FLOAT_VALS; i++)
25619     if (atof_ieee ((char *) fp_const[i], 'x', fp_values[i]) == NULL)
25620       abort ();
25621 }
25622
25623 /* Auto-select Thumb mode if it's the only available instruction set for the
25624    given architecture.  */
25625
25626 static void
25627 autoselect_thumb_from_cpu_variant (void)
25628 {
25629   if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
25630     opcode_select (16);
25631 }
25632
25633 void
25634 md_begin (void)
25635 {
25636   unsigned mach;
25637   unsigned int i;
25638
25639   if (   (arm_ops_hsh = hash_new ()) == NULL
25640       || (arm_cond_hsh = hash_new ()) == NULL
25641       || (arm_shift_hsh = hash_new ()) == NULL
25642       || (arm_psr_hsh = hash_new ()) == NULL
25643       || (arm_v7m_psr_hsh = hash_new ()) == NULL
25644       || (arm_reg_hsh = hash_new ()) == NULL
25645       || (arm_reloc_hsh = hash_new ()) == NULL
25646       || (arm_barrier_opt_hsh = hash_new ()) == NULL)
25647     as_fatal (_("virtual memory exhausted"));
25648
25649   for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++)
25650     hash_insert (arm_ops_hsh, insns[i].template_name, (void *) (insns + i));
25651   for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++)
25652     hash_insert (arm_cond_hsh, conds[i].template_name, (void *) (conds + i));
25653   for (i = 0; i < sizeof (shift_names) / sizeof (struct asm_shift_name); i++)
25654     hash_insert (arm_shift_hsh, shift_names[i].name, (void *) (shift_names + i));
25655   for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++)
25656     hash_insert (arm_psr_hsh, psrs[i].template_name, (void *) (psrs + i));
25657   for (i = 0; i < sizeof (v7m_psrs) / sizeof (struct asm_psr); i++)
25658     hash_insert (arm_v7m_psr_hsh, v7m_psrs[i].template_name,
25659                  (void *) (v7m_psrs + i));
25660   for (i = 0; i < sizeof (reg_names) / sizeof (struct reg_entry); i++)
25661     hash_insert (arm_reg_hsh, reg_names[i].name, (void *) (reg_names + i));
25662   for (i = 0;
25663        i < sizeof (barrier_opt_names) / sizeof (struct asm_barrier_opt);
25664        i++)
25665     hash_insert (arm_barrier_opt_hsh, barrier_opt_names[i].template_name,
25666                  (void *) (barrier_opt_names + i));
25667 #ifdef OBJ_ELF
25668   for (i = 0; i < ARRAY_SIZE (reloc_names); i++)
25669     {
25670       struct reloc_entry * entry = reloc_names + i;
25671
25672       if (arm_is_eabi() && entry->reloc == BFD_RELOC_ARM_PLT32)
25673         /* This makes encode_branch() use the EABI versions of this relocation.  */
25674         entry->reloc = BFD_RELOC_UNUSED;
25675
25676       hash_insert (arm_reloc_hsh, entry->name, (void *) entry);
25677     }
25678 #endif
25679
25680   set_constant_flonums ();
25681
25682   /* Set the cpu variant based on the command-line options.  We prefer
25683      -mcpu= over -march= if both are set (as for GCC); and we prefer
25684      -mfpu= over any other way of setting the floating point unit.
25685      Use of legacy options with new options are faulted.  */
25686   if (legacy_cpu)
25687     {
25688       if (mcpu_cpu_opt || march_cpu_opt)
25689         as_bad (_("use of old and new-style options to set CPU type"));
25690
25691       selected_arch = *legacy_cpu;
25692     }
25693   else if (mcpu_cpu_opt)
25694     {
25695       selected_arch = *mcpu_cpu_opt;
25696       selected_ext = *mcpu_ext_opt;
25697     }
25698   else if (march_cpu_opt)
25699     {
25700       selected_arch = *march_cpu_opt;
25701       selected_ext = *march_ext_opt;
25702     }
25703   ARM_MERGE_FEATURE_SETS (selected_cpu, selected_arch, selected_ext);
25704
25705   if (legacy_fpu)
25706     {
25707       if (mfpu_opt)
25708         as_bad (_("use of old and new-style options to set FPU type"));
25709
25710       selected_fpu = *legacy_fpu;
25711     }
25712   else if (mfpu_opt)
25713     selected_fpu = *mfpu_opt;
25714   else
25715     {
25716 #if !(defined (EABI_DEFAULT) || defined (TE_LINUX) \
25717         || defined (TE_NetBSD) || defined (TE_VXWORKS))
25718       /* Some environments specify a default FPU.  If they don't, infer it
25719          from the processor.  */
25720       if (mcpu_fpu_opt)
25721         selected_fpu = *mcpu_fpu_opt;
25722       else if (march_fpu_opt)
25723         selected_fpu = *march_fpu_opt;
25724 #else
25725       selected_fpu = fpu_default;
25726 #endif
25727     }
25728
25729   if (ARM_FEATURE_ZERO (selected_fpu))
25730     {
25731       if (!no_cpu_selected ())
25732         selected_fpu = fpu_default;
25733       else
25734         selected_fpu = fpu_arch_fpa;
25735     }
25736
25737 #ifdef CPU_DEFAULT
25738   if (ARM_FEATURE_ZERO (selected_arch))
25739     {
25740       selected_arch = cpu_default;
25741       selected_cpu = selected_arch;
25742     }
25743   ARM_MERGE_FEATURE_SETS (cpu_variant, selected_cpu, selected_fpu);
25744 #else
25745   /*  Autodection of feature mode: allow all features in cpu_variant but leave
25746       selected_cpu unset.  It will be set in aeabi_set_public_attributes ()
25747       after all instruction have been processed and we can decide what CPU
25748       should be selected.  */
25749   if (ARM_FEATURE_ZERO (selected_arch))
25750     ARM_MERGE_FEATURE_SETS (cpu_variant, arm_arch_any, selected_fpu);
25751   else
25752     ARM_MERGE_FEATURE_SETS (cpu_variant, selected_cpu, selected_fpu);
25753 #endif
25754
25755   autoselect_thumb_from_cpu_variant ();
25756
25757   arm_arch_used = thumb_arch_used = arm_arch_none;
25758
25759 #if defined OBJ_COFF || defined OBJ_ELF
25760   {
25761     unsigned int flags = 0;
25762
25763 #if defined OBJ_ELF
25764     flags = meabi_flags;
25765
25766     switch (meabi_flags)
25767       {
25768       case EF_ARM_EABI_UNKNOWN:
25769 #endif
25770         /* Set the flags in the private structure.  */
25771         if (uses_apcs_26)      flags |= F_APCS26;
25772         if (support_interwork) flags |= F_INTERWORK;
25773         if (uses_apcs_float)   flags |= F_APCS_FLOAT;
25774         if (pic_code)          flags |= F_PIC;
25775         if (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_any_hard))
25776           flags |= F_SOFT_FLOAT;
25777
25778         switch (mfloat_abi_opt)
25779           {
25780           case ARM_FLOAT_ABI_SOFT:
25781           case ARM_FLOAT_ABI_SOFTFP:
25782             flags |= F_SOFT_FLOAT;
25783             break;
25784
25785           case ARM_FLOAT_ABI_HARD:
25786             if (flags & F_SOFT_FLOAT)
25787               as_bad (_("hard-float conflicts with specified fpu"));
25788             break;
25789           }
25790
25791         /* Using pure-endian doubles (even if soft-float).      */
25792         if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_endian_pure))
25793           flags |= F_VFP_FLOAT;
25794
25795 #if defined OBJ_ELF
25796         if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_arch_maverick))
25797             flags |= EF_ARM_MAVERICK_FLOAT;
25798         break;
25799
25800       case EF_ARM_EABI_VER4:
25801       case EF_ARM_EABI_VER5:
25802         /* No additional flags to set.  */
25803         break;
25804
25805       default:
25806         abort ();
25807       }
25808 #endif
25809     bfd_set_private_flags (stdoutput, flags);
25810
25811     /* We have run out flags in the COFF header to encode the
25812        status of ATPCS support, so instead we create a dummy,
25813        empty, debug section called .arm.atpcs.  */
25814     if (atpcs)
25815       {
25816         asection * sec;
25817
25818         sec = bfd_make_section (stdoutput, ".arm.atpcs");
25819
25820         if (sec != NULL)
25821           {
25822             bfd_set_section_flags
25823               (stdoutput, sec, SEC_READONLY | SEC_DEBUGGING /* | SEC_HAS_CONTENTS */);
25824             bfd_set_section_size (stdoutput, sec, 0);
25825             bfd_set_section_contents (stdoutput, sec, NULL, 0, 0);
25826           }
25827       }
25828   }
25829 #endif
25830
25831   /* Record the CPU type as well.  */
25832   if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt2))
25833     mach = bfd_mach_arm_iWMMXt2;
25834   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt))
25835     mach = bfd_mach_arm_iWMMXt;
25836   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_xscale))
25837     mach = bfd_mach_arm_XScale;
25838   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_maverick))
25839     mach = bfd_mach_arm_ep9312;
25840   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v5e))
25841     mach = bfd_mach_arm_5TE;
25842   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v5))
25843     {
25844       if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
25845         mach = bfd_mach_arm_5T;
25846       else
25847         mach = bfd_mach_arm_5;
25848     }
25849   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4))
25850     {
25851       if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
25852         mach = bfd_mach_arm_4T;
25853       else
25854         mach = bfd_mach_arm_4;
25855     }
25856   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v3m))
25857     mach = bfd_mach_arm_3M;
25858   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v3))
25859     mach = bfd_mach_arm_3;
25860   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v2s))
25861     mach = bfd_mach_arm_2a;
25862   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v2))
25863     mach = bfd_mach_arm_2;
25864   else
25865     mach = bfd_mach_arm_unknown;
25866
25867   bfd_set_arch_mach (stdoutput, TARGET_ARCH, mach);
25868 }
25869
25870 /* Command line processing.  */
25871
25872 /* md_parse_option
25873       Invocation line includes a switch not recognized by the base assembler.
25874       See if it's a processor-specific option.
25875
25876       This routine is somewhat complicated by the need for backwards
25877       compatibility (since older releases of gcc can't be changed).
25878       The new options try to make the interface as compatible as
25879       possible with GCC.
25880
25881       New options (supported) are:
25882
25883               -mcpu=<cpu name>           Assemble for selected processor
25884               -march=<architecture name> Assemble for selected architecture
25885               -mfpu=<fpu architecture>   Assemble for selected FPU.
25886               -EB/-mbig-endian           Big-endian
25887               -EL/-mlittle-endian        Little-endian
25888               -k                         Generate PIC code
25889               -mthumb                    Start in Thumb mode
25890               -mthumb-interwork          Code supports ARM/Thumb interworking
25891
25892               -m[no-]warn-deprecated     Warn about deprecated features
25893               -m[no-]warn-syms           Warn when symbols match instructions
25894
25895       For now we will also provide support for:
25896
25897               -mapcs-32                  32-bit Program counter
25898               -mapcs-26                  26-bit Program counter
25899               -macps-float               Floats passed in FP registers
25900               -mapcs-reentrant           Reentrant code
25901               -matpcs
25902       (sometime these will probably be replaced with -mapcs=<list of options>
25903       and -matpcs=<list of options>)
25904
25905       The remaining options are only supported for back-wards compatibility.
25906       Cpu variants, the arm part is optional:
25907               -m[arm]1                Currently not supported.
25908               -m[arm]2, -m[arm]250    Arm 2 and Arm 250 processor
25909               -m[arm]3                Arm 3 processor
25910               -m[arm]6[xx],           Arm 6 processors
25911               -m[arm]7[xx][t][[d]m]   Arm 7 processors
25912               -m[arm]8[10]            Arm 8 processors
25913               -m[arm]9[20][tdmi]      Arm 9 processors
25914               -mstrongarm[110[0]]     StrongARM processors
25915               -mxscale                XScale processors
25916               -m[arm]v[2345[t[e]]]    Arm architectures
25917               -mall                   All (except the ARM1)
25918       FP variants:
25919               -mfpa10, -mfpa11        FPA10 and 11 co-processor instructions
25920               -mfpe-old               (No float load/store multiples)
25921               -mvfpxd                 VFP Single precision
25922               -mvfp                   All VFP
25923               -mno-fpu                Disable all floating point instructions
25924
25925       The following CPU names are recognized:
25926               arm1, arm2, arm250, arm3, arm6, arm600, arm610, arm620,
25927               arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700,
25928               arm700i, arm710 arm710t, arm720, arm720t, arm740t, arm710c,
25929               arm7100, arm7500, arm7500fe, arm7tdmi, arm8, arm810, arm9,
25930               arm920, arm920t, arm940t, arm946, arm966, arm9tdmi, arm9e,
25931               arm10t arm10e, arm1020t, arm1020e, arm10200e,
25932               strongarm, strongarm110, strongarm1100, strongarm1110, xscale.
25933
25934       */
25935
25936 const char * md_shortopts = "m:k";
25937
25938 #ifdef ARM_BI_ENDIAN
25939 #define OPTION_EB (OPTION_MD_BASE + 0)
25940 #define OPTION_EL (OPTION_MD_BASE + 1)
25941 #else
25942 #if TARGET_BYTES_BIG_ENDIAN
25943 #define OPTION_EB (OPTION_MD_BASE + 0)
25944 #else
25945 #define OPTION_EL (OPTION_MD_BASE + 1)
25946 #endif
25947 #endif
25948 #define OPTION_FIX_V4BX (OPTION_MD_BASE + 2)
25949 #define OPTION_FDPIC (OPTION_MD_BASE + 3)
25950
25951 struct option md_longopts[] =
25952 {
25953 #ifdef OPTION_EB
25954   {"EB", no_argument, NULL, OPTION_EB},
25955 #endif
25956 #ifdef OPTION_EL
25957   {"EL", no_argument, NULL, OPTION_EL},
25958 #endif
25959   {"fix-v4bx", no_argument, NULL, OPTION_FIX_V4BX},
25960 #ifdef OBJ_ELF
25961   {"fdpic", no_argument, NULL, OPTION_FDPIC},
25962 #endif
25963   {NULL, no_argument, NULL, 0}
25964 };
25965
25966 size_t md_longopts_size = sizeof (md_longopts);
25967
25968 struct arm_option_table
25969 {
25970   const char *  option;         /* Option name to match.  */
25971   const char *  help;           /* Help information.  */
25972   int *         var;            /* Variable to change.  */
25973   int           value;          /* What to change it to.  */
25974   const char *  deprecated;     /* If non-null, print this message.  */
25975 };
25976
25977 struct arm_option_table arm_opts[] =
25978 {
25979   {"k",      N_("generate PIC code"),      &pic_code,    1, NULL},
25980   {"mthumb", N_("assemble Thumb code"),    &thumb_mode,  1, NULL},
25981   {"mthumb-interwork", N_("support ARM/Thumb interworking"),
25982    &support_interwork, 1, NULL},
25983   {"mapcs-32", N_("code uses 32-bit program counter"), &uses_apcs_26, 0, NULL},
25984   {"mapcs-26", N_("code uses 26-bit program counter"), &uses_apcs_26, 1, NULL},
25985   {"mapcs-float", N_("floating point args are in fp regs"), &uses_apcs_float,
25986    1, NULL},
25987   {"mapcs-reentrant", N_("re-entrant code"), &pic_code, 1, NULL},
25988   {"matpcs", N_("code is ATPCS conformant"), &atpcs, 1, NULL},
25989   {"mbig-endian", N_("assemble for big-endian"), &target_big_endian, 1, NULL},
25990   {"mlittle-endian", N_("assemble for little-endian"), &target_big_endian, 0,
25991    NULL},
25992
25993   /* These are recognized by the assembler, but have no affect on code.  */
25994   {"mapcs-frame", N_("use frame pointer"), NULL, 0, NULL},
25995   {"mapcs-stack-check", N_("use stack size checking"), NULL, 0, NULL},
25996
25997   {"mwarn-deprecated", NULL, &warn_on_deprecated, 1, NULL},
25998   {"mno-warn-deprecated", N_("do not warn on use of deprecated feature"),
25999    &warn_on_deprecated, 0, NULL},
26000   {"mwarn-syms", N_("warn about symbols that match instruction names [default]"), (int *) (& flag_warn_syms), TRUE, NULL},
26001   {"mno-warn-syms", N_("disable warnings about symobls that match instructions"), (int *) (& flag_warn_syms), FALSE, NULL},
26002   {NULL, NULL, NULL, 0, NULL}
26003 };
26004
26005 struct arm_legacy_option_table
26006 {
26007   const char *              option;             /* Option name to match.  */
26008   const arm_feature_set **  var;                /* Variable to change.  */
26009   const arm_feature_set     value;              /* What to change it to.  */
26010   const char *              deprecated;         /* If non-null, print this message.  */
26011 };
26012
26013 const struct arm_legacy_option_table arm_legacy_opts[] =
26014 {
26015   /* DON'T add any new processors to this list -- we want the whole list
26016      to go away...  Add them to the processors table instead.  */
26017   {"marm1",      &legacy_cpu, ARM_ARCH_V1,  N_("use -mcpu=arm1")},
26018   {"m1",         &legacy_cpu, ARM_ARCH_V1,  N_("use -mcpu=arm1")},
26019   {"marm2",      &legacy_cpu, ARM_ARCH_V2,  N_("use -mcpu=arm2")},
26020   {"m2",         &legacy_cpu, ARM_ARCH_V2,  N_("use -mcpu=arm2")},
26021   {"marm250",    &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm250")},
26022   {"m250",       &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm250")},
26023   {"marm3",      &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm3")},
26024   {"m3",         &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm3")},
26025   {"marm6",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm6")},
26026   {"m6",         &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm6")},
26027   {"marm600",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm600")},
26028   {"m600",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm600")},
26029   {"marm610",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm610")},
26030   {"m610",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm610")},
26031   {"marm620",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm620")},
26032   {"m620",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm620")},
26033   {"marm7",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7")},
26034   {"m7",         &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7")},
26035   {"marm70",     &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm70")},
26036   {"m70",        &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm70")},
26037   {"marm700",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700")},
26038   {"m700",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700")},
26039   {"marm700i",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700i")},
26040   {"m700i",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700i")},
26041   {"marm710",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710")},
26042   {"m710",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710")},
26043   {"marm710c",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710c")},
26044   {"m710c",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710c")},
26045   {"marm720",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm720")},
26046   {"m720",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm720")},
26047   {"marm7d",     &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7d")},
26048   {"m7d",        &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7d")},
26049   {"marm7di",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7di")},
26050   {"m7di",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7di")},
26051   {"marm7m",     &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7m")},
26052   {"m7m",        &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7m")},
26053   {"marm7dm",    &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dm")},
26054   {"m7dm",       &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dm")},
26055   {"marm7dmi",   &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dmi")},
26056   {"m7dmi",      &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dmi")},
26057   {"marm7100",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7100")},
26058   {"m7100",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7100")},
26059   {"marm7500",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500")},
26060   {"m7500",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500")},
26061   {"marm7500fe", &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500fe")},
26062   {"m7500fe",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500fe")},
26063   {"marm7t",     &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
26064   {"m7t",        &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
26065   {"marm7tdmi",  &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
26066   {"m7tdmi",     &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
26067   {"marm710t",   &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm710t")},
26068   {"m710t",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm710t")},
26069   {"marm720t",   &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm720t")},
26070   {"m720t",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm720t")},
26071   {"marm740t",   &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm740t")},
26072   {"m740t",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm740t")},
26073   {"marm8",      &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm8")},
26074   {"m8",         &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm8")},
26075   {"marm810",    &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm810")},
26076   {"m810",       &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm810")},
26077   {"marm9",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9")},
26078   {"m9",         &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9")},
26079   {"marm9tdmi",  &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9tdmi")},
26080   {"m9tdmi",     &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9tdmi")},
26081   {"marm920",    &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm920")},
26082   {"m920",       &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm920")},
26083   {"marm940",    &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm940")},
26084   {"m940",       &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm940")},
26085   {"mstrongarm", &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=strongarm")},
26086   {"mstrongarm110", &legacy_cpu, ARM_ARCH_V4,
26087    N_("use -mcpu=strongarm110")},
26088   {"mstrongarm1100", &legacy_cpu, ARM_ARCH_V4,
26089    N_("use -mcpu=strongarm1100")},
26090   {"mstrongarm1110", &legacy_cpu, ARM_ARCH_V4,
26091    N_("use -mcpu=strongarm1110")},
26092   {"mxscale",    &legacy_cpu, ARM_ARCH_XSCALE, N_("use -mcpu=xscale")},
26093   {"miwmmxt",    &legacy_cpu, ARM_ARCH_IWMMXT, N_("use -mcpu=iwmmxt")},
26094   {"mall",       &legacy_cpu, ARM_ANY,         N_("use -mcpu=all")},
26095
26096   /* Architecture variants -- don't add any more to this list either.  */
26097   {"mv2",        &legacy_cpu, ARM_ARCH_V2,  N_("use -march=armv2")},
26098   {"marmv2",     &legacy_cpu, ARM_ARCH_V2,  N_("use -march=armv2")},
26099   {"mv2a",       &legacy_cpu, ARM_ARCH_V2S, N_("use -march=armv2a")},
26100   {"marmv2a",    &legacy_cpu, ARM_ARCH_V2S, N_("use -march=armv2a")},
26101   {"mv3",        &legacy_cpu, ARM_ARCH_V3,  N_("use -march=armv3")},
26102   {"marmv3",     &legacy_cpu, ARM_ARCH_V3,  N_("use -march=armv3")},
26103   {"mv3m",       &legacy_cpu, ARM_ARCH_V3M, N_("use -march=armv3m")},
26104   {"marmv3m",    &legacy_cpu, ARM_ARCH_V3M, N_("use -march=armv3m")},
26105   {"mv4",        &legacy_cpu, ARM_ARCH_V4,  N_("use -march=armv4")},
26106   {"marmv4",     &legacy_cpu, ARM_ARCH_V4,  N_("use -march=armv4")},
26107   {"mv4t",       &legacy_cpu, ARM_ARCH_V4T, N_("use -march=armv4t")},
26108   {"marmv4t",    &legacy_cpu, ARM_ARCH_V4T, N_("use -march=armv4t")},
26109   {"mv5",        &legacy_cpu, ARM_ARCH_V5,  N_("use -march=armv5")},
26110   {"marmv5",     &legacy_cpu, ARM_ARCH_V5,  N_("use -march=armv5")},
26111   {"mv5t",       &legacy_cpu, ARM_ARCH_V5T, N_("use -march=armv5t")},
26112   {"marmv5t",    &legacy_cpu, ARM_ARCH_V5T, N_("use -march=armv5t")},
26113   {"mv5e",       &legacy_cpu, ARM_ARCH_V5TE, N_("use -march=armv5te")},
26114   {"marmv5e",    &legacy_cpu, ARM_ARCH_V5TE, N_("use -march=armv5te")},
26115
26116   /* Floating point variants -- don't add any more to this list either.  */
26117   {"mfpe-old",   &legacy_fpu, FPU_ARCH_FPE, N_("use -mfpu=fpe")},
26118   {"mfpa10",     &legacy_fpu, FPU_ARCH_FPA, N_("use -mfpu=fpa10")},
26119   {"mfpa11",     &legacy_fpu, FPU_ARCH_FPA, N_("use -mfpu=fpa11")},
26120   {"mno-fpu",    &legacy_fpu, ARM_ARCH_NONE,
26121    N_("use either -mfpu=softfpa or -mfpu=softvfp")},
26122
26123   {NULL, NULL, ARM_ARCH_NONE, NULL}
26124 };
26125
26126 struct arm_cpu_option_table
26127 {
26128   const char *           name;
26129   size_t                 name_len;
26130   const arm_feature_set  value;
26131   const arm_feature_set  ext;
26132   /* For some CPUs we assume an FPU unless the user explicitly sets
26133      -mfpu=...  */
26134   const arm_feature_set  default_fpu;
26135   /* The canonical name of the CPU, or NULL to use NAME converted to upper
26136      case.  */
26137   const char *           canonical_name;
26138 };
26139
26140 /* This list should, at a minimum, contain all the cpu names
26141    recognized by GCC.  */
26142 #define ARM_CPU_OPT(N, CN, V, E, DF) { N, sizeof (N) - 1, V, E, DF, CN }
26143
26144 static const struct arm_cpu_option_table arm_cpus[] =
26145 {
26146   ARM_CPU_OPT ("all",             NULL,                ARM_ANY,
26147                ARM_ARCH_NONE,
26148                FPU_ARCH_FPA),
26149   ARM_CPU_OPT ("arm1",            NULL,                ARM_ARCH_V1,
26150                ARM_ARCH_NONE,
26151                FPU_ARCH_FPA),
26152   ARM_CPU_OPT ("arm2",            NULL,                ARM_ARCH_V2,
26153                ARM_ARCH_NONE,
26154                FPU_ARCH_FPA),
26155   ARM_CPU_OPT ("arm250",          NULL,                ARM_ARCH_V2S,
26156                ARM_ARCH_NONE,
26157                FPU_ARCH_FPA),
26158   ARM_CPU_OPT ("arm3",            NULL,                ARM_ARCH_V2S,
26159                ARM_ARCH_NONE,
26160                FPU_ARCH_FPA),
26161   ARM_CPU_OPT ("arm6",            NULL,                ARM_ARCH_V3,
26162                ARM_ARCH_NONE,
26163                FPU_ARCH_FPA),
26164   ARM_CPU_OPT ("arm60",           NULL,                ARM_ARCH_V3,
26165                ARM_ARCH_NONE,
26166                FPU_ARCH_FPA),
26167   ARM_CPU_OPT ("arm600",          NULL,                ARM_ARCH_V3,
26168                ARM_ARCH_NONE,
26169                FPU_ARCH_FPA),
26170   ARM_CPU_OPT ("arm610",          NULL,                ARM_ARCH_V3,
26171                ARM_ARCH_NONE,
26172                FPU_ARCH_FPA),
26173   ARM_CPU_OPT ("arm620",          NULL,                ARM_ARCH_V3,
26174                ARM_ARCH_NONE,
26175                FPU_ARCH_FPA),
26176   ARM_CPU_OPT ("arm7",            NULL,                ARM_ARCH_V3,
26177                ARM_ARCH_NONE,
26178                FPU_ARCH_FPA),
26179   ARM_CPU_OPT ("arm7m",           NULL,                ARM_ARCH_V3M,
26180                ARM_ARCH_NONE,
26181                FPU_ARCH_FPA),
26182   ARM_CPU_OPT ("arm7d",           NULL,                ARM_ARCH_V3,
26183                ARM_ARCH_NONE,
26184                FPU_ARCH_FPA),
26185   ARM_CPU_OPT ("arm7dm",          NULL,                ARM_ARCH_V3M,
26186                ARM_ARCH_NONE,
26187                FPU_ARCH_FPA),
26188   ARM_CPU_OPT ("arm7di",          NULL,                ARM_ARCH_V3,
26189                ARM_ARCH_NONE,
26190                FPU_ARCH_FPA),
26191   ARM_CPU_OPT ("arm7dmi",         NULL,                ARM_ARCH_V3M,
26192                ARM_ARCH_NONE,
26193                FPU_ARCH_FPA),
26194   ARM_CPU_OPT ("arm70",           NULL,                ARM_ARCH_V3,
26195                ARM_ARCH_NONE,
26196                FPU_ARCH_FPA),
26197   ARM_CPU_OPT ("arm700",          NULL,                ARM_ARCH_V3,
26198                ARM_ARCH_NONE,
26199                FPU_ARCH_FPA),
26200   ARM_CPU_OPT ("arm700i",         NULL,                ARM_ARCH_V3,
26201                ARM_ARCH_NONE,
26202                FPU_ARCH_FPA),
26203   ARM_CPU_OPT ("arm710",          NULL,                ARM_ARCH_V3,
26204                ARM_ARCH_NONE,
26205                FPU_ARCH_FPA),
26206   ARM_CPU_OPT ("arm710t",         NULL,                ARM_ARCH_V4T,
26207                ARM_ARCH_NONE,
26208                FPU_ARCH_FPA),
26209   ARM_CPU_OPT ("arm720",          NULL,                ARM_ARCH_V3,
26210                ARM_ARCH_NONE,
26211                FPU_ARCH_FPA),
26212   ARM_CPU_OPT ("arm720t",         NULL,                ARM_ARCH_V4T,
26213                ARM_ARCH_NONE,
26214                FPU_ARCH_FPA),
26215   ARM_CPU_OPT ("arm740t",         NULL,                ARM_ARCH_V4T,
26216                ARM_ARCH_NONE,
26217                FPU_ARCH_FPA),
26218   ARM_CPU_OPT ("arm710c",         NULL,                ARM_ARCH_V3,
26219                ARM_ARCH_NONE,
26220                FPU_ARCH_FPA),
26221   ARM_CPU_OPT ("arm7100",         NULL,                ARM_ARCH_V3,
26222                ARM_ARCH_NONE,
26223                FPU_ARCH_FPA),
26224   ARM_CPU_OPT ("arm7500",         NULL,                ARM_ARCH_V3,
26225                ARM_ARCH_NONE,
26226                FPU_ARCH_FPA),
26227   ARM_CPU_OPT ("arm7500fe",       NULL,                ARM_ARCH_V3,
26228                ARM_ARCH_NONE,
26229                FPU_ARCH_FPA),
26230   ARM_CPU_OPT ("arm7t",           NULL,                ARM_ARCH_V4T,
26231                ARM_ARCH_NONE,
26232                FPU_ARCH_FPA),
26233   ARM_CPU_OPT ("arm7tdmi",        NULL,                ARM_ARCH_V4T,
26234                ARM_ARCH_NONE,
26235                FPU_ARCH_FPA),
26236   ARM_CPU_OPT ("arm7tdmi-s",      NULL,                ARM_ARCH_V4T,
26237                ARM_ARCH_NONE,
26238                FPU_ARCH_FPA),
26239   ARM_CPU_OPT ("arm8",            NULL,                ARM_ARCH_V4,
26240                ARM_ARCH_NONE,
26241                FPU_ARCH_FPA),
26242   ARM_CPU_OPT ("arm810",          NULL,                ARM_ARCH_V4,
26243                ARM_ARCH_NONE,
26244                FPU_ARCH_FPA),
26245   ARM_CPU_OPT ("strongarm",       NULL,                ARM_ARCH_V4,
26246                ARM_ARCH_NONE,
26247                FPU_ARCH_FPA),
26248   ARM_CPU_OPT ("strongarm1",      NULL,                ARM_ARCH_V4,
26249                ARM_ARCH_NONE,
26250                FPU_ARCH_FPA),
26251   ARM_CPU_OPT ("strongarm110",    NULL,                ARM_ARCH_V4,
26252                ARM_ARCH_NONE,
26253                FPU_ARCH_FPA),
26254   ARM_CPU_OPT ("strongarm1100",   NULL,                ARM_ARCH_V4,
26255                ARM_ARCH_NONE,
26256                FPU_ARCH_FPA),
26257   ARM_CPU_OPT ("strongarm1110",   NULL,                ARM_ARCH_V4,
26258                ARM_ARCH_NONE,
26259                FPU_ARCH_FPA),
26260   ARM_CPU_OPT ("arm9",            NULL,                ARM_ARCH_V4T,
26261                ARM_ARCH_NONE,
26262                FPU_ARCH_FPA),
26263   ARM_CPU_OPT ("arm920",          "ARM920T",           ARM_ARCH_V4T,
26264                ARM_ARCH_NONE,
26265                FPU_ARCH_FPA),
26266   ARM_CPU_OPT ("arm920t",         NULL,                ARM_ARCH_V4T,
26267                ARM_ARCH_NONE,
26268                FPU_ARCH_FPA),
26269   ARM_CPU_OPT ("arm922t",         NULL,                ARM_ARCH_V4T,
26270                ARM_ARCH_NONE,
26271                FPU_ARCH_FPA),
26272   ARM_CPU_OPT ("arm940t",         NULL,                ARM_ARCH_V4T,
26273                ARM_ARCH_NONE,
26274                FPU_ARCH_FPA),
26275   ARM_CPU_OPT ("arm9tdmi",        NULL,                ARM_ARCH_V4T,
26276                ARM_ARCH_NONE,
26277                FPU_ARCH_FPA),
26278   ARM_CPU_OPT ("fa526",           NULL,                ARM_ARCH_V4,
26279                ARM_ARCH_NONE,
26280                FPU_ARCH_FPA),
26281   ARM_CPU_OPT ("fa626",           NULL,                ARM_ARCH_V4,
26282                ARM_ARCH_NONE,
26283                FPU_ARCH_FPA),
26284
26285   /* For V5 or later processors we default to using VFP; but the user
26286      should really set the FPU type explicitly.  */
26287   ARM_CPU_OPT ("arm9e-r0",        NULL,                ARM_ARCH_V5TExP,
26288                ARM_ARCH_NONE,
26289                FPU_ARCH_VFP_V2),
26290   ARM_CPU_OPT ("arm9e",           NULL,                ARM_ARCH_V5TE,
26291                ARM_ARCH_NONE,
26292                FPU_ARCH_VFP_V2),
26293   ARM_CPU_OPT ("arm926ej",        "ARM926EJ-S",        ARM_ARCH_V5TEJ,
26294                ARM_ARCH_NONE,
26295                FPU_ARCH_VFP_V2),
26296   ARM_CPU_OPT ("arm926ejs",       "ARM926EJ-S",        ARM_ARCH_V5TEJ,
26297                ARM_ARCH_NONE,
26298                FPU_ARCH_VFP_V2),
26299   ARM_CPU_OPT ("arm926ej-s",      NULL,                ARM_ARCH_V5TEJ,
26300                ARM_ARCH_NONE,
26301                FPU_ARCH_VFP_V2),
26302   ARM_CPU_OPT ("arm946e-r0",      NULL,                ARM_ARCH_V5TExP,
26303                ARM_ARCH_NONE,
26304                FPU_ARCH_VFP_V2),
26305   ARM_CPU_OPT ("arm946e",         "ARM946E-S",         ARM_ARCH_V5TE,
26306                ARM_ARCH_NONE,
26307                FPU_ARCH_VFP_V2),
26308   ARM_CPU_OPT ("arm946e-s",       NULL,                ARM_ARCH_V5TE,
26309                ARM_ARCH_NONE,
26310                FPU_ARCH_VFP_V2),
26311   ARM_CPU_OPT ("arm966e-r0",      NULL,                ARM_ARCH_V5TExP,
26312                ARM_ARCH_NONE,
26313                FPU_ARCH_VFP_V2),
26314   ARM_CPU_OPT ("arm966e",         "ARM966E-S",         ARM_ARCH_V5TE,
26315                ARM_ARCH_NONE,
26316                FPU_ARCH_VFP_V2),
26317   ARM_CPU_OPT ("arm966e-s",       NULL,                ARM_ARCH_V5TE,
26318                ARM_ARCH_NONE,
26319                FPU_ARCH_VFP_V2),
26320   ARM_CPU_OPT ("arm968e-s",       NULL,                ARM_ARCH_V5TE,
26321                ARM_ARCH_NONE,
26322                FPU_ARCH_VFP_V2),
26323   ARM_CPU_OPT ("arm10t",          NULL,                ARM_ARCH_V5T,
26324                ARM_ARCH_NONE,
26325                FPU_ARCH_VFP_V1),
26326   ARM_CPU_OPT ("arm10tdmi",       NULL,                ARM_ARCH_V5T,
26327                ARM_ARCH_NONE,
26328                FPU_ARCH_VFP_V1),
26329   ARM_CPU_OPT ("arm10e",          NULL,                ARM_ARCH_V5TE,
26330                ARM_ARCH_NONE,
26331                FPU_ARCH_VFP_V2),
26332   ARM_CPU_OPT ("arm1020",         "ARM1020E",          ARM_ARCH_V5TE,
26333                ARM_ARCH_NONE,
26334                FPU_ARCH_VFP_V2),
26335   ARM_CPU_OPT ("arm1020t",        NULL,                ARM_ARCH_V5T,
26336                ARM_ARCH_NONE,
26337                FPU_ARCH_VFP_V1),
26338   ARM_CPU_OPT ("arm1020e",        NULL,                ARM_ARCH_V5TE,
26339                ARM_ARCH_NONE,
26340                FPU_ARCH_VFP_V2),
26341   ARM_CPU_OPT ("arm1022e",        NULL,                ARM_ARCH_V5TE,
26342                ARM_ARCH_NONE,
26343                FPU_ARCH_VFP_V2),
26344   ARM_CPU_OPT ("arm1026ejs",      "ARM1026EJ-S",       ARM_ARCH_V5TEJ,
26345                ARM_ARCH_NONE,
26346                FPU_ARCH_VFP_V2),
26347   ARM_CPU_OPT ("arm1026ej-s",     NULL,                ARM_ARCH_V5TEJ,
26348                ARM_ARCH_NONE,
26349                FPU_ARCH_VFP_V2),
26350   ARM_CPU_OPT ("fa606te",         NULL,                ARM_ARCH_V5TE,
26351                ARM_ARCH_NONE,
26352                FPU_ARCH_VFP_V2),
26353   ARM_CPU_OPT ("fa616te",         NULL,                ARM_ARCH_V5TE,
26354                ARM_ARCH_NONE,
26355                FPU_ARCH_VFP_V2),
26356   ARM_CPU_OPT ("fa626te",         NULL,                ARM_ARCH_V5TE,
26357                ARM_ARCH_NONE,
26358                FPU_ARCH_VFP_V2),
26359   ARM_CPU_OPT ("fmp626",          NULL,                ARM_ARCH_V5TE,
26360                ARM_ARCH_NONE,
26361                FPU_ARCH_VFP_V2),
26362   ARM_CPU_OPT ("fa726te",         NULL,                ARM_ARCH_V5TE,
26363                ARM_ARCH_NONE,
26364                FPU_ARCH_VFP_V2),
26365   ARM_CPU_OPT ("arm1136js",       "ARM1136J-S",        ARM_ARCH_V6,
26366                ARM_ARCH_NONE,
26367                FPU_NONE),
26368   ARM_CPU_OPT ("arm1136j-s",      NULL,                ARM_ARCH_V6,
26369                ARM_ARCH_NONE,
26370                FPU_NONE),
26371   ARM_CPU_OPT ("arm1136jfs",      "ARM1136JF-S",       ARM_ARCH_V6,
26372                ARM_ARCH_NONE,
26373                FPU_ARCH_VFP_V2),
26374   ARM_CPU_OPT ("arm1136jf-s",     NULL,                ARM_ARCH_V6,
26375                ARM_ARCH_NONE,
26376                FPU_ARCH_VFP_V2),
26377   ARM_CPU_OPT ("mpcore",          "MPCore",            ARM_ARCH_V6K,
26378                ARM_ARCH_NONE,
26379                FPU_ARCH_VFP_V2),
26380   ARM_CPU_OPT ("mpcorenovfp",     "MPCore",            ARM_ARCH_V6K,
26381                ARM_ARCH_NONE,
26382                FPU_NONE),
26383   ARM_CPU_OPT ("arm1156t2-s",     NULL,                ARM_ARCH_V6T2,
26384                ARM_ARCH_NONE,
26385                FPU_NONE),
26386   ARM_CPU_OPT ("arm1156t2f-s",    NULL,                ARM_ARCH_V6T2,
26387                ARM_ARCH_NONE,
26388                FPU_ARCH_VFP_V2),
26389   ARM_CPU_OPT ("arm1176jz-s",     NULL,                ARM_ARCH_V6KZ,
26390                ARM_ARCH_NONE,
26391                FPU_NONE),
26392   ARM_CPU_OPT ("arm1176jzf-s",    NULL,                ARM_ARCH_V6KZ,
26393                ARM_ARCH_NONE,
26394                FPU_ARCH_VFP_V2),
26395   ARM_CPU_OPT ("cortex-a5",       "Cortex-A5",         ARM_ARCH_V7A,
26396                ARM_FEATURE_CORE_LOW (ARM_EXT_MP | ARM_EXT_SEC),
26397                FPU_NONE),
26398   ARM_CPU_OPT ("cortex-a7",       "Cortex-A7",         ARM_ARCH_V7VE,
26399                ARM_ARCH_NONE,
26400                FPU_ARCH_NEON_VFP_V4),
26401   ARM_CPU_OPT ("cortex-a8",       "Cortex-A8",         ARM_ARCH_V7A,
26402                ARM_FEATURE_CORE_LOW (ARM_EXT_SEC),
26403                ARM_FEATURE_COPROC (FPU_VFP_V3 | FPU_NEON_EXT_V1)),
26404   ARM_CPU_OPT ("cortex-a9",       "Cortex-A9",         ARM_ARCH_V7A,
26405                ARM_FEATURE_CORE_LOW (ARM_EXT_MP | ARM_EXT_SEC),
26406                ARM_FEATURE_COPROC (FPU_VFP_V3 | FPU_NEON_EXT_V1)),
26407   ARM_CPU_OPT ("cortex-a12",      "Cortex-A12",        ARM_ARCH_V7VE,
26408                ARM_ARCH_NONE,
26409                FPU_ARCH_NEON_VFP_V4),
26410   ARM_CPU_OPT ("cortex-a15",      "Cortex-A15",        ARM_ARCH_V7VE,
26411                ARM_ARCH_NONE,
26412                FPU_ARCH_NEON_VFP_V4),
26413   ARM_CPU_OPT ("cortex-a17",      "Cortex-A17",        ARM_ARCH_V7VE,
26414                ARM_ARCH_NONE,
26415                FPU_ARCH_NEON_VFP_V4),
26416   ARM_CPU_OPT ("cortex-a32",      "Cortex-A32",        ARM_ARCH_V8A,
26417                ARM_FEATURE_COPROC (CRC_EXT_ARMV8),
26418                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8),
26419   ARM_CPU_OPT ("cortex-a35",      "Cortex-A35",        ARM_ARCH_V8A,
26420                ARM_FEATURE_COPROC (CRC_EXT_ARMV8),
26421                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8),
26422   ARM_CPU_OPT ("cortex-a53",      "Cortex-A53",        ARM_ARCH_V8A,
26423                ARM_FEATURE_COPROC (CRC_EXT_ARMV8),
26424                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8),
26425   ARM_CPU_OPT ("cortex-a55",    "Cortex-A55",          ARM_ARCH_V8_2A,
26426                ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_INST),
26427                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8_DOTPROD),
26428   ARM_CPU_OPT ("cortex-a57",      "Cortex-A57",        ARM_ARCH_V8A,
26429                ARM_FEATURE_COPROC (CRC_EXT_ARMV8),
26430                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8),
26431   ARM_CPU_OPT ("cortex-a72",      "Cortex-A72",        ARM_ARCH_V8A,
26432               ARM_FEATURE_COPROC (CRC_EXT_ARMV8),
26433               FPU_ARCH_CRYPTO_NEON_VFP_ARMV8),
26434   ARM_CPU_OPT ("cortex-a73",      "Cortex-A73",        ARM_ARCH_V8A,
26435               ARM_FEATURE_COPROC (CRC_EXT_ARMV8),
26436               FPU_ARCH_CRYPTO_NEON_VFP_ARMV8),
26437   ARM_CPU_OPT ("cortex-a75",    "Cortex-A75",          ARM_ARCH_V8_2A,
26438                ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_INST),
26439                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8_DOTPROD),
26440   ARM_CPU_OPT ("cortex-a76",    "Cortex-A76",          ARM_ARCH_V8_2A,
26441                ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_INST),
26442                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8_DOTPROD),
26443   ARM_CPU_OPT ("ares",    "Ares",              ARM_ARCH_V8_2A,
26444                ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_INST),
26445                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8_DOTPROD),
26446   ARM_CPU_OPT ("cortex-r4",       "Cortex-R4",         ARM_ARCH_V7R,
26447                ARM_ARCH_NONE,
26448                FPU_NONE),
26449   ARM_CPU_OPT ("cortex-r4f",      "Cortex-R4F",        ARM_ARCH_V7R,
26450                ARM_ARCH_NONE,
26451                FPU_ARCH_VFP_V3D16),
26452   ARM_CPU_OPT ("cortex-r5",       "Cortex-R5",         ARM_ARCH_V7R,
26453                ARM_FEATURE_CORE_LOW (ARM_EXT_ADIV),
26454                FPU_NONE),
26455   ARM_CPU_OPT ("cortex-r7",       "Cortex-R7",         ARM_ARCH_V7R,
26456                ARM_FEATURE_CORE_LOW (ARM_EXT_ADIV),
26457                FPU_ARCH_VFP_V3D16),
26458   ARM_CPU_OPT ("cortex-r8",       "Cortex-R8",         ARM_ARCH_V7R,
26459                ARM_FEATURE_CORE_LOW (ARM_EXT_ADIV),
26460                FPU_ARCH_VFP_V3D16),
26461   ARM_CPU_OPT ("cortex-r52",      "Cortex-R52",        ARM_ARCH_V8R,
26462               ARM_FEATURE_COPROC (CRC_EXT_ARMV8),
26463               FPU_ARCH_NEON_VFP_ARMV8),
26464   ARM_CPU_OPT ("cortex-m33",      "Cortex-M33",        ARM_ARCH_V8M_MAIN,
26465                ARM_FEATURE_CORE_LOW (ARM_EXT_V5ExP | ARM_EXT_V6_DSP),
26466                FPU_NONE),
26467   ARM_CPU_OPT ("cortex-m23",      "Cortex-M23",        ARM_ARCH_V8M_BASE,
26468                ARM_ARCH_NONE,
26469                FPU_NONE),
26470   ARM_CPU_OPT ("cortex-m7",       "Cortex-M7",         ARM_ARCH_V7EM,
26471                ARM_ARCH_NONE,
26472                FPU_NONE),
26473   ARM_CPU_OPT ("cortex-m4",       "Cortex-M4",         ARM_ARCH_V7EM,
26474                ARM_ARCH_NONE,
26475                FPU_NONE),
26476   ARM_CPU_OPT ("cortex-m3",       "Cortex-M3",         ARM_ARCH_V7M,
26477                ARM_ARCH_NONE,
26478                FPU_NONE),
26479   ARM_CPU_OPT ("cortex-m1",       "Cortex-M1",         ARM_ARCH_V6SM,
26480                ARM_ARCH_NONE,
26481                FPU_NONE),
26482   ARM_CPU_OPT ("cortex-m0",       "Cortex-M0",         ARM_ARCH_V6SM,
26483                ARM_ARCH_NONE,
26484                FPU_NONE),
26485   ARM_CPU_OPT ("cortex-m0plus",   "Cortex-M0+",        ARM_ARCH_V6SM,
26486                ARM_ARCH_NONE,
26487                FPU_NONE),
26488   ARM_CPU_OPT ("exynos-m1",       "Samsung Exynos M1", ARM_ARCH_V8A,
26489                ARM_FEATURE_COPROC (CRC_EXT_ARMV8),
26490                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8),
26491   ARM_CPU_OPT ("neoverse-n1",    "Neoverse N1",        ARM_ARCH_V8_2A,
26492                ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_INST),
26493                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8_DOTPROD),
26494   /* ??? XSCALE is really an architecture.  */
26495   ARM_CPU_OPT ("xscale",          NULL,                ARM_ARCH_XSCALE,
26496                ARM_ARCH_NONE,
26497                FPU_ARCH_VFP_V2),
26498
26499   /* ??? iwmmxt is not a processor.  */
26500   ARM_CPU_OPT ("iwmmxt",          NULL,                ARM_ARCH_IWMMXT,
26501                ARM_ARCH_NONE,
26502                FPU_ARCH_VFP_V2),
26503   ARM_CPU_OPT ("iwmmxt2",         NULL,                ARM_ARCH_IWMMXT2,
26504                ARM_ARCH_NONE,
26505                FPU_ARCH_VFP_V2),
26506   ARM_CPU_OPT ("i80200",          NULL,                ARM_ARCH_XSCALE,
26507                ARM_ARCH_NONE,
26508                FPU_ARCH_VFP_V2),
26509
26510   /* Maverick.  */
26511   ARM_CPU_OPT ("ep9312",          "ARM920T",
26512                ARM_FEATURE_LOW (ARM_AEXT_V4T, ARM_CEXT_MAVERICK),
26513                ARM_ARCH_NONE, FPU_ARCH_MAVERICK),
26514
26515   /* Marvell processors.  */
26516   ARM_CPU_OPT ("marvell-pj4",     NULL,                ARM_ARCH_V7A,
26517                ARM_FEATURE_CORE_LOW (ARM_EXT_MP | ARM_EXT_SEC),
26518                FPU_ARCH_VFP_V3D16),
26519   ARM_CPU_OPT ("marvell-whitney", NULL,                ARM_ARCH_V7A,
26520                ARM_FEATURE_CORE_LOW (ARM_EXT_MP | ARM_EXT_SEC),
26521                FPU_ARCH_NEON_VFP_V4),
26522
26523   /* APM X-Gene family.  */
26524   ARM_CPU_OPT ("xgene1",          "APM X-Gene 1",      ARM_ARCH_V8A,
26525                ARM_ARCH_NONE,
26526                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8),
26527   ARM_CPU_OPT ("xgene2",          "APM X-Gene 2",      ARM_ARCH_V8A,
26528                ARM_FEATURE_COPROC (CRC_EXT_ARMV8),
26529                FPU_ARCH_CRYPTO_NEON_VFP_ARMV8),
26530
26531   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE, ARM_ARCH_NONE, NULL }
26532 };
26533 #undef ARM_CPU_OPT
26534
26535 struct arm_ext_table
26536 {
26537   const char *            name;
26538   size_t                  name_len;
26539   const arm_feature_set   merge;
26540   const arm_feature_set   clear;
26541 };
26542
26543 struct arm_arch_option_table
26544 {
26545   const char *                  name;
26546   size_t                        name_len;
26547   const arm_feature_set         value;
26548   const arm_feature_set         default_fpu;
26549   const struct arm_ext_table *  ext_table;
26550 };
26551
26552 /* Used to add support for +E and +noE extension.  */
26553 #define ARM_EXT(E, M, C) { E, sizeof (E) - 1, M, C }
26554 /* Used to add support for a +E extension.  */
26555 #define ARM_ADD(E, M) { E, sizeof(E) - 1, M, ARM_ARCH_NONE }
26556 /* Used to add support for a +noE extension.  */
26557 #define ARM_REMOVE(E, C) { E, sizeof(E) -1, ARM_ARCH_NONE, C }
26558
26559 #define ALL_FP ARM_FEATURE (0, ARM_EXT2_FP16_INST | ARM_EXT2_FP16_FML, \
26560                             ~0 & ~FPU_ENDIAN_PURE)
26561
26562 static const struct arm_ext_table armv5te_ext_table[] =
26563 {
26564   ARM_EXT ("fp", FPU_ARCH_VFP_V2, ALL_FP),
26565   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26566 };
26567
26568 static const struct arm_ext_table armv7_ext_table[] =
26569 {
26570   ARM_EXT ("fp", FPU_ARCH_VFP_V3D16, ALL_FP),
26571   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26572 };
26573
26574 static const struct arm_ext_table armv7ve_ext_table[] =
26575 {
26576   ARM_EXT ("fp", FPU_ARCH_VFP_V4D16, ALL_FP),
26577   ARM_ADD ("vfpv3-d16", FPU_ARCH_VFP_V3D16),
26578   ARM_ADD ("vfpv3", FPU_ARCH_VFP_V3),
26579   ARM_ADD ("vfpv3-d16-fp16", FPU_ARCH_VFP_V3D16_FP16),
26580   ARM_ADD ("vfpv3-fp16", FPU_ARCH_VFP_V3_FP16),
26581   ARM_ADD ("vfpv4-d16", FPU_ARCH_VFP_V4D16),  /* Alias for +fp.  */
26582   ARM_ADD ("vfpv4", FPU_ARCH_VFP_V4),
26583
26584   ARM_EXT ("simd", FPU_ARCH_NEON_VFP_V4,
26585            ARM_FEATURE_COPROC (FPU_NEON_EXT_V1 | FPU_NEON_EXT_FMA)),
26586
26587   /* Aliases for +simd.  */
26588   ARM_ADD ("neon-vfpv4", FPU_ARCH_NEON_VFP_V4),
26589
26590   ARM_ADD ("neon", FPU_ARCH_VFP_V3_PLUS_NEON_V1),
26591   ARM_ADD ("neon-vfpv3", FPU_ARCH_VFP_V3_PLUS_NEON_V1),
26592   ARM_ADD ("neon-fp16", FPU_ARCH_NEON_FP16),
26593
26594   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26595 };
26596
26597 static const struct arm_ext_table armv7a_ext_table[] =
26598 {
26599   ARM_EXT ("fp", FPU_ARCH_VFP_V3D16, ALL_FP),
26600   ARM_ADD ("vfpv3-d16", FPU_ARCH_VFP_V3D16), /* Alias for +fp.  */
26601   ARM_ADD ("vfpv3", FPU_ARCH_VFP_V3),
26602   ARM_ADD ("vfpv3-d16-fp16", FPU_ARCH_VFP_V3D16_FP16),
26603   ARM_ADD ("vfpv3-fp16", FPU_ARCH_VFP_V3_FP16),
26604   ARM_ADD ("vfpv4-d16", FPU_ARCH_VFP_V4D16),
26605   ARM_ADD ("vfpv4", FPU_ARCH_VFP_V4),
26606
26607   ARM_EXT ("simd", FPU_ARCH_VFP_V3_PLUS_NEON_V1,
26608            ARM_FEATURE_COPROC (FPU_NEON_EXT_V1 | FPU_NEON_EXT_FMA)),
26609
26610   /* Aliases for +simd.  */
26611   ARM_ADD ("neon", FPU_ARCH_VFP_V3_PLUS_NEON_V1),
26612   ARM_ADD ("neon-vfpv3", FPU_ARCH_VFP_V3_PLUS_NEON_V1),
26613
26614   ARM_ADD ("neon-fp16", FPU_ARCH_NEON_FP16),
26615   ARM_ADD ("neon-vfpv4", FPU_ARCH_NEON_VFP_V4),
26616
26617   ARM_ADD ("mp", ARM_FEATURE_CORE_LOW (ARM_EXT_MP)),
26618   ARM_ADD ("sec", ARM_FEATURE_CORE_LOW (ARM_EXT_SEC)),
26619   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26620 };
26621
26622 static const struct arm_ext_table armv7r_ext_table[] =
26623 {
26624   ARM_ADD ("fp.sp", FPU_ARCH_VFP_V3xD),
26625   ARM_ADD ("vfpv3xd", FPU_ARCH_VFP_V3xD), /* Alias for +fp.sp.  */
26626   ARM_EXT ("fp", FPU_ARCH_VFP_V3D16, ALL_FP),
26627   ARM_ADD ("vfpv3-d16", FPU_ARCH_VFP_V3D16), /* Alias for +fp.  */
26628   ARM_ADD ("vfpv3xd-fp16", FPU_ARCH_VFP_V3xD_FP16),
26629   ARM_ADD ("vfpv3-d16-fp16", FPU_ARCH_VFP_V3D16_FP16),
26630   ARM_EXT ("idiv", ARM_FEATURE_CORE_LOW (ARM_EXT_ADIV | ARM_EXT_DIV),
26631            ARM_FEATURE_CORE_LOW (ARM_EXT_ADIV | ARM_EXT_DIV)),
26632   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26633 };
26634
26635 static const struct arm_ext_table armv7em_ext_table[] =
26636 {
26637   ARM_EXT ("fp", FPU_ARCH_VFP_V4_SP_D16, ALL_FP),
26638   /* Alias for +fp, used to be known as fpv4-sp-d16.  */
26639   ARM_ADD ("vfpv4-sp-d16", FPU_ARCH_VFP_V4_SP_D16),
26640   ARM_ADD ("fpv5", FPU_ARCH_VFP_V5_SP_D16),
26641   ARM_ADD ("fp.dp", FPU_ARCH_VFP_V5D16),
26642   ARM_ADD ("fpv5-d16", FPU_ARCH_VFP_V5D16),
26643   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26644 };
26645
26646 static const struct arm_ext_table armv8a_ext_table[] =
26647 {
26648   ARM_ADD ("crc", ARCH_CRC_ARMV8),
26649   ARM_ADD ("simd", FPU_ARCH_NEON_VFP_ARMV8),
26650   ARM_EXT ("crypto", FPU_ARCH_CRYPTO_NEON_VFP_ARMV8,
26651            ARM_FEATURE_COPROC (FPU_CRYPTO_ARMV8)),
26652
26653   /* Armv8-a does not allow an FP implementation without SIMD, so the user
26654      should use the +simd option to turn on FP.  */
26655   ARM_REMOVE ("fp", ALL_FP),
26656   ARM_ADD ("sb", ARM_FEATURE_CORE_HIGH (ARM_EXT2_SB)),
26657   ARM_ADD ("predres", ARM_FEATURE_CORE_HIGH (ARM_EXT2_PREDRES)),
26658   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26659 };
26660
26661
26662 static const struct arm_ext_table armv81a_ext_table[] =
26663 {
26664   ARM_ADD ("simd", FPU_ARCH_NEON_VFP_ARMV8_1),
26665   ARM_EXT ("crypto", FPU_ARCH_CRYPTO_NEON_VFP_ARMV8_1,
26666            ARM_FEATURE_COPROC (FPU_CRYPTO_ARMV8)),
26667
26668   /* Armv8-a does not allow an FP implementation without SIMD, so the user
26669      should use the +simd option to turn on FP.  */
26670   ARM_REMOVE ("fp", ALL_FP),
26671   ARM_ADD ("sb", ARM_FEATURE_CORE_HIGH (ARM_EXT2_SB)),
26672   ARM_ADD ("predres", ARM_FEATURE_CORE_HIGH (ARM_EXT2_PREDRES)),
26673   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26674 };
26675
26676 static const struct arm_ext_table armv82a_ext_table[] =
26677 {
26678   ARM_ADD ("simd", FPU_ARCH_NEON_VFP_ARMV8_1),
26679   ARM_ADD ("fp16", FPU_ARCH_NEON_VFP_ARMV8_2_FP16),
26680   ARM_ADD ("fp16fml", FPU_ARCH_NEON_VFP_ARMV8_2_FP16FML),
26681   ARM_EXT ("crypto", FPU_ARCH_CRYPTO_NEON_VFP_ARMV8_1,
26682            ARM_FEATURE_COPROC (FPU_CRYPTO_ARMV8)),
26683   ARM_ADD ("dotprod", FPU_ARCH_DOTPROD_NEON_VFP_ARMV8),
26684
26685   /* Armv8-a does not allow an FP implementation without SIMD, so the user
26686      should use the +simd option to turn on FP.  */
26687   ARM_REMOVE ("fp", ALL_FP),
26688   ARM_ADD ("sb", ARM_FEATURE_CORE_HIGH (ARM_EXT2_SB)),
26689   ARM_ADD ("predres", ARM_FEATURE_CORE_HIGH (ARM_EXT2_PREDRES)),
26690   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26691 };
26692
26693 static const struct arm_ext_table armv84a_ext_table[] =
26694 {
26695   ARM_ADD ("simd", FPU_ARCH_DOTPROD_NEON_VFP_ARMV8),
26696   ARM_ADD ("fp16", FPU_ARCH_NEON_VFP_ARMV8_4_FP16FML),
26697   ARM_EXT ("crypto", FPU_ARCH_CRYPTO_NEON_VFP_ARMV8_4,
26698            ARM_FEATURE_COPROC (FPU_CRYPTO_ARMV8)),
26699
26700   /* Armv8-a does not allow an FP implementation without SIMD, so the user
26701      should use the +simd option to turn on FP.  */
26702   ARM_REMOVE ("fp", ALL_FP),
26703   ARM_ADD ("sb", ARM_FEATURE_CORE_HIGH (ARM_EXT2_SB)),
26704   ARM_ADD ("predres", ARM_FEATURE_CORE_HIGH (ARM_EXT2_PREDRES)),
26705   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26706 };
26707
26708 static const struct arm_ext_table armv85a_ext_table[] =
26709 {
26710   ARM_ADD ("simd", FPU_ARCH_DOTPROD_NEON_VFP_ARMV8),
26711   ARM_ADD ("fp16", FPU_ARCH_NEON_VFP_ARMV8_4_FP16FML),
26712   ARM_EXT ("crypto", FPU_ARCH_CRYPTO_NEON_VFP_ARMV8_4,
26713            ARM_FEATURE_COPROC (FPU_CRYPTO_ARMV8)),
26714
26715   /* Armv8-a does not allow an FP implementation without SIMD, so the user
26716      should use the +simd option to turn on FP.  */
26717   ARM_REMOVE ("fp", ALL_FP),
26718   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26719 };
26720
26721 static const struct arm_ext_table armv8m_main_ext_table[] =
26722 {
26723   ARM_EXT ("dsp", ARM_FEATURE_CORE_LOW (ARM_EXT_V5ExP | ARM_EXT_V6_DSP),
26724                   ARM_FEATURE_CORE_LOW (ARM_EXT_V5ExP | ARM_EXT_V6_DSP)),
26725   ARM_EXT ("fp", FPU_ARCH_VFP_V5_SP_D16, ALL_FP),
26726   ARM_ADD ("fp.dp", FPU_ARCH_VFP_V5D16),
26727   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26728 };
26729
26730 static const struct arm_ext_table armv8_1m_main_ext_table[] =
26731 {
26732   ARM_EXT ("dsp", ARM_FEATURE_CORE_LOW (ARM_EXT_V5ExP | ARM_EXT_V6_DSP),
26733                   ARM_FEATURE_CORE_LOW (ARM_EXT_V5ExP | ARM_EXT_V6_DSP)),
26734   ARM_EXT ("fp",
26735            ARM_FEATURE (0, ARM_EXT2_FP16_INST,
26736                         FPU_VFP_V5_SP_D16 | FPU_VFP_EXT_FP16 | FPU_VFP_EXT_FMA),
26737            ALL_FP),
26738   ARM_ADD ("fp.dp",
26739            ARM_FEATURE (0, ARM_EXT2_FP16_INST,
26740                         FPU_VFP_V5D16 | FPU_VFP_EXT_FP16 | FPU_VFP_EXT_FMA)),
26741   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26742 };
26743
26744 static const struct arm_ext_table armv8r_ext_table[] =
26745 {
26746   ARM_ADD ("crc", ARCH_CRC_ARMV8),
26747   ARM_ADD ("simd", FPU_ARCH_NEON_VFP_ARMV8),
26748   ARM_EXT ("crypto", FPU_ARCH_CRYPTO_NEON_VFP_ARMV8,
26749            ARM_FEATURE_COPROC (FPU_CRYPTO_ARMV8)),
26750   ARM_REMOVE ("fp", ALL_FP),
26751   ARM_ADD ("fp.sp", FPU_ARCH_VFP_V5_SP_D16),
26752   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
26753 };
26754
26755 /* This list should, at a minimum, contain all the architecture names
26756    recognized by GCC.  */
26757 #define ARM_ARCH_OPT(N, V, DF) { N, sizeof (N) - 1, V, DF, NULL }
26758 #define ARM_ARCH_OPT2(N, V, DF, ext) \
26759   { N, sizeof (N) - 1, V, DF, ext##_ext_table }
26760
26761 static const struct arm_arch_option_table arm_archs[] =
26762 {
26763   ARM_ARCH_OPT ("all",            ARM_ANY,              FPU_ARCH_FPA),
26764   ARM_ARCH_OPT ("armv1",          ARM_ARCH_V1,          FPU_ARCH_FPA),
26765   ARM_ARCH_OPT ("armv2",          ARM_ARCH_V2,          FPU_ARCH_FPA),
26766   ARM_ARCH_OPT ("armv2a",         ARM_ARCH_V2S,         FPU_ARCH_FPA),
26767   ARM_ARCH_OPT ("armv2s",         ARM_ARCH_V2S,         FPU_ARCH_FPA),
26768   ARM_ARCH_OPT ("armv3",          ARM_ARCH_V3,          FPU_ARCH_FPA),
26769   ARM_ARCH_OPT ("armv3m",         ARM_ARCH_V3M,         FPU_ARCH_FPA),
26770   ARM_ARCH_OPT ("armv4",          ARM_ARCH_V4,          FPU_ARCH_FPA),
26771   ARM_ARCH_OPT ("armv4xm",        ARM_ARCH_V4xM,        FPU_ARCH_FPA),
26772   ARM_ARCH_OPT ("armv4t",         ARM_ARCH_V4T,         FPU_ARCH_FPA),
26773   ARM_ARCH_OPT ("armv4txm",       ARM_ARCH_V4TxM,       FPU_ARCH_FPA),
26774   ARM_ARCH_OPT ("armv5",          ARM_ARCH_V5,          FPU_ARCH_VFP),
26775   ARM_ARCH_OPT ("armv5t",         ARM_ARCH_V5T,         FPU_ARCH_VFP),
26776   ARM_ARCH_OPT ("armv5txm",       ARM_ARCH_V5TxM,       FPU_ARCH_VFP),
26777   ARM_ARCH_OPT2 ("armv5te",       ARM_ARCH_V5TE,        FPU_ARCH_VFP,   armv5te),
26778   ARM_ARCH_OPT2 ("armv5texp",     ARM_ARCH_V5TExP,      FPU_ARCH_VFP, armv5te),
26779   ARM_ARCH_OPT2 ("armv5tej",      ARM_ARCH_V5TEJ,       FPU_ARCH_VFP,   armv5te),
26780   ARM_ARCH_OPT2 ("armv6",         ARM_ARCH_V6,          FPU_ARCH_VFP,   armv5te),
26781   ARM_ARCH_OPT2 ("armv6j",        ARM_ARCH_V6,          FPU_ARCH_VFP,   armv5te),
26782   ARM_ARCH_OPT2 ("armv6k",        ARM_ARCH_V6K,         FPU_ARCH_VFP,   armv5te),
26783   ARM_ARCH_OPT2 ("armv6z",        ARM_ARCH_V6Z,         FPU_ARCH_VFP,   armv5te),
26784   /* The official spelling of this variant is ARMv6KZ, the name "armv6zk" is
26785      kept to preserve existing behaviour.  */
26786   ARM_ARCH_OPT2 ("armv6kz",       ARM_ARCH_V6KZ,        FPU_ARCH_VFP,   armv5te),
26787   ARM_ARCH_OPT2 ("armv6zk",       ARM_ARCH_V6KZ,        FPU_ARCH_VFP,   armv5te),
26788   ARM_ARCH_OPT2 ("armv6t2",       ARM_ARCH_V6T2,        FPU_ARCH_VFP,   armv5te),
26789   ARM_ARCH_OPT2 ("armv6kt2",      ARM_ARCH_V6KT2,       FPU_ARCH_VFP,   armv5te),
26790   ARM_ARCH_OPT2 ("armv6zt2",      ARM_ARCH_V6ZT2,       FPU_ARCH_VFP,   armv5te),
26791   /* The official spelling of this variant is ARMv6KZ, the name "armv6zkt2" is
26792      kept to preserve existing behaviour.  */
26793   ARM_ARCH_OPT2 ("armv6kzt2",     ARM_ARCH_V6KZT2,      FPU_ARCH_VFP,   armv5te),
26794   ARM_ARCH_OPT2 ("armv6zkt2",     ARM_ARCH_V6KZT2,      FPU_ARCH_VFP,   armv5te),
26795   ARM_ARCH_OPT ("armv6-m",        ARM_ARCH_V6M,         FPU_ARCH_VFP),
26796   ARM_ARCH_OPT ("armv6s-m",       ARM_ARCH_V6SM,        FPU_ARCH_VFP),
26797   ARM_ARCH_OPT2 ("armv7",         ARM_ARCH_V7,          FPU_ARCH_VFP, armv7),
26798   /* The official spelling of the ARMv7 profile variants is the dashed form.
26799      Accept the non-dashed form for compatibility with old toolchains.  */
26800   ARM_ARCH_OPT2 ("armv7a",        ARM_ARCH_V7A,         FPU_ARCH_VFP, armv7a),
26801   ARM_ARCH_OPT2 ("armv7ve",       ARM_ARCH_V7VE,        FPU_ARCH_VFP, armv7ve),
26802   ARM_ARCH_OPT2 ("armv7r",        ARM_ARCH_V7R,         FPU_ARCH_VFP, armv7r),
26803   ARM_ARCH_OPT ("armv7m",         ARM_ARCH_V7M,         FPU_ARCH_VFP),
26804   ARM_ARCH_OPT2 ("armv7-a",       ARM_ARCH_V7A,         FPU_ARCH_VFP, armv7a),
26805   ARM_ARCH_OPT2 ("armv7-r",       ARM_ARCH_V7R,         FPU_ARCH_VFP, armv7r),
26806   ARM_ARCH_OPT ("armv7-m",        ARM_ARCH_V7M,         FPU_ARCH_VFP),
26807   ARM_ARCH_OPT2 ("armv7e-m",      ARM_ARCH_V7EM,        FPU_ARCH_VFP, armv7em),
26808   ARM_ARCH_OPT ("armv8-m.base",   ARM_ARCH_V8M_BASE,    FPU_ARCH_VFP),
26809   ARM_ARCH_OPT2 ("armv8-m.main",  ARM_ARCH_V8M_MAIN,    FPU_ARCH_VFP,
26810                  armv8m_main),
26811   ARM_ARCH_OPT2 ("armv8.1-m.main", ARM_ARCH_V8_1M_MAIN, FPU_ARCH_VFP,
26812                  armv8_1m_main),
26813   ARM_ARCH_OPT2 ("armv8-a",       ARM_ARCH_V8A,         FPU_ARCH_VFP, armv8a),
26814   ARM_ARCH_OPT2 ("armv8.1-a",     ARM_ARCH_V8_1A,       FPU_ARCH_VFP, armv81a),
26815   ARM_ARCH_OPT2 ("armv8.2-a",     ARM_ARCH_V8_2A,       FPU_ARCH_VFP, armv82a),
26816   ARM_ARCH_OPT2 ("armv8.3-a",     ARM_ARCH_V8_3A,       FPU_ARCH_VFP, armv82a),
26817   ARM_ARCH_OPT2 ("armv8-r",       ARM_ARCH_V8R,         FPU_ARCH_VFP, armv8r),
26818   ARM_ARCH_OPT2 ("armv8.4-a",     ARM_ARCH_V8_4A,       FPU_ARCH_VFP, armv84a),
26819   ARM_ARCH_OPT2 ("armv8.5-a",     ARM_ARCH_V8_5A,       FPU_ARCH_VFP, armv85a),
26820   ARM_ARCH_OPT ("xscale",         ARM_ARCH_XSCALE,      FPU_ARCH_VFP),
26821   ARM_ARCH_OPT ("iwmmxt",         ARM_ARCH_IWMMXT,      FPU_ARCH_VFP),
26822   ARM_ARCH_OPT ("iwmmxt2",        ARM_ARCH_IWMMXT2,     FPU_ARCH_VFP),
26823   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE, NULL }
26824 };
26825 #undef ARM_ARCH_OPT
26826
26827 /* ISA extensions in the co-processor and main instruction set space.  */
26828
26829 struct arm_option_extension_value_table
26830 {
26831   const char *           name;
26832   size_t                 name_len;
26833   const arm_feature_set  merge_value;
26834   const arm_feature_set  clear_value;
26835   /* List of architectures for which an extension is available.  ARM_ARCH_NONE
26836      indicates that an extension is available for all architectures while
26837      ARM_ANY marks an empty entry.  */
26838   const arm_feature_set  allowed_archs[2];
26839 };
26840
26841 /* The following table must be in alphabetical order with a NULL last entry.  */
26842
26843 #define ARM_EXT_OPT(N, M, C, AA) { N, sizeof (N) - 1, M, C, { AA, ARM_ANY } }
26844 #define ARM_EXT_OPT2(N, M, C, AA1, AA2) { N, sizeof (N) - 1, M, C, {AA1, AA2} }
26845
26846 /* DEPRECATED: Refrain from using this table to add any new extensions, instead
26847    use the context sensitive approach using arm_ext_table's.  */
26848 static const struct arm_option_extension_value_table arm_extensions[] =
26849 {
26850   ARM_EXT_OPT ("crc",  ARCH_CRC_ARMV8, ARM_FEATURE_COPROC (CRC_EXT_ARMV8),
26851                          ARM_FEATURE_CORE_LOW (ARM_EXT_V8)),
26852   ARM_EXT_OPT ("crypto", FPU_ARCH_CRYPTO_NEON_VFP_ARMV8,
26853                          ARM_FEATURE_COPROC (FPU_CRYPTO_ARMV8),
26854                                    ARM_FEATURE_CORE_LOW (ARM_EXT_V8)),
26855   ARM_EXT_OPT ("dotprod", FPU_ARCH_DOTPROD_NEON_VFP_ARMV8,
26856                           ARM_FEATURE_COPROC (FPU_NEON_EXT_DOTPROD),
26857                           ARM_ARCH_V8_2A),
26858   ARM_EXT_OPT ("dsp",   ARM_FEATURE_CORE_LOW (ARM_EXT_V5ExP | ARM_EXT_V6_DSP),
26859                         ARM_FEATURE_CORE_LOW (ARM_EXT_V5ExP | ARM_EXT_V6_DSP),
26860                         ARM_FEATURE_CORE (ARM_EXT_V7M, ARM_EXT2_V8M)),
26861   ARM_EXT_OPT ("fp",     FPU_ARCH_VFP_ARMV8, ARM_FEATURE_COPROC (FPU_VFP_ARMV8),
26862                                    ARM_FEATURE_CORE_LOW (ARM_EXT_V8)),
26863   ARM_EXT_OPT ("fp16",  ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_INST),
26864                         ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_INST),
26865                         ARM_ARCH_V8_2A),
26866   ARM_EXT_OPT ("fp16fml",  ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_INST
26867                                                   | ARM_EXT2_FP16_FML),
26868                            ARM_FEATURE_CORE_HIGH (ARM_EXT2_FP16_INST
26869                                                   | ARM_EXT2_FP16_FML),
26870                            ARM_ARCH_V8_2A),
26871   ARM_EXT_OPT2 ("idiv", ARM_FEATURE_CORE_LOW (ARM_EXT_ADIV | ARM_EXT_DIV),
26872                         ARM_FEATURE_CORE_LOW (ARM_EXT_ADIV | ARM_EXT_DIV),
26873                         ARM_FEATURE_CORE_LOW (ARM_EXT_V7A),
26874                         ARM_FEATURE_CORE_LOW (ARM_EXT_V7R)),
26875   /* Duplicate entry for the purpose of allowing ARMv7 to match in presence of
26876      Thumb divide instruction.  Due to this having the same name as the
26877      previous entry, this will be ignored when doing command-line parsing and
26878      only considered by build attribute selection code.  */
26879   ARM_EXT_OPT ("idiv",  ARM_FEATURE_CORE_LOW (ARM_EXT_DIV),
26880                         ARM_FEATURE_CORE_LOW (ARM_EXT_DIV),
26881                         ARM_FEATURE_CORE_LOW (ARM_EXT_V7)),
26882   ARM_EXT_OPT ("iwmmxt",ARM_FEATURE_COPROC (ARM_CEXT_IWMMXT),
26883                         ARM_FEATURE_COPROC (ARM_CEXT_IWMMXT), ARM_ARCH_NONE),
26884   ARM_EXT_OPT ("iwmmxt2", ARM_FEATURE_COPROC (ARM_CEXT_IWMMXT2),
26885                         ARM_FEATURE_COPROC (ARM_CEXT_IWMMXT2), ARM_ARCH_NONE),
26886   ARM_EXT_OPT ("maverick", ARM_FEATURE_COPROC (ARM_CEXT_MAVERICK),
26887                         ARM_FEATURE_COPROC (ARM_CEXT_MAVERICK), ARM_ARCH_NONE),
26888   ARM_EXT_OPT2 ("mp",   ARM_FEATURE_CORE_LOW (ARM_EXT_MP),
26889                         ARM_FEATURE_CORE_LOW (ARM_EXT_MP),
26890                         ARM_FEATURE_CORE_LOW (ARM_EXT_V7A),
26891                         ARM_FEATURE_CORE_LOW (ARM_EXT_V7R)),
26892   ARM_EXT_OPT ("os",    ARM_FEATURE_CORE_LOW (ARM_EXT_OS),
26893                         ARM_FEATURE_CORE_LOW (ARM_EXT_OS),
26894                                    ARM_FEATURE_CORE_LOW (ARM_EXT_V6M)),
26895   ARM_EXT_OPT ("pan",   ARM_FEATURE_CORE_HIGH (ARM_EXT2_PAN),
26896                         ARM_FEATURE (ARM_EXT_V8, ARM_EXT2_PAN, 0),
26897                         ARM_FEATURE_CORE_HIGH (ARM_EXT2_V8A)),
26898   ARM_EXT_OPT ("predres", ARM_FEATURE_CORE_HIGH (ARM_EXT2_PREDRES),
26899                         ARM_FEATURE_CORE_HIGH (ARM_EXT2_PREDRES),
26900                         ARM_ARCH_V8A),
26901   ARM_EXT_OPT ("ras",   ARM_FEATURE_CORE_HIGH (ARM_EXT2_RAS),
26902                         ARM_FEATURE (ARM_EXT_V8, ARM_EXT2_RAS, 0),
26903                         ARM_FEATURE_CORE_HIGH (ARM_EXT2_V8A)),
26904   ARM_EXT_OPT ("rdma",  FPU_ARCH_NEON_VFP_ARMV8_1,
26905                         ARM_FEATURE_COPROC (FPU_NEON_ARMV8 | FPU_NEON_EXT_RDMA),
26906                         ARM_FEATURE_CORE_HIGH (ARM_EXT2_V8A)),
26907   ARM_EXT_OPT ("sb",    ARM_FEATURE_CORE_HIGH (ARM_EXT2_SB),
26908                         ARM_FEATURE_CORE_HIGH (ARM_EXT2_SB),
26909                         ARM_ARCH_V8A),
26910   ARM_EXT_OPT2 ("sec",  ARM_FEATURE_CORE_LOW (ARM_EXT_SEC),
26911                         ARM_FEATURE_CORE_LOW (ARM_EXT_SEC),
26912                         ARM_FEATURE_CORE_LOW (ARM_EXT_V6K),
26913                         ARM_FEATURE_CORE_LOW (ARM_EXT_V7A)),
26914   ARM_EXT_OPT ("simd",  FPU_ARCH_NEON_VFP_ARMV8,
26915                         ARM_FEATURE_COPROC (FPU_NEON_ARMV8),
26916                         ARM_FEATURE_CORE_LOW (ARM_EXT_V8)),
26917   ARM_EXT_OPT ("virt",  ARM_FEATURE_CORE_LOW (ARM_EXT_VIRT | ARM_EXT_ADIV
26918                                      | ARM_EXT_DIV),
26919                         ARM_FEATURE_CORE_LOW (ARM_EXT_VIRT),
26920                                    ARM_FEATURE_CORE_LOW (ARM_EXT_V7A)),
26921   ARM_EXT_OPT ("xscale",ARM_FEATURE_COPROC (ARM_CEXT_XSCALE),
26922                         ARM_FEATURE_COPROC (ARM_CEXT_XSCALE), ARM_ARCH_NONE),
26923   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE, { ARM_ARCH_NONE, ARM_ARCH_NONE } }
26924 };
26925 #undef ARM_EXT_OPT
26926
26927 /* ISA floating-point and Advanced SIMD extensions.  */
26928 struct arm_option_fpu_value_table
26929 {
26930   const char *           name;
26931   const arm_feature_set  value;
26932 };
26933
26934 /* This list should, at a minimum, contain all the fpu names
26935    recognized by GCC.  */
26936 static const struct arm_option_fpu_value_table arm_fpus[] =
26937 {
26938   {"softfpa",           FPU_NONE},
26939   {"fpe",               FPU_ARCH_FPE},
26940   {"fpe2",              FPU_ARCH_FPE},
26941   {"fpe3",              FPU_ARCH_FPA},  /* Third release supports LFM/SFM.  */
26942   {"fpa",               FPU_ARCH_FPA},
26943   {"fpa10",             FPU_ARCH_FPA},
26944   {"fpa11",             FPU_ARCH_FPA},
26945   {"arm7500fe",         FPU_ARCH_FPA},
26946   {"softvfp",           FPU_ARCH_VFP},
26947   {"softvfp+vfp",       FPU_ARCH_VFP_V2},
26948   {"vfp",               FPU_ARCH_VFP_V2},
26949   {"vfp9",              FPU_ARCH_VFP_V2},
26950   {"vfp3",              FPU_ARCH_VFP_V3}, /* Undocumented, use vfpv3.  */
26951   {"vfp10",             FPU_ARCH_VFP_V2},
26952   {"vfp10-r0",          FPU_ARCH_VFP_V1},
26953   {"vfpxd",             FPU_ARCH_VFP_V1xD},
26954   {"vfpv2",             FPU_ARCH_VFP_V2},
26955   {"vfpv3",             FPU_ARCH_VFP_V3},
26956   {"vfpv3-fp16",        FPU_ARCH_VFP_V3_FP16},
26957   {"vfpv3-d16",         FPU_ARCH_VFP_V3D16},
26958   {"vfpv3-d16-fp16",    FPU_ARCH_VFP_V3D16_FP16},
26959   {"vfpv3xd",           FPU_ARCH_VFP_V3xD},
26960   {"vfpv3xd-fp16",      FPU_ARCH_VFP_V3xD_FP16},
26961   {"arm1020t",          FPU_ARCH_VFP_V1},
26962   {"arm1020e",          FPU_ARCH_VFP_V2},
26963   {"arm1136jfs",        FPU_ARCH_VFP_V2}, /* Undocumented, use arm1136jf-s.  */
26964   {"arm1136jf-s",       FPU_ARCH_VFP_V2},
26965   {"maverick",          FPU_ARCH_MAVERICK},
26966   {"neon",              FPU_ARCH_VFP_V3_PLUS_NEON_V1},
26967   {"neon-vfpv3",        FPU_ARCH_VFP_V3_PLUS_NEON_V1},
26968   {"neon-fp16",         FPU_ARCH_NEON_FP16},
26969   {"vfpv4",             FPU_ARCH_VFP_V4},
26970   {"vfpv4-d16",         FPU_ARCH_VFP_V4D16},
26971   {"fpv4-sp-d16",       FPU_ARCH_VFP_V4_SP_D16},
26972   {"fpv5-d16",          FPU_ARCH_VFP_V5D16},
26973   {"fpv5-sp-d16",       FPU_ARCH_VFP_V5_SP_D16},
26974   {"neon-vfpv4",        FPU_ARCH_NEON_VFP_V4},
26975   {"fp-armv8",          FPU_ARCH_VFP_ARMV8},
26976   {"neon-fp-armv8",     FPU_ARCH_NEON_VFP_ARMV8},
26977   {"crypto-neon-fp-armv8",
26978                         FPU_ARCH_CRYPTO_NEON_VFP_ARMV8},
26979   {"neon-fp-armv8.1",   FPU_ARCH_NEON_VFP_ARMV8_1},
26980   {"crypto-neon-fp-armv8.1",
26981                         FPU_ARCH_CRYPTO_NEON_VFP_ARMV8_1},
26982   {NULL,                ARM_ARCH_NONE}
26983 };
26984
26985 struct arm_option_value_table
26986 {
26987   const char *name;
26988   long value;
26989 };
26990
26991 static const struct arm_option_value_table arm_float_abis[] =
26992 {
26993   {"hard",      ARM_FLOAT_ABI_HARD},
26994   {"softfp",    ARM_FLOAT_ABI_SOFTFP},
26995   {"soft",      ARM_FLOAT_ABI_SOFT},
26996   {NULL,        0}
26997 };
26998
26999 #ifdef OBJ_ELF
27000 /* We only know how to output GNU and ver 4/5 (AAELF) formats.  */
27001 static const struct arm_option_value_table arm_eabis[] =
27002 {
27003   {"gnu",       EF_ARM_EABI_UNKNOWN},
27004   {"4",         EF_ARM_EABI_VER4},
27005   {"5",         EF_ARM_EABI_VER5},
27006   {NULL,        0}
27007 };
27008 #endif
27009
27010 struct arm_long_option_table
27011 {
27012   const char * option;                  /* Substring to match.  */
27013   const char * help;                    /* Help information.  */
27014   int (* func) (const char * subopt);   /* Function to decode sub-option.  */
27015   const char * deprecated;              /* If non-null, print this message.  */
27016 };
27017
27018 static bfd_boolean
27019 arm_parse_extension (const char *str, const arm_feature_set *opt_set,
27020                      arm_feature_set *ext_set,
27021                      const struct arm_ext_table *ext_table)
27022 {
27023   /* We insist on extensions being specified in alphabetical order, and with
27024      extensions being added before being removed.  We achieve this by having
27025      the global ARM_EXTENSIONS table in alphabetical order, and using the
27026      ADDING_VALUE variable to indicate whether we are adding an extension (1)
27027      or removing it (0) and only allowing it to change in the order
27028      -1 -> 1 -> 0.  */
27029   const struct arm_option_extension_value_table * opt = NULL;
27030   const arm_feature_set arm_any = ARM_ANY;
27031   int adding_value = -1;
27032
27033   while (str != NULL && *str != 0)
27034     {
27035       const char *ext;
27036       size_t len;
27037
27038       if (*str != '+')
27039         {
27040           as_bad (_("invalid architectural extension"));
27041           return FALSE;
27042         }
27043
27044       str++;
27045       ext = strchr (str, '+');
27046
27047       if (ext != NULL)
27048         len = ext - str;
27049       else
27050         len = strlen (str);
27051
27052       if (len >= 2 && strncmp (str, "no", 2) == 0)
27053         {
27054           if (adding_value != 0)
27055             {
27056               adding_value = 0;
27057               opt = arm_extensions;
27058             }
27059
27060           len -= 2;
27061           str += 2;
27062         }
27063       else if (len > 0)
27064         {
27065           if (adding_value == -1)
27066             {
27067               adding_value = 1;
27068               opt = arm_extensions;
27069             }
27070           else if (adding_value != 1)
27071             {
27072               as_bad (_("must specify extensions to add before specifying "
27073                         "those to remove"));
27074               return FALSE;
27075             }
27076         }
27077
27078       if (len == 0)
27079         {
27080           as_bad (_("missing architectural extension"));
27081           return FALSE;
27082         }
27083
27084       gas_assert (adding_value != -1);
27085       gas_assert (opt != NULL);
27086
27087       if (ext_table != NULL)
27088         {
27089           const struct arm_ext_table * ext_opt = ext_table;
27090           bfd_boolean found = FALSE;
27091           for (; ext_opt->name != NULL; ext_opt++)
27092             if (ext_opt->name_len == len
27093                 && strncmp (ext_opt->name, str, len) == 0)
27094               {
27095                 if (adding_value)
27096                   {
27097                     if (ARM_FEATURE_ZERO (ext_opt->merge))
27098                         /* TODO: Option not supported.  When we remove the
27099                            legacy table this case should error out.  */
27100                         continue;
27101
27102                     ARM_MERGE_FEATURE_SETS (*ext_set, *ext_set, ext_opt->merge);
27103                   }
27104                 else
27105                   {
27106                     if (ARM_FEATURE_ZERO (ext_opt->clear))
27107                         /* TODO: Option not supported.  When we remove the
27108                            legacy table this case should error out.  */
27109                         continue;
27110                     ARM_CLEAR_FEATURE (*ext_set, *ext_set, ext_opt->clear);
27111                   }
27112                 found = TRUE;
27113                 break;
27114               }
27115           if (found)
27116             {
27117               str = ext;
27118               continue;
27119             }
27120         }
27121
27122       /* Scan over the options table trying to find an exact match. */
27123       for (; opt->name != NULL; opt++)
27124         if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
27125           {
27126             int i, nb_allowed_archs =
27127               sizeof (opt->allowed_archs) / sizeof (opt->allowed_archs[0]);
27128             /* Check we can apply the extension to this architecture.  */
27129             for (i = 0; i < nb_allowed_archs; i++)
27130               {
27131                 /* Empty entry.  */
27132                 if (ARM_FEATURE_EQUAL (opt->allowed_archs[i], arm_any))
27133                   continue;
27134                 if (ARM_FSET_CPU_SUBSET (opt->allowed_archs[i], *opt_set))
27135                   break;
27136               }
27137             if (i == nb_allowed_archs)
27138               {
27139                 as_bad (_("extension does not apply to the base architecture"));
27140                 return FALSE;
27141               }
27142
27143             /* Add or remove the extension.  */
27144             if (adding_value)
27145               ARM_MERGE_FEATURE_SETS (*ext_set, *ext_set, opt->merge_value);
27146             else
27147               ARM_CLEAR_FEATURE (*ext_set, *ext_set, opt->clear_value);
27148
27149             /* Allowing Thumb division instructions for ARMv7 in autodetection
27150                rely on this break so that duplicate extensions (extensions
27151                with the same name as a previous extension in the list) are not
27152                considered for command-line parsing.  */
27153             break;
27154           }
27155
27156       if (opt->name == NULL)
27157         {
27158           /* Did we fail to find an extension because it wasn't specified in
27159              alphabetical order, or because it does not exist?  */
27160
27161           for (opt = arm_extensions; opt->name != NULL; opt++)
27162             if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
27163               break;
27164
27165           if (opt->name == NULL)
27166             as_bad (_("unknown architectural extension `%s'"), str);
27167           else
27168             as_bad (_("architectural extensions must be specified in "
27169                       "alphabetical order"));
27170
27171           return FALSE;
27172         }
27173       else
27174         {
27175           /* We should skip the extension we've just matched the next time
27176              round.  */
27177           opt++;
27178         }
27179
27180       str = ext;
27181     };
27182
27183   return TRUE;
27184 }
27185
27186 static bfd_boolean
27187 arm_parse_cpu (const char *str)
27188 {
27189   const struct arm_cpu_option_table *opt;
27190   const char *ext = strchr (str, '+');
27191   size_t len;
27192
27193   if (ext != NULL)
27194     len = ext - str;
27195   else
27196     len = strlen (str);
27197
27198   if (len == 0)
27199     {
27200       as_bad (_("missing cpu name `%s'"), str);
27201       return FALSE;
27202     }
27203
27204   for (opt = arm_cpus; opt->name != NULL; opt++)
27205     if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
27206       {
27207         mcpu_cpu_opt = &opt->value;
27208         if (mcpu_ext_opt == NULL)
27209           mcpu_ext_opt = XNEW (arm_feature_set);
27210         *mcpu_ext_opt = opt->ext;
27211         mcpu_fpu_opt = &opt->default_fpu;
27212         if (opt->canonical_name)
27213           {
27214             gas_assert (sizeof selected_cpu_name > strlen (opt->canonical_name));
27215             strcpy (selected_cpu_name, opt->canonical_name);
27216           }
27217         else
27218           {
27219             size_t i;
27220
27221             if (len >= sizeof selected_cpu_name)
27222               len = (sizeof selected_cpu_name) - 1;
27223
27224             for (i = 0; i < len; i++)
27225               selected_cpu_name[i] = TOUPPER (opt->name[i]);
27226             selected_cpu_name[i] = 0;
27227           }
27228
27229         if (ext != NULL)
27230           return arm_parse_extension (ext, mcpu_cpu_opt, mcpu_ext_opt, NULL);
27231
27232         return TRUE;
27233       }
27234
27235   as_bad (_("unknown cpu `%s'"), str);
27236   return FALSE;
27237 }
27238
27239 static bfd_boolean
27240 arm_parse_arch (const char *str)
27241 {
27242   const struct arm_arch_option_table *opt;
27243   const char *ext = strchr (str, '+');
27244   size_t len;
27245
27246   if (ext != NULL)
27247     len = ext - str;
27248   else
27249     len = strlen (str);
27250
27251   if (len == 0)
27252     {
27253       as_bad (_("missing architecture name `%s'"), str);
27254       return FALSE;
27255     }
27256
27257   for (opt = arm_archs; opt->name != NULL; opt++)
27258     if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
27259       {
27260         march_cpu_opt = &opt->value;
27261         if (march_ext_opt == NULL)
27262           march_ext_opt = XNEW (arm_feature_set);
27263         *march_ext_opt = arm_arch_none;
27264         march_fpu_opt = &opt->default_fpu;
27265         strcpy (selected_cpu_name, opt->name);
27266
27267         if (ext != NULL)
27268           return arm_parse_extension (ext, march_cpu_opt, march_ext_opt,
27269                                       opt->ext_table);
27270
27271         return TRUE;
27272       }
27273
27274   as_bad (_("unknown architecture `%s'\n"), str);
27275   return FALSE;
27276 }
27277
27278 static bfd_boolean
27279 arm_parse_fpu (const char * str)
27280 {
27281   const struct arm_option_fpu_value_table * opt;
27282
27283   for (opt = arm_fpus; opt->name != NULL; opt++)
27284     if (streq (opt->name, str))
27285       {
27286         mfpu_opt = &opt->value;
27287         return TRUE;
27288       }
27289
27290   as_bad (_("unknown floating point format `%s'\n"), str);
27291   return FALSE;
27292 }
27293
27294 static bfd_boolean
27295 arm_parse_float_abi (const char * str)
27296 {
27297   const struct arm_option_value_table * opt;
27298
27299   for (opt = arm_float_abis; opt->name != NULL; opt++)
27300     if (streq (opt->name, str))
27301       {
27302         mfloat_abi_opt = opt->value;
27303         return TRUE;
27304       }
27305
27306   as_bad (_("unknown floating point abi `%s'\n"), str);
27307   return FALSE;
27308 }
27309
27310 #ifdef OBJ_ELF
27311 static bfd_boolean
27312 arm_parse_eabi (const char * str)
27313 {
27314   const struct arm_option_value_table *opt;
27315
27316   for (opt = arm_eabis; opt->name != NULL; opt++)
27317     if (streq (opt->name, str))
27318       {
27319         meabi_flags = opt->value;
27320         return TRUE;
27321       }
27322   as_bad (_("unknown EABI `%s'\n"), str);
27323   return FALSE;
27324 }
27325 #endif
27326
27327 static bfd_boolean
27328 arm_parse_it_mode (const char * str)
27329 {
27330   bfd_boolean ret = TRUE;
27331
27332   if (streq ("arm", str))
27333     implicit_it_mode = IMPLICIT_IT_MODE_ARM;
27334   else if (streq ("thumb", str))
27335     implicit_it_mode = IMPLICIT_IT_MODE_THUMB;
27336   else if (streq ("always", str))
27337     implicit_it_mode = IMPLICIT_IT_MODE_ALWAYS;
27338   else if (streq ("never", str))
27339     implicit_it_mode = IMPLICIT_IT_MODE_NEVER;
27340   else
27341     {
27342       as_bad (_("unknown implicit IT mode `%s', should be "\
27343                 "arm, thumb, always, or never."), str);
27344       ret = FALSE;
27345     }
27346
27347   return ret;
27348 }
27349
27350 static bfd_boolean
27351 arm_ccs_mode (const char * unused ATTRIBUTE_UNUSED)
27352 {
27353   codecomposer_syntax = TRUE;
27354   arm_comment_chars[0] = ';';
27355   arm_line_separator_chars[0] = 0;
27356   return TRUE;
27357 }
27358
27359 struct arm_long_option_table arm_long_opts[] =
27360 {
27361   {"mcpu=", N_("<cpu name>\t  assemble for CPU <cpu name>"),
27362    arm_parse_cpu, NULL},
27363   {"march=", N_("<arch name>\t  assemble for architecture <arch name>"),
27364    arm_parse_arch, NULL},
27365   {"mfpu=", N_("<fpu name>\t  assemble for FPU architecture <fpu name>"),
27366    arm_parse_fpu, NULL},
27367   {"mfloat-abi=", N_("<abi>\t  assemble for floating point ABI <abi>"),
27368    arm_parse_float_abi, NULL},
27369 #ifdef OBJ_ELF
27370   {"meabi=", N_("<ver>\t\t  assemble for eabi version <ver>"),
27371    arm_parse_eabi, NULL},
27372 #endif
27373   {"mimplicit-it=", N_("<mode>\t  controls implicit insertion of IT instructions"),
27374    arm_parse_it_mode, NULL},
27375   {"mccs", N_("\t\t\t  TI CodeComposer Studio syntax compatibility mode"),
27376    arm_ccs_mode, NULL},
27377   {NULL, NULL, 0, NULL}
27378 };
27379
27380 int
27381 md_parse_option (int c, const char * arg)
27382 {
27383   struct arm_option_table *opt;
27384   const struct arm_legacy_option_table *fopt;
27385   struct arm_long_option_table *lopt;
27386
27387   switch (c)
27388     {
27389 #ifdef OPTION_EB
27390     case OPTION_EB:
27391       target_big_endian = 1;
27392       break;
27393 #endif
27394
27395 #ifdef OPTION_EL
27396     case OPTION_EL:
27397       target_big_endian = 0;
27398       break;
27399 #endif
27400
27401     case OPTION_FIX_V4BX:
27402       fix_v4bx = TRUE;
27403       break;
27404
27405 #ifdef OBJ_ELF
27406     case OPTION_FDPIC:
27407       arm_fdpic = TRUE;
27408       break;
27409 #endif /* OBJ_ELF */
27410
27411     case 'a':
27412       /* Listing option.  Just ignore these, we don't support additional
27413          ones.  */
27414       return 0;
27415
27416     default:
27417       for (opt = arm_opts; opt->option != NULL; opt++)
27418         {
27419           if (c == opt->option[0]
27420               && ((arg == NULL && opt->option[1] == 0)
27421                   || streq (arg, opt->option + 1)))
27422             {
27423               /* If the option is deprecated, tell the user.  */
27424               if (warn_on_deprecated && opt->deprecated != NULL)
27425                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c,
27426                            arg ? arg : "", _(opt->deprecated));
27427
27428               if (opt->var != NULL)
27429                 *opt->var = opt->value;
27430
27431               return 1;
27432             }
27433         }
27434
27435       for (fopt = arm_legacy_opts; fopt->option != NULL; fopt++)
27436         {
27437           if (c == fopt->option[0]
27438               && ((arg == NULL && fopt->option[1] == 0)
27439                   || streq (arg, fopt->option + 1)))
27440             {
27441               /* If the option is deprecated, tell the user.  */
27442               if (warn_on_deprecated && fopt->deprecated != NULL)
27443                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c,
27444                            arg ? arg : "", _(fopt->deprecated));
27445
27446               if (fopt->var != NULL)
27447                 *fopt->var = &fopt->value;
27448
27449               return 1;
27450             }
27451         }
27452
27453       for (lopt = arm_long_opts; lopt->option != NULL; lopt++)
27454         {
27455           /* These options are expected to have an argument.  */
27456           if (c == lopt->option[0]
27457               && arg != NULL
27458               && strncmp (arg, lopt->option + 1,
27459                           strlen (lopt->option + 1)) == 0)
27460             {
27461               /* If the option is deprecated, tell the user.  */
27462               if (warn_on_deprecated && lopt->deprecated != NULL)
27463                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c, arg,
27464                            _(lopt->deprecated));
27465
27466               /* Call the sup-option parser.  */
27467               return lopt->func (arg + strlen (lopt->option) - 1);
27468             }
27469         }
27470
27471       return 0;
27472     }
27473
27474   return 1;
27475 }
27476
27477 void
27478 md_show_usage (FILE * fp)
27479 {
27480   struct arm_option_table *opt;
27481   struct arm_long_option_table *lopt;
27482
27483   fprintf (fp, _(" ARM-specific assembler options:\n"));
27484
27485   for (opt = arm_opts; opt->option != NULL; opt++)
27486     if (opt->help != NULL)
27487       fprintf (fp, "  -%-23s%s\n", opt->option, _(opt->help));
27488
27489   for (lopt = arm_long_opts; lopt->option != NULL; lopt++)
27490     if (lopt->help != NULL)
27491       fprintf (fp, "  -%s%s\n", lopt->option, _(lopt->help));
27492
27493 #ifdef OPTION_EB
27494   fprintf (fp, _("\
27495   -EB                     assemble code for a big-endian cpu\n"));
27496 #endif
27497
27498 #ifdef OPTION_EL
27499   fprintf (fp, _("\
27500   -EL                     assemble code for a little-endian cpu\n"));
27501 #endif
27502
27503   fprintf (fp, _("\
27504   --fix-v4bx              Allow BX in ARMv4 code\n"));
27505
27506 #ifdef OBJ_ELF
27507   fprintf (fp, _("\
27508   --fdpic                 generate an FDPIC object file\n"));
27509 #endif /* OBJ_ELF */
27510 }
27511
27512 #ifdef OBJ_ELF
27513
27514 typedef struct
27515 {
27516   int val;
27517   arm_feature_set flags;
27518 } cpu_arch_ver_table;
27519
27520 /* Mapping from CPU features to EABI CPU arch values.  Table must be sorted
27521    chronologically for architectures, with an exception for ARMv6-M and
27522    ARMv6S-M due to legacy reasons.  No new architecture should have a
27523    special case.  This allows for build attribute selection results to be
27524    stable when new architectures are added.  */
27525 static const cpu_arch_ver_table cpu_arch_ver[] =
27526 {
27527     {TAG_CPU_ARCH_PRE_V4,     ARM_ARCH_V1},
27528     {TAG_CPU_ARCH_PRE_V4,     ARM_ARCH_V2},
27529     {TAG_CPU_ARCH_PRE_V4,     ARM_ARCH_V2S},
27530     {TAG_CPU_ARCH_PRE_V4,     ARM_ARCH_V3},
27531     {TAG_CPU_ARCH_PRE_V4,     ARM_ARCH_V3M},
27532     {TAG_CPU_ARCH_V4,         ARM_ARCH_V4xM},
27533     {TAG_CPU_ARCH_V4,         ARM_ARCH_V4},
27534     {TAG_CPU_ARCH_V4T,        ARM_ARCH_V4TxM},
27535     {TAG_CPU_ARCH_V4T,        ARM_ARCH_V4T},
27536     {TAG_CPU_ARCH_V5T,        ARM_ARCH_V5xM},
27537     {TAG_CPU_ARCH_V5T,        ARM_ARCH_V5},
27538     {TAG_CPU_ARCH_V5T,        ARM_ARCH_V5TxM},
27539     {TAG_CPU_ARCH_V5T,        ARM_ARCH_V5T},
27540     {TAG_CPU_ARCH_V5TE,       ARM_ARCH_V5TExP},
27541     {TAG_CPU_ARCH_V5TE,       ARM_ARCH_V5TE},
27542     {TAG_CPU_ARCH_V5TEJ,      ARM_ARCH_V5TEJ},
27543     {TAG_CPU_ARCH_V6,         ARM_ARCH_V6},
27544     {TAG_CPU_ARCH_V6KZ,       ARM_ARCH_V6Z},
27545     {TAG_CPU_ARCH_V6KZ,       ARM_ARCH_V6KZ},
27546     {TAG_CPU_ARCH_V6K,        ARM_ARCH_V6K},
27547     {TAG_CPU_ARCH_V6T2,       ARM_ARCH_V6T2},
27548     {TAG_CPU_ARCH_V6T2,       ARM_ARCH_V6KT2},
27549     {TAG_CPU_ARCH_V6T2,       ARM_ARCH_V6ZT2},
27550     {TAG_CPU_ARCH_V6T2,       ARM_ARCH_V6KZT2},
27551
27552     /* When assembling a file with only ARMv6-M or ARMv6S-M instruction, GNU as
27553        always selected build attributes to match those of ARMv6-M
27554        (resp. ARMv6S-M).  However, due to these architectures being a strict
27555        subset of ARMv7-M in terms of instructions available, ARMv7-M attributes
27556        would be selected when fully respecting chronology of architectures.
27557        It is thus necessary to make a special case of ARMv6-M and ARMv6S-M and
27558        move them before ARMv7 architectures.  */
27559     {TAG_CPU_ARCH_V6_M,       ARM_ARCH_V6M},
27560     {TAG_CPU_ARCH_V6S_M,      ARM_ARCH_V6SM},
27561
27562     {TAG_CPU_ARCH_V7,         ARM_ARCH_V7},
27563     {TAG_CPU_ARCH_V7,         ARM_ARCH_V7A},
27564     {TAG_CPU_ARCH_V7,         ARM_ARCH_V7R},
27565     {TAG_CPU_ARCH_V7,         ARM_ARCH_V7M},
27566     {TAG_CPU_ARCH_V7,         ARM_ARCH_V7VE},
27567     {TAG_CPU_ARCH_V7E_M,      ARM_ARCH_V7EM},
27568     {TAG_CPU_ARCH_V8,         ARM_ARCH_V8A},
27569     {TAG_CPU_ARCH_V8,         ARM_ARCH_V8_1A},
27570     {TAG_CPU_ARCH_V8,         ARM_ARCH_V8_2A},
27571     {TAG_CPU_ARCH_V8,         ARM_ARCH_V8_3A},
27572     {TAG_CPU_ARCH_V8M_BASE,   ARM_ARCH_V8M_BASE},
27573     {TAG_CPU_ARCH_V8M_MAIN,   ARM_ARCH_V8M_MAIN},
27574     {TAG_CPU_ARCH_V8R,        ARM_ARCH_V8R},
27575     {TAG_CPU_ARCH_V8,         ARM_ARCH_V8_4A},
27576     {TAG_CPU_ARCH_V8,         ARM_ARCH_V8_5A},
27577     {TAG_CPU_ARCH_V8_1M_MAIN, ARM_ARCH_V8_1M_MAIN},
27578     {-1,                      ARM_ARCH_NONE}
27579 };
27580
27581 /* Set an attribute if it has not already been set by the user.  */
27582
27583 static void
27584 aeabi_set_attribute_int (int tag, int value)
27585 {
27586   if (tag < 1
27587       || tag >= NUM_KNOWN_OBJ_ATTRIBUTES
27588       || !attributes_set_explicitly[tag])
27589     bfd_elf_add_proc_attr_int (stdoutput, tag, value);
27590 }
27591
27592 static void
27593 aeabi_set_attribute_string (int tag, const char *value)
27594 {
27595   if (tag < 1
27596       || tag >= NUM_KNOWN_OBJ_ATTRIBUTES
27597       || !attributes_set_explicitly[tag])
27598     bfd_elf_add_proc_attr_string (stdoutput, tag, value);
27599 }
27600
27601 /* Return whether features in the *NEEDED feature set are available via
27602    extensions for the architecture whose feature set is *ARCH_FSET.  */
27603
27604 static bfd_boolean
27605 have_ext_for_needed_feat_p (const arm_feature_set *arch_fset,
27606                             const arm_feature_set *needed)
27607 {
27608   int i, nb_allowed_archs;
27609   arm_feature_set ext_fset;
27610   const struct arm_option_extension_value_table *opt;
27611
27612   ext_fset = arm_arch_none;
27613   for (opt = arm_extensions; opt->name != NULL; opt++)
27614     {
27615       /* Extension does not provide any feature we need.  */
27616       if (!ARM_CPU_HAS_FEATURE (*needed, opt->merge_value))
27617         continue;
27618
27619       nb_allowed_archs =
27620         sizeof (opt->allowed_archs) / sizeof (opt->allowed_archs[0]);
27621       for (i = 0; i < nb_allowed_archs; i++)
27622         {
27623           /* Empty entry.  */
27624           if (ARM_FEATURE_EQUAL (opt->allowed_archs[i], arm_arch_any))
27625             break;
27626
27627           /* Extension is available, add it.  */
27628           if (ARM_FSET_CPU_SUBSET (opt->allowed_archs[i], *arch_fset))
27629             ARM_MERGE_FEATURE_SETS (ext_fset, ext_fset, opt->merge_value);
27630         }
27631     }
27632
27633   /* Can we enable all features in *needed?  */
27634   return ARM_FSET_CPU_SUBSET (*needed, ext_fset);
27635 }
27636
27637 /* Select value for Tag_CPU_arch and Tag_CPU_arch_profile build attributes for
27638    a given architecture feature set *ARCH_EXT_FSET including extension feature
27639    set *EXT_FSET.  Selection logic used depend on EXACT_MATCH:
27640    - if true, check for an exact match of the architecture modulo extensions;
27641    - otherwise, select build attribute value of the first superset
27642      architecture released so that results remains stable when new architectures
27643      are added.
27644    For -march/-mcpu=all the build attribute value of the most featureful
27645    architecture is returned.  Tag_CPU_arch_profile result is returned in
27646    PROFILE.  */
27647
27648 static int
27649 get_aeabi_cpu_arch_from_fset (const arm_feature_set *arch_ext_fset,
27650                               const arm_feature_set *ext_fset,
27651                               char *profile, int exact_match)
27652 {
27653   arm_feature_set arch_fset;
27654   const cpu_arch_ver_table *p_ver, *p_ver_ret = NULL;
27655
27656   /* Select most featureful architecture with all its extensions if building
27657      for -march=all as the feature sets used to set build attributes.  */
27658   if (ARM_FEATURE_EQUAL (*arch_ext_fset, arm_arch_any))
27659     {
27660       /* Force revisiting of decision for each new architecture.  */
27661       gas_assert (MAX_TAG_CPU_ARCH <= TAG_CPU_ARCH_V8_1M_MAIN);
27662       *profile = 'A';
27663       return TAG_CPU_ARCH_V8;
27664     }
27665
27666   ARM_CLEAR_FEATURE (arch_fset, *arch_ext_fset, *ext_fset);
27667
27668   for (p_ver = cpu_arch_ver; p_ver->val != -1; p_ver++)
27669     {
27670       arm_feature_set known_arch_fset;
27671
27672       ARM_CLEAR_FEATURE (known_arch_fset, p_ver->flags, fpu_any);
27673       if (exact_match)
27674         {
27675           /* Base architecture match user-specified architecture and
27676              extensions, eg. ARMv6S-M matching -march=armv6-m+os.  */
27677           if (ARM_FEATURE_EQUAL (*arch_ext_fset, known_arch_fset))
27678             {
27679               p_ver_ret = p_ver;
27680               goto found;
27681             }
27682           /* Base architecture match user-specified architecture only
27683              (eg. ARMv6-M in the same case as above).  Record it in case we
27684              find a match with above condition.  */
27685           else if (p_ver_ret == NULL
27686                    && ARM_FEATURE_EQUAL (arch_fset, known_arch_fset))
27687             p_ver_ret = p_ver;
27688         }
27689       else
27690         {
27691
27692           /* Architecture has all features wanted.  */
27693           if (ARM_FSET_CPU_SUBSET (arch_fset, known_arch_fset))
27694             {
27695               arm_feature_set added_fset;
27696
27697               /* Compute features added by this architecture over the one
27698                  recorded in p_ver_ret.  */
27699               if (p_ver_ret != NULL)
27700                 ARM_CLEAR_FEATURE (added_fset, known_arch_fset,
27701                                    p_ver_ret->flags);
27702               /* First architecture that match incl. with extensions, or the
27703                  only difference in features over the recorded match is
27704                  features that were optional and are now mandatory.  */
27705               if (p_ver_ret == NULL
27706                   || ARM_FSET_CPU_SUBSET (added_fset, arch_fset))
27707                 {
27708                   p_ver_ret = p_ver;
27709                   goto found;
27710                 }
27711             }
27712           else if (p_ver_ret == NULL)
27713             {
27714               arm_feature_set needed_ext_fset;
27715
27716               ARM_CLEAR_FEATURE (needed_ext_fset, arch_fset, known_arch_fset);
27717
27718               /* Architecture has all features needed when using some
27719                  extensions.  Record it and continue searching in case there
27720                  exist an architecture providing all needed features without
27721                  the need for extensions (eg. ARMv6S-M Vs ARMv6-M with
27722                  OS extension).  */
27723               if (have_ext_for_needed_feat_p (&known_arch_fset,
27724                                               &needed_ext_fset))
27725                 p_ver_ret = p_ver;
27726             }
27727         }
27728     }
27729
27730   if (p_ver_ret == NULL)
27731     return -1;
27732
27733 found:
27734   /* Tag_CPU_arch_profile.  */
27735   if (ARM_CPU_HAS_FEATURE (p_ver_ret->flags, arm_ext_v7a)
27736       || ARM_CPU_HAS_FEATURE (p_ver_ret->flags, arm_ext_v8)
27737       || (ARM_CPU_HAS_FEATURE (p_ver_ret->flags, arm_ext_atomics)
27738           && !ARM_CPU_HAS_FEATURE (p_ver_ret->flags, arm_ext_v8m_m_only)))
27739     *profile = 'A';
27740   else if (ARM_CPU_HAS_FEATURE (p_ver_ret->flags, arm_ext_v7r))
27741     *profile = 'R';
27742   else if (ARM_CPU_HAS_FEATURE (p_ver_ret->flags, arm_ext_m))
27743     *profile = 'M';
27744   else
27745     *profile = '\0';
27746   return p_ver_ret->val;
27747 }
27748
27749 /* Set the public EABI object attributes.  */
27750
27751 static void
27752 aeabi_set_public_attributes (void)
27753 {
27754   char profile = '\0';
27755   int arch = -1;
27756   int virt_sec = 0;
27757   int fp16_optional = 0;
27758   int skip_exact_match = 0;
27759   arm_feature_set flags, flags_arch, flags_ext;
27760
27761   /* Autodetection mode, choose the architecture based the instructions
27762      actually used.  */
27763   if (no_cpu_selected ())
27764     {
27765       ARM_MERGE_FEATURE_SETS (flags, arm_arch_used, thumb_arch_used);
27766
27767       if (ARM_CPU_HAS_FEATURE (arm_arch_used, arm_arch_any))
27768         ARM_MERGE_FEATURE_SETS (flags, flags, arm_ext_v1);
27769
27770       if (ARM_CPU_HAS_FEATURE (thumb_arch_used, arm_arch_any))
27771         ARM_MERGE_FEATURE_SETS (flags, flags, arm_ext_v4t);
27772
27773       /* Code run during relaxation relies on selected_cpu being set.  */
27774       ARM_CLEAR_FEATURE (flags_arch, flags, fpu_any);
27775       flags_ext = arm_arch_none;
27776       ARM_CLEAR_FEATURE (selected_arch, flags_arch, flags_ext);
27777       selected_ext = flags_ext;
27778       selected_cpu = flags;
27779     }
27780   /* Otherwise, choose the architecture based on the capabilities of the
27781      requested cpu.  */
27782   else
27783     {
27784       ARM_MERGE_FEATURE_SETS (flags_arch, selected_arch, selected_ext);
27785       ARM_CLEAR_FEATURE (flags_arch, flags_arch, fpu_any);
27786       flags_ext = selected_ext;
27787       flags = selected_cpu;
27788     }
27789   ARM_MERGE_FEATURE_SETS (flags, flags, selected_fpu);
27790
27791   /* Allow the user to override the reported architecture.  */
27792   if (!ARM_FEATURE_ZERO (selected_object_arch))
27793     {
27794       ARM_CLEAR_FEATURE (flags_arch, selected_object_arch, fpu_any);
27795       flags_ext = arm_arch_none;
27796     }
27797   else
27798     skip_exact_match = ARM_FEATURE_EQUAL (selected_cpu, arm_arch_any);
27799
27800   /* When this function is run again after relaxation has happened there is no
27801      way to determine whether an architecture or CPU was specified by the user:
27802      - selected_cpu is set above for relaxation to work;
27803      - march_cpu_opt is not set if only -mcpu or .cpu is used;
27804      - mcpu_cpu_opt is set to arm_arch_any for autodetection.
27805      Therefore, if not in -march=all case we first try an exact match and fall
27806      back to autodetection.  */
27807   if (!skip_exact_match)
27808     arch = get_aeabi_cpu_arch_from_fset (&flags_arch, &flags_ext, &profile, 1);
27809   if (arch == -1)
27810     arch = get_aeabi_cpu_arch_from_fset (&flags_arch, &flags_ext, &profile, 0);
27811   if (arch == -1)
27812     as_bad (_("no architecture contains all the instructions used\n"));
27813
27814   /* Tag_CPU_name.  */
27815   if (selected_cpu_name[0])
27816     {
27817       char *q;
27818
27819       q = selected_cpu_name;
27820       if (strncmp (q, "armv", 4) == 0)
27821         {
27822           int i;
27823
27824           q += 4;
27825           for (i = 0; q[i]; i++)
27826             q[i] = TOUPPER (q[i]);
27827         }
27828       aeabi_set_attribute_string (Tag_CPU_name, q);
27829     }
27830
27831   /* Tag_CPU_arch.  */
27832   aeabi_set_attribute_int (Tag_CPU_arch, arch);
27833
27834   /* Tag_CPU_arch_profile.  */
27835   if (profile != '\0')
27836     aeabi_set_attribute_int (Tag_CPU_arch_profile, profile);
27837
27838   /* Tag_DSP_extension.  */
27839   if (ARM_CPU_HAS_FEATURE (selected_ext, arm_ext_dsp))
27840     aeabi_set_attribute_int (Tag_DSP_extension, 1);
27841
27842   ARM_CLEAR_FEATURE (flags_arch, flags, fpu_any);
27843   /* Tag_ARM_ISA_use.  */
27844   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v1)
27845       || ARM_FEATURE_ZERO (flags_arch))
27846     aeabi_set_attribute_int (Tag_ARM_ISA_use, 1);
27847
27848   /* Tag_THUMB_ISA_use.  */
27849   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v4t)
27850       || ARM_FEATURE_ZERO (flags_arch))
27851     {
27852       int thumb_isa_use;
27853
27854       if (!ARM_CPU_HAS_FEATURE (flags, arm_ext_v8)
27855           && ARM_CPU_HAS_FEATURE (flags, arm_ext_v8m_m_only))
27856         thumb_isa_use = 3;
27857       else if (ARM_CPU_HAS_FEATURE (flags, arm_arch_t2))
27858         thumb_isa_use = 2;
27859       else
27860         thumb_isa_use = 1;
27861       aeabi_set_attribute_int (Tag_THUMB_ISA_use, thumb_isa_use);
27862     }
27863
27864   /* Tag_VFP_arch.  */
27865   if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_armv8xd))
27866     aeabi_set_attribute_int (Tag_VFP_arch,
27867                              ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_d32)
27868                              ? 7 : 8);
27869   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_fma))
27870     aeabi_set_attribute_int (Tag_VFP_arch,
27871                              ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_d32)
27872                              ? 5 : 6);
27873   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_d32))
27874     {
27875       fp16_optional = 1;
27876       aeabi_set_attribute_int (Tag_VFP_arch, 3);
27877     }
27878   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v3xd))
27879     {
27880       aeabi_set_attribute_int (Tag_VFP_arch, 4);
27881       fp16_optional = 1;
27882     }
27883   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v2))
27884     aeabi_set_attribute_int (Tag_VFP_arch, 2);
27885   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1)
27886            || ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1xd))
27887     aeabi_set_attribute_int (Tag_VFP_arch, 1);
27888
27889   /* Tag_ABI_HardFP_use.  */
27890   if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1xd)
27891       && !ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1))
27892     aeabi_set_attribute_int (Tag_ABI_HardFP_use, 1);
27893
27894   /* Tag_WMMX_arch.  */
27895   if (ARM_CPU_HAS_FEATURE (flags, arm_cext_iwmmxt2))
27896     aeabi_set_attribute_int (Tag_WMMX_arch, 2);
27897   else if (ARM_CPU_HAS_FEATURE (flags, arm_cext_iwmmxt))
27898     aeabi_set_attribute_int (Tag_WMMX_arch, 1);
27899
27900   /* Tag_Advanced_SIMD_arch (formerly Tag_NEON_arch).  */
27901   if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_v8_1))
27902     aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 4);
27903   else if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_armv8))
27904     aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 3);
27905   else if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_v1))
27906     {
27907       if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_fma))
27908         {
27909           aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 2);
27910         }
27911       else
27912         {
27913           aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 1);
27914           fp16_optional = 1;
27915         }
27916     }
27917
27918   /* Tag_VFP_HP_extension (formerly Tag_NEON_FP16_arch).  */
27919   if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_fp16) && fp16_optional)
27920     aeabi_set_attribute_int (Tag_VFP_HP_extension, 1);
27921
27922   /* Tag_DIV_use.
27923
27924      We set Tag_DIV_use to two when integer divide instructions have been used
27925      in ARM state, or when Thumb integer divide instructions have been used,
27926      but we have no architecture profile set, nor have we any ARM instructions.
27927
27928      For ARMv8-A and ARMv8-M we set the tag to 0 as integer divide is implied
27929      by the base architecture.
27930
27931      For new architectures we will have to check these tests.  */
27932   gas_assert (arch <= TAG_CPU_ARCH_V8_1M_MAIN);
27933   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v8)
27934       || ARM_CPU_HAS_FEATURE (flags, arm_ext_v8m))
27935     aeabi_set_attribute_int (Tag_DIV_use, 0);
27936   else if (ARM_CPU_HAS_FEATURE (flags, arm_ext_adiv)
27937            || (profile == '\0'
27938                && ARM_CPU_HAS_FEATURE (flags, arm_ext_div)
27939                && !ARM_CPU_HAS_FEATURE (arm_arch_used, arm_arch_any)))
27940     aeabi_set_attribute_int (Tag_DIV_use, 2);
27941
27942   /* Tag_MP_extension_use.  */
27943   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_mp))
27944     aeabi_set_attribute_int (Tag_MPextension_use, 1);
27945
27946   /* Tag Virtualization_use.  */
27947   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_sec))
27948     virt_sec |= 1;
27949   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_virt))
27950     virt_sec |= 2;
27951   if (virt_sec != 0)
27952     aeabi_set_attribute_int (Tag_Virtualization_use, virt_sec);
27953 }
27954
27955 /* Post relaxation hook.  Recompute ARM attributes now that relaxation is
27956    finished and free extension feature bits which will not be used anymore.  */
27957
27958 void
27959 arm_md_post_relax (void)
27960 {
27961   aeabi_set_public_attributes ();
27962   XDELETE (mcpu_ext_opt);
27963   mcpu_ext_opt = NULL;
27964   XDELETE (march_ext_opt);
27965   march_ext_opt = NULL;
27966 }
27967
27968 /* Add the default contents for the .ARM.attributes section.  */
27969
27970 void
27971 arm_md_end (void)
27972 {
27973   if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
27974     return;
27975
27976   aeabi_set_public_attributes ();
27977 }
27978 #endif /* OBJ_ELF */
27979
27980 /* Parse a .cpu directive.  */
27981
27982 static void
27983 s_arm_cpu (int ignored ATTRIBUTE_UNUSED)
27984 {
27985   const struct arm_cpu_option_table *opt;
27986   char *name;
27987   char saved_char;
27988
27989   name = input_line_pointer;
27990   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
27991     input_line_pointer++;
27992   saved_char = *input_line_pointer;
27993   *input_line_pointer = 0;
27994
27995   /* Skip the first "all" entry.  */
27996   for (opt = arm_cpus + 1; opt->name != NULL; opt++)
27997     if (streq (opt->name, name))
27998       {
27999         selected_arch = opt->value;
28000         selected_ext = opt->ext;
28001         ARM_MERGE_FEATURE_SETS (selected_cpu, selected_arch, selected_ext);
28002         if (opt->canonical_name)
28003           strcpy (selected_cpu_name, opt->canonical_name);
28004         else
28005           {
28006             int i;
28007             for (i = 0; opt->name[i]; i++)
28008               selected_cpu_name[i] = TOUPPER (opt->name[i]);
28009
28010             selected_cpu_name[i] = 0;
28011           }
28012         ARM_MERGE_FEATURE_SETS (cpu_variant, selected_cpu, selected_fpu);
28013
28014         *input_line_pointer = saved_char;
28015         demand_empty_rest_of_line ();
28016         return;
28017       }
28018   as_bad (_("unknown cpu `%s'"), name);
28019   *input_line_pointer = saved_char;
28020   ignore_rest_of_line ();
28021 }
28022
28023 /* Parse a .arch directive.  */
28024
28025 static void
28026 s_arm_arch (int ignored ATTRIBUTE_UNUSED)
28027 {
28028   const struct arm_arch_option_table *opt;
28029   char saved_char;
28030   char *name;
28031
28032   name = input_line_pointer;
28033   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
28034     input_line_pointer++;
28035   saved_char = *input_line_pointer;
28036   *input_line_pointer = 0;
28037
28038   /* Skip the first "all" entry.  */
28039   for (opt = arm_archs + 1; opt->name != NULL; opt++)
28040     if (streq (opt->name, name))
28041       {
28042         selected_arch = opt->value;
28043         selected_ext = arm_arch_none;
28044         selected_cpu = selected_arch;
28045         strcpy (selected_cpu_name, opt->name);
28046         ARM_MERGE_FEATURE_SETS (cpu_variant, selected_cpu, selected_fpu);
28047         *input_line_pointer = saved_char;
28048         demand_empty_rest_of_line ();
28049         return;
28050       }
28051
28052   as_bad (_("unknown architecture `%s'\n"), name);
28053   *input_line_pointer = saved_char;
28054   ignore_rest_of_line ();
28055 }
28056
28057 /* Parse a .object_arch directive.  */
28058
28059 static void
28060 s_arm_object_arch (int ignored ATTRIBUTE_UNUSED)
28061 {
28062   const struct arm_arch_option_table *opt;
28063   char saved_char;
28064   char *name;
28065
28066   name = input_line_pointer;
28067   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
28068     input_line_pointer++;
28069   saved_char = *input_line_pointer;
28070   *input_line_pointer = 0;
28071
28072   /* Skip the first "all" entry.  */
28073   for (opt = arm_archs + 1; opt->name != NULL; opt++)
28074     if (streq (opt->name, name))
28075       {
28076         selected_object_arch = opt->value;
28077         *input_line_pointer = saved_char;
28078         demand_empty_rest_of_line ();
28079         return;
28080       }
28081
28082   as_bad (_("unknown architecture `%s'\n"), name);
28083   *input_line_pointer = saved_char;
28084   ignore_rest_of_line ();
28085 }
28086
28087 /* Parse a .arch_extension directive.  */
28088
28089 static void
28090 s_arm_arch_extension (int ignored ATTRIBUTE_UNUSED)
28091 {
28092   const struct arm_option_extension_value_table *opt;
28093   char saved_char;
28094   char *name;
28095   int adding_value = 1;
28096
28097   name = input_line_pointer;
28098   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
28099     input_line_pointer++;
28100   saved_char = *input_line_pointer;
28101   *input_line_pointer = 0;
28102
28103   if (strlen (name) >= 2
28104       && strncmp (name, "no", 2) == 0)
28105     {
28106       adding_value = 0;
28107       name += 2;
28108     }
28109
28110   for (opt = arm_extensions; opt->name != NULL; opt++)
28111     if (streq (opt->name, name))
28112       {
28113         int i, nb_allowed_archs =
28114           sizeof (opt->allowed_archs) / sizeof (opt->allowed_archs[i]);
28115         for (i = 0; i < nb_allowed_archs; i++)
28116           {
28117             /* Empty entry.  */
28118             if (ARM_CPU_IS_ANY (opt->allowed_archs[i]))
28119               continue;
28120             if (ARM_FSET_CPU_SUBSET (opt->allowed_archs[i], selected_arch))
28121               break;
28122           }
28123
28124         if (i == nb_allowed_archs)
28125           {
28126             as_bad (_("architectural extension `%s' is not allowed for the "
28127                       "current base architecture"), name);
28128             break;
28129           }
28130
28131         if (adding_value)
28132           ARM_MERGE_FEATURE_SETS (selected_ext, selected_ext,
28133                                   opt->merge_value);
28134         else
28135           ARM_CLEAR_FEATURE (selected_ext, selected_ext, opt->clear_value);
28136
28137         ARM_MERGE_FEATURE_SETS (selected_cpu, selected_arch, selected_ext);
28138         ARM_MERGE_FEATURE_SETS (cpu_variant, selected_cpu, selected_fpu);
28139         *input_line_pointer = saved_char;
28140         demand_empty_rest_of_line ();
28141         /* Allowing Thumb division instructions for ARMv7 in autodetection rely
28142            on this return so that duplicate extensions (extensions with the
28143            same name as a previous extension in the list) are not considered
28144            for command-line parsing.  */
28145         return;
28146       }
28147
28148   if (opt->name == NULL)
28149     as_bad (_("unknown architecture extension `%s'\n"), name);
28150
28151   *input_line_pointer = saved_char;
28152   ignore_rest_of_line ();
28153 }
28154
28155 /* Parse a .fpu directive.  */
28156
28157 static void
28158 s_arm_fpu (int ignored ATTRIBUTE_UNUSED)
28159 {
28160   const struct arm_option_fpu_value_table *opt;
28161   char saved_char;
28162   char *name;
28163
28164   name = input_line_pointer;
28165   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
28166     input_line_pointer++;
28167   saved_char = *input_line_pointer;
28168   *input_line_pointer = 0;
28169
28170   for (opt = arm_fpus; opt->name != NULL; opt++)
28171     if (streq (opt->name, name))
28172       {
28173         selected_fpu = opt->value;
28174 #ifndef CPU_DEFAULT
28175         if (no_cpu_selected ())
28176           ARM_MERGE_FEATURE_SETS (cpu_variant, arm_arch_any, selected_fpu);
28177         else
28178 #endif
28179           ARM_MERGE_FEATURE_SETS (cpu_variant, selected_cpu, selected_fpu);
28180         *input_line_pointer = saved_char;
28181         demand_empty_rest_of_line ();
28182         return;
28183       }
28184
28185   as_bad (_("unknown floating point format `%s'\n"), name);
28186   *input_line_pointer = saved_char;
28187   ignore_rest_of_line ();
28188 }
28189
28190 /* Copy symbol information.  */
28191
28192 void
28193 arm_copy_symbol_attributes (symbolS *dest, symbolS *src)
28194 {
28195   ARM_GET_FLAG (dest) = ARM_GET_FLAG (src);
28196 }
28197
28198 #ifdef OBJ_ELF
28199 /* Given a symbolic attribute NAME, return the proper integer value.
28200    Returns -1 if the attribute is not known.  */
28201
28202 int
28203 arm_convert_symbolic_attribute (const char *name)
28204 {
28205   static const struct
28206   {
28207     const char * name;
28208     const int    tag;
28209   }
28210   attribute_table[] =
28211     {
28212       /* When you modify this table you should
28213          also modify the list in doc/c-arm.texi.  */
28214 #define T(tag) {#tag, tag}
28215       T (Tag_CPU_raw_name),
28216       T (Tag_CPU_name),
28217       T (Tag_CPU_arch),
28218       T (Tag_CPU_arch_profile),
28219       T (Tag_ARM_ISA_use),
28220       T (Tag_THUMB_ISA_use),
28221       T (Tag_FP_arch),
28222       T (Tag_VFP_arch),
28223       T (Tag_WMMX_arch),
28224       T (Tag_Advanced_SIMD_arch),
28225       T (Tag_PCS_config),
28226       T (Tag_ABI_PCS_R9_use),
28227       T (Tag_ABI_PCS_RW_data),
28228       T (Tag_ABI_PCS_RO_data),
28229       T (Tag_ABI_PCS_GOT_use),
28230       T (Tag_ABI_PCS_wchar_t),
28231       T (Tag_ABI_FP_rounding),
28232       T (Tag_ABI_FP_denormal),
28233       T (Tag_ABI_FP_exceptions),
28234       T (Tag_ABI_FP_user_exceptions),
28235       T (Tag_ABI_FP_number_model),
28236       T (Tag_ABI_align_needed),
28237       T (Tag_ABI_align8_needed),
28238       T (Tag_ABI_align_preserved),
28239       T (Tag_ABI_align8_preserved),
28240       T (Tag_ABI_enum_size),
28241       T (Tag_ABI_HardFP_use),
28242       T (Tag_ABI_VFP_args),
28243       T (Tag_ABI_WMMX_args),
28244       T (Tag_ABI_optimization_goals),
28245       T (Tag_ABI_FP_optimization_goals),
28246       T (Tag_compatibility),
28247       T (Tag_CPU_unaligned_access),
28248       T (Tag_FP_HP_extension),
28249       T (Tag_VFP_HP_extension),
28250       T (Tag_ABI_FP_16bit_format),
28251       T (Tag_MPextension_use),
28252       T (Tag_DIV_use),
28253       T (Tag_nodefaults),
28254       T (Tag_also_compatible_with),
28255       T (Tag_conformance),
28256       T (Tag_T2EE_use),
28257       T (Tag_Virtualization_use),
28258       T (Tag_DSP_extension),
28259       /* We deliberately do not include Tag_MPextension_use_legacy.  */
28260 #undef T
28261     };
28262   unsigned int i;
28263
28264   if (name == NULL)
28265     return -1;
28266
28267   for (i = 0; i < ARRAY_SIZE (attribute_table); i++)
28268     if (streq (name, attribute_table[i].name))
28269       return attribute_table[i].tag;
28270
28271   return -1;
28272 }
28273
28274 /* Apply sym value for relocations only in the case that they are for
28275    local symbols in the same segment as the fixup and you have the
28276    respective architectural feature for blx and simple switches.  */
28277
28278 int
28279 arm_apply_sym_value (struct fix * fixP, segT this_seg)
28280 {
28281   if (fixP->fx_addsy
28282       && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
28283       /* PR 17444: If the local symbol is in a different section then a reloc
28284          will always be generated for it, so applying the symbol value now
28285          will result in a double offset being stored in the relocation.  */
28286       && (S_GET_SEGMENT (fixP->fx_addsy) == this_seg)
28287       && !S_FORCE_RELOC (fixP->fx_addsy, TRUE))
28288     {
28289       switch (fixP->fx_r_type)
28290         {
28291         case BFD_RELOC_ARM_PCREL_BLX:
28292         case BFD_RELOC_THUMB_PCREL_BRANCH23:
28293           if (ARM_IS_FUNC (fixP->fx_addsy))
28294             return 1;
28295           break;
28296
28297         case BFD_RELOC_ARM_PCREL_CALL:
28298         case BFD_RELOC_THUMB_PCREL_BLX:
28299           if (THUMB_IS_FUNC (fixP->fx_addsy))
28300             return 1;
28301           break;
28302
28303         default:
28304           break;
28305         }
28306
28307     }
28308   return 0;
28309 }
28310 #endif /* OBJ_ELF */