* gas/config/tc-arm.c (NEON_ENC_TAB): Add vmaxnm, vminnm entries.
[external/binutils.git] / gas / config / tc-arm.c
1 /* tc-arm.c -- Assemble for the ARM
2    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3    2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4    Free Software Foundation, Inc.
5    Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
6         Modified by David Taylor (dtaylor@armltd.co.uk)
7         Cirrus coprocessor mods by Aldy Hernandez (aldyh@redhat.com)
8         Cirrus coprocessor fixes by Petko Manolov (petkan@nucleusys.com)
9         Cirrus coprocessor fixes by Vladimir Ivanov (vladitx@nucleusys.com)
10
11    This file is part of GAS, the GNU Assembler.
12
13    GAS is free software; you can redistribute it and/or modify
14    it under the terms of the GNU General Public License as published by
15    the Free Software Foundation; either version 3, or (at your option)
16    any later version.
17
18    GAS is distributed in the hope that it will be useful,
19    but WITHOUT ANY WARRANTY; without even the implied warranty of
20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21    GNU General Public License for more details.
22
23    You should have received a copy of the GNU General Public License
24    along with GAS; see the file COPYING.  If not, write to the Free
25    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
26    02110-1301, USA.  */
27
28 #include "as.h"
29 #include <limits.h>
30 #include <stdarg.h>
31 #define  NO_RELOC 0
32 #include "safe-ctype.h"
33 #include "subsegs.h"
34 #include "obstack.h"
35 #include "libiberty.h"
36 #include "opcode/arm.h"
37
38 #ifdef OBJ_ELF
39 #include "elf/arm.h"
40 #include "dw2gencfi.h"
41 #endif
42
43 #include "dwarf2dbg.h"
44
45 #ifdef OBJ_ELF
46 /* Must be at least the size of the largest unwind opcode (currently two).  */
47 #define ARM_OPCODE_CHUNK_SIZE 8
48
49 /* This structure holds the unwinding state.  */
50
51 static struct
52 {
53   symbolS *       proc_start;
54   symbolS *       table_entry;
55   symbolS *       personality_routine;
56   int             personality_index;
57   /* The segment containing the function.  */
58   segT            saved_seg;
59   subsegT         saved_subseg;
60   /* Opcodes generated from this function.  */
61   unsigned char * opcodes;
62   int             opcode_count;
63   int             opcode_alloc;
64   /* The number of bytes pushed to the stack.  */
65   offsetT         frame_size;
66   /* We don't add stack adjustment opcodes immediately so that we can merge
67      multiple adjustments.  We can also omit the final adjustment
68      when using a frame pointer.  */
69   offsetT         pending_offset;
70   /* These two fields are set by both unwind_movsp and unwind_setfp.  They
71      hold the reg+offset to use when restoring sp from a frame pointer.  */
72   offsetT         fp_offset;
73   int             fp_reg;
74   /* Nonzero if an unwind_setfp directive has been seen.  */
75   unsigned        fp_used:1;
76   /* Nonzero if the last opcode restores sp from fp_reg.  */
77   unsigned        sp_restored:1;
78 } unwind;
79
80 #endif /* OBJ_ELF */
81
82 /* Results from operand parsing worker functions.  */
83
84 typedef enum
85 {
86   PARSE_OPERAND_SUCCESS,
87   PARSE_OPERAND_FAIL,
88   PARSE_OPERAND_FAIL_NO_BACKTRACK
89 } parse_operand_result;
90
91 enum arm_float_abi
92 {
93   ARM_FLOAT_ABI_HARD,
94   ARM_FLOAT_ABI_SOFTFP,
95   ARM_FLOAT_ABI_SOFT
96 };
97
98 /* Types of processor to assemble for.  */
99 #ifndef CPU_DEFAULT
100 /* The code that was here used to select a default CPU depending on compiler
101    pre-defines which were only present when doing native builds, thus
102    changing gas' default behaviour depending upon the build host.
103
104    If you have a target that requires a default CPU option then the you
105    should define CPU_DEFAULT here.  */
106 #endif
107
108 #ifndef FPU_DEFAULT
109 # ifdef TE_LINUX
110 #  define FPU_DEFAULT FPU_ARCH_FPA
111 # elif defined (TE_NetBSD)
112 #  ifdef OBJ_ELF
113 #   define FPU_DEFAULT FPU_ARCH_VFP     /* Soft-float, but VFP order.  */
114 #  else
115     /* Legacy a.out format.  */
116 #   define FPU_DEFAULT FPU_ARCH_FPA     /* Soft-float, but FPA order.  */
117 #  endif
118 # elif defined (TE_VXWORKS)
119 #  define FPU_DEFAULT FPU_ARCH_VFP      /* Soft-float, VFP order.  */
120 # else
121    /* For backwards compatibility, default to FPA.  */
122 #  define FPU_DEFAULT FPU_ARCH_FPA
123 # endif
124 #endif /* ifndef FPU_DEFAULT */
125
126 #define streq(a, b)           (strcmp (a, b) == 0)
127
128 static arm_feature_set cpu_variant;
129 static arm_feature_set arm_arch_used;
130 static arm_feature_set thumb_arch_used;
131
132 /* Flags stored in private area of BFD structure.  */
133 static int uses_apcs_26      = FALSE;
134 static int atpcs             = FALSE;
135 static int support_interwork = FALSE;
136 static int uses_apcs_float   = FALSE;
137 static int pic_code          = FALSE;
138 static int fix_v4bx          = FALSE;
139 /* Warn on using deprecated features.  */
140 static int warn_on_deprecated = TRUE;
141
142
143 /* Variables that we set while parsing command-line options.  Once all
144    options have been read we re-process these values to set the real
145    assembly flags.  */
146 static const arm_feature_set *legacy_cpu = NULL;
147 static const arm_feature_set *legacy_fpu = NULL;
148
149 static const arm_feature_set *mcpu_cpu_opt = NULL;
150 static const arm_feature_set *mcpu_fpu_opt = NULL;
151 static const arm_feature_set *march_cpu_opt = NULL;
152 static const arm_feature_set *march_fpu_opt = NULL;
153 static const arm_feature_set *mfpu_opt = NULL;
154 static const arm_feature_set *object_arch = NULL;
155
156 /* Constants for known architecture features.  */
157 static const arm_feature_set fpu_default = FPU_DEFAULT;
158 static const arm_feature_set fpu_arch_vfp_v1 = FPU_ARCH_VFP_V1;
159 static const arm_feature_set fpu_arch_vfp_v2 = FPU_ARCH_VFP_V2;
160 static const arm_feature_set fpu_arch_vfp_v3 = FPU_ARCH_VFP_V3;
161 static const arm_feature_set fpu_arch_neon_v1 = FPU_ARCH_NEON_V1;
162 static const arm_feature_set fpu_arch_fpa = FPU_ARCH_FPA;
163 static const arm_feature_set fpu_any_hard = FPU_ANY_HARD;
164 static const arm_feature_set fpu_arch_maverick = FPU_ARCH_MAVERICK;
165 static const arm_feature_set fpu_endian_pure = FPU_ARCH_ENDIAN_PURE;
166
167 #ifdef CPU_DEFAULT
168 static const arm_feature_set cpu_default = CPU_DEFAULT;
169 #endif
170
171 static const arm_feature_set arm_ext_v1 = ARM_FEATURE (ARM_EXT_V1, 0);
172 static const arm_feature_set arm_ext_v2 = ARM_FEATURE (ARM_EXT_V1, 0);
173 static const arm_feature_set arm_ext_v2s = ARM_FEATURE (ARM_EXT_V2S, 0);
174 static const arm_feature_set arm_ext_v3 = ARM_FEATURE (ARM_EXT_V3, 0);
175 static const arm_feature_set arm_ext_v3m = ARM_FEATURE (ARM_EXT_V3M, 0);
176 static const arm_feature_set arm_ext_v4 = ARM_FEATURE (ARM_EXT_V4, 0);
177 static const arm_feature_set arm_ext_v4t = ARM_FEATURE (ARM_EXT_V4T, 0);
178 static const arm_feature_set arm_ext_v5 = ARM_FEATURE (ARM_EXT_V5, 0);
179 static const arm_feature_set arm_ext_v4t_5 =
180   ARM_FEATURE (ARM_EXT_V4T | ARM_EXT_V5, 0);
181 static const arm_feature_set arm_ext_v5t = ARM_FEATURE (ARM_EXT_V5T, 0);
182 static const arm_feature_set arm_ext_v5e = ARM_FEATURE (ARM_EXT_V5E, 0);
183 static const arm_feature_set arm_ext_v5exp = ARM_FEATURE (ARM_EXT_V5ExP, 0);
184 static const arm_feature_set arm_ext_v5j = ARM_FEATURE (ARM_EXT_V5J, 0);
185 static const arm_feature_set arm_ext_v6 = ARM_FEATURE (ARM_EXT_V6, 0);
186 static const arm_feature_set arm_ext_v6k = ARM_FEATURE (ARM_EXT_V6K, 0);
187 static const arm_feature_set arm_ext_v6t2 = ARM_FEATURE (ARM_EXT_V6T2, 0);
188 static const arm_feature_set arm_ext_v6m = ARM_FEATURE (ARM_EXT_V6M, 0);
189 static const arm_feature_set arm_ext_v6_notm = ARM_FEATURE (ARM_EXT_V6_NOTM, 0);
190 static const arm_feature_set arm_ext_v6_dsp = ARM_FEATURE (ARM_EXT_V6_DSP, 0);
191 static const arm_feature_set arm_ext_barrier = ARM_FEATURE (ARM_EXT_BARRIER, 0);
192 static const arm_feature_set arm_ext_msr = ARM_FEATURE (ARM_EXT_THUMB_MSR, 0);
193 static const arm_feature_set arm_ext_div = ARM_FEATURE (ARM_EXT_DIV, 0);
194 static const arm_feature_set arm_ext_v7 = ARM_FEATURE (ARM_EXT_V7, 0);
195 static const arm_feature_set arm_ext_v7a = ARM_FEATURE (ARM_EXT_V7A, 0);
196 static const arm_feature_set arm_ext_v7r = ARM_FEATURE (ARM_EXT_V7R, 0);
197 static const arm_feature_set arm_ext_v7m = ARM_FEATURE (ARM_EXT_V7M, 0);
198 static const arm_feature_set arm_ext_v8 = ARM_FEATURE (ARM_EXT_V8, 0);
199 static const arm_feature_set arm_ext_m =
200   ARM_FEATURE (ARM_EXT_V6M | ARM_EXT_OS | ARM_EXT_V7M, 0);
201 static const arm_feature_set arm_ext_mp = ARM_FEATURE (ARM_EXT_MP, 0);
202 static const arm_feature_set arm_ext_sec = ARM_FEATURE (ARM_EXT_SEC, 0);
203 static const arm_feature_set arm_ext_os = ARM_FEATURE (ARM_EXT_OS, 0);
204 static const arm_feature_set arm_ext_adiv = ARM_FEATURE (ARM_EXT_ADIV, 0);
205 static const arm_feature_set arm_ext_virt = ARM_FEATURE (ARM_EXT_VIRT, 0);
206
207 static const arm_feature_set arm_arch_any = ARM_ANY;
208 static const arm_feature_set arm_arch_full = ARM_FEATURE (-1, -1);
209 static const arm_feature_set arm_arch_t2 = ARM_ARCH_THUMB2;
210 static const arm_feature_set arm_arch_none = ARM_ARCH_NONE;
211 static const arm_feature_set arm_arch_v6m_only = ARM_ARCH_V6M_ONLY;
212
213 static const arm_feature_set arm_cext_iwmmxt2 =
214   ARM_FEATURE (0, ARM_CEXT_IWMMXT2);
215 static const arm_feature_set arm_cext_iwmmxt =
216   ARM_FEATURE (0, ARM_CEXT_IWMMXT);
217 static const arm_feature_set arm_cext_xscale =
218   ARM_FEATURE (0, ARM_CEXT_XSCALE);
219 static const arm_feature_set arm_cext_maverick =
220   ARM_FEATURE (0, ARM_CEXT_MAVERICK);
221 static const arm_feature_set fpu_fpa_ext_v1 = ARM_FEATURE (0, FPU_FPA_EXT_V1);
222 static const arm_feature_set fpu_fpa_ext_v2 = ARM_FEATURE (0, FPU_FPA_EXT_V2);
223 static const arm_feature_set fpu_vfp_ext_v1xd =
224   ARM_FEATURE (0, FPU_VFP_EXT_V1xD);
225 static const arm_feature_set fpu_vfp_ext_v1 = ARM_FEATURE (0, FPU_VFP_EXT_V1);
226 static const arm_feature_set fpu_vfp_ext_v2 = ARM_FEATURE (0, FPU_VFP_EXT_V2);
227 static const arm_feature_set fpu_vfp_ext_v3xd = ARM_FEATURE (0, FPU_VFP_EXT_V3xD);
228 static const arm_feature_set fpu_vfp_ext_v3 = ARM_FEATURE (0, FPU_VFP_EXT_V3);
229 static const arm_feature_set fpu_vfp_ext_d32 =
230   ARM_FEATURE (0, FPU_VFP_EXT_D32);
231 static const arm_feature_set fpu_neon_ext_v1 = ARM_FEATURE (0, FPU_NEON_EXT_V1);
232 static const arm_feature_set fpu_vfp_v3_or_neon_ext =
233   ARM_FEATURE (0, FPU_NEON_EXT_V1 | FPU_VFP_EXT_V3);
234 static const arm_feature_set fpu_vfp_fp16 = ARM_FEATURE (0, FPU_VFP_EXT_FP16);
235 static const arm_feature_set fpu_neon_ext_fma = ARM_FEATURE (0, FPU_NEON_EXT_FMA);
236 static const arm_feature_set fpu_vfp_ext_fma = ARM_FEATURE (0, FPU_VFP_EXT_FMA);
237 static const arm_feature_set fpu_vfp_ext_armv8 =
238   ARM_FEATURE (0, FPU_VFP_EXT_ARMV8);
239 static const arm_feature_set fpu_neon_ext_armv8 =
240   ARM_FEATURE (0, FPU_NEON_EXT_ARMV8);
241 static const arm_feature_set fpu_crypto_ext_armv8 =
242   ARM_FEATURE (0, FPU_CRYPTO_EXT_ARMV8);
243
244 static int mfloat_abi_opt = -1;
245 /* Record user cpu selection for object attributes.  */
246 static arm_feature_set selected_cpu = ARM_ARCH_NONE;
247 /* Must be long enough to hold any of the names in arm_cpus.  */
248 static char selected_cpu_name[16];
249
250 /* Return if no cpu was selected on command-line.  */
251 static bfd_boolean
252 no_cpu_selected (void)
253 {
254   return selected_cpu.core == arm_arch_none.core
255     && selected_cpu.coproc == arm_arch_none.coproc;
256 }
257
258 #ifdef OBJ_ELF
259 # ifdef EABI_DEFAULT
260 static int meabi_flags = EABI_DEFAULT;
261 # else
262 static int meabi_flags = EF_ARM_EABI_UNKNOWN;
263 # endif
264
265 static int attributes_set_explicitly[NUM_KNOWN_OBJ_ATTRIBUTES];
266
267 bfd_boolean
268 arm_is_eabi (void)
269 {
270   return (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4);
271 }
272 #endif
273
274 #ifdef OBJ_ELF
275 /* Pre-defined "_GLOBAL_OFFSET_TABLE_"  */
276 symbolS * GOT_symbol;
277 #endif
278
279 /* 0: assemble for ARM,
280    1: assemble for Thumb,
281    2: assemble for Thumb even though target CPU does not support thumb
282       instructions.  */
283 static int thumb_mode = 0;
284 /* A value distinct from the possible values for thumb_mode that we
285    can use to record whether thumb_mode has been copied into the
286    tc_frag_data field of a frag.  */
287 #define MODE_RECORDED (1 << 4)
288
289 /* Specifies the intrinsic IT insn behavior mode.  */
290 enum implicit_it_mode
291 {
292   IMPLICIT_IT_MODE_NEVER  = 0x00,
293   IMPLICIT_IT_MODE_ARM    = 0x01,
294   IMPLICIT_IT_MODE_THUMB  = 0x02,
295   IMPLICIT_IT_MODE_ALWAYS = (IMPLICIT_IT_MODE_ARM | IMPLICIT_IT_MODE_THUMB)
296 };
297 static int implicit_it_mode = IMPLICIT_IT_MODE_ARM;
298
299 /* If unified_syntax is true, we are processing the new unified
300    ARM/Thumb syntax.  Important differences from the old ARM mode:
301
302      - Immediate operands do not require a # prefix.
303      - Conditional affixes always appear at the end of the
304        instruction.  (For backward compatibility, those instructions
305        that formerly had them in the middle, continue to accept them
306        there.)
307      - The IT instruction may appear, and if it does is validated
308        against subsequent conditional affixes.  It does not generate
309        machine code.
310
311    Important differences from the old Thumb mode:
312
313      - Immediate operands do not require a # prefix.
314      - Most of the V6T2 instructions are only available in unified mode.
315      - The .N and .W suffixes are recognized and honored (it is an error
316        if they cannot be honored).
317      - All instructions set the flags if and only if they have an 's' affix.
318      - Conditional affixes may be used.  They are validated against
319        preceding IT instructions.  Unlike ARM mode, you cannot use a
320        conditional affix except in the scope of an IT instruction.  */
321
322 static bfd_boolean unified_syntax = FALSE;
323
324 enum neon_el_type
325 {
326   NT_invtype,
327   NT_untyped,
328   NT_integer,
329   NT_float,
330   NT_poly,
331   NT_signed,
332   NT_unsigned
333 };
334
335 struct neon_type_el
336 {
337   enum neon_el_type type;
338   unsigned size;
339 };
340
341 #define NEON_MAX_TYPE_ELS 4
342
343 struct neon_type
344 {
345   struct neon_type_el el[NEON_MAX_TYPE_ELS];
346   unsigned elems;
347 };
348
349 enum it_instruction_type
350 {
351    OUTSIDE_IT_INSN,
352    INSIDE_IT_INSN,
353    INSIDE_IT_LAST_INSN,
354    IF_INSIDE_IT_LAST_INSN, /* Either outside or inside;
355                               if inside, should be the last one.  */
356    NEUTRAL_IT_INSN,        /* This could be either inside or outside,
357                               i.e. BKPT and NOP.  */
358    IT_INSN                 /* The IT insn has been parsed.  */
359 };
360
361 /* The maximum number of operands we need.  */
362 #define ARM_IT_MAX_OPERANDS 6
363
364 struct arm_it
365 {
366   const char *  error;
367   unsigned long instruction;
368   int           size;
369   int           size_req;
370   int           cond;
371   /* "uncond_value" is set to the value in place of the conditional field in
372      unconditional versions of the instruction, or -1 if nothing is
373      appropriate.  */
374   int           uncond_value;
375   struct neon_type vectype;
376   /* This does not indicate an actual NEON instruction, only that
377      the mnemonic accepts neon-style type suffixes.  */
378   int           is_neon;
379   /* Set to the opcode if the instruction needs relaxation.
380      Zero if the instruction is not relaxed.  */
381   unsigned long relax;
382   struct
383   {
384     bfd_reloc_code_real_type type;
385     expressionS              exp;
386     int                      pc_rel;
387   } reloc;
388
389   enum it_instruction_type it_insn_type;
390
391   struct
392   {
393     unsigned reg;
394     signed int imm;
395     struct neon_type_el vectype;
396     unsigned present    : 1;  /* Operand present.  */
397     unsigned isreg      : 1;  /* Operand was a register.  */
398     unsigned immisreg   : 1;  /* .imm field is a second register.  */
399     unsigned isscalar   : 1;  /* Operand is a (Neon) scalar.  */
400     unsigned immisalign : 1;  /* Immediate is an alignment specifier.  */
401     unsigned immisfloat : 1;  /* Immediate was parsed as a float.  */
402     /* Note: we abuse "regisimm" to mean "is Neon register" in VMOV
403        instructions. This allows us to disambiguate ARM <-> vector insns.  */
404     unsigned regisimm   : 1;  /* 64-bit immediate, reg forms high 32 bits.  */
405     unsigned isvec      : 1;  /* Is a single, double or quad VFP/Neon reg.  */
406     unsigned isquad     : 1;  /* Operand is Neon quad-precision register.  */
407     unsigned issingle   : 1;  /* Operand is VFP single-precision register.  */
408     unsigned hasreloc   : 1;  /* Operand has relocation suffix.  */
409     unsigned writeback  : 1;  /* Operand has trailing !  */
410     unsigned preind     : 1;  /* Preindexed address.  */
411     unsigned postind    : 1;  /* Postindexed address.  */
412     unsigned negative   : 1;  /* Index register was negated.  */
413     unsigned shifted    : 1;  /* Shift applied to operation.  */
414     unsigned shift_kind : 3;  /* Shift operation (enum shift_kind).  */
415   } operands[ARM_IT_MAX_OPERANDS];
416 };
417
418 static struct arm_it inst;
419
420 #define NUM_FLOAT_VALS 8
421
422 const char * fp_const[] =
423 {
424   "0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0", 0
425 };
426
427 /* Number of littlenums required to hold an extended precision number.  */
428 #define MAX_LITTLENUMS 6
429
430 LITTLENUM_TYPE fp_values[NUM_FLOAT_VALS][MAX_LITTLENUMS];
431
432 #define FAIL    (-1)
433 #define SUCCESS (0)
434
435 #define SUFF_S 1
436 #define SUFF_D 2
437 #define SUFF_E 3
438 #define SUFF_P 4
439
440 #define CP_T_X   0x00008000
441 #define CP_T_Y   0x00400000
442
443 #define CONDS_BIT        0x00100000
444 #define LOAD_BIT         0x00100000
445
446 #define DOUBLE_LOAD_FLAG 0x00000001
447
448 struct asm_cond
449 {
450   const char *   template_name;
451   unsigned long  value;
452 };
453
454 #define COND_ALWAYS 0xE
455
456 struct asm_psr
457 {
458   const char *   template_name;
459   unsigned long  field;
460 };
461
462 struct asm_barrier_opt
463 {
464   const char *    template_name;
465   unsigned long   value;
466   const arm_feature_set arch;
467 };
468
469 /* The bit that distinguishes CPSR and SPSR.  */
470 #define SPSR_BIT   (1 << 22)
471
472 /* The individual PSR flag bits.  */
473 #define PSR_c   (1 << 16)
474 #define PSR_x   (1 << 17)
475 #define PSR_s   (1 << 18)
476 #define PSR_f   (1 << 19)
477
478 struct reloc_entry
479 {
480   char *                    name;
481   bfd_reloc_code_real_type  reloc;
482 };
483
484 enum vfp_reg_pos
485 {
486   VFP_REG_Sd, VFP_REG_Sm, VFP_REG_Sn,
487   VFP_REG_Dd, VFP_REG_Dm, VFP_REG_Dn
488 };
489
490 enum vfp_ldstm_type
491 {
492   VFP_LDSTMIA, VFP_LDSTMDB, VFP_LDSTMIAX, VFP_LDSTMDBX
493 };
494
495 /* Bits for DEFINED field in neon_typed_alias.  */
496 #define NTA_HASTYPE  1
497 #define NTA_HASINDEX 2
498
499 struct neon_typed_alias
500 {
501   unsigned char        defined;
502   unsigned char        index;
503   struct neon_type_el  eltype;
504 };
505
506 /* ARM register categories.  This includes coprocessor numbers and various
507    architecture extensions' registers.  */
508 enum arm_reg_type
509 {
510   REG_TYPE_RN,
511   REG_TYPE_CP,
512   REG_TYPE_CN,
513   REG_TYPE_FN,
514   REG_TYPE_VFS,
515   REG_TYPE_VFD,
516   REG_TYPE_NQ,
517   REG_TYPE_VFSD,
518   REG_TYPE_NDQ,
519   REG_TYPE_NSDQ,
520   REG_TYPE_VFC,
521   REG_TYPE_MVF,
522   REG_TYPE_MVD,
523   REG_TYPE_MVFX,
524   REG_TYPE_MVDX,
525   REG_TYPE_MVAX,
526   REG_TYPE_DSPSC,
527   REG_TYPE_MMXWR,
528   REG_TYPE_MMXWC,
529   REG_TYPE_MMXWCG,
530   REG_TYPE_XSCALE,
531   REG_TYPE_RNB
532 };
533
534 /* Structure for a hash table entry for a register.
535    If TYPE is REG_TYPE_VFD or REG_TYPE_NQ, the NEON field can point to extra
536    information which states whether a vector type or index is specified (for a
537    register alias created with .dn or .qn). Otherwise NEON should be NULL.  */
538 struct reg_entry
539 {
540   const char *               name;
541   unsigned int               number;
542   unsigned char              type;
543   unsigned char              builtin;
544   struct neon_typed_alias *  neon;
545 };
546
547 /* Diagnostics used when we don't get a register of the expected type.  */
548 const char * const reg_expected_msgs[] =
549 {
550   N_("ARM register expected"),
551   N_("bad or missing co-processor number"),
552   N_("co-processor register expected"),
553   N_("FPA register expected"),
554   N_("VFP single precision register expected"),
555   N_("VFP/Neon double precision register expected"),
556   N_("Neon quad precision register expected"),
557   N_("VFP single or double precision register expected"),
558   N_("Neon double or quad precision register expected"),
559   N_("VFP single, double or Neon quad precision register expected"),
560   N_("VFP system register expected"),
561   N_("Maverick MVF register expected"),
562   N_("Maverick MVD register expected"),
563   N_("Maverick MVFX register expected"),
564   N_("Maverick MVDX register expected"),
565   N_("Maverick MVAX register expected"),
566   N_("Maverick DSPSC register expected"),
567   N_("iWMMXt data register expected"),
568   N_("iWMMXt control register expected"),
569   N_("iWMMXt scalar register expected"),
570   N_("XScale accumulator register expected"),
571 };
572
573 /* Some well known registers that we refer to directly elsewhere.  */
574 #define REG_R12 12
575 #define REG_SP  13
576 #define REG_LR  14
577 #define REG_PC  15
578
579 /* ARM instructions take 4bytes in the object file, Thumb instructions
580    take 2:  */
581 #define INSN_SIZE       4
582
583 struct asm_opcode
584 {
585   /* Basic string to match.  */
586   const char * template_name;
587
588   /* Parameters to instruction.  */
589   unsigned int operands[8];
590
591   /* Conditional tag - see opcode_lookup.  */
592   unsigned int tag : 4;
593
594   /* Basic instruction code.  */
595   unsigned int avalue : 28;
596
597   /* Thumb-format instruction code.  */
598   unsigned int tvalue;
599
600   /* Which architecture variant provides this instruction.  */
601   const arm_feature_set * avariant;
602   const arm_feature_set * tvariant;
603
604   /* Function to call to encode instruction in ARM format.  */
605   void (* aencode) (void);
606
607   /* Function to call to encode instruction in Thumb format.  */
608   void (* tencode) (void);
609 };
610
611 /* Defines for various bits that we will want to toggle.  */
612 #define INST_IMMEDIATE  0x02000000
613 #define OFFSET_REG      0x02000000
614 #define HWOFFSET_IMM    0x00400000
615 #define SHIFT_BY_REG    0x00000010
616 #define PRE_INDEX       0x01000000
617 #define INDEX_UP        0x00800000
618 #define WRITE_BACK      0x00200000
619 #define LDM_TYPE_2_OR_3 0x00400000
620 #define CPSI_MMOD       0x00020000
621
622 #define LITERAL_MASK    0xf000f000
623 #define OPCODE_MASK     0xfe1fffff
624 #define V4_STR_BIT      0x00000020
625
626 #define T2_SUBS_PC_LR   0xf3de8f00
627
628 #define DATA_OP_SHIFT   21
629
630 #define T2_OPCODE_MASK  0xfe1fffff
631 #define T2_DATA_OP_SHIFT 21
632
633 #define A_COND_MASK         0xf0000000
634 #define A_PUSH_POP_OP_MASK  0x0fff0000
635
636 /* Opcodes for pushing/poping registers to/from the stack.  */
637 #define A1_OPCODE_PUSH    0x092d0000
638 #define A2_OPCODE_PUSH    0x052d0004
639 #define A2_OPCODE_POP     0x049d0004
640
641 /* Codes to distinguish the arithmetic instructions.  */
642 #define OPCODE_AND      0
643 #define OPCODE_EOR      1
644 #define OPCODE_SUB      2
645 #define OPCODE_RSB      3
646 #define OPCODE_ADD      4
647 #define OPCODE_ADC      5
648 #define OPCODE_SBC      6
649 #define OPCODE_RSC      7
650 #define OPCODE_TST      8
651 #define OPCODE_TEQ      9
652 #define OPCODE_CMP      10
653 #define OPCODE_CMN      11
654 #define OPCODE_ORR      12
655 #define OPCODE_MOV      13
656 #define OPCODE_BIC      14
657 #define OPCODE_MVN      15
658
659 #define T2_OPCODE_AND   0
660 #define T2_OPCODE_BIC   1
661 #define T2_OPCODE_ORR   2
662 #define T2_OPCODE_ORN   3
663 #define T2_OPCODE_EOR   4
664 #define T2_OPCODE_ADD   8
665 #define T2_OPCODE_ADC   10
666 #define T2_OPCODE_SBC   11
667 #define T2_OPCODE_SUB   13
668 #define T2_OPCODE_RSB   14
669
670 #define T_OPCODE_MUL 0x4340
671 #define T_OPCODE_TST 0x4200
672 #define T_OPCODE_CMN 0x42c0
673 #define T_OPCODE_NEG 0x4240
674 #define T_OPCODE_MVN 0x43c0
675
676 #define T_OPCODE_ADD_R3 0x1800
677 #define T_OPCODE_SUB_R3 0x1a00
678 #define T_OPCODE_ADD_HI 0x4400
679 #define T_OPCODE_ADD_ST 0xb000
680 #define T_OPCODE_SUB_ST 0xb080
681 #define T_OPCODE_ADD_SP 0xa800
682 #define T_OPCODE_ADD_PC 0xa000
683 #define T_OPCODE_ADD_I8 0x3000
684 #define T_OPCODE_SUB_I8 0x3800
685 #define T_OPCODE_ADD_I3 0x1c00
686 #define T_OPCODE_SUB_I3 0x1e00
687
688 #define T_OPCODE_ASR_R  0x4100
689 #define T_OPCODE_LSL_R  0x4080
690 #define T_OPCODE_LSR_R  0x40c0
691 #define T_OPCODE_ROR_R  0x41c0
692 #define T_OPCODE_ASR_I  0x1000
693 #define T_OPCODE_LSL_I  0x0000
694 #define T_OPCODE_LSR_I  0x0800
695
696 #define T_OPCODE_MOV_I8 0x2000
697 #define T_OPCODE_CMP_I8 0x2800
698 #define T_OPCODE_CMP_LR 0x4280
699 #define T_OPCODE_MOV_HR 0x4600
700 #define T_OPCODE_CMP_HR 0x4500
701
702 #define T_OPCODE_LDR_PC 0x4800
703 #define T_OPCODE_LDR_SP 0x9800
704 #define T_OPCODE_STR_SP 0x9000
705 #define T_OPCODE_LDR_IW 0x6800
706 #define T_OPCODE_STR_IW 0x6000
707 #define T_OPCODE_LDR_IH 0x8800
708 #define T_OPCODE_STR_IH 0x8000
709 #define T_OPCODE_LDR_IB 0x7800
710 #define T_OPCODE_STR_IB 0x7000
711 #define T_OPCODE_LDR_RW 0x5800
712 #define T_OPCODE_STR_RW 0x5000
713 #define T_OPCODE_LDR_RH 0x5a00
714 #define T_OPCODE_STR_RH 0x5200
715 #define T_OPCODE_LDR_RB 0x5c00
716 #define T_OPCODE_STR_RB 0x5400
717
718 #define T_OPCODE_PUSH   0xb400
719 #define T_OPCODE_POP    0xbc00
720
721 #define T_OPCODE_BRANCH 0xe000
722
723 #define THUMB_SIZE      2       /* Size of thumb instruction.  */
724 #define THUMB_PP_PC_LR 0x0100
725 #define THUMB_LOAD_BIT 0x0800
726 #define THUMB2_LOAD_BIT 0x00100000
727
728 #define BAD_ARGS        _("bad arguments to instruction")
729 #define BAD_SP          _("r13 not allowed here")
730 #define BAD_PC          _("r15 not allowed here")
731 #define BAD_COND        _("instruction cannot be conditional")
732 #define BAD_OVERLAP     _("registers may not be the same")
733 #define BAD_HIREG       _("lo register required")
734 #define BAD_THUMB32     _("instruction not supported in Thumb16 mode")
735 #define BAD_ADDR_MODE   _("instruction does not accept this addressing mode");
736 #define BAD_BRANCH      _("branch must be last instruction in IT block")
737 #define BAD_NOT_IT      _("instruction not allowed in IT block")
738 #define BAD_FPU         _("selected FPU does not support instruction")
739 #define BAD_OUT_IT      _("thumb conditional instruction should be in IT block")
740 #define BAD_IT_COND     _("incorrect condition in IT block")
741 #define BAD_IT_IT       _("IT falling in the range of a previous IT block")
742 #define MISSING_FNSTART _("missing .fnstart before unwinding directive")
743 #define BAD_PC_ADDRESSING \
744         _("cannot use register index with PC-relative addressing")
745 #define BAD_PC_WRITEBACK \
746         _("cannot use writeback with PC-relative addressing")
747 #define BAD_RANGE     _("branch out of range")
748
749 static struct hash_control * arm_ops_hsh;
750 static struct hash_control * arm_cond_hsh;
751 static struct hash_control * arm_shift_hsh;
752 static struct hash_control * arm_psr_hsh;
753 static struct hash_control * arm_v7m_psr_hsh;
754 static struct hash_control * arm_reg_hsh;
755 static struct hash_control * arm_reloc_hsh;
756 static struct hash_control * arm_barrier_opt_hsh;
757
758 /* Stuff needed to resolve the label ambiguity
759    As:
760      ...
761      label:   <insn>
762    may differ from:
763      ...
764      label:
765               <insn>  */
766
767 symbolS *  last_label_seen;
768 static int label_is_thumb_function_name = FALSE;
769
770 /* Literal pool structure.  Held on a per-section
771    and per-sub-section basis.  */
772
773 #define MAX_LITERAL_POOL_SIZE 1024
774 typedef struct literal_pool
775 {
776   expressionS            literals [MAX_LITERAL_POOL_SIZE];
777   unsigned int           next_free_entry;
778   unsigned int           id;
779   symbolS *              symbol;
780   segT                   section;
781   subsegT                sub_section;
782 #ifdef OBJ_ELF
783   struct dwarf2_line_info locs [MAX_LITERAL_POOL_SIZE];
784 #endif
785   struct literal_pool *  next;
786 } literal_pool;
787
788 /* Pointer to a linked list of literal pools.  */
789 literal_pool * list_of_pools = NULL;
790
791 #ifdef OBJ_ELF
792 #  define now_it seg_info (now_seg)->tc_segment_info_data.current_it
793 #else
794 static struct current_it now_it;
795 #endif
796
797 static inline int
798 now_it_compatible (int cond)
799 {
800   return (cond & ~1) == (now_it.cc & ~1);
801 }
802
803 static inline int
804 conditional_insn (void)
805 {
806   return inst.cond != COND_ALWAYS;
807 }
808
809 static int in_it_block (void);
810
811 static int handle_it_state (void);
812
813 static void force_automatic_it_block_close (void);
814
815 static void it_fsm_post_encode (void);
816
817 #define set_it_insn_type(type)                  \
818   do                                            \
819     {                                           \
820       inst.it_insn_type = type;                 \
821       if (handle_it_state () == FAIL)           \
822         return;                                 \
823     }                                           \
824   while (0)
825
826 #define set_it_insn_type_nonvoid(type, failret) \
827   do                                            \
828     {                                           \
829       inst.it_insn_type = type;                 \
830       if (handle_it_state () == FAIL)           \
831         return failret;                         \
832     }                                           \
833   while(0)
834
835 #define set_it_insn_type_last()                         \
836   do                                                    \
837     {                                                   \
838       if (inst.cond == COND_ALWAYS)                     \
839         set_it_insn_type (IF_INSIDE_IT_LAST_INSN);      \
840       else                                              \
841         set_it_insn_type (INSIDE_IT_LAST_INSN);         \
842     }                                                   \
843   while (0)
844
845 /* Pure syntax.  */
846
847 /* This array holds the chars that always start a comment.  If the
848    pre-processor is disabled, these aren't very useful.  */
849 const char comment_chars[] = "@";
850
851 /* This array holds the chars that only start a comment at the beginning of
852    a line.  If the line seems to have the form '# 123 filename'
853    .line and .file directives will appear in the pre-processed output.  */
854 /* Note that input_file.c hand checks for '#' at the beginning of the
855    first line of the input file.  This is because the compiler outputs
856    #NO_APP at the beginning of its output.  */
857 /* Also note that comments like this one will always work.  */
858 const char line_comment_chars[] = "#";
859
860 const char line_separator_chars[] = ";";
861
862 /* Chars that can be used to separate mant
863    from exp in floating point numbers.  */
864 const char EXP_CHARS[] = "eE";
865
866 /* Chars that mean this number is a floating point constant.  */
867 /* As in 0f12.456  */
868 /* or    0d1.2345e12  */
869
870 const char FLT_CHARS[] = "rRsSfFdDxXeEpP";
871
872 /* Prefix characters that indicate the start of an immediate
873    value.  */
874 #define is_immediate_prefix(C) ((C) == '#' || (C) == '$')
875
876 /* Separator character handling.  */
877
878 #define skip_whitespace(str)  do { if (*(str) == ' ') ++(str); } while (0)
879
880 static inline int
881 skip_past_char (char ** str, char c)
882 {
883   if (**str == c)
884     {
885       (*str)++;
886       return SUCCESS;
887     }
888   else
889     return FAIL;
890 }
891
892 #define skip_past_comma(str) skip_past_char (str, ',')
893
894 /* Arithmetic expressions (possibly involving symbols).  */
895
896 /* Return TRUE if anything in the expression is a bignum.  */
897
898 static int
899 walk_no_bignums (symbolS * sp)
900 {
901   if (symbol_get_value_expression (sp)->X_op == O_big)
902     return 1;
903
904   if (symbol_get_value_expression (sp)->X_add_symbol)
905     {
906       return (walk_no_bignums (symbol_get_value_expression (sp)->X_add_symbol)
907               || (symbol_get_value_expression (sp)->X_op_symbol
908                   && walk_no_bignums (symbol_get_value_expression (sp)->X_op_symbol)));
909     }
910
911   return 0;
912 }
913
914 static int in_my_get_expression = 0;
915
916 /* Third argument to my_get_expression.  */
917 #define GE_NO_PREFIX 0
918 #define GE_IMM_PREFIX 1
919 #define GE_OPT_PREFIX 2
920 /* This is a bit of a hack. Use an optional prefix, and also allow big (64-bit)
921    immediates, as can be used in Neon VMVN and VMOV immediate instructions.  */
922 #define GE_OPT_PREFIX_BIG 3
923
924 static int
925 my_get_expression (expressionS * ep, char ** str, int prefix_mode)
926 {
927   char * save_in;
928   segT   seg;
929
930   /* In unified syntax, all prefixes are optional.  */
931   if (unified_syntax)
932     prefix_mode = (prefix_mode == GE_OPT_PREFIX_BIG) ? prefix_mode
933                   : GE_OPT_PREFIX;
934
935   switch (prefix_mode)
936     {
937     case GE_NO_PREFIX: break;
938     case GE_IMM_PREFIX:
939       if (!is_immediate_prefix (**str))
940         {
941           inst.error = _("immediate expression requires a # prefix");
942           return FAIL;
943         }
944       (*str)++;
945       break;
946     case GE_OPT_PREFIX:
947     case GE_OPT_PREFIX_BIG:
948       if (is_immediate_prefix (**str))
949         (*str)++;
950       break;
951     default: abort ();
952     }
953
954   memset (ep, 0, sizeof (expressionS));
955
956   save_in = input_line_pointer;
957   input_line_pointer = *str;
958   in_my_get_expression = 1;
959   seg = expression (ep);
960   in_my_get_expression = 0;
961
962   if (ep->X_op == O_illegal || ep->X_op == O_absent)
963     {
964       /* We found a bad or missing expression in md_operand().  */
965       *str = input_line_pointer;
966       input_line_pointer = save_in;
967       if (inst.error == NULL)
968         inst.error = (ep->X_op == O_absent
969                       ? _("missing expression") :_("bad expression"));
970       return 1;
971     }
972
973 #ifdef OBJ_AOUT
974   if (seg != absolute_section
975       && seg != text_section
976       && seg != data_section
977       && seg != bss_section
978       && seg != undefined_section)
979     {
980       inst.error = _("bad segment");
981       *str = input_line_pointer;
982       input_line_pointer = save_in;
983       return 1;
984     }
985 #else
986   (void) seg;
987 #endif
988
989   /* Get rid of any bignums now, so that we don't generate an error for which
990      we can't establish a line number later on.  Big numbers are never valid
991      in instructions, which is where this routine is always called.  */
992   if (prefix_mode != GE_OPT_PREFIX_BIG
993       && (ep->X_op == O_big
994           || (ep->X_add_symbol
995               && (walk_no_bignums (ep->X_add_symbol)
996                   || (ep->X_op_symbol
997                       && walk_no_bignums (ep->X_op_symbol))))))
998     {
999       inst.error = _("invalid constant");
1000       *str = input_line_pointer;
1001       input_line_pointer = save_in;
1002       return 1;
1003     }
1004
1005   *str = input_line_pointer;
1006   input_line_pointer = save_in;
1007   return 0;
1008 }
1009
1010 /* Turn a string in input_line_pointer into a floating point constant
1011    of type TYPE, and store the appropriate bytes in *LITP.  The number
1012    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
1013    returned, or NULL on OK.
1014
1015    Note that fp constants aren't represent in the normal way on the ARM.
1016    In big endian mode, things are as expected.  However, in little endian
1017    mode fp constants are big-endian word-wise, and little-endian byte-wise
1018    within the words.  For example, (double) 1.1 in big endian mode is
1019    the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is
1020    the byte sequence 99 99 f1 3f 9a 99 99 99.
1021
1022    ??? The format of 12 byte floats is uncertain according to gcc's arm.h.  */
1023
1024 char *
1025 md_atof (int type, char * litP, int * sizeP)
1026 {
1027   int prec;
1028   LITTLENUM_TYPE words[MAX_LITTLENUMS];
1029   char *t;
1030   int i;
1031
1032   switch (type)
1033     {
1034     case 'f':
1035     case 'F':
1036     case 's':
1037     case 'S':
1038       prec = 2;
1039       break;
1040
1041     case 'd':
1042     case 'D':
1043     case 'r':
1044     case 'R':
1045       prec = 4;
1046       break;
1047
1048     case 'x':
1049     case 'X':
1050       prec = 5;
1051       break;
1052
1053     case 'p':
1054     case 'P':
1055       prec = 5;
1056       break;
1057
1058     default:
1059       *sizeP = 0;
1060       return _("Unrecognized or unsupported floating point constant");
1061     }
1062
1063   t = atof_ieee (input_line_pointer, type, words);
1064   if (t)
1065     input_line_pointer = t;
1066   *sizeP = prec * sizeof (LITTLENUM_TYPE);
1067
1068   if (target_big_endian)
1069     {
1070       for (i = 0; i < prec; i++)
1071         {
1072           md_number_to_chars (litP, (valueT) words[i], sizeof (LITTLENUM_TYPE));
1073           litP += sizeof (LITTLENUM_TYPE);
1074         }
1075     }
1076   else
1077     {
1078       if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_endian_pure))
1079         for (i = prec - 1; i >= 0; i--)
1080           {
1081             md_number_to_chars (litP, (valueT) words[i], sizeof (LITTLENUM_TYPE));
1082             litP += sizeof (LITTLENUM_TYPE);
1083           }
1084       else
1085         /* For a 4 byte float the order of elements in `words' is 1 0.
1086            For an 8 byte float the order is 1 0 3 2.  */
1087         for (i = 0; i < prec; i += 2)
1088           {
1089             md_number_to_chars (litP, (valueT) words[i + 1],
1090                                 sizeof (LITTLENUM_TYPE));
1091             md_number_to_chars (litP + sizeof (LITTLENUM_TYPE),
1092                                 (valueT) words[i], sizeof (LITTLENUM_TYPE));
1093             litP += 2 * sizeof (LITTLENUM_TYPE);
1094           }
1095     }
1096
1097   return NULL;
1098 }
1099
1100 /* We handle all bad expressions here, so that we can report the faulty
1101    instruction in the error message.  */
1102 void
1103 md_operand (expressionS * exp)
1104 {
1105   if (in_my_get_expression)
1106     exp->X_op = O_illegal;
1107 }
1108
1109 /* Immediate values.  */
1110
1111 /* Generic immediate-value read function for use in directives.
1112    Accepts anything that 'expression' can fold to a constant.
1113    *val receives the number.  */
1114 #ifdef OBJ_ELF
1115 static int
1116 immediate_for_directive (int *val)
1117 {
1118   expressionS exp;
1119   exp.X_op = O_illegal;
1120
1121   if (is_immediate_prefix (*input_line_pointer))
1122     {
1123       input_line_pointer++;
1124       expression (&exp);
1125     }
1126
1127   if (exp.X_op != O_constant)
1128     {
1129       as_bad (_("expected #constant"));
1130       ignore_rest_of_line ();
1131       return FAIL;
1132     }
1133   *val = exp.X_add_number;
1134   return SUCCESS;
1135 }
1136 #endif
1137
1138 /* Register parsing.  */
1139
1140 /* Generic register parser.  CCP points to what should be the
1141    beginning of a register name.  If it is indeed a valid register
1142    name, advance CCP over it and return the reg_entry structure;
1143    otherwise return NULL.  Does not issue diagnostics.  */
1144
1145 static struct reg_entry *
1146 arm_reg_parse_multi (char **ccp)
1147 {
1148   char *start = *ccp;
1149   char *p;
1150   struct reg_entry *reg;
1151
1152 #ifdef REGISTER_PREFIX
1153   if (*start != REGISTER_PREFIX)
1154     return NULL;
1155   start++;
1156 #endif
1157 #ifdef OPTIONAL_REGISTER_PREFIX
1158   if (*start == OPTIONAL_REGISTER_PREFIX)
1159     start++;
1160 #endif
1161
1162   p = start;
1163   if (!ISALPHA (*p) || !is_name_beginner (*p))
1164     return NULL;
1165
1166   do
1167     p++;
1168   while (ISALPHA (*p) || ISDIGIT (*p) || *p == '_');
1169
1170   reg = (struct reg_entry *) hash_find_n (arm_reg_hsh, start, p - start);
1171
1172   if (!reg)
1173     return NULL;
1174
1175   *ccp = p;
1176   return reg;
1177 }
1178
1179 static int
1180 arm_reg_alt_syntax (char **ccp, char *start, struct reg_entry *reg,
1181                     enum arm_reg_type type)
1182 {
1183   /* Alternative syntaxes are accepted for a few register classes.  */
1184   switch (type)
1185     {
1186     case REG_TYPE_MVF:
1187     case REG_TYPE_MVD:
1188     case REG_TYPE_MVFX:
1189     case REG_TYPE_MVDX:
1190       /* Generic coprocessor register names are allowed for these.  */
1191       if (reg && reg->type == REG_TYPE_CN)
1192         return reg->number;
1193       break;
1194
1195     case REG_TYPE_CP:
1196       /* For backward compatibility, a bare number is valid here.  */
1197       {
1198         unsigned long processor = strtoul (start, ccp, 10);
1199         if (*ccp != start && processor <= 15)
1200           return processor;
1201       }
1202
1203     case REG_TYPE_MMXWC:
1204       /* WC includes WCG.  ??? I'm not sure this is true for all
1205          instructions that take WC registers.  */
1206       if (reg && reg->type == REG_TYPE_MMXWCG)
1207         return reg->number;
1208       break;
1209
1210     default:
1211       break;
1212     }
1213
1214   return FAIL;
1215 }
1216
1217 /* As arm_reg_parse_multi, but the register must be of type TYPE, and the
1218    return value is the register number or FAIL.  */
1219
1220 static int
1221 arm_reg_parse (char **ccp, enum arm_reg_type type)
1222 {
1223   char *start = *ccp;
1224   struct reg_entry *reg = arm_reg_parse_multi (ccp);
1225   int ret;
1226
1227   /* Do not allow a scalar (reg+index) to parse as a register.  */
1228   if (reg && reg->neon && (reg->neon->defined & NTA_HASINDEX))
1229     return FAIL;
1230
1231   if (reg && reg->type == type)
1232     return reg->number;
1233
1234   if ((ret = arm_reg_alt_syntax (ccp, start, reg, type)) != FAIL)
1235     return ret;
1236
1237   *ccp = start;
1238   return FAIL;
1239 }
1240
1241 /* Parse a Neon type specifier. *STR should point at the leading '.'
1242    character. Does no verification at this stage that the type fits the opcode
1243    properly. E.g.,
1244
1245      .i32.i32.s16
1246      .s32.f32
1247      .u16
1248
1249    Can all be legally parsed by this function.
1250
1251    Fills in neon_type struct pointer with parsed information, and updates STR
1252    to point after the parsed type specifier. Returns SUCCESS if this was a legal
1253    type, FAIL if not.  */
1254
1255 static int
1256 parse_neon_type (struct neon_type *type, char **str)
1257 {
1258   char *ptr = *str;
1259
1260   if (type)
1261     type->elems = 0;
1262
1263   while (type->elems < NEON_MAX_TYPE_ELS)
1264     {
1265       enum neon_el_type thistype = NT_untyped;
1266       unsigned thissize = -1u;
1267
1268       if (*ptr != '.')
1269         break;
1270
1271       ptr++;
1272
1273       /* Just a size without an explicit type.  */
1274       if (ISDIGIT (*ptr))
1275         goto parsesize;
1276
1277       switch (TOLOWER (*ptr))
1278         {
1279         case 'i': thistype = NT_integer; break;
1280         case 'f': thistype = NT_float; break;
1281         case 'p': thistype = NT_poly; break;
1282         case 's': thistype = NT_signed; break;
1283         case 'u': thistype = NT_unsigned; break;
1284         case 'd':
1285           thistype = NT_float;
1286           thissize = 64;
1287           ptr++;
1288           goto done;
1289         default:
1290           as_bad (_("unexpected character `%c' in type specifier"), *ptr);
1291           return FAIL;
1292         }
1293
1294       ptr++;
1295
1296       /* .f is an abbreviation for .f32.  */
1297       if (thistype == NT_float && !ISDIGIT (*ptr))
1298         thissize = 32;
1299       else
1300         {
1301         parsesize:
1302           thissize = strtoul (ptr, &ptr, 10);
1303
1304           if (thissize != 8 && thissize != 16 && thissize != 32
1305               && thissize != 64)
1306             {
1307               as_bad (_("bad size %d in type specifier"), thissize);
1308               return FAIL;
1309             }
1310         }
1311
1312       done:
1313       if (type)
1314         {
1315           type->el[type->elems].type = thistype;
1316           type->el[type->elems].size = thissize;
1317           type->elems++;
1318         }
1319     }
1320
1321   /* Empty/missing type is not a successful parse.  */
1322   if (type->elems == 0)
1323     return FAIL;
1324
1325   *str = ptr;
1326
1327   return SUCCESS;
1328 }
1329
1330 /* Errors may be set multiple times during parsing or bit encoding
1331    (particularly in the Neon bits), but usually the earliest error which is set
1332    will be the most meaningful. Avoid overwriting it with later (cascading)
1333    errors by calling this function.  */
1334
1335 static void
1336 first_error (const char *err)
1337 {
1338   if (!inst.error)
1339     inst.error = err;
1340 }
1341
1342 /* Parse a single type, e.g. ".s32", leading period included.  */
1343 static int
1344 parse_neon_operand_type (struct neon_type_el *vectype, char **ccp)
1345 {
1346   char *str = *ccp;
1347   struct neon_type optype;
1348
1349   if (*str == '.')
1350     {
1351       if (parse_neon_type (&optype, &str) == SUCCESS)
1352         {
1353           if (optype.elems == 1)
1354             *vectype = optype.el[0];
1355           else
1356             {
1357               first_error (_("only one type should be specified for operand"));
1358               return FAIL;
1359             }
1360         }
1361       else
1362         {
1363           first_error (_("vector type expected"));
1364           return FAIL;
1365         }
1366     }
1367   else
1368     return FAIL;
1369
1370   *ccp = str;
1371
1372   return SUCCESS;
1373 }
1374
1375 /* Special meanings for indices (which have a range of 0-7), which will fit into
1376    a 4-bit integer.  */
1377
1378 #define NEON_ALL_LANES          15
1379 #define NEON_INTERLEAVE_LANES   14
1380
1381 /* Parse either a register or a scalar, with an optional type. Return the
1382    register number, and optionally fill in the actual type of the register
1383    when multiple alternatives were given (NEON_TYPE_NDQ) in *RTYPE, and
1384    type/index information in *TYPEINFO.  */
1385
1386 static int
1387 parse_typed_reg_or_scalar (char **ccp, enum arm_reg_type type,
1388                            enum arm_reg_type *rtype,
1389                            struct neon_typed_alias *typeinfo)
1390 {
1391   char *str = *ccp;
1392   struct reg_entry *reg = arm_reg_parse_multi (&str);
1393   struct neon_typed_alias atype;
1394   struct neon_type_el parsetype;
1395
1396   atype.defined = 0;
1397   atype.index = -1;
1398   atype.eltype.type = NT_invtype;
1399   atype.eltype.size = -1;
1400
1401   /* Try alternate syntax for some types of register. Note these are mutually
1402      exclusive with the Neon syntax extensions.  */
1403   if (reg == NULL)
1404     {
1405       int altreg = arm_reg_alt_syntax (&str, *ccp, reg, type);
1406       if (altreg != FAIL)
1407         *ccp = str;
1408       if (typeinfo)
1409         *typeinfo = atype;
1410       return altreg;
1411     }
1412
1413   /* Undo polymorphism when a set of register types may be accepted.  */
1414   if ((type == REG_TYPE_NDQ
1415        && (reg->type == REG_TYPE_NQ || reg->type == REG_TYPE_VFD))
1416       || (type == REG_TYPE_VFSD
1417           && (reg->type == REG_TYPE_VFS || reg->type == REG_TYPE_VFD))
1418       || (type == REG_TYPE_NSDQ
1419           && (reg->type == REG_TYPE_VFS || reg->type == REG_TYPE_VFD
1420               || reg->type == REG_TYPE_NQ))
1421       || (type == REG_TYPE_MMXWC
1422           && (reg->type == REG_TYPE_MMXWCG)))
1423     type = (enum arm_reg_type) reg->type;
1424
1425   if (type != reg->type)
1426     return FAIL;
1427
1428   if (reg->neon)
1429     atype = *reg->neon;
1430
1431   if (parse_neon_operand_type (&parsetype, &str) == SUCCESS)
1432     {
1433       if ((atype.defined & NTA_HASTYPE) != 0)
1434         {
1435           first_error (_("can't redefine type for operand"));
1436           return FAIL;
1437         }
1438       atype.defined |= NTA_HASTYPE;
1439       atype.eltype = parsetype;
1440     }
1441
1442   if (skip_past_char (&str, '[') == SUCCESS)
1443     {
1444       if (type != REG_TYPE_VFD)
1445         {
1446           first_error (_("only D registers may be indexed"));
1447           return FAIL;
1448         }
1449
1450       if ((atype.defined & NTA_HASINDEX) != 0)
1451         {
1452           first_error (_("can't change index for operand"));
1453           return FAIL;
1454         }
1455
1456       atype.defined |= NTA_HASINDEX;
1457
1458       if (skip_past_char (&str, ']') == SUCCESS)
1459         atype.index = NEON_ALL_LANES;
1460       else
1461         {
1462           expressionS exp;
1463
1464           my_get_expression (&exp, &str, GE_NO_PREFIX);
1465
1466           if (exp.X_op != O_constant)
1467             {
1468               first_error (_("constant expression required"));
1469               return FAIL;
1470             }
1471
1472           if (skip_past_char (&str, ']') == FAIL)
1473             return FAIL;
1474
1475           atype.index = exp.X_add_number;
1476         }
1477     }
1478
1479   if (typeinfo)
1480     *typeinfo = atype;
1481
1482   if (rtype)
1483     *rtype = type;
1484
1485   *ccp = str;
1486
1487   return reg->number;
1488 }
1489
1490 /* Like arm_reg_parse, but allow allow the following extra features:
1491     - If RTYPE is non-zero, return the (possibly restricted) type of the
1492       register (e.g. Neon double or quad reg when either has been requested).
1493     - If this is a Neon vector type with additional type information, fill
1494       in the struct pointed to by VECTYPE (if non-NULL).
1495    This function will fault on encountering a scalar.  */
1496
1497 static int
1498 arm_typed_reg_parse (char **ccp, enum arm_reg_type type,
1499                      enum arm_reg_type *rtype, struct neon_type_el *vectype)
1500 {
1501   struct neon_typed_alias atype;
1502   char *str = *ccp;
1503   int reg = parse_typed_reg_or_scalar (&str, type, rtype, &atype);
1504
1505   if (reg == FAIL)
1506     return FAIL;
1507
1508   /* Do not allow regname(... to parse as a register.  */
1509   if (*str == '(')
1510     return FAIL;
1511
1512   /* Do not allow a scalar (reg+index) to parse as a register.  */
1513   if ((atype.defined & NTA_HASINDEX) != 0)
1514     {
1515       first_error (_("register operand expected, but got scalar"));
1516       return FAIL;
1517     }
1518
1519   if (vectype)
1520     *vectype = atype.eltype;
1521
1522   *ccp = str;
1523
1524   return reg;
1525 }
1526
1527 #define NEON_SCALAR_REG(X)      ((X) >> 4)
1528 #define NEON_SCALAR_INDEX(X)    ((X) & 15)
1529
1530 /* Parse a Neon scalar. Most of the time when we're parsing a scalar, we don't
1531    have enough information to be able to do a good job bounds-checking. So, we
1532    just do easy checks here, and do further checks later.  */
1533
1534 static int
1535 parse_scalar (char **ccp, int elsize, struct neon_type_el *type)
1536 {
1537   int reg;
1538   char *str = *ccp;
1539   struct neon_typed_alias atype;
1540
1541   reg = parse_typed_reg_or_scalar (&str, REG_TYPE_VFD, NULL, &atype);
1542
1543   if (reg == FAIL || (atype.defined & NTA_HASINDEX) == 0)
1544     return FAIL;
1545
1546   if (atype.index == NEON_ALL_LANES)
1547     {
1548       first_error (_("scalar must have an index"));
1549       return FAIL;
1550     }
1551   else if (atype.index >= 64 / elsize)
1552     {
1553       first_error (_("scalar index out of range"));
1554       return FAIL;
1555     }
1556
1557   if (type)
1558     *type = atype.eltype;
1559
1560   *ccp = str;
1561
1562   return reg * 16 + atype.index;
1563 }
1564
1565 /* Parse an ARM register list.  Returns the bitmask, or FAIL.  */
1566
1567 static long
1568 parse_reg_list (char ** strp)
1569 {
1570   char * str = * strp;
1571   long   range = 0;
1572   int    another_range;
1573
1574   /* We come back here if we get ranges concatenated by '+' or '|'.  */
1575   do
1576     {
1577       another_range = 0;
1578
1579       if (*str == '{')
1580         {
1581           int in_range = 0;
1582           int cur_reg = -1;
1583
1584           str++;
1585           do
1586             {
1587               int reg;
1588
1589               if ((reg = arm_reg_parse (&str, REG_TYPE_RN)) == FAIL)
1590                 {
1591                   first_error (_(reg_expected_msgs[REG_TYPE_RN]));
1592                   return FAIL;
1593                 }
1594
1595               if (in_range)
1596                 {
1597                   int i;
1598
1599                   if (reg <= cur_reg)
1600                     {
1601                       first_error (_("bad range in register list"));
1602                       return FAIL;
1603                     }
1604
1605                   for (i = cur_reg + 1; i < reg; i++)
1606                     {
1607                       if (range & (1 << i))
1608                         as_tsktsk
1609                           (_("Warning: duplicated register (r%d) in register list"),
1610                            i);
1611                       else
1612                         range |= 1 << i;
1613                     }
1614                   in_range = 0;
1615                 }
1616
1617               if (range & (1 << reg))
1618                 as_tsktsk (_("Warning: duplicated register (r%d) in register list"),
1619                            reg);
1620               else if (reg <= cur_reg)
1621                 as_tsktsk (_("Warning: register range not in ascending order"));
1622
1623               range |= 1 << reg;
1624               cur_reg = reg;
1625             }
1626           while (skip_past_comma (&str) != FAIL
1627                  || (in_range = 1, *str++ == '-'));
1628           str--;
1629
1630           if (*str++ != '}')
1631             {
1632               first_error (_("missing `}'"));
1633               return FAIL;
1634             }
1635         }
1636       else
1637         {
1638           expressionS exp;
1639
1640           if (my_get_expression (&exp, &str, GE_NO_PREFIX))
1641             return FAIL;
1642
1643           if (exp.X_op == O_constant)
1644             {
1645               if (exp.X_add_number
1646                   != (exp.X_add_number & 0x0000ffff))
1647                 {
1648                   inst.error = _("invalid register mask");
1649                   return FAIL;
1650                 }
1651
1652               if ((range & exp.X_add_number) != 0)
1653                 {
1654                   int regno = range & exp.X_add_number;
1655
1656                   regno &= -regno;
1657                   regno = (1 << regno) - 1;
1658                   as_tsktsk
1659                     (_("Warning: duplicated register (r%d) in register list"),
1660                      regno);
1661                 }
1662
1663               range |= exp.X_add_number;
1664             }
1665           else
1666             {
1667               if (inst.reloc.type != 0)
1668                 {
1669                   inst.error = _("expression too complex");
1670                   return FAIL;
1671                 }
1672
1673               memcpy (&inst.reloc.exp, &exp, sizeof (expressionS));
1674               inst.reloc.type = BFD_RELOC_ARM_MULTI;
1675               inst.reloc.pc_rel = 0;
1676             }
1677         }
1678
1679       if (*str == '|' || *str == '+')
1680         {
1681           str++;
1682           another_range = 1;
1683         }
1684     }
1685   while (another_range);
1686
1687   *strp = str;
1688   return range;
1689 }
1690
1691 /* Types of registers in a list.  */
1692
1693 enum reg_list_els
1694 {
1695   REGLIST_VFP_S,
1696   REGLIST_VFP_D,
1697   REGLIST_NEON_D
1698 };
1699
1700 /* Parse a VFP register list.  If the string is invalid return FAIL.
1701    Otherwise return the number of registers, and set PBASE to the first
1702    register.  Parses registers of type ETYPE.
1703    If REGLIST_NEON_D is used, several syntax enhancements are enabled:
1704      - Q registers can be used to specify pairs of D registers
1705      - { } can be omitted from around a singleton register list
1706          FIXME: This is not implemented, as it would require backtracking in
1707          some cases, e.g.:
1708            vtbl.8 d3,d4,d5
1709          This could be done (the meaning isn't really ambiguous), but doesn't
1710          fit in well with the current parsing framework.
1711      - 32 D registers may be used (also true for VFPv3).
1712    FIXME: Types are ignored in these register lists, which is probably a
1713    bug.  */
1714
1715 static int
1716 parse_vfp_reg_list (char **ccp, unsigned int *pbase, enum reg_list_els etype)
1717 {
1718   char *str = *ccp;
1719   int base_reg;
1720   int new_base;
1721   enum arm_reg_type regtype = (enum arm_reg_type) 0;
1722   int max_regs = 0;
1723   int count = 0;
1724   int warned = 0;
1725   unsigned long mask = 0;
1726   int i;
1727
1728   if (*str != '{')
1729     {
1730       inst.error = _("expecting {");
1731       return FAIL;
1732     }
1733
1734   str++;
1735
1736   switch (etype)
1737     {
1738     case REGLIST_VFP_S:
1739       regtype = REG_TYPE_VFS;
1740       max_regs = 32;
1741       break;
1742
1743     case REGLIST_VFP_D:
1744       regtype = REG_TYPE_VFD;
1745       break;
1746
1747     case REGLIST_NEON_D:
1748       regtype = REG_TYPE_NDQ;
1749       break;
1750     }
1751
1752   if (etype != REGLIST_VFP_S)
1753     {
1754       /* VFPv3 allows 32 D registers, except for the VFPv3-D16 variant.  */
1755       if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_d32))
1756         {
1757           max_regs = 32;
1758           if (thumb_mode)
1759             ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
1760                                     fpu_vfp_ext_d32);
1761           else
1762             ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used,
1763                                     fpu_vfp_ext_d32);
1764         }
1765       else
1766         max_regs = 16;
1767     }
1768
1769   base_reg = max_regs;
1770
1771   do
1772     {
1773       int setmask = 1, addregs = 1;
1774
1775       new_base = arm_typed_reg_parse (&str, regtype, &regtype, NULL);
1776
1777       if (new_base == FAIL)
1778         {
1779           first_error (_(reg_expected_msgs[regtype]));
1780           return FAIL;
1781         }
1782
1783       if (new_base >= max_regs)
1784         {
1785           first_error (_("register out of range in list"));
1786           return FAIL;
1787         }
1788
1789       /* Note: a value of 2 * n is returned for the register Q<n>.  */
1790       if (regtype == REG_TYPE_NQ)
1791         {
1792           setmask = 3;
1793           addregs = 2;
1794         }
1795
1796       if (new_base < base_reg)
1797         base_reg = new_base;
1798
1799       if (mask & (setmask << new_base))
1800         {
1801           first_error (_("invalid register list"));
1802           return FAIL;
1803         }
1804
1805       if ((mask >> new_base) != 0 && ! warned)
1806         {
1807           as_tsktsk (_("register list not in ascending order"));
1808           warned = 1;
1809         }
1810
1811       mask |= setmask << new_base;
1812       count += addregs;
1813
1814       if (*str == '-') /* We have the start of a range expression */
1815         {
1816           int high_range;
1817
1818           str++;
1819
1820           if ((high_range = arm_typed_reg_parse (&str, regtype, NULL, NULL))
1821               == FAIL)
1822             {
1823               inst.error = gettext (reg_expected_msgs[regtype]);
1824               return FAIL;
1825             }
1826
1827           if (high_range >= max_regs)
1828             {
1829               first_error (_("register out of range in list"));
1830               return FAIL;
1831             }
1832
1833           if (regtype == REG_TYPE_NQ)
1834             high_range = high_range + 1;
1835
1836           if (high_range <= new_base)
1837             {
1838               inst.error = _("register range not in ascending order");
1839               return FAIL;
1840             }
1841
1842           for (new_base += addregs; new_base <= high_range; new_base += addregs)
1843             {
1844               if (mask & (setmask << new_base))
1845                 {
1846                   inst.error = _("invalid register list");
1847                   return FAIL;
1848                 }
1849
1850               mask |= setmask << new_base;
1851               count += addregs;
1852             }
1853         }
1854     }
1855   while (skip_past_comma (&str) != FAIL);
1856
1857   str++;
1858
1859   /* Sanity check -- should have raised a parse error above.  */
1860   if (count == 0 || count > max_regs)
1861     abort ();
1862
1863   *pbase = base_reg;
1864
1865   /* Final test -- the registers must be consecutive.  */
1866   mask >>= base_reg;
1867   for (i = 0; i < count; i++)
1868     {
1869       if ((mask & (1u << i)) == 0)
1870         {
1871           inst.error = _("non-contiguous register range");
1872           return FAIL;
1873         }
1874     }
1875
1876   *ccp = str;
1877
1878   return count;
1879 }
1880
1881 /* True if two alias types are the same.  */
1882
1883 static bfd_boolean
1884 neon_alias_types_same (struct neon_typed_alias *a, struct neon_typed_alias *b)
1885 {
1886   if (!a && !b)
1887     return TRUE;
1888
1889   if (!a || !b)
1890     return FALSE;
1891
1892   if (a->defined != b->defined)
1893     return FALSE;
1894
1895   if ((a->defined & NTA_HASTYPE) != 0
1896       && (a->eltype.type != b->eltype.type
1897           || a->eltype.size != b->eltype.size))
1898     return FALSE;
1899
1900   if ((a->defined & NTA_HASINDEX) != 0
1901       && (a->index != b->index))
1902     return FALSE;
1903
1904   return TRUE;
1905 }
1906
1907 /* Parse element/structure lists for Neon VLD<n> and VST<n> instructions.
1908    The base register is put in *PBASE.
1909    The lane (or one of the NEON_*_LANES constants) is placed in bits [3:0] of
1910    the return value.
1911    The register stride (minus one) is put in bit 4 of the return value.
1912    Bits [6:5] encode the list length (minus one).
1913    The type of the list elements is put in *ELTYPE, if non-NULL.  */
1914
1915 #define NEON_LANE(X)            ((X) & 0xf)
1916 #define NEON_REG_STRIDE(X)      ((((X) >> 4) & 1) + 1)
1917 #define NEON_REGLIST_LENGTH(X)  ((((X) >> 5) & 3) + 1)
1918
1919 static int
1920 parse_neon_el_struct_list (char **str, unsigned *pbase,
1921                            struct neon_type_el *eltype)
1922 {
1923   char *ptr = *str;
1924   int base_reg = -1;
1925   int reg_incr = -1;
1926   int count = 0;
1927   int lane = -1;
1928   int leading_brace = 0;
1929   enum arm_reg_type rtype = REG_TYPE_NDQ;
1930   const char *const incr_error = _("register stride must be 1 or 2");
1931   const char *const type_error = _("mismatched element/structure types in list");
1932   struct neon_typed_alias firsttype;
1933
1934   if (skip_past_char (&ptr, '{') == SUCCESS)
1935     leading_brace = 1;
1936
1937   do
1938     {
1939       struct neon_typed_alias atype;
1940       int getreg = parse_typed_reg_or_scalar (&ptr, rtype, &rtype, &atype);
1941
1942       if (getreg == FAIL)
1943         {
1944           first_error (_(reg_expected_msgs[rtype]));
1945           return FAIL;
1946         }
1947
1948       if (base_reg == -1)
1949         {
1950           base_reg = getreg;
1951           if (rtype == REG_TYPE_NQ)
1952             {
1953               reg_incr = 1;
1954             }
1955           firsttype = atype;
1956         }
1957       else if (reg_incr == -1)
1958         {
1959           reg_incr = getreg - base_reg;
1960           if (reg_incr < 1 || reg_incr > 2)
1961             {
1962               first_error (_(incr_error));
1963               return FAIL;
1964             }
1965         }
1966       else if (getreg != base_reg + reg_incr * count)
1967         {
1968           first_error (_(incr_error));
1969           return FAIL;
1970         }
1971
1972       if (! neon_alias_types_same (&atype, &firsttype))
1973         {
1974           first_error (_(type_error));
1975           return FAIL;
1976         }
1977
1978       /* Handle Dn-Dm or Qn-Qm syntax. Can only be used with non-indexed list
1979          modes.  */
1980       if (ptr[0] == '-')
1981         {
1982           struct neon_typed_alias htype;
1983           int hireg, dregs = (rtype == REG_TYPE_NQ) ? 2 : 1;
1984           if (lane == -1)
1985             lane = NEON_INTERLEAVE_LANES;
1986           else if (lane != NEON_INTERLEAVE_LANES)
1987             {
1988               first_error (_(type_error));
1989               return FAIL;
1990             }
1991           if (reg_incr == -1)
1992             reg_incr = 1;
1993           else if (reg_incr != 1)
1994             {
1995               first_error (_("don't use Rn-Rm syntax with non-unit stride"));
1996               return FAIL;
1997             }
1998           ptr++;
1999           hireg = parse_typed_reg_or_scalar (&ptr, rtype, NULL, &htype);
2000           if (hireg == FAIL)
2001             {
2002               first_error (_(reg_expected_msgs[rtype]));
2003               return FAIL;
2004             }
2005           if (! neon_alias_types_same (&htype, &firsttype))
2006             {
2007               first_error (_(type_error));
2008               return FAIL;
2009             }
2010           count += hireg + dregs - getreg;
2011           continue;
2012         }
2013
2014       /* If we're using Q registers, we can't use [] or [n] syntax.  */
2015       if (rtype == REG_TYPE_NQ)
2016         {
2017           count += 2;
2018           continue;
2019         }
2020
2021       if ((atype.defined & NTA_HASINDEX) != 0)
2022         {
2023           if (lane == -1)
2024             lane = atype.index;
2025           else if (lane != atype.index)
2026             {
2027               first_error (_(type_error));
2028               return FAIL;
2029             }
2030         }
2031       else if (lane == -1)
2032         lane = NEON_INTERLEAVE_LANES;
2033       else if (lane != NEON_INTERLEAVE_LANES)
2034         {
2035           first_error (_(type_error));
2036           return FAIL;
2037         }
2038       count++;
2039     }
2040   while ((count != 1 || leading_brace) && skip_past_comma (&ptr) != FAIL);
2041
2042   /* No lane set by [x]. We must be interleaving structures.  */
2043   if (lane == -1)
2044     lane = NEON_INTERLEAVE_LANES;
2045
2046   /* Sanity check.  */
2047   if (lane == -1 || base_reg == -1 || count < 1 || count > 4
2048       || (count > 1 && reg_incr == -1))
2049     {
2050       first_error (_("error parsing element/structure list"));
2051       return FAIL;
2052     }
2053
2054   if ((count > 1 || leading_brace) && skip_past_char (&ptr, '}') == FAIL)
2055     {
2056       first_error (_("expected }"));
2057       return FAIL;
2058     }
2059
2060   if (reg_incr == -1)
2061     reg_incr = 1;
2062
2063   if (eltype)
2064     *eltype = firsttype.eltype;
2065
2066   *pbase = base_reg;
2067   *str = ptr;
2068
2069   return lane | ((reg_incr - 1) << 4) | ((count - 1) << 5);
2070 }
2071
2072 /* Parse an explicit relocation suffix on an expression.  This is
2073    either nothing, or a word in parentheses.  Note that if !OBJ_ELF,
2074    arm_reloc_hsh contains no entries, so this function can only
2075    succeed if there is no () after the word.  Returns -1 on error,
2076    BFD_RELOC_UNUSED if there wasn't any suffix.  */
2077
2078 static int
2079 parse_reloc (char **str)
2080 {
2081   struct reloc_entry *r;
2082   char *p, *q;
2083
2084   if (**str != '(')
2085     return BFD_RELOC_UNUSED;
2086
2087   p = *str + 1;
2088   q = p;
2089
2090   while (*q && *q != ')' && *q != ',')
2091     q++;
2092   if (*q != ')')
2093     return -1;
2094
2095   if ((r = (struct reloc_entry *)
2096        hash_find_n (arm_reloc_hsh, p, q - p)) == NULL)
2097     return -1;
2098
2099   *str = q + 1;
2100   return r->reloc;
2101 }
2102
2103 /* Directives: register aliases.  */
2104
2105 static struct reg_entry *
2106 insert_reg_alias (char *str, unsigned number, int type)
2107 {
2108   struct reg_entry *new_reg;
2109   const char *name;
2110
2111   if ((new_reg = (struct reg_entry *) hash_find (arm_reg_hsh, str)) != 0)
2112     {
2113       if (new_reg->builtin)
2114         as_warn (_("ignoring attempt to redefine built-in register '%s'"), str);
2115
2116       /* Only warn about a redefinition if it's not defined as the
2117          same register.  */
2118       else if (new_reg->number != number || new_reg->type != type)
2119         as_warn (_("ignoring redefinition of register alias '%s'"), str);
2120
2121       return NULL;
2122     }
2123
2124   name = xstrdup (str);
2125   new_reg = (struct reg_entry *) xmalloc (sizeof (struct reg_entry));
2126
2127   new_reg->name = name;
2128   new_reg->number = number;
2129   new_reg->type = type;
2130   new_reg->builtin = FALSE;
2131   new_reg->neon = NULL;
2132
2133   if (hash_insert (arm_reg_hsh, name, (void *) new_reg))
2134     abort ();
2135
2136   return new_reg;
2137 }
2138
2139 static void
2140 insert_neon_reg_alias (char *str, int number, int type,
2141                        struct neon_typed_alias *atype)
2142 {
2143   struct reg_entry *reg = insert_reg_alias (str, number, type);
2144
2145   if (!reg)
2146     {
2147       first_error (_("attempt to redefine typed alias"));
2148       return;
2149     }
2150
2151   if (atype)
2152     {
2153       reg->neon = (struct neon_typed_alias *)
2154           xmalloc (sizeof (struct neon_typed_alias));
2155       *reg->neon = *atype;
2156     }
2157 }
2158
2159 /* Look for the .req directive.  This is of the form:
2160
2161         new_register_name .req existing_register_name
2162
2163    If we find one, or if it looks sufficiently like one that we want to
2164    handle any error here, return TRUE.  Otherwise return FALSE.  */
2165
2166 static bfd_boolean
2167 create_register_alias (char * newname, char *p)
2168 {
2169   struct reg_entry *old;
2170   char *oldname, *nbuf;
2171   size_t nlen;
2172
2173   /* The input scrubber ensures that whitespace after the mnemonic is
2174      collapsed to single spaces.  */
2175   oldname = p;
2176   if (strncmp (oldname, " .req ", 6) != 0)
2177     return FALSE;
2178
2179   oldname += 6;
2180   if (*oldname == '\0')
2181     return FALSE;
2182
2183   old = (struct reg_entry *) hash_find (arm_reg_hsh, oldname);
2184   if (!old)
2185     {
2186       as_warn (_("unknown register '%s' -- .req ignored"), oldname);
2187       return TRUE;
2188     }
2189
2190   /* If TC_CASE_SENSITIVE is defined, then newname already points to
2191      the desired alias name, and p points to its end.  If not, then
2192      the desired alias name is in the global original_case_string.  */
2193 #ifdef TC_CASE_SENSITIVE
2194   nlen = p - newname;
2195 #else
2196   newname = original_case_string;
2197   nlen = strlen (newname);
2198 #endif
2199
2200   nbuf = (char *) alloca (nlen + 1);
2201   memcpy (nbuf, newname, nlen);
2202   nbuf[nlen] = '\0';
2203
2204   /* Create aliases under the new name as stated; an all-lowercase
2205      version of the new name; and an all-uppercase version of the new
2206      name.  */
2207   if (insert_reg_alias (nbuf, old->number, old->type) != NULL)
2208     {
2209       for (p = nbuf; *p; p++)
2210         *p = TOUPPER (*p);
2211
2212       if (strncmp (nbuf, newname, nlen))
2213         {
2214           /* If this attempt to create an additional alias fails, do not bother
2215              trying to create the all-lower case alias.  We will fail and issue
2216              a second, duplicate error message.  This situation arises when the
2217              programmer does something like:
2218                foo .req r0
2219                Foo .req r1
2220              The second .req creates the "Foo" alias but then fails to create
2221              the artificial FOO alias because it has already been created by the
2222              first .req.  */
2223           if (insert_reg_alias (nbuf, old->number, old->type) == NULL)
2224             return TRUE;
2225         }
2226
2227       for (p = nbuf; *p; p++)
2228         *p = TOLOWER (*p);
2229
2230       if (strncmp (nbuf, newname, nlen))
2231         insert_reg_alias (nbuf, old->number, old->type);
2232     }
2233
2234   return TRUE;
2235 }
2236
2237 /* Create a Neon typed/indexed register alias using directives, e.g.:
2238      X .dn d5.s32[1]
2239      Y .qn 6.s16
2240      Z .dn d7
2241      T .dn Z[0]
2242    These typed registers can be used instead of the types specified after the
2243    Neon mnemonic, so long as all operands given have types. Types can also be
2244    specified directly, e.g.:
2245      vadd d0.s32, d1.s32, d2.s32  */
2246
2247 static bfd_boolean
2248 create_neon_reg_alias (char *newname, char *p)
2249 {
2250   enum arm_reg_type basetype;
2251   struct reg_entry *basereg;
2252   struct reg_entry mybasereg;
2253   struct neon_type ntype;
2254   struct neon_typed_alias typeinfo;
2255   char *namebuf, *nameend ATTRIBUTE_UNUSED;
2256   int namelen;
2257
2258   typeinfo.defined = 0;
2259   typeinfo.eltype.type = NT_invtype;
2260   typeinfo.eltype.size = -1;
2261   typeinfo.index = -1;
2262
2263   nameend = p;
2264
2265   if (strncmp (p, " .dn ", 5) == 0)
2266     basetype = REG_TYPE_VFD;
2267   else if (strncmp (p, " .qn ", 5) == 0)
2268     basetype = REG_TYPE_NQ;
2269   else
2270     return FALSE;
2271
2272   p += 5;
2273
2274   if (*p == '\0')
2275     return FALSE;
2276
2277   basereg = arm_reg_parse_multi (&p);
2278
2279   if (basereg && basereg->type != basetype)
2280     {
2281       as_bad (_("bad type for register"));
2282       return FALSE;
2283     }
2284
2285   if (basereg == NULL)
2286     {
2287       expressionS exp;
2288       /* Try parsing as an integer.  */
2289       my_get_expression (&exp, &p, GE_NO_PREFIX);
2290       if (exp.X_op != O_constant)
2291         {
2292           as_bad (_("expression must be constant"));
2293           return FALSE;
2294         }
2295       basereg = &mybasereg;
2296       basereg->number = (basetype == REG_TYPE_NQ) ? exp.X_add_number * 2
2297                                                   : exp.X_add_number;
2298       basereg->neon = 0;
2299     }
2300
2301   if (basereg->neon)
2302     typeinfo = *basereg->neon;
2303
2304   if (parse_neon_type (&ntype, &p) == SUCCESS)
2305     {
2306       /* We got a type.  */
2307       if (typeinfo.defined & NTA_HASTYPE)
2308         {
2309           as_bad (_("can't redefine the type of a register alias"));
2310           return FALSE;
2311         }
2312
2313       typeinfo.defined |= NTA_HASTYPE;
2314       if (ntype.elems != 1)
2315         {
2316           as_bad (_("you must specify a single type only"));
2317           return FALSE;
2318         }
2319       typeinfo.eltype = ntype.el[0];
2320     }
2321
2322   if (skip_past_char (&p, '[') == SUCCESS)
2323     {
2324       expressionS exp;
2325       /* We got a scalar index.  */
2326
2327       if (typeinfo.defined & NTA_HASINDEX)
2328         {
2329           as_bad (_("can't redefine the index of a scalar alias"));
2330           return FALSE;
2331         }
2332
2333       my_get_expression (&exp, &p, GE_NO_PREFIX);
2334
2335       if (exp.X_op != O_constant)
2336         {
2337           as_bad (_("scalar index must be constant"));
2338           return FALSE;
2339         }
2340
2341       typeinfo.defined |= NTA_HASINDEX;
2342       typeinfo.index = exp.X_add_number;
2343
2344       if (skip_past_char (&p, ']') == FAIL)
2345         {
2346           as_bad (_("expecting ]"));
2347           return FALSE;
2348         }
2349     }
2350
2351   /* If TC_CASE_SENSITIVE is defined, then newname already points to
2352      the desired alias name, and p points to its end.  If not, then
2353      the desired alias name is in the global original_case_string.  */
2354 #ifdef TC_CASE_SENSITIVE
2355   namelen = nameend - newname;
2356 #else
2357   newname = original_case_string;
2358   namelen = strlen (newname);
2359 #endif
2360
2361   namebuf = (char *) alloca (namelen + 1);
2362   strncpy (namebuf, newname, namelen);
2363   namebuf[namelen] = '\0';
2364
2365   insert_neon_reg_alias (namebuf, basereg->number, basetype,
2366                          typeinfo.defined != 0 ? &typeinfo : NULL);
2367
2368   /* Insert name in all uppercase.  */
2369   for (p = namebuf; *p; p++)
2370     *p = TOUPPER (*p);
2371
2372   if (strncmp (namebuf, newname, namelen))
2373     insert_neon_reg_alias (namebuf, basereg->number, basetype,
2374                            typeinfo.defined != 0 ? &typeinfo : NULL);
2375
2376   /* Insert name in all lowercase.  */
2377   for (p = namebuf; *p; p++)
2378     *p = TOLOWER (*p);
2379
2380   if (strncmp (namebuf, newname, namelen))
2381     insert_neon_reg_alias (namebuf, basereg->number, basetype,
2382                            typeinfo.defined != 0 ? &typeinfo : NULL);
2383
2384   return TRUE;
2385 }
2386
2387 /* Should never be called, as .req goes between the alias and the
2388    register name, not at the beginning of the line.  */
2389
2390 static void
2391 s_req (int a ATTRIBUTE_UNUSED)
2392 {
2393   as_bad (_("invalid syntax for .req directive"));
2394 }
2395
2396 static void
2397 s_dn (int a ATTRIBUTE_UNUSED)
2398 {
2399   as_bad (_("invalid syntax for .dn directive"));
2400 }
2401
2402 static void
2403 s_qn (int a ATTRIBUTE_UNUSED)
2404 {
2405   as_bad (_("invalid syntax for .qn directive"));
2406 }
2407
2408 /* The .unreq directive deletes an alias which was previously defined
2409    by .req.  For example:
2410
2411        my_alias .req r11
2412        .unreq my_alias    */
2413
2414 static void
2415 s_unreq (int a ATTRIBUTE_UNUSED)
2416 {
2417   char * name;
2418   char saved_char;
2419
2420   name = input_line_pointer;
2421
2422   while (*input_line_pointer != 0
2423          && *input_line_pointer != ' '
2424          && *input_line_pointer != '\n')
2425     ++input_line_pointer;
2426
2427   saved_char = *input_line_pointer;
2428   *input_line_pointer = 0;
2429
2430   if (!*name)
2431     as_bad (_("invalid syntax for .unreq directive"));
2432   else
2433     {
2434       struct reg_entry *reg = (struct reg_entry *) hash_find (arm_reg_hsh,
2435                                                               name);
2436
2437       if (!reg)
2438         as_bad (_("unknown register alias '%s'"), name);
2439       else if (reg->builtin)
2440         as_warn (_("ignoring attempt to use .unreq on fixed register name: '%s'"),
2441                  name);
2442       else
2443         {
2444           char * p;
2445           char * nbuf;
2446
2447           hash_delete (arm_reg_hsh, name, FALSE);
2448           free ((char *) reg->name);
2449           if (reg->neon)
2450             free (reg->neon);
2451           free (reg);
2452
2453           /* Also locate the all upper case and all lower case versions.
2454              Do not complain if we cannot find one or the other as it
2455              was probably deleted above.  */
2456
2457           nbuf = strdup (name);
2458           for (p = nbuf; *p; p++)
2459             *p = TOUPPER (*p);
2460           reg = (struct reg_entry *) hash_find (arm_reg_hsh, nbuf);
2461           if (reg)
2462             {
2463               hash_delete (arm_reg_hsh, nbuf, FALSE);
2464               free ((char *) reg->name);
2465               if (reg->neon)
2466                 free (reg->neon);
2467               free (reg);
2468             }
2469
2470           for (p = nbuf; *p; p++)
2471             *p = TOLOWER (*p);
2472           reg = (struct reg_entry *) hash_find (arm_reg_hsh, nbuf);
2473           if (reg)
2474             {
2475               hash_delete (arm_reg_hsh, nbuf, FALSE);
2476               free ((char *) reg->name);
2477               if (reg->neon)
2478                 free (reg->neon);
2479               free (reg);
2480             }
2481
2482           free (nbuf);
2483         }
2484     }
2485
2486   *input_line_pointer = saved_char;
2487   demand_empty_rest_of_line ();
2488 }
2489
2490 /* Directives: Instruction set selection.  */
2491
2492 #ifdef OBJ_ELF
2493 /* This code is to handle mapping symbols as defined in the ARM ELF spec.
2494    (See "Mapping symbols", section 4.5.5, ARM AAELF version 1.0).
2495    Note that previously, $a and $t has type STT_FUNC (BSF_OBJECT flag),
2496    and $d has type STT_OBJECT (BSF_OBJECT flag). Now all three are untyped.  */
2497
2498 /* Create a new mapping symbol for the transition to STATE.  */
2499
2500 static void
2501 make_mapping_symbol (enum mstate state, valueT value, fragS *frag)
2502 {
2503   symbolS * symbolP;
2504   const char * symname;
2505   int type;
2506
2507   switch (state)
2508     {
2509     case MAP_DATA:
2510       symname = "$d";
2511       type = BSF_NO_FLAGS;
2512       break;
2513     case MAP_ARM:
2514       symname = "$a";
2515       type = BSF_NO_FLAGS;
2516       break;
2517     case MAP_THUMB:
2518       symname = "$t";
2519       type = BSF_NO_FLAGS;
2520       break;
2521     default:
2522       abort ();
2523     }
2524
2525   symbolP = symbol_new (symname, now_seg, value, frag);
2526   symbol_get_bfdsym (symbolP)->flags |= type | BSF_LOCAL;
2527
2528   switch (state)
2529     {
2530     case MAP_ARM:
2531       THUMB_SET_FUNC (symbolP, 0);
2532       ARM_SET_THUMB (symbolP, 0);
2533       ARM_SET_INTERWORK (symbolP, support_interwork);
2534       break;
2535
2536     case MAP_THUMB:
2537       THUMB_SET_FUNC (symbolP, 1);
2538       ARM_SET_THUMB (symbolP, 1);
2539       ARM_SET_INTERWORK (symbolP, support_interwork);
2540       break;
2541
2542     case MAP_DATA:
2543     default:
2544       break;
2545     }
2546
2547   /* Save the mapping symbols for future reference.  Also check that
2548      we do not place two mapping symbols at the same offset within a
2549      frag.  We'll handle overlap between frags in
2550      check_mapping_symbols.
2551
2552      If .fill or other data filling directive generates zero sized data,
2553      the mapping symbol for the following code will have the same value
2554      as the one generated for the data filling directive.  In this case,
2555      we replace the old symbol with the new one at the same address.  */
2556   if (value == 0)
2557     {
2558       if (frag->tc_frag_data.first_map != NULL)
2559         {
2560           know (S_GET_VALUE (frag->tc_frag_data.first_map) == 0);
2561           symbol_remove (frag->tc_frag_data.first_map, &symbol_rootP, &symbol_lastP);
2562         }
2563       frag->tc_frag_data.first_map = symbolP;
2564     }
2565   if (frag->tc_frag_data.last_map != NULL)
2566     {
2567       know (S_GET_VALUE (frag->tc_frag_data.last_map) <= S_GET_VALUE (symbolP));
2568       if (S_GET_VALUE (frag->tc_frag_data.last_map) == S_GET_VALUE (symbolP))
2569         symbol_remove (frag->tc_frag_data.last_map, &symbol_rootP, &symbol_lastP);
2570     }
2571   frag->tc_frag_data.last_map = symbolP;
2572 }
2573
2574 /* We must sometimes convert a region marked as code to data during
2575    code alignment, if an odd number of bytes have to be padded.  The
2576    code mapping symbol is pushed to an aligned address.  */
2577
2578 static void
2579 insert_data_mapping_symbol (enum mstate state,
2580                             valueT value, fragS *frag, offsetT bytes)
2581 {
2582   /* If there was already a mapping symbol, remove it.  */
2583   if (frag->tc_frag_data.last_map != NULL
2584       && S_GET_VALUE (frag->tc_frag_data.last_map) == frag->fr_address + value)
2585     {
2586       symbolS *symp = frag->tc_frag_data.last_map;
2587
2588       if (value == 0)
2589         {
2590           know (frag->tc_frag_data.first_map == symp);
2591           frag->tc_frag_data.first_map = NULL;
2592         }
2593       frag->tc_frag_data.last_map = NULL;
2594       symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2595     }
2596
2597   make_mapping_symbol (MAP_DATA, value, frag);
2598   make_mapping_symbol (state, value + bytes, frag);
2599 }
2600
2601 static void mapping_state_2 (enum mstate state, int max_chars);
2602
2603 /* Set the mapping state to STATE.  Only call this when about to
2604    emit some STATE bytes to the file.  */
2605
2606 void
2607 mapping_state (enum mstate state)
2608 {
2609   enum mstate mapstate = seg_info (now_seg)->tc_segment_info_data.mapstate;
2610
2611 #define TRANSITION(from, to) (mapstate == (from) && state == (to))
2612
2613   if (mapstate == state)
2614     /* The mapping symbol has already been emitted.
2615        There is nothing else to do.  */
2616     return;
2617
2618   if (state == MAP_ARM || state == MAP_THUMB)
2619     /*  PR gas/12931
2620         All ARM instructions require 4-byte alignment.
2621         (Almost) all Thumb instructions require 2-byte alignment.
2622
2623         When emitting instructions into any section, mark the section
2624         appropriately.
2625
2626         Some Thumb instructions are alignment-sensitive modulo 4 bytes,
2627         but themselves require 2-byte alignment; this applies to some
2628         PC- relative forms.  However, these cases will invovle implicit
2629         literal pool generation or an explicit .align >=2, both of
2630         which will cause the section to me marked with sufficient
2631         alignment.  Thus, we don't handle those cases here.  */
2632     record_alignment (now_seg, state == MAP_ARM ? 2 : 1);
2633
2634   if (TRANSITION (MAP_UNDEFINED, MAP_DATA))
2635     /* This case will be evaluated later in the next else.  */
2636     return;
2637   else if (TRANSITION (MAP_UNDEFINED, MAP_ARM)
2638           || TRANSITION (MAP_UNDEFINED, MAP_THUMB))
2639     {
2640       /* Only add the symbol if the offset is > 0:
2641          if we're at the first frag, check it's size > 0;
2642          if we're not at the first frag, then for sure
2643             the offset is > 0.  */
2644       struct frag * const frag_first = seg_info (now_seg)->frchainP->frch_root;
2645       const int add_symbol = (frag_now != frag_first) || (frag_now_fix () > 0);
2646
2647       if (add_symbol)
2648         make_mapping_symbol (MAP_DATA, (valueT) 0, frag_first);
2649     }
2650
2651   mapping_state_2 (state, 0);
2652 #undef TRANSITION
2653 }
2654
2655 /* Same as mapping_state, but MAX_CHARS bytes have already been
2656    allocated.  Put the mapping symbol that far back.  */
2657
2658 static void
2659 mapping_state_2 (enum mstate state, int max_chars)
2660 {
2661   enum mstate mapstate = seg_info (now_seg)->tc_segment_info_data.mapstate;
2662
2663   if (!SEG_NORMAL (now_seg))
2664     return;
2665
2666   if (mapstate == state)
2667     /* The mapping symbol has already been emitted.
2668        There is nothing else to do.  */
2669     return;
2670
2671   seg_info (now_seg)->tc_segment_info_data.mapstate = state;
2672   make_mapping_symbol (state, (valueT) frag_now_fix () - max_chars, frag_now);
2673 }
2674 #else
2675 #define mapping_state(x) ((void)0)
2676 #define mapping_state_2(x, y) ((void)0)
2677 #endif
2678
2679 /* Find the real, Thumb encoded start of a Thumb function.  */
2680
2681 #ifdef OBJ_COFF
2682 static symbolS *
2683 find_real_start (symbolS * symbolP)
2684 {
2685   char *       real_start;
2686   const char * name = S_GET_NAME (symbolP);
2687   symbolS *    new_target;
2688
2689   /* This definition must agree with the one in gcc/config/arm/thumb.c.  */
2690 #define STUB_NAME ".real_start_of"
2691
2692   if (name == NULL)
2693     abort ();
2694
2695   /* The compiler may generate BL instructions to local labels because
2696      it needs to perform a branch to a far away location. These labels
2697      do not have a corresponding ".real_start_of" label.  We check
2698      both for S_IS_LOCAL and for a leading dot, to give a way to bypass
2699      the ".real_start_of" convention for nonlocal branches.  */
2700   if (S_IS_LOCAL (symbolP) || name[0] == '.')
2701     return symbolP;
2702
2703   real_start = ACONCAT ((STUB_NAME, name, NULL));
2704   new_target = symbol_find (real_start);
2705
2706   if (new_target == NULL)
2707     {
2708       as_warn (_("Failed to find real start of function: %s\n"), name);
2709       new_target = symbolP;
2710     }
2711
2712   return new_target;
2713 }
2714 #endif
2715
2716 static void
2717 opcode_select (int width)
2718 {
2719   switch (width)
2720     {
2721     case 16:
2722       if (! thumb_mode)
2723         {
2724           if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
2725             as_bad (_("selected processor does not support THUMB opcodes"));
2726
2727           thumb_mode = 1;
2728           /* No need to force the alignment, since we will have been
2729              coming from ARM mode, which is word-aligned.  */
2730           record_alignment (now_seg, 1);
2731         }
2732       break;
2733
2734     case 32:
2735       if (thumb_mode)
2736         {
2737           if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
2738             as_bad (_("selected processor does not support ARM opcodes"));
2739
2740           thumb_mode = 0;
2741
2742           if (!need_pass_2)
2743             frag_align (2, 0, 0);
2744
2745           record_alignment (now_seg, 1);
2746         }
2747       break;
2748
2749     default:
2750       as_bad (_("invalid instruction size selected (%d)"), width);
2751     }
2752 }
2753
2754 static void
2755 s_arm (int ignore ATTRIBUTE_UNUSED)
2756 {
2757   opcode_select (32);
2758   demand_empty_rest_of_line ();
2759 }
2760
2761 static void
2762 s_thumb (int ignore ATTRIBUTE_UNUSED)
2763 {
2764   opcode_select (16);
2765   demand_empty_rest_of_line ();
2766 }
2767
2768 static void
2769 s_code (int unused ATTRIBUTE_UNUSED)
2770 {
2771   int temp;
2772
2773   temp = get_absolute_expression ();
2774   switch (temp)
2775     {
2776     case 16:
2777     case 32:
2778       opcode_select (temp);
2779       break;
2780
2781     default:
2782       as_bad (_("invalid operand to .code directive (%d) (expecting 16 or 32)"), temp);
2783     }
2784 }
2785
2786 static void
2787 s_force_thumb (int ignore ATTRIBUTE_UNUSED)
2788 {
2789   /* If we are not already in thumb mode go into it, EVEN if
2790      the target processor does not support thumb instructions.
2791      This is used by gcc/config/arm/lib1funcs.asm for example
2792      to compile interworking support functions even if the
2793      target processor should not support interworking.  */
2794   if (! thumb_mode)
2795     {
2796       thumb_mode = 2;
2797       record_alignment (now_seg, 1);
2798     }
2799
2800   demand_empty_rest_of_line ();
2801 }
2802
2803 static void
2804 s_thumb_func (int ignore ATTRIBUTE_UNUSED)
2805 {
2806   s_thumb (0);
2807
2808   /* The following label is the name/address of the start of a Thumb function.
2809      We need to know this for the interworking support.  */
2810   label_is_thumb_function_name = TRUE;
2811 }
2812
2813 /* Perform a .set directive, but also mark the alias as
2814    being a thumb function.  */
2815
2816 static void
2817 s_thumb_set (int equiv)
2818 {
2819   /* XXX the following is a duplicate of the code for s_set() in read.c
2820      We cannot just call that code as we need to get at the symbol that
2821      is created.  */
2822   char *    name;
2823   char      delim;
2824   char *    end_name;
2825   symbolS * symbolP;
2826
2827   /* Especial apologies for the random logic:
2828      This just grew, and could be parsed much more simply!
2829      Dean - in haste.  */
2830   name      = input_line_pointer;
2831   delim     = get_symbol_end ();
2832   end_name  = input_line_pointer;
2833   *end_name = delim;
2834
2835   if (*input_line_pointer != ',')
2836     {
2837       *end_name = 0;
2838       as_bad (_("expected comma after name \"%s\""), name);
2839       *end_name = delim;
2840       ignore_rest_of_line ();
2841       return;
2842     }
2843
2844   input_line_pointer++;
2845   *end_name = 0;
2846
2847   if (name[0] == '.' && name[1] == '\0')
2848     {
2849       /* XXX - this should not happen to .thumb_set.  */
2850       abort ();
2851     }
2852
2853   if ((symbolP = symbol_find (name)) == NULL
2854       && (symbolP = md_undefined_symbol (name)) == NULL)
2855     {
2856 #ifndef NO_LISTING
2857       /* When doing symbol listings, play games with dummy fragments living
2858          outside the normal fragment chain to record the file and line info
2859          for this symbol.  */
2860       if (listing & LISTING_SYMBOLS)
2861         {
2862           extern struct list_info_struct * listing_tail;
2863           fragS * dummy_frag = (fragS * ) xmalloc (sizeof (fragS));
2864
2865           memset (dummy_frag, 0, sizeof (fragS));
2866           dummy_frag->fr_type = rs_fill;
2867           dummy_frag->line = listing_tail;
2868           symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
2869           dummy_frag->fr_symbol = symbolP;
2870         }
2871       else
2872 #endif
2873         symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
2874
2875 #ifdef OBJ_COFF
2876       /* "set" symbols are local unless otherwise specified.  */
2877       SF_SET_LOCAL (symbolP);
2878 #endif /* OBJ_COFF  */
2879     }                           /* Make a new symbol.  */
2880
2881   symbol_table_insert (symbolP);
2882
2883   * end_name = delim;
2884
2885   if (equiv
2886       && S_IS_DEFINED (symbolP)
2887       && S_GET_SEGMENT (symbolP) != reg_section)
2888     as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
2889
2890   pseudo_set (symbolP);
2891
2892   demand_empty_rest_of_line ();
2893
2894   /* XXX Now we come to the Thumb specific bit of code.  */
2895
2896   THUMB_SET_FUNC (symbolP, 1);
2897   ARM_SET_THUMB (symbolP, 1);
2898 #if defined OBJ_ELF || defined OBJ_COFF
2899   ARM_SET_INTERWORK (symbolP, support_interwork);
2900 #endif
2901 }
2902
2903 /* Directives: Mode selection.  */
2904
2905 /* .syntax [unified|divided] - choose the new unified syntax
2906    (same for Arm and Thumb encoding, modulo slight differences in what
2907    can be represented) or the old divergent syntax for each mode.  */
2908 static void
2909 s_syntax (int unused ATTRIBUTE_UNUSED)
2910 {
2911   char *name, delim;
2912
2913   name = input_line_pointer;
2914   delim = get_symbol_end ();
2915
2916   if (!strcasecmp (name, "unified"))
2917     unified_syntax = TRUE;
2918   else if (!strcasecmp (name, "divided"))
2919     unified_syntax = FALSE;
2920   else
2921     {
2922       as_bad (_("unrecognized syntax mode \"%s\""), name);
2923       return;
2924     }
2925   *input_line_pointer = delim;
2926   demand_empty_rest_of_line ();
2927 }
2928
2929 /* Directives: sectioning and alignment.  */
2930
2931 /* Same as s_align_ptwo but align 0 => align 2.  */
2932
2933 static void
2934 s_align (int unused ATTRIBUTE_UNUSED)
2935 {
2936   int temp;
2937   bfd_boolean fill_p;
2938   long temp_fill;
2939   long max_alignment = 15;
2940
2941   temp = get_absolute_expression ();
2942   if (temp > max_alignment)
2943     as_bad (_("alignment too large: %d assumed"), temp = max_alignment);
2944   else if (temp < 0)
2945     {
2946       as_bad (_("alignment negative. 0 assumed."));
2947       temp = 0;
2948     }
2949
2950   if (*input_line_pointer == ',')
2951     {
2952       input_line_pointer++;
2953       temp_fill = get_absolute_expression ();
2954       fill_p = TRUE;
2955     }
2956   else
2957     {
2958       fill_p = FALSE;
2959       temp_fill = 0;
2960     }
2961
2962   if (!temp)
2963     temp = 2;
2964
2965   /* Only make a frag if we HAVE to.  */
2966   if (temp && !need_pass_2)
2967     {
2968       if (!fill_p && subseg_text_p (now_seg))
2969         frag_align_code (temp, 0);
2970       else
2971         frag_align (temp, (int) temp_fill, 0);
2972     }
2973   demand_empty_rest_of_line ();
2974
2975   record_alignment (now_seg, temp);
2976 }
2977
2978 static void
2979 s_bss (int ignore ATTRIBUTE_UNUSED)
2980 {
2981   /* We don't support putting frags in the BSS segment, we fake it by
2982      marking in_bss, then looking at s_skip for clues.  */
2983   subseg_set (bss_section, 0);
2984   demand_empty_rest_of_line ();
2985
2986 #ifdef md_elf_section_change_hook
2987   md_elf_section_change_hook ();
2988 #endif
2989 }
2990
2991 static void
2992 s_even (int ignore ATTRIBUTE_UNUSED)
2993 {
2994   /* Never make frag if expect extra pass.  */
2995   if (!need_pass_2)
2996     frag_align (1, 0, 0);
2997
2998   record_alignment (now_seg, 1);
2999
3000   demand_empty_rest_of_line ();
3001 }
3002
3003 /* Directives: Literal pools.  */
3004
3005 static literal_pool *
3006 find_literal_pool (void)
3007 {
3008   literal_pool * pool;
3009
3010   for (pool = list_of_pools; pool != NULL; pool = pool->next)
3011     {
3012       if (pool->section == now_seg
3013           && pool->sub_section == now_subseg)
3014         break;
3015     }
3016
3017   return pool;
3018 }
3019
3020 static literal_pool *
3021 find_or_make_literal_pool (void)
3022 {
3023   /* Next literal pool ID number.  */
3024   static unsigned int latest_pool_num = 1;
3025   literal_pool *      pool;
3026
3027   pool = find_literal_pool ();
3028
3029   if (pool == NULL)
3030     {
3031       /* Create a new pool.  */
3032       pool = (literal_pool *) xmalloc (sizeof (* pool));
3033       if (! pool)
3034         return NULL;
3035
3036       pool->next_free_entry = 0;
3037       pool->section         = now_seg;
3038       pool->sub_section     = now_subseg;
3039       pool->next            = list_of_pools;
3040       pool->symbol          = NULL;
3041
3042       /* Add it to the list.  */
3043       list_of_pools = pool;
3044     }
3045
3046   /* New pools, and emptied pools, will have a NULL symbol.  */
3047   if (pool->symbol == NULL)
3048     {
3049       pool->symbol = symbol_create (FAKE_LABEL_NAME, undefined_section,
3050                                     (valueT) 0, &zero_address_frag);
3051       pool->id = latest_pool_num ++;
3052     }
3053
3054   /* Done.  */
3055   return pool;
3056 }
3057
3058 /* Add the literal in the global 'inst'
3059    structure to the relevant literal pool.  */
3060
3061 static int
3062 add_to_lit_pool (void)
3063 {
3064   literal_pool * pool;
3065   unsigned int entry;
3066
3067   pool = find_or_make_literal_pool ();
3068
3069   /* Check if this literal value is already in the pool.  */
3070   for (entry = 0; entry < pool->next_free_entry; entry ++)
3071     {
3072       if ((pool->literals[entry].X_op == inst.reloc.exp.X_op)
3073           && (inst.reloc.exp.X_op == O_constant)
3074           && (pool->literals[entry].X_add_number
3075               == inst.reloc.exp.X_add_number)
3076           && (pool->literals[entry].X_unsigned
3077               == inst.reloc.exp.X_unsigned))
3078         break;
3079
3080       if ((pool->literals[entry].X_op == inst.reloc.exp.X_op)
3081           && (inst.reloc.exp.X_op == O_symbol)
3082           && (pool->literals[entry].X_add_number
3083               == inst.reloc.exp.X_add_number)
3084           && (pool->literals[entry].X_add_symbol
3085               == inst.reloc.exp.X_add_symbol)
3086           && (pool->literals[entry].X_op_symbol
3087               == inst.reloc.exp.X_op_symbol))
3088         break;
3089     }
3090
3091   /* Do we need to create a new entry?  */
3092   if (entry == pool->next_free_entry)
3093     {
3094       if (entry >= MAX_LITERAL_POOL_SIZE)
3095         {
3096           inst.error = _("literal pool overflow");
3097           return FAIL;
3098         }
3099
3100       pool->literals[entry] = inst.reloc.exp;
3101 #ifdef OBJ_ELF
3102       /* PR ld/12974: Record the location of the first source line to reference
3103          this entry in the literal pool.  If it turns out during linking that the
3104          symbol does not exist we will be able to give an accurate line number for
3105          the (first use of the) missing reference.  */
3106       if (debug_type == DEBUG_DWARF2)
3107         dwarf2_where (pool->locs + entry);
3108 #endif
3109       pool->next_free_entry += 1;
3110     }
3111
3112   inst.reloc.exp.X_op         = O_symbol;
3113   inst.reloc.exp.X_add_number = ((int) entry) * 4;
3114   inst.reloc.exp.X_add_symbol = pool->symbol;
3115
3116   return SUCCESS;
3117 }
3118
3119 /* Can't use symbol_new here, so have to create a symbol and then at
3120    a later date assign it a value. Thats what these functions do.  */
3121
3122 static void
3123 symbol_locate (symbolS *    symbolP,
3124                const char * name,       /* It is copied, the caller can modify.  */
3125                segT         segment,    /* Segment identifier (SEG_<something>).  */
3126                valueT       valu,       /* Symbol value.  */
3127                fragS *      frag)       /* Associated fragment.  */
3128 {
3129   unsigned int name_length;
3130   char * preserved_copy_of_name;
3131
3132   name_length = strlen (name) + 1;   /* +1 for \0.  */
3133   obstack_grow (&notes, name, name_length);
3134   preserved_copy_of_name = (char *) obstack_finish (&notes);
3135
3136 #ifdef tc_canonicalize_symbol_name
3137   preserved_copy_of_name =
3138     tc_canonicalize_symbol_name (preserved_copy_of_name);
3139 #endif
3140
3141   S_SET_NAME (symbolP, preserved_copy_of_name);
3142
3143   S_SET_SEGMENT (symbolP, segment);
3144   S_SET_VALUE (symbolP, valu);
3145   symbol_clear_list_pointers (symbolP);
3146
3147   symbol_set_frag (symbolP, frag);
3148
3149   /* Link to end of symbol chain.  */
3150   {
3151     extern int symbol_table_frozen;
3152
3153     if (symbol_table_frozen)
3154       abort ();
3155   }
3156
3157   symbol_append (symbolP, symbol_lastP, & symbol_rootP, & symbol_lastP);
3158
3159   obj_symbol_new_hook (symbolP);
3160
3161 #ifdef tc_symbol_new_hook
3162   tc_symbol_new_hook (symbolP);
3163 #endif
3164
3165 #ifdef DEBUG_SYMS
3166   verify_symbol_chain (symbol_rootP, symbol_lastP);
3167 #endif /* DEBUG_SYMS  */
3168 }
3169
3170
3171 static void
3172 s_ltorg (int ignored ATTRIBUTE_UNUSED)
3173 {
3174   unsigned int entry;
3175   literal_pool * pool;
3176   char sym_name[20];
3177
3178   pool = find_literal_pool ();
3179   if (pool == NULL
3180       || pool->symbol == NULL
3181       || pool->next_free_entry == 0)
3182     return;
3183
3184   mapping_state (MAP_DATA);
3185
3186   /* Align pool as you have word accesses.
3187      Only make a frag if we have to.  */
3188   if (!need_pass_2)
3189     frag_align (2, 0, 0);
3190
3191   record_alignment (now_seg, 2);
3192
3193   sprintf (sym_name, "$$lit_\002%x", pool->id);
3194
3195   symbol_locate (pool->symbol, sym_name, now_seg,
3196                  (valueT) frag_now_fix (), frag_now);
3197   symbol_table_insert (pool->symbol);
3198
3199   ARM_SET_THUMB (pool->symbol, thumb_mode);
3200
3201 #if defined OBJ_COFF || defined OBJ_ELF
3202   ARM_SET_INTERWORK (pool->symbol, support_interwork);
3203 #endif
3204
3205   for (entry = 0; entry < pool->next_free_entry; entry ++)
3206     {
3207 #ifdef OBJ_ELF
3208       if (debug_type == DEBUG_DWARF2)
3209         dwarf2_gen_line_info (frag_now_fix (), pool->locs + entry);
3210 #endif
3211       /* First output the expression in the instruction to the pool.  */
3212       emit_expr (&(pool->literals[entry]), 4); /* .word  */
3213     }
3214
3215   /* Mark the pool as empty.  */
3216   pool->next_free_entry = 0;
3217   pool->symbol = NULL;
3218 }
3219
3220 #ifdef OBJ_ELF
3221 /* Forward declarations for functions below, in the MD interface
3222    section.  */
3223 static void fix_new_arm (fragS *, int, short, expressionS *, int, int);
3224 static valueT create_unwind_entry (int);
3225 static void start_unwind_section (const segT, int);
3226 static void add_unwind_opcode (valueT, int);
3227 static void flush_pending_unwind (void);
3228
3229 /* Directives: Data.  */
3230
3231 static void
3232 s_arm_elf_cons (int nbytes)
3233 {
3234   expressionS exp;
3235
3236 #ifdef md_flush_pending_output
3237   md_flush_pending_output ();
3238 #endif
3239
3240   if (is_it_end_of_statement ())
3241     {
3242       demand_empty_rest_of_line ();
3243       return;
3244     }
3245
3246 #ifdef md_cons_align
3247   md_cons_align (nbytes);
3248 #endif
3249
3250   mapping_state (MAP_DATA);
3251   do
3252     {
3253       int reloc;
3254       char *base = input_line_pointer;
3255
3256       expression (& exp);
3257
3258       if (exp.X_op != O_symbol)
3259         emit_expr (&exp, (unsigned int) nbytes);
3260       else
3261         {
3262           char *before_reloc = input_line_pointer;
3263           reloc = parse_reloc (&input_line_pointer);
3264           if (reloc == -1)
3265             {
3266               as_bad (_("unrecognized relocation suffix"));
3267               ignore_rest_of_line ();
3268               return;
3269             }
3270           else if (reloc == BFD_RELOC_UNUSED)
3271             emit_expr (&exp, (unsigned int) nbytes);
3272           else
3273             {
3274               reloc_howto_type *howto = (reloc_howto_type *)
3275                   bfd_reloc_type_lookup (stdoutput,
3276                                          (bfd_reloc_code_real_type) reloc);
3277               int size = bfd_get_reloc_size (howto);
3278
3279               if (reloc == BFD_RELOC_ARM_PLT32)
3280                 {
3281                   as_bad (_("(plt) is only valid on branch targets"));
3282                   reloc = BFD_RELOC_UNUSED;
3283                   size = 0;
3284                 }
3285
3286               if (size > nbytes)
3287                 as_bad (_("%s relocations do not fit in %d bytes"),
3288                         howto->name, nbytes);
3289               else
3290                 {
3291                   /* We've parsed an expression stopping at O_symbol.
3292                      But there may be more expression left now that we
3293                      have parsed the relocation marker.  Parse it again.
3294                      XXX Surely there is a cleaner way to do this.  */
3295                   char *p = input_line_pointer;
3296                   int offset;
3297                   char *save_buf = (char *) alloca (input_line_pointer - base);
3298                   memcpy (save_buf, base, input_line_pointer - base);
3299                   memmove (base + (input_line_pointer - before_reloc),
3300                            base, before_reloc - base);
3301
3302                   input_line_pointer = base + (input_line_pointer-before_reloc);
3303                   expression (&exp);
3304                   memcpy (base, save_buf, p - base);
3305
3306                   offset = nbytes - size;
3307                   p = frag_more ((int) nbytes);
3308                   fix_new_exp (frag_now, p - frag_now->fr_literal + offset,
3309                                size, &exp, 0, (enum bfd_reloc_code_real) reloc);
3310                 }
3311             }
3312         }
3313     }
3314   while (*input_line_pointer++ == ',');
3315
3316   /* Put terminator back into stream.  */
3317   input_line_pointer --;
3318   demand_empty_rest_of_line ();
3319 }
3320
3321 /* Emit an expression containing a 32-bit thumb instruction.
3322    Implementation based on put_thumb32_insn.  */
3323
3324 static void
3325 emit_thumb32_expr (expressionS * exp)
3326 {
3327   expressionS exp_high = *exp;
3328
3329   exp_high.X_add_number = (unsigned long)exp_high.X_add_number >> 16;
3330   emit_expr (& exp_high, (unsigned int) THUMB_SIZE);
3331   exp->X_add_number &= 0xffff;
3332   emit_expr (exp, (unsigned int) THUMB_SIZE);
3333 }
3334
3335 /*  Guess the instruction size based on the opcode.  */
3336
3337 static int
3338 thumb_insn_size (int opcode)
3339 {
3340   if ((unsigned int) opcode < 0xe800u)
3341     return 2;
3342   else if ((unsigned int) opcode >= 0xe8000000u)
3343     return 4;
3344   else
3345     return 0;
3346 }
3347
3348 static bfd_boolean
3349 emit_insn (expressionS *exp, int nbytes)
3350 {
3351   int size = 0;
3352
3353   if (exp->X_op == O_constant)
3354     {
3355       size = nbytes;
3356
3357       if (size == 0)
3358         size = thumb_insn_size (exp->X_add_number);
3359
3360       if (size != 0)
3361         {
3362           if (size == 2 && (unsigned int)exp->X_add_number > 0xffffu)
3363             {
3364               as_bad (_(".inst.n operand too big. "\
3365                         "Use .inst.w instead"));
3366               size = 0;
3367             }
3368           else
3369             {
3370               if (now_it.state == AUTOMATIC_IT_BLOCK)
3371                 set_it_insn_type_nonvoid (OUTSIDE_IT_INSN, 0);
3372               else
3373                 set_it_insn_type_nonvoid (NEUTRAL_IT_INSN, 0);
3374
3375               if (thumb_mode && (size > THUMB_SIZE) && !target_big_endian)
3376                 emit_thumb32_expr (exp);
3377               else
3378                 emit_expr (exp, (unsigned int) size);
3379
3380               it_fsm_post_encode ();
3381             }
3382         }
3383       else
3384         as_bad (_("cannot determine Thumb instruction size. "   \
3385                   "Use .inst.n/.inst.w instead"));
3386     }
3387   else
3388     as_bad (_("constant expression required"));
3389
3390   return (size != 0);
3391 }
3392
3393 /* Like s_arm_elf_cons but do not use md_cons_align and
3394    set the mapping state to MAP_ARM/MAP_THUMB.  */
3395
3396 static void
3397 s_arm_elf_inst (int nbytes)
3398 {
3399   if (is_it_end_of_statement ())
3400     {
3401       demand_empty_rest_of_line ();
3402       return;
3403     }
3404
3405   /* Calling mapping_state () here will not change ARM/THUMB,
3406      but will ensure not to be in DATA state.  */
3407
3408   if (thumb_mode)
3409     mapping_state (MAP_THUMB);
3410   else
3411     {
3412       if (nbytes != 0)
3413         {
3414           as_bad (_("width suffixes are invalid in ARM mode"));
3415           ignore_rest_of_line ();
3416           return;
3417         }
3418
3419       nbytes = 4;
3420
3421       mapping_state (MAP_ARM);
3422     }
3423
3424   do
3425     {
3426       expressionS exp;
3427
3428       expression (& exp);
3429
3430       if (! emit_insn (& exp, nbytes))
3431         {
3432           ignore_rest_of_line ();
3433           return;
3434         }
3435     }
3436   while (*input_line_pointer++ == ',');
3437
3438   /* Put terminator back into stream.  */
3439   input_line_pointer --;
3440   demand_empty_rest_of_line ();
3441 }
3442
3443 /* Parse a .rel31 directive.  */
3444
3445 static void
3446 s_arm_rel31 (int ignored ATTRIBUTE_UNUSED)
3447 {
3448   expressionS exp;
3449   char *p;
3450   valueT highbit;
3451
3452   highbit = 0;
3453   if (*input_line_pointer == '1')
3454     highbit = 0x80000000;
3455   else if (*input_line_pointer != '0')
3456     as_bad (_("expected 0 or 1"));
3457
3458   input_line_pointer++;
3459   if (*input_line_pointer != ',')
3460     as_bad (_("missing comma"));
3461   input_line_pointer++;
3462
3463 #ifdef md_flush_pending_output
3464   md_flush_pending_output ();
3465 #endif
3466
3467 #ifdef md_cons_align
3468   md_cons_align (4);
3469 #endif
3470
3471   mapping_state (MAP_DATA);
3472
3473   expression (&exp);
3474
3475   p = frag_more (4);
3476   md_number_to_chars (p, highbit, 4);
3477   fix_new_arm (frag_now, p - frag_now->fr_literal, 4, &exp, 1,
3478                BFD_RELOC_ARM_PREL31);
3479
3480   demand_empty_rest_of_line ();
3481 }
3482
3483 /* Directives: AEABI stack-unwind tables.  */
3484
3485 /* Parse an unwind_fnstart directive.  Simply records the current location.  */
3486
3487 static void
3488 s_arm_unwind_fnstart (int ignored ATTRIBUTE_UNUSED)
3489 {
3490   demand_empty_rest_of_line ();
3491   if (unwind.proc_start)
3492     {
3493       as_bad (_("duplicate .fnstart directive"));
3494       return;
3495     }
3496
3497   /* Mark the start of the function.  */
3498   unwind.proc_start = expr_build_dot ();
3499
3500   /* Reset the rest of the unwind info.  */
3501   unwind.opcode_count = 0;
3502   unwind.table_entry = NULL;
3503   unwind.personality_routine = NULL;
3504   unwind.personality_index = -1;
3505   unwind.frame_size = 0;
3506   unwind.fp_offset = 0;
3507   unwind.fp_reg = REG_SP;
3508   unwind.fp_used = 0;
3509   unwind.sp_restored = 0;
3510 }
3511
3512
3513 /* Parse a handlerdata directive.  Creates the exception handling table entry
3514    for the function.  */
3515
3516 static void
3517 s_arm_unwind_handlerdata (int ignored ATTRIBUTE_UNUSED)
3518 {
3519   demand_empty_rest_of_line ();
3520   if (!unwind.proc_start)
3521     as_bad (MISSING_FNSTART);
3522
3523   if (unwind.table_entry)
3524     as_bad (_("duplicate .handlerdata directive"));
3525
3526   create_unwind_entry (1);
3527 }
3528
3529 /* Parse an unwind_fnend directive.  Generates the index table entry.  */
3530
3531 static void
3532 s_arm_unwind_fnend (int ignored ATTRIBUTE_UNUSED)
3533 {
3534   long where;
3535   char *ptr;
3536   valueT val;
3537   unsigned int marked_pr_dependency;
3538
3539   demand_empty_rest_of_line ();
3540
3541   if (!unwind.proc_start)
3542     {
3543       as_bad (_(".fnend directive without .fnstart"));
3544       return;
3545     }
3546
3547   /* Add eh table entry.  */
3548   if (unwind.table_entry == NULL)
3549     val = create_unwind_entry (0);
3550   else
3551     val = 0;
3552
3553   /* Add index table entry.  This is two words.  */
3554   start_unwind_section (unwind.saved_seg, 1);
3555   frag_align (2, 0, 0);
3556   record_alignment (now_seg, 2);
3557
3558   ptr = frag_more (8);
3559   memset (ptr, 0, 8);
3560   where = frag_now_fix () - 8;
3561
3562   /* Self relative offset of the function start.  */
3563   fix_new (frag_now, where, 4, unwind.proc_start, 0, 1,
3564            BFD_RELOC_ARM_PREL31);
3565
3566   /* Indicate dependency on EHABI-defined personality routines to the
3567      linker, if it hasn't been done already.  */
3568   marked_pr_dependency
3569     = seg_info (now_seg)->tc_segment_info_data.marked_pr_dependency;
3570   if (unwind.personality_index >= 0 && unwind.personality_index < 3
3571       && !(marked_pr_dependency & (1 << unwind.personality_index)))
3572     {
3573       static const char *const name[] =
3574         {
3575           "__aeabi_unwind_cpp_pr0",
3576           "__aeabi_unwind_cpp_pr1",
3577           "__aeabi_unwind_cpp_pr2"
3578         };
3579       symbolS *pr = symbol_find_or_make (name[unwind.personality_index]);
3580       fix_new (frag_now, where, 0, pr, 0, 1, BFD_RELOC_NONE);
3581       seg_info (now_seg)->tc_segment_info_data.marked_pr_dependency
3582         |= 1 << unwind.personality_index;
3583     }
3584
3585   if (val)
3586     /* Inline exception table entry.  */
3587     md_number_to_chars (ptr + 4, val, 4);
3588   else
3589     /* Self relative offset of the table entry.  */
3590     fix_new (frag_now, where + 4, 4, unwind.table_entry, 0, 1,
3591              BFD_RELOC_ARM_PREL31);
3592
3593   /* Restore the original section.  */
3594   subseg_set (unwind.saved_seg, unwind.saved_subseg);
3595
3596   unwind.proc_start = NULL;
3597 }
3598
3599
3600 /* Parse an unwind_cantunwind directive.  */
3601
3602 static void
3603 s_arm_unwind_cantunwind (int ignored ATTRIBUTE_UNUSED)
3604 {
3605   demand_empty_rest_of_line ();
3606   if (!unwind.proc_start)
3607     as_bad (MISSING_FNSTART);
3608
3609   if (unwind.personality_routine || unwind.personality_index != -1)
3610     as_bad (_("personality routine specified for cantunwind frame"));
3611
3612   unwind.personality_index = -2;
3613 }
3614
3615
3616 /* Parse a personalityindex directive.  */
3617
3618 static void
3619 s_arm_unwind_personalityindex (int ignored ATTRIBUTE_UNUSED)
3620 {
3621   expressionS exp;
3622
3623   if (!unwind.proc_start)
3624     as_bad (MISSING_FNSTART);
3625
3626   if (unwind.personality_routine || unwind.personality_index != -1)
3627     as_bad (_("duplicate .personalityindex directive"));
3628
3629   expression (&exp);
3630
3631   if (exp.X_op != O_constant
3632       || exp.X_add_number < 0 || exp.X_add_number > 15)
3633     {
3634       as_bad (_("bad personality routine number"));
3635       ignore_rest_of_line ();
3636       return;
3637     }
3638
3639   unwind.personality_index = exp.X_add_number;
3640
3641   demand_empty_rest_of_line ();
3642 }
3643
3644
3645 /* Parse a personality directive.  */
3646
3647 static void
3648 s_arm_unwind_personality (int ignored ATTRIBUTE_UNUSED)
3649 {
3650   char *name, *p, c;
3651
3652   if (!unwind.proc_start)
3653     as_bad (MISSING_FNSTART);
3654
3655   if (unwind.personality_routine || unwind.personality_index != -1)
3656     as_bad (_("duplicate .personality directive"));
3657
3658   name = input_line_pointer;
3659   c = get_symbol_end ();
3660   p = input_line_pointer;
3661   unwind.personality_routine = symbol_find_or_make (name);
3662   *p = c;
3663   demand_empty_rest_of_line ();
3664 }
3665
3666
3667 /* Parse a directive saving core registers.  */
3668
3669 static void
3670 s_arm_unwind_save_core (void)
3671 {
3672   valueT op;
3673   long range;
3674   int n;
3675
3676   range = parse_reg_list (&input_line_pointer);
3677   if (range == FAIL)
3678     {
3679       as_bad (_("expected register list"));
3680       ignore_rest_of_line ();
3681       return;
3682     }
3683
3684   demand_empty_rest_of_line ();
3685
3686   /* Turn .unwind_movsp ip followed by .unwind_save {..., ip, ...}
3687      into .unwind_save {..., sp...}.  We aren't bothered about the value of
3688      ip because it is clobbered by calls.  */
3689   if (unwind.sp_restored && unwind.fp_reg == 12
3690       && (range & 0x3000) == 0x1000)
3691     {
3692       unwind.opcode_count--;
3693       unwind.sp_restored = 0;
3694       range = (range | 0x2000) & ~0x1000;
3695       unwind.pending_offset = 0;
3696     }
3697
3698   /* Pop r4-r15.  */
3699   if (range & 0xfff0)
3700     {
3701       /* See if we can use the short opcodes.  These pop a block of up to 8
3702          registers starting with r4, plus maybe r14.  */
3703       for (n = 0; n < 8; n++)
3704         {
3705           /* Break at the first non-saved register.      */
3706           if ((range & (1 << (n + 4))) == 0)
3707             break;
3708         }
3709       /* See if there are any other bits set.  */
3710       if (n == 0 || (range & (0xfff0 << n) & 0xbff0) != 0)
3711         {
3712           /* Use the long form.  */
3713           op = 0x8000 | ((range >> 4) & 0xfff);
3714           add_unwind_opcode (op, 2);
3715         }
3716       else
3717         {
3718           /* Use the short form.  */
3719           if (range & 0x4000)
3720             op = 0xa8; /* Pop r14.      */
3721           else
3722             op = 0xa0; /* Do not pop r14.  */
3723           op |= (n - 1);
3724           add_unwind_opcode (op, 1);
3725         }
3726     }
3727
3728   /* Pop r0-r3.  */
3729   if (range & 0xf)
3730     {
3731       op = 0xb100 | (range & 0xf);
3732       add_unwind_opcode (op, 2);
3733     }
3734
3735   /* Record the number of bytes pushed.  */
3736   for (n = 0; n < 16; n++)
3737     {
3738       if (range & (1 << n))
3739         unwind.frame_size += 4;
3740     }
3741 }
3742
3743
3744 /* Parse a directive saving FPA registers.  */
3745
3746 static void
3747 s_arm_unwind_save_fpa (int reg)
3748 {
3749   expressionS exp;
3750   int num_regs;
3751   valueT op;
3752
3753   /* Get Number of registers to transfer.  */
3754   if (skip_past_comma (&input_line_pointer) != FAIL)
3755     expression (&exp);
3756   else
3757     exp.X_op = O_illegal;
3758
3759   if (exp.X_op != O_constant)
3760     {
3761       as_bad (_("expected , <constant>"));
3762       ignore_rest_of_line ();
3763       return;
3764     }
3765
3766   num_regs = exp.X_add_number;
3767
3768   if (num_regs < 1 || num_regs > 4)
3769     {
3770       as_bad (_("number of registers must be in the range [1:4]"));
3771       ignore_rest_of_line ();
3772       return;
3773     }
3774
3775   demand_empty_rest_of_line ();
3776
3777   if (reg == 4)
3778     {
3779       /* Short form.  */
3780       op = 0xb4 | (num_regs - 1);
3781       add_unwind_opcode (op, 1);
3782     }
3783   else
3784     {
3785       /* Long form.  */
3786       op = 0xc800 | (reg << 4) | (num_regs - 1);
3787       add_unwind_opcode (op, 2);
3788     }
3789   unwind.frame_size += num_regs * 12;
3790 }
3791
3792
3793 /* Parse a directive saving VFP registers for ARMv6 and above.  */
3794
3795 static void
3796 s_arm_unwind_save_vfp_armv6 (void)
3797 {
3798   int count;
3799   unsigned int start;
3800   valueT op;
3801   int num_vfpv3_regs = 0;
3802   int num_regs_below_16;
3803
3804   count = parse_vfp_reg_list (&input_line_pointer, &start, REGLIST_VFP_D);
3805   if (count == FAIL)
3806     {
3807       as_bad (_("expected register list"));
3808       ignore_rest_of_line ();
3809       return;
3810     }
3811
3812   demand_empty_rest_of_line ();
3813
3814   /* We always generate FSTMD/FLDMD-style unwinding opcodes (rather
3815      than FSTMX/FLDMX-style ones).  */
3816
3817   /* Generate opcode for (VFPv3) registers numbered in the range 16 .. 31.  */
3818   if (start >= 16)
3819     num_vfpv3_regs = count;
3820   else if (start + count > 16)
3821     num_vfpv3_regs = start + count - 16;
3822
3823   if (num_vfpv3_regs > 0)
3824     {
3825       int start_offset = start > 16 ? start - 16 : 0;
3826       op = 0xc800 | (start_offset << 4) | (num_vfpv3_regs - 1);
3827       add_unwind_opcode (op, 2);
3828     }
3829
3830   /* Generate opcode for registers numbered in the range 0 .. 15.  */
3831   num_regs_below_16 = num_vfpv3_regs > 0 ? 16 - (int) start : count;
3832   gas_assert (num_regs_below_16 + num_vfpv3_regs == count);
3833   if (num_regs_below_16 > 0)
3834     {
3835       op = 0xc900 | (start << 4) | (num_regs_below_16 - 1);
3836       add_unwind_opcode (op, 2);
3837     }
3838
3839   unwind.frame_size += count * 8;
3840 }
3841
3842
3843 /* Parse a directive saving VFP registers for pre-ARMv6.  */
3844
3845 static void
3846 s_arm_unwind_save_vfp (void)
3847 {
3848   int count;
3849   unsigned int reg;
3850   valueT op;
3851
3852   count = parse_vfp_reg_list (&input_line_pointer, &reg, REGLIST_VFP_D);
3853   if (count == FAIL)
3854     {
3855       as_bad (_("expected register list"));
3856       ignore_rest_of_line ();
3857       return;
3858     }
3859
3860   demand_empty_rest_of_line ();
3861
3862   if (reg == 8)
3863     {
3864       /* Short form.  */
3865       op = 0xb8 | (count - 1);
3866       add_unwind_opcode (op, 1);
3867     }
3868   else
3869     {
3870       /* Long form.  */
3871       op = 0xb300 | (reg << 4) | (count - 1);
3872       add_unwind_opcode (op, 2);
3873     }
3874   unwind.frame_size += count * 8 + 4;
3875 }
3876
3877
3878 /* Parse a directive saving iWMMXt data registers.  */
3879
3880 static void
3881 s_arm_unwind_save_mmxwr (void)
3882 {
3883   int reg;
3884   int hi_reg;
3885   int i;
3886   unsigned mask = 0;
3887   valueT op;
3888
3889   if (*input_line_pointer == '{')
3890     input_line_pointer++;
3891
3892   do
3893     {
3894       reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWR);
3895
3896       if (reg == FAIL)
3897         {
3898           as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWR]));
3899           goto error;
3900         }
3901
3902       if (mask >> reg)
3903         as_tsktsk (_("register list not in ascending order"));
3904       mask |= 1 << reg;
3905
3906       if (*input_line_pointer == '-')
3907         {
3908           input_line_pointer++;
3909           hi_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWR);
3910           if (hi_reg == FAIL)
3911             {
3912               as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWR]));
3913               goto error;
3914             }
3915           else if (reg >= hi_reg)
3916             {
3917               as_bad (_("bad register range"));
3918               goto error;
3919             }
3920           for (; reg < hi_reg; reg++)
3921             mask |= 1 << reg;
3922         }
3923     }
3924   while (skip_past_comma (&input_line_pointer) != FAIL);
3925
3926   if (*input_line_pointer == '}')
3927     input_line_pointer++;
3928
3929   demand_empty_rest_of_line ();
3930
3931   /* Generate any deferred opcodes because we're going to be looking at
3932      the list.  */
3933   flush_pending_unwind ();
3934
3935   for (i = 0; i < 16; i++)
3936     {
3937       if (mask & (1 << i))
3938         unwind.frame_size += 8;
3939     }
3940
3941   /* Attempt to combine with a previous opcode.  We do this because gcc
3942      likes to output separate unwind directives for a single block of
3943      registers.  */
3944   if (unwind.opcode_count > 0)
3945     {
3946       i = unwind.opcodes[unwind.opcode_count - 1];
3947       if ((i & 0xf8) == 0xc0)
3948         {
3949           i &= 7;
3950           /* Only merge if the blocks are contiguous.  */
3951           if (i < 6)
3952             {
3953               if ((mask & 0xfe00) == (1 << 9))
3954                 {
3955                   mask |= ((1 << (i + 11)) - 1) & 0xfc00;
3956                   unwind.opcode_count--;
3957                 }
3958             }
3959           else if (i == 6 && unwind.opcode_count >= 2)
3960             {
3961               i = unwind.opcodes[unwind.opcode_count - 2];
3962               reg = i >> 4;
3963               i &= 0xf;
3964
3965               op = 0xffff << (reg - 1);
3966               if (reg > 0
3967                   && ((mask & op) == (1u << (reg - 1))))
3968                 {
3969                   op = (1 << (reg + i + 1)) - 1;
3970                   op &= ~((1 << reg) - 1);
3971                   mask |= op;
3972                   unwind.opcode_count -= 2;
3973                 }
3974             }
3975         }
3976     }
3977
3978   hi_reg = 15;
3979   /* We want to generate opcodes in the order the registers have been
3980      saved, ie. descending order.  */
3981   for (reg = 15; reg >= -1; reg--)
3982     {
3983       /* Save registers in blocks.  */
3984       if (reg < 0
3985           || !(mask & (1 << reg)))
3986         {
3987           /* We found an unsaved reg.  Generate opcodes to save the
3988              preceding block.   */
3989           if (reg != hi_reg)
3990             {
3991               if (reg == 9)
3992                 {
3993                   /* Short form.  */
3994                   op = 0xc0 | (hi_reg - 10);
3995                   add_unwind_opcode (op, 1);
3996                 }
3997               else
3998                 {
3999                   /* Long form.  */
4000                   op = 0xc600 | ((reg + 1) << 4) | ((hi_reg - reg) - 1);
4001                   add_unwind_opcode (op, 2);
4002                 }
4003             }
4004           hi_reg = reg - 1;
4005         }
4006     }
4007
4008   return;
4009 error:
4010   ignore_rest_of_line ();
4011 }
4012
4013 static void
4014 s_arm_unwind_save_mmxwcg (void)
4015 {
4016   int reg;
4017   int hi_reg;
4018   unsigned mask = 0;
4019   valueT op;
4020
4021   if (*input_line_pointer == '{')
4022     input_line_pointer++;
4023
4024   do
4025     {
4026       reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWCG);
4027
4028       if (reg == FAIL)
4029         {
4030           as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWCG]));
4031           goto error;
4032         }
4033
4034       reg -= 8;
4035       if (mask >> reg)
4036         as_tsktsk (_("register list not in ascending order"));
4037       mask |= 1 << reg;
4038
4039       if (*input_line_pointer == '-')
4040         {
4041           input_line_pointer++;
4042           hi_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWCG);
4043           if (hi_reg == FAIL)
4044             {
4045               as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWCG]));
4046               goto error;
4047             }
4048           else if (reg >= hi_reg)
4049             {
4050               as_bad (_("bad register range"));
4051               goto error;
4052             }
4053           for (; reg < hi_reg; reg++)
4054             mask |= 1 << reg;
4055         }
4056     }
4057   while (skip_past_comma (&input_line_pointer) != FAIL);
4058
4059   if (*input_line_pointer == '}')
4060     input_line_pointer++;
4061
4062   demand_empty_rest_of_line ();
4063
4064   /* Generate any deferred opcodes because we're going to be looking at
4065      the list.  */
4066   flush_pending_unwind ();
4067
4068   for (reg = 0; reg < 16; reg++)
4069     {
4070       if (mask & (1 << reg))
4071         unwind.frame_size += 4;
4072     }
4073   op = 0xc700 | mask;
4074   add_unwind_opcode (op, 2);
4075   return;
4076 error:
4077   ignore_rest_of_line ();
4078 }
4079
4080
4081 /* Parse an unwind_save directive.
4082    If the argument is non-zero, this is a .vsave directive.  */
4083
4084 static void
4085 s_arm_unwind_save (int arch_v6)
4086 {
4087   char *peek;
4088   struct reg_entry *reg;
4089   bfd_boolean had_brace = FALSE;
4090
4091   if (!unwind.proc_start)
4092     as_bad (MISSING_FNSTART);
4093
4094   /* Figure out what sort of save we have.  */
4095   peek = input_line_pointer;
4096
4097   if (*peek == '{')
4098     {
4099       had_brace = TRUE;
4100       peek++;
4101     }
4102
4103   reg = arm_reg_parse_multi (&peek);
4104
4105   if (!reg)
4106     {
4107       as_bad (_("register expected"));
4108       ignore_rest_of_line ();
4109       return;
4110     }
4111
4112   switch (reg->type)
4113     {
4114     case REG_TYPE_FN:
4115       if (had_brace)
4116         {
4117           as_bad (_("FPA .unwind_save does not take a register list"));
4118           ignore_rest_of_line ();
4119           return;
4120         }
4121       input_line_pointer = peek;
4122       s_arm_unwind_save_fpa (reg->number);
4123       return;
4124
4125     case REG_TYPE_RN:     s_arm_unwind_save_core ();   return;
4126     case REG_TYPE_VFD:
4127       if (arch_v6)
4128         s_arm_unwind_save_vfp_armv6 ();
4129       else
4130         s_arm_unwind_save_vfp ();
4131       return;
4132     case REG_TYPE_MMXWR:  s_arm_unwind_save_mmxwr ();  return;
4133     case REG_TYPE_MMXWCG: s_arm_unwind_save_mmxwcg (); return;
4134
4135     default:
4136       as_bad (_(".unwind_save does not support this kind of register"));
4137       ignore_rest_of_line ();
4138     }
4139 }
4140
4141
4142 /* Parse an unwind_movsp directive.  */
4143
4144 static void
4145 s_arm_unwind_movsp (int ignored ATTRIBUTE_UNUSED)
4146 {
4147   int reg;
4148   valueT op;
4149   int offset;
4150
4151   if (!unwind.proc_start)
4152     as_bad (MISSING_FNSTART);
4153
4154   reg = arm_reg_parse (&input_line_pointer, REG_TYPE_RN);
4155   if (reg == FAIL)
4156     {
4157       as_bad ("%s", _(reg_expected_msgs[REG_TYPE_RN]));
4158       ignore_rest_of_line ();
4159       return;
4160     }
4161
4162   /* Optional constant.  */
4163   if (skip_past_comma (&input_line_pointer) != FAIL)
4164     {
4165       if (immediate_for_directive (&offset) == FAIL)
4166         return;
4167     }
4168   else
4169     offset = 0;
4170
4171   demand_empty_rest_of_line ();
4172
4173   if (reg == REG_SP || reg == REG_PC)
4174     {
4175       as_bad (_("SP and PC not permitted in .unwind_movsp directive"));
4176       return;
4177     }
4178
4179   if (unwind.fp_reg != REG_SP)
4180     as_bad (_("unexpected .unwind_movsp directive"));
4181
4182   /* Generate opcode to restore the value.  */
4183   op = 0x90 | reg;
4184   add_unwind_opcode (op, 1);
4185
4186   /* Record the information for later.  */
4187   unwind.fp_reg = reg;
4188   unwind.fp_offset = unwind.frame_size - offset;
4189   unwind.sp_restored = 1;
4190 }
4191
4192 /* Parse an unwind_pad directive.  */
4193
4194 static void
4195 s_arm_unwind_pad (int ignored ATTRIBUTE_UNUSED)
4196 {
4197   int offset;
4198
4199   if (!unwind.proc_start)
4200     as_bad (MISSING_FNSTART);
4201
4202   if (immediate_for_directive (&offset) == FAIL)
4203     return;
4204
4205   if (offset & 3)
4206     {
4207       as_bad (_("stack increment must be multiple of 4"));
4208       ignore_rest_of_line ();
4209       return;
4210     }
4211
4212   /* Don't generate any opcodes, just record the details for later.  */
4213   unwind.frame_size += offset;
4214   unwind.pending_offset += offset;
4215
4216   demand_empty_rest_of_line ();
4217 }
4218
4219 /* Parse an unwind_setfp directive.  */
4220
4221 static void
4222 s_arm_unwind_setfp (int ignored ATTRIBUTE_UNUSED)
4223 {
4224   int sp_reg;
4225   int fp_reg;
4226   int offset;
4227
4228   if (!unwind.proc_start)
4229     as_bad (MISSING_FNSTART);
4230
4231   fp_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_RN);
4232   if (skip_past_comma (&input_line_pointer) == FAIL)
4233     sp_reg = FAIL;
4234   else
4235     sp_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_RN);
4236
4237   if (fp_reg == FAIL || sp_reg == FAIL)
4238     {
4239       as_bad (_("expected <reg>, <reg>"));
4240       ignore_rest_of_line ();
4241       return;
4242     }
4243
4244   /* Optional constant.  */
4245   if (skip_past_comma (&input_line_pointer) != FAIL)
4246     {
4247       if (immediate_for_directive (&offset) == FAIL)
4248         return;
4249     }
4250   else
4251     offset = 0;
4252
4253   demand_empty_rest_of_line ();
4254
4255   if (sp_reg != REG_SP && sp_reg != unwind.fp_reg)
4256     {
4257       as_bad (_("register must be either sp or set by a previous"
4258                 "unwind_movsp directive"));
4259       return;
4260     }
4261
4262   /* Don't generate any opcodes, just record the information for later.  */
4263   unwind.fp_reg = fp_reg;
4264   unwind.fp_used = 1;
4265   if (sp_reg == REG_SP)
4266     unwind.fp_offset = unwind.frame_size - offset;
4267   else
4268     unwind.fp_offset -= offset;
4269 }
4270
4271 /* Parse an unwind_raw directive.  */
4272
4273 static void
4274 s_arm_unwind_raw (int ignored ATTRIBUTE_UNUSED)
4275 {
4276   expressionS exp;
4277   /* This is an arbitrary limit.         */
4278   unsigned char op[16];
4279   int count;
4280
4281   if (!unwind.proc_start)
4282     as_bad (MISSING_FNSTART);
4283
4284   expression (&exp);
4285   if (exp.X_op == O_constant
4286       && skip_past_comma (&input_line_pointer) != FAIL)
4287     {
4288       unwind.frame_size += exp.X_add_number;
4289       expression (&exp);
4290     }
4291   else
4292     exp.X_op = O_illegal;
4293
4294   if (exp.X_op != O_constant)
4295     {
4296       as_bad (_("expected <offset>, <opcode>"));
4297       ignore_rest_of_line ();
4298       return;
4299     }
4300
4301   count = 0;
4302
4303   /* Parse the opcode.  */
4304   for (;;)
4305     {
4306       if (count >= 16)
4307         {
4308           as_bad (_("unwind opcode too long"));
4309           ignore_rest_of_line ();
4310         }
4311       if (exp.X_op != O_constant || exp.X_add_number & ~0xff)
4312         {
4313           as_bad (_("invalid unwind opcode"));
4314           ignore_rest_of_line ();
4315           return;
4316         }
4317       op[count++] = exp.X_add_number;
4318
4319       /* Parse the next byte.  */
4320       if (skip_past_comma (&input_line_pointer) == FAIL)
4321         break;
4322
4323       expression (&exp);
4324     }
4325
4326   /* Add the opcode bytes in reverse order.  */
4327   while (count--)
4328     add_unwind_opcode (op[count], 1);
4329
4330   demand_empty_rest_of_line ();
4331 }
4332
4333
4334 /* Parse a .eabi_attribute directive.  */
4335
4336 static void
4337 s_arm_eabi_attribute (int ignored ATTRIBUTE_UNUSED)
4338 {
4339   int tag = s_vendor_attribute (OBJ_ATTR_PROC);
4340
4341   if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
4342     attributes_set_explicitly[tag] = 1;
4343 }
4344
4345 /* Emit a tls fix for the symbol.  */
4346
4347 static void
4348 s_arm_tls_descseq (int ignored ATTRIBUTE_UNUSED)
4349 {
4350   char *p;
4351   expressionS exp;
4352 #ifdef md_flush_pending_output
4353   md_flush_pending_output ();
4354 #endif
4355
4356 #ifdef md_cons_align
4357   md_cons_align (4);
4358 #endif
4359
4360   /* Since we're just labelling the code, there's no need to define a
4361      mapping symbol.  */
4362   expression (&exp);
4363   p = obstack_next_free (&frchain_now->frch_obstack);
4364   fix_new_arm (frag_now, p - frag_now->fr_literal, 4, &exp, 0,
4365                thumb_mode ? BFD_RELOC_ARM_THM_TLS_DESCSEQ
4366                : BFD_RELOC_ARM_TLS_DESCSEQ);
4367 }
4368 #endif /* OBJ_ELF */
4369
4370 static void s_arm_arch (int);
4371 static void s_arm_object_arch (int);
4372 static void s_arm_cpu (int);
4373 static void s_arm_fpu (int);
4374 static void s_arm_arch_extension (int);
4375
4376 #ifdef TE_PE
4377
4378 static void
4379 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED)
4380 {
4381   expressionS exp;
4382
4383   do
4384     {
4385       expression (&exp);
4386       if (exp.X_op == O_symbol)
4387         exp.X_op = O_secrel;
4388
4389       emit_expr (&exp, 4);
4390     }
4391   while (*input_line_pointer++ == ',');
4392
4393   input_line_pointer--;
4394   demand_empty_rest_of_line ();
4395 }
4396 #endif /* TE_PE */
4397
4398 /* This table describes all the machine specific pseudo-ops the assembler
4399    has to support.  The fields are:
4400      pseudo-op name without dot
4401      function to call to execute this pseudo-op
4402      Integer arg to pass to the function.  */
4403
4404 const pseudo_typeS md_pseudo_table[] =
4405 {
4406   /* Never called because '.req' does not start a line.  */
4407   { "req",         s_req,         0 },
4408   /* Following two are likewise never called.  */
4409   { "dn",          s_dn,          0 },
4410   { "qn",          s_qn,          0 },
4411   { "unreq",       s_unreq,       0 },
4412   { "bss",         s_bss,         0 },
4413   { "align",       s_align,       0 },
4414   { "arm",         s_arm,         0 },
4415   { "thumb",       s_thumb,       0 },
4416   { "code",        s_code,        0 },
4417   { "force_thumb", s_force_thumb, 0 },
4418   { "thumb_func",  s_thumb_func,  0 },
4419   { "thumb_set",   s_thumb_set,   0 },
4420   { "even",        s_even,        0 },
4421   { "ltorg",       s_ltorg,       0 },
4422   { "pool",        s_ltorg,       0 },
4423   { "syntax",      s_syntax,      0 },
4424   { "cpu",         s_arm_cpu,     0 },
4425   { "arch",        s_arm_arch,    0 },
4426   { "object_arch", s_arm_object_arch,   0 },
4427   { "fpu",         s_arm_fpu,     0 },
4428   { "arch_extension", s_arm_arch_extension, 0 },
4429 #ifdef OBJ_ELF
4430   { "word",             s_arm_elf_cons, 4 },
4431   { "long",             s_arm_elf_cons, 4 },
4432   { "inst.n",           s_arm_elf_inst, 2 },
4433   { "inst.w",           s_arm_elf_inst, 4 },
4434   { "inst",             s_arm_elf_inst, 0 },
4435   { "rel31",            s_arm_rel31,      0 },
4436   { "fnstart",          s_arm_unwind_fnstart,   0 },
4437   { "fnend",            s_arm_unwind_fnend,     0 },
4438   { "cantunwind",       s_arm_unwind_cantunwind, 0 },
4439   { "personality",      s_arm_unwind_personality, 0 },
4440   { "personalityindex", s_arm_unwind_personalityindex, 0 },
4441   { "handlerdata",      s_arm_unwind_handlerdata, 0 },
4442   { "save",             s_arm_unwind_save,      0 },
4443   { "vsave",            s_arm_unwind_save,      1 },
4444   { "movsp",            s_arm_unwind_movsp,     0 },
4445   { "pad",              s_arm_unwind_pad,       0 },
4446   { "setfp",            s_arm_unwind_setfp,     0 },
4447   { "unwind_raw",       s_arm_unwind_raw,       0 },
4448   { "eabi_attribute",   s_arm_eabi_attribute,   0 },
4449   { "tlsdescseq",       s_arm_tls_descseq,      0 },
4450 #else
4451   { "word",        cons, 4},
4452
4453   /* These are used for dwarf.  */
4454   {"2byte", cons, 2},
4455   {"4byte", cons, 4},
4456   {"8byte", cons, 8},
4457   /* These are used for dwarf2.  */
4458   { "file", (void (*) (int)) dwarf2_directive_file, 0 },
4459   { "loc",  dwarf2_directive_loc,  0 },
4460   { "loc_mark_labels", dwarf2_directive_loc_mark_labels, 0 },
4461 #endif
4462   { "extend",      float_cons, 'x' },
4463   { "ldouble",     float_cons, 'x' },
4464   { "packed",      float_cons, 'p' },
4465 #ifdef TE_PE
4466   {"secrel32", pe_directive_secrel, 0},
4467 #endif
4468   { 0, 0, 0 }
4469 };
4470 \f
4471 /* Parser functions used exclusively in instruction operands.  */
4472
4473 /* Generic immediate-value read function for use in insn parsing.
4474    STR points to the beginning of the immediate (the leading #);
4475    VAL receives the value; if the value is outside [MIN, MAX]
4476    issue an error.  PREFIX_OPT is true if the immediate prefix is
4477    optional.  */
4478
4479 static int
4480 parse_immediate (char **str, int *val, int min, int max,
4481                  bfd_boolean prefix_opt)
4482 {
4483   expressionS exp;
4484   my_get_expression (&exp, str, prefix_opt ? GE_OPT_PREFIX : GE_IMM_PREFIX);
4485   if (exp.X_op != O_constant)
4486     {
4487       inst.error = _("constant expression required");
4488       return FAIL;
4489     }
4490
4491   if (exp.X_add_number < min || exp.X_add_number > max)
4492     {
4493       inst.error = _("immediate value out of range");
4494       return FAIL;
4495     }
4496
4497   *val = exp.X_add_number;
4498   return SUCCESS;
4499 }
4500
4501 /* Less-generic immediate-value read function with the possibility of loading a
4502    big (64-bit) immediate, as required by Neon VMOV, VMVN and logic immediate
4503    instructions. Puts the result directly in inst.operands[i].  */
4504
4505 static int
4506 parse_big_immediate (char **str, int i)
4507 {
4508   expressionS exp;
4509   char *ptr = *str;
4510
4511   my_get_expression (&exp, &ptr, GE_OPT_PREFIX_BIG);
4512
4513   if (exp.X_op == O_constant)
4514     {
4515       inst.operands[i].imm = exp.X_add_number & 0xffffffff;
4516       /* If we're on a 64-bit host, then a 64-bit number can be returned using
4517          O_constant.  We have to be careful not to break compilation for
4518          32-bit X_add_number, though.  */
4519       if ((exp.X_add_number & ~(offsetT)(0xffffffffU)) != 0)
4520         {
4521           /* X >> 32 is illegal if sizeof (exp.X_add_number) == 4.  */
4522           inst.operands[i].reg = ((exp.X_add_number >> 16) >> 16) & 0xffffffff;
4523           inst.operands[i].regisimm = 1;
4524         }
4525     }
4526   else if (exp.X_op == O_big
4527            && LITTLENUM_NUMBER_OF_BITS * exp.X_add_number > 32)
4528     {
4529       unsigned parts = 32 / LITTLENUM_NUMBER_OF_BITS, j, idx = 0;
4530
4531       /* Bignums have their least significant bits in
4532          generic_bignum[0]. Make sure we put 32 bits in imm and
4533          32 bits in reg,  in a (hopefully) portable way.  */
4534       gas_assert (parts != 0);
4535
4536       /* Make sure that the number is not too big.
4537          PR 11972: Bignums can now be sign-extended to the
4538          size of a .octa so check that the out of range bits
4539          are all zero or all one.  */
4540       if (LITTLENUM_NUMBER_OF_BITS * exp.X_add_number > 64)
4541         {
4542           LITTLENUM_TYPE m = -1;
4543
4544           if (generic_bignum[parts * 2] != 0
4545               && generic_bignum[parts * 2] != m)
4546             return FAIL;
4547
4548           for (j = parts * 2 + 1; j < (unsigned) exp.X_add_number; j++)
4549             if (generic_bignum[j] != generic_bignum[j-1])
4550               return FAIL;
4551         }
4552
4553       inst.operands[i].imm = 0;
4554       for (j = 0; j < parts; j++, idx++)
4555         inst.operands[i].imm |= generic_bignum[idx]
4556                                 << (LITTLENUM_NUMBER_OF_BITS * j);
4557       inst.operands[i].reg = 0;
4558       for (j = 0; j < parts; j++, idx++)
4559         inst.operands[i].reg |= generic_bignum[idx]
4560                                 << (LITTLENUM_NUMBER_OF_BITS * j);
4561       inst.operands[i].regisimm = 1;
4562     }
4563   else
4564     return FAIL;
4565
4566   *str = ptr;
4567
4568   return SUCCESS;
4569 }
4570
4571 /* Returns the pseudo-register number of an FPA immediate constant,
4572    or FAIL if there isn't a valid constant here.  */
4573
4574 static int
4575 parse_fpa_immediate (char ** str)
4576 {
4577   LITTLENUM_TYPE words[MAX_LITTLENUMS];
4578   char *         save_in;
4579   expressionS    exp;
4580   int            i;
4581   int            j;
4582
4583   /* First try and match exact strings, this is to guarantee
4584      that some formats will work even for cross assembly.  */
4585
4586   for (i = 0; fp_const[i]; i++)
4587     {
4588       if (strncmp (*str, fp_const[i], strlen (fp_const[i])) == 0)
4589         {
4590           char *start = *str;
4591
4592           *str += strlen (fp_const[i]);
4593           if (is_end_of_line[(unsigned char) **str])
4594             return i + 8;
4595           *str = start;
4596         }
4597     }
4598
4599   /* Just because we didn't get a match doesn't mean that the constant
4600      isn't valid, just that it is in a format that we don't
4601      automatically recognize.  Try parsing it with the standard
4602      expression routines.  */
4603
4604   memset (words, 0, MAX_LITTLENUMS * sizeof (LITTLENUM_TYPE));
4605
4606   /* Look for a raw floating point number.  */
4607   if ((save_in = atof_ieee (*str, 'x', words)) != NULL
4608       && is_end_of_line[(unsigned char) *save_in])
4609     {
4610       for (i = 0; i < NUM_FLOAT_VALS; i++)
4611         {
4612           for (j = 0; j < MAX_LITTLENUMS; j++)
4613             {
4614               if (words[j] != fp_values[i][j])
4615                 break;
4616             }
4617
4618           if (j == MAX_LITTLENUMS)
4619             {
4620               *str = save_in;
4621               return i + 8;
4622             }
4623         }
4624     }
4625
4626   /* Try and parse a more complex expression, this will probably fail
4627      unless the code uses a floating point prefix (eg "0f").  */
4628   save_in = input_line_pointer;
4629   input_line_pointer = *str;
4630   if (expression (&exp) == absolute_section
4631       && exp.X_op == O_big
4632       && exp.X_add_number < 0)
4633     {
4634       /* FIXME: 5 = X_PRECISION, should be #define'd where we can use it.
4635          Ditto for 15.  */
4636       if (gen_to_words (words, 5, (long) 15) == 0)
4637         {
4638           for (i = 0; i < NUM_FLOAT_VALS; i++)
4639             {
4640               for (j = 0; j < MAX_LITTLENUMS; j++)
4641                 {
4642                   if (words[j] != fp_values[i][j])
4643                     break;
4644                 }
4645
4646               if (j == MAX_LITTLENUMS)
4647                 {
4648                   *str = input_line_pointer;
4649                   input_line_pointer = save_in;
4650                   return i + 8;
4651                 }
4652             }
4653         }
4654     }
4655
4656   *str = input_line_pointer;
4657   input_line_pointer = save_in;
4658   inst.error = _("invalid FPA immediate expression");
4659   return FAIL;
4660 }
4661
4662 /* Returns 1 if a number has "quarter-precision" float format
4663    0baBbbbbbc defgh000 00000000 00000000.  */
4664
4665 static int
4666 is_quarter_float (unsigned imm)
4667 {
4668   int bs = (imm & 0x20000000) ? 0x3e000000 : 0x40000000;
4669   return (imm & 0x7ffff) == 0 && ((imm & 0x7e000000) ^ bs) == 0;
4670 }
4671
4672 /* Parse an 8-bit "quarter-precision" floating point number of the form:
4673    0baBbbbbbc defgh000 00000000 00000000.
4674    The zero and minus-zero cases need special handling, since they can't be
4675    encoded in the "quarter-precision" float format, but can nonetheless be
4676    loaded as integer constants.  */
4677
4678 static unsigned
4679 parse_qfloat_immediate (char **ccp, int *immed)
4680 {
4681   char *str = *ccp;
4682   char *fpnum;
4683   LITTLENUM_TYPE words[MAX_LITTLENUMS];
4684   int found_fpchar = 0;
4685
4686   skip_past_char (&str, '#');
4687
4688   /* We must not accidentally parse an integer as a floating-point number. Make
4689      sure that the value we parse is not an integer by checking for special
4690      characters '.' or 'e'.
4691      FIXME: This is a horrible hack, but doing better is tricky because type
4692      information isn't in a very usable state at parse time.  */
4693   fpnum = str;
4694   skip_whitespace (fpnum);
4695
4696   if (strncmp (fpnum, "0x", 2) == 0)
4697     return FAIL;
4698   else
4699     {
4700       for (; *fpnum != '\0' && *fpnum != ' ' && *fpnum != '\n'; fpnum++)
4701         if (*fpnum == '.' || *fpnum == 'e' || *fpnum == 'E')
4702           {
4703             found_fpchar = 1;
4704             break;
4705           }
4706
4707       if (!found_fpchar)
4708         return FAIL;
4709     }
4710
4711   if ((str = atof_ieee (str, 's', words)) != NULL)
4712     {
4713       unsigned fpword = 0;
4714       int i;
4715
4716       /* Our FP word must be 32 bits (single-precision FP).  */
4717       for (i = 0; i < 32 / LITTLENUM_NUMBER_OF_BITS; i++)
4718         {
4719           fpword <<= LITTLENUM_NUMBER_OF_BITS;
4720           fpword |= words[i];
4721         }
4722
4723       if (is_quarter_float (fpword) || (fpword & 0x7fffffff) == 0)
4724         *immed = fpword;
4725       else
4726         return FAIL;
4727
4728       *ccp = str;
4729
4730       return SUCCESS;
4731     }
4732
4733   return FAIL;
4734 }
4735
4736 /* Shift operands.  */
4737 enum shift_kind
4738 {
4739   SHIFT_LSL, SHIFT_LSR, SHIFT_ASR, SHIFT_ROR, SHIFT_RRX
4740 };
4741
4742 struct asm_shift_name
4743 {
4744   const char      *name;
4745   enum shift_kind  kind;
4746 };
4747
4748 /* Third argument to parse_shift.  */
4749 enum parse_shift_mode
4750 {
4751   NO_SHIFT_RESTRICT,            /* Any kind of shift is accepted.  */
4752   SHIFT_IMMEDIATE,              /* Shift operand must be an immediate.  */
4753   SHIFT_LSL_OR_ASR_IMMEDIATE,   /* Shift must be LSL or ASR immediate.  */
4754   SHIFT_ASR_IMMEDIATE,          /* Shift must be ASR immediate.  */
4755   SHIFT_LSL_IMMEDIATE,          /* Shift must be LSL immediate.  */
4756 };
4757
4758 /* Parse a <shift> specifier on an ARM data processing instruction.
4759    This has three forms:
4760
4761      (LSL|LSR|ASL|ASR|ROR) Rs
4762      (LSL|LSR|ASL|ASR|ROR) #imm
4763      RRX
4764
4765    Note that ASL is assimilated to LSL in the instruction encoding, and
4766    RRX to ROR #0 (which cannot be written as such).  */
4767
4768 static int
4769 parse_shift (char **str, int i, enum parse_shift_mode mode)
4770 {
4771   const struct asm_shift_name *shift_name;
4772   enum shift_kind shift;
4773   char *s = *str;
4774   char *p = s;
4775   int reg;
4776
4777   for (p = *str; ISALPHA (*p); p++)
4778     ;
4779
4780   if (p == *str)
4781     {
4782       inst.error = _("shift expression expected");
4783       return FAIL;
4784     }
4785
4786   shift_name = (const struct asm_shift_name *) hash_find_n (arm_shift_hsh, *str,
4787                                                             p - *str);
4788
4789   if (shift_name == NULL)
4790     {
4791       inst.error = _("shift expression expected");
4792       return FAIL;
4793     }
4794
4795   shift = shift_name->kind;
4796
4797   switch (mode)
4798     {
4799     case NO_SHIFT_RESTRICT:
4800     case SHIFT_IMMEDIATE:   break;
4801
4802     case SHIFT_LSL_OR_ASR_IMMEDIATE:
4803       if (shift != SHIFT_LSL && shift != SHIFT_ASR)
4804         {
4805           inst.error = _("'LSL' or 'ASR' required");
4806           return FAIL;
4807         }
4808       break;
4809
4810     case SHIFT_LSL_IMMEDIATE:
4811       if (shift != SHIFT_LSL)
4812         {
4813           inst.error = _("'LSL' required");
4814           return FAIL;
4815         }
4816       break;
4817
4818     case SHIFT_ASR_IMMEDIATE:
4819       if (shift != SHIFT_ASR)
4820         {
4821           inst.error = _("'ASR' required");
4822           return FAIL;
4823         }
4824       break;
4825
4826     default: abort ();
4827     }
4828
4829   if (shift != SHIFT_RRX)
4830     {
4831       /* Whitespace can appear here if the next thing is a bare digit.  */
4832       skip_whitespace (p);
4833
4834       if (mode == NO_SHIFT_RESTRICT
4835           && (reg = arm_reg_parse (&p, REG_TYPE_RN)) != FAIL)
4836         {
4837           inst.operands[i].imm = reg;
4838           inst.operands[i].immisreg = 1;
4839         }
4840       else if (my_get_expression (&inst.reloc.exp, &p, GE_IMM_PREFIX))
4841         return FAIL;
4842     }
4843   inst.operands[i].shift_kind = shift;
4844   inst.operands[i].shifted = 1;
4845   *str = p;
4846   return SUCCESS;
4847 }
4848
4849 /* Parse a <shifter_operand> for an ARM data processing instruction:
4850
4851       #<immediate>
4852       #<immediate>, <rotate>
4853       <Rm>
4854       <Rm>, <shift>
4855
4856    where <shift> is defined by parse_shift above, and <rotate> is a
4857    multiple of 2 between 0 and 30.  Validation of immediate operands
4858    is deferred to md_apply_fix.  */
4859
4860 static int
4861 parse_shifter_operand (char **str, int i)
4862 {
4863   int value;
4864   expressionS exp;
4865
4866   if ((value = arm_reg_parse (str, REG_TYPE_RN)) != FAIL)
4867     {
4868       inst.operands[i].reg = value;
4869       inst.operands[i].isreg = 1;
4870
4871       /* parse_shift will override this if appropriate */
4872       inst.reloc.exp.X_op = O_constant;
4873       inst.reloc.exp.X_add_number = 0;
4874
4875       if (skip_past_comma (str) == FAIL)
4876         return SUCCESS;
4877
4878       /* Shift operation on register.  */
4879       return parse_shift (str, i, NO_SHIFT_RESTRICT);
4880     }
4881
4882   if (my_get_expression (&inst.reloc.exp, str, GE_IMM_PREFIX))
4883     return FAIL;
4884
4885   if (skip_past_comma (str) == SUCCESS)
4886     {
4887       /* #x, y -- ie explicit rotation by Y.  */
4888       if (my_get_expression (&exp, str, GE_NO_PREFIX))
4889         return FAIL;
4890
4891       if (exp.X_op != O_constant || inst.reloc.exp.X_op != O_constant)
4892         {
4893           inst.error = _("constant expression expected");
4894           return FAIL;
4895         }
4896
4897       value = exp.X_add_number;
4898       if (value < 0 || value > 30 || value % 2 != 0)
4899         {
4900           inst.error = _("invalid rotation");
4901           return FAIL;
4902         }
4903       if (inst.reloc.exp.X_add_number < 0 || inst.reloc.exp.X_add_number > 255)
4904         {
4905           inst.error = _("invalid constant");
4906           return FAIL;
4907         }
4908
4909       /* Encode as specified.  */
4910       inst.operands[i].imm = inst.reloc.exp.X_add_number | value << 7;
4911       return SUCCESS;
4912     }
4913
4914   inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
4915   inst.reloc.pc_rel = 0;
4916   return SUCCESS;
4917 }
4918
4919 /* Group relocation information.  Each entry in the table contains the
4920    textual name of the relocation as may appear in assembler source
4921    and must end with a colon.
4922    Along with this textual name are the relocation codes to be used if
4923    the corresponding instruction is an ALU instruction (ADD or SUB only),
4924    an LDR, an LDRS, or an LDC.  */
4925
4926 struct group_reloc_table_entry
4927 {
4928   const char *name;
4929   int alu_code;
4930   int ldr_code;
4931   int ldrs_code;
4932   int ldc_code;
4933 };
4934
4935 typedef enum
4936 {
4937   /* Varieties of non-ALU group relocation.  */
4938
4939   GROUP_LDR,
4940   GROUP_LDRS,
4941   GROUP_LDC
4942 } group_reloc_type;
4943
4944 static struct group_reloc_table_entry group_reloc_table[] =
4945   { /* Program counter relative: */
4946     { "pc_g0_nc",
4947       BFD_RELOC_ARM_ALU_PC_G0_NC,       /* ALU */
4948       0,                                /* LDR */
4949       0,                                /* LDRS */
4950       0 },                              /* LDC */
4951     { "pc_g0",
4952       BFD_RELOC_ARM_ALU_PC_G0,          /* ALU */
4953       BFD_RELOC_ARM_LDR_PC_G0,          /* LDR */
4954       BFD_RELOC_ARM_LDRS_PC_G0,         /* LDRS */
4955       BFD_RELOC_ARM_LDC_PC_G0 },        /* LDC */
4956     { "pc_g1_nc",
4957       BFD_RELOC_ARM_ALU_PC_G1_NC,       /* ALU */
4958       0,                                /* LDR */
4959       0,                                /* LDRS */
4960       0 },                              /* LDC */
4961     { "pc_g1",
4962       BFD_RELOC_ARM_ALU_PC_G1,          /* ALU */
4963       BFD_RELOC_ARM_LDR_PC_G1,          /* LDR */
4964       BFD_RELOC_ARM_LDRS_PC_G1,         /* LDRS */
4965       BFD_RELOC_ARM_LDC_PC_G1 },        /* LDC */
4966     { "pc_g2",
4967       BFD_RELOC_ARM_ALU_PC_G2,          /* ALU */
4968       BFD_RELOC_ARM_LDR_PC_G2,          /* LDR */
4969       BFD_RELOC_ARM_LDRS_PC_G2,         /* LDRS */
4970       BFD_RELOC_ARM_LDC_PC_G2 },        /* LDC */
4971     /* Section base relative */
4972     { "sb_g0_nc",
4973       BFD_RELOC_ARM_ALU_SB_G0_NC,       /* ALU */
4974       0,                                /* LDR */
4975       0,                                /* LDRS */
4976       0 },                              /* LDC */
4977     { "sb_g0",
4978       BFD_RELOC_ARM_ALU_SB_G0,          /* ALU */
4979       BFD_RELOC_ARM_LDR_SB_G0,          /* LDR */
4980       BFD_RELOC_ARM_LDRS_SB_G0,         /* LDRS */
4981       BFD_RELOC_ARM_LDC_SB_G0 },        /* LDC */
4982     { "sb_g1_nc",
4983       BFD_RELOC_ARM_ALU_SB_G1_NC,       /* ALU */
4984       0,                                /* LDR */
4985       0,                                /* LDRS */
4986       0 },                              /* LDC */
4987     { "sb_g1",
4988       BFD_RELOC_ARM_ALU_SB_G1,          /* ALU */
4989       BFD_RELOC_ARM_LDR_SB_G1,          /* LDR */
4990       BFD_RELOC_ARM_LDRS_SB_G1,         /* LDRS */
4991       BFD_RELOC_ARM_LDC_SB_G1 },        /* LDC */
4992     { "sb_g2",
4993       BFD_RELOC_ARM_ALU_SB_G2,          /* ALU */
4994       BFD_RELOC_ARM_LDR_SB_G2,          /* LDR */
4995       BFD_RELOC_ARM_LDRS_SB_G2,         /* LDRS */
4996       BFD_RELOC_ARM_LDC_SB_G2 } };      /* LDC */
4997
4998 /* Given the address of a pointer pointing to the textual name of a group
4999    relocation as may appear in assembler source, attempt to find its details
5000    in group_reloc_table.  The pointer will be updated to the character after
5001    the trailing colon.  On failure, FAIL will be returned; SUCCESS
5002    otherwise.  On success, *entry will be updated to point at the relevant
5003    group_reloc_table entry. */
5004
5005 static int
5006 find_group_reloc_table_entry (char **str, struct group_reloc_table_entry **out)
5007 {
5008   unsigned int i;
5009   for (i = 0; i < ARRAY_SIZE (group_reloc_table); i++)
5010     {
5011       int length = strlen (group_reloc_table[i].name);
5012
5013       if (strncasecmp (group_reloc_table[i].name, *str, length) == 0
5014           && (*str)[length] == ':')
5015         {
5016           *out = &group_reloc_table[i];
5017           *str += (length + 1);
5018           return SUCCESS;
5019         }
5020     }
5021
5022   return FAIL;
5023 }
5024
5025 /* Parse a <shifter_operand> for an ARM data processing instruction
5026    (as for parse_shifter_operand) where group relocations are allowed:
5027
5028       #<immediate>
5029       #<immediate>, <rotate>
5030       #:<group_reloc>:<expression>
5031       <Rm>
5032       <Rm>, <shift>
5033
5034    where <group_reloc> is one of the strings defined in group_reloc_table.
5035    The hashes are optional.
5036
5037    Everything else is as for parse_shifter_operand.  */
5038
5039 static parse_operand_result
5040 parse_shifter_operand_group_reloc (char **str, int i)
5041 {
5042   /* Determine if we have the sequence of characters #: or just :
5043      coming next.  If we do, then we check for a group relocation.
5044      If we don't, punt the whole lot to parse_shifter_operand.  */
5045
5046   if (((*str)[0] == '#' && (*str)[1] == ':')
5047       || (*str)[0] == ':')
5048     {
5049       struct group_reloc_table_entry *entry;
5050
5051       if ((*str)[0] == '#')
5052         (*str) += 2;
5053       else
5054         (*str)++;
5055
5056       /* Try to parse a group relocation.  Anything else is an error.  */
5057       if (find_group_reloc_table_entry (str, &entry) == FAIL)
5058         {
5059           inst.error = _("unknown group relocation");
5060           return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5061         }
5062
5063       /* We now have the group relocation table entry corresponding to
5064          the name in the assembler source.  Next, we parse the expression.  */
5065       if (my_get_expression (&inst.reloc.exp, str, GE_NO_PREFIX))
5066         return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5067
5068       /* Record the relocation type (always the ALU variant here).  */
5069       inst.reloc.type = (bfd_reloc_code_real_type) entry->alu_code;
5070       gas_assert (inst.reloc.type != 0);
5071
5072       return PARSE_OPERAND_SUCCESS;
5073     }
5074   else
5075     return parse_shifter_operand (str, i) == SUCCESS
5076            ? PARSE_OPERAND_SUCCESS : PARSE_OPERAND_FAIL;
5077
5078   /* Never reached.  */
5079 }
5080
5081 /* Parse a Neon alignment expression.  Information is written to
5082    inst.operands[i].  We assume the initial ':' has been skipped.
5083
5084    align        .imm = align << 8, .immisalign=1, .preind=0  */
5085 static parse_operand_result
5086 parse_neon_alignment (char **str, int i)
5087 {
5088   char *p = *str;
5089   expressionS exp;
5090
5091   my_get_expression (&exp, &p, GE_NO_PREFIX);
5092
5093   if (exp.X_op != O_constant)
5094     {
5095       inst.error = _("alignment must be constant");
5096       return PARSE_OPERAND_FAIL;
5097     }
5098
5099   inst.operands[i].imm = exp.X_add_number << 8;
5100   inst.operands[i].immisalign = 1;
5101   /* Alignments are not pre-indexes.  */
5102   inst.operands[i].preind = 0;
5103
5104   *str = p;
5105   return PARSE_OPERAND_SUCCESS;
5106 }
5107
5108 /* Parse all forms of an ARM address expression.  Information is written
5109    to inst.operands[i] and/or inst.reloc.
5110
5111    Preindexed addressing (.preind=1):
5112
5113    [Rn, #offset]       .reg=Rn .reloc.exp=offset
5114    [Rn, +/-Rm]         .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5115    [Rn, +/-Rm, shift]  .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5116                        .shift_kind=shift .reloc.exp=shift_imm
5117
5118    These three may have a trailing ! which causes .writeback to be set also.
5119
5120    Postindexed addressing (.postind=1, .writeback=1):
5121
5122    [Rn], #offset       .reg=Rn .reloc.exp=offset
5123    [Rn], +/-Rm         .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5124    [Rn], +/-Rm, shift  .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5125                        .shift_kind=shift .reloc.exp=shift_imm
5126
5127    Unindexed addressing (.preind=0, .postind=0):
5128
5129    [Rn], {option}      .reg=Rn .imm=option .immisreg=0
5130
5131    Other:
5132
5133    [Rn]{!}             shorthand for [Rn,#0]{!}
5134    =immediate          .isreg=0 .reloc.exp=immediate
5135    label               .reg=PC .reloc.pc_rel=1 .reloc.exp=label
5136
5137   It is the caller's responsibility to check for addressing modes not
5138   supported by the instruction, and to set inst.reloc.type.  */
5139
5140 static parse_operand_result
5141 parse_address_main (char **str, int i, int group_relocations,
5142                     group_reloc_type group_type)
5143 {
5144   char *p = *str;
5145   int reg;
5146
5147   if (skip_past_char (&p, '[') == FAIL)
5148     {
5149       if (skip_past_char (&p, '=') == FAIL)
5150         {
5151           /* Bare address - translate to PC-relative offset.  */
5152           inst.reloc.pc_rel = 1;
5153           inst.operands[i].reg = REG_PC;
5154           inst.operands[i].isreg = 1;
5155           inst.operands[i].preind = 1;
5156         }
5157       /* Otherwise a load-constant pseudo op, no special treatment needed here.  */
5158
5159       if (my_get_expression (&inst.reloc.exp, &p, GE_NO_PREFIX))
5160         return PARSE_OPERAND_FAIL;
5161
5162       *str = p;
5163       return PARSE_OPERAND_SUCCESS;
5164     }
5165
5166   if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) == FAIL)
5167     {
5168       inst.error = _(reg_expected_msgs[REG_TYPE_RN]);
5169       return PARSE_OPERAND_FAIL;
5170     }
5171   inst.operands[i].reg = reg;
5172   inst.operands[i].isreg = 1;
5173
5174   if (skip_past_comma (&p) == SUCCESS)
5175     {
5176       inst.operands[i].preind = 1;
5177
5178       if (*p == '+') p++;
5179       else if (*p == '-') p++, inst.operands[i].negative = 1;
5180
5181       if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) != FAIL)
5182         {
5183           inst.operands[i].imm = reg;
5184           inst.operands[i].immisreg = 1;
5185
5186           if (skip_past_comma (&p) == SUCCESS)
5187             if (parse_shift (&p, i, SHIFT_IMMEDIATE) == FAIL)
5188               return PARSE_OPERAND_FAIL;
5189         }
5190       else if (skip_past_char (&p, ':') == SUCCESS)
5191         {
5192           /* FIXME: '@' should be used here, but it's filtered out by generic
5193              code before we get to see it here. This may be subject to
5194              change.  */
5195           parse_operand_result result = parse_neon_alignment (&p, i);
5196
5197           if (result != PARSE_OPERAND_SUCCESS)
5198             return result;
5199         }
5200       else
5201         {
5202           if (inst.operands[i].negative)
5203             {
5204               inst.operands[i].negative = 0;
5205               p--;
5206             }
5207
5208           if (group_relocations
5209               && ((*p == '#' && *(p + 1) == ':') || *p == ':'))
5210             {
5211               struct group_reloc_table_entry *entry;
5212
5213               /* Skip over the #: or : sequence.  */
5214               if (*p == '#')
5215                 p += 2;
5216               else
5217                 p++;
5218
5219               /* Try to parse a group relocation.  Anything else is an
5220                  error.  */
5221               if (find_group_reloc_table_entry (&p, &entry) == FAIL)
5222                 {
5223                   inst.error = _("unknown group relocation");
5224                   return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5225                 }
5226
5227               /* We now have the group relocation table entry corresponding to
5228                  the name in the assembler source.  Next, we parse the
5229                  expression.  */
5230               if (my_get_expression (&inst.reloc.exp, &p, GE_NO_PREFIX))
5231                 return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5232
5233               /* Record the relocation type.  */
5234               switch (group_type)
5235                 {
5236                   case GROUP_LDR:
5237                     inst.reloc.type = (bfd_reloc_code_real_type) entry->ldr_code;
5238                     break;
5239
5240                   case GROUP_LDRS:
5241                     inst.reloc.type = (bfd_reloc_code_real_type) entry->ldrs_code;
5242                     break;
5243
5244                   case GROUP_LDC:
5245                     inst.reloc.type = (bfd_reloc_code_real_type) entry->ldc_code;
5246                     break;
5247
5248                   default:
5249                     gas_assert (0);
5250                 }
5251
5252               if (inst.reloc.type == 0)
5253                 {
5254                   inst.error = _("this group relocation is not allowed on this instruction");
5255                   return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5256                 }
5257             }
5258           else
5259             {
5260               char *q = p;
5261               if (my_get_expression (&inst.reloc.exp, &p, GE_IMM_PREFIX))
5262                 return PARSE_OPERAND_FAIL;
5263               /* If the offset is 0, find out if it's a +0 or -0.  */
5264               if (inst.reloc.exp.X_op == O_constant
5265                   && inst.reloc.exp.X_add_number == 0)
5266                 {
5267                   skip_whitespace (q);
5268                   if (*q == '#')
5269                     {
5270                       q++;
5271                       skip_whitespace (q);
5272                     }
5273                   if (*q == '-')
5274                     inst.operands[i].negative = 1;
5275                 }
5276             }
5277         }
5278     }
5279   else if (skip_past_char (&p, ':') == SUCCESS)
5280     {
5281       /* FIXME: '@' should be used here, but it's filtered out by generic code
5282          before we get to see it here. This may be subject to change.  */
5283       parse_operand_result result = parse_neon_alignment (&p, i);
5284
5285       if (result != PARSE_OPERAND_SUCCESS)
5286         return result;
5287     }
5288
5289   if (skip_past_char (&p, ']') == FAIL)
5290     {
5291       inst.error = _("']' expected");
5292       return PARSE_OPERAND_FAIL;
5293     }
5294
5295   if (skip_past_char (&p, '!') == SUCCESS)
5296     inst.operands[i].writeback = 1;
5297
5298   else if (skip_past_comma (&p) == SUCCESS)
5299     {
5300       if (skip_past_char (&p, '{') == SUCCESS)
5301         {
5302           /* [Rn], {expr} - unindexed, with option */
5303           if (parse_immediate (&p, &inst.operands[i].imm,
5304                                0, 255, TRUE) == FAIL)
5305             return PARSE_OPERAND_FAIL;
5306
5307           if (skip_past_char (&p, '}') == FAIL)
5308             {
5309               inst.error = _("'}' expected at end of 'option' field");
5310               return PARSE_OPERAND_FAIL;
5311             }
5312           if (inst.operands[i].preind)
5313             {
5314               inst.error = _("cannot combine index with option");
5315               return PARSE_OPERAND_FAIL;
5316             }
5317           *str = p;
5318           return PARSE_OPERAND_SUCCESS;
5319         }
5320       else
5321         {
5322           inst.operands[i].postind = 1;
5323           inst.operands[i].writeback = 1;
5324
5325           if (inst.operands[i].preind)
5326             {
5327               inst.error = _("cannot combine pre- and post-indexing");
5328               return PARSE_OPERAND_FAIL;
5329             }
5330
5331           if (*p == '+') p++;
5332           else if (*p == '-') p++, inst.operands[i].negative = 1;
5333
5334           if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) != FAIL)
5335             {
5336               /* We might be using the immediate for alignment already. If we
5337                  are, OR the register number into the low-order bits.  */
5338               if (inst.operands[i].immisalign)
5339                 inst.operands[i].imm |= reg;
5340               else
5341                 inst.operands[i].imm = reg;
5342               inst.operands[i].immisreg = 1;
5343
5344               if (skip_past_comma (&p) == SUCCESS)
5345                 if (parse_shift (&p, i, SHIFT_IMMEDIATE) == FAIL)
5346                   return PARSE_OPERAND_FAIL;
5347             }
5348           else
5349             {
5350               char *q = p;
5351               if (inst.operands[i].negative)
5352                 {
5353                   inst.operands[i].negative = 0;
5354                   p--;
5355                 }
5356               if (my_get_expression (&inst.reloc.exp, &p, GE_IMM_PREFIX))
5357                 return PARSE_OPERAND_FAIL;
5358               /* If the offset is 0, find out if it's a +0 or -0.  */
5359               if (inst.reloc.exp.X_op == O_constant
5360                   && inst.reloc.exp.X_add_number == 0)
5361                 {
5362                   skip_whitespace (q);
5363                   if (*q == '#')
5364                     {
5365                       q++;
5366                       skip_whitespace (q);
5367                     }
5368                   if (*q == '-')
5369                     inst.operands[i].negative = 1;
5370                 }
5371             }
5372         }
5373     }
5374
5375   /* If at this point neither .preind nor .postind is set, we have a
5376      bare [Rn]{!}, which is shorthand for [Rn,#0]{!}.  */
5377   if (inst.operands[i].preind == 0 && inst.operands[i].postind == 0)
5378     {
5379       inst.operands[i].preind = 1;
5380       inst.reloc.exp.X_op = O_constant;
5381       inst.reloc.exp.X_add_number = 0;
5382     }
5383   *str = p;
5384   return PARSE_OPERAND_SUCCESS;
5385 }
5386
5387 static int
5388 parse_address (char **str, int i)
5389 {
5390   return parse_address_main (str, i, 0, GROUP_LDR) == PARSE_OPERAND_SUCCESS
5391          ? SUCCESS : FAIL;
5392 }
5393
5394 static parse_operand_result
5395 parse_address_group_reloc (char **str, int i, group_reloc_type type)
5396 {
5397   return parse_address_main (str, i, 1, type);
5398 }
5399
5400 /* Parse an operand for a MOVW or MOVT instruction.  */
5401 static int
5402 parse_half (char **str)
5403 {
5404   char * p;
5405
5406   p = *str;
5407   skip_past_char (&p, '#');
5408   if (strncasecmp (p, ":lower16:", 9) == 0)
5409     inst.reloc.type = BFD_RELOC_ARM_MOVW;
5410   else if (strncasecmp (p, ":upper16:", 9) == 0)
5411     inst.reloc.type = BFD_RELOC_ARM_MOVT;
5412
5413   if (inst.reloc.type != BFD_RELOC_UNUSED)
5414     {
5415       p += 9;
5416       skip_whitespace (p);
5417     }
5418
5419   if (my_get_expression (&inst.reloc.exp, &p, GE_NO_PREFIX))
5420     return FAIL;
5421
5422   if (inst.reloc.type == BFD_RELOC_UNUSED)
5423     {
5424       if (inst.reloc.exp.X_op != O_constant)
5425         {
5426           inst.error = _("constant expression expected");
5427           return FAIL;
5428         }
5429       if (inst.reloc.exp.X_add_number < 0
5430           || inst.reloc.exp.X_add_number > 0xffff)
5431         {
5432           inst.error = _("immediate value out of range");
5433           return FAIL;
5434         }
5435     }
5436   *str = p;
5437   return SUCCESS;
5438 }
5439
5440 /* Miscellaneous. */
5441
5442 /* Parse a PSR flag operand.  The value returned is FAIL on syntax error,
5443    or a bitmask suitable to be or-ed into the ARM msr instruction.  */
5444 static int
5445 parse_psr (char **str, bfd_boolean lhs)
5446 {
5447   char *p;
5448   unsigned long psr_field;
5449   const struct asm_psr *psr;
5450   char *start;
5451   bfd_boolean is_apsr = FALSE;
5452   bfd_boolean m_profile = ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_m);
5453
5454   /* PR gas/12698:  If the user has specified -march=all then m_profile will
5455      be TRUE, but we want to ignore it in this case as we are building for any
5456      CPU type, including non-m variants.  */
5457   if (selected_cpu.core == arm_arch_any.core)
5458     m_profile = FALSE;
5459
5460   /* CPSR's and SPSR's can now be lowercase.  This is just a convenience
5461      feature for ease of use and backwards compatibility.  */
5462   p = *str;
5463   if (strncasecmp (p, "SPSR", 4) == 0)
5464     {
5465       if (m_profile)
5466         goto unsupported_psr;
5467
5468       psr_field = SPSR_BIT;
5469     }
5470   else if (strncasecmp (p, "CPSR", 4) == 0)
5471     {
5472       if (m_profile)
5473         goto unsupported_psr;
5474
5475       psr_field = 0;
5476     }
5477   else if (strncasecmp (p, "APSR", 4) == 0)
5478     {
5479       /* APSR[_<bits>] can be used as a synonym for CPSR[_<flags>] on ARMv7-A
5480          and ARMv7-R architecture CPUs.  */
5481       is_apsr = TRUE;
5482       psr_field = 0;
5483     }
5484   else if (m_profile)
5485     {
5486       start = p;
5487       do
5488         p++;
5489       while (ISALNUM (*p) || *p == '_');
5490
5491       if (strncasecmp (start, "iapsr", 5) == 0
5492           || strncasecmp (start, "eapsr", 5) == 0
5493           || strncasecmp (start, "xpsr", 4) == 0
5494           || strncasecmp (start, "psr", 3) == 0)
5495         p = start + strcspn (start, "rR") + 1;
5496
5497       psr = (const struct asm_psr *) hash_find_n (arm_v7m_psr_hsh, start,
5498                                                   p - start);
5499
5500       if (!psr)
5501         return FAIL;
5502
5503       /* If APSR is being written, a bitfield may be specified.  Note that
5504          APSR itself is handled above.  */
5505       if (psr->field <= 3)
5506         {
5507           psr_field = psr->field;
5508           is_apsr = TRUE;
5509           goto check_suffix;
5510         }
5511
5512       *str = p;
5513       /* M-profile MSR instructions have the mask field set to "10", except
5514          *PSR variants which modify APSR, which may use a different mask (and
5515          have been handled already).  Do that by setting the PSR_f field
5516          here.  */
5517       return psr->field | (lhs ? PSR_f : 0);
5518     }
5519   else
5520     goto unsupported_psr;
5521
5522   p += 4;
5523 check_suffix:
5524   if (*p == '_')
5525     {
5526       /* A suffix follows.  */
5527       p++;
5528       start = p;
5529
5530       do
5531         p++;
5532       while (ISALNUM (*p) || *p == '_');
5533
5534       if (is_apsr)
5535         {
5536           /* APSR uses a notation for bits, rather than fields.  */
5537           unsigned int nzcvq_bits = 0;
5538           unsigned int g_bit = 0;
5539           char *bit;
5540
5541           for (bit = start; bit != p; bit++)
5542             {
5543               switch (TOLOWER (*bit))
5544                 {
5545                 case 'n':
5546                   nzcvq_bits |= (nzcvq_bits & 0x01) ? 0x20 : 0x01;
5547                   break;
5548
5549                 case 'z':
5550                   nzcvq_bits |= (nzcvq_bits & 0x02) ? 0x20 : 0x02;
5551                   break;
5552
5553                 case 'c':
5554                   nzcvq_bits |= (nzcvq_bits & 0x04) ? 0x20 : 0x04;
5555                   break;
5556
5557                 case 'v':
5558                   nzcvq_bits |= (nzcvq_bits & 0x08) ? 0x20 : 0x08;
5559                   break;
5560
5561                 case 'q':
5562                   nzcvq_bits |= (nzcvq_bits & 0x10) ? 0x20 : 0x10;
5563                   break;
5564
5565                 case 'g':
5566                   g_bit |= (g_bit & 0x1) ? 0x2 : 0x1;
5567                   break;
5568
5569                 default:
5570                   inst.error = _("unexpected bit specified after APSR");
5571                   return FAIL;
5572                 }
5573             }
5574
5575           if (nzcvq_bits == 0x1f)
5576             psr_field |= PSR_f;
5577
5578           if (g_bit == 0x1)
5579             {
5580               if (!ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6_dsp))
5581                 {
5582                   inst.error = _("selected processor does not "
5583                                  "support DSP extension");
5584                   return FAIL;
5585                 }
5586
5587               psr_field |= PSR_s;
5588             }
5589
5590           if ((nzcvq_bits & 0x20) != 0
5591               || (nzcvq_bits != 0x1f && nzcvq_bits != 0)
5592               || (g_bit & 0x2) != 0)
5593             {
5594               inst.error = _("bad bitmask specified after APSR");
5595               return FAIL;
5596             }
5597         }
5598       else
5599         {
5600           psr = (const struct asm_psr *) hash_find_n (arm_psr_hsh, start,
5601                                                       p - start);
5602           if (!psr)
5603             goto error;
5604
5605           psr_field |= psr->field;
5606         }
5607     }
5608   else
5609     {
5610       if (ISALNUM (*p))
5611         goto error;    /* Garbage after "[CS]PSR".  */
5612
5613       /* Unadorned APSR is equivalent to APSR_nzcvq/CPSR_f (for writes).  This
5614          is deprecated, but allow it anyway.  */
5615       if (is_apsr && lhs)
5616         {
5617           psr_field |= PSR_f;
5618           as_tsktsk (_("writing to APSR without specifying a bitmask is "
5619                        "deprecated"));
5620         }
5621       else if (!m_profile)
5622         /* These bits are never right for M-profile devices: don't set them
5623            (only code paths which read/write APSR reach here).  */
5624         psr_field |= (PSR_c | PSR_f);
5625     }
5626   *str = p;
5627   return psr_field;
5628
5629  unsupported_psr:
5630   inst.error = _("selected processor does not support requested special "
5631                  "purpose register");
5632   return FAIL;
5633
5634  error:
5635   inst.error = _("flag for {c}psr instruction expected");
5636   return FAIL;
5637 }
5638
5639 /* Parse the flags argument to CPSI[ED].  Returns FAIL on error, or a
5640    value suitable for splatting into the AIF field of the instruction.  */
5641
5642 static int
5643 parse_cps_flags (char **str)
5644 {
5645   int val = 0;
5646   int saw_a_flag = 0;
5647   char *s = *str;
5648
5649   for (;;)
5650     switch (*s++)
5651       {
5652       case '\0': case ',':
5653         goto done;
5654
5655       case 'a': case 'A': saw_a_flag = 1; val |= 0x4; break;
5656       case 'i': case 'I': saw_a_flag = 1; val |= 0x2; break;
5657       case 'f': case 'F': saw_a_flag = 1; val |= 0x1; break;
5658
5659       default:
5660         inst.error = _("unrecognized CPS flag");
5661         return FAIL;
5662       }
5663
5664  done:
5665   if (saw_a_flag == 0)
5666     {
5667       inst.error = _("missing CPS flags");
5668       return FAIL;
5669     }
5670
5671   *str = s - 1;
5672   return val;
5673 }
5674
5675 /* Parse an endian specifier ("BE" or "LE", case insensitive);
5676    returns 0 for big-endian, 1 for little-endian, FAIL for an error.  */
5677
5678 static int
5679 parse_endian_specifier (char **str)
5680 {
5681   int little_endian;
5682   char *s = *str;
5683
5684   if (strncasecmp (s, "BE", 2))
5685     little_endian = 0;
5686   else if (strncasecmp (s, "LE", 2))
5687     little_endian = 1;
5688   else
5689     {
5690       inst.error = _("valid endian specifiers are be or le");
5691       return FAIL;
5692     }
5693
5694   if (ISALNUM (s[2]) || s[2] == '_')
5695     {
5696       inst.error = _("valid endian specifiers are be or le");
5697       return FAIL;
5698     }
5699
5700   *str = s + 2;
5701   return little_endian;
5702 }
5703
5704 /* Parse a rotation specifier: ROR #0, #8, #16, #24.  *val receives a
5705    value suitable for poking into the rotate field of an sxt or sxta
5706    instruction, or FAIL on error.  */
5707
5708 static int
5709 parse_ror (char **str)
5710 {
5711   int rot;
5712   char *s = *str;
5713
5714   if (strncasecmp (s, "ROR", 3) == 0)
5715     s += 3;
5716   else
5717     {
5718       inst.error = _("missing rotation field after comma");
5719       return FAIL;
5720     }
5721
5722   if (parse_immediate (&s, &rot, 0, 24, FALSE) == FAIL)
5723     return FAIL;
5724
5725   switch (rot)
5726     {
5727     case  0: *str = s; return 0x0;
5728     case  8: *str = s; return 0x1;
5729     case 16: *str = s; return 0x2;
5730     case 24: *str = s; return 0x3;
5731
5732     default:
5733       inst.error = _("rotation can only be 0, 8, 16, or 24");
5734       return FAIL;
5735     }
5736 }
5737
5738 /* Parse a conditional code (from conds[] below).  The value returned is in the
5739    range 0 .. 14, or FAIL.  */
5740 static int
5741 parse_cond (char **str)
5742 {
5743   char *q;
5744   const struct asm_cond *c;
5745   int n;
5746   /* Condition codes are always 2 characters, so matching up to
5747      3 characters is sufficient.  */
5748   char cond[3];
5749
5750   q = *str;
5751   n = 0;
5752   while (ISALPHA (*q) && n < 3)
5753     {
5754       cond[n] = TOLOWER (*q);
5755       q++;
5756       n++;
5757     }
5758
5759   c = (const struct asm_cond *) hash_find_n (arm_cond_hsh, cond, n);
5760   if (!c)
5761     {
5762       inst.error = _("condition required");
5763       return FAIL;
5764     }
5765
5766   *str = q;
5767   return c->value;
5768 }
5769
5770 /* If the given feature available in the selected CPU, mark it as used.
5771    Returns TRUE iff feature is available.  */
5772 static bfd_boolean
5773 mark_feature_used (const arm_feature_set *feature)
5774 {
5775   /* Ensure the option is valid on the current architecture.  */
5776   if (!ARM_CPU_HAS_FEATURE (cpu_variant, *feature))
5777     return FALSE;
5778
5779   /* Add the appropriate architecture feature for the barrier option used.
5780      */
5781   if (thumb_mode)
5782     ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used, *feature);
5783   else
5784     ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used, *feature);
5785
5786   return TRUE;
5787 }
5788
5789 /* Parse an option for a barrier instruction.  Returns the encoding for the
5790    option, or FAIL.  */
5791 static int
5792 parse_barrier (char **str)
5793 {
5794   char *p, *q;
5795   const struct asm_barrier_opt *o;
5796
5797   p = q = *str;
5798   while (ISALPHA (*q))
5799     q++;
5800
5801   o = (const struct asm_barrier_opt *) hash_find_n (arm_barrier_opt_hsh, p,
5802                                                     q - p);
5803   if (!o)
5804     return FAIL;
5805
5806   if (!mark_feature_used (&o->arch))
5807     return FAIL;
5808
5809   *str = q;
5810   return o->value;
5811 }
5812
5813 /* Parse the operands of a table branch instruction.  Similar to a memory
5814    operand.  */
5815 static int
5816 parse_tb (char **str)
5817 {
5818   char * p = *str;
5819   int reg;
5820
5821   if (skip_past_char (&p, '[') == FAIL)
5822     {
5823       inst.error = _("'[' expected");
5824       return FAIL;
5825     }
5826
5827   if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) == FAIL)
5828     {
5829       inst.error = _(reg_expected_msgs[REG_TYPE_RN]);
5830       return FAIL;
5831     }
5832   inst.operands[0].reg = reg;
5833
5834   if (skip_past_comma (&p) == FAIL)
5835     {
5836       inst.error = _("',' expected");
5837       return FAIL;
5838     }
5839
5840   if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) == FAIL)
5841     {
5842       inst.error = _(reg_expected_msgs[REG_TYPE_RN]);
5843       return FAIL;
5844     }
5845   inst.operands[0].imm = reg;
5846
5847   if (skip_past_comma (&p) == SUCCESS)
5848     {
5849       if (parse_shift (&p, 0, SHIFT_LSL_IMMEDIATE) == FAIL)
5850         return FAIL;
5851       if (inst.reloc.exp.X_add_number != 1)
5852         {
5853           inst.error = _("invalid shift");
5854           return FAIL;
5855         }
5856       inst.operands[0].shifted = 1;
5857     }
5858
5859   if (skip_past_char (&p, ']') == FAIL)
5860     {
5861       inst.error = _("']' expected");
5862       return FAIL;
5863     }
5864   *str = p;
5865   return SUCCESS;
5866 }
5867
5868 /* Parse the operands of a Neon VMOV instruction. See do_neon_mov for more
5869    information on the types the operands can take and how they are encoded.
5870    Up to four operands may be read; this function handles setting the
5871    ".present" field for each read operand itself.
5872    Updates STR and WHICH_OPERAND if parsing is successful and returns SUCCESS,
5873    else returns FAIL.  */
5874
5875 static int
5876 parse_neon_mov (char **str, int *which_operand)
5877 {
5878   int i = *which_operand, val;
5879   enum arm_reg_type rtype;
5880   char *ptr = *str;
5881   struct neon_type_el optype;
5882
5883   if ((val = parse_scalar (&ptr, 8, &optype)) != FAIL)
5884     {
5885       /* Case 4: VMOV<c><q>.<size> <Dn[x]>, <Rd>.  */
5886       inst.operands[i].reg = val;
5887       inst.operands[i].isscalar = 1;
5888       inst.operands[i].vectype = optype;
5889       inst.operands[i++].present = 1;
5890
5891       if (skip_past_comma (&ptr) == FAIL)
5892         goto wanted_comma;
5893
5894       if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
5895         goto wanted_arm;
5896
5897       inst.operands[i].reg = val;
5898       inst.operands[i].isreg = 1;
5899       inst.operands[i].present = 1;
5900     }
5901   else if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_NSDQ, &rtype, &optype))
5902            != FAIL)
5903     {
5904       /* Cases 0, 1, 2, 3, 5 (D only).  */
5905       if (skip_past_comma (&ptr) == FAIL)
5906         goto wanted_comma;
5907
5908       inst.operands[i].reg = val;
5909       inst.operands[i].isreg = 1;
5910       inst.operands[i].isquad = (rtype == REG_TYPE_NQ);
5911       inst.operands[i].issingle = (rtype == REG_TYPE_VFS);
5912       inst.operands[i].isvec = 1;
5913       inst.operands[i].vectype = optype;
5914       inst.operands[i++].present = 1;
5915
5916       if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) != FAIL)
5917         {
5918           /* Case 5: VMOV<c><q> <Dm>, <Rd>, <Rn>.
5919              Case 13: VMOV <Sd>, <Rm>  */
5920           inst.operands[i].reg = val;
5921           inst.operands[i].isreg = 1;
5922           inst.operands[i].present = 1;
5923
5924           if (rtype == REG_TYPE_NQ)
5925             {
5926               first_error (_("can't use Neon quad register here"));
5927               return FAIL;
5928             }
5929           else if (rtype != REG_TYPE_VFS)
5930             {
5931               i++;
5932               if (skip_past_comma (&ptr) == FAIL)
5933                 goto wanted_comma;
5934               if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
5935                 goto wanted_arm;
5936               inst.operands[i].reg = val;
5937               inst.operands[i].isreg = 1;
5938               inst.operands[i].present = 1;
5939             }
5940         }
5941       else if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_NSDQ, &rtype,
5942                                            &optype)) != FAIL)
5943         {
5944           /* Case 0: VMOV<c><q> <Qd>, <Qm>
5945              Case 1: VMOV<c><q> <Dd>, <Dm>
5946              Case 8: VMOV.F32 <Sd>, <Sm>
5947              Case 15: VMOV <Sd>, <Se>, <Rn>, <Rm>  */
5948
5949           inst.operands[i].reg = val;
5950           inst.operands[i].isreg = 1;
5951           inst.operands[i].isquad = (rtype == REG_TYPE_NQ);
5952           inst.operands[i].issingle = (rtype == REG_TYPE_VFS);
5953           inst.operands[i].isvec = 1;
5954           inst.operands[i].vectype = optype;
5955           inst.operands[i].present = 1;
5956
5957           if (skip_past_comma (&ptr) == SUCCESS)
5958             {
5959               /* Case 15.  */
5960               i++;
5961
5962               if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
5963                 goto wanted_arm;
5964
5965               inst.operands[i].reg = val;
5966               inst.operands[i].isreg = 1;
5967               inst.operands[i++].present = 1;
5968
5969               if (skip_past_comma (&ptr) == FAIL)
5970                 goto wanted_comma;
5971
5972               if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
5973                 goto wanted_arm;
5974
5975               inst.operands[i].reg = val;
5976               inst.operands[i].isreg = 1;
5977               inst.operands[i].present = 1;
5978             }
5979         }
5980       else if (parse_qfloat_immediate (&ptr, &inst.operands[i].imm) == SUCCESS)
5981           /* Case 2: VMOV<c><q>.<dt> <Qd>, #<float-imm>
5982              Case 3: VMOV<c><q>.<dt> <Dd>, #<float-imm>
5983              Case 10: VMOV.F32 <Sd>, #<imm>
5984              Case 11: VMOV.F64 <Dd>, #<imm>  */
5985         inst.operands[i].immisfloat = 1;
5986       else if (parse_big_immediate (&ptr, i) == SUCCESS)
5987           /* Case 2: VMOV<c><q>.<dt> <Qd>, #<imm>
5988              Case 3: VMOV<c><q>.<dt> <Dd>, #<imm>  */
5989         ;
5990       else
5991         {
5992           first_error (_("expected <Rm> or <Dm> or <Qm> operand"));
5993           return FAIL;
5994         }
5995     }
5996   else if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) != FAIL)
5997     {
5998       /* Cases 6, 7.  */
5999       inst.operands[i].reg = val;
6000       inst.operands[i].isreg = 1;
6001       inst.operands[i++].present = 1;
6002
6003       if (skip_past_comma (&ptr) == FAIL)
6004         goto wanted_comma;
6005
6006       if ((val = parse_scalar (&ptr, 8, &optype)) != FAIL)
6007         {
6008           /* Case 6: VMOV<c><q>.<dt> <Rd>, <Dn[x]>  */
6009           inst.operands[i].reg = val;
6010           inst.operands[i].isscalar = 1;
6011           inst.operands[i].present = 1;
6012           inst.operands[i].vectype = optype;
6013         }
6014       else if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) != FAIL)
6015         {
6016           /* Case 7: VMOV<c><q> <Rd>, <Rn>, <Dm>  */
6017           inst.operands[i].reg = val;
6018           inst.operands[i].isreg = 1;
6019           inst.operands[i++].present = 1;
6020
6021           if (skip_past_comma (&ptr) == FAIL)
6022             goto wanted_comma;
6023
6024           if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_VFSD, &rtype, &optype))
6025               == FAIL)
6026             {
6027               first_error (_(reg_expected_msgs[REG_TYPE_VFSD]));
6028               return FAIL;
6029             }
6030
6031           inst.operands[i].reg = val;
6032           inst.operands[i].isreg = 1;
6033           inst.operands[i].isvec = 1;
6034           inst.operands[i].issingle = (rtype == REG_TYPE_VFS);
6035           inst.operands[i].vectype = optype;
6036           inst.operands[i].present = 1;
6037
6038           if (rtype == REG_TYPE_VFS)
6039             {
6040               /* Case 14.  */
6041               i++;
6042               if (skip_past_comma (&ptr) == FAIL)
6043                 goto wanted_comma;
6044               if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_VFS, NULL,
6045                                               &optype)) == FAIL)
6046                 {
6047                   first_error (_(reg_expected_msgs[REG_TYPE_VFS]));
6048                   return FAIL;
6049                 }
6050               inst.operands[i].reg = val;
6051               inst.operands[i].isreg = 1;
6052               inst.operands[i].isvec = 1;
6053               inst.operands[i].issingle = 1;
6054               inst.operands[i].vectype = optype;
6055               inst.operands[i].present = 1;
6056             }
6057         }
6058       else if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_VFS, NULL, &optype))
6059                != FAIL)
6060         {
6061           /* Case 13.  */
6062           inst.operands[i].reg = val;
6063           inst.operands[i].isreg = 1;
6064           inst.operands[i].isvec = 1;
6065           inst.operands[i].issingle = 1;
6066           inst.operands[i].vectype = optype;
6067           inst.operands[i].present = 1;
6068         }
6069     }
6070   else
6071     {
6072       first_error (_("parse error"));
6073       return FAIL;
6074     }
6075
6076   /* Successfully parsed the operands. Update args.  */
6077   *which_operand = i;
6078   *str = ptr;
6079   return SUCCESS;
6080
6081  wanted_comma:
6082   first_error (_("expected comma"));
6083   return FAIL;
6084
6085  wanted_arm:
6086   first_error (_(reg_expected_msgs[REG_TYPE_RN]));
6087   return FAIL;
6088 }
6089
6090 /* Use this macro when the operand constraints are different
6091    for ARM and THUMB (e.g. ldrd).  */
6092 #define MIX_ARM_THUMB_OPERANDS(arm_operand, thumb_operand) \
6093         ((arm_operand) | ((thumb_operand) << 16))
6094
6095 /* Matcher codes for parse_operands.  */
6096 enum operand_parse_code
6097 {
6098   OP_stop,      /* end of line */
6099
6100   OP_RR,        /* ARM register */
6101   OP_RRnpc,     /* ARM register, not r15 */
6102   OP_RRnpcsp,   /* ARM register, neither r15 nor r13 (a.k.a. 'BadReg') */
6103   OP_RRnpcb,    /* ARM register, not r15, in square brackets */
6104   OP_RRnpctw,   /* ARM register, not r15 in Thumb-state or with writeback,
6105                    optional trailing ! */
6106   OP_RRw,       /* ARM register, not r15, optional trailing ! */
6107   OP_RCP,       /* Coprocessor number */
6108   OP_RCN,       /* Coprocessor register */
6109   OP_RF,        /* FPA register */
6110   OP_RVS,       /* VFP single precision register */
6111   OP_RVD,       /* VFP double precision register (0..15) */
6112   OP_RND,       /* Neon double precision register (0..31) */
6113   OP_RNQ,       /* Neon quad precision register */
6114   OP_RVSD,      /* VFP single or double precision register */
6115   OP_RNDQ,      /* Neon double or quad precision register */
6116   OP_RNSDQ,     /* Neon single, double or quad precision register */
6117   OP_RNSC,      /* Neon scalar D[X] */
6118   OP_RVC,       /* VFP control register */
6119   OP_RMF,       /* Maverick F register */
6120   OP_RMD,       /* Maverick D register */
6121   OP_RMFX,      /* Maverick FX register */
6122   OP_RMDX,      /* Maverick DX register */
6123   OP_RMAX,      /* Maverick AX register */
6124   OP_RMDS,      /* Maverick DSPSC register */
6125   OP_RIWR,      /* iWMMXt wR register */
6126   OP_RIWC,      /* iWMMXt wC register */
6127   OP_RIWG,      /* iWMMXt wCG register */
6128   OP_RXA,       /* XScale accumulator register */
6129
6130   OP_REGLST,    /* ARM register list */
6131   OP_VRSLST,    /* VFP single-precision register list */
6132   OP_VRDLST,    /* VFP double-precision register list */
6133   OP_VRSDLST,   /* VFP single or double-precision register list (& quad) */
6134   OP_NRDLST,    /* Neon double-precision register list (d0-d31, qN aliases) */
6135   OP_NSTRLST,   /* Neon element/structure list */
6136
6137   OP_RNDQ_I0,   /* Neon D or Q reg, or immediate zero.  */
6138   OP_RVSD_I0,   /* VFP S or D reg, or immediate zero.  */
6139   OP_RR_RNSC,   /* ARM reg or Neon scalar.  */
6140   OP_RNSDQ_RNSC, /* Vector S, D or Q reg, or Neon scalar.  */
6141   OP_RNDQ_RNSC, /* Neon D or Q reg, or Neon scalar.  */
6142   OP_RND_RNSC,  /* Neon D reg, or Neon scalar.  */
6143   OP_VMOV,      /* Neon VMOV operands.  */
6144   OP_RNDQ_Ibig, /* Neon D or Q reg, or big immediate for logic and VMVN.  */
6145   OP_RNDQ_I63b, /* Neon D or Q reg, or immediate for shift.  */
6146   OP_RIWR_I32z, /* iWMMXt wR register, or immediate 0 .. 32 for iWMMXt2.  */
6147
6148   OP_I0,        /* immediate zero */
6149   OP_I7,        /* immediate value 0 .. 7 */
6150   OP_I15,       /*                 0 .. 15 */
6151   OP_I16,       /*                 1 .. 16 */
6152   OP_I16z,      /*                 0 .. 16 */
6153   OP_I31,       /*                 0 .. 31 */
6154   OP_I31w,      /*                 0 .. 31, optional trailing ! */
6155   OP_I32,       /*                 1 .. 32 */
6156   OP_I32z,      /*                 0 .. 32 */
6157   OP_I63,       /*                 0 .. 63 */
6158   OP_I63s,      /*               -64 .. 63 */
6159   OP_I64,       /*                 1 .. 64 */
6160   OP_I64z,      /*                 0 .. 64 */
6161   OP_I255,      /*                 0 .. 255 */
6162
6163   OP_I4b,       /* immediate, prefix optional, 1 .. 4 */
6164   OP_I7b,       /*                             0 .. 7 */
6165   OP_I15b,      /*                             0 .. 15 */
6166   OP_I31b,      /*                             0 .. 31 */
6167
6168   OP_SH,        /* shifter operand */
6169   OP_SHG,       /* shifter operand with possible group relocation */
6170   OP_ADDR,      /* Memory address expression (any mode) */
6171   OP_ADDRGLDR,  /* Mem addr expr (any mode) with possible LDR group reloc */
6172   OP_ADDRGLDRS, /* Mem addr expr (any mode) with possible LDRS group reloc */
6173   OP_ADDRGLDC,  /* Mem addr expr (any mode) with possible LDC group reloc */
6174   OP_EXP,       /* arbitrary expression */
6175   OP_EXPi,      /* same, with optional immediate prefix */
6176   OP_EXPr,      /* same, with optional relocation suffix */
6177   OP_HALF,      /* 0 .. 65535 or low/high reloc.  */
6178
6179   OP_CPSF,      /* CPS flags */
6180   OP_ENDI,      /* Endianness specifier */
6181   OP_wPSR,      /* CPSR/SPSR/APSR mask for msr (writing).  */
6182   OP_rPSR,      /* CPSR/SPSR/APSR mask for msr (reading).  */
6183   OP_COND,      /* conditional code */
6184   OP_TB,        /* Table branch.  */
6185
6186   OP_APSR_RR,   /* ARM register or "APSR_nzcv".  */
6187
6188   OP_RRnpc_I0,  /* ARM register or literal 0 */
6189   OP_RR_EXr,    /* ARM register or expression with opt. reloc suff. */
6190   OP_RR_EXi,    /* ARM register or expression with imm prefix */
6191   OP_RF_IF,     /* FPA register or immediate */
6192   OP_RIWR_RIWC, /* iWMMXt R or C reg */
6193   OP_RIWC_RIWG, /* iWMMXt wC or wCG reg */
6194
6195   /* Optional operands.  */
6196   OP_oI7b,       /* immediate, prefix optional, 0 .. 7 */
6197   OP_oI31b,      /*                             0 .. 31 */
6198   OP_oI32b,      /*                             1 .. 32 */
6199   OP_oI32z,      /*                             0 .. 32 */
6200   OP_oIffffb,    /*                             0 .. 65535 */
6201   OP_oI255c,     /*       curly-brace enclosed, 0 .. 255 */
6202
6203   OP_oRR,        /* ARM register */
6204   OP_oRRnpc,     /* ARM register, not the PC */
6205   OP_oRRnpcsp,   /* ARM register, neither the PC nor the SP (a.k.a. BadReg) */
6206   OP_oRRw,       /* ARM register, not r15, optional trailing ! */
6207   OP_oRND,       /* Optional Neon double precision register */
6208   OP_oRNQ,       /* Optional Neon quad precision register */
6209   OP_oRNDQ,      /* Optional Neon double or quad precision register */
6210   OP_oRNSDQ,     /* Optional single, double or quad precision vector register */
6211   OP_oSHll,      /* LSL immediate */
6212   OP_oSHar,      /* ASR immediate */
6213   OP_oSHllar,    /* LSL or ASR immediate */
6214   OP_oROR,       /* ROR 0/8/16/24 */
6215   OP_oBARRIER_I15, /* Option argument for a barrier instruction.  */
6216
6217   /* Some pre-defined mixed (ARM/THUMB) operands.  */
6218   OP_RR_npcsp           = MIX_ARM_THUMB_OPERANDS (OP_RR, OP_RRnpcsp),
6219   OP_RRnpc_npcsp        = MIX_ARM_THUMB_OPERANDS (OP_RRnpc, OP_RRnpcsp),
6220   OP_oRRnpc_npcsp       = MIX_ARM_THUMB_OPERANDS (OP_oRRnpc, OP_oRRnpcsp),
6221
6222   OP_FIRST_OPTIONAL = OP_oI7b
6223 };
6224
6225 /* Generic instruction operand parser.  This does no encoding and no
6226    semantic validation; it merely squirrels values away in the inst
6227    structure.  Returns SUCCESS or FAIL depending on whether the
6228    specified grammar matched.  */
6229 static int
6230 parse_operands (char *str, const unsigned int *pattern, bfd_boolean thumb)
6231 {
6232   unsigned const int *upat = pattern;
6233   char *backtrack_pos = 0;
6234   const char *backtrack_error = 0;
6235   int i, val = 0, backtrack_index = 0;
6236   enum arm_reg_type rtype;
6237   parse_operand_result result;
6238   unsigned int op_parse_code;
6239
6240 #define po_char_or_fail(chr)                    \
6241   do                                            \
6242     {                                           \
6243       if (skip_past_char (&str, chr) == FAIL)   \
6244         goto bad_args;                          \
6245     }                                           \
6246   while (0)
6247
6248 #define po_reg_or_fail(regtype)                                 \
6249   do                                                            \
6250     {                                                           \
6251       val = arm_typed_reg_parse (& str, regtype, & rtype,       \
6252                                  & inst.operands[i].vectype);   \
6253       if (val == FAIL)                                          \
6254         {                                                       \
6255           first_error (_(reg_expected_msgs[regtype]));          \
6256           goto failure;                                         \
6257         }                                                       \
6258       inst.operands[i].reg = val;                               \
6259       inst.operands[i].isreg = 1;                               \
6260       inst.operands[i].isquad = (rtype == REG_TYPE_NQ);         \
6261       inst.operands[i].issingle = (rtype == REG_TYPE_VFS);      \
6262       inst.operands[i].isvec = (rtype == REG_TYPE_VFS           \
6263                              || rtype == REG_TYPE_VFD           \
6264                              || rtype == REG_TYPE_NQ);          \
6265     }                                                           \
6266   while (0)
6267
6268 #define po_reg_or_goto(regtype, label)                          \
6269   do                                                            \
6270     {                                                           \
6271       val = arm_typed_reg_parse (& str, regtype, & rtype,       \
6272                                  & inst.operands[i].vectype);   \
6273       if (val == FAIL)                                          \
6274         goto label;                                             \
6275                                                                 \
6276       inst.operands[i].reg = val;                               \
6277       inst.operands[i].isreg = 1;                               \
6278       inst.operands[i].isquad = (rtype == REG_TYPE_NQ);         \
6279       inst.operands[i].issingle = (rtype == REG_TYPE_VFS);      \
6280       inst.operands[i].isvec = (rtype == REG_TYPE_VFS           \
6281                              || rtype == REG_TYPE_VFD           \
6282                              || rtype == REG_TYPE_NQ);          \
6283     }                                                           \
6284   while (0)
6285
6286 #define po_imm_or_fail(min, max, popt)                          \
6287   do                                                            \
6288     {                                                           \
6289       if (parse_immediate (&str, &val, min, max, popt) == FAIL) \
6290         goto failure;                                           \
6291       inst.operands[i].imm = val;                               \
6292     }                                                           \
6293   while (0)
6294
6295 #define po_scalar_or_goto(elsz, label)                                  \
6296   do                                                                    \
6297     {                                                                   \
6298       val = parse_scalar (& str, elsz, & inst.operands[i].vectype);     \
6299       if (val == FAIL)                                                  \
6300         goto label;                                                     \
6301       inst.operands[i].reg = val;                                       \
6302       inst.operands[i].isscalar = 1;                                    \
6303     }                                                                   \
6304   while (0)
6305
6306 #define po_misc_or_fail(expr)                   \
6307   do                                            \
6308     {                                           \
6309       if (expr)                                 \
6310         goto failure;                           \
6311     }                                           \
6312   while (0)
6313
6314 #define po_misc_or_fail_no_backtrack(expr)              \
6315   do                                                    \
6316     {                                                   \
6317       result = expr;                                    \
6318       if (result == PARSE_OPERAND_FAIL_NO_BACKTRACK)    \
6319         backtrack_pos = 0;                              \
6320       if (result != PARSE_OPERAND_SUCCESS)              \
6321         goto failure;                                   \
6322     }                                                   \
6323   while (0)
6324
6325 #define po_barrier_or_imm(str)                             \
6326   do                                                       \
6327     {                                                      \
6328       val = parse_barrier (&str);                          \
6329       if (val == FAIL)                                     \
6330         {                                                  \
6331           if (ISALPHA (*str))                              \
6332               goto failure;                                \
6333           else                                             \
6334               goto immediate;                              \
6335         }                                                  \
6336       else                                                 \
6337         {                                                  \
6338           if ((inst.instruction & 0xf0) == 0x60            \
6339               && val != 0xf)                               \
6340             {                                              \
6341                /* ISB can only take SY as an option.  */   \
6342                inst.error = _("invalid barrier type");     \
6343                goto failure;                               \
6344             }                                              \
6345         }                                                  \
6346     }                                                      \
6347   while (0)
6348
6349   skip_whitespace (str);
6350
6351   for (i = 0; upat[i] != OP_stop; i++)
6352     {
6353       op_parse_code = upat[i];
6354       if (op_parse_code >= 1<<16)
6355         op_parse_code = thumb ? (op_parse_code >> 16)
6356                                 : (op_parse_code & ((1<<16)-1));
6357
6358       if (op_parse_code >= OP_FIRST_OPTIONAL)
6359         {
6360           /* Remember where we are in case we need to backtrack.  */
6361           gas_assert (!backtrack_pos);
6362           backtrack_pos = str;
6363           backtrack_error = inst.error;
6364           backtrack_index = i;
6365         }
6366
6367       if (i > 0 && (i > 1 || inst.operands[0].present))
6368         po_char_or_fail (',');
6369
6370       switch (op_parse_code)
6371         {
6372           /* Registers */
6373         case OP_oRRnpc:
6374         case OP_oRRnpcsp:
6375         case OP_RRnpc:
6376         case OP_RRnpcsp:
6377         case OP_oRR:
6378         case OP_RR:    po_reg_or_fail (REG_TYPE_RN);      break;
6379         case OP_RCP:   po_reg_or_fail (REG_TYPE_CP);      break;
6380         case OP_RCN:   po_reg_or_fail (REG_TYPE_CN);      break;
6381         case OP_RF:    po_reg_or_fail (REG_TYPE_FN);      break;
6382         case OP_RVS:   po_reg_or_fail (REG_TYPE_VFS);     break;
6383         case OP_RVD:   po_reg_or_fail (REG_TYPE_VFD);     break;
6384         case OP_oRND:
6385         case OP_RND:   po_reg_or_fail (REG_TYPE_VFD);     break;
6386         case OP_RVC:
6387           po_reg_or_goto (REG_TYPE_VFC, coproc_reg);
6388           break;
6389           /* Also accept generic coprocessor regs for unknown registers.  */
6390           coproc_reg:
6391           po_reg_or_fail (REG_TYPE_CN);
6392           break;
6393         case OP_RMF:   po_reg_or_fail (REG_TYPE_MVF);     break;
6394         case OP_RMD:   po_reg_or_fail (REG_TYPE_MVD);     break;
6395         case OP_RMFX:  po_reg_or_fail (REG_TYPE_MVFX);    break;
6396         case OP_RMDX:  po_reg_or_fail (REG_TYPE_MVDX);    break;
6397         case OP_RMAX:  po_reg_or_fail (REG_TYPE_MVAX);    break;
6398         case OP_RMDS:  po_reg_or_fail (REG_TYPE_DSPSC);   break;
6399         case OP_RIWR:  po_reg_or_fail (REG_TYPE_MMXWR);   break;
6400         case OP_RIWC:  po_reg_or_fail (REG_TYPE_MMXWC);   break;
6401         case OP_RIWG:  po_reg_or_fail (REG_TYPE_MMXWCG);  break;
6402         case OP_RXA:   po_reg_or_fail (REG_TYPE_XSCALE);  break;
6403         case OP_oRNQ:
6404         case OP_RNQ:   po_reg_or_fail (REG_TYPE_NQ);      break;
6405         case OP_oRNDQ:
6406         case OP_RNDQ:  po_reg_or_fail (REG_TYPE_NDQ);     break;
6407         case OP_RVSD:  po_reg_or_fail (REG_TYPE_VFSD);    break;
6408         case OP_oRNSDQ:
6409         case OP_RNSDQ: po_reg_or_fail (REG_TYPE_NSDQ);    break;
6410
6411         /* Neon scalar. Using an element size of 8 means that some invalid
6412            scalars are accepted here, so deal with those in later code.  */
6413         case OP_RNSC:  po_scalar_or_goto (8, failure);    break;
6414
6415         case OP_RNDQ_I0:
6416           {
6417             po_reg_or_goto (REG_TYPE_NDQ, try_imm0);
6418             break;
6419             try_imm0:
6420             po_imm_or_fail (0, 0, TRUE);
6421           }
6422           break;
6423
6424         case OP_RVSD_I0:
6425           po_reg_or_goto (REG_TYPE_VFSD, try_imm0);
6426           break;
6427
6428         case OP_RR_RNSC:
6429           {
6430             po_scalar_or_goto (8, try_rr);
6431             break;
6432             try_rr:
6433             po_reg_or_fail (REG_TYPE_RN);
6434           }
6435           break;
6436
6437         case OP_RNSDQ_RNSC:
6438           {
6439             po_scalar_or_goto (8, try_nsdq);
6440             break;
6441             try_nsdq:
6442             po_reg_or_fail (REG_TYPE_NSDQ);
6443           }
6444           break;
6445
6446         case OP_RNDQ_RNSC:
6447           {
6448             po_scalar_or_goto (8, try_ndq);
6449             break;
6450             try_ndq:
6451             po_reg_or_fail (REG_TYPE_NDQ);
6452           }
6453           break;
6454
6455         case OP_RND_RNSC:
6456           {
6457             po_scalar_or_goto (8, try_vfd);
6458             break;
6459             try_vfd:
6460             po_reg_or_fail (REG_TYPE_VFD);
6461           }
6462           break;
6463
6464         case OP_VMOV:
6465           /* WARNING: parse_neon_mov can move the operand counter, i. If we're
6466              not careful then bad things might happen.  */
6467           po_misc_or_fail (parse_neon_mov (&str, &i) == FAIL);
6468           break;
6469
6470         case OP_RNDQ_Ibig:
6471           {
6472             po_reg_or_goto (REG_TYPE_NDQ, try_immbig);
6473             break;
6474             try_immbig:
6475             /* There's a possibility of getting a 64-bit immediate here, so
6476                we need special handling.  */
6477             if (parse_big_immediate (&str, i) == FAIL)
6478               {
6479                 inst.error = _("immediate value is out of range");
6480                 goto failure;
6481               }
6482           }
6483           break;
6484
6485         case OP_RNDQ_I63b:
6486           {
6487             po_reg_or_goto (REG_TYPE_NDQ, try_shimm);
6488             break;
6489             try_shimm:
6490             po_imm_or_fail (0, 63, TRUE);
6491           }
6492           break;
6493
6494         case OP_RRnpcb:
6495           po_char_or_fail ('[');
6496           po_reg_or_fail  (REG_TYPE_RN);
6497           po_char_or_fail (']');
6498           break;
6499
6500         case OP_RRnpctw:
6501         case OP_RRw:
6502         case OP_oRRw:
6503           po_reg_or_fail (REG_TYPE_RN);
6504           if (skip_past_char (&str, '!') == SUCCESS)
6505             inst.operands[i].writeback = 1;
6506           break;
6507
6508           /* Immediates */
6509         case OP_I7:      po_imm_or_fail (  0,      7, FALSE);   break;
6510         case OP_I15:     po_imm_or_fail (  0,     15, FALSE);   break;
6511         case OP_I16:     po_imm_or_fail (  1,     16, FALSE);   break;
6512         case OP_I16z:    po_imm_or_fail (  0,     16, FALSE);   break;
6513         case OP_I31:     po_imm_or_fail (  0,     31, FALSE);   break;
6514         case OP_I32:     po_imm_or_fail (  1,     32, FALSE);   break;
6515         case OP_I32z:    po_imm_or_fail (  0,     32, FALSE);   break;
6516         case OP_I63s:    po_imm_or_fail (-64,     63, FALSE);   break;
6517         case OP_I63:     po_imm_or_fail (  0,     63, FALSE);   break;
6518         case OP_I64:     po_imm_or_fail (  1,     64, FALSE);   break;
6519         case OP_I64z:    po_imm_or_fail (  0,     64, FALSE);   break;
6520         case OP_I255:    po_imm_or_fail (  0,    255, FALSE);   break;
6521
6522         case OP_I4b:     po_imm_or_fail (  1,      4, TRUE);    break;
6523         case OP_oI7b:
6524         case OP_I7b:     po_imm_or_fail (  0,      7, TRUE);    break;
6525         case OP_I15b:    po_imm_or_fail (  0,     15, TRUE);    break;
6526         case OP_oI31b:
6527         case OP_I31b:    po_imm_or_fail (  0,     31, TRUE);    break;
6528         case OP_oI32b:   po_imm_or_fail (  1,     32, TRUE);    break;
6529         case OP_oI32z:   po_imm_or_fail (  0,     32, TRUE);    break;
6530         case OP_oIffffb: po_imm_or_fail (  0, 0xffff, TRUE);    break;
6531
6532           /* Immediate variants */
6533         case OP_oI255c:
6534           po_char_or_fail ('{');
6535           po_imm_or_fail (0, 255, TRUE);
6536           po_char_or_fail ('}');
6537           break;
6538
6539         case OP_I31w:
6540           /* The expression parser chokes on a trailing !, so we have
6541              to find it first and zap it.  */
6542           {
6543             char *s = str;
6544             while (*s && *s != ',')
6545               s++;
6546             if (s[-1] == '!')
6547               {
6548                 s[-1] = '\0';
6549                 inst.operands[i].writeback = 1;
6550               }
6551             po_imm_or_fail (0, 31, TRUE);
6552             if (str == s - 1)
6553               str = s;
6554           }
6555           break;
6556
6557           /* Expressions */
6558         case OP_EXPi:   EXPi:
6559           po_misc_or_fail (my_get_expression (&inst.reloc.exp, &str,
6560                                               GE_OPT_PREFIX));
6561           break;
6562
6563         case OP_EXP:
6564           po_misc_or_fail (my_get_expression (&inst.reloc.exp, &str,
6565                                               GE_NO_PREFIX));
6566           break;
6567
6568         case OP_EXPr:   EXPr:
6569           po_misc_or_fail (my_get_expression (&inst.reloc.exp, &str,
6570                                               GE_NO_PREFIX));
6571           if (inst.reloc.exp.X_op == O_symbol)
6572             {
6573               val = parse_reloc (&str);
6574               if (val == -1)
6575                 {
6576                   inst.error = _("unrecognized relocation suffix");
6577                   goto failure;
6578                 }
6579               else if (val != BFD_RELOC_UNUSED)
6580                 {
6581                   inst.operands[i].imm = val;
6582                   inst.operands[i].hasreloc = 1;
6583                 }
6584             }
6585           break;
6586
6587           /* Operand for MOVW or MOVT.  */
6588         case OP_HALF:
6589           po_misc_or_fail (parse_half (&str));
6590           break;
6591
6592           /* Register or expression.  */
6593         case OP_RR_EXr:   po_reg_or_goto (REG_TYPE_RN, EXPr); break;
6594         case OP_RR_EXi:   po_reg_or_goto (REG_TYPE_RN, EXPi); break;
6595
6596           /* Register or immediate.  */
6597         case OP_RRnpc_I0: po_reg_or_goto (REG_TYPE_RN, I0);   break;
6598         I0:               po_imm_or_fail (0, 0, FALSE);       break;
6599
6600         case OP_RF_IF:    po_reg_or_goto (REG_TYPE_FN, IF);   break;
6601         IF:
6602           if (!is_immediate_prefix (*str))
6603             goto bad_args;
6604           str++;
6605           val = parse_fpa_immediate (&str);
6606           if (val == FAIL)
6607             goto failure;
6608           /* FPA immediates are encoded as registers 8-15.
6609              parse_fpa_immediate has already applied the offset.  */
6610           inst.operands[i].reg = val;
6611           inst.operands[i].isreg = 1;
6612           break;
6613
6614         case OP_RIWR_I32z: po_reg_or_goto (REG_TYPE_MMXWR, I32z); break;
6615         I32z:             po_imm_or_fail (0, 32, FALSE);          break;
6616
6617           /* Two kinds of register.  */
6618         case OP_RIWR_RIWC:
6619           {
6620             struct reg_entry *rege = arm_reg_parse_multi (&str);
6621             if (!rege
6622                 || (rege->type != REG_TYPE_MMXWR
6623                     && rege->type != REG_TYPE_MMXWC
6624                     && rege->type != REG_TYPE_MMXWCG))
6625               {
6626                 inst.error = _("iWMMXt data or control register expected");
6627                 goto failure;
6628               }
6629             inst.operands[i].reg = rege->number;
6630             inst.operands[i].isreg = (rege->type == REG_TYPE_MMXWR);
6631           }
6632           break;
6633
6634         case OP_RIWC_RIWG:
6635           {
6636             struct reg_entry *rege = arm_reg_parse_multi (&str);
6637             if (!rege
6638                 || (rege->type != REG_TYPE_MMXWC
6639                     && rege->type != REG_TYPE_MMXWCG))
6640               {
6641                 inst.error = _("iWMMXt control register expected");
6642                 goto failure;
6643               }
6644             inst.operands[i].reg = rege->number;
6645             inst.operands[i].isreg = 1;
6646           }
6647           break;
6648
6649           /* Misc */
6650         case OP_CPSF:    val = parse_cps_flags (&str);          break;
6651         case OP_ENDI:    val = parse_endian_specifier (&str);   break;
6652         case OP_oROR:    val = parse_ror (&str);                break;
6653         case OP_COND:    val = parse_cond (&str);               break;
6654         case OP_oBARRIER_I15:
6655           po_barrier_or_imm (str); break;
6656           immediate:
6657           if (parse_immediate (&str, &val, 0, 15, TRUE) == FAIL)
6658             goto failure;
6659           break;
6660
6661         case OP_wPSR:
6662         case OP_rPSR:
6663           po_reg_or_goto (REG_TYPE_RNB, try_psr);
6664           if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_virt))
6665             {
6666               inst.error = _("Banked registers are not available with this "
6667                              "architecture.");
6668               goto failure;
6669             }
6670           break;
6671           try_psr:
6672           val = parse_psr (&str, op_parse_code == OP_wPSR);
6673           break;
6674
6675         case OP_APSR_RR:
6676           po_reg_or_goto (REG_TYPE_RN, try_apsr);
6677           break;
6678           try_apsr:
6679           /* Parse "APSR_nvzc" operand (for FMSTAT-equivalent MRS
6680              instruction).  */
6681           if (strncasecmp (str, "APSR_", 5) == 0)
6682             {
6683               unsigned found = 0;
6684               str += 5;
6685               while (found < 15)
6686                 switch (*str++)
6687                   {
6688                   case 'c': found = (found & 1) ? 16 : found | 1; break;
6689                   case 'n': found = (found & 2) ? 16 : found | 2; break;
6690                   case 'z': found = (found & 4) ? 16 : found | 4; break;
6691                   case 'v': found = (found & 8) ? 16 : found | 8; break;
6692                   default: found = 16;
6693                   }
6694               if (found != 15)
6695                 goto failure;
6696               inst.operands[i].isvec = 1;
6697               /* APSR_nzcv is encoded in instructions as if it were the REG_PC.  */
6698               inst.operands[i].reg = REG_PC;
6699             }
6700           else
6701             goto failure;
6702           break;
6703
6704         case OP_TB:
6705           po_misc_or_fail (parse_tb (&str));
6706           break;
6707
6708           /* Register lists.  */
6709         case OP_REGLST:
6710           val = parse_reg_list (&str);
6711           if (*str == '^')
6712             {
6713               inst.operands[1].writeback = 1;
6714               str++;
6715             }
6716           break;
6717
6718         case OP_VRSLST:
6719           val = parse_vfp_reg_list (&str, &inst.operands[i].reg, REGLIST_VFP_S);
6720           break;
6721
6722         case OP_VRDLST:
6723           val = parse_vfp_reg_list (&str, &inst.operands[i].reg, REGLIST_VFP_D);
6724           break;
6725
6726         case OP_VRSDLST:
6727           /* Allow Q registers too.  */
6728           val = parse_vfp_reg_list (&str, &inst.operands[i].reg,
6729                                     REGLIST_NEON_D);
6730           if (val == FAIL)
6731             {
6732               inst.error = NULL;
6733               val = parse_vfp_reg_list (&str, &inst.operands[i].reg,
6734                                         REGLIST_VFP_S);
6735               inst.operands[i].issingle = 1;
6736             }
6737           break;
6738
6739         case OP_NRDLST:
6740           val = parse_vfp_reg_list (&str, &inst.operands[i].reg,
6741                                     REGLIST_NEON_D);
6742           break;
6743
6744         case OP_NSTRLST:
6745           val = parse_neon_el_struct_list (&str, &inst.operands[i].reg,
6746                                            &inst.operands[i].vectype);
6747           break;
6748
6749           /* Addressing modes */
6750         case OP_ADDR:
6751           po_misc_or_fail (parse_address (&str, i));
6752           break;
6753
6754         case OP_ADDRGLDR:
6755           po_misc_or_fail_no_backtrack (
6756             parse_address_group_reloc (&str, i, GROUP_LDR));
6757           break;
6758
6759         case OP_ADDRGLDRS:
6760           po_misc_or_fail_no_backtrack (
6761             parse_address_group_reloc (&str, i, GROUP_LDRS));
6762           break;
6763
6764         case OP_ADDRGLDC:
6765           po_misc_or_fail_no_backtrack (
6766             parse_address_group_reloc (&str, i, GROUP_LDC));
6767           break;
6768
6769         case OP_SH:
6770           po_misc_or_fail (parse_shifter_operand (&str, i));
6771           break;
6772
6773         case OP_SHG:
6774           po_misc_or_fail_no_backtrack (
6775             parse_shifter_operand_group_reloc (&str, i));
6776           break;
6777
6778         case OP_oSHll:
6779           po_misc_or_fail (parse_shift (&str, i, SHIFT_LSL_IMMEDIATE));
6780           break;
6781
6782         case OP_oSHar:
6783           po_misc_or_fail (parse_shift (&str, i, SHIFT_ASR_IMMEDIATE));
6784           break;
6785
6786         case OP_oSHllar:
6787           po_misc_or_fail (parse_shift (&str, i, SHIFT_LSL_OR_ASR_IMMEDIATE));
6788           break;
6789
6790         default:
6791           as_fatal (_("unhandled operand code %d"), op_parse_code);
6792         }
6793
6794       /* Various value-based sanity checks and shared operations.  We
6795          do not signal immediate failures for the register constraints;
6796          this allows a syntax error to take precedence.  */
6797       switch (op_parse_code)
6798         {
6799         case OP_oRRnpc:
6800         case OP_RRnpc:
6801         case OP_RRnpcb:
6802         case OP_RRw:
6803         case OP_oRRw:
6804         case OP_RRnpc_I0:
6805           if (inst.operands[i].isreg && inst.operands[i].reg == REG_PC)
6806             inst.error = BAD_PC;
6807           break;
6808
6809         case OP_oRRnpcsp:
6810         case OP_RRnpcsp:
6811           if (inst.operands[i].isreg)
6812             {
6813               if (inst.operands[i].reg == REG_PC)
6814                 inst.error = BAD_PC;
6815               else if (inst.operands[i].reg == REG_SP)
6816                 inst.error = BAD_SP;
6817             }
6818           break;
6819
6820         case OP_RRnpctw:
6821           if (inst.operands[i].isreg
6822               && inst.operands[i].reg == REG_PC
6823               && (inst.operands[i].writeback || thumb))
6824             inst.error = BAD_PC;
6825           break;
6826
6827         case OP_CPSF:
6828         case OP_ENDI:
6829         case OP_oROR:
6830         case OP_wPSR:
6831         case OP_rPSR:
6832         case OP_COND:
6833         case OP_oBARRIER_I15:
6834         case OP_REGLST:
6835         case OP_VRSLST:
6836         case OP_VRDLST:
6837         case OP_VRSDLST:
6838         case OP_NRDLST:
6839         case OP_NSTRLST:
6840           if (val == FAIL)
6841             goto failure;
6842           inst.operands[i].imm = val;
6843           break;
6844
6845         default:
6846           break;
6847         }
6848
6849       /* If we get here, this operand was successfully parsed.  */
6850       inst.operands[i].present = 1;
6851       continue;
6852
6853     bad_args:
6854       inst.error = BAD_ARGS;
6855
6856     failure:
6857       if (!backtrack_pos)
6858         {
6859           /* The parse routine should already have set inst.error, but set a
6860              default here just in case.  */
6861           if (!inst.error)
6862             inst.error = _("syntax error");
6863           return FAIL;
6864         }
6865
6866       /* Do not backtrack over a trailing optional argument that
6867          absorbed some text.  We will only fail again, with the
6868          'garbage following instruction' error message, which is
6869          probably less helpful than the current one.  */
6870       if (backtrack_index == i && backtrack_pos != str
6871           && upat[i+1] == OP_stop)
6872         {
6873           if (!inst.error)
6874             inst.error = _("syntax error");
6875           return FAIL;
6876         }
6877
6878       /* Try again, skipping the optional argument at backtrack_pos.  */
6879       str = backtrack_pos;
6880       inst.error = backtrack_error;
6881       inst.operands[backtrack_index].present = 0;
6882       i = backtrack_index;
6883       backtrack_pos = 0;
6884     }
6885
6886   /* Check that we have parsed all the arguments.  */
6887   if (*str != '\0' && !inst.error)
6888     inst.error = _("garbage following instruction");
6889
6890   return inst.error ? FAIL : SUCCESS;
6891 }
6892
6893 #undef po_char_or_fail
6894 #undef po_reg_or_fail
6895 #undef po_reg_or_goto
6896 #undef po_imm_or_fail
6897 #undef po_scalar_or_fail
6898 #undef po_barrier_or_imm
6899
6900 /* Shorthand macro for instruction encoding functions issuing errors.  */
6901 #define constraint(expr, err)                   \
6902   do                                            \
6903     {                                           \
6904       if (expr)                                 \
6905         {                                       \
6906           inst.error = err;                     \
6907           return;                               \
6908         }                                       \
6909     }                                           \
6910   while (0)
6911
6912 /* Reject "bad registers" for Thumb-2 instructions.  Many Thumb-2
6913    instructions are unpredictable if these registers are used.  This
6914    is the BadReg predicate in ARM's Thumb-2 documentation.  */
6915 #define reject_bad_reg(reg)                             \
6916   do                                                    \
6917    if (reg == REG_SP || reg == REG_PC)                  \
6918      {                                                  \
6919        inst.error = (reg == REG_SP) ? BAD_SP : BAD_PC;  \
6920        return;                                          \
6921      }                                                  \
6922   while (0)
6923
6924 /* If REG is R13 (the stack pointer), warn that its use is
6925    deprecated.  */
6926 #define warn_deprecated_sp(reg)                 \
6927   do                                            \
6928     if (warn_on_deprecated && reg == REG_SP)    \
6929        as_warn (_("use of r13 is deprecated")); \
6930   while (0)
6931
6932 /* Functions for operand encoding.  ARM, then Thumb.  */
6933
6934 #define rotate_left(v, n) (v << n | v >> (32 - n))
6935
6936 /* If VAL can be encoded in the immediate field of an ARM instruction,
6937    return the encoded form.  Otherwise, return FAIL.  */
6938
6939 static unsigned int
6940 encode_arm_immediate (unsigned int val)
6941 {
6942   unsigned int a, i;
6943
6944   for (i = 0; i < 32; i += 2)
6945     if ((a = rotate_left (val, i)) <= 0xff)
6946       return a | (i << 7); /* 12-bit pack: [shift-cnt,const].  */
6947
6948   return FAIL;
6949 }
6950
6951 /* If VAL can be encoded in the immediate field of a Thumb32 instruction,
6952    return the encoded form.  Otherwise, return FAIL.  */
6953 static unsigned int
6954 encode_thumb32_immediate (unsigned int val)
6955 {
6956   unsigned int a, i;
6957
6958   if (val <= 0xff)
6959     return val;
6960
6961   for (i = 1; i <= 24; i++)
6962     {
6963       a = val >> i;
6964       if ((val & ~(0xff << i)) == 0)
6965         return ((val >> i) & 0x7f) | ((32 - i) << 7);
6966     }
6967
6968   a = val & 0xff;
6969   if (val == ((a << 16) | a))
6970     return 0x100 | a;
6971   if (val == ((a << 24) | (a << 16) | (a << 8) | a))
6972     return 0x300 | a;
6973
6974   a = val & 0xff00;
6975   if (val == ((a << 16) | a))
6976     return 0x200 | (a >> 8);
6977
6978   return FAIL;
6979 }
6980 /* Encode a VFP SP or DP register number into inst.instruction.  */
6981
6982 static void
6983 encode_arm_vfp_reg (int reg, enum vfp_reg_pos pos)
6984 {
6985   if ((pos == VFP_REG_Dd || pos == VFP_REG_Dn || pos == VFP_REG_Dm)
6986       && reg > 15)
6987     {
6988       if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_d32))
6989         {
6990           if (thumb_mode)
6991             ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
6992                                     fpu_vfp_ext_d32);
6993           else
6994             ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used,
6995                                     fpu_vfp_ext_d32);
6996         }
6997       else
6998         {
6999           first_error (_("D register out of range for selected VFP version"));
7000           return;
7001         }
7002     }
7003
7004   switch (pos)
7005     {
7006     case VFP_REG_Sd:
7007       inst.instruction |= ((reg >> 1) << 12) | ((reg & 1) << 22);
7008       break;
7009
7010     case VFP_REG_Sn:
7011       inst.instruction |= ((reg >> 1) << 16) | ((reg & 1) << 7);
7012       break;
7013
7014     case VFP_REG_Sm:
7015       inst.instruction |= ((reg >> 1) << 0) | ((reg & 1) << 5);
7016       break;
7017
7018     case VFP_REG_Dd:
7019       inst.instruction |= ((reg & 15) << 12) | ((reg >> 4) << 22);
7020       break;
7021
7022     case VFP_REG_Dn:
7023       inst.instruction |= ((reg & 15) << 16) | ((reg >> 4) << 7);
7024       break;
7025
7026     case VFP_REG_Dm:
7027       inst.instruction |= (reg & 15) | ((reg >> 4) << 5);
7028       break;
7029
7030     default:
7031       abort ();
7032     }
7033 }
7034
7035 /* Encode a <shift> in an ARM-format instruction.  The immediate,
7036    if any, is handled by md_apply_fix.   */
7037 static void
7038 encode_arm_shift (int i)
7039 {
7040   if (inst.operands[i].shift_kind == SHIFT_RRX)
7041     inst.instruction |= SHIFT_ROR << 5;
7042   else
7043     {
7044       inst.instruction |= inst.operands[i].shift_kind << 5;
7045       if (inst.operands[i].immisreg)
7046         {
7047           inst.instruction |= SHIFT_BY_REG;
7048           inst.instruction |= inst.operands[i].imm << 8;
7049         }
7050       else
7051         inst.reloc.type = BFD_RELOC_ARM_SHIFT_IMM;
7052     }
7053 }
7054
7055 static void
7056 encode_arm_shifter_operand (int i)
7057 {
7058   if (inst.operands[i].isreg)
7059     {
7060       inst.instruction |= inst.operands[i].reg;
7061       encode_arm_shift (i);
7062     }
7063   else
7064     {
7065       inst.instruction |= INST_IMMEDIATE;
7066       if (inst.reloc.type != BFD_RELOC_ARM_IMMEDIATE)
7067         inst.instruction |= inst.operands[i].imm;
7068     }
7069 }
7070
7071 /* Subroutine of encode_arm_addr_mode_2 and encode_arm_addr_mode_3.  */
7072 static void
7073 encode_arm_addr_mode_common (int i, bfd_boolean is_t)
7074 {
7075   /* PR 14260:
7076      Generate an error if the operand is not a register.  */
7077   constraint (!inst.operands[i].isreg,
7078               _("Instruction does not support =N addresses"));
7079
7080   inst.instruction |= inst.operands[i].reg << 16;
7081
7082   if (inst.operands[i].preind)
7083     {
7084       if (is_t)
7085         {
7086           inst.error = _("instruction does not accept preindexed addressing");
7087           return;
7088         }
7089       inst.instruction |= PRE_INDEX;
7090       if (inst.operands[i].writeback)
7091         inst.instruction |= WRITE_BACK;
7092
7093     }
7094   else if (inst.operands[i].postind)
7095     {
7096       gas_assert (inst.operands[i].writeback);
7097       if (is_t)
7098         inst.instruction |= WRITE_BACK;
7099     }
7100   else /* unindexed - only for coprocessor */
7101     {
7102       inst.error = _("instruction does not accept unindexed addressing");
7103       return;
7104     }
7105
7106   if (((inst.instruction & WRITE_BACK) || !(inst.instruction & PRE_INDEX))
7107       && (((inst.instruction & 0x000f0000) >> 16)
7108           == ((inst.instruction & 0x0000f000) >> 12)))
7109     as_warn ((inst.instruction & LOAD_BIT)
7110              ? _("destination register same as write-back base")
7111              : _("source register same as write-back base"));
7112 }
7113
7114 /* inst.operands[i] was set up by parse_address.  Encode it into an
7115    ARM-format mode 2 load or store instruction.  If is_t is true,
7116    reject forms that cannot be used with a T instruction (i.e. not
7117    post-indexed).  */
7118 static void
7119 encode_arm_addr_mode_2 (int i, bfd_boolean is_t)
7120 {
7121   const bfd_boolean is_pc = (inst.operands[i].reg == REG_PC);
7122
7123   encode_arm_addr_mode_common (i, is_t);
7124
7125   if (inst.operands[i].immisreg)
7126     {
7127       constraint ((inst.operands[i].imm == REG_PC
7128                    || (is_pc && inst.operands[i].writeback)),
7129                   BAD_PC_ADDRESSING);
7130       inst.instruction |= INST_IMMEDIATE;  /* yes, this is backwards */
7131       inst.instruction |= inst.operands[i].imm;
7132       if (!inst.operands[i].negative)
7133         inst.instruction |= INDEX_UP;
7134       if (inst.operands[i].shifted)
7135         {
7136           if (inst.operands[i].shift_kind == SHIFT_RRX)
7137             inst.instruction |= SHIFT_ROR << 5;
7138           else
7139             {
7140               inst.instruction |= inst.operands[i].shift_kind << 5;
7141               inst.reloc.type = BFD_RELOC_ARM_SHIFT_IMM;
7142             }
7143         }
7144     }
7145   else /* immediate offset in inst.reloc */
7146     {
7147       if (is_pc && !inst.reloc.pc_rel)
7148         {
7149           const bfd_boolean is_load = ((inst.instruction & LOAD_BIT) != 0);
7150
7151           /* If is_t is TRUE, it's called from do_ldstt.  ldrt/strt
7152              cannot use PC in addressing.
7153              PC cannot be used in writeback addressing, either.  */
7154           constraint ((is_t || inst.operands[i].writeback),
7155                       BAD_PC_ADDRESSING);
7156
7157           /* Use of PC in str is deprecated for ARMv7.  */
7158           if (warn_on_deprecated
7159               && !is_load
7160               && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v7))
7161             as_warn (_("use of PC in this instruction is deprecated"));
7162         }
7163
7164       if (inst.reloc.type == BFD_RELOC_UNUSED)
7165         {
7166           /* Prefer + for zero encoded value.  */
7167           if (!inst.operands[i].negative)
7168             inst.instruction |= INDEX_UP;
7169           inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
7170         }
7171     }
7172 }
7173
7174 /* inst.operands[i] was set up by parse_address.  Encode it into an
7175    ARM-format mode 3 load or store instruction.  Reject forms that
7176    cannot be used with such instructions.  If is_t is true, reject
7177    forms that cannot be used with a T instruction (i.e. not
7178    post-indexed).  */
7179 static void
7180 encode_arm_addr_mode_3 (int i, bfd_boolean is_t)
7181 {
7182   if (inst.operands[i].immisreg && inst.operands[i].shifted)
7183     {
7184       inst.error = _("instruction does not accept scaled register index");
7185       return;
7186     }
7187
7188   encode_arm_addr_mode_common (i, is_t);
7189
7190   if (inst.operands[i].immisreg)
7191     {
7192       constraint ((inst.operands[i].imm == REG_PC
7193                    || inst.operands[i].reg == REG_PC),
7194                   BAD_PC_ADDRESSING);
7195       inst.instruction |= inst.operands[i].imm;
7196       if (!inst.operands[i].negative)
7197         inst.instruction |= INDEX_UP;
7198     }
7199   else /* immediate offset in inst.reloc */
7200     {
7201       constraint ((inst.operands[i].reg == REG_PC && !inst.reloc.pc_rel
7202                    && inst.operands[i].writeback),
7203                   BAD_PC_WRITEBACK);
7204       inst.instruction |= HWOFFSET_IMM;
7205       if (inst.reloc.type == BFD_RELOC_UNUSED)
7206         {
7207           /* Prefer + for zero encoded value.  */
7208           if (!inst.operands[i].negative)
7209             inst.instruction |= INDEX_UP;
7210
7211           inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
7212         }
7213     }
7214 }
7215
7216 /* inst.operands[i] was set up by parse_address.  Encode it into an
7217    ARM-format instruction.  Reject all forms which cannot be encoded
7218    into a coprocessor load/store instruction.  If wb_ok is false,
7219    reject use of writeback; if unind_ok is false, reject use of
7220    unindexed addressing.  If reloc_override is not 0, use it instead
7221    of BFD_ARM_CP_OFF_IMM, unless the initial relocation is a group one
7222    (in which case it is preserved).  */
7223
7224 static int
7225 encode_arm_cp_address (int i, int wb_ok, int unind_ok, int reloc_override)
7226 {
7227   inst.instruction |= inst.operands[i].reg << 16;
7228
7229   gas_assert (!(inst.operands[i].preind && inst.operands[i].postind));
7230
7231   if (!inst.operands[i].preind && !inst.operands[i].postind) /* unindexed */
7232     {
7233       gas_assert (!inst.operands[i].writeback);
7234       if (!unind_ok)
7235         {
7236           inst.error = _("instruction does not support unindexed addressing");
7237           return FAIL;
7238         }
7239       inst.instruction |= inst.operands[i].imm;
7240       inst.instruction |= INDEX_UP;
7241       return SUCCESS;
7242     }
7243
7244   if (inst.operands[i].preind)
7245     inst.instruction |= PRE_INDEX;
7246
7247   if (inst.operands[i].writeback)
7248     {
7249       if (inst.operands[i].reg == REG_PC)
7250         {
7251           inst.error = _("pc may not be used with write-back");
7252           return FAIL;
7253         }
7254       if (!wb_ok)
7255         {
7256           inst.error = _("instruction does not support writeback");
7257           return FAIL;
7258         }
7259       inst.instruction |= WRITE_BACK;
7260     }
7261
7262   if (reloc_override)
7263     inst.reloc.type = (bfd_reloc_code_real_type) reloc_override;
7264   else if ((inst.reloc.type < BFD_RELOC_ARM_ALU_PC_G0_NC
7265             || inst.reloc.type > BFD_RELOC_ARM_LDC_SB_G2)
7266            && inst.reloc.type != BFD_RELOC_ARM_LDR_PC_G0)
7267     {
7268       if (thumb_mode)
7269         inst.reloc.type = BFD_RELOC_ARM_T32_CP_OFF_IMM;
7270       else
7271         inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM;
7272     }
7273
7274   /* Prefer + for zero encoded value.  */
7275   if (!inst.operands[i].negative)
7276     inst.instruction |= INDEX_UP;
7277
7278   return SUCCESS;
7279 }
7280
7281 /* inst.reloc.exp describes an "=expr" load pseudo-operation.
7282    Determine whether it can be performed with a move instruction; if
7283    it can, convert inst.instruction to that move instruction and
7284    return TRUE; if it can't, convert inst.instruction to a literal-pool
7285    load and return FALSE.  If this is not a valid thing to do in the
7286    current context, set inst.error and return TRUE.
7287
7288    inst.operands[i] describes the destination register.  */
7289
7290 static bfd_boolean
7291 move_or_literal_pool (int i, bfd_boolean thumb_p, bfd_boolean mode_3)
7292 {
7293   unsigned long tbit;
7294
7295   if (thumb_p)
7296     tbit = (inst.instruction > 0xffff) ? THUMB2_LOAD_BIT : THUMB_LOAD_BIT;
7297   else
7298     tbit = LOAD_BIT;
7299
7300   if ((inst.instruction & tbit) == 0)
7301     {
7302       inst.error = _("invalid pseudo operation");
7303       return TRUE;
7304     }
7305   if (inst.reloc.exp.X_op != O_constant && inst.reloc.exp.X_op != O_symbol)
7306     {
7307       inst.error = _("constant expression expected");
7308       return TRUE;
7309     }
7310   if (inst.reloc.exp.X_op == O_constant)
7311     {
7312       if (thumb_p)
7313         {
7314           if (!unified_syntax && (inst.reloc.exp.X_add_number & ~0xFF) == 0)
7315             {
7316               /* This can be done with a mov(1) instruction.  */
7317               inst.instruction  = T_OPCODE_MOV_I8 | (inst.operands[i].reg << 8);
7318               inst.instruction |= inst.reloc.exp.X_add_number;
7319               return TRUE;
7320             }
7321         }
7322       else
7323         {
7324           int value = encode_arm_immediate (inst.reloc.exp.X_add_number);
7325           if (value != FAIL)
7326             {
7327               /* This can be done with a mov instruction.  */
7328               inst.instruction &= LITERAL_MASK;
7329               inst.instruction |= INST_IMMEDIATE | (OPCODE_MOV << DATA_OP_SHIFT);
7330               inst.instruction |= value & 0xfff;
7331               return TRUE;
7332             }
7333
7334           value = encode_arm_immediate (~inst.reloc.exp.X_add_number);
7335           if (value != FAIL)
7336             {
7337               /* This can be done with a mvn instruction.  */
7338               inst.instruction &= LITERAL_MASK;
7339               inst.instruction |= INST_IMMEDIATE | (OPCODE_MVN << DATA_OP_SHIFT);
7340               inst.instruction |= value & 0xfff;
7341               return TRUE;
7342             }
7343         }
7344     }
7345
7346   if (add_to_lit_pool () == FAIL)
7347     {
7348       inst.error = _("literal pool insertion failed");
7349       return TRUE;
7350     }
7351   inst.operands[1].reg = REG_PC;
7352   inst.operands[1].isreg = 1;
7353   inst.operands[1].preind = 1;
7354   inst.reloc.pc_rel = 1;
7355   inst.reloc.type = (thumb_p
7356                      ? BFD_RELOC_ARM_THUMB_OFFSET
7357                      : (mode_3
7358                         ? BFD_RELOC_ARM_HWLITERAL
7359                         : BFD_RELOC_ARM_LITERAL));
7360   return FALSE;
7361 }
7362
7363 /* Functions for instruction encoding, sorted by sub-architecture.
7364    First some generics; their names are taken from the conventional
7365    bit positions for register arguments in ARM format instructions.  */
7366
7367 static void
7368 do_noargs (void)
7369 {
7370 }
7371
7372 static void
7373 do_rd (void)
7374 {
7375   inst.instruction |= inst.operands[0].reg << 12;
7376 }
7377
7378 static void
7379 do_rd_rm (void)
7380 {
7381   inst.instruction |= inst.operands[0].reg << 12;
7382   inst.instruction |= inst.operands[1].reg;
7383 }
7384
7385 static void
7386 do_rm_rn (void)
7387 {
7388   inst.instruction |= inst.operands[0].reg;
7389   inst.instruction |= inst.operands[1].reg << 16;
7390 }
7391
7392 static void
7393 do_rd_rn (void)
7394 {
7395   inst.instruction |= inst.operands[0].reg << 12;
7396   inst.instruction |= inst.operands[1].reg << 16;
7397 }
7398
7399 static void
7400 do_rn_rd (void)
7401 {
7402   inst.instruction |= inst.operands[0].reg << 16;
7403   inst.instruction |= inst.operands[1].reg << 12;
7404 }
7405
7406 static bfd_boolean
7407 check_obsolete (const arm_feature_set *feature, const char *msg)
7408 {
7409   if (ARM_CPU_IS_ANY (cpu_variant))
7410     {
7411       as_warn ("%s", msg);
7412       return TRUE;
7413     }
7414   else if (ARM_CPU_HAS_FEATURE (cpu_variant, *feature))
7415     {
7416       as_bad ("%s", msg);
7417       return TRUE;
7418     }
7419
7420   return FALSE;
7421 }
7422
7423 static void
7424 do_rd_rm_rn (void)
7425 {
7426   unsigned Rn = inst.operands[2].reg;
7427   /* Enforce restrictions on SWP instruction.  */
7428   if ((inst.instruction & 0x0fbfffff) == 0x01000090)
7429     {
7430       constraint (Rn == inst.operands[0].reg || Rn == inst.operands[1].reg,
7431                   _("Rn must not overlap other operands"));
7432
7433       /* SWP{b} is obsolete for ARMv8-A, and deprecated for ARMv6* and ARMv7.
7434        */
7435       if (!check_obsolete (&arm_ext_v8,
7436                            _("swp{b} use is obsoleted for ARMv8 and later"))
7437           && warn_on_deprecated
7438           && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6))
7439         as_warn (_("swp{b} use is deprecated for ARMv6 and ARMv7"));
7440     }
7441
7442   inst.instruction |= inst.operands[0].reg << 12;
7443   inst.instruction |= inst.operands[1].reg;
7444   inst.instruction |= Rn << 16;
7445 }
7446
7447 static void
7448 do_rd_rn_rm (void)
7449 {
7450   inst.instruction |= inst.operands[0].reg << 12;
7451   inst.instruction |= inst.operands[1].reg << 16;
7452   inst.instruction |= inst.operands[2].reg;
7453 }
7454
7455 static void
7456 do_rm_rd_rn (void)
7457 {
7458   constraint ((inst.operands[2].reg == REG_PC), BAD_PC);
7459   constraint (((inst.reloc.exp.X_op != O_constant
7460                 && inst.reloc.exp.X_op != O_illegal)
7461                || inst.reloc.exp.X_add_number != 0),
7462               BAD_ADDR_MODE);
7463   inst.instruction |= inst.operands[0].reg;
7464   inst.instruction |= inst.operands[1].reg << 12;
7465   inst.instruction |= inst.operands[2].reg << 16;
7466 }
7467
7468 static void
7469 do_imm0 (void)
7470 {
7471   inst.instruction |= inst.operands[0].imm;
7472 }
7473
7474 static void
7475 do_rd_cpaddr (void)
7476 {
7477   inst.instruction |= inst.operands[0].reg << 12;
7478   encode_arm_cp_address (1, TRUE, TRUE, 0);
7479 }
7480
7481 /* ARM instructions, in alphabetical order by function name (except
7482    that wrapper functions appear immediately after the function they
7483    wrap).  */
7484
7485 /* This is a pseudo-op of the form "adr rd, label" to be converted
7486    into a relative address of the form "add rd, pc, #label-.-8".  */
7487
7488 static void
7489 do_adr (void)
7490 {
7491   inst.instruction |= (inst.operands[0].reg << 12);  /* Rd */
7492
7493   /* Frag hacking will turn this into a sub instruction if the offset turns
7494      out to be negative.  */
7495   inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
7496   inst.reloc.pc_rel = 1;
7497   inst.reloc.exp.X_add_number -= 8;
7498 }
7499
7500 /* This is a pseudo-op of the form "adrl rd, label" to be converted
7501    into a relative address of the form:
7502    add rd, pc, #low(label-.-8)"
7503    add rd, rd, #high(label-.-8)"  */
7504
7505 static void
7506 do_adrl (void)
7507 {
7508   inst.instruction |= (inst.operands[0].reg << 12);  /* Rd */
7509
7510   /* Frag hacking will turn this into a sub instruction if the offset turns
7511      out to be negative.  */
7512   inst.reloc.type              = BFD_RELOC_ARM_ADRL_IMMEDIATE;
7513   inst.reloc.pc_rel            = 1;
7514   inst.size                    = INSN_SIZE * 2;
7515   inst.reloc.exp.X_add_number -= 8;
7516 }
7517
7518 static void
7519 do_arit (void)
7520 {
7521   if (!inst.operands[1].present)
7522     inst.operands[1].reg = inst.operands[0].reg;
7523   inst.instruction |= inst.operands[0].reg << 12;
7524   inst.instruction |= inst.operands[1].reg << 16;
7525   encode_arm_shifter_operand (2);
7526 }
7527
7528 static void
7529 do_barrier (void)
7530 {
7531   if (inst.operands[0].present)
7532     {
7533       constraint ((inst.instruction & 0xf0) != 0x40
7534                   && inst.operands[0].imm > 0xf
7535                   && inst.operands[0].imm < 0x0,
7536                   _("bad barrier type"));
7537       inst.instruction |= inst.operands[0].imm;
7538     }
7539   else
7540     inst.instruction |= 0xf;
7541 }
7542
7543 static void
7544 do_bfc (void)
7545 {
7546   unsigned int msb = inst.operands[1].imm + inst.operands[2].imm;
7547   constraint (msb > 32, _("bit-field extends past end of register"));
7548   /* The instruction encoding stores the LSB and MSB,
7549      not the LSB and width.  */
7550   inst.instruction |= inst.operands[0].reg << 12;
7551   inst.instruction |= inst.operands[1].imm << 7;
7552   inst.instruction |= (msb - 1) << 16;
7553 }
7554
7555 static void
7556 do_bfi (void)
7557 {
7558   unsigned int msb;
7559
7560   /* #0 in second position is alternative syntax for bfc, which is
7561      the same instruction but with REG_PC in the Rm field.  */
7562   if (!inst.operands[1].isreg)
7563     inst.operands[1].reg = REG_PC;
7564
7565   msb = inst.operands[2].imm + inst.operands[3].imm;
7566   constraint (msb > 32, _("bit-field extends past end of register"));
7567   /* The instruction encoding stores the LSB and MSB,
7568      not the LSB and width.  */
7569   inst.instruction |= inst.operands[0].reg << 12;
7570   inst.instruction |= inst.operands[1].reg;
7571   inst.instruction |= inst.operands[2].imm << 7;
7572   inst.instruction |= (msb - 1) << 16;
7573 }
7574
7575 static void
7576 do_bfx (void)
7577 {
7578   constraint (inst.operands[2].imm + inst.operands[3].imm > 32,
7579               _("bit-field extends past end of register"));
7580   inst.instruction |= inst.operands[0].reg << 12;
7581   inst.instruction |= inst.operands[1].reg;
7582   inst.instruction |= inst.operands[2].imm << 7;
7583   inst.instruction |= (inst.operands[3].imm - 1) << 16;
7584 }
7585
7586 /* ARM V5 breakpoint instruction (argument parse)
7587      BKPT <16 bit unsigned immediate>
7588      Instruction is not conditional.
7589         The bit pattern given in insns[] has the COND_ALWAYS condition,
7590         and it is an error if the caller tried to override that.  */
7591
7592 static void
7593 do_bkpt (void)
7594 {
7595   /* Top 12 of 16 bits to bits 19:8.  */
7596   inst.instruction |= (inst.operands[0].imm & 0xfff0) << 4;
7597
7598   /* Bottom 4 of 16 bits to bits 3:0.  */
7599   inst.instruction |= inst.operands[0].imm & 0xf;
7600 }
7601
7602 static void
7603 encode_branch (int default_reloc)
7604 {
7605   if (inst.operands[0].hasreloc)
7606     {
7607       constraint (inst.operands[0].imm != BFD_RELOC_ARM_PLT32
7608                   && inst.operands[0].imm != BFD_RELOC_ARM_TLS_CALL,
7609                   _("the only valid suffixes here are '(plt)' and '(tlscall)'"));
7610       inst.reloc.type = inst.operands[0].imm == BFD_RELOC_ARM_PLT32
7611         ? BFD_RELOC_ARM_PLT32
7612         : thumb_mode ? BFD_RELOC_ARM_THM_TLS_CALL : BFD_RELOC_ARM_TLS_CALL;
7613     }
7614   else
7615     inst.reloc.type = (bfd_reloc_code_real_type) default_reloc;
7616   inst.reloc.pc_rel = 1;
7617 }
7618
7619 static void
7620 do_branch (void)
7621 {
7622 #ifdef OBJ_ELF
7623   if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
7624     encode_branch (BFD_RELOC_ARM_PCREL_JUMP);
7625   else
7626 #endif
7627     encode_branch (BFD_RELOC_ARM_PCREL_BRANCH);
7628 }
7629
7630 static void
7631 do_bl (void)
7632 {
7633 #ifdef OBJ_ELF
7634   if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
7635     {
7636       if (inst.cond == COND_ALWAYS)
7637         encode_branch (BFD_RELOC_ARM_PCREL_CALL);
7638       else
7639         encode_branch (BFD_RELOC_ARM_PCREL_JUMP);
7640     }
7641   else
7642 #endif
7643     encode_branch (BFD_RELOC_ARM_PCREL_BRANCH);
7644 }
7645
7646 /* ARM V5 branch-link-exchange instruction (argument parse)
7647      BLX <target_addr>          ie BLX(1)
7648      BLX{<condition>} <Rm>      ie BLX(2)
7649    Unfortunately, there are two different opcodes for this mnemonic.
7650    So, the insns[].value is not used, and the code here zaps values
7651         into inst.instruction.
7652    Also, the <target_addr> can be 25 bits, hence has its own reloc.  */
7653
7654 static void
7655 do_blx (void)
7656 {
7657   if (inst.operands[0].isreg)
7658     {
7659       /* Arg is a register; the opcode provided by insns[] is correct.
7660          It is not illegal to do "blx pc", just useless.  */
7661       if (inst.operands[0].reg == REG_PC)
7662         as_tsktsk (_("use of r15 in blx in ARM mode is not really useful"));
7663
7664       inst.instruction |= inst.operands[0].reg;
7665     }
7666   else
7667     {
7668       /* Arg is an address; this instruction cannot be executed
7669          conditionally, and the opcode must be adjusted.
7670          We retain the BFD_RELOC_ARM_PCREL_BLX till the very end
7671          where we generate out a BFD_RELOC_ARM_PCREL_CALL instead.  */
7672       constraint (inst.cond != COND_ALWAYS, BAD_COND);
7673       inst.instruction = 0xfa000000;
7674       encode_branch (BFD_RELOC_ARM_PCREL_BLX);
7675     }
7676 }
7677
7678 static void
7679 do_bx (void)
7680 {
7681   bfd_boolean want_reloc;
7682
7683   if (inst.operands[0].reg == REG_PC)
7684     as_tsktsk (_("use of r15 in bx in ARM mode is not really useful"));
7685
7686   inst.instruction |= inst.operands[0].reg;
7687   /* Output R_ARM_V4BX relocations if is an EABI object that looks like
7688      it is for ARMv4t or earlier.  */
7689   want_reloc = !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5);
7690   if (object_arch && !ARM_CPU_HAS_FEATURE (*object_arch, arm_ext_v5))
7691       want_reloc = TRUE;
7692
7693 #ifdef OBJ_ELF
7694   if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
7695 #endif
7696     want_reloc = FALSE;
7697
7698   if (want_reloc)
7699     inst.reloc.type = BFD_RELOC_ARM_V4BX;
7700 }
7701
7702
7703 /* ARM v5TEJ.  Jump to Jazelle code.  */
7704
7705 static void
7706 do_bxj (void)
7707 {
7708   if (inst.operands[0].reg == REG_PC)
7709     as_tsktsk (_("use of r15 in bxj is not really useful"));
7710
7711   inst.instruction |= inst.operands[0].reg;
7712 }
7713
7714 /* Co-processor data operation:
7715       CDP{cond} <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>{, <opcode_2>}
7716       CDP2      <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>{, <opcode_2>}  */
7717 static void
7718 do_cdp (void)
7719 {
7720   inst.instruction |= inst.operands[0].reg << 8;
7721   inst.instruction |= inst.operands[1].imm << 20;
7722   inst.instruction |= inst.operands[2].reg << 12;
7723   inst.instruction |= inst.operands[3].reg << 16;
7724   inst.instruction |= inst.operands[4].reg;
7725   inst.instruction |= inst.operands[5].imm << 5;
7726 }
7727
7728 static void
7729 do_cmp (void)
7730 {
7731   inst.instruction |= inst.operands[0].reg << 16;
7732   encode_arm_shifter_operand (1);
7733 }
7734
7735 /* Transfer between coprocessor and ARM registers.
7736    MRC{cond} <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>{, <opcode_2>}
7737    MRC2
7738    MCR{cond}
7739    MCR2
7740
7741    No special properties.  */
7742
7743 struct deprecated_coproc_regs_s
7744 {
7745   unsigned cp;
7746   int opc1;
7747   unsigned crn;
7748   unsigned crm;
7749   int opc2;
7750   arm_feature_set deprecated;
7751   arm_feature_set obsoleted;
7752   const char *dep_msg;
7753   const char *obs_msg;
7754 };
7755
7756 #define DEPR_ACCESS_V8 \
7757   N_("This coprocessor register access is deprecated in ARMv8")
7758
7759 /* Table of all deprecated coprocessor registers.  */
7760 static struct deprecated_coproc_regs_s deprecated_coproc_regs[] =
7761 {
7762     {15, 0, 7, 10, 5,                                   /* CP15DMB.  */
7763      ARM_FEATURE (ARM_EXT_V8, 0), ARM_FEATURE (0, 0),
7764      DEPR_ACCESS_V8, NULL},
7765     {15, 0, 7, 10, 4,                                   /* CP15DSB.  */
7766      ARM_FEATURE (ARM_EXT_V8, 0), ARM_FEATURE (0, 0),
7767      DEPR_ACCESS_V8, NULL},
7768     {15, 0, 7,  5, 4,                                   /* CP15ISB.  */
7769      ARM_FEATURE (ARM_EXT_V8, 0), ARM_FEATURE (0, 0),
7770      DEPR_ACCESS_V8, NULL},
7771     {14, 6, 1,  0, 0,                                   /* TEEHBR.  */
7772      ARM_FEATURE (ARM_EXT_V8, 0), ARM_FEATURE (0, 0),
7773      DEPR_ACCESS_V8, NULL},
7774     {14, 6, 0,  0, 0,                                   /* TEECR.  */
7775      ARM_FEATURE (ARM_EXT_V8, 0), ARM_FEATURE (0, 0),
7776      DEPR_ACCESS_V8, NULL},
7777 };
7778
7779 #undef DEPR_ACCESS_V8
7780
7781 static const size_t deprecated_coproc_reg_count =
7782   sizeof (deprecated_coproc_regs) / sizeof (deprecated_coproc_regs[0]);
7783
7784 static void
7785 do_co_reg (void)
7786 {
7787   unsigned Rd;
7788   size_t i;
7789
7790   Rd = inst.operands[2].reg;
7791   if (thumb_mode)
7792     {
7793       if (inst.instruction == 0xee000010
7794           || inst.instruction == 0xfe000010)
7795         /* MCR, MCR2  */
7796         reject_bad_reg (Rd);
7797       else
7798         /* MRC, MRC2  */
7799         constraint (Rd == REG_SP, BAD_SP);
7800     }
7801   else
7802     {
7803       /* MCR */
7804       if (inst.instruction == 0xe000010)
7805         constraint (Rd == REG_PC, BAD_PC);
7806     }
7807
7808     for (i = 0; i < deprecated_coproc_reg_count; ++i)
7809       {
7810         const struct deprecated_coproc_regs_s *r =
7811           deprecated_coproc_regs + i;
7812
7813         if (inst.operands[0].reg == r->cp
7814             && inst.operands[1].imm == r->opc1
7815             && inst.operands[3].reg == r->crn
7816             && inst.operands[4].reg == r->crm
7817             && inst.operands[5].imm == r->opc2)
7818           {
7819             if (!check_obsolete (&r->obsoleted, r->obs_msg)
7820                 && warn_on_deprecated
7821                 && ARM_CPU_HAS_FEATURE (cpu_variant, r->deprecated))
7822               as_warn ("%s", r->dep_msg);
7823           }
7824       }
7825
7826   inst.instruction |= inst.operands[0].reg << 8;
7827   inst.instruction |= inst.operands[1].imm << 21;
7828   inst.instruction |= Rd << 12;
7829   inst.instruction |= inst.operands[3].reg << 16;
7830   inst.instruction |= inst.operands[4].reg;
7831   inst.instruction |= inst.operands[5].imm << 5;
7832 }
7833
7834 /* Transfer between coprocessor register and pair of ARM registers.
7835    MCRR{cond} <coproc>, <opcode>, <Rd>, <Rn>, <CRm>.
7836    MCRR2
7837    MRRC{cond}
7838    MRRC2
7839
7840    Two XScale instructions are special cases of these:
7841
7842      MAR{cond} acc0, <RdLo>, <RdHi> == MCRR{cond} p0, #0, <RdLo>, <RdHi>, c0
7843      MRA{cond} acc0, <RdLo>, <RdHi> == MRRC{cond} p0, #0, <RdLo>, <RdHi>, c0
7844
7845    Result unpredictable if Rd or Rn is R15.  */
7846
7847 static void
7848 do_co_reg2c (void)
7849 {
7850   unsigned Rd, Rn;
7851
7852   Rd = inst.operands[2].reg;
7853   Rn = inst.operands[3].reg;
7854
7855   if (thumb_mode)
7856     {
7857       reject_bad_reg (Rd);
7858       reject_bad_reg (Rn);
7859     }
7860   else
7861     {
7862       constraint (Rd == REG_PC, BAD_PC);
7863       constraint (Rn == REG_PC, BAD_PC);
7864     }
7865
7866   inst.instruction |= inst.operands[0].reg << 8;
7867   inst.instruction |= inst.operands[1].imm << 4;
7868   inst.instruction |= Rd << 12;
7869   inst.instruction |= Rn << 16;
7870   inst.instruction |= inst.operands[4].reg;
7871 }
7872
7873 static void
7874 do_cpsi (void)
7875 {
7876   inst.instruction |= inst.operands[0].imm << 6;
7877   if (inst.operands[1].present)
7878     {
7879       inst.instruction |= CPSI_MMOD;
7880       inst.instruction |= inst.operands[1].imm;
7881     }
7882 }
7883
7884 static void
7885 do_dbg (void)
7886 {
7887   inst.instruction |= inst.operands[0].imm;
7888 }
7889
7890 static void
7891 do_div (void)
7892 {
7893   unsigned Rd, Rn, Rm;
7894
7895   Rd = inst.operands[0].reg;
7896   Rn = (inst.operands[1].present
7897         ? inst.operands[1].reg : Rd);
7898   Rm = inst.operands[2].reg;
7899
7900   constraint ((Rd == REG_PC), BAD_PC);
7901   constraint ((Rn == REG_PC), BAD_PC);
7902   constraint ((Rm == REG_PC), BAD_PC);
7903
7904   inst.instruction |= Rd << 16;
7905   inst.instruction |= Rn << 0;
7906   inst.instruction |= Rm << 8;
7907 }
7908
7909 static void
7910 do_it (void)
7911 {
7912   /* There is no IT instruction in ARM mode.  We
7913      process it to do the validation as if in
7914      thumb mode, just in case the code gets
7915      assembled for thumb using the unified syntax.  */
7916
7917   inst.size = 0;
7918   if (unified_syntax)
7919     {
7920       set_it_insn_type (IT_INSN);
7921       now_it.mask = (inst.instruction & 0xf) | 0x10;
7922       now_it.cc = inst.operands[0].imm;
7923     }
7924 }
7925
7926 /* If there is only one register in the register list,
7927    then return its register number.  Otherwise return -1.  */
7928 static int
7929 only_one_reg_in_list (int range)
7930 {
7931   int i = ffs (range) - 1;
7932   return (i > 15 || range != (1 << i)) ? -1 : i;
7933 }
7934
7935 static void
7936 encode_ldmstm(int from_push_pop_mnem)
7937 {
7938   int base_reg = inst.operands[0].reg;
7939   int range = inst.operands[1].imm;
7940   int one_reg;
7941
7942   inst.instruction |= base_reg << 16;
7943   inst.instruction |= range;
7944
7945   if (inst.operands[1].writeback)
7946     inst.instruction |= LDM_TYPE_2_OR_3;
7947
7948   if (inst.operands[0].writeback)
7949     {
7950       inst.instruction |= WRITE_BACK;
7951       /* Check for unpredictable uses of writeback.  */
7952       if (inst.instruction & LOAD_BIT)
7953         {
7954           /* Not allowed in LDM type 2.  */
7955           if ((inst.instruction & LDM_TYPE_2_OR_3)
7956               && ((range & (1 << REG_PC)) == 0))
7957             as_warn (_("writeback of base register is UNPREDICTABLE"));
7958           /* Only allowed if base reg not in list for other types.  */
7959           else if (range & (1 << base_reg))
7960             as_warn (_("writeback of base register when in register list is UNPREDICTABLE"));
7961         }
7962       else /* STM.  */
7963         {
7964           /* Not allowed for type 2.  */
7965           if (inst.instruction & LDM_TYPE_2_OR_3)
7966             as_warn (_("writeback of base register is UNPREDICTABLE"));
7967           /* Only allowed if base reg not in list, or first in list.  */
7968           else if ((range & (1 << base_reg))
7969                    && (range & ((1 << base_reg) - 1)))
7970             as_warn (_("if writeback register is in list, it must be the lowest reg in the list"));
7971         }
7972     }
7973
7974   /* If PUSH/POP has only one register, then use the A2 encoding.  */
7975   one_reg = only_one_reg_in_list (range);
7976   if (from_push_pop_mnem && one_reg >= 0)
7977     {
7978       int is_push = (inst.instruction & A_PUSH_POP_OP_MASK) == A1_OPCODE_PUSH;
7979
7980       inst.instruction &= A_COND_MASK;
7981       inst.instruction |= is_push ? A2_OPCODE_PUSH : A2_OPCODE_POP;
7982       inst.instruction |= one_reg << 12;
7983     }
7984 }
7985
7986 static void
7987 do_ldmstm (void)
7988 {
7989   encode_ldmstm (/*from_push_pop_mnem=*/FALSE);
7990 }
7991
7992 /* ARMv5TE load-consecutive (argument parse)
7993    Mode is like LDRH.
7994
7995      LDRccD R, mode
7996      STRccD R, mode.  */
7997
7998 static void
7999 do_ldrd (void)
8000 {
8001   constraint (inst.operands[0].reg % 2 != 0,
8002               _("first transfer register must be even"));
8003   constraint (inst.operands[1].present
8004               && inst.operands[1].reg != inst.operands[0].reg + 1,
8005               _("can only transfer two consecutive registers"));
8006   constraint (inst.operands[0].reg == REG_LR, _("r14 not allowed here"));
8007   constraint (!inst.operands[2].isreg, _("'[' expected"));
8008
8009   if (!inst.operands[1].present)
8010     inst.operands[1].reg = inst.operands[0].reg + 1;
8011
8012   /* encode_arm_addr_mode_3 will diagnose overlap between the base
8013      register and the first register written; we have to diagnose
8014      overlap between the base and the second register written here.  */
8015
8016   if (inst.operands[2].reg == inst.operands[1].reg
8017       && (inst.operands[2].writeback || inst.operands[2].postind))
8018     as_warn (_("base register written back, and overlaps "
8019                "second transfer register"));
8020
8021   if (!(inst.instruction & V4_STR_BIT))
8022     {
8023       /* For an index-register load, the index register must not overlap the
8024         destination (even if not write-back).  */
8025       if (inst.operands[2].immisreg
8026               && ((unsigned) inst.operands[2].imm == inst.operands[0].reg
8027               || (unsigned) inst.operands[2].imm == inst.operands[1].reg))
8028         as_warn (_("index register overlaps transfer register"));
8029     }
8030   inst.instruction |= inst.operands[0].reg << 12;
8031   encode_arm_addr_mode_3 (2, /*is_t=*/FALSE);
8032 }
8033
8034 static void
8035 do_ldrex (void)
8036 {
8037   constraint (!inst.operands[1].isreg || !inst.operands[1].preind
8038               || inst.operands[1].postind || inst.operands[1].writeback
8039               || inst.operands[1].immisreg || inst.operands[1].shifted
8040               || inst.operands[1].negative
8041               /* This can arise if the programmer has written
8042                    strex rN, rM, foo
8043                  or if they have mistakenly used a register name as the last
8044                  operand,  eg:
8045                    strex rN, rM, rX
8046                  It is very difficult to distinguish between these two cases
8047                  because "rX" might actually be a label. ie the register
8048                  name has been occluded by a symbol of the same name. So we
8049                  just generate a general 'bad addressing mode' type error
8050                  message and leave it up to the programmer to discover the
8051                  true cause and fix their mistake.  */
8052               || (inst.operands[1].reg == REG_PC),
8053               BAD_ADDR_MODE);
8054
8055   constraint (inst.reloc.exp.X_op != O_constant
8056               || inst.reloc.exp.X_add_number != 0,
8057               _("offset must be zero in ARM encoding"));
8058
8059   constraint ((inst.operands[1].reg == REG_PC), BAD_PC);
8060
8061   inst.instruction |= inst.operands[0].reg << 12;
8062   inst.instruction |= inst.operands[1].reg << 16;
8063   inst.reloc.type = BFD_RELOC_UNUSED;
8064 }
8065
8066 static void
8067 do_ldrexd (void)
8068 {
8069   constraint (inst.operands[0].reg % 2 != 0,
8070               _("even register required"));
8071   constraint (inst.operands[1].present
8072               && inst.operands[1].reg != inst.operands[0].reg + 1,
8073               _("can only load two consecutive registers"));
8074   /* If op 1 were present and equal to PC, this function wouldn't
8075      have been called in the first place.  */
8076   constraint (inst.operands[0].reg == REG_LR, _("r14 not allowed here"));
8077
8078   inst.instruction |= inst.operands[0].reg << 12;
8079   inst.instruction |= inst.operands[2].reg << 16;
8080 }
8081
8082 /* In both ARM and thumb state 'ldr pc, #imm'  with an immediate
8083    which is not a multiple of four is UNPREDICTABLE.  */
8084 static void
8085 check_ldr_r15_aligned (void)
8086 {
8087   constraint (!(inst.operands[1].immisreg)
8088               && (inst.operands[0].reg == REG_PC
8089               && inst.operands[1].reg == REG_PC
8090               && (inst.reloc.exp.X_add_number & 0x3)),
8091               _("ldr to register 15 must be 4-byte alligned"));
8092 }
8093
8094 static void
8095 do_ldst (void)
8096 {
8097   inst.instruction |= inst.operands[0].reg << 12;
8098   if (!inst.operands[1].isreg)
8099     if (move_or_literal_pool (0, /*thumb_p=*/FALSE, /*mode_3=*/FALSE))
8100       return;
8101   encode_arm_addr_mode_2 (1, /*is_t=*/FALSE);
8102   check_ldr_r15_aligned ();
8103 }
8104
8105 static void
8106 do_ldstt (void)
8107 {
8108   /* ldrt/strt always use post-indexed addressing.  Turn [Rn] into [Rn]! and
8109      reject [Rn,...].  */
8110   if (inst.operands[1].preind)
8111     {
8112       constraint (inst.reloc.exp.X_op != O_constant
8113                   || inst.reloc.exp.X_add_number != 0,
8114                   _("this instruction requires a post-indexed address"));
8115
8116       inst.operands[1].preind = 0;
8117       inst.operands[1].postind = 1;
8118       inst.operands[1].writeback = 1;
8119     }
8120   inst.instruction |= inst.operands[0].reg << 12;
8121   encode_arm_addr_mode_2 (1, /*is_t=*/TRUE);
8122 }
8123
8124 /* Halfword and signed-byte load/store operations.  */
8125
8126 static void
8127 do_ldstv4 (void)
8128 {
8129   constraint (inst.operands[0].reg == REG_PC, BAD_PC);
8130   inst.instruction |= inst.operands[0].reg << 12;
8131   if (!inst.operands[1].isreg)
8132     if (move_or_literal_pool (0, /*thumb_p=*/FALSE, /*mode_3=*/TRUE))
8133       return;
8134   encode_arm_addr_mode_3 (1, /*is_t=*/FALSE);
8135 }
8136
8137 static void
8138 do_ldsttv4 (void)
8139 {
8140   /* ldrt/strt always use post-indexed addressing.  Turn [Rn] into [Rn]! and
8141      reject [Rn,...].  */
8142   if (inst.operands[1].preind)
8143     {
8144       constraint (inst.reloc.exp.X_op != O_constant
8145                   || inst.reloc.exp.X_add_number != 0,
8146                   _("this instruction requires a post-indexed address"));
8147
8148       inst.operands[1].preind = 0;
8149       inst.operands[1].postind = 1;
8150       inst.operands[1].writeback = 1;
8151     }
8152   inst.instruction |= inst.operands[0].reg << 12;
8153   encode_arm_addr_mode_3 (1, /*is_t=*/TRUE);
8154 }
8155
8156 /* Co-processor register load/store.
8157    Format: <LDC|STC>{cond}[L] CP#,CRd,<address>  */
8158 static void
8159 do_lstc (void)
8160 {
8161   inst.instruction |= inst.operands[0].reg << 8;
8162   inst.instruction |= inst.operands[1].reg << 12;
8163   encode_arm_cp_address (2, TRUE, TRUE, 0);
8164 }
8165
8166 static void
8167 do_mlas (void)
8168 {
8169   /* This restriction does not apply to mls (nor to mla in v6 or later).  */
8170   if (inst.operands[0].reg == inst.operands[1].reg
8171       && !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6)
8172       && !(inst.instruction & 0x00400000))
8173     as_tsktsk (_("Rd and Rm should be different in mla"));
8174
8175   inst.instruction |= inst.operands[0].reg << 16;
8176   inst.instruction |= inst.operands[1].reg;
8177   inst.instruction |= inst.operands[2].reg << 8;
8178   inst.instruction |= inst.operands[3].reg << 12;
8179 }
8180
8181 static void
8182 do_mov (void)
8183 {
8184   inst.instruction |= inst.operands[0].reg << 12;
8185   encode_arm_shifter_operand (1);
8186 }
8187
8188 /* ARM V6T2 16-bit immediate register load: MOV[WT]{cond} Rd, #<imm16>.  */
8189 static void
8190 do_mov16 (void)
8191 {
8192   bfd_vma imm;
8193   bfd_boolean top;
8194
8195   top = (inst.instruction & 0x00400000) != 0;
8196   constraint (top && inst.reloc.type == BFD_RELOC_ARM_MOVW,
8197               _(":lower16: not allowed this instruction"));
8198   constraint (!top && inst.reloc.type == BFD_RELOC_ARM_MOVT,
8199               _(":upper16: not allowed instruction"));
8200   inst.instruction |= inst.operands[0].reg << 12;
8201   if (inst.reloc.type == BFD_RELOC_UNUSED)
8202     {
8203       imm = inst.reloc.exp.X_add_number;
8204       /* The value is in two pieces: 0:11, 16:19.  */
8205       inst.instruction |= (imm & 0x00000fff);
8206       inst.instruction |= (imm & 0x0000f000) << 4;
8207     }
8208 }
8209
8210 static void do_vfp_nsyn_opcode (const char *);
8211
8212 static int
8213 do_vfp_nsyn_mrs (void)
8214 {
8215   if (inst.operands[0].isvec)
8216     {
8217       if (inst.operands[1].reg != 1)
8218         first_error (_("operand 1 must be FPSCR"));
8219       memset (&inst.operands[0], '\0', sizeof (inst.operands[0]));
8220       memset (&inst.operands[1], '\0', sizeof (inst.operands[1]));
8221       do_vfp_nsyn_opcode ("fmstat");
8222     }
8223   else if (inst.operands[1].isvec)
8224     do_vfp_nsyn_opcode ("fmrx");
8225   else
8226     return FAIL;
8227
8228   return SUCCESS;
8229 }
8230
8231 static int
8232 do_vfp_nsyn_msr (void)
8233 {
8234   if (inst.operands[0].isvec)
8235     do_vfp_nsyn_opcode ("fmxr");
8236   else
8237     return FAIL;
8238
8239   return SUCCESS;
8240 }
8241
8242 static void
8243 do_vmrs (void)
8244 {
8245   unsigned Rt = inst.operands[0].reg;
8246
8247   if (thumb_mode && inst.operands[0].reg == REG_SP)
8248     {
8249       inst.error = BAD_SP;
8250       return;
8251     }
8252
8253   /* APSR_ sets isvec. All other refs to PC are illegal.  */
8254   if (!inst.operands[0].isvec && inst.operands[0].reg == REG_PC)
8255     {
8256       inst.error = BAD_PC;
8257       return;
8258     }
8259
8260   switch (inst.operands[1].reg)
8261     {
8262     case 0: /* FPSID */
8263     case 1: /* FPSCR */
8264     case 6: /* MVFR1 */
8265     case 7: /* MVFR0 */
8266     case 8: /* FPEXC */
8267       inst.instruction |= (inst.operands[1].reg << 16);
8268       break;
8269     default:
8270       first_error (_("operand 1 must be a VFP extension System Register"));
8271     }
8272
8273   inst.instruction |= (Rt << 12);
8274 }
8275
8276 static void
8277 do_vmsr (void)
8278 {
8279   unsigned Rt = inst.operands[1].reg;
8280
8281   if (thumb_mode)
8282     reject_bad_reg (Rt);
8283   else if (Rt == REG_PC)
8284     {
8285       inst.error = BAD_PC;
8286       return;
8287     }
8288
8289   switch (inst.operands[0].reg)
8290     {
8291     case 0: /* FPSID  */
8292     case 1: /* FPSCR  */
8293     case 8: /* FPEXC */
8294       inst.instruction |= (inst.operands[0].reg << 16);
8295       break;
8296     default:
8297       first_error (_("operand 0 must be FPSID or FPSCR pr FPEXC"));
8298     }
8299
8300   inst.instruction |= (Rt << 12);
8301 }
8302
8303 static void
8304 do_mrs (void)
8305 {
8306   unsigned br;
8307
8308   if (do_vfp_nsyn_mrs () == SUCCESS)
8309     return;
8310
8311   constraint (inst.operands[0].reg == REG_PC, BAD_PC);
8312   inst.instruction |= inst.operands[0].reg << 12;
8313
8314   if (inst.operands[1].isreg)
8315     {
8316       br = inst.operands[1].reg;
8317       if (((br & 0x200) == 0) && ((br & 0xf0000) != 0xf000))
8318         as_bad (_("bad register for mrs"));
8319     }
8320   else
8321     {
8322       /* mrs only accepts CPSR/SPSR/CPSR_all/SPSR_all.  */
8323       constraint ((inst.operands[1].imm & (PSR_c|PSR_x|PSR_s|PSR_f))
8324                   != (PSR_c|PSR_f),
8325                   _("'APSR', 'CPSR' or 'SPSR' expected"));
8326       br = (15<<16) | (inst.operands[1].imm & SPSR_BIT);
8327     }
8328
8329   inst.instruction |= br;
8330 }
8331
8332 /* Two possible forms:
8333       "{C|S}PSR_<field>, Rm",
8334       "{C|S}PSR_f, #expression".  */
8335
8336 static void
8337 do_msr (void)
8338 {
8339   if (do_vfp_nsyn_msr () == SUCCESS)
8340     return;
8341
8342   inst.instruction |= inst.operands[0].imm;
8343   if (inst.operands[1].isreg)
8344     inst.instruction |= inst.operands[1].reg;
8345   else
8346     {
8347       inst.instruction |= INST_IMMEDIATE;
8348       inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
8349       inst.reloc.pc_rel = 0;
8350     }
8351 }
8352
8353 static void
8354 do_mul (void)
8355 {
8356   constraint (inst.operands[2].reg == REG_PC, BAD_PC);
8357
8358   if (!inst.operands[2].present)
8359     inst.operands[2].reg = inst.operands[0].reg;
8360   inst.instruction |= inst.operands[0].reg << 16;
8361   inst.instruction |= inst.operands[1].reg;
8362   inst.instruction |= inst.operands[2].reg << 8;
8363
8364   if (inst.operands[0].reg == inst.operands[1].reg
8365       && !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6))
8366     as_tsktsk (_("Rd and Rm should be different in mul"));
8367 }
8368
8369 /* Long Multiply Parser
8370    UMULL RdLo, RdHi, Rm, Rs
8371    SMULL RdLo, RdHi, Rm, Rs
8372    UMLAL RdLo, RdHi, Rm, Rs
8373    SMLAL RdLo, RdHi, Rm, Rs.  */
8374
8375 static void
8376 do_mull (void)
8377 {
8378   inst.instruction |= inst.operands[0].reg << 12;
8379   inst.instruction |= inst.operands[1].reg << 16;
8380   inst.instruction |= inst.operands[2].reg;
8381   inst.instruction |= inst.operands[3].reg << 8;
8382
8383   /* rdhi and rdlo must be different.  */
8384   if (inst.operands[0].reg == inst.operands[1].reg)
8385     as_tsktsk (_("rdhi and rdlo must be different"));
8386
8387   /* rdhi, rdlo and rm must all be different before armv6.  */
8388   if ((inst.operands[0].reg == inst.operands[2].reg
8389       || inst.operands[1].reg == inst.operands[2].reg)
8390       && !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6))
8391     as_tsktsk (_("rdhi, rdlo and rm must all be different"));
8392 }
8393
8394 static void
8395 do_nop (void)
8396 {
8397   if (inst.operands[0].present
8398       || ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6k))
8399     {
8400       /* Architectural NOP hints are CPSR sets with no bits selected.  */
8401       inst.instruction &= 0xf0000000;
8402       inst.instruction |= 0x0320f000;
8403       if (inst.operands[0].present)
8404         inst.instruction |= inst.operands[0].imm;
8405     }
8406 }
8407
8408 /* ARM V6 Pack Halfword Bottom Top instruction (argument parse).
8409    PKHBT {<cond>} <Rd>, <Rn>, <Rm> {, LSL #<shift_imm>}
8410    Condition defaults to COND_ALWAYS.
8411    Error if Rd, Rn or Rm are R15.  */
8412
8413 static void
8414 do_pkhbt (void)
8415 {
8416   inst.instruction |= inst.operands[0].reg << 12;
8417   inst.instruction |= inst.operands[1].reg << 16;
8418   inst.instruction |= inst.operands[2].reg;
8419   if (inst.operands[3].present)
8420     encode_arm_shift (3);
8421 }
8422
8423 /* ARM V6 PKHTB (Argument Parse).  */
8424
8425 static void
8426 do_pkhtb (void)
8427 {
8428   if (!inst.operands[3].present)
8429     {
8430       /* If the shift specifier is omitted, turn the instruction
8431          into pkhbt rd, rm, rn. */
8432       inst.instruction &= 0xfff00010;
8433       inst.instruction |= inst.operands[0].reg << 12;
8434       inst.instruction |= inst.operands[1].reg;
8435       inst.instruction |= inst.operands[2].reg << 16;
8436     }
8437   else
8438     {
8439       inst.instruction |= inst.operands[0].reg << 12;
8440       inst.instruction |= inst.operands[1].reg << 16;
8441       inst.instruction |= inst.operands[2].reg;
8442       encode_arm_shift (3);
8443     }
8444 }
8445
8446 /* ARMv5TE: Preload-Cache
8447    MP Extensions: Preload for write
8448
8449     PLD(W) <addr_mode>
8450
8451   Syntactically, like LDR with B=1, W=0, L=1.  */
8452
8453 static void
8454 do_pld (void)
8455 {
8456   constraint (!inst.operands[0].isreg,
8457               _("'[' expected after PLD mnemonic"));
8458   constraint (inst.operands[0].postind,
8459               _("post-indexed expression used in preload instruction"));
8460   constraint (inst.operands[0].writeback,
8461               _("writeback used in preload instruction"));
8462   constraint (!inst.operands[0].preind,
8463               _("unindexed addressing used in preload instruction"));
8464   encode_arm_addr_mode_2 (0, /*is_t=*/FALSE);
8465 }
8466
8467 /* ARMv7: PLI <addr_mode>  */
8468 static void
8469 do_pli (void)
8470 {
8471   constraint (!inst.operands[0].isreg,
8472               _("'[' expected after PLI mnemonic"));
8473   constraint (inst.operands[0].postind,
8474               _("post-indexed expression used in preload instruction"));
8475   constraint (inst.operands[0].writeback,
8476               _("writeback used in preload instruction"));
8477   constraint (!inst.operands[0].preind,
8478               _("unindexed addressing used in preload instruction"));
8479   encode_arm_addr_mode_2 (0, /*is_t=*/FALSE);
8480   inst.instruction &= ~PRE_INDEX;
8481 }
8482
8483 static void
8484 do_push_pop (void)
8485 {
8486   inst.operands[1] = inst.operands[0];
8487   memset (&inst.operands[0], 0, sizeof inst.operands[0]);
8488   inst.operands[0].isreg = 1;
8489   inst.operands[0].writeback = 1;
8490   inst.operands[0].reg = REG_SP;
8491   encode_ldmstm (/*from_push_pop_mnem=*/TRUE);
8492 }
8493
8494 /* ARM V6 RFE (Return from Exception) loads the PC and CPSR from the
8495    word at the specified address and the following word
8496    respectively.
8497    Unconditionally executed.
8498    Error if Rn is R15.  */
8499
8500 static void
8501 do_rfe (void)
8502 {
8503   inst.instruction |= inst.operands[0].reg << 16;
8504   if (inst.operands[0].writeback)
8505     inst.instruction |= WRITE_BACK;
8506 }
8507
8508 /* ARM V6 ssat (argument parse).  */
8509
8510 static void
8511 do_ssat (void)
8512 {
8513   inst.instruction |= inst.operands[0].reg << 12;
8514   inst.instruction |= (inst.operands[1].imm - 1) << 16;
8515   inst.instruction |= inst.operands[2].reg;
8516
8517   if (inst.operands[3].present)
8518     encode_arm_shift (3);
8519 }
8520
8521 /* ARM V6 usat (argument parse).  */
8522
8523 static void
8524 do_usat (void)
8525 {
8526   inst.instruction |= inst.operands[0].reg << 12;
8527   inst.instruction |= inst.operands[1].imm << 16;
8528   inst.instruction |= inst.operands[2].reg;
8529
8530   if (inst.operands[3].present)
8531     encode_arm_shift (3);
8532 }
8533
8534 /* ARM V6 ssat16 (argument parse).  */
8535
8536 static void
8537 do_ssat16 (void)
8538 {
8539   inst.instruction |= inst.operands[0].reg << 12;
8540   inst.instruction |= ((inst.operands[1].imm - 1) << 16);
8541   inst.instruction |= inst.operands[2].reg;
8542 }
8543
8544 static void
8545 do_usat16 (void)
8546 {
8547   inst.instruction |= inst.operands[0].reg << 12;
8548   inst.instruction |= inst.operands[1].imm << 16;
8549   inst.instruction |= inst.operands[2].reg;
8550 }
8551
8552 /* ARM V6 SETEND (argument parse).  Sets the E bit in the CPSR while
8553    preserving the other bits.
8554
8555    setend <endian_specifier>, where <endian_specifier> is either
8556    BE or LE.  */
8557
8558 static void
8559 do_setend (void)
8560 {
8561   if (warn_on_deprecated
8562       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
8563       as_warn (_("setend use is deprecated for ARMv8"));
8564
8565   if (inst.operands[0].imm)
8566     inst.instruction |= 0x200;
8567 }
8568
8569 static void
8570 do_shift (void)
8571 {
8572   unsigned int Rm = (inst.operands[1].present
8573                      ? inst.operands[1].reg
8574                      : inst.operands[0].reg);
8575
8576   inst.instruction |= inst.operands[0].reg << 12;
8577   inst.instruction |= Rm;
8578   if (inst.operands[2].isreg)  /* Rd, {Rm,} Rs */
8579     {
8580       inst.instruction |= inst.operands[2].reg << 8;
8581       inst.instruction |= SHIFT_BY_REG;
8582       /* PR 12854: Error on extraneous shifts.  */
8583       constraint (inst.operands[2].shifted,
8584                   _("extraneous shift as part of operand to shift insn"));
8585     }
8586   else
8587     inst.reloc.type = BFD_RELOC_ARM_SHIFT_IMM;
8588 }
8589
8590 static void
8591 do_smc (void)
8592 {
8593   inst.reloc.type = BFD_RELOC_ARM_SMC;
8594   inst.reloc.pc_rel = 0;
8595 }
8596
8597 static void
8598 do_hvc (void)
8599 {
8600   inst.reloc.type = BFD_RELOC_ARM_HVC;
8601   inst.reloc.pc_rel = 0;
8602 }
8603
8604 static void
8605 do_swi (void)
8606 {
8607   inst.reloc.type = BFD_RELOC_ARM_SWI;
8608   inst.reloc.pc_rel = 0;
8609 }
8610
8611 /* ARM V5E (El Segundo) signed-multiply-accumulate (argument parse)
8612    SMLAxy{cond} Rd,Rm,Rs,Rn
8613    SMLAWy{cond} Rd,Rm,Rs,Rn
8614    Error if any register is R15.  */
8615
8616 static void
8617 do_smla (void)
8618 {
8619   inst.instruction |= inst.operands[0].reg << 16;
8620   inst.instruction |= inst.operands[1].reg;
8621   inst.instruction |= inst.operands[2].reg << 8;
8622   inst.instruction |= inst.operands[3].reg << 12;
8623 }
8624
8625 /* ARM V5E (El Segundo) signed-multiply-accumulate-long (argument parse)
8626    SMLALxy{cond} Rdlo,Rdhi,Rm,Rs
8627    Error if any register is R15.
8628    Warning if Rdlo == Rdhi.  */
8629
8630 static void
8631 do_smlal (void)
8632 {
8633   inst.instruction |= inst.operands[0].reg << 12;
8634   inst.instruction |= inst.operands[1].reg << 16;
8635   inst.instruction |= inst.operands[2].reg;
8636   inst.instruction |= inst.operands[3].reg << 8;
8637
8638   if (inst.operands[0].reg == inst.operands[1].reg)
8639     as_tsktsk (_("rdhi and rdlo must be different"));
8640 }
8641
8642 /* ARM V5E (El Segundo) signed-multiply (argument parse)
8643    SMULxy{cond} Rd,Rm,Rs
8644    Error if any register is R15.  */
8645
8646 static void
8647 do_smul (void)
8648 {
8649   inst.instruction |= inst.operands[0].reg << 16;
8650   inst.instruction |= inst.operands[1].reg;
8651   inst.instruction |= inst.operands[2].reg << 8;
8652 }
8653
8654 /* ARM V6 srs (argument parse).  The variable fields in the encoding are
8655    the same for both ARM and Thumb-2.  */
8656
8657 static void
8658 do_srs (void)
8659 {
8660   int reg;
8661
8662   if (inst.operands[0].present)
8663     {
8664       reg = inst.operands[0].reg;
8665       constraint (reg != REG_SP, _("SRS base register must be r13"));
8666     }
8667   else
8668     reg = REG_SP;
8669
8670   inst.instruction |= reg << 16;
8671   inst.instruction |= inst.operands[1].imm;
8672   if (inst.operands[0].writeback || inst.operands[1].writeback)
8673     inst.instruction |= WRITE_BACK;
8674 }
8675
8676 /* ARM V6 strex (argument parse).  */
8677
8678 static void
8679 do_strex (void)
8680 {
8681   constraint (!inst.operands[2].isreg || !inst.operands[2].preind
8682               || inst.operands[2].postind || inst.operands[2].writeback
8683               || inst.operands[2].immisreg || inst.operands[2].shifted
8684               || inst.operands[2].negative
8685               /* See comment in do_ldrex().  */
8686               || (inst.operands[2].reg == REG_PC),
8687               BAD_ADDR_MODE);
8688
8689   constraint (inst.operands[0].reg == inst.operands[1].reg
8690               || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
8691
8692   constraint (inst.reloc.exp.X_op != O_constant
8693               || inst.reloc.exp.X_add_number != 0,
8694               _("offset must be zero in ARM encoding"));
8695
8696   inst.instruction |= inst.operands[0].reg << 12;
8697   inst.instruction |= inst.operands[1].reg;
8698   inst.instruction |= inst.operands[2].reg << 16;
8699   inst.reloc.type = BFD_RELOC_UNUSED;
8700 }
8701
8702 static void
8703 do_t_strexbh (void)
8704 {
8705   constraint (!inst.operands[2].isreg || !inst.operands[2].preind
8706               || inst.operands[2].postind || inst.operands[2].writeback
8707               || inst.operands[2].immisreg || inst.operands[2].shifted
8708               || inst.operands[2].negative,
8709               BAD_ADDR_MODE);
8710
8711   constraint (inst.operands[0].reg == inst.operands[1].reg
8712               || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
8713
8714   do_rm_rd_rn ();
8715 }
8716
8717 static void
8718 do_strexd (void)
8719 {
8720   constraint (inst.operands[1].reg % 2 != 0,
8721               _("even register required"));
8722   constraint (inst.operands[2].present
8723               && inst.operands[2].reg != inst.operands[1].reg + 1,
8724               _("can only store two consecutive registers"));
8725   /* If op 2 were present and equal to PC, this function wouldn't
8726      have been called in the first place.  */
8727   constraint (inst.operands[1].reg == REG_LR, _("r14 not allowed here"));
8728
8729   constraint (inst.operands[0].reg == inst.operands[1].reg
8730               || inst.operands[0].reg == inst.operands[1].reg + 1
8731               || inst.operands[0].reg == inst.operands[3].reg,
8732               BAD_OVERLAP);
8733
8734   inst.instruction |= inst.operands[0].reg << 12;
8735   inst.instruction |= inst.operands[1].reg;
8736   inst.instruction |= inst.operands[3].reg << 16;
8737 }
8738
8739 /* ARM V8 STRL.  */
8740 static void
8741 do_strlex (void)
8742 {
8743   constraint (inst.operands[0].reg == inst.operands[1].reg
8744               || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
8745
8746   do_rd_rm_rn ();
8747 }
8748
8749 static void
8750 do_t_strlex (void)
8751 {
8752   constraint (inst.operands[0].reg == inst.operands[1].reg
8753               || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
8754
8755   do_rm_rd_rn ();
8756 }
8757
8758 /* ARM V6 SXTAH extracts a 16-bit value from a register, sign
8759    extends it to 32-bits, and adds the result to a value in another
8760    register.  You can specify a rotation by 0, 8, 16, or 24 bits
8761    before extracting the 16-bit value.
8762    SXTAH{<cond>} <Rd>, <Rn>, <Rm>{, <rotation>}
8763    Condition defaults to COND_ALWAYS.
8764    Error if any register uses R15.  */
8765
8766 static void
8767 do_sxtah (void)
8768 {
8769   inst.instruction |= inst.operands[0].reg << 12;
8770   inst.instruction |= inst.operands[1].reg << 16;
8771   inst.instruction |= inst.operands[2].reg;
8772   inst.instruction |= inst.operands[3].imm << 10;
8773 }
8774
8775 /* ARM V6 SXTH.
8776
8777    SXTH {<cond>} <Rd>, <Rm>{, <rotation>}
8778    Condition defaults to COND_ALWAYS.
8779    Error if any register uses R15.  */
8780
8781 static void
8782 do_sxth (void)
8783 {
8784   inst.instruction |= inst.operands[0].reg << 12;
8785   inst.instruction |= inst.operands[1].reg;
8786   inst.instruction |= inst.operands[2].imm << 10;
8787 }
8788 \f
8789 /* VFP instructions.  In a logical order: SP variant first, monad
8790    before dyad, arithmetic then move then load/store.  */
8791
8792 static void
8793 do_vfp_sp_monadic (void)
8794 {
8795   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
8796   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sm);
8797 }
8798
8799 static void
8800 do_vfp_sp_dyadic (void)
8801 {
8802   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
8803   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sn);
8804   encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Sm);
8805 }
8806
8807 static void
8808 do_vfp_sp_compare_z (void)
8809 {
8810   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
8811 }
8812
8813 static void
8814 do_vfp_dp_sp_cvt (void)
8815 {
8816   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
8817   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sm);
8818 }
8819
8820 static void
8821 do_vfp_sp_dp_cvt (void)
8822 {
8823   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
8824   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dm);
8825 }
8826
8827 static void
8828 do_vfp_reg_from_sp (void)
8829 {
8830   inst.instruction |= inst.operands[0].reg << 12;
8831   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sn);
8832 }
8833
8834 static void
8835 do_vfp_reg2_from_sp2 (void)
8836 {
8837   constraint (inst.operands[2].imm != 2,
8838               _("only two consecutive VFP SP registers allowed here"));
8839   inst.instruction |= inst.operands[0].reg << 12;
8840   inst.instruction |= inst.operands[1].reg << 16;
8841   encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Sm);
8842 }
8843
8844 static void
8845 do_vfp_sp_from_reg (void)
8846 {
8847   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sn);
8848   inst.instruction |= inst.operands[1].reg << 12;
8849 }
8850
8851 static void
8852 do_vfp_sp2_from_reg2 (void)
8853 {
8854   constraint (inst.operands[0].imm != 2,
8855               _("only two consecutive VFP SP registers allowed here"));
8856   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sm);
8857   inst.instruction |= inst.operands[1].reg << 12;
8858   inst.instruction |= inst.operands[2].reg << 16;
8859 }
8860
8861 static void
8862 do_vfp_sp_ldst (void)
8863 {
8864   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
8865   encode_arm_cp_address (1, FALSE, TRUE, 0);
8866 }
8867
8868 static void
8869 do_vfp_dp_ldst (void)
8870 {
8871   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
8872   encode_arm_cp_address (1, FALSE, TRUE, 0);
8873 }
8874
8875
8876 static void
8877 vfp_sp_ldstm (enum vfp_ldstm_type ldstm_type)
8878 {
8879   if (inst.operands[0].writeback)
8880     inst.instruction |= WRITE_BACK;
8881   else
8882     constraint (ldstm_type != VFP_LDSTMIA,
8883                 _("this addressing mode requires base-register writeback"));
8884   inst.instruction |= inst.operands[0].reg << 16;
8885   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sd);
8886   inst.instruction |= inst.operands[1].imm;
8887 }
8888
8889 static void
8890 vfp_dp_ldstm (enum vfp_ldstm_type ldstm_type)
8891 {
8892   int count;
8893
8894   if (inst.operands[0].writeback)
8895     inst.instruction |= WRITE_BACK;
8896   else
8897     constraint (ldstm_type != VFP_LDSTMIA && ldstm_type != VFP_LDSTMIAX,
8898                 _("this addressing mode requires base-register writeback"));
8899
8900   inst.instruction |= inst.operands[0].reg << 16;
8901   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dd);
8902
8903   count = inst.operands[1].imm << 1;
8904   if (ldstm_type == VFP_LDSTMIAX || ldstm_type == VFP_LDSTMDBX)
8905     count += 1;
8906
8907   inst.instruction |= count;
8908 }
8909
8910 static void
8911 do_vfp_sp_ldstmia (void)
8912 {
8913   vfp_sp_ldstm (VFP_LDSTMIA);
8914 }
8915
8916 static void
8917 do_vfp_sp_ldstmdb (void)
8918 {
8919   vfp_sp_ldstm (VFP_LDSTMDB);
8920 }
8921
8922 static void
8923 do_vfp_dp_ldstmia (void)
8924 {
8925   vfp_dp_ldstm (VFP_LDSTMIA);
8926 }
8927
8928 static void
8929 do_vfp_dp_ldstmdb (void)
8930 {
8931   vfp_dp_ldstm (VFP_LDSTMDB);
8932 }
8933
8934 static void
8935 do_vfp_xp_ldstmia (void)
8936 {
8937   vfp_dp_ldstm (VFP_LDSTMIAX);
8938 }
8939
8940 static void
8941 do_vfp_xp_ldstmdb (void)
8942 {
8943   vfp_dp_ldstm (VFP_LDSTMDBX);
8944 }
8945
8946 static void
8947 do_vfp_dp_rd_rm (void)
8948 {
8949   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
8950   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dm);
8951 }
8952
8953 static void
8954 do_vfp_dp_rn_rd (void)
8955 {
8956   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dn);
8957   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dd);
8958 }
8959
8960 static void
8961 do_vfp_dp_rd_rn (void)
8962 {
8963   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
8964   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dn);
8965 }
8966
8967 static void
8968 do_vfp_dp_rd_rn_rm (void)
8969 {
8970   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
8971   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dn);
8972   encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Dm);
8973 }
8974
8975 static void
8976 do_vfp_dp_rd (void)
8977 {
8978   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
8979 }
8980
8981 static void
8982 do_vfp_dp_rm_rd_rn (void)
8983 {
8984   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dm);
8985   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dd);
8986   encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Dn);
8987 }
8988
8989 /* VFPv3 instructions.  */
8990 static void
8991 do_vfp_sp_const (void)
8992 {
8993   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
8994   inst.instruction |= (inst.operands[1].imm & 0xf0) << 12;
8995   inst.instruction |= (inst.operands[1].imm & 0x0f);
8996 }
8997
8998 static void
8999 do_vfp_dp_const (void)
9000 {
9001   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9002   inst.instruction |= (inst.operands[1].imm & 0xf0) << 12;
9003   inst.instruction |= (inst.operands[1].imm & 0x0f);
9004 }
9005
9006 static void
9007 vfp_conv (int srcsize)
9008 {
9009   int immbits = srcsize - inst.operands[1].imm;
9010
9011   if (srcsize == 16 && !(immbits >= 0 && immbits <= srcsize))
9012     {
9013       /* If srcsize is 16, inst.operands[1].imm must be in the range 0-16.
9014          i.e. immbits must be in range 0 - 16.  */
9015       inst.error = _("immediate value out of range, expected range [0, 16]");
9016       return;
9017     }
9018   else if (srcsize == 32 && !(immbits >= 0 && immbits < srcsize))
9019     {
9020       /* If srcsize is 32, inst.operands[1].imm must be in the range 1-32.
9021          i.e. immbits must be in range 0 - 31.  */
9022       inst.error = _("immediate value out of range, expected range [1, 32]");
9023       return;
9024     }
9025
9026   inst.instruction |= (immbits & 1) << 5;
9027   inst.instruction |= (immbits >> 1);
9028 }
9029
9030 static void
9031 do_vfp_sp_conv_16 (void)
9032 {
9033   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9034   vfp_conv (16);
9035 }
9036
9037 static void
9038 do_vfp_dp_conv_16 (void)
9039 {
9040   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9041   vfp_conv (16);
9042 }
9043
9044 static void
9045 do_vfp_sp_conv_32 (void)
9046 {
9047   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9048   vfp_conv (32);
9049 }
9050
9051 static void
9052 do_vfp_dp_conv_32 (void)
9053 {
9054   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9055   vfp_conv (32);
9056 }
9057 \f
9058 /* FPA instructions.  Also in a logical order.  */
9059
9060 static void
9061 do_fpa_cmp (void)
9062 {
9063   inst.instruction |= inst.operands[0].reg << 16;
9064   inst.instruction |= inst.operands[1].reg;
9065 }
9066
9067 static void
9068 do_fpa_ldmstm (void)
9069 {
9070   inst.instruction |= inst.operands[0].reg << 12;
9071   switch (inst.operands[1].imm)
9072     {
9073     case 1: inst.instruction |= CP_T_X;          break;
9074     case 2: inst.instruction |= CP_T_Y;          break;
9075     case 3: inst.instruction |= CP_T_Y | CP_T_X; break;
9076     case 4:                                      break;
9077     default: abort ();
9078     }
9079
9080   if (inst.instruction & (PRE_INDEX | INDEX_UP))
9081     {
9082       /* The instruction specified "ea" or "fd", so we can only accept
9083          [Rn]{!}.  The instruction does not really support stacking or
9084          unstacking, so we have to emulate these by setting appropriate
9085          bits and offsets.  */
9086       constraint (inst.reloc.exp.X_op != O_constant
9087                   || inst.reloc.exp.X_add_number != 0,
9088                   _("this instruction does not support indexing"));
9089
9090       if ((inst.instruction & PRE_INDEX) || inst.operands[2].writeback)
9091         inst.reloc.exp.X_add_number = 12 * inst.operands[1].imm;
9092
9093       if (!(inst.instruction & INDEX_UP))
9094         inst.reloc.exp.X_add_number = -inst.reloc.exp.X_add_number;
9095
9096       if (!(inst.instruction & PRE_INDEX) && inst.operands[2].writeback)
9097         {
9098           inst.operands[2].preind = 0;
9099           inst.operands[2].postind = 1;
9100         }
9101     }
9102
9103   encode_arm_cp_address (2, TRUE, TRUE, 0);
9104 }
9105 \f
9106 /* iWMMXt instructions: strictly in alphabetical order.  */
9107
9108 static void
9109 do_iwmmxt_tandorc (void)
9110 {
9111   constraint (inst.operands[0].reg != REG_PC, _("only r15 allowed here"));
9112 }
9113
9114 static void
9115 do_iwmmxt_textrc (void)
9116 {
9117   inst.instruction |= inst.operands[0].reg << 12;
9118   inst.instruction |= inst.operands[1].imm;
9119 }
9120
9121 static void
9122 do_iwmmxt_textrm (void)
9123 {
9124   inst.instruction |= inst.operands[0].reg << 12;
9125   inst.instruction |= inst.operands[1].reg << 16;
9126   inst.instruction |= inst.operands[2].imm;
9127 }
9128
9129 static void
9130 do_iwmmxt_tinsr (void)
9131 {
9132   inst.instruction |= inst.operands[0].reg << 16;
9133   inst.instruction |= inst.operands[1].reg << 12;
9134   inst.instruction |= inst.operands[2].imm;
9135 }
9136
9137 static void
9138 do_iwmmxt_tmia (void)
9139 {
9140   inst.instruction |= inst.operands[0].reg << 5;
9141   inst.instruction |= inst.operands[1].reg;
9142   inst.instruction |= inst.operands[2].reg << 12;
9143 }
9144
9145 static void
9146 do_iwmmxt_waligni (void)
9147 {
9148   inst.instruction |= inst.operands[0].reg << 12;
9149   inst.instruction |= inst.operands[1].reg << 16;
9150   inst.instruction |= inst.operands[2].reg;
9151   inst.instruction |= inst.operands[3].imm << 20;
9152 }
9153
9154 static void
9155 do_iwmmxt_wmerge (void)
9156 {
9157   inst.instruction |= inst.operands[0].reg << 12;
9158   inst.instruction |= inst.operands[1].reg << 16;
9159   inst.instruction |= inst.operands[2].reg;
9160   inst.instruction |= inst.operands[3].imm << 21;
9161 }
9162
9163 static void
9164 do_iwmmxt_wmov (void)
9165 {
9166   /* WMOV rD, rN is an alias for WOR rD, rN, rN.  */
9167   inst.instruction |= inst.operands[0].reg << 12;
9168   inst.instruction |= inst.operands[1].reg << 16;
9169   inst.instruction |= inst.operands[1].reg;
9170 }
9171
9172 static void
9173 do_iwmmxt_wldstbh (void)
9174 {
9175   int reloc;
9176   inst.instruction |= inst.operands[0].reg << 12;
9177   if (thumb_mode)
9178     reloc = BFD_RELOC_ARM_T32_CP_OFF_IMM_S2;
9179   else
9180     reloc = BFD_RELOC_ARM_CP_OFF_IMM_S2;
9181   encode_arm_cp_address (1, TRUE, FALSE, reloc);
9182 }
9183
9184 static void
9185 do_iwmmxt_wldstw (void)
9186 {
9187   /* RIWR_RIWC clears .isreg for a control register.  */
9188   if (!inst.operands[0].isreg)
9189     {
9190       constraint (inst.cond != COND_ALWAYS, BAD_COND);
9191       inst.instruction |= 0xf0000000;
9192     }
9193
9194   inst.instruction |= inst.operands[0].reg << 12;
9195   encode_arm_cp_address (1, TRUE, TRUE, 0);
9196 }
9197
9198 static void
9199 do_iwmmxt_wldstd (void)
9200 {
9201   inst.instruction |= inst.operands[0].reg << 12;
9202   if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt2)
9203       && inst.operands[1].immisreg)
9204     {
9205       inst.instruction &= ~0x1a000ff;
9206       inst.instruction |= (0xf << 28);
9207       if (inst.operands[1].preind)
9208         inst.instruction |= PRE_INDEX;
9209       if (!inst.operands[1].negative)
9210         inst.instruction |= INDEX_UP;
9211       if (inst.operands[1].writeback)
9212         inst.instruction |= WRITE_BACK;
9213       inst.instruction |= inst.operands[1].reg << 16;
9214       inst.instruction |= inst.reloc.exp.X_add_number << 4;
9215       inst.instruction |= inst.operands[1].imm;
9216     }
9217   else
9218     encode_arm_cp_address (1, TRUE, FALSE, 0);
9219 }
9220
9221 static void
9222 do_iwmmxt_wshufh (void)
9223 {
9224   inst.instruction |= inst.operands[0].reg << 12;
9225   inst.instruction |= inst.operands[1].reg << 16;
9226   inst.instruction |= ((inst.operands[2].imm & 0xf0) << 16);
9227   inst.instruction |= (inst.operands[2].imm & 0x0f);
9228 }
9229
9230 static void
9231 do_iwmmxt_wzero (void)
9232 {
9233   /* WZERO reg is an alias for WANDN reg, reg, reg.  */
9234   inst.instruction |= inst.operands[0].reg;
9235   inst.instruction |= inst.operands[0].reg << 12;
9236   inst.instruction |= inst.operands[0].reg << 16;
9237 }
9238
9239 static void
9240 do_iwmmxt_wrwrwr_or_imm5 (void)
9241 {
9242   if (inst.operands[2].isreg)
9243     do_rd_rn_rm ();
9244   else {
9245     constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt2),
9246                 _("immediate operand requires iWMMXt2"));
9247     do_rd_rn ();
9248     if (inst.operands[2].imm == 0)
9249       {
9250         switch ((inst.instruction >> 20) & 0xf)
9251           {
9252           case 4:
9253           case 5:
9254           case 6:
9255           case 7:
9256             /* w...h wrd, wrn, #0 -> wrorh wrd, wrn, #16.  */
9257             inst.operands[2].imm = 16;
9258             inst.instruction = (inst.instruction & 0xff0fffff) | (0x7 << 20);
9259             break;
9260           case 8:
9261           case 9:
9262           case 10:
9263           case 11:
9264             /* w...w wrd, wrn, #0 -> wrorw wrd, wrn, #32.  */
9265             inst.operands[2].imm = 32;
9266             inst.instruction = (inst.instruction & 0xff0fffff) | (0xb << 20);
9267             break;
9268           case 12:
9269           case 13:
9270           case 14:
9271           case 15:
9272             {
9273               /* w...d wrd, wrn, #0 -> wor wrd, wrn, wrn.  */
9274               unsigned long wrn;
9275               wrn = (inst.instruction >> 16) & 0xf;
9276               inst.instruction &= 0xff0fff0f;
9277               inst.instruction |= wrn;
9278               /* Bail out here; the instruction is now assembled.  */
9279               return;
9280             }
9281           }
9282       }
9283     /* Map 32 -> 0, etc.  */
9284     inst.operands[2].imm &= 0x1f;
9285     inst.instruction |= (0xf << 28) | ((inst.operands[2].imm & 0x10) << 4) | (inst.operands[2].imm & 0xf);
9286   }
9287 }
9288 \f
9289 /* Cirrus Maverick instructions.  Simple 2-, 3-, and 4-register
9290    operations first, then control, shift, and load/store.  */
9291
9292 /* Insns like "foo X,Y,Z".  */
9293
9294 static void
9295 do_mav_triple (void)
9296 {
9297   inst.instruction |= inst.operands[0].reg << 16;
9298   inst.instruction |= inst.operands[1].reg;
9299   inst.instruction |= inst.operands[2].reg << 12;
9300 }
9301
9302 /* Insns like "foo W,X,Y,Z".
9303     where W=MVAX[0:3] and X,Y,Z=MVFX[0:15].  */
9304
9305 static void
9306 do_mav_quad (void)
9307 {
9308   inst.instruction |= inst.operands[0].reg << 5;
9309   inst.instruction |= inst.operands[1].reg << 12;
9310   inst.instruction |= inst.operands[2].reg << 16;
9311   inst.instruction |= inst.operands[3].reg;
9312 }
9313
9314 /* cfmvsc32<cond> DSPSC,MVDX[15:0].  */
9315 static void
9316 do_mav_dspsc (void)
9317 {
9318   inst.instruction |= inst.operands[1].reg << 12;
9319 }
9320
9321 /* Maverick shift immediate instructions.
9322    cfsh32<cond> MVFX[15:0],MVFX[15:0],Shift[6:0].
9323    cfsh64<cond> MVDX[15:0],MVDX[15:0],Shift[6:0].  */
9324
9325 static void
9326 do_mav_shift (void)
9327 {
9328   int imm = inst.operands[2].imm;
9329
9330   inst.instruction |= inst.operands[0].reg << 12;
9331   inst.instruction |= inst.operands[1].reg << 16;
9332
9333   /* Bits 0-3 of the insn should have bits 0-3 of the immediate.
9334      Bits 5-7 of the insn should have bits 4-6 of the immediate.
9335      Bit 4 should be 0.  */
9336   imm = (imm & 0xf) | ((imm & 0x70) << 1);
9337
9338   inst.instruction |= imm;
9339 }
9340 \f
9341 /* XScale instructions.  Also sorted arithmetic before move.  */
9342
9343 /* Xscale multiply-accumulate (argument parse)
9344      MIAcc   acc0,Rm,Rs
9345      MIAPHcc acc0,Rm,Rs
9346      MIAxycc acc0,Rm,Rs.  */
9347
9348 static void
9349 do_xsc_mia (void)
9350 {
9351   inst.instruction |= inst.operands[1].reg;
9352   inst.instruction |= inst.operands[2].reg << 12;
9353 }
9354
9355 /* Xscale move-accumulator-register (argument parse)
9356
9357      MARcc   acc0,RdLo,RdHi.  */
9358
9359 static void
9360 do_xsc_mar (void)
9361 {
9362   inst.instruction |= inst.operands[1].reg << 12;
9363   inst.instruction |= inst.operands[2].reg << 16;
9364 }
9365
9366 /* Xscale move-register-accumulator (argument parse)
9367
9368      MRAcc   RdLo,RdHi,acc0.  */
9369
9370 static void
9371 do_xsc_mra (void)
9372 {
9373   constraint (inst.operands[0].reg == inst.operands[1].reg, BAD_OVERLAP);
9374   inst.instruction |= inst.operands[0].reg << 12;
9375   inst.instruction |= inst.operands[1].reg << 16;
9376 }
9377 \f
9378 /* Encoding functions relevant only to Thumb.  */
9379
9380 /* inst.operands[i] is a shifted-register operand; encode
9381    it into inst.instruction in the format used by Thumb32.  */
9382
9383 static void
9384 encode_thumb32_shifted_operand (int i)
9385 {
9386   unsigned int value = inst.reloc.exp.X_add_number;
9387   unsigned int shift = inst.operands[i].shift_kind;
9388
9389   constraint (inst.operands[i].immisreg,
9390               _("shift by register not allowed in thumb mode"));
9391   inst.instruction |= inst.operands[i].reg;
9392   if (shift == SHIFT_RRX)
9393     inst.instruction |= SHIFT_ROR << 4;
9394   else
9395     {
9396       constraint (inst.reloc.exp.X_op != O_constant,
9397                   _("expression too complex"));
9398
9399       constraint (value > 32
9400                   || (value == 32 && (shift == SHIFT_LSL
9401                                       || shift == SHIFT_ROR)),
9402                   _("shift expression is too large"));
9403
9404       if (value == 0)
9405         shift = SHIFT_LSL;
9406       else if (value == 32)
9407         value = 0;
9408
9409       inst.instruction |= shift << 4;
9410       inst.instruction |= (value & 0x1c) << 10;
9411       inst.instruction |= (value & 0x03) << 6;
9412     }
9413 }
9414
9415
9416 /* inst.operands[i] was set up by parse_address.  Encode it into a
9417    Thumb32 format load or store instruction.  Reject forms that cannot
9418    be used with such instructions.  If is_t is true, reject forms that
9419    cannot be used with a T instruction; if is_d is true, reject forms
9420    that cannot be used with a D instruction.  If it is a store insn,
9421    reject PC in Rn.  */
9422
9423 static void
9424 encode_thumb32_addr_mode (int i, bfd_boolean is_t, bfd_boolean is_d)
9425 {
9426   const bfd_boolean is_pc = (inst.operands[i].reg == REG_PC);
9427
9428   constraint (!inst.operands[i].isreg,
9429               _("Instruction does not support =N addresses"));
9430
9431   inst.instruction |= inst.operands[i].reg << 16;
9432   if (inst.operands[i].immisreg)
9433     {
9434       constraint (is_pc, BAD_PC_ADDRESSING);
9435       constraint (is_t || is_d, _("cannot use register index with this instruction"));
9436       constraint (inst.operands[i].negative,
9437                   _("Thumb does not support negative register indexing"));
9438       constraint (inst.operands[i].postind,
9439                   _("Thumb does not support register post-indexing"));
9440       constraint (inst.operands[i].writeback,
9441                   _("Thumb does not support register indexing with writeback"));
9442       constraint (inst.operands[i].shifted && inst.operands[i].shift_kind != SHIFT_LSL,
9443                   _("Thumb supports only LSL in shifted register indexing"));
9444
9445       inst.instruction |= inst.operands[i].imm;
9446       if (inst.operands[i].shifted)
9447         {
9448           constraint (inst.reloc.exp.X_op != O_constant,
9449                       _("expression too complex"));
9450           constraint (inst.reloc.exp.X_add_number < 0
9451                       || inst.reloc.exp.X_add_number > 3,
9452                       _("shift out of range"));
9453           inst.instruction |= inst.reloc.exp.X_add_number << 4;
9454         }
9455       inst.reloc.type = BFD_RELOC_UNUSED;
9456     }
9457   else if (inst.operands[i].preind)
9458     {
9459       constraint (is_pc && inst.operands[i].writeback, BAD_PC_WRITEBACK);
9460       constraint (is_t && inst.operands[i].writeback,
9461                   _("cannot use writeback with this instruction"));
9462       constraint (is_pc && ((inst.instruction & THUMB2_LOAD_BIT) == 0)
9463                   && !inst.reloc.pc_rel, BAD_PC_ADDRESSING);
9464
9465       if (is_d)
9466         {
9467           inst.instruction |= 0x01000000;
9468           if (inst.operands[i].writeback)
9469             inst.instruction |= 0x00200000;
9470         }
9471       else
9472         {
9473           inst.instruction |= 0x00000c00;
9474           if (inst.operands[i].writeback)
9475             inst.instruction |= 0x00000100;
9476         }
9477       inst.reloc.type = BFD_RELOC_ARM_T32_OFFSET_IMM;
9478     }
9479   else if (inst.operands[i].postind)
9480     {
9481       gas_assert (inst.operands[i].writeback);
9482       constraint (is_pc, _("cannot use post-indexing with PC-relative addressing"));
9483       constraint (is_t, _("cannot use post-indexing with this instruction"));
9484
9485       if (is_d)
9486         inst.instruction |= 0x00200000;
9487       else
9488         inst.instruction |= 0x00000900;
9489       inst.reloc.type = BFD_RELOC_ARM_T32_OFFSET_IMM;
9490     }
9491   else /* unindexed - only for coprocessor */
9492     inst.error = _("instruction does not accept unindexed addressing");
9493 }
9494
9495 /* Table of Thumb instructions which exist in both 16- and 32-bit
9496    encodings (the latter only in post-V6T2 cores).  The index is the
9497    value used in the insns table below.  When there is more than one
9498    possible 16-bit encoding for the instruction, this table always
9499    holds variant (1).
9500    Also contains several pseudo-instructions used during relaxation.  */
9501 #define T16_32_TAB                              \
9502   X(_adc,   4140, eb400000),                    \
9503   X(_adcs,  4140, eb500000),                    \
9504   X(_add,   1c00, eb000000),                    \
9505   X(_adds,  1c00, eb100000),                    \
9506   X(_addi,  0000, f1000000),                    \
9507   X(_addis, 0000, f1100000),                    \
9508   X(_add_pc,000f, f20f0000),                    \
9509   X(_add_sp,000d, f10d0000),                    \
9510   X(_adr,   000f, f20f0000),                    \
9511   X(_and,   4000, ea000000),                    \
9512   X(_ands,  4000, ea100000),                    \
9513   X(_asr,   1000, fa40f000),                    \
9514   X(_asrs,  1000, fa50f000),                    \
9515   X(_b,     e000, f000b000),                    \
9516   X(_bcond, d000, f0008000),                    \
9517   X(_bic,   4380, ea200000),                    \
9518   X(_bics,  4380, ea300000),                    \
9519   X(_cmn,   42c0, eb100f00),                    \
9520   X(_cmp,   2800, ebb00f00),                    \
9521   X(_cpsie, b660, f3af8400),                    \
9522   X(_cpsid, b670, f3af8600),                    \
9523   X(_cpy,   4600, ea4f0000),                    \
9524   X(_dec_sp,80dd, f1ad0d00),                    \
9525   X(_eor,   4040, ea800000),                    \
9526   X(_eors,  4040, ea900000),                    \
9527   X(_inc_sp,00dd, f10d0d00),                    \
9528   X(_ldmia, c800, e8900000),                    \
9529   X(_ldr,   6800, f8500000),                    \
9530   X(_ldrb,  7800, f8100000),                    \
9531   X(_ldrh,  8800, f8300000),                    \
9532   X(_ldrsb, 5600, f9100000),                    \
9533   X(_ldrsh, 5e00, f9300000),                    \
9534   X(_ldr_pc,4800, f85f0000),                    \
9535   X(_ldr_pc2,4800, f85f0000),                   \
9536   X(_ldr_sp,9800, f85d0000),                    \
9537   X(_lsl,   0000, fa00f000),                    \
9538   X(_lsls,  0000, fa10f000),                    \
9539   X(_lsr,   0800, fa20f000),                    \
9540   X(_lsrs,  0800, fa30f000),                    \
9541   X(_mov,   2000, ea4f0000),                    \
9542   X(_movs,  2000, ea5f0000),                    \
9543   X(_mul,   4340, fb00f000),                     \
9544   X(_muls,  4340, ffffffff), /* no 32b muls */  \
9545   X(_mvn,   43c0, ea6f0000),                    \
9546   X(_mvns,  43c0, ea7f0000),                    \
9547   X(_neg,   4240, f1c00000), /* rsb #0 */       \
9548   X(_negs,  4240, f1d00000), /* rsbs #0 */      \
9549   X(_orr,   4300, ea400000),                    \
9550   X(_orrs,  4300, ea500000),                    \
9551   X(_pop,   bc00, e8bd0000), /* ldmia sp!,... */        \
9552   X(_push,  b400, e92d0000), /* stmdb sp!,... */        \
9553   X(_rev,   ba00, fa90f080),                    \
9554   X(_rev16, ba40, fa90f090),                    \
9555   X(_revsh, bac0, fa90f0b0),                    \
9556   X(_ror,   41c0, fa60f000),                    \
9557   X(_rors,  41c0, fa70f000),                    \
9558   X(_sbc,   4180, eb600000),                    \
9559   X(_sbcs,  4180, eb700000),                    \
9560   X(_stmia, c000, e8800000),                    \
9561   X(_str,   6000, f8400000),                    \
9562   X(_strb,  7000, f8000000),                    \
9563   X(_strh,  8000, f8200000),                    \
9564   X(_str_sp,9000, f84d0000),                    \
9565   X(_sub,   1e00, eba00000),                    \
9566   X(_subs,  1e00, ebb00000),                    \
9567   X(_subi,  8000, f1a00000),                    \
9568   X(_subis, 8000, f1b00000),                    \
9569   X(_sxtb,  b240, fa4ff080),                    \
9570   X(_sxth,  b200, fa0ff080),                    \
9571   X(_tst,   4200, ea100f00),                    \
9572   X(_uxtb,  b2c0, fa5ff080),                    \
9573   X(_uxth,  b280, fa1ff080),                    \
9574   X(_nop,   bf00, f3af8000),                    \
9575   X(_yield, bf10, f3af8001),                    \
9576   X(_wfe,   bf20, f3af8002),                    \
9577   X(_wfi,   bf30, f3af8003),                    \
9578   X(_sev,   bf40, f3af8004),                    \
9579   X(_sevl,  bf50, f3af8005)
9580
9581 /* To catch errors in encoding functions, the codes are all offset by
9582    0xF800, putting them in one of the 32-bit prefix ranges, ergo undefined
9583    as 16-bit instructions.  */
9584 #define X(a,b,c) T_MNEM##a
9585 enum t16_32_codes { T16_32_OFFSET = 0xF7FF, T16_32_TAB };
9586 #undef X
9587
9588 #define X(a,b,c) 0x##b
9589 static const unsigned short thumb_op16[] = { T16_32_TAB };
9590 #define THUMB_OP16(n) (thumb_op16[(n) - (T16_32_OFFSET + 1)])
9591 #undef X
9592
9593 #define X(a,b,c) 0x##c
9594 static const unsigned int thumb_op32[] = { T16_32_TAB };
9595 #define THUMB_OP32(n)        (thumb_op32[(n) - (T16_32_OFFSET + 1)])
9596 #define THUMB_SETS_FLAGS(n)  (THUMB_OP32 (n) & 0x00100000)
9597 #undef X
9598 #undef T16_32_TAB
9599
9600 /* Thumb instruction encoders, in alphabetical order.  */
9601
9602 /* ADDW or SUBW.  */
9603
9604 static void
9605 do_t_add_sub_w (void)
9606 {
9607   int Rd, Rn;
9608
9609   Rd = inst.operands[0].reg;
9610   Rn = inst.operands[1].reg;
9611
9612   /* If Rn is REG_PC, this is ADR; if Rn is REG_SP, then this
9613      is the SP-{plus,minus}-immediate form of the instruction.  */
9614   if (Rn == REG_SP)
9615     constraint (Rd == REG_PC, BAD_PC);
9616   else
9617     reject_bad_reg (Rd);
9618
9619   inst.instruction |= (Rn << 16) | (Rd << 8);
9620   inst.reloc.type = BFD_RELOC_ARM_T32_IMM12;
9621 }
9622
9623 /* Parse an add or subtract instruction.  We get here with inst.instruction
9624    equalling any of THUMB_OPCODE_add, adds, sub, or subs.  */
9625
9626 static void
9627 do_t_add_sub (void)
9628 {
9629   int Rd, Rs, Rn;
9630
9631   Rd = inst.operands[0].reg;
9632   Rs = (inst.operands[1].present
9633         ? inst.operands[1].reg    /* Rd, Rs, foo */
9634         : inst.operands[0].reg);  /* Rd, foo -> Rd, Rd, foo */
9635
9636   if (Rd == REG_PC)
9637     set_it_insn_type_last ();
9638
9639   if (unified_syntax)
9640     {
9641       bfd_boolean flags;
9642       bfd_boolean narrow;
9643       int opcode;
9644
9645       flags = (inst.instruction == T_MNEM_adds
9646                || inst.instruction == T_MNEM_subs);
9647       if (flags)
9648         narrow = !in_it_block ();
9649       else
9650         narrow = in_it_block ();
9651       if (!inst.operands[2].isreg)
9652         {
9653           int add;
9654
9655           constraint (Rd == REG_SP && Rs != REG_SP, BAD_SP);
9656
9657           add = (inst.instruction == T_MNEM_add
9658                  || inst.instruction == T_MNEM_adds);
9659           opcode = 0;
9660           if (inst.size_req != 4)
9661             {
9662               /* Attempt to use a narrow opcode, with relaxation if
9663                  appropriate.  */
9664               if (Rd == REG_SP && Rs == REG_SP && !flags)
9665                 opcode = add ? T_MNEM_inc_sp : T_MNEM_dec_sp;
9666               else if (Rd <= 7 && Rs == REG_SP && add && !flags)
9667                 opcode = T_MNEM_add_sp;
9668               else if (Rd <= 7 && Rs == REG_PC && add && !flags)
9669                 opcode = T_MNEM_add_pc;
9670               else if (Rd <= 7 && Rs <= 7 && narrow)
9671                 {
9672                   if (flags)
9673                     opcode = add ? T_MNEM_addis : T_MNEM_subis;
9674                   else
9675                     opcode = add ? T_MNEM_addi : T_MNEM_subi;
9676                 }
9677               if (opcode)
9678                 {
9679                   inst.instruction = THUMB_OP16(opcode);
9680                   inst.instruction |= (Rd << 4) | Rs;
9681                   inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
9682                   if (inst.size_req != 2)
9683                     inst.relax = opcode;
9684                 }
9685               else
9686                 constraint (inst.size_req == 2, BAD_HIREG);
9687             }
9688           if (inst.size_req == 4
9689               || (inst.size_req != 2 && !opcode))
9690             {
9691               if (Rd == REG_PC)
9692                 {
9693                   constraint (add, BAD_PC);
9694                   constraint (Rs != REG_LR || inst.instruction != T_MNEM_subs,
9695                              _("only SUBS PC, LR, #const allowed"));
9696                   constraint (inst.reloc.exp.X_op != O_constant,
9697                               _("expression too complex"));
9698                   constraint (inst.reloc.exp.X_add_number < 0
9699                               || inst.reloc.exp.X_add_number > 0xff,
9700                              _("immediate value out of range"));
9701                   inst.instruction = T2_SUBS_PC_LR
9702                                      | inst.reloc.exp.X_add_number;
9703                   inst.reloc.type = BFD_RELOC_UNUSED;
9704                   return;
9705                 }
9706               else if (Rs == REG_PC)
9707                 {
9708                   /* Always use addw/subw.  */
9709                   inst.instruction = add ? 0xf20f0000 : 0xf2af0000;
9710                   inst.reloc.type = BFD_RELOC_ARM_T32_IMM12;
9711                 }
9712               else
9713                 {
9714                   inst.instruction = THUMB_OP32 (inst.instruction);
9715                   inst.instruction = (inst.instruction & 0xe1ffffff)
9716                                      | 0x10000000;
9717                   if (flags)
9718                     inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
9719                   else
9720                     inst.reloc.type = BFD_RELOC_ARM_T32_ADD_IMM;
9721                 }
9722               inst.instruction |= Rd << 8;
9723               inst.instruction |= Rs << 16;
9724             }
9725         }
9726       else
9727         {
9728           unsigned int value = inst.reloc.exp.X_add_number;
9729           unsigned int shift = inst.operands[2].shift_kind;
9730
9731           Rn = inst.operands[2].reg;
9732           /* See if we can do this with a 16-bit instruction.  */
9733           if (!inst.operands[2].shifted && inst.size_req != 4)
9734             {
9735               if (Rd > 7 || Rs > 7 || Rn > 7)
9736                 narrow = FALSE;
9737
9738               if (narrow)
9739                 {
9740                   inst.instruction = ((inst.instruction == T_MNEM_adds
9741                                        || inst.instruction == T_MNEM_add)
9742                                       ? T_OPCODE_ADD_R3
9743                                       : T_OPCODE_SUB_R3);
9744                   inst.instruction |= Rd | (Rs << 3) | (Rn << 6);
9745                   return;
9746                 }
9747
9748               if (inst.instruction == T_MNEM_add && (Rd == Rs || Rd == Rn))
9749                 {
9750                   /* Thumb-1 cores (except v6-M) require at least one high
9751                      register in a narrow non flag setting add.  */
9752                   if (Rd > 7 || Rn > 7
9753                       || ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6t2)
9754                       || ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_msr))
9755                     {
9756                       if (Rd == Rn)
9757                         {
9758                           Rn = Rs;
9759                           Rs = Rd;
9760                         }
9761                       inst.instruction = T_OPCODE_ADD_HI;
9762                       inst.instruction |= (Rd & 8) << 4;
9763                       inst.instruction |= (Rd & 7);
9764                       inst.instruction |= Rn << 3;
9765                       return;
9766                     }
9767                 }
9768             }
9769
9770           constraint (Rd == REG_PC, BAD_PC);
9771           constraint (Rd == REG_SP && Rs != REG_SP, BAD_SP);
9772           constraint (Rs == REG_PC, BAD_PC);
9773           reject_bad_reg (Rn);
9774
9775           /* If we get here, it can't be done in 16 bits.  */
9776           constraint (inst.operands[2].shifted && inst.operands[2].immisreg,
9777                       _("shift must be constant"));
9778           inst.instruction = THUMB_OP32 (inst.instruction);
9779           inst.instruction |= Rd << 8;
9780           inst.instruction |= Rs << 16;
9781           constraint (Rd == REG_SP && Rs == REG_SP && value > 3,
9782                       _("shift value over 3 not allowed in thumb mode"));
9783           constraint (Rd == REG_SP && Rs == REG_SP && shift != SHIFT_LSL,
9784                       _("only LSL shift allowed in thumb mode"));
9785           encode_thumb32_shifted_operand (2);
9786         }
9787     }
9788   else
9789     {
9790       constraint (inst.instruction == T_MNEM_adds
9791                   || inst.instruction == T_MNEM_subs,
9792                   BAD_THUMB32);
9793
9794       if (!inst.operands[2].isreg) /* Rd, Rs, #imm */
9795         {
9796           constraint ((Rd > 7 && (Rd != REG_SP || Rs != REG_SP))
9797                       || (Rs > 7 && Rs != REG_SP && Rs != REG_PC),
9798                       BAD_HIREG);
9799
9800           inst.instruction = (inst.instruction == T_MNEM_add
9801                               ? 0x0000 : 0x8000);
9802           inst.instruction |= (Rd << 4) | Rs;
9803           inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
9804           return;
9805         }
9806
9807       Rn = inst.operands[2].reg;
9808       constraint (inst.operands[2].shifted, _("unshifted register required"));
9809
9810       /* We now have Rd, Rs, and Rn set to registers.  */
9811       if (Rd > 7 || Rs > 7 || Rn > 7)
9812         {
9813           /* Can't do this for SUB.      */
9814           constraint (inst.instruction == T_MNEM_sub, BAD_HIREG);
9815           inst.instruction = T_OPCODE_ADD_HI;
9816           inst.instruction |= (Rd & 8) << 4;
9817           inst.instruction |= (Rd & 7);
9818           if (Rs == Rd)
9819             inst.instruction |= Rn << 3;
9820           else if (Rn == Rd)
9821             inst.instruction |= Rs << 3;
9822           else
9823             constraint (1, _("dest must overlap one source register"));
9824         }
9825       else
9826         {
9827           inst.instruction = (inst.instruction == T_MNEM_add
9828                               ? T_OPCODE_ADD_R3 : T_OPCODE_SUB_R3);
9829           inst.instruction |= Rd | (Rs << 3) | (Rn << 6);
9830         }
9831     }
9832 }
9833
9834 static void
9835 do_t_adr (void)
9836 {
9837   unsigned Rd;
9838
9839   Rd = inst.operands[0].reg;
9840   reject_bad_reg (Rd);
9841
9842   if (unified_syntax && inst.size_req == 0 && Rd <= 7)
9843     {
9844       /* Defer to section relaxation.  */
9845       inst.relax = inst.instruction;
9846       inst.instruction = THUMB_OP16 (inst.instruction);
9847       inst.instruction |= Rd << 4;
9848     }
9849   else if (unified_syntax && inst.size_req != 2)
9850     {
9851       /* Generate a 32-bit opcode.  */
9852       inst.instruction = THUMB_OP32 (inst.instruction);
9853       inst.instruction |= Rd << 8;
9854       inst.reloc.type = BFD_RELOC_ARM_T32_ADD_PC12;
9855       inst.reloc.pc_rel = 1;
9856     }
9857   else
9858     {
9859       /* Generate a 16-bit opcode.  */
9860       inst.instruction = THUMB_OP16 (inst.instruction);
9861       inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
9862       inst.reloc.exp.X_add_number -= 4; /* PC relative adjust.  */
9863       inst.reloc.pc_rel = 1;
9864
9865       inst.instruction |= Rd << 4;
9866     }
9867 }
9868
9869 /* Arithmetic instructions for which there is just one 16-bit
9870    instruction encoding, and it allows only two low registers.
9871    For maximal compatibility with ARM syntax, we allow three register
9872    operands even when Thumb-32 instructions are not available, as long
9873    as the first two are identical.  For instance, both "sbc r0,r1" and
9874    "sbc r0,r0,r1" are allowed.  */
9875 static void
9876 do_t_arit3 (void)
9877 {
9878   int Rd, Rs, Rn;
9879
9880   Rd = inst.operands[0].reg;
9881   Rs = (inst.operands[1].present
9882         ? inst.operands[1].reg    /* Rd, Rs, foo */
9883         : inst.operands[0].reg);  /* Rd, foo -> Rd, Rd, foo */
9884   Rn = inst.operands[2].reg;
9885
9886   reject_bad_reg (Rd);
9887   reject_bad_reg (Rs);
9888   if (inst.operands[2].isreg)
9889     reject_bad_reg (Rn);
9890
9891   if (unified_syntax)
9892     {
9893       if (!inst.operands[2].isreg)
9894         {
9895           /* For an immediate, we always generate a 32-bit opcode;
9896              section relaxation will shrink it later if possible.  */
9897           inst.instruction = THUMB_OP32 (inst.instruction);
9898           inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
9899           inst.instruction |= Rd << 8;
9900           inst.instruction |= Rs << 16;
9901           inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
9902         }
9903       else
9904         {
9905           bfd_boolean narrow;
9906
9907           /* See if we can do this with a 16-bit instruction.  */
9908           if (THUMB_SETS_FLAGS (inst.instruction))
9909             narrow = !in_it_block ();
9910           else
9911             narrow = in_it_block ();
9912
9913           if (Rd > 7 || Rn > 7 || Rs > 7)
9914             narrow = FALSE;
9915           if (inst.operands[2].shifted)
9916             narrow = FALSE;
9917           if (inst.size_req == 4)
9918             narrow = FALSE;
9919
9920           if (narrow
9921               && Rd == Rs)
9922             {
9923               inst.instruction = THUMB_OP16 (inst.instruction);
9924               inst.instruction |= Rd;
9925               inst.instruction |= Rn << 3;
9926               return;
9927             }
9928
9929           /* If we get here, it can't be done in 16 bits.  */
9930           constraint (inst.operands[2].shifted
9931                       && inst.operands[2].immisreg,
9932                       _("shift must be constant"));
9933           inst.instruction = THUMB_OP32 (inst.instruction);
9934           inst.instruction |= Rd << 8;
9935           inst.instruction |= Rs << 16;
9936           encode_thumb32_shifted_operand (2);
9937         }
9938     }
9939   else
9940     {
9941       /* On its face this is a lie - the instruction does set the
9942          flags.  However, the only supported mnemonic in this mode
9943          says it doesn't.  */
9944       constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
9945
9946       constraint (!inst.operands[2].isreg || inst.operands[2].shifted,
9947                   _("unshifted register required"));
9948       constraint (Rd > 7 || Rs > 7 || Rn > 7, BAD_HIREG);
9949       constraint (Rd != Rs,
9950                   _("dest and source1 must be the same register"));
9951
9952       inst.instruction = THUMB_OP16 (inst.instruction);
9953       inst.instruction |= Rd;
9954       inst.instruction |= Rn << 3;
9955     }
9956 }
9957
9958 /* Similarly, but for instructions where the arithmetic operation is
9959    commutative, so we can allow either of them to be different from
9960    the destination operand in a 16-bit instruction.  For instance, all
9961    three of "adc r0,r1", "adc r0,r0,r1", and "adc r0,r1,r0" are
9962    accepted.  */
9963 static void
9964 do_t_arit3c (void)
9965 {
9966   int Rd, Rs, Rn;
9967
9968   Rd = inst.operands[0].reg;
9969   Rs = (inst.operands[1].present
9970         ? inst.operands[1].reg    /* Rd, Rs, foo */
9971         : inst.operands[0].reg);  /* Rd, foo -> Rd, Rd, foo */
9972   Rn = inst.operands[2].reg;
9973
9974   reject_bad_reg (Rd);
9975   reject_bad_reg (Rs);
9976   if (inst.operands[2].isreg)
9977     reject_bad_reg (Rn);
9978
9979   if (unified_syntax)
9980     {
9981       if (!inst.operands[2].isreg)
9982         {
9983           /* For an immediate, we always generate a 32-bit opcode;
9984              section relaxation will shrink it later if possible.  */
9985           inst.instruction = THUMB_OP32 (inst.instruction);
9986           inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
9987           inst.instruction |= Rd << 8;
9988           inst.instruction |= Rs << 16;
9989           inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
9990         }
9991       else
9992         {
9993           bfd_boolean narrow;
9994
9995           /* See if we can do this with a 16-bit instruction.  */
9996           if (THUMB_SETS_FLAGS (inst.instruction))
9997             narrow = !in_it_block ();
9998           else
9999             narrow = in_it_block ();
10000
10001           if (Rd > 7 || Rn > 7 || Rs > 7)
10002             narrow = FALSE;
10003           if (inst.operands[2].shifted)
10004             narrow = FALSE;
10005           if (inst.size_req == 4)
10006             narrow = FALSE;
10007
10008           if (narrow)
10009             {
10010               if (Rd == Rs)
10011                 {
10012                   inst.instruction = THUMB_OP16 (inst.instruction);
10013                   inst.instruction |= Rd;
10014                   inst.instruction |= Rn << 3;
10015                   return;
10016                 }
10017               if (Rd == Rn)
10018                 {
10019                   inst.instruction = THUMB_OP16 (inst.instruction);
10020                   inst.instruction |= Rd;
10021                   inst.instruction |= Rs << 3;
10022                   return;
10023                 }
10024             }
10025
10026           /* If we get here, it can't be done in 16 bits.  */
10027           constraint (inst.operands[2].shifted
10028                       && inst.operands[2].immisreg,
10029                       _("shift must be constant"));
10030           inst.instruction = THUMB_OP32 (inst.instruction);
10031           inst.instruction |= Rd << 8;
10032           inst.instruction |= Rs << 16;
10033           encode_thumb32_shifted_operand (2);
10034         }
10035     }
10036   else
10037     {
10038       /* On its face this is a lie - the instruction does set the
10039          flags.  However, the only supported mnemonic in this mode
10040          says it doesn't.  */
10041       constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
10042
10043       constraint (!inst.operands[2].isreg || inst.operands[2].shifted,
10044                   _("unshifted register required"));
10045       constraint (Rd > 7 || Rs > 7 || Rn > 7, BAD_HIREG);
10046
10047       inst.instruction = THUMB_OP16 (inst.instruction);
10048       inst.instruction |= Rd;
10049
10050       if (Rd == Rs)
10051         inst.instruction |= Rn << 3;
10052       else if (Rd == Rn)
10053         inst.instruction |= Rs << 3;
10054       else
10055         constraint (1, _("dest must overlap one source register"));
10056     }
10057 }
10058
10059 static void
10060 do_t_barrier (void)
10061 {
10062   if (inst.operands[0].present)
10063     {
10064       constraint ((inst.instruction & 0xf0) != 0x40
10065                   && inst.operands[0].imm > 0xf
10066                   && inst.operands[0].imm < 0x0,
10067                   _("bad barrier type"));
10068       inst.instruction |= inst.operands[0].imm;
10069     }
10070   else
10071     inst.instruction |= 0xf;
10072 }
10073
10074 static void
10075 do_t_bfc (void)
10076 {
10077   unsigned Rd;
10078   unsigned int msb = inst.operands[1].imm + inst.operands[2].imm;
10079   constraint (msb > 32, _("bit-field extends past end of register"));
10080   /* The instruction encoding stores the LSB and MSB,
10081      not the LSB and width.  */
10082   Rd = inst.operands[0].reg;
10083   reject_bad_reg (Rd);
10084   inst.instruction |= Rd << 8;
10085   inst.instruction |= (inst.operands[1].imm & 0x1c) << 10;
10086   inst.instruction |= (inst.operands[1].imm & 0x03) << 6;
10087   inst.instruction |= msb - 1;
10088 }
10089
10090 static void
10091 do_t_bfi (void)
10092 {
10093   int Rd, Rn;
10094   unsigned int msb;
10095
10096   Rd = inst.operands[0].reg;
10097   reject_bad_reg (Rd);
10098
10099   /* #0 in second position is alternative syntax for bfc, which is
10100      the same instruction but with REG_PC in the Rm field.  */
10101   if (!inst.operands[1].isreg)
10102     Rn = REG_PC;
10103   else
10104     {
10105       Rn = inst.operands[1].reg;
10106       reject_bad_reg (Rn);
10107     }
10108
10109   msb = inst.operands[2].imm + inst.operands[3].imm;
10110   constraint (msb > 32, _("bit-field extends past end of register"));
10111   /* The instruction encoding stores the LSB and MSB,
10112      not the LSB and width.  */
10113   inst.instruction |= Rd << 8;
10114   inst.instruction |= Rn << 16;
10115   inst.instruction |= (inst.operands[2].imm & 0x1c) << 10;
10116   inst.instruction |= (inst.operands[2].imm & 0x03) << 6;
10117   inst.instruction |= msb - 1;
10118 }
10119
10120 static void
10121 do_t_bfx (void)
10122 {
10123   unsigned Rd, Rn;
10124
10125   Rd = inst.operands[0].reg;
10126   Rn = inst.operands[1].reg;
10127
10128   reject_bad_reg (Rd);
10129   reject_bad_reg (Rn);
10130
10131   constraint (inst.operands[2].imm + inst.operands[3].imm > 32,
10132               _("bit-field extends past end of register"));
10133   inst.instruction |= Rd << 8;
10134   inst.instruction |= Rn << 16;
10135   inst.instruction |= (inst.operands[2].imm & 0x1c) << 10;
10136   inst.instruction |= (inst.operands[2].imm & 0x03) << 6;
10137   inst.instruction |= inst.operands[3].imm - 1;
10138 }
10139
10140 /* ARM V5 Thumb BLX (argument parse)
10141         BLX <target_addr>       which is BLX(1)
10142         BLX <Rm>                which is BLX(2)
10143    Unfortunately, there are two different opcodes for this mnemonic.
10144    So, the insns[].value is not used, and the code here zaps values
10145         into inst.instruction.
10146
10147    ??? How to take advantage of the additional two bits of displacement
10148    available in Thumb32 mode?  Need new relocation?  */
10149
10150 static void
10151 do_t_blx (void)
10152 {
10153   set_it_insn_type_last ();
10154
10155   if (inst.operands[0].isreg)
10156     {
10157       constraint (inst.operands[0].reg == REG_PC, BAD_PC);
10158       /* We have a register, so this is BLX(2).  */
10159       inst.instruction |= inst.operands[0].reg << 3;
10160     }
10161   else
10162     {
10163       /* No register.  This must be BLX(1).  */
10164       inst.instruction = 0xf000e800;
10165       encode_branch (BFD_RELOC_THUMB_PCREL_BLX);
10166     }
10167 }
10168
10169 static void
10170 do_t_branch (void)
10171 {
10172   int opcode;
10173   int cond;
10174   int reloc;
10175
10176   cond = inst.cond;
10177   set_it_insn_type (IF_INSIDE_IT_LAST_INSN);
10178
10179   if (in_it_block ())
10180     {
10181       /* Conditional branches inside IT blocks are encoded as unconditional
10182          branches.  */
10183       cond = COND_ALWAYS;
10184     }
10185   else
10186     cond = inst.cond;
10187
10188   if (cond != COND_ALWAYS)
10189     opcode = T_MNEM_bcond;
10190   else
10191     opcode = inst.instruction;
10192
10193   if (unified_syntax
10194       && (inst.size_req == 4
10195           || (inst.size_req != 2
10196               && (inst.operands[0].hasreloc
10197                   || inst.reloc.exp.X_op == O_constant))))
10198     {
10199       inst.instruction = THUMB_OP32(opcode);
10200       if (cond == COND_ALWAYS)
10201         reloc = BFD_RELOC_THUMB_PCREL_BRANCH25;
10202       else
10203         {
10204           gas_assert (cond != 0xF);
10205           inst.instruction |= cond << 22;
10206           reloc = BFD_RELOC_THUMB_PCREL_BRANCH20;
10207         }
10208     }
10209   else
10210     {
10211       inst.instruction = THUMB_OP16(opcode);
10212       if (cond == COND_ALWAYS)
10213         reloc = BFD_RELOC_THUMB_PCREL_BRANCH12;
10214       else
10215         {
10216           inst.instruction |= cond << 8;
10217           reloc = BFD_RELOC_THUMB_PCREL_BRANCH9;
10218         }
10219       /* Allow section relaxation.  */
10220       if (unified_syntax && inst.size_req != 2)
10221         inst.relax = opcode;
10222     }
10223   inst.reloc.type = reloc;
10224   inst.reloc.pc_rel = 1;
10225 }
10226
10227 /* Actually do the work for Thumb state bkpt and hlt.  The only difference
10228    between the two is the maximum immediate allowed - which is passed in 
10229    RANGE.  */
10230 static void
10231 do_t_bkpt_hlt1 (int range)
10232 {
10233   constraint (inst.cond != COND_ALWAYS,
10234               _("instruction is always unconditional"));
10235   if (inst.operands[0].present)
10236     {
10237       constraint (inst.operands[0].imm > range,
10238                   _("immediate value out of range"));
10239       inst.instruction |= inst.operands[0].imm;
10240     }
10241
10242   set_it_insn_type (NEUTRAL_IT_INSN);
10243 }
10244
10245 static void
10246 do_t_hlt (void)
10247 {
10248   do_t_bkpt_hlt1 (63);
10249 }
10250
10251 static void
10252 do_t_bkpt (void)
10253 {
10254   do_t_bkpt_hlt1 (255);
10255 }
10256
10257 static void
10258 do_t_branch23 (void)
10259 {
10260   set_it_insn_type_last ();
10261   encode_branch (BFD_RELOC_THUMB_PCREL_BRANCH23);
10262
10263   /* md_apply_fix blows up with 'bl foo(PLT)' where foo is defined in
10264      this file.  We used to simply ignore the PLT reloc type here --
10265      the branch encoding is now needed to deal with TLSCALL relocs.
10266      So if we see a PLT reloc now, put it back to how it used to be to
10267      keep the preexisting behaviour.  */
10268   if (inst.reloc.type == BFD_RELOC_ARM_PLT32)
10269     inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH23;
10270
10271 #if defined(OBJ_COFF)
10272   /* If the destination of the branch is a defined symbol which does not have
10273      the THUMB_FUNC attribute, then we must be calling a function which has
10274      the (interfacearm) attribute.  We look for the Thumb entry point to that
10275      function and change the branch to refer to that function instead.  */
10276   if (   inst.reloc.exp.X_op == O_symbol
10277       && inst.reloc.exp.X_add_symbol != NULL
10278       && S_IS_DEFINED (inst.reloc.exp.X_add_symbol)
10279       && ! THUMB_IS_FUNC (inst.reloc.exp.X_add_symbol))
10280     inst.reloc.exp.X_add_symbol =
10281       find_real_start (inst.reloc.exp.X_add_symbol);
10282 #endif
10283 }
10284
10285 static void
10286 do_t_bx (void)
10287 {
10288   set_it_insn_type_last ();
10289   inst.instruction |= inst.operands[0].reg << 3;
10290   /* ??? FIXME: Should add a hacky reloc here if reg is REG_PC.  The reloc
10291      should cause the alignment to be checked once it is known.  This is
10292      because BX PC only works if the instruction is word aligned.  */
10293 }
10294
10295 static void
10296 do_t_bxj (void)
10297 {
10298   int Rm;
10299
10300   set_it_insn_type_last ();
10301   Rm = inst.operands[0].reg;
10302   reject_bad_reg (Rm);
10303   inst.instruction |= Rm << 16;
10304 }
10305
10306 static void
10307 do_t_clz (void)
10308 {
10309   unsigned Rd;
10310   unsigned Rm;
10311
10312   Rd = inst.operands[0].reg;
10313   Rm = inst.operands[1].reg;
10314
10315   reject_bad_reg (Rd);
10316   reject_bad_reg (Rm);
10317
10318   inst.instruction |= Rd << 8;
10319   inst.instruction |= Rm << 16;
10320   inst.instruction |= Rm;
10321 }
10322
10323 static void
10324 do_t_cps (void)
10325 {
10326   set_it_insn_type (OUTSIDE_IT_INSN);
10327   inst.instruction |= inst.operands[0].imm;
10328 }
10329
10330 static void
10331 do_t_cpsi (void)
10332 {
10333   set_it_insn_type (OUTSIDE_IT_INSN);
10334   if (unified_syntax
10335       && (inst.operands[1].present || inst.size_req == 4)
10336       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6_notm))
10337     {
10338       unsigned int imod = (inst.instruction & 0x0030) >> 4;
10339       inst.instruction = 0xf3af8000;
10340       inst.instruction |= imod << 9;
10341       inst.instruction |= inst.operands[0].imm << 5;
10342       if (inst.operands[1].present)
10343         inst.instruction |= 0x100 | inst.operands[1].imm;
10344     }
10345   else
10346     {
10347       constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1)
10348                   && (inst.operands[0].imm & 4),
10349                   _("selected processor does not support 'A' form "
10350                     "of this instruction"));
10351       constraint (inst.operands[1].present || inst.size_req == 4,
10352                   _("Thumb does not support the 2-argument "
10353                     "form of this instruction"));
10354       inst.instruction |= inst.operands[0].imm;
10355     }
10356 }
10357
10358 /* THUMB CPY instruction (argument parse).  */
10359
10360 static void
10361 do_t_cpy (void)
10362 {
10363   if (inst.size_req == 4)
10364     {
10365       inst.instruction = THUMB_OP32 (T_MNEM_mov);
10366       inst.instruction |= inst.operands[0].reg << 8;
10367       inst.instruction |= inst.operands[1].reg;
10368     }
10369   else
10370     {
10371       inst.instruction |= (inst.operands[0].reg & 0x8) << 4;
10372       inst.instruction |= (inst.operands[0].reg & 0x7);
10373       inst.instruction |= inst.operands[1].reg << 3;
10374     }
10375 }
10376
10377 static void
10378 do_t_cbz (void)
10379 {
10380   set_it_insn_type (OUTSIDE_IT_INSN);
10381   constraint (inst.operands[0].reg > 7, BAD_HIREG);
10382   inst.instruction |= inst.operands[0].reg;
10383   inst.reloc.pc_rel = 1;
10384   inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH7;
10385 }
10386
10387 static void
10388 do_t_dbg (void)
10389 {
10390   inst.instruction |= inst.operands[0].imm;
10391 }
10392
10393 static void
10394 do_t_div (void)
10395 {
10396   unsigned Rd, Rn, Rm;
10397
10398   Rd = inst.operands[0].reg;
10399   Rn = (inst.operands[1].present
10400         ? inst.operands[1].reg : Rd);
10401   Rm = inst.operands[2].reg;
10402
10403   reject_bad_reg (Rd);
10404   reject_bad_reg (Rn);
10405   reject_bad_reg (Rm);
10406
10407   inst.instruction |= Rd << 8;
10408   inst.instruction |= Rn << 16;
10409   inst.instruction |= Rm;
10410 }
10411
10412 static void
10413 do_t_hint (void)
10414 {
10415   if (unified_syntax && inst.size_req == 4)
10416     inst.instruction = THUMB_OP32 (inst.instruction);
10417   else
10418     inst.instruction = THUMB_OP16 (inst.instruction);
10419 }
10420
10421 static void
10422 do_t_it (void)
10423 {
10424   unsigned int cond = inst.operands[0].imm;
10425
10426   set_it_insn_type (IT_INSN);
10427   now_it.mask = (inst.instruction & 0xf) | 0x10;
10428   now_it.cc = cond;
10429   now_it.warn_deprecated = FALSE;
10430
10431   /* If the condition is a negative condition, invert the mask.  */
10432   if ((cond & 0x1) == 0x0)
10433     {
10434       unsigned int mask = inst.instruction & 0x000f;
10435
10436       if ((mask & 0x7) == 0)
10437         {
10438           /* No conversion needed.  */
10439           now_it.block_length = 1;
10440         }
10441       else if ((mask & 0x3) == 0)
10442         {
10443           mask ^= 0x8;
10444           now_it.block_length = 2;
10445         }
10446       else if ((mask & 0x1) == 0)
10447         {
10448           mask ^= 0xC;
10449           now_it.block_length = 3;
10450         }
10451       else
10452         {
10453           mask ^= 0xE;
10454           now_it.block_length = 4;
10455         }
10456
10457       inst.instruction &= 0xfff0;
10458       inst.instruction |= mask;
10459     }
10460
10461   inst.instruction |= cond << 4;
10462 }
10463
10464 /* Helper function used for both push/pop and ldm/stm.  */
10465 static void
10466 encode_thumb2_ldmstm (int base, unsigned mask, bfd_boolean writeback)
10467 {
10468   bfd_boolean load;
10469
10470   load = (inst.instruction & (1 << 20)) != 0;
10471
10472   if (mask & (1 << 13))
10473     inst.error =  _("SP not allowed in register list");
10474
10475   if ((mask & (1 << base)) != 0
10476       && writeback)
10477     inst.error = _("having the base register in the register list when "
10478                    "using write back is UNPREDICTABLE");
10479
10480   if (load)
10481     {
10482       if (mask & (1 << 15))
10483         {
10484           if (mask & (1 << 14))
10485             inst.error = _("LR and PC should not both be in register list");
10486           else
10487             set_it_insn_type_last ();
10488         }
10489     }
10490   else
10491     {
10492       if (mask & (1 << 15))
10493         inst.error = _("PC not allowed in register list");
10494     }
10495
10496   if ((mask & (mask - 1)) == 0)
10497     {
10498       /* Single register transfers implemented as str/ldr.  */
10499       if (writeback)
10500         {
10501           if (inst.instruction & (1 << 23))
10502             inst.instruction = 0x00000b04; /* ia! -> [base], #4 */
10503           else
10504             inst.instruction = 0x00000d04; /* db! -> [base, #-4]! */
10505         }
10506       else
10507         {
10508           if (inst.instruction & (1 << 23))
10509             inst.instruction = 0x00800000; /* ia -> [base] */
10510           else
10511             inst.instruction = 0x00000c04; /* db -> [base, #-4] */
10512         }
10513
10514       inst.instruction |= 0xf8400000;
10515       if (load)
10516         inst.instruction |= 0x00100000;
10517
10518       mask = ffs (mask) - 1;
10519       mask <<= 12;
10520     }
10521   else if (writeback)
10522     inst.instruction |= WRITE_BACK;
10523
10524   inst.instruction |= mask;
10525   inst.instruction |= base << 16;
10526 }
10527
10528 static void
10529 do_t_ldmstm (void)
10530 {
10531   /* This really doesn't seem worth it.  */
10532   constraint (inst.reloc.type != BFD_RELOC_UNUSED,
10533               _("expression too complex"));
10534   constraint (inst.operands[1].writeback,
10535               _("Thumb load/store multiple does not support {reglist}^"));
10536
10537   if (unified_syntax)
10538     {
10539       bfd_boolean narrow;
10540       unsigned mask;
10541
10542       narrow = FALSE;
10543       /* See if we can use a 16-bit instruction.  */
10544       if (inst.instruction < 0xffff /* not ldmdb/stmdb */
10545           && inst.size_req != 4
10546           && !(inst.operands[1].imm & ~0xff))
10547         {
10548           mask = 1 << inst.operands[0].reg;
10549
10550           if (inst.operands[0].reg <= 7)
10551             {
10552               if (inst.instruction == T_MNEM_stmia
10553                   ? inst.operands[0].writeback
10554                   : (inst.operands[0].writeback
10555                      == !(inst.operands[1].imm & mask)))
10556                 {
10557                   if (inst.instruction == T_MNEM_stmia
10558                       && (inst.operands[1].imm & mask)
10559                       && (inst.operands[1].imm & (mask - 1)))
10560                     as_warn (_("value stored for r%d is UNKNOWN"),
10561                              inst.operands[0].reg);
10562
10563                   inst.instruction = THUMB_OP16 (inst.instruction);
10564                   inst.instruction |= inst.operands[0].reg << 8;
10565                   inst.instruction |= inst.operands[1].imm;
10566                   narrow = TRUE;
10567                 }
10568               else if ((inst.operands[1].imm & (inst.operands[1].imm-1)) == 0)
10569                 {
10570                   /* This means 1 register in reg list one of 3 situations:
10571                      1. Instruction is stmia, but without writeback.
10572                      2. lmdia without writeback, but with Rn not in
10573                         reglist.
10574                      3. ldmia with writeback, but with Rn in reglist.
10575                      Case 3 is UNPREDICTABLE behaviour, so we handle
10576                      case 1 and 2 which can be converted into a 16-bit
10577                      str or ldr. The SP cases are handled below.  */
10578                   unsigned long opcode;
10579                   /* First, record an error for Case 3.  */
10580                   if (inst.operands[1].imm & mask
10581                       && inst.operands[0].writeback)
10582                     inst.error =
10583                         _("having the base register in the register list when "
10584                           "using write back is UNPREDICTABLE");
10585
10586                   opcode = (inst.instruction == T_MNEM_stmia ? T_MNEM_str
10587                                                              : T_MNEM_ldr);
10588                   inst.instruction = THUMB_OP16 (opcode);
10589                   inst.instruction |= inst.operands[0].reg << 3;
10590                   inst.instruction |= (ffs (inst.operands[1].imm)-1);
10591                   narrow = TRUE;
10592                 }
10593             }
10594           else if (inst.operands[0] .reg == REG_SP)
10595             {
10596               if (inst.operands[0].writeback)
10597                 {
10598                   inst.instruction =
10599                         THUMB_OP16 (inst.instruction == T_MNEM_stmia
10600                                     ? T_MNEM_push : T_MNEM_pop);
10601                   inst.instruction |= inst.operands[1].imm;
10602                   narrow = TRUE;
10603                 }
10604               else if ((inst.operands[1].imm & (inst.operands[1].imm-1)) == 0)
10605                 {
10606                   inst.instruction =
10607                         THUMB_OP16 (inst.instruction == T_MNEM_stmia
10608                                     ? T_MNEM_str_sp : T_MNEM_ldr_sp);
10609                   inst.instruction |= ((ffs (inst.operands[1].imm)-1) << 8);
10610                   narrow = TRUE;
10611                 }
10612             }
10613         }
10614
10615       if (!narrow)
10616         {
10617           if (inst.instruction < 0xffff)
10618             inst.instruction = THUMB_OP32 (inst.instruction);
10619
10620           encode_thumb2_ldmstm (inst.operands[0].reg, inst.operands[1].imm,
10621                                 inst.operands[0].writeback);
10622         }
10623     }
10624   else
10625     {
10626       constraint (inst.operands[0].reg > 7
10627                   || (inst.operands[1].imm & ~0xff), BAD_HIREG);
10628       constraint (inst.instruction != T_MNEM_ldmia
10629                   && inst.instruction != T_MNEM_stmia,
10630                   _("Thumb-2 instruction only valid in unified syntax"));
10631       if (inst.instruction == T_MNEM_stmia)
10632         {
10633           if (!inst.operands[0].writeback)
10634             as_warn (_("this instruction will write back the base register"));
10635           if ((inst.operands[1].imm & (1 << inst.operands[0].reg))
10636               && (inst.operands[1].imm & ((1 << inst.operands[0].reg) - 1)))
10637             as_warn (_("value stored for r%d is UNKNOWN"),
10638                      inst.operands[0].reg);
10639         }
10640       else
10641         {
10642           if (!inst.operands[0].writeback
10643               && !(inst.operands[1].imm & (1 << inst.operands[0].reg)))
10644             as_warn (_("this instruction will write back the base register"));
10645           else if (inst.operands[0].writeback
10646                    && (inst.operands[1].imm & (1 << inst.operands[0].reg)))
10647             as_warn (_("this instruction will not write back the base register"));
10648         }
10649
10650       inst.instruction = THUMB_OP16 (inst.instruction);
10651       inst.instruction |= inst.operands[0].reg << 8;
10652       inst.instruction |= inst.operands[1].imm;
10653     }
10654 }
10655
10656 static void
10657 do_t_ldrex (void)
10658 {
10659   constraint (!inst.operands[1].isreg || !inst.operands[1].preind
10660               || inst.operands[1].postind || inst.operands[1].writeback
10661               || inst.operands[1].immisreg || inst.operands[1].shifted
10662               || inst.operands[1].negative,
10663               BAD_ADDR_MODE);
10664
10665   constraint ((inst.operands[1].reg == REG_PC), BAD_PC);
10666
10667   inst.instruction |= inst.operands[0].reg << 12;
10668   inst.instruction |= inst.operands[1].reg << 16;
10669   inst.reloc.type = BFD_RELOC_ARM_T32_OFFSET_U8;
10670 }
10671
10672 static void
10673 do_t_ldrexd (void)
10674 {
10675   if (!inst.operands[1].present)
10676     {
10677       constraint (inst.operands[0].reg == REG_LR,
10678                   _("r14 not allowed as first register "
10679                     "when second register is omitted"));
10680       inst.operands[1].reg = inst.operands[0].reg + 1;
10681     }
10682   constraint (inst.operands[0].reg == inst.operands[1].reg,
10683               BAD_OVERLAP);
10684
10685   inst.instruction |= inst.operands[0].reg << 12;
10686   inst.instruction |= inst.operands[1].reg << 8;
10687   inst.instruction |= inst.operands[2].reg << 16;
10688 }
10689
10690 static void
10691 do_t_ldst (void)
10692 {
10693   unsigned long opcode;
10694   int Rn;
10695
10696   if (inst.operands[0].isreg
10697       && !inst.operands[0].preind
10698       && inst.operands[0].reg == REG_PC)
10699     set_it_insn_type_last ();
10700
10701   opcode = inst.instruction;
10702   if (unified_syntax)
10703     {
10704       if (!inst.operands[1].isreg)
10705         {
10706           if (opcode <= 0xffff)
10707             inst.instruction = THUMB_OP32 (opcode);
10708           if (move_or_literal_pool (0, /*thumb_p=*/TRUE, /*mode_3=*/FALSE))
10709             return;
10710         }
10711       if (inst.operands[1].isreg
10712           && !inst.operands[1].writeback
10713           && !inst.operands[1].shifted && !inst.operands[1].postind
10714           && !inst.operands[1].negative && inst.operands[0].reg <= 7
10715           && opcode <= 0xffff
10716           && inst.size_req != 4)
10717         {
10718           /* Insn may have a 16-bit form.  */
10719           Rn = inst.operands[1].reg;
10720           if (inst.operands[1].immisreg)
10721             {
10722               inst.instruction = THUMB_OP16 (opcode);
10723               /* [Rn, Rik] */
10724               if (Rn <= 7 && inst.operands[1].imm <= 7)
10725                 goto op16;
10726               else if (opcode != T_MNEM_ldr && opcode != T_MNEM_str)
10727                 reject_bad_reg (inst.operands[1].imm);
10728             }
10729           else if ((Rn <= 7 && opcode != T_MNEM_ldrsh
10730                     && opcode != T_MNEM_ldrsb)
10731                    || ((Rn == REG_PC || Rn == REG_SP) && opcode == T_MNEM_ldr)
10732                    || (Rn == REG_SP && opcode == T_MNEM_str))
10733             {
10734               /* [Rn, #const] */
10735               if (Rn > 7)
10736                 {
10737                   if (Rn == REG_PC)
10738                     {
10739                       if (inst.reloc.pc_rel)
10740                         opcode = T_MNEM_ldr_pc2;
10741                       else
10742                         opcode = T_MNEM_ldr_pc;
10743                     }
10744                   else
10745                     {
10746                       if (opcode == T_MNEM_ldr)
10747                         opcode = T_MNEM_ldr_sp;
10748                       else
10749                         opcode = T_MNEM_str_sp;
10750                     }
10751                   inst.instruction = inst.operands[0].reg << 8;
10752                 }
10753               else
10754                 {
10755                   inst.instruction = inst.operands[0].reg;
10756                   inst.instruction |= inst.operands[1].reg << 3;
10757                 }
10758               inst.instruction |= THUMB_OP16 (opcode);
10759               if (inst.size_req == 2)
10760                 inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
10761               else
10762                 inst.relax = opcode;
10763               return;
10764             }
10765         }
10766       /* Definitely a 32-bit variant.  */
10767
10768       /* Warning for Erratum 752419.  */
10769       if (opcode == T_MNEM_ldr
10770           && inst.operands[0].reg == REG_SP
10771           && inst.operands[1].writeback == 1
10772           && !inst.operands[1].immisreg)
10773         {
10774           if (no_cpu_selected ()
10775               || (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7)
10776                   && !ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7a)
10777                   && !ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7r)))
10778             as_warn (_("This instruction may be unpredictable "
10779                        "if executed on M-profile cores "
10780                        "with interrupts enabled."));
10781         }
10782
10783       /* Do some validations regarding addressing modes.  */
10784       if (inst.operands[1].immisreg)
10785         reject_bad_reg (inst.operands[1].imm);
10786
10787       constraint (inst.operands[1].writeback == 1
10788                   && inst.operands[0].reg == inst.operands[1].reg,
10789                   BAD_OVERLAP);
10790
10791       inst.instruction = THUMB_OP32 (opcode);
10792       inst.instruction |= inst.operands[0].reg << 12;
10793       encode_thumb32_addr_mode (1, /*is_t=*/FALSE, /*is_d=*/FALSE);
10794       check_ldr_r15_aligned ();
10795       return;
10796     }
10797
10798   constraint (inst.operands[0].reg > 7, BAD_HIREG);
10799
10800   if (inst.instruction == T_MNEM_ldrsh || inst.instruction == T_MNEM_ldrsb)
10801     {
10802       /* Only [Rn,Rm] is acceptable.  */
10803       constraint (inst.operands[1].reg > 7 || inst.operands[1].imm > 7, BAD_HIREG);
10804       constraint (!inst.operands[1].isreg || !inst.operands[1].immisreg
10805                   || inst.operands[1].postind || inst.operands[1].shifted
10806                   || inst.operands[1].negative,
10807                   _("Thumb does not support this addressing mode"));
10808       inst.instruction = THUMB_OP16 (inst.instruction);
10809       goto op16;
10810     }
10811
10812   inst.instruction = THUMB_OP16 (inst.instruction);
10813   if (!inst.operands[1].isreg)
10814     if (move_or_literal_pool (0, /*thumb_p=*/TRUE, /*mode_3=*/FALSE))
10815       return;
10816
10817   constraint (!inst.operands[1].preind
10818               || inst.operands[1].shifted
10819               || inst.operands[1].writeback,
10820               _("Thumb does not support this addressing mode"));
10821   if (inst.operands[1].reg == REG_PC || inst.operands[1].reg == REG_SP)
10822     {
10823       constraint (inst.instruction & 0x0600,
10824                   _("byte or halfword not valid for base register"));
10825       constraint (inst.operands[1].reg == REG_PC
10826                   && !(inst.instruction & THUMB_LOAD_BIT),
10827                   _("r15 based store not allowed"));
10828       constraint (inst.operands[1].immisreg,
10829                   _("invalid base register for register offset"));
10830
10831       if (inst.operands[1].reg == REG_PC)
10832         inst.instruction = T_OPCODE_LDR_PC;
10833       else if (inst.instruction & THUMB_LOAD_BIT)
10834         inst.instruction = T_OPCODE_LDR_SP;
10835       else
10836         inst.instruction = T_OPCODE_STR_SP;
10837
10838       inst.instruction |= inst.operands[0].reg << 8;
10839       inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
10840       return;
10841     }
10842
10843   constraint (inst.operands[1].reg > 7, BAD_HIREG);
10844   if (!inst.operands[1].immisreg)
10845     {
10846       /* Immediate offset.  */
10847       inst.instruction |= inst.operands[0].reg;
10848       inst.instruction |= inst.operands[1].reg << 3;
10849       inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
10850       return;
10851     }
10852
10853   /* Register offset.  */
10854   constraint (inst.operands[1].imm > 7, BAD_HIREG);
10855   constraint (inst.operands[1].negative,
10856               _("Thumb does not support this addressing mode"));
10857
10858  op16:
10859   switch (inst.instruction)
10860     {
10861     case T_OPCODE_STR_IW: inst.instruction = T_OPCODE_STR_RW; break;
10862     case T_OPCODE_STR_IH: inst.instruction = T_OPCODE_STR_RH; break;
10863     case T_OPCODE_STR_IB: inst.instruction = T_OPCODE_STR_RB; break;
10864     case T_OPCODE_LDR_IW: inst.instruction = T_OPCODE_LDR_RW; break;
10865     case T_OPCODE_LDR_IH: inst.instruction = T_OPCODE_LDR_RH; break;
10866     case T_OPCODE_LDR_IB: inst.instruction = T_OPCODE_LDR_RB; break;
10867     case 0x5600 /* ldrsb */:
10868     case 0x5e00 /* ldrsh */: break;
10869     default: abort ();
10870     }
10871
10872   inst.instruction |= inst.operands[0].reg;
10873   inst.instruction |= inst.operands[1].reg << 3;
10874   inst.instruction |= inst.operands[1].imm << 6;
10875 }
10876
10877 static void
10878 do_t_ldstd (void)
10879 {
10880   if (!inst.operands[1].present)
10881     {
10882       inst.operands[1].reg = inst.operands[0].reg + 1;
10883       constraint (inst.operands[0].reg == REG_LR,
10884                   _("r14 not allowed here"));
10885       constraint (inst.operands[0].reg == REG_R12,
10886                   _("r12 not allowed here"));
10887     }
10888
10889   if (inst.operands[2].writeback
10890       && (inst.operands[0].reg == inst.operands[2].reg
10891       || inst.operands[1].reg == inst.operands[2].reg))
10892     as_warn (_("base register written back, and overlaps "
10893                "one of transfer registers"));
10894
10895   inst.instruction |= inst.operands[0].reg << 12;
10896   inst.instruction |= inst.operands[1].reg << 8;
10897   encode_thumb32_addr_mode (2, /*is_t=*/FALSE, /*is_d=*/TRUE);
10898 }
10899
10900 static void
10901 do_t_ldstt (void)
10902 {
10903   inst.instruction |= inst.operands[0].reg << 12;
10904   encode_thumb32_addr_mode (1, /*is_t=*/TRUE, /*is_d=*/FALSE);
10905 }
10906
10907 static void
10908 do_t_mla (void)
10909 {
10910   unsigned Rd, Rn, Rm, Ra;
10911
10912   Rd = inst.operands[0].reg;
10913   Rn = inst.operands[1].reg;
10914   Rm = inst.operands[2].reg;
10915   Ra = inst.operands[3].reg;
10916
10917   reject_bad_reg (Rd);
10918   reject_bad_reg (Rn);
10919   reject_bad_reg (Rm);
10920   reject_bad_reg (Ra);
10921
10922   inst.instruction |= Rd << 8;
10923   inst.instruction |= Rn << 16;
10924   inst.instruction |= Rm;
10925   inst.instruction |= Ra << 12;
10926 }
10927
10928 static void
10929 do_t_mlal (void)
10930 {
10931   unsigned RdLo, RdHi, Rn, Rm;
10932
10933   RdLo = inst.operands[0].reg;
10934   RdHi = inst.operands[1].reg;
10935   Rn = inst.operands[2].reg;
10936   Rm = inst.operands[3].reg;
10937
10938   reject_bad_reg (RdLo);
10939   reject_bad_reg (RdHi);
10940   reject_bad_reg (Rn);
10941   reject_bad_reg (Rm);
10942
10943   inst.instruction |= RdLo << 12;
10944   inst.instruction |= RdHi << 8;
10945   inst.instruction |= Rn << 16;
10946   inst.instruction |= Rm;
10947 }
10948
10949 static void
10950 do_t_mov_cmp (void)
10951 {
10952   unsigned Rn, Rm;
10953
10954   Rn = inst.operands[0].reg;
10955   Rm = inst.operands[1].reg;
10956
10957   if (Rn == REG_PC)
10958     set_it_insn_type_last ();
10959
10960   if (unified_syntax)
10961     {
10962       int r0off = (inst.instruction == T_MNEM_mov
10963                    || inst.instruction == T_MNEM_movs) ? 8 : 16;
10964       unsigned long opcode;
10965       bfd_boolean narrow;
10966       bfd_boolean low_regs;
10967
10968       low_regs = (Rn <= 7 && Rm <= 7);
10969       opcode = inst.instruction;
10970       if (in_it_block ())
10971         narrow = opcode != T_MNEM_movs;
10972       else
10973         narrow = opcode != T_MNEM_movs || low_regs;
10974       if (inst.size_req == 4
10975           || inst.operands[1].shifted)
10976         narrow = FALSE;
10977
10978       /* MOVS PC, LR is encoded as SUBS PC, LR, #0.  */
10979       if (opcode == T_MNEM_movs && inst.operands[1].isreg
10980           && !inst.operands[1].shifted
10981           && Rn == REG_PC
10982           && Rm == REG_LR)
10983         {
10984           inst.instruction = T2_SUBS_PC_LR;
10985           return;
10986         }
10987
10988       if (opcode == T_MNEM_cmp)
10989         {
10990           constraint (Rn == REG_PC, BAD_PC);
10991           if (narrow)
10992             {
10993               /* In the Thumb-2 ISA, use of R13 as Rm is deprecated,
10994                  but valid.  */
10995               warn_deprecated_sp (Rm);
10996               /* R15 was documented as a valid choice for Rm in ARMv6,
10997                  but as UNPREDICTABLE in ARMv7.  ARM's proprietary
10998                  tools reject R15, so we do too.  */
10999               constraint (Rm == REG_PC, BAD_PC);
11000             }
11001           else
11002             reject_bad_reg (Rm);
11003         }
11004       else if (opcode == T_MNEM_mov
11005                || opcode == T_MNEM_movs)
11006         {
11007           if (inst.operands[1].isreg)
11008             {
11009               if (opcode == T_MNEM_movs)
11010                 {
11011                   reject_bad_reg (Rn);
11012                   reject_bad_reg (Rm);
11013                 }
11014               else if (narrow)
11015                 {
11016                   /* This is mov.n.  */
11017                   if ((Rn == REG_SP || Rn == REG_PC)
11018                       && (Rm == REG_SP || Rm == REG_PC))
11019                     {
11020                       as_warn (_("Use of r%u as a source register is "
11021                                  "deprecated when r%u is the destination "
11022                                  "register."), Rm, Rn);
11023                     }
11024                 }
11025               else
11026                 {
11027                   /* This is mov.w.  */
11028                   constraint (Rn == REG_PC, BAD_PC);
11029                   constraint (Rm == REG_PC, BAD_PC);
11030                   constraint (Rn == REG_SP && Rm == REG_SP, BAD_SP);
11031                 }
11032             }
11033           else
11034             reject_bad_reg (Rn);
11035         }
11036
11037       if (!inst.operands[1].isreg)
11038         {
11039           /* Immediate operand.  */
11040           if (!in_it_block () && opcode == T_MNEM_mov)
11041             narrow = 0;
11042           if (low_regs && narrow)
11043             {
11044               inst.instruction = THUMB_OP16 (opcode);
11045               inst.instruction |= Rn << 8;
11046               if (inst.size_req == 2)
11047                 inst.reloc.type = BFD_RELOC_ARM_THUMB_IMM;
11048               else
11049                 inst.relax = opcode;
11050             }
11051           else
11052             {
11053               inst.instruction = THUMB_OP32 (inst.instruction);
11054               inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
11055               inst.instruction |= Rn << r0off;
11056               inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
11057             }
11058         }
11059       else if (inst.operands[1].shifted && inst.operands[1].immisreg
11060                && (inst.instruction == T_MNEM_mov
11061                    || inst.instruction == T_MNEM_movs))
11062         {
11063           /* Register shifts are encoded as separate shift instructions.  */
11064           bfd_boolean flags = (inst.instruction == T_MNEM_movs);
11065
11066           if (in_it_block ())
11067             narrow = !flags;
11068           else
11069             narrow = flags;
11070
11071           if (inst.size_req == 4)
11072             narrow = FALSE;
11073
11074           if (!low_regs || inst.operands[1].imm > 7)
11075             narrow = FALSE;
11076
11077           if (Rn != Rm)
11078             narrow = FALSE;
11079
11080           switch (inst.operands[1].shift_kind)
11081             {
11082             case SHIFT_LSL:
11083               opcode = narrow ? T_OPCODE_LSL_R : THUMB_OP32 (T_MNEM_lsl);
11084               break;
11085             case SHIFT_ASR:
11086               opcode = narrow ? T_OPCODE_ASR_R : THUMB_OP32 (T_MNEM_asr);
11087               break;
11088             case SHIFT_LSR:
11089               opcode = narrow ? T_OPCODE_LSR_R : THUMB_OP32 (T_MNEM_lsr);
11090               break;
11091             case SHIFT_ROR:
11092               opcode = narrow ? T_OPCODE_ROR_R : THUMB_OP32 (T_MNEM_ror);
11093               break;
11094             default:
11095               abort ();
11096             }
11097
11098           inst.instruction = opcode;
11099           if (narrow)
11100             {
11101               inst.instruction |= Rn;
11102               inst.instruction |= inst.operands[1].imm << 3;
11103             }
11104           else
11105             {
11106               if (flags)
11107                 inst.instruction |= CONDS_BIT;
11108
11109               inst.instruction |= Rn << 8;
11110               inst.instruction |= Rm << 16;
11111               inst.instruction |= inst.operands[1].imm;
11112             }
11113         }
11114       else if (!narrow)
11115         {
11116           /* Some mov with immediate shift have narrow variants.
11117              Register shifts are handled above.  */
11118           if (low_regs && inst.operands[1].shifted
11119               && (inst.instruction == T_MNEM_mov
11120                   || inst.instruction == T_MNEM_movs))
11121             {
11122               if (in_it_block ())
11123                 narrow = (inst.instruction == T_MNEM_mov);
11124               else
11125                 narrow = (inst.instruction == T_MNEM_movs);
11126             }
11127
11128           if (narrow)
11129             {
11130               switch (inst.operands[1].shift_kind)
11131                 {
11132                 case SHIFT_LSL: inst.instruction = T_OPCODE_LSL_I; break;
11133                 case SHIFT_LSR: inst.instruction = T_OPCODE_LSR_I; break;
11134                 case SHIFT_ASR: inst.instruction = T_OPCODE_ASR_I; break;
11135                 default: narrow = FALSE; break;
11136                 }
11137             }
11138
11139           if (narrow)
11140             {
11141               inst.instruction |= Rn;
11142               inst.instruction |= Rm << 3;
11143               inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
11144             }
11145           else
11146             {
11147               inst.instruction = THUMB_OP32 (inst.instruction);
11148               inst.instruction |= Rn << r0off;
11149               encode_thumb32_shifted_operand (1);
11150             }
11151         }
11152       else
11153         switch (inst.instruction)
11154           {
11155           case T_MNEM_mov:
11156             /* In v4t or v5t a move of two lowregs produces unpredictable
11157                results. Don't allow this.  */
11158             if (low_regs)
11159               {
11160                 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6),
11161                             "MOV Rd, Rs with two low registers is not "
11162                             "permitted on this architecture");
11163                 ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
11164                                         arm_ext_v6);
11165               }
11166
11167             inst.instruction = T_OPCODE_MOV_HR;
11168             inst.instruction |= (Rn & 0x8) << 4;
11169             inst.instruction |= (Rn & 0x7);
11170             inst.instruction |= Rm << 3;
11171             break;
11172
11173           case T_MNEM_movs:
11174             /* We know we have low registers at this point.
11175                Generate LSLS Rd, Rs, #0.  */
11176             inst.instruction = T_OPCODE_LSL_I;
11177             inst.instruction |= Rn;
11178             inst.instruction |= Rm << 3;
11179             break;
11180
11181           case T_MNEM_cmp:
11182             if (low_regs)
11183               {
11184                 inst.instruction = T_OPCODE_CMP_LR;
11185                 inst.instruction |= Rn;
11186                 inst.instruction |= Rm << 3;
11187               }
11188             else
11189               {
11190                 inst.instruction = T_OPCODE_CMP_HR;
11191                 inst.instruction |= (Rn & 0x8) << 4;
11192                 inst.instruction |= (Rn & 0x7);
11193                 inst.instruction |= Rm << 3;
11194               }
11195             break;
11196           }
11197       return;
11198     }
11199
11200   inst.instruction = THUMB_OP16 (inst.instruction);
11201
11202   /* PR 10443: Do not silently ignore shifted operands.  */
11203   constraint (inst.operands[1].shifted,
11204               _("shifts in CMP/MOV instructions are only supported in unified syntax"));
11205
11206   if (inst.operands[1].isreg)
11207     {
11208       if (Rn < 8 && Rm < 8)
11209         {
11210           /* A move of two lowregs is encoded as ADD Rd, Rs, #0
11211              since a MOV instruction produces unpredictable results.  */
11212           if (inst.instruction == T_OPCODE_MOV_I8)
11213             inst.instruction = T_OPCODE_ADD_I3;
11214           else
11215             inst.instruction = T_OPCODE_CMP_LR;
11216
11217           inst.instruction |= Rn;
11218           inst.instruction |= Rm << 3;
11219         }
11220       else
11221         {
11222           if (inst.instruction == T_OPCODE_MOV_I8)
11223             inst.instruction = T_OPCODE_MOV_HR;
11224           else
11225             inst.instruction = T_OPCODE_CMP_HR;
11226           do_t_cpy ();
11227         }
11228     }
11229   else
11230     {
11231       constraint (Rn > 7,
11232                   _("only lo regs allowed with immediate"));
11233       inst.instruction |= Rn << 8;
11234       inst.reloc.type = BFD_RELOC_ARM_THUMB_IMM;
11235     }
11236 }
11237
11238 static void
11239 do_t_mov16 (void)
11240 {
11241   unsigned Rd;
11242   bfd_vma imm;
11243   bfd_boolean top;
11244
11245   top = (inst.instruction & 0x00800000) != 0;
11246   if (inst.reloc.type == BFD_RELOC_ARM_MOVW)
11247     {
11248       constraint (top, _(":lower16: not allowed this instruction"));
11249       inst.reloc.type = BFD_RELOC_ARM_THUMB_MOVW;
11250     }
11251   else if (inst.reloc.type == BFD_RELOC_ARM_MOVT)
11252     {
11253       constraint (!top, _(":upper16: not allowed this instruction"));
11254       inst.reloc.type = BFD_RELOC_ARM_THUMB_MOVT;
11255     }
11256
11257   Rd = inst.operands[0].reg;
11258   reject_bad_reg (Rd);
11259
11260   inst.instruction |= Rd << 8;
11261   if (inst.reloc.type == BFD_RELOC_UNUSED)
11262     {
11263       imm = inst.reloc.exp.X_add_number;
11264       inst.instruction |= (imm & 0xf000) << 4;
11265       inst.instruction |= (imm & 0x0800) << 15;
11266       inst.instruction |= (imm & 0x0700) << 4;
11267       inst.instruction |= (imm & 0x00ff);
11268     }
11269 }
11270
11271 static void
11272 do_t_mvn_tst (void)
11273 {
11274   unsigned Rn, Rm;
11275
11276   Rn = inst.operands[0].reg;
11277   Rm = inst.operands[1].reg;
11278
11279   if (inst.instruction == T_MNEM_cmp
11280       || inst.instruction == T_MNEM_cmn)
11281     constraint (Rn == REG_PC, BAD_PC);
11282   else
11283     reject_bad_reg (Rn);
11284   reject_bad_reg (Rm);
11285
11286   if (unified_syntax)
11287     {
11288       int r0off = (inst.instruction == T_MNEM_mvn
11289                    || inst.instruction == T_MNEM_mvns) ? 8 : 16;
11290       bfd_boolean narrow;
11291
11292       if (inst.size_req == 4
11293           || inst.instruction > 0xffff
11294           || inst.operands[1].shifted
11295           || Rn > 7 || Rm > 7)
11296         narrow = FALSE;
11297       else if (inst.instruction == T_MNEM_cmn)
11298         narrow = TRUE;
11299       else if (THUMB_SETS_FLAGS (inst.instruction))
11300         narrow = !in_it_block ();
11301       else
11302         narrow = in_it_block ();
11303
11304       if (!inst.operands[1].isreg)
11305         {
11306           /* For an immediate, we always generate a 32-bit opcode;
11307              section relaxation will shrink it later if possible.  */
11308           if (inst.instruction < 0xffff)
11309             inst.instruction = THUMB_OP32 (inst.instruction);
11310           inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
11311           inst.instruction |= Rn << r0off;
11312           inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
11313         }
11314       else
11315         {
11316           /* See if we can do this with a 16-bit instruction.  */
11317           if (narrow)
11318             {
11319               inst.instruction = THUMB_OP16 (inst.instruction);
11320               inst.instruction |= Rn;
11321               inst.instruction |= Rm << 3;
11322             }
11323           else
11324             {
11325               constraint (inst.operands[1].shifted
11326                           && inst.operands[1].immisreg,
11327                           _("shift must be constant"));
11328               if (inst.instruction < 0xffff)
11329                 inst.instruction = THUMB_OP32 (inst.instruction);
11330               inst.instruction |= Rn << r0off;
11331               encode_thumb32_shifted_operand (1);
11332             }
11333         }
11334     }
11335   else
11336     {
11337       constraint (inst.instruction > 0xffff
11338                   || inst.instruction == T_MNEM_mvns, BAD_THUMB32);
11339       constraint (!inst.operands[1].isreg || inst.operands[1].shifted,
11340                   _("unshifted register required"));
11341       constraint (Rn > 7 || Rm > 7,
11342                   BAD_HIREG);
11343
11344       inst.instruction = THUMB_OP16 (inst.instruction);
11345       inst.instruction |= Rn;
11346       inst.instruction |= Rm << 3;
11347     }
11348 }
11349
11350 static void
11351 do_t_mrs (void)
11352 {
11353   unsigned Rd;
11354
11355   if (do_vfp_nsyn_mrs () == SUCCESS)
11356     return;
11357
11358   Rd = inst.operands[0].reg;
11359   reject_bad_reg (Rd);
11360   inst.instruction |= Rd << 8;
11361
11362   if (inst.operands[1].isreg)
11363     {
11364       unsigned br = inst.operands[1].reg;
11365       if (((br & 0x200) == 0) && ((br & 0xf000) != 0xf000))
11366         as_bad (_("bad register for mrs"));
11367
11368       inst.instruction |= br & (0xf << 16);
11369       inst.instruction |= (br & 0x300) >> 4;
11370       inst.instruction |= (br & SPSR_BIT) >> 2;
11371     }
11372   else
11373     {
11374       int flags = inst.operands[1].imm & (PSR_c|PSR_x|PSR_s|PSR_f|SPSR_BIT);
11375
11376       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_m))
11377         {
11378           /* PR gas/12698:  The constraint is only applied for m_profile.
11379              If the user has specified -march=all, we want to ignore it as
11380              we are building for any CPU type, including non-m variants.  */
11381           bfd_boolean m_profile = selected_cpu.core != arm_arch_any.core;
11382           constraint ((flags != 0) && m_profile, _("selected processor does "
11383                                                    "not support requested special purpose register"));
11384         }
11385       else
11386         /* mrs only accepts APSR/CPSR/SPSR/CPSR_all/SPSR_all (for non-M profile
11387            devices).  */
11388         constraint ((flags & ~SPSR_BIT) != (PSR_c|PSR_f),
11389                     _("'APSR', 'CPSR' or 'SPSR' expected"));
11390
11391       inst.instruction |= (flags & SPSR_BIT) >> 2;
11392       inst.instruction |= inst.operands[1].imm & 0xff;
11393       inst.instruction |= 0xf0000;
11394     }
11395 }
11396
11397 static void
11398 do_t_msr (void)
11399 {
11400   int flags;
11401   unsigned Rn;
11402
11403   if (do_vfp_nsyn_msr () == SUCCESS)
11404     return;
11405
11406   constraint (!inst.operands[1].isreg,
11407               _("Thumb encoding does not support an immediate here"));
11408
11409   if (inst.operands[0].isreg)
11410     flags = (int)(inst.operands[0].reg);
11411   else
11412     flags = inst.operands[0].imm;
11413
11414   if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_m))
11415     {
11416       int bits = inst.operands[0].imm & (PSR_c|PSR_x|PSR_s|PSR_f|SPSR_BIT);
11417
11418       /* PR gas/12698:  The constraint is only applied for m_profile.
11419          If the user has specified -march=all, we want to ignore it as
11420          we are building for any CPU type, including non-m variants.  */
11421       bfd_boolean m_profile = selected_cpu.core != arm_arch_any.core;
11422       constraint (((ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6_dsp)
11423            && (bits & ~(PSR_s | PSR_f)) != 0)
11424           || (!ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6_dsp)
11425               && bits != PSR_f)) && m_profile,
11426           _("selected processor does not support requested special "
11427             "purpose register"));
11428     }
11429   else
11430      constraint ((flags & 0xff) != 0, _("selected processor does not support "
11431                  "requested special purpose register"));
11432
11433   Rn = inst.operands[1].reg;
11434   reject_bad_reg (Rn);
11435
11436   inst.instruction |= (flags & SPSR_BIT) >> 2;
11437   inst.instruction |= (flags & 0xf0000) >> 8;
11438   inst.instruction |= (flags & 0x300) >> 4;
11439   inst.instruction |= (flags & 0xff);
11440   inst.instruction |= Rn << 16;
11441 }
11442
11443 static void
11444 do_t_mul (void)
11445 {
11446   bfd_boolean narrow;
11447   unsigned Rd, Rn, Rm;
11448
11449   if (!inst.operands[2].present)
11450     inst.operands[2].reg = inst.operands[0].reg;
11451
11452   Rd = inst.operands[0].reg;
11453   Rn = inst.operands[1].reg;
11454   Rm = inst.operands[2].reg;
11455
11456   if (unified_syntax)
11457     {
11458       if (inst.size_req == 4
11459           || (Rd != Rn
11460               && Rd != Rm)
11461           || Rn > 7
11462           || Rm > 7)
11463         narrow = FALSE;
11464       else if (inst.instruction == T_MNEM_muls)
11465         narrow = !in_it_block ();
11466       else
11467         narrow = in_it_block ();
11468     }
11469   else
11470     {
11471       constraint (inst.instruction == T_MNEM_muls, BAD_THUMB32);
11472       constraint (Rn > 7 || Rm > 7,
11473                   BAD_HIREG);
11474       narrow = TRUE;
11475     }
11476
11477   if (narrow)
11478     {
11479       /* 16-bit MULS/Conditional MUL.  */
11480       inst.instruction = THUMB_OP16 (inst.instruction);
11481       inst.instruction |= Rd;
11482
11483       if (Rd == Rn)
11484         inst.instruction |= Rm << 3;
11485       else if (Rd == Rm)
11486         inst.instruction |= Rn << 3;
11487       else
11488         constraint (1, _("dest must overlap one source register"));
11489     }
11490   else
11491     {
11492       constraint (inst.instruction != T_MNEM_mul,
11493                   _("Thumb-2 MUL must not set flags"));
11494       /* 32-bit MUL.  */
11495       inst.instruction = THUMB_OP32 (inst.instruction);
11496       inst.instruction |= Rd << 8;
11497       inst.instruction |= Rn << 16;
11498       inst.instruction |= Rm << 0;
11499
11500       reject_bad_reg (Rd);
11501       reject_bad_reg (Rn);
11502       reject_bad_reg (Rm);
11503     }
11504 }
11505
11506 static void
11507 do_t_mull (void)
11508 {
11509   unsigned RdLo, RdHi, Rn, Rm;
11510
11511   RdLo = inst.operands[0].reg;
11512   RdHi = inst.operands[1].reg;
11513   Rn = inst.operands[2].reg;
11514   Rm = inst.operands[3].reg;
11515
11516   reject_bad_reg (RdLo);
11517   reject_bad_reg (RdHi);
11518   reject_bad_reg (Rn);
11519   reject_bad_reg (Rm);
11520
11521   inst.instruction |= RdLo << 12;
11522   inst.instruction |= RdHi << 8;
11523   inst.instruction |= Rn << 16;
11524   inst.instruction |= Rm;
11525
11526  if (RdLo == RdHi)
11527     as_tsktsk (_("rdhi and rdlo must be different"));
11528 }
11529
11530 static void
11531 do_t_nop (void)
11532 {
11533   set_it_insn_type (NEUTRAL_IT_INSN);
11534
11535   if (unified_syntax)
11536     {
11537       if (inst.size_req == 4 || inst.operands[0].imm > 15)
11538         {
11539           inst.instruction = THUMB_OP32 (inst.instruction);
11540           inst.instruction |= inst.operands[0].imm;
11541         }
11542       else
11543         {
11544           /* PR9722: Check for Thumb2 availability before
11545              generating a thumb2 nop instruction.  */
11546           if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6t2))
11547             {
11548               inst.instruction = THUMB_OP16 (inst.instruction);
11549               inst.instruction |= inst.operands[0].imm << 4;
11550             }
11551           else
11552             inst.instruction = 0x46c0;
11553         }
11554     }
11555   else
11556     {
11557       constraint (inst.operands[0].present,
11558                   _("Thumb does not support NOP with hints"));
11559       inst.instruction = 0x46c0;
11560     }
11561 }
11562
11563 static void
11564 do_t_neg (void)
11565 {
11566   if (unified_syntax)
11567     {
11568       bfd_boolean narrow;
11569
11570       if (THUMB_SETS_FLAGS (inst.instruction))
11571         narrow = !in_it_block ();
11572       else
11573         narrow = in_it_block ();
11574       if (inst.operands[0].reg > 7 || inst.operands[1].reg > 7)
11575         narrow = FALSE;
11576       if (inst.size_req == 4)
11577         narrow = FALSE;
11578
11579       if (!narrow)
11580         {
11581           inst.instruction = THUMB_OP32 (inst.instruction);
11582           inst.instruction |= inst.operands[0].reg << 8;
11583           inst.instruction |= inst.operands[1].reg << 16;
11584         }
11585       else
11586         {
11587           inst.instruction = THUMB_OP16 (inst.instruction);
11588           inst.instruction |= inst.operands[0].reg;
11589           inst.instruction |= inst.operands[1].reg << 3;
11590         }
11591     }
11592   else
11593     {
11594       constraint (inst.operands[0].reg > 7 || inst.operands[1].reg > 7,
11595                   BAD_HIREG);
11596       constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
11597
11598       inst.instruction = THUMB_OP16 (inst.instruction);
11599       inst.instruction |= inst.operands[0].reg;
11600       inst.instruction |= inst.operands[1].reg << 3;
11601     }
11602 }
11603
11604 static void
11605 do_t_orn (void)
11606 {
11607   unsigned Rd, Rn;
11608
11609   Rd = inst.operands[0].reg;
11610   Rn = inst.operands[1].present ? inst.operands[1].reg : Rd;
11611
11612   reject_bad_reg (Rd);
11613   /* Rn == REG_SP is unpredictable; Rn == REG_PC is MVN.  */
11614   reject_bad_reg (Rn);
11615
11616   inst.instruction |= Rd << 8;
11617   inst.instruction |= Rn << 16;
11618
11619   if (!inst.operands[2].isreg)
11620     {
11621       inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
11622       inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
11623     }
11624   else
11625     {
11626       unsigned Rm;
11627
11628       Rm = inst.operands[2].reg;
11629       reject_bad_reg (Rm);
11630
11631       constraint (inst.operands[2].shifted
11632                   && inst.operands[2].immisreg,
11633                   _("shift must be constant"));
11634       encode_thumb32_shifted_operand (2);
11635     }
11636 }
11637
11638 static void
11639 do_t_pkhbt (void)
11640 {
11641   unsigned Rd, Rn, Rm;
11642
11643   Rd = inst.operands[0].reg;
11644   Rn = inst.operands[1].reg;
11645   Rm = inst.operands[2].reg;
11646
11647   reject_bad_reg (Rd);
11648   reject_bad_reg (Rn);
11649   reject_bad_reg (Rm);
11650
11651   inst.instruction |= Rd << 8;
11652   inst.instruction |= Rn << 16;
11653   inst.instruction |= Rm;
11654   if (inst.operands[3].present)
11655     {
11656       unsigned int val = inst.reloc.exp.X_add_number;
11657       constraint (inst.reloc.exp.X_op != O_constant,
11658                   _("expression too complex"));
11659       inst.instruction |= (val & 0x1c) << 10;
11660       inst.instruction |= (val & 0x03) << 6;
11661     }
11662 }
11663
11664 static void
11665 do_t_pkhtb (void)
11666 {
11667   if (!inst.operands[3].present)
11668     {
11669       unsigned Rtmp;
11670
11671       inst.instruction &= ~0x00000020;
11672
11673       /* PR 10168.  Swap the Rm and Rn registers.  */
11674       Rtmp = inst.operands[1].reg;
11675       inst.operands[1].reg = inst.operands[2].reg;
11676       inst.operands[2].reg = Rtmp;
11677     }
11678   do_t_pkhbt ();
11679 }
11680
11681 static void
11682 do_t_pld (void)
11683 {
11684   if (inst.operands[0].immisreg)
11685     reject_bad_reg (inst.operands[0].imm);
11686
11687   encode_thumb32_addr_mode (0, /*is_t=*/FALSE, /*is_d=*/FALSE);
11688 }
11689
11690 static void
11691 do_t_push_pop (void)
11692 {
11693   unsigned mask;
11694
11695   constraint (inst.operands[0].writeback,
11696               _("push/pop do not support {reglist}^"));
11697   constraint (inst.reloc.type != BFD_RELOC_UNUSED,
11698               _("expression too complex"));
11699
11700   mask = inst.operands[0].imm;
11701   if ((mask & ~0xff) == 0)
11702     inst.instruction = THUMB_OP16 (inst.instruction) | mask;
11703   else if ((inst.instruction == T_MNEM_push
11704             && (mask & ~0xff) == 1 << REG_LR)
11705            || (inst.instruction == T_MNEM_pop
11706                && (mask & ~0xff) == 1 << REG_PC))
11707     {
11708       inst.instruction = THUMB_OP16 (inst.instruction);
11709       inst.instruction |= THUMB_PP_PC_LR;
11710       inst.instruction |= mask & 0xff;
11711     }
11712   else if (unified_syntax)
11713     {
11714       inst.instruction = THUMB_OP32 (inst.instruction);
11715       encode_thumb2_ldmstm (13, mask, TRUE);
11716     }
11717   else
11718     {
11719       inst.error = _("invalid register list to push/pop instruction");
11720       return;
11721     }
11722 }
11723
11724 static void
11725 do_t_rbit (void)
11726 {
11727   unsigned Rd, Rm;
11728
11729   Rd = inst.operands[0].reg;
11730   Rm = inst.operands[1].reg;
11731
11732   reject_bad_reg (Rd);
11733   reject_bad_reg (Rm);
11734
11735   inst.instruction |= Rd << 8;
11736   inst.instruction |= Rm << 16;
11737   inst.instruction |= Rm;
11738 }
11739
11740 static void
11741 do_t_rev (void)
11742 {
11743   unsigned Rd, Rm;
11744
11745   Rd = inst.operands[0].reg;
11746   Rm = inst.operands[1].reg;
11747
11748   reject_bad_reg (Rd);
11749   reject_bad_reg (Rm);
11750
11751   if (Rd <= 7 && Rm <= 7
11752       && inst.size_req != 4)
11753     {
11754       inst.instruction = THUMB_OP16 (inst.instruction);
11755       inst.instruction |= Rd;
11756       inst.instruction |= Rm << 3;
11757     }
11758   else if (unified_syntax)
11759     {
11760       inst.instruction = THUMB_OP32 (inst.instruction);
11761       inst.instruction |= Rd << 8;
11762       inst.instruction |= Rm << 16;
11763       inst.instruction |= Rm;
11764     }
11765   else
11766     inst.error = BAD_HIREG;
11767 }
11768
11769 static void
11770 do_t_rrx (void)
11771 {
11772   unsigned Rd, Rm;
11773
11774   Rd = inst.operands[0].reg;
11775   Rm = inst.operands[1].reg;
11776
11777   reject_bad_reg (Rd);
11778   reject_bad_reg (Rm);
11779
11780   inst.instruction |= Rd << 8;
11781   inst.instruction |= Rm;
11782 }
11783
11784 static void
11785 do_t_rsb (void)
11786 {
11787   unsigned Rd, Rs;
11788
11789   Rd = inst.operands[0].reg;
11790   Rs = (inst.operands[1].present
11791         ? inst.operands[1].reg    /* Rd, Rs, foo */
11792         : inst.operands[0].reg);  /* Rd, foo -> Rd, Rd, foo */
11793
11794   reject_bad_reg (Rd);
11795   reject_bad_reg (Rs);
11796   if (inst.operands[2].isreg)
11797     reject_bad_reg (inst.operands[2].reg);
11798
11799   inst.instruction |= Rd << 8;
11800   inst.instruction |= Rs << 16;
11801   if (!inst.operands[2].isreg)
11802     {
11803       bfd_boolean narrow;
11804
11805       if ((inst.instruction & 0x00100000) != 0)
11806         narrow = !in_it_block ();
11807       else
11808         narrow = in_it_block ();
11809
11810       if (Rd > 7 || Rs > 7)
11811         narrow = FALSE;
11812
11813       if (inst.size_req == 4 || !unified_syntax)
11814         narrow = FALSE;
11815
11816       if (inst.reloc.exp.X_op != O_constant
11817           || inst.reloc.exp.X_add_number != 0)
11818         narrow = FALSE;
11819
11820       /* Turn rsb #0 into 16-bit neg.  We should probably do this via
11821          relaxation, but it doesn't seem worth the hassle.  */
11822       if (narrow)
11823         {
11824           inst.reloc.type = BFD_RELOC_UNUSED;
11825           inst.instruction = THUMB_OP16 (T_MNEM_negs);
11826           inst.instruction |= Rs << 3;
11827           inst.instruction |= Rd;
11828         }
11829       else
11830         {
11831           inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
11832           inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
11833         }
11834     }
11835   else
11836     encode_thumb32_shifted_operand (2);
11837 }
11838
11839 static void
11840 do_t_setend (void)
11841 {
11842   if (warn_on_deprecated
11843       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
11844       as_warn (_("setend use is deprecated for ARMv8"));
11845
11846   set_it_insn_type (OUTSIDE_IT_INSN);
11847   if (inst.operands[0].imm)
11848     inst.instruction |= 0x8;
11849 }
11850
11851 static void
11852 do_t_shift (void)
11853 {
11854   if (!inst.operands[1].present)
11855     inst.operands[1].reg = inst.operands[0].reg;
11856
11857   if (unified_syntax)
11858     {
11859       bfd_boolean narrow;
11860       int shift_kind;
11861
11862       switch (inst.instruction)
11863         {
11864         case T_MNEM_asr:
11865         case T_MNEM_asrs: shift_kind = SHIFT_ASR; break;
11866         case T_MNEM_lsl:
11867         case T_MNEM_lsls: shift_kind = SHIFT_LSL; break;
11868         case T_MNEM_lsr:
11869         case T_MNEM_lsrs: shift_kind = SHIFT_LSR; break;
11870         case T_MNEM_ror:
11871         case T_MNEM_rors: shift_kind = SHIFT_ROR; break;
11872         default: abort ();
11873         }
11874
11875       if (THUMB_SETS_FLAGS (inst.instruction))
11876         narrow = !in_it_block ();
11877       else
11878         narrow = in_it_block ();
11879       if (inst.operands[0].reg > 7 || inst.operands[1].reg > 7)
11880         narrow = FALSE;
11881       if (!inst.operands[2].isreg && shift_kind == SHIFT_ROR)
11882         narrow = FALSE;
11883       if (inst.operands[2].isreg
11884           && (inst.operands[1].reg != inst.operands[0].reg
11885               || inst.operands[2].reg > 7))
11886         narrow = FALSE;
11887       if (inst.size_req == 4)
11888         narrow = FALSE;
11889
11890       reject_bad_reg (inst.operands[0].reg);
11891       reject_bad_reg (inst.operands[1].reg);
11892
11893       if (!narrow)
11894         {
11895           if (inst.operands[2].isreg)
11896             {
11897               reject_bad_reg (inst.operands[2].reg);
11898               inst.instruction = THUMB_OP32 (inst.instruction);
11899               inst.instruction |= inst.operands[0].reg << 8;
11900               inst.instruction |= inst.operands[1].reg << 16;
11901               inst.instruction |= inst.operands[2].reg;
11902
11903               /* PR 12854: Error on extraneous shifts.  */
11904               constraint (inst.operands[2].shifted,
11905                           _("extraneous shift as part of operand to shift insn"));
11906             }
11907           else
11908             {
11909               inst.operands[1].shifted = 1;
11910               inst.operands[1].shift_kind = shift_kind;
11911               inst.instruction = THUMB_OP32 (THUMB_SETS_FLAGS (inst.instruction)
11912                                              ? T_MNEM_movs : T_MNEM_mov);
11913               inst.instruction |= inst.operands[0].reg << 8;
11914               encode_thumb32_shifted_operand (1);
11915               /* Prevent the incorrect generation of an ARM_IMMEDIATE fixup.  */
11916               inst.reloc.type = BFD_RELOC_UNUSED;
11917             }
11918         }
11919       else
11920         {
11921           if (inst.operands[2].isreg)
11922             {
11923               switch (shift_kind)
11924                 {
11925                 case SHIFT_ASR: inst.instruction = T_OPCODE_ASR_R; break;
11926                 case SHIFT_LSL: inst.instruction = T_OPCODE_LSL_R; break;
11927                 case SHIFT_LSR: inst.instruction = T_OPCODE_LSR_R; break;
11928                 case SHIFT_ROR: inst.instruction = T_OPCODE_ROR_R; break;
11929                 default: abort ();
11930                 }
11931
11932               inst.instruction |= inst.operands[0].reg;
11933               inst.instruction |= inst.operands[2].reg << 3;
11934
11935               /* PR 12854: Error on extraneous shifts.  */
11936               constraint (inst.operands[2].shifted,
11937                           _("extraneous shift as part of operand to shift insn"));
11938             }
11939           else
11940             {
11941               switch (shift_kind)
11942                 {
11943                 case SHIFT_ASR: inst.instruction = T_OPCODE_ASR_I; break;
11944                 case SHIFT_LSL: inst.instruction = T_OPCODE_LSL_I; break;
11945                 case SHIFT_LSR: inst.instruction = T_OPCODE_LSR_I; break;
11946                 default: abort ();
11947                 }
11948               inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
11949               inst.instruction |= inst.operands[0].reg;
11950               inst.instruction |= inst.operands[1].reg << 3;
11951             }
11952         }
11953     }
11954   else
11955     {
11956       constraint (inst.operands[0].reg > 7
11957                   || inst.operands[1].reg > 7, BAD_HIREG);
11958       constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
11959
11960       if (inst.operands[2].isreg)  /* Rd, {Rs,} Rn */
11961         {
11962           constraint (inst.operands[2].reg > 7, BAD_HIREG);
11963           constraint (inst.operands[0].reg != inst.operands[1].reg,
11964                       _("source1 and dest must be same register"));
11965
11966           switch (inst.instruction)
11967             {
11968             case T_MNEM_asr: inst.instruction = T_OPCODE_ASR_R; break;
11969             case T_MNEM_lsl: inst.instruction = T_OPCODE_LSL_R; break;
11970             case T_MNEM_lsr: inst.instruction = T_OPCODE_LSR_R; break;
11971             case T_MNEM_ror: inst.instruction = T_OPCODE_ROR_R; break;
11972             default: abort ();
11973             }
11974
11975           inst.instruction |= inst.operands[0].reg;
11976           inst.instruction |= inst.operands[2].reg << 3;
11977
11978           /* PR 12854: Error on extraneous shifts.  */
11979           constraint (inst.operands[2].shifted,
11980                       _("extraneous shift as part of operand to shift insn"));
11981         }
11982       else
11983         {
11984           switch (inst.instruction)
11985             {
11986             case T_MNEM_asr: inst.instruction = T_OPCODE_ASR_I; break;
11987             case T_MNEM_lsl: inst.instruction = T_OPCODE_LSL_I; break;
11988             case T_MNEM_lsr: inst.instruction = T_OPCODE_LSR_I; break;
11989             case T_MNEM_ror: inst.error = _("ror #imm not supported"); return;
11990             default: abort ();
11991             }
11992           inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
11993           inst.instruction |= inst.operands[0].reg;
11994           inst.instruction |= inst.operands[1].reg << 3;
11995         }
11996     }
11997 }
11998
11999 static void
12000 do_t_simd (void)
12001 {
12002   unsigned Rd, Rn, Rm;
12003
12004   Rd = inst.operands[0].reg;
12005   Rn = inst.operands[1].reg;
12006   Rm = inst.operands[2].reg;
12007
12008   reject_bad_reg (Rd);
12009   reject_bad_reg (Rn);
12010   reject_bad_reg (Rm);
12011
12012   inst.instruction |= Rd << 8;
12013   inst.instruction |= Rn << 16;
12014   inst.instruction |= Rm;
12015 }
12016
12017 static void
12018 do_t_simd2 (void)
12019 {
12020   unsigned Rd, Rn, Rm;
12021
12022   Rd = inst.operands[0].reg;
12023   Rm = inst.operands[1].reg;
12024   Rn = inst.operands[2].reg;
12025
12026   reject_bad_reg (Rd);
12027   reject_bad_reg (Rn);
12028   reject_bad_reg (Rm);
12029
12030   inst.instruction |= Rd << 8;
12031   inst.instruction |= Rn << 16;
12032   inst.instruction |= Rm;
12033 }
12034
12035 static void
12036 do_t_smc (void)
12037 {
12038   unsigned int value = inst.reloc.exp.X_add_number;
12039   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7a),
12040               _("SMC is not permitted on this architecture"));
12041   constraint (inst.reloc.exp.X_op != O_constant,
12042               _("expression too complex"));
12043   inst.reloc.type = BFD_RELOC_UNUSED;
12044   inst.instruction |= (value & 0xf000) >> 12;
12045   inst.instruction |= (value & 0x0ff0);
12046   inst.instruction |= (value & 0x000f) << 16;
12047 }
12048
12049 static void
12050 do_t_hvc (void)
12051 {
12052   unsigned int value = inst.reloc.exp.X_add_number;
12053
12054   inst.reloc.type = BFD_RELOC_UNUSED;
12055   inst.instruction |= (value & 0x0fff);
12056   inst.instruction |= (value & 0xf000) << 4;
12057 }
12058
12059 static void
12060 do_t_ssat_usat (int bias)
12061 {
12062   unsigned Rd, Rn;
12063
12064   Rd = inst.operands[0].reg;
12065   Rn = inst.operands[2].reg;
12066
12067   reject_bad_reg (Rd);
12068   reject_bad_reg (Rn);
12069
12070   inst.instruction |= Rd << 8;
12071   inst.instruction |= inst.operands[1].imm - bias;
12072   inst.instruction |= Rn << 16;
12073
12074   if (inst.operands[3].present)
12075     {
12076       offsetT shift_amount = inst.reloc.exp.X_add_number;
12077
12078       inst.reloc.type = BFD_RELOC_UNUSED;
12079
12080       constraint (inst.reloc.exp.X_op != O_constant,
12081                   _("expression too complex"));
12082
12083       if (shift_amount != 0)
12084         {
12085           constraint (shift_amount > 31,
12086                       _("shift expression is too large"));
12087
12088           if (inst.operands[3].shift_kind == SHIFT_ASR)
12089             inst.instruction |= 0x00200000;  /* sh bit.  */
12090
12091           inst.instruction |= (shift_amount & 0x1c) << 10;
12092           inst.instruction |= (shift_amount & 0x03) << 6;
12093         }
12094     }
12095 }
12096
12097 static void
12098 do_t_ssat (void)
12099 {
12100   do_t_ssat_usat (1);
12101 }
12102
12103 static void
12104 do_t_ssat16 (void)
12105 {
12106   unsigned Rd, Rn;
12107
12108   Rd = inst.operands[0].reg;
12109   Rn = inst.operands[2].reg;
12110
12111   reject_bad_reg (Rd);
12112   reject_bad_reg (Rn);
12113
12114   inst.instruction |= Rd << 8;
12115   inst.instruction |= inst.operands[1].imm - 1;
12116   inst.instruction |= Rn << 16;
12117 }
12118
12119 static void
12120 do_t_strex (void)
12121 {
12122   constraint (!inst.operands[2].isreg || !inst.operands[2].preind
12123               || inst.operands[2].postind || inst.operands[2].writeback
12124               || inst.operands[2].immisreg || inst.operands[2].shifted
12125               || inst.operands[2].negative,
12126               BAD_ADDR_MODE);
12127
12128   constraint (inst.operands[2].reg == REG_PC, BAD_PC);
12129
12130   inst.instruction |= inst.operands[0].reg << 8;
12131   inst.instruction |= inst.operands[1].reg << 12;
12132   inst.instruction |= inst.operands[2].reg << 16;
12133   inst.reloc.type = BFD_RELOC_ARM_T32_OFFSET_U8;
12134 }
12135
12136 static void
12137 do_t_strexd (void)
12138 {
12139   if (!inst.operands[2].present)
12140     inst.operands[2].reg = inst.operands[1].reg + 1;
12141
12142   constraint (inst.operands[0].reg == inst.operands[1].reg
12143               || inst.operands[0].reg == inst.operands[2].reg
12144               || inst.operands[0].reg == inst.operands[3].reg,
12145               BAD_OVERLAP);
12146
12147   inst.instruction |= inst.operands[0].reg;
12148   inst.instruction |= inst.operands[1].reg << 12;
12149   inst.instruction |= inst.operands[2].reg << 8;
12150   inst.instruction |= inst.operands[3].reg << 16;
12151 }
12152
12153 static void
12154 do_t_sxtah (void)
12155 {
12156   unsigned Rd, Rn, Rm;
12157
12158   Rd = inst.operands[0].reg;
12159   Rn = inst.operands[1].reg;
12160   Rm = inst.operands[2].reg;
12161
12162   reject_bad_reg (Rd);
12163   reject_bad_reg (Rn);
12164   reject_bad_reg (Rm);
12165
12166   inst.instruction |= Rd << 8;
12167   inst.instruction |= Rn << 16;
12168   inst.instruction |= Rm;
12169   inst.instruction |= inst.operands[3].imm << 4;
12170 }
12171
12172 static void
12173 do_t_sxth (void)
12174 {
12175   unsigned Rd, Rm;
12176
12177   Rd = inst.operands[0].reg;
12178   Rm = inst.operands[1].reg;
12179
12180   reject_bad_reg (Rd);
12181   reject_bad_reg (Rm);
12182
12183   if (inst.instruction <= 0xffff
12184       && inst.size_req != 4
12185       && Rd <= 7 && Rm <= 7
12186       && (!inst.operands[2].present || inst.operands[2].imm == 0))
12187     {
12188       inst.instruction = THUMB_OP16 (inst.instruction);
12189       inst.instruction |= Rd;
12190       inst.instruction |= Rm << 3;
12191     }
12192   else if (unified_syntax)
12193     {
12194       if (inst.instruction <= 0xffff)
12195         inst.instruction = THUMB_OP32 (inst.instruction);
12196       inst.instruction |= Rd << 8;
12197       inst.instruction |= Rm;
12198       inst.instruction |= inst.operands[2].imm << 4;
12199     }
12200   else
12201     {
12202       constraint (inst.operands[2].present && inst.operands[2].imm != 0,
12203                   _("Thumb encoding does not support rotation"));
12204       constraint (1, BAD_HIREG);
12205     }
12206 }
12207
12208 static void
12209 do_t_swi (void)
12210 {
12211   /* We have to do the following check manually as ARM_EXT_OS only applies
12212      to ARM_EXT_V6M.  */
12213   if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6m))
12214     {
12215       if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_os)
12216           /* This only applies to the v6m howver, not later architectures.  */
12217           && ! ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7))
12218         as_bad (_("SVC is not permitted on this architecture"));
12219       ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used, arm_ext_os);
12220     }
12221
12222   inst.reloc.type = BFD_RELOC_ARM_SWI;
12223 }
12224
12225 static void
12226 do_t_tb (void)
12227 {
12228   unsigned Rn, Rm;
12229   int half;
12230
12231   half = (inst.instruction & 0x10) != 0;
12232   set_it_insn_type_last ();
12233   constraint (inst.operands[0].immisreg,
12234               _("instruction requires register index"));
12235
12236   Rn = inst.operands[0].reg;
12237   Rm = inst.operands[0].imm;
12238
12239   constraint (Rn == REG_SP, BAD_SP);
12240   reject_bad_reg (Rm);
12241
12242   constraint (!half && inst.operands[0].shifted,
12243               _("instruction does not allow shifted index"));
12244   inst.instruction |= (Rn << 16) | Rm;
12245 }
12246
12247 static void
12248 do_t_usat (void)
12249 {
12250   do_t_ssat_usat (0);
12251 }
12252
12253 static void
12254 do_t_usat16 (void)
12255 {
12256   unsigned Rd, Rn;
12257
12258   Rd = inst.operands[0].reg;
12259   Rn = inst.operands[2].reg;
12260
12261   reject_bad_reg (Rd);
12262   reject_bad_reg (Rn);
12263
12264   inst.instruction |= Rd << 8;
12265   inst.instruction |= inst.operands[1].imm;
12266   inst.instruction |= Rn << 16;
12267 }
12268
12269 /* Neon instruction encoder helpers.  */
12270
12271 /* Encodings for the different types for various Neon opcodes.  */
12272
12273 /* An "invalid" code for the following tables.  */
12274 #define N_INV -1u
12275
12276 struct neon_tab_entry
12277 {
12278   unsigned integer;
12279   unsigned float_or_poly;
12280   unsigned scalar_or_imm;
12281 };
12282
12283 /* Map overloaded Neon opcodes to their respective encodings.  */
12284 #define NEON_ENC_TAB                                    \
12285   X(vabd,       0x0000700, 0x1200d00, N_INV),           \
12286   X(vmax,       0x0000600, 0x0000f00, N_INV),           \
12287   X(vmin,       0x0000610, 0x0200f00, N_INV),           \
12288   X(vpadd,      0x0000b10, 0x1000d00, N_INV),           \
12289   X(vpmax,      0x0000a00, 0x1000f00, N_INV),           \
12290   X(vpmin,      0x0000a10, 0x1200f00, N_INV),           \
12291   X(vadd,       0x0000800, 0x0000d00, N_INV),           \
12292   X(vsub,       0x1000800, 0x0200d00, N_INV),           \
12293   X(vceq,       0x1000810, 0x0000e00, 0x1b10100),       \
12294   X(vcge,       0x0000310, 0x1000e00, 0x1b10080),       \
12295   X(vcgt,       0x0000300, 0x1200e00, 0x1b10000),       \
12296   /* Register variants of the following two instructions are encoded as
12297      vcge / vcgt with the operands reversed.  */        \
12298   X(vclt,       0x0000300, 0x1200e00, 0x1b10200),       \
12299   X(vcle,       0x0000310, 0x1000e00, 0x1b10180),       \
12300   X(vfma,       N_INV, 0x0000c10, N_INV),               \
12301   X(vfms,       N_INV, 0x0200c10, N_INV),               \
12302   X(vmla,       0x0000900, 0x0000d10, 0x0800040),       \
12303   X(vmls,       0x1000900, 0x0200d10, 0x0800440),       \
12304   X(vmul,       0x0000910, 0x1000d10, 0x0800840),       \
12305   X(vmull,      0x0800c00, 0x0800e00, 0x0800a40), /* polynomial not float.  */ \
12306   X(vmlal,      0x0800800, N_INV,     0x0800240),       \
12307   X(vmlsl,      0x0800a00, N_INV,     0x0800640),       \
12308   X(vqdmlal,    0x0800900, N_INV,     0x0800340),       \
12309   X(vqdmlsl,    0x0800b00, N_INV,     0x0800740),       \
12310   X(vqdmull,    0x0800d00, N_INV,     0x0800b40),       \
12311   X(vqdmulh,    0x0000b00, N_INV,     0x0800c40),       \
12312   X(vqrdmulh,   0x1000b00, N_INV,     0x0800d40),       \
12313   X(vshl,       0x0000400, N_INV,     0x0800510),       \
12314   X(vqshl,      0x0000410, N_INV,     0x0800710),       \
12315   X(vand,       0x0000110, N_INV,     0x0800030),       \
12316   X(vbic,       0x0100110, N_INV,     0x0800030),       \
12317   X(veor,       0x1000110, N_INV,     N_INV),           \
12318   X(vorn,       0x0300110, N_INV,     0x0800010),       \
12319   X(vorr,       0x0200110, N_INV,     0x0800010),       \
12320   X(vmvn,       0x1b00580, N_INV,     0x0800030),       \
12321   X(vshll,      0x1b20300, N_INV,     0x0800a10), /* max shift, immediate.  */ \
12322   X(vcvt,       0x1b30600, N_INV,     0x0800e10), /* integer, fixed-point.  */ \
12323   X(vdup,       0xe800b10, N_INV,     0x1b00c00), /* arm, scalar.  */ \
12324   X(vld1,       0x0200000, 0x0a00000, 0x0a00c00), /* interlv, lane, dup.  */ \
12325   X(vst1,       0x0000000, 0x0800000, N_INV),           \
12326   X(vld2,       0x0200100, 0x0a00100, 0x0a00d00),       \
12327   X(vst2,       0x0000100, 0x0800100, N_INV),           \
12328   X(vld3,       0x0200200, 0x0a00200, 0x0a00e00),       \
12329   X(vst3,       0x0000200, 0x0800200, N_INV),           \
12330   X(vld4,       0x0200300, 0x0a00300, 0x0a00f00),       \
12331   X(vst4,       0x0000300, 0x0800300, N_INV),           \
12332   X(vmovn,      0x1b20200, N_INV,     N_INV),           \
12333   X(vtrn,       0x1b20080, N_INV,     N_INV),           \
12334   X(vqmovn,     0x1b20200, N_INV,     N_INV),           \
12335   X(vqmovun,    0x1b20240, N_INV,     N_INV),           \
12336   X(vnmul,      0xe200a40, 0xe200b40, N_INV),           \
12337   X(vnmla,      0xe100a40, 0xe100b40, N_INV),           \
12338   X(vnmls,      0xe100a00, 0xe100b00, N_INV),           \
12339   X(vfnma,      0xe900a40, 0xe900b40, N_INV),           \
12340   X(vfnms,      0xe900a00, 0xe900b00, N_INV),           \
12341   X(vcmp,       0xeb40a40, 0xeb40b40, N_INV),           \
12342   X(vcmpz,      0xeb50a40, 0xeb50b40, N_INV),           \
12343   X(vcmpe,      0xeb40ac0, 0xeb40bc0, N_INV),           \
12344   X(vcmpez,     0xeb50ac0, 0xeb50bc0, N_INV),           \
12345   X(vseleq,     0xe000a00, N_INV,     N_INV),           \
12346   X(vselvs,     0xe100a00, N_INV,     N_INV),           \
12347   X(vselge,     0xe200a00, N_INV,     N_INV),           \
12348   X(vselgt,     0xe300a00, N_INV,     N_INV),           \
12349   X(vmaxnm,     0xe800a00, 0x3000f10, N_INV),           \
12350   X(vminnm,     0xe800a40, 0x3200f10, N_INV)
12351
12352 enum neon_opc
12353 {
12354 #define X(OPC,I,F,S) N_MNEM_##OPC
12355 NEON_ENC_TAB
12356 #undef X
12357 };
12358
12359 static const struct neon_tab_entry neon_enc_tab[] =
12360 {
12361 #define X(OPC,I,F,S) { (I), (F), (S) }
12362 NEON_ENC_TAB
12363 #undef X
12364 };
12365
12366 /* Do not use these macros; instead, use NEON_ENCODE defined below.  */
12367 #define NEON_ENC_INTEGER_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
12368 #define NEON_ENC_ARMREG_(X)  (neon_enc_tab[(X) & 0x0fffffff].integer)
12369 #define NEON_ENC_POLY_(X)    (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
12370 #define NEON_ENC_FLOAT_(X)   (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
12371 #define NEON_ENC_SCALAR_(X)  (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
12372 #define NEON_ENC_IMMED_(X)   (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
12373 #define NEON_ENC_INTERLV_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
12374 #define NEON_ENC_LANE_(X)    (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
12375 #define NEON_ENC_DUP_(X)     (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
12376 #define NEON_ENC_SINGLE_(X) \
12377   ((neon_enc_tab[(X) & 0x0fffffff].integer) | ((X) & 0xf0000000))
12378 #define NEON_ENC_DOUBLE_(X) \
12379   ((neon_enc_tab[(X) & 0x0fffffff].float_or_poly) | ((X) & 0xf0000000))
12380 #define NEON_ENC_FPV8_(X) \
12381   ((neon_enc_tab[(X) & 0x0fffffff].integer) | ((X) & 0xf000000))
12382
12383 #define NEON_ENCODE(type, inst)                                 \
12384   do                                                            \
12385     {                                                           \
12386       inst.instruction = NEON_ENC_##type##_ (inst.instruction); \
12387       inst.is_neon = 1;                                         \
12388     }                                                           \
12389   while (0)
12390
12391 #define check_neon_suffixes                                             \
12392   do                                                                    \
12393     {                                                                   \
12394       if (!inst.error && inst.vectype.elems > 0 && !inst.is_neon)       \
12395         {                                                               \
12396           as_bad (_("invalid neon suffix for non neon instruction"));   \
12397           return;                                                       \
12398         }                                                               \
12399     }                                                                   \
12400   while (0)
12401
12402 /* Define shapes for instruction operands. The following mnemonic characters
12403    are used in this table:
12404
12405      F - VFP S<n> register
12406      D - Neon D<n> register
12407      Q - Neon Q<n> register
12408      I - Immediate
12409      S - Scalar
12410      R - ARM register
12411      L - D<n> register list
12412
12413    This table is used to generate various data:
12414      - enumerations of the form NS_DDR to be used as arguments to
12415        neon_select_shape.
12416      - a table classifying shapes into single, double, quad, mixed.
12417      - a table used to drive neon_select_shape.  */
12418
12419 #define NEON_SHAPE_DEF                  \
12420   X(3, (D, D, D), DOUBLE),              \
12421   X(3, (Q, Q, Q), QUAD),                \
12422   X(3, (D, D, I), DOUBLE),              \
12423   X(3, (Q, Q, I), QUAD),                \
12424   X(3, (D, D, S), DOUBLE),              \
12425   X(3, (Q, Q, S), QUAD),                \
12426   X(2, (D, D), DOUBLE),                 \
12427   X(2, (Q, Q), QUAD),                   \
12428   X(2, (D, S), DOUBLE),                 \
12429   X(2, (Q, S), QUAD),                   \
12430   X(2, (D, R), DOUBLE),                 \
12431   X(2, (Q, R), QUAD),                   \
12432   X(2, (D, I), DOUBLE),                 \
12433   X(2, (Q, I), QUAD),                   \
12434   X(3, (D, L, D), DOUBLE),              \
12435   X(2, (D, Q), MIXED),                  \
12436   X(2, (Q, D), MIXED),                  \
12437   X(3, (D, Q, I), MIXED),               \
12438   X(3, (Q, D, I), MIXED),               \
12439   X(3, (Q, D, D), MIXED),               \
12440   X(3, (D, Q, Q), MIXED),               \
12441   X(3, (Q, Q, D), MIXED),               \
12442   X(3, (Q, D, S), MIXED),               \
12443   X(3, (D, Q, S), MIXED),               \
12444   X(4, (D, D, D, I), DOUBLE),           \
12445   X(4, (Q, Q, Q, I), QUAD),             \
12446   X(2, (F, F), SINGLE),                 \
12447   X(3, (F, F, F), SINGLE),              \
12448   X(2, (F, I), SINGLE),                 \
12449   X(2, (F, D), MIXED),                  \
12450   X(2, (D, F), MIXED),                  \
12451   X(3, (F, F, I), MIXED),               \
12452   X(4, (R, R, F, F), SINGLE),           \
12453   X(4, (F, F, R, R), SINGLE),           \
12454   X(3, (D, R, R), DOUBLE),              \
12455   X(3, (R, R, D), DOUBLE),              \
12456   X(2, (S, R), SINGLE),                 \
12457   X(2, (R, S), SINGLE),                 \
12458   X(2, (F, R), SINGLE),                 \
12459   X(2, (R, F), SINGLE)
12460
12461 #define S2(A,B)         NS_##A##B
12462 #define S3(A,B,C)       NS_##A##B##C
12463 #define S4(A,B,C,D)     NS_##A##B##C##D
12464
12465 #define X(N, L, C) S##N L
12466
12467 enum neon_shape
12468 {
12469   NEON_SHAPE_DEF,
12470   NS_NULL
12471 };
12472
12473 #undef X
12474 #undef S2
12475 #undef S3
12476 #undef S4
12477
12478 enum neon_shape_class
12479 {
12480   SC_SINGLE,
12481   SC_DOUBLE,
12482   SC_QUAD,
12483   SC_MIXED
12484 };
12485
12486 #define X(N, L, C) SC_##C
12487
12488 static enum neon_shape_class neon_shape_class[] =
12489 {
12490   NEON_SHAPE_DEF
12491 };
12492
12493 #undef X
12494
12495 enum neon_shape_el
12496 {
12497   SE_F,
12498   SE_D,
12499   SE_Q,
12500   SE_I,
12501   SE_S,
12502   SE_R,
12503   SE_L
12504 };
12505
12506 /* Register widths of above.  */
12507 static unsigned neon_shape_el_size[] =
12508 {
12509   32,
12510   64,
12511   128,
12512   0,
12513   32,
12514   32,
12515   0
12516 };
12517
12518 struct neon_shape_info
12519 {
12520   unsigned els;
12521   enum neon_shape_el el[NEON_MAX_TYPE_ELS];
12522 };
12523
12524 #define S2(A,B)         { SE_##A, SE_##B }
12525 #define S3(A,B,C)       { SE_##A, SE_##B, SE_##C }
12526 #define S4(A,B,C,D)     { SE_##A, SE_##B, SE_##C, SE_##D }
12527
12528 #define X(N, L, C) { N, S##N L }
12529
12530 static struct neon_shape_info neon_shape_tab[] =
12531 {
12532   NEON_SHAPE_DEF
12533 };
12534
12535 #undef X
12536 #undef S2
12537 #undef S3
12538 #undef S4
12539
12540 /* Bit masks used in type checking given instructions.
12541   'N_EQK' means the type must be the same as (or based on in some way) the key
12542    type, which itself is marked with the 'N_KEY' bit. If the 'N_EQK' bit is
12543    set, various other bits can be set as well in order to modify the meaning of
12544    the type constraint.  */
12545
12546 enum neon_type_mask
12547 {
12548   N_S8   = 0x0000001,
12549   N_S16  = 0x0000002,
12550   N_S32  = 0x0000004,
12551   N_S64  = 0x0000008,
12552   N_U8   = 0x0000010,
12553   N_U16  = 0x0000020,
12554   N_U32  = 0x0000040,
12555   N_U64  = 0x0000080,
12556   N_I8   = 0x0000100,
12557   N_I16  = 0x0000200,
12558   N_I32  = 0x0000400,
12559   N_I64  = 0x0000800,
12560   N_8    = 0x0001000,
12561   N_16   = 0x0002000,
12562   N_32   = 0x0004000,
12563   N_64   = 0x0008000,
12564   N_P8   = 0x0010000,
12565   N_P16  = 0x0020000,
12566   N_F16  = 0x0040000,
12567   N_F32  = 0x0080000,
12568   N_F64  = 0x0100000,
12569   N_KEY  = 0x1000000, /* Key element (main type specifier).  */
12570   N_EQK  = 0x2000000, /* Given operand has the same type & size as the key.  */
12571   N_VFP  = 0x4000000, /* VFP mode: operand size must match register width.  */
12572   N_DBL  = 0x0000001, /* If N_EQK, this operand is twice the size.  */
12573   N_HLF  = 0x0000002, /* If N_EQK, this operand is half the size.  */
12574   N_SGN  = 0x0000004, /* If N_EQK, this operand is forced to be signed.  */
12575   N_UNS  = 0x0000008, /* If N_EQK, this operand is forced to be unsigned.  */
12576   N_INT  = 0x0000010, /* If N_EQK, this operand is forced to be integer.  */
12577   N_FLT  = 0x0000020, /* If N_EQK, this operand is forced to be float.  */
12578   N_SIZ  = 0x0000040, /* If N_EQK, this operand is forced to be size-only.  */
12579   N_UTYP = 0,
12580   N_MAX_NONSPECIAL = N_F64
12581 };
12582
12583 #define N_ALLMODS  (N_DBL | N_HLF | N_SGN | N_UNS | N_INT | N_FLT | N_SIZ)
12584
12585 #define N_SU_ALL   (N_S8 | N_S16 | N_S32 | N_S64 | N_U8 | N_U16 | N_U32 | N_U64)
12586 #define N_SU_32    (N_S8 | N_S16 | N_S32 | N_U8 | N_U16 | N_U32)
12587 #define N_SU_16_64 (N_S16 | N_S32 | N_S64 | N_U16 | N_U32 | N_U64)
12588 #define N_SUF_32   (N_SU_32 | N_F32)
12589 #define N_I_ALL    (N_I8 | N_I16 | N_I32 | N_I64)
12590 #define N_IF_32    (N_I8 | N_I16 | N_I32 | N_F32)
12591
12592 /* Pass this as the first type argument to neon_check_type to ignore types
12593    altogether.  */
12594 #define N_IGNORE_TYPE (N_KEY | N_EQK)
12595
12596 /* Select a "shape" for the current instruction (describing register types or
12597    sizes) from a list of alternatives. Return NS_NULL if the current instruction
12598    doesn't fit. For non-polymorphic shapes, checking is usually done as a
12599    function of operand parsing, so this function doesn't need to be called.
12600    Shapes should be listed in order of decreasing length.  */
12601
12602 static enum neon_shape
12603 neon_select_shape (enum neon_shape shape, ...)
12604 {
12605   va_list ap;
12606   enum neon_shape first_shape = shape;
12607
12608   /* Fix missing optional operands. FIXME: we don't know at this point how
12609      many arguments we should have, so this makes the assumption that we have
12610      > 1. This is true of all current Neon opcodes, I think, but may not be
12611      true in the future.  */
12612   if (!inst.operands[1].present)
12613     inst.operands[1] = inst.operands[0];
12614
12615   va_start (ap, shape);
12616
12617   for (; shape != NS_NULL; shape = (enum neon_shape) va_arg (ap, int))
12618     {
12619       unsigned j;
12620       int matches = 1;
12621
12622       for (j = 0; j < neon_shape_tab[shape].els; j++)
12623         {
12624           if (!inst.operands[j].present)
12625             {
12626               matches = 0;
12627               break;
12628             }
12629
12630           switch (neon_shape_tab[shape].el[j])
12631             {
12632             case SE_F:
12633               if (!(inst.operands[j].isreg
12634                     && inst.operands[j].isvec
12635                     && inst.operands[j].issingle
12636                     && !inst.operands[j].isquad))
12637                 matches = 0;
12638               break;
12639
12640             case SE_D:
12641               if (!(inst.operands[j].isreg
12642                     && inst.operands[j].isvec
12643                     && !inst.operands[j].isquad
12644                     && !inst.operands[j].issingle))
12645                 matches = 0;
12646               break;
12647
12648             case SE_R:
12649               if (!(inst.operands[j].isreg
12650                     && !inst.operands[j].isvec))
12651                 matches = 0;
12652               break;
12653
12654             case SE_Q:
12655               if (!(inst.operands[j].isreg
12656                     && inst.operands[j].isvec
12657                     && inst.operands[j].isquad
12658                     && !inst.operands[j].issingle))
12659                 matches = 0;
12660               break;
12661
12662             case SE_I:
12663               if (!(!inst.operands[j].isreg
12664                     && !inst.operands[j].isscalar))
12665                 matches = 0;
12666               break;
12667
12668             case SE_S:
12669               if (!(!inst.operands[j].isreg
12670                     && inst.operands[j].isscalar))
12671                 matches = 0;
12672               break;
12673
12674             case SE_L:
12675               break;
12676             }
12677           if (!matches)
12678             break;
12679         }
12680       if (matches && (j >= ARM_IT_MAX_OPERANDS || !inst.operands[j].present))
12681         /* We've matched all the entries in the shape table, and we don't
12682            have any left over operands which have not been matched.  */
12683         break;
12684     }
12685
12686   va_end (ap);
12687
12688   if (shape == NS_NULL && first_shape != NS_NULL)
12689     first_error (_("invalid instruction shape"));
12690
12691   return shape;
12692 }
12693
12694 /* True if SHAPE is predominantly a quadword operation (most of the time, this
12695    means the Q bit should be set).  */
12696
12697 static int
12698 neon_quad (enum neon_shape shape)
12699 {
12700   return neon_shape_class[shape] == SC_QUAD;
12701 }
12702
12703 static void
12704 neon_modify_type_size (unsigned typebits, enum neon_el_type *g_type,
12705                        unsigned *g_size)
12706 {
12707   /* Allow modification to be made to types which are constrained to be
12708      based on the key element, based on bits set alongside N_EQK.  */
12709   if ((typebits & N_EQK) != 0)
12710     {
12711       if ((typebits & N_HLF) != 0)
12712         *g_size /= 2;
12713       else if ((typebits & N_DBL) != 0)
12714         *g_size *= 2;
12715       if ((typebits & N_SGN) != 0)
12716         *g_type = NT_signed;
12717       else if ((typebits & N_UNS) != 0)
12718         *g_type = NT_unsigned;
12719       else if ((typebits & N_INT) != 0)
12720         *g_type = NT_integer;
12721       else if ((typebits & N_FLT) != 0)
12722         *g_type = NT_float;
12723       else if ((typebits & N_SIZ) != 0)
12724         *g_type = NT_untyped;
12725     }
12726 }
12727
12728 /* Return operand OPNO promoted by bits set in THISARG. KEY should be the "key"
12729    operand type, i.e. the single type specified in a Neon instruction when it
12730    is the only one given.  */
12731
12732 static struct neon_type_el
12733 neon_type_promote (struct neon_type_el *key, unsigned thisarg)
12734 {
12735   struct neon_type_el dest = *key;
12736
12737   gas_assert ((thisarg & N_EQK) != 0);
12738
12739   neon_modify_type_size (thisarg, &dest.type, &dest.size);
12740
12741   return dest;
12742 }
12743
12744 /* Convert Neon type and size into compact bitmask representation.  */
12745
12746 static enum neon_type_mask
12747 type_chk_of_el_type (enum neon_el_type type, unsigned size)
12748 {
12749   switch (type)
12750     {
12751     case NT_untyped:
12752       switch (size)
12753         {
12754         case 8:  return N_8;
12755         case 16: return N_16;
12756         case 32: return N_32;
12757         case 64: return N_64;
12758         default: ;
12759         }
12760       break;
12761
12762     case NT_integer:
12763       switch (size)
12764         {
12765         case 8:  return N_I8;
12766         case 16: return N_I16;
12767         case 32: return N_I32;
12768         case 64: return N_I64;
12769         default: ;
12770         }
12771       break;
12772
12773     case NT_float:
12774       switch (size)
12775         {
12776         case 16: return N_F16;
12777         case 32: return N_F32;
12778         case 64: return N_F64;
12779         default: ;
12780         }
12781       break;
12782
12783     case NT_poly:
12784       switch (size)
12785         {
12786         case 8:  return N_P8;
12787         case 16: return N_P16;
12788         default: ;
12789         }
12790       break;
12791
12792     case NT_signed:
12793       switch (size)
12794         {
12795         case 8:  return N_S8;
12796         case 16: return N_S16;
12797         case 32: return N_S32;
12798         case 64: return N_S64;
12799         default: ;
12800         }
12801       break;
12802
12803     case NT_unsigned:
12804       switch (size)
12805         {
12806         case 8:  return N_U8;
12807         case 16: return N_U16;
12808         case 32: return N_U32;
12809         case 64: return N_U64;
12810         default: ;
12811         }
12812       break;
12813
12814     default: ;
12815     }
12816
12817   return N_UTYP;
12818 }
12819
12820 /* Convert compact Neon bitmask type representation to a type and size. Only
12821    handles the case where a single bit is set in the mask.  */
12822
12823 static int
12824 el_type_of_type_chk (enum neon_el_type *type, unsigned *size,
12825                      enum neon_type_mask mask)
12826 {
12827   if ((mask & N_EQK) != 0)
12828     return FAIL;
12829
12830   if ((mask & (N_S8 | N_U8 | N_I8 | N_8 | N_P8)) != 0)
12831     *size = 8;
12832   else if ((mask & (N_S16 | N_U16 | N_I16 | N_16 | N_P16)) != 0)
12833     *size = 16;
12834   else if ((mask & (N_S32 | N_U32 | N_I32 | N_32 | N_F32)) != 0)
12835     *size = 32;
12836   else if ((mask & (N_S64 | N_U64 | N_I64 | N_64 | N_F64)) != 0)
12837     *size = 64;
12838   else
12839     return FAIL;
12840
12841   if ((mask & (N_S8 | N_S16 | N_S32 | N_S64)) != 0)
12842     *type = NT_signed;
12843   else if ((mask & (N_U8 | N_U16 | N_U32 | N_U64)) != 0)
12844     *type = NT_unsigned;
12845   else if ((mask & (N_I8 | N_I16 | N_I32 | N_I64)) != 0)
12846     *type = NT_integer;
12847   else if ((mask & (N_8 | N_16 | N_32 | N_64)) != 0)
12848     *type = NT_untyped;
12849   else if ((mask & (N_P8 | N_P16)) != 0)
12850     *type = NT_poly;
12851   else if ((mask & (N_F32 | N_F64)) != 0)
12852     *type = NT_float;
12853   else
12854     return FAIL;
12855
12856   return SUCCESS;
12857 }
12858
12859 /* Modify a bitmask of allowed types. This is only needed for type
12860    relaxation.  */
12861
12862 static unsigned
12863 modify_types_allowed (unsigned allowed, unsigned mods)
12864 {
12865   unsigned size;
12866   enum neon_el_type type;
12867   unsigned destmask;
12868   int i;
12869
12870   destmask = 0;
12871
12872   for (i = 1; i <= N_MAX_NONSPECIAL; i <<= 1)
12873     {
12874       if (el_type_of_type_chk (&type, &size,
12875                                (enum neon_type_mask) (allowed & i)) == SUCCESS)
12876         {
12877           neon_modify_type_size (mods, &type, &size);
12878           destmask |= type_chk_of_el_type (type, size);
12879         }
12880     }
12881
12882   return destmask;
12883 }
12884
12885 /* Check type and return type classification.
12886    The manual states (paraphrase): If one datatype is given, it indicates the
12887    type given in:
12888     - the second operand, if there is one
12889     - the operand, if there is no second operand
12890     - the result, if there are no operands.
12891    This isn't quite good enough though, so we use a concept of a "key" datatype
12892    which is set on a per-instruction basis, which is the one which matters when
12893    only one data type is written.
12894    Note: this function has side-effects (e.g. filling in missing operands). All
12895    Neon instructions should call it before performing bit encoding.  */
12896
12897 static struct neon_type_el
12898 neon_check_type (unsigned els, enum neon_shape ns, ...)
12899 {
12900   va_list ap;
12901   unsigned i, pass, key_el = 0;
12902   unsigned types[NEON_MAX_TYPE_ELS];
12903   enum neon_el_type k_type = NT_invtype;
12904   unsigned k_size = -1u;
12905   struct neon_type_el badtype = {NT_invtype, -1};
12906   unsigned key_allowed = 0;
12907
12908   /* Optional registers in Neon instructions are always (not) in operand 1.
12909      Fill in the missing operand here, if it was omitted.  */
12910   if (els > 1 && !inst.operands[1].present)
12911     inst.operands[1] = inst.operands[0];
12912
12913   /* Suck up all the varargs.  */
12914   va_start (ap, ns);
12915   for (i = 0; i < els; i++)
12916     {
12917       unsigned thisarg = va_arg (ap, unsigned);
12918       if (thisarg == N_IGNORE_TYPE)
12919         {
12920           va_end (ap);
12921           return badtype;
12922         }
12923       types[i] = thisarg;
12924       if ((thisarg & N_KEY) != 0)
12925         key_el = i;
12926     }
12927   va_end (ap);
12928
12929   if (inst.vectype.elems > 0)
12930     for (i = 0; i < els; i++)
12931       if (inst.operands[i].vectype.type != NT_invtype)
12932         {
12933           first_error (_("types specified in both the mnemonic and operands"));
12934           return badtype;
12935         }
12936
12937   /* Duplicate inst.vectype elements here as necessary.
12938      FIXME: No idea if this is exactly the same as the ARM assembler,
12939      particularly when an insn takes one register and one non-register
12940      operand. */
12941   if (inst.vectype.elems == 1 && els > 1)
12942     {
12943       unsigned j;
12944       inst.vectype.elems = els;
12945       inst.vectype.el[key_el] = inst.vectype.el[0];
12946       for (j = 0; j < els; j++)
12947         if (j != key_el)
12948           inst.vectype.el[j] = neon_type_promote (&inst.vectype.el[key_el],
12949                                                   types[j]);
12950     }
12951   else if (inst.vectype.elems == 0 && els > 0)
12952     {
12953       unsigned j;
12954       /* No types were given after the mnemonic, so look for types specified
12955          after each operand. We allow some flexibility here; as long as the
12956          "key" operand has a type, we can infer the others.  */
12957       for (j = 0; j < els; j++)
12958         if (inst.operands[j].vectype.type != NT_invtype)
12959           inst.vectype.el[j] = inst.operands[j].vectype;
12960
12961       if (inst.operands[key_el].vectype.type != NT_invtype)
12962         {
12963           for (j = 0; j < els; j++)
12964             if (inst.operands[j].vectype.type == NT_invtype)
12965               inst.vectype.el[j] = neon_type_promote (&inst.vectype.el[key_el],
12966                                                       types[j]);
12967         }
12968       else
12969         {
12970           first_error (_("operand types can't be inferred"));
12971           return badtype;
12972         }
12973     }
12974   else if (inst.vectype.elems != els)
12975     {
12976       first_error (_("type specifier has the wrong number of parts"));
12977       return badtype;
12978     }
12979
12980   for (pass = 0; pass < 2; pass++)
12981     {
12982       for (i = 0; i < els; i++)
12983         {
12984           unsigned thisarg = types[i];
12985           unsigned types_allowed = ((thisarg & N_EQK) != 0 && pass != 0)
12986             ? modify_types_allowed (key_allowed, thisarg) : thisarg;
12987           enum neon_el_type g_type = inst.vectype.el[i].type;
12988           unsigned g_size = inst.vectype.el[i].size;
12989
12990           /* Decay more-specific signed & unsigned types to sign-insensitive
12991              integer types if sign-specific variants are unavailable.  */
12992           if ((g_type == NT_signed || g_type == NT_unsigned)
12993               && (types_allowed & N_SU_ALL) == 0)
12994             g_type = NT_integer;
12995
12996           /* If only untyped args are allowed, decay any more specific types to
12997              them. Some instructions only care about signs for some element
12998              sizes, so handle that properly.  */
12999           if ((g_size == 8 && (types_allowed & N_8) != 0)
13000               || (g_size == 16 && (types_allowed & N_16) != 0)
13001               || (g_size == 32 && (types_allowed & N_32) != 0)
13002               || (g_size == 64 && (types_allowed & N_64) != 0))
13003             g_type = NT_untyped;
13004
13005           if (pass == 0)
13006             {
13007               if ((thisarg & N_KEY) != 0)
13008                 {
13009                   k_type = g_type;
13010                   k_size = g_size;
13011                   key_allowed = thisarg & ~N_KEY;
13012                 }
13013             }
13014           else
13015             {
13016               if ((thisarg & N_VFP) != 0)
13017                 {
13018                   enum neon_shape_el regshape;
13019                   unsigned regwidth, match;
13020
13021                   /* PR 11136: Catch the case where we are passed a shape of NS_NULL.  */
13022                   if (ns == NS_NULL)
13023                     {
13024                       first_error (_("invalid instruction shape"));
13025                       return badtype;
13026                     }
13027                   regshape = neon_shape_tab[ns].el[i];
13028                   regwidth = neon_shape_el_size[regshape];
13029
13030                   /* In VFP mode, operands must match register widths. If we
13031                      have a key operand, use its width, else use the width of
13032                      the current operand.  */
13033                   if (k_size != -1u)
13034                     match = k_size;
13035                   else
13036                     match = g_size;
13037
13038                   if (regwidth != match)
13039                     {
13040                       first_error (_("operand size must match register width"));
13041                       return badtype;
13042                     }
13043                 }
13044
13045               if ((thisarg & N_EQK) == 0)
13046                 {
13047                   unsigned given_type = type_chk_of_el_type (g_type, g_size);
13048
13049                   if ((given_type & types_allowed) == 0)
13050                     {
13051                       first_error (_("bad type in Neon instruction"));
13052                       return badtype;
13053                     }
13054                 }
13055               else
13056                 {
13057                   enum neon_el_type mod_k_type = k_type;
13058                   unsigned mod_k_size = k_size;
13059                   neon_modify_type_size (thisarg, &mod_k_type, &mod_k_size);
13060                   if (g_type != mod_k_type || g_size != mod_k_size)
13061                     {
13062                       first_error (_("inconsistent types in Neon instruction"));
13063                       return badtype;
13064                     }
13065                 }
13066             }
13067         }
13068     }
13069
13070   return inst.vectype.el[key_el];
13071 }
13072
13073 /* Neon-style VFP instruction forwarding.  */
13074
13075 /* Thumb VFP instructions have 0xE in the condition field.  */
13076
13077 static void
13078 do_vfp_cond_or_thumb (void)
13079 {
13080   inst.is_neon = 1;
13081
13082   if (thumb_mode)
13083     inst.instruction |= 0xe0000000;
13084   else
13085     inst.instruction |= inst.cond << 28;
13086 }
13087
13088 /* Look up and encode a simple mnemonic, for use as a helper function for the
13089    Neon-style VFP syntax.  This avoids duplication of bits of the insns table,
13090    etc.  It is assumed that operand parsing has already been done, and that the
13091    operands are in the form expected by the given opcode (this isn't necessarily
13092    the same as the form in which they were parsed, hence some massaging must
13093    take place before this function is called).
13094    Checks current arch version against that in the looked-up opcode.  */
13095
13096 static void
13097 do_vfp_nsyn_opcode (const char *opname)
13098 {
13099   const struct asm_opcode *opcode;
13100
13101   opcode = (const struct asm_opcode *) hash_find (arm_ops_hsh, opname);
13102
13103   if (!opcode)
13104     abort ();
13105
13106   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant,
13107                 thumb_mode ? *opcode->tvariant : *opcode->avariant),
13108               _(BAD_FPU));
13109
13110   inst.is_neon = 1;
13111
13112   if (thumb_mode)
13113     {
13114       inst.instruction = opcode->tvalue;
13115       opcode->tencode ();
13116     }
13117   else
13118     {
13119       inst.instruction = (inst.cond << 28) | opcode->avalue;
13120       opcode->aencode ();
13121     }
13122 }
13123
13124 static void
13125 do_vfp_nsyn_add_sub (enum neon_shape rs)
13126 {
13127   int is_add = (inst.instruction & 0x0fffffff) == N_MNEM_vadd;
13128
13129   if (rs == NS_FFF)
13130     {
13131       if (is_add)
13132         do_vfp_nsyn_opcode ("fadds");
13133       else
13134         do_vfp_nsyn_opcode ("fsubs");
13135     }
13136   else
13137     {
13138       if (is_add)
13139         do_vfp_nsyn_opcode ("faddd");
13140       else
13141         do_vfp_nsyn_opcode ("fsubd");
13142     }
13143 }
13144
13145 /* Check operand types to see if this is a VFP instruction, and if so call
13146    PFN ().  */
13147
13148 static int
13149 try_vfp_nsyn (int args, void (*pfn) (enum neon_shape))
13150 {
13151   enum neon_shape rs;
13152   struct neon_type_el et;
13153
13154   switch (args)
13155     {
13156     case 2:
13157       rs = neon_select_shape (NS_FF, NS_DD, NS_NULL);
13158       et = neon_check_type (2, rs,
13159         N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13160       break;
13161
13162     case 3:
13163       rs = neon_select_shape (NS_FFF, NS_DDD, NS_NULL);
13164       et = neon_check_type (3, rs,
13165         N_EQK | N_VFP, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13166       break;
13167
13168     default:
13169       abort ();
13170     }
13171
13172   if (et.type != NT_invtype)
13173     {
13174       pfn (rs);
13175       return SUCCESS;
13176     }
13177
13178   inst.error = NULL;
13179   return FAIL;
13180 }
13181
13182 static void
13183 do_vfp_nsyn_mla_mls (enum neon_shape rs)
13184 {
13185   int is_mla = (inst.instruction & 0x0fffffff) == N_MNEM_vmla;
13186
13187   if (rs == NS_FFF)
13188     {
13189       if (is_mla)
13190         do_vfp_nsyn_opcode ("fmacs");
13191       else
13192         do_vfp_nsyn_opcode ("fnmacs");
13193     }
13194   else
13195     {
13196       if (is_mla)
13197         do_vfp_nsyn_opcode ("fmacd");
13198       else
13199         do_vfp_nsyn_opcode ("fnmacd");
13200     }
13201 }
13202
13203 static void
13204 do_vfp_nsyn_fma_fms (enum neon_shape rs)
13205 {
13206   int is_fma = (inst.instruction & 0x0fffffff) == N_MNEM_vfma;
13207
13208   if (rs == NS_FFF)
13209     {
13210       if (is_fma)
13211         do_vfp_nsyn_opcode ("ffmas");
13212       else
13213         do_vfp_nsyn_opcode ("ffnmas");
13214     }
13215   else
13216     {
13217       if (is_fma)
13218         do_vfp_nsyn_opcode ("ffmad");
13219       else
13220         do_vfp_nsyn_opcode ("ffnmad");
13221     }
13222 }
13223
13224 static void
13225 do_vfp_nsyn_mul (enum neon_shape rs)
13226 {
13227   if (rs == NS_FFF)
13228     do_vfp_nsyn_opcode ("fmuls");
13229   else
13230     do_vfp_nsyn_opcode ("fmuld");
13231 }
13232
13233 static void
13234 do_vfp_nsyn_abs_neg (enum neon_shape rs)
13235 {
13236   int is_neg = (inst.instruction & 0x80) != 0;
13237   neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_VFP | N_KEY);
13238
13239   if (rs == NS_FF)
13240     {
13241       if (is_neg)
13242         do_vfp_nsyn_opcode ("fnegs");
13243       else
13244         do_vfp_nsyn_opcode ("fabss");
13245     }
13246   else
13247     {
13248       if (is_neg)
13249         do_vfp_nsyn_opcode ("fnegd");
13250       else
13251         do_vfp_nsyn_opcode ("fabsd");
13252     }
13253 }
13254
13255 /* Encode single-precision (only!) VFP fldm/fstm instructions. Double precision
13256    insns belong to Neon, and are handled elsewhere.  */
13257
13258 static void
13259 do_vfp_nsyn_ldm_stm (int is_dbmode)
13260 {
13261   int is_ldm = (inst.instruction & (1 << 20)) != 0;
13262   if (is_ldm)
13263     {
13264       if (is_dbmode)
13265         do_vfp_nsyn_opcode ("fldmdbs");
13266       else
13267         do_vfp_nsyn_opcode ("fldmias");
13268     }
13269   else
13270     {
13271       if (is_dbmode)
13272         do_vfp_nsyn_opcode ("fstmdbs");
13273       else
13274         do_vfp_nsyn_opcode ("fstmias");
13275     }
13276 }
13277
13278 static void
13279 do_vfp_nsyn_sqrt (void)
13280 {
13281   enum neon_shape rs = neon_select_shape (NS_FF, NS_DD, NS_NULL);
13282   neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13283
13284   if (rs == NS_FF)
13285     do_vfp_nsyn_opcode ("fsqrts");
13286   else
13287     do_vfp_nsyn_opcode ("fsqrtd");
13288 }
13289
13290 static void
13291 do_vfp_nsyn_div (void)
13292 {
13293   enum neon_shape rs = neon_select_shape (NS_FFF, NS_DDD, NS_NULL);
13294   neon_check_type (3, rs, N_EQK | N_VFP, N_EQK | N_VFP,
13295     N_F32 | N_F64 | N_KEY | N_VFP);
13296
13297   if (rs == NS_FFF)
13298     do_vfp_nsyn_opcode ("fdivs");
13299   else
13300     do_vfp_nsyn_opcode ("fdivd");
13301 }
13302
13303 static void
13304 do_vfp_nsyn_nmul (void)
13305 {
13306   enum neon_shape rs = neon_select_shape (NS_FFF, NS_DDD, NS_NULL);
13307   neon_check_type (3, rs, N_EQK | N_VFP, N_EQK | N_VFP,
13308     N_F32 | N_F64 | N_KEY | N_VFP);
13309
13310   if (rs == NS_FFF)
13311     {
13312       NEON_ENCODE (SINGLE, inst);
13313       do_vfp_sp_dyadic ();
13314     }
13315   else
13316     {
13317       NEON_ENCODE (DOUBLE, inst);
13318       do_vfp_dp_rd_rn_rm ();
13319     }
13320   do_vfp_cond_or_thumb ();
13321 }
13322
13323 static void
13324 do_vfp_nsyn_cmp (void)
13325 {
13326   if (inst.operands[1].isreg)
13327     {
13328       enum neon_shape rs = neon_select_shape (NS_FF, NS_DD, NS_NULL);
13329       neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13330
13331       if (rs == NS_FF)
13332         {
13333           NEON_ENCODE (SINGLE, inst);
13334           do_vfp_sp_monadic ();
13335         }
13336       else
13337         {
13338           NEON_ENCODE (DOUBLE, inst);
13339           do_vfp_dp_rd_rm ();
13340         }
13341     }
13342   else
13343     {
13344       enum neon_shape rs = neon_select_shape (NS_FI, NS_DI, NS_NULL);
13345       neon_check_type (2, rs, N_F32 | N_F64 | N_KEY | N_VFP, N_EQK);
13346
13347       switch (inst.instruction & 0x0fffffff)
13348         {
13349         case N_MNEM_vcmp:
13350           inst.instruction += N_MNEM_vcmpz - N_MNEM_vcmp;
13351           break;
13352         case N_MNEM_vcmpe:
13353           inst.instruction += N_MNEM_vcmpez - N_MNEM_vcmpe;
13354           break;
13355         default:
13356           abort ();
13357         }
13358
13359       if (rs == NS_FI)
13360         {
13361           NEON_ENCODE (SINGLE, inst);
13362           do_vfp_sp_compare_z ();
13363         }
13364       else
13365         {
13366           NEON_ENCODE (DOUBLE, inst);
13367           do_vfp_dp_rd ();
13368         }
13369     }
13370   do_vfp_cond_or_thumb ();
13371 }
13372
13373 static void
13374 nsyn_insert_sp (void)
13375 {
13376   inst.operands[1] = inst.operands[0];
13377   memset (&inst.operands[0], '\0', sizeof (inst.operands[0]));
13378   inst.operands[0].reg = REG_SP;
13379   inst.operands[0].isreg = 1;
13380   inst.operands[0].writeback = 1;
13381   inst.operands[0].present = 1;
13382 }
13383
13384 static void
13385 do_vfp_nsyn_push (void)
13386 {
13387   nsyn_insert_sp ();
13388   if (inst.operands[1].issingle)
13389     do_vfp_nsyn_opcode ("fstmdbs");
13390   else
13391     do_vfp_nsyn_opcode ("fstmdbd");
13392 }
13393
13394 static void
13395 do_vfp_nsyn_pop (void)
13396 {
13397   nsyn_insert_sp ();
13398   if (inst.operands[1].issingle)
13399     do_vfp_nsyn_opcode ("fldmias");
13400   else
13401     do_vfp_nsyn_opcode ("fldmiad");
13402 }
13403
13404 /* Fix up Neon data-processing instructions, ORing in the correct bits for
13405    ARM mode or Thumb mode and moving the encoded bit 24 to bit 28.  */
13406
13407 static void
13408 neon_dp_fixup (struct arm_it* insn)
13409 {
13410   unsigned int i = insn->instruction;
13411   insn->is_neon = 1;
13412
13413   if (thumb_mode)
13414     {
13415       /* The U bit is at bit 24 by default. Move to bit 28 in Thumb mode.  */
13416       if (i & (1 << 24))
13417         i |= 1 << 28;
13418
13419       i &= ~(1 << 24);
13420
13421       i |= 0xef000000;
13422     }
13423   else
13424     i |= 0xf2000000;
13425
13426   insn->instruction = i;
13427 }
13428
13429 /* Turn a size (8, 16, 32, 64) into the respective bit number minus 3
13430    (0, 1, 2, 3).  */
13431
13432 static unsigned
13433 neon_logbits (unsigned x)
13434 {
13435   return ffs (x) - 4;
13436 }
13437
13438 #define LOW4(R) ((R) & 0xf)
13439 #define HI1(R) (((R) >> 4) & 1)
13440
13441 /* Encode insns with bit pattern:
13442
13443   |28/24|23|22 |21 20|19 16|15 12|11    8|7|6|5|4|3  0|
13444   |  U  |x |D  |size | Rn  | Rd  |x x x x|N|Q|M|x| Rm |
13445
13446   SIZE is passed in bits. -1 means size field isn't changed, in case it has a
13447   different meaning for some instruction.  */
13448
13449 static void
13450 neon_three_same (int isquad, int ubit, int size)
13451 {
13452   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
13453   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
13454   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
13455   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
13456   inst.instruction |= LOW4 (inst.operands[2].reg);
13457   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
13458   inst.instruction |= (isquad != 0) << 6;
13459   inst.instruction |= (ubit != 0) << 24;
13460   if (size != -1)
13461     inst.instruction |= neon_logbits (size) << 20;
13462
13463   neon_dp_fixup (&inst);
13464 }
13465
13466 /* Encode instructions of the form:
13467
13468   |28/24|23|22|21 20|19 18|17 16|15 12|11      7|6|5|4|3  0|
13469   |  U  |x |D |x  x |size |x  x | Rd  |x x x x x|Q|M|x| Rm |
13470
13471   Don't write size if SIZE == -1.  */
13472
13473 static void
13474 neon_two_same (int qbit, int ubit, int size)
13475 {
13476   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
13477   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
13478   inst.instruction |= LOW4 (inst.operands[1].reg);
13479   inst.instruction |= HI1 (inst.operands[1].reg) << 5;
13480   inst.instruction |= (qbit != 0) << 6;
13481   inst.instruction |= (ubit != 0) << 24;
13482
13483   if (size != -1)
13484     inst.instruction |= neon_logbits (size) << 18;
13485
13486   neon_dp_fixup (&inst);
13487 }
13488
13489 /* Neon instruction encoders, in approximate order of appearance.  */
13490
13491 static void
13492 do_neon_dyadic_i_su (void)
13493 {
13494   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13495   struct neon_type_el et = neon_check_type (3, rs,
13496     N_EQK, N_EQK, N_SU_32 | N_KEY);
13497   neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
13498 }
13499
13500 static void
13501 do_neon_dyadic_i64_su (void)
13502 {
13503   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13504   struct neon_type_el et = neon_check_type (3, rs,
13505     N_EQK, N_EQK, N_SU_ALL | N_KEY);
13506   neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
13507 }
13508
13509 static void
13510 neon_imm_shift (int write_ubit, int uval, int isquad, struct neon_type_el et,
13511                 unsigned immbits)
13512 {
13513   unsigned size = et.size >> 3;
13514   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
13515   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
13516   inst.instruction |= LOW4 (inst.operands[1].reg);
13517   inst.instruction |= HI1 (inst.operands[1].reg) << 5;
13518   inst.instruction |= (isquad != 0) << 6;
13519   inst.instruction |= immbits << 16;
13520   inst.instruction |= (size >> 3) << 7;
13521   inst.instruction |= (size & 0x7) << 19;
13522   if (write_ubit)
13523     inst.instruction |= (uval != 0) << 24;
13524
13525   neon_dp_fixup (&inst);
13526 }
13527
13528 static void
13529 do_neon_shl_imm (void)
13530 {
13531   if (!inst.operands[2].isreg)
13532     {
13533       enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
13534       struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_KEY | N_I_ALL);
13535       NEON_ENCODE (IMMED, inst);
13536       neon_imm_shift (FALSE, 0, neon_quad (rs), et, inst.operands[2].imm);
13537     }
13538   else
13539     {
13540       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13541       struct neon_type_el et = neon_check_type (3, rs,
13542         N_EQK, N_SU_ALL | N_KEY, N_EQK | N_SGN);
13543       unsigned int tmp;
13544
13545       /* VSHL/VQSHL 3-register variants have syntax such as:
13546            vshl.xx Dd, Dm, Dn
13547          whereas other 3-register operations encoded by neon_three_same have
13548          syntax like:
13549            vadd.xx Dd, Dn, Dm
13550          (i.e. with Dn & Dm reversed). Swap operands[1].reg and operands[2].reg
13551          here.  */
13552       tmp = inst.operands[2].reg;
13553       inst.operands[2].reg = inst.operands[1].reg;
13554       inst.operands[1].reg = tmp;
13555       NEON_ENCODE (INTEGER, inst);
13556       neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
13557     }
13558 }
13559
13560 static void
13561 do_neon_qshl_imm (void)
13562 {
13563   if (!inst.operands[2].isreg)
13564     {
13565       enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
13566       struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_ALL | N_KEY);
13567
13568       NEON_ENCODE (IMMED, inst);
13569       neon_imm_shift (TRUE, et.type == NT_unsigned, neon_quad (rs), et,
13570                       inst.operands[2].imm);
13571     }
13572   else
13573     {
13574       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13575       struct neon_type_el et = neon_check_type (3, rs,
13576         N_EQK, N_SU_ALL | N_KEY, N_EQK | N_SGN);
13577       unsigned int tmp;
13578
13579       /* See note in do_neon_shl_imm.  */
13580       tmp = inst.operands[2].reg;
13581       inst.operands[2].reg = inst.operands[1].reg;
13582       inst.operands[1].reg = tmp;
13583       NEON_ENCODE (INTEGER, inst);
13584       neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
13585     }
13586 }
13587
13588 static void
13589 do_neon_rshl (void)
13590 {
13591   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13592   struct neon_type_el et = neon_check_type (3, rs,
13593     N_EQK, N_EQK, N_SU_ALL | N_KEY);
13594   unsigned int tmp;
13595
13596   tmp = inst.operands[2].reg;
13597   inst.operands[2].reg = inst.operands[1].reg;
13598   inst.operands[1].reg = tmp;
13599   neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
13600 }
13601
13602 static int
13603 neon_cmode_for_logic_imm (unsigned immediate, unsigned *immbits, int size)
13604 {
13605   /* Handle .I8 pseudo-instructions.  */
13606   if (size == 8)
13607     {
13608       /* Unfortunately, this will make everything apart from zero out-of-range.
13609          FIXME is this the intended semantics? There doesn't seem much point in
13610          accepting .I8 if so.  */
13611       immediate |= immediate << 8;
13612       size = 16;
13613     }
13614
13615   if (size >= 32)
13616     {
13617       if (immediate == (immediate & 0x000000ff))
13618         {
13619           *immbits = immediate;
13620           return 0x1;
13621         }
13622       else if (immediate == (immediate & 0x0000ff00))
13623         {
13624           *immbits = immediate >> 8;
13625           return 0x3;
13626         }
13627       else if (immediate == (immediate & 0x00ff0000))
13628         {
13629           *immbits = immediate >> 16;
13630           return 0x5;
13631         }
13632       else if (immediate == (immediate & 0xff000000))
13633         {
13634           *immbits = immediate >> 24;
13635           return 0x7;
13636         }
13637       if ((immediate & 0xffff) != (immediate >> 16))
13638         goto bad_immediate;
13639       immediate &= 0xffff;
13640     }
13641
13642   if (immediate == (immediate & 0x000000ff))
13643     {
13644       *immbits = immediate;
13645       return 0x9;
13646     }
13647   else if (immediate == (immediate & 0x0000ff00))
13648     {
13649       *immbits = immediate >> 8;
13650       return 0xb;
13651     }
13652
13653   bad_immediate:
13654   first_error (_("immediate value out of range"));
13655   return FAIL;
13656 }
13657
13658 /* True if IMM has form 0bAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD for bits
13659    A, B, C, D.  */
13660
13661 static int
13662 neon_bits_same_in_bytes (unsigned imm)
13663 {
13664   return ((imm & 0x000000ff) == 0 || (imm & 0x000000ff) == 0x000000ff)
13665          && ((imm & 0x0000ff00) == 0 || (imm & 0x0000ff00) == 0x0000ff00)
13666          && ((imm & 0x00ff0000) == 0 || (imm & 0x00ff0000) == 0x00ff0000)
13667          && ((imm & 0xff000000) == 0 || (imm & 0xff000000) == 0xff000000);
13668 }
13669
13670 /* For immediate of above form, return 0bABCD.  */
13671
13672 static unsigned
13673 neon_squash_bits (unsigned imm)
13674 {
13675   return (imm & 0x01) | ((imm & 0x0100) >> 7) | ((imm & 0x010000) >> 14)
13676          | ((imm & 0x01000000) >> 21);
13677 }
13678
13679 /* Compress quarter-float representation to 0b...000 abcdefgh.  */
13680
13681 static unsigned
13682 neon_qfloat_bits (unsigned imm)
13683 {
13684   return ((imm >> 19) & 0x7f) | ((imm >> 24) & 0x80);
13685 }
13686
13687 /* Returns CMODE. IMMBITS [7:0] is set to bits suitable for inserting into
13688    the instruction. *OP is passed as the initial value of the op field, and
13689    may be set to a different value depending on the constant (i.e.
13690    "MOV I64, 0bAAAAAAAABBBB..." which uses OP = 1 despite being MOV not
13691    MVN).  If the immediate looks like a repeated pattern then also
13692    try smaller element sizes.  */
13693
13694 static int
13695 neon_cmode_for_move_imm (unsigned immlo, unsigned immhi, int float_p,
13696                          unsigned *immbits, int *op, int size,
13697                          enum neon_el_type type)
13698 {
13699   /* Only permit float immediates (including 0.0/-0.0) if the operand type is
13700      float.  */
13701   if (type == NT_float && !float_p)
13702     return FAIL;
13703
13704   if (type == NT_float && is_quarter_float (immlo) && immhi == 0)
13705     {
13706       if (size != 32 || *op == 1)
13707         return FAIL;
13708       *immbits = neon_qfloat_bits (immlo);
13709       return 0xf;
13710     }
13711
13712   if (size == 64)
13713     {
13714       if (neon_bits_same_in_bytes (immhi)
13715           && neon_bits_same_in_bytes (immlo))
13716         {
13717           if (*op == 1)
13718             return FAIL;
13719           *immbits = (neon_squash_bits (immhi) << 4)
13720                      | neon_squash_bits (immlo);
13721           *op = 1;
13722           return 0xe;
13723         }
13724
13725       if (immhi != immlo)
13726         return FAIL;
13727     }
13728
13729   if (size >= 32)
13730     {
13731       if (immlo == (immlo & 0x000000ff))
13732         {
13733           *immbits = immlo;
13734           return 0x0;
13735         }
13736       else if (immlo == (immlo & 0x0000ff00))
13737         {
13738           *immbits = immlo >> 8;
13739           return 0x2;
13740         }
13741       else if (immlo == (immlo & 0x00ff0000))
13742         {
13743           *immbits = immlo >> 16;
13744           return 0x4;
13745         }
13746       else if (immlo == (immlo & 0xff000000))
13747         {
13748           *immbits = immlo >> 24;
13749           return 0x6;
13750         }
13751       else if (immlo == ((immlo & 0x0000ff00) | 0x000000ff))
13752         {
13753           *immbits = (immlo >> 8) & 0xff;
13754           return 0xc;
13755         }
13756       else if (immlo == ((immlo & 0x00ff0000) | 0x0000ffff))
13757         {
13758           *immbits = (immlo >> 16) & 0xff;
13759           return 0xd;
13760         }
13761
13762       if ((immlo & 0xffff) != (immlo >> 16))
13763         return FAIL;
13764       immlo &= 0xffff;
13765     }
13766
13767   if (size >= 16)
13768     {
13769       if (immlo == (immlo & 0x000000ff))
13770         {
13771           *immbits = immlo;
13772           return 0x8;
13773         }
13774       else if (immlo == (immlo & 0x0000ff00))
13775         {
13776           *immbits = immlo >> 8;
13777           return 0xa;
13778         }
13779
13780       if ((immlo & 0xff) != (immlo >> 8))
13781         return FAIL;
13782       immlo &= 0xff;
13783     }
13784
13785   if (immlo == (immlo & 0x000000ff))
13786     {
13787       /* Don't allow MVN with 8-bit immediate.  */
13788       if (*op == 1)
13789         return FAIL;
13790       *immbits = immlo;
13791       return 0xe;
13792     }
13793
13794   return FAIL;
13795 }
13796
13797 /* Write immediate bits [7:0] to the following locations:
13798
13799   |28/24|23     19|18 16|15                    4|3     0|
13800   |  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|
13801
13802   This function is used by VMOV/VMVN/VORR/VBIC.  */
13803
13804 static void
13805 neon_write_immbits (unsigned immbits)
13806 {
13807   inst.instruction |= immbits & 0xf;
13808   inst.instruction |= ((immbits >> 4) & 0x7) << 16;
13809   inst.instruction |= ((immbits >> 7) & 0x1) << 24;
13810 }
13811
13812 /* Invert low-order SIZE bits of XHI:XLO.  */
13813
13814 static void
13815 neon_invert_size (unsigned *xlo, unsigned *xhi, int size)
13816 {
13817   unsigned immlo = xlo ? *xlo : 0;
13818   unsigned immhi = xhi ? *xhi : 0;
13819
13820   switch (size)
13821     {
13822     case 8:
13823       immlo = (~immlo) & 0xff;
13824       break;
13825
13826     case 16:
13827       immlo = (~immlo) & 0xffff;
13828       break;
13829
13830     case 64:
13831       immhi = (~immhi) & 0xffffffff;
13832       /* fall through.  */
13833
13834     case 32:
13835       immlo = (~immlo) & 0xffffffff;
13836       break;
13837
13838     default:
13839       abort ();
13840     }
13841
13842   if (xlo)
13843     *xlo = immlo;
13844
13845   if (xhi)
13846     *xhi = immhi;
13847 }
13848
13849 static void
13850 do_neon_logic (void)
13851 {
13852   if (inst.operands[2].present && inst.operands[2].isreg)
13853     {
13854       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13855       neon_check_type (3, rs, N_IGNORE_TYPE);
13856       /* U bit and size field were set as part of the bitmask.  */
13857       NEON_ENCODE (INTEGER, inst);
13858       neon_three_same (neon_quad (rs), 0, -1);
13859     }
13860   else
13861     {
13862       const int three_ops_form = (inst.operands[2].present
13863                                   && !inst.operands[2].isreg);
13864       const int immoperand = (three_ops_form ? 2 : 1);
13865       enum neon_shape rs = (three_ops_form
13866                             ? neon_select_shape (NS_DDI, NS_QQI, NS_NULL)
13867                             : neon_select_shape (NS_DI, NS_QI, NS_NULL));
13868       struct neon_type_el et = neon_check_type (2, rs,
13869         N_I8 | N_I16 | N_I32 | N_I64 | N_F32 | N_KEY, N_EQK);
13870       enum neon_opc opcode = (enum neon_opc) inst.instruction & 0x0fffffff;
13871       unsigned immbits;
13872       int cmode;
13873
13874       if (et.type == NT_invtype)
13875         return;
13876
13877       if (three_ops_form)
13878         constraint (inst.operands[0].reg != inst.operands[1].reg,
13879                     _("first and second operands shall be the same register"));
13880
13881       NEON_ENCODE (IMMED, inst);
13882
13883       immbits = inst.operands[immoperand].imm;
13884       if (et.size == 64)
13885         {
13886           /* .i64 is a pseudo-op, so the immediate must be a repeating
13887              pattern.  */
13888           if (immbits != (inst.operands[immoperand].regisimm ?
13889                           inst.operands[immoperand].reg : 0))
13890             {
13891               /* Set immbits to an invalid constant.  */
13892               immbits = 0xdeadbeef;
13893             }
13894         }
13895
13896       switch (opcode)
13897         {
13898         case N_MNEM_vbic:
13899           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
13900           break;
13901
13902         case N_MNEM_vorr:
13903           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
13904           break;
13905
13906         case N_MNEM_vand:
13907           /* Pseudo-instruction for VBIC.  */
13908           neon_invert_size (&immbits, 0, et.size);
13909           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
13910           break;
13911
13912         case N_MNEM_vorn:
13913           /* Pseudo-instruction for VORR.  */
13914           neon_invert_size (&immbits, 0, et.size);
13915           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
13916           break;
13917
13918         default:
13919           abort ();
13920         }
13921
13922       if (cmode == FAIL)
13923         return;
13924
13925       inst.instruction |= neon_quad (rs) << 6;
13926       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
13927       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
13928       inst.instruction |= cmode << 8;
13929       neon_write_immbits (immbits);
13930
13931       neon_dp_fixup (&inst);
13932     }
13933 }
13934
13935 static void
13936 do_neon_bitfield (void)
13937 {
13938   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13939   neon_check_type (3, rs, N_IGNORE_TYPE);
13940   neon_three_same (neon_quad (rs), 0, -1);
13941 }
13942
13943 static void
13944 neon_dyadic_misc (enum neon_el_type ubit_meaning, unsigned types,
13945                   unsigned destbits)
13946 {
13947   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13948   struct neon_type_el et = neon_check_type (3, rs, N_EQK | destbits, N_EQK,
13949                                             types | N_KEY);
13950   if (et.type == NT_float)
13951     {
13952       NEON_ENCODE (FLOAT, inst);
13953       neon_three_same (neon_quad (rs), 0, -1);
13954     }
13955   else
13956     {
13957       NEON_ENCODE (INTEGER, inst);
13958       neon_three_same (neon_quad (rs), et.type == ubit_meaning, et.size);
13959     }
13960 }
13961
13962 static void
13963 do_neon_dyadic_if_su (void)
13964 {
13965   neon_dyadic_misc (NT_unsigned, N_SUF_32, 0);
13966 }
13967
13968 static void
13969 do_neon_dyadic_if_su_d (void)
13970 {
13971   /* This version only allow D registers, but that constraint is enforced during
13972      operand parsing so we don't need to do anything extra here.  */
13973   neon_dyadic_misc (NT_unsigned, N_SUF_32, 0);
13974 }
13975
13976 static void
13977 do_neon_dyadic_if_i_d (void)
13978 {
13979   /* The "untyped" case can't happen. Do this to stop the "U" bit being
13980      affected if we specify unsigned args.  */
13981   neon_dyadic_misc (NT_untyped, N_IF_32, 0);
13982 }
13983
13984 enum vfp_or_neon_is_neon_bits
13985 {
13986   NEON_CHECK_CC = 1,
13987   NEON_CHECK_ARCH = 2,
13988   NEON_CHECK_ARCH8 = 4
13989 };
13990
13991 /* Call this function if an instruction which may have belonged to the VFP or
13992    Neon instruction sets, but turned out to be a Neon instruction (due to the
13993    operand types involved, etc.). We have to check and/or fix-up a couple of
13994    things:
13995
13996      - Make sure the user hasn't attempted to make a Neon instruction
13997        conditional.
13998      - Alter the value in the condition code field if necessary.
13999      - Make sure that the arch supports Neon instructions.
14000
14001    Which of these operations take place depends on bits from enum
14002    vfp_or_neon_is_neon_bits.
14003
14004    WARNING: This function has side effects! If NEON_CHECK_CC is used and the
14005    current instruction's condition is COND_ALWAYS, the condition field is
14006    changed to inst.uncond_value. This is necessary because instructions shared
14007    between VFP and Neon may be conditional for the VFP variants only, and the
14008    unconditional Neon version must have, e.g., 0xF in the condition field.  */
14009
14010 static int
14011 vfp_or_neon_is_neon (unsigned check)
14012 {
14013   /* Conditions are always legal in Thumb mode (IT blocks).  */
14014   if (!thumb_mode && (check & NEON_CHECK_CC))
14015     {
14016       if (inst.cond != COND_ALWAYS)
14017         {
14018           first_error (_(BAD_COND));
14019           return FAIL;
14020         }
14021       if (inst.uncond_value != -1)
14022         inst.instruction |= inst.uncond_value << 28;
14023     }
14024
14025   if ((check & NEON_CHECK_ARCH)
14026       && !mark_feature_used (&fpu_neon_ext_v1))
14027     {
14028       first_error (_(BAD_FPU));
14029       return FAIL;
14030     }
14031
14032   if ((check & NEON_CHECK_ARCH8)
14033       && !mark_feature_used (&fpu_neon_ext_armv8))
14034     {
14035       first_error (_(BAD_FPU));
14036       return FAIL;
14037     }
14038
14039   return SUCCESS;
14040 }
14041
14042 static void
14043 do_neon_addsub_if_i (void)
14044 {
14045   if (try_vfp_nsyn (3, do_vfp_nsyn_add_sub) == SUCCESS)
14046     return;
14047
14048   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14049     return;
14050
14051   /* The "untyped" case can't happen. Do this to stop the "U" bit being
14052      affected if we specify unsigned args.  */
14053   neon_dyadic_misc (NT_untyped, N_IF_32 | N_I64, 0);
14054 }
14055
14056 /* Swaps operands 1 and 2. If operand 1 (optional arg) was omitted, we want the
14057    result to be:
14058      V<op> A,B     (A is operand 0, B is operand 2)
14059    to mean:
14060      V<op> A,B,A
14061    not:
14062      V<op> A,B,B
14063    so handle that case specially.  */
14064
14065 static void
14066 neon_exchange_operands (void)
14067 {
14068   void *scratch = alloca (sizeof (inst.operands[0]));
14069   if (inst.operands[1].present)
14070     {
14071       /* Swap operands[1] and operands[2].  */
14072       memcpy (scratch, &inst.operands[1], sizeof (inst.operands[0]));
14073       inst.operands[1] = inst.operands[2];
14074       memcpy (&inst.operands[2], scratch, sizeof (inst.operands[0]));
14075     }
14076   else
14077     {
14078       inst.operands[1] = inst.operands[2];
14079       inst.operands[2] = inst.operands[0];
14080     }
14081 }
14082
14083 static void
14084 neon_compare (unsigned regtypes, unsigned immtypes, int invert)
14085 {
14086   if (inst.operands[2].isreg)
14087     {
14088       if (invert)
14089         neon_exchange_operands ();
14090       neon_dyadic_misc (NT_unsigned, regtypes, N_SIZ);
14091     }
14092   else
14093     {
14094       enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14095       struct neon_type_el et = neon_check_type (2, rs,
14096         N_EQK | N_SIZ, immtypes | N_KEY);
14097
14098       NEON_ENCODE (IMMED, inst);
14099       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14100       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14101       inst.instruction |= LOW4 (inst.operands[1].reg);
14102       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14103       inst.instruction |= neon_quad (rs) << 6;
14104       inst.instruction |= (et.type == NT_float) << 10;
14105       inst.instruction |= neon_logbits (et.size) << 18;
14106
14107       neon_dp_fixup (&inst);
14108     }
14109 }
14110
14111 static void
14112 do_neon_cmp (void)
14113 {
14114   neon_compare (N_SUF_32, N_S8 | N_S16 | N_S32 | N_F32, FALSE);
14115 }
14116
14117 static void
14118 do_neon_cmp_inv (void)
14119 {
14120   neon_compare (N_SUF_32, N_S8 | N_S16 | N_S32 | N_F32, TRUE);
14121 }
14122
14123 static void
14124 do_neon_ceq (void)
14125 {
14126   neon_compare (N_IF_32, N_IF_32, FALSE);
14127 }
14128
14129 /* For multiply instructions, we have the possibility of 16-bit or 32-bit
14130    scalars, which are encoded in 5 bits, M : Rm.
14131    For 16-bit scalars, the register is encoded in Rm[2:0] and the index in
14132    M:Rm[3], and for 32-bit scalars, the register is encoded in Rm[3:0] and the
14133    index in M.  */
14134
14135 static unsigned
14136 neon_scalar_for_mul (unsigned scalar, unsigned elsize)
14137 {
14138   unsigned regno = NEON_SCALAR_REG (scalar);
14139   unsigned elno = NEON_SCALAR_INDEX (scalar);
14140
14141   switch (elsize)
14142     {
14143     case 16:
14144       if (regno > 7 || elno > 3)
14145         goto bad_scalar;
14146       return regno | (elno << 3);
14147
14148     case 32:
14149       if (regno > 15 || elno > 1)
14150         goto bad_scalar;
14151       return regno | (elno << 4);
14152
14153     default:
14154     bad_scalar:
14155       first_error (_("scalar out of range for multiply instruction"));
14156     }
14157
14158   return 0;
14159 }
14160
14161 /* Encode multiply / multiply-accumulate scalar instructions.  */
14162
14163 static void
14164 neon_mul_mac (struct neon_type_el et, int ubit)
14165 {
14166   unsigned scalar;
14167
14168   /* Give a more helpful error message if we have an invalid type.  */
14169   if (et.type == NT_invtype)
14170     return;
14171
14172   scalar = neon_scalar_for_mul (inst.operands[2].reg, et.size);
14173   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14174   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14175   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
14176   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
14177   inst.instruction |= LOW4 (scalar);
14178   inst.instruction |= HI1 (scalar) << 5;
14179   inst.instruction |= (et.type == NT_float) << 8;
14180   inst.instruction |= neon_logbits (et.size) << 20;
14181   inst.instruction |= (ubit != 0) << 24;
14182
14183   neon_dp_fixup (&inst);
14184 }
14185
14186 static void
14187 do_neon_mac_maybe_scalar (void)
14188 {
14189   if (try_vfp_nsyn (3, do_vfp_nsyn_mla_mls) == SUCCESS)
14190     return;
14191
14192   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14193     return;
14194
14195   if (inst.operands[2].isscalar)
14196     {
14197       enum neon_shape rs = neon_select_shape (NS_DDS, NS_QQS, NS_NULL);
14198       struct neon_type_el et = neon_check_type (3, rs,
14199         N_EQK, N_EQK, N_I16 | N_I32 | N_F32 | N_KEY);
14200       NEON_ENCODE (SCALAR, inst);
14201       neon_mul_mac (et, neon_quad (rs));
14202     }
14203   else
14204     {
14205       /* The "untyped" case can't happen.  Do this to stop the "U" bit being
14206          affected if we specify unsigned args.  */
14207       neon_dyadic_misc (NT_untyped, N_IF_32, 0);
14208     }
14209 }
14210
14211 static void
14212 do_neon_fmac (void)
14213 {
14214   if (try_vfp_nsyn (3, do_vfp_nsyn_fma_fms) == SUCCESS)
14215     return;
14216
14217   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14218     return;
14219
14220   neon_dyadic_misc (NT_untyped, N_IF_32, 0);
14221 }
14222
14223 static void
14224 do_neon_tst (void)
14225 {
14226   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14227   struct neon_type_el et = neon_check_type (3, rs,
14228     N_EQK, N_EQK, N_8 | N_16 | N_32 | N_KEY);
14229   neon_three_same (neon_quad (rs), 0, et.size);
14230 }
14231
14232 /* VMUL with 3 registers allows the P8 type. The scalar version supports the
14233    same types as the MAC equivalents. The polynomial type for this instruction
14234    is encoded the same as the integer type.  */
14235
14236 static void
14237 do_neon_mul (void)
14238 {
14239   if (try_vfp_nsyn (3, do_vfp_nsyn_mul) == SUCCESS)
14240     return;
14241
14242   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14243     return;
14244
14245   if (inst.operands[2].isscalar)
14246     do_neon_mac_maybe_scalar ();
14247   else
14248     neon_dyadic_misc (NT_poly, N_I8 | N_I16 | N_I32 | N_F32 | N_P8, 0);
14249 }
14250
14251 static void
14252 do_neon_qdmulh (void)
14253 {
14254   if (inst.operands[2].isscalar)
14255     {
14256       enum neon_shape rs = neon_select_shape (NS_DDS, NS_QQS, NS_NULL);
14257       struct neon_type_el et = neon_check_type (3, rs,
14258         N_EQK, N_EQK, N_S16 | N_S32 | N_KEY);
14259       NEON_ENCODE (SCALAR, inst);
14260       neon_mul_mac (et, neon_quad (rs));
14261     }
14262   else
14263     {
14264       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14265       struct neon_type_el et = neon_check_type (3, rs,
14266         N_EQK, N_EQK, N_S16 | N_S32 | N_KEY);
14267       NEON_ENCODE (INTEGER, inst);
14268       /* The U bit (rounding) comes from bit mask.  */
14269       neon_three_same (neon_quad (rs), 0, et.size);
14270     }
14271 }
14272
14273 static void
14274 do_neon_fcmp_absolute (void)
14275 {
14276   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14277   neon_check_type (3, rs, N_EQK, N_EQK, N_F32 | N_KEY);
14278   /* Size field comes from bit mask.  */
14279   neon_three_same (neon_quad (rs), 1, -1);
14280 }
14281
14282 static void
14283 do_neon_fcmp_absolute_inv (void)
14284 {
14285   neon_exchange_operands ();
14286   do_neon_fcmp_absolute ();
14287 }
14288
14289 static void
14290 do_neon_step (void)
14291 {
14292   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14293   neon_check_type (3, rs, N_EQK, N_EQK, N_F32 | N_KEY);
14294   neon_three_same (neon_quad (rs), 0, -1);
14295 }
14296
14297 static void
14298 do_neon_abs_neg (void)
14299 {
14300   enum neon_shape rs;
14301   struct neon_type_el et;
14302
14303   if (try_vfp_nsyn (2, do_vfp_nsyn_abs_neg) == SUCCESS)
14304     return;
14305
14306   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14307     return;
14308
14309   rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
14310   et = neon_check_type (2, rs, N_EQK, N_S8 | N_S16 | N_S32 | N_F32 | N_KEY);
14311
14312   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14313   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14314   inst.instruction |= LOW4 (inst.operands[1].reg);
14315   inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14316   inst.instruction |= neon_quad (rs) << 6;
14317   inst.instruction |= (et.type == NT_float) << 10;
14318   inst.instruction |= neon_logbits (et.size) << 18;
14319
14320   neon_dp_fixup (&inst);
14321 }
14322
14323 static void
14324 do_neon_sli (void)
14325 {
14326   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14327   struct neon_type_el et = neon_check_type (2, rs,
14328     N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
14329   int imm = inst.operands[2].imm;
14330   constraint (imm < 0 || (unsigned)imm >= et.size,
14331               _("immediate out of range for insert"));
14332   neon_imm_shift (FALSE, 0, neon_quad (rs), et, imm);
14333 }
14334
14335 static void
14336 do_neon_sri (void)
14337 {
14338   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14339   struct neon_type_el et = neon_check_type (2, rs,
14340     N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
14341   int imm = inst.operands[2].imm;
14342   constraint (imm < 1 || (unsigned)imm > et.size,
14343               _("immediate out of range for insert"));
14344   neon_imm_shift (FALSE, 0, neon_quad (rs), et, et.size - imm);
14345 }
14346
14347 static void
14348 do_neon_qshlu_imm (void)
14349 {
14350   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14351   struct neon_type_el et = neon_check_type (2, rs,
14352     N_EQK | N_UNS, N_S8 | N_S16 | N_S32 | N_S64 | N_KEY);
14353   int imm = inst.operands[2].imm;
14354   constraint (imm < 0 || (unsigned)imm >= et.size,
14355               _("immediate out of range for shift"));
14356   /* Only encodes the 'U present' variant of the instruction.
14357      In this case, signed types have OP (bit 8) set to 0.
14358      Unsigned types have OP set to 1.  */
14359   inst.instruction |= (et.type == NT_unsigned) << 8;
14360   /* The rest of the bits are the same as other immediate shifts.  */
14361   neon_imm_shift (FALSE, 0, neon_quad (rs), et, imm);
14362 }
14363
14364 static void
14365 do_neon_qmovn (void)
14366 {
14367   struct neon_type_el et = neon_check_type (2, NS_DQ,
14368     N_EQK | N_HLF, N_SU_16_64 | N_KEY);
14369   /* Saturating move where operands can be signed or unsigned, and the
14370      destination has the same signedness.  */
14371   NEON_ENCODE (INTEGER, inst);
14372   if (et.type == NT_unsigned)
14373     inst.instruction |= 0xc0;
14374   else
14375     inst.instruction |= 0x80;
14376   neon_two_same (0, 1, et.size / 2);
14377 }
14378
14379 static void
14380 do_neon_qmovun (void)
14381 {
14382   struct neon_type_el et = neon_check_type (2, NS_DQ,
14383     N_EQK | N_HLF | N_UNS, N_S16 | N_S32 | N_S64 | N_KEY);
14384   /* Saturating move with unsigned results. Operands must be signed.  */
14385   NEON_ENCODE (INTEGER, inst);
14386   neon_two_same (0, 1, et.size / 2);
14387 }
14388
14389 static void
14390 do_neon_rshift_sat_narrow (void)
14391 {
14392   /* FIXME: Types for narrowing. If operands are signed, results can be signed
14393      or unsigned. If operands are unsigned, results must also be unsigned.  */
14394   struct neon_type_el et = neon_check_type (2, NS_DQI,
14395     N_EQK | N_HLF, N_SU_16_64 | N_KEY);
14396   int imm = inst.operands[2].imm;
14397   /* This gets the bounds check, size encoding and immediate bits calculation
14398      right.  */
14399   et.size /= 2;
14400
14401   /* VQ{R}SHRN.I<size> <Dd>, <Qm>, #0 is a synonym for
14402      VQMOVN.I<size> <Dd>, <Qm>.  */
14403   if (imm == 0)
14404     {
14405       inst.operands[2].present = 0;
14406       inst.instruction = N_MNEM_vqmovn;
14407       do_neon_qmovn ();
14408       return;
14409     }
14410
14411   constraint (imm < 1 || (unsigned)imm > et.size,
14412               _("immediate out of range"));
14413   neon_imm_shift (TRUE, et.type == NT_unsigned, 0, et, et.size - imm);
14414 }
14415
14416 static void
14417 do_neon_rshift_sat_narrow_u (void)
14418 {
14419   /* FIXME: Types for narrowing. If operands are signed, results can be signed
14420      or unsigned. If operands are unsigned, results must also be unsigned.  */
14421   struct neon_type_el et = neon_check_type (2, NS_DQI,
14422     N_EQK | N_HLF | N_UNS, N_S16 | N_S32 | N_S64 | N_KEY);
14423   int imm = inst.operands[2].imm;
14424   /* This gets the bounds check, size encoding and immediate bits calculation
14425      right.  */
14426   et.size /= 2;
14427
14428   /* VQSHRUN.I<size> <Dd>, <Qm>, #0 is a synonym for
14429      VQMOVUN.I<size> <Dd>, <Qm>.  */
14430   if (imm == 0)
14431     {
14432       inst.operands[2].present = 0;
14433       inst.instruction = N_MNEM_vqmovun;
14434       do_neon_qmovun ();
14435       return;
14436     }
14437
14438   constraint (imm < 1 || (unsigned)imm > et.size,
14439               _("immediate out of range"));
14440   /* FIXME: The manual is kind of unclear about what value U should have in
14441      VQ{R}SHRUN instructions, but U=0, op=0 definitely encodes VRSHR, so it
14442      must be 1.  */
14443   neon_imm_shift (TRUE, 1, 0, et, et.size - imm);
14444 }
14445
14446 static void
14447 do_neon_movn (void)
14448 {
14449   struct neon_type_el et = neon_check_type (2, NS_DQ,
14450     N_EQK | N_HLF, N_I16 | N_I32 | N_I64 | N_KEY);
14451   NEON_ENCODE (INTEGER, inst);
14452   neon_two_same (0, 1, et.size / 2);
14453 }
14454
14455 static void
14456 do_neon_rshift_narrow (void)
14457 {
14458   struct neon_type_el et = neon_check_type (2, NS_DQI,
14459     N_EQK | N_HLF, N_I16 | N_I32 | N_I64 | N_KEY);
14460   int imm = inst.operands[2].imm;
14461   /* This gets the bounds check, size encoding and immediate bits calculation
14462      right.  */
14463   et.size /= 2;
14464
14465   /* If immediate is zero then we are a pseudo-instruction for
14466      VMOVN.I<size> <Dd>, <Qm>  */
14467   if (imm == 0)
14468     {
14469       inst.operands[2].present = 0;
14470       inst.instruction = N_MNEM_vmovn;
14471       do_neon_movn ();
14472       return;
14473     }
14474
14475   constraint (imm < 1 || (unsigned)imm > et.size,
14476               _("immediate out of range for narrowing operation"));
14477   neon_imm_shift (FALSE, 0, 0, et, et.size - imm);
14478 }
14479
14480 static void
14481 do_neon_shll (void)
14482 {
14483   /* FIXME: Type checking when lengthening.  */
14484   struct neon_type_el et = neon_check_type (2, NS_QDI,
14485     N_EQK | N_DBL, N_I8 | N_I16 | N_I32 | N_KEY);
14486   unsigned imm = inst.operands[2].imm;
14487
14488   if (imm == et.size)
14489     {
14490       /* Maximum shift variant.  */
14491       NEON_ENCODE (INTEGER, inst);
14492       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14493       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14494       inst.instruction |= LOW4 (inst.operands[1].reg);
14495       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14496       inst.instruction |= neon_logbits (et.size) << 18;
14497
14498       neon_dp_fixup (&inst);
14499     }
14500   else
14501     {
14502       /* A more-specific type check for non-max versions.  */
14503       et = neon_check_type (2, NS_QDI,
14504         N_EQK | N_DBL, N_SU_32 | N_KEY);
14505       NEON_ENCODE (IMMED, inst);
14506       neon_imm_shift (TRUE, et.type == NT_unsigned, 0, et, imm);
14507     }
14508 }
14509
14510 /* Check the various types for the VCVT instruction, and return which version
14511    the current instruction is.  */
14512
14513 static int
14514 neon_cvt_flavour (enum neon_shape rs)
14515 {
14516 #define CVT_VAR(C,X,Y)                                                  \
14517   et = neon_check_type (2, rs, whole_reg | (X), whole_reg | (Y));       \
14518   if (et.type != NT_invtype)                                            \
14519     {                                                                   \
14520       inst.error = NULL;                                                \
14521       return (C);                                                       \
14522     }
14523   struct neon_type_el et;
14524   unsigned whole_reg = (rs == NS_FFI || rs == NS_FD || rs == NS_DF
14525                         || rs == NS_FF) ? N_VFP : 0;
14526   /* The instruction versions which take an immediate take one register
14527      argument, which is extended to the width of the full register. Thus the
14528      "source" and "destination" registers must have the same width.  Hack that
14529      here by making the size equal to the key (wider, in this case) operand.  */
14530   unsigned key = (rs == NS_QQI || rs == NS_DDI || rs == NS_FFI) ? N_KEY : 0;
14531
14532   CVT_VAR (0, N_S32, N_F32);
14533   CVT_VAR (1, N_U32, N_F32);
14534   CVT_VAR (2, N_F32, N_S32);
14535   CVT_VAR (3, N_F32, N_U32);
14536   /* Half-precision conversions.  */
14537   CVT_VAR (4, N_F32, N_F16);
14538   CVT_VAR (5, N_F16, N_F32);
14539
14540   whole_reg = N_VFP;
14541
14542   /* VFP instructions.  */
14543   CVT_VAR (6, N_F32, N_F64);
14544   CVT_VAR (7, N_F64, N_F32);
14545   CVT_VAR (8, N_S32, N_F64 | key);
14546   CVT_VAR (9, N_U32, N_F64 | key);
14547   CVT_VAR (10, N_F64 | key, N_S32);
14548   CVT_VAR (11, N_F64 | key, N_U32);
14549   /* VFP instructions with bitshift.  */
14550   CVT_VAR (12, N_F32 | key, N_S16);
14551   CVT_VAR (13, N_F32 | key, N_U16);
14552   CVT_VAR (14, N_F64 | key, N_S16);
14553   CVT_VAR (15, N_F64 | key, N_U16);
14554   CVT_VAR (16, N_S16, N_F32 | key);
14555   CVT_VAR (17, N_U16, N_F32 | key);
14556   CVT_VAR (18, N_S16, N_F64 | key);
14557   CVT_VAR (19, N_U16, N_F64 | key);
14558
14559   return -1;
14560 #undef CVT_VAR
14561 }
14562
14563 /* Neon-syntax VFP conversions.  */
14564
14565 static void
14566 do_vfp_nsyn_cvt (enum neon_shape rs, int flavour)
14567 {
14568   const char *opname = 0;
14569
14570   if (rs == NS_DDI || rs == NS_QQI || rs == NS_FFI)
14571     {
14572       /* Conversions with immediate bitshift.  */
14573       const char *enc[] =
14574         {
14575           "ftosls",
14576           "ftouls",
14577           "fsltos",
14578           "fultos",
14579           NULL,
14580           NULL,
14581           NULL,
14582           NULL,
14583           "ftosld",
14584           "ftould",
14585           "fsltod",
14586           "fultod",
14587           "fshtos",
14588           "fuhtos",
14589           "fshtod",
14590           "fuhtod",
14591           "ftoshs",
14592           "ftouhs",
14593           "ftoshd",
14594           "ftouhd"
14595         };
14596
14597       if (flavour >= 0 && flavour < (int) ARRAY_SIZE (enc))
14598         {
14599           opname = enc[flavour];
14600           constraint (inst.operands[0].reg != inst.operands[1].reg,
14601                       _("operands 0 and 1 must be the same register"));
14602           inst.operands[1] = inst.operands[2];
14603           memset (&inst.operands[2], '\0', sizeof (inst.operands[2]));
14604         }
14605     }
14606   else
14607     {
14608       /* Conversions without bitshift.  */
14609       const char *enc[] =
14610         {
14611           "ftosis",
14612           "ftouis",
14613           "fsitos",
14614           "fuitos",
14615           "NULL",
14616           "NULL",
14617           "fcvtsd",
14618           "fcvtds",
14619           "ftosid",
14620           "ftouid",
14621           "fsitod",
14622           "fuitod"
14623         };
14624
14625       if (flavour >= 0 && flavour < (int) ARRAY_SIZE (enc))
14626         opname = enc[flavour];
14627     }
14628
14629   if (opname)
14630     do_vfp_nsyn_opcode (opname);
14631 }
14632
14633 static void
14634 do_vfp_nsyn_cvtz (void)
14635 {
14636   enum neon_shape rs = neon_select_shape (NS_FF, NS_FD, NS_NULL);
14637   int flavour = neon_cvt_flavour (rs);
14638   const char *enc[] =
14639     {
14640       "ftosizs",
14641       "ftouizs",
14642       NULL,
14643       NULL,
14644       NULL,
14645       NULL,
14646       NULL,
14647       NULL,
14648       "ftosizd",
14649       "ftouizd"
14650     };
14651
14652   if (flavour >= 0 && flavour < (int) ARRAY_SIZE (enc) && enc[flavour])
14653     do_vfp_nsyn_opcode (enc[flavour]);
14654 }
14655
14656 static void
14657 do_neon_cvt_1 (bfd_boolean round_to_zero ATTRIBUTE_UNUSED)
14658 {
14659   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_FFI, NS_DD, NS_QQ,
14660     NS_FD, NS_DF, NS_FF, NS_QD, NS_DQ, NS_NULL);
14661   int flavour = neon_cvt_flavour (rs);
14662
14663   /* PR11109: Handle round-to-zero for VCVT conversions.  */
14664   if (round_to_zero
14665       && ARM_CPU_HAS_FEATURE (cpu_variant, fpu_arch_vfp_v2)
14666       && (flavour == 0 || flavour == 1 || flavour == 8 || flavour == 9)
14667       && (rs == NS_FD || rs == NS_FF))
14668     {
14669       do_vfp_nsyn_cvtz ();
14670       return;
14671     }
14672
14673   /* VFP rather than Neon conversions.  */
14674   if (flavour >= 6)
14675     {
14676       do_vfp_nsyn_cvt (rs, flavour);
14677       return;
14678     }
14679
14680   switch (rs)
14681     {
14682     case NS_DDI:
14683     case NS_QQI:
14684       {
14685         unsigned immbits;
14686         unsigned enctab[] = { 0x0000100, 0x1000100, 0x0, 0x1000000 };
14687
14688         if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14689           return;
14690
14691         /* Fixed-point conversion with #0 immediate is encoded as an
14692            integer conversion.  */
14693         if (inst.operands[2].present && inst.operands[2].imm == 0)
14694           goto int_encode;
14695        immbits = 32 - inst.operands[2].imm;
14696         NEON_ENCODE (IMMED, inst);
14697         if (flavour != -1)
14698           inst.instruction |= enctab[flavour];
14699         inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14700         inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14701         inst.instruction |= LOW4 (inst.operands[1].reg);
14702         inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14703         inst.instruction |= neon_quad (rs) << 6;
14704         inst.instruction |= 1 << 21;
14705         inst.instruction |= immbits << 16;
14706
14707         neon_dp_fixup (&inst);
14708       }
14709       break;
14710
14711     case NS_DD:
14712     case NS_QQ:
14713     int_encode:
14714       {
14715         unsigned enctab[] = { 0x100, 0x180, 0x0, 0x080 };
14716
14717         NEON_ENCODE (INTEGER, inst);
14718
14719         if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14720           return;
14721
14722         if (flavour != -1)
14723           inst.instruction |= enctab[flavour];
14724
14725         inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14726         inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14727         inst.instruction |= LOW4 (inst.operands[1].reg);
14728         inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14729         inst.instruction |= neon_quad (rs) << 6;
14730         inst.instruction |= 2 << 18;
14731
14732         neon_dp_fixup (&inst);
14733       }
14734     break;
14735
14736     /* Half-precision conversions for Advanced SIMD -- neon.  */
14737     case NS_QD:
14738     case NS_DQ:
14739
14740       if ((rs == NS_DQ)
14741           && (inst.vectype.el[0].size != 16 || inst.vectype.el[1].size != 32))
14742           {
14743             as_bad (_("operand size must match register width"));
14744             break;
14745           }
14746
14747       if ((rs == NS_QD)
14748           && ((inst.vectype.el[0].size != 32 || inst.vectype.el[1].size != 16)))
14749           {
14750             as_bad (_("operand size must match register width"));
14751             break;
14752           }
14753
14754       if (rs == NS_DQ)
14755         inst.instruction = 0x3b60600;
14756       else
14757         inst.instruction = 0x3b60700;
14758
14759       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14760       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14761       inst.instruction |= LOW4 (inst.operands[1].reg);
14762       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14763       neon_dp_fixup (&inst);
14764       break;
14765
14766     default:
14767       /* Some VFP conversions go here (s32 <-> f32, u32 <-> f32).  */
14768       do_vfp_nsyn_cvt (rs, flavour);
14769     }
14770 }
14771
14772 static void
14773 do_neon_cvtr (void)
14774 {
14775   do_neon_cvt_1 (FALSE);
14776 }
14777
14778 static void
14779 do_neon_cvt (void)
14780 {
14781   do_neon_cvt_1 (TRUE);
14782 }
14783
14784 static void
14785 do_neon_cvtb (void)
14786 {
14787   inst.instruction = 0xeb20a40;
14788
14789   /* The sizes are attached to the mnemonic.  */
14790   if (inst.vectype.el[0].type != NT_invtype
14791       && inst.vectype.el[0].size == 16)
14792     inst.instruction |= 0x00010000;
14793
14794   /* Programmer's syntax: the sizes are attached to the operands.  */
14795   else if (inst.operands[0].vectype.type != NT_invtype
14796            && inst.operands[0].vectype.size == 16)
14797     inst.instruction |= 0x00010000;
14798
14799   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
14800   encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sm);
14801   do_vfp_cond_or_thumb ();
14802 }
14803
14804
14805 static void
14806 do_neon_cvtt (void)
14807 {
14808   do_neon_cvtb ();
14809   inst.instruction |= 0x80;
14810 }
14811
14812 static void
14813 neon_move_immediate (void)
14814 {
14815   enum neon_shape rs = neon_select_shape (NS_DI, NS_QI, NS_NULL);
14816   struct neon_type_el et = neon_check_type (2, rs,
14817     N_I8 | N_I16 | N_I32 | N_I64 | N_F32 | N_KEY, N_EQK);
14818   unsigned immlo, immhi = 0, immbits;
14819   int op, cmode, float_p;
14820
14821   constraint (et.type == NT_invtype,
14822               _("operand size must be specified for immediate VMOV"));
14823
14824   /* We start out as an MVN instruction if OP = 1, MOV otherwise.  */
14825   op = (inst.instruction & (1 << 5)) != 0;
14826
14827   immlo = inst.operands[1].imm;
14828   if (inst.operands[1].regisimm)
14829     immhi = inst.operands[1].reg;
14830
14831   constraint (et.size < 32 && (immlo & ~((1 << et.size) - 1)) != 0,
14832               _("immediate has bits set outside the operand size"));
14833
14834   float_p = inst.operands[1].immisfloat;
14835
14836   if ((cmode = neon_cmode_for_move_imm (immlo, immhi, float_p, &immbits, &op,
14837                                         et.size, et.type)) == FAIL)
14838     {
14839       /* Invert relevant bits only.  */
14840       neon_invert_size (&immlo, &immhi, et.size);
14841       /* Flip from VMOV/VMVN to VMVN/VMOV. Some immediate types are unavailable
14842          with one or the other; those cases are caught by
14843          neon_cmode_for_move_imm.  */
14844       op = !op;
14845       if ((cmode = neon_cmode_for_move_imm (immlo, immhi, float_p, &immbits,
14846                                             &op, et.size, et.type)) == FAIL)
14847         {
14848           first_error (_("immediate out of range"));
14849           return;
14850         }
14851     }
14852
14853   inst.instruction &= ~(1 << 5);
14854   inst.instruction |= op << 5;
14855
14856   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14857   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14858   inst.instruction |= neon_quad (rs) << 6;
14859   inst.instruction |= cmode << 8;
14860
14861   neon_write_immbits (immbits);
14862 }
14863
14864 static void
14865 do_neon_mvn (void)
14866 {
14867   if (inst.operands[1].isreg)
14868     {
14869       enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
14870
14871       NEON_ENCODE (INTEGER, inst);
14872       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14873       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14874       inst.instruction |= LOW4 (inst.operands[1].reg);
14875       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14876       inst.instruction |= neon_quad (rs) << 6;
14877     }
14878   else
14879     {
14880       NEON_ENCODE (IMMED, inst);
14881       neon_move_immediate ();
14882     }
14883
14884   neon_dp_fixup (&inst);
14885 }
14886
14887 /* Encode instructions of form:
14888
14889   |28/24|23|22|21 20|19 16|15 12|11    8|7|6|5|4|3  0|
14890   |  U  |x |D |size | Rn  | Rd  |x x x x|N|x|M|x| Rm |  */
14891
14892 static void
14893 neon_mixed_length (struct neon_type_el et, unsigned size)
14894 {
14895   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14896   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14897   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
14898   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
14899   inst.instruction |= LOW4 (inst.operands[2].reg);
14900   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
14901   inst.instruction |= (et.type == NT_unsigned) << 24;
14902   inst.instruction |= neon_logbits (size) << 20;
14903
14904   neon_dp_fixup (&inst);
14905 }
14906
14907 static void
14908 do_neon_dyadic_long (void)
14909 {
14910   /* FIXME: Type checking for lengthening op.  */
14911   struct neon_type_el et = neon_check_type (3, NS_QDD,
14912     N_EQK | N_DBL, N_EQK, N_SU_32 | N_KEY);
14913   neon_mixed_length (et, et.size);
14914 }
14915
14916 static void
14917 do_neon_abal (void)
14918 {
14919   struct neon_type_el et = neon_check_type (3, NS_QDD,
14920     N_EQK | N_INT | N_DBL, N_EQK, N_SU_32 | N_KEY);
14921   neon_mixed_length (et, et.size);
14922 }
14923
14924 static void
14925 neon_mac_reg_scalar_long (unsigned regtypes, unsigned scalartypes)
14926 {
14927   if (inst.operands[2].isscalar)
14928     {
14929       struct neon_type_el et = neon_check_type (3, NS_QDS,
14930         N_EQK | N_DBL, N_EQK, regtypes | N_KEY);
14931       NEON_ENCODE (SCALAR, inst);
14932       neon_mul_mac (et, et.type == NT_unsigned);
14933     }
14934   else
14935     {
14936       struct neon_type_el et = neon_check_type (3, NS_QDD,
14937         N_EQK | N_DBL, N_EQK, scalartypes | N_KEY);
14938       NEON_ENCODE (INTEGER, inst);
14939       neon_mixed_length (et, et.size);
14940     }
14941 }
14942
14943 static void
14944 do_neon_mac_maybe_scalar_long (void)
14945 {
14946   neon_mac_reg_scalar_long (N_S16 | N_S32 | N_U16 | N_U32, N_SU_32);
14947 }
14948
14949 static void
14950 do_neon_dyadic_wide (void)
14951 {
14952   struct neon_type_el et = neon_check_type (3, NS_QQD,
14953     N_EQK | N_DBL, N_EQK | N_DBL, N_SU_32 | N_KEY);
14954   neon_mixed_length (et, et.size);
14955 }
14956
14957 static void
14958 do_neon_dyadic_narrow (void)
14959 {
14960   struct neon_type_el et = neon_check_type (3, NS_QDD,
14961     N_EQK | N_DBL, N_EQK, N_I16 | N_I32 | N_I64 | N_KEY);
14962   /* Operand sign is unimportant, and the U bit is part of the opcode,
14963      so force the operand type to integer.  */
14964   et.type = NT_integer;
14965   neon_mixed_length (et, et.size / 2);
14966 }
14967
14968 static void
14969 do_neon_mul_sat_scalar_long (void)
14970 {
14971   neon_mac_reg_scalar_long (N_S16 | N_S32, N_S16 | N_S32);
14972 }
14973
14974 static void
14975 do_neon_vmull (void)
14976 {
14977   if (inst.operands[2].isscalar)
14978     do_neon_mac_maybe_scalar_long ();
14979   else
14980     {
14981       struct neon_type_el et = neon_check_type (3, NS_QDD,
14982         N_EQK | N_DBL, N_EQK, N_SU_32 | N_P8 | N_KEY);
14983       if (et.type == NT_poly)
14984         NEON_ENCODE (POLY, inst);
14985       else
14986         NEON_ENCODE (INTEGER, inst);
14987       /* For polynomial encoding, size field must be 0b00 and the U bit must be
14988          zero. Should be OK as-is.  */
14989       neon_mixed_length (et, et.size);
14990     }
14991 }
14992
14993 static void
14994 do_neon_ext (void)
14995 {
14996   enum neon_shape rs = neon_select_shape (NS_DDDI, NS_QQQI, NS_NULL);
14997   struct neon_type_el et = neon_check_type (3, rs,
14998     N_EQK, N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
14999   unsigned imm = (inst.operands[3].imm * et.size) / 8;
15000
15001   constraint (imm >= (unsigned) (neon_quad (rs) ? 16 : 8),
15002               _("shift out of range"));
15003   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15004   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15005   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15006   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15007   inst.instruction |= LOW4 (inst.operands[2].reg);
15008   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
15009   inst.instruction |= neon_quad (rs) << 6;
15010   inst.instruction |= imm << 8;
15011
15012   neon_dp_fixup (&inst);
15013 }
15014
15015 static void
15016 do_neon_rev (void)
15017 {
15018   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15019   struct neon_type_el et = neon_check_type (2, rs,
15020     N_EQK, N_8 | N_16 | N_32 | N_KEY);
15021   unsigned op = (inst.instruction >> 7) & 3;
15022   /* N (width of reversed regions) is encoded as part of the bitmask. We
15023      extract it here to check the elements to be reversed are smaller.
15024      Otherwise we'd get a reserved instruction.  */
15025   unsigned elsize = (op == 2) ? 16 : (op == 1) ? 32 : (op == 0) ? 64 : 0;
15026   gas_assert (elsize != 0);
15027   constraint (et.size >= elsize,
15028               _("elements must be smaller than reversal region"));
15029   neon_two_same (neon_quad (rs), 1, et.size);
15030 }
15031
15032 static void
15033 do_neon_dup (void)
15034 {
15035   if (inst.operands[1].isscalar)
15036     {
15037       enum neon_shape rs = neon_select_shape (NS_DS, NS_QS, NS_NULL);
15038       struct neon_type_el et = neon_check_type (2, rs,
15039         N_EQK, N_8 | N_16 | N_32 | N_KEY);
15040       unsigned sizebits = et.size >> 3;
15041       unsigned dm = NEON_SCALAR_REG (inst.operands[1].reg);
15042       int logsize = neon_logbits (et.size);
15043       unsigned x = NEON_SCALAR_INDEX (inst.operands[1].reg) << logsize;
15044
15045       if (vfp_or_neon_is_neon (NEON_CHECK_CC) == FAIL)
15046         return;
15047
15048       NEON_ENCODE (SCALAR, inst);
15049       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15050       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15051       inst.instruction |= LOW4 (dm);
15052       inst.instruction |= HI1 (dm) << 5;
15053       inst.instruction |= neon_quad (rs) << 6;
15054       inst.instruction |= x << 17;
15055       inst.instruction |= sizebits << 16;
15056
15057       neon_dp_fixup (&inst);
15058     }
15059   else
15060     {
15061       enum neon_shape rs = neon_select_shape (NS_DR, NS_QR, NS_NULL);
15062       struct neon_type_el et = neon_check_type (2, rs,
15063         N_8 | N_16 | N_32 | N_KEY, N_EQK);
15064       /* Duplicate ARM register to lanes of vector.  */
15065       NEON_ENCODE (ARMREG, inst);
15066       switch (et.size)
15067         {
15068         case 8:  inst.instruction |= 0x400000; break;
15069         case 16: inst.instruction |= 0x000020; break;
15070         case 32: inst.instruction |= 0x000000; break;
15071         default: break;
15072         }
15073       inst.instruction |= LOW4 (inst.operands[1].reg) << 12;
15074       inst.instruction |= LOW4 (inst.operands[0].reg) << 16;
15075       inst.instruction |= HI1 (inst.operands[0].reg) << 7;
15076       inst.instruction |= neon_quad (rs) << 21;
15077       /* The encoding for this instruction is identical for the ARM and Thumb
15078          variants, except for the condition field.  */
15079       do_vfp_cond_or_thumb ();
15080     }
15081 }
15082
15083 /* VMOV has particularly many variations. It can be one of:
15084      0. VMOV<c><q> <Qd>, <Qm>
15085      1. VMOV<c><q> <Dd>, <Dm>
15086    (Register operations, which are VORR with Rm = Rn.)
15087      2. VMOV<c><q>.<dt> <Qd>, #<imm>
15088      3. VMOV<c><q>.<dt> <Dd>, #<imm>
15089    (Immediate loads.)
15090      4. VMOV<c><q>.<size> <Dn[x]>, <Rd>
15091    (ARM register to scalar.)
15092      5. VMOV<c><q> <Dm>, <Rd>, <Rn>
15093    (Two ARM registers to vector.)
15094      6. VMOV<c><q>.<dt> <Rd>, <Dn[x]>
15095    (Scalar to ARM register.)
15096      7. VMOV<c><q> <Rd>, <Rn>, <Dm>
15097    (Vector to two ARM registers.)
15098      8. VMOV.F32 <Sd>, <Sm>
15099      9. VMOV.F64 <Dd>, <Dm>
15100    (VFP register moves.)
15101     10. VMOV.F32 <Sd>, #imm
15102     11. VMOV.F64 <Dd>, #imm
15103    (VFP float immediate load.)
15104     12. VMOV <Rd>, <Sm>
15105    (VFP single to ARM reg.)
15106     13. VMOV <Sd>, <Rm>
15107    (ARM reg to VFP single.)
15108     14. VMOV <Rd>, <Re>, <Sn>, <Sm>
15109    (Two ARM regs to two VFP singles.)
15110     15. VMOV <Sd>, <Se>, <Rn>, <Rm>
15111    (Two VFP singles to two ARM regs.)
15112
15113    These cases can be disambiguated using neon_select_shape, except cases 1/9
15114    and 3/11 which depend on the operand type too.
15115
15116    All the encoded bits are hardcoded by this function.
15117
15118    Cases 4, 6 may be used with VFPv1 and above (only 32-bit transfers!).
15119    Cases 5, 7 may be used with VFPv2 and above.
15120
15121    FIXME: Some of the checking may be a bit sloppy (in a couple of cases you
15122    can specify a type where it doesn't make sense to, and is ignored).  */
15123
15124 static void
15125 do_neon_mov (void)
15126 {
15127   enum neon_shape rs = neon_select_shape (NS_RRFF, NS_FFRR, NS_DRR, NS_RRD,
15128     NS_QQ, NS_DD, NS_QI, NS_DI, NS_SR, NS_RS, NS_FF, NS_FI, NS_RF, NS_FR,
15129     NS_NULL);
15130   struct neon_type_el et;
15131   const char *ldconst = 0;
15132
15133   switch (rs)
15134     {
15135     case NS_DD:  /* case 1/9.  */
15136       et = neon_check_type (2, rs, N_EQK, N_F64 | N_KEY);
15137       /* It is not an error here if no type is given.  */
15138       inst.error = NULL;
15139       if (et.type == NT_float && et.size == 64)
15140         {
15141           do_vfp_nsyn_opcode ("fcpyd");
15142           break;
15143         }
15144       /* fall through.  */
15145
15146     case NS_QQ:  /* case 0/1.  */
15147       {
15148         if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15149           return;
15150         /* The architecture manual I have doesn't explicitly state which
15151            value the U bit should have for register->register moves, but
15152            the equivalent VORR instruction has U = 0, so do that.  */
15153         inst.instruction = 0x0200110;
15154         inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15155         inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15156         inst.instruction |= LOW4 (inst.operands[1].reg);
15157         inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15158         inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15159         inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15160         inst.instruction |= neon_quad (rs) << 6;
15161
15162         neon_dp_fixup (&inst);
15163       }
15164       break;
15165
15166     case NS_DI:  /* case 3/11.  */
15167       et = neon_check_type (2, rs, N_EQK, N_F64 | N_KEY);
15168       inst.error = NULL;
15169       if (et.type == NT_float && et.size == 64)
15170         {
15171           /* case 11 (fconstd).  */
15172           ldconst = "fconstd";
15173           goto encode_fconstd;
15174         }
15175       /* fall through.  */
15176
15177     case NS_QI:  /* case 2/3.  */
15178       if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15179         return;
15180       inst.instruction = 0x0800010;
15181       neon_move_immediate ();
15182       neon_dp_fixup (&inst);
15183       break;
15184
15185     case NS_SR:  /* case 4.  */
15186       {
15187         unsigned bcdebits = 0;
15188         int logsize;
15189         unsigned dn = NEON_SCALAR_REG (inst.operands[0].reg);
15190         unsigned x = NEON_SCALAR_INDEX (inst.operands[0].reg);
15191
15192         et = neon_check_type (2, NS_NULL, N_8 | N_16 | N_32 | N_KEY, N_EQK);
15193         logsize = neon_logbits (et.size);
15194
15195         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v1),
15196                     _(BAD_FPU));
15197         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_v1)
15198                     && et.size != 32, _(BAD_FPU));
15199         constraint (et.type == NT_invtype, _("bad type for scalar"));
15200         constraint (x >= 64 / et.size, _("scalar index out of range"));
15201
15202         switch (et.size)
15203           {
15204           case 8:  bcdebits = 0x8; break;
15205           case 16: bcdebits = 0x1; break;
15206           case 32: bcdebits = 0x0; break;
15207           default: ;
15208           }
15209
15210         bcdebits |= x << logsize;
15211
15212         inst.instruction = 0xe000b10;
15213         do_vfp_cond_or_thumb ();
15214         inst.instruction |= LOW4 (dn) << 16;
15215         inst.instruction |= HI1 (dn) << 7;
15216         inst.instruction |= inst.operands[1].reg << 12;
15217         inst.instruction |= (bcdebits & 3) << 5;
15218         inst.instruction |= (bcdebits >> 2) << 21;
15219       }
15220       break;
15221
15222     case NS_DRR:  /* case 5 (fmdrr).  */
15223       constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v2),
15224                   _(BAD_FPU));
15225
15226       inst.instruction = 0xc400b10;
15227       do_vfp_cond_or_thumb ();
15228       inst.instruction |= LOW4 (inst.operands[0].reg);
15229       inst.instruction |= HI1 (inst.operands[0].reg) << 5;
15230       inst.instruction |= inst.operands[1].reg << 12;
15231       inst.instruction |= inst.operands[2].reg << 16;
15232       break;
15233
15234     case NS_RS:  /* case 6.  */
15235       {
15236         unsigned logsize;
15237         unsigned dn = NEON_SCALAR_REG (inst.operands[1].reg);
15238         unsigned x = NEON_SCALAR_INDEX (inst.operands[1].reg);
15239         unsigned abcdebits = 0;
15240
15241         et = neon_check_type (2, NS_NULL,
15242                               N_EQK, N_S8 | N_S16 | N_U8 | N_U16 | N_32 | N_KEY);
15243         logsize = neon_logbits (et.size);
15244
15245         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v1),
15246                     _(BAD_FPU));
15247         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_v1)
15248                     && et.size != 32, _(BAD_FPU));
15249         constraint (et.type == NT_invtype, _("bad type for scalar"));
15250         constraint (x >= 64 / et.size, _("scalar index out of range"));
15251
15252         switch (et.size)
15253           {
15254           case 8:  abcdebits = (et.type == NT_signed) ? 0x08 : 0x18; break;
15255           case 16: abcdebits = (et.type == NT_signed) ? 0x01 : 0x11; break;
15256           case 32: abcdebits = 0x00; break;
15257           default: ;
15258           }
15259
15260         abcdebits |= x << logsize;
15261         inst.instruction = 0xe100b10;
15262         do_vfp_cond_or_thumb ();
15263         inst.instruction |= LOW4 (dn) << 16;
15264         inst.instruction |= HI1 (dn) << 7;
15265         inst.instruction |= inst.operands[0].reg << 12;
15266         inst.instruction |= (abcdebits & 3) << 5;
15267         inst.instruction |= (abcdebits >> 2) << 21;
15268       }
15269       break;
15270
15271     case NS_RRD:  /* case 7 (fmrrd).  */
15272       constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v2),
15273                   _(BAD_FPU));
15274
15275       inst.instruction = 0xc500b10;
15276       do_vfp_cond_or_thumb ();
15277       inst.instruction |= inst.operands[0].reg << 12;
15278       inst.instruction |= inst.operands[1].reg << 16;
15279       inst.instruction |= LOW4 (inst.operands[2].reg);
15280       inst.instruction |= HI1 (inst.operands[2].reg) << 5;
15281       break;
15282
15283     case NS_FF:  /* case 8 (fcpys).  */
15284       do_vfp_nsyn_opcode ("fcpys");
15285       break;
15286
15287     case NS_FI:  /* case 10 (fconsts).  */
15288       ldconst = "fconsts";
15289       encode_fconstd:
15290       if (is_quarter_float (inst.operands[1].imm))
15291         {
15292           inst.operands[1].imm = neon_qfloat_bits (inst.operands[1].imm);
15293           do_vfp_nsyn_opcode (ldconst);
15294         }
15295       else
15296         first_error (_("immediate out of range"));
15297       break;
15298
15299     case NS_RF:  /* case 12 (fmrs).  */
15300       do_vfp_nsyn_opcode ("fmrs");
15301       break;
15302
15303     case NS_FR:  /* case 13 (fmsr).  */
15304       do_vfp_nsyn_opcode ("fmsr");
15305       break;
15306
15307     /* The encoders for the fmrrs and fmsrr instructions expect three operands
15308        (one of which is a list), but we have parsed four.  Do some fiddling to
15309        make the operands what do_vfp_reg2_from_sp2 and do_vfp_sp2_from_reg2
15310        expect.  */
15311     case NS_RRFF:  /* case 14 (fmrrs).  */
15312       constraint (inst.operands[3].reg != inst.operands[2].reg + 1,
15313                   _("VFP registers must be adjacent"));
15314       inst.operands[2].imm = 2;
15315       memset (&inst.operands[3], '\0', sizeof (inst.operands[3]));
15316       do_vfp_nsyn_opcode ("fmrrs");
15317       break;
15318
15319     case NS_FFRR:  /* case 15 (fmsrr).  */
15320       constraint (inst.operands[1].reg != inst.operands[0].reg + 1,
15321                   _("VFP registers must be adjacent"));
15322       inst.operands[1] = inst.operands[2];
15323       inst.operands[2] = inst.operands[3];
15324       inst.operands[0].imm = 2;
15325       memset (&inst.operands[3], '\0', sizeof (inst.operands[3]));
15326       do_vfp_nsyn_opcode ("fmsrr");
15327       break;
15328
15329     default:
15330       abort ();
15331     }
15332 }
15333
15334 static void
15335 do_neon_rshift_round_imm (void)
15336 {
15337   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
15338   struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_ALL | N_KEY);
15339   int imm = inst.operands[2].imm;
15340
15341   /* imm == 0 case is encoded as VMOV for V{R}SHR.  */
15342   if (imm == 0)
15343     {
15344       inst.operands[2].present = 0;
15345       do_neon_mov ();
15346       return;
15347     }
15348
15349   constraint (imm < 1 || (unsigned)imm > et.size,
15350               _("immediate out of range for shift"));
15351   neon_imm_shift (TRUE, et.type == NT_unsigned, neon_quad (rs), et,
15352                   et.size - imm);
15353 }
15354
15355 static void
15356 do_neon_movl (void)
15357 {
15358   struct neon_type_el et = neon_check_type (2, NS_QD,
15359     N_EQK | N_DBL, N_SU_32 | N_KEY);
15360   unsigned sizebits = et.size >> 3;
15361   inst.instruction |= sizebits << 19;
15362   neon_two_same (0, et.type == NT_unsigned, -1);
15363 }
15364
15365 static void
15366 do_neon_trn (void)
15367 {
15368   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15369   struct neon_type_el et = neon_check_type (2, rs,
15370     N_EQK, N_8 | N_16 | N_32 | N_KEY);
15371   NEON_ENCODE (INTEGER, inst);
15372   neon_two_same (neon_quad (rs), 1, et.size);
15373 }
15374
15375 static void
15376 do_neon_zip_uzp (void)
15377 {
15378   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15379   struct neon_type_el et = neon_check_type (2, rs,
15380     N_EQK, N_8 | N_16 | N_32 | N_KEY);
15381   if (rs == NS_DD && et.size == 32)
15382     {
15383       /* Special case: encode as VTRN.32 <Dd>, <Dm>.  */
15384       inst.instruction = N_MNEM_vtrn;
15385       do_neon_trn ();
15386       return;
15387     }
15388   neon_two_same (neon_quad (rs), 1, et.size);
15389 }
15390
15391 static void
15392 do_neon_sat_abs_neg (void)
15393 {
15394   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15395   struct neon_type_el et = neon_check_type (2, rs,
15396     N_EQK, N_S8 | N_S16 | N_S32 | N_KEY);
15397   neon_two_same (neon_quad (rs), 1, et.size);
15398 }
15399
15400 static void
15401 do_neon_pair_long (void)
15402 {
15403   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15404   struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_32 | N_KEY);
15405   /* Unsigned is encoded in OP field (bit 7) for these instruction.  */
15406   inst.instruction |= (et.type == NT_unsigned) << 7;
15407   neon_two_same (neon_quad (rs), 1, et.size);
15408 }
15409
15410 static void
15411 do_neon_recip_est (void)
15412 {
15413   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15414   struct neon_type_el et = neon_check_type (2, rs,
15415     N_EQK | N_FLT, N_F32 | N_U32 | N_KEY);
15416   inst.instruction |= (et.type == NT_float) << 8;
15417   neon_two_same (neon_quad (rs), 1, et.size);
15418 }
15419
15420 static void
15421 do_neon_cls (void)
15422 {
15423   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15424   struct neon_type_el et = neon_check_type (2, rs,
15425     N_EQK, N_S8 | N_S16 | N_S32 | N_KEY);
15426   neon_two_same (neon_quad (rs), 1, et.size);
15427 }
15428
15429 static void
15430 do_neon_clz (void)
15431 {
15432   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15433   struct neon_type_el et = neon_check_type (2, rs,
15434     N_EQK, N_I8 | N_I16 | N_I32 | N_KEY);
15435   neon_two_same (neon_quad (rs), 1, et.size);
15436 }
15437
15438 static void
15439 do_neon_cnt (void)
15440 {
15441   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15442   struct neon_type_el et = neon_check_type (2, rs,
15443     N_EQK | N_INT, N_8 | N_KEY);
15444   neon_two_same (neon_quad (rs), 1, et.size);
15445 }
15446
15447 static void
15448 do_neon_swp (void)
15449 {
15450   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15451   neon_two_same (neon_quad (rs), 1, -1);
15452 }
15453
15454 static void
15455 do_neon_tbl_tbx (void)
15456 {
15457   unsigned listlenbits;
15458   neon_check_type (3, NS_DLD, N_EQK, N_EQK, N_8 | N_KEY);
15459
15460   if (inst.operands[1].imm < 1 || inst.operands[1].imm > 4)
15461     {
15462       first_error (_("bad list length for table lookup"));
15463       return;
15464     }
15465
15466   listlenbits = inst.operands[1].imm - 1;
15467   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15468   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15469   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15470   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15471   inst.instruction |= LOW4 (inst.operands[2].reg);
15472   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
15473   inst.instruction |= listlenbits << 8;
15474
15475   neon_dp_fixup (&inst);
15476 }
15477
15478 static void
15479 do_neon_ldm_stm (void)
15480 {
15481   /* P, U and L bits are part of bitmask.  */
15482   int is_dbmode = (inst.instruction & (1 << 24)) != 0;
15483   unsigned offsetbits = inst.operands[1].imm * 2;
15484
15485   if (inst.operands[1].issingle)
15486     {
15487       do_vfp_nsyn_ldm_stm (is_dbmode);
15488       return;
15489     }
15490
15491   constraint (is_dbmode && !inst.operands[0].writeback,
15492               _("writeback (!) must be used for VLDMDB and VSTMDB"));
15493
15494   constraint (inst.operands[1].imm < 1 || inst.operands[1].imm > 16,
15495               _("register list must contain at least 1 and at most 16 "
15496                 "registers"));
15497
15498   inst.instruction |= inst.operands[0].reg << 16;
15499   inst.instruction |= inst.operands[0].writeback << 21;
15500   inst.instruction |= LOW4 (inst.operands[1].reg) << 12;
15501   inst.instruction |= HI1 (inst.operands[1].reg) << 22;
15502
15503   inst.instruction |= offsetbits;
15504
15505   do_vfp_cond_or_thumb ();
15506 }
15507
15508 static void
15509 do_neon_ldr_str (void)
15510 {
15511   int is_ldr = (inst.instruction & (1 << 20)) != 0;
15512
15513   /* Use of PC in vstr in ARM mode is deprecated in ARMv7.
15514      And is UNPREDICTABLE in thumb mode.  */
15515   if (!is_ldr
15516       && inst.operands[1].reg == REG_PC
15517       && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v7))
15518     {
15519       if (!thumb_mode && warn_on_deprecated)
15520         as_warn (_("Use of PC here is deprecated"));
15521       else
15522         inst.error = _("Use of PC here is UNPREDICTABLE");
15523     }
15524
15525   if (inst.operands[0].issingle)
15526     {
15527       if (is_ldr)
15528         do_vfp_nsyn_opcode ("flds");
15529       else
15530         do_vfp_nsyn_opcode ("fsts");
15531     }
15532   else
15533     {
15534       if (is_ldr)
15535         do_vfp_nsyn_opcode ("fldd");
15536       else
15537         do_vfp_nsyn_opcode ("fstd");
15538     }
15539 }
15540
15541 /* "interleave" version also handles non-interleaving register VLD1/VST1
15542    instructions.  */
15543
15544 static void
15545 do_neon_ld_st_interleave (void)
15546 {
15547   struct neon_type_el et = neon_check_type (1, NS_NULL,
15548                                             N_8 | N_16 | N_32 | N_64);
15549   unsigned alignbits = 0;
15550   unsigned idx;
15551   /* The bits in this table go:
15552      0: register stride of one (0) or two (1)
15553      1,2: register list length, minus one (1, 2, 3, 4).
15554      3,4: <n> in instruction type, minus one (VLD<n> / VST<n>).
15555      We use -1 for invalid entries.  */
15556   const int typetable[] =
15557     {
15558       0x7,  -1, 0xa,  -1, 0x6,  -1, 0x2,  -1, /* VLD1 / VST1.  */
15559        -1,  -1, 0x8, 0x9,  -1,  -1, 0x3,  -1, /* VLD2 / VST2.  */
15560        -1,  -1,  -1,  -1, 0x4, 0x5,  -1,  -1, /* VLD3 / VST3.  */
15561        -1,  -1,  -1,  -1,  -1,  -1, 0x0, 0x1  /* VLD4 / VST4.  */
15562     };
15563   int typebits;
15564
15565   if (et.type == NT_invtype)
15566     return;
15567
15568   if (inst.operands[1].immisalign)
15569     switch (inst.operands[1].imm >> 8)
15570       {
15571       case 64: alignbits = 1; break;
15572       case 128:
15573         if (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 2
15574             && NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4)
15575           goto bad_alignment;
15576         alignbits = 2;
15577         break;
15578       case 256:
15579         if (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4)
15580           goto bad_alignment;
15581         alignbits = 3;
15582         break;
15583       default:
15584       bad_alignment:
15585         first_error (_("bad alignment"));
15586         return;
15587       }
15588
15589   inst.instruction |= alignbits << 4;
15590   inst.instruction |= neon_logbits (et.size) << 6;
15591
15592   /* Bits [4:6] of the immediate in a list specifier encode register stride
15593      (minus 1) in bit 4, and list length in bits [5:6]. We put the <n> of
15594      VLD<n>/VST<n> in bits [9:8] of the initial bitmask. Suck it out here, look
15595      up the right value for "type" in a table based on this value and the given
15596      list style, then stick it back.  */
15597   idx = ((inst.operands[0].imm >> 4) & 7)
15598         | (((inst.instruction >> 8) & 3) << 3);
15599
15600   typebits = typetable[idx];
15601
15602   constraint (typebits == -1, _("bad list type for instruction"));
15603
15604   inst.instruction &= ~0xf00;
15605   inst.instruction |= typebits << 8;
15606 }
15607
15608 /* Check alignment is valid for do_neon_ld_st_lane and do_neon_ld_dup.
15609    *DO_ALIGN is set to 1 if the relevant alignment bit should be set, 0
15610    otherwise. The variable arguments are a list of pairs of legal (size, align)
15611    values, terminated with -1.  */
15612
15613 static int
15614 neon_alignment_bit (int size, int align, int *do_align, ...)
15615 {
15616   va_list ap;
15617   int result = FAIL, thissize, thisalign;
15618
15619   if (!inst.operands[1].immisalign)
15620     {
15621       *do_align = 0;
15622       return SUCCESS;
15623     }
15624
15625   va_start (ap, do_align);
15626
15627   do
15628     {
15629       thissize = va_arg (ap, int);
15630       if (thissize == -1)
15631         break;
15632       thisalign = va_arg (ap, int);
15633
15634       if (size == thissize && align == thisalign)
15635         result = SUCCESS;
15636     }
15637   while (result != SUCCESS);
15638
15639   va_end (ap);
15640
15641   if (result == SUCCESS)
15642     *do_align = 1;
15643   else
15644     first_error (_("unsupported alignment for instruction"));
15645
15646   return result;
15647 }
15648
15649 static void
15650 do_neon_ld_st_lane (void)
15651 {
15652   struct neon_type_el et = neon_check_type (1, NS_NULL, N_8 | N_16 | N_32);
15653   int align_good, do_align = 0;
15654   int logsize = neon_logbits (et.size);
15655   int align = inst.operands[1].imm >> 8;
15656   int n = (inst.instruction >> 8) & 3;
15657   int max_el = 64 / et.size;
15658
15659   if (et.type == NT_invtype)
15660     return;
15661
15662   constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != n + 1,
15663               _("bad list length"));
15664   constraint (NEON_LANE (inst.operands[0].imm) >= max_el,
15665               _("scalar index out of range"));
15666   constraint (n != 0 && NEON_REG_STRIDE (inst.operands[0].imm) == 2
15667               && et.size == 8,
15668               _("stride of 2 unavailable when element size is 8"));
15669
15670   switch (n)
15671     {
15672     case 0:  /* VLD1 / VST1.  */
15673       align_good = neon_alignment_bit (et.size, align, &do_align, 16, 16,
15674                                        32, 32, -1);
15675       if (align_good == FAIL)
15676         return;
15677       if (do_align)
15678         {
15679           unsigned alignbits = 0;
15680           switch (et.size)
15681             {
15682             case 16: alignbits = 0x1; break;
15683             case 32: alignbits = 0x3; break;
15684             default: ;
15685             }
15686           inst.instruction |= alignbits << 4;
15687         }
15688       break;
15689
15690     case 1:  /* VLD2 / VST2.  */
15691       align_good = neon_alignment_bit (et.size, align, &do_align, 8, 16, 16, 32,
15692                                        32, 64, -1);
15693       if (align_good == FAIL)
15694         return;
15695       if (do_align)
15696         inst.instruction |= 1 << 4;
15697       break;
15698
15699     case 2:  /* VLD3 / VST3.  */
15700       constraint (inst.operands[1].immisalign,
15701                   _("can't use alignment with this instruction"));
15702       break;
15703
15704     case 3:  /* VLD4 / VST4.  */
15705       align_good = neon_alignment_bit (et.size, align, &do_align, 8, 32,
15706                                        16, 64, 32, 64, 32, 128, -1);
15707       if (align_good == FAIL)
15708         return;
15709       if (do_align)
15710         {
15711           unsigned alignbits = 0;
15712           switch (et.size)
15713             {
15714             case 8:  alignbits = 0x1; break;
15715             case 16: alignbits = 0x1; break;
15716             case 32: alignbits = (align == 64) ? 0x1 : 0x2; break;
15717             default: ;
15718             }
15719           inst.instruction |= alignbits << 4;
15720         }
15721       break;
15722
15723     default: ;
15724     }
15725
15726   /* Reg stride of 2 is encoded in bit 5 when size==16, bit 6 when size==32.  */
15727   if (n != 0 && NEON_REG_STRIDE (inst.operands[0].imm) == 2)
15728     inst.instruction |= 1 << (4 + logsize);
15729
15730   inst.instruction |= NEON_LANE (inst.operands[0].imm) << (logsize + 5);
15731   inst.instruction |= logsize << 10;
15732 }
15733
15734 /* Encode single n-element structure to all lanes VLD<n> instructions.  */
15735
15736 static void
15737 do_neon_ld_dup (void)
15738 {
15739   struct neon_type_el et = neon_check_type (1, NS_NULL, N_8 | N_16 | N_32);
15740   int align_good, do_align = 0;
15741
15742   if (et.type == NT_invtype)
15743     return;
15744
15745   switch ((inst.instruction >> 8) & 3)
15746     {
15747     case 0:  /* VLD1.  */
15748       gas_assert (NEON_REG_STRIDE (inst.operands[0].imm) != 2);
15749       align_good = neon_alignment_bit (et.size, inst.operands[1].imm >> 8,
15750                                        &do_align, 16, 16, 32, 32, -1);
15751       if (align_good == FAIL)
15752         return;
15753       switch (NEON_REGLIST_LENGTH (inst.operands[0].imm))
15754         {
15755         case 1: break;
15756         case 2: inst.instruction |= 1 << 5; break;
15757         default: first_error (_("bad list length")); return;
15758         }
15759       inst.instruction |= neon_logbits (et.size) << 6;
15760       break;
15761
15762     case 1:  /* VLD2.  */
15763       align_good = neon_alignment_bit (et.size, inst.operands[1].imm >> 8,
15764                                        &do_align, 8, 16, 16, 32, 32, 64, -1);
15765       if (align_good == FAIL)
15766         return;
15767       constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 2,
15768                   _("bad list length"));
15769       if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
15770         inst.instruction |= 1 << 5;
15771       inst.instruction |= neon_logbits (et.size) << 6;
15772       break;
15773
15774     case 2:  /* VLD3.  */
15775       constraint (inst.operands[1].immisalign,
15776                   _("can't use alignment with this instruction"));
15777       constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 3,
15778                   _("bad list length"));
15779       if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
15780         inst.instruction |= 1 << 5;
15781       inst.instruction |= neon_logbits (et.size) << 6;
15782       break;
15783
15784     case 3:  /* VLD4.  */
15785       {
15786         int align = inst.operands[1].imm >> 8;
15787         align_good = neon_alignment_bit (et.size, align, &do_align, 8, 32,
15788                                          16, 64, 32, 64, 32, 128, -1);
15789         if (align_good == FAIL)
15790           return;
15791         constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4,
15792                     _("bad list length"));
15793         if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
15794           inst.instruction |= 1 << 5;
15795         if (et.size == 32 && align == 128)
15796           inst.instruction |= 0x3 << 6;
15797         else
15798           inst.instruction |= neon_logbits (et.size) << 6;
15799       }
15800       break;
15801
15802     default: ;
15803     }
15804
15805   inst.instruction |= do_align << 4;
15806 }
15807
15808 /* Disambiguate VLD<n> and VST<n> instructions, and fill in common bits (those
15809    apart from bits [11:4].  */
15810
15811 static void
15812 do_neon_ldx_stx (void)
15813 {
15814   if (inst.operands[1].isreg)
15815     constraint (inst.operands[1].reg == REG_PC, BAD_PC);
15816
15817   switch (NEON_LANE (inst.operands[0].imm))
15818     {
15819     case NEON_INTERLEAVE_LANES:
15820       NEON_ENCODE (INTERLV, inst);
15821       do_neon_ld_st_interleave ();
15822       break;
15823
15824     case NEON_ALL_LANES:
15825       NEON_ENCODE (DUP, inst);
15826       do_neon_ld_dup ();
15827       break;
15828
15829     default:
15830       NEON_ENCODE (LANE, inst);
15831       do_neon_ld_st_lane ();
15832     }
15833
15834   /* L bit comes from bit mask.  */
15835   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15836   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15837   inst.instruction |= inst.operands[1].reg << 16;
15838
15839   if (inst.operands[1].postind)
15840     {
15841       int postreg = inst.operands[1].imm & 0xf;
15842       constraint (!inst.operands[1].immisreg,
15843                   _("post-index must be a register"));
15844       constraint (postreg == 0xd || postreg == 0xf,
15845                   _("bad register for post-index"));
15846       inst.instruction |= postreg;
15847     }
15848   else if (inst.operands[1].writeback)
15849     {
15850       inst.instruction |= 0xd;
15851     }
15852   else
15853     inst.instruction |= 0xf;
15854
15855   if (thumb_mode)
15856     inst.instruction |= 0xf9000000;
15857   else
15858     inst.instruction |= 0xf4000000;
15859 }
15860
15861 /* FP v8.  */
15862 static void
15863 do_vfp_nsyn_fpv8 (enum neon_shape rs)
15864 {
15865   NEON_ENCODE (FPV8, inst);
15866
15867   if (rs == NS_FFF)
15868     do_vfp_sp_dyadic ();
15869   else
15870     do_vfp_dp_rd_rn_rm ();
15871
15872   if (rs == NS_DDD)
15873     inst.instruction |= 0x100;
15874
15875   inst.instruction |= 0xf0000000;
15876 }
15877
15878 static void
15879 do_vsel (void)
15880 {
15881   set_it_insn_type (OUTSIDE_IT_INSN);
15882
15883   if (try_vfp_nsyn (3, do_vfp_nsyn_fpv8) != SUCCESS)
15884     first_error (_("invalid instruction shape"));
15885 }
15886
15887 static void
15888 do_vmaxnm (void)
15889 {
15890   set_it_insn_type (OUTSIDE_IT_INSN);
15891
15892   if (try_vfp_nsyn (3, do_vfp_nsyn_fpv8) == SUCCESS)
15893     return;
15894
15895   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH8) == FAIL)
15896     return;
15897
15898   neon_dyadic_misc (NT_untyped, N_F32, 0);
15899 }
15900
15901 \f
15902 /* Overall per-instruction processing.  */
15903
15904 /* We need to be able to fix up arbitrary expressions in some statements.
15905    This is so that we can handle symbols that are an arbitrary distance from
15906    the pc.  The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
15907    which returns part of an address in a form which will be valid for
15908    a data instruction.  We do this by pushing the expression into a symbol
15909    in the expr_section, and creating a fix for that.  */
15910
15911 static void
15912 fix_new_arm (fragS *       frag,
15913              int           where,
15914              short int     size,
15915              expressionS * exp,
15916              int           pc_rel,
15917              int           reloc)
15918 {
15919   fixS *           new_fix;
15920
15921   switch (exp->X_op)
15922     {
15923     case O_constant:
15924       if (pc_rel)
15925         {
15926           /* Create an absolute valued symbol, so we have something to
15927              refer to in the object file.  Unfortunately for us, gas's
15928              generic expression parsing will already have folded out
15929              any use of .set foo/.type foo %function that may have
15930              been used to set type information of the target location,
15931              that's being specified symbolically.  We have to presume
15932              the user knows what they are doing.  */
15933           char name[16 + 8];
15934           symbolS *symbol;
15935
15936           sprintf (name, "*ABS*0x%lx", (unsigned long)exp->X_add_number);
15937
15938           symbol = symbol_find_or_make (name);
15939           S_SET_SEGMENT (symbol, absolute_section);
15940           symbol_set_frag (symbol, &zero_address_frag);
15941           S_SET_VALUE (symbol, exp->X_add_number);
15942           exp->X_op = O_symbol;
15943           exp->X_add_symbol = symbol;
15944           exp->X_add_number = 0;
15945         }
15946       /* FALLTHROUGH */
15947     case O_symbol:
15948     case O_add:
15949     case O_subtract:
15950       new_fix = fix_new_exp (frag, where, size, exp, pc_rel,
15951                              (enum bfd_reloc_code_real) reloc);
15952       break;
15953
15954     default:
15955       new_fix = (fixS *) fix_new (frag, where, size, make_expr_symbol (exp), 0,
15956                                   pc_rel, (enum bfd_reloc_code_real) reloc);
15957       break;
15958     }
15959
15960   /* Mark whether the fix is to a THUMB instruction, or an ARM
15961      instruction.  */
15962   new_fix->tc_fix_data = thumb_mode;
15963 }
15964
15965 /* Create a frg for an instruction requiring relaxation.  */
15966 static void
15967 output_relax_insn (void)
15968 {
15969   char * to;
15970   symbolS *sym;
15971   int offset;
15972
15973   /* The size of the instruction is unknown, so tie the debug info to the
15974      start of the instruction.  */
15975   dwarf2_emit_insn (0);
15976
15977   switch (inst.reloc.exp.X_op)
15978     {
15979     case O_symbol:
15980       sym = inst.reloc.exp.X_add_symbol;
15981       offset = inst.reloc.exp.X_add_number;
15982       break;
15983     case O_constant:
15984       sym = NULL;
15985       offset = inst.reloc.exp.X_add_number;
15986       break;
15987     default:
15988       sym = make_expr_symbol (&inst.reloc.exp);
15989       offset = 0;
15990       break;
15991   }
15992   to = frag_var (rs_machine_dependent, INSN_SIZE, THUMB_SIZE,
15993                  inst.relax, sym, offset, NULL/*offset, opcode*/);
15994   md_number_to_chars (to, inst.instruction, THUMB_SIZE);
15995 }
15996
15997 /* Write a 32-bit thumb instruction to buf.  */
15998 static void
15999 put_thumb32_insn (char * buf, unsigned long insn)
16000 {
16001   md_number_to_chars (buf, insn >> 16, THUMB_SIZE);
16002   md_number_to_chars (buf + THUMB_SIZE, insn, THUMB_SIZE);
16003 }
16004
16005 static void
16006 output_inst (const char * str)
16007 {
16008   char * to = NULL;
16009
16010   if (inst.error)
16011     {
16012       as_bad ("%s -- `%s'", inst.error, str);
16013       return;
16014     }
16015   if (inst.relax)
16016     {
16017       output_relax_insn ();
16018       return;
16019     }
16020   if (inst.size == 0)
16021     return;
16022
16023   to = frag_more (inst.size);
16024   /* PR 9814: Record the thumb mode into the current frag so that we know
16025      what type of NOP padding to use, if necessary.  We override any previous
16026      setting so that if the mode has changed then the NOPS that we use will
16027      match the encoding of the last instruction in the frag.  */
16028   frag_now->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
16029
16030   if (thumb_mode && (inst.size > THUMB_SIZE))
16031     {
16032       gas_assert (inst.size == (2 * THUMB_SIZE));
16033       put_thumb32_insn (to, inst.instruction);
16034     }
16035   else if (inst.size > INSN_SIZE)
16036     {
16037       gas_assert (inst.size == (2 * INSN_SIZE));
16038       md_number_to_chars (to, inst.instruction, INSN_SIZE);
16039       md_number_to_chars (to + INSN_SIZE, inst.instruction, INSN_SIZE);
16040     }
16041   else
16042     md_number_to_chars (to, inst.instruction, inst.size);
16043
16044   if (inst.reloc.type != BFD_RELOC_UNUSED)
16045     fix_new_arm (frag_now, to - frag_now->fr_literal,
16046                  inst.size, & inst.reloc.exp, inst.reloc.pc_rel,
16047                  inst.reloc.type);
16048
16049   dwarf2_emit_insn (inst.size);
16050 }
16051
16052 static char *
16053 output_it_inst (int cond, int mask, char * to)
16054 {
16055   unsigned long instruction = 0xbf00;
16056
16057   mask &= 0xf;
16058   instruction |= mask;
16059   instruction |= cond << 4;
16060
16061   if (to == NULL)
16062     {
16063       to = frag_more (2);
16064 #ifdef OBJ_ELF
16065       dwarf2_emit_insn (2);
16066 #endif
16067     }
16068
16069   md_number_to_chars (to, instruction, 2);
16070
16071   return to;
16072 }
16073
16074 /* Tag values used in struct asm_opcode's tag field.  */
16075 enum opcode_tag
16076 {
16077   OT_unconditional,     /* Instruction cannot be conditionalized.
16078                            The ARM condition field is still 0xE.  */
16079   OT_unconditionalF,    /* Instruction cannot be conditionalized
16080                            and carries 0xF in its ARM condition field.  */
16081   OT_csuffix,           /* Instruction takes a conditional suffix.  */
16082   OT_csuffixF,          /* Some forms of the instruction take a conditional
16083                            suffix, others place 0xF where the condition field
16084                            would be.  */
16085   OT_cinfix3,           /* Instruction takes a conditional infix,
16086                            beginning at character index 3.  (In
16087                            unified mode, it becomes a suffix.)  */
16088   OT_cinfix3_deprecated, /* The same as OT_cinfix3.  This is used for
16089                             tsts, cmps, cmns, and teqs. */
16090   OT_cinfix3_legacy,    /* Legacy instruction takes a conditional infix at
16091                            character index 3, even in unified mode.  Used for
16092                            legacy instructions where suffix and infix forms
16093                            may be ambiguous.  */
16094   OT_csuf_or_in3,       /* Instruction takes either a conditional
16095                            suffix or an infix at character index 3.  */
16096   OT_odd_infix_unc,     /* This is the unconditional variant of an
16097                            instruction that takes a conditional infix
16098                            at an unusual position.  In unified mode,
16099                            this variant will accept a suffix.  */
16100   OT_odd_infix_0        /* Values greater than or equal to OT_odd_infix_0
16101                            are the conditional variants of instructions that
16102                            take conditional infixes in unusual positions.
16103                            The infix appears at character index
16104                            (tag - OT_odd_infix_0).  These are not accepted
16105                            in unified mode.  */
16106 };
16107
16108 /* Subroutine of md_assemble, responsible for looking up the primary
16109    opcode from the mnemonic the user wrote.  STR points to the
16110    beginning of the mnemonic.
16111
16112    This is not simply a hash table lookup, because of conditional
16113    variants.  Most instructions have conditional variants, which are
16114    expressed with a _conditional affix_ to the mnemonic.  If we were
16115    to encode each conditional variant as a literal string in the opcode
16116    table, it would have approximately 20,000 entries.
16117
16118    Most mnemonics take this affix as a suffix, and in unified syntax,
16119    'most' is upgraded to 'all'.  However, in the divided syntax, some
16120    instructions take the affix as an infix, notably the s-variants of
16121    the arithmetic instructions.  Of those instructions, all but six
16122    have the infix appear after the third character of the mnemonic.
16123
16124    Accordingly, the algorithm for looking up primary opcodes given
16125    an identifier is:
16126
16127    1. Look up the identifier in the opcode table.
16128       If we find a match, go to step U.
16129
16130    2. Look up the last two characters of the identifier in the
16131       conditions table.  If we find a match, look up the first N-2
16132       characters of the identifier in the opcode table.  If we
16133       find a match, go to step CE.
16134
16135    3. Look up the fourth and fifth characters of the identifier in
16136       the conditions table.  If we find a match, extract those
16137       characters from the identifier, and look up the remaining
16138       characters in the opcode table.  If we find a match, go
16139       to step CM.
16140
16141    4. Fail.
16142
16143    U. Examine the tag field of the opcode structure, in case this is
16144       one of the six instructions with its conditional infix in an
16145       unusual place.  If it is, the tag tells us where to find the
16146       infix; look it up in the conditions table and set inst.cond
16147       accordingly.  Otherwise, this is an unconditional instruction.
16148       Again set inst.cond accordingly.  Return the opcode structure.
16149
16150   CE. Examine the tag field to make sure this is an instruction that
16151       should receive a conditional suffix.  If it is not, fail.
16152       Otherwise, set inst.cond from the suffix we already looked up,
16153       and return the opcode structure.
16154
16155   CM. Examine the tag field to make sure this is an instruction that
16156       should receive a conditional infix after the third character.
16157       If it is not, fail.  Otherwise, undo the edits to the current
16158       line of input and proceed as for case CE.  */
16159
16160 static const struct asm_opcode *
16161 opcode_lookup (char **str)
16162 {
16163   char *end, *base;
16164   char *affix;
16165   const struct asm_opcode *opcode;
16166   const struct asm_cond *cond;
16167   char save[2];
16168
16169   /* Scan up to the end of the mnemonic, which must end in white space,
16170      '.' (in unified mode, or for Neon/VFP instructions), or end of string.  */
16171   for (base = end = *str; *end != '\0'; end++)
16172     if (*end == ' ' || *end == '.')
16173       break;
16174
16175   if (end == base)
16176     return NULL;
16177
16178   /* Handle a possible width suffix and/or Neon type suffix.  */
16179   if (end[0] == '.')
16180     {
16181       int offset = 2;
16182
16183       /* The .w and .n suffixes are only valid if the unified syntax is in
16184          use.  */
16185       if (unified_syntax && end[1] == 'w')
16186         inst.size_req = 4;
16187       else if (unified_syntax && end[1] == 'n')
16188         inst.size_req = 2;
16189       else
16190         offset = 0;
16191
16192       inst.vectype.elems = 0;
16193
16194       *str = end + offset;
16195
16196       if (end[offset] == '.')
16197         {
16198           /* See if we have a Neon type suffix (possible in either unified or
16199              non-unified ARM syntax mode).  */
16200           if (parse_neon_type (&inst.vectype, str) == FAIL)
16201             return NULL;
16202         }
16203       else if (end[offset] != '\0' && end[offset] != ' ')
16204         return NULL;
16205     }
16206   else
16207     *str = end;
16208
16209   /* Look for unaffixed or special-case affixed mnemonic.  */
16210   opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
16211                                                     end - base);
16212   if (opcode)
16213     {
16214       /* step U */
16215       if (opcode->tag < OT_odd_infix_0)
16216         {
16217           inst.cond = COND_ALWAYS;
16218           return opcode;
16219         }
16220
16221       if (warn_on_deprecated && unified_syntax)
16222         as_warn (_("conditional infixes are deprecated in unified syntax"));
16223       affix = base + (opcode->tag - OT_odd_infix_0);
16224       cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
16225       gas_assert (cond);
16226
16227       inst.cond = cond->value;
16228       return opcode;
16229     }
16230
16231   /* Cannot have a conditional suffix on a mnemonic of less than two
16232      characters.  */
16233   if (end - base < 3)
16234     return NULL;
16235
16236   /* Look for suffixed mnemonic.  */
16237   affix = end - 2;
16238   cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
16239   opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
16240                                                     affix - base);
16241   if (opcode && cond)
16242     {
16243       /* step CE */
16244       switch (opcode->tag)
16245         {
16246         case OT_cinfix3_legacy:
16247           /* Ignore conditional suffixes matched on infix only mnemonics.  */
16248           break;
16249
16250         case OT_cinfix3:
16251         case OT_cinfix3_deprecated:
16252         case OT_odd_infix_unc:
16253           if (!unified_syntax)
16254             return 0;
16255           /* else fall through */
16256
16257         case OT_csuffix:
16258         case OT_csuffixF:
16259         case OT_csuf_or_in3:
16260           inst.cond = cond->value;
16261           return opcode;
16262
16263         case OT_unconditional:
16264         case OT_unconditionalF:
16265           if (thumb_mode)
16266             inst.cond = cond->value;
16267           else
16268             {
16269               /* Delayed diagnostic.  */
16270               inst.error = BAD_COND;
16271               inst.cond = COND_ALWAYS;
16272             }
16273           return opcode;
16274
16275         default:
16276           return NULL;
16277         }
16278     }
16279
16280   /* Cannot have a usual-position infix on a mnemonic of less than
16281      six characters (five would be a suffix).  */
16282   if (end - base < 6)
16283     return NULL;
16284
16285   /* Look for infixed mnemonic in the usual position.  */
16286   affix = base + 3;
16287   cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
16288   if (!cond)
16289     return NULL;
16290
16291   memcpy (save, affix, 2);
16292   memmove (affix, affix + 2, (end - affix) - 2);
16293   opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
16294                                                     (end - base) - 2);
16295   memmove (affix + 2, affix, (end - affix) - 2);
16296   memcpy (affix, save, 2);
16297
16298   if (opcode
16299       && (opcode->tag == OT_cinfix3
16300           || opcode->tag == OT_cinfix3_deprecated
16301           || opcode->tag == OT_csuf_or_in3
16302           || opcode->tag == OT_cinfix3_legacy))
16303     {
16304       /* Step CM.  */
16305       if (warn_on_deprecated && unified_syntax
16306           && (opcode->tag == OT_cinfix3
16307               || opcode->tag == OT_cinfix3_deprecated))
16308         as_warn (_("conditional infixes are deprecated in unified syntax"));
16309
16310       inst.cond = cond->value;
16311       return opcode;
16312     }
16313
16314   return NULL;
16315 }
16316
16317 /* This function generates an initial IT instruction, leaving its block
16318    virtually open for the new instructions. Eventually,
16319    the mask will be updated by now_it_add_mask () each time
16320    a new instruction needs to be included in the IT block.
16321    Finally, the block is closed with close_automatic_it_block ().
16322    The block closure can be requested either from md_assemble (),
16323    a tencode (), or due to a label hook.  */
16324
16325 static void
16326 new_automatic_it_block (int cond)
16327 {
16328   now_it.state = AUTOMATIC_IT_BLOCK;
16329   now_it.mask = 0x18;
16330   now_it.cc = cond;
16331   now_it.block_length = 1;
16332   mapping_state (MAP_THUMB);
16333   now_it.insn = output_it_inst (cond, now_it.mask, NULL);
16334   now_it.warn_deprecated = FALSE;
16335   now_it.insn_cond = TRUE;
16336 }
16337
16338 /* Close an automatic IT block.
16339    See comments in new_automatic_it_block ().  */
16340
16341 static void
16342 close_automatic_it_block (void)
16343 {
16344   now_it.mask = 0x10;
16345   now_it.block_length = 0;
16346 }
16347
16348 /* Update the mask of the current automatically-generated IT
16349    instruction. See comments in new_automatic_it_block ().  */
16350
16351 static void
16352 now_it_add_mask (int cond)
16353 {
16354 #define CLEAR_BIT(value, nbit)  ((value) & ~(1 << (nbit)))
16355 #define SET_BIT_VALUE(value, bitvalue, nbit)  (CLEAR_BIT (value, nbit) \
16356                                               | ((bitvalue) << (nbit)))
16357   const int resulting_bit = (cond & 1);
16358
16359   now_it.mask &= 0xf;
16360   now_it.mask = SET_BIT_VALUE (now_it.mask,
16361                                    resulting_bit,
16362                                   (5 - now_it.block_length));
16363   now_it.mask = SET_BIT_VALUE (now_it.mask,
16364                                    1,
16365                                    ((5 - now_it.block_length) - 1) );
16366   output_it_inst (now_it.cc, now_it.mask, now_it.insn);
16367
16368 #undef CLEAR_BIT
16369 #undef SET_BIT_VALUE
16370 }
16371
16372 /* The IT blocks handling machinery is accessed through the these functions:
16373      it_fsm_pre_encode ()               from md_assemble ()
16374      set_it_insn_type ()                optional, from the tencode functions
16375      set_it_insn_type_last ()           ditto
16376      in_it_block ()                     ditto
16377      it_fsm_post_encode ()              from md_assemble ()
16378      force_automatic_it_block_close ()  from label habdling functions
16379
16380    Rationale:
16381      1) md_assemble () calls it_fsm_pre_encode () before calling tencode (),
16382         initializing the IT insn type with a generic initial value depending
16383         on the inst.condition.
16384      2) During the tencode function, two things may happen:
16385         a) The tencode function overrides the IT insn type by
16386            calling either set_it_insn_type (type) or set_it_insn_type_last ().
16387         b) The tencode function queries the IT block state by
16388            calling in_it_block () (i.e. to determine narrow/not narrow mode).
16389
16390         Both set_it_insn_type and in_it_block run the internal FSM state
16391         handling function (handle_it_state), because: a) setting the IT insn
16392         type may incur in an invalid state (exiting the function),
16393         and b) querying the state requires the FSM to be updated.
16394         Specifically we want to avoid creating an IT block for conditional
16395         branches, so it_fsm_pre_encode is actually a guess and we can't
16396         determine whether an IT block is required until the tencode () routine
16397         has decided what type of instruction this actually it.
16398         Because of this, if set_it_insn_type and in_it_block have to be used,
16399         set_it_insn_type has to be called first.
16400
16401         set_it_insn_type_last () is a wrapper of set_it_insn_type (type), that
16402         determines the insn IT type depending on the inst.cond code.
16403         When a tencode () routine encodes an instruction that can be
16404         either outside an IT block, or, in the case of being inside, has to be
16405         the last one, set_it_insn_type_last () will determine the proper
16406         IT instruction type based on the inst.cond code. Otherwise,
16407         set_it_insn_type can be called for overriding that logic or
16408         for covering other cases.
16409
16410         Calling handle_it_state () may not transition the IT block state to
16411         OUTSIDE_IT_BLOCK immediatelly, since the (current) state could be
16412         still queried. Instead, if the FSM determines that the state should
16413         be transitioned to OUTSIDE_IT_BLOCK, a flag is marked to be closed
16414         after the tencode () function: that's what it_fsm_post_encode () does.
16415
16416         Since in_it_block () calls the state handling function to get an
16417         updated state, an error may occur (due to invalid insns combination).
16418         In that case, inst.error is set.
16419         Therefore, inst.error has to be checked after the execution of
16420         the tencode () routine.
16421
16422      3) Back in md_assemble(), it_fsm_post_encode () is called to commit
16423         any pending state change (if any) that didn't take place in
16424         handle_it_state () as explained above.  */
16425
16426 static void
16427 it_fsm_pre_encode (void)
16428 {
16429   if (inst.cond != COND_ALWAYS)
16430     inst.it_insn_type = INSIDE_IT_INSN;
16431   else
16432     inst.it_insn_type = OUTSIDE_IT_INSN;
16433
16434   now_it.state_handled = 0;
16435 }
16436
16437 /* IT state FSM handling function.  */
16438
16439 static int
16440 handle_it_state (void)
16441 {
16442   now_it.state_handled = 1;
16443   now_it.insn_cond = FALSE;
16444
16445   switch (now_it.state)
16446     {
16447     case OUTSIDE_IT_BLOCK:
16448       switch (inst.it_insn_type)
16449         {
16450         case OUTSIDE_IT_INSN:
16451           break;
16452
16453         case INSIDE_IT_INSN:
16454         case INSIDE_IT_LAST_INSN:
16455           if (thumb_mode == 0)
16456             {
16457               if (unified_syntax
16458                   && !(implicit_it_mode & IMPLICIT_IT_MODE_ARM))
16459                 as_tsktsk (_("Warning: conditional outside an IT block"\
16460                              " for Thumb."));
16461             }
16462           else
16463             {
16464               if ((implicit_it_mode & IMPLICIT_IT_MODE_THUMB)
16465                   && ARM_CPU_HAS_FEATURE (cpu_variant, arm_arch_t2))
16466                 {
16467                   /* Automatically generate the IT instruction.  */
16468                   new_automatic_it_block (inst.cond);
16469                   if (inst.it_insn_type == INSIDE_IT_LAST_INSN)
16470                     close_automatic_it_block ();
16471                 }
16472               else
16473                 {
16474                   inst.error = BAD_OUT_IT;
16475                   return FAIL;
16476                 }
16477             }
16478           break;
16479
16480         case IF_INSIDE_IT_LAST_INSN:
16481         case NEUTRAL_IT_INSN:
16482           break;
16483
16484         case IT_INSN:
16485           now_it.state = MANUAL_IT_BLOCK;
16486           now_it.block_length = 0;
16487           break;
16488         }
16489       break;
16490
16491     case AUTOMATIC_IT_BLOCK:
16492       /* Three things may happen now:
16493          a) We should increment current it block size;
16494          b) We should close current it block (closing insn or 4 insns);
16495          c) We should close current it block and start a new one (due
16496          to incompatible conditions or
16497          4 insns-length block reached).  */
16498
16499       switch (inst.it_insn_type)
16500         {
16501         case OUTSIDE_IT_INSN:
16502           /* The closure of the block shall happen immediatelly,
16503              so any in_it_block () call reports the block as closed.  */
16504           force_automatic_it_block_close ();
16505           break;
16506
16507         case INSIDE_IT_INSN:
16508         case INSIDE_IT_LAST_INSN:
16509         case IF_INSIDE_IT_LAST_INSN:
16510           now_it.block_length++;
16511
16512           if (now_it.block_length > 4
16513               || !now_it_compatible (inst.cond))
16514             {
16515               force_automatic_it_block_close ();
16516               if (inst.it_insn_type != IF_INSIDE_IT_LAST_INSN)
16517                 new_automatic_it_block (inst.cond);
16518             }
16519           else
16520             {
16521               now_it.insn_cond = TRUE;
16522               now_it_add_mask (inst.cond);
16523             }
16524
16525           if (now_it.state == AUTOMATIC_IT_BLOCK
16526               && (inst.it_insn_type == INSIDE_IT_LAST_INSN
16527                   || inst.it_insn_type == IF_INSIDE_IT_LAST_INSN))
16528             close_automatic_it_block ();
16529           break;
16530
16531         case NEUTRAL_IT_INSN:
16532           now_it.block_length++;
16533           now_it.insn_cond = TRUE;
16534
16535           if (now_it.block_length > 4)
16536             force_automatic_it_block_close ();
16537           else
16538             now_it_add_mask (now_it.cc & 1);
16539           break;
16540
16541         case IT_INSN:
16542           close_automatic_it_block ();
16543           now_it.state = MANUAL_IT_BLOCK;
16544           break;
16545         }
16546       break;
16547
16548     case MANUAL_IT_BLOCK:
16549       {
16550         /* Check conditional suffixes.  */
16551         const int cond = now_it.cc ^ ((now_it.mask >> 4) & 1) ^ 1;
16552         int is_last;
16553         now_it.mask <<= 1;
16554         now_it.mask &= 0x1f;
16555         is_last = (now_it.mask == 0x10);
16556         now_it.insn_cond = TRUE;
16557
16558         switch (inst.it_insn_type)
16559           {
16560           case OUTSIDE_IT_INSN:
16561             inst.error = BAD_NOT_IT;
16562             return FAIL;
16563
16564           case INSIDE_IT_INSN:
16565             if (cond != inst.cond)
16566               {
16567                 inst.error = BAD_IT_COND;
16568                 return FAIL;
16569               }
16570             break;
16571
16572           case INSIDE_IT_LAST_INSN:
16573           case IF_INSIDE_IT_LAST_INSN:
16574             if (cond != inst.cond)
16575               {
16576                 inst.error = BAD_IT_COND;
16577                 return FAIL;
16578               }
16579             if (!is_last)
16580               {
16581                 inst.error = BAD_BRANCH;
16582                 return FAIL;
16583               }
16584             break;
16585
16586           case NEUTRAL_IT_INSN:
16587             /* The BKPT instruction is unconditional even in an IT block.  */
16588             break;
16589
16590           case IT_INSN:
16591             inst.error = BAD_IT_IT;
16592             return FAIL;
16593           }
16594       }
16595       break;
16596     }
16597
16598   return SUCCESS;
16599 }
16600
16601 struct depr_insn_mask
16602 {
16603   unsigned long pattern;
16604   unsigned long mask;
16605   const char* description;
16606 };
16607
16608 /* List of 16-bit instruction patterns deprecated in an IT block in
16609    ARMv8.  */
16610 static const struct depr_insn_mask depr_it_insns[] = {
16611   { 0xc000, 0xc000, N_("Short branches, Undefined, SVC, LDM/STM") },
16612   { 0xb000, 0xb000, N_("Miscellaneous 16-bit instructions") },
16613   { 0xa000, 0xb800, N_("ADR") },
16614   { 0x4800, 0xf800, N_("Literal loads") },
16615   { 0x4478, 0xf478, N_("Hi-register ADD, MOV, CMP, BX, BLX using pc") },
16616   { 0x4487, 0xfc87, N_("Hi-register ADD, MOV, CMP using pc") },
16617   { 0, 0, NULL }
16618 };
16619
16620 static void
16621 it_fsm_post_encode (void)
16622 {
16623   int is_last;
16624
16625   if (!now_it.state_handled)
16626     handle_it_state ();
16627
16628   if (now_it.insn_cond
16629       && !now_it.warn_deprecated
16630       && warn_on_deprecated
16631       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
16632     {
16633       if (inst.instruction >= 0x10000)
16634         {
16635           as_warn (_("it blocks containing wide Thumb instructions are "
16636                      "deprecated in ARMv8"));
16637           now_it.warn_deprecated = TRUE;
16638         }
16639       else
16640         {
16641           const struct depr_insn_mask *p = depr_it_insns;
16642
16643           while (p->mask != 0)
16644             {
16645               if ((inst.instruction & p->mask) == p->pattern)
16646                 {
16647                   as_warn (_("it blocks containing 16-bit Thumb intsructions "
16648                              "of the following class are deprecated in ARMv8: "
16649                              "%s"), p->description);
16650                   now_it.warn_deprecated = TRUE;
16651                   break;
16652                 }
16653
16654               ++p;
16655             }
16656         }
16657
16658       if (now_it.block_length > 1)
16659         {
16660           as_warn (_("it blocks of more than one conditional instruction are "
16661                      "deprecated in ARMv8"));
16662           now_it.warn_deprecated = TRUE;
16663         }
16664     }
16665
16666   is_last = (now_it.mask == 0x10);
16667   if (is_last)
16668     {
16669       now_it.state = OUTSIDE_IT_BLOCK;
16670       now_it.mask = 0;
16671     }
16672 }
16673
16674 static void
16675 force_automatic_it_block_close (void)
16676 {
16677   if (now_it.state == AUTOMATIC_IT_BLOCK)
16678     {
16679       close_automatic_it_block ();
16680       now_it.state = OUTSIDE_IT_BLOCK;
16681       now_it.mask = 0;
16682     }
16683 }
16684
16685 static int
16686 in_it_block (void)
16687 {
16688   if (!now_it.state_handled)
16689     handle_it_state ();
16690
16691   return now_it.state != OUTSIDE_IT_BLOCK;
16692 }
16693
16694 void
16695 md_assemble (char *str)
16696 {
16697   char *p = str;
16698   const struct asm_opcode * opcode;
16699
16700   /* Align the previous label if needed.  */
16701   if (last_label_seen != NULL)
16702     {
16703       symbol_set_frag (last_label_seen, frag_now);
16704       S_SET_VALUE (last_label_seen, (valueT) frag_now_fix ());
16705       S_SET_SEGMENT (last_label_seen, now_seg);
16706     }
16707
16708   memset (&inst, '\0', sizeof (inst));
16709   inst.reloc.type = BFD_RELOC_UNUSED;
16710
16711   opcode = opcode_lookup (&p);
16712   if (!opcode)
16713     {
16714       /* It wasn't an instruction, but it might be a register alias of
16715          the form alias .req reg, or a Neon .dn/.qn directive.  */
16716       if (! create_register_alias (str, p)
16717           && ! create_neon_reg_alias (str, p))
16718         as_bad (_("bad instruction `%s'"), str);
16719
16720       return;
16721     }
16722
16723   if (warn_on_deprecated && opcode->tag == OT_cinfix3_deprecated)
16724     as_warn (_("s suffix on comparison instruction is deprecated"));
16725
16726   /* The value which unconditional instructions should have in place of the
16727      condition field.  */
16728   inst.uncond_value = (opcode->tag == OT_csuffixF) ? 0xf : -1;
16729
16730   if (thumb_mode)
16731     {
16732       arm_feature_set variant;
16733
16734       variant = cpu_variant;
16735       /* Only allow coprocessor instructions on Thumb-2 capable devices.  */
16736       if (!ARM_CPU_HAS_FEATURE (variant, arm_arch_t2))
16737         ARM_CLEAR_FEATURE (variant, variant, fpu_any_hard);
16738       /* Check that this instruction is supported for this CPU.  */
16739       if (!opcode->tvariant
16740           || (thumb_mode == 1
16741               && !ARM_CPU_HAS_FEATURE (variant, *opcode->tvariant)))
16742         {
16743           as_bad (_("selected processor does not support Thumb mode `%s'"), str);
16744           return;
16745         }
16746       if (inst.cond != COND_ALWAYS && !unified_syntax
16747           && opcode->tencode != do_t_branch)
16748         {
16749           as_bad (_("Thumb does not support conditional execution"));
16750           return;
16751         }
16752
16753       if (!ARM_CPU_HAS_FEATURE (variant, arm_ext_v6t2))
16754         {
16755           if (opcode->tencode != do_t_blx && opcode->tencode != do_t_branch23
16756               && !(ARM_CPU_HAS_FEATURE(*opcode->tvariant, arm_ext_msr)
16757                    || ARM_CPU_HAS_FEATURE(*opcode->tvariant, arm_ext_barrier)))
16758             {
16759               /* Two things are addressed here.
16760                  1) Implicit require narrow instructions on Thumb-1.
16761                     This avoids relaxation accidentally introducing Thumb-2
16762                      instructions.
16763                  2) Reject wide instructions in non Thumb-2 cores.  */
16764               if (inst.size_req == 0)
16765                 inst.size_req = 2;
16766               else if (inst.size_req == 4)
16767                 {
16768                   as_bad (_("selected processor does not support Thumb-2 mode `%s'"), str);
16769                   return;
16770                 }
16771             }
16772         }
16773
16774       inst.instruction = opcode->tvalue;
16775
16776       if (!parse_operands (p, opcode->operands, /*thumb=*/TRUE))
16777         {
16778           /* Prepare the it_insn_type for those encodings that don't set
16779              it.  */
16780           it_fsm_pre_encode ();
16781
16782           opcode->tencode ();
16783
16784           it_fsm_post_encode ();
16785         }
16786
16787       if (!(inst.error || inst.relax))
16788         {
16789           gas_assert (inst.instruction < 0xe800 || inst.instruction > 0xffff);
16790           inst.size = (inst.instruction > 0xffff ? 4 : 2);
16791           if (inst.size_req && inst.size_req != inst.size)
16792             {
16793               as_bad (_("cannot honor width suffix -- `%s'"), str);
16794               return;
16795             }
16796         }
16797
16798       /* Something has gone badly wrong if we try to relax a fixed size
16799          instruction.  */
16800       gas_assert (inst.size_req == 0 || !inst.relax);
16801
16802       ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
16803                               *opcode->tvariant);
16804       /* Many Thumb-2 instructions also have Thumb-1 variants, so explicitly
16805          set those bits when Thumb-2 32-bit instructions are seen.  ie.
16806          anything other than bl/blx and v6-M instructions.
16807          This is overly pessimistic for relaxable instructions.  */
16808       if (((inst.size == 4 && (inst.instruction & 0xf800e800) != 0xf000e800)
16809            || inst.relax)
16810           && !(ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_msr)
16811                || ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_barrier)))
16812         ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
16813                                 arm_ext_v6t2);
16814
16815       check_neon_suffixes;
16816
16817       if (!inst.error)
16818         {
16819           mapping_state (MAP_THUMB);
16820         }
16821     }
16822   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
16823     {
16824       bfd_boolean is_bx;
16825
16826       /* bx is allowed on v5 cores, and sometimes on v4 cores.  */
16827       is_bx = (opcode->aencode == do_bx);
16828
16829       /* Check that this instruction is supported for this CPU.  */
16830       if (!(is_bx && fix_v4bx)
16831           && !(opcode->avariant &&
16832                ARM_CPU_HAS_FEATURE (cpu_variant, *opcode->avariant)))
16833         {
16834           as_bad (_("selected processor does not support ARM mode `%s'"), str);
16835           return;
16836         }
16837       if (inst.size_req)
16838         {
16839           as_bad (_("width suffixes are invalid in ARM mode -- `%s'"), str);
16840           return;
16841         }
16842
16843       inst.instruction = opcode->avalue;
16844       if (opcode->tag == OT_unconditionalF)
16845         inst.instruction |= 0xF << 28;
16846       else
16847         inst.instruction |= inst.cond << 28;
16848       inst.size = INSN_SIZE;
16849       if (!parse_operands (p, opcode->operands, /*thumb=*/FALSE))
16850         {
16851           it_fsm_pre_encode ();
16852           opcode->aencode ();
16853           it_fsm_post_encode ();
16854         }
16855       /* Arm mode bx is marked as both v4T and v5 because it's still required
16856          on a hypothetical non-thumb v5 core.  */
16857       if (is_bx)
16858         ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used, arm_ext_v4t);
16859       else
16860         ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used,
16861                                 *opcode->avariant);
16862
16863       check_neon_suffixes;
16864
16865       if (!inst.error)
16866         {
16867           mapping_state (MAP_ARM);
16868         }
16869     }
16870   else
16871     {
16872       as_bad (_("attempt to use an ARM instruction on a Thumb-only processor "
16873                 "-- `%s'"), str);
16874       return;
16875     }
16876   output_inst (str);
16877 }
16878
16879 static void
16880 check_it_blocks_finished (void)
16881 {
16882 #ifdef OBJ_ELF
16883   asection *sect;
16884
16885   for (sect = stdoutput->sections; sect != NULL; sect = sect->next)
16886     if (seg_info (sect)->tc_segment_info_data.current_it.state
16887         == MANUAL_IT_BLOCK)
16888       {
16889         as_warn (_("section '%s' finished with an open IT block."),
16890                  sect->name);
16891       }
16892 #else
16893   if (now_it.state == MANUAL_IT_BLOCK)
16894     as_warn (_("file finished with an open IT block."));
16895 #endif
16896 }
16897
16898 /* Various frobbings of labels and their addresses.  */
16899
16900 void
16901 arm_start_line_hook (void)
16902 {
16903   last_label_seen = NULL;
16904 }
16905
16906 void
16907 arm_frob_label (symbolS * sym)
16908 {
16909   last_label_seen = sym;
16910
16911   ARM_SET_THUMB (sym, thumb_mode);
16912
16913 #if defined OBJ_COFF || defined OBJ_ELF
16914   ARM_SET_INTERWORK (sym, support_interwork);
16915 #endif
16916
16917   force_automatic_it_block_close ();
16918
16919   /* Note - do not allow local symbols (.Lxxx) to be labelled
16920      as Thumb functions.  This is because these labels, whilst
16921      they exist inside Thumb code, are not the entry points for
16922      possible ARM->Thumb calls.  Also, these labels can be used
16923      as part of a computed goto or switch statement.  eg gcc
16924      can generate code that looks like this:
16925
16926                 ldr  r2, [pc, .Laaa]
16927                 lsl  r3, r3, #2
16928                 ldr  r2, [r3, r2]
16929                 mov  pc, r2
16930
16931        .Lbbb:  .word .Lxxx
16932        .Lccc:  .word .Lyyy
16933        ..etc...
16934        .Laaa:   .word Lbbb
16935
16936      The first instruction loads the address of the jump table.
16937      The second instruction converts a table index into a byte offset.
16938      The third instruction gets the jump address out of the table.
16939      The fourth instruction performs the jump.
16940
16941      If the address stored at .Laaa is that of a symbol which has the
16942      Thumb_Func bit set, then the linker will arrange for this address
16943      to have the bottom bit set, which in turn would mean that the
16944      address computation performed by the third instruction would end
16945      up with the bottom bit set.  Since the ARM is capable of unaligned
16946      word loads, the instruction would then load the incorrect address
16947      out of the jump table, and chaos would ensue.  */
16948   if (label_is_thumb_function_name
16949       && (S_GET_NAME (sym)[0] != '.' || S_GET_NAME (sym)[1] != 'L')
16950       && (bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
16951     {
16952       /* When the address of a Thumb function is taken the bottom
16953          bit of that address should be set.  This will allow
16954          interworking between Arm and Thumb functions to work
16955          correctly.  */
16956
16957       THUMB_SET_FUNC (sym, 1);
16958
16959       label_is_thumb_function_name = FALSE;
16960     }
16961
16962   dwarf2_emit_label (sym);
16963 }
16964
16965 bfd_boolean
16966 arm_data_in_code (void)
16967 {
16968   if (thumb_mode && ! strncmp (input_line_pointer + 1, "data:", 5))
16969     {
16970       *input_line_pointer = '/';
16971       input_line_pointer += 5;
16972       *input_line_pointer = 0;
16973       return TRUE;
16974     }
16975
16976   return FALSE;
16977 }
16978
16979 char *
16980 arm_canonicalize_symbol_name (char * name)
16981 {
16982   int len;
16983
16984   if (thumb_mode && (len = strlen (name)) > 5
16985       && streq (name + len - 5, "/data"))
16986     *(name + len - 5) = 0;
16987
16988   return name;
16989 }
16990 \f
16991 /* Table of all register names defined by default.  The user can
16992    define additional names with .req.  Note that all register names
16993    should appear in both upper and lowercase variants.  Some registers
16994    also have mixed-case names.  */
16995
16996 #define REGDEF(s,n,t) { #s, n, REG_TYPE_##t, TRUE, 0 }
16997 #define REGNUM(p,n,t) REGDEF(p##n, n, t)
16998 #define REGNUM2(p,n,t) REGDEF(p##n, 2 * n, t)
16999 #define REGSET(p,t) \
17000   REGNUM(p, 0,t), REGNUM(p, 1,t), REGNUM(p, 2,t), REGNUM(p, 3,t), \
17001   REGNUM(p, 4,t), REGNUM(p, 5,t), REGNUM(p, 6,t), REGNUM(p, 7,t), \
17002   REGNUM(p, 8,t), REGNUM(p, 9,t), REGNUM(p,10,t), REGNUM(p,11,t), \
17003   REGNUM(p,12,t), REGNUM(p,13,t), REGNUM(p,14,t), REGNUM(p,15,t)
17004 #define REGSETH(p,t) \
17005   REGNUM(p,16,t), REGNUM(p,17,t), REGNUM(p,18,t), REGNUM(p,19,t), \
17006   REGNUM(p,20,t), REGNUM(p,21,t), REGNUM(p,22,t), REGNUM(p,23,t), \
17007   REGNUM(p,24,t), REGNUM(p,25,t), REGNUM(p,26,t), REGNUM(p,27,t), \
17008   REGNUM(p,28,t), REGNUM(p,29,t), REGNUM(p,30,t), REGNUM(p,31,t)
17009 #define REGSET2(p,t) \
17010   REGNUM2(p, 0,t), REGNUM2(p, 1,t), REGNUM2(p, 2,t), REGNUM2(p, 3,t), \
17011   REGNUM2(p, 4,t), REGNUM2(p, 5,t), REGNUM2(p, 6,t), REGNUM2(p, 7,t), \
17012   REGNUM2(p, 8,t), REGNUM2(p, 9,t), REGNUM2(p,10,t), REGNUM2(p,11,t), \
17013   REGNUM2(p,12,t), REGNUM2(p,13,t), REGNUM2(p,14,t), REGNUM2(p,15,t)
17014 #define SPLRBANK(base,bank,t) \
17015   REGDEF(lr_##bank, 768|((base+0)<<16), t), \
17016   REGDEF(sp_##bank, 768|((base+1)<<16), t), \
17017   REGDEF(spsr_##bank, 768|(base<<16)|SPSR_BIT, t), \
17018   REGDEF(LR_##bank, 768|((base+0)<<16), t), \
17019   REGDEF(SP_##bank, 768|((base+1)<<16), t), \
17020   REGDEF(SPSR_##bank, 768|(base<<16)|SPSR_BIT, t)
17021
17022 static const struct reg_entry reg_names[] =
17023 {
17024   /* ARM integer registers.  */
17025   REGSET(r, RN), REGSET(R, RN),
17026
17027   /* ATPCS synonyms.  */
17028   REGDEF(a1,0,RN), REGDEF(a2,1,RN), REGDEF(a3, 2,RN), REGDEF(a4, 3,RN),
17029   REGDEF(v1,4,RN), REGDEF(v2,5,RN), REGDEF(v3, 6,RN), REGDEF(v4, 7,RN),
17030   REGDEF(v5,8,RN), REGDEF(v6,9,RN), REGDEF(v7,10,RN), REGDEF(v8,11,RN),
17031
17032   REGDEF(A1,0,RN), REGDEF(A2,1,RN), REGDEF(A3, 2,RN), REGDEF(A4, 3,RN),
17033   REGDEF(V1,4,RN), REGDEF(V2,5,RN), REGDEF(V3, 6,RN), REGDEF(V4, 7,RN),
17034   REGDEF(V5,8,RN), REGDEF(V6,9,RN), REGDEF(V7,10,RN), REGDEF(V8,11,RN),
17035
17036   /* Well-known aliases.  */
17037   REGDEF(wr, 7,RN), REGDEF(sb, 9,RN), REGDEF(sl,10,RN), REGDEF(fp,11,RN),
17038   REGDEF(ip,12,RN), REGDEF(sp,13,RN), REGDEF(lr,14,RN), REGDEF(pc,15,RN),
17039
17040   REGDEF(WR, 7,RN), REGDEF(SB, 9,RN), REGDEF(SL,10,RN), REGDEF(FP,11,RN),
17041   REGDEF(IP,12,RN), REGDEF(SP,13,RN), REGDEF(LR,14,RN), REGDEF(PC,15,RN),
17042
17043   /* Coprocessor numbers.  */
17044   REGSET(p, CP), REGSET(P, CP),
17045
17046   /* Coprocessor register numbers.  The "cr" variants are for backward
17047      compatibility.  */
17048   REGSET(c,  CN), REGSET(C, CN),
17049   REGSET(cr, CN), REGSET(CR, CN),
17050
17051   /* ARM banked registers.  */
17052   REGDEF(R8_usr,512|(0<<16),RNB), REGDEF(r8_usr,512|(0<<16),RNB),
17053   REGDEF(R9_usr,512|(1<<16),RNB), REGDEF(r9_usr,512|(1<<16),RNB),
17054   REGDEF(R10_usr,512|(2<<16),RNB), REGDEF(r10_usr,512|(2<<16),RNB),
17055   REGDEF(R11_usr,512|(3<<16),RNB), REGDEF(r11_usr,512|(3<<16),RNB),
17056   REGDEF(R12_usr,512|(4<<16),RNB), REGDEF(r12_usr,512|(4<<16),RNB),
17057   REGDEF(SP_usr,512|(5<<16),RNB), REGDEF(sp_usr,512|(5<<16),RNB),
17058   REGDEF(LR_usr,512|(6<<16),RNB), REGDEF(lr_usr,512|(6<<16),RNB),
17059
17060   REGDEF(R8_fiq,512|(8<<16),RNB), REGDEF(r8_fiq,512|(8<<16),RNB),
17061   REGDEF(R9_fiq,512|(9<<16),RNB), REGDEF(r9_fiq,512|(9<<16),RNB),
17062   REGDEF(R10_fiq,512|(10<<16),RNB), REGDEF(r10_fiq,512|(10<<16),RNB),
17063   REGDEF(R11_fiq,512|(11<<16),RNB), REGDEF(r11_fiq,512|(11<<16),RNB),
17064   REGDEF(R12_fiq,512|(12<<16),RNB), REGDEF(r12_fiq,512|(12<<16),RNB),
17065   REGDEF(SP_fiq,512|(13<<16),RNB), REGDEF(SP_fiq,512|(13<<16),RNB),
17066   REGDEF(LR_fiq,512|(14<<16),RNB), REGDEF(lr_fiq,512|(14<<16),RNB),
17067   REGDEF(SPSR_fiq,512|(14<<16)|SPSR_BIT,RNB), REGDEF(spsr_fiq,512|(14<<16)|SPSR_BIT,RNB),
17068
17069   SPLRBANK(0,IRQ,RNB), SPLRBANK(0,irq,RNB),
17070   SPLRBANK(2,SVC,RNB), SPLRBANK(2,svc,RNB),
17071   SPLRBANK(4,ABT,RNB), SPLRBANK(4,abt,RNB),
17072   SPLRBANK(6,UND,RNB), SPLRBANK(6,und,RNB),
17073   SPLRBANK(12,MON,RNB), SPLRBANK(12,mon,RNB),
17074   REGDEF(elr_hyp,768|(14<<16),RNB), REGDEF(ELR_hyp,768|(14<<16),RNB),
17075   REGDEF(sp_hyp,768|(15<<16),RNB), REGDEF(SP_hyp,768|(15<<16),RNB),
17076   REGDEF(spsr_hyp,768|(14<<16)|SPSR_BIT,RNB),
17077   REGDEF(SPSR_hyp,768|(14<<16)|SPSR_BIT,RNB),
17078
17079   /* FPA registers.  */
17080   REGNUM(f,0,FN), REGNUM(f,1,FN), REGNUM(f,2,FN), REGNUM(f,3,FN),
17081   REGNUM(f,4,FN), REGNUM(f,5,FN), REGNUM(f,6,FN), REGNUM(f,7, FN),
17082
17083   REGNUM(F,0,FN), REGNUM(F,1,FN), REGNUM(F,2,FN), REGNUM(F,3,FN),
17084   REGNUM(F,4,FN), REGNUM(F,5,FN), REGNUM(F,6,FN), REGNUM(F,7, FN),
17085
17086   /* VFP SP registers.  */
17087   REGSET(s,VFS),  REGSET(S,VFS),
17088   REGSETH(s,VFS), REGSETH(S,VFS),
17089
17090   /* VFP DP Registers.  */
17091   REGSET(d,VFD),  REGSET(D,VFD),
17092   /* Extra Neon DP registers.  */
17093   REGSETH(d,VFD), REGSETH(D,VFD),
17094
17095   /* Neon QP registers.  */
17096   REGSET2(q,NQ),  REGSET2(Q,NQ),
17097
17098   /* VFP control registers.  */
17099   REGDEF(fpsid,0,VFC), REGDEF(fpscr,1,VFC), REGDEF(fpexc,8,VFC),
17100   REGDEF(FPSID,0,VFC), REGDEF(FPSCR,1,VFC), REGDEF(FPEXC,8,VFC),
17101   REGDEF(fpinst,9,VFC), REGDEF(fpinst2,10,VFC),
17102   REGDEF(FPINST,9,VFC), REGDEF(FPINST2,10,VFC),
17103   REGDEF(mvfr0,7,VFC), REGDEF(mvfr1,6,VFC),
17104   REGDEF(MVFR0,7,VFC), REGDEF(MVFR1,6,VFC),
17105
17106   /* Maverick DSP coprocessor registers.  */
17107   REGSET(mvf,MVF),  REGSET(mvd,MVD),  REGSET(mvfx,MVFX),  REGSET(mvdx,MVDX),
17108   REGSET(MVF,MVF),  REGSET(MVD,MVD),  REGSET(MVFX,MVFX),  REGSET(MVDX,MVDX),
17109
17110   REGNUM(mvax,0,MVAX), REGNUM(mvax,1,MVAX),
17111   REGNUM(mvax,2,MVAX), REGNUM(mvax,3,MVAX),
17112   REGDEF(dspsc,0,DSPSC),
17113
17114   REGNUM(MVAX,0,MVAX), REGNUM(MVAX,1,MVAX),
17115   REGNUM(MVAX,2,MVAX), REGNUM(MVAX,3,MVAX),
17116   REGDEF(DSPSC,0,DSPSC),
17117
17118   /* iWMMXt data registers - p0, c0-15.  */
17119   REGSET(wr,MMXWR), REGSET(wR,MMXWR), REGSET(WR, MMXWR),
17120
17121   /* iWMMXt control registers - p1, c0-3.  */
17122   REGDEF(wcid,  0,MMXWC),  REGDEF(wCID,  0,MMXWC),  REGDEF(WCID,  0,MMXWC),
17123   REGDEF(wcon,  1,MMXWC),  REGDEF(wCon,  1,MMXWC),  REGDEF(WCON,  1,MMXWC),
17124   REGDEF(wcssf, 2,MMXWC),  REGDEF(wCSSF, 2,MMXWC),  REGDEF(WCSSF, 2,MMXWC),
17125   REGDEF(wcasf, 3,MMXWC),  REGDEF(wCASF, 3,MMXWC),  REGDEF(WCASF, 3,MMXWC),
17126
17127   /* iWMMXt scalar (constant/offset) registers - p1, c8-11.  */
17128   REGDEF(wcgr0, 8,MMXWCG),  REGDEF(wCGR0, 8,MMXWCG),  REGDEF(WCGR0, 8,MMXWCG),
17129   REGDEF(wcgr1, 9,MMXWCG),  REGDEF(wCGR1, 9,MMXWCG),  REGDEF(WCGR1, 9,MMXWCG),
17130   REGDEF(wcgr2,10,MMXWCG),  REGDEF(wCGR2,10,MMXWCG),  REGDEF(WCGR2,10,MMXWCG),
17131   REGDEF(wcgr3,11,MMXWCG),  REGDEF(wCGR3,11,MMXWCG),  REGDEF(WCGR3,11,MMXWCG),
17132
17133   /* XScale accumulator registers.  */
17134   REGNUM(acc,0,XSCALE), REGNUM(ACC,0,XSCALE),
17135 };
17136 #undef REGDEF
17137 #undef REGNUM
17138 #undef REGSET
17139
17140 /* Table of all PSR suffixes.  Bare "CPSR" and "SPSR" are handled
17141    within psr_required_here.  */
17142 static const struct asm_psr psrs[] =
17143 {
17144   /* Backward compatibility notation.  Note that "all" is no longer
17145      truly all possible PSR bits.  */
17146   {"all",  PSR_c | PSR_f},
17147   {"flg",  PSR_f},
17148   {"ctl",  PSR_c},
17149
17150   /* Individual flags.  */
17151   {"f",    PSR_f},
17152   {"c",    PSR_c},
17153   {"x",    PSR_x},
17154   {"s",    PSR_s},
17155
17156   /* Combinations of flags.  */
17157   {"fs",   PSR_f | PSR_s},
17158   {"fx",   PSR_f | PSR_x},
17159   {"fc",   PSR_f | PSR_c},
17160   {"sf",   PSR_s | PSR_f},
17161   {"sx",   PSR_s | PSR_x},
17162   {"sc",   PSR_s | PSR_c},
17163   {"xf",   PSR_x | PSR_f},
17164   {"xs",   PSR_x | PSR_s},
17165   {"xc",   PSR_x | PSR_c},
17166   {"cf",   PSR_c | PSR_f},
17167   {"cs",   PSR_c | PSR_s},
17168   {"cx",   PSR_c | PSR_x},
17169   {"fsx",  PSR_f | PSR_s | PSR_x},
17170   {"fsc",  PSR_f | PSR_s | PSR_c},
17171   {"fxs",  PSR_f | PSR_x | PSR_s},
17172   {"fxc",  PSR_f | PSR_x | PSR_c},
17173   {"fcs",  PSR_f | PSR_c | PSR_s},
17174   {"fcx",  PSR_f | PSR_c | PSR_x},
17175   {"sfx",  PSR_s | PSR_f | PSR_x},
17176   {"sfc",  PSR_s | PSR_f | PSR_c},
17177   {"sxf",  PSR_s | PSR_x | PSR_f},
17178   {"sxc",  PSR_s | PSR_x | PSR_c},
17179   {"scf",  PSR_s | PSR_c | PSR_f},
17180   {"scx",  PSR_s | PSR_c | PSR_x},
17181   {"xfs",  PSR_x | PSR_f | PSR_s},
17182   {"xfc",  PSR_x | PSR_f | PSR_c},
17183   {"xsf",  PSR_x | PSR_s | PSR_f},
17184   {"xsc",  PSR_x | PSR_s | PSR_c},
17185   {"xcf",  PSR_x | PSR_c | PSR_f},
17186   {"xcs",  PSR_x | PSR_c | PSR_s},
17187   {"cfs",  PSR_c | PSR_f | PSR_s},
17188   {"cfx",  PSR_c | PSR_f | PSR_x},
17189   {"csf",  PSR_c | PSR_s | PSR_f},
17190   {"csx",  PSR_c | PSR_s | PSR_x},
17191   {"cxf",  PSR_c | PSR_x | PSR_f},
17192   {"cxs",  PSR_c | PSR_x | PSR_s},
17193   {"fsxc", PSR_f | PSR_s | PSR_x | PSR_c},
17194   {"fscx", PSR_f | PSR_s | PSR_c | PSR_x},
17195   {"fxsc", PSR_f | PSR_x | PSR_s | PSR_c},
17196   {"fxcs", PSR_f | PSR_x | PSR_c | PSR_s},
17197   {"fcsx", PSR_f | PSR_c | PSR_s | PSR_x},
17198   {"fcxs", PSR_f | PSR_c | PSR_x | PSR_s},
17199   {"sfxc", PSR_s | PSR_f | PSR_x | PSR_c},
17200   {"sfcx", PSR_s | PSR_f | PSR_c | PSR_x},
17201   {"sxfc", PSR_s | PSR_x | PSR_f | PSR_c},
17202   {"sxcf", PSR_s | PSR_x | PSR_c | PSR_f},
17203   {"scfx", PSR_s | PSR_c | PSR_f | PSR_x},
17204   {"scxf", PSR_s | PSR_c | PSR_x | PSR_f},
17205   {"xfsc", PSR_x | PSR_f | PSR_s | PSR_c},
17206   {"xfcs", PSR_x | PSR_f | PSR_c | PSR_s},
17207   {"xsfc", PSR_x | PSR_s | PSR_f | PSR_c},
17208   {"xscf", PSR_x | PSR_s | PSR_c | PSR_f},
17209   {"xcfs", PSR_x | PSR_c | PSR_f | PSR_s},
17210   {"xcsf", PSR_x | PSR_c | PSR_s | PSR_f},
17211   {"cfsx", PSR_c | PSR_f | PSR_s | PSR_x},
17212   {"cfxs", PSR_c | PSR_f | PSR_x | PSR_s},
17213   {"csfx", PSR_c | PSR_s | PSR_f | PSR_x},
17214   {"csxf", PSR_c | PSR_s | PSR_x | PSR_f},
17215   {"cxfs", PSR_c | PSR_x | PSR_f | PSR_s},
17216   {"cxsf", PSR_c | PSR_x | PSR_s | PSR_f},
17217 };
17218
17219 /* Table of V7M psr names.  */
17220 static const struct asm_psr v7m_psrs[] =
17221 {
17222   {"apsr",        0 }, {"APSR",         0 },
17223   {"iapsr",       1 }, {"IAPSR",        1 },
17224   {"eapsr",       2 }, {"EAPSR",        2 },
17225   {"psr",         3 }, {"PSR",          3 },
17226   {"xpsr",        3 }, {"XPSR",         3 }, {"xPSR",     3 },
17227   {"ipsr",        5 }, {"IPSR",         5 },
17228   {"epsr",        6 }, {"EPSR",         6 },
17229   {"iepsr",       7 }, {"IEPSR",        7 },
17230   {"msp",         8 }, {"MSP",          8 },
17231   {"psp",         9 }, {"PSP",          9 },
17232   {"primask",     16}, {"PRIMASK",      16},
17233   {"basepri",     17}, {"BASEPRI",      17},
17234   {"basepri_max", 18}, {"BASEPRI_MAX",  18},
17235   {"basepri_max", 18}, {"BASEPRI_MASK", 18}, /* Typo, preserved for backwards compatibility.  */
17236   {"faultmask",   19}, {"FAULTMASK",    19},
17237   {"control",     20}, {"CONTROL",      20}
17238 };
17239
17240 /* Table of all shift-in-operand names.  */
17241 static const struct asm_shift_name shift_names [] =
17242 {
17243   { "asl", SHIFT_LSL },  { "ASL", SHIFT_LSL },
17244   { "lsl", SHIFT_LSL },  { "LSL", SHIFT_LSL },
17245   { "lsr", SHIFT_LSR },  { "LSR", SHIFT_LSR },
17246   { "asr", SHIFT_ASR },  { "ASR", SHIFT_ASR },
17247   { "ror", SHIFT_ROR },  { "ROR", SHIFT_ROR },
17248   { "rrx", SHIFT_RRX },  { "RRX", SHIFT_RRX }
17249 };
17250
17251 /* Table of all explicit relocation names.  */
17252 #ifdef OBJ_ELF
17253 static struct reloc_entry reloc_names[] =
17254 {
17255   { "got",     BFD_RELOC_ARM_GOT32   },  { "GOT",     BFD_RELOC_ARM_GOT32   },
17256   { "gotoff",  BFD_RELOC_ARM_GOTOFF  },  { "GOTOFF",  BFD_RELOC_ARM_GOTOFF  },
17257   { "plt",     BFD_RELOC_ARM_PLT32   },  { "PLT",     BFD_RELOC_ARM_PLT32   },
17258   { "target1", BFD_RELOC_ARM_TARGET1 },  { "TARGET1", BFD_RELOC_ARM_TARGET1 },
17259   { "target2", BFD_RELOC_ARM_TARGET2 },  { "TARGET2", BFD_RELOC_ARM_TARGET2 },
17260   { "sbrel",   BFD_RELOC_ARM_SBREL32 },  { "SBREL",   BFD_RELOC_ARM_SBREL32 },
17261   { "tlsgd",   BFD_RELOC_ARM_TLS_GD32},  { "TLSGD",   BFD_RELOC_ARM_TLS_GD32},
17262   { "tlsldm",  BFD_RELOC_ARM_TLS_LDM32}, { "TLSLDM",  BFD_RELOC_ARM_TLS_LDM32},
17263   { "tlsldo",  BFD_RELOC_ARM_TLS_LDO32}, { "TLSLDO",  BFD_RELOC_ARM_TLS_LDO32},
17264   { "gottpoff",BFD_RELOC_ARM_TLS_IE32},  { "GOTTPOFF",BFD_RELOC_ARM_TLS_IE32},
17265   { "tpoff",   BFD_RELOC_ARM_TLS_LE32},  { "TPOFF",   BFD_RELOC_ARM_TLS_LE32},
17266   { "got_prel", BFD_RELOC_ARM_GOT_PREL}, { "GOT_PREL", BFD_RELOC_ARM_GOT_PREL},
17267   { "tlsdesc", BFD_RELOC_ARM_TLS_GOTDESC},
17268         { "TLSDESC", BFD_RELOC_ARM_TLS_GOTDESC},
17269   { "tlscall", BFD_RELOC_ARM_TLS_CALL},
17270         { "TLSCALL", BFD_RELOC_ARM_TLS_CALL},
17271   { "tlsdescseq", BFD_RELOC_ARM_TLS_DESCSEQ},
17272         { "TLSDESCSEQ", BFD_RELOC_ARM_TLS_DESCSEQ}
17273 };
17274 #endif
17275
17276 /* Table of all conditional affixes.  0xF is not defined as a condition code.  */
17277 static const struct asm_cond conds[] =
17278 {
17279   {"eq", 0x0},
17280   {"ne", 0x1},
17281   {"cs", 0x2}, {"hs", 0x2},
17282   {"cc", 0x3}, {"ul", 0x3}, {"lo", 0x3},
17283   {"mi", 0x4},
17284   {"pl", 0x5},
17285   {"vs", 0x6},
17286   {"vc", 0x7},
17287   {"hi", 0x8},
17288   {"ls", 0x9},
17289   {"ge", 0xa},
17290   {"lt", 0xb},
17291   {"gt", 0xc},
17292   {"le", 0xd},
17293   {"al", 0xe}
17294 };
17295
17296 #define UL_BARRIER(L,U,CODE,FEAT) \
17297   { L, CODE, ARM_FEATURE (FEAT, 0) }, \
17298   { U, CODE, ARM_FEATURE (FEAT, 0) }
17299
17300 static struct asm_barrier_opt barrier_opt_names[] =
17301 {
17302   UL_BARRIER ("sy",     "SY",    0xf, ARM_EXT_BARRIER),
17303   UL_BARRIER ("st",     "ST",    0xe, ARM_EXT_BARRIER),
17304   UL_BARRIER ("ld",     "LD",    0xd, ARM_EXT_V8),
17305   UL_BARRIER ("ish",    "ISH",   0xb, ARM_EXT_BARRIER),
17306   UL_BARRIER ("sh",     "SH",    0xb, ARM_EXT_BARRIER),
17307   UL_BARRIER ("ishst",  "ISHST", 0xa, ARM_EXT_BARRIER),
17308   UL_BARRIER ("shst",   "SHST",  0xa, ARM_EXT_BARRIER),
17309   UL_BARRIER ("ishld",  "ISHLD", 0x9, ARM_EXT_V8),
17310   UL_BARRIER ("un",     "UN",    0x7, ARM_EXT_BARRIER),
17311   UL_BARRIER ("nsh",    "NSH",   0x7, ARM_EXT_BARRIER),
17312   UL_BARRIER ("unst",   "UNST",  0x6, ARM_EXT_BARRIER),
17313   UL_BARRIER ("nshst",  "NSHST", 0x6, ARM_EXT_BARRIER),
17314   UL_BARRIER ("nshld",  "NSHLD", 0x5, ARM_EXT_V8),
17315   UL_BARRIER ("osh",    "OSH",   0x3, ARM_EXT_BARRIER),
17316   UL_BARRIER ("oshst",  "OSHST", 0x2, ARM_EXT_BARRIER),
17317   UL_BARRIER ("oshld",  "OSHLD", 0x1, ARM_EXT_V8)
17318 };
17319
17320 #undef UL_BARRIER
17321
17322 /* Table of ARM-format instructions.    */
17323
17324 /* Macros for gluing together operand strings.  N.B. In all cases
17325    other than OPS0, the trailing OP_stop comes from default
17326    zero-initialization of the unspecified elements of the array.  */
17327 #define OPS0()            { OP_stop, }
17328 #define OPS1(a)           { OP_##a, }
17329 #define OPS2(a,b)         { OP_##a,OP_##b, }
17330 #define OPS3(a,b,c)       { OP_##a,OP_##b,OP_##c, }
17331 #define OPS4(a,b,c,d)     { OP_##a,OP_##b,OP_##c,OP_##d, }
17332 #define OPS5(a,b,c,d,e)   { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e, }
17333 #define OPS6(a,b,c,d,e,f) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e,OP_##f, }
17334
17335 /* These macros are similar to the OPSn, but do not prepend the OP_ prefix.
17336    This is useful when mixing operands for ARM and THUMB, i.e. using the
17337    MIX_ARM_THUMB_OPERANDS macro.
17338    In order to use these macros, prefix the number of operands with _
17339    e.g. _3.  */
17340 #define OPS_1(a)           { a, }
17341 #define OPS_2(a,b)         { a,b, }
17342 #define OPS_3(a,b,c)       { a,b,c, }
17343 #define OPS_4(a,b,c,d)     { a,b,c,d, }
17344 #define OPS_5(a,b,c,d,e)   { a,b,c,d,e, }
17345 #define OPS_6(a,b,c,d,e,f) { a,b,c,d,e,f, }
17346
17347 /* These macros abstract out the exact format of the mnemonic table and
17348    save some repeated characters.  */
17349
17350 /* The normal sort of mnemonic; has a Thumb variant; takes a conditional suffix.  */
17351 #define TxCE(mnem, op, top, nops, ops, ae, te) \
17352   { mnem, OPS##nops ops, OT_csuffix, 0x##op, top, ARM_VARIANT, \
17353     THUMB_VARIANT, do_##ae, do_##te }
17354
17355 /* Two variants of the above - TCE for a numeric Thumb opcode, tCE for
17356    a T_MNEM_xyz enumerator.  */
17357 #define TCE(mnem, aop, top, nops, ops, ae, te) \
17358       TxCE (mnem, aop, 0x##top, nops, ops, ae, te)
17359 #define tCE(mnem, aop, top, nops, ops, ae, te) \
17360       TxCE (mnem, aop, T_MNEM##top, nops, ops, ae, te)
17361
17362 /* Second most common sort of mnemonic: has a Thumb variant, takes a conditional
17363    infix after the third character.  */
17364 #define TxC3(mnem, op, top, nops, ops, ae, te) \
17365   { mnem, OPS##nops ops, OT_cinfix3, 0x##op, top, ARM_VARIANT, \
17366     THUMB_VARIANT, do_##ae, do_##te }
17367 #define TxC3w(mnem, op, top, nops, ops, ae, te) \
17368   { mnem, OPS##nops ops, OT_cinfix3_deprecated, 0x##op, top, ARM_VARIANT, \
17369     THUMB_VARIANT, do_##ae, do_##te }
17370 #define TC3(mnem, aop, top, nops, ops, ae, te) \
17371       TxC3 (mnem, aop, 0x##top, nops, ops, ae, te)
17372 #define TC3w(mnem, aop, top, nops, ops, ae, te) \
17373       TxC3w (mnem, aop, 0x##top, nops, ops, ae, te)
17374 #define tC3(mnem, aop, top, nops, ops, ae, te) \
17375       TxC3 (mnem, aop, T_MNEM##top, nops, ops, ae, te)
17376 #define tC3w(mnem, aop, top, nops, ops, ae, te) \
17377       TxC3w (mnem, aop, T_MNEM##top, nops, ops, ae, te)
17378
17379 /* Mnemonic with a conditional infix in an unusual place.  Each and every variant has to
17380    appear in the condition table.  */
17381 #define TxCM_(m1, m2, m3, op, top, nops, ops, ae, te)   \
17382   { m1 #m2 m3, OPS##nops ops, sizeof (#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof (m1) - 1, \
17383     0x##op, top, ARM_VARIANT, THUMB_VARIANT, do_##ae, do_##te }
17384
17385 #define TxCM(m1, m2, op, top, nops, ops, ae, te)        \
17386   TxCM_ (m1,   , m2, op, top, nops, ops, ae, te),       \
17387   TxCM_ (m1, eq, m2, op, top, nops, ops, ae, te),       \
17388   TxCM_ (m1, ne, m2, op, top, nops, ops, ae, te),       \
17389   TxCM_ (m1, cs, m2, op, top, nops, ops, ae, te),       \
17390   TxCM_ (m1, hs, m2, op, top, nops, ops, ae, te),       \
17391   TxCM_ (m1, cc, m2, op, top, nops, ops, ae, te),       \
17392   TxCM_ (m1, ul, m2, op, top, nops, ops, ae, te),       \
17393   TxCM_ (m1, lo, m2, op, top, nops, ops, ae, te),       \
17394   TxCM_ (m1, mi, m2, op, top, nops, ops, ae, te),       \
17395   TxCM_ (m1, pl, m2, op, top, nops, ops, ae, te),       \
17396   TxCM_ (m1, vs, m2, op, top, nops, ops, ae, te),       \
17397   TxCM_ (m1, vc, m2, op, top, nops, ops, ae, te),       \
17398   TxCM_ (m1, hi, m2, op, top, nops, ops, ae, te),       \
17399   TxCM_ (m1, ls, m2, op, top, nops, ops, ae, te),       \
17400   TxCM_ (m1, ge, m2, op, top, nops, ops, ae, te),       \
17401   TxCM_ (m1, lt, m2, op, top, nops, ops, ae, te),       \
17402   TxCM_ (m1, gt, m2, op, top, nops, ops, ae, te),       \
17403   TxCM_ (m1, le, m2, op, top, nops, ops, ae, te),       \
17404   TxCM_ (m1, al, m2, op, top, nops, ops, ae, te)
17405
17406 #define TCM(m1,m2, aop, top, nops, ops, ae, te)         \
17407       TxCM (m1,m2, aop, 0x##top, nops, ops, ae, te)
17408 #define tCM(m1,m2, aop, top, nops, ops, ae, te)         \
17409       TxCM (m1,m2, aop, T_MNEM##top, nops, ops, ae, te)
17410
17411 /* Mnemonic that cannot be conditionalized.  The ARM condition-code
17412    field is still 0xE.  Many of the Thumb variants can be executed
17413    conditionally, so this is checked separately.  */
17414 #define TUE(mnem, op, top, nops, ops, ae, te)                           \
17415   { mnem, OPS##nops ops, OT_unconditional, 0x##op, 0x##top, ARM_VARIANT, \
17416     THUMB_VARIANT, do_##ae, do_##te }
17417
17418 /* Mnemonic that cannot be conditionalized, and bears 0xF in its ARM
17419    condition code field.  */
17420 #define TUF(mnem, op, top, nops, ops, ae, te)                           \
17421   { mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##top, ARM_VARIANT, \
17422     THUMB_VARIANT, do_##ae, do_##te }
17423
17424 /* ARM-only variants of all the above.  */
17425 #define CE(mnem,  op, nops, ops, ae)    \
17426   { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
17427
17428 #define C3(mnem, op, nops, ops, ae)     \
17429   { #mnem, OPS##nops ops, OT_cinfix3, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
17430
17431 /* Legacy mnemonics that always have conditional infix after the third
17432    character.  */
17433 #define CL(mnem, op, nops, ops, ae)     \
17434   { mnem, OPS##nops ops, OT_cinfix3_legacy, \
17435     0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
17436
17437 /* Coprocessor instructions.  Isomorphic between Arm and Thumb-2.  */
17438 #define cCE(mnem,  op, nops, ops, ae)   \
17439   { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
17440
17441 /* Legacy coprocessor instructions where conditional infix and conditional
17442    suffix are ambiguous.  For consistency this includes all FPA instructions,
17443    not just the potentially ambiguous ones.  */
17444 #define cCL(mnem, op, nops, ops, ae)    \
17445   { mnem, OPS##nops ops, OT_cinfix3_legacy, \
17446     0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
17447
17448 /* Coprocessor, takes either a suffix or a position-3 infix
17449    (for an FPA corner case). */
17450 #define C3E(mnem, op, nops, ops, ae) \
17451   { mnem, OPS##nops ops, OT_csuf_or_in3, \
17452     0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
17453
17454 #define xCM_(m1, m2, m3, op, nops, ops, ae)     \
17455   { m1 #m2 m3, OPS##nops ops, \
17456     sizeof (#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof (m1) - 1, \
17457     0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
17458
17459 #define CM(m1, m2, op, nops, ops, ae)   \
17460   xCM_ (m1,   , m2, op, nops, ops, ae), \
17461   xCM_ (m1, eq, m2, op, nops, ops, ae), \
17462   xCM_ (m1, ne, m2, op, nops, ops, ae), \
17463   xCM_ (m1, cs, m2, op, nops, ops, ae), \
17464   xCM_ (m1, hs, m2, op, nops, ops, ae), \
17465   xCM_ (m1, cc, m2, op, nops, ops, ae), \
17466   xCM_ (m1, ul, m2, op, nops, ops, ae), \
17467   xCM_ (m1, lo, m2, op, nops, ops, ae), \
17468   xCM_ (m1, mi, m2, op, nops, ops, ae), \
17469   xCM_ (m1, pl, m2, op, nops, ops, ae), \
17470   xCM_ (m1, vs, m2, op, nops, ops, ae), \
17471   xCM_ (m1, vc, m2, op, nops, ops, ae), \
17472   xCM_ (m1, hi, m2, op, nops, ops, ae), \
17473   xCM_ (m1, ls, m2, op, nops, ops, ae), \
17474   xCM_ (m1, ge, m2, op, nops, ops, ae), \
17475   xCM_ (m1, lt, m2, op, nops, ops, ae), \
17476   xCM_ (m1, gt, m2, op, nops, ops, ae), \
17477   xCM_ (m1, le, m2, op, nops, ops, ae), \
17478   xCM_ (m1, al, m2, op, nops, ops, ae)
17479
17480 #define UE(mnem, op, nops, ops, ae)     \
17481   { #mnem, OPS##nops ops, OT_unconditional, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
17482
17483 #define UF(mnem, op, nops, ops, ae)     \
17484   { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
17485
17486 /* Neon data-processing. ARM versions are unconditional with cond=0xf.
17487    The Thumb and ARM variants are mostly the same (bits 0-23 and 24/28), so we
17488    use the same encoding function for each.  */
17489 #define NUF(mnem, op, nops, ops, enc)                                   \
17490   { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##op,            \
17491     ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
17492
17493 /* Neon data processing, version which indirects through neon_enc_tab for
17494    the various overloaded versions of opcodes.  */
17495 #define nUF(mnem, op, nops, ops, enc)                                   \
17496   { #mnem, OPS##nops ops, OT_unconditionalF, N_MNEM##op, N_MNEM##op,    \
17497     ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
17498
17499 /* Neon insn with conditional suffix for the ARM version, non-overloaded
17500    version.  */
17501 #define NCE_tag(mnem, op, nops, ops, enc, tag)                          \
17502   { #mnem, OPS##nops ops, tag, 0x##op, 0x##op, ARM_VARIANT,             \
17503     THUMB_VARIANT, do_##enc, do_##enc }
17504
17505 #define NCE(mnem, op, nops, ops, enc)                                   \
17506    NCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
17507
17508 #define NCEF(mnem, op, nops, ops, enc)                                  \
17509     NCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
17510
17511 /* Neon insn with conditional suffix for the ARM version, overloaded types.  */
17512 #define nCE_tag(mnem, op, nops, ops, enc, tag)                          \
17513   { #mnem, OPS##nops ops, tag, N_MNEM##op, N_MNEM##op,          \
17514     ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
17515
17516 #define nCE(mnem, op, nops, ops, enc)                                   \
17517    nCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
17518
17519 #define nCEF(mnem, op, nops, ops, enc)                                  \
17520     nCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
17521
17522 #define do_0 0
17523
17524 static const struct asm_opcode insns[] =
17525 {
17526 #define ARM_VARIANT &arm_ext_v1 /* Core ARM Instructions.  */
17527 #define THUMB_VARIANT &arm_ext_v4t
17528  tCE("and",     0000000, _and,     3, (RR, oRR, SH), arit, t_arit3c),
17529  tC3("ands",    0100000, _ands,    3, (RR, oRR, SH), arit, t_arit3c),
17530  tCE("eor",     0200000, _eor,     3, (RR, oRR, SH), arit, t_arit3c),
17531  tC3("eors",    0300000, _eors,    3, (RR, oRR, SH), arit, t_arit3c),
17532  tCE("sub",     0400000, _sub,     3, (RR, oRR, SH), arit, t_add_sub),
17533  tC3("subs",    0500000, _subs,    3, (RR, oRR, SH), arit, t_add_sub),
17534  tCE("add",     0800000, _add,     3, (RR, oRR, SHG), arit, t_add_sub),
17535  tC3("adds",    0900000, _adds,    3, (RR, oRR, SHG), arit, t_add_sub),
17536  tCE("adc",     0a00000, _adc,     3, (RR, oRR, SH), arit, t_arit3c),
17537  tC3("adcs",    0b00000, _adcs,    3, (RR, oRR, SH), arit, t_arit3c),
17538  tCE("sbc",     0c00000, _sbc,     3, (RR, oRR, SH), arit, t_arit3),
17539  tC3("sbcs",    0d00000, _sbcs,    3, (RR, oRR, SH), arit, t_arit3),
17540  tCE("orr",     1800000, _orr,     3, (RR, oRR, SH), arit, t_arit3c),
17541  tC3("orrs",    1900000, _orrs,    3, (RR, oRR, SH), arit, t_arit3c),
17542  tCE("bic",     1c00000, _bic,     3, (RR, oRR, SH), arit, t_arit3),
17543  tC3("bics",    1d00000, _bics,    3, (RR, oRR, SH), arit, t_arit3),
17544
17545  /* The p-variants of tst/cmp/cmn/teq (below) are the pre-V6 mechanism
17546     for setting PSR flag bits.  They are obsolete in V6 and do not
17547     have Thumb equivalents. */
17548  tCE("tst",     1100000, _tst,     2, (RR, SH),      cmp,  t_mvn_tst),
17549  tC3w("tsts",   1100000, _tst,     2, (RR, SH),      cmp,  t_mvn_tst),
17550   CL("tstp",    110f000,           2, (RR, SH),      cmp),
17551  tCE("cmp",     1500000, _cmp,     2, (RR, SH),      cmp,  t_mov_cmp),
17552  tC3w("cmps",   1500000, _cmp,     2, (RR, SH),      cmp,  t_mov_cmp),
17553   CL("cmpp",    150f000,           2, (RR, SH),      cmp),
17554  tCE("cmn",     1700000, _cmn,     2, (RR, SH),      cmp,  t_mvn_tst),
17555  tC3w("cmns",   1700000, _cmn,     2, (RR, SH),      cmp,  t_mvn_tst),
17556   CL("cmnp",    170f000,           2, (RR, SH),      cmp),
17557
17558  tCE("mov",     1a00000, _mov,     2, (RR, SH),      mov,  t_mov_cmp),
17559  tC3("movs",    1b00000, _movs,    2, (RR, SH),      mov,  t_mov_cmp),
17560  tCE("mvn",     1e00000, _mvn,     2, (RR, SH),      mov,  t_mvn_tst),
17561  tC3("mvns",    1f00000, _mvns,    2, (RR, SH),      mov,  t_mvn_tst),
17562
17563  tCE("ldr",     4100000, _ldr,     2, (RR, ADDRGLDR),ldst, t_ldst),
17564  tC3("ldrb",    4500000, _ldrb,    2, (RRnpc_npcsp, ADDRGLDR),ldst, t_ldst),
17565  tCE("str",     4000000, _str,     _2, (MIX_ARM_THUMB_OPERANDS (OP_RR,
17566                                                                 OP_RRnpc),
17567                                         OP_ADDRGLDR),ldst, t_ldst),
17568  tC3("strb",    4400000, _strb,    2, (RRnpc_npcsp, ADDRGLDR),ldst, t_ldst),
17569
17570  tCE("stm",     8800000, _stmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17571  tC3("stmia",   8800000, _stmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17572  tC3("stmea",   8800000, _stmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17573  tCE("ldm",     8900000, _ldmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17574  tC3("ldmia",   8900000, _ldmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17575  tC3("ldmfd",   8900000, _ldmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17576
17577  TCE("swi",     f000000, df00,     1, (EXPi),        swi, t_swi),
17578  TCE("svc",     f000000, df00,     1, (EXPi),        swi, t_swi),
17579  tCE("b",       a000000, _b,       1, (EXPr),        branch, t_branch),
17580  TCE("bl",      b000000, f000f800, 1, (EXPr),        bl, t_branch23),
17581
17582   /* Pseudo ops.  */
17583  tCE("adr",     28f0000, _adr,     2, (RR, EXP),     adr,  t_adr),
17584   C3(adrl,      28f0000,           2, (RR, EXP),     adrl),
17585  tCE("nop",     1a00000, _nop,     1, (oI255c),      nop,  t_nop),
17586
17587   /* Thumb-compatibility pseudo ops.  */
17588  tCE("lsl",     1a00000, _lsl,     3, (RR, oRR, SH), shift, t_shift),
17589  tC3("lsls",    1b00000, _lsls,    3, (RR, oRR, SH), shift, t_shift),
17590  tCE("lsr",     1a00020, _lsr,     3, (RR, oRR, SH), shift, t_shift),
17591  tC3("lsrs",    1b00020, _lsrs,    3, (RR, oRR, SH), shift, t_shift),
17592  tCE("asr",     1a00040, _asr,     3, (RR, oRR, SH), shift, t_shift),
17593  tC3("asrs",      1b00040, _asrs,     3, (RR, oRR, SH), shift, t_shift),
17594  tCE("ror",     1a00060, _ror,     3, (RR, oRR, SH), shift, t_shift),
17595  tC3("rors",    1b00060, _rors,    3, (RR, oRR, SH), shift, t_shift),
17596  tCE("neg",     2600000, _neg,     2, (RR, RR),      rd_rn, t_neg),
17597  tC3("negs",    2700000, _negs,    2, (RR, RR),      rd_rn, t_neg),
17598  tCE("push",    92d0000, _push,     1, (REGLST),             push_pop, t_push_pop),
17599  tCE("pop",     8bd0000, _pop,     1, (REGLST),      push_pop, t_push_pop),
17600
17601  /* These may simplify to neg.  */
17602  TCE("rsb",     0600000, ebc00000, 3, (RR, oRR, SH), arit, t_rsb),
17603  TC3("rsbs",    0700000, ebd00000, 3, (RR, oRR, SH), arit, t_rsb),
17604
17605 #undef  THUMB_VARIANT
17606 #define THUMB_VARIANT  & arm_ext_v6
17607
17608  TCE("cpy",       1a00000, 4600,     2, (RR, RR),      rd_rm, t_cpy),
17609
17610  /* V1 instructions with no Thumb analogue prior to V6T2.  */
17611 #undef  THUMB_VARIANT
17612 #define THUMB_VARIANT  & arm_ext_v6t2
17613
17614  TCE("teq",     1300000, ea900f00, 2, (RR, SH),      cmp,  t_mvn_tst),
17615  TC3w("teqs",   1300000, ea900f00, 2, (RR, SH),      cmp,  t_mvn_tst),
17616   CL("teqp",    130f000,           2, (RR, SH),      cmp),
17617
17618  TC3("ldrt",    4300000, f8500e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
17619  TC3("ldrbt",   4700000, f8100e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
17620  TC3("strt",    4200000, f8400e00, 2, (RR_npcsp, ADDR),   ldstt, t_ldstt),
17621  TC3("strbt",   4600000, f8000e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
17622
17623  TC3("stmdb",   9000000, e9000000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
17624  TC3("stmfd",     9000000, e9000000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
17625
17626  TC3("ldmdb",   9100000, e9100000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
17627  TC3("ldmea",   9100000, e9100000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
17628
17629  /* V1 instructions with no Thumb analogue at all.  */
17630   CE("rsc",     0e00000,           3, (RR, oRR, SH), arit),
17631   C3(rscs,      0f00000,           3, (RR, oRR, SH), arit),
17632
17633   C3(stmib,     9800000,           2, (RRw, REGLST), ldmstm),
17634   C3(stmfa,     9800000,           2, (RRw, REGLST), ldmstm),
17635   C3(stmda,     8000000,           2, (RRw, REGLST), ldmstm),
17636   C3(stmed,     8000000,           2, (RRw, REGLST), ldmstm),
17637   C3(ldmib,     9900000,           2, (RRw, REGLST), ldmstm),
17638   C3(ldmed,     9900000,           2, (RRw, REGLST), ldmstm),
17639   C3(ldmda,     8100000,           2, (RRw, REGLST), ldmstm),
17640   C3(ldmfa,     8100000,           2, (RRw, REGLST), ldmstm),
17641
17642 #undef  ARM_VARIANT
17643 #define ARM_VARIANT    & arm_ext_v2     /* ARM 2 - multiplies.  */
17644 #undef  THUMB_VARIANT
17645 #define THUMB_VARIANT  & arm_ext_v4t
17646
17647  tCE("mul",     0000090, _mul,     3, (RRnpc, RRnpc, oRR), mul, t_mul),
17648  tC3("muls",    0100090, _muls,    3, (RRnpc, RRnpc, oRR), mul, t_mul),
17649
17650 #undef  THUMB_VARIANT
17651 #define THUMB_VARIANT  & arm_ext_v6t2
17652
17653  TCE("mla",     0200090, fb000000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas, t_mla),
17654   C3(mlas,      0300090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas),
17655
17656   /* Generic coprocessor instructions.  */
17657  TCE("cdp",     e000000, ee000000, 6, (RCP, I15b, RCN, RCN, RCN, oI7b), cdp,    cdp),
17658  TCE("ldc",     c100000, ec100000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17659  TC3("ldcl",    c500000, ec500000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17660  TCE("stc",     c000000, ec000000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17661  TC3("stcl",    c400000, ec400000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17662  TCE("mcr",     e000010, ee000010, 6, (RCP, I7b, RR, RCN, RCN, oI7b),   co_reg, co_reg),
17663  TCE("mrc",     e100010, ee100010, 6, (RCP, I7b, APSR_RR, RCN, RCN, oI7b),   co_reg, co_reg),
17664
17665 #undef  ARM_VARIANT
17666 #define ARM_VARIANT  & arm_ext_v2s /* ARM 3 - swp instructions.  */
17667
17668   CE("swp",     1000090,           3, (RRnpc, RRnpc, RRnpcb), rd_rm_rn),
17669   C3(swpb,      1400090,           3, (RRnpc, RRnpc, RRnpcb), rd_rm_rn),
17670
17671 #undef  ARM_VARIANT
17672 #define ARM_VARIANT    & arm_ext_v3     /* ARM 6 Status register instructions.  */
17673 #undef  THUMB_VARIANT
17674 #define THUMB_VARIANT  & arm_ext_msr
17675
17676  TCE("mrs",     1000000, f3e08000, 2, (RRnpc, rPSR), mrs, t_mrs),
17677  TCE("msr",     120f000, f3808000, 2, (wPSR, RR_EXi), msr, t_msr),
17678
17679 #undef  ARM_VARIANT
17680 #define ARM_VARIANT    & arm_ext_v3m     /* ARM 7M long multiplies.  */
17681 #undef  THUMB_VARIANT
17682 #define THUMB_VARIANT  & arm_ext_v6t2
17683
17684  TCE("smull",   0c00090, fb800000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
17685   CM("smull","s",       0d00090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
17686  TCE("umull",   0800090, fba00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
17687   CM("umull","s",       0900090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
17688  TCE("smlal",   0e00090, fbc00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
17689   CM("smlal","s",       0f00090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
17690  TCE("umlal",   0a00090, fbe00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
17691   CM("umlal","s",       0b00090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
17692
17693 #undef  ARM_VARIANT
17694 #define ARM_VARIANT    & arm_ext_v4     /* ARM Architecture 4.  */
17695 #undef  THUMB_VARIANT
17696 #define THUMB_VARIANT  & arm_ext_v4t
17697
17698  tC3("ldrh",    01000b0, _ldrh,     2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17699  tC3("strh",    00000b0, _strh,     2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17700  tC3("ldrsh",   01000f0, _ldrsh,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17701  tC3("ldrsb",   01000d0, _ldrsb,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17702  tCM("ld","sh", 01000f0, _ldrsh,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17703  tCM("ld","sb", 01000d0, _ldrsb,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17704
17705 #undef  ARM_VARIANT
17706 #define ARM_VARIANT  & arm_ext_v4t_5
17707
17708   /* ARM Architecture 4T.  */
17709   /* Note: bx (and blx) are required on V5, even if the processor does
17710      not support Thumb.  */
17711  TCE("bx",      12fff10, 4700, 1, (RR), bx, t_bx),
17712
17713 #undef  ARM_VARIANT
17714 #define ARM_VARIANT    & arm_ext_v5 /*  ARM Architecture 5T.     */
17715 #undef  THUMB_VARIANT
17716 #define THUMB_VARIANT  & arm_ext_v5t
17717
17718   /* Note: blx has 2 variants; the .value coded here is for
17719      BLX(2).  Only this variant has conditional execution.  */
17720  TCE("blx",     12fff30, 4780, 1, (RR_EXr),                         blx,  t_blx),
17721  TUE("bkpt",    1200070, be00, 1, (oIffffb),                        bkpt, t_bkpt),
17722
17723 #undef  THUMB_VARIANT
17724 #define THUMB_VARIANT  & arm_ext_v6t2
17725
17726  TCE("clz",     16f0f10, fab0f080, 2, (RRnpc, RRnpc),                   rd_rm,  t_clz),
17727  TUF("ldc2",    c100000, fc100000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17728  TUF("ldc2l",   c500000, fc500000, 3, (RCP, RCN, ADDRGLDC),                     lstc,   lstc),
17729  TUF("stc2",    c000000, fc000000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17730  TUF("stc2l",   c400000, fc400000, 3, (RCP, RCN, ADDRGLDC),                     lstc,   lstc),
17731  TUF("cdp2",    e000000, fe000000, 6, (RCP, I15b, RCN, RCN, RCN, oI7b), cdp,    cdp),
17732  TUF("mcr2",    e000010, fe000010, 6, (RCP, I7b, RR, RCN, RCN, oI7b),   co_reg, co_reg),
17733  TUF("mrc2",    e100010, fe100010, 6, (RCP, I7b, RR, RCN, RCN, oI7b),   co_reg, co_reg),
17734
17735 #undef  ARM_VARIANT
17736 #define ARM_VARIANT  & arm_ext_v5exp /*  ARM Architecture 5TExP.  */
17737 #undef THUMB_VARIANT
17738 #define THUMB_VARIANT &arm_ext_v5exp
17739
17740  TCE("smlabb",  1000080, fb100000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
17741  TCE("smlatb",  10000a0, fb100020, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
17742  TCE("smlabt",  10000c0, fb100010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
17743  TCE("smlatt",  10000e0, fb100030, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
17744
17745  TCE("smlawb",  1200080, fb300000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
17746  TCE("smlawt",  12000c0, fb300010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
17747
17748  TCE("smlalbb", 1400080, fbc00080, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
17749  TCE("smlaltb", 14000a0, fbc000a0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
17750  TCE("smlalbt", 14000c0, fbc00090, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
17751  TCE("smlaltt", 14000e0, fbc000b0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
17752
17753  TCE("smulbb",  1600080, fb10f000, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
17754  TCE("smultb",  16000a0, fb10f020, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
17755  TCE("smulbt",  16000c0, fb10f010, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
17756  TCE("smultt",  16000e0, fb10f030, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
17757
17758  TCE("smulwb",  12000a0, fb30f000, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
17759  TCE("smulwt",  12000e0, fb30f010, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
17760
17761  TCE("qadd",    1000050, fa80f080, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
17762  TCE("qdadd",   1400050, fa80f090, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
17763  TCE("qsub",    1200050, fa80f0a0, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
17764  TCE("qdsub",   1600050, fa80f0b0, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
17765
17766 #undef  ARM_VARIANT
17767 #define ARM_VARIANT  & arm_ext_v5e /*  ARM Architecture 5TE.  */
17768 #undef THUMB_VARIANT
17769 #define THUMB_VARIANT &arm_ext_v6t2
17770
17771  TUF("pld",     450f000, f810f000, 1, (ADDR),                pld,  t_pld),
17772  TC3("ldrd",    00000d0, e8500000, 3, (RRnpc_npcsp, oRRnpc_npcsp, ADDRGLDRS),
17773      ldrd, t_ldstd),
17774  TC3("strd",    00000f0, e8400000, 3, (RRnpc_npcsp, oRRnpc_npcsp,
17775                                        ADDRGLDRS), ldrd, t_ldstd),
17776
17777  TCE("mcrr",    c400000, ec400000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
17778  TCE("mrrc",    c500000, ec500000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
17779
17780 #undef  ARM_VARIANT
17781 #define ARM_VARIANT  & arm_ext_v5j /*  ARM Architecture 5TEJ.  */
17782
17783  TCE("bxj",     12fff20, f3c08f00, 1, (RR),                       bxj, t_bxj),
17784
17785 #undef  ARM_VARIANT
17786 #define ARM_VARIANT    & arm_ext_v6 /*  ARM V6.  */
17787 #undef  THUMB_VARIANT
17788 #define THUMB_VARIANT  & arm_ext_v6
17789
17790  TUF("cpsie",     1080000, b660,     2, (CPSF, oI31b),              cpsi,   t_cpsi),
17791  TUF("cpsid",     10c0000, b670,     2, (CPSF, oI31b),              cpsi,   t_cpsi),
17792  tCE("rev",       6bf0f30, _rev,      2, (RRnpc, RRnpc),             rd_rm,  t_rev),
17793  tCE("rev16",     6bf0fb0, _rev16,    2, (RRnpc, RRnpc),             rd_rm,  t_rev),
17794  tCE("revsh",     6ff0fb0, _revsh,    2, (RRnpc, RRnpc),             rd_rm,  t_rev),
17795  tCE("sxth",      6bf0070, _sxth,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
17796  tCE("uxth",      6ff0070, _uxth,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
17797  tCE("sxtb",      6af0070, _sxtb,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
17798  tCE("uxtb",      6ef0070, _uxtb,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
17799  TUF("setend",    1010000, b650,     1, (ENDI),                     setend, t_setend),
17800
17801 #undef  THUMB_VARIANT
17802 #define THUMB_VARIANT  & arm_ext_v6t2
17803
17804  TCE("ldrex",   1900f9f, e8500f00, 2, (RRnpc_npcsp, ADDR),        ldrex, t_ldrex),
17805  TCE("strex",   1800f90, e8400000, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
17806                                       strex,  t_strex),
17807  TUF("mcrr2",   c400000, fc400000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
17808  TUF("mrrc2",   c500000, fc500000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
17809
17810  TCE("ssat",    6a00010, f3000000, 4, (RRnpc, I32, RRnpc, oSHllar),ssat,   t_ssat),
17811  TCE("usat",    6e00010, f3800000, 4, (RRnpc, I31, RRnpc, oSHllar),usat,   t_usat),
17812
17813 /*  ARM V6 not included in V7M.  */
17814 #undef  THUMB_VARIANT
17815 #define THUMB_VARIANT  & arm_ext_v6_notm
17816  TUF("rfeia",   8900a00, e990c000, 1, (RRw),                       rfe, rfe),
17817   UF(rfeib,     9900a00,           1, (RRw),                       rfe),
17818   UF(rfeda,     8100a00,           1, (RRw),                       rfe),
17819  TUF("rfedb",   9100a00, e810c000, 1, (RRw),                       rfe, rfe),
17820  TUF("rfefd",   8900a00, e990c000, 1, (RRw),                       rfe, rfe),
17821   UF(rfefa,     9900a00,           1, (RRw),                       rfe),
17822   UF(rfeea,     8100a00,           1, (RRw),                       rfe),
17823  TUF("rfeed",   9100a00, e810c000, 1, (RRw),                       rfe, rfe),
17824  TUF("srsia",   8c00500, e980c000, 2, (oRRw, I31w),                srs,  srs),
17825   UF(srsib,     9c00500,           2, (oRRw, I31w),                srs),
17826   UF(srsda,     8400500,           2, (oRRw, I31w),                srs),
17827  TUF("srsdb",   9400500, e800c000, 2, (oRRw, I31w),                srs,  srs),
17828
17829 /*  ARM V6 not included in V7M (eg. integer SIMD).  */
17830 #undef  THUMB_VARIANT
17831 #define THUMB_VARIANT  & arm_ext_v6_dsp
17832  TUF("cps",     1020000, f3af8100, 1, (I31b),                     imm0, t_cps),
17833  TCE("pkhbt",   6800010, eac00000, 4, (RRnpc, RRnpc, RRnpc, oSHll),   pkhbt, t_pkhbt),
17834  TCE("pkhtb",   6800050, eac00020, 4, (RRnpc, RRnpc, RRnpc, oSHar),   pkhtb, t_pkhtb),
17835  TCE("qadd16",  6200f10, fa90f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17836  TCE("qadd8",   6200f90, fa80f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17837  TCE("qasx",    6200f30, faa0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17838  /* Old name for QASX.  */
17839  TCE("qaddsubx",        6200f30, faa0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17840  TCE("qsax",    6200f50, fae0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17841  /* Old name for QSAX.  */
17842  TCE("qsubaddx",        6200f50, fae0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17843  TCE("qsub16",  6200f70, fad0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17844  TCE("qsub8",   6200ff0, fac0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17845  TCE("sadd16",  6100f10, fa90f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17846  TCE("sadd8",   6100f90, fa80f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17847  TCE("sasx",    6100f30, faa0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17848  /* Old name for SASX.  */
17849  TCE("saddsubx",        6100f30, faa0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17850  TCE("shadd16", 6300f10, fa90f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17851  TCE("shadd8",  6300f90, fa80f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17852  TCE("shasx",     6300f30, faa0f020, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17853  /* Old name for SHASX.  */
17854  TCE("shaddsubx", 6300f30, faa0f020, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17855  TCE("shsax",      6300f50, fae0f020, 3, (RRnpc, RRnpc, RRnpc),    rd_rn_rm, t_simd),
17856  /* Old name for SHSAX.  */
17857  TCE("shsubaddx", 6300f50, fae0f020, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17858  TCE("shsub16", 6300f70, fad0f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17859  TCE("shsub8",  6300ff0, fac0f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17860  TCE("ssax",    6100f50, fae0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17861  /* Old name for SSAX.  */
17862  TCE("ssubaddx",        6100f50, fae0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17863  TCE("ssub16",  6100f70, fad0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17864  TCE("ssub8",   6100ff0, fac0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17865  TCE("uadd16",  6500f10, fa90f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17866  TCE("uadd8",   6500f90, fa80f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17867  TCE("uasx",    6500f30, faa0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17868  /* Old name for UASX.  */
17869  TCE("uaddsubx",        6500f30, faa0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17870  TCE("uhadd16", 6700f10, fa90f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17871  TCE("uhadd8",  6700f90, fa80f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17872  TCE("uhasx",     6700f30, faa0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17873  /* Old name for UHASX.  */
17874  TCE("uhaddsubx", 6700f30, faa0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17875  TCE("uhsax",     6700f50, fae0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17876  /* Old name for UHSAX.  */
17877  TCE("uhsubaddx", 6700f50, fae0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17878  TCE("uhsub16", 6700f70, fad0f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17879  TCE("uhsub8",  6700ff0, fac0f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17880  TCE("uqadd16", 6600f10, fa90f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17881  TCE("uqadd8",  6600f90, fa80f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17882  TCE("uqasx",     6600f30, faa0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17883  /* Old name for UQASX.  */
17884  TCE("uqaddsubx", 6600f30, faa0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17885  TCE("uqsax",     6600f50, fae0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17886  /* Old name for UQSAX.  */
17887  TCE("uqsubaddx", 6600f50, fae0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
17888  TCE("uqsub16", 6600f70, fad0f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17889  TCE("uqsub8",  6600ff0, fac0f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17890  TCE("usub16",  6500f70, fad0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17891  TCE("usax",    6500f50, fae0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17892  /* Old name for USAX.  */
17893  TCE("usubaddx",        6500f50, fae0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17894  TCE("usub8",   6500ff0, fac0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17895  TCE("sxtah",   6b00070, fa00f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
17896  TCE("sxtab16", 6800070, fa20f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
17897  TCE("sxtab",   6a00070, fa40f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
17898  TCE("sxtb16",  68f0070, fa2ff080, 3, (RRnpc, RRnpc, oROR),        sxth,  t_sxth),
17899  TCE("uxtah",   6f00070, fa10f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
17900  TCE("uxtab16", 6c00070, fa30f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
17901  TCE("uxtab",   6e00070, fa50f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
17902  TCE("uxtb16",  6cf0070, fa3ff080, 3, (RRnpc, RRnpc, oROR),        sxth,  t_sxth),
17903  TCE("sel",     6800fb0, faa0f080, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
17904  TCE("smlad",   7000010, fb200000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
17905  TCE("smladx",  7000030, fb200010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
17906  TCE("smlald",  7400010, fbc000c0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
17907  TCE("smlaldx", 7400030, fbc000d0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
17908  TCE("smlsd",   7000050, fb400000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
17909  TCE("smlsdx",  7000070, fb400010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
17910  TCE("smlsld",  7400050, fbd000c0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
17911  TCE("smlsldx", 7400070, fbd000d0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
17912  TCE("smmla",   7500010, fb500000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
17913  TCE("smmlar",  7500030, fb500010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
17914  TCE("smmls",   75000d0, fb600000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
17915  TCE("smmlsr",  75000f0, fb600010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
17916  TCE("smmul",   750f010, fb50f000, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
17917  TCE("smmulr",  750f030, fb50f010, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
17918  TCE("smuad",   700f010, fb20f000, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
17919  TCE("smuadx",  700f030, fb20f010, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
17920  TCE("smusd",   700f050, fb40f000, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
17921  TCE("smusdx",  700f070, fb40f010, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
17922  TCE("ssat16",  6a00f30, f3200000, 3, (RRnpc, I16, RRnpc),         ssat16, t_ssat16),
17923  TCE("umaal",   0400090, fbe00060, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,  t_mlal),
17924  TCE("usad8",   780f010, fb70f000, 3, (RRnpc, RRnpc, RRnpc),       smul,   t_simd),
17925  TCE("usada8",  7800010, fb700000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla,   t_mla),
17926  TCE("usat16",  6e00f30, f3a00000, 3, (RRnpc, I15, RRnpc),         usat16, t_usat16),
17927
17928 #undef  ARM_VARIANT
17929 #define ARM_VARIANT   & arm_ext_v6k
17930 #undef  THUMB_VARIANT
17931 #define THUMB_VARIANT & arm_ext_v6k
17932
17933  tCE("yield",   320f001, _yield,    0, (), noargs, t_hint),
17934  tCE("wfe",     320f002, _wfe,      0, (), noargs, t_hint),
17935  tCE("wfi",     320f003, _wfi,      0, (), noargs, t_hint),
17936  tCE("sev",     320f004, _sev,      0, (), noargs, t_hint),
17937
17938 #undef  THUMB_VARIANT
17939 #define THUMB_VARIANT  & arm_ext_v6_notm
17940  TCE("ldrexd",  1b00f9f, e8d0007f, 3, (RRnpc_npcsp, oRRnpc_npcsp, RRnpcb),
17941                                       ldrexd, t_ldrexd),
17942  TCE("strexd",  1a00f90, e8c00070, 4, (RRnpc_npcsp, RRnpc_npcsp, oRRnpc_npcsp,
17943                                        RRnpcb), strexd, t_strexd),
17944
17945 #undef  THUMB_VARIANT
17946 #define THUMB_VARIANT  & arm_ext_v6t2
17947  TCE("ldrexb",  1d00f9f, e8d00f4f, 2, (RRnpc_npcsp,RRnpcb),
17948      rd_rn,  rd_rn),
17949  TCE("ldrexh",  1f00f9f, e8d00f5f, 2, (RRnpc_npcsp, RRnpcb),
17950      rd_rn,  rd_rn),
17951  TCE("strexb",  1c00f90, e8c00f40, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
17952      strex, t_strexbh),
17953  TCE("strexh",  1e00f90, e8c00f50, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
17954      strex, t_strexbh),
17955  TUF("clrex",   57ff01f, f3bf8f2f, 0, (),                             noargs, noargs),
17956
17957 #undef  ARM_VARIANT
17958 #define ARM_VARIANT    & arm_ext_sec
17959 #undef THUMB_VARIANT
17960 #define THUMB_VARIANT  & arm_ext_sec
17961
17962  TCE("smc",     1600070, f7f08000, 1, (EXPi), smc, t_smc),
17963
17964 #undef  ARM_VARIANT
17965 #define ARM_VARIANT    & arm_ext_virt
17966 #undef  THUMB_VARIANT
17967 #define THUMB_VARIANT    & arm_ext_virt
17968
17969  TCE("hvc",     1400070, f7e08000, 1, (EXPi), hvc, t_hvc),
17970  TCE("eret",    160006e, f3de8f00, 0, (), noargs, noargs),
17971
17972 #undef  ARM_VARIANT
17973 #define ARM_VARIANT  & arm_ext_v6t2
17974 #undef  THUMB_VARIANT
17975 #define THUMB_VARIANT  & arm_ext_v6t2
17976
17977  TCE("bfc",     7c0001f, f36f0000, 3, (RRnpc, I31, I32),           bfc, t_bfc),
17978  TCE("bfi",     7c00010, f3600000, 4, (RRnpc, RRnpc_I0, I31, I32), bfi, t_bfi),
17979  TCE("sbfx",    7a00050, f3400000, 4, (RR, RR, I31, I32),          bfx, t_bfx),
17980  TCE("ubfx",    7e00050, f3c00000, 4, (RR, RR, I31, I32),          bfx, t_bfx),
17981
17982  TCE("mls",     0600090, fb000010, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas, t_mla),
17983  TCE("movw",    3000000, f2400000, 2, (RRnpc, HALF),                mov16, t_mov16),
17984  TCE("movt",    3400000, f2c00000, 2, (RRnpc, HALF),                mov16, t_mov16),
17985  TCE("rbit",    6ff0f30, fa90f0a0, 2, (RR, RR),                     rd_rm, t_rbit),
17986
17987  TC3("ldrht",   03000b0, f8300e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
17988  TC3("ldrsht",  03000f0, f9300e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
17989  TC3("ldrsbt",  03000d0, f9100e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
17990  TC3("strht",   02000b0, f8200e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
17991
17992  /* Thumb-only instructions.  */
17993 #undef ARM_VARIANT
17994 #define ARM_VARIANT NULL
17995   TUE("cbnz",     0,           b900,     2, (RR, EXP), 0, t_cbz),
17996   TUE("cbz",      0,           b100,     2, (RR, EXP), 0, t_cbz),
17997
17998  /* ARM does not really have an IT instruction, so always allow it.
17999     The opcode is copied from Thumb in order to allow warnings in
18000     -mimplicit-it=[never | arm] modes.  */
18001 #undef  ARM_VARIANT
18002 #define ARM_VARIANT  & arm_ext_v1
18003
18004  TUE("it",        bf08,        bf08,     1, (COND),   it,    t_it),
18005  TUE("itt",       bf0c,        bf0c,     1, (COND),   it,    t_it),
18006  TUE("ite",       bf04,        bf04,     1, (COND),   it,    t_it),
18007  TUE("ittt",      bf0e,        bf0e,     1, (COND),   it,    t_it),
18008  TUE("itet",      bf06,        bf06,     1, (COND),   it,    t_it),
18009  TUE("itte",      bf0a,        bf0a,     1, (COND),   it,    t_it),
18010  TUE("itee",      bf02,        bf02,     1, (COND),   it,    t_it),
18011  TUE("itttt",     bf0f,        bf0f,     1, (COND),   it,    t_it),
18012  TUE("itett",     bf07,        bf07,     1, (COND),   it,    t_it),
18013  TUE("ittet",     bf0b,        bf0b,     1, (COND),   it,    t_it),
18014  TUE("iteet",     bf03,        bf03,     1, (COND),   it,    t_it),
18015  TUE("ittte",     bf0d,        bf0d,     1, (COND),   it,    t_it),
18016  TUE("itete",     bf05,        bf05,     1, (COND),   it,    t_it),
18017  TUE("ittee",     bf09,        bf09,     1, (COND),   it,    t_it),
18018  TUE("iteee",     bf01,        bf01,     1, (COND),   it,    t_it),
18019  /* ARM/Thumb-2 instructions with no Thumb-1 equivalent.  */
18020  TC3("rrx",       01a00060, ea4f0030, 2, (RR, RR), rd_rm, t_rrx),
18021  TC3("rrxs",      01b00060, ea5f0030, 2, (RR, RR), rd_rm, t_rrx),
18022
18023  /* Thumb2 only instructions.  */
18024 #undef  ARM_VARIANT
18025 #define ARM_VARIANT  NULL
18026
18027  TCE("addw",    0, f2000000, 3, (RR, RR, EXPi), 0, t_add_sub_w),
18028  TCE("subw",    0, f2a00000, 3, (RR, RR, EXPi), 0, t_add_sub_w),
18029  TCE("orn",       0, ea600000, 3, (RR, oRR, SH),  0, t_orn),
18030  TCE("orns",      0, ea700000, 3, (RR, oRR, SH),  0, t_orn),
18031  TCE("tbb",       0, e8d0f000, 1, (TB), 0, t_tb),
18032  TCE("tbh",       0, e8d0f010, 1, (TB), 0, t_tb),
18033
18034  /* Hardware division instructions.  */
18035 #undef  ARM_VARIANT
18036 #define ARM_VARIANT    & arm_ext_adiv
18037 #undef  THUMB_VARIANT
18038 #define THUMB_VARIANT  & arm_ext_div
18039
18040  TCE("sdiv",    710f010, fb90f0f0, 3, (RR, oRR, RR), div, t_div),
18041  TCE("udiv",    730f010, fbb0f0f0, 3, (RR, oRR, RR), div, t_div),
18042
18043  /* ARM V6M/V7 instructions.  */
18044 #undef  ARM_VARIANT
18045 #define ARM_VARIANT    & arm_ext_barrier
18046 #undef  THUMB_VARIANT
18047 #define THUMB_VARIANT  & arm_ext_barrier
18048
18049  TUF("dmb",     57ff050, f3bf8f50, 1, (oBARRIER_I15), barrier,  t_barrier),
18050  TUF("dsb",     57ff040, f3bf8f40, 1, (oBARRIER_I15), barrier,  t_barrier),
18051  TUF("isb",     57ff060, f3bf8f60, 1, (oBARRIER_I15), barrier,  t_barrier),
18052
18053  /* ARM V7 instructions.  */
18054 #undef  ARM_VARIANT
18055 #define ARM_VARIANT    & arm_ext_v7
18056 #undef  THUMB_VARIANT
18057 #define THUMB_VARIANT  & arm_ext_v7
18058
18059  TUF("pli",     450f000, f910f000, 1, (ADDR),     pli,      t_pld),
18060  TCE("dbg",     320f0f0, f3af80f0, 1, (I15),      dbg,      t_dbg),
18061
18062 #undef ARM_VARIANT
18063 #define ARM_VARIANT    & arm_ext_mp
18064 #undef THUMB_VARIANT
18065 #define THUMB_VARIANT  & arm_ext_mp
18066
18067  TUF("pldw",    410f000, f830f000, 1, (ADDR),   pld,    t_pld),
18068
18069  /* AArchv8 instructions.  */
18070 #undef  ARM_VARIANT
18071 #define ARM_VARIANT   & arm_ext_v8
18072 #undef  THUMB_VARIANT
18073 #define THUMB_VARIANT & arm_ext_v8
18074
18075  tCE("sevl",    320f005, _sevl,    0, (),               noargs, t_hint),
18076  TUE("hlt",     1000070, ba80,     1, (oIffffb),        bkpt,   t_hlt),
18077  TCE("ldraex",  1900e9f, e8d00fef, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
18078  TCE("ldraexd", 1b00e9f, e8d000ff, 3, (RRnpc, oRRnpc, RRnpcb),
18079                                                         ldrexd, t_ldrexd),
18080  TCE("ldraexb", 1d00e9f, e8d00fcf, 2, (RRnpc,RRnpcb),   rd_rn,  rd_rn),
18081  TCE("ldraexh", 1f00e9f, e8d00fdf, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
18082  TCE("strlex",  1800e90, e8c00fe0, 3, (RRnpc, RRnpc, RRnpcb),
18083                                                         strlex,  t_strlex),
18084  TCE("strlexd", 1a00e90, e8c000f0, 4, (RRnpc, RRnpc, oRRnpc, RRnpcb),
18085                                                         strexd, t_strexd),
18086  TCE("strlexb", 1c00e90, e8c00fc0, 3, (RRnpc, RRnpc, RRnpcb),
18087                                                         strlex, t_strlex),
18088  TCE("strlexh", 1e00e90, e8c00fd0, 3, (RRnpc, RRnpc, RRnpcb),
18089                                                         strlex, t_strlex),
18090  TCE("ldra",    1900c9f, e8d00faf, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
18091  TCE("ldrab",   1d00c9f, e8d00f8f, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
18092  TCE("ldrah",   1f00c9f, e8d00f9f, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
18093  TCE("strl",    180fc90, e8c00faf, 2, (RRnpc, RRnpcb),  rm_rn,  rd_rn),
18094  TCE("strlb",   1c0fc90, e8c00f8f, 2, (RRnpc, RRnpcb),  rm_rn,  rd_rn),
18095  TCE("strlh",   1e0fc90, e8c00f9f, 2, (RRnpc, RRnpcb),  rm_rn,  rd_rn),
18096
18097  /* ARMv8 T32 only.  */
18098 #undef ARM_VARIANT
18099 #define ARM_VARIANT  NULL
18100  TUF("dcps1",   0,       f78f8001, 0, (),       noargs, noargs),
18101  TUF("dcps2",   0,       f78f8002, 0, (),       noargs, noargs),
18102  TUF("dcps3",   0,       f78f8003, 0, (),       noargs, noargs),
18103
18104   /* FP for ARMv8.  */
18105 #undef  ARM_VARIANT
18106 #define ARM_VARIANT & fpu_vfp_ext_armv8
18107 #undef  THUMB_VARIANT
18108 #define THUMB_VARIANT & fpu_vfp_ext_armv8
18109
18110   nUF(vseleq, _vseleq, 3, (RVSD, RVSD, RVSD),           vsel),
18111   nUF(vselvs, _vselvs, 3, (RVSD, RVSD, RVSD),           vsel),
18112   nUF(vselge, _vselge, 3, (RVSD, RVSD, RVSD),           vsel),
18113   nUF(vselgt, _vselgt, 3, (RVSD, RVSD, RVSD),           vsel),
18114   nUF(vmaxnm, _vmaxnm, 3, (RNSDQ, oRNSDQ, RNSDQ),       vmaxnm),
18115   nUF(vminnm, _vminnm, 3, (RNSDQ, oRNSDQ, RNSDQ),       vmaxnm),
18116
18117 #undef  ARM_VARIANT
18118 #define ARM_VARIANT  & fpu_fpa_ext_v1  /* Core FPA instruction set (V1).  */
18119 #undef  THUMB_VARIANT
18120 #define THUMB_VARIANT NULL
18121
18122  cCE("wfs",     e200110, 1, (RR),            rd),
18123  cCE("rfs",     e300110, 1, (RR),            rd),
18124  cCE("wfc",     e400110, 1, (RR),            rd),
18125  cCE("rfc",     e500110, 1, (RR),            rd),
18126
18127  cCL("ldfs",    c100100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18128  cCL("ldfd",    c108100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18129  cCL("ldfe",    c500100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18130  cCL("ldfp",    c508100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18131
18132  cCL("stfs",    c000100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18133  cCL("stfd",    c008100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18134  cCL("stfe",    c400100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18135  cCL("stfp",    c408100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18136
18137  cCL("mvfs",    e008100, 2, (RF, RF_IF),     rd_rm),
18138  cCL("mvfsp",   e008120, 2, (RF, RF_IF),     rd_rm),
18139  cCL("mvfsm",   e008140, 2, (RF, RF_IF),     rd_rm),
18140  cCL("mvfsz",   e008160, 2, (RF, RF_IF),     rd_rm),
18141  cCL("mvfd",    e008180, 2, (RF, RF_IF),     rd_rm),
18142  cCL("mvfdp",   e0081a0, 2, (RF, RF_IF),     rd_rm),
18143  cCL("mvfdm",   e0081c0, 2, (RF, RF_IF),     rd_rm),
18144  cCL("mvfdz",   e0081e0, 2, (RF, RF_IF),     rd_rm),
18145  cCL("mvfe",    e088100, 2, (RF, RF_IF),     rd_rm),
18146  cCL("mvfep",   e088120, 2, (RF, RF_IF),     rd_rm),
18147  cCL("mvfem",   e088140, 2, (RF, RF_IF),     rd_rm),
18148  cCL("mvfez",   e088160, 2, (RF, RF_IF),     rd_rm),
18149
18150  cCL("mnfs",    e108100, 2, (RF, RF_IF),     rd_rm),
18151  cCL("mnfsp",   e108120, 2, (RF, RF_IF),     rd_rm),
18152  cCL("mnfsm",   e108140, 2, (RF, RF_IF),     rd_rm),
18153  cCL("mnfsz",   e108160, 2, (RF, RF_IF),     rd_rm),
18154  cCL("mnfd",    e108180, 2, (RF, RF_IF),     rd_rm),
18155  cCL("mnfdp",   e1081a0, 2, (RF, RF_IF),     rd_rm),
18156  cCL("mnfdm",   e1081c0, 2, (RF, RF_IF),     rd_rm),
18157  cCL("mnfdz",   e1081e0, 2, (RF, RF_IF),     rd_rm),
18158  cCL("mnfe",    e188100, 2, (RF, RF_IF),     rd_rm),
18159  cCL("mnfep",   e188120, 2, (RF, RF_IF),     rd_rm),
18160  cCL("mnfem",   e188140, 2, (RF, RF_IF),     rd_rm),
18161  cCL("mnfez",   e188160, 2, (RF, RF_IF),     rd_rm),
18162
18163  cCL("abss",    e208100, 2, (RF, RF_IF),     rd_rm),
18164  cCL("abssp",   e208120, 2, (RF, RF_IF),     rd_rm),
18165  cCL("abssm",   e208140, 2, (RF, RF_IF),     rd_rm),
18166  cCL("abssz",   e208160, 2, (RF, RF_IF),     rd_rm),
18167  cCL("absd",    e208180, 2, (RF, RF_IF),     rd_rm),
18168  cCL("absdp",   e2081a0, 2, (RF, RF_IF),     rd_rm),
18169  cCL("absdm",   e2081c0, 2, (RF, RF_IF),     rd_rm),
18170  cCL("absdz",   e2081e0, 2, (RF, RF_IF),     rd_rm),
18171  cCL("abse",    e288100, 2, (RF, RF_IF),     rd_rm),
18172  cCL("absep",   e288120, 2, (RF, RF_IF),     rd_rm),
18173  cCL("absem",   e288140, 2, (RF, RF_IF),     rd_rm),
18174  cCL("absez",   e288160, 2, (RF, RF_IF),     rd_rm),
18175
18176  cCL("rnds",    e308100, 2, (RF, RF_IF),     rd_rm),
18177  cCL("rndsp",   e308120, 2, (RF, RF_IF),     rd_rm),
18178  cCL("rndsm",   e308140, 2, (RF, RF_IF),     rd_rm),
18179  cCL("rndsz",   e308160, 2, (RF, RF_IF),     rd_rm),
18180  cCL("rndd",    e308180, 2, (RF, RF_IF),     rd_rm),
18181  cCL("rnddp",   e3081a0, 2, (RF, RF_IF),     rd_rm),
18182  cCL("rnddm",   e3081c0, 2, (RF, RF_IF),     rd_rm),
18183  cCL("rnddz",   e3081e0, 2, (RF, RF_IF),     rd_rm),
18184  cCL("rnde",    e388100, 2, (RF, RF_IF),     rd_rm),
18185  cCL("rndep",   e388120, 2, (RF, RF_IF),     rd_rm),
18186  cCL("rndem",   e388140, 2, (RF, RF_IF),     rd_rm),
18187  cCL("rndez",   e388160, 2, (RF, RF_IF),     rd_rm),
18188
18189  cCL("sqts",    e408100, 2, (RF, RF_IF),     rd_rm),
18190  cCL("sqtsp",   e408120, 2, (RF, RF_IF),     rd_rm),
18191  cCL("sqtsm",   e408140, 2, (RF, RF_IF),     rd_rm),
18192  cCL("sqtsz",   e408160, 2, (RF, RF_IF),     rd_rm),
18193  cCL("sqtd",    e408180, 2, (RF, RF_IF),     rd_rm),
18194  cCL("sqtdp",   e4081a0, 2, (RF, RF_IF),     rd_rm),
18195  cCL("sqtdm",   e4081c0, 2, (RF, RF_IF),     rd_rm),
18196  cCL("sqtdz",   e4081e0, 2, (RF, RF_IF),     rd_rm),
18197  cCL("sqte",    e488100, 2, (RF, RF_IF),     rd_rm),
18198  cCL("sqtep",   e488120, 2, (RF, RF_IF),     rd_rm),
18199  cCL("sqtem",   e488140, 2, (RF, RF_IF),     rd_rm),
18200  cCL("sqtez",   e488160, 2, (RF, RF_IF),     rd_rm),
18201
18202  cCL("logs",    e508100, 2, (RF, RF_IF),     rd_rm),
18203  cCL("logsp",   e508120, 2, (RF, RF_IF),     rd_rm),
18204  cCL("logsm",   e508140, 2, (RF, RF_IF),     rd_rm),
18205  cCL("logsz",   e508160, 2, (RF, RF_IF),     rd_rm),
18206  cCL("logd",    e508180, 2, (RF, RF_IF),     rd_rm),
18207  cCL("logdp",   e5081a0, 2, (RF, RF_IF),     rd_rm),
18208  cCL("logdm",   e5081c0, 2, (RF, RF_IF),     rd_rm),
18209  cCL("logdz",   e5081e0, 2, (RF, RF_IF),     rd_rm),
18210  cCL("loge",    e588100, 2, (RF, RF_IF),     rd_rm),
18211  cCL("logep",   e588120, 2, (RF, RF_IF),     rd_rm),
18212  cCL("logem",   e588140, 2, (RF, RF_IF),     rd_rm),
18213  cCL("logez",   e588160, 2, (RF, RF_IF),     rd_rm),
18214
18215  cCL("lgns",    e608100, 2, (RF, RF_IF),     rd_rm),
18216  cCL("lgnsp",   e608120, 2, (RF, RF_IF),     rd_rm),
18217  cCL("lgnsm",   e608140, 2, (RF, RF_IF),     rd_rm),
18218  cCL("lgnsz",   e608160, 2, (RF, RF_IF),     rd_rm),
18219  cCL("lgnd",    e608180, 2, (RF, RF_IF),     rd_rm),
18220  cCL("lgndp",   e6081a0, 2, (RF, RF_IF),     rd_rm),
18221  cCL("lgndm",   e6081c0, 2, (RF, RF_IF),     rd_rm),
18222  cCL("lgndz",   e6081e0, 2, (RF, RF_IF),     rd_rm),
18223  cCL("lgne",    e688100, 2, (RF, RF_IF),     rd_rm),
18224  cCL("lgnep",   e688120, 2, (RF, RF_IF),     rd_rm),
18225  cCL("lgnem",   e688140, 2, (RF, RF_IF),     rd_rm),
18226  cCL("lgnez",   e688160, 2, (RF, RF_IF),     rd_rm),
18227
18228  cCL("exps",    e708100, 2, (RF, RF_IF),     rd_rm),
18229  cCL("expsp",   e708120, 2, (RF, RF_IF),     rd_rm),
18230  cCL("expsm",   e708140, 2, (RF, RF_IF),     rd_rm),
18231  cCL("expsz",   e708160, 2, (RF, RF_IF),     rd_rm),
18232  cCL("expd",    e708180, 2, (RF, RF_IF),     rd_rm),
18233  cCL("expdp",   e7081a0, 2, (RF, RF_IF),     rd_rm),
18234  cCL("expdm",   e7081c0, 2, (RF, RF_IF),     rd_rm),
18235  cCL("expdz",   e7081e0, 2, (RF, RF_IF),     rd_rm),
18236  cCL("expe",    e788100, 2, (RF, RF_IF),     rd_rm),
18237  cCL("expep",   e788120, 2, (RF, RF_IF),     rd_rm),
18238  cCL("expem",   e788140, 2, (RF, RF_IF),     rd_rm),
18239  cCL("expdz",   e788160, 2, (RF, RF_IF),     rd_rm),
18240
18241  cCL("sins",    e808100, 2, (RF, RF_IF),     rd_rm),
18242  cCL("sinsp",   e808120, 2, (RF, RF_IF),     rd_rm),
18243  cCL("sinsm",   e808140, 2, (RF, RF_IF),     rd_rm),
18244  cCL("sinsz",   e808160, 2, (RF, RF_IF),     rd_rm),
18245  cCL("sind",    e808180, 2, (RF, RF_IF),     rd_rm),
18246  cCL("sindp",   e8081a0, 2, (RF, RF_IF),     rd_rm),
18247  cCL("sindm",   e8081c0, 2, (RF, RF_IF),     rd_rm),
18248  cCL("sindz",   e8081e0, 2, (RF, RF_IF),     rd_rm),
18249  cCL("sine",    e888100, 2, (RF, RF_IF),     rd_rm),
18250  cCL("sinep",   e888120, 2, (RF, RF_IF),     rd_rm),
18251  cCL("sinem",   e888140, 2, (RF, RF_IF),     rd_rm),
18252  cCL("sinez",   e888160, 2, (RF, RF_IF),     rd_rm),
18253
18254  cCL("coss",    e908100, 2, (RF, RF_IF),     rd_rm),
18255  cCL("cossp",   e908120, 2, (RF, RF_IF),     rd_rm),
18256  cCL("cossm",   e908140, 2, (RF, RF_IF),     rd_rm),
18257  cCL("cossz",   e908160, 2, (RF, RF_IF),     rd_rm),
18258  cCL("cosd",    e908180, 2, (RF, RF_IF),     rd_rm),
18259  cCL("cosdp",   e9081a0, 2, (RF, RF_IF),     rd_rm),
18260  cCL("cosdm",   e9081c0, 2, (RF, RF_IF),     rd_rm),
18261  cCL("cosdz",   e9081e0, 2, (RF, RF_IF),     rd_rm),
18262  cCL("cose",    e988100, 2, (RF, RF_IF),     rd_rm),
18263  cCL("cosep",   e988120, 2, (RF, RF_IF),     rd_rm),
18264  cCL("cosem",   e988140, 2, (RF, RF_IF),     rd_rm),
18265  cCL("cosez",   e988160, 2, (RF, RF_IF),     rd_rm),
18266
18267  cCL("tans",    ea08100, 2, (RF, RF_IF),     rd_rm),
18268  cCL("tansp",   ea08120, 2, (RF, RF_IF),     rd_rm),
18269  cCL("tansm",   ea08140, 2, (RF, RF_IF),     rd_rm),
18270  cCL("tansz",   ea08160, 2, (RF, RF_IF),     rd_rm),
18271  cCL("tand",    ea08180, 2, (RF, RF_IF),     rd_rm),
18272  cCL("tandp",   ea081a0, 2, (RF, RF_IF),     rd_rm),
18273  cCL("tandm",   ea081c0, 2, (RF, RF_IF),     rd_rm),
18274  cCL("tandz",   ea081e0, 2, (RF, RF_IF),     rd_rm),
18275  cCL("tane",    ea88100, 2, (RF, RF_IF),     rd_rm),
18276  cCL("tanep",   ea88120, 2, (RF, RF_IF),     rd_rm),
18277  cCL("tanem",   ea88140, 2, (RF, RF_IF),     rd_rm),
18278  cCL("tanez",   ea88160, 2, (RF, RF_IF),     rd_rm),
18279
18280  cCL("asns",    eb08100, 2, (RF, RF_IF),     rd_rm),
18281  cCL("asnsp",   eb08120, 2, (RF, RF_IF),     rd_rm),
18282  cCL("asnsm",   eb08140, 2, (RF, RF_IF),     rd_rm),
18283  cCL("asnsz",   eb08160, 2, (RF, RF_IF),     rd_rm),
18284  cCL("asnd",    eb08180, 2, (RF, RF_IF),     rd_rm),
18285  cCL("asndp",   eb081a0, 2, (RF, RF_IF),     rd_rm),
18286  cCL("asndm",   eb081c0, 2, (RF, RF_IF),     rd_rm),
18287  cCL("asndz",   eb081e0, 2, (RF, RF_IF),     rd_rm),
18288  cCL("asne",    eb88100, 2, (RF, RF_IF),     rd_rm),
18289  cCL("asnep",   eb88120, 2, (RF, RF_IF),     rd_rm),
18290  cCL("asnem",   eb88140, 2, (RF, RF_IF),     rd_rm),
18291  cCL("asnez",   eb88160, 2, (RF, RF_IF),     rd_rm),
18292
18293  cCL("acss",    ec08100, 2, (RF, RF_IF),     rd_rm),
18294  cCL("acssp",   ec08120, 2, (RF, RF_IF),     rd_rm),
18295  cCL("acssm",   ec08140, 2, (RF, RF_IF),     rd_rm),
18296  cCL("acssz",   ec08160, 2, (RF, RF_IF),     rd_rm),
18297  cCL("acsd",    ec08180, 2, (RF, RF_IF),     rd_rm),
18298  cCL("acsdp",   ec081a0, 2, (RF, RF_IF),     rd_rm),
18299  cCL("acsdm",   ec081c0, 2, (RF, RF_IF),     rd_rm),
18300  cCL("acsdz",   ec081e0, 2, (RF, RF_IF),     rd_rm),
18301  cCL("acse",    ec88100, 2, (RF, RF_IF),     rd_rm),
18302  cCL("acsep",   ec88120, 2, (RF, RF_IF),     rd_rm),
18303  cCL("acsem",   ec88140, 2, (RF, RF_IF),     rd_rm),
18304  cCL("acsez",   ec88160, 2, (RF, RF_IF),     rd_rm),
18305
18306  cCL("atns",    ed08100, 2, (RF, RF_IF),     rd_rm),
18307  cCL("atnsp",   ed08120, 2, (RF, RF_IF),     rd_rm),
18308  cCL("atnsm",   ed08140, 2, (RF, RF_IF),     rd_rm),
18309  cCL("atnsz",   ed08160, 2, (RF, RF_IF),     rd_rm),
18310  cCL("atnd",    ed08180, 2, (RF, RF_IF),     rd_rm),
18311  cCL("atndp",   ed081a0, 2, (RF, RF_IF),     rd_rm),
18312  cCL("atndm",   ed081c0, 2, (RF, RF_IF),     rd_rm),
18313  cCL("atndz",   ed081e0, 2, (RF, RF_IF),     rd_rm),
18314  cCL("atne",    ed88100, 2, (RF, RF_IF),     rd_rm),
18315  cCL("atnep",   ed88120, 2, (RF, RF_IF),     rd_rm),
18316  cCL("atnem",   ed88140, 2, (RF, RF_IF),     rd_rm),
18317  cCL("atnez",   ed88160, 2, (RF, RF_IF),     rd_rm),
18318
18319  cCL("urds",    ee08100, 2, (RF, RF_IF),     rd_rm),
18320  cCL("urdsp",   ee08120, 2, (RF, RF_IF),     rd_rm),
18321  cCL("urdsm",   ee08140, 2, (RF, RF_IF),     rd_rm),
18322  cCL("urdsz",   ee08160, 2, (RF, RF_IF),     rd_rm),
18323  cCL("urdd",    ee08180, 2, (RF, RF_IF),     rd_rm),
18324  cCL("urddp",   ee081a0, 2, (RF, RF_IF),     rd_rm),
18325  cCL("urddm",   ee081c0, 2, (RF, RF_IF),     rd_rm),
18326  cCL("urddz",   ee081e0, 2, (RF, RF_IF),     rd_rm),
18327  cCL("urde",    ee88100, 2, (RF, RF_IF),     rd_rm),
18328  cCL("urdep",   ee88120, 2, (RF, RF_IF),     rd_rm),
18329  cCL("urdem",   ee88140, 2, (RF, RF_IF),     rd_rm),
18330  cCL("urdez",   ee88160, 2, (RF, RF_IF),     rd_rm),
18331
18332  cCL("nrms",    ef08100, 2, (RF, RF_IF),     rd_rm),
18333  cCL("nrmsp",   ef08120, 2, (RF, RF_IF),     rd_rm),
18334  cCL("nrmsm",   ef08140, 2, (RF, RF_IF),     rd_rm),
18335  cCL("nrmsz",   ef08160, 2, (RF, RF_IF),     rd_rm),
18336  cCL("nrmd",    ef08180, 2, (RF, RF_IF),     rd_rm),
18337  cCL("nrmdp",   ef081a0, 2, (RF, RF_IF),     rd_rm),
18338  cCL("nrmdm",   ef081c0, 2, (RF, RF_IF),     rd_rm),
18339  cCL("nrmdz",   ef081e0, 2, (RF, RF_IF),     rd_rm),
18340  cCL("nrme",    ef88100, 2, (RF, RF_IF),     rd_rm),
18341  cCL("nrmep",   ef88120, 2, (RF, RF_IF),     rd_rm),
18342  cCL("nrmem",   ef88140, 2, (RF, RF_IF),     rd_rm),
18343  cCL("nrmez",   ef88160, 2, (RF, RF_IF),     rd_rm),
18344
18345  cCL("adfs",    e000100, 3, (RF, RF, RF_IF), rd_rn_rm),
18346  cCL("adfsp",   e000120, 3, (RF, RF, RF_IF), rd_rn_rm),
18347  cCL("adfsm",   e000140, 3, (RF, RF, RF_IF), rd_rn_rm),
18348  cCL("adfsz",   e000160, 3, (RF, RF, RF_IF), rd_rn_rm),
18349  cCL("adfd",    e000180, 3, (RF, RF, RF_IF), rd_rn_rm),
18350  cCL("adfdp",   e0001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18351  cCL("adfdm",   e0001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18352  cCL("adfdz",   e0001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18353  cCL("adfe",    e080100, 3, (RF, RF, RF_IF), rd_rn_rm),
18354  cCL("adfep",   e080120, 3, (RF, RF, RF_IF), rd_rn_rm),
18355  cCL("adfem",   e080140, 3, (RF, RF, RF_IF), rd_rn_rm),
18356  cCL("adfez",   e080160, 3, (RF, RF, RF_IF), rd_rn_rm),
18357
18358  cCL("sufs",    e200100, 3, (RF, RF, RF_IF), rd_rn_rm),
18359  cCL("sufsp",   e200120, 3, (RF, RF, RF_IF), rd_rn_rm),
18360  cCL("sufsm",   e200140, 3, (RF, RF, RF_IF), rd_rn_rm),
18361  cCL("sufsz",   e200160, 3, (RF, RF, RF_IF), rd_rn_rm),
18362  cCL("sufd",    e200180, 3, (RF, RF, RF_IF), rd_rn_rm),
18363  cCL("sufdp",   e2001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18364  cCL("sufdm",   e2001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18365  cCL("sufdz",   e2001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18366  cCL("sufe",    e280100, 3, (RF, RF, RF_IF), rd_rn_rm),
18367  cCL("sufep",   e280120, 3, (RF, RF, RF_IF), rd_rn_rm),
18368  cCL("sufem",   e280140, 3, (RF, RF, RF_IF), rd_rn_rm),
18369  cCL("sufez",   e280160, 3, (RF, RF, RF_IF), rd_rn_rm),
18370
18371  cCL("rsfs",    e300100, 3, (RF, RF, RF_IF), rd_rn_rm),
18372  cCL("rsfsp",   e300120, 3, (RF, RF, RF_IF), rd_rn_rm),
18373  cCL("rsfsm",   e300140, 3, (RF, RF, RF_IF), rd_rn_rm),
18374  cCL("rsfsz",   e300160, 3, (RF, RF, RF_IF), rd_rn_rm),
18375  cCL("rsfd",    e300180, 3, (RF, RF, RF_IF), rd_rn_rm),
18376  cCL("rsfdp",   e3001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18377  cCL("rsfdm",   e3001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18378  cCL("rsfdz",   e3001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18379  cCL("rsfe",    e380100, 3, (RF, RF, RF_IF), rd_rn_rm),
18380  cCL("rsfep",   e380120, 3, (RF, RF, RF_IF), rd_rn_rm),
18381  cCL("rsfem",   e380140, 3, (RF, RF, RF_IF), rd_rn_rm),
18382  cCL("rsfez",   e380160, 3, (RF, RF, RF_IF), rd_rn_rm),
18383
18384  cCL("mufs",    e100100, 3, (RF, RF, RF_IF), rd_rn_rm),
18385  cCL("mufsp",   e100120, 3, (RF, RF, RF_IF), rd_rn_rm),
18386  cCL("mufsm",   e100140, 3, (RF, RF, RF_IF), rd_rn_rm),
18387  cCL("mufsz",   e100160, 3, (RF, RF, RF_IF), rd_rn_rm),
18388  cCL("mufd",    e100180, 3, (RF, RF, RF_IF), rd_rn_rm),
18389  cCL("mufdp",   e1001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18390  cCL("mufdm",   e1001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18391  cCL("mufdz",   e1001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18392  cCL("mufe",    e180100, 3, (RF, RF, RF_IF), rd_rn_rm),
18393  cCL("mufep",   e180120, 3, (RF, RF, RF_IF), rd_rn_rm),
18394  cCL("mufem",   e180140, 3, (RF, RF, RF_IF), rd_rn_rm),
18395  cCL("mufez",   e180160, 3, (RF, RF, RF_IF), rd_rn_rm),
18396
18397  cCL("dvfs",    e400100, 3, (RF, RF, RF_IF), rd_rn_rm),
18398  cCL("dvfsp",   e400120, 3, (RF, RF, RF_IF), rd_rn_rm),
18399  cCL("dvfsm",   e400140, 3, (RF, RF, RF_IF), rd_rn_rm),
18400  cCL("dvfsz",   e400160, 3, (RF, RF, RF_IF), rd_rn_rm),
18401  cCL("dvfd",    e400180, 3, (RF, RF, RF_IF), rd_rn_rm),
18402  cCL("dvfdp",   e4001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18403  cCL("dvfdm",   e4001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18404  cCL("dvfdz",   e4001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18405  cCL("dvfe",    e480100, 3, (RF, RF, RF_IF), rd_rn_rm),
18406  cCL("dvfep",   e480120, 3, (RF, RF, RF_IF), rd_rn_rm),
18407  cCL("dvfem",   e480140, 3, (RF, RF, RF_IF), rd_rn_rm),
18408  cCL("dvfez",   e480160, 3, (RF, RF, RF_IF), rd_rn_rm),
18409
18410  cCL("rdfs",    e500100, 3, (RF, RF, RF_IF), rd_rn_rm),
18411  cCL("rdfsp",   e500120, 3, (RF, RF, RF_IF), rd_rn_rm),
18412  cCL("rdfsm",   e500140, 3, (RF, RF, RF_IF), rd_rn_rm),
18413  cCL("rdfsz",   e500160, 3, (RF, RF, RF_IF), rd_rn_rm),
18414  cCL("rdfd",    e500180, 3, (RF, RF, RF_IF), rd_rn_rm),
18415  cCL("rdfdp",   e5001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18416  cCL("rdfdm",   e5001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18417  cCL("rdfdz",   e5001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18418  cCL("rdfe",    e580100, 3, (RF, RF, RF_IF), rd_rn_rm),
18419  cCL("rdfep",   e580120, 3, (RF, RF, RF_IF), rd_rn_rm),
18420  cCL("rdfem",   e580140, 3, (RF, RF, RF_IF), rd_rn_rm),
18421  cCL("rdfez",   e580160, 3, (RF, RF, RF_IF), rd_rn_rm),
18422
18423  cCL("pows",    e600100, 3, (RF, RF, RF_IF), rd_rn_rm),
18424  cCL("powsp",   e600120, 3, (RF, RF, RF_IF), rd_rn_rm),
18425  cCL("powsm",   e600140, 3, (RF, RF, RF_IF), rd_rn_rm),
18426  cCL("powsz",   e600160, 3, (RF, RF, RF_IF), rd_rn_rm),
18427  cCL("powd",    e600180, 3, (RF, RF, RF_IF), rd_rn_rm),
18428  cCL("powdp",   e6001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18429  cCL("powdm",   e6001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18430  cCL("powdz",   e6001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18431  cCL("powe",    e680100, 3, (RF, RF, RF_IF), rd_rn_rm),
18432  cCL("powep",   e680120, 3, (RF, RF, RF_IF), rd_rn_rm),
18433  cCL("powem",   e680140, 3, (RF, RF, RF_IF), rd_rn_rm),
18434  cCL("powez",   e680160, 3, (RF, RF, RF_IF), rd_rn_rm),
18435
18436  cCL("rpws",    e700100, 3, (RF, RF, RF_IF), rd_rn_rm),
18437  cCL("rpwsp",   e700120, 3, (RF, RF, RF_IF), rd_rn_rm),
18438  cCL("rpwsm",   e700140, 3, (RF, RF, RF_IF), rd_rn_rm),
18439  cCL("rpwsz",   e700160, 3, (RF, RF, RF_IF), rd_rn_rm),
18440  cCL("rpwd",    e700180, 3, (RF, RF, RF_IF), rd_rn_rm),
18441  cCL("rpwdp",   e7001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18442  cCL("rpwdm",   e7001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18443  cCL("rpwdz",   e7001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18444  cCL("rpwe",    e780100, 3, (RF, RF, RF_IF), rd_rn_rm),
18445  cCL("rpwep",   e780120, 3, (RF, RF, RF_IF), rd_rn_rm),
18446  cCL("rpwem",   e780140, 3, (RF, RF, RF_IF), rd_rn_rm),
18447  cCL("rpwez",   e780160, 3, (RF, RF, RF_IF), rd_rn_rm),
18448
18449  cCL("rmfs",    e800100, 3, (RF, RF, RF_IF), rd_rn_rm),
18450  cCL("rmfsp",   e800120, 3, (RF, RF, RF_IF), rd_rn_rm),
18451  cCL("rmfsm",   e800140, 3, (RF, RF, RF_IF), rd_rn_rm),
18452  cCL("rmfsz",   e800160, 3, (RF, RF, RF_IF), rd_rn_rm),
18453  cCL("rmfd",    e800180, 3, (RF, RF, RF_IF), rd_rn_rm),
18454  cCL("rmfdp",   e8001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18455  cCL("rmfdm",   e8001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18456  cCL("rmfdz",   e8001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18457  cCL("rmfe",    e880100, 3, (RF, RF, RF_IF), rd_rn_rm),
18458  cCL("rmfep",   e880120, 3, (RF, RF, RF_IF), rd_rn_rm),
18459  cCL("rmfem",   e880140, 3, (RF, RF, RF_IF), rd_rn_rm),
18460  cCL("rmfez",   e880160, 3, (RF, RF, RF_IF), rd_rn_rm),
18461
18462  cCL("fmls",    e900100, 3, (RF, RF, RF_IF), rd_rn_rm),
18463  cCL("fmlsp",   e900120, 3, (RF, RF, RF_IF), rd_rn_rm),
18464  cCL("fmlsm",   e900140, 3, (RF, RF, RF_IF), rd_rn_rm),
18465  cCL("fmlsz",   e900160, 3, (RF, RF, RF_IF), rd_rn_rm),
18466  cCL("fmld",    e900180, 3, (RF, RF, RF_IF), rd_rn_rm),
18467  cCL("fmldp",   e9001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18468  cCL("fmldm",   e9001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18469  cCL("fmldz",   e9001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18470  cCL("fmle",    e980100, 3, (RF, RF, RF_IF), rd_rn_rm),
18471  cCL("fmlep",   e980120, 3, (RF, RF, RF_IF), rd_rn_rm),
18472  cCL("fmlem",   e980140, 3, (RF, RF, RF_IF), rd_rn_rm),
18473  cCL("fmlez",   e980160, 3, (RF, RF, RF_IF), rd_rn_rm),
18474
18475  cCL("fdvs",    ea00100, 3, (RF, RF, RF_IF), rd_rn_rm),
18476  cCL("fdvsp",   ea00120, 3, (RF, RF, RF_IF), rd_rn_rm),
18477  cCL("fdvsm",   ea00140, 3, (RF, RF, RF_IF), rd_rn_rm),
18478  cCL("fdvsz",   ea00160, 3, (RF, RF, RF_IF), rd_rn_rm),
18479  cCL("fdvd",    ea00180, 3, (RF, RF, RF_IF), rd_rn_rm),
18480  cCL("fdvdp",   ea001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18481  cCL("fdvdm",   ea001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18482  cCL("fdvdz",   ea001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18483  cCL("fdve",    ea80100, 3, (RF, RF, RF_IF), rd_rn_rm),
18484  cCL("fdvep",   ea80120, 3, (RF, RF, RF_IF), rd_rn_rm),
18485  cCL("fdvem",   ea80140, 3, (RF, RF, RF_IF), rd_rn_rm),
18486  cCL("fdvez",   ea80160, 3, (RF, RF, RF_IF), rd_rn_rm),
18487
18488  cCL("frds",    eb00100, 3, (RF, RF, RF_IF), rd_rn_rm),
18489  cCL("frdsp",   eb00120, 3, (RF, RF, RF_IF), rd_rn_rm),
18490  cCL("frdsm",   eb00140, 3, (RF, RF, RF_IF), rd_rn_rm),
18491  cCL("frdsz",   eb00160, 3, (RF, RF, RF_IF), rd_rn_rm),
18492  cCL("frdd",    eb00180, 3, (RF, RF, RF_IF), rd_rn_rm),
18493  cCL("frddp",   eb001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18494  cCL("frddm",   eb001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18495  cCL("frddz",   eb001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18496  cCL("frde",    eb80100, 3, (RF, RF, RF_IF), rd_rn_rm),
18497  cCL("frdep",   eb80120, 3, (RF, RF, RF_IF), rd_rn_rm),
18498  cCL("frdem",   eb80140, 3, (RF, RF, RF_IF), rd_rn_rm),
18499  cCL("frdez",   eb80160, 3, (RF, RF, RF_IF), rd_rn_rm),
18500
18501  cCL("pols",    ec00100, 3, (RF, RF, RF_IF), rd_rn_rm),
18502  cCL("polsp",   ec00120, 3, (RF, RF, RF_IF), rd_rn_rm),
18503  cCL("polsm",   ec00140, 3, (RF, RF, RF_IF), rd_rn_rm),
18504  cCL("polsz",   ec00160, 3, (RF, RF, RF_IF), rd_rn_rm),
18505  cCL("pold",    ec00180, 3, (RF, RF, RF_IF), rd_rn_rm),
18506  cCL("poldp",   ec001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18507  cCL("poldm",   ec001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18508  cCL("poldz",   ec001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18509  cCL("pole",    ec80100, 3, (RF, RF, RF_IF), rd_rn_rm),
18510  cCL("polep",   ec80120, 3, (RF, RF, RF_IF), rd_rn_rm),
18511  cCL("polem",   ec80140, 3, (RF, RF, RF_IF), rd_rn_rm),
18512  cCL("polez",   ec80160, 3, (RF, RF, RF_IF), rd_rn_rm),
18513
18514  cCE("cmf",     e90f110, 2, (RF, RF_IF),     fpa_cmp),
18515  C3E("cmfe",    ed0f110, 2, (RF, RF_IF),     fpa_cmp),
18516  cCE("cnf",     eb0f110, 2, (RF, RF_IF),     fpa_cmp),
18517  C3E("cnfe",    ef0f110, 2, (RF, RF_IF),     fpa_cmp),
18518
18519  cCL("flts",    e000110, 2, (RF, RR),        rn_rd),
18520  cCL("fltsp",   e000130, 2, (RF, RR),        rn_rd),
18521  cCL("fltsm",   e000150, 2, (RF, RR),        rn_rd),
18522  cCL("fltsz",   e000170, 2, (RF, RR),        rn_rd),
18523  cCL("fltd",    e000190, 2, (RF, RR),        rn_rd),
18524  cCL("fltdp",   e0001b0, 2, (RF, RR),        rn_rd),
18525  cCL("fltdm",   e0001d0, 2, (RF, RR),        rn_rd),
18526  cCL("fltdz",   e0001f0, 2, (RF, RR),        rn_rd),
18527  cCL("flte",    e080110, 2, (RF, RR),        rn_rd),
18528  cCL("fltep",   e080130, 2, (RF, RR),        rn_rd),
18529  cCL("fltem",   e080150, 2, (RF, RR),        rn_rd),
18530  cCL("fltez",   e080170, 2, (RF, RR),        rn_rd),
18531
18532   /* The implementation of the FIX instruction is broken on some
18533      assemblers, in that it accepts a precision specifier as well as a
18534      rounding specifier, despite the fact that this is meaningless.
18535      To be more compatible, we accept it as well, though of course it
18536      does not set any bits.  */
18537  cCE("fix",     e100110, 2, (RR, RF),        rd_rm),
18538  cCL("fixp",    e100130, 2, (RR, RF),        rd_rm),
18539  cCL("fixm",    e100150, 2, (RR, RF),        rd_rm),
18540  cCL("fixz",    e100170, 2, (RR, RF),        rd_rm),
18541  cCL("fixsp",   e100130, 2, (RR, RF),        rd_rm),
18542  cCL("fixsm",   e100150, 2, (RR, RF),        rd_rm),
18543  cCL("fixsz",   e100170, 2, (RR, RF),        rd_rm),
18544  cCL("fixdp",   e100130, 2, (RR, RF),        rd_rm),
18545  cCL("fixdm",   e100150, 2, (RR, RF),        rd_rm),
18546  cCL("fixdz",   e100170, 2, (RR, RF),        rd_rm),
18547  cCL("fixep",   e100130, 2, (RR, RF),        rd_rm),
18548  cCL("fixem",   e100150, 2, (RR, RF),        rd_rm),
18549  cCL("fixez",   e100170, 2, (RR, RF),        rd_rm),
18550
18551   /* Instructions that were new with the real FPA, call them V2.  */
18552 #undef  ARM_VARIANT
18553 #define ARM_VARIANT  & fpu_fpa_ext_v2
18554
18555  cCE("lfm",     c100200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18556  cCL("lfmfd",   c900200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18557  cCL("lfmea",   d100200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18558  cCE("sfm",     c000200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18559  cCL("sfmfd",   d000200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18560  cCL("sfmea",   c800200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18561
18562 #undef  ARM_VARIANT
18563 #define ARM_VARIANT  & fpu_vfp_ext_v1xd  /* VFP V1xD (single precision).  */
18564
18565   /* Moves and type conversions.  */
18566  cCE("fcpys",   eb00a40, 2, (RVS, RVS),       vfp_sp_monadic),
18567  cCE("fmrs",    e100a10, 2, (RR, RVS),        vfp_reg_from_sp),
18568  cCE("fmsr",    e000a10, 2, (RVS, RR),        vfp_sp_from_reg),
18569  cCE("fmstat",  ef1fa10, 0, (),               noargs),
18570  cCE("vmrs",    ef00a10, 2, (APSR_RR, RVC),   vmrs),
18571  cCE("vmsr",    ee00a10, 2, (RVC, RR),        vmsr),
18572  cCE("fsitos",  eb80ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18573  cCE("fuitos",  eb80a40, 2, (RVS, RVS),       vfp_sp_monadic),
18574  cCE("ftosis",  ebd0a40, 2, (RVS, RVS),       vfp_sp_monadic),
18575  cCE("ftosizs", ebd0ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18576  cCE("ftouis",  ebc0a40, 2, (RVS, RVS),       vfp_sp_monadic),
18577  cCE("ftouizs", ebc0ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18578  cCE("fmrx",    ef00a10, 2, (RR, RVC),        rd_rn),
18579  cCE("fmxr",    ee00a10, 2, (RVC, RR),        rn_rd),
18580
18581   /* Memory operations.  */
18582  cCE("flds",    d100a00, 2, (RVS, ADDRGLDC),  vfp_sp_ldst),
18583  cCE("fsts",    d000a00, 2, (RVS, ADDRGLDC),  vfp_sp_ldst),
18584  cCE("fldmias", c900a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
18585  cCE("fldmfds", c900a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
18586  cCE("fldmdbs", d300a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
18587  cCE("fldmeas", d300a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
18588  cCE("fldmiax", c900b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
18589  cCE("fldmfdx", c900b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
18590  cCE("fldmdbx", d300b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
18591  cCE("fldmeax", d300b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
18592  cCE("fstmias", c800a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
18593  cCE("fstmeas", c800a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
18594  cCE("fstmdbs", d200a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
18595  cCE("fstmfds", d200a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
18596  cCE("fstmiax", c800b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
18597  cCE("fstmeax", c800b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
18598  cCE("fstmdbx", d200b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
18599  cCE("fstmfdx", d200b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
18600
18601   /* Monadic operations.  */
18602  cCE("fabss",   eb00ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18603  cCE("fnegs",   eb10a40, 2, (RVS, RVS),       vfp_sp_monadic),
18604  cCE("fsqrts",  eb10ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18605
18606   /* Dyadic operations.  */
18607  cCE("fadds",   e300a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18608  cCE("fsubs",   e300a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18609  cCE("fmuls",   e200a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18610  cCE("fdivs",   e800a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18611  cCE("fmacs",   e000a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18612  cCE("fmscs",   e100a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18613  cCE("fnmuls",  e200a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18614  cCE("fnmacs",  e000a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18615  cCE("fnmscs",  e100a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18616
18617   /* Comparisons.  */
18618  cCE("fcmps",   eb40a40, 2, (RVS, RVS),       vfp_sp_monadic),
18619  cCE("fcmpzs",  eb50a40, 1, (RVS),            vfp_sp_compare_z),
18620  cCE("fcmpes",  eb40ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18621  cCE("fcmpezs", eb50ac0, 1, (RVS),            vfp_sp_compare_z),
18622
18623  /* Double precision load/store are still present on single precision
18624     implementations.  */
18625  cCE("fldd",    d100b00, 2, (RVD, ADDRGLDC),  vfp_dp_ldst),
18626  cCE("fstd",    d000b00, 2, (RVD, ADDRGLDC),  vfp_dp_ldst),
18627  cCE("fldmiad", c900b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
18628  cCE("fldmfdd", c900b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
18629  cCE("fldmdbd", d300b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
18630  cCE("fldmead", d300b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
18631  cCE("fstmiad", c800b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
18632  cCE("fstmead", c800b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
18633  cCE("fstmdbd", d200b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
18634  cCE("fstmfdd", d200b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
18635
18636 #undef  ARM_VARIANT
18637 #define ARM_VARIANT  & fpu_vfp_ext_v1 /* VFP V1 (Double precision).  */
18638
18639   /* Moves and type conversions.  */
18640  cCE("fcpyd",   eb00b40, 2, (RVD, RVD),       vfp_dp_rd_rm),
18641  cCE("fcvtds",  eb70ac0, 2, (RVD, RVS),       vfp_dp_sp_cvt),
18642  cCE("fcvtsd",  eb70bc0, 2, (RVS, RVD),       vfp_sp_dp_cvt),
18643  cCE("fmdhr",   e200b10, 2, (RVD, RR),        vfp_dp_rn_rd),
18644  cCE("fmdlr",   e000b10, 2, (RVD, RR),        vfp_dp_rn_rd),
18645  cCE("fmrdh",   e300b10, 2, (RR, RVD),        vfp_dp_rd_rn),
18646  cCE("fmrdl",   e100b10, 2, (RR, RVD),        vfp_dp_rd_rn),
18647  cCE("fsitod",  eb80bc0, 2, (RVD, RVS),       vfp_dp_sp_cvt),
18648  cCE("fuitod",  eb80b40, 2, (RVD, RVS),       vfp_dp_sp_cvt),
18649  cCE("ftosid",  ebd0b40, 2, (RVS, RVD),       vfp_sp_dp_cvt),
18650  cCE("ftosizd", ebd0bc0, 2, (RVS, RVD),       vfp_sp_dp_cvt),
18651  cCE("ftouid",  ebc0b40, 2, (RVS, RVD),       vfp_sp_dp_cvt),
18652  cCE("ftouizd", ebc0bc0, 2, (RVS, RVD),       vfp_sp_dp_cvt),
18653
18654   /* Monadic operations.  */
18655  cCE("fabsd",   eb00bc0, 2, (RVD, RVD),       vfp_dp_rd_rm),
18656  cCE("fnegd",   eb10b40, 2, (RVD, RVD),       vfp_dp_rd_rm),
18657  cCE("fsqrtd",  eb10bc0, 2, (RVD, RVD),       vfp_dp_rd_rm),
18658
18659   /* Dyadic operations.  */
18660  cCE("faddd",   e300b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18661  cCE("fsubd",   e300b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18662  cCE("fmuld",   e200b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18663  cCE("fdivd",   e800b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18664  cCE("fmacd",   e000b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18665  cCE("fmscd",   e100b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18666  cCE("fnmuld",  e200b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18667  cCE("fnmacd",  e000b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18668  cCE("fnmscd",  e100b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18669
18670   /* Comparisons.  */
18671  cCE("fcmpd",   eb40b40, 2, (RVD, RVD),       vfp_dp_rd_rm),
18672  cCE("fcmpzd",  eb50b40, 1, (RVD),            vfp_dp_rd),
18673  cCE("fcmped",  eb40bc0, 2, (RVD, RVD),       vfp_dp_rd_rm),
18674  cCE("fcmpezd", eb50bc0, 1, (RVD),            vfp_dp_rd),
18675
18676 #undef  ARM_VARIANT
18677 #define ARM_VARIANT  & fpu_vfp_ext_v2
18678
18679  cCE("fmsrr",   c400a10, 3, (VRSLST, RR, RR), vfp_sp2_from_reg2),
18680  cCE("fmrrs",   c500a10, 3, (RR, RR, VRSLST), vfp_reg2_from_sp2),
18681  cCE("fmdrr",   c400b10, 3, (RVD, RR, RR),    vfp_dp_rm_rd_rn),
18682  cCE("fmrrd",   c500b10, 3, (RR, RR, RVD),    vfp_dp_rd_rn_rm),
18683
18684 /* Instructions which may belong to either the Neon or VFP instruction sets.
18685    Individual encoder functions perform additional architecture checks.  */
18686 #undef  ARM_VARIANT
18687 #define ARM_VARIANT    & fpu_vfp_ext_v1xd
18688 #undef  THUMB_VARIANT
18689 #define THUMB_VARIANT  & fpu_vfp_ext_v1xd
18690
18691   /* These mnemonics are unique to VFP.  */
18692  NCE(vsqrt,     0,       2, (RVSD, RVSD),       vfp_nsyn_sqrt),
18693  NCE(vdiv,      0,       3, (RVSD, RVSD, RVSD), vfp_nsyn_div),
18694  nCE(vnmul,     _vnmul,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
18695  nCE(vnmla,     _vnmla,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
18696  nCE(vnmls,     _vnmls,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
18697  nCE(vcmp,      _vcmp,    2, (RVSD, RVSD_I0),    vfp_nsyn_cmp),
18698  nCE(vcmpe,     _vcmpe,   2, (RVSD, RVSD_I0),    vfp_nsyn_cmp),
18699  NCE(vpush,     0,       1, (VRSDLST),          vfp_nsyn_push),
18700  NCE(vpop,      0,       1, (VRSDLST),          vfp_nsyn_pop),
18701  NCE(vcvtz,     0,       2, (RVSD, RVSD),       vfp_nsyn_cvtz),
18702
18703   /* Mnemonics shared by Neon and VFP.  */
18704  nCEF(vmul,     _vmul,    3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mul),
18705  nCEF(vmla,     _vmla,    3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mac_maybe_scalar),
18706  nCEF(vmls,     _vmls,    3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mac_maybe_scalar),
18707
18708  nCEF(vadd,     _vadd,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_addsub_if_i),
18709  nCEF(vsub,     _vsub,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_addsub_if_i),
18710
18711  NCEF(vabs,     1b10300, 2, (RNSDQ, RNSDQ), neon_abs_neg),
18712  NCEF(vneg,     1b10380, 2, (RNSDQ, RNSDQ), neon_abs_neg),
18713
18714  NCE(vldm,      c900b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18715  NCE(vldmia,    c900b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18716  NCE(vldmdb,    d100b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18717  NCE(vstm,      c800b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18718  NCE(vstmia,    c800b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18719  NCE(vstmdb,    d000b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18720  NCE(vldr,      d100b00, 2, (RVSD, ADDRGLDC), neon_ldr_str),
18721  NCE(vstr,      d000b00, 2, (RVSD, ADDRGLDC), neon_ldr_str),
18722
18723  nCEF(vcvt,     _vcvt,   3, (RNSDQ, RNSDQ, oI32z), neon_cvt),
18724  nCEF(vcvtr,    _vcvt,   2, (RNSDQ, RNSDQ), neon_cvtr),
18725  nCEF(vcvtb,    _vcvt,   2, (RVS, RVS), neon_cvtb),
18726  nCEF(vcvtt,    _vcvt,   2, (RVS, RVS), neon_cvtt),
18727
18728
18729   /* NOTE: All VMOV encoding is special-cased!  */
18730  NCE(vmov,      0,       1, (VMOV), neon_mov),
18731  NCE(vmovq,     0,       1, (VMOV), neon_mov),
18732
18733 #undef  THUMB_VARIANT
18734 #define THUMB_VARIANT  & fpu_neon_ext_v1
18735 #undef  ARM_VARIANT
18736 #define ARM_VARIANT    & fpu_neon_ext_v1
18737
18738   /* Data processing with three registers of the same length.  */
18739   /* integer ops, valid types S8 S16 S32 U8 U16 U32.  */
18740  NUF(vaba,      0000710, 3, (RNDQ, RNDQ,  RNDQ), neon_dyadic_i_su),
18741  NUF(vabaq,     0000710, 3, (RNQ,  RNQ,   RNQ),  neon_dyadic_i_su),
18742  NUF(vhadd,     0000000, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
18743  NUF(vhaddq,    0000000, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i_su),
18744  NUF(vrhadd,    0000100, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
18745  NUF(vrhaddq,   0000100, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i_su),
18746  NUF(vhsub,     0000200, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
18747  NUF(vhsubq,    0000200, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i_su),
18748   /* integer ops, valid types S8 S16 S32 S64 U8 U16 U32 U64.  */
18749  NUF(vqadd,     0000010, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i64_su),
18750  NUF(vqaddq,    0000010, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i64_su),
18751  NUF(vqsub,     0000210, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i64_su),
18752  NUF(vqsubq,    0000210, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i64_su),
18753  NUF(vrshl,     0000500, 3, (RNDQ, oRNDQ, RNDQ), neon_rshl),
18754  NUF(vrshlq,    0000500, 3, (RNQ,  oRNQ,  RNQ),  neon_rshl),
18755  NUF(vqrshl,    0000510, 3, (RNDQ, oRNDQ, RNDQ), neon_rshl),
18756  NUF(vqrshlq,   0000510, 3, (RNQ,  oRNQ,  RNQ),  neon_rshl),
18757   /* If not immediate, fall back to neon_dyadic_i64_su.
18758      shl_imm should accept I8 I16 I32 I64,
18759      qshl_imm should accept S8 S16 S32 S64 U8 U16 U32 U64.  */
18760  nUF(vshl,      _vshl,    3, (RNDQ, oRNDQ, RNDQ_I63b), neon_shl_imm),
18761  nUF(vshlq,     _vshl,    3, (RNQ,  oRNQ,  RNDQ_I63b), neon_shl_imm),
18762  nUF(vqshl,     _vqshl,   3, (RNDQ, oRNDQ, RNDQ_I63b), neon_qshl_imm),
18763  nUF(vqshlq,    _vqshl,   3, (RNQ,  oRNQ,  RNDQ_I63b), neon_qshl_imm),
18764   /* Logic ops, types optional & ignored.  */
18765  nUF(vand,      _vand,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
18766  nUF(vandq,     _vand,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
18767  nUF(vbic,      _vbic,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
18768  nUF(vbicq,     _vbic,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
18769  nUF(vorr,      _vorr,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
18770  nUF(vorrq,     _vorr,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
18771  nUF(vorn,      _vorn,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
18772  nUF(vornq,     _vorn,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
18773  nUF(veor,      _veor,    3, (RNDQ, oRNDQ, RNDQ),      neon_logic),
18774  nUF(veorq,     _veor,    3, (RNQ,  oRNQ,  RNQ),       neon_logic),
18775   /* Bitfield ops, untyped.  */
18776  NUF(vbsl,      1100110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
18777  NUF(vbslq,     1100110, 3, (RNQ,  RNQ,  RNQ),  neon_bitfield),
18778  NUF(vbit,      1200110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
18779  NUF(vbitq,     1200110, 3, (RNQ,  RNQ,  RNQ),  neon_bitfield),
18780  NUF(vbif,      1300110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
18781  NUF(vbifq,     1300110, 3, (RNQ,  RNQ,  RNQ),  neon_bitfield),
18782   /* Int and float variants, types S8 S16 S32 U8 U16 U32 F32.  */
18783  nUF(vabd,      _vabd,    3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
18784  nUF(vabdq,     _vabd,    3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_if_su),
18785  nUF(vmax,      _vmax,    3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
18786  nUF(vmaxq,     _vmax,    3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_if_su),
18787  nUF(vmin,      _vmin,    3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
18788  nUF(vminq,     _vmin,    3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_if_su),
18789   /* Comparisons. Types S8 S16 S32 U8 U16 U32 F32. Non-immediate versions fall
18790      back to neon_dyadic_if_su.  */
18791  nUF(vcge,      _vcge,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp),
18792  nUF(vcgeq,     _vcge,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp),
18793  nUF(vcgt,      _vcgt,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp),
18794  nUF(vcgtq,     _vcgt,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp),
18795  nUF(vclt,      _vclt,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp_inv),
18796  nUF(vcltq,     _vclt,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp_inv),
18797  nUF(vcle,      _vcle,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp_inv),
18798  nUF(vcleq,     _vcle,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp_inv),
18799   /* Comparison. Type I8 I16 I32 F32.  */
18800  nUF(vceq,      _vceq,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_ceq),
18801  nUF(vceqq,     _vceq,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_ceq),
18802   /* As above, D registers only.  */
18803  nUF(vpmax,     _vpmax,   3, (RND, oRND, RND), neon_dyadic_if_su_d),
18804  nUF(vpmin,     _vpmin,   3, (RND, oRND, RND), neon_dyadic_if_su_d),
18805   /* Int and float variants, signedness unimportant.  */
18806  nUF(vmlaq,     _vmla,    3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_mac_maybe_scalar),
18807  nUF(vmlsq,     _vmls,    3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_mac_maybe_scalar),
18808  nUF(vpadd,     _vpadd,   3, (RND,  oRND,  RND),       neon_dyadic_if_i_d),
18809   /* Add/sub take types I8 I16 I32 I64 F32.  */
18810  nUF(vaddq,     _vadd,    3, (RNQ,  oRNQ,  RNQ),  neon_addsub_if_i),
18811  nUF(vsubq,     _vsub,    3, (RNQ,  oRNQ,  RNQ),  neon_addsub_if_i),
18812   /* vtst takes sizes 8, 16, 32.  */
18813  NUF(vtst,      0000810, 3, (RNDQ, oRNDQ, RNDQ), neon_tst),
18814  NUF(vtstq,     0000810, 3, (RNQ,  oRNQ,  RNQ),  neon_tst),
18815   /* VMUL takes I8 I16 I32 F32 P8.  */
18816  nUF(vmulq,     _vmul,     3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_mul),
18817   /* VQD{R}MULH takes S16 S32.  */
18818  nUF(vqdmulh,   _vqdmulh,  3, (RNDQ, oRNDQ, RNDQ_RNSC), neon_qdmulh),
18819  nUF(vqdmulhq,  _vqdmulh,  3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_qdmulh),
18820  nUF(vqrdmulh,  _vqrdmulh, 3, (RNDQ, oRNDQ, RNDQ_RNSC), neon_qdmulh),
18821  nUF(vqrdmulhq, _vqrdmulh, 3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_qdmulh),
18822  NUF(vacge,     0000e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute),
18823  NUF(vacgeq,    0000e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute),
18824  NUF(vacgt,     0200e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute),
18825  NUF(vacgtq,    0200e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute),
18826  NUF(vaclt,     0200e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute_inv),
18827  NUF(vacltq,    0200e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute_inv),
18828  NUF(vacle,     0000e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute_inv),
18829  NUF(vacleq,    0000e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute_inv),
18830  NUF(vrecps,    0000f10,  3, (RNDQ, oRNDQ, RNDQ), neon_step),
18831  NUF(vrecpsq,   0000f10,  3, (RNQ,  oRNQ,  RNQ),  neon_step),
18832  NUF(vrsqrts,   0200f10,  3, (RNDQ, oRNDQ, RNDQ), neon_step),
18833  NUF(vrsqrtsq,  0200f10,  3, (RNQ,  oRNQ,  RNQ),  neon_step),
18834
18835   /* Two address, int/float. Types S8 S16 S32 F32.  */
18836  NUF(vabsq,     1b10300, 2, (RNQ,  RNQ),      neon_abs_neg),
18837  NUF(vnegq,     1b10380, 2, (RNQ,  RNQ),      neon_abs_neg),
18838
18839   /* Data processing with two registers and a shift amount.  */
18840   /* Right shifts, and variants with rounding.
18841      Types accepted S8 S16 S32 S64 U8 U16 U32 U64.  */
18842  NUF(vshr,      0800010, 3, (RNDQ, oRNDQ, I64z), neon_rshift_round_imm),
18843  NUF(vshrq,     0800010, 3, (RNQ,  oRNQ,  I64z), neon_rshift_round_imm),
18844  NUF(vrshr,     0800210, 3, (RNDQ, oRNDQ, I64z), neon_rshift_round_imm),
18845  NUF(vrshrq,    0800210, 3, (RNQ,  oRNQ,  I64z), neon_rshift_round_imm),
18846  NUF(vsra,      0800110, 3, (RNDQ, oRNDQ, I64),  neon_rshift_round_imm),
18847  NUF(vsraq,     0800110, 3, (RNQ,  oRNQ,  I64),  neon_rshift_round_imm),
18848  NUF(vrsra,     0800310, 3, (RNDQ, oRNDQ, I64),  neon_rshift_round_imm),
18849  NUF(vrsraq,    0800310, 3, (RNQ,  oRNQ,  I64),  neon_rshift_round_imm),
18850   /* Shift and insert. Sizes accepted 8 16 32 64.  */
18851  NUF(vsli,      1800510, 3, (RNDQ, oRNDQ, I63), neon_sli),
18852  NUF(vsliq,     1800510, 3, (RNQ,  oRNQ,  I63), neon_sli),
18853  NUF(vsri,      1800410, 3, (RNDQ, oRNDQ, I64), neon_sri),
18854  NUF(vsriq,     1800410, 3, (RNQ,  oRNQ,  I64), neon_sri),
18855   /* QSHL{U} immediate accepts S8 S16 S32 S64 U8 U16 U32 U64.  */
18856  NUF(vqshlu,    1800610, 3, (RNDQ, oRNDQ, I63), neon_qshlu_imm),
18857  NUF(vqshluq,   1800610, 3, (RNQ,  oRNQ,  I63), neon_qshlu_imm),
18858   /* Right shift immediate, saturating & narrowing, with rounding variants.
18859      Types accepted S16 S32 S64 U16 U32 U64.  */
18860  NUF(vqshrn,    0800910, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow),
18861  NUF(vqrshrn,   0800950, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow),
18862   /* As above, unsigned. Types accepted S16 S32 S64.  */
18863  NUF(vqshrun,   0800810, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow_u),
18864  NUF(vqrshrun,  0800850, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow_u),
18865   /* Right shift narrowing. Types accepted I16 I32 I64.  */
18866  NUF(vshrn,     0800810, 3, (RND, RNQ, I32z), neon_rshift_narrow),
18867  NUF(vrshrn,    0800850, 3, (RND, RNQ, I32z), neon_rshift_narrow),
18868   /* Special case. Types S8 S16 S32 U8 U16 U32. Handles max shift variant.  */
18869  nUF(vshll,     _vshll,   3, (RNQ, RND, I32),  neon_shll),
18870   /* CVT with optional immediate for fixed-point variant.  */
18871  nUF(vcvtq,     _vcvt,    3, (RNQ, RNQ, oI32b), neon_cvt),
18872
18873  nUF(vmvn,      _vmvn,    2, (RNDQ, RNDQ_Ibig), neon_mvn),
18874  nUF(vmvnq,     _vmvn,    2, (RNQ,  RNDQ_Ibig), neon_mvn),
18875
18876   /* Data processing, three registers of different lengths.  */
18877   /* Dyadic, long insns. Types S8 S16 S32 U8 U16 U32.  */
18878  NUF(vabal,     0800500, 3, (RNQ, RND, RND),  neon_abal),
18879  NUF(vabdl,     0800700, 3, (RNQ, RND, RND),  neon_dyadic_long),
18880  NUF(vaddl,     0800000, 3, (RNQ, RND, RND),  neon_dyadic_long),
18881  NUF(vsubl,     0800200, 3, (RNQ, RND, RND),  neon_dyadic_long),
18882   /* If not scalar, fall back to neon_dyadic_long.
18883      Vector types as above, scalar types S16 S32 U16 U32.  */
18884  nUF(vmlal,     _vmlal,   3, (RNQ, RND, RND_RNSC), neon_mac_maybe_scalar_long),
18885  nUF(vmlsl,     _vmlsl,   3, (RNQ, RND, RND_RNSC), neon_mac_maybe_scalar_long),
18886   /* Dyadic, widening insns. Types S8 S16 S32 U8 U16 U32.  */
18887  NUF(vaddw,     0800100, 3, (RNQ, oRNQ, RND), neon_dyadic_wide),
18888  NUF(vsubw,     0800300, 3, (RNQ, oRNQ, RND), neon_dyadic_wide),
18889   /* Dyadic, narrowing insns. Types I16 I32 I64.  */
18890  NUF(vaddhn,    0800400, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
18891  NUF(vraddhn,   1800400, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
18892  NUF(vsubhn,    0800600, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
18893  NUF(vrsubhn,   1800600, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
18894   /* Saturating doubling multiplies. Types S16 S32.  */
18895  nUF(vqdmlal,   _vqdmlal, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
18896  nUF(vqdmlsl,   _vqdmlsl, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
18897  nUF(vqdmull,   _vqdmull, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
18898   /* VMULL. Vector types S8 S16 S32 U8 U16 U32 P8, scalar types
18899      S16 S32 U16 U32.  */
18900  nUF(vmull,     _vmull,   3, (RNQ, RND, RND_RNSC), neon_vmull),
18901
18902   /* Extract. Size 8.  */
18903  NUF(vext,      0b00000, 4, (RNDQ, oRNDQ, RNDQ, I15), neon_ext),
18904  NUF(vextq,     0b00000, 4, (RNQ,  oRNQ,  RNQ,  I15), neon_ext),
18905
18906   /* Two registers, miscellaneous.  */
18907   /* Reverse. Sizes 8 16 32 (must be < size in opcode).  */
18908  NUF(vrev64,    1b00000, 2, (RNDQ, RNDQ),     neon_rev),
18909  NUF(vrev64q,   1b00000, 2, (RNQ,  RNQ),      neon_rev),
18910  NUF(vrev32,    1b00080, 2, (RNDQ, RNDQ),     neon_rev),
18911  NUF(vrev32q,   1b00080, 2, (RNQ,  RNQ),      neon_rev),
18912  NUF(vrev16,    1b00100, 2, (RNDQ, RNDQ),     neon_rev),
18913  NUF(vrev16q,   1b00100, 2, (RNQ,  RNQ),      neon_rev),
18914   /* Vector replicate. Sizes 8 16 32.  */
18915  nCE(vdup,      _vdup,    2, (RNDQ, RR_RNSC),  neon_dup),
18916  nCE(vdupq,     _vdup,    2, (RNQ,  RR_RNSC),  neon_dup),
18917   /* VMOVL. Types S8 S16 S32 U8 U16 U32.  */
18918  NUF(vmovl,     0800a10, 2, (RNQ, RND),       neon_movl),
18919   /* VMOVN. Types I16 I32 I64.  */
18920  nUF(vmovn,     _vmovn,   2, (RND, RNQ),       neon_movn),
18921   /* VQMOVN. Types S16 S32 S64 U16 U32 U64.  */
18922  nUF(vqmovn,    _vqmovn,  2, (RND, RNQ),       neon_qmovn),
18923   /* VQMOVUN. Types S16 S32 S64.  */
18924  nUF(vqmovun,   _vqmovun, 2, (RND, RNQ),       neon_qmovun),
18925   /* VZIP / VUZP. Sizes 8 16 32.  */
18926  NUF(vzip,      1b20180, 2, (RNDQ, RNDQ),     neon_zip_uzp),
18927  NUF(vzipq,     1b20180, 2, (RNQ,  RNQ),      neon_zip_uzp),
18928  NUF(vuzp,      1b20100, 2, (RNDQ, RNDQ),     neon_zip_uzp),
18929  NUF(vuzpq,     1b20100, 2, (RNQ,  RNQ),      neon_zip_uzp),
18930   /* VQABS / VQNEG. Types S8 S16 S32.  */
18931  NUF(vqabs,     1b00700, 2, (RNDQ, RNDQ),     neon_sat_abs_neg),
18932  NUF(vqabsq,    1b00700, 2, (RNQ,  RNQ),      neon_sat_abs_neg),
18933  NUF(vqneg,     1b00780, 2, (RNDQ, RNDQ),     neon_sat_abs_neg),
18934  NUF(vqnegq,    1b00780, 2, (RNQ,  RNQ),      neon_sat_abs_neg),
18935   /* Pairwise, lengthening. Types S8 S16 S32 U8 U16 U32.  */
18936  NUF(vpadal,    1b00600, 2, (RNDQ, RNDQ),     neon_pair_long),
18937  NUF(vpadalq,   1b00600, 2, (RNQ,  RNQ),      neon_pair_long),
18938  NUF(vpaddl,    1b00200, 2, (RNDQ, RNDQ),     neon_pair_long),
18939  NUF(vpaddlq,   1b00200, 2, (RNQ,  RNQ),      neon_pair_long),
18940   /* Reciprocal estimates. Types U32 F32.  */
18941  NUF(vrecpe,    1b30400, 2, (RNDQ, RNDQ),     neon_recip_est),
18942  NUF(vrecpeq,   1b30400, 2, (RNQ,  RNQ),      neon_recip_est),
18943  NUF(vrsqrte,   1b30480, 2, (RNDQ, RNDQ),     neon_recip_est),
18944  NUF(vrsqrteq,  1b30480, 2, (RNQ,  RNQ),      neon_recip_est),
18945   /* VCLS. Types S8 S16 S32.  */
18946  NUF(vcls,      1b00400, 2, (RNDQ, RNDQ),     neon_cls),
18947  NUF(vclsq,     1b00400, 2, (RNQ,  RNQ),      neon_cls),
18948   /* VCLZ. Types I8 I16 I32.  */
18949  NUF(vclz,      1b00480, 2, (RNDQ, RNDQ),     neon_clz),
18950  NUF(vclzq,     1b00480, 2, (RNQ,  RNQ),      neon_clz),
18951   /* VCNT. Size 8.  */
18952  NUF(vcnt,      1b00500, 2, (RNDQ, RNDQ),     neon_cnt),
18953  NUF(vcntq,     1b00500, 2, (RNQ,  RNQ),      neon_cnt),
18954   /* Two address, untyped.  */
18955  NUF(vswp,      1b20000, 2, (RNDQ, RNDQ),     neon_swp),
18956  NUF(vswpq,     1b20000, 2, (RNQ,  RNQ),      neon_swp),
18957   /* VTRN. Sizes 8 16 32.  */
18958  nUF(vtrn,      _vtrn,    2, (RNDQ, RNDQ),     neon_trn),
18959  nUF(vtrnq,     _vtrn,    2, (RNQ,  RNQ),      neon_trn),
18960
18961   /* Table lookup. Size 8.  */
18962  NUF(vtbl,      1b00800, 3, (RND, NRDLST, RND), neon_tbl_tbx),
18963  NUF(vtbx,      1b00840, 3, (RND, NRDLST, RND), neon_tbl_tbx),
18964
18965 #undef  THUMB_VARIANT
18966 #define THUMB_VARIANT  & fpu_vfp_v3_or_neon_ext
18967 #undef  ARM_VARIANT
18968 #define ARM_VARIANT    & fpu_vfp_v3_or_neon_ext
18969
18970   /* Neon element/structure load/store.  */
18971  nUF(vld1,      _vld1,    2, (NSTRLST, ADDR),  neon_ldx_stx),
18972  nUF(vst1,      _vst1,    2, (NSTRLST, ADDR),  neon_ldx_stx),
18973  nUF(vld2,      _vld2,    2, (NSTRLST, ADDR),  neon_ldx_stx),
18974  nUF(vst2,      _vst2,    2, (NSTRLST, ADDR),  neon_ldx_stx),
18975  nUF(vld3,      _vld3,    2, (NSTRLST, ADDR),  neon_ldx_stx),
18976  nUF(vst3,      _vst3,    2, (NSTRLST, ADDR),  neon_ldx_stx),
18977  nUF(vld4,      _vld4,    2, (NSTRLST, ADDR),  neon_ldx_stx),
18978  nUF(vst4,      _vst4,    2, (NSTRLST, ADDR),  neon_ldx_stx),
18979
18980 #undef  THUMB_VARIANT
18981 #define THUMB_VARIANT &fpu_vfp_ext_v3xd
18982 #undef ARM_VARIANT
18983 #define ARM_VARIANT &fpu_vfp_ext_v3xd
18984  cCE("fconsts",   eb00a00, 2, (RVS, I255),      vfp_sp_const),
18985  cCE("fshtos",    eba0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
18986  cCE("fsltos",    eba0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
18987  cCE("fuhtos",    ebb0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
18988  cCE("fultos",    ebb0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
18989  cCE("ftoshs",    ebe0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
18990  cCE("ftosls",    ebe0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
18991  cCE("ftouhs",    ebf0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
18992  cCE("ftouls",    ebf0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
18993
18994 #undef THUMB_VARIANT
18995 #define THUMB_VARIANT  & fpu_vfp_ext_v3
18996 #undef  ARM_VARIANT
18997 #define ARM_VARIANT    & fpu_vfp_ext_v3
18998
18999  cCE("fconstd",   eb00b00, 2, (RVD, I255),      vfp_dp_const),
19000  cCE("fshtod",    eba0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
19001  cCE("fsltod",    eba0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
19002  cCE("fuhtod",    ebb0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
19003  cCE("fultod",    ebb0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
19004  cCE("ftoshd",    ebe0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
19005  cCE("ftosld",    ebe0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
19006  cCE("ftouhd",    ebf0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
19007  cCE("ftould",    ebf0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
19008
19009 #undef ARM_VARIANT
19010 #define ARM_VARIANT &fpu_vfp_ext_fma
19011 #undef THUMB_VARIANT
19012 #define THUMB_VARIANT &fpu_vfp_ext_fma
19013  /* Mnemonics shared by Neon and VFP.  These are included in the
19014     VFP FMA variant; NEON and VFP FMA always includes the NEON
19015     FMA instructions.  */
19016  nCEF(vfma,     _vfma,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_fmac),
19017  nCEF(vfms,     _vfms,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_fmac),
19018  /* ffmas/ffmad/ffmss/ffmsd are dummy mnemonics to satisfy gas;
19019     the v form should always be used.  */
19020  cCE("ffmas",   ea00a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
19021  cCE("ffnmas",  ea00a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
19022  cCE("ffmad",   ea00b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
19023  cCE("ffnmad",  ea00b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
19024  nCE(vfnma,     _vfnma,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
19025  nCE(vfnms,     _vfnms,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
19026
19027 #undef THUMB_VARIANT
19028 #undef  ARM_VARIANT
19029 #define ARM_VARIANT  & arm_cext_xscale /* Intel XScale extensions.  */
19030
19031  cCE("mia",     e200010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19032  cCE("miaph",   e280010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19033  cCE("miabb",   e2c0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19034  cCE("miabt",   e2d0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19035  cCE("miatb",   e2e0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19036  cCE("miatt",   e2f0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19037  cCE("mar",     c400000, 3, (RXA, RRnpc, RRnpc), xsc_mar),
19038  cCE("mra",     c500000, 3, (RRnpc, RRnpc, RXA), xsc_mra),
19039
19040 #undef  ARM_VARIANT
19041 #define ARM_VARIANT  & arm_cext_iwmmxt /* Intel Wireless MMX technology.  */
19042
19043  cCE("tandcb",  e13f130, 1, (RR),                   iwmmxt_tandorc),
19044  cCE("tandch",  e53f130, 1, (RR),                   iwmmxt_tandorc),
19045  cCE("tandcw",  e93f130, 1, (RR),                   iwmmxt_tandorc),
19046  cCE("tbcstb",  e400010, 2, (RIWR, RR),             rn_rd),
19047  cCE("tbcsth",  e400050, 2, (RIWR, RR),             rn_rd),
19048  cCE("tbcstw",  e400090, 2, (RIWR, RR),             rn_rd),
19049  cCE("textrcb", e130170, 2, (RR, I7),               iwmmxt_textrc),
19050  cCE("textrch", e530170, 2, (RR, I7),               iwmmxt_textrc),
19051  cCE("textrcw", e930170, 2, (RR, I7),               iwmmxt_textrc),
19052  cCE("textrmub",        e100070, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19053  cCE("textrmuh",        e500070, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19054  cCE("textrmuw",        e900070, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19055  cCE("textrmsb",        e100078, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19056  cCE("textrmsh",        e500078, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19057  cCE("textrmsw",        e900078, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19058  cCE("tinsrb",  e600010, 3, (RIWR, RR, I7),         iwmmxt_tinsr),
19059  cCE("tinsrh",  e600050, 3, (RIWR, RR, I7),         iwmmxt_tinsr),
19060  cCE("tinsrw",  e600090, 3, (RIWR, RR, I7),         iwmmxt_tinsr),
19061  cCE("tmcr",    e000110, 2, (RIWC_RIWG, RR),        rn_rd),
19062  cCE("tmcrr",   c400000, 3, (RIWR, RR, RR),         rm_rd_rn),
19063  cCE("tmia",    e200010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19064  cCE("tmiaph",  e280010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19065  cCE("tmiabb",  e2c0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19066  cCE("tmiabt",  e2d0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19067  cCE("tmiatb",  e2e0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19068  cCE("tmiatt",  e2f0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19069  cCE("tmovmskb",        e100030, 2, (RR, RIWR),             rd_rn),
19070  cCE("tmovmskh",        e500030, 2, (RR, RIWR),             rd_rn),
19071  cCE("tmovmskw",        e900030, 2, (RR, RIWR),             rd_rn),
19072  cCE("tmrc",    e100110, 2, (RR, RIWC_RIWG),        rd_rn),
19073  cCE("tmrrc",   c500000, 3, (RR, RR, RIWR),         rd_rn_rm),
19074  cCE("torcb",   e13f150, 1, (RR),                   iwmmxt_tandorc),
19075  cCE("torch",   e53f150, 1, (RR),                   iwmmxt_tandorc),
19076  cCE("torcw",   e93f150, 1, (RR),                   iwmmxt_tandorc),
19077  cCE("waccb",   e0001c0, 2, (RIWR, RIWR),           rd_rn),
19078  cCE("wacch",   e4001c0, 2, (RIWR, RIWR),           rd_rn),
19079  cCE("waccw",   e8001c0, 2, (RIWR, RIWR),           rd_rn),
19080  cCE("waddbss", e300180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19081  cCE("waddb",   e000180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19082  cCE("waddbus", e100180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19083  cCE("waddhss", e700180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19084  cCE("waddh",   e400180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19085  cCE("waddhus", e500180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19086  cCE("waddwss", eb00180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19087  cCE("waddw",   e800180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19088  cCE("waddwus", e900180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19089  cCE("waligni", e000020, 4, (RIWR, RIWR, RIWR, I7), iwmmxt_waligni),
19090  cCE("walignr0",        e800020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19091  cCE("walignr1",        e900020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19092  cCE("walignr2",        ea00020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19093  cCE("walignr3",        eb00020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19094  cCE("wand",    e200000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19095  cCE("wandn",   e300000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19096  cCE("wavg2b",  e800000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19097  cCE("wavg2br", e900000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19098  cCE("wavg2h",  ec00000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19099  cCE("wavg2hr", ed00000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19100  cCE("wcmpeqb", e000060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19101  cCE("wcmpeqh", e400060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19102  cCE("wcmpeqw", e800060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19103  cCE("wcmpgtub",        e100060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19104  cCE("wcmpgtuh",        e500060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19105  cCE("wcmpgtuw",        e900060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19106  cCE("wcmpgtsb",        e300060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19107  cCE("wcmpgtsh",        e700060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19108  cCE("wcmpgtsw",        eb00060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19109  cCE("wldrb",   c100000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
19110  cCE("wldrh",   c500000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
19111  cCE("wldrw",   c100100, 2, (RIWR_RIWC, ADDR),      iwmmxt_wldstw),
19112  cCE("wldrd",   c500100, 2, (RIWR, ADDR),           iwmmxt_wldstd),
19113  cCE("wmacs",   e600100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19114  cCE("wmacsz",  e700100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19115  cCE("wmacu",   e400100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19116  cCE("wmacuz",  e500100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19117  cCE("wmadds",  ea00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19118  cCE("wmaddu",  e800100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19119  cCE("wmaxsb",  e200160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19120  cCE("wmaxsh",  e600160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19121  cCE("wmaxsw",  ea00160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19122  cCE("wmaxub",  e000160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19123  cCE("wmaxuh",  e400160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19124  cCE("wmaxuw",  e800160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19125  cCE("wminsb",  e300160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19126  cCE("wminsh",  e700160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19127  cCE("wminsw",  eb00160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19128  cCE("wminub",  e100160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19129  cCE("wminuh",  e500160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19130  cCE("wminuw",  e900160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19131  cCE("wmov",    e000000, 2, (RIWR, RIWR),           iwmmxt_wmov),
19132  cCE("wmulsm",  e300100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19133  cCE("wmulsl",  e200100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19134  cCE("wmulum",  e100100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19135  cCE("wmulul",  e000100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19136  cCE("wor",     e000000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19137  cCE("wpackhss",        e700080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19138  cCE("wpackhus",        e500080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19139  cCE("wpackwss",        eb00080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19140  cCE("wpackwus",        e900080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19141  cCE("wpackdss",        ef00080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19142  cCE("wpackdus",        ed00080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19143  cCE("wrorh",   e700040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19144  cCE("wrorhg",  e700148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19145  cCE("wrorw",   eb00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19146  cCE("wrorwg",  eb00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19147  cCE("wrord",   ef00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19148  cCE("wrordg",  ef00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19149  cCE("wsadb",   e000120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19150  cCE("wsadbz",  e100120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19151  cCE("wsadh",   e400120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19152  cCE("wsadhz",  e500120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19153  cCE("wshufh",  e0001e0, 3, (RIWR, RIWR, I255),     iwmmxt_wshufh),
19154  cCE("wsllh",   e500040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19155  cCE("wsllhg",  e500148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19156  cCE("wsllw",   e900040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19157  cCE("wsllwg",  e900148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19158  cCE("wslld",   ed00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19159  cCE("wslldg",  ed00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19160  cCE("wsrah",   e400040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19161  cCE("wsrahg",  e400148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19162  cCE("wsraw",   e800040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19163  cCE("wsrawg",  e800148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19164  cCE("wsrad",   ec00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19165  cCE("wsradg",  ec00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19166  cCE("wsrlh",   e600040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19167  cCE("wsrlhg",  e600148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19168  cCE("wsrlw",   ea00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19169  cCE("wsrlwg",  ea00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19170  cCE("wsrld",   ee00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19171  cCE("wsrldg",  ee00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19172  cCE("wstrb",   c000000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
19173  cCE("wstrh",   c400000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
19174  cCE("wstrw",   c000100, 2, (RIWR_RIWC, ADDR),      iwmmxt_wldstw),
19175  cCE("wstrd",   c400100, 2, (RIWR, ADDR),           iwmmxt_wldstd),
19176  cCE("wsubbss", e3001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19177  cCE("wsubb",   e0001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19178  cCE("wsubbus", e1001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19179  cCE("wsubhss", e7001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19180  cCE("wsubh",   e4001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19181  cCE("wsubhus", e5001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19182  cCE("wsubwss", eb001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19183  cCE("wsubw",   e8001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19184  cCE("wsubwus", e9001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19185  cCE("wunpckehub",e0000c0, 2, (RIWR, RIWR),         rd_rn),
19186  cCE("wunpckehuh",e4000c0, 2, (RIWR, RIWR),         rd_rn),
19187  cCE("wunpckehuw",e8000c0, 2, (RIWR, RIWR),         rd_rn),
19188  cCE("wunpckehsb",e2000c0, 2, (RIWR, RIWR),         rd_rn),
19189  cCE("wunpckehsh",e6000c0, 2, (RIWR, RIWR),         rd_rn),
19190  cCE("wunpckehsw",ea000c0, 2, (RIWR, RIWR),         rd_rn),
19191  cCE("wunpckihb", e1000c0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19192  cCE("wunpckihh", e5000c0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19193  cCE("wunpckihw", e9000c0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19194  cCE("wunpckelub",e0000e0, 2, (RIWR, RIWR),         rd_rn),
19195  cCE("wunpckeluh",e4000e0, 2, (RIWR, RIWR),         rd_rn),
19196  cCE("wunpckeluw",e8000e0, 2, (RIWR, RIWR),         rd_rn),
19197  cCE("wunpckelsb",e2000e0, 2, (RIWR, RIWR),         rd_rn),
19198  cCE("wunpckelsh",e6000e0, 2, (RIWR, RIWR),         rd_rn),
19199  cCE("wunpckelsw",ea000e0, 2, (RIWR, RIWR),         rd_rn),
19200  cCE("wunpckilb", e1000e0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19201  cCE("wunpckilh", e5000e0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19202  cCE("wunpckilw", e9000e0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19203  cCE("wxor",    e100000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19204  cCE("wzero",   e300000, 1, (RIWR),                 iwmmxt_wzero),
19205
19206 #undef  ARM_VARIANT
19207 #define ARM_VARIANT  & arm_cext_iwmmxt2 /* Intel Wireless MMX technology, version 2.  */
19208
19209  cCE("torvscb",   e12f190, 1, (RR),                 iwmmxt_tandorc),
19210  cCE("torvsch",   e52f190, 1, (RR),                 iwmmxt_tandorc),
19211  cCE("torvscw",   e92f190, 1, (RR),                 iwmmxt_tandorc),
19212  cCE("wabsb",     e2001c0, 2, (RIWR, RIWR),           rd_rn),
19213  cCE("wabsh",     e6001c0, 2, (RIWR, RIWR),           rd_rn),
19214  cCE("wabsw",     ea001c0, 2, (RIWR, RIWR),           rd_rn),
19215  cCE("wabsdiffb", e1001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19216  cCE("wabsdiffh", e5001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19217  cCE("wabsdiffw", e9001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19218  cCE("waddbhusl", e2001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19219  cCE("waddbhusm", e6001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19220  cCE("waddhc",    e600180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19221  cCE("waddwc",    ea00180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19222  cCE("waddsubhx", ea001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19223  cCE("wavg4",   e400000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19224  cCE("wavg4r",    e500000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19225  cCE("wmaddsn",   ee00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19226  cCE("wmaddsx",   eb00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19227  cCE("wmaddun",   ec00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19228  cCE("wmaddux",   e900100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19229  cCE("wmerge",    e000080, 4, (RIWR, RIWR, RIWR, I7), iwmmxt_wmerge),
19230  cCE("wmiabb",    e0000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19231  cCE("wmiabt",    e1000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19232  cCE("wmiatb",    e2000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19233  cCE("wmiatt",    e3000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19234  cCE("wmiabbn",   e4000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19235  cCE("wmiabtn",   e5000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19236  cCE("wmiatbn",   e6000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19237  cCE("wmiattn",   e7000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19238  cCE("wmiawbb",   e800120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19239  cCE("wmiawbt",   e900120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19240  cCE("wmiawtb",   ea00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19241  cCE("wmiawtt",   eb00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19242  cCE("wmiawbbn",  ec00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19243  cCE("wmiawbtn",  ed00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19244  cCE("wmiawtbn",  ee00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19245  cCE("wmiawttn",  ef00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19246  cCE("wmulsmr",   ef00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19247  cCE("wmulumr",   ed00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19248  cCE("wmulwumr",  ec000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19249  cCE("wmulwsmr",  ee000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19250  cCE("wmulwum",   ed000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19251  cCE("wmulwsm",   ef000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19252  cCE("wmulwl",    eb000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19253  cCE("wqmiabb",   e8000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19254  cCE("wqmiabt",   e9000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19255  cCE("wqmiatb",   ea000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19256  cCE("wqmiatt",   eb000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19257  cCE("wqmiabbn",  ec000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19258  cCE("wqmiabtn",  ed000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19259  cCE("wqmiatbn",  ee000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19260  cCE("wqmiattn",  ef000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19261  cCE("wqmulm",    e100080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19262  cCE("wqmulmr",   e300080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19263  cCE("wqmulwm",   ec000e0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19264  cCE("wqmulwmr",  ee000e0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19265  cCE("wsubaddhx", ed001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19266
19267 #undef  ARM_VARIANT
19268 #define ARM_VARIANT  & arm_cext_maverick /* Cirrus Maverick instructions.  */
19269
19270  cCE("cfldrs",  c100400, 2, (RMF, ADDRGLDC),          rd_cpaddr),
19271  cCE("cfldrd",  c500400, 2, (RMD, ADDRGLDC),          rd_cpaddr),
19272  cCE("cfldr32", c100500, 2, (RMFX, ADDRGLDC),         rd_cpaddr),
19273  cCE("cfldr64", c500500, 2, (RMDX, ADDRGLDC),         rd_cpaddr),
19274  cCE("cfstrs",  c000400, 2, (RMF, ADDRGLDC),          rd_cpaddr),
19275  cCE("cfstrd",  c400400, 2, (RMD, ADDRGLDC),          rd_cpaddr),
19276  cCE("cfstr32", c000500, 2, (RMFX, ADDRGLDC),         rd_cpaddr),
19277  cCE("cfstr64", c400500, 2, (RMDX, ADDRGLDC),         rd_cpaddr),
19278  cCE("cfmvsr",  e000450, 2, (RMF, RR),                rn_rd),
19279  cCE("cfmvrs",  e100450, 2, (RR, RMF),                rd_rn),
19280  cCE("cfmvdlr", e000410, 2, (RMD, RR),                rn_rd),
19281  cCE("cfmvrdl", e100410, 2, (RR, RMD),                rd_rn),
19282  cCE("cfmvdhr", e000430, 2, (RMD, RR),                rn_rd),
19283  cCE("cfmvrdh", e100430, 2, (RR, RMD),                rd_rn),
19284  cCE("cfmv64lr",        e000510, 2, (RMDX, RR),               rn_rd),
19285  cCE("cfmvr64l",        e100510, 2, (RR, RMDX),               rd_rn),
19286  cCE("cfmv64hr",        e000530, 2, (RMDX, RR),               rn_rd),
19287  cCE("cfmvr64h",        e100530, 2, (RR, RMDX),               rd_rn),
19288  cCE("cfmval32",        e200440, 2, (RMAX, RMFX),             rd_rn),
19289  cCE("cfmv32al",        e100440, 2, (RMFX, RMAX),             rd_rn),
19290  cCE("cfmvam32",        e200460, 2, (RMAX, RMFX),             rd_rn),
19291  cCE("cfmv32am",        e100460, 2, (RMFX, RMAX),             rd_rn),
19292  cCE("cfmvah32",        e200480, 2, (RMAX, RMFX),             rd_rn),
19293  cCE("cfmv32ah",        e100480, 2, (RMFX, RMAX),             rd_rn),
19294  cCE("cfmva32", e2004a0, 2, (RMAX, RMFX),             rd_rn),
19295  cCE("cfmv32a", e1004a0, 2, (RMFX, RMAX),             rd_rn),
19296  cCE("cfmva64", e2004c0, 2, (RMAX, RMDX),             rd_rn),
19297  cCE("cfmv64a", e1004c0, 2, (RMDX, RMAX),             rd_rn),
19298  cCE("cfmvsc32",        e2004e0, 2, (RMDS, RMDX),             mav_dspsc),
19299  cCE("cfmv32sc",        e1004e0, 2, (RMDX, RMDS),             rd),
19300  cCE("cfcpys",  e000400, 2, (RMF, RMF),               rd_rn),
19301  cCE("cfcpyd",  e000420, 2, (RMD, RMD),               rd_rn),
19302  cCE("cfcvtsd", e000460, 2, (RMD, RMF),               rd_rn),
19303  cCE("cfcvtds", e000440, 2, (RMF, RMD),               rd_rn),
19304  cCE("cfcvt32s",        e000480, 2, (RMF, RMFX),              rd_rn),
19305  cCE("cfcvt32d",        e0004a0, 2, (RMD, RMFX),              rd_rn),
19306  cCE("cfcvt64s",        e0004c0, 2, (RMF, RMDX),              rd_rn),
19307  cCE("cfcvt64d",        e0004e0, 2, (RMD, RMDX),              rd_rn),
19308  cCE("cfcvts32",        e100580, 2, (RMFX, RMF),              rd_rn),
19309  cCE("cfcvtd32",        e1005a0, 2, (RMFX, RMD),              rd_rn),
19310  cCE("cftruncs32",e1005c0, 2, (RMFX, RMF),            rd_rn),
19311  cCE("cftruncd32",e1005e0, 2, (RMFX, RMD),            rd_rn),
19312  cCE("cfrshl32",        e000550, 3, (RMFX, RMFX, RR),         mav_triple),
19313  cCE("cfrshl64",        e000570, 3, (RMDX, RMDX, RR),         mav_triple),
19314  cCE("cfsh32",  e000500, 3, (RMFX, RMFX, I63s),       mav_shift),
19315  cCE("cfsh64",  e200500, 3, (RMDX, RMDX, I63s),       mav_shift),
19316  cCE("cfcmps",  e100490, 3, (RR, RMF, RMF),           rd_rn_rm),
19317  cCE("cfcmpd",  e1004b0, 3, (RR, RMD, RMD),           rd_rn_rm),
19318  cCE("cfcmp32", e100590, 3, (RR, RMFX, RMFX),         rd_rn_rm),
19319  cCE("cfcmp64", e1005b0, 3, (RR, RMDX, RMDX),         rd_rn_rm),
19320  cCE("cfabss",  e300400, 2, (RMF, RMF),               rd_rn),
19321  cCE("cfabsd",  e300420, 2, (RMD, RMD),               rd_rn),
19322  cCE("cfnegs",  e300440, 2, (RMF, RMF),               rd_rn),
19323  cCE("cfnegd",  e300460, 2, (RMD, RMD),               rd_rn),
19324  cCE("cfadds",  e300480, 3, (RMF, RMF, RMF),          rd_rn_rm),
19325  cCE("cfaddd",  e3004a0, 3, (RMD, RMD, RMD),          rd_rn_rm),
19326  cCE("cfsubs",  e3004c0, 3, (RMF, RMF, RMF),          rd_rn_rm),
19327  cCE("cfsubd",  e3004e0, 3, (RMD, RMD, RMD),          rd_rn_rm),
19328  cCE("cfmuls",  e100400, 3, (RMF, RMF, RMF),          rd_rn_rm),
19329  cCE("cfmuld",  e100420, 3, (RMD, RMD, RMD),          rd_rn_rm),
19330  cCE("cfabs32", e300500, 2, (RMFX, RMFX),             rd_rn),
19331  cCE("cfabs64", e300520, 2, (RMDX, RMDX),             rd_rn),
19332  cCE("cfneg32", e300540, 2, (RMFX, RMFX),             rd_rn),
19333  cCE("cfneg64", e300560, 2, (RMDX, RMDX),             rd_rn),
19334  cCE("cfadd32", e300580, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
19335  cCE("cfadd64", e3005a0, 3, (RMDX, RMDX, RMDX),       rd_rn_rm),
19336  cCE("cfsub32", e3005c0, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
19337  cCE("cfsub64", e3005e0, 3, (RMDX, RMDX, RMDX),       rd_rn_rm),
19338  cCE("cfmul32", e100500, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
19339  cCE("cfmul64", e100520, 3, (RMDX, RMDX, RMDX),       rd_rn_rm),
19340  cCE("cfmac32", e100540, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
19341  cCE("cfmsc32", e100560, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
19342  cCE("cfmadd32",        e000600, 4, (RMAX, RMFX, RMFX, RMFX), mav_quad),
19343  cCE("cfmsub32",        e100600, 4, (RMAX, RMFX, RMFX, RMFX), mav_quad),
19344  cCE("cfmadda32", e200600, 4, (RMAX, RMAX, RMFX, RMFX), mav_quad),
19345  cCE("cfmsuba32", e300600, 4, (RMAX, RMAX, RMFX, RMFX), mav_quad),
19346 };
19347 #undef ARM_VARIANT
19348 #undef THUMB_VARIANT
19349 #undef TCE
19350 #undef TCM
19351 #undef TUE
19352 #undef TUF
19353 #undef TCC
19354 #undef cCE
19355 #undef cCL
19356 #undef C3E
19357 #undef CE
19358 #undef CM
19359 #undef UE
19360 #undef UF
19361 #undef UT
19362 #undef NUF
19363 #undef nUF
19364 #undef NCE
19365 #undef nCE
19366 #undef OPS0
19367 #undef OPS1
19368 #undef OPS2
19369 #undef OPS3
19370 #undef OPS4
19371 #undef OPS5
19372 #undef OPS6
19373 #undef do_0
19374 \f
19375 /* MD interface: bits in the object file.  */
19376
19377 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
19378    for use in the a.out file, and stores them in the array pointed to by buf.
19379    This knows about the endian-ness of the target machine and does
19380    THE RIGHT THING, whatever it is.  Possible values for n are 1 (byte)
19381    2 (short) and 4 (long)  Floating numbers are put out as a series of
19382    LITTLENUMS (shorts, here at least).  */
19383
19384 void
19385 md_number_to_chars (char * buf, valueT val, int n)
19386 {
19387   if (target_big_endian)
19388     number_to_chars_bigendian (buf, val, n);
19389   else
19390     number_to_chars_littleendian (buf, val, n);
19391 }
19392
19393 static valueT
19394 md_chars_to_number (char * buf, int n)
19395 {
19396   valueT result = 0;
19397   unsigned char * where = (unsigned char *) buf;
19398
19399   if (target_big_endian)
19400     {
19401       while (n--)
19402         {
19403           result <<= 8;
19404           result |= (*where++ & 255);
19405         }
19406     }
19407   else
19408     {
19409       while (n--)
19410         {
19411           result <<= 8;
19412           result |= (where[n] & 255);
19413         }
19414     }
19415
19416   return result;
19417 }
19418
19419 /* MD interface: Sections.  */
19420
19421 /* Calculate the maximum variable size (i.e., excluding fr_fix)
19422    that an rs_machine_dependent frag may reach.  */
19423
19424 unsigned int
19425 arm_frag_max_var (fragS *fragp)
19426 {
19427   /* We only use rs_machine_dependent for variable-size Thumb instructions,
19428      which are either THUMB_SIZE (2) or INSN_SIZE (4).
19429
19430      Note that we generate relaxable instructions even for cases that don't
19431      really need it, like an immediate that's a trivial constant.  So we're
19432      overestimating the instruction size for some of those cases.  Rather
19433      than putting more intelligence here, it would probably be better to
19434      avoid generating a relaxation frag in the first place when it can be
19435      determined up front that a short instruction will suffice.  */
19436
19437   gas_assert (fragp->fr_type == rs_machine_dependent);
19438   return INSN_SIZE;
19439 }
19440
19441 /* Estimate the size of a frag before relaxing.  Assume everything fits in
19442    2 bytes.  */
19443
19444 int
19445 md_estimate_size_before_relax (fragS * fragp,
19446                                segT    segtype ATTRIBUTE_UNUSED)
19447 {
19448   fragp->fr_var = 2;
19449   return 2;
19450 }
19451
19452 /* Convert a machine dependent frag.  */
19453
19454 void
19455 md_convert_frag (bfd *abfd, segT asec ATTRIBUTE_UNUSED, fragS *fragp)
19456 {
19457   unsigned long insn;
19458   unsigned long old_op;
19459   char *buf;
19460   expressionS exp;
19461   fixS *fixp;
19462   int reloc_type;
19463   int pc_rel;
19464   int opcode;
19465
19466   buf = fragp->fr_literal + fragp->fr_fix;
19467
19468   old_op = bfd_get_16(abfd, buf);
19469   if (fragp->fr_symbol)
19470     {
19471       exp.X_op = O_symbol;
19472       exp.X_add_symbol = fragp->fr_symbol;
19473     }
19474   else
19475     {
19476       exp.X_op = O_constant;
19477     }
19478   exp.X_add_number = fragp->fr_offset;
19479   opcode = fragp->fr_subtype;
19480   switch (opcode)
19481     {
19482     case T_MNEM_ldr_pc:
19483     case T_MNEM_ldr_pc2:
19484     case T_MNEM_ldr_sp:
19485     case T_MNEM_str_sp:
19486     case T_MNEM_ldr:
19487     case T_MNEM_ldrb:
19488     case T_MNEM_ldrh:
19489     case T_MNEM_str:
19490     case T_MNEM_strb:
19491     case T_MNEM_strh:
19492       if (fragp->fr_var == 4)
19493         {
19494           insn = THUMB_OP32 (opcode);
19495           if ((old_op >> 12) == 4 || (old_op >> 12) == 9)
19496             {
19497               insn |= (old_op & 0x700) << 4;
19498             }
19499           else
19500             {
19501               insn |= (old_op & 7) << 12;
19502               insn |= (old_op & 0x38) << 13;
19503             }
19504           insn |= 0x00000c00;
19505           put_thumb32_insn (buf, insn);
19506           reloc_type = BFD_RELOC_ARM_T32_OFFSET_IMM;
19507         }
19508       else
19509         {
19510           reloc_type = BFD_RELOC_ARM_THUMB_OFFSET;
19511         }
19512       pc_rel = (opcode == T_MNEM_ldr_pc2);
19513       break;
19514     case T_MNEM_adr:
19515       if (fragp->fr_var == 4)
19516         {
19517           insn = THUMB_OP32 (opcode);
19518           insn |= (old_op & 0xf0) << 4;
19519           put_thumb32_insn (buf, insn);
19520           reloc_type = BFD_RELOC_ARM_T32_ADD_PC12;
19521         }
19522       else
19523         {
19524           reloc_type = BFD_RELOC_ARM_THUMB_ADD;
19525           exp.X_add_number -= 4;
19526         }
19527       pc_rel = 1;
19528       break;
19529     case T_MNEM_mov:
19530     case T_MNEM_movs:
19531     case T_MNEM_cmp:
19532     case T_MNEM_cmn:
19533       if (fragp->fr_var == 4)
19534         {
19535           int r0off = (opcode == T_MNEM_mov
19536                        || opcode == T_MNEM_movs) ? 0 : 8;
19537           insn = THUMB_OP32 (opcode);
19538           insn = (insn & 0xe1ffffff) | 0x10000000;
19539           insn |= (old_op & 0x700) << r0off;
19540           put_thumb32_insn (buf, insn);
19541           reloc_type = BFD_RELOC_ARM_T32_IMMEDIATE;
19542         }
19543       else
19544         {
19545           reloc_type = BFD_RELOC_ARM_THUMB_IMM;
19546         }
19547       pc_rel = 0;
19548       break;
19549     case T_MNEM_b:
19550       if (fragp->fr_var == 4)
19551         {
19552           insn = THUMB_OP32(opcode);
19553           put_thumb32_insn (buf, insn);
19554           reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH25;
19555         }
19556       else
19557         reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH12;
19558       pc_rel = 1;
19559       break;
19560     case T_MNEM_bcond:
19561       if (fragp->fr_var == 4)
19562         {
19563           insn = THUMB_OP32(opcode);
19564           insn |= (old_op & 0xf00) << 14;
19565           put_thumb32_insn (buf, insn);
19566           reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH20;
19567         }
19568       else
19569         reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH9;
19570       pc_rel = 1;
19571       break;
19572     case T_MNEM_add_sp:
19573     case T_MNEM_add_pc:
19574     case T_MNEM_inc_sp:
19575     case T_MNEM_dec_sp:
19576       if (fragp->fr_var == 4)
19577         {
19578           /* ??? Choose between add and addw.  */
19579           insn = THUMB_OP32 (opcode);
19580           insn |= (old_op & 0xf0) << 4;
19581           put_thumb32_insn (buf, insn);
19582           if (opcode == T_MNEM_add_pc)
19583             reloc_type = BFD_RELOC_ARM_T32_IMM12;
19584           else
19585             reloc_type = BFD_RELOC_ARM_T32_ADD_IMM;
19586         }
19587       else
19588         reloc_type = BFD_RELOC_ARM_THUMB_ADD;
19589       pc_rel = 0;
19590       break;
19591
19592     case T_MNEM_addi:
19593     case T_MNEM_addis:
19594     case T_MNEM_subi:
19595     case T_MNEM_subis:
19596       if (fragp->fr_var == 4)
19597         {
19598           insn = THUMB_OP32 (opcode);
19599           insn |= (old_op & 0xf0) << 4;
19600           insn |= (old_op & 0xf) << 16;
19601           put_thumb32_insn (buf, insn);
19602           if (insn & (1 << 20))
19603             reloc_type = BFD_RELOC_ARM_T32_ADD_IMM;
19604           else
19605             reloc_type = BFD_RELOC_ARM_T32_IMMEDIATE;
19606         }
19607       else
19608         reloc_type = BFD_RELOC_ARM_THUMB_ADD;
19609       pc_rel = 0;
19610       break;
19611     default:
19612       abort ();
19613     }
19614   fixp = fix_new_exp (fragp, fragp->fr_fix, fragp->fr_var, &exp, pc_rel,
19615                       (enum bfd_reloc_code_real) reloc_type);
19616   fixp->fx_file = fragp->fr_file;
19617   fixp->fx_line = fragp->fr_line;
19618   fragp->fr_fix += fragp->fr_var;
19619 }
19620
19621 /* Return the size of a relaxable immediate operand instruction.
19622    SHIFT and SIZE specify the form of the allowable immediate.  */
19623 static int
19624 relax_immediate (fragS *fragp, int size, int shift)
19625 {
19626   offsetT offset;
19627   offsetT mask;
19628   offsetT low;
19629
19630   /* ??? Should be able to do better than this.  */
19631   if (fragp->fr_symbol)
19632     return 4;
19633
19634   low = (1 << shift) - 1;
19635   mask = (1 << (shift + size)) - (1 << shift);
19636   offset = fragp->fr_offset;
19637   /* Force misaligned offsets to 32-bit variant.  */
19638   if (offset & low)
19639     return 4;
19640   if (offset & ~mask)
19641     return 4;
19642   return 2;
19643 }
19644
19645 /* Get the address of a symbol during relaxation.  */
19646 static addressT
19647 relaxed_symbol_addr (fragS *fragp, long stretch)
19648 {
19649   fragS *sym_frag;
19650   addressT addr;
19651   symbolS *sym;
19652
19653   sym = fragp->fr_symbol;
19654   sym_frag = symbol_get_frag (sym);
19655   know (S_GET_SEGMENT (sym) != absolute_section
19656         || sym_frag == &zero_address_frag);
19657   addr = S_GET_VALUE (sym) + fragp->fr_offset;
19658
19659   /* If frag has yet to be reached on this pass, assume it will
19660      move by STRETCH just as we did.  If this is not so, it will
19661      be because some frag between grows, and that will force
19662      another pass.  */
19663
19664   if (stretch != 0
19665       && sym_frag->relax_marker != fragp->relax_marker)
19666     {
19667       fragS *f;
19668
19669       /* Adjust stretch for any alignment frag.  Note that if have
19670          been expanding the earlier code, the symbol may be
19671          defined in what appears to be an earlier frag.  FIXME:
19672          This doesn't handle the fr_subtype field, which specifies
19673          a maximum number of bytes to skip when doing an
19674          alignment.  */
19675       for (f = fragp; f != NULL && f != sym_frag; f = f->fr_next)
19676         {
19677           if (f->fr_type == rs_align || f->fr_type == rs_align_code)
19678             {
19679               if (stretch < 0)
19680                 stretch = - ((- stretch)
19681                              & ~ ((1 << (int) f->fr_offset) - 1));
19682               else
19683                 stretch &= ~ ((1 << (int) f->fr_offset) - 1);
19684               if (stretch == 0)
19685                 break;
19686             }
19687         }
19688       if (f != NULL)
19689         addr += stretch;
19690     }
19691
19692   return addr;
19693 }
19694
19695 /* Return the size of a relaxable adr pseudo-instruction or PC-relative
19696    load.  */
19697 static int
19698 relax_adr (fragS *fragp, asection *sec, long stretch)
19699 {
19700   addressT addr;
19701   offsetT val;
19702
19703   /* Assume worst case for symbols not known to be in the same section.  */
19704   if (fragp->fr_symbol == NULL
19705       || !S_IS_DEFINED (fragp->fr_symbol)
19706       || sec != S_GET_SEGMENT (fragp->fr_symbol)
19707       || S_IS_WEAK (fragp->fr_symbol))
19708     return 4;
19709
19710   val = relaxed_symbol_addr (fragp, stretch);
19711   addr = fragp->fr_address + fragp->fr_fix;
19712   addr = (addr + 4) & ~3;
19713   /* Force misaligned targets to 32-bit variant.  */
19714   if (val & 3)
19715     return 4;
19716   val -= addr;
19717   if (val < 0 || val > 1020)
19718     return 4;
19719   return 2;
19720 }
19721
19722 /* Return the size of a relaxable add/sub immediate instruction.  */
19723 static int
19724 relax_addsub (fragS *fragp, asection *sec)
19725 {
19726   char *buf;
19727   int op;
19728
19729   buf = fragp->fr_literal + fragp->fr_fix;
19730   op = bfd_get_16(sec->owner, buf);
19731   if ((op & 0xf) == ((op >> 4) & 0xf))
19732     return relax_immediate (fragp, 8, 0);
19733   else
19734     return relax_immediate (fragp, 3, 0);
19735 }
19736
19737
19738 /* Return the size of a relaxable branch instruction.  BITS is the
19739    size of the offset field in the narrow instruction.  */
19740
19741 static int
19742 relax_branch (fragS *fragp, asection *sec, int bits, long stretch)
19743 {
19744   addressT addr;
19745   offsetT val;
19746   offsetT limit;
19747
19748   /* Assume worst case for symbols not known to be in the same section.  */
19749   if (!S_IS_DEFINED (fragp->fr_symbol)
19750       || sec != S_GET_SEGMENT (fragp->fr_symbol)
19751       || S_IS_WEAK (fragp->fr_symbol))
19752     return 4;
19753
19754 #ifdef OBJ_ELF
19755   if (S_IS_DEFINED (fragp->fr_symbol)
19756       && ARM_IS_FUNC (fragp->fr_symbol))
19757       return 4;
19758
19759   /* PR 12532.  Global symbols with default visibility might
19760      be preempted, so do not relax relocations to them.  */
19761   if ((ELF_ST_VISIBILITY (S_GET_OTHER (fragp->fr_symbol)) == STV_DEFAULT)
19762       && (! S_IS_LOCAL (fragp->fr_symbol)))
19763     return 4;
19764 #endif
19765
19766   val = relaxed_symbol_addr (fragp, stretch);
19767   addr = fragp->fr_address + fragp->fr_fix + 4;
19768   val -= addr;
19769
19770   /* Offset is a signed value *2 */
19771   limit = 1 << bits;
19772   if (val >= limit || val < -limit)
19773     return 4;
19774   return 2;
19775 }
19776
19777
19778 /* Relax a machine dependent frag.  This returns the amount by which
19779    the current size of the frag should change.  */
19780
19781 int
19782 arm_relax_frag (asection *sec, fragS *fragp, long stretch)
19783 {
19784   int oldsize;
19785   int newsize;
19786
19787   oldsize = fragp->fr_var;
19788   switch (fragp->fr_subtype)
19789     {
19790     case T_MNEM_ldr_pc2:
19791       newsize = relax_adr (fragp, sec, stretch);
19792       break;
19793     case T_MNEM_ldr_pc:
19794     case T_MNEM_ldr_sp:
19795     case T_MNEM_str_sp:
19796       newsize = relax_immediate (fragp, 8, 2);
19797       break;
19798     case T_MNEM_ldr:
19799     case T_MNEM_str:
19800       newsize = relax_immediate (fragp, 5, 2);
19801       break;
19802     case T_MNEM_ldrh:
19803     case T_MNEM_strh:
19804       newsize = relax_immediate (fragp, 5, 1);
19805       break;
19806     case T_MNEM_ldrb:
19807     case T_MNEM_strb:
19808       newsize = relax_immediate (fragp, 5, 0);
19809       break;
19810     case T_MNEM_adr:
19811       newsize = relax_adr (fragp, sec, stretch);
19812       break;
19813     case T_MNEM_mov:
19814     case T_MNEM_movs:
19815     case T_MNEM_cmp:
19816     case T_MNEM_cmn:
19817       newsize = relax_immediate (fragp, 8, 0);
19818       break;
19819     case T_MNEM_b:
19820       newsize = relax_branch (fragp, sec, 11, stretch);
19821       break;
19822     case T_MNEM_bcond:
19823       newsize = relax_branch (fragp, sec, 8, stretch);
19824       break;
19825     case T_MNEM_add_sp:
19826     case T_MNEM_add_pc:
19827       newsize = relax_immediate (fragp, 8, 2);
19828       break;
19829     case T_MNEM_inc_sp:
19830     case T_MNEM_dec_sp:
19831       newsize = relax_immediate (fragp, 7, 2);
19832       break;
19833     case T_MNEM_addi:
19834     case T_MNEM_addis:
19835     case T_MNEM_subi:
19836     case T_MNEM_subis:
19837       newsize = relax_addsub (fragp, sec);
19838       break;
19839     default:
19840       abort ();
19841     }
19842
19843   fragp->fr_var = newsize;
19844   /* Freeze wide instructions that are at or before the same location as
19845      in the previous pass.  This avoids infinite loops.
19846      Don't freeze them unconditionally because targets may be artificially
19847      misaligned by the expansion of preceding frags.  */
19848   if (stretch <= 0 && newsize > 2)
19849     {
19850       md_convert_frag (sec->owner, sec, fragp);
19851       frag_wane (fragp);
19852     }
19853
19854   return newsize - oldsize;
19855 }
19856
19857 /* Round up a section size to the appropriate boundary.  */
19858
19859 valueT
19860 md_section_align (segT   segment ATTRIBUTE_UNUSED,
19861                   valueT size)
19862 {
19863 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
19864   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
19865     {
19866       /* For a.out, force the section size to be aligned.  If we don't do
19867          this, BFD will align it for us, but it will not write out the
19868          final bytes of the section.  This may be a bug in BFD, but it is
19869          easier to fix it here since that is how the other a.out targets
19870          work.  */
19871       int align;
19872
19873       align = bfd_get_section_alignment (stdoutput, segment);
19874       size = ((size + (1 << align) - 1) & ((valueT) -1 << align));
19875     }
19876 #endif
19877
19878   return size;
19879 }
19880
19881 /* This is called from HANDLE_ALIGN in write.c.  Fill in the contents
19882    of an rs_align_code fragment.  */
19883
19884 void
19885 arm_handle_align (fragS * fragP)
19886 {
19887   static char const arm_noop[2][2][4] =
19888     {
19889       {  /* ARMv1 */
19890         {0x00, 0x00, 0xa0, 0xe1},  /* LE */
19891         {0xe1, 0xa0, 0x00, 0x00},  /* BE */
19892       },
19893       {  /* ARMv6k */
19894         {0x00, 0xf0, 0x20, 0xe3},  /* LE */
19895         {0xe3, 0x20, 0xf0, 0x00},  /* BE */
19896       },
19897     };
19898   static char const thumb_noop[2][2][2] =
19899     {
19900       {  /* Thumb-1 */
19901         {0xc0, 0x46},  /* LE */
19902         {0x46, 0xc0},  /* BE */
19903       },
19904       {  /* Thumb-2 */
19905         {0x00, 0xbf},  /* LE */
19906         {0xbf, 0x00}   /* BE */
19907       }
19908     };
19909   static char const wide_thumb_noop[2][4] =
19910     {  /* Wide Thumb-2 */
19911       {0xaf, 0xf3, 0x00, 0x80},  /* LE */
19912       {0xf3, 0xaf, 0x80, 0x00},  /* BE */
19913     };
19914
19915   unsigned bytes, fix, noop_size;
19916   char * p;
19917   const char * noop;
19918   const char *narrow_noop = NULL;
19919 #ifdef OBJ_ELF
19920   enum mstate state;
19921 #endif
19922
19923   if (fragP->fr_type != rs_align_code)
19924     return;
19925
19926   bytes = fragP->fr_next->fr_address - fragP->fr_address - fragP->fr_fix;
19927   p = fragP->fr_literal + fragP->fr_fix;
19928   fix = 0;
19929
19930   if (bytes > MAX_MEM_FOR_RS_ALIGN_CODE)
19931     bytes &= MAX_MEM_FOR_RS_ALIGN_CODE;
19932
19933   gas_assert ((fragP->tc_frag_data.thumb_mode & MODE_RECORDED) != 0);
19934
19935   if (fragP->tc_frag_data.thumb_mode & (~ MODE_RECORDED))
19936     {
19937       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6t2))
19938         {
19939           narrow_noop = thumb_noop[1][target_big_endian];
19940           noop = wide_thumb_noop[target_big_endian];
19941         }
19942       else
19943         noop = thumb_noop[0][target_big_endian];
19944       noop_size = 2;
19945 #ifdef OBJ_ELF
19946       state = MAP_THUMB;
19947 #endif
19948     }
19949   else
19950     {
19951       noop = arm_noop[ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6k) != 0]
19952                      [target_big_endian];
19953       noop_size = 4;
19954 #ifdef OBJ_ELF
19955       state = MAP_ARM;
19956 #endif
19957     }
19958
19959   fragP->fr_var = noop_size;
19960
19961   if (bytes & (noop_size - 1))
19962     {
19963       fix = bytes & (noop_size - 1);
19964 #ifdef OBJ_ELF
19965       insert_data_mapping_symbol (state, fragP->fr_fix, fragP, fix);
19966 #endif
19967       memset (p, 0, fix);
19968       p += fix;
19969       bytes -= fix;
19970     }
19971
19972   if (narrow_noop)
19973     {
19974       if (bytes & noop_size)
19975         {
19976           /* Insert a narrow noop.  */
19977           memcpy (p, narrow_noop, noop_size);
19978           p += noop_size;
19979           bytes -= noop_size;
19980           fix += noop_size;
19981         }
19982
19983       /* Use wide noops for the remainder */
19984       noop_size = 4;
19985     }
19986
19987   while (bytes >= noop_size)
19988     {
19989       memcpy (p, noop, noop_size);
19990       p += noop_size;
19991       bytes -= noop_size;
19992       fix += noop_size;
19993     }
19994
19995   fragP->fr_fix += fix;
19996 }
19997
19998 /* Called from md_do_align.  Used to create an alignment
19999    frag in a code section.  */
20000
20001 void
20002 arm_frag_align_code (int n, int max)
20003 {
20004   char * p;
20005
20006   /* We assume that there will never be a requirement
20007      to support alignments greater than MAX_MEM_FOR_RS_ALIGN_CODE bytes.  */
20008   if (max > MAX_MEM_FOR_RS_ALIGN_CODE)
20009     {
20010       char err_msg[128];
20011
20012       sprintf (err_msg,
20013         _("alignments greater than %d bytes not supported in .text sections."),
20014         MAX_MEM_FOR_RS_ALIGN_CODE + 1);
20015       as_fatal ("%s", err_msg);
20016     }
20017
20018   p = frag_var (rs_align_code,
20019                 MAX_MEM_FOR_RS_ALIGN_CODE,
20020                 1,
20021                 (relax_substateT) max,
20022                 (symbolS *) NULL,
20023                 (offsetT) n,
20024                 (char *) NULL);
20025   *p = 0;
20026 }
20027
20028 /* Perform target specific initialisation of a frag.
20029    Note - despite the name this initialisation is not done when the frag
20030    is created, but only when its type is assigned.  A frag can be created
20031    and used a long time before its type is set, so beware of assuming that
20032    this initialisationis performed first.  */
20033
20034 #ifndef OBJ_ELF
20035 void
20036 arm_init_frag (fragS * fragP, int max_chars ATTRIBUTE_UNUSED)
20037 {
20038   /* Record whether this frag is in an ARM or a THUMB area.  */
20039   fragP->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
20040 }
20041
20042 #else /* OBJ_ELF is defined.  */
20043 void
20044 arm_init_frag (fragS * fragP, int max_chars)
20045 {
20046   /* If the current ARM vs THUMB mode has not already
20047      been recorded into this frag then do so now.  */
20048   if ((fragP->tc_frag_data.thumb_mode & MODE_RECORDED) == 0)
20049     {
20050       fragP->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
20051
20052       /* Record a mapping symbol for alignment frags.  We will delete this
20053          later if the alignment ends up empty.  */
20054       switch (fragP->fr_type)
20055         {
20056           case rs_align:
20057           case rs_align_test:
20058           case rs_fill:
20059             mapping_state_2 (MAP_DATA, max_chars);
20060             break;
20061           case rs_align_code:
20062             mapping_state_2 (thumb_mode ? MAP_THUMB : MAP_ARM, max_chars);
20063             break;
20064           default:
20065             break;
20066         }
20067     }
20068 }
20069
20070 /* When we change sections we need to issue a new mapping symbol.  */
20071
20072 void
20073 arm_elf_change_section (void)
20074 {
20075   /* Link an unlinked unwind index table section to the .text section.  */
20076   if (elf_section_type (now_seg) == SHT_ARM_EXIDX
20077       && elf_linked_to_section (now_seg) == NULL)
20078     elf_linked_to_section (now_seg) = text_section;
20079 }
20080
20081 int
20082 arm_elf_section_type (const char * str, size_t len)
20083 {
20084   if (len == 5 && strncmp (str, "exidx", 5) == 0)
20085     return SHT_ARM_EXIDX;
20086
20087   return -1;
20088 }
20089 \f
20090 /* Code to deal with unwinding tables.  */
20091
20092 static void add_unwind_adjustsp (offsetT);
20093
20094 /* Generate any deferred unwind frame offset.  */
20095
20096 static void
20097 flush_pending_unwind (void)
20098 {
20099   offsetT offset;
20100
20101   offset = unwind.pending_offset;
20102   unwind.pending_offset = 0;
20103   if (offset != 0)
20104     add_unwind_adjustsp (offset);
20105 }
20106
20107 /* Add an opcode to this list for this function.  Two-byte opcodes should
20108    be passed as op[0] << 8 | op[1].  The list of opcodes is built in reverse
20109    order.  */
20110
20111 static void
20112 add_unwind_opcode (valueT op, int length)
20113 {
20114   /* Add any deferred stack adjustment.  */
20115   if (unwind.pending_offset)
20116     flush_pending_unwind ();
20117
20118   unwind.sp_restored = 0;
20119
20120   if (unwind.opcode_count + length > unwind.opcode_alloc)
20121     {
20122       unwind.opcode_alloc += ARM_OPCODE_CHUNK_SIZE;
20123       if (unwind.opcodes)
20124         unwind.opcodes = (unsigned char *) xrealloc (unwind.opcodes,
20125                                                      unwind.opcode_alloc);
20126       else
20127         unwind.opcodes = (unsigned char *) xmalloc (unwind.opcode_alloc);
20128     }
20129   while (length > 0)
20130     {
20131       length--;
20132       unwind.opcodes[unwind.opcode_count] = op & 0xff;
20133       op >>= 8;
20134       unwind.opcode_count++;
20135     }
20136 }
20137
20138 /* Add unwind opcodes to adjust the stack pointer.  */
20139
20140 static void
20141 add_unwind_adjustsp (offsetT offset)
20142 {
20143   valueT op;
20144
20145   if (offset > 0x200)
20146     {
20147       /* We need at most 5 bytes to hold a 32-bit value in a uleb128.  */
20148       char bytes[5];
20149       int n;
20150       valueT o;
20151
20152       /* Long form: 0xb2, uleb128.  */
20153       /* This might not fit in a word so add the individual bytes,
20154          remembering the list is built in reverse order.  */
20155       o = (valueT) ((offset - 0x204) >> 2);
20156       if (o == 0)
20157         add_unwind_opcode (0, 1);
20158
20159       /* Calculate the uleb128 encoding of the offset.  */
20160       n = 0;
20161       while (o)
20162         {
20163           bytes[n] = o & 0x7f;
20164           o >>= 7;
20165           if (o)
20166             bytes[n] |= 0x80;
20167           n++;
20168         }
20169       /* Add the insn.  */
20170       for (; n; n--)
20171         add_unwind_opcode (bytes[n - 1], 1);
20172       add_unwind_opcode (0xb2, 1);
20173     }
20174   else if (offset > 0x100)
20175     {
20176       /* Two short opcodes.  */
20177       add_unwind_opcode (0x3f, 1);
20178       op = (offset - 0x104) >> 2;
20179       add_unwind_opcode (op, 1);
20180     }
20181   else if (offset > 0)
20182     {
20183       /* Short opcode.  */
20184       op = (offset - 4) >> 2;
20185       add_unwind_opcode (op, 1);
20186     }
20187   else if (offset < 0)
20188     {
20189       offset = -offset;
20190       while (offset > 0x100)
20191         {
20192           add_unwind_opcode (0x7f, 1);
20193           offset -= 0x100;
20194         }
20195       op = ((offset - 4) >> 2) | 0x40;
20196       add_unwind_opcode (op, 1);
20197     }
20198 }
20199
20200 /* Finish the list of unwind opcodes for this function.  */
20201 static void
20202 finish_unwind_opcodes (void)
20203 {
20204   valueT op;
20205
20206   if (unwind.fp_used)
20207     {
20208       /* Adjust sp as necessary.  */
20209       unwind.pending_offset += unwind.fp_offset - unwind.frame_size;
20210       flush_pending_unwind ();
20211
20212       /* After restoring sp from the frame pointer.  */
20213       op = 0x90 | unwind.fp_reg;
20214       add_unwind_opcode (op, 1);
20215     }
20216   else
20217     flush_pending_unwind ();
20218 }
20219
20220
20221 /* Start an exception table entry.  If idx is nonzero this is an index table
20222    entry.  */
20223
20224 static void
20225 start_unwind_section (const segT text_seg, int idx)
20226 {
20227   const char * text_name;
20228   const char * prefix;
20229   const char * prefix_once;
20230   const char * group_name;
20231   size_t prefix_len;
20232   size_t text_len;
20233   char * sec_name;
20234   size_t sec_name_len;
20235   int type;
20236   int flags;
20237   int linkonce;
20238
20239   if (idx)
20240     {
20241       prefix = ELF_STRING_ARM_unwind;
20242       prefix_once = ELF_STRING_ARM_unwind_once;
20243       type = SHT_ARM_EXIDX;
20244     }
20245   else
20246     {
20247       prefix = ELF_STRING_ARM_unwind_info;
20248       prefix_once = ELF_STRING_ARM_unwind_info_once;
20249       type = SHT_PROGBITS;
20250     }
20251
20252   text_name = segment_name (text_seg);
20253   if (streq (text_name, ".text"))
20254     text_name = "";
20255
20256   if (strncmp (text_name, ".gnu.linkonce.t.",
20257                strlen (".gnu.linkonce.t.")) == 0)
20258     {
20259       prefix = prefix_once;
20260       text_name += strlen (".gnu.linkonce.t.");
20261     }
20262
20263   prefix_len = strlen (prefix);
20264   text_len = strlen (text_name);
20265   sec_name_len = prefix_len + text_len;
20266   sec_name = (char *) xmalloc (sec_name_len + 1);
20267   memcpy (sec_name, prefix, prefix_len);
20268   memcpy (sec_name + prefix_len, text_name, text_len);
20269   sec_name[prefix_len + text_len] = '\0';
20270
20271   flags = SHF_ALLOC;
20272   linkonce = 0;
20273   group_name = 0;
20274
20275   /* Handle COMDAT group.  */
20276   if (prefix != prefix_once && (text_seg->flags & SEC_LINK_ONCE) != 0)
20277     {
20278       group_name = elf_group_name (text_seg);
20279       if (group_name == NULL)
20280         {
20281           as_bad (_("Group section `%s' has no group signature"),
20282                   segment_name (text_seg));
20283           ignore_rest_of_line ();
20284           return;
20285         }
20286       flags |= SHF_GROUP;
20287       linkonce = 1;
20288     }
20289
20290   obj_elf_change_section (sec_name, type, flags, 0, group_name, linkonce, 0);
20291
20292   /* Set the section link for index tables.  */
20293   if (idx)
20294     elf_linked_to_section (now_seg) = text_seg;
20295 }
20296
20297
20298 /* Start an unwind table entry.  HAVE_DATA is nonzero if we have additional
20299    personality routine data.  Returns zero, or the index table value for
20300    and inline entry.  */
20301
20302 static valueT
20303 create_unwind_entry (int have_data)
20304 {
20305   int size;
20306   addressT where;
20307   char *ptr;
20308   /* The current word of data.  */
20309   valueT data;
20310   /* The number of bytes left in this word.  */
20311   int n;
20312
20313   finish_unwind_opcodes ();
20314
20315   /* Remember the current text section.  */
20316   unwind.saved_seg = now_seg;
20317   unwind.saved_subseg = now_subseg;
20318
20319   start_unwind_section (now_seg, 0);
20320
20321   if (unwind.personality_routine == NULL)
20322     {
20323       if (unwind.personality_index == -2)
20324         {
20325           if (have_data)
20326             as_bad (_("handlerdata in cantunwind frame"));
20327           return 1; /* EXIDX_CANTUNWIND.  */
20328         }
20329
20330       /* Use a default personality routine if none is specified.  */
20331       if (unwind.personality_index == -1)
20332         {
20333           if (unwind.opcode_count > 3)
20334             unwind.personality_index = 1;
20335           else
20336             unwind.personality_index = 0;
20337         }
20338
20339       /* Space for the personality routine entry.  */
20340       if (unwind.personality_index == 0)
20341         {
20342           if (unwind.opcode_count > 3)
20343             as_bad (_("too many unwind opcodes for personality routine 0"));
20344
20345           if (!have_data)
20346             {
20347               /* All the data is inline in the index table.  */
20348               data = 0x80;
20349               n = 3;
20350               while (unwind.opcode_count > 0)
20351                 {
20352                   unwind.opcode_count--;
20353                   data = (data << 8) | unwind.opcodes[unwind.opcode_count];
20354                   n--;
20355                 }
20356
20357               /* Pad with "finish" opcodes.  */
20358               while (n--)
20359                 data = (data << 8) | 0xb0;
20360
20361               return data;
20362             }
20363           size = 0;
20364         }
20365       else
20366         /* We get two opcodes "free" in the first word.  */
20367         size = unwind.opcode_count - 2;
20368     }
20369   else
20370     {
20371       gas_assert (unwind.personality_index == -1);
20372
20373       /* An extra byte is required for the opcode count.        */
20374       size = unwind.opcode_count + 1;
20375     }
20376
20377   size = (size + 3) >> 2;
20378   if (size > 0xff)
20379     as_bad (_("too many unwind opcodes"));
20380
20381   frag_align (2, 0, 0);
20382   record_alignment (now_seg, 2);
20383   unwind.table_entry = expr_build_dot ();
20384
20385   /* Allocate the table entry.  */
20386   ptr = frag_more ((size << 2) + 4);
20387   /* PR 13449: Zero the table entries in case some of them are not used.  */
20388   memset (ptr, 0, (size << 2) + 4);
20389   where = frag_now_fix () - ((size << 2) + 4);
20390
20391   switch (unwind.personality_index)
20392     {
20393     case -1:
20394       /* ??? Should this be a PLT generating relocation?  */
20395       /* Custom personality routine.  */
20396       fix_new (frag_now, where, 4, unwind.personality_routine, 0, 1,
20397                BFD_RELOC_ARM_PREL31);
20398
20399       where += 4;
20400       ptr += 4;
20401
20402       /* Set the first byte to the number of additional words.  */
20403       data = size > 0 ? size - 1 : 0;
20404       n = 3;
20405       break;
20406
20407     /* ABI defined personality routines.  */
20408     case 0:
20409       /* Three opcodes bytes are packed into the first word.  */
20410       data = 0x80;
20411       n = 3;
20412       break;
20413
20414     case 1:
20415     case 2:
20416       /* The size and first two opcode bytes go in the first word.  */
20417       data = ((0x80 + unwind.personality_index) << 8) | size;
20418       n = 2;
20419       break;
20420
20421     default:
20422       /* Should never happen.  */
20423       abort ();
20424     }
20425
20426   /* Pack the opcodes into words (MSB first), reversing the list at the same
20427      time.  */
20428   while (unwind.opcode_count > 0)
20429     {
20430       if (n == 0)
20431         {
20432           md_number_to_chars (ptr, data, 4);
20433           ptr += 4;
20434           n = 4;
20435           data = 0;
20436         }
20437       unwind.opcode_count--;
20438       n--;
20439       data = (data << 8) | unwind.opcodes[unwind.opcode_count];
20440     }
20441
20442   /* Finish off the last word.  */
20443   if (n < 4)
20444     {
20445       /* Pad with "finish" opcodes.  */
20446       while (n--)
20447         data = (data << 8) | 0xb0;
20448
20449       md_number_to_chars (ptr, data, 4);
20450     }
20451
20452   if (!have_data)
20453     {
20454       /* Add an empty descriptor if there is no user-specified data.   */
20455       ptr = frag_more (4);
20456       md_number_to_chars (ptr, 0, 4);
20457     }
20458
20459   return 0;
20460 }
20461
20462
20463 /* Initialize the DWARF-2 unwind information for this procedure.  */
20464
20465 void
20466 tc_arm_frame_initial_instructions (void)
20467 {
20468   cfi_add_CFA_def_cfa (REG_SP, 0);
20469 }
20470 #endif /* OBJ_ELF */
20471
20472 /* Convert REGNAME to a DWARF-2 register number.  */
20473
20474 int
20475 tc_arm_regname_to_dw2regnum (char *regname)
20476 {
20477   int reg = arm_reg_parse (&regname, REG_TYPE_RN);
20478
20479   if (reg == FAIL)
20480     return -1;
20481
20482   return reg;
20483 }
20484
20485 #ifdef TE_PE
20486 void
20487 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
20488 {
20489   expressionS exp;
20490
20491   exp.X_op = O_secrel;
20492   exp.X_add_symbol = symbol;
20493   exp.X_add_number = 0;
20494   emit_expr (&exp, size);
20495 }
20496 #endif
20497
20498 /* MD interface: Symbol and relocation handling.  */
20499
20500 /* Return the address within the segment that a PC-relative fixup is
20501    relative to.  For ARM, PC-relative fixups applied to instructions
20502    are generally relative to the location of the fixup plus 8 bytes.
20503    Thumb branches are offset by 4, and Thumb loads relative to PC
20504    require special handling.  */
20505
20506 long
20507 md_pcrel_from_section (fixS * fixP, segT seg)
20508 {
20509   offsetT base = fixP->fx_where + fixP->fx_frag->fr_address;
20510
20511   /* If this is pc-relative and we are going to emit a relocation
20512      then we just want to put out any pipeline compensation that the linker
20513      will need.  Otherwise we want to use the calculated base.
20514      For WinCE we skip the bias for externals as well, since this
20515      is how the MS ARM-CE assembler behaves and we want to be compatible.  */
20516   if (fixP->fx_pcrel
20517       && ((fixP->fx_addsy && S_GET_SEGMENT (fixP->fx_addsy) != seg)
20518           || (arm_force_relocation (fixP)
20519 #ifdef TE_WINCE
20520               && !S_IS_EXTERNAL (fixP->fx_addsy)
20521 #endif
20522               )))
20523     base = 0;
20524
20525
20526   switch (fixP->fx_r_type)
20527     {
20528       /* PC relative addressing on the Thumb is slightly odd as the
20529          bottom two bits of the PC are forced to zero for the
20530          calculation.  This happens *after* application of the
20531          pipeline offset.  However, Thumb adrl already adjusts for
20532          this, so we need not do it again.  */
20533     case BFD_RELOC_ARM_THUMB_ADD:
20534       return base & ~3;
20535
20536     case BFD_RELOC_ARM_THUMB_OFFSET:
20537     case BFD_RELOC_ARM_T32_OFFSET_IMM:
20538     case BFD_RELOC_ARM_T32_ADD_PC12:
20539     case BFD_RELOC_ARM_T32_CP_OFF_IMM:
20540       return (base + 4) & ~3;
20541
20542       /* Thumb branches are simply offset by +4.  */
20543     case BFD_RELOC_THUMB_PCREL_BRANCH7:
20544     case BFD_RELOC_THUMB_PCREL_BRANCH9:
20545     case BFD_RELOC_THUMB_PCREL_BRANCH12:
20546     case BFD_RELOC_THUMB_PCREL_BRANCH20:
20547     case BFD_RELOC_THUMB_PCREL_BRANCH25:
20548       return base + 4;
20549
20550     case BFD_RELOC_THUMB_PCREL_BRANCH23:
20551       if (fixP->fx_addsy
20552           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
20553           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
20554           && ARM_IS_FUNC (fixP->fx_addsy)
20555           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
20556         base = fixP->fx_where + fixP->fx_frag->fr_address;
20557        return base + 4;
20558
20559       /* BLX is like branches above, but forces the low two bits of PC to
20560          zero.  */
20561     case BFD_RELOC_THUMB_PCREL_BLX:
20562       if (fixP->fx_addsy
20563           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
20564           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
20565           && THUMB_IS_FUNC (fixP->fx_addsy)
20566           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
20567         base = fixP->fx_where + fixP->fx_frag->fr_address;
20568       return (base + 4) & ~3;
20569
20570       /* ARM mode branches are offset by +8.  However, the Windows CE
20571          loader expects the relocation not to take this into account.  */
20572     case BFD_RELOC_ARM_PCREL_BLX:
20573       if (fixP->fx_addsy
20574           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
20575           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
20576           && ARM_IS_FUNC (fixP->fx_addsy)
20577           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
20578         base = fixP->fx_where + fixP->fx_frag->fr_address;
20579       return base + 8;
20580
20581     case BFD_RELOC_ARM_PCREL_CALL:
20582       if (fixP->fx_addsy
20583           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
20584           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
20585           && THUMB_IS_FUNC (fixP->fx_addsy)
20586           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
20587         base = fixP->fx_where + fixP->fx_frag->fr_address;
20588       return base + 8;
20589
20590     case BFD_RELOC_ARM_PCREL_BRANCH:
20591     case BFD_RELOC_ARM_PCREL_JUMP:
20592     case BFD_RELOC_ARM_PLT32:
20593 #ifdef TE_WINCE
20594       /* When handling fixups immediately, because we have already
20595          discovered the value of a symbol, or the address of the frag involved
20596          we must account for the offset by +8, as the OS loader will never see the reloc.
20597          see fixup_segment() in write.c
20598          The S_IS_EXTERNAL test handles the case of global symbols.
20599          Those need the calculated base, not just the pipe compensation the linker will need.  */
20600       if (fixP->fx_pcrel
20601           && fixP->fx_addsy != NULL
20602           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
20603           && (S_IS_EXTERNAL (fixP->fx_addsy) || !arm_force_relocation (fixP)))
20604         return base + 8;
20605       return base;
20606 #else
20607       return base + 8;
20608 #endif
20609
20610
20611       /* ARM mode loads relative to PC are also offset by +8.  Unlike
20612          branches, the Windows CE loader *does* expect the relocation
20613          to take this into account.  */
20614     case BFD_RELOC_ARM_OFFSET_IMM:
20615     case BFD_RELOC_ARM_OFFSET_IMM8:
20616     case BFD_RELOC_ARM_HWLITERAL:
20617     case BFD_RELOC_ARM_LITERAL:
20618     case BFD_RELOC_ARM_CP_OFF_IMM:
20619       return base + 8;
20620
20621
20622       /* Other PC-relative relocations are un-offset.  */
20623     default:
20624       return base;
20625     }
20626 }
20627
20628 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
20629    Otherwise we have no need to default values of symbols.  */
20630
20631 symbolS *
20632 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
20633 {
20634 #ifdef OBJ_ELF
20635   if (name[0] == '_' && name[1] == 'G'
20636       && streq (name, GLOBAL_OFFSET_TABLE_NAME))
20637     {
20638       if (!GOT_symbol)
20639         {
20640           if (symbol_find (name))
20641             as_bad (_("GOT already in the symbol table"));
20642
20643           GOT_symbol = symbol_new (name, undefined_section,
20644                                    (valueT) 0, & zero_address_frag);
20645         }
20646
20647       return GOT_symbol;
20648     }
20649 #endif
20650
20651   return NULL;
20652 }
20653
20654 /* Subroutine of md_apply_fix.   Check to see if an immediate can be
20655    computed as two separate immediate values, added together.  We
20656    already know that this value cannot be computed by just one ARM
20657    instruction.  */
20658
20659 static unsigned int
20660 validate_immediate_twopart (unsigned int   val,
20661                             unsigned int * highpart)
20662 {
20663   unsigned int a;
20664   unsigned int i;
20665
20666   for (i = 0; i < 32; i += 2)
20667     if (((a = rotate_left (val, i)) & 0xff) != 0)
20668       {
20669         if (a & 0xff00)
20670           {
20671             if (a & ~ 0xffff)
20672               continue;
20673             * highpart = (a  >> 8) | ((i + 24) << 7);
20674           }
20675         else if (a & 0xff0000)
20676           {
20677             if (a & 0xff000000)
20678               continue;
20679             * highpart = (a >> 16) | ((i + 16) << 7);
20680           }
20681         else
20682           {
20683             gas_assert (a & 0xff000000);
20684             * highpart = (a >> 24) | ((i + 8) << 7);
20685           }
20686
20687         return (a & 0xff) | (i << 7);
20688       }
20689
20690   return FAIL;
20691 }
20692
20693 static int
20694 validate_offset_imm (unsigned int val, int hwse)
20695 {
20696   if ((hwse && val > 255) || val > 4095)
20697     return FAIL;
20698   return val;
20699 }
20700
20701 /* Subroutine of md_apply_fix.   Do those data_ops which can take a
20702    negative immediate constant by altering the instruction.  A bit of
20703    a hack really.
20704         MOV <-> MVN
20705         AND <-> BIC
20706         ADC <-> SBC
20707         by inverting the second operand, and
20708         ADD <-> SUB
20709         CMP <-> CMN
20710         by negating the second operand.  */
20711
20712 static int
20713 negate_data_op (unsigned long * instruction,
20714                 unsigned long   value)
20715 {
20716   int op, new_inst;
20717   unsigned long negated, inverted;
20718
20719   negated = encode_arm_immediate (-value);
20720   inverted = encode_arm_immediate (~value);
20721
20722   op = (*instruction >> DATA_OP_SHIFT) & 0xf;
20723   switch (op)
20724     {
20725       /* First negates.  */
20726     case OPCODE_SUB:             /* ADD <-> SUB  */
20727       new_inst = OPCODE_ADD;
20728       value = negated;
20729       break;
20730
20731     case OPCODE_ADD:
20732       new_inst = OPCODE_SUB;
20733       value = negated;
20734       break;
20735
20736     case OPCODE_CMP:             /* CMP <-> CMN  */
20737       new_inst = OPCODE_CMN;
20738       value = negated;
20739       break;
20740
20741     case OPCODE_CMN:
20742       new_inst = OPCODE_CMP;
20743       value = negated;
20744       break;
20745
20746       /* Now Inverted ops.  */
20747     case OPCODE_MOV:             /* MOV <-> MVN  */
20748       new_inst = OPCODE_MVN;
20749       value = inverted;
20750       break;
20751
20752     case OPCODE_MVN:
20753       new_inst = OPCODE_MOV;
20754       value = inverted;
20755       break;
20756
20757     case OPCODE_AND:             /* AND <-> BIC  */
20758       new_inst = OPCODE_BIC;
20759       value = inverted;
20760       break;
20761
20762     case OPCODE_BIC:
20763       new_inst = OPCODE_AND;
20764       value = inverted;
20765       break;
20766
20767     case OPCODE_ADC:              /* ADC <-> SBC  */
20768       new_inst = OPCODE_SBC;
20769       value = inverted;
20770       break;
20771
20772     case OPCODE_SBC:
20773       new_inst = OPCODE_ADC;
20774       value = inverted;
20775       break;
20776
20777       /* We cannot do anything.  */
20778     default:
20779       return FAIL;
20780     }
20781
20782   if (value == (unsigned) FAIL)
20783     return FAIL;
20784
20785   *instruction &= OPCODE_MASK;
20786   *instruction |= new_inst << DATA_OP_SHIFT;
20787   return value;
20788 }
20789
20790 /* Like negate_data_op, but for Thumb-2.   */
20791
20792 static unsigned int
20793 thumb32_negate_data_op (offsetT *instruction, unsigned int value)
20794 {
20795   int op, new_inst;
20796   int rd;
20797   unsigned int negated, inverted;
20798
20799   negated = encode_thumb32_immediate (-value);
20800   inverted = encode_thumb32_immediate (~value);
20801
20802   rd = (*instruction >> 8) & 0xf;
20803   op = (*instruction >> T2_DATA_OP_SHIFT) & 0xf;
20804   switch (op)
20805     {
20806       /* ADD <-> SUB.  Includes CMP <-> CMN.  */
20807     case T2_OPCODE_SUB:
20808       new_inst = T2_OPCODE_ADD;
20809       value = negated;
20810       break;
20811
20812     case T2_OPCODE_ADD:
20813       new_inst = T2_OPCODE_SUB;
20814       value = negated;
20815       break;
20816
20817       /* ORR <-> ORN.  Includes MOV <-> MVN.  */
20818     case T2_OPCODE_ORR:
20819       new_inst = T2_OPCODE_ORN;
20820       value = inverted;
20821       break;
20822
20823     case T2_OPCODE_ORN:
20824       new_inst = T2_OPCODE_ORR;
20825       value = inverted;
20826       break;
20827
20828       /* AND <-> BIC.  TST has no inverted equivalent.  */
20829     case T2_OPCODE_AND:
20830       new_inst = T2_OPCODE_BIC;
20831       if (rd == 15)
20832         value = FAIL;
20833       else
20834         value = inverted;
20835       break;
20836
20837     case T2_OPCODE_BIC:
20838       new_inst = T2_OPCODE_AND;
20839       value = inverted;
20840       break;
20841
20842       /* ADC <-> SBC  */
20843     case T2_OPCODE_ADC:
20844       new_inst = T2_OPCODE_SBC;
20845       value = inverted;
20846       break;
20847
20848     case T2_OPCODE_SBC:
20849       new_inst = T2_OPCODE_ADC;
20850       value = inverted;
20851       break;
20852
20853       /* We cannot do anything.  */
20854     default:
20855       return FAIL;
20856     }
20857
20858   if (value == (unsigned int)FAIL)
20859     return FAIL;
20860
20861   *instruction &= T2_OPCODE_MASK;
20862   *instruction |= new_inst << T2_DATA_OP_SHIFT;
20863   return value;
20864 }
20865
20866 /* Read a 32-bit thumb instruction from buf.  */
20867 static unsigned long
20868 get_thumb32_insn (char * buf)
20869 {
20870   unsigned long insn;
20871   insn = md_chars_to_number (buf, THUMB_SIZE) << 16;
20872   insn |= md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
20873
20874   return insn;
20875 }
20876
20877
20878 /* We usually want to set the low bit on the address of thumb function
20879    symbols.  In particular .word foo - . should have the low bit set.
20880    Generic code tries to fold the difference of two symbols to
20881    a constant.  Prevent this and force a relocation when the first symbols
20882    is a thumb function.  */
20883
20884 bfd_boolean
20885 arm_optimize_expr (expressionS *l, operatorT op, expressionS *r)
20886 {
20887   if (op == O_subtract
20888       && l->X_op == O_symbol
20889       && r->X_op == O_symbol
20890       && THUMB_IS_FUNC (l->X_add_symbol))
20891     {
20892       l->X_op = O_subtract;
20893       l->X_op_symbol = r->X_add_symbol;
20894       l->X_add_number -= r->X_add_number;
20895       return TRUE;
20896     }
20897
20898   /* Process as normal.  */
20899   return FALSE;
20900 }
20901
20902 /* Encode Thumb2 unconditional branches and calls. The encoding
20903    for the 2 are identical for the immediate values.  */
20904
20905 static void
20906 encode_thumb2_b_bl_offset (char * buf, offsetT value)
20907 {
20908 #define T2I1I2MASK  ((1 << 13) | (1 << 11))
20909   offsetT newval;
20910   offsetT newval2;
20911   addressT S, I1, I2, lo, hi;
20912
20913   S = (value >> 24) & 0x01;
20914   I1 = (value >> 23) & 0x01;
20915   I2 = (value >> 22) & 0x01;
20916   hi = (value >> 12) & 0x3ff;
20917   lo = (value >> 1) & 0x7ff;
20918   newval   = md_chars_to_number (buf, THUMB_SIZE);
20919   newval2  = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
20920   newval  |= (S << 10) | hi;
20921   newval2 &=  ~T2I1I2MASK;
20922   newval2 |= (((I1 ^ S) << 13) | ((I2 ^ S) << 11) | lo) ^ T2I1I2MASK;
20923   md_number_to_chars (buf, newval, THUMB_SIZE);
20924   md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
20925 }
20926
20927 void
20928 md_apply_fix (fixS *    fixP,
20929                valueT * valP,
20930                segT     seg)
20931 {
20932   offsetT        value = * valP;
20933   offsetT        newval;
20934   unsigned int   newimm;
20935   unsigned long  temp;
20936   int            sign;
20937   char *         buf = fixP->fx_where + fixP->fx_frag->fr_literal;
20938
20939   gas_assert (fixP->fx_r_type <= BFD_RELOC_UNUSED);
20940
20941   /* Note whether this will delete the relocation.  */
20942
20943   if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
20944     fixP->fx_done = 1;
20945
20946   /* On a 64-bit host, silently truncate 'value' to 32 bits for
20947      consistency with the behaviour on 32-bit hosts.  Remember value
20948      for emit_reloc.  */
20949   value &= 0xffffffff;
20950   value ^= 0x80000000;
20951   value -= 0x80000000;
20952
20953   *valP = value;
20954   fixP->fx_addnumber = value;
20955
20956   /* Same treatment for fixP->fx_offset.  */
20957   fixP->fx_offset &= 0xffffffff;
20958   fixP->fx_offset ^= 0x80000000;
20959   fixP->fx_offset -= 0x80000000;
20960
20961   switch (fixP->fx_r_type)
20962     {
20963     case BFD_RELOC_NONE:
20964       /* This will need to go in the object file.  */
20965       fixP->fx_done = 0;
20966       break;
20967
20968     case BFD_RELOC_ARM_IMMEDIATE:
20969       /* We claim that this fixup has been processed here,
20970          even if in fact we generate an error because we do
20971          not have a reloc for it, so tc_gen_reloc will reject it.  */
20972       fixP->fx_done = 1;
20973
20974       if (fixP->fx_addsy)
20975         {
20976           const char *msg = 0;
20977
20978           if (! S_IS_DEFINED (fixP->fx_addsy))
20979             msg = _("undefined symbol %s used as an immediate value");
20980           else if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
20981             msg = _("symbol %s is in a different section");
20982           else if (S_IS_WEAK (fixP->fx_addsy))
20983             msg = _("symbol %s is weak and may be overridden later");
20984
20985           if (msg)
20986             {
20987               as_bad_where (fixP->fx_file, fixP->fx_line,
20988                             msg, S_GET_NAME (fixP->fx_addsy));
20989               break;
20990             }
20991         }
20992
20993       temp = md_chars_to_number (buf, INSN_SIZE);
20994
20995       /* If the offset is negative, we should use encoding A2 for ADR.  */
20996       if ((temp & 0xfff0000) == 0x28f0000 && value < 0)
20997         newimm = negate_data_op (&temp, value);
20998       else
20999         {
21000           newimm = encode_arm_immediate (value);
21001
21002           /* If the instruction will fail, see if we can fix things up by
21003              changing the opcode.  */
21004           if (newimm == (unsigned int) FAIL)
21005             newimm = negate_data_op (&temp, value);
21006         }
21007
21008       if (newimm == (unsigned int) FAIL)
21009         {
21010           as_bad_where (fixP->fx_file, fixP->fx_line,
21011                         _("invalid constant (%lx) after fixup"),
21012                         (unsigned long) value);
21013           break;
21014         }
21015
21016       newimm |= (temp & 0xfffff000);
21017       md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
21018       break;
21019
21020     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
21021       {
21022         unsigned int highpart = 0;
21023         unsigned int newinsn  = 0xe1a00000; /* nop.  */
21024
21025         if (fixP->fx_addsy)
21026           {
21027             const char *msg = 0;
21028
21029             if (! S_IS_DEFINED (fixP->fx_addsy))
21030               msg = _("undefined symbol %s used as an immediate value");
21031             else if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
21032               msg = _("symbol %s is in a different section");
21033             else if (S_IS_WEAK (fixP->fx_addsy))
21034               msg = _("symbol %s is weak and may be overridden later");
21035
21036             if (msg)
21037               {
21038                 as_bad_where (fixP->fx_file, fixP->fx_line,
21039                               msg, S_GET_NAME (fixP->fx_addsy));
21040                 break;
21041               }
21042           }
21043
21044         newimm = encode_arm_immediate (value);
21045         temp = md_chars_to_number (buf, INSN_SIZE);
21046
21047         /* If the instruction will fail, see if we can fix things up by
21048            changing the opcode.  */
21049         if (newimm == (unsigned int) FAIL
21050             && (newimm = negate_data_op (& temp, value)) == (unsigned int) FAIL)
21051           {
21052             /* No ?  OK - try using two ADD instructions to generate
21053                the value.  */
21054             newimm = validate_immediate_twopart (value, & highpart);
21055
21056             /* Yes - then make sure that the second instruction is
21057                also an add.  */
21058             if (newimm != (unsigned int) FAIL)
21059               newinsn = temp;
21060             /* Still No ?  Try using a negated value.  */
21061             else if ((newimm = validate_immediate_twopart (- value, & highpart)) != (unsigned int) FAIL)
21062               temp = newinsn = (temp & OPCODE_MASK) | OPCODE_SUB << DATA_OP_SHIFT;
21063             /* Otherwise - give up.  */
21064             else
21065               {
21066                 as_bad_where (fixP->fx_file, fixP->fx_line,
21067                               _("unable to compute ADRL instructions for PC offset of 0x%lx"),
21068                               (long) value);
21069                 break;
21070               }
21071
21072             /* Replace the first operand in the 2nd instruction (which
21073                is the PC) with the destination register.  We have
21074                already added in the PC in the first instruction and we
21075                do not want to do it again.  */
21076             newinsn &= ~ 0xf0000;
21077             newinsn |= ((newinsn & 0x0f000) << 4);
21078           }
21079
21080         newimm |= (temp & 0xfffff000);
21081         md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
21082
21083         highpart |= (newinsn & 0xfffff000);
21084         md_number_to_chars (buf + INSN_SIZE, (valueT) highpart, INSN_SIZE);
21085       }
21086       break;
21087
21088     case BFD_RELOC_ARM_OFFSET_IMM:
21089       if (!fixP->fx_done && seg->use_rela_p)
21090         value = 0;
21091
21092     case BFD_RELOC_ARM_LITERAL:
21093       sign = value > 0;
21094
21095       if (value < 0)
21096         value = - value;
21097
21098       if (validate_offset_imm (value, 0) == FAIL)
21099         {
21100           if (fixP->fx_r_type == BFD_RELOC_ARM_LITERAL)
21101             as_bad_where (fixP->fx_file, fixP->fx_line,
21102                           _("invalid literal constant: pool needs to be closer"));
21103           else
21104             as_bad_where (fixP->fx_file, fixP->fx_line,
21105                           _("bad immediate value for offset (%ld)"),
21106                           (long) value);
21107           break;
21108         }
21109
21110       newval = md_chars_to_number (buf, INSN_SIZE);
21111       if (value == 0)
21112         newval &= 0xfffff000;
21113       else
21114         {
21115           newval &= 0xff7ff000;
21116           newval |= value | (sign ? INDEX_UP : 0);
21117         }
21118       md_number_to_chars (buf, newval, INSN_SIZE);
21119       break;
21120
21121     case BFD_RELOC_ARM_OFFSET_IMM8:
21122     case BFD_RELOC_ARM_HWLITERAL:
21123       sign = value > 0;
21124
21125       if (value < 0)
21126         value = - value;
21127
21128       if (validate_offset_imm (value, 1) == FAIL)
21129         {
21130           if (fixP->fx_r_type == BFD_RELOC_ARM_HWLITERAL)
21131             as_bad_where (fixP->fx_file, fixP->fx_line,
21132                           _("invalid literal constant: pool needs to be closer"));
21133           else
21134             as_bad (_("bad immediate value for 8-bit offset (%ld)"),
21135                     (long) value);
21136           break;
21137         }
21138
21139       newval = md_chars_to_number (buf, INSN_SIZE);
21140       if (value == 0)
21141         newval &= 0xfffff0f0;
21142       else
21143         {
21144           newval &= 0xff7ff0f0;
21145           newval |= ((value >> 4) << 8) | (value & 0xf) | (sign ? INDEX_UP : 0);
21146         }
21147       md_number_to_chars (buf, newval, INSN_SIZE);
21148       break;
21149
21150     case BFD_RELOC_ARM_T32_OFFSET_U8:
21151       if (value < 0 || value > 1020 || value % 4 != 0)
21152         as_bad_where (fixP->fx_file, fixP->fx_line,
21153                       _("bad immediate value for offset (%ld)"), (long) value);
21154       value /= 4;
21155
21156       newval = md_chars_to_number (buf+2, THUMB_SIZE);
21157       newval |= value;
21158       md_number_to_chars (buf+2, newval, THUMB_SIZE);
21159       break;
21160
21161     case BFD_RELOC_ARM_T32_OFFSET_IMM:
21162       /* This is a complicated relocation used for all varieties of Thumb32
21163          load/store instruction with immediate offset:
21164
21165          1110 100P u1WL NNNN XXXX YYYY iiii iiii - +/-(U) pre/post(P) 8-bit,
21166                                                    *4, optional writeback(W)
21167                                                    (doubleword load/store)
21168
21169          1111 100S uTTL 1111 XXXX iiii iiii iiii - +/-(U) 12-bit PC-rel
21170          1111 100S 0TTL NNNN XXXX 1Pu1 iiii iiii - +/-(U) pre/post(P) 8-bit
21171          1111 100S 0TTL NNNN XXXX 1110 iiii iiii - positive 8-bit (T instruction)
21172          1111 100S 1TTL NNNN XXXX iiii iiii iiii - positive 12-bit
21173          1111 100S 0TTL NNNN XXXX 1100 iiii iiii - negative 8-bit
21174
21175          Uppercase letters indicate bits that are already encoded at
21176          this point.  Lowercase letters are our problem.  For the
21177          second block of instructions, the secondary opcode nybble
21178          (bits 8..11) is present, and bit 23 is zero, even if this is
21179          a PC-relative operation.  */
21180       newval = md_chars_to_number (buf, THUMB_SIZE);
21181       newval <<= 16;
21182       newval |= md_chars_to_number (buf+THUMB_SIZE, THUMB_SIZE);
21183
21184       if ((newval & 0xf0000000) == 0xe0000000)
21185         {
21186           /* Doubleword load/store: 8-bit offset, scaled by 4.  */
21187           if (value >= 0)
21188             newval |= (1 << 23);
21189           else
21190             value = -value;
21191           if (value % 4 != 0)
21192             {
21193               as_bad_where (fixP->fx_file, fixP->fx_line,
21194                             _("offset not a multiple of 4"));
21195               break;
21196             }
21197           value /= 4;
21198           if (value > 0xff)
21199             {
21200               as_bad_where (fixP->fx_file, fixP->fx_line,
21201                             _("offset out of range"));
21202               break;
21203             }
21204           newval &= ~0xff;
21205         }
21206       else if ((newval & 0x000f0000) == 0x000f0000)
21207         {
21208           /* PC-relative, 12-bit offset.  */
21209           if (value >= 0)
21210             newval |= (1 << 23);
21211           else
21212             value = -value;
21213           if (value > 0xfff)
21214             {
21215               as_bad_where (fixP->fx_file, fixP->fx_line,
21216                             _("offset out of range"));
21217               break;
21218             }
21219           newval &= ~0xfff;
21220         }
21221       else if ((newval & 0x00000100) == 0x00000100)
21222         {
21223           /* Writeback: 8-bit, +/- offset.  */
21224           if (value >= 0)
21225             newval |= (1 << 9);
21226           else
21227             value = -value;
21228           if (value > 0xff)
21229             {
21230               as_bad_where (fixP->fx_file, fixP->fx_line,
21231                             _("offset out of range"));
21232               break;
21233             }
21234           newval &= ~0xff;
21235         }
21236       else if ((newval & 0x00000f00) == 0x00000e00)
21237         {
21238           /* T-instruction: positive 8-bit offset.  */
21239           if (value < 0 || value > 0xff)
21240             {
21241               as_bad_where (fixP->fx_file, fixP->fx_line,
21242                             _("offset out of range"));
21243               break;
21244             }
21245           newval &= ~0xff;
21246           newval |= value;
21247         }
21248       else
21249         {
21250           /* Positive 12-bit or negative 8-bit offset.  */
21251           int limit;
21252           if (value >= 0)
21253             {
21254               newval |= (1 << 23);
21255               limit = 0xfff;
21256             }
21257           else
21258             {
21259               value = -value;
21260               limit = 0xff;
21261             }
21262           if (value > limit)
21263             {
21264               as_bad_where (fixP->fx_file, fixP->fx_line,
21265                             _("offset out of range"));
21266               break;
21267             }
21268           newval &= ~limit;
21269         }
21270
21271       newval |= value;
21272       md_number_to_chars (buf, (newval >> 16) & 0xffff, THUMB_SIZE);
21273       md_number_to_chars (buf + THUMB_SIZE, newval & 0xffff, THUMB_SIZE);
21274       break;
21275
21276     case BFD_RELOC_ARM_SHIFT_IMM:
21277       newval = md_chars_to_number (buf, INSN_SIZE);
21278       if (((unsigned long) value) > 32
21279           || (value == 32
21280               && (((newval & 0x60) == 0) || (newval & 0x60) == 0x60)))
21281         {
21282           as_bad_where (fixP->fx_file, fixP->fx_line,
21283                         _("shift expression is too large"));
21284           break;
21285         }
21286
21287       if (value == 0)
21288         /* Shifts of zero must be done as lsl.  */
21289         newval &= ~0x60;
21290       else if (value == 32)
21291         value = 0;
21292       newval &= 0xfffff07f;
21293       newval |= (value & 0x1f) << 7;
21294       md_number_to_chars (buf, newval, INSN_SIZE);
21295       break;
21296
21297     case BFD_RELOC_ARM_T32_IMMEDIATE:
21298     case BFD_RELOC_ARM_T32_ADD_IMM:
21299     case BFD_RELOC_ARM_T32_IMM12:
21300     case BFD_RELOC_ARM_T32_ADD_PC12:
21301       /* We claim that this fixup has been processed here,
21302          even if in fact we generate an error because we do
21303          not have a reloc for it, so tc_gen_reloc will reject it.  */
21304       fixP->fx_done = 1;
21305
21306       if (fixP->fx_addsy
21307           && ! S_IS_DEFINED (fixP->fx_addsy))
21308         {
21309           as_bad_where (fixP->fx_file, fixP->fx_line,
21310                         _("undefined symbol %s used as an immediate value"),
21311                         S_GET_NAME (fixP->fx_addsy));
21312           break;
21313         }
21314
21315       newval = md_chars_to_number (buf, THUMB_SIZE);
21316       newval <<= 16;
21317       newval |= md_chars_to_number (buf+2, THUMB_SIZE);
21318
21319       newimm = FAIL;
21320       if (fixP->fx_r_type == BFD_RELOC_ARM_T32_IMMEDIATE
21321           || fixP->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM)
21322         {
21323           newimm = encode_thumb32_immediate (value);
21324           if (newimm == (unsigned int) FAIL)
21325             newimm = thumb32_negate_data_op (&newval, value);
21326         }
21327       if (fixP->fx_r_type != BFD_RELOC_ARM_T32_IMMEDIATE
21328           && newimm == (unsigned int) FAIL)
21329         {
21330           /* Turn add/sum into addw/subw.  */
21331           if (fixP->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM)
21332             newval = (newval & 0xfeffffff) | 0x02000000;
21333           /* No flat 12-bit imm encoding for addsw/subsw.  */
21334           if ((newval & 0x00100000) == 0)
21335             {
21336               /* 12 bit immediate for addw/subw.  */
21337               if (value < 0)
21338                 {
21339                   value = -value;
21340                   newval ^= 0x00a00000;
21341                 }
21342               if (value > 0xfff)
21343                 newimm = (unsigned int) FAIL;
21344               else
21345                 newimm = value;
21346             }
21347         }
21348
21349       if (newimm == (unsigned int)FAIL)
21350         {
21351           as_bad_where (fixP->fx_file, fixP->fx_line,
21352                         _("invalid constant (%lx) after fixup"),
21353                         (unsigned long) value);
21354           break;
21355         }
21356
21357       newval |= (newimm & 0x800) << 15;
21358       newval |= (newimm & 0x700) << 4;
21359       newval |= (newimm & 0x0ff);
21360
21361       md_number_to_chars (buf,   (valueT) ((newval >> 16) & 0xffff), THUMB_SIZE);
21362       md_number_to_chars (buf+2, (valueT) (newval & 0xffff), THUMB_SIZE);
21363       break;
21364
21365     case BFD_RELOC_ARM_SMC:
21366       if (((unsigned long) value) > 0xffff)
21367         as_bad_where (fixP->fx_file, fixP->fx_line,
21368                       _("invalid smc expression"));
21369       newval = md_chars_to_number (buf, INSN_SIZE);
21370       newval |= (value & 0xf) | ((value & 0xfff0) << 4);
21371       md_number_to_chars (buf, newval, INSN_SIZE);
21372       break;
21373
21374     case BFD_RELOC_ARM_HVC:
21375       if (((unsigned long) value) > 0xffff)
21376         as_bad_where (fixP->fx_file, fixP->fx_line,
21377                       _("invalid hvc expression"));
21378       newval = md_chars_to_number (buf, INSN_SIZE);
21379       newval |= (value & 0xf) | ((value & 0xfff0) << 4);
21380       md_number_to_chars (buf, newval, INSN_SIZE);
21381       break;
21382
21383     case BFD_RELOC_ARM_SWI:
21384       if (fixP->tc_fix_data != 0)
21385         {
21386           if (((unsigned long) value) > 0xff)
21387             as_bad_where (fixP->fx_file, fixP->fx_line,
21388                           _("invalid swi expression"));
21389           newval = md_chars_to_number (buf, THUMB_SIZE);
21390           newval |= value;
21391           md_number_to_chars (buf, newval, THUMB_SIZE);
21392         }
21393       else
21394         {
21395           if (((unsigned long) value) > 0x00ffffff)
21396             as_bad_where (fixP->fx_file, fixP->fx_line,
21397                           _("invalid swi expression"));
21398           newval = md_chars_to_number (buf, INSN_SIZE);
21399           newval |= value;
21400           md_number_to_chars (buf, newval, INSN_SIZE);
21401         }
21402       break;
21403
21404     case BFD_RELOC_ARM_MULTI:
21405       if (((unsigned long) value) > 0xffff)
21406         as_bad_where (fixP->fx_file, fixP->fx_line,
21407                       _("invalid expression in load/store multiple"));
21408       newval = value | md_chars_to_number (buf, INSN_SIZE);
21409       md_number_to_chars (buf, newval, INSN_SIZE);
21410       break;
21411
21412 #ifdef OBJ_ELF
21413     case BFD_RELOC_ARM_PCREL_CALL:
21414
21415       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
21416           && fixP->fx_addsy
21417           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21418           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21419           && THUMB_IS_FUNC (fixP->fx_addsy))
21420         /* Flip the bl to blx. This is a simple flip
21421            bit here because we generate PCREL_CALL for
21422            unconditional bls.  */
21423         {
21424           newval = md_chars_to_number (buf, INSN_SIZE);
21425           newval = newval | 0x10000000;
21426           md_number_to_chars (buf, newval, INSN_SIZE);
21427           temp = 1;
21428           fixP->fx_done = 1;
21429         }
21430       else
21431         temp = 3;
21432       goto arm_branch_common;
21433
21434     case BFD_RELOC_ARM_PCREL_JUMP:
21435       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
21436           && fixP->fx_addsy
21437           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21438           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21439           && THUMB_IS_FUNC (fixP->fx_addsy))
21440         {
21441           /* This would map to a bl<cond>, b<cond>,
21442              b<always> to a Thumb function. We
21443              need to force a relocation for this particular
21444              case.  */
21445           newval = md_chars_to_number (buf, INSN_SIZE);
21446           fixP->fx_done = 0;
21447         }
21448
21449     case BFD_RELOC_ARM_PLT32:
21450 #endif
21451     case BFD_RELOC_ARM_PCREL_BRANCH:
21452       temp = 3;
21453       goto arm_branch_common;
21454
21455     case BFD_RELOC_ARM_PCREL_BLX:
21456
21457       temp = 1;
21458       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
21459           && fixP->fx_addsy
21460           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21461           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21462           && ARM_IS_FUNC (fixP->fx_addsy))
21463         {
21464           /* Flip the blx to a bl and warn.  */
21465           const char *name = S_GET_NAME (fixP->fx_addsy);
21466           newval = 0xeb000000;
21467           as_warn_where (fixP->fx_file, fixP->fx_line,
21468                          _("blx to '%s' an ARM ISA state function changed to bl"),
21469                           name);
21470           md_number_to_chars (buf, newval, INSN_SIZE);
21471           temp = 3;
21472           fixP->fx_done = 1;
21473         }
21474
21475 #ifdef OBJ_ELF
21476        if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
21477          fixP->fx_r_type = BFD_RELOC_ARM_PCREL_CALL;
21478 #endif
21479
21480     arm_branch_common:
21481       /* We are going to store value (shifted right by two) in the
21482          instruction, in a 24 bit, signed field.  Bits 26 through 32 either
21483          all clear or all set and bit 0 must be clear.  For B/BL bit 1 must
21484          also be be clear.  */
21485       if (value & temp)
21486         as_bad_where (fixP->fx_file, fixP->fx_line,
21487                       _("misaligned branch destination"));
21488       if ((value & (offsetT)0xfe000000) != (offsetT)0
21489           && (value & (offsetT)0xfe000000) != (offsetT)0xfe000000)
21490         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21491
21492       if (fixP->fx_done || !seg->use_rela_p)
21493         {
21494           newval = md_chars_to_number (buf, INSN_SIZE);
21495           newval |= (value >> 2) & 0x00ffffff;
21496           /* Set the H bit on BLX instructions.  */
21497           if (temp == 1)
21498             {
21499               if (value & 2)
21500                 newval |= 0x01000000;
21501               else
21502                 newval &= ~0x01000000;
21503             }
21504           md_number_to_chars (buf, newval, INSN_SIZE);
21505         }
21506       break;
21507
21508     case BFD_RELOC_THUMB_PCREL_BRANCH7: /* CBZ */
21509       /* CBZ can only branch forward.  */
21510
21511       /* Attempts to use CBZ to branch to the next instruction
21512          (which, strictly speaking, are prohibited) will be turned into
21513          no-ops.
21514
21515          FIXME: It may be better to remove the instruction completely and
21516          perform relaxation.  */
21517       if (value == -2)
21518         {
21519           newval = md_chars_to_number (buf, THUMB_SIZE);
21520           newval = 0xbf00; /* NOP encoding T1 */
21521           md_number_to_chars (buf, newval, THUMB_SIZE);
21522         }
21523       else
21524         {
21525           if (value & ~0x7e)
21526             as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21527
21528           if (fixP->fx_done || !seg->use_rela_p)
21529             {
21530               newval = md_chars_to_number (buf, THUMB_SIZE);
21531               newval |= ((value & 0x3e) << 2) | ((value & 0x40) << 3);
21532               md_number_to_chars (buf, newval, THUMB_SIZE);
21533             }
21534         }
21535       break;
21536
21537     case BFD_RELOC_THUMB_PCREL_BRANCH9: /* Conditional branch.  */
21538       if ((value & ~0xff) && ((value & ~0xff) != ~0xff))
21539         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21540
21541       if (fixP->fx_done || !seg->use_rela_p)
21542         {
21543           newval = md_chars_to_number (buf, THUMB_SIZE);
21544           newval |= (value & 0x1ff) >> 1;
21545           md_number_to_chars (buf, newval, THUMB_SIZE);
21546         }
21547       break;
21548
21549     case BFD_RELOC_THUMB_PCREL_BRANCH12: /* Unconditional branch.  */
21550       if ((value & ~0x7ff) && ((value & ~0x7ff) != ~0x7ff))
21551         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21552
21553       if (fixP->fx_done || !seg->use_rela_p)
21554         {
21555           newval = md_chars_to_number (buf, THUMB_SIZE);
21556           newval |= (value & 0xfff) >> 1;
21557           md_number_to_chars (buf, newval, THUMB_SIZE);
21558         }
21559       break;
21560
21561     case BFD_RELOC_THUMB_PCREL_BRANCH20:
21562       if (fixP->fx_addsy
21563           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21564           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21565           && ARM_IS_FUNC (fixP->fx_addsy)
21566           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
21567         {
21568           /* Force a relocation for a branch 20 bits wide.  */
21569           fixP->fx_done = 0;
21570         }
21571       if ((value & ~0x1fffff) && ((value & ~0x0fffff) != ~0x0fffff))
21572         as_bad_where (fixP->fx_file, fixP->fx_line,
21573                       _("conditional branch out of range"));
21574
21575       if (fixP->fx_done || !seg->use_rela_p)
21576         {
21577           offsetT newval2;
21578           addressT S, J1, J2, lo, hi;
21579
21580           S  = (value & 0x00100000) >> 20;
21581           J2 = (value & 0x00080000) >> 19;
21582           J1 = (value & 0x00040000) >> 18;
21583           hi = (value & 0x0003f000) >> 12;
21584           lo = (value & 0x00000ffe) >> 1;
21585
21586           newval   = md_chars_to_number (buf, THUMB_SIZE);
21587           newval2  = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
21588           newval  |= (S << 10) | hi;
21589           newval2 |= (J1 << 13) | (J2 << 11) | lo;
21590           md_number_to_chars (buf, newval, THUMB_SIZE);
21591           md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
21592         }
21593       break;
21594
21595     case BFD_RELOC_THUMB_PCREL_BLX:
21596       /* If there is a blx from a thumb state function to
21597          another thumb function flip this to a bl and warn
21598          about it.  */
21599
21600       if (fixP->fx_addsy
21601           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21602           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21603           && THUMB_IS_FUNC (fixP->fx_addsy))
21604         {
21605           const char *name = S_GET_NAME (fixP->fx_addsy);
21606           as_warn_where (fixP->fx_file, fixP->fx_line,
21607                          _("blx to Thumb func '%s' from Thumb ISA state changed to bl"),
21608                          name);
21609           newval = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
21610           newval = newval | 0x1000;
21611           md_number_to_chars (buf+THUMB_SIZE, newval, THUMB_SIZE);
21612           fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BRANCH23;
21613           fixP->fx_done = 1;
21614         }
21615
21616
21617       goto thumb_bl_common;
21618
21619     case BFD_RELOC_THUMB_PCREL_BRANCH23:
21620       /* A bl from Thumb state ISA to an internal ARM state function
21621          is converted to a blx.  */
21622       if (fixP->fx_addsy
21623           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21624           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21625           && ARM_IS_FUNC (fixP->fx_addsy)
21626           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
21627         {
21628           newval = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
21629           newval = newval & ~0x1000;
21630           md_number_to_chars (buf+THUMB_SIZE, newval, THUMB_SIZE);
21631           fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BLX;
21632           fixP->fx_done = 1;
21633         }
21634
21635     thumb_bl_common:
21636
21637 #ifdef OBJ_ELF
21638        if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4
21639            && fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX)
21640          fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BRANCH23;
21641 #endif
21642
21643       if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX)
21644         /* For a BLX instruction, make sure that the relocation is rounded up
21645            to a word boundary.  This follows the semantics of the instruction
21646            which specifies that bit 1 of the target address will come from bit
21647            1 of the base address.  */
21648         value = (value + 1) & ~ 1;
21649
21650       if ((value & ~0x3fffff) && ((value & ~0x3fffff) != ~0x3fffff))
21651         {
21652           if (!(ARM_CPU_HAS_FEATURE (cpu_variant, arm_arch_t2)))
21653             as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21654           else if ((value & ~0x1ffffff)
21655                    && ((value & ~0x1ffffff) != ~0x1ffffff))
21656             as_bad_where (fixP->fx_file, fixP->fx_line,
21657                           _("Thumb2 branch out of range"));
21658         }
21659
21660       if (fixP->fx_done || !seg->use_rela_p)
21661         encode_thumb2_b_bl_offset (buf, value);
21662
21663       break;
21664
21665     case BFD_RELOC_THUMB_PCREL_BRANCH25:
21666       if ((value & ~0x0ffffff) && ((value & ~0x0ffffff) != ~0x0ffffff))
21667         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21668
21669       if (fixP->fx_done || !seg->use_rela_p)
21670           encode_thumb2_b_bl_offset (buf, value);
21671
21672       break;
21673
21674     case BFD_RELOC_8:
21675       if (fixP->fx_done || !seg->use_rela_p)
21676         md_number_to_chars (buf, value, 1);
21677       break;
21678
21679     case BFD_RELOC_16:
21680       if (fixP->fx_done || !seg->use_rela_p)
21681         md_number_to_chars (buf, value, 2);
21682       break;
21683
21684 #ifdef OBJ_ELF
21685     case BFD_RELOC_ARM_TLS_CALL:
21686     case BFD_RELOC_ARM_THM_TLS_CALL:
21687     case BFD_RELOC_ARM_TLS_DESCSEQ:
21688     case BFD_RELOC_ARM_THM_TLS_DESCSEQ:
21689       S_SET_THREAD_LOCAL (fixP->fx_addsy);
21690       break;
21691
21692     case BFD_RELOC_ARM_TLS_GOTDESC:
21693     case BFD_RELOC_ARM_TLS_GD32:
21694     case BFD_RELOC_ARM_TLS_LE32:
21695     case BFD_RELOC_ARM_TLS_IE32:
21696     case BFD_RELOC_ARM_TLS_LDM32:
21697     case BFD_RELOC_ARM_TLS_LDO32:
21698       S_SET_THREAD_LOCAL (fixP->fx_addsy);
21699       /* fall through */
21700
21701     case BFD_RELOC_ARM_GOT32:
21702     case BFD_RELOC_ARM_GOTOFF:
21703       if (fixP->fx_done || !seg->use_rela_p)
21704         md_number_to_chars (buf, 0, 4);
21705       break;
21706
21707     case BFD_RELOC_ARM_GOT_PREL:
21708       if (fixP->fx_done || !seg->use_rela_p)
21709         md_number_to_chars (buf, value, 4);
21710       break;
21711
21712     case BFD_RELOC_ARM_TARGET2:
21713       /* TARGET2 is not partial-inplace, so we need to write the
21714          addend here for REL targets, because it won't be written out
21715          during reloc processing later.  */
21716       if (fixP->fx_done || !seg->use_rela_p)
21717         md_number_to_chars (buf, fixP->fx_offset, 4);
21718       break;
21719 #endif
21720
21721     case BFD_RELOC_RVA:
21722     case BFD_RELOC_32:
21723     case BFD_RELOC_ARM_TARGET1:
21724     case BFD_RELOC_ARM_ROSEGREL32:
21725     case BFD_RELOC_ARM_SBREL32:
21726     case BFD_RELOC_32_PCREL:
21727 #ifdef TE_PE
21728     case BFD_RELOC_32_SECREL:
21729 #endif
21730       if (fixP->fx_done || !seg->use_rela_p)
21731 #ifdef TE_WINCE
21732         /* For WinCE we only do this for pcrel fixups.  */
21733         if (fixP->fx_done || fixP->fx_pcrel)
21734 #endif
21735           md_number_to_chars (buf, value, 4);
21736       break;
21737
21738 #ifdef OBJ_ELF
21739     case BFD_RELOC_ARM_PREL31:
21740       if (fixP->fx_done || !seg->use_rela_p)
21741         {
21742           newval = md_chars_to_number (buf, 4) & 0x80000000;
21743           if ((value ^ (value >> 1)) & 0x40000000)
21744             {
21745               as_bad_where (fixP->fx_file, fixP->fx_line,
21746                             _("rel31 relocation overflow"));
21747             }
21748           newval |= value & 0x7fffffff;
21749           md_number_to_chars (buf, newval, 4);
21750         }
21751       break;
21752 #endif
21753
21754     case BFD_RELOC_ARM_CP_OFF_IMM:
21755     case BFD_RELOC_ARM_T32_CP_OFF_IMM:
21756       if (value < -1023 || value > 1023 || (value & 3))
21757         as_bad_where (fixP->fx_file, fixP->fx_line,
21758                       _("co-processor offset out of range"));
21759     cp_off_common:
21760       sign = value > 0;
21761       if (value < 0)
21762         value = -value;
21763       if (fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
21764           || fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2)
21765         newval = md_chars_to_number (buf, INSN_SIZE);
21766       else
21767         newval = get_thumb32_insn (buf);
21768       if (value == 0)
21769         newval &= 0xffffff00;
21770       else
21771         {
21772           newval &= 0xff7fff00;
21773           newval |= (value >> 2) | (sign ? INDEX_UP : 0);
21774         }
21775       if (fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
21776           || fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2)
21777         md_number_to_chars (buf, newval, INSN_SIZE);
21778       else
21779         put_thumb32_insn (buf, newval);
21780       break;
21781
21782     case BFD_RELOC_ARM_CP_OFF_IMM_S2:
21783     case BFD_RELOC_ARM_T32_CP_OFF_IMM_S2:
21784       if (value < -255 || value > 255)
21785         as_bad_where (fixP->fx_file, fixP->fx_line,
21786                       _("co-processor offset out of range"));
21787       value *= 4;
21788       goto cp_off_common;
21789
21790     case BFD_RELOC_ARM_THUMB_OFFSET:
21791       newval = md_chars_to_number (buf, THUMB_SIZE);
21792       /* Exactly what ranges, and where the offset is inserted depends
21793          on the type of instruction, we can establish this from the
21794          top 4 bits.  */
21795       switch (newval >> 12)
21796         {
21797         case 4: /* PC load.  */
21798           /* Thumb PC loads are somewhat odd, bit 1 of the PC is
21799              forced to zero for these loads; md_pcrel_from has already
21800              compensated for this.  */
21801           if (value & 3)
21802             as_bad_where (fixP->fx_file, fixP->fx_line,
21803                           _("invalid offset, target not word aligned (0x%08lX)"),
21804                           (((unsigned long) fixP->fx_frag->fr_address
21805                             + (unsigned long) fixP->fx_where) & ~3)
21806                           + (unsigned long) value);
21807
21808           if (value & ~0x3fc)
21809             as_bad_where (fixP->fx_file, fixP->fx_line,
21810                           _("invalid offset, value too big (0x%08lX)"),
21811                           (long) value);
21812
21813           newval |= value >> 2;
21814           break;
21815
21816         case 9: /* SP load/store.  */
21817           if (value & ~0x3fc)
21818             as_bad_where (fixP->fx_file, fixP->fx_line,
21819                           _("invalid offset, value too big (0x%08lX)"),
21820                           (long) value);
21821           newval |= value >> 2;
21822           break;
21823
21824         case 6: /* Word load/store.  */
21825           if (value & ~0x7c)
21826             as_bad_where (fixP->fx_file, fixP->fx_line,
21827                           _("invalid offset, value too big (0x%08lX)"),
21828                           (long) value);
21829           newval |= value << 4; /* 6 - 2.  */
21830           break;
21831
21832         case 7: /* Byte load/store.  */
21833           if (value & ~0x1f)
21834             as_bad_where (fixP->fx_file, fixP->fx_line,
21835                           _("invalid offset, value too big (0x%08lX)"),
21836                           (long) value);
21837           newval |= value << 6;
21838           break;
21839
21840         case 8: /* Halfword load/store.  */
21841           if (value & ~0x3e)
21842             as_bad_where (fixP->fx_file, fixP->fx_line,
21843                           _("invalid offset, value too big (0x%08lX)"),
21844                           (long) value);
21845           newval |= value << 5; /* 6 - 1.  */
21846           break;
21847
21848         default:
21849           as_bad_where (fixP->fx_file, fixP->fx_line,
21850                         "Unable to process relocation for thumb opcode: %lx",
21851                         (unsigned long) newval);
21852           break;
21853         }
21854       md_number_to_chars (buf, newval, THUMB_SIZE);
21855       break;
21856
21857     case BFD_RELOC_ARM_THUMB_ADD:
21858       /* This is a complicated relocation, since we use it for all of
21859          the following immediate relocations:
21860
21861             3bit ADD/SUB
21862             8bit ADD/SUB
21863             9bit ADD/SUB SP word-aligned
21864            10bit ADD PC/SP word-aligned
21865
21866          The type of instruction being processed is encoded in the
21867          instruction field:
21868
21869            0x8000  SUB
21870            0x00F0  Rd
21871            0x000F  Rs
21872       */
21873       newval = md_chars_to_number (buf, THUMB_SIZE);
21874       {
21875         int rd = (newval >> 4) & 0xf;
21876         int rs = newval & 0xf;
21877         int subtract = !!(newval & 0x8000);
21878
21879         /* Check for HI regs, only very restricted cases allowed:
21880            Adjusting SP, and using PC or SP to get an address.  */
21881         if ((rd > 7 && (rd != REG_SP || rs != REG_SP))
21882             || (rs > 7 && rs != REG_SP && rs != REG_PC))
21883           as_bad_where (fixP->fx_file, fixP->fx_line,
21884                         _("invalid Hi register with immediate"));
21885
21886         /* If value is negative, choose the opposite instruction.  */
21887         if (value < 0)
21888           {
21889             value = -value;
21890             subtract = !subtract;
21891             if (value < 0)
21892               as_bad_where (fixP->fx_file, fixP->fx_line,
21893                             _("immediate value out of range"));
21894           }
21895
21896         if (rd == REG_SP)
21897           {
21898             if (value & ~0x1fc)
21899               as_bad_where (fixP->fx_file, fixP->fx_line,
21900                             _("invalid immediate for stack address calculation"));
21901             newval = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
21902             newval |= value >> 2;
21903           }
21904         else if (rs == REG_PC || rs == REG_SP)
21905           {
21906             if (subtract || value & ~0x3fc)
21907               as_bad_where (fixP->fx_file, fixP->fx_line,
21908                             _("invalid immediate for address calculation (value = 0x%08lX)"),
21909                             (unsigned long) value);
21910             newval = (rs == REG_PC ? T_OPCODE_ADD_PC : T_OPCODE_ADD_SP);
21911             newval |= rd << 8;
21912             newval |= value >> 2;
21913           }
21914         else if (rs == rd)
21915           {
21916             if (value & ~0xff)
21917               as_bad_where (fixP->fx_file, fixP->fx_line,
21918                             _("immediate value out of range"));
21919             newval = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
21920             newval |= (rd << 8) | value;
21921           }
21922         else
21923           {
21924             if (value & ~0x7)
21925               as_bad_where (fixP->fx_file, fixP->fx_line,
21926                             _("immediate value out of range"));
21927             newval = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
21928             newval |= rd | (rs << 3) | (value << 6);
21929           }
21930       }
21931       md_number_to_chars (buf, newval, THUMB_SIZE);
21932       break;
21933
21934     case BFD_RELOC_ARM_THUMB_IMM:
21935       newval = md_chars_to_number (buf, THUMB_SIZE);
21936       if (value < 0 || value > 255)
21937         as_bad_where (fixP->fx_file, fixP->fx_line,
21938                       _("invalid immediate: %ld is out of range"),
21939                       (long) value);
21940       newval |= value;
21941       md_number_to_chars (buf, newval, THUMB_SIZE);
21942       break;
21943
21944     case BFD_RELOC_ARM_THUMB_SHIFT:
21945       /* 5bit shift value (0..32).  LSL cannot take 32.  */
21946       newval = md_chars_to_number (buf, THUMB_SIZE) & 0xf83f;
21947       temp = newval & 0xf800;
21948       if (value < 0 || value > 32 || (value == 32 && temp == T_OPCODE_LSL_I))
21949         as_bad_where (fixP->fx_file, fixP->fx_line,
21950                       _("invalid shift value: %ld"), (long) value);
21951       /* Shifts of zero must be encoded as LSL.  */
21952       if (value == 0)
21953         newval = (newval & 0x003f) | T_OPCODE_LSL_I;
21954       /* Shifts of 32 are encoded as zero.  */
21955       else if (value == 32)
21956         value = 0;
21957       newval |= value << 6;
21958       md_number_to_chars (buf, newval, THUMB_SIZE);
21959       break;
21960
21961     case BFD_RELOC_VTABLE_INHERIT:
21962     case BFD_RELOC_VTABLE_ENTRY:
21963       fixP->fx_done = 0;
21964       return;
21965
21966     case BFD_RELOC_ARM_MOVW:
21967     case BFD_RELOC_ARM_MOVT:
21968     case BFD_RELOC_ARM_THUMB_MOVW:
21969     case BFD_RELOC_ARM_THUMB_MOVT:
21970       if (fixP->fx_done || !seg->use_rela_p)
21971         {
21972           /* REL format relocations are limited to a 16-bit addend.  */
21973           if (!fixP->fx_done)
21974             {
21975               if (value < -0x8000 || value > 0x7fff)
21976                   as_bad_where (fixP->fx_file, fixP->fx_line,
21977                                 _("offset out of range"));
21978             }
21979           else if (fixP->fx_r_type == BFD_RELOC_ARM_MOVT
21980                    || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT)
21981             {
21982               value >>= 16;
21983             }
21984
21985           if (fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW
21986               || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT)
21987             {
21988               newval = get_thumb32_insn (buf);
21989               newval &= 0xfbf08f00;
21990               newval |= (value & 0xf000) << 4;
21991               newval |= (value & 0x0800) << 15;
21992               newval |= (value & 0x0700) << 4;
21993               newval |= (value & 0x00ff);
21994               put_thumb32_insn (buf, newval);
21995             }
21996           else
21997             {
21998               newval = md_chars_to_number (buf, 4);
21999               newval &= 0xfff0f000;
22000               newval |= value & 0x0fff;
22001               newval |= (value & 0xf000) << 4;
22002               md_number_to_chars (buf, newval, 4);
22003             }
22004         }
22005       return;
22006
22007    case BFD_RELOC_ARM_ALU_PC_G0_NC:
22008    case BFD_RELOC_ARM_ALU_PC_G0:
22009    case BFD_RELOC_ARM_ALU_PC_G1_NC:
22010    case BFD_RELOC_ARM_ALU_PC_G1:
22011    case BFD_RELOC_ARM_ALU_PC_G2:
22012    case BFD_RELOC_ARM_ALU_SB_G0_NC:
22013    case BFD_RELOC_ARM_ALU_SB_G0:
22014    case BFD_RELOC_ARM_ALU_SB_G1_NC:
22015    case BFD_RELOC_ARM_ALU_SB_G1:
22016    case BFD_RELOC_ARM_ALU_SB_G2:
22017      gas_assert (!fixP->fx_done);
22018      if (!seg->use_rela_p)
22019        {
22020          bfd_vma insn;
22021          bfd_vma encoded_addend;
22022          bfd_vma addend_abs = abs (value);
22023
22024          /* Check that the absolute value of the addend can be
22025             expressed as an 8-bit constant plus a rotation.  */
22026          encoded_addend = encode_arm_immediate (addend_abs);
22027          if (encoded_addend == (unsigned int) FAIL)
22028            as_bad_where (fixP->fx_file, fixP->fx_line,
22029                          _("the offset 0x%08lX is not representable"),
22030                          (unsigned long) addend_abs);
22031
22032          /* Extract the instruction.  */
22033          insn = md_chars_to_number (buf, INSN_SIZE);
22034
22035          /* If the addend is positive, use an ADD instruction.
22036             Otherwise use a SUB.  Take care not to destroy the S bit.  */
22037          insn &= 0xff1fffff;
22038          if (value < 0)
22039            insn |= 1 << 22;
22040          else
22041            insn |= 1 << 23;
22042
22043          /* Place the encoded addend into the first 12 bits of the
22044             instruction.  */
22045          insn &= 0xfffff000;
22046          insn |= encoded_addend;
22047
22048          /* Update the instruction.  */
22049          md_number_to_chars (buf, insn, INSN_SIZE);
22050        }
22051      break;
22052
22053     case BFD_RELOC_ARM_LDR_PC_G0:
22054     case BFD_RELOC_ARM_LDR_PC_G1:
22055     case BFD_RELOC_ARM_LDR_PC_G2:
22056     case BFD_RELOC_ARM_LDR_SB_G0:
22057     case BFD_RELOC_ARM_LDR_SB_G1:
22058     case BFD_RELOC_ARM_LDR_SB_G2:
22059       gas_assert (!fixP->fx_done);
22060       if (!seg->use_rela_p)
22061         {
22062           bfd_vma insn;
22063           bfd_vma addend_abs = abs (value);
22064
22065           /* Check that the absolute value of the addend can be
22066              encoded in 12 bits.  */
22067           if (addend_abs >= 0x1000)
22068             as_bad_where (fixP->fx_file, fixP->fx_line,
22069                           _("bad offset 0x%08lX (only 12 bits available for the magnitude)"),
22070                           (unsigned long) addend_abs);
22071
22072           /* Extract the instruction.  */
22073           insn = md_chars_to_number (buf, INSN_SIZE);
22074
22075           /* If the addend is negative, clear bit 23 of the instruction.
22076              Otherwise set it.  */
22077           if (value < 0)
22078             insn &= ~(1 << 23);
22079           else
22080             insn |= 1 << 23;
22081
22082           /* Place the absolute value of the addend into the first 12 bits
22083              of the instruction.  */
22084           insn &= 0xfffff000;
22085           insn |= addend_abs;
22086
22087           /* Update the instruction.  */
22088           md_number_to_chars (buf, insn, INSN_SIZE);
22089         }
22090       break;
22091
22092     case BFD_RELOC_ARM_LDRS_PC_G0:
22093     case BFD_RELOC_ARM_LDRS_PC_G1:
22094     case BFD_RELOC_ARM_LDRS_PC_G2:
22095     case BFD_RELOC_ARM_LDRS_SB_G0:
22096     case BFD_RELOC_ARM_LDRS_SB_G1:
22097     case BFD_RELOC_ARM_LDRS_SB_G2:
22098       gas_assert (!fixP->fx_done);
22099       if (!seg->use_rela_p)
22100         {
22101           bfd_vma insn;
22102           bfd_vma addend_abs = abs (value);
22103
22104           /* Check that the absolute value of the addend can be
22105              encoded in 8 bits.  */
22106           if (addend_abs >= 0x100)
22107             as_bad_where (fixP->fx_file, fixP->fx_line,
22108                           _("bad offset 0x%08lX (only 8 bits available for the magnitude)"),
22109                           (unsigned long) addend_abs);
22110
22111           /* Extract the instruction.  */
22112           insn = md_chars_to_number (buf, INSN_SIZE);
22113
22114           /* If the addend is negative, clear bit 23 of the instruction.
22115              Otherwise set it.  */
22116           if (value < 0)
22117             insn &= ~(1 << 23);
22118           else
22119             insn |= 1 << 23;
22120
22121           /* Place the first four bits of the absolute value of the addend
22122              into the first 4 bits of the instruction, and the remaining
22123              four into bits 8 .. 11.  */
22124           insn &= 0xfffff0f0;
22125           insn |= (addend_abs & 0xf) | ((addend_abs & 0xf0) << 4);
22126
22127           /* Update the instruction.  */
22128           md_number_to_chars (buf, insn, INSN_SIZE);
22129         }
22130       break;
22131
22132     case BFD_RELOC_ARM_LDC_PC_G0:
22133     case BFD_RELOC_ARM_LDC_PC_G1:
22134     case BFD_RELOC_ARM_LDC_PC_G2:
22135     case BFD_RELOC_ARM_LDC_SB_G0:
22136     case BFD_RELOC_ARM_LDC_SB_G1:
22137     case BFD_RELOC_ARM_LDC_SB_G2:
22138       gas_assert (!fixP->fx_done);
22139       if (!seg->use_rela_p)
22140         {
22141           bfd_vma insn;
22142           bfd_vma addend_abs = abs (value);
22143
22144           /* Check that the absolute value of the addend is a multiple of
22145              four and, when divided by four, fits in 8 bits.  */
22146           if (addend_abs & 0x3)
22147             as_bad_where (fixP->fx_file, fixP->fx_line,
22148                           _("bad offset 0x%08lX (must be word-aligned)"),
22149                           (unsigned long) addend_abs);
22150
22151           if ((addend_abs >> 2) > 0xff)
22152             as_bad_where (fixP->fx_file, fixP->fx_line,
22153                           _("bad offset 0x%08lX (must be an 8-bit number of words)"),
22154                           (unsigned long) addend_abs);
22155
22156           /* Extract the instruction.  */
22157           insn = md_chars_to_number (buf, INSN_SIZE);
22158
22159           /* If the addend is negative, clear bit 23 of the instruction.
22160              Otherwise set it.  */
22161           if (value < 0)
22162             insn &= ~(1 << 23);
22163           else
22164             insn |= 1 << 23;
22165
22166           /* Place the addend (divided by four) into the first eight
22167              bits of the instruction.  */
22168           insn &= 0xfffffff0;
22169           insn |= addend_abs >> 2;
22170
22171           /* Update the instruction.  */
22172           md_number_to_chars (buf, insn, INSN_SIZE);
22173         }
22174       break;
22175
22176     case BFD_RELOC_ARM_V4BX:
22177       /* This will need to go in the object file.  */
22178       fixP->fx_done = 0;
22179       break;
22180
22181     case BFD_RELOC_UNUSED:
22182     default:
22183       as_bad_where (fixP->fx_file, fixP->fx_line,
22184                     _("bad relocation fixup type (%d)"), fixP->fx_r_type);
22185     }
22186 }
22187
22188 /* Translate internal representation of relocation info to BFD target
22189    format.  */
22190
22191 arelent *
22192 tc_gen_reloc (asection *section, fixS *fixp)
22193 {
22194   arelent * reloc;
22195   bfd_reloc_code_real_type code;
22196
22197   reloc = (arelent *) xmalloc (sizeof (arelent));
22198
22199   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
22200   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
22201   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
22202
22203   if (fixp->fx_pcrel)
22204     {
22205       if (section->use_rela_p)
22206         fixp->fx_offset -= md_pcrel_from_section (fixp, section);
22207       else
22208         fixp->fx_offset = reloc->address;
22209     }
22210   reloc->addend = fixp->fx_offset;
22211
22212   switch (fixp->fx_r_type)
22213     {
22214     case BFD_RELOC_8:
22215       if (fixp->fx_pcrel)
22216         {
22217           code = BFD_RELOC_8_PCREL;
22218           break;
22219         }
22220
22221     case BFD_RELOC_16:
22222       if (fixp->fx_pcrel)
22223         {
22224           code = BFD_RELOC_16_PCREL;
22225           break;
22226         }
22227
22228     case BFD_RELOC_32:
22229       if (fixp->fx_pcrel)
22230         {
22231           code = BFD_RELOC_32_PCREL;
22232           break;
22233         }
22234
22235     case BFD_RELOC_ARM_MOVW:
22236       if (fixp->fx_pcrel)
22237         {
22238           code = BFD_RELOC_ARM_MOVW_PCREL;
22239           break;
22240         }
22241
22242     case BFD_RELOC_ARM_MOVT:
22243       if (fixp->fx_pcrel)
22244         {
22245           code = BFD_RELOC_ARM_MOVT_PCREL;
22246           break;
22247         }
22248
22249     case BFD_RELOC_ARM_THUMB_MOVW:
22250       if (fixp->fx_pcrel)
22251         {
22252           code = BFD_RELOC_ARM_THUMB_MOVW_PCREL;
22253           break;
22254         }
22255
22256     case BFD_RELOC_ARM_THUMB_MOVT:
22257       if (fixp->fx_pcrel)
22258         {
22259           code = BFD_RELOC_ARM_THUMB_MOVT_PCREL;
22260           break;
22261         }
22262
22263     case BFD_RELOC_NONE:
22264     case BFD_RELOC_ARM_PCREL_BRANCH:
22265     case BFD_RELOC_ARM_PCREL_BLX:
22266     case BFD_RELOC_RVA:
22267     case BFD_RELOC_THUMB_PCREL_BRANCH7:
22268     case BFD_RELOC_THUMB_PCREL_BRANCH9:
22269     case BFD_RELOC_THUMB_PCREL_BRANCH12:
22270     case BFD_RELOC_THUMB_PCREL_BRANCH20:
22271     case BFD_RELOC_THUMB_PCREL_BRANCH23:
22272     case BFD_RELOC_THUMB_PCREL_BRANCH25:
22273     case BFD_RELOC_VTABLE_ENTRY:
22274     case BFD_RELOC_VTABLE_INHERIT:
22275 #ifdef TE_PE
22276     case BFD_RELOC_32_SECREL:
22277 #endif
22278       code = fixp->fx_r_type;
22279       break;
22280
22281     case BFD_RELOC_THUMB_PCREL_BLX:
22282 #ifdef OBJ_ELF
22283       if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
22284         code = BFD_RELOC_THUMB_PCREL_BRANCH23;
22285       else
22286 #endif
22287         code = BFD_RELOC_THUMB_PCREL_BLX;
22288       break;
22289
22290     case BFD_RELOC_ARM_LITERAL:
22291     case BFD_RELOC_ARM_HWLITERAL:
22292       /* If this is called then the a literal has
22293          been referenced across a section boundary.  */
22294       as_bad_where (fixp->fx_file, fixp->fx_line,
22295                     _("literal referenced across section boundary"));
22296       return NULL;
22297
22298 #ifdef OBJ_ELF
22299     case BFD_RELOC_ARM_TLS_CALL:
22300     case BFD_RELOC_ARM_THM_TLS_CALL:
22301     case BFD_RELOC_ARM_TLS_DESCSEQ:
22302     case BFD_RELOC_ARM_THM_TLS_DESCSEQ:
22303     case BFD_RELOC_ARM_GOT32:
22304     case BFD_RELOC_ARM_GOTOFF:
22305     case BFD_RELOC_ARM_GOT_PREL:
22306     case BFD_RELOC_ARM_PLT32:
22307     case BFD_RELOC_ARM_TARGET1:
22308     case BFD_RELOC_ARM_ROSEGREL32:
22309     case BFD_RELOC_ARM_SBREL32:
22310     case BFD_RELOC_ARM_PREL31:
22311     case BFD_RELOC_ARM_TARGET2:
22312     case BFD_RELOC_ARM_TLS_LE32:
22313     case BFD_RELOC_ARM_TLS_LDO32:
22314     case BFD_RELOC_ARM_PCREL_CALL:
22315     case BFD_RELOC_ARM_PCREL_JUMP:
22316     case BFD_RELOC_ARM_ALU_PC_G0_NC:
22317     case BFD_RELOC_ARM_ALU_PC_G0:
22318     case BFD_RELOC_ARM_ALU_PC_G1_NC:
22319     case BFD_RELOC_ARM_ALU_PC_G1:
22320     case BFD_RELOC_ARM_ALU_PC_G2:
22321     case BFD_RELOC_ARM_LDR_PC_G0:
22322     case BFD_RELOC_ARM_LDR_PC_G1:
22323     case BFD_RELOC_ARM_LDR_PC_G2:
22324     case BFD_RELOC_ARM_LDRS_PC_G0:
22325     case BFD_RELOC_ARM_LDRS_PC_G1:
22326     case BFD_RELOC_ARM_LDRS_PC_G2:
22327     case BFD_RELOC_ARM_LDC_PC_G0:
22328     case BFD_RELOC_ARM_LDC_PC_G1:
22329     case BFD_RELOC_ARM_LDC_PC_G2:
22330     case BFD_RELOC_ARM_ALU_SB_G0_NC:
22331     case BFD_RELOC_ARM_ALU_SB_G0:
22332     case BFD_RELOC_ARM_ALU_SB_G1_NC:
22333     case BFD_RELOC_ARM_ALU_SB_G1:
22334     case BFD_RELOC_ARM_ALU_SB_G2:
22335     case BFD_RELOC_ARM_LDR_SB_G0:
22336     case BFD_RELOC_ARM_LDR_SB_G1:
22337     case BFD_RELOC_ARM_LDR_SB_G2:
22338     case BFD_RELOC_ARM_LDRS_SB_G0:
22339     case BFD_RELOC_ARM_LDRS_SB_G1:
22340     case BFD_RELOC_ARM_LDRS_SB_G2:
22341     case BFD_RELOC_ARM_LDC_SB_G0:
22342     case BFD_RELOC_ARM_LDC_SB_G1:
22343     case BFD_RELOC_ARM_LDC_SB_G2:
22344     case BFD_RELOC_ARM_V4BX:
22345       code = fixp->fx_r_type;
22346       break;
22347
22348     case BFD_RELOC_ARM_TLS_GOTDESC:
22349     case BFD_RELOC_ARM_TLS_GD32:
22350     case BFD_RELOC_ARM_TLS_IE32:
22351     case BFD_RELOC_ARM_TLS_LDM32:
22352       /* BFD will include the symbol's address in the addend.
22353          But we don't want that, so subtract it out again here.  */
22354       if (!S_IS_COMMON (fixp->fx_addsy))
22355         reloc->addend -= (*reloc->sym_ptr_ptr)->value;
22356       code = fixp->fx_r_type;
22357       break;
22358 #endif
22359
22360     case BFD_RELOC_ARM_IMMEDIATE:
22361       as_bad_where (fixp->fx_file, fixp->fx_line,
22362                     _("internal relocation (type: IMMEDIATE) not fixed up"));
22363       return NULL;
22364
22365     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
22366       as_bad_where (fixp->fx_file, fixp->fx_line,
22367                     _("ADRL used for a symbol not defined in the same file"));
22368       return NULL;
22369
22370     case BFD_RELOC_ARM_OFFSET_IMM:
22371       if (section->use_rela_p)
22372         {
22373           code = fixp->fx_r_type;
22374           break;
22375         }
22376
22377       if (fixp->fx_addsy != NULL
22378           && !S_IS_DEFINED (fixp->fx_addsy)
22379           && S_IS_LOCAL (fixp->fx_addsy))
22380         {
22381           as_bad_where (fixp->fx_file, fixp->fx_line,
22382                         _("undefined local label `%s'"),
22383                         S_GET_NAME (fixp->fx_addsy));
22384           return NULL;
22385         }
22386
22387       as_bad_where (fixp->fx_file, fixp->fx_line,
22388                     _("internal_relocation (type: OFFSET_IMM) not fixed up"));
22389       return NULL;
22390
22391     default:
22392       {
22393         char * type;
22394
22395         switch (fixp->fx_r_type)
22396           {
22397           case BFD_RELOC_NONE:             type = "NONE";         break;
22398           case BFD_RELOC_ARM_OFFSET_IMM8:  type = "OFFSET_IMM8";  break;
22399           case BFD_RELOC_ARM_SHIFT_IMM:    type = "SHIFT_IMM";    break;
22400           case BFD_RELOC_ARM_SMC:          type = "SMC";          break;
22401           case BFD_RELOC_ARM_SWI:          type = "SWI";          break;
22402           case BFD_RELOC_ARM_MULTI:        type = "MULTI";        break;
22403           case BFD_RELOC_ARM_CP_OFF_IMM:   type = "CP_OFF_IMM";   break;
22404           case BFD_RELOC_ARM_T32_OFFSET_IMM: type = "T32_OFFSET_IMM"; break;
22405           case BFD_RELOC_ARM_T32_CP_OFF_IMM: type = "T32_CP_OFF_IMM"; break;
22406           case BFD_RELOC_ARM_THUMB_ADD:    type = "THUMB_ADD";    break;
22407           case BFD_RELOC_ARM_THUMB_SHIFT:  type = "THUMB_SHIFT";  break;
22408           case BFD_RELOC_ARM_THUMB_IMM:    type = "THUMB_IMM";    break;
22409           case BFD_RELOC_ARM_THUMB_OFFSET: type = "THUMB_OFFSET"; break;
22410           default:                         type = _("<unknown>"); break;
22411           }
22412         as_bad_where (fixp->fx_file, fixp->fx_line,
22413                       _("cannot represent %s relocation in this object file format"),
22414                       type);
22415         return NULL;
22416       }
22417     }
22418
22419 #ifdef OBJ_ELF
22420   if ((code == BFD_RELOC_32_PCREL || code == BFD_RELOC_32)
22421       && GOT_symbol
22422       && fixp->fx_addsy == GOT_symbol)
22423     {
22424       code = BFD_RELOC_ARM_GOTPC;
22425       reloc->addend = fixp->fx_offset = reloc->address;
22426     }
22427 #endif
22428
22429   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
22430
22431   if (reloc->howto == NULL)
22432     {
22433       as_bad_where (fixp->fx_file, fixp->fx_line,
22434                     _("cannot represent %s relocation in this object file format"),
22435                     bfd_get_reloc_code_name (code));
22436       return NULL;
22437     }
22438
22439   /* HACK: Since arm ELF uses Rel instead of Rela, encode the
22440      vtable entry to be used in the relocation's section offset.  */
22441   if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
22442     reloc->address = fixp->fx_offset;
22443
22444   return reloc;
22445 }
22446
22447 /* This fix_new is called by cons via TC_CONS_FIX_NEW.  */
22448
22449 void
22450 cons_fix_new_arm (fragS *       frag,
22451                   int           where,
22452                   int           size,
22453                   expressionS * exp)
22454 {
22455   bfd_reloc_code_real_type type;
22456   int pcrel = 0;
22457
22458   /* Pick a reloc.
22459      FIXME: @@ Should look at CPU word size.  */
22460   switch (size)
22461     {
22462     case 1:
22463       type = BFD_RELOC_8;
22464       break;
22465     case 2:
22466       type = BFD_RELOC_16;
22467       break;
22468     case 4:
22469     default:
22470       type = BFD_RELOC_32;
22471       break;
22472     case 8:
22473       type = BFD_RELOC_64;
22474       break;
22475     }
22476
22477 #ifdef TE_PE
22478   if (exp->X_op == O_secrel)
22479   {
22480     exp->X_op = O_symbol;
22481     type = BFD_RELOC_32_SECREL;
22482   }
22483 #endif
22484
22485   fix_new_exp (frag, where, (int) size, exp, pcrel, type);
22486 }
22487
22488 #if defined (OBJ_COFF)
22489 void
22490 arm_validate_fix (fixS * fixP)
22491 {
22492   /* If the destination of the branch is a defined symbol which does not have
22493      the THUMB_FUNC attribute, then we must be calling a function which has
22494      the (interfacearm) attribute.  We look for the Thumb entry point to that
22495      function and change the branch to refer to that function instead.  */
22496   if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23
22497       && fixP->fx_addsy != NULL
22498       && S_IS_DEFINED (fixP->fx_addsy)
22499       && ! THUMB_IS_FUNC (fixP->fx_addsy))
22500     {
22501       fixP->fx_addsy = find_real_start (fixP->fx_addsy);
22502     }
22503 }
22504 #endif
22505
22506
22507 int
22508 arm_force_relocation (struct fix * fixp)
22509 {
22510 #if defined (OBJ_COFF) && defined (TE_PE)
22511   if (fixp->fx_r_type == BFD_RELOC_RVA)
22512     return 1;
22513 #endif
22514
22515   /* In case we have a call or a branch to a function in ARM ISA mode from
22516      a thumb function or vice-versa force the relocation. These relocations
22517      are cleared off for some cores that might have blx and simple transformations
22518      are possible.  */
22519
22520 #ifdef OBJ_ELF
22521   switch (fixp->fx_r_type)
22522     {
22523     case BFD_RELOC_ARM_PCREL_JUMP:
22524     case BFD_RELOC_ARM_PCREL_CALL:
22525     case BFD_RELOC_THUMB_PCREL_BLX:
22526       if (THUMB_IS_FUNC (fixp->fx_addsy))
22527         return 1;
22528       break;
22529
22530     case BFD_RELOC_ARM_PCREL_BLX:
22531     case BFD_RELOC_THUMB_PCREL_BRANCH25:
22532     case BFD_RELOC_THUMB_PCREL_BRANCH20:
22533     case BFD_RELOC_THUMB_PCREL_BRANCH23:
22534       if (ARM_IS_FUNC (fixp->fx_addsy))
22535         return 1;
22536       break;
22537
22538     default:
22539       break;
22540     }
22541 #endif
22542
22543   /* Resolve these relocations even if the symbol is extern or weak.
22544      Technically this is probably wrong due to symbol preemption.
22545      In practice these relocations do not have enough range to be useful
22546      at dynamic link time, and some code (e.g. in the Linux kernel)
22547      expects these references to be resolved.  */
22548   if (fixp->fx_r_type == BFD_RELOC_ARM_IMMEDIATE
22549       || fixp->fx_r_type == BFD_RELOC_ARM_OFFSET_IMM
22550       || fixp->fx_r_type == BFD_RELOC_ARM_OFFSET_IMM8
22551       || fixp->fx_r_type == BFD_RELOC_ARM_ADRL_IMMEDIATE
22552       || fixp->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
22553       || fixp->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2
22554       || fixp->fx_r_type == BFD_RELOC_ARM_THUMB_OFFSET
22555       || fixp->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM
22556       || fixp->fx_r_type == BFD_RELOC_ARM_T32_IMMEDIATE
22557       || fixp->fx_r_type == BFD_RELOC_ARM_T32_IMM12
22558       || fixp->fx_r_type == BFD_RELOC_ARM_T32_OFFSET_IMM
22559       || fixp->fx_r_type == BFD_RELOC_ARM_T32_ADD_PC12
22560       || fixp->fx_r_type == BFD_RELOC_ARM_T32_CP_OFF_IMM
22561       || fixp->fx_r_type == BFD_RELOC_ARM_T32_CP_OFF_IMM_S2)
22562     return 0;
22563
22564   /* Always leave these relocations for the linker.  */
22565   if ((fixp->fx_r_type >= BFD_RELOC_ARM_ALU_PC_G0_NC
22566        && fixp->fx_r_type <= BFD_RELOC_ARM_LDC_SB_G2)
22567       || fixp->fx_r_type == BFD_RELOC_ARM_LDR_PC_G0)
22568     return 1;
22569
22570   /* Always generate relocations against function symbols.  */
22571   if (fixp->fx_r_type == BFD_RELOC_32
22572       && fixp->fx_addsy
22573       && (symbol_get_bfdsym (fixp->fx_addsy)->flags & BSF_FUNCTION))
22574     return 1;
22575
22576   return generic_force_reloc (fixp);
22577 }
22578
22579 #if defined (OBJ_ELF) || defined (OBJ_COFF)
22580 /* Relocations against function names must be left unadjusted,
22581    so that the linker can use this information to generate interworking
22582    stubs.  The MIPS version of this function
22583    also prevents relocations that are mips-16 specific, but I do not
22584    know why it does this.
22585
22586    FIXME:
22587    There is one other problem that ought to be addressed here, but
22588    which currently is not:  Taking the address of a label (rather
22589    than a function) and then later jumping to that address.  Such
22590    addresses also ought to have their bottom bit set (assuming that
22591    they reside in Thumb code), but at the moment they will not.  */
22592
22593 bfd_boolean
22594 arm_fix_adjustable (fixS * fixP)
22595 {
22596   if (fixP->fx_addsy == NULL)
22597     return 1;
22598
22599   /* Preserve relocations against symbols with function type.  */
22600   if (symbol_get_bfdsym (fixP->fx_addsy)->flags & BSF_FUNCTION)
22601     return FALSE;
22602
22603   if (THUMB_IS_FUNC (fixP->fx_addsy)
22604       && fixP->fx_subsy == NULL)
22605     return FALSE;
22606
22607   /* We need the symbol name for the VTABLE entries.  */
22608   if (   fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
22609       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
22610     return FALSE;
22611
22612   /* Don't allow symbols to be discarded on GOT related relocs.  */
22613   if (fixP->fx_r_type == BFD_RELOC_ARM_PLT32
22614       || fixP->fx_r_type == BFD_RELOC_ARM_GOT32
22615       || fixP->fx_r_type == BFD_RELOC_ARM_GOTOFF
22616       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_GD32
22617       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LE32
22618       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_IE32
22619       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDM32
22620       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDO32
22621       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_GOTDESC
22622       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_CALL
22623       || fixP->fx_r_type == BFD_RELOC_ARM_THM_TLS_CALL
22624       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_DESCSEQ
22625       || fixP->fx_r_type == BFD_RELOC_ARM_THM_TLS_DESCSEQ
22626       || fixP->fx_r_type == BFD_RELOC_ARM_TARGET2)
22627     return FALSE;
22628
22629   /* Similarly for group relocations.  */
22630   if ((fixP->fx_r_type >= BFD_RELOC_ARM_ALU_PC_G0_NC
22631        && fixP->fx_r_type <= BFD_RELOC_ARM_LDC_SB_G2)
22632       || fixP->fx_r_type == BFD_RELOC_ARM_LDR_PC_G0)
22633     return FALSE;
22634
22635   /* MOVW/MOVT REL relocations have limited offsets, so keep the symbols.  */
22636   if (fixP->fx_r_type == BFD_RELOC_ARM_MOVW
22637       || fixP->fx_r_type == BFD_RELOC_ARM_MOVT
22638       || fixP->fx_r_type == BFD_RELOC_ARM_MOVW_PCREL
22639       || fixP->fx_r_type == BFD_RELOC_ARM_MOVT_PCREL
22640       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW
22641       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT
22642       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW_PCREL
22643       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT_PCREL)
22644     return FALSE;
22645
22646   return TRUE;
22647 }
22648 #endif /* defined (OBJ_ELF) || defined (OBJ_COFF) */
22649
22650 #ifdef OBJ_ELF
22651
22652 const char *
22653 elf32_arm_target_format (void)
22654 {
22655 #ifdef TE_SYMBIAN
22656   return (target_big_endian
22657           ? "elf32-bigarm-symbian"
22658           : "elf32-littlearm-symbian");
22659 #elif defined (TE_VXWORKS)
22660   return (target_big_endian
22661           ? "elf32-bigarm-vxworks"
22662           : "elf32-littlearm-vxworks");
22663 #elif defined (TE_NACL)
22664   return (target_big_endian
22665           ? "elf32-bigarm-nacl"
22666           : "elf32-littlearm-nacl");
22667 #else
22668   if (target_big_endian)
22669     return "elf32-bigarm";
22670   else
22671     return "elf32-littlearm";
22672 #endif
22673 }
22674
22675 void
22676 armelf_frob_symbol (symbolS * symp,
22677                     int *     puntp)
22678 {
22679   elf_frob_symbol (symp, puntp);
22680 }
22681 #endif
22682
22683 /* MD interface: Finalization.  */
22684
22685 void
22686 arm_cleanup (void)
22687 {
22688   literal_pool * pool;
22689
22690   /* Ensure that all the IT blocks are properly closed.  */
22691   check_it_blocks_finished ();
22692
22693   for (pool = list_of_pools; pool; pool = pool->next)
22694     {
22695       /* Put it at the end of the relevant section.  */
22696       subseg_set (pool->section, pool->sub_section);
22697 #ifdef OBJ_ELF
22698       arm_elf_change_section ();
22699 #endif
22700       s_ltorg (0);
22701     }
22702 }
22703
22704 #ifdef OBJ_ELF
22705 /* Remove any excess mapping symbols generated for alignment frags in
22706    SEC.  We may have created a mapping symbol before a zero byte
22707    alignment; remove it if there's a mapping symbol after the
22708    alignment.  */
22709 static void
22710 check_mapping_symbols (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
22711                        void *dummy ATTRIBUTE_UNUSED)
22712 {
22713   segment_info_type *seginfo = seg_info (sec);
22714   fragS *fragp;
22715
22716   if (seginfo == NULL || seginfo->frchainP == NULL)
22717     return;
22718
22719   for (fragp = seginfo->frchainP->frch_root;
22720        fragp != NULL;
22721        fragp = fragp->fr_next)
22722     {
22723       symbolS *sym = fragp->tc_frag_data.last_map;
22724       fragS *next = fragp->fr_next;
22725
22726       /* Variable-sized frags have been converted to fixed size by
22727          this point.  But if this was variable-sized to start with,
22728          there will be a fixed-size frag after it.  So don't handle
22729          next == NULL.  */
22730       if (sym == NULL || next == NULL)
22731         continue;
22732
22733       if (S_GET_VALUE (sym) < next->fr_address)
22734         /* Not at the end of this frag.  */
22735         continue;
22736       know (S_GET_VALUE (sym) == next->fr_address);
22737
22738       do
22739         {
22740           if (next->tc_frag_data.first_map != NULL)
22741             {
22742               /* Next frag starts with a mapping symbol.  Discard this
22743                  one.  */
22744               symbol_remove (sym, &symbol_rootP, &symbol_lastP);
22745               break;
22746             }
22747
22748           if (next->fr_next == NULL)
22749             {
22750               /* This mapping symbol is at the end of the section.  Discard
22751                  it.  */
22752               know (next->fr_fix == 0 && next->fr_var == 0);
22753               symbol_remove (sym, &symbol_rootP, &symbol_lastP);
22754               break;
22755             }
22756
22757           /* As long as we have empty frags without any mapping symbols,
22758              keep looking.  */
22759           /* If the next frag is non-empty and does not start with a
22760              mapping symbol, then this mapping symbol is required.  */
22761           if (next->fr_address != next->fr_next->fr_address)
22762             break;
22763
22764           next = next->fr_next;
22765         }
22766       while (next != NULL);
22767     }
22768 }
22769 #endif
22770
22771 /* Adjust the symbol table.  This marks Thumb symbols as distinct from
22772    ARM ones.  */
22773
22774 void
22775 arm_adjust_symtab (void)
22776 {
22777 #ifdef OBJ_COFF
22778   symbolS * sym;
22779
22780   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
22781     {
22782       if (ARM_IS_THUMB (sym))
22783         {
22784           if (THUMB_IS_FUNC (sym))
22785             {
22786               /* Mark the symbol as a Thumb function.  */
22787               if (   S_GET_STORAGE_CLASS (sym) == C_STAT
22788                   || S_GET_STORAGE_CLASS (sym) == C_LABEL)  /* This can happen!  */
22789                 S_SET_STORAGE_CLASS (sym, C_THUMBSTATFUNC);
22790
22791               else if (S_GET_STORAGE_CLASS (sym) == C_EXT)
22792                 S_SET_STORAGE_CLASS (sym, C_THUMBEXTFUNC);
22793               else
22794                 as_bad (_("%s: unexpected function type: %d"),
22795                         S_GET_NAME (sym), S_GET_STORAGE_CLASS (sym));
22796             }
22797           else switch (S_GET_STORAGE_CLASS (sym))
22798             {
22799             case C_EXT:
22800               S_SET_STORAGE_CLASS (sym, C_THUMBEXT);
22801               break;
22802             case C_STAT:
22803               S_SET_STORAGE_CLASS (sym, C_THUMBSTAT);
22804               break;
22805             case C_LABEL:
22806               S_SET_STORAGE_CLASS (sym, C_THUMBLABEL);
22807               break;
22808             default:
22809               /* Do nothing.  */
22810               break;
22811             }
22812         }
22813
22814       if (ARM_IS_INTERWORK (sym))
22815         coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_flags = 0xFF;
22816     }
22817 #endif
22818 #ifdef OBJ_ELF
22819   symbolS * sym;
22820   char      bind;
22821
22822   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
22823     {
22824       if (ARM_IS_THUMB (sym))
22825         {
22826           elf_symbol_type * elf_sym;
22827
22828           elf_sym = elf_symbol (symbol_get_bfdsym (sym));
22829           bind = ELF_ST_BIND (elf_sym->internal_elf_sym.st_info);
22830
22831           if (! bfd_is_arm_special_symbol_name (elf_sym->symbol.name,
22832                 BFD_ARM_SPECIAL_SYM_TYPE_ANY))
22833             {
22834               /* If it's a .thumb_func, declare it as so,
22835                  otherwise tag label as .code 16.  */
22836               if (THUMB_IS_FUNC (sym))
22837                 elf_sym->internal_elf_sym.st_target_internal
22838                   = ST_BRANCH_TO_THUMB;
22839               else if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
22840                 elf_sym->internal_elf_sym.st_info =
22841                   ELF_ST_INFO (bind, STT_ARM_16BIT);
22842             }
22843         }
22844     }
22845
22846   /* Remove any overlapping mapping symbols generated by alignment frags.  */
22847   bfd_map_over_sections (stdoutput, check_mapping_symbols, (char *) 0);
22848   /* Now do generic ELF adjustments.  */
22849   elf_adjust_symtab ();
22850 #endif
22851 }
22852
22853 /* MD interface: Initialization.  */
22854
22855 static void
22856 set_constant_flonums (void)
22857 {
22858   int i;
22859
22860   for (i = 0; i < NUM_FLOAT_VALS; i++)
22861     if (atof_ieee ((char *) fp_const[i], 'x', fp_values[i]) == NULL)
22862       abort ();
22863 }
22864
22865 /* Auto-select Thumb mode if it's the only available instruction set for the
22866    given architecture.  */
22867
22868 static void
22869 autoselect_thumb_from_cpu_variant (void)
22870 {
22871   if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
22872     opcode_select (16);
22873 }
22874
22875 void
22876 md_begin (void)
22877 {
22878   unsigned mach;
22879   unsigned int i;
22880
22881   if (   (arm_ops_hsh = hash_new ()) == NULL
22882       || (arm_cond_hsh = hash_new ()) == NULL
22883       || (arm_shift_hsh = hash_new ()) == NULL
22884       || (arm_psr_hsh = hash_new ()) == NULL
22885       || (arm_v7m_psr_hsh = hash_new ()) == NULL
22886       || (arm_reg_hsh = hash_new ()) == NULL
22887       || (arm_reloc_hsh = hash_new ()) == NULL
22888       || (arm_barrier_opt_hsh = hash_new ()) == NULL)
22889     as_fatal (_("virtual memory exhausted"));
22890
22891   for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++)
22892     hash_insert (arm_ops_hsh, insns[i].template_name, (void *) (insns + i));
22893   for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++)
22894     hash_insert (arm_cond_hsh, conds[i].template_name, (void *) (conds + i));
22895   for (i = 0; i < sizeof (shift_names) / sizeof (struct asm_shift_name); i++)
22896     hash_insert (arm_shift_hsh, shift_names[i].name, (void *) (shift_names + i));
22897   for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++)
22898     hash_insert (arm_psr_hsh, psrs[i].template_name, (void *) (psrs + i));
22899   for (i = 0; i < sizeof (v7m_psrs) / sizeof (struct asm_psr); i++)
22900     hash_insert (arm_v7m_psr_hsh, v7m_psrs[i].template_name,
22901                  (void *) (v7m_psrs + i));
22902   for (i = 0; i < sizeof (reg_names) / sizeof (struct reg_entry); i++)
22903     hash_insert (arm_reg_hsh, reg_names[i].name, (void *) (reg_names + i));
22904   for (i = 0;
22905        i < sizeof (barrier_opt_names) / sizeof (struct asm_barrier_opt);
22906        i++)
22907     hash_insert (arm_barrier_opt_hsh, barrier_opt_names[i].template_name,
22908                  (void *) (barrier_opt_names + i));
22909 #ifdef OBJ_ELF
22910   for (i = 0; i < ARRAY_SIZE (reloc_names); i++)
22911     {
22912       struct reloc_entry * entry = reloc_names + i;
22913
22914       if (arm_is_eabi() && entry->reloc == BFD_RELOC_ARM_PLT32)
22915         /* This makes encode_branch() use the EABI versions of this relocation.  */
22916         entry->reloc = BFD_RELOC_UNUSED;
22917
22918       hash_insert (arm_reloc_hsh, entry->name, (void *) entry);
22919     }
22920 #endif
22921
22922   set_constant_flonums ();
22923
22924   /* Set the cpu variant based on the command-line options.  We prefer
22925      -mcpu= over -march= if both are set (as for GCC); and we prefer
22926      -mfpu= over any other way of setting the floating point unit.
22927      Use of legacy options with new options are faulted.  */
22928   if (legacy_cpu)
22929     {
22930       if (mcpu_cpu_opt || march_cpu_opt)
22931         as_bad (_("use of old and new-style options to set CPU type"));
22932
22933       mcpu_cpu_opt = legacy_cpu;
22934     }
22935   else if (!mcpu_cpu_opt)
22936     mcpu_cpu_opt = march_cpu_opt;
22937
22938   if (legacy_fpu)
22939     {
22940       if (mfpu_opt)
22941         as_bad (_("use of old and new-style options to set FPU type"));
22942
22943       mfpu_opt = legacy_fpu;
22944     }
22945   else if (!mfpu_opt)
22946     {
22947 #if !(defined (EABI_DEFAULT) || defined (TE_LINUX) \
22948         || defined (TE_NetBSD) || defined (TE_VXWORKS))
22949       /* Some environments specify a default FPU.  If they don't, infer it
22950          from the processor.  */
22951       if (mcpu_fpu_opt)
22952         mfpu_opt = mcpu_fpu_opt;
22953       else
22954         mfpu_opt = march_fpu_opt;
22955 #else
22956       mfpu_opt = &fpu_default;
22957 #endif
22958     }
22959
22960   if (!mfpu_opt)
22961     {
22962       if (mcpu_cpu_opt != NULL)
22963         mfpu_opt = &fpu_default;
22964       else if (mcpu_fpu_opt != NULL && ARM_CPU_HAS_FEATURE (*mcpu_fpu_opt, arm_ext_v5))
22965         mfpu_opt = &fpu_arch_vfp_v2;
22966       else
22967         mfpu_opt = &fpu_arch_fpa;
22968     }
22969
22970 #ifdef CPU_DEFAULT
22971   if (!mcpu_cpu_opt)
22972     {
22973       mcpu_cpu_opt = &cpu_default;
22974       selected_cpu = cpu_default;
22975     }
22976 #else
22977   if (mcpu_cpu_opt)
22978     selected_cpu = *mcpu_cpu_opt;
22979   else
22980     mcpu_cpu_opt = &arm_arch_any;
22981 #endif
22982
22983   ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
22984
22985   autoselect_thumb_from_cpu_variant ();
22986
22987   arm_arch_used = thumb_arch_used = arm_arch_none;
22988
22989 #if defined OBJ_COFF || defined OBJ_ELF
22990   {
22991     unsigned int flags = 0;
22992
22993 #if defined OBJ_ELF
22994     flags = meabi_flags;
22995
22996     switch (meabi_flags)
22997       {
22998       case EF_ARM_EABI_UNKNOWN:
22999 #endif
23000         /* Set the flags in the private structure.  */
23001         if (uses_apcs_26)      flags |= F_APCS26;
23002         if (support_interwork) flags |= F_INTERWORK;
23003         if (uses_apcs_float)   flags |= F_APCS_FLOAT;
23004         if (pic_code)          flags |= F_PIC;
23005         if (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_any_hard))
23006           flags |= F_SOFT_FLOAT;
23007
23008         switch (mfloat_abi_opt)
23009           {
23010           case ARM_FLOAT_ABI_SOFT:
23011           case ARM_FLOAT_ABI_SOFTFP:
23012             flags |= F_SOFT_FLOAT;
23013             break;
23014
23015           case ARM_FLOAT_ABI_HARD:
23016             if (flags & F_SOFT_FLOAT)
23017               as_bad (_("hard-float conflicts with specified fpu"));
23018             break;
23019           }
23020
23021         /* Using pure-endian doubles (even if soft-float).      */
23022         if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_endian_pure))
23023           flags |= F_VFP_FLOAT;
23024
23025 #if defined OBJ_ELF
23026         if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_arch_maverick))
23027             flags |= EF_ARM_MAVERICK_FLOAT;
23028         break;
23029
23030       case EF_ARM_EABI_VER4:
23031       case EF_ARM_EABI_VER5:
23032         /* No additional flags to set.  */
23033         break;
23034
23035       default:
23036         abort ();
23037       }
23038 #endif
23039     bfd_set_private_flags (stdoutput, flags);
23040
23041     /* We have run out flags in the COFF header to encode the
23042        status of ATPCS support, so instead we create a dummy,
23043        empty, debug section called .arm.atpcs.  */
23044     if (atpcs)
23045       {
23046         asection * sec;
23047
23048         sec = bfd_make_section (stdoutput, ".arm.atpcs");
23049
23050         if (sec != NULL)
23051           {
23052             bfd_set_section_flags
23053               (stdoutput, sec, SEC_READONLY | SEC_DEBUGGING /* | SEC_HAS_CONTENTS */);
23054             bfd_set_section_size (stdoutput, sec, 0);
23055             bfd_set_section_contents (stdoutput, sec, NULL, 0, 0);
23056           }
23057       }
23058   }
23059 #endif
23060
23061   /* Record the CPU type as well.  */
23062   if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt2))
23063     mach = bfd_mach_arm_iWMMXt2;
23064   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt))
23065     mach = bfd_mach_arm_iWMMXt;
23066   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_xscale))
23067     mach = bfd_mach_arm_XScale;
23068   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_maverick))
23069     mach = bfd_mach_arm_ep9312;
23070   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v5e))
23071     mach = bfd_mach_arm_5TE;
23072   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v5))
23073     {
23074       if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
23075         mach = bfd_mach_arm_5T;
23076       else
23077         mach = bfd_mach_arm_5;
23078     }
23079   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4))
23080     {
23081       if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
23082         mach = bfd_mach_arm_4T;
23083       else
23084         mach = bfd_mach_arm_4;
23085     }
23086   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v3m))
23087     mach = bfd_mach_arm_3M;
23088   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v3))
23089     mach = bfd_mach_arm_3;
23090   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v2s))
23091     mach = bfd_mach_arm_2a;
23092   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v2))
23093     mach = bfd_mach_arm_2;
23094   else
23095     mach = bfd_mach_arm_unknown;
23096
23097   bfd_set_arch_mach (stdoutput, TARGET_ARCH, mach);
23098 }
23099
23100 /* Command line processing.  */
23101
23102 /* md_parse_option
23103       Invocation line includes a switch not recognized by the base assembler.
23104       See if it's a processor-specific option.
23105
23106       This routine is somewhat complicated by the need for backwards
23107       compatibility (since older releases of gcc can't be changed).
23108       The new options try to make the interface as compatible as
23109       possible with GCC.
23110
23111       New options (supported) are:
23112
23113               -mcpu=<cpu name>           Assemble for selected processor
23114               -march=<architecture name> Assemble for selected architecture
23115               -mfpu=<fpu architecture>   Assemble for selected FPU.
23116               -EB/-mbig-endian           Big-endian
23117               -EL/-mlittle-endian        Little-endian
23118               -k                         Generate PIC code
23119               -mthumb                    Start in Thumb mode
23120               -mthumb-interwork          Code supports ARM/Thumb interworking
23121
23122               -m[no-]warn-deprecated     Warn about deprecated features
23123
23124       For now we will also provide support for:
23125
23126               -mapcs-32                  32-bit Program counter
23127               -mapcs-26                  26-bit Program counter
23128               -macps-float               Floats passed in FP registers
23129               -mapcs-reentrant           Reentrant code
23130               -matpcs
23131       (sometime these will probably be replaced with -mapcs=<list of options>
23132       and -matpcs=<list of options>)
23133
23134       The remaining options are only supported for back-wards compatibility.
23135       Cpu variants, the arm part is optional:
23136               -m[arm]1                Currently not supported.
23137               -m[arm]2, -m[arm]250    Arm 2 and Arm 250 processor
23138               -m[arm]3                Arm 3 processor
23139               -m[arm]6[xx],           Arm 6 processors
23140               -m[arm]7[xx][t][[d]m]   Arm 7 processors
23141               -m[arm]8[10]            Arm 8 processors
23142               -m[arm]9[20][tdmi]      Arm 9 processors
23143               -mstrongarm[110[0]]     StrongARM processors
23144               -mxscale                XScale processors
23145               -m[arm]v[2345[t[e]]]    Arm architectures
23146               -mall                   All (except the ARM1)
23147       FP variants:
23148               -mfpa10, -mfpa11        FPA10 and 11 co-processor instructions
23149               -mfpe-old               (No float load/store multiples)
23150               -mvfpxd                 VFP Single precision
23151               -mvfp                   All VFP
23152               -mno-fpu                Disable all floating point instructions
23153
23154       The following CPU names are recognized:
23155               arm1, arm2, arm250, arm3, arm6, arm600, arm610, arm620,
23156               arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700,
23157               arm700i, arm710 arm710t, arm720, arm720t, arm740t, arm710c,
23158               arm7100, arm7500, arm7500fe, arm7tdmi, arm8, arm810, arm9,
23159               arm920, arm920t, arm940t, arm946, arm966, arm9tdmi, arm9e,
23160               arm10t arm10e, arm1020t, arm1020e, arm10200e,
23161               strongarm, strongarm110, strongarm1100, strongarm1110, xscale.
23162
23163       */
23164
23165 const char * md_shortopts = "m:k";
23166
23167 #ifdef ARM_BI_ENDIAN
23168 #define OPTION_EB (OPTION_MD_BASE + 0)
23169 #define OPTION_EL (OPTION_MD_BASE + 1)
23170 #else
23171 #if TARGET_BYTES_BIG_ENDIAN
23172 #define OPTION_EB (OPTION_MD_BASE + 0)
23173 #else
23174 #define OPTION_EL (OPTION_MD_BASE + 1)
23175 #endif
23176 #endif
23177 #define OPTION_FIX_V4BX (OPTION_MD_BASE + 2)
23178
23179 struct option md_longopts[] =
23180 {
23181 #ifdef OPTION_EB
23182   {"EB", no_argument, NULL, OPTION_EB},
23183 #endif
23184 #ifdef OPTION_EL
23185   {"EL", no_argument, NULL, OPTION_EL},
23186 #endif
23187   {"fix-v4bx", no_argument, NULL, OPTION_FIX_V4BX},
23188   {NULL, no_argument, NULL, 0}
23189 };
23190
23191 size_t md_longopts_size = sizeof (md_longopts);
23192
23193 struct arm_option_table
23194 {
23195   char *option;         /* Option name to match.  */
23196   char *help;           /* Help information.  */
23197   int  *var;            /* Variable to change.  */
23198   int   value;          /* What to change it to.  */
23199   char *deprecated;     /* If non-null, print this message.  */
23200 };
23201
23202 struct arm_option_table arm_opts[] =
23203 {
23204   {"k",      N_("generate PIC code"),      &pic_code,    1, NULL},
23205   {"mthumb", N_("assemble Thumb code"),    &thumb_mode,  1, NULL},
23206   {"mthumb-interwork", N_("support ARM/Thumb interworking"),
23207    &support_interwork, 1, NULL},
23208   {"mapcs-32", N_("code uses 32-bit program counter"), &uses_apcs_26, 0, NULL},
23209   {"mapcs-26", N_("code uses 26-bit program counter"), &uses_apcs_26, 1, NULL},
23210   {"mapcs-float", N_("floating point args are in fp regs"), &uses_apcs_float,
23211    1, NULL},
23212   {"mapcs-reentrant", N_("re-entrant code"), &pic_code, 1, NULL},
23213   {"matpcs", N_("code is ATPCS conformant"), &atpcs, 1, NULL},
23214   {"mbig-endian", N_("assemble for big-endian"), &target_big_endian, 1, NULL},
23215   {"mlittle-endian", N_("assemble for little-endian"), &target_big_endian, 0,
23216    NULL},
23217
23218   /* These are recognized by the assembler, but have no affect on code.  */
23219   {"mapcs-frame", N_("use frame pointer"), NULL, 0, NULL},
23220   {"mapcs-stack-check", N_("use stack size checking"), NULL, 0, NULL},
23221
23222   {"mwarn-deprecated", NULL, &warn_on_deprecated, 1, NULL},
23223   {"mno-warn-deprecated", N_("do not warn on use of deprecated feature"),
23224    &warn_on_deprecated, 0, NULL},
23225   {NULL, NULL, NULL, 0, NULL}
23226 };
23227
23228 struct arm_legacy_option_table
23229 {
23230   char *option;                         /* Option name to match.  */
23231   const arm_feature_set **var;          /* Variable to change.  */
23232   const arm_feature_set value;          /* What to change it to.  */
23233   char *deprecated;                     /* If non-null, print this message.  */
23234 };
23235
23236 const struct arm_legacy_option_table arm_legacy_opts[] =
23237 {
23238   /* DON'T add any new processors to this list -- we want the whole list
23239      to go away...  Add them to the processors table instead.  */
23240   {"marm1",      &legacy_cpu, ARM_ARCH_V1,  N_("use -mcpu=arm1")},
23241   {"m1",         &legacy_cpu, ARM_ARCH_V1,  N_("use -mcpu=arm1")},
23242   {"marm2",      &legacy_cpu, ARM_ARCH_V2,  N_("use -mcpu=arm2")},
23243   {"m2",         &legacy_cpu, ARM_ARCH_V2,  N_("use -mcpu=arm2")},
23244   {"marm250",    &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm250")},
23245   {"m250",       &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm250")},
23246   {"marm3",      &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm3")},
23247   {"m3",         &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm3")},
23248   {"marm6",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm6")},
23249   {"m6",         &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm6")},
23250   {"marm600",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm600")},
23251   {"m600",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm600")},
23252   {"marm610",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm610")},
23253   {"m610",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm610")},
23254   {"marm620",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm620")},
23255   {"m620",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm620")},
23256   {"marm7",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7")},
23257   {"m7",         &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7")},
23258   {"marm70",     &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm70")},
23259   {"m70",        &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm70")},
23260   {"marm700",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700")},
23261   {"m700",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700")},
23262   {"marm700i",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700i")},
23263   {"m700i",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700i")},
23264   {"marm710",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710")},
23265   {"m710",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710")},
23266   {"marm710c",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710c")},
23267   {"m710c",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710c")},
23268   {"marm720",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm720")},
23269   {"m720",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm720")},
23270   {"marm7d",     &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7d")},
23271   {"m7d",        &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7d")},
23272   {"marm7di",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7di")},
23273   {"m7di",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7di")},
23274   {"marm7m",     &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7m")},
23275   {"m7m",        &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7m")},
23276   {"marm7dm",    &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dm")},
23277   {"m7dm",       &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dm")},
23278   {"marm7dmi",   &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dmi")},
23279   {"m7dmi",      &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dmi")},
23280   {"marm7100",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7100")},
23281   {"m7100",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7100")},
23282   {"marm7500",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500")},
23283   {"m7500",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500")},
23284   {"marm7500fe", &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500fe")},
23285   {"m7500fe",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500fe")},
23286   {"marm7t",     &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
23287   {"m7t",        &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
23288   {"marm7tdmi",  &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
23289   {"m7tdmi",     &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
23290   {"marm710t",   &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm710t")},
23291   {"m710t",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm710t")},
23292   {"marm720t",   &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm720t")},
23293   {"m720t",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm720t")},
23294   {"marm740t",   &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm740t")},
23295   {"m740t",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm740t")},
23296   {"marm8",      &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm8")},
23297   {"m8",         &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm8")},
23298   {"marm810",    &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm810")},
23299   {"m810",       &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm810")},
23300   {"marm9",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9")},
23301   {"m9",         &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9")},
23302   {"marm9tdmi",  &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9tdmi")},
23303   {"m9tdmi",     &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9tdmi")},
23304   {"marm920",    &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm920")},
23305   {"m920",       &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm920")},
23306   {"marm940",    &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm940")},
23307   {"m940",       &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm940")},
23308   {"mstrongarm", &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=strongarm")},
23309   {"mstrongarm110", &legacy_cpu, ARM_ARCH_V4,
23310    N_("use -mcpu=strongarm110")},
23311   {"mstrongarm1100", &legacy_cpu, ARM_ARCH_V4,
23312    N_("use -mcpu=strongarm1100")},
23313   {"mstrongarm1110", &legacy_cpu, ARM_ARCH_V4,
23314    N_("use -mcpu=strongarm1110")},
23315   {"mxscale",    &legacy_cpu, ARM_ARCH_XSCALE, N_("use -mcpu=xscale")},
23316   {"miwmmxt",    &legacy_cpu, ARM_ARCH_IWMMXT, N_("use -mcpu=iwmmxt")},
23317   {"mall",       &legacy_cpu, ARM_ANY,         N_("use -mcpu=all")},
23318
23319   /* Architecture variants -- don't add any more to this list either.  */
23320   {"mv2",        &legacy_cpu, ARM_ARCH_V2,  N_("use -march=armv2")},
23321   {"marmv2",     &legacy_cpu, ARM_ARCH_V2,  N_("use -march=armv2")},
23322   {"mv2a",       &legacy_cpu, ARM_ARCH_V2S, N_("use -march=armv2a")},
23323   {"marmv2a",    &legacy_cpu, ARM_ARCH_V2S, N_("use -march=armv2a")},
23324   {"mv3",        &legacy_cpu, ARM_ARCH_V3,  N_("use -march=armv3")},
23325   {"marmv3",     &legacy_cpu, ARM_ARCH_V3,  N_("use -march=armv3")},
23326   {"mv3m",       &legacy_cpu, ARM_ARCH_V3M, N_("use -march=armv3m")},
23327   {"marmv3m",    &legacy_cpu, ARM_ARCH_V3M, N_("use -march=armv3m")},
23328   {"mv4",        &legacy_cpu, ARM_ARCH_V4,  N_("use -march=armv4")},
23329   {"marmv4",     &legacy_cpu, ARM_ARCH_V4,  N_("use -march=armv4")},
23330   {"mv4t",       &legacy_cpu, ARM_ARCH_V4T, N_("use -march=armv4t")},
23331   {"marmv4t",    &legacy_cpu, ARM_ARCH_V4T, N_("use -march=armv4t")},
23332   {"mv5",        &legacy_cpu, ARM_ARCH_V5,  N_("use -march=armv5")},
23333   {"marmv5",     &legacy_cpu, ARM_ARCH_V5,  N_("use -march=armv5")},
23334   {"mv5t",       &legacy_cpu, ARM_ARCH_V5T, N_("use -march=armv5t")},
23335   {"marmv5t",    &legacy_cpu, ARM_ARCH_V5T, N_("use -march=armv5t")},
23336   {"mv5e",       &legacy_cpu, ARM_ARCH_V5TE, N_("use -march=armv5te")},
23337   {"marmv5e",    &legacy_cpu, ARM_ARCH_V5TE, N_("use -march=armv5te")},
23338
23339   /* Floating point variants -- don't add any more to this list either.  */
23340   {"mfpe-old", &legacy_fpu, FPU_ARCH_FPE, N_("use -mfpu=fpe")},
23341   {"mfpa10",   &legacy_fpu, FPU_ARCH_FPA, N_("use -mfpu=fpa10")},
23342   {"mfpa11",   &legacy_fpu, FPU_ARCH_FPA, N_("use -mfpu=fpa11")},
23343   {"mno-fpu",  &legacy_fpu, ARM_ARCH_NONE,
23344    N_("use either -mfpu=softfpa or -mfpu=softvfp")},
23345
23346   {NULL, NULL, ARM_ARCH_NONE, NULL}
23347 };
23348
23349 struct arm_cpu_option_table
23350 {
23351   char *name;
23352   size_t name_len;
23353   const arm_feature_set value;
23354   /* For some CPUs we assume an FPU unless the user explicitly sets
23355      -mfpu=...  */
23356   const arm_feature_set default_fpu;
23357   /* The canonical name of the CPU, or NULL to use NAME converted to upper
23358      case.  */
23359   const char *canonical_name;
23360 };
23361
23362 /* This list should, at a minimum, contain all the cpu names
23363    recognized by GCC.  */
23364 #define ARM_CPU_OPT(N, V, DF, CN) { N, sizeof (N) - 1, V, DF, CN }
23365 static const struct arm_cpu_option_table arm_cpus[] =
23366 {
23367   ARM_CPU_OPT ("all",           ARM_ANY,         FPU_ARCH_FPA,    NULL),
23368   ARM_CPU_OPT ("arm1",          ARM_ARCH_V1,     FPU_ARCH_FPA,    NULL),
23369   ARM_CPU_OPT ("arm2",          ARM_ARCH_V2,     FPU_ARCH_FPA,    NULL),
23370   ARM_CPU_OPT ("arm250",        ARM_ARCH_V2S,    FPU_ARCH_FPA,    NULL),
23371   ARM_CPU_OPT ("arm3",          ARM_ARCH_V2S,    FPU_ARCH_FPA,    NULL),
23372   ARM_CPU_OPT ("arm6",          ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23373   ARM_CPU_OPT ("arm60",         ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23374   ARM_CPU_OPT ("arm600",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23375   ARM_CPU_OPT ("arm610",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23376   ARM_CPU_OPT ("arm620",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23377   ARM_CPU_OPT ("arm7",          ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23378   ARM_CPU_OPT ("arm7m",         ARM_ARCH_V3M,    FPU_ARCH_FPA,    NULL),
23379   ARM_CPU_OPT ("arm7d",         ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23380   ARM_CPU_OPT ("arm7dm",        ARM_ARCH_V3M,    FPU_ARCH_FPA,    NULL),
23381   ARM_CPU_OPT ("arm7di",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23382   ARM_CPU_OPT ("arm7dmi",       ARM_ARCH_V3M,    FPU_ARCH_FPA,    NULL),
23383   ARM_CPU_OPT ("arm70",         ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23384   ARM_CPU_OPT ("arm700",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23385   ARM_CPU_OPT ("arm700i",       ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23386   ARM_CPU_OPT ("arm710",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23387   ARM_CPU_OPT ("arm710t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23388   ARM_CPU_OPT ("arm720",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23389   ARM_CPU_OPT ("arm720t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23390   ARM_CPU_OPT ("arm740t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23391   ARM_CPU_OPT ("arm710c",       ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23392   ARM_CPU_OPT ("arm7100",       ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23393   ARM_CPU_OPT ("arm7500",       ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23394   ARM_CPU_OPT ("arm7500fe",     ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23395   ARM_CPU_OPT ("arm7t",         ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23396   ARM_CPU_OPT ("arm7tdmi",      ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23397   ARM_CPU_OPT ("arm7tdmi-s",    ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23398   ARM_CPU_OPT ("arm8",          ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23399   ARM_CPU_OPT ("arm810",        ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23400   ARM_CPU_OPT ("strongarm",     ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23401   ARM_CPU_OPT ("strongarm1",    ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23402   ARM_CPU_OPT ("strongarm110",  ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23403   ARM_CPU_OPT ("strongarm1100", ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23404   ARM_CPU_OPT ("strongarm1110", ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23405   ARM_CPU_OPT ("arm9",          ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23406   ARM_CPU_OPT ("arm920",        ARM_ARCH_V4T,    FPU_ARCH_FPA,    "ARM920T"),
23407   ARM_CPU_OPT ("arm920t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23408   ARM_CPU_OPT ("arm922t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23409   ARM_CPU_OPT ("arm940t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23410   ARM_CPU_OPT ("arm9tdmi",      ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23411   ARM_CPU_OPT ("fa526",         ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23412   ARM_CPU_OPT ("fa626",         ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23413   /* For V5 or later processors we default to using VFP; but the user
23414      should really set the FPU type explicitly.  */
23415   ARM_CPU_OPT ("arm9e-r0",      ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2, NULL),
23416   ARM_CPU_OPT ("arm9e",         ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23417   ARM_CPU_OPT ("arm926ej",      ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2, "ARM926EJ-S"),
23418   ARM_CPU_OPT ("arm926ejs",     ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2, "ARM926EJ-S"),
23419   ARM_CPU_OPT ("arm926ej-s",    ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2, NULL),
23420   ARM_CPU_OPT ("arm946e-r0",    ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2, NULL),
23421   ARM_CPU_OPT ("arm946e",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, "ARM946E-S"),
23422   ARM_CPU_OPT ("arm946e-s",     ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23423   ARM_CPU_OPT ("arm966e-r0",    ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2, NULL),
23424   ARM_CPU_OPT ("arm966e",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, "ARM966E-S"),
23425   ARM_CPU_OPT ("arm966e-s",     ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23426   ARM_CPU_OPT ("arm968e-s",     ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23427   ARM_CPU_OPT ("arm10t",        ARM_ARCH_V5T,    FPU_ARCH_VFP_V1, NULL),
23428   ARM_CPU_OPT ("arm10tdmi",     ARM_ARCH_V5T,    FPU_ARCH_VFP_V1, NULL),
23429   ARM_CPU_OPT ("arm10e",        ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23430   ARM_CPU_OPT ("arm1020",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, "ARM1020E"),
23431   ARM_CPU_OPT ("arm1020t",      ARM_ARCH_V5T,    FPU_ARCH_VFP_V1, NULL),
23432   ARM_CPU_OPT ("arm1020e",      ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23433   ARM_CPU_OPT ("arm1022e",      ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23434   ARM_CPU_OPT ("arm1026ejs",    ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2,
23435                                                                  "ARM1026EJ-S"),
23436   ARM_CPU_OPT ("arm1026ej-s",   ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2, NULL),
23437   ARM_CPU_OPT ("fa606te",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23438   ARM_CPU_OPT ("fa616te",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23439   ARM_CPU_OPT ("fa626te",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23440   ARM_CPU_OPT ("fmp626",        ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23441   ARM_CPU_OPT ("fa726te",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23442   ARM_CPU_OPT ("arm1136js",     ARM_ARCH_V6,     FPU_NONE,        "ARM1136J-S"),
23443   ARM_CPU_OPT ("arm1136j-s",    ARM_ARCH_V6,     FPU_NONE,        NULL),
23444   ARM_CPU_OPT ("arm1136jfs",    ARM_ARCH_V6,     FPU_ARCH_VFP_V2,
23445                                                                  "ARM1136JF-S"),
23446   ARM_CPU_OPT ("arm1136jf-s",   ARM_ARCH_V6,     FPU_ARCH_VFP_V2, NULL),
23447   ARM_CPU_OPT ("mpcore",        ARM_ARCH_V6K,    FPU_ARCH_VFP_V2, "MPCore"),
23448   ARM_CPU_OPT ("mpcorenovfp",   ARM_ARCH_V6K,    FPU_NONE,        "MPCore"),
23449   ARM_CPU_OPT ("arm1156t2-s",   ARM_ARCH_V6T2,   FPU_NONE,        NULL),
23450   ARM_CPU_OPT ("arm1156t2f-s",  ARM_ARCH_V6T2,   FPU_ARCH_VFP_V2, NULL),
23451   ARM_CPU_OPT ("arm1176jz-s",   ARM_ARCH_V6ZK,   FPU_NONE,        NULL),
23452   ARM_CPU_OPT ("arm1176jzf-s",  ARM_ARCH_V6ZK,   FPU_ARCH_VFP_V2, NULL),
23453   ARM_CPU_OPT ("cortex-a5",     ARM_ARCH_V7A_MP_SEC,
23454                                                  FPU_NONE,        "Cortex-A5"),
23455   ARM_CPU_OPT ("cortex-a7",     ARM_ARCH_V7A_IDIV_MP_SEC_VIRT,
23456                                                  FPU_ARCH_NEON_VFP_V4,
23457                                                                   "Cortex-A7"),
23458   ARM_CPU_OPT ("cortex-a8",     ARM_ARCH_V7A_SEC,
23459                                                  ARM_FEATURE (0, FPU_VFP_V3
23460                                                         | FPU_NEON_EXT_V1),
23461                                                                   "Cortex-A8"),
23462   ARM_CPU_OPT ("cortex-a9",     ARM_ARCH_V7A_MP_SEC,
23463                                                  ARM_FEATURE (0, FPU_VFP_V3
23464                                                         | FPU_NEON_EXT_V1),
23465                                                                   "Cortex-A9"),
23466   ARM_CPU_OPT ("cortex-a15",    ARM_ARCH_V7A_IDIV_MP_SEC_VIRT,
23467                                                  FPU_ARCH_NEON_VFP_V4,
23468                                                                   "Cortex-A15"),
23469   ARM_CPU_OPT ("cortex-r4",     ARM_ARCH_V7R,    FPU_NONE,        "Cortex-R4"),
23470   ARM_CPU_OPT ("cortex-r4f",    ARM_ARCH_V7R,    FPU_ARCH_VFP_V3D16,
23471                                                                   "Cortex-R4F"),
23472   ARM_CPU_OPT ("cortex-r5",     ARM_ARCH_V7R_IDIV,
23473                                                  FPU_NONE,        "Cortex-R5"),
23474   ARM_CPU_OPT ("cortex-m4",     ARM_ARCH_V7EM,   FPU_NONE,        "Cortex-M4"),
23475   ARM_CPU_OPT ("cortex-m3",     ARM_ARCH_V7M,    FPU_NONE,        "Cortex-M3"),
23476   ARM_CPU_OPT ("cortex-m1",     ARM_ARCH_V6SM,   FPU_NONE,        "Cortex-M1"),
23477   ARM_CPU_OPT ("cortex-m0",     ARM_ARCH_V6SM,   FPU_NONE,        "Cortex-M0"),
23478   ARM_CPU_OPT ("cortex-m0plus", ARM_ARCH_V6SM,   FPU_NONE,        "Cortex-M0+"),
23479   /* ??? XSCALE is really an architecture.  */
23480   ARM_CPU_OPT ("xscale",        ARM_ARCH_XSCALE, FPU_ARCH_VFP_V2, NULL),
23481   /* ??? iwmmxt is not a processor.  */
23482   ARM_CPU_OPT ("iwmmxt",        ARM_ARCH_IWMMXT, FPU_ARCH_VFP_V2, NULL),
23483   ARM_CPU_OPT ("iwmmxt2",       ARM_ARCH_IWMMXT2,FPU_ARCH_VFP_V2, NULL),
23484   ARM_CPU_OPT ("i80200",        ARM_ARCH_XSCALE, FPU_ARCH_VFP_V2, NULL),
23485   /* Maverick */
23486   ARM_CPU_OPT ("ep9312",        ARM_FEATURE (ARM_AEXT_V4T, ARM_CEXT_MAVERICK),
23487                                                  FPU_ARCH_MAVERICK,
23488                                                                   "ARM920T"),
23489   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE, NULL }
23490 };
23491 #undef ARM_CPU_OPT
23492
23493 struct arm_arch_option_table
23494 {
23495   char *name;
23496   size_t name_len;
23497   const arm_feature_set value;
23498   const arm_feature_set default_fpu;
23499 };
23500
23501 /* This list should, at a minimum, contain all the architecture names
23502    recognized by GCC.  */
23503 #define ARM_ARCH_OPT(N, V, DF) { N, sizeof (N) - 1, V, DF }
23504 static const struct arm_arch_option_table arm_archs[] =
23505 {
23506   ARM_ARCH_OPT ("all",          ARM_ANY,         FPU_ARCH_FPA),
23507   ARM_ARCH_OPT ("armv1",        ARM_ARCH_V1,     FPU_ARCH_FPA),
23508   ARM_ARCH_OPT ("armv2",        ARM_ARCH_V2,     FPU_ARCH_FPA),
23509   ARM_ARCH_OPT ("armv2a",       ARM_ARCH_V2S,    FPU_ARCH_FPA),
23510   ARM_ARCH_OPT ("armv2s",       ARM_ARCH_V2S,    FPU_ARCH_FPA),
23511   ARM_ARCH_OPT ("armv3",        ARM_ARCH_V3,     FPU_ARCH_FPA),
23512   ARM_ARCH_OPT ("armv3m",       ARM_ARCH_V3M,    FPU_ARCH_FPA),
23513   ARM_ARCH_OPT ("armv4",        ARM_ARCH_V4,     FPU_ARCH_FPA),
23514   ARM_ARCH_OPT ("armv4xm",      ARM_ARCH_V4xM,   FPU_ARCH_FPA),
23515   ARM_ARCH_OPT ("armv4t",       ARM_ARCH_V4T,    FPU_ARCH_FPA),
23516   ARM_ARCH_OPT ("armv4txm",     ARM_ARCH_V4TxM,  FPU_ARCH_FPA),
23517   ARM_ARCH_OPT ("armv5",        ARM_ARCH_V5,     FPU_ARCH_VFP),
23518   ARM_ARCH_OPT ("armv5t",       ARM_ARCH_V5T,    FPU_ARCH_VFP),
23519   ARM_ARCH_OPT ("armv5txm",     ARM_ARCH_V5TxM,  FPU_ARCH_VFP),
23520   ARM_ARCH_OPT ("armv5te",      ARM_ARCH_V5TE,   FPU_ARCH_VFP),
23521   ARM_ARCH_OPT ("armv5texp",    ARM_ARCH_V5TExP, FPU_ARCH_VFP),
23522   ARM_ARCH_OPT ("armv5tej",     ARM_ARCH_V5TEJ,  FPU_ARCH_VFP),
23523   ARM_ARCH_OPT ("armv6",        ARM_ARCH_V6,     FPU_ARCH_VFP),
23524   ARM_ARCH_OPT ("armv6j",       ARM_ARCH_V6,     FPU_ARCH_VFP),
23525   ARM_ARCH_OPT ("armv6k",       ARM_ARCH_V6K,    FPU_ARCH_VFP),
23526   ARM_ARCH_OPT ("armv6z",       ARM_ARCH_V6Z,    FPU_ARCH_VFP),
23527   ARM_ARCH_OPT ("armv6zk",      ARM_ARCH_V6ZK,   FPU_ARCH_VFP),
23528   ARM_ARCH_OPT ("armv6t2",      ARM_ARCH_V6T2,   FPU_ARCH_VFP),
23529   ARM_ARCH_OPT ("armv6kt2",     ARM_ARCH_V6KT2,  FPU_ARCH_VFP),
23530   ARM_ARCH_OPT ("armv6zt2",     ARM_ARCH_V6ZT2,  FPU_ARCH_VFP),
23531   ARM_ARCH_OPT ("armv6zkt2",    ARM_ARCH_V6ZKT2, FPU_ARCH_VFP),
23532   ARM_ARCH_OPT ("armv6-m",      ARM_ARCH_V6M,    FPU_ARCH_VFP),
23533   ARM_ARCH_OPT ("armv6s-m",     ARM_ARCH_V6SM,   FPU_ARCH_VFP),
23534   ARM_ARCH_OPT ("armv7",        ARM_ARCH_V7,     FPU_ARCH_VFP),
23535   /* The official spelling of the ARMv7 profile variants is the dashed form.
23536      Accept the non-dashed form for compatibility with old toolchains.  */
23537   ARM_ARCH_OPT ("armv7a",       ARM_ARCH_V7A,    FPU_ARCH_VFP),
23538   ARM_ARCH_OPT ("armv7r",       ARM_ARCH_V7R,    FPU_ARCH_VFP),
23539   ARM_ARCH_OPT ("armv7m",       ARM_ARCH_V7M,    FPU_ARCH_VFP),
23540   ARM_ARCH_OPT ("armv7-a",      ARM_ARCH_V7A,    FPU_ARCH_VFP),
23541   ARM_ARCH_OPT ("armv7-r",      ARM_ARCH_V7R,    FPU_ARCH_VFP),
23542   ARM_ARCH_OPT ("armv7-m",      ARM_ARCH_V7M,    FPU_ARCH_VFP),
23543   ARM_ARCH_OPT ("armv7e-m",     ARM_ARCH_V7EM,   FPU_ARCH_VFP),
23544   ARM_ARCH_OPT ("armv8-a",      ARM_ARCH_V8A,    FPU_ARCH_VFP),
23545   ARM_ARCH_OPT ("xscale",       ARM_ARCH_XSCALE, FPU_ARCH_VFP),
23546   ARM_ARCH_OPT ("iwmmxt",       ARM_ARCH_IWMMXT, FPU_ARCH_VFP),
23547   ARM_ARCH_OPT ("iwmmxt2",      ARM_ARCH_IWMMXT2,FPU_ARCH_VFP),
23548   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
23549 };
23550 #undef ARM_ARCH_OPT
23551
23552 /* ISA extensions in the co-processor and main instruction set space.  */
23553 struct arm_option_extension_value_table
23554 {
23555   char *name;
23556   size_t name_len;
23557   const arm_feature_set value;
23558   const arm_feature_set allowed_archs;
23559 };
23560
23561 /* The following table must be in alphabetical order with a NULL last entry.
23562    */
23563 #define ARM_EXT_OPT(N, V, AA) { N, sizeof (N) - 1, V, AA }
23564 static const struct arm_option_extension_value_table arm_extensions[] =
23565 {
23566   ARM_EXT_OPT ("crypto", FPU_ARCH_CRYPTO_NEON_VFP_ARMV8,
23567                                    ARM_FEATURE (ARM_EXT_V8, 0)),
23568   ARM_EXT_OPT ("fp",     FPU_ARCH_VFP_ARMV8,
23569                                    ARM_FEATURE (ARM_EXT_V8, 0)),
23570   ARM_EXT_OPT ("idiv",  ARM_FEATURE (ARM_EXT_ADIV | ARM_EXT_DIV, 0),
23571                                    ARM_FEATURE (ARM_EXT_V7A | ARM_EXT_V7R, 0)),
23572   ARM_EXT_OPT ("iwmmxt",ARM_FEATURE (0, ARM_CEXT_IWMMXT),       ARM_ANY),
23573   ARM_EXT_OPT ("iwmmxt2",
23574                         ARM_FEATURE (0, ARM_CEXT_IWMMXT2),      ARM_ANY),
23575   ARM_EXT_OPT ("maverick",
23576                         ARM_FEATURE (0, ARM_CEXT_MAVERICK),     ARM_ANY),
23577   ARM_EXT_OPT ("mp",    ARM_FEATURE (ARM_EXT_MP, 0),
23578                                    ARM_FEATURE (ARM_EXT_V7A | ARM_EXT_V7R, 0)),
23579   ARM_EXT_OPT ("simd",   FPU_ARCH_NEON_VFP_ARMV8,
23580                                    ARM_FEATURE (ARM_EXT_V8, 0)),
23581   ARM_EXT_OPT ("os",    ARM_FEATURE (ARM_EXT_OS, 0),
23582                                    ARM_FEATURE (ARM_EXT_V6M, 0)),
23583   ARM_EXT_OPT ("sec",   ARM_FEATURE (ARM_EXT_SEC, 0),
23584                                    ARM_FEATURE (ARM_EXT_V6K | ARM_EXT_V7A, 0)),
23585   ARM_EXT_OPT ("virt",  ARM_FEATURE (ARM_EXT_VIRT | ARM_EXT_ADIV
23586                                      | ARM_EXT_DIV, 0),
23587                                    ARM_FEATURE (ARM_EXT_V7A, 0)),
23588   ARM_EXT_OPT ("xscale",ARM_FEATURE (0, ARM_CEXT_XSCALE),       ARM_ANY),
23589   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
23590 };
23591 #undef ARM_EXT_OPT
23592
23593 /* ISA floating-point and Advanced SIMD extensions.  */
23594 struct arm_option_fpu_value_table
23595 {
23596   char *name;
23597   const arm_feature_set value;
23598 };
23599
23600 /* This list should, at a minimum, contain all the fpu names
23601    recognized by GCC.  */
23602 static const struct arm_option_fpu_value_table arm_fpus[] =
23603 {
23604   {"softfpa",           FPU_NONE},
23605   {"fpe",               FPU_ARCH_FPE},
23606   {"fpe2",              FPU_ARCH_FPE},
23607   {"fpe3",              FPU_ARCH_FPA},  /* Third release supports LFM/SFM.  */
23608   {"fpa",               FPU_ARCH_FPA},
23609   {"fpa10",             FPU_ARCH_FPA},
23610   {"fpa11",             FPU_ARCH_FPA},
23611   {"arm7500fe",         FPU_ARCH_FPA},
23612   {"softvfp",           FPU_ARCH_VFP},
23613   {"softvfp+vfp",       FPU_ARCH_VFP_V2},
23614   {"vfp",               FPU_ARCH_VFP_V2},
23615   {"vfp9",              FPU_ARCH_VFP_V2},
23616   {"vfp3",              FPU_ARCH_VFP_V3}, /* For backwards compatbility.  */
23617   {"vfp10",             FPU_ARCH_VFP_V2},
23618   {"vfp10-r0",          FPU_ARCH_VFP_V1},
23619   {"vfpxd",             FPU_ARCH_VFP_V1xD},
23620   {"vfpv2",             FPU_ARCH_VFP_V2},
23621   {"vfpv3",             FPU_ARCH_VFP_V3},
23622   {"vfpv3-fp16",        FPU_ARCH_VFP_V3_FP16},
23623   {"vfpv3-d16",         FPU_ARCH_VFP_V3D16},
23624   {"vfpv3-d16-fp16",    FPU_ARCH_VFP_V3D16_FP16},
23625   {"vfpv3xd",           FPU_ARCH_VFP_V3xD},
23626   {"vfpv3xd-fp16",      FPU_ARCH_VFP_V3xD_FP16},
23627   {"arm1020t",          FPU_ARCH_VFP_V1},
23628   {"arm1020e",          FPU_ARCH_VFP_V2},
23629   {"arm1136jfs",        FPU_ARCH_VFP_V2},
23630   {"arm1136jf-s",       FPU_ARCH_VFP_V2},
23631   {"maverick",          FPU_ARCH_MAVERICK},
23632   {"neon",              FPU_ARCH_VFP_V3_PLUS_NEON_V1},
23633   {"neon-fp16",         FPU_ARCH_NEON_FP16},
23634   {"vfpv4",             FPU_ARCH_VFP_V4},
23635   {"vfpv4-d16",         FPU_ARCH_VFP_V4D16},
23636   {"fpv4-sp-d16",       FPU_ARCH_VFP_V4_SP_D16},
23637   {"neon-vfpv4",        FPU_ARCH_NEON_VFP_V4},
23638   {"fp-armv8",          FPU_ARCH_VFP_ARMV8},
23639   {"neon-fp-armv8",     FPU_ARCH_NEON_VFP_ARMV8},
23640   {"crypto-neon-fp-armv8",
23641                         FPU_ARCH_CRYPTO_NEON_VFP_ARMV8},
23642   {NULL,                ARM_ARCH_NONE}
23643 };
23644
23645 struct arm_option_value_table
23646 {
23647   char *name;
23648   long value;
23649 };
23650
23651 static const struct arm_option_value_table arm_float_abis[] =
23652 {
23653   {"hard",      ARM_FLOAT_ABI_HARD},
23654   {"softfp",    ARM_FLOAT_ABI_SOFTFP},
23655   {"soft",      ARM_FLOAT_ABI_SOFT},
23656   {NULL,        0}
23657 };
23658
23659 #ifdef OBJ_ELF
23660 /* We only know how to output GNU and ver 4/5 (AAELF) formats.  */
23661 static const struct arm_option_value_table arm_eabis[] =
23662 {
23663   {"gnu",       EF_ARM_EABI_UNKNOWN},
23664   {"4",         EF_ARM_EABI_VER4},
23665   {"5",         EF_ARM_EABI_VER5},
23666   {NULL,        0}
23667 };
23668 #endif
23669
23670 struct arm_long_option_table
23671 {
23672   char * option;                /* Substring to match.  */
23673   char * help;                  /* Help information.  */
23674   int (* func) (char * subopt); /* Function to decode sub-option.  */
23675   char * deprecated;            /* If non-null, print this message.  */
23676 };
23677
23678 static bfd_boolean
23679 arm_parse_extension (char *str, const arm_feature_set **opt_p)
23680 {
23681   arm_feature_set *ext_set = (arm_feature_set *)
23682       xmalloc (sizeof (arm_feature_set));
23683
23684   /* We insist on extensions being specified in alphabetical order, and with
23685      extensions being added before being removed.  We achieve this by having
23686      the global ARM_EXTENSIONS table in alphabetical order, and using the
23687      ADDING_VALUE variable to indicate whether we are adding an extension (1)
23688      or removing it (0) and only allowing it to change in the order
23689      -1 -> 1 -> 0.  */
23690   const struct arm_option_extension_value_table * opt = NULL;
23691   int adding_value = -1;
23692
23693   /* Copy the feature set, so that we can modify it.  */
23694   *ext_set = **opt_p;
23695   *opt_p = ext_set;
23696
23697   while (str != NULL && *str != 0)
23698     {
23699       char *ext;
23700       size_t len;
23701
23702       if (*str != '+')
23703         {
23704           as_bad (_("invalid architectural extension"));
23705           return FALSE;
23706         }
23707
23708       str++;
23709       ext = strchr (str, '+');
23710
23711       if (ext != NULL)
23712         len = ext - str;
23713       else
23714         len = strlen (str);
23715
23716       if (len >= 2 && strncmp (str, "no", 2) == 0)
23717         {
23718           if (adding_value != 0)
23719             {
23720               adding_value = 0;
23721               opt = arm_extensions;
23722             }
23723
23724           len -= 2;
23725           str += 2;
23726         }
23727       else if (len > 0)
23728         {
23729           if (adding_value == -1)
23730             {
23731               adding_value = 1;
23732               opt = arm_extensions;
23733             }
23734           else if (adding_value != 1)
23735             {
23736               as_bad (_("must specify extensions to add before specifying "
23737                         "those to remove"));
23738               return FALSE;
23739             }
23740         }
23741
23742       if (len == 0)
23743         {
23744           as_bad (_("missing architectural extension"));
23745           return FALSE;
23746         }
23747
23748       gas_assert (adding_value != -1);
23749       gas_assert (opt != NULL);
23750
23751       /* Scan over the options table trying to find an exact match. */
23752       for (; opt->name != NULL; opt++)
23753         if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
23754           {
23755             /* Check we can apply the extension to this architecture.  */
23756             if (!ARM_CPU_HAS_FEATURE (*ext_set, opt->allowed_archs))
23757               {
23758                 as_bad (_("extension does not apply to the base architecture"));
23759                 return FALSE;
23760               }
23761
23762             /* Add or remove the extension.  */
23763             if (adding_value)
23764               ARM_MERGE_FEATURE_SETS (*ext_set, *ext_set, opt->value);
23765             else
23766               ARM_CLEAR_FEATURE (*ext_set, *ext_set, opt->value);
23767
23768             break;
23769           }
23770
23771       if (opt->name == NULL)
23772         {
23773           /* Did we fail to find an extension because it wasn't specified in
23774              alphabetical order, or because it does not exist?  */
23775
23776           for (opt = arm_extensions; opt->name != NULL; opt++)
23777             if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
23778               break;
23779
23780           if (opt->name == NULL)
23781             as_bad (_("unknown architectural extension `%s'"), str);
23782           else
23783             as_bad (_("architectural extensions must be specified in "
23784                       "alphabetical order"));
23785
23786           return FALSE;
23787         }
23788       else
23789         {
23790           /* We should skip the extension we've just matched the next time
23791              round.  */
23792           opt++;
23793         }
23794
23795       str = ext;
23796     };
23797
23798   return TRUE;
23799 }
23800
23801 static bfd_boolean
23802 arm_parse_cpu (char *str)
23803 {
23804   const struct arm_cpu_option_table *opt;
23805   char *ext = strchr (str, '+');
23806   size_t len;
23807
23808   if (ext != NULL)
23809     len = ext - str;
23810   else
23811     len = strlen (str);
23812
23813   if (len == 0)
23814     {
23815       as_bad (_("missing cpu name `%s'"), str);
23816       return FALSE;
23817     }
23818
23819   for (opt = arm_cpus; opt->name != NULL; opt++)
23820     if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
23821       {
23822         mcpu_cpu_opt = &opt->value;
23823         mcpu_fpu_opt = &opt->default_fpu;
23824         if (opt->canonical_name)
23825           strcpy (selected_cpu_name, opt->canonical_name);
23826         else
23827           {
23828             size_t i;
23829
23830             for (i = 0; i < len; i++)
23831               selected_cpu_name[i] = TOUPPER (opt->name[i]);
23832             selected_cpu_name[i] = 0;
23833           }
23834
23835         if (ext != NULL)
23836           return arm_parse_extension (ext, &mcpu_cpu_opt);
23837
23838         return TRUE;
23839       }
23840
23841   as_bad (_("unknown cpu `%s'"), str);
23842   return FALSE;
23843 }
23844
23845 static bfd_boolean
23846 arm_parse_arch (char *str)
23847 {
23848   const struct arm_arch_option_table *opt;
23849   char *ext = strchr (str, '+');
23850   size_t len;
23851
23852   if (ext != NULL)
23853     len = ext - str;
23854   else
23855     len = strlen (str);
23856
23857   if (len == 0)
23858     {
23859       as_bad (_("missing architecture name `%s'"), str);
23860       return FALSE;
23861     }
23862
23863   for (opt = arm_archs; opt->name != NULL; opt++)
23864     if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
23865       {
23866         march_cpu_opt = &opt->value;
23867         march_fpu_opt = &opt->default_fpu;
23868         strcpy (selected_cpu_name, opt->name);
23869
23870         if (ext != NULL)
23871           return arm_parse_extension (ext, &march_cpu_opt);
23872
23873         return TRUE;
23874       }
23875
23876   as_bad (_("unknown architecture `%s'\n"), str);
23877   return FALSE;
23878 }
23879
23880 static bfd_boolean
23881 arm_parse_fpu (char * str)
23882 {
23883   const struct arm_option_fpu_value_table * opt;
23884
23885   for (opt = arm_fpus; opt->name != NULL; opt++)
23886     if (streq (opt->name, str))
23887       {
23888         mfpu_opt = &opt->value;
23889         return TRUE;
23890       }
23891
23892   as_bad (_("unknown floating point format `%s'\n"), str);
23893   return FALSE;
23894 }
23895
23896 static bfd_boolean
23897 arm_parse_float_abi (char * str)
23898 {
23899   const struct arm_option_value_table * opt;
23900
23901   for (opt = arm_float_abis; opt->name != NULL; opt++)
23902     if (streq (opt->name, str))
23903       {
23904         mfloat_abi_opt = opt->value;
23905         return TRUE;
23906       }
23907
23908   as_bad (_("unknown floating point abi `%s'\n"), str);
23909   return FALSE;
23910 }
23911
23912 #ifdef OBJ_ELF
23913 static bfd_boolean
23914 arm_parse_eabi (char * str)
23915 {
23916   const struct arm_option_value_table *opt;
23917
23918   for (opt = arm_eabis; opt->name != NULL; opt++)
23919     if (streq (opt->name, str))
23920       {
23921         meabi_flags = opt->value;
23922         return TRUE;
23923       }
23924   as_bad (_("unknown EABI `%s'\n"), str);
23925   return FALSE;
23926 }
23927 #endif
23928
23929 static bfd_boolean
23930 arm_parse_it_mode (char * str)
23931 {
23932   bfd_boolean ret = TRUE;
23933
23934   if (streq ("arm", str))
23935     implicit_it_mode = IMPLICIT_IT_MODE_ARM;
23936   else if (streq ("thumb", str))
23937     implicit_it_mode = IMPLICIT_IT_MODE_THUMB;
23938   else if (streq ("always", str))
23939     implicit_it_mode = IMPLICIT_IT_MODE_ALWAYS;
23940   else if (streq ("never", str))
23941     implicit_it_mode = IMPLICIT_IT_MODE_NEVER;
23942   else
23943     {
23944       as_bad (_("unknown implicit IT mode `%s', should be "\
23945                 "arm, thumb, always, or never."), str);
23946       ret = FALSE;
23947     }
23948
23949   return ret;
23950 }
23951
23952 struct arm_long_option_table arm_long_opts[] =
23953 {
23954   {"mcpu=", N_("<cpu name>\t  assemble for CPU <cpu name>"),
23955    arm_parse_cpu, NULL},
23956   {"march=", N_("<arch name>\t  assemble for architecture <arch name>"),
23957    arm_parse_arch, NULL},
23958   {"mfpu=", N_("<fpu name>\t  assemble for FPU architecture <fpu name>"),
23959    arm_parse_fpu, NULL},
23960   {"mfloat-abi=", N_("<abi>\t  assemble for floating point ABI <abi>"),
23961    arm_parse_float_abi, NULL},
23962 #ifdef OBJ_ELF
23963   {"meabi=", N_("<ver>\t\t  assemble for eabi version <ver>"),
23964    arm_parse_eabi, NULL},
23965 #endif
23966   {"mimplicit-it=", N_("<mode>\t  controls implicit insertion of IT instructions"),
23967    arm_parse_it_mode, NULL},
23968   {NULL, NULL, 0, NULL}
23969 };
23970
23971 int
23972 md_parse_option (int c, char * arg)
23973 {
23974   struct arm_option_table *opt;
23975   const struct arm_legacy_option_table *fopt;
23976   struct arm_long_option_table *lopt;
23977
23978   switch (c)
23979     {
23980 #ifdef OPTION_EB
23981     case OPTION_EB:
23982       target_big_endian = 1;
23983       break;
23984 #endif
23985
23986 #ifdef OPTION_EL
23987     case OPTION_EL:
23988       target_big_endian = 0;
23989       break;
23990 #endif
23991
23992     case OPTION_FIX_V4BX:
23993       fix_v4bx = TRUE;
23994       break;
23995
23996     case 'a':
23997       /* Listing option.  Just ignore these, we don't support additional
23998          ones.  */
23999       return 0;
24000
24001     default:
24002       for (opt = arm_opts; opt->option != NULL; opt++)
24003         {
24004           if (c == opt->option[0]
24005               && ((arg == NULL && opt->option[1] == 0)
24006                   || streq (arg, opt->option + 1)))
24007             {
24008               /* If the option is deprecated, tell the user.  */
24009               if (warn_on_deprecated && opt->deprecated != NULL)
24010                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c,
24011                            arg ? arg : "", _(opt->deprecated));
24012
24013               if (opt->var != NULL)
24014                 *opt->var = opt->value;
24015
24016               return 1;
24017             }
24018         }
24019
24020       for (fopt = arm_legacy_opts; fopt->option != NULL; fopt++)
24021         {
24022           if (c == fopt->option[0]
24023               && ((arg == NULL && fopt->option[1] == 0)
24024                   || streq (arg, fopt->option + 1)))
24025             {
24026               /* If the option is deprecated, tell the user.  */
24027               if (warn_on_deprecated && fopt->deprecated != NULL)
24028                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c,
24029                            arg ? arg : "", _(fopt->deprecated));
24030
24031               if (fopt->var != NULL)
24032                 *fopt->var = &fopt->value;
24033
24034               return 1;
24035             }
24036         }
24037
24038       for (lopt = arm_long_opts; lopt->option != NULL; lopt++)
24039         {
24040           /* These options are expected to have an argument.  */
24041           if (c == lopt->option[0]
24042               && arg != NULL
24043               && strncmp (arg, lopt->option + 1,
24044                           strlen (lopt->option + 1)) == 0)
24045             {
24046               /* If the option is deprecated, tell the user.  */
24047               if (warn_on_deprecated && lopt->deprecated != NULL)
24048                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c, arg,
24049                            _(lopt->deprecated));
24050
24051               /* Call the sup-option parser.  */
24052               return lopt->func (arg + strlen (lopt->option) - 1);
24053             }
24054         }
24055
24056       return 0;
24057     }
24058
24059   return 1;
24060 }
24061
24062 void
24063 md_show_usage (FILE * fp)
24064 {
24065   struct arm_option_table *opt;
24066   struct arm_long_option_table *lopt;
24067
24068   fprintf (fp, _(" ARM-specific assembler options:\n"));
24069
24070   for (opt = arm_opts; opt->option != NULL; opt++)
24071     if (opt->help != NULL)
24072       fprintf (fp, "  -%-23s%s\n", opt->option, _(opt->help));
24073
24074   for (lopt = arm_long_opts; lopt->option != NULL; lopt++)
24075     if (lopt->help != NULL)
24076       fprintf (fp, "  -%s%s\n", lopt->option, _(lopt->help));
24077
24078 #ifdef OPTION_EB
24079   fprintf (fp, _("\
24080   -EB                     assemble code for a big-endian cpu\n"));
24081 #endif
24082
24083 #ifdef OPTION_EL
24084   fprintf (fp, _("\
24085   -EL                     assemble code for a little-endian cpu\n"));
24086 #endif
24087
24088   fprintf (fp, _("\
24089   --fix-v4bx              Allow BX in ARMv4 code\n"));
24090 }
24091
24092
24093 #ifdef OBJ_ELF
24094 typedef struct
24095 {
24096   int val;
24097   arm_feature_set flags;
24098 } cpu_arch_ver_table;
24099
24100 /* Mapping from CPU features to EABI CPU arch values.  Table must be sorted
24101    least features first.  */
24102 static const cpu_arch_ver_table cpu_arch_ver[] =
24103 {
24104     {1, ARM_ARCH_V4},
24105     {2, ARM_ARCH_V4T},
24106     {3, ARM_ARCH_V5},
24107     {3, ARM_ARCH_V5T},
24108     {4, ARM_ARCH_V5TE},
24109     {5, ARM_ARCH_V5TEJ},
24110     {6, ARM_ARCH_V6},
24111     {9, ARM_ARCH_V6K},
24112     {7, ARM_ARCH_V6Z},
24113     {11, ARM_ARCH_V6M},
24114     {12, ARM_ARCH_V6SM},
24115     {8, ARM_ARCH_V6T2},
24116     {10, ARM_ARCH_V7A_IDIV_MP_SEC_VIRT},
24117     {10, ARM_ARCH_V7R},
24118     {10, ARM_ARCH_V7M},
24119     {14, ARM_ARCH_V8A},
24120     {0, ARM_ARCH_NONE}
24121 };
24122
24123 /* Set an attribute if it has not already been set by the user.  */
24124 static void
24125 aeabi_set_attribute_int (int tag, int value)
24126 {
24127   if (tag < 1
24128       || tag >= NUM_KNOWN_OBJ_ATTRIBUTES
24129       || !attributes_set_explicitly[tag])
24130     bfd_elf_add_proc_attr_int (stdoutput, tag, value);
24131 }
24132
24133 static void
24134 aeabi_set_attribute_string (int tag, const char *value)
24135 {
24136   if (tag < 1
24137       || tag >= NUM_KNOWN_OBJ_ATTRIBUTES
24138       || !attributes_set_explicitly[tag])
24139     bfd_elf_add_proc_attr_string (stdoutput, tag, value);
24140 }
24141
24142 /* Set the public EABI object attributes.  */
24143 static void
24144 aeabi_set_public_attributes (void)
24145 {
24146   int arch;
24147   char profile;
24148   int virt_sec = 0;
24149   int fp16_optional = 0;
24150   arm_feature_set flags;
24151   arm_feature_set tmp;
24152   const cpu_arch_ver_table *p;
24153
24154   /* Choose the architecture based on the capabilities of the requested cpu
24155      (if any) and/or the instructions actually used.  */
24156   ARM_MERGE_FEATURE_SETS (flags, arm_arch_used, thumb_arch_used);
24157   ARM_MERGE_FEATURE_SETS (flags, flags, *mfpu_opt);
24158   ARM_MERGE_FEATURE_SETS (flags, flags, selected_cpu);
24159
24160   if (ARM_CPU_HAS_FEATURE (arm_arch_used, arm_arch_any))
24161     ARM_MERGE_FEATURE_SETS (flags, flags, arm_ext_v1);
24162
24163   if (ARM_CPU_HAS_FEATURE (thumb_arch_used, arm_arch_any))
24164     ARM_MERGE_FEATURE_SETS (flags, flags, arm_ext_v4t);
24165
24166   /* Allow the user to override the reported architecture.  */
24167   if (object_arch)
24168     {
24169       ARM_CLEAR_FEATURE (flags, flags, arm_arch_any);
24170       ARM_MERGE_FEATURE_SETS (flags, flags, *object_arch);
24171     }
24172
24173   /* We need to make sure that the attributes do not identify us as v6S-M
24174      when the only v6S-M feature in use is the Operating System Extensions.  */
24175   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_os))
24176       if (!ARM_CPU_HAS_FEATURE (flags, arm_arch_v6m_only))
24177         ARM_CLEAR_FEATURE (flags, flags, arm_ext_os);
24178
24179   tmp = flags;
24180   arch = 0;
24181   for (p = cpu_arch_ver; p->val; p++)
24182     {
24183       if (ARM_CPU_HAS_FEATURE (tmp, p->flags))
24184         {
24185           arch = p->val;
24186           ARM_CLEAR_FEATURE (tmp, tmp, p->flags);
24187         }
24188     }
24189
24190   /* The table lookup above finds the last architecture to contribute
24191      a new feature.  Unfortunately, Tag13 is a subset of the union of
24192      v6T2 and v7-M, so it is never seen as contributing a new feature.
24193      We can not search for the last entry which is entirely used,
24194      because if no CPU is specified we build up only those flags
24195      actually used.  Perhaps we should separate out the specified
24196      and implicit cases.  Avoid taking this path for -march=all by
24197      checking for contradictory v7-A / v7-M features.  */
24198   if (arch == 10
24199       && !ARM_CPU_HAS_FEATURE (flags, arm_ext_v7a)
24200       && ARM_CPU_HAS_FEATURE (flags, arm_ext_v7m)
24201       && ARM_CPU_HAS_FEATURE (flags, arm_ext_v6_dsp))
24202     arch = 13;
24203
24204   /* Tag_CPU_name.  */
24205   if (selected_cpu_name[0])
24206     {
24207       char *q;
24208
24209       q = selected_cpu_name;
24210       if (strncmp (q, "armv", 4) == 0)
24211         {
24212           int i;
24213
24214           q += 4;
24215           for (i = 0; q[i]; i++)
24216             q[i] = TOUPPER (q[i]);
24217         }
24218       aeabi_set_attribute_string (Tag_CPU_name, q);
24219     }
24220
24221   /* Tag_CPU_arch.  */
24222   aeabi_set_attribute_int (Tag_CPU_arch, arch);
24223
24224   /* Tag_CPU_arch_profile.  */
24225   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v7a))
24226     profile = 'A';
24227   else if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v7r))
24228     profile = 'R';
24229   else if (ARM_CPU_HAS_FEATURE (flags, arm_ext_m))
24230     profile = 'M';
24231   else
24232     profile = '\0';
24233
24234   if (profile != '\0')
24235     aeabi_set_attribute_int (Tag_CPU_arch_profile, profile);
24236
24237   /* Tag_ARM_ISA_use.  */
24238   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v1)
24239       || arch == 0)
24240     aeabi_set_attribute_int (Tag_ARM_ISA_use, 1);
24241
24242   /* Tag_THUMB_ISA_use.  */
24243   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v4t)
24244       || arch == 0)
24245     aeabi_set_attribute_int (Tag_THUMB_ISA_use,
24246         ARM_CPU_HAS_FEATURE (flags, arm_arch_t2) ? 2 : 1);
24247
24248   /* Tag_VFP_arch.  */
24249   if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_armv8))
24250     aeabi_set_attribute_int (Tag_VFP_arch, 7);
24251   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_fma))
24252     aeabi_set_attribute_int (Tag_VFP_arch,
24253                              ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_d32)
24254                              ? 5 : 6);
24255   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_d32))
24256     {
24257       fp16_optional = 1;
24258       aeabi_set_attribute_int (Tag_VFP_arch, 3);
24259     }
24260   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v3xd))
24261     {
24262       aeabi_set_attribute_int (Tag_VFP_arch, 4);
24263       fp16_optional = 1;
24264     }
24265   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v2))
24266     aeabi_set_attribute_int (Tag_VFP_arch, 2);
24267   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1)
24268            || ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1xd))
24269     aeabi_set_attribute_int (Tag_VFP_arch, 1);
24270
24271   /* Tag_ABI_HardFP_use.  */
24272   if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1xd)
24273       && !ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1))
24274     aeabi_set_attribute_int (Tag_ABI_HardFP_use, 1);
24275
24276   /* Tag_WMMX_arch.  */
24277   if (ARM_CPU_HAS_FEATURE (flags, arm_cext_iwmmxt2))
24278     aeabi_set_attribute_int (Tag_WMMX_arch, 2);
24279   else if (ARM_CPU_HAS_FEATURE (flags, arm_cext_iwmmxt))
24280     aeabi_set_attribute_int (Tag_WMMX_arch, 1);
24281
24282   /* Tag_Advanced_SIMD_arch (formerly Tag_NEON_arch).  */
24283   if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_armv8))
24284     aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 3);
24285   else if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_v1))
24286     {
24287       if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_fma))
24288         {
24289           aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 2);
24290         }
24291       else
24292         {
24293           aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 1);
24294           fp16_optional = 1;
24295         }
24296     }
24297
24298   /* Tag_VFP_HP_extension (formerly Tag_NEON_FP16_arch).  */
24299   if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_fp16) && fp16_optional)
24300     aeabi_set_attribute_int (Tag_VFP_HP_extension, 1);
24301
24302   /* Tag_DIV_use.
24303
24304      We set Tag_DIV_use to two when integer divide instructions have been used
24305      in ARM state, or when Thumb integer divide instructions have been used,
24306      but we have no architecture profile set, nor have we any ARM instructions.
24307
24308      For ARMv8 we set the tag to 0 as integer divide is implied by the base
24309      architecture.
24310
24311      For new architectures we will have to check these tests.  */
24312   gas_assert (arch <= TAG_CPU_ARCH_V8);
24313   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v8))
24314     aeabi_set_attribute_int (Tag_DIV_use, 0);
24315   else if (ARM_CPU_HAS_FEATURE (flags, arm_ext_adiv)
24316            || (profile == '\0'
24317                && ARM_CPU_HAS_FEATURE (flags, arm_ext_div)
24318                && !ARM_CPU_HAS_FEATURE (arm_arch_used, arm_arch_any)))
24319     aeabi_set_attribute_int (Tag_DIV_use, 2);
24320
24321   /* Tag_MP_extension_use.  */
24322   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_mp))
24323     aeabi_set_attribute_int (Tag_MPextension_use, 1);
24324
24325   /* Tag Virtualization_use.  */
24326   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_sec))
24327     virt_sec |= 1;
24328   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_virt))
24329     virt_sec |= 2;
24330   if (virt_sec != 0)
24331     aeabi_set_attribute_int (Tag_Virtualization_use, virt_sec);
24332 }
24333
24334 /* Add the default contents for the .ARM.attributes section.  */
24335 void
24336 arm_md_end (void)
24337 {
24338   if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
24339     return;
24340
24341   aeabi_set_public_attributes ();
24342 }
24343 #endif /* OBJ_ELF */
24344
24345
24346 /* Parse a .cpu directive.  */
24347
24348 static void
24349 s_arm_cpu (int ignored ATTRIBUTE_UNUSED)
24350 {
24351   const struct arm_cpu_option_table *opt;
24352   char *name;
24353   char saved_char;
24354
24355   name = input_line_pointer;
24356   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
24357     input_line_pointer++;
24358   saved_char = *input_line_pointer;
24359   *input_line_pointer = 0;
24360
24361   /* Skip the first "all" entry.  */
24362   for (opt = arm_cpus + 1; opt->name != NULL; opt++)
24363     if (streq (opt->name, name))
24364       {
24365         mcpu_cpu_opt = &opt->value;
24366         selected_cpu = opt->value;
24367         if (opt->canonical_name)
24368           strcpy (selected_cpu_name, opt->canonical_name);
24369         else
24370           {
24371             int i;
24372             for (i = 0; opt->name[i]; i++)
24373               selected_cpu_name[i] = TOUPPER (opt->name[i]);
24374
24375             selected_cpu_name[i] = 0;
24376           }
24377         ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
24378         *input_line_pointer = saved_char;
24379         demand_empty_rest_of_line ();
24380         return;
24381       }
24382   as_bad (_("unknown cpu `%s'"), name);
24383   *input_line_pointer = saved_char;
24384   ignore_rest_of_line ();
24385 }
24386
24387
24388 /* Parse a .arch directive.  */
24389
24390 static void
24391 s_arm_arch (int ignored ATTRIBUTE_UNUSED)
24392 {
24393   const struct arm_arch_option_table *opt;
24394   char saved_char;
24395   char *name;
24396
24397   name = input_line_pointer;
24398   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
24399     input_line_pointer++;
24400   saved_char = *input_line_pointer;
24401   *input_line_pointer = 0;
24402
24403   /* Skip the first "all" entry.  */
24404   for (opt = arm_archs + 1; opt->name != NULL; opt++)
24405     if (streq (opt->name, name))
24406       {
24407         mcpu_cpu_opt = &opt->value;
24408         selected_cpu = opt->value;
24409         strcpy (selected_cpu_name, opt->name);
24410         ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
24411         *input_line_pointer = saved_char;
24412         demand_empty_rest_of_line ();
24413         return;
24414       }
24415
24416   as_bad (_("unknown architecture `%s'\n"), name);
24417   *input_line_pointer = saved_char;
24418   ignore_rest_of_line ();
24419 }
24420
24421
24422 /* Parse a .object_arch directive.  */
24423
24424 static void
24425 s_arm_object_arch (int ignored ATTRIBUTE_UNUSED)
24426 {
24427   const struct arm_arch_option_table *opt;
24428   char saved_char;
24429   char *name;
24430
24431   name = input_line_pointer;
24432   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
24433     input_line_pointer++;
24434   saved_char = *input_line_pointer;
24435   *input_line_pointer = 0;
24436
24437   /* Skip the first "all" entry.  */
24438   for (opt = arm_archs + 1; opt->name != NULL; opt++)
24439     if (streq (opt->name, name))
24440       {
24441         object_arch = &opt->value;
24442         *input_line_pointer = saved_char;
24443         demand_empty_rest_of_line ();
24444         return;
24445       }
24446
24447   as_bad (_("unknown architecture `%s'\n"), name);
24448   *input_line_pointer = saved_char;
24449   ignore_rest_of_line ();
24450 }
24451
24452 /* Parse a .arch_extension directive.  */
24453
24454 static void
24455 s_arm_arch_extension (int ignored ATTRIBUTE_UNUSED)
24456 {
24457   const struct arm_option_extension_value_table *opt;
24458   char saved_char;
24459   char *name;
24460   int adding_value = 1;
24461
24462   name = input_line_pointer;
24463   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
24464     input_line_pointer++;
24465   saved_char = *input_line_pointer;
24466   *input_line_pointer = 0;
24467
24468   if (strlen (name) >= 2
24469       && strncmp (name, "no", 2) == 0)
24470     {
24471       adding_value = 0;
24472       name += 2;
24473     }
24474
24475   for (opt = arm_extensions; opt->name != NULL; opt++)
24476     if (streq (opt->name, name))
24477       {
24478         if (!ARM_CPU_HAS_FEATURE (*mcpu_cpu_opt, opt->allowed_archs))
24479           {
24480             as_bad (_("architectural extension `%s' is not allowed for the "
24481                       "current base architecture"), name);
24482             break;
24483           }
24484
24485         if (adding_value)
24486           ARM_MERGE_FEATURE_SETS (selected_cpu, selected_cpu, opt->value);
24487         else
24488           ARM_CLEAR_FEATURE (selected_cpu, selected_cpu, opt->value);
24489
24490         mcpu_cpu_opt = &selected_cpu;
24491         ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
24492         *input_line_pointer = saved_char;
24493         demand_empty_rest_of_line ();
24494         return;
24495       }
24496
24497   if (opt->name == NULL)
24498     as_bad (_("unknown architecture `%s'\n"), name);
24499
24500   *input_line_pointer = saved_char;
24501   ignore_rest_of_line ();
24502 }
24503
24504 /* Parse a .fpu directive.  */
24505
24506 static void
24507 s_arm_fpu (int ignored ATTRIBUTE_UNUSED)
24508 {
24509   const struct arm_option_fpu_value_table *opt;
24510   char saved_char;
24511   char *name;
24512
24513   name = input_line_pointer;
24514   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
24515     input_line_pointer++;
24516   saved_char = *input_line_pointer;
24517   *input_line_pointer = 0;
24518
24519   for (opt = arm_fpus; opt->name != NULL; opt++)
24520     if (streq (opt->name, name))
24521       {
24522         mfpu_opt = &opt->value;
24523         ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
24524         *input_line_pointer = saved_char;
24525         demand_empty_rest_of_line ();
24526         return;
24527       }
24528
24529   as_bad (_("unknown floating point format `%s'\n"), name);
24530   *input_line_pointer = saved_char;
24531   ignore_rest_of_line ();
24532 }
24533
24534 /* Copy symbol information.  */
24535
24536 void
24537 arm_copy_symbol_attributes (symbolS *dest, symbolS *src)
24538 {
24539   ARM_GET_FLAG (dest) = ARM_GET_FLAG (src);
24540 }
24541
24542 #ifdef OBJ_ELF
24543 /* Given a symbolic attribute NAME, return the proper integer value.
24544    Returns -1 if the attribute is not known.  */
24545
24546 int
24547 arm_convert_symbolic_attribute (const char *name)
24548 {
24549   static const struct
24550   {
24551     const char * name;
24552     const int    tag;
24553   }
24554   attribute_table[] =
24555     {
24556       /* When you modify this table you should
24557          also modify the list in doc/c-arm.texi.  */
24558 #define T(tag) {#tag, tag}
24559       T (Tag_CPU_raw_name),
24560       T (Tag_CPU_name),
24561       T (Tag_CPU_arch),
24562       T (Tag_CPU_arch_profile),
24563       T (Tag_ARM_ISA_use),
24564       T (Tag_THUMB_ISA_use),
24565       T (Tag_FP_arch),
24566       T (Tag_VFP_arch),
24567       T (Tag_WMMX_arch),
24568       T (Tag_Advanced_SIMD_arch),
24569       T (Tag_PCS_config),
24570       T (Tag_ABI_PCS_R9_use),
24571       T (Tag_ABI_PCS_RW_data),
24572       T (Tag_ABI_PCS_RO_data),
24573       T (Tag_ABI_PCS_GOT_use),
24574       T (Tag_ABI_PCS_wchar_t),
24575       T (Tag_ABI_FP_rounding),
24576       T (Tag_ABI_FP_denormal),
24577       T (Tag_ABI_FP_exceptions),
24578       T (Tag_ABI_FP_user_exceptions),
24579       T (Tag_ABI_FP_number_model),
24580       T (Tag_ABI_align_needed),
24581       T (Tag_ABI_align8_needed),
24582       T (Tag_ABI_align_preserved),
24583       T (Tag_ABI_align8_preserved),
24584       T (Tag_ABI_enum_size),
24585       T (Tag_ABI_HardFP_use),
24586       T (Tag_ABI_VFP_args),
24587       T (Tag_ABI_WMMX_args),
24588       T (Tag_ABI_optimization_goals),
24589       T (Tag_ABI_FP_optimization_goals),
24590       T (Tag_compatibility),
24591       T (Tag_CPU_unaligned_access),
24592       T (Tag_FP_HP_extension),
24593       T (Tag_VFP_HP_extension),
24594       T (Tag_ABI_FP_16bit_format),
24595       T (Tag_MPextension_use),
24596       T (Tag_DIV_use),
24597       T (Tag_nodefaults),
24598       T (Tag_also_compatible_with),
24599       T (Tag_conformance),
24600       T (Tag_T2EE_use),
24601       T (Tag_Virtualization_use),
24602       /* We deliberately do not include Tag_MPextension_use_legacy.  */
24603 #undef T
24604     };
24605   unsigned int i;
24606
24607   if (name == NULL)
24608     return -1;
24609
24610   for (i = 0; i < ARRAY_SIZE (attribute_table); i++)
24611     if (streq (name, attribute_table[i].name))
24612       return attribute_table[i].tag;
24613
24614   return -1;
24615 }
24616
24617
24618 /* Apply sym value for relocations only in the case that
24619    they are for local symbols and you have the respective
24620    architectural feature for blx and simple switches.  */
24621 int
24622 arm_apply_sym_value (struct fix * fixP)
24623 {
24624   if (fixP->fx_addsy
24625       && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
24626       && !S_FORCE_RELOC (fixP->fx_addsy, TRUE))
24627     {
24628       switch (fixP->fx_r_type)
24629         {
24630         case BFD_RELOC_ARM_PCREL_BLX:
24631         case BFD_RELOC_THUMB_PCREL_BRANCH23:
24632           if (ARM_IS_FUNC (fixP->fx_addsy))
24633             return 1;
24634           break;
24635
24636         case BFD_RELOC_ARM_PCREL_CALL:
24637         case BFD_RELOC_THUMB_PCREL_BLX:
24638           if (THUMB_IS_FUNC (fixP->fx_addsy))
24639               return 1;
24640           break;
24641
24642         default:
24643           break;
24644         }
24645
24646     }
24647   return 0;
24648 }
24649 #endif /* OBJ_ELF */