* gas/config/tc-arm.c (el_type_type_check): Add handling for 16-bit
[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   X(vcvta,      0xebc0a40, 0x3bb0000, N_INV),           \
12352   X(vrintr,     0xeb60a40, 0x3ba0400, N_INV),           \
12353   X(vrinta,     0xeb80a40, 0x3ba0400, N_INV)
12354
12355 enum neon_opc
12356 {
12357 #define X(OPC,I,F,S) N_MNEM_##OPC
12358 NEON_ENC_TAB
12359 #undef X
12360 };
12361
12362 static const struct neon_tab_entry neon_enc_tab[] =
12363 {
12364 #define X(OPC,I,F,S) { (I), (F), (S) }
12365 NEON_ENC_TAB
12366 #undef X
12367 };
12368
12369 /* Do not use these macros; instead, use NEON_ENCODE defined below.  */
12370 #define NEON_ENC_INTEGER_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
12371 #define NEON_ENC_ARMREG_(X)  (neon_enc_tab[(X) & 0x0fffffff].integer)
12372 #define NEON_ENC_POLY_(X)    (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
12373 #define NEON_ENC_FLOAT_(X)   (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
12374 #define NEON_ENC_SCALAR_(X)  (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
12375 #define NEON_ENC_IMMED_(X)   (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
12376 #define NEON_ENC_INTERLV_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
12377 #define NEON_ENC_LANE_(X)    (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
12378 #define NEON_ENC_DUP_(X)     (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
12379 #define NEON_ENC_SINGLE_(X) \
12380   ((neon_enc_tab[(X) & 0x0fffffff].integer) | ((X) & 0xf0000000))
12381 #define NEON_ENC_DOUBLE_(X) \
12382   ((neon_enc_tab[(X) & 0x0fffffff].float_or_poly) | ((X) & 0xf0000000))
12383 #define NEON_ENC_FPV8_(X) \
12384   ((neon_enc_tab[(X) & 0x0fffffff].integer) | ((X) & 0xf000000))
12385
12386 #define NEON_ENCODE(type, inst)                                 \
12387   do                                                            \
12388     {                                                           \
12389       inst.instruction = NEON_ENC_##type##_ (inst.instruction); \
12390       inst.is_neon = 1;                                         \
12391     }                                                           \
12392   while (0)
12393
12394 #define check_neon_suffixes                                             \
12395   do                                                                    \
12396     {                                                                   \
12397       if (!inst.error && inst.vectype.elems > 0 && !inst.is_neon)       \
12398         {                                                               \
12399           as_bad (_("invalid neon suffix for non neon instruction"));   \
12400           return;                                                       \
12401         }                                                               \
12402     }                                                                   \
12403   while (0)
12404
12405 /* Define shapes for instruction operands. The following mnemonic characters
12406    are used in this table:
12407
12408      F - VFP S<n> register
12409      D - Neon D<n> register
12410      Q - Neon Q<n> register
12411      I - Immediate
12412      S - Scalar
12413      R - ARM register
12414      L - D<n> register list
12415
12416    This table is used to generate various data:
12417      - enumerations of the form NS_DDR to be used as arguments to
12418        neon_select_shape.
12419      - a table classifying shapes into single, double, quad, mixed.
12420      - a table used to drive neon_select_shape.  */
12421
12422 #define NEON_SHAPE_DEF                  \
12423   X(3, (D, D, D), DOUBLE),              \
12424   X(3, (Q, Q, Q), QUAD),                \
12425   X(3, (D, D, I), DOUBLE),              \
12426   X(3, (Q, Q, I), QUAD),                \
12427   X(3, (D, D, S), DOUBLE),              \
12428   X(3, (Q, Q, S), QUAD),                \
12429   X(2, (D, D), DOUBLE),                 \
12430   X(2, (Q, Q), QUAD),                   \
12431   X(2, (D, S), DOUBLE),                 \
12432   X(2, (Q, S), QUAD),                   \
12433   X(2, (D, R), DOUBLE),                 \
12434   X(2, (Q, R), QUAD),                   \
12435   X(2, (D, I), DOUBLE),                 \
12436   X(2, (Q, I), QUAD),                   \
12437   X(3, (D, L, D), DOUBLE),              \
12438   X(2, (D, Q), MIXED),                  \
12439   X(2, (Q, D), MIXED),                  \
12440   X(3, (D, Q, I), MIXED),               \
12441   X(3, (Q, D, I), MIXED),               \
12442   X(3, (Q, D, D), MIXED),               \
12443   X(3, (D, Q, Q), MIXED),               \
12444   X(3, (Q, Q, D), MIXED),               \
12445   X(3, (Q, D, S), MIXED),               \
12446   X(3, (D, Q, S), MIXED),               \
12447   X(4, (D, D, D, I), DOUBLE),           \
12448   X(4, (Q, Q, Q, I), QUAD),             \
12449   X(2, (F, F), SINGLE),                 \
12450   X(3, (F, F, F), SINGLE),              \
12451   X(2, (F, I), SINGLE),                 \
12452   X(2, (F, D), MIXED),                  \
12453   X(2, (D, F), MIXED),                  \
12454   X(3, (F, F, I), MIXED),               \
12455   X(4, (R, R, F, F), SINGLE),           \
12456   X(4, (F, F, R, R), SINGLE),           \
12457   X(3, (D, R, R), DOUBLE),              \
12458   X(3, (R, R, D), DOUBLE),              \
12459   X(2, (S, R), SINGLE),                 \
12460   X(2, (R, S), SINGLE),                 \
12461   X(2, (F, R), SINGLE),                 \
12462   X(2, (R, F), SINGLE)
12463
12464 #define S2(A,B)         NS_##A##B
12465 #define S3(A,B,C)       NS_##A##B##C
12466 #define S4(A,B,C,D)     NS_##A##B##C##D
12467
12468 #define X(N, L, C) S##N L
12469
12470 enum neon_shape
12471 {
12472   NEON_SHAPE_DEF,
12473   NS_NULL
12474 };
12475
12476 #undef X
12477 #undef S2
12478 #undef S3
12479 #undef S4
12480
12481 enum neon_shape_class
12482 {
12483   SC_SINGLE,
12484   SC_DOUBLE,
12485   SC_QUAD,
12486   SC_MIXED
12487 };
12488
12489 #define X(N, L, C) SC_##C
12490
12491 static enum neon_shape_class neon_shape_class[] =
12492 {
12493   NEON_SHAPE_DEF
12494 };
12495
12496 #undef X
12497
12498 enum neon_shape_el
12499 {
12500   SE_F,
12501   SE_D,
12502   SE_Q,
12503   SE_I,
12504   SE_S,
12505   SE_R,
12506   SE_L
12507 };
12508
12509 /* Register widths of above.  */
12510 static unsigned neon_shape_el_size[] =
12511 {
12512   32,
12513   64,
12514   128,
12515   0,
12516   32,
12517   32,
12518   0
12519 };
12520
12521 struct neon_shape_info
12522 {
12523   unsigned els;
12524   enum neon_shape_el el[NEON_MAX_TYPE_ELS];
12525 };
12526
12527 #define S2(A,B)         { SE_##A, SE_##B }
12528 #define S3(A,B,C)       { SE_##A, SE_##B, SE_##C }
12529 #define S4(A,B,C,D)     { SE_##A, SE_##B, SE_##C, SE_##D }
12530
12531 #define X(N, L, C) { N, S##N L }
12532
12533 static struct neon_shape_info neon_shape_tab[] =
12534 {
12535   NEON_SHAPE_DEF
12536 };
12537
12538 #undef X
12539 #undef S2
12540 #undef S3
12541 #undef S4
12542
12543 /* Bit masks used in type checking given instructions.
12544   'N_EQK' means the type must be the same as (or based on in some way) the key
12545    type, which itself is marked with the 'N_KEY' bit. If the 'N_EQK' bit is
12546    set, various other bits can be set as well in order to modify the meaning of
12547    the type constraint.  */
12548
12549 enum neon_type_mask
12550 {
12551   N_S8   = 0x0000001,
12552   N_S16  = 0x0000002,
12553   N_S32  = 0x0000004,
12554   N_S64  = 0x0000008,
12555   N_U8   = 0x0000010,
12556   N_U16  = 0x0000020,
12557   N_U32  = 0x0000040,
12558   N_U64  = 0x0000080,
12559   N_I8   = 0x0000100,
12560   N_I16  = 0x0000200,
12561   N_I32  = 0x0000400,
12562   N_I64  = 0x0000800,
12563   N_8    = 0x0001000,
12564   N_16   = 0x0002000,
12565   N_32   = 0x0004000,
12566   N_64   = 0x0008000,
12567   N_P8   = 0x0010000,
12568   N_P16  = 0x0020000,
12569   N_F16  = 0x0040000,
12570   N_F32  = 0x0080000,
12571   N_F64  = 0x0100000,
12572   N_KEY  = 0x1000000, /* Key element (main type specifier).  */
12573   N_EQK  = 0x2000000, /* Given operand has the same type & size as the key.  */
12574   N_VFP  = 0x4000000, /* VFP mode: operand size must match register width.  */
12575   N_DBL  = 0x0000001, /* If N_EQK, this operand is twice the size.  */
12576   N_HLF  = 0x0000002, /* If N_EQK, this operand is half the size.  */
12577   N_SGN  = 0x0000004, /* If N_EQK, this operand is forced to be signed.  */
12578   N_UNS  = 0x0000008, /* If N_EQK, this operand is forced to be unsigned.  */
12579   N_INT  = 0x0000010, /* If N_EQK, this operand is forced to be integer.  */
12580   N_FLT  = 0x0000020, /* If N_EQK, this operand is forced to be float.  */
12581   N_SIZ  = 0x0000040, /* If N_EQK, this operand is forced to be size-only.  */
12582   N_UTYP = 0,
12583   N_MAX_NONSPECIAL = N_F64
12584 };
12585
12586 #define N_ALLMODS  (N_DBL | N_HLF | N_SGN | N_UNS | N_INT | N_FLT | N_SIZ)
12587
12588 #define N_SU_ALL   (N_S8 | N_S16 | N_S32 | N_S64 | N_U8 | N_U16 | N_U32 | N_U64)
12589 #define N_SU_32    (N_S8 | N_S16 | N_S32 | N_U8 | N_U16 | N_U32)
12590 #define N_SU_16_64 (N_S16 | N_S32 | N_S64 | N_U16 | N_U32 | N_U64)
12591 #define N_SUF_32   (N_SU_32 | N_F32)
12592 #define N_I_ALL    (N_I8 | N_I16 | N_I32 | N_I64)
12593 #define N_IF_32    (N_I8 | N_I16 | N_I32 | N_F32)
12594
12595 /* Pass this as the first type argument to neon_check_type to ignore types
12596    altogether.  */
12597 #define N_IGNORE_TYPE (N_KEY | N_EQK)
12598
12599 /* Select a "shape" for the current instruction (describing register types or
12600    sizes) from a list of alternatives. Return NS_NULL if the current instruction
12601    doesn't fit. For non-polymorphic shapes, checking is usually done as a
12602    function of operand parsing, so this function doesn't need to be called.
12603    Shapes should be listed in order of decreasing length.  */
12604
12605 static enum neon_shape
12606 neon_select_shape (enum neon_shape shape, ...)
12607 {
12608   va_list ap;
12609   enum neon_shape first_shape = shape;
12610
12611   /* Fix missing optional operands. FIXME: we don't know at this point how
12612      many arguments we should have, so this makes the assumption that we have
12613      > 1. This is true of all current Neon opcodes, I think, but may not be
12614      true in the future.  */
12615   if (!inst.operands[1].present)
12616     inst.operands[1] = inst.operands[0];
12617
12618   va_start (ap, shape);
12619
12620   for (; shape != NS_NULL; shape = (enum neon_shape) va_arg (ap, int))
12621     {
12622       unsigned j;
12623       int matches = 1;
12624
12625       for (j = 0; j < neon_shape_tab[shape].els; j++)
12626         {
12627           if (!inst.operands[j].present)
12628             {
12629               matches = 0;
12630               break;
12631             }
12632
12633           switch (neon_shape_tab[shape].el[j])
12634             {
12635             case SE_F:
12636               if (!(inst.operands[j].isreg
12637                     && inst.operands[j].isvec
12638                     && inst.operands[j].issingle
12639                     && !inst.operands[j].isquad))
12640                 matches = 0;
12641               break;
12642
12643             case SE_D:
12644               if (!(inst.operands[j].isreg
12645                     && inst.operands[j].isvec
12646                     && !inst.operands[j].isquad
12647                     && !inst.operands[j].issingle))
12648                 matches = 0;
12649               break;
12650
12651             case SE_R:
12652               if (!(inst.operands[j].isreg
12653                     && !inst.operands[j].isvec))
12654                 matches = 0;
12655               break;
12656
12657             case SE_Q:
12658               if (!(inst.operands[j].isreg
12659                     && inst.operands[j].isvec
12660                     && inst.operands[j].isquad
12661                     && !inst.operands[j].issingle))
12662                 matches = 0;
12663               break;
12664
12665             case SE_I:
12666               if (!(!inst.operands[j].isreg
12667                     && !inst.operands[j].isscalar))
12668                 matches = 0;
12669               break;
12670
12671             case SE_S:
12672               if (!(!inst.operands[j].isreg
12673                     && inst.operands[j].isscalar))
12674                 matches = 0;
12675               break;
12676
12677             case SE_L:
12678               break;
12679             }
12680           if (!matches)
12681             break;
12682         }
12683       if (matches && (j >= ARM_IT_MAX_OPERANDS || !inst.operands[j].present))
12684         /* We've matched all the entries in the shape table, and we don't
12685            have any left over operands which have not been matched.  */
12686         break;
12687     }
12688
12689   va_end (ap);
12690
12691   if (shape == NS_NULL && first_shape != NS_NULL)
12692     first_error (_("invalid instruction shape"));
12693
12694   return shape;
12695 }
12696
12697 /* True if SHAPE is predominantly a quadword operation (most of the time, this
12698    means the Q bit should be set).  */
12699
12700 static int
12701 neon_quad (enum neon_shape shape)
12702 {
12703   return neon_shape_class[shape] == SC_QUAD;
12704 }
12705
12706 static void
12707 neon_modify_type_size (unsigned typebits, enum neon_el_type *g_type,
12708                        unsigned *g_size)
12709 {
12710   /* Allow modification to be made to types which are constrained to be
12711      based on the key element, based on bits set alongside N_EQK.  */
12712   if ((typebits & N_EQK) != 0)
12713     {
12714       if ((typebits & N_HLF) != 0)
12715         *g_size /= 2;
12716       else if ((typebits & N_DBL) != 0)
12717         *g_size *= 2;
12718       if ((typebits & N_SGN) != 0)
12719         *g_type = NT_signed;
12720       else if ((typebits & N_UNS) != 0)
12721         *g_type = NT_unsigned;
12722       else if ((typebits & N_INT) != 0)
12723         *g_type = NT_integer;
12724       else if ((typebits & N_FLT) != 0)
12725         *g_type = NT_float;
12726       else if ((typebits & N_SIZ) != 0)
12727         *g_type = NT_untyped;
12728     }
12729 }
12730
12731 /* Return operand OPNO promoted by bits set in THISARG. KEY should be the "key"
12732    operand type, i.e. the single type specified in a Neon instruction when it
12733    is the only one given.  */
12734
12735 static struct neon_type_el
12736 neon_type_promote (struct neon_type_el *key, unsigned thisarg)
12737 {
12738   struct neon_type_el dest = *key;
12739
12740   gas_assert ((thisarg & N_EQK) != 0);
12741
12742   neon_modify_type_size (thisarg, &dest.type, &dest.size);
12743
12744   return dest;
12745 }
12746
12747 /* Convert Neon type and size into compact bitmask representation.  */
12748
12749 static enum neon_type_mask
12750 type_chk_of_el_type (enum neon_el_type type, unsigned size)
12751 {
12752   switch (type)
12753     {
12754     case NT_untyped:
12755       switch (size)
12756         {
12757         case 8:  return N_8;
12758         case 16: return N_16;
12759         case 32: return N_32;
12760         case 64: return N_64;
12761         default: ;
12762         }
12763       break;
12764
12765     case NT_integer:
12766       switch (size)
12767         {
12768         case 8:  return N_I8;
12769         case 16: return N_I16;
12770         case 32: return N_I32;
12771         case 64: return N_I64;
12772         default: ;
12773         }
12774       break;
12775
12776     case NT_float:
12777       switch (size)
12778         {
12779         case 16: return N_F16;
12780         case 32: return N_F32;
12781         case 64: return N_F64;
12782         default: ;
12783         }
12784       break;
12785
12786     case NT_poly:
12787       switch (size)
12788         {
12789         case 8:  return N_P8;
12790         case 16: return N_P16;
12791         default: ;
12792         }
12793       break;
12794
12795     case NT_signed:
12796       switch (size)
12797         {
12798         case 8:  return N_S8;
12799         case 16: return N_S16;
12800         case 32: return N_S32;
12801         case 64: return N_S64;
12802         default: ;
12803         }
12804       break;
12805
12806     case NT_unsigned:
12807       switch (size)
12808         {
12809         case 8:  return N_U8;
12810         case 16: return N_U16;
12811         case 32: return N_U32;
12812         case 64: return N_U64;
12813         default: ;
12814         }
12815       break;
12816
12817     default: ;
12818     }
12819
12820   return N_UTYP;
12821 }
12822
12823 /* Convert compact Neon bitmask type representation to a type and size. Only
12824    handles the case where a single bit is set in the mask.  */
12825
12826 static int
12827 el_type_of_type_chk (enum neon_el_type *type, unsigned *size,
12828                      enum neon_type_mask mask)
12829 {
12830   if ((mask & N_EQK) != 0)
12831     return FAIL;
12832
12833   if ((mask & (N_S8 | N_U8 | N_I8 | N_8 | N_P8)) != 0)
12834     *size = 8;
12835   else if ((mask & (N_S16 | N_U16 | N_I16 | N_16 | N_F16 | N_P16)) != 0)
12836     *size = 16;
12837   else if ((mask & (N_S32 | N_U32 | N_I32 | N_32 | N_F32)) != 0)
12838     *size = 32;
12839   else if ((mask & (N_S64 | N_U64 | N_I64 | N_64 | N_F64)) != 0)
12840     *size = 64;
12841   else
12842     return FAIL;
12843
12844   if ((mask & (N_S8 | N_S16 | N_S32 | N_S64)) != 0)
12845     *type = NT_signed;
12846   else if ((mask & (N_U8 | N_U16 | N_U32 | N_U64)) != 0)
12847     *type = NT_unsigned;
12848   else if ((mask & (N_I8 | N_I16 | N_I32 | N_I64)) != 0)
12849     *type = NT_integer;
12850   else if ((mask & (N_8 | N_16 | N_32 | N_64)) != 0)
12851     *type = NT_untyped;
12852   else if ((mask & (N_P8 | N_P16)) != 0)
12853     *type = NT_poly;
12854   else if ((mask & (N_F16 | N_F32 | N_F64)) != 0)
12855     *type = NT_float;
12856   else
12857     return FAIL;
12858
12859   return SUCCESS;
12860 }
12861
12862 /* Modify a bitmask of allowed types. This is only needed for type
12863    relaxation.  */
12864
12865 static unsigned
12866 modify_types_allowed (unsigned allowed, unsigned mods)
12867 {
12868   unsigned size;
12869   enum neon_el_type type;
12870   unsigned destmask;
12871   int i;
12872
12873   destmask = 0;
12874
12875   for (i = 1; i <= N_MAX_NONSPECIAL; i <<= 1)
12876     {
12877       if (el_type_of_type_chk (&type, &size,
12878                                (enum neon_type_mask) (allowed & i)) == SUCCESS)
12879         {
12880           neon_modify_type_size (mods, &type, &size);
12881           destmask |= type_chk_of_el_type (type, size);
12882         }
12883     }
12884
12885   return destmask;
12886 }
12887
12888 /* Check type and return type classification.
12889    The manual states (paraphrase): If one datatype is given, it indicates the
12890    type given in:
12891     - the second operand, if there is one
12892     - the operand, if there is no second operand
12893     - the result, if there are no operands.
12894    This isn't quite good enough though, so we use a concept of a "key" datatype
12895    which is set on a per-instruction basis, which is the one which matters when
12896    only one data type is written.
12897    Note: this function has side-effects (e.g. filling in missing operands). All
12898    Neon instructions should call it before performing bit encoding.  */
12899
12900 static struct neon_type_el
12901 neon_check_type (unsigned els, enum neon_shape ns, ...)
12902 {
12903   va_list ap;
12904   unsigned i, pass, key_el = 0;
12905   unsigned types[NEON_MAX_TYPE_ELS];
12906   enum neon_el_type k_type = NT_invtype;
12907   unsigned k_size = -1u;
12908   struct neon_type_el badtype = {NT_invtype, -1};
12909   unsigned key_allowed = 0;
12910
12911   /* Optional registers in Neon instructions are always (not) in operand 1.
12912      Fill in the missing operand here, if it was omitted.  */
12913   if (els > 1 && !inst.operands[1].present)
12914     inst.operands[1] = inst.operands[0];
12915
12916   /* Suck up all the varargs.  */
12917   va_start (ap, ns);
12918   for (i = 0; i < els; i++)
12919     {
12920       unsigned thisarg = va_arg (ap, unsigned);
12921       if (thisarg == N_IGNORE_TYPE)
12922         {
12923           va_end (ap);
12924           return badtype;
12925         }
12926       types[i] = thisarg;
12927       if ((thisarg & N_KEY) != 0)
12928         key_el = i;
12929     }
12930   va_end (ap);
12931
12932   if (inst.vectype.elems > 0)
12933     for (i = 0; i < els; i++)
12934       if (inst.operands[i].vectype.type != NT_invtype)
12935         {
12936           first_error (_("types specified in both the mnemonic and operands"));
12937           return badtype;
12938         }
12939
12940   /* Duplicate inst.vectype elements here as necessary.
12941      FIXME: No idea if this is exactly the same as the ARM assembler,
12942      particularly when an insn takes one register and one non-register
12943      operand. */
12944   if (inst.vectype.elems == 1 && els > 1)
12945     {
12946       unsigned j;
12947       inst.vectype.elems = els;
12948       inst.vectype.el[key_el] = inst.vectype.el[0];
12949       for (j = 0; j < els; j++)
12950         if (j != key_el)
12951           inst.vectype.el[j] = neon_type_promote (&inst.vectype.el[key_el],
12952                                                   types[j]);
12953     }
12954   else if (inst.vectype.elems == 0 && els > 0)
12955     {
12956       unsigned j;
12957       /* No types were given after the mnemonic, so look for types specified
12958          after each operand. We allow some flexibility here; as long as the
12959          "key" operand has a type, we can infer the others.  */
12960       for (j = 0; j < els; j++)
12961         if (inst.operands[j].vectype.type != NT_invtype)
12962           inst.vectype.el[j] = inst.operands[j].vectype;
12963
12964       if (inst.operands[key_el].vectype.type != NT_invtype)
12965         {
12966           for (j = 0; j < els; j++)
12967             if (inst.operands[j].vectype.type == NT_invtype)
12968               inst.vectype.el[j] = neon_type_promote (&inst.vectype.el[key_el],
12969                                                       types[j]);
12970         }
12971       else
12972         {
12973           first_error (_("operand types can't be inferred"));
12974           return badtype;
12975         }
12976     }
12977   else if (inst.vectype.elems != els)
12978     {
12979       first_error (_("type specifier has the wrong number of parts"));
12980       return badtype;
12981     }
12982
12983   for (pass = 0; pass < 2; pass++)
12984     {
12985       for (i = 0; i < els; i++)
12986         {
12987           unsigned thisarg = types[i];
12988           unsigned types_allowed = ((thisarg & N_EQK) != 0 && pass != 0)
12989             ? modify_types_allowed (key_allowed, thisarg) : thisarg;
12990           enum neon_el_type g_type = inst.vectype.el[i].type;
12991           unsigned g_size = inst.vectype.el[i].size;
12992
12993           /* Decay more-specific signed & unsigned types to sign-insensitive
12994              integer types if sign-specific variants are unavailable.  */
12995           if ((g_type == NT_signed || g_type == NT_unsigned)
12996               && (types_allowed & N_SU_ALL) == 0)
12997             g_type = NT_integer;
12998
12999           /* If only untyped args are allowed, decay any more specific types to
13000              them. Some instructions only care about signs for some element
13001              sizes, so handle that properly.  */
13002           if ((g_size == 8 && (types_allowed & N_8) != 0)
13003               || (g_size == 16 && (types_allowed & N_16) != 0)
13004               || (g_size == 32 && (types_allowed & N_32) != 0)
13005               || (g_size == 64 && (types_allowed & N_64) != 0))
13006             g_type = NT_untyped;
13007
13008           if (pass == 0)
13009             {
13010               if ((thisarg & N_KEY) != 0)
13011                 {
13012                   k_type = g_type;
13013                   k_size = g_size;
13014                   key_allowed = thisarg & ~N_KEY;
13015                 }
13016             }
13017           else
13018             {
13019               if ((thisarg & N_VFP) != 0)
13020                 {
13021                   enum neon_shape_el regshape;
13022                   unsigned regwidth, match;
13023
13024                   /* PR 11136: Catch the case where we are passed a shape of NS_NULL.  */
13025                   if (ns == NS_NULL)
13026                     {
13027                       first_error (_("invalid instruction shape"));
13028                       return badtype;
13029                     }
13030                   regshape = neon_shape_tab[ns].el[i];
13031                   regwidth = neon_shape_el_size[regshape];
13032
13033                   /* In VFP mode, operands must match register widths. If we
13034                      have a key operand, use its width, else use the width of
13035                      the current operand.  */
13036                   if (k_size != -1u)
13037                     match = k_size;
13038                   else
13039                     match = g_size;
13040
13041                   if (regwidth != match)
13042                     {
13043                       first_error (_("operand size must match register width"));
13044                       return badtype;
13045                     }
13046                 }
13047
13048               if ((thisarg & N_EQK) == 0)
13049                 {
13050                   unsigned given_type = type_chk_of_el_type (g_type, g_size);
13051
13052                   if ((given_type & types_allowed) == 0)
13053                     {
13054                       first_error (_("bad type in Neon instruction"));
13055                       return badtype;
13056                     }
13057                 }
13058               else
13059                 {
13060                   enum neon_el_type mod_k_type = k_type;
13061                   unsigned mod_k_size = k_size;
13062                   neon_modify_type_size (thisarg, &mod_k_type, &mod_k_size);
13063                   if (g_type != mod_k_type || g_size != mod_k_size)
13064                     {
13065                       first_error (_("inconsistent types in Neon instruction"));
13066                       return badtype;
13067                     }
13068                 }
13069             }
13070         }
13071     }
13072
13073   return inst.vectype.el[key_el];
13074 }
13075
13076 /* Neon-style VFP instruction forwarding.  */
13077
13078 /* Thumb VFP instructions have 0xE in the condition field.  */
13079
13080 static void
13081 do_vfp_cond_or_thumb (void)
13082 {
13083   inst.is_neon = 1;
13084
13085   if (thumb_mode)
13086     inst.instruction |= 0xe0000000;
13087   else
13088     inst.instruction |= inst.cond << 28;
13089 }
13090
13091 /* Look up and encode a simple mnemonic, for use as a helper function for the
13092    Neon-style VFP syntax.  This avoids duplication of bits of the insns table,
13093    etc.  It is assumed that operand parsing has already been done, and that the
13094    operands are in the form expected by the given opcode (this isn't necessarily
13095    the same as the form in which they were parsed, hence some massaging must
13096    take place before this function is called).
13097    Checks current arch version against that in the looked-up opcode.  */
13098
13099 static void
13100 do_vfp_nsyn_opcode (const char *opname)
13101 {
13102   const struct asm_opcode *opcode;
13103
13104   opcode = (const struct asm_opcode *) hash_find (arm_ops_hsh, opname);
13105
13106   if (!opcode)
13107     abort ();
13108
13109   constraint (!ARM_CPU_HAS_FEATURE (cpu_variant,
13110                 thumb_mode ? *opcode->tvariant : *opcode->avariant),
13111               _(BAD_FPU));
13112
13113   inst.is_neon = 1;
13114
13115   if (thumb_mode)
13116     {
13117       inst.instruction = opcode->tvalue;
13118       opcode->tencode ();
13119     }
13120   else
13121     {
13122       inst.instruction = (inst.cond << 28) | opcode->avalue;
13123       opcode->aencode ();
13124     }
13125 }
13126
13127 static void
13128 do_vfp_nsyn_add_sub (enum neon_shape rs)
13129 {
13130   int is_add = (inst.instruction & 0x0fffffff) == N_MNEM_vadd;
13131
13132   if (rs == NS_FFF)
13133     {
13134       if (is_add)
13135         do_vfp_nsyn_opcode ("fadds");
13136       else
13137         do_vfp_nsyn_opcode ("fsubs");
13138     }
13139   else
13140     {
13141       if (is_add)
13142         do_vfp_nsyn_opcode ("faddd");
13143       else
13144         do_vfp_nsyn_opcode ("fsubd");
13145     }
13146 }
13147
13148 /* Check operand types to see if this is a VFP instruction, and if so call
13149    PFN ().  */
13150
13151 static int
13152 try_vfp_nsyn (int args, void (*pfn) (enum neon_shape))
13153 {
13154   enum neon_shape rs;
13155   struct neon_type_el et;
13156
13157   switch (args)
13158     {
13159     case 2:
13160       rs = neon_select_shape (NS_FF, NS_DD, NS_NULL);
13161       et = neon_check_type (2, rs,
13162         N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13163       break;
13164
13165     case 3:
13166       rs = neon_select_shape (NS_FFF, NS_DDD, NS_NULL);
13167       et = neon_check_type (3, rs,
13168         N_EQK | N_VFP, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13169       break;
13170
13171     default:
13172       abort ();
13173     }
13174
13175   if (et.type != NT_invtype)
13176     {
13177       pfn (rs);
13178       return SUCCESS;
13179     }
13180
13181   inst.error = NULL;
13182   return FAIL;
13183 }
13184
13185 static void
13186 do_vfp_nsyn_mla_mls (enum neon_shape rs)
13187 {
13188   int is_mla = (inst.instruction & 0x0fffffff) == N_MNEM_vmla;
13189
13190   if (rs == NS_FFF)
13191     {
13192       if (is_mla)
13193         do_vfp_nsyn_opcode ("fmacs");
13194       else
13195         do_vfp_nsyn_opcode ("fnmacs");
13196     }
13197   else
13198     {
13199       if (is_mla)
13200         do_vfp_nsyn_opcode ("fmacd");
13201       else
13202         do_vfp_nsyn_opcode ("fnmacd");
13203     }
13204 }
13205
13206 static void
13207 do_vfp_nsyn_fma_fms (enum neon_shape rs)
13208 {
13209   int is_fma = (inst.instruction & 0x0fffffff) == N_MNEM_vfma;
13210
13211   if (rs == NS_FFF)
13212     {
13213       if (is_fma)
13214         do_vfp_nsyn_opcode ("ffmas");
13215       else
13216         do_vfp_nsyn_opcode ("ffnmas");
13217     }
13218   else
13219     {
13220       if (is_fma)
13221         do_vfp_nsyn_opcode ("ffmad");
13222       else
13223         do_vfp_nsyn_opcode ("ffnmad");
13224     }
13225 }
13226
13227 static void
13228 do_vfp_nsyn_mul (enum neon_shape rs)
13229 {
13230   if (rs == NS_FFF)
13231     do_vfp_nsyn_opcode ("fmuls");
13232   else
13233     do_vfp_nsyn_opcode ("fmuld");
13234 }
13235
13236 static void
13237 do_vfp_nsyn_abs_neg (enum neon_shape rs)
13238 {
13239   int is_neg = (inst.instruction & 0x80) != 0;
13240   neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_VFP | N_KEY);
13241
13242   if (rs == NS_FF)
13243     {
13244       if (is_neg)
13245         do_vfp_nsyn_opcode ("fnegs");
13246       else
13247         do_vfp_nsyn_opcode ("fabss");
13248     }
13249   else
13250     {
13251       if (is_neg)
13252         do_vfp_nsyn_opcode ("fnegd");
13253       else
13254         do_vfp_nsyn_opcode ("fabsd");
13255     }
13256 }
13257
13258 /* Encode single-precision (only!) VFP fldm/fstm instructions. Double precision
13259    insns belong to Neon, and are handled elsewhere.  */
13260
13261 static void
13262 do_vfp_nsyn_ldm_stm (int is_dbmode)
13263 {
13264   int is_ldm = (inst.instruction & (1 << 20)) != 0;
13265   if (is_ldm)
13266     {
13267       if (is_dbmode)
13268         do_vfp_nsyn_opcode ("fldmdbs");
13269       else
13270         do_vfp_nsyn_opcode ("fldmias");
13271     }
13272   else
13273     {
13274       if (is_dbmode)
13275         do_vfp_nsyn_opcode ("fstmdbs");
13276       else
13277         do_vfp_nsyn_opcode ("fstmias");
13278     }
13279 }
13280
13281 static void
13282 do_vfp_nsyn_sqrt (void)
13283 {
13284   enum neon_shape rs = neon_select_shape (NS_FF, NS_DD, NS_NULL);
13285   neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13286
13287   if (rs == NS_FF)
13288     do_vfp_nsyn_opcode ("fsqrts");
13289   else
13290     do_vfp_nsyn_opcode ("fsqrtd");
13291 }
13292
13293 static void
13294 do_vfp_nsyn_div (void)
13295 {
13296   enum neon_shape rs = neon_select_shape (NS_FFF, NS_DDD, NS_NULL);
13297   neon_check_type (3, rs, N_EQK | N_VFP, N_EQK | N_VFP,
13298     N_F32 | N_F64 | N_KEY | N_VFP);
13299
13300   if (rs == NS_FFF)
13301     do_vfp_nsyn_opcode ("fdivs");
13302   else
13303     do_vfp_nsyn_opcode ("fdivd");
13304 }
13305
13306 static void
13307 do_vfp_nsyn_nmul (void)
13308 {
13309   enum neon_shape rs = neon_select_shape (NS_FFF, NS_DDD, NS_NULL);
13310   neon_check_type (3, rs, N_EQK | N_VFP, N_EQK | N_VFP,
13311     N_F32 | N_F64 | N_KEY | N_VFP);
13312
13313   if (rs == NS_FFF)
13314     {
13315       NEON_ENCODE (SINGLE, inst);
13316       do_vfp_sp_dyadic ();
13317     }
13318   else
13319     {
13320       NEON_ENCODE (DOUBLE, inst);
13321       do_vfp_dp_rd_rn_rm ();
13322     }
13323   do_vfp_cond_or_thumb ();
13324 }
13325
13326 static void
13327 do_vfp_nsyn_cmp (void)
13328 {
13329   if (inst.operands[1].isreg)
13330     {
13331       enum neon_shape rs = neon_select_shape (NS_FF, NS_DD, NS_NULL);
13332       neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13333
13334       if (rs == NS_FF)
13335         {
13336           NEON_ENCODE (SINGLE, inst);
13337           do_vfp_sp_monadic ();
13338         }
13339       else
13340         {
13341           NEON_ENCODE (DOUBLE, inst);
13342           do_vfp_dp_rd_rm ();
13343         }
13344     }
13345   else
13346     {
13347       enum neon_shape rs = neon_select_shape (NS_FI, NS_DI, NS_NULL);
13348       neon_check_type (2, rs, N_F32 | N_F64 | N_KEY | N_VFP, N_EQK);
13349
13350       switch (inst.instruction & 0x0fffffff)
13351         {
13352         case N_MNEM_vcmp:
13353           inst.instruction += N_MNEM_vcmpz - N_MNEM_vcmp;
13354           break;
13355         case N_MNEM_vcmpe:
13356           inst.instruction += N_MNEM_vcmpez - N_MNEM_vcmpe;
13357           break;
13358         default:
13359           abort ();
13360         }
13361
13362       if (rs == NS_FI)
13363         {
13364           NEON_ENCODE (SINGLE, inst);
13365           do_vfp_sp_compare_z ();
13366         }
13367       else
13368         {
13369           NEON_ENCODE (DOUBLE, inst);
13370           do_vfp_dp_rd ();
13371         }
13372     }
13373   do_vfp_cond_or_thumb ();
13374 }
13375
13376 static void
13377 nsyn_insert_sp (void)
13378 {
13379   inst.operands[1] = inst.operands[0];
13380   memset (&inst.operands[0], '\0', sizeof (inst.operands[0]));
13381   inst.operands[0].reg = REG_SP;
13382   inst.operands[0].isreg = 1;
13383   inst.operands[0].writeback = 1;
13384   inst.operands[0].present = 1;
13385 }
13386
13387 static void
13388 do_vfp_nsyn_push (void)
13389 {
13390   nsyn_insert_sp ();
13391   if (inst.operands[1].issingle)
13392     do_vfp_nsyn_opcode ("fstmdbs");
13393   else
13394     do_vfp_nsyn_opcode ("fstmdbd");
13395 }
13396
13397 static void
13398 do_vfp_nsyn_pop (void)
13399 {
13400   nsyn_insert_sp ();
13401   if (inst.operands[1].issingle)
13402     do_vfp_nsyn_opcode ("fldmias");
13403   else
13404     do_vfp_nsyn_opcode ("fldmiad");
13405 }
13406
13407 /* Fix up Neon data-processing instructions, ORing in the correct bits for
13408    ARM mode or Thumb mode and moving the encoded bit 24 to bit 28.  */
13409
13410 static void
13411 neon_dp_fixup (struct arm_it* insn)
13412 {
13413   unsigned int i = insn->instruction;
13414   insn->is_neon = 1;
13415
13416   if (thumb_mode)
13417     {
13418       /* The U bit is at bit 24 by default. Move to bit 28 in Thumb mode.  */
13419       if (i & (1 << 24))
13420         i |= 1 << 28;
13421
13422       i &= ~(1 << 24);
13423
13424       i |= 0xef000000;
13425     }
13426   else
13427     i |= 0xf2000000;
13428
13429   insn->instruction = i;
13430 }
13431
13432 /* Turn a size (8, 16, 32, 64) into the respective bit number minus 3
13433    (0, 1, 2, 3).  */
13434
13435 static unsigned
13436 neon_logbits (unsigned x)
13437 {
13438   return ffs (x) - 4;
13439 }
13440
13441 #define LOW4(R) ((R) & 0xf)
13442 #define HI1(R) (((R) >> 4) & 1)
13443
13444 /* Encode insns with bit pattern:
13445
13446   |28/24|23|22 |21 20|19 16|15 12|11    8|7|6|5|4|3  0|
13447   |  U  |x |D  |size | Rn  | Rd  |x x x x|N|Q|M|x| Rm |
13448
13449   SIZE is passed in bits. -1 means size field isn't changed, in case it has a
13450   different meaning for some instruction.  */
13451
13452 static void
13453 neon_three_same (int isquad, int ubit, int size)
13454 {
13455   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
13456   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
13457   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
13458   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
13459   inst.instruction |= LOW4 (inst.operands[2].reg);
13460   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
13461   inst.instruction |= (isquad != 0) << 6;
13462   inst.instruction |= (ubit != 0) << 24;
13463   if (size != -1)
13464     inst.instruction |= neon_logbits (size) << 20;
13465
13466   neon_dp_fixup (&inst);
13467 }
13468
13469 /* Encode instructions of the form:
13470
13471   |28/24|23|22|21 20|19 18|17 16|15 12|11      7|6|5|4|3  0|
13472   |  U  |x |D |x  x |size |x  x | Rd  |x x x x x|Q|M|x| Rm |
13473
13474   Don't write size if SIZE == -1.  */
13475
13476 static void
13477 neon_two_same (int qbit, int ubit, int size)
13478 {
13479   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
13480   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
13481   inst.instruction |= LOW4 (inst.operands[1].reg);
13482   inst.instruction |= HI1 (inst.operands[1].reg) << 5;
13483   inst.instruction |= (qbit != 0) << 6;
13484   inst.instruction |= (ubit != 0) << 24;
13485
13486   if (size != -1)
13487     inst.instruction |= neon_logbits (size) << 18;
13488
13489   neon_dp_fixup (&inst);
13490 }
13491
13492 /* Neon instruction encoders, in approximate order of appearance.  */
13493
13494 static void
13495 do_neon_dyadic_i_su (void)
13496 {
13497   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13498   struct neon_type_el et = neon_check_type (3, rs,
13499     N_EQK, N_EQK, N_SU_32 | N_KEY);
13500   neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
13501 }
13502
13503 static void
13504 do_neon_dyadic_i64_su (void)
13505 {
13506   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13507   struct neon_type_el et = neon_check_type (3, rs,
13508     N_EQK, N_EQK, N_SU_ALL | N_KEY);
13509   neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
13510 }
13511
13512 static void
13513 neon_imm_shift (int write_ubit, int uval, int isquad, struct neon_type_el et,
13514                 unsigned immbits)
13515 {
13516   unsigned size = et.size >> 3;
13517   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
13518   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
13519   inst.instruction |= LOW4 (inst.operands[1].reg);
13520   inst.instruction |= HI1 (inst.operands[1].reg) << 5;
13521   inst.instruction |= (isquad != 0) << 6;
13522   inst.instruction |= immbits << 16;
13523   inst.instruction |= (size >> 3) << 7;
13524   inst.instruction |= (size & 0x7) << 19;
13525   if (write_ubit)
13526     inst.instruction |= (uval != 0) << 24;
13527
13528   neon_dp_fixup (&inst);
13529 }
13530
13531 static void
13532 do_neon_shl_imm (void)
13533 {
13534   if (!inst.operands[2].isreg)
13535     {
13536       enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
13537       struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_KEY | N_I_ALL);
13538       NEON_ENCODE (IMMED, inst);
13539       neon_imm_shift (FALSE, 0, neon_quad (rs), et, inst.operands[2].imm);
13540     }
13541   else
13542     {
13543       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13544       struct neon_type_el et = neon_check_type (3, rs,
13545         N_EQK, N_SU_ALL | N_KEY, N_EQK | N_SGN);
13546       unsigned int tmp;
13547
13548       /* VSHL/VQSHL 3-register variants have syntax such as:
13549            vshl.xx Dd, Dm, Dn
13550          whereas other 3-register operations encoded by neon_three_same have
13551          syntax like:
13552            vadd.xx Dd, Dn, Dm
13553          (i.e. with Dn & Dm reversed). Swap operands[1].reg and operands[2].reg
13554          here.  */
13555       tmp = inst.operands[2].reg;
13556       inst.operands[2].reg = inst.operands[1].reg;
13557       inst.operands[1].reg = tmp;
13558       NEON_ENCODE (INTEGER, inst);
13559       neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
13560     }
13561 }
13562
13563 static void
13564 do_neon_qshl_imm (void)
13565 {
13566   if (!inst.operands[2].isreg)
13567     {
13568       enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
13569       struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_ALL | N_KEY);
13570
13571       NEON_ENCODE (IMMED, inst);
13572       neon_imm_shift (TRUE, et.type == NT_unsigned, neon_quad (rs), et,
13573                       inst.operands[2].imm);
13574     }
13575   else
13576     {
13577       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13578       struct neon_type_el et = neon_check_type (3, rs,
13579         N_EQK, N_SU_ALL | N_KEY, N_EQK | N_SGN);
13580       unsigned int tmp;
13581
13582       /* See note in do_neon_shl_imm.  */
13583       tmp = inst.operands[2].reg;
13584       inst.operands[2].reg = inst.operands[1].reg;
13585       inst.operands[1].reg = tmp;
13586       NEON_ENCODE (INTEGER, inst);
13587       neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
13588     }
13589 }
13590
13591 static void
13592 do_neon_rshl (void)
13593 {
13594   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13595   struct neon_type_el et = neon_check_type (3, rs,
13596     N_EQK, N_EQK, N_SU_ALL | N_KEY);
13597   unsigned int tmp;
13598
13599   tmp = inst.operands[2].reg;
13600   inst.operands[2].reg = inst.operands[1].reg;
13601   inst.operands[1].reg = tmp;
13602   neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
13603 }
13604
13605 static int
13606 neon_cmode_for_logic_imm (unsigned immediate, unsigned *immbits, int size)
13607 {
13608   /* Handle .I8 pseudo-instructions.  */
13609   if (size == 8)
13610     {
13611       /* Unfortunately, this will make everything apart from zero out-of-range.
13612          FIXME is this the intended semantics? There doesn't seem much point in
13613          accepting .I8 if so.  */
13614       immediate |= immediate << 8;
13615       size = 16;
13616     }
13617
13618   if (size >= 32)
13619     {
13620       if (immediate == (immediate & 0x000000ff))
13621         {
13622           *immbits = immediate;
13623           return 0x1;
13624         }
13625       else if (immediate == (immediate & 0x0000ff00))
13626         {
13627           *immbits = immediate >> 8;
13628           return 0x3;
13629         }
13630       else if (immediate == (immediate & 0x00ff0000))
13631         {
13632           *immbits = immediate >> 16;
13633           return 0x5;
13634         }
13635       else if (immediate == (immediate & 0xff000000))
13636         {
13637           *immbits = immediate >> 24;
13638           return 0x7;
13639         }
13640       if ((immediate & 0xffff) != (immediate >> 16))
13641         goto bad_immediate;
13642       immediate &= 0xffff;
13643     }
13644
13645   if (immediate == (immediate & 0x000000ff))
13646     {
13647       *immbits = immediate;
13648       return 0x9;
13649     }
13650   else if (immediate == (immediate & 0x0000ff00))
13651     {
13652       *immbits = immediate >> 8;
13653       return 0xb;
13654     }
13655
13656   bad_immediate:
13657   first_error (_("immediate value out of range"));
13658   return FAIL;
13659 }
13660
13661 /* True if IMM has form 0bAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD for bits
13662    A, B, C, D.  */
13663
13664 static int
13665 neon_bits_same_in_bytes (unsigned imm)
13666 {
13667   return ((imm & 0x000000ff) == 0 || (imm & 0x000000ff) == 0x000000ff)
13668          && ((imm & 0x0000ff00) == 0 || (imm & 0x0000ff00) == 0x0000ff00)
13669          && ((imm & 0x00ff0000) == 0 || (imm & 0x00ff0000) == 0x00ff0000)
13670          && ((imm & 0xff000000) == 0 || (imm & 0xff000000) == 0xff000000);
13671 }
13672
13673 /* For immediate of above form, return 0bABCD.  */
13674
13675 static unsigned
13676 neon_squash_bits (unsigned imm)
13677 {
13678   return (imm & 0x01) | ((imm & 0x0100) >> 7) | ((imm & 0x010000) >> 14)
13679          | ((imm & 0x01000000) >> 21);
13680 }
13681
13682 /* Compress quarter-float representation to 0b...000 abcdefgh.  */
13683
13684 static unsigned
13685 neon_qfloat_bits (unsigned imm)
13686 {
13687   return ((imm >> 19) & 0x7f) | ((imm >> 24) & 0x80);
13688 }
13689
13690 /* Returns CMODE. IMMBITS [7:0] is set to bits suitable for inserting into
13691    the instruction. *OP is passed as the initial value of the op field, and
13692    may be set to a different value depending on the constant (i.e.
13693    "MOV I64, 0bAAAAAAAABBBB..." which uses OP = 1 despite being MOV not
13694    MVN).  If the immediate looks like a repeated pattern then also
13695    try smaller element sizes.  */
13696
13697 static int
13698 neon_cmode_for_move_imm (unsigned immlo, unsigned immhi, int float_p,
13699                          unsigned *immbits, int *op, int size,
13700                          enum neon_el_type type)
13701 {
13702   /* Only permit float immediates (including 0.0/-0.0) if the operand type is
13703      float.  */
13704   if (type == NT_float && !float_p)
13705     return FAIL;
13706
13707   if (type == NT_float && is_quarter_float (immlo) && immhi == 0)
13708     {
13709       if (size != 32 || *op == 1)
13710         return FAIL;
13711       *immbits = neon_qfloat_bits (immlo);
13712       return 0xf;
13713     }
13714
13715   if (size == 64)
13716     {
13717       if (neon_bits_same_in_bytes (immhi)
13718           && neon_bits_same_in_bytes (immlo))
13719         {
13720           if (*op == 1)
13721             return FAIL;
13722           *immbits = (neon_squash_bits (immhi) << 4)
13723                      | neon_squash_bits (immlo);
13724           *op = 1;
13725           return 0xe;
13726         }
13727
13728       if (immhi != immlo)
13729         return FAIL;
13730     }
13731
13732   if (size >= 32)
13733     {
13734       if (immlo == (immlo & 0x000000ff))
13735         {
13736           *immbits = immlo;
13737           return 0x0;
13738         }
13739       else if (immlo == (immlo & 0x0000ff00))
13740         {
13741           *immbits = immlo >> 8;
13742           return 0x2;
13743         }
13744       else if (immlo == (immlo & 0x00ff0000))
13745         {
13746           *immbits = immlo >> 16;
13747           return 0x4;
13748         }
13749       else if (immlo == (immlo & 0xff000000))
13750         {
13751           *immbits = immlo >> 24;
13752           return 0x6;
13753         }
13754       else if (immlo == ((immlo & 0x0000ff00) | 0x000000ff))
13755         {
13756           *immbits = (immlo >> 8) & 0xff;
13757           return 0xc;
13758         }
13759       else if (immlo == ((immlo & 0x00ff0000) | 0x0000ffff))
13760         {
13761           *immbits = (immlo >> 16) & 0xff;
13762           return 0xd;
13763         }
13764
13765       if ((immlo & 0xffff) != (immlo >> 16))
13766         return FAIL;
13767       immlo &= 0xffff;
13768     }
13769
13770   if (size >= 16)
13771     {
13772       if (immlo == (immlo & 0x000000ff))
13773         {
13774           *immbits = immlo;
13775           return 0x8;
13776         }
13777       else if (immlo == (immlo & 0x0000ff00))
13778         {
13779           *immbits = immlo >> 8;
13780           return 0xa;
13781         }
13782
13783       if ((immlo & 0xff) != (immlo >> 8))
13784         return FAIL;
13785       immlo &= 0xff;
13786     }
13787
13788   if (immlo == (immlo & 0x000000ff))
13789     {
13790       /* Don't allow MVN with 8-bit immediate.  */
13791       if (*op == 1)
13792         return FAIL;
13793       *immbits = immlo;
13794       return 0xe;
13795     }
13796
13797   return FAIL;
13798 }
13799
13800 /* Write immediate bits [7:0] to the following locations:
13801
13802   |28/24|23     19|18 16|15                    4|3     0|
13803   |  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|
13804
13805   This function is used by VMOV/VMVN/VORR/VBIC.  */
13806
13807 static void
13808 neon_write_immbits (unsigned immbits)
13809 {
13810   inst.instruction |= immbits & 0xf;
13811   inst.instruction |= ((immbits >> 4) & 0x7) << 16;
13812   inst.instruction |= ((immbits >> 7) & 0x1) << 24;
13813 }
13814
13815 /* Invert low-order SIZE bits of XHI:XLO.  */
13816
13817 static void
13818 neon_invert_size (unsigned *xlo, unsigned *xhi, int size)
13819 {
13820   unsigned immlo = xlo ? *xlo : 0;
13821   unsigned immhi = xhi ? *xhi : 0;
13822
13823   switch (size)
13824     {
13825     case 8:
13826       immlo = (~immlo) & 0xff;
13827       break;
13828
13829     case 16:
13830       immlo = (~immlo) & 0xffff;
13831       break;
13832
13833     case 64:
13834       immhi = (~immhi) & 0xffffffff;
13835       /* fall through.  */
13836
13837     case 32:
13838       immlo = (~immlo) & 0xffffffff;
13839       break;
13840
13841     default:
13842       abort ();
13843     }
13844
13845   if (xlo)
13846     *xlo = immlo;
13847
13848   if (xhi)
13849     *xhi = immhi;
13850 }
13851
13852 static void
13853 do_neon_logic (void)
13854 {
13855   if (inst.operands[2].present && inst.operands[2].isreg)
13856     {
13857       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13858       neon_check_type (3, rs, N_IGNORE_TYPE);
13859       /* U bit and size field were set as part of the bitmask.  */
13860       NEON_ENCODE (INTEGER, inst);
13861       neon_three_same (neon_quad (rs), 0, -1);
13862     }
13863   else
13864     {
13865       const int three_ops_form = (inst.operands[2].present
13866                                   && !inst.operands[2].isreg);
13867       const int immoperand = (three_ops_form ? 2 : 1);
13868       enum neon_shape rs = (three_ops_form
13869                             ? neon_select_shape (NS_DDI, NS_QQI, NS_NULL)
13870                             : neon_select_shape (NS_DI, NS_QI, NS_NULL));
13871       struct neon_type_el et = neon_check_type (2, rs,
13872         N_I8 | N_I16 | N_I32 | N_I64 | N_F32 | N_KEY, N_EQK);
13873       enum neon_opc opcode = (enum neon_opc) inst.instruction & 0x0fffffff;
13874       unsigned immbits;
13875       int cmode;
13876
13877       if (et.type == NT_invtype)
13878         return;
13879
13880       if (three_ops_form)
13881         constraint (inst.operands[0].reg != inst.operands[1].reg,
13882                     _("first and second operands shall be the same register"));
13883
13884       NEON_ENCODE (IMMED, inst);
13885
13886       immbits = inst.operands[immoperand].imm;
13887       if (et.size == 64)
13888         {
13889           /* .i64 is a pseudo-op, so the immediate must be a repeating
13890              pattern.  */
13891           if (immbits != (inst.operands[immoperand].regisimm ?
13892                           inst.operands[immoperand].reg : 0))
13893             {
13894               /* Set immbits to an invalid constant.  */
13895               immbits = 0xdeadbeef;
13896             }
13897         }
13898
13899       switch (opcode)
13900         {
13901         case N_MNEM_vbic:
13902           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
13903           break;
13904
13905         case N_MNEM_vorr:
13906           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
13907           break;
13908
13909         case N_MNEM_vand:
13910           /* Pseudo-instruction for VBIC.  */
13911           neon_invert_size (&immbits, 0, et.size);
13912           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
13913           break;
13914
13915         case N_MNEM_vorn:
13916           /* Pseudo-instruction for VORR.  */
13917           neon_invert_size (&immbits, 0, et.size);
13918           cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
13919           break;
13920
13921         default:
13922           abort ();
13923         }
13924
13925       if (cmode == FAIL)
13926         return;
13927
13928       inst.instruction |= neon_quad (rs) << 6;
13929       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
13930       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
13931       inst.instruction |= cmode << 8;
13932       neon_write_immbits (immbits);
13933
13934       neon_dp_fixup (&inst);
13935     }
13936 }
13937
13938 static void
13939 do_neon_bitfield (void)
13940 {
13941   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13942   neon_check_type (3, rs, N_IGNORE_TYPE);
13943   neon_three_same (neon_quad (rs), 0, -1);
13944 }
13945
13946 static void
13947 neon_dyadic_misc (enum neon_el_type ubit_meaning, unsigned types,
13948                   unsigned destbits)
13949 {
13950   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
13951   struct neon_type_el et = neon_check_type (3, rs, N_EQK | destbits, N_EQK,
13952                                             types | N_KEY);
13953   if (et.type == NT_float)
13954     {
13955       NEON_ENCODE (FLOAT, inst);
13956       neon_three_same (neon_quad (rs), 0, -1);
13957     }
13958   else
13959     {
13960       NEON_ENCODE (INTEGER, inst);
13961       neon_three_same (neon_quad (rs), et.type == ubit_meaning, et.size);
13962     }
13963 }
13964
13965 static void
13966 do_neon_dyadic_if_su (void)
13967 {
13968   neon_dyadic_misc (NT_unsigned, N_SUF_32, 0);
13969 }
13970
13971 static void
13972 do_neon_dyadic_if_su_d (void)
13973 {
13974   /* This version only allow D registers, but that constraint is enforced during
13975      operand parsing so we don't need to do anything extra here.  */
13976   neon_dyadic_misc (NT_unsigned, N_SUF_32, 0);
13977 }
13978
13979 static void
13980 do_neon_dyadic_if_i_d (void)
13981 {
13982   /* The "untyped" case can't happen. Do this to stop the "U" bit being
13983      affected if we specify unsigned args.  */
13984   neon_dyadic_misc (NT_untyped, N_IF_32, 0);
13985 }
13986
13987 enum vfp_or_neon_is_neon_bits
13988 {
13989   NEON_CHECK_CC = 1,
13990   NEON_CHECK_ARCH = 2,
13991   NEON_CHECK_ARCH8 = 4
13992 };
13993
13994 /* Call this function if an instruction which may have belonged to the VFP or
13995    Neon instruction sets, but turned out to be a Neon instruction (due to the
13996    operand types involved, etc.). We have to check and/or fix-up a couple of
13997    things:
13998
13999      - Make sure the user hasn't attempted to make a Neon instruction
14000        conditional.
14001      - Alter the value in the condition code field if necessary.
14002      - Make sure that the arch supports Neon instructions.
14003
14004    Which of these operations take place depends on bits from enum
14005    vfp_or_neon_is_neon_bits.
14006
14007    WARNING: This function has side effects! If NEON_CHECK_CC is used and the
14008    current instruction's condition is COND_ALWAYS, the condition field is
14009    changed to inst.uncond_value. This is necessary because instructions shared
14010    between VFP and Neon may be conditional for the VFP variants only, and the
14011    unconditional Neon version must have, e.g., 0xF in the condition field.  */
14012
14013 static int
14014 vfp_or_neon_is_neon (unsigned check)
14015 {
14016   /* Conditions are always legal in Thumb mode (IT blocks).  */
14017   if (!thumb_mode && (check & NEON_CHECK_CC))
14018     {
14019       if (inst.cond != COND_ALWAYS)
14020         {
14021           first_error (_(BAD_COND));
14022           return FAIL;
14023         }
14024       if (inst.uncond_value != -1)
14025         inst.instruction |= inst.uncond_value << 28;
14026     }
14027
14028   if ((check & NEON_CHECK_ARCH)
14029       && !mark_feature_used (&fpu_neon_ext_v1))
14030     {
14031       first_error (_(BAD_FPU));
14032       return FAIL;
14033     }
14034
14035   if ((check & NEON_CHECK_ARCH8)
14036       && !mark_feature_used (&fpu_neon_ext_armv8))
14037     {
14038       first_error (_(BAD_FPU));
14039       return FAIL;
14040     }
14041
14042   return SUCCESS;
14043 }
14044
14045 static void
14046 do_neon_addsub_if_i (void)
14047 {
14048   if (try_vfp_nsyn (3, do_vfp_nsyn_add_sub) == SUCCESS)
14049     return;
14050
14051   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14052     return;
14053
14054   /* The "untyped" case can't happen. Do this to stop the "U" bit being
14055      affected if we specify unsigned args.  */
14056   neon_dyadic_misc (NT_untyped, N_IF_32 | N_I64, 0);
14057 }
14058
14059 /* Swaps operands 1 and 2. If operand 1 (optional arg) was omitted, we want the
14060    result to be:
14061      V<op> A,B     (A is operand 0, B is operand 2)
14062    to mean:
14063      V<op> A,B,A
14064    not:
14065      V<op> A,B,B
14066    so handle that case specially.  */
14067
14068 static void
14069 neon_exchange_operands (void)
14070 {
14071   void *scratch = alloca (sizeof (inst.operands[0]));
14072   if (inst.operands[1].present)
14073     {
14074       /* Swap operands[1] and operands[2].  */
14075       memcpy (scratch, &inst.operands[1], sizeof (inst.operands[0]));
14076       inst.operands[1] = inst.operands[2];
14077       memcpy (&inst.operands[2], scratch, sizeof (inst.operands[0]));
14078     }
14079   else
14080     {
14081       inst.operands[1] = inst.operands[2];
14082       inst.operands[2] = inst.operands[0];
14083     }
14084 }
14085
14086 static void
14087 neon_compare (unsigned regtypes, unsigned immtypes, int invert)
14088 {
14089   if (inst.operands[2].isreg)
14090     {
14091       if (invert)
14092         neon_exchange_operands ();
14093       neon_dyadic_misc (NT_unsigned, regtypes, N_SIZ);
14094     }
14095   else
14096     {
14097       enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14098       struct neon_type_el et = neon_check_type (2, rs,
14099         N_EQK | N_SIZ, immtypes | N_KEY);
14100
14101       NEON_ENCODE (IMMED, inst);
14102       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14103       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14104       inst.instruction |= LOW4 (inst.operands[1].reg);
14105       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14106       inst.instruction |= neon_quad (rs) << 6;
14107       inst.instruction |= (et.type == NT_float) << 10;
14108       inst.instruction |= neon_logbits (et.size) << 18;
14109
14110       neon_dp_fixup (&inst);
14111     }
14112 }
14113
14114 static void
14115 do_neon_cmp (void)
14116 {
14117   neon_compare (N_SUF_32, N_S8 | N_S16 | N_S32 | N_F32, FALSE);
14118 }
14119
14120 static void
14121 do_neon_cmp_inv (void)
14122 {
14123   neon_compare (N_SUF_32, N_S8 | N_S16 | N_S32 | N_F32, TRUE);
14124 }
14125
14126 static void
14127 do_neon_ceq (void)
14128 {
14129   neon_compare (N_IF_32, N_IF_32, FALSE);
14130 }
14131
14132 /* For multiply instructions, we have the possibility of 16-bit or 32-bit
14133    scalars, which are encoded in 5 bits, M : Rm.
14134    For 16-bit scalars, the register is encoded in Rm[2:0] and the index in
14135    M:Rm[3], and for 32-bit scalars, the register is encoded in Rm[3:0] and the
14136    index in M.  */
14137
14138 static unsigned
14139 neon_scalar_for_mul (unsigned scalar, unsigned elsize)
14140 {
14141   unsigned regno = NEON_SCALAR_REG (scalar);
14142   unsigned elno = NEON_SCALAR_INDEX (scalar);
14143
14144   switch (elsize)
14145     {
14146     case 16:
14147       if (regno > 7 || elno > 3)
14148         goto bad_scalar;
14149       return regno | (elno << 3);
14150
14151     case 32:
14152       if (regno > 15 || elno > 1)
14153         goto bad_scalar;
14154       return regno | (elno << 4);
14155
14156     default:
14157     bad_scalar:
14158       first_error (_("scalar out of range for multiply instruction"));
14159     }
14160
14161   return 0;
14162 }
14163
14164 /* Encode multiply / multiply-accumulate scalar instructions.  */
14165
14166 static void
14167 neon_mul_mac (struct neon_type_el et, int ubit)
14168 {
14169   unsigned scalar;
14170
14171   /* Give a more helpful error message if we have an invalid type.  */
14172   if (et.type == NT_invtype)
14173     return;
14174
14175   scalar = neon_scalar_for_mul (inst.operands[2].reg, et.size);
14176   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14177   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14178   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
14179   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
14180   inst.instruction |= LOW4 (scalar);
14181   inst.instruction |= HI1 (scalar) << 5;
14182   inst.instruction |= (et.type == NT_float) << 8;
14183   inst.instruction |= neon_logbits (et.size) << 20;
14184   inst.instruction |= (ubit != 0) << 24;
14185
14186   neon_dp_fixup (&inst);
14187 }
14188
14189 static void
14190 do_neon_mac_maybe_scalar (void)
14191 {
14192   if (try_vfp_nsyn (3, do_vfp_nsyn_mla_mls) == SUCCESS)
14193     return;
14194
14195   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14196     return;
14197
14198   if (inst.operands[2].isscalar)
14199     {
14200       enum neon_shape rs = neon_select_shape (NS_DDS, NS_QQS, NS_NULL);
14201       struct neon_type_el et = neon_check_type (3, rs,
14202         N_EQK, N_EQK, N_I16 | N_I32 | N_F32 | N_KEY);
14203       NEON_ENCODE (SCALAR, inst);
14204       neon_mul_mac (et, neon_quad (rs));
14205     }
14206   else
14207     {
14208       /* The "untyped" case can't happen.  Do this to stop the "U" bit being
14209          affected if we specify unsigned args.  */
14210       neon_dyadic_misc (NT_untyped, N_IF_32, 0);
14211     }
14212 }
14213
14214 static void
14215 do_neon_fmac (void)
14216 {
14217   if (try_vfp_nsyn (3, do_vfp_nsyn_fma_fms) == SUCCESS)
14218     return;
14219
14220   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14221     return;
14222
14223   neon_dyadic_misc (NT_untyped, N_IF_32, 0);
14224 }
14225
14226 static void
14227 do_neon_tst (void)
14228 {
14229   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14230   struct neon_type_el et = neon_check_type (3, rs,
14231     N_EQK, N_EQK, N_8 | N_16 | N_32 | N_KEY);
14232   neon_three_same (neon_quad (rs), 0, et.size);
14233 }
14234
14235 /* VMUL with 3 registers allows the P8 type. The scalar version supports the
14236    same types as the MAC equivalents. The polynomial type for this instruction
14237    is encoded the same as the integer type.  */
14238
14239 static void
14240 do_neon_mul (void)
14241 {
14242   if (try_vfp_nsyn (3, do_vfp_nsyn_mul) == SUCCESS)
14243     return;
14244
14245   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14246     return;
14247
14248   if (inst.operands[2].isscalar)
14249     do_neon_mac_maybe_scalar ();
14250   else
14251     neon_dyadic_misc (NT_poly, N_I8 | N_I16 | N_I32 | N_F32 | N_P8, 0);
14252 }
14253
14254 static void
14255 do_neon_qdmulh (void)
14256 {
14257   if (inst.operands[2].isscalar)
14258     {
14259       enum neon_shape rs = neon_select_shape (NS_DDS, NS_QQS, NS_NULL);
14260       struct neon_type_el et = neon_check_type (3, rs,
14261         N_EQK, N_EQK, N_S16 | N_S32 | N_KEY);
14262       NEON_ENCODE (SCALAR, inst);
14263       neon_mul_mac (et, neon_quad (rs));
14264     }
14265   else
14266     {
14267       enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14268       struct neon_type_el et = neon_check_type (3, rs,
14269         N_EQK, N_EQK, N_S16 | N_S32 | N_KEY);
14270       NEON_ENCODE (INTEGER, inst);
14271       /* The U bit (rounding) comes from bit mask.  */
14272       neon_three_same (neon_quad (rs), 0, et.size);
14273     }
14274 }
14275
14276 static void
14277 do_neon_fcmp_absolute (void)
14278 {
14279   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14280   neon_check_type (3, rs, N_EQK, N_EQK, N_F32 | N_KEY);
14281   /* Size field comes from bit mask.  */
14282   neon_three_same (neon_quad (rs), 1, -1);
14283 }
14284
14285 static void
14286 do_neon_fcmp_absolute_inv (void)
14287 {
14288   neon_exchange_operands ();
14289   do_neon_fcmp_absolute ();
14290 }
14291
14292 static void
14293 do_neon_step (void)
14294 {
14295   enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14296   neon_check_type (3, rs, N_EQK, N_EQK, N_F32 | N_KEY);
14297   neon_three_same (neon_quad (rs), 0, -1);
14298 }
14299
14300 static void
14301 do_neon_abs_neg (void)
14302 {
14303   enum neon_shape rs;
14304   struct neon_type_el et;
14305
14306   if (try_vfp_nsyn (2, do_vfp_nsyn_abs_neg) == SUCCESS)
14307     return;
14308
14309   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14310     return;
14311
14312   rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
14313   et = neon_check_type (2, rs, N_EQK, N_S8 | N_S16 | N_S32 | N_F32 | N_KEY);
14314
14315   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14316   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14317   inst.instruction |= LOW4 (inst.operands[1].reg);
14318   inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14319   inst.instruction |= neon_quad (rs) << 6;
14320   inst.instruction |= (et.type == NT_float) << 10;
14321   inst.instruction |= neon_logbits (et.size) << 18;
14322
14323   neon_dp_fixup (&inst);
14324 }
14325
14326 static void
14327 do_neon_sli (void)
14328 {
14329   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14330   struct neon_type_el et = neon_check_type (2, rs,
14331     N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
14332   int imm = inst.operands[2].imm;
14333   constraint (imm < 0 || (unsigned)imm >= et.size,
14334               _("immediate out of range for insert"));
14335   neon_imm_shift (FALSE, 0, neon_quad (rs), et, imm);
14336 }
14337
14338 static void
14339 do_neon_sri (void)
14340 {
14341   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14342   struct neon_type_el et = neon_check_type (2, rs,
14343     N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
14344   int imm = inst.operands[2].imm;
14345   constraint (imm < 1 || (unsigned)imm > et.size,
14346               _("immediate out of range for insert"));
14347   neon_imm_shift (FALSE, 0, neon_quad (rs), et, et.size - imm);
14348 }
14349
14350 static void
14351 do_neon_qshlu_imm (void)
14352 {
14353   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14354   struct neon_type_el et = neon_check_type (2, rs,
14355     N_EQK | N_UNS, N_S8 | N_S16 | N_S32 | N_S64 | N_KEY);
14356   int imm = inst.operands[2].imm;
14357   constraint (imm < 0 || (unsigned)imm >= et.size,
14358               _("immediate out of range for shift"));
14359   /* Only encodes the 'U present' variant of the instruction.
14360      In this case, signed types have OP (bit 8) set to 0.
14361      Unsigned types have OP set to 1.  */
14362   inst.instruction |= (et.type == NT_unsigned) << 8;
14363   /* The rest of the bits are the same as other immediate shifts.  */
14364   neon_imm_shift (FALSE, 0, neon_quad (rs), et, imm);
14365 }
14366
14367 static void
14368 do_neon_qmovn (void)
14369 {
14370   struct neon_type_el et = neon_check_type (2, NS_DQ,
14371     N_EQK | N_HLF, N_SU_16_64 | N_KEY);
14372   /* Saturating move where operands can be signed or unsigned, and the
14373      destination has the same signedness.  */
14374   NEON_ENCODE (INTEGER, inst);
14375   if (et.type == NT_unsigned)
14376     inst.instruction |= 0xc0;
14377   else
14378     inst.instruction |= 0x80;
14379   neon_two_same (0, 1, et.size / 2);
14380 }
14381
14382 static void
14383 do_neon_qmovun (void)
14384 {
14385   struct neon_type_el et = neon_check_type (2, NS_DQ,
14386     N_EQK | N_HLF | N_UNS, N_S16 | N_S32 | N_S64 | N_KEY);
14387   /* Saturating move with unsigned results. Operands must be signed.  */
14388   NEON_ENCODE (INTEGER, inst);
14389   neon_two_same (0, 1, et.size / 2);
14390 }
14391
14392 static void
14393 do_neon_rshift_sat_narrow (void)
14394 {
14395   /* FIXME: Types for narrowing. If operands are signed, results can be signed
14396      or unsigned. If operands are unsigned, results must also be unsigned.  */
14397   struct neon_type_el et = neon_check_type (2, NS_DQI,
14398     N_EQK | N_HLF, N_SU_16_64 | N_KEY);
14399   int imm = inst.operands[2].imm;
14400   /* This gets the bounds check, size encoding and immediate bits calculation
14401      right.  */
14402   et.size /= 2;
14403
14404   /* VQ{R}SHRN.I<size> <Dd>, <Qm>, #0 is a synonym for
14405      VQMOVN.I<size> <Dd>, <Qm>.  */
14406   if (imm == 0)
14407     {
14408       inst.operands[2].present = 0;
14409       inst.instruction = N_MNEM_vqmovn;
14410       do_neon_qmovn ();
14411       return;
14412     }
14413
14414   constraint (imm < 1 || (unsigned)imm > et.size,
14415               _("immediate out of range"));
14416   neon_imm_shift (TRUE, et.type == NT_unsigned, 0, et, et.size - imm);
14417 }
14418
14419 static void
14420 do_neon_rshift_sat_narrow_u (void)
14421 {
14422   /* FIXME: Types for narrowing. If operands are signed, results can be signed
14423      or unsigned. If operands are unsigned, results must also be unsigned.  */
14424   struct neon_type_el et = neon_check_type (2, NS_DQI,
14425     N_EQK | N_HLF | N_UNS, N_S16 | N_S32 | N_S64 | N_KEY);
14426   int imm = inst.operands[2].imm;
14427   /* This gets the bounds check, size encoding and immediate bits calculation
14428      right.  */
14429   et.size /= 2;
14430
14431   /* VQSHRUN.I<size> <Dd>, <Qm>, #0 is a synonym for
14432      VQMOVUN.I<size> <Dd>, <Qm>.  */
14433   if (imm == 0)
14434     {
14435       inst.operands[2].present = 0;
14436       inst.instruction = N_MNEM_vqmovun;
14437       do_neon_qmovun ();
14438       return;
14439     }
14440
14441   constraint (imm < 1 || (unsigned)imm > et.size,
14442               _("immediate out of range"));
14443   /* FIXME: The manual is kind of unclear about what value U should have in
14444      VQ{R}SHRUN instructions, but U=0, op=0 definitely encodes VRSHR, so it
14445      must be 1.  */
14446   neon_imm_shift (TRUE, 1, 0, et, et.size - imm);
14447 }
14448
14449 static void
14450 do_neon_movn (void)
14451 {
14452   struct neon_type_el et = neon_check_type (2, NS_DQ,
14453     N_EQK | N_HLF, N_I16 | N_I32 | N_I64 | N_KEY);
14454   NEON_ENCODE (INTEGER, inst);
14455   neon_two_same (0, 1, et.size / 2);
14456 }
14457
14458 static void
14459 do_neon_rshift_narrow (void)
14460 {
14461   struct neon_type_el et = neon_check_type (2, NS_DQI,
14462     N_EQK | N_HLF, N_I16 | N_I32 | N_I64 | N_KEY);
14463   int imm = inst.operands[2].imm;
14464   /* This gets the bounds check, size encoding and immediate bits calculation
14465      right.  */
14466   et.size /= 2;
14467
14468   /* If immediate is zero then we are a pseudo-instruction for
14469      VMOVN.I<size> <Dd>, <Qm>  */
14470   if (imm == 0)
14471     {
14472       inst.operands[2].present = 0;
14473       inst.instruction = N_MNEM_vmovn;
14474       do_neon_movn ();
14475       return;
14476     }
14477
14478   constraint (imm < 1 || (unsigned)imm > et.size,
14479               _("immediate out of range for narrowing operation"));
14480   neon_imm_shift (FALSE, 0, 0, et, et.size - imm);
14481 }
14482
14483 static void
14484 do_neon_shll (void)
14485 {
14486   /* FIXME: Type checking when lengthening.  */
14487   struct neon_type_el et = neon_check_type (2, NS_QDI,
14488     N_EQK | N_DBL, N_I8 | N_I16 | N_I32 | N_KEY);
14489   unsigned imm = inst.operands[2].imm;
14490
14491   if (imm == et.size)
14492     {
14493       /* Maximum shift variant.  */
14494       NEON_ENCODE (INTEGER, inst);
14495       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14496       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14497       inst.instruction |= LOW4 (inst.operands[1].reg);
14498       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14499       inst.instruction |= neon_logbits (et.size) << 18;
14500
14501       neon_dp_fixup (&inst);
14502     }
14503   else
14504     {
14505       /* A more-specific type check for non-max versions.  */
14506       et = neon_check_type (2, NS_QDI,
14507         N_EQK | N_DBL, N_SU_32 | N_KEY);
14508       NEON_ENCODE (IMMED, inst);
14509       neon_imm_shift (TRUE, et.type == NT_unsigned, 0, et, imm);
14510     }
14511 }
14512
14513 /* Check the various types for the VCVT instruction, and return which version
14514    the current instruction is.  */
14515
14516 #define CVT_FLAVOUR_VAR                                                       \
14517   CVT_VAR (s32_f32, N_S32, N_F32, whole_reg,   "ftosls", "ftosis", "ftosizs") \
14518   CVT_VAR (u32_f32, N_U32, N_F32, whole_reg,   "ftouls", "ftouis", "ftouizs") \
14519   CVT_VAR (f32_s32, N_F32, N_S32, whole_reg,   "fsltos", "fsitos", NULL)      \
14520   CVT_VAR (f32_u32, N_F32, N_U32, whole_reg,   "fultos", "fuitos", NULL)      \
14521   /* Half-precision conversions.  */                                          \
14522   CVT_VAR (f32_f16, N_F32, N_F16, whole_reg,   NULL,     NULL,     NULL)      \
14523   CVT_VAR (f16_f32, N_F16, N_F32, whole_reg,   NULL,     NULL,     NULL)      \
14524   /* VFP instructions.  */                                                    \
14525   CVT_VAR (f32_f64, N_F32, N_F64, N_VFP,       NULL,     "fcvtsd", NULL)      \
14526   CVT_VAR (f64_f32, N_F64, N_F32, N_VFP,       NULL,     "fcvtds", NULL)      \
14527   CVT_VAR (s32_f64, N_S32, N_F64 | key, N_VFP, "ftosld", "ftosid", "ftosizd") \
14528   CVT_VAR (u32_f64, N_U32, N_F64 | key, N_VFP, "ftould", "ftouid", "ftouizd") \
14529   CVT_VAR (f64_s32, N_F64 | key, N_S32, N_VFP, "fsltod", "fsitod", NULL)      \
14530   CVT_VAR (f64_u32, N_F64 | key, N_U32, N_VFP, "fultod", "fuitod", NULL)      \
14531   /* VFP instructions with bitshift.  */                                      \
14532   CVT_VAR (f32_s16, N_F32 | key, N_S16, N_VFP, "fshtos", NULL,     NULL)      \
14533   CVT_VAR (f32_u16, N_F32 | key, N_U16, N_VFP, "fuhtos", NULL,     NULL)      \
14534   CVT_VAR (f64_s16, N_F64 | key, N_S16, N_VFP, "fshtod", NULL,     NULL)      \
14535   CVT_VAR (f64_u16, N_F64 | key, N_U16, N_VFP, "fuhtod", NULL,     NULL)      \
14536   CVT_VAR (s16_f32, N_S16, N_F32 | key, N_VFP, "ftoshs", NULL,     NULL)      \
14537   CVT_VAR (u16_f32, N_U16, N_F32 | key, N_VFP, "ftouhs", NULL,     NULL)      \
14538   CVT_VAR (s16_f64, N_S16, N_F64 | key, N_VFP, "ftoshd", NULL,     NULL)      \
14539   CVT_VAR (u16_f64, N_U16, N_F64 | key, N_VFP, "ftouhd", NULL,     NULL)
14540
14541 #define CVT_VAR(C, X, Y, R, BSN, CN, ZN) \
14542   neon_cvt_flavour_##C,
14543
14544 /* The different types of conversions we can do.  */
14545 enum neon_cvt_flavour
14546 {
14547   CVT_FLAVOUR_VAR
14548   neon_cvt_flavour_invalid,
14549   neon_cvt_flavour_first_fp = neon_cvt_flavour_f32_f64
14550 };
14551
14552 #undef CVT_VAR
14553
14554 static enum neon_cvt_flavour
14555 get_neon_cvt_flavour (enum neon_shape rs)
14556 {
14557 #define CVT_VAR(C,X,Y,R,BSN,CN,ZN)                      \
14558   et = neon_check_type (2, rs, (R) | (X), (R) | (Y));   \
14559   if (et.type != NT_invtype)                            \
14560     {                                                   \
14561       inst.error = NULL;                                \
14562       return (neon_cvt_flavour_##C);                    \
14563     }
14564
14565   struct neon_type_el et;
14566   unsigned whole_reg = (rs == NS_FFI || rs == NS_FD || rs == NS_DF
14567                         || rs == NS_FF) ? N_VFP : 0;
14568   /* The instruction versions which take an immediate take one register
14569      argument, which is extended to the width of the full register. Thus the
14570      "source" and "destination" registers must have the same width.  Hack that
14571      here by making the size equal to the key (wider, in this case) operand.  */
14572   unsigned key = (rs == NS_QQI || rs == NS_DDI || rs == NS_FFI) ? N_KEY : 0;
14573
14574   CVT_FLAVOUR_VAR;
14575
14576   return neon_cvt_flavour_invalid;
14577 #undef CVT_VAR
14578 }
14579
14580 enum neon_cvt_mode
14581 {
14582   neon_cvt_mode_a,
14583   neon_cvt_mode_n,
14584   neon_cvt_mode_p,
14585   neon_cvt_mode_m,
14586   neon_cvt_mode_z,
14587   neon_cvt_mode_x,
14588   neon_cvt_mode_r
14589 };
14590
14591 /* Neon-syntax VFP conversions.  */
14592
14593 static void
14594 do_vfp_nsyn_cvt (enum neon_shape rs, enum neon_cvt_flavour flavour)
14595 {
14596   const char *opname = 0;
14597
14598   if (rs == NS_DDI || rs == NS_QQI || rs == NS_FFI)
14599     {
14600       /* Conversions with immediate bitshift.  */
14601       const char *enc[] =
14602         {
14603 #define CVT_VAR(C,A,B,R,BSN,CN,ZN) BSN,
14604           CVT_FLAVOUR_VAR
14605           NULL
14606 #undef CVT_VAR
14607         };
14608
14609       if (flavour < (int) ARRAY_SIZE (enc))
14610         {
14611           opname = enc[flavour];
14612           constraint (inst.operands[0].reg != inst.operands[1].reg,
14613                       _("operands 0 and 1 must be the same register"));
14614           inst.operands[1] = inst.operands[2];
14615           memset (&inst.operands[2], '\0', sizeof (inst.operands[2]));
14616         }
14617     }
14618   else
14619     {
14620       /* Conversions without bitshift.  */
14621       const char *enc[] =
14622         {
14623 #define CVT_VAR(C,A,B,R,BSN,CN,ZN) CN,
14624           CVT_FLAVOUR_VAR
14625           NULL
14626 #undef CVT_VAR
14627         };
14628
14629       if (flavour < (int) ARRAY_SIZE (enc))
14630         opname = enc[flavour];
14631     }
14632
14633   if (opname)
14634     do_vfp_nsyn_opcode (opname);
14635 }
14636
14637 static void
14638 do_vfp_nsyn_cvtz (void)
14639 {
14640   enum neon_shape rs = neon_select_shape (NS_FF, NS_FD, NS_NULL);
14641   enum neon_cvt_flavour flavour = get_neon_cvt_flavour (rs);
14642   const char *enc[] =
14643     {
14644 #define CVT_VAR(C,A,B,R,BSN,CN,ZN) ZN,
14645       CVT_FLAVOUR_VAR
14646       NULL
14647 #undef CVT_VAR
14648     };
14649
14650   if (flavour < (int) ARRAY_SIZE (enc) && enc[flavour])
14651     do_vfp_nsyn_opcode (enc[flavour]);
14652 }
14653
14654 static void
14655 do_vfp_nsyn_cvt_fpv8 (enum neon_cvt_flavour flavour, 
14656                       enum neon_cvt_mode mode)
14657 {
14658   int sz, op;
14659   int rm;
14660
14661   set_it_insn_type (OUTSIDE_IT_INSN);
14662
14663   switch (flavour)
14664     {
14665     case neon_cvt_flavour_s32_f64:
14666       sz = 1;
14667       op = 0;
14668       break;
14669     case neon_cvt_flavour_s32_f32:
14670       sz = 0;
14671       op = 1;
14672       break;
14673     case neon_cvt_flavour_u32_f64:
14674       sz = 1;
14675       op = 0;
14676       break;
14677     case neon_cvt_flavour_u32_f32:
14678       sz = 0;
14679       op = 0;
14680       break;
14681     default:
14682       first_error (_("invalid instruction shape"));
14683       return;
14684     }
14685
14686   switch (mode)
14687     {
14688     case neon_cvt_mode_a: rm = 0; break;
14689     case neon_cvt_mode_n: rm = 1; break;
14690     case neon_cvt_mode_p: rm = 2; break;
14691     case neon_cvt_mode_m: rm = 3; break;
14692     default: first_error (_("invalid rounding mode")); return;
14693     }
14694
14695   NEON_ENCODE (FPV8, inst);
14696   encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
14697   encode_arm_vfp_reg (inst.operands[1].reg, sz == 1 ? VFP_REG_Dm : VFP_REG_Sm);
14698   inst.instruction |= sz << 8;
14699   inst.instruction |= op << 7;
14700   inst.instruction |= rm << 16;
14701   inst.instruction |= 0xf0000000;
14702   inst.is_neon = TRUE;
14703 }
14704
14705 static void
14706 do_neon_cvt_1 (enum neon_cvt_mode mode)
14707 {
14708   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_FFI, NS_DD, NS_QQ,
14709     NS_FD, NS_DF, NS_FF, NS_QD, NS_DQ, NS_NULL);
14710   enum neon_cvt_flavour flavour = get_neon_cvt_flavour (rs);
14711
14712   /* PR11109: Handle round-to-zero for VCVT conversions.  */
14713   if (mode == neon_cvt_mode_z
14714       && ARM_CPU_HAS_FEATURE (cpu_variant, fpu_arch_vfp_v2)
14715       && (flavour == neon_cvt_flavour_s32_f32 
14716           || flavour == neon_cvt_flavour_u32_f32 
14717           || flavour == neon_cvt_flavour_s32_f64 
14718           || flavour == neon_cvt_flavour_u32_f64)
14719       && (rs == NS_FD || rs == NS_FF))
14720     {
14721       do_vfp_nsyn_cvtz ();
14722       return;
14723     }
14724
14725   /* VFP rather than Neon conversions.  */
14726   if (flavour >= neon_cvt_flavour_first_fp)
14727     {
14728       if (mode == neon_cvt_mode_x || mode == neon_cvt_mode_z)
14729         do_vfp_nsyn_cvt (rs, flavour);
14730       else
14731         do_vfp_nsyn_cvt_fpv8 (flavour, mode);
14732
14733       return;
14734     }
14735
14736   switch (rs)
14737     {
14738     case NS_DDI:
14739     case NS_QQI:
14740       {
14741         unsigned immbits;
14742         unsigned enctab[] = { 0x0000100, 0x1000100, 0x0, 0x1000000 };
14743
14744         if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14745           return;
14746
14747         /* Fixed-point conversion with #0 immediate is encoded as an
14748            integer conversion.  */
14749         if (inst.operands[2].present && inst.operands[2].imm == 0)
14750           goto int_encode;
14751        immbits = 32 - inst.operands[2].imm;
14752         NEON_ENCODE (IMMED, inst);
14753         if (flavour != neon_cvt_flavour_invalid)
14754           inst.instruction |= enctab[flavour];
14755         inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14756         inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14757         inst.instruction |= LOW4 (inst.operands[1].reg);
14758         inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14759         inst.instruction |= neon_quad (rs) << 6;
14760         inst.instruction |= 1 << 21;
14761         inst.instruction |= immbits << 16;
14762
14763         neon_dp_fixup (&inst);
14764       }
14765       break;
14766
14767     case NS_DD:
14768     case NS_QQ:
14769       if (mode != neon_cvt_mode_x && mode != neon_cvt_mode_z)
14770         {
14771           NEON_ENCODE (FLOAT, inst);
14772           set_it_insn_type (OUTSIDE_IT_INSN);
14773
14774           if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH8) == FAIL)
14775             return;
14776
14777           inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14778           inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14779           inst.instruction |= LOW4 (inst.operands[1].reg);
14780           inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14781           inst.instruction |= neon_quad (rs) << 6;
14782           inst.instruction |= (flavour == neon_cvt_flavour_u32_f32) << 7;
14783           inst.instruction |= mode << 8;
14784           if (thumb_mode)
14785             inst.instruction |= 0xfc000000;
14786           else
14787             inst.instruction |= 0xf0000000;
14788         }
14789       else
14790         {
14791     int_encode:
14792           {
14793             unsigned enctab[] = { 0x100, 0x180, 0x0, 0x080 };
14794
14795             NEON_ENCODE (INTEGER, inst);
14796
14797             if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14798               return;
14799
14800             if (flavour != neon_cvt_flavour_invalid)
14801               inst.instruction |= enctab[flavour];
14802
14803             inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14804             inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14805             inst.instruction |= LOW4 (inst.operands[1].reg);
14806             inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14807             inst.instruction |= neon_quad (rs) << 6;
14808             inst.instruction |= 2 << 18;
14809
14810             neon_dp_fixup (&inst);
14811           }
14812         }
14813       break;
14814
14815     /* Half-precision conversions for Advanced SIMD -- neon.  */
14816     case NS_QD:
14817     case NS_DQ:
14818
14819       if ((rs == NS_DQ)
14820           && (inst.vectype.el[0].size != 16 || inst.vectype.el[1].size != 32))
14821           {
14822             as_bad (_("operand size must match register width"));
14823             break;
14824           }
14825
14826       if ((rs == NS_QD)
14827           && ((inst.vectype.el[0].size != 32 || inst.vectype.el[1].size != 16)))
14828           {
14829             as_bad (_("operand size must match register width"));
14830             break;
14831           }
14832
14833       if (rs == NS_DQ)
14834         inst.instruction = 0x3b60600;
14835       else
14836         inst.instruction = 0x3b60700;
14837
14838       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14839       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14840       inst.instruction |= LOW4 (inst.operands[1].reg);
14841       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14842       neon_dp_fixup (&inst);
14843       break;
14844
14845     default:
14846       /* Some VFP conversions go here (s32 <-> f32, u32 <-> f32).  */
14847       if (mode == neon_cvt_mode_x || mode == neon_cvt_mode_z)
14848         do_vfp_nsyn_cvt (rs, flavour);
14849       else
14850         do_vfp_nsyn_cvt_fpv8 (flavour, mode);
14851     }
14852 }
14853
14854 static void
14855 do_neon_cvtr (void)
14856 {
14857   do_neon_cvt_1 (neon_cvt_mode_x);
14858 }
14859
14860 static void
14861 do_neon_cvt (void)
14862 {
14863   do_neon_cvt_1 (neon_cvt_mode_z);
14864 }
14865
14866 static void
14867 do_neon_cvta (void)
14868 {
14869   do_neon_cvt_1 (neon_cvt_mode_a);
14870 }
14871
14872 static void
14873 do_neon_cvtn (void)
14874 {
14875   do_neon_cvt_1 (neon_cvt_mode_n);
14876 }
14877
14878 static void
14879 do_neon_cvtp (void)
14880 {
14881   do_neon_cvt_1 (neon_cvt_mode_p);
14882 }
14883
14884 static void
14885 do_neon_cvtm (void)
14886 {
14887   do_neon_cvt_1 (neon_cvt_mode_m);
14888 }
14889
14890 static void
14891 do_neon_cvttb_2 (bfd_boolean t, bfd_boolean to, bfd_boolean is_double)
14892 {
14893   if (is_double)
14894     mark_feature_used (&fpu_vfp_ext_armv8);
14895
14896   encode_arm_vfp_reg (inst.operands[0].reg,
14897                       (is_double && !to) ? VFP_REG_Dd : VFP_REG_Sd);
14898   encode_arm_vfp_reg (inst.operands[1].reg,
14899                       (is_double && to) ? VFP_REG_Dm : VFP_REG_Sm);
14900   inst.instruction |= to ? 0x10000 : 0;
14901   inst.instruction |= t ? 0x80 : 0;
14902   inst.instruction |= is_double ? 0x100 : 0;
14903   do_vfp_cond_or_thumb ();
14904 }
14905
14906 static void
14907 do_neon_cvttb_1 (bfd_boolean t)
14908 {
14909   enum neon_shape rs = neon_select_shape (NS_FF, NS_FD, NS_DF, NS_NULL);
14910
14911   if (rs == NS_NULL)
14912     return;
14913   else if (neon_check_type (2, rs, N_F16, N_F32 | N_VFP).type != NT_invtype)
14914     {
14915       inst.error = NULL;
14916       do_neon_cvttb_2 (t, /*to=*/TRUE, /*is_double=*/FALSE);
14917     }
14918   else if (neon_check_type (2, rs, N_F32 | N_VFP, N_F16).type != NT_invtype)
14919     {
14920       inst.error = NULL;
14921       do_neon_cvttb_2 (t, /*to=*/FALSE, /*is_double=*/FALSE);
14922     }
14923   else if (neon_check_type (2, rs, N_F16, N_F64 | N_VFP).type != NT_invtype)
14924     {
14925       inst.error = NULL;
14926       do_neon_cvttb_2 (t, /*to=*/TRUE, /*is_double=*/TRUE);
14927     }
14928   else if (neon_check_type (2, rs, N_F64 | N_VFP, N_F16).type != NT_invtype)
14929     {
14930       inst.error = NULL;
14931       do_neon_cvttb_2 (t, /*to=*/FALSE, /*is_double=*/TRUE);
14932     }
14933   else
14934     return;
14935 }
14936
14937 static void
14938 do_neon_cvtb (void)
14939 {
14940   do_neon_cvttb_1 (FALSE);
14941 }
14942
14943
14944 static void
14945 do_neon_cvtt (void)
14946 {
14947   do_neon_cvttb_1 (TRUE);
14948 }
14949
14950 static void
14951 neon_move_immediate (void)
14952 {
14953   enum neon_shape rs = neon_select_shape (NS_DI, NS_QI, NS_NULL);
14954   struct neon_type_el et = neon_check_type (2, rs,
14955     N_I8 | N_I16 | N_I32 | N_I64 | N_F32 | N_KEY, N_EQK);
14956   unsigned immlo, immhi = 0, immbits;
14957   int op, cmode, float_p;
14958
14959   constraint (et.type == NT_invtype,
14960               _("operand size must be specified for immediate VMOV"));
14961
14962   /* We start out as an MVN instruction if OP = 1, MOV otherwise.  */
14963   op = (inst.instruction & (1 << 5)) != 0;
14964
14965   immlo = inst.operands[1].imm;
14966   if (inst.operands[1].regisimm)
14967     immhi = inst.operands[1].reg;
14968
14969   constraint (et.size < 32 && (immlo & ~((1 << et.size) - 1)) != 0,
14970               _("immediate has bits set outside the operand size"));
14971
14972   float_p = inst.operands[1].immisfloat;
14973
14974   if ((cmode = neon_cmode_for_move_imm (immlo, immhi, float_p, &immbits, &op,
14975                                         et.size, et.type)) == FAIL)
14976     {
14977       /* Invert relevant bits only.  */
14978       neon_invert_size (&immlo, &immhi, et.size);
14979       /* Flip from VMOV/VMVN to VMVN/VMOV. Some immediate types are unavailable
14980          with one or the other; those cases are caught by
14981          neon_cmode_for_move_imm.  */
14982       op = !op;
14983       if ((cmode = neon_cmode_for_move_imm (immlo, immhi, float_p, &immbits,
14984                                             &op, et.size, et.type)) == FAIL)
14985         {
14986           first_error (_("immediate out of range"));
14987           return;
14988         }
14989     }
14990
14991   inst.instruction &= ~(1 << 5);
14992   inst.instruction |= op << 5;
14993
14994   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14995   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14996   inst.instruction |= neon_quad (rs) << 6;
14997   inst.instruction |= cmode << 8;
14998
14999   neon_write_immbits (immbits);
15000 }
15001
15002 static void
15003 do_neon_mvn (void)
15004 {
15005   if (inst.operands[1].isreg)
15006     {
15007       enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15008
15009       NEON_ENCODE (INTEGER, inst);
15010       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15011       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15012       inst.instruction |= LOW4 (inst.operands[1].reg);
15013       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15014       inst.instruction |= neon_quad (rs) << 6;
15015     }
15016   else
15017     {
15018       NEON_ENCODE (IMMED, inst);
15019       neon_move_immediate ();
15020     }
15021
15022   neon_dp_fixup (&inst);
15023 }
15024
15025 /* Encode instructions of form:
15026
15027   |28/24|23|22|21 20|19 16|15 12|11    8|7|6|5|4|3  0|
15028   |  U  |x |D |size | Rn  | Rd  |x x x x|N|x|M|x| Rm |  */
15029
15030 static void
15031 neon_mixed_length (struct neon_type_el et, unsigned size)
15032 {
15033   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15034   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15035   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15036   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15037   inst.instruction |= LOW4 (inst.operands[2].reg);
15038   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
15039   inst.instruction |= (et.type == NT_unsigned) << 24;
15040   inst.instruction |= neon_logbits (size) << 20;
15041
15042   neon_dp_fixup (&inst);
15043 }
15044
15045 static void
15046 do_neon_dyadic_long (void)
15047 {
15048   /* FIXME: Type checking for lengthening op.  */
15049   struct neon_type_el et = neon_check_type (3, NS_QDD,
15050     N_EQK | N_DBL, N_EQK, N_SU_32 | N_KEY);
15051   neon_mixed_length (et, et.size);
15052 }
15053
15054 static void
15055 do_neon_abal (void)
15056 {
15057   struct neon_type_el et = neon_check_type (3, NS_QDD,
15058     N_EQK | N_INT | N_DBL, N_EQK, N_SU_32 | N_KEY);
15059   neon_mixed_length (et, et.size);
15060 }
15061
15062 static void
15063 neon_mac_reg_scalar_long (unsigned regtypes, unsigned scalartypes)
15064 {
15065   if (inst.operands[2].isscalar)
15066     {
15067       struct neon_type_el et = neon_check_type (3, NS_QDS,
15068         N_EQK | N_DBL, N_EQK, regtypes | N_KEY);
15069       NEON_ENCODE (SCALAR, inst);
15070       neon_mul_mac (et, et.type == NT_unsigned);
15071     }
15072   else
15073     {
15074       struct neon_type_el et = neon_check_type (3, NS_QDD,
15075         N_EQK | N_DBL, N_EQK, scalartypes | N_KEY);
15076       NEON_ENCODE (INTEGER, inst);
15077       neon_mixed_length (et, et.size);
15078     }
15079 }
15080
15081 static void
15082 do_neon_mac_maybe_scalar_long (void)
15083 {
15084   neon_mac_reg_scalar_long (N_S16 | N_S32 | N_U16 | N_U32, N_SU_32);
15085 }
15086
15087 static void
15088 do_neon_dyadic_wide (void)
15089 {
15090   struct neon_type_el et = neon_check_type (3, NS_QQD,
15091     N_EQK | N_DBL, N_EQK | N_DBL, N_SU_32 | N_KEY);
15092   neon_mixed_length (et, et.size);
15093 }
15094
15095 static void
15096 do_neon_dyadic_narrow (void)
15097 {
15098   struct neon_type_el et = neon_check_type (3, NS_QDD,
15099     N_EQK | N_DBL, N_EQK, N_I16 | N_I32 | N_I64 | N_KEY);
15100   /* Operand sign is unimportant, and the U bit is part of the opcode,
15101      so force the operand type to integer.  */
15102   et.type = NT_integer;
15103   neon_mixed_length (et, et.size / 2);
15104 }
15105
15106 static void
15107 do_neon_mul_sat_scalar_long (void)
15108 {
15109   neon_mac_reg_scalar_long (N_S16 | N_S32, N_S16 | N_S32);
15110 }
15111
15112 static void
15113 do_neon_vmull (void)
15114 {
15115   if (inst.operands[2].isscalar)
15116     do_neon_mac_maybe_scalar_long ();
15117   else
15118     {
15119       struct neon_type_el et = neon_check_type (3, NS_QDD,
15120         N_EQK | N_DBL, N_EQK, N_SU_32 | N_P8 | N_KEY);
15121       if (et.type == NT_poly)
15122         NEON_ENCODE (POLY, inst);
15123       else
15124         NEON_ENCODE (INTEGER, inst);
15125       /* For polynomial encoding, size field must be 0b00 and the U bit must be
15126          zero. Should be OK as-is.  */
15127       neon_mixed_length (et, et.size);
15128     }
15129 }
15130
15131 static void
15132 do_neon_ext (void)
15133 {
15134   enum neon_shape rs = neon_select_shape (NS_DDDI, NS_QQQI, NS_NULL);
15135   struct neon_type_el et = neon_check_type (3, rs,
15136     N_EQK, N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
15137   unsigned imm = (inst.operands[3].imm * et.size) / 8;
15138
15139   constraint (imm >= (unsigned) (neon_quad (rs) ? 16 : 8),
15140               _("shift out of range"));
15141   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15142   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15143   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15144   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15145   inst.instruction |= LOW4 (inst.operands[2].reg);
15146   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
15147   inst.instruction |= neon_quad (rs) << 6;
15148   inst.instruction |= imm << 8;
15149
15150   neon_dp_fixup (&inst);
15151 }
15152
15153 static void
15154 do_neon_rev (void)
15155 {
15156   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15157   struct neon_type_el et = neon_check_type (2, rs,
15158     N_EQK, N_8 | N_16 | N_32 | N_KEY);
15159   unsigned op = (inst.instruction >> 7) & 3;
15160   /* N (width of reversed regions) is encoded as part of the bitmask. We
15161      extract it here to check the elements to be reversed are smaller.
15162      Otherwise we'd get a reserved instruction.  */
15163   unsigned elsize = (op == 2) ? 16 : (op == 1) ? 32 : (op == 0) ? 64 : 0;
15164   gas_assert (elsize != 0);
15165   constraint (et.size >= elsize,
15166               _("elements must be smaller than reversal region"));
15167   neon_two_same (neon_quad (rs), 1, et.size);
15168 }
15169
15170 static void
15171 do_neon_dup (void)
15172 {
15173   if (inst.operands[1].isscalar)
15174     {
15175       enum neon_shape rs = neon_select_shape (NS_DS, NS_QS, NS_NULL);
15176       struct neon_type_el et = neon_check_type (2, rs,
15177         N_EQK, N_8 | N_16 | N_32 | N_KEY);
15178       unsigned sizebits = et.size >> 3;
15179       unsigned dm = NEON_SCALAR_REG (inst.operands[1].reg);
15180       int logsize = neon_logbits (et.size);
15181       unsigned x = NEON_SCALAR_INDEX (inst.operands[1].reg) << logsize;
15182
15183       if (vfp_or_neon_is_neon (NEON_CHECK_CC) == FAIL)
15184         return;
15185
15186       NEON_ENCODE (SCALAR, inst);
15187       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15188       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15189       inst.instruction |= LOW4 (dm);
15190       inst.instruction |= HI1 (dm) << 5;
15191       inst.instruction |= neon_quad (rs) << 6;
15192       inst.instruction |= x << 17;
15193       inst.instruction |= sizebits << 16;
15194
15195       neon_dp_fixup (&inst);
15196     }
15197   else
15198     {
15199       enum neon_shape rs = neon_select_shape (NS_DR, NS_QR, NS_NULL);
15200       struct neon_type_el et = neon_check_type (2, rs,
15201         N_8 | N_16 | N_32 | N_KEY, N_EQK);
15202       /* Duplicate ARM register to lanes of vector.  */
15203       NEON_ENCODE (ARMREG, inst);
15204       switch (et.size)
15205         {
15206         case 8:  inst.instruction |= 0x400000; break;
15207         case 16: inst.instruction |= 0x000020; break;
15208         case 32: inst.instruction |= 0x000000; break;
15209         default: break;
15210         }
15211       inst.instruction |= LOW4 (inst.operands[1].reg) << 12;
15212       inst.instruction |= LOW4 (inst.operands[0].reg) << 16;
15213       inst.instruction |= HI1 (inst.operands[0].reg) << 7;
15214       inst.instruction |= neon_quad (rs) << 21;
15215       /* The encoding for this instruction is identical for the ARM and Thumb
15216          variants, except for the condition field.  */
15217       do_vfp_cond_or_thumb ();
15218     }
15219 }
15220
15221 /* VMOV has particularly many variations. It can be one of:
15222      0. VMOV<c><q> <Qd>, <Qm>
15223      1. VMOV<c><q> <Dd>, <Dm>
15224    (Register operations, which are VORR with Rm = Rn.)
15225      2. VMOV<c><q>.<dt> <Qd>, #<imm>
15226      3. VMOV<c><q>.<dt> <Dd>, #<imm>
15227    (Immediate loads.)
15228      4. VMOV<c><q>.<size> <Dn[x]>, <Rd>
15229    (ARM register to scalar.)
15230      5. VMOV<c><q> <Dm>, <Rd>, <Rn>
15231    (Two ARM registers to vector.)
15232      6. VMOV<c><q>.<dt> <Rd>, <Dn[x]>
15233    (Scalar to ARM register.)
15234      7. VMOV<c><q> <Rd>, <Rn>, <Dm>
15235    (Vector to two ARM registers.)
15236      8. VMOV.F32 <Sd>, <Sm>
15237      9. VMOV.F64 <Dd>, <Dm>
15238    (VFP register moves.)
15239     10. VMOV.F32 <Sd>, #imm
15240     11. VMOV.F64 <Dd>, #imm
15241    (VFP float immediate load.)
15242     12. VMOV <Rd>, <Sm>
15243    (VFP single to ARM reg.)
15244     13. VMOV <Sd>, <Rm>
15245    (ARM reg to VFP single.)
15246     14. VMOV <Rd>, <Re>, <Sn>, <Sm>
15247    (Two ARM regs to two VFP singles.)
15248     15. VMOV <Sd>, <Se>, <Rn>, <Rm>
15249    (Two VFP singles to two ARM regs.)
15250
15251    These cases can be disambiguated using neon_select_shape, except cases 1/9
15252    and 3/11 which depend on the operand type too.
15253
15254    All the encoded bits are hardcoded by this function.
15255
15256    Cases 4, 6 may be used with VFPv1 and above (only 32-bit transfers!).
15257    Cases 5, 7 may be used with VFPv2 and above.
15258
15259    FIXME: Some of the checking may be a bit sloppy (in a couple of cases you
15260    can specify a type where it doesn't make sense to, and is ignored).  */
15261
15262 static void
15263 do_neon_mov (void)
15264 {
15265   enum neon_shape rs = neon_select_shape (NS_RRFF, NS_FFRR, NS_DRR, NS_RRD,
15266     NS_QQ, NS_DD, NS_QI, NS_DI, NS_SR, NS_RS, NS_FF, NS_FI, NS_RF, NS_FR,
15267     NS_NULL);
15268   struct neon_type_el et;
15269   const char *ldconst = 0;
15270
15271   switch (rs)
15272     {
15273     case NS_DD:  /* case 1/9.  */
15274       et = neon_check_type (2, rs, N_EQK, N_F64 | N_KEY);
15275       /* It is not an error here if no type is given.  */
15276       inst.error = NULL;
15277       if (et.type == NT_float && et.size == 64)
15278         {
15279           do_vfp_nsyn_opcode ("fcpyd");
15280           break;
15281         }
15282       /* fall through.  */
15283
15284     case NS_QQ:  /* case 0/1.  */
15285       {
15286         if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15287           return;
15288         /* The architecture manual I have doesn't explicitly state which
15289            value the U bit should have for register->register moves, but
15290            the equivalent VORR instruction has U = 0, so do that.  */
15291         inst.instruction = 0x0200110;
15292         inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15293         inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15294         inst.instruction |= LOW4 (inst.operands[1].reg);
15295         inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15296         inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15297         inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15298         inst.instruction |= neon_quad (rs) << 6;
15299
15300         neon_dp_fixup (&inst);
15301       }
15302       break;
15303
15304     case NS_DI:  /* case 3/11.  */
15305       et = neon_check_type (2, rs, N_EQK, N_F64 | N_KEY);
15306       inst.error = NULL;
15307       if (et.type == NT_float && et.size == 64)
15308         {
15309           /* case 11 (fconstd).  */
15310           ldconst = "fconstd";
15311           goto encode_fconstd;
15312         }
15313       /* fall through.  */
15314
15315     case NS_QI:  /* case 2/3.  */
15316       if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15317         return;
15318       inst.instruction = 0x0800010;
15319       neon_move_immediate ();
15320       neon_dp_fixup (&inst);
15321       break;
15322
15323     case NS_SR:  /* case 4.  */
15324       {
15325         unsigned bcdebits = 0;
15326         int logsize;
15327         unsigned dn = NEON_SCALAR_REG (inst.operands[0].reg);
15328         unsigned x = NEON_SCALAR_INDEX (inst.operands[0].reg);
15329
15330         et = neon_check_type (2, NS_NULL, N_8 | N_16 | N_32 | N_KEY, N_EQK);
15331         logsize = neon_logbits (et.size);
15332
15333         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v1),
15334                     _(BAD_FPU));
15335         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_v1)
15336                     && et.size != 32, _(BAD_FPU));
15337         constraint (et.type == NT_invtype, _("bad type for scalar"));
15338         constraint (x >= 64 / et.size, _("scalar index out of range"));
15339
15340         switch (et.size)
15341           {
15342           case 8:  bcdebits = 0x8; break;
15343           case 16: bcdebits = 0x1; break;
15344           case 32: bcdebits = 0x0; break;
15345           default: ;
15346           }
15347
15348         bcdebits |= x << logsize;
15349
15350         inst.instruction = 0xe000b10;
15351         do_vfp_cond_or_thumb ();
15352         inst.instruction |= LOW4 (dn) << 16;
15353         inst.instruction |= HI1 (dn) << 7;
15354         inst.instruction |= inst.operands[1].reg << 12;
15355         inst.instruction |= (bcdebits & 3) << 5;
15356         inst.instruction |= (bcdebits >> 2) << 21;
15357       }
15358       break;
15359
15360     case NS_DRR:  /* case 5 (fmdrr).  */
15361       constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v2),
15362                   _(BAD_FPU));
15363
15364       inst.instruction = 0xc400b10;
15365       do_vfp_cond_or_thumb ();
15366       inst.instruction |= LOW4 (inst.operands[0].reg);
15367       inst.instruction |= HI1 (inst.operands[0].reg) << 5;
15368       inst.instruction |= inst.operands[1].reg << 12;
15369       inst.instruction |= inst.operands[2].reg << 16;
15370       break;
15371
15372     case NS_RS:  /* case 6.  */
15373       {
15374         unsigned logsize;
15375         unsigned dn = NEON_SCALAR_REG (inst.operands[1].reg);
15376         unsigned x = NEON_SCALAR_INDEX (inst.operands[1].reg);
15377         unsigned abcdebits = 0;
15378
15379         et = neon_check_type (2, NS_NULL,
15380                               N_EQK, N_S8 | N_S16 | N_U8 | N_U16 | N_32 | N_KEY);
15381         logsize = neon_logbits (et.size);
15382
15383         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v1),
15384                     _(BAD_FPU));
15385         constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_v1)
15386                     && et.size != 32, _(BAD_FPU));
15387         constraint (et.type == NT_invtype, _("bad type for scalar"));
15388         constraint (x >= 64 / et.size, _("scalar index out of range"));
15389
15390         switch (et.size)
15391           {
15392           case 8:  abcdebits = (et.type == NT_signed) ? 0x08 : 0x18; break;
15393           case 16: abcdebits = (et.type == NT_signed) ? 0x01 : 0x11; break;
15394           case 32: abcdebits = 0x00; break;
15395           default: ;
15396           }
15397
15398         abcdebits |= x << logsize;
15399         inst.instruction = 0xe100b10;
15400         do_vfp_cond_or_thumb ();
15401         inst.instruction |= LOW4 (dn) << 16;
15402         inst.instruction |= HI1 (dn) << 7;
15403         inst.instruction |= inst.operands[0].reg << 12;
15404         inst.instruction |= (abcdebits & 3) << 5;
15405         inst.instruction |= (abcdebits >> 2) << 21;
15406       }
15407       break;
15408
15409     case NS_RRD:  /* case 7 (fmrrd).  */
15410       constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v2),
15411                   _(BAD_FPU));
15412
15413       inst.instruction = 0xc500b10;
15414       do_vfp_cond_or_thumb ();
15415       inst.instruction |= inst.operands[0].reg << 12;
15416       inst.instruction |= inst.operands[1].reg << 16;
15417       inst.instruction |= LOW4 (inst.operands[2].reg);
15418       inst.instruction |= HI1 (inst.operands[2].reg) << 5;
15419       break;
15420
15421     case NS_FF:  /* case 8 (fcpys).  */
15422       do_vfp_nsyn_opcode ("fcpys");
15423       break;
15424
15425     case NS_FI:  /* case 10 (fconsts).  */
15426       ldconst = "fconsts";
15427       encode_fconstd:
15428       if (is_quarter_float (inst.operands[1].imm))
15429         {
15430           inst.operands[1].imm = neon_qfloat_bits (inst.operands[1].imm);
15431           do_vfp_nsyn_opcode (ldconst);
15432         }
15433       else
15434         first_error (_("immediate out of range"));
15435       break;
15436
15437     case NS_RF:  /* case 12 (fmrs).  */
15438       do_vfp_nsyn_opcode ("fmrs");
15439       break;
15440
15441     case NS_FR:  /* case 13 (fmsr).  */
15442       do_vfp_nsyn_opcode ("fmsr");
15443       break;
15444
15445     /* The encoders for the fmrrs and fmsrr instructions expect three operands
15446        (one of which is a list), but we have parsed four.  Do some fiddling to
15447        make the operands what do_vfp_reg2_from_sp2 and do_vfp_sp2_from_reg2
15448        expect.  */
15449     case NS_RRFF:  /* case 14 (fmrrs).  */
15450       constraint (inst.operands[3].reg != inst.operands[2].reg + 1,
15451                   _("VFP registers must be adjacent"));
15452       inst.operands[2].imm = 2;
15453       memset (&inst.operands[3], '\0', sizeof (inst.operands[3]));
15454       do_vfp_nsyn_opcode ("fmrrs");
15455       break;
15456
15457     case NS_FFRR:  /* case 15 (fmsrr).  */
15458       constraint (inst.operands[1].reg != inst.operands[0].reg + 1,
15459                   _("VFP registers must be adjacent"));
15460       inst.operands[1] = inst.operands[2];
15461       inst.operands[2] = inst.operands[3];
15462       inst.operands[0].imm = 2;
15463       memset (&inst.operands[3], '\0', sizeof (inst.operands[3]));
15464       do_vfp_nsyn_opcode ("fmsrr");
15465       break;
15466
15467     default:
15468       abort ();
15469     }
15470 }
15471
15472 static void
15473 do_neon_rshift_round_imm (void)
15474 {
15475   enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
15476   struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_ALL | N_KEY);
15477   int imm = inst.operands[2].imm;
15478
15479   /* imm == 0 case is encoded as VMOV for V{R}SHR.  */
15480   if (imm == 0)
15481     {
15482       inst.operands[2].present = 0;
15483       do_neon_mov ();
15484       return;
15485     }
15486
15487   constraint (imm < 1 || (unsigned)imm > et.size,
15488               _("immediate out of range for shift"));
15489   neon_imm_shift (TRUE, et.type == NT_unsigned, neon_quad (rs), et,
15490                   et.size - imm);
15491 }
15492
15493 static void
15494 do_neon_movl (void)
15495 {
15496   struct neon_type_el et = neon_check_type (2, NS_QD,
15497     N_EQK | N_DBL, N_SU_32 | N_KEY);
15498   unsigned sizebits = et.size >> 3;
15499   inst.instruction |= sizebits << 19;
15500   neon_two_same (0, et.type == NT_unsigned, -1);
15501 }
15502
15503 static void
15504 do_neon_trn (void)
15505 {
15506   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15507   struct neon_type_el et = neon_check_type (2, rs,
15508     N_EQK, N_8 | N_16 | N_32 | N_KEY);
15509   NEON_ENCODE (INTEGER, inst);
15510   neon_two_same (neon_quad (rs), 1, et.size);
15511 }
15512
15513 static void
15514 do_neon_zip_uzp (void)
15515 {
15516   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15517   struct neon_type_el et = neon_check_type (2, rs,
15518     N_EQK, N_8 | N_16 | N_32 | N_KEY);
15519   if (rs == NS_DD && et.size == 32)
15520     {
15521       /* Special case: encode as VTRN.32 <Dd>, <Dm>.  */
15522       inst.instruction = N_MNEM_vtrn;
15523       do_neon_trn ();
15524       return;
15525     }
15526   neon_two_same (neon_quad (rs), 1, et.size);
15527 }
15528
15529 static void
15530 do_neon_sat_abs_neg (void)
15531 {
15532   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15533   struct neon_type_el et = neon_check_type (2, rs,
15534     N_EQK, N_S8 | N_S16 | N_S32 | N_KEY);
15535   neon_two_same (neon_quad (rs), 1, et.size);
15536 }
15537
15538 static void
15539 do_neon_pair_long (void)
15540 {
15541   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15542   struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_32 | N_KEY);
15543   /* Unsigned is encoded in OP field (bit 7) for these instruction.  */
15544   inst.instruction |= (et.type == NT_unsigned) << 7;
15545   neon_two_same (neon_quad (rs), 1, et.size);
15546 }
15547
15548 static void
15549 do_neon_recip_est (void)
15550 {
15551   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15552   struct neon_type_el et = neon_check_type (2, rs,
15553     N_EQK | N_FLT, N_F32 | N_U32 | N_KEY);
15554   inst.instruction |= (et.type == NT_float) << 8;
15555   neon_two_same (neon_quad (rs), 1, et.size);
15556 }
15557
15558 static void
15559 do_neon_cls (void)
15560 {
15561   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15562   struct neon_type_el et = neon_check_type (2, rs,
15563     N_EQK, N_S8 | N_S16 | N_S32 | N_KEY);
15564   neon_two_same (neon_quad (rs), 1, et.size);
15565 }
15566
15567 static void
15568 do_neon_clz (void)
15569 {
15570   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15571   struct neon_type_el et = neon_check_type (2, rs,
15572     N_EQK, N_I8 | N_I16 | N_I32 | N_KEY);
15573   neon_two_same (neon_quad (rs), 1, et.size);
15574 }
15575
15576 static void
15577 do_neon_cnt (void)
15578 {
15579   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15580   struct neon_type_el et = neon_check_type (2, rs,
15581     N_EQK | N_INT, N_8 | N_KEY);
15582   neon_two_same (neon_quad (rs), 1, et.size);
15583 }
15584
15585 static void
15586 do_neon_swp (void)
15587 {
15588   enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15589   neon_two_same (neon_quad (rs), 1, -1);
15590 }
15591
15592 static void
15593 do_neon_tbl_tbx (void)
15594 {
15595   unsigned listlenbits;
15596   neon_check_type (3, NS_DLD, N_EQK, N_EQK, N_8 | N_KEY);
15597
15598   if (inst.operands[1].imm < 1 || inst.operands[1].imm > 4)
15599     {
15600       first_error (_("bad list length for table lookup"));
15601       return;
15602     }
15603
15604   listlenbits = inst.operands[1].imm - 1;
15605   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15606   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15607   inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15608   inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15609   inst.instruction |= LOW4 (inst.operands[2].reg);
15610   inst.instruction |= HI1 (inst.operands[2].reg) << 5;
15611   inst.instruction |= listlenbits << 8;
15612
15613   neon_dp_fixup (&inst);
15614 }
15615
15616 static void
15617 do_neon_ldm_stm (void)
15618 {
15619   /* P, U and L bits are part of bitmask.  */
15620   int is_dbmode = (inst.instruction & (1 << 24)) != 0;
15621   unsigned offsetbits = inst.operands[1].imm * 2;
15622
15623   if (inst.operands[1].issingle)
15624     {
15625       do_vfp_nsyn_ldm_stm (is_dbmode);
15626       return;
15627     }
15628
15629   constraint (is_dbmode && !inst.operands[0].writeback,
15630               _("writeback (!) must be used for VLDMDB and VSTMDB"));
15631
15632   constraint (inst.operands[1].imm < 1 || inst.operands[1].imm > 16,
15633               _("register list must contain at least 1 and at most 16 "
15634                 "registers"));
15635
15636   inst.instruction |= inst.operands[0].reg << 16;
15637   inst.instruction |= inst.operands[0].writeback << 21;
15638   inst.instruction |= LOW4 (inst.operands[1].reg) << 12;
15639   inst.instruction |= HI1 (inst.operands[1].reg) << 22;
15640
15641   inst.instruction |= offsetbits;
15642
15643   do_vfp_cond_or_thumb ();
15644 }
15645
15646 static void
15647 do_neon_ldr_str (void)
15648 {
15649   int is_ldr = (inst.instruction & (1 << 20)) != 0;
15650
15651   /* Use of PC in vstr in ARM mode is deprecated in ARMv7.
15652      And is UNPREDICTABLE in thumb mode.  */
15653   if (!is_ldr
15654       && inst.operands[1].reg == REG_PC
15655       && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v7))
15656     {
15657       if (!thumb_mode && warn_on_deprecated)
15658         as_warn (_("Use of PC here is deprecated"));
15659       else
15660         inst.error = _("Use of PC here is UNPREDICTABLE");
15661     }
15662
15663   if (inst.operands[0].issingle)
15664     {
15665       if (is_ldr)
15666         do_vfp_nsyn_opcode ("flds");
15667       else
15668         do_vfp_nsyn_opcode ("fsts");
15669     }
15670   else
15671     {
15672       if (is_ldr)
15673         do_vfp_nsyn_opcode ("fldd");
15674       else
15675         do_vfp_nsyn_opcode ("fstd");
15676     }
15677 }
15678
15679 /* "interleave" version also handles non-interleaving register VLD1/VST1
15680    instructions.  */
15681
15682 static void
15683 do_neon_ld_st_interleave (void)
15684 {
15685   struct neon_type_el et = neon_check_type (1, NS_NULL,
15686                                             N_8 | N_16 | N_32 | N_64);
15687   unsigned alignbits = 0;
15688   unsigned idx;
15689   /* The bits in this table go:
15690      0: register stride of one (0) or two (1)
15691      1,2: register list length, minus one (1, 2, 3, 4).
15692      3,4: <n> in instruction type, minus one (VLD<n> / VST<n>).
15693      We use -1 for invalid entries.  */
15694   const int typetable[] =
15695     {
15696       0x7,  -1, 0xa,  -1, 0x6,  -1, 0x2,  -1, /* VLD1 / VST1.  */
15697        -1,  -1, 0x8, 0x9,  -1,  -1, 0x3,  -1, /* VLD2 / VST2.  */
15698        -1,  -1,  -1,  -1, 0x4, 0x5,  -1,  -1, /* VLD3 / VST3.  */
15699        -1,  -1,  -1,  -1,  -1,  -1, 0x0, 0x1  /* VLD4 / VST4.  */
15700     };
15701   int typebits;
15702
15703   if (et.type == NT_invtype)
15704     return;
15705
15706   if (inst.operands[1].immisalign)
15707     switch (inst.operands[1].imm >> 8)
15708       {
15709       case 64: alignbits = 1; break;
15710       case 128:
15711         if (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 2
15712             && NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4)
15713           goto bad_alignment;
15714         alignbits = 2;
15715         break;
15716       case 256:
15717         if (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4)
15718           goto bad_alignment;
15719         alignbits = 3;
15720         break;
15721       default:
15722       bad_alignment:
15723         first_error (_("bad alignment"));
15724         return;
15725       }
15726
15727   inst.instruction |= alignbits << 4;
15728   inst.instruction |= neon_logbits (et.size) << 6;
15729
15730   /* Bits [4:6] of the immediate in a list specifier encode register stride
15731      (minus 1) in bit 4, and list length in bits [5:6]. We put the <n> of
15732      VLD<n>/VST<n> in bits [9:8] of the initial bitmask. Suck it out here, look
15733      up the right value for "type" in a table based on this value and the given
15734      list style, then stick it back.  */
15735   idx = ((inst.operands[0].imm >> 4) & 7)
15736         | (((inst.instruction >> 8) & 3) << 3);
15737
15738   typebits = typetable[idx];
15739
15740   constraint (typebits == -1, _("bad list type for instruction"));
15741
15742   inst.instruction &= ~0xf00;
15743   inst.instruction |= typebits << 8;
15744 }
15745
15746 /* Check alignment is valid for do_neon_ld_st_lane and do_neon_ld_dup.
15747    *DO_ALIGN is set to 1 if the relevant alignment bit should be set, 0
15748    otherwise. The variable arguments are a list of pairs of legal (size, align)
15749    values, terminated with -1.  */
15750
15751 static int
15752 neon_alignment_bit (int size, int align, int *do_align, ...)
15753 {
15754   va_list ap;
15755   int result = FAIL, thissize, thisalign;
15756
15757   if (!inst.operands[1].immisalign)
15758     {
15759       *do_align = 0;
15760       return SUCCESS;
15761     }
15762
15763   va_start (ap, do_align);
15764
15765   do
15766     {
15767       thissize = va_arg (ap, int);
15768       if (thissize == -1)
15769         break;
15770       thisalign = va_arg (ap, int);
15771
15772       if (size == thissize && align == thisalign)
15773         result = SUCCESS;
15774     }
15775   while (result != SUCCESS);
15776
15777   va_end (ap);
15778
15779   if (result == SUCCESS)
15780     *do_align = 1;
15781   else
15782     first_error (_("unsupported alignment for instruction"));
15783
15784   return result;
15785 }
15786
15787 static void
15788 do_neon_ld_st_lane (void)
15789 {
15790   struct neon_type_el et = neon_check_type (1, NS_NULL, N_8 | N_16 | N_32);
15791   int align_good, do_align = 0;
15792   int logsize = neon_logbits (et.size);
15793   int align = inst.operands[1].imm >> 8;
15794   int n = (inst.instruction >> 8) & 3;
15795   int max_el = 64 / et.size;
15796
15797   if (et.type == NT_invtype)
15798     return;
15799
15800   constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != n + 1,
15801               _("bad list length"));
15802   constraint (NEON_LANE (inst.operands[0].imm) >= max_el,
15803               _("scalar index out of range"));
15804   constraint (n != 0 && NEON_REG_STRIDE (inst.operands[0].imm) == 2
15805               && et.size == 8,
15806               _("stride of 2 unavailable when element size is 8"));
15807
15808   switch (n)
15809     {
15810     case 0:  /* VLD1 / VST1.  */
15811       align_good = neon_alignment_bit (et.size, align, &do_align, 16, 16,
15812                                        32, 32, -1);
15813       if (align_good == FAIL)
15814         return;
15815       if (do_align)
15816         {
15817           unsigned alignbits = 0;
15818           switch (et.size)
15819             {
15820             case 16: alignbits = 0x1; break;
15821             case 32: alignbits = 0x3; break;
15822             default: ;
15823             }
15824           inst.instruction |= alignbits << 4;
15825         }
15826       break;
15827
15828     case 1:  /* VLD2 / VST2.  */
15829       align_good = neon_alignment_bit (et.size, align, &do_align, 8, 16, 16, 32,
15830                                        32, 64, -1);
15831       if (align_good == FAIL)
15832         return;
15833       if (do_align)
15834         inst.instruction |= 1 << 4;
15835       break;
15836
15837     case 2:  /* VLD3 / VST3.  */
15838       constraint (inst.operands[1].immisalign,
15839                   _("can't use alignment with this instruction"));
15840       break;
15841
15842     case 3:  /* VLD4 / VST4.  */
15843       align_good = neon_alignment_bit (et.size, align, &do_align, 8, 32,
15844                                        16, 64, 32, 64, 32, 128, -1);
15845       if (align_good == FAIL)
15846         return;
15847       if (do_align)
15848         {
15849           unsigned alignbits = 0;
15850           switch (et.size)
15851             {
15852             case 8:  alignbits = 0x1; break;
15853             case 16: alignbits = 0x1; break;
15854             case 32: alignbits = (align == 64) ? 0x1 : 0x2; break;
15855             default: ;
15856             }
15857           inst.instruction |= alignbits << 4;
15858         }
15859       break;
15860
15861     default: ;
15862     }
15863
15864   /* Reg stride of 2 is encoded in bit 5 when size==16, bit 6 when size==32.  */
15865   if (n != 0 && NEON_REG_STRIDE (inst.operands[0].imm) == 2)
15866     inst.instruction |= 1 << (4 + logsize);
15867
15868   inst.instruction |= NEON_LANE (inst.operands[0].imm) << (logsize + 5);
15869   inst.instruction |= logsize << 10;
15870 }
15871
15872 /* Encode single n-element structure to all lanes VLD<n> instructions.  */
15873
15874 static void
15875 do_neon_ld_dup (void)
15876 {
15877   struct neon_type_el et = neon_check_type (1, NS_NULL, N_8 | N_16 | N_32);
15878   int align_good, do_align = 0;
15879
15880   if (et.type == NT_invtype)
15881     return;
15882
15883   switch ((inst.instruction >> 8) & 3)
15884     {
15885     case 0:  /* VLD1.  */
15886       gas_assert (NEON_REG_STRIDE (inst.operands[0].imm) != 2);
15887       align_good = neon_alignment_bit (et.size, inst.operands[1].imm >> 8,
15888                                        &do_align, 16, 16, 32, 32, -1);
15889       if (align_good == FAIL)
15890         return;
15891       switch (NEON_REGLIST_LENGTH (inst.operands[0].imm))
15892         {
15893         case 1: break;
15894         case 2: inst.instruction |= 1 << 5; break;
15895         default: first_error (_("bad list length")); return;
15896         }
15897       inst.instruction |= neon_logbits (et.size) << 6;
15898       break;
15899
15900     case 1:  /* VLD2.  */
15901       align_good = neon_alignment_bit (et.size, inst.operands[1].imm >> 8,
15902                                        &do_align, 8, 16, 16, 32, 32, 64, -1);
15903       if (align_good == FAIL)
15904         return;
15905       constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 2,
15906                   _("bad list length"));
15907       if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
15908         inst.instruction |= 1 << 5;
15909       inst.instruction |= neon_logbits (et.size) << 6;
15910       break;
15911
15912     case 2:  /* VLD3.  */
15913       constraint (inst.operands[1].immisalign,
15914                   _("can't use alignment with this instruction"));
15915       constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 3,
15916                   _("bad list length"));
15917       if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
15918         inst.instruction |= 1 << 5;
15919       inst.instruction |= neon_logbits (et.size) << 6;
15920       break;
15921
15922     case 3:  /* VLD4.  */
15923       {
15924         int align = inst.operands[1].imm >> 8;
15925         align_good = neon_alignment_bit (et.size, align, &do_align, 8, 32,
15926                                          16, 64, 32, 64, 32, 128, -1);
15927         if (align_good == FAIL)
15928           return;
15929         constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4,
15930                     _("bad list length"));
15931         if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
15932           inst.instruction |= 1 << 5;
15933         if (et.size == 32 && align == 128)
15934           inst.instruction |= 0x3 << 6;
15935         else
15936           inst.instruction |= neon_logbits (et.size) << 6;
15937       }
15938       break;
15939
15940     default: ;
15941     }
15942
15943   inst.instruction |= do_align << 4;
15944 }
15945
15946 /* Disambiguate VLD<n> and VST<n> instructions, and fill in common bits (those
15947    apart from bits [11:4].  */
15948
15949 static void
15950 do_neon_ldx_stx (void)
15951 {
15952   if (inst.operands[1].isreg)
15953     constraint (inst.operands[1].reg == REG_PC, BAD_PC);
15954
15955   switch (NEON_LANE (inst.operands[0].imm))
15956     {
15957     case NEON_INTERLEAVE_LANES:
15958       NEON_ENCODE (INTERLV, inst);
15959       do_neon_ld_st_interleave ();
15960       break;
15961
15962     case NEON_ALL_LANES:
15963       NEON_ENCODE (DUP, inst);
15964       do_neon_ld_dup ();
15965       break;
15966
15967     default:
15968       NEON_ENCODE (LANE, inst);
15969       do_neon_ld_st_lane ();
15970     }
15971
15972   /* L bit comes from bit mask.  */
15973   inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15974   inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15975   inst.instruction |= inst.operands[1].reg << 16;
15976
15977   if (inst.operands[1].postind)
15978     {
15979       int postreg = inst.operands[1].imm & 0xf;
15980       constraint (!inst.operands[1].immisreg,
15981                   _("post-index must be a register"));
15982       constraint (postreg == 0xd || postreg == 0xf,
15983                   _("bad register for post-index"));
15984       inst.instruction |= postreg;
15985     }
15986   else if (inst.operands[1].writeback)
15987     {
15988       inst.instruction |= 0xd;
15989     }
15990   else
15991     inst.instruction |= 0xf;
15992
15993   if (thumb_mode)
15994     inst.instruction |= 0xf9000000;
15995   else
15996     inst.instruction |= 0xf4000000;
15997 }
15998
15999 /* FP v8.  */
16000 static void
16001 do_vfp_nsyn_fpv8 (enum neon_shape rs)
16002 {
16003   NEON_ENCODE (FPV8, inst);
16004
16005   if (rs == NS_FFF)
16006     do_vfp_sp_dyadic ();
16007   else
16008     do_vfp_dp_rd_rn_rm ();
16009
16010   if (rs == NS_DDD)
16011     inst.instruction |= 0x100;
16012
16013   inst.instruction |= 0xf0000000;
16014 }
16015
16016 static void
16017 do_vsel (void)
16018 {
16019   set_it_insn_type (OUTSIDE_IT_INSN);
16020
16021   if (try_vfp_nsyn (3, do_vfp_nsyn_fpv8) != SUCCESS)
16022     first_error (_("invalid instruction shape"));
16023 }
16024
16025 static void
16026 do_vmaxnm (void)
16027 {
16028   set_it_insn_type (OUTSIDE_IT_INSN);
16029
16030   if (try_vfp_nsyn (3, do_vfp_nsyn_fpv8) == SUCCESS)
16031     return;
16032
16033   if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH8) == FAIL)
16034     return;
16035
16036   neon_dyadic_misc (NT_untyped, N_F32, 0);
16037 }
16038
16039 static void
16040 do_vrint_1 (enum neon_cvt_mode mode)
16041 {
16042   enum neon_shape rs = neon_select_shape (NS_FF, NS_DD, NS_QQ, NS_NULL);
16043   struct neon_type_el et;
16044
16045   if (rs == NS_NULL)
16046     return;
16047
16048   et = neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
16049   if (et.type != NT_invtype)
16050     {
16051       /* VFP encodings.  */
16052       if (mode == neon_cvt_mode_a || mode == neon_cvt_mode_n
16053           || mode == neon_cvt_mode_p || mode == neon_cvt_mode_m)
16054         set_it_insn_type (OUTSIDE_IT_INSN);
16055
16056       NEON_ENCODE (FPV8, inst);
16057       if (rs == NS_FF)
16058         do_vfp_sp_monadic ();
16059       else
16060         do_vfp_dp_rd_rm ();
16061
16062       switch (mode)
16063         {
16064         case neon_cvt_mode_r: inst.instruction |= 0x00000000; break;
16065         case neon_cvt_mode_z: inst.instruction |= 0x00000080; break;
16066         case neon_cvt_mode_x: inst.instruction |= 0x00010000; break;
16067         case neon_cvt_mode_a: inst.instruction |= 0xf0000000; break;
16068         case neon_cvt_mode_n: inst.instruction |= 0xf0010000; break;
16069         case neon_cvt_mode_p: inst.instruction |= 0xf0020000; break;
16070         case neon_cvt_mode_m: inst.instruction |= 0xf0030000; break;
16071         default: abort ();
16072         }
16073
16074       inst.instruction |= (rs == NS_DD) << 8;
16075       do_vfp_cond_or_thumb ();
16076     }
16077   else
16078     {
16079       /* Neon encodings (or something broken...).  */
16080       inst.error = NULL;
16081       et = neon_check_type (2, rs, N_EQK, N_F32 | N_KEY);
16082
16083       if (et.type == NT_invtype)
16084         return;
16085
16086       set_it_insn_type (OUTSIDE_IT_INSN);
16087       NEON_ENCODE (FLOAT, inst);
16088
16089       if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH8) == FAIL)
16090         return;
16091
16092       inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16093       inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16094       inst.instruction |= LOW4 (inst.operands[1].reg);
16095       inst.instruction |= HI1 (inst.operands[1].reg) << 5;
16096       inst.instruction |= neon_quad (rs) << 6;
16097       switch (mode)
16098         {
16099         case neon_cvt_mode_z: inst.instruction |= 3 << 7; break;
16100         case neon_cvt_mode_x: inst.instruction |= 1 << 7; break;
16101         case neon_cvt_mode_a: inst.instruction |= 2 << 7; break;
16102         case neon_cvt_mode_n: inst.instruction |= 0 << 7; break;
16103         case neon_cvt_mode_p: inst.instruction |= 7 << 7; break;
16104         case neon_cvt_mode_m: inst.instruction |= 5 << 7; break;
16105         case neon_cvt_mode_r: inst.error = _("invalid rounding mode"); break;
16106         default: abort ();
16107         }
16108
16109       if (thumb_mode)
16110         inst.instruction |= 0xfc000000;
16111       else
16112         inst.instruction |= 0xf0000000;
16113     }
16114 }
16115
16116 static void
16117 do_vrintx (void)
16118 {
16119   do_vrint_1 (neon_cvt_mode_x);
16120 }
16121
16122 static void
16123 do_vrintz (void)
16124 {
16125   do_vrint_1 (neon_cvt_mode_z);
16126 }
16127
16128 static void
16129 do_vrintr (void)
16130 {
16131   do_vrint_1 (neon_cvt_mode_r);
16132 }
16133
16134 static void
16135 do_vrinta (void)
16136 {
16137   do_vrint_1 (neon_cvt_mode_a);
16138 }
16139
16140 static void
16141 do_vrintn (void)
16142 {
16143   do_vrint_1 (neon_cvt_mode_n);
16144 }
16145
16146 static void
16147 do_vrintp (void)
16148 {
16149   do_vrint_1 (neon_cvt_mode_p);
16150 }
16151
16152 static void
16153 do_vrintm (void)
16154 {
16155   do_vrint_1 (neon_cvt_mode_m);
16156 }
16157
16158 \f
16159 /* Overall per-instruction processing.  */
16160
16161 /* We need to be able to fix up arbitrary expressions in some statements.
16162    This is so that we can handle symbols that are an arbitrary distance from
16163    the pc.  The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
16164    which returns part of an address in a form which will be valid for
16165    a data instruction.  We do this by pushing the expression into a symbol
16166    in the expr_section, and creating a fix for that.  */
16167
16168 static void
16169 fix_new_arm (fragS *       frag,
16170              int           where,
16171              short int     size,
16172              expressionS * exp,
16173              int           pc_rel,
16174              int           reloc)
16175 {
16176   fixS *           new_fix;
16177
16178   switch (exp->X_op)
16179     {
16180     case O_constant:
16181       if (pc_rel)
16182         {
16183           /* Create an absolute valued symbol, so we have something to
16184              refer to in the object file.  Unfortunately for us, gas's
16185              generic expression parsing will already have folded out
16186              any use of .set foo/.type foo %function that may have
16187              been used to set type information of the target location,
16188              that's being specified symbolically.  We have to presume
16189              the user knows what they are doing.  */
16190           char name[16 + 8];
16191           symbolS *symbol;
16192
16193           sprintf (name, "*ABS*0x%lx", (unsigned long)exp->X_add_number);
16194
16195           symbol = symbol_find_or_make (name);
16196           S_SET_SEGMENT (symbol, absolute_section);
16197           symbol_set_frag (symbol, &zero_address_frag);
16198           S_SET_VALUE (symbol, exp->X_add_number);
16199           exp->X_op = O_symbol;
16200           exp->X_add_symbol = symbol;
16201           exp->X_add_number = 0;
16202         }
16203       /* FALLTHROUGH */
16204     case O_symbol:
16205     case O_add:
16206     case O_subtract:
16207       new_fix = fix_new_exp (frag, where, size, exp, pc_rel,
16208                              (enum bfd_reloc_code_real) reloc);
16209       break;
16210
16211     default:
16212       new_fix = (fixS *) fix_new (frag, where, size, make_expr_symbol (exp), 0,
16213                                   pc_rel, (enum bfd_reloc_code_real) reloc);
16214       break;
16215     }
16216
16217   /* Mark whether the fix is to a THUMB instruction, or an ARM
16218      instruction.  */
16219   new_fix->tc_fix_data = thumb_mode;
16220 }
16221
16222 /* Create a frg for an instruction requiring relaxation.  */
16223 static void
16224 output_relax_insn (void)
16225 {
16226   char * to;
16227   symbolS *sym;
16228   int offset;
16229
16230   /* The size of the instruction is unknown, so tie the debug info to the
16231      start of the instruction.  */
16232   dwarf2_emit_insn (0);
16233
16234   switch (inst.reloc.exp.X_op)
16235     {
16236     case O_symbol:
16237       sym = inst.reloc.exp.X_add_symbol;
16238       offset = inst.reloc.exp.X_add_number;
16239       break;
16240     case O_constant:
16241       sym = NULL;
16242       offset = inst.reloc.exp.X_add_number;
16243       break;
16244     default:
16245       sym = make_expr_symbol (&inst.reloc.exp);
16246       offset = 0;
16247       break;
16248   }
16249   to = frag_var (rs_machine_dependent, INSN_SIZE, THUMB_SIZE,
16250                  inst.relax, sym, offset, NULL/*offset, opcode*/);
16251   md_number_to_chars (to, inst.instruction, THUMB_SIZE);
16252 }
16253
16254 /* Write a 32-bit thumb instruction to buf.  */
16255 static void
16256 put_thumb32_insn (char * buf, unsigned long insn)
16257 {
16258   md_number_to_chars (buf, insn >> 16, THUMB_SIZE);
16259   md_number_to_chars (buf + THUMB_SIZE, insn, THUMB_SIZE);
16260 }
16261
16262 static void
16263 output_inst (const char * str)
16264 {
16265   char * to = NULL;
16266
16267   if (inst.error)
16268     {
16269       as_bad ("%s -- `%s'", inst.error, str);
16270       return;
16271     }
16272   if (inst.relax)
16273     {
16274       output_relax_insn ();
16275       return;
16276     }
16277   if (inst.size == 0)
16278     return;
16279
16280   to = frag_more (inst.size);
16281   /* PR 9814: Record the thumb mode into the current frag so that we know
16282      what type of NOP padding to use, if necessary.  We override any previous
16283      setting so that if the mode has changed then the NOPS that we use will
16284      match the encoding of the last instruction in the frag.  */
16285   frag_now->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
16286
16287   if (thumb_mode && (inst.size > THUMB_SIZE))
16288     {
16289       gas_assert (inst.size == (2 * THUMB_SIZE));
16290       put_thumb32_insn (to, inst.instruction);
16291     }
16292   else if (inst.size > INSN_SIZE)
16293     {
16294       gas_assert (inst.size == (2 * INSN_SIZE));
16295       md_number_to_chars (to, inst.instruction, INSN_SIZE);
16296       md_number_to_chars (to + INSN_SIZE, inst.instruction, INSN_SIZE);
16297     }
16298   else
16299     md_number_to_chars (to, inst.instruction, inst.size);
16300
16301   if (inst.reloc.type != BFD_RELOC_UNUSED)
16302     fix_new_arm (frag_now, to - frag_now->fr_literal,
16303                  inst.size, & inst.reloc.exp, inst.reloc.pc_rel,
16304                  inst.reloc.type);
16305
16306   dwarf2_emit_insn (inst.size);
16307 }
16308
16309 static char *
16310 output_it_inst (int cond, int mask, char * to)
16311 {
16312   unsigned long instruction = 0xbf00;
16313
16314   mask &= 0xf;
16315   instruction |= mask;
16316   instruction |= cond << 4;
16317
16318   if (to == NULL)
16319     {
16320       to = frag_more (2);
16321 #ifdef OBJ_ELF
16322       dwarf2_emit_insn (2);
16323 #endif
16324     }
16325
16326   md_number_to_chars (to, instruction, 2);
16327
16328   return to;
16329 }
16330
16331 /* Tag values used in struct asm_opcode's tag field.  */
16332 enum opcode_tag
16333 {
16334   OT_unconditional,     /* Instruction cannot be conditionalized.
16335                            The ARM condition field is still 0xE.  */
16336   OT_unconditionalF,    /* Instruction cannot be conditionalized
16337                            and carries 0xF in its ARM condition field.  */
16338   OT_csuffix,           /* Instruction takes a conditional suffix.  */
16339   OT_csuffixF,          /* Some forms of the instruction take a conditional
16340                            suffix, others place 0xF where the condition field
16341                            would be.  */
16342   OT_cinfix3,           /* Instruction takes a conditional infix,
16343                            beginning at character index 3.  (In
16344                            unified mode, it becomes a suffix.)  */
16345   OT_cinfix3_deprecated, /* The same as OT_cinfix3.  This is used for
16346                             tsts, cmps, cmns, and teqs. */
16347   OT_cinfix3_legacy,    /* Legacy instruction takes a conditional infix at
16348                            character index 3, even in unified mode.  Used for
16349                            legacy instructions where suffix and infix forms
16350                            may be ambiguous.  */
16351   OT_csuf_or_in3,       /* Instruction takes either a conditional
16352                            suffix or an infix at character index 3.  */
16353   OT_odd_infix_unc,     /* This is the unconditional variant of an
16354                            instruction that takes a conditional infix
16355                            at an unusual position.  In unified mode,
16356                            this variant will accept a suffix.  */
16357   OT_odd_infix_0        /* Values greater than or equal to OT_odd_infix_0
16358                            are the conditional variants of instructions that
16359                            take conditional infixes in unusual positions.
16360                            The infix appears at character index
16361                            (tag - OT_odd_infix_0).  These are not accepted
16362                            in unified mode.  */
16363 };
16364
16365 /* Subroutine of md_assemble, responsible for looking up the primary
16366    opcode from the mnemonic the user wrote.  STR points to the
16367    beginning of the mnemonic.
16368
16369    This is not simply a hash table lookup, because of conditional
16370    variants.  Most instructions have conditional variants, which are
16371    expressed with a _conditional affix_ to the mnemonic.  If we were
16372    to encode each conditional variant as a literal string in the opcode
16373    table, it would have approximately 20,000 entries.
16374
16375    Most mnemonics take this affix as a suffix, and in unified syntax,
16376    'most' is upgraded to 'all'.  However, in the divided syntax, some
16377    instructions take the affix as an infix, notably the s-variants of
16378    the arithmetic instructions.  Of those instructions, all but six
16379    have the infix appear after the third character of the mnemonic.
16380
16381    Accordingly, the algorithm for looking up primary opcodes given
16382    an identifier is:
16383
16384    1. Look up the identifier in the opcode table.
16385       If we find a match, go to step U.
16386
16387    2. Look up the last two characters of the identifier in the
16388       conditions table.  If we find a match, look up the first N-2
16389       characters of the identifier in the opcode table.  If we
16390       find a match, go to step CE.
16391
16392    3. Look up the fourth and fifth characters of the identifier in
16393       the conditions table.  If we find a match, extract those
16394       characters from the identifier, and look up the remaining
16395       characters in the opcode table.  If we find a match, go
16396       to step CM.
16397
16398    4. Fail.
16399
16400    U. Examine the tag field of the opcode structure, in case this is
16401       one of the six instructions with its conditional infix in an
16402       unusual place.  If it is, the tag tells us where to find the
16403       infix; look it up in the conditions table and set inst.cond
16404       accordingly.  Otherwise, this is an unconditional instruction.
16405       Again set inst.cond accordingly.  Return the opcode structure.
16406
16407   CE. Examine the tag field to make sure this is an instruction that
16408       should receive a conditional suffix.  If it is not, fail.
16409       Otherwise, set inst.cond from the suffix we already looked up,
16410       and return the opcode structure.
16411
16412   CM. Examine the tag field to make sure this is an instruction that
16413       should receive a conditional infix after the third character.
16414       If it is not, fail.  Otherwise, undo the edits to the current
16415       line of input and proceed as for case CE.  */
16416
16417 static const struct asm_opcode *
16418 opcode_lookup (char **str)
16419 {
16420   char *end, *base;
16421   char *affix;
16422   const struct asm_opcode *opcode;
16423   const struct asm_cond *cond;
16424   char save[2];
16425
16426   /* Scan up to the end of the mnemonic, which must end in white space,
16427      '.' (in unified mode, or for Neon/VFP instructions), or end of string.  */
16428   for (base = end = *str; *end != '\0'; end++)
16429     if (*end == ' ' || *end == '.')
16430       break;
16431
16432   if (end == base)
16433     return NULL;
16434
16435   /* Handle a possible width suffix and/or Neon type suffix.  */
16436   if (end[0] == '.')
16437     {
16438       int offset = 2;
16439
16440       /* The .w and .n suffixes are only valid if the unified syntax is in
16441          use.  */
16442       if (unified_syntax && end[1] == 'w')
16443         inst.size_req = 4;
16444       else if (unified_syntax && end[1] == 'n')
16445         inst.size_req = 2;
16446       else
16447         offset = 0;
16448
16449       inst.vectype.elems = 0;
16450
16451       *str = end + offset;
16452
16453       if (end[offset] == '.')
16454         {
16455           /* See if we have a Neon type suffix (possible in either unified or
16456              non-unified ARM syntax mode).  */
16457           if (parse_neon_type (&inst.vectype, str) == FAIL)
16458             return NULL;
16459         }
16460       else if (end[offset] != '\0' && end[offset] != ' ')
16461         return NULL;
16462     }
16463   else
16464     *str = end;
16465
16466   /* Look for unaffixed or special-case affixed mnemonic.  */
16467   opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
16468                                                     end - base);
16469   if (opcode)
16470     {
16471       /* step U */
16472       if (opcode->tag < OT_odd_infix_0)
16473         {
16474           inst.cond = COND_ALWAYS;
16475           return opcode;
16476         }
16477
16478       if (warn_on_deprecated && unified_syntax)
16479         as_warn (_("conditional infixes are deprecated in unified syntax"));
16480       affix = base + (opcode->tag - OT_odd_infix_0);
16481       cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
16482       gas_assert (cond);
16483
16484       inst.cond = cond->value;
16485       return opcode;
16486     }
16487
16488   /* Cannot have a conditional suffix on a mnemonic of less than two
16489      characters.  */
16490   if (end - base < 3)
16491     return NULL;
16492
16493   /* Look for suffixed mnemonic.  */
16494   affix = end - 2;
16495   cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
16496   opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
16497                                                     affix - base);
16498   if (opcode && cond)
16499     {
16500       /* step CE */
16501       switch (opcode->tag)
16502         {
16503         case OT_cinfix3_legacy:
16504           /* Ignore conditional suffixes matched on infix only mnemonics.  */
16505           break;
16506
16507         case OT_cinfix3:
16508         case OT_cinfix3_deprecated:
16509         case OT_odd_infix_unc:
16510           if (!unified_syntax)
16511             return 0;
16512           /* else fall through */
16513
16514         case OT_csuffix:
16515         case OT_csuffixF:
16516         case OT_csuf_or_in3:
16517           inst.cond = cond->value;
16518           return opcode;
16519
16520         case OT_unconditional:
16521         case OT_unconditionalF:
16522           if (thumb_mode)
16523             inst.cond = cond->value;
16524           else
16525             {
16526               /* Delayed diagnostic.  */
16527               inst.error = BAD_COND;
16528               inst.cond = COND_ALWAYS;
16529             }
16530           return opcode;
16531
16532         default:
16533           return NULL;
16534         }
16535     }
16536
16537   /* Cannot have a usual-position infix on a mnemonic of less than
16538      six characters (five would be a suffix).  */
16539   if (end - base < 6)
16540     return NULL;
16541
16542   /* Look for infixed mnemonic in the usual position.  */
16543   affix = base + 3;
16544   cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
16545   if (!cond)
16546     return NULL;
16547
16548   memcpy (save, affix, 2);
16549   memmove (affix, affix + 2, (end - affix) - 2);
16550   opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
16551                                                     (end - base) - 2);
16552   memmove (affix + 2, affix, (end - affix) - 2);
16553   memcpy (affix, save, 2);
16554
16555   if (opcode
16556       && (opcode->tag == OT_cinfix3
16557           || opcode->tag == OT_cinfix3_deprecated
16558           || opcode->tag == OT_csuf_or_in3
16559           || opcode->tag == OT_cinfix3_legacy))
16560     {
16561       /* Step CM.  */
16562       if (warn_on_deprecated && unified_syntax
16563           && (opcode->tag == OT_cinfix3
16564               || opcode->tag == OT_cinfix3_deprecated))
16565         as_warn (_("conditional infixes are deprecated in unified syntax"));
16566
16567       inst.cond = cond->value;
16568       return opcode;
16569     }
16570
16571   return NULL;
16572 }
16573
16574 /* This function generates an initial IT instruction, leaving its block
16575    virtually open for the new instructions. Eventually,
16576    the mask will be updated by now_it_add_mask () each time
16577    a new instruction needs to be included in the IT block.
16578    Finally, the block is closed with close_automatic_it_block ().
16579    The block closure can be requested either from md_assemble (),
16580    a tencode (), or due to a label hook.  */
16581
16582 static void
16583 new_automatic_it_block (int cond)
16584 {
16585   now_it.state = AUTOMATIC_IT_BLOCK;
16586   now_it.mask = 0x18;
16587   now_it.cc = cond;
16588   now_it.block_length = 1;
16589   mapping_state (MAP_THUMB);
16590   now_it.insn = output_it_inst (cond, now_it.mask, NULL);
16591   now_it.warn_deprecated = FALSE;
16592   now_it.insn_cond = TRUE;
16593 }
16594
16595 /* Close an automatic IT block.
16596    See comments in new_automatic_it_block ().  */
16597
16598 static void
16599 close_automatic_it_block (void)
16600 {
16601   now_it.mask = 0x10;
16602   now_it.block_length = 0;
16603 }
16604
16605 /* Update the mask of the current automatically-generated IT
16606    instruction. See comments in new_automatic_it_block ().  */
16607
16608 static void
16609 now_it_add_mask (int cond)
16610 {
16611 #define CLEAR_BIT(value, nbit)  ((value) & ~(1 << (nbit)))
16612 #define SET_BIT_VALUE(value, bitvalue, nbit)  (CLEAR_BIT (value, nbit) \
16613                                               | ((bitvalue) << (nbit)))
16614   const int resulting_bit = (cond & 1);
16615
16616   now_it.mask &= 0xf;
16617   now_it.mask = SET_BIT_VALUE (now_it.mask,
16618                                    resulting_bit,
16619                                   (5 - now_it.block_length));
16620   now_it.mask = SET_BIT_VALUE (now_it.mask,
16621                                    1,
16622                                    ((5 - now_it.block_length) - 1) );
16623   output_it_inst (now_it.cc, now_it.mask, now_it.insn);
16624
16625 #undef CLEAR_BIT
16626 #undef SET_BIT_VALUE
16627 }
16628
16629 /* The IT blocks handling machinery is accessed through the these functions:
16630      it_fsm_pre_encode ()               from md_assemble ()
16631      set_it_insn_type ()                optional, from the tencode functions
16632      set_it_insn_type_last ()           ditto
16633      in_it_block ()                     ditto
16634      it_fsm_post_encode ()              from md_assemble ()
16635      force_automatic_it_block_close ()  from label habdling functions
16636
16637    Rationale:
16638      1) md_assemble () calls it_fsm_pre_encode () before calling tencode (),
16639         initializing the IT insn type with a generic initial value depending
16640         on the inst.condition.
16641      2) During the tencode function, two things may happen:
16642         a) The tencode function overrides the IT insn type by
16643            calling either set_it_insn_type (type) or set_it_insn_type_last ().
16644         b) The tencode function queries the IT block state by
16645            calling in_it_block () (i.e. to determine narrow/not narrow mode).
16646
16647         Both set_it_insn_type and in_it_block run the internal FSM state
16648         handling function (handle_it_state), because: a) setting the IT insn
16649         type may incur in an invalid state (exiting the function),
16650         and b) querying the state requires the FSM to be updated.
16651         Specifically we want to avoid creating an IT block for conditional
16652         branches, so it_fsm_pre_encode is actually a guess and we can't
16653         determine whether an IT block is required until the tencode () routine
16654         has decided what type of instruction this actually it.
16655         Because of this, if set_it_insn_type and in_it_block have to be used,
16656         set_it_insn_type has to be called first.
16657
16658         set_it_insn_type_last () is a wrapper of set_it_insn_type (type), that
16659         determines the insn IT type depending on the inst.cond code.
16660         When a tencode () routine encodes an instruction that can be
16661         either outside an IT block, or, in the case of being inside, has to be
16662         the last one, set_it_insn_type_last () will determine the proper
16663         IT instruction type based on the inst.cond code. Otherwise,
16664         set_it_insn_type can be called for overriding that logic or
16665         for covering other cases.
16666
16667         Calling handle_it_state () may not transition the IT block state to
16668         OUTSIDE_IT_BLOCK immediatelly, since the (current) state could be
16669         still queried. Instead, if the FSM determines that the state should
16670         be transitioned to OUTSIDE_IT_BLOCK, a flag is marked to be closed
16671         after the tencode () function: that's what it_fsm_post_encode () does.
16672
16673         Since in_it_block () calls the state handling function to get an
16674         updated state, an error may occur (due to invalid insns combination).
16675         In that case, inst.error is set.
16676         Therefore, inst.error has to be checked after the execution of
16677         the tencode () routine.
16678
16679      3) Back in md_assemble(), it_fsm_post_encode () is called to commit
16680         any pending state change (if any) that didn't take place in
16681         handle_it_state () as explained above.  */
16682
16683 static void
16684 it_fsm_pre_encode (void)
16685 {
16686   if (inst.cond != COND_ALWAYS)
16687     inst.it_insn_type = INSIDE_IT_INSN;
16688   else
16689     inst.it_insn_type = OUTSIDE_IT_INSN;
16690
16691   now_it.state_handled = 0;
16692 }
16693
16694 /* IT state FSM handling function.  */
16695
16696 static int
16697 handle_it_state (void)
16698 {
16699   now_it.state_handled = 1;
16700   now_it.insn_cond = FALSE;
16701
16702   switch (now_it.state)
16703     {
16704     case OUTSIDE_IT_BLOCK:
16705       switch (inst.it_insn_type)
16706         {
16707         case OUTSIDE_IT_INSN:
16708           break;
16709
16710         case INSIDE_IT_INSN:
16711         case INSIDE_IT_LAST_INSN:
16712           if (thumb_mode == 0)
16713             {
16714               if (unified_syntax
16715                   && !(implicit_it_mode & IMPLICIT_IT_MODE_ARM))
16716                 as_tsktsk (_("Warning: conditional outside an IT block"\
16717                              " for Thumb."));
16718             }
16719           else
16720             {
16721               if ((implicit_it_mode & IMPLICIT_IT_MODE_THUMB)
16722                   && ARM_CPU_HAS_FEATURE (cpu_variant, arm_arch_t2))
16723                 {
16724                   /* Automatically generate the IT instruction.  */
16725                   new_automatic_it_block (inst.cond);
16726                   if (inst.it_insn_type == INSIDE_IT_LAST_INSN)
16727                     close_automatic_it_block ();
16728                 }
16729               else
16730                 {
16731                   inst.error = BAD_OUT_IT;
16732                   return FAIL;
16733                 }
16734             }
16735           break;
16736
16737         case IF_INSIDE_IT_LAST_INSN:
16738         case NEUTRAL_IT_INSN:
16739           break;
16740
16741         case IT_INSN:
16742           now_it.state = MANUAL_IT_BLOCK;
16743           now_it.block_length = 0;
16744           break;
16745         }
16746       break;
16747
16748     case AUTOMATIC_IT_BLOCK:
16749       /* Three things may happen now:
16750          a) We should increment current it block size;
16751          b) We should close current it block (closing insn or 4 insns);
16752          c) We should close current it block and start a new one (due
16753          to incompatible conditions or
16754          4 insns-length block reached).  */
16755
16756       switch (inst.it_insn_type)
16757         {
16758         case OUTSIDE_IT_INSN:
16759           /* The closure of the block shall happen immediatelly,
16760              so any in_it_block () call reports the block as closed.  */
16761           force_automatic_it_block_close ();
16762           break;
16763
16764         case INSIDE_IT_INSN:
16765         case INSIDE_IT_LAST_INSN:
16766         case IF_INSIDE_IT_LAST_INSN:
16767           now_it.block_length++;
16768
16769           if (now_it.block_length > 4
16770               || !now_it_compatible (inst.cond))
16771             {
16772               force_automatic_it_block_close ();
16773               if (inst.it_insn_type != IF_INSIDE_IT_LAST_INSN)
16774                 new_automatic_it_block (inst.cond);
16775             }
16776           else
16777             {
16778               now_it.insn_cond = TRUE;
16779               now_it_add_mask (inst.cond);
16780             }
16781
16782           if (now_it.state == AUTOMATIC_IT_BLOCK
16783               && (inst.it_insn_type == INSIDE_IT_LAST_INSN
16784                   || inst.it_insn_type == IF_INSIDE_IT_LAST_INSN))
16785             close_automatic_it_block ();
16786           break;
16787
16788         case NEUTRAL_IT_INSN:
16789           now_it.block_length++;
16790           now_it.insn_cond = TRUE;
16791
16792           if (now_it.block_length > 4)
16793             force_automatic_it_block_close ();
16794           else
16795             now_it_add_mask (now_it.cc & 1);
16796           break;
16797
16798         case IT_INSN:
16799           close_automatic_it_block ();
16800           now_it.state = MANUAL_IT_BLOCK;
16801           break;
16802         }
16803       break;
16804
16805     case MANUAL_IT_BLOCK:
16806       {
16807         /* Check conditional suffixes.  */
16808         const int cond = now_it.cc ^ ((now_it.mask >> 4) & 1) ^ 1;
16809         int is_last;
16810         now_it.mask <<= 1;
16811         now_it.mask &= 0x1f;
16812         is_last = (now_it.mask == 0x10);
16813         now_it.insn_cond = TRUE;
16814
16815         switch (inst.it_insn_type)
16816           {
16817           case OUTSIDE_IT_INSN:
16818             inst.error = BAD_NOT_IT;
16819             return FAIL;
16820
16821           case INSIDE_IT_INSN:
16822             if (cond != inst.cond)
16823               {
16824                 inst.error = BAD_IT_COND;
16825                 return FAIL;
16826               }
16827             break;
16828
16829           case INSIDE_IT_LAST_INSN:
16830           case IF_INSIDE_IT_LAST_INSN:
16831             if (cond != inst.cond)
16832               {
16833                 inst.error = BAD_IT_COND;
16834                 return FAIL;
16835               }
16836             if (!is_last)
16837               {
16838                 inst.error = BAD_BRANCH;
16839                 return FAIL;
16840               }
16841             break;
16842
16843           case NEUTRAL_IT_INSN:
16844             /* The BKPT instruction is unconditional even in an IT block.  */
16845             break;
16846
16847           case IT_INSN:
16848             inst.error = BAD_IT_IT;
16849             return FAIL;
16850           }
16851       }
16852       break;
16853     }
16854
16855   return SUCCESS;
16856 }
16857
16858 struct depr_insn_mask
16859 {
16860   unsigned long pattern;
16861   unsigned long mask;
16862   const char* description;
16863 };
16864
16865 /* List of 16-bit instruction patterns deprecated in an IT block in
16866    ARMv8.  */
16867 static const struct depr_insn_mask depr_it_insns[] = {
16868   { 0xc000, 0xc000, N_("Short branches, Undefined, SVC, LDM/STM") },
16869   { 0xb000, 0xb000, N_("Miscellaneous 16-bit instructions") },
16870   { 0xa000, 0xb800, N_("ADR") },
16871   { 0x4800, 0xf800, N_("Literal loads") },
16872   { 0x4478, 0xf478, N_("Hi-register ADD, MOV, CMP, BX, BLX using pc") },
16873   { 0x4487, 0xfc87, N_("Hi-register ADD, MOV, CMP using pc") },
16874   { 0, 0, NULL }
16875 };
16876
16877 static void
16878 it_fsm_post_encode (void)
16879 {
16880   int is_last;
16881
16882   if (!now_it.state_handled)
16883     handle_it_state ();
16884
16885   if (now_it.insn_cond
16886       && !now_it.warn_deprecated
16887       && warn_on_deprecated
16888       && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
16889     {
16890       if (inst.instruction >= 0x10000)
16891         {
16892           as_warn (_("it blocks containing wide Thumb instructions are "
16893                      "deprecated in ARMv8"));
16894           now_it.warn_deprecated = TRUE;
16895         }
16896       else
16897         {
16898           const struct depr_insn_mask *p = depr_it_insns;
16899
16900           while (p->mask != 0)
16901             {
16902               if ((inst.instruction & p->mask) == p->pattern)
16903                 {
16904                   as_warn (_("it blocks containing 16-bit Thumb intsructions "
16905                              "of the following class are deprecated in ARMv8: "
16906                              "%s"), p->description);
16907                   now_it.warn_deprecated = TRUE;
16908                   break;
16909                 }
16910
16911               ++p;
16912             }
16913         }
16914
16915       if (now_it.block_length > 1)
16916         {
16917           as_warn (_("it blocks of more than one conditional instruction are "
16918                      "deprecated in ARMv8"));
16919           now_it.warn_deprecated = TRUE;
16920         }
16921     }
16922
16923   is_last = (now_it.mask == 0x10);
16924   if (is_last)
16925     {
16926       now_it.state = OUTSIDE_IT_BLOCK;
16927       now_it.mask = 0;
16928     }
16929 }
16930
16931 static void
16932 force_automatic_it_block_close (void)
16933 {
16934   if (now_it.state == AUTOMATIC_IT_BLOCK)
16935     {
16936       close_automatic_it_block ();
16937       now_it.state = OUTSIDE_IT_BLOCK;
16938       now_it.mask = 0;
16939     }
16940 }
16941
16942 static int
16943 in_it_block (void)
16944 {
16945   if (!now_it.state_handled)
16946     handle_it_state ();
16947
16948   return now_it.state != OUTSIDE_IT_BLOCK;
16949 }
16950
16951 void
16952 md_assemble (char *str)
16953 {
16954   char *p = str;
16955   const struct asm_opcode * opcode;
16956
16957   /* Align the previous label if needed.  */
16958   if (last_label_seen != NULL)
16959     {
16960       symbol_set_frag (last_label_seen, frag_now);
16961       S_SET_VALUE (last_label_seen, (valueT) frag_now_fix ());
16962       S_SET_SEGMENT (last_label_seen, now_seg);
16963     }
16964
16965   memset (&inst, '\0', sizeof (inst));
16966   inst.reloc.type = BFD_RELOC_UNUSED;
16967
16968   opcode = opcode_lookup (&p);
16969   if (!opcode)
16970     {
16971       /* It wasn't an instruction, but it might be a register alias of
16972          the form alias .req reg, or a Neon .dn/.qn directive.  */
16973       if (! create_register_alias (str, p)
16974           && ! create_neon_reg_alias (str, p))
16975         as_bad (_("bad instruction `%s'"), str);
16976
16977       return;
16978     }
16979
16980   if (warn_on_deprecated && opcode->tag == OT_cinfix3_deprecated)
16981     as_warn (_("s suffix on comparison instruction is deprecated"));
16982
16983   /* The value which unconditional instructions should have in place of the
16984      condition field.  */
16985   inst.uncond_value = (opcode->tag == OT_csuffixF) ? 0xf : -1;
16986
16987   if (thumb_mode)
16988     {
16989       arm_feature_set variant;
16990
16991       variant = cpu_variant;
16992       /* Only allow coprocessor instructions on Thumb-2 capable devices.  */
16993       if (!ARM_CPU_HAS_FEATURE (variant, arm_arch_t2))
16994         ARM_CLEAR_FEATURE (variant, variant, fpu_any_hard);
16995       /* Check that this instruction is supported for this CPU.  */
16996       if (!opcode->tvariant
16997           || (thumb_mode == 1
16998               && !ARM_CPU_HAS_FEATURE (variant, *opcode->tvariant)))
16999         {
17000           as_bad (_("selected processor does not support Thumb mode `%s'"), str);
17001           return;
17002         }
17003       if (inst.cond != COND_ALWAYS && !unified_syntax
17004           && opcode->tencode != do_t_branch)
17005         {
17006           as_bad (_("Thumb does not support conditional execution"));
17007           return;
17008         }
17009
17010       if (!ARM_CPU_HAS_FEATURE (variant, arm_ext_v6t2))
17011         {
17012           if (opcode->tencode != do_t_blx && opcode->tencode != do_t_branch23
17013               && !(ARM_CPU_HAS_FEATURE(*opcode->tvariant, arm_ext_msr)
17014                    || ARM_CPU_HAS_FEATURE(*opcode->tvariant, arm_ext_barrier)))
17015             {
17016               /* Two things are addressed here.
17017                  1) Implicit require narrow instructions on Thumb-1.
17018                     This avoids relaxation accidentally introducing Thumb-2
17019                      instructions.
17020                  2) Reject wide instructions in non Thumb-2 cores.  */
17021               if (inst.size_req == 0)
17022                 inst.size_req = 2;
17023               else if (inst.size_req == 4)
17024                 {
17025                   as_bad (_("selected processor does not support Thumb-2 mode `%s'"), str);
17026                   return;
17027                 }
17028             }
17029         }
17030
17031       inst.instruction = opcode->tvalue;
17032
17033       if (!parse_operands (p, opcode->operands, /*thumb=*/TRUE))
17034         {
17035           /* Prepare the it_insn_type for those encodings that don't set
17036              it.  */
17037           it_fsm_pre_encode ();
17038
17039           opcode->tencode ();
17040
17041           it_fsm_post_encode ();
17042         }
17043
17044       if (!(inst.error || inst.relax))
17045         {
17046           gas_assert (inst.instruction < 0xe800 || inst.instruction > 0xffff);
17047           inst.size = (inst.instruction > 0xffff ? 4 : 2);
17048           if (inst.size_req && inst.size_req != inst.size)
17049             {
17050               as_bad (_("cannot honor width suffix -- `%s'"), str);
17051               return;
17052             }
17053         }
17054
17055       /* Something has gone badly wrong if we try to relax a fixed size
17056          instruction.  */
17057       gas_assert (inst.size_req == 0 || !inst.relax);
17058
17059       ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
17060                               *opcode->tvariant);
17061       /* Many Thumb-2 instructions also have Thumb-1 variants, so explicitly
17062          set those bits when Thumb-2 32-bit instructions are seen.  ie.
17063          anything other than bl/blx and v6-M instructions.
17064          This is overly pessimistic for relaxable instructions.  */
17065       if (((inst.size == 4 && (inst.instruction & 0xf800e800) != 0xf000e800)
17066            || inst.relax)
17067           && !(ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_msr)
17068                || ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_barrier)))
17069         ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
17070                                 arm_ext_v6t2);
17071
17072       check_neon_suffixes;
17073
17074       if (!inst.error)
17075         {
17076           mapping_state (MAP_THUMB);
17077         }
17078     }
17079   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
17080     {
17081       bfd_boolean is_bx;
17082
17083       /* bx is allowed on v5 cores, and sometimes on v4 cores.  */
17084       is_bx = (opcode->aencode == do_bx);
17085
17086       /* Check that this instruction is supported for this CPU.  */
17087       if (!(is_bx && fix_v4bx)
17088           && !(opcode->avariant &&
17089                ARM_CPU_HAS_FEATURE (cpu_variant, *opcode->avariant)))
17090         {
17091           as_bad (_("selected processor does not support ARM mode `%s'"), str);
17092           return;
17093         }
17094       if (inst.size_req)
17095         {
17096           as_bad (_("width suffixes are invalid in ARM mode -- `%s'"), str);
17097           return;
17098         }
17099
17100       inst.instruction = opcode->avalue;
17101       if (opcode->tag == OT_unconditionalF)
17102         inst.instruction |= 0xF << 28;
17103       else
17104         inst.instruction |= inst.cond << 28;
17105       inst.size = INSN_SIZE;
17106       if (!parse_operands (p, opcode->operands, /*thumb=*/FALSE))
17107         {
17108           it_fsm_pre_encode ();
17109           opcode->aencode ();
17110           it_fsm_post_encode ();
17111         }
17112       /* Arm mode bx is marked as both v4T and v5 because it's still required
17113          on a hypothetical non-thumb v5 core.  */
17114       if (is_bx)
17115         ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used, arm_ext_v4t);
17116       else
17117         ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used,
17118                                 *opcode->avariant);
17119
17120       check_neon_suffixes;
17121
17122       if (!inst.error)
17123         {
17124           mapping_state (MAP_ARM);
17125         }
17126     }
17127   else
17128     {
17129       as_bad (_("attempt to use an ARM instruction on a Thumb-only processor "
17130                 "-- `%s'"), str);
17131       return;
17132     }
17133   output_inst (str);
17134 }
17135
17136 static void
17137 check_it_blocks_finished (void)
17138 {
17139 #ifdef OBJ_ELF
17140   asection *sect;
17141
17142   for (sect = stdoutput->sections; sect != NULL; sect = sect->next)
17143     if (seg_info (sect)->tc_segment_info_data.current_it.state
17144         == MANUAL_IT_BLOCK)
17145       {
17146         as_warn (_("section '%s' finished with an open IT block."),
17147                  sect->name);
17148       }
17149 #else
17150   if (now_it.state == MANUAL_IT_BLOCK)
17151     as_warn (_("file finished with an open IT block."));
17152 #endif
17153 }
17154
17155 /* Various frobbings of labels and their addresses.  */
17156
17157 void
17158 arm_start_line_hook (void)
17159 {
17160   last_label_seen = NULL;
17161 }
17162
17163 void
17164 arm_frob_label (symbolS * sym)
17165 {
17166   last_label_seen = sym;
17167
17168   ARM_SET_THUMB (sym, thumb_mode);
17169
17170 #if defined OBJ_COFF || defined OBJ_ELF
17171   ARM_SET_INTERWORK (sym, support_interwork);
17172 #endif
17173
17174   force_automatic_it_block_close ();
17175
17176   /* Note - do not allow local symbols (.Lxxx) to be labelled
17177      as Thumb functions.  This is because these labels, whilst
17178      they exist inside Thumb code, are not the entry points for
17179      possible ARM->Thumb calls.  Also, these labels can be used
17180      as part of a computed goto or switch statement.  eg gcc
17181      can generate code that looks like this:
17182
17183                 ldr  r2, [pc, .Laaa]
17184                 lsl  r3, r3, #2
17185                 ldr  r2, [r3, r2]
17186                 mov  pc, r2
17187
17188        .Lbbb:  .word .Lxxx
17189        .Lccc:  .word .Lyyy
17190        ..etc...
17191        .Laaa:   .word Lbbb
17192
17193      The first instruction loads the address of the jump table.
17194      The second instruction converts a table index into a byte offset.
17195      The third instruction gets the jump address out of the table.
17196      The fourth instruction performs the jump.
17197
17198      If the address stored at .Laaa is that of a symbol which has the
17199      Thumb_Func bit set, then the linker will arrange for this address
17200      to have the bottom bit set, which in turn would mean that the
17201      address computation performed by the third instruction would end
17202      up with the bottom bit set.  Since the ARM is capable of unaligned
17203      word loads, the instruction would then load the incorrect address
17204      out of the jump table, and chaos would ensue.  */
17205   if (label_is_thumb_function_name
17206       && (S_GET_NAME (sym)[0] != '.' || S_GET_NAME (sym)[1] != 'L')
17207       && (bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
17208     {
17209       /* When the address of a Thumb function is taken the bottom
17210          bit of that address should be set.  This will allow
17211          interworking between Arm and Thumb functions to work
17212          correctly.  */
17213
17214       THUMB_SET_FUNC (sym, 1);
17215
17216       label_is_thumb_function_name = FALSE;
17217     }
17218
17219   dwarf2_emit_label (sym);
17220 }
17221
17222 bfd_boolean
17223 arm_data_in_code (void)
17224 {
17225   if (thumb_mode && ! strncmp (input_line_pointer + 1, "data:", 5))
17226     {
17227       *input_line_pointer = '/';
17228       input_line_pointer += 5;
17229       *input_line_pointer = 0;
17230       return TRUE;
17231     }
17232
17233   return FALSE;
17234 }
17235
17236 char *
17237 arm_canonicalize_symbol_name (char * name)
17238 {
17239   int len;
17240
17241   if (thumb_mode && (len = strlen (name)) > 5
17242       && streq (name + len - 5, "/data"))
17243     *(name + len - 5) = 0;
17244
17245   return name;
17246 }
17247 \f
17248 /* Table of all register names defined by default.  The user can
17249    define additional names with .req.  Note that all register names
17250    should appear in both upper and lowercase variants.  Some registers
17251    also have mixed-case names.  */
17252
17253 #define REGDEF(s,n,t) { #s, n, REG_TYPE_##t, TRUE, 0 }
17254 #define REGNUM(p,n,t) REGDEF(p##n, n, t)
17255 #define REGNUM2(p,n,t) REGDEF(p##n, 2 * n, t)
17256 #define REGSET(p,t) \
17257   REGNUM(p, 0,t), REGNUM(p, 1,t), REGNUM(p, 2,t), REGNUM(p, 3,t), \
17258   REGNUM(p, 4,t), REGNUM(p, 5,t), REGNUM(p, 6,t), REGNUM(p, 7,t), \
17259   REGNUM(p, 8,t), REGNUM(p, 9,t), REGNUM(p,10,t), REGNUM(p,11,t), \
17260   REGNUM(p,12,t), REGNUM(p,13,t), REGNUM(p,14,t), REGNUM(p,15,t)
17261 #define REGSETH(p,t) \
17262   REGNUM(p,16,t), REGNUM(p,17,t), REGNUM(p,18,t), REGNUM(p,19,t), \
17263   REGNUM(p,20,t), REGNUM(p,21,t), REGNUM(p,22,t), REGNUM(p,23,t), \
17264   REGNUM(p,24,t), REGNUM(p,25,t), REGNUM(p,26,t), REGNUM(p,27,t), \
17265   REGNUM(p,28,t), REGNUM(p,29,t), REGNUM(p,30,t), REGNUM(p,31,t)
17266 #define REGSET2(p,t) \
17267   REGNUM2(p, 0,t), REGNUM2(p, 1,t), REGNUM2(p, 2,t), REGNUM2(p, 3,t), \
17268   REGNUM2(p, 4,t), REGNUM2(p, 5,t), REGNUM2(p, 6,t), REGNUM2(p, 7,t), \
17269   REGNUM2(p, 8,t), REGNUM2(p, 9,t), REGNUM2(p,10,t), REGNUM2(p,11,t), \
17270   REGNUM2(p,12,t), REGNUM2(p,13,t), REGNUM2(p,14,t), REGNUM2(p,15,t)
17271 #define SPLRBANK(base,bank,t) \
17272   REGDEF(lr_##bank, 768|((base+0)<<16), t), \
17273   REGDEF(sp_##bank, 768|((base+1)<<16), t), \
17274   REGDEF(spsr_##bank, 768|(base<<16)|SPSR_BIT, t), \
17275   REGDEF(LR_##bank, 768|((base+0)<<16), t), \
17276   REGDEF(SP_##bank, 768|((base+1)<<16), t), \
17277   REGDEF(SPSR_##bank, 768|(base<<16)|SPSR_BIT, t)
17278
17279 static const struct reg_entry reg_names[] =
17280 {
17281   /* ARM integer registers.  */
17282   REGSET(r, RN), REGSET(R, RN),
17283
17284   /* ATPCS synonyms.  */
17285   REGDEF(a1,0,RN), REGDEF(a2,1,RN), REGDEF(a3, 2,RN), REGDEF(a4, 3,RN),
17286   REGDEF(v1,4,RN), REGDEF(v2,5,RN), REGDEF(v3, 6,RN), REGDEF(v4, 7,RN),
17287   REGDEF(v5,8,RN), REGDEF(v6,9,RN), REGDEF(v7,10,RN), REGDEF(v8,11,RN),
17288
17289   REGDEF(A1,0,RN), REGDEF(A2,1,RN), REGDEF(A3, 2,RN), REGDEF(A4, 3,RN),
17290   REGDEF(V1,4,RN), REGDEF(V2,5,RN), REGDEF(V3, 6,RN), REGDEF(V4, 7,RN),
17291   REGDEF(V5,8,RN), REGDEF(V6,9,RN), REGDEF(V7,10,RN), REGDEF(V8,11,RN),
17292
17293   /* Well-known aliases.  */
17294   REGDEF(wr, 7,RN), REGDEF(sb, 9,RN), REGDEF(sl,10,RN), REGDEF(fp,11,RN),
17295   REGDEF(ip,12,RN), REGDEF(sp,13,RN), REGDEF(lr,14,RN), REGDEF(pc,15,RN),
17296
17297   REGDEF(WR, 7,RN), REGDEF(SB, 9,RN), REGDEF(SL,10,RN), REGDEF(FP,11,RN),
17298   REGDEF(IP,12,RN), REGDEF(SP,13,RN), REGDEF(LR,14,RN), REGDEF(PC,15,RN),
17299
17300   /* Coprocessor numbers.  */
17301   REGSET(p, CP), REGSET(P, CP),
17302
17303   /* Coprocessor register numbers.  The "cr" variants are for backward
17304      compatibility.  */
17305   REGSET(c,  CN), REGSET(C, CN),
17306   REGSET(cr, CN), REGSET(CR, CN),
17307
17308   /* ARM banked registers.  */
17309   REGDEF(R8_usr,512|(0<<16),RNB), REGDEF(r8_usr,512|(0<<16),RNB),
17310   REGDEF(R9_usr,512|(1<<16),RNB), REGDEF(r9_usr,512|(1<<16),RNB),
17311   REGDEF(R10_usr,512|(2<<16),RNB), REGDEF(r10_usr,512|(2<<16),RNB),
17312   REGDEF(R11_usr,512|(3<<16),RNB), REGDEF(r11_usr,512|(3<<16),RNB),
17313   REGDEF(R12_usr,512|(4<<16),RNB), REGDEF(r12_usr,512|(4<<16),RNB),
17314   REGDEF(SP_usr,512|(5<<16),RNB), REGDEF(sp_usr,512|(5<<16),RNB),
17315   REGDEF(LR_usr,512|(6<<16),RNB), REGDEF(lr_usr,512|(6<<16),RNB),
17316
17317   REGDEF(R8_fiq,512|(8<<16),RNB), REGDEF(r8_fiq,512|(8<<16),RNB),
17318   REGDEF(R9_fiq,512|(9<<16),RNB), REGDEF(r9_fiq,512|(9<<16),RNB),
17319   REGDEF(R10_fiq,512|(10<<16),RNB), REGDEF(r10_fiq,512|(10<<16),RNB),
17320   REGDEF(R11_fiq,512|(11<<16),RNB), REGDEF(r11_fiq,512|(11<<16),RNB),
17321   REGDEF(R12_fiq,512|(12<<16),RNB), REGDEF(r12_fiq,512|(12<<16),RNB),
17322   REGDEF(SP_fiq,512|(13<<16),RNB), REGDEF(SP_fiq,512|(13<<16),RNB),
17323   REGDEF(LR_fiq,512|(14<<16),RNB), REGDEF(lr_fiq,512|(14<<16),RNB),
17324   REGDEF(SPSR_fiq,512|(14<<16)|SPSR_BIT,RNB), REGDEF(spsr_fiq,512|(14<<16)|SPSR_BIT,RNB),
17325
17326   SPLRBANK(0,IRQ,RNB), SPLRBANK(0,irq,RNB),
17327   SPLRBANK(2,SVC,RNB), SPLRBANK(2,svc,RNB),
17328   SPLRBANK(4,ABT,RNB), SPLRBANK(4,abt,RNB),
17329   SPLRBANK(6,UND,RNB), SPLRBANK(6,und,RNB),
17330   SPLRBANK(12,MON,RNB), SPLRBANK(12,mon,RNB),
17331   REGDEF(elr_hyp,768|(14<<16),RNB), REGDEF(ELR_hyp,768|(14<<16),RNB),
17332   REGDEF(sp_hyp,768|(15<<16),RNB), REGDEF(SP_hyp,768|(15<<16),RNB),
17333   REGDEF(spsr_hyp,768|(14<<16)|SPSR_BIT,RNB),
17334   REGDEF(SPSR_hyp,768|(14<<16)|SPSR_BIT,RNB),
17335
17336   /* FPA registers.  */
17337   REGNUM(f,0,FN), REGNUM(f,1,FN), REGNUM(f,2,FN), REGNUM(f,3,FN),
17338   REGNUM(f,4,FN), REGNUM(f,5,FN), REGNUM(f,6,FN), REGNUM(f,7, FN),
17339
17340   REGNUM(F,0,FN), REGNUM(F,1,FN), REGNUM(F,2,FN), REGNUM(F,3,FN),
17341   REGNUM(F,4,FN), REGNUM(F,5,FN), REGNUM(F,6,FN), REGNUM(F,7, FN),
17342
17343   /* VFP SP registers.  */
17344   REGSET(s,VFS),  REGSET(S,VFS),
17345   REGSETH(s,VFS), REGSETH(S,VFS),
17346
17347   /* VFP DP Registers.  */
17348   REGSET(d,VFD),  REGSET(D,VFD),
17349   /* Extra Neon DP registers.  */
17350   REGSETH(d,VFD), REGSETH(D,VFD),
17351
17352   /* Neon QP registers.  */
17353   REGSET2(q,NQ),  REGSET2(Q,NQ),
17354
17355   /* VFP control registers.  */
17356   REGDEF(fpsid,0,VFC), REGDEF(fpscr,1,VFC), REGDEF(fpexc,8,VFC),
17357   REGDEF(FPSID,0,VFC), REGDEF(FPSCR,1,VFC), REGDEF(FPEXC,8,VFC),
17358   REGDEF(fpinst,9,VFC), REGDEF(fpinst2,10,VFC),
17359   REGDEF(FPINST,9,VFC), REGDEF(FPINST2,10,VFC),
17360   REGDEF(mvfr0,7,VFC), REGDEF(mvfr1,6,VFC),
17361   REGDEF(MVFR0,7,VFC), REGDEF(MVFR1,6,VFC),
17362
17363   /* Maverick DSP coprocessor registers.  */
17364   REGSET(mvf,MVF),  REGSET(mvd,MVD),  REGSET(mvfx,MVFX),  REGSET(mvdx,MVDX),
17365   REGSET(MVF,MVF),  REGSET(MVD,MVD),  REGSET(MVFX,MVFX),  REGSET(MVDX,MVDX),
17366
17367   REGNUM(mvax,0,MVAX), REGNUM(mvax,1,MVAX),
17368   REGNUM(mvax,2,MVAX), REGNUM(mvax,3,MVAX),
17369   REGDEF(dspsc,0,DSPSC),
17370
17371   REGNUM(MVAX,0,MVAX), REGNUM(MVAX,1,MVAX),
17372   REGNUM(MVAX,2,MVAX), REGNUM(MVAX,3,MVAX),
17373   REGDEF(DSPSC,0,DSPSC),
17374
17375   /* iWMMXt data registers - p0, c0-15.  */
17376   REGSET(wr,MMXWR), REGSET(wR,MMXWR), REGSET(WR, MMXWR),
17377
17378   /* iWMMXt control registers - p1, c0-3.  */
17379   REGDEF(wcid,  0,MMXWC),  REGDEF(wCID,  0,MMXWC),  REGDEF(WCID,  0,MMXWC),
17380   REGDEF(wcon,  1,MMXWC),  REGDEF(wCon,  1,MMXWC),  REGDEF(WCON,  1,MMXWC),
17381   REGDEF(wcssf, 2,MMXWC),  REGDEF(wCSSF, 2,MMXWC),  REGDEF(WCSSF, 2,MMXWC),
17382   REGDEF(wcasf, 3,MMXWC),  REGDEF(wCASF, 3,MMXWC),  REGDEF(WCASF, 3,MMXWC),
17383
17384   /* iWMMXt scalar (constant/offset) registers - p1, c8-11.  */
17385   REGDEF(wcgr0, 8,MMXWCG),  REGDEF(wCGR0, 8,MMXWCG),  REGDEF(WCGR0, 8,MMXWCG),
17386   REGDEF(wcgr1, 9,MMXWCG),  REGDEF(wCGR1, 9,MMXWCG),  REGDEF(WCGR1, 9,MMXWCG),
17387   REGDEF(wcgr2,10,MMXWCG),  REGDEF(wCGR2,10,MMXWCG),  REGDEF(WCGR2,10,MMXWCG),
17388   REGDEF(wcgr3,11,MMXWCG),  REGDEF(wCGR3,11,MMXWCG),  REGDEF(WCGR3,11,MMXWCG),
17389
17390   /* XScale accumulator registers.  */
17391   REGNUM(acc,0,XSCALE), REGNUM(ACC,0,XSCALE),
17392 };
17393 #undef REGDEF
17394 #undef REGNUM
17395 #undef REGSET
17396
17397 /* Table of all PSR suffixes.  Bare "CPSR" and "SPSR" are handled
17398    within psr_required_here.  */
17399 static const struct asm_psr psrs[] =
17400 {
17401   /* Backward compatibility notation.  Note that "all" is no longer
17402      truly all possible PSR bits.  */
17403   {"all",  PSR_c | PSR_f},
17404   {"flg",  PSR_f},
17405   {"ctl",  PSR_c},
17406
17407   /* Individual flags.  */
17408   {"f",    PSR_f},
17409   {"c",    PSR_c},
17410   {"x",    PSR_x},
17411   {"s",    PSR_s},
17412
17413   /* Combinations of flags.  */
17414   {"fs",   PSR_f | PSR_s},
17415   {"fx",   PSR_f | PSR_x},
17416   {"fc",   PSR_f | PSR_c},
17417   {"sf",   PSR_s | PSR_f},
17418   {"sx",   PSR_s | PSR_x},
17419   {"sc",   PSR_s | PSR_c},
17420   {"xf",   PSR_x | PSR_f},
17421   {"xs",   PSR_x | PSR_s},
17422   {"xc",   PSR_x | PSR_c},
17423   {"cf",   PSR_c | PSR_f},
17424   {"cs",   PSR_c | PSR_s},
17425   {"cx",   PSR_c | PSR_x},
17426   {"fsx",  PSR_f | PSR_s | PSR_x},
17427   {"fsc",  PSR_f | PSR_s | PSR_c},
17428   {"fxs",  PSR_f | PSR_x | PSR_s},
17429   {"fxc",  PSR_f | PSR_x | PSR_c},
17430   {"fcs",  PSR_f | PSR_c | PSR_s},
17431   {"fcx",  PSR_f | PSR_c | PSR_x},
17432   {"sfx",  PSR_s | PSR_f | PSR_x},
17433   {"sfc",  PSR_s | PSR_f | PSR_c},
17434   {"sxf",  PSR_s | PSR_x | PSR_f},
17435   {"sxc",  PSR_s | PSR_x | PSR_c},
17436   {"scf",  PSR_s | PSR_c | PSR_f},
17437   {"scx",  PSR_s | PSR_c | PSR_x},
17438   {"xfs",  PSR_x | PSR_f | PSR_s},
17439   {"xfc",  PSR_x | PSR_f | PSR_c},
17440   {"xsf",  PSR_x | PSR_s | PSR_f},
17441   {"xsc",  PSR_x | PSR_s | PSR_c},
17442   {"xcf",  PSR_x | PSR_c | PSR_f},
17443   {"xcs",  PSR_x | PSR_c | PSR_s},
17444   {"cfs",  PSR_c | PSR_f | PSR_s},
17445   {"cfx",  PSR_c | PSR_f | PSR_x},
17446   {"csf",  PSR_c | PSR_s | PSR_f},
17447   {"csx",  PSR_c | PSR_s | PSR_x},
17448   {"cxf",  PSR_c | PSR_x | PSR_f},
17449   {"cxs",  PSR_c | PSR_x | PSR_s},
17450   {"fsxc", PSR_f | PSR_s | PSR_x | PSR_c},
17451   {"fscx", PSR_f | PSR_s | PSR_c | PSR_x},
17452   {"fxsc", PSR_f | PSR_x | PSR_s | PSR_c},
17453   {"fxcs", PSR_f | PSR_x | PSR_c | PSR_s},
17454   {"fcsx", PSR_f | PSR_c | PSR_s | PSR_x},
17455   {"fcxs", PSR_f | PSR_c | PSR_x | PSR_s},
17456   {"sfxc", PSR_s | PSR_f | PSR_x | PSR_c},
17457   {"sfcx", PSR_s | PSR_f | PSR_c | PSR_x},
17458   {"sxfc", PSR_s | PSR_x | PSR_f | PSR_c},
17459   {"sxcf", PSR_s | PSR_x | PSR_c | PSR_f},
17460   {"scfx", PSR_s | PSR_c | PSR_f | PSR_x},
17461   {"scxf", PSR_s | PSR_c | PSR_x | PSR_f},
17462   {"xfsc", PSR_x | PSR_f | PSR_s | PSR_c},
17463   {"xfcs", PSR_x | PSR_f | PSR_c | PSR_s},
17464   {"xsfc", PSR_x | PSR_s | PSR_f | PSR_c},
17465   {"xscf", PSR_x | PSR_s | PSR_c | PSR_f},
17466   {"xcfs", PSR_x | PSR_c | PSR_f | PSR_s},
17467   {"xcsf", PSR_x | PSR_c | PSR_s | PSR_f},
17468   {"cfsx", PSR_c | PSR_f | PSR_s | PSR_x},
17469   {"cfxs", PSR_c | PSR_f | PSR_x | PSR_s},
17470   {"csfx", PSR_c | PSR_s | PSR_f | PSR_x},
17471   {"csxf", PSR_c | PSR_s | PSR_x | PSR_f},
17472   {"cxfs", PSR_c | PSR_x | PSR_f | PSR_s},
17473   {"cxsf", PSR_c | PSR_x | PSR_s | PSR_f},
17474 };
17475
17476 /* Table of V7M psr names.  */
17477 static const struct asm_psr v7m_psrs[] =
17478 {
17479   {"apsr",        0 }, {"APSR",         0 },
17480   {"iapsr",       1 }, {"IAPSR",        1 },
17481   {"eapsr",       2 }, {"EAPSR",        2 },
17482   {"psr",         3 }, {"PSR",          3 },
17483   {"xpsr",        3 }, {"XPSR",         3 }, {"xPSR",     3 },
17484   {"ipsr",        5 }, {"IPSR",         5 },
17485   {"epsr",        6 }, {"EPSR",         6 },
17486   {"iepsr",       7 }, {"IEPSR",        7 },
17487   {"msp",         8 }, {"MSP",          8 },
17488   {"psp",         9 }, {"PSP",          9 },
17489   {"primask",     16}, {"PRIMASK",      16},
17490   {"basepri",     17}, {"BASEPRI",      17},
17491   {"basepri_max", 18}, {"BASEPRI_MAX",  18},
17492   {"basepri_max", 18}, {"BASEPRI_MASK", 18}, /* Typo, preserved for backwards compatibility.  */
17493   {"faultmask",   19}, {"FAULTMASK",    19},
17494   {"control",     20}, {"CONTROL",      20}
17495 };
17496
17497 /* Table of all shift-in-operand names.  */
17498 static const struct asm_shift_name shift_names [] =
17499 {
17500   { "asl", SHIFT_LSL },  { "ASL", SHIFT_LSL },
17501   { "lsl", SHIFT_LSL },  { "LSL", SHIFT_LSL },
17502   { "lsr", SHIFT_LSR },  { "LSR", SHIFT_LSR },
17503   { "asr", SHIFT_ASR },  { "ASR", SHIFT_ASR },
17504   { "ror", SHIFT_ROR },  { "ROR", SHIFT_ROR },
17505   { "rrx", SHIFT_RRX },  { "RRX", SHIFT_RRX }
17506 };
17507
17508 /* Table of all explicit relocation names.  */
17509 #ifdef OBJ_ELF
17510 static struct reloc_entry reloc_names[] =
17511 {
17512   { "got",     BFD_RELOC_ARM_GOT32   },  { "GOT",     BFD_RELOC_ARM_GOT32   },
17513   { "gotoff",  BFD_RELOC_ARM_GOTOFF  },  { "GOTOFF",  BFD_RELOC_ARM_GOTOFF  },
17514   { "plt",     BFD_RELOC_ARM_PLT32   },  { "PLT",     BFD_RELOC_ARM_PLT32   },
17515   { "target1", BFD_RELOC_ARM_TARGET1 },  { "TARGET1", BFD_RELOC_ARM_TARGET1 },
17516   { "target2", BFD_RELOC_ARM_TARGET2 },  { "TARGET2", BFD_RELOC_ARM_TARGET2 },
17517   { "sbrel",   BFD_RELOC_ARM_SBREL32 },  { "SBREL",   BFD_RELOC_ARM_SBREL32 },
17518   { "tlsgd",   BFD_RELOC_ARM_TLS_GD32},  { "TLSGD",   BFD_RELOC_ARM_TLS_GD32},
17519   { "tlsldm",  BFD_RELOC_ARM_TLS_LDM32}, { "TLSLDM",  BFD_RELOC_ARM_TLS_LDM32},
17520   { "tlsldo",  BFD_RELOC_ARM_TLS_LDO32}, { "TLSLDO",  BFD_RELOC_ARM_TLS_LDO32},
17521   { "gottpoff",BFD_RELOC_ARM_TLS_IE32},  { "GOTTPOFF",BFD_RELOC_ARM_TLS_IE32},
17522   { "tpoff",   BFD_RELOC_ARM_TLS_LE32},  { "TPOFF",   BFD_RELOC_ARM_TLS_LE32},
17523   { "got_prel", BFD_RELOC_ARM_GOT_PREL}, { "GOT_PREL", BFD_RELOC_ARM_GOT_PREL},
17524   { "tlsdesc", BFD_RELOC_ARM_TLS_GOTDESC},
17525         { "TLSDESC", BFD_RELOC_ARM_TLS_GOTDESC},
17526   { "tlscall", BFD_RELOC_ARM_TLS_CALL},
17527         { "TLSCALL", BFD_RELOC_ARM_TLS_CALL},
17528   { "tlsdescseq", BFD_RELOC_ARM_TLS_DESCSEQ},
17529         { "TLSDESCSEQ", BFD_RELOC_ARM_TLS_DESCSEQ}
17530 };
17531 #endif
17532
17533 /* Table of all conditional affixes.  0xF is not defined as a condition code.  */
17534 static const struct asm_cond conds[] =
17535 {
17536   {"eq", 0x0},
17537   {"ne", 0x1},
17538   {"cs", 0x2}, {"hs", 0x2},
17539   {"cc", 0x3}, {"ul", 0x3}, {"lo", 0x3},
17540   {"mi", 0x4},
17541   {"pl", 0x5},
17542   {"vs", 0x6},
17543   {"vc", 0x7},
17544   {"hi", 0x8},
17545   {"ls", 0x9},
17546   {"ge", 0xa},
17547   {"lt", 0xb},
17548   {"gt", 0xc},
17549   {"le", 0xd},
17550   {"al", 0xe}
17551 };
17552
17553 #define UL_BARRIER(L,U,CODE,FEAT) \
17554   { L, CODE, ARM_FEATURE (FEAT, 0) }, \
17555   { U, CODE, ARM_FEATURE (FEAT, 0) }
17556
17557 static struct asm_barrier_opt barrier_opt_names[] =
17558 {
17559   UL_BARRIER ("sy",     "SY",    0xf, ARM_EXT_BARRIER),
17560   UL_BARRIER ("st",     "ST",    0xe, ARM_EXT_BARRIER),
17561   UL_BARRIER ("ld",     "LD",    0xd, ARM_EXT_V8),
17562   UL_BARRIER ("ish",    "ISH",   0xb, ARM_EXT_BARRIER),
17563   UL_BARRIER ("sh",     "SH",    0xb, ARM_EXT_BARRIER),
17564   UL_BARRIER ("ishst",  "ISHST", 0xa, ARM_EXT_BARRIER),
17565   UL_BARRIER ("shst",   "SHST",  0xa, ARM_EXT_BARRIER),
17566   UL_BARRIER ("ishld",  "ISHLD", 0x9, ARM_EXT_V8),
17567   UL_BARRIER ("un",     "UN",    0x7, ARM_EXT_BARRIER),
17568   UL_BARRIER ("nsh",    "NSH",   0x7, ARM_EXT_BARRIER),
17569   UL_BARRIER ("unst",   "UNST",  0x6, ARM_EXT_BARRIER),
17570   UL_BARRIER ("nshst",  "NSHST", 0x6, ARM_EXT_BARRIER),
17571   UL_BARRIER ("nshld",  "NSHLD", 0x5, ARM_EXT_V8),
17572   UL_BARRIER ("osh",    "OSH",   0x3, ARM_EXT_BARRIER),
17573   UL_BARRIER ("oshst",  "OSHST", 0x2, ARM_EXT_BARRIER),
17574   UL_BARRIER ("oshld",  "OSHLD", 0x1, ARM_EXT_V8)
17575 };
17576
17577 #undef UL_BARRIER
17578
17579 /* Table of ARM-format instructions.    */
17580
17581 /* Macros for gluing together operand strings.  N.B. In all cases
17582    other than OPS0, the trailing OP_stop comes from default
17583    zero-initialization of the unspecified elements of the array.  */
17584 #define OPS0()            { OP_stop, }
17585 #define OPS1(a)           { OP_##a, }
17586 #define OPS2(a,b)         { OP_##a,OP_##b, }
17587 #define OPS3(a,b,c)       { OP_##a,OP_##b,OP_##c, }
17588 #define OPS4(a,b,c,d)     { OP_##a,OP_##b,OP_##c,OP_##d, }
17589 #define OPS5(a,b,c,d,e)   { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e, }
17590 #define OPS6(a,b,c,d,e,f) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e,OP_##f, }
17591
17592 /* These macros are similar to the OPSn, but do not prepend the OP_ prefix.
17593    This is useful when mixing operands for ARM and THUMB, i.e. using the
17594    MIX_ARM_THUMB_OPERANDS macro.
17595    In order to use these macros, prefix the number of operands with _
17596    e.g. _3.  */
17597 #define OPS_1(a)           { a, }
17598 #define OPS_2(a,b)         { a,b, }
17599 #define OPS_3(a,b,c)       { a,b,c, }
17600 #define OPS_4(a,b,c,d)     { a,b,c,d, }
17601 #define OPS_5(a,b,c,d,e)   { a,b,c,d,e, }
17602 #define OPS_6(a,b,c,d,e,f) { a,b,c,d,e,f, }
17603
17604 /* These macros abstract out the exact format of the mnemonic table and
17605    save some repeated characters.  */
17606
17607 /* The normal sort of mnemonic; has a Thumb variant; takes a conditional suffix.  */
17608 #define TxCE(mnem, op, top, nops, ops, ae, te) \
17609   { mnem, OPS##nops ops, OT_csuffix, 0x##op, top, ARM_VARIANT, \
17610     THUMB_VARIANT, do_##ae, do_##te }
17611
17612 /* Two variants of the above - TCE for a numeric Thumb opcode, tCE for
17613    a T_MNEM_xyz enumerator.  */
17614 #define TCE(mnem, aop, top, nops, ops, ae, te) \
17615       TxCE (mnem, aop, 0x##top, nops, ops, ae, te)
17616 #define tCE(mnem, aop, top, nops, ops, ae, te) \
17617       TxCE (mnem, aop, T_MNEM##top, nops, ops, ae, te)
17618
17619 /* Second most common sort of mnemonic: has a Thumb variant, takes a conditional
17620    infix after the third character.  */
17621 #define TxC3(mnem, op, top, nops, ops, ae, te) \
17622   { mnem, OPS##nops ops, OT_cinfix3, 0x##op, top, ARM_VARIANT, \
17623     THUMB_VARIANT, do_##ae, do_##te }
17624 #define TxC3w(mnem, op, top, nops, ops, ae, te) \
17625   { mnem, OPS##nops ops, OT_cinfix3_deprecated, 0x##op, top, ARM_VARIANT, \
17626     THUMB_VARIANT, do_##ae, do_##te }
17627 #define TC3(mnem, aop, top, nops, ops, ae, te) \
17628       TxC3 (mnem, aop, 0x##top, nops, ops, ae, te)
17629 #define TC3w(mnem, aop, top, nops, ops, ae, te) \
17630       TxC3w (mnem, aop, 0x##top, nops, ops, ae, te)
17631 #define tC3(mnem, aop, top, nops, ops, ae, te) \
17632       TxC3 (mnem, aop, T_MNEM##top, nops, ops, ae, te)
17633 #define tC3w(mnem, aop, top, nops, ops, ae, te) \
17634       TxC3w (mnem, aop, T_MNEM##top, nops, ops, ae, te)
17635
17636 /* Mnemonic with a conditional infix in an unusual place.  Each and every variant has to
17637    appear in the condition table.  */
17638 #define TxCM_(m1, m2, m3, op, top, nops, ops, ae, te)   \
17639   { m1 #m2 m3, OPS##nops ops, sizeof (#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof (m1) - 1, \
17640     0x##op, top, ARM_VARIANT, THUMB_VARIANT, do_##ae, do_##te }
17641
17642 #define TxCM(m1, m2, op, top, nops, ops, ae, te)        \
17643   TxCM_ (m1,   , m2, op, top, nops, ops, ae, te),       \
17644   TxCM_ (m1, eq, m2, op, top, nops, ops, ae, te),       \
17645   TxCM_ (m1, ne, m2, op, top, nops, ops, ae, te),       \
17646   TxCM_ (m1, cs, m2, op, top, nops, ops, ae, te),       \
17647   TxCM_ (m1, hs, m2, op, top, nops, ops, ae, te),       \
17648   TxCM_ (m1, cc, m2, op, top, nops, ops, ae, te),       \
17649   TxCM_ (m1, ul, m2, op, top, nops, ops, ae, te),       \
17650   TxCM_ (m1, lo, m2, op, top, nops, ops, ae, te),       \
17651   TxCM_ (m1, mi, m2, op, top, nops, ops, ae, te),       \
17652   TxCM_ (m1, pl, m2, op, top, nops, ops, ae, te),       \
17653   TxCM_ (m1, vs, m2, op, top, nops, ops, ae, te),       \
17654   TxCM_ (m1, vc, m2, op, top, nops, ops, ae, te),       \
17655   TxCM_ (m1, hi, m2, op, top, nops, ops, ae, te),       \
17656   TxCM_ (m1, ls, m2, op, top, nops, ops, ae, te),       \
17657   TxCM_ (m1, ge, m2, op, top, nops, ops, ae, te),       \
17658   TxCM_ (m1, lt, m2, op, top, nops, ops, ae, te),       \
17659   TxCM_ (m1, gt, m2, op, top, nops, ops, ae, te),       \
17660   TxCM_ (m1, le, m2, op, top, nops, ops, ae, te),       \
17661   TxCM_ (m1, al, m2, op, top, nops, ops, ae, te)
17662
17663 #define TCM(m1,m2, aop, top, nops, ops, ae, te)         \
17664       TxCM (m1,m2, aop, 0x##top, nops, ops, ae, te)
17665 #define tCM(m1,m2, aop, top, nops, ops, ae, te)         \
17666       TxCM (m1,m2, aop, T_MNEM##top, nops, ops, ae, te)
17667
17668 /* Mnemonic that cannot be conditionalized.  The ARM condition-code
17669    field is still 0xE.  Many of the Thumb variants can be executed
17670    conditionally, so this is checked separately.  */
17671 #define TUE(mnem, op, top, nops, ops, ae, te)                           \
17672   { mnem, OPS##nops ops, OT_unconditional, 0x##op, 0x##top, ARM_VARIANT, \
17673     THUMB_VARIANT, do_##ae, do_##te }
17674
17675 /* Mnemonic that cannot be conditionalized, and bears 0xF in its ARM
17676    condition code field.  */
17677 #define TUF(mnem, op, top, nops, ops, ae, te)                           \
17678   { mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##top, ARM_VARIANT, \
17679     THUMB_VARIANT, do_##ae, do_##te }
17680
17681 /* ARM-only variants of all the above.  */
17682 #define CE(mnem,  op, nops, ops, ae)    \
17683   { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
17684
17685 #define C3(mnem, op, nops, ops, ae)     \
17686   { #mnem, OPS##nops ops, OT_cinfix3, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
17687
17688 /* Legacy mnemonics that always have conditional infix after the third
17689    character.  */
17690 #define CL(mnem, op, nops, ops, ae)     \
17691   { mnem, OPS##nops ops, OT_cinfix3_legacy, \
17692     0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
17693
17694 /* Coprocessor instructions.  Isomorphic between Arm and Thumb-2.  */
17695 #define cCE(mnem,  op, nops, ops, ae)   \
17696   { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
17697
17698 /* Legacy coprocessor instructions where conditional infix and conditional
17699    suffix are ambiguous.  For consistency this includes all FPA instructions,
17700    not just the potentially ambiguous ones.  */
17701 #define cCL(mnem, op, nops, ops, ae)    \
17702   { mnem, OPS##nops ops, OT_cinfix3_legacy, \
17703     0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
17704
17705 /* Coprocessor, takes either a suffix or a position-3 infix
17706    (for an FPA corner case). */
17707 #define C3E(mnem, op, nops, ops, ae) \
17708   { mnem, OPS##nops ops, OT_csuf_or_in3, \
17709     0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
17710
17711 #define xCM_(m1, m2, m3, op, nops, ops, ae)     \
17712   { m1 #m2 m3, OPS##nops ops, \
17713     sizeof (#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof (m1) - 1, \
17714     0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
17715
17716 #define CM(m1, m2, op, nops, ops, ae)   \
17717   xCM_ (m1,   , m2, op, nops, ops, ae), \
17718   xCM_ (m1, eq, m2, op, nops, ops, ae), \
17719   xCM_ (m1, ne, m2, op, nops, ops, ae), \
17720   xCM_ (m1, cs, m2, op, nops, ops, ae), \
17721   xCM_ (m1, hs, m2, op, nops, ops, ae), \
17722   xCM_ (m1, cc, m2, op, nops, ops, ae), \
17723   xCM_ (m1, ul, m2, op, nops, ops, ae), \
17724   xCM_ (m1, lo, m2, op, nops, ops, ae), \
17725   xCM_ (m1, mi, m2, op, nops, ops, ae), \
17726   xCM_ (m1, pl, m2, op, nops, ops, ae), \
17727   xCM_ (m1, vs, m2, op, nops, ops, ae), \
17728   xCM_ (m1, vc, m2, op, nops, ops, ae), \
17729   xCM_ (m1, hi, m2, op, nops, ops, ae), \
17730   xCM_ (m1, ls, m2, op, nops, ops, ae), \
17731   xCM_ (m1, ge, m2, op, nops, ops, ae), \
17732   xCM_ (m1, lt, m2, op, nops, ops, ae), \
17733   xCM_ (m1, gt, m2, op, nops, ops, ae), \
17734   xCM_ (m1, le, m2, op, nops, ops, ae), \
17735   xCM_ (m1, al, m2, op, nops, ops, ae)
17736
17737 #define UE(mnem, op, nops, ops, ae)     \
17738   { #mnem, OPS##nops ops, OT_unconditional, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
17739
17740 #define UF(mnem, op, nops, ops, ae)     \
17741   { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
17742
17743 /* Neon data-processing. ARM versions are unconditional with cond=0xf.
17744    The Thumb and ARM variants are mostly the same (bits 0-23 and 24/28), so we
17745    use the same encoding function for each.  */
17746 #define NUF(mnem, op, nops, ops, enc)                                   \
17747   { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##op,            \
17748     ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
17749
17750 /* Neon data processing, version which indirects through neon_enc_tab for
17751    the various overloaded versions of opcodes.  */
17752 #define nUF(mnem, op, nops, ops, enc)                                   \
17753   { #mnem, OPS##nops ops, OT_unconditionalF, N_MNEM##op, N_MNEM##op,    \
17754     ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
17755
17756 /* Neon insn with conditional suffix for the ARM version, non-overloaded
17757    version.  */
17758 #define NCE_tag(mnem, op, nops, ops, enc, tag)                          \
17759   { #mnem, OPS##nops ops, tag, 0x##op, 0x##op, ARM_VARIANT,             \
17760     THUMB_VARIANT, do_##enc, do_##enc }
17761
17762 #define NCE(mnem, op, nops, ops, enc)                                   \
17763    NCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
17764
17765 #define NCEF(mnem, op, nops, ops, enc)                                  \
17766     NCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
17767
17768 /* Neon insn with conditional suffix for the ARM version, overloaded types.  */
17769 #define nCE_tag(mnem, op, nops, ops, enc, tag)                          \
17770   { #mnem, OPS##nops ops, tag, N_MNEM##op, N_MNEM##op,          \
17771     ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
17772
17773 #define nCE(mnem, op, nops, ops, enc)                                   \
17774    nCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
17775
17776 #define nCEF(mnem, op, nops, ops, enc)                                  \
17777     nCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
17778
17779 #define do_0 0
17780
17781 static const struct asm_opcode insns[] =
17782 {
17783 #define ARM_VARIANT &arm_ext_v1 /* Core ARM Instructions.  */
17784 #define THUMB_VARIANT &arm_ext_v4t
17785  tCE("and",     0000000, _and,     3, (RR, oRR, SH), arit, t_arit3c),
17786  tC3("ands",    0100000, _ands,    3, (RR, oRR, SH), arit, t_arit3c),
17787  tCE("eor",     0200000, _eor,     3, (RR, oRR, SH), arit, t_arit3c),
17788  tC3("eors",    0300000, _eors,    3, (RR, oRR, SH), arit, t_arit3c),
17789  tCE("sub",     0400000, _sub,     3, (RR, oRR, SH), arit, t_add_sub),
17790  tC3("subs",    0500000, _subs,    3, (RR, oRR, SH), arit, t_add_sub),
17791  tCE("add",     0800000, _add,     3, (RR, oRR, SHG), arit, t_add_sub),
17792  tC3("adds",    0900000, _adds,    3, (RR, oRR, SHG), arit, t_add_sub),
17793  tCE("adc",     0a00000, _adc,     3, (RR, oRR, SH), arit, t_arit3c),
17794  tC3("adcs",    0b00000, _adcs,    3, (RR, oRR, SH), arit, t_arit3c),
17795  tCE("sbc",     0c00000, _sbc,     3, (RR, oRR, SH), arit, t_arit3),
17796  tC3("sbcs",    0d00000, _sbcs,    3, (RR, oRR, SH), arit, t_arit3),
17797  tCE("orr",     1800000, _orr,     3, (RR, oRR, SH), arit, t_arit3c),
17798  tC3("orrs",    1900000, _orrs,    3, (RR, oRR, SH), arit, t_arit3c),
17799  tCE("bic",     1c00000, _bic,     3, (RR, oRR, SH), arit, t_arit3),
17800  tC3("bics",    1d00000, _bics,    3, (RR, oRR, SH), arit, t_arit3),
17801
17802  /* The p-variants of tst/cmp/cmn/teq (below) are the pre-V6 mechanism
17803     for setting PSR flag bits.  They are obsolete in V6 and do not
17804     have Thumb equivalents. */
17805  tCE("tst",     1100000, _tst,     2, (RR, SH),      cmp,  t_mvn_tst),
17806  tC3w("tsts",   1100000, _tst,     2, (RR, SH),      cmp,  t_mvn_tst),
17807   CL("tstp",    110f000,           2, (RR, SH),      cmp),
17808  tCE("cmp",     1500000, _cmp,     2, (RR, SH),      cmp,  t_mov_cmp),
17809  tC3w("cmps",   1500000, _cmp,     2, (RR, SH),      cmp,  t_mov_cmp),
17810   CL("cmpp",    150f000,           2, (RR, SH),      cmp),
17811  tCE("cmn",     1700000, _cmn,     2, (RR, SH),      cmp,  t_mvn_tst),
17812  tC3w("cmns",   1700000, _cmn,     2, (RR, SH),      cmp,  t_mvn_tst),
17813   CL("cmnp",    170f000,           2, (RR, SH),      cmp),
17814
17815  tCE("mov",     1a00000, _mov,     2, (RR, SH),      mov,  t_mov_cmp),
17816  tC3("movs",    1b00000, _movs,    2, (RR, SH),      mov,  t_mov_cmp),
17817  tCE("mvn",     1e00000, _mvn,     2, (RR, SH),      mov,  t_mvn_tst),
17818  tC3("mvns",    1f00000, _mvns,    2, (RR, SH),      mov,  t_mvn_tst),
17819
17820  tCE("ldr",     4100000, _ldr,     2, (RR, ADDRGLDR),ldst, t_ldst),
17821  tC3("ldrb",    4500000, _ldrb,    2, (RRnpc_npcsp, ADDRGLDR),ldst, t_ldst),
17822  tCE("str",     4000000, _str,     _2, (MIX_ARM_THUMB_OPERANDS (OP_RR,
17823                                                                 OP_RRnpc),
17824                                         OP_ADDRGLDR),ldst, t_ldst),
17825  tC3("strb",    4400000, _strb,    2, (RRnpc_npcsp, ADDRGLDR),ldst, t_ldst),
17826
17827  tCE("stm",     8800000, _stmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17828  tC3("stmia",   8800000, _stmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17829  tC3("stmea",   8800000, _stmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17830  tCE("ldm",     8900000, _ldmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17831  tC3("ldmia",   8900000, _ldmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17832  tC3("ldmfd",   8900000, _ldmia,    2, (RRw, REGLST), ldmstm, t_ldmstm),
17833
17834  TCE("swi",     f000000, df00,     1, (EXPi),        swi, t_swi),
17835  TCE("svc",     f000000, df00,     1, (EXPi),        swi, t_swi),
17836  tCE("b",       a000000, _b,       1, (EXPr),        branch, t_branch),
17837  TCE("bl",      b000000, f000f800, 1, (EXPr),        bl, t_branch23),
17838
17839   /* Pseudo ops.  */
17840  tCE("adr",     28f0000, _adr,     2, (RR, EXP),     adr,  t_adr),
17841   C3(adrl,      28f0000,           2, (RR, EXP),     adrl),
17842  tCE("nop",     1a00000, _nop,     1, (oI255c),      nop,  t_nop),
17843
17844   /* Thumb-compatibility pseudo ops.  */
17845  tCE("lsl",     1a00000, _lsl,     3, (RR, oRR, SH), shift, t_shift),
17846  tC3("lsls",    1b00000, _lsls,    3, (RR, oRR, SH), shift, t_shift),
17847  tCE("lsr",     1a00020, _lsr,     3, (RR, oRR, SH), shift, t_shift),
17848  tC3("lsrs",    1b00020, _lsrs,    3, (RR, oRR, SH), shift, t_shift),
17849  tCE("asr",     1a00040, _asr,     3, (RR, oRR, SH), shift, t_shift),
17850  tC3("asrs",      1b00040, _asrs,     3, (RR, oRR, SH), shift, t_shift),
17851  tCE("ror",     1a00060, _ror,     3, (RR, oRR, SH), shift, t_shift),
17852  tC3("rors",    1b00060, _rors,    3, (RR, oRR, SH), shift, t_shift),
17853  tCE("neg",     2600000, _neg,     2, (RR, RR),      rd_rn, t_neg),
17854  tC3("negs",    2700000, _negs,    2, (RR, RR),      rd_rn, t_neg),
17855  tCE("push",    92d0000, _push,     1, (REGLST),             push_pop, t_push_pop),
17856  tCE("pop",     8bd0000, _pop,     1, (REGLST),      push_pop, t_push_pop),
17857
17858  /* These may simplify to neg.  */
17859  TCE("rsb",     0600000, ebc00000, 3, (RR, oRR, SH), arit, t_rsb),
17860  TC3("rsbs",    0700000, ebd00000, 3, (RR, oRR, SH), arit, t_rsb),
17861
17862 #undef  THUMB_VARIANT
17863 #define THUMB_VARIANT  & arm_ext_v6
17864
17865  TCE("cpy",       1a00000, 4600,     2, (RR, RR),      rd_rm, t_cpy),
17866
17867  /* V1 instructions with no Thumb analogue prior to V6T2.  */
17868 #undef  THUMB_VARIANT
17869 #define THUMB_VARIANT  & arm_ext_v6t2
17870
17871  TCE("teq",     1300000, ea900f00, 2, (RR, SH),      cmp,  t_mvn_tst),
17872  TC3w("teqs",   1300000, ea900f00, 2, (RR, SH),      cmp,  t_mvn_tst),
17873   CL("teqp",    130f000,           2, (RR, SH),      cmp),
17874
17875  TC3("ldrt",    4300000, f8500e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
17876  TC3("ldrbt",   4700000, f8100e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
17877  TC3("strt",    4200000, f8400e00, 2, (RR_npcsp, ADDR),   ldstt, t_ldstt),
17878  TC3("strbt",   4600000, f8000e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
17879
17880  TC3("stmdb",   9000000, e9000000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
17881  TC3("stmfd",     9000000, e9000000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
17882
17883  TC3("ldmdb",   9100000, e9100000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
17884  TC3("ldmea",   9100000, e9100000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
17885
17886  /* V1 instructions with no Thumb analogue at all.  */
17887   CE("rsc",     0e00000,           3, (RR, oRR, SH), arit),
17888   C3(rscs,      0f00000,           3, (RR, oRR, SH), arit),
17889
17890   C3(stmib,     9800000,           2, (RRw, REGLST), ldmstm),
17891   C3(stmfa,     9800000,           2, (RRw, REGLST), ldmstm),
17892   C3(stmda,     8000000,           2, (RRw, REGLST), ldmstm),
17893   C3(stmed,     8000000,           2, (RRw, REGLST), ldmstm),
17894   C3(ldmib,     9900000,           2, (RRw, REGLST), ldmstm),
17895   C3(ldmed,     9900000,           2, (RRw, REGLST), ldmstm),
17896   C3(ldmda,     8100000,           2, (RRw, REGLST), ldmstm),
17897   C3(ldmfa,     8100000,           2, (RRw, REGLST), ldmstm),
17898
17899 #undef  ARM_VARIANT
17900 #define ARM_VARIANT    & arm_ext_v2     /* ARM 2 - multiplies.  */
17901 #undef  THUMB_VARIANT
17902 #define THUMB_VARIANT  & arm_ext_v4t
17903
17904  tCE("mul",     0000090, _mul,     3, (RRnpc, RRnpc, oRR), mul, t_mul),
17905  tC3("muls",    0100090, _muls,    3, (RRnpc, RRnpc, oRR), mul, t_mul),
17906
17907 #undef  THUMB_VARIANT
17908 #define THUMB_VARIANT  & arm_ext_v6t2
17909
17910  TCE("mla",     0200090, fb000000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas, t_mla),
17911   C3(mlas,      0300090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas),
17912
17913   /* Generic coprocessor instructions.  */
17914  TCE("cdp",     e000000, ee000000, 6, (RCP, I15b, RCN, RCN, RCN, oI7b), cdp,    cdp),
17915  TCE("ldc",     c100000, ec100000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17916  TC3("ldcl",    c500000, ec500000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17917  TCE("stc",     c000000, ec000000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17918  TC3("stcl",    c400000, ec400000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17919  TCE("mcr",     e000010, ee000010, 6, (RCP, I7b, RR, RCN, RCN, oI7b),   co_reg, co_reg),
17920  TCE("mrc",     e100010, ee100010, 6, (RCP, I7b, APSR_RR, RCN, RCN, oI7b),   co_reg, co_reg),
17921
17922 #undef  ARM_VARIANT
17923 #define ARM_VARIANT  & arm_ext_v2s /* ARM 3 - swp instructions.  */
17924
17925   CE("swp",     1000090,           3, (RRnpc, RRnpc, RRnpcb), rd_rm_rn),
17926   C3(swpb,      1400090,           3, (RRnpc, RRnpc, RRnpcb), rd_rm_rn),
17927
17928 #undef  ARM_VARIANT
17929 #define ARM_VARIANT    & arm_ext_v3     /* ARM 6 Status register instructions.  */
17930 #undef  THUMB_VARIANT
17931 #define THUMB_VARIANT  & arm_ext_msr
17932
17933  TCE("mrs",     1000000, f3e08000, 2, (RRnpc, rPSR), mrs, t_mrs),
17934  TCE("msr",     120f000, f3808000, 2, (wPSR, RR_EXi), msr, t_msr),
17935
17936 #undef  ARM_VARIANT
17937 #define ARM_VARIANT    & arm_ext_v3m     /* ARM 7M long multiplies.  */
17938 #undef  THUMB_VARIANT
17939 #define THUMB_VARIANT  & arm_ext_v6t2
17940
17941  TCE("smull",   0c00090, fb800000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
17942   CM("smull","s",       0d00090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
17943  TCE("umull",   0800090, fba00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
17944   CM("umull","s",       0900090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
17945  TCE("smlal",   0e00090, fbc00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
17946   CM("smlal","s",       0f00090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
17947  TCE("umlal",   0a00090, fbe00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
17948   CM("umlal","s",       0b00090,           4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
17949
17950 #undef  ARM_VARIANT
17951 #define ARM_VARIANT    & arm_ext_v4     /* ARM Architecture 4.  */
17952 #undef  THUMB_VARIANT
17953 #define THUMB_VARIANT  & arm_ext_v4t
17954
17955  tC3("ldrh",    01000b0, _ldrh,     2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17956  tC3("strh",    00000b0, _strh,     2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17957  tC3("ldrsh",   01000f0, _ldrsh,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17958  tC3("ldrsb",   01000d0, _ldrsb,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17959  tCM("ld","sh", 01000f0, _ldrsh,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17960  tCM("ld","sb", 01000d0, _ldrsb,    2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
17961
17962 #undef  ARM_VARIANT
17963 #define ARM_VARIANT  & arm_ext_v4t_5
17964
17965   /* ARM Architecture 4T.  */
17966   /* Note: bx (and blx) are required on V5, even if the processor does
17967      not support Thumb.  */
17968  TCE("bx",      12fff10, 4700, 1, (RR), bx, t_bx),
17969
17970 #undef  ARM_VARIANT
17971 #define ARM_VARIANT    & arm_ext_v5 /*  ARM Architecture 5T.     */
17972 #undef  THUMB_VARIANT
17973 #define THUMB_VARIANT  & arm_ext_v5t
17974
17975   /* Note: blx has 2 variants; the .value coded here is for
17976      BLX(2).  Only this variant has conditional execution.  */
17977  TCE("blx",     12fff30, 4780, 1, (RR_EXr),                         blx,  t_blx),
17978  TUE("bkpt",    1200070, be00, 1, (oIffffb),                        bkpt, t_bkpt),
17979
17980 #undef  THUMB_VARIANT
17981 #define THUMB_VARIANT  & arm_ext_v6t2
17982
17983  TCE("clz",     16f0f10, fab0f080, 2, (RRnpc, RRnpc),                   rd_rm,  t_clz),
17984  TUF("ldc2",    c100000, fc100000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17985  TUF("ldc2l",   c500000, fc500000, 3, (RCP, RCN, ADDRGLDC),                     lstc,   lstc),
17986  TUF("stc2",    c000000, fc000000, 3, (RCP, RCN, ADDRGLDC),             lstc,   lstc),
17987  TUF("stc2l",   c400000, fc400000, 3, (RCP, RCN, ADDRGLDC),                     lstc,   lstc),
17988  TUF("cdp2",    e000000, fe000000, 6, (RCP, I15b, RCN, RCN, RCN, oI7b), cdp,    cdp),
17989  TUF("mcr2",    e000010, fe000010, 6, (RCP, I7b, RR, RCN, RCN, oI7b),   co_reg, co_reg),
17990  TUF("mrc2",    e100010, fe100010, 6, (RCP, I7b, RR, RCN, RCN, oI7b),   co_reg, co_reg),
17991
17992 #undef  ARM_VARIANT
17993 #define ARM_VARIANT  & arm_ext_v5exp /*  ARM Architecture 5TExP.  */
17994 #undef THUMB_VARIANT
17995 #define THUMB_VARIANT &arm_ext_v5exp
17996
17997  TCE("smlabb",  1000080, fb100000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
17998  TCE("smlatb",  10000a0, fb100020, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
17999  TCE("smlabt",  10000c0, fb100010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
18000  TCE("smlatt",  10000e0, fb100030, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
18001
18002  TCE("smlawb",  1200080, fb300000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
18003  TCE("smlawt",  12000c0, fb300010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smla, t_mla),
18004
18005  TCE("smlalbb", 1400080, fbc00080, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
18006  TCE("smlaltb", 14000a0, fbc000a0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
18007  TCE("smlalbt", 14000c0, fbc00090, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
18008  TCE("smlaltt", 14000e0, fbc000b0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),   smlal, t_mlal),
18009
18010  TCE("smulbb",  1600080, fb10f000, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
18011  TCE("smultb",  16000a0, fb10f020, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
18012  TCE("smulbt",  16000c0, fb10f010, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
18013  TCE("smultt",  16000e0, fb10f030, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
18014
18015  TCE("smulwb",  12000a0, fb30f000, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
18016  TCE("smulwt",  12000e0, fb30f010, 3, (RRnpc, RRnpc, RRnpc),        smul, t_simd),
18017
18018  TCE("qadd",    1000050, fa80f080, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
18019  TCE("qdadd",   1400050, fa80f090, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
18020  TCE("qsub",    1200050, fa80f0a0, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
18021  TCE("qdsub",   1600050, fa80f0b0, 3, (RRnpc, RRnpc, RRnpc),        rd_rm_rn, t_simd2),
18022
18023 #undef  ARM_VARIANT
18024 #define ARM_VARIANT  & arm_ext_v5e /*  ARM Architecture 5TE.  */
18025 #undef THUMB_VARIANT
18026 #define THUMB_VARIANT &arm_ext_v6t2
18027
18028  TUF("pld",     450f000, f810f000, 1, (ADDR),                pld,  t_pld),
18029  TC3("ldrd",    00000d0, e8500000, 3, (RRnpc_npcsp, oRRnpc_npcsp, ADDRGLDRS),
18030      ldrd, t_ldstd),
18031  TC3("strd",    00000f0, e8400000, 3, (RRnpc_npcsp, oRRnpc_npcsp,
18032                                        ADDRGLDRS), ldrd, t_ldstd),
18033
18034  TCE("mcrr",    c400000, ec400000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
18035  TCE("mrrc",    c500000, ec500000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
18036
18037 #undef  ARM_VARIANT
18038 #define ARM_VARIANT  & arm_ext_v5j /*  ARM Architecture 5TEJ.  */
18039
18040  TCE("bxj",     12fff20, f3c08f00, 1, (RR),                       bxj, t_bxj),
18041
18042 #undef  ARM_VARIANT
18043 #define ARM_VARIANT    & arm_ext_v6 /*  ARM V6.  */
18044 #undef  THUMB_VARIANT
18045 #define THUMB_VARIANT  & arm_ext_v6
18046
18047  TUF("cpsie",     1080000, b660,     2, (CPSF, oI31b),              cpsi,   t_cpsi),
18048  TUF("cpsid",     10c0000, b670,     2, (CPSF, oI31b),              cpsi,   t_cpsi),
18049  tCE("rev",       6bf0f30, _rev,      2, (RRnpc, RRnpc),             rd_rm,  t_rev),
18050  tCE("rev16",     6bf0fb0, _rev16,    2, (RRnpc, RRnpc),             rd_rm,  t_rev),
18051  tCE("revsh",     6ff0fb0, _revsh,    2, (RRnpc, RRnpc),             rd_rm,  t_rev),
18052  tCE("sxth",      6bf0070, _sxth,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
18053  tCE("uxth",      6ff0070, _uxth,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
18054  tCE("sxtb",      6af0070, _sxtb,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
18055  tCE("uxtb",      6ef0070, _uxtb,     3, (RRnpc, RRnpc, oROR),       sxth,   t_sxth),
18056  TUF("setend",    1010000, b650,     1, (ENDI),                     setend, t_setend),
18057
18058 #undef  THUMB_VARIANT
18059 #define THUMB_VARIANT  & arm_ext_v6t2
18060
18061  TCE("ldrex",   1900f9f, e8500f00, 2, (RRnpc_npcsp, ADDR),        ldrex, t_ldrex),
18062  TCE("strex",   1800f90, e8400000, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
18063                                       strex,  t_strex),
18064  TUF("mcrr2",   c400000, fc400000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
18065  TUF("mrrc2",   c500000, fc500000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
18066
18067  TCE("ssat",    6a00010, f3000000, 4, (RRnpc, I32, RRnpc, oSHllar),ssat,   t_ssat),
18068  TCE("usat",    6e00010, f3800000, 4, (RRnpc, I31, RRnpc, oSHllar),usat,   t_usat),
18069
18070 /*  ARM V6 not included in V7M.  */
18071 #undef  THUMB_VARIANT
18072 #define THUMB_VARIANT  & arm_ext_v6_notm
18073  TUF("rfeia",   8900a00, e990c000, 1, (RRw),                       rfe, rfe),
18074   UF(rfeib,     9900a00,           1, (RRw),                       rfe),
18075   UF(rfeda,     8100a00,           1, (RRw),                       rfe),
18076  TUF("rfedb",   9100a00, e810c000, 1, (RRw),                       rfe, rfe),
18077  TUF("rfefd",   8900a00, e990c000, 1, (RRw),                       rfe, rfe),
18078   UF(rfefa,     9900a00,           1, (RRw),                       rfe),
18079   UF(rfeea,     8100a00,           1, (RRw),                       rfe),
18080  TUF("rfeed",   9100a00, e810c000, 1, (RRw),                       rfe, rfe),
18081  TUF("srsia",   8c00500, e980c000, 2, (oRRw, I31w),                srs,  srs),
18082   UF(srsib,     9c00500,           2, (oRRw, I31w),                srs),
18083   UF(srsda,     8400500,           2, (oRRw, I31w),                srs),
18084  TUF("srsdb",   9400500, e800c000, 2, (oRRw, I31w),                srs,  srs),
18085
18086 /*  ARM V6 not included in V7M (eg. integer SIMD).  */
18087 #undef  THUMB_VARIANT
18088 #define THUMB_VARIANT  & arm_ext_v6_dsp
18089  TUF("cps",     1020000, f3af8100, 1, (I31b),                     imm0, t_cps),
18090  TCE("pkhbt",   6800010, eac00000, 4, (RRnpc, RRnpc, RRnpc, oSHll),   pkhbt, t_pkhbt),
18091  TCE("pkhtb",   6800050, eac00020, 4, (RRnpc, RRnpc, RRnpc, oSHar),   pkhtb, t_pkhtb),
18092  TCE("qadd16",  6200f10, fa90f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18093  TCE("qadd8",   6200f90, fa80f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18094  TCE("qasx",    6200f30, faa0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18095  /* Old name for QASX.  */
18096  TCE("qaddsubx",        6200f30, faa0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18097  TCE("qsax",    6200f50, fae0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18098  /* Old name for QSAX.  */
18099  TCE("qsubaddx",        6200f50, fae0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18100  TCE("qsub16",  6200f70, fad0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18101  TCE("qsub8",   6200ff0, fac0f010, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18102  TCE("sadd16",  6100f10, fa90f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18103  TCE("sadd8",   6100f90, fa80f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18104  TCE("sasx",    6100f30, faa0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18105  /* Old name for SASX.  */
18106  TCE("saddsubx",        6100f30, faa0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18107  TCE("shadd16", 6300f10, fa90f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18108  TCE("shadd8",  6300f90, fa80f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18109  TCE("shasx",     6300f30, faa0f020, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18110  /* Old name for SHASX.  */
18111  TCE("shaddsubx", 6300f30, faa0f020, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18112  TCE("shsax",      6300f50, fae0f020, 3, (RRnpc, RRnpc, RRnpc),    rd_rn_rm, t_simd),
18113  /* Old name for SHSAX.  */
18114  TCE("shsubaddx", 6300f50, fae0f020, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18115  TCE("shsub16", 6300f70, fad0f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18116  TCE("shsub8",  6300ff0, fac0f020, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18117  TCE("ssax",    6100f50, fae0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18118  /* Old name for SSAX.  */
18119  TCE("ssubaddx",        6100f50, fae0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18120  TCE("ssub16",  6100f70, fad0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18121  TCE("ssub8",   6100ff0, fac0f000, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18122  TCE("uadd16",  6500f10, fa90f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18123  TCE("uadd8",   6500f90, fa80f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18124  TCE("uasx",    6500f30, faa0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18125  /* Old name for UASX.  */
18126  TCE("uaddsubx",        6500f30, faa0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18127  TCE("uhadd16", 6700f10, fa90f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18128  TCE("uhadd8",  6700f90, fa80f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18129  TCE("uhasx",     6700f30, faa0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18130  /* Old name for UHASX.  */
18131  TCE("uhaddsubx", 6700f30, faa0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18132  TCE("uhsax",     6700f50, fae0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18133  /* Old name for UHSAX.  */
18134  TCE("uhsubaddx", 6700f50, fae0f060, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18135  TCE("uhsub16", 6700f70, fad0f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18136  TCE("uhsub8",  6700ff0, fac0f060, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18137  TCE("uqadd16", 6600f10, fa90f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18138  TCE("uqadd8",  6600f90, fa80f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18139  TCE("uqasx",     6600f30, faa0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18140  /* Old name for UQASX.  */
18141  TCE("uqaddsubx", 6600f30, faa0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18142  TCE("uqsax",     6600f50, fae0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18143  /* Old name for UQSAX.  */
18144  TCE("uqsubaddx", 6600f50, fae0f050, 3, (RRnpc, RRnpc, RRnpc),     rd_rn_rm, t_simd),
18145  TCE("uqsub16", 6600f70, fad0f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18146  TCE("uqsub8",  6600ff0, fac0f050, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18147  TCE("usub16",  6500f70, fad0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18148  TCE("usax",    6500f50, fae0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18149  /* Old name for USAX.  */
18150  TCE("usubaddx",        6500f50, fae0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18151  TCE("usub8",   6500ff0, fac0f040, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18152  TCE("sxtah",   6b00070, fa00f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18153  TCE("sxtab16", 6800070, fa20f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18154  TCE("sxtab",   6a00070, fa40f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18155  TCE("sxtb16",  68f0070, fa2ff080, 3, (RRnpc, RRnpc, oROR),        sxth,  t_sxth),
18156  TCE("uxtah",   6f00070, fa10f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18157  TCE("uxtab16", 6c00070, fa30f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18158  TCE("uxtab",   6e00070, fa50f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18159  TCE("uxtb16",  6cf0070, fa3ff080, 3, (RRnpc, RRnpc, oROR),        sxth,  t_sxth),
18160  TCE("sel",     6800fb0, faa0f080, 3, (RRnpc, RRnpc, RRnpc),       rd_rn_rm, t_simd),
18161  TCE("smlad",   7000010, fb200000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18162  TCE("smladx",  7000030, fb200010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18163  TCE("smlald",  7400010, fbc000c0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
18164  TCE("smlaldx", 7400030, fbc000d0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
18165  TCE("smlsd",   7000050, fb400000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18166  TCE("smlsdx",  7000070, fb400010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18167  TCE("smlsld",  7400050, fbd000c0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
18168  TCE("smlsldx", 7400070, fbd000d0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
18169  TCE("smmla",   7500010, fb500000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18170  TCE("smmlar",  7500030, fb500010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18171  TCE("smmls",   75000d0, fb600000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18172  TCE("smmlsr",  75000f0, fb600010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18173  TCE("smmul",   750f010, fb50f000, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
18174  TCE("smmulr",  750f030, fb50f010, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
18175  TCE("smuad",   700f010, fb20f000, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
18176  TCE("smuadx",  700f030, fb20f010, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
18177  TCE("smusd",   700f050, fb40f000, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
18178  TCE("smusdx",  700f070, fb40f010, 3, (RRnpc, RRnpc, RRnpc),       smul, t_simd),
18179  TCE("ssat16",  6a00f30, f3200000, 3, (RRnpc, I16, RRnpc),         ssat16, t_ssat16),
18180  TCE("umaal",   0400090, fbe00060, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,  t_mlal),
18181  TCE("usad8",   780f010, fb70f000, 3, (RRnpc, RRnpc, RRnpc),       smul,   t_simd),
18182  TCE("usada8",  7800010, fb700000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla,   t_mla),
18183  TCE("usat16",  6e00f30, f3a00000, 3, (RRnpc, I15, RRnpc),         usat16, t_usat16),
18184
18185 #undef  ARM_VARIANT
18186 #define ARM_VARIANT   & arm_ext_v6k
18187 #undef  THUMB_VARIANT
18188 #define THUMB_VARIANT & arm_ext_v6k
18189
18190  tCE("yield",   320f001, _yield,    0, (), noargs, t_hint),
18191  tCE("wfe",     320f002, _wfe,      0, (), noargs, t_hint),
18192  tCE("wfi",     320f003, _wfi,      0, (), noargs, t_hint),
18193  tCE("sev",     320f004, _sev,      0, (), noargs, t_hint),
18194
18195 #undef  THUMB_VARIANT
18196 #define THUMB_VARIANT  & arm_ext_v6_notm
18197  TCE("ldrexd",  1b00f9f, e8d0007f, 3, (RRnpc_npcsp, oRRnpc_npcsp, RRnpcb),
18198                                       ldrexd, t_ldrexd),
18199  TCE("strexd",  1a00f90, e8c00070, 4, (RRnpc_npcsp, RRnpc_npcsp, oRRnpc_npcsp,
18200                                        RRnpcb), strexd, t_strexd),
18201
18202 #undef  THUMB_VARIANT
18203 #define THUMB_VARIANT  & arm_ext_v6t2
18204  TCE("ldrexb",  1d00f9f, e8d00f4f, 2, (RRnpc_npcsp,RRnpcb),
18205      rd_rn,  rd_rn),
18206  TCE("ldrexh",  1f00f9f, e8d00f5f, 2, (RRnpc_npcsp, RRnpcb),
18207      rd_rn,  rd_rn),
18208  TCE("strexb",  1c00f90, e8c00f40, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
18209      strex, t_strexbh),
18210  TCE("strexh",  1e00f90, e8c00f50, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
18211      strex, t_strexbh),
18212  TUF("clrex",   57ff01f, f3bf8f2f, 0, (),                             noargs, noargs),
18213
18214 #undef  ARM_VARIANT
18215 #define ARM_VARIANT    & arm_ext_sec
18216 #undef THUMB_VARIANT
18217 #define THUMB_VARIANT  & arm_ext_sec
18218
18219  TCE("smc",     1600070, f7f08000, 1, (EXPi), smc, t_smc),
18220
18221 #undef  ARM_VARIANT
18222 #define ARM_VARIANT    & arm_ext_virt
18223 #undef  THUMB_VARIANT
18224 #define THUMB_VARIANT    & arm_ext_virt
18225
18226  TCE("hvc",     1400070, f7e08000, 1, (EXPi), hvc, t_hvc),
18227  TCE("eret",    160006e, f3de8f00, 0, (), noargs, noargs),
18228
18229 #undef  ARM_VARIANT
18230 #define ARM_VARIANT  & arm_ext_v6t2
18231 #undef  THUMB_VARIANT
18232 #define THUMB_VARIANT  & arm_ext_v6t2
18233
18234  TCE("bfc",     7c0001f, f36f0000, 3, (RRnpc, I31, I32),           bfc, t_bfc),
18235  TCE("bfi",     7c00010, f3600000, 4, (RRnpc, RRnpc_I0, I31, I32), bfi, t_bfi),
18236  TCE("sbfx",    7a00050, f3400000, 4, (RR, RR, I31, I32),          bfx, t_bfx),
18237  TCE("ubfx",    7e00050, f3c00000, 4, (RR, RR, I31, I32),          bfx, t_bfx),
18238
18239  TCE("mls",     0600090, fb000010, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas, t_mla),
18240  TCE("movw",    3000000, f2400000, 2, (RRnpc, HALF),                mov16, t_mov16),
18241  TCE("movt",    3400000, f2c00000, 2, (RRnpc, HALF),                mov16, t_mov16),
18242  TCE("rbit",    6ff0f30, fa90f0a0, 2, (RR, RR),                     rd_rm, t_rbit),
18243
18244  TC3("ldrht",   03000b0, f8300e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
18245  TC3("ldrsht",  03000f0, f9300e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
18246  TC3("ldrsbt",  03000d0, f9100e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
18247  TC3("strht",   02000b0, f8200e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
18248
18249  /* Thumb-only instructions.  */
18250 #undef ARM_VARIANT
18251 #define ARM_VARIANT NULL
18252   TUE("cbnz",     0,           b900,     2, (RR, EXP), 0, t_cbz),
18253   TUE("cbz",      0,           b100,     2, (RR, EXP), 0, t_cbz),
18254
18255  /* ARM does not really have an IT instruction, so always allow it.
18256     The opcode is copied from Thumb in order to allow warnings in
18257     -mimplicit-it=[never | arm] modes.  */
18258 #undef  ARM_VARIANT
18259 #define ARM_VARIANT  & arm_ext_v1
18260
18261  TUE("it",        bf08,        bf08,     1, (COND),   it,    t_it),
18262  TUE("itt",       bf0c,        bf0c,     1, (COND),   it,    t_it),
18263  TUE("ite",       bf04,        bf04,     1, (COND),   it,    t_it),
18264  TUE("ittt",      bf0e,        bf0e,     1, (COND),   it,    t_it),
18265  TUE("itet",      bf06,        bf06,     1, (COND),   it,    t_it),
18266  TUE("itte",      bf0a,        bf0a,     1, (COND),   it,    t_it),
18267  TUE("itee",      bf02,        bf02,     1, (COND),   it,    t_it),
18268  TUE("itttt",     bf0f,        bf0f,     1, (COND),   it,    t_it),
18269  TUE("itett",     bf07,        bf07,     1, (COND),   it,    t_it),
18270  TUE("ittet",     bf0b,        bf0b,     1, (COND),   it,    t_it),
18271  TUE("iteet",     bf03,        bf03,     1, (COND),   it,    t_it),
18272  TUE("ittte",     bf0d,        bf0d,     1, (COND),   it,    t_it),
18273  TUE("itete",     bf05,        bf05,     1, (COND),   it,    t_it),
18274  TUE("ittee",     bf09,        bf09,     1, (COND),   it,    t_it),
18275  TUE("iteee",     bf01,        bf01,     1, (COND),   it,    t_it),
18276  /* ARM/Thumb-2 instructions with no Thumb-1 equivalent.  */
18277  TC3("rrx",       01a00060, ea4f0030, 2, (RR, RR), rd_rm, t_rrx),
18278  TC3("rrxs",      01b00060, ea5f0030, 2, (RR, RR), rd_rm, t_rrx),
18279
18280  /* Thumb2 only instructions.  */
18281 #undef  ARM_VARIANT
18282 #define ARM_VARIANT  NULL
18283
18284  TCE("addw",    0, f2000000, 3, (RR, RR, EXPi), 0, t_add_sub_w),
18285  TCE("subw",    0, f2a00000, 3, (RR, RR, EXPi), 0, t_add_sub_w),
18286  TCE("orn",       0, ea600000, 3, (RR, oRR, SH),  0, t_orn),
18287  TCE("orns",      0, ea700000, 3, (RR, oRR, SH),  0, t_orn),
18288  TCE("tbb",       0, e8d0f000, 1, (TB), 0, t_tb),
18289  TCE("tbh",       0, e8d0f010, 1, (TB), 0, t_tb),
18290
18291  /* Hardware division instructions.  */
18292 #undef  ARM_VARIANT
18293 #define ARM_VARIANT    & arm_ext_adiv
18294 #undef  THUMB_VARIANT
18295 #define THUMB_VARIANT  & arm_ext_div
18296
18297  TCE("sdiv",    710f010, fb90f0f0, 3, (RR, oRR, RR), div, t_div),
18298  TCE("udiv",    730f010, fbb0f0f0, 3, (RR, oRR, RR), div, t_div),
18299
18300  /* ARM V6M/V7 instructions.  */
18301 #undef  ARM_VARIANT
18302 #define ARM_VARIANT    & arm_ext_barrier
18303 #undef  THUMB_VARIANT
18304 #define THUMB_VARIANT  & arm_ext_barrier
18305
18306  TUF("dmb",     57ff050, f3bf8f50, 1, (oBARRIER_I15), barrier,  t_barrier),
18307  TUF("dsb",     57ff040, f3bf8f40, 1, (oBARRIER_I15), barrier,  t_barrier),
18308  TUF("isb",     57ff060, f3bf8f60, 1, (oBARRIER_I15), barrier,  t_barrier),
18309
18310  /* ARM V7 instructions.  */
18311 #undef  ARM_VARIANT
18312 #define ARM_VARIANT    & arm_ext_v7
18313 #undef  THUMB_VARIANT
18314 #define THUMB_VARIANT  & arm_ext_v7
18315
18316  TUF("pli",     450f000, f910f000, 1, (ADDR),     pli,      t_pld),
18317  TCE("dbg",     320f0f0, f3af80f0, 1, (I15),      dbg,      t_dbg),
18318
18319 #undef ARM_VARIANT
18320 #define ARM_VARIANT    & arm_ext_mp
18321 #undef THUMB_VARIANT
18322 #define THUMB_VARIANT  & arm_ext_mp
18323
18324  TUF("pldw",    410f000, f830f000, 1, (ADDR),   pld,    t_pld),
18325
18326  /* AArchv8 instructions.  */
18327 #undef  ARM_VARIANT
18328 #define ARM_VARIANT   & arm_ext_v8
18329 #undef  THUMB_VARIANT
18330 #define THUMB_VARIANT & arm_ext_v8
18331
18332  tCE("sevl",    320f005, _sevl,    0, (),               noargs, t_hint),
18333  TUE("hlt",     1000070, ba80,     1, (oIffffb),        bkpt,   t_hlt),
18334  TCE("ldraex",  1900e9f, e8d00fef, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
18335  TCE("ldraexd", 1b00e9f, e8d000ff, 3, (RRnpc, oRRnpc, RRnpcb),
18336                                                         ldrexd, t_ldrexd),
18337  TCE("ldraexb", 1d00e9f, e8d00fcf, 2, (RRnpc,RRnpcb),   rd_rn,  rd_rn),
18338  TCE("ldraexh", 1f00e9f, e8d00fdf, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
18339  TCE("strlex",  1800e90, e8c00fe0, 3, (RRnpc, RRnpc, RRnpcb),
18340                                                         strlex,  t_strlex),
18341  TCE("strlexd", 1a00e90, e8c000f0, 4, (RRnpc, RRnpc, oRRnpc, RRnpcb),
18342                                                         strexd, t_strexd),
18343  TCE("strlexb", 1c00e90, e8c00fc0, 3, (RRnpc, RRnpc, RRnpcb),
18344                                                         strlex, t_strlex),
18345  TCE("strlexh", 1e00e90, e8c00fd0, 3, (RRnpc, RRnpc, RRnpcb),
18346                                                         strlex, t_strlex),
18347  TCE("ldra",    1900c9f, e8d00faf, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
18348  TCE("ldrab",   1d00c9f, e8d00f8f, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
18349  TCE("ldrah",   1f00c9f, e8d00f9f, 2, (RRnpc, RRnpcb),  rd_rn,  rd_rn),
18350  TCE("strl",    180fc90, e8c00faf, 2, (RRnpc, RRnpcb),  rm_rn,  rd_rn),
18351  TCE("strlb",   1c0fc90, e8c00f8f, 2, (RRnpc, RRnpcb),  rm_rn,  rd_rn),
18352  TCE("strlh",   1e0fc90, e8c00f9f, 2, (RRnpc, RRnpcb),  rm_rn,  rd_rn),
18353
18354  /* ARMv8 T32 only.  */
18355 #undef ARM_VARIANT
18356 #define ARM_VARIANT  NULL
18357  TUF("dcps1",   0,       f78f8001, 0, (),       noargs, noargs),
18358  TUF("dcps2",   0,       f78f8002, 0, (),       noargs, noargs),
18359  TUF("dcps3",   0,       f78f8003, 0, (),       noargs, noargs),
18360
18361   /* FP for ARMv8.  */
18362 #undef  ARM_VARIANT
18363 #define ARM_VARIANT & fpu_vfp_ext_armv8
18364 #undef  THUMB_VARIANT
18365 #define THUMB_VARIANT & fpu_vfp_ext_armv8
18366
18367   nUF(vseleq, _vseleq, 3, (RVSD, RVSD, RVSD),           vsel),
18368   nUF(vselvs, _vselvs, 3, (RVSD, RVSD, RVSD),           vsel),
18369   nUF(vselge, _vselge, 3, (RVSD, RVSD, RVSD),           vsel),
18370   nUF(vselgt, _vselgt, 3, (RVSD, RVSD, RVSD),           vsel),
18371   nUF(vmaxnm, _vmaxnm, 3, (RNSDQ, oRNSDQ, RNSDQ),       vmaxnm),
18372   nUF(vminnm, _vminnm, 3, (RNSDQ, oRNSDQ, RNSDQ),       vmaxnm),
18373   nUF(vcvta,  _vcvta,  2, (RNSDQ, oRNSDQ),              neon_cvta),
18374   nUF(vcvtn,  _vcvta,  2, (RNSDQ, oRNSDQ),              neon_cvtn),
18375   nUF(vcvtp,  _vcvta,  2, (RNSDQ, oRNSDQ),              neon_cvtp),
18376   nUF(vcvtm,  _vcvta,  2, (RNSDQ, oRNSDQ),              neon_cvtm),
18377   nCE(vrintr, _vrintr, 2, (RNSDQ, oRNSDQ),              vrintr),
18378   nCE(vrintz, _vrintr, 2, (RNSDQ, oRNSDQ),              vrintz),
18379   nCE(vrintx, _vrintr, 2, (RNSDQ, oRNSDQ),              vrintx),
18380   nUF(vrinta, _vrinta, 2, (RNSDQ, oRNSDQ),              vrinta),
18381   nUF(vrintn, _vrinta, 2, (RNSDQ, oRNSDQ),              vrintn),
18382   nUF(vrintp, _vrinta, 2, (RNSDQ, oRNSDQ),              vrintp),
18383   nUF(vrintm, _vrinta, 2, (RNSDQ, oRNSDQ),              vrintm),
18384
18385 #undef  ARM_VARIANT
18386 #define ARM_VARIANT  & fpu_fpa_ext_v1  /* Core FPA instruction set (V1).  */
18387 #undef  THUMB_VARIANT
18388 #define THUMB_VARIANT NULL
18389
18390  cCE("wfs",     e200110, 1, (RR),            rd),
18391  cCE("rfs",     e300110, 1, (RR),            rd),
18392  cCE("wfc",     e400110, 1, (RR),            rd),
18393  cCE("rfc",     e500110, 1, (RR),            rd),
18394
18395  cCL("ldfs",    c100100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18396  cCL("ldfd",    c108100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18397  cCL("ldfe",    c500100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18398  cCL("ldfp",    c508100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18399
18400  cCL("stfs",    c000100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18401  cCL("stfd",    c008100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18402  cCL("stfe",    c400100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18403  cCL("stfp",    c408100, 2, (RF, ADDRGLDC),  rd_cpaddr),
18404
18405  cCL("mvfs",    e008100, 2, (RF, RF_IF),     rd_rm),
18406  cCL("mvfsp",   e008120, 2, (RF, RF_IF),     rd_rm),
18407  cCL("mvfsm",   e008140, 2, (RF, RF_IF),     rd_rm),
18408  cCL("mvfsz",   e008160, 2, (RF, RF_IF),     rd_rm),
18409  cCL("mvfd",    e008180, 2, (RF, RF_IF),     rd_rm),
18410  cCL("mvfdp",   e0081a0, 2, (RF, RF_IF),     rd_rm),
18411  cCL("mvfdm",   e0081c0, 2, (RF, RF_IF),     rd_rm),
18412  cCL("mvfdz",   e0081e0, 2, (RF, RF_IF),     rd_rm),
18413  cCL("mvfe",    e088100, 2, (RF, RF_IF),     rd_rm),
18414  cCL("mvfep",   e088120, 2, (RF, RF_IF),     rd_rm),
18415  cCL("mvfem",   e088140, 2, (RF, RF_IF),     rd_rm),
18416  cCL("mvfez",   e088160, 2, (RF, RF_IF),     rd_rm),
18417
18418  cCL("mnfs",    e108100, 2, (RF, RF_IF),     rd_rm),
18419  cCL("mnfsp",   e108120, 2, (RF, RF_IF),     rd_rm),
18420  cCL("mnfsm",   e108140, 2, (RF, RF_IF),     rd_rm),
18421  cCL("mnfsz",   e108160, 2, (RF, RF_IF),     rd_rm),
18422  cCL("mnfd",    e108180, 2, (RF, RF_IF),     rd_rm),
18423  cCL("mnfdp",   e1081a0, 2, (RF, RF_IF),     rd_rm),
18424  cCL("mnfdm",   e1081c0, 2, (RF, RF_IF),     rd_rm),
18425  cCL("mnfdz",   e1081e0, 2, (RF, RF_IF),     rd_rm),
18426  cCL("mnfe",    e188100, 2, (RF, RF_IF),     rd_rm),
18427  cCL("mnfep",   e188120, 2, (RF, RF_IF),     rd_rm),
18428  cCL("mnfem",   e188140, 2, (RF, RF_IF),     rd_rm),
18429  cCL("mnfez",   e188160, 2, (RF, RF_IF),     rd_rm),
18430
18431  cCL("abss",    e208100, 2, (RF, RF_IF),     rd_rm),
18432  cCL("abssp",   e208120, 2, (RF, RF_IF),     rd_rm),
18433  cCL("abssm",   e208140, 2, (RF, RF_IF),     rd_rm),
18434  cCL("abssz",   e208160, 2, (RF, RF_IF),     rd_rm),
18435  cCL("absd",    e208180, 2, (RF, RF_IF),     rd_rm),
18436  cCL("absdp",   e2081a0, 2, (RF, RF_IF),     rd_rm),
18437  cCL("absdm",   e2081c0, 2, (RF, RF_IF),     rd_rm),
18438  cCL("absdz",   e2081e0, 2, (RF, RF_IF),     rd_rm),
18439  cCL("abse",    e288100, 2, (RF, RF_IF),     rd_rm),
18440  cCL("absep",   e288120, 2, (RF, RF_IF),     rd_rm),
18441  cCL("absem",   e288140, 2, (RF, RF_IF),     rd_rm),
18442  cCL("absez",   e288160, 2, (RF, RF_IF),     rd_rm),
18443
18444  cCL("rnds",    e308100, 2, (RF, RF_IF),     rd_rm),
18445  cCL("rndsp",   e308120, 2, (RF, RF_IF),     rd_rm),
18446  cCL("rndsm",   e308140, 2, (RF, RF_IF),     rd_rm),
18447  cCL("rndsz",   e308160, 2, (RF, RF_IF),     rd_rm),
18448  cCL("rndd",    e308180, 2, (RF, RF_IF),     rd_rm),
18449  cCL("rnddp",   e3081a0, 2, (RF, RF_IF),     rd_rm),
18450  cCL("rnddm",   e3081c0, 2, (RF, RF_IF),     rd_rm),
18451  cCL("rnddz",   e3081e0, 2, (RF, RF_IF),     rd_rm),
18452  cCL("rnde",    e388100, 2, (RF, RF_IF),     rd_rm),
18453  cCL("rndep",   e388120, 2, (RF, RF_IF),     rd_rm),
18454  cCL("rndem",   e388140, 2, (RF, RF_IF),     rd_rm),
18455  cCL("rndez",   e388160, 2, (RF, RF_IF),     rd_rm),
18456
18457  cCL("sqts",    e408100, 2, (RF, RF_IF),     rd_rm),
18458  cCL("sqtsp",   e408120, 2, (RF, RF_IF),     rd_rm),
18459  cCL("sqtsm",   e408140, 2, (RF, RF_IF),     rd_rm),
18460  cCL("sqtsz",   e408160, 2, (RF, RF_IF),     rd_rm),
18461  cCL("sqtd",    e408180, 2, (RF, RF_IF),     rd_rm),
18462  cCL("sqtdp",   e4081a0, 2, (RF, RF_IF),     rd_rm),
18463  cCL("sqtdm",   e4081c0, 2, (RF, RF_IF),     rd_rm),
18464  cCL("sqtdz",   e4081e0, 2, (RF, RF_IF),     rd_rm),
18465  cCL("sqte",    e488100, 2, (RF, RF_IF),     rd_rm),
18466  cCL("sqtep",   e488120, 2, (RF, RF_IF),     rd_rm),
18467  cCL("sqtem",   e488140, 2, (RF, RF_IF),     rd_rm),
18468  cCL("sqtez",   e488160, 2, (RF, RF_IF),     rd_rm),
18469
18470  cCL("logs",    e508100, 2, (RF, RF_IF),     rd_rm),
18471  cCL("logsp",   e508120, 2, (RF, RF_IF),     rd_rm),
18472  cCL("logsm",   e508140, 2, (RF, RF_IF),     rd_rm),
18473  cCL("logsz",   e508160, 2, (RF, RF_IF),     rd_rm),
18474  cCL("logd",    e508180, 2, (RF, RF_IF),     rd_rm),
18475  cCL("logdp",   e5081a0, 2, (RF, RF_IF),     rd_rm),
18476  cCL("logdm",   e5081c0, 2, (RF, RF_IF),     rd_rm),
18477  cCL("logdz",   e5081e0, 2, (RF, RF_IF),     rd_rm),
18478  cCL("loge",    e588100, 2, (RF, RF_IF),     rd_rm),
18479  cCL("logep",   e588120, 2, (RF, RF_IF),     rd_rm),
18480  cCL("logem",   e588140, 2, (RF, RF_IF),     rd_rm),
18481  cCL("logez",   e588160, 2, (RF, RF_IF),     rd_rm),
18482
18483  cCL("lgns",    e608100, 2, (RF, RF_IF),     rd_rm),
18484  cCL("lgnsp",   e608120, 2, (RF, RF_IF),     rd_rm),
18485  cCL("lgnsm",   e608140, 2, (RF, RF_IF),     rd_rm),
18486  cCL("lgnsz",   e608160, 2, (RF, RF_IF),     rd_rm),
18487  cCL("lgnd",    e608180, 2, (RF, RF_IF),     rd_rm),
18488  cCL("lgndp",   e6081a0, 2, (RF, RF_IF),     rd_rm),
18489  cCL("lgndm",   e6081c0, 2, (RF, RF_IF),     rd_rm),
18490  cCL("lgndz",   e6081e0, 2, (RF, RF_IF),     rd_rm),
18491  cCL("lgne",    e688100, 2, (RF, RF_IF),     rd_rm),
18492  cCL("lgnep",   e688120, 2, (RF, RF_IF),     rd_rm),
18493  cCL("lgnem",   e688140, 2, (RF, RF_IF),     rd_rm),
18494  cCL("lgnez",   e688160, 2, (RF, RF_IF),     rd_rm),
18495
18496  cCL("exps",    e708100, 2, (RF, RF_IF),     rd_rm),
18497  cCL("expsp",   e708120, 2, (RF, RF_IF),     rd_rm),
18498  cCL("expsm",   e708140, 2, (RF, RF_IF),     rd_rm),
18499  cCL("expsz",   e708160, 2, (RF, RF_IF),     rd_rm),
18500  cCL("expd",    e708180, 2, (RF, RF_IF),     rd_rm),
18501  cCL("expdp",   e7081a0, 2, (RF, RF_IF),     rd_rm),
18502  cCL("expdm",   e7081c0, 2, (RF, RF_IF),     rd_rm),
18503  cCL("expdz",   e7081e0, 2, (RF, RF_IF),     rd_rm),
18504  cCL("expe",    e788100, 2, (RF, RF_IF),     rd_rm),
18505  cCL("expep",   e788120, 2, (RF, RF_IF),     rd_rm),
18506  cCL("expem",   e788140, 2, (RF, RF_IF),     rd_rm),
18507  cCL("expdz",   e788160, 2, (RF, RF_IF),     rd_rm),
18508
18509  cCL("sins",    e808100, 2, (RF, RF_IF),     rd_rm),
18510  cCL("sinsp",   e808120, 2, (RF, RF_IF),     rd_rm),
18511  cCL("sinsm",   e808140, 2, (RF, RF_IF),     rd_rm),
18512  cCL("sinsz",   e808160, 2, (RF, RF_IF),     rd_rm),
18513  cCL("sind",    e808180, 2, (RF, RF_IF),     rd_rm),
18514  cCL("sindp",   e8081a0, 2, (RF, RF_IF),     rd_rm),
18515  cCL("sindm",   e8081c0, 2, (RF, RF_IF),     rd_rm),
18516  cCL("sindz",   e8081e0, 2, (RF, RF_IF),     rd_rm),
18517  cCL("sine",    e888100, 2, (RF, RF_IF),     rd_rm),
18518  cCL("sinep",   e888120, 2, (RF, RF_IF),     rd_rm),
18519  cCL("sinem",   e888140, 2, (RF, RF_IF),     rd_rm),
18520  cCL("sinez",   e888160, 2, (RF, RF_IF),     rd_rm),
18521
18522  cCL("coss",    e908100, 2, (RF, RF_IF),     rd_rm),
18523  cCL("cossp",   e908120, 2, (RF, RF_IF),     rd_rm),
18524  cCL("cossm",   e908140, 2, (RF, RF_IF),     rd_rm),
18525  cCL("cossz",   e908160, 2, (RF, RF_IF),     rd_rm),
18526  cCL("cosd",    e908180, 2, (RF, RF_IF),     rd_rm),
18527  cCL("cosdp",   e9081a0, 2, (RF, RF_IF),     rd_rm),
18528  cCL("cosdm",   e9081c0, 2, (RF, RF_IF),     rd_rm),
18529  cCL("cosdz",   e9081e0, 2, (RF, RF_IF),     rd_rm),
18530  cCL("cose",    e988100, 2, (RF, RF_IF),     rd_rm),
18531  cCL("cosep",   e988120, 2, (RF, RF_IF),     rd_rm),
18532  cCL("cosem",   e988140, 2, (RF, RF_IF),     rd_rm),
18533  cCL("cosez",   e988160, 2, (RF, RF_IF),     rd_rm),
18534
18535  cCL("tans",    ea08100, 2, (RF, RF_IF),     rd_rm),
18536  cCL("tansp",   ea08120, 2, (RF, RF_IF),     rd_rm),
18537  cCL("tansm",   ea08140, 2, (RF, RF_IF),     rd_rm),
18538  cCL("tansz",   ea08160, 2, (RF, RF_IF),     rd_rm),
18539  cCL("tand",    ea08180, 2, (RF, RF_IF),     rd_rm),
18540  cCL("tandp",   ea081a0, 2, (RF, RF_IF),     rd_rm),
18541  cCL("tandm",   ea081c0, 2, (RF, RF_IF),     rd_rm),
18542  cCL("tandz",   ea081e0, 2, (RF, RF_IF),     rd_rm),
18543  cCL("tane",    ea88100, 2, (RF, RF_IF),     rd_rm),
18544  cCL("tanep",   ea88120, 2, (RF, RF_IF),     rd_rm),
18545  cCL("tanem",   ea88140, 2, (RF, RF_IF),     rd_rm),
18546  cCL("tanez",   ea88160, 2, (RF, RF_IF),     rd_rm),
18547
18548  cCL("asns",    eb08100, 2, (RF, RF_IF),     rd_rm),
18549  cCL("asnsp",   eb08120, 2, (RF, RF_IF),     rd_rm),
18550  cCL("asnsm",   eb08140, 2, (RF, RF_IF),     rd_rm),
18551  cCL("asnsz",   eb08160, 2, (RF, RF_IF),     rd_rm),
18552  cCL("asnd",    eb08180, 2, (RF, RF_IF),     rd_rm),
18553  cCL("asndp",   eb081a0, 2, (RF, RF_IF),     rd_rm),
18554  cCL("asndm",   eb081c0, 2, (RF, RF_IF),     rd_rm),
18555  cCL("asndz",   eb081e0, 2, (RF, RF_IF),     rd_rm),
18556  cCL("asne",    eb88100, 2, (RF, RF_IF),     rd_rm),
18557  cCL("asnep",   eb88120, 2, (RF, RF_IF),     rd_rm),
18558  cCL("asnem",   eb88140, 2, (RF, RF_IF),     rd_rm),
18559  cCL("asnez",   eb88160, 2, (RF, RF_IF),     rd_rm),
18560
18561  cCL("acss",    ec08100, 2, (RF, RF_IF),     rd_rm),
18562  cCL("acssp",   ec08120, 2, (RF, RF_IF),     rd_rm),
18563  cCL("acssm",   ec08140, 2, (RF, RF_IF),     rd_rm),
18564  cCL("acssz",   ec08160, 2, (RF, RF_IF),     rd_rm),
18565  cCL("acsd",    ec08180, 2, (RF, RF_IF),     rd_rm),
18566  cCL("acsdp",   ec081a0, 2, (RF, RF_IF),     rd_rm),
18567  cCL("acsdm",   ec081c0, 2, (RF, RF_IF),     rd_rm),
18568  cCL("acsdz",   ec081e0, 2, (RF, RF_IF),     rd_rm),
18569  cCL("acse",    ec88100, 2, (RF, RF_IF),     rd_rm),
18570  cCL("acsep",   ec88120, 2, (RF, RF_IF),     rd_rm),
18571  cCL("acsem",   ec88140, 2, (RF, RF_IF),     rd_rm),
18572  cCL("acsez",   ec88160, 2, (RF, RF_IF),     rd_rm),
18573
18574  cCL("atns",    ed08100, 2, (RF, RF_IF),     rd_rm),
18575  cCL("atnsp",   ed08120, 2, (RF, RF_IF),     rd_rm),
18576  cCL("atnsm",   ed08140, 2, (RF, RF_IF),     rd_rm),
18577  cCL("atnsz",   ed08160, 2, (RF, RF_IF),     rd_rm),
18578  cCL("atnd",    ed08180, 2, (RF, RF_IF),     rd_rm),
18579  cCL("atndp",   ed081a0, 2, (RF, RF_IF),     rd_rm),
18580  cCL("atndm",   ed081c0, 2, (RF, RF_IF),     rd_rm),
18581  cCL("atndz",   ed081e0, 2, (RF, RF_IF),     rd_rm),
18582  cCL("atne",    ed88100, 2, (RF, RF_IF),     rd_rm),
18583  cCL("atnep",   ed88120, 2, (RF, RF_IF),     rd_rm),
18584  cCL("atnem",   ed88140, 2, (RF, RF_IF),     rd_rm),
18585  cCL("atnez",   ed88160, 2, (RF, RF_IF),     rd_rm),
18586
18587  cCL("urds",    ee08100, 2, (RF, RF_IF),     rd_rm),
18588  cCL("urdsp",   ee08120, 2, (RF, RF_IF),     rd_rm),
18589  cCL("urdsm",   ee08140, 2, (RF, RF_IF),     rd_rm),
18590  cCL("urdsz",   ee08160, 2, (RF, RF_IF),     rd_rm),
18591  cCL("urdd",    ee08180, 2, (RF, RF_IF),     rd_rm),
18592  cCL("urddp",   ee081a0, 2, (RF, RF_IF),     rd_rm),
18593  cCL("urddm",   ee081c0, 2, (RF, RF_IF),     rd_rm),
18594  cCL("urddz",   ee081e0, 2, (RF, RF_IF),     rd_rm),
18595  cCL("urde",    ee88100, 2, (RF, RF_IF),     rd_rm),
18596  cCL("urdep",   ee88120, 2, (RF, RF_IF),     rd_rm),
18597  cCL("urdem",   ee88140, 2, (RF, RF_IF),     rd_rm),
18598  cCL("urdez",   ee88160, 2, (RF, RF_IF),     rd_rm),
18599
18600  cCL("nrms",    ef08100, 2, (RF, RF_IF),     rd_rm),
18601  cCL("nrmsp",   ef08120, 2, (RF, RF_IF),     rd_rm),
18602  cCL("nrmsm",   ef08140, 2, (RF, RF_IF),     rd_rm),
18603  cCL("nrmsz",   ef08160, 2, (RF, RF_IF),     rd_rm),
18604  cCL("nrmd",    ef08180, 2, (RF, RF_IF),     rd_rm),
18605  cCL("nrmdp",   ef081a0, 2, (RF, RF_IF),     rd_rm),
18606  cCL("nrmdm",   ef081c0, 2, (RF, RF_IF),     rd_rm),
18607  cCL("nrmdz",   ef081e0, 2, (RF, RF_IF),     rd_rm),
18608  cCL("nrme",    ef88100, 2, (RF, RF_IF),     rd_rm),
18609  cCL("nrmep",   ef88120, 2, (RF, RF_IF),     rd_rm),
18610  cCL("nrmem",   ef88140, 2, (RF, RF_IF),     rd_rm),
18611  cCL("nrmez",   ef88160, 2, (RF, RF_IF),     rd_rm),
18612
18613  cCL("adfs",    e000100, 3, (RF, RF, RF_IF), rd_rn_rm),
18614  cCL("adfsp",   e000120, 3, (RF, RF, RF_IF), rd_rn_rm),
18615  cCL("adfsm",   e000140, 3, (RF, RF, RF_IF), rd_rn_rm),
18616  cCL("adfsz",   e000160, 3, (RF, RF, RF_IF), rd_rn_rm),
18617  cCL("adfd",    e000180, 3, (RF, RF, RF_IF), rd_rn_rm),
18618  cCL("adfdp",   e0001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18619  cCL("adfdm",   e0001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18620  cCL("adfdz",   e0001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18621  cCL("adfe",    e080100, 3, (RF, RF, RF_IF), rd_rn_rm),
18622  cCL("adfep",   e080120, 3, (RF, RF, RF_IF), rd_rn_rm),
18623  cCL("adfem",   e080140, 3, (RF, RF, RF_IF), rd_rn_rm),
18624  cCL("adfez",   e080160, 3, (RF, RF, RF_IF), rd_rn_rm),
18625
18626  cCL("sufs",    e200100, 3, (RF, RF, RF_IF), rd_rn_rm),
18627  cCL("sufsp",   e200120, 3, (RF, RF, RF_IF), rd_rn_rm),
18628  cCL("sufsm",   e200140, 3, (RF, RF, RF_IF), rd_rn_rm),
18629  cCL("sufsz",   e200160, 3, (RF, RF, RF_IF), rd_rn_rm),
18630  cCL("sufd",    e200180, 3, (RF, RF, RF_IF), rd_rn_rm),
18631  cCL("sufdp",   e2001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18632  cCL("sufdm",   e2001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18633  cCL("sufdz",   e2001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18634  cCL("sufe",    e280100, 3, (RF, RF, RF_IF), rd_rn_rm),
18635  cCL("sufep",   e280120, 3, (RF, RF, RF_IF), rd_rn_rm),
18636  cCL("sufem",   e280140, 3, (RF, RF, RF_IF), rd_rn_rm),
18637  cCL("sufez",   e280160, 3, (RF, RF, RF_IF), rd_rn_rm),
18638
18639  cCL("rsfs",    e300100, 3, (RF, RF, RF_IF), rd_rn_rm),
18640  cCL("rsfsp",   e300120, 3, (RF, RF, RF_IF), rd_rn_rm),
18641  cCL("rsfsm",   e300140, 3, (RF, RF, RF_IF), rd_rn_rm),
18642  cCL("rsfsz",   e300160, 3, (RF, RF, RF_IF), rd_rn_rm),
18643  cCL("rsfd",    e300180, 3, (RF, RF, RF_IF), rd_rn_rm),
18644  cCL("rsfdp",   e3001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18645  cCL("rsfdm",   e3001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18646  cCL("rsfdz",   e3001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18647  cCL("rsfe",    e380100, 3, (RF, RF, RF_IF), rd_rn_rm),
18648  cCL("rsfep",   e380120, 3, (RF, RF, RF_IF), rd_rn_rm),
18649  cCL("rsfem",   e380140, 3, (RF, RF, RF_IF), rd_rn_rm),
18650  cCL("rsfez",   e380160, 3, (RF, RF, RF_IF), rd_rn_rm),
18651
18652  cCL("mufs",    e100100, 3, (RF, RF, RF_IF), rd_rn_rm),
18653  cCL("mufsp",   e100120, 3, (RF, RF, RF_IF), rd_rn_rm),
18654  cCL("mufsm",   e100140, 3, (RF, RF, RF_IF), rd_rn_rm),
18655  cCL("mufsz",   e100160, 3, (RF, RF, RF_IF), rd_rn_rm),
18656  cCL("mufd",    e100180, 3, (RF, RF, RF_IF), rd_rn_rm),
18657  cCL("mufdp",   e1001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18658  cCL("mufdm",   e1001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18659  cCL("mufdz",   e1001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18660  cCL("mufe",    e180100, 3, (RF, RF, RF_IF), rd_rn_rm),
18661  cCL("mufep",   e180120, 3, (RF, RF, RF_IF), rd_rn_rm),
18662  cCL("mufem",   e180140, 3, (RF, RF, RF_IF), rd_rn_rm),
18663  cCL("mufez",   e180160, 3, (RF, RF, RF_IF), rd_rn_rm),
18664
18665  cCL("dvfs",    e400100, 3, (RF, RF, RF_IF), rd_rn_rm),
18666  cCL("dvfsp",   e400120, 3, (RF, RF, RF_IF), rd_rn_rm),
18667  cCL("dvfsm",   e400140, 3, (RF, RF, RF_IF), rd_rn_rm),
18668  cCL("dvfsz",   e400160, 3, (RF, RF, RF_IF), rd_rn_rm),
18669  cCL("dvfd",    e400180, 3, (RF, RF, RF_IF), rd_rn_rm),
18670  cCL("dvfdp",   e4001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18671  cCL("dvfdm",   e4001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18672  cCL("dvfdz",   e4001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18673  cCL("dvfe",    e480100, 3, (RF, RF, RF_IF), rd_rn_rm),
18674  cCL("dvfep",   e480120, 3, (RF, RF, RF_IF), rd_rn_rm),
18675  cCL("dvfem",   e480140, 3, (RF, RF, RF_IF), rd_rn_rm),
18676  cCL("dvfez",   e480160, 3, (RF, RF, RF_IF), rd_rn_rm),
18677
18678  cCL("rdfs",    e500100, 3, (RF, RF, RF_IF), rd_rn_rm),
18679  cCL("rdfsp",   e500120, 3, (RF, RF, RF_IF), rd_rn_rm),
18680  cCL("rdfsm",   e500140, 3, (RF, RF, RF_IF), rd_rn_rm),
18681  cCL("rdfsz",   e500160, 3, (RF, RF, RF_IF), rd_rn_rm),
18682  cCL("rdfd",    e500180, 3, (RF, RF, RF_IF), rd_rn_rm),
18683  cCL("rdfdp",   e5001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18684  cCL("rdfdm",   e5001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18685  cCL("rdfdz",   e5001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18686  cCL("rdfe",    e580100, 3, (RF, RF, RF_IF), rd_rn_rm),
18687  cCL("rdfep",   e580120, 3, (RF, RF, RF_IF), rd_rn_rm),
18688  cCL("rdfem",   e580140, 3, (RF, RF, RF_IF), rd_rn_rm),
18689  cCL("rdfez",   e580160, 3, (RF, RF, RF_IF), rd_rn_rm),
18690
18691  cCL("pows",    e600100, 3, (RF, RF, RF_IF), rd_rn_rm),
18692  cCL("powsp",   e600120, 3, (RF, RF, RF_IF), rd_rn_rm),
18693  cCL("powsm",   e600140, 3, (RF, RF, RF_IF), rd_rn_rm),
18694  cCL("powsz",   e600160, 3, (RF, RF, RF_IF), rd_rn_rm),
18695  cCL("powd",    e600180, 3, (RF, RF, RF_IF), rd_rn_rm),
18696  cCL("powdp",   e6001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18697  cCL("powdm",   e6001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18698  cCL("powdz",   e6001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18699  cCL("powe",    e680100, 3, (RF, RF, RF_IF), rd_rn_rm),
18700  cCL("powep",   e680120, 3, (RF, RF, RF_IF), rd_rn_rm),
18701  cCL("powem",   e680140, 3, (RF, RF, RF_IF), rd_rn_rm),
18702  cCL("powez",   e680160, 3, (RF, RF, RF_IF), rd_rn_rm),
18703
18704  cCL("rpws",    e700100, 3, (RF, RF, RF_IF), rd_rn_rm),
18705  cCL("rpwsp",   e700120, 3, (RF, RF, RF_IF), rd_rn_rm),
18706  cCL("rpwsm",   e700140, 3, (RF, RF, RF_IF), rd_rn_rm),
18707  cCL("rpwsz",   e700160, 3, (RF, RF, RF_IF), rd_rn_rm),
18708  cCL("rpwd",    e700180, 3, (RF, RF, RF_IF), rd_rn_rm),
18709  cCL("rpwdp",   e7001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18710  cCL("rpwdm",   e7001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18711  cCL("rpwdz",   e7001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18712  cCL("rpwe",    e780100, 3, (RF, RF, RF_IF), rd_rn_rm),
18713  cCL("rpwep",   e780120, 3, (RF, RF, RF_IF), rd_rn_rm),
18714  cCL("rpwem",   e780140, 3, (RF, RF, RF_IF), rd_rn_rm),
18715  cCL("rpwez",   e780160, 3, (RF, RF, RF_IF), rd_rn_rm),
18716
18717  cCL("rmfs",    e800100, 3, (RF, RF, RF_IF), rd_rn_rm),
18718  cCL("rmfsp",   e800120, 3, (RF, RF, RF_IF), rd_rn_rm),
18719  cCL("rmfsm",   e800140, 3, (RF, RF, RF_IF), rd_rn_rm),
18720  cCL("rmfsz",   e800160, 3, (RF, RF, RF_IF), rd_rn_rm),
18721  cCL("rmfd",    e800180, 3, (RF, RF, RF_IF), rd_rn_rm),
18722  cCL("rmfdp",   e8001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18723  cCL("rmfdm",   e8001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18724  cCL("rmfdz",   e8001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18725  cCL("rmfe",    e880100, 3, (RF, RF, RF_IF), rd_rn_rm),
18726  cCL("rmfep",   e880120, 3, (RF, RF, RF_IF), rd_rn_rm),
18727  cCL("rmfem",   e880140, 3, (RF, RF, RF_IF), rd_rn_rm),
18728  cCL("rmfez",   e880160, 3, (RF, RF, RF_IF), rd_rn_rm),
18729
18730  cCL("fmls",    e900100, 3, (RF, RF, RF_IF), rd_rn_rm),
18731  cCL("fmlsp",   e900120, 3, (RF, RF, RF_IF), rd_rn_rm),
18732  cCL("fmlsm",   e900140, 3, (RF, RF, RF_IF), rd_rn_rm),
18733  cCL("fmlsz",   e900160, 3, (RF, RF, RF_IF), rd_rn_rm),
18734  cCL("fmld",    e900180, 3, (RF, RF, RF_IF), rd_rn_rm),
18735  cCL("fmldp",   e9001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18736  cCL("fmldm",   e9001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18737  cCL("fmldz",   e9001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18738  cCL("fmle",    e980100, 3, (RF, RF, RF_IF), rd_rn_rm),
18739  cCL("fmlep",   e980120, 3, (RF, RF, RF_IF), rd_rn_rm),
18740  cCL("fmlem",   e980140, 3, (RF, RF, RF_IF), rd_rn_rm),
18741  cCL("fmlez",   e980160, 3, (RF, RF, RF_IF), rd_rn_rm),
18742
18743  cCL("fdvs",    ea00100, 3, (RF, RF, RF_IF), rd_rn_rm),
18744  cCL("fdvsp",   ea00120, 3, (RF, RF, RF_IF), rd_rn_rm),
18745  cCL("fdvsm",   ea00140, 3, (RF, RF, RF_IF), rd_rn_rm),
18746  cCL("fdvsz",   ea00160, 3, (RF, RF, RF_IF), rd_rn_rm),
18747  cCL("fdvd",    ea00180, 3, (RF, RF, RF_IF), rd_rn_rm),
18748  cCL("fdvdp",   ea001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18749  cCL("fdvdm",   ea001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18750  cCL("fdvdz",   ea001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18751  cCL("fdve",    ea80100, 3, (RF, RF, RF_IF), rd_rn_rm),
18752  cCL("fdvep",   ea80120, 3, (RF, RF, RF_IF), rd_rn_rm),
18753  cCL("fdvem",   ea80140, 3, (RF, RF, RF_IF), rd_rn_rm),
18754  cCL("fdvez",   ea80160, 3, (RF, RF, RF_IF), rd_rn_rm),
18755
18756  cCL("frds",    eb00100, 3, (RF, RF, RF_IF), rd_rn_rm),
18757  cCL("frdsp",   eb00120, 3, (RF, RF, RF_IF), rd_rn_rm),
18758  cCL("frdsm",   eb00140, 3, (RF, RF, RF_IF), rd_rn_rm),
18759  cCL("frdsz",   eb00160, 3, (RF, RF, RF_IF), rd_rn_rm),
18760  cCL("frdd",    eb00180, 3, (RF, RF, RF_IF), rd_rn_rm),
18761  cCL("frddp",   eb001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18762  cCL("frddm",   eb001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18763  cCL("frddz",   eb001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18764  cCL("frde",    eb80100, 3, (RF, RF, RF_IF), rd_rn_rm),
18765  cCL("frdep",   eb80120, 3, (RF, RF, RF_IF), rd_rn_rm),
18766  cCL("frdem",   eb80140, 3, (RF, RF, RF_IF), rd_rn_rm),
18767  cCL("frdez",   eb80160, 3, (RF, RF, RF_IF), rd_rn_rm),
18768
18769  cCL("pols",    ec00100, 3, (RF, RF, RF_IF), rd_rn_rm),
18770  cCL("polsp",   ec00120, 3, (RF, RF, RF_IF), rd_rn_rm),
18771  cCL("polsm",   ec00140, 3, (RF, RF, RF_IF), rd_rn_rm),
18772  cCL("polsz",   ec00160, 3, (RF, RF, RF_IF), rd_rn_rm),
18773  cCL("pold",    ec00180, 3, (RF, RF, RF_IF), rd_rn_rm),
18774  cCL("poldp",   ec001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
18775  cCL("poldm",   ec001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
18776  cCL("poldz",   ec001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
18777  cCL("pole",    ec80100, 3, (RF, RF, RF_IF), rd_rn_rm),
18778  cCL("polep",   ec80120, 3, (RF, RF, RF_IF), rd_rn_rm),
18779  cCL("polem",   ec80140, 3, (RF, RF, RF_IF), rd_rn_rm),
18780  cCL("polez",   ec80160, 3, (RF, RF, RF_IF), rd_rn_rm),
18781
18782  cCE("cmf",     e90f110, 2, (RF, RF_IF),     fpa_cmp),
18783  C3E("cmfe",    ed0f110, 2, (RF, RF_IF),     fpa_cmp),
18784  cCE("cnf",     eb0f110, 2, (RF, RF_IF),     fpa_cmp),
18785  C3E("cnfe",    ef0f110, 2, (RF, RF_IF),     fpa_cmp),
18786
18787  cCL("flts",    e000110, 2, (RF, RR),        rn_rd),
18788  cCL("fltsp",   e000130, 2, (RF, RR),        rn_rd),
18789  cCL("fltsm",   e000150, 2, (RF, RR),        rn_rd),
18790  cCL("fltsz",   e000170, 2, (RF, RR),        rn_rd),
18791  cCL("fltd",    e000190, 2, (RF, RR),        rn_rd),
18792  cCL("fltdp",   e0001b0, 2, (RF, RR),        rn_rd),
18793  cCL("fltdm",   e0001d0, 2, (RF, RR),        rn_rd),
18794  cCL("fltdz",   e0001f0, 2, (RF, RR),        rn_rd),
18795  cCL("flte",    e080110, 2, (RF, RR),        rn_rd),
18796  cCL("fltep",   e080130, 2, (RF, RR),        rn_rd),
18797  cCL("fltem",   e080150, 2, (RF, RR),        rn_rd),
18798  cCL("fltez",   e080170, 2, (RF, RR),        rn_rd),
18799
18800   /* The implementation of the FIX instruction is broken on some
18801      assemblers, in that it accepts a precision specifier as well as a
18802      rounding specifier, despite the fact that this is meaningless.
18803      To be more compatible, we accept it as well, though of course it
18804      does not set any bits.  */
18805  cCE("fix",     e100110, 2, (RR, RF),        rd_rm),
18806  cCL("fixp",    e100130, 2, (RR, RF),        rd_rm),
18807  cCL("fixm",    e100150, 2, (RR, RF),        rd_rm),
18808  cCL("fixz",    e100170, 2, (RR, RF),        rd_rm),
18809  cCL("fixsp",   e100130, 2, (RR, RF),        rd_rm),
18810  cCL("fixsm",   e100150, 2, (RR, RF),        rd_rm),
18811  cCL("fixsz",   e100170, 2, (RR, RF),        rd_rm),
18812  cCL("fixdp",   e100130, 2, (RR, RF),        rd_rm),
18813  cCL("fixdm",   e100150, 2, (RR, RF),        rd_rm),
18814  cCL("fixdz",   e100170, 2, (RR, RF),        rd_rm),
18815  cCL("fixep",   e100130, 2, (RR, RF),        rd_rm),
18816  cCL("fixem",   e100150, 2, (RR, RF),        rd_rm),
18817  cCL("fixez",   e100170, 2, (RR, RF),        rd_rm),
18818
18819   /* Instructions that were new with the real FPA, call them V2.  */
18820 #undef  ARM_VARIANT
18821 #define ARM_VARIANT  & fpu_fpa_ext_v2
18822
18823  cCE("lfm",     c100200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18824  cCL("lfmfd",   c900200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18825  cCL("lfmea",   d100200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18826  cCE("sfm",     c000200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18827  cCL("sfmfd",   d000200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18828  cCL("sfmea",   c800200, 3, (RF, I4b, ADDR), fpa_ldmstm),
18829
18830 #undef  ARM_VARIANT
18831 #define ARM_VARIANT  & fpu_vfp_ext_v1xd  /* VFP V1xD (single precision).  */
18832
18833   /* Moves and type conversions.  */
18834  cCE("fcpys",   eb00a40, 2, (RVS, RVS),       vfp_sp_monadic),
18835  cCE("fmrs",    e100a10, 2, (RR, RVS),        vfp_reg_from_sp),
18836  cCE("fmsr",    e000a10, 2, (RVS, RR),        vfp_sp_from_reg),
18837  cCE("fmstat",  ef1fa10, 0, (),               noargs),
18838  cCE("vmrs",    ef00a10, 2, (APSR_RR, RVC),   vmrs),
18839  cCE("vmsr",    ee00a10, 2, (RVC, RR),        vmsr),
18840  cCE("fsitos",  eb80ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18841  cCE("fuitos",  eb80a40, 2, (RVS, RVS),       vfp_sp_monadic),
18842  cCE("ftosis",  ebd0a40, 2, (RVS, RVS),       vfp_sp_monadic),
18843  cCE("ftosizs", ebd0ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18844  cCE("ftouis",  ebc0a40, 2, (RVS, RVS),       vfp_sp_monadic),
18845  cCE("ftouizs", ebc0ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18846  cCE("fmrx",    ef00a10, 2, (RR, RVC),        rd_rn),
18847  cCE("fmxr",    ee00a10, 2, (RVC, RR),        rn_rd),
18848
18849   /* Memory operations.  */
18850  cCE("flds",    d100a00, 2, (RVS, ADDRGLDC),  vfp_sp_ldst),
18851  cCE("fsts",    d000a00, 2, (RVS, ADDRGLDC),  vfp_sp_ldst),
18852  cCE("fldmias", c900a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
18853  cCE("fldmfds", c900a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
18854  cCE("fldmdbs", d300a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
18855  cCE("fldmeas", d300a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
18856  cCE("fldmiax", c900b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
18857  cCE("fldmfdx", c900b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
18858  cCE("fldmdbx", d300b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
18859  cCE("fldmeax", d300b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
18860  cCE("fstmias", c800a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
18861  cCE("fstmeas", c800a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmia),
18862  cCE("fstmdbs", d200a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
18863  cCE("fstmfds", d200a00, 2, (RRnpctw, VRSLST),    vfp_sp_ldstmdb),
18864  cCE("fstmiax", c800b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
18865  cCE("fstmeax", c800b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmia),
18866  cCE("fstmdbx", d200b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
18867  cCE("fstmfdx", d200b00, 2, (RRnpctw, VRDLST),    vfp_xp_ldstmdb),
18868
18869   /* Monadic operations.  */
18870  cCE("fabss",   eb00ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18871  cCE("fnegs",   eb10a40, 2, (RVS, RVS),       vfp_sp_monadic),
18872  cCE("fsqrts",  eb10ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18873
18874   /* Dyadic operations.  */
18875  cCE("fadds",   e300a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18876  cCE("fsubs",   e300a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18877  cCE("fmuls",   e200a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18878  cCE("fdivs",   e800a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18879  cCE("fmacs",   e000a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18880  cCE("fmscs",   e100a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18881  cCE("fnmuls",  e200a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18882  cCE("fnmacs",  e000a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18883  cCE("fnmscs",  e100a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
18884
18885   /* Comparisons.  */
18886  cCE("fcmps",   eb40a40, 2, (RVS, RVS),       vfp_sp_monadic),
18887  cCE("fcmpzs",  eb50a40, 1, (RVS),            vfp_sp_compare_z),
18888  cCE("fcmpes",  eb40ac0, 2, (RVS, RVS),       vfp_sp_monadic),
18889  cCE("fcmpezs", eb50ac0, 1, (RVS),            vfp_sp_compare_z),
18890
18891  /* Double precision load/store are still present on single precision
18892     implementations.  */
18893  cCE("fldd",    d100b00, 2, (RVD, ADDRGLDC),  vfp_dp_ldst),
18894  cCE("fstd",    d000b00, 2, (RVD, ADDRGLDC),  vfp_dp_ldst),
18895  cCE("fldmiad", c900b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
18896  cCE("fldmfdd", c900b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
18897  cCE("fldmdbd", d300b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
18898  cCE("fldmead", d300b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
18899  cCE("fstmiad", c800b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
18900  cCE("fstmead", c800b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmia),
18901  cCE("fstmdbd", d200b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
18902  cCE("fstmfdd", d200b00, 2, (RRnpctw, VRDLST),    vfp_dp_ldstmdb),
18903
18904 #undef  ARM_VARIANT
18905 #define ARM_VARIANT  & fpu_vfp_ext_v1 /* VFP V1 (Double precision).  */
18906
18907   /* Moves and type conversions.  */
18908  cCE("fcpyd",   eb00b40, 2, (RVD, RVD),       vfp_dp_rd_rm),
18909  cCE("fcvtds",  eb70ac0, 2, (RVD, RVS),       vfp_dp_sp_cvt),
18910  cCE("fcvtsd",  eb70bc0, 2, (RVS, RVD),       vfp_sp_dp_cvt),
18911  cCE("fmdhr",   e200b10, 2, (RVD, RR),        vfp_dp_rn_rd),
18912  cCE("fmdlr",   e000b10, 2, (RVD, RR),        vfp_dp_rn_rd),
18913  cCE("fmrdh",   e300b10, 2, (RR, RVD),        vfp_dp_rd_rn),
18914  cCE("fmrdl",   e100b10, 2, (RR, RVD),        vfp_dp_rd_rn),
18915  cCE("fsitod",  eb80bc0, 2, (RVD, RVS),       vfp_dp_sp_cvt),
18916  cCE("fuitod",  eb80b40, 2, (RVD, RVS),       vfp_dp_sp_cvt),
18917  cCE("ftosid",  ebd0b40, 2, (RVS, RVD),       vfp_sp_dp_cvt),
18918  cCE("ftosizd", ebd0bc0, 2, (RVS, RVD),       vfp_sp_dp_cvt),
18919  cCE("ftouid",  ebc0b40, 2, (RVS, RVD),       vfp_sp_dp_cvt),
18920  cCE("ftouizd", ebc0bc0, 2, (RVS, RVD),       vfp_sp_dp_cvt),
18921
18922   /* Monadic operations.  */
18923  cCE("fabsd",   eb00bc0, 2, (RVD, RVD),       vfp_dp_rd_rm),
18924  cCE("fnegd",   eb10b40, 2, (RVD, RVD),       vfp_dp_rd_rm),
18925  cCE("fsqrtd",  eb10bc0, 2, (RVD, RVD),       vfp_dp_rd_rm),
18926
18927   /* Dyadic operations.  */
18928  cCE("faddd",   e300b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18929  cCE("fsubd",   e300b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18930  cCE("fmuld",   e200b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18931  cCE("fdivd",   e800b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18932  cCE("fmacd",   e000b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18933  cCE("fmscd",   e100b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18934  cCE("fnmuld",  e200b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18935  cCE("fnmacd",  e000b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18936  cCE("fnmscd",  e100b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
18937
18938   /* Comparisons.  */
18939  cCE("fcmpd",   eb40b40, 2, (RVD, RVD),       vfp_dp_rd_rm),
18940  cCE("fcmpzd",  eb50b40, 1, (RVD),            vfp_dp_rd),
18941  cCE("fcmped",  eb40bc0, 2, (RVD, RVD),       vfp_dp_rd_rm),
18942  cCE("fcmpezd", eb50bc0, 1, (RVD),            vfp_dp_rd),
18943
18944 #undef  ARM_VARIANT
18945 #define ARM_VARIANT  & fpu_vfp_ext_v2
18946
18947  cCE("fmsrr",   c400a10, 3, (VRSLST, RR, RR), vfp_sp2_from_reg2),
18948  cCE("fmrrs",   c500a10, 3, (RR, RR, VRSLST), vfp_reg2_from_sp2),
18949  cCE("fmdrr",   c400b10, 3, (RVD, RR, RR),    vfp_dp_rm_rd_rn),
18950  cCE("fmrrd",   c500b10, 3, (RR, RR, RVD),    vfp_dp_rd_rn_rm),
18951
18952 /* Instructions which may belong to either the Neon or VFP instruction sets.
18953    Individual encoder functions perform additional architecture checks.  */
18954 #undef  ARM_VARIANT
18955 #define ARM_VARIANT    & fpu_vfp_ext_v1xd
18956 #undef  THUMB_VARIANT
18957 #define THUMB_VARIANT  & fpu_vfp_ext_v1xd
18958
18959   /* These mnemonics are unique to VFP.  */
18960  NCE(vsqrt,     0,       2, (RVSD, RVSD),       vfp_nsyn_sqrt),
18961  NCE(vdiv,      0,       3, (RVSD, RVSD, RVSD), vfp_nsyn_div),
18962  nCE(vnmul,     _vnmul,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
18963  nCE(vnmla,     _vnmla,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
18964  nCE(vnmls,     _vnmls,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
18965  nCE(vcmp,      _vcmp,    2, (RVSD, RVSD_I0),    vfp_nsyn_cmp),
18966  nCE(vcmpe,     _vcmpe,   2, (RVSD, RVSD_I0),    vfp_nsyn_cmp),
18967  NCE(vpush,     0,       1, (VRSDLST),          vfp_nsyn_push),
18968  NCE(vpop,      0,       1, (VRSDLST),          vfp_nsyn_pop),
18969  NCE(vcvtz,     0,       2, (RVSD, RVSD),       vfp_nsyn_cvtz),
18970
18971   /* Mnemonics shared by Neon and VFP.  */
18972  nCEF(vmul,     _vmul,    3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mul),
18973  nCEF(vmla,     _vmla,    3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mac_maybe_scalar),
18974  nCEF(vmls,     _vmls,    3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mac_maybe_scalar),
18975
18976  nCEF(vadd,     _vadd,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_addsub_if_i),
18977  nCEF(vsub,     _vsub,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_addsub_if_i),
18978
18979  NCEF(vabs,     1b10300, 2, (RNSDQ, RNSDQ), neon_abs_neg),
18980  NCEF(vneg,     1b10380, 2, (RNSDQ, RNSDQ), neon_abs_neg),
18981
18982  NCE(vldm,      c900b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18983  NCE(vldmia,    c900b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18984  NCE(vldmdb,    d100b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18985  NCE(vstm,      c800b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18986  NCE(vstmia,    c800b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18987  NCE(vstmdb,    d000b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
18988  NCE(vldr,      d100b00, 2, (RVSD, ADDRGLDC), neon_ldr_str),
18989  NCE(vstr,      d000b00, 2, (RVSD, ADDRGLDC), neon_ldr_str),
18990
18991  nCEF(vcvt,     _vcvt,   3, (RNSDQ, RNSDQ, oI32z), neon_cvt),
18992  nCEF(vcvtr,    _vcvt,   2, (RNSDQ, RNSDQ), neon_cvtr),
18993  NCEF(vcvtb,    eb20a40, 2, (RVSD, RVSD), neon_cvtb),
18994  NCEF(vcvtt,    eb20a40, 2, (RVSD, RVSD), neon_cvtt),
18995
18996
18997   /* NOTE: All VMOV encoding is special-cased!  */
18998  NCE(vmov,      0,       1, (VMOV), neon_mov),
18999  NCE(vmovq,     0,       1, (VMOV), neon_mov),
19000
19001 #undef  THUMB_VARIANT
19002 #define THUMB_VARIANT  & fpu_neon_ext_v1
19003 #undef  ARM_VARIANT
19004 #define ARM_VARIANT    & fpu_neon_ext_v1
19005
19006   /* Data processing with three registers of the same length.  */
19007   /* integer ops, valid types S8 S16 S32 U8 U16 U32.  */
19008  NUF(vaba,      0000710, 3, (RNDQ, RNDQ,  RNDQ), neon_dyadic_i_su),
19009  NUF(vabaq,     0000710, 3, (RNQ,  RNQ,   RNQ),  neon_dyadic_i_su),
19010  NUF(vhadd,     0000000, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
19011  NUF(vhaddq,    0000000, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i_su),
19012  NUF(vrhadd,    0000100, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
19013  NUF(vrhaddq,   0000100, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i_su),
19014  NUF(vhsub,     0000200, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
19015  NUF(vhsubq,    0000200, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i_su),
19016   /* integer ops, valid types S8 S16 S32 S64 U8 U16 U32 U64.  */
19017  NUF(vqadd,     0000010, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i64_su),
19018  NUF(vqaddq,    0000010, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i64_su),
19019  NUF(vqsub,     0000210, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i64_su),
19020  NUF(vqsubq,    0000210, 3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_i64_su),
19021  NUF(vrshl,     0000500, 3, (RNDQ, oRNDQ, RNDQ), neon_rshl),
19022  NUF(vrshlq,    0000500, 3, (RNQ,  oRNQ,  RNQ),  neon_rshl),
19023  NUF(vqrshl,    0000510, 3, (RNDQ, oRNDQ, RNDQ), neon_rshl),
19024  NUF(vqrshlq,   0000510, 3, (RNQ,  oRNQ,  RNQ),  neon_rshl),
19025   /* If not immediate, fall back to neon_dyadic_i64_su.
19026      shl_imm should accept I8 I16 I32 I64,
19027      qshl_imm should accept S8 S16 S32 S64 U8 U16 U32 U64.  */
19028  nUF(vshl,      _vshl,    3, (RNDQ, oRNDQ, RNDQ_I63b), neon_shl_imm),
19029  nUF(vshlq,     _vshl,    3, (RNQ,  oRNQ,  RNDQ_I63b), neon_shl_imm),
19030  nUF(vqshl,     _vqshl,   3, (RNDQ, oRNDQ, RNDQ_I63b), neon_qshl_imm),
19031  nUF(vqshlq,    _vqshl,   3, (RNQ,  oRNQ,  RNDQ_I63b), neon_qshl_imm),
19032   /* Logic ops, types optional & ignored.  */
19033  nUF(vand,      _vand,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
19034  nUF(vandq,     _vand,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
19035  nUF(vbic,      _vbic,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
19036  nUF(vbicq,     _vbic,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
19037  nUF(vorr,      _vorr,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
19038  nUF(vorrq,     _vorr,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
19039  nUF(vorn,      _vorn,    3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
19040  nUF(vornq,     _vorn,    3, (RNQ,  oRNQ,  RNDQ_Ibig), neon_logic),
19041  nUF(veor,      _veor,    3, (RNDQ, oRNDQ, RNDQ),      neon_logic),
19042  nUF(veorq,     _veor,    3, (RNQ,  oRNQ,  RNQ),       neon_logic),
19043   /* Bitfield ops, untyped.  */
19044  NUF(vbsl,      1100110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
19045  NUF(vbslq,     1100110, 3, (RNQ,  RNQ,  RNQ),  neon_bitfield),
19046  NUF(vbit,      1200110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
19047  NUF(vbitq,     1200110, 3, (RNQ,  RNQ,  RNQ),  neon_bitfield),
19048  NUF(vbif,      1300110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
19049  NUF(vbifq,     1300110, 3, (RNQ,  RNQ,  RNQ),  neon_bitfield),
19050   /* Int and float variants, types S8 S16 S32 U8 U16 U32 F32.  */
19051  nUF(vabd,      _vabd,    3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
19052  nUF(vabdq,     _vabd,    3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_if_su),
19053  nUF(vmax,      _vmax,    3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
19054  nUF(vmaxq,     _vmax,    3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_if_su),
19055  nUF(vmin,      _vmin,    3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
19056  nUF(vminq,     _vmin,    3, (RNQ,  oRNQ,  RNQ),  neon_dyadic_if_su),
19057   /* Comparisons. Types S8 S16 S32 U8 U16 U32 F32. Non-immediate versions fall
19058      back to neon_dyadic_if_su.  */
19059  nUF(vcge,      _vcge,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp),
19060  nUF(vcgeq,     _vcge,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp),
19061  nUF(vcgt,      _vcgt,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp),
19062  nUF(vcgtq,     _vcgt,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp),
19063  nUF(vclt,      _vclt,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp_inv),
19064  nUF(vcltq,     _vclt,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp_inv),
19065  nUF(vcle,      _vcle,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp_inv),
19066  nUF(vcleq,     _vcle,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_cmp_inv),
19067   /* Comparison. Type I8 I16 I32 F32.  */
19068  nUF(vceq,      _vceq,    3, (RNDQ, oRNDQ, RNDQ_I0), neon_ceq),
19069  nUF(vceqq,     _vceq,    3, (RNQ,  oRNQ,  RNDQ_I0), neon_ceq),
19070   /* As above, D registers only.  */
19071  nUF(vpmax,     _vpmax,   3, (RND, oRND, RND), neon_dyadic_if_su_d),
19072  nUF(vpmin,     _vpmin,   3, (RND, oRND, RND), neon_dyadic_if_su_d),
19073   /* Int and float variants, signedness unimportant.  */
19074  nUF(vmlaq,     _vmla,    3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_mac_maybe_scalar),
19075  nUF(vmlsq,     _vmls,    3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_mac_maybe_scalar),
19076  nUF(vpadd,     _vpadd,   3, (RND,  oRND,  RND),       neon_dyadic_if_i_d),
19077   /* Add/sub take types I8 I16 I32 I64 F32.  */
19078  nUF(vaddq,     _vadd,    3, (RNQ,  oRNQ,  RNQ),  neon_addsub_if_i),
19079  nUF(vsubq,     _vsub,    3, (RNQ,  oRNQ,  RNQ),  neon_addsub_if_i),
19080   /* vtst takes sizes 8, 16, 32.  */
19081  NUF(vtst,      0000810, 3, (RNDQ, oRNDQ, RNDQ), neon_tst),
19082  NUF(vtstq,     0000810, 3, (RNQ,  oRNQ,  RNQ),  neon_tst),
19083   /* VMUL takes I8 I16 I32 F32 P8.  */
19084  nUF(vmulq,     _vmul,     3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_mul),
19085   /* VQD{R}MULH takes S16 S32.  */
19086  nUF(vqdmulh,   _vqdmulh,  3, (RNDQ, oRNDQ, RNDQ_RNSC), neon_qdmulh),
19087  nUF(vqdmulhq,  _vqdmulh,  3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_qdmulh),
19088  nUF(vqrdmulh,  _vqrdmulh, 3, (RNDQ, oRNDQ, RNDQ_RNSC), neon_qdmulh),
19089  nUF(vqrdmulhq, _vqrdmulh, 3, (RNQ,  oRNQ,  RNDQ_RNSC), neon_qdmulh),
19090  NUF(vacge,     0000e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute),
19091  NUF(vacgeq,    0000e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute),
19092  NUF(vacgt,     0200e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute),
19093  NUF(vacgtq,    0200e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute),
19094  NUF(vaclt,     0200e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute_inv),
19095  NUF(vacltq,    0200e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute_inv),
19096  NUF(vacle,     0000e10,  3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute_inv),
19097  NUF(vacleq,    0000e10,  3, (RNQ,  oRNQ,  RNQ),  neon_fcmp_absolute_inv),
19098  NUF(vrecps,    0000f10,  3, (RNDQ, oRNDQ, RNDQ), neon_step),
19099  NUF(vrecpsq,   0000f10,  3, (RNQ,  oRNQ,  RNQ),  neon_step),
19100  NUF(vrsqrts,   0200f10,  3, (RNDQ, oRNDQ, RNDQ), neon_step),
19101  NUF(vrsqrtsq,  0200f10,  3, (RNQ,  oRNQ,  RNQ),  neon_step),
19102
19103   /* Two address, int/float. Types S8 S16 S32 F32.  */
19104  NUF(vabsq,     1b10300, 2, (RNQ,  RNQ),      neon_abs_neg),
19105  NUF(vnegq,     1b10380, 2, (RNQ,  RNQ),      neon_abs_neg),
19106
19107   /* Data processing with two registers and a shift amount.  */
19108   /* Right shifts, and variants with rounding.
19109      Types accepted S8 S16 S32 S64 U8 U16 U32 U64.  */
19110  NUF(vshr,      0800010, 3, (RNDQ, oRNDQ, I64z), neon_rshift_round_imm),
19111  NUF(vshrq,     0800010, 3, (RNQ,  oRNQ,  I64z), neon_rshift_round_imm),
19112  NUF(vrshr,     0800210, 3, (RNDQ, oRNDQ, I64z), neon_rshift_round_imm),
19113  NUF(vrshrq,    0800210, 3, (RNQ,  oRNQ,  I64z), neon_rshift_round_imm),
19114  NUF(vsra,      0800110, 3, (RNDQ, oRNDQ, I64),  neon_rshift_round_imm),
19115  NUF(vsraq,     0800110, 3, (RNQ,  oRNQ,  I64),  neon_rshift_round_imm),
19116  NUF(vrsra,     0800310, 3, (RNDQ, oRNDQ, I64),  neon_rshift_round_imm),
19117  NUF(vrsraq,    0800310, 3, (RNQ,  oRNQ,  I64),  neon_rshift_round_imm),
19118   /* Shift and insert. Sizes accepted 8 16 32 64.  */
19119  NUF(vsli,      1800510, 3, (RNDQ, oRNDQ, I63), neon_sli),
19120  NUF(vsliq,     1800510, 3, (RNQ,  oRNQ,  I63), neon_sli),
19121  NUF(vsri,      1800410, 3, (RNDQ, oRNDQ, I64), neon_sri),
19122  NUF(vsriq,     1800410, 3, (RNQ,  oRNQ,  I64), neon_sri),
19123   /* QSHL{U} immediate accepts S8 S16 S32 S64 U8 U16 U32 U64.  */
19124  NUF(vqshlu,    1800610, 3, (RNDQ, oRNDQ, I63), neon_qshlu_imm),
19125  NUF(vqshluq,   1800610, 3, (RNQ,  oRNQ,  I63), neon_qshlu_imm),
19126   /* Right shift immediate, saturating & narrowing, with rounding variants.
19127      Types accepted S16 S32 S64 U16 U32 U64.  */
19128  NUF(vqshrn,    0800910, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow),
19129  NUF(vqrshrn,   0800950, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow),
19130   /* As above, unsigned. Types accepted S16 S32 S64.  */
19131  NUF(vqshrun,   0800810, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow_u),
19132  NUF(vqrshrun,  0800850, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow_u),
19133   /* Right shift narrowing. Types accepted I16 I32 I64.  */
19134  NUF(vshrn,     0800810, 3, (RND, RNQ, I32z), neon_rshift_narrow),
19135  NUF(vrshrn,    0800850, 3, (RND, RNQ, I32z), neon_rshift_narrow),
19136   /* Special case. Types S8 S16 S32 U8 U16 U32. Handles max shift variant.  */
19137  nUF(vshll,     _vshll,   3, (RNQ, RND, I32),  neon_shll),
19138   /* CVT with optional immediate for fixed-point variant.  */
19139  nUF(vcvtq,     _vcvt,    3, (RNQ, RNQ, oI32b), neon_cvt),
19140
19141  nUF(vmvn,      _vmvn,    2, (RNDQ, RNDQ_Ibig), neon_mvn),
19142  nUF(vmvnq,     _vmvn,    2, (RNQ,  RNDQ_Ibig), neon_mvn),
19143
19144   /* Data processing, three registers of different lengths.  */
19145   /* Dyadic, long insns. Types S8 S16 S32 U8 U16 U32.  */
19146  NUF(vabal,     0800500, 3, (RNQ, RND, RND),  neon_abal),
19147  NUF(vabdl,     0800700, 3, (RNQ, RND, RND),  neon_dyadic_long),
19148  NUF(vaddl,     0800000, 3, (RNQ, RND, RND),  neon_dyadic_long),
19149  NUF(vsubl,     0800200, 3, (RNQ, RND, RND),  neon_dyadic_long),
19150   /* If not scalar, fall back to neon_dyadic_long.
19151      Vector types as above, scalar types S16 S32 U16 U32.  */
19152  nUF(vmlal,     _vmlal,   3, (RNQ, RND, RND_RNSC), neon_mac_maybe_scalar_long),
19153  nUF(vmlsl,     _vmlsl,   3, (RNQ, RND, RND_RNSC), neon_mac_maybe_scalar_long),
19154   /* Dyadic, widening insns. Types S8 S16 S32 U8 U16 U32.  */
19155  NUF(vaddw,     0800100, 3, (RNQ, oRNQ, RND), neon_dyadic_wide),
19156  NUF(vsubw,     0800300, 3, (RNQ, oRNQ, RND), neon_dyadic_wide),
19157   /* Dyadic, narrowing insns. Types I16 I32 I64.  */
19158  NUF(vaddhn,    0800400, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
19159  NUF(vraddhn,   1800400, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
19160  NUF(vsubhn,    0800600, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
19161  NUF(vrsubhn,   1800600, 3, (RND, RNQ, RNQ),  neon_dyadic_narrow),
19162   /* Saturating doubling multiplies. Types S16 S32.  */
19163  nUF(vqdmlal,   _vqdmlal, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
19164  nUF(vqdmlsl,   _vqdmlsl, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
19165  nUF(vqdmull,   _vqdmull, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
19166   /* VMULL. Vector types S8 S16 S32 U8 U16 U32 P8, scalar types
19167      S16 S32 U16 U32.  */
19168  nUF(vmull,     _vmull,   3, (RNQ, RND, RND_RNSC), neon_vmull),
19169
19170   /* Extract. Size 8.  */
19171  NUF(vext,      0b00000, 4, (RNDQ, oRNDQ, RNDQ, I15), neon_ext),
19172  NUF(vextq,     0b00000, 4, (RNQ,  oRNQ,  RNQ,  I15), neon_ext),
19173
19174   /* Two registers, miscellaneous.  */
19175   /* Reverse. Sizes 8 16 32 (must be < size in opcode).  */
19176  NUF(vrev64,    1b00000, 2, (RNDQ, RNDQ),     neon_rev),
19177  NUF(vrev64q,   1b00000, 2, (RNQ,  RNQ),      neon_rev),
19178  NUF(vrev32,    1b00080, 2, (RNDQ, RNDQ),     neon_rev),
19179  NUF(vrev32q,   1b00080, 2, (RNQ,  RNQ),      neon_rev),
19180  NUF(vrev16,    1b00100, 2, (RNDQ, RNDQ),     neon_rev),
19181  NUF(vrev16q,   1b00100, 2, (RNQ,  RNQ),      neon_rev),
19182   /* Vector replicate. Sizes 8 16 32.  */
19183  nCE(vdup,      _vdup,    2, (RNDQ, RR_RNSC),  neon_dup),
19184  nCE(vdupq,     _vdup,    2, (RNQ,  RR_RNSC),  neon_dup),
19185   /* VMOVL. Types S8 S16 S32 U8 U16 U32.  */
19186  NUF(vmovl,     0800a10, 2, (RNQ, RND),       neon_movl),
19187   /* VMOVN. Types I16 I32 I64.  */
19188  nUF(vmovn,     _vmovn,   2, (RND, RNQ),       neon_movn),
19189   /* VQMOVN. Types S16 S32 S64 U16 U32 U64.  */
19190  nUF(vqmovn,    _vqmovn,  2, (RND, RNQ),       neon_qmovn),
19191   /* VQMOVUN. Types S16 S32 S64.  */
19192  nUF(vqmovun,   _vqmovun, 2, (RND, RNQ),       neon_qmovun),
19193   /* VZIP / VUZP. Sizes 8 16 32.  */
19194  NUF(vzip,      1b20180, 2, (RNDQ, RNDQ),     neon_zip_uzp),
19195  NUF(vzipq,     1b20180, 2, (RNQ,  RNQ),      neon_zip_uzp),
19196  NUF(vuzp,      1b20100, 2, (RNDQ, RNDQ),     neon_zip_uzp),
19197  NUF(vuzpq,     1b20100, 2, (RNQ,  RNQ),      neon_zip_uzp),
19198   /* VQABS / VQNEG. Types S8 S16 S32.  */
19199  NUF(vqabs,     1b00700, 2, (RNDQ, RNDQ),     neon_sat_abs_neg),
19200  NUF(vqabsq,    1b00700, 2, (RNQ,  RNQ),      neon_sat_abs_neg),
19201  NUF(vqneg,     1b00780, 2, (RNDQ, RNDQ),     neon_sat_abs_neg),
19202  NUF(vqnegq,    1b00780, 2, (RNQ,  RNQ),      neon_sat_abs_neg),
19203   /* Pairwise, lengthening. Types S8 S16 S32 U8 U16 U32.  */
19204  NUF(vpadal,    1b00600, 2, (RNDQ, RNDQ),     neon_pair_long),
19205  NUF(vpadalq,   1b00600, 2, (RNQ,  RNQ),      neon_pair_long),
19206  NUF(vpaddl,    1b00200, 2, (RNDQ, RNDQ),     neon_pair_long),
19207  NUF(vpaddlq,   1b00200, 2, (RNQ,  RNQ),      neon_pair_long),
19208   /* Reciprocal estimates. Types U32 F32.  */
19209  NUF(vrecpe,    1b30400, 2, (RNDQ, RNDQ),     neon_recip_est),
19210  NUF(vrecpeq,   1b30400, 2, (RNQ,  RNQ),      neon_recip_est),
19211  NUF(vrsqrte,   1b30480, 2, (RNDQ, RNDQ),     neon_recip_est),
19212  NUF(vrsqrteq,  1b30480, 2, (RNQ,  RNQ),      neon_recip_est),
19213   /* VCLS. Types S8 S16 S32.  */
19214  NUF(vcls,      1b00400, 2, (RNDQ, RNDQ),     neon_cls),
19215  NUF(vclsq,     1b00400, 2, (RNQ,  RNQ),      neon_cls),
19216   /* VCLZ. Types I8 I16 I32.  */
19217  NUF(vclz,      1b00480, 2, (RNDQ, RNDQ),     neon_clz),
19218  NUF(vclzq,     1b00480, 2, (RNQ,  RNQ),      neon_clz),
19219   /* VCNT. Size 8.  */
19220  NUF(vcnt,      1b00500, 2, (RNDQ, RNDQ),     neon_cnt),
19221  NUF(vcntq,     1b00500, 2, (RNQ,  RNQ),      neon_cnt),
19222   /* Two address, untyped.  */
19223  NUF(vswp,      1b20000, 2, (RNDQ, RNDQ),     neon_swp),
19224  NUF(vswpq,     1b20000, 2, (RNQ,  RNQ),      neon_swp),
19225   /* VTRN. Sizes 8 16 32.  */
19226  nUF(vtrn,      _vtrn,    2, (RNDQ, RNDQ),     neon_trn),
19227  nUF(vtrnq,     _vtrn,    2, (RNQ,  RNQ),      neon_trn),
19228
19229   /* Table lookup. Size 8.  */
19230  NUF(vtbl,      1b00800, 3, (RND, NRDLST, RND), neon_tbl_tbx),
19231  NUF(vtbx,      1b00840, 3, (RND, NRDLST, RND), neon_tbl_tbx),
19232
19233 #undef  THUMB_VARIANT
19234 #define THUMB_VARIANT  & fpu_vfp_v3_or_neon_ext
19235 #undef  ARM_VARIANT
19236 #define ARM_VARIANT    & fpu_vfp_v3_or_neon_ext
19237
19238   /* Neon element/structure load/store.  */
19239  nUF(vld1,      _vld1,    2, (NSTRLST, ADDR),  neon_ldx_stx),
19240  nUF(vst1,      _vst1,    2, (NSTRLST, ADDR),  neon_ldx_stx),
19241  nUF(vld2,      _vld2,    2, (NSTRLST, ADDR),  neon_ldx_stx),
19242  nUF(vst2,      _vst2,    2, (NSTRLST, ADDR),  neon_ldx_stx),
19243  nUF(vld3,      _vld3,    2, (NSTRLST, ADDR),  neon_ldx_stx),
19244  nUF(vst3,      _vst3,    2, (NSTRLST, ADDR),  neon_ldx_stx),
19245  nUF(vld4,      _vld4,    2, (NSTRLST, ADDR),  neon_ldx_stx),
19246  nUF(vst4,      _vst4,    2, (NSTRLST, ADDR),  neon_ldx_stx),
19247
19248 #undef  THUMB_VARIANT
19249 #define THUMB_VARIANT &fpu_vfp_ext_v3xd
19250 #undef ARM_VARIANT
19251 #define ARM_VARIANT &fpu_vfp_ext_v3xd
19252  cCE("fconsts",   eb00a00, 2, (RVS, I255),      vfp_sp_const),
19253  cCE("fshtos",    eba0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
19254  cCE("fsltos",    eba0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
19255  cCE("fuhtos",    ebb0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
19256  cCE("fultos",    ebb0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
19257  cCE("ftoshs",    ebe0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
19258  cCE("ftosls",    ebe0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
19259  cCE("ftouhs",    ebf0a40, 2, (RVS, I16z),      vfp_sp_conv_16),
19260  cCE("ftouls",    ebf0ac0, 2, (RVS, I32),       vfp_sp_conv_32),
19261
19262 #undef THUMB_VARIANT
19263 #define THUMB_VARIANT  & fpu_vfp_ext_v3
19264 #undef  ARM_VARIANT
19265 #define ARM_VARIANT    & fpu_vfp_ext_v3
19266
19267  cCE("fconstd",   eb00b00, 2, (RVD, I255),      vfp_dp_const),
19268  cCE("fshtod",    eba0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
19269  cCE("fsltod",    eba0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
19270  cCE("fuhtod",    ebb0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
19271  cCE("fultod",    ebb0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
19272  cCE("ftoshd",    ebe0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
19273  cCE("ftosld",    ebe0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
19274  cCE("ftouhd",    ebf0b40, 2, (RVD, I16z),      vfp_dp_conv_16),
19275  cCE("ftould",    ebf0bc0, 2, (RVD, I32),       vfp_dp_conv_32),
19276
19277 #undef ARM_VARIANT
19278 #define ARM_VARIANT &fpu_vfp_ext_fma
19279 #undef THUMB_VARIANT
19280 #define THUMB_VARIANT &fpu_vfp_ext_fma
19281  /* Mnemonics shared by Neon and VFP.  These are included in the
19282     VFP FMA variant; NEON and VFP FMA always includes the NEON
19283     FMA instructions.  */
19284  nCEF(vfma,     _vfma,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_fmac),
19285  nCEF(vfms,     _vfms,    3, (RNSDQ, oRNSDQ, RNSDQ), neon_fmac),
19286  /* ffmas/ffmad/ffmss/ffmsd are dummy mnemonics to satisfy gas;
19287     the v form should always be used.  */
19288  cCE("ffmas",   ea00a00, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
19289  cCE("ffnmas",  ea00a40, 3, (RVS, RVS, RVS),  vfp_sp_dyadic),
19290  cCE("ffmad",   ea00b00, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
19291  cCE("ffnmad",  ea00b40, 3, (RVD, RVD, RVD),  vfp_dp_rd_rn_rm),
19292  nCE(vfnma,     _vfnma,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
19293  nCE(vfnms,     _vfnms,   3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
19294
19295 #undef THUMB_VARIANT
19296 #undef  ARM_VARIANT
19297 #define ARM_VARIANT  & arm_cext_xscale /* Intel XScale extensions.  */
19298
19299  cCE("mia",     e200010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19300  cCE("miaph",   e280010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19301  cCE("miabb",   e2c0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19302  cCE("miabt",   e2d0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19303  cCE("miatb",   e2e0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19304  cCE("miatt",   e2f0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19305  cCE("mar",     c400000, 3, (RXA, RRnpc, RRnpc), xsc_mar),
19306  cCE("mra",     c500000, 3, (RRnpc, RRnpc, RXA), xsc_mra),
19307
19308 #undef  ARM_VARIANT
19309 #define ARM_VARIANT  & arm_cext_iwmmxt /* Intel Wireless MMX technology.  */
19310
19311  cCE("tandcb",  e13f130, 1, (RR),                   iwmmxt_tandorc),
19312  cCE("tandch",  e53f130, 1, (RR),                   iwmmxt_tandorc),
19313  cCE("tandcw",  e93f130, 1, (RR),                   iwmmxt_tandorc),
19314  cCE("tbcstb",  e400010, 2, (RIWR, RR),             rn_rd),
19315  cCE("tbcsth",  e400050, 2, (RIWR, RR),             rn_rd),
19316  cCE("tbcstw",  e400090, 2, (RIWR, RR),             rn_rd),
19317  cCE("textrcb", e130170, 2, (RR, I7),               iwmmxt_textrc),
19318  cCE("textrch", e530170, 2, (RR, I7),               iwmmxt_textrc),
19319  cCE("textrcw", e930170, 2, (RR, I7),               iwmmxt_textrc),
19320  cCE("textrmub",        e100070, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19321  cCE("textrmuh",        e500070, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19322  cCE("textrmuw",        e900070, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19323  cCE("textrmsb",        e100078, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19324  cCE("textrmsh",        e500078, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19325  cCE("textrmsw",        e900078, 3, (RR, RIWR, I7),         iwmmxt_textrm),
19326  cCE("tinsrb",  e600010, 3, (RIWR, RR, I7),         iwmmxt_tinsr),
19327  cCE("tinsrh",  e600050, 3, (RIWR, RR, I7),         iwmmxt_tinsr),
19328  cCE("tinsrw",  e600090, 3, (RIWR, RR, I7),         iwmmxt_tinsr),
19329  cCE("tmcr",    e000110, 2, (RIWC_RIWG, RR),        rn_rd),
19330  cCE("tmcrr",   c400000, 3, (RIWR, RR, RR),         rm_rd_rn),
19331  cCE("tmia",    e200010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19332  cCE("tmiaph",  e280010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19333  cCE("tmiabb",  e2c0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19334  cCE("tmiabt",  e2d0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19335  cCE("tmiatb",  e2e0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19336  cCE("tmiatt",  e2f0010, 3, (RIWR, RR, RR),         iwmmxt_tmia),
19337  cCE("tmovmskb",        e100030, 2, (RR, RIWR),             rd_rn),
19338  cCE("tmovmskh",        e500030, 2, (RR, RIWR),             rd_rn),
19339  cCE("tmovmskw",        e900030, 2, (RR, RIWR),             rd_rn),
19340  cCE("tmrc",    e100110, 2, (RR, RIWC_RIWG),        rd_rn),
19341  cCE("tmrrc",   c500000, 3, (RR, RR, RIWR),         rd_rn_rm),
19342  cCE("torcb",   e13f150, 1, (RR),                   iwmmxt_tandorc),
19343  cCE("torch",   e53f150, 1, (RR),                   iwmmxt_tandorc),
19344  cCE("torcw",   e93f150, 1, (RR),                   iwmmxt_tandorc),
19345  cCE("waccb",   e0001c0, 2, (RIWR, RIWR),           rd_rn),
19346  cCE("wacch",   e4001c0, 2, (RIWR, RIWR),           rd_rn),
19347  cCE("waccw",   e8001c0, 2, (RIWR, RIWR),           rd_rn),
19348  cCE("waddbss", e300180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19349  cCE("waddb",   e000180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19350  cCE("waddbus", e100180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19351  cCE("waddhss", e700180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19352  cCE("waddh",   e400180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19353  cCE("waddhus", e500180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19354  cCE("waddwss", eb00180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19355  cCE("waddw",   e800180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19356  cCE("waddwus", e900180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19357  cCE("waligni", e000020, 4, (RIWR, RIWR, RIWR, I7), iwmmxt_waligni),
19358  cCE("walignr0",        e800020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19359  cCE("walignr1",        e900020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19360  cCE("walignr2",        ea00020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19361  cCE("walignr3",        eb00020, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19362  cCE("wand",    e200000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19363  cCE("wandn",   e300000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19364  cCE("wavg2b",  e800000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19365  cCE("wavg2br", e900000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19366  cCE("wavg2h",  ec00000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19367  cCE("wavg2hr", ed00000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19368  cCE("wcmpeqb", e000060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19369  cCE("wcmpeqh", e400060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19370  cCE("wcmpeqw", e800060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19371  cCE("wcmpgtub",        e100060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19372  cCE("wcmpgtuh",        e500060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19373  cCE("wcmpgtuw",        e900060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19374  cCE("wcmpgtsb",        e300060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19375  cCE("wcmpgtsh",        e700060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19376  cCE("wcmpgtsw",        eb00060, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19377  cCE("wldrb",   c100000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
19378  cCE("wldrh",   c500000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
19379  cCE("wldrw",   c100100, 2, (RIWR_RIWC, ADDR),      iwmmxt_wldstw),
19380  cCE("wldrd",   c500100, 2, (RIWR, ADDR),           iwmmxt_wldstd),
19381  cCE("wmacs",   e600100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19382  cCE("wmacsz",  e700100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19383  cCE("wmacu",   e400100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19384  cCE("wmacuz",  e500100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19385  cCE("wmadds",  ea00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19386  cCE("wmaddu",  e800100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19387  cCE("wmaxsb",  e200160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19388  cCE("wmaxsh",  e600160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19389  cCE("wmaxsw",  ea00160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19390  cCE("wmaxub",  e000160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19391  cCE("wmaxuh",  e400160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19392  cCE("wmaxuw",  e800160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19393  cCE("wminsb",  e300160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19394  cCE("wminsh",  e700160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19395  cCE("wminsw",  eb00160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19396  cCE("wminub",  e100160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19397  cCE("wminuh",  e500160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19398  cCE("wminuw",  e900160, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19399  cCE("wmov",    e000000, 2, (RIWR, RIWR),           iwmmxt_wmov),
19400  cCE("wmulsm",  e300100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19401  cCE("wmulsl",  e200100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19402  cCE("wmulum",  e100100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19403  cCE("wmulul",  e000100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19404  cCE("wor",     e000000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19405  cCE("wpackhss",        e700080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19406  cCE("wpackhus",        e500080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19407  cCE("wpackwss",        eb00080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19408  cCE("wpackwus",        e900080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19409  cCE("wpackdss",        ef00080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19410  cCE("wpackdus",        ed00080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19411  cCE("wrorh",   e700040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19412  cCE("wrorhg",  e700148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19413  cCE("wrorw",   eb00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19414  cCE("wrorwg",  eb00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19415  cCE("wrord",   ef00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19416  cCE("wrordg",  ef00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19417  cCE("wsadb",   e000120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19418  cCE("wsadbz",  e100120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19419  cCE("wsadh",   e400120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19420  cCE("wsadhz",  e500120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19421  cCE("wshufh",  e0001e0, 3, (RIWR, RIWR, I255),     iwmmxt_wshufh),
19422  cCE("wsllh",   e500040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19423  cCE("wsllhg",  e500148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19424  cCE("wsllw",   e900040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19425  cCE("wsllwg",  e900148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19426  cCE("wslld",   ed00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19427  cCE("wslldg",  ed00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19428  cCE("wsrah",   e400040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19429  cCE("wsrahg",  e400148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19430  cCE("wsraw",   e800040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19431  cCE("wsrawg",  e800148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19432  cCE("wsrad",   ec00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19433  cCE("wsradg",  ec00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19434  cCE("wsrlh",   e600040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19435  cCE("wsrlhg",  e600148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19436  cCE("wsrlw",   ea00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19437  cCE("wsrlwg",  ea00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19438  cCE("wsrld",   ee00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
19439  cCE("wsrldg",  ee00148, 3, (RIWR, RIWR, RIWG),     rd_rn_rm),
19440  cCE("wstrb",   c000000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
19441  cCE("wstrh",   c400000, 2, (RIWR, ADDR),           iwmmxt_wldstbh),
19442  cCE("wstrw",   c000100, 2, (RIWR_RIWC, ADDR),      iwmmxt_wldstw),
19443  cCE("wstrd",   c400100, 2, (RIWR, ADDR),           iwmmxt_wldstd),
19444  cCE("wsubbss", e3001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19445  cCE("wsubb",   e0001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19446  cCE("wsubbus", e1001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19447  cCE("wsubhss", e7001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19448  cCE("wsubh",   e4001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19449  cCE("wsubhus", e5001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19450  cCE("wsubwss", eb001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19451  cCE("wsubw",   e8001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19452  cCE("wsubwus", e9001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19453  cCE("wunpckehub",e0000c0, 2, (RIWR, RIWR),         rd_rn),
19454  cCE("wunpckehuh",e4000c0, 2, (RIWR, RIWR),         rd_rn),
19455  cCE("wunpckehuw",e8000c0, 2, (RIWR, RIWR),         rd_rn),
19456  cCE("wunpckehsb",e2000c0, 2, (RIWR, RIWR),         rd_rn),
19457  cCE("wunpckehsh",e6000c0, 2, (RIWR, RIWR),         rd_rn),
19458  cCE("wunpckehsw",ea000c0, 2, (RIWR, RIWR),         rd_rn),
19459  cCE("wunpckihb", e1000c0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19460  cCE("wunpckihh", e5000c0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19461  cCE("wunpckihw", e9000c0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19462  cCE("wunpckelub",e0000e0, 2, (RIWR, RIWR),         rd_rn),
19463  cCE("wunpckeluh",e4000e0, 2, (RIWR, RIWR),         rd_rn),
19464  cCE("wunpckeluw",e8000e0, 2, (RIWR, RIWR),         rd_rn),
19465  cCE("wunpckelsb",e2000e0, 2, (RIWR, RIWR),         rd_rn),
19466  cCE("wunpckelsh",e6000e0, 2, (RIWR, RIWR),         rd_rn),
19467  cCE("wunpckelsw",ea000e0, 2, (RIWR, RIWR),         rd_rn),
19468  cCE("wunpckilb", e1000e0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19469  cCE("wunpckilh", e5000e0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19470  cCE("wunpckilw", e9000e0, 3, (RIWR, RIWR, RIWR),           rd_rn_rm),
19471  cCE("wxor",    e100000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19472  cCE("wzero",   e300000, 1, (RIWR),                 iwmmxt_wzero),
19473
19474 #undef  ARM_VARIANT
19475 #define ARM_VARIANT  & arm_cext_iwmmxt2 /* Intel Wireless MMX technology, version 2.  */
19476
19477  cCE("torvscb",   e12f190, 1, (RR),                 iwmmxt_tandorc),
19478  cCE("torvsch",   e52f190, 1, (RR),                 iwmmxt_tandorc),
19479  cCE("torvscw",   e92f190, 1, (RR),                 iwmmxt_tandorc),
19480  cCE("wabsb",     e2001c0, 2, (RIWR, RIWR),           rd_rn),
19481  cCE("wabsh",     e6001c0, 2, (RIWR, RIWR),           rd_rn),
19482  cCE("wabsw",     ea001c0, 2, (RIWR, RIWR),           rd_rn),
19483  cCE("wabsdiffb", e1001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19484  cCE("wabsdiffh", e5001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19485  cCE("wabsdiffw", e9001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19486  cCE("waddbhusl", e2001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19487  cCE("waddbhusm", e6001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19488  cCE("waddhc",    e600180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19489  cCE("waddwc",    ea00180, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19490  cCE("waddsubhx", ea001a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19491  cCE("wavg4",   e400000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19492  cCE("wavg4r",    e500000, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19493  cCE("wmaddsn",   ee00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19494  cCE("wmaddsx",   eb00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19495  cCE("wmaddun",   ec00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19496  cCE("wmaddux",   e900100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19497  cCE("wmerge",    e000080, 4, (RIWR, RIWR, RIWR, I7), iwmmxt_wmerge),
19498  cCE("wmiabb",    e0000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19499  cCE("wmiabt",    e1000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19500  cCE("wmiatb",    e2000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19501  cCE("wmiatt",    e3000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19502  cCE("wmiabbn",   e4000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19503  cCE("wmiabtn",   e5000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19504  cCE("wmiatbn",   e6000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19505  cCE("wmiattn",   e7000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19506  cCE("wmiawbb",   e800120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19507  cCE("wmiawbt",   e900120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19508  cCE("wmiawtb",   ea00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19509  cCE("wmiawtt",   eb00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19510  cCE("wmiawbbn",  ec00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19511  cCE("wmiawbtn",  ed00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19512  cCE("wmiawtbn",  ee00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19513  cCE("wmiawttn",  ef00120, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19514  cCE("wmulsmr",   ef00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19515  cCE("wmulumr",   ed00100, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19516  cCE("wmulwumr",  ec000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19517  cCE("wmulwsmr",  ee000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19518  cCE("wmulwum",   ed000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19519  cCE("wmulwsm",   ef000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19520  cCE("wmulwl",    eb000c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19521  cCE("wqmiabb",   e8000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19522  cCE("wqmiabt",   e9000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19523  cCE("wqmiatb",   ea000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19524  cCE("wqmiatt",   eb000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19525  cCE("wqmiabbn",  ec000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19526  cCE("wqmiabtn",  ed000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19527  cCE("wqmiatbn",  ee000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19528  cCE("wqmiattn",  ef000a0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19529  cCE("wqmulm",    e100080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19530  cCE("wqmulmr",   e300080, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19531  cCE("wqmulwm",   ec000e0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19532  cCE("wqmulwmr",  ee000e0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19533  cCE("wsubaddhx", ed001c0, 3, (RIWR, RIWR, RIWR),     rd_rn_rm),
19534
19535 #undef  ARM_VARIANT
19536 #define ARM_VARIANT  & arm_cext_maverick /* Cirrus Maverick instructions.  */
19537
19538  cCE("cfldrs",  c100400, 2, (RMF, ADDRGLDC),          rd_cpaddr),
19539  cCE("cfldrd",  c500400, 2, (RMD, ADDRGLDC),          rd_cpaddr),
19540  cCE("cfldr32", c100500, 2, (RMFX, ADDRGLDC),         rd_cpaddr),
19541  cCE("cfldr64", c500500, 2, (RMDX, ADDRGLDC),         rd_cpaddr),
19542  cCE("cfstrs",  c000400, 2, (RMF, ADDRGLDC),          rd_cpaddr),
19543  cCE("cfstrd",  c400400, 2, (RMD, ADDRGLDC),          rd_cpaddr),
19544  cCE("cfstr32", c000500, 2, (RMFX, ADDRGLDC),         rd_cpaddr),
19545  cCE("cfstr64", c400500, 2, (RMDX, ADDRGLDC),         rd_cpaddr),
19546  cCE("cfmvsr",  e000450, 2, (RMF, RR),                rn_rd),
19547  cCE("cfmvrs",  e100450, 2, (RR, RMF),                rd_rn),
19548  cCE("cfmvdlr", e000410, 2, (RMD, RR),                rn_rd),
19549  cCE("cfmvrdl", e100410, 2, (RR, RMD),                rd_rn),
19550  cCE("cfmvdhr", e000430, 2, (RMD, RR),                rn_rd),
19551  cCE("cfmvrdh", e100430, 2, (RR, RMD),                rd_rn),
19552  cCE("cfmv64lr",        e000510, 2, (RMDX, RR),               rn_rd),
19553  cCE("cfmvr64l",        e100510, 2, (RR, RMDX),               rd_rn),
19554  cCE("cfmv64hr",        e000530, 2, (RMDX, RR),               rn_rd),
19555  cCE("cfmvr64h",        e100530, 2, (RR, RMDX),               rd_rn),
19556  cCE("cfmval32",        e200440, 2, (RMAX, RMFX),             rd_rn),
19557  cCE("cfmv32al",        e100440, 2, (RMFX, RMAX),             rd_rn),
19558  cCE("cfmvam32",        e200460, 2, (RMAX, RMFX),             rd_rn),
19559  cCE("cfmv32am",        e100460, 2, (RMFX, RMAX),             rd_rn),
19560  cCE("cfmvah32",        e200480, 2, (RMAX, RMFX),             rd_rn),
19561  cCE("cfmv32ah",        e100480, 2, (RMFX, RMAX),             rd_rn),
19562  cCE("cfmva32", e2004a0, 2, (RMAX, RMFX),             rd_rn),
19563  cCE("cfmv32a", e1004a0, 2, (RMFX, RMAX),             rd_rn),
19564  cCE("cfmva64", e2004c0, 2, (RMAX, RMDX),             rd_rn),
19565  cCE("cfmv64a", e1004c0, 2, (RMDX, RMAX),             rd_rn),
19566  cCE("cfmvsc32",        e2004e0, 2, (RMDS, RMDX),             mav_dspsc),
19567  cCE("cfmv32sc",        e1004e0, 2, (RMDX, RMDS),             rd),
19568  cCE("cfcpys",  e000400, 2, (RMF, RMF),               rd_rn),
19569  cCE("cfcpyd",  e000420, 2, (RMD, RMD),               rd_rn),
19570  cCE("cfcvtsd", e000460, 2, (RMD, RMF),               rd_rn),
19571  cCE("cfcvtds", e000440, 2, (RMF, RMD),               rd_rn),
19572  cCE("cfcvt32s",        e000480, 2, (RMF, RMFX),              rd_rn),
19573  cCE("cfcvt32d",        e0004a0, 2, (RMD, RMFX),              rd_rn),
19574  cCE("cfcvt64s",        e0004c0, 2, (RMF, RMDX),              rd_rn),
19575  cCE("cfcvt64d",        e0004e0, 2, (RMD, RMDX),              rd_rn),
19576  cCE("cfcvts32",        e100580, 2, (RMFX, RMF),              rd_rn),
19577  cCE("cfcvtd32",        e1005a0, 2, (RMFX, RMD),              rd_rn),
19578  cCE("cftruncs32",e1005c0, 2, (RMFX, RMF),            rd_rn),
19579  cCE("cftruncd32",e1005e0, 2, (RMFX, RMD),            rd_rn),
19580  cCE("cfrshl32",        e000550, 3, (RMFX, RMFX, RR),         mav_triple),
19581  cCE("cfrshl64",        e000570, 3, (RMDX, RMDX, RR),         mav_triple),
19582  cCE("cfsh32",  e000500, 3, (RMFX, RMFX, I63s),       mav_shift),
19583  cCE("cfsh64",  e200500, 3, (RMDX, RMDX, I63s),       mav_shift),
19584  cCE("cfcmps",  e100490, 3, (RR, RMF, RMF),           rd_rn_rm),
19585  cCE("cfcmpd",  e1004b0, 3, (RR, RMD, RMD),           rd_rn_rm),
19586  cCE("cfcmp32", e100590, 3, (RR, RMFX, RMFX),         rd_rn_rm),
19587  cCE("cfcmp64", e1005b0, 3, (RR, RMDX, RMDX),         rd_rn_rm),
19588  cCE("cfabss",  e300400, 2, (RMF, RMF),               rd_rn),
19589  cCE("cfabsd",  e300420, 2, (RMD, RMD),               rd_rn),
19590  cCE("cfnegs",  e300440, 2, (RMF, RMF),               rd_rn),
19591  cCE("cfnegd",  e300460, 2, (RMD, RMD),               rd_rn),
19592  cCE("cfadds",  e300480, 3, (RMF, RMF, RMF),          rd_rn_rm),
19593  cCE("cfaddd",  e3004a0, 3, (RMD, RMD, RMD),          rd_rn_rm),
19594  cCE("cfsubs",  e3004c0, 3, (RMF, RMF, RMF),          rd_rn_rm),
19595  cCE("cfsubd",  e3004e0, 3, (RMD, RMD, RMD),          rd_rn_rm),
19596  cCE("cfmuls",  e100400, 3, (RMF, RMF, RMF),          rd_rn_rm),
19597  cCE("cfmuld",  e100420, 3, (RMD, RMD, RMD),          rd_rn_rm),
19598  cCE("cfabs32", e300500, 2, (RMFX, RMFX),             rd_rn),
19599  cCE("cfabs64", e300520, 2, (RMDX, RMDX),             rd_rn),
19600  cCE("cfneg32", e300540, 2, (RMFX, RMFX),             rd_rn),
19601  cCE("cfneg64", e300560, 2, (RMDX, RMDX),             rd_rn),
19602  cCE("cfadd32", e300580, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
19603  cCE("cfadd64", e3005a0, 3, (RMDX, RMDX, RMDX),       rd_rn_rm),
19604  cCE("cfsub32", e3005c0, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
19605  cCE("cfsub64", e3005e0, 3, (RMDX, RMDX, RMDX),       rd_rn_rm),
19606  cCE("cfmul32", e100500, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
19607  cCE("cfmul64", e100520, 3, (RMDX, RMDX, RMDX),       rd_rn_rm),
19608  cCE("cfmac32", e100540, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
19609  cCE("cfmsc32", e100560, 3, (RMFX, RMFX, RMFX),       rd_rn_rm),
19610  cCE("cfmadd32",        e000600, 4, (RMAX, RMFX, RMFX, RMFX), mav_quad),
19611  cCE("cfmsub32",        e100600, 4, (RMAX, RMFX, RMFX, RMFX), mav_quad),
19612  cCE("cfmadda32", e200600, 4, (RMAX, RMAX, RMFX, RMFX), mav_quad),
19613  cCE("cfmsuba32", e300600, 4, (RMAX, RMAX, RMFX, RMFX), mav_quad),
19614 };
19615 #undef ARM_VARIANT
19616 #undef THUMB_VARIANT
19617 #undef TCE
19618 #undef TCM
19619 #undef TUE
19620 #undef TUF
19621 #undef TCC
19622 #undef cCE
19623 #undef cCL
19624 #undef C3E
19625 #undef CE
19626 #undef CM
19627 #undef UE
19628 #undef UF
19629 #undef UT
19630 #undef NUF
19631 #undef nUF
19632 #undef NCE
19633 #undef nCE
19634 #undef OPS0
19635 #undef OPS1
19636 #undef OPS2
19637 #undef OPS3
19638 #undef OPS4
19639 #undef OPS5
19640 #undef OPS6
19641 #undef do_0
19642 \f
19643 /* MD interface: bits in the object file.  */
19644
19645 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
19646    for use in the a.out file, and stores them in the array pointed to by buf.
19647    This knows about the endian-ness of the target machine and does
19648    THE RIGHT THING, whatever it is.  Possible values for n are 1 (byte)
19649    2 (short) and 4 (long)  Floating numbers are put out as a series of
19650    LITTLENUMS (shorts, here at least).  */
19651
19652 void
19653 md_number_to_chars (char * buf, valueT val, int n)
19654 {
19655   if (target_big_endian)
19656     number_to_chars_bigendian (buf, val, n);
19657   else
19658     number_to_chars_littleendian (buf, val, n);
19659 }
19660
19661 static valueT
19662 md_chars_to_number (char * buf, int n)
19663 {
19664   valueT result = 0;
19665   unsigned char * where = (unsigned char *) buf;
19666
19667   if (target_big_endian)
19668     {
19669       while (n--)
19670         {
19671           result <<= 8;
19672           result |= (*where++ & 255);
19673         }
19674     }
19675   else
19676     {
19677       while (n--)
19678         {
19679           result <<= 8;
19680           result |= (where[n] & 255);
19681         }
19682     }
19683
19684   return result;
19685 }
19686
19687 /* MD interface: Sections.  */
19688
19689 /* Calculate the maximum variable size (i.e., excluding fr_fix)
19690    that an rs_machine_dependent frag may reach.  */
19691
19692 unsigned int
19693 arm_frag_max_var (fragS *fragp)
19694 {
19695   /* We only use rs_machine_dependent for variable-size Thumb instructions,
19696      which are either THUMB_SIZE (2) or INSN_SIZE (4).
19697
19698      Note that we generate relaxable instructions even for cases that don't
19699      really need it, like an immediate that's a trivial constant.  So we're
19700      overestimating the instruction size for some of those cases.  Rather
19701      than putting more intelligence here, it would probably be better to
19702      avoid generating a relaxation frag in the first place when it can be
19703      determined up front that a short instruction will suffice.  */
19704
19705   gas_assert (fragp->fr_type == rs_machine_dependent);
19706   return INSN_SIZE;
19707 }
19708
19709 /* Estimate the size of a frag before relaxing.  Assume everything fits in
19710    2 bytes.  */
19711
19712 int
19713 md_estimate_size_before_relax (fragS * fragp,
19714                                segT    segtype ATTRIBUTE_UNUSED)
19715 {
19716   fragp->fr_var = 2;
19717   return 2;
19718 }
19719
19720 /* Convert a machine dependent frag.  */
19721
19722 void
19723 md_convert_frag (bfd *abfd, segT asec ATTRIBUTE_UNUSED, fragS *fragp)
19724 {
19725   unsigned long insn;
19726   unsigned long old_op;
19727   char *buf;
19728   expressionS exp;
19729   fixS *fixp;
19730   int reloc_type;
19731   int pc_rel;
19732   int opcode;
19733
19734   buf = fragp->fr_literal + fragp->fr_fix;
19735
19736   old_op = bfd_get_16(abfd, buf);
19737   if (fragp->fr_symbol)
19738     {
19739       exp.X_op = O_symbol;
19740       exp.X_add_symbol = fragp->fr_symbol;
19741     }
19742   else
19743     {
19744       exp.X_op = O_constant;
19745     }
19746   exp.X_add_number = fragp->fr_offset;
19747   opcode = fragp->fr_subtype;
19748   switch (opcode)
19749     {
19750     case T_MNEM_ldr_pc:
19751     case T_MNEM_ldr_pc2:
19752     case T_MNEM_ldr_sp:
19753     case T_MNEM_str_sp:
19754     case T_MNEM_ldr:
19755     case T_MNEM_ldrb:
19756     case T_MNEM_ldrh:
19757     case T_MNEM_str:
19758     case T_MNEM_strb:
19759     case T_MNEM_strh:
19760       if (fragp->fr_var == 4)
19761         {
19762           insn = THUMB_OP32 (opcode);
19763           if ((old_op >> 12) == 4 || (old_op >> 12) == 9)
19764             {
19765               insn |= (old_op & 0x700) << 4;
19766             }
19767           else
19768             {
19769               insn |= (old_op & 7) << 12;
19770               insn |= (old_op & 0x38) << 13;
19771             }
19772           insn |= 0x00000c00;
19773           put_thumb32_insn (buf, insn);
19774           reloc_type = BFD_RELOC_ARM_T32_OFFSET_IMM;
19775         }
19776       else
19777         {
19778           reloc_type = BFD_RELOC_ARM_THUMB_OFFSET;
19779         }
19780       pc_rel = (opcode == T_MNEM_ldr_pc2);
19781       break;
19782     case T_MNEM_adr:
19783       if (fragp->fr_var == 4)
19784         {
19785           insn = THUMB_OP32 (opcode);
19786           insn |= (old_op & 0xf0) << 4;
19787           put_thumb32_insn (buf, insn);
19788           reloc_type = BFD_RELOC_ARM_T32_ADD_PC12;
19789         }
19790       else
19791         {
19792           reloc_type = BFD_RELOC_ARM_THUMB_ADD;
19793           exp.X_add_number -= 4;
19794         }
19795       pc_rel = 1;
19796       break;
19797     case T_MNEM_mov:
19798     case T_MNEM_movs:
19799     case T_MNEM_cmp:
19800     case T_MNEM_cmn:
19801       if (fragp->fr_var == 4)
19802         {
19803           int r0off = (opcode == T_MNEM_mov
19804                        || opcode == T_MNEM_movs) ? 0 : 8;
19805           insn = THUMB_OP32 (opcode);
19806           insn = (insn & 0xe1ffffff) | 0x10000000;
19807           insn |= (old_op & 0x700) << r0off;
19808           put_thumb32_insn (buf, insn);
19809           reloc_type = BFD_RELOC_ARM_T32_IMMEDIATE;
19810         }
19811       else
19812         {
19813           reloc_type = BFD_RELOC_ARM_THUMB_IMM;
19814         }
19815       pc_rel = 0;
19816       break;
19817     case T_MNEM_b:
19818       if (fragp->fr_var == 4)
19819         {
19820           insn = THUMB_OP32(opcode);
19821           put_thumb32_insn (buf, insn);
19822           reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH25;
19823         }
19824       else
19825         reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH12;
19826       pc_rel = 1;
19827       break;
19828     case T_MNEM_bcond:
19829       if (fragp->fr_var == 4)
19830         {
19831           insn = THUMB_OP32(opcode);
19832           insn |= (old_op & 0xf00) << 14;
19833           put_thumb32_insn (buf, insn);
19834           reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH20;
19835         }
19836       else
19837         reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH9;
19838       pc_rel = 1;
19839       break;
19840     case T_MNEM_add_sp:
19841     case T_MNEM_add_pc:
19842     case T_MNEM_inc_sp:
19843     case T_MNEM_dec_sp:
19844       if (fragp->fr_var == 4)
19845         {
19846           /* ??? Choose between add and addw.  */
19847           insn = THUMB_OP32 (opcode);
19848           insn |= (old_op & 0xf0) << 4;
19849           put_thumb32_insn (buf, insn);
19850           if (opcode == T_MNEM_add_pc)
19851             reloc_type = BFD_RELOC_ARM_T32_IMM12;
19852           else
19853             reloc_type = BFD_RELOC_ARM_T32_ADD_IMM;
19854         }
19855       else
19856         reloc_type = BFD_RELOC_ARM_THUMB_ADD;
19857       pc_rel = 0;
19858       break;
19859
19860     case T_MNEM_addi:
19861     case T_MNEM_addis:
19862     case T_MNEM_subi:
19863     case T_MNEM_subis:
19864       if (fragp->fr_var == 4)
19865         {
19866           insn = THUMB_OP32 (opcode);
19867           insn |= (old_op & 0xf0) << 4;
19868           insn |= (old_op & 0xf) << 16;
19869           put_thumb32_insn (buf, insn);
19870           if (insn & (1 << 20))
19871             reloc_type = BFD_RELOC_ARM_T32_ADD_IMM;
19872           else
19873             reloc_type = BFD_RELOC_ARM_T32_IMMEDIATE;
19874         }
19875       else
19876         reloc_type = BFD_RELOC_ARM_THUMB_ADD;
19877       pc_rel = 0;
19878       break;
19879     default:
19880       abort ();
19881     }
19882   fixp = fix_new_exp (fragp, fragp->fr_fix, fragp->fr_var, &exp, pc_rel,
19883                       (enum bfd_reloc_code_real) reloc_type);
19884   fixp->fx_file = fragp->fr_file;
19885   fixp->fx_line = fragp->fr_line;
19886   fragp->fr_fix += fragp->fr_var;
19887 }
19888
19889 /* Return the size of a relaxable immediate operand instruction.
19890    SHIFT and SIZE specify the form of the allowable immediate.  */
19891 static int
19892 relax_immediate (fragS *fragp, int size, int shift)
19893 {
19894   offsetT offset;
19895   offsetT mask;
19896   offsetT low;
19897
19898   /* ??? Should be able to do better than this.  */
19899   if (fragp->fr_symbol)
19900     return 4;
19901
19902   low = (1 << shift) - 1;
19903   mask = (1 << (shift + size)) - (1 << shift);
19904   offset = fragp->fr_offset;
19905   /* Force misaligned offsets to 32-bit variant.  */
19906   if (offset & low)
19907     return 4;
19908   if (offset & ~mask)
19909     return 4;
19910   return 2;
19911 }
19912
19913 /* Get the address of a symbol during relaxation.  */
19914 static addressT
19915 relaxed_symbol_addr (fragS *fragp, long stretch)
19916 {
19917   fragS *sym_frag;
19918   addressT addr;
19919   symbolS *sym;
19920
19921   sym = fragp->fr_symbol;
19922   sym_frag = symbol_get_frag (sym);
19923   know (S_GET_SEGMENT (sym) != absolute_section
19924         || sym_frag == &zero_address_frag);
19925   addr = S_GET_VALUE (sym) + fragp->fr_offset;
19926
19927   /* If frag has yet to be reached on this pass, assume it will
19928      move by STRETCH just as we did.  If this is not so, it will
19929      be because some frag between grows, and that will force
19930      another pass.  */
19931
19932   if (stretch != 0
19933       && sym_frag->relax_marker != fragp->relax_marker)
19934     {
19935       fragS *f;
19936
19937       /* Adjust stretch for any alignment frag.  Note that if have
19938          been expanding the earlier code, the symbol may be
19939          defined in what appears to be an earlier frag.  FIXME:
19940          This doesn't handle the fr_subtype field, which specifies
19941          a maximum number of bytes to skip when doing an
19942          alignment.  */
19943       for (f = fragp; f != NULL && f != sym_frag; f = f->fr_next)
19944         {
19945           if (f->fr_type == rs_align || f->fr_type == rs_align_code)
19946             {
19947               if (stretch < 0)
19948                 stretch = - ((- stretch)
19949                              & ~ ((1 << (int) f->fr_offset) - 1));
19950               else
19951                 stretch &= ~ ((1 << (int) f->fr_offset) - 1);
19952               if (stretch == 0)
19953                 break;
19954             }
19955         }
19956       if (f != NULL)
19957         addr += stretch;
19958     }
19959
19960   return addr;
19961 }
19962
19963 /* Return the size of a relaxable adr pseudo-instruction or PC-relative
19964    load.  */
19965 static int
19966 relax_adr (fragS *fragp, asection *sec, long stretch)
19967 {
19968   addressT addr;
19969   offsetT val;
19970
19971   /* Assume worst case for symbols not known to be in the same section.  */
19972   if (fragp->fr_symbol == NULL
19973       || !S_IS_DEFINED (fragp->fr_symbol)
19974       || sec != S_GET_SEGMENT (fragp->fr_symbol)
19975       || S_IS_WEAK (fragp->fr_symbol))
19976     return 4;
19977
19978   val = relaxed_symbol_addr (fragp, stretch);
19979   addr = fragp->fr_address + fragp->fr_fix;
19980   addr = (addr + 4) & ~3;
19981   /* Force misaligned targets to 32-bit variant.  */
19982   if (val & 3)
19983     return 4;
19984   val -= addr;
19985   if (val < 0 || val > 1020)
19986     return 4;
19987   return 2;
19988 }
19989
19990 /* Return the size of a relaxable add/sub immediate instruction.  */
19991 static int
19992 relax_addsub (fragS *fragp, asection *sec)
19993 {
19994   char *buf;
19995   int op;
19996
19997   buf = fragp->fr_literal + fragp->fr_fix;
19998   op = bfd_get_16(sec->owner, buf);
19999   if ((op & 0xf) == ((op >> 4) & 0xf))
20000     return relax_immediate (fragp, 8, 0);
20001   else
20002     return relax_immediate (fragp, 3, 0);
20003 }
20004
20005
20006 /* Return the size of a relaxable branch instruction.  BITS is the
20007    size of the offset field in the narrow instruction.  */
20008
20009 static int
20010 relax_branch (fragS *fragp, asection *sec, int bits, long stretch)
20011 {
20012   addressT addr;
20013   offsetT val;
20014   offsetT limit;
20015
20016   /* Assume worst case for symbols not known to be in the same section.  */
20017   if (!S_IS_DEFINED (fragp->fr_symbol)
20018       || sec != S_GET_SEGMENT (fragp->fr_symbol)
20019       || S_IS_WEAK (fragp->fr_symbol))
20020     return 4;
20021
20022 #ifdef OBJ_ELF
20023   if (S_IS_DEFINED (fragp->fr_symbol)
20024       && ARM_IS_FUNC (fragp->fr_symbol))
20025       return 4;
20026
20027   /* PR 12532.  Global symbols with default visibility might
20028      be preempted, so do not relax relocations to them.  */
20029   if ((ELF_ST_VISIBILITY (S_GET_OTHER (fragp->fr_symbol)) == STV_DEFAULT)
20030       && (! S_IS_LOCAL (fragp->fr_symbol)))
20031     return 4;
20032 #endif
20033
20034   val = relaxed_symbol_addr (fragp, stretch);
20035   addr = fragp->fr_address + fragp->fr_fix + 4;
20036   val -= addr;
20037
20038   /* Offset is a signed value *2 */
20039   limit = 1 << bits;
20040   if (val >= limit || val < -limit)
20041     return 4;
20042   return 2;
20043 }
20044
20045
20046 /* Relax a machine dependent frag.  This returns the amount by which
20047    the current size of the frag should change.  */
20048
20049 int
20050 arm_relax_frag (asection *sec, fragS *fragp, long stretch)
20051 {
20052   int oldsize;
20053   int newsize;
20054
20055   oldsize = fragp->fr_var;
20056   switch (fragp->fr_subtype)
20057     {
20058     case T_MNEM_ldr_pc2:
20059       newsize = relax_adr (fragp, sec, stretch);
20060       break;
20061     case T_MNEM_ldr_pc:
20062     case T_MNEM_ldr_sp:
20063     case T_MNEM_str_sp:
20064       newsize = relax_immediate (fragp, 8, 2);
20065       break;
20066     case T_MNEM_ldr:
20067     case T_MNEM_str:
20068       newsize = relax_immediate (fragp, 5, 2);
20069       break;
20070     case T_MNEM_ldrh:
20071     case T_MNEM_strh:
20072       newsize = relax_immediate (fragp, 5, 1);
20073       break;
20074     case T_MNEM_ldrb:
20075     case T_MNEM_strb:
20076       newsize = relax_immediate (fragp, 5, 0);
20077       break;
20078     case T_MNEM_adr:
20079       newsize = relax_adr (fragp, sec, stretch);
20080       break;
20081     case T_MNEM_mov:
20082     case T_MNEM_movs:
20083     case T_MNEM_cmp:
20084     case T_MNEM_cmn:
20085       newsize = relax_immediate (fragp, 8, 0);
20086       break;
20087     case T_MNEM_b:
20088       newsize = relax_branch (fragp, sec, 11, stretch);
20089       break;
20090     case T_MNEM_bcond:
20091       newsize = relax_branch (fragp, sec, 8, stretch);
20092       break;
20093     case T_MNEM_add_sp:
20094     case T_MNEM_add_pc:
20095       newsize = relax_immediate (fragp, 8, 2);
20096       break;
20097     case T_MNEM_inc_sp:
20098     case T_MNEM_dec_sp:
20099       newsize = relax_immediate (fragp, 7, 2);
20100       break;
20101     case T_MNEM_addi:
20102     case T_MNEM_addis:
20103     case T_MNEM_subi:
20104     case T_MNEM_subis:
20105       newsize = relax_addsub (fragp, sec);
20106       break;
20107     default:
20108       abort ();
20109     }
20110
20111   fragp->fr_var = newsize;
20112   /* Freeze wide instructions that are at or before the same location as
20113      in the previous pass.  This avoids infinite loops.
20114      Don't freeze them unconditionally because targets may be artificially
20115      misaligned by the expansion of preceding frags.  */
20116   if (stretch <= 0 && newsize > 2)
20117     {
20118       md_convert_frag (sec->owner, sec, fragp);
20119       frag_wane (fragp);
20120     }
20121
20122   return newsize - oldsize;
20123 }
20124
20125 /* Round up a section size to the appropriate boundary.  */
20126
20127 valueT
20128 md_section_align (segT   segment ATTRIBUTE_UNUSED,
20129                   valueT size)
20130 {
20131 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
20132   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
20133     {
20134       /* For a.out, force the section size to be aligned.  If we don't do
20135          this, BFD will align it for us, but it will not write out the
20136          final bytes of the section.  This may be a bug in BFD, but it is
20137          easier to fix it here since that is how the other a.out targets
20138          work.  */
20139       int align;
20140
20141       align = bfd_get_section_alignment (stdoutput, segment);
20142       size = ((size + (1 << align) - 1) & ((valueT) -1 << align));
20143     }
20144 #endif
20145
20146   return size;
20147 }
20148
20149 /* This is called from HANDLE_ALIGN in write.c.  Fill in the contents
20150    of an rs_align_code fragment.  */
20151
20152 void
20153 arm_handle_align (fragS * fragP)
20154 {
20155   static char const arm_noop[2][2][4] =
20156     {
20157       {  /* ARMv1 */
20158         {0x00, 0x00, 0xa0, 0xe1},  /* LE */
20159         {0xe1, 0xa0, 0x00, 0x00},  /* BE */
20160       },
20161       {  /* ARMv6k */
20162         {0x00, 0xf0, 0x20, 0xe3},  /* LE */
20163         {0xe3, 0x20, 0xf0, 0x00},  /* BE */
20164       },
20165     };
20166   static char const thumb_noop[2][2][2] =
20167     {
20168       {  /* Thumb-1 */
20169         {0xc0, 0x46},  /* LE */
20170         {0x46, 0xc0},  /* BE */
20171       },
20172       {  /* Thumb-2 */
20173         {0x00, 0xbf},  /* LE */
20174         {0xbf, 0x00}   /* BE */
20175       }
20176     };
20177   static char const wide_thumb_noop[2][4] =
20178     {  /* Wide Thumb-2 */
20179       {0xaf, 0xf3, 0x00, 0x80},  /* LE */
20180       {0xf3, 0xaf, 0x80, 0x00},  /* BE */
20181     };
20182
20183   unsigned bytes, fix, noop_size;
20184   char * p;
20185   const char * noop;
20186   const char *narrow_noop = NULL;
20187 #ifdef OBJ_ELF
20188   enum mstate state;
20189 #endif
20190
20191   if (fragP->fr_type != rs_align_code)
20192     return;
20193
20194   bytes = fragP->fr_next->fr_address - fragP->fr_address - fragP->fr_fix;
20195   p = fragP->fr_literal + fragP->fr_fix;
20196   fix = 0;
20197
20198   if (bytes > MAX_MEM_FOR_RS_ALIGN_CODE)
20199     bytes &= MAX_MEM_FOR_RS_ALIGN_CODE;
20200
20201   gas_assert ((fragP->tc_frag_data.thumb_mode & MODE_RECORDED) != 0);
20202
20203   if (fragP->tc_frag_data.thumb_mode & (~ MODE_RECORDED))
20204     {
20205       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6t2))
20206         {
20207           narrow_noop = thumb_noop[1][target_big_endian];
20208           noop = wide_thumb_noop[target_big_endian];
20209         }
20210       else
20211         noop = thumb_noop[0][target_big_endian];
20212       noop_size = 2;
20213 #ifdef OBJ_ELF
20214       state = MAP_THUMB;
20215 #endif
20216     }
20217   else
20218     {
20219       noop = arm_noop[ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6k) != 0]
20220                      [target_big_endian];
20221       noop_size = 4;
20222 #ifdef OBJ_ELF
20223       state = MAP_ARM;
20224 #endif
20225     }
20226
20227   fragP->fr_var = noop_size;
20228
20229   if (bytes & (noop_size - 1))
20230     {
20231       fix = bytes & (noop_size - 1);
20232 #ifdef OBJ_ELF
20233       insert_data_mapping_symbol (state, fragP->fr_fix, fragP, fix);
20234 #endif
20235       memset (p, 0, fix);
20236       p += fix;
20237       bytes -= fix;
20238     }
20239
20240   if (narrow_noop)
20241     {
20242       if (bytes & noop_size)
20243         {
20244           /* Insert a narrow noop.  */
20245           memcpy (p, narrow_noop, noop_size);
20246           p += noop_size;
20247           bytes -= noop_size;
20248           fix += noop_size;
20249         }
20250
20251       /* Use wide noops for the remainder */
20252       noop_size = 4;
20253     }
20254
20255   while (bytes >= noop_size)
20256     {
20257       memcpy (p, noop, noop_size);
20258       p += noop_size;
20259       bytes -= noop_size;
20260       fix += noop_size;
20261     }
20262
20263   fragP->fr_fix += fix;
20264 }
20265
20266 /* Called from md_do_align.  Used to create an alignment
20267    frag in a code section.  */
20268
20269 void
20270 arm_frag_align_code (int n, int max)
20271 {
20272   char * p;
20273
20274   /* We assume that there will never be a requirement
20275      to support alignments greater than MAX_MEM_FOR_RS_ALIGN_CODE bytes.  */
20276   if (max > MAX_MEM_FOR_RS_ALIGN_CODE)
20277     {
20278       char err_msg[128];
20279
20280       sprintf (err_msg,
20281         _("alignments greater than %d bytes not supported in .text sections."),
20282         MAX_MEM_FOR_RS_ALIGN_CODE + 1);
20283       as_fatal ("%s", err_msg);
20284     }
20285
20286   p = frag_var (rs_align_code,
20287                 MAX_MEM_FOR_RS_ALIGN_CODE,
20288                 1,
20289                 (relax_substateT) max,
20290                 (symbolS *) NULL,
20291                 (offsetT) n,
20292                 (char *) NULL);
20293   *p = 0;
20294 }
20295
20296 /* Perform target specific initialisation of a frag.
20297    Note - despite the name this initialisation is not done when the frag
20298    is created, but only when its type is assigned.  A frag can be created
20299    and used a long time before its type is set, so beware of assuming that
20300    this initialisationis performed first.  */
20301
20302 #ifndef OBJ_ELF
20303 void
20304 arm_init_frag (fragS * fragP, int max_chars ATTRIBUTE_UNUSED)
20305 {
20306   /* Record whether this frag is in an ARM or a THUMB area.  */
20307   fragP->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
20308 }
20309
20310 #else /* OBJ_ELF is defined.  */
20311 void
20312 arm_init_frag (fragS * fragP, int max_chars)
20313 {
20314   /* If the current ARM vs THUMB mode has not already
20315      been recorded into this frag then do so now.  */
20316   if ((fragP->tc_frag_data.thumb_mode & MODE_RECORDED) == 0)
20317     {
20318       fragP->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
20319
20320       /* Record a mapping symbol for alignment frags.  We will delete this
20321          later if the alignment ends up empty.  */
20322       switch (fragP->fr_type)
20323         {
20324           case rs_align:
20325           case rs_align_test:
20326           case rs_fill:
20327             mapping_state_2 (MAP_DATA, max_chars);
20328             break;
20329           case rs_align_code:
20330             mapping_state_2 (thumb_mode ? MAP_THUMB : MAP_ARM, max_chars);
20331             break;
20332           default:
20333             break;
20334         }
20335     }
20336 }
20337
20338 /* When we change sections we need to issue a new mapping symbol.  */
20339
20340 void
20341 arm_elf_change_section (void)
20342 {
20343   /* Link an unlinked unwind index table section to the .text section.  */
20344   if (elf_section_type (now_seg) == SHT_ARM_EXIDX
20345       && elf_linked_to_section (now_seg) == NULL)
20346     elf_linked_to_section (now_seg) = text_section;
20347 }
20348
20349 int
20350 arm_elf_section_type (const char * str, size_t len)
20351 {
20352   if (len == 5 && strncmp (str, "exidx", 5) == 0)
20353     return SHT_ARM_EXIDX;
20354
20355   return -1;
20356 }
20357 \f
20358 /* Code to deal with unwinding tables.  */
20359
20360 static void add_unwind_adjustsp (offsetT);
20361
20362 /* Generate any deferred unwind frame offset.  */
20363
20364 static void
20365 flush_pending_unwind (void)
20366 {
20367   offsetT offset;
20368
20369   offset = unwind.pending_offset;
20370   unwind.pending_offset = 0;
20371   if (offset != 0)
20372     add_unwind_adjustsp (offset);
20373 }
20374
20375 /* Add an opcode to this list for this function.  Two-byte opcodes should
20376    be passed as op[0] << 8 | op[1].  The list of opcodes is built in reverse
20377    order.  */
20378
20379 static void
20380 add_unwind_opcode (valueT op, int length)
20381 {
20382   /* Add any deferred stack adjustment.  */
20383   if (unwind.pending_offset)
20384     flush_pending_unwind ();
20385
20386   unwind.sp_restored = 0;
20387
20388   if (unwind.opcode_count + length > unwind.opcode_alloc)
20389     {
20390       unwind.opcode_alloc += ARM_OPCODE_CHUNK_SIZE;
20391       if (unwind.opcodes)
20392         unwind.opcodes = (unsigned char *) xrealloc (unwind.opcodes,
20393                                                      unwind.opcode_alloc);
20394       else
20395         unwind.opcodes = (unsigned char *) xmalloc (unwind.opcode_alloc);
20396     }
20397   while (length > 0)
20398     {
20399       length--;
20400       unwind.opcodes[unwind.opcode_count] = op & 0xff;
20401       op >>= 8;
20402       unwind.opcode_count++;
20403     }
20404 }
20405
20406 /* Add unwind opcodes to adjust the stack pointer.  */
20407
20408 static void
20409 add_unwind_adjustsp (offsetT offset)
20410 {
20411   valueT op;
20412
20413   if (offset > 0x200)
20414     {
20415       /* We need at most 5 bytes to hold a 32-bit value in a uleb128.  */
20416       char bytes[5];
20417       int n;
20418       valueT o;
20419
20420       /* Long form: 0xb2, uleb128.  */
20421       /* This might not fit in a word so add the individual bytes,
20422          remembering the list is built in reverse order.  */
20423       o = (valueT) ((offset - 0x204) >> 2);
20424       if (o == 0)
20425         add_unwind_opcode (0, 1);
20426
20427       /* Calculate the uleb128 encoding of the offset.  */
20428       n = 0;
20429       while (o)
20430         {
20431           bytes[n] = o & 0x7f;
20432           o >>= 7;
20433           if (o)
20434             bytes[n] |= 0x80;
20435           n++;
20436         }
20437       /* Add the insn.  */
20438       for (; n; n--)
20439         add_unwind_opcode (bytes[n - 1], 1);
20440       add_unwind_opcode (0xb2, 1);
20441     }
20442   else if (offset > 0x100)
20443     {
20444       /* Two short opcodes.  */
20445       add_unwind_opcode (0x3f, 1);
20446       op = (offset - 0x104) >> 2;
20447       add_unwind_opcode (op, 1);
20448     }
20449   else if (offset > 0)
20450     {
20451       /* Short opcode.  */
20452       op = (offset - 4) >> 2;
20453       add_unwind_opcode (op, 1);
20454     }
20455   else if (offset < 0)
20456     {
20457       offset = -offset;
20458       while (offset > 0x100)
20459         {
20460           add_unwind_opcode (0x7f, 1);
20461           offset -= 0x100;
20462         }
20463       op = ((offset - 4) >> 2) | 0x40;
20464       add_unwind_opcode (op, 1);
20465     }
20466 }
20467
20468 /* Finish the list of unwind opcodes for this function.  */
20469 static void
20470 finish_unwind_opcodes (void)
20471 {
20472   valueT op;
20473
20474   if (unwind.fp_used)
20475     {
20476       /* Adjust sp as necessary.  */
20477       unwind.pending_offset += unwind.fp_offset - unwind.frame_size;
20478       flush_pending_unwind ();
20479
20480       /* After restoring sp from the frame pointer.  */
20481       op = 0x90 | unwind.fp_reg;
20482       add_unwind_opcode (op, 1);
20483     }
20484   else
20485     flush_pending_unwind ();
20486 }
20487
20488
20489 /* Start an exception table entry.  If idx is nonzero this is an index table
20490    entry.  */
20491
20492 static void
20493 start_unwind_section (const segT text_seg, int idx)
20494 {
20495   const char * text_name;
20496   const char * prefix;
20497   const char * prefix_once;
20498   const char * group_name;
20499   size_t prefix_len;
20500   size_t text_len;
20501   char * sec_name;
20502   size_t sec_name_len;
20503   int type;
20504   int flags;
20505   int linkonce;
20506
20507   if (idx)
20508     {
20509       prefix = ELF_STRING_ARM_unwind;
20510       prefix_once = ELF_STRING_ARM_unwind_once;
20511       type = SHT_ARM_EXIDX;
20512     }
20513   else
20514     {
20515       prefix = ELF_STRING_ARM_unwind_info;
20516       prefix_once = ELF_STRING_ARM_unwind_info_once;
20517       type = SHT_PROGBITS;
20518     }
20519
20520   text_name = segment_name (text_seg);
20521   if (streq (text_name, ".text"))
20522     text_name = "";
20523
20524   if (strncmp (text_name, ".gnu.linkonce.t.",
20525                strlen (".gnu.linkonce.t.")) == 0)
20526     {
20527       prefix = prefix_once;
20528       text_name += strlen (".gnu.linkonce.t.");
20529     }
20530
20531   prefix_len = strlen (prefix);
20532   text_len = strlen (text_name);
20533   sec_name_len = prefix_len + text_len;
20534   sec_name = (char *) xmalloc (sec_name_len + 1);
20535   memcpy (sec_name, prefix, prefix_len);
20536   memcpy (sec_name + prefix_len, text_name, text_len);
20537   sec_name[prefix_len + text_len] = '\0';
20538
20539   flags = SHF_ALLOC;
20540   linkonce = 0;
20541   group_name = 0;
20542
20543   /* Handle COMDAT group.  */
20544   if (prefix != prefix_once && (text_seg->flags & SEC_LINK_ONCE) != 0)
20545     {
20546       group_name = elf_group_name (text_seg);
20547       if (group_name == NULL)
20548         {
20549           as_bad (_("Group section `%s' has no group signature"),
20550                   segment_name (text_seg));
20551           ignore_rest_of_line ();
20552           return;
20553         }
20554       flags |= SHF_GROUP;
20555       linkonce = 1;
20556     }
20557
20558   obj_elf_change_section (sec_name, type, flags, 0, group_name, linkonce, 0);
20559
20560   /* Set the section link for index tables.  */
20561   if (idx)
20562     elf_linked_to_section (now_seg) = text_seg;
20563 }
20564
20565
20566 /* Start an unwind table entry.  HAVE_DATA is nonzero if we have additional
20567    personality routine data.  Returns zero, or the index table value for
20568    and inline entry.  */
20569
20570 static valueT
20571 create_unwind_entry (int have_data)
20572 {
20573   int size;
20574   addressT where;
20575   char *ptr;
20576   /* The current word of data.  */
20577   valueT data;
20578   /* The number of bytes left in this word.  */
20579   int n;
20580
20581   finish_unwind_opcodes ();
20582
20583   /* Remember the current text section.  */
20584   unwind.saved_seg = now_seg;
20585   unwind.saved_subseg = now_subseg;
20586
20587   start_unwind_section (now_seg, 0);
20588
20589   if (unwind.personality_routine == NULL)
20590     {
20591       if (unwind.personality_index == -2)
20592         {
20593           if (have_data)
20594             as_bad (_("handlerdata in cantunwind frame"));
20595           return 1; /* EXIDX_CANTUNWIND.  */
20596         }
20597
20598       /* Use a default personality routine if none is specified.  */
20599       if (unwind.personality_index == -1)
20600         {
20601           if (unwind.opcode_count > 3)
20602             unwind.personality_index = 1;
20603           else
20604             unwind.personality_index = 0;
20605         }
20606
20607       /* Space for the personality routine entry.  */
20608       if (unwind.personality_index == 0)
20609         {
20610           if (unwind.opcode_count > 3)
20611             as_bad (_("too many unwind opcodes for personality routine 0"));
20612
20613           if (!have_data)
20614             {
20615               /* All the data is inline in the index table.  */
20616               data = 0x80;
20617               n = 3;
20618               while (unwind.opcode_count > 0)
20619                 {
20620                   unwind.opcode_count--;
20621                   data = (data << 8) | unwind.opcodes[unwind.opcode_count];
20622                   n--;
20623                 }
20624
20625               /* Pad with "finish" opcodes.  */
20626               while (n--)
20627                 data = (data << 8) | 0xb0;
20628
20629               return data;
20630             }
20631           size = 0;
20632         }
20633       else
20634         /* We get two opcodes "free" in the first word.  */
20635         size = unwind.opcode_count - 2;
20636     }
20637   else
20638     {
20639       gas_assert (unwind.personality_index == -1);
20640
20641       /* An extra byte is required for the opcode count.        */
20642       size = unwind.opcode_count + 1;
20643     }
20644
20645   size = (size + 3) >> 2;
20646   if (size > 0xff)
20647     as_bad (_("too many unwind opcodes"));
20648
20649   frag_align (2, 0, 0);
20650   record_alignment (now_seg, 2);
20651   unwind.table_entry = expr_build_dot ();
20652
20653   /* Allocate the table entry.  */
20654   ptr = frag_more ((size << 2) + 4);
20655   /* PR 13449: Zero the table entries in case some of them are not used.  */
20656   memset (ptr, 0, (size << 2) + 4);
20657   where = frag_now_fix () - ((size << 2) + 4);
20658
20659   switch (unwind.personality_index)
20660     {
20661     case -1:
20662       /* ??? Should this be a PLT generating relocation?  */
20663       /* Custom personality routine.  */
20664       fix_new (frag_now, where, 4, unwind.personality_routine, 0, 1,
20665                BFD_RELOC_ARM_PREL31);
20666
20667       where += 4;
20668       ptr += 4;
20669
20670       /* Set the first byte to the number of additional words.  */
20671       data = size > 0 ? size - 1 : 0;
20672       n = 3;
20673       break;
20674
20675     /* ABI defined personality routines.  */
20676     case 0:
20677       /* Three opcodes bytes are packed into the first word.  */
20678       data = 0x80;
20679       n = 3;
20680       break;
20681
20682     case 1:
20683     case 2:
20684       /* The size and first two opcode bytes go in the first word.  */
20685       data = ((0x80 + unwind.personality_index) << 8) | size;
20686       n = 2;
20687       break;
20688
20689     default:
20690       /* Should never happen.  */
20691       abort ();
20692     }
20693
20694   /* Pack the opcodes into words (MSB first), reversing the list at the same
20695      time.  */
20696   while (unwind.opcode_count > 0)
20697     {
20698       if (n == 0)
20699         {
20700           md_number_to_chars (ptr, data, 4);
20701           ptr += 4;
20702           n = 4;
20703           data = 0;
20704         }
20705       unwind.opcode_count--;
20706       n--;
20707       data = (data << 8) | unwind.opcodes[unwind.opcode_count];
20708     }
20709
20710   /* Finish off the last word.  */
20711   if (n < 4)
20712     {
20713       /* Pad with "finish" opcodes.  */
20714       while (n--)
20715         data = (data << 8) | 0xb0;
20716
20717       md_number_to_chars (ptr, data, 4);
20718     }
20719
20720   if (!have_data)
20721     {
20722       /* Add an empty descriptor if there is no user-specified data.   */
20723       ptr = frag_more (4);
20724       md_number_to_chars (ptr, 0, 4);
20725     }
20726
20727   return 0;
20728 }
20729
20730
20731 /* Initialize the DWARF-2 unwind information for this procedure.  */
20732
20733 void
20734 tc_arm_frame_initial_instructions (void)
20735 {
20736   cfi_add_CFA_def_cfa (REG_SP, 0);
20737 }
20738 #endif /* OBJ_ELF */
20739
20740 /* Convert REGNAME to a DWARF-2 register number.  */
20741
20742 int
20743 tc_arm_regname_to_dw2regnum (char *regname)
20744 {
20745   int reg = arm_reg_parse (&regname, REG_TYPE_RN);
20746
20747   if (reg == FAIL)
20748     return -1;
20749
20750   return reg;
20751 }
20752
20753 #ifdef TE_PE
20754 void
20755 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
20756 {
20757   expressionS exp;
20758
20759   exp.X_op = O_secrel;
20760   exp.X_add_symbol = symbol;
20761   exp.X_add_number = 0;
20762   emit_expr (&exp, size);
20763 }
20764 #endif
20765
20766 /* MD interface: Symbol and relocation handling.  */
20767
20768 /* Return the address within the segment that a PC-relative fixup is
20769    relative to.  For ARM, PC-relative fixups applied to instructions
20770    are generally relative to the location of the fixup plus 8 bytes.
20771    Thumb branches are offset by 4, and Thumb loads relative to PC
20772    require special handling.  */
20773
20774 long
20775 md_pcrel_from_section (fixS * fixP, segT seg)
20776 {
20777   offsetT base = fixP->fx_where + fixP->fx_frag->fr_address;
20778
20779   /* If this is pc-relative and we are going to emit a relocation
20780      then we just want to put out any pipeline compensation that the linker
20781      will need.  Otherwise we want to use the calculated base.
20782      For WinCE we skip the bias for externals as well, since this
20783      is how the MS ARM-CE assembler behaves and we want to be compatible.  */
20784   if (fixP->fx_pcrel
20785       && ((fixP->fx_addsy && S_GET_SEGMENT (fixP->fx_addsy) != seg)
20786           || (arm_force_relocation (fixP)
20787 #ifdef TE_WINCE
20788               && !S_IS_EXTERNAL (fixP->fx_addsy)
20789 #endif
20790               )))
20791     base = 0;
20792
20793
20794   switch (fixP->fx_r_type)
20795     {
20796       /* PC relative addressing on the Thumb is slightly odd as the
20797          bottom two bits of the PC are forced to zero for the
20798          calculation.  This happens *after* application of the
20799          pipeline offset.  However, Thumb adrl already adjusts for
20800          this, so we need not do it again.  */
20801     case BFD_RELOC_ARM_THUMB_ADD:
20802       return base & ~3;
20803
20804     case BFD_RELOC_ARM_THUMB_OFFSET:
20805     case BFD_RELOC_ARM_T32_OFFSET_IMM:
20806     case BFD_RELOC_ARM_T32_ADD_PC12:
20807     case BFD_RELOC_ARM_T32_CP_OFF_IMM:
20808       return (base + 4) & ~3;
20809
20810       /* Thumb branches are simply offset by +4.  */
20811     case BFD_RELOC_THUMB_PCREL_BRANCH7:
20812     case BFD_RELOC_THUMB_PCREL_BRANCH9:
20813     case BFD_RELOC_THUMB_PCREL_BRANCH12:
20814     case BFD_RELOC_THUMB_PCREL_BRANCH20:
20815     case BFD_RELOC_THUMB_PCREL_BRANCH25:
20816       return base + 4;
20817
20818     case BFD_RELOC_THUMB_PCREL_BRANCH23:
20819       if (fixP->fx_addsy
20820           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
20821           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
20822           && ARM_IS_FUNC (fixP->fx_addsy)
20823           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
20824         base = fixP->fx_where + fixP->fx_frag->fr_address;
20825        return base + 4;
20826
20827       /* BLX is like branches above, but forces the low two bits of PC to
20828          zero.  */
20829     case BFD_RELOC_THUMB_PCREL_BLX:
20830       if (fixP->fx_addsy
20831           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
20832           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
20833           && THUMB_IS_FUNC (fixP->fx_addsy)
20834           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
20835         base = fixP->fx_where + fixP->fx_frag->fr_address;
20836       return (base + 4) & ~3;
20837
20838       /* ARM mode branches are offset by +8.  However, the Windows CE
20839          loader expects the relocation not to take this into account.  */
20840     case BFD_RELOC_ARM_PCREL_BLX:
20841       if (fixP->fx_addsy
20842           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
20843           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
20844           && ARM_IS_FUNC (fixP->fx_addsy)
20845           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
20846         base = fixP->fx_where + fixP->fx_frag->fr_address;
20847       return base + 8;
20848
20849     case BFD_RELOC_ARM_PCREL_CALL:
20850       if (fixP->fx_addsy
20851           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
20852           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
20853           && THUMB_IS_FUNC (fixP->fx_addsy)
20854           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
20855         base = fixP->fx_where + fixP->fx_frag->fr_address;
20856       return base + 8;
20857
20858     case BFD_RELOC_ARM_PCREL_BRANCH:
20859     case BFD_RELOC_ARM_PCREL_JUMP:
20860     case BFD_RELOC_ARM_PLT32:
20861 #ifdef TE_WINCE
20862       /* When handling fixups immediately, because we have already
20863          discovered the value of a symbol, or the address of the frag involved
20864          we must account for the offset by +8, as the OS loader will never see the reloc.
20865          see fixup_segment() in write.c
20866          The S_IS_EXTERNAL test handles the case of global symbols.
20867          Those need the calculated base, not just the pipe compensation the linker will need.  */
20868       if (fixP->fx_pcrel
20869           && fixP->fx_addsy != NULL
20870           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
20871           && (S_IS_EXTERNAL (fixP->fx_addsy) || !arm_force_relocation (fixP)))
20872         return base + 8;
20873       return base;
20874 #else
20875       return base + 8;
20876 #endif
20877
20878
20879       /* ARM mode loads relative to PC are also offset by +8.  Unlike
20880          branches, the Windows CE loader *does* expect the relocation
20881          to take this into account.  */
20882     case BFD_RELOC_ARM_OFFSET_IMM:
20883     case BFD_RELOC_ARM_OFFSET_IMM8:
20884     case BFD_RELOC_ARM_HWLITERAL:
20885     case BFD_RELOC_ARM_LITERAL:
20886     case BFD_RELOC_ARM_CP_OFF_IMM:
20887       return base + 8;
20888
20889
20890       /* Other PC-relative relocations are un-offset.  */
20891     default:
20892       return base;
20893     }
20894 }
20895
20896 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
20897    Otherwise we have no need to default values of symbols.  */
20898
20899 symbolS *
20900 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
20901 {
20902 #ifdef OBJ_ELF
20903   if (name[0] == '_' && name[1] == 'G'
20904       && streq (name, GLOBAL_OFFSET_TABLE_NAME))
20905     {
20906       if (!GOT_symbol)
20907         {
20908           if (symbol_find (name))
20909             as_bad (_("GOT already in the symbol table"));
20910
20911           GOT_symbol = symbol_new (name, undefined_section,
20912                                    (valueT) 0, & zero_address_frag);
20913         }
20914
20915       return GOT_symbol;
20916     }
20917 #endif
20918
20919   return NULL;
20920 }
20921
20922 /* Subroutine of md_apply_fix.   Check to see if an immediate can be
20923    computed as two separate immediate values, added together.  We
20924    already know that this value cannot be computed by just one ARM
20925    instruction.  */
20926
20927 static unsigned int
20928 validate_immediate_twopart (unsigned int   val,
20929                             unsigned int * highpart)
20930 {
20931   unsigned int a;
20932   unsigned int i;
20933
20934   for (i = 0; i < 32; i += 2)
20935     if (((a = rotate_left (val, i)) & 0xff) != 0)
20936       {
20937         if (a & 0xff00)
20938           {
20939             if (a & ~ 0xffff)
20940               continue;
20941             * highpart = (a  >> 8) | ((i + 24) << 7);
20942           }
20943         else if (a & 0xff0000)
20944           {
20945             if (a & 0xff000000)
20946               continue;
20947             * highpart = (a >> 16) | ((i + 16) << 7);
20948           }
20949         else
20950           {
20951             gas_assert (a & 0xff000000);
20952             * highpart = (a >> 24) | ((i + 8) << 7);
20953           }
20954
20955         return (a & 0xff) | (i << 7);
20956       }
20957
20958   return FAIL;
20959 }
20960
20961 static int
20962 validate_offset_imm (unsigned int val, int hwse)
20963 {
20964   if ((hwse && val > 255) || val > 4095)
20965     return FAIL;
20966   return val;
20967 }
20968
20969 /* Subroutine of md_apply_fix.   Do those data_ops which can take a
20970    negative immediate constant by altering the instruction.  A bit of
20971    a hack really.
20972         MOV <-> MVN
20973         AND <-> BIC
20974         ADC <-> SBC
20975         by inverting the second operand, and
20976         ADD <-> SUB
20977         CMP <-> CMN
20978         by negating the second operand.  */
20979
20980 static int
20981 negate_data_op (unsigned long * instruction,
20982                 unsigned long   value)
20983 {
20984   int op, new_inst;
20985   unsigned long negated, inverted;
20986
20987   negated = encode_arm_immediate (-value);
20988   inverted = encode_arm_immediate (~value);
20989
20990   op = (*instruction >> DATA_OP_SHIFT) & 0xf;
20991   switch (op)
20992     {
20993       /* First negates.  */
20994     case OPCODE_SUB:             /* ADD <-> SUB  */
20995       new_inst = OPCODE_ADD;
20996       value = negated;
20997       break;
20998
20999     case OPCODE_ADD:
21000       new_inst = OPCODE_SUB;
21001       value = negated;
21002       break;
21003
21004     case OPCODE_CMP:             /* CMP <-> CMN  */
21005       new_inst = OPCODE_CMN;
21006       value = negated;
21007       break;
21008
21009     case OPCODE_CMN:
21010       new_inst = OPCODE_CMP;
21011       value = negated;
21012       break;
21013
21014       /* Now Inverted ops.  */
21015     case OPCODE_MOV:             /* MOV <-> MVN  */
21016       new_inst = OPCODE_MVN;
21017       value = inverted;
21018       break;
21019
21020     case OPCODE_MVN:
21021       new_inst = OPCODE_MOV;
21022       value = inverted;
21023       break;
21024
21025     case OPCODE_AND:             /* AND <-> BIC  */
21026       new_inst = OPCODE_BIC;
21027       value = inverted;
21028       break;
21029
21030     case OPCODE_BIC:
21031       new_inst = OPCODE_AND;
21032       value = inverted;
21033       break;
21034
21035     case OPCODE_ADC:              /* ADC <-> SBC  */
21036       new_inst = OPCODE_SBC;
21037       value = inverted;
21038       break;
21039
21040     case OPCODE_SBC:
21041       new_inst = OPCODE_ADC;
21042       value = inverted;
21043       break;
21044
21045       /* We cannot do anything.  */
21046     default:
21047       return FAIL;
21048     }
21049
21050   if (value == (unsigned) FAIL)
21051     return FAIL;
21052
21053   *instruction &= OPCODE_MASK;
21054   *instruction |= new_inst << DATA_OP_SHIFT;
21055   return value;
21056 }
21057
21058 /* Like negate_data_op, but for Thumb-2.   */
21059
21060 static unsigned int
21061 thumb32_negate_data_op (offsetT *instruction, unsigned int value)
21062 {
21063   int op, new_inst;
21064   int rd;
21065   unsigned int negated, inverted;
21066
21067   negated = encode_thumb32_immediate (-value);
21068   inverted = encode_thumb32_immediate (~value);
21069
21070   rd = (*instruction >> 8) & 0xf;
21071   op = (*instruction >> T2_DATA_OP_SHIFT) & 0xf;
21072   switch (op)
21073     {
21074       /* ADD <-> SUB.  Includes CMP <-> CMN.  */
21075     case T2_OPCODE_SUB:
21076       new_inst = T2_OPCODE_ADD;
21077       value = negated;
21078       break;
21079
21080     case T2_OPCODE_ADD:
21081       new_inst = T2_OPCODE_SUB;
21082       value = negated;
21083       break;
21084
21085       /* ORR <-> ORN.  Includes MOV <-> MVN.  */
21086     case T2_OPCODE_ORR:
21087       new_inst = T2_OPCODE_ORN;
21088       value = inverted;
21089       break;
21090
21091     case T2_OPCODE_ORN:
21092       new_inst = T2_OPCODE_ORR;
21093       value = inverted;
21094       break;
21095
21096       /* AND <-> BIC.  TST has no inverted equivalent.  */
21097     case T2_OPCODE_AND:
21098       new_inst = T2_OPCODE_BIC;
21099       if (rd == 15)
21100         value = FAIL;
21101       else
21102         value = inverted;
21103       break;
21104
21105     case T2_OPCODE_BIC:
21106       new_inst = T2_OPCODE_AND;
21107       value = inverted;
21108       break;
21109
21110       /* ADC <-> SBC  */
21111     case T2_OPCODE_ADC:
21112       new_inst = T2_OPCODE_SBC;
21113       value = inverted;
21114       break;
21115
21116     case T2_OPCODE_SBC:
21117       new_inst = T2_OPCODE_ADC;
21118       value = inverted;
21119       break;
21120
21121       /* We cannot do anything.  */
21122     default:
21123       return FAIL;
21124     }
21125
21126   if (value == (unsigned int)FAIL)
21127     return FAIL;
21128
21129   *instruction &= T2_OPCODE_MASK;
21130   *instruction |= new_inst << T2_DATA_OP_SHIFT;
21131   return value;
21132 }
21133
21134 /* Read a 32-bit thumb instruction from buf.  */
21135 static unsigned long
21136 get_thumb32_insn (char * buf)
21137 {
21138   unsigned long insn;
21139   insn = md_chars_to_number (buf, THUMB_SIZE) << 16;
21140   insn |= md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
21141
21142   return insn;
21143 }
21144
21145
21146 /* We usually want to set the low bit on the address of thumb function
21147    symbols.  In particular .word foo - . should have the low bit set.
21148    Generic code tries to fold the difference of two symbols to
21149    a constant.  Prevent this and force a relocation when the first symbols
21150    is a thumb function.  */
21151
21152 bfd_boolean
21153 arm_optimize_expr (expressionS *l, operatorT op, expressionS *r)
21154 {
21155   if (op == O_subtract
21156       && l->X_op == O_symbol
21157       && r->X_op == O_symbol
21158       && THUMB_IS_FUNC (l->X_add_symbol))
21159     {
21160       l->X_op = O_subtract;
21161       l->X_op_symbol = r->X_add_symbol;
21162       l->X_add_number -= r->X_add_number;
21163       return TRUE;
21164     }
21165
21166   /* Process as normal.  */
21167   return FALSE;
21168 }
21169
21170 /* Encode Thumb2 unconditional branches and calls. The encoding
21171    for the 2 are identical for the immediate values.  */
21172
21173 static void
21174 encode_thumb2_b_bl_offset (char * buf, offsetT value)
21175 {
21176 #define T2I1I2MASK  ((1 << 13) | (1 << 11))
21177   offsetT newval;
21178   offsetT newval2;
21179   addressT S, I1, I2, lo, hi;
21180
21181   S = (value >> 24) & 0x01;
21182   I1 = (value >> 23) & 0x01;
21183   I2 = (value >> 22) & 0x01;
21184   hi = (value >> 12) & 0x3ff;
21185   lo = (value >> 1) & 0x7ff;
21186   newval   = md_chars_to_number (buf, THUMB_SIZE);
21187   newval2  = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
21188   newval  |= (S << 10) | hi;
21189   newval2 &=  ~T2I1I2MASK;
21190   newval2 |= (((I1 ^ S) << 13) | ((I2 ^ S) << 11) | lo) ^ T2I1I2MASK;
21191   md_number_to_chars (buf, newval, THUMB_SIZE);
21192   md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
21193 }
21194
21195 void
21196 md_apply_fix (fixS *    fixP,
21197                valueT * valP,
21198                segT     seg)
21199 {
21200   offsetT        value = * valP;
21201   offsetT        newval;
21202   unsigned int   newimm;
21203   unsigned long  temp;
21204   int            sign;
21205   char *         buf = fixP->fx_where + fixP->fx_frag->fr_literal;
21206
21207   gas_assert (fixP->fx_r_type <= BFD_RELOC_UNUSED);
21208
21209   /* Note whether this will delete the relocation.  */
21210
21211   if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
21212     fixP->fx_done = 1;
21213
21214   /* On a 64-bit host, silently truncate 'value' to 32 bits for
21215      consistency with the behaviour on 32-bit hosts.  Remember value
21216      for emit_reloc.  */
21217   value &= 0xffffffff;
21218   value ^= 0x80000000;
21219   value -= 0x80000000;
21220
21221   *valP = value;
21222   fixP->fx_addnumber = value;
21223
21224   /* Same treatment for fixP->fx_offset.  */
21225   fixP->fx_offset &= 0xffffffff;
21226   fixP->fx_offset ^= 0x80000000;
21227   fixP->fx_offset -= 0x80000000;
21228
21229   switch (fixP->fx_r_type)
21230     {
21231     case BFD_RELOC_NONE:
21232       /* This will need to go in the object file.  */
21233       fixP->fx_done = 0;
21234       break;
21235
21236     case BFD_RELOC_ARM_IMMEDIATE:
21237       /* We claim that this fixup has been processed here,
21238          even if in fact we generate an error because we do
21239          not have a reloc for it, so tc_gen_reloc will reject it.  */
21240       fixP->fx_done = 1;
21241
21242       if (fixP->fx_addsy)
21243         {
21244           const char *msg = 0;
21245
21246           if (! S_IS_DEFINED (fixP->fx_addsy))
21247             msg = _("undefined symbol %s used as an immediate value");
21248           else if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
21249             msg = _("symbol %s is in a different section");
21250           else if (S_IS_WEAK (fixP->fx_addsy))
21251             msg = _("symbol %s is weak and may be overridden later");
21252
21253           if (msg)
21254             {
21255               as_bad_where (fixP->fx_file, fixP->fx_line,
21256                             msg, S_GET_NAME (fixP->fx_addsy));
21257               break;
21258             }
21259         }
21260
21261       temp = md_chars_to_number (buf, INSN_SIZE);
21262
21263       /* If the offset is negative, we should use encoding A2 for ADR.  */
21264       if ((temp & 0xfff0000) == 0x28f0000 && value < 0)
21265         newimm = negate_data_op (&temp, value);
21266       else
21267         {
21268           newimm = encode_arm_immediate (value);
21269
21270           /* If the instruction will fail, see if we can fix things up by
21271              changing the opcode.  */
21272           if (newimm == (unsigned int) FAIL)
21273             newimm = negate_data_op (&temp, value);
21274         }
21275
21276       if (newimm == (unsigned int) FAIL)
21277         {
21278           as_bad_where (fixP->fx_file, fixP->fx_line,
21279                         _("invalid constant (%lx) after fixup"),
21280                         (unsigned long) value);
21281           break;
21282         }
21283
21284       newimm |= (temp & 0xfffff000);
21285       md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
21286       break;
21287
21288     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
21289       {
21290         unsigned int highpart = 0;
21291         unsigned int newinsn  = 0xe1a00000; /* nop.  */
21292
21293         if (fixP->fx_addsy)
21294           {
21295             const char *msg = 0;
21296
21297             if (! S_IS_DEFINED (fixP->fx_addsy))
21298               msg = _("undefined symbol %s used as an immediate value");
21299             else if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
21300               msg = _("symbol %s is in a different section");
21301             else if (S_IS_WEAK (fixP->fx_addsy))
21302               msg = _("symbol %s is weak and may be overridden later");
21303
21304             if (msg)
21305               {
21306                 as_bad_where (fixP->fx_file, fixP->fx_line,
21307                               msg, S_GET_NAME (fixP->fx_addsy));
21308                 break;
21309               }
21310           }
21311
21312         newimm = encode_arm_immediate (value);
21313         temp = md_chars_to_number (buf, INSN_SIZE);
21314
21315         /* If the instruction will fail, see if we can fix things up by
21316            changing the opcode.  */
21317         if (newimm == (unsigned int) FAIL
21318             && (newimm = negate_data_op (& temp, value)) == (unsigned int) FAIL)
21319           {
21320             /* No ?  OK - try using two ADD instructions to generate
21321                the value.  */
21322             newimm = validate_immediate_twopart (value, & highpart);
21323
21324             /* Yes - then make sure that the second instruction is
21325                also an add.  */
21326             if (newimm != (unsigned int) FAIL)
21327               newinsn = temp;
21328             /* Still No ?  Try using a negated value.  */
21329             else if ((newimm = validate_immediate_twopart (- value, & highpart)) != (unsigned int) FAIL)
21330               temp = newinsn = (temp & OPCODE_MASK) | OPCODE_SUB << DATA_OP_SHIFT;
21331             /* Otherwise - give up.  */
21332             else
21333               {
21334                 as_bad_where (fixP->fx_file, fixP->fx_line,
21335                               _("unable to compute ADRL instructions for PC offset of 0x%lx"),
21336                               (long) value);
21337                 break;
21338               }
21339
21340             /* Replace the first operand in the 2nd instruction (which
21341                is the PC) with the destination register.  We have
21342                already added in the PC in the first instruction and we
21343                do not want to do it again.  */
21344             newinsn &= ~ 0xf0000;
21345             newinsn |= ((newinsn & 0x0f000) << 4);
21346           }
21347
21348         newimm |= (temp & 0xfffff000);
21349         md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
21350
21351         highpart |= (newinsn & 0xfffff000);
21352         md_number_to_chars (buf + INSN_SIZE, (valueT) highpart, INSN_SIZE);
21353       }
21354       break;
21355
21356     case BFD_RELOC_ARM_OFFSET_IMM:
21357       if (!fixP->fx_done && seg->use_rela_p)
21358         value = 0;
21359
21360     case BFD_RELOC_ARM_LITERAL:
21361       sign = value > 0;
21362
21363       if (value < 0)
21364         value = - value;
21365
21366       if (validate_offset_imm (value, 0) == FAIL)
21367         {
21368           if (fixP->fx_r_type == BFD_RELOC_ARM_LITERAL)
21369             as_bad_where (fixP->fx_file, fixP->fx_line,
21370                           _("invalid literal constant: pool needs to be closer"));
21371           else
21372             as_bad_where (fixP->fx_file, fixP->fx_line,
21373                           _("bad immediate value for offset (%ld)"),
21374                           (long) value);
21375           break;
21376         }
21377
21378       newval = md_chars_to_number (buf, INSN_SIZE);
21379       if (value == 0)
21380         newval &= 0xfffff000;
21381       else
21382         {
21383           newval &= 0xff7ff000;
21384           newval |= value | (sign ? INDEX_UP : 0);
21385         }
21386       md_number_to_chars (buf, newval, INSN_SIZE);
21387       break;
21388
21389     case BFD_RELOC_ARM_OFFSET_IMM8:
21390     case BFD_RELOC_ARM_HWLITERAL:
21391       sign = value > 0;
21392
21393       if (value < 0)
21394         value = - value;
21395
21396       if (validate_offset_imm (value, 1) == FAIL)
21397         {
21398           if (fixP->fx_r_type == BFD_RELOC_ARM_HWLITERAL)
21399             as_bad_where (fixP->fx_file, fixP->fx_line,
21400                           _("invalid literal constant: pool needs to be closer"));
21401           else
21402             as_bad (_("bad immediate value for 8-bit offset (%ld)"),
21403                     (long) value);
21404           break;
21405         }
21406
21407       newval = md_chars_to_number (buf, INSN_SIZE);
21408       if (value == 0)
21409         newval &= 0xfffff0f0;
21410       else
21411         {
21412           newval &= 0xff7ff0f0;
21413           newval |= ((value >> 4) << 8) | (value & 0xf) | (sign ? INDEX_UP : 0);
21414         }
21415       md_number_to_chars (buf, newval, INSN_SIZE);
21416       break;
21417
21418     case BFD_RELOC_ARM_T32_OFFSET_U8:
21419       if (value < 0 || value > 1020 || value % 4 != 0)
21420         as_bad_where (fixP->fx_file, fixP->fx_line,
21421                       _("bad immediate value for offset (%ld)"), (long) value);
21422       value /= 4;
21423
21424       newval = md_chars_to_number (buf+2, THUMB_SIZE);
21425       newval |= value;
21426       md_number_to_chars (buf+2, newval, THUMB_SIZE);
21427       break;
21428
21429     case BFD_RELOC_ARM_T32_OFFSET_IMM:
21430       /* This is a complicated relocation used for all varieties of Thumb32
21431          load/store instruction with immediate offset:
21432
21433          1110 100P u1WL NNNN XXXX YYYY iiii iiii - +/-(U) pre/post(P) 8-bit,
21434                                                    *4, optional writeback(W)
21435                                                    (doubleword load/store)
21436
21437          1111 100S uTTL 1111 XXXX iiii iiii iiii - +/-(U) 12-bit PC-rel
21438          1111 100S 0TTL NNNN XXXX 1Pu1 iiii iiii - +/-(U) pre/post(P) 8-bit
21439          1111 100S 0TTL NNNN XXXX 1110 iiii iiii - positive 8-bit (T instruction)
21440          1111 100S 1TTL NNNN XXXX iiii iiii iiii - positive 12-bit
21441          1111 100S 0TTL NNNN XXXX 1100 iiii iiii - negative 8-bit
21442
21443          Uppercase letters indicate bits that are already encoded at
21444          this point.  Lowercase letters are our problem.  For the
21445          second block of instructions, the secondary opcode nybble
21446          (bits 8..11) is present, and bit 23 is zero, even if this is
21447          a PC-relative operation.  */
21448       newval = md_chars_to_number (buf, THUMB_SIZE);
21449       newval <<= 16;
21450       newval |= md_chars_to_number (buf+THUMB_SIZE, THUMB_SIZE);
21451
21452       if ((newval & 0xf0000000) == 0xe0000000)
21453         {
21454           /* Doubleword load/store: 8-bit offset, scaled by 4.  */
21455           if (value >= 0)
21456             newval |= (1 << 23);
21457           else
21458             value = -value;
21459           if (value % 4 != 0)
21460             {
21461               as_bad_where (fixP->fx_file, fixP->fx_line,
21462                             _("offset not a multiple of 4"));
21463               break;
21464             }
21465           value /= 4;
21466           if (value > 0xff)
21467             {
21468               as_bad_where (fixP->fx_file, fixP->fx_line,
21469                             _("offset out of range"));
21470               break;
21471             }
21472           newval &= ~0xff;
21473         }
21474       else if ((newval & 0x000f0000) == 0x000f0000)
21475         {
21476           /* PC-relative, 12-bit offset.  */
21477           if (value >= 0)
21478             newval |= (1 << 23);
21479           else
21480             value = -value;
21481           if (value > 0xfff)
21482             {
21483               as_bad_where (fixP->fx_file, fixP->fx_line,
21484                             _("offset out of range"));
21485               break;
21486             }
21487           newval &= ~0xfff;
21488         }
21489       else if ((newval & 0x00000100) == 0x00000100)
21490         {
21491           /* Writeback: 8-bit, +/- offset.  */
21492           if (value >= 0)
21493             newval |= (1 << 9);
21494           else
21495             value = -value;
21496           if (value > 0xff)
21497             {
21498               as_bad_where (fixP->fx_file, fixP->fx_line,
21499                             _("offset out of range"));
21500               break;
21501             }
21502           newval &= ~0xff;
21503         }
21504       else if ((newval & 0x00000f00) == 0x00000e00)
21505         {
21506           /* T-instruction: positive 8-bit offset.  */
21507           if (value < 0 || value > 0xff)
21508             {
21509               as_bad_where (fixP->fx_file, fixP->fx_line,
21510                             _("offset out of range"));
21511               break;
21512             }
21513           newval &= ~0xff;
21514           newval |= value;
21515         }
21516       else
21517         {
21518           /* Positive 12-bit or negative 8-bit offset.  */
21519           int limit;
21520           if (value >= 0)
21521             {
21522               newval |= (1 << 23);
21523               limit = 0xfff;
21524             }
21525           else
21526             {
21527               value = -value;
21528               limit = 0xff;
21529             }
21530           if (value > limit)
21531             {
21532               as_bad_where (fixP->fx_file, fixP->fx_line,
21533                             _("offset out of range"));
21534               break;
21535             }
21536           newval &= ~limit;
21537         }
21538
21539       newval |= value;
21540       md_number_to_chars (buf, (newval >> 16) & 0xffff, THUMB_SIZE);
21541       md_number_to_chars (buf + THUMB_SIZE, newval & 0xffff, THUMB_SIZE);
21542       break;
21543
21544     case BFD_RELOC_ARM_SHIFT_IMM:
21545       newval = md_chars_to_number (buf, INSN_SIZE);
21546       if (((unsigned long) value) > 32
21547           || (value == 32
21548               && (((newval & 0x60) == 0) || (newval & 0x60) == 0x60)))
21549         {
21550           as_bad_where (fixP->fx_file, fixP->fx_line,
21551                         _("shift expression is too large"));
21552           break;
21553         }
21554
21555       if (value == 0)
21556         /* Shifts of zero must be done as lsl.  */
21557         newval &= ~0x60;
21558       else if (value == 32)
21559         value = 0;
21560       newval &= 0xfffff07f;
21561       newval |= (value & 0x1f) << 7;
21562       md_number_to_chars (buf, newval, INSN_SIZE);
21563       break;
21564
21565     case BFD_RELOC_ARM_T32_IMMEDIATE:
21566     case BFD_RELOC_ARM_T32_ADD_IMM:
21567     case BFD_RELOC_ARM_T32_IMM12:
21568     case BFD_RELOC_ARM_T32_ADD_PC12:
21569       /* We claim that this fixup has been processed here,
21570          even if in fact we generate an error because we do
21571          not have a reloc for it, so tc_gen_reloc will reject it.  */
21572       fixP->fx_done = 1;
21573
21574       if (fixP->fx_addsy
21575           && ! S_IS_DEFINED (fixP->fx_addsy))
21576         {
21577           as_bad_where (fixP->fx_file, fixP->fx_line,
21578                         _("undefined symbol %s used as an immediate value"),
21579                         S_GET_NAME (fixP->fx_addsy));
21580           break;
21581         }
21582
21583       newval = md_chars_to_number (buf, THUMB_SIZE);
21584       newval <<= 16;
21585       newval |= md_chars_to_number (buf+2, THUMB_SIZE);
21586
21587       newimm = FAIL;
21588       if (fixP->fx_r_type == BFD_RELOC_ARM_T32_IMMEDIATE
21589           || fixP->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM)
21590         {
21591           newimm = encode_thumb32_immediate (value);
21592           if (newimm == (unsigned int) FAIL)
21593             newimm = thumb32_negate_data_op (&newval, value);
21594         }
21595       if (fixP->fx_r_type != BFD_RELOC_ARM_T32_IMMEDIATE
21596           && newimm == (unsigned int) FAIL)
21597         {
21598           /* Turn add/sum into addw/subw.  */
21599           if (fixP->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM)
21600             newval = (newval & 0xfeffffff) | 0x02000000;
21601           /* No flat 12-bit imm encoding for addsw/subsw.  */
21602           if ((newval & 0x00100000) == 0)
21603             {
21604               /* 12 bit immediate for addw/subw.  */
21605               if (value < 0)
21606                 {
21607                   value = -value;
21608                   newval ^= 0x00a00000;
21609                 }
21610               if (value > 0xfff)
21611                 newimm = (unsigned int) FAIL;
21612               else
21613                 newimm = value;
21614             }
21615         }
21616
21617       if (newimm == (unsigned int)FAIL)
21618         {
21619           as_bad_where (fixP->fx_file, fixP->fx_line,
21620                         _("invalid constant (%lx) after fixup"),
21621                         (unsigned long) value);
21622           break;
21623         }
21624
21625       newval |= (newimm & 0x800) << 15;
21626       newval |= (newimm & 0x700) << 4;
21627       newval |= (newimm & 0x0ff);
21628
21629       md_number_to_chars (buf,   (valueT) ((newval >> 16) & 0xffff), THUMB_SIZE);
21630       md_number_to_chars (buf+2, (valueT) (newval & 0xffff), THUMB_SIZE);
21631       break;
21632
21633     case BFD_RELOC_ARM_SMC:
21634       if (((unsigned long) value) > 0xffff)
21635         as_bad_where (fixP->fx_file, fixP->fx_line,
21636                       _("invalid smc expression"));
21637       newval = md_chars_to_number (buf, INSN_SIZE);
21638       newval |= (value & 0xf) | ((value & 0xfff0) << 4);
21639       md_number_to_chars (buf, newval, INSN_SIZE);
21640       break;
21641
21642     case BFD_RELOC_ARM_HVC:
21643       if (((unsigned long) value) > 0xffff)
21644         as_bad_where (fixP->fx_file, fixP->fx_line,
21645                       _("invalid hvc expression"));
21646       newval = md_chars_to_number (buf, INSN_SIZE);
21647       newval |= (value & 0xf) | ((value & 0xfff0) << 4);
21648       md_number_to_chars (buf, newval, INSN_SIZE);
21649       break;
21650
21651     case BFD_RELOC_ARM_SWI:
21652       if (fixP->tc_fix_data != 0)
21653         {
21654           if (((unsigned long) value) > 0xff)
21655             as_bad_where (fixP->fx_file, fixP->fx_line,
21656                           _("invalid swi expression"));
21657           newval = md_chars_to_number (buf, THUMB_SIZE);
21658           newval |= value;
21659           md_number_to_chars (buf, newval, THUMB_SIZE);
21660         }
21661       else
21662         {
21663           if (((unsigned long) value) > 0x00ffffff)
21664             as_bad_where (fixP->fx_file, fixP->fx_line,
21665                           _("invalid swi expression"));
21666           newval = md_chars_to_number (buf, INSN_SIZE);
21667           newval |= value;
21668           md_number_to_chars (buf, newval, INSN_SIZE);
21669         }
21670       break;
21671
21672     case BFD_RELOC_ARM_MULTI:
21673       if (((unsigned long) value) > 0xffff)
21674         as_bad_where (fixP->fx_file, fixP->fx_line,
21675                       _("invalid expression in load/store multiple"));
21676       newval = value | md_chars_to_number (buf, INSN_SIZE);
21677       md_number_to_chars (buf, newval, INSN_SIZE);
21678       break;
21679
21680 #ifdef OBJ_ELF
21681     case BFD_RELOC_ARM_PCREL_CALL:
21682
21683       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
21684           && fixP->fx_addsy
21685           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21686           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21687           && THUMB_IS_FUNC (fixP->fx_addsy))
21688         /* Flip the bl to blx. This is a simple flip
21689            bit here because we generate PCREL_CALL for
21690            unconditional bls.  */
21691         {
21692           newval = md_chars_to_number (buf, INSN_SIZE);
21693           newval = newval | 0x10000000;
21694           md_number_to_chars (buf, newval, INSN_SIZE);
21695           temp = 1;
21696           fixP->fx_done = 1;
21697         }
21698       else
21699         temp = 3;
21700       goto arm_branch_common;
21701
21702     case BFD_RELOC_ARM_PCREL_JUMP:
21703       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
21704           && fixP->fx_addsy
21705           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21706           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21707           && THUMB_IS_FUNC (fixP->fx_addsy))
21708         {
21709           /* This would map to a bl<cond>, b<cond>,
21710              b<always> to a Thumb function. We
21711              need to force a relocation for this particular
21712              case.  */
21713           newval = md_chars_to_number (buf, INSN_SIZE);
21714           fixP->fx_done = 0;
21715         }
21716
21717     case BFD_RELOC_ARM_PLT32:
21718 #endif
21719     case BFD_RELOC_ARM_PCREL_BRANCH:
21720       temp = 3;
21721       goto arm_branch_common;
21722
21723     case BFD_RELOC_ARM_PCREL_BLX:
21724
21725       temp = 1;
21726       if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
21727           && fixP->fx_addsy
21728           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21729           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21730           && ARM_IS_FUNC (fixP->fx_addsy))
21731         {
21732           /* Flip the blx to a bl and warn.  */
21733           const char *name = S_GET_NAME (fixP->fx_addsy);
21734           newval = 0xeb000000;
21735           as_warn_where (fixP->fx_file, fixP->fx_line,
21736                          _("blx to '%s' an ARM ISA state function changed to bl"),
21737                           name);
21738           md_number_to_chars (buf, newval, INSN_SIZE);
21739           temp = 3;
21740           fixP->fx_done = 1;
21741         }
21742
21743 #ifdef OBJ_ELF
21744        if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
21745          fixP->fx_r_type = BFD_RELOC_ARM_PCREL_CALL;
21746 #endif
21747
21748     arm_branch_common:
21749       /* We are going to store value (shifted right by two) in the
21750          instruction, in a 24 bit, signed field.  Bits 26 through 32 either
21751          all clear or all set and bit 0 must be clear.  For B/BL bit 1 must
21752          also be be clear.  */
21753       if (value & temp)
21754         as_bad_where (fixP->fx_file, fixP->fx_line,
21755                       _("misaligned branch destination"));
21756       if ((value & (offsetT)0xfe000000) != (offsetT)0
21757           && (value & (offsetT)0xfe000000) != (offsetT)0xfe000000)
21758         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21759
21760       if (fixP->fx_done || !seg->use_rela_p)
21761         {
21762           newval = md_chars_to_number (buf, INSN_SIZE);
21763           newval |= (value >> 2) & 0x00ffffff;
21764           /* Set the H bit on BLX instructions.  */
21765           if (temp == 1)
21766             {
21767               if (value & 2)
21768                 newval |= 0x01000000;
21769               else
21770                 newval &= ~0x01000000;
21771             }
21772           md_number_to_chars (buf, newval, INSN_SIZE);
21773         }
21774       break;
21775
21776     case BFD_RELOC_THUMB_PCREL_BRANCH7: /* CBZ */
21777       /* CBZ can only branch forward.  */
21778
21779       /* Attempts to use CBZ to branch to the next instruction
21780          (which, strictly speaking, are prohibited) will be turned into
21781          no-ops.
21782
21783          FIXME: It may be better to remove the instruction completely and
21784          perform relaxation.  */
21785       if (value == -2)
21786         {
21787           newval = md_chars_to_number (buf, THUMB_SIZE);
21788           newval = 0xbf00; /* NOP encoding T1 */
21789           md_number_to_chars (buf, newval, THUMB_SIZE);
21790         }
21791       else
21792         {
21793           if (value & ~0x7e)
21794             as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21795
21796           if (fixP->fx_done || !seg->use_rela_p)
21797             {
21798               newval = md_chars_to_number (buf, THUMB_SIZE);
21799               newval |= ((value & 0x3e) << 2) | ((value & 0x40) << 3);
21800               md_number_to_chars (buf, newval, THUMB_SIZE);
21801             }
21802         }
21803       break;
21804
21805     case BFD_RELOC_THUMB_PCREL_BRANCH9: /* Conditional branch.  */
21806       if ((value & ~0xff) && ((value & ~0xff) != ~0xff))
21807         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21808
21809       if (fixP->fx_done || !seg->use_rela_p)
21810         {
21811           newval = md_chars_to_number (buf, THUMB_SIZE);
21812           newval |= (value & 0x1ff) >> 1;
21813           md_number_to_chars (buf, newval, THUMB_SIZE);
21814         }
21815       break;
21816
21817     case BFD_RELOC_THUMB_PCREL_BRANCH12: /* Unconditional branch.  */
21818       if ((value & ~0x7ff) && ((value & ~0x7ff) != ~0x7ff))
21819         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21820
21821       if (fixP->fx_done || !seg->use_rela_p)
21822         {
21823           newval = md_chars_to_number (buf, THUMB_SIZE);
21824           newval |= (value & 0xfff) >> 1;
21825           md_number_to_chars (buf, newval, THUMB_SIZE);
21826         }
21827       break;
21828
21829     case BFD_RELOC_THUMB_PCREL_BRANCH20:
21830       if (fixP->fx_addsy
21831           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21832           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21833           && ARM_IS_FUNC (fixP->fx_addsy)
21834           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
21835         {
21836           /* Force a relocation for a branch 20 bits wide.  */
21837           fixP->fx_done = 0;
21838         }
21839       if ((value & ~0x1fffff) && ((value & ~0x0fffff) != ~0x0fffff))
21840         as_bad_where (fixP->fx_file, fixP->fx_line,
21841                       _("conditional branch out of range"));
21842
21843       if (fixP->fx_done || !seg->use_rela_p)
21844         {
21845           offsetT newval2;
21846           addressT S, J1, J2, lo, hi;
21847
21848           S  = (value & 0x00100000) >> 20;
21849           J2 = (value & 0x00080000) >> 19;
21850           J1 = (value & 0x00040000) >> 18;
21851           hi = (value & 0x0003f000) >> 12;
21852           lo = (value & 0x00000ffe) >> 1;
21853
21854           newval   = md_chars_to_number (buf, THUMB_SIZE);
21855           newval2  = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
21856           newval  |= (S << 10) | hi;
21857           newval2 |= (J1 << 13) | (J2 << 11) | lo;
21858           md_number_to_chars (buf, newval, THUMB_SIZE);
21859           md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
21860         }
21861       break;
21862
21863     case BFD_RELOC_THUMB_PCREL_BLX:
21864       /* If there is a blx from a thumb state function to
21865          another thumb function flip this to a bl and warn
21866          about it.  */
21867
21868       if (fixP->fx_addsy
21869           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21870           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21871           && THUMB_IS_FUNC (fixP->fx_addsy))
21872         {
21873           const char *name = S_GET_NAME (fixP->fx_addsy);
21874           as_warn_where (fixP->fx_file, fixP->fx_line,
21875                          _("blx to Thumb func '%s' from Thumb ISA state changed to bl"),
21876                          name);
21877           newval = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
21878           newval = newval | 0x1000;
21879           md_number_to_chars (buf+THUMB_SIZE, newval, THUMB_SIZE);
21880           fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BRANCH23;
21881           fixP->fx_done = 1;
21882         }
21883
21884
21885       goto thumb_bl_common;
21886
21887     case BFD_RELOC_THUMB_PCREL_BRANCH23:
21888       /* A bl from Thumb state ISA to an internal ARM state function
21889          is converted to a blx.  */
21890       if (fixP->fx_addsy
21891           && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21892           && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21893           && ARM_IS_FUNC (fixP->fx_addsy)
21894           && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
21895         {
21896           newval = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
21897           newval = newval & ~0x1000;
21898           md_number_to_chars (buf+THUMB_SIZE, newval, THUMB_SIZE);
21899           fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BLX;
21900           fixP->fx_done = 1;
21901         }
21902
21903     thumb_bl_common:
21904
21905 #ifdef OBJ_ELF
21906        if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4
21907            && fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX)
21908          fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BRANCH23;
21909 #endif
21910
21911       if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX)
21912         /* For a BLX instruction, make sure that the relocation is rounded up
21913            to a word boundary.  This follows the semantics of the instruction
21914            which specifies that bit 1 of the target address will come from bit
21915            1 of the base address.  */
21916         value = (value + 1) & ~ 1;
21917
21918       if ((value & ~0x3fffff) && ((value & ~0x3fffff) != ~0x3fffff))
21919         {
21920           if (!(ARM_CPU_HAS_FEATURE (cpu_variant, arm_arch_t2)))
21921             as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21922           else if ((value & ~0x1ffffff)
21923                    && ((value & ~0x1ffffff) != ~0x1ffffff))
21924             as_bad_where (fixP->fx_file, fixP->fx_line,
21925                           _("Thumb2 branch out of range"));
21926         }
21927
21928       if (fixP->fx_done || !seg->use_rela_p)
21929         encode_thumb2_b_bl_offset (buf, value);
21930
21931       break;
21932
21933     case BFD_RELOC_THUMB_PCREL_BRANCH25:
21934       if ((value & ~0x0ffffff) && ((value & ~0x0ffffff) != ~0x0ffffff))
21935         as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
21936
21937       if (fixP->fx_done || !seg->use_rela_p)
21938           encode_thumb2_b_bl_offset (buf, value);
21939
21940       break;
21941
21942     case BFD_RELOC_8:
21943       if (fixP->fx_done || !seg->use_rela_p)
21944         md_number_to_chars (buf, value, 1);
21945       break;
21946
21947     case BFD_RELOC_16:
21948       if (fixP->fx_done || !seg->use_rela_p)
21949         md_number_to_chars (buf, value, 2);
21950       break;
21951
21952 #ifdef OBJ_ELF
21953     case BFD_RELOC_ARM_TLS_CALL:
21954     case BFD_RELOC_ARM_THM_TLS_CALL:
21955     case BFD_RELOC_ARM_TLS_DESCSEQ:
21956     case BFD_RELOC_ARM_THM_TLS_DESCSEQ:
21957       S_SET_THREAD_LOCAL (fixP->fx_addsy);
21958       break;
21959
21960     case BFD_RELOC_ARM_TLS_GOTDESC:
21961     case BFD_RELOC_ARM_TLS_GD32:
21962     case BFD_RELOC_ARM_TLS_LE32:
21963     case BFD_RELOC_ARM_TLS_IE32:
21964     case BFD_RELOC_ARM_TLS_LDM32:
21965     case BFD_RELOC_ARM_TLS_LDO32:
21966       S_SET_THREAD_LOCAL (fixP->fx_addsy);
21967       /* fall through */
21968
21969     case BFD_RELOC_ARM_GOT32:
21970     case BFD_RELOC_ARM_GOTOFF:
21971       if (fixP->fx_done || !seg->use_rela_p)
21972         md_number_to_chars (buf, 0, 4);
21973       break;
21974
21975     case BFD_RELOC_ARM_GOT_PREL:
21976       if (fixP->fx_done || !seg->use_rela_p)
21977         md_number_to_chars (buf, value, 4);
21978       break;
21979
21980     case BFD_RELOC_ARM_TARGET2:
21981       /* TARGET2 is not partial-inplace, so we need to write the
21982          addend here for REL targets, because it won't be written out
21983          during reloc processing later.  */
21984       if (fixP->fx_done || !seg->use_rela_p)
21985         md_number_to_chars (buf, fixP->fx_offset, 4);
21986       break;
21987 #endif
21988
21989     case BFD_RELOC_RVA:
21990     case BFD_RELOC_32:
21991     case BFD_RELOC_ARM_TARGET1:
21992     case BFD_RELOC_ARM_ROSEGREL32:
21993     case BFD_RELOC_ARM_SBREL32:
21994     case BFD_RELOC_32_PCREL:
21995 #ifdef TE_PE
21996     case BFD_RELOC_32_SECREL:
21997 #endif
21998       if (fixP->fx_done || !seg->use_rela_p)
21999 #ifdef TE_WINCE
22000         /* For WinCE we only do this for pcrel fixups.  */
22001         if (fixP->fx_done || fixP->fx_pcrel)
22002 #endif
22003           md_number_to_chars (buf, value, 4);
22004       break;
22005
22006 #ifdef OBJ_ELF
22007     case BFD_RELOC_ARM_PREL31:
22008       if (fixP->fx_done || !seg->use_rela_p)
22009         {
22010           newval = md_chars_to_number (buf, 4) & 0x80000000;
22011           if ((value ^ (value >> 1)) & 0x40000000)
22012             {
22013               as_bad_where (fixP->fx_file, fixP->fx_line,
22014                             _("rel31 relocation overflow"));
22015             }
22016           newval |= value & 0x7fffffff;
22017           md_number_to_chars (buf, newval, 4);
22018         }
22019       break;
22020 #endif
22021
22022     case BFD_RELOC_ARM_CP_OFF_IMM:
22023     case BFD_RELOC_ARM_T32_CP_OFF_IMM:
22024       if (value < -1023 || value > 1023 || (value & 3))
22025         as_bad_where (fixP->fx_file, fixP->fx_line,
22026                       _("co-processor offset out of range"));
22027     cp_off_common:
22028       sign = value > 0;
22029       if (value < 0)
22030         value = -value;
22031       if (fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
22032           || fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2)
22033         newval = md_chars_to_number (buf, INSN_SIZE);
22034       else
22035         newval = get_thumb32_insn (buf);
22036       if (value == 0)
22037         newval &= 0xffffff00;
22038       else
22039         {
22040           newval &= 0xff7fff00;
22041           newval |= (value >> 2) | (sign ? INDEX_UP : 0);
22042         }
22043       if (fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
22044           || fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2)
22045         md_number_to_chars (buf, newval, INSN_SIZE);
22046       else
22047         put_thumb32_insn (buf, newval);
22048       break;
22049
22050     case BFD_RELOC_ARM_CP_OFF_IMM_S2:
22051     case BFD_RELOC_ARM_T32_CP_OFF_IMM_S2:
22052       if (value < -255 || value > 255)
22053         as_bad_where (fixP->fx_file, fixP->fx_line,
22054                       _("co-processor offset out of range"));
22055       value *= 4;
22056       goto cp_off_common;
22057
22058     case BFD_RELOC_ARM_THUMB_OFFSET:
22059       newval = md_chars_to_number (buf, THUMB_SIZE);
22060       /* Exactly what ranges, and where the offset is inserted depends
22061          on the type of instruction, we can establish this from the
22062          top 4 bits.  */
22063       switch (newval >> 12)
22064         {
22065         case 4: /* PC load.  */
22066           /* Thumb PC loads are somewhat odd, bit 1 of the PC is
22067              forced to zero for these loads; md_pcrel_from has already
22068              compensated for this.  */
22069           if (value & 3)
22070             as_bad_where (fixP->fx_file, fixP->fx_line,
22071                           _("invalid offset, target not word aligned (0x%08lX)"),
22072                           (((unsigned long) fixP->fx_frag->fr_address
22073                             + (unsigned long) fixP->fx_where) & ~3)
22074                           + (unsigned long) value);
22075
22076           if (value & ~0x3fc)
22077             as_bad_where (fixP->fx_file, fixP->fx_line,
22078                           _("invalid offset, value too big (0x%08lX)"),
22079                           (long) value);
22080
22081           newval |= value >> 2;
22082           break;
22083
22084         case 9: /* SP load/store.  */
22085           if (value & ~0x3fc)
22086             as_bad_where (fixP->fx_file, fixP->fx_line,
22087                           _("invalid offset, value too big (0x%08lX)"),
22088                           (long) value);
22089           newval |= value >> 2;
22090           break;
22091
22092         case 6: /* Word load/store.  */
22093           if (value & ~0x7c)
22094             as_bad_where (fixP->fx_file, fixP->fx_line,
22095                           _("invalid offset, value too big (0x%08lX)"),
22096                           (long) value);
22097           newval |= value << 4; /* 6 - 2.  */
22098           break;
22099
22100         case 7: /* Byte load/store.  */
22101           if (value & ~0x1f)
22102             as_bad_where (fixP->fx_file, fixP->fx_line,
22103                           _("invalid offset, value too big (0x%08lX)"),
22104                           (long) value);
22105           newval |= value << 6;
22106           break;
22107
22108         case 8: /* Halfword load/store.  */
22109           if (value & ~0x3e)
22110             as_bad_where (fixP->fx_file, fixP->fx_line,
22111                           _("invalid offset, value too big (0x%08lX)"),
22112                           (long) value);
22113           newval |= value << 5; /* 6 - 1.  */
22114           break;
22115
22116         default:
22117           as_bad_where (fixP->fx_file, fixP->fx_line,
22118                         "Unable to process relocation for thumb opcode: %lx",
22119                         (unsigned long) newval);
22120           break;
22121         }
22122       md_number_to_chars (buf, newval, THUMB_SIZE);
22123       break;
22124
22125     case BFD_RELOC_ARM_THUMB_ADD:
22126       /* This is a complicated relocation, since we use it for all of
22127          the following immediate relocations:
22128
22129             3bit ADD/SUB
22130             8bit ADD/SUB
22131             9bit ADD/SUB SP word-aligned
22132            10bit ADD PC/SP word-aligned
22133
22134          The type of instruction being processed is encoded in the
22135          instruction field:
22136
22137            0x8000  SUB
22138            0x00F0  Rd
22139            0x000F  Rs
22140       */
22141       newval = md_chars_to_number (buf, THUMB_SIZE);
22142       {
22143         int rd = (newval >> 4) & 0xf;
22144         int rs = newval & 0xf;
22145         int subtract = !!(newval & 0x8000);
22146
22147         /* Check for HI regs, only very restricted cases allowed:
22148            Adjusting SP, and using PC or SP to get an address.  */
22149         if ((rd > 7 && (rd != REG_SP || rs != REG_SP))
22150             || (rs > 7 && rs != REG_SP && rs != REG_PC))
22151           as_bad_where (fixP->fx_file, fixP->fx_line,
22152                         _("invalid Hi register with immediate"));
22153
22154         /* If value is negative, choose the opposite instruction.  */
22155         if (value < 0)
22156           {
22157             value = -value;
22158             subtract = !subtract;
22159             if (value < 0)
22160               as_bad_where (fixP->fx_file, fixP->fx_line,
22161                             _("immediate value out of range"));
22162           }
22163
22164         if (rd == REG_SP)
22165           {
22166             if (value & ~0x1fc)
22167               as_bad_where (fixP->fx_file, fixP->fx_line,
22168                             _("invalid immediate for stack address calculation"));
22169             newval = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
22170             newval |= value >> 2;
22171           }
22172         else if (rs == REG_PC || rs == REG_SP)
22173           {
22174             if (subtract || value & ~0x3fc)
22175               as_bad_where (fixP->fx_file, fixP->fx_line,
22176                             _("invalid immediate for address calculation (value = 0x%08lX)"),
22177                             (unsigned long) value);
22178             newval = (rs == REG_PC ? T_OPCODE_ADD_PC : T_OPCODE_ADD_SP);
22179             newval |= rd << 8;
22180             newval |= value >> 2;
22181           }
22182         else if (rs == rd)
22183           {
22184             if (value & ~0xff)
22185               as_bad_where (fixP->fx_file, fixP->fx_line,
22186                             _("immediate value out of range"));
22187             newval = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
22188             newval |= (rd << 8) | value;
22189           }
22190         else
22191           {
22192             if (value & ~0x7)
22193               as_bad_where (fixP->fx_file, fixP->fx_line,
22194                             _("immediate value out of range"));
22195             newval = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
22196             newval |= rd | (rs << 3) | (value << 6);
22197           }
22198       }
22199       md_number_to_chars (buf, newval, THUMB_SIZE);
22200       break;
22201
22202     case BFD_RELOC_ARM_THUMB_IMM:
22203       newval = md_chars_to_number (buf, THUMB_SIZE);
22204       if (value < 0 || value > 255)
22205         as_bad_where (fixP->fx_file, fixP->fx_line,
22206                       _("invalid immediate: %ld is out of range"),
22207                       (long) value);
22208       newval |= value;
22209       md_number_to_chars (buf, newval, THUMB_SIZE);
22210       break;
22211
22212     case BFD_RELOC_ARM_THUMB_SHIFT:
22213       /* 5bit shift value (0..32).  LSL cannot take 32.  */
22214       newval = md_chars_to_number (buf, THUMB_SIZE) & 0xf83f;
22215       temp = newval & 0xf800;
22216       if (value < 0 || value > 32 || (value == 32 && temp == T_OPCODE_LSL_I))
22217         as_bad_where (fixP->fx_file, fixP->fx_line,
22218                       _("invalid shift value: %ld"), (long) value);
22219       /* Shifts of zero must be encoded as LSL.  */
22220       if (value == 0)
22221         newval = (newval & 0x003f) | T_OPCODE_LSL_I;
22222       /* Shifts of 32 are encoded as zero.  */
22223       else if (value == 32)
22224         value = 0;
22225       newval |= value << 6;
22226       md_number_to_chars (buf, newval, THUMB_SIZE);
22227       break;
22228
22229     case BFD_RELOC_VTABLE_INHERIT:
22230     case BFD_RELOC_VTABLE_ENTRY:
22231       fixP->fx_done = 0;
22232       return;
22233
22234     case BFD_RELOC_ARM_MOVW:
22235     case BFD_RELOC_ARM_MOVT:
22236     case BFD_RELOC_ARM_THUMB_MOVW:
22237     case BFD_RELOC_ARM_THUMB_MOVT:
22238       if (fixP->fx_done || !seg->use_rela_p)
22239         {
22240           /* REL format relocations are limited to a 16-bit addend.  */
22241           if (!fixP->fx_done)
22242             {
22243               if (value < -0x8000 || value > 0x7fff)
22244                   as_bad_where (fixP->fx_file, fixP->fx_line,
22245                                 _("offset out of range"));
22246             }
22247           else if (fixP->fx_r_type == BFD_RELOC_ARM_MOVT
22248                    || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT)
22249             {
22250               value >>= 16;
22251             }
22252
22253           if (fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW
22254               || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT)
22255             {
22256               newval = get_thumb32_insn (buf);
22257               newval &= 0xfbf08f00;
22258               newval |= (value & 0xf000) << 4;
22259               newval |= (value & 0x0800) << 15;
22260               newval |= (value & 0x0700) << 4;
22261               newval |= (value & 0x00ff);
22262               put_thumb32_insn (buf, newval);
22263             }
22264           else
22265             {
22266               newval = md_chars_to_number (buf, 4);
22267               newval &= 0xfff0f000;
22268               newval |= value & 0x0fff;
22269               newval |= (value & 0xf000) << 4;
22270               md_number_to_chars (buf, newval, 4);
22271             }
22272         }
22273       return;
22274
22275    case BFD_RELOC_ARM_ALU_PC_G0_NC:
22276    case BFD_RELOC_ARM_ALU_PC_G0:
22277    case BFD_RELOC_ARM_ALU_PC_G1_NC:
22278    case BFD_RELOC_ARM_ALU_PC_G1:
22279    case BFD_RELOC_ARM_ALU_PC_G2:
22280    case BFD_RELOC_ARM_ALU_SB_G0_NC:
22281    case BFD_RELOC_ARM_ALU_SB_G0:
22282    case BFD_RELOC_ARM_ALU_SB_G1_NC:
22283    case BFD_RELOC_ARM_ALU_SB_G1:
22284    case BFD_RELOC_ARM_ALU_SB_G2:
22285      gas_assert (!fixP->fx_done);
22286      if (!seg->use_rela_p)
22287        {
22288          bfd_vma insn;
22289          bfd_vma encoded_addend;
22290          bfd_vma addend_abs = abs (value);
22291
22292          /* Check that the absolute value of the addend can be
22293             expressed as an 8-bit constant plus a rotation.  */
22294          encoded_addend = encode_arm_immediate (addend_abs);
22295          if (encoded_addend == (unsigned int) FAIL)
22296            as_bad_where (fixP->fx_file, fixP->fx_line,
22297                          _("the offset 0x%08lX is not representable"),
22298                          (unsigned long) addend_abs);
22299
22300          /* Extract the instruction.  */
22301          insn = md_chars_to_number (buf, INSN_SIZE);
22302
22303          /* If the addend is positive, use an ADD instruction.
22304             Otherwise use a SUB.  Take care not to destroy the S bit.  */
22305          insn &= 0xff1fffff;
22306          if (value < 0)
22307            insn |= 1 << 22;
22308          else
22309            insn |= 1 << 23;
22310
22311          /* Place the encoded addend into the first 12 bits of the
22312             instruction.  */
22313          insn &= 0xfffff000;
22314          insn |= encoded_addend;
22315
22316          /* Update the instruction.  */
22317          md_number_to_chars (buf, insn, INSN_SIZE);
22318        }
22319      break;
22320
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_LDR_SB_G0:
22325     case BFD_RELOC_ARM_LDR_SB_G1:
22326     case BFD_RELOC_ARM_LDR_SB_G2:
22327       gas_assert (!fixP->fx_done);
22328       if (!seg->use_rela_p)
22329         {
22330           bfd_vma insn;
22331           bfd_vma addend_abs = abs (value);
22332
22333           /* Check that the absolute value of the addend can be
22334              encoded in 12 bits.  */
22335           if (addend_abs >= 0x1000)
22336             as_bad_where (fixP->fx_file, fixP->fx_line,
22337                           _("bad offset 0x%08lX (only 12 bits available for the magnitude)"),
22338                           (unsigned long) addend_abs);
22339
22340           /* Extract the instruction.  */
22341           insn = md_chars_to_number (buf, INSN_SIZE);
22342
22343           /* If the addend is negative, clear bit 23 of the instruction.
22344              Otherwise set it.  */
22345           if (value < 0)
22346             insn &= ~(1 << 23);
22347           else
22348             insn |= 1 << 23;
22349
22350           /* Place the absolute value of the addend into the first 12 bits
22351              of the instruction.  */
22352           insn &= 0xfffff000;
22353           insn |= addend_abs;
22354
22355           /* Update the instruction.  */
22356           md_number_to_chars (buf, insn, INSN_SIZE);
22357         }
22358       break;
22359
22360     case BFD_RELOC_ARM_LDRS_PC_G0:
22361     case BFD_RELOC_ARM_LDRS_PC_G1:
22362     case BFD_RELOC_ARM_LDRS_PC_G2:
22363     case BFD_RELOC_ARM_LDRS_SB_G0:
22364     case BFD_RELOC_ARM_LDRS_SB_G1:
22365     case BFD_RELOC_ARM_LDRS_SB_G2:
22366       gas_assert (!fixP->fx_done);
22367       if (!seg->use_rela_p)
22368         {
22369           bfd_vma insn;
22370           bfd_vma addend_abs = abs (value);
22371
22372           /* Check that the absolute value of the addend can be
22373              encoded in 8 bits.  */
22374           if (addend_abs >= 0x100)
22375             as_bad_where (fixP->fx_file, fixP->fx_line,
22376                           _("bad offset 0x%08lX (only 8 bits available for the magnitude)"),
22377                           (unsigned long) addend_abs);
22378
22379           /* Extract the instruction.  */
22380           insn = md_chars_to_number (buf, INSN_SIZE);
22381
22382           /* If the addend is negative, clear bit 23 of the instruction.
22383              Otherwise set it.  */
22384           if (value < 0)
22385             insn &= ~(1 << 23);
22386           else
22387             insn |= 1 << 23;
22388
22389           /* Place the first four bits of the absolute value of the addend
22390              into the first 4 bits of the instruction, and the remaining
22391              four into bits 8 .. 11.  */
22392           insn &= 0xfffff0f0;
22393           insn |= (addend_abs & 0xf) | ((addend_abs & 0xf0) << 4);
22394
22395           /* Update the instruction.  */
22396           md_number_to_chars (buf, insn, INSN_SIZE);
22397         }
22398       break;
22399
22400     case BFD_RELOC_ARM_LDC_PC_G0:
22401     case BFD_RELOC_ARM_LDC_PC_G1:
22402     case BFD_RELOC_ARM_LDC_PC_G2:
22403     case BFD_RELOC_ARM_LDC_SB_G0:
22404     case BFD_RELOC_ARM_LDC_SB_G1:
22405     case BFD_RELOC_ARM_LDC_SB_G2:
22406       gas_assert (!fixP->fx_done);
22407       if (!seg->use_rela_p)
22408         {
22409           bfd_vma insn;
22410           bfd_vma addend_abs = abs (value);
22411
22412           /* Check that the absolute value of the addend is a multiple of
22413              four and, when divided by four, fits in 8 bits.  */
22414           if (addend_abs & 0x3)
22415             as_bad_where (fixP->fx_file, fixP->fx_line,
22416                           _("bad offset 0x%08lX (must be word-aligned)"),
22417                           (unsigned long) addend_abs);
22418
22419           if ((addend_abs >> 2) > 0xff)
22420             as_bad_where (fixP->fx_file, fixP->fx_line,
22421                           _("bad offset 0x%08lX (must be an 8-bit number of words)"),
22422                           (unsigned long) addend_abs);
22423
22424           /* Extract the instruction.  */
22425           insn = md_chars_to_number (buf, INSN_SIZE);
22426
22427           /* If the addend is negative, clear bit 23 of the instruction.
22428              Otherwise set it.  */
22429           if (value < 0)
22430             insn &= ~(1 << 23);
22431           else
22432             insn |= 1 << 23;
22433
22434           /* Place the addend (divided by four) into the first eight
22435              bits of the instruction.  */
22436           insn &= 0xfffffff0;
22437           insn |= addend_abs >> 2;
22438
22439           /* Update the instruction.  */
22440           md_number_to_chars (buf, insn, INSN_SIZE);
22441         }
22442       break;
22443
22444     case BFD_RELOC_ARM_V4BX:
22445       /* This will need to go in the object file.  */
22446       fixP->fx_done = 0;
22447       break;
22448
22449     case BFD_RELOC_UNUSED:
22450     default:
22451       as_bad_where (fixP->fx_file, fixP->fx_line,
22452                     _("bad relocation fixup type (%d)"), fixP->fx_r_type);
22453     }
22454 }
22455
22456 /* Translate internal representation of relocation info to BFD target
22457    format.  */
22458
22459 arelent *
22460 tc_gen_reloc (asection *section, fixS *fixp)
22461 {
22462   arelent * reloc;
22463   bfd_reloc_code_real_type code;
22464
22465   reloc = (arelent *) xmalloc (sizeof (arelent));
22466
22467   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
22468   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
22469   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
22470
22471   if (fixp->fx_pcrel)
22472     {
22473       if (section->use_rela_p)
22474         fixp->fx_offset -= md_pcrel_from_section (fixp, section);
22475       else
22476         fixp->fx_offset = reloc->address;
22477     }
22478   reloc->addend = fixp->fx_offset;
22479
22480   switch (fixp->fx_r_type)
22481     {
22482     case BFD_RELOC_8:
22483       if (fixp->fx_pcrel)
22484         {
22485           code = BFD_RELOC_8_PCREL;
22486           break;
22487         }
22488
22489     case BFD_RELOC_16:
22490       if (fixp->fx_pcrel)
22491         {
22492           code = BFD_RELOC_16_PCREL;
22493           break;
22494         }
22495
22496     case BFD_RELOC_32:
22497       if (fixp->fx_pcrel)
22498         {
22499           code = BFD_RELOC_32_PCREL;
22500           break;
22501         }
22502
22503     case BFD_RELOC_ARM_MOVW:
22504       if (fixp->fx_pcrel)
22505         {
22506           code = BFD_RELOC_ARM_MOVW_PCREL;
22507           break;
22508         }
22509
22510     case BFD_RELOC_ARM_MOVT:
22511       if (fixp->fx_pcrel)
22512         {
22513           code = BFD_RELOC_ARM_MOVT_PCREL;
22514           break;
22515         }
22516
22517     case BFD_RELOC_ARM_THUMB_MOVW:
22518       if (fixp->fx_pcrel)
22519         {
22520           code = BFD_RELOC_ARM_THUMB_MOVW_PCREL;
22521           break;
22522         }
22523
22524     case BFD_RELOC_ARM_THUMB_MOVT:
22525       if (fixp->fx_pcrel)
22526         {
22527           code = BFD_RELOC_ARM_THUMB_MOVT_PCREL;
22528           break;
22529         }
22530
22531     case BFD_RELOC_NONE:
22532     case BFD_RELOC_ARM_PCREL_BRANCH:
22533     case BFD_RELOC_ARM_PCREL_BLX:
22534     case BFD_RELOC_RVA:
22535     case BFD_RELOC_THUMB_PCREL_BRANCH7:
22536     case BFD_RELOC_THUMB_PCREL_BRANCH9:
22537     case BFD_RELOC_THUMB_PCREL_BRANCH12:
22538     case BFD_RELOC_THUMB_PCREL_BRANCH20:
22539     case BFD_RELOC_THUMB_PCREL_BRANCH23:
22540     case BFD_RELOC_THUMB_PCREL_BRANCH25:
22541     case BFD_RELOC_VTABLE_ENTRY:
22542     case BFD_RELOC_VTABLE_INHERIT:
22543 #ifdef TE_PE
22544     case BFD_RELOC_32_SECREL:
22545 #endif
22546       code = fixp->fx_r_type;
22547       break;
22548
22549     case BFD_RELOC_THUMB_PCREL_BLX:
22550 #ifdef OBJ_ELF
22551       if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
22552         code = BFD_RELOC_THUMB_PCREL_BRANCH23;
22553       else
22554 #endif
22555         code = BFD_RELOC_THUMB_PCREL_BLX;
22556       break;
22557
22558     case BFD_RELOC_ARM_LITERAL:
22559     case BFD_RELOC_ARM_HWLITERAL:
22560       /* If this is called then the a literal has
22561          been referenced across a section boundary.  */
22562       as_bad_where (fixp->fx_file, fixp->fx_line,
22563                     _("literal referenced across section boundary"));
22564       return NULL;
22565
22566 #ifdef OBJ_ELF
22567     case BFD_RELOC_ARM_TLS_CALL:
22568     case BFD_RELOC_ARM_THM_TLS_CALL:
22569     case BFD_RELOC_ARM_TLS_DESCSEQ:
22570     case BFD_RELOC_ARM_THM_TLS_DESCSEQ:
22571     case BFD_RELOC_ARM_GOT32:
22572     case BFD_RELOC_ARM_GOTOFF:
22573     case BFD_RELOC_ARM_GOT_PREL:
22574     case BFD_RELOC_ARM_PLT32:
22575     case BFD_RELOC_ARM_TARGET1:
22576     case BFD_RELOC_ARM_ROSEGREL32:
22577     case BFD_RELOC_ARM_SBREL32:
22578     case BFD_RELOC_ARM_PREL31:
22579     case BFD_RELOC_ARM_TARGET2:
22580     case BFD_RELOC_ARM_TLS_LE32:
22581     case BFD_RELOC_ARM_TLS_LDO32:
22582     case BFD_RELOC_ARM_PCREL_CALL:
22583     case BFD_RELOC_ARM_PCREL_JUMP:
22584     case BFD_RELOC_ARM_ALU_PC_G0_NC:
22585     case BFD_RELOC_ARM_ALU_PC_G0:
22586     case BFD_RELOC_ARM_ALU_PC_G1_NC:
22587     case BFD_RELOC_ARM_ALU_PC_G1:
22588     case BFD_RELOC_ARM_ALU_PC_G2:
22589     case BFD_RELOC_ARM_LDR_PC_G0:
22590     case BFD_RELOC_ARM_LDR_PC_G1:
22591     case BFD_RELOC_ARM_LDR_PC_G2:
22592     case BFD_RELOC_ARM_LDRS_PC_G0:
22593     case BFD_RELOC_ARM_LDRS_PC_G1:
22594     case BFD_RELOC_ARM_LDRS_PC_G2:
22595     case BFD_RELOC_ARM_LDC_PC_G0:
22596     case BFD_RELOC_ARM_LDC_PC_G1:
22597     case BFD_RELOC_ARM_LDC_PC_G2:
22598     case BFD_RELOC_ARM_ALU_SB_G0_NC:
22599     case BFD_RELOC_ARM_ALU_SB_G0:
22600     case BFD_RELOC_ARM_ALU_SB_G1_NC:
22601     case BFD_RELOC_ARM_ALU_SB_G1:
22602     case BFD_RELOC_ARM_ALU_SB_G2:
22603     case BFD_RELOC_ARM_LDR_SB_G0:
22604     case BFD_RELOC_ARM_LDR_SB_G1:
22605     case BFD_RELOC_ARM_LDR_SB_G2:
22606     case BFD_RELOC_ARM_LDRS_SB_G0:
22607     case BFD_RELOC_ARM_LDRS_SB_G1:
22608     case BFD_RELOC_ARM_LDRS_SB_G2:
22609     case BFD_RELOC_ARM_LDC_SB_G0:
22610     case BFD_RELOC_ARM_LDC_SB_G1:
22611     case BFD_RELOC_ARM_LDC_SB_G2:
22612     case BFD_RELOC_ARM_V4BX:
22613       code = fixp->fx_r_type;
22614       break;
22615
22616     case BFD_RELOC_ARM_TLS_GOTDESC:
22617     case BFD_RELOC_ARM_TLS_GD32:
22618     case BFD_RELOC_ARM_TLS_IE32:
22619     case BFD_RELOC_ARM_TLS_LDM32:
22620       /* BFD will include the symbol's address in the addend.
22621          But we don't want that, so subtract it out again here.  */
22622       if (!S_IS_COMMON (fixp->fx_addsy))
22623         reloc->addend -= (*reloc->sym_ptr_ptr)->value;
22624       code = fixp->fx_r_type;
22625       break;
22626 #endif
22627
22628     case BFD_RELOC_ARM_IMMEDIATE:
22629       as_bad_where (fixp->fx_file, fixp->fx_line,
22630                     _("internal relocation (type: IMMEDIATE) not fixed up"));
22631       return NULL;
22632
22633     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
22634       as_bad_where (fixp->fx_file, fixp->fx_line,
22635                     _("ADRL used for a symbol not defined in the same file"));
22636       return NULL;
22637
22638     case BFD_RELOC_ARM_OFFSET_IMM:
22639       if (section->use_rela_p)
22640         {
22641           code = fixp->fx_r_type;
22642           break;
22643         }
22644
22645       if (fixp->fx_addsy != NULL
22646           && !S_IS_DEFINED (fixp->fx_addsy)
22647           && S_IS_LOCAL (fixp->fx_addsy))
22648         {
22649           as_bad_where (fixp->fx_file, fixp->fx_line,
22650                         _("undefined local label `%s'"),
22651                         S_GET_NAME (fixp->fx_addsy));
22652           return NULL;
22653         }
22654
22655       as_bad_where (fixp->fx_file, fixp->fx_line,
22656                     _("internal_relocation (type: OFFSET_IMM) not fixed up"));
22657       return NULL;
22658
22659     default:
22660       {
22661         char * type;
22662
22663         switch (fixp->fx_r_type)
22664           {
22665           case BFD_RELOC_NONE:             type = "NONE";         break;
22666           case BFD_RELOC_ARM_OFFSET_IMM8:  type = "OFFSET_IMM8";  break;
22667           case BFD_RELOC_ARM_SHIFT_IMM:    type = "SHIFT_IMM";    break;
22668           case BFD_RELOC_ARM_SMC:          type = "SMC";          break;
22669           case BFD_RELOC_ARM_SWI:          type = "SWI";          break;
22670           case BFD_RELOC_ARM_MULTI:        type = "MULTI";        break;
22671           case BFD_RELOC_ARM_CP_OFF_IMM:   type = "CP_OFF_IMM";   break;
22672           case BFD_RELOC_ARM_T32_OFFSET_IMM: type = "T32_OFFSET_IMM"; break;
22673           case BFD_RELOC_ARM_T32_CP_OFF_IMM: type = "T32_CP_OFF_IMM"; break;
22674           case BFD_RELOC_ARM_THUMB_ADD:    type = "THUMB_ADD";    break;
22675           case BFD_RELOC_ARM_THUMB_SHIFT:  type = "THUMB_SHIFT";  break;
22676           case BFD_RELOC_ARM_THUMB_IMM:    type = "THUMB_IMM";    break;
22677           case BFD_RELOC_ARM_THUMB_OFFSET: type = "THUMB_OFFSET"; break;
22678           default:                         type = _("<unknown>"); break;
22679           }
22680         as_bad_where (fixp->fx_file, fixp->fx_line,
22681                       _("cannot represent %s relocation in this object file format"),
22682                       type);
22683         return NULL;
22684       }
22685     }
22686
22687 #ifdef OBJ_ELF
22688   if ((code == BFD_RELOC_32_PCREL || code == BFD_RELOC_32)
22689       && GOT_symbol
22690       && fixp->fx_addsy == GOT_symbol)
22691     {
22692       code = BFD_RELOC_ARM_GOTPC;
22693       reloc->addend = fixp->fx_offset = reloc->address;
22694     }
22695 #endif
22696
22697   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
22698
22699   if (reloc->howto == NULL)
22700     {
22701       as_bad_where (fixp->fx_file, fixp->fx_line,
22702                     _("cannot represent %s relocation in this object file format"),
22703                     bfd_get_reloc_code_name (code));
22704       return NULL;
22705     }
22706
22707   /* HACK: Since arm ELF uses Rel instead of Rela, encode the
22708      vtable entry to be used in the relocation's section offset.  */
22709   if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
22710     reloc->address = fixp->fx_offset;
22711
22712   return reloc;
22713 }
22714
22715 /* This fix_new is called by cons via TC_CONS_FIX_NEW.  */
22716
22717 void
22718 cons_fix_new_arm (fragS *       frag,
22719                   int           where,
22720                   int           size,
22721                   expressionS * exp)
22722 {
22723   bfd_reloc_code_real_type type;
22724   int pcrel = 0;
22725
22726   /* Pick a reloc.
22727      FIXME: @@ Should look at CPU word size.  */
22728   switch (size)
22729     {
22730     case 1:
22731       type = BFD_RELOC_8;
22732       break;
22733     case 2:
22734       type = BFD_RELOC_16;
22735       break;
22736     case 4:
22737     default:
22738       type = BFD_RELOC_32;
22739       break;
22740     case 8:
22741       type = BFD_RELOC_64;
22742       break;
22743     }
22744
22745 #ifdef TE_PE
22746   if (exp->X_op == O_secrel)
22747   {
22748     exp->X_op = O_symbol;
22749     type = BFD_RELOC_32_SECREL;
22750   }
22751 #endif
22752
22753   fix_new_exp (frag, where, (int) size, exp, pcrel, type);
22754 }
22755
22756 #if defined (OBJ_COFF)
22757 void
22758 arm_validate_fix (fixS * fixP)
22759 {
22760   /* If the destination of the branch is a defined symbol which does not have
22761      the THUMB_FUNC attribute, then we must be calling a function which has
22762      the (interfacearm) attribute.  We look for the Thumb entry point to that
22763      function and change the branch to refer to that function instead.  */
22764   if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23
22765       && fixP->fx_addsy != NULL
22766       && S_IS_DEFINED (fixP->fx_addsy)
22767       && ! THUMB_IS_FUNC (fixP->fx_addsy))
22768     {
22769       fixP->fx_addsy = find_real_start (fixP->fx_addsy);
22770     }
22771 }
22772 #endif
22773
22774
22775 int
22776 arm_force_relocation (struct fix * fixp)
22777 {
22778 #if defined (OBJ_COFF) && defined (TE_PE)
22779   if (fixp->fx_r_type == BFD_RELOC_RVA)
22780     return 1;
22781 #endif
22782
22783   /* In case we have a call or a branch to a function in ARM ISA mode from
22784      a thumb function or vice-versa force the relocation. These relocations
22785      are cleared off for some cores that might have blx and simple transformations
22786      are possible.  */
22787
22788 #ifdef OBJ_ELF
22789   switch (fixp->fx_r_type)
22790     {
22791     case BFD_RELOC_ARM_PCREL_JUMP:
22792     case BFD_RELOC_ARM_PCREL_CALL:
22793     case BFD_RELOC_THUMB_PCREL_BLX:
22794       if (THUMB_IS_FUNC (fixp->fx_addsy))
22795         return 1;
22796       break;
22797
22798     case BFD_RELOC_ARM_PCREL_BLX:
22799     case BFD_RELOC_THUMB_PCREL_BRANCH25:
22800     case BFD_RELOC_THUMB_PCREL_BRANCH20:
22801     case BFD_RELOC_THUMB_PCREL_BRANCH23:
22802       if (ARM_IS_FUNC (fixp->fx_addsy))
22803         return 1;
22804       break;
22805
22806     default:
22807       break;
22808     }
22809 #endif
22810
22811   /* Resolve these relocations even if the symbol is extern or weak.
22812      Technically this is probably wrong due to symbol preemption.
22813      In practice these relocations do not have enough range to be useful
22814      at dynamic link time, and some code (e.g. in the Linux kernel)
22815      expects these references to be resolved.  */
22816   if (fixp->fx_r_type == BFD_RELOC_ARM_IMMEDIATE
22817       || fixp->fx_r_type == BFD_RELOC_ARM_OFFSET_IMM
22818       || fixp->fx_r_type == BFD_RELOC_ARM_OFFSET_IMM8
22819       || fixp->fx_r_type == BFD_RELOC_ARM_ADRL_IMMEDIATE
22820       || fixp->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
22821       || fixp->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2
22822       || fixp->fx_r_type == BFD_RELOC_ARM_THUMB_OFFSET
22823       || fixp->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM
22824       || fixp->fx_r_type == BFD_RELOC_ARM_T32_IMMEDIATE
22825       || fixp->fx_r_type == BFD_RELOC_ARM_T32_IMM12
22826       || fixp->fx_r_type == BFD_RELOC_ARM_T32_OFFSET_IMM
22827       || fixp->fx_r_type == BFD_RELOC_ARM_T32_ADD_PC12
22828       || fixp->fx_r_type == BFD_RELOC_ARM_T32_CP_OFF_IMM
22829       || fixp->fx_r_type == BFD_RELOC_ARM_T32_CP_OFF_IMM_S2)
22830     return 0;
22831
22832   /* Always leave these relocations for the linker.  */
22833   if ((fixp->fx_r_type >= BFD_RELOC_ARM_ALU_PC_G0_NC
22834        && fixp->fx_r_type <= BFD_RELOC_ARM_LDC_SB_G2)
22835       || fixp->fx_r_type == BFD_RELOC_ARM_LDR_PC_G0)
22836     return 1;
22837
22838   /* Always generate relocations against function symbols.  */
22839   if (fixp->fx_r_type == BFD_RELOC_32
22840       && fixp->fx_addsy
22841       && (symbol_get_bfdsym (fixp->fx_addsy)->flags & BSF_FUNCTION))
22842     return 1;
22843
22844   return generic_force_reloc (fixp);
22845 }
22846
22847 #if defined (OBJ_ELF) || defined (OBJ_COFF)
22848 /* Relocations against function names must be left unadjusted,
22849    so that the linker can use this information to generate interworking
22850    stubs.  The MIPS version of this function
22851    also prevents relocations that are mips-16 specific, but I do not
22852    know why it does this.
22853
22854    FIXME:
22855    There is one other problem that ought to be addressed here, but
22856    which currently is not:  Taking the address of a label (rather
22857    than a function) and then later jumping to that address.  Such
22858    addresses also ought to have their bottom bit set (assuming that
22859    they reside in Thumb code), but at the moment they will not.  */
22860
22861 bfd_boolean
22862 arm_fix_adjustable (fixS * fixP)
22863 {
22864   if (fixP->fx_addsy == NULL)
22865     return 1;
22866
22867   /* Preserve relocations against symbols with function type.  */
22868   if (symbol_get_bfdsym (fixP->fx_addsy)->flags & BSF_FUNCTION)
22869     return FALSE;
22870
22871   if (THUMB_IS_FUNC (fixP->fx_addsy)
22872       && fixP->fx_subsy == NULL)
22873     return FALSE;
22874
22875   /* We need the symbol name for the VTABLE entries.  */
22876   if (   fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
22877       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
22878     return FALSE;
22879
22880   /* Don't allow symbols to be discarded on GOT related relocs.  */
22881   if (fixP->fx_r_type == BFD_RELOC_ARM_PLT32
22882       || fixP->fx_r_type == BFD_RELOC_ARM_GOT32
22883       || fixP->fx_r_type == BFD_RELOC_ARM_GOTOFF
22884       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_GD32
22885       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LE32
22886       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_IE32
22887       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDM32
22888       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDO32
22889       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_GOTDESC
22890       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_CALL
22891       || fixP->fx_r_type == BFD_RELOC_ARM_THM_TLS_CALL
22892       || fixP->fx_r_type == BFD_RELOC_ARM_TLS_DESCSEQ
22893       || fixP->fx_r_type == BFD_RELOC_ARM_THM_TLS_DESCSEQ
22894       || fixP->fx_r_type == BFD_RELOC_ARM_TARGET2)
22895     return FALSE;
22896
22897   /* Similarly for group relocations.  */
22898   if ((fixP->fx_r_type >= BFD_RELOC_ARM_ALU_PC_G0_NC
22899        && fixP->fx_r_type <= BFD_RELOC_ARM_LDC_SB_G2)
22900       || fixP->fx_r_type == BFD_RELOC_ARM_LDR_PC_G0)
22901     return FALSE;
22902
22903   /* MOVW/MOVT REL relocations have limited offsets, so keep the symbols.  */
22904   if (fixP->fx_r_type == BFD_RELOC_ARM_MOVW
22905       || fixP->fx_r_type == BFD_RELOC_ARM_MOVT
22906       || fixP->fx_r_type == BFD_RELOC_ARM_MOVW_PCREL
22907       || fixP->fx_r_type == BFD_RELOC_ARM_MOVT_PCREL
22908       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW
22909       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT
22910       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW_PCREL
22911       || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT_PCREL)
22912     return FALSE;
22913
22914   return TRUE;
22915 }
22916 #endif /* defined (OBJ_ELF) || defined (OBJ_COFF) */
22917
22918 #ifdef OBJ_ELF
22919
22920 const char *
22921 elf32_arm_target_format (void)
22922 {
22923 #ifdef TE_SYMBIAN
22924   return (target_big_endian
22925           ? "elf32-bigarm-symbian"
22926           : "elf32-littlearm-symbian");
22927 #elif defined (TE_VXWORKS)
22928   return (target_big_endian
22929           ? "elf32-bigarm-vxworks"
22930           : "elf32-littlearm-vxworks");
22931 #elif defined (TE_NACL)
22932   return (target_big_endian
22933           ? "elf32-bigarm-nacl"
22934           : "elf32-littlearm-nacl");
22935 #else
22936   if (target_big_endian)
22937     return "elf32-bigarm";
22938   else
22939     return "elf32-littlearm";
22940 #endif
22941 }
22942
22943 void
22944 armelf_frob_symbol (symbolS * symp,
22945                     int *     puntp)
22946 {
22947   elf_frob_symbol (symp, puntp);
22948 }
22949 #endif
22950
22951 /* MD interface: Finalization.  */
22952
22953 void
22954 arm_cleanup (void)
22955 {
22956   literal_pool * pool;
22957
22958   /* Ensure that all the IT blocks are properly closed.  */
22959   check_it_blocks_finished ();
22960
22961   for (pool = list_of_pools; pool; pool = pool->next)
22962     {
22963       /* Put it at the end of the relevant section.  */
22964       subseg_set (pool->section, pool->sub_section);
22965 #ifdef OBJ_ELF
22966       arm_elf_change_section ();
22967 #endif
22968       s_ltorg (0);
22969     }
22970 }
22971
22972 #ifdef OBJ_ELF
22973 /* Remove any excess mapping symbols generated for alignment frags in
22974    SEC.  We may have created a mapping symbol before a zero byte
22975    alignment; remove it if there's a mapping symbol after the
22976    alignment.  */
22977 static void
22978 check_mapping_symbols (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
22979                        void *dummy ATTRIBUTE_UNUSED)
22980 {
22981   segment_info_type *seginfo = seg_info (sec);
22982   fragS *fragp;
22983
22984   if (seginfo == NULL || seginfo->frchainP == NULL)
22985     return;
22986
22987   for (fragp = seginfo->frchainP->frch_root;
22988        fragp != NULL;
22989        fragp = fragp->fr_next)
22990     {
22991       symbolS *sym = fragp->tc_frag_data.last_map;
22992       fragS *next = fragp->fr_next;
22993
22994       /* Variable-sized frags have been converted to fixed size by
22995          this point.  But if this was variable-sized to start with,
22996          there will be a fixed-size frag after it.  So don't handle
22997          next == NULL.  */
22998       if (sym == NULL || next == NULL)
22999         continue;
23000
23001       if (S_GET_VALUE (sym) < next->fr_address)
23002         /* Not at the end of this frag.  */
23003         continue;
23004       know (S_GET_VALUE (sym) == next->fr_address);
23005
23006       do
23007         {
23008           if (next->tc_frag_data.first_map != NULL)
23009             {
23010               /* Next frag starts with a mapping symbol.  Discard this
23011                  one.  */
23012               symbol_remove (sym, &symbol_rootP, &symbol_lastP);
23013               break;
23014             }
23015
23016           if (next->fr_next == NULL)
23017             {
23018               /* This mapping symbol is at the end of the section.  Discard
23019                  it.  */
23020               know (next->fr_fix == 0 && next->fr_var == 0);
23021               symbol_remove (sym, &symbol_rootP, &symbol_lastP);
23022               break;
23023             }
23024
23025           /* As long as we have empty frags without any mapping symbols,
23026              keep looking.  */
23027           /* If the next frag is non-empty and does not start with a
23028              mapping symbol, then this mapping symbol is required.  */
23029           if (next->fr_address != next->fr_next->fr_address)
23030             break;
23031
23032           next = next->fr_next;
23033         }
23034       while (next != NULL);
23035     }
23036 }
23037 #endif
23038
23039 /* Adjust the symbol table.  This marks Thumb symbols as distinct from
23040    ARM ones.  */
23041
23042 void
23043 arm_adjust_symtab (void)
23044 {
23045 #ifdef OBJ_COFF
23046   symbolS * sym;
23047
23048   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
23049     {
23050       if (ARM_IS_THUMB (sym))
23051         {
23052           if (THUMB_IS_FUNC (sym))
23053             {
23054               /* Mark the symbol as a Thumb function.  */
23055               if (   S_GET_STORAGE_CLASS (sym) == C_STAT
23056                   || S_GET_STORAGE_CLASS (sym) == C_LABEL)  /* This can happen!  */
23057                 S_SET_STORAGE_CLASS (sym, C_THUMBSTATFUNC);
23058
23059               else if (S_GET_STORAGE_CLASS (sym) == C_EXT)
23060                 S_SET_STORAGE_CLASS (sym, C_THUMBEXTFUNC);
23061               else
23062                 as_bad (_("%s: unexpected function type: %d"),
23063                         S_GET_NAME (sym), S_GET_STORAGE_CLASS (sym));
23064             }
23065           else switch (S_GET_STORAGE_CLASS (sym))
23066             {
23067             case C_EXT:
23068               S_SET_STORAGE_CLASS (sym, C_THUMBEXT);
23069               break;
23070             case C_STAT:
23071               S_SET_STORAGE_CLASS (sym, C_THUMBSTAT);
23072               break;
23073             case C_LABEL:
23074               S_SET_STORAGE_CLASS (sym, C_THUMBLABEL);
23075               break;
23076             default:
23077               /* Do nothing.  */
23078               break;
23079             }
23080         }
23081
23082       if (ARM_IS_INTERWORK (sym))
23083         coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_flags = 0xFF;
23084     }
23085 #endif
23086 #ifdef OBJ_ELF
23087   symbolS * sym;
23088   char      bind;
23089
23090   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
23091     {
23092       if (ARM_IS_THUMB (sym))
23093         {
23094           elf_symbol_type * elf_sym;
23095
23096           elf_sym = elf_symbol (symbol_get_bfdsym (sym));
23097           bind = ELF_ST_BIND (elf_sym->internal_elf_sym.st_info);
23098
23099           if (! bfd_is_arm_special_symbol_name (elf_sym->symbol.name,
23100                 BFD_ARM_SPECIAL_SYM_TYPE_ANY))
23101             {
23102               /* If it's a .thumb_func, declare it as so,
23103                  otherwise tag label as .code 16.  */
23104               if (THUMB_IS_FUNC (sym))
23105                 elf_sym->internal_elf_sym.st_target_internal
23106                   = ST_BRANCH_TO_THUMB;
23107               else if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
23108                 elf_sym->internal_elf_sym.st_info =
23109                   ELF_ST_INFO (bind, STT_ARM_16BIT);
23110             }
23111         }
23112     }
23113
23114   /* Remove any overlapping mapping symbols generated by alignment frags.  */
23115   bfd_map_over_sections (stdoutput, check_mapping_symbols, (char *) 0);
23116   /* Now do generic ELF adjustments.  */
23117   elf_adjust_symtab ();
23118 #endif
23119 }
23120
23121 /* MD interface: Initialization.  */
23122
23123 static void
23124 set_constant_flonums (void)
23125 {
23126   int i;
23127
23128   for (i = 0; i < NUM_FLOAT_VALS; i++)
23129     if (atof_ieee ((char *) fp_const[i], 'x', fp_values[i]) == NULL)
23130       abort ();
23131 }
23132
23133 /* Auto-select Thumb mode if it's the only available instruction set for the
23134    given architecture.  */
23135
23136 static void
23137 autoselect_thumb_from_cpu_variant (void)
23138 {
23139   if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
23140     opcode_select (16);
23141 }
23142
23143 void
23144 md_begin (void)
23145 {
23146   unsigned mach;
23147   unsigned int i;
23148
23149   if (   (arm_ops_hsh = hash_new ()) == NULL
23150       || (arm_cond_hsh = hash_new ()) == NULL
23151       || (arm_shift_hsh = hash_new ()) == NULL
23152       || (arm_psr_hsh = hash_new ()) == NULL
23153       || (arm_v7m_psr_hsh = hash_new ()) == NULL
23154       || (arm_reg_hsh = hash_new ()) == NULL
23155       || (arm_reloc_hsh = hash_new ()) == NULL
23156       || (arm_barrier_opt_hsh = hash_new ()) == NULL)
23157     as_fatal (_("virtual memory exhausted"));
23158
23159   for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++)
23160     hash_insert (arm_ops_hsh, insns[i].template_name, (void *) (insns + i));
23161   for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++)
23162     hash_insert (arm_cond_hsh, conds[i].template_name, (void *) (conds + i));
23163   for (i = 0; i < sizeof (shift_names) / sizeof (struct asm_shift_name); i++)
23164     hash_insert (arm_shift_hsh, shift_names[i].name, (void *) (shift_names + i));
23165   for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++)
23166     hash_insert (arm_psr_hsh, psrs[i].template_name, (void *) (psrs + i));
23167   for (i = 0; i < sizeof (v7m_psrs) / sizeof (struct asm_psr); i++)
23168     hash_insert (arm_v7m_psr_hsh, v7m_psrs[i].template_name,
23169                  (void *) (v7m_psrs + i));
23170   for (i = 0; i < sizeof (reg_names) / sizeof (struct reg_entry); i++)
23171     hash_insert (arm_reg_hsh, reg_names[i].name, (void *) (reg_names + i));
23172   for (i = 0;
23173        i < sizeof (barrier_opt_names) / sizeof (struct asm_barrier_opt);
23174        i++)
23175     hash_insert (arm_barrier_opt_hsh, barrier_opt_names[i].template_name,
23176                  (void *) (barrier_opt_names + i));
23177 #ifdef OBJ_ELF
23178   for (i = 0; i < ARRAY_SIZE (reloc_names); i++)
23179     {
23180       struct reloc_entry * entry = reloc_names + i;
23181
23182       if (arm_is_eabi() && entry->reloc == BFD_RELOC_ARM_PLT32)
23183         /* This makes encode_branch() use the EABI versions of this relocation.  */
23184         entry->reloc = BFD_RELOC_UNUSED;
23185
23186       hash_insert (arm_reloc_hsh, entry->name, (void *) entry);
23187     }
23188 #endif
23189
23190   set_constant_flonums ();
23191
23192   /* Set the cpu variant based on the command-line options.  We prefer
23193      -mcpu= over -march= if both are set (as for GCC); and we prefer
23194      -mfpu= over any other way of setting the floating point unit.
23195      Use of legacy options with new options are faulted.  */
23196   if (legacy_cpu)
23197     {
23198       if (mcpu_cpu_opt || march_cpu_opt)
23199         as_bad (_("use of old and new-style options to set CPU type"));
23200
23201       mcpu_cpu_opt = legacy_cpu;
23202     }
23203   else if (!mcpu_cpu_opt)
23204     mcpu_cpu_opt = march_cpu_opt;
23205
23206   if (legacy_fpu)
23207     {
23208       if (mfpu_opt)
23209         as_bad (_("use of old and new-style options to set FPU type"));
23210
23211       mfpu_opt = legacy_fpu;
23212     }
23213   else if (!mfpu_opt)
23214     {
23215 #if !(defined (EABI_DEFAULT) || defined (TE_LINUX) \
23216         || defined (TE_NetBSD) || defined (TE_VXWORKS))
23217       /* Some environments specify a default FPU.  If they don't, infer it
23218          from the processor.  */
23219       if (mcpu_fpu_opt)
23220         mfpu_opt = mcpu_fpu_opt;
23221       else
23222         mfpu_opt = march_fpu_opt;
23223 #else
23224       mfpu_opt = &fpu_default;
23225 #endif
23226     }
23227
23228   if (!mfpu_opt)
23229     {
23230       if (mcpu_cpu_opt != NULL)
23231         mfpu_opt = &fpu_default;
23232       else if (mcpu_fpu_opt != NULL && ARM_CPU_HAS_FEATURE (*mcpu_fpu_opt, arm_ext_v5))
23233         mfpu_opt = &fpu_arch_vfp_v2;
23234       else
23235         mfpu_opt = &fpu_arch_fpa;
23236     }
23237
23238 #ifdef CPU_DEFAULT
23239   if (!mcpu_cpu_opt)
23240     {
23241       mcpu_cpu_opt = &cpu_default;
23242       selected_cpu = cpu_default;
23243     }
23244 #else
23245   if (mcpu_cpu_opt)
23246     selected_cpu = *mcpu_cpu_opt;
23247   else
23248     mcpu_cpu_opt = &arm_arch_any;
23249 #endif
23250
23251   ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
23252
23253   autoselect_thumb_from_cpu_variant ();
23254
23255   arm_arch_used = thumb_arch_used = arm_arch_none;
23256
23257 #if defined OBJ_COFF || defined OBJ_ELF
23258   {
23259     unsigned int flags = 0;
23260
23261 #if defined OBJ_ELF
23262     flags = meabi_flags;
23263
23264     switch (meabi_flags)
23265       {
23266       case EF_ARM_EABI_UNKNOWN:
23267 #endif
23268         /* Set the flags in the private structure.  */
23269         if (uses_apcs_26)      flags |= F_APCS26;
23270         if (support_interwork) flags |= F_INTERWORK;
23271         if (uses_apcs_float)   flags |= F_APCS_FLOAT;
23272         if (pic_code)          flags |= F_PIC;
23273         if (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_any_hard))
23274           flags |= F_SOFT_FLOAT;
23275
23276         switch (mfloat_abi_opt)
23277           {
23278           case ARM_FLOAT_ABI_SOFT:
23279           case ARM_FLOAT_ABI_SOFTFP:
23280             flags |= F_SOFT_FLOAT;
23281             break;
23282
23283           case ARM_FLOAT_ABI_HARD:
23284             if (flags & F_SOFT_FLOAT)
23285               as_bad (_("hard-float conflicts with specified fpu"));
23286             break;
23287           }
23288
23289         /* Using pure-endian doubles (even if soft-float).      */
23290         if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_endian_pure))
23291           flags |= F_VFP_FLOAT;
23292
23293 #if defined OBJ_ELF
23294         if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_arch_maverick))
23295             flags |= EF_ARM_MAVERICK_FLOAT;
23296         break;
23297
23298       case EF_ARM_EABI_VER4:
23299       case EF_ARM_EABI_VER5:
23300         /* No additional flags to set.  */
23301         break;
23302
23303       default:
23304         abort ();
23305       }
23306 #endif
23307     bfd_set_private_flags (stdoutput, flags);
23308
23309     /* We have run out flags in the COFF header to encode the
23310        status of ATPCS support, so instead we create a dummy,
23311        empty, debug section called .arm.atpcs.  */
23312     if (atpcs)
23313       {
23314         asection * sec;
23315
23316         sec = bfd_make_section (stdoutput, ".arm.atpcs");
23317
23318         if (sec != NULL)
23319           {
23320             bfd_set_section_flags
23321               (stdoutput, sec, SEC_READONLY | SEC_DEBUGGING /* | SEC_HAS_CONTENTS */);
23322             bfd_set_section_size (stdoutput, sec, 0);
23323             bfd_set_section_contents (stdoutput, sec, NULL, 0, 0);
23324           }
23325       }
23326   }
23327 #endif
23328
23329   /* Record the CPU type as well.  */
23330   if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt2))
23331     mach = bfd_mach_arm_iWMMXt2;
23332   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt))
23333     mach = bfd_mach_arm_iWMMXt;
23334   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_xscale))
23335     mach = bfd_mach_arm_XScale;
23336   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_maverick))
23337     mach = bfd_mach_arm_ep9312;
23338   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v5e))
23339     mach = bfd_mach_arm_5TE;
23340   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v5))
23341     {
23342       if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
23343         mach = bfd_mach_arm_5T;
23344       else
23345         mach = bfd_mach_arm_5;
23346     }
23347   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4))
23348     {
23349       if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
23350         mach = bfd_mach_arm_4T;
23351       else
23352         mach = bfd_mach_arm_4;
23353     }
23354   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v3m))
23355     mach = bfd_mach_arm_3M;
23356   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v3))
23357     mach = bfd_mach_arm_3;
23358   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v2s))
23359     mach = bfd_mach_arm_2a;
23360   else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v2))
23361     mach = bfd_mach_arm_2;
23362   else
23363     mach = bfd_mach_arm_unknown;
23364
23365   bfd_set_arch_mach (stdoutput, TARGET_ARCH, mach);
23366 }
23367
23368 /* Command line processing.  */
23369
23370 /* md_parse_option
23371       Invocation line includes a switch not recognized by the base assembler.
23372       See if it's a processor-specific option.
23373
23374       This routine is somewhat complicated by the need for backwards
23375       compatibility (since older releases of gcc can't be changed).
23376       The new options try to make the interface as compatible as
23377       possible with GCC.
23378
23379       New options (supported) are:
23380
23381               -mcpu=<cpu name>           Assemble for selected processor
23382               -march=<architecture name> Assemble for selected architecture
23383               -mfpu=<fpu architecture>   Assemble for selected FPU.
23384               -EB/-mbig-endian           Big-endian
23385               -EL/-mlittle-endian        Little-endian
23386               -k                         Generate PIC code
23387               -mthumb                    Start in Thumb mode
23388               -mthumb-interwork          Code supports ARM/Thumb interworking
23389
23390               -m[no-]warn-deprecated     Warn about deprecated features
23391
23392       For now we will also provide support for:
23393
23394               -mapcs-32                  32-bit Program counter
23395               -mapcs-26                  26-bit Program counter
23396               -macps-float               Floats passed in FP registers
23397               -mapcs-reentrant           Reentrant code
23398               -matpcs
23399       (sometime these will probably be replaced with -mapcs=<list of options>
23400       and -matpcs=<list of options>)
23401
23402       The remaining options are only supported for back-wards compatibility.
23403       Cpu variants, the arm part is optional:
23404               -m[arm]1                Currently not supported.
23405               -m[arm]2, -m[arm]250    Arm 2 and Arm 250 processor
23406               -m[arm]3                Arm 3 processor
23407               -m[arm]6[xx],           Arm 6 processors
23408               -m[arm]7[xx][t][[d]m]   Arm 7 processors
23409               -m[arm]8[10]            Arm 8 processors
23410               -m[arm]9[20][tdmi]      Arm 9 processors
23411               -mstrongarm[110[0]]     StrongARM processors
23412               -mxscale                XScale processors
23413               -m[arm]v[2345[t[e]]]    Arm architectures
23414               -mall                   All (except the ARM1)
23415       FP variants:
23416               -mfpa10, -mfpa11        FPA10 and 11 co-processor instructions
23417               -mfpe-old               (No float load/store multiples)
23418               -mvfpxd                 VFP Single precision
23419               -mvfp                   All VFP
23420               -mno-fpu                Disable all floating point instructions
23421
23422       The following CPU names are recognized:
23423               arm1, arm2, arm250, arm3, arm6, arm600, arm610, arm620,
23424               arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700,
23425               arm700i, arm710 arm710t, arm720, arm720t, arm740t, arm710c,
23426               arm7100, arm7500, arm7500fe, arm7tdmi, arm8, arm810, arm9,
23427               arm920, arm920t, arm940t, arm946, arm966, arm9tdmi, arm9e,
23428               arm10t arm10e, arm1020t, arm1020e, arm10200e,
23429               strongarm, strongarm110, strongarm1100, strongarm1110, xscale.
23430
23431       */
23432
23433 const char * md_shortopts = "m:k";
23434
23435 #ifdef ARM_BI_ENDIAN
23436 #define OPTION_EB (OPTION_MD_BASE + 0)
23437 #define OPTION_EL (OPTION_MD_BASE + 1)
23438 #else
23439 #if TARGET_BYTES_BIG_ENDIAN
23440 #define OPTION_EB (OPTION_MD_BASE + 0)
23441 #else
23442 #define OPTION_EL (OPTION_MD_BASE + 1)
23443 #endif
23444 #endif
23445 #define OPTION_FIX_V4BX (OPTION_MD_BASE + 2)
23446
23447 struct option md_longopts[] =
23448 {
23449 #ifdef OPTION_EB
23450   {"EB", no_argument, NULL, OPTION_EB},
23451 #endif
23452 #ifdef OPTION_EL
23453   {"EL", no_argument, NULL, OPTION_EL},
23454 #endif
23455   {"fix-v4bx", no_argument, NULL, OPTION_FIX_V4BX},
23456   {NULL, no_argument, NULL, 0}
23457 };
23458
23459 size_t md_longopts_size = sizeof (md_longopts);
23460
23461 struct arm_option_table
23462 {
23463   char *option;         /* Option name to match.  */
23464   char *help;           /* Help information.  */
23465   int  *var;            /* Variable to change.  */
23466   int   value;          /* What to change it to.  */
23467   char *deprecated;     /* If non-null, print this message.  */
23468 };
23469
23470 struct arm_option_table arm_opts[] =
23471 {
23472   {"k",      N_("generate PIC code"),      &pic_code,    1, NULL},
23473   {"mthumb", N_("assemble Thumb code"),    &thumb_mode,  1, NULL},
23474   {"mthumb-interwork", N_("support ARM/Thumb interworking"),
23475    &support_interwork, 1, NULL},
23476   {"mapcs-32", N_("code uses 32-bit program counter"), &uses_apcs_26, 0, NULL},
23477   {"mapcs-26", N_("code uses 26-bit program counter"), &uses_apcs_26, 1, NULL},
23478   {"mapcs-float", N_("floating point args are in fp regs"), &uses_apcs_float,
23479    1, NULL},
23480   {"mapcs-reentrant", N_("re-entrant code"), &pic_code, 1, NULL},
23481   {"matpcs", N_("code is ATPCS conformant"), &atpcs, 1, NULL},
23482   {"mbig-endian", N_("assemble for big-endian"), &target_big_endian, 1, NULL},
23483   {"mlittle-endian", N_("assemble for little-endian"), &target_big_endian, 0,
23484    NULL},
23485
23486   /* These are recognized by the assembler, but have no affect on code.  */
23487   {"mapcs-frame", N_("use frame pointer"), NULL, 0, NULL},
23488   {"mapcs-stack-check", N_("use stack size checking"), NULL, 0, NULL},
23489
23490   {"mwarn-deprecated", NULL, &warn_on_deprecated, 1, NULL},
23491   {"mno-warn-deprecated", N_("do not warn on use of deprecated feature"),
23492    &warn_on_deprecated, 0, NULL},
23493   {NULL, NULL, NULL, 0, NULL}
23494 };
23495
23496 struct arm_legacy_option_table
23497 {
23498   char *option;                         /* Option name to match.  */
23499   const arm_feature_set **var;          /* Variable to change.  */
23500   const arm_feature_set value;          /* What to change it to.  */
23501   char *deprecated;                     /* If non-null, print this message.  */
23502 };
23503
23504 const struct arm_legacy_option_table arm_legacy_opts[] =
23505 {
23506   /* DON'T add any new processors to this list -- we want the whole list
23507      to go away...  Add them to the processors table instead.  */
23508   {"marm1",      &legacy_cpu, ARM_ARCH_V1,  N_("use -mcpu=arm1")},
23509   {"m1",         &legacy_cpu, ARM_ARCH_V1,  N_("use -mcpu=arm1")},
23510   {"marm2",      &legacy_cpu, ARM_ARCH_V2,  N_("use -mcpu=arm2")},
23511   {"m2",         &legacy_cpu, ARM_ARCH_V2,  N_("use -mcpu=arm2")},
23512   {"marm250",    &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm250")},
23513   {"m250",       &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm250")},
23514   {"marm3",      &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm3")},
23515   {"m3",         &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm3")},
23516   {"marm6",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm6")},
23517   {"m6",         &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm6")},
23518   {"marm600",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm600")},
23519   {"m600",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm600")},
23520   {"marm610",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm610")},
23521   {"m610",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm610")},
23522   {"marm620",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm620")},
23523   {"m620",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm620")},
23524   {"marm7",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7")},
23525   {"m7",         &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7")},
23526   {"marm70",     &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm70")},
23527   {"m70",        &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm70")},
23528   {"marm700",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700")},
23529   {"m700",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700")},
23530   {"marm700i",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700i")},
23531   {"m700i",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm700i")},
23532   {"marm710",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710")},
23533   {"m710",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710")},
23534   {"marm710c",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710c")},
23535   {"m710c",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm710c")},
23536   {"marm720",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm720")},
23537   {"m720",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm720")},
23538   {"marm7d",     &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7d")},
23539   {"m7d",        &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7d")},
23540   {"marm7di",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7di")},
23541   {"m7di",       &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7di")},
23542   {"marm7m",     &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7m")},
23543   {"m7m",        &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7m")},
23544   {"marm7dm",    &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dm")},
23545   {"m7dm",       &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dm")},
23546   {"marm7dmi",   &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dmi")},
23547   {"m7dmi",      &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dmi")},
23548   {"marm7100",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7100")},
23549   {"m7100",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7100")},
23550   {"marm7500",   &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500")},
23551   {"m7500",      &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500")},
23552   {"marm7500fe", &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500fe")},
23553   {"m7500fe",    &legacy_cpu, ARM_ARCH_V3,  N_("use -mcpu=arm7500fe")},
23554   {"marm7t",     &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
23555   {"m7t",        &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
23556   {"marm7tdmi",  &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
23557   {"m7tdmi",     &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
23558   {"marm710t",   &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm710t")},
23559   {"m710t",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm710t")},
23560   {"marm720t",   &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm720t")},
23561   {"m720t",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm720t")},
23562   {"marm740t",   &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm740t")},
23563   {"m740t",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm740t")},
23564   {"marm8",      &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm8")},
23565   {"m8",         &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm8")},
23566   {"marm810",    &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm810")},
23567   {"m810",       &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=arm810")},
23568   {"marm9",      &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9")},
23569   {"m9",         &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9")},
23570   {"marm9tdmi",  &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9tdmi")},
23571   {"m9tdmi",     &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9tdmi")},
23572   {"marm920",    &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm920")},
23573   {"m920",       &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm920")},
23574   {"marm940",    &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm940")},
23575   {"m940",       &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm940")},
23576   {"mstrongarm", &legacy_cpu, ARM_ARCH_V4,  N_("use -mcpu=strongarm")},
23577   {"mstrongarm110", &legacy_cpu, ARM_ARCH_V4,
23578    N_("use -mcpu=strongarm110")},
23579   {"mstrongarm1100", &legacy_cpu, ARM_ARCH_V4,
23580    N_("use -mcpu=strongarm1100")},
23581   {"mstrongarm1110", &legacy_cpu, ARM_ARCH_V4,
23582    N_("use -mcpu=strongarm1110")},
23583   {"mxscale",    &legacy_cpu, ARM_ARCH_XSCALE, N_("use -mcpu=xscale")},
23584   {"miwmmxt",    &legacy_cpu, ARM_ARCH_IWMMXT, N_("use -mcpu=iwmmxt")},
23585   {"mall",       &legacy_cpu, ARM_ANY,         N_("use -mcpu=all")},
23586
23587   /* Architecture variants -- don't add any more to this list either.  */
23588   {"mv2",        &legacy_cpu, ARM_ARCH_V2,  N_("use -march=armv2")},
23589   {"marmv2",     &legacy_cpu, ARM_ARCH_V2,  N_("use -march=armv2")},
23590   {"mv2a",       &legacy_cpu, ARM_ARCH_V2S, N_("use -march=armv2a")},
23591   {"marmv2a",    &legacy_cpu, ARM_ARCH_V2S, N_("use -march=armv2a")},
23592   {"mv3",        &legacy_cpu, ARM_ARCH_V3,  N_("use -march=armv3")},
23593   {"marmv3",     &legacy_cpu, ARM_ARCH_V3,  N_("use -march=armv3")},
23594   {"mv3m",       &legacy_cpu, ARM_ARCH_V3M, N_("use -march=armv3m")},
23595   {"marmv3m",    &legacy_cpu, ARM_ARCH_V3M, N_("use -march=armv3m")},
23596   {"mv4",        &legacy_cpu, ARM_ARCH_V4,  N_("use -march=armv4")},
23597   {"marmv4",     &legacy_cpu, ARM_ARCH_V4,  N_("use -march=armv4")},
23598   {"mv4t",       &legacy_cpu, ARM_ARCH_V4T, N_("use -march=armv4t")},
23599   {"marmv4t",    &legacy_cpu, ARM_ARCH_V4T, N_("use -march=armv4t")},
23600   {"mv5",        &legacy_cpu, ARM_ARCH_V5,  N_("use -march=armv5")},
23601   {"marmv5",     &legacy_cpu, ARM_ARCH_V5,  N_("use -march=armv5")},
23602   {"mv5t",       &legacy_cpu, ARM_ARCH_V5T, N_("use -march=armv5t")},
23603   {"marmv5t",    &legacy_cpu, ARM_ARCH_V5T, N_("use -march=armv5t")},
23604   {"mv5e",       &legacy_cpu, ARM_ARCH_V5TE, N_("use -march=armv5te")},
23605   {"marmv5e",    &legacy_cpu, ARM_ARCH_V5TE, N_("use -march=armv5te")},
23606
23607   /* Floating point variants -- don't add any more to this list either.  */
23608   {"mfpe-old", &legacy_fpu, FPU_ARCH_FPE, N_("use -mfpu=fpe")},
23609   {"mfpa10",   &legacy_fpu, FPU_ARCH_FPA, N_("use -mfpu=fpa10")},
23610   {"mfpa11",   &legacy_fpu, FPU_ARCH_FPA, N_("use -mfpu=fpa11")},
23611   {"mno-fpu",  &legacy_fpu, ARM_ARCH_NONE,
23612    N_("use either -mfpu=softfpa or -mfpu=softvfp")},
23613
23614   {NULL, NULL, ARM_ARCH_NONE, NULL}
23615 };
23616
23617 struct arm_cpu_option_table
23618 {
23619   char *name;
23620   size_t name_len;
23621   const arm_feature_set value;
23622   /* For some CPUs we assume an FPU unless the user explicitly sets
23623      -mfpu=...  */
23624   const arm_feature_set default_fpu;
23625   /* The canonical name of the CPU, or NULL to use NAME converted to upper
23626      case.  */
23627   const char *canonical_name;
23628 };
23629
23630 /* This list should, at a minimum, contain all the cpu names
23631    recognized by GCC.  */
23632 #define ARM_CPU_OPT(N, V, DF, CN) { N, sizeof (N) - 1, V, DF, CN }
23633 static const struct arm_cpu_option_table arm_cpus[] =
23634 {
23635   ARM_CPU_OPT ("all",           ARM_ANY,         FPU_ARCH_FPA,    NULL),
23636   ARM_CPU_OPT ("arm1",          ARM_ARCH_V1,     FPU_ARCH_FPA,    NULL),
23637   ARM_CPU_OPT ("arm2",          ARM_ARCH_V2,     FPU_ARCH_FPA,    NULL),
23638   ARM_CPU_OPT ("arm250",        ARM_ARCH_V2S,    FPU_ARCH_FPA,    NULL),
23639   ARM_CPU_OPT ("arm3",          ARM_ARCH_V2S,    FPU_ARCH_FPA,    NULL),
23640   ARM_CPU_OPT ("arm6",          ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23641   ARM_CPU_OPT ("arm60",         ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23642   ARM_CPU_OPT ("arm600",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23643   ARM_CPU_OPT ("arm610",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23644   ARM_CPU_OPT ("arm620",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23645   ARM_CPU_OPT ("arm7",          ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23646   ARM_CPU_OPT ("arm7m",         ARM_ARCH_V3M,    FPU_ARCH_FPA,    NULL),
23647   ARM_CPU_OPT ("arm7d",         ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23648   ARM_CPU_OPT ("arm7dm",        ARM_ARCH_V3M,    FPU_ARCH_FPA,    NULL),
23649   ARM_CPU_OPT ("arm7di",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23650   ARM_CPU_OPT ("arm7dmi",       ARM_ARCH_V3M,    FPU_ARCH_FPA,    NULL),
23651   ARM_CPU_OPT ("arm70",         ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23652   ARM_CPU_OPT ("arm700",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23653   ARM_CPU_OPT ("arm700i",       ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23654   ARM_CPU_OPT ("arm710",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23655   ARM_CPU_OPT ("arm710t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23656   ARM_CPU_OPT ("arm720",        ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23657   ARM_CPU_OPT ("arm720t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23658   ARM_CPU_OPT ("arm740t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23659   ARM_CPU_OPT ("arm710c",       ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23660   ARM_CPU_OPT ("arm7100",       ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23661   ARM_CPU_OPT ("arm7500",       ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23662   ARM_CPU_OPT ("arm7500fe",     ARM_ARCH_V3,     FPU_ARCH_FPA,    NULL),
23663   ARM_CPU_OPT ("arm7t",         ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23664   ARM_CPU_OPT ("arm7tdmi",      ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23665   ARM_CPU_OPT ("arm7tdmi-s",    ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23666   ARM_CPU_OPT ("arm8",          ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23667   ARM_CPU_OPT ("arm810",        ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23668   ARM_CPU_OPT ("strongarm",     ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23669   ARM_CPU_OPT ("strongarm1",    ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23670   ARM_CPU_OPT ("strongarm110",  ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23671   ARM_CPU_OPT ("strongarm1100", ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23672   ARM_CPU_OPT ("strongarm1110", ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23673   ARM_CPU_OPT ("arm9",          ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23674   ARM_CPU_OPT ("arm920",        ARM_ARCH_V4T,    FPU_ARCH_FPA,    "ARM920T"),
23675   ARM_CPU_OPT ("arm920t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23676   ARM_CPU_OPT ("arm922t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23677   ARM_CPU_OPT ("arm940t",       ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23678   ARM_CPU_OPT ("arm9tdmi",      ARM_ARCH_V4T,    FPU_ARCH_FPA,    NULL),
23679   ARM_CPU_OPT ("fa526",         ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23680   ARM_CPU_OPT ("fa626",         ARM_ARCH_V4,     FPU_ARCH_FPA,    NULL),
23681   /* For V5 or later processors we default to using VFP; but the user
23682      should really set the FPU type explicitly.  */
23683   ARM_CPU_OPT ("arm9e-r0",      ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2, NULL),
23684   ARM_CPU_OPT ("arm9e",         ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23685   ARM_CPU_OPT ("arm926ej",      ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2, "ARM926EJ-S"),
23686   ARM_CPU_OPT ("arm926ejs",     ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2, "ARM926EJ-S"),
23687   ARM_CPU_OPT ("arm926ej-s",    ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2, NULL),
23688   ARM_CPU_OPT ("arm946e-r0",    ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2, NULL),
23689   ARM_CPU_OPT ("arm946e",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, "ARM946E-S"),
23690   ARM_CPU_OPT ("arm946e-s",     ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23691   ARM_CPU_OPT ("arm966e-r0",    ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2, NULL),
23692   ARM_CPU_OPT ("arm966e",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, "ARM966E-S"),
23693   ARM_CPU_OPT ("arm966e-s",     ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23694   ARM_CPU_OPT ("arm968e-s",     ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23695   ARM_CPU_OPT ("arm10t",        ARM_ARCH_V5T,    FPU_ARCH_VFP_V1, NULL),
23696   ARM_CPU_OPT ("arm10tdmi",     ARM_ARCH_V5T,    FPU_ARCH_VFP_V1, NULL),
23697   ARM_CPU_OPT ("arm10e",        ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23698   ARM_CPU_OPT ("arm1020",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, "ARM1020E"),
23699   ARM_CPU_OPT ("arm1020t",      ARM_ARCH_V5T,    FPU_ARCH_VFP_V1, NULL),
23700   ARM_CPU_OPT ("arm1020e",      ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23701   ARM_CPU_OPT ("arm1022e",      ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23702   ARM_CPU_OPT ("arm1026ejs",    ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2,
23703                                                                  "ARM1026EJ-S"),
23704   ARM_CPU_OPT ("arm1026ej-s",   ARM_ARCH_V5TEJ,  FPU_ARCH_VFP_V2, NULL),
23705   ARM_CPU_OPT ("fa606te",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23706   ARM_CPU_OPT ("fa616te",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23707   ARM_CPU_OPT ("fa626te",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23708   ARM_CPU_OPT ("fmp626",        ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23709   ARM_CPU_OPT ("fa726te",       ARM_ARCH_V5TE,   FPU_ARCH_VFP_V2, NULL),
23710   ARM_CPU_OPT ("arm1136js",     ARM_ARCH_V6,     FPU_NONE,        "ARM1136J-S"),
23711   ARM_CPU_OPT ("arm1136j-s",    ARM_ARCH_V6,     FPU_NONE,        NULL),
23712   ARM_CPU_OPT ("arm1136jfs",    ARM_ARCH_V6,     FPU_ARCH_VFP_V2,
23713                                                                  "ARM1136JF-S"),
23714   ARM_CPU_OPT ("arm1136jf-s",   ARM_ARCH_V6,     FPU_ARCH_VFP_V2, NULL),
23715   ARM_CPU_OPT ("mpcore",        ARM_ARCH_V6K,    FPU_ARCH_VFP_V2, "MPCore"),
23716   ARM_CPU_OPT ("mpcorenovfp",   ARM_ARCH_V6K,    FPU_NONE,        "MPCore"),
23717   ARM_CPU_OPT ("arm1156t2-s",   ARM_ARCH_V6T2,   FPU_NONE,        NULL),
23718   ARM_CPU_OPT ("arm1156t2f-s",  ARM_ARCH_V6T2,   FPU_ARCH_VFP_V2, NULL),
23719   ARM_CPU_OPT ("arm1176jz-s",   ARM_ARCH_V6ZK,   FPU_NONE,        NULL),
23720   ARM_CPU_OPT ("arm1176jzf-s",  ARM_ARCH_V6ZK,   FPU_ARCH_VFP_V2, NULL),
23721   ARM_CPU_OPT ("cortex-a5",     ARM_ARCH_V7A_MP_SEC,
23722                                                  FPU_NONE,        "Cortex-A5"),
23723   ARM_CPU_OPT ("cortex-a7",     ARM_ARCH_V7A_IDIV_MP_SEC_VIRT,
23724                                                  FPU_ARCH_NEON_VFP_V4,
23725                                                                   "Cortex-A7"),
23726   ARM_CPU_OPT ("cortex-a8",     ARM_ARCH_V7A_SEC,
23727                                                  ARM_FEATURE (0, FPU_VFP_V3
23728                                                         | FPU_NEON_EXT_V1),
23729                                                                   "Cortex-A8"),
23730   ARM_CPU_OPT ("cortex-a9",     ARM_ARCH_V7A_MP_SEC,
23731                                                  ARM_FEATURE (0, FPU_VFP_V3
23732                                                         | FPU_NEON_EXT_V1),
23733                                                                   "Cortex-A9"),
23734   ARM_CPU_OPT ("cortex-a15",    ARM_ARCH_V7A_IDIV_MP_SEC_VIRT,
23735                                                  FPU_ARCH_NEON_VFP_V4,
23736                                                                   "Cortex-A15"),
23737   ARM_CPU_OPT ("cortex-r4",     ARM_ARCH_V7R,    FPU_NONE,        "Cortex-R4"),
23738   ARM_CPU_OPT ("cortex-r4f",    ARM_ARCH_V7R,    FPU_ARCH_VFP_V3D16,
23739                                                                   "Cortex-R4F"),
23740   ARM_CPU_OPT ("cortex-r5",     ARM_ARCH_V7R_IDIV,
23741                                                  FPU_NONE,        "Cortex-R5"),
23742   ARM_CPU_OPT ("cortex-m4",     ARM_ARCH_V7EM,   FPU_NONE,        "Cortex-M4"),
23743   ARM_CPU_OPT ("cortex-m3",     ARM_ARCH_V7M,    FPU_NONE,        "Cortex-M3"),
23744   ARM_CPU_OPT ("cortex-m1",     ARM_ARCH_V6SM,   FPU_NONE,        "Cortex-M1"),
23745   ARM_CPU_OPT ("cortex-m0",     ARM_ARCH_V6SM,   FPU_NONE,        "Cortex-M0"),
23746   ARM_CPU_OPT ("cortex-m0plus", ARM_ARCH_V6SM,   FPU_NONE,        "Cortex-M0+"),
23747   /* ??? XSCALE is really an architecture.  */
23748   ARM_CPU_OPT ("xscale",        ARM_ARCH_XSCALE, FPU_ARCH_VFP_V2, NULL),
23749   /* ??? iwmmxt is not a processor.  */
23750   ARM_CPU_OPT ("iwmmxt",        ARM_ARCH_IWMMXT, FPU_ARCH_VFP_V2, NULL),
23751   ARM_CPU_OPT ("iwmmxt2",       ARM_ARCH_IWMMXT2,FPU_ARCH_VFP_V2, NULL),
23752   ARM_CPU_OPT ("i80200",        ARM_ARCH_XSCALE, FPU_ARCH_VFP_V2, NULL),
23753   /* Maverick */
23754   ARM_CPU_OPT ("ep9312",        ARM_FEATURE (ARM_AEXT_V4T, ARM_CEXT_MAVERICK),
23755                                                  FPU_ARCH_MAVERICK,
23756                                                                   "ARM920T"),
23757   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE, NULL }
23758 };
23759 #undef ARM_CPU_OPT
23760
23761 struct arm_arch_option_table
23762 {
23763   char *name;
23764   size_t name_len;
23765   const arm_feature_set value;
23766   const arm_feature_set default_fpu;
23767 };
23768
23769 /* This list should, at a minimum, contain all the architecture names
23770    recognized by GCC.  */
23771 #define ARM_ARCH_OPT(N, V, DF) { N, sizeof (N) - 1, V, DF }
23772 static const struct arm_arch_option_table arm_archs[] =
23773 {
23774   ARM_ARCH_OPT ("all",          ARM_ANY,         FPU_ARCH_FPA),
23775   ARM_ARCH_OPT ("armv1",        ARM_ARCH_V1,     FPU_ARCH_FPA),
23776   ARM_ARCH_OPT ("armv2",        ARM_ARCH_V2,     FPU_ARCH_FPA),
23777   ARM_ARCH_OPT ("armv2a",       ARM_ARCH_V2S,    FPU_ARCH_FPA),
23778   ARM_ARCH_OPT ("armv2s",       ARM_ARCH_V2S,    FPU_ARCH_FPA),
23779   ARM_ARCH_OPT ("armv3",        ARM_ARCH_V3,     FPU_ARCH_FPA),
23780   ARM_ARCH_OPT ("armv3m",       ARM_ARCH_V3M,    FPU_ARCH_FPA),
23781   ARM_ARCH_OPT ("armv4",        ARM_ARCH_V4,     FPU_ARCH_FPA),
23782   ARM_ARCH_OPT ("armv4xm",      ARM_ARCH_V4xM,   FPU_ARCH_FPA),
23783   ARM_ARCH_OPT ("armv4t",       ARM_ARCH_V4T,    FPU_ARCH_FPA),
23784   ARM_ARCH_OPT ("armv4txm",     ARM_ARCH_V4TxM,  FPU_ARCH_FPA),
23785   ARM_ARCH_OPT ("armv5",        ARM_ARCH_V5,     FPU_ARCH_VFP),
23786   ARM_ARCH_OPT ("armv5t",       ARM_ARCH_V5T,    FPU_ARCH_VFP),
23787   ARM_ARCH_OPT ("armv5txm",     ARM_ARCH_V5TxM,  FPU_ARCH_VFP),
23788   ARM_ARCH_OPT ("armv5te",      ARM_ARCH_V5TE,   FPU_ARCH_VFP),
23789   ARM_ARCH_OPT ("armv5texp",    ARM_ARCH_V5TExP, FPU_ARCH_VFP),
23790   ARM_ARCH_OPT ("armv5tej",     ARM_ARCH_V5TEJ,  FPU_ARCH_VFP),
23791   ARM_ARCH_OPT ("armv6",        ARM_ARCH_V6,     FPU_ARCH_VFP),
23792   ARM_ARCH_OPT ("armv6j",       ARM_ARCH_V6,     FPU_ARCH_VFP),
23793   ARM_ARCH_OPT ("armv6k",       ARM_ARCH_V6K,    FPU_ARCH_VFP),
23794   ARM_ARCH_OPT ("armv6z",       ARM_ARCH_V6Z,    FPU_ARCH_VFP),
23795   ARM_ARCH_OPT ("armv6zk",      ARM_ARCH_V6ZK,   FPU_ARCH_VFP),
23796   ARM_ARCH_OPT ("armv6t2",      ARM_ARCH_V6T2,   FPU_ARCH_VFP),
23797   ARM_ARCH_OPT ("armv6kt2",     ARM_ARCH_V6KT2,  FPU_ARCH_VFP),
23798   ARM_ARCH_OPT ("armv6zt2",     ARM_ARCH_V6ZT2,  FPU_ARCH_VFP),
23799   ARM_ARCH_OPT ("armv6zkt2",    ARM_ARCH_V6ZKT2, FPU_ARCH_VFP),
23800   ARM_ARCH_OPT ("armv6-m",      ARM_ARCH_V6M,    FPU_ARCH_VFP),
23801   ARM_ARCH_OPT ("armv6s-m",     ARM_ARCH_V6SM,   FPU_ARCH_VFP),
23802   ARM_ARCH_OPT ("armv7",        ARM_ARCH_V7,     FPU_ARCH_VFP),
23803   /* The official spelling of the ARMv7 profile variants is the dashed form.
23804      Accept the non-dashed form for compatibility with old toolchains.  */
23805   ARM_ARCH_OPT ("armv7a",       ARM_ARCH_V7A,    FPU_ARCH_VFP),
23806   ARM_ARCH_OPT ("armv7r",       ARM_ARCH_V7R,    FPU_ARCH_VFP),
23807   ARM_ARCH_OPT ("armv7m",       ARM_ARCH_V7M,    FPU_ARCH_VFP),
23808   ARM_ARCH_OPT ("armv7-a",      ARM_ARCH_V7A,    FPU_ARCH_VFP),
23809   ARM_ARCH_OPT ("armv7-r",      ARM_ARCH_V7R,    FPU_ARCH_VFP),
23810   ARM_ARCH_OPT ("armv7-m",      ARM_ARCH_V7M,    FPU_ARCH_VFP),
23811   ARM_ARCH_OPT ("armv7e-m",     ARM_ARCH_V7EM,   FPU_ARCH_VFP),
23812   ARM_ARCH_OPT ("armv8-a",      ARM_ARCH_V8A,    FPU_ARCH_VFP),
23813   ARM_ARCH_OPT ("xscale",       ARM_ARCH_XSCALE, FPU_ARCH_VFP),
23814   ARM_ARCH_OPT ("iwmmxt",       ARM_ARCH_IWMMXT, FPU_ARCH_VFP),
23815   ARM_ARCH_OPT ("iwmmxt2",      ARM_ARCH_IWMMXT2,FPU_ARCH_VFP),
23816   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
23817 };
23818 #undef ARM_ARCH_OPT
23819
23820 /* ISA extensions in the co-processor and main instruction set space.  */
23821 struct arm_option_extension_value_table
23822 {
23823   char *name;
23824   size_t name_len;
23825   const arm_feature_set value;
23826   const arm_feature_set allowed_archs;
23827 };
23828
23829 /* The following table must be in alphabetical order with a NULL last entry.
23830    */
23831 #define ARM_EXT_OPT(N, V, AA) { N, sizeof (N) - 1, V, AA }
23832 static const struct arm_option_extension_value_table arm_extensions[] =
23833 {
23834   ARM_EXT_OPT ("crypto", FPU_ARCH_CRYPTO_NEON_VFP_ARMV8,
23835                                    ARM_FEATURE (ARM_EXT_V8, 0)),
23836   ARM_EXT_OPT ("fp",     FPU_ARCH_VFP_ARMV8,
23837                                    ARM_FEATURE (ARM_EXT_V8, 0)),
23838   ARM_EXT_OPT ("idiv",  ARM_FEATURE (ARM_EXT_ADIV | ARM_EXT_DIV, 0),
23839                                    ARM_FEATURE (ARM_EXT_V7A | ARM_EXT_V7R, 0)),
23840   ARM_EXT_OPT ("iwmmxt",ARM_FEATURE (0, ARM_CEXT_IWMMXT),       ARM_ANY),
23841   ARM_EXT_OPT ("iwmmxt2",
23842                         ARM_FEATURE (0, ARM_CEXT_IWMMXT2),      ARM_ANY),
23843   ARM_EXT_OPT ("maverick",
23844                         ARM_FEATURE (0, ARM_CEXT_MAVERICK),     ARM_ANY),
23845   ARM_EXT_OPT ("mp",    ARM_FEATURE (ARM_EXT_MP, 0),
23846                                    ARM_FEATURE (ARM_EXT_V7A | ARM_EXT_V7R, 0)),
23847   ARM_EXT_OPT ("simd",   FPU_ARCH_NEON_VFP_ARMV8,
23848                                    ARM_FEATURE (ARM_EXT_V8, 0)),
23849   ARM_EXT_OPT ("os",    ARM_FEATURE (ARM_EXT_OS, 0),
23850                                    ARM_FEATURE (ARM_EXT_V6M, 0)),
23851   ARM_EXT_OPT ("sec",   ARM_FEATURE (ARM_EXT_SEC, 0),
23852                                    ARM_FEATURE (ARM_EXT_V6K | ARM_EXT_V7A, 0)),
23853   ARM_EXT_OPT ("virt",  ARM_FEATURE (ARM_EXT_VIRT | ARM_EXT_ADIV
23854                                      | ARM_EXT_DIV, 0),
23855                                    ARM_FEATURE (ARM_EXT_V7A, 0)),
23856   ARM_EXT_OPT ("xscale",ARM_FEATURE (0, ARM_CEXT_XSCALE),       ARM_ANY),
23857   { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
23858 };
23859 #undef ARM_EXT_OPT
23860
23861 /* ISA floating-point and Advanced SIMD extensions.  */
23862 struct arm_option_fpu_value_table
23863 {
23864   char *name;
23865   const arm_feature_set value;
23866 };
23867
23868 /* This list should, at a minimum, contain all the fpu names
23869    recognized by GCC.  */
23870 static const struct arm_option_fpu_value_table arm_fpus[] =
23871 {
23872   {"softfpa",           FPU_NONE},
23873   {"fpe",               FPU_ARCH_FPE},
23874   {"fpe2",              FPU_ARCH_FPE},
23875   {"fpe3",              FPU_ARCH_FPA},  /* Third release supports LFM/SFM.  */
23876   {"fpa",               FPU_ARCH_FPA},
23877   {"fpa10",             FPU_ARCH_FPA},
23878   {"fpa11",             FPU_ARCH_FPA},
23879   {"arm7500fe",         FPU_ARCH_FPA},
23880   {"softvfp",           FPU_ARCH_VFP},
23881   {"softvfp+vfp",       FPU_ARCH_VFP_V2},
23882   {"vfp",               FPU_ARCH_VFP_V2},
23883   {"vfp9",              FPU_ARCH_VFP_V2},
23884   {"vfp3",              FPU_ARCH_VFP_V3}, /* For backwards compatbility.  */
23885   {"vfp10",             FPU_ARCH_VFP_V2},
23886   {"vfp10-r0",          FPU_ARCH_VFP_V1},
23887   {"vfpxd",             FPU_ARCH_VFP_V1xD},
23888   {"vfpv2",             FPU_ARCH_VFP_V2},
23889   {"vfpv3",             FPU_ARCH_VFP_V3},
23890   {"vfpv3-fp16",        FPU_ARCH_VFP_V3_FP16},
23891   {"vfpv3-d16",         FPU_ARCH_VFP_V3D16},
23892   {"vfpv3-d16-fp16",    FPU_ARCH_VFP_V3D16_FP16},
23893   {"vfpv3xd",           FPU_ARCH_VFP_V3xD},
23894   {"vfpv3xd-fp16",      FPU_ARCH_VFP_V3xD_FP16},
23895   {"arm1020t",          FPU_ARCH_VFP_V1},
23896   {"arm1020e",          FPU_ARCH_VFP_V2},
23897   {"arm1136jfs",        FPU_ARCH_VFP_V2},
23898   {"arm1136jf-s",       FPU_ARCH_VFP_V2},
23899   {"maverick",          FPU_ARCH_MAVERICK},
23900   {"neon",              FPU_ARCH_VFP_V3_PLUS_NEON_V1},
23901   {"neon-fp16",         FPU_ARCH_NEON_FP16},
23902   {"vfpv4",             FPU_ARCH_VFP_V4},
23903   {"vfpv4-d16",         FPU_ARCH_VFP_V4D16},
23904   {"fpv4-sp-d16",       FPU_ARCH_VFP_V4_SP_D16},
23905   {"neon-vfpv4",        FPU_ARCH_NEON_VFP_V4},
23906   {"fp-armv8",          FPU_ARCH_VFP_ARMV8},
23907   {"neon-fp-armv8",     FPU_ARCH_NEON_VFP_ARMV8},
23908   {"crypto-neon-fp-armv8",
23909                         FPU_ARCH_CRYPTO_NEON_VFP_ARMV8},
23910   {NULL,                ARM_ARCH_NONE}
23911 };
23912
23913 struct arm_option_value_table
23914 {
23915   char *name;
23916   long value;
23917 };
23918
23919 static const struct arm_option_value_table arm_float_abis[] =
23920 {
23921   {"hard",      ARM_FLOAT_ABI_HARD},
23922   {"softfp",    ARM_FLOAT_ABI_SOFTFP},
23923   {"soft",      ARM_FLOAT_ABI_SOFT},
23924   {NULL,        0}
23925 };
23926
23927 #ifdef OBJ_ELF
23928 /* We only know how to output GNU and ver 4/5 (AAELF) formats.  */
23929 static const struct arm_option_value_table arm_eabis[] =
23930 {
23931   {"gnu",       EF_ARM_EABI_UNKNOWN},
23932   {"4",         EF_ARM_EABI_VER4},
23933   {"5",         EF_ARM_EABI_VER5},
23934   {NULL,        0}
23935 };
23936 #endif
23937
23938 struct arm_long_option_table
23939 {
23940   char * option;                /* Substring to match.  */
23941   char * help;                  /* Help information.  */
23942   int (* func) (char * subopt); /* Function to decode sub-option.  */
23943   char * deprecated;            /* If non-null, print this message.  */
23944 };
23945
23946 static bfd_boolean
23947 arm_parse_extension (char *str, const arm_feature_set **opt_p)
23948 {
23949   arm_feature_set *ext_set = (arm_feature_set *)
23950       xmalloc (sizeof (arm_feature_set));
23951
23952   /* We insist on extensions being specified in alphabetical order, and with
23953      extensions being added before being removed.  We achieve this by having
23954      the global ARM_EXTENSIONS table in alphabetical order, and using the
23955      ADDING_VALUE variable to indicate whether we are adding an extension (1)
23956      or removing it (0) and only allowing it to change in the order
23957      -1 -> 1 -> 0.  */
23958   const struct arm_option_extension_value_table * opt = NULL;
23959   int adding_value = -1;
23960
23961   /* Copy the feature set, so that we can modify it.  */
23962   *ext_set = **opt_p;
23963   *opt_p = ext_set;
23964
23965   while (str != NULL && *str != 0)
23966     {
23967       char *ext;
23968       size_t len;
23969
23970       if (*str != '+')
23971         {
23972           as_bad (_("invalid architectural extension"));
23973           return FALSE;
23974         }
23975
23976       str++;
23977       ext = strchr (str, '+');
23978
23979       if (ext != NULL)
23980         len = ext - str;
23981       else
23982         len = strlen (str);
23983
23984       if (len >= 2 && strncmp (str, "no", 2) == 0)
23985         {
23986           if (adding_value != 0)
23987             {
23988               adding_value = 0;
23989               opt = arm_extensions;
23990             }
23991
23992           len -= 2;
23993           str += 2;
23994         }
23995       else if (len > 0)
23996         {
23997           if (adding_value == -1)
23998             {
23999               adding_value = 1;
24000               opt = arm_extensions;
24001             }
24002           else if (adding_value != 1)
24003             {
24004               as_bad (_("must specify extensions to add before specifying "
24005                         "those to remove"));
24006               return FALSE;
24007             }
24008         }
24009
24010       if (len == 0)
24011         {
24012           as_bad (_("missing architectural extension"));
24013           return FALSE;
24014         }
24015
24016       gas_assert (adding_value != -1);
24017       gas_assert (opt != NULL);
24018
24019       /* Scan over the options table trying to find an exact match. */
24020       for (; opt->name != NULL; opt++)
24021         if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
24022           {
24023             /* Check we can apply the extension to this architecture.  */
24024             if (!ARM_CPU_HAS_FEATURE (*ext_set, opt->allowed_archs))
24025               {
24026                 as_bad (_("extension does not apply to the base architecture"));
24027                 return FALSE;
24028               }
24029
24030             /* Add or remove the extension.  */
24031             if (adding_value)
24032               ARM_MERGE_FEATURE_SETS (*ext_set, *ext_set, opt->value);
24033             else
24034               ARM_CLEAR_FEATURE (*ext_set, *ext_set, opt->value);
24035
24036             break;
24037           }
24038
24039       if (opt->name == NULL)
24040         {
24041           /* Did we fail to find an extension because it wasn't specified in
24042              alphabetical order, or because it does not exist?  */
24043
24044           for (opt = arm_extensions; opt->name != NULL; opt++)
24045             if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
24046               break;
24047
24048           if (opt->name == NULL)
24049             as_bad (_("unknown architectural extension `%s'"), str);
24050           else
24051             as_bad (_("architectural extensions must be specified in "
24052                       "alphabetical order"));
24053
24054           return FALSE;
24055         }
24056       else
24057         {
24058           /* We should skip the extension we've just matched the next time
24059              round.  */
24060           opt++;
24061         }
24062
24063       str = ext;
24064     };
24065
24066   return TRUE;
24067 }
24068
24069 static bfd_boolean
24070 arm_parse_cpu (char *str)
24071 {
24072   const struct arm_cpu_option_table *opt;
24073   char *ext = strchr (str, '+');
24074   size_t len;
24075
24076   if (ext != NULL)
24077     len = ext - str;
24078   else
24079     len = strlen (str);
24080
24081   if (len == 0)
24082     {
24083       as_bad (_("missing cpu name `%s'"), str);
24084       return FALSE;
24085     }
24086
24087   for (opt = arm_cpus; opt->name != NULL; opt++)
24088     if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
24089       {
24090         mcpu_cpu_opt = &opt->value;
24091         mcpu_fpu_opt = &opt->default_fpu;
24092         if (opt->canonical_name)
24093           strcpy (selected_cpu_name, opt->canonical_name);
24094         else
24095           {
24096             size_t i;
24097
24098             for (i = 0; i < len; i++)
24099               selected_cpu_name[i] = TOUPPER (opt->name[i]);
24100             selected_cpu_name[i] = 0;
24101           }
24102
24103         if (ext != NULL)
24104           return arm_parse_extension (ext, &mcpu_cpu_opt);
24105
24106         return TRUE;
24107       }
24108
24109   as_bad (_("unknown cpu `%s'"), str);
24110   return FALSE;
24111 }
24112
24113 static bfd_boolean
24114 arm_parse_arch (char *str)
24115 {
24116   const struct arm_arch_option_table *opt;
24117   char *ext = strchr (str, '+');
24118   size_t len;
24119
24120   if (ext != NULL)
24121     len = ext - str;
24122   else
24123     len = strlen (str);
24124
24125   if (len == 0)
24126     {
24127       as_bad (_("missing architecture name `%s'"), str);
24128       return FALSE;
24129     }
24130
24131   for (opt = arm_archs; opt->name != NULL; opt++)
24132     if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
24133       {
24134         march_cpu_opt = &opt->value;
24135         march_fpu_opt = &opt->default_fpu;
24136         strcpy (selected_cpu_name, opt->name);
24137
24138         if (ext != NULL)
24139           return arm_parse_extension (ext, &march_cpu_opt);
24140
24141         return TRUE;
24142       }
24143
24144   as_bad (_("unknown architecture `%s'\n"), str);
24145   return FALSE;
24146 }
24147
24148 static bfd_boolean
24149 arm_parse_fpu (char * str)
24150 {
24151   const struct arm_option_fpu_value_table * opt;
24152
24153   for (opt = arm_fpus; opt->name != NULL; opt++)
24154     if (streq (opt->name, str))
24155       {
24156         mfpu_opt = &opt->value;
24157         return TRUE;
24158       }
24159
24160   as_bad (_("unknown floating point format `%s'\n"), str);
24161   return FALSE;
24162 }
24163
24164 static bfd_boolean
24165 arm_parse_float_abi (char * str)
24166 {
24167   const struct arm_option_value_table * opt;
24168
24169   for (opt = arm_float_abis; opt->name != NULL; opt++)
24170     if (streq (opt->name, str))
24171       {
24172         mfloat_abi_opt = opt->value;
24173         return TRUE;
24174       }
24175
24176   as_bad (_("unknown floating point abi `%s'\n"), str);
24177   return FALSE;
24178 }
24179
24180 #ifdef OBJ_ELF
24181 static bfd_boolean
24182 arm_parse_eabi (char * str)
24183 {
24184   const struct arm_option_value_table *opt;
24185
24186   for (opt = arm_eabis; opt->name != NULL; opt++)
24187     if (streq (opt->name, str))
24188       {
24189         meabi_flags = opt->value;
24190         return TRUE;
24191       }
24192   as_bad (_("unknown EABI `%s'\n"), str);
24193   return FALSE;
24194 }
24195 #endif
24196
24197 static bfd_boolean
24198 arm_parse_it_mode (char * str)
24199 {
24200   bfd_boolean ret = TRUE;
24201
24202   if (streq ("arm", str))
24203     implicit_it_mode = IMPLICIT_IT_MODE_ARM;
24204   else if (streq ("thumb", str))
24205     implicit_it_mode = IMPLICIT_IT_MODE_THUMB;
24206   else if (streq ("always", str))
24207     implicit_it_mode = IMPLICIT_IT_MODE_ALWAYS;
24208   else if (streq ("never", str))
24209     implicit_it_mode = IMPLICIT_IT_MODE_NEVER;
24210   else
24211     {
24212       as_bad (_("unknown implicit IT mode `%s', should be "\
24213                 "arm, thumb, always, or never."), str);
24214       ret = FALSE;
24215     }
24216
24217   return ret;
24218 }
24219
24220 struct arm_long_option_table arm_long_opts[] =
24221 {
24222   {"mcpu=", N_("<cpu name>\t  assemble for CPU <cpu name>"),
24223    arm_parse_cpu, NULL},
24224   {"march=", N_("<arch name>\t  assemble for architecture <arch name>"),
24225    arm_parse_arch, NULL},
24226   {"mfpu=", N_("<fpu name>\t  assemble for FPU architecture <fpu name>"),
24227    arm_parse_fpu, NULL},
24228   {"mfloat-abi=", N_("<abi>\t  assemble for floating point ABI <abi>"),
24229    arm_parse_float_abi, NULL},
24230 #ifdef OBJ_ELF
24231   {"meabi=", N_("<ver>\t\t  assemble for eabi version <ver>"),
24232    arm_parse_eabi, NULL},
24233 #endif
24234   {"mimplicit-it=", N_("<mode>\t  controls implicit insertion of IT instructions"),
24235    arm_parse_it_mode, NULL},
24236   {NULL, NULL, 0, NULL}
24237 };
24238
24239 int
24240 md_parse_option (int c, char * arg)
24241 {
24242   struct arm_option_table *opt;
24243   const struct arm_legacy_option_table *fopt;
24244   struct arm_long_option_table *lopt;
24245
24246   switch (c)
24247     {
24248 #ifdef OPTION_EB
24249     case OPTION_EB:
24250       target_big_endian = 1;
24251       break;
24252 #endif
24253
24254 #ifdef OPTION_EL
24255     case OPTION_EL:
24256       target_big_endian = 0;
24257       break;
24258 #endif
24259
24260     case OPTION_FIX_V4BX:
24261       fix_v4bx = TRUE;
24262       break;
24263
24264     case 'a':
24265       /* Listing option.  Just ignore these, we don't support additional
24266          ones.  */
24267       return 0;
24268
24269     default:
24270       for (opt = arm_opts; opt->option != NULL; opt++)
24271         {
24272           if (c == opt->option[0]
24273               && ((arg == NULL && opt->option[1] == 0)
24274                   || streq (arg, opt->option + 1)))
24275             {
24276               /* If the option is deprecated, tell the user.  */
24277               if (warn_on_deprecated && opt->deprecated != NULL)
24278                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c,
24279                            arg ? arg : "", _(opt->deprecated));
24280
24281               if (opt->var != NULL)
24282                 *opt->var = opt->value;
24283
24284               return 1;
24285             }
24286         }
24287
24288       for (fopt = arm_legacy_opts; fopt->option != NULL; fopt++)
24289         {
24290           if (c == fopt->option[0]
24291               && ((arg == NULL && fopt->option[1] == 0)
24292                   || streq (arg, fopt->option + 1)))
24293             {
24294               /* If the option is deprecated, tell the user.  */
24295               if (warn_on_deprecated && fopt->deprecated != NULL)
24296                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c,
24297                            arg ? arg : "", _(fopt->deprecated));
24298
24299               if (fopt->var != NULL)
24300                 *fopt->var = &fopt->value;
24301
24302               return 1;
24303             }
24304         }
24305
24306       for (lopt = arm_long_opts; lopt->option != NULL; lopt++)
24307         {
24308           /* These options are expected to have an argument.  */
24309           if (c == lopt->option[0]
24310               && arg != NULL
24311               && strncmp (arg, lopt->option + 1,
24312                           strlen (lopt->option + 1)) == 0)
24313             {
24314               /* If the option is deprecated, tell the user.  */
24315               if (warn_on_deprecated && lopt->deprecated != NULL)
24316                 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c, arg,
24317                            _(lopt->deprecated));
24318
24319               /* Call the sup-option parser.  */
24320               return lopt->func (arg + strlen (lopt->option) - 1);
24321             }
24322         }
24323
24324       return 0;
24325     }
24326
24327   return 1;
24328 }
24329
24330 void
24331 md_show_usage (FILE * fp)
24332 {
24333   struct arm_option_table *opt;
24334   struct arm_long_option_table *lopt;
24335
24336   fprintf (fp, _(" ARM-specific assembler options:\n"));
24337
24338   for (opt = arm_opts; opt->option != NULL; opt++)
24339     if (opt->help != NULL)
24340       fprintf (fp, "  -%-23s%s\n", opt->option, _(opt->help));
24341
24342   for (lopt = arm_long_opts; lopt->option != NULL; lopt++)
24343     if (lopt->help != NULL)
24344       fprintf (fp, "  -%s%s\n", lopt->option, _(lopt->help));
24345
24346 #ifdef OPTION_EB
24347   fprintf (fp, _("\
24348   -EB                     assemble code for a big-endian cpu\n"));
24349 #endif
24350
24351 #ifdef OPTION_EL
24352   fprintf (fp, _("\
24353   -EL                     assemble code for a little-endian cpu\n"));
24354 #endif
24355
24356   fprintf (fp, _("\
24357   --fix-v4bx              Allow BX in ARMv4 code\n"));
24358 }
24359
24360
24361 #ifdef OBJ_ELF
24362 typedef struct
24363 {
24364   int val;
24365   arm_feature_set flags;
24366 } cpu_arch_ver_table;
24367
24368 /* Mapping from CPU features to EABI CPU arch values.  Table must be sorted
24369    least features first.  */
24370 static const cpu_arch_ver_table cpu_arch_ver[] =
24371 {
24372     {1, ARM_ARCH_V4},
24373     {2, ARM_ARCH_V4T},
24374     {3, ARM_ARCH_V5},
24375     {3, ARM_ARCH_V5T},
24376     {4, ARM_ARCH_V5TE},
24377     {5, ARM_ARCH_V5TEJ},
24378     {6, ARM_ARCH_V6},
24379     {9, ARM_ARCH_V6K},
24380     {7, ARM_ARCH_V6Z},
24381     {11, ARM_ARCH_V6M},
24382     {12, ARM_ARCH_V6SM},
24383     {8, ARM_ARCH_V6T2},
24384     {10, ARM_ARCH_V7A_IDIV_MP_SEC_VIRT},
24385     {10, ARM_ARCH_V7R},
24386     {10, ARM_ARCH_V7M},
24387     {14, ARM_ARCH_V8A},
24388     {0, ARM_ARCH_NONE}
24389 };
24390
24391 /* Set an attribute if it has not already been set by the user.  */
24392 static void
24393 aeabi_set_attribute_int (int tag, int value)
24394 {
24395   if (tag < 1
24396       || tag >= NUM_KNOWN_OBJ_ATTRIBUTES
24397       || !attributes_set_explicitly[tag])
24398     bfd_elf_add_proc_attr_int (stdoutput, tag, value);
24399 }
24400
24401 static void
24402 aeabi_set_attribute_string (int tag, const char *value)
24403 {
24404   if (tag < 1
24405       || tag >= NUM_KNOWN_OBJ_ATTRIBUTES
24406       || !attributes_set_explicitly[tag])
24407     bfd_elf_add_proc_attr_string (stdoutput, tag, value);
24408 }
24409
24410 /* Set the public EABI object attributes.  */
24411 static void
24412 aeabi_set_public_attributes (void)
24413 {
24414   int arch;
24415   char profile;
24416   int virt_sec = 0;
24417   int fp16_optional = 0;
24418   arm_feature_set flags;
24419   arm_feature_set tmp;
24420   const cpu_arch_ver_table *p;
24421
24422   /* Choose the architecture based on the capabilities of the requested cpu
24423      (if any) and/or the instructions actually used.  */
24424   ARM_MERGE_FEATURE_SETS (flags, arm_arch_used, thumb_arch_used);
24425   ARM_MERGE_FEATURE_SETS (flags, flags, *mfpu_opt);
24426   ARM_MERGE_FEATURE_SETS (flags, flags, selected_cpu);
24427
24428   if (ARM_CPU_HAS_FEATURE (arm_arch_used, arm_arch_any))
24429     ARM_MERGE_FEATURE_SETS (flags, flags, arm_ext_v1);
24430
24431   if (ARM_CPU_HAS_FEATURE (thumb_arch_used, arm_arch_any))
24432     ARM_MERGE_FEATURE_SETS (flags, flags, arm_ext_v4t);
24433
24434   /* Allow the user to override the reported architecture.  */
24435   if (object_arch)
24436     {
24437       ARM_CLEAR_FEATURE (flags, flags, arm_arch_any);
24438       ARM_MERGE_FEATURE_SETS (flags, flags, *object_arch);
24439     }
24440
24441   /* We need to make sure that the attributes do not identify us as v6S-M
24442      when the only v6S-M feature in use is the Operating System Extensions.  */
24443   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_os))
24444       if (!ARM_CPU_HAS_FEATURE (flags, arm_arch_v6m_only))
24445         ARM_CLEAR_FEATURE (flags, flags, arm_ext_os);
24446
24447   tmp = flags;
24448   arch = 0;
24449   for (p = cpu_arch_ver; p->val; p++)
24450     {
24451       if (ARM_CPU_HAS_FEATURE (tmp, p->flags))
24452         {
24453           arch = p->val;
24454           ARM_CLEAR_FEATURE (tmp, tmp, p->flags);
24455         }
24456     }
24457
24458   /* The table lookup above finds the last architecture to contribute
24459      a new feature.  Unfortunately, Tag13 is a subset of the union of
24460      v6T2 and v7-M, so it is never seen as contributing a new feature.
24461      We can not search for the last entry which is entirely used,
24462      because if no CPU is specified we build up only those flags
24463      actually used.  Perhaps we should separate out the specified
24464      and implicit cases.  Avoid taking this path for -march=all by
24465      checking for contradictory v7-A / v7-M features.  */
24466   if (arch == 10
24467       && !ARM_CPU_HAS_FEATURE (flags, arm_ext_v7a)
24468       && ARM_CPU_HAS_FEATURE (flags, arm_ext_v7m)
24469       && ARM_CPU_HAS_FEATURE (flags, arm_ext_v6_dsp))
24470     arch = 13;
24471
24472   /* Tag_CPU_name.  */
24473   if (selected_cpu_name[0])
24474     {
24475       char *q;
24476
24477       q = selected_cpu_name;
24478       if (strncmp (q, "armv", 4) == 0)
24479         {
24480           int i;
24481
24482           q += 4;
24483           for (i = 0; q[i]; i++)
24484             q[i] = TOUPPER (q[i]);
24485         }
24486       aeabi_set_attribute_string (Tag_CPU_name, q);
24487     }
24488
24489   /* Tag_CPU_arch.  */
24490   aeabi_set_attribute_int (Tag_CPU_arch, arch);
24491
24492   /* Tag_CPU_arch_profile.  */
24493   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v7a))
24494     profile = 'A';
24495   else if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v7r))
24496     profile = 'R';
24497   else if (ARM_CPU_HAS_FEATURE (flags, arm_ext_m))
24498     profile = 'M';
24499   else
24500     profile = '\0';
24501
24502   if (profile != '\0')
24503     aeabi_set_attribute_int (Tag_CPU_arch_profile, profile);
24504
24505   /* Tag_ARM_ISA_use.  */
24506   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v1)
24507       || arch == 0)
24508     aeabi_set_attribute_int (Tag_ARM_ISA_use, 1);
24509
24510   /* Tag_THUMB_ISA_use.  */
24511   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v4t)
24512       || arch == 0)
24513     aeabi_set_attribute_int (Tag_THUMB_ISA_use,
24514         ARM_CPU_HAS_FEATURE (flags, arm_arch_t2) ? 2 : 1);
24515
24516   /* Tag_VFP_arch.  */
24517   if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_armv8))
24518     aeabi_set_attribute_int (Tag_VFP_arch, 7);
24519   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_fma))
24520     aeabi_set_attribute_int (Tag_VFP_arch,
24521                              ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_d32)
24522                              ? 5 : 6);
24523   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_d32))
24524     {
24525       fp16_optional = 1;
24526       aeabi_set_attribute_int (Tag_VFP_arch, 3);
24527     }
24528   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v3xd))
24529     {
24530       aeabi_set_attribute_int (Tag_VFP_arch, 4);
24531       fp16_optional = 1;
24532     }
24533   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v2))
24534     aeabi_set_attribute_int (Tag_VFP_arch, 2);
24535   else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1)
24536            || ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1xd))
24537     aeabi_set_attribute_int (Tag_VFP_arch, 1);
24538
24539   /* Tag_ABI_HardFP_use.  */
24540   if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1xd)
24541       && !ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1))
24542     aeabi_set_attribute_int (Tag_ABI_HardFP_use, 1);
24543
24544   /* Tag_WMMX_arch.  */
24545   if (ARM_CPU_HAS_FEATURE (flags, arm_cext_iwmmxt2))
24546     aeabi_set_attribute_int (Tag_WMMX_arch, 2);
24547   else if (ARM_CPU_HAS_FEATURE (flags, arm_cext_iwmmxt))
24548     aeabi_set_attribute_int (Tag_WMMX_arch, 1);
24549
24550   /* Tag_Advanced_SIMD_arch (formerly Tag_NEON_arch).  */
24551   if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_armv8))
24552     aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 3);
24553   else if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_v1))
24554     {
24555       if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_fma))
24556         {
24557           aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 2);
24558         }
24559       else
24560         {
24561           aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 1);
24562           fp16_optional = 1;
24563         }
24564     }
24565
24566   /* Tag_VFP_HP_extension (formerly Tag_NEON_FP16_arch).  */
24567   if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_fp16) && fp16_optional)
24568     aeabi_set_attribute_int (Tag_VFP_HP_extension, 1);
24569
24570   /* Tag_DIV_use.
24571
24572      We set Tag_DIV_use to two when integer divide instructions have been used
24573      in ARM state, or when Thumb integer divide instructions have been used,
24574      but we have no architecture profile set, nor have we any ARM instructions.
24575
24576      For ARMv8 we set the tag to 0 as integer divide is implied by the base
24577      architecture.
24578
24579      For new architectures we will have to check these tests.  */
24580   gas_assert (arch <= TAG_CPU_ARCH_V8);
24581   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v8))
24582     aeabi_set_attribute_int (Tag_DIV_use, 0);
24583   else if (ARM_CPU_HAS_FEATURE (flags, arm_ext_adiv)
24584            || (profile == '\0'
24585                && ARM_CPU_HAS_FEATURE (flags, arm_ext_div)
24586                && !ARM_CPU_HAS_FEATURE (arm_arch_used, arm_arch_any)))
24587     aeabi_set_attribute_int (Tag_DIV_use, 2);
24588
24589   /* Tag_MP_extension_use.  */
24590   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_mp))
24591     aeabi_set_attribute_int (Tag_MPextension_use, 1);
24592
24593   /* Tag Virtualization_use.  */
24594   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_sec))
24595     virt_sec |= 1;
24596   if (ARM_CPU_HAS_FEATURE (flags, arm_ext_virt))
24597     virt_sec |= 2;
24598   if (virt_sec != 0)
24599     aeabi_set_attribute_int (Tag_Virtualization_use, virt_sec);
24600 }
24601
24602 /* Add the default contents for the .ARM.attributes section.  */
24603 void
24604 arm_md_end (void)
24605 {
24606   if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
24607     return;
24608
24609   aeabi_set_public_attributes ();
24610 }
24611 #endif /* OBJ_ELF */
24612
24613
24614 /* Parse a .cpu directive.  */
24615
24616 static void
24617 s_arm_cpu (int ignored ATTRIBUTE_UNUSED)
24618 {
24619   const struct arm_cpu_option_table *opt;
24620   char *name;
24621   char saved_char;
24622
24623   name = input_line_pointer;
24624   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
24625     input_line_pointer++;
24626   saved_char = *input_line_pointer;
24627   *input_line_pointer = 0;
24628
24629   /* Skip the first "all" entry.  */
24630   for (opt = arm_cpus + 1; opt->name != NULL; opt++)
24631     if (streq (opt->name, name))
24632       {
24633         mcpu_cpu_opt = &opt->value;
24634         selected_cpu = opt->value;
24635         if (opt->canonical_name)
24636           strcpy (selected_cpu_name, opt->canonical_name);
24637         else
24638           {
24639             int i;
24640             for (i = 0; opt->name[i]; i++)
24641               selected_cpu_name[i] = TOUPPER (opt->name[i]);
24642
24643             selected_cpu_name[i] = 0;
24644           }
24645         ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
24646         *input_line_pointer = saved_char;
24647         demand_empty_rest_of_line ();
24648         return;
24649       }
24650   as_bad (_("unknown cpu `%s'"), name);
24651   *input_line_pointer = saved_char;
24652   ignore_rest_of_line ();
24653 }
24654
24655
24656 /* Parse a .arch directive.  */
24657
24658 static void
24659 s_arm_arch (int ignored ATTRIBUTE_UNUSED)
24660 {
24661   const struct arm_arch_option_table *opt;
24662   char saved_char;
24663   char *name;
24664
24665   name = input_line_pointer;
24666   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
24667     input_line_pointer++;
24668   saved_char = *input_line_pointer;
24669   *input_line_pointer = 0;
24670
24671   /* Skip the first "all" entry.  */
24672   for (opt = arm_archs + 1; opt->name != NULL; opt++)
24673     if (streq (opt->name, name))
24674       {
24675         mcpu_cpu_opt = &opt->value;
24676         selected_cpu = opt->value;
24677         strcpy (selected_cpu_name, opt->name);
24678         ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
24679         *input_line_pointer = saved_char;
24680         demand_empty_rest_of_line ();
24681         return;
24682       }
24683
24684   as_bad (_("unknown architecture `%s'\n"), name);
24685   *input_line_pointer = saved_char;
24686   ignore_rest_of_line ();
24687 }
24688
24689
24690 /* Parse a .object_arch directive.  */
24691
24692 static void
24693 s_arm_object_arch (int ignored ATTRIBUTE_UNUSED)
24694 {
24695   const struct arm_arch_option_table *opt;
24696   char saved_char;
24697   char *name;
24698
24699   name = input_line_pointer;
24700   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
24701     input_line_pointer++;
24702   saved_char = *input_line_pointer;
24703   *input_line_pointer = 0;
24704
24705   /* Skip the first "all" entry.  */
24706   for (opt = arm_archs + 1; opt->name != NULL; opt++)
24707     if (streq (opt->name, name))
24708       {
24709         object_arch = &opt->value;
24710         *input_line_pointer = saved_char;
24711         demand_empty_rest_of_line ();
24712         return;
24713       }
24714
24715   as_bad (_("unknown architecture `%s'\n"), name);
24716   *input_line_pointer = saved_char;
24717   ignore_rest_of_line ();
24718 }
24719
24720 /* Parse a .arch_extension directive.  */
24721
24722 static void
24723 s_arm_arch_extension (int ignored ATTRIBUTE_UNUSED)
24724 {
24725   const struct arm_option_extension_value_table *opt;
24726   char saved_char;
24727   char *name;
24728   int adding_value = 1;
24729
24730   name = input_line_pointer;
24731   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
24732     input_line_pointer++;
24733   saved_char = *input_line_pointer;
24734   *input_line_pointer = 0;
24735
24736   if (strlen (name) >= 2
24737       && strncmp (name, "no", 2) == 0)
24738     {
24739       adding_value = 0;
24740       name += 2;
24741     }
24742
24743   for (opt = arm_extensions; opt->name != NULL; opt++)
24744     if (streq (opt->name, name))
24745       {
24746         if (!ARM_CPU_HAS_FEATURE (*mcpu_cpu_opt, opt->allowed_archs))
24747           {
24748             as_bad (_("architectural extension `%s' is not allowed for the "
24749                       "current base architecture"), name);
24750             break;
24751           }
24752
24753         if (adding_value)
24754           ARM_MERGE_FEATURE_SETS (selected_cpu, selected_cpu, opt->value);
24755         else
24756           ARM_CLEAR_FEATURE (selected_cpu, selected_cpu, opt->value);
24757
24758         mcpu_cpu_opt = &selected_cpu;
24759         ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
24760         *input_line_pointer = saved_char;
24761         demand_empty_rest_of_line ();
24762         return;
24763       }
24764
24765   if (opt->name == NULL)
24766     as_bad (_("unknown architecture `%s'\n"), name);
24767
24768   *input_line_pointer = saved_char;
24769   ignore_rest_of_line ();
24770 }
24771
24772 /* Parse a .fpu directive.  */
24773
24774 static void
24775 s_arm_fpu (int ignored ATTRIBUTE_UNUSED)
24776 {
24777   const struct arm_option_fpu_value_table *opt;
24778   char saved_char;
24779   char *name;
24780
24781   name = input_line_pointer;
24782   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
24783     input_line_pointer++;
24784   saved_char = *input_line_pointer;
24785   *input_line_pointer = 0;
24786
24787   for (opt = arm_fpus; opt->name != NULL; opt++)
24788     if (streq (opt->name, name))
24789       {
24790         mfpu_opt = &opt->value;
24791         ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
24792         *input_line_pointer = saved_char;
24793         demand_empty_rest_of_line ();
24794         return;
24795       }
24796
24797   as_bad (_("unknown floating point format `%s'\n"), name);
24798   *input_line_pointer = saved_char;
24799   ignore_rest_of_line ();
24800 }
24801
24802 /* Copy symbol information.  */
24803
24804 void
24805 arm_copy_symbol_attributes (symbolS *dest, symbolS *src)
24806 {
24807   ARM_GET_FLAG (dest) = ARM_GET_FLAG (src);
24808 }
24809
24810 #ifdef OBJ_ELF
24811 /* Given a symbolic attribute NAME, return the proper integer value.
24812    Returns -1 if the attribute is not known.  */
24813
24814 int
24815 arm_convert_symbolic_attribute (const char *name)
24816 {
24817   static const struct
24818   {
24819     const char * name;
24820     const int    tag;
24821   }
24822   attribute_table[] =
24823     {
24824       /* When you modify this table you should
24825          also modify the list in doc/c-arm.texi.  */
24826 #define T(tag) {#tag, tag}
24827       T (Tag_CPU_raw_name),
24828       T (Tag_CPU_name),
24829       T (Tag_CPU_arch),
24830       T (Tag_CPU_arch_profile),
24831       T (Tag_ARM_ISA_use),
24832       T (Tag_THUMB_ISA_use),
24833       T (Tag_FP_arch),
24834       T (Tag_VFP_arch),
24835       T (Tag_WMMX_arch),
24836       T (Tag_Advanced_SIMD_arch),
24837       T (Tag_PCS_config),
24838       T (Tag_ABI_PCS_R9_use),
24839       T (Tag_ABI_PCS_RW_data),
24840       T (Tag_ABI_PCS_RO_data),
24841       T (Tag_ABI_PCS_GOT_use),
24842       T (Tag_ABI_PCS_wchar_t),
24843       T (Tag_ABI_FP_rounding),
24844       T (Tag_ABI_FP_denormal),
24845       T (Tag_ABI_FP_exceptions),
24846       T (Tag_ABI_FP_user_exceptions),
24847       T (Tag_ABI_FP_number_model),
24848       T (Tag_ABI_align_needed),
24849       T (Tag_ABI_align8_needed),
24850       T (Tag_ABI_align_preserved),
24851       T (Tag_ABI_align8_preserved),
24852       T (Tag_ABI_enum_size),
24853       T (Tag_ABI_HardFP_use),
24854       T (Tag_ABI_VFP_args),
24855       T (Tag_ABI_WMMX_args),
24856       T (Tag_ABI_optimization_goals),
24857       T (Tag_ABI_FP_optimization_goals),
24858       T (Tag_compatibility),
24859       T (Tag_CPU_unaligned_access),
24860       T (Tag_FP_HP_extension),
24861       T (Tag_VFP_HP_extension),
24862       T (Tag_ABI_FP_16bit_format),
24863       T (Tag_MPextension_use),
24864       T (Tag_DIV_use),
24865       T (Tag_nodefaults),
24866       T (Tag_also_compatible_with),
24867       T (Tag_conformance),
24868       T (Tag_T2EE_use),
24869       T (Tag_Virtualization_use),
24870       /* We deliberately do not include Tag_MPextension_use_legacy.  */
24871 #undef T
24872     };
24873   unsigned int i;
24874
24875   if (name == NULL)
24876     return -1;
24877
24878   for (i = 0; i < ARRAY_SIZE (attribute_table); i++)
24879     if (streq (name, attribute_table[i].name))
24880       return attribute_table[i].tag;
24881
24882   return -1;
24883 }
24884
24885
24886 /* Apply sym value for relocations only in the case that
24887    they are for local symbols and you have the respective
24888    architectural feature for blx and simple switches.  */
24889 int
24890 arm_apply_sym_value (struct fix * fixP)
24891 {
24892   if (fixP->fx_addsy
24893       && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
24894       && !S_FORCE_RELOC (fixP->fx_addsy, TRUE))
24895     {
24896       switch (fixP->fx_r_type)
24897         {
24898         case BFD_RELOC_ARM_PCREL_BLX:
24899         case BFD_RELOC_THUMB_PCREL_BRANCH23:
24900           if (ARM_IS_FUNC (fixP->fx_addsy))
24901             return 1;
24902           break;
24903
24904         case BFD_RELOC_ARM_PCREL_CALL:
24905         case BFD_RELOC_THUMB_PCREL_BLX:
24906           if (THUMB_IS_FUNC (fixP->fx_addsy))
24907               return 1;
24908           break;
24909
24910         default:
24911           break;
24912         }
24913
24914     }
24915   return 0;
24916 }
24917 #endif /* OBJ_ELF */