1 /* tc-arm.c -- Assemble for the ARM
2 Copyright (C) 1994-2014 Free Software Foundation, Inc.
3 Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
4 Modified by David Taylor (dtaylor@armltd.co.uk)
5 Cirrus coprocessor mods by Aldy Hernandez (aldyh@redhat.com)
6 Cirrus coprocessor fixes by Petko Manolov (petkan@nucleusys.com)
7 Cirrus coprocessor fixes by Vladimir Ivanov (vladitx@nucleusys.com)
9 This file is part of GAS, the GNU Assembler.
11 GAS is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
16 GAS is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GAS; see the file COPYING. If not, write to the Free
23 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
30 #include "safe-ctype.h"
33 #include "libiberty.h"
34 #include "opcode/arm.h"
38 #include "dw2gencfi.h"
41 #include "dwarf2dbg.h"
44 /* Must be at least the size of the largest unwind opcode (currently two). */
45 #define ARM_OPCODE_CHUNK_SIZE 8
47 /* This structure holds the unwinding state. */
52 symbolS * table_entry;
53 symbolS * personality_routine;
54 int personality_index;
55 /* The segment containing the function. */
58 /* Opcodes generated from this function. */
59 unsigned char * opcodes;
62 /* The number of bytes pushed to the stack. */
64 /* We don't add stack adjustment opcodes immediately so that we can merge
65 multiple adjustments. We can also omit the final adjustment
66 when using a frame pointer. */
67 offsetT pending_offset;
68 /* These two fields are set by both unwind_movsp and unwind_setfp. They
69 hold the reg+offset to use when restoring sp from a frame pointer. */
72 /* Nonzero if an unwind_setfp directive has been seen. */
74 /* Nonzero if the last opcode restores sp from fp_reg. */
75 unsigned sp_restored:1;
80 /* Results from operand parsing worker functions. */
84 PARSE_OPERAND_SUCCESS,
86 PARSE_OPERAND_FAIL_NO_BACKTRACK
87 } parse_operand_result;
96 /* Types of processor to assemble for. */
98 /* The code that was here used to select a default CPU depending on compiler
99 pre-defines which were only present when doing native builds, thus
100 changing gas' default behaviour depending upon the build host.
102 If you have a target that requires a default CPU option then the you
103 should define CPU_DEFAULT here. */
108 # define FPU_DEFAULT FPU_ARCH_FPA
109 # elif defined (TE_NetBSD)
111 # define FPU_DEFAULT FPU_ARCH_VFP /* Soft-float, but VFP order. */
113 /* Legacy a.out format. */
114 # define FPU_DEFAULT FPU_ARCH_FPA /* Soft-float, but FPA order. */
116 # elif defined (TE_VXWORKS)
117 # define FPU_DEFAULT FPU_ARCH_VFP /* Soft-float, VFP order. */
119 /* For backwards compatibility, default to FPA. */
120 # define FPU_DEFAULT FPU_ARCH_FPA
122 #endif /* ifndef FPU_DEFAULT */
124 #define streq(a, b) (strcmp (a, b) == 0)
126 static arm_feature_set cpu_variant;
127 static arm_feature_set arm_arch_used;
128 static arm_feature_set thumb_arch_used;
130 /* Flags stored in private area of BFD structure. */
131 static int uses_apcs_26 = FALSE;
132 static int atpcs = FALSE;
133 static int support_interwork = FALSE;
134 static int uses_apcs_float = FALSE;
135 static int pic_code = FALSE;
136 static int fix_v4bx = FALSE;
137 /* Warn on using deprecated features. */
138 static int warn_on_deprecated = TRUE;
140 /* Understand CodeComposer Studio assembly syntax. */
141 bfd_boolean codecomposer_syntax = FALSE;
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
146 static const arm_feature_set *legacy_cpu = NULL;
147 static const arm_feature_set *legacy_fpu = NULL;
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;
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;
168 static const arm_feature_set cpu_default = CPU_DEFAULT;
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);
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;
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_vfp_ext_armv8xd =
240 ARM_FEATURE (0, FPU_VFP_EXT_ARMV8xD);
241 static const arm_feature_set fpu_neon_ext_armv8 =
242 ARM_FEATURE (0, FPU_NEON_EXT_ARMV8);
243 static const arm_feature_set fpu_crypto_ext_armv8 =
244 ARM_FEATURE (0, FPU_CRYPTO_EXT_ARMV8);
245 static const arm_feature_set crc_ext_armv8 =
246 ARM_FEATURE (0, CRC_EXT_ARMV8);
248 static int mfloat_abi_opt = -1;
249 /* Record user cpu selection for object attributes. */
250 static arm_feature_set selected_cpu = ARM_ARCH_NONE;
251 /* Must be long enough to hold any of the names in arm_cpus. */
252 static char selected_cpu_name[16];
254 extern FLONUM_TYPE generic_floating_point_number;
256 /* Return if no cpu was selected on command-line. */
258 no_cpu_selected (void)
260 return selected_cpu.core == arm_arch_none.core
261 && selected_cpu.coproc == arm_arch_none.coproc;
266 static int meabi_flags = EABI_DEFAULT;
268 static int meabi_flags = EF_ARM_EABI_UNKNOWN;
271 static int attributes_set_explicitly[NUM_KNOWN_OBJ_ATTRIBUTES];
276 return (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4);
281 /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
282 symbolS * GOT_symbol;
285 /* 0: assemble for ARM,
286 1: assemble for Thumb,
287 2: assemble for Thumb even though target CPU does not support thumb
289 static int thumb_mode = 0;
290 /* A value distinct from the possible values for thumb_mode that we
291 can use to record whether thumb_mode has been copied into the
292 tc_frag_data field of a frag. */
293 #define MODE_RECORDED (1 << 4)
295 /* Specifies the intrinsic IT insn behavior mode. */
296 enum implicit_it_mode
298 IMPLICIT_IT_MODE_NEVER = 0x00,
299 IMPLICIT_IT_MODE_ARM = 0x01,
300 IMPLICIT_IT_MODE_THUMB = 0x02,
301 IMPLICIT_IT_MODE_ALWAYS = (IMPLICIT_IT_MODE_ARM | IMPLICIT_IT_MODE_THUMB)
303 static int implicit_it_mode = IMPLICIT_IT_MODE_ARM;
305 /* If unified_syntax is true, we are processing the new unified
306 ARM/Thumb syntax. Important differences from the old ARM mode:
308 - Immediate operands do not require a # prefix.
309 - Conditional affixes always appear at the end of the
310 instruction. (For backward compatibility, those instructions
311 that formerly had them in the middle, continue to accept them
313 - The IT instruction may appear, and if it does is validated
314 against subsequent conditional affixes. It does not generate
317 Important differences from the old Thumb mode:
319 - Immediate operands do not require a # prefix.
320 - Most of the V6T2 instructions are only available in unified mode.
321 - The .N and .W suffixes are recognized and honored (it is an error
322 if they cannot be honored).
323 - All instructions set the flags if and only if they have an 's' affix.
324 - Conditional affixes may be used. They are validated against
325 preceding IT instructions. Unlike ARM mode, you cannot use a
326 conditional affix except in the scope of an IT instruction. */
328 static bfd_boolean unified_syntax = FALSE;
330 /* An immediate operand can start with #, and ld*, st*, pld operands
331 can contain [ and ]. We need to tell APP not to elide whitespace
332 before a [, which can appear as the first operand for pld.
333 Likewise, a { can appear as the first operand for push, pop, vld*, etc. */
334 const char arm_symbol_chars[] = "#[]{}";
349 enum neon_el_type type;
353 #define NEON_MAX_TYPE_ELS 4
357 struct neon_type_el el[NEON_MAX_TYPE_ELS];
361 enum it_instruction_type
366 IF_INSIDE_IT_LAST_INSN, /* Either outside or inside;
367 if inside, should be the last one. */
368 NEUTRAL_IT_INSN, /* This could be either inside or outside,
369 i.e. BKPT and NOP. */
370 IT_INSN /* The IT insn has been parsed. */
373 /* The maximum number of operands we need. */
374 #define ARM_IT_MAX_OPERANDS 6
379 unsigned long instruction;
383 /* "uncond_value" is set to the value in place of the conditional field in
384 unconditional versions of the instruction, or -1 if nothing is
387 struct neon_type vectype;
388 /* This does not indicate an actual NEON instruction, only that
389 the mnemonic accepts neon-style type suffixes. */
391 /* Set to the opcode if the instruction needs relaxation.
392 Zero if the instruction is not relaxed. */
396 bfd_reloc_code_real_type type;
401 enum it_instruction_type it_insn_type;
407 struct neon_type_el vectype;
408 unsigned present : 1; /* Operand present. */
409 unsigned isreg : 1; /* Operand was a register. */
410 unsigned immisreg : 1; /* .imm field is a second register. */
411 unsigned isscalar : 1; /* Operand is a (Neon) scalar. */
412 unsigned immisalign : 1; /* Immediate is an alignment specifier. */
413 unsigned immisfloat : 1; /* Immediate was parsed as a float. */
414 /* Note: we abuse "regisimm" to mean "is Neon register" in VMOV
415 instructions. This allows us to disambiguate ARM <-> vector insns. */
416 unsigned regisimm : 1; /* 64-bit immediate, reg forms high 32 bits. */
417 unsigned isvec : 1; /* Is a single, double or quad VFP/Neon reg. */
418 unsigned isquad : 1; /* Operand is Neon quad-precision register. */
419 unsigned issingle : 1; /* Operand is VFP single-precision register. */
420 unsigned hasreloc : 1; /* Operand has relocation suffix. */
421 unsigned writeback : 1; /* Operand has trailing ! */
422 unsigned preind : 1; /* Preindexed address. */
423 unsigned postind : 1; /* Postindexed address. */
424 unsigned negative : 1; /* Index register was negated. */
425 unsigned shifted : 1; /* Shift applied to operation. */
426 unsigned shift_kind : 3; /* Shift operation (enum shift_kind). */
427 } operands[ARM_IT_MAX_OPERANDS];
430 static struct arm_it inst;
432 #define NUM_FLOAT_VALS 8
434 const char * fp_const[] =
436 "0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0", 0
439 /* Number of littlenums required to hold an extended precision number. */
440 #define MAX_LITTLENUMS 6
442 LITTLENUM_TYPE fp_values[NUM_FLOAT_VALS][MAX_LITTLENUMS];
452 #define CP_T_X 0x00008000
453 #define CP_T_Y 0x00400000
455 #define CONDS_BIT 0x00100000
456 #define LOAD_BIT 0x00100000
458 #define DOUBLE_LOAD_FLAG 0x00000001
462 const char * template_name;
466 #define COND_ALWAYS 0xE
470 const char * template_name;
474 struct asm_barrier_opt
476 const char * template_name;
478 const arm_feature_set arch;
481 /* The bit that distinguishes CPSR and SPSR. */
482 #define SPSR_BIT (1 << 22)
484 /* The individual PSR flag bits. */
485 #define PSR_c (1 << 16)
486 #define PSR_x (1 << 17)
487 #define PSR_s (1 << 18)
488 #define PSR_f (1 << 19)
493 bfd_reloc_code_real_type reloc;
498 VFP_REG_Sd, VFP_REG_Sm, VFP_REG_Sn,
499 VFP_REG_Dd, VFP_REG_Dm, VFP_REG_Dn
504 VFP_LDSTMIA, VFP_LDSTMDB, VFP_LDSTMIAX, VFP_LDSTMDBX
507 /* Bits for DEFINED field in neon_typed_alias. */
508 #define NTA_HASTYPE 1
509 #define NTA_HASINDEX 2
511 struct neon_typed_alias
513 unsigned char defined;
515 struct neon_type_el eltype;
518 /* ARM register categories. This includes coprocessor numbers and various
519 architecture extensions' registers. */
546 /* Structure for a hash table entry for a register.
547 If TYPE is REG_TYPE_VFD or REG_TYPE_NQ, the NEON field can point to extra
548 information which states whether a vector type or index is specified (for a
549 register alias created with .dn or .qn). Otherwise NEON should be NULL. */
555 unsigned char builtin;
556 struct neon_typed_alias * neon;
559 /* Diagnostics used when we don't get a register of the expected type. */
560 const char * const reg_expected_msgs[] =
562 N_("ARM register expected"),
563 N_("bad or missing co-processor number"),
564 N_("co-processor register expected"),
565 N_("FPA register expected"),
566 N_("VFP single precision register expected"),
567 N_("VFP/Neon double precision register expected"),
568 N_("Neon quad precision register expected"),
569 N_("VFP single or double precision register expected"),
570 N_("Neon double or quad precision register expected"),
571 N_("VFP single, double or Neon quad precision register expected"),
572 N_("VFP system register expected"),
573 N_("Maverick MVF register expected"),
574 N_("Maverick MVD register expected"),
575 N_("Maverick MVFX register expected"),
576 N_("Maverick MVDX register expected"),
577 N_("Maverick MVAX register expected"),
578 N_("Maverick DSPSC register expected"),
579 N_("iWMMXt data register expected"),
580 N_("iWMMXt control register expected"),
581 N_("iWMMXt scalar register expected"),
582 N_("XScale accumulator register expected"),
585 /* Some well known registers that we refer to directly elsewhere. */
591 /* ARM instructions take 4bytes in the object file, Thumb instructions
597 /* Basic string to match. */
598 const char * template_name;
600 /* Parameters to instruction. */
601 unsigned int operands[8];
603 /* Conditional tag - see opcode_lookup. */
604 unsigned int tag : 4;
606 /* Basic instruction code. */
607 unsigned int avalue : 28;
609 /* Thumb-format instruction code. */
612 /* Which architecture variant provides this instruction. */
613 const arm_feature_set * avariant;
614 const arm_feature_set * tvariant;
616 /* Function to call to encode instruction in ARM format. */
617 void (* aencode) (void);
619 /* Function to call to encode instruction in Thumb format. */
620 void (* tencode) (void);
623 /* Defines for various bits that we will want to toggle. */
624 #define INST_IMMEDIATE 0x02000000
625 #define OFFSET_REG 0x02000000
626 #define HWOFFSET_IMM 0x00400000
627 #define SHIFT_BY_REG 0x00000010
628 #define PRE_INDEX 0x01000000
629 #define INDEX_UP 0x00800000
630 #define WRITE_BACK 0x00200000
631 #define LDM_TYPE_2_OR_3 0x00400000
632 #define CPSI_MMOD 0x00020000
634 #define LITERAL_MASK 0xf000f000
635 #define OPCODE_MASK 0xfe1fffff
636 #define V4_STR_BIT 0x00000020
637 #define VLDR_VMOV_SAME 0x0040f000
639 #define T2_SUBS_PC_LR 0xf3de8f00
641 #define DATA_OP_SHIFT 21
643 #define T2_OPCODE_MASK 0xfe1fffff
644 #define T2_DATA_OP_SHIFT 21
646 #define A_COND_MASK 0xf0000000
647 #define A_PUSH_POP_OP_MASK 0x0fff0000
649 /* Opcodes for pushing/poping registers to/from the stack. */
650 #define A1_OPCODE_PUSH 0x092d0000
651 #define A2_OPCODE_PUSH 0x052d0004
652 #define A2_OPCODE_POP 0x049d0004
654 /* Codes to distinguish the arithmetic instructions. */
665 #define OPCODE_CMP 10
666 #define OPCODE_CMN 11
667 #define OPCODE_ORR 12
668 #define OPCODE_MOV 13
669 #define OPCODE_BIC 14
670 #define OPCODE_MVN 15
672 #define T2_OPCODE_AND 0
673 #define T2_OPCODE_BIC 1
674 #define T2_OPCODE_ORR 2
675 #define T2_OPCODE_ORN 3
676 #define T2_OPCODE_EOR 4
677 #define T2_OPCODE_ADD 8
678 #define T2_OPCODE_ADC 10
679 #define T2_OPCODE_SBC 11
680 #define T2_OPCODE_SUB 13
681 #define T2_OPCODE_RSB 14
683 #define T_OPCODE_MUL 0x4340
684 #define T_OPCODE_TST 0x4200
685 #define T_OPCODE_CMN 0x42c0
686 #define T_OPCODE_NEG 0x4240
687 #define T_OPCODE_MVN 0x43c0
689 #define T_OPCODE_ADD_R3 0x1800
690 #define T_OPCODE_SUB_R3 0x1a00
691 #define T_OPCODE_ADD_HI 0x4400
692 #define T_OPCODE_ADD_ST 0xb000
693 #define T_OPCODE_SUB_ST 0xb080
694 #define T_OPCODE_ADD_SP 0xa800
695 #define T_OPCODE_ADD_PC 0xa000
696 #define T_OPCODE_ADD_I8 0x3000
697 #define T_OPCODE_SUB_I8 0x3800
698 #define T_OPCODE_ADD_I3 0x1c00
699 #define T_OPCODE_SUB_I3 0x1e00
701 #define T_OPCODE_ASR_R 0x4100
702 #define T_OPCODE_LSL_R 0x4080
703 #define T_OPCODE_LSR_R 0x40c0
704 #define T_OPCODE_ROR_R 0x41c0
705 #define T_OPCODE_ASR_I 0x1000
706 #define T_OPCODE_LSL_I 0x0000
707 #define T_OPCODE_LSR_I 0x0800
709 #define T_OPCODE_MOV_I8 0x2000
710 #define T_OPCODE_CMP_I8 0x2800
711 #define T_OPCODE_CMP_LR 0x4280
712 #define T_OPCODE_MOV_HR 0x4600
713 #define T_OPCODE_CMP_HR 0x4500
715 #define T_OPCODE_LDR_PC 0x4800
716 #define T_OPCODE_LDR_SP 0x9800
717 #define T_OPCODE_STR_SP 0x9000
718 #define T_OPCODE_LDR_IW 0x6800
719 #define T_OPCODE_STR_IW 0x6000
720 #define T_OPCODE_LDR_IH 0x8800
721 #define T_OPCODE_STR_IH 0x8000
722 #define T_OPCODE_LDR_IB 0x7800
723 #define T_OPCODE_STR_IB 0x7000
724 #define T_OPCODE_LDR_RW 0x5800
725 #define T_OPCODE_STR_RW 0x5000
726 #define T_OPCODE_LDR_RH 0x5a00
727 #define T_OPCODE_STR_RH 0x5200
728 #define T_OPCODE_LDR_RB 0x5c00
729 #define T_OPCODE_STR_RB 0x5400
731 #define T_OPCODE_PUSH 0xb400
732 #define T_OPCODE_POP 0xbc00
734 #define T_OPCODE_BRANCH 0xe000
736 #define THUMB_SIZE 2 /* Size of thumb instruction. */
737 #define THUMB_PP_PC_LR 0x0100
738 #define THUMB_LOAD_BIT 0x0800
739 #define THUMB2_LOAD_BIT 0x00100000
741 #define BAD_ARGS _("bad arguments to instruction")
742 #define BAD_SP _("r13 not allowed here")
743 #define BAD_PC _("r15 not allowed here")
744 #define BAD_COND _("instruction cannot be conditional")
745 #define BAD_OVERLAP _("registers may not be the same")
746 #define BAD_HIREG _("lo register required")
747 #define BAD_THUMB32 _("instruction not supported in Thumb16 mode")
748 #define BAD_ADDR_MODE _("instruction does not accept this addressing mode");
749 #define BAD_BRANCH _("branch must be last instruction in IT block")
750 #define BAD_NOT_IT _("instruction not allowed in IT block")
751 #define BAD_FPU _("selected FPU does not support instruction")
752 #define BAD_OUT_IT _("thumb conditional instruction should be in IT block")
753 #define BAD_IT_COND _("incorrect condition in IT block")
754 #define BAD_IT_IT _("IT falling in the range of a previous IT block")
755 #define MISSING_FNSTART _("missing .fnstart before unwinding directive")
756 #define BAD_PC_ADDRESSING \
757 _("cannot use register index with PC-relative addressing")
758 #define BAD_PC_WRITEBACK \
759 _("cannot use writeback with PC-relative addressing")
760 #define BAD_RANGE _("branch out of range")
761 #define UNPRED_REG(R) _("using " R " results in unpredictable behaviour")
763 static struct hash_control * arm_ops_hsh;
764 static struct hash_control * arm_cond_hsh;
765 static struct hash_control * arm_shift_hsh;
766 static struct hash_control * arm_psr_hsh;
767 static struct hash_control * arm_v7m_psr_hsh;
768 static struct hash_control * arm_reg_hsh;
769 static struct hash_control * arm_reloc_hsh;
770 static struct hash_control * arm_barrier_opt_hsh;
772 /* Stuff needed to resolve the label ambiguity
781 symbolS * last_label_seen;
782 static int label_is_thumb_function_name = FALSE;
784 /* Literal pool structure. Held on a per-section
785 and per-sub-section basis. */
787 #define MAX_LITERAL_POOL_SIZE 1024
788 typedef struct literal_pool
790 expressionS literals [MAX_LITERAL_POOL_SIZE];
791 unsigned int next_free_entry;
797 struct dwarf2_line_info locs [MAX_LITERAL_POOL_SIZE];
799 struct literal_pool * next;
800 unsigned int alignment;
803 /* Pointer to a linked list of literal pools. */
804 literal_pool * list_of_pools = NULL;
806 typedef enum asmfunc_states
809 WAITING_ASMFUNC_NAME,
813 static asmfunc_states asmfunc_state = OUTSIDE_ASMFUNC;
816 # define now_it seg_info (now_seg)->tc_segment_info_data.current_it
818 static struct current_it now_it;
822 now_it_compatible (int cond)
824 return (cond & ~1) == (now_it.cc & ~1);
828 conditional_insn (void)
830 return inst.cond != COND_ALWAYS;
833 static int in_it_block (void);
835 static int handle_it_state (void);
837 static void force_automatic_it_block_close (void);
839 static void it_fsm_post_encode (void);
841 #define set_it_insn_type(type) \
844 inst.it_insn_type = type; \
845 if (handle_it_state () == FAIL) \
850 #define set_it_insn_type_nonvoid(type, failret) \
853 inst.it_insn_type = type; \
854 if (handle_it_state () == FAIL) \
859 #define set_it_insn_type_last() \
862 if (inst.cond == COND_ALWAYS) \
863 set_it_insn_type (IF_INSIDE_IT_LAST_INSN); \
865 set_it_insn_type (INSIDE_IT_LAST_INSN); \
871 /* This array holds the chars that always start a comment. If the
872 pre-processor is disabled, these aren't very useful. */
873 char arm_comment_chars[] = "@";
875 /* This array holds the chars that only start a comment at the beginning of
876 a line. If the line seems to have the form '# 123 filename'
877 .line and .file directives will appear in the pre-processed output. */
878 /* Note that input_file.c hand checks for '#' at the beginning of the
879 first line of the input file. This is because the compiler outputs
880 #NO_APP at the beginning of its output. */
881 /* Also note that comments like this one will always work. */
882 const char line_comment_chars[] = "#";
884 char arm_line_separator_chars[] = ";";
886 /* Chars that can be used to separate mant
887 from exp in floating point numbers. */
888 const char EXP_CHARS[] = "eE";
890 /* Chars that mean this number is a floating point constant. */
894 const char FLT_CHARS[] = "rRsSfFdDxXeEpP";
896 /* Prefix characters that indicate the start of an immediate
898 #define is_immediate_prefix(C) ((C) == '#' || (C) == '$')
900 /* Separator character handling. */
902 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
905 skip_past_char (char ** str, char c)
907 /* PR gas/14987: Allow for whitespace before the expected character. */
908 skip_whitespace (*str);
919 #define skip_past_comma(str) skip_past_char (str, ',')
921 /* Arithmetic expressions (possibly involving symbols). */
923 /* Return TRUE if anything in the expression is a bignum. */
926 walk_no_bignums (symbolS * sp)
928 if (symbol_get_value_expression (sp)->X_op == O_big)
931 if (symbol_get_value_expression (sp)->X_add_symbol)
933 return (walk_no_bignums (symbol_get_value_expression (sp)->X_add_symbol)
934 || (symbol_get_value_expression (sp)->X_op_symbol
935 && walk_no_bignums (symbol_get_value_expression (sp)->X_op_symbol)));
941 static int in_my_get_expression = 0;
943 /* Third argument to my_get_expression. */
944 #define GE_NO_PREFIX 0
945 #define GE_IMM_PREFIX 1
946 #define GE_OPT_PREFIX 2
947 /* This is a bit of a hack. Use an optional prefix, and also allow big (64-bit)
948 immediates, as can be used in Neon VMVN and VMOV immediate instructions. */
949 #define GE_OPT_PREFIX_BIG 3
952 my_get_expression (expressionS * ep, char ** str, int prefix_mode)
957 /* In unified syntax, all prefixes are optional. */
959 prefix_mode = (prefix_mode == GE_OPT_PREFIX_BIG) ? prefix_mode
964 case GE_NO_PREFIX: break;
966 if (!is_immediate_prefix (**str))
968 inst.error = _("immediate expression requires a # prefix");
974 case GE_OPT_PREFIX_BIG:
975 if (is_immediate_prefix (**str))
981 memset (ep, 0, sizeof (expressionS));
983 save_in = input_line_pointer;
984 input_line_pointer = *str;
985 in_my_get_expression = 1;
986 seg = expression (ep);
987 in_my_get_expression = 0;
989 if (ep->X_op == O_illegal || ep->X_op == O_absent)
991 /* We found a bad or missing expression in md_operand(). */
992 *str = input_line_pointer;
993 input_line_pointer = save_in;
994 if (inst.error == NULL)
995 inst.error = (ep->X_op == O_absent
996 ? _("missing expression") :_("bad expression"));
1001 if (seg != absolute_section
1002 && seg != text_section
1003 && seg != data_section
1004 && seg != bss_section
1005 && seg != undefined_section)
1007 inst.error = _("bad segment");
1008 *str = input_line_pointer;
1009 input_line_pointer = save_in;
1016 /* Get rid of any bignums now, so that we don't generate an error for which
1017 we can't establish a line number later on. Big numbers are never valid
1018 in instructions, which is where this routine is always called. */
1019 if (prefix_mode != GE_OPT_PREFIX_BIG
1020 && (ep->X_op == O_big
1021 || (ep->X_add_symbol
1022 && (walk_no_bignums (ep->X_add_symbol)
1024 && walk_no_bignums (ep->X_op_symbol))))))
1026 inst.error = _("invalid constant");
1027 *str = input_line_pointer;
1028 input_line_pointer = save_in;
1032 *str = input_line_pointer;
1033 input_line_pointer = save_in;
1037 /* Turn a string in input_line_pointer into a floating point constant
1038 of type TYPE, and store the appropriate bytes in *LITP. The number
1039 of LITTLENUMS emitted is stored in *SIZEP. An error message is
1040 returned, or NULL on OK.
1042 Note that fp constants aren't represent in the normal way on the ARM.
1043 In big endian mode, things are as expected. However, in little endian
1044 mode fp constants are big-endian word-wise, and little-endian byte-wise
1045 within the words. For example, (double) 1.1 in big endian mode is
1046 the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is
1047 the byte sequence 99 99 f1 3f 9a 99 99 99.
1049 ??? The format of 12 byte floats is uncertain according to gcc's arm.h. */
1052 md_atof (int type, char * litP, int * sizeP)
1055 LITTLENUM_TYPE words[MAX_LITTLENUMS];
1087 return _("Unrecognized or unsupported floating point constant");
1090 t = atof_ieee (input_line_pointer, type, words);
1092 input_line_pointer = t;
1093 *sizeP = prec * sizeof (LITTLENUM_TYPE);
1095 if (target_big_endian)
1097 for (i = 0; i < prec; i++)
1099 md_number_to_chars (litP, (valueT) words[i], sizeof (LITTLENUM_TYPE));
1100 litP += sizeof (LITTLENUM_TYPE);
1105 if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_endian_pure))
1106 for (i = prec - 1; i >= 0; i--)
1108 md_number_to_chars (litP, (valueT) words[i], sizeof (LITTLENUM_TYPE));
1109 litP += sizeof (LITTLENUM_TYPE);
1112 /* For a 4 byte float the order of elements in `words' is 1 0.
1113 For an 8 byte float the order is 1 0 3 2. */
1114 for (i = 0; i < prec; i += 2)
1116 md_number_to_chars (litP, (valueT) words[i + 1],
1117 sizeof (LITTLENUM_TYPE));
1118 md_number_to_chars (litP + sizeof (LITTLENUM_TYPE),
1119 (valueT) words[i], sizeof (LITTLENUM_TYPE));
1120 litP += 2 * sizeof (LITTLENUM_TYPE);
1127 /* We handle all bad expressions here, so that we can report the faulty
1128 instruction in the error message. */
1130 md_operand (expressionS * exp)
1132 if (in_my_get_expression)
1133 exp->X_op = O_illegal;
1136 /* Immediate values. */
1138 /* Generic immediate-value read function for use in directives.
1139 Accepts anything that 'expression' can fold to a constant.
1140 *val receives the number. */
1143 immediate_for_directive (int *val)
1146 exp.X_op = O_illegal;
1148 if (is_immediate_prefix (*input_line_pointer))
1150 input_line_pointer++;
1154 if (exp.X_op != O_constant)
1156 as_bad (_("expected #constant"));
1157 ignore_rest_of_line ();
1160 *val = exp.X_add_number;
1165 /* Register parsing. */
1167 /* Generic register parser. CCP points to what should be the
1168 beginning of a register name. If it is indeed a valid register
1169 name, advance CCP over it and return the reg_entry structure;
1170 otherwise return NULL. Does not issue diagnostics. */
1172 static struct reg_entry *
1173 arm_reg_parse_multi (char **ccp)
1177 struct reg_entry *reg;
1179 skip_whitespace (start);
1181 #ifdef REGISTER_PREFIX
1182 if (*start != REGISTER_PREFIX)
1186 #ifdef OPTIONAL_REGISTER_PREFIX
1187 if (*start == OPTIONAL_REGISTER_PREFIX)
1192 if (!ISALPHA (*p) || !is_name_beginner (*p))
1197 while (ISALPHA (*p) || ISDIGIT (*p) || *p == '_');
1199 reg = (struct reg_entry *) hash_find_n (arm_reg_hsh, start, p - start);
1209 arm_reg_alt_syntax (char **ccp, char *start, struct reg_entry *reg,
1210 enum arm_reg_type type)
1212 /* Alternative syntaxes are accepted for a few register classes. */
1219 /* Generic coprocessor register names are allowed for these. */
1220 if (reg && reg->type == REG_TYPE_CN)
1225 /* For backward compatibility, a bare number is valid here. */
1227 unsigned long processor = strtoul (start, ccp, 10);
1228 if (*ccp != start && processor <= 15)
1232 case REG_TYPE_MMXWC:
1233 /* WC includes WCG. ??? I'm not sure this is true for all
1234 instructions that take WC registers. */
1235 if (reg && reg->type == REG_TYPE_MMXWCG)
1246 /* As arm_reg_parse_multi, but the register must be of type TYPE, and the
1247 return value is the register number or FAIL. */
1250 arm_reg_parse (char **ccp, enum arm_reg_type type)
1253 struct reg_entry *reg = arm_reg_parse_multi (ccp);
1256 /* Do not allow a scalar (reg+index) to parse as a register. */
1257 if (reg && reg->neon && (reg->neon->defined & NTA_HASINDEX))
1260 if (reg && reg->type == type)
1263 if ((ret = arm_reg_alt_syntax (ccp, start, reg, type)) != FAIL)
1270 /* Parse a Neon type specifier. *STR should point at the leading '.'
1271 character. Does no verification at this stage that the type fits the opcode
1278 Can all be legally parsed by this function.
1280 Fills in neon_type struct pointer with parsed information, and updates STR
1281 to point after the parsed type specifier. Returns SUCCESS if this was a legal
1282 type, FAIL if not. */
1285 parse_neon_type (struct neon_type *type, char **str)
1292 while (type->elems < NEON_MAX_TYPE_ELS)
1294 enum neon_el_type thistype = NT_untyped;
1295 unsigned thissize = -1u;
1302 /* Just a size without an explicit type. */
1306 switch (TOLOWER (*ptr))
1308 case 'i': thistype = NT_integer; break;
1309 case 'f': thistype = NT_float; break;
1310 case 'p': thistype = NT_poly; break;
1311 case 's': thistype = NT_signed; break;
1312 case 'u': thistype = NT_unsigned; break;
1314 thistype = NT_float;
1319 as_bad (_("unexpected character `%c' in type specifier"), *ptr);
1325 /* .f is an abbreviation for .f32. */
1326 if (thistype == NT_float && !ISDIGIT (*ptr))
1331 thissize = strtoul (ptr, &ptr, 10);
1333 if (thissize != 8 && thissize != 16 && thissize != 32
1336 as_bad (_("bad size %d in type specifier"), thissize);
1344 type->el[type->elems].type = thistype;
1345 type->el[type->elems].size = thissize;
1350 /* Empty/missing type is not a successful parse. */
1351 if (type->elems == 0)
1359 /* Errors may be set multiple times during parsing or bit encoding
1360 (particularly in the Neon bits), but usually the earliest error which is set
1361 will be the most meaningful. Avoid overwriting it with later (cascading)
1362 errors by calling this function. */
1365 first_error (const char *err)
1371 /* Parse a single type, e.g. ".s32", leading period included. */
1373 parse_neon_operand_type (struct neon_type_el *vectype, char **ccp)
1376 struct neon_type optype;
1380 if (parse_neon_type (&optype, &str) == SUCCESS)
1382 if (optype.elems == 1)
1383 *vectype = optype.el[0];
1386 first_error (_("only one type should be specified for operand"));
1392 first_error (_("vector type expected"));
1404 /* Special meanings for indices (which have a range of 0-7), which will fit into
1407 #define NEON_ALL_LANES 15
1408 #define NEON_INTERLEAVE_LANES 14
1410 /* Parse either a register or a scalar, with an optional type. Return the
1411 register number, and optionally fill in the actual type of the register
1412 when multiple alternatives were given (NEON_TYPE_NDQ) in *RTYPE, and
1413 type/index information in *TYPEINFO. */
1416 parse_typed_reg_or_scalar (char **ccp, enum arm_reg_type type,
1417 enum arm_reg_type *rtype,
1418 struct neon_typed_alias *typeinfo)
1421 struct reg_entry *reg = arm_reg_parse_multi (&str);
1422 struct neon_typed_alias atype;
1423 struct neon_type_el parsetype;
1427 atype.eltype.type = NT_invtype;
1428 atype.eltype.size = -1;
1430 /* Try alternate syntax for some types of register. Note these are mutually
1431 exclusive with the Neon syntax extensions. */
1434 int altreg = arm_reg_alt_syntax (&str, *ccp, reg, type);
1442 /* Undo polymorphism when a set of register types may be accepted. */
1443 if ((type == REG_TYPE_NDQ
1444 && (reg->type == REG_TYPE_NQ || reg->type == REG_TYPE_VFD))
1445 || (type == REG_TYPE_VFSD
1446 && (reg->type == REG_TYPE_VFS || reg->type == REG_TYPE_VFD))
1447 || (type == REG_TYPE_NSDQ
1448 && (reg->type == REG_TYPE_VFS || reg->type == REG_TYPE_VFD
1449 || reg->type == REG_TYPE_NQ))
1450 || (type == REG_TYPE_MMXWC
1451 && (reg->type == REG_TYPE_MMXWCG)))
1452 type = (enum arm_reg_type) reg->type;
1454 if (type != reg->type)
1460 if (parse_neon_operand_type (&parsetype, &str) == SUCCESS)
1462 if ((atype.defined & NTA_HASTYPE) != 0)
1464 first_error (_("can't redefine type for operand"));
1467 atype.defined |= NTA_HASTYPE;
1468 atype.eltype = parsetype;
1471 if (skip_past_char (&str, '[') == SUCCESS)
1473 if (type != REG_TYPE_VFD)
1475 first_error (_("only D registers may be indexed"));
1479 if ((atype.defined & NTA_HASINDEX) != 0)
1481 first_error (_("can't change index for operand"));
1485 atype.defined |= NTA_HASINDEX;
1487 if (skip_past_char (&str, ']') == SUCCESS)
1488 atype.index = NEON_ALL_LANES;
1493 my_get_expression (&exp, &str, GE_NO_PREFIX);
1495 if (exp.X_op != O_constant)
1497 first_error (_("constant expression required"));
1501 if (skip_past_char (&str, ']') == FAIL)
1504 atype.index = exp.X_add_number;
1519 /* Like arm_reg_parse, but allow allow the following extra features:
1520 - If RTYPE is non-zero, return the (possibly restricted) type of the
1521 register (e.g. Neon double or quad reg when either has been requested).
1522 - If this is a Neon vector type with additional type information, fill
1523 in the struct pointed to by VECTYPE (if non-NULL).
1524 This function will fault on encountering a scalar. */
1527 arm_typed_reg_parse (char **ccp, enum arm_reg_type type,
1528 enum arm_reg_type *rtype, struct neon_type_el *vectype)
1530 struct neon_typed_alias atype;
1532 int reg = parse_typed_reg_or_scalar (&str, type, rtype, &atype);
1537 /* Do not allow regname(... to parse as a register. */
1541 /* Do not allow a scalar (reg+index) to parse as a register. */
1542 if ((atype.defined & NTA_HASINDEX) != 0)
1544 first_error (_("register operand expected, but got scalar"));
1549 *vectype = atype.eltype;
1556 #define NEON_SCALAR_REG(X) ((X) >> 4)
1557 #define NEON_SCALAR_INDEX(X) ((X) & 15)
1559 /* Parse a Neon scalar. Most of the time when we're parsing a scalar, we don't
1560 have enough information to be able to do a good job bounds-checking. So, we
1561 just do easy checks here, and do further checks later. */
1564 parse_scalar (char **ccp, int elsize, struct neon_type_el *type)
1568 struct neon_typed_alias atype;
1570 reg = parse_typed_reg_or_scalar (&str, REG_TYPE_VFD, NULL, &atype);
1572 if (reg == FAIL || (atype.defined & NTA_HASINDEX) == 0)
1575 if (atype.index == NEON_ALL_LANES)
1577 first_error (_("scalar must have an index"));
1580 else if (atype.index >= 64 / elsize)
1582 first_error (_("scalar index out of range"));
1587 *type = atype.eltype;
1591 return reg * 16 + atype.index;
1594 /* Parse an ARM register list. Returns the bitmask, or FAIL. */
1597 parse_reg_list (char ** strp)
1599 char * str = * strp;
1603 /* We come back here if we get ranges concatenated by '+' or '|'. */
1606 skip_whitespace (str);
1620 if ((reg = arm_reg_parse (&str, REG_TYPE_RN)) == FAIL)
1622 first_error (_(reg_expected_msgs[REG_TYPE_RN]));
1632 first_error (_("bad range in register list"));
1636 for (i = cur_reg + 1; i < reg; i++)
1638 if (range & (1 << i))
1640 (_("Warning: duplicated register (r%d) in register list"),
1648 if (range & (1 << reg))
1649 as_tsktsk (_("Warning: duplicated register (r%d) in register list"),
1651 else if (reg <= cur_reg)
1652 as_tsktsk (_("Warning: register range not in ascending order"));
1657 while (skip_past_comma (&str) != FAIL
1658 || (in_range = 1, *str++ == '-'));
1661 if (skip_past_char (&str, '}') == FAIL)
1663 first_error (_("missing `}'"));
1671 if (my_get_expression (&exp, &str, GE_NO_PREFIX))
1674 if (exp.X_op == O_constant)
1676 if (exp.X_add_number
1677 != (exp.X_add_number & 0x0000ffff))
1679 inst.error = _("invalid register mask");
1683 if ((range & exp.X_add_number) != 0)
1685 int regno = range & exp.X_add_number;
1688 regno = (1 << regno) - 1;
1690 (_("Warning: duplicated register (r%d) in register list"),
1694 range |= exp.X_add_number;
1698 if (inst.reloc.type != 0)
1700 inst.error = _("expression too complex");
1704 memcpy (&inst.reloc.exp, &exp, sizeof (expressionS));
1705 inst.reloc.type = BFD_RELOC_ARM_MULTI;
1706 inst.reloc.pc_rel = 0;
1710 if (*str == '|' || *str == '+')
1716 while (another_range);
1722 /* Types of registers in a list. */
1731 /* Parse a VFP register list. If the string is invalid return FAIL.
1732 Otherwise return the number of registers, and set PBASE to the first
1733 register. Parses registers of type ETYPE.
1734 If REGLIST_NEON_D is used, several syntax enhancements are enabled:
1735 - Q registers can be used to specify pairs of D registers
1736 - { } can be omitted from around a singleton register list
1737 FIXME: This is not implemented, as it would require backtracking in
1740 This could be done (the meaning isn't really ambiguous), but doesn't
1741 fit in well with the current parsing framework.
1742 - 32 D registers may be used (also true for VFPv3).
1743 FIXME: Types are ignored in these register lists, which is probably a
1747 parse_vfp_reg_list (char **ccp, unsigned int *pbase, enum reg_list_els etype)
1752 enum arm_reg_type regtype = (enum arm_reg_type) 0;
1756 unsigned long mask = 0;
1759 if (skip_past_char (&str, '{') == FAIL)
1761 inst.error = _("expecting {");
1768 regtype = REG_TYPE_VFS;
1773 regtype = REG_TYPE_VFD;
1776 case REGLIST_NEON_D:
1777 regtype = REG_TYPE_NDQ;
1781 if (etype != REGLIST_VFP_S)
1783 /* VFPv3 allows 32 D registers, except for the VFPv3-D16 variant. */
1784 if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_d32))
1788 ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
1791 ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used,
1798 base_reg = max_regs;
1802 int setmask = 1, addregs = 1;
1804 new_base = arm_typed_reg_parse (&str, regtype, ®type, NULL);
1806 if (new_base == FAIL)
1808 first_error (_(reg_expected_msgs[regtype]));
1812 if (new_base >= max_regs)
1814 first_error (_("register out of range in list"));
1818 /* Note: a value of 2 * n is returned for the register Q<n>. */
1819 if (regtype == REG_TYPE_NQ)
1825 if (new_base < base_reg)
1826 base_reg = new_base;
1828 if (mask & (setmask << new_base))
1830 first_error (_("invalid register list"));
1834 if ((mask >> new_base) != 0 && ! warned)
1836 as_tsktsk (_("register list not in ascending order"));
1840 mask |= setmask << new_base;
1843 if (*str == '-') /* We have the start of a range expression */
1849 if ((high_range = arm_typed_reg_parse (&str, regtype, NULL, NULL))
1852 inst.error = gettext (reg_expected_msgs[regtype]);
1856 if (high_range >= max_regs)
1858 first_error (_("register out of range in list"));
1862 if (regtype == REG_TYPE_NQ)
1863 high_range = high_range + 1;
1865 if (high_range <= new_base)
1867 inst.error = _("register range not in ascending order");
1871 for (new_base += addregs; new_base <= high_range; new_base += addregs)
1873 if (mask & (setmask << new_base))
1875 inst.error = _("invalid register list");
1879 mask |= setmask << new_base;
1884 while (skip_past_comma (&str) != FAIL);
1888 /* Sanity check -- should have raised a parse error above. */
1889 if (count == 0 || count > max_regs)
1894 /* Final test -- the registers must be consecutive. */
1896 for (i = 0; i < count; i++)
1898 if ((mask & (1u << i)) == 0)
1900 inst.error = _("non-contiguous register range");
1910 /* True if two alias types are the same. */
1913 neon_alias_types_same (struct neon_typed_alias *a, struct neon_typed_alias *b)
1921 if (a->defined != b->defined)
1924 if ((a->defined & NTA_HASTYPE) != 0
1925 && (a->eltype.type != b->eltype.type
1926 || a->eltype.size != b->eltype.size))
1929 if ((a->defined & NTA_HASINDEX) != 0
1930 && (a->index != b->index))
1936 /* Parse element/structure lists for Neon VLD<n> and VST<n> instructions.
1937 The base register is put in *PBASE.
1938 The lane (or one of the NEON_*_LANES constants) is placed in bits [3:0] of
1940 The register stride (minus one) is put in bit 4 of the return value.
1941 Bits [6:5] encode the list length (minus one).
1942 The type of the list elements is put in *ELTYPE, if non-NULL. */
1944 #define NEON_LANE(X) ((X) & 0xf)
1945 #define NEON_REG_STRIDE(X) ((((X) >> 4) & 1) + 1)
1946 #define NEON_REGLIST_LENGTH(X) ((((X) >> 5) & 3) + 1)
1949 parse_neon_el_struct_list (char **str, unsigned *pbase,
1950 struct neon_type_el *eltype)
1957 int leading_brace = 0;
1958 enum arm_reg_type rtype = REG_TYPE_NDQ;
1959 const char *const incr_error = _("register stride must be 1 or 2");
1960 const char *const type_error = _("mismatched element/structure types in list");
1961 struct neon_typed_alias firsttype;
1963 if (skip_past_char (&ptr, '{') == SUCCESS)
1968 struct neon_typed_alias atype;
1969 int getreg = parse_typed_reg_or_scalar (&ptr, rtype, &rtype, &atype);
1973 first_error (_(reg_expected_msgs[rtype]));
1980 if (rtype == REG_TYPE_NQ)
1986 else if (reg_incr == -1)
1988 reg_incr = getreg - base_reg;
1989 if (reg_incr < 1 || reg_incr > 2)
1991 first_error (_(incr_error));
1995 else if (getreg != base_reg + reg_incr * count)
1997 first_error (_(incr_error));
2001 if (! neon_alias_types_same (&atype, &firsttype))
2003 first_error (_(type_error));
2007 /* Handle Dn-Dm or Qn-Qm syntax. Can only be used with non-indexed list
2011 struct neon_typed_alias htype;
2012 int hireg, dregs = (rtype == REG_TYPE_NQ) ? 2 : 1;
2014 lane = NEON_INTERLEAVE_LANES;
2015 else if (lane != NEON_INTERLEAVE_LANES)
2017 first_error (_(type_error));
2022 else if (reg_incr != 1)
2024 first_error (_("don't use Rn-Rm syntax with non-unit stride"));
2028 hireg = parse_typed_reg_or_scalar (&ptr, rtype, NULL, &htype);
2031 first_error (_(reg_expected_msgs[rtype]));
2034 if (! neon_alias_types_same (&htype, &firsttype))
2036 first_error (_(type_error));
2039 count += hireg + dregs - getreg;
2043 /* If we're using Q registers, we can't use [] or [n] syntax. */
2044 if (rtype == REG_TYPE_NQ)
2050 if ((atype.defined & NTA_HASINDEX) != 0)
2054 else if (lane != atype.index)
2056 first_error (_(type_error));
2060 else if (lane == -1)
2061 lane = NEON_INTERLEAVE_LANES;
2062 else if (lane != NEON_INTERLEAVE_LANES)
2064 first_error (_(type_error));
2069 while ((count != 1 || leading_brace) && skip_past_comma (&ptr) != FAIL);
2071 /* No lane set by [x]. We must be interleaving structures. */
2073 lane = NEON_INTERLEAVE_LANES;
2076 if (lane == -1 || base_reg == -1 || count < 1 || count > 4
2077 || (count > 1 && reg_incr == -1))
2079 first_error (_("error parsing element/structure list"));
2083 if ((count > 1 || leading_brace) && skip_past_char (&ptr, '}') == FAIL)
2085 first_error (_("expected }"));
2093 *eltype = firsttype.eltype;
2098 return lane | ((reg_incr - 1) << 4) | ((count - 1) << 5);
2101 /* Parse an explicit relocation suffix on an expression. This is
2102 either nothing, or a word in parentheses. Note that if !OBJ_ELF,
2103 arm_reloc_hsh contains no entries, so this function can only
2104 succeed if there is no () after the word. Returns -1 on error,
2105 BFD_RELOC_UNUSED if there wasn't any suffix. */
2108 parse_reloc (char **str)
2110 struct reloc_entry *r;
2114 return BFD_RELOC_UNUSED;
2119 while (*q && *q != ')' && *q != ',')
2124 if ((r = (struct reloc_entry *)
2125 hash_find_n (arm_reloc_hsh, p, q - p)) == NULL)
2132 /* Directives: register aliases. */
2134 static struct reg_entry *
2135 insert_reg_alias (char *str, unsigned number, int type)
2137 struct reg_entry *new_reg;
2140 if ((new_reg = (struct reg_entry *) hash_find (arm_reg_hsh, str)) != 0)
2142 if (new_reg->builtin)
2143 as_warn (_("ignoring attempt to redefine built-in register '%s'"), str);
2145 /* Only warn about a redefinition if it's not defined as the
2147 else if (new_reg->number != number || new_reg->type != type)
2148 as_warn (_("ignoring redefinition of register alias '%s'"), str);
2153 name = xstrdup (str);
2154 new_reg = (struct reg_entry *) xmalloc (sizeof (struct reg_entry));
2156 new_reg->name = name;
2157 new_reg->number = number;
2158 new_reg->type = type;
2159 new_reg->builtin = FALSE;
2160 new_reg->neon = NULL;
2162 if (hash_insert (arm_reg_hsh, name, (void *) new_reg))
2169 insert_neon_reg_alias (char *str, int number, int type,
2170 struct neon_typed_alias *atype)
2172 struct reg_entry *reg = insert_reg_alias (str, number, type);
2176 first_error (_("attempt to redefine typed alias"));
2182 reg->neon = (struct neon_typed_alias *)
2183 xmalloc (sizeof (struct neon_typed_alias));
2184 *reg->neon = *atype;
2188 /* Look for the .req directive. This is of the form:
2190 new_register_name .req existing_register_name
2192 If we find one, or if it looks sufficiently like one that we want to
2193 handle any error here, return TRUE. Otherwise return FALSE. */
2196 create_register_alias (char * newname, char *p)
2198 struct reg_entry *old;
2199 char *oldname, *nbuf;
2202 /* The input scrubber ensures that whitespace after the mnemonic is
2203 collapsed to single spaces. */
2205 if (strncmp (oldname, " .req ", 6) != 0)
2209 if (*oldname == '\0')
2212 old = (struct reg_entry *) hash_find (arm_reg_hsh, oldname);
2215 as_warn (_("unknown register '%s' -- .req ignored"), oldname);
2219 /* If TC_CASE_SENSITIVE is defined, then newname already points to
2220 the desired alias name, and p points to its end. If not, then
2221 the desired alias name is in the global original_case_string. */
2222 #ifdef TC_CASE_SENSITIVE
2225 newname = original_case_string;
2226 nlen = strlen (newname);
2229 nbuf = (char *) alloca (nlen + 1);
2230 memcpy (nbuf, newname, nlen);
2233 /* Create aliases under the new name as stated; an all-lowercase
2234 version of the new name; and an all-uppercase version of the new
2236 if (insert_reg_alias (nbuf, old->number, old->type) != NULL)
2238 for (p = nbuf; *p; p++)
2241 if (strncmp (nbuf, newname, nlen))
2243 /* If this attempt to create an additional alias fails, do not bother
2244 trying to create the all-lower case alias. We will fail and issue
2245 a second, duplicate error message. This situation arises when the
2246 programmer does something like:
2249 The second .req creates the "Foo" alias but then fails to create
2250 the artificial FOO alias because it has already been created by the
2252 if (insert_reg_alias (nbuf, old->number, old->type) == NULL)
2256 for (p = nbuf; *p; p++)
2259 if (strncmp (nbuf, newname, nlen))
2260 insert_reg_alias (nbuf, old->number, old->type);
2266 /* Create a Neon typed/indexed register alias using directives, e.g.:
2271 These typed registers can be used instead of the types specified after the
2272 Neon mnemonic, so long as all operands given have types. Types can also be
2273 specified directly, e.g.:
2274 vadd d0.s32, d1.s32, d2.s32 */
2277 create_neon_reg_alias (char *newname, char *p)
2279 enum arm_reg_type basetype;
2280 struct reg_entry *basereg;
2281 struct reg_entry mybasereg;
2282 struct neon_type ntype;
2283 struct neon_typed_alias typeinfo;
2284 char *namebuf, *nameend ATTRIBUTE_UNUSED;
2287 typeinfo.defined = 0;
2288 typeinfo.eltype.type = NT_invtype;
2289 typeinfo.eltype.size = -1;
2290 typeinfo.index = -1;
2294 if (strncmp (p, " .dn ", 5) == 0)
2295 basetype = REG_TYPE_VFD;
2296 else if (strncmp (p, " .qn ", 5) == 0)
2297 basetype = REG_TYPE_NQ;
2306 basereg = arm_reg_parse_multi (&p);
2308 if (basereg && basereg->type != basetype)
2310 as_bad (_("bad type for register"));
2314 if (basereg == NULL)
2317 /* Try parsing as an integer. */
2318 my_get_expression (&exp, &p, GE_NO_PREFIX);
2319 if (exp.X_op != O_constant)
2321 as_bad (_("expression must be constant"));
2324 basereg = &mybasereg;
2325 basereg->number = (basetype == REG_TYPE_NQ) ? exp.X_add_number * 2
2331 typeinfo = *basereg->neon;
2333 if (parse_neon_type (&ntype, &p) == SUCCESS)
2335 /* We got a type. */
2336 if (typeinfo.defined & NTA_HASTYPE)
2338 as_bad (_("can't redefine the type of a register alias"));
2342 typeinfo.defined |= NTA_HASTYPE;
2343 if (ntype.elems != 1)
2345 as_bad (_("you must specify a single type only"));
2348 typeinfo.eltype = ntype.el[0];
2351 if (skip_past_char (&p, '[') == SUCCESS)
2354 /* We got a scalar index. */
2356 if (typeinfo.defined & NTA_HASINDEX)
2358 as_bad (_("can't redefine the index of a scalar alias"));
2362 my_get_expression (&exp, &p, GE_NO_PREFIX);
2364 if (exp.X_op != O_constant)
2366 as_bad (_("scalar index must be constant"));
2370 typeinfo.defined |= NTA_HASINDEX;
2371 typeinfo.index = exp.X_add_number;
2373 if (skip_past_char (&p, ']') == FAIL)
2375 as_bad (_("expecting ]"));
2380 /* If TC_CASE_SENSITIVE is defined, then newname already points to
2381 the desired alias name, and p points to its end. If not, then
2382 the desired alias name is in the global original_case_string. */
2383 #ifdef TC_CASE_SENSITIVE
2384 namelen = nameend - newname;
2386 newname = original_case_string;
2387 namelen = strlen (newname);
2390 namebuf = (char *) alloca (namelen + 1);
2391 strncpy (namebuf, newname, namelen);
2392 namebuf[namelen] = '\0';
2394 insert_neon_reg_alias (namebuf, basereg->number, basetype,
2395 typeinfo.defined != 0 ? &typeinfo : NULL);
2397 /* Insert name in all uppercase. */
2398 for (p = namebuf; *p; p++)
2401 if (strncmp (namebuf, newname, namelen))
2402 insert_neon_reg_alias (namebuf, basereg->number, basetype,
2403 typeinfo.defined != 0 ? &typeinfo : NULL);
2405 /* Insert name in all lowercase. */
2406 for (p = namebuf; *p; p++)
2409 if (strncmp (namebuf, newname, namelen))
2410 insert_neon_reg_alias (namebuf, basereg->number, basetype,
2411 typeinfo.defined != 0 ? &typeinfo : NULL);
2416 /* Should never be called, as .req goes between the alias and the
2417 register name, not at the beginning of the line. */
2420 s_req (int a ATTRIBUTE_UNUSED)
2422 as_bad (_("invalid syntax for .req directive"));
2426 s_dn (int a ATTRIBUTE_UNUSED)
2428 as_bad (_("invalid syntax for .dn directive"));
2432 s_qn (int a ATTRIBUTE_UNUSED)
2434 as_bad (_("invalid syntax for .qn directive"));
2437 /* The .unreq directive deletes an alias which was previously defined
2438 by .req. For example:
2444 s_unreq (int a ATTRIBUTE_UNUSED)
2449 name = input_line_pointer;
2451 while (*input_line_pointer != 0
2452 && *input_line_pointer != ' '
2453 && *input_line_pointer != '\n')
2454 ++input_line_pointer;
2456 saved_char = *input_line_pointer;
2457 *input_line_pointer = 0;
2460 as_bad (_("invalid syntax for .unreq directive"));
2463 struct reg_entry *reg = (struct reg_entry *) hash_find (arm_reg_hsh,
2467 as_bad (_("unknown register alias '%s'"), name);
2468 else if (reg->builtin)
2469 as_warn (_("ignoring attempt to use .unreq on fixed register name: '%s'"),
2476 hash_delete (arm_reg_hsh, name, FALSE);
2477 free ((char *) reg->name);
2482 /* Also locate the all upper case and all lower case versions.
2483 Do not complain if we cannot find one or the other as it
2484 was probably deleted above. */
2486 nbuf = strdup (name);
2487 for (p = nbuf; *p; p++)
2489 reg = (struct reg_entry *) hash_find (arm_reg_hsh, nbuf);
2492 hash_delete (arm_reg_hsh, nbuf, FALSE);
2493 free ((char *) reg->name);
2499 for (p = nbuf; *p; p++)
2501 reg = (struct reg_entry *) hash_find (arm_reg_hsh, nbuf);
2504 hash_delete (arm_reg_hsh, nbuf, FALSE);
2505 free ((char *) reg->name);
2515 *input_line_pointer = saved_char;
2516 demand_empty_rest_of_line ();
2519 /* Directives: Instruction set selection. */
2522 /* This code is to handle mapping symbols as defined in the ARM ELF spec.
2523 (See "Mapping symbols", section 4.5.5, ARM AAELF version 1.0).
2524 Note that previously, $a and $t has type STT_FUNC (BSF_OBJECT flag),
2525 and $d has type STT_OBJECT (BSF_OBJECT flag). Now all three are untyped. */
2527 /* Create a new mapping symbol for the transition to STATE. */
2530 make_mapping_symbol (enum mstate state, valueT value, fragS *frag)
2533 const char * symname;
2540 type = BSF_NO_FLAGS;
2544 type = BSF_NO_FLAGS;
2548 type = BSF_NO_FLAGS;
2554 symbolP = symbol_new (symname, now_seg, value, frag);
2555 symbol_get_bfdsym (symbolP)->flags |= type | BSF_LOCAL;
2560 THUMB_SET_FUNC (symbolP, 0);
2561 ARM_SET_THUMB (symbolP, 0);
2562 ARM_SET_INTERWORK (symbolP, support_interwork);
2566 THUMB_SET_FUNC (symbolP, 1);
2567 ARM_SET_THUMB (symbolP, 1);
2568 ARM_SET_INTERWORK (symbolP, support_interwork);
2576 /* Save the mapping symbols for future reference. Also check that
2577 we do not place two mapping symbols at the same offset within a
2578 frag. We'll handle overlap between frags in
2579 check_mapping_symbols.
2581 If .fill or other data filling directive generates zero sized data,
2582 the mapping symbol for the following code will have the same value
2583 as the one generated for the data filling directive. In this case,
2584 we replace the old symbol with the new one at the same address. */
2587 if (frag->tc_frag_data.first_map != NULL)
2589 know (S_GET_VALUE (frag->tc_frag_data.first_map) == 0);
2590 symbol_remove (frag->tc_frag_data.first_map, &symbol_rootP, &symbol_lastP);
2592 frag->tc_frag_data.first_map = symbolP;
2594 if (frag->tc_frag_data.last_map != NULL)
2596 know (S_GET_VALUE (frag->tc_frag_data.last_map) <= S_GET_VALUE (symbolP));
2597 if (S_GET_VALUE (frag->tc_frag_data.last_map) == S_GET_VALUE (symbolP))
2598 symbol_remove (frag->tc_frag_data.last_map, &symbol_rootP, &symbol_lastP);
2600 frag->tc_frag_data.last_map = symbolP;
2603 /* We must sometimes convert a region marked as code to data during
2604 code alignment, if an odd number of bytes have to be padded. The
2605 code mapping symbol is pushed to an aligned address. */
2608 insert_data_mapping_symbol (enum mstate state,
2609 valueT value, fragS *frag, offsetT bytes)
2611 /* If there was already a mapping symbol, remove it. */
2612 if (frag->tc_frag_data.last_map != NULL
2613 && S_GET_VALUE (frag->tc_frag_data.last_map) == frag->fr_address + value)
2615 symbolS *symp = frag->tc_frag_data.last_map;
2619 know (frag->tc_frag_data.first_map == symp);
2620 frag->tc_frag_data.first_map = NULL;
2622 frag->tc_frag_data.last_map = NULL;
2623 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2626 make_mapping_symbol (MAP_DATA, value, frag);
2627 make_mapping_symbol (state, value + bytes, frag);
2630 static void mapping_state_2 (enum mstate state, int max_chars);
2632 /* Set the mapping state to STATE. Only call this when about to
2633 emit some STATE bytes to the file. */
2636 mapping_state (enum mstate state)
2638 enum mstate mapstate = seg_info (now_seg)->tc_segment_info_data.mapstate;
2640 #define TRANSITION(from, to) (mapstate == (from) && state == (to))
2642 if (mapstate == state)
2643 /* The mapping symbol has already been emitted.
2644 There is nothing else to do. */
2647 if (state == MAP_ARM || state == MAP_THUMB)
2649 All ARM instructions require 4-byte alignment.
2650 (Almost) all Thumb instructions require 2-byte alignment.
2652 When emitting instructions into any section, mark the section
2655 Some Thumb instructions are alignment-sensitive modulo 4 bytes,
2656 but themselves require 2-byte alignment; this applies to some
2657 PC- relative forms. However, these cases will invovle implicit
2658 literal pool generation or an explicit .align >=2, both of
2659 which will cause the section to me marked with sufficient
2660 alignment. Thus, we don't handle those cases here. */
2661 record_alignment (now_seg, state == MAP_ARM ? 2 : 1);
2663 if (TRANSITION (MAP_UNDEFINED, MAP_DATA))
2664 /* This case will be evaluated later in the next else. */
2666 else if (TRANSITION (MAP_UNDEFINED, MAP_ARM)
2667 || TRANSITION (MAP_UNDEFINED, MAP_THUMB))
2669 /* Only add the symbol if the offset is > 0:
2670 if we're at the first frag, check it's size > 0;
2671 if we're not at the first frag, then for sure
2672 the offset is > 0. */
2673 struct frag * const frag_first = seg_info (now_seg)->frchainP->frch_root;
2674 const int add_symbol = (frag_now != frag_first) || (frag_now_fix () > 0);
2677 make_mapping_symbol (MAP_DATA, (valueT) 0, frag_first);
2680 mapping_state_2 (state, 0);
2684 /* Same as mapping_state, but MAX_CHARS bytes have already been
2685 allocated. Put the mapping symbol that far back. */
2688 mapping_state_2 (enum mstate state, int max_chars)
2690 enum mstate mapstate = seg_info (now_seg)->tc_segment_info_data.mapstate;
2692 if (!SEG_NORMAL (now_seg))
2695 if (mapstate == state)
2696 /* The mapping symbol has already been emitted.
2697 There is nothing else to do. */
2700 seg_info (now_seg)->tc_segment_info_data.mapstate = state;
2701 make_mapping_symbol (state, (valueT) frag_now_fix () - max_chars, frag_now);
2704 #define mapping_state(x) ((void)0)
2705 #define mapping_state_2(x, y) ((void)0)
2708 /* Find the real, Thumb encoded start of a Thumb function. */
2712 find_real_start (symbolS * symbolP)
2715 const char * name = S_GET_NAME (symbolP);
2716 symbolS * new_target;
2718 /* This definition must agree with the one in gcc/config/arm/thumb.c. */
2719 #define STUB_NAME ".real_start_of"
2724 /* The compiler may generate BL instructions to local labels because
2725 it needs to perform a branch to a far away location. These labels
2726 do not have a corresponding ".real_start_of" label. We check
2727 both for S_IS_LOCAL and for a leading dot, to give a way to bypass
2728 the ".real_start_of" convention for nonlocal branches. */
2729 if (S_IS_LOCAL (symbolP) || name[0] == '.')
2732 real_start = ACONCAT ((STUB_NAME, name, NULL));
2733 new_target = symbol_find (real_start);
2735 if (new_target == NULL)
2737 as_warn (_("Failed to find real start of function: %s\n"), name);
2738 new_target = symbolP;
2746 opcode_select (int width)
2753 if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
2754 as_bad (_("selected processor does not support THUMB opcodes"));
2757 /* No need to force the alignment, since we will have been
2758 coming from ARM mode, which is word-aligned. */
2759 record_alignment (now_seg, 1);
2766 if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
2767 as_bad (_("selected processor does not support ARM opcodes"));
2772 frag_align (2, 0, 0);
2774 record_alignment (now_seg, 1);
2779 as_bad (_("invalid instruction size selected (%d)"), width);
2784 s_arm (int ignore ATTRIBUTE_UNUSED)
2787 demand_empty_rest_of_line ();
2791 s_thumb (int ignore ATTRIBUTE_UNUSED)
2794 demand_empty_rest_of_line ();
2798 s_code (int unused ATTRIBUTE_UNUSED)
2802 temp = get_absolute_expression ();
2807 opcode_select (temp);
2811 as_bad (_("invalid operand to .code directive (%d) (expecting 16 or 32)"), temp);
2816 s_force_thumb (int ignore ATTRIBUTE_UNUSED)
2818 /* If we are not already in thumb mode go into it, EVEN if
2819 the target processor does not support thumb instructions.
2820 This is used by gcc/config/arm/lib1funcs.asm for example
2821 to compile interworking support functions even if the
2822 target processor should not support interworking. */
2826 record_alignment (now_seg, 1);
2829 demand_empty_rest_of_line ();
2833 s_thumb_func (int ignore ATTRIBUTE_UNUSED)
2837 /* The following label is the name/address of the start of a Thumb function.
2838 We need to know this for the interworking support. */
2839 label_is_thumb_function_name = TRUE;
2842 /* Perform a .set directive, but also mark the alias as
2843 being a thumb function. */
2846 s_thumb_set (int equiv)
2848 /* XXX the following is a duplicate of the code for s_set() in read.c
2849 We cannot just call that code as we need to get at the symbol that
2856 /* Especial apologies for the random logic:
2857 This just grew, and could be parsed much more simply!
2859 name = input_line_pointer;
2860 delim = get_symbol_end ();
2861 end_name = input_line_pointer;
2864 if (*input_line_pointer != ',')
2867 as_bad (_("expected comma after name \"%s\""), name);
2869 ignore_rest_of_line ();
2873 input_line_pointer++;
2876 if (name[0] == '.' && name[1] == '\0')
2878 /* XXX - this should not happen to .thumb_set. */
2882 if ((symbolP = symbol_find (name)) == NULL
2883 && (symbolP = md_undefined_symbol (name)) == NULL)
2886 /* When doing symbol listings, play games with dummy fragments living
2887 outside the normal fragment chain to record the file and line info
2889 if (listing & LISTING_SYMBOLS)
2891 extern struct list_info_struct * listing_tail;
2892 fragS * dummy_frag = (fragS * ) xmalloc (sizeof (fragS));
2894 memset (dummy_frag, 0, sizeof (fragS));
2895 dummy_frag->fr_type = rs_fill;
2896 dummy_frag->line = listing_tail;
2897 symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
2898 dummy_frag->fr_symbol = symbolP;
2902 symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
2905 /* "set" symbols are local unless otherwise specified. */
2906 SF_SET_LOCAL (symbolP);
2907 #endif /* OBJ_COFF */
2908 } /* Make a new symbol. */
2910 symbol_table_insert (symbolP);
2915 && S_IS_DEFINED (symbolP)
2916 && S_GET_SEGMENT (symbolP) != reg_section)
2917 as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
2919 pseudo_set (symbolP);
2921 demand_empty_rest_of_line ();
2923 /* XXX Now we come to the Thumb specific bit of code. */
2925 THUMB_SET_FUNC (symbolP, 1);
2926 ARM_SET_THUMB (symbolP, 1);
2927 #if defined OBJ_ELF || defined OBJ_COFF
2928 ARM_SET_INTERWORK (symbolP, support_interwork);
2932 /* Directives: Mode selection. */
2934 /* .syntax [unified|divided] - choose the new unified syntax
2935 (same for Arm and Thumb encoding, modulo slight differences in what
2936 can be represented) or the old divergent syntax for each mode. */
2938 s_syntax (int unused ATTRIBUTE_UNUSED)
2942 name = input_line_pointer;
2943 delim = get_symbol_end ();
2945 if (!strcasecmp (name, "unified"))
2946 unified_syntax = TRUE;
2947 else if (!strcasecmp (name, "divided"))
2948 unified_syntax = FALSE;
2951 as_bad (_("unrecognized syntax mode \"%s\""), name);
2954 *input_line_pointer = delim;
2955 demand_empty_rest_of_line ();
2958 /* Directives: sectioning and alignment. */
2960 /* Same as s_align_ptwo but align 0 => align 2. */
2963 s_align (int unused ATTRIBUTE_UNUSED)
2968 long max_alignment = 15;
2970 temp = get_absolute_expression ();
2971 if (temp > max_alignment)
2972 as_bad (_("alignment too large: %d assumed"), temp = max_alignment);
2975 as_bad (_("alignment negative. 0 assumed."));
2979 if (*input_line_pointer == ',')
2981 input_line_pointer++;
2982 temp_fill = get_absolute_expression ();
2994 /* Only make a frag if we HAVE to. */
2995 if (temp && !need_pass_2)
2997 if (!fill_p && subseg_text_p (now_seg))
2998 frag_align_code (temp, 0);
3000 frag_align (temp, (int) temp_fill, 0);
3002 demand_empty_rest_of_line ();
3004 record_alignment (now_seg, temp);
3008 s_bss (int ignore ATTRIBUTE_UNUSED)
3010 /* We don't support putting frags in the BSS segment, we fake it by
3011 marking in_bss, then looking at s_skip for clues. */
3012 subseg_set (bss_section, 0);
3013 demand_empty_rest_of_line ();
3015 #ifdef md_elf_section_change_hook
3016 md_elf_section_change_hook ();
3021 s_even (int ignore ATTRIBUTE_UNUSED)
3023 /* Never make frag if expect extra pass. */
3025 frag_align (1, 0, 0);
3027 record_alignment (now_seg, 1);
3029 demand_empty_rest_of_line ();
3032 /* Directives: CodeComposer Studio. */
3034 /* .ref (for CodeComposer Studio syntax only). */
3036 s_ccs_ref (int unused ATTRIBUTE_UNUSED)
3038 if (codecomposer_syntax)
3039 ignore_rest_of_line ();
3041 as_bad (_(".ref pseudo-op only available with -mccs flag."));
3044 /* If name is not NULL, then it is used for marking the beginning of a
3045 function, wherease if it is NULL then it means the function end. */
3047 asmfunc_debug (const char * name)
3049 static const char * last_name = NULL;
3053 gas_assert (last_name == NULL);
3056 if (debug_type == DEBUG_STABS)
3057 stabs_generate_asm_func (name, name);
3061 gas_assert (last_name != NULL);
3063 if (debug_type == DEBUG_STABS)
3064 stabs_generate_asm_endfunc (last_name, last_name);
3071 s_ccs_asmfunc (int unused ATTRIBUTE_UNUSED)
3073 if (codecomposer_syntax)
3075 switch (asmfunc_state)
3077 case OUTSIDE_ASMFUNC:
3078 asmfunc_state = WAITING_ASMFUNC_NAME;
3081 case WAITING_ASMFUNC_NAME:
3082 as_bad (_(".asmfunc repeated."));
3085 case WAITING_ENDASMFUNC:
3086 as_bad (_(".asmfunc without function."));
3089 demand_empty_rest_of_line ();
3092 as_bad (_(".asmfunc pseudo-op only available with -mccs flag."));
3096 s_ccs_endasmfunc (int unused ATTRIBUTE_UNUSED)
3098 if (codecomposer_syntax)
3100 switch (asmfunc_state)
3102 case OUTSIDE_ASMFUNC:
3103 as_bad (_(".endasmfunc without a .asmfunc."));
3106 case WAITING_ASMFUNC_NAME:
3107 as_bad (_(".endasmfunc without function."));
3110 case WAITING_ENDASMFUNC:
3111 asmfunc_state = OUTSIDE_ASMFUNC;
3112 asmfunc_debug (NULL);
3115 demand_empty_rest_of_line ();
3118 as_bad (_(".endasmfunc pseudo-op only available with -mccs flag."));
3122 s_ccs_def (int name)
3124 if (codecomposer_syntax)
3127 as_bad (_(".def pseudo-op only available with -mccs flag."));
3130 /* Directives: Literal pools. */
3132 static literal_pool *
3133 find_literal_pool (void)
3135 literal_pool * pool;
3137 for (pool = list_of_pools; pool != NULL; pool = pool->next)
3139 if (pool->section == now_seg
3140 && pool->sub_section == now_subseg)
3147 static literal_pool *
3148 find_or_make_literal_pool (void)
3150 /* Next literal pool ID number. */
3151 static unsigned int latest_pool_num = 1;
3152 literal_pool * pool;
3154 pool = find_literal_pool ();
3158 /* Create a new pool. */
3159 pool = (literal_pool *) xmalloc (sizeof (* pool));
3163 pool->next_free_entry = 0;
3164 pool->section = now_seg;
3165 pool->sub_section = now_subseg;
3166 pool->next = list_of_pools;
3167 pool->symbol = NULL;
3168 pool->alignment = 2;
3170 /* Add it to the list. */
3171 list_of_pools = pool;
3174 /* New pools, and emptied pools, will have a NULL symbol. */
3175 if (pool->symbol == NULL)
3177 pool->symbol = symbol_create (FAKE_LABEL_NAME, undefined_section,
3178 (valueT) 0, &zero_address_frag);
3179 pool->id = latest_pool_num ++;
3186 /* Add the literal in the global 'inst'
3187 structure to the relevant literal pool. */
3190 add_to_lit_pool (unsigned int nbytes)
3192 #define PADDING_SLOT 0x1
3193 #define LIT_ENTRY_SIZE_MASK 0xFF
3194 literal_pool * pool;
3195 unsigned int entry, pool_size = 0;
3196 bfd_boolean padding_slot_p = FALSE;
3202 imm1 = inst.operands[1].imm;
3203 imm2 = (inst.operands[1].regisimm ? inst.operands[1].reg
3204 : inst.reloc.exp.X_unsigned ? 0
3205 : ((bfd_int64_t) inst.operands[1].imm) >> 32);
3206 if (target_big_endian)
3209 imm2 = inst.operands[1].imm;
3213 pool = find_or_make_literal_pool ();
3215 /* Check if this literal value is already in the pool. */
3216 for (entry = 0; entry < pool->next_free_entry; entry ++)
3220 if ((pool->literals[entry].X_op == inst.reloc.exp.X_op)
3221 && (inst.reloc.exp.X_op == O_constant)
3222 && (pool->literals[entry].X_add_number
3223 == inst.reloc.exp.X_add_number)
3224 && (pool->literals[entry].X_md == nbytes)
3225 && (pool->literals[entry].X_unsigned
3226 == inst.reloc.exp.X_unsigned))
3229 if ((pool->literals[entry].X_op == inst.reloc.exp.X_op)
3230 && (inst.reloc.exp.X_op == O_symbol)
3231 && (pool->literals[entry].X_add_number
3232 == inst.reloc.exp.X_add_number)
3233 && (pool->literals[entry].X_add_symbol
3234 == inst.reloc.exp.X_add_symbol)
3235 && (pool->literals[entry].X_op_symbol
3236 == inst.reloc.exp.X_op_symbol)
3237 && (pool->literals[entry].X_md == nbytes))
3240 else if ((nbytes == 8)
3241 && !(pool_size & 0x7)
3242 && ((entry + 1) != pool->next_free_entry)
3243 && (pool->literals[entry].X_op == O_constant)
3244 && (pool->literals[entry].X_add_number == (offsetT) imm1)
3245 && (pool->literals[entry].X_unsigned
3246 == inst.reloc.exp.X_unsigned)
3247 && (pool->literals[entry + 1].X_op == O_constant)
3248 && (pool->literals[entry + 1].X_add_number == (offsetT) imm2)
3249 && (pool->literals[entry + 1].X_unsigned
3250 == inst.reloc.exp.X_unsigned))
3253 padding_slot_p = ((pool->literals[entry].X_md >> 8) == PADDING_SLOT);
3254 if (padding_slot_p && (nbytes == 4))
3260 /* Do we need to create a new entry? */
3261 if (entry == pool->next_free_entry)
3263 if (entry >= MAX_LITERAL_POOL_SIZE)
3265 inst.error = _("literal pool overflow");
3271 /* For 8-byte entries, we align to an 8-byte boundary,
3272 and split it into two 4-byte entries, because on 32-bit
3273 host, 8-byte constants are treated as big num, thus
3274 saved in "generic_bignum" which will be overwritten
3275 by later assignments.
3277 We also need to make sure there is enough space for
3280 We also check to make sure the literal operand is a
3282 if (!(inst.reloc.exp.X_op == O_constant
3283 || inst.reloc.exp.X_op == O_big))
3285 inst.error = _("invalid type for literal pool");
3288 else if (pool_size & 0x7)
3290 if ((entry + 2) >= MAX_LITERAL_POOL_SIZE)
3292 inst.error = _("literal pool overflow");
3296 pool->literals[entry] = inst.reloc.exp;
3297 pool->literals[entry].X_add_number = 0;
3298 pool->literals[entry++].X_md = (PADDING_SLOT << 8) | 4;
3299 pool->next_free_entry += 1;
3302 else if ((entry + 1) >= MAX_LITERAL_POOL_SIZE)
3304 inst.error = _("literal pool overflow");
3308 pool->literals[entry] = inst.reloc.exp;
3309 pool->literals[entry].X_op = O_constant;
3310 pool->literals[entry].X_add_number = imm1;
3311 pool->literals[entry].X_unsigned = inst.reloc.exp.X_unsigned;
3312 pool->literals[entry++].X_md = 4;
3313 pool->literals[entry] = inst.reloc.exp;
3314 pool->literals[entry].X_op = O_constant;
3315 pool->literals[entry].X_add_number = imm2;
3316 pool->literals[entry].X_unsigned = inst.reloc.exp.X_unsigned;
3317 pool->literals[entry].X_md = 4;
3318 pool->alignment = 3;
3319 pool->next_free_entry += 1;
3323 pool->literals[entry] = inst.reloc.exp;
3324 pool->literals[entry].X_md = 4;
3328 /* PR ld/12974: Record the location of the first source line to reference
3329 this entry in the literal pool. If it turns out during linking that the
3330 symbol does not exist we will be able to give an accurate line number for
3331 the (first use of the) missing reference. */
3332 if (debug_type == DEBUG_DWARF2)
3333 dwarf2_where (pool->locs + entry);
3335 pool->next_free_entry += 1;
3337 else if (padding_slot_p)
3339 pool->literals[entry] = inst.reloc.exp;
3340 pool->literals[entry].X_md = nbytes;
3343 inst.reloc.exp.X_op = O_symbol;
3344 inst.reloc.exp.X_add_number = pool_size;
3345 inst.reloc.exp.X_add_symbol = pool->symbol;
3351 tc_start_label_without_colon (char unused1 ATTRIBUTE_UNUSED, const char * rest)
3353 bfd_boolean ret = TRUE;
3355 if (codecomposer_syntax && asmfunc_state == WAITING_ASMFUNC_NAME)
3357 const char *label = rest;
3359 while (!is_end_of_line[(int) label[-1]])
3364 as_bad (_("Invalid label '%s'"), label);
3368 asmfunc_debug (label);
3370 asmfunc_state = WAITING_ENDASMFUNC;
3376 /* Can't use symbol_new here, so have to create a symbol and then at
3377 a later date assign it a value. Thats what these functions do. */
3380 symbol_locate (symbolS * symbolP,
3381 const char * name, /* It is copied, the caller can modify. */
3382 segT segment, /* Segment identifier (SEG_<something>). */
3383 valueT valu, /* Symbol value. */
3384 fragS * frag) /* Associated fragment. */
3387 char * preserved_copy_of_name;
3389 name_length = strlen (name) + 1; /* +1 for \0. */
3390 obstack_grow (¬es, name, name_length);
3391 preserved_copy_of_name = (char *) obstack_finish (¬es);
3393 #ifdef tc_canonicalize_symbol_name
3394 preserved_copy_of_name =
3395 tc_canonicalize_symbol_name (preserved_copy_of_name);
3398 S_SET_NAME (symbolP, preserved_copy_of_name);
3400 S_SET_SEGMENT (symbolP, segment);
3401 S_SET_VALUE (symbolP, valu);
3402 symbol_clear_list_pointers (symbolP);
3404 symbol_set_frag (symbolP, frag);
3406 /* Link to end of symbol chain. */
3408 extern int symbol_table_frozen;
3410 if (symbol_table_frozen)
3414 symbol_append (symbolP, symbol_lastP, & symbol_rootP, & symbol_lastP);
3416 obj_symbol_new_hook (symbolP);
3418 #ifdef tc_symbol_new_hook
3419 tc_symbol_new_hook (symbolP);
3423 verify_symbol_chain (symbol_rootP, symbol_lastP);
3424 #endif /* DEBUG_SYMS */
3428 s_ltorg (int ignored ATTRIBUTE_UNUSED)
3431 literal_pool * pool;
3434 pool = find_literal_pool ();
3436 || pool->symbol == NULL
3437 || pool->next_free_entry == 0)
3440 /* Align pool as you have word accesses.
3441 Only make a frag if we have to. */
3443 frag_align (pool->alignment, 0, 0);
3445 record_alignment (now_seg, 2);
3448 seg_info (now_seg)->tc_segment_info_data.mapstate = MAP_DATA;
3449 make_mapping_symbol (MAP_DATA, (valueT) frag_now_fix (), frag_now);
3451 sprintf (sym_name, "$$lit_\002%x", pool->id);
3453 symbol_locate (pool->symbol, sym_name, now_seg,
3454 (valueT) frag_now_fix (), frag_now);
3455 symbol_table_insert (pool->symbol);
3457 ARM_SET_THUMB (pool->symbol, thumb_mode);
3459 #if defined OBJ_COFF || defined OBJ_ELF
3460 ARM_SET_INTERWORK (pool->symbol, support_interwork);
3463 for (entry = 0; entry < pool->next_free_entry; entry ++)
3466 if (debug_type == DEBUG_DWARF2)
3467 dwarf2_gen_line_info (frag_now_fix (), pool->locs + entry);
3469 /* First output the expression in the instruction to the pool. */
3470 emit_expr (&(pool->literals[entry]),
3471 pool->literals[entry].X_md & LIT_ENTRY_SIZE_MASK);
3474 /* Mark the pool as empty. */
3475 pool->next_free_entry = 0;
3476 pool->symbol = NULL;
3480 /* Forward declarations for functions below, in the MD interface
3482 static void fix_new_arm (fragS *, int, short, expressionS *, int, int);
3483 static valueT create_unwind_entry (int);
3484 static void start_unwind_section (const segT, int);
3485 static void add_unwind_opcode (valueT, int);
3486 static void flush_pending_unwind (void);
3488 /* Directives: Data. */
3491 s_arm_elf_cons (int nbytes)
3495 #ifdef md_flush_pending_output
3496 md_flush_pending_output ();
3499 if (is_it_end_of_statement ())
3501 demand_empty_rest_of_line ();
3505 #ifdef md_cons_align
3506 md_cons_align (nbytes);
3509 mapping_state (MAP_DATA);
3513 char *base = input_line_pointer;
3517 if (exp.X_op != O_symbol)
3518 emit_expr (&exp, (unsigned int) nbytes);
3521 char *before_reloc = input_line_pointer;
3522 reloc = parse_reloc (&input_line_pointer);
3525 as_bad (_("unrecognized relocation suffix"));
3526 ignore_rest_of_line ();
3529 else if (reloc == BFD_RELOC_UNUSED)
3530 emit_expr (&exp, (unsigned int) nbytes);
3533 reloc_howto_type *howto = (reloc_howto_type *)
3534 bfd_reloc_type_lookup (stdoutput,
3535 (bfd_reloc_code_real_type) reloc);
3536 int size = bfd_get_reloc_size (howto);
3538 if (reloc == BFD_RELOC_ARM_PLT32)
3540 as_bad (_("(plt) is only valid on branch targets"));
3541 reloc = BFD_RELOC_UNUSED;
3546 as_bad (_("%s relocations do not fit in %d bytes"),
3547 howto->name, nbytes);
3550 /* We've parsed an expression stopping at O_symbol.
3551 But there may be more expression left now that we
3552 have parsed the relocation marker. Parse it again.
3553 XXX Surely there is a cleaner way to do this. */
3554 char *p = input_line_pointer;
3556 char *save_buf = (char *) alloca (input_line_pointer - base);
3557 memcpy (save_buf, base, input_line_pointer - base);
3558 memmove (base + (input_line_pointer - before_reloc),
3559 base, before_reloc - base);
3561 input_line_pointer = base + (input_line_pointer-before_reloc);
3563 memcpy (base, save_buf, p - base);
3565 offset = nbytes - size;
3566 p = frag_more (nbytes);
3567 memset (p, 0, nbytes);
3568 fix_new_exp (frag_now, p - frag_now->fr_literal + offset,
3569 size, &exp, 0, (enum bfd_reloc_code_real) reloc);
3574 while (*input_line_pointer++ == ',');
3576 /* Put terminator back into stream. */
3577 input_line_pointer --;
3578 demand_empty_rest_of_line ();
3581 /* Emit an expression containing a 32-bit thumb instruction.
3582 Implementation based on put_thumb32_insn. */
3585 emit_thumb32_expr (expressionS * exp)
3587 expressionS exp_high = *exp;
3589 exp_high.X_add_number = (unsigned long)exp_high.X_add_number >> 16;
3590 emit_expr (& exp_high, (unsigned int) THUMB_SIZE);
3591 exp->X_add_number &= 0xffff;
3592 emit_expr (exp, (unsigned int) THUMB_SIZE);
3595 /* Guess the instruction size based on the opcode. */
3598 thumb_insn_size (int opcode)
3600 if ((unsigned int) opcode < 0xe800u)
3602 else if ((unsigned int) opcode >= 0xe8000000u)
3609 emit_insn (expressionS *exp, int nbytes)
3613 if (exp->X_op == O_constant)
3618 size = thumb_insn_size (exp->X_add_number);
3622 if (size == 2 && (unsigned int)exp->X_add_number > 0xffffu)
3624 as_bad (_(".inst.n operand too big. "\
3625 "Use .inst.w instead"));
3630 if (now_it.state == AUTOMATIC_IT_BLOCK)
3631 set_it_insn_type_nonvoid (OUTSIDE_IT_INSN, 0);
3633 set_it_insn_type_nonvoid (NEUTRAL_IT_INSN, 0);
3635 if (thumb_mode && (size > THUMB_SIZE) && !target_big_endian)
3636 emit_thumb32_expr (exp);
3638 emit_expr (exp, (unsigned int) size);
3640 it_fsm_post_encode ();
3644 as_bad (_("cannot determine Thumb instruction size. " \
3645 "Use .inst.n/.inst.w instead"));
3648 as_bad (_("constant expression required"));
3653 /* Like s_arm_elf_cons but do not use md_cons_align and
3654 set the mapping state to MAP_ARM/MAP_THUMB. */
3657 s_arm_elf_inst (int nbytes)
3659 if (is_it_end_of_statement ())
3661 demand_empty_rest_of_line ();
3665 /* Calling mapping_state () here will not change ARM/THUMB,
3666 but will ensure not to be in DATA state. */
3669 mapping_state (MAP_THUMB);
3674 as_bad (_("width suffixes are invalid in ARM mode"));
3675 ignore_rest_of_line ();
3681 mapping_state (MAP_ARM);
3690 if (! emit_insn (& exp, nbytes))
3692 ignore_rest_of_line ();
3696 while (*input_line_pointer++ == ',');
3698 /* Put terminator back into stream. */
3699 input_line_pointer --;
3700 demand_empty_rest_of_line ();
3703 /* Parse a .rel31 directive. */
3706 s_arm_rel31 (int ignored ATTRIBUTE_UNUSED)
3713 if (*input_line_pointer == '1')
3714 highbit = 0x80000000;
3715 else if (*input_line_pointer != '0')
3716 as_bad (_("expected 0 or 1"));
3718 input_line_pointer++;
3719 if (*input_line_pointer != ',')
3720 as_bad (_("missing comma"));
3721 input_line_pointer++;
3723 #ifdef md_flush_pending_output
3724 md_flush_pending_output ();
3727 #ifdef md_cons_align
3731 mapping_state (MAP_DATA);
3736 md_number_to_chars (p, highbit, 4);
3737 fix_new_arm (frag_now, p - frag_now->fr_literal, 4, &exp, 1,
3738 BFD_RELOC_ARM_PREL31);
3740 demand_empty_rest_of_line ();
3743 /* Directives: AEABI stack-unwind tables. */
3745 /* Parse an unwind_fnstart directive. Simply records the current location. */
3748 s_arm_unwind_fnstart (int ignored ATTRIBUTE_UNUSED)
3750 demand_empty_rest_of_line ();
3751 if (unwind.proc_start)
3753 as_bad (_("duplicate .fnstart directive"));
3757 /* Mark the start of the function. */
3758 unwind.proc_start = expr_build_dot ();
3760 /* Reset the rest of the unwind info. */
3761 unwind.opcode_count = 0;
3762 unwind.table_entry = NULL;
3763 unwind.personality_routine = NULL;
3764 unwind.personality_index = -1;
3765 unwind.frame_size = 0;
3766 unwind.fp_offset = 0;
3767 unwind.fp_reg = REG_SP;
3769 unwind.sp_restored = 0;
3773 /* Parse a handlerdata directive. Creates the exception handling table entry
3774 for the function. */
3777 s_arm_unwind_handlerdata (int ignored ATTRIBUTE_UNUSED)
3779 demand_empty_rest_of_line ();
3780 if (!unwind.proc_start)
3781 as_bad (MISSING_FNSTART);
3783 if (unwind.table_entry)
3784 as_bad (_("duplicate .handlerdata directive"));
3786 create_unwind_entry (1);
3789 /* Parse an unwind_fnend directive. Generates the index table entry. */
3792 s_arm_unwind_fnend (int ignored ATTRIBUTE_UNUSED)
3797 unsigned int marked_pr_dependency;
3799 demand_empty_rest_of_line ();
3801 if (!unwind.proc_start)
3803 as_bad (_(".fnend directive without .fnstart"));
3807 /* Add eh table entry. */
3808 if (unwind.table_entry == NULL)
3809 val = create_unwind_entry (0);
3813 /* Add index table entry. This is two words. */
3814 start_unwind_section (unwind.saved_seg, 1);
3815 frag_align (2, 0, 0);
3816 record_alignment (now_seg, 2);
3818 ptr = frag_more (8);
3820 where = frag_now_fix () - 8;
3822 /* Self relative offset of the function start. */
3823 fix_new (frag_now, where, 4, unwind.proc_start, 0, 1,
3824 BFD_RELOC_ARM_PREL31);
3826 /* Indicate dependency on EHABI-defined personality routines to the
3827 linker, if it hasn't been done already. */
3828 marked_pr_dependency
3829 = seg_info (now_seg)->tc_segment_info_data.marked_pr_dependency;
3830 if (unwind.personality_index >= 0 && unwind.personality_index < 3
3831 && !(marked_pr_dependency & (1 << unwind.personality_index)))
3833 static const char *const name[] =
3835 "__aeabi_unwind_cpp_pr0",
3836 "__aeabi_unwind_cpp_pr1",
3837 "__aeabi_unwind_cpp_pr2"
3839 symbolS *pr = symbol_find_or_make (name[unwind.personality_index]);
3840 fix_new (frag_now, where, 0, pr, 0, 1, BFD_RELOC_NONE);
3841 seg_info (now_seg)->tc_segment_info_data.marked_pr_dependency
3842 |= 1 << unwind.personality_index;
3846 /* Inline exception table entry. */
3847 md_number_to_chars (ptr + 4, val, 4);
3849 /* Self relative offset of the table entry. */
3850 fix_new (frag_now, where + 4, 4, unwind.table_entry, 0, 1,
3851 BFD_RELOC_ARM_PREL31);
3853 /* Restore the original section. */
3854 subseg_set (unwind.saved_seg, unwind.saved_subseg);
3856 unwind.proc_start = NULL;
3860 /* Parse an unwind_cantunwind directive. */
3863 s_arm_unwind_cantunwind (int ignored ATTRIBUTE_UNUSED)
3865 demand_empty_rest_of_line ();
3866 if (!unwind.proc_start)
3867 as_bad (MISSING_FNSTART);
3869 if (unwind.personality_routine || unwind.personality_index != -1)
3870 as_bad (_("personality routine specified for cantunwind frame"));
3872 unwind.personality_index = -2;
3876 /* Parse a personalityindex directive. */
3879 s_arm_unwind_personalityindex (int ignored ATTRIBUTE_UNUSED)
3883 if (!unwind.proc_start)
3884 as_bad (MISSING_FNSTART);
3886 if (unwind.personality_routine || unwind.personality_index != -1)
3887 as_bad (_("duplicate .personalityindex directive"));
3891 if (exp.X_op != O_constant
3892 || exp.X_add_number < 0 || exp.X_add_number > 15)
3894 as_bad (_("bad personality routine number"));
3895 ignore_rest_of_line ();
3899 unwind.personality_index = exp.X_add_number;
3901 demand_empty_rest_of_line ();
3905 /* Parse a personality directive. */
3908 s_arm_unwind_personality (int ignored ATTRIBUTE_UNUSED)
3912 if (!unwind.proc_start)
3913 as_bad (MISSING_FNSTART);
3915 if (unwind.personality_routine || unwind.personality_index != -1)
3916 as_bad (_("duplicate .personality directive"));
3918 name = input_line_pointer;
3919 c = get_symbol_end ();
3920 p = input_line_pointer;
3921 unwind.personality_routine = symbol_find_or_make (name);
3923 demand_empty_rest_of_line ();
3927 /* Parse a directive saving core registers. */
3930 s_arm_unwind_save_core (void)
3936 range = parse_reg_list (&input_line_pointer);
3939 as_bad (_("expected register list"));
3940 ignore_rest_of_line ();
3944 demand_empty_rest_of_line ();
3946 /* Turn .unwind_movsp ip followed by .unwind_save {..., ip, ...}
3947 into .unwind_save {..., sp...}. We aren't bothered about the value of
3948 ip because it is clobbered by calls. */
3949 if (unwind.sp_restored && unwind.fp_reg == 12
3950 && (range & 0x3000) == 0x1000)
3952 unwind.opcode_count--;
3953 unwind.sp_restored = 0;
3954 range = (range | 0x2000) & ~0x1000;
3955 unwind.pending_offset = 0;
3961 /* See if we can use the short opcodes. These pop a block of up to 8
3962 registers starting with r4, plus maybe r14. */
3963 for (n = 0; n < 8; n++)
3965 /* Break at the first non-saved register. */
3966 if ((range & (1 << (n + 4))) == 0)
3969 /* See if there are any other bits set. */
3970 if (n == 0 || (range & (0xfff0 << n) & 0xbff0) != 0)
3972 /* Use the long form. */
3973 op = 0x8000 | ((range >> 4) & 0xfff);
3974 add_unwind_opcode (op, 2);
3978 /* Use the short form. */
3980 op = 0xa8; /* Pop r14. */
3982 op = 0xa0; /* Do not pop r14. */
3984 add_unwind_opcode (op, 1);
3991 op = 0xb100 | (range & 0xf);
3992 add_unwind_opcode (op, 2);
3995 /* Record the number of bytes pushed. */
3996 for (n = 0; n < 16; n++)
3998 if (range & (1 << n))
3999 unwind.frame_size += 4;
4004 /* Parse a directive saving FPA registers. */
4007 s_arm_unwind_save_fpa (int reg)
4013 /* Get Number of registers to transfer. */
4014 if (skip_past_comma (&input_line_pointer) != FAIL)
4017 exp.X_op = O_illegal;
4019 if (exp.X_op != O_constant)
4021 as_bad (_("expected , <constant>"));
4022 ignore_rest_of_line ();
4026 num_regs = exp.X_add_number;
4028 if (num_regs < 1 || num_regs > 4)
4030 as_bad (_("number of registers must be in the range [1:4]"));
4031 ignore_rest_of_line ();
4035 demand_empty_rest_of_line ();
4040 op = 0xb4 | (num_regs - 1);
4041 add_unwind_opcode (op, 1);
4046 op = 0xc800 | (reg << 4) | (num_regs - 1);
4047 add_unwind_opcode (op, 2);
4049 unwind.frame_size += num_regs * 12;
4053 /* Parse a directive saving VFP registers for ARMv6 and above. */
4056 s_arm_unwind_save_vfp_armv6 (void)
4061 int num_vfpv3_regs = 0;
4062 int num_regs_below_16;
4064 count = parse_vfp_reg_list (&input_line_pointer, &start, REGLIST_VFP_D);
4067 as_bad (_("expected register list"));
4068 ignore_rest_of_line ();
4072 demand_empty_rest_of_line ();
4074 /* We always generate FSTMD/FLDMD-style unwinding opcodes (rather
4075 than FSTMX/FLDMX-style ones). */
4077 /* Generate opcode for (VFPv3) registers numbered in the range 16 .. 31. */
4079 num_vfpv3_regs = count;
4080 else if (start + count > 16)
4081 num_vfpv3_regs = start + count - 16;
4083 if (num_vfpv3_regs > 0)
4085 int start_offset = start > 16 ? start - 16 : 0;
4086 op = 0xc800 | (start_offset << 4) | (num_vfpv3_regs - 1);
4087 add_unwind_opcode (op, 2);
4090 /* Generate opcode for registers numbered in the range 0 .. 15. */
4091 num_regs_below_16 = num_vfpv3_regs > 0 ? 16 - (int) start : count;
4092 gas_assert (num_regs_below_16 + num_vfpv3_regs == count);
4093 if (num_regs_below_16 > 0)
4095 op = 0xc900 | (start << 4) | (num_regs_below_16 - 1);
4096 add_unwind_opcode (op, 2);
4099 unwind.frame_size += count * 8;
4103 /* Parse a directive saving VFP registers for pre-ARMv6. */
4106 s_arm_unwind_save_vfp (void)
4112 count = parse_vfp_reg_list (&input_line_pointer, ®, REGLIST_VFP_D);
4115 as_bad (_("expected register list"));
4116 ignore_rest_of_line ();
4120 demand_empty_rest_of_line ();
4125 op = 0xb8 | (count - 1);
4126 add_unwind_opcode (op, 1);
4131 op = 0xb300 | (reg << 4) | (count - 1);
4132 add_unwind_opcode (op, 2);
4134 unwind.frame_size += count * 8 + 4;
4138 /* Parse a directive saving iWMMXt data registers. */
4141 s_arm_unwind_save_mmxwr (void)
4149 if (*input_line_pointer == '{')
4150 input_line_pointer++;
4154 reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWR);
4158 as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWR]));
4163 as_tsktsk (_("register list not in ascending order"));
4166 if (*input_line_pointer == '-')
4168 input_line_pointer++;
4169 hi_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWR);
4172 as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWR]));
4175 else if (reg >= hi_reg)
4177 as_bad (_("bad register range"));
4180 for (; reg < hi_reg; reg++)
4184 while (skip_past_comma (&input_line_pointer) != FAIL);
4186 skip_past_char (&input_line_pointer, '}');
4188 demand_empty_rest_of_line ();
4190 /* Generate any deferred opcodes because we're going to be looking at
4192 flush_pending_unwind ();
4194 for (i = 0; i < 16; i++)
4196 if (mask & (1 << i))
4197 unwind.frame_size += 8;
4200 /* Attempt to combine with a previous opcode. We do this because gcc
4201 likes to output separate unwind directives for a single block of
4203 if (unwind.opcode_count > 0)
4205 i = unwind.opcodes[unwind.opcode_count - 1];
4206 if ((i & 0xf8) == 0xc0)
4209 /* Only merge if the blocks are contiguous. */
4212 if ((mask & 0xfe00) == (1 << 9))
4214 mask |= ((1 << (i + 11)) - 1) & 0xfc00;
4215 unwind.opcode_count--;
4218 else if (i == 6 && unwind.opcode_count >= 2)
4220 i = unwind.opcodes[unwind.opcode_count - 2];
4224 op = 0xffff << (reg - 1);
4226 && ((mask & op) == (1u << (reg - 1))))
4228 op = (1 << (reg + i + 1)) - 1;
4229 op &= ~((1 << reg) - 1);
4231 unwind.opcode_count -= 2;
4238 /* We want to generate opcodes in the order the registers have been
4239 saved, ie. descending order. */
4240 for (reg = 15; reg >= -1; reg--)
4242 /* Save registers in blocks. */
4244 || !(mask & (1 << reg)))
4246 /* We found an unsaved reg. Generate opcodes to save the
4253 op = 0xc0 | (hi_reg - 10);
4254 add_unwind_opcode (op, 1);
4259 op = 0xc600 | ((reg + 1) << 4) | ((hi_reg - reg) - 1);
4260 add_unwind_opcode (op, 2);
4269 ignore_rest_of_line ();
4273 s_arm_unwind_save_mmxwcg (void)
4280 if (*input_line_pointer == '{')
4281 input_line_pointer++;
4283 skip_whitespace (input_line_pointer);
4287 reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWCG);
4291 as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWCG]));
4297 as_tsktsk (_("register list not in ascending order"));
4300 if (*input_line_pointer == '-')
4302 input_line_pointer++;
4303 hi_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_MMXWCG);
4306 as_bad ("%s", _(reg_expected_msgs[REG_TYPE_MMXWCG]));
4309 else if (reg >= hi_reg)
4311 as_bad (_("bad register range"));
4314 for (; reg < hi_reg; reg++)
4318 while (skip_past_comma (&input_line_pointer) != FAIL);
4320 skip_past_char (&input_line_pointer, '}');
4322 demand_empty_rest_of_line ();
4324 /* Generate any deferred opcodes because we're going to be looking at
4326 flush_pending_unwind ();
4328 for (reg = 0; reg < 16; reg++)
4330 if (mask & (1 << reg))
4331 unwind.frame_size += 4;
4334 add_unwind_opcode (op, 2);
4337 ignore_rest_of_line ();
4341 /* Parse an unwind_save directive.
4342 If the argument is non-zero, this is a .vsave directive. */
4345 s_arm_unwind_save (int arch_v6)
4348 struct reg_entry *reg;
4349 bfd_boolean had_brace = FALSE;
4351 if (!unwind.proc_start)
4352 as_bad (MISSING_FNSTART);
4354 /* Figure out what sort of save we have. */
4355 peek = input_line_pointer;
4363 reg = arm_reg_parse_multi (&peek);
4367 as_bad (_("register expected"));
4368 ignore_rest_of_line ();
4377 as_bad (_("FPA .unwind_save does not take a register list"));
4378 ignore_rest_of_line ();
4381 input_line_pointer = peek;
4382 s_arm_unwind_save_fpa (reg->number);
4386 s_arm_unwind_save_core ();
4391 s_arm_unwind_save_vfp_armv6 ();
4393 s_arm_unwind_save_vfp ();
4396 case REG_TYPE_MMXWR:
4397 s_arm_unwind_save_mmxwr ();
4400 case REG_TYPE_MMXWCG:
4401 s_arm_unwind_save_mmxwcg ();
4405 as_bad (_(".unwind_save does not support this kind of register"));
4406 ignore_rest_of_line ();
4411 /* Parse an unwind_movsp directive. */
4414 s_arm_unwind_movsp (int ignored ATTRIBUTE_UNUSED)
4420 if (!unwind.proc_start)
4421 as_bad (MISSING_FNSTART);
4423 reg = arm_reg_parse (&input_line_pointer, REG_TYPE_RN);
4426 as_bad ("%s", _(reg_expected_msgs[REG_TYPE_RN]));
4427 ignore_rest_of_line ();
4431 /* Optional constant. */
4432 if (skip_past_comma (&input_line_pointer) != FAIL)
4434 if (immediate_for_directive (&offset) == FAIL)
4440 demand_empty_rest_of_line ();
4442 if (reg == REG_SP || reg == REG_PC)
4444 as_bad (_("SP and PC not permitted in .unwind_movsp directive"));
4448 if (unwind.fp_reg != REG_SP)
4449 as_bad (_("unexpected .unwind_movsp directive"));
4451 /* Generate opcode to restore the value. */
4453 add_unwind_opcode (op, 1);
4455 /* Record the information for later. */
4456 unwind.fp_reg = reg;
4457 unwind.fp_offset = unwind.frame_size - offset;
4458 unwind.sp_restored = 1;
4461 /* Parse an unwind_pad directive. */
4464 s_arm_unwind_pad (int ignored ATTRIBUTE_UNUSED)
4468 if (!unwind.proc_start)
4469 as_bad (MISSING_FNSTART);
4471 if (immediate_for_directive (&offset) == FAIL)
4476 as_bad (_("stack increment must be multiple of 4"));
4477 ignore_rest_of_line ();
4481 /* Don't generate any opcodes, just record the details for later. */
4482 unwind.frame_size += offset;
4483 unwind.pending_offset += offset;
4485 demand_empty_rest_of_line ();
4488 /* Parse an unwind_setfp directive. */
4491 s_arm_unwind_setfp (int ignored ATTRIBUTE_UNUSED)
4497 if (!unwind.proc_start)
4498 as_bad (MISSING_FNSTART);
4500 fp_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_RN);
4501 if (skip_past_comma (&input_line_pointer) == FAIL)
4504 sp_reg = arm_reg_parse (&input_line_pointer, REG_TYPE_RN);
4506 if (fp_reg == FAIL || sp_reg == FAIL)
4508 as_bad (_("expected <reg>, <reg>"));
4509 ignore_rest_of_line ();
4513 /* Optional constant. */
4514 if (skip_past_comma (&input_line_pointer) != FAIL)
4516 if (immediate_for_directive (&offset) == FAIL)
4522 demand_empty_rest_of_line ();
4524 if (sp_reg != REG_SP && sp_reg != unwind.fp_reg)
4526 as_bad (_("register must be either sp or set by a previous"
4527 "unwind_movsp directive"));
4531 /* Don't generate any opcodes, just record the information for later. */
4532 unwind.fp_reg = fp_reg;
4534 if (sp_reg == REG_SP)
4535 unwind.fp_offset = unwind.frame_size - offset;
4537 unwind.fp_offset -= offset;
4540 /* Parse an unwind_raw directive. */
4543 s_arm_unwind_raw (int ignored ATTRIBUTE_UNUSED)
4546 /* This is an arbitrary limit. */
4547 unsigned char op[16];
4550 if (!unwind.proc_start)
4551 as_bad (MISSING_FNSTART);
4554 if (exp.X_op == O_constant
4555 && skip_past_comma (&input_line_pointer) != FAIL)
4557 unwind.frame_size += exp.X_add_number;
4561 exp.X_op = O_illegal;
4563 if (exp.X_op != O_constant)
4565 as_bad (_("expected <offset>, <opcode>"));
4566 ignore_rest_of_line ();
4572 /* Parse the opcode. */
4577 as_bad (_("unwind opcode too long"));
4578 ignore_rest_of_line ();
4580 if (exp.X_op != O_constant || exp.X_add_number & ~0xff)
4582 as_bad (_("invalid unwind opcode"));
4583 ignore_rest_of_line ();
4586 op[count++] = exp.X_add_number;
4588 /* Parse the next byte. */
4589 if (skip_past_comma (&input_line_pointer) == FAIL)
4595 /* Add the opcode bytes in reverse order. */
4597 add_unwind_opcode (op[count], 1);
4599 demand_empty_rest_of_line ();
4603 /* Parse a .eabi_attribute directive. */
4606 s_arm_eabi_attribute (int ignored ATTRIBUTE_UNUSED)
4608 int tag = obj_elf_vendor_attribute (OBJ_ATTR_PROC);
4610 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
4611 attributes_set_explicitly[tag] = 1;
4614 /* Emit a tls fix for the symbol. */
4617 s_arm_tls_descseq (int ignored ATTRIBUTE_UNUSED)
4621 #ifdef md_flush_pending_output
4622 md_flush_pending_output ();
4625 #ifdef md_cons_align
4629 /* Since we're just labelling the code, there's no need to define a
4632 p = obstack_next_free (&frchain_now->frch_obstack);
4633 fix_new_arm (frag_now, p - frag_now->fr_literal, 4, &exp, 0,
4634 thumb_mode ? BFD_RELOC_ARM_THM_TLS_DESCSEQ
4635 : BFD_RELOC_ARM_TLS_DESCSEQ);
4637 #endif /* OBJ_ELF */
4639 static void s_arm_arch (int);
4640 static void s_arm_object_arch (int);
4641 static void s_arm_cpu (int);
4642 static void s_arm_fpu (int);
4643 static void s_arm_arch_extension (int);
4648 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED)
4655 if (exp.X_op == O_symbol)
4656 exp.X_op = O_secrel;
4658 emit_expr (&exp, 4);
4660 while (*input_line_pointer++ == ',');
4662 input_line_pointer--;
4663 demand_empty_rest_of_line ();
4667 /* This table describes all the machine specific pseudo-ops the assembler
4668 has to support. The fields are:
4669 pseudo-op name without dot
4670 function to call to execute this pseudo-op
4671 Integer arg to pass to the function. */
4673 const pseudo_typeS md_pseudo_table[] =
4675 /* Never called because '.req' does not start a line. */
4676 { "req", s_req, 0 },
4677 /* Following two are likewise never called. */
4680 { "unreq", s_unreq, 0 },
4681 { "bss", s_bss, 0 },
4682 { "align", s_align, 0 },
4683 { "arm", s_arm, 0 },
4684 { "thumb", s_thumb, 0 },
4685 { "code", s_code, 0 },
4686 { "force_thumb", s_force_thumb, 0 },
4687 { "thumb_func", s_thumb_func, 0 },
4688 { "thumb_set", s_thumb_set, 0 },
4689 { "even", s_even, 0 },
4690 { "ltorg", s_ltorg, 0 },
4691 { "pool", s_ltorg, 0 },
4692 { "syntax", s_syntax, 0 },
4693 { "cpu", s_arm_cpu, 0 },
4694 { "arch", s_arm_arch, 0 },
4695 { "object_arch", s_arm_object_arch, 0 },
4696 { "fpu", s_arm_fpu, 0 },
4697 { "arch_extension", s_arm_arch_extension, 0 },
4699 { "word", s_arm_elf_cons, 4 },
4700 { "long", s_arm_elf_cons, 4 },
4701 { "inst.n", s_arm_elf_inst, 2 },
4702 { "inst.w", s_arm_elf_inst, 4 },
4703 { "inst", s_arm_elf_inst, 0 },
4704 { "rel31", s_arm_rel31, 0 },
4705 { "fnstart", s_arm_unwind_fnstart, 0 },
4706 { "fnend", s_arm_unwind_fnend, 0 },
4707 { "cantunwind", s_arm_unwind_cantunwind, 0 },
4708 { "personality", s_arm_unwind_personality, 0 },
4709 { "personalityindex", s_arm_unwind_personalityindex, 0 },
4710 { "handlerdata", s_arm_unwind_handlerdata, 0 },
4711 { "save", s_arm_unwind_save, 0 },
4712 { "vsave", s_arm_unwind_save, 1 },
4713 { "movsp", s_arm_unwind_movsp, 0 },
4714 { "pad", s_arm_unwind_pad, 0 },
4715 { "setfp", s_arm_unwind_setfp, 0 },
4716 { "unwind_raw", s_arm_unwind_raw, 0 },
4717 { "eabi_attribute", s_arm_eabi_attribute, 0 },
4718 { "tlsdescseq", s_arm_tls_descseq, 0 },
4722 /* These are used for dwarf. */
4726 /* These are used for dwarf2. */
4727 { "file", (void (*) (int)) dwarf2_directive_file, 0 },
4728 { "loc", dwarf2_directive_loc, 0 },
4729 { "loc_mark_labels", dwarf2_directive_loc_mark_labels, 0 },
4731 { "extend", float_cons, 'x' },
4732 { "ldouble", float_cons, 'x' },
4733 { "packed", float_cons, 'p' },
4735 {"secrel32", pe_directive_secrel, 0},
4738 /* These are for compatibility with CodeComposer Studio. */
4739 {"ref", s_ccs_ref, 0},
4740 {"def", s_ccs_def, 0},
4741 {"asmfunc", s_ccs_asmfunc, 0},
4742 {"endasmfunc", s_ccs_endasmfunc, 0},
4747 /* Parser functions used exclusively in instruction operands. */
4749 /* Generic immediate-value read function for use in insn parsing.
4750 STR points to the beginning of the immediate (the leading #);
4751 VAL receives the value; if the value is outside [MIN, MAX]
4752 issue an error. PREFIX_OPT is true if the immediate prefix is
4756 parse_immediate (char **str, int *val, int min, int max,
4757 bfd_boolean prefix_opt)
4760 my_get_expression (&exp, str, prefix_opt ? GE_OPT_PREFIX : GE_IMM_PREFIX);
4761 if (exp.X_op != O_constant)
4763 inst.error = _("constant expression required");
4767 if (exp.X_add_number < min || exp.X_add_number > max)
4769 inst.error = _("immediate value out of range");
4773 *val = exp.X_add_number;
4777 /* Less-generic immediate-value read function with the possibility of loading a
4778 big (64-bit) immediate, as required by Neon VMOV, VMVN and logic immediate
4779 instructions. Puts the result directly in inst.operands[i]. */
4782 parse_big_immediate (char **str, int i, expressionS *in_exp,
4783 bfd_boolean allow_symbol_p)
4786 expressionS *exp_p = in_exp ? in_exp : &exp;
4789 my_get_expression (exp_p, &ptr, GE_OPT_PREFIX_BIG);
4791 if (exp_p->X_op == O_constant)
4793 inst.operands[i].imm = exp_p->X_add_number & 0xffffffff;
4794 /* If we're on a 64-bit host, then a 64-bit number can be returned using
4795 O_constant. We have to be careful not to break compilation for
4796 32-bit X_add_number, though. */
4797 if ((exp_p->X_add_number & ~(offsetT)(0xffffffffU)) != 0)
4799 /* X >> 32 is illegal if sizeof (exp_p->X_add_number) == 4. */
4800 inst.operands[i].reg = (((exp_p->X_add_number >> 16) >> 16)
4802 inst.operands[i].regisimm = 1;
4805 else if (exp_p->X_op == O_big
4806 && LITTLENUM_NUMBER_OF_BITS * exp_p->X_add_number > 32)
4808 unsigned parts = 32 / LITTLENUM_NUMBER_OF_BITS, j, idx = 0;
4810 /* Bignums have their least significant bits in
4811 generic_bignum[0]. Make sure we put 32 bits in imm and
4812 32 bits in reg, in a (hopefully) portable way. */
4813 gas_assert (parts != 0);
4815 /* Make sure that the number is not too big.
4816 PR 11972: Bignums can now be sign-extended to the
4817 size of a .octa so check that the out of range bits
4818 are all zero or all one. */
4819 if (LITTLENUM_NUMBER_OF_BITS * exp_p->X_add_number > 64)
4821 LITTLENUM_TYPE m = -1;
4823 if (generic_bignum[parts * 2] != 0
4824 && generic_bignum[parts * 2] != m)
4827 for (j = parts * 2 + 1; j < (unsigned) exp_p->X_add_number; j++)
4828 if (generic_bignum[j] != generic_bignum[j-1])
4832 inst.operands[i].imm = 0;
4833 for (j = 0; j < parts; j++, idx++)
4834 inst.operands[i].imm |= generic_bignum[idx]
4835 << (LITTLENUM_NUMBER_OF_BITS * j);
4836 inst.operands[i].reg = 0;
4837 for (j = 0; j < parts; j++, idx++)
4838 inst.operands[i].reg |= generic_bignum[idx]
4839 << (LITTLENUM_NUMBER_OF_BITS * j);
4840 inst.operands[i].regisimm = 1;
4842 else if (!(exp_p->X_op == O_symbol && allow_symbol_p))
4850 /* Returns the pseudo-register number of an FPA immediate constant,
4851 or FAIL if there isn't a valid constant here. */
4854 parse_fpa_immediate (char ** str)
4856 LITTLENUM_TYPE words[MAX_LITTLENUMS];
4862 /* First try and match exact strings, this is to guarantee
4863 that some formats will work even for cross assembly. */
4865 for (i = 0; fp_const[i]; i++)
4867 if (strncmp (*str, fp_const[i], strlen (fp_const[i])) == 0)
4871 *str += strlen (fp_const[i]);
4872 if (is_end_of_line[(unsigned char) **str])
4878 /* Just because we didn't get a match doesn't mean that the constant
4879 isn't valid, just that it is in a format that we don't
4880 automatically recognize. Try parsing it with the standard
4881 expression routines. */
4883 memset (words, 0, MAX_LITTLENUMS * sizeof (LITTLENUM_TYPE));
4885 /* Look for a raw floating point number. */
4886 if ((save_in = atof_ieee (*str, 'x', words)) != NULL
4887 && is_end_of_line[(unsigned char) *save_in])
4889 for (i = 0; i < NUM_FLOAT_VALS; i++)
4891 for (j = 0; j < MAX_LITTLENUMS; j++)
4893 if (words[j] != fp_values[i][j])
4897 if (j == MAX_LITTLENUMS)
4905 /* Try and parse a more complex expression, this will probably fail
4906 unless the code uses a floating point prefix (eg "0f"). */
4907 save_in = input_line_pointer;
4908 input_line_pointer = *str;
4909 if (expression (&exp) == absolute_section
4910 && exp.X_op == O_big
4911 && exp.X_add_number < 0)
4913 /* FIXME: 5 = X_PRECISION, should be #define'd where we can use it.
4915 if (gen_to_words (words, 5, (long) 15) == 0)
4917 for (i = 0; i < NUM_FLOAT_VALS; i++)
4919 for (j = 0; j < MAX_LITTLENUMS; j++)
4921 if (words[j] != fp_values[i][j])
4925 if (j == MAX_LITTLENUMS)
4927 *str = input_line_pointer;
4928 input_line_pointer = save_in;
4935 *str = input_line_pointer;
4936 input_line_pointer = save_in;
4937 inst.error = _("invalid FPA immediate expression");
4941 /* Returns 1 if a number has "quarter-precision" float format
4942 0baBbbbbbc defgh000 00000000 00000000. */
4945 is_quarter_float (unsigned imm)
4947 int bs = (imm & 0x20000000) ? 0x3e000000 : 0x40000000;
4948 return (imm & 0x7ffff) == 0 && ((imm & 0x7e000000) ^ bs) == 0;
4952 /* Detect the presence of a floating point or integer zero constant,
4956 parse_ifimm_zero (char **in)
4960 if (!is_immediate_prefix (**in))
4964 error_code = atof_generic (in, ".", EXP_CHARS,
4965 &generic_floating_point_number);
4968 && generic_floating_point_number.sign == '+'
4969 && (generic_floating_point_number.low
4970 > generic_floating_point_number.leader))
4976 /* Parse an 8-bit "quarter-precision" floating point number of the form:
4977 0baBbbbbbc defgh000 00000000 00000000.
4978 The zero and minus-zero cases need special handling, since they can't be
4979 encoded in the "quarter-precision" float format, but can nonetheless be
4980 loaded as integer constants. */
4983 parse_qfloat_immediate (char **ccp, int *immed)
4987 LITTLENUM_TYPE words[MAX_LITTLENUMS];
4988 int found_fpchar = 0;
4990 skip_past_char (&str, '#');
4992 /* We must not accidentally parse an integer as a floating-point number. Make
4993 sure that the value we parse is not an integer by checking for special
4994 characters '.' or 'e'.
4995 FIXME: This is a horrible hack, but doing better is tricky because type
4996 information isn't in a very usable state at parse time. */
4998 skip_whitespace (fpnum);
5000 if (strncmp (fpnum, "0x", 2) == 0)
5004 for (; *fpnum != '\0' && *fpnum != ' ' && *fpnum != '\n'; fpnum++)
5005 if (*fpnum == '.' || *fpnum == 'e' || *fpnum == 'E')
5015 if ((str = atof_ieee (str, 's', words)) != NULL)
5017 unsigned fpword = 0;
5020 /* Our FP word must be 32 bits (single-precision FP). */
5021 for (i = 0; i < 32 / LITTLENUM_NUMBER_OF_BITS; i++)
5023 fpword <<= LITTLENUM_NUMBER_OF_BITS;
5027 if (is_quarter_float (fpword) || (fpword & 0x7fffffff) == 0)
5040 /* Shift operands. */
5043 SHIFT_LSL, SHIFT_LSR, SHIFT_ASR, SHIFT_ROR, SHIFT_RRX
5046 struct asm_shift_name
5049 enum shift_kind kind;
5052 /* Third argument to parse_shift. */
5053 enum parse_shift_mode
5055 NO_SHIFT_RESTRICT, /* Any kind of shift is accepted. */
5056 SHIFT_IMMEDIATE, /* Shift operand must be an immediate. */
5057 SHIFT_LSL_OR_ASR_IMMEDIATE, /* Shift must be LSL or ASR immediate. */
5058 SHIFT_ASR_IMMEDIATE, /* Shift must be ASR immediate. */
5059 SHIFT_LSL_IMMEDIATE, /* Shift must be LSL immediate. */
5062 /* Parse a <shift> specifier on an ARM data processing instruction.
5063 This has three forms:
5065 (LSL|LSR|ASL|ASR|ROR) Rs
5066 (LSL|LSR|ASL|ASR|ROR) #imm
5069 Note that ASL is assimilated to LSL in the instruction encoding, and
5070 RRX to ROR #0 (which cannot be written as such). */
5073 parse_shift (char **str, int i, enum parse_shift_mode mode)
5075 const struct asm_shift_name *shift_name;
5076 enum shift_kind shift;
5081 for (p = *str; ISALPHA (*p); p++)
5086 inst.error = _("shift expression expected");
5090 shift_name = (const struct asm_shift_name *) hash_find_n (arm_shift_hsh, *str,
5093 if (shift_name == NULL)
5095 inst.error = _("shift expression expected");
5099 shift = shift_name->kind;
5103 case NO_SHIFT_RESTRICT:
5104 case SHIFT_IMMEDIATE: break;
5106 case SHIFT_LSL_OR_ASR_IMMEDIATE:
5107 if (shift != SHIFT_LSL && shift != SHIFT_ASR)
5109 inst.error = _("'LSL' or 'ASR' required");
5114 case SHIFT_LSL_IMMEDIATE:
5115 if (shift != SHIFT_LSL)
5117 inst.error = _("'LSL' required");
5122 case SHIFT_ASR_IMMEDIATE:
5123 if (shift != SHIFT_ASR)
5125 inst.error = _("'ASR' required");
5133 if (shift != SHIFT_RRX)
5135 /* Whitespace can appear here if the next thing is a bare digit. */
5136 skip_whitespace (p);
5138 if (mode == NO_SHIFT_RESTRICT
5139 && (reg = arm_reg_parse (&p, REG_TYPE_RN)) != FAIL)
5141 inst.operands[i].imm = reg;
5142 inst.operands[i].immisreg = 1;
5144 else if (my_get_expression (&inst.reloc.exp, &p, GE_IMM_PREFIX))
5147 inst.operands[i].shift_kind = shift;
5148 inst.operands[i].shifted = 1;
5153 /* Parse a <shifter_operand> for an ARM data processing instruction:
5156 #<immediate>, <rotate>
5160 where <shift> is defined by parse_shift above, and <rotate> is a
5161 multiple of 2 between 0 and 30. Validation of immediate operands
5162 is deferred to md_apply_fix. */
5165 parse_shifter_operand (char **str, int i)
5170 if ((value = arm_reg_parse (str, REG_TYPE_RN)) != FAIL)
5172 inst.operands[i].reg = value;
5173 inst.operands[i].isreg = 1;
5175 /* parse_shift will override this if appropriate */
5176 inst.reloc.exp.X_op = O_constant;
5177 inst.reloc.exp.X_add_number = 0;
5179 if (skip_past_comma (str) == FAIL)
5182 /* Shift operation on register. */
5183 return parse_shift (str, i, NO_SHIFT_RESTRICT);
5186 if (my_get_expression (&inst.reloc.exp, str, GE_IMM_PREFIX))
5189 if (skip_past_comma (str) == SUCCESS)
5191 /* #x, y -- ie explicit rotation by Y. */
5192 if (my_get_expression (&exp, str, GE_NO_PREFIX))
5195 if (exp.X_op != O_constant || inst.reloc.exp.X_op != O_constant)
5197 inst.error = _("constant expression expected");
5201 value = exp.X_add_number;
5202 if (value < 0 || value > 30 || value % 2 != 0)
5204 inst.error = _("invalid rotation");
5207 if (inst.reloc.exp.X_add_number < 0 || inst.reloc.exp.X_add_number > 255)
5209 inst.error = _("invalid constant");
5213 /* Encode as specified. */
5214 inst.operands[i].imm = inst.reloc.exp.X_add_number | value << 7;
5218 inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
5219 inst.reloc.pc_rel = 0;
5223 /* Group relocation information. Each entry in the table contains the
5224 textual name of the relocation as may appear in assembler source
5225 and must end with a colon.
5226 Along with this textual name are the relocation codes to be used if
5227 the corresponding instruction is an ALU instruction (ADD or SUB only),
5228 an LDR, an LDRS, or an LDC. */
5230 struct group_reloc_table_entry
5241 /* Varieties of non-ALU group relocation. */
5248 static struct group_reloc_table_entry group_reloc_table[] =
5249 { /* Program counter relative: */
5251 BFD_RELOC_ARM_ALU_PC_G0_NC, /* ALU */
5256 BFD_RELOC_ARM_ALU_PC_G0, /* ALU */
5257 BFD_RELOC_ARM_LDR_PC_G0, /* LDR */
5258 BFD_RELOC_ARM_LDRS_PC_G0, /* LDRS */
5259 BFD_RELOC_ARM_LDC_PC_G0 }, /* LDC */
5261 BFD_RELOC_ARM_ALU_PC_G1_NC, /* ALU */
5266 BFD_RELOC_ARM_ALU_PC_G1, /* ALU */
5267 BFD_RELOC_ARM_LDR_PC_G1, /* LDR */
5268 BFD_RELOC_ARM_LDRS_PC_G1, /* LDRS */
5269 BFD_RELOC_ARM_LDC_PC_G1 }, /* LDC */
5271 BFD_RELOC_ARM_ALU_PC_G2, /* ALU */
5272 BFD_RELOC_ARM_LDR_PC_G2, /* LDR */
5273 BFD_RELOC_ARM_LDRS_PC_G2, /* LDRS */
5274 BFD_RELOC_ARM_LDC_PC_G2 }, /* LDC */
5275 /* Section base relative */
5277 BFD_RELOC_ARM_ALU_SB_G0_NC, /* ALU */
5282 BFD_RELOC_ARM_ALU_SB_G0, /* ALU */
5283 BFD_RELOC_ARM_LDR_SB_G0, /* LDR */
5284 BFD_RELOC_ARM_LDRS_SB_G0, /* LDRS */
5285 BFD_RELOC_ARM_LDC_SB_G0 }, /* LDC */
5287 BFD_RELOC_ARM_ALU_SB_G1_NC, /* ALU */
5292 BFD_RELOC_ARM_ALU_SB_G1, /* ALU */
5293 BFD_RELOC_ARM_LDR_SB_G1, /* LDR */
5294 BFD_RELOC_ARM_LDRS_SB_G1, /* LDRS */
5295 BFD_RELOC_ARM_LDC_SB_G1 }, /* LDC */
5297 BFD_RELOC_ARM_ALU_SB_G2, /* ALU */
5298 BFD_RELOC_ARM_LDR_SB_G2, /* LDR */
5299 BFD_RELOC_ARM_LDRS_SB_G2, /* LDRS */
5300 BFD_RELOC_ARM_LDC_SB_G2 } }; /* LDC */
5302 /* Given the address of a pointer pointing to the textual name of a group
5303 relocation as may appear in assembler source, attempt to find its details
5304 in group_reloc_table. The pointer will be updated to the character after
5305 the trailing colon. On failure, FAIL will be returned; SUCCESS
5306 otherwise. On success, *entry will be updated to point at the relevant
5307 group_reloc_table entry. */
5310 find_group_reloc_table_entry (char **str, struct group_reloc_table_entry **out)
5313 for (i = 0; i < ARRAY_SIZE (group_reloc_table); i++)
5315 int length = strlen (group_reloc_table[i].name);
5317 if (strncasecmp (group_reloc_table[i].name, *str, length) == 0
5318 && (*str)[length] == ':')
5320 *out = &group_reloc_table[i];
5321 *str += (length + 1);
5329 /* Parse a <shifter_operand> for an ARM data processing instruction
5330 (as for parse_shifter_operand) where group relocations are allowed:
5333 #<immediate>, <rotate>
5334 #:<group_reloc>:<expression>
5338 where <group_reloc> is one of the strings defined in group_reloc_table.
5339 The hashes are optional.
5341 Everything else is as for parse_shifter_operand. */
5343 static parse_operand_result
5344 parse_shifter_operand_group_reloc (char **str, int i)
5346 /* Determine if we have the sequence of characters #: or just :
5347 coming next. If we do, then we check for a group relocation.
5348 If we don't, punt the whole lot to parse_shifter_operand. */
5350 if (((*str)[0] == '#' && (*str)[1] == ':')
5351 || (*str)[0] == ':')
5353 struct group_reloc_table_entry *entry;
5355 if ((*str)[0] == '#')
5360 /* Try to parse a group relocation. Anything else is an error. */
5361 if (find_group_reloc_table_entry (str, &entry) == FAIL)
5363 inst.error = _("unknown group relocation");
5364 return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5367 /* We now have the group relocation table entry corresponding to
5368 the name in the assembler source. Next, we parse the expression. */
5369 if (my_get_expression (&inst.reloc.exp, str, GE_NO_PREFIX))
5370 return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5372 /* Record the relocation type (always the ALU variant here). */
5373 inst.reloc.type = (bfd_reloc_code_real_type) entry->alu_code;
5374 gas_assert (inst.reloc.type != 0);
5376 return PARSE_OPERAND_SUCCESS;
5379 return parse_shifter_operand (str, i) == SUCCESS
5380 ? PARSE_OPERAND_SUCCESS : PARSE_OPERAND_FAIL;
5382 /* Never reached. */
5385 /* Parse a Neon alignment expression. Information is written to
5386 inst.operands[i]. We assume the initial ':' has been skipped.
5388 align .imm = align << 8, .immisalign=1, .preind=0 */
5389 static parse_operand_result
5390 parse_neon_alignment (char **str, int i)
5395 my_get_expression (&exp, &p, GE_NO_PREFIX);
5397 if (exp.X_op != O_constant)
5399 inst.error = _("alignment must be constant");
5400 return PARSE_OPERAND_FAIL;
5403 inst.operands[i].imm = exp.X_add_number << 8;
5404 inst.operands[i].immisalign = 1;
5405 /* Alignments are not pre-indexes. */
5406 inst.operands[i].preind = 0;
5409 return PARSE_OPERAND_SUCCESS;
5412 /* Parse all forms of an ARM address expression. Information is written
5413 to inst.operands[i] and/or inst.reloc.
5415 Preindexed addressing (.preind=1):
5417 [Rn, #offset] .reg=Rn .reloc.exp=offset
5418 [Rn, +/-Rm] .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5419 [Rn, +/-Rm, shift] .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5420 .shift_kind=shift .reloc.exp=shift_imm
5422 These three may have a trailing ! which causes .writeback to be set also.
5424 Postindexed addressing (.postind=1, .writeback=1):
5426 [Rn], #offset .reg=Rn .reloc.exp=offset
5427 [Rn], +/-Rm .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5428 [Rn], +/-Rm, shift .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
5429 .shift_kind=shift .reloc.exp=shift_imm
5431 Unindexed addressing (.preind=0, .postind=0):
5433 [Rn], {option} .reg=Rn .imm=option .immisreg=0
5437 [Rn]{!} shorthand for [Rn,#0]{!}
5438 =immediate .isreg=0 .reloc.exp=immediate
5439 label .reg=PC .reloc.pc_rel=1 .reloc.exp=label
5441 It is the caller's responsibility to check for addressing modes not
5442 supported by the instruction, and to set inst.reloc.type. */
5444 static parse_operand_result
5445 parse_address_main (char **str, int i, int group_relocations,
5446 group_reloc_type group_type)
5451 if (skip_past_char (&p, '[') == FAIL)
5453 if (skip_past_char (&p, '=') == FAIL)
5455 /* Bare address - translate to PC-relative offset. */
5456 inst.reloc.pc_rel = 1;
5457 inst.operands[i].reg = REG_PC;
5458 inst.operands[i].isreg = 1;
5459 inst.operands[i].preind = 1;
5461 if (my_get_expression (&inst.reloc.exp, &p, GE_OPT_PREFIX_BIG))
5462 return PARSE_OPERAND_FAIL;
5464 else if (parse_big_immediate (&p, i, &inst.reloc.exp,
5465 /*allow_symbol_p=*/TRUE))
5466 return PARSE_OPERAND_FAIL;
5469 return PARSE_OPERAND_SUCCESS;
5472 /* PR gas/14887: Allow for whitespace after the opening bracket. */
5473 skip_whitespace (p);
5475 if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) == FAIL)
5477 inst.error = _(reg_expected_msgs[REG_TYPE_RN]);
5478 return PARSE_OPERAND_FAIL;
5480 inst.operands[i].reg = reg;
5481 inst.operands[i].isreg = 1;
5483 if (skip_past_comma (&p) == SUCCESS)
5485 inst.operands[i].preind = 1;
5488 else if (*p == '-') p++, inst.operands[i].negative = 1;
5490 if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) != FAIL)
5492 inst.operands[i].imm = reg;
5493 inst.operands[i].immisreg = 1;
5495 if (skip_past_comma (&p) == SUCCESS)
5496 if (parse_shift (&p, i, SHIFT_IMMEDIATE) == FAIL)
5497 return PARSE_OPERAND_FAIL;
5499 else if (skip_past_char (&p, ':') == SUCCESS)
5501 /* FIXME: '@' should be used here, but it's filtered out by generic
5502 code before we get to see it here. This may be subject to
5504 parse_operand_result result = parse_neon_alignment (&p, i);
5506 if (result != PARSE_OPERAND_SUCCESS)
5511 if (inst.operands[i].negative)
5513 inst.operands[i].negative = 0;
5517 if (group_relocations
5518 && ((*p == '#' && *(p + 1) == ':') || *p == ':'))
5520 struct group_reloc_table_entry *entry;
5522 /* Skip over the #: or : sequence. */
5528 /* Try to parse a group relocation. Anything else is an
5530 if (find_group_reloc_table_entry (&p, &entry) == FAIL)
5532 inst.error = _("unknown group relocation");
5533 return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5536 /* We now have the group relocation table entry corresponding to
5537 the name in the assembler source. Next, we parse the
5539 if (my_get_expression (&inst.reloc.exp, &p, GE_NO_PREFIX))
5540 return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5542 /* Record the relocation type. */
5546 inst.reloc.type = (bfd_reloc_code_real_type) entry->ldr_code;
5550 inst.reloc.type = (bfd_reloc_code_real_type) entry->ldrs_code;
5554 inst.reloc.type = (bfd_reloc_code_real_type) entry->ldc_code;
5561 if (inst.reloc.type == 0)
5563 inst.error = _("this group relocation is not allowed on this instruction");
5564 return PARSE_OPERAND_FAIL_NO_BACKTRACK;
5570 if (my_get_expression (&inst.reloc.exp, &p, GE_IMM_PREFIX))
5571 return PARSE_OPERAND_FAIL;
5572 /* If the offset is 0, find out if it's a +0 or -0. */
5573 if (inst.reloc.exp.X_op == O_constant
5574 && inst.reloc.exp.X_add_number == 0)
5576 skip_whitespace (q);
5580 skip_whitespace (q);
5583 inst.operands[i].negative = 1;
5588 else if (skip_past_char (&p, ':') == SUCCESS)
5590 /* FIXME: '@' should be used here, but it's filtered out by generic code
5591 before we get to see it here. This may be subject to change. */
5592 parse_operand_result result = parse_neon_alignment (&p, i);
5594 if (result != PARSE_OPERAND_SUCCESS)
5598 if (skip_past_char (&p, ']') == FAIL)
5600 inst.error = _("']' expected");
5601 return PARSE_OPERAND_FAIL;
5604 if (skip_past_char (&p, '!') == SUCCESS)
5605 inst.operands[i].writeback = 1;
5607 else if (skip_past_comma (&p) == SUCCESS)
5609 if (skip_past_char (&p, '{') == SUCCESS)
5611 /* [Rn], {expr} - unindexed, with option */
5612 if (parse_immediate (&p, &inst.operands[i].imm,
5613 0, 255, TRUE) == FAIL)
5614 return PARSE_OPERAND_FAIL;
5616 if (skip_past_char (&p, '}') == FAIL)
5618 inst.error = _("'}' expected at end of 'option' field");
5619 return PARSE_OPERAND_FAIL;
5621 if (inst.operands[i].preind)
5623 inst.error = _("cannot combine index with option");
5624 return PARSE_OPERAND_FAIL;
5627 return PARSE_OPERAND_SUCCESS;
5631 inst.operands[i].postind = 1;
5632 inst.operands[i].writeback = 1;
5634 if (inst.operands[i].preind)
5636 inst.error = _("cannot combine pre- and post-indexing");
5637 return PARSE_OPERAND_FAIL;
5641 else if (*p == '-') p++, inst.operands[i].negative = 1;
5643 if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) != FAIL)
5645 /* We might be using the immediate for alignment already. If we
5646 are, OR the register number into the low-order bits. */
5647 if (inst.operands[i].immisalign)
5648 inst.operands[i].imm |= reg;
5650 inst.operands[i].imm = reg;
5651 inst.operands[i].immisreg = 1;
5653 if (skip_past_comma (&p) == SUCCESS)
5654 if (parse_shift (&p, i, SHIFT_IMMEDIATE) == FAIL)
5655 return PARSE_OPERAND_FAIL;
5660 if (inst.operands[i].negative)
5662 inst.operands[i].negative = 0;
5665 if (my_get_expression (&inst.reloc.exp, &p, GE_IMM_PREFIX))
5666 return PARSE_OPERAND_FAIL;
5667 /* If the offset is 0, find out if it's a +0 or -0. */
5668 if (inst.reloc.exp.X_op == O_constant
5669 && inst.reloc.exp.X_add_number == 0)
5671 skip_whitespace (q);
5675 skip_whitespace (q);
5678 inst.operands[i].negative = 1;
5684 /* If at this point neither .preind nor .postind is set, we have a
5685 bare [Rn]{!}, which is shorthand for [Rn,#0]{!}. */
5686 if (inst.operands[i].preind == 0 && inst.operands[i].postind == 0)
5688 inst.operands[i].preind = 1;
5689 inst.reloc.exp.X_op = O_constant;
5690 inst.reloc.exp.X_add_number = 0;
5693 return PARSE_OPERAND_SUCCESS;
5697 parse_address (char **str, int i)
5699 return parse_address_main (str, i, 0, GROUP_LDR) == PARSE_OPERAND_SUCCESS
5703 static parse_operand_result
5704 parse_address_group_reloc (char **str, int i, group_reloc_type type)
5706 return parse_address_main (str, i, 1, type);
5709 /* Parse an operand for a MOVW or MOVT instruction. */
5711 parse_half (char **str)
5716 skip_past_char (&p, '#');
5717 if (strncasecmp (p, ":lower16:", 9) == 0)
5718 inst.reloc.type = BFD_RELOC_ARM_MOVW;
5719 else if (strncasecmp (p, ":upper16:", 9) == 0)
5720 inst.reloc.type = BFD_RELOC_ARM_MOVT;
5722 if (inst.reloc.type != BFD_RELOC_UNUSED)
5725 skip_whitespace (p);
5728 if (my_get_expression (&inst.reloc.exp, &p, GE_NO_PREFIX))
5731 if (inst.reloc.type == BFD_RELOC_UNUSED)
5733 if (inst.reloc.exp.X_op != O_constant)
5735 inst.error = _("constant expression expected");
5738 if (inst.reloc.exp.X_add_number < 0
5739 || inst.reloc.exp.X_add_number > 0xffff)
5741 inst.error = _("immediate value out of range");
5749 /* Miscellaneous. */
5751 /* Parse a PSR flag operand. The value returned is FAIL on syntax error,
5752 or a bitmask suitable to be or-ed into the ARM msr instruction. */
5754 parse_psr (char **str, bfd_boolean lhs)
5757 unsigned long psr_field;
5758 const struct asm_psr *psr;
5760 bfd_boolean is_apsr = FALSE;
5761 bfd_boolean m_profile = ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_m);
5763 /* PR gas/12698: If the user has specified -march=all then m_profile will
5764 be TRUE, but we want to ignore it in this case as we are building for any
5765 CPU type, including non-m variants. */
5766 if (selected_cpu.core == arm_arch_any.core)
5769 /* CPSR's and SPSR's can now be lowercase. This is just a convenience
5770 feature for ease of use and backwards compatibility. */
5772 if (strncasecmp (p, "SPSR", 4) == 0)
5775 goto unsupported_psr;
5777 psr_field = SPSR_BIT;
5779 else if (strncasecmp (p, "CPSR", 4) == 0)
5782 goto unsupported_psr;
5786 else if (strncasecmp (p, "APSR", 4) == 0)
5788 /* APSR[_<bits>] can be used as a synonym for CPSR[_<flags>] on ARMv7-A
5789 and ARMv7-R architecture CPUs. */
5798 while (ISALNUM (*p) || *p == '_');
5800 if (strncasecmp (start, "iapsr", 5) == 0
5801 || strncasecmp (start, "eapsr", 5) == 0
5802 || strncasecmp (start, "xpsr", 4) == 0
5803 || strncasecmp (start, "psr", 3) == 0)
5804 p = start + strcspn (start, "rR") + 1;
5806 psr = (const struct asm_psr *) hash_find_n (arm_v7m_psr_hsh, start,
5812 /* If APSR is being written, a bitfield may be specified. Note that
5813 APSR itself is handled above. */
5814 if (psr->field <= 3)
5816 psr_field = psr->field;
5822 /* M-profile MSR instructions have the mask field set to "10", except
5823 *PSR variants which modify APSR, which may use a different mask (and
5824 have been handled already). Do that by setting the PSR_f field
5826 return psr->field | (lhs ? PSR_f : 0);
5829 goto unsupported_psr;
5835 /* A suffix follows. */
5841 while (ISALNUM (*p) || *p == '_');
5845 /* APSR uses a notation for bits, rather than fields. */
5846 unsigned int nzcvq_bits = 0;
5847 unsigned int g_bit = 0;
5850 for (bit = start; bit != p; bit++)
5852 switch (TOLOWER (*bit))
5855 nzcvq_bits |= (nzcvq_bits & 0x01) ? 0x20 : 0x01;
5859 nzcvq_bits |= (nzcvq_bits & 0x02) ? 0x20 : 0x02;
5863 nzcvq_bits |= (nzcvq_bits & 0x04) ? 0x20 : 0x04;
5867 nzcvq_bits |= (nzcvq_bits & 0x08) ? 0x20 : 0x08;
5871 nzcvq_bits |= (nzcvq_bits & 0x10) ? 0x20 : 0x10;
5875 g_bit |= (g_bit & 0x1) ? 0x2 : 0x1;
5879 inst.error = _("unexpected bit specified after APSR");
5884 if (nzcvq_bits == 0x1f)
5889 if (!ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6_dsp))
5891 inst.error = _("selected processor does not "
5892 "support DSP extension");
5899 if ((nzcvq_bits & 0x20) != 0
5900 || (nzcvq_bits != 0x1f && nzcvq_bits != 0)
5901 || (g_bit & 0x2) != 0)
5903 inst.error = _("bad bitmask specified after APSR");
5909 psr = (const struct asm_psr *) hash_find_n (arm_psr_hsh, start,
5914 psr_field |= psr->field;
5920 goto error; /* Garbage after "[CS]PSR". */
5922 /* Unadorned APSR is equivalent to APSR_nzcvq/CPSR_f (for writes). This
5923 is deprecated, but allow it anyway. */
5927 as_tsktsk (_("writing to APSR without specifying a bitmask is "
5930 else if (!m_profile)
5931 /* These bits are never right for M-profile devices: don't set them
5932 (only code paths which read/write APSR reach here). */
5933 psr_field |= (PSR_c | PSR_f);
5939 inst.error = _("selected processor does not support requested special "
5940 "purpose register");
5944 inst.error = _("flag for {c}psr instruction expected");
5948 /* Parse the flags argument to CPSI[ED]. Returns FAIL on error, or a
5949 value suitable for splatting into the AIF field of the instruction. */
5952 parse_cps_flags (char **str)
5961 case '\0': case ',':
5964 case 'a': case 'A': saw_a_flag = 1; val |= 0x4; break;
5965 case 'i': case 'I': saw_a_flag = 1; val |= 0x2; break;
5966 case 'f': case 'F': saw_a_flag = 1; val |= 0x1; break;
5969 inst.error = _("unrecognized CPS flag");
5974 if (saw_a_flag == 0)
5976 inst.error = _("missing CPS flags");
5984 /* Parse an endian specifier ("BE" or "LE", case insensitive);
5985 returns 0 for big-endian, 1 for little-endian, FAIL for an error. */
5988 parse_endian_specifier (char **str)
5993 if (strncasecmp (s, "BE", 2))
5995 else if (strncasecmp (s, "LE", 2))
5999 inst.error = _("valid endian specifiers are be or le");
6003 if (ISALNUM (s[2]) || s[2] == '_')
6005 inst.error = _("valid endian specifiers are be or le");
6010 return little_endian;
6013 /* Parse a rotation specifier: ROR #0, #8, #16, #24. *val receives a
6014 value suitable for poking into the rotate field of an sxt or sxta
6015 instruction, or FAIL on error. */
6018 parse_ror (char **str)
6023 if (strncasecmp (s, "ROR", 3) == 0)
6027 inst.error = _("missing rotation field after comma");
6031 if (parse_immediate (&s, &rot, 0, 24, FALSE) == FAIL)
6036 case 0: *str = s; return 0x0;
6037 case 8: *str = s; return 0x1;
6038 case 16: *str = s; return 0x2;
6039 case 24: *str = s; return 0x3;
6042 inst.error = _("rotation can only be 0, 8, 16, or 24");
6047 /* Parse a conditional code (from conds[] below). The value returned is in the
6048 range 0 .. 14, or FAIL. */
6050 parse_cond (char **str)
6053 const struct asm_cond *c;
6055 /* Condition codes are always 2 characters, so matching up to
6056 3 characters is sufficient. */
6061 while (ISALPHA (*q) && n < 3)
6063 cond[n] = TOLOWER (*q);
6068 c = (const struct asm_cond *) hash_find_n (arm_cond_hsh, cond, n);
6071 inst.error = _("condition required");
6079 /* If the given feature available in the selected CPU, mark it as used.
6080 Returns TRUE iff feature is available. */
6082 mark_feature_used (const arm_feature_set *feature)
6084 /* Ensure the option is valid on the current architecture. */
6085 if (!ARM_CPU_HAS_FEATURE (cpu_variant, *feature))
6088 /* Add the appropriate architecture feature for the barrier option used.
6091 ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used, *feature);
6093 ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used, *feature);
6098 /* Parse an option for a barrier instruction. Returns the encoding for the
6101 parse_barrier (char **str)
6104 const struct asm_barrier_opt *o;
6107 while (ISALPHA (*q))
6110 o = (const struct asm_barrier_opt *) hash_find_n (arm_barrier_opt_hsh, p,
6115 if (!mark_feature_used (&o->arch))
6122 /* Parse the operands of a table branch instruction. Similar to a memory
6125 parse_tb (char **str)
6130 if (skip_past_char (&p, '[') == FAIL)
6132 inst.error = _("'[' expected");
6136 if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) == FAIL)
6138 inst.error = _(reg_expected_msgs[REG_TYPE_RN]);
6141 inst.operands[0].reg = reg;
6143 if (skip_past_comma (&p) == FAIL)
6145 inst.error = _("',' expected");
6149 if ((reg = arm_reg_parse (&p, REG_TYPE_RN)) == FAIL)
6151 inst.error = _(reg_expected_msgs[REG_TYPE_RN]);
6154 inst.operands[0].imm = reg;
6156 if (skip_past_comma (&p) == SUCCESS)
6158 if (parse_shift (&p, 0, SHIFT_LSL_IMMEDIATE) == FAIL)
6160 if (inst.reloc.exp.X_add_number != 1)
6162 inst.error = _("invalid shift");
6165 inst.operands[0].shifted = 1;
6168 if (skip_past_char (&p, ']') == FAIL)
6170 inst.error = _("']' expected");
6177 /* Parse the operands of a Neon VMOV instruction. See do_neon_mov for more
6178 information on the types the operands can take and how they are encoded.
6179 Up to four operands may be read; this function handles setting the
6180 ".present" field for each read operand itself.
6181 Updates STR and WHICH_OPERAND if parsing is successful and returns SUCCESS,
6182 else returns FAIL. */
6185 parse_neon_mov (char **str, int *which_operand)
6187 int i = *which_operand, val;
6188 enum arm_reg_type rtype;
6190 struct neon_type_el optype;
6192 if ((val = parse_scalar (&ptr, 8, &optype)) != FAIL)
6194 /* Case 4: VMOV<c><q>.<size> <Dn[x]>, <Rd>. */
6195 inst.operands[i].reg = val;
6196 inst.operands[i].isscalar = 1;
6197 inst.operands[i].vectype = optype;
6198 inst.operands[i++].present = 1;
6200 if (skip_past_comma (&ptr) == FAIL)
6203 if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
6206 inst.operands[i].reg = val;
6207 inst.operands[i].isreg = 1;
6208 inst.operands[i].present = 1;
6210 else if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_NSDQ, &rtype, &optype))
6213 /* Cases 0, 1, 2, 3, 5 (D only). */
6214 if (skip_past_comma (&ptr) == FAIL)
6217 inst.operands[i].reg = val;
6218 inst.operands[i].isreg = 1;
6219 inst.operands[i].isquad = (rtype == REG_TYPE_NQ);
6220 inst.operands[i].issingle = (rtype == REG_TYPE_VFS);
6221 inst.operands[i].isvec = 1;
6222 inst.operands[i].vectype = optype;
6223 inst.operands[i++].present = 1;
6225 if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) != FAIL)
6227 /* Case 5: VMOV<c><q> <Dm>, <Rd>, <Rn>.
6228 Case 13: VMOV <Sd>, <Rm> */
6229 inst.operands[i].reg = val;
6230 inst.operands[i].isreg = 1;
6231 inst.operands[i].present = 1;
6233 if (rtype == REG_TYPE_NQ)
6235 first_error (_("can't use Neon quad register here"));
6238 else if (rtype != REG_TYPE_VFS)
6241 if (skip_past_comma (&ptr) == FAIL)
6243 if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
6245 inst.operands[i].reg = val;
6246 inst.operands[i].isreg = 1;
6247 inst.operands[i].present = 1;
6250 else if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_NSDQ, &rtype,
6253 /* Case 0: VMOV<c><q> <Qd>, <Qm>
6254 Case 1: VMOV<c><q> <Dd>, <Dm>
6255 Case 8: VMOV.F32 <Sd>, <Sm>
6256 Case 15: VMOV <Sd>, <Se>, <Rn>, <Rm> */
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 = 1;
6263 inst.operands[i].vectype = optype;
6264 inst.operands[i].present = 1;
6266 if (skip_past_comma (&ptr) == SUCCESS)
6271 if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
6274 inst.operands[i].reg = val;
6275 inst.operands[i].isreg = 1;
6276 inst.operands[i++].present = 1;
6278 if (skip_past_comma (&ptr) == FAIL)
6281 if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) == FAIL)
6284 inst.operands[i].reg = val;
6285 inst.operands[i].isreg = 1;
6286 inst.operands[i].present = 1;
6289 else if (parse_qfloat_immediate (&ptr, &inst.operands[i].imm) == SUCCESS)
6290 /* Case 2: VMOV<c><q>.<dt> <Qd>, #<float-imm>
6291 Case 3: VMOV<c><q>.<dt> <Dd>, #<float-imm>
6292 Case 10: VMOV.F32 <Sd>, #<imm>
6293 Case 11: VMOV.F64 <Dd>, #<imm> */
6294 inst.operands[i].immisfloat = 1;
6295 else if (parse_big_immediate (&ptr, i, NULL, /*allow_symbol_p=*/FALSE)
6297 /* Case 2: VMOV<c><q>.<dt> <Qd>, #<imm>
6298 Case 3: VMOV<c><q>.<dt> <Dd>, #<imm> */
6302 first_error (_("expected <Rm> or <Dm> or <Qm> operand"));
6306 else if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) != FAIL)
6309 inst.operands[i].reg = val;
6310 inst.operands[i].isreg = 1;
6311 inst.operands[i++].present = 1;
6313 if (skip_past_comma (&ptr) == FAIL)
6316 if ((val = parse_scalar (&ptr, 8, &optype)) != FAIL)
6318 /* Case 6: VMOV<c><q>.<dt> <Rd>, <Dn[x]> */
6319 inst.operands[i].reg = val;
6320 inst.operands[i].isscalar = 1;
6321 inst.operands[i].present = 1;
6322 inst.operands[i].vectype = optype;
6324 else if ((val = arm_reg_parse (&ptr, REG_TYPE_RN)) != FAIL)
6326 /* Case 7: VMOV<c><q> <Rd>, <Rn>, <Dm> */
6327 inst.operands[i].reg = val;
6328 inst.operands[i].isreg = 1;
6329 inst.operands[i++].present = 1;
6331 if (skip_past_comma (&ptr) == FAIL)
6334 if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_VFSD, &rtype, &optype))
6337 first_error (_(reg_expected_msgs[REG_TYPE_VFSD]));
6341 inst.operands[i].reg = val;
6342 inst.operands[i].isreg = 1;
6343 inst.operands[i].isvec = 1;
6344 inst.operands[i].issingle = (rtype == REG_TYPE_VFS);
6345 inst.operands[i].vectype = optype;
6346 inst.operands[i].present = 1;
6348 if (rtype == REG_TYPE_VFS)
6352 if (skip_past_comma (&ptr) == FAIL)
6354 if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_VFS, NULL,
6357 first_error (_(reg_expected_msgs[REG_TYPE_VFS]));
6360 inst.operands[i].reg = val;
6361 inst.operands[i].isreg = 1;
6362 inst.operands[i].isvec = 1;
6363 inst.operands[i].issingle = 1;
6364 inst.operands[i].vectype = optype;
6365 inst.operands[i].present = 1;
6368 else if ((val = arm_typed_reg_parse (&ptr, REG_TYPE_VFS, NULL, &optype))
6372 inst.operands[i].reg = val;
6373 inst.operands[i].isreg = 1;
6374 inst.operands[i].isvec = 1;
6375 inst.operands[i].issingle = 1;
6376 inst.operands[i].vectype = optype;
6377 inst.operands[i].present = 1;
6382 first_error (_("parse error"));
6386 /* Successfully parsed the operands. Update args. */
6392 first_error (_("expected comma"));
6396 first_error (_(reg_expected_msgs[REG_TYPE_RN]));
6400 /* Use this macro when the operand constraints are different
6401 for ARM and THUMB (e.g. ldrd). */
6402 #define MIX_ARM_THUMB_OPERANDS(arm_operand, thumb_operand) \
6403 ((arm_operand) | ((thumb_operand) << 16))
6405 /* Matcher codes for parse_operands. */
6406 enum operand_parse_code
6408 OP_stop, /* end of line */
6410 OP_RR, /* ARM register */
6411 OP_RRnpc, /* ARM register, not r15 */
6412 OP_RRnpcsp, /* ARM register, neither r15 nor r13 (a.k.a. 'BadReg') */
6413 OP_RRnpcb, /* ARM register, not r15, in square brackets */
6414 OP_RRnpctw, /* ARM register, not r15 in Thumb-state or with writeback,
6415 optional trailing ! */
6416 OP_RRw, /* ARM register, not r15, optional trailing ! */
6417 OP_RCP, /* Coprocessor number */
6418 OP_RCN, /* Coprocessor register */
6419 OP_RF, /* FPA register */
6420 OP_RVS, /* VFP single precision register */
6421 OP_RVD, /* VFP double precision register (0..15) */
6422 OP_RND, /* Neon double precision register (0..31) */
6423 OP_RNQ, /* Neon quad precision register */
6424 OP_RVSD, /* VFP single or double precision register */
6425 OP_RNDQ, /* Neon double or quad precision register */
6426 OP_RNSDQ, /* Neon single, double or quad precision register */
6427 OP_RNSC, /* Neon scalar D[X] */
6428 OP_RVC, /* VFP control register */
6429 OP_RMF, /* Maverick F register */
6430 OP_RMD, /* Maverick D register */
6431 OP_RMFX, /* Maverick FX register */
6432 OP_RMDX, /* Maverick DX register */
6433 OP_RMAX, /* Maverick AX register */
6434 OP_RMDS, /* Maverick DSPSC register */
6435 OP_RIWR, /* iWMMXt wR register */
6436 OP_RIWC, /* iWMMXt wC register */
6437 OP_RIWG, /* iWMMXt wCG register */
6438 OP_RXA, /* XScale accumulator register */
6440 OP_REGLST, /* ARM register list */
6441 OP_VRSLST, /* VFP single-precision register list */
6442 OP_VRDLST, /* VFP double-precision register list */
6443 OP_VRSDLST, /* VFP single or double-precision register list (& quad) */
6444 OP_NRDLST, /* Neon double-precision register list (d0-d31, qN aliases) */
6445 OP_NSTRLST, /* Neon element/structure list */
6447 OP_RNDQ_I0, /* Neon D or Q reg, or immediate zero. */
6448 OP_RVSD_I0, /* VFP S or D reg, or immediate zero. */
6449 OP_RSVD_FI0, /* VFP S or D reg, or floating point immediate zero. */
6450 OP_RR_RNSC, /* ARM reg or Neon scalar. */
6451 OP_RNSDQ_RNSC, /* Vector S, D or Q reg, or Neon scalar. */
6452 OP_RNDQ_RNSC, /* Neon D or Q reg, or Neon scalar. */
6453 OP_RND_RNSC, /* Neon D reg, or Neon scalar. */
6454 OP_VMOV, /* Neon VMOV operands. */
6455 OP_RNDQ_Ibig, /* Neon D or Q reg, or big immediate for logic and VMVN. */
6456 OP_RNDQ_I63b, /* Neon D or Q reg, or immediate for shift. */
6457 OP_RIWR_I32z, /* iWMMXt wR register, or immediate 0 .. 32 for iWMMXt2. */
6459 OP_I0, /* immediate zero */
6460 OP_I7, /* immediate value 0 .. 7 */
6461 OP_I15, /* 0 .. 15 */
6462 OP_I16, /* 1 .. 16 */
6463 OP_I16z, /* 0 .. 16 */
6464 OP_I31, /* 0 .. 31 */
6465 OP_I31w, /* 0 .. 31, optional trailing ! */
6466 OP_I32, /* 1 .. 32 */
6467 OP_I32z, /* 0 .. 32 */
6468 OP_I63, /* 0 .. 63 */
6469 OP_I63s, /* -64 .. 63 */
6470 OP_I64, /* 1 .. 64 */
6471 OP_I64z, /* 0 .. 64 */
6472 OP_I255, /* 0 .. 255 */
6474 OP_I4b, /* immediate, prefix optional, 1 .. 4 */
6475 OP_I7b, /* 0 .. 7 */
6476 OP_I15b, /* 0 .. 15 */
6477 OP_I31b, /* 0 .. 31 */
6479 OP_SH, /* shifter operand */
6480 OP_SHG, /* shifter operand with possible group relocation */
6481 OP_ADDR, /* Memory address expression (any mode) */
6482 OP_ADDRGLDR, /* Mem addr expr (any mode) with possible LDR group reloc */
6483 OP_ADDRGLDRS, /* Mem addr expr (any mode) with possible LDRS group reloc */
6484 OP_ADDRGLDC, /* Mem addr expr (any mode) with possible LDC group reloc */
6485 OP_EXP, /* arbitrary expression */
6486 OP_EXPi, /* same, with optional immediate prefix */
6487 OP_EXPr, /* same, with optional relocation suffix */
6488 OP_HALF, /* 0 .. 65535 or low/high reloc. */
6490 OP_CPSF, /* CPS flags */
6491 OP_ENDI, /* Endianness specifier */
6492 OP_wPSR, /* CPSR/SPSR/APSR mask for msr (writing). */
6493 OP_rPSR, /* CPSR/SPSR/APSR mask for msr (reading). */
6494 OP_COND, /* conditional code */
6495 OP_TB, /* Table branch. */
6497 OP_APSR_RR, /* ARM register or "APSR_nzcv". */
6499 OP_RRnpc_I0, /* ARM register or literal 0 */
6500 OP_RR_EXr, /* ARM register or expression with opt. reloc suff. */
6501 OP_RR_EXi, /* ARM register or expression with imm prefix */
6502 OP_RF_IF, /* FPA register or immediate */
6503 OP_RIWR_RIWC, /* iWMMXt R or C reg */
6504 OP_RIWC_RIWG, /* iWMMXt wC or wCG reg */
6506 /* Optional operands. */
6507 OP_oI7b, /* immediate, prefix optional, 0 .. 7 */
6508 OP_oI31b, /* 0 .. 31 */
6509 OP_oI32b, /* 1 .. 32 */
6510 OP_oI32z, /* 0 .. 32 */
6511 OP_oIffffb, /* 0 .. 65535 */
6512 OP_oI255c, /* curly-brace enclosed, 0 .. 255 */
6514 OP_oRR, /* ARM register */
6515 OP_oRRnpc, /* ARM register, not the PC */
6516 OP_oRRnpcsp, /* ARM register, neither the PC nor the SP (a.k.a. BadReg) */
6517 OP_oRRw, /* ARM register, not r15, optional trailing ! */
6518 OP_oRND, /* Optional Neon double precision register */
6519 OP_oRNQ, /* Optional Neon quad precision register */
6520 OP_oRNDQ, /* Optional Neon double or quad precision register */
6521 OP_oRNSDQ, /* Optional single, double or quad precision vector register */
6522 OP_oSHll, /* LSL immediate */
6523 OP_oSHar, /* ASR immediate */
6524 OP_oSHllar, /* LSL or ASR immediate */
6525 OP_oROR, /* ROR 0/8/16/24 */
6526 OP_oBARRIER_I15, /* Option argument for a barrier instruction. */
6528 /* Some pre-defined mixed (ARM/THUMB) operands. */
6529 OP_RR_npcsp = MIX_ARM_THUMB_OPERANDS (OP_RR, OP_RRnpcsp),
6530 OP_RRnpc_npcsp = MIX_ARM_THUMB_OPERANDS (OP_RRnpc, OP_RRnpcsp),
6531 OP_oRRnpc_npcsp = MIX_ARM_THUMB_OPERANDS (OP_oRRnpc, OP_oRRnpcsp),
6533 OP_FIRST_OPTIONAL = OP_oI7b
6536 /* Generic instruction operand parser. This does no encoding and no
6537 semantic validation; it merely squirrels values away in the inst
6538 structure. Returns SUCCESS or FAIL depending on whether the
6539 specified grammar matched. */
6541 parse_operands (char *str, const unsigned int *pattern, bfd_boolean thumb)
6543 unsigned const int *upat = pattern;
6544 char *backtrack_pos = 0;
6545 const char *backtrack_error = 0;
6546 int i, val = 0, backtrack_index = 0;
6547 enum arm_reg_type rtype;
6548 parse_operand_result result;
6549 unsigned int op_parse_code;
6551 #define po_char_or_fail(chr) \
6554 if (skip_past_char (&str, chr) == FAIL) \
6559 #define po_reg_or_fail(regtype) \
6562 val = arm_typed_reg_parse (& str, regtype, & rtype, \
6563 & inst.operands[i].vectype); \
6566 first_error (_(reg_expected_msgs[regtype])); \
6569 inst.operands[i].reg = val; \
6570 inst.operands[i].isreg = 1; \
6571 inst.operands[i].isquad = (rtype == REG_TYPE_NQ); \
6572 inst.operands[i].issingle = (rtype == REG_TYPE_VFS); \
6573 inst.operands[i].isvec = (rtype == REG_TYPE_VFS \
6574 || rtype == REG_TYPE_VFD \
6575 || rtype == REG_TYPE_NQ); \
6579 #define po_reg_or_goto(regtype, label) \
6582 val = arm_typed_reg_parse (& str, regtype, & rtype, \
6583 & inst.operands[i].vectype); \
6587 inst.operands[i].reg = val; \
6588 inst.operands[i].isreg = 1; \
6589 inst.operands[i].isquad = (rtype == REG_TYPE_NQ); \
6590 inst.operands[i].issingle = (rtype == REG_TYPE_VFS); \
6591 inst.operands[i].isvec = (rtype == REG_TYPE_VFS \
6592 || rtype == REG_TYPE_VFD \
6593 || rtype == REG_TYPE_NQ); \
6597 #define po_imm_or_fail(min, max, popt) \
6600 if (parse_immediate (&str, &val, min, max, popt) == FAIL) \
6602 inst.operands[i].imm = val; \
6606 #define po_scalar_or_goto(elsz, label) \
6609 val = parse_scalar (& str, elsz, & inst.operands[i].vectype); \
6612 inst.operands[i].reg = val; \
6613 inst.operands[i].isscalar = 1; \
6617 #define po_misc_or_fail(expr) \
6625 #define po_misc_or_fail_no_backtrack(expr) \
6629 if (result == PARSE_OPERAND_FAIL_NO_BACKTRACK) \
6630 backtrack_pos = 0; \
6631 if (result != PARSE_OPERAND_SUCCESS) \
6636 #define po_barrier_or_imm(str) \
6639 val = parse_barrier (&str); \
6640 if (val == FAIL && ! ISALPHA (*str)) \
6643 /* ISB can only take SY as an option. */ \
6644 || ((inst.instruction & 0xf0) == 0x60 \
6647 inst.error = _("invalid barrier type"); \
6648 backtrack_pos = 0; \
6654 skip_whitespace (str);
6656 for (i = 0; upat[i] != OP_stop; i++)
6658 op_parse_code = upat[i];
6659 if (op_parse_code >= 1<<16)
6660 op_parse_code = thumb ? (op_parse_code >> 16)
6661 : (op_parse_code & ((1<<16)-1));
6663 if (op_parse_code >= OP_FIRST_OPTIONAL)
6665 /* Remember where we are in case we need to backtrack. */
6666 gas_assert (!backtrack_pos);
6667 backtrack_pos = str;
6668 backtrack_error = inst.error;
6669 backtrack_index = i;
6672 if (i > 0 && (i > 1 || inst.operands[0].present))
6673 po_char_or_fail (',');
6675 switch (op_parse_code)
6683 case OP_RR: po_reg_or_fail (REG_TYPE_RN); break;
6684 case OP_RCP: po_reg_or_fail (REG_TYPE_CP); break;
6685 case OP_RCN: po_reg_or_fail (REG_TYPE_CN); break;
6686 case OP_RF: po_reg_or_fail (REG_TYPE_FN); break;
6687 case OP_RVS: po_reg_or_fail (REG_TYPE_VFS); break;
6688 case OP_RVD: po_reg_or_fail (REG_TYPE_VFD); break;
6690 case OP_RND: po_reg_or_fail (REG_TYPE_VFD); break;
6692 po_reg_or_goto (REG_TYPE_VFC, coproc_reg);
6694 /* Also accept generic coprocessor regs for unknown registers. */
6696 po_reg_or_fail (REG_TYPE_CN);
6698 case OP_RMF: po_reg_or_fail (REG_TYPE_MVF); break;
6699 case OP_RMD: po_reg_or_fail (REG_TYPE_MVD); break;
6700 case OP_RMFX: po_reg_or_fail (REG_TYPE_MVFX); break;
6701 case OP_RMDX: po_reg_or_fail (REG_TYPE_MVDX); break;
6702 case OP_RMAX: po_reg_or_fail (REG_TYPE_MVAX); break;
6703 case OP_RMDS: po_reg_or_fail (REG_TYPE_DSPSC); break;
6704 case OP_RIWR: po_reg_or_fail (REG_TYPE_MMXWR); break;
6705 case OP_RIWC: po_reg_or_fail (REG_TYPE_MMXWC); break;
6706 case OP_RIWG: po_reg_or_fail (REG_TYPE_MMXWCG); break;
6707 case OP_RXA: po_reg_or_fail (REG_TYPE_XSCALE); break;
6709 case OP_RNQ: po_reg_or_fail (REG_TYPE_NQ); break;
6711 case OP_RNDQ: po_reg_or_fail (REG_TYPE_NDQ); break;
6712 case OP_RVSD: po_reg_or_fail (REG_TYPE_VFSD); break;
6714 case OP_RNSDQ: po_reg_or_fail (REG_TYPE_NSDQ); break;
6716 /* Neon scalar. Using an element size of 8 means that some invalid
6717 scalars are accepted here, so deal with those in later code. */
6718 case OP_RNSC: po_scalar_or_goto (8, failure); break;
6722 po_reg_or_goto (REG_TYPE_NDQ, try_imm0);
6725 po_imm_or_fail (0, 0, TRUE);
6730 po_reg_or_goto (REG_TYPE_VFSD, try_imm0);
6735 po_reg_or_goto (REG_TYPE_VFSD, try_ifimm0);
6738 if (parse_ifimm_zero (&str))
6739 inst.operands[i].imm = 0;
6743 = _("only floating point zero is allowed as immediate value");
6751 po_scalar_or_goto (8, try_rr);
6754 po_reg_or_fail (REG_TYPE_RN);
6760 po_scalar_or_goto (8, try_nsdq);
6763 po_reg_or_fail (REG_TYPE_NSDQ);
6769 po_scalar_or_goto (8, try_ndq);
6772 po_reg_or_fail (REG_TYPE_NDQ);
6778 po_scalar_or_goto (8, try_vfd);
6781 po_reg_or_fail (REG_TYPE_VFD);
6786 /* WARNING: parse_neon_mov can move the operand counter, i. If we're
6787 not careful then bad things might happen. */
6788 po_misc_or_fail (parse_neon_mov (&str, &i) == FAIL);
6793 po_reg_or_goto (REG_TYPE_NDQ, try_immbig);
6796 /* There's a possibility of getting a 64-bit immediate here, so
6797 we need special handling. */
6798 if (parse_big_immediate (&str, i, NULL, /*allow_symbol_p=*/FALSE)
6801 inst.error = _("immediate value is out of range");
6809 po_reg_or_goto (REG_TYPE_NDQ, try_shimm);
6812 po_imm_or_fail (0, 63, TRUE);
6817 po_char_or_fail ('[');
6818 po_reg_or_fail (REG_TYPE_RN);
6819 po_char_or_fail (']');
6825 po_reg_or_fail (REG_TYPE_RN);
6826 if (skip_past_char (&str, '!') == SUCCESS)
6827 inst.operands[i].writeback = 1;
6831 case OP_I7: po_imm_or_fail ( 0, 7, FALSE); break;
6832 case OP_I15: po_imm_or_fail ( 0, 15, FALSE); break;
6833 case OP_I16: po_imm_or_fail ( 1, 16, FALSE); break;
6834 case OP_I16z: po_imm_or_fail ( 0, 16, FALSE); break;
6835 case OP_I31: po_imm_or_fail ( 0, 31, FALSE); break;
6836 case OP_I32: po_imm_or_fail ( 1, 32, FALSE); break;
6837 case OP_I32z: po_imm_or_fail ( 0, 32, FALSE); break;
6838 case OP_I63s: po_imm_or_fail (-64, 63, FALSE); break;
6839 case OP_I63: po_imm_or_fail ( 0, 63, FALSE); break;
6840 case OP_I64: po_imm_or_fail ( 1, 64, FALSE); break;
6841 case OP_I64z: po_imm_or_fail ( 0, 64, FALSE); break;
6842 case OP_I255: po_imm_or_fail ( 0, 255, FALSE); break;
6844 case OP_I4b: po_imm_or_fail ( 1, 4, TRUE); break;
6846 case OP_I7b: po_imm_or_fail ( 0, 7, TRUE); break;
6847 case OP_I15b: po_imm_or_fail ( 0, 15, TRUE); break;
6849 case OP_I31b: po_imm_or_fail ( 0, 31, TRUE); break;
6850 case OP_oI32b: po_imm_or_fail ( 1, 32, TRUE); break;
6851 case OP_oI32z: po_imm_or_fail ( 0, 32, TRUE); break;
6852 case OP_oIffffb: po_imm_or_fail ( 0, 0xffff, TRUE); break;
6854 /* Immediate variants */
6856 po_char_or_fail ('{');
6857 po_imm_or_fail (0, 255, TRUE);
6858 po_char_or_fail ('}');
6862 /* The expression parser chokes on a trailing !, so we have
6863 to find it first and zap it. */
6866 while (*s && *s != ',')
6871 inst.operands[i].writeback = 1;
6873 po_imm_or_fail (0, 31, TRUE);
6881 po_misc_or_fail (my_get_expression (&inst.reloc.exp, &str,
6886 po_misc_or_fail (my_get_expression (&inst.reloc.exp, &str,
6891 po_misc_or_fail (my_get_expression (&inst.reloc.exp, &str,
6893 if (inst.reloc.exp.X_op == O_symbol)
6895 val = parse_reloc (&str);
6898 inst.error = _("unrecognized relocation suffix");
6901 else if (val != BFD_RELOC_UNUSED)
6903 inst.operands[i].imm = val;
6904 inst.operands[i].hasreloc = 1;
6909 /* Operand for MOVW or MOVT. */
6911 po_misc_or_fail (parse_half (&str));
6914 /* Register or expression. */
6915 case OP_RR_EXr: po_reg_or_goto (REG_TYPE_RN, EXPr); break;
6916 case OP_RR_EXi: po_reg_or_goto (REG_TYPE_RN, EXPi); break;
6918 /* Register or immediate. */
6919 case OP_RRnpc_I0: po_reg_or_goto (REG_TYPE_RN, I0); break;
6920 I0: po_imm_or_fail (0, 0, FALSE); break;
6922 case OP_RF_IF: po_reg_or_goto (REG_TYPE_FN, IF); break;
6924 if (!is_immediate_prefix (*str))
6927 val = parse_fpa_immediate (&str);
6930 /* FPA immediates are encoded as registers 8-15.
6931 parse_fpa_immediate has already applied the offset. */
6932 inst.operands[i].reg = val;
6933 inst.operands[i].isreg = 1;
6936 case OP_RIWR_I32z: po_reg_or_goto (REG_TYPE_MMXWR, I32z); break;
6937 I32z: po_imm_or_fail (0, 32, FALSE); break;
6939 /* Two kinds of register. */
6942 struct reg_entry *rege = arm_reg_parse_multi (&str);
6944 || (rege->type != REG_TYPE_MMXWR
6945 && rege->type != REG_TYPE_MMXWC
6946 && rege->type != REG_TYPE_MMXWCG))
6948 inst.error = _("iWMMXt data or control register expected");
6951 inst.operands[i].reg = rege->number;
6952 inst.operands[i].isreg = (rege->type == REG_TYPE_MMXWR);
6958 struct reg_entry *rege = arm_reg_parse_multi (&str);
6960 || (rege->type != REG_TYPE_MMXWC
6961 && rege->type != REG_TYPE_MMXWCG))
6963 inst.error = _("iWMMXt control register expected");
6966 inst.operands[i].reg = rege->number;
6967 inst.operands[i].isreg = 1;
6972 case OP_CPSF: val = parse_cps_flags (&str); break;
6973 case OP_ENDI: val = parse_endian_specifier (&str); break;
6974 case OP_oROR: val = parse_ror (&str); break;
6975 case OP_COND: val = parse_cond (&str); break;
6976 case OP_oBARRIER_I15:
6977 po_barrier_or_imm (str); break;
6979 if (parse_immediate (&str, &val, 0, 15, TRUE) == FAIL)
6985 po_reg_or_goto (REG_TYPE_RNB, try_psr);
6986 if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_virt))
6988 inst.error = _("Banked registers are not available with this "
6994 val = parse_psr (&str, op_parse_code == OP_wPSR);
6998 po_reg_or_goto (REG_TYPE_RN, try_apsr);
7001 /* Parse "APSR_nvzc" operand (for FMSTAT-equivalent MRS
7003 if (strncasecmp (str, "APSR_", 5) == 0)
7010 case 'c': found = (found & 1) ? 16 : found | 1; break;
7011 case 'n': found = (found & 2) ? 16 : found | 2; break;
7012 case 'z': found = (found & 4) ? 16 : found | 4; break;
7013 case 'v': found = (found & 8) ? 16 : found | 8; break;
7014 default: found = 16;
7018 inst.operands[i].isvec = 1;
7019 /* APSR_nzcv is encoded in instructions as if it were the REG_PC. */
7020 inst.operands[i].reg = REG_PC;
7027 po_misc_or_fail (parse_tb (&str));
7030 /* Register lists. */
7032 val = parse_reg_list (&str);
7035 inst.operands[1].writeback = 1;
7041 val = parse_vfp_reg_list (&str, &inst.operands[i].reg, REGLIST_VFP_S);
7045 val = parse_vfp_reg_list (&str, &inst.operands[i].reg, REGLIST_VFP_D);
7049 /* Allow Q registers too. */
7050 val = parse_vfp_reg_list (&str, &inst.operands[i].reg,
7055 val = parse_vfp_reg_list (&str, &inst.operands[i].reg,
7057 inst.operands[i].issingle = 1;
7062 val = parse_vfp_reg_list (&str, &inst.operands[i].reg,
7067 val = parse_neon_el_struct_list (&str, &inst.operands[i].reg,
7068 &inst.operands[i].vectype);
7071 /* Addressing modes */
7073 po_misc_or_fail (parse_address (&str, i));
7077 po_misc_or_fail_no_backtrack (
7078 parse_address_group_reloc (&str, i, GROUP_LDR));
7082 po_misc_or_fail_no_backtrack (
7083 parse_address_group_reloc (&str, i, GROUP_LDRS));
7087 po_misc_or_fail_no_backtrack (
7088 parse_address_group_reloc (&str, i, GROUP_LDC));
7092 po_misc_or_fail (parse_shifter_operand (&str, i));
7096 po_misc_or_fail_no_backtrack (
7097 parse_shifter_operand_group_reloc (&str, i));
7101 po_misc_or_fail (parse_shift (&str, i, SHIFT_LSL_IMMEDIATE));
7105 po_misc_or_fail (parse_shift (&str, i, SHIFT_ASR_IMMEDIATE));
7109 po_misc_or_fail (parse_shift (&str, i, SHIFT_LSL_OR_ASR_IMMEDIATE));
7113 as_fatal (_("unhandled operand code %d"), op_parse_code);
7116 /* Various value-based sanity checks and shared operations. We
7117 do not signal immediate failures for the register constraints;
7118 this allows a syntax error to take precedence. */
7119 switch (op_parse_code)
7127 if (inst.operands[i].isreg && inst.operands[i].reg == REG_PC)
7128 inst.error = BAD_PC;
7133 if (inst.operands[i].isreg)
7135 if (inst.operands[i].reg == REG_PC)
7136 inst.error = BAD_PC;
7137 else if (inst.operands[i].reg == REG_SP)
7138 inst.error = BAD_SP;
7143 if (inst.operands[i].isreg
7144 && inst.operands[i].reg == REG_PC
7145 && (inst.operands[i].writeback || thumb))
7146 inst.error = BAD_PC;
7155 case OP_oBARRIER_I15:
7164 inst.operands[i].imm = val;
7171 /* If we get here, this operand was successfully parsed. */
7172 inst.operands[i].present = 1;
7176 inst.error = BAD_ARGS;
7181 /* The parse routine should already have set inst.error, but set a
7182 default here just in case. */
7184 inst.error = _("syntax error");
7188 /* Do not backtrack over a trailing optional argument that
7189 absorbed some text. We will only fail again, with the
7190 'garbage following instruction' error message, which is
7191 probably less helpful than the current one. */
7192 if (backtrack_index == i && backtrack_pos != str
7193 && upat[i+1] == OP_stop)
7196 inst.error = _("syntax error");
7200 /* Try again, skipping the optional argument at backtrack_pos. */
7201 str = backtrack_pos;
7202 inst.error = backtrack_error;
7203 inst.operands[backtrack_index].present = 0;
7204 i = backtrack_index;
7208 /* Check that we have parsed all the arguments. */
7209 if (*str != '\0' && !inst.error)
7210 inst.error = _("garbage following instruction");
7212 return inst.error ? FAIL : SUCCESS;
7215 #undef po_char_or_fail
7216 #undef po_reg_or_fail
7217 #undef po_reg_or_goto
7218 #undef po_imm_or_fail
7219 #undef po_scalar_or_fail
7220 #undef po_barrier_or_imm
7222 /* Shorthand macro for instruction encoding functions issuing errors. */
7223 #define constraint(expr, err) \
7234 /* Reject "bad registers" for Thumb-2 instructions. Many Thumb-2
7235 instructions are unpredictable if these registers are used. This
7236 is the BadReg predicate in ARM's Thumb-2 documentation. */
7237 #define reject_bad_reg(reg) \
7239 if (reg == REG_SP || reg == REG_PC) \
7241 inst.error = (reg == REG_SP) ? BAD_SP : BAD_PC; \
7246 /* If REG is R13 (the stack pointer), warn that its use is
7248 #define warn_deprecated_sp(reg) \
7250 if (warn_on_deprecated && reg == REG_SP) \
7251 as_warn (_("use of r13 is deprecated")); \
7254 /* Functions for operand encoding. ARM, then Thumb. */
7256 #define rotate_left(v, n) (v << (n & 31) | v >> ((32 - n) & 31))
7258 /* If VAL can be encoded in the immediate field of an ARM instruction,
7259 return the encoded form. Otherwise, return FAIL. */
7262 encode_arm_immediate (unsigned int val)
7266 for (i = 0; i < 32; i += 2)
7267 if ((a = rotate_left (val, i)) <= 0xff)
7268 return a | (i << 7); /* 12-bit pack: [shift-cnt,const]. */
7273 /* If VAL can be encoded in the immediate field of a Thumb32 instruction,
7274 return the encoded form. Otherwise, return FAIL. */
7276 encode_thumb32_immediate (unsigned int val)
7283 for (i = 1; i <= 24; i++)
7286 if ((val & ~(0xff << i)) == 0)
7287 return ((val >> i) & 0x7f) | ((32 - i) << 7);
7291 if (val == ((a << 16) | a))
7293 if (val == ((a << 24) | (a << 16) | (a << 8) | a))
7297 if (val == ((a << 16) | a))
7298 return 0x200 | (a >> 8);
7302 /* Encode a VFP SP or DP register number into inst.instruction. */
7305 encode_arm_vfp_reg (int reg, enum vfp_reg_pos pos)
7307 if ((pos == VFP_REG_Dd || pos == VFP_REG_Dn || pos == VFP_REG_Dm)
7310 if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_d32))
7313 ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
7316 ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used,
7321 first_error (_("D register out of range for selected VFP version"));
7329 inst.instruction |= ((reg >> 1) << 12) | ((reg & 1) << 22);
7333 inst.instruction |= ((reg >> 1) << 16) | ((reg & 1) << 7);
7337 inst.instruction |= ((reg >> 1) << 0) | ((reg & 1) << 5);
7341 inst.instruction |= ((reg & 15) << 12) | ((reg >> 4) << 22);
7345 inst.instruction |= ((reg & 15) << 16) | ((reg >> 4) << 7);
7349 inst.instruction |= (reg & 15) | ((reg >> 4) << 5);
7357 /* Encode a <shift> in an ARM-format instruction. The immediate,
7358 if any, is handled by md_apply_fix. */
7360 encode_arm_shift (int i)
7362 if (inst.operands[i].shift_kind == SHIFT_RRX)
7363 inst.instruction |= SHIFT_ROR << 5;
7366 inst.instruction |= inst.operands[i].shift_kind << 5;
7367 if (inst.operands[i].immisreg)
7369 inst.instruction |= SHIFT_BY_REG;
7370 inst.instruction |= inst.operands[i].imm << 8;
7373 inst.reloc.type = BFD_RELOC_ARM_SHIFT_IMM;
7378 encode_arm_shifter_operand (int i)
7380 if (inst.operands[i].isreg)
7382 inst.instruction |= inst.operands[i].reg;
7383 encode_arm_shift (i);
7387 inst.instruction |= INST_IMMEDIATE;
7388 if (inst.reloc.type != BFD_RELOC_ARM_IMMEDIATE)
7389 inst.instruction |= inst.operands[i].imm;
7393 /* Subroutine of encode_arm_addr_mode_2 and encode_arm_addr_mode_3. */
7395 encode_arm_addr_mode_common (int i, bfd_boolean is_t)
7398 Generate an error if the operand is not a register. */
7399 constraint (!inst.operands[i].isreg,
7400 _("Instruction does not support =N addresses"));
7402 inst.instruction |= inst.operands[i].reg << 16;
7404 if (inst.operands[i].preind)
7408 inst.error = _("instruction does not accept preindexed addressing");
7411 inst.instruction |= PRE_INDEX;
7412 if (inst.operands[i].writeback)
7413 inst.instruction |= WRITE_BACK;
7416 else if (inst.operands[i].postind)
7418 gas_assert (inst.operands[i].writeback);
7420 inst.instruction |= WRITE_BACK;
7422 else /* unindexed - only for coprocessor */
7424 inst.error = _("instruction does not accept unindexed addressing");
7428 if (((inst.instruction & WRITE_BACK) || !(inst.instruction & PRE_INDEX))
7429 && (((inst.instruction & 0x000f0000) >> 16)
7430 == ((inst.instruction & 0x0000f000) >> 12)))
7431 as_warn ((inst.instruction & LOAD_BIT)
7432 ? _("destination register same as write-back base")
7433 : _("source register same as write-back base"));
7436 /* inst.operands[i] was set up by parse_address. Encode it into an
7437 ARM-format mode 2 load or store instruction. If is_t is true,
7438 reject forms that cannot be used with a T instruction (i.e. not
7441 encode_arm_addr_mode_2 (int i, bfd_boolean is_t)
7443 const bfd_boolean is_pc = (inst.operands[i].reg == REG_PC);
7445 encode_arm_addr_mode_common (i, is_t);
7447 if (inst.operands[i].immisreg)
7449 constraint ((inst.operands[i].imm == REG_PC
7450 || (is_pc && inst.operands[i].writeback)),
7452 inst.instruction |= INST_IMMEDIATE; /* yes, this is backwards */
7453 inst.instruction |= inst.operands[i].imm;
7454 if (!inst.operands[i].negative)
7455 inst.instruction |= INDEX_UP;
7456 if (inst.operands[i].shifted)
7458 if (inst.operands[i].shift_kind == SHIFT_RRX)
7459 inst.instruction |= SHIFT_ROR << 5;
7462 inst.instruction |= inst.operands[i].shift_kind << 5;
7463 inst.reloc.type = BFD_RELOC_ARM_SHIFT_IMM;
7467 else /* immediate offset in inst.reloc */
7469 if (is_pc && !inst.reloc.pc_rel)
7471 const bfd_boolean is_load = ((inst.instruction & LOAD_BIT) != 0);
7473 /* If is_t is TRUE, it's called from do_ldstt. ldrt/strt
7474 cannot use PC in addressing.
7475 PC cannot be used in writeback addressing, either. */
7476 constraint ((is_t || inst.operands[i].writeback),
7479 /* Use of PC in str is deprecated for ARMv7. */
7480 if (warn_on_deprecated
7482 && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v7))
7483 as_warn (_("use of PC in this instruction is deprecated"));
7486 if (inst.reloc.type == BFD_RELOC_UNUSED)
7488 /* Prefer + for zero encoded value. */
7489 if (!inst.operands[i].negative)
7490 inst.instruction |= INDEX_UP;
7491 inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
7496 /* inst.operands[i] was set up by parse_address. Encode it into an
7497 ARM-format mode 3 load or store instruction. Reject forms that
7498 cannot be used with such instructions. If is_t is true, reject
7499 forms that cannot be used with a T instruction (i.e. not
7502 encode_arm_addr_mode_3 (int i, bfd_boolean is_t)
7504 if (inst.operands[i].immisreg && inst.operands[i].shifted)
7506 inst.error = _("instruction does not accept scaled register index");
7510 encode_arm_addr_mode_common (i, is_t);
7512 if (inst.operands[i].immisreg)
7514 constraint ((inst.operands[i].imm == REG_PC
7515 || (is_t && inst.operands[i].reg == REG_PC)),
7517 constraint (inst.operands[i].reg == REG_PC && inst.operands[i].writeback,
7519 inst.instruction |= inst.operands[i].imm;
7520 if (!inst.operands[i].negative)
7521 inst.instruction |= INDEX_UP;
7523 else /* immediate offset in inst.reloc */
7525 constraint ((inst.operands[i].reg == REG_PC && !inst.reloc.pc_rel
7526 && inst.operands[i].writeback),
7528 inst.instruction |= HWOFFSET_IMM;
7529 if (inst.reloc.type == BFD_RELOC_UNUSED)
7531 /* Prefer + for zero encoded value. */
7532 if (!inst.operands[i].negative)
7533 inst.instruction |= INDEX_UP;
7535 inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
7540 /* Write immediate bits [7:0] to the following locations:
7542 |28/24|23 19|18 16|15 4|3 0|
7543 | 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|
7545 This function is used by VMOV/VMVN/VORR/VBIC. */
7548 neon_write_immbits (unsigned immbits)
7550 inst.instruction |= immbits & 0xf;
7551 inst.instruction |= ((immbits >> 4) & 0x7) << 16;
7552 inst.instruction |= ((immbits >> 7) & 0x1) << (thumb_mode ? 28 : 24);
7555 /* Invert low-order SIZE bits of XHI:XLO. */
7558 neon_invert_size (unsigned *xlo, unsigned *xhi, int size)
7560 unsigned immlo = xlo ? *xlo : 0;
7561 unsigned immhi = xhi ? *xhi : 0;
7566 immlo = (~immlo) & 0xff;
7570 immlo = (~immlo) & 0xffff;
7574 immhi = (~immhi) & 0xffffffff;
7578 immlo = (~immlo) & 0xffffffff;
7592 /* True if IMM has form 0bAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD for bits
7596 neon_bits_same_in_bytes (unsigned imm)
7598 return ((imm & 0x000000ff) == 0 || (imm & 0x000000ff) == 0x000000ff)
7599 && ((imm & 0x0000ff00) == 0 || (imm & 0x0000ff00) == 0x0000ff00)
7600 && ((imm & 0x00ff0000) == 0 || (imm & 0x00ff0000) == 0x00ff0000)
7601 && ((imm & 0xff000000) == 0 || (imm & 0xff000000) == 0xff000000);
7604 /* For immediate of above form, return 0bABCD. */
7607 neon_squash_bits (unsigned imm)
7609 return (imm & 0x01) | ((imm & 0x0100) >> 7) | ((imm & 0x010000) >> 14)
7610 | ((imm & 0x01000000) >> 21);
7613 /* Compress quarter-float representation to 0b...000 abcdefgh. */
7616 neon_qfloat_bits (unsigned imm)
7618 return ((imm >> 19) & 0x7f) | ((imm >> 24) & 0x80);
7621 /* Returns CMODE. IMMBITS [7:0] is set to bits suitable for inserting into
7622 the instruction. *OP is passed as the initial value of the op field, and
7623 may be set to a different value depending on the constant (i.e.
7624 "MOV I64, 0bAAAAAAAABBBB..." which uses OP = 1 despite being MOV not
7625 MVN). If the immediate looks like a repeated pattern then also
7626 try smaller element sizes. */
7629 neon_cmode_for_move_imm (unsigned immlo, unsigned immhi, int float_p,
7630 unsigned *immbits, int *op, int size,
7631 enum neon_el_type type)
7633 /* Only permit float immediates (including 0.0/-0.0) if the operand type is
7635 if (type == NT_float && !float_p)
7638 if (type == NT_float && is_quarter_float (immlo) && immhi == 0)
7640 if (size != 32 || *op == 1)
7642 *immbits = neon_qfloat_bits (immlo);
7648 if (neon_bits_same_in_bytes (immhi)
7649 && neon_bits_same_in_bytes (immlo))
7653 *immbits = (neon_squash_bits (immhi) << 4)
7654 | neon_squash_bits (immlo);
7665 if (immlo == (immlo & 0x000000ff))
7670 else if (immlo == (immlo & 0x0000ff00))
7672 *immbits = immlo >> 8;
7675 else if (immlo == (immlo & 0x00ff0000))
7677 *immbits = immlo >> 16;
7680 else if (immlo == (immlo & 0xff000000))
7682 *immbits = immlo >> 24;
7685 else if (immlo == ((immlo & 0x0000ff00) | 0x000000ff))
7687 *immbits = (immlo >> 8) & 0xff;
7690 else if (immlo == ((immlo & 0x00ff0000) | 0x0000ffff))
7692 *immbits = (immlo >> 16) & 0xff;
7696 if ((immlo & 0xffff) != (immlo >> 16))
7703 if (immlo == (immlo & 0x000000ff))
7708 else if (immlo == (immlo & 0x0000ff00))
7710 *immbits = immlo >> 8;
7714 if ((immlo & 0xff) != (immlo >> 8))
7719 if (immlo == (immlo & 0x000000ff))
7721 /* Don't allow MVN with 8-bit immediate. */
7738 /* inst.reloc.exp describes an "=expr" load pseudo-operation.
7739 Determine whether it can be performed with a move instruction; if
7740 it can, convert inst.instruction to that move instruction and
7741 return TRUE; if it can't, convert inst.instruction to a literal-pool
7742 load and return FALSE. If this is not a valid thing to do in the
7743 current context, set inst.error and return TRUE.
7745 inst.operands[i] describes the destination register. */
7748 move_or_literal_pool (int i, enum lit_type t, bfd_boolean mode_3)
7751 bfd_boolean thumb_p = (t == CONST_THUMB);
7752 bfd_boolean arm_p = (t == CONST_ARM);
7753 bfd_boolean vec64_p = (t == CONST_VEC) && !inst.operands[i].issingle;
7756 tbit = (inst.instruction > 0xffff) ? THUMB2_LOAD_BIT : THUMB_LOAD_BIT;
7760 if ((inst.instruction & tbit) == 0)
7762 inst.error = _("invalid pseudo operation");
7765 if (inst.reloc.exp.X_op != O_constant
7766 && inst.reloc.exp.X_op != O_symbol
7767 && inst.reloc.exp.X_op != O_big)
7769 inst.error = _("constant expression expected");
7772 if ((inst.reloc.exp.X_op == O_constant
7773 || inst.reloc.exp.X_op == O_big)
7774 && !inst.operands[i].issingle)
7776 if (thumb_p && inst.reloc.exp.X_op == O_constant)
7778 if (!unified_syntax && (inst.reloc.exp.X_add_number & ~0xFF) == 0)
7780 /* This can be done with a mov(1) instruction. */
7781 inst.instruction = T_OPCODE_MOV_I8 | (inst.operands[i].reg << 8);
7782 inst.instruction |= inst.reloc.exp.X_add_number;
7786 else if (arm_p && inst.reloc.exp.X_op == O_constant)
7788 int value = encode_arm_immediate (inst.reloc.exp.X_add_number);
7791 /* This can be done with a mov instruction. */
7792 inst.instruction &= LITERAL_MASK;
7793 inst.instruction |= INST_IMMEDIATE | (OPCODE_MOV << DATA_OP_SHIFT);
7794 inst.instruction |= value & 0xfff;
7798 value = encode_arm_immediate (~inst.reloc.exp.X_add_number);
7801 /* This can be done with a mvn instruction. */
7802 inst.instruction &= LITERAL_MASK;
7803 inst.instruction |= INST_IMMEDIATE | (OPCODE_MVN << DATA_OP_SHIFT);
7804 inst.instruction |= value & 0xfff;
7811 unsigned immbits = 0;
7812 unsigned immlo = inst.operands[1].imm;
7813 unsigned immhi = inst.operands[1].regisimm
7814 ? inst.operands[1].reg
7815 : inst.reloc.exp.X_unsigned
7817 : ((bfd_int64_t)((int) immlo)) >> 32;
7818 int cmode = neon_cmode_for_move_imm (immlo, immhi, FALSE, &immbits,
7819 &op, 64, NT_invtype);
7823 neon_invert_size (&immlo, &immhi, 64);
7825 cmode = neon_cmode_for_move_imm (immlo, immhi, FALSE, &immbits,
7826 &op, 64, NT_invtype);
7830 inst.instruction = (inst.instruction & VLDR_VMOV_SAME)
7835 /* Fill other bits in vmov encoding for both thumb and arm. */
7837 inst.instruction |= (0x7 << 29) | (0xF << 24);
7839 inst.instruction |= (0xF << 28) | (0x1 << 25);
7840 neon_write_immbits (immbits);
7846 if (add_to_lit_pool ((!inst.operands[i].isvec
7847 || inst.operands[i].issingle) ? 4 : 8) == FAIL)
7850 inst.operands[1].reg = REG_PC;
7851 inst.operands[1].isreg = 1;
7852 inst.operands[1].preind = 1;
7853 inst.reloc.pc_rel = 1;
7854 inst.reloc.type = (thumb_p
7855 ? BFD_RELOC_ARM_THUMB_OFFSET
7857 ? BFD_RELOC_ARM_HWLITERAL
7858 : BFD_RELOC_ARM_LITERAL));
7862 /* inst.operands[i] was set up by parse_address. Encode it into an
7863 ARM-format instruction. Reject all forms which cannot be encoded
7864 into a coprocessor load/store instruction. If wb_ok is false,
7865 reject use of writeback; if unind_ok is false, reject use of
7866 unindexed addressing. If reloc_override is not 0, use it instead
7867 of BFD_ARM_CP_OFF_IMM, unless the initial relocation is a group one
7868 (in which case it is preserved). */
7871 encode_arm_cp_address (int i, int wb_ok, int unind_ok, int reloc_override)
7873 if (!inst.operands[i].isreg)
7875 gas_assert (inst.operands[0].isvec);
7876 if (move_or_literal_pool (0, CONST_VEC, /*mode_3=*/FALSE))
7880 inst.instruction |= inst.operands[i].reg << 16;
7882 gas_assert (!(inst.operands[i].preind && inst.operands[i].postind));
7884 if (!inst.operands[i].preind && !inst.operands[i].postind) /* unindexed */
7886 gas_assert (!inst.operands[i].writeback);
7889 inst.error = _("instruction does not support unindexed addressing");
7892 inst.instruction |= inst.operands[i].imm;
7893 inst.instruction |= INDEX_UP;
7897 if (inst.operands[i].preind)
7898 inst.instruction |= PRE_INDEX;
7900 if (inst.operands[i].writeback)
7902 if (inst.operands[i].reg == REG_PC)
7904 inst.error = _("pc may not be used with write-back");
7909 inst.error = _("instruction does not support writeback");
7912 inst.instruction |= WRITE_BACK;
7916 inst.reloc.type = (bfd_reloc_code_real_type) reloc_override;
7917 else if ((inst.reloc.type < BFD_RELOC_ARM_ALU_PC_G0_NC
7918 || inst.reloc.type > BFD_RELOC_ARM_LDC_SB_G2)
7919 && inst.reloc.type != BFD_RELOC_ARM_LDR_PC_G0)
7922 inst.reloc.type = BFD_RELOC_ARM_T32_CP_OFF_IMM;
7924 inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM;
7927 /* Prefer + for zero encoded value. */
7928 if (!inst.operands[i].negative)
7929 inst.instruction |= INDEX_UP;
7934 /* Functions for instruction encoding, sorted by sub-architecture.
7935 First some generics; their names are taken from the conventional
7936 bit positions for register arguments in ARM format instructions. */
7946 inst.instruction |= inst.operands[0].reg << 12;
7952 inst.instruction |= inst.operands[0].reg << 12;
7953 inst.instruction |= inst.operands[1].reg;
7959 inst.instruction |= inst.operands[0].reg;
7960 inst.instruction |= inst.operands[1].reg << 16;
7966 inst.instruction |= inst.operands[0].reg << 12;
7967 inst.instruction |= inst.operands[1].reg << 16;
7973 inst.instruction |= inst.operands[0].reg << 16;
7974 inst.instruction |= inst.operands[1].reg << 12;
7978 check_obsolete (const arm_feature_set *feature, const char *msg)
7980 if (ARM_CPU_IS_ANY (cpu_variant))
7982 as_warn ("%s", msg);
7985 else if (ARM_CPU_HAS_FEATURE (cpu_variant, *feature))
7997 unsigned Rn = inst.operands[2].reg;
7998 /* Enforce restrictions on SWP instruction. */
7999 if ((inst.instruction & 0x0fbfffff) == 0x01000090)
8001 constraint (Rn == inst.operands[0].reg || Rn == inst.operands[1].reg,
8002 _("Rn must not overlap other operands"));
8004 /* SWP{b} is obsolete for ARMv8-A, and deprecated for ARMv6* and ARMv7.
8006 if (!check_obsolete (&arm_ext_v8,
8007 _("swp{b} use is obsoleted for ARMv8 and later"))
8008 && warn_on_deprecated
8009 && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6))
8010 as_warn (_("swp{b} use is deprecated for ARMv6 and ARMv7"));
8013 inst.instruction |= inst.operands[0].reg << 12;
8014 inst.instruction |= inst.operands[1].reg;
8015 inst.instruction |= Rn << 16;
8021 inst.instruction |= inst.operands[0].reg << 12;
8022 inst.instruction |= inst.operands[1].reg << 16;
8023 inst.instruction |= inst.operands[2].reg;
8029 constraint ((inst.operands[2].reg == REG_PC), BAD_PC);
8030 constraint (((inst.reloc.exp.X_op != O_constant
8031 && inst.reloc.exp.X_op != O_illegal)
8032 || inst.reloc.exp.X_add_number != 0),
8034 inst.instruction |= inst.operands[0].reg;
8035 inst.instruction |= inst.operands[1].reg << 12;
8036 inst.instruction |= inst.operands[2].reg << 16;
8042 inst.instruction |= inst.operands[0].imm;
8048 inst.instruction |= inst.operands[0].reg << 12;
8049 encode_arm_cp_address (1, TRUE, TRUE, 0);
8052 /* ARM instructions, in alphabetical order by function name (except
8053 that wrapper functions appear immediately after the function they
8056 /* This is a pseudo-op of the form "adr rd, label" to be converted
8057 into a relative address of the form "add rd, pc, #label-.-8". */
8062 inst.instruction |= (inst.operands[0].reg << 12); /* Rd */
8064 /* Frag hacking will turn this into a sub instruction if the offset turns
8065 out to be negative. */
8066 inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
8067 inst.reloc.pc_rel = 1;
8068 inst.reloc.exp.X_add_number -= 8;
8071 /* This is a pseudo-op of the form "adrl rd, label" to be converted
8072 into a relative address of the form:
8073 add rd, pc, #low(label-.-8)"
8074 add rd, rd, #high(label-.-8)" */
8079 inst.instruction |= (inst.operands[0].reg << 12); /* Rd */
8081 /* Frag hacking will turn this into a sub instruction if the offset turns
8082 out to be negative. */
8083 inst.reloc.type = BFD_RELOC_ARM_ADRL_IMMEDIATE;
8084 inst.reloc.pc_rel = 1;
8085 inst.size = INSN_SIZE * 2;
8086 inst.reloc.exp.X_add_number -= 8;
8092 if (!inst.operands[1].present)
8093 inst.operands[1].reg = inst.operands[0].reg;
8094 inst.instruction |= inst.operands[0].reg << 12;
8095 inst.instruction |= inst.operands[1].reg << 16;
8096 encode_arm_shifter_operand (2);
8102 if (inst.operands[0].present)
8103 inst.instruction |= inst.operands[0].imm;
8105 inst.instruction |= 0xf;
8111 unsigned int msb = inst.operands[1].imm + inst.operands[2].imm;
8112 constraint (msb > 32, _("bit-field extends past end of register"));
8113 /* The instruction encoding stores the LSB and MSB,
8114 not the LSB and width. */
8115 inst.instruction |= inst.operands[0].reg << 12;
8116 inst.instruction |= inst.operands[1].imm << 7;
8117 inst.instruction |= (msb - 1) << 16;
8125 /* #0 in second position is alternative syntax for bfc, which is
8126 the same instruction but with REG_PC in the Rm field. */
8127 if (!inst.operands[1].isreg)
8128 inst.operands[1].reg = REG_PC;
8130 msb = inst.operands[2].imm + inst.operands[3].imm;
8131 constraint (msb > 32, _("bit-field extends past end of register"));
8132 /* The instruction encoding stores the LSB and MSB,
8133 not the LSB and width. */
8134 inst.instruction |= inst.operands[0].reg << 12;
8135 inst.instruction |= inst.operands[1].reg;
8136 inst.instruction |= inst.operands[2].imm << 7;
8137 inst.instruction |= (msb - 1) << 16;
8143 constraint (inst.operands[2].imm + inst.operands[3].imm > 32,
8144 _("bit-field extends past end of register"));
8145 inst.instruction |= inst.operands[0].reg << 12;
8146 inst.instruction |= inst.operands[1].reg;
8147 inst.instruction |= inst.operands[2].imm << 7;
8148 inst.instruction |= (inst.operands[3].imm - 1) << 16;
8151 /* ARM V5 breakpoint instruction (argument parse)
8152 BKPT <16 bit unsigned immediate>
8153 Instruction is not conditional.
8154 The bit pattern given in insns[] has the COND_ALWAYS condition,
8155 and it is an error if the caller tried to override that. */
8160 /* Top 12 of 16 bits to bits 19:8. */
8161 inst.instruction |= (inst.operands[0].imm & 0xfff0) << 4;
8163 /* Bottom 4 of 16 bits to bits 3:0. */
8164 inst.instruction |= inst.operands[0].imm & 0xf;
8168 encode_branch (int default_reloc)
8170 if (inst.operands[0].hasreloc)
8172 constraint (inst.operands[0].imm != BFD_RELOC_ARM_PLT32
8173 && inst.operands[0].imm != BFD_RELOC_ARM_TLS_CALL,
8174 _("the only valid suffixes here are '(plt)' and '(tlscall)'"));
8175 inst.reloc.type = inst.operands[0].imm == BFD_RELOC_ARM_PLT32
8176 ? BFD_RELOC_ARM_PLT32
8177 : thumb_mode ? BFD_RELOC_ARM_THM_TLS_CALL : BFD_RELOC_ARM_TLS_CALL;
8180 inst.reloc.type = (bfd_reloc_code_real_type) default_reloc;
8181 inst.reloc.pc_rel = 1;
8188 if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
8189 encode_branch (BFD_RELOC_ARM_PCREL_JUMP);
8192 encode_branch (BFD_RELOC_ARM_PCREL_BRANCH);
8199 if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
8201 if (inst.cond == COND_ALWAYS)
8202 encode_branch (BFD_RELOC_ARM_PCREL_CALL);
8204 encode_branch (BFD_RELOC_ARM_PCREL_JUMP);
8208 encode_branch (BFD_RELOC_ARM_PCREL_BRANCH);
8211 /* ARM V5 branch-link-exchange instruction (argument parse)
8212 BLX <target_addr> ie BLX(1)
8213 BLX{<condition>} <Rm> ie BLX(2)
8214 Unfortunately, there are two different opcodes for this mnemonic.
8215 So, the insns[].value is not used, and the code here zaps values
8216 into inst.instruction.
8217 Also, the <target_addr> can be 25 bits, hence has its own reloc. */
8222 if (inst.operands[0].isreg)
8224 /* Arg is a register; the opcode provided by insns[] is correct.
8225 It is not illegal to do "blx pc", just useless. */
8226 if (inst.operands[0].reg == REG_PC)
8227 as_tsktsk (_("use of r15 in blx in ARM mode is not really useful"));
8229 inst.instruction |= inst.operands[0].reg;
8233 /* Arg is an address; this instruction cannot be executed
8234 conditionally, and the opcode must be adjusted.
8235 We retain the BFD_RELOC_ARM_PCREL_BLX till the very end
8236 where we generate out a BFD_RELOC_ARM_PCREL_CALL instead. */
8237 constraint (inst.cond != COND_ALWAYS, BAD_COND);
8238 inst.instruction = 0xfa000000;
8239 encode_branch (BFD_RELOC_ARM_PCREL_BLX);
8246 bfd_boolean want_reloc;
8248 if (inst.operands[0].reg == REG_PC)
8249 as_tsktsk (_("use of r15 in bx in ARM mode is not really useful"));
8251 inst.instruction |= inst.operands[0].reg;
8252 /* Output R_ARM_V4BX relocations if is an EABI object that looks like
8253 it is for ARMv4t or earlier. */
8254 want_reloc = !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5);
8255 if (object_arch && !ARM_CPU_HAS_FEATURE (*object_arch, arm_ext_v5))
8259 if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
8264 inst.reloc.type = BFD_RELOC_ARM_V4BX;
8268 /* ARM v5TEJ. Jump to Jazelle code. */
8273 if (inst.operands[0].reg == REG_PC)
8274 as_tsktsk (_("use of r15 in bxj is not really useful"));
8276 inst.instruction |= inst.operands[0].reg;
8279 /* Co-processor data operation:
8280 CDP{cond} <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>{, <opcode_2>}
8281 CDP2 <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>{, <opcode_2>} */
8285 inst.instruction |= inst.operands[0].reg << 8;
8286 inst.instruction |= inst.operands[1].imm << 20;
8287 inst.instruction |= inst.operands[2].reg << 12;
8288 inst.instruction |= inst.operands[3].reg << 16;
8289 inst.instruction |= inst.operands[4].reg;
8290 inst.instruction |= inst.operands[5].imm << 5;
8296 inst.instruction |= inst.operands[0].reg << 16;
8297 encode_arm_shifter_operand (1);
8300 /* Transfer between coprocessor and ARM registers.
8301 MRC{cond} <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>{, <opcode_2>}
8306 No special properties. */
8308 struct deprecated_coproc_regs_s
8315 arm_feature_set deprecated;
8316 arm_feature_set obsoleted;
8317 const char *dep_msg;
8318 const char *obs_msg;
8321 #define DEPR_ACCESS_V8 \
8322 N_("This coprocessor register access is deprecated in ARMv8")
8324 /* Table of all deprecated coprocessor registers. */
8325 static struct deprecated_coproc_regs_s deprecated_coproc_regs[] =
8327 {15, 0, 7, 10, 5, /* CP15DMB. */
8328 ARM_FEATURE (ARM_EXT_V8, 0), ARM_FEATURE (0, 0),
8329 DEPR_ACCESS_V8, NULL},
8330 {15, 0, 7, 10, 4, /* CP15DSB. */
8331 ARM_FEATURE (ARM_EXT_V8, 0), ARM_FEATURE (0, 0),
8332 DEPR_ACCESS_V8, NULL},
8333 {15, 0, 7, 5, 4, /* CP15ISB. */
8334 ARM_FEATURE (ARM_EXT_V8, 0), ARM_FEATURE (0, 0),
8335 DEPR_ACCESS_V8, NULL},
8336 {14, 6, 1, 0, 0, /* TEEHBR. */
8337 ARM_FEATURE (ARM_EXT_V8, 0), ARM_FEATURE (0, 0),
8338 DEPR_ACCESS_V8, NULL},
8339 {14, 6, 0, 0, 0, /* TEECR. */
8340 ARM_FEATURE (ARM_EXT_V8, 0), ARM_FEATURE (0, 0),
8341 DEPR_ACCESS_V8, NULL},
8344 #undef DEPR_ACCESS_V8
8346 static const size_t deprecated_coproc_reg_count =
8347 sizeof (deprecated_coproc_regs) / sizeof (deprecated_coproc_regs[0]);
8355 Rd = inst.operands[2].reg;
8358 if (inst.instruction == 0xee000010
8359 || inst.instruction == 0xfe000010)
8361 reject_bad_reg (Rd);
8364 constraint (Rd == REG_SP, BAD_SP);
8369 if (inst.instruction == 0xe000010)
8370 constraint (Rd == REG_PC, BAD_PC);
8373 for (i = 0; i < deprecated_coproc_reg_count; ++i)
8375 const struct deprecated_coproc_regs_s *r =
8376 deprecated_coproc_regs + i;
8378 if (inst.operands[0].reg == r->cp
8379 && inst.operands[1].imm == r->opc1
8380 && inst.operands[3].reg == r->crn
8381 && inst.operands[4].reg == r->crm
8382 && inst.operands[5].imm == r->opc2)
8384 if (! ARM_CPU_IS_ANY (cpu_variant)
8385 && warn_on_deprecated
8386 && ARM_CPU_HAS_FEATURE (cpu_variant, r->deprecated))
8387 as_warn ("%s", r->dep_msg);
8391 inst.instruction |= inst.operands[0].reg << 8;
8392 inst.instruction |= inst.operands[1].imm << 21;
8393 inst.instruction |= Rd << 12;
8394 inst.instruction |= inst.operands[3].reg << 16;
8395 inst.instruction |= inst.operands[4].reg;
8396 inst.instruction |= inst.operands[5].imm << 5;
8399 /* Transfer between coprocessor register and pair of ARM registers.
8400 MCRR{cond} <coproc>, <opcode>, <Rd>, <Rn>, <CRm>.
8405 Two XScale instructions are special cases of these:
8407 MAR{cond} acc0, <RdLo>, <RdHi> == MCRR{cond} p0, #0, <RdLo>, <RdHi>, c0
8408 MRA{cond} acc0, <RdLo>, <RdHi> == MRRC{cond} p0, #0, <RdLo>, <RdHi>, c0
8410 Result unpredictable if Rd or Rn is R15. */
8417 Rd = inst.operands[2].reg;
8418 Rn = inst.operands[3].reg;
8422 reject_bad_reg (Rd);
8423 reject_bad_reg (Rn);
8427 constraint (Rd == REG_PC, BAD_PC);
8428 constraint (Rn == REG_PC, BAD_PC);
8431 inst.instruction |= inst.operands[0].reg << 8;
8432 inst.instruction |= inst.operands[1].imm << 4;
8433 inst.instruction |= Rd << 12;
8434 inst.instruction |= Rn << 16;
8435 inst.instruction |= inst.operands[4].reg;
8441 inst.instruction |= inst.operands[0].imm << 6;
8442 if (inst.operands[1].present)
8444 inst.instruction |= CPSI_MMOD;
8445 inst.instruction |= inst.operands[1].imm;
8452 inst.instruction |= inst.operands[0].imm;
8458 unsigned Rd, Rn, Rm;
8460 Rd = inst.operands[0].reg;
8461 Rn = (inst.operands[1].present
8462 ? inst.operands[1].reg : Rd);
8463 Rm = inst.operands[2].reg;
8465 constraint ((Rd == REG_PC), BAD_PC);
8466 constraint ((Rn == REG_PC), BAD_PC);
8467 constraint ((Rm == REG_PC), BAD_PC);
8469 inst.instruction |= Rd << 16;
8470 inst.instruction |= Rn << 0;
8471 inst.instruction |= Rm << 8;
8477 /* There is no IT instruction in ARM mode. We
8478 process it to do the validation as if in
8479 thumb mode, just in case the code gets
8480 assembled for thumb using the unified syntax. */
8485 set_it_insn_type (IT_INSN);
8486 now_it.mask = (inst.instruction & 0xf) | 0x10;
8487 now_it.cc = inst.operands[0].imm;
8491 /* If there is only one register in the register list,
8492 then return its register number. Otherwise return -1. */
8494 only_one_reg_in_list (int range)
8496 int i = ffs (range) - 1;
8497 return (i > 15 || range != (1 << i)) ? -1 : i;
8501 encode_ldmstm(int from_push_pop_mnem)
8503 int base_reg = inst.operands[0].reg;
8504 int range = inst.operands[1].imm;
8507 inst.instruction |= base_reg << 16;
8508 inst.instruction |= range;
8510 if (inst.operands[1].writeback)
8511 inst.instruction |= LDM_TYPE_2_OR_3;
8513 if (inst.operands[0].writeback)
8515 inst.instruction |= WRITE_BACK;
8516 /* Check for unpredictable uses of writeback. */
8517 if (inst.instruction & LOAD_BIT)
8519 /* Not allowed in LDM type 2. */
8520 if ((inst.instruction & LDM_TYPE_2_OR_3)
8521 && ((range & (1 << REG_PC)) == 0))
8522 as_warn (_("writeback of base register is UNPREDICTABLE"));
8523 /* Only allowed if base reg not in list for other types. */
8524 else if (range & (1 << base_reg))
8525 as_warn (_("writeback of base register when in register list is UNPREDICTABLE"));
8529 /* Not allowed for type 2. */
8530 if (inst.instruction & LDM_TYPE_2_OR_3)
8531 as_warn (_("writeback of base register is UNPREDICTABLE"));
8532 /* Only allowed if base reg not in list, or first in list. */
8533 else if ((range & (1 << base_reg))
8534 && (range & ((1 << base_reg) - 1)))
8535 as_warn (_("if writeback register is in list, it must be the lowest reg in the list"));
8539 /* If PUSH/POP has only one register, then use the A2 encoding. */
8540 one_reg = only_one_reg_in_list (range);
8541 if (from_push_pop_mnem && one_reg >= 0)
8543 int is_push = (inst.instruction & A_PUSH_POP_OP_MASK) == A1_OPCODE_PUSH;
8545 inst.instruction &= A_COND_MASK;
8546 inst.instruction |= is_push ? A2_OPCODE_PUSH : A2_OPCODE_POP;
8547 inst.instruction |= one_reg << 12;
8554 encode_ldmstm (/*from_push_pop_mnem=*/FALSE);
8557 /* ARMv5TE load-consecutive (argument parse)
8566 constraint (inst.operands[0].reg % 2 != 0,
8567 _("first transfer register must be even"));
8568 constraint (inst.operands[1].present
8569 && inst.operands[1].reg != inst.operands[0].reg + 1,
8570 _("can only transfer two consecutive registers"));
8571 constraint (inst.operands[0].reg == REG_LR, _("r14 not allowed here"));
8572 constraint (!inst.operands[2].isreg, _("'[' expected"));
8574 if (!inst.operands[1].present)
8575 inst.operands[1].reg = inst.operands[0].reg + 1;
8577 /* encode_arm_addr_mode_3 will diagnose overlap between the base
8578 register and the first register written; we have to diagnose
8579 overlap between the base and the second register written here. */
8581 if (inst.operands[2].reg == inst.operands[1].reg
8582 && (inst.operands[2].writeback || inst.operands[2].postind))
8583 as_warn (_("base register written back, and overlaps "
8584 "second transfer register"));
8586 if (!(inst.instruction & V4_STR_BIT))
8588 /* For an index-register load, the index register must not overlap the
8589 destination (even if not write-back). */
8590 if (inst.operands[2].immisreg
8591 && ((unsigned) inst.operands[2].imm == inst.operands[0].reg
8592 || (unsigned) inst.operands[2].imm == inst.operands[1].reg))
8593 as_warn (_("index register overlaps transfer register"));
8595 inst.instruction |= inst.operands[0].reg << 12;
8596 encode_arm_addr_mode_3 (2, /*is_t=*/FALSE);
8602 constraint (!inst.operands[1].isreg || !inst.operands[1].preind
8603 || inst.operands[1].postind || inst.operands[1].writeback
8604 || inst.operands[1].immisreg || inst.operands[1].shifted
8605 || inst.operands[1].negative
8606 /* This can arise if the programmer has written
8608 or if they have mistakenly used a register name as the last
8611 It is very difficult to distinguish between these two cases
8612 because "rX" might actually be a label. ie the register
8613 name has been occluded by a symbol of the same name. So we
8614 just generate a general 'bad addressing mode' type error
8615 message and leave it up to the programmer to discover the
8616 true cause and fix their mistake. */
8617 || (inst.operands[1].reg == REG_PC),
8620 constraint (inst.reloc.exp.X_op != O_constant
8621 || inst.reloc.exp.X_add_number != 0,
8622 _("offset must be zero in ARM encoding"));
8624 constraint ((inst.operands[1].reg == REG_PC), BAD_PC);
8626 inst.instruction |= inst.operands[0].reg << 12;
8627 inst.instruction |= inst.operands[1].reg << 16;
8628 inst.reloc.type = BFD_RELOC_UNUSED;
8634 constraint (inst.operands[0].reg % 2 != 0,
8635 _("even register required"));
8636 constraint (inst.operands[1].present
8637 && inst.operands[1].reg != inst.operands[0].reg + 1,
8638 _("can only load two consecutive registers"));
8639 /* If op 1 were present and equal to PC, this function wouldn't
8640 have been called in the first place. */
8641 constraint (inst.operands[0].reg == REG_LR, _("r14 not allowed here"));
8643 inst.instruction |= inst.operands[0].reg << 12;
8644 inst.instruction |= inst.operands[2].reg << 16;
8647 /* In both ARM and thumb state 'ldr pc, #imm' with an immediate
8648 which is not a multiple of four is UNPREDICTABLE. */
8650 check_ldr_r15_aligned (void)
8652 constraint (!(inst.operands[1].immisreg)
8653 && (inst.operands[0].reg == REG_PC
8654 && inst.operands[1].reg == REG_PC
8655 && (inst.reloc.exp.X_add_number & 0x3)),
8656 _("ldr to register 15 must be 4-byte alligned"));
8662 inst.instruction |= inst.operands[0].reg << 12;
8663 if (!inst.operands[1].isreg)
8664 if (move_or_literal_pool (0, CONST_ARM, /*mode_3=*/FALSE))
8666 encode_arm_addr_mode_2 (1, /*is_t=*/FALSE);
8667 check_ldr_r15_aligned ();
8673 /* ldrt/strt always use post-indexed addressing. Turn [Rn] into [Rn]! and
8675 if (inst.operands[1].preind)
8677 constraint (inst.reloc.exp.X_op != O_constant
8678 || inst.reloc.exp.X_add_number != 0,
8679 _("this instruction requires a post-indexed address"));
8681 inst.operands[1].preind = 0;
8682 inst.operands[1].postind = 1;
8683 inst.operands[1].writeback = 1;
8685 inst.instruction |= inst.operands[0].reg << 12;
8686 encode_arm_addr_mode_2 (1, /*is_t=*/TRUE);
8689 /* Halfword and signed-byte load/store operations. */
8694 constraint (inst.operands[0].reg == REG_PC, BAD_PC);
8695 inst.instruction |= inst.operands[0].reg << 12;
8696 if (!inst.operands[1].isreg)
8697 if (move_or_literal_pool (0, CONST_ARM, /*mode_3=*/TRUE))
8699 encode_arm_addr_mode_3 (1, /*is_t=*/FALSE);
8705 /* ldrt/strt always use post-indexed addressing. Turn [Rn] into [Rn]! and
8707 if (inst.operands[1].preind)
8709 constraint (inst.reloc.exp.X_op != O_constant
8710 || inst.reloc.exp.X_add_number != 0,
8711 _("this instruction requires a post-indexed address"));
8713 inst.operands[1].preind = 0;
8714 inst.operands[1].postind = 1;
8715 inst.operands[1].writeback = 1;
8717 inst.instruction |= inst.operands[0].reg << 12;
8718 encode_arm_addr_mode_3 (1, /*is_t=*/TRUE);
8721 /* Co-processor register load/store.
8722 Format: <LDC|STC>{cond}[L] CP#,CRd,<address> */
8726 inst.instruction |= inst.operands[0].reg << 8;
8727 inst.instruction |= inst.operands[1].reg << 12;
8728 encode_arm_cp_address (2, TRUE, TRUE, 0);
8734 /* This restriction does not apply to mls (nor to mla in v6 or later). */
8735 if (inst.operands[0].reg == inst.operands[1].reg
8736 && !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6)
8737 && !(inst.instruction & 0x00400000))
8738 as_tsktsk (_("Rd and Rm should be different in mla"));
8740 inst.instruction |= inst.operands[0].reg << 16;
8741 inst.instruction |= inst.operands[1].reg;
8742 inst.instruction |= inst.operands[2].reg << 8;
8743 inst.instruction |= inst.operands[3].reg << 12;
8749 inst.instruction |= inst.operands[0].reg << 12;
8750 encode_arm_shifter_operand (1);
8753 /* ARM V6T2 16-bit immediate register load: MOV[WT]{cond} Rd, #<imm16>. */
8760 top = (inst.instruction & 0x00400000) != 0;
8761 constraint (top && inst.reloc.type == BFD_RELOC_ARM_MOVW,
8762 _(":lower16: not allowed this instruction"));
8763 constraint (!top && inst.reloc.type == BFD_RELOC_ARM_MOVT,
8764 _(":upper16: not allowed instruction"));
8765 inst.instruction |= inst.operands[0].reg << 12;
8766 if (inst.reloc.type == BFD_RELOC_UNUSED)
8768 imm = inst.reloc.exp.X_add_number;
8769 /* The value is in two pieces: 0:11, 16:19. */
8770 inst.instruction |= (imm & 0x00000fff);
8771 inst.instruction |= (imm & 0x0000f000) << 4;
8775 static void do_vfp_nsyn_opcode (const char *);
8778 do_vfp_nsyn_mrs (void)
8780 if (inst.operands[0].isvec)
8782 if (inst.operands[1].reg != 1)
8783 first_error (_("operand 1 must be FPSCR"));
8784 memset (&inst.operands[0], '\0', sizeof (inst.operands[0]));
8785 memset (&inst.operands[1], '\0', sizeof (inst.operands[1]));
8786 do_vfp_nsyn_opcode ("fmstat");
8788 else if (inst.operands[1].isvec)
8789 do_vfp_nsyn_opcode ("fmrx");
8797 do_vfp_nsyn_msr (void)
8799 if (inst.operands[0].isvec)
8800 do_vfp_nsyn_opcode ("fmxr");
8810 unsigned Rt = inst.operands[0].reg;
8812 if (thumb_mode && Rt == REG_SP)
8814 inst.error = BAD_SP;
8818 /* APSR_ sets isvec. All other refs to PC are illegal. */
8819 if (!inst.operands[0].isvec && Rt == REG_PC)
8821 inst.error = BAD_PC;
8825 /* If we get through parsing the register name, we just insert the number
8826 generated into the instruction without further validation. */
8827 inst.instruction |= (inst.operands[1].reg << 16);
8828 inst.instruction |= (Rt << 12);
8834 unsigned Rt = inst.operands[1].reg;
8837 reject_bad_reg (Rt);
8838 else if (Rt == REG_PC)
8840 inst.error = BAD_PC;
8844 /* If we get through parsing the register name, we just insert the number
8845 generated into the instruction without further validation. */
8846 inst.instruction |= (inst.operands[0].reg << 16);
8847 inst.instruction |= (Rt << 12);
8855 if (do_vfp_nsyn_mrs () == SUCCESS)
8858 constraint (inst.operands[0].reg == REG_PC, BAD_PC);
8859 inst.instruction |= inst.operands[0].reg << 12;
8861 if (inst.operands[1].isreg)
8863 br = inst.operands[1].reg;
8864 if (((br & 0x200) == 0) && ((br & 0xf0000) != 0xf000))
8865 as_bad (_("bad register for mrs"));
8869 /* mrs only accepts CPSR/SPSR/CPSR_all/SPSR_all. */
8870 constraint ((inst.operands[1].imm & (PSR_c|PSR_x|PSR_s|PSR_f))
8872 _("'APSR', 'CPSR' or 'SPSR' expected"));
8873 br = (15<<16) | (inst.operands[1].imm & SPSR_BIT);
8876 inst.instruction |= br;
8879 /* Two possible forms:
8880 "{C|S}PSR_<field>, Rm",
8881 "{C|S}PSR_f, #expression". */
8886 if (do_vfp_nsyn_msr () == SUCCESS)
8889 inst.instruction |= inst.operands[0].imm;
8890 if (inst.operands[1].isreg)
8891 inst.instruction |= inst.operands[1].reg;
8894 inst.instruction |= INST_IMMEDIATE;
8895 inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
8896 inst.reloc.pc_rel = 0;
8903 constraint (inst.operands[2].reg == REG_PC, BAD_PC);
8905 if (!inst.operands[2].present)
8906 inst.operands[2].reg = inst.operands[0].reg;
8907 inst.instruction |= inst.operands[0].reg << 16;
8908 inst.instruction |= inst.operands[1].reg;
8909 inst.instruction |= inst.operands[2].reg << 8;
8911 if (inst.operands[0].reg == inst.operands[1].reg
8912 && !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6))
8913 as_tsktsk (_("Rd and Rm should be different in mul"));
8916 /* Long Multiply Parser
8917 UMULL RdLo, RdHi, Rm, Rs
8918 SMULL RdLo, RdHi, Rm, Rs
8919 UMLAL RdLo, RdHi, Rm, Rs
8920 SMLAL RdLo, RdHi, Rm, Rs. */
8925 inst.instruction |= inst.operands[0].reg << 12;
8926 inst.instruction |= inst.operands[1].reg << 16;
8927 inst.instruction |= inst.operands[2].reg;
8928 inst.instruction |= inst.operands[3].reg << 8;
8930 /* rdhi and rdlo must be different. */
8931 if (inst.operands[0].reg == inst.operands[1].reg)
8932 as_tsktsk (_("rdhi and rdlo must be different"));
8934 /* rdhi, rdlo and rm must all be different before armv6. */
8935 if ((inst.operands[0].reg == inst.operands[2].reg
8936 || inst.operands[1].reg == inst.operands[2].reg)
8937 && !ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6))
8938 as_tsktsk (_("rdhi, rdlo and rm must all be different"));
8944 if (inst.operands[0].present
8945 || ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6k))
8947 /* Architectural NOP hints are CPSR sets with no bits selected. */
8948 inst.instruction &= 0xf0000000;
8949 inst.instruction |= 0x0320f000;
8950 if (inst.operands[0].present)
8951 inst.instruction |= inst.operands[0].imm;
8955 /* ARM V6 Pack Halfword Bottom Top instruction (argument parse).
8956 PKHBT {<cond>} <Rd>, <Rn>, <Rm> {, LSL #<shift_imm>}
8957 Condition defaults to COND_ALWAYS.
8958 Error if Rd, Rn or Rm are R15. */
8963 inst.instruction |= inst.operands[0].reg << 12;
8964 inst.instruction |= inst.operands[1].reg << 16;
8965 inst.instruction |= inst.operands[2].reg;
8966 if (inst.operands[3].present)
8967 encode_arm_shift (3);
8970 /* ARM V6 PKHTB (Argument Parse). */
8975 if (!inst.operands[3].present)
8977 /* If the shift specifier is omitted, turn the instruction
8978 into pkhbt rd, rm, rn. */
8979 inst.instruction &= 0xfff00010;
8980 inst.instruction |= inst.operands[0].reg << 12;
8981 inst.instruction |= inst.operands[1].reg;
8982 inst.instruction |= inst.operands[2].reg << 16;
8986 inst.instruction |= inst.operands[0].reg << 12;
8987 inst.instruction |= inst.operands[1].reg << 16;
8988 inst.instruction |= inst.operands[2].reg;
8989 encode_arm_shift (3);
8993 /* ARMv5TE: Preload-Cache
8994 MP Extensions: Preload for write
8998 Syntactically, like LDR with B=1, W=0, L=1. */
9003 constraint (!inst.operands[0].isreg,
9004 _("'[' expected after PLD mnemonic"));
9005 constraint (inst.operands[0].postind,
9006 _("post-indexed expression used in preload instruction"));
9007 constraint (inst.operands[0].writeback,
9008 _("writeback used in preload instruction"));
9009 constraint (!inst.operands[0].preind,
9010 _("unindexed addressing used in preload instruction"));
9011 encode_arm_addr_mode_2 (0, /*is_t=*/FALSE);
9014 /* ARMv7: PLI <addr_mode> */
9018 constraint (!inst.operands[0].isreg,
9019 _("'[' expected after PLI mnemonic"));
9020 constraint (inst.operands[0].postind,
9021 _("post-indexed expression used in preload instruction"));
9022 constraint (inst.operands[0].writeback,
9023 _("writeback used in preload instruction"));
9024 constraint (!inst.operands[0].preind,
9025 _("unindexed addressing used in preload instruction"));
9026 encode_arm_addr_mode_2 (0, /*is_t=*/FALSE);
9027 inst.instruction &= ~PRE_INDEX;
9033 inst.operands[1] = inst.operands[0];
9034 memset (&inst.operands[0], 0, sizeof inst.operands[0]);
9035 inst.operands[0].isreg = 1;
9036 inst.operands[0].writeback = 1;
9037 inst.operands[0].reg = REG_SP;
9038 encode_ldmstm (/*from_push_pop_mnem=*/TRUE);
9041 /* ARM V6 RFE (Return from Exception) loads the PC and CPSR from the
9042 word at the specified address and the following word
9044 Unconditionally executed.
9045 Error if Rn is R15. */
9050 inst.instruction |= inst.operands[0].reg << 16;
9051 if (inst.operands[0].writeback)
9052 inst.instruction |= WRITE_BACK;
9055 /* ARM V6 ssat (argument parse). */
9060 inst.instruction |= inst.operands[0].reg << 12;
9061 inst.instruction |= (inst.operands[1].imm - 1) << 16;
9062 inst.instruction |= inst.operands[2].reg;
9064 if (inst.operands[3].present)
9065 encode_arm_shift (3);
9068 /* ARM V6 usat (argument parse). */
9073 inst.instruction |= inst.operands[0].reg << 12;
9074 inst.instruction |= inst.operands[1].imm << 16;
9075 inst.instruction |= inst.operands[2].reg;
9077 if (inst.operands[3].present)
9078 encode_arm_shift (3);
9081 /* ARM V6 ssat16 (argument parse). */
9086 inst.instruction |= inst.operands[0].reg << 12;
9087 inst.instruction |= ((inst.operands[1].imm - 1) << 16);
9088 inst.instruction |= inst.operands[2].reg;
9094 inst.instruction |= inst.operands[0].reg << 12;
9095 inst.instruction |= inst.operands[1].imm << 16;
9096 inst.instruction |= inst.operands[2].reg;
9099 /* ARM V6 SETEND (argument parse). Sets the E bit in the CPSR while
9100 preserving the other bits.
9102 setend <endian_specifier>, where <endian_specifier> is either
9108 if (warn_on_deprecated
9109 && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
9110 as_warn (_("setend use is deprecated for ARMv8"));
9112 if (inst.operands[0].imm)
9113 inst.instruction |= 0x200;
9119 unsigned int Rm = (inst.operands[1].present
9120 ? inst.operands[1].reg
9121 : inst.operands[0].reg);
9123 inst.instruction |= inst.operands[0].reg << 12;
9124 inst.instruction |= Rm;
9125 if (inst.operands[2].isreg) /* Rd, {Rm,} Rs */
9127 inst.instruction |= inst.operands[2].reg << 8;
9128 inst.instruction |= SHIFT_BY_REG;
9129 /* PR 12854: Error on extraneous shifts. */
9130 constraint (inst.operands[2].shifted,
9131 _("extraneous shift as part of operand to shift insn"));
9134 inst.reloc.type = BFD_RELOC_ARM_SHIFT_IMM;
9140 inst.reloc.type = BFD_RELOC_ARM_SMC;
9141 inst.reloc.pc_rel = 0;
9147 inst.reloc.type = BFD_RELOC_ARM_HVC;
9148 inst.reloc.pc_rel = 0;
9154 inst.reloc.type = BFD_RELOC_ARM_SWI;
9155 inst.reloc.pc_rel = 0;
9158 /* ARM V5E (El Segundo) signed-multiply-accumulate (argument parse)
9159 SMLAxy{cond} Rd,Rm,Rs,Rn
9160 SMLAWy{cond} Rd,Rm,Rs,Rn
9161 Error if any register is R15. */
9166 inst.instruction |= inst.operands[0].reg << 16;
9167 inst.instruction |= inst.operands[1].reg;
9168 inst.instruction |= inst.operands[2].reg << 8;
9169 inst.instruction |= inst.operands[3].reg << 12;
9172 /* ARM V5E (El Segundo) signed-multiply-accumulate-long (argument parse)
9173 SMLALxy{cond} Rdlo,Rdhi,Rm,Rs
9174 Error if any register is R15.
9175 Warning if Rdlo == Rdhi. */
9180 inst.instruction |= inst.operands[0].reg << 12;
9181 inst.instruction |= inst.operands[1].reg << 16;
9182 inst.instruction |= inst.operands[2].reg;
9183 inst.instruction |= inst.operands[3].reg << 8;
9185 if (inst.operands[0].reg == inst.operands[1].reg)
9186 as_tsktsk (_("rdhi and rdlo must be different"));
9189 /* ARM V5E (El Segundo) signed-multiply (argument parse)
9190 SMULxy{cond} Rd,Rm,Rs
9191 Error if any register is R15. */
9196 inst.instruction |= inst.operands[0].reg << 16;
9197 inst.instruction |= inst.operands[1].reg;
9198 inst.instruction |= inst.operands[2].reg << 8;
9201 /* ARM V6 srs (argument parse). The variable fields in the encoding are
9202 the same for both ARM and Thumb-2. */
9209 if (inst.operands[0].present)
9211 reg = inst.operands[0].reg;
9212 constraint (reg != REG_SP, _("SRS base register must be r13"));
9217 inst.instruction |= reg << 16;
9218 inst.instruction |= inst.operands[1].imm;
9219 if (inst.operands[0].writeback || inst.operands[1].writeback)
9220 inst.instruction |= WRITE_BACK;
9223 /* ARM V6 strex (argument parse). */
9228 constraint (!inst.operands[2].isreg || !inst.operands[2].preind
9229 || inst.operands[2].postind || inst.operands[2].writeback
9230 || inst.operands[2].immisreg || inst.operands[2].shifted
9231 || inst.operands[2].negative
9232 /* See comment in do_ldrex(). */
9233 || (inst.operands[2].reg == REG_PC),
9236 constraint (inst.operands[0].reg == inst.operands[1].reg
9237 || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
9239 constraint (inst.reloc.exp.X_op != O_constant
9240 || inst.reloc.exp.X_add_number != 0,
9241 _("offset must be zero in ARM encoding"));
9243 inst.instruction |= inst.operands[0].reg << 12;
9244 inst.instruction |= inst.operands[1].reg;
9245 inst.instruction |= inst.operands[2].reg << 16;
9246 inst.reloc.type = BFD_RELOC_UNUSED;
9252 constraint (!inst.operands[2].isreg || !inst.operands[2].preind
9253 || inst.operands[2].postind || inst.operands[2].writeback
9254 || inst.operands[2].immisreg || inst.operands[2].shifted
9255 || inst.operands[2].negative,
9258 constraint (inst.operands[0].reg == inst.operands[1].reg
9259 || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
9267 constraint (inst.operands[1].reg % 2 != 0,
9268 _("even register required"));
9269 constraint (inst.operands[2].present
9270 && inst.operands[2].reg != inst.operands[1].reg + 1,
9271 _("can only store two consecutive registers"));
9272 /* If op 2 were present and equal to PC, this function wouldn't
9273 have been called in the first place. */
9274 constraint (inst.operands[1].reg == REG_LR, _("r14 not allowed here"));
9276 constraint (inst.operands[0].reg == inst.operands[1].reg
9277 || inst.operands[0].reg == inst.operands[1].reg + 1
9278 || inst.operands[0].reg == inst.operands[3].reg,
9281 inst.instruction |= inst.operands[0].reg << 12;
9282 inst.instruction |= inst.operands[1].reg;
9283 inst.instruction |= inst.operands[3].reg << 16;
9290 constraint (inst.operands[0].reg == inst.operands[1].reg
9291 || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
9299 constraint (inst.operands[0].reg == inst.operands[1].reg
9300 || inst.operands[0].reg == inst.operands[2].reg, BAD_OVERLAP);
9305 /* ARM V6 SXTAH extracts a 16-bit value from a register, sign
9306 extends it to 32-bits, and adds the result to a value in another
9307 register. You can specify a rotation by 0, 8, 16, or 24 bits
9308 before extracting the 16-bit value.
9309 SXTAH{<cond>} <Rd>, <Rn>, <Rm>{, <rotation>}
9310 Condition defaults to COND_ALWAYS.
9311 Error if any register uses R15. */
9316 inst.instruction |= inst.operands[0].reg << 12;
9317 inst.instruction |= inst.operands[1].reg << 16;
9318 inst.instruction |= inst.operands[2].reg;
9319 inst.instruction |= inst.operands[3].imm << 10;
9324 SXTH {<cond>} <Rd>, <Rm>{, <rotation>}
9325 Condition defaults to COND_ALWAYS.
9326 Error if any register uses R15. */
9331 inst.instruction |= inst.operands[0].reg << 12;
9332 inst.instruction |= inst.operands[1].reg;
9333 inst.instruction |= inst.operands[2].imm << 10;
9336 /* VFP instructions. In a logical order: SP variant first, monad
9337 before dyad, arithmetic then move then load/store. */
9340 do_vfp_sp_monadic (void)
9342 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9343 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sm);
9347 do_vfp_sp_dyadic (void)
9349 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9350 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sn);
9351 encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Sm);
9355 do_vfp_sp_compare_z (void)
9357 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9361 do_vfp_dp_sp_cvt (void)
9363 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9364 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sm);
9368 do_vfp_sp_dp_cvt (void)
9370 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9371 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dm);
9375 do_vfp_reg_from_sp (void)
9377 inst.instruction |= inst.operands[0].reg << 12;
9378 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sn);
9382 do_vfp_reg2_from_sp2 (void)
9384 constraint (inst.operands[2].imm != 2,
9385 _("only two consecutive VFP SP registers allowed here"));
9386 inst.instruction |= inst.operands[0].reg << 12;
9387 inst.instruction |= inst.operands[1].reg << 16;
9388 encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Sm);
9392 do_vfp_sp_from_reg (void)
9394 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sn);
9395 inst.instruction |= inst.operands[1].reg << 12;
9399 do_vfp_sp2_from_reg2 (void)
9401 constraint (inst.operands[0].imm != 2,
9402 _("only two consecutive VFP SP registers allowed here"));
9403 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sm);
9404 inst.instruction |= inst.operands[1].reg << 12;
9405 inst.instruction |= inst.operands[2].reg << 16;
9409 do_vfp_sp_ldst (void)
9411 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9412 encode_arm_cp_address (1, FALSE, TRUE, 0);
9416 do_vfp_dp_ldst (void)
9418 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9419 encode_arm_cp_address (1, FALSE, TRUE, 0);
9424 vfp_sp_ldstm (enum vfp_ldstm_type ldstm_type)
9426 if (inst.operands[0].writeback)
9427 inst.instruction |= WRITE_BACK;
9429 constraint (ldstm_type != VFP_LDSTMIA,
9430 _("this addressing mode requires base-register writeback"));
9431 inst.instruction |= inst.operands[0].reg << 16;
9432 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Sd);
9433 inst.instruction |= inst.operands[1].imm;
9437 vfp_dp_ldstm (enum vfp_ldstm_type ldstm_type)
9441 if (inst.operands[0].writeback)
9442 inst.instruction |= WRITE_BACK;
9444 constraint (ldstm_type != VFP_LDSTMIA && ldstm_type != VFP_LDSTMIAX,
9445 _("this addressing mode requires base-register writeback"));
9447 inst.instruction |= inst.operands[0].reg << 16;
9448 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dd);
9450 count = inst.operands[1].imm << 1;
9451 if (ldstm_type == VFP_LDSTMIAX || ldstm_type == VFP_LDSTMDBX)
9454 inst.instruction |= count;
9458 do_vfp_sp_ldstmia (void)
9460 vfp_sp_ldstm (VFP_LDSTMIA);
9464 do_vfp_sp_ldstmdb (void)
9466 vfp_sp_ldstm (VFP_LDSTMDB);
9470 do_vfp_dp_ldstmia (void)
9472 vfp_dp_ldstm (VFP_LDSTMIA);
9476 do_vfp_dp_ldstmdb (void)
9478 vfp_dp_ldstm (VFP_LDSTMDB);
9482 do_vfp_xp_ldstmia (void)
9484 vfp_dp_ldstm (VFP_LDSTMIAX);
9488 do_vfp_xp_ldstmdb (void)
9490 vfp_dp_ldstm (VFP_LDSTMDBX);
9494 do_vfp_dp_rd_rm (void)
9496 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9497 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dm);
9501 do_vfp_dp_rn_rd (void)
9503 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dn);
9504 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dd);
9508 do_vfp_dp_rd_rn (void)
9510 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9511 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dn);
9515 do_vfp_dp_rd_rn_rm (void)
9517 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9518 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dn);
9519 encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Dm);
9525 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9529 do_vfp_dp_rm_rd_rn (void)
9531 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dm);
9532 encode_arm_vfp_reg (inst.operands[1].reg, VFP_REG_Dd);
9533 encode_arm_vfp_reg (inst.operands[2].reg, VFP_REG_Dn);
9536 /* VFPv3 instructions. */
9538 do_vfp_sp_const (void)
9540 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9541 inst.instruction |= (inst.operands[1].imm & 0xf0) << 12;
9542 inst.instruction |= (inst.operands[1].imm & 0x0f);
9546 do_vfp_dp_const (void)
9548 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9549 inst.instruction |= (inst.operands[1].imm & 0xf0) << 12;
9550 inst.instruction |= (inst.operands[1].imm & 0x0f);
9554 vfp_conv (int srcsize)
9556 int immbits = srcsize - inst.operands[1].imm;
9558 if (srcsize == 16 && !(immbits >= 0 && immbits <= srcsize))
9560 /* If srcsize is 16, inst.operands[1].imm must be in the range 0-16.
9561 i.e. immbits must be in range 0 - 16. */
9562 inst.error = _("immediate value out of range, expected range [0, 16]");
9565 else if (srcsize == 32 && !(immbits >= 0 && immbits < srcsize))
9567 /* If srcsize is 32, inst.operands[1].imm must be in the range 1-32.
9568 i.e. immbits must be in range 0 - 31. */
9569 inst.error = _("immediate value out of range, expected range [1, 32]");
9573 inst.instruction |= (immbits & 1) << 5;
9574 inst.instruction |= (immbits >> 1);
9578 do_vfp_sp_conv_16 (void)
9580 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9585 do_vfp_dp_conv_16 (void)
9587 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9592 do_vfp_sp_conv_32 (void)
9594 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
9599 do_vfp_dp_conv_32 (void)
9601 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Dd);
9605 /* FPA instructions. Also in a logical order. */
9610 inst.instruction |= inst.operands[0].reg << 16;
9611 inst.instruction |= inst.operands[1].reg;
9615 do_fpa_ldmstm (void)
9617 inst.instruction |= inst.operands[0].reg << 12;
9618 switch (inst.operands[1].imm)
9620 case 1: inst.instruction |= CP_T_X; break;
9621 case 2: inst.instruction |= CP_T_Y; break;
9622 case 3: inst.instruction |= CP_T_Y | CP_T_X; break;
9627 if (inst.instruction & (PRE_INDEX | INDEX_UP))
9629 /* The instruction specified "ea" or "fd", so we can only accept
9630 [Rn]{!}. The instruction does not really support stacking or
9631 unstacking, so we have to emulate these by setting appropriate
9632 bits and offsets. */
9633 constraint (inst.reloc.exp.X_op != O_constant
9634 || inst.reloc.exp.X_add_number != 0,
9635 _("this instruction does not support indexing"));
9637 if ((inst.instruction & PRE_INDEX) || inst.operands[2].writeback)
9638 inst.reloc.exp.X_add_number = 12 * inst.operands[1].imm;
9640 if (!(inst.instruction & INDEX_UP))
9641 inst.reloc.exp.X_add_number = -inst.reloc.exp.X_add_number;
9643 if (!(inst.instruction & PRE_INDEX) && inst.operands[2].writeback)
9645 inst.operands[2].preind = 0;
9646 inst.operands[2].postind = 1;
9650 encode_arm_cp_address (2, TRUE, TRUE, 0);
9653 /* iWMMXt instructions: strictly in alphabetical order. */
9656 do_iwmmxt_tandorc (void)
9658 constraint (inst.operands[0].reg != REG_PC, _("only r15 allowed here"));
9662 do_iwmmxt_textrc (void)
9664 inst.instruction |= inst.operands[0].reg << 12;
9665 inst.instruction |= inst.operands[1].imm;
9669 do_iwmmxt_textrm (void)
9671 inst.instruction |= inst.operands[0].reg << 12;
9672 inst.instruction |= inst.operands[1].reg << 16;
9673 inst.instruction |= inst.operands[2].imm;
9677 do_iwmmxt_tinsr (void)
9679 inst.instruction |= inst.operands[0].reg << 16;
9680 inst.instruction |= inst.operands[1].reg << 12;
9681 inst.instruction |= inst.operands[2].imm;
9685 do_iwmmxt_tmia (void)
9687 inst.instruction |= inst.operands[0].reg << 5;
9688 inst.instruction |= inst.operands[1].reg;
9689 inst.instruction |= inst.operands[2].reg << 12;
9693 do_iwmmxt_waligni (void)
9695 inst.instruction |= inst.operands[0].reg << 12;
9696 inst.instruction |= inst.operands[1].reg << 16;
9697 inst.instruction |= inst.operands[2].reg;
9698 inst.instruction |= inst.operands[3].imm << 20;
9702 do_iwmmxt_wmerge (void)
9704 inst.instruction |= inst.operands[0].reg << 12;
9705 inst.instruction |= inst.operands[1].reg << 16;
9706 inst.instruction |= inst.operands[2].reg;
9707 inst.instruction |= inst.operands[3].imm << 21;
9711 do_iwmmxt_wmov (void)
9713 /* WMOV rD, rN is an alias for WOR rD, rN, rN. */
9714 inst.instruction |= inst.operands[0].reg << 12;
9715 inst.instruction |= inst.operands[1].reg << 16;
9716 inst.instruction |= inst.operands[1].reg;
9720 do_iwmmxt_wldstbh (void)
9723 inst.instruction |= inst.operands[0].reg << 12;
9725 reloc = BFD_RELOC_ARM_T32_CP_OFF_IMM_S2;
9727 reloc = BFD_RELOC_ARM_CP_OFF_IMM_S2;
9728 encode_arm_cp_address (1, TRUE, FALSE, reloc);
9732 do_iwmmxt_wldstw (void)
9734 /* RIWR_RIWC clears .isreg for a control register. */
9735 if (!inst.operands[0].isreg)
9737 constraint (inst.cond != COND_ALWAYS, BAD_COND);
9738 inst.instruction |= 0xf0000000;
9741 inst.instruction |= inst.operands[0].reg << 12;
9742 encode_arm_cp_address (1, TRUE, TRUE, 0);
9746 do_iwmmxt_wldstd (void)
9748 inst.instruction |= inst.operands[0].reg << 12;
9749 if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt2)
9750 && inst.operands[1].immisreg)
9752 inst.instruction &= ~0x1a000ff;
9753 inst.instruction |= (0xf << 28);
9754 if (inst.operands[1].preind)
9755 inst.instruction |= PRE_INDEX;
9756 if (!inst.operands[1].negative)
9757 inst.instruction |= INDEX_UP;
9758 if (inst.operands[1].writeback)
9759 inst.instruction |= WRITE_BACK;
9760 inst.instruction |= inst.operands[1].reg << 16;
9761 inst.instruction |= inst.reloc.exp.X_add_number << 4;
9762 inst.instruction |= inst.operands[1].imm;
9765 encode_arm_cp_address (1, TRUE, FALSE, 0);
9769 do_iwmmxt_wshufh (void)
9771 inst.instruction |= inst.operands[0].reg << 12;
9772 inst.instruction |= inst.operands[1].reg << 16;
9773 inst.instruction |= ((inst.operands[2].imm & 0xf0) << 16);
9774 inst.instruction |= (inst.operands[2].imm & 0x0f);
9778 do_iwmmxt_wzero (void)
9780 /* WZERO reg is an alias for WANDN reg, reg, reg. */
9781 inst.instruction |= inst.operands[0].reg;
9782 inst.instruction |= inst.operands[0].reg << 12;
9783 inst.instruction |= inst.operands[0].reg << 16;
9787 do_iwmmxt_wrwrwr_or_imm5 (void)
9789 if (inst.operands[2].isreg)
9792 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt2),
9793 _("immediate operand requires iWMMXt2"));
9795 if (inst.operands[2].imm == 0)
9797 switch ((inst.instruction >> 20) & 0xf)
9803 /* w...h wrd, wrn, #0 -> wrorh wrd, wrn, #16. */
9804 inst.operands[2].imm = 16;
9805 inst.instruction = (inst.instruction & 0xff0fffff) | (0x7 << 20);
9811 /* w...w wrd, wrn, #0 -> wrorw wrd, wrn, #32. */
9812 inst.operands[2].imm = 32;
9813 inst.instruction = (inst.instruction & 0xff0fffff) | (0xb << 20);
9820 /* w...d wrd, wrn, #0 -> wor wrd, wrn, wrn. */
9822 wrn = (inst.instruction >> 16) & 0xf;
9823 inst.instruction &= 0xff0fff0f;
9824 inst.instruction |= wrn;
9825 /* Bail out here; the instruction is now assembled. */
9830 /* Map 32 -> 0, etc. */
9831 inst.operands[2].imm &= 0x1f;
9832 inst.instruction |= (0xf << 28) | ((inst.operands[2].imm & 0x10) << 4) | (inst.operands[2].imm & 0xf);
9836 /* Cirrus Maverick instructions. Simple 2-, 3-, and 4-register
9837 operations first, then control, shift, and load/store. */
9839 /* Insns like "foo X,Y,Z". */
9842 do_mav_triple (void)
9844 inst.instruction |= inst.operands[0].reg << 16;
9845 inst.instruction |= inst.operands[1].reg;
9846 inst.instruction |= inst.operands[2].reg << 12;
9849 /* Insns like "foo W,X,Y,Z".
9850 where W=MVAX[0:3] and X,Y,Z=MVFX[0:15]. */
9855 inst.instruction |= inst.operands[0].reg << 5;
9856 inst.instruction |= inst.operands[1].reg << 12;
9857 inst.instruction |= inst.operands[2].reg << 16;
9858 inst.instruction |= inst.operands[3].reg;
9861 /* cfmvsc32<cond> DSPSC,MVDX[15:0]. */
9865 inst.instruction |= inst.operands[1].reg << 12;
9868 /* Maverick shift immediate instructions.
9869 cfsh32<cond> MVFX[15:0],MVFX[15:0],Shift[6:0].
9870 cfsh64<cond> MVDX[15:0],MVDX[15:0],Shift[6:0]. */
9875 int imm = inst.operands[2].imm;
9877 inst.instruction |= inst.operands[0].reg << 12;
9878 inst.instruction |= inst.operands[1].reg << 16;
9880 /* Bits 0-3 of the insn should have bits 0-3 of the immediate.
9881 Bits 5-7 of the insn should have bits 4-6 of the immediate.
9882 Bit 4 should be 0. */
9883 imm = (imm & 0xf) | ((imm & 0x70) << 1);
9885 inst.instruction |= imm;
9888 /* XScale instructions. Also sorted arithmetic before move. */
9890 /* Xscale multiply-accumulate (argument parse)
9893 MIAxycc acc0,Rm,Rs. */
9898 inst.instruction |= inst.operands[1].reg;
9899 inst.instruction |= inst.operands[2].reg << 12;
9902 /* Xscale move-accumulator-register (argument parse)
9904 MARcc acc0,RdLo,RdHi. */
9909 inst.instruction |= inst.operands[1].reg << 12;
9910 inst.instruction |= inst.operands[2].reg << 16;
9913 /* Xscale move-register-accumulator (argument parse)
9915 MRAcc RdLo,RdHi,acc0. */
9920 constraint (inst.operands[0].reg == inst.operands[1].reg, BAD_OVERLAP);
9921 inst.instruction |= inst.operands[0].reg << 12;
9922 inst.instruction |= inst.operands[1].reg << 16;
9925 /* Encoding functions relevant only to Thumb. */
9927 /* inst.operands[i] is a shifted-register operand; encode
9928 it into inst.instruction in the format used by Thumb32. */
9931 encode_thumb32_shifted_operand (int i)
9933 unsigned int value = inst.reloc.exp.X_add_number;
9934 unsigned int shift = inst.operands[i].shift_kind;
9936 constraint (inst.operands[i].immisreg,
9937 _("shift by register not allowed in thumb mode"));
9938 inst.instruction |= inst.operands[i].reg;
9939 if (shift == SHIFT_RRX)
9940 inst.instruction |= SHIFT_ROR << 4;
9943 constraint (inst.reloc.exp.X_op != O_constant,
9944 _("expression too complex"));
9946 constraint (value > 32
9947 || (value == 32 && (shift == SHIFT_LSL
9948 || shift == SHIFT_ROR)),
9949 _("shift expression is too large"));
9953 else if (value == 32)
9956 inst.instruction |= shift << 4;
9957 inst.instruction |= (value & 0x1c) << 10;
9958 inst.instruction |= (value & 0x03) << 6;
9963 /* inst.operands[i] was set up by parse_address. Encode it into a
9964 Thumb32 format load or store instruction. Reject forms that cannot
9965 be used with such instructions. If is_t is true, reject forms that
9966 cannot be used with a T instruction; if is_d is true, reject forms
9967 that cannot be used with a D instruction. If it is a store insn,
9971 encode_thumb32_addr_mode (int i, bfd_boolean is_t, bfd_boolean is_d)
9973 const bfd_boolean is_pc = (inst.operands[i].reg == REG_PC);
9975 constraint (!inst.operands[i].isreg,
9976 _("Instruction does not support =N addresses"));
9978 inst.instruction |= inst.operands[i].reg << 16;
9979 if (inst.operands[i].immisreg)
9981 constraint (is_pc, BAD_PC_ADDRESSING);
9982 constraint (is_t || is_d, _("cannot use register index with this instruction"));
9983 constraint (inst.operands[i].negative,
9984 _("Thumb does not support negative register indexing"));
9985 constraint (inst.operands[i].postind,
9986 _("Thumb does not support register post-indexing"));
9987 constraint (inst.operands[i].writeback,
9988 _("Thumb does not support register indexing with writeback"));
9989 constraint (inst.operands[i].shifted && inst.operands[i].shift_kind != SHIFT_LSL,
9990 _("Thumb supports only LSL in shifted register indexing"));
9992 inst.instruction |= inst.operands[i].imm;
9993 if (inst.operands[i].shifted)
9995 constraint (inst.reloc.exp.X_op != O_constant,
9996 _("expression too complex"));
9997 constraint (inst.reloc.exp.X_add_number < 0
9998 || inst.reloc.exp.X_add_number > 3,
9999 _("shift out of range"));
10000 inst.instruction |= inst.reloc.exp.X_add_number << 4;
10002 inst.reloc.type = BFD_RELOC_UNUSED;
10004 else if (inst.operands[i].preind)
10006 constraint (is_pc && inst.operands[i].writeback, BAD_PC_WRITEBACK);
10007 constraint (is_t && inst.operands[i].writeback,
10008 _("cannot use writeback with this instruction"));
10009 constraint (is_pc && ((inst.instruction & THUMB2_LOAD_BIT) == 0),
10010 BAD_PC_ADDRESSING);
10014 inst.instruction |= 0x01000000;
10015 if (inst.operands[i].writeback)
10016 inst.instruction |= 0x00200000;
10020 inst.instruction |= 0x00000c00;
10021 if (inst.operands[i].writeback)
10022 inst.instruction |= 0x00000100;
10024 inst.reloc.type = BFD_RELOC_ARM_T32_OFFSET_IMM;
10026 else if (inst.operands[i].postind)
10028 gas_assert (inst.operands[i].writeback);
10029 constraint (is_pc, _("cannot use post-indexing with PC-relative addressing"));
10030 constraint (is_t, _("cannot use post-indexing with this instruction"));
10033 inst.instruction |= 0x00200000;
10035 inst.instruction |= 0x00000900;
10036 inst.reloc.type = BFD_RELOC_ARM_T32_OFFSET_IMM;
10038 else /* unindexed - only for coprocessor */
10039 inst.error = _("instruction does not accept unindexed addressing");
10042 /* Table of Thumb instructions which exist in both 16- and 32-bit
10043 encodings (the latter only in post-V6T2 cores). The index is the
10044 value used in the insns table below. When there is more than one
10045 possible 16-bit encoding for the instruction, this table always
10047 Also contains several pseudo-instructions used during relaxation. */
10048 #define T16_32_TAB \
10049 X(_adc, 4140, eb400000), \
10050 X(_adcs, 4140, eb500000), \
10051 X(_add, 1c00, eb000000), \
10052 X(_adds, 1c00, eb100000), \
10053 X(_addi, 0000, f1000000), \
10054 X(_addis, 0000, f1100000), \
10055 X(_add_pc,000f, f20f0000), \
10056 X(_add_sp,000d, f10d0000), \
10057 X(_adr, 000f, f20f0000), \
10058 X(_and, 4000, ea000000), \
10059 X(_ands, 4000, ea100000), \
10060 X(_asr, 1000, fa40f000), \
10061 X(_asrs, 1000, fa50f000), \
10062 X(_b, e000, f000b000), \
10063 X(_bcond, d000, f0008000), \
10064 X(_bic, 4380, ea200000), \
10065 X(_bics, 4380, ea300000), \
10066 X(_cmn, 42c0, eb100f00), \
10067 X(_cmp, 2800, ebb00f00), \
10068 X(_cpsie, b660, f3af8400), \
10069 X(_cpsid, b670, f3af8600), \
10070 X(_cpy, 4600, ea4f0000), \
10071 X(_dec_sp,80dd, f1ad0d00), \
10072 X(_eor, 4040, ea800000), \
10073 X(_eors, 4040, ea900000), \
10074 X(_inc_sp,00dd, f10d0d00), \
10075 X(_ldmia, c800, e8900000), \
10076 X(_ldr, 6800, f8500000), \
10077 X(_ldrb, 7800, f8100000), \
10078 X(_ldrh, 8800, f8300000), \
10079 X(_ldrsb, 5600, f9100000), \
10080 X(_ldrsh, 5e00, f9300000), \
10081 X(_ldr_pc,4800, f85f0000), \
10082 X(_ldr_pc2,4800, f85f0000), \
10083 X(_ldr_sp,9800, f85d0000), \
10084 X(_lsl, 0000, fa00f000), \
10085 X(_lsls, 0000, fa10f000), \
10086 X(_lsr, 0800, fa20f000), \
10087 X(_lsrs, 0800, fa30f000), \
10088 X(_mov, 2000, ea4f0000), \
10089 X(_movs, 2000, ea5f0000), \
10090 X(_mul, 4340, fb00f000), \
10091 X(_muls, 4340, ffffffff), /* no 32b muls */ \
10092 X(_mvn, 43c0, ea6f0000), \
10093 X(_mvns, 43c0, ea7f0000), \
10094 X(_neg, 4240, f1c00000), /* rsb #0 */ \
10095 X(_negs, 4240, f1d00000), /* rsbs #0 */ \
10096 X(_orr, 4300, ea400000), \
10097 X(_orrs, 4300, ea500000), \
10098 X(_pop, bc00, e8bd0000), /* ldmia sp!,... */ \
10099 X(_push, b400, e92d0000), /* stmdb sp!,... */ \
10100 X(_rev, ba00, fa90f080), \
10101 X(_rev16, ba40, fa90f090), \
10102 X(_revsh, bac0, fa90f0b0), \
10103 X(_ror, 41c0, fa60f000), \
10104 X(_rors, 41c0, fa70f000), \
10105 X(_sbc, 4180, eb600000), \
10106 X(_sbcs, 4180, eb700000), \
10107 X(_stmia, c000, e8800000), \
10108 X(_str, 6000, f8400000), \
10109 X(_strb, 7000, f8000000), \
10110 X(_strh, 8000, f8200000), \
10111 X(_str_sp,9000, f84d0000), \
10112 X(_sub, 1e00, eba00000), \
10113 X(_subs, 1e00, ebb00000), \
10114 X(_subi, 8000, f1a00000), \
10115 X(_subis, 8000, f1b00000), \
10116 X(_sxtb, b240, fa4ff080), \
10117 X(_sxth, b200, fa0ff080), \
10118 X(_tst, 4200, ea100f00), \
10119 X(_uxtb, b2c0, fa5ff080), \
10120 X(_uxth, b280, fa1ff080), \
10121 X(_nop, bf00, f3af8000), \
10122 X(_yield, bf10, f3af8001), \
10123 X(_wfe, bf20, f3af8002), \
10124 X(_wfi, bf30, f3af8003), \
10125 X(_sev, bf40, f3af8004), \
10126 X(_sevl, bf50, f3af8005), \
10127 X(_udf, de00, f7f0a000)
10129 /* To catch errors in encoding functions, the codes are all offset by
10130 0xF800, putting them in one of the 32-bit prefix ranges, ergo undefined
10131 as 16-bit instructions. */
10132 #define X(a,b,c) T_MNEM##a
10133 enum t16_32_codes { T16_32_OFFSET = 0xF7FF, T16_32_TAB };
10136 #define X(a,b,c) 0x##b
10137 static const unsigned short thumb_op16[] = { T16_32_TAB };
10138 #define THUMB_OP16(n) (thumb_op16[(n) - (T16_32_OFFSET + 1)])
10141 #define X(a,b,c) 0x##c
10142 static const unsigned int thumb_op32[] = { T16_32_TAB };
10143 #define THUMB_OP32(n) (thumb_op32[(n) - (T16_32_OFFSET + 1)])
10144 #define THUMB_SETS_FLAGS(n) (THUMB_OP32 (n) & 0x00100000)
10148 /* Thumb instruction encoders, in alphabetical order. */
10150 /* ADDW or SUBW. */
10153 do_t_add_sub_w (void)
10157 Rd = inst.operands[0].reg;
10158 Rn = inst.operands[1].reg;
10160 /* If Rn is REG_PC, this is ADR; if Rn is REG_SP, then this
10161 is the SP-{plus,minus}-immediate form of the instruction. */
10163 constraint (Rd == REG_PC, BAD_PC);
10165 reject_bad_reg (Rd);
10167 inst.instruction |= (Rn << 16) | (Rd << 8);
10168 inst.reloc.type = BFD_RELOC_ARM_T32_IMM12;
10171 /* Parse an add or subtract instruction. We get here with inst.instruction
10172 equalling any of THUMB_OPCODE_add, adds, sub, or subs. */
10175 do_t_add_sub (void)
10179 Rd = inst.operands[0].reg;
10180 Rs = (inst.operands[1].present
10181 ? inst.operands[1].reg /* Rd, Rs, foo */
10182 : inst.operands[0].reg); /* Rd, foo -> Rd, Rd, foo */
10185 set_it_insn_type_last ();
10187 if (unified_syntax)
10190 bfd_boolean narrow;
10193 flags = (inst.instruction == T_MNEM_adds
10194 || inst.instruction == T_MNEM_subs);
10196 narrow = !in_it_block ();
10198 narrow = in_it_block ();
10199 if (!inst.operands[2].isreg)
10203 constraint (Rd == REG_SP && Rs != REG_SP, BAD_SP);
10205 add = (inst.instruction == T_MNEM_add
10206 || inst.instruction == T_MNEM_adds);
10208 if (inst.size_req != 4)
10210 /* Attempt to use a narrow opcode, with relaxation if
10212 if (Rd == REG_SP && Rs == REG_SP && !flags)
10213 opcode = add ? T_MNEM_inc_sp : T_MNEM_dec_sp;
10214 else if (Rd <= 7 && Rs == REG_SP && add && !flags)
10215 opcode = T_MNEM_add_sp;
10216 else if (Rd <= 7 && Rs == REG_PC && add && !flags)
10217 opcode = T_MNEM_add_pc;
10218 else if (Rd <= 7 && Rs <= 7 && narrow)
10221 opcode = add ? T_MNEM_addis : T_MNEM_subis;
10223 opcode = add ? T_MNEM_addi : T_MNEM_subi;
10227 inst.instruction = THUMB_OP16(opcode);
10228 inst.instruction |= (Rd << 4) | Rs;
10229 inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
10230 if (inst.size_req != 2)
10231 inst.relax = opcode;
10234 constraint (inst.size_req == 2, BAD_HIREG);
10236 if (inst.size_req == 4
10237 || (inst.size_req != 2 && !opcode))
10241 constraint (add, BAD_PC);
10242 constraint (Rs != REG_LR || inst.instruction != T_MNEM_subs,
10243 _("only SUBS PC, LR, #const allowed"));
10244 constraint (inst.reloc.exp.X_op != O_constant,
10245 _("expression too complex"));
10246 constraint (inst.reloc.exp.X_add_number < 0
10247 || inst.reloc.exp.X_add_number > 0xff,
10248 _("immediate value out of range"));
10249 inst.instruction = T2_SUBS_PC_LR
10250 | inst.reloc.exp.X_add_number;
10251 inst.reloc.type = BFD_RELOC_UNUSED;
10254 else if (Rs == REG_PC)
10256 /* Always use addw/subw. */
10257 inst.instruction = add ? 0xf20f0000 : 0xf2af0000;
10258 inst.reloc.type = BFD_RELOC_ARM_T32_IMM12;
10262 inst.instruction = THUMB_OP32 (inst.instruction);
10263 inst.instruction = (inst.instruction & 0xe1ffffff)
10266 inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
10268 inst.reloc.type = BFD_RELOC_ARM_T32_ADD_IMM;
10270 inst.instruction |= Rd << 8;
10271 inst.instruction |= Rs << 16;
10276 unsigned int value = inst.reloc.exp.X_add_number;
10277 unsigned int shift = inst.operands[2].shift_kind;
10279 Rn = inst.operands[2].reg;
10280 /* See if we can do this with a 16-bit instruction. */
10281 if (!inst.operands[2].shifted && inst.size_req != 4)
10283 if (Rd > 7 || Rs > 7 || Rn > 7)
10288 inst.instruction = ((inst.instruction == T_MNEM_adds
10289 || inst.instruction == T_MNEM_add)
10291 : T_OPCODE_SUB_R3);
10292 inst.instruction |= Rd | (Rs << 3) | (Rn << 6);
10296 if (inst.instruction == T_MNEM_add && (Rd == Rs || Rd == Rn))
10298 /* Thumb-1 cores (except v6-M) require at least one high
10299 register in a narrow non flag setting add. */
10300 if (Rd > 7 || Rn > 7
10301 || ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6t2)
10302 || ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_msr))
10309 inst.instruction = T_OPCODE_ADD_HI;
10310 inst.instruction |= (Rd & 8) << 4;
10311 inst.instruction |= (Rd & 7);
10312 inst.instruction |= Rn << 3;
10318 constraint (Rd == REG_PC, BAD_PC);
10319 constraint (Rd == REG_SP && Rs != REG_SP, BAD_SP);
10320 constraint (Rs == REG_PC, BAD_PC);
10321 reject_bad_reg (Rn);
10323 /* If we get here, it can't be done in 16 bits. */
10324 constraint (inst.operands[2].shifted && inst.operands[2].immisreg,
10325 _("shift must be constant"));
10326 inst.instruction = THUMB_OP32 (inst.instruction);
10327 inst.instruction |= Rd << 8;
10328 inst.instruction |= Rs << 16;
10329 constraint (Rd == REG_SP && Rs == REG_SP && value > 3,
10330 _("shift value over 3 not allowed in thumb mode"));
10331 constraint (Rd == REG_SP && Rs == REG_SP && shift != SHIFT_LSL,
10332 _("only LSL shift allowed in thumb mode"));
10333 encode_thumb32_shifted_operand (2);
10338 constraint (inst.instruction == T_MNEM_adds
10339 || inst.instruction == T_MNEM_subs,
10342 if (!inst.operands[2].isreg) /* Rd, Rs, #imm */
10344 constraint ((Rd > 7 && (Rd != REG_SP || Rs != REG_SP))
10345 || (Rs > 7 && Rs != REG_SP && Rs != REG_PC),
10348 inst.instruction = (inst.instruction == T_MNEM_add
10349 ? 0x0000 : 0x8000);
10350 inst.instruction |= (Rd << 4) | Rs;
10351 inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
10355 Rn = inst.operands[2].reg;
10356 constraint (inst.operands[2].shifted, _("unshifted register required"));
10358 /* We now have Rd, Rs, and Rn set to registers. */
10359 if (Rd > 7 || Rs > 7 || Rn > 7)
10361 /* Can't do this for SUB. */
10362 constraint (inst.instruction == T_MNEM_sub, BAD_HIREG);
10363 inst.instruction = T_OPCODE_ADD_HI;
10364 inst.instruction |= (Rd & 8) << 4;
10365 inst.instruction |= (Rd & 7);
10367 inst.instruction |= Rn << 3;
10369 inst.instruction |= Rs << 3;
10371 constraint (1, _("dest must overlap one source register"));
10375 inst.instruction = (inst.instruction == T_MNEM_add
10376 ? T_OPCODE_ADD_R3 : T_OPCODE_SUB_R3);
10377 inst.instruction |= Rd | (Rs << 3) | (Rn << 6);
10387 Rd = inst.operands[0].reg;
10388 reject_bad_reg (Rd);
10390 if (unified_syntax && inst.size_req == 0 && Rd <= 7)
10392 /* Defer to section relaxation. */
10393 inst.relax = inst.instruction;
10394 inst.instruction = THUMB_OP16 (inst.instruction);
10395 inst.instruction |= Rd << 4;
10397 else if (unified_syntax && inst.size_req != 2)
10399 /* Generate a 32-bit opcode. */
10400 inst.instruction = THUMB_OP32 (inst.instruction);
10401 inst.instruction |= Rd << 8;
10402 inst.reloc.type = BFD_RELOC_ARM_T32_ADD_PC12;
10403 inst.reloc.pc_rel = 1;
10407 /* Generate a 16-bit opcode. */
10408 inst.instruction = THUMB_OP16 (inst.instruction);
10409 inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
10410 inst.reloc.exp.X_add_number -= 4; /* PC relative adjust. */
10411 inst.reloc.pc_rel = 1;
10413 inst.instruction |= Rd << 4;
10417 /* Arithmetic instructions for which there is just one 16-bit
10418 instruction encoding, and it allows only two low registers.
10419 For maximal compatibility with ARM syntax, we allow three register
10420 operands even when Thumb-32 instructions are not available, as long
10421 as the first two are identical. For instance, both "sbc r0,r1" and
10422 "sbc r0,r0,r1" are allowed. */
10428 Rd = inst.operands[0].reg;
10429 Rs = (inst.operands[1].present
10430 ? inst.operands[1].reg /* Rd, Rs, foo */
10431 : inst.operands[0].reg); /* Rd, foo -> Rd, Rd, foo */
10432 Rn = inst.operands[2].reg;
10434 reject_bad_reg (Rd);
10435 reject_bad_reg (Rs);
10436 if (inst.operands[2].isreg)
10437 reject_bad_reg (Rn);
10439 if (unified_syntax)
10441 if (!inst.operands[2].isreg)
10443 /* For an immediate, we always generate a 32-bit opcode;
10444 section relaxation will shrink it later if possible. */
10445 inst.instruction = THUMB_OP32 (inst.instruction);
10446 inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
10447 inst.instruction |= Rd << 8;
10448 inst.instruction |= Rs << 16;
10449 inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
10453 bfd_boolean narrow;
10455 /* See if we can do this with a 16-bit instruction. */
10456 if (THUMB_SETS_FLAGS (inst.instruction))
10457 narrow = !in_it_block ();
10459 narrow = in_it_block ();
10461 if (Rd > 7 || Rn > 7 || Rs > 7)
10463 if (inst.operands[2].shifted)
10465 if (inst.size_req == 4)
10471 inst.instruction = THUMB_OP16 (inst.instruction);
10472 inst.instruction |= Rd;
10473 inst.instruction |= Rn << 3;
10477 /* If we get here, it can't be done in 16 bits. */
10478 constraint (inst.operands[2].shifted
10479 && inst.operands[2].immisreg,
10480 _("shift must be constant"));
10481 inst.instruction = THUMB_OP32 (inst.instruction);
10482 inst.instruction |= Rd << 8;
10483 inst.instruction |= Rs << 16;
10484 encode_thumb32_shifted_operand (2);
10489 /* On its face this is a lie - the instruction does set the
10490 flags. However, the only supported mnemonic in this mode
10491 says it doesn't. */
10492 constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
10494 constraint (!inst.operands[2].isreg || inst.operands[2].shifted,
10495 _("unshifted register required"));
10496 constraint (Rd > 7 || Rs > 7 || Rn > 7, BAD_HIREG);
10497 constraint (Rd != Rs,
10498 _("dest and source1 must be the same register"));
10500 inst.instruction = THUMB_OP16 (inst.instruction);
10501 inst.instruction |= Rd;
10502 inst.instruction |= Rn << 3;
10506 /* Similarly, but for instructions where the arithmetic operation is
10507 commutative, so we can allow either of them to be different from
10508 the destination operand in a 16-bit instruction. For instance, all
10509 three of "adc r0,r1", "adc r0,r0,r1", and "adc r0,r1,r0" are
10516 Rd = inst.operands[0].reg;
10517 Rs = (inst.operands[1].present
10518 ? inst.operands[1].reg /* Rd, Rs, foo */
10519 : inst.operands[0].reg); /* Rd, foo -> Rd, Rd, foo */
10520 Rn = inst.operands[2].reg;
10522 reject_bad_reg (Rd);
10523 reject_bad_reg (Rs);
10524 if (inst.operands[2].isreg)
10525 reject_bad_reg (Rn);
10527 if (unified_syntax)
10529 if (!inst.operands[2].isreg)
10531 /* For an immediate, we always generate a 32-bit opcode;
10532 section relaxation will shrink it later if possible. */
10533 inst.instruction = THUMB_OP32 (inst.instruction);
10534 inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
10535 inst.instruction |= Rd << 8;
10536 inst.instruction |= Rs << 16;
10537 inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
10541 bfd_boolean narrow;
10543 /* See if we can do this with a 16-bit instruction. */
10544 if (THUMB_SETS_FLAGS (inst.instruction))
10545 narrow = !in_it_block ();
10547 narrow = in_it_block ();
10549 if (Rd > 7 || Rn > 7 || Rs > 7)
10551 if (inst.operands[2].shifted)
10553 if (inst.size_req == 4)
10560 inst.instruction = THUMB_OP16 (inst.instruction);
10561 inst.instruction |= Rd;
10562 inst.instruction |= Rn << 3;
10567 inst.instruction = THUMB_OP16 (inst.instruction);
10568 inst.instruction |= Rd;
10569 inst.instruction |= Rs << 3;
10574 /* If we get here, it can't be done in 16 bits. */
10575 constraint (inst.operands[2].shifted
10576 && inst.operands[2].immisreg,
10577 _("shift must be constant"));
10578 inst.instruction = THUMB_OP32 (inst.instruction);
10579 inst.instruction |= Rd << 8;
10580 inst.instruction |= Rs << 16;
10581 encode_thumb32_shifted_operand (2);
10586 /* On its face this is a lie - the instruction does set the
10587 flags. However, the only supported mnemonic in this mode
10588 says it doesn't. */
10589 constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
10591 constraint (!inst.operands[2].isreg || inst.operands[2].shifted,
10592 _("unshifted register required"));
10593 constraint (Rd > 7 || Rs > 7 || Rn > 7, BAD_HIREG);
10595 inst.instruction = THUMB_OP16 (inst.instruction);
10596 inst.instruction |= Rd;
10599 inst.instruction |= Rn << 3;
10601 inst.instruction |= Rs << 3;
10603 constraint (1, _("dest must overlap one source register"));
10611 unsigned int msb = inst.operands[1].imm + inst.operands[2].imm;
10612 constraint (msb > 32, _("bit-field extends past end of register"));
10613 /* The instruction encoding stores the LSB and MSB,
10614 not the LSB and width. */
10615 Rd = inst.operands[0].reg;
10616 reject_bad_reg (Rd);
10617 inst.instruction |= Rd << 8;
10618 inst.instruction |= (inst.operands[1].imm & 0x1c) << 10;
10619 inst.instruction |= (inst.operands[1].imm & 0x03) << 6;
10620 inst.instruction |= msb - 1;
10629 Rd = inst.operands[0].reg;
10630 reject_bad_reg (Rd);
10632 /* #0 in second position is alternative syntax for bfc, which is
10633 the same instruction but with REG_PC in the Rm field. */
10634 if (!inst.operands[1].isreg)
10638 Rn = inst.operands[1].reg;
10639 reject_bad_reg (Rn);
10642 msb = inst.operands[2].imm + inst.operands[3].imm;
10643 constraint (msb > 32, _("bit-field extends past end of register"));
10644 /* The instruction encoding stores the LSB and MSB,
10645 not the LSB and width. */
10646 inst.instruction |= Rd << 8;
10647 inst.instruction |= Rn << 16;
10648 inst.instruction |= (inst.operands[2].imm & 0x1c) << 10;
10649 inst.instruction |= (inst.operands[2].imm & 0x03) << 6;
10650 inst.instruction |= msb - 1;
10658 Rd = inst.operands[0].reg;
10659 Rn = inst.operands[1].reg;
10661 reject_bad_reg (Rd);
10662 reject_bad_reg (Rn);
10664 constraint (inst.operands[2].imm + inst.operands[3].imm > 32,
10665 _("bit-field extends past end of register"));
10666 inst.instruction |= Rd << 8;
10667 inst.instruction |= Rn << 16;
10668 inst.instruction |= (inst.operands[2].imm & 0x1c) << 10;
10669 inst.instruction |= (inst.operands[2].imm & 0x03) << 6;
10670 inst.instruction |= inst.operands[3].imm - 1;
10673 /* ARM V5 Thumb BLX (argument parse)
10674 BLX <target_addr> which is BLX(1)
10675 BLX <Rm> which is BLX(2)
10676 Unfortunately, there are two different opcodes for this mnemonic.
10677 So, the insns[].value is not used, and the code here zaps values
10678 into inst.instruction.
10680 ??? How to take advantage of the additional two bits of displacement
10681 available in Thumb32 mode? Need new relocation? */
10686 set_it_insn_type_last ();
10688 if (inst.operands[0].isreg)
10690 constraint (inst.operands[0].reg == REG_PC, BAD_PC);
10691 /* We have a register, so this is BLX(2). */
10692 inst.instruction |= inst.operands[0].reg << 3;
10696 /* No register. This must be BLX(1). */
10697 inst.instruction = 0xf000e800;
10698 encode_branch (BFD_RELOC_THUMB_PCREL_BLX);
10710 set_it_insn_type (IF_INSIDE_IT_LAST_INSN);
10712 if (in_it_block ())
10714 /* Conditional branches inside IT blocks are encoded as unconditional
10716 cond = COND_ALWAYS;
10721 if (cond != COND_ALWAYS)
10722 opcode = T_MNEM_bcond;
10724 opcode = inst.instruction;
10727 && (inst.size_req == 4
10728 || (inst.size_req != 2
10729 && (inst.operands[0].hasreloc
10730 || inst.reloc.exp.X_op == O_constant))))
10732 inst.instruction = THUMB_OP32(opcode);
10733 if (cond == COND_ALWAYS)
10734 reloc = BFD_RELOC_THUMB_PCREL_BRANCH25;
10737 gas_assert (cond != 0xF);
10738 inst.instruction |= cond << 22;
10739 reloc = BFD_RELOC_THUMB_PCREL_BRANCH20;
10744 inst.instruction = THUMB_OP16(opcode);
10745 if (cond == COND_ALWAYS)
10746 reloc = BFD_RELOC_THUMB_PCREL_BRANCH12;
10749 inst.instruction |= cond << 8;
10750 reloc = BFD_RELOC_THUMB_PCREL_BRANCH9;
10752 /* Allow section relaxation. */
10753 if (unified_syntax && inst.size_req != 2)
10754 inst.relax = opcode;
10756 inst.reloc.type = reloc;
10757 inst.reloc.pc_rel = 1;
10760 /* Actually do the work for Thumb state bkpt and hlt. The only difference
10761 between the two is the maximum immediate allowed - which is passed in
10764 do_t_bkpt_hlt1 (int range)
10766 constraint (inst.cond != COND_ALWAYS,
10767 _("instruction is always unconditional"));
10768 if (inst.operands[0].present)
10770 constraint (inst.operands[0].imm > range,
10771 _("immediate value out of range"));
10772 inst.instruction |= inst.operands[0].imm;
10775 set_it_insn_type (NEUTRAL_IT_INSN);
10781 do_t_bkpt_hlt1 (63);
10787 do_t_bkpt_hlt1 (255);
10791 do_t_branch23 (void)
10793 set_it_insn_type_last ();
10794 encode_branch (BFD_RELOC_THUMB_PCREL_BRANCH23);
10796 /* md_apply_fix blows up with 'bl foo(PLT)' where foo is defined in
10797 this file. We used to simply ignore the PLT reloc type here --
10798 the branch encoding is now needed to deal with TLSCALL relocs.
10799 So if we see a PLT reloc now, put it back to how it used to be to
10800 keep the preexisting behaviour. */
10801 if (inst.reloc.type == BFD_RELOC_ARM_PLT32)
10802 inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH23;
10804 #if defined(OBJ_COFF)
10805 /* If the destination of the branch is a defined symbol which does not have
10806 the THUMB_FUNC attribute, then we must be calling a function which has
10807 the (interfacearm) attribute. We look for the Thumb entry point to that
10808 function and change the branch to refer to that function instead. */
10809 if ( inst.reloc.exp.X_op == O_symbol
10810 && inst.reloc.exp.X_add_symbol != NULL
10811 && S_IS_DEFINED (inst.reloc.exp.X_add_symbol)
10812 && ! THUMB_IS_FUNC (inst.reloc.exp.X_add_symbol))
10813 inst.reloc.exp.X_add_symbol =
10814 find_real_start (inst.reloc.exp.X_add_symbol);
10821 set_it_insn_type_last ();
10822 inst.instruction |= inst.operands[0].reg << 3;
10823 /* ??? FIXME: Should add a hacky reloc here if reg is REG_PC. The reloc
10824 should cause the alignment to be checked once it is known. This is
10825 because BX PC only works if the instruction is word aligned. */
10833 set_it_insn_type_last ();
10834 Rm = inst.operands[0].reg;
10835 reject_bad_reg (Rm);
10836 inst.instruction |= Rm << 16;
10845 Rd = inst.operands[0].reg;
10846 Rm = inst.operands[1].reg;
10848 reject_bad_reg (Rd);
10849 reject_bad_reg (Rm);
10851 inst.instruction |= Rd << 8;
10852 inst.instruction |= Rm << 16;
10853 inst.instruction |= Rm;
10859 set_it_insn_type (OUTSIDE_IT_INSN);
10860 inst.instruction |= inst.operands[0].imm;
10866 set_it_insn_type (OUTSIDE_IT_INSN);
10868 && (inst.operands[1].present || inst.size_req == 4)
10869 && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6_notm))
10871 unsigned int imod = (inst.instruction & 0x0030) >> 4;
10872 inst.instruction = 0xf3af8000;
10873 inst.instruction |= imod << 9;
10874 inst.instruction |= inst.operands[0].imm << 5;
10875 if (inst.operands[1].present)
10876 inst.instruction |= 0x100 | inst.operands[1].imm;
10880 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1)
10881 && (inst.operands[0].imm & 4),
10882 _("selected processor does not support 'A' form "
10883 "of this instruction"));
10884 constraint (inst.operands[1].present || inst.size_req == 4,
10885 _("Thumb does not support the 2-argument "
10886 "form of this instruction"));
10887 inst.instruction |= inst.operands[0].imm;
10891 /* THUMB CPY instruction (argument parse). */
10896 if (inst.size_req == 4)
10898 inst.instruction = THUMB_OP32 (T_MNEM_mov);
10899 inst.instruction |= inst.operands[0].reg << 8;
10900 inst.instruction |= inst.operands[1].reg;
10904 inst.instruction |= (inst.operands[0].reg & 0x8) << 4;
10905 inst.instruction |= (inst.operands[0].reg & 0x7);
10906 inst.instruction |= inst.operands[1].reg << 3;
10913 set_it_insn_type (OUTSIDE_IT_INSN);
10914 constraint (inst.operands[0].reg > 7, BAD_HIREG);
10915 inst.instruction |= inst.operands[0].reg;
10916 inst.reloc.pc_rel = 1;
10917 inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH7;
10923 inst.instruction |= inst.operands[0].imm;
10929 unsigned Rd, Rn, Rm;
10931 Rd = inst.operands[0].reg;
10932 Rn = (inst.operands[1].present
10933 ? inst.operands[1].reg : Rd);
10934 Rm = inst.operands[2].reg;
10936 reject_bad_reg (Rd);
10937 reject_bad_reg (Rn);
10938 reject_bad_reg (Rm);
10940 inst.instruction |= Rd << 8;
10941 inst.instruction |= Rn << 16;
10942 inst.instruction |= Rm;
10948 if (unified_syntax && inst.size_req == 4)
10949 inst.instruction = THUMB_OP32 (inst.instruction);
10951 inst.instruction = THUMB_OP16 (inst.instruction);
10957 unsigned int cond = inst.operands[0].imm;
10959 set_it_insn_type (IT_INSN);
10960 now_it.mask = (inst.instruction & 0xf) | 0x10;
10962 now_it.warn_deprecated = FALSE;
10964 /* If the condition is a negative condition, invert the mask. */
10965 if ((cond & 0x1) == 0x0)
10967 unsigned int mask = inst.instruction & 0x000f;
10969 if ((mask & 0x7) == 0)
10971 /* No conversion needed. */
10972 now_it.block_length = 1;
10974 else if ((mask & 0x3) == 0)
10977 now_it.block_length = 2;
10979 else if ((mask & 0x1) == 0)
10982 now_it.block_length = 3;
10987 now_it.block_length = 4;
10990 inst.instruction &= 0xfff0;
10991 inst.instruction |= mask;
10994 inst.instruction |= cond << 4;
10997 /* Helper function used for both push/pop and ldm/stm. */
10999 encode_thumb2_ldmstm (int base, unsigned mask, bfd_boolean writeback)
11003 load = (inst.instruction & (1 << 20)) != 0;
11005 if (mask & (1 << 13))
11006 inst.error = _("SP not allowed in register list");
11008 if ((mask & (1 << base)) != 0
11010 inst.error = _("having the base register in the register list when "
11011 "using write back is UNPREDICTABLE");
11015 if (mask & (1 << 15))
11017 if (mask & (1 << 14))
11018 inst.error = _("LR and PC should not both be in register list");
11020 set_it_insn_type_last ();
11025 if (mask & (1 << 15))
11026 inst.error = _("PC not allowed in register list");
11029 if ((mask & (mask - 1)) == 0)
11031 /* Single register transfers implemented as str/ldr. */
11034 if (inst.instruction & (1 << 23))
11035 inst.instruction = 0x00000b04; /* ia! -> [base], #4 */
11037 inst.instruction = 0x00000d04; /* db! -> [base, #-4]! */
11041 if (inst.instruction & (1 << 23))
11042 inst.instruction = 0x00800000; /* ia -> [base] */
11044 inst.instruction = 0x00000c04; /* db -> [base, #-4] */
11047 inst.instruction |= 0xf8400000;
11049 inst.instruction |= 0x00100000;
11051 mask = ffs (mask) - 1;
11054 else if (writeback)
11055 inst.instruction |= WRITE_BACK;
11057 inst.instruction |= mask;
11058 inst.instruction |= base << 16;
11064 /* This really doesn't seem worth it. */
11065 constraint (inst.reloc.type != BFD_RELOC_UNUSED,
11066 _("expression too complex"));
11067 constraint (inst.operands[1].writeback,
11068 _("Thumb load/store multiple does not support {reglist}^"));
11070 if (unified_syntax)
11072 bfd_boolean narrow;
11076 /* See if we can use a 16-bit instruction. */
11077 if (inst.instruction < 0xffff /* not ldmdb/stmdb */
11078 && inst.size_req != 4
11079 && !(inst.operands[1].imm & ~0xff))
11081 mask = 1 << inst.operands[0].reg;
11083 if (inst.operands[0].reg <= 7)
11085 if (inst.instruction == T_MNEM_stmia
11086 ? inst.operands[0].writeback
11087 : (inst.operands[0].writeback
11088 == !(inst.operands[1].imm & mask)))
11090 if (inst.instruction == T_MNEM_stmia
11091 && (inst.operands[1].imm & mask)
11092 && (inst.operands[1].imm & (mask - 1)))
11093 as_warn (_("value stored for r%d is UNKNOWN"),
11094 inst.operands[0].reg);
11096 inst.instruction = THUMB_OP16 (inst.instruction);
11097 inst.instruction |= inst.operands[0].reg << 8;
11098 inst.instruction |= inst.operands[1].imm;
11101 else if ((inst.operands[1].imm & (inst.operands[1].imm-1)) == 0)
11103 /* This means 1 register in reg list one of 3 situations:
11104 1. Instruction is stmia, but without writeback.
11105 2. lmdia without writeback, but with Rn not in
11107 3. ldmia with writeback, but with Rn in reglist.
11108 Case 3 is UNPREDICTABLE behaviour, so we handle
11109 case 1 and 2 which can be converted into a 16-bit
11110 str or ldr. The SP cases are handled below. */
11111 unsigned long opcode;
11112 /* First, record an error for Case 3. */
11113 if (inst.operands[1].imm & mask
11114 && inst.operands[0].writeback)
11116 _("having the base register in the register list when "
11117 "using write back is UNPREDICTABLE");
11119 opcode = (inst.instruction == T_MNEM_stmia ? T_MNEM_str
11121 inst.instruction = THUMB_OP16 (opcode);
11122 inst.instruction |= inst.operands[0].reg << 3;
11123 inst.instruction |= (ffs (inst.operands[1].imm)-1);
11127 else if (inst.operands[0] .reg == REG_SP)
11129 if (inst.operands[0].writeback)
11132 THUMB_OP16 (inst.instruction == T_MNEM_stmia
11133 ? T_MNEM_push : T_MNEM_pop);
11134 inst.instruction |= inst.operands[1].imm;
11137 else if ((inst.operands[1].imm & (inst.operands[1].imm-1)) == 0)
11140 THUMB_OP16 (inst.instruction == T_MNEM_stmia
11141 ? T_MNEM_str_sp : T_MNEM_ldr_sp);
11142 inst.instruction |= ((ffs (inst.operands[1].imm)-1) << 8);
11150 if (inst.instruction < 0xffff)
11151 inst.instruction = THUMB_OP32 (inst.instruction);
11153 encode_thumb2_ldmstm (inst.operands[0].reg, inst.operands[1].imm,
11154 inst.operands[0].writeback);
11159 constraint (inst.operands[0].reg > 7
11160 || (inst.operands[1].imm & ~0xff), BAD_HIREG);
11161 constraint (inst.instruction != T_MNEM_ldmia
11162 && inst.instruction != T_MNEM_stmia,
11163 _("Thumb-2 instruction only valid in unified syntax"));
11164 if (inst.instruction == T_MNEM_stmia)
11166 if (!inst.operands[0].writeback)
11167 as_warn (_("this instruction will write back the base register"));
11168 if ((inst.operands[1].imm & (1 << inst.operands[0].reg))
11169 && (inst.operands[1].imm & ((1 << inst.operands[0].reg) - 1)))
11170 as_warn (_("value stored for r%d is UNKNOWN"),
11171 inst.operands[0].reg);
11175 if (!inst.operands[0].writeback
11176 && !(inst.operands[1].imm & (1 << inst.operands[0].reg)))
11177 as_warn (_("this instruction will write back the base register"));
11178 else if (inst.operands[0].writeback
11179 && (inst.operands[1].imm & (1 << inst.operands[0].reg)))
11180 as_warn (_("this instruction will not write back the base register"));
11183 inst.instruction = THUMB_OP16 (inst.instruction);
11184 inst.instruction |= inst.operands[0].reg << 8;
11185 inst.instruction |= inst.operands[1].imm;
11192 constraint (!inst.operands[1].isreg || !inst.operands[1].preind
11193 || inst.operands[1].postind || inst.operands[1].writeback
11194 || inst.operands[1].immisreg || inst.operands[1].shifted
11195 || inst.operands[1].negative,
11198 constraint ((inst.operands[1].reg == REG_PC), BAD_PC);
11200 inst.instruction |= inst.operands[0].reg << 12;
11201 inst.instruction |= inst.operands[1].reg << 16;
11202 inst.reloc.type = BFD_RELOC_ARM_T32_OFFSET_U8;
11208 if (!inst.operands[1].present)
11210 constraint (inst.operands[0].reg == REG_LR,
11211 _("r14 not allowed as first register "
11212 "when second register is omitted"));
11213 inst.operands[1].reg = inst.operands[0].reg + 1;
11215 constraint (inst.operands[0].reg == inst.operands[1].reg,
11218 inst.instruction |= inst.operands[0].reg << 12;
11219 inst.instruction |= inst.operands[1].reg << 8;
11220 inst.instruction |= inst.operands[2].reg << 16;
11226 unsigned long opcode;
11229 if (inst.operands[0].isreg
11230 && !inst.operands[0].preind
11231 && inst.operands[0].reg == REG_PC)
11232 set_it_insn_type_last ();
11234 opcode = inst.instruction;
11235 if (unified_syntax)
11237 if (!inst.operands[1].isreg)
11239 if (opcode <= 0xffff)
11240 inst.instruction = THUMB_OP32 (opcode);
11241 if (move_or_literal_pool (0, CONST_THUMB, /*mode_3=*/FALSE))
11244 if (inst.operands[1].isreg
11245 && !inst.operands[1].writeback
11246 && !inst.operands[1].shifted && !inst.operands[1].postind
11247 && !inst.operands[1].negative && inst.operands[0].reg <= 7
11248 && opcode <= 0xffff
11249 && inst.size_req != 4)
11251 /* Insn may have a 16-bit form. */
11252 Rn = inst.operands[1].reg;
11253 if (inst.operands[1].immisreg)
11255 inst.instruction = THUMB_OP16 (opcode);
11257 if (Rn <= 7 && inst.operands[1].imm <= 7)
11259 else if (opcode != T_MNEM_ldr && opcode != T_MNEM_str)
11260 reject_bad_reg (inst.operands[1].imm);
11262 else if ((Rn <= 7 && opcode != T_MNEM_ldrsh
11263 && opcode != T_MNEM_ldrsb)
11264 || ((Rn == REG_PC || Rn == REG_SP) && opcode == T_MNEM_ldr)
11265 || (Rn == REG_SP && opcode == T_MNEM_str))
11272 if (inst.reloc.pc_rel)
11273 opcode = T_MNEM_ldr_pc2;
11275 opcode = T_MNEM_ldr_pc;
11279 if (opcode == T_MNEM_ldr)
11280 opcode = T_MNEM_ldr_sp;
11282 opcode = T_MNEM_str_sp;
11284 inst.instruction = inst.operands[0].reg << 8;
11288 inst.instruction = inst.operands[0].reg;
11289 inst.instruction |= inst.operands[1].reg << 3;
11291 inst.instruction |= THUMB_OP16 (opcode);
11292 if (inst.size_req == 2)
11293 inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
11295 inst.relax = opcode;
11299 /* Definitely a 32-bit variant. */
11301 /* Warning for Erratum 752419. */
11302 if (opcode == T_MNEM_ldr
11303 && inst.operands[0].reg == REG_SP
11304 && inst.operands[1].writeback == 1
11305 && !inst.operands[1].immisreg)
11307 if (no_cpu_selected ()
11308 || (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7)
11309 && !ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7a)
11310 && !ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7r)))
11311 as_warn (_("This instruction may be unpredictable "
11312 "if executed on M-profile cores "
11313 "with interrupts enabled."));
11316 /* Do some validations regarding addressing modes. */
11317 if (inst.operands[1].immisreg)
11318 reject_bad_reg (inst.operands[1].imm);
11320 constraint (inst.operands[1].writeback == 1
11321 && inst.operands[0].reg == inst.operands[1].reg,
11324 inst.instruction = THUMB_OP32 (opcode);
11325 inst.instruction |= inst.operands[0].reg << 12;
11326 encode_thumb32_addr_mode (1, /*is_t=*/FALSE, /*is_d=*/FALSE);
11327 check_ldr_r15_aligned ();
11331 constraint (inst.operands[0].reg > 7, BAD_HIREG);
11333 if (inst.instruction == T_MNEM_ldrsh || inst.instruction == T_MNEM_ldrsb)
11335 /* Only [Rn,Rm] is acceptable. */
11336 constraint (inst.operands[1].reg > 7 || inst.operands[1].imm > 7, BAD_HIREG);
11337 constraint (!inst.operands[1].isreg || !inst.operands[1].immisreg
11338 || inst.operands[1].postind || inst.operands[1].shifted
11339 || inst.operands[1].negative,
11340 _("Thumb does not support this addressing mode"));
11341 inst.instruction = THUMB_OP16 (inst.instruction);
11345 inst.instruction = THUMB_OP16 (inst.instruction);
11346 if (!inst.operands[1].isreg)
11347 if (move_or_literal_pool (0, CONST_THUMB, /*mode_3=*/FALSE))
11350 constraint (!inst.operands[1].preind
11351 || inst.operands[1].shifted
11352 || inst.operands[1].writeback,
11353 _("Thumb does not support this addressing mode"));
11354 if (inst.operands[1].reg == REG_PC || inst.operands[1].reg == REG_SP)
11356 constraint (inst.instruction & 0x0600,
11357 _("byte or halfword not valid for base register"));
11358 constraint (inst.operands[1].reg == REG_PC
11359 && !(inst.instruction & THUMB_LOAD_BIT),
11360 _("r15 based store not allowed"));
11361 constraint (inst.operands[1].immisreg,
11362 _("invalid base register for register offset"));
11364 if (inst.operands[1].reg == REG_PC)
11365 inst.instruction = T_OPCODE_LDR_PC;
11366 else if (inst.instruction & THUMB_LOAD_BIT)
11367 inst.instruction = T_OPCODE_LDR_SP;
11369 inst.instruction = T_OPCODE_STR_SP;
11371 inst.instruction |= inst.operands[0].reg << 8;
11372 inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
11376 constraint (inst.operands[1].reg > 7, BAD_HIREG);
11377 if (!inst.operands[1].immisreg)
11379 /* Immediate offset. */
11380 inst.instruction |= inst.operands[0].reg;
11381 inst.instruction |= inst.operands[1].reg << 3;
11382 inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
11386 /* Register offset. */
11387 constraint (inst.operands[1].imm > 7, BAD_HIREG);
11388 constraint (inst.operands[1].negative,
11389 _("Thumb does not support this addressing mode"));
11392 switch (inst.instruction)
11394 case T_OPCODE_STR_IW: inst.instruction = T_OPCODE_STR_RW; break;
11395 case T_OPCODE_STR_IH: inst.instruction = T_OPCODE_STR_RH; break;
11396 case T_OPCODE_STR_IB: inst.instruction = T_OPCODE_STR_RB; break;
11397 case T_OPCODE_LDR_IW: inst.instruction = T_OPCODE_LDR_RW; break;
11398 case T_OPCODE_LDR_IH: inst.instruction = T_OPCODE_LDR_RH; break;
11399 case T_OPCODE_LDR_IB: inst.instruction = T_OPCODE_LDR_RB; break;
11400 case 0x5600 /* ldrsb */:
11401 case 0x5e00 /* ldrsh */: break;
11405 inst.instruction |= inst.operands[0].reg;
11406 inst.instruction |= inst.operands[1].reg << 3;
11407 inst.instruction |= inst.operands[1].imm << 6;
11413 if (!inst.operands[1].present)
11415 inst.operands[1].reg = inst.operands[0].reg + 1;
11416 constraint (inst.operands[0].reg == REG_LR,
11417 _("r14 not allowed here"));
11418 constraint (inst.operands[0].reg == REG_R12,
11419 _("r12 not allowed here"));
11422 if (inst.operands[2].writeback
11423 && (inst.operands[0].reg == inst.operands[2].reg
11424 || inst.operands[1].reg == inst.operands[2].reg))
11425 as_warn (_("base register written back, and overlaps "
11426 "one of transfer registers"));
11428 inst.instruction |= inst.operands[0].reg << 12;
11429 inst.instruction |= inst.operands[1].reg << 8;
11430 encode_thumb32_addr_mode (2, /*is_t=*/FALSE, /*is_d=*/TRUE);
11436 inst.instruction |= inst.operands[0].reg << 12;
11437 encode_thumb32_addr_mode (1, /*is_t=*/TRUE, /*is_d=*/FALSE);
11443 unsigned Rd, Rn, Rm, Ra;
11445 Rd = inst.operands[0].reg;
11446 Rn = inst.operands[1].reg;
11447 Rm = inst.operands[2].reg;
11448 Ra = inst.operands[3].reg;
11450 reject_bad_reg (Rd);
11451 reject_bad_reg (Rn);
11452 reject_bad_reg (Rm);
11453 reject_bad_reg (Ra);
11455 inst.instruction |= Rd << 8;
11456 inst.instruction |= Rn << 16;
11457 inst.instruction |= Rm;
11458 inst.instruction |= Ra << 12;
11464 unsigned RdLo, RdHi, Rn, Rm;
11466 RdLo = inst.operands[0].reg;
11467 RdHi = inst.operands[1].reg;
11468 Rn = inst.operands[2].reg;
11469 Rm = inst.operands[3].reg;
11471 reject_bad_reg (RdLo);
11472 reject_bad_reg (RdHi);
11473 reject_bad_reg (Rn);
11474 reject_bad_reg (Rm);
11476 inst.instruction |= RdLo << 12;
11477 inst.instruction |= RdHi << 8;
11478 inst.instruction |= Rn << 16;
11479 inst.instruction |= Rm;
11483 do_t_mov_cmp (void)
11487 Rn = inst.operands[0].reg;
11488 Rm = inst.operands[1].reg;
11491 set_it_insn_type_last ();
11493 if (unified_syntax)
11495 int r0off = (inst.instruction == T_MNEM_mov
11496 || inst.instruction == T_MNEM_movs) ? 8 : 16;
11497 unsigned long opcode;
11498 bfd_boolean narrow;
11499 bfd_boolean low_regs;
11501 low_regs = (Rn <= 7 && Rm <= 7);
11502 opcode = inst.instruction;
11503 if (in_it_block ())
11504 narrow = opcode != T_MNEM_movs;
11506 narrow = opcode != T_MNEM_movs || low_regs;
11507 if (inst.size_req == 4
11508 || inst.operands[1].shifted)
11511 /* MOVS PC, LR is encoded as SUBS PC, LR, #0. */
11512 if (opcode == T_MNEM_movs && inst.operands[1].isreg
11513 && !inst.operands[1].shifted
11517 inst.instruction = T2_SUBS_PC_LR;
11521 if (opcode == T_MNEM_cmp)
11523 constraint (Rn == REG_PC, BAD_PC);
11526 /* In the Thumb-2 ISA, use of R13 as Rm is deprecated,
11528 warn_deprecated_sp (Rm);
11529 /* R15 was documented as a valid choice for Rm in ARMv6,
11530 but as UNPREDICTABLE in ARMv7. ARM's proprietary
11531 tools reject R15, so we do too. */
11532 constraint (Rm == REG_PC, BAD_PC);
11535 reject_bad_reg (Rm);
11537 else if (opcode == T_MNEM_mov
11538 || opcode == T_MNEM_movs)
11540 if (inst.operands[1].isreg)
11542 if (opcode == T_MNEM_movs)
11544 reject_bad_reg (Rn);
11545 reject_bad_reg (Rm);
11549 /* This is mov.n. */
11550 if ((Rn == REG_SP || Rn == REG_PC)
11551 && (Rm == REG_SP || Rm == REG_PC))
11553 as_warn (_("Use of r%u as a source register is "
11554 "deprecated when r%u is the destination "
11555 "register."), Rm, Rn);
11560 /* This is mov.w. */
11561 constraint (Rn == REG_PC, BAD_PC);
11562 constraint (Rm == REG_PC, BAD_PC);
11563 constraint (Rn == REG_SP && Rm == REG_SP, BAD_SP);
11567 reject_bad_reg (Rn);
11570 if (!inst.operands[1].isreg)
11572 /* Immediate operand. */
11573 if (!in_it_block () && opcode == T_MNEM_mov)
11575 if (low_regs && narrow)
11577 inst.instruction = THUMB_OP16 (opcode);
11578 inst.instruction |= Rn << 8;
11579 if (inst.size_req == 2)
11580 inst.reloc.type = BFD_RELOC_ARM_THUMB_IMM;
11582 inst.relax = opcode;
11586 inst.instruction = THUMB_OP32 (inst.instruction);
11587 inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
11588 inst.instruction |= Rn << r0off;
11589 inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
11592 else if (inst.operands[1].shifted && inst.operands[1].immisreg
11593 && (inst.instruction == T_MNEM_mov
11594 || inst.instruction == T_MNEM_movs))
11596 /* Register shifts are encoded as separate shift instructions. */
11597 bfd_boolean flags = (inst.instruction == T_MNEM_movs);
11599 if (in_it_block ())
11604 if (inst.size_req == 4)
11607 if (!low_regs || inst.operands[1].imm > 7)
11613 switch (inst.operands[1].shift_kind)
11616 opcode = narrow ? T_OPCODE_LSL_R : THUMB_OP32 (T_MNEM_lsl);
11619 opcode = narrow ? T_OPCODE_ASR_R : THUMB_OP32 (T_MNEM_asr);
11622 opcode = narrow ? T_OPCODE_LSR_R : THUMB_OP32 (T_MNEM_lsr);
11625 opcode = narrow ? T_OPCODE_ROR_R : THUMB_OP32 (T_MNEM_ror);
11631 inst.instruction = opcode;
11634 inst.instruction |= Rn;
11635 inst.instruction |= inst.operands[1].imm << 3;
11640 inst.instruction |= CONDS_BIT;
11642 inst.instruction |= Rn << 8;
11643 inst.instruction |= Rm << 16;
11644 inst.instruction |= inst.operands[1].imm;
11649 /* Some mov with immediate shift have narrow variants.
11650 Register shifts are handled above. */
11651 if (low_regs && inst.operands[1].shifted
11652 && (inst.instruction == T_MNEM_mov
11653 || inst.instruction == T_MNEM_movs))
11655 if (in_it_block ())
11656 narrow = (inst.instruction == T_MNEM_mov);
11658 narrow = (inst.instruction == T_MNEM_movs);
11663 switch (inst.operands[1].shift_kind)
11665 case SHIFT_LSL: inst.instruction = T_OPCODE_LSL_I; break;
11666 case SHIFT_LSR: inst.instruction = T_OPCODE_LSR_I; break;
11667 case SHIFT_ASR: inst.instruction = T_OPCODE_ASR_I; break;
11668 default: narrow = FALSE; break;
11674 inst.instruction |= Rn;
11675 inst.instruction |= Rm << 3;
11676 inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
11680 inst.instruction = THUMB_OP32 (inst.instruction);
11681 inst.instruction |= Rn << r0off;
11682 encode_thumb32_shifted_operand (1);
11686 switch (inst.instruction)
11689 /* In v4t or v5t a move of two lowregs produces unpredictable
11690 results. Don't allow this. */
11693 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6),
11694 "MOV Rd, Rs with two low registers is not "
11695 "permitted on this architecture");
11696 ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
11700 inst.instruction = T_OPCODE_MOV_HR;
11701 inst.instruction |= (Rn & 0x8) << 4;
11702 inst.instruction |= (Rn & 0x7);
11703 inst.instruction |= Rm << 3;
11707 /* We know we have low registers at this point.
11708 Generate LSLS Rd, Rs, #0. */
11709 inst.instruction = T_OPCODE_LSL_I;
11710 inst.instruction |= Rn;
11711 inst.instruction |= Rm << 3;
11717 inst.instruction = T_OPCODE_CMP_LR;
11718 inst.instruction |= Rn;
11719 inst.instruction |= Rm << 3;
11723 inst.instruction = T_OPCODE_CMP_HR;
11724 inst.instruction |= (Rn & 0x8) << 4;
11725 inst.instruction |= (Rn & 0x7);
11726 inst.instruction |= Rm << 3;
11733 inst.instruction = THUMB_OP16 (inst.instruction);
11735 /* PR 10443: Do not silently ignore shifted operands. */
11736 constraint (inst.operands[1].shifted,
11737 _("shifts in CMP/MOV instructions are only supported in unified syntax"));
11739 if (inst.operands[1].isreg)
11741 if (Rn < 8 && Rm < 8)
11743 /* A move of two lowregs is encoded as ADD Rd, Rs, #0
11744 since a MOV instruction produces unpredictable results. */
11745 if (inst.instruction == T_OPCODE_MOV_I8)
11746 inst.instruction = T_OPCODE_ADD_I3;
11748 inst.instruction = T_OPCODE_CMP_LR;
11750 inst.instruction |= Rn;
11751 inst.instruction |= Rm << 3;
11755 if (inst.instruction == T_OPCODE_MOV_I8)
11756 inst.instruction = T_OPCODE_MOV_HR;
11758 inst.instruction = T_OPCODE_CMP_HR;
11764 constraint (Rn > 7,
11765 _("only lo regs allowed with immediate"));
11766 inst.instruction |= Rn << 8;
11767 inst.reloc.type = BFD_RELOC_ARM_THUMB_IMM;
11778 top = (inst.instruction & 0x00800000) != 0;
11779 if (inst.reloc.type == BFD_RELOC_ARM_MOVW)
11781 constraint (top, _(":lower16: not allowed this instruction"));
11782 inst.reloc.type = BFD_RELOC_ARM_THUMB_MOVW;
11784 else if (inst.reloc.type == BFD_RELOC_ARM_MOVT)
11786 constraint (!top, _(":upper16: not allowed this instruction"));
11787 inst.reloc.type = BFD_RELOC_ARM_THUMB_MOVT;
11790 Rd = inst.operands[0].reg;
11791 reject_bad_reg (Rd);
11793 inst.instruction |= Rd << 8;
11794 if (inst.reloc.type == BFD_RELOC_UNUSED)
11796 imm = inst.reloc.exp.X_add_number;
11797 inst.instruction |= (imm & 0xf000) << 4;
11798 inst.instruction |= (imm & 0x0800) << 15;
11799 inst.instruction |= (imm & 0x0700) << 4;
11800 inst.instruction |= (imm & 0x00ff);
11805 do_t_mvn_tst (void)
11809 Rn = inst.operands[0].reg;
11810 Rm = inst.operands[1].reg;
11812 if (inst.instruction == T_MNEM_cmp
11813 || inst.instruction == T_MNEM_cmn)
11814 constraint (Rn == REG_PC, BAD_PC);
11816 reject_bad_reg (Rn);
11817 reject_bad_reg (Rm);
11819 if (unified_syntax)
11821 int r0off = (inst.instruction == T_MNEM_mvn
11822 || inst.instruction == T_MNEM_mvns) ? 8 : 16;
11823 bfd_boolean narrow;
11825 if (inst.size_req == 4
11826 || inst.instruction > 0xffff
11827 || inst.operands[1].shifted
11828 || Rn > 7 || Rm > 7)
11830 else if (inst.instruction == T_MNEM_cmn
11831 || inst.instruction == T_MNEM_tst)
11833 else if (THUMB_SETS_FLAGS (inst.instruction))
11834 narrow = !in_it_block ();
11836 narrow = in_it_block ();
11838 if (!inst.operands[1].isreg)
11840 /* For an immediate, we always generate a 32-bit opcode;
11841 section relaxation will shrink it later if possible. */
11842 if (inst.instruction < 0xffff)
11843 inst.instruction = THUMB_OP32 (inst.instruction);
11844 inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
11845 inst.instruction |= Rn << r0off;
11846 inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
11850 /* See if we can do this with a 16-bit instruction. */
11853 inst.instruction = THUMB_OP16 (inst.instruction);
11854 inst.instruction |= Rn;
11855 inst.instruction |= Rm << 3;
11859 constraint (inst.operands[1].shifted
11860 && inst.operands[1].immisreg,
11861 _("shift must be constant"));
11862 if (inst.instruction < 0xffff)
11863 inst.instruction = THUMB_OP32 (inst.instruction);
11864 inst.instruction |= Rn << r0off;
11865 encode_thumb32_shifted_operand (1);
11871 constraint (inst.instruction > 0xffff
11872 || inst.instruction == T_MNEM_mvns, BAD_THUMB32);
11873 constraint (!inst.operands[1].isreg || inst.operands[1].shifted,
11874 _("unshifted register required"));
11875 constraint (Rn > 7 || Rm > 7,
11878 inst.instruction = THUMB_OP16 (inst.instruction);
11879 inst.instruction |= Rn;
11880 inst.instruction |= Rm << 3;
11889 if (do_vfp_nsyn_mrs () == SUCCESS)
11892 Rd = inst.operands[0].reg;
11893 reject_bad_reg (Rd);
11894 inst.instruction |= Rd << 8;
11896 if (inst.operands[1].isreg)
11898 unsigned br = inst.operands[1].reg;
11899 if (((br & 0x200) == 0) && ((br & 0xf000) != 0xf000))
11900 as_bad (_("bad register for mrs"));
11902 inst.instruction |= br & (0xf << 16);
11903 inst.instruction |= (br & 0x300) >> 4;
11904 inst.instruction |= (br & SPSR_BIT) >> 2;
11908 int flags = inst.operands[1].imm & (PSR_c|PSR_x|PSR_s|PSR_f|SPSR_BIT);
11910 if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_m))
11912 /* PR gas/12698: The constraint is only applied for m_profile.
11913 If the user has specified -march=all, we want to ignore it as
11914 we are building for any CPU type, including non-m variants. */
11915 bfd_boolean m_profile = selected_cpu.core != arm_arch_any.core;
11916 constraint ((flags != 0) && m_profile, _("selected processor does "
11917 "not support requested special purpose register"));
11920 /* mrs only accepts APSR/CPSR/SPSR/CPSR_all/SPSR_all (for non-M profile
11922 constraint ((flags & ~SPSR_BIT) != (PSR_c|PSR_f),
11923 _("'APSR', 'CPSR' or 'SPSR' expected"));
11925 inst.instruction |= (flags & SPSR_BIT) >> 2;
11926 inst.instruction |= inst.operands[1].imm & 0xff;
11927 inst.instruction |= 0xf0000;
11937 if (do_vfp_nsyn_msr () == SUCCESS)
11940 constraint (!inst.operands[1].isreg,
11941 _("Thumb encoding does not support an immediate here"));
11943 if (inst.operands[0].isreg)
11944 flags = (int)(inst.operands[0].reg);
11946 flags = inst.operands[0].imm;
11948 if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_m))
11950 int bits = inst.operands[0].imm & (PSR_c|PSR_x|PSR_s|PSR_f|SPSR_BIT);
11952 /* PR gas/12698: The constraint is only applied for m_profile.
11953 If the user has specified -march=all, we want to ignore it as
11954 we are building for any CPU type, including non-m variants. */
11955 bfd_boolean m_profile = selected_cpu.core != arm_arch_any.core;
11956 constraint (((ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6_dsp)
11957 && (bits & ~(PSR_s | PSR_f)) != 0)
11958 || (!ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6_dsp)
11959 && bits != PSR_f)) && m_profile,
11960 _("selected processor does not support requested special "
11961 "purpose register"));
11964 constraint ((flags & 0xff) != 0, _("selected processor does not support "
11965 "requested special purpose register"));
11967 Rn = inst.operands[1].reg;
11968 reject_bad_reg (Rn);
11970 inst.instruction |= (flags & SPSR_BIT) >> 2;
11971 inst.instruction |= (flags & 0xf0000) >> 8;
11972 inst.instruction |= (flags & 0x300) >> 4;
11973 inst.instruction |= (flags & 0xff);
11974 inst.instruction |= Rn << 16;
11980 bfd_boolean narrow;
11981 unsigned Rd, Rn, Rm;
11983 if (!inst.operands[2].present)
11984 inst.operands[2].reg = inst.operands[0].reg;
11986 Rd = inst.operands[0].reg;
11987 Rn = inst.operands[1].reg;
11988 Rm = inst.operands[2].reg;
11990 if (unified_syntax)
11992 if (inst.size_req == 4
11998 else if (inst.instruction == T_MNEM_muls)
11999 narrow = !in_it_block ();
12001 narrow = in_it_block ();
12005 constraint (inst.instruction == T_MNEM_muls, BAD_THUMB32);
12006 constraint (Rn > 7 || Rm > 7,
12013 /* 16-bit MULS/Conditional MUL. */
12014 inst.instruction = THUMB_OP16 (inst.instruction);
12015 inst.instruction |= Rd;
12018 inst.instruction |= Rm << 3;
12020 inst.instruction |= Rn << 3;
12022 constraint (1, _("dest must overlap one source register"));
12026 constraint (inst.instruction != T_MNEM_mul,
12027 _("Thumb-2 MUL must not set flags"));
12029 inst.instruction = THUMB_OP32 (inst.instruction);
12030 inst.instruction |= Rd << 8;
12031 inst.instruction |= Rn << 16;
12032 inst.instruction |= Rm << 0;
12034 reject_bad_reg (Rd);
12035 reject_bad_reg (Rn);
12036 reject_bad_reg (Rm);
12043 unsigned RdLo, RdHi, Rn, Rm;
12045 RdLo = inst.operands[0].reg;
12046 RdHi = inst.operands[1].reg;
12047 Rn = inst.operands[2].reg;
12048 Rm = inst.operands[3].reg;
12050 reject_bad_reg (RdLo);
12051 reject_bad_reg (RdHi);
12052 reject_bad_reg (Rn);
12053 reject_bad_reg (Rm);
12055 inst.instruction |= RdLo << 12;
12056 inst.instruction |= RdHi << 8;
12057 inst.instruction |= Rn << 16;
12058 inst.instruction |= Rm;
12061 as_tsktsk (_("rdhi and rdlo must be different"));
12067 set_it_insn_type (NEUTRAL_IT_INSN);
12069 if (unified_syntax)
12071 if (inst.size_req == 4 || inst.operands[0].imm > 15)
12073 inst.instruction = THUMB_OP32 (inst.instruction);
12074 inst.instruction |= inst.operands[0].imm;
12078 /* PR9722: Check for Thumb2 availability before
12079 generating a thumb2 nop instruction. */
12080 if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v6t2))
12082 inst.instruction = THUMB_OP16 (inst.instruction);
12083 inst.instruction |= inst.operands[0].imm << 4;
12086 inst.instruction = 0x46c0;
12091 constraint (inst.operands[0].present,
12092 _("Thumb does not support NOP with hints"));
12093 inst.instruction = 0x46c0;
12100 if (unified_syntax)
12102 bfd_boolean narrow;
12104 if (THUMB_SETS_FLAGS (inst.instruction))
12105 narrow = !in_it_block ();
12107 narrow = in_it_block ();
12108 if (inst.operands[0].reg > 7 || inst.operands[1].reg > 7)
12110 if (inst.size_req == 4)
12115 inst.instruction = THUMB_OP32 (inst.instruction);
12116 inst.instruction |= inst.operands[0].reg << 8;
12117 inst.instruction |= inst.operands[1].reg << 16;
12121 inst.instruction = THUMB_OP16 (inst.instruction);
12122 inst.instruction |= inst.operands[0].reg;
12123 inst.instruction |= inst.operands[1].reg << 3;
12128 constraint (inst.operands[0].reg > 7 || inst.operands[1].reg > 7,
12130 constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
12132 inst.instruction = THUMB_OP16 (inst.instruction);
12133 inst.instruction |= inst.operands[0].reg;
12134 inst.instruction |= inst.operands[1].reg << 3;
12143 Rd = inst.operands[0].reg;
12144 Rn = inst.operands[1].present ? inst.operands[1].reg : Rd;
12146 reject_bad_reg (Rd);
12147 /* Rn == REG_SP is unpredictable; Rn == REG_PC is MVN. */
12148 reject_bad_reg (Rn);
12150 inst.instruction |= Rd << 8;
12151 inst.instruction |= Rn << 16;
12153 if (!inst.operands[2].isreg)
12155 inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
12156 inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
12162 Rm = inst.operands[2].reg;
12163 reject_bad_reg (Rm);
12165 constraint (inst.operands[2].shifted
12166 && inst.operands[2].immisreg,
12167 _("shift must be constant"));
12168 encode_thumb32_shifted_operand (2);
12175 unsigned Rd, Rn, Rm;
12177 Rd = inst.operands[0].reg;
12178 Rn = inst.operands[1].reg;
12179 Rm = inst.operands[2].reg;
12181 reject_bad_reg (Rd);
12182 reject_bad_reg (Rn);
12183 reject_bad_reg (Rm);
12185 inst.instruction |= Rd << 8;
12186 inst.instruction |= Rn << 16;
12187 inst.instruction |= Rm;
12188 if (inst.operands[3].present)
12190 unsigned int val = inst.reloc.exp.X_add_number;
12191 constraint (inst.reloc.exp.X_op != O_constant,
12192 _("expression too complex"));
12193 inst.instruction |= (val & 0x1c) << 10;
12194 inst.instruction |= (val & 0x03) << 6;
12201 if (!inst.operands[3].present)
12205 inst.instruction &= ~0x00000020;
12207 /* PR 10168. Swap the Rm and Rn registers. */
12208 Rtmp = inst.operands[1].reg;
12209 inst.operands[1].reg = inst.operands[2].reg;
12210 inst.operands[2].reg = Rtmp;
12218 if (inst.operands[0].immisreg)
12219 reject_bad_reg (inst.operands[0].imm);
12221 encode_thumb32_addr_mode (0, /*is_t=*/FALSE, /*is_d=*/FALSE);
12225 do_t_push_pop (void)
12229 constraint (inst.operands[0].writeback,
12230 _("push/pop do not support {reglist}^"));
12231 constraint (inst.reloc.type != BFD_RELOC_UNUSED,
12232 _("expression too complex"));
12234 mask = inst.operands[0].imm;
12235 if (inst.size_req != 4 && (mask & ~0xff) == 0)
12236 inst.instruction = THUMB_OP16 (inst.instruction) | mask;
12237 else if (inst.size_req != 4
12238 && (mask & ~0xff) == (1 << (inst.instruction == T_MNEM_push
12239 ? REG_LR : REG_PC)))
12241 inst.instruction = THUMB_OP16 (inst.instruction);
12242 inst.instruction |= THUMB_PP_PC_LR;
12243 inst.instruction |= mask & 0xff;
12245 else if (unified_syntax)
12247 inst.instruction = THUMB_OP32 (inst.instruction);
12248 encode_thumb2_ldmstm (13, mask, TRUE);
12252 inst.error = _("invalid register list to push/pop instruction");
12262 Rd = inst.operands[0].reg;
12263 Rm = inst.operands[1].reg;
12265 reject_bad_reg (Rd);
12266 reject_bad_reg (Rm);
12268 inst.instruction |= Rd << 8;
12269 inst.instruction |= Rm << 16;
12270 inst.instruction |= Rm;
12278 Rd = inst.operands[0].reg;
12279 Rm = inst.operands[1].reg;
12281 reject_bad_reg (Rd);
12282 reject_bad_reg (Rm);
12284 if (Rd <= 7 && Rm <= 7
12285 && inst.size_req != 4)
12287 inst.instruction = THUMB_OP16 (inst.instruction);
12288 inst.instruction |= Rd;
12289 inst.instruction |= Rm << 3;
12291 else if (unified_syntax)
12293 inst.instruction = THUMB_OP32 (inst.instruction);
12294 inst.instruction |= Rd << 8;
12295 inst.instruction |= Rm << 16;
12296 inst.instruction |= Rm;
12299 inst.error = BAD_HIREG;
12307 Rd = inst.operands[0].reg;
12308 Rm = inst.operands[1].reg;
12310 reject_bad_reg (Rd);
12311 reject_bad_reg (Rm);
12313 inst.instruction |= Rd << 8;
12314 inst.instruction |= Rm;
12322 Rd = inst.operands[0].reg;
12323 Rs = (inst.operands[1].present
12324 ? inst.operands[1].reg /* Rd, Rs, foo */
12325 : inst.operands[0].reg); /* Rd, foo -> Rd, Rd, foo */
12327 reject_bad_reg (Rd);
12328 reject_bad_reg (Rs);
12329 if (inst.operands[2].isreg)
12330 reject_bad_reg (inst.operands[2].reg);
12332 inst.instruction |= Rd << 8;
12333 inst.instruction |= Rs << 16;
12334 if (!inst.operands[2].isreg)
12336 bfd_boolean narrow;
12338 if ((inst.instruction & 0x00100000) != 0)
12339 narrow = !in_it_block ();
12341 narrow = in_it_block ();
12343 if (Rd > 7 || Rs > 7)
12346 if (inst.size_req == 4 || !unified_syntax)
12349 if (inst.reloc.exp.X_op != O_constant
12350 || inst.reloc.exp.X_add_number != 0)
12353 /* Turn rsb #0 into 16-bit neg. We should probably do this via
12354 relaxation, but it doesn't seem worth the hassle. */
12357 inst.reloc.type = BFD_RELOC_UNUSED;
12358 inst.instruction = THUMB_OP16 (T_MNEM_negs);
12359 inst.instruction |= Rs << 3;
12360 inst.instruction |= Rd;
12364 inst.instruction = (inst.instruction & 0xe1ffffff) | 0x10000000;
12365 inst.reloc.type = BFD_RELOC_ARM_T32_IMMEDIATE;
12369 encode_thumb32_shifted_operand (2);
12375 if (warn_on_deprecated
12376 && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
12377 as_warn (_("setend use is deprecated for ARMv8"));
12379 set_it_insn_type (OUTSIDE_IT_INSN);
12380 if (inst.operands[0].imm)
12381 inst.instruction |= 0x8;
12387 if (!inst.operands[1].present)
12388 inst.operands[1].reg = inst.operands[0].reg;
12390 if (unified_syntax)
12392 bfd_boolean narrow;
12395 switch (inst.instruction)
12398 case T_MNEM_asrs: shift_kind = SHIFT_ASR; break;
12400 case T_MNEM_lsls: shift_kind = SHIFT_LSL; break;
12402 case T_MNEM_lsrs: shift_kind = SHIFT_LSR; break;
12404 case T_MNEM_rors: shift_kind = SHIFT_ROR; break;
12408 if (THUMB_SETS_FLAGS (inst.instruction))
12409 narrow = !in_it_block ();
12411 narrow = in_it_block ();
12412 if (inst.operands[0].reg > 7 || inst.operands[1].reg > 7)
12414 if (!inst.operands[2].isreg && shift_kind == SHIFT_ROR)
12416 if (inst.operands[2].isreg
12417 && (inst.operands[1].reg != inst.operands[0].reg
12418 || inst.operands[2].reg > 7))
12420 if (inst.size_req == 4)
12423 reject_bad_reg (inst.operands[0].reg);
12424 reject_bad_reg (inst.operands[1].reg);
12428 if (inst.operands[2].isreg)
12430 reject_bad_reg (inst.operands[2].reg);
12431 inst.instruction = THUMB_OP32 (inst.instruction);
12432 inst.instruction |= inst.operands[0].reg << 8;
12433 inst.instruction |= inst.operands[1].reg << 16;
12434 inst.instruction |= inst.operands[2].reg;
12436 /* PR 12854: Error on extraneous shifts. */
12437 constraint (inst.operands[2].shifted,
12438 _("extraneous shift as part of operand to shift insn"));
12442 inst.operands[1].shifted = 1;
12443 inst.operands[1].shift_kind = shift_kind;
12444 inst.instruction = THUMB_OP32 (THUMB_SETS_FLAGS (inst.instruction)
12445 ? T_MNEM_movs : T_MNEM_mov);
12446 inst.instruction |= inst.operands[0].reg << 8;
12447 encode_thumb32_shifted_operand (1);
12448 /* Prevent the incorrect generation of an ARM_IMMEDIATE fixup. */
12449 inst.reloc.type = BFD_RELOC_UNUSED;
12454 if (inst.operands[2].isreg)
12456 switch (shift_kind)
12458 case SHIFT_ASR: inst.instruction = T_OPCODE_ASR_R; break;
12459 case SHIFT_LSL: inst.instruction = T_OPCODE_LSL_R; break;
12460 case SHIFT_LSR: inst.instruction = T_OPCODE_LSR_R; break;
12461 case SHIFT_ROR: inst.instruction = T_OPCODE_ROR_R; break;
12465 inst.instruction |= inst.operands[0].reg;
12466 inst.instruction |= inst.operands[2].reg << 3;
12468 /* PR 12854: Error on extraneous shifts. */
12469 constraint (inst.operands[2].shifted,
12470 _("extraneous shift as part of operand to shift insn"));
12474 switch (shift_kind)
12476 case SHIFT_ASR: inst.instruction = T_OPCODE_ASR_I; break;
12477 case SHIFT_LSL: inst.instruction = T_OPCODE_LSL_I; break;
12478 case SHIFT_LSR: inst.instruction = T_OPCODE_LSR_I; break;
12481 inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
12482 inst.instruction |= inst.operands[0].reg;
12483 inst.instruction |= inst.operands[1].reg << 3;
12489 constraint (inst.operands[0].reg > 7
12490 || inst.operands[1].reg > 7, BAD_HIREG);
12491 constraint (THUMB_SETS_FLAGS (inst.instruction), BAD_THUMB32);
12493 if (inst.operands[2].isreg) /* Rd, {Rs,} Rn */
12495 constraint (inst.operands[2].reg > 7, BAD_HIREG);
12496 constraint (inst.operands[0].reg != inst.operands[1].reg,
12497 _("source1 and dest must be same register"));
12499 switch (inst.instruction)
12501 case T_MNEM_asr: inst.instruction = T_OPCODE_ASR_R; break;
12502 case T_MNEM_lsl: inst.instruction = T_OPCODE_LSL_R; break;
12503 case T_MNEM_lsr: inst.instruction = T_OPCODE_LSR_R; break;
12504 case T_MNEM_ror: inst.instruction = T_OPCODE_ROR_R; break;
12508 inst.instruction |= inst.operands[0].reg;
12509 inst.instruction |= inst.operands[2].reg << 3;
12511 /* PR 12854: Error on extraneous shifts. */
12512 constraint (inst.operands[2].shifted,
12513 _("extraneous shift as part of operand to shift insn"));
12517 switch (inst.instruction)
12519 case T_MNEM_asr: inst.instruction = T_OPCODE_ASR_I; break;
12520 case T_MNEM_lsl: inst.instruction = T_OPCODE_LSL_I; break;
12521 case T_MNEM_lsr: inst.instruction = T_OPCODE_LSR_I; break;
12522 case T_MNEM_ror: inst.error = _("ror #imm not supported"); return;
12525 inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
12526 inst.instruction |= inst.operands[0].reg;
12527 inst.instruction |= inst.operands[1].reg << 3;
12535 unsigned Rd, Rn, Rm;
12537 Rd = inst.operands[0].reg;
12538 Rn = inst.operands[1].reg;
12539 Rm = inst.operands[2].reg;
12541 reject_bad_reg (Rd);
12542 reject_bad_reg (Rn);
12543 reject_bad_reg (Rm);
12545 inst.instruction |= Rd << 8;
12546 inst.instruction |= Rn << 16;
12547 inst.instruction |= Rm;
12553 unsigned Rd, Rn, Rm;
12555 Rd = inst.operands[0].reg;
12556 Rm = inst.operands[1].reg;
12557 Rn = inst.operands[2].reg;
12559 reject_bad_reg (Rd);
12560 reject_bad_reg (Rn);
12561 reject_bad_reg (Rm);
12563 inst.instruction |= Rd << 8;
12564 inst.instruction |= Rn << 16;
12565 inst.instruction |= Rm;
12571 unsigned int value = inst.reloc.exp.X_add_number;
12572 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7a),
12573 _("SMC is not permitted on this architecture"));
12574 constraint (inst.reloc.exp.X_op != O_constant,
12575 _("expression too complex"));
12576 inst.reloc.type = BFD_RELOC_UNUSED;
12577 inst.instruction |= (value & 0xf000) >> 12;
12578 inst.instruction |= (value & 0x0ff0);
12579 inst.instruction |= (value & 0x000f) << 16;
12580 /* PR gas/15623: SMC instructions must be last in an IT block. */
12581 set_it_insn_type_last ();
12587 unsigned int value = inst.reloc.exp.X_add_number;
12589 inst.reloc.type = BFD_RELOC_UNUSED;
12590 inst.instruction |= (value & 0x0fff);
12591 inst.instruction |= (value & 0xf000) << 4;
12595 do_t_ssat_usat (int bias)
12599 Rd = inst.operands[0].reg;
12600 Rn = inst.operands[2].reg;
12602 reject_bad_reg (Rd);
12603 reject_bad_reg (Rn);
12605 inst.instruction |= Rd << 8;
12606 inst.instruction |= inst.operands[1].imm - bias;
12607 inst.instruction |= Rn << 16;
12609 if (inst.operands[3].present)
12611 offsetT shift_amount = inst.reloc.exp.X_add_number;
12613 inst.reloc.type = BFD_RELOC_UNUSED;
12615 constraint (inst.reloc.exp.X_op != O_constant,
12616 _("expression too complex"));
12618 if (shift_amount != 0)
12620 constraint (shift_amount > 31,
12621 _("shift expression is too large"));
12623 if (inst.operands[3].shift_kind == SHIFT_ASR)
12624 inst.instruction |= 0x00200000; /* sh bit. */
12626 inst.instruction |= (shift_amount & 0x1c) << 10;
12627 inst.instruction |= (shift_amount & 0x03) << 6;
12635 do_t_ssat_usat (1);
12643 Rd = inst.operands[0].reg;
12644 Rn = inst.operands[2].reg;
12646 reject_bad_reg (Rd);
12647 reject_bad_reg (Rn);
12649 inst.instruction |= Rd << 8;
12650 inst.instruction |= inst.operands[1].imm - 1;
12651 inst.instruction |= Rn << 16;
12657 constraint (!inst.operands[2].isreg || !inst.operands[2].preind
12658 || inst.operands[2].postind || inst.operands[2].writeback
12659 || inst.operands[2].immisreg || inst.operands[2].shifted
12660 || inst.operands[2].negative,
12663 constraint (inst.operands[2].reg == REG_PC, BAD_PC);
12665 inst.instruction |= inst.operands[0].reg << 8;
12666 inst.instruction |= inst.operands[1].reg << 12;
12667 inst.instruction |= inst.operands[2].reg << 16;
12668 inst.reloc.type = BFD_RELOC_ARM_T32_OFFSET_U8;
12674 if (!inst.operands[2].present)
12675 inst.operands[2].reg = inst.operands[1].reg + 1;
12677 constraint (inst.operands[0].reg == inst.operands[1].reg
12678 || inst.operands[0].reg == inst.operands[2].reg
12679 || inst.operands[0].reg == inst.operands[3].reg,
12682 inst.instruction |= inst.operands[0].reg;
12683 inst.instruction |= inst.operands[1].reg << 12;
12684 inst.instruction |= inst.operands[2].reg << 8;
12685 inst.instruction |= inst.operands[3].reg << 16;
12691 unsigned Rd, Rn, Rm;
12693 Rd = inst.operands[0].reg;
12694 Rn = inst.operands[1].reg;
12695 Rm = inst.operands[2].reg;
12697 reject_bad_reg (Rd);
12698 reject_bad_reg (Rn);
12699 reject_bad_reg (Rm);
12701 inst.instruction |= Rd << 8;
12702 inst.instruction |= Rn << 16;
12703 inst.instruction |= Rm;
12704 inst.instruction |= inst.operands[3].imm << 4;
12712 Rd = inst.operands[0].reg;
12713 Rm = inst.operands[1].reg;
12715 reject_bad_reg (Rd);
12716 reject_bad_reg (Rm);
12718 if (inst.instruction <= 0xffff
12719 && inst.size_req != 4
12720 && Rd <= 7 && Rm <= 7
12721 && (!inst.operands[2].present || inst.operands[2].imm == 0))
12723 inst.instruction = THUMB_OP16 (inst.instruction);
12724 inst.instruction |= Rd;
12725 inst.instruction |= Rm << 3;
12727 else if (unified_syntax)
12729 if (inst.instruction <= 0xffff)
12730 inst.instruction = THUMB_OP32 (inst.instruction);
12731 inst.instruction |= Rd << 8;
12732 inst.instruction |= Rm;
12733 inst.instruction |= inst.operands[2].imm << 4;
12737 constraint (inst.operands[2].present && inst.operands[2].imm != 0,
12738 _("Thumb encoding does not support rotation"));
12739 constraint (1, BAD_HIREG);
12746 /* We have to do the following check manually as ARM_EXT_OS only applies
12748 if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v6m))
12750 if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_os)
12751 /* This only applies to the v6m howver, not later architectures. */
12752 && ! ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v7))
12753 as_bad (_("SVC is not permitted on this architecture"));
12754 ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used, arm_ext_os);
12757 inst.reloc.type = BFD_RELOC_ARM_SWI;
12766 half = (inst.instruction & 0x10) != 0;
12767 set_it_insn_type_last ();
12768 constraint (inst.operands[0].immisreg,
12769 _("instruction requires register index"));
12771 Rn = inst.operands[0].reg;
12772 Rm = inst.operands[0].imm;
12774 constraint (Rn == REG_SP, BAD_SP);
12775 reject_bad_reg (Rm);
12777 constraint (!half && inst.operands[0].shifted,
12778 _("instruction does not allow shifted index"));
12779 inst.instruction |= (Rn << 16) | Rm;
12785 if (!inst.operands[0].present)
12786 inst.operands[0].imm = 0;
12788 if ((unsigned int) inst.operands[0].imm > 255 || inst.size_req == 4)
12790 constraint (inst.size_req == 2,
12791 _("immediate value out of range"));
12792 inst.instruction = THUMB_OP32 (inst.instruction);
12793 inst.instruction |= (inst.operands[0].imm & 0xf000u) << 4;
12794 inst.instruction |= (inst.operands[0].imm & 0x0fffu) << 0;
12798 inst.instruction = THUMB_OP16 (inst.instruction);
12799 inst.instruction |= inst.operands[0].imm;
12802 set_it_insn_type (NEUTRAL_IT_INSN);
12809 do_t_ssat_usat (0);
12817 Rd = inst.operands[0].reg;
12818 Rn = inst.operands[2].reg;
12820 reject_bad_reg (Rd);
12821 reject_bad_reg (Rn);
12823 inst.instruction |= Rd << 8;
12824 inst.instruction |= inst.operands[1].imm;
12825 inst.instruction |= Rn << 16;
12828 /* Neon instruction encoder helpers. */
12830 /* Encodings for the different types for various Neon opcodes. */
12832 /* An "invalid" code for the following tables. */
12835 struct neon_tab_entry
12838 unsigned float_or_poly;
12839 unsigned scalar_or_imm;
12842 /* Map overloaded Neon opcodes to their respective encodings. */
12843 #define NEON_ENC_TAB \
12844 X(vabd, 0x0000700, 0x1200d00, N_INV), \
12845 X(vmax, 0x0000600, 0x0000f00, N_INV), \
12846 X(vmin, 0x0000610, 0x0200f00, N_INV), \
12847 X(vpadd, 0x0000b10, 0x1000d00, N_INV), \
12848 X(vpmax, 0x0000a00, 0x1000f00, N_INV), \
12849 X(vpmin, 0x0000a10, 0x1200f00, N_INV), \
12850 X(vadd, 0x0000800, 0x0000d00, N_INV), \
12851 X(vsub, 0x1000800, 0x0200d00, N_INV), \
12852 X(vceq, 0x1000810, 0x0000e00, 0x1b10100), \
12853 X(vcge, 0x0000310, 0x1000e00, 0x1b10080), \
12854 X(vcgt, 0x0000300, 0x1200e00, 0x1b10000), \
12855 /* Register variants of the following two instructions are encoded as
12856 vcge / vcgt with the operands reversed. */ \
12857 X(vclt, 0x0000300, 0x1200e00, 0x1b10200), \
12858 X(vcle, 0x0000310, 0x1000e00, 0x1b10180), \
12859 X(vfma, N_INV, 0x0000c10, N_INV), \
12860 X(vfms, N_INV, 0x0200c10, N_INV), \
12861 X(vmla, 0x0000900, 0x0000d10, 0x0800040), \
12862 X(vmls, 0x1000900, 0x0200d10, 0x0800440), \
12863 X(vmul, 0x0000910, 0x1000d10, 0x0800840), \
12864 X(vmull, 0x0800c00, 0x0800e00, 0x0800a40), /* polynomial not float. */ \
12865 X(vmlal, 0x0800800, N_INV, 0x0800240), \
12866 X(vmlsl, 0x0800a00, N_INV, 0x0800640), \
12867 X(vqdmlal, 0x0800900, N_INV, 0x0800340), \
12868 X(vqdmlsl, 0x0800b00, N_INV, 0x0800740), \
12869 X(vqdmull, 0x0800d00, N_INV, 0x0800b40), \
12870 X(vqdmulh, 0x0000b00, N_INV, 0x0800c40), \
12871 X(vqrdmulh, 0x1000b00, N_INV, 0x0800d40), \
12872 X(vshl, 0x0000400, N_INV, 0x0800510), \
12873 X(vqshl, 0x0000410, N_INV, 0x0800710), \
12874 X(vand, 0x0000110, N_INV, 0x0800030), \
12875 X(vbic, 0x0100110, N_INV, 0x0800030), \
12876 X(veor, 0x1000110, N_INV, N_INV), \
12877 X(vorn, 0x0300110, N_INV, 0x0800010), \
12878 X(vorr, 0x0200110, N_INV, 0x0800010), \
12879 X(vmvn, 0x1b00580, N_INV, 0x0800030), \
12880 X(vshll, 0x1b20300, N_INV, 0x0800a10), /* max shift, immediate. */ \
12881 X(vcvt, 0x1b30600, N_INV, 0x0800e10), /* integer, fixed-point. */ \
12882 X(vdup, 0xe800b10, N_INV, 0x1b00c00), /* arm, scalar. */ \
12883 X(vld1, 0x0200000, 0x0a00000, 0x0a00c00), /* interlv, lane, dup. */ \
12884 X(vst1, 0x0000000, 0x0800000, N_INV), \
12885 X(vld2, 0x0200100, 0x0a00100, 0x0a00d00), \
12886 X(vst2, 0x0000100, 0x0800100, N_INV), \
12887 X(vld3, 0x0200200, 0x0a00200, 0x0a00e00), \
12888 X(vst3, 0x0000200, 0x0800200, N_INV), \
12889 X(vld4, 0x0200300, 0x0a00300, 0x0a00f00), \
12890 X(vst4, 0x0000300, 0x0800300, N_INV), \
12891 X(vmovn, 0x1b20200, N_INV, N_INV), \
12892 X(vtrn, 0x1b20080, N_INV, N_INV), \
12893 X(vqmovn, 0x1b20200, N_INV, N_INV), \
12894 X(vqmovun, 0x1b20240, N_INV, N_INV), \
12895 X(vnmul, 0xe200a40, 0xe200b40, N_INV), \
12896 X(vnmla, 0xe100a40, 0xe100b40, N_INV), \
12897 X(vnmls, 0xe100a00, 0xe100b00, N_INV), \
12898 X(vfnma, 0xe900a40, 0xe900b40, N_INV), \
12899 X(vfnms, 0xe900a00, 0xe900b00, N_INV), \
12900 X(vcmp, 0xeb40a40, 0xeb40b40, N_INV), \
12901 X(vcmpz, 0xeb50a40, 0xeb50b40, N_INV), \
12902 X(vcmpe, 0xeb40ac0, 0xeb40bc0, N_INV), \
12903 X(vcmpez, 0xeb50ac0, 0xeb50bc0, N_INV), \
12904 X(vseleq, 0xe000a00, N_INV, N_INV), \
12905 X(vselvs, 0xe100a00, N_INV, N_INV), \
12906 X(vselge, 0xe200a00, N_INV, N_INV), \
12907 X(vselgt, 0xe300a00, N_INV, N_INV), \
12908 X(vmaxnm, 0xe800a00, 0x3000f10, N_INV), \
12909 X(vminnm, 0xe800a40, 0x3200f10, N_INV), \
12910 X(vcvta, 0xebc0a40, 0x3bb0000, N_INV), \
12911 X(vrintr, 0xeb60a40, 0x3ba0400, N_INV), \
12912 X(vrinta, 0xeb80a40, 0x3ba0400, N_INV), \
12913 X(aes, 0x3b00300, N_INV, N_INV), \
12914 X(sha3op, 0x2000c00, N_INV, N_INV), \
12915 X(sha1h, 0x3b902c0, N_INV, N_INV), \
12916 X(sha2op, 0x3ba0380, N_INV, N_INV)
12920 #define X(OPC,I,F,S) N_MNEM_##OPC
12925 static const struct neon_tab_entry neon_enc_tab[] =
12927 #define X(OPC,I,F,S) { (I), (F), (S) }
12932 /* Do not use these macros; instead, use NEON_ENCODE defined below. */
12933 #define NEON_ENC_INTEGER_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
12934 #define NEON_ENC_ARMREG_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
12935 #define NEON_ENC_POLY_(X) (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
12936 #define NEON_ENC_FLOAT_(X) (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
12937 #define NEON_ENC_SCALAR_(X) (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
12938 #define NEON_ENC_IMMED_(X) (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
12939 #define NEON_ENC_INTERLV_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
12940 #define NEON_ENC_LANE_(X) (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
12941 #define NEON_ENC_DUP_(X) (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
12942 #define NEON_ENC_SINGLE_(X) \
12943 ((neon_enc_tab[(X) & 0x0fffffff].integer) | ((X) & 0xf0000000))
12944 #define NEON_ENC_DOUBLE_(X) \
12945 ((neon_enc_tab[(X) & 0x0fffffff].float_or_poly) | ((X) & 0xf0000000))
12946 #define NEON_ENC_FPV8_(X) \
12947 ((neon_enc_tab[(X) & 0x0fffffff].integer) | ((X) & 0xf000000))
12949 #define NEON_ENCODE(type, inst) \
12952 inst.instruction = NEON_ENC_##type##_ (inst.instruction); \
12953 inst.is_neon = 1; \
12957 #define check_neon_suffixes \
12960 if (!inst.error && inst.vectype.elems > 0 && !inst.is_neon) \
12962 as_bad (_("invalid neon suffix for non neon instruction")); \
12968 /* Define shapes for instruction operands. The following mnemonic characters
12969 are used in this table:
12971 F - VFP S<n> register
12972 D - Neon D<n> register
12973 Q - Neon Q<n> register
12977 L - D<n> register list
12979 This table is used to generate various data:
12980 - enumerations of the form NS_DDR to be used as arguments to
12982 - a table classifying shapes into single, double, quad, mixed.
12983 - a table used to drive neon_select_shape. */
12985 #define NEON_SHAPE_DEF \
12986 X(3, (D, D, D), DOUBLE), \
12987 X(3, (Q, Q, Q), QUAD), \
12988 X(3, (D, D, I), DOUBLE), \
12989 X(3, (Q, Q, I), QUAD), \
12990 X(3, (D, D, S), DOUBLE), \
12991 X(3, (Q, Q, S), QUAD), \
12992 X(2, (D, D), DOUBLE), \
12993 X(2, (Q, Q), QUAD), \
12994 X(2, (D, S), DOUBLE), \
12995 X(2, (Q, S), QUAD), \
12996 X(2, (D, R), DOUBLE), \
12997 X(2, (Q, R), QUAD), \
12998 X(2, (D, I), DOUBLE), \
12999 X(2, (Q, I), QUAD), \
13000 X(3, (D, L, D), DOUBLE), \
13001 X(2, (D, Q), MIXED), \
13002 X(2, (Q, D), MIXED), \
13003 X(3, (D, Q, I), MIXED), \
13004 X(3, (Q, D, I), MIXED), \
13005 X(3, (Q, D, D), MIXED), \
13006 X(3, (D, Q, Q), MIXED), \
13007 X(3, (Q, Q, D), MIXED), \
13008 X(3, (Q, D, S), MIXED), \
13009 X(3, (D, Q, S), MIXED), \
13010 X(4, (D, D, D, I), DOUBLE), \
13011 X(4, (Q, Q, Q, I), QUAD), \
13012 X(2, (F, F), SINGLE), \
13013 X(3, (F, F, F), SINGLE), \
13014 X(2, (F, I), SINGLE), \
13015 X(2, (F, D), MIXED), \
13016 X(2, (D, F), MIXED), \
13017 X(3, (F, F, I), MIXED), \
13018 X(4, (R, R, F, F), SINGLE), \
13019 X(4, (F, F, R, R), SINGLE), \
13020 X(3, (D, R, R), DOUBLE), \
13021 X(3, (R, R, D), DOUBLE), \
13022 X(2, (S, R), SINGLE), \
13023 X(2, (R, S), SINGLE), \
13024 X(2, (F, R), SINGLE), \
13025 X(2, (R, F), SINGLE)
13027 #define S2(A,B) NS_##A##B
13028 #define S3(A,B,C) NS_##A##B##C
13029 #define S4(A,B,C,D) NS_##A##B##C##D
13031 #define X(N, L, C) S##N L
13044 enum neon_shape_class
13052 #define X(N, L, C) SC_##C
13054 static enum neon_shape_class neon_shape_class[] =
13072 /* Register widths of above. */
13073 static unsigned neon_shape_el_size[] =
13084 struct neon_shape_info
13087 enum neon_shape_el el[NEON_MAX_TYPE_ELS];
13090 #define S2(A,B) { SE_##A, SE_##B }
13091 #define S3(A,B,C) { SE_##A, SE_##B, SE_##C }
13092 #define S4(A,B,C,D) { SE_##A, SE_##B, SE_##C, SE_##D }
13094 #define X(N, L, C) { N, S##N L }
13096 static struct neon_shape_info neon_shape_tab[] =
13106 /* Bit masks used in type checking given instructions.
13107 'N_EQK' means the type must be the same as (or based on in some way) the key
13108 type, which itself is marked with the 'N_KEY' bit. If the 'N_EQK' bit is
13109 set, various other bits can be set as well in order to modify the meaning of
13110 the type constraint. */
13112 enum neon_type_mask
13136 N_KEY = 0x1000000, /* Key element (main type specifier). */
13137 N_EQK = 0x2000000, /* Given operand has the same type & size as the key. */
13138 N_VFP = 0x4000000, /* VFP mode: operand size must match register width. */
13139 N_UNT = 0x8000000, /* Must be explicitly untyped. */
13140 N_DBL = 0x0000001, /* If N_EQK, this operand is twice the size. */
13141 N_HLF = 0x0000002, /* If N_EQK, this operand is half the size. */
13142 N_SGN = 0x0000004, /* If N_EQK, this operand is forced to be signed. */
13143 N_UNS = 0x0000008, /* If N_EQK, this operand is forced to be unsigned. */
13144 N_INT = 0x0000010, /* If N_EQK, this operand is forced to be integer. */
13145 N_FLT = 0x0000020, /* If N_EQK, this operand is forced to be float. */
13146 N_SIZ = 0x0000040, /* If N_EQK, this operand is forced to be size-only. */
13148 N_MAX_NONSPECIAL = N_P64
13151 #define N_ALLMODS (N_DBL | N_HLF | N_SGN | N_UNS | N_INT | N_FLT | N_SIZ)
13153 #define N_SU_ALL (N_S8 | N_S16 | N_S32 | N_S64 | N_U8 | N_U16 | N_U32 | N_U64)
13154 #define N_SU_32 (N_S8 | N_S16 | N_S32 | N_U8 | N_U16 | N_U32)
13155 #define N_SU_16_64 (N_S16 | N_S32 | N_S64 | N_U16 | N_U32 | N_U64)
13156 #define N_SUF_32 (N_SU_32 | N_F32)
13157 #define N_I_ALL (N_I8 | N_I16 | N_I32 | N_I64)
13158 #define N_IF_32 (N_I8 | N_I16 | N_I32 | N_F32)
13160 /* Pass this as the first type argument to neon_check_type to ignore types
13162 #define N_IGNORE_TYPE (N_KEY | N_EQK)
13164 /* Select a "shape" for the current instruction (describing register types or
13165 sizes) from a list of alternatives. Return NS_NULL if the current instruction
13166 doesn't fit. For non-polymorphic shapes, checking is usually done as a
13167 function of operand parsing, so this function doesn't need to be called.
13168 Shapes should be listed in order of decreasing length. */
13170 static enum neon_shape
13171 neon_select_shape (enum neon_shape shape, ...)
13174 enum neon_shape first_shape = shape;
13176 /* Fix missing optional operands. FIXME: we don't know at this point how
13177 many arguments we should have, so this makes the assumption that we have
13178 > 1. This is true of all current Neon opcodes, I think, but may not be
13179 true in the future. */
13180 if (!inst.operands[1].present)
13181 inst.operands[1] = inst.operands[0];
13183 va_start (ap, shape);
13185 for (; shape != NS_NULL; shape = (enum neon_shape) va_arg (ap, int))
13190 for (j = 0; j < neon_shape_tab[shape].els; j++)
13192 if (!inst.operands[j].present)
13198 switch (neon_shape_tab[shape].el[j])
13201 if (!(inst.operands[j].isreg
13202 && inst.operands[j].isvec
13203 && inst.operands[j].issingle
13204 && !inst.operands[j].isquad))
13209 if (!(inst.operands[j].isreg
13210 && inst.operands[j].isvec
13211 && !inst.operands[j].isquad
13212 && !inst.operands[j].issingle))
13217 if (!(inst.operands[j].isreg
13218 && !inst.operands[j].isvec))
13223 if (!(inst.operands[j].isreg
13224 && inst.operands[j].isvec
13225 && inst.operands[j].isquad
13226 && !inst.operands[j].issingle))
13231 if (!(!inst.operands[j].isreg
13232 && !inst.operands[j].isscalar))
13237 if (!(!inst.operands[j].isreg
13238 && inst.operands[j].isscalar))
13248 if (matches && (j >= ARM_IT_MAX_OPERANDS || !inst.operands[j].present))
13249 /* We've matched all the entries in the shape table, and we don't
13250 have any left over operands which have not been matched. */
13256 if (shape == NS_NULL && first_shape != NS_NULL)
13257 first_error (_("invalid instruction shape"));
13262 /* True if SHAPE is predominantly a quadword operation (most of the time, this
13263 means the Q bit should be set). */
13266 neon_quad (enum neon_shape shape)
13268 return neon_shape_class[shape] == SC_QUAD;
13272 neon_modify_type_size (unsigned typebits, enum neon_el_type *g_type,
13275 /* Allow modification to be made to types which are constrained to be
13276 based on the key element, based on bits set alongside N_EQK. */
13277 if ((typebits & N_EQK) != 0)
13279 if ((typebits & N_HLF) != 0)
13281 else if ((typebits & N_DBL) != 0)
13283 if ((typebits & N_SGN) != 0)
13284 *g_type = NT_signed;
13285 else if ((typebits & N_UNS) != 0)
13286 *g_type = NT_unsigned;
13287 else if ((typebits & N_INT) != 0)
13288 *g_type = NT_integer;
13289 else if ((typebits & N_FLT) != 0)
13290 *g_type = NT_float;
13291 else if ((typebits & N_SIZ) != 0)
13292 *g_type = NT_untyped;
13296 /* Return operand OPNO promoted by bits set in THISARG. KEY should be the "key"
13297 operand type, i.e. the single type specified in a Neon instruction when it
13298 is the only one given. */
13300 static struct neon_type_el
13301 neon_type_promote (struct neon_type_el *key, unsigned thisarg)
13303 struct neon_type_el dest = *key;
13305 gas_assert ((thisarg & N_EQK) != 0);
13307 neon_modify_type_size (thisarg, &dest.type, &dest.size);
13312 /* Convert Neon type and size into compact bitmask representation. */
13314 static enum neon_type_mask
13315 type_chk_of_el_type (enum neon_el_type type, unsigned size)
13322 case 8: return N_8;
13323 case 16: return N_16;
13324 case 32: return N_32;
13325 case 64: return N_64;
13333 case 8: return N_I8;
13334 case 16: return N_I16;
13335 case 32: return N_I32;
13336 case 64: return N_I64;
13344 case 16: return N_F16;
13345 case 32: return N_F32;
13346 case 64: return N_F64;
13354 case 8: return N_P8;
13355 case 16: return N_P16;
13356 case 64: return N_P64;
13364 case 8: return N_S8;
13365 case 16: return N_S16;
13366 case 32: return N_S32;
13367 case 64: return N_S64;
13375 case 8: return N_U8;
13376 case 16: return N_U16;
13377 case 32: return N_U32;
13378 case 64: return N_U64;
13389 /* Convert compact Neon bitmask type representation to a type and size. Only
13390 handles the case where a single bit is set in the mask. */
13393 el_type_of_type_chk (enum neon_el_type *type, unsigned *size,
13394 enum neon_type_mask mask)
13396 if ((mask & N_EQK) != 0)
13399 if ((mask & (N_S8 | N_U8 | N_I8 | N_8 | N_P8)) != 0)
13401 else if ((mask & (N_S16 | N_U16 | N_I16 | N_16 | N_F16 | N_P16)) != 0)
13403 else if ((mask & (N_S32 | N_U32 | N_I32 | N_32 | N_F32)) != 0)
13405 else if ((mask & (N_S64 | N_U64 | N_I64 | N_64 | N_F64 | N_P64)) != 0)
13410 if ((mask & (N_S8 | N_S16 | N_S32 | N_S64)) != 0)
13412 else if ((mask & (N_U8 | N_U16 | N_U32 | N_U64)) != 0)
13413 *type = NT_unsigned;
13414 else if ((mask & (N_I8 | N_I16 | N_I32 | N_I64)) != 0)
13415 *type = NT_integer;
13416 else if ((mask & (N_8 | N_16 | N_32 | N_64)) != 0)
13417 *type = NT_untyped;
13418 else if ((mask & (N_P8 | N_P16 | N_P64)) != 0)
13420 else if ((mask & (N_F16 | N_F32 | N_F64)) != 0)
13428 /* Modify a bitmask of allowed types. This is only needed for type
13432 modify_types_allowed (unsigned allowed, unsigned mods)
13435 enum neon_el_type type;
13441 for (i = 1; i <= N_MAX_NONSPECIAL; i <<= 1)
13443 if (el_type_of_type_chk (&type, &size,
13444 (enum neon_type_mask) (allowed & i)) == SUCCESS)
13446 neon_modify_type_size (mods, &type, &size);
13447 destmask |= type_chk_of_el_type (type, size);
13454 /* Check type and return type classification.
13455 The manual states (paraphrase): If one datatype is given, it indicates the
13457 - the second operand, if there is one
13458 - the operand, if there is no second operand
13459 - the result, if there are no operands.
13460 This isn't quite good enough though, so we use a concept of a "key" datatype
13461 which is set on a per-instruction basis, which is the one which matters when
13462 only one data type is written.
13463 Note: this function has side-effects (e.g. filling in missing operands). All
13464 Neon instructions should call it before performing bit encoding. */
13466 static struct neon_type_el
13467 neon_check_type (unsigned els, enum neon_shape ns, ...)
13470 unsigned i, pass, key_el = 0;
13471 unsigned types[NEON_MAX_TYPE_ELS];
13472 enum neon_el_type k_type = NT_invtype;
13473 unsigned k_size = -1u;
13474 struct neon_type_el badtype = {NT_invtype, -1};
13475 unsigned key_allowed = 0;
13477 /* Optional registers in Neon instructions are always (not) in operand 1.
13478 Fill in the missing operand here, if it was omitted. */
13479 if (els > 1 && !inst.operands[1].present)
13480 inst.operands[1] = inst.operands[0];
13482 /* Suck up all the varargs. */
13484 for (i = 0; i < els; i++)
13486 unsigned thisarg = va_arg (ap, unsigned);
13487 if (thisarg == N_IGNORE_TYPE)
13492 types[i] = thisarg;
13493 if ((thisarg & N_KEY) != 0)
13498 if (inst.vectype.elems > 0)
13499 for (i = 0; i < els; i++)
13500 if (inst.operands[i].vectype.type != NT_invtype)
13502 first_error (_("types specified in both the mnemonic and operands"));
13506 /* Duplicate inst.vectype elements here as necessary.
13507 FIXME: No idea if this is exactly the same as the ARM assembler,
13508 particularly when an insn takes one register and one non-register
13510 if (inst.vectype.elems == 1 && els > 1)
13513 inst.vectype.elems = els;
13514 inst.vectype.el[key_el] = inst.vectype.el[0];
13515 for (j = 0; j < els; j++)
13517 inst.vectype.el[j] = neon_type_promote (&inst.vectype.el[key_el],
13520 else if (inst.vectype.elems == 0 && els > 0)
13523 /* No types were given after the mnemonic, so look for types specified
13524 after each operand. We allow some flexibility here; as long as the
13525 "key" operand has a type, we can infer the others. */
13526 for (j = 0; j < els; j++)
13527 if (inst.operands[j].vectype.type != NT_invtype)
13528 inst.vectype.el[j] = inst.operands[j].vectype;
13530 if (inst.operands[key_el].vectype.type != NT_invtype)
13532 for (j = 0; j < els; j++)
13533 if (inst.operands[j].vectype.type == NT_invtype)
13534 inst.vectype.el[j] = neon_type_promote (&inst.vectype.el[key_el],
13539 first_error (_("operand types can't be inferred"));
13543 else if (inst.vectype.elems != els)
13545 first_error (_("type specifier has the wrong number of parts"));
13549 for (pass = 0; pass < 2; pass++)
13551 for (i = 0; i < els; i++)
13553 unsigned thisarg = types[i];
13554 unsigned types_allowed = ((thisarg & N_EQK) != 0 && pass != 0)
13555 ? modify_types_allowed (key_allowed, thisarg) : thisarg;
13556 enum neon_el_type g_type = inst.vectype.el[i].type;
13557 unsigned g_size = inst.vectype.el[i].size;
13559 /* Decay more-specific signed & unsigned types to sign-insensitive
13560 integer types if sign-specific variants are unavailable. */
13561 if ((g_type == NT_signed || g_type == NT_unsigned)
13562 && (types_allowed & N_SU_ALL) == 0)
13563 g_type = NT_integer;
13565 /* If only untyped args are allowed, decay any more specific types to
13566 them. Some instructions only care about signs for some element
13567 sizes, so handle that properly. */
13568 if (((types_allowed & N_UNT) == 0)
13569 && ((g_size == 8 && (types_allowed & N_8) != 0)
13570 || (g_size == 16 && (types_allowed & N_16) != 0)
13571 || (g_size == 32 && (types_allowed & N_32) != 0)
13572 || (g_size == 64 && (types_allowed & N_64) != 0)))
13573 g_type = NT_untyped;
13577 if ((thisarg & N_KEY) != 0)
13581 key_allowed = thisarg & ~N_KEY;
13586 if ((thisarg & N_VFP) != 0)
13588 enum neon_shape_el regshape;
13589 unsigned regwidth, match;
13591 /* PR 11136: Catch the case where we are passed a shape of NS_NULL. */
13594 first_error (_("invalid instruction shape"));
13597 regshape = neon_shape_tab[ns].el[i];
13598 regwidth = neon_shape_el_size[regshape];
13600 /* In VFP mode, operands must match register widths. If we
13601 have a key operand, use its width, else use the width of
13602 the current operand. */
13608 if (regwidth != match)
13610 first_error (_("operand size must match register width"));
13615 if ((thisarg & N_EQK) == 0)
13617 unsigned given_type = type_chk_of_el_type (g_type, g_size);
13619 if ((given_type & types_allowed) == 0)
13621 first_error (_("bad type in Neon instruction"));
13627 enum neon_el_type mod_k_type = k_type;
13628 unsigned mod_k_size = k_size;
13629 neon_modify_type_size (thisarg, &mod_k_type, &mod_k_size);
13630 if (g_type != mod_k_type || g_size != mod_k_size)
13632 first_error (_("inconsistent types in Neon instruction"));
13640 return inst.vectype.el[key_el];
13643 /* Neon-style VFP instruction forwarding. */
13645 /* Thumb VFP instructions have 0xE in the condition field. */
13648 do_vfp_cond_or_thumb (void)
13653 inst.instruction |= 0xe0000000;
13655 inst.instruction |= inst.cond << 28;
13658 /* Look up and encode a simple mnemonic, for use as a helper function for the
13659 Neon-style VFP syntax. This avoids duplication of bits of the insns table,
13660 etc. It is assumed that operand parsing has already been done, and that the
13661 operands are in the form expected by the given opcode (this isn't necessarily
13662 the same as the form in which they were parsed, hence some massaging must
13663 take place before this function is called).
13664 Checks current arch version against that in the looked-up opcode. */
13667 do_vfp_nsyn_opcode (const char *opname)
13669 const struct asm_opcode *opcode;
13671 opcode = (const struct asm_opcode *) hash_find (arm_ops_hsh, opname);
13676 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant,
13677 thumb_mode ? *opcode->tvariant : *opcode->avariant),
13684 inst.instruction = opcode->tvalue;
13685 opcode->tencode ();
13689 inst.instruction = (inst.cond << 28) | opcode->avalue;
13690 opcode->aencode ();
13695 do_vfp_nsyn_add_sub (enum neon_shape rs)
13697 int is_add = (inst.instruction & 0x0fffffff) == N_MNEM_vadd;
13702 do_vfp_nsyn_opcode ("fadds");
13704 do_vfp_nsyn_opcode ("fsubs");
13709 do_vfp_nsyn_opcode ("faddd");
13711 do_vfp_nsyn_opcode ("fsubd");
13715 /* Check operand types to see if this is a VFP instruction, and if so call
13719 try_vfp_nsyn (int args, void (*pfn) (enum neon_shape))
13721 enum neon_shape rs;
13722 struct neon_type_el et;
13727 rs = neon_select_shape (NS_FF, NS_DD, NS_NULL);
13728 et = neon_check_type (2, rs,
13729 N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13733 rs = neon_select_shape (NS_FFF, NS_DDD, NS_NULL);
13734 et = neon_check_type (3, rs,
13735 N_EQK | N_VFP, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13742 if (et.type != NT_invtype)
13753 do_vfp_nsyn_mla_mls (enum neon_shape rs)
13755 int is_mla = (inst.instruction & 0x0fffffff) == N_MNEM_vmla;
13760 do_vfp_nsyn_opcode ("fmacs");
13762 do_vfp_nsyn_opcode ("fnmacs");
13767 do_vfp_nsyn_opcode ("fmacd");
13769 do_vfp_nsyn_opcode ("fnmacd");
13774 do_vfp_nsyn_fma_fms (enum neon_shape rs)
13776 int is_fma = (inst.instruction & 0x0fffffff) == N_MNEM_vfma;
13781 do_vfp_nsyn_opcode ("ffmas");
13783 do_vfp_nsyn_opcode ("ffnmas");
13788 do_vfp_nsyn_opcode ("ffmad");
13790 do_vfp_nsyn_opcode ("ffnmad");
13795 do_vfp_nsyn_mul (enum neon_shape rs)
13798 do_vfp_nsyn_opcode ("fmuls");
13800 do_vfp_nsyn_opcode ("fmuld");
13804 do_vfp_nsyn_abs_neg (enum neon_shape rs)
13806 int is_neg = (inst.instruction & 0x80) != 0;
13807 neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_VFP | N_KEY);
13812 do_vfp_nsyn_opcode ("fnegs");
13814 do_vfp_nsyn_opcode ("fabss");
13819 do_vfp_nsyn_opcode ("fnegd");
13821 do_vfp_nsyn_opcode ("fabsd");
13825 /* Encode single-precision (only!) VFP fldm/fstm instructions. Double precision
13826 insns belong to Neon, and are handled elsewhere. */
13829 do_vfp_nsyn_ldm_stm (int is_dbmode)
13831 int is_ldm = (inst.instruction & (1 << 20)) != 0;
13835 do_vfp_nsyn_opcode ("fldmdbs");
13837 do_vfp_nsyn_opcode ("fldmias");
13842 do_vfp_nsyn_opcode ("fstmdbs");
13844 do_vfp_nsyn_opcode ("fstmias");
13849 do_vfp_nsyn_sqrt (void)
13851 enum neon_shape rs = neon_select_shape (NS_FF, NS_DD, NS_NULL);
13852 neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13855 do_vfp_nsyn_opcode ("fsqrts");
13857 do_vfp_nsyn_opcode ("fsqrtd");
13861 do_vfp_nsyn_div (void)
13863 enum neon_shape rs = neon_select_shape (NS_FFF, NS_DDD, NS_NULL);
13864 neon_check_type (3, rs, N_EQK | N_VFP, N_EQK | N_VFP,
13865 N_F32 | N_F64 | N_KEY | N_VFP);
13868 do_vfp_nsyn_opcode ("fdivs");
13870 do_vfp_nsyn_opcode ("fdivd");
13874 do_vfp_nsyn_nmul (void)
13876 enum neon_shape rs = neon_select_shape (NS_FFF, NS_DDD, NS_NULL);
13877 neon_check_type (3, rs, N_EQK | N_VFP, N_EQK | N_VFP,
13878 N_F32 | N_F64 | N_KEY | N_VFP);
13882 NEON_ENCODE (SINGLE, inst);
13883 do_vfp_sp_dyadic ();
13887 NEON_ENCODE (DOUBLE, inst);
13888 do_vfp_dp_rd_rn_rm ();
13890 do_vfp_cond_or_thumb ();
13894 do_vfp_nsyn_cmp (void)
13896 if (inst.operands[1].isreg)
13898 enum neon_shape rs = neon_select_shape (NS_FF, NS_DD, NS_NULL);
13899 neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
13903 NEON_ENCODE (SINGLE, inst);
13904 do_vfp_sp_monadic ();
13908 NEON_ENCODE (DOUBLE, inst);
13909 do_vfp_dp_rd_rm ();
13914 enum neon_shape rs = neon_select_shape (NS_FI, NS_DI, NS_NULL);
13915 neon_check_type (2, rs, N_F32 | N_F64 | N_KEY | N_VFP, N_EQK);
13917 switch (inst.instruction & 0x0fffffff)
13920 inst.instruction += N_MNEM_vcmpz - N_MNEM_vcmp;
13923 inst.instruction += N_MNEM_vcmpez - N_MNEM_vcmpe;
13931 NEON_ENCODE (SINGLE, inst);
13932 do_vfp_sp_compare_z ();
13936 NEON_ENCODE (DOUBLE, inst);
13940 do_vfp_cond_or_thumb ();
13944 nsyn_insert_sp (void)
13946 inst.operands[1] = inst.operands[0];
13947 memset (&inst.operands[0], '\0', sizeof (inst.operands[0]));
13948 inst.operands[0].reg = REG_SP;
13949 inst.operands[0].isreg = 1;
13950 inst.operands[0].writeback = 1;
13951 inst.operands[0].present = 1;
13955 do_vfp_nsyn_push (void)
13958 if (inst.operands[1].issingle)
13959 do_vfp_nsyn_opcode ("fstmdbs");
13961 do_vfp_nsyn_opcode ("fstmdbd");
13965 do_vfp_nsyn_pop (void)
13968 if (inst.operands[1].issingle)
13969 do_vfp_nsyn_opcode ("fldmias");
13971 do_vfp_nsyn_opcode ("fldmiad");
13974 /* Fix up Neon data-processing instructions, ORing in the correct bits for
13975 ARM mode or Thumb mode and moving the encoded bit 24 to bit 28. */
13978 neon_dp_fixup (struct arm_it* insn)
13980 unsigned int i = insn->instruction;
13985 /* The U bit is at bit 24 by default. Move to bit 28 in Thumb mode. */
13996 insn->instruction = i;
13999 /* Turn a size (8, 16, 32, 64) into the respective bit number minus 3
14003 neon_logbits (unsigned x)
14005 return ffs (x) - 4;
14008 #define LOW4(R) ((R) & 0xf)
14009 #define HI1(R) (((R) >> 4) & 1)
14011 /* Encode insns with bit pattern:
14013 |28/24|23|22 |21 20|19 16|15 12|11 8|7|6|5|4|3 0|
14014 | U |x |D |size | Rn | Rd |x x x x|N|Q|M|x| Rm |
14016 SIZE is passed in bits. -1 means size field isn't changed, in case it has a
14017 different meaning for some instruction. */
14020 neon_three_same (int isquad, int ubit, int size)
14022 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14023 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14024 inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
14025 inst.instruction |= HI1 (inst.operands[1].reg) << 7;
14026 inst.instruction |= LOW4 (inst.operands[2].reg);
14027 inst.instruction |= HI1 (inst.operands[2].reg) << 5;
14028 inst.instruction |= (isquad != 0) << 6;
14029 inst.instruction |= (ubit != 0) << 24;
14031 inst.instruction |= neon_logbits (size) << 20;
14033 neon_dp_fixup (&inst);
14036 /* Encode instructions of the form:
14038 |28/24|23|22|21 20|19 18|17 16|15 12|11 7|6|5|4|3 0|
14039 | U |x |D |x x |size |x x | Rd |x x x x x|Q|M|x| Rm |
14041 Don't write size if SIZE == -1. */
14044 neon_two_same (int qbit, int ubit, int size)
14046 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14047 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14048 inst.instruction |= LOW4 (inst.operands[1].reg);
14049 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14050 inst.instruction |= (qbit != 0) << 6;
14051 inst.instruction |= (ubit != 0) << 24;
14054 inst.instruction |= neon_logbits (size) << 18;
14056 neon_dp_fixup (&inst);
14059 /* Neon instruction encoders, in approximate order of appearance. */
14062 do_neon_dyadic_i_su (void)
14064 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14065 struct neon_type_el et = neon_check_type (3, rs,
14066 N_EQK, N_EQK, N_SU_32 | N_KEY);
14067 neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
14071 do_neon_dyadic_i64_su (void)
14073 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14074 struct neon_type_el et = neon_check_type (3, rs,
14075 N_EQK, N_EQK, N_SU_ALL | N_KEY);
14076 neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
14080 neon_imm_shift (int write_ubit, int uval, int isquad, struct neon_type_el et,
14083 unsigned size = et.size >> 3;
14084 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14085 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14086 inst.instruction |= LOW4 (inst.operands[1].reg);
14087 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14088 inst.instruction |= (isquad != 0) << 6;
14089 inst.instruction |= immbits << 16;
14090 inst.instruction |= (size >> 3) << 7;
14091 inst.instruction |= (size & 0x7) << 19;
14093 inst.instruction |= (uval != 0) << 24;
14095 neon_dp_fixup (&inst);
14099 do_neon_shl_imm (void)
14101 if (!inst.operands[2].isreg)
14103 enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14104 struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_KEY | N_I_ALL);
14105 NEON_ENCODE (IMMED, inst);
14106 neon_imm_shift (FALSE, 0, neon_quad (rs), et, inst.operands[2].imm);
14110 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14111 struct neon_type_el et = neon_check_type (3, rs,
14112 N_EQK, N_SU_ALL | N_KEY, N_EQK | N_SGN);
14115 /* VSHL/VQSHL 3-register variants have syntax such as:
14117 whereas other 3-register operations encoded by neon_three_same have
14120 (i.e. with Dn & Dm reversed). Swap operands[1].reg and operands[2].reg
14122 tmp = inst.operands[2].reg;
14123 inst.operands[2].reg = inst.operands[1].reg;
14124 inst.operands[1].reg = tmp;
14125 NEON_ENCODE (INTEGER, inst);
14126 neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
14131 do_neon_qshl_imm (void)
14133 if (!inst.operands[2].isreg)
14135 enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14136 struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_ALL | N_KEY);
14138 NEON_ENCODE (IMMED, inst);
14139 neon_imm_shift (TRUE, et.type == NT_unsigned, neon_quad (rs), et,
14140 inst.operands[2].imm);
14144 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14145 struct neon_type_el et = neon_check_type (3, rs,
14146 N_EQK, N_SU_ALL | N_KEY, N_EQK | N_SGN);
14149 /* See note in do_neon_shl_imm. */
14150 tmp = inst.operands[2].reg;
14151 inst.operands[2].reg = inst.operands[1].reg;
14152 inst.operands[1].reg = tmp;
14153 NEON_ENCODE (INTEGER, inst);
14154 neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
14159 do_neon_rshl (void)
14161 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14162 struct neon_type_el et = neon_check_type (3, rs,
14163 N_EQK, N_EQK, N_SU_ALL | N_KEY);
14166 tmp = inst.operands[2].reg;
14167 inst.operands[2].reg = inst.operands[1].reg;
14168 inst.operands[1].reg = tmp;
14169 neon_three_same (neon_quad (rs), et.type == NT_unsigned, et.size);
14173 neon_cmode_for_logic_imm (unsigned immediate, unsigned *immbits, int size)
14175 /* Handle .I8 pseudo-instructions. */
14178 /* Unfortunately, this will make everything apart from zero out-of-range.
14179 FIXME is this the intended semantics? There doesn't seem much point in
14180 accepting .I8 if so. */
14181 immediate |= immediate << 8;
14187 if (immediate == (immediate & 0x000000ff))
14189 *immbits = immediate;
14192 else if (immediate == (immediate & 0x0000ff00))
14194 *immbits = immediate >> 8;
14197 else if (immediate == (immediate & 0x00ff0000))
14199 *immbits = immediate >> 16;
14202 else if (immediate == (immediate & 0xff000000))
14204 *immbits = immediate >> 24;
14207 if ((immediate & 0xffff) != (immediate >> 16))
14208 goto bad_immediate;
14209 immediate &= 0xffff;
14212 if (immediate == (immediate & 0x000000ff))
14214 *immbits = immediate;
14217 else if (immediate == (immediate & 0x0000ff00))
14219 *immbits = immediate >> 8;
14224 first_error (_("immediate value out of range"));
14229 do_neon_logic (void)
14231 if (inst.operands[2].present && inst.operands[2].isreg)
14233 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14234 neon_check_type (3, rs, N_IGNORE_TYPE);
14235 /* U bit and size field were set as part of the bitmask. */
14236 NEON_ENCODE (INTEGER, inst);
14237 neon_three_same (neon_quad (rs), 0, -1);
14241 const int three_ops_form = (inst.operands[2].present
14242 && !inst.operands[2].isreg);
14243 const int immoperand = (three_ops_form ? 2 : 1);
14244 enum neon_shape rs = (three_ops_form
14245 ? neon_select_shape (NS_DDI, NS_QQI, NS_NULL)
14246 : neon_select_shape (NS_DI, NS_QI, NS_NULL));
14247 struct neon_type_el et = neon_check_type (2, rs,
14248 N_I8 | N_I16 | N_I32 | N_I64 | N_F32 | N_KEY, N_EQK);
14249 enum neon_opc opcode = (enum neon_opc) inst.instruction & 0x0fffffff;
14253 if (et.type == NT_invtype)
14256 if (three_ops_form)
14257 constraint (inst.operands[0].reg != inst.operands[1].reg,
14258 _("first and second operands shall be the same register"));
14260 NEON_ENCODE (IMMED, inst);
14262 immbits = inst.operands[immoperand].imm;
14265 /* .i64 is a pseudo-op, so the immediate must be a repeating
14267 if (immbits != (inst.operands[immoperand].regisimm ?
14268 inst.operands[immoperand].reg : 0))
14270 /* Set immbits to an invalid constant. */
14271 immbits = 0xdeadbeef;
14278 cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
14282 cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
14286 /* Pseudo-instruction for VBIC. */
14287 neon_invert_size (&immbits, 0, et.size);
14288 cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
14292 /* Pseudo-instruction for VORR. */
14293 neon_invert_size (&immbits, 0, et.size);
14294 cmode = neon_cmode_for_logic_imm (immbits, &immbits, et.size);
14304 inst.instruction |= neon_quad (rs) << 6;
14305 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14306 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14307 inst.instruction |= cmode << 8;
14308 neon_write_immbits (immbits);
14310 neon_dp_fixup (&inst);
14315 do_neon_bitfield (void)
14317 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14318 neon_check_type (3, rs, N_IGNORE_TYPE);
14319 neon_three_same (neon_quad (rs), 0, -1);
14323 neon_dyadic_misc (enum neon_el_type ubit_meaning, unsigned types,
14326 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14327 struct neon_type_el et = neon_check_type (3, rs, N_EQK | destbits, N_EQK,
14329 if (et.type == NT_float)
14331 NEON_ENCODE (FLOAT, inst);
14332 neon_three_same (neon_quad (rs), 0, -1);
14336 NEON_ENCODE (INTEGER, inst);
14337 neon_three_same (neon_quad (rs), et.type == ubit_meaning, et.size);
14342 do_neon_dyadic_if_su (void)
14344 neon_dyadic_misc (NT_unsigned, N_SUF_32, 0);
14348 do_neon_dyadic_if_su_d (void)
14350 /* This version only allow D registers, but that constraint is enforced during
14351 operand parsing so we don't need to do anything extra here. */
14352 neon_dyadic_misc (NT_unsigned, N_SUF_32, 0);
14356 do_neon_dyadic_if_i_d (void)
14358 /* The "untyped" case can't happen. Do this to stop the "U" bit being
14359 affected if we specify unsigned args. */
14360 neon_dyadic_misc (NT_untyped, N_IF_32, 0);
14363 enum vfp_or_neon_is_neon_bits
14366 NEON_CHECK_ARCH = 2,
14367 NEON_CHECK_ARCH8 = 4
14370 /* Call this function if an instruction which may have belonged to the VFP or
14371 Neon instruction sets, but turned out to be a Neon instruction (due to the
14372 operand types involved, etc.). We have to check and/or fix-up a couple of
14375 - Make sure the user hasn't attempted to make a Neon instruction
14377 - Alter the value in the condition code field if necessary.
14378 - Make sure that the arch supports Neon instructions.
14380 Which of these operations take place depends on bits from enum
14381 vfp_or_neon_is_neon_bits.
14383 WARNING: This function has side effects! If NEON_CHECK_CC is used and the
14384 current instruction's condition is COND_ALWAYS, the condition field is
14385 changed to inst.uncond_value. This is necessary because instructions shared
14386 between VFP and Neon may be conditional for the VFP variants only, and the
14387 unconditional Neon version must have, e.g., 0xF in the condition field. */
14390 vfp_or_neon_is_neon (unsigned check)
14392 /* Conditions are always legal in Thumb mode (IT blocks). */
14393 if (!thumb_mode && (check & NEON_CHECK_CC))
14395 if (inst.cond != COND_ALWAYS)
14397 first_error (_(BAD_COND));
14400 if (inst.uncond_value != -1)
14401 inst.instruction |= inst.uncond_value << 28;
14404 if ((check & NEON_CHECK_ARCH)
14405 && !mark_feature_used (&fpu_neon_ext_v1))
14407 first_error (_(BAD_FPU));
14411 if ((check & NEON_CHECK_ARCH8)
14412 && !mark_feature_used (&fpu_neon_ext_armv8))
14414 first_error (_(BAD_FPU));
14422 do_neon_addsub_if_i (void)
14424 if (try_vfp_nsyn (3, do_vfp_nsyn_add_sub) == SUCCESS)
14427 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14430 /* The "untyped" case can't happen. Do this to stop the "U" bit being
14431 affected if we specify unsigned args. */
14432 neon_dyadic_misc (NT_untyped, N_IF_32 | N_I64, 0);
14435 /* Swaps operands 1 and 2. If operand 1 (optional arg) was omitted, we want the
14437 V<op> A,B (A is operand 0, B is operand 2)
14442 so handle that case specially. */
14445 neon_exchange_operands (void)
14447 void *scratch = alloca (sizeof (inst.operands[0]));
14448 if (inst.operands[1].present)
14450 /* Swap operands[1] and operands[2]. */
14451 memcpy (scratch, &inst.operands[1], sizeof (inst.operands[0]));
14452 inst.operands[1] = inst.operands[2];
14453 memcpy (&inst.operands[2], scratch, sizeof (inst.operands[0]));
14457 inst.operands[1] = inst.operands[2];
14458 inst.operands[2] = inst.operands[0];
14463 neon_compare (unsigned regtypes, unsigned immtypes, int invert)
14465 if (inst.operands[2].isreg)
14468 neon_exchange_operands ();
14469 neon_dyadic_misc (NT_unsigned, regtypes, N_SIZ);
14473 enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14474 struct neon_type_el et = neon_check_type (2, rs,
14475 N_EQK | N_SIZ, immtypes | N_KEY);
14477 NEON_ENCODE (IMMED, inst);
14478 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14479 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14480 inst.instruction |= LOW4 (inst.operands[1].reg);
14481 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14482 inst.instruction |= neon_quad (rs) << 6;
14483 inst.instruction |= (et.type == NT_float) << 10;
14484 inst.instruction |= neon_logbits (et.size) << 18;
14486 neon_dp_fixup (&inst);
14493 neon_compare (N_SUF_32, N_S8 | N_S16 | N_S32 | N_F32, FALSE);
14497 do_neon_cmp_inv (void)
14499 neon_compare (N_SUF_32, N_S8 | N_S16 | N_S32 | N_F32, TRUE);
14505 neon_compare (N_IF_32, N_IF_32, FALSE);
14508 /* For multiply instructions, we have the possibility of 16-bit or 32-bit
14509 scalars, which are encoded in 5 bits, M : Rm.
14510 For 16-bit scalars, the register is encoded in Rm[2:0] and the index in
14511 M:Rm[3], and for 32-bit scalars, the register is encoded in Rm[3:0] and the
14515 neon_scalar_for_mul (unsigned scalar, unsigned elsize)
14517 unsigned regno = NEON_SCALAR_REG (scalar);
14518 unsigned elno = NEON_SCALAR_INDEX (scalar);
14523 if (regno > 7 || elno > 3)
14525 return regno | (elno << 3);
14528 if (regno > 15 || elno > 1)
14530 return regno | (elno << 4);
14534 first_error (_("scalar out of range for multiply instruction"));
14540 /* Encode multiply / multiply-accumulate scalar instructions. */
14543 neon_mul_mac (struct neon_type_el et, int ubit)
14547 /* Give a more helpful error message if we have an invalid type. */
14548 if (et.type == NT_invtype)
14551 scalar = neon_scalar_for_mul (inst.operands[2].reg, et.size);
14552 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14553 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14554 inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
14555 inst.instruction |= HI1 (inst.operands[1].reg) << 7;
14556 inst.instruction |= LOW4 (scalar);
14557 inst.instruction |= HI1 (scalar) << 5;
14558 inst.instruction |= (et.type == NT_float) << 8;
14559 inst.instruction |= neon_logbits (et.size) << 20;
14560 inst.instruction |= (ubit != 0) << 24;
14562 neon_dp_fixup (&inst);
14566 do_neon_mac_maybe_scalar (void)
14568 if (try_vfp_nsyn (3, do_vfp_nsyn_mla_mls) == SUCCESS)
14571 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14574 if (inst.operands[2].isscalar)
14576 enum neon_shape rs = neon_select_shape (NS_DDS, NS_QQS, NS_NULL);
14577 struct neon_type_el et = neon_check_type (3, rs,
14578 N_EQK, N_EQK, N_I16 | N_I32 | N_F32 | N_KEY);
14579 NEON_ENCODE (SCALAR, inst);
14580 neon_mul_mac (et, neon_quad (rs));
14584 /* The "untyped" case can't happen. Do this to stop the "U" bit being
14585 affected if we specify unsigned args. */
14586 neon_dyadic_misc (NT_untyped, N_IF_32, 0);
14591 do_neon_fmac (void)
14593 if (try_vfp_nsyn (3, do_vfp_nsyn_fma_fms) == SUCCESS)
14596 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14599 neon_dyadic_misc (NT_untyped, N_IF_32, 0);
14605 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14606 struct neon_type_el et = neon_check_type (3, rs,
14607 N_EQK, N_EQK, N_8 | N_16 | N_32 | N_KEY);
14608 neon_three_same (neon_quad (rs), 0, et.size);
14611 /* VMUL with 3 registers allows the P8 type. The scalar version supports the
14612 same types as the MAC equivalents. The polynomial type for this instruction
14613 is encoded the same as the integer type. */
14618 if (try_vfp_nsyn (3, do_vfp_nsyn_mul) == SUCCESS)
14621 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14624 if (inst.operands[2].isscalar)
14625 do_neon_mac_maybe_scalar ();
14627 neon_dyadic_misc (NT_poly, N_I8 | N_I16 | N_I32 | N_F32 | N_P8, 0);
14631 do_neon_qdmulh (void)
14633 if (inst.operands[2].isscalar)
14635 enum neon_shape rs = neon_select_shape (NS_DDS, NS_QQS, NS_NULL);
14636 struct neon_type_el et = neon_check_type (3, rs,
14637 N_EQK, N_EQK, N_S16 | N_S32 | N_KEY);
14638 NEON_ENCODE (SCALAR, inst);
14639 neon_mul_mac (et, neon_quad (rs));
14643 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14644 struct neon_type_el et = neon_check_type (3, rs,
14645 N_EQK, N_EQK, N_S16 | N_S32 | N_KEY);
14646 NEON_ENCODE (INTEGER, inst);
14647 /* The U bit (rounding) comes from bit mask. */
14648 neon_three_same (neon_quad (rs), 0, et.size);
14653 do_neon_fcmp_absolute (void)
14655 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14656 neon_check_type (3, rs, N_EQK, N_EQK, N_F32 | N_KEY);
14657 /* Size field comes from bit mask. */
14658 neon_three_same (neon_quad (rs), 1, -1);
14662 do_neon_fcmp_absolute_inv (void)
14664 neon_exchange_operands ();
14665 do_neon_fcmp_absolute ();
14669 do_neon_step (void)
14671 enum neon_shape rs = neon_select_shape (NS_DDD, NS_QQQ, NS_NULL);
14672 neon_check_type (3, rs, N_EQK, N_EQK, N_F32 | N_KEY);
14673 neon_three_same (neon_quad (rs), 0, -1);
14677 do_neon_abs_neg (void)
14679 enum neon_shape rs;
14680 struct neon_type_el et;
14682 if (try_vfp_nsyn (2, do_vfp_nsyn_abs_neg) == SUCCESS)
14685 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
14688 rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
14689 et = neon_check_type (2, rs, N_EQK, N_S8 | N_S16 | N_S32 | N_F32 | N_KEY);
14691 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14692 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14693 inst.instruction |= LOW4 (inst.operands[1].reg);
14694 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14695 inst.instruction |= neon_quad (rs) << 6;
14696 inst.instruction |= (et.type == NT_float) << 10;
14697 inst.instruction |= neon_logbits (et.size) << 18;
14699 neon_dp_fixup (&inst);
14705 enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14706 struct neon_type_el et = neon_check_type (2, rs,
14707 N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
14708 int imm = inst.operands[2].imm;
14709 constraint (imm < 0 || (unsigned)imm >= et.size,
14710 _("immediate out of range for insert"));
14711 neon_imm_shift (FALSE, 0, neon_quad (rs), et, imm);
14717 enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14718 struct neon_type_el et = neon_check_type (2, rs,
14719 N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
14720 int imm = inst.operands[2].imm;
14721 constraint (imm < 1 || (unsigned)imm > et.size,
14722 _("immediate out of range for insert"));
14723 neon_imm_shift (FALSE, 0, neon_quad (rs), et, et.size - imm);
14727 do_neon_qshlu_imm (void)
14729 enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
14730 struct neon_type_el et = neon_check_type (2, rs,
14731 N_EQK | N_UNS, N_S8 | N_S16 | N_S32 | N_S64 | N_KEY);
14732 int imm = inst.operands[2].imm;
14733 constraint (imm < 0 || (unsigned)imm >= et.size,
14734 _("immediate out of range for shift"));
14735 /* Only encodes the 'U present' variant of the instruction.
14736 In this case, signed types have OP (bit 8) set to 0.
14737 Unsigned types have OP set to 1. */
14738 inst.instruction |= (et.type == NT_unsigned) << 8;
14739 /* The rest of the bits are the same as other immediate shifts. */
14740 neon_imm_shift (FALSE, 0, neon_quad (rs), et, imm);
14744 do_neon_qmovn (void)
14746 struct neon_type_el et = neon_check_type (2, NS_DQ,
14747 N_EQK | N_HLF, N_SU_16_64 | N_KEY);
14748 /* Saturating move where operands can be signed or unsigned, and the
14749 destination has the same signedness. */
14750 NEON_ENCODE (INTEGER, inst);
14751 if (et.type == NT_unsigned)
14752 inst.instruction |= 0xc0;
14754 inst.instruction |= 0x80;
14755 neon_two_same (0, 1, et.size / 2);
14759 do_neon_qmovun (void)
14761 struct neon_type_el et = neon_check_type (2, NS_DQ,
14762 N_EQK | N_HLF | N_UNS, N_S16 | N_S32 | N_S64 | N_KEY);
14763 /* Saturating move with unsigned results. Operands must be signed. */
14764 NEON_ENCODE (INTEGER, inst);
14765 neon_two_same (0, 1, et.size / 2);
14769 do_neon_rshift_sat_narrow (void)
14771 /* FIXME: Types for narrowing. If operands are signed, results can be signed
14772 or unsigned. If operands are unsigned, results must also be unsigned. */
14773 struct neon_type_el et = neon_check_type (2, NS_DQI,
14774 N_EQK | N_HLF, N_SU_16_64 | N_KEY);
14775 int imm = inst.operands[2].imm;
14776 /* This gets the bounds check, size encoding and immediate bits calculation
14780 /* VQ{R}SHRN.I<size> <Dd>, <Qm>, #0 is a synonym for
14781 VQMOVN.I<size> <Dd>, <Qm>. */
14784 inst.operands[2].present = 0;
14785 inst.instruction = N_MNEM_vqmovn;
14790 constraint (imm < 1 || (unsigned)imm > et.size,
14791 _("immediate out of range"));
14792 neon_imm_shift (TRUE, et.type == NT_unsigned, 0, et, et.size - imm);
14796 do_neon_rshift_sat_narrow_u (void)
14798 /* FIXME: Types for narrowing. If operands are signed, results can be signed
14799 or unsigned. If operands are unsigned, results must also be unsigned. */
14800 struct neon_type_el et = neon_check_type (2, NS_DQI,
14801 N_EQK | N_HLF | N_UNS, N_S16 | N_S32 | N_S64 | N_KEY);
14802 int imm = inst.operands[2].imm;
14803 /* This gets the bounds check, size encoding and immediate bits calculation
14807 /* VQSHRUN.I<size> <Dd>, <Qm>, #0 is a synonym for
14808 VQMOVUN.I<size> <Dd>, <Qm>. */
14811 inst.operands[2].present = 0;
14812 inst.instruction = N_MNEM_vqmovun;
14817 constraint (imm < 1 || (unsigned)imm > et.size,
14818 _("immediate out of range"));
14819 /* FIXME: The manual is kind of unclear about what value U should have in
14820 VQ{R}SHRUN instructions, but U=0, op=0 definitely encodes VRSHR, so it
14822 neon_imm_shift (TRUE, 1, 0, et, et.size - imm);
14826 do_neon_movn (void)
14828 struct neon_type_el et = neon_check_type (2, NS_DQ,
14829 N_EQK | N_HLF, N_I16 | N_I32 | N_I64 | N_KEY);
14830 NEON_ENCODE (INTEGER, inst);
14831 neon_two_same (0, 1, et.size / 2);
14835 do_neon_rshift_narrow (void)
14837 struct neon_type_el et = neon_check_type (2, NS_DQI,
14838 N_EQK | N_HLF, N_I16 | N_I32 | N_I64 | N_KEY);
14839 int imm = inst.operands[2].imm;
14840 /* This gets the bounds check, size encoding and immediate bits calculation
14844 /* If immediate is zero then we are a pseudo-instruction for
14845 VMOVN.I<size> <Dd>, <Qm> */
14848 inst.operands[2].present = 0;
14849 inst.instruction = N_MNEM_vmovn;
14854 constraint (imm < 1 || (unsigned)imm > et.size,
14855 _("immediate out of range for narrowing operation"));
14856 neon_imm_shift (FALSE, 0, 0, et, et.size - imm);
14860 do_neon_shll (void)
14862 /* FIXME: Type checking when lengthening. */
14863 struct neon_type_el et = neon_check_type (2, NS_QDI,
14864 N_EQK | N_DBL, N_I8 | N_I16 | N_I32 | N_KEY);
14865 unsigned imm = inst.operands[2].imm;
14867 if (imm == et.size)
14869 /* Maximum shift variant. */
14870 NEON_ENCODE (INTEGER, inst);
14871 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
14872 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
14873 inst.instruction |= LOW4 (inst.operands[1].reg);
14874 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
14875 inst.instruction |= neon_logbits (et.size) << 18;
14877 neon_dp_fixup (&inst);
14881 /* A more-specific type check for non-max versions. */
14882 et = neon_check_type (2, NS_QDI,
14883 N_EQK | N_DBL, N_SU_32 | N_KEY);
14884 NEON_ENCODE (IMMED, inst);
14885 neon_imm_shift (TRUE, et.type == NT_unsigned, 0, et, imm);
14889 /* Check the various types for the VCVT instruction, and return which version
14890 the current instruction is. */
14892 #define CVT_FLAVOUR_VAR \
14893 CVT_VAR (s32_f32, N_S32, N_F32, whole_reg, "ftosls", "ftosis", "ftosizs") \
14894 CVT_VAR (u32_f32, N_U32, N_F32, whole_reg, "ftouls", "ftouis", "ftouizs") \
14895 CVT_VAR (f32_s32, N_F32, N_S32, whole_reg, "fsltos", "fsitos", NULL) \
14896 CVT_VAR (f32_u32, N_F32, N_U32, whole_reg, "fultos", "fuitos", NULL) \
14897 /* Half-precision conversions. */ \
14898 CVT_VAR (f32_f16, N_F32, N_F16, whole_reg, NULL, NULL, NULL) \
14899 CVT_VAR (f16_f32, N_F16, N_F32, whole_reg, NULL, NULL, NULL) \
14900 /* VFP instructions. */ \
14901 CVT_VAR (f32_f64, N_F32, N_F64, N_VFP, NULL, "fcvtsd", NULL) \
14902 CVT_VAR (f64_f32, N_F64, N_F32, N_VFP, NULL, "fcvtds", NULL) \
14903 CVT_VAR (s32_f64, N_S32, N_F64 | key, N_VFP, "ftosld", "ftosid", "ftosizd") \
14904 CVT_VAR (u32_f64, N_U32, N_F64 | key, N_VFP, "ftould", "ftouid", "ftouizd") \
14905 CVT_VAR (f64_s32, N_F64 | key, N_S32, N_VFP, "fsltod", "fsitod", NULL) \
14906 CVT_VAR (f64_u32, N_F64 | key, N_U32, N_VFP, "fultod", "fuitod", NULL) \
14907 /* VFP instructions with bitshift. */ \
14908 CVT_VAR (f32_s16, N_F32 | key, N_S16, N_VFP, "fshtos", NULL, NULL) \
14909 CVT_VAR (f32_u16, N_F32 | key, N_U16, N_VFP, "fuhtos", NULL, NULL) \
14910 CVT_VAR (f64_s16, N_F64 | key, N_S16, N_VFP, "fshtod", NULL, NULL) \
14911 CVT_VAR (f64_u16, N_F64 | key, N_U16, N_VFP, "fuhtod", NULL, NULL) \
14912 CVT_VAR (s16_f32, N_S16, N_F32 | key, N_VFP, "ftoshs", NULL, NULL) \
14913 CVT_VAR (u16_f32, N_U16, N_F32 | key, N_VFP, "ftouhs", NULL, NULL) \
14914 CVT_VAR (s16_f64, N_S16, N_F64 | key, N_VFP, "ftoshd", NULL, NULL) \
14915 CVT_VAR (u16_f64, N_U16, N_F64 | key, N_VFP, "ftouhd", NULL, NULL)
14917 #define CVT_VAR(C, X, Y, R, BSN, CN, ZN) \
14918 neon_cvt_flavour_##C,
14920 /* The different types of conversions we can do. */
14921 enum neon_cvt_flavour
14924 neon_cvt_flavour_invalid,
14925 neon_cvt_flavour_first_fp = neon_cvt_flavour_f32_f64
14930 static enum neon_cvt_flavour
14931 get_neon_cvt_flavour (enum neon_shape rs)
14933 #define CVT_VAR(C,X,Y,R,BSN,CN,ZN) \
14934 et = neon_check_type (2, rs, (R) | (X), (R) | (Y)); \
14935 if (et.type != NT_invtype) \
14937 inst.error = NULL; \
14938 return (neon_cvt_flavour_##C); \
14941 struct neon_type_el et;
14942 unsigned whole_reg = (rs == NS_FFI || rs == NS_FD || rs == NS_DF
14943 || rs == NS_FF) ? N_VFP : 0;
14944 /* The instruction versions which take an immediate take one register
14945 argument, which is extended to the width of the full register. Thus the
14946 "source" and "destination" registers must have the same width. Hack that
14947 here by making the size equal to the key (wider, in this case) operand. */
14948 unsigned key = (rs == NS_QQI || rs == NS_DDI || rs == NS_FFI) ? N_KEY : 0;
14952 return neon_cvt_flavour_invalid;
14967 /* Neon-syntax VFP conversions. */
14970 do_vfp_nsyn_cvt (enum neon_shape rs, enum neon_cvt_flavour flavour)
14972 const char *opname = 0;
14974 if (rs == NS_DDI || rs == NS_QQI || rs == NS_FFI)
14976 /* Conversions with immediate bitshift. */
14977 const char *enc[] =
14979 #define CVT_VAR(C,A,B,R,BSN,CN,ZN) BSN,
14985 if (flavour < (int) ARRAY_SIZE (enc))
14987 opname = enc[flavour];
14988 constraint (inst.operands[0].reg != inst.operands[1].reg,
14989 _("operands 0 and 1 must be the same register"));
14990 inst.operands[1] = inst.operands[2];
14991 memset (&inst.operands[2], '\0', sizeof (inst.operands[2]));
14996 /* Conversions without bitshift. */
14997 const char *enc[] =
14999 #define CVT_VAR(C,A,B,R,BSN,CN,ZN) CN,
15005 if (flavour < (int) ARRAY_SIZE (enc))
15006 opname = enc[flavour];
15010 do_vfp_nsyn_opcode (opname);
15014 do_vfp_nsyn_cvtz (void)
15016 enum neon_shape rs = neon_select_shape (NS_FF, NS_FD, NS_NULL);
15017 enum neon_cvt_flavour flavour = get_neon_cvt_flavour (rs);
15018 const char *enc[] =
15020 #define CVT_VAR(C,A,B,R,BSN,CN,ZN) ZN,
15026 if (flavour < (int) ARRAY_SIZE (enc) && enc[flavour])
15027 do_vfp_nsyn_opcode (enc[flavour]);
15031 do_vfp_nsyn_cvt_fpv8 (enum neon_cvt_flavour flavour,
15032 enum neon_cvt_mode mode)
15037 /* Targets like FPv5-SP-D16 don't support FP v8 instructions with
15038 D register operands. */
15039 if (flavour == neon_cvt_flavour_s32_f64
15040 || flavour == neon_cvt_flavour_u32_f64)
15041 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
15044 set_it_insn_type (OUTSIDE_IT_INSN);
15048 case neon_cvt_flavour_s32_f64:
15052 case neon_cvt_flavour_s32_f32:
15056 case neon_cvt_flavour_u32_f64:
15060 case neon_cvt_flavour_u32_f32:
15065 first_error (_("invalid instruction shape"));
15071 case neon_cvt_mode_a: rm = 0; break;
15072 case neon_cvt_mode_n: rm = 1; break;
15073 case neon_cvt_mode_p: rm = 2; break;
15074 case neon_cvt_mode_m: rm = 3; break;
15075 default: first_error (_("invalid rounding mode")); return;
15078 NEON_ENCODE (FPV8, inst);
15079 encode_arm_vfp_reg (inst.operands[0].reg, VFP_REG_Sd);
15080 encode_arm_vfp_reg (inst.operands[1].reg, sz == 1 ? VFP_REG_Dm : VFP_REG_Sm);
15081 inst.instruction |= sz << 8;
15082 inst.instruction |= op << 7;
15083 inst.instruction |= rm << 16;
15084 inst.instruction |= 0xf0000000;
15085 inst.is_neon = TRUE;
15089 do_neon_cvt_1 (enum neon_cvt_mode mode)
15091 enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_FFI, NS_DD, NS_QQ,
15092 NS_FD, NS_DF, NS_FF, NS_QD, NS_DQ, NS_NULL);
15093 enum neon_cvt_flavour flavour = get_neon_cvt_flavour (rs);
15095 /* PR11109: Handle round-to-zero for VCVT conversions. */
15096 if (mode == neon_cvt_mode_z
15097 && ARM_CPU_HAS_FEATURE (cpu_variant, fpu_arch_vfp_v2)
15098 && (flavour == neon_cvt_flavour_s32_f32
15099 || flavour == neon_cvt_flavour_u32_f32
15100 || flavour == neon_cvt_flavour_s32_f64
15101 || flavour == neon_cvt_flavour_u32_f64)
15102 && (rs == NS_FD || rs == NS_FF))
15104 do_vfp_nsyn_cvtz ();
15108 /* VFP rather than Neon conversions. */
15109 if (flavour >= neon_cvt_flavour_first_fp)
15111 if (mode == neon_cvt_mode_x || mode == neon_cvt_mode_z)
15112 do_vfp_nsyn_cvt (rs, flavour);
15114 do_vfp_nsyn_cvt_fpv8 (flavour, mode);
15125 unsigned enctab[] = { 0x0000100, 0x1000100, 0x0, 0x1000000 };
15127 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15130 /* Fixed-point conversion with #0 immediate is encoded as an
15131 integer conversion. */
15132 if (inst.operands[2].present && inst.operands[2].imm == 0)
15134 immbits = 32 - inst.operands[2].imm;
15135 NEON_ENCODE (IMMED, inst);
15136 if (flavour != neon_cvt_flavour_invalid)
15137 inst.instruction |= enctab[flavour];
15138 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15139 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15140 inst.instruction |= LOW4 (inst.operands[1].reg);
15141 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15142 inst.instruction |= neon_quad (rs) << 6;
15143 inst.instruction |= 1 << 21;
15144 inst.instruction |= immbits << 16;
15146 neon_dp_fixup (&inst);
15152 if (mode != neon_cvt_mode_x && mode != neon_cvt_mode_z)
15154 NEON_ENCODE (FLOAT, inst);
15155 set_it_insn_type (OUTSIDE_IT_INSN);
15157 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH8) == FAIL)
15160 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15161 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15162 inst.instruction |= LOW4 (inst.operands[1].reg);
15163 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15164 inst.instruction |= neon_quad (rs) << 6;
15165 inst.instruction |= (flavour == neon_cvt_flavour_u32_f32) << 7;
15166 inst.instruction |= mode << 8;
15168 inst.instruction |= 0xfc000000;
15170 inst.instruction |= 0xf0000000;
15176 unsigned enctab[] = { 0x100, 0x180, 0x0, 0x080 };
15178 NEON_ENCODE (INTEGER, inst);
15180 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15183 if (flavour != neon_cvt_flavour_invalid)
15184 inst.instruction |= enctab[flavour];
15186 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15187 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15188 inst.instruction |= LOW4 (inst.operands[1].reg);
15189 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15190 inst.instruction |= neon_quad (rs) << 6;
15191 inst.instruction |= 2 << 18;
15193 neon_dp_fixup (&inst);
15198 /* Half-precision conversions for Advanced SIMD -- neon. */
15203 && (inst.vectype.el[0].size != 16 || inst.vectype.el[1].size != 32))
15205 as_bad (_("operand size must match register width"));
15210 && ((inst.vectype.el[0].size != 32 || inst.vectype.el[1].size != 16)))
15212 as_bad (_("operand size must match register width"));
15217 inst.instruction = 0x3b60600;
15219 inst.instruction = 0x3b60700;
15221 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15222 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15223 inst.instruction |= LOW4 (inst.operands[1].reg);
15224 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15225 neon_dp_fixup (&inst);
15229 /* Some VFP conversions go here (s32 <-> f32, u32 <-> f32). */
15230 if (mode == neon_cvt_mode_x || mode == neon_cvt_mode_z)
15231 do_vfp_nsyn_cvt (rs, flavour);
15233 do_vfp_nsyn_cvt_fpv8 (flavour, mode);
15238 do_neon_cvtr (void)
15240 do_neon_cvt_1 (neon_cvt_mode_x);
15246 do_neon_cvt_1 (neon_cvt_mode_z);
15250 do_neon_cvta (void)
15252 do_neon_cvt_1 (neon_cvt_mode_a);
15256 do_neon_cvtn (void)
15258 do_neon_cvt_1 (neon_cvt_mode_n);
15262 do_neon_cvtp (void)
15264 do_neon_cvt_1 (neon_cvt_mode_p);
15268 do_neon_cvtm (void)
15270 do_neon_cvt_1 (neon_cvt_mode_m);
15274 do_neon_cvttb_2 (bfd_boolean t, bfd_boolean to, bfd_boolean is_double)
15277 mark_feature_used (&fpu_vfp_ext_armv8);
15279 encode_arm_vfp_reg (inst.operands[0].reg,
15280 (is_double && !to) ? VFP_REG_Dd : VFP_REG_Sd);
15281 encode_arm_vfp_reg (inst.operands[1].reg,
15282 (is_double && to) ? VFP_REG_Dm : VFP_REG_Sm);
15283 inst.instruction |= to ? 0x10000 : 0;
15284 inst.instruction |= t ? 0x80 : 0;
15285 inst.instruction |= is_double ? 0x100 : 0;
15286 do_vfp_cond_or_thumb ();
15290 do_neon_cvttb_1 (bfd_boolean t)
15292 enum neon_shape rs = neon_select_shape (NS_FF, NS_FD, NS_DF, NS_NULL);
15296 else if (neon_check_type (2, rs, N_F16, N_F32 | N_VFP).type != NT_invtype)
15299 do_neon_cvttb_2 (t, /*to=*/TRUE, /*is_double=*/FALSE);
15301 else if (neon_check_type (2, rs, N_F32 | N_VFP, N_F16).type != NT_invtype)
15304 do_neon_cvttb_2 (t, /*to=*/FALSE, /*is_double=*/FALSE);
15306 else if (neon_check_type (2, rs, N_F16, N_F64 | N_VFP).type != NT_invtype)
15308 /* The VCVTB and VCVTT instructions with D-register operands
15309 don't work for SP only targets. */
15310 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
15314 do_neon_cvttb_2 (t, /*to=*/TRUE, /*is_double=*/TRUE);
15316 else if (neon_check_type (2, rs, N_F64 | N_VFP, N_F16).type != NT_invtype)
15318 /* The VCVTB and VCVTT instructions with D-register operands
15319 don't work for SP only targets. */
15320 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
15324 do_neon_cvttb_2 (t, /*to=*/FALSE, /*is_double=*/TRUE);
15331 do_neon_cvtb (void)
15333 do_neon_cvttb_1 (FALSE);
15338 do_neon_cvtt (void)
15340 do_neon_cvttb_1 (TRUE);
15344 neon_move_immediate (void)
15346 enum neon_shape rs = neon_select_shape (NS_DI, NS_QI, NS_NULL);
15347 struct neon_type_el et = neon_check_type (2, rs,
15348 N_I8 | N_I16 | N_I32 | N_I64 | N_F32 | N_KEY, N_EQK);
15349 unsigned immlo, immhi = 0, immbits;
15350 int op, cmode, float_p;
15352 constraint (et.type == NT_invtype,
15353 _("operand size must be specified for immediate VMOV"));
15355 /* We start out as an MVN instruction if OP = 1, MOV otherwise. */
15356 op = (inst.instruction & (1 << 5)) != 0;
15358 immlo = inst.operands[1].imm;
15359 if (inst.operands[1].regisimm)
15360 immhi = inst.operands[1].reg;
15362 constraint (et.size < 32 && (immlo & ~((1 << et.size) - 1)) != 0,
15363 _("immediate has bits set outside the operand size"));
15365 float_p = inst.operands[1].immisfloat;
15367 if ((cmode = neon_cmode_for_move_imm (immlo, immhi, float_p, &immbits, &op,
15368 et.size, et.type)) == FAIL)
15370 /* Invert relevant bits only. */
15371 neon_invert_size (&immlo, &immhi, et.size);
15372 /* Flip from VMOV/VMVN to VMVN/VMOV. Some immediate types are unavailable
15373 with one or the other; those cases are caught by
15374 neon_cmode_for_move_imm. */
15376 if ((cmode = neon_cmode_for_move_imm (immlo, immhi, float_p, &immbits,
15377 &op, et.size, et.type)) == FAIL)
15379 first_error (_("immediate out of range"));
15384 inst.instruction &= ~(1 << 5);
15385 inst.instruction |= op << 5;
15387 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15388 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15389 inst.instruction |= neon_quad (rs) << 6;
15390 inst.instruction |= cmode << 8;
15392 neon_write_immbits (immbits);
15398 if (inst.operands[1].isreg)
15400 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15402 NEON_ENCODE (INTEGER, inst);
15403 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15404 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15405 inst.instruction |= LOW4 (inst.operands[1].reg);
15406 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15407 inst.instruction |= neon_quad (rs) << 6;
15411 NEON_ENCODE (IMMED, inst);
15412 neon_move_immediate ();
15415 neon_dp_fixup (&inst);
15418 /* Encode instructions of form:
15420 |28/24|23|22|21 20|19 16|15 12|11 8|7|6|5|4|3 0|
15421 | U |x |D |size | Rn | Rd |x x x x|N|x|M|x| Rm | */
15424 neon_mixed_length (struct neon_type_el et, unsigned size)
15426 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15427 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15428 inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15429 inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15430 inst.instruction |= LOW4 (inst.operands[2].reg);
15431 inst.instruction |= HI1 (inst.operands[2].reg) << 5;
15432 inst.instruction |= (et.type == NT_unsigned) << 24;
15433 inst.instruction |= neon_logbits (size) << 20;
15435 neon_dp_fixup (&inst);
15439 do_neon_dyadic_long (void)
15441 /* FIXME: Type checking for lengthening op. */
15442 struct neon_type_el et = neon_check_type (3, NS_QDD,
15443 N_EQK | N_DBL, N_EQK, N_SU_32 | N_KEY);
15444 neon_mixed_length (et, et.size);
15448 do_neon_abal (void)
15450 struct neon_type_el et = neon_check_type (3, NS_QDD,
15451 N_EQK | N_INT | N_DBL, N_EQK, N_SU_32 | N_KEY);
15452 neon_mixed_length (et, et.size);
15456 neon_mac_reg_scalar_long (unsigned regtypes, unsigned scalartypes)
15458 if (inst.operands[2].isscalar)
15460 struct neon_type_el et = neon_check_type (3, NS_QDS,
15461 N_EQK | N_DBL, N_EQK, regtypes | N_KEY);
15462 NEON_ENCODE (SCALAR, inst);
15463 neon_mul_mac (et, et.type == NT_unsigned);
15467 struct neon_type_el et = neon_check_type (3, NS_QDD,
15468 N_EQK | N_DBL, N_EQK, scalartypes | N_KEY);
15469 NEON_ENCODE (INTEGER, inst);
15470 neon_mixed_length (et, et.size);
15475 do_neon_mac_maybe_scalar_long (void)
15477 neon_mac_reg_scalar_long (N_S16 | N_S32 | N_U16 | N_U32, N_SU_32);
15481 do_neon_dyadic_wide (void)
15483 struct neon_type_el et = neon_check_type (3, NS_QQD,
15484 N_EQK | N_DBL, N_EQK | N_DBL, N_SU_32 | N_KEY);
15485 neon_mixed_length (et, et.size);
15489 do_neon_dyadic_narrow (void)
15491 struct neon_type_el et = neon_check_type (3, NS_QDD,
15492 N_EQK | N_DBL, N_EQK, N_I16 | N_I32 | N_I64 | N_KEY);
15493 /* Operand sign is unimportant, and the U bit is part of the opcode,
15494 so force the operand type to integer. */
15495 et.type = NT_integer;
15496 neon_mixed_length (et, et.size / 2);
15500 do_neon_mul_sat_scalar_long (void)
15502 neon_mac_reg_scalar_long (N_S16 | N_S32, N_S16 | N_S32);
15506 do_neon_vmull (void)
15508 if (inst.operands[2].isscalar)
15509 do_neon_mac_maybe_scalar_long ();
15512 struct neon_type_el et = neon_check_type (3, NS_QDD,
15513 N_EQK | N_DBL, N_EQK, N_SU_32 | N_P8 | N_P64 | N_KEY);
15515 if (et.type == NT_poly)
15516 NEON_ENCODE (POLY, inst);
15518 NEON_ENCODE (INTEGER, inst);
15520 /* For polynomial encoding the U bit must be zero, and the size must
15521 be 8 (encoded as 0b00) or, on ARMv8 or later 64 (encoded, non
15522 obviously, as 0b10). */
15525 /* Check we're on the correct architecture. */
15526 if (!mark_feature_used (&fpu_crypto_ext_armv8))
15528 _("Instruction form not available on this architecture.");
15533 neon_mixed_length (et, et.size);
15540 enum neon_shape rs = neon_select_shape (NS_DDDI, NS_QQQI, NS_NULL);
15541 struct neon_type_el et = neon_check_type (3, rs,
15542 N_EQK, N_EQK, N_8 | N_16 | N_32 | N_64 | N_KEY);
15543 unsigned imm = (inst.operands[3].imm * et.size) / 8;
15545 constraint (imm >= (unsigned) (neon_quad (rs) ? 16 : 8),
15546 _("shift out of range"));
15547 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15548 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15549 inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15550 inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15551 inst.instruction |= LOW4 (inst.operands[2].reg);
15552 inst.instruction |= HI1 (inst.operands[2].reg) << 5;
15553 inst.instruction |= neon_quad (rs) << 6;
15554 inst.instruction |= imm << 8;
15556 neon_dp_fixup (&inst);
15562 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15563 struct neon_type_el et = neon_check_type (2, rs,
15564 N_EQK, N_8 | N_16 | N_32 | N_KEY);
15565 unsigned op = (inst.instruction >> 7) & 3;
15566 /* N (width of reversed regions) is encoded as part of the bitmask. We
15567 extract it here to check the elements to be reversed are smaller.
15568 Otherwise we'd get a reserved instruction. */
15569 unsigned elsize = (op == 2) ? 16 : (op == 1) ? 32 : (op == 0) ? 64 : 0;
15570 gas_assert (elsize != 0);
15571 constraint (et.size >= elsize,
15572 _("elements must be smaller than reversal region"));
15573 neon_two_same (neon_quad (rs), 1, et.size);
15579 if (inst.operands[1].isscalar)
15581 enum neon_shape rs = neon_select_shape (NS_DS, NS_QS, NS_NULL);
15582 struct neon_type_el et = neon_check_type (2, rs,
15583 N_EQK, N_8 | N_16 | N_32 | N_KEY);
15584 unsigned sizebits = et.size >> 3;
15585 unsigned dm = NEON_SCALAR_REG (inst.operands[1].reg);
15586 int logsize = neon_logbits (et.size);
15587 unsigned x = NEON_SCALAR_INDEX (inst.operands[1].reg) << logsize;
15589 if (vfp_or_neon_is_neon (NEON_CHECK_CC) == FAIL)
15592 NEON_ENCODE (SCALAR, inst);
15593 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15594 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15595 inst.instruction |= LOW4 (dm);
15596 inst.instruction |= HI1 (dm) << 5;
15597 inst.instruction |= neon_quad (rs) << 6;
15598 inst.instruction |= x << 17;
15599 inst.instruction |= sizebits << 16;
15601 neon_dp_fixup (&inst);
15605 enum neon_shape rs = neon_select_shape (NS_DR, NS_QR, NS_NULL);
15606 struct neon_type_el et = neon_check_type (2, rs,
15607 N_8 | N_16 | N_32 | N_KEY, N_EQK);
15608 /* Duplicate ARM register to lanes of vector. */
15609 NEON_ENCODE (ARMREG, inst);
15612 case 8: inst.instruction |= 0x400000; break;
15613 case 16: inst.instruction |= 0x000020; break;
15614 case 32: inst.instruction |= 0x000000; break;
15617 inst.instruction |= LOW4 (inst.operands[1].reg) << 12;
15618 inst.instruction |= LOW4 (inst.operands[0].reg) << 16;
15619 inst.instruction |= HI1 (inst.operands[0].reg) << 7;
15620 inst.instruction |= neon_quad (rs) << 21;
15621 /* The encoding for this instruction is identical for the ARM and Thumb
15622 variants, except for the condition field. */
15623 do_vfp_cond_or_thumb ();
15627 /* VMOV has particularly many variations. It can be one of:
15628 0. VMOV<c><q> <Qd>, <Qm>
15629 1. VMOV<c><q> <Dd>, <Dm>
15630 (Register operations, which are VORR with Rm = Rn.)
15631 2. VMOV<c><q>.<dt> <Qd>, #<imm>
15632 3. VMOV<c><q>.<dt> <Dd>, #<imm>
15634 4. VMOV<c><q>.<size> <Dn[x]>, <Rd>
15635 (ARM register to scalar.)
15636 5. VMOV<c><q> <Dm>, <Rd>, <Rn>
15637 (Two ARM registers to vector.)
15638 6. VMOV<c><q>.<dt> <Rd>, <Dn[x]>
15639 (Scalar to ARM register.)
15640 7. VMOV<c><q> <Rd>, <Rn>, <Dm>
15641 (Vector to two ARM registers.)
15642 8. VMOV.F32 <Sd>, <Sm>
15643 9. VMOV.F64 <Dd>, <Dm>
15644 (VFP register moves.)
15645 10. VMOV.F32 <Sd>, #imm
15646 11. VMOV.F64 <Dd>, #imm
15647 (VFP float immediate load.)
15648 12. VMOV <Rd>, <Sm>
15649 (VFP single to ARM reg.)
15650 13. VMOV <Sd>, <Rm>
15651 (ARM reg to VFP single.)
15652 14. VMOV <Rd>, <Re>, <Sn>, <Sm>
15653 (Two ARM regs to two VFP singles.)
15654 15. VMOV <Sd>, <Se>, <Rn>, <Rm>
15655 (Two VFP singles to two ARM regs.)
15657 These cases can be disambiguated using neon_select_shape, except cases 1/9
15658 and 3/11 which depend on the operand type too.
15660 All the encoded bits are hardcoded by this function.
15662 Cases 4, 6 may be used with VFPv1 and above (only 32-bit transfers!).
15663 Cases 5, 7 may be used with VFPv2 and above.
15665 FIXME: Some of the checking may be a bit sloppy (in a couple of cases you
15666 can specify a type where it doesn't make sense to, and is ignored). */
15671 enum neon_shape rs = neon_select_shape (NS_RRFF, NS_FFRR, NS_DRR, NS_RRD,
15672 NS_QQ, NS_DD, NS_QI, NS_DI, NS_SR, NS_RS, NS_FF, NS_FI, NS_RF, NS_FR,
15674 struct neon_type_el et;
15675 const char *ldconst = 0;
15679 case NS_DD: /* case 1/9. */
15680 et = neon_check_type (2, rs, N_EQK, N_F64 | N_KEY);
15681 /* It is not an error here if no type is given. */
15683 if (et.type == NT_float && et.size == 64)
15685 do_vfp_nsyn_opcode ("fcpyd");
15688 /* fall through. */
15690 case NS_QQ: /* case 0/1. */
15692 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15694 /* The architecture manual I have doesn't explicitly state which
15695 value the U bit should have for register->register moves, but
15696 the equivalent VORR instruction has U = 0, so do that. */
15697 inst.instruction = 0x0200110;
15698 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
15699 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
15700 inst.instruction |= LOW4 (inst.operands[1].reg);
15701 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
15702 inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
15703 inst.instruction |= HI1 (inst.operands[1].reg) << 7;
15704 inst.instruction |= neon_quad (rs) << 6;
15706 neon_dp_fixup (&inst);
15710 case NS_DI: /* case 3/11. */
15711 et = neon_check_type (2, rs, N_EQK, N_F64 | N_KEY);
15713 if (et.type == NT_float && et.size == 64)
15715 /* case 11 (fconstd). */
15716 ldconst = "fconstd";
15717 goto encode_fconstd;
15719 /* fall through. */
15721 case NS_QI: /* case 2/3. */
15722 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH) == FAIL)
15724 inst.instruction = 0x0800010;
15725 neon_move_immediate ();
15726 neon_dp_fixup (&inst);
15729 case NS_SR: /* case 4. */
15731 unsigned bcdebits = 0;
15733 unsigned dn = NEON_SCALAR_REG (inst.operands[0].reg);
15734 unsigned x = NEON_SCALAR_INDEX (inst.operands[0].reg);
15736 /* .<size> is optional here, defaulting to .32. */
15737 if (inst.vectype.elems == 0
15738 && inst.operands[0].vectype.type == NT_invtype
15739 && inst.operands[1].vectype.type == NT_invtype)
15741 inst.vectype.el[0].type = NT_untyped;
15742 inst.vectype.el[0].size = 32;
15743 inst.vectype.elems = 1;
15746 et = neon_check_type (2, NS_NULL, N_8 | N_16 | N_32 | N_KEY, N_EQK);
15747 logsize = neon_logbits (et.size);
15749 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v1),
15751 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_v1)
15752 && et.size != 32, _(BAD_FPU));
15753 constraint (et.type == NT_invtype, _("bad type for scalar"));
15754 constraint (x >= 64 / et.size, _("scalar index out of range"));
15758 case 8: bcdebits = 0x8; break;
15759 case 16: bcdebits = 0x1; break;
15760 case 32: bcdebits = 0x0; break;
15764 bcdebits |= x << logsize;
15766 inst.instruction = 0xe000b10;
15767 do_vfp_cond_or_thumb ();
15768 inst.instruction |= LOW4 (dn) << 16;
15769 inst.instruction |= HI1 (dn) << 7;
15770 inst.instruction |= inst.operands[1].reg << 12;
15771 inst.instruction |= (bcdebits & 3) << 5;
15772 inst.instruction |= (bcdebits >> 2) << 21;
15776 case NS_DRR: /* case 5 (fmdrr). */
15777 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v2),
15780 inst.instruction = 0xc400b10;
15781 do_vfp_cond_or_thumb ();
15782 inst.instruction |= LOW4 (inst.operands[0].reg);
15783 inst.instruction |= HI1 (inst.operands[0].reg) << 5;
15784 inst.instruction |= inst.operands[1].reg << 12;
15785 inst.instruction |= inst.operands[2].reg << 16;
15788 case NS_RS: /* case 6. */
15791 unsigned dn = NEON_SCALAR_REG (inst.operands[1].reg);
15792 unsigned x = NEON_SCALAR_INDEX (inst.operands[1].reg);
15793 unsigned abcdebits = 0;
15795 /* .<dt> is optional here, defaulting to .32. */
15796 if (inst.vectype.elems == 0
15797 && inst.operands[0].vectype.type == NT_invtype
15798 && inst.operands[1].vectype.type == NT_invtype)
15800 inst.vectype.el[0].type = NT_untyped;
15801 inst.vectype.el[0].size = 32;
15802 inst.vectype.elems = 1;
15805 et = neon_check_type (2, NS_NULL,
15806 N_EQK, N_S8 | N_S16 | N_U8 | N_U16 | N_32 | N_KEY);
15807 logsize = neon_logbits (et.size);
15809 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v1),
15811 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_neon_ext_v1)
15812 && et.size != 32, _(BAD_FPU));
15813 constraint (et.type == NT_invtype, _("bad type for scalar"));
15814 constraint (x >= 64 / et.size, _("scalar index out of range"));
15818 case 8: abcdebits = (et.type == NT_signed) ? 0x08 : 0x18; break;
15819 case 16: abcdebits = (et.type == NT_signed) ? 0x01 : 0x11; break;
15820 case 32: abcdebits = 0x00; break;
15824 abcdebits |= x << logsize;
15825 inst.instruction = 0xe100b10;
15826 do_vfp_cond_or_thumb ();
15827 inst.instruction |= LOW4 (dn) << 16;
15828 inst.instruction |= HI1 (dn) << 7;
15829 inst.instruction |= inst.operands[0].reg << 12;
15830 inst.instruction |= (abcdebits & 3) << 5;
15831 inst.instruction |= (abcdebits >> 2) << 21;
15835 case NS_RRD: /* case 7 (fmrrd). */
15836 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_v2),
15839 inst.instruction = 0xc500b10;
15840 do_vfp_cond_or_thumb ();
15841 inst.instruction |= inst.operands[0].reg << 12;
15842 inst.instruction |= inst.operands[1].reg << 16;
15843 inst.instruction |= LOW4 (inst.operands[2].reg);
15844 inst.instruction |= HI1 (inst.operands[2].reg) << 5;
15847 case NS_FF: /* case 8 (fcpys). */
15848 do_vfp_nsyn_opcode ("fcpys");
15851 case NS_FI: /* case 10 (fconsts). */
15852 ldconst = "fconsts";
15854 if (is_quarter_float (inst.operands[1].imm))
15856 inst.operands[1].imm = neon_qfloat_bits (inst.operands[1].imm);
15857 do_vfp_nsyn_opcode (ldconst);
15860 first_error (_("immediate out of range"));
15863 case NS_RF: /* case 12 (fmrs). */
15864 do_vfp_nsyn_opcode ("fmrs");
15867 case NS_FR: /* case 13 (fmsr). */
15868 do_vfp_nsyn_opcode ("fmsr");
15871 /* The encoders for the fmrrs and fmsrr instructions expect three operands
15872 (one of which is a list), but we have parsed four. Do some fiddling to
15873 make the operands what do_vfp_reg2_from_sp2 and do_vfp_sp2_from_reg2
15875 case NS_RRFF: /* case 14 (fmrrs). */
15876 constraint (inst.operands[3].reg != inst.operands[2].reg + 1,
15877 _("VFP registers must be adjacent"));
15878 inst.operands[2].imm = 2;
15879 memset (&inst.operands[3], '\0', sizeof (inst.operands[3]));
15880 do_vfp_nsyn_opcode ("fmrrs");
15883 case NS_FFRR: /* case 15 (fmsrr). */
15884 constraint (inst.operands[1].reg != inst.operands[0].reg + 1,
15885 _("VFP registers must be adjacent"));
15886 inst.operands[1] = inst.operands[2];
15887 inst.operands[2] = inst.operands[3];
15888 inst.operands[0].imm = 2;
15889 memset (&inst.operands[3], '\0', sizeof (inst.operands[3]));
15890 do_vfp_nsyn_opcode ("fmsrr");
15894 /* neon_select_shape has determined that the instruction
15895 shape is wrong and has already set the error message. */
15904 do_neon_rshift_round_imm (void)
15906 enum neon_shape rs = neon_select_shape (NS_DDI, NS_QQI, NS_NULL);
15907 struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_ALL | N_KEY);
15908 int imm = inst.operands[2].imm;
15910 /* imm == 0 case is encoded as VMOV for V{R}SHR. */
15913 inst.operands[2].present = 0;
15918 constraint (imm < 1 || (unsigned)imm > et.size,
15919 _("immediate out of range for shift"));
15920 neon_imm_shift (TRUE, et.type == NT_unsigned, neon_quad (rs), et,
15925 do_neon_movl (void)
15927 struct neon_type_el et = neon_check_type (2, NS_QD,
15928 N_EQK | N_DBL, N_SU_32 | N_KEY);
15929 unsigned sizebits = et.size >> 3;
15930 inst.instruction |= sizebits << 19;
15931 neon_two_same (0, et.type == NT_unsigned, -1);
15937 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15938 struct neon_type_el et = neon_check_type (2, rs,
15939 N_EQK, N_8 | N_16 | N_32 | N_KEY);
15940 NEON_ENCODE (INTEGER, inst);
15941 neon_two_same (neon_quad (rs), 1, et.size);
15945 do_neon_zip_uzp (void)
15947 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15948 struct neon_type_el et = neon_check_type (2, rs,
15949 N_EQK, N_8 | N_16 | N_32 | N_KEY);
15950 if (rs == NS_DD && et.size == 32)
15952 /* Special case: encode as VTRN.32 <Dd>, <Dm>. */
15953 inst.instruction = N_MNEM_vtrn;
15957 neon_two_same (neon_quad (rs), 1, et.size);
15961 do_neon_sat_abs_neg (void)
15963 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15964 struct neon_type_el et = neon_check_type (2, rs,
15965 N_EQK, N_S8 | N_S16 | N_S32 | N_KEY);
15966 neon_two_same (neon_quad (rs), 1, et.size);
15970 do_neon_pair_long (void)
15972 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15973 struct neon_type_el et = neon_check_type (2, rs, N_EQK, N_SU_32 | N_KEY);
15974 /* Unsigned is encoded in OP field (bit 7) for these instruction. */
15975 inst.instruction |= (et.type == NT_unsigned) << 7;
15976 neon_two_same (neon_quad (rs), 1, et.size);
15980 do_neon_recip_est (void)
15982 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15983 struct neon_type_el et = neon_check_type (2, rs,
15984 N_EQK | N_FLT, N_F32 | N_U32 | N_KEY);
15985 inst.instruction |= (et.type == NT_float) << 8;
15986 neon_two_same (neon_quad (rs), 1, et.size);
15992 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
15993 struct neon_type_el et = neon_check_type (2, rs,
15994 N_EQK, N_S8 | N_S16 | N_S32 | N_KEY);
15995 neon_two_same (neon_quad (rs), 1, et.size);
16001 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
16002 struct neon_type_el et = neon_check_type (2, rs,
16003 N_EQK, N_I8 | N_I16 | N_I32 | N_KEY);
16004 neon_two_same (neon_quad (rs), 1, et.size);
16010 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
16011 struct neon_type_el et = neon_check_type (2, rs,
16012 N_EQK | N_INT, N_8 | N_KEY);
16013 neon_two_same (neon_quad (rs), 1, et.size);
16019 enum neon_shape rs = neon_select_shape (NS_DD, NS_QQ, NS_NULL);
16020 neon_two_same (neon_quad (rs), 1, -1);
16024 do_neon_tbl_tbx (void)
16026 unsigned listlenbits;
16027 neon_check_type (3, NS_DLD, N_EQK, N_EQK, N_8 | N_KEY);
16029 if (inst.operands[1].imm < 1 || inst.operands[1].imm > 4)
16031 first_error (_("bad list length for table lookup"));
16035 listlenbits = inst.operands[1].imm - 1;
16036 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16037 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16038 inst.instruction |= LOW4 (inst.operands[1].reg) << 16;
16039 inst.instruction |= HI1 (inst.operands[1].reg) << 7;
16040 inst.instruction |= LOW4 (inst.operands[2].reg);
16041 inst.instruction |= HI1 (inst.operands[2].reg) << 5;
16042 inst.instruction |= listlenbits << 8;
16044 neon_dp_fixup (&inst);
16048 do_neon_ldm_stm (void)
16050 /* P, U and L bits are part of bitmask. */
16051 int is_dbmode = (inst.instruction & (1 << 24)) != 0;
16052 unsigned offsetbits = inst.operands[1].imm * 2;
16054 if (inst.operands[1].issingle)
16056 do_vfp_nsyn_ldm_stm (is_dbmode);
16060 constraint (is_dbmode && !inst.operands[0].writeback,
16061 _("writeback (!) must be used for VLDMDB and VSTMDB"));
16063 constraint (inst.operands[1].imm < 1 || inst.operands[1].imm > 16,
16064 _("register list must contain at least 1 and at most 16 "
16067 inst.instruction |= inst.operands[0].reg << 16;
16068 inst.instruction |= inst.operands[0].writeback << 21;
16069 inst.instruction |= LOW4 (inst.operands[1].reg) << 12;
16070 inst.instruction |= HI1 (inst.operands[1].reg) << 22;
16072 inst.instruction |= offsetbits;
16074 do_vfp_cond_or_thumb ();
16078 do_neon_ldr_str (void)
16080 int is_ldr = (inst.instruction & (1 << 20)) != 0;
16082 /* Use of PC in vstr in ARM mode is deprecated in ARMv7.
16083 And is UNPREDICTABLE in thumb mode. */
16085 && inst.operands[1].reg == REG_PC
16086 && (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v7) || thumb_mode))
16089 inst.error = _("Use of PC here is UNPREDICTABLE");
16090 else if (warn_on_deprecated)
16091 as_warn (_("Use of PC here is deprecated"));
16094 if (inst.operands[0].issingle)
16097 do_vfp_nsyn_opcode ("flds");
16099 do_vfp_nsyn_opcode ("fsts");
16104 do_vfp_nsyn_opcode ("fldd");
16106 do_vfp_nsyn_opcode ("fstd");
16110 /* "interleave" version also handles non-interleaving register VLD1/VST1
16114 do_neon_ld_st_interleave (void)
16116 struct neon_type_el et = neon_check_type (1, NS_NULL,
16117 N_8 | N_16 | N_32 | N_64);
16118 unsigned alignbits = 0;
16120 /* The bits in this table go:
16121 0: register stride of one (0) or two (1)
16122 1,2: register list length, minus one (1, 2, 3, 4).
16123 3,4: <n> in instruction type, minus one (VLD<n> / VST<n>).
16124 We use -1 for invalid entries. */
16125 const int typetable[] =
16127 0x7, -1, 0xa, -1, 0x6, -1, 0x2, -1, /* VLD1 / VST1. */
16128 -1, -1, 0x8, 0x9, -1, -1, 0x3, -1, /* VLD2 / VST2. */
16129 -1, -1, -1, -1, 0x4, 0x5, -1, -1, /* VLD3 / VST3. */
16130 -1, -1, -1, -1, -1, -1, 0x0, 0x1 /* VLD4 / VST4. */
16134 if (et.type == NT_invtype)
16137 if (inst.operands[1].immisalign)
16138 switch (inst.operands[1].imm >> 8)
16140 case 64: alignbits = 1; break;
16142 if (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 2
16143 && NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4)
16144 goto bad_alignment;
16148 if (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4)
16149 goto bad_alignment;
16154 first_error (_("bad alignment"));
16158 inst.instruction |= alignbits << 4;
16159 inst.instruction |= neon_logbits (et.size) << 6;
16161 /* Bits [4:6] of the immediate in a list specifier encode register stride
16162 (minus 1) in bit 4, and list length in bits [5:6]. We put the <n> of
16163 VLD<n>/VST<n> in bits [9:8] of the initial bitmask. Suck it out here, look
16164 up the right value for "type" in a table based on this value and the given
16165 list style, then stick it back. */
16166 idx = ((inst.operands[0].imm >> 4) & 7)
16167 | (((inst.instruction >> 8) & 3) << 3);
16169 typebits = typetable[idx];
16171 constraint (typebits == -1, _("bad list type for instruction"));
16172 constraint (((inst.instruction >> 8) & 3) && et.size == 64,
16173 _("bad element type for instruction"));
16175 inst.instruction &= ~0xf00;
16176 inst.instruction |= typebits << 8;
16179 /* Check alignment is valid for do_neon_ld_st_lane and do_neon_ld_dup.
16180 *DO_ALIGN is set to 1 if the relevant alignment bit should be set, 0
16181 otherwise. The variable arguments are a list of pairs of legal (size, align)
16182 values, terminated with -1. */
16185 neon_alignment_bit (int size, int align, int *do_align, ...)
16188 int result = FAIL, thissize, thisalign;
16190 if (!inst.operands[1].immisalign)
16196 va_start (ap, do_align);
16200 thissize = va_arg (ap, int);
16201 if (thissize == -1)
16203 thisalign = va_arg (ap, int);
16205 if (size == thissize && align == thisalign)
16208 while (result != SUCCESS);
16212 if (result == SUCCESS)
16215 first_error (_("unsupported alignment for instruction"));
16221 do_neon_ld_st_lane (void)
16223 struct neon_type_el et = neon_check_type (1, NS_NULL, N_8 | N_16 | N_32);
16224 int align_good, do_align = 0;
16225 int logsize = neon_logbits (et.size);
16226 int align = inst.operands[1].imm >> 8;
16227 int n = (inst.instruction >> 8) & 3;
16228 int max_el = 64 / et.size;
16230 if (et.type == NT_invtype)
16233 constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != n + 1,
16234 _("bad list length"));
16235 constraint (NEON_LANE (inst.operands[0].imm) >= max_el,
16236 _("scalar index out of range"));
16237 constraint (n != 0 && NEON_REG_STRIDE (inst.operands[0].imm) == 2
16239 _("stride of 2 unavailable when element size is 8"));
16243 case 0: /* VLD1 / VST1. */
16244 align_good = neon_alignment_bit (et.size, align, &do_align, 16, 16,
16246 if (align_good == FAIL)
16250 unsigned alignbits = 0;
16253 case 16: alignbits = 0x1; break;
16254 case 32: alignbits = 0x3; break;
16257 inst.instruction |= alignbits << 4;
16261 case 1: /* VLD2 / VST2. */
16262 align_good = neon_alignment_bit (et.size, align, &do_align, 8, 16, 16, 32,
16264 if (align_good == FAIL)
16267 inst.instruction |= 1 << 4;
16270 case 2: /* VLD3 / VST3. */
16271 constraint (inst.operands[1].immisalign,
16272 _("can't use alignment with this instruction"));
16275 case 3: /* VLD4 / VST4. */
16276 align_good = neon_alignment_bit (et.size, align, &do_align, 8, 32,
16277 16, 64, 32, 64, 32, 128, -1);
16278 if (align_good == FAIL)
16282 unsigned alignbits = 0;
16285 case 8: alignbits = 0x1; break;
16286 case 16: alignbits = 0x1; break;
16287 case 32: alignbits = (align == 64) ? 0x1 : 0x2; break;
16290 inst.instruction |= alignbits << 4;
16297 /* Reg stride of 2 is encoded in bit 5 when size==16, bit 6 when size==32. */
16298 if (n != 0 && NEON_REG_STRIDE (inst.operands[0].imm) == 2)
16299 inst.instruction |= 1 << (4 + logsize);
16301 inst.instruction |= NEON_LANE (inst.operands[0].imm) << (logsize + 5);
16302 inst.instruction |= logsize << 10;
16305 /* Encode single n-element structure to all lanes VLD<n> instructions. */
16308 do_neon_ld_dup (void)
16310 struct neon_type_el et = neon_check_type (1, NS_NULL, N_8 | N_16 | N_32);
16311 int align_good, do_align = 0;
16313 if (et.type == NT_invtype)
16316 switch ((inst.instruction >> 8) & 3)
16318 case 0: /* VLD1. */
16319 gas_assert (NEON_REG_STRIDE (inst.operands[0].imm) != 2);
16320 align_good = neon_alignment_bit (et.size, inst.operands[1].imm >> 8,
16321 &do_align, 16, 16, 32, 32, -1);
16322 if (align_good == FAIL)
16324 switch (NEON_REGLIST_LENGTH (inst.operands[0].imm))
16327 case 2: inst.instruction |= 1 << 5; break;
16328 default: first_error (_("bad list length")); return;
16330 inst.instruction |= neon_logbits (et.size) << 6;
16333 case 1: /* VLD2. */
16334 align_good = neon_alignment_bit (et.size, inst.operands[1].imm >> 8,
16335 &do_align, 8, 16, 16, 32, 32, 64, -1);
16336 if (align_good == FAIL)
16338 constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 2,
16339 _("bad list length"));
16340 if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
16341 inst.instruction |= 1 << 5;
16342 inst.instruction |= neon_logbits (et.size) << 6;
16345 case 2: /* VLD3. */
16346 constraint (inst.operands[1].immisalign,
16347 _("can't use alignment with this instruction"));
16348 constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 3,
16349 _("bad list length"));
16350 if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
16351 inst.instruction |= 1 << 5;
16352 inst.instruction |= neon_logbits (et.size) << 6;
16355 case 3: /* VLD4. */
16357 int align = inst.operands[1].imm >> 8;
16358 align_good = neon_alignment_bit (et.size, align, &do_align, 8, 32,
16359 16, 64, 32, 64, 32, 128, -1);
16360 if (align_good == FAIL)
16362 constraint (NEON_REGLIST_LENGTH (inst.operands[0].imm) != 4,
16363 _("bad list length"));
16364 if (NEON_REG_STRIDE (inst.operands[0].imm) == 2)
16365 inst.instruction |= 1 << 5;
16366 if (et.size == 32 && align == 128)
16367 inst.instruction |= 0x3 << 6;
16369 inst.instruction |= neon_logbits (et.size) << 6;
16376 inst.instruction |= do_align << 4;
16379 /* Disambiguate VLD<n> and VST<n> instructions, and fill in common bits (those
16380 apart from bits [11:4]. */
16383 do_neon_ldx_stx (void)
16385 if (inst.operands[1].isreg)
16386 constraint (inst.operands[1].reg == REG_PC, BAD_PC);
16388 switch (NEON_LANE (inst.operands[0].imm))
16390 case NEON_INTERLEAVE_LANES:
16391 NEON_ENCODE (INTERLV, inst);
16392 do_neon_ld_st_interleave ();
16395 case NEON_ALL_LANES:
16396 NEON_ENCODE (DUP, inst);
16397 if (inst.instruction == N_INV)
16399 first_error ("only loads support such operands");
16406 NEON_ENCODE (LANE, inst);
16407 do_neon_ld_st_lane ();
16410 /* L bit comes from bit mask. */
16411 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16412 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16413 inst.instruction |= inst.operands[1].reg << 16;
16415 if (inst.operands[1].postind)
16417 int postreg = inst.operands[1].imm & 0xf;
16418 constraint (!inst.operands[1].immisreg,
16419 _("post-index must be a register"));
16420 constraint (postreg == 0xd || postreg == 0xf,
16421 _("bad register for post-index"));
16422 inst.instruction |= postreg;
16426 constraint (inst.operands[1].immisreg, BAD_ADDR_MODE);
16427 constraint (inst.reloc.exp.X_op != O_constant
16428 || inst.reloc.exp.X_add_number != 0,
16431 if (inst.operands[1].writeback)
16433 inst.instruction |= 0xd;
16436 inst.instruction |= 0xf;
16440 inst.instruction |= 0xf9000000;
16442 inst.instruction |= 0xf4000000;
16447 do_vfp_nsyn_fpv8 (enum neon_shape rs)
16449 /* Targets like FPv5-SP-D16 don't support FP v8 instructions with
16450 D register operands. */
16451 if (neon_shape_class[rs] == SC_DOUBLE)
16452 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
16455 NEON_ENCODE (FPV8, inst);
16458 do_vfp_sp_dyadic ();
16460 do_vfp_dp_rd_rn_rm ();
16463 inst.instruction |= 0x100;
16465 inst.instruction |= 0xf0000000;
16471 set_it_insn_type (OUTSIDE_IT_INSN);
16473 if (try_vfp_nsyn (3, do_vfp_nsyn_fpv8) != SUCCESS)
16474 first_error (_("invalid instruction shape"));
16480 set_it_insn_type (OUTSIDE_IT_INSN);
16482 if (try_vfp_nsyn (3, do_vfp_nsyn_fpv8) == SUCCESS)
16485 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH8) == FAIL)
16488 neon_dyadic_misc (NT_untyped, N_F32, 0);
16492 do_vrint_1 (enum neon_cvt_mode mode)
16494 enum neon_shape rs = neon_select_shape (NS_FF, NS_DD, NS_QQ, NS_NULL);
16495 struct neon_type_el et;
16500 /* Targets like FPv5-SP-D16 don't support FP v8 instructions with
16501 D register operands. */
16502 if (neon_shape_class[rs] == SC_DOUBLE)
16503 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_vfp_ext_armv8),
16506 et = neon_check_type (2, rs, N_EQK | N_VFP, N_F32 | N_F64 | N_KEY | N_VFP);
16507 if (et.type != NT_invtype)
16509 /* VFP encodings. */
16510 if (mode == neon_cvt_mode_a || mode == neon_cvt_mode_n
16511 || mode == neon_cvt_mode_p || mode == neon_cvt_mode_m)
16512 set_it_insn_type (OUTSIDE_IT_INSN);
16514 NEON_ENCODE (FPV8, inst);
16516 do_vfp_sp_monadic ();
16518 do_vfp_dp_rd_rm ();
16522 case neon_cvt_mode_r: inst.instruction |= 0x00000000; break;
16523 case neon_cvt_mode_z: inst.instruction |= 0x00000080; break;
16524 case neon_cvt_mode_x: inst.instruction |= 0x00010000; break;
16525 case neon_cvt_mode_a: inst.instruction |= 0xf0000000; break;
16526 case neon_cvt_mode_n: inst.instruction |= 0xf0010000; break;
16527 case neon_cvt_mode_p: inst.instruction |= 0xf0020000; break;
16528 case neon_cvt_mode_m: inst.instruction |= 0xf0030000; break;
16532 inst.instruction |= (rs == NS_DD) << 8;
16533 do_vfp_cond_or_thumb ();
16537 /* Neon encodings (or something broken...). */
16539 et = neon_check_type (2, rs, N_EQK, N_F32 | N_KEY);
16541 if (et.type == NT_invtype)
16544 set_it_insn_type (OUTSIDE_IT_INSN);
16545 NEON_ENCODE (FLOAT, inst);
16547 if (vfp_or_neon_is_neon (NEON_CHECK_CC | NEON_CHECK_ARCH8) == FAIL)
16550 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16551 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16552 inst.instruction |= LOW4 (inst.operands[1].reg);
16553 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
16554 inst.instruction |= neon_quad (rs) << 6;
16557 case neon_cvt_mode_z: inst.instruction |= 3 << 7; break;
16558 case neon_cvt_mode_x: inst.instruction |= 1 << 7; break;
16559 case neon_cvt_mode_a: inst.instruction |= 2 << 7; break;
16560 case neon_cvt_mode_n: inst.instruction |= 0 << 7; break;
16561 case neon_cvt_mode_p: inst.instruction |= 7 << 7; break;
16562 case neon_cvt_mode_m: inst.instruction |= 5 << 7; break;
16563 case neon_cvt_mode_r: inst.error = _("invalid rounding mode"); break;
16568 inst.instruction |= 0xfc000000;
16570 inst.instruction |= 0xf0000000;
16577 do_vrint_1 (neon_cvt_mode_x);
16583 do_vrint_1 (neon_cvt_mode_z);
16589 do_vrint_1 (neon_cvt_mode_r);
16595 do_vrint_1 (neon_cvt_mode_a);
16601 do_vrint_1 (neon_cvt_mode_n);
16607 do_vrint_1 (neon_cvt_mode_p);
16613 do_vrint_1 (neon_cvt_mode_m);
16616 /* Crypto v1 instructions. */
16618 do_crypto_2op_1 (unsigned elttype, int op)
16620 set_it_insn_type (OUTSIDE_IT_INSN);
16622 if (neon_check_type (2, NS_QQ, N_EQK | N_UNT, elttype | N_UNT | N_KEY).type
16628 NEON_ENCODE (INTEGER, inst);
16629 inst.instruction |= LOW4 (inst.operands[0].reg) << 12;
16630 inst.instruction |= HI1 (inst.operands[0].reg) << 22;
16631 inst.instruction |= LOW4 (inst.operands[1].reg);
16632 inst.instruction |= HI1 (inst.operands[1].reg) << 5;
16634 inst.instruction |= op << 6;
16637 inst.instruction |= 0xfc000000;
16639 inst.instruction |= 0xf0000000;
16643 do_crypto_3op_1 (int u, int op)
16645 set_it_insn_type (OUTSIDE_IT_INSN);
16647 if (neon_check_type (3, NS_QQQ, N_EQK | N_UNT, N_EQK | N_UNT,
16648 N_32 | N_UNT | N_KEY).type == NT_invtype)
16653 NEON_ENCODE (INTEGER, inst);
16654 neon_three_same (1, u, 8 << op);
16660 do_crypto_2op_1 (N_8, 0);
16666 do_crypto_2op_1 (N_8, 1);
16672 do_crypto_2op_1 (N_8, 2);
16678 do_crypto_2op_1 (N_8, 3);
16684 do_crypto_3op_1 (0, 0);
16690 do_crypto_3op_1 (0, 1);
16696 do_crypto_3op_1 (0, 2);
16702 do_crypto_3op_1 (0, 3);
16708 do_crypto_3op_1 (1, 0);
16714 do_crypto_3op_1 (1, 1);
16718 do_sha256su1 (void)
16720 do_crypto_3op_1 (1, 2);
16726 do_crypto_2op_1 (N_32, -1);
16732 do_crypto_2op_1 (N_32, 0);
16736 do_sha256su0 (void)
16738 do_crypto_2op_1 (N_32, 1);
16742 do_crc32_1 (unsigned int poly, unsigned int sz)
16744 unsigned int Rd = inst.operands[0].reg;
16745 unsigned int Rn = inst.operands[1].reg;
16746 unsigned int Rm = inst.operands[2].reg;
16748 set_it_insn_type (OUTSIDE_IT_INSN);
16749 inst.instruction |= LOW4 (Rd) << (thumb_mode ? 8 : 12);
16750 inst.instruction |= LOW4 (Rn) << 16;
16751 inst.instruction |= LOW4 (Rm);
16752 inst.instruction |= sz << (thumb_mode ? 4 : 21);
16753 inst.instruction |= poly << (thumb_mode ? 20 : 9);
16755 if (Rd == REG_PC || Rn == REG_PC || Rm == REG_PC)
16756 as_warn (UNPRED_REG ("r15"));
16757 if (thumb_mode && (Rd == REG_SP || Rn == REG_SP || Rm == REG_SP))
16758 as_warn (UNPRED_REG ("r13"));
16798 /* Overall per-instruction processing. */
16800 /* We need to be able to fix up arbitrary expressions in some statements.
16801 This is so that we can handle symbols that are an arbitrary distance from
16802 the pc. The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
16803 which returns part of an address in a form which will be valid for
16804 a data instruction. We do this by pushing the expression into a symbol
16805 in the expr_section, and creating a fix for that. */
16808 fix_new_arm (fragS * frag,
16822 /* Create an absolute valued symbol, so we have something to
16823 refer to in the object file. Unfortunately for us, gas's
16824 generic expression parsing will already have folded out
16825 any use of .set foo/.type foo %function that may have
16826 been used to set type information of the target location,
16827 that's being specified symbolically. We have to presume
16828 the user knows what they are doing. */
16832 sprintf (name, "*ABS*0x%lx", (unsigned long)exp->X_add_number);
16834 symbol = symbol_find_or_make (name);
16835 S_SET_SEGMENT (symbol, absolute_section);
16836 symbol_set_frag (symbol, &zero_address_frag);
16837 S_SET_VALUE (symbol, exp->X_add_number);
16838 exp->X_op = O_symbol;
16839 exp->X_add_symbol = symbol;
16840 exp->X_add_number = 0;
16846 new_fix = fix_new_exp (frag, where, size, exp, pc_rel,
16847 (enum bfd_reloc_code_real) reloc);
16851 new_fix = (fixS *) fix_new (frag, where, size, make_expr_symbol (exp), 0,
16852 pc_rel, (enum bfd_reloc_code_real) reloc);
16856 /* Mark whether the fix is to a THUMB instruction, or an ARM
16858 new_fix->tc_fix_data = thumb_mode;
16861 /* Create a frg for an instruction requiring relaxation. */
16863 output_relax_insn (void)
16869 /* The size of the instruction is unknown, so tie the debug info to the
16870 start of the instruction. */
16871 dwarf2_emit_insn (0);
16873 switch (inst.reloc.exp.X_op)
16876 sym = inst.reloc.exp.X_add_symbol;
16877 offset = inst.reloc.exp.X_add_number;
16881 offset = inst.reloc.exp.X_add_number;
16884 sym = make_expr_symbol (&inst.reloc.exp);
16888 to = frag_var (rs_machine_dependent, INSN_SIZE, THUMB_SIZE,
16889 inst.relax, sym, offset, NULL/*offset, opcode*/);
16890 md_number_to_chars (to, inst.instruction, THUMB_SIZE);
16893 /* Write a 32-bit thumb instruction to buf. */
16895 put_thumb32_insn (char * buf, unsigned long insn)
16897 md_number_to_chars (buf, insn >> 16, THUMB_SIZE);
16898 md_number_to_chars (buf + THUMB_SIZE, insn, THUMB_SIZE);
16902 output_inst (const char * str)
16908 as_bad ("%s -- `%s'", inst.error, str);
16913 output_relax_insn ();
16916 if (inst.size == 0)
16919 to = frag_more (inst.size);
16920 /* PR 9814: Record the thumb mode into the current frag so that we know
16921 what type of NOP padding to use, if necessary. We override any previous
16922 setting so that if the mode has changed then the NOPS that we use will
16923 match the encoding of the last instruction in the frag. */
16924 frag_now->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
16926 if (thumb_mode && (inst.size > THUMB_SIZE))
16928 gas_assert (inst.size == (2 * THUMB_SIZE));
16929 put_thumb32_insn (to, inst.instruction);
16931 else if (inst.size > INSN_SIZE)
16933 gas_assert (inst.size == (2 * INSN_SIZE));
16934 md_number_to_chars (to, inst.instruction, INSN_SIZE);
16935 md_number_to_chars (to + INSN_SIZE, inst.instruction, INSN_SIZE);
16938 md_number_to_chars (to, inst.instruction, inst.size);
16940 if (inst.reloc.type != BFD_RELOC_UNUSED)
16941 fix_new_arm (frag_now, to - frag_now->fr_literal,
16942 inst.size, & inst.reloc.exp, inst.reloc.pc_rel,
16945 dwarf2_emit_insn (inst.size);
16949 output_it_inst (int cond, int mask, char * to)
16951 unsigned long instruction = 0xbf00;
16954 instruction |= mask;
16955 instruction |= cond << 4;
16959 to = frag_more (2);
16961 dwarf2_emit_insn (2);
16965 md_number_to_chars (to, instruction, 2);
16970 /* Tag values used in struct asm_opcode's tag field. */
16973 OT_unconditional, /* Instruction cannot be conditionalized.
16974 The ARM condition field is still 0xE. */
16975 OT_unconditionalF, /* Instruction cannot be conditionalized
16976 and carries 0xF in its ARM condition field. */
16977 OT_csuffix, /* Instruction takes a conditional suffix. */
16978 OT_csuffixF, /* Some forms of the instruction take a conditional
16979 suffix, others place 0xF where the condition field
16981 OT_cinfix3, /* Instruction takes a conditional infix,
16982 beginning at character index 3. (In
16983 unified mode, it becomes a suffix.) */
16984 OT_cinfix3_deprecated, /* The same as OT_cinfix3. This is used for
16985 tsts, cmps, cmns, and teqs. */
16986 OT_cinfix3_legacy, /* Legacy instruction takes a conditional infix at
16987 character index 3, even in unified mode. Used for
16988 legacy instructions where suffix and infix forms
16989 may be ambiguous. */
16990 OT_csuf_or_in3, /* Instruction takes either a conditional
16991 suffix or an infix at character index 3. */
16992 OT_odd_infix_unc, /* This is the unconditional variant of an
16993 instruction that takes a conditional infix
16994 at an unusual position. In unified mode,
16995 this variant will accept a suffix. */
16996 OT_odd_infix_0 /* Values greater than or equal to OT_odd_infix_0
16997 are the conditional variants of instructions that
16998 take conditional infixes in unusual positions.
16999 The infix appears at character index
17000 (tag - OT_odd_infix_0). These are not accepted
17001 in unified mode. */
17004 /* Subroutine of md_assemble, responsible for looking up the primary
17005 opcode from the mnemonic the user wrote. STR points to the
17006 beginning of the mnemonic.
17008 This is not simply a hash table lookup, because of conditional
17009 variants. Most instructions have conditional variants, which are
17010 expressed with a _conditional affix_ to the mnemonic. If we were
17011 to encode each conditional variant as a literal string in the opcode
17012 table, it would have approximately 20,000 entries.
17014 Most mnemonics take this affix as a suffix, and in unified syntax,
17015 'most' is upgraded to 'all'. However, in the divided syntax, some
17016 instructions take the affix as an infix, notably the s-variants of
17017 the arithmetic instructions. Of those instructions, all but six
17018 have the infix appear after the third character of the mnemonic.
17020 Accordingly, the algorithm for looking up primary opcodes given
17023 1. Look up the identifier in the opcode table.
17024 If we find a match, go to step U.
17026 2. Look up the last two characters of the identifier in the
17027 conditions table. If we find a match, look up the first N-2
17028 characters of the identifier in the opcode table. If we
17029 find a match, go to step CE.
17031 3. Look up the fourth and fifth characters of the identifier in
17032 the conditions table. If we find a match, extract those
17033 characters from the identifier, and look up the remaining
17034 characters in the opcode table. If we find a match, go
17039 U. Examine the tag field of the opcode structure, in case this is
17040 one of the six instructions with its conditional infix in an
17041 unusual place. If it is, the tag tells us where to find the
17042 infix; look it up in the conditions table and set inst.cond
17043 accordingly. Otherwise, this is an unconditional instruction.
17044 Again set inst.cond accordingly. Return the opcode structure.
17046 CE. Examine the tag field to make sure this is an instruction that
17047 should receive a conditional suffix. If it is not, fail.
17048 Otherwise, set inst.cond from the suffix we already looked up,
17049 and return the opcode structure.
17051 CM. Examine the tag field to make sure this is an instruction that
17052 should receive a conditional infix after the third character.
17053 If it is not, fail. Otherwise, undo the edits to the current
17054 line of input and proceed as for case CE. */
17056 static const struct asm_opcode *
17057 opcode_lookup (char **str)
17061 const struct asm_opcode *opcode;
17062 const struct asm_cond *cond;
17065 /* Scan up to the end of the mnemonic, which must end in white space,
17066 '.' (in unified mode, or for Neon/VFP instructions), or end of string. */
17067 for (base = end = *str; *end != '\0'; end++)
17068 if (*end == ' ' || *end == '.')
17074 /* Handle a possible width suffix and/or Neon type suffix. */
17079 /* The .w and .n suffixes are only valid if the unified syntax is in
17081 if (unified_syntax && end[1] == 'w')
17083 else if (unified_syntax && end[1] == 'n')
17088 inst.vectype.elems = 0;
17090 *str = end + offset;
17092 if (end[offset] == '.')
17094 /* See if we have a Neon type suffix (possible in either unified or
17095 non-unified ARM syntax mode). */
17096 if (parse_neon_type (&inst.vectype, str) == FAIL)
17099 else if (end[offset] != '\0' && end[offset] != ' ')
17105 /* Look for unaffixed or special-case affixed mnemonic. */
17106 opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
17111 if (opcode->tag < OT_odd_infix_0)
17113 inst.cond = COND_ALWAYS;
17117 if (warn_on_deprecated && unified_syntax)
17118 as_warn (_("conditional infixes are deprecated in unified syntax"));
17119 affix = base + (opcode->tag - OT_odd_infix_0);
17120 cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
17123 inst.cond = cond->value;
17127 /* Cannot have a conditional suffix on a mnemonic of less than two
17129 if (end - base < 3)
17132 /* Look for suffixed mnemonic. */
17134 cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
17135 opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
17137 if (opcode && cond)
17140 switch (opcode->tag)
17142 case OT_cinfix3_legacy:
17143 /* Ignore conditional suffixes matched on infix only mnemonics. */
17147 case OT_cinfix3_deprecated:
17148 case OT_odd_infix_unc:
17149 if (!unified_syntax)
17151 /* else fall through */
17155 case OT_csuf_or_in3:
17156 inst.cond = cond->value;
17159 case OT_unconditional:
17160 case OT_unconditionalF:
17162 inst.cond = cond->value;
17165 /* Delayed diagnostic. */
17166 inst.error = BAD_COND;
17167 inst.cond = COND_ALWAYS;
17176 /* Cannot have a usual-position infix on a mnemonic of less than
17177 six characters (five would be a suffix). */
17178 if (end - base < 6)
17181 /* Look for infixed mnemonic in the usual position. */
17183 cond = (const struct asm_cond *) hash_find_n (arm_cond_hsh, affix, 2);
17187 memcpy (save, affix, 2);
17188 memmove (affix, affix + 2, (end - affix) - 2);
17189 opcode = (const struct asm_opcode *) hash_find_n (arm_ops_hsh, base,
17191 memmove (affix + 2, affix, (end - affix) - 2);
17192 memcpy (affix, save, 2);
17195 && (opcode->tag == OT_cinfix3
17196 || opcode->tag == OT_cinfix3_deprecated
17197 || opcode->tag == OT_csuf_or_in3
17198 || opcode->tag == OT_cinfix3_legacy))
17201 if (warn_on_deprecated && unified_syntax
17202 && (opcode->tag == OT_cinfix3
17203 || opcode->tag == OT_cinfix3_deprecated))
17204 as_warn (_("conditional infixes are deprecated in unified syntax"));
17206 inst.cond = cond->value;
17213 /* This function generates an initial IT instruction, leaving its block
17214 virtually open for the new instructions. Eventually,
17215 the mask will be updated by now_it_add_mask () each time
17216 a new instruction needs to be included in the IT block.
17217 Finally, the block is closed with close_automatic_it_block ().
17218 The block closure can be requested either from md_assemble (),
17219 a tencode (), or due to a label hook. */
17222 new_automatic_it_block (int cond)
17224 now_it.state = AUTOMATIC_IT_BLOCK;
17225 now_it.mask = 0x18;
17227 now_it.block_length = 1;
17228 mapping_state (MAP_THUMB);
17229 now_it.insn = output_it_inst (cond, now_it.mask, NULL);
17230 now_it.warn_deprecated = FALSE;
17231 now_it.insn_cond = TRUE;
17234 /* Close an automatic IT block.
17235 See comments in new_automatic_it_block (). */
17238 close_automatic_it_block (void)
17240 now_it.mask = 0x10;
17241 now_it.block_length = 0;
17244 /* Update the mask of the current automatically-generated IT
17245 instruction. See comments in new_automatic_it_block (). */
17248 now_it_add_mask (int cond)
17250 #define CLEAR_BIT(value, nbit) ((value) & ~(1 << (nbit)))
17251 #define SET_BIT_VALUE(value, bitvalue, nbit) (CLEAR_BIT (value, nbit) \
17252 | ((bitvalue) << (nbit)))
17253 const int resulting_bit = (cond & 1);
17255 now_it.mask &= 0xf;
17256 now_it.mask = SET_BIT_VALUE (now_it.mask,
17258 (5 - now_it.block_length));
17259 now_it.mask = SET_BIT_VALUE (now_it.mask,
17261 ((5 - now_it.block_length) - 1) );
17262 output_it_inst (now_it.cc, now_it.mask, now_it.insn);
17265 #undef SET_BIT_VALUE
17268 /* The IT blocks handling machinery is accessed through the these functions:
17269 it_fsm_pre_encode () from md_assemble ()
17270 set_it_insn_type () optional, from the tencode functions
17271 set_it_insn_type_last () ditto
17272 in_it_block () ditto
17273 it_fsm_post_encode () from md_assemble ()
17274 force_automatic_it_block_close () from label habdling functions
17277 1) md_assemble () calls it_fsm_pre_encode () before calling tencode (),
17278 initializing the IT insn type with a generic initial value depending
17279 on the inst.condition.
17280 2) During the tencode function, two things may happen:
17281 a) The tencode function overrides the IT insn type by
17282 calling either set_it_insn_type (type) or set_it_insn_type_last ().
17283 b) The tencode function queries the IT block state by
17284 calling in_it_block () (i.e. to determine narrow/not narrow mode).
17286 Both set_it_insn_type and in_it_block run the internal FSM state
17287 handling function (handle_it_state), because: a) setting the IT insn
17288 type may incur in an invalid state (exiting the function),
17289 and b) querying the state requires the FSM to be updated.
17290 Specifically we want to avoid creating an IT block for conditional
17291 branches, so it_fsm_pre_encode is actually a guess and we can't
17292 determine whether an IT block is required until the tencode () routine
17293 has decided what type of instruction this actually it.
17294 Because of this, if set_it_insn_type and in_it_block have to be used,
17295 set_it_insn_type has to be called first.
17297 set_it_insn_type_last () is a wrapper of set_it_insn_type (type), that
17298 determines the insn IT type depending on the inst.cond code.
17299 When a tencode () routine encodes an instruction that can be
17300 either outside an IT block, or, in the case of being inside, has to be
17301 the last one, set_it_insn_type_last () will determine the proper
17302 IT instruction type based on the inst.cond code. Otherwise,
17303 set_it_insn_type can be called for overriding that logic or
17304 for covering other cases.
17306 Calling handle_it_state () may not transition the IT block state to
17307 OUTSIDE_IT_BLOCK immediatelly, since the (current) state could be
17308 still queried. Instead, if the FSM determines that the state should
17309 be transitioned to OUTSIDE_IT_BLOCK, a flag is marked to be closed
17310 after the tencode () function: that's what it_fsm_post_encode () does.
17312 Since in_it_block () calls the state handling function to get an
17313 updated state, an error may occur (due to invalid insns combination).
17314 In that case, inst.error is set.
17315 Therefore, inst.error has to be checked after the execution of
17316 the tencode () routine.
17318 3) Back in md_assemble(), it_fsm_post_encode () is called to commit
17319 any pending state change (if any) that didn't take place in
17320 handle_it_state () as explained above. */
17323 it_fsm_pre_encode (void)
17325 if (inst.cond != COND_ALWAYS)
17326 inst.it_insn_type = INSIDE_IT_INSN;
17328 inst.it_insn_type = OUTSIDE_IT_INSN;
17330 now_it.state_handled = 0;
17333 /* IT state FSM handling function. */
17336 handle_it_state (void)
17338 now_it.state_handled = 1;
17339 now_it.insn_cond = FALSE;
17341 switch (now_it.state)
17343 case OUTSIDE_IT_BLOCK:
17344 switch (inst.it_insn_type)
17346 case OUTSIDE_IT_INSN:
17349 case INSIDE_IT_INSN:
17350 case INSIDE_IT_LAST_INSN:
17351 if (thumb_mode == 0)
17354 && !(implicit_it_mode & IMPLICIT_IT_MODE_ARM))
17355 as_tsktsk (_("Warning: conditional outside an IT block"\
17360 if ((implicit_it_mode & IMPLICIT_IT_MODE_THUMB)
17361 && ARM_CPU_HAS_FEATURE (cpu_variant, arm_arch_t2))
17363 /* Automatically generate the IT instruction. */
17364 new_automatic_it_block (inst.cond);
17365 if (inst.it_insn_type == INSIDE_IT_LAST_INSN)
17366 close_automatic_it_block ();
17370 inst.error = BAD_OUT_IT;
17376 case IF_INSIDE_IT_LAST_INSN:
17377 case NEUTRAL_IT_INSN:
17381 now_it.state = MANUAL_IT_BLOCK;
17382 now_it.block_length = 0;
17387 case AUTOMATIC_IT_BLOCK:
17388 /* Three things may happen now:
17389 a) We should increment current it block size;
17390 b) We should close current it block (closing insn or 4 insns);
17391 c) We should close current it block and start a new one (due
17392 to incompatible conditions or
17393 4 insns-length block reached). */
17395 switch (inst.it_insn_type)
17397 case OUTSIDE_IT_INSN:
17398 /* The closure of the block shall happen immediatelly,
17399 so any in_it_block () call reports the block as closed. */
17400 force_automatic_it_block_close ();
17403 case INSIDE_IT_INSN:
17404 case INSIDE_IT_LAST_INSN:
17405 case IF_INSIDE_IT_LAST_INSN:
17406 now_it.block_length++;
17408 if (now_it.block_length > 4
17409 || !now_it_compatible (inst.cond))
17411 force_automatic_it_block_close ();
17412 if (inst.it_insn_type != IF_INSIDE_IT_LAST_INSN)
17413 new_automatic_it_block (inst.cond);
17417 now_it.insn_cond = TRUE;
17418 now_it_add_mask (inst.cond);
17421 if (now_it.state == AUTOMATIC_IT_BLOCK
17422 && (inst.it_insn_type == INSIDE_IT_LAST_INSN
17423 || inst.it_insn_type == IF_INSIDE_IT_LAST_INSN))
17424 close_automatic_it_block ();
17427 case NEUTRAL_IT_INSN:
17428 now_it.block_length++;
17429 now_it.insn_cond = TRUE;
17431 if (now_it.block_length > 4)
17432 force_automatic_it_block_close ();
17434 now_it_add_mask (now_it.cc & 1);
17438 close_automatic_it_block ();
17439 now_it.state = MANUAL_IT_BLOCK;
17444 case MANUAL_IT_BLOCK:
17446 /* Check conditional suffixes. */
17447 const int cond = now_it.cc ^ ((now_it.mask >> 4) & 1) ^ 1;
17450 now_it.mask &= 0x1f;
17451 is_last = (now_it.mask == 0x10);
17452 now_it.insn_cond = TRUE;
17454 switch (inst.it_insn_type)
17456 case OUTSIDE_IT_INSN:
17457 inst.error = BAD_NOT_IT;
17460 case INSIDE_IT_INSN:
17461 if (cond != inst.cond)
17463 inst.error = BAD_IT_COND;
17468 case INSIDE_IT_LAST_INSN:
17469 case IF_INSIDE_IT_LAST_INSN:
17470 if (cond != inst.cond)
17472 inst.error = BAD_IT_COND;
17477 inst.error = BAD_BRANCH;
17482 case NEUTRAL_IT_INSN:
17483 /* The BKPT instruction is unconditional even in an IT block. */
17487 inst.error = BAD_IT_IT;
17497 struct depr_insn_mask
17499 unsigned long pattern;
17500 unsigned long mask;
17501 const char* description;
17504 /* List of 16-bit instruction patterns deprecated in an IT block in
17506 static const struct depr_insn_mask depr_it_insns[] = {
17507 { 0xc000, 0xc000, N_("Short branches, Undefined, SVC, LDM/STM") },
17508 { 0xb000, 0xb000, N_("Miscellaneous 16-bit instructions") },
17509 { 0xa000, 0xb800, N_("ADR") },
17510 { 0x4800, 0xf800, N_("Literal loads") },
17511 { 0x4478, 0xf478, N_("Hi-register ADD, MOV, CMP, BX, BLX using pc") },
17512 { 0x4487, 0xfc87, N_("Hi-register ADD, MOV, CMP using pc") },
17513 /* NOTE: 0x00dd is not the real encoding, instead, it is the 'tvalue'
17514 field in asm_opcode. 'tvalue' is used at the stage this check happen. */
17515 { 0x00dd, 0x7fff, N_("ADD/SUB sp, sp #imm") },
17520 it_fsm_post_encode (void)
17524 if (!now_it.state_handled)
17525 handle_it_state ();
17527 if (now_it.insn_cond
17528 && !now_it.warn_deprecated
17529 && warn_on_deprecated
17530 && ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v8))
17532 if (inst.instruction >= 0x10000)
17534 as_warn (_("IT blocks containing 32-bit Thumb instructions are "
17535 "deprecated in ARMv8"));
17536 now_it.warn_deprecated = TRUE;
17540 const struct depr_insn_mask *p = depr_it_insns;
17542 while (p->mask != 0)
17544 if ((inst.instruction & p->mask) == p->pattern)
17546 as_warn (_("IT blocks containing 16-bit Thumb instructions "
17547 "of the following class are deprecated in ARMv8: "
17548 "%s"), p->description);
17549 now_it.warn_deprecated = TRUE;
17557 if (now_it.block_length > 1)
17559 as_warn (_("IT blocks containing more than one conditional "
17560 "instruction are deprecated in ARMv8"));
17561 now_it.warn_deprecated = TRUE;
17565 is_last = (now_it.mask == 0x10);
17568 now_it.state = OUTSIDE_IT_BLOCK;
17574 force_automatic_it_block_close (void)
17576 if (now_it.state == AUTOMATIC_IT_BLOCK)
17578 close_automatic_it_block ();
17579 now_it.state = OUTSIDE_IT_BLOCK;
17587 if (!now_it.state_handled)
17588 handle_it_state ();
17590 return now_it.state != OUTSIDE_IT_BLOCK;
17594 md_assemble (char *str)
17597 const struct asm_opcode * opcode;
17599 /* Align the previous label if needed. */
17600 if (last_label_seen != NULL)
17602 symbol_set_frag (last_label_seen, frag_now);
17603 S_SET_VALUE (last_label_seen, (valueT) frag_now_fix ());
17604 S_SET_SEGMENT (last_label_seen, now_seg);
17607 memset (&inst, '\0', sizeof (inst));
17608 inst.reloc.type = BFD_RELOC_UNUSED;
17610 opcode = opcode_lookup (&p);
17613 /* It wasn't an instruction, but it might be a register alias of
17614 the form alias .req reg, or a Neon .dn/.qn directive. */
17615 if (! create_register_alias (str, p)
17616 && ! create_neon_reg_alias (str, p))
17617 as_bad (_("bad instruction `%s'"), str);
17622 if (warn_on_deprecated && opcode->tag == OT_cinfix3_deprecated)
17623 as_warn (_("s suffix on comparison instruction is deprecated"));
17625 /* The value which unconditional instructions should have in place of the
17626 condition field. */
17627 inst.uncond_value = (opcode->tag == OT_csuffixF) ? 0xf : -1;
17631 arm_feature_set variant;
17633 variant = cpu_variant;
17634 /* Only allow coprocessor instructions on Thumb-2 capable devices. */
17635 if (!ARM_CPU_HAS_FEATURE (variant, arm_arch_t2))
17636 ARM_CLEAR_FEATURE (variant, variant, fpu_any_hard);
17637 /* Check that this instruction is supported for this CPU. */
17638 if (!opcode->tvariant
17639 || (thumb_mode == 1
17640 && !ARM_CPU_HAS_FEATURE (variant, *opcode->tvariant)))
17642 as_bad (_("selected processor does not support Thumb mode `%s'"), str);
17645 if (inst.cond != COND_ALWAYS && !unified_syntax
17646 && opcode->tencode != do_t_branch)
17648 as_bad (_("Thumb does not support conditional execution"));
17652 if (!ARM_CPU_HAS_FEATURE (variant, arm_ext_v6t2))
17654 if (opcode->tencode != do_t_blx && opcode->tencode != do_t_branch23
17655 && !(ARM_CPU_HAS_FEATURE(*opcode->tvariant, arm_ext_msr)
17656 || ARM_CPU_HAS_FEATURE(*opcode->tvariant, arm_ext_barrier)))
17658 /* Two things are addressed here.
17659 1) Implicit require narrow instructions on Thumb-1.
17660 This avoids relaxation accidentally introducing Thumb-2
17662 2) Reject wide instructions in non Thumb-2 cores. */
17663 if (inst.size_req == 0)
17665 else if (inst.size_req == 4)
17667 as_bad (_("selected processor does not support Thumb-2 mode `%s'"), str);
17673 inst.instruction = opcode->tvalue;
17675 if (!parse_operands (p, opcode->operands, /*thumb=*/TRUE))
17677 /* Prepare the it_insn_type for those encodings that don't set
17679 it_fsm_pre_encode ();
17681 opcode->tencode ();
17683 it_fsm_post_encode ();
17686 if (!(inst.error || inst.relax))
17688 gas_assert (inst.instruction < 0xe800 || inst.instruction > 0xffff);
17689 inst.size = (inst.instruction > 0xffff ? 4 : 2);
17690 if (inst.size_req && inst.size_req != inst.size)
17692 as_bad (_("cannot honor width suffix -- `%s'"), str);
17697 /* Something has gone badly wrong if we try to relax a fixed size
17699 gas_assert (inst.size_req == 0 || !inst.relax);
17701 ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
17702 *opcode->tvariant);
17703 /* Many Thumb-2 instructions also have Thumb-1 variants, so explicitly
17704 set those bits when Thumb-2 32-bit instructions are seen. ie.
17705 anything other than bl/blx and v6-M instructions.
17706 The impact of relaxable instructions will be considered later after we
17707 finish all relaxation. */
17708 if ((inst.size == 4 && (inst.instruction & 0xf800e800) != 0xf000e800)
17709 && !(ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_msr)
17710 || ARM_CPU_HAS_FEATURE (*opcode->tvariant, arm_ext_barrier)))
17711 ARM_MERGE_FEATURE_SETS (thumb_arch_used, thumb_arch_used,
17714 check_neon_suffixes;
17718 mapping_state (MAP_THUMB);
17721 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
17725 /* bx is allowed on v5 cores, and sometimes on v4 cores. */
17726 is_bx = (opcode->aencode == do_bx);
17728 /* Check that this instruction is supported for this CPU. */
17729 if (!(is_bx && fix_v4bx)
17730 && !(opcode->avariant &&
17731 ARM_CPU_HAS_FEATURE (cpu_variant, *opcode->avariant)))
17733 as_bad (_("selected processor does not support ARM mode `%s'"), str);
17738 as_bad (_("width suffixes are invalid in ARM mode -- `%s'"), str);
17742 inst.instruction = opcode->avalue;
17743 if (opcode->tag == OT_unconditionalF)
17744 inst.instruction |= 0xF << 28;
17746 inst.instruction |= inst.cond << 28;
17747 inst.size = INSN_SIZE;
17748 if (!parse_operands (p, opcode->operands, /*thumb=*/FALSE))
17750 it_fsm_pre_encode ();
17751 opcode->aencode ();
17752 it_fsm_post_encode ();
17754 /* Arm mode bx is marked as both v4T and v5 because it's still required
17755 on a hypothetical non-thumb v5 core. */
17757 ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used, arm_ext_v4t);
17759 ARM_MERGE_FEATURE_SETS (arm_arch_used, arm_arch_used,
17760 *opcode->avariant);
17762 check_neon_suffixes;
17766 mapping_state (MAP_ARM);
17771 as_bad (_("attempt to use an ARM instruction on a Thumb-only processor "
17779 check_it_blocks_finished (void)
17784 for (sect = stdoutput->sections; sect != NULL; sect = sect->next)
17785 if (seg_info (sect)->tc_segment_info_data.current_it.state
17786 == MANUAL_IT_BLOCK)
17788 as_warn (_("section '%s' finished with an open IT block."),
17792 if (now_it.state == MANUAL_IT_BLOCK)
17793 as_warn (_("file finished with an open IT block."));
17797 /* Various frobbings of labels and their addresses. */
17800 arm_start_line_hook (void)
17802 last_label_seen = NULL;
17806 arm_frob_label (symbolS * sym)
17808 last_label_seen = sym;
17810 ARM_SET_THUMB (sym, thumb_mode);
17812 #if defined OBJ_COFF || defined OBJ_ELF
17813 ARM_SET_INTERWORK (sym, support_interwork);
17816 force_automatic_it_block_close ();
17818 /* Note - do not allow local symbols (.Lxxx) to be labelled
17819 as Thumb functions. This is because these labels, whilst
17820 they exist inside Thumb code, are not the entry points for
17821 possible ARM->Thumb calls. Also, these labels can be used
17822 as part of a computed goto or switch statement. eg gcc
17823 can generate code that looks like this:
17825 ldr r2, [pc, .Laaa]
17835 The first instruction loads the address of the jump table.
17836 The second instruction converts a table index into a byte offset.
17837 The third instruction gets the jump address out of the table.
17838 The fourth instruction performs the jump.
17840 If the address stored at .Laaa is that of a symbol which has the
17841 Thumb_Func bit set, then the linker will arrange for this address
17842 to have the bottom bit set, which in turn would mean that the
17843 address computation performed by the third instruction would end
17844 up with the bottom bit set. Since the ARM is capable of unaligned
17845 word loads, the instruction would then load the incorrect address
17846 out of the jump table, and chaos would ensue. */
17847 if (label_is_thumb_function_name
17848 && (S_GET_NAME (sym)[0] != '.' || S_GET_NAME (sym)[1] != 'L')
17849 && (bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
17851 /* When the address of a Thumb function is taken the bottom
17852 bit of that address should be set. This will allow
17853 interworking between Arm and Thumb functions to work
17856 THUMB_SET_FUNC (sym, 1);
17858 label_is_thumb_function_name = FALSE;
17861 dwarf2_emit_label (sym);
17865 arm_data_in_code (void)
17867 if (thumb_mode && ! strncmp (input_line_pointer + 1, "data:", 5))
17869 *input_line_pointer = '/';
17870 input_line_pointer += 5;
17871 *input_line_pointer = 0;
17879 arm_canonicalize_symbol_name (char * name)
17883 if (thumb_mode && (len = strlen (name)) > 5
17884 && streq (name + len - 5, "/data"))
17885 *(name + len - 5) = 0;
17890 /* Table of all register names defined by default. The user can
17891 define additional names with .req. Note that all register names
17892 should appear in both upper and lowercase variants. Some registers
17893 also have mixed-case names. */
17895 #define REGDEF(s,n,t) { #s, n, REG_TYPE_##t, TRUE, 0 }
17896 #define REGNUM(p,n,t) REGDEF(p##n, n, t)
17897 #define REGNUM2(p,n,t) REGDEF(p##n, 2 * n, t)
17898 #define REGSET(p,t) \
17899 REGNUM(p, 0,t), REGNUM(p, 1,t), REGNUM(p, 2,t), REGNUM(p, 3,t), \
17900 REGNUM(p, 4,t), REGNUM(p, 5,t), REGNUM(p, 6,t), REGNUM(p, 7,t), \
17901 REGNUM(p, 8,t), REGNUM(p, 9,t), REGNUM(p,10,t), REGNUM(p,11,t), \
17902 REGNUM(p,12,t), REGNUM(p,13,t), REGNUM(p,14,t), REGNUM(p,15,t)
17903 #define REGSETH(p,t) \
17904 REGNUM(p,16,t), REGNUM(p,17,t), REGNUM(p,18,t), REGNUM(p,19,t), \
17905 REGNUM(p,20,t), REGNUM(p,21,t), REGNUM(p,22,t), REGNUM(p,23,t), \
17906 REGNUM(p,24,t), REGNUM(p,25,t), REGNUM(p,26,t), REGNUM(p,27,t), \
17907 REGNUM(p,28,t), REGNUM(p,29,t), REGNUM(p,30,t), REGNUM(p,31,t)
17908 #define REGSET2(p,t) \
17909 REGNUM2(p, 0,t), REGNUM2(p, 1,t), REGNUM2(p, 2,t), REGNUM2(p, 3,t), \
17910 REGNUM2(p, 4,t), REGNUM2(p, 5,t), REGNUM2(p, 6,t), REGNUM2(p, 7,t), \
17911 REGNUM2(p, 8,t), REGNUM2(p, 9,t), REGNUM2(p,10,t), REGNUM2(p,11,t), \
17912 REGNUM2(p,12,t), REGNUM2(p,13,t), REGNUM2(p,14,t), REGNUM2(p,15,t)
17913 #define SPLRBANK(base,bank,t) \
17914 REGDEF(lr_##bank, 768|((base+0)<<16), t), \
17915 REGDEF(sp_##bank, 768|((base+1)<<16), t), \
17916 REGDEF(spsr_##bank, 768|(base<<16)|SPSR_BIT, t), \
17917 REGDEF(LR_##bank, 768|((base+0)<<16), t), \
17918 REGDEF(SP_##bank, 768|((base+1)<<16), t), \
17919 REGDEF(SPSR_##bank, 768|(base<<16)|SPSR_BIT, t)
17921 static const struct reg_entry reg_names[] =
17923 /* ARM integer registers. */
17924 REGSET(r, RN), REGSET(R, RN),
17926 /* ATPCS synonyms. */
17927 REGDEF(a1,0,RN), REGDEF(a2,1,RN), REGDEF(a3, 2,RN), REGDEF(a4, 3,RN),
17928 REGDEF(v1,4,RN), REGDEF(v2,5,RN), REGDEF(v3, 6,RN), REGDEF(v4, 7,RN),
17929 REGDEF(v5,8,RN), REGDEF(v6,9,RN), REGDEF(v7,10,RN), REGDEF(v8,11,RN),
17931 REGDEF(A1,0,RN), REGDEF(A2,1,RN), REGDEF(A3, 2,RN), REGDEF(A4, 3,RN),
17932 REGDEF(V1,4,RN), REGDEF(V2,5,RN), REGDEF(V3, 6,RN), REGDEF(V4, 7,RN),
17933 REGDEF(V5,8,RN), REGDEF(V6,9,RN), REGDEF(V7,10,RN), REGDEF(V8,11,RN),
17935 /* Well-known aliases. */
17936 REGDEF(wr, 7,RN), REGDEF(sb, 9,RN), REGDEF(sl,10,RN), REGDEF(fp,11,RN),
17937 REGDEF(ip,12,RN), REGDEF(sp,13,RN), REGDEF(lr,14,RN), REGDEF(pc,15,RN),
17939 REGDEF(WR, 7,RN), REGDEF(SB, 9,RN), REGDEF(SL,10,RN), REGDEF(FP,11,RN),
17940 REGDEF(IP,12,RN), REGDEF(SP,13,RN), REGDEF(LR,14,RN), REGDEF(PC,15,RN),
17942 /* Coprocessor numbers. */
17943 REGSET(p, CP), REGSET(P, CP),
17945 /* Coprocessor register numbers. The "cr" variants are for backward
17947 REGSET(c, CN), REGSET(C, CN),
17948 REGSET(cr, CN), REGSET(CR, CN),
17950 /* ARM banked registers. */
17951 REGDEF(R8_usr,512|(0<<16),RNB), REGDEF(r8_usr,512|(0<<16),RNB),
17952 REGDEF(R9_usr,512|(1<<16),RNB), REGDEF(r9_usr,512|(1<<16),RNB),
17953 REGDEF(R10_usr,512|(2<<16),RNB), REGDEF(r10_usr,512|(2<<16),RNB),
17954 REGDEF(R11_usr,512|(3<<16),RNB), REGDEF(r11_usr,512|(3<<16),RNB),
17955 REGDEF(R12_usr,512|(4<<16),RNB), REGDEF(r12_usr,512|(4<<16),RNB),
17956 REGDEF(SP_usr,512|(5<<16),RNB), REGDEF(sp_usr,512|(5<<16),RNB),
17957 REGDEF(LR_usr,512|(6<<16),RNB), REGDEF(lr_usr,512|(6<<16),RNB),
17959 REGDEF(R8_fiq,512|(8<<16),RNB), REGDEF(r8_fiq,512|(8<<16),RNB),
17960 REGDEF(R9_fiq,512|(9<<16),RNB), REGDEF(r9_fiq,512|(9<<16),RNB),
17961 REGDEF(R10_fiq,512|(10<<16),RNB), REGDEF(r10_fiq,512|(10<<16),RNB),
17962 REGDEF(R11_fiq,512|(11<<16),RNB), REGDEF(r11_fiq,512|(11<<16),RNB),
17963 REGDEF(R12_fiq,512|(12<<16),RNB), REGDEF(r12_fiq,512|(12<<16),RNB),
17964 REGDEF(SP_fiq,512|(13<<16),RNB), REGDEF(sp_fiq,512|(13<<16),RNB),
17965 REGDEF(LR_fiq,512|(14<<16),RNB), REGDEF(lr_fiq,512|(14<<16),RNB),
17966 REGDEF(SPSR_fiq,512|(14<<16)|SPSR_BIT,RNB), REGDEF(spsr_fiq,512|(14<<16)|SPSR_BIT,RNB),
17968 SPLRBANK(0,IRQ,RNB), SPLRBANK(0,irq,RNB),
17969 SPLRBANK(2,SVC,RNB), SPLRBANK(2,svc,RNB),
17970 SPLRBANK(4,ABT,RNB), SPLRBANK(4,abt,RNB),
17971 SPLRBANK(6,UND,RNB), SPLRBANK(6,und,RNB),
17972 SPLRBANK(12,MON,RNB), SPLRBANK(12,mon,RNB),
17973 REGDEF(elr_hyp,768|(14<<16),RNB), REGDEF(ELR_hyp,768|(14<<16),RNB),
17974 REGDEF(sp_hyp,768|(15<<16),RNB), REGDEF(SP_hyp,768|(15<<16),RNB),
17975 REGDEF(spsr_hyp,768|(14<<16)|SPSR_BIT,RNB),
17976 REGDEF(SPSR_hyp,768|(14<<16)|SPSR_BIT,RNB),
17978 /* FPA registers. */
17979 REGNUM(f,0,FN), REGNUM(f,1,FN), REGNUM(f,2,FN), REGNUM(f,3,FN),
17980 REGNUM(f,4,FN), REGNUM(f,5,FN), REGNUM(f,6,FN), REGNUM(f,7, FN),
17982 REGNUM(F,0,FN), REGNUM(F,1,FN), REGNUM(F,2,FN), REGNUM(F,3,FN),
17983 REGNUM(F,4,FN), REGNUM(F,5,FN), REGNUM(F,6,FN), REGNUM(F,7, FN),
17985 /* VFP SP registers. */
17986 REGSET(s,VFS), REGSET(S,VFS),
17987 REGSETH(s,VFS), REGSETH(S,VFS),
17989 /* VFP DP Registers. */
17990 REGSET(d,VFD), REGSET(D,VFD),
17991 /* Extra Neon DP registers. */
17992 REGSETH(d,VFD), REGSETH(D,VFD),
17994 /* Neon QP registers. */
17995 REGSET2(q,NQ), REGSET2(Q,NQ),
17997 /* VFP control registers. */
17998 REGDEF(fpsid,0,VFC), REGDEF(fpscr,1,VFC), REGDEF(fpexc,8,VFC),
17999 REGDEF(FPSID,0,VFC), REGDEF(FPSCR,1,VFC), REGDEF(FPEXC,8,VFC),
18000 REGDEF(fpinst,9,VFC), REGDEF(fpinst2,10,VFC),
18001 REGDEF(FPINST,9,VFC), REGDEF(FPINST2,10,VFC),
18002 REGDEF(mvfr0,7,VFC), REGDEF(mvfr1,6,VFC),
18003 REGDEF(MVFR0,7,VFC), REGDEF(MVFR1,6,VFC),
18005 /* Maverick DSP coprocessor registers. */
18006 REGSET(mvf,MVF), REGSET(mvd,MVD), REGSET(mvfx,MVFX), REGSET(mvdx,MVDX),
18007 REGSET(MVF,MVF), REGSET(MVD,MVD), REGSET(MVFX,MVFX), REGSET(MVDX,MVDX),
18009 REGNUM(mvax,0,MVAX), REGNUM(mvax,1,MVAX),
18010 REGNUM(mvax,2,MVAX), REGNUM(mvax,3,MVAX),
18011 REGDEF(dspsc,0,DSPSC),
18013 REGNUM(MVAX,0,MVAX), REGNUM(MVAX,1,MVAX),
18014 REGNUM(MVAX,2,MVAX), REGNUM(MVAX,3,MVAX),
18015 REGDEF(DSPSC,0,DSPSC),
18017 /* iWMMXt data registers - p0, c0-15. */
18018 REGSET(wr,MMXWR), REGSET(wR,MMXWR), REGSET(WR, MMXWR),
18020 /* iWMMXt control registers - p1, c0-3. */
18021 REGDEF(wcid, 0,MMXWC), REGDEF(wCID, 0,MMXWC), REGDEF(WCID, 0,MMXWC),
18022 REGDEF(wcon, 1,MMXWC), REGDEF(wCon, 1,MMXWC), REGDEF(WCON, 1,MMXWC),
18023 REGDEF(wcssf, 2,MMXWC), REGDEF(wCSSF, 2,MMXWC), REGDEF(WCSSF, 2,MMXWC),
18024 REGDEF(wcasf, 3,MMXWC), REGDEF(wCASF, 3,MMXWC), REGDEF(WCASF, 3,MMXWC),
18026 /* iWMMXt scalar (constant/offset) registers - p1, c8-11. */
18027 REGDEF(wcgr0, 8,MMXWCG), REGDEF(wCGR0, 8,MMXWCG), REGDEF(WCGR0, 8,MMXWCG),
18028 REGDEF(wcgr1, 9,MMXWCG), REGDEF(wCGR1, 9,MMXWCG), REGDEF(WCGR1, 9,MMXWCG),
18029 REGDEF(wcgr2,10,MMXWCG), REGDEF(wCGR2,10,MMXWCG), REGDEF(WCGR2,10,MMXWCG),
18030 REGDEF(wcgr3,11,MMXWCG), REGDEF(wCGR3,11,MMXWCG), REGDEF(WCGR3,11,MMXWCG),
18032 /* XScale accumulator registers. */
18033 REGNUM(acc,0,XSCALE), REGNUM(ACC,0,XSCALE),
18039 /* Table of all PSR suffixes. Bare "CPSR" and "SPSR" are handled
18040 within psr_required_here. */
18041 static const struct asm_psr psrs[] =
18043 /* Backward compatibility notation. Note that "all" is no longer
18044 truly all possible PSR bits. */
18045 {"all", PSR_c | PSR_f},
18049 /* Individual flags. */
18055 /* Combinations of flags. */
18056 {"fs", PSR_f | PSR_s},
18057 {"fx", PSR_f | PSR_x},
18058 {"fc", PSR_f | PSR_c},
18059 {"sf", PSR_s | PSR_f},
18060 {"sx", PSR_s | PSR_x},
18061 {"sc", PSR_s | PSR_c},
18062 {"xf", PSR_x | PSR_f},
18063 {"xs", PSR_x | PSR_s},
18064 {"xc", PSR_x | PSR_c},
18065 {"cf", PSR_c | PSR_f},
18066 {"cs", PSR_c | PSR_s},
18067 {"cx", PSR_c | PSR_x},
18068 {"fsx", PSR_f | PSR_s | PSR_x},
18069 {"fsc", PSR_f | PSR_s | PSR_c},
18070 {"fxs", PSR_f | PSR_x | PSR_s},
18071 {"fxc", PSR_f | PSR_x | PSR_c},
18072 {"fcs", PSR_f | PSR_c | PSR_s},
18073 {"fcx", PSR_f | PSR_c | PSR_x},
18074 {"sfx", PSR_s | PSR_f | PSR_x},
18075 {"sfc", PSR_s | PSR_f | PSR_c},
18076 {"sxf", PSR_s | PSR_x | PSR_f},
18077 {"sxc", PSR_s | PSR_x | PSR_c},
18078 {"scf", PSR_s | PSR_c | PSR_f},
18079 {"scx", PSR_s | PSR_c | PSR_x},
18080 {"xfs", PSR_x | PSR_f | PSR_s},
18081 {"xfc", PSR_x | PSR_f | PSR_c},
18082 {"xsf", PSR_x | PSR_s | PSR_f},
18083 {"xsc", PSR_x | PSR_s | PSR_c},
18084 {"xcf", PSR_x | PSR_c | PSR_f},
18085 {"xcs", PSR_x | PSR_c | PSR_s},
18086 {"cfs", PSR_c | PSR_f | PSR_s},
18087 {"cfx", PSR_c | PSR_f | PSR_x},
18088 {"csf", PSR_c | PSR_s | PSR_f},
18089 {"csx", PSR_c | PSR_s | PSR_x},
18090 {"cxf", PSR_c | PSR_x | PSR_f},
18091 {"cxs", PSR_c | PSR_x | PSR_s},
18092 {"fsxc", PSR_f | PSR_s | PSR_x | PSR_c},
18093 {"fscx", PSR_f | PSR_s | PSR_c | PSR_x},
18094 {"fxsc", PSR_f | PSR_x | PSR_s | PSR_c},
18095 {"fxcs", PSR_f | PSR_x | PSR_c | PSR_s},
18096 {"fcsx", PSR_f | PSR_c | PSR_s | PSR_x},
18097 {"fcxs", PSR_f | PSR_c | PSR_x | PSR_s},
18098 {"sfxc", PSR_s | PSR_f | PSR_x | PSR_c},
18099 {"sfcx", PSR_s | PSR_f | PSR_c | PSR_x},
18100 {"sxfc", PSR_s | PSR_x | PSR_f | PSR_c},
18101 {"sxcf", PSR_s | PSR_x | PSR_c | PSR_f},
18102 {"scfx", PSR_s | PSR_c | PSR_f | PSR_x},
18103 {"scxf", PSR_s | PSR_c | PSR_x | PSR_f},
18104 {"xfsc", PSR_x | PSR_f | PSR_s | PSR_c},
18105 {"xfcs", PSR_x | PSR_f | PSR_c | PSR_s},
18106 {"xsfc", PSR_x | PSR_s | PSR_f | PSR_c},
18107 {"xscf", PSR_x | PSR_s | PSR_c | PSR_f},
18108 {"xcfs", PSR_x | PSR_c | PSR_f | PSR_s},
18109 {"xcsf", PSR_x | PSR_c | PSR_s | PSR_f},
18110 {"cfsx", PSR_c | PSR_f | PSR_s | PSR_x},
18111 {"cfxs", PSR_c | PSR_f | PSR_x | PSR_s},
18112 {"csfx", PSR_c | PSR_s | PSR_f | PSR_x},
18113 {"csxf", PSR_c | PSR_s | PSR_x | PSR_f},
18114 {"cxfs", PSR_c | PSR_x | PSR_f | PSR_s},
18115 {"cxsf", PSR_c | PSR_x | PSR_s | PSR_f},
18118 /* Table of V7M psr names. */
18119 static const struct asm_psr v7m_psrs[] =
18121 {"apsr", 0 }, {"APSR", 0 },
18122 {"iapsr", 1 }, {"IAPSR", 1 },
18123 {"eapsr", 2 }, {"EAPSR", 2 },
18124 {"psr", 3 }, {"PSR", 3 },
18125 {"xpsr", 3 }, {"XPSR", 3 }, {"xPSR", 3 },
18126 {"ipsr", 5 }, {"IPSR", 5 },
18127 {"epsr", 6 }, {"EPSR", 6 },
18128 {"iepsr", 7 }, {"IEPSR", 7 },
18129 {"msp", 8 }, {"MSP", 8 },
18130 {"psp", 9 }, {"PSP", 9 },
18131 {"primask", 16}, {"PRIMASK", 16},
18132 {"basepri", 17}, {"BASEPRI", 17},
18133 {"basepri_max", 18}, {"BASEPRI_MAX", 18},
18134 {"basepri_max", 18}, {"BASEPRI_MASK", 18}, /* Typo, preserved for backwards compatibility. */
18135 {"faultmask", 19}, {"FAULTMASK", 19},
18136 {"control", 20}, {"CONTROL", 20}
18139 /* Table of all shift-in-operand names. */
18140 static const struct asm_shift_name shift_names [] =
18142 { "asl", SHIFT_LSL }, { "ASL", SHIFT_LSL },
18143 { "lsl", SHIFT_LSL }, { "LSL", SHIFT_LSL },
18144 { "lsr", SHIFT_LSR }, { "LSR", SHIFT_LSR },
18145 { "asr", SHIFT_ASR }, { "ASR", SHIFT_ASR },
18146 { "ror", SHIFT_ROR }, { "ROR", SHIFT_ROR },
18147 { "rrx", SHIFT_RRX }, { "RRX", SHIFT_RRX }
18150 /* Table of all explicit relocation names. */
18152 static struct reloc_entry reloc_names[] =
18154 { "got", BFD_RELOC_ARM_GOT32 }, { "GOT", BFD_RELOC_ARM_GOT32 },
18155 { "gotoff", BFD_RELOC_ARM_GOTOFF }, { "GOTOFF", BFD_RELOC_ARM_GOTOFF },
18156 { "plt", BFD_RELOC_ARM_PLT32 }, { "PLT", BFD_RELOC_ARM_PLT32 },
18157 { "target1", BFD_RELOC_ARM_TARGET1 }, { "TARGET1", BFD_RELOC_ARM_TARGET1 },
18158 { "target2", BFD_RELOC_ARM_TARGET2 }, { "TARGET2", BFD_RELOC_ARM_TARGET2 },
18159 { "sbrel", BFD_RELOC_ARM_SBREL32 }, { "SBREL", BFD_RELOC_ARM_SBREL32 },
18160 { "tlsgd", BFD_RELOC_ARM_TLS_GD32}, { "TLSGD", BFD_RELOC_ARM_TLS_GD32},
18161 { "tlsldm", BFD_RELOC_ARM_TLS_LDM32}, { "TLSLDM", BFD_RELOC_ARM_TLS_LDM32},
18162 { "tlsldo", BFD_RELOC_ARM_TLS_LDO32}, { "TLSLDO", BFD_RELOC_ARM_TLS_LDO32},
18163 { "gottpoff",BFD_RELOC_ARM_TLS_IE32}, { "GOTTPOFF",BFD_RELOC_ARM_TLS_IE32},
18164 { "tpoff", BFD_RELOC_ARM_TLS_LE32}, { "TPOFF", BFD_RELOC_ARM_TLS_LE32},
18165 { "got_prel", BFD_RELOC_ARM_GOT_PREL}, { "GOT_PREL", BFD_RELOC_ARM_GOT_PREL},
18166 { "tlsdesc", BFD_RELOC_ARM_TLS_GOTDESC},
18167 { "TLSDESC", BFD_RELOC_ARM_TLS_GOTDESC},
18168 { "tlscall", BFD_RELOC_ARM_TLS_CALL},
18169 { "TLSCALL", BFD_RELOC_ARM_TLS_CALL},
18170 { "tlsdescseq", BFD_RELOC_ARM_TLS_DESCSEQ},
18171 { "TLSDESCSEQ", BFD_RELOC_ARM_TLS_DESCSEQ}
18175 /* Table of all conditional affixes. 0xF is not defined as a condition code. */
18176 static const struct asm_cond conds[] =
18180 {"cs", 0x2}, {"hs", 0x2},
18181 {"cc", 0x3}, {"ul", 0x3}, {"lo", 0x3},
18195 #define UL_BARRIER(L,U,CODE,FEAT) \
18196 { L, CODE, ARM_FEATURE (FEAT, 0) }, \
18197 { U, CODE, ARM_FEATURE (FEAT, 0) }
18199 static struct asm_barrier_opt barrier_opt_names[] =
18201 UL_BARRIER ("sy", "SY", 0xf, ARM_EXT_BARRIER),
18202 UL_BARRIER ("st", "ST", 0xe, ARM_EXT_BARRIER),
18203 UL_BARRIER ("ld", "LD", 0xd, ARM_EXT_V8),
18204 UL_BARRIER ("ish", "ISH", 0xb, ARM_EXT_BARRIER),
18205 UL_BARRIER ("sh", "SH", 0xb, ARM_EXT_BARRIER),
18206 UL_BARRIER ("ishst", "ISHST", 0xa, ARM_EXT_BARRIER),
18207 UL_BARRIER ("shst", "SHST", 0xa, ARM_EXT_BARRIER),
18208 UL_BARRIER ("ishld", "ISHLD", 0x9, ARM_EXT_V8),
18209 UL_BARRIER ("un", "UN", 0x7, ARM_EXT_BARRIER),
18210 UL_BARRIER ("nsh", "NSH", 0x7, ARM_EXT_BARRIER),
18211 UL_BARRIER ("unst", "UNST", 0x6, ARM_EXT_BARRIER),
18212 UL_BARRIER ("nshst", "NSHST", 0x6, ARM_EXT_BARRIER),
18213 UL_BARRIER ("nshld", "NSHLD", 0x5, ARM_EXT_V8),
18214 UL_BARRIER ("osh", "OSH", 0x3, ARM_EXT_BARRIER),
18215 UL_BARRIER ("oshst", "OSHST", 0x2, ARM_EXT_BARRIER),
18216 UL_BARRIER ("oshld", "OSHLD", 0x1, ARM_EXT_V8)
18221 /* Table of ARM-format instructions. */
18223 /* Macros for gluing together operand strings. N.B. In all cases
18224 other than OPS0, the trailing OP_stop comes from default
18225 zero-initialization of the unspecified elements of the array. */
18226 #define OPS0() { OP_stop, }
18227 #define OPS1(a) { OP_##a, }
18228 #define OPS2(a,b) { OP_##a,OP_##b, }
18229 #define OPS3(a,b,c) { OP_##a,OP_##b,OP_##c, }
18230 #define OPS4(a,b,c,d) { OP_##a,OP_##b,OP_##c,OP_##d, }
18231 #define OPS5(a,b,c,d,e) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e, }
18232 #define OPS6(a,b,c,d,e,f) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e,OP_##f, }
18234 /* These macros are similar to the OPSn, but do not prepend the OP_ prefix.
18235 This is useful when mixing operands for ARM and THUMB, i.e. using the
18236 MIX_ARM_THUMB_OPERANDS macro.
18237 In order to use these macros, prefix the number of operands with _
18239 #define OPS_1(a) { a, }
18240 #define OPS_2(a,b) { a,b, }
18241 #define OPS_3(a,b,c) { a,b,c, }
18242 #define OPS_4(a,b,c,d) { a,b,c,d, }
18243 #define OPS_5(a,b,c,d,e) { a,b,c,d,e, }
18244 #define OPS_6(a,b,c,d,e,f) { a,b,c,d,e,f, }
18246 /* These macros abstract out the exact format of the mnemonic table and
18247 save some repeated characters. */
18249 /* The normal sort of mnemonic; has a Thumb variant; takes a conditional suffix. */
18250 #define TxCE(mnem, op, top, nops, ops, ae, te) \
18251 { mnem, OPS##nops ops, OT_csuffix, 0x##op, top, ARM_VARIANT, \
18252 THUMB_VARIANT, do_##ae, do_##te }
18254 /* Two variants of the above - TCE for a numeric Thumb opcode, tCE for
18255 a T_MNEM_xyz enumerator. */
18256 #define TCE(mnem, aop, top, nops, ops, ae, te) \
18257 TxCE (mnem, aop, 0x##top, nops, ops, ae, te)
18258 #define tCE(mnem, aop, top, nops, ops, ae, te) \
18259 TxCE (mnem, aop, T_MNEM##top, nops, ops, ae, te)
18261 /* Second most common sort of mnemonic: has a Thumb variant, takes a conditional
18262 infix after the third character. */
18263 #define TxC3(mnem, op, top, nops, ops, ae, te) \
18264 { mnem, OPS##nops ops, OT_cinfix3, 0x##op, top, ARM_VARIANT, \
18265 THUMB_VARIANT, do_##ae, do_##te }
18266 #define TxC3w(mnem, op, top, nops, ops, ae, te) \
18267 { mnem, OPS##nops ops, OT_cinfix3_deprecated, 0x##op, top, ARM_VARIANT, \
18268 THUMB_VARIANT, do_##ae, do_##te }
18269 #define TC3(mnem, aop, top, nops, ops, ae, te) \
18270 TxC3 (mnem, aop, 0x##top, nops, ops, ae, te)
18271 #define TC3w(mnem, aop, top, nops, ops, ae, te) \
18272 TxC3w (mnem, aop, 0x##top, nops, ops, ae, te)
18273 #define tC3(mnem, aop, top, nops, ops, ae, te) \
18274 TxC3 (mnem, aop, T_MNEM##top, nops, ops, ae, te)
18275 #define tC3w(mnem, aop, top, nops, ops, ae, te) \
18276 TxC3w (mnem, aop, T_MNEM##top, nops, ops, ae, te)
18278 /* Mnemonic that cannot be conditionalized. The ARM condition-code
18279 field is still 0xE. Many of the Thumb variants can be executed
18280 conditionally, so this is checked separately. */
18281 #define TUE(mnem, op, top, nops, ops, ae, te) \
18282 { mnem, OPS##nops ops, OT_unconditional, 0x##op, 0x##top, ARM_VARIANT, \
18283 THUMB_VARIANT, do_##ae, do_##te }
18285 /* Same as TUE but the encoding function for ARM and Thumb modes is the same.
18286 Used by mnemonics that have very minimal differences in the encoding for
18287 ARM and Thumb variants and can be handled in a common function. */
18288 #define TUEc(mnem, op, top, nops, ops, en) \
18289 { mnem, OPS##nops ops, OT_unconditional, 0x##op, 0x##top, ARM_VARIANT, \
18290 THUMB_VARIANT, do_##en, do_##en }
18292 /* Mnemonic that cannot be conditionalized, and bears 0xF in its ARM
18293 condition code field. */
18294 #define TUF(mnem, op, top, nops, ops, ae, te) \
18295 { mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##top, ARM_VARIANT, \
18296 THUMB_VARIANT, do_##ae, do_##te }
18298 /* ARM-only variants of all the above. */
18299 #define CE(mnem, op, nops, ops, ae) \
18300 { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
18302 #define C3(mnem, op, nops, ops, ae) \
18303 { #mnem, OPS##nops ops, OT_cinfix3, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
18305 /* Legacy mnemonics that always have conditional infix after the third
18307 #define CL(mnem, op, nops, ops, ae) \
18308 { mnem, OPS##nops ops, OT_cinfix3_legacy, \
18309 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
18311 /* Coprocessor instructions. Isomorphic between Arm and Thumb-2. */
18312 #define cCE(mnem, op, nops, ops, ae) \
18313 { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
18315 /* Legacy coprocessor instructions where conditional infix and conditional
18316 suffix are ambiguous. For consistency this includes all FPA instructions,
18317 not just the potentially ambiguous ones. */
18318 #define cCL(mnem, op, nops, ops, ae) \
18319 { mnem, OPS##nops ops, OT_cinfix3_legacy, \
18320 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
18322 /* Coprocessor, takes either a suffix or a position-3 infix
18323 (for an FPA corner case). */
18324 #define C3E(mnem, op, nops, ops, ae) \
18325 { mnem, OPS##nops ops, OT_csuf_or_in3, \
18326 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
18328 #define xCM_(m1, m2, m3, op, nops, ops, ae) \
18329 { m1 #m2 m3, OPS##nops ops, \
18330 sizeof (#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof (m1) - 1, \
18331 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
18333 #define CM(m1, m2, op, nops, ops, ae) \
18334 xCM_ (m1, , m2, op, nops, ops, ae), \
18335 xCM_ (m1, eq, m2, op, nops, ops, ae), \
18336 xCM_ (m1, ne, m2, op, nops, ops, ae), \
18337 xCM_ (m1, cs, m2, op, nops, ops, ae), \
18338 xCM_ (m1, hs, m2, op, nops, ops, ae), \
18339 xCM_ (m1, cc, m2, op, nops, ops, ae), \
18340 xCM_ (m1, ul, m2, op, nops, ops, ae), \
18341 xCM_ (m1, lo, m2, op, nops, ops, ae), \
18342 xCM_ (m1, mi, m2, op, nops, ops, ae), \
18343 xCM_ (m1, pl, m2, op, nops, ops, ae), \
18344 xCM_ (m1, vs, m2, op, nops, ops, ae), \
18345 xCM_ (m1, vc, m2, op, nops, ops, ae), \
18346 xCM_ (m1, hi, m2, op, nops, ops, ae), \
18347 xCM_ (m1, ls, m2, op, nops, ops, ae), \
18348 xCM_ (m1, ge, m2, op, nops, ops, ae), \
18349 xCM_ (m1, lt, m2, op, nops, ops, ae), \
18350 xCM_ (m1, gt, m2, op, nops, ops, ae), \
18351 xCM_ (m1, le, m2, op, nops, ops, ae), \
18352 xCM_ (m1, al, m2, op, nops, ops, ae)
18354 #define UE(mnem, op, nops, ops, ae) \
18355 { #mnem, OPS##nops ops, OT_unconditional, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
18357 #define UF(mnem, op, nops, ops, ae) \
18358 { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
18360 /* Neon data-processing. ARM versions are unconditional with cond=0xf.
18361 The Thumb and ARM variants are mostly the same (bits 0-23 and 24/28), so we
18362 use the same encoding function for each. */
18363 #define NUF(mnem, op, nops, ops, enc) \
18364 { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##op, \
18365 ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
18367 /* Neon data processing, version which indirects through neon_enc_tab for
18368 the various overloaded versions of opcodes. */
18369 #define nUF(mnem, op, nops, ops, enc) \
18370 { #mnem, OPS##nops ops, OT_unconditionalF, N_MNEM##op, N_MNEM##op, \
18371 ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
18373 /* Neon insn with conditional suffix for the ARM version, non-overloaded
18375 #define NCE_tag(mnem, op, nops, ops, enc, tag) \
18376 { #mnem, OPS##nops ops, tag, 0x##op, 0x##op, ARM_VARIANT, \
18377 THUMB_VARIANT, do_##enc, do_##enc }
18379 #define NCE(mnem, op, nops, ops, enc) \
18380 NCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
18382 #define NCEF(mnem, op, nops, ops, enc) \
18383 NCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
18385 /* Neon insn with conditional suffix for the ARM version, overloaded types. */
18386 #define nCE_tag(mnem, op, nops, ops, enc, tag) \
18387 { #mnem, OPS##nops ops, tag, N_MNEM##op, N_MNEM##op, \
18388 ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
18390 #define nCE(mnem, op, nops, ops, enc) \
18391 nCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
18393 #define nCEF(mnem, op, nops, ops, enc) \
18394 nCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
18398 static const struct asm_opcode insns[] =
18400 #define ARM_VARIANT & arm_ext_v1 /* Core ARM Instructions. */
18401 #define THUMB_VARIANT & arm_ext_v4t
18402 tCE("and", 0000000, _and, 3, (RR, oRR, SH), arit, t_arit3c),
18403 tC3("ands", 0100000, _ands, 3, (RR, oRR, SH), arit, t_arit3c),
18404 tCE("eor", 0200000, _eor, 3, (RR, oRR, SH), arit, t_arit3c),
18405 tC3("eors", 0300000, _eors, 3, (RR, oRR, SH), arit, t_arit3c),
18406 tCE("sub", 0400000, _sub, 3, (RR, oRR, SH), arit, t_add_sub),
18407 tC3("subs", 0500000, _subs, 3, (RR, oRR, SH), arit, t_add_sub),
18408 tCE("add", 0800000, _add, 3, (RR, oRR, SHG), arit, t_add_sub),
18409 tC3("adds", 0900000, _adds, 3, (RR, oRR, SHG), arit, t_add_sub),
18410 tCE("adc", 0a00000, _adc, 3, (RR, oRR, SH), arit, t_arit3c),
18411 tC3("adcs", 0b00000, _adcs, 3, (RR, oRR, SH), arit, t_arit3c),
18412 tCE("sbc", 0c00000, _sbc, 3, (RR, oRR, SH), arit, t_arit3),
18413 tC3("sbcs", 0d00000, _sbcs, 3, (RR, oRR, SH), arit, t_arit3),
18414 tCE("orr", 1800000, _orr, 3, (RR, oRR, SH), arit, t_arit3c),
18415 tC3("orrs", 1900000, _orrs, 3, (RR, oRR, SH), arit, t_arit3c),
18416 tCE("bic", 1c00000, _bic, 3, (RR, oRR, SH), arit, t_arit3),
18417 tC3("bics", 1d00000, _bics, 3, (RR, oRR, SH), arit, t_arit3),
18419 /* The p-variants of tst/cmp/cmn/teq (below) are the pre-V6 mechanism
18420 for setting PSR flag bits. They are obsolete in V6 and do not
18421 have Thumb equivalents. */
18422 tCE("tst", 1100000, _tst, 2, (RR, SH), cmp, t_mvn_tst),
18423 tC3w("tsts", 1100000, _tst, 2, (RR, SH), cmp, t_mvn_tst),
18424 CL("tstp", 110f000, 2, (RR, SH), cmp),
18425 tCE("cmp", 1500000, _cmp, 2, (RR, SH), cmp, t_mov_cmp),
18426 tC3w("cmps", 1500000, _cmp, 2, (RR, SH), cmp, t_mov_cmp),
18427 CL("cmpp", 150f000, 2, (RR, SH), cmp),
18428 tCE("cmn", 1700000, _cmn, 2, (RR, SH), cmp, t_mvn_tst),
18429 tC3w("cmns", 1700000, _cmn, 2, (RR, SH), cmp, t_mvn_tst),
18430 CL("cmnp", 170f000, 2, (RR, SH), cmp),
18432 tCE("mov", 1a00000, _mov, 2, (RR, SH), mov, t_mov_cmp),
18433 tC3("movs", 1b00000, _movs, 2, (RR, SH), mov, t_mov_cmp),
18434 tCE("mvn", 1e00000, _mvn, 2, (RR, SH), mov, t_mvn_tst),
18435 tC3("mvns", 1f00000, _mvns, 2, (RR, SH), mov, t_mvn_tst),
18437 tCE("ldr", 4100000, _ldr, 2, (RR, ADDRGLDR),ldst, t_ldst),
18438 tC3("ldrb", 4500000, _ldrb, 2, (RRnpc_npcsp, ADDRGLDR),ldst, t_ldst),
18439 tCE("str", 4000000, _str, _2, (MIX_ARM_THUMB_OPERANDS (OP_RR,
18441 OP_ADDRGLDR),ldst, t_ldst),
18442 tC3("strb", 4400000, _strb, 2, (RRnpc_npcsp, ADDRGLDR),ldst, t_ldst),
18444 tCE("stm", 8800000, _stmia, 2, (RRw, REGLST), ldmstm, t_ldmstm),
18445 tC3("stmia", 8800000, _stmia, 2, (RRw, REGLST), ldmstm, t_ldmstm),
18446 tC3("stmea", 8800000, _stmia, 2, (RRw, REGLST), ldmstm, t_ldmstm),
18447 tCE("ldm", 8900000, _ldmia, 2, (RRw, REGLST), ldmstm, t_ldmstm),
18448 tC3("ldmia", 8900000, _ldmia, 2, (RRw, REGLST), ldmstm, t_ldmstm),
18449 tC3("ldmfd", 8900000, _ldmia, 2, (RRw, REGLST), ldmstm, t_ldmstm),
18451 TCE("swi", f000000, df00, 1, (EXPi), swi, t_swi),
18452 TCE("svc", f000000, df00, 1, (EXPi), swi, t_swi),
18453 tCE("b", a000000, _b, 1, (EXPr), branch, t_branch),
18454 TCE("bl", b000000, f000f800, 1, (EXPr), bl, t_branch23),
18457 tCE("adr", 28f0000, _adr, 2, (RR, EXP), adr, t_adr),
18458 C3(adrl, 28f0000, 2, (RR, EXP), adrl),
18459 tCE("nop", 1a00000, _nop, 1, (oI255c), nop, t_nop),
18460 tCE("udf", 7f000f0, _udf, 1, (oIffffb), bkpt, t_udf),
18462 /* Thumb-compatibility pseudo ops. */
18463 tCE("lsl", 1a00000, _lsl, 3, (RR, oRR, SH), shift, t_shift),
18464 tC3("lsls", 1b00000, _lsls, 3, (RR, oRR, SH), shift, t_shift),
18465 tCE("lsr", 1a00020, _lsr, 3, (RR, oRR, SH), shift, t_shift),
18466 tC3("lsrs", 1b00020, _lsrs, 3, (RR, oRR, SH), shift, t_shift),
18467 tCE("asr", 1a00040, _asr, 3, (RR, oRR, SH), shift, t_shift),
18468 tC3("asrs", 1b00040, _asrs, 3, (RR, oRR, SH), shift, t_shift),
18469 tCE("ror", 1a00060, _ror, 3, (RR, oRR, SH), shift, t_shift),
18470 tC3("rors", 1b00060, _rors, 3, (RR, oRR, SH), shift, t_shift),
18471 tCE("neg", 2600000, _neg, 2, (RR, RR), rd_rn, t_neg),
18472 tC3("negs", 2700000, _negs, 2, (RR, RR), rd_rn, t_neg),
18473 tCE("push", 92d0000, _push, 1, (REGLST), push_pop, t_push_pop),
18474 tCE("pop", 8bd0000, _pop, 1, (REGLST), push_pop, t_push_pop),
18476 /* These may simplify to neg. */
18477 TCE("rsb", 0600000, ebc00000, 3, (RR, oRR, SH), arit, t_rsb),
18478 TC3("rsbs", 0700000, ebd00000, 3, (RR, oRR, SH), arit, t_rsb),
18480 #undef THUMB_VARIANT
18481 #define THUMB_VARIANT & arm_ext_v6
18483 TCE("cpy", 1a00000, 4600, 2, (RR, RR), rd_rm, t_cpy),
18485 /* V1 instructions with no Thumb analogue prior to V6T2. */
18486 #undef THUMB_VARIANT
18487 #define THUMB_VARIANT & arm_ext_v6t2
18489 TCE("teq", 1300000, ea900f00, 2, (RR, SH), cmp, t_mvn_tst),
18490 TC3w("teqs", 1300000, ea900f00, 2, (RR, SH), cmp, t_mvn_tst),
18491 CL("teqp", 130f000, 2, (RR, SH), cmp),
18493 TC3("ldrt", 4300000, f8500e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
18494 TC3("ldrbt", 4700000, f8100e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
18495 TC3("strt", 4200000, f8400e00, 2, (RR_npcsp, ADDR), ldstt, t_ldstt),
18496 TC3("strbt", 4600000, f8000e00, 2, (RRnpc_npcsp, ADDR),ldstt, t_ldstt),
18498 TC3("stmdb", 9000000, e9000000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
18499 TC3("stmfd", 9000000, e9000000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
18501 TC3("ldmdb", 9100000, e9100000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
18502 TC3("ldmea", 9100000, e9100000, 2, (RRw, REGLST), ldmstm, t_ldmstm),
18504 /* V1 instructions with no Thumb analogue at all. */
18505 CE("rsc", 0e00000, 3, (RR, oRR, SH), arit),
18506 C3(rscs, 0f00000, 3, (RR, oRR, SH), arit),
18508 C3(stmib, 9800000, 2, (RRw, REGLST), ldmstm),
18509 C3(stmfa, 9800000, 2, (RRw, REGLST), ldmstm),
18510 C3(stmda, 8000000, 2, (RRw, REGLST), ldmstm),
18511 C3(stmed, 8000000, 2, (RRw, REGLST), ldmstm),
18512 C3(ldmib, 9900000, 2, (RRw, REGLST), ldmstm),
18513 C3(ldmed, 9900000, 2, (RRw, REGLST), ldmstm),
18514 C3(ldmda, 8100000, 2, (RRw, REGLST), ldmstm),
18515 C3(ldmfa, 8100000, 2, (RRw, REGLST), ldmstm),
18518 #define ARM_VARIANT & arm_ext_v2 /* ARM 2 - multiplies. */
18519 #undef THUMB_VARIANT
18520 #define THUMB_VARIANT & arm_ext_v4t
18522 tCE("mul", 0000090, _mul, 3, (RRnpc, RRnpc, oRR), mul, t_mul),
18523 tC3("muls", 0100090, _muls, 3, (RRnpc, RRnpc, oRR), mul, t_mul),
18525 #undef THUMB_VARIANT
18526 #define THUMB_VARIANT & arm_ext_v6t2
18528 TCE("mla", 0200090, fb000000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas, t_mla),
18529 C3(mlas, 0300090, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas),
18531 /* Generic coprocessor instructions. */
18532 TCE("cdp", e000000, ee000000, 6, (RCP, I15b, RCN, RCN, RCN, oI7b), cdp, cdp),
18533 TCE("ldc", c100000, ec100000, 3, (RCP, RCN, ADDRGLDC), lstc, lstc),
18534 TC3("ldcl", c500000, ec500000, 3, (RCP, RCN, ADDRGLDC), lstc, lstc),
18535 TCE("stc", c000000, ec000000, 3, (RCP, RCN, ADDRGLDC), lstc, lstc),
18536 TC3("stcl", c400000, ec400000, 3, (RCP, RCN, ADDRGLDC), lstc, lstc),
18537 TCE("mcr", e000010, ee000010, 6, (RCP, I7b, RR, RCN, RCN, oI7b), co_reg, co_reg),
18538 TCE("mrc", e100010, ee100010, 6, (RCP, I7b, APSR_RR, RCN, RCN, oI7b), co_reg, co_reg),
18541 #define ARM_VARIANT & arm_ext_v2s /* ARM 3 - swp instructions. */
18543 CE("swp", 1000090, 3, (RRnpc, RRnpc, RRnpcb), rd_rm_rn),
18544 C3(swpb, 1400090, 3, (RRnpc, RRnpc, RRnpcb), rd_rm_rn),
18547 #define ARM_VARIANT & arm_ext_v3 /* ARM 6 Status register instructions. */
18548 #undef THUMB_VARIANT
18549 #define THUMB_VARIANT & arm_ext_msr
18551 TCE("mrs", 1000000, f3e08000, 2, (RRnpc, rPSR), mrs, t_mrs),
18552 TCE("msr", 120f000, f3808000, 2, (wPSR, RR_EXi), msr, t_msr),
18555 #define ARM_VARIANT & arm_ext_v3m /* ARM 7M long multiplies. */
18556 #undef THUMB_VARIANT
18557 #define THUMB_VARIANT & arm_ext_v6t2
18559 TCE("smull", 0c00090, fb800000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
18560 CM("smull","s", 0d00090, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
18561 TCE("umull", 0800090, fba00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
18562 CM("umull","s", 0900090, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
18563 TCE("smlal", 0e00090, fbc00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
18564 CM("smlal","s", 0f00090, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
18565 TCE("umlal", 0a00090, fbe00000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull, t_mull),
18566 CM("umlal","s", 0b00090, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mull),
18569 #define ARM_VARIANT & arm_ext_v4 /* ARM Architecture 4. */
18570 #undef THUMB_VARIANT
18571 #define THUMB_VARIANT & arm_ext_v4t
18573 tC3("ldrh", 01000b0, _ldrh, 2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
18574 tC3("strh", 00000b0, _strh, 2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
18575 tC3("ldrsh", 01000f0, _ldrsh, 2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
18576 tC3("ldrsb", 01000d0, _ldrsb, 2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
18577 tC3("ldsh", 01000f0, _ldrsh, 2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
18578 tC3("ldsb", 01000d0, _ldrsb, 2, (RRnpc_npcsp, ADDRGLDRS), ldstv4, t_ldst),
18581 #define ARM_VARIANT & arm_ext_v4t_5
18583 /* ARM Architecture 4T. */
18584 /* Note: bx (and blx) are required on V5, even if the processor does
18585 not support Thumb. */
18586 TCE("bx", 12fff10, 4700, 1, (RR), bx, t_bx),
18589 #define ARM_VARIANT & arm_ext_v5 /* ARM Architecture 5T. */
18590 #undef THUMB_VARIANT
18591 #define THUMB_VARIANT & arm_ext_v5t
18593 /* Note: blx has 2 variants; the .value coded here is for
18594 BLX(2). Only this variant has conditional execution. */
18595 TCE("blx", 12fff30, 4780, 1, (RR_EXr), blx, t_blx),
18596 TUE("bkpt", 1200070, be00, 1, (oIffffb), bkpt, t_bkpt),
18598 #undef THUMB_VARIANT
18599 #define THUMB_VARIANT & arm_ext_v6t2
18601 TCE("clz", 16f0f10, fab0f080, 2, (RRnpc, RRnpc), rd_rm, t_clz),
18602 TUF("ldc2", c100000, fc100000, 3, (RCP, RCN, ADDRGLDC), lstc, lstc),
18603 TUF("ldc2l", c500000, fc500000, 3, (RCP, RCN, ADDRGLDC), lstc, lstc),
18604 TUF("stc2", c000000, fc000000, 3, (RCP, RCN, ADDRGLDC), lstc, lstc),
18605 TUF("stc2l", c400000, fc400000, 3, (RCP, RCN, ADDRGLDC), lstc, lstc),
18606 TUF("cdp2", e000000, fe000000, 6, (RCP, I15b, RCN, RCN, RCN, oI7b), cdp, cdp),
18607 TUF("mcr2", e000010, fe000010, 6, (RCP, I7b, RR, RCN, RCN, oI7b), co_reg, co_reg),
18608 TUF("mrc2", e100010, fe100010, 6, (RCP, I7b, RR, RCN, RCN, oI7b), co_reg, co_reg),
18611 #define ARM_VARIANT & arm_ext_v5exp /* ARM Architecture 5TExP. */
18612 #undef THUMB_VARIANT
18613 #define THUMB_VARIANT & arm_ext_v5exp
18615 TCE("smlabb", 1000080, fb100000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), smla, t_mla),
18616 TCE("smlatb", 10000a0, fb100020, 4, (RRnpc, RRnpc, RRnpc, RRnpc), smla, t_mla),
18617 TCE("smlabt", 10000c0, fb100010, 4, (RRnpc, RRnpc, RRnpc, RRnpc), smla, t_mla),
18618 TCE("smlatt", 10000e0, fb100030, 4, (RRnpc, RRnpc, RRnpc, RRnpc), smla, t_mla),
18620 TCE("smlawb", 1200080, fb300000, 4, (RRnpc, RRnpc, RRnpc, RRnpc), smla, t_mla),
18621 TCE("smlawt", 12000c0, fb300010, 4, (RRnpc, RRnpc, RRnpc, RRnpc), smla, t_mla),
18623 TCE("smlalbb", 1400080, fbc00080, 4, (RRnpc, RRnpc, RRnpc, RRnpc), smlal, t_mlal),
18624 TCE("smlaltb", 14000a0, fbc000a0, 4, (RRnpc, RRnpc, RRnpc, RRnpc), smlal, t_mlal),
18625 TCE("smlalbt", 14000c0, fbc00090, 4, (RRnpc, RRnpc, RRnpc, RRnpc), smlal, t_mlal),
18626 TCE("smlaltt", 14000e0, fbc000b0, 4, (RRnpc, RRnpc, RRnpc, RRnpc), smlal, t_mlal),
18628 TCE("smulbb", 1600080, fb10f000, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18629 TCE("smultb", 16000a0, fb10f020, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18630 TCE("smulbt", 16000c0, fb10f010, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18631 TCE("smultt", 16000e0, fb10f030, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18633 TCE("smulwb", 12000a0, fb30f000, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18634 TCE("smulwt", 12000e0, fb30f010, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18636 TCE("qadd", 1000050, fa80f080, 3, (RRnpc, RRnpc, RRnpc), rd_rm_rn, t_simd2),
18637 TCE("qdadd", 1400050, fa80f090, 3, (RRnpc, RRnpc, RRnpc), rd_rm_rn, t_simd2),
18638 TCE("qsub", 1200050, fa80f0a0, 3, (RRnpc, RRnpc, RRnpc), rd_rm_rn, t_simd2),
18639 TCE("qdsub", 1600050, fa80f0b0, 3, (RRnpc, RRnpc, RRnpc), rd_rm_rn, t_simd2),
18642 #define ARM_VARIANT & arm_ext_v5e /* ARM Architecture 5TE. */
18643 #undef THUMB_VARIANT
18644 #define THUMB_VARIANT & arm_ext_v6t2
18646 TUF("pld", 450f000, f810f000, 1, (ADDR), pld, t_pld),
18647 TC3("ldrd", 00000d0, e8500000, 3, (RRnpc_npcsp, oRRnpc_npcsp, ADDRGLDRS),
18649 TC3("strd", 00000f0, e8400000, 3, (RRnpc_npcsp, oRRnpc_npcsp,
18650 ADDRGLDRS), ldrd, t_ldstd),
18652 TCE("mcrr", c400000, ec400000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
18653 TCE("mrrc", c500000, ec500000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
18656 #define ARM_VARIANT & arm_ext_v5j /* ARM Architecture 5TEJ. */
18658 TCE("bxj", 12fff20, f3c08f00, 1, (RR), bxj, t_bxj),
18661 #define ARM_VARIANT & arm_ext_v6 /* ARM V6. */
18662 #undef THUMB_VARIANT
18663 #define THUMB_VARIANT & arm_ext_v6
18665 TUF("cpsie", 1080000, b660, 2, (CPSF, oI31b), cpsi, t_cpsi),
18666 TUF("cpsid", 10c0000, b670, 2, (CPSF, oI31b), cpsi, t_cpsi),
18667 tCE("rev", 6bf0f30, _rev, 2, (RRnpc, RRnpc), rd_rm, t_rev),
18668 tCE("rev16", 6bf0fb0, _rev16, 2, (RRnpc, RRnpc), rd_rm, t_rev),
18669 tCE("revsh", 6ff0fb0, _revsh, 2, (RRnpc, RRnpc), rd_rm, t_rev),
18670 tCE("sxth", 6bf0070, _sxth, 3, (RRnpc, RRnpc, oROR), sxth, t_sxth),
18671 tCE("uxth", 6ff0070, _uxth, 3, (RRnpc, RRnpc, oROR), sxth, t_sxth),
18672 tCE("sxtb", 6af0070, _sxtb, 3, (RRnpc, RRnpc, oROR), sxth, t_sxth),
18673 tCE("uxtb", 6ef0070, _uxtb, 3, (RRnpc, RRnpc, oROR), sxth, t_sxth),
18674 TUF("setend", 1010000, b650, 1, (ENDI), setend, t_setend),
18676 #undef THUMB_VARIANT
18677 #define THUMB_VARIANT & arm_ext_v6t2
18679 TCE("ldrex", 1900f9f, e8500f00, 2, (RRnpc_npcsp, ADDR), ldrex, t_ldrex),
18680 TCE("strex", 1800f90, e8400000, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
18682 TUF("mcrr2", c400000, fc400000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
18683 TUF("mrrc2", c500000, fc500000, 5, (RCP, I15b, RRnpc, RRnpc, RCN), co_reg2c, co_reg2c),
18685 TCE("ssat", 6a00010, f3000000, 4, (RRnpc, I32, RRnpc, oSHllar),ssat, t_ssat),
18686 TCE("usat", 6e00010, f3800000, 4, (RRnpc, I31, RRnpc, oSHllar),usat, t_usat),
18688 /* ARM V6 not included in V7M. */
18689 #undef THUMB_VARIANT
18690 #define THUMB_VARIANT & arm_ext_v6_notm
18691 TUF("rfeia", 8900a00, e990c000, 1, (RRw), rfe, rfe),
18692 TUF("rfe", 8900a00, e990c000, 1, (RRw), rfe, rfe),
18693 UF(rfeib, 9900a00, 1, (RRw), rfe),
18694 UF(rfeda, 8100a00, 1, (RRw), rfe),
18695 TUF("rfedb", 9100a00, e810c000, 1, (RRw), rfe, rfe),
18696 TUF("rfefd", 8900a00, e990c000, 1, (RRw), rfe, rfe),
18697 UF(rfefa, 8100a00, 1, (RRw), rfe),
18698 TUF("rfeea", 9100a00, e810c000, 1, (RRw), rfe, rfe),
18699 UF(rfeed, 9900a00, 1, (RRw), rfe),
18700 TUF("srsia", 8c00500, e980c000, 2, (oRRw, I31w), srs, srs),
18701 TUF("srs", 8c00500, e980c000, 2, (oRRw, I31w), srs, srs),
18702 TUF("srsea", 8c00500, e980c000, 2, (oRRw, I31w), srs, srs),
18703 UF(srsib, 9c00500, 2, (oRRw, I31w), srs),
18704 UF(srsfa, 9c00500, 2, (oRRw, I31w), srs),
18705 UF(srsda, 8400500, 2, (oRRw, I31w), srs),
18706 UF(srsed, 8400500, 2, (oRRw, I31w), srs),
18707 TUF("srsdb", 9400500, e800c000, 2, (oRRw, I31w), srs, srs),
18708 TUF("srsfd", 9400500, e800c000, 2, (oRRw, I31w), srs, srs),
18710 /* ARM V6 not included in V7M (eg. integer SIMD). */
18711 #undef THUMB_VARIANT
18712 #define THUMB_VARIANT & arm_ext_v6_dsp
18713 TUF("cps", 1020000, f3af8100, 1, (I31b), imm0, t_cps),
18714 TCE("pkhbt", 6800010, eac00000, 4, (RRnpc, RRnpc, RRnpc, oSHll), pkhbt, t_pkhbt),
18715 TCE("pkhtb", 6800050, eac00020, 4, (RRnpc, RRnpc, RRnpc, oSHar), pkhtb, t_pkhtb),
18716 TCE("qadd16", 6200f10, fa90f010, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18717 TCE("qadd8", 6200f90, fa80f010, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18718 TCE("qasx", 6200f30, faa0f010, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18719 /* Old name for QASX. */
18720 TCE("qaddsubx",6200f30, faa0f010, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18721 TCE("qsax", 6200f50, fae0f010, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18722 /* Old name for QSAX. */
18723 TCE("qsubaddx",6200f50, fae0f010, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18724 TCE("qsub16", 6200f70, fad0f010, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18725 TCE("qsub8", 6200ff0, fac0f010, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18726 TCE("sadd16", 6100f10, fa90f000, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18727 TCE("sadd8", 6100f90, fa80f000, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18728 TCE("sasx", 6100f30, faa0f000, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18729 /* Old name for SASX. */
18730 TCE("saddsubx",6100f30, faa0f000, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18731 TCE("shadd16", 6300f10, fa90f020, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18732 TCE("shadd8", 6300f90, fa80f020, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18733 TCE("shasx", 6300f30, faa0f020, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18734 /* Old name for SHASX. */
18735 TCE("shaddsubx", 6300f30, faa0f020, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18736 TCE("shsax", 6300f50, fae0f020, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18737 /* Old name for SHSAX. */
18738 TCE("shsubaddx", 6300f50, fae0f020, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18739 TCE("shsub16", 6300f70, fad0f020, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18740 TCE("shsub8", 6300ff0, fac0f020, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18741 TCE("ssax", 6100f50, fae0f000, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18742 /* Old name for SSAX. */
18743 TCE("ssubaddx",6100f50, fae0f000, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18744 TCE("ssub16", 6100f70, fad0f000, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18745 TCE("ssub8", 6100ff0, fac0f000, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18746 TCE("uadd16", 6500f10, fa90f040, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18747 TCE("uadd8", 6500f90, fa80f040, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18748 TCE("uasx", 6500f30, faa0f040, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18749 /* Old name for UASX. */
18750 TCE("uaddsubx",6500f30, faa0f040, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18751 TCE("uhadd16", 6700f10, fa90f060, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18752 TCE("uhadd8", 6700f90, fa80f060, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18753 TCE("uhasx", 6700f30, faa0f060, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18754 /* Old name for UHASX. */
18755 TCE("uhaddsubx", 6700f30, faa0f060, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18756 TCE("uhsax", 6700f50, fae0f060, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18757 /* Old name for UHSAX. */
18758 TCE("uhsubaddx", 6700f50, fae0f060, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18759 TCE("uhsub16", 6700f70, fad0f060, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18760 TCE("uhsub8", 6700ff0, fac0f060, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18761 TCE("uqadd16", 6600f10, fa90f050, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18762 TCE("uqadd8", 6600f90, fa80f050, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18763 TCE("uqasx", 6600f30, faa0f050, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18764 /* Old name for UQASX. */
18765 TCE("uqaddsubx", 6600f30, faa0f050, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18766 TCE("uqsax", 6600f50, fae0f050, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18767 /* Old name for UQSAX. */
18768 TCE("uqsubaddx", 6600f50, fae0f050, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18769 TCE("uqsub16", 6600f70, fad0f050, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18770 TCE("uqsub8", 6600ff0, fac0f050, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18771 TCE("usub16", 6500f70, fad0f040, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18772 TCE("usax", 6500f50, fae0f040, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18773 /* Old name for USAX. */
18774 TCE("usubaddx",6500f50, fae0f040, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18775 TCE("usub8", 6500ff0, fac0f040, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18776 TCE("sxtah", 6b00070, fa00f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18777 TCE("sxtab16", 6800070, fa20f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18778 TCE("sxtab", 6a00070, fa40f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18779 TCE("sxtb16", 68f0070, fa2ff080, 3, (RRnpc, RRnpc, oROR), sxth, t_sxth),
18780 TCE("uxtah", 6f00070, fa10f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18781 TCE("uxtab16", 6c00070, fa30f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18782 TCE("uxtab", 6e00070, fa50f080, 4, (RRnpc, RRnpc, RRnpc, oROR), sxtah, t_sxtah),
18783 TCE("uxtb16", 6cf0070, fa3ff080, 3, (RRnpc, RRnpc, oROR), sxth, t_sxth),
18784 TCE("sel", 6800fb0, faa0f080, 3, (RRnpc, RRnpc, RRnpc), rd_rn_rm, t_simd),
18785 TCE("smlad", 7000010, fb200000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18786 TCE("smladx", 7000030, fb200010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18787 TCE("smlald", 7400010, fbc000c0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
18788 TCE("smlaldx", 7400030, fbc000d0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
18789 TCE("smlsd", 7000050, fb400000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18790 TCE("smlsdx", 7000070, fb400010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18791 TCE("smlsld", 7400050, fbd000c0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
18792 TCE("smlsldx", 7400070, fbd000d0, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal,t_mlal),
18793 TCE("smmla", 7500010, fb500000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18794 TCE("smmlar", 7500030, fb500010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18795 TCE("smmls", 75000d0, fb600000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18796 TCE("smmlsr", 75000f0, fb600010, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18797 TCE("smmul", 750f010, fb50f000, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18798 TCE("smmulr", 750f030, fb50f010, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18799 TCE("smuad", 700f010, fb20f000, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18800 TCE("smuadx", 700f030, fb20f010, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18801 TCE("smusd", 700f050, fb40f000, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18802 TCE("smusdx", 700f070, fb40f010, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18803 TCE("ssat16", 6a00f30, f3200000, 3, (RRnpc, I16, RRnpc), ssat16, t_ssat16),
18804 TCE("umaal", 0400090, fbe00060, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smlal, t_mlal),
18805 TCE("usad8", 780f010, fb70f000, 3, (RRnpc, RRnpc, RRnpc), smul, t_simd),
18806 TCE("usada8", 7800010, fb700000, 4, (RRnpc, RRnpc, RRnpc, RRnpc),smla, t_mla),
18807 TCE("usat16", 6e00f30, f3a00000, 3, (RRnpc, I15, RRnpc), usat16, t_usat16),
18810 #define ARM_VARIANT & arm_ext_v6k
18811 #undef THUMB_VARIANT
18812 #define THUMB_VARIANT & arm_ext_v6k
18814 tCE("yield", 320f001, _yield, 0, (), noargs, t_hint),
18815 tCE("wfe", 320f002, _wfe, 0, (), noargs, t_hint),
18816 tCE("wfi", 320f003, _wfi, 0, (), noargs, t_hint),
18817 tCE("sev", 320f004, _sev, 0, (), noargs, t_hint),
18819 #undef THUMB_VARIANT
18820 #define THUMB_VARIANT & arm_ext_v6_notm
18821 TCE("ldrexd", 1b00f9f, e8d0007f, 3, (RRnpc_npcsp, oRRnpc_npcsp, RRnpcb),
18823 TCE("strexd", 1a00f90, e8c00070, 4, (RRnpc_npcsp, RRnpc_npcsp, oRRnpc_npcsp,
18824 RRnpcb), strexd, t_strexd),
18826 #undef THUMB_VARIANT
18827 #define THUMB_VARIANT & arm_ext_v6t2
18828 TCE("ldrexb", 1d00f9f, e8d00f4f, 2, (RRnpc_npcsp,RRnpcb),
18830 TCE("ldrexh", 1f00f9f, e8d00f5f, 2, (RRnpc_npcsp, RRnpcb),
18832 TCE("strexb", 1c00f90, e8c00f40, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
18834 TCE("strexh", 1e00f90, e8c00f50, 3, (RRnpc_npcsp, RRnpc_npcsp, ADDR),
18836 TUF("clrex", 57ff01f, f3bf8f2f, 0, (), noargs, noargs),
18839 #define ARM_VARIANT & arm_ext_sec
18840 #undef THUMB_VARIANT
18841 #define THUMB_VARIANT & arm_ext_sec
18843 TCE("smc", 1600070, f7f08000, 1, (EXPi), smc, t_smc),
18846 #define ARM_VARIANT & arm_ext_virt
18847 #undef THUMB_VARIANT
18848 #define THUMB_VARIANT & arm_ext_virt
18850 TCE("hvc", 1400070, f7e08000, 1, (EXPi), hvc, t_hvc),
18851 TCE("eret", 160006e, f3de8f00, 0, (), noargs, noargs),
18854 #define ARM_VARIANT & arm_ext_v6t2
18855 #undef THUMB_VARIANT
18856 #define THUMB_VARIANT & arm_ext_v6t2
18858 TCE("bfc", 7c0001f, f36f0000, 3, (RRnpc, I31, I32), bfc, t_bfc),
18859 TCE("bfi", 7c00010, f3600000, 4, (RRnpc, RRnpc_I0, I31, I32), bfi, t_bfi),
18860 TCE("sbfx", 7a00050, f3400000, 4, (RR, RR, I31, I32), bfx, t_bfx),
18861 TCE("ubfx", 7e00050, f3c00000, 4, (RR, RR, I31, I32), bfx, t_bfx),
18863 TCE("mls", 0600090, fb000010, 4, (RRnpc, RRnpc, RRnpc, RRnpc), mlas, t_mla),
18864 TCE("movw", 3000000, f2400000, 2, (RRnpc, HALF), mov16, t_mov16),
18865 TCE("movt", 3400000, f2c00000, 2, (RRnpc, HALF), mov16, t_mov16),
18866 TCE("rbit", 6ff0f30, fa90f0a0, 2, (RR, RR), rd_rm, t_rbit),
18868 TC3("ldrht", 03000b0, f8300e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
18869 TC3("ldrsht", 03000f0, f9300e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
18870 TC3("ldrsbt", 03000d0, f9100e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
18871 TC3("strht", 02000b0, f8200e00, 2, (RRnpc_npcsp, ADDR), ldsttv4, t_ldstt),
18873 /* Thumb-only instructions. */
18875 #define ARM_VARIANT NULL
18876 TUE("cbnz", 0, b900, 2, (RR, EXP), 0, t_cbz),
18877 TUE("cbz", 0, b100, 2, (RR, EXP), 0, t_cbz),
18879 /* ARM does not really have an IT instruction, so always allow it.
18880 The opcode is copied from Thumb in order to allow warnings in
18881 -mimplicit-it=[never | arm] modes. */
18883 #define ARM_VARIANT & arm_ext_v1
18885 TUE("it", bf08, bf08, 1, (COND), it, t_it),
18886 TUE("itt", bf0c, bf0c, 1, (COND), it, t_it),
18887 TUE("ite", bf04, bf04, 1, (COND), it, t_it),
18888 TUE("ittt", bf0e, bf0e, 1, (COND), it, t_it),
18889 TUE("itet", bf06, bf06, 1, (COND), it, t_it),
18890 TUE("itte", bf0a, bf0a, 1, (COND), it, t_it),
18891 TUE("itee", bf02, bf02, 1, (COND), it, t_it),
18892 TUE("itttt", bf0f, bf0f, 1, (COND), it, t_it),
18893 TUE("itett", bf07, bf07, 1, (COND), it, t_it),
18894 TUE("ittet", bf0b, bf0b, 1, (COND), it, t_it),
18895 TUE("iteet", bf03, bf03, 1, (COND), it, t_it),
18896 TUE("ittte", bf0d, bf0d, 1, (COND), it, t_it),
18897 TUE("itete", bf05, bf05, 1, (COND), it, t_it),
18898 TUE("ittee", bf09, bf09, 1, (COND), it, t_it),
18899 TUE("iteee", bf01, bf01, 1, (COND), it, t_it),
18900 /* ARM/Thumb-2 instructions with no Thumb-1 equivalent. */
18901 TC3("rrx", 01a00060, ea4f0030, 2, (RR, RR), rd_rm, t_rrx),
18902 TC3("rrxs", 01b00060, ea5f0030, 2, (RR, RR), rd_rm, t_rrx),
18904 /* Thumb2 only instructions. */
18906 #define ARM_VARIANT NULL
18908 TCE("addw", 0, f2000000, 3, (RR, RR, EXPi), 0, t_add_sub_w),
18909 TCE("subw", 0, f2a00000, 3, (RR, RR, EXPi), 0, t_add_sub_w),
18910 TCE("orn", 0, ea600000, 3, (RR, oRR, SH), 0, t_orn),
18911 TCE("orns", 0, ea700000, 3, (RR, oRR, SH), 0, t_orn),
18912 TCE("tbb", 0, e8d0f000, 1, (TB), 0, t_tb),
18913 TCE("tbh", 0, e8d0f010, 1, (TB), 0, t_tb),
18915 /* Hardware division instructions. */
18917 #define ARM_VARIANT & arm_ext_adiv
18918 #undef THUMB_VARIANT
18919 #define THUMB_VARIANT & arm_ext_div
18921 TCE("sdiv", 710f010, fb90f0f0, 3, (RR, oRR, RR), div, t_div),
18922 TCE("udiv", 730f010, fbb0f0f0, 3, (RR, oRR, RR), div, t_div),
18924 /* ARM V6M/V7 instructions. */
18926 #define ARM_VARIANT & arm_ext_barrier
18927 #undef THUMB_VARIANT
18928 #define THUMB_VARIANT & arm_ext_barrier
18930 TUF("dmb", 57ff050, f3bf8f50, 1, (oBARRIER_I15), barrier, barrier),
18931 TUF("dsb", 57ff040, f3bf8f40, 1, (oBARRIER_I15), barrier, barrier),
18932 TUF("isb", 57ff060, f3bf8f60, 1, (oBARRIER_I15), barrier, barrier),
18934 /* ARM V7 instructions. */
18936 #define ARM_VARIANT & arm_ext_v7
18937 #undef THUMB_VARIANT
18938 #define THUMB_VARIANT & arm_ext_v7
18940 TUF("pli", 450f000, f910f000, 1, (ADDR), pli, t_pld),
18941 TCE("dbg", 320f0f0, f3af80f0, 1, (I15), dbg, t_dbg),
18944 #define ARM_VARIANT & arm_ext_mp
18945 #undef THUMB_VARIANT
18946 #define THUMB_VARIANT & arm_ext_mp
18948 TUF("pldw", 410f000, f830f000, 1, (ADDR), pld, t_pld),
18950 /* AArchv8 instructions. */
18952 #define ARM_VARIANT & arm_ext_v8
18953 #undef THUMB_VARIANT
18954 #define THUMB_VARIANT & arm_ext_v8
18956 tCE("sevl", 320f005, _sevl, 0, (), noargs, t_hint),
18957 TUE("hlt", 1000070, ba80, 1, (oIffffb), bkpt, t_hlt),
18958 TCE("ldaex", 1900e9f, e8d00fef, 2, (RRnpc, RRnpcb), rd_rn, rd_rn),
18959 TCE("ldaexd", 1b00e9f, e8d000ff, 3, (RRnpc, oRRnpc, RRnpcb),
18961 TCE("ldaexb", 1d00e9f, e8d00fcf, 2, (RRnpc,RRnpcb), rd_rn, rd_rn),
18962 TCE("ldaexh", 1f00e9f, e8d00fdf, 2, (RRnpc, RRnpcb), rd_rn, rd_rn),
18963 TCE("stlex", 1800e90, e8c00fe0, 3, (RRnpc, RRnpc, RRnpcb),
18965 TCE("stlexd", 1a00e90, e8c000f0, 4, (RRnpc, RRnpc, oRRnpc, RRnpcb),
18967 TCE("stlexb", 1c00e90, e8c00fc0, 3, (RRnpc, RRnpc, RRnpcb),
18969 TCE("stlexh", 1e00e90, e8c00fd0, 3, (RRnpc, RRnpc, RRnpcb),
18971 TCE("lda", 1900c9f, e8d00faf, 2, (RRnpc, RRnpcb), rd_rn, rd_rn),
18972 TCE("ldab", 1d00c9f, e8d00f8f, 2, (RRnpc, RRnpcb), rd_rn, rd_rn),
18973 TCE("ldah", 1f00c9f, e8d00f9f, 2, (RRnpc, RRnpcb), rd_rn, rd_rn),
18974 TCE("stl", 180fc90, e8c00faf, 2, (RRnpc, RRnpcb), rm_rn, rd_rn),
18975 TCE("stlb", 1c0fc90, e8c00f8f, 2, (RRnpc, RRnpcb), rm_rn, rd_rn),
18976 TCE("stlh", 1e0fc90, e8c00f9f, 2, (RRnpc, RRnpcb), rm_rn, rd_rn),
18978 /* ARMv8 T32 only. */
18980 #define ARM_VARIANT NULL
18981 TUF("dcps1", 0, f78f8001, 0, (), noargs, noargs),
18982 TUF("dcps2", 0, f78f8002, 0, (), noargs, noargs),
18983 TUF("dcps3", 0, f78f8003, 0, (), noargs, noargs),
18985 /* FP for ARMv8. */
18987 #define ARM_VARIANT & fpu_vfp_ext_armv8xd
18988 #undef THUMB_VARIANT
18989 #define THUMB_VARIANT & fpu_vfp_ext_armv8xd
18991 nUF(vseleq, _vseleq, 3, (RVSD, RVSD, RVSD), vsel),
18992 nUF(vselvs, _vselvs, 3, (RVSD, RVSD, RVSD), vsel),
18993 nUF(vselge, _vselge, 3, (RVSD, RVSD, RVSD), vsel),
18994 nUF(vselgt, _vselgt, 3, (RVSD, RVSD, RVSD), vsel),
18995 nUF(vmaxnm, _vmaxnm, 3, (RNSDQ, oRNSDQ, RNSDQ), vmaxnm),
18996 nUF(vminnm, _vminnm, 3, (RNSDQ, oRNSDQ, RNSDQ), vmaxnm),
18997 nUF(vcvta, _vcvta, 2, (RNSDQ, oRNSDQ), neon_cvta),
18998 nUF(vcvtn, _vcvta, 2, (RNSDQ, oRNSDQ), neon_cvtn),
18999 nUF(vcvtp, _vcvta, 2, (RNSDQ, oRNSDQ), neon_cvtp),
19000 nUF(vcvtm, _vcvta, 2, (RNSDQ, oRNSDQ), neon_cvtm),
19001 nCE(vrintr, _vrintr, 2, (RNSDQ, oRNSDQ), vrintr),
19002 nCE(vrintz, _vrintr, 2, (RNSDQ, oRNSDQ), vrintz),
19003 nCE(vrintx, _vrintr, 2, (RNSDQ, oRNSDQ), vrintx),
19004 nUF(vrinta, _vrinta, 2, (RNSDQ, oRNSDQ), vrinta),
19005 nUF(vrintn, _vrinta, 2, (RNSDQ, oRNSDQ), vrintn),
19006 nUF(vrintp, _vrinta, 2, (RNSDQ, oRNSDQ), vrintp),
19007 nUF(vrintm, _vrinta, 2, (RNSDQ, oRNSDQ), vrintm),
19009 /* Crypto v1 extensions. */
19011 #define ARM_VARIANT & fpu_crypto_ext_armv8
19012 #undef THUMB_VARIANT
19013 #define THUMB_VARIANT & fpu_crypto_ext_armv8
19015 nUF(aese, _aes, 2, (RNQ, RNQ), aese),
19016 nUF(aesd, _aes, 2, (RNQ, RNQ), aesd),
19017 nUF(aesmc, _aes, 2, (RNQ, RNQ), aesmc),
19018 nUF(aesimc, _aes, 2, (RNQ, RNQ), aesimc),
19019 nUF(sha1c, _sha3op, 3, (RNQ, RNQ, RNQ), sha1c),
19020 nUF(sha1p, _sha3op, 3, (RNQ, RNQ, RNQ), sha1p),
19021 nUF(sha1m, _sha3op, 3, (RNQ, RNQ, RNQ), sha1m),
19022 nUF(sha1su0, _sha3op, 3, (RNQ, RNQ, RNQ), sha1su0),
19023 nUF(sha256h, _sha3op, 3, (RNQ, RNQ, RNQ), sha256h),
19024 nUF(sha256h2, _sha3op, 3, (RNQ, RNQ, RNQ), sha256h2),
19025 nUF(sha256su1, _sha3op, 3, (RNQ, RNQ, RNQ), sha256su1),
19026 nUF(sha1h, _sha1h, 2, (RNQ, RNQ), sha1h),
19027 nUF(sha1su1, _sha2op, 2, (RNQ, RNQ), sha1su1),
19028 nUF(sha256su0, _sha2op, 2, (RNQ, RNQ), sha256su0),
19031 #define ARM_VARIANT & crc_ext_armv8
19032 #undef THUMB_VARIANT
19033 #define THUMB_VARIANT & crc_ext_armv8
19034 TUEc("crc32b", 1000040, fac0f080, 3, (RR, oRR, RR), crc32b),
19035 TUEc("crc32h", 1200040, fac0f090, 3, (RR, oRR, RR), crc32h),
19036 TUEc("crc32w", 1400040, fac0f0a0, 3, (RR, oRR, RR), crc32w),
19037 TUEc("crc32cb",1000240, fad0f080, 3, (RR, oRR, RR), crc32cb),
19038 TUEc("crc32ch",1200240, fad0f090, 3, (RR, oRR, RR), crc32ch),
19039 TUEc("crc32cw",1400240, fad0f0a0, 3, (RR, oRR, RR), crc32cw),
19042 #define ARM_VARIANT & fpu_fpa_ext_v1 /* Core FPA instruction set (V1). */
19043 #undef THUMB_VARIANT
19044 #define THUMB_VARIANT NULL
19046 cCE("wfs", e200110, 1, (RR), rd),
19047 cCE("rfs", e300110, 1, (RR), rd),
19048 cCE("wfc", e400110, 1, (RR), rd),
19049 cCE("rfc", e500110, 1, (RR), rd),
19051 cCL("ldfs", c100100, 2, (RF, ADDRGLDC), rd_cpaddr),
19052 cCL("ldfd", c108100, 2, (RF, ADDRGLDC), rd_cpaddr),
19053 cCL("ldfe", c500100, 2, (RF, ADDRGLDC), rd_cpaddr),
19054 cCL("ldfp", c508100, 2, (RF, ADDRGLDC), rd_cpaddr),
19056 cCL("stfs", c000100, 2, (RF, ADDRGLDC), rd_cpaddr),
19057 cCL("stfd", c008100, 2, (RF, ADDRGLDC), rd_cpaddr),
19058 cCL("stfe", c400100, 2, (RF, ADDRGLDC), rd_cpaddr),
19059 cCL("stfp", c408100, 2, (RF, ADDRGLDC), rd_cpaddr),
19061 cCL("mvfs", e008100, 2, (RF, RF_IF), rd_rm),
19062 cCL("mvfsp", e008120, 2, (RF, RF_IF), rd_rm),
19063 cCL("mvfsm", e008140, 2, (RF, RF_IF), rd_rm),
19064 cCL("mvfsz", e008160, 2, (RF, RF_IF), rd_rm),
19065 cCL("mvfd", e008180, 2, (RF, RF_IF), rd_rm),
19066 cCL("mvfdp", e0081a0, 2, (RF, RF_IF), rd_rm),
19067 cCL("mvfdm", e0081c0, 2, (RF, RF_IF), rd_rm),
19068 cCL("mvfdz", e0081e0, 2, (RF, RF_IF), rd_rm),
19069 cCL("mvfe", e088100, 2, (RF, RF_IF), rd_rm),
19070 cCL("mvfep", e088120, 2, (RF, RF_IF), rd_rm),
19071 cCL("mvfem", e088140, 2, (RF, RF_IF), rd_rm),
19072 cCL("mvfez", e088160, 2, (RF, RF_IF), rd_rm),
19074 cCL("mnfs", e108100, 2, (RF, RF_IF), rd_rm),
19075 cCL("mnfsp", e108120, 2, (RF, RF_IF), rd_rm),
19076 cCL("mnfsm", e108140, 2, (RF, RF_IF), rd_rm),
19077 cCL("mnfsz", e108160, 2, (RF, RF_IF), rd_rm),
19078 cCL("mnfd", e108180, 2, (RF, RF_IF), rd_rm),
19079 cCL("mnfdp", e1081a0, 2, (RF, RF_IF), rd_rm),
19080 cCL("mnfdm", e1081c0, 2, (RF, RF_IF), rd_rm),
19081 cCL("mnfdz", e1081e0, 2, (RF, RF_IF), rd_rm),
19082 cCL("mnfe", e188100, 2, (RF, RF_IF), rd_rm),
19083 cCL("mnfep", e188120, 2, (RF, RF_IF), rd_rm),
19084 cCL("mnfem", e188140, 2, (RF, RF_IF), rd_rm),
19085 cCL("mnfez", e188160, 2, (RF, RF_IF), rd_rm),
19087 cCL("abss", e208100, 2, (RF, RF_IF), rd_rm),
19088 cCL("abssp", e208120, 2, (RF, RF_IF), rd_rm),
19089 cCL("abssm", e208140, 2, (RF, RF_IF), rd_rm),
19090 cCL("abssz", e208160, 2, (RF, RF_IF), rd_rm),
19091 cCL("absd", e208180, 2, (RF, RF_IF), rd_rm),
19092 cCL("absdp", e2081a0, 2, (RF, RF_IF), rd_rm),
19093 cCL("absdm", e2081c0, 2, (RF, RF_IF), rd_rm),
19094 cCL("absdz", e2081e0, 2, (RF, RF_IF), rd_rm),
19095 cCL("abse", e288100, 2, (RF, RF_IF), rd_rm),
19096 cCL("absep", e288120, 2, (RF, RF_IF), rd_rm),
19097 cCL("absem", e288140, 2, (RF, RF_IF), rd_rm),
19098 cCL("absez", e288160, 2, (RF, RF_IF), rd_rm),
19100 cCL("rnds", e308100, 2, (RF, RF_IF), rd_rm),
19101 cCL("rndsp", e308120, 2, (RF, RF_IF), rd_rm),
19102 cCL("rndsm", e308140, 2, (RF, RF_IF), rd_rm),
19103 cCL("rndsz", e308160, 2, (RF, RF_IF), rd_rm),
19104 cCL("rndd", e308180, 2, (RF, RF_IF), rd_rm),
19105 cCL("rnddp", e3081a0, 2, (RF, RF_IF), rd_rm),
19106 cCL("rnddm", e3081c0, 2, (RF, RF_IF), rd_rm),
19107 cCL("rnddz", e3081e0, 2, (RF, RF_IF), rd_rm),
19108 cCL("rnde", e388100, 2, (RF, RF_IF), rd_rm),
19109 cCL("rndep", e388120, 2, (RF, RF_IF), rd_rm),
19110 cCL("rndem", e388140, 2, (RF, RF_IF), rd_rm),
19111 cCL("rndez", e388160, 2, (RF, RF_IF), rd_rm),
19113 cCL("sqts", e408100, 2, (RF, RF_IF), rd_rm),
19114 cCL("sqtsp", e408120, 2, (RF, RF_IF), rd_rm),
19115 cCL("sqtsm", e408140, 2, (RF, RF_IF), rd_rm),
19116 cCL("sqtsz", e408160, 2, (RF, RF_IF), rd_rm),
19117 cCL("sqtd", e408180, 2, (RF, RF_IF), rd_rm),
19118 cCL("sqtdp", e4081a0, 2, (RF, RF_IF), rd_rm),
19119 cCL("sqtdm", e4081c0, 2, (RF, RF_IF), rd_rm),
19120 cCL("sqtdz", e4081e0, 2, (RF, RF_IF), rd_rm),
19121 cCL("sqte", e488100, 2, (RF, RF_IF), rd_rm),
19122 cCL("sqtep", e488120, 2, (RF, RF_IF), rd_rm),
19123 cCL("sqtem", e488140, 2, (RF, RF_IF), rd_rm),
19124 cCL("sqtez", e488160, 2, (RF, RF_IF), rd_rm),
19126 cCL("logs", e508100, 2, (RF, RF_IF), rd_rm),
19127 cCL("logsp", e508120, 2, (RF, RF_IF), rd_rm),
19128 cCL("logsm", e508140, 2, (RF, RF_IF), rd_rm),
19129 cCL("logsz", e508160, 2, (RF, RF_IF), rd_rm),
19130 cCL("logd", e508180, 2, (RF, RF_IF), rd_rm),
19131 cCL("logdp", e5081a0, 2, (RF, RF_IF), rd_rm),
19132 cCL("logdm", e5081c0, 2, (RF, RF_IF), rd_rm),
19133 cCL("logdz", e5081e0, 2, (RF, RF_IF), rd_rm),
19134 cCL("loge", e588100, 2, (RF, RF_IF), rd_rm),
19135 cCL("logep", e588120, 2, (RF, RF_IF), rd_rm),
19136 cCL("logem", e588140, 2, (RF, RF_IF), rd_rm),
19137 cCL("logez", e588160, 2, (RF, RF_IF), rd_rm),
19139 cCL("lgns", e608100, 2, (RF, RF_IF), rd_rm),
19140 cCL("lgnsp", e608120, 2, (RF, RF_IF), rd_rm),
19141 cCL("lgnsm", e608140, 2, (RF, RF_IF), rd_rm),
19142 cCL("lgnsz", e608160, 2, (RF, RF_IF), rd_rm),
19143 cCL("lgnd", e608180, 2, (RF, RF_IF), rd_rm),
19144 cCL("lgndp", e6081a0, 2, (RF, RF_IF), rd_rm),
19145 cCL("lgndm", e6081c0, 2, (RF, RF_IF), rd_rm),
19146 cCL("lgndz", e6081e0, 2, (RF, RF_IF), rd_rm),
19147 cCL("lgne", e688100, 2, (RF, RF_IF), rd_rm),
19148 cCL("lgnep", e688120, 2, (RF, RF_IF), rd_rm),
19149 cCL("lgnem", e688140, 2, (RF, RF_IF), rd_rm),
19150 cCL("lgnez", e688160, 2, (RF, RF_IF), rd_rm),
19152 cCL("exps", e708100, 2, (RF, RF_IF), rd_rm),
19153 cCL("expsp", e708120, 2, (RF, RF_IF), rd_rm),
19154 cCL("expsm", e708140, 2, (RF, RF_IF), rd_rm),
19155 cCL("expsz", e708160, 2, (RF, RF_IF), rd_rm),
19156 cCL("expd", e708180, 2, (RF, RF_IF), rd_rm),
19157 cCL("expdp", e7081a0, 2, (RF, RF_IF), rd_rm),
19158 cCL("expdm", e7081c0, 2, (RF, RF_IF), rd_rm),
19159 cCL("expdz", e7081e0, 2, (RF, RF_IF), rd_rm),
19160 cCL("expe", e788100, 2, (RF, RF_IF), rd_rm),
19161 cCL("expep", e788120, 2, (RF, RF_IF), rd_rm),
19162 cCL("expem", e788140, 2, (RF, RF_IF), rd_rm),
19163 cCL("expdz", e788160, 2, (RF, RF_IF), rd_rm),
19165 cCL("sins", e808100, 2, (RF, RF_IF), rd_rm),
19166 cCL("sinsp", e808120, 2, (RF, RF_IF), rd_rm),
19167 cCL("sinsm", e808140, 2, (RF, RF_IF), rd_rm),
19168 cCL("sinsz", e808160, 2, (RF, RF_IF), rd_rm),
19169 cCL("sind", e808180, 2, (RF, RF_IF), rd_rm),
19170 cCL("sindp", e8081a0, 2, (RF, RF_IF), rd_rm),
19171 cCL("sindm", e8081c0, 2, (RF, RF_IF), rd_rm),
19172 cCL("sindz", e8081e0, 2, (RF, RF_IF), rd_rm),
19173 cCL("sine", e888100, 2, (RF, RF_IF), rd_rm),
19174 cCL("sinep", e888120, 2, (RF, RF_IF), rd_rm),
19175 cCL("sinem", e888140, 2, (RF, RF_IF), rd_rm),
19176 cCL("sinez", e888160, 2, (RF, RF_IF), rd_rm),
19178 cCL("coss", e908100, 2, (RF, RF_IF), rd_rm),
19179 cCL("cossp", e908120, 2, (RF, RF_IF), rd_rm),
19180 cCL("cossm", e908140, 2, (RF, RF_IF), rd_rm),
19181 cCL("cossz", e908160, 2, (RF, RF_IF), rd_rm),
19182 cCL("cosd", e908180, 2, (RF, RF_IF), rd_rm),
19183 cCL("cosdp", e9081a0, 2, (RF, RF_IF), rd_rm),
19184 cCL("cosdm", e9081c0, 2, (RF, RF_IF), rd_rm),
19185 cCL("cosdz", e9081e0, 2, (RF, RF_IF), rd_rm),
19186 cCL("cose", e988100, 2, (RF, RF_IF), rd_rm),
19187 cCL("cosep", e988120, 2, (RF, RF_IF), rd_rm),
19188 cCL("cosem", e988140, 2, (RF, RF_IF), rd_rm),
19189 cCL("cosez", e988160, 2, (RF, RF_IF), rd_rm),
19191 cCL("tans", ea08100, 2, (RF, RF_IF), rd_rm),
19192 cCL("tansp", ea08120, 2, (RF, RF_IF), rd_rm),
19193 cCL("tansm", ea08140, 2, (RF, RF_IF), rd_rm),
19194 cCL("tansz", ea08160, 2, (RF, RF_IF), rd_rm),
19195 cCL("tand", ea08180, 2, (RF, RF_IF), rd_rm),
19196 cCL("tandp", ea081a0, 2, (RF, RF_IF), rd_rm),
19197 cCL("tandm", ea081c0, 2, (RF, RF_IF), rd_rm),
19198 cCL("tandz", ea081e0, 2, (RF, RF_IF), rd_rm),
19199 cCL("tane", ea88100, 2, (RF, RF_IF), rd_rm),
19200 cCL("tanep", ea88120, 2, (RF, RF_IF), rd_rm),
19201 cCL("tanem", ea88140, 2, (RF, RF_IF), rd_rm),
19202 cCL("tanez", ea88160, 2, (RF, RF_IF), rd_rm),
19204 cCL("asns", eb08100, 2, (RF, RF_IF), rd_rm),
19205 cCL("asnsp", eb08120, 2, (RF, RF_IF), rd_rm),
19206 cCL("asnsm", eb08140, 2, (RF, RF_IF), rd_rm),
19207 cCL("asnsz", eb08160, 2, (RF, RF_IF), rd_rm),
19208 cCL("asnd", eb08180, 2, (RF, RF_IF), rd_rm),
19209 cCL("asndp", eb081a0, 2, (RF, RF_IF), rd_rm),
19210 cCL("asndm", eb081c0, 2, (RF, RF_IF), rd_rm),
19211 cCL("asndz", eb081e0, 2, (RF, RF_IF), rd_rm),
19212 cCL("asne", eb88100, 2, (RF, RF_IF), rd_rm),
19213 cCL("asnep", eb88120, 2, (RF, RF_IF), rd_rm),
19214 cCL("asnem", eb88140, 2, (RF, RF_IF), rd_rm),
19215 cCL("asnez", eb88160, 2, (RF, RF_IF), rd_rm),
19217 cCL("acss", ec08100, 2, (RF, RF_IF), rd_rm),
19218 cCL("acssp", ec08120, 2, (RF, RF_IF), rd_rm),
19219 cCL("acssm", ec08140, 2, (RF, RF_IF), rd_rm),
19220 cCL("acssz", ec08160, 2, (RF, RF_IF), rd_rm),
19221 cCL("acsd", ec08180, 2, (RF, RF_IF), rd_rm),
19222 cCL("acsdp", ec081a0, 2, (RF, RF_IF), rd_rm),
19223 cCL("acsdm", ec081c0, 2, (RF, RF_IF), rd_rm),
19224 cCL("acsdz", ec081e0, 2, (RF, RF_IF), rd_rm),
19225 cCL("acse", ec88100, 2, (RF, RF_IF), rd_rm),
19226 cCL("acsep", ec88120, 2, (RF, RF_IF), rd_rm),
19227 cCL("acsem", ec88140, 2, (RF, RF_IF), rd_rm),
19228 cCL("acsez", ec88160, 2, (RF, RF_IF), rd_rm),
19230 cCL("atns", ed08100, 2, (RF, RF_IF), rd_rm),
19231 cCL("atnsp", ed08120, 2, (RF, RF_IF), rd_rm),
19232 cCL("atnsm", ed08140, 2, (RF, RF_IF), rd_rm),
19233 cCL("atnsz", ed08160, 2, (RF, RF_IF), rd_rm),
19234 cCL("atnd", ed08180, 2, (RF, RF_IF), rd_rm),
19235 cCL("atndp", ed081a0, 2, (RF, RF_IF), rd_rm),
19236 cCL("atndm", ed081c0, 2, (RF, RF_IF), rd_rm),
19237 cCL("atndz", ed081e0, 2, (RF, RF_IF), rd_rm),
19238 cCL("atne", ed88100, 2, (RF, RF_IF), rd_rm),
19239 cCL("atnep", ed88120, 2, (RF, RF_IF), rd_rm),
19240 cCL("atnem", ed88140, 2, (RF, RF_IF), rd_rm),
19241 cCL("atnez", ed88160, 2, (RF, RF_IF), rd_rm),
19243 cCL("urds", ee08100, 2, (RF, RF_IF), rd_rm),
19244 cCL("urdsp", ee08120, 2, (RF, RF_IF), rd_rm),
19245 cCL("urdsm", ee08140, 2, (RF, RF_IF), rd_rm),
19246 cCL("urdsz", ee08160, 2, (RF, RF_IF), rd_rm),
19247 cCL("urdd", ee08180, 2, (RF, RF_IF), rd_rm),
19248 cCL("urddp", ee081a0, 2, (RF, RF_IF), rd_rm),
19249 cCL("urddm", ee081c0, 2, (RF, RF_IF), rd_rm),
19250 cCL("urddz", ee081e0, 2, (RF, RF_IF), rd_rm),
19251 cCL("urde", ee88100, 2, (RF, RF_IF), rd_rm),
19252 cCL("urdep", ee88120, 2, (RF, RF_IF), rd_rm),
19253 cCL("urdem", ee88140, 2, (RF, RF_IF), rd_rm),
19254 cCL("urdez", ee88160, 2, (RF, RF_IF), rd_rm),
19256 cCL("nrms", ef08100, 2, (RF, RF_IF), rd_rm),
19257 cCL("nrmsp", ef08120, 2, (RF, RF_IF), rd_rm),
19258 cCL("nrmsm", ef08140, 2, (RF, RF_IF), rd_rm),
19259 cCL("nrmsz", ef08160, 2, (RF, RF_IF), rd_rm),
19260 cCL("nrmd", ef08180, 2, (RF, RF_IF), rd_rm),
19261 cCL("nrmdp", ef081a0, 2, (RF, RF_IF), rd_rm),
19262 cCL("nrmdm", ef081c0, 2, (RF, RF_IF), rd_rm),
19263 cCL("nrmdz", ef081e0, 2, (RF, RF_IF), rd_rm),
19264 cCL("nrme", ef88100, 2, (RF, RF_IF), rd_rm),
19265 cCL("nrmep", ef88120, 2, (RF, RF_IF), rd_rm),
19266 cCL("nrmem", ef88140, 2, (RF, RF_IF), rd_rm),
19267 cCL("nrmez", ef88160, 2, (RF, RF_IF), rd_rm),
19269 cCL("adfs", e000100, 3, (RF, RF, RF_IF), rd_rn_rm),
19270 cCL("adfsp", e000120, 3, (RF, RF, RF_IF), rd_rn_rm),
19271 cCL("adfsm", e000140, 3, (RF, RF, RF_IF), rd_rn_rm),
19272 cCL("adfsz", e000160, 3, (RF, RF, RF_IF), rd_rn_rm),
19273 cCL("adfd", e000180, 3, (RF, RF, RF_IF), rd_rn_rm),
19274 cCL("adfdp", e0001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19275 cCL("adfdm", e0001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19276 cCL("adfdz", e0001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19277 cCL("adfe", e080100, 3, (RF, RF, RF_IF), rd_rn_rm),
19278 cCL("adfep", e080120, 3, (RF, RF, RF_IF), rd_rn_rm),
19279 cCL("adfem", e080140, 3, (RF, RF, RF_IF), rd_rn_rm),
19280 cCL("adfez", e080160, 3, (RF, RF, RF_IF), rd_rn_rm),
19282 cCL("sufs", e200100, 3, (RF, RF, RF_IF), rd_rn_rm),
19283 cCL("sufsp", e200120, 3, (RF, RF, RF_IF), rd_rn_rm),
19284 cCL("sufsm", e200140, 3, (RF, RF, RF_IF), rd_rn_rm),
19285 cCL("sufsz", e200160, 3, (RF, RF, RF_IF), rd_rn_rm),
19286 cCL("sufd", e200180, 3, (RF, RF, RF_IF), rd_rn_rm),
19287 cCL("sufdp", e2001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19288 cCL("sufdm", e2001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19289 cCL("sufdz", e2001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19290 cCL("sufe", e280100, 3, (RF, RF, RF_IF), rd_rn_rm),
19291 cCL("sufep", e280120, 3, (RF, RF, RF_IF), rd_rn_rm),
19292 cCL("sufem", e280140, 3, (RF, RF, RF_IF), rd_rn_rm),
19293 cCL("sufez", e280160, 3, (RF, RF, RF_IF), rd_rn_rm),
19295 cCL("rsfs", e300100, 3, (RF, RF, RF_IF), rd_rn_rm),
19296 cCL("rsfsp", e300120, 3, (RF, RF, RF_IF), rd_rn_rm),
19297 cCL("rsfsm", e300140, 3, (RF, RF, RF_IF), rd_rn_rm),
19298 cCL("rsfsz", e300160, 3, (RF, RF, RF_IF), rd_rn_rm),
19299 cCL("rsfd", e300180, 3, (RF, RF, RF_IF), rd_rn_rm),
19300 cCL("rsfdp", e3001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19301 cCL("rsfdm", e3001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19302 cCL("rsfdz", e3001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19303 cCL("rsfe", e380100, 3, (RF, RF, RF_IF), rd_rn_rm),
19304 cCL("rsfep", e380120, 3, (RF, RF, RF_IF), rd_rn_rm),
19305 cCL("rsfem", e380140, 3, (RF, RF, RF_IF), rd_rn_rm),
19306 cCL("rsfez", e380160, 3, (RF, RF, RF_IF), rd_rn_rm),
19308 cCL("mufs", e100100, 3, (RF, RF, RF_IF), rd_rn_rm),
19309 cCL("mufsp", e100120, 3, (RF, RF, RF_IF), rd_rn_rm),
19310 cCL("mufsm", e100140, 3, (RF, RF, RF_IF), rd_rn_rm),
19311 cCL("mufsz", e100160, 3, (RF, RF, RF_IF), rd_rn_rm),
19312 cCL("mufd", e100180, 3, (RF, RF, RF_IF), rd_rn_rm),
19313 cCL("mufdp", e1001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19314 cCL("mufdm", e1001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19315 cCL("mufdz", e1001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19316 cCL("mufe", e180100, 3, (RF, RF, RF_IF), rd_rn_rm),
19317 cCL("mufep", e180120, 3, (RF, RF, RF_IF), rd_rn_rm),
19318 cCL("mufem", e180140, 3, (RF, RF, RF_IF), rd_rn_rm),
19319 cCL("mufez", e180160, 3, (RF, RF, RF_IF), rd_rn_rm),
19321 cCL("dvfs", e400100, 3, (RF, RF, RF_IF), rd_rn_rm),
19322 cCL("dvfsp", e400120, 3, (RF, RF, RF_IF), rd_rn_rm),
19323 cCL("dvfsm", e400140, 3, (RF, RF, RF_IF), rd_rn_rm),
19324 cCL("dvfsz", e400160, 3, (RF, RF, RF_IF), rd_rn_rm),
19325 cCL("dvfd", e400180, 3, (RF, RF, RF_IF), rd_rn_rm),
19326 cCL("dvfdp", e4001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19327 cCL("dvfdm", e4001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19328 cCL("dvfdz", e4001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19329 cCL("dvfe", e480100, 3, (RF, RF, RF_IF), rd_rn_rm),
19330 cCL("dvfep", e480120, 3, (RF, RF, RF_IF), rd_rn_rm),
19331 cCL("dvfem", e480140, 3, (RF, RF, RF_IF), rd_rn_rm),
19332 cCL("dvfez", e480160, 3, (RF, RF, RF_IF), rd_rn_rm),
19334 cCL("rdfs", e500100, 3, (RF, RF, RF_IF), rd_rn_rm),
19335 cCL("rdfsp", e500120, 3, (RF, RF, RF_IF), rd_rn_rm),
19336 cCL("rdfsm", e500140, 3, (RF, RF, RF_IF), rd_rn_rm),
19337 cCL("rdfsz", e500160, 3, (RF, RF, RF_IF), rd_rn_rm),
19338 cCL("rdfd", e500180, 3, (RF, RF, RF_IF), rd_rn_rm),
19339 cCL("rdfdp", e5001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19340 cCL("rdfdm", e5001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19341 cCL("rdfdz", e5001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19342 cCL("rdfe", e580100, 3, (RF, RF, RF_IF), rd_rn_rm),
19343 cCL("rdfep", e580120, 3, (RF, RF, RF_IF), rd_rn_rm),
19344 cCL("rdfem", e580140, 3, (RF, RF, RF_IF), rd_rn_rm),
19345 cCL("rdfez", e580160, 3, (RF, RF, RF_IF), rd_rn_rm),
19347 cCL("pows", e600100, 3, (RF, RF, RF_IF), rd_rn_rm),
19348 cCL("powsp", e600120, 3, (RF, RF, RF_IF), rd_rn_rm),
19349 cCL("powsm", e600140, 3, (RF, RF, RF_IF), rd_rn_rm),
19350 cCL("powsz", e600160, 3, (RF, RF, RF_IF), rd_rn_rm),
19351 cCL("powd", e600180, 3, (RF, RF, RF_IF), rd_rn_rm),
19352 cCL("powdp", e6001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19353 cCL("powdm", e6001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19354 cCL("powdz", e6001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19355 cCL("powe", e680100, 3, (RF, RF, RF_IF), rd_rn_rm),
19356 cCL("powep", e680120, 3, (RF, RF, RF_IF), rd_rn_rm),
19357 cCL("powem", e680140, 3, (RF, RF, RF_IF), rd_rn_rm),
19358 cCL("powez", e680160, 3, (RF, RF, RF_IF), rd_rn_rm),
19360 cCL("rpws", e700100, 3, (RF, RF, RF_IF), rd_rn_rm),
19361 cCL("rpwsp", e700120, 3, (RF, RF, RF_IF), rd_rn_rm),
19362 cCL("rpwsm", e700140, 3, (RF, RF, RF_IF), rd_rn_rm),
19363 cCL("rpwsz", e700160, 3, (RF, RF, RF_IF), rd_rn_rm),
19364 cCL("rpwd", e700180, 3, (RF, RF, RF_IF), rd_rn_rm),
19365 cCL("rpwdp", e7001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19366 cCL("rpwdm", e7001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19367 cCL("rpwdz", e7001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19368 cCL("rpwe", e780100, 3, (RF, RF, RF_IF), rd_rn_rm),
19369 cCL("rpwep", e780120, 3, (RF, RF, RF_IF), rd_rn_rm),
19370 cCL("rpwem", e780140, 3, (RF, RF, RF_IF), rd_rn_rm),
19371 cCL("rpwez", e780160, 3, (RF, RF, RF_IF), rd_rn_rm),
19373 cCL("rmfs", e800100, 3, (RF, RF, RF_IF), rd_rn_rm),
19374 cCL("rmfsp", e800120, 3, (RF, RF, RF_IF), rd_rn_rm),
19375 cCL("rmfsm", e800140, 3, (RF, RF, RF_IF), rd_rn_rm),
19376 cCL("rmfsz", e800160, 3, (RF, RF, RF_IF), rd_rn_rm),
19377 cCL("rmfd", e800180, 3, (RF, RF, RF_IF), rd_rn_rm),
19378 cCL("rmfdp", e8001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19379 cCL("rmfdm", e8001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19380 cCL("rmfdz", e8001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19381 cCL("rmfe", e880100, 3, (RF, RF, RF_IF), rd_rn_rm),
19382 cCL("rmfep", e880120, 3, (RF, RF, RF_IF), rd_rn_rm),
19383 cCL("rmfem", e880140, 3, (RF, RF, RF_IF), rd_rn_rm),
19384 cCL("rmfez", e880160, 3, (RF, RF, RF_IF), rd_rn_rm),
19386 cCL("fmls", e900100, 3, (RF, RF, RF_IF), rd_rn_rm),
19387 cCL("fmlsp", e900120, 3, (RF, RF, RF_IF), rd_rn_rm),
19388 cCL("fmlsm", e900140, 3, (RF, RF, RF_IF), rd_rn_rm),
19389 cCL("fmlsz", e900160, 3, (RF, RF, RF_IF), rd_rn_rm),
19390 cCL("fmld", e900180, 3, (RF, RF, RF_IF), rd_rn_rm),
19391 cCL("fmldp", e9001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19392 cCL("fmldm", e9001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19393 cCL("fmldz", e9001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19394 cCL("fmle", e980100, 3, (RF, RF, RF_IF), rd_rn_rm),
19395 cCL("fmlep", e980120, 3, (RF, RF, RF_IF), rd_rn_rm),
19396 cCL("fmlem", e980140, 3, (RF, RF, RF_IF), rd_rn_rm),
19397 cCL("fmlez", e980160, 3, (RF, RF, RF_IF), rd_rn_rm),
19399 cCL("fdvs", ea00100, 3, (RF, RF, RF_IF), rd_rn_rm),
19400 cCL("fdvsp", ea00120, 3, (RF, RF, RF_IF), rd_rn_rm),
19401 cCL("fdvsm", ea00140, 3, (RF, RF, RF_IF), rd_rn_rm),
19402 cCL("fdvsz", ea00160, 3, (RF, RF, RF_IF), rd_rn_rm),
19403 cCL("fdvd", ea00180, 3, (RF, RF, RF_IF), rd_rn_rm),
19404 cCL("fdvdp", ea001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19405 cCL("fdvdm", ea001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19406 cCL("fdvdz", ea001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19407 cCL("fdve", ea80100, 3, (RF, RF, RF_IF), rd_rn_rm),
19408 cCL("fdvep", ea80120, 3, (RF, RF, RF_IF), rd_rn_rm),
19409 cCL("fdvem", ea80140, 3, (RF, RF, RF_IF), rd_rn_rm),
19410 cCL("fdvez", ea80160, 3, (RF, RF, RF_IF), rd_rn_rm),
19412 cCL("frds", eb00100, 3, (RF, RF, RF_IF), rd_rn_rm),
19413 cCL("frdsp", eb00120, 3, (RF, RF, RF_IF), rd_rn_rm),
19414 cCL("frdsm", eb00140, 3, (RF, RF, RF_IF), rd_rn_rm),
19415 cCL("frdsz", eb00160, 3, (RF, RF, RF_IF), rd_rn_rm),
19416 cCL("frdd", eb00180, 3, (RF, RF, RF_IF), rd_rn_rm),
19417 cCL("frddp", eb001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19418 cCL("frddm", eb001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19419 cCL("frddz", eb001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19420 cCL("frde", eb80100, 3, (RF, RF, RF_IF), rd_rn_rm),
19421 cCL("frdep", eb80120, 3, (RF, RF, RF_IF), rd_rn_rm),
19422 cCL("frdem", eb80140, 3, (RF, RF, RF_IF), rd_rn_rm),
19423 cCL("frdez", eb80160, 3, (RF, RF, RF_IF), rd_rn_rm),
19425 cCL("pols", ec00100, 3, (RF, RF, RF_IF), rd_rn_rm),
19426 cCL("polsp", ec00120, 3, (RF, RF, RF_IF), rd_rn_rm),
19427 cCL("polsm", ec00140, 3, (RF, RF, RF_IF), rd_rn_rm),
19428 cCL("polsz", ec00160, 3, (RF, RF, RF_IF), rd_rn_rm),
19429 cCL("pold", ec00180, 3, (RF, RF, RF_IF), rd_rn_rm),
19430 cCL("poldp", ec001a0, 3, (RF, RF, RF_IF), rd_rn_rm),
19431 cCL("poldm", ec001c0, 3, (RF, RF, RF_IF), rd_rn_rm),
19432 cCL("poldz", ec001e0, 3, (RF, RF, RF_IF), rd_rn_rm),
19433 cCL("pole", ec80100, 3, (RF, RF, RF_IF), rd_rn_rm),
19434 cCL("polep", ec80120, 3, (RF, RF, RF_IF), rd_rn_rm),
19435 cCL("polem", ec80140, 3, (RF, RF, RF_IF), rd_rn_rm),
19436 cCL("polez", ec80160, 3, (RF, RF, RF_IF), rd_rn_rm),
19438 cCE("cmf", e90f110, 2, (RF, RF_IF), fpa_cmp),
19439 C3E("cmfe", ed0f110, 2, (RF, RF_IF), fpa_cmp),
19440 cCE("cnf", eb0f110, 2, (RF, RF_IF), fpa_cmp),
19441 C3E("cnfe", ef0f110, 2, (RF, RF_IF), fpa_cmp),
19443 cCL("flts", e000110, 2, (RF, RR), rn_rd),
19444 cCL("fltsp", e000130, 2, (RF, RR), rn_rd),
19445 cCL("fltsm", e000150, 2, (RF, RR), rn_rd),
19446 cCL("fltsz", e000170, 2, (RF, RR), rn_rd),
19447 cCL("fltd", e000190, 2, (RF, RR), rn_rd),
19448 cCL("fltdp", e0001b0, 2, (RF, RR), rn_rd),
19449 cCL("fltdm", e0001d0, 2, (RF, RR), rn_rd),
19450 cCL("fltdz", e0001f0, 2, (RF, RR), rn_rd),
19451 cCL("flte", e080110, 2, (RF, RR), rn_rd),
19452 cCL("fltep", e080130, 2, (RF, RR), rn_rd),
19453 cCL("fltem", e080150, 2, (RF, RR), rn_rd),
19454 cCL("fltez", e080170, 2, (RF, RR), rn_rd),
19456 /* The implementation of the FIX instruction is broken on some
19457 assemblers, in that it accepts a precision specifier as well as a
19458 rounding specifier, despite the fact that this is meaningless.
19459 To be more compatible, we accept it as well, though of course it
19460 does not set any bits. */
19461 cCE("fix", e100110, 2, (RR, RF), rd_rm),
19462 cCL("fixp", e100130, 2, (RR, RF), rd_rm),
19463 cCL("fixm", e100150, 2, (RR, RF), rd_rm),
19464 cCL("fixz", e100170, 2, (RR, RF), rd_rm),
19465 cCL("fixsp", e100130, 2, (RR, RF), rd_rm),
19466 cCL("fixsm", e100150, 2, (RR, RF), rd_rm),
19467 cCL("fixsz", e100170, 2, (RR, RF), rd_rm),
19468 cCL("fixdp", e100130, 2, (RR, RF), rd_rm),
19469 cCL("fixdm", e100150, 2, (RR, RF), rd_rm),
19470 cCL("fixdz", e100170, 2, (RR, RF), rd_rm),
19471 cCL("fixep", e100130, 2, (RR, RF), rd_rm),
19472 cCL("fixem", e100150, 2, (RR, RF), rd_rm),
19473 cCL("fixez", e100170, 2, (RR, RF), rd_rm),
19475 /* Instructions that were new with the real FPA, call them V2. */
19477 #define ARM_VARIANT & fpu_fpa_ext_v2
19479 cCE("lfm", c100200, 3, (RF, I4b, ADDR), fpa_ldmstm),
19480 cCL("lfmfd", c900200, 3, (RF, I4b, ADDR), fpa_ldmstm),
19481 cCL("lfmea", d100200, 3, (RF, I4b, ADDR), fpa_ldmstm),
19482 cCE("sfm", c000200, 3, (RF, I4b, ADDR), fpa_ldmstm),
19483 cCL("sfmfd", d000200, 3, (RF, I4b, ADDR), fpa_ldmstm),
19484 cCL("sfmea", c800200, 3, (RF, I4b, ADDR), fpa_ldmstm),
19487 #define ARM_VARIANT & fpu_vfp_ext_v1xd /* VFP V1xD (single precision). */
19489 /* Moves and type conversions. */
19490 cCE("fcpys", eb00a40, 2, (RVS, RVS), vfp_sp_monadic),
19491 cCE("fmrs", e100a10, 2, (RR, RVS), vfp_reg_from_sp),
19492 cCE("fmsr", e000a10, 2, (RVS, RR), vfp_sp_from_reg),
19493 cCE("fmstat", ef1fa10, 0, (), noargs),
19494 cCE("vmrs", ef00a10, 2, (APSR_RR, RVC), vmrs),
19495 cCE("vmsr", ee00a10, 2, (RVC, RR), vmsr),
19496 cCE("fsitos", eb80ac0, 2, (RVS, RVS), vfp_sp_monadic),
19497 cCE("fuitos", eb80a40, 2, (RVS, RVS), vfp_sp_monadic),
19498 cCE("ftosis", ebd0a40, 2, (RVS, RVS), vfp_sp_monadic),
19499 cCE("ftosizs", ebd0ac0, 2, (RVS, RVS), vfp_sp_monadic),
19500 cCE("ftouis", ebc0a40, 2, (RVS, RVS), vfp_sp_monadic),
19501 cCE("ftouizs", ebc0ac0, 2, (RVS, RVS), vfp_sp_monadic),
19502 cCE("fmrx", ef00a10, 2, (RR, RVC), rd_rn),
19503 cCE("fmxr", ee00a10, 2, (RVC, RR), rn_rd),
19505 /* Memory operations. */
19506 cCE("flds", d100a00, 2, (RVS, ADDRGLDC), vfp_sp_ldst),
19507 cCE("fsts", d000a00, 2, (RVS, ADDRGLDC), vfp_sp_ldst),
19508 cCE("fldmias", c900a00, 2, (RRnpctw, VRSLST), vfp_sp_ldstmia),
19509 cCE("fldmfds", c900a00, 2, (RRnpctw, VRSLST), vfp_sp_ldstmia),
19510 cCE("fldmdbs", d300a00, 2, (RRnpctw, VRSLST), vfp_sp_ldstmdb),
19511 cCE("fldmeas", d300a00, 2, (RRnpctw, VRSLST), vfp_sp_ldstmdb),
19512 cCE("fldmiax", c900b00, 2, (RRnpctw, VRDLST), vfp_xp_ldstmia),
19513 cCE("fldmfdx", c900b00, 2, (RRnpctw, VRDLST), vfp_xp_ldstmia),
19514 cCE("fldmdbx", d300b00, 2, (RRnpctw, VRDLST), vfp_xp_ldstmdb),
19515 cCE("fldmeax", d300b00, 2, (RRnpctw, VRDLST), vfp_xp_ldstmdb),
19516 cCE("fstmias", c800a00, 2, (RRnpctw, VRSLST), vfp_sp_ldstmia),
19517 cCE("fstmeas", c800a00, 2, (RRnpctw, VRSLST), vfp_sp_ldstmia),
19518 cCE("fstmdbs", d200a00, 2, (RRnpctw, VRSLST), vfp_sp_ldstmdb),
19519 cCE("fstmfds", d200a00, 2, (RRnpctw, VRSLST), vfp_sp_ldstmdb),
19520 cCE("fstmiax", c800b00, 2, (RRnpctw, VRDLST), vfp_xp_ldstmia),
19521 cCE("fstmeax", c800b00, 2, (RRnpctw, VRDLST), vfp_xp_ldstmia),
19522 cCE("fstmdbx", d200b00, 2, (RRnpctw, VRDLST), vfp_xp_ldstmdb),
19523 cCE("fstmfdx", d200b00, 2, (RRnpctw, VRDLST), vfp_xp_ldstmdb),
19525 /* Monadic operations. */
19526 cCE("fabss", eb00ac0, 2, (RVS, RVS), vfp_sp_monadic),
19527 cCE("fnegs", eb10a40, 2, (RVS, RVS), vfp_sp_monadic),
19528 cCE("fsqrts", eb10ac0, 2, (RVS, RVS), vfp_sp_monadic),
19530 /* Dyadic operations. */
19531 cCE("fadds", e300a00, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19532 cCE("fsubs", e300a40, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19533 cCE("fmuls", e200a00, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19534 cCE("fdivs", e800a00, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19535 cCE("fmacs", e000a00, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19536 cCE("fmscs", e100a00, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19537 cCE("fnmuls", e200a40, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19538 cCE("fnmacs", e000a40, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19539 cCE("fnmscs", e100a40, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19542 cCE("fcmps", eb40a40, 2, (RVS, RVS), vfp_sp_monadic),
19543 cCE("fcmpzs", eb50a40, 1, (RVS), vfp_sp_compare_z),
19544 cCE("fcmpes", eb40ac0, 2, (RVS, RVS), vfp_sp_monadic),
19545 cCE("fcmpezs", eb50ac0, 1, (RVS), vfp_sp_compare_z),
19547 /* Double precision load/store are still present on single precision
19548 implementations. */
19549 cCE("fldd", d100b00, 2, (RVD, ADDRGLDC), vfp_dp_ldst),
19550 cCE("fstd", d000b00, 2, (RVD, ADDRGLDC), vfp_dp_ldst),
19551 cCE("fldmiad", c900b00, 2, (RRnpctw, VRDLST), vfp_dp_ldstmia),
19552 cCE("fldmfdd", c900b00, 2, (RRnpctw, VRDLST), vfp_dp_ldstmia),
19553 cCE("fldmdbd", d300b00, 2, (RRnpctw, VRDLST), vfp_dp_ldstmdb),
19554 cCE("fldmead", d300b00, 2, (RRnpctw, VRDLST), vfp_dp_ldstmdb),
19555 cCE("fstmiad", c800b00, 2, (RRnpctw, VRDLST), vfp_dp_ldstmia),
19556 cCE("fstmead", c800b00, 2, (RRnpctw, VRDLST), vfp_dp_ldstmia),
19557 cCE("fstmdbd", d200b00, 2, (RRnpctw, VRDLST), vfp_dp_ldstmdb),
19558 cCE("fstmfdd", d200b00, 2, (RRnpctw, VRDLST), vfp_dp_ldstmdb),
19561 #define ARM_VARIANT & fpu_vfp_ext_v1 /* VFP V1 (Double precision). */
19563 /* Moves and type conversions. */
19564 cCE("fcpyd", eb00b40, 2, (RVD, RVD), vfp_dp_rd_rm),
19565 cCE("fcvtds", eb70ac0, 2, (RVD, RVS), vfp_dp_sp_cvt),
19566 cCE("fcvtsd", eb70bc0, 2, (RVS, RVD), vfp_sp_dp_cvt),
19567 cCE("fmdhr", e200b10, 2, (RVD, RR), vfp_dp_rn_rd),
19568 cCE("fmdlr", e000b10, 2, (RVD, RR), vfp_dp_rn_rd),
19569 cCE("fmrdh", e300b10, 2, (RR, RVD), vfp_dp_rd_rn),
19570 cCE("fmrdl", e100b10, 2, (RR, RVD), vfp_dp_rd_rn),
19571 cCE("fsitod", eb80bc0, 2, (RVD, RVS), vfp_dp_sp_cvt),
19572 cCE("fuitod", eb80b40, 2, (RVD, RVS), vfp_dp_sp_cvt),
19573 cCE("ftosid", ebd0b40, 2, (RVS, RVD), vfp_sp_dp_cvt),
19574 cCE("ftosizd", ebd0bc0, 2, (RVS, RVD), vfp_sp_dp_cvt),
19575 cCE("ftouid", ebc0b40, 2, (RVS, RVD), vfp_sp_dp_cvt),
19576 cCE("ftouizd", ebc0bc0, 2, (RVS, RVD), vfp_sp_dp_cvt),
19578 /* Monadic operations. */
19579 cCE("fabsd", eb00bc0, 2, (RVD, RVD), vfp_dp_rd_rm),
19580 cCE("fnegd", eb10b40, 2, (RVD, RVD), vfp_dp_rd_rm),
19581 cCE("fsqrtd", eb10bc0, 2, (RVD, RVD), vfp_dp_rd_rm),
19583 /* Dyadic operations. */
19584 cCE("faddd", e300b00, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19585 cCE("fsubd", e300b40, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19586 cCE("fmuld", e200b00, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19587 cCE("fdivd", e800b00, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19588 cCE("fmacd", e000b00, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19589 cCE("fmscd", e100b00, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19590 cCE("fnmuld", e200b40, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19591 cCE("fnmacd", e000b40, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19592 cCE("fnmscd", e100b40, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19595 cCE("fcmpd", eb40b40, 2, (RVD, RVD), vfp_dp_rd_rm),
19596 cCE("fcmpzd", eb50b40, 1, (RVD), vfp_dp_rd),
19597 cCE("fcmped", eb40bc0, 2, (RVD, RVD), vfp_dp_rd_rm),
19598 cCE("fcmpezd", eb50bc0, 1, (RVD), vfp_dp_rd),
19601 #define ARM_VARIANT & fpu_vfp_ext_v2
19603 cCE("fmsrr", c400a10, 3, (VRSLST, RR, RR), vfp_sp2_from_reg2),
19604 cCE("fmrrs", c500a10, 3, (RR, RR, VRSLST), vfp_reg2_from_sp2),
19605 cCE("fmdrr", c400b10, 3, (RVD, RR, RR), vfp_dp_rm_rd_rn),
19606 cCE("fmrrd", c500b10, 3, (RR, RR, RVD), vfp_dp_rd_rn_rm),
19608 /* Instructions which may belong to either the Neon or VFP instruction sets.
19609 Individual encoder functions perform additional architecture checks. */
19611 #define ARM_VARIANT & fpu_vfp_ext_v1xd
19612 #undef THUMB_VARIANT
19613 #define THUMB_VARIANT & fpu_vfp_ext_v1xd
19615 /* These mnemonics are unique to VFP. */
19616 NCE(vsqrt, 0, 2, (RVSD, RVSD), vfp_nsyn_sqrt),
19617 NCE(vdiv, 0, 3, (RVSD, RVSD, RVSD), vfp_nsyn_div),
19618 nCE(vnmul, _vnmul, 3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
19619 nCE(vnmla, _vnmla, 3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
19620 nCE(vnmls, _vnmls, 3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
19621 nCE(vcmp, _vcmp, 2, (RVSD, RSVD_FI0), vfp_nsyn_cmp),
19622 nCE(vcmpe, _vcmpe, 2, (RVSD, RSVD_FI0), vfp_nsyn_cmp),
19623 NCE(vpush, 0, 1, (VRSDLST), vfp_nsyn_push),
19624 NCE(vpop, 0, 1, (VRSDLST), vfp_nsyn_pop),
19625 NCE(vcvtz, 0, 2, (RVSD, RVSD), vfp_nsyn_cvtz),
19627 /* Mnemonics shared by Neon and VFP. */
19628 nCEF(vmul, _vmul, 3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mul),
19629 nCEF(vmla, _vmla, 3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mac_maybe_scalar),
19630 nCEF(vmls, _vmls, 3, (RNSDQ, oRNSDQ, RNSDQ_RNSC), neon_mac_maybe_scalar),
19632 nCEF(vadd, _vadd, 3, (RNSDQ, oRNSDQ, RNSDQ), neon_addsub_if_i),
19633 nCEF(vsub, _vsub, 3, (RNSDQ, oRNSDQ, RNSDQ), neon_addsub_if_i),
19635 NCEF(vabs, 1b10300, 2, (RNSDQ, RNSDQ), neon_abs_neg),
19636 NCEF(vneg, 1b10380, 2, (RNSDQ, RNSDQ), neon_abs_neg),
19638 NCE(vldm, c900b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
19639 NCE(vldmia, c900b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
19640 NCE(vldmdb, d100b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
19641 NCE(vstm, c800b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
19642 NCE(vstmia, c800b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
19643 NCE(vstmdb, d000b00, 2, (RRnpctw, VRSDLST), neon_ldm_stm),
19644 NCE(vldr, d100b00, 2, (RVSD, ADDRGLDC), neon_ldr_str),
19645 NCE(vstr, d000b00, 2, (RVSD, ADDRGLDC), neon_ldr_str),
19647 nCEF(vcvt, _vcvt, 3, (RNSDQ, RNSDQ, oI32z), neon_cvt),
19648 nCEF(vcvtr, _vcvt, 2, (RNSDQ, RNSDQ), neon_cvtr),
19649 NCEF(vcvtb, eb20a40, 2, (RVSD, RVSD), neon_cvtb),
19650 NCEF(vcvtt, eb20a40, 2, (RVSD, RVSD), neon_cvtt),
19653 /* NOTE: All VMOV encoding is special-cased! */
19654 NCE(vmov, 0, 1, (VMOV), neon_mov),
19655 NCE(vmovq, 0, 1, (VMOV), neon_mov),
19657 #undef THUMB_VARIANT
19658 #define THUMB_VARIANT & fpu_neon_ext_v1
19660 #define ARM_VARIANT & fpu_neon_ext_v1
19662 /* Data processing with three registers of the same length. */
19663 /* integer ops, valid types S8 S16 S32 U8 U16 U32. */
19664 NUF(vaba, 0000710, 3, (RNDQ, RNDQ, RNDQ), neon_dyadic_i_su),
19665 NUF(vabaq, 0000710, 3, (RNQ, RNQ, RNQ), neon_dyadic_i_su),
19666 NUF(vhadd, 0000000, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
19667 NUF(vhaddq, 0000000, 3, (RNQ, oRNQ, RNQ), neon_dyadic_i_su),
19668 NUF(vrhadd, 0000100, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
19669 NUF(vrhaddq, 0000100, 3, (RNQ, oRNQ, RNQ), neon_dyadic_i_su),
19670 NUF(vhsub, 0000200, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i_su),
19671 NUF(vhsubq, 0000200, 3, (RNQ, oRNQ, RNQ), neon_dyadic_i_su),
19672 /* integer ops, valid types S8 S16 S32 S64 U8 U16 U32 U64. */
19673 NUF(vqadd, 0000010, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i64_su),
19674 NUF(vqaddq, 0000010, 3, (RNQ, oRNQ, RNQ), neon_dyadic_i64_su),
19675 NUF(vqsub, 0000210, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_i64_su),
19676 NUF(vqsubq, 0000210, 3, (RNQ, oRNQ, RNQ), neon_dyadic_i64_su),
19677 NUF(vrshl, 0000500, 3, (RNDQ, oRNDQ, RNDQ), neon_rshl),
19678 NUF(vrshlq, 0000500, 3, (RNQ, oRNQ, RNQ), neon_rshl),
19679 NUF(vqrshl, 0000510, 3, (RNDQ, oRNDQ, RNDQ), neon_rshl),
19680 NUF(vqrshlq, 0000510, 3, (RNQ, oRNQ, RNQ), neon_rshl),
19681 /* If not immediate, fall back to neon_dyadic_i64_su.
19682 shl_imm should accept I8 I16 I32 I64,
19683 qshl_imm should accept S8 S16 S32 S64 U8 U16 U32 U64. */
19684 nUF(vshl, _vshl, 3, (RNDQ, oRNDQ, RNDQ_I63b), neon_shl_imm),
19685 nUF(vshlq, _vshl, 3, (RNQ, oRNQ, RNDQ_I63b), neon_shl_imm),
19686 nUF(vqshl, _vqshl, 3, (RNDQ, oRNDQ, RNDQ_I63b), neon_qshl_imm),
19687 nUF(vqshlq, _vqshl, 3, (RNQ, oRNQ, RNDQ_I63b), neon_qshl_imm),
19688 /* Logic ops, types optional & ignored. */
19689 nUF(vand, _vand, 3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
19690 nUF(vandq, _vand, 3, (RNQ, oRNQ, RNDQ_Ibig), neon_logic),
19691 nUF(vbic, _vbic, 3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
19692 nUF(vbicq, _vbic, 3, (RNQ, oRNQ, RNDQ_Ibig), neon_logic),
19693 nUF(vorr, _vorr, 3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
19694 nUF(vorrq, _vorr, 3, (RNQ, oRNQ, RNDQ_Ibig), neon_logic),
19695 nUF(vorn, _vorn, 3, (RNDQ, oRNDQ, RNDQ_Ibig), neon_logic),
19696 nUF(vornq, _vorn, 3, (RNQ, oRNQ, RNDQ_Ibig), neon_logic),
19697 nUF(veor, _veor, 3, (RNDQ, oRNDQ, RNDQ), neon_logic),
19698 nUF(veorq, _veor, 3, (RNQ, oRNQ, RNQ), neon_logic),
19699 /* Bitfield ops, untyped. */
19700 NUF(vbsl, 1100110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
19701 NUF(vbslq, 1100110, 3, (RNQ, RNQ, RNQ), neon_bitfield),
19702 NUF(vbit, 1200110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
19703 NUF(vbitq, 1200110, 3, (RNQ, RNQ, RNQ), neon_bitfield),
19704 NUF(vbif, 1300110, 3, (RNDQ, RNDQ, RNDQ), neon_bitfield),
19705 NUF(vbifq, 1300110, 3, (RNQ, RNQ, RNQ), neon_bitfield),
19706 /* Int and float variants, types S8 S16 S32 U8 U16 U32 F32. */
19707 nUF(vabd, _vabd, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
19708 nUF(vabdq, _vabd, 3, (RNQ, oRNQ, RNQ), neon_dyadic_if_su),
19709 nUF(vmax, _vmax, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
19710 nUF(vmaxq, _vmax, 3, (RNQ, oRNQ, RNQ), neon_dyadic_if_su),
19711 nUF(vmin, _vmin, 3, (RNDQ, oRNDQ, RNDQ), neon_dyadic_if_su),
19712 nUF(vminq, _vmin, 3, (RNQ, oRNQ, RNQ), neon_dyadic_if_su),
19713 /* Comparisons. Types S8 S16 S32 U8 U16 U32 F32. Non-immediate versions fall
19714 back to neon_dyadic_if_su. */
19715 nUF(vcge, _vcge, 3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp),
19716 nUF(vcgeq, _vcge, 3, (RNQ, oRNQ, RNDQ_I0), neon_cmp),
19717 nUF(vcgt, _vcgt, 3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp),
19718 nUF(vcgtq, _vcgt, 3, (RNQ, oRNQ, RNDQ_I0), neon_cmp),
19719 nUF(vclt, _vclt, 3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp_inv),
19720 nUF(vcltq, _vclt, 3, (RNQ, oRNQ, RNDQ_I0), neon_cmp_inv),
19721 nUF(vcle, _vcle, 3, (RNDQ, oRNDQ, RNDQ_I0), neon_cmp_inv),
19722 nUF(vcleq, _vcle, 3, (RNQ, oRNQ, RNDQ_I0), neon_cmp_inv),
19723 /* Comparison. Type I8 I16 I32 F32. */
19724 nUF(vceq, _vceq, 3, (RNDQ, oRNDQ, RNDQ_I0), neon_ceq),
19725 nUF(vceqq, _vceq, 3, (RNQ, oRNQ, RNDQ_I0), neon_ceq),
19726 /* As above, D registers only. */
19727 nUF(vpmax, _vpmax, 3, (RND, oRND, RND), neon_dyadic_if_su_d),
19728 nUF(vpmin, _vpmin, 3, (RND, oRND, RND), neon_dyadic_if_su_d),
19729 /* Int and float variants, signedness unimportant. */
19730 nUF(vmlaq, _vmla, 3, (RNQ, oRNQ, RNDQ_RNSC), neon_mac_maybe_scalar),
19731 nUF(vmlsq, _vmls, 3, (RNQ, oRNQ, RNDQ_RNSC), neon_mac_maybe_scalar),
19732 nUF(vpadd, _vpadd, 3, (RND, oRND, RND), neon_dyadic_if_i_d),
19733 /* Add/sub take types I8 I16 I32 I64 F32. */
19734 nUF(vaddq, _vadd, 3, (RNQ, oRNQ, RNQ), neon_addsub_if_i),
19735 nUF(vsubq, _vsub, 3, (RNQ, oRNQ, RNQ), neon_addsub_if_i),
19736 /* vtst takes sizes 8, 16, 32. */
19737 NUF(vtst, 0000810, 3, (RNDQ, oRNDQ, RNDQ), neon_tst),
19738 NUF(vtstq, 0000810, 3, (RNQ, oRNQ, RNQ), neon_tst),
19739 /* VMUL takes I8 I16 I32 F32 P8. */
19740 nUF(vmulq, _vmul, 3, (RNQ, oRNQ, RNDQ_RNSC), neon_mul),
19741 /* VQD{R}MULH takes S16 S32. */
19742 nUF(vqdmulh, _vqdmulh, 3, (RNDQ, oRNDQ, RNDQ_RNSC), neon_qdmulh),
19743 nUF(vqdmulhq, _vqdmulh, 3, (RNQ, oRNQ, RNDQ_RNSC), neon_qdmulh),
19744 nUF(vqrdmulh, _vqrdmulh, 3, (RNDQ, oRNDQ, RNDQ_RNSC), neon_qdmulh),
19745 nUF(vqrdmulhq, _vqrdmulh, 3, (RNQ, oRNQ, RNDQ_RNSC), neon_qdmulh),
19746 NUF(vacge, 0000e10, 3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute),
19747 NUF(vacgeq, 0000e10, 3, (RNQ, oRNQ, RNQ), neon_fcmp_absolute),
19748 NUF(vacgt, 0200e10, 3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute),
19749 NUF(vacgtq, 0200e10, 3, (RNQ, oRNQ, RNQ), neon_fcmp_absolute),
19750 NUF(vaclt, 0200e10, 3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute_inv),
19751 NUF(vacltq, 0200e10, 3, (RNQ, oRNQ, RNQ), neon_fcmp_absolute_inv),
19752 NUF(vacle, 0000e10, 3, (RNDQ, oRNDQ, RNDQ), neon_fcmp_absolute_inv),
19753 NUF(vacleq, 0000e10, 3, (RNQ, oRNQ, RNQ), neon_fcmp_absolute_inv),
19754 NUF(vrecps, 0000f10, 3, (RNDQ, oRNDQ, RNDQ), neon_step),
19755 NUF(vrecpsq, 0000f10, 3, (RNQ, oRNQ, RNQ), neon_step),
19756 NUF(vrsqrts, 0200f10, 3, (RNDQ, oRNDQ, RNDQ), neon_step),
19757 NUF(vrsqrtsq, 0200f10, 3, (RNQ, oRNQ, RNQ), neon_step),
19759 /* Two address, int/float. Types S8 S16 S32 F32. */
19760 NUF(vabsq, 1b10300, 2, (RNQ, RNQ), neon_abs_neg),
19761 NUF(vnegq, 1b10380, 2, (RNQ, RNQ), neon_abs_neg),
19763 /* Data processing with two registers and a shift amount. */
19764 /* Right shifts, and variants with rounding.
19765 Types accepted S8 S16 S32 S64 U8 U16 U32 U64. */
19766 NUF(vshr, 0800010, 3, (RNDQ, oRNDQ, I64z), neon_rshift_round_imm),
19767 NUF(vshrq, 0800010, 3, (RNQ, oRNQ, I64z), neon_rshift_round_imm),
19768 NUF(vrshr, 0800210, 3, (RNDQ, oRNDQ, I64z), neon_rshift_round_imm),
19769 NUF(vrshrq, 0800210, 3, (RNQ, oRNQ, I64z), neon_rshift_round_imm),
19770 NUF(vsra, 0800110, 3, (RNDQ, oRNDQ, I64), neon_rshift_round_imm),
19771 NUF(vsraq, 0800110, 3, (RNQ, oRNQ, I64), neon_rshift_round_imm),
19772 NUF(vrsra, 0800310, 3, (RNDQ, oRNDQ, I64), neon_rshift_round_imm),
19773 NUF(vrsraq, 0800310, 3, (RNQ, oRNQ, I64), neon_rshift_round_imm),
19774 /* Shift and insert. Sizes accepted 8 16 32 64. */
19775 NUF(vsli, 1800510, 3, (RNDQ, oRNDQ, I63), neon_sli),
19776 NUF(vsliq, 1800510, 3, (RNQ, oRNQ, I63), neon_sli),
19777 NUF(vsri, 1800410, 3, (RNDQ, oRNDQ, I64), neon_sri),
19778 NUF(vsriq, 1800410, 3, (RNQ, oRNQ, I64), neon_sri),
19779 /* QSHL{U} immediate accepts S8 S16 S32 S64 U8 U16 U32 U64. */
19780 NUF(vqshlu, 1800610, 3, (RNDQ, oRNDQ, I63), neon_qshlu_imm),
19781 NUF(vqshluq, 1800610, 3, (RNQ, oRNQ, I63), neon_qshlu_imm),
19782 /* Right shift immediate, saturating & narrowing, with rounding variants.
19783 Types accepted S16 S32 S64 U16 U32 U64. */
19784 NUF(vqshrn, 0800910, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow),
19785 NUF(vqrshrn, 0800950, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow),
19786 /* As above, unsigned. Types accepted S16 S32 S64. */
19787 NUF(vqshrun, 0800810, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow_u),
19788 NUF(vqrshrun, 0800850, 3, (RND, RNQ, I32z), neon_rshift_sat_narrow_u),
19789 /* Right shift narrowing. Types accepted I16 I32 I64. */
19790 NUF(vshrn, 0800810, 3, (RND, RNQ, I32z), neon_rshift_narrow),
19791 NUF(vrshrn, 0800850, 3, (RND, RNQ, I32z), neon_rshift_narrow),
19792 /* Special case. Types S8 S16 S32 U8 U16 U32. Handles max shift variant. */
19793 nUF(vshll, _vshll, 3, (RNQ, RND, I32), neon_shll),
19794 /* CVT with optional immediate for fixed-point variant. */
19795 nUF(vcvtq, _vcvt, 3, (RNQ, RNQ, oI32b), neon_cvt),
19797 nUF(vmvn, _vmvn, 2, (RNDQ, RNDQ_Ibig), neon_mvn),
19798 nUF(vmvnq, _vmvn, 2, (RNQ, RNDQ_Ibig), neon_mvn),
19800 /* Data processing, three registers of different lengths. */
19801 /* Dyadic, long insns. Types S8 S16 S32 U8 U16 U32. */
19802 NUF(vabal, 0800500, 3, (RNQ, RND, RND), neon_abal),
19803 NUF(vabdl, 0800700, 3, (RNQ, RND, RND), neon_dyadic_long),
19804 NUF(vaddl, 0800000, 3, (RNQ, RND, RND), neon_dyadic_long),
19805 NUF(vsubl, 0800200, 3, (RNQ, RND, RND), neon_dyadic_long),
19806 /* If not scalar, fall back to neon_dyadic_long.
19807 Vector types as above, scalar types S16 S32 U16 U32. */
19808 nUF(vmlal, _vmlal, 3, (RNQ, RND, RND_RNSC), neon_mac_maybe_scalar_long),
19809 nUF(vmlsl, _vmlsl, 3, (RNQ, RND, RND_RNSC), neon_mac_maybe_scalar_long),
19810 /* Dyadic, widening insns. Types S8 S16 S32 U8 U16 U32. */
19811 NUF(vaddw, 0800100, 3, (RNQ, oRNQ, RND), neon_dyadic_wide),
19812 NUF(vsubw, 0800300, 3, (RNQ, oRNQ, RND), neon_dyadic_wide),
19813 /* Dyadic, narrowing insns. Types I16 I32 I64. */
19814 NUF(vaddhn, 0800400, 3, (RND, RNQ, RNQ), neon_dyadic_narrow),
19815 NUF(vraddhn, 1800400, 3, (RND, RNQ, RNQ), neon_dyadic_narrow),
19816 NUF(vsubhn, 0800600, 3, (RND, RNQ, RNQ), neon_dyadic_narrow),
19817 NUF(vrsubhn, 1800600, 3, (RND, RNQ, RNQ), neon_dyadic_narrow),
19818 /* Saturating doubling multiplies. Types S16 S32. */
19819 nUF(vqdmlal, _vqdmlal, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
19820 nUF(vqdmlsl, _vqdmlsl, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
19821 nUF(vqdmull, _vqdmull, 3, (RNQ, RND, RND_RNSC), neon_mul_sat_scalar_long),
19822 /* VMULL. Vector types S8 S16 S32 U8 U16 U32 P8, scalar types
19823 S16 S32 U16 U32. */
19824 nUF(vmull, _vmull, 3, (RNQ, RND, RND_RNSC), neon_vmull),
19826 /* Extract. Size 8. */
19827 NUF(vext, 0b00000, 4, (RNDQ, oRNDQ, RNDQ, I15), neon_ext),
19828 NUF(vextq, 0b00000, 4, (RNQ, oRNQ, RNQ, I15), neon_ext),
19830 /* Two registers, miscellaneous. */
19831 /* Reverse. Sizes 8 16 32 (must be < size in opcode). */
19832 NUF(vrev64, 1b00000, 2, (RNDQ, RNDQ), neon_rev),
19833 NUF(vrev64q, 1b00000, 2, (RNQ, RNQ), neon_rev),
19834 NUF(vrev32, 1b00080, 2, (RNDQ, RNDQ), neon_rev),
19835 NUF(vrev32q, 1b00080, 2, (RNQ, RNQ), neon_rev),
19836 NUF(vrev16, 1b00100, 2, (RNDQ, RNDQ), neon_rev),
19837 NUF(vrev16q, 1b00100, 2, (RNQ, RNQ), neon_rev),
19838 /* Vector replicate. Sizes 8 16 32. */
19839 nCE(vdup, _vdup, 2, (RNDQ, RR_RNSC), neon_dup),
19840 nCE(vdupq, _vdup, 2, (RNQ, RR_RNSC), neon_dup),
19841 /* VMOVL. Types S8 S16 S32 U8 U16 U32. */
19842 NUF(vmovl, 0800a10, 2, (RNQ, RND), neon_movl),
19843 /* VMOVN. Types I16 I32 I64. */
19844 nUF(vmovn, _vmovn, 2, (RND, RNQ), neon_movn),
19845 /* VQMOVN. Types S16 S32 S64 U16 U32 U64. */
19846 nUF(vqmovn, _vqmovn, 2, (RND, RNQ), neon_qmovn),
19847 /* VQMOVUN. Types S16 S32 S64. */
19848 nUF(vqmovun, _vqmovun, 2, (RND, RNQ), neon_qmovun),
19849 /* VZIP / VUZP. Sizes 8 16 32. */
19850 NUF(vzip, 1b20180, 2, (RNDQ, RNDQ), neon_zip_uzp),
19851 NUF(vzipq, 1b20180, 2, (RNQ, RNQ), neon_zip_uzp),
19852 NUF(vuzp, 1b20100, 2, (RNDQ, RNDQ), neon_zip_uzp),
19853 NUF(vuzpq, 1b20100, 2, (RNQ, RNQ), neon_zip_uzp),
19854 /* VQABS / VQNEG. Types S8 S16 S32. */
19855 NUF(vqabs, 1b00700, 2, (RNDQ, RNDQ), neon_sat_abs_neg),
19856 NUF(vqabsq, 1b00700, 2, (RNQ, RNQ), neon_sat_abs_neg),
19857 NUF(vqneg, 1b00780, 2, (RNDQ, RNDQ), neon_sat_abs_neg),
19858 NUF(vqnegq, 1b00780, 2, (RNQ, RNQ), neon_sat_abs_neg),
19859 /* Pairwise, lengthening. Types S8 S16 S32 U8 U16 U32. */
19860 NUF(vpadal, 1b00600, 2, (RNDQ, RNDQ), neon_pair_long),
19861 NUF(vpadalq, 1b00600, 2, (RNQ, RNQ), neon_pair_long),
19862 NUF(vpaddl, 1b00200, 2, (RNDQ, RNDQ), neon_pair_long),
19863 NUF(vpaddlq, 1b00200, 2, (RNQ, RNQ), neon_pair_long),
19864 /* Reciprocal estimates. Types U32 F32. */
19865 NUF(vrecpe, 1b30400, 2, (RNDQ, RNDQ), neon_recip_est),
19866 NUF(vrecpeq, 1b30400, 2, (RNQ, RNQ), neon_recip_est),
19867 NUF(vrsqrte, 1b30480, 2, (RNDQ, RNDQ), neon_recip_est),
19868 NUF(vrsqrteq, 1b30480, 2, (RNQ, RNQ), neon_recip_est),
19869 /* VCLS. Types S8 S16 S32. */
19870 NUF(vcls, 1b00400, 2, (RNDQ, RNDQ), neon_cls),
19871 NUF(vclsq, 1b00400, 2, (RNQ, RNQ), neon_cls),
19872 /* VCLZ. Types I8 I16 I32. */
19873 NUF(vclz, 1b00480, 2, (RNDQ, RNDQ), neon_clz),
19874 NUF(vclzq, 1b00480, 2, (RNQ, RNQ), neon_clz),
19875 /* VCNT. Size 8. */
19876 NUF(vcnt, 1b00500, 2, (RNDQ, RNDQ), neon_cnt),
19877 NUF(vcntq, 1b00500, 2, (RNQ, RNQ), neon_cnt),
19878 /* Two address, untyped. */
19879 NUF(vswp, 1b20000, 2, (RNDQ, RNDQ), neon_swp),
19880 NUF(vswpq, 1b20000, 2, (RNQ, RNQ), neon_swp),
19881 /* VTRN. Sizes 8 16 32. */
19882 nUF(vtrn, _vtrn, 2, (RNDQ, RNDQ), neon_trn),
19883 nUF(vtrnq, _vtrn, 2, (RNQ, RNQ), neon_trn),
19885 /* Table lookup. Size 8. */
19886 NUF(vtbl, 1b00800, 3, (RND, NRDLST, RND), neon_tbl_tbx),
19887 NUF(vtbx, 1b00840, 3, (RND, NRDLST, RND), neon_tbl_tbx),
19889 #undef THUMB_VARIANT
19890 #define THUMB_VARIANT & fpu_vfp_v3_or_neon_ext
19892 #define ARM_VARIANT & fpu_vfp_v3_or_neon_ext
19894 /* Neon element/structure load/store. */
19895 nUF(vld1, _vld1, 2, (NSTRLST, ADDR), neon_ldx_stx),
19896 nUF(vst1, _vst1, 2, (NSTRLST, ADDR), neon_ldx_stx),
19897 nUF(vld2, _vld2, 2, (NSTRLST, ADDR), neon_ldx_stx),
19898 nUF(vst2, _vst2, 2, (NSTRLST, ADDR), neon_ldx_stx),
19899 nUF(vld3, _vld3, 2, (NSTRLST, ADDR), neon_ldx_stx),
19900 nUF(vst3, _vst3, 2, (NSTRLST, ADDR), neon_ldx_stx),
19901 nUF(vld4, _vld4, 2, (NSTRLST, ADDR), neon_ldx_stx),
19902 nUF(vst4, _vst4, 2, (NSTRLST, ADDR), neon_ldx_stx),
19904 #undef THUMB_VARIANT
19905 #define THUMB_VARIANT & fpu_vfp_ext_v3xd
19907 #define ARM_VARIANT & fpu_vfp_ext_v3xd
19908 cCE("fconsts", eb00a00, 2, (RVS, I255), vfp_sp_const),
19909 cCE("fshtos", eba0a40, 2, (RVS, I16z), vfp_sp_conv_16),
19910 cCE("fsltos", eba0ac0, 2, (RVS, I32), vfp_sp_conv_32),
19911 cCE("fuhtos", ebb0a40, 2, (RVS, I16z), vfp_sp_conv_16),
19912 cCE("fultos", ebb0ac0, 2, (RVS, I32), vfp_sp_conv_32),
19913 cCE("ftoshs", ebe0a40, 2, (RVS, I16z), vfp_sp_conv_16),
19914 cCE("ftosls", ebe0ac0, 2, (RVS, I32), vfp_sp_conv_32),
19915 cCE("ftouhs", ebf0a40, 2, (RVS, I16z), vfp_sp_conv_16),
19916 cCE("ftouls", ebf0ac0, 2, (RVS, I32), vfp_sp_conv_32),
19918 #undef THUMB_VARIANT
19919 #define THUMB_VARIANT & fpu_vfp_ext_v3
19921 #define ARM_VARIANT & fpu_vfp_ext_v3
19923 cCE("fconstd", eb00b00, 2, (RVD, I255), vfp_dp_const),
19924 cCE("fshtod", eba0b40, 2, (RVD, I16z), vfp_dp_conv_16),
19925 cCE("fsltod", eba0bc0, 2, (RVD, I32), vfp_dp_conv_32),
19926 cCE("fuhtod", ebb0b40, 2, (RVD, I16z), vfp_dp_conv_16),
19927 cCE("fultod", ebb0bc0, 2, (RVD, I32), vfp_dp_conv_32),
19928 cCE("ftoshd", ebe0b40, 2, (RVD, I16z), vfp_dp_conv_16),
19929 cCE("ftosld", ebe0bc0, 2, (RVD, I32), vfp_dp_conv_32),
19930 cCE("ftouhd", ebf0b40, 2, (RVD, I16z), vfp_dp_conv_16),
19931 cCE("ftould", ebf0bc0, 2, (RVD, I32), vfp_dp_conv_32),
19934 #define ARM_VARIANT & fpu_vfp_ext_fma
19935 #undef THUMB_VARIANT
19936 #define THUMB_VARIANT & fpu_vfp_ext_fma
19937 /* Mnemonics shared by Neon and VFP. These are included in the
19938 VFP FMA variant; NEON and VFP FMA always includes the NEON
19939 FMA instructions. */
19940 nCEF(vfma, _vfma, 3, (RNSDQ, oRNSDQ, RNSDQ), neon_fmac),
19941 nCEF(vfms, _vfms, 3, (RNSDQ, oRNSDQ, RNSDQ), neon_fmac),
19942 /* ffmas/ffmad/ffmss/ffmsd are dummy mnemonics to satisfy gas;
19943 the v form should always be used. */
19944 cCE("ffmas", ea00a00, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19945 cCE("ffnmas", ea00a40, 3, (RVS, RVS, RVS), vfp_sp_dyadic),
19946 cCE("ffmad", ea00b00, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19947 cCE("ffnmad", ea00b40, 3, (RVD, RVD, RVD), vfp_dp_rd_rn_rm),
19948 nCE(vfnma, _vfnma, 3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
19949 nCE(vfnms, _vfnms, 3, (RVSD, RVSD, RVSD), vfp_nsyn_nmul),
19951 #undef THUMB_VARIANT
19953 #define ARM_VARIANT & arm_cext_xscale /* Intel XScale extensions. */
19955 cCE("mia", e200010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19956 cCE("miaph", e280010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19957 cCE("miabb", e2c0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19958 cCE("miabt", e2d0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19959 cCE("miatb", e2e0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19960 cCE("miatt", e2f0010, 3, (RXA, RRnpc, RRnpc), xsc_mia),
19961 cCE("mar", c400000, 3, (RXA, RRnpc, RRnpc), xsc_mar),
19962 cCE("mra", c500000, 3, (RRnpc, RRnpc, RXA), xsc_mra),
19965 #define ARM_VARIANT & arm_cext_iwmmxt /* Intel Wireless MMX technology. */
19967 cCE("tandcb", e13f130, 1, (RR), iwmmxt_tandorc),
19968 cCE("tandch", e53f130, 1, (RR), iwmmxt_tandorc),
19969 cCE("tandcw", e93f130, 1, (RR), iwmmxt_tandorc),
19970 cCE("tbcstb", e400010, 2, (RIWR, RR), rn_rd),
19971 cCE("tbcsth", e400050, 2, (RIWR, RR), rn_rd),
19972 cCE("tbcstw", e400090, 2, (RIWR, RR), rn_rd),
19973 cCE("textrcb", e130170, 2, (RR, I7), iwmmxt_textrc),
19974 cCE("textrch", e530170, 2, (RR, I7), iwmmxt_textrc),
19975 cCE("textrcw", e930170, 2, (RR, I7), iwmmxt_textrc),
19976 cCE("textrmub",e100070, 3, (RR, RIWR, I7), iwmmxt_textrm),
19977 cCE("textrmuh",e500070, 3, (RR, RIWR, I7), iwmmxt_textrm),
19978 cCE("textrmuw",e900070, 3, (RR, RIWR, I7), iwmmxt_textrm),
19979 cCE("textrmsb",e100078, 3, (RR, RIWR, I7), iwmmxt_textrm),
19980 cCE("textrmsh",e500078, 3, (RR, RIWR, I7), iwmmxt_textrm),
19981 cCE("textrmsw",e900078, 3, (RR, RIWR, I7), iwmmxt_textrm),
19982 cCE("tinsrb", e600010, 3, (RIWR, RR, I7), iwmmxt_tinsr),
19983 cCE("tinsrh", e600050, 3, (RIWR, RR, I7), iwmmxt_tinsr),
19984 cCE("tinsrw", e600090, 3, (RIWR, RR, I7), iwmmxt_tinsr),
19985 cCE("tmcr", e000110, 2, (RIWC_RIWG, RR), rn_rd),
19986 cCE("tmcrr", c400000, 3, (RIWR, RR, RR), rm_rd_rn),
19987 cCE("tmia", e200010, 3, (RIWR, RR, RR), iwmmxt_tmia),
19988 cCE("tmiaph", e280010, 3, (RIWR, RR, RR), iwmmxt_tmia),
19989 cCE("tmiabb", e2c0010, 3, (RIWR, RR, RR), iwmmxt_tmia),
19990 cCE("tmiabt", e2d0010, 3, (RIWR, RR, RR), iwmmxt_tmia),
19991 cCE("tmiatb", e2e0010, 3, (RIWR, RR, RR), iwmmxt_tmia),
19992 cCE("tmiatt", e2f0010, 3, (RIWR, RR, RR), iwmmxt_tmia),
19993 cCE("tmovmskb",e100030, 2, (RR, RIWR), rd_rn),
19994 cCE("tmovmskh",e500030, 2, (RR, RIWR), rd_rn),
19995 cCE("tmovmskw",e900030, 2, (RR, RIWR), rd_rn),
19996 cCE("tmrc", e100110, 2, (RR, RIWC_RIWG), rd_rn),
19997 cCE("tmrrc", c500000, 3, (RR, RR, RIWR), rd_rn_rm),
19998 cCE("torcb", e13f150, 1, (RR), iwmmxt_tandorc),
19999 cCE("torch", e53f150, 1, (RR), iwmmxt_tandorc),
20000 cCE("torcw", e93f150, 1, (RR), iwmmxt_tandorc),
20001 cCE("waccb", e0001c0, 2, (RIWR, RIWR), rd_rn),
20002 cCE("wacch", e4001c0, 2, (RIWR, RIWR), rd_rn),
20003 cCE("waccw", e8001c0, 2, (RIWR, RIWR), rd_rn),
20004 cCE("waddbss", e300180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20005 cCE("waddb", e000180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20006 cCE("waddbus", e100180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20007 cCE("waddhss", e700180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20008 cCE("waddh", e400180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20009 cCE("waddhus", e500180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20010 cCE("waddwss", eb00180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20011 cCE("waddw", e800180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20012 cCE("waddwus", e900180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20013 cCE("waligni", e000020, 4, (RIWR, RIWR, RIWR, I7), iwmmxt_waligni),
20014 cCE("walignr0",e800020, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20015 cCE("walignr1",e900020, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20016 cCE("walignr2",ea00020, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20017 cCE("walignr3",eb00020, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20018 cCE("wand", e200000, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20019 cCE("wandn", e300000, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20020 cCE("wavg2b", e800000, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20021 cCE("wavg2br", e900000, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20022 cCE("wavg2h", ec00000, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20023 cCE("wavg2hr", ed00000, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20024 cCE("wcmpeqb", e000060, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20025 cCE("wcmpeqh", e400060, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20026 cCE("wcmpeqw", e800060, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20027 cCE("wcmpgtub",e100060, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20028 cCE("wcmpgtuh",e500060, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20029 cCE("wcmpgtuw",e900060, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20030 cCE("wcmpgtsb",e300060, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20031 cCE("wcmpgtsh",e700060, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20032 cCE("wcmpgtsw",eb00060, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20033 cCE("wldrb", c100000, 2, (RIWR, ADDR), iwmmxt_wldstbh),
20034 cCE("wldrh", c500000, 2, (RIWR, ADDR), iwmmxt_wldstbh),
20035 cCE("wldrw", c100100, 2, (RIWR_RIWC, ADDR), iwmmxt_wldstw),
20036 cCE("wldrd", c500100, 2, (RIWR, ADDR), iwmmxt_wldstd),
20037 cCE("wmacs", e600100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20038 cCE("wmacsz", e700100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20039 cCE("wmacu", e400100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20040 cCE("wmacuz", e500100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20041 cCE("wmadds", ea00100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20042 cCE("wmaddu", e800100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20043 cCE("wmaxsb", e200160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20044 cCE("wmaxsh", e600160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20045 cCE("wmaxsw", ea00160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20046 cCE("wmaxub", e000160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20047 cCE("wmaxuh", e400160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20048 cCE("wmaxuw", e800160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20049 cCE("wminsb", e300160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20050 cCE("wminsh", e700160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20051 cCE("wminsw", eb00160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20052 cCE("wminub", e100160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20053 cCE("wminuh", e500160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20054 cCE("wminuw", e900160, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20055 cCE("wmov", e000000, 2, (RIWR, RIWR), iwmmxt_wmov),
20056 cCE("wmulsm", e300100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20057 cCE("wmulsl", e200100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20058 cCE("wmulum", e100100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20059 cCE("wmulul", e000100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20060 cCE("wor", e000000, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20061 cCE("wpackhss",e700080, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20062 cCE("wpackhus",e500080, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20063 cCE("wpackwss",eb00080, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20064 cCE("wpackwus",e900080, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20065 cCE("wpackdss",ef00080, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20066 cCE("wpackdus",ed00080, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20067 cCE("wrorh", e700040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20068 cCE("wrorhg", e700148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20069 cCE("wrorw", eb00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20070 cCE("wrorwg", eb00148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20071 cCE("wrord", ef00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20072 cCE("wrordg", ef00148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20073 cCE("wsadb", e000120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20074 cCE("wsadbz", e100120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20075 cCE("wsadh", e400120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20076 cCE("wsadhz", e500120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20077 cCE("wshufh", e0001e0, 3, (RIWR, RIWR, I255), iwmmxt_wshufh),
20078 cCE("wsllh", e500040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20079 cCE("wsllhg", e500148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20080 cCE("wsllw", e900040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20081 cCE("wsllwg", e900148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20082 cCE("wslld", ed00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20083 cCE("wslldg", ed00148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20084 cCE("wsrah", e400040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20085 cCE("wsrahg", e400148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20086 cCE("wsraw", e800040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20087 cCE("wsrawg", e800148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20088 cCE("wsrad", ec00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20089 cCE("wsradg", ec00148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20090 cCE("wsrlh", e600040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20091 cCE("wsrlhg", e600148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20092 cCE("wsrlw", ea00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20093 cCE("wsrlwg", ea00148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20094 cCE("wsrld", ee00040, 3, (RIWR, RIWR, RIWR_I32z),iwmmxt_wrwrwr_or_imm5),
20095 cCE("wsrldg", ee00148, 3, (RIWR, RIWR, RIWG), rd_rn_rm),
20096 cCE("wstrb", c000000, 2, (RIWR, ADDR), iwmmxt_wldstbh),
20097 cCE("wstrh", c400000, 2, (RIWR, ADDR), iwmmxt_wldstbh),
20098 cCE("wstrw", c000100, 2, (RIWR_RIWC, ADDR), iwmmxt_wldstw),
20099 cCE("wstrd", c400100, 2, (RIWR, ADDR), iwmmxt_wldstd),
20100 cCE("wsubbss", e3001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20101 cCE("wsubb", e0001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20102 cCE("wsubbus", e1001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20103 cCE("wsubhss", e7001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20104 cCE("wsubh", e4001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20105 cCE("wsubhus", e5001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20106 cCE("wsubwss", eb001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20107 cCE("wsubw", e8001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20108 cCE("wsubwus", e9001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20109 cCE("wunpckehub",e0000c0, 2, (RIWR, RIWR), rd_rn),
20110 cCE("wunpckehuh",e4000c0, 2, (RIWR, RIWR), rd_rn),
20111 cCE("wunpckehuw",e8000c0, 2, (RIWR, RIWR), rd_rn),
20112 cCE("wunpckehsb",e2000c0, 2, (RIWR, RIWR), rd_rn),
20113 cCE("wunpckehsh",e6000c0, 2, (RIWR, RIWR), rd_rn),
20114 cCE("wunpckehsw",ea000c0, 2, (RIWR, RIWR), rd_rn),
20115 cCE("wunpckihb", e1000c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20116 cCE("wunpckihh", e5000c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20117 cCE("wunpckihw", e9000c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20118 cCE("wunpckelub",e0000e0, 2, (RIWR, RIWR), rd_rn),
20119 cCE("wunpckeluh",e4000e0, 2, (RIWR, RIWR), rd_rn),
20120 cCE("wunpckeluw",e8000e0, 2, (RIWR, RIWR), rd_rn),
20121 cCE("wunpckelsb",e2000e0, 2, (RIWR, RIWR), rd_rn),
20122 cCE("wunpckelsh",e6000e0, 2, (RIWR, RIWR), rd_rn),
20123 cCE("wunpckelsw",ea000e0, 2, (RIWR, RIWR), rd_rn),
20124 cCE("wunpckilb", e1000e0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20125 cCE("wunpckilh", e5000e0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20126 cCE("wunpckilw", e9000e0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20127 cCE("wxor", e100000, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20128 cCE("wzero", e300000, 1, (RIWR), iwmmxt_wzero),
20131 #define ARM_VARIANT & arm_cext_iwmmxt2 /* Intel Wireless MMX technology, version 2. */
20133 cCE("torvscb", e12f190, 1, (RR), iwmmxt_tandorc),
20134 cCE("torvsch", e52f190, 1, (RR), iwmmxt_tandorc),
20135 cCE("torvscw", e92f190, 1, (RR), iwmmxt_tandorc),
20136 cCE("wabsb", e2001c0, 2, (RIWR, RIWR), rd_rn),
20137 cCE("wabsh", e6001c0, 2, (RIWR, RIWR), rd_rn),
20138 cCE("wabsw", ea001c0, 2, (RIWR, RIWR), rd_rn),
20139 cCE("wabsdiffb", e1001c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20140 cCE("wabsdiffh", e5001c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20141 cCE("wabsdiffw", e9001c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20142 cCE("waddbhusl", e2001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20143 cCE("waddbhusm", e6001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20144 cCE("waddhc", e600180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20145 cCE("waddwc", ea00180, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20146 cCE("waddsubhx", ea001a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20147 cCE("wavg4", e400000, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20148 cCE("wavg4r", e500000, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20149 cCE("wmaddsn", ee00100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20150 cCE("wmaddsx", eb00100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20151 cCE("wmaddun", ec00100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20152 cCE("wmaddux", e900100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20153 cCE("wmerge", e000080, 4, (RIWR, RIWR, RIWR, I7), iwmmxt_wmerge),
20154 cCE("wmiabb", e0000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20155 cCE("wmiabt", e1000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20156 cCE("wmiatb", e2000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20157 cCE("wmiatt", e3000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20158 cCE("wmiabbn", e4000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20159 cCE("wmiabtn", e5000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20160 cCE("wmiatbn", e6000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20161 cCE("wmiattn", e7000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20162 cCE("wmiawbb", e800120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20163 cCE("wmiawbt", e900120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20164 cCE("wmiawtb", ea00120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20165 cCE("wmiawtt", eb00120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20166 cCE("wmiawbbn", ec00120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20167 cCE("wmiawbtn", ed00120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20168 cCE("wmiawtbn", ee00120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20169 cCE("wmiawttn", ef00120, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20170 cCE("wmulsmr", ef00100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20171 cCE("wmulumr", ed00100, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20172 cCE("wmulwumr", ec000c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20173 cCE("wmulwsmr", ee000c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20174 cCE("wmulwum", ed000c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20175 cCE("wmulwsm", ef000c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20176 cCE("wmulwl", eb000c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20177 cCE("wqmiabb", e8000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20178 cCE("wqmiabt", e9000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20179 cCE("wqmiatb", ea000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20180 cCE("wqmiatt", eb000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20181 cCE("wqmiabbn", ec000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20182 cCE("wqmiabtn", ed000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20183 cCE("wqmiatbn", ee000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20184 cCE("wqmiattn", ef000a0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20185 cCE("wqmulm", e100080, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20186 cCE("wqmulmr", e300080, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20187 cCE("wqmulwm", ec000e0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20188 cCE("wqmulwmr", ee000e0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20189 cCE("wsubaddhx", ed001c0, 3, (RIWR, RIWR, RIWR), rd_rn_rm),
20192 #define ARM_VARIANT & arm_cext_maverick /* Cirrus Maverick instructions. */
20194 cCE("cfldrs", c100400, 2, (RMF, ADDRGLDC), rd_cpaddr),
20195 cCE("cfldrd", c500400, 2, (RMD, ADDRGLDC), rd_cpaddr),
20196 cCE("cfldr32", c100500, 2, (RMFX, ADDRGLDC), rd_cpaddr),
20197 cCE("cfldr64", c500500, 2, (RMDX, ADDRGLDC), rd_cpaddr),
20198 cCE("cfstrs", c000400, 2, (RMF, ADDRGLDC), rd_cpaddr),
20199 cCE("cfstrd", c400400, 2, (RMD, ADDRGLDC), rd_cpaddr),
20200 cCE("cfstr32", c000500, 2, (RMFX, ADDRGLDC), rd_cpaddr),
20201 cCE("cfstr64", c400500, 2, (RMDX, ADDRGLDC), rd_cpaddr),
20202 cCE("cfmvsr", e000450, 2, (RMF, RR), rn_rd),
20203 cCE("cfmvrs", e100450, 2, (RR, RMF), rd_rn),
20204 cCE("cfmvdlr", e000410, 2, (RMD, RR), rn_rd),
20205 cCE("cfmvrdl", e100410, 2, (RR, RMD), rd_rn),
20206 cCE("cfmvdhr", e000430, 2, (RMD, RR), rn_rd),
20207 cCE("cfmvrdh", e100430, 2, (RR, RMD), rd_rn),
20208 cCE("cfmv64lr",e000510, 2, (RMDX, RR), rn_rd),
20209 cCE("cfmvr64l",e100510, 2, (RR, RMDX), rd_rn),
20210 cCE("cfmv64hr",e000530, 2, (RMDX, RR), rn_rd),
20211 cCE("cfmvr64h",e100530, 2, (RR, RMDX), rd_rn),
20212 cCE("cfmval32",e200440, 2, (RMAX, RMFX), rd_rn),
20213 cCE("cfmv32al",e100440, 2, (RMFX, RMAX), rd_rn),
20214 cCE("cfmvam32",e200460, 2, (RMAX, RMFX), rd_rn),
20215 cCE("cfmv32am",e100460, 2, (RMFX, RMAX), rd_rn),
20216 cCE("cfmvah32",e200480, 2, (RMAX, RMFX), rd_rn),
20217 cCE("cfmv32ah",e100480, 2, (RMFX, RMAX), rd_rn),
20218 cCE("cfmva32", e2004a0, 2, (RMAX, RMFX), rd_rn),
20219 cCE("cfmv32a", e1004a0, 2, (RMFX, RMAX), rd_rn),
20220 cCE("cfmva64", e2004c0, 2, (RMAX, RMDX), rd_rn),
20221 cCE("cfmv64a", e1004c0, 2, (RMDX, RMAX), rd_rn),
20222 cCE("cfmvsc32",e2004e0, 2, (RMDS, RMDX), mav_dspsc),
20223 cCE("cfmv32sc",e1004e0, 2, (RMDX, RMDS), rd),
20224 cCE("cfcpys", e000400, 2, (RMF, RMF), rd_rn),
20225 cCE("cfcpyd", e000420, 2, (RMD, RMD), rd_rn),
20226 cCE("cfcvtsd", e000460, 2, (RMD, RMF), rd_rn),
20227 cCE("cfcvtds", e000440, 2, (RMF, RMD), rd_rn),
20228 cCE("cfcvt32s",e000480, 2, (RMF, RMFX), rd_rn),
20229 cCE("cfcvt32d",e0004a0, 2, (RMD, RMFX), rd_rn),
20230 cCE("cfcvt64s",e0004c0, 2, (RMF, RMDX), rd_rn),
20231 cCE("cfcvt64d",e0004e0, 2, (RMD, RMDX), rd_rn),
20232 cCE("cfcvts32",e100580, 2, (RMFX, RMF), rd_rn),
20233 cCE("cfcvtd32",e1005a0, 2, (RMFX, RMD), rd_rn),
20234 cCE("cftruncs32",e1005c0, 2, (RMFX, RMF), rd_rn),
20235 cCE("cftruncd32",e1005e0, 2, (RMFX, RMD), rd_rn),
20236 cCE("cfrshl32",e000550, 3, (RMFX, RMFX, RR), mav_triple),
20237 cCE("cfrshl64",e000570, 3, (RMDX, RMDX, RR), mav_triple),
20238 cCE("cfsh32", e000500, 3, (RMFX, RMFX, I63s), mav_shift),
20239 cCE("cfsh64", e200500, 3, (RMDX, RMDX, I63s), mav_shift),
20240 cCE("cfcmps", e100490, 3, (RR, RMF, RMF), rd_rn_rm),
20241 cCE("cfcmpd", e1004b0, 3, (RR, RMD, RMD), rd_rn_rm),
20242 cCE("cfcmp32", e100590, 3, (RR, RMFX, RMFX), rd_rn_rm),
20243 cCE("cfcmp64", e1005b0, 3, (RR, RMDX, RMDX), rd_rn_rm),
20244 cCE("cfabss", e300400, 2, (RMF, RMF), rd_rn),
20245 cCE("cfabsd", e300420, 2, (RMD, RMD), rd_rn),
20246 cCE("cfnegs", e300440, 2, (RMF, RMF), rd_rn),
20247 cCE("cfnegd", e300460, 2, (RMD, RMD), rd_rn),
20248 cCE("cfadds", e300480, 3, (RMF, RMF, RMF), rd_rn_rm),
20249 cCE("cfaddd", e3004a0, 3, (RMD, RMD, RMD), rd_rn_rm),
20250 cCE("cfsubs", e3004c0, 3, (RMF, RMF, RMF), rd_rn_rm),
20251 cCE("cfsubd", e3004e0, 3, (RMD, RMD, RMD), rd_rn_rm),
20252 cCE("cfmuls", e100400, 3, (RMF, RMF, RMF), rd_rn_rm),
20253 cCE("cfmuld", e100420, 3, (RMD, RMD, RMD), rd_rn_rm),
20254 cCE("cfabs32", e300500, 2, (RMFX, RMFX), rd_rn),
20255 cCE("cfabs64", e300520, 2, (RMDX, RMDX), rd_rn),
20256 cCE("cfneg32", e300540, 2, (RMFX, RMFX), rd_rn),
20257 cCE("cfneg64", e300560, 2, (RMDX, RMDX), rd_rn),
20258 cCE("cfadd32", e300580, 3, (RMFX, RMFX, RMFX), rd_rn_rm),
20259 cCE("cfadd64", e3005a0, 3, (RMDX, RMDX, RMDX), rd_rn_rm),
20260 cCE("cfsub32", e3005c0, 3, (RMFX, RMFX, RMFX), rd_rn_rm),
20261 cCE("cfsub64", e3005e0, 3, (RMDX, RMDX, RMDX), rd_rn_rm),
20262 cCE("cfmul32", e100500, 3, (RMFX, RMFX, RMFX), rd_rn_rm),
20263 cCE("cfmul64", e100520, 3, (RMDX, RMDX, RMDX), rd_rn_rm),
20264 cCE("cfmac32", e100540, 3, (RMFX, RMFX, RMFX), rd_rn_rm),
20265 cCE("cfmsc32", e100560, 3, (RMFX, RMFX, RMFX), rd_rn_rm),
20266 cCE("cfmadd32",e000600, 4, (RMAX, RMFX, RMFX, RMFX), mav_quad),
20267 cCE("cfmsub32",e100600, 4, (RMAX, RMFX, RMFX, RMFX), mav_quad),
20268 cCE("cfmadda32", e200600, 4, (RMAX, RMAX, RMFX, RMFX), mav_quad),
20269 cCE("cfmsuba32", e300600, 4, (RMAX, RMAX, RMFX, RMFX), mav_quad),
20272 #undef THUMB_VARIANT
20298 /* MD interface: bits in the object file. */
20300 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
20301 for use in the a.out file, and stores them in the array pointed to by buf.
20302 This knows about the endian-ness of the target machine and does
20303 THE RIGHT THING, whatever it is. Possible values for n are 1 (byte)
20304 2 (short) and 4 (long) Floating numbers are put out as a series of
20305 LITTLENUMS (shorts, here at least). */
20308 md_number_to_chars (char * buf, valueT val, int n)
20310 if (target_big_endian)
20311 number_to_chars_bigendian (buf, val, n);
20313 number_to_chars_littleendian (buf, val, n);
20317 md_chars_to_number (char * buf, int n)
20320 unsigned char * where = (unsigned char *) buf;
20322 if (target_big_endian)
20327 result |= (*where++ & 255);
20335 result |= (where[n] & 255);
20342 /* MD interface: Sections. */
20344 /* Calculate the maximum variable size (i.e., excluding fr_fix)
20345 that an rs_machine_dependent frag may reach. */
20348 arm_frag_max_var (fragS *fragp)
20350 /* We only use rs_machine_dependent for variable-size Thumb instructions,
20351 which are either THUMB_SIZE (2) or INSN_SIZE (4).
20353 Note that we generate relaxable instructions even for cases that don't
20354 really need it, like an immediate that's a trivial constant. So we're
20355 overestimating the instruction size for some of those cases. Rather
20356 than putting more intelligence here, it would probably be better to
20357 avoid generating a relaxation frag in the first place when it can be
20358 determined up front that a short instruction will suffice. */
20360 gas_assert (fragp->fr_type == rs_machine_dependent);
20364 /* Estimate the size of a frag before relaxing. Assume everything fits in
20368 md_estimate_size_before_relax (fragS * fragp,
20369 segT segtype ATTRIBUTE_UNUSED)
20375 /* Convert a machine dependent frag. */
20378 md_convert_frag (bfd *abfd, segT asec ATTRIBUTE_UNUSED, fragS *fragp)
20380 unsigned long insn;
20381 unsigned long old_op;
20389 buf = fragp->fr_literal + fragp->fr_fix;
20391 old_op = bfd_get_16(abfd, buf);
20392 if (fragp->fr_symbol)
20394 exp.X_op = O_symbol;
20395 exp.X_add_symbol = fragp->fr_symbol;
20399 exp.X_op = O_constant;
20401 exp.X_add_number = fragp->fr_offset;
20402 opcode = fragp->fr_subtype;
20405 case T_MNEM_ldr_pc:
20406 case T_MNEM_ldr_pc2:
20407 case T_MNEM_ldr_sp:
20408 case T_MNEM_str_sp:
20415 if (fragp->fr_var == 4)
20417 insn = THUMB_OP32 (opcode);
20418 if ((old_op >> 12) == 4 || (old_op >> 12) == 9)
20420 insn |= (old_op & 0x700) << 4;
20424 insn |= (old_op & 7) << 12;
20425 insn |= (old_op & 0x38) << 13;
20427 insn |= 0x00000c00;
20428 put_thumb32_insn (buf, insn);
20429 reloc_type = BFD_RELOC_ARM_T32_OFFSET_IMM;
20433 reloc_type = BFD_RELOC_ARM_THUMB_OFFSET;
20435 pc_rel = (opcode == T_MNEM_ldr_pc2);
20438 if (fragp->fr_var == 4)
20440 insn = THUMB_OP32 (opcode);
20441 insn |= (old_op & 0xf0) << 4;
20442 put_thumb32_insn (buf, insn);
20443 reloc_type = BFD_RELOC_ARM_T32_ADD_PC12;
20447 reloc_type = BFD_RELOC_ARM_THUMB_ADD;
20448 exp.X_add_number -= 4;
20456 if (fragp->fr_var == 4)
20458 int r0off = (opcode == T_MNEM_mov
20459 || opcode == T_MNEM_movs) ? 0 : 8;
20460 insn = THUMB_OP32 (opcode);
20461 insn = (insn & 0xe1ffffff) | 0x10000000;
20462 insn |= (old_op & 0x700) << r0off;
20463 put_thumb32_insn (buf, insn);
20464 reloc_type = BFD_RELOC_ARM_T32_IMMEDIATE;
20468 reloc_type = BFD_RELOC_ARM_THUMB_IMM;
20473 if (fragp->fr_var == 4)
20475 insn = THUMB_OP32(opcode);
20476 put_thumb32_insn (buf, insn);
20477 reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH25;
20480 reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH12;
20484 if (fragp->fr_var == 4)
20486 insn = THUMB_OP32(opcode);
20487 insn |= (old_op & 0xf00) << 14;
20488 put_thumb32_insn (buf, insn);
20489 reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH20;
20492 reloc_type = BFD_RELOC_THUMB_PCREL_BRANCH9;
20495 case T_MNEM_add_sp:
20496 case T_MNEM_add_pc:
20497 case T_MNEM_inc_sp:
20498 case T_MNEM_dec_sp:
20499 if (fragp->fr_var == 4)
20501 /* ??? Choose between add and addw. */
20502 insn = THUMB_OP32 (opcode);
20503 insn |= (old_op & 0xf0) << 4;
20504 put_thumb32_insn (buf, insn);
20505 if (opcode == T_MNEM_add_pc)
20506 reloc_type = BFD_RELOC_ARM_T32_IMM12;
20508 reloc_type = BFD_RELOC_ARM_T32_ADD_IMM;
20511 reloc_type = BFD_RELOC_ARM_THUMB_ADD;
20519 if (fragp->fr_var == 4)
20521 insn = THUMB_OP32 (opcode);
20522 insn |= (old_op & 0xf0) << 4;
20523 insn |= (old_op & 0xf) << 16;
20524 put_thumb32_insn (buf, insn);
20525 if (insn & (1 << 20))
20526 reloc_type = BFD_RELOC_ARM_T32_ADD_IMM;
20528 reloc_type = BFD_RELOC_ARM_T32_IMMEDIATE;
20531 reloc_type = BFD_RELOC_ARM_THUMB_ADD;
20537 fixp = fix_new_exp (fragp, fragp->fr_fix, fragp->fr_var, &exp, pc_rel,
20538 (enum bfd_reloc_code_real) reloc_type);
20539 fixp->fx_file = fragp->fr_file;
20540 fixp->fx_line = fragp->fr_line;
20541 fragp->fr_fix += fragp->fr_var;
20543 /* Set whether we use thumb-2 ISA based on final relaxation results. */
20544 if (thumb_mode && fragp->fr_var == 4 && no_cpu_selected ()
20545 && !ARM_CPU_HAS_FEATURE (thumb_arch_used, arm_arch_t2))
20546 ARM_MERGE_FEATURE_SETS (arm_arch_used, thumb_arch_used, arm_ext_v6t2);
20549 /* Return the size of a relaxable immediate operand instruction.
20550 SHIFT and SIZE specify the form of the allowable immediate. */
20552 relax_immediate (fragS *fragp, int size, int shift)
20558 /* ??? Should be able to do better than this. */
20559 if (fragp->fr_symbol)
20562 low = (1 << shift) - 1;
20563 mask = (1 << (shift + size)) - (1 << shift);
20564 offset = fragp->fr_offset;
20565 /* Force misaligned offsets to 32-bit variant. */
20568 if (offset & ~mask)
20573 /* Get the address of a symbol during relaxation. */
20575 relaxed_symbol_addr (fragS *fragp, long stretch)
20581 sym = fragp->fr_symbol;
20582 sym_frag = symbol_get_frag (sym);
20583 know (S_GET_SEGMENT (sym) != absolute_section
20584 || sym_frag == &zero_address_frag);
20585 addr = S_GET_VALUE (sym) + fragp->fr_offset;
20587 /* If frag has yet to be reached on this pass, assume it will
20588 move by STRETCH just as we did. If this is not so, it will
20589 be because some frag between grows, and that will force
20593 && sym_frag->relax_marker != fragp->relax_marker)
20597 /* Adjust stretch for any alignment frag. Note that if have
20598 been expanding the earlier code, the symbol may be
20599 defined in what appears to be an earlier frag. FIXME:
20600 This doesn't handle the fr_subtype field, which specifies
20601 a maximum number of bytes to skip when doing an
20603 for (f = fragp; f != NULL && f != sym_frag; f = f->fr_next)
20605 if (f->fr_type == rs_align || f->fr_type == rs_align_code)
20608 stretch = - ((- stretch)
20609 & ~ ((1 << (int) f->fr_offset) - 1));
20611 stretch &= ~ ((1 << (int) f->fr_offset) - 1);
20623 /* Return the size of a relaxable adr pseudo-instruction or PC-relative
20626 relax_adr (fragS *fragp, asection *sec, long stretch)
20631 /* Assume worst case for symbols not known to be in the same section. */
20632 if (fragp->fr_symbol == NULL
20633 || !S_IS_DEFINED (fragp->fr_symbol)
20634 || sec != S_GET_SEGMENT (fragp->fr_symbol)
20635 || S_IS_WEAK (fragp->fr_symbol))
20638 val = relaxed_symbol_addr (fragp, stretch);
20639 addr = fragp->fr_address + fragp->fr_fix;
20640 addr = (addr + 4) & ~3;
20641 /* Force misaligned targets to 32-bit variant. */
20645 if (val < 0 || val > 1020)
20650 /* Return the size of a relaxable add/sub immediate instruction. */
20652 relax_addsub (fragS *fragp, asection *sec)
20657 buf = fragp->fr_literal + fragp->fr_fix;
20658 op = bfd_get_16(sec->owner, buf);
20659 if ((op & 0xf) == ((op >> 4) & 0xf))
20660 return relax_immediate (fragp, 8, 0);
20662 return relax_immediate (fragp, 3, 0);
20665 /* Return TRUE iff the definition of symbol S could be pre-empted
20666 (overridden) at link or load time. */
20668 symbol_preemptible (symbolS *s)
20670 /* Weak symbols can always be pre-empted. */
20674 /* Non-global symbols cannot be pre-empted. */
20675 if (! S_IS_EXTERNAL (s))
20679 /* In ELF, a global symbol can be marked protected, or private. In that
20680 case it can't be pre-empted (other definitions in the same link unit
20681 would violate the ODR). */
20682 if (ELF_ST_VISIBILITY (S_GET_OTHER (s)) > STV_DEFAULT)
20686 /* Other global symbols might be pre-empted. */
20690 /* Return the size of a relaxable branch instruction. BITS is the
20691 size of the offset field in the narrow instruction. */
20694 relax_branch (fragS *fragp, asection *sec, int bits, long stretch)
20700 /* Assume worst case for symbols not known to be in the same section. */
20701 if (!S_IS_DEFINED (fragp->fr_symbol)
20702 || sec != S_GET_SEGMENT (fragp->fr_symbol)
20703 || S_IS_WEAK (fragp->fr_symbol))
20707 /* A branch to a function in ARM state will require interworking. */
20708 if (S_IS_DEFINED (fragp->fr_symbol)
20709 && ARM_IS_FUNC (fragp->fr_symbol))
20713 if (symbol_preemptible (fragp->fr_symbol))
20716 val = relaxed_symbol_addr (fragp, stretch);
20717 addr = fragp->fr_address + fragp->fr_fix + 4;
20720 /* Offset is a signed value *2 */
20722 if (val >= limit || val < -limit)
20728 /* Relax a machine dependent frag. This returns the amount by which
20729 the current size of the frag should change. */
20732 arm_relax_frag (asection *sec, fragS *fragp, long stretch)
20737 oldsize = fragp->fr_var;
20738 switch (fragp->fr_subtype)
20740 case T_MNEM_ldr_pc2:
20741 newsize = relax_adr (fragp, sec, stretch);
20743 case T_MNEM_ldr_pc:
20744 case T_MNEM_ldr_sp:
20745 case T_MNEM_str_sp:
20746 newsize = relax_immediate (fragp, 8, 2);
20750 newsize = relax_immediate (fragp, 5, 2);
20754 newsize = relax_immediate (fragp, 5, 1);
20758 newsize = relax_immediate (fragp, 5, 0);
20761 newsize = relax_adr (fragp, sec, stretch);
20767 newsize = relax_immediate (fragp, 8, 0);
20770 newsize = relax_branch (fragp, sec, 11, stretch);
20773 newsize = relax_branch (fragp, sec, 8, stretch);
20775 case T_MNEM_add_sp:
20776 case T_MNEM_add_pc:
20777 newsize = relax_immediate (fragp, 8, 2);
20779 case T_MNEM_inc_sp:
20780 case T_MNEM_dec_sp:
20781 newsize = relax_immediate (fragp, 7, 2);
20787 newsize = relax_addsub (fragp, sec);
20793 fragp->fr_var = newsize;
20794 /* Freeze wide instructions that are at or before the same location as
20795 in the previous pass. This avoids infinite loops.
20796 Don't freeze them unconditionally because targets may be artificially
20797 misaligned by the expansion of preceding frags. */
20798 if (stretch <= 0 && newsize > 2)
20800 md_convert_frag (sec->owner, sec, fragp);
20804 return newsize - oldsize;
20807 /* Round up a section size to the appropriate boundary. */
20810 md_section_align (segT segment ATTRIBUTE_UNUSED,
20813 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
20814 if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
20816 /* For a.out, force the section size to be aligned. If we don't do
20817 this, BFD will align it for us, but it will not write out the
20818 final bytes of the section. This may be a bug in BFD, but it is
20819 easier to fix it here since that is how the other a.out targets
20823 align = bfd_get_section_alignment (stdoutput, segment);
20824 size = ((size + (1 << align) - 1) & ((valueT) -1 << align));
20831 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
20832 of an rs_align_code fragment. */
20835 arm_handle_align (fragS * fragP)
20837 static char const arm_noop[2][2][4] =
20840 {0x00, 0x00, 0xa0, 0xe1}, /* LE */
20841 {0xe1, 0xa0, 0x00, 0x00}, /* BE */
20844 {0x00, 0xf0, 0x20, 0xe3}, /* LE */
20845 {0xe3, 0x20, 0xf0, 0x00}, /* BE */
20848 static char const thumb_noop[2][2][2] =
20851 {0xc0, 0x46}, /* LE */
20852 {0x46, 0xc0}, /* BE */
20855 {0x00, 0xbf}, /* LE */
20856 {0xbf, 0x00} /* BE */
20859 static char const wide_thumb_noop[2][4] =
20860 { /* Wide Thumb-2 */
20861 {0xaf, 0xf3, 0x00, 0x80}, /* LE */
20862 {0xf3, 0xaf, 0x80, 0x00}, /* BE */
20865 unsigned bytes, fix, noop_size;
20868 const char *narrow_noop = NULL;
20873 if (fragP->fr_type != rs_align_code)
20876 bytes = fragP->fr_next->fr_address - fragP->fr_address - fragP->fr_fix;
20877 p = fragP->fr_literal + fragP->fr_fix;
20880 if (bytes > MAX_MEM_FOR_RS_ALIGN_CODE)
20881 bytes &= MAX_MEM_FOR_RS_ALIGN_CODE;
20883 gas_assert ((fragP->tc_frag_data.thumb_mode & MODE_RECORDED) != 0);
20885 if (fragP->tc_frag_data.thumb_mode & (~ MODE_RECORDED))
20887 if (ARM_CPU_HAS_FEATURE (selected_cpu_name[0]
20888 ? selected_cpu : arm_arch_none, arm_ext_v6t2))
20890 narrow_noop = thumb_noop[1][target_big_endian];
20891 noop = wide_thumb_noop[target_big_endian];
20894 noop = thumb_noop[0][target_big_endian];
20902 noop = arm_noop[ARM_CPU_HAS_FEATURE (selected_cpu_name[0]
20903 ? selected_cpu : arm_arch_none,
20905 [target_big_endian];
20912 fragP->fr_var = noop_size;
20914 if (bytes & (noop_size - 1))
20916 fix = bytes & (noop_size - 1);
20918 insert_data_mapping_symbol (state, fragP->fr_fix, fragP, fix);
20920 memset (p, 0, fix);
20927 if (bytes & noop_size)
20929 /* Insert a narrow noop. */
20930 memcpy (p, narrow_noop, noop_size);
20932 bytes -= noop_size;
20936 /* Use wide noops for the remainder */
20940 while (bytes >= noop_size)
20942 memcpy (p, noop, noop_size);
20944 bytes -= noop_size;
20948 fragP->fr_fix += fix;
20951 /* Called from md_do_align. Used to create an alignment
20952 frag in a code section. */
20955 arm_frag_align_code (int n, int max)
20959 /* We assume that there will never be a requirement
20960 to support alignments greater than MAX_MEM_FOR_RS_ALIGN_CODE bytes. */
20961 if (max > MAX_MEM_FOR_RS_ALIGN_CODE)
20966 _("alignments greater than %d bytes not supported in .text sections."),
20967 MAX_MEM_FOR_RS_ALIGN_CODE + 1);
20968 as_fatal ("%s", err_msg);
20971 p = frag_var (rs_align_code,
20972 MAX_MEM_FOR_RS_ALIGN_CODE,
20974 (relax_substateT) max,
20981 /* Perform target specific initialisation of a frag.
20982 Note - despite the name this initialisation is not done when the frag
20983 is created, but only when its type is assigned. A frag can be created
20984 and used a long time before its type is set, so beware of assuming that
20985 this initialisationis performed first. */
20989 arm_init_frag (fragS * fragP, int max_chars ATTRIBUTE_UNUSED)
20991 /* Record whether this frag is in an ARM or a THUMB area. */
20992 fragP->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
20995 #else /* OBJ_ELF is defined. */
20997 arm_init_frag (fragS * fragP, int max_chars)
20999 /* If the current ARM vs THUMB mode has not already
21000 been recorded into this frag then do so now. */
21001 if ((fragP->tc_frag_data.thumb_mode & MODE_RECORDED) == 0)
21003 fragP->tc_frag_data.thumb_mode = thumb_mode | MODE_RECORDED;
21005 /* Record a mapping symbol for alignment frags. We will delete this
21006 later if the alignment ends up empty. */
21007 switch (fragP->fr_type)
21010 case rs_align_test:
21012 mapping_state_2 (MAP_DATA, max_chars);
21014 case rs_align_code:
21015 mapping_state_2 (thumb_mode ? MAP_THUMB : MAP_ARM, max_chars);
21023 /* When we change sections we need to issue a new mapping symbol. */
21026 arm_elf_change_section (void)
21028 /* Link an unlinked unwind index table section to the .text section. */
21029 if (elf_section_type (now_seg) == SHT_ARM_EXIDX
21030 && elf_linked_to_section (now_seg) == NULL)
21031 elf_linked_to_section (now_seg) = text_section;
21035 arm_elf_section_type (const char * str, size_t len)
21037 if (len == 5 && strncmp (str, "exidx", 5) == 0)
21038 return SHT_ARM_EXIDX;
21043 /* Code to deal with unwinding tables. */
21045 static void add_unwind_adjustsp (offsetT);
21047 /* Generate any deferred unwind frame offset. */
21050 flush_pending_unwind (void)
21054 offset = unwind.pending_offset;
21055 unwind.pending_offset = 0;
21057 add_unwind_adjustsp (offset);
21060 /* Add an opcode to this list for this function. Two-byte opcodes should
21061 be passed as op[0] << 8 | op[1]. The list of opcodes is built in reverse
21065 add_unwind_opcode (valueT op, int length)
21067 /* Add any deferred stack adjustment. */
21068 if (unwind.pending_offset)
21069 flush_pending_unwind ();
21071 unwind.sp_restored = 0;
21073 if (unwind.opcode_count + length > unwind.opcode_alloc)
21075 unwind.opcode_alloc += ARM_OPCODE_CHUNK_SIZE;
21076 if (unwind.opcodes)
21077 unwind.opcodes = (unsigned char *) xrealloc (unwind.opcodes,
21078 unwind.opcode_alloc);
21080 unwind.opcodes = (unsigned char *) xmalloc (unwind.opcode_alloc);
21085 unwind.opcodes[unwind.opcode_count] = op & 0xff;
21087 unwind.opcode_count++;
21091 /* Add unwind opcodes to adjust the stack pointer. */
21094 add_unwind_adjustsp (offsetT offset)
21098 if (offset > 0x200)
21100 /* We need at most 5 bytes to hold a 32-bit value in a uleb128. */
21105 /* Long form: 0xb2, uleb128. */
21106 /* This might not fit in a word so add the individual bytes,
21107 remembering the list is built in reverse order. */
21108 o = (valueT) ((offset - 0x204) >> 2);
21110 add_unwind_opcode (0, 1);
21112 /* Calculate the uleb128 encoding of the offset. */
21116 bytes[n] = o & 0x7f;
21122 /* Add the insn. */
21124 add_unwind_opcode (bytes[n - 1], 1);
21125 add_unwind_opcode (0xb2, 1);
21127 else if (offset > 0x100)
21129 /* Two short opcodes. */
21130 add_unwind_opcode (0x3f, 1);
21131 op = (offset - 0x104) >> 2;
21132 add_unwind_opcode (op, 1);
21134 else if (offset > 0)
21136 /* Short opcode. */
21137 op = (offset - 4) >> 2;
21138 add_unwind_opcode (op, 1);
21140 else if (offset < 0)
21143 while (offset > 0x100)
21145 add_unwind_opcode (0x7f, 1);
21148 op = ((offset - 4) >> 2) | 0x40;
21149 add_unwind_opcode (op, 1);
21153 /* Finish the list of unwind opcodes for this function. */
21155 finish_unwind_opcodes (void)
21159 if (unwind.fp_used)
21161 /* Adjust sp as necessary. */
21162 unwind.pending_offset += unwind.fp_offset - unwind.frame_size;
21163 flush_pending_unwind ();
21165 /* After restoring sp from the frame pointer. */
21166 op = 0x90 | unwind.fp_reg;
21167 add_unwind_opcode (op, 1);
21170 flush_pending_unwind ();
21174 /* Start an exception table entry. If idx is nonzero this is an index table
21178 start_unwind_section (const segT text_seg, int idx)
21180 const char * text_name;
21181 const char * prefix;
21182 const char * prefix_once;
21183 const char * group_name;
21187 size_t sec_name_len;
21194 prefix = ELF_STRING_ARM_unwind;
21195 prefix_once = ELF_STRING_ARM_unwind_once;
21196 type = SHT_ARM_EXIDX;
21200 prefix = ELF_STRING_ARM_unwind_info;
21201 prefix_once = ELF_STRING_ARM_unwind_info_once;
21202 type = SHT_PROGBITS;
21205 text_name = segment_name (text_seg);
21206 if (streq (text_name, ".text"))
21209 if (strncmp (text_name, ".gnu.linkonce.t.",
21210 strlen (".gnu.linkonce.t.")) == 0)
21212 prefix = prefix_once;
21213 text_name += strlen (".gnu.linkonce.t.");
21216 prefix_len = strlen (prefix);
21217 text_len = strlen (text_name);
21218 sec_name_len = prefix_len + text_len;
21219 sec_name = (char *) xmalloc (sec_name_len + 1);
21220 memcpy (sec_name, prefix, prefix_len);
21221 memcpy (sec_name + prefix_len, text_name, text_len);
21222 sec_name[prefix_len + text_len] = '\0';
21228 /* Handle COMDAT group. */
21229 if (prefix != prefix_once && (text_seg->flags & SEC_LINK_ONCE) != 0)
21231 group_name = elf_group_name (text_seg);
21232 if (group_name == NULL)
21234 as_bad (_("Group section `%s' has no group signature"),
21235 segment_name (text_seg));
21236 ignore_rest_of_line ();
21239 flags |= SHF_GROUP;
21243 obj_elf_change_section (sec_name, type, flags, 0, group_name, linkonce, 0);
21245 /* Set the section link for index tables. */
21247 elf_linked_to_section (now_seg) = text_seg;
21251 /* Start an unwind table entry. HAVE_DATA is nonzero if we have additional
21252 personality routine data. Returns zero, or the index table value for
21253 an inline entry. */
21256 create_unwind_entry (int have_data)
21261 /* The current word of data. */
21263 /* The number of bytes left in this word. */
21266 finish_unwind_opcodes ();
21268 /* Remember the current text section. */
21269 unwind.saved_seg = now_seg;
21270 unwind.saved_subseg = now_subseg;
21272 start_unwind_section (now_seg, 0);
21274 if (unwind.personality_routine == NULL)
21276 if (unwind.personality_index == -2)
21279 as_bad (_("handlerdata in cantunwind frame"));
21280 return 1; /* EXIDX_CANTUNWIND. */
21283 /* Use a default personality routine if none is specified. */
21284 if (unwind.personality_index == -1)
21286 if (unwind.opcode_count > 3)
21287 unwind.personality_index = 1;
21289 unwind.personality_index = 0;
21292 /* Space for the personality routine entry. */
21293 if (unwind.personality_index == 0)
21295 if (unwind.opcode_count > 3)
21296 as_bad (_("too many unwind opcodes for personality routine 0"));
21300 /* All the data is inline in the index table. */
21303 while (unwind.opcode_count > 0)
21305 unwind.opcode_count--;
21306 data = (data << 8) | unwind.opcodes[unwind.opcode_count];
21310 /* Pad with "finish" opcodes. */
21312 data = (data << 8) | 0xb0;
21319 /* We get two opcodes "free" in the first word. */
21320 size = unwind.opcode_count - 2;
21324 /* PR 16765: Missing or misplaced unwind directives can trigger this. */
21325 if (unwind.personality_index != -1)
21327 as_bad (_("attempt to recreate an unwind entry"));
21331 /* An extra byte is required for the opcode count. */
21332 size = unwind.opcode_count + 1;
21335 size = (size + 3) >> 2;
21337 as_bad (_("too many unwind opcodes"));
21339 frag_align (2, 0, 0);
21340 record_alignment (now_seg, 2);
21341 unwind.table_entry = expr_build_dot ();
21343 /* Allocate the table entry. */
21344 ptr = frag_more ((size << 2) + 4);
21345 /* PR 13449: Zero the table entries in case some of them are not used. */
21346 memset (ptr, 0, (size << 2) + 4);
21347 where = frag_now_fix () - ((size << 2) + 4);
21349 switch (unwind.personality_index)
21352 /* ??? Should this be a PLT generating relocation? */
21353 /* Custom personality routine. */
21354 fix_new (frag_now, where, 4, unwind.personality_routine, 0, 1,
21355 BFD_RELOC_ARM_PREL31);
21360 /* Set the first byte to the number of additional words. */
21361 data = size > 0 ? size - 1 : 0;
21365 /* ABI defined personality routines. */
21367 /* Three opcodes bytes are packed into the first word. */
21374 /* The size and first two opcode bytes go in the first word. */
21375 data = ((0x80 + unwind.personality_index) << 8) | size;
21380 /* Should never happen. */
21384 /* Pack the opcodes into words (MSB first), reversing the list at the same
21386 while (unwind.opcode_count > 0)
21390 md_number_to_chars (ptr, data, 4);
21395 unwind.opcode_count--;
21397 data = (data << 8) | unwind.opcodes[unwind.opcode_count];
21400 /* Finish off the last word. */
21403 /* Pad with "finish" opcodes. */
21405 data = (data << 8) | 0xb0;
21407 md_number_to_chars (ptr, data, 4);
21412 /* Add an empty descriptor if there is no user-specified data. */
21413 ptr = frag_more (4);
21414 md_number_to_chars (ptr, 0, 4);
21421 /* Initialize the DWARF-2 unwind information for this procedure. */
21424 tc_arm_frame_initial_instructions (void)
21426 cfi_add_CFA_def_cfa (REG_SP, 0);
21428 #endif /* OBJ_ELF */
21430 /* Convert REGNAME to a DWARF-2 register number. */
21433 tc_arm_regname_to_dw2regnum (char *regname)
21435 int reg = arm_reg_parse (®name, REG_TYPE_RN);
21439 /* PR 16694: Allow VFP registers as well. */
21440 reg = arm_reg_parse (®name, REG_TYPE_VFS);
21444 reg = arm_reg_parse (®name, REG_TYPE_VFD);
21453 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
21457 exp.X_op = O_secrel;
21458 exp.X_add_symbol = symbol;
21459 exp.X_add_number = 0;
21460 emit_expr (&exp, size);
21464 /* MD interface: Symbol and relocation handling. */
21466 /* Return the address within the segment that a PC-relative fixup is
21467 relative to. For ARM, PC-relative fixups applied to instructions
21468 are generally relative to the location of the fixup plus 8 bytes.
21469 Thumb branches are offset by 4, and Thumb loads relative to PC
21470 require special handling. */
21473 md_pcrel_from_section (fixS * fixP, segT seg)
21475 offsetT base = fixP->fx_where + fixP->fx_frag->fr_address;
21477 /* If this is pc-relative and we are going to emit a relocation
21478 then we just want to put out any pipeline compensation that the linker
21479 will need. Otherwise we want to use the calculated base.
21480 For WinCE we skip the bias for externals as well, since this
21481 is how the MS ARM-CE assembler behaves and we want to be compatible. */
21483 && ((fixP->fx_addsy && S_GET_SEGMENT (fixP->fx_addsy) != seg)
21484 || (arm_force_relocation (fixP)
21486 && !S_IS_EXTERNAL (fixP->fx_addsy)
21492 switch (fixP->fx_r_type)
21494 /* PC relative addressing on the Thumb is slightly odd as the
21495 bottom two bits of the PC are forced to zero for the
21496 calculation. This happens *after* application of the
21497 pipeline offset. However, Thumb adrl already adjusts for
21498 this, so we need not do it again. */
21499 case BFD_RELOC_ARM_THUMB_ADD:
21502 case BFD_RELOC_ARM_THUMB_OFFSET:
21503 case BFD_RELOC_ARM_T32_OFFSET_IMM:
21504 case BFD_RELOC_ARM_T32_ADD_PC12:
21505 case BFD_RELOC_ARM_T32_CP_OFF_IMM:
21506 return (base + 4) & ~3;
21508 /* Thumb branches are simply offset by +4. */
21509 case BFD_RELOC_THUMB_PCREL_BRANCH7:
21510 case BFD_RELOC_THUMB_PCREL_BRANCH9:
21511 case BFD_RELOC_THUMB_PCREL_BRANCH12:
21512 case BFD_RELOC_THUMB_PCREL_BRANCH20:
21513 case BFD_RELOC_THUMB_PCREL_BRANCH25:
21516 case BFD_RELOC_THUMB_PCREL_BRANCH23:
21518 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21519 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21520 && ARM_IS_FUNC (fixP->fx_addsy)
21521 && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
21522 base = fixP->fx_where + fixP->fx_frag->fr_address;
21525 /* BLX is like branches above, but forces the low two bits of PC to
21527 case BFD_RELOC_THUMB_PCREL_BLX:
21529 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21530 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21531 && THUMB_IS_FUNC (fixP->fx_addsy)
21532 && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
21533 base = fixP->fx_where + fixP->fx_frag->fr_address;
21534 return (base + 4) & ~3;
21536 /* ARM mode branches are offset by +8. However, the Windows CE
21537 loader expects the relocation not to take this into account. */
21538 case BFD_RELOC_ARM_PCREL_BLX:
21540 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21541 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21542 && ARM_IS_FUNC (fixP->fx_addsy)
21543 && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
21544 base = fixP->fx_where + fixP->fx_frag->fr_address;
21547 case BFD_RELOC_ARM_PCREL_CALL:
21549 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21550 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
21551 && THUMB_IS_FUNC (fixP->fx_addsy)
21552 && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
21553 base = fixP->fx_where + fixP->fx_frag->fr_address;
21556 case BFD_RELOC_ARM_PCREL_BRANCH:
21557 case BFD_RELOC_ARM_PCREL_JUMP:
21558 case BFD_RELOC_ARM_PLT32:
21560 /* When handling fixups immediately, because we have already
21561 discovered the value of a symbol, or the address of the frag involved
21562 we must account for the offset by +8, as the OS loader will never see the reloc.
21563 see fixup_segment() in write.c
21564 The S_IS_EXTERNAL test handles the case of global symbols.
21565 Those need the calculated base, not just the pipe compensation the linker will need. */
21567 && fixP->fx_addsy != NULL
21568 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
21569 && (S_IS_EXTERNAL (fixP->fx_addsy) || !arm_force_relocation (fixP)))
21577 /* ARM mode loads relative to PC are also offset by +8. Unlike
21578 branches, the Windows CE loader *does* expect the relocation
21579 to take this into account. */
21580 case BFD_RELOC_ARM_OFFSET_IMM:
21581 case BFD_RELOC_ARM_OFFSET_IMM8:
21582 case BFD_RELOC_ARM_HWLITERAL:
21583 case BFD_RELOC_ARM_LITERAL:
21584 case BFD_RELOC_ARM_CP_OFF_IMM:
21588 /* Other PC-relative relocations are un-offset. */
21594 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
21595 Otherwise we have no need to default values of symbols. */
21598 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
21601 if (name[0] == '_' && name[1] == 'G'
21602 && streq (name, GLOBAL_OFFSET_TABLE_NAME))
21606 if (symbol_find (name))
21607 as_bad (_("GOT already in the symbol table"));
21609 GOT_symbol = symbol_new (name, undefined_section,
21610 (valueT) 0, & zero_address_frag);
21620 /* Subroutine of md_apply_fix. Check to see if an immediate can be
21621 computed as two separate immediate values, added together. We
21622 already know that this value cannot be computed by just one ARM
21625 static unsigned int
21626 validate_immediate_twopart (unsigned int val,
21627 unsigned int * highpart)
21632 for (i = 0; i < 32; i += 2)
21633 if (((a = rotate_left (val, i)) & 0xff) != 0)
21639 * highpart = (a >> 8) | ((i + 24) << 7);
21641 else if (a & 0xff0000)
21643 if (a & 0xff000000)
21645 * highpart = (a >> 16) | ((i + 16) << 7);
21649 gas_assert (a & 0xff000000);
21650 * highpart = (a >> 24) | ((i + 8) << 7);
21653 return (a & 0xff) | (i << 7);
21660 validate_offset_imm (unsigned int val, int hwse)
21662 if ((hwse && val > 255) || val > 4095)
21667 /* Subroutine of md_apply_fix. Do those data_ops which can take a
21668 negative immediate constant by altering the instruction. A bit of
21673 by inverting the second operand, and
21676 by negating the second operand. */
21679 negate_data_op (unsigned long * instruction,
21680 unsigned long value)
21683 unsigned long negated, inverted;
21685 negated = encode_arm_immediate (-value);
21686 inverted = encode_arm_immediate (~value);
21688 op = (*instruction >> DATA_OP_SHIFT) & 0xf;
21691 /* First negates. */
21692 case OPCODE_SUB: /* ADD <-> SUB */
21693 new_inst = OPCODE_ADD;
21698 new_inst = OPCODE_SUB;
21702 case OPCODE_CMP: /* CMP <-> CMN */
21703 new_inst = OPCODE_CMN;
21708 new_inst = OPCODE_CMP;
21712 /* Now Inverted ops. */
21713 case OPCODE_MOV: /* MOV <-> MVN */
21714 new_inst = OPCODE_MVN;
21719 new_inst = OPCODE_MOV;
21723 case OPCODE_AND: /* AND <-> BIC */
21724 new_inst = OPCODE_BIC;
21729 new_inst = OPCODE_AND;
21733 case OPCODE_ADC: /* ADC <-> SBC */
21734 new_inst = OPCODE_SBC;
21739 new_inst = OPCODE_ADC;
21743 /* We cannot do anything. */
21748 if (value == (unsigned) FAIL)
21751 *instruction &= OPCODE_MASK;
21752 *instruction |= new_inst << DATA_OP_SHIFT;
21756 /* Like negate_data_op, but for Thumb-2. */
21758 static unsigned int
21759 thumb32_negate_data_op (offsetT *instruction, unsigned int value)
21763 unsigned int negated, inverted;
21765 negated = encode_thumb32_immediate (-value);
21766 inverted = encode_thumb32_immediate (~value);
21768 rd = (*instruction >> 8) & 0xf;
21769 op = (*instruction >> T2_DATA_OP_SHIFT) & 0xf;
21772 /* ADD <-> SUB. Includes CMP <-> CMN. */
21773 case T2_OPCODE_SUB:
21774 new_inst = T2_OPCODE_ADD;
21778 case T2_OPCODE_ADD:
21779 new_inst = T2_OPCODE_SUB;
21783 /* ORR <-> ORN. Includes MOV <-> MVN. */
21784 case T2_OPCODE_ORR:
21785 new_inst = T2_OPCODE_ORN;
21789 case T2_OPCODE_ORN:
21790 new_inst = T2_OPCODE_ORR;
21794 /* AND <-> BIC. TST has no inverted equivalent. */
21795 case T2_OPCODE_AND:
21796 new_inst = T2_OPCODE_BIC;
21803 case T2_OPCODE_BIC:
21804 new_inst = T2_OPCODE_AND;
21809 case T2_OPCODE_ADC:
21810 new_inst = T2_OPCODE_SBC;
21814 case T2_OPCODE_SBC:
21815 new_inst = T2_OPCODE_ADC;
21819 /* We cannot do anything. */
21824 if (value == (unsigned int)FAIL)
21827 *instruction &= T2_OPCODE_MASK;
21828 *instruction |= new_inst << T2_DATA_OP_SHIFT;
21832 /* Read a 32-bit thumb instruction from buf. */
21833 static unsigned long
21834 get_thumb32_insn (char * buf)
21836 unsigned long insn;
21837 insn = md_chars_to_number (buf, THUMB_SIZE) << 16;
21838 insn |= md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
21844 /* We usually want to set the low bit on the address of thumb function
21845 symbols. In particular .word foo - . should have the low bit set.
21846 Generic code tries to fold the difference of two symbols to
21847 a constant. Prevent this and force a relocation when the first symbols
21848 is a thumb function. */
21851 arm_optimize_expr (expressionS *l, operatorT op, expressionS *r)
21853 if (op == O_subtract
21854 && l->X_op == O_symbol
21855 && r->X_op == O_symbol
21856 && THUMB_IS_FUNC (l->X_add_symbol))
21858 l->X_op = O_subtract;
21859 l->X_op_symbol = r->X_add_symbol;
21860 l->X_add_number -= r->X_add_number;
21864 /* Process as normal. */
21868 /* Encode Thumb2 unconditional branches and calls. The encoding
21869 for the 2 are identical for the immediate values. */
21872 encode_thumb2_b_bl_offset (char * buf, offsetT value)
21874 #define T2I1I2MASK ((1 << 13) | (1 << 11))
21877 addressT S, I1, I2, lo, hi;
21879 S = (value >> 24) & 0x01;
21880 I1 = (value >> 23) & 0x01;
21881 I2 = (value >> 22) & 0x01;
21882 hi = (value >> 12) & 0x3ff;
21883 lo = (value >> 1) & 0x7ff;
21884 newval = md_chars_to_number (buf, THUMB_SIZE);
21885 newval2 = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
21886 newval |= (S << 10) | hi;
21887 newval2 &= ~T2I1I2MASK;
21888 newval2 |= (((I1 ^ S) << 13) | ((I2 ^ S) << 11) | lo) ^ T2I1I2MASK;
21889 md_number_to_chars (buf, newval, THUMB_SIZE);
21890 md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
21894 md_apply_fix (fixS * fixP,
21898 offsetT value = * valP;
21900 unsigned int newimm;
21901 unsigned long temp;
21903 char * buf = fixP->fx_where + fixP->fx_frag->fr_literal;
21905 gas_assert (fixP->fx_r_type <= BFD_RELOC_UNUSED);
21907 /* Note whether this will delete the relocation. */
21909 if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
21912 /* On a 64-bit host, silently truncate 'value' to 32 bits for
21913 consistency with the behaviour on 32-bit hosts. Remember value
21915 value &= 0xffffffff;
21916 value ^= 0x80000000;
21917 value -= 0x80000000;
21920 fixP->fx_addnumber = value;
21922 /* Same treatment for fixP->fx_offset. */
21923 fixP->fx_offset &= 0xffffffff;
21924 fixP->fx_offset ^= 0x80000000;
21925 fixP->fx_offset -= 0x80000000;
21927 switch (fixP->fx_r_type)
21929 case BFD_RELOC_NONE:
21930 /* This will need to go in the object file. */
21934 case BFD_RELOC_ARM_IMMEDIATE:
21935 /* We claim that this fixup has been processed here,
21936 even if in fact we generate an error because we do
21937 not have a reloc for it, so tc_gen_reloc will reject it. */
21940 if (fixP->fx_addsy)
21942 const char *msg = 0;
21944 if (! S_IS_DEFINED (fixP->fx_addsy))
21945 msg = _("undefined symbol %s used as an immediate value");
21946 else if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
21947 msg = _("symbol %s is in a different section");
21948 else if (S_IS_WEAK (fixP->fx_addsy))
21949 msg = _("symbol %s is weak and may be overridden later");
21953 as_bad_where (fixP->fx_file, fixP->fx_line,
21954 msg, S_GET_NAME (fixP->fx_addsy));
21959 temp = md_chars_to_number (buf, INSN_SIZE);
21961 /* If the offset is negative, we should use encoding A2 for ADR. */
21962 if ((temp & 0xfff0000) == 0x28f0000 && value < 0)
21963 newimm = negate_data_op (&temp, value);
21966 newimm = encode_arm_immediate (value);
21968 /* If the instruction will fail, see if we can fix things up by
21969 changing the opcode. */
21970 if (newimm == (unsigned int) FAIL)
21971 newimm = negate_data_op (&temp, value);
21974 if (newimm == (unsigned int) FAIL)
21976 as_bad_where (fixP->fx_file, fixP->fx_line,
21977 _("invalid constant (%lx) after fixup"),
21978 (unsigned long) value);
21982 newimm |= (temp & 0xfffff000);
21983 md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
21986 case BFD_RELOC_ARM_ADRL_IMMEDIATE:
21988 unsigned int highpart = 0;
21989 unsigned int newinsn = 0xe1a00000; /* nop. */
21991 if (fixP->fx_addsy)
21993 const char *msg = 0;
21995 if (! S_IS_DEFINED (fixP->fx_addsy))
21996 msg = _("undefined symbol %s used as an immediate value");
21997 else if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
21998 msg = _("symbol %s is in a different section");
21999 else if (S_IS_WEAK (fixP->fx_addsy))
22000 msg = _("symbol %s is weak and may be overridden later");
22004 as_bad_where (fixP->fx_file, fixP->fx_line,
22005 msg, S_GET_NAME (fixP->fx_addsy));
22010 newimm = encode_arm_immediate (value);
22011 temp = md_chars_to_number (buf, INSN_SIZE);
22013 /* If the instruction will fail, see if we can fix things up by
22014 changing the opcode. */
22015 if (newimm == (unsigned int) FAIL
22016 && (newimm = negate_data_op (& temp, value)) == (unsigned int) FAIL)
22018 /* No ? OK - try using two ADD instructions to generate
22020 newimm = validate_immediate_twopart (value, & highpart);
22022 /* Yes - then make sure that the second instruction is
22024 if (newimm != (unsigned int) FAIL)
22026 /* Still No ? Try using a negated value. */
22027 else if ((newimm = validate_immediate_twopart (- value, & highpart)) != (unsigned int) FAIL)
22028 temp = newinsn = (temp & OPCODE_MASK) | OPCODE_SUB << DATA_OP_SHIFT;
22029 /* Otherwise - give up. */
22032 as_bad_where (fixP->fx_file, fixP->fx_line,
22033 _("unable to compute ADRL instructions for PC offset of 0x%lx"),
22038 /* Replace the first operand in the 2nd instruction (which
22039 is the PC) with the destination register. We have
22040 already added in the PC in the first instruction and we
22041 do not want to do it again. */
22042 newinsn &= ~ 0xf0000;
22043 newinsn |= ((newinsn & 0x0f000) << 4);
22046 newimm |= (temp & 0xfffff000);
22047 md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
22049 highpart |= (newinsn & 0xfffff000);
22050 md_number_to_chars (buf + INSN_SIZE, (valueT) highpart, INSN_SIZE);
22054 case BFD_RELOC_ARM_OFFSET_IMM:
22055 if (!fixP->fx_done && seg->use_rela_p)
22058 case BFD_RELOC_ARM_LITERAL:
22064 if (validate_offset_imm (value, 0) == FAIL)
22066 if (fixP->fx_r_type == BFD_RELOC_ARM_LITERAL)
22067 as_bad_where (fixP->fx_file, fixP->fx_line,
22068 _("invalid literal constant: pool needs to be closer"));
22070 as_bad_where (fixP->fx_file, fixP->fx_line,
22071 _("bad immediate value for offset (%ld)"),
22076 newval = md_chars_to_number (buf, INSN_SIZE);
22078 newval &= 0xfffff000;
22081 newval &= 0xff7ff000;
22082 newval |= value | (sign ? INDEX_UP : 0);
22084 md_number_to_chars (buf, newval, INSN_SIZE);
22087 case BFD_RELOC_ARM_OFFSET_IMM8:
22088 case BFD_RELOC_ARM_HWLITERAL:
22094 if (validate_offset_imm (value, 1) == FAIL)
22096 if (fixP->fx_r_type == BFD_RELOC_ARM_HWLITERAL)
22097 as_bad_where (fixP->fx_file, fixP->fx_line,
22098 _("invalid literal constant: pool needs to be closer"));
22100 as_bad_where (fixP->fx_file, fixP->fx_line,
22101 _("bad immediate value for 8-bit offset (%ld)"),
22106 newval = md_chars_to_number (buf, INSN_SIZE);
22108 newval &= 0xfffff0f0;
22111 newval &= 0xff7ff0f0;
22112 newval |= ((value >> 4) << 8) | (value & 0xf) | (sign ? INDEX_UP : 0);
22114 md_number_to_chars (buf, newval, INSN_SIZE);
22117 case BFD_RELOC_ARM_T32_OFFSET_U8:
22118 if (value < 0 || value > 1020 || value % 4 != 0)
22119 as_bad_where (fixP->fx_file, fixP->fx_line,
22120 _("bad immediate value for offset (%ld)"), (long) value);
22123 newval = md_chars_to_number (buf+2, THUMB_SIZE);
22125 md_number_to_chars (buf+2, newval, THUMB_SIZE);
22128 case BFD_RELOC_ARM_T32_OFFSET_IMM:
22129 /* This is a complicated relocation used for all varieties of Thumb32
22130 load/store instruction with immediate offset:
22132 1110 100P u1WL NNNN XXXX YYYY iiii iiii - +/-(U) pre/post(P) 8-bit,
22133 *4, optional writeback(W)
22134 (doubleword load/store)
22136 1111 100S uTTL 1111 XXXX iiii iiii iiii - +/-(U) 12-bit PC-rel
22137 1111 100S 0TTL NNNN XXXX 1Pu1 iiii iiii - +/-(U) pre/post(P) 8-bit
22138 1111 100S 0TTL NNNN XXXX 1110 iiii iiii - positive 8-bit (T instruction)
22139 1111 100S 1TTL NNNN XXXX iiii iiii iiii - positive 12-bit
22140 1111 100S 0TTL NNNN XXXX 1100 iiii iiii - negative 8-bit
22142 Uppercase letters indicate bits that are already encoded at
22143 this point. Lowercase letters are our problem. For the
22144 second block of instructions, the secondary opcode nybble
22145 (bits 8..11) is present, and bit 23 is zero, even if this is
22146 a PC-relative operation. */
22147 newval = md_chars_to_number (buf, THUMB_SIZE);
22149 newval |= md_chars_to_number (buf+THUMB_SIZE, THUMB_SIZE);
22151 if ((newval & 0xf0000000) == 0xe0000000)
22153 /* Doubleword load/store: 8-bit offset, scaled by 4. */
22155 newval |= (1 << 23);
22158 if (value % 4 != 0)
22160 as_bad_where (fixP->fx_file, fixP->fx_line,
22161 _("offset not a multiple of 4"));
22167 as_bad_where (fixP->fx_file, fixP->fx_line,
22168 _("offset out of range"));
22173 else if ((newval & 0x000f0000) == 0x000f0000)
22175 /* PC-relative, 12-bit offset. */
22177 newval |= (1 << 23);
22182 as_bad_where (fixP->fx_file, fixP->fx_line,
22183 _("offset out of range"));
22188 else if ((newval & 0x00000100) == 0x00000100)
22190 /* Writeback: 8-bit, +/- offset. */
22192 newval |= (1 << 9);
22197 as_bad_where (fixP->fx_file, fixP->fx_line,
22198 _("offset out of range"));
22203 else if ((newval & 0x00000f00) == 0x00000e00)
22205 /* T-instruction: positive 8-bit offset. */
22206 if (value < 0 || value > 0xff)
22208 as_bad_where (fixP->fx_file, fixP->fx_line,
22209 _("offset out of range"));
22217 /* Positive 12-bit or negative 8-bit offset. */
22221 newval |= (1 << 23);
22231 as_bad_where (fixP->fx_file, fixP->fx_line,
22232 _("offset out of range"));
22239 md_number_to_chars (buf, (newval >> 16) & 0xffff, THUMB_SIZE);
22240 md_number_to_chars (buf + THUMB_SIZE, newval & 0xffff, THUMB_SIZE);
22243 case BFD_RELOC_ARM_SHIFT_IMM:
22244 newval = md_chars_to_number (buf, INSN_SIZE);
22245 if (((unsigned long) value) > 32
22247 && (((newval & 0x60) == 0) || (newval & 0x60) == 0x60)))
22249 as_bad_where (fixP->fx_file, fixP->fx_line,
22250 _("shift expression is too large"));
22255 /* Shifts of zero must be done as lsl. */
22257 else if (value == 32)
22259 newval &= 0xfffff07f;
22260 newval |= (value & 0x1f) << 7;
22261 md_number_to_chars (buf, newval, INSN_SIZE);
22264 case BFD_RELOC_ARM_T32_IMMEDIATE:
22265 case BFD_RELOC_ARM_T32_ADD_IMM:
22266 case BFD_RELOC_ARM_T32_IMM12:
22267 case BFD_RELOC_ARM_T32_ADD_PC12:
22268 /* We claim that this fixup has been processed here,
22269 even if in fact we generate an error because we do
22270 not have a reloc for it, so tc_gen_reloc will reject it. */
22274 && ! S_IS_DEFINED (fixP->fx_addsy))
22276 as_bad_where (fixP->fx_file, fixP->fx_line,
22277 _("undefined symbol %s used as an immediate value"),
22278 S_GET_NAME (fixP->fx_addsy));
22282 newval = md_chars_to_number (buf, THUMB_SIZE);
22284 newval |= md_chars_to_number (buf+2, THUMB_SIZE);
22287 if (fixP->fx_r_type == BFD_RELOC_ARM_T32_IMMEDIATE
22288 || fixP->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM)
22290 newimm = encode_thumb32_immediate (value);
22291 if (newimm == (unsigned int) FAIL)
22292 newimm = thumb32_negate_data_op (&newval, value);
22294 if (fixP->fx_r_type != BFD_RELOC_ARM_T32_IMMEDIATE
22295 && newimm == (unsigned int) FAIL)
22297 /* Turn add/sum into addw/subw. */
22298 if (fixP->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM)
22299 newval = (newval & 0xfeffffff) | 0x02000000;
22300 /* No flat 12-bit imm encoding for addsw/subsw. */
22301 if ((newval & 0x00100000) == 0)
22303 /* 12 bit immediate for addw/subw. */
22307 newval ^= 0x00a00000;
22310 newimm = (unsigned int) FAIL;
22316 if (newimm == (unsigned int)FAIL)
22318 as_bad_where (fixP->fx_file, fixP->fx_line,
22319 _("invalid constant (%lx) after fixup"),
22320 (unsigned long) value);
22324 newval |= (newimm & 0x800) << 15;
22325 newval |= (newimm & 0x700) << 4;
22326 newval |= (newimm & 0x0ff);
22328 md_number_to_chars (buf, (valueT) ((newval >> 16) & 0xffff), THUMB_SIZE);
22329 md_number_to_chars (buf+2, (valueT) (newval & 0xffff), THUMB_SIZE);
22332 case BFD_RELOC_ARM_SMC:
22333 if (((unsigned long) value) > 0xffff)
22334 as_bad_where (fixP->fx_file, fixP->fx_line,
22335 _("invalid smc expression"));
22336 newval = md_chars_to_number (buf, INSN_SIZE);
22337 newval |= (value & 0xf) | ((value & 0xfff0) << 4);
22338 md_number_to_chars (buf, newval, INSN_SIZE);
22341 case BFD_RELOC_ARM_HVC:
22342 if (((unsigned long) value) > 0xffff)
22343 as_bad_where (fixP->fx_file, fixP->fx_line,
22344 _("invalid hvc expression"));
22345 newval = md_chars_to_number (buf, INSN_SIZE);
22346 newval |= (value & 0xf) | ((value & 0xfff0) << 4);
22347 md_number_to_chars (buf, newval, INSN_SIZE);
22350 case BFD_RELOC_ARM_SWI:
22351 if (fixP->tc_fix_data != 0)
22353 if (((unsigned long) value) > 0xff)
22354 as_bad_where (fixP->fx_file, fixP->fx_line,
22355 _("invalid swi expression"));
22356 newval = md_chars_to_number (buf, THUMB_SIZE);
22358 md_number_to_chars (buf, newval, THUMB_SIZE);
22362 if (((unsigned long) value) > 0x00ffffff)
22363 as_bad_where (fixP->fx_file, fixP->fx_line,
22364 _("invalid swi expression"));
22365 newval = md_chars_to_number (buf, INSN_SIZE);
22367 md_number_to_chars (buf, newval, INSN_SIZE);
22371 case BFD_RELOC_ARM_MULTI:
22372 if (((unsigned long) value) > 0xffff)
22373 as_bad_where (fixP->fx_file, fixP->fx_line,
22374 _("invalid expression in load/store multiple"));
22375 newval = value | md_chars_to_number (buf, INSN_SIZE);
22376 md_number_to_chars (buf, newval, INSN_SIZE);
22380 case BFD_RELOC_ARM_PCREL_CALL:
22382 if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
22384 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
22385 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22386 && THUMB_IS_FUNC (fixP->fx_addsy))
22387 /* Flip the bl to blx. This is a simple flip
22388 bit here because we generate PCREL_CALL for
22389 unconditional bls. */
22391 newval = md_chars_to_number (buf, INSN_SIZE);
22392 newval = newval | 0x10000000;
22393 md_number_to_chars (buf, newval, INSN_SIZE);
22399 goto arm_branch_common;
22401 case BFD_RELOC_ARM_PCREL_JUMP:
22402 if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
22404 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
22405 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22406 && THUMB_IS_FUNC (fixP->fx_addsy))
22408 /* This would map to a bl<cond>, b<cond>,
22409 b<always> to a Thumb function. We
22410 need to force a relocation for this particular
22412 newval = md_chars_to_number (buf, INSN_SIZE);
22416 case BFD_RELOC_ARM_PLT32:
22418 case BFD_RELOC_ARM_PCREL_BRANCH:
22420 goto arm_branch_common;
22422 case BFD_RELOC_ARM_PCREL_BLX:
22425 if (ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
22427 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
22428 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22429 && ARM_IS_FUNC (fixP->fx_addsy))
22431 /* Flip the blx to a bl and warn. */
22432 const char *name = S_GET_NAME (fixP->fx_addsy);
22433 newval = 0xeb000000;
22434 as_warn_where (fixP->fx_file, fixP->fx_line,
22435 _("blx to '%s' an ARM ISA state function changed to bl"),
22437 md_number_to_chars (buf, newval, INSN_SIZE);
22443 if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
22444 fixP->fx_r_type = BFD_RELOC_ARM_PCREL_CALL;
22448 /* We are going to store value (shifted right by two) in the
22449 instruction, in a 24 bit, signed field. Bits 26 through 32 either
22450 all clear or all set and bit 0 must be clear. For B/BL bit 1 must
22451 also be be clear. */
22453 as_bad_where (fixP->fx_file, fixP->fx_line,
22454 _("misaligned branch destination"));
22455 if ((value & (offsetT)0xfe000000) != (offsetT)0
22456 && (value & (offsetT)0xfe000000) != (offsetT)0xfe000000)
22457 as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
22459 if (fixP->fx_done || !seg->use_rela_p)
22461 newval = md_chars_to_number (buf, INSN_SIZE);
22462 newval |= (value >> 2) & 0x00ffffff;
22463 /* Set the H bit on BLX instructions. */
22467 newval |= 0x01000000;
22469 newval &= ~0x01000000;
22471 md_number_to_chars (buf, newval, INSN_SIZE);
22475 case BFD_RELOC_THUMB_PCREL_BRANCH7: /* CBZ */
22476 /* CBZ can only branch forward. */
22478 /* Attempts to use CBZ to branch to the next instruction
22479 (which, strictly speaking, are prohibited) will be turned into
22482 FIXME: It may be better to remove the instruction completely and
22483 perform relaxation. */
22486 newval = md_chars_to_number (buf, THUMB_SIZE);
22487 newval = 0xbf00; /* NOP encoding T1 */
22488 md_number_to_chars (buf, newval, THUMB_SIZE);
22493 as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
22495 if (fixP->fx_done || !seg->use_rela_p)
22497 newval = md_chars_to_number (buf, THUMB_SIZE);
22498 newval |= ((value & 0x3e) << 2) | ((value & 0x40) << 3);
22499 md_number_to_chars (buf, newval, THUMB_SIZE);
22504 case BFD_RELOC_THUMB_PCREL_BRANCH9: /* Conditional branch. */
22505 if ((value & ~0xff) && ((value & ~0xff) != ~0xff))
22506 as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
22508 if (fixP->fx_done || !seg->use_rela_p)
22510 newval = md_chars_to_number (buf, THUMB_SIZE);
22511 newval |= (value & 0x1ff) >> 1;
22512 md_number_to_chars (buf, newval, THUMB_SIZE);
22516 case BFD_RELOC_THUMB_PCREL_BRANCH12: /* Unconditional branch. */
22517 if ((value & ~0x7ff) && ((value & ~0x7ff) != ~0x7ff))
22518 as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
22520 if (fixP->fx_done || !seg->use_rela_p)
22522 newval = md_chars_to_number (buf, THUMB_SIZE);
22523 newval |= (value & 0xfff) >> 1;
22524 md_number_to_chars (buf, newval, THUMB_SIZE);
22528 case BFD_RELOC_THUMB_PCREL_BRANCH20:
22530 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22531 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
22532 && ARM_IS_FUNC (fixP->fx_addsy)
22533 && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
22535 /* Force a relocation for a branch 20 bits wide. */
22538 if ((value & ~0x1fffff) && ((value & ~0x0fffff) != ~0x0fffff))
22539 as_bad_where (fixP->fx_file, fixP->fx_line,
22540 _("conditional branch out of range"));
22542 if (fixP->fx_done || !seg->use_rela_p)
22545 addressT S, J1, J2, lo, hi;
22547 S = (value & 0x00100000) >> 20;
22548 J2 = (value & 0x00080000) >> 19;
22549 J1 = (value & 0x00040000) >> 18;
22550 hi = (value & 0x0003f000) >> 12;
22551 lo = (value & 0x00000ffe) >> 1;
22553 newval = md_chars_to_number (buf, THUMB_SIZE);
22554 newval2 = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
22555 newval |= (S << 10) | hi;
22556 newval2 |= (J1 << 13) | (J2 << 11) | lo;
22557 md_number_to_chars (buf, newval, THUMB_SIZE);
22558 md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
22562 case BFD_RELOC_THUMB_PCREL_BLX:
22563 /* If there is a blx from a thumb state function to
22564 another thumb function flip this to a bl and warn
22568 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
22569 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22570 && THUMB_IS_FUNC (fixP->fx_addsy))
22572 const char *name = S_GET_NAME (fixP->fx_addsy);
22573 as_warn_where (fixP->fx_file, fixP->fx_line,
22574 _("blx to Thumb func '%s' from Thumb ISA state changed to bl"),
22576 newval = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
22577 newval = newval | 0x1000;
22578 md_number_to_chars (buf+THUMB_SIZE, newval, THUMB_SIZE);
22579 fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BRANCH23;
22584 goto thumb_bl_common;
22586 case BFD_RELOC_THUMB_PCREL_BRANCH23:
22587 /* A bl from Thumb state ISA to an internal ARM state function
22588 is converted to a blx. */
22590 && (S_GET_SEGMENT (fixP->fx_addsy) == seg)
22591 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE)
22592 && ARM_IS_FUNC (fixP->fx_addsy)
22593 && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t))
22595 newval = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
22596 newval = newval & ~0x1000;
22597 md_number_to_chars (buf+THUMB_SIZE, newval, THUMB_SIZE);
22598 fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BLX;
22604 if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX)
22605 /* For a BLX instruction, make sure that the relocation is rounded up
22606 to a word boundary. This follows the semantics of the instruction
22607 which specifies that bit 1 of the target address will come from bit
22608 1 of the base address. */
22609 value = (value + 3) & ~ 3;
22612 if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4
22613 && fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX)
22614 fixP->fx_r_type = BFD_RELOC_THUMB_PCREL_BRANCH23;
22617 if ((value & ~0x3fffff) && ((value & ~0x3fffff) != ~0x3fffff))
22619 if (!(ARM_CPU_HAS_FEATURE (cpu_variant, arm_arch_t2)))
22620 as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
22621 else if ((value & ~0x1ffffff)
22622 && ((value & ~0x1ffffff) != ~0x1ffffff))
22623 as_bad_where (fixP->fx_file, fixP->fx_line,
22624 _("Thumb2 branch out of range"));
22627 if (fixP->fx_done || !seg->use_rela_p)
22628 encode_thumb2_b_bl_offset (buf, value);
22632 case BFD_RELOC_THUMB_PCREL_BRANCH25:
22633 if ((value & ~0x0ffffff) && ((value & ~0x0ffffff) != ~0x0ffffff))
22634 as_bad_where (fixP->fx_file, fixP->fx_line, BAD_RANGE);
22636 if (fixP->fx_done || !seg->use_rela_p)
22637 encode_thumb2_b_bl_offset (buf, value);
22642 if (fixP->fx_done || !seg->use_rela_p)
22647 if (fixP->fx_done || !seg->use_rela_p)
22648 md_number_to_chars (buf, value, 2);
22652 case BFD_RELOC_ARM_TLS_CALL:
22653 case BFD_RELOC_ARM_THM_TLS_CALL:
22654 case BFD_RELOC_ARM_TLS_DESCSEQ:
22655 case BFD_RELOC_ARM_THM_TLS_DESCSEQ:
22656 case BFD_RELOC_ARM_TLS_GOTDESC:
22657 case BFD_RELOC_ARM_TLS_GD32:
22658 case BFD_RELOC_ARM_TLS_LE32:
22659 case BFD_RELOC_ARM_TLS_IE32:
22660 case BFD_RELOC_ARM_TLS_LDM32:
22661 case BFD_RELOC_ARM_TLS_LDO32:
22662 S_SET_THREAD_LOCAL (fixP->fx_addsy);
22665 case BFD_RELOC_ARM_GOT32:
22666 case BFD_RELOC_ARM_GOTOFF:
22669 case BFD_RELOC_ARM_GOT_PREL:
22670 if (fixP->fx_done || !seg->use_rela_p)
22671 md_number_to_chars (buf, value, 4);
22674 case BFD_RELOC_ARM_TARGET2:
22675 /* TARGET2 is not partial-inplace, so we need to write the
22676 addend here for REL targets, because it won't be written out
22677 during reloc processing later. */
22678 if (fixP->fx_done || !seg->use_rela_p)
22679 md_number_to_chars (buf, fixP->fx_offset, 4);
22683 case BFD_RELOC_RVA:
22685 case BFD_RELOC_ARM_TARGET1:
22686 case BFD_RELOC_ARM_ROSEGREL32:
22687 case BFD_RELOC_ARM_SBREL32:
22688 case BFD_RELOC_32_PCREL:
22690 case BFD_RELOC_32_SECREL:
22692 if (fixP->fx_done || !seg->use_rela_p)
22694 /* For WinCE we only do this for pcrel fixups. */
22695 if (fixP->fx_done || fixP->fx_pcrel)
22697 md_number_to_chars (buf, value, 4);
22701 case BFD_RELOC_ARM_PREL31:
22702 if (fixP->fx_done || !seg->use_rela_p)
22704 newval = md_chars_to_number (buf, 4) & 0x80000000;
22705 if ((value ^ (value >> 1)) & 0x40000000)
22707 as_bad_where (fixP->fx_file, fixP->fx_line,
22708 _("rel31 relocation overflow"));
22710 newval |= value & 0x7fffffff;
22711 md_number_to_chars (buf, newval, 4);
22716 case BFD_RELOC_ARM_CP_OFF_IMM:
22717 case BFD_RELOC_ARM_T32_CP_OFF_IMM:
22718 if (value < -1023 || value > 1023 || (value & 3))
22719 as_bad_where (fixP->fx_file, fixP->fx_line,
22720 _("co-processor offset out of range"));
22725 if (fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
22726 || fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2)
22727 newval = md_chars_to_number (buf, INSN_SIZE);
22729 newval = get_thumb32_insn (buf);
22731 newval &= 0xffffff00;
22734 newval &= 0xff7fff00;
22735 newval |= (value >> 2) | (sign ? INDEX_UP : 0);
22737 if (fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
22738 || fixP->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2)
22739 md_number_to_chars (buf, newval, INSN_SIZE);
22741 put_thumb32_insn (buf, newval);
22744 case BFD_RELOC_ARM_CP_OFF_IMM_S2:
22745 case BFD_RELOC_ARM_T32_CP_OFF_IMM_S2:
22746 if (value < -255 || value > 255)
22747 as_bad_where (fixP->fx_file, fixP->fx_line,
22748 _("co-processor offset out of range"));
22750 goto cp_off_common;
22752 case BFD_RELOC_ARM_THUMB_OFFSET:
22753 newval = md_chars_to_number (buf, THUMB_SIZE);
22754 /* Exactly what ranges, and where the offset is inserted depends
22755 on the type of instruction, we can establish this from the
22757 switch (newval >> 12)
22759 case 4: /* PC load. */
22760 /* Thumb PC loads are somewhat odd, bit 1 of the PC is
22761 forced to zero for these loads; md_pcrel_from has already
22762 compensated for this. */
22764 as_bad_where (fixP->fx_file, fixP->fx_line,
22765 _("invalid offset, target not word aligned (0x%08lX)"),
22766 (((unsigned long) fixP->fx_frag->fr_address
22767 + (unsigned long) fixP->fx_where) & ~3)
22768 + (unsigned long) value);
22770 if (value & ~0x3fc)
22771 as_bad_where (fixP->fx_file, fixP->fx_line,
22772 _("invalid offset, value too big (0x%08lX)"),
22775 newval |= value >> 2;
22778 case 9: /* SP load/store. */
22779 if (value & ~0x3fc)
22780 as_bad_where (fixP->fx_file, fixP->fx_line,
22781 _("invalid offset, value too big (0x%08lX)"),
22783 newval |= value >> 2;
22786 case 6: /* Word load/store. */
22788 as_bad_where (fixP->fx_file, fixP->fx_line,
22789 _("invalid offset, value too big (0x%08lX)"),
22791 newval |= value << 4; /* 6 - 2. */
22794 case 7: /* Byte load/store. */
22796 as_bad_where (fixP->fx_file, fixP->fx_line,
22797 _("invalid offset, value too big (0x%08lX)"),
22799 newval |= value << 6;
22802 case 8: /* Halfword load/store. */
22804 as_bad_where (fixP->fx_file, fixP->fx_line,
22805 _("invalid offset, value too big (0x%08lX)"),
22807 newval |= value << 5; /* 6 - 1. */
22811 as_bad_where (fixP->fx_file, fixP->fx_line,
22812 "Unable to process relocation for thumb opcode: %lx",
22813 (unsigned long) newval);
22816 md_number_to_chars (buf, newval, THUMB_SIZE);
22819 case BFD_RELOC_ARM_THUMB_ADD:
22820 /* This is a complicated relocation, since we use it for all of
22821 the following immediate relocations:
22825 9bit ADD/SUB SP word-aligned
22826 10bit ADD PC/SP word-aligned
22828 The type of instruction being processed is encoded in the
22835 newval = md_chars_to_number (buf, THUMB_SIZE);
22837 int rd = (newval >> 4) & 0xf;
22838 int rs = newval & 0xf;
22839 int subtract = !!(newval & 0x8000);
22841 /* Check for HI regs, only very restricted cases allowed:
22842 Adjusting SP, and using PC or SP to get an address. */
22843 if ((rd > 7 && (rd != REG_SP || rs != REG_SP))
22844 || (rs > 7 && rs != REG_SP && rs != REG_PC))
22845 as_bad_where (fixP->fx_file, fixP->fx_line,
22846 _("invalid Hi register with immediate"));
22848 /* If value is negative, choose the opposite instruction. */
22852 subtract = !subtract;
22854 as_bad_where (fixP->fx_file, fixP->fx_line,
22855 _("immediate value out of range"));
22860 if (value & ~0x1fc)
22861 as_bad_where (fixP->fx_file, fixP->fx_line,
22862 _("invalid immediate for stack address calculation"));
22863 newval = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
22864 newval |= value >> 2;
22866 else if (rs == REG_PC || rs == REG_SP)
22868 if (subtract || value & ~0x3fc)
22869 as_bad_where (fixP->fx_file, fixP->fx_line,
22870 _("invalid immediate for address calculation (value = 0x%08lX)"),
22871 (unsigned long) value);
22872 newval = (rs == REG_PC ? T_OPCODE_ADD_PC : T_OPCODE_ADD_SP);
22874 newval |= value >> 2;
22879 as_bad_where (fixP->fx_file, fixP->fx_line,
22880 _("immediate value out of range"));
22881 newval = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
22882 newval |= (rd << 8) | value;
22887 as_bad_where (fixP->fx_file, fixP->fx_line,
22888 _("immediate value out of range"));
22889 newval = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
22890 newval |= rd | (rs << 3) | (value << 6);
22893 md_number_to_chars (buf, newval, THUMB_SIZE);
22896 case BFD_RELOC_ARM_THUMB_IMM:
22897 newval = md_chars_to_number (buf, THUMB_SIZE);
22898 if (value < 0 || value > 255)
22899 as_bad_where (fixP->fx_file, fixP->fx_line,
22900 _("invalid immediate: %ld is out of range"),
22903 md_number_to_chars (buf, newval, THUMB_SIZE);
22906 case BFD_RELOC_ARM_THUMB_SHIFT:
22907 /* 5bit shift value (0..32). LSL cannot take 32. */
22908 newval = md_chars_to_number (buf, THUMB_SIZE) & 0xf83f;
22909 temp = newval & 0xf800;
22910 if (value < 0 || value > 32 || (value == 32 && temp == T_OPCODE_LSL_I))
22911 as_bad_where (fixP->fx_file, fixP->fx_line,
22912 _("invalid shift value: %ld"), (long) value);
22913 /* Shifts of zero must be encoded as LSL. */
22915 newval = (newval & 0x003f) | T_OPCODE_LSL_I;
22916 /* Shifts of 32 are encoded as zero. */
22917 else if (value == 32)
22919 newval |= value << 6;
22920 md_number_to_chars (buf, newval, THUMB_SIZE);
22923 case BFD_RELOC_VTABLE_INHERIT:
22924 case BFD_RELOC_VTABLE_ENTRY:
22928 case BFD_RELOC_ARM_MOVW:
22929 case BFD_RELOC_ARM_MOVT:
22930 case BFD_RELOC_ARM_THUMB_MOVW:
22931 case BFD_RELOC_ARM_THUMB_MOVT:
22932 if (fixP->fx_done || !seg->use_rela_p)
22934 /* REL format relocations are limited to a 16-bit addend. */
22935 if (!fixP->fx_done)
22937 if (value < -0x8000 || value > 0x7fff)
22938 as_bad_where (fixP->fx_file, fixP->fx_line,
22939 _("offset out of range"));
22941 else if (fixP->fx_r_type == BFD_RELOC_ARM_MOVT
22942 || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT)
22947 if (fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW
22948 || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT)
22950 newval = get_thumb32_insn (buf);
22951 newval &= 0xfbf08f00;
22952 newval |= (value & 0xf000) << 4;
22953 newval |= (value & 0x0800) << 15;
22954 newval |= (value & 0x0700) << 4;
22955 newval |= (value & 0x00ff);
22956 put_thumb32_insn (buf, newval);
22960 newval = md_chars_to_number (buf, 4);
22961 newval &= 0xfff0f000;
22962 newval |= value & 0x0fff;
22963 newval |= (value & 0xf000) << 4;
22964 md_number_to_chars (buf, newval, 4);
22969 case BFD_RELOC_ARM_ALU_PC_G0_NC:
22970 case BFD_RELOC_ARM_ALU_PC_G0:
22971 case BFD_RELOC_ARM_ALU_PC_G1_NC:
22972 case BFD_RELOC_ARM_ALU_PC_G1:
22973 case BFD_RELOC_ARM_ALU_PC_G2:
22974 case BFD_RELOC_ARM_ALU_SB_G0_NC:
22975 case BFD_RELOC_ARM_ALU_SB_G0:
22976 case BFD_RELOC_ARM_ALU_SB_G1_NC:
22977 case BFD_RELOC_ARM_ALU_SB_G1:
22978 case BFD_RELOC_ARM_ALU_SB_G2:
22979 gas_assert (!fixP->fx_done);
22980 if (!seg->use_rela_p)
22983 bfd_vma encoded_addend;
22984 bfd_vma addend_abs = abs (value);
22986 /* Check that the absolute value of the addend can be
22987 expressed as an 8-bit constant plus a rotation. */
22988 encoded_addend = encode_arm_immediate (addend_abs);
22989 if (encoded_addend == (unsigned int) FAIL)
22990 as_bad_where (fixP->fx_file, fixP->fx_line,
22991 _("the offset 0x%08lX is not representable"),
22992 (unsigned long) addend_abs);
22994 /* Extract the instruction. */
22995 insn = md_chars_to_number (buf, INSN_SIZE);
22997 /* If the addend is positive, use an ADD instruction.
22998 Otherwise use a SUB. Take care not to destroy the S bit. */
22999 insn &= 0xff1fffff;
23005 /* Place the encoded addend into the first 12 bits of the
23007 insn &= 0xfffff000;
23008 insn |= encoded_addend;
23010 /* Update the instruction. */
23011 md_number_to_chars (buf, insn, INSN_SIZE);
23015 case BFD_RELOC_ARM_LDR_PC_G0:
23016 case BFD_RELOC_ARM_LDR_PC_G1:
23017 case BFD_RELOC_ARM_LDR_PC_G2:
23018 case BFD_RELOC_ARM_LDR_SB_G0:
23019 case BFD_RELOC_ARM_LDR_SB_G1:
23020 case BFD_RELOC_ARM_LDR_SB_G2:
23021 gas_assert (!fixP->fx_done);
23022 if (!seg->use_rela_p)
23025 bfd_vma addend_abs = abs (value);
23027 /* Check that the absolute value of the addend can be
23028 encoded in 12 bits. */
23029 if (addend_abs >= 0x1000)
23030 as_bad_where (fixP->fx_file, fixP->fx_line,
23031 _("bad offset 0x%08lX (only 12 bits available for the magnitude)"),
23032 (unsigned long) addend_abs);
23034 /* Extract the instruction. */
23035 insn = md_chars_to_number (buf, INSN_SIZE);
23037 /* If the addend is negative, clear bit 23 of the instruction.
23038 Otherwise set it. */
23040 insn &= ~(1 << 23);
23044 /* Place the absolute value of the addend into the first 12 bits
23045 of the instruction. */
23046 insn &= 0xfffff000;
23047 insn |= addend_abs;
23049 /* Update the instruction. */
23050 md_number_to_chars (buf, insn, INSN_SIZE);
23054 case BFD_RELOC_ARM_LDRS_PC_G0:
23055 case BFD_RELOC_ARM_LDRS_PC_G1:
23056 case BFD_RELOC_ARM_LDRS_PC_G2:
23057 case BFD_RELOC_ARM_LDRS_SB_G0:
23058 case BFD_RELOC_ARM_LDRS_SB_G1:
23059 case BFD_RELOC_ARM_LDRS_SB_G2:
23060 gas_assert (!fixP->fx_done);
23061 if (!seg->use_rela_p)
23064 bfd_vma addend_abs = abs (value);
23066 /* Check that the absolute value of the addend can be
23067 encoded in 8 bits. */
23068 if (addend_abs >= 0x100)
23069 as_bad_where (fixP->fx_file, fixP->fx_line,
23070 _("bad offset 0x%08lX (only 8 bits available for the magnitude)"),
23071 (unsigned long) addend_abs);
23073 /* Extract the instruction. */
23074 insn = md_chars_to_number (buf, INSN_SIZE);
23076 /* If the addend is negative, clear bit 23 of the instruction.
23077 Otherwise set it. */
23079 insn &= ~(1 << 23);
23083 /* Place the first four bits of the absolute value of the addend
23084 into the first 4 bits of the instruction, and the remaining
23085 four into bits 8 .. 11. */
23086 insn &= 0xfffff0f0;
23087 insn |= (addend_abs & 0xf) | ((addend_abs & 0xf0) << 4);
23089 /* Update the instruction. */
23090 md_number_to_chars (buf, insn, INSN_SIZE);
23094 case BFD_RELOC_ARM_LDC_PC_G0:
23095 case BFD_RELOC_ARM_LDC_PC_G1:
23096 case BFD_RELOC_ARM_LDC_PC_G2:
23097 case BFD_RELOC_ARM_LDC_SB_G0:
23098 case BFD_RELOC_ARM_LDC_SB_G1:
23099 case BFD_RELOC_ARM_LDC_SB_G2:
23100 gas_assert (!fixP->fx_done);
23101 if (!seg->use_rela_p)
23104 bfd_vma addend_abs = abs (value);
23106 /* Check that the absolute value of the addend is a multiple of
23107 four and, when divided by four, fits in 8 bits. */
23108 if (addend_abs & 0x3)
23109 as_bad_where (fixP->fx_file, fixP->fx_line,
23110 _("bad offset 0x%08lX (must be word-aligned)"),
23111 (unsigned long) addend_abs);
23113 if ((addend_abs >> 2) > 0xff)
23114 as_bad_where (fixP->fx_file, fixP->fx_line,
23115 _("bad offset 0x%08lX (must be an 8-bit number of words)"),
23116 (unsigned long) addend_abs);
23118 /* Extract the instruction. */
23119 insn = md_chars_to_number (buf, INSN_SIZE);
23121 /* If the addend is negative, clear bit 23 of the instruction.
23122 Otherwise set it. */
23124 insn &= ~(1 << 23);
23128 /* Place the addend (divided by four) into the first eight
23129 bits of the instruction. */
23130 insn &= 0xfffffff0;
23131 insn |= addend_abs >> 2;
23133 /* Update the instruction. */
23134 md_number_to_chars (buf, insn, INSN_SIZE);
23138 case BFD_RELOC_ARM_V4BX:
23139 /* This will need to go in the object file. */
23143 case BFD_RELOC_UNUSED:
23145 as_bad_where (fixP->fx_file, fixP->fx_line,
23146 _("bad relocation fixup type (%d)"), fixP->fx_r_type);
23150 /* Translate internal representation of relocation info to BFD target
23154 tc_gen_reloc (asection *section, fixS *fixp)
23157 bfd_reloc_code_real_type code;
23159 reloc = (arelent *) xmalloc (sizeof (arelent));
23161 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
23162 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
23163 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
23165 if (fixp->fx_pcrel)
23167 if (section->use_rela_p)
23168 fixp->fx_offset -= md_pcrel_from_section (fixp, section);
23170 fixp->fx_offset = reloc->address;
23172 reloc->addend = fixp->fx_offset;
23174 switch (fixp->fx_r_type)
23177 if (fixp->fx_pcrel)
23179 code = BFD_RELOC_8_PCREL;
23184 if (fixp->fx_pcrel)
23186 code = BFD_RELOC_16_PCREL;
23191 if (fixp->fx_pcrel)
23193 code = BFD_RELOC_32_PCREL;
23197 case BFD_RELOC_ARM_MOVW:
23198 if (fixp->fx_pcrel)
23200 code = BFD_RELOC_ARM_MOVW_PCREL;
23204 case BFD_RELOC_ARM_MOVT:
23205 if (fixp->fx_pcrel)
23207 code = BFD_RELOC_ARM_MOVT_PCREL;
23211 case BFD_RELOC_ARM_THUMB_MOVW:
23212 if (fixp->fx_pcrel)
23214 code = BFD_RELOC_ARM_THUMB_MOVW_PCREL;
23218 case BFD_RELOC_ARM_THUMB_MOVT:
23219 if (fixp->fx_pcrel)
23221 code = BFD_RELOC_ARM_THUMB_MOVT_PCREL;
23225 case BFD_RELOC_NONE:
23226 case BFD_RELOC_ARM_PCREL_BRANCH:
23227 case BFD_RELOC_ARM_PCREL_BLX:
23228 case BFD_RELOC_RVA:
23229 case BFD_RELOC_THUMB_PCREL_BRANCH7:
23230 case BFD_RELOC_THUMB_PCREL_BRANCH9:
23231 case BFD_RELOC_THUMB_PCREL_BRANCH12:
23232 case BFD_RELOC_THUMB_PCREL_BRANCH20:
23233 case BFD_RELOC_THUMB_PCREL_BRANCH23:
23234 case BFD_RELOC_THUMB_PCREL_BRANCH25:
23235 case BFD_RELOC_VTABLE_ENTRY:
23236 case BFD_RELOC_VTABLE_INHERIT:
23238 case BFD_RELOC_32_SECREL:
23240 code = fixp->fx_r_type;
23243 case BFD_RELOC_THUMB_PCREL_BLX:
23245 if (EF_ARM_EABI_VERSION (meabi_flags) >= EF_ARM_EABI_VER4)
23246 code = BFD_RELOC_THUMB_PCREL_BRANCH23;
23249 code = BFD_RELOC_THUMB_PCREL_BLX;
23252 case BFD_RELOC_ARM_LITERAL:
23253 case BFD_RELOC_ARM_HWLITERAL:
23254 /* If this is called then the a literal has
23255 been referenced across a section boundary. */
23256 as_bad_where (fixp->fx_file, fixp->fx_line,
23257 _("literal referenced across section boundary"));
23261 case BFD_RELOC_ARM_TLS_CALL:
23262 case BFD_RELOC_ARM_THM_TLS_CALL:
23263 case BFD_RELOC_ARM_TLS_DESCSEQ:
23264 case BFD_RELOC_ARM_THM_TLS_DESCSEQ:
23265 case BFD_RELOC_ARM_GOT32:
23266 case BFD_RELOC_ARM_GOTOFF:
23267 case BFD_RELOC_ARM_GOT_PREL:
23268 case BFD_RELOC_ARM_PLT32:
23269 case BFD_RELOC_ARM_TARGET1:
23270 case BFD_RELOC_ARM_ROSEGREL32:
23271 case BFD_RELOC_ARM_SBREL32:
23272 case BFD_RELOC_ARM_PREL31:
23273 case BFD_RELOC_ARM_TARGET2:
23274 case BFD_RELOC_ARM_TLS_LE32:
23275 case BFD_RELOC_ARM_TLS_LDO32:
23276 case BFD_RELOC_ARM_PCREL_CALL:
23277 case BFD_RELOC_ARM_PCREL_JUMP:
23278 case BFD_RELOC_ARM_ALU_PC_G0_NC:
23279 case BFD_RELOC_ARM_ALU_PC_G0:
23280 case BFD_RELOC_ARM_ALU_PC_G1_NC:
23281 case BFD_RELOC_ARM_ALU_PC_G1:
23282 case BFD_RELOC_ARM_ALU_PC_G2:
23283 case BFD_RELOC_ARM_LDR_PC_G0:
23284 case BFD_RELOC_ARM_LDR_PC_G1:
23285 case BFD_RELOC_ARM_LDR_PC_G2:
23286 case BFD_RELOC_ARM_LDRS_PC_G0:
23287 case BFD_RELOC_ARM_LDRS_PC_G1:
23288 case BFD_RELOC_ARM_LDRS_PC_G2:
23289 case BFD_RELOC_ARM_LDC_PC_G0:
23290 case BFD_RELOC_ARM_LDC_PC_G1:
23291 case BFD_RELOC_ARM_LDC_PC_G2:
23292 case BFD_RELOC_ARM_ALU_SB_G0_NC:
23293 case BFD_RELOC_ARM_ALU_SB_G0:
23294 case BFD_RELOC_ARM_ALU_SB_G1_NC:
23295 case BFD_RELOC_ARM_ALU_SB_G1:
23296 case BFD_RELOC_ARM_ALU_SB_G2:
23297 case BFD_RELOC_ARM_LDR_SB_G0:
23298 case BFD_RELOC_ARM_LDR_SB_G1:
23299 case BFD_RELOC_ARM_LDR_SB_G2:
23300 case BFD_RELOC_ARM_LDRS_SB_G0:
23301 case BFD_RELOC_ARM_LDRS_SB_G1:
23302 case BFD_RELOC_ARM_LDRS_SB_G2:
23303 case BFD_RELOC_ARM_LDC_SB_G0:
23304 case BFD_RELOC_ARM_LDC_SB_G1:
23305 case BFD_RELOC_ARM_LDC_SB_G2:
23306 case BFD_RELOC_ARM_V4BX:
23307 code = fixp->fx_r_type;
23310 case BFD_RELOC_ARM_TLS_GOTDESC:
23311 case BFD_RELOC_ARM_TLS_GD32:
23312 case BFD_RELOC_ARM_TLS_IE32:
23313 case BFD_RELOC_ARM_TLS_LDM32:
23314 /* BFD will include the symbol's address in the addend.
23315 But we don't want that, so subtract it out again here. */
23316 if (!S_IS_COMMON (fixp->fx_addsy))
23317 reloc->addend -= (*reloc->sym_ptr_ptr)->value;
23318 code = fixp->fx_r_type;
23322 case BFD_RELOC_ARM_IMMEDIATE:
23323 as_bad_where (fixp->fx_file, fixp->fx_line,
23324 _("internal relocation (type: IMMEDIATE) not fixed up"));
23327 case BFD_RELOC_ARM_ADRL_IMMEDIATE:
23328 as_bad_where (fixp->fx_file, fixp->fx_line,
23329 _("ADRL used for a symbol not defined in the same file"));
23332 case BFD_RELOC_ARM_OFFSET_IMM:
23333 if (section->use_rela_p)
23335 code = fixp->fx_r_type;
23339 if (fixp->fx_addsy != NULL
23340 && !S_IS_DEFINED (fixp->fx_addsy)
23341 && S_IS_LOCAL (fixp->fx_addsy))
23343 as_bad_where (fixp->fx_file, fixp->fx_line,
23344 _("undefined local label `%s'"),
23345 S_GET_NAME (fixp->fx_addsy));
23349 as_bad_where (fixp->fx_file, fixp->fx_line,
23350 _("internal_relocation (type: OFFSET_IMM) not fixed up"));
23357 switch (fixp->fx_r_type)
23359 case BFD_RELOC_NONE: type = "NONE"; break;
23360 case BFD_RELOC_ARM_OFFSET_IMM8: type = "OFFSET_IMM8"; break;
23361 case BFD_RELOC_ARM_SHIFT_IMM: type = "SHIFT_IMM"; break;
23362 case BFD_RELOC_ARM_SMC: type = "SMC"; break;
23363 case BFD_RELOC_ARM_SWI: type = "SWI"; break;
23364 case BFD_RELOC_ARM_MULTI: type = "MULTI"; break;
23365 case BFD_RELOC_ARM_CP_OFF_IMM: type = "CP_OFF_IMM"; break;
23366 case BFD_RELOC_ARM_T32_OFFSET_IMM: type = "T32_OFFSET_IMM"; break;
23367 case BFD_RELOC_ARM_T32_CP_OFF_IMM: type = "T32_CP_OFF_IMM"; break;
23368 case BFD_RELOC_ARM_THUMB_ADD: type = "THUMB_ADD"; break;
23369 case BFD_RELOC_ARM_THUMB_SHIFT: type = "THUMB_SHIFT"; break;
23370 case BFD_RELOC_ARM_THUMB_IMM: type = "THUMB_IMM"; break;
23371 case BFD_RELOC_ARM_THUMB_OFFSET: type = "THUMB_OFFSET"; break;
23372 default: type = _("<unknown>"); break;
23374 as_bad_where (fixp->fx_file, fixp->fx_line,
23375 _("cannot represent %s relocation in this object file format"),
23382 if ((code == BFD_RELOC_32_PCREL || code == BFD_RELOC_32)
23384 && fixp->fx_addsy == GOT_symbol)
23386 code = BFD_RELOC_ARM_GOTPC;
23387 reloc->addend = fixp->fx_offset = reloc->address;
23391 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
23393 if (reloc->howto == NULL)
23395 as_bad_where (fixp->fx_file, fixp->fx_line,
23396 _("cannot represent %s relocation in this object file format"),
23397 bfd_get_reloc_code_name (code));
23401 /* HACK: Since arm ELF uses Rel instead of Rela, encode the
23402 vtable entry to be used in the relocation's section offset. */
23403 if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
23404 reloc->address = fixp->fx_offset;
23409 /* This fix_new is called by cons via TC_CONS_FIX_NEW. */
23412 cons_fix_new_arm (fragS * frag,
23416 bfd_reloc_code_real_type reloc)
23421 FIXME: @@ Should look at CPU word size. */
23425 reloc = BFD_RELOC_8;
23428 reloc = BFD_RELOC_16;
23432 reloc = BFD_RELOC_32;
23435 reloc = BFD_RELOC_64;
23440 if (exp->X_op == O_secrel)
23442 exp->X_op = O_symbol;
23443 reloc = BFD_RELOC_32_SECREL;
23447 fix_new_exp (frag, where, size, exp, pcrel, reloc);
23450 #if defined (OBJ_COFF)
23452 arm_validate_fix (fixS * fixP)
23454 /* If the destination of the branch is a defined symbol which does not have
23455 the THUMB_FUNC attribute, then we must be calling a function which has
23456 the (interfacearm) attribute. We look for the Thumb entry point to that
23457 function and change the branch to refer to that function instead. */
23458 if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23
23459 && fixP->fx_addsy != NULL
23460 && S_IS_DEFINED (fixP->fx_addsy)
23461 && ! THUMB_IS_FUNC (fixP->fx_addsy))
23463 fixP->fx_addsy = find_real_start (fixP->fx_addsy);
23470 arm_force_relocation (struct fix * fixp)
23472 #if defined (OBJ_COFF) && defined (TE_PE)
23473 if (fixp->fx_r_type == BFD_RELOC_RVA)
23477 /* In case we have a call or a branch to a function in ARM ISA mode from
23478 a thumb function or vice-versa force the relocation. These relocations
23479 are cleared off for some cores that might have blx and simple transformations
23483 switch (fixp->fx_r_type)
23485 case BFD_RELOC_ARM_PCREL_JUMP:
23486 case BFD_RELOC_ARM_PCREL_CALL:
23487 case BFD_RELOC_THUMB_PCREL_BLX:
23488 if (THUMB_IS_FUNC (fixp->fx_addsy))
23492 case BFD_RELOC_ARM_PCREL_BLX:
23493 case BFD_RELOC_THUMB_PCREL_BRANCH25:
23494 case BFD_RELOC_THUMB_PCREL_BRANCH20:
23495 case BFD_RELOC_THUMB_PCREL_BRANCH23:
23496 if (ARM_IS_FUNC (fixp->fx_addsy))
23505 /* Resolve these relocations even if the symbol is extern or weak.
23506 Technically this is probably wrong due to symbol preemption.
23507 In practice these relocations do not have enough range to be useful
23508 at dynamic link time, and some code (e.g. in the Linux kernel)
23509 expects these references to be resolved. */
23510 if (fixp->fx_r_type == BFD_RELOC_ARM_IMMEDIATE
23511 || fixp->fx_r_type == BFD_RELOC_ARM_OFFSET_IMM
23512 || fixp->fx_r_type == BFD_RELOC_ARM_OFFSET_IMM8
23513 || fixp->fx_r_type == BFD_RELOC_ARM_ADRL_IMMEDIATE
23514 || fixp->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM
23515 || fixp->fx_r_type == BFD_RELOC_ARM_CP_OFF_IMM_S2
23516 || fixp->fx_r_type == BFD_RELOC_ARM_THUMB_OFFSET
23517 || fixp->fx_r_type == BFD_RELOC_ARM_T32_ADD_IMM
23518 || fixp->fx_r_type == BFD_RELOC_ARM_T32_IMMEDIATE
23519 || fixp->fx_r_type == BFD_RELOC_ARM_T32_IMM12
23520 || fixp->fx_r_type == BFD_RELOC_ARM_T32_OFFSET_IMM
23521 || fixp->fx_r_type == BFD_RELOC_ARM_T32_ADD_PC12
23522 || fixp->fx_r_type == BFD_RELOC_ARM_T32_CP_OFF_IMM
23523 || fixp->fx_r_type == BFD_RELOC_ARM_T32_CP_OFF_IMM_S2)
23526 /* Always leave these relocations for the linker. */
23527 if ((fixp->fx_r_type >= BFD_RELOC_ARM_ALU_PC_G0_NC
23528 && fixp->fx_r_type <= BFD_RELOC_ARM_LDC_SB_G2)
23529 || fixp->fx_r_type == BFD_RELOC_ARM_LDR_PC_G0)
23532 /* Always generate relocations against function symbols. */
23533 if (fixp->fx_r_type == BFD_RELOC_32
23535 && (symbol_get_bfdsym (fixp->fx_addsy)->flags & BSF_FUNCTION))
23538 return generic_force_reloc (fixp);
23541 #if defined (OBJ_ELF) || defined (OBJ_COFF)
23542 /* Relocations against function names must be left unadjusted,
23543 so that the linker can use this information to generate interworking
23544 stubs. The MIPS version of this function
23545 also prevents relocations that are mips-16 specific, but I do not
23546 know why it does this.
23549 There is one other problem that ought to be addressed here, but
23550 which currently is not: Taking the address of a label (rather
23551 than a function) and then later jumping to that address. Such
23552 addresses also ought to have their bottom bit set (assuming that
23553 they reside in Thumb code), but at the moment they will not. */
23556 arm_fix_adjustable (fixS * fixP)
23558 if (fixP->fx_addsy == NULL)
23561 /* Preserve relocations against symbols with function type. */
23562 if (symbol_get_bfdsym (fixP->fx_addsy)->flags & BSF_FUNCTION)
23565 if (THUMB_IS_FUNC (fixP->fx_addsy)
23566 && fixP->fx_subsy == NULL)
23569 /* We need the symbol name for the VTABLE entries. */
23570 if ( fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
23571 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
23574 /* Don't allow symbols to be discarded on GOT related relocs. */
23575 if (fixP->fx_r_type == BFD_RELOC_ARM_PLT32
23576 || fixP->fx_r_type == BFD_RELOC_ARM_GOT32
23577 || fixP->fx_r_type == BFD_RELOC_ARM_GOTOFF
23578 || fixP->fx_r_type == BFD_RELOC_ARM_TLS_GD32
23579 || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LE32
23580 || fixP->fx_r_type == BFD_RELOC_ARM_TLS_IE32
23581 || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDM32
23582 || fixP->fx_r_type == BFD_RELOC_ARM_TLS_LDO32
23583 || fixP->fx_r_type == BFD_RELOC_ARM_TLS_GOTDESC
23584 || fixP->fx_r_type == BFD_RELOC_ARM_TLS_CALL
23585 || fixP->fx_r_type == BFD_RELOC_ARM_THM_TLS_CALL
23586 || fixP->fx_r_type == BFD_RELOC_ARM_TLS_DESCSEQ
23587 || fixP->fx_r_type == BFD_RELOC_ARM_THM_TLS_DESCSEQ
23588 || fixP->fx_r_type == BFD_RELOC_ARM_TARGET2)
23591 /* Similarly for group relocations. */
23592 if ((fixP->fx_r_type >= BFD_RELOC_ARM_ALU_PC_G0_NC
23593 && fixP->fx_r_type <= BFD_RELOC_ARM_LDC_SB_G2)
23594 || fixP->fx_r_type == BFD_RELOC_ARM_LDR_PC_G0)
23597 /* MOVW/MOVT REL relocations have limited offsets, so keep the symbols. */
23598 if (fixP->fx_r_type == BFD_RELOC_ARM_MOVW
23599 || fixP->fx_r_type == BFD_RELOC_ARM_MOVT
23600 || fixP->fx_r_type == BFD_RELOC_ARM_MOVW_PCREL
23601 || fixP->fx_r_type == BFD_RELOC_ARM_MOVT_PCREL
23602 || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW
23603 || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT
23604 || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVW_PCREL
23605 || fixP->fx_r_type == BFD_RELOC_ARM_THUMB_MOVT_PCREL)
23610 #endif /* defined (OBJ_ELF) || defined (OBJ_COFF) */
23615 elf32_arm_target_format (void)
23618 return (target_big_endian
23619 ? "elf32-bigarm-symbian"
23620 : "elf32-littlearm-symbian");
23621 #elif defined (TE_VXWORKS)
23622 return (target_big_endian
23623 ? "elf32-bigarm-vxworks"
23624 : "elf32-littlearm-vxworks");
23625 #elif defined (TE_NACL)
23626 return (target_big_endian
23627 ? "elf32-bigarm-nacl"
23628 : "elf32-littlearm-nacl");
23630 if (target_big_endian)
23631 return "elf32-bigarm";
23633 return "elf32-littlearm";
23638 armelf_frob_symbol (symbolS * symp,
23641 elf_frob_symbol (symp, puntp);
23645 /* MD interface: Finalization. */
23650 literal_pool * pool;
23652 /* Ensure that all the IT blocks are properly closed. */
23653 check_it_blocks_finished ();
23655 for (pool = list_of_pools; pool; pool = pool->next)
23657 /* Put it at the end of the relevant section. */
23658 subseg_set (pool->section, pool->sub_section);
23660 arm_elf_change_section ();
23667 /* Remove any excess mapping symbols generated for alignment frags in
23668 SEC. We may have created a mapping symbol before a zero byte
23669 alignment; remove it if there's a mapping symbol after the
23672 check_mapping_symbols (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
23673 void *dummy ATTRIBUTE_UNUSED)
23675 segment_info_type *seginfo = seg_info (sec);
23678 if (seginfo == NULL || seginfo->frchainP == NULL)
23681 for (fragp = seginfo->frchainP->frch_root;
23683 fragp = fragp->fr_next)
23685 symbolS *sym = fragp->tc_frag_data.last_map;
23686 fragS *next = fragp->fr_next;
23688 /* Variable-sized frags have been converted to fixed size by
23689 this point. But if this was variable-sized to start with,
23690 there will be a fixed-size frag after it. So don't handle
23692 if (sym == NULL || next == NULL)
23695 if (S_GET_VALUE (sym) < next->fr_address)
23696 /* Not at the end of this frag. */
23698 know (S_GET_VALUE (sym) == next->fr_address);
23702 if (next->tc_frag_data.first_map != NULL)
23704 /* Next frag starts with a mapping symbol. Discard this
23706 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
23710 if (next->fr_next == NULL)
23712 /* This mapping symbol is at the end of the section. Discard
23714 know (next->fr_fix == 0 && next->fr_var == 0);
23715 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
23719 /* As long as we have empty frags without any mapping symbols,
23721 /* If the next frag is non-empty and does not start with a
23722 mapping symbol, then this mapping symbol is required. */
23723 if (next->fr_address != next->fr_next->fr_address)
23726 next = next->fr_next;
23728 while (next != NULL);
23733 /* Adjust the symbol table. This marks Thumb symbols as distinct from
23737 arm_adjust_symtab (void)
23742 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
23744 if (ARM_IS_THUMB (sym))
23746 if (THUMB_IS_FUNC (sym))
23748 /* Mark the symbol as a Thumb function. */
23749 if ( S_GET_STORAGE_CLASS (sym) == C_STAT
23750 || S_GET_STORAGE_CLASS (sym) == C_LABEL) /* This can happen! */
23751 S_SET_STORAGE_CLASS (sym, C_THUMBSTATFUNC);
23753 else if (S_GET_STORAGE_CLASS (sym) == C_EXT)
23754 S_SET_STORAGE_CLASS (sym, C_THUMBEXTFUNC);
23756 as_bad (_("%s: unexpected function type: %d"),
23757 S_GET_NAME (sym), S_GET_STORAGE_CLASS (sym));
23759 else switch (S_GET_STORAGE_CLASS (sym))
23762 S_SET_STORAGE_CLASS (sym, C_THUMBEXT);
23765 S_SET_STORAGE_CLASS (sym, C_THUMBSTAT);
23768 S_SET_STORAGE_CLASS (sym, C_THUMBLABEL);
23776 if (ARM_IS_INTERWORK (sym))
23777 coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_flags = 0xFF;
23784 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
23786 if (ARM_IS_THUMB (sym))
23788 elf_symbol_type * elf_sym;
23790 elf_sym = elf_symbol (symbol_get_bfdsym (sym));
23791 bind = ELF_ST_BIND (elf_sym->internal_elf_sym.st_info);
23793 if (! bfd_is_arm_special_symbol_name (elf_sym->symbol.name,
23794 BFD_ARM_SPECIAL_SYM_TYPE_ANY))
23796 /* If it's a .thumb_func, declare it as so,
23797 otherwise tag label as .code 16. */
23798 if (THUMB_IS_FUNC (sym))
23799 elf_sym->internal_elf_sym.st_target_internal
23800 = ST_BRANCH_TO_THUMB;
23801 else if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
23802 elf_sym->internal_elf_sym.st_info =
23803 ELF_ST_INFO (bind, STT_ARM_16BIT);
23808 /* Remove any overlapping mapping symbols generated by alignment frags. */
23809 bfd_map_over_sections (stdoutput, check_mapping_symbols, (char *) 0);
23810 /* Now do generic ELF adjustments. */
23811 elf_adjust_symtab ();
23815 /* MD interface: Initialization. */
23818 set_constant_flonums (void)
23822 for (i = 0; i < NUM_FLOAT_VALS; i++)
23823 if (atof_ieee ((char *) fp_const[i], 'x', fp_values[i]) == NULL)
23827 /* Auto-select Thumb mode if it's the only available instruction set for the
23828 given architecture. */
23831 autoselect_thumb_from_cpu_variant (void)
23833 if (!ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v1))
23834 opcode_select (16);
23843 if ( (arm_ops_hsh = hash_new ()) == NULL
23844 || (arm_cond_hsh = hash_new ()) == NULL
23845 || (arm_shift_hsh = hash_new ()) == NULL
23846 || (arm_psr_hsh = hash_new ()) == NULL
23847 || (arm_v7m_psr_hsh = hash_new ()) == NULL
23848 || (arm_reg_hsh = hash_new ()) == NULL
23849 || (arm_reloc_hsh = hash_new ()) == NULL
23850 || (arm_barrier_opt_hsh = hash_new ()) == NULL)
23851 as_fatal (_("virtual memory exhausted"));
23853 for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++)
23854 hash_insert (arm_ops_hsh, insns[i].template_name, (void *) (insns + i));
23855 for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++)
23856 hash_insert (arm_cond_hsh, conds[i].template_name, (void *) (conds + i));
23857 for (i = 0; i < sizeof (shift_names) / sizeof (struct asm_shift_name); i++)
23858 hash_insert (arm_shift_hsh, shift_names[i].name, (void *) (shift_names + i));
23859 for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++)
23860 hash_insert (arm_psr_hsh, psrs[i].template_name, (void *) (psrs + i));
23861 for (i = 0; i < sizeof (v7m_psrs) / sizeof (struct asm_psr); i++)
23862 hash_insert (arm_v7m_psr_hsh, v7m_psrs[i].template_name,
23863 (void *) (v7m_psrs + i));
23864 for (i = 0; i < sizeof (reg_names) / sizeof (struct reg_entry); i++)
23865 hash_insert (arm_reg_hsh, reg_names[i].name, (void *) (reg_names + i));
23867 i < sizeof (barrier_opt_names) / sizeof (struct asm_barrier_opt);
23869 hash_insert (arm_barrier_opt_hsh, barrier_opt_names[i].template_name,
23870 (void *) (barrier_opt_names + i));
23872 for (i = 0; i < ARRAY_SIZE (reloc_names); i++)
23874 struct reloc_entry * entry = reloc_names + i;
23876 if (arm_is_eabi() && entry->reloc == BFD_RELOC_ARM_PLT32)
23877 /* This makes encode_branch() use the EABI versions of this relocation. */
23878 entry->reloc = BFD_RELOC_UNUSED;
23880 hash_insert (arm_reloc_hsh, entry->name, (void *) entry);
23884 set_constant_flonums ();
23886 /* Set the cpu variant based on the command-line options. We prefer
23887 -mcpu= over -march= if both are set (as for GCC); and we prefer
23888 -mfpu= over any other way of setting the floating point unit.
23889 Use of legacy options with new options are faulted. */
23892 if (mcpu_cpu_opt || march_cpu_opt)
23893 as_bad (_("use of old and new-style options to set CPU type"));
23895 mcpu_cpu_opt = legacy_cpu;
23897 else if (!mcpu_cpu_opt)
23898 mcpu_cpu_opt = march_cpu_opt;
23903 as_bad (_("use of old and new-style options to set FPU type"));
23905 mfpu_opt = legacy_fpu;
23907 else if (!mfpu_opt)
23909 #if !(defined (EABI_DEFAULT) || defined (TE_LINUX) \
23910 || defined (TE_NetBSD) || defined (TE_VXWORKS))
23911 /* Some environments specify a default FPU. If they don't, infer it
23912 from the processor. */
23914 mfpu_opt = mcpu_fpu_opt;
23916 mfpu_opt = march_fpu_opt;
23918 mfpu_opt = &fpu_default;
23924 if (mcpu_cpu_opt != NULL)
23925 mfpu_opt = &fpu_default;
23926 else if (mcpu_fpu_opt != NULL && ARM_CPU_HAS_FEATURE (*mcpu_fpu_opt, arm_ext_v5))
23927 mfpu_opt = &fpu_arch_vfp_v2;
23929 mfpu_opt = &fpu_arch_fpa;
23935 mcpu_cpu_opt = &cpu_default;
23936 selected_cpu = cpu_default;
23940 selected_cpu = *mcpu_cpu_opt;
23942 mcpu_cpu_opt = &arm_arch_any;
23945 ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
23947 autoselect_thumb_from_cpu_variant ();
23949 arm_arch_used = thumb_arch_used = arm_arch_none;
23951 #if defined OBJ_COFF || defined OBJ_ELF
23953 unsigned int flags = 0;
23955 #if defined OBJ_ELF
23956 flags = meabi_flags;
23958 switch (meabi_flags)
23960 case EF_ARM_EABI_UNKNOWN:
23962 /* Set the flags in the private structure. */
23963 if (uses_apcs_26) flags |= F_APCS26;
23964 if (support_interwork) flags |= F_INTERWORK;
23965 if (uses_apcs_float) flags |= F_APCS_FLOAT;
23966 if (pic_code) flags |= F_PIC;
23967 if (!ARM_CPU_HAS_FEATURE (cpu_variant, fpu_any_hard))
23968 flags |= F_SOFT_FLOAT;
23970 switch (mfloat_abi_opt)
23972 case ARM_FLOAT_ABI_SOFT:
23973 case ARM_FLOAT_ABI_SOFTFP:
23974 flags |= F_SOFT_FLOAT;
23977 case ARM_FLOAT_ABI_HARD:
23978 if (flags & F_SOFT_FLOAT)
23979 as_bad (_("hard-float conflicts with specified fpu"));
23983 /* Using pure-endian doubles (even if soft-float). */
23984 if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_endian_pure))
23985 flags |= F_VFP_FLOAT;
23987 #if defined OBJ_ELF
23988 if (ARM_CPU_HAS_FEATURE (cpu_variant, fpu_arch_maverick))
23989 flags |= EF_ARM_MAVERICK_FLOAT;
23992 case EF_ARM_EABI_VER4:
23993 case EF_ARM_EABI_VER5:
23994 /* No additional flags to set. */
24001 bfd_set_private_flags (stdoutput, flags);
24003 /* We have run out flags in the COFF header to encode the
24004 status of ATPCS support, so instead we create a dummy,
24005 empty, debug section called .arm.atpcs. */
24010 sec = bfd_make_section (stdoutput, ".arm.atpcs");
24014 bfd_set_section_flags
24015 (stdoutput, sec, SEC_READONLY | SEC_DEBUGGING /* | SEC_HAS_CONTENTS */);
24016 bfd_set_section_size (stdoutput, sec, 0);
24017 bfd_set_section_contents (stdoutput, sec, NULL, 0, 0);
24023 /* Record the CPU type as well. */
24024 if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt2))
24025 mach = bfd_mach_arm_iWMMXt2;
24026 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_iwmmxt))
24027 mach = bfd_mach_arm_iWMMXt;
24028 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_xscale))
24029 mach = bfd_mach_arm_XScale;
24030 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_cext_maverick))
24031 mach = bfd_mach_arm_ep9312;
24032 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v5e))
24033 mach = bfd_mach_arm_5TE;
24034 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v5))
24036 if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
24037 mach = bfd_mach_arm_5T;
24039 mach = bfd_mach_arm_5;
24041 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4))
24043 if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v4t))
24044 mach = bfd_mach_arm_4T;
24046 mach = bfd_mach_arm_4;
24048 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v3m))
24049 mach = bfd_mach_arm_3M;
24050 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v3))
24051 mach = bfd_mach_arm_3;
24052 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v2s))
24053 mach = bfd_mach_arm_2a;
24054 else if (ARM_CPU_HAS_FEATURE (cpu_variant, arm_ext_v2))
24055 mach = bfd_mach_arm_2;
24057 mach = bfd_mach_arm_unknown;
24059 bfd_set_arch_mach (stdoutput, TARGET_ARCH, mach);
24062 /* Command line processing. */
24065 Invocation line includes a switch not recognized by the base assembler.
24066 See if it's a processor-specific option.
24068 This routine is somewhat complicated by the need for backwards
24069 compatibility (since older releases of gcc can't be changed).
24070 The new options try to make the interface as compatible as
24073 New options (supported) are:
24075 -mcpu=<cpu name> Assemble for selected processor
24076 -march=<architecture name> Assemble for selected architecture
24077 -mfpu=<fpu architecture> Assemble for selected FPU.
24078 -EB/-mbig-endian Big-endian
24079 -EL/-mlittle-endian Little-endian
24080 -k Generate PIC code
24081 -mthumb Start in Thumb mode
24082 -mthumb-interwork Code supports ARM/Thumb interworking
24084 -m[no-]warn-deprecated Warn about deprecated features
24086 For now we will also provide support for:
24088 -mapcs-32 32-bit Program counter
24089 -mapcs-26 26-bit Program counter
24090 -macps-float Floats passed in FP registers
24091 -mapcs-reentrant Reentrant code
24093 (sometime these will probably be replaced with -mapcs=<list of options>
24094 and -matpcs=<list of options>)
24096 The remaining options are only supported for back-wards compatibility.
24097 Cpu variants, the arm part is optional:
24098 -m[arm]1 Currently not supported.
24099 -m[arm]2, -m[arm]250 Arm 2 and Arm 250 processor
24100 -m[arm]3 Arm 3 processor
24101 -m[arm]6[xx], Arm 6 processors
24102 -m[arm]7[xx][t][[d]m] Arm 7 processors
24103 -m[arm]8[10] Arm 8 processors
24104 -m[arm]9[20][tdmi] Arm 9 processors
24105 -mstrongarm[110[0]] StrongARM processors
24106 -mxscale XScale processors
24107 -m[arm]v[2345[t[e]]] Arm architectures
24108 -mall All (except the ARM1)
24110 -mfpa10, -mfpa11 FPA10 and 11 co-processor instructions
24111 -mfpe-old (No float load/store multiples)
24112 -mvfpxd VFP Single precision
24114 -mno-fpu Disable all floating point instructions
24116 The following CPU names are recognized:
24117 arm1, arm2, arm250, arm3, arm6, arm600, arm610, arm620,
24118 arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700,
24119 arm700i, arm710 arm710t, arm720, arm720t, arm740t, arm710c,
24120 arm7100, arm7500, arm7500fe, arm7tdmi, arm8, arm810, arm9,
24121 arm920, arm920t, arm940t, arm946, arm966, arm9tdmi, arm9e,
24122 arm10t arm10e, arm1020t, arm1020e, arm10200e,
24123 strongarm, strongarm110, strongarm1100, strongarm1110, xscale.
24127 const char * md_shortopts = "m:k";
24129 #ifdef ARM_BI_ENDIAN
24130 #define OPTION_EB (OPTION_MD_BASE + 0)
24131 #define OPTION_EL (OPTION_MD_BASE + 1)
24133 #if TARGET_BYTES_BIG_ENDIAN
24134 #define OPTION_EB (OPTION_MD_BASE + 0)
24136 #define OPTION_EL (OPTION_MD_BASE + 1)
24139 #define OPTION_FIX_V4BX (OPTION_MD_BASE + 2)
24141 struct option md_longopts[] =
24144 {"EB", no_argument, NULL, OPTION_EB},
24147 {"EL", no_argument, NULL, OPTION_EL},
24149 {"fix-v4bx", no_argument, NULL, OPTION_FIX_V4BX},
24150 {NULL, no_argument, NULL, 0}
24153 size_t md_longopts_size = sizeof (md_longopts);
24155 struct arm_option_table
24157 char *option; /* Option name to match. */
24158 char *help; /* Help information. */
24159 int *var; /* Variable to change. */
24160 int value; /* What to change it to. */
24161 char *deprecated; /* If non-null, print this message. */
24164 struct arm_option_table arm_opts[] =
24166 {"k", N_("generate PIC code"), &pic_code, 1, NULL},
24167 {"mthumb", N_("assemble Thumb code"), &thumb_mode, 1, NULL},
24168 {"mthumb-interwork", N_("support ARM/Thumb interworking"),
24169 &support_interwork, 1, NULL},
24170 {"mapcs-32", N_("code uses 32-bit program counter"), &uses_apcs_26, 0, NULL},
24171 {"mapcs-26", N_("code uses 26-bit program counter"), &uses_apcs_26, 1, NULL},
24172 {"mapcs-float", N_("floating point args are in fp regs"), &uses_apcs_float,
24174 {"mapcs-reentrant", N_("re-entrant code"), &pic_code, 1, NULL},
24175 {"matpcs", N_("code is ATPCS conformant"), &atpcs, 1, NULL},
24176 {"mbig-endian", N_("assemble for big-endian"), &target_big_endian, 1, NULL},
24177 {"mlittle-endian", N_("assemble for little-endian"), &target_big_endian, 0,
24180 /* These are recognized by the assembler, but have no affect on code. */
24181 {"mapcs-frame", N_("use frame pointer"), NULL, 0, NULL},
24182 {"mapcs-stack-check", N_("use stack size checking"), NULL, 0, NULL},
24184 {"mwarn-deprecated", NULL, &warn_on_deprecated, 1, NULL},
24185 {"mno-warn-deprecated", N_("do not warn on use of deprecated feature"),
24186 &warn_on_deprecated, 0, NULL},
24187 {NULL, NULL, NULL, 0, NULL}
24190 struct arm_legacy_option_table
24192 char *option; /* Option name to match. */
24193 const arm_feature_set **var; /* Variable to change. */
24194 const arm_feature_set value; /* What to change it to. */
24195 char *deprecated; /* If non-null, print this message. */
24198 const struct arm_legacy_option_table arm_legacy_opts[] =
24200 /* DON'T add any new processors to this list -- we want the whole list
24201 to go away... Add them to the processors table instead. */
24202 {"marm1", &legacy_cpu, ARM_ARCH_V1, N_("use -mcpu=arm1")},
24203 {"m1", &legacy_cpu, ARM_ARCH_V1, N_("use -mcpu=arm1")},
24204 {"marm2", &legacy_cpu, ARM_ARCH_V2, N_("use -mcpu=arm2")},
24205 {"m2", &legacy_cpu, ARM_ARCH_V2, N_("use -mcpu=arm2")},
24206 {"marm250", &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm250")},
24207 {"m250", &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm250")},
24208 {"marm3", &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm3")},
24209 {"m3", &legacy_cpu, ARM_ARCH_V2S, N_("use -mcpu=arm3")},
24210 {"marm6", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm6")},
24211 {"m6", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm6")},
24212 {"marm600", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm600")},
24213 {"m600", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm600")},
24214 {"marm610", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm610")},
24215 {"m610", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm610")},
24216 {"marm620", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm620")},
24217 {"m620", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm620")},
24218 {"marm7", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7")},
24219 {"m7", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7")},
24220 {"marm70", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm70")},
24221 {"m70", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm70")},
24222 {"marm700", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm700")},
24223 {"m700", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm700")},
24224 {"marm700i", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm700i")},
24225 {"m700i", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm700i")},
24226 {"marm710", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm710")},
24227 {"m710", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm710")},
24228 {"marm710c", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm710c")},
24229 {"m710c", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm710c")},
24230 {"marm720", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm720")},
24231 {"m720", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm720")},
24232 {"marm7d", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7d")},
24233 {"m7d", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7d")},
24234 {"marm7di", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7di")},
24235 {"m7di", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7di")},
24236 {"marm7m", &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7m")},
24237 {"m7m", &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7m")},
24238 {"marm7dm", &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dm")},
24239 {"m7dm", &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dm")},
24240 {"marm7dmi", &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dmi")},
24241 {"m7dmi", &legacy_cpu, ARM_ARCH_V3M, N_("use -mcpu=arm7dmi")},
24242 {"marm7100", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7100")},
24243 {"m7100", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7100")},
24244 {"marm7500", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7500")},
24245 {"m7500", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7500")},
24246 {"marm7500fe", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7500fe")},
24247 {"m7500fe", &legacy_cpu, ARM_ARCH_V3, N_("use -mcpu=arm7500fe")},
24248 {"marm7t", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
24249 {"m7t", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
24250 {"marm7tdmi", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
24251 {"m7tdmi", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm7tdmi")},
24252 {"marm710t", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm710t")},
24253 {"m710t", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm710t")},
24254 {"marm720t", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm720t")},
24255 {"m720t", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm720t")},
24256 {"marm740t", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm740t")},
24257 {"m740t", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm740t")},
24258 {"marm8", &legacy_cpu, ARM_ARCH_V4, N_("use -mcpu=arm8")},
24259 {"m8", &legacy_cpu, ARM_ARCH_V4, N_("use -mcpu=arm8")},
24260 {"marm810", &legacy_cpu, ARM_ARCH_V4, N_("use -mcpu=arm810")},
24261 {"m810", &legacy_cpu, ARM_ARCH_V4, N_("use -mcpu=arm810")},
24262 {"marm9", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9")},
24263 {"m9", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9")},
24264 {"marm9tdmi", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9tdmi")},
24265 {"m9tdmi", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm9tdmi")},
24266 {"marm920", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm920")},
24267 {"m920", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm920")},
24268 {"marm940", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm940")},
24269 {"m940", &legacy_cpu, ARM_ARCH_V4T, N_("use -mcpu=arm940")},
24270 {"mstrongarm", &legacy_cpu, ARM_ARCH_V4, N_("use -mcpu=strongarm")},
24271 {"mstrongarm110", &legacy_cpu, ARM_ARCH_V4,
24272 N_("use -mcpu=strongarm110")},
24273 {"mstrongarm1100", &legacy_cpu, ARM_ARCH_V4,
24274 N_("use -mcpu=strongarm1100")},
24275 {"mstrongarm1110", &legacy_cpu, ARM_ARCH_V4,
24276 N_("use -mcpu=strongarm1110")},
24277 {"mxscale", &legacy_cpu, ARM_ARCH_XSCALE, N_("use -mcpu=xscale")},
24278 {"miwmmxt", &legacy_cpu, ARM_ARCH_IWMMXT, N_("use -mcpu=iwmmxt")},
24279 {"mall", &legacy_cpu, ARM_ANY, N_("use -mcpu=all")},
24281 /* Architecture variants -- don't add any more to this list either. */
24282 {"mv2", &legacy_cpu, ARM_ARCH_V2, N_("use -march=armv2")},
24283 {"marmv2", &legacy_cpu, ARM_ARCH_V2, N_("use -march=armv2")},
24284 {"mv2a", &legacy_cpu, ARM_ARCH_V2S, N_("use -march=armv2a")},
24285 {"marmv2a", &legacy_cpu, ARM_ARCH_V2S, N_("use -march=armv2a")},
24286 {"mv3", &legacy_cpu, ARM_ARCH_V3, N_("use -march=armv3")},
24287 {"marmv3", &legacy_cpu, ARM_ARCH_V3, N_("use -march=armv3")},
24288 {"mv3m", &legacy_cpu, ARM_ARCH_V3M, N_("use -march=armv3m")},
24289 {"marmv3m", &legacy_cpu, ARM_ARCH_V3M, N_("use -march=armv3m")},
24290 {"mv4", &legacy_cpu, ARM_ARCH_V4, N_("use -march=armv4")},
24291 {"marmv4", &legacy_cpu, ARM_ARCH_V4, N_("use -march=armv4")},
24292 {"mv4t", &legacy_cpu, ARM_ARCH_V4T, N_("use -march=armv4t")},
24293 {"marmv4t", &legacy_cpu, ARM_ARCH_V4T, N_("use -march=armv4t")},
24294 {"mv5", &legacy_cpu, ARM_ARCH_V5, N_("use -march=armv5")},
24295 {"marmv5", &legacy_cpu, ARM_ARCH_V5, N_("use -march=armv5")},
24296 {"mv5t", &legacy_cpu, ARM_ARCH_V5T, N_("use -march=armv5t")},
24297 {"marmv5t", &legacy_cpu, ARM_ARCH_V5T, N_("use -march=armv5t")},
24298 {"mv5e", &legacy_cpu, ARM_ARCH_V5TE, N_("use -march=armv5te")},
24299 {"marmv5e", &legacy_cpu, ARM_ARCH_V5TE, N_("use -march=armv5te")},
24301 /* Floating point variants -- don't add any more to this list either. */
24302 {"mfpe-old", &legacy_fpu, FPU_ARCH_FPE, N_("use -mfpu=fpe")},
24303 {"mfpa10", &legacy_fpu, FPU_ARCH_FPA, N_("use -mfpu=fpa10")},
24304 {"mfpa11", &legacy_fpu, FPU_ARCH_FPA, N_("use -mfpu=fpa11")},
24305 {"mno-fpu", &legacy_fpu, ARM_ARCH_NONE,
24306 N_("use either -mfpu=softfpa or -mfpu=softvfp")},
24308 {NULL, NULL, ARM_ARCH_NONE, NULL}
24311 struct arm_cpu_option_table
24315 const arm_feature_set value;
24316 /* For some CPUs we assume an FPU unless the user explicitly sets
24318 const arm_feature_set default_fpu;
24319 /* The canonical name of the CPU, or NULL to use NAME converted to upper
24321 const char *canonical_name;
24324 /* This list should, at a minimum, contain all the cpu names
24325 recognized by GCC. */
24326 #define ARM_CPU_OPT(N, V, DF, CN) { N, sizeof (N) - 1, V, DF, CN }
24327 static const struct arm_cpu_option_table arm_cpus[] =
24329 ARM_CPU_OPT ("all", ARM_ANY, FPU_ARCH_FPA, NULL),
24330 ARM_CPU_OPT ("arm1", ARM_ARCH_V1, FPU_ARCH_FPA, NULL),
24331 ARM_CPU_OPT ("arm2", ARM_ARCH_V2, FPU_ARCH_FPA, NULL),
24332 ARM_CPU_OPT ("arm250", ARM_ARCH_V2S, FPU_ARCH_FPA, NULL),
24333 ARM_CPU_OPT ("arm3", ARM_ARCH_V2S, FPU_ARCH_FPA, NULL),
24334 ARM_CPU_OPT ("arm6", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24335 ARM_CPU_OPT ("arm60", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24336 ARM_CPU_OPT ("arm600", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24337 ARM_CPU_OPT ("arm610", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24338 ARM_CPU_OPT ("arm620", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24339 ARM_CPU_OPT ("arm7", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24340 ARM_CPU_OPT ("arm7m", ARM_ARCH_V3M, FPU_ARCH_FPA, NULL),
24341 ARM_CPU_OPT ("arm7d", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24342 ARM_CPU_OPT ("arm7dm", ARM_ARCH_V3M, FPU_ARCH_FPA, NULL),
24343 ARM_CPU_OPT ("arm7di", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24344 ARM_CPU_OPT ("arm7dmi", ARM_ARCH_V3M, FPU_ARCH_FPA, NULL),
24345 ARM_CPU_OPT ("arm70", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24346 ARM_CPU_OPT ("arm700", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24347 ARM_CPU_OPT ("arm700i", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24348 ARM_CPU_OPT ("arm710", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24349 ARM_CPU_OPT ("arm710t", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24350 ARM_CPU_OPT ("arm720", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24351 ARM_CPU_OPT ("arm720t", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24352 ARM_CPU_OPT ("arm740t", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24353 ARM_CPU_OPT ("arm710c", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24354 ARM_CPU_OPT ("arm7100", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24355 ARM_CPU_OPT ("arm7500", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24356 ARM_CPU_OPT ("arm7500fe", ARM_ARCH_V3, FPU_ARCH_FPA, NULL),
24357 ARM_CPU_OPT ("arm7t", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24358 ARM_CPU_OPT ("arm7tdmi", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24359 ARM_CPU_OPT ("arm7tdmi-s", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24360 ARM_CPU_OPT ("arm8", ARM_ARCH_V4, FPU_ARCH_FPA, NULL),
24361 ARM_CPU_OPT ("arm810", ARM_ARCH_V4, FPU_ARCH_FPA, NULL),
24362 ARM_CPU_OPT ("strongarm", ARM_ARCH_V4, FPU_ARCH_FPA, NULL),
24363 ARM_CPU_OPT ("strongarm1", ARM_ARCH_V4, FPU_ARCH_FPA, NULL),
24364 ARM_CPU_OPT ("strongarm110", ARM_ARCH_V4, FPU_ARCH_FPA, NULL),
24365 ARM_CPU_OPT ("strongarm1100", ARM_ARCH_V4, FPU_ARCH_FPA, NULL),
24366 ARM_CPU_OPT ("strongarm1110", ARM_ARCH_V4, FPU_ARCH_FPA, NULL),
24367 ARM_CPU_OPT ("arm9", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24368 ARM_CPU_OPT ("arm920", ARM_ARCH_V4T, FPU_ARCH_FPA, "ARM920T"),
24369 ARM_CPU_OPT ("arm920t", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24370 ARM_CPU_OPT ("arm922t", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24371 ARM_CPU_OPT ("arm940t", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24372 ARM_CPU_OPT ("arm9tdmi", ARM_ARCH_V4T, FPU_ARCH_FPA, NULL),
24373 ARM_CPU_OPT ("fa526", ARM_ARCH_V4, FPU_ARCH_FPA, NULL),
24374 ARM_CPU_OPT ("fa626", ARM_ARCH_V4, FPU_ARCH_FPA, NULL),
24375 /* For V5 or later processors we default to using VFP; but the user
24376 should really set the FPU type explicitly. */
24377 ARM_CPU_OPT ("arm9e-r0", ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2, NULL),
24378 ARM_CPU_OPT ("arm9e", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24379 ARM_CPU_OPT ("arm926ej", ARM_ARCH_V5TEJ, FPU_ARCH_VFP_V2, "ARM926EJ-S"),
24380 ARM_CPU_OPT ("arm926ejs", ARM_ARCH_V5TEJ, FPU_ARCH_VFP_V2, "ARM926EJ-S"),
24381 ARM_CPU_OPT ("arm926ej-s", ARM_ARCH_V5TEJ, FPU_ARCH_VFP_V2, NULL),
24382 ARM_CPU_OPT ("arm946e-r0", ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2, NULL),
24383 ARM_CPU_OPT ("arm946e", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, "ARM946E-S"),
24384 ARM_CPU_OPT ("arm946e-s", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24385 ARM_CPU_OPT ("arm966e-r0", ARM_ARCH_V5TExP, FPU_ARCH_VFP_V2, NULL),
24386 ARM_CPU_OPT ("arm966e", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, "ARM966E-S"),
24387 ARM_CPU_OPT ("arm966e-s", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24388 ARM_CPU_OPT ("arm968e-s", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24389 ARM_CPU_OPT ("arm10t", ARM_ARCH_V5T, FPU_ARCH_VFP_V1, NULL),
24390 ARM_CPU_OPT ("arm10tdmi", ARM_ARCH_V5T, FPU_ARCH_VFP_V1, NULL),
24391 ARM_CPU_OPT ("arm10e", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24392 ARM_CPU_OPT ("arm1020", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, "ARM1020E"),
24393 ARM_CPU_OPT ("arm1020t", ARM_ARCH_V5T, FPU_ARCH_VFP_V1, NULL),
24394 ARM_CPU_OPT ("arm1020e", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24395 ARM_CPU_OPT ("arm1022e", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24396 ARM_CPU_OPT ("arm1026ejs", ARM_ARCH_V5TEJ, FPU_ARCH_VFP_V2,
24398 ARM_CPU_OPT ("arm1026ej-s", ARM_ARCH_V5TEJ, FPU_ARCH_VFP_V2, NULL),
24399 ARM_CPU_OPT ("fa606te", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24400 ARM_CPU_OPT ("fa616te", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24401 ARM_CPU_OPT ("fa626te", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24402 ARM_CPU_OPT ("fmp626", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24403 ARM_CPU_OPT ("fa726te", ARM_ARCH_V5TE, FPU_ARCH_VFP_V2, NULL),
24404 ARM_CPU_OPT ("arm1136js", ARM_ARCH_V6, FPU_NONE, "ARM1136J-S"),
24405 ARM_CPU_OPT ("arm1136j-s", ARM_ARCH_V6, FPU_NONE, NULL),
24406 ARM_CPU_OPT ("arm1136jfs", ARM_ARCH_V6, FPU_ARCH_VFP_V2,
24408 ARM_CPU_OPT ("arm1136jf-s", ARM_ARCH_V6, FPU_ARCH_VFP_V2, NULL),
24409 ARM_CPU_OPT ("mpcore", ARM_ARCH_V6K, FPU_ARCH_VFP_V2, "MPCore"),
24410 ARM_CPU_OPT ("mpcorenovfp", ARM_ARCH_V6K, FPU_NONE, "MPCore"),
24411 ARM_CPU_OPT ("arm1156t2-s", ARM_ARCH_V6T2, FPU_NONE, NULL),
24412 ARM_CPU_OPT ("arm1156t2f-s", ARM_ARCH_V6T2, FPU_ARCH_VFP_V2, NULL),
24413 ARM_CPU_OPT ("arm1176jz-s", ARM_ARCH_V6ZK, FPU_NONE, NULL),
24414 ARM_CPU_OPT ("arm1176jzf-s", ARM_ARCH_V6ZK, FPU_ARCH_VFP_V2, NULL),
24415 ARM_CPU_OPT ("cortex-a5", ARM_ARCH_V7A_MP_SEC,
24416 FPU_NONE, "Cortex-A5"),
24417 ARM_CPU_OPT ("cortex-a7", ARM_ARCH_V7VE, FPU_ARCH_NEON_VFP_V4,
24419 ARM_CPU_OPT ("cortex-a8", ARM_ARCH_V7A_SEC,
24420 ARM_FEATURE (0, FPU_VFP_V3
24421 | FPU_NEON_EXT_V1),
24423 ARM_CPU_OPT ("cortex-a9", ARM_ARCH_V7A_MP_SEC,
24424 ARM_FEATURE (0, FPU_VFP_V3
24425 | FPU_NEON_EXT_V1),
24427 ARM_CPU_OPT ("cortex-a12", ARM_ARCH_V7VE, FPU_ARCH_NEON_VFP_V4,
24429 ARM_CPU_OPT ("cortex-a15", ARM_ARCH_V7VE, FPU_ARCH_NEON_VFP_V4,
24431 ARM_CPU_OPT ("cortex-a17", ARM_ARCH_V7VE, FPU_ARCH_NEON_VFP_V4,
24433 ARM_CPU_OPT ("cortex-a53", ARM_ARCH_V8A, FPU_ARCH_CRYPTO_NEON_VFP_ARMV8,
24435 ARM_CPU_OPT ("cortex-a57", ARM_ARCH_V8A, FPU_ARCH_CRYPTO_NEON_VFP_ARMV8,
24437 ARM_CPU_OPT ("cortex-r4", ARM_ARCH_V7R, FPU_NONE, "Cortex-R4"),
24438 ARM_CPU_OPT ("cortex-r4f", ARM_ARCH_V7R, FPU_ARCH_VFP_V3D16,
24440 ARM_CPU_OPT ("cortex-r5", ARM_ARCH_V7R_IDIV,
24441 FPU_NONE, "Cortex-R5"),
24442 ARM_CPU_OPT ("cortex-r7", ARM_ARCH_V7R_IDIV,
24443 FPU_ARCH_VFP_V3D16,
24445 ARM_CPU_OPT ("cortex-m7", ARM_ARCH_V7EM, FPU_NONE, "Cortex-M7"),
24446 ARM_CPU_OPT ("cortex-m4", ARM_ARCH_V7EM, FPU_NONE, "Cortex-M4"),
24447 ARM_CPU_OPT ("cortex-m3", ARM_ARCH_V7M, FPU_NONE, "Cortex-M3"),
24448 ARM_CPU_OPT ("cortex-m1", ARM_ARCH_V6SM, FPU_NONE, "Cortex-M1"),
24449 ARM_CPU_OPT ("cortex-m0", ARM_ARCH_V6SM, FPU_NONE, "Cortex-M0"),
24450 ARM_CPU_OPT ("cortex-m0plus", ARM_ARCH_V6SM, FPU_NONE, "Cortex-M0+"),
24451 /* ??? XSCALE is really an architecture. */
24452 ARM_CPU_OPT ("xscale", ARM_ARCH_XSCALE, FPU_ARCH_VFP_V2, NULL),
24453 /* ??? iwmmxt is not a processor. */
24454 ARM_CPU_OPT ("iwmmxt", ARM_ARCH_IWMMXT, FPU_ARCH_VFP_V2, NULL),
24455 ARM_CPU_OPT ("iwmmxt2", ARM_ARCH_IWMMXT2,FPU_ARCH_VFP_V2, NULL),
24456 ARM_CPU_OPT ("i80200", ARM_ARCH_XSCALE, FPU_ARCH_VFP_V2, NULL),
24458 ARM_CPU_OPT ("ep9312", ARM_FEATURE (ARM_AEXT_V4T, ARM_CEXT_MAVERICK),
24459 FPU_ARCH_MAVERICK, "ARM920T"),
24460 /* Marvell processors. */
24461 ARM_CPU_OPT ("marvell-pj4", ARM_FEATURE (ARM_AEXT_V7A | ARM_EXT_MP | ARM_EXT_SEC, 0),
24462 FPU_ARCH_VFP_V3D16, NULL),
24463 ARM_CPU_OPT ("marvell-whitney", ARM_FEATURE (ARM_AEXT_V7A | ARM_EXT_MP
24465 FPU_ARCH_NEON_VFP_V4, NULL),
24467 { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE, NULL }
24471 struct arm_arch_option_table
24475 const arm_feature_set value;
24476 const arm_feature_set default_fpu;
24479 /* This list should, at a minimum, contain all the architecture names
24480 recognized by GCC. */
24481 #define ARM_ARCH_OPT(N, V, DF) { N, sizeof (N) - 1, V, DF }
24482 static const struct arm_arch_option_table arm_archs[] =
24484 ARM_ARCH_OPT ("all", ARM_ANY, FPU_ARCH_FPA),
24485 ARM_ARCH_OPT ("armv1", ARM_ARCH_V1, FPU_ARCH_FPA),
24486 ARM_ARCH_OPT ("armv2", ARM_ARCH_V2, FPU_ARCH_FPA),
24487 ARM_ARCH_OPT ("armv2a", ARM_ARCH_V2S, FPU_ARCH_FPA),
24488 ARM_ARCH_OPT ("armv2s", ARM_ARCH_V2S, FPU_ARCH_FPA),
24489 ARM_ARCH_OPT ("armv3", ARM_ARCH_V3, FPU_ARCH_FPA),
24490 ARM_ARCH_OPT ("armv3m", ARM_ARCH_V3M, FPU_ARCH_FPA),
24491 ARM_ARCH_OPT ("armv4", ARM_ARCH_V4, FPU_ARCH_FPA),
24492 ARM_ARCH_OPT ("armv4xm", ARM_ARCH_V4xM, FPU_ARCH_FPA),
24493 ARM_ARCH_OPT ("armv4t", ARM_ARCH_V4T, FPU_ARCH_FPA),
24494 ARM_ARCH_OPT ("armv4txm", ARM_ARCH_V4TxM, FPU_ARCH_FPA),
24495 ARM_ARCH_OPT ("armv5", ARM_ARCH_V5, FPU_ARCH_VFP),
24496 ARM_ARCH_OPT ("armv5t", ARM_ARCH_V5T, FPU_ARCH_VFP),
24497 ARM_ARCH_OPT ("armv5txm", ARM_ARCH_V5TxM, FPU_ARCH_VFP),
24498 ARM_ARCH_OPT ("armv5te", ARM_ARCH_V5TE, FPU_ARCH_VFP),
24499 ARM_ARCH_OPT ("armv5texp", ARM_ARCH_V5TExP, FPU_ARCH_VFP),
24500 ARM_ARCH_OPT ("armv5tej", ARM_ARCH_V5TEJ, FPU_ARCH_VFP),
24501 ARM_ARCH_OPT ("armv6", ARM_ARCH_V6, FPU_ARCH_VFP),
24502 ARM_ARCH_OPT ("armv6j", ARM_ARCH_V6, FPU_ARCH_VFP),
24503 ARM_ARCH_OPT ("armv6k", ARM_ARCH_V6K, FPU_ARCH_VFP),
24504 ARM_ARCH_OPT ("armv6z", ARM_ARCH_V6Z, FPU_ARCH_VFP),
24505 ARM_ARCH_OPT ("armv6zk", ARM_ARCH_V6ZK, FPU_ARCH_VFP),
24506 ARM_ARCH_OPT ("armv6t2", ARM_ARCH_V6T2, FPU_ARCH_VFP),
24507 ARM_ARCH_OPT ("armv6kt2", ARM_ARCH_V6KT2, FPU_ARCH_VFP),
24508 ARM_ARCH_OPT ("armv6zt2", ARM_ARCH_V6ZT2, FPU_ARCH_VFP),
24509 ARM_ARCH_OPT ("armv6zkt2", ARM_ARCH_V6ZKT2, FPU_ARCH_VFP),
24510 ARM_ARCH_OPT ("armv6-m", ARM_ARCH_V6M, FPU_ARCH_VFP),
24511 ARM_ARCH_OPT ("armv6s-m", ARM_ARCH_V6SM, FPU_ARCH_VFP),
24512 ARM_ARCH_OPT ("armv7", ARM_ARCH_V7, FPU_ARCH_VFP),
24513 /* The official spelling of the ARMv7 profile variants is the dashed form.
24514 Accept the non-dashed form for compatibility with old toolchains. */
24515 ARM_ARCH_OPT ("armv7a", ARM_ARCH_V7A, FPU_ARCH_VFP),
24516 ARM_ARCH_OPT ("armv7ve", ARM_ARCH_V7VE, FPU_ARCH_VFP),
24517 ARM_ARCH_OPT ("armv7r", ARM_ARCH_V7R, FPU_ARCH_VFP),
24518 ARM_ARCH_OPT ("armv7m", ARM_ARCH_V7M, FPU_ARCH_VFP),
24519 ARM_ARCH_OPT ("armv7-a", ARM_ARCH_V7A, FPU_ARCH_VFP),
24520 ARM_ARCH_OPT ("armv7-r", ARM_ARCH_V7R, FPU_ARCH_VFP),
24521 ARM_ARCH_OPT ("armv7-m", ARM_ARCH_V7M, FPU_ARCH_VFP),
24522 ARM_ARCH_OPT ("armv7e-m", ARM_ARCH_V7EM, FPU_ARCH_VFP),
24523 ARM_ARCH_OPT ("armv8-a", ARM_ARCH_V8A, FPU_ARCH_VFP),
24524 ARM_ARCH_OPT ("xscale", ARM_ARCH_XSCALE, FPU_ARCH_VFP),
24525 ARM_ARCH_OPT ("iwmmxt", ARM_ARCH_IWMMXT, FPU_ARCH_VFP),
24526 ARM_ARCH_OPT ("iwmmxt2", ARM_ARCH_IWMMXT2,FPU_ARCH_VFP),
24527 { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
24529 #undef ARM_ARCH_OPT
24531 /* ISA extensions in the co-processor and main instruction set space. */
24532 struct arm_option_extension_value_table
24536 const arm_feature_set value;
24537 const arm_feature_set allowed_archs;
24540 /* The following table must be in alphabetical order with a NULL last entry.
24542 #define ARM_EXT_OPT(N, V, AA) { N, sizeof (N) - 1, V, AA }
24543 static const struct arm_option_extension_value_table arm_extensions[] =
24545 ARM_EXT_OPT ("crc", ARCH_CRC_ARMV8, ARM_FEATURE (ARM_EXT_V8, 0)),
24546 ARM_EXT_OPT ("crypto", FPU_ARCH_CRYPTO_NEON_VFP_ARMV8,
24547 ARM_FEATURE (ARM_EXT_V8, 0)),
24548 ARM_EXT_OPT ("fp", FPU_ARCH_VFP_ARMV8,
24549 ARM_FEATURE (ARM_EXT_V8, 0)),
24550 ARM_EXT_OPT ("idiv", ARM_FEATURE (ARM_EXT_ADIV | ARM_EXT_DIV, 0),
24551 ARM_FEATURE (ARM_EXT_V7A | ARM_EXT_V7R, 0)),
24552 ARM_EXT_OPT ("iwmmxt",ARM_FEATURE (0, ARM_CEXT_IWMMXT), ARM_ANY),
24553 ARM_EXT_OPT ("iwmmxt2",
24554 ARM_FEATURE (0, ARM_CEXT_IWMMXT2), ARM_ANY),
24555 ARM_EXT_OPT ("maverick",
24556 ARM_FEATURE (0, ARM_CEXT_MAVERICK), ARM_ANY),
24557 ARM_EXT_OPT ("mp", ARM_FEATURE (ARM_EXT_MP, 0),
24558 ARM_FEATURE (ARM_EXT_V7A | ARM_EXT_V7R, 0)),
24559 ARM_EXT_OPT ("simd", FPU_ARCH_NEON_VFP_ARMV8,
24560 ARM_FEATURE (ARM_EXT_V8, 0)),
24561 ARM_EXT_OPT ("os", ARM_FEATURE (ARM_EXT_OS, 0),
24562 ARM_FEATURE (ARM_EXT_V6M, 0)),
24563 ARM_EXT_OPT ("sec", ARM_FEATURE (ARM_EXT_SEC, 0),
24564 ARM_FEATURE (ARM_EXT_V6K | ARM_EXT_V7A, 0)),
24565 ARM_EXT_OPT ("virt", ARM_FEATURE (ARM_EXT_VIRT | ARM_EXT_ADIV
24567 ARM_FEATURE (ARM_EXT_V7A, 0)),
24568 ARM_EXT_OPT ("xscale",ARM_FEATURE (0, ARM_CEXT_XSCALE), ARM_ANY),
24569 { NULL, 0, ARM_ARCH_NONE, ARM_ARCH_NONE }
24573 /* ISA floating-point and Advanced SIMD extensions. */
24574 struct arm_option_fpu_value_table
24577 const arm_feature_set value;
24580 /* This list should, at a minimum, contain all the fpu names
24581 recognized by GCC. */
24582 static const struct arm_option_fpu_value_table arm_fpus[] =
24584 {"softfpa", FPU_NONE},
24585 {"fpe", FPU_ARCH_FPE},
24586 {"fpe2", FPU_ARCH_FPE},
24587 {"fpe3", FPU_ARCH_FPA}, /* Third release supports LFM/SFM. */
24588 {"fpa", FPU_ARCH_FPA},
24589 {"fpa10", FPU_ARCH_FPA},
24590 {"fpa11", FPU_ARCH_FPA},
24591 {"arm7500fe", FPU_ARCH_FPA},
24592 {"softvfp", FPU_ARCH_VFP},
24593 {"softvfp+vfp", FPU_ARCH_VFP_V2},
24594 {"vfp", FPU_ARCH_VFP_V2},
24595 {"vfp9", FPU_ARCH_VFP_V2},
24596 {"vfp3", FPU_ARCH_VFP_V3}, /* For backwards compatbility. */
24597 {"vfp10", FPU_ARCH_VFP_V2},
24598 {"vfp10-r0", FPU_ARCH_VFP_V1},
24599 {"vfpxd", FPU_ARCH_VFP_V1xD},
24600 {"vfpv2", FPU_ARCH_VFP_V2},
24601 {"vfpv3", FPU_ARCH_VFP_V3},
24602 {"vfpv3-fp16", FPU_ARCH_VFP_V3_FP16},
24603 {"vfpv3-d16", FPU_ARCH_VFP_V3D16},
24604 {"vfpv3-d16-fp16", FPU_ARCH_VFP_V3D16_FP16},
24605 {"vfpv3xd", FPU_ARCH_VFP_V3xD},
24606 {"vfpv3xd-fp16", FPU_ARCH_VFP_V3xD_FP16},
24607 {"arm1020t", FPU_ARCH_VFP_V1},
24608 {"arm1020e", FPU_ARCH_VFP_V2},
24609 {"arm1136jfs", FPU_ARCH_VFP_V2},
24610 {"arm1136jf-s", FPU_ARCH_VFP_V2},
24611 {"maverick", FPU_ARCH_MAVERICK},
24612 {"neon", FPU_ARCH_VFP_V3_PLUS_NEON_V1},
24613 {"neon-fp16", FPU_ARCH_NEON_FP16},
24614 {"vfpv4", FPU_ARCH_VFP_V4},
24615 {"vfpv4-d16", FPU_ARCH_VFP_V4D16},
24616 {"fpv4-sp-d16", FPU_ARCH_VFP_V4_SP_D16},
24617 {"fpv5-d16", FPU_ARCH_VFP_V5D16},
24618 {"fpv5-sp-d16", FPU_ARCH_VFP_V5_SP_D16},
24619 {"neon-vfpv4", FPU_ARCH_NEON_VFP_V4},
24620 {"fp-armv8", FPU_ARCH_VFP_ARMV8},
24621 {"neon-fp-armv8", FPU_ARCH_NEON_VFP_ARMV8},
24622 {"crypto-neon-fp-armv8",
24623 FPU_ARCH_CRYPTO_NEON_VFP_ARMV8},
24624 {NULL, ARM_ARCH_NONE}
24627 struct arm_option_value_table
24633 static const struct arm_option_value_table arm_float_abis[] =
24635 {"hard", ARM_FLOAT_ABI_HARD},
24636 {"softfp", ARM_FLOAT_ABI_SOFTFP},
24637 {"soft", ARM_FLOAT_ABI_SOFT},
24642 /* We only know how to output GNU and ver 4/5 (AAELF) formats. */
24643 static const struct arm_option_value_table arm_eabis[] =
24645 {"gnu", EF_ARM_EABI_UNKNOWN},
24646 {"4", EF_ARM_EABI_VER4},
24647 {"5", EF_ARM_EABI_VER5},
24652 struct arm_long_option_table
24654 char * option; /* Substring to match. */
24655 char * help; /* Help information. */
24656 int (* func) (char * subopt); /* Function to decode sub-option. */
24657 char * deprecated; /* If non-null, print this message. */
24661 arm_parse_extension (char *str, const arm_feature_set **opt_p)
24663 arm_feature_set *ext_set = (arm_feature_set *)
24664 xmalloc (sizeof (arm_feature_set));
24666 /* We insist on extensions being specified in alphabetical order, and with
24667 extensions being added before being removed. We achieve this by having
24668 the global ARM_EXTENSIONS table in alphabetical order, and using the
24669 ADDING_VALUE variable to indicate whether we are adding an extension (1)
24670 or removing it (0) and only allowing it to change in the order
24672 const struct arm_option_extension_value_table * opt = NULL;
24673 int adding_value = -1;
24675 /* Copy the feature set, so that we can modify it. */
24676 *ext_set = **opt_p;
24679 while (str != NULL && *str != 0)
24686 as_bad (_("invalid architectural extension"));
24691 ext = strchr (str, '+');
24696 len = strlen (str);
24698 if (len >= 2 && strncmp (str, "no", 2) == 0)
24700 if (adding_value != 0)
24703 opt = arm_extensions;
24711 if (adding_value == -1)
24714 opt = arm_extensions;
24716 else if (adding_value != 1)
24718 as_bad (_("must specify extensions to add before specifying "
24719 "those to remove"));
24726 as_bad (_("missing architectural extension"));
24730 gas_assert (adding_value != -1);
24731 gas_assert (opt != NULL);
24733 /* Scan over the options table trying to find an exact match. */
24734 for (; opt->name != NULL; opt++)
24735 if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
24737 /* Check we can apply the extension to this architecture. */
24738 if (!ARM_CPU_HAS_FEATURE (*ext_set, opt->allowed_archs))
24740 as_bad (_("extension does not apply to the base architecture"));
24744 /* Add or remove the extension. */
24746 ARM_MERGE_FEATURE_SETS (*ext_set, *ext_set, opt->value);
24748 ARM_CLEAR_FEATURE (*ext_set, *ext_set, opt->value);
24753 if (opt->name == NULL)
24755 /* Did we fail to find an extension because it wasn't specified in
24756 alphabetical order, or because it does not exist? */
24758 for (opt = arm_extensions; opt->name != NULL; opt++)
24759 if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
24762 if (opt->name == NULL)
24763 as_bad (_("unknown architectural extension `%s'"), str);
24765 as_bad (_("architectural extensions must be specified in "
24766 "alphabetical order"));
24772 /* We should skip the extension we've just matched the next time
24784 arm_parse_cpu (char *str)
24786 const struct arm_cpu_option_table *opt;
24787 char *ext = strchr (str, '+');
24793 len = strlen (str);
24797 as_bad (_("missing cpu name `%s'"), str);
24801 for (opt = arm_cpus; opt->name != NULL; opt++)
24802 if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
24804 mcpu_cpu_opt = &opt->value;
24805 mcpu_fpu_opt = &opt->default_fpu;
24806 if (opt->canonical_name)
24807 strcpy (selected_cpu_name, opt->canonical_name);
24812 for (i = 0; i < len; i++)
24813 selected_cpu_name[i] = TOUPPER (opt->name[i]);
24814 selected_cpu_name[i] = 0;
24818 return arm_parse_extension (ext, &mcpu_cpu_opt);
24823 as_bad (_("unknown cpu `%s'"), str);
24828 arm_parse_arch (char *str)
24830 const struct arm_arch_option_table *opt;
24831 char *ext = strchr (str, '+');
24837 len = strlen (str);
24841 as_bad (_("missing architecture name `%s'"), str);
24845 for (opt = arm_archs; opt->name != NULL; opt++)
24846 if (opt->name_len == len && strncmp (opt->name, str, len) == 0)
24848 march_cpu_opt = &opt->value;
24849 march_fpu_opt = &opt->default_fpu;
24850 strcpy (selected_cpu_name, opt->name);
24853 return arm_parse_extension (ext, &march_cpu_opt);
24858 as_bad (_("unknown architecture `%s'\n"), str);
24863 arm_parse_fpu (char * str)
24865 const struct arm_option_fpu_value_table * opt;
24867 for (opt = arm_fpus; opt->name != NULL; opt++)
24868 if (streq (opt->name, str))
24870 mfpu_opt = &opt->value;
24874 as_bad (_("unknown floating point format `%s'\n"), str);
24879 arm_parse_float_abi (char * str)
24881 const struct arm_option_value_table * opt;
24883 for (opt = arm_float_abis; opt->name != NULL; opt++)
24884 if (streq (opt->name, str))
24886 mfloat_abi_opt = opt->value;
24890 as_bad (_("unknown floating point abi `%s'\n"), str);
24896 arm_parse_eabi (char * str)
24898 const struct arm_option_value_table *opt;
24900 for (opt = arm_eabis; opt->name != NULL; opt++)
24901 if (streq (opt->name, str))
24903 meabi_flags = opt->value;
24906 as_bad (_("unknown EABI `%s'\n"), str);
24912 arm_parse_it_mode (char * str)
24914 bfd_boolean ret = TRUE;
24916 if (streq ("arm", str))
24917 implicit_it_mode = IMPLICIT_IT_MODE_ARM;
24918 else if (streq ("thumb", str))
24919 implicit_it_mode = IMPLICIT_IT_MODE_THUMB;
24920 else if (streq ("always", str))
24921 implicit_it_mode = IMPLICIT_IT_MODE_ALWAYS;
24922 else if (streq ("never", str))
24923 implicit_it_mode = IMPLICIT_IT_MODE_NEVER;
24926 as_bad (_("unknown implicit IT mode `%s', should be "\
24927 "arm, thumb, always, or never."), str);
24935 arm_ccs_mode (char * unused ATTRIBUTE_UNUSED)
24937 codecomposer_syntax = TRUE;
24938 arm_comment_chars[0] = ';';
24939 arm_line_separator_chars[0] = 0;
24943 struct arm_long_option_table arm_long_opts[] =
24945 {"mcpu=", N_("<cpu name>\t assemble for CPU <cpu name>"),
24946 arm_parse_cpu, NULL},
24947 {"march=", N_("<arch name>\t assemble for architecture <arch name>"),
24948 arm_parse_arch, NULL},
24949 {"mfpu=", N_("<fpu name>\t assemble for FPU architecture <fpu name>"),
24950 arm_parse_fpu, NULL},
24951 {"mfloat-abi=", N_("<abi>\t assemble for floating point ABI <abi>"),
24952 arm_parse_float_abi, NULL},
24954 {"meabi=", N_("<ver>\t\t assemble for eabi version <ver>"),
24955 arm_parse_eabi, NULL},
24957 {"mimplicit-it=", N_("<mode>\t controls implicit insertion of IT instructions"),
24958 arm_parse_it_mode, NULL},
24959 {"mccs", N_("\t\t\t TI CodeComposer Studio syntax compatibility mode"),
24960 arm_ccs_mode, NULL},
24961 {NULL, NULL, 0, NULL}
24965 md_parse_option (int c, char * arg)
24967 struct arm_option_table *opt;
24968 const struct arm_legacy_option_table *fopt;
24969 struct arm_long_option_table *lopt;
24975 target_big_endian = 1;
24981 target_big_endian = 0;
24985 case OPTION_FIX_V4BX:
24990 /* Listing option. Just ignore these, we don't support additional
24995 for (opt = arm_opts; opt->option != NULL; opt++)
24997 if (c == opt->option[0]
24998 && ((arg == NULL && opt->option[1] == 0)
24999 || streq (arg, opt->option + 1)))
25001 /* If the option is deprecated, tell the user. */
25002 if (warn_on_deprecated && opt->deprecated != NULL)
25003 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c,
25004 arg ? arg : "", _(opt->deprecated));
25006 if (opt->var != NULL)
25007 *opt->var = opt->value;
25013 for (fopt = arm_legacy_opts; fopt->option != NULL; fopt++)
25015 if (c == fopt->option[0]
25016 && ((arg == NULL && fopt->option[1] == 0)
25017 || streq (arg, fopt->option + 1)))
25019 /* If the option is deprecated, tell the user. */
25020 if (warn_on_deprecated && fopt->deprecated != NULL)
25021 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c,
25022 arg ? arg : "", _(fopt->deprecated));
25024 if (fopt->var != NULL)
25025 *fopt->var = &fopt->value;
25031 for (lopt = arm_long_opts; lopt->option != NULL; lopt++)
25033 /* These options are expected to have an argument. */
25034 if (c == lopt->option[0]
25036 && strncmp (arg, lopt->option + 1,
25037 strlen (lopt->option + 1)) == 0)
25039 /* If the option is deprecated, tell the user. */
25040 if (warn_on_deprecated && lopt->deprecated != NULL)
25041 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c, arg,
25042 _(lopt->deprecated));
25044 /* Call the sup-option parser. */
25045 return lopt->func (arg + strlen (lopt->option) - 1);
25056 md_show_usage (FILE * fp)
25058 struct arm_option_table *opt;
25059 struct arm_long_option_table *lopt;
25061 fprintf (fp, _(" ARM-specific assembler options:\n"));
25063 for (opt = arm_opts; opt->option != NULL; opt++)
25064 if (opt->help != NULL)
25065 fprintf (fp, " -%-23s%s\n", opt->option, _(opt->help));
25067 for (lopt = arm_long_opts; lopt->option != NULL; lopt++)
25068 if (lopt->help != NULL)
25069 fprintf (fp, " -%s%s\n", lopt->option, _(lopt->help));
25073 -EB assemble code for a big-endian cpu\n"));
25078 -EL assemble code for a little-endian cpu\n"));
25082 --fix-v4bx Allow BX in ARMv4 code\n"));
25090 arm_feature_set flags;
25091 } cpu_arch_ver_table;
25093 /* Mapping from CPU features to EABI CPU arch values. Table must be sorted
25094 least features first. */
25095 static const cpu_arch_ver_table cpu_arch_ver[] =
25101 {4, ARM_ARCH_V5TE},
25102 {5, ARM_ARCH_V5TEJ},
25106 {11, ARM_ARCH_V6M},
25107 {12, ARM_ARCH_V6SM},
25108 {8, ARM_ARCH_V6T2},
25109 {10, ARM_ARCH_V7VE},
25110 {10, ARM_ARCH_V7R},
25111 {10, ARM_ARCH_V7M},
25112 {14, ARM_ARCH_V8A},
25116 /* Set an attribute if it has not already been set by the user. */
25118 aeabi_set_attribute_int (int tag, int value)
25121 || tag >= NUM_KNOWN_OBJ_ATTRIBUTES
25122 || !attributes_set_explicitly[tag])
25123 bfd_elf_add_proc_attr_int (stdoutput, tag, value);
25127 aeabi_set_attribute_string (int tag, const char *value)
25130 || tag >= NUM_KNOWN_OBJ_ATTRIBUTES
25131 || !attributes_set_explicitly[tag])
25132 bfd_elf_add_proc_attr_string (stdoutput, tag, value);
25135 /* Set the public EABI object attributes. */
25137 aeabi_set_public_attributes (void)
25142 int fp16_optional = 0;
25143 arm_feature_set flags;
25144 arm_feature_set tmp;
25145 const cpu_arch_ver_table *p;
25147 /* Choose the architecture based on the capabilities of the requested cpu
25148 (if any) and/or the instructions actually used. */
25149 ARM_MERGE_FEATURE_SETS (flags, arm_arch_used, thumb_arch_used);
25150 ARM_MERGE_FEATURE_SETS (flags, flags, *mfpu_opt);
25151 ARM_MERGE_FEATURE_SETS (flags, flags, selected_cpu);
25153 if (ARM_CPU_HAS_FEATURE (arm_arch_used, arm_arch_any))
25154 ARM_MERGE_FEATURE_SETS (flags, flags, arm_ext_v1);
25156 if (ARM_CPU_HAS_FEATURE (thumb_arch_used, arm_arch_any))
25157 ARM_MERGE_FEATURE_SETS (flags, flags, arm_ext_v4t);
25159 selected_cpu = flags;
25161 /* Allow the user to override the reported architecture. */
25164 ARM_CLEAR_FEATURE (flags, flags, arm_arch_any);
25165 ARM_MERGE_FEATURE_SETS (flags, flags, *object_arch);
25168 /* We need to make sure that the attributes do not identify us as v6S-M
25169 when the only v6S-M feature in use is the Operating System Extensions. */
25170 if (ARM_CPU_HAS_FEATURE (flags, arm_ext_os))
25171 if (!ARM_CPU_HAS_FEATURE (flags, arm_arch_v6m_only))
25172 ARM_CLEAR_FEATURE (flags, flags, arm_ext_os);
25176 for (p = cpu_arch_ver; p->val; p++)
25178 if (ARM_CPU_HAS_FEATURE (tmp, p->flags))
25181 ARM_CLEAR_FEATURE (tmp, tmp, p->flags);
25185 /* The table lookup above finds the last architecture to contribute
25186 a new feature. Unfortunately, Tag13 is a subset of the union of
25187 v6T2 and v7-M, so it is never seen as contributing a new feature.
25188 We can not search for the last entry which is entirely used,
25189 because if no CPU is specified we build up only those flags
25190 actually used. Perhaps we should separate out the specified
25191 and implicit cases. Avoid taking this path for -march=all by
25192 checking for contradictory v7-A / v7-M features. */
25194 && !ARM_CPU_HAS_FEATURE (flags, arm_ext_v7a)
25195 && ARM_CPU_HAS_FEATURE (flags, arm_ext_v7m)
25196 && ARM_CPU_HAS_FEATURE (flags, arm_ext_v6_dsp))
25199 /* Tag_CPU_name. */
25200 if (selected_cpu_name[0])
25204 q = selected_cpu_name;
25205 if (strncmp (q, "armv", 4) == 0)
25210 for (i = 0; q[i]; i++)
25211 q[i] = TOUPPER (q[i]);
25213 aeabi_set_attribute_string (Tag_CPU_name, q);
25216 /* Tag_CPU_arch. */
25217 aeabi_set_attribute_int (Tag_CPU_arch, arch);
25219 /* Tag_CPU_arch_profile. */
25220 if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v7a))
25222 else if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v7r))
25224 else if (ARM_CPU_HAS_FEATURE (flags, arm_ext_m))
25229 if (profile != '\0')
25230 aeabi_set_attribute_int (Tag_CPU_arch_profile, profile);
25232 /* Tag_ARM_ISA_use. */
25233 if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v1)
25235 aeabi_set_attribute_int (Tag_ARM_ISA_use, 1);
25237 /* Tag_THUMB_ISA_use. */
25238 if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v4t)
25240 aeabi_set_attribute_int (Tag_THUMB_ISA_use,
25241 ARM_CPU_HAS_FEATURE (flags, arm_arch_t2) ? 2 : 1);
25243 /* Tag_VFP_arch. */
25244 if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_armv8xd))
25245 aeabi_set_attribute_int (Tag_VFP_arch,
25246 ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_d32)
25248 else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_fma))
25249 aeabi_set_attribute_int (Tag_VFP_arch,
25250 ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_d32)
25252 else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_d32))
25255 aeabi_set_attribute_int (Tag_VFP_arch, 3);
25257 else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v3xd))
25259 aeabi_set_attribute_int (Tag_VFP_arch, 4);
25262 else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v2))
25263 aeabi_set_attribute_int (Tag_VFP_arch, 2);
25264 else if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1)
25265 || ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1xd))
25266 aeabi_set_attribute_int (Tag_VFP_arch, 1);
25268 /* Tag_ABI_HardFP_use. */
25269 if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1xd)
25270 && !ARM_CPU_HAS_FEATURE (flags, fpu_vfp_ext_v1))
25271 aeabi_set_attribute_int (Tag_ABI_HardFP_use, 1);
25273 /* Tag_WMMX_arch. */
25274 if (ARM_CPU_HAS_FEATURE (flags, arm_cext_iwmmxt2))
25275 aeabi_set_attribute_int (Tag_WMMX_arch, 2);
25276 else if (ARM_CPU_HAS_FEATURE (flags, arm_cext_iwmmxt))
25277 aeabi_set_attribute_int (Tag_WMMX_arch, 1);
25279 /* Tag_Advanced_SIMD_arch (formerly Tag_NEON_arch). */
25280 if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_armv8))
25281 aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 3);
25282 else if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_v1))
25284 if (ARM_CPU_HAS_FEATURE (flags, fpu_neon_ext_fma))
25286 aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 2);
25290 aeabi_set_attribute_int (Tag_Advanced_SIMD_arch, 1);
25295 /* Tag_VFP_HP_extension (formerly Tag_NEON_FP16_arch). */
25296 if (ARM_CPU_HAS_FEATURE (flags, fpu_vfp_fp16) && fp16_optional)
25297 aeabi_set_attribute_int (Tag_VFP_HP_extension, 1);
25301 We set Tag_DIV_use to two when integer divide instructions have been used
25302 in ARM state, or when Thumb integer divide instructions have been used,
25303 but we have no architecture profile set, nor have we any ARM instructions.
25305 For ARMv8 we set the tag to 0 as integer divide is implied by the base
25308 For new architectures we will have to check these tests. */
25309 gas_assert (arch <= TAG_CPU_ARCH_V8);
25310 if (ARM_CPU_HAS_FEATURE (flags, arm_ext_v8))
25311 aeabi_set_attribute_int (Tag_DIV_use, 0);
25312 else if (ARM_CPU_HAS_FEATURE (flags, arm_ext_adiv)
25313 || (profile == '\0'
25314 && ARM_CPU_HAS_FEATURE (flags, arm_ext_div)
25315 && !ARM_CPU_HAS_FEATURE (arm_arch_used, arm_arch_any)))
25316 aeabi_set_attribute_int (Tag_DIV_use, 2);
25318 /* Tag_MP_extension_use. */
25319 if (ARM_CPU_HAS_FEATURE (flags, arm_ext_mp))
25320 aeabi_set_attribute_int (Tag_MPextension_use, 1);
25322 /* Tag Virtualization_use. */
25323 if (ARM_CPU_HAS_FEATURE (flags, arm_ext_sec))
25325 if (ARM_CPU_HAS_FEATURE (flags, arm_ext_virt))
25328 aeabi_set_attribute_int (Tag_Virtualization_use, virt_sec);
25331 /* Add the default contents for the .ARM.attributes section. */
25335 if (EF_ARM_EABI_VERSION (meabi_flags) < EF_ARM_EABI_VER4)
25338 aeabi_set_public_attributes ();
25340 #endif /* OBJ_ELF */
25343 /* Parse a .cpu directive. */
25346 s_arm_cpu (int ignored ATTRIBUTE_UNUSED)
25348 const struct arm_cpu_option_table *opt;
25352 name = input_line_pointer;
25353 while (*input_line_pointer && !ISSPACE (*input_line_pointer))
25354 input_line_pointer++;
25355 saved_char = *input_line_pointer;
25356 *input_line_pointer = 0;
25358 /* Skip the first "all" entry. */
25359 for (opt = arm_cpus + 1; opt->name != NULL; opt++)
25360 if (streq (opt->name, name))
25362 mcpu_cpu_opt = &opt->value;
25363 selected_cpu = opt->value;
25364 if (opt->canonical_name)
25365 strcpy (selected_cpu_name, opt->canonical_name);
25369 for (i = 0; opt->name[i]; i++)
25370 selected_cpu_name[i] = TOUPPER (opt->name[i]);
25372 selected_cpu_name[i] = 0;
25374 ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
25375 *input_line_pointer = saved_char;
25376 demand_empty_rest_of_line ();
25379 as_bad (_("unknown cpu `%s'"), name);
25380 *input_line_pointer = saved_char;
25381 ignore_rest_of_line ();
25385 /* Parse a .arch directive. */
25388 s_arm_arch (int ignored ATTRIBUTE_UNUSED)
25390 const struct arm_arch_option_table *opt;
25394 name = input_line_pointer;
25395 while (*input_line_pointer && !ISSPACE (*input_line_pointer))
25396 input_line_pointer++;
25397 saved_char = *input_line_pointer;
25398 *input_line_pointer = 0;
25400 /* Skip the first "all" entry. */
25401 for (opt = arm_archs + 1; opt->name != NULL; opt++)
25402 if (streq (opt->name, name))
25404 mcpu_cpu_opt = &opt->value;
25405 selected_cpu = opt->value;
25406 strcpy (selected_cpu_name, opt->name);
25407 ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
25408 *input_line_pointer = saved_char;
25409 demand_empty_rest_of_line ();
25413 as_bad (_("unknown architecture `%s'\n"), name);
25414 *input_line_pointer = saved_char;
25415 ignore_rest_of_line ();
25419 /* Parse a .object_arch directive. */
25422 s_arm_object_arch (int ignored ATTRIBUTE_UNUSED)
25424 const struct arm_arch_option_table *opt;
25428 name = input_line_pointer;
25429 while (*input_line_pointer && !ISSPACE (*input_line_pointer))
25430 input_line_pointer++;
25431 saved_char = *input_line_pointer;
25432 *input_line_pointer = 0;
25434 /* Skip the first "all" entry. */
25435 for (opt = arm_archs + 1; opt->name != NULL; opt++)
25436 if (streq (opt->name, name))
25438 object_arch = &opt->value;
25439 *input_line_pointer = saved_char;
25440 demand_empty_rest_of_line ();
25444 as_bad (_("unknown architecture `%s'\n"), name);
25445 *input_line_pointer = saved_char;
25446 ignore_rest_of_line ();
25449 /* Parse a .arch_extension directive. */
25452 s_arm_arch_extension (int ignored ATTRIBUTE_UNUSED)
25454 const struct arm_option_extension_value_table *opt;
25457 int adding_value = 1;
25459 name = input_line_pointer;
25460 while (*input_line_pointer && !ISSPACE (*input_line_pointer))
25461 input_line_pointer++;
25462 saved_char = *input_line_pointer;
25463 *input_line_pointer = 0;
25465 if (strlen (name) >= 2
25466 && strncmp (name, "no", 2) == 0)
25472 for (opt = arm_extensions; opt->name != NULL; opt++)
25473 if (streq (opt->name, name))
25475 if (!ARM_CPU_HAS_FEATURE (*mcpu_cpu_opt, opt->allowed_archs))
25477 as_bad (_("architectural extension `%s' is not allowed for the "
25478 "current base architecture"), name);
25483 ARM_MERGE_FEATURE_SETS (selected_cpu, selected_cpu, opt->value);
25485 ARM_CLEAR_FEATURE (selected_cpu, selected_cpu, opt->value);
25487 mcpu_cpu_opt = &selected_cpu;
25488 ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
25489 *input_line_pointer = saved_char;
25490 demand_empty_rest_of_line ();
25494 if (opt->name == NULL)
25495 as_bad (_("unknown architecture extension `%s'\n"), name);
25497 *input_line_pointer = saved_char;
25498 ignore_rest_of_line ();
25501 /* Parse a .fpu directive. */
25504 s_arm_fpu (int ignored ATTRIBUTE_UNUSED)
25506 const struct arm_option_fpu_value_table *opt;
25510 name = input_line_pointer;
25511 while (*input_line_pointer && !ISSPACE (*input_line_pointer))
25512 input_line_pointer++;
25513 saved_char = *input_line_pointer;
25514 *input_line_pointer = 0;
25516 for (opt = arm_fpus; opt->name != NULL; opt++)
25517 if (streq (opt->name, name))
25519 mfpu_opt = &opt->value;
25520 ARM_MERGE_FEATURE_SETS (cpu_variant, *mcpu_cpu_opt, *mfpu_opt);
25521 *input_line_pointer = saved_char;
25522 demand_empty_rest_of_line ();
25526 as_bad (_("unknown floating point format `%s'\n"), name);
25527 *input_line_pointer = saved_char;
25528 ignore_rest_of_line ();
25531 /* Copy symbol information. */
25534 arm_copy_symbol_attributes (symbolS *dest, symbolS *src)
25536 ARM_GET_FLAG (dest) = ARM_GET_FLAG (src);
25540 /* Given a symbolic attribute NAME, return the proper integer value.
25541 Returns -1 if the attribute is not known. */
25544 arm_convert_symbolic_attribute (const char *name)
25546 static const struct
25551 attribute_table[] =
25553 /* When you modify this table you should
25554 also modify the list in doc/c-arm.texi. */
25555 #define T(tag) {#tag, tag}
25556 T (Tag_CPU_raw_name),
25559 T (Tag_CPU_arch_profile),
25560 T (Tag_ARM_ISA_use),
25561 T (Tag_THUMB_ISA_use),
25565 T (Tag_Advanced_SIMD_arch),
25566 T (Tag_PCS_config),
25567 T (Tag_ABI_PCS_R9_use),
25568 T (Tag_ABI_PCS_RW_data),
25569 T (Tag_ABI_PCS_RO_data),
25570 T (Tag_ABI_PCS_GOT_use),
25571 T (Tag_ABI_PCS_wchar_t),
25572 T (Tag_ABI_FP_rounding),
25573 T (Tag_ABI_FP_denormal),
25574 T (Tag_ABI_FP_exceptions),
25575 T (Tag_ABI_FP_user_exceptions),
25576 T (Tag_ABI_FP_number_model),
25577 T (Tag_ABI_align_needed),
25578 T (Tag_ABI_align8_needed),
25579 T (Tag_ABI_align_preserved),
25580 T (Tag_ABI_align8_preserved),
25581 T (Tag_ABI_enum_size),
25582 T (Tag_ABI_HardFP_use),
25583 T (Tag_ABI_VFP_args),
25584 T (Tag_ABI_WMMX_args),
25585 T (Tag_ABI_optimization_goals),
25586 T (Tag_ABI_FP_optimization_goals),
25587 T (Tag_compatibility),
25588 T (Tag_CPU_unaligned_access),
25589 T (Tag_FP_HP_extension),
25590 T (Tag_VFP_HP_extension),
25591 T (Tag_ABI_FP_16bit_format),
25592 T (Tag_MPextension_use),
25594 T (Tag_nodefaults),
25595 T (Tag_also_compatible_with),
25596 T (Tag_conformance),
25598 T (Tag_Virtualization_use),
25599 /* We deliberately do not include Tag_MPextension_use_legacy. */
25607 for (i = 0; i < ARRAY_SIZE (attribute_table); i++)
25608 if (streq (name, attribute_table[i].name))
25609 return attribute_table[i].tag;
25615 /* Apply sym value for relocations only in the case that
25616 they are for local symbols and you have the respective
25617 architectural feature for blx and simple switches. */
25619 arm_apply_sym_value (struct fix * fixP)
25622 && ARM_CPU_HAS_FEATURE (selected_cpu, arm_ext_v5t)
25623 && !S_FORCE_RELOC (fixP->fx_addsy, TRUE))
25625 switch (fixP->fx_r_type)
25627 case BFD_RELOC_ARM_PCREL_BLX:
25628 case BFD_RELOC_THUMB_PCREL_BRANCH23:
25629 if (ARM_IS_FUNC (fixP->fx_addsy))
25633 case BFD_RELOC_ARM_PCREL_CALL:
25634 case BFD_RELOC_THUMB_PCREL_BLX:
25635 if (THUMB_IS_FUNC (fixP->fx_addsy))
25646 #endif /* OBJ_ELF */