1 /* tc-arm.c -- Assemble for the ARM
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
6 Modified by David Taylor (dtaylor@armltd.co.uk)
7 Cirrus coprocessor mods by Aldy Hernandez (aldyh@redhat.com)
8 Cirrus coprocessor fixes by Petko Manolov (petkan@nucleusys.com)
9 Cirrus coprocessor fixes by Vladimir Ivanov (vladitx@nucleusys.com)
11 This file is part of GAS, the GNU Assembler.
13 GAS is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 3, or (at your option)
18 GAS is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GAS; see the file COPYING. If not, write to the Free
25 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
32 #include "safe-ctype.h"
36 #include "opcode/arm.h"
40 #include "dw2gencfi.h"
43 #include "dwarf2dbg.h"
46 /* Must be at least the size of the largest unwind opcode (currently two). */
47 #define ARM_OPCODE_CHUNK_SIZE 8
49 /* This structure holds the unwinding state. */
54 symbolS
* table_entry
;
55 symbolS
* personality_routine
;
56 int personality_index
;
57 /* The segment containing the function. */
60 /* Opcodes generated from this function. */
61 unsigned char * opcodes
;
64 /* The number of bytes pushed to the stack. */
66 /* We don't add stack adjustment opcodes immediately so that we can merge
67 multiple adjustments. We can also omit the final adjustment
68 when using a frame pointer. */
69 offsetT pending_offset
;
70 /* These two fields are set by both unwind_movsp and unwind_setfp. They
71 hold the reg+offset to use when restoring sp from a frame pointer. */
74 /* Nonzero if an unwind_setfp directive has been seen. */
76 /* Nonzero if the last opcode restores sp from fp_reg. */
77 unsigned sp_restored
:1;
82 /* Results from operand parsing worker functions. */
86 PARSE_OPERAND_SUCCESS
,
88 PARSE_OPERAND_FAIL_NO_BACKTRACK
89 } parse_operand_result
;
98 /* Types of processor to assemble for. */
100 #if defined __XSCALE__
101 #define CPU_DEFAULT ARM_ARCH_XSCALE
103 #if defined __thumb__
104 #define CPU_DEFAULT ARM_ARCH_V5T
111 # define FPU_DEFAULT FPU_ARCH_FPA
112 # elif defined (TE_NetBSD)
114 # define FPU_DEFAULT FPU_ARCH_VFP /* Soft-float, but VFP order. */
116 /* Legacy a.out format. */
117 # define FPU_DEFAULT FPU_ARCH_FPA /* Soft-float, but FPA order. */
119 # elif defined (TE_VXWORKS)
120 # define FPU_DEFAULT FPU_ARCH_VFP /* Soft-float, VFP order. */
122 /* For backwards compatibility, default to FPA. */
123 # define FPU_DEFAULT FPU_ARCH_FPA
125 #endif /* ifndef FPU_DEFAULT */
127 #define streq(a, b) (strcmp (a, b) == 0)
129 static arm_feature_set cpu_variant
;
130 static arm_feature_set arm_arch_used
;
131 static arm_feature_set thumb_arch_used
;
133 /* Flags stored in private area of BFD structure. */
134 static int uses_apcs_26
= FALSE
;
135 static int atpcs
= FALSE
;
136 static int support_interwork
= FALSE
;
137 static int uses_apcs_float
= FALSE
;
138 static int pic_code
= FALSE
;
139 static int fix_v4bx
= FALSE
;
140 /* Warn on using deprecated features. */
141 static int warn_on_deprecated
= TRUE
;
144 /* Variables that we set while parsing command-line options. Once all
145 options have been read we re-process these values to set the real
147 static const arm_feature_set
*legacy_cpu
= NULL
;
148 static const arm_feature_set
*legacy_fpu
= NULL
;
150 static const arm_feature_set
*mcpu_cpu_opt
= NULL
;
151 static const arm_feature_set
*mcpu_fpu_opt
= NULL
;
152 static const arm_feature_set
*march_cpu_opt
= NULL
;
153 static const arm_feature_set
*march_fpu_opt
= NULL
;
154 static const arm_feature_set
*mfpu_opt
= NULL
;
155 static const arm_feature_set
*object_arch
= NULL
;
157 /* Constants for known architecture features. */
158 static const arm_feature_set fpu_default
= FPU_DEFAULT
;
159 static const arm_feature_set fpu_arch_vfp_v1
= FPU_ARCH_VFP_V1
;
160 static const arm_feature_set fpu_arch_vfp_v2
= FPU_ARCH_VFP_V2
;
161 static const arm_feature_set fpu_arch_vfp_v3
= FPU_ARCH_VFP_V3
;
162 static const arm_feature_set fpu_arch_neon_v1
= FPU_ARCH_NEON_V1
;
163 static const arm_feature_set fpu_arch_fpa
= FPU_ARCH_FPA
;
164 static const arm_feature_set fpu_any_hard
= FPU_ANY_HARD
;
165 static const arm_feature_set fpu_arch_maverick
= FPU_ARCH_MAVERICK
;
166 static const arm_feature_set fpu_endian_pure
= FPU_ARCH_ENDIAN_PURE
;
169 static const arm_feature_set cpu_default
= CPU_DEFAULT
;
172 static const arm_feature_set arm_ext_v1
= ARM_FEATURE (ARM_EXT_V1
, 0);
173 static const arm_feature_set arm_ext_v2
= ARM_FEATURE (ARM_EXT_V1
, 0);
174 static const arm_feature_set arm_ext_v2s
= ARM_FEATURE (ARM_EXT_V2S
, 0);
175 static const arm_feature_set arm_ext_v3
= ARM_FEATURE (ARM_EXT_V3
, 0);
176 static const arm_feature_set arm_ext_v3m
= ARM_FEATURE (ARM_EXT_V3M
, 0);
177 static const arm_feature_set arm_ext_v4
= ARM_FEATURE (ARM_EXT_V4
, 0);
178 static const arm_feature_set arm_ext_v4t
= ARM_FEATURE (ARM_EXT_V4T
, 0);
179 static const arm_feature_set arm_ext_v5
= ARM_FEATURE (ARM_EXT_V5
, 0);
180 static const arm_feature_set arm_ext_v4t_5
=
181 ARM_FEATURE (ARM_EXT_V4T
| ARM_EXT_V5
, 0);
182 static const arm_feature_set arm_ext_v5t
= ARM_FEATURE (ARM_EXT_V5T
, 0);
183 static const arm_feature_set arm_ext_v5e
= ARM_FEATURE (ARM_EXT_V5E
, 0);
184 static const arm_feature_set arm_ext_v5exp
= ARM_FEATURE (ARM_EXT_V5ExP
, 0);
185 static const arm_feature_set arm_ext_v5j
= ARM_FEATURE (ARM_EXT_V5J
, 0);
186 static const arm_feature_set arm_ext_v6
= ARM_FEATURE (ARM_EXT_V6
, 0);
187 static const arm_feature_set arm_ext_v6k
= ARM_FEATURE (ARM_EXT_V6K
, 0);
188 static const arm_feature_set arm_ext_v6z
= ARM_FEATURE (ARM_EXT_V6Z
, 0);
189 static const arm_feature_set arm_ext_v6t2
= ARM_FEATURE (ARM_EXT_V6T2
, 0);
190 static const arm_feature_set arm_ext_v6_notm
= ARM_FEATURE (ARM_EXT_V6_NOTM
, 0);
191 static const arm_feature_set arm_ext_v6_dsp
= ARM_FEATURE (ARM_EXT_V6_DSP
, 0);
192 static const arm_feature_set arm_ext_barrier
= ARM_FEATURE (ARM_EXT_BARRIER
, 0);
193 static const arm_feature_set arm_ext_msr
= ARM_FEATURE (ARM_EXT_THUMB_MSR
, 0);
194 static const arm_feature_set arm_ext_div
= ARM_FEATURE (ARM_EXT_DIV
, 0);
195 static const arm_feature_set arm_ext_v7
= ARM_FEATURE (ARM_EXT_V7
, 0);
196 static const arm_feature_set arm_ext_v7a
= ARM_FEATURE (ARM_EXT_V7A
, 0);
197 static const arm_feature_set arm_ext_v7r
= ARM_FEATURE (ARM_EXT_V7R
, 0);
198 static const arm_feature_set arm_ext_v7m
= ARM_FEATURE (ARM_EXT_V7M
, 0);
199 static const arm_feature_set arm_ext_m
=
200 ARM_FEATURE (ARM_EXT_V6M
| ARM_EXT_V7M
, 0);
202 static const arm_feature_set arm_arch_any
= ARM_ANY
;
203 static const arm_feature_set arm_arch_full
= ARM_FEATURE (-1, -1);
204 static const arm_feature_set arm_arch_t2
= ARM_ARCH_THUMB2
;
205 static const arm_feature_set arm_arch_none
= ARM_ARCH_NONE
;
207 static const arm_feature_set arm_cext_iwmmxt2
=
208 ARM_FEATURE (0, ARM_CEXT_IWMMXT2
);
209 static const arm_feature_set arm_cext_iwmmxt
=
210 ARM_FEATURE (0, ARM_CEXT_IWMMXT
);
211 static const arm_feature_set arm_cext_xscale
=
212 ARM_FEATURE (0, ARM_CEXT_XSCALE
);
213 static const arm_feature_set arm_cext_maverick
=
214 ARM_FEATURE (0, ARM_CEXT_MAVERICK
);
215 static const arm_feature_set fpu_fpa_ext_v1
= ARM_FEATURE (0, FPU_FPA_EXT_V1
);
216 static const arm_feature_set fpu_fpa_ext_v2
= ARM_FEATURE (0, FPU_FPA_EXT_V2
);
217 static const arm_feature_set fpu_vfp_ext_v1xd
=
218 ARM_FEATURE (0, FPU_VFP_EXT_V1xD
);
219 static const arm_feature_set fpu_vfp_ext_v1
= ARM_FEATURE (0, FPU_VFP_EXT_V1
);
220 static const arm_feature_set fpu_vfp_ext_v2
= ARM_FEATURE (0, FPU_VFP_EXT_V2
);
221 static const arm_feature_set fpu_vfp_ext_v3xd
= ARM_FEATURE (0, FPU_VFP_EXT_V3xD
);
222 static const arm_feature_set fpu_vfp_ext_v3
= ARM_FEATURE (0, FPU_VFP_EXT_V3
);
223 static const arm_feature_set fpu_vfp_ext_d32
=
224 ARM_FEATURE (0, FPU_VFP_EXT_D32
);
225 static const arm_feature_set fpu_neon_ext_v1
= ARM_FEATURE (0, FPU_NEON_EXT_V1
);
226 static const arm_feature_set fpu_vfp_v3_or_neon_ext
=
227 ARM_FEATURE (0, FPU_NEON_EXT_V1
| FPU_VFP_EXT_V3
);
228 static const arm_feature_set fpu_vfp_fp16
= ARM_FEATURE (0, FPU_VFP_EXT_FP16
);
229 static const arm_feature_set fpu_neon_ext_fma
= ARM_FEATURE (0, FPU_NEON_EXT_FMA
);
230 static const arm_feature_set fpu_vfp_ext_fma
= ARM_FEATURE (0, FPU_VFP_EXT_FMA
);
232 static int mfloat_abi_opt
= -1;
233 /* Record user cpu selection for object attributes. */
234 static arm_feature_set selected_cpu
= ARM_ARCH_NONE
;
235 /* Must be long enough to hold any of the names in arm_cpus. */
236 static char selected_cpu_name
[16];
239 static int meabi_flags
= EABI_DEFAULT
;
241 static int meabi_flags
= EF_ARM_EABI_UNKNOWN
;
244 static int attributes_set_explicitly
[NUM_KNOWN_OBJ_ATTRIBUTES
];
249 return (EF_ARM_EABI_VERSION (meabi_flags
) >= EF_ARM_EABI_VER4
);
254 /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
255 symbolS
* GOT_symbol
;
258 /* 0: assemble for ARM,
259 1: assemble for Thumb,
260 2: assemble for Thumb even though target CPU does not support thumb
262 static int thumb_mode
= 0;
263 /* A value distinct from the possible values for thumb_mode that we
264 can use to record whether thumb_mode has been copied into the
265 tc_frag_data field of a frag. */
266 #define MODE_RECORDED (1 << 4)
268 /* Specifies the intrinsic IT insn behavior mode. */
269 enum implicit_it_mode
271 IMPLICIT_IT_MODE_NEVER
= 0x00,
272 IMPLICIT_IT_MODE_ARM
= 0x01,
273 IMPLICIT_IT_MODE_THUMB
= 0x02,
274 IMPLICIT_IT_MODE_ALWAYS
= (IMPLICIT_IT_MODE_ARM
| IMPLICIT_IT_MODE_THUMB
)
276 static int implicit_it_mode
= IMPLICIT_IT_MODE_ARM
;
278 /* If unified_syntax is true, we are processing the new unified
279 ARM/Thumb syntax. Important differences from the old ARM mode:
281 - Immediate operands do not require a # prefix.
282 - Conditional affixes always appear at the end of the
283 instruction. (For backward compatibility, those instructions
284 that formerly had them in the middle, continue to accept them
286 - The IT instruction may appear, and if it does is validated
287 against subsequent conditional affixes. It does not generate
290 Important differences from the old Thumb mode:
292 - Immediate operands do not require a # prefix.
293 - Most of the V6T2 instructions are only available in unified mode.
294 - The .N and .W suffixes are recognized and honored (it is an error
295 if they cannot be honored).
296 - All instructions set the flags if and only if they have an 's' affix.
297 - Conditional affixes may be used. They are validated against
298 preceding IT instructions. Unlike ARM mode, you cannot use a
299 conditional affix except in the scope of an IT instruction. */
301 static bfd_boolean unified_syntax
= FALSE
;
316 enum neon_el_type type
;
320 #define NEON_MAX_TYPE_ELS 4
324 struct neon_type_el el
[NEON_MAX_TYPE_ELS
];
328 enum it_instruction_type
333 IF_INSIDE_IT_LAST_INSN
, /* Either outside or inside;
334 if inside, should be the last one. */
335 NEUTRAL_IT_INSN
, /* This could be either inside or outside,
336 i.e. BKPT and NOP. */
337 IT_INSN
/* The IT insn has been parsed. */
343 unsigned long instruction
;
347 /* "uncond_value" is set to the value in place of the conditional field in
348 unconditional versions of the instruction, or -1 if nothing is
351 struct neon_type vectype
;
352 /* This does not indicate an actual NEON instruction, only that
353 the mnemonic accepts neon-style type suffixes. */
355 /* Set to the opcode if the instruction needs relaxation.
356 Zero if the instruction is not relaxed. */
360 bfd_reloc_code_real_type type
;
365 enum it_instruction_type it_insn_type
;
371 struct neon_type_el vectype
;
372 unsigned present
: 1; /* Operand present. */
373 unsigned isreg
: 1; /* Operand was a register. */
374 unsigned immisreg
: 1; /* .imm field is a second register. */
375 unsigned isscalar
: 1; /* Operand is a (Neon) scalar. */
376 unsigned immisalign
: 1; /* Immediate is an alignment specifier. */
377 unsigned immisfloat
: 1; /* Immediate was parsed as a float. */
378 /* Note: we abuse "regisimm" to mean "is Neon register" in VMOV
379 instructions. This allows us to disambiguate ARM <-> vector insns. */
380 unsigned regisimm
: 1; /* 64-bit immediate, reg forms high 32 bits. */
381 unsigned isvec
: 1; /* Is a single, double or quad VFP/Neon reg. */
382 unsigned isquad
: 1; /* Operand is Neon quad-precision register. */
383 unsigned issingle
: 1; /* Operand is VFP single-precision register. */
384 unsigned hasreloc
: 1; /* Operand has relocation suffix. */
385 unsigned writeback
: 1; /* Operand has trailing ! */
386 unsigned preind
: 1; /* Preindexed address. */
387 unsigned postind
: 1; /* Postindexed address. */
388 unsigned negative
: 1; /* Index register was negated. */
389 unsigned shifted
: 1; /* Shift applied to operation. */
390 unsigned shift_kind
: 3; /* Shift operation (enum shift_kind). */
394 static struct arm_it inst
;
396 #define NUM_FLOAT_VALS 8
398 const char * fp_const
[] =
400 "0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0", 0
403 /* Number of littlenums required to hold an extended precision number. */
404 #define MAX_LITTLENUMS 6
406 LITTLENUM_TYPE fp_values
[NUM_FLOAT_VALS
][MAX_LITTLENUMS
];
416 #define CP_T_X 0x00008000
417 #define CP_T_Y 0x00400000
419 #define CONDS_BIT 0x00100000
420 #define LOAD_BIT 0x00100000
422 #define DOUBLE_LOAD_FLAG 0x00000001
426 const char * template_name
;
430 #define COND_ALWAYS 0xE
434 const char * template_name
;
438 struct asm_barrier_opt
440 const char * template_name
;
444 /* The bit that distinguishes CPSR and SPSR. */
445 #define SPSR_BIT (1 << 22)
447 /* The individual PSR flag bits. */
448 #define PSR_c (1 << 16)
449 #define PSR_x (1 << 17)
450 #define PSR_s (1 << 18)
451 #define PSR_f (1 << 19)
456 bfd_reloc_code_real_type reloc
;
461 VFP_REG_Sd
, VFP_REG_Sm
, VFP_REG_Sn
,
462 VFP_REG_Dd
, VFP_REG_Dm
, VFP_REG_Dn
467 VFP_LDSTMIA
, VFP_LDSTMDB
, VFP_LDSTMIAX
, VFP_LDSTMDBX
470 /* Bits for DEFINED field in neon_typed_alias. */
471 #define NTA_HASTYPE 1
472 #define NTA_HASINDEX 2
474 struct neon_typed_alias
476 unsigned char defined
;
478 struct neon_type_el eltype
;
481 /* ARM register categories. This includes coprocessor numbers and various
482 architecture extensions' registers. */
508 /* Structure for a hash table entry for a register.
509 If TYPE is REG_TYPE_VFD or REG_TYPE_NQ, the NEON field can point to extra
510 information which states whether a vector type or index is specified (for a
511 register alias created with .dn or .qn). Otherwise NEON should be NULL. */
515 unsigned char number
;
517 unsigned char builtin
;
518 struct neon_typed_alias
* neon
;
521 /* Diagnostics used when we don't get a register of the expected type. */
522 const char * const reg_expected_msgs
[] =
524 N_("ARM register expected"),
525 N_("bad or missing co-processor number"),
526 N_("co-processor register expected"),
527 N_("FPA register expected"),
528 N_("VFP single precision register expected"),
529 N_("VFP/Neon double precision register expected"),
530 N_("Neon quad precision register expected"),
531 N_("VFP single or double precision register expected"),
532 N_("Neon double or quad precision register expected"),
533 N_("VFP single, double or Neon quad precision register expected"),
534 N_("VFP system register expected"),
535 N_("Maverick MVF register expected"),
536 N_("Maverick MVD register expected"),
537 N_("Maverick MVFX register expected"),
538 N_("Maverick MVDX register expected"),
539 N_("Maverick MVAX register expected"),
540 N_("Maverick DSPSC register expected"),
541 N_("iWMMXt data register expected"),
542 N_("iWMMXt control register expected"),
543 N_("iWMMXt scalar register expected"),
544 N_("XScale accumulator register expected"),
547 /* Some well known registers that we refer to directly elsewhere. */
552 /* ARM instructions take 4bytes in the object file, Thumb instructions
558 /* Basic string to match. */
559 const char * template_name
;
561 /* Parameters to instruction. */
562 unsigned char operands
[8];
564 /* Conditional tag - see opcode_lookup. */
565 unsigned int tag
: 4;
567 /* Basic instruction code. */
568 unsigned int avalue
: 28;
570 /* Thumb-format instruction code. */
573 /* Which architecture variant provides this instruction. */
574 const arm_feature_set
* avariant
;
575 const arm_feature_set
* tvariant
;
577 /* Function to call to encode instruction in ARM format. */
578 void (* aencode
) (void);
580 /* Function to call to encode instruction in Thumb format. */
581 void (* tencode
) (void);
584 /* Defines for various bits that we will want to toggle. */
585 #define INST_IMMEDIATE 0x02000000
586 #define OFFSET_REG 0x02000000
587 #define HWOFFSET_IMM 0x00400000
588 #define SHIFT_BY_REG 0x00000010
589 #define PRE_INDEX 0x01000000
590 #define INDEX_UP 0x00800000
591 #define WRITE_BACK 0x00200000
592 #define LDM_TYPE_2_OR_3 0x00400000
593 #define CPSI_MMOD 0x00020000
595 #define LITERAL_MASK 0xf000f000
596 #define OPCODE_MASK 0xfe1fffff
597 #define V4_STR_BIT 0x00000020
599 #define T2_SUBS_PC_LR 0xf3de8f00
601 #define DATA_OP_SHIFT 21
603 #define T2_OPCODE_MASK 0xfe1fffff
604 #define T2_DATA_OP_SHIFT 21
606 /* Codes to distinguish the arithmetic instructions. */
617 #define OPCODE_CMP 10
618 #define OPCODE_CMN 11
619 #define OPCODE_ORR 12
620 #define OPCODE_MOV 13
621 #define OPCODE_BIC 14
622 #define OPCODE_MVN 15
624 #define T2_OPCODE_AND 0
625 #define T2_OPCODE_BIC 1
626 #define T2_OPCODE_ORR 2
627 #define T2_OPCODE_ORN 3
628 #define T2_OPCODE_EOR 4
629 #define T2_OPCODE_ADD 8
630 #define T2_OPCODE_ADC 10
631 #define T2_OPCODE_SBC 11
632 #define T2_OPCODE_SUB 13
633 #define T2_OPCODE_RSB 14
635 #define T_OPCODE_MUL 0x4340
636 #define T_OPCODE_TST 0x4200
637 #define T_OPCODE_CMN 0x42c0
638 #define T_OPCODE_NEG 0x4240
639 #define T_OPCODE_MVN 0x43c0
641 #define T_OPCODE_ADD_R3 0x1800
642 #define T_OPCODE_SUB_R3 0x1a00
643 #define T_OPCODE_ADD_HI 0x4400
644 #define T_OPCODE_ADD_ST 0xb000
645 #define T_OPCODE_SUB_ST 0xb080
646 #define T_OPCODE_ADD_SP 0xa800
647 #define T_OPCODE_ADD_PC 0xa000
648 #define T_OPCODE_ADD_I8 0x3000
649 #define T_OPCODE_SUB_I8 0x3800
650 #define T_OPCODE_ADD_I3 0x1c00
651 #define T_OPCODE_SUB_I3 0x1e00
653 #define T_OPCODE_ASR_R 0x4100
654 #define T_OPCODE_LSL_R 0x4080
655 #define T_OPCODE_LSR_R 0x40c0
656 #define T_OPCODE_ROR_R 0x41c0
657 #define T_OPCODE_ASR_I 0x1000
658 #define T_OPCODE_LSL_I 0x0000
659 #define T_OPCODE_LSR_I 0x0800
661 #define T_OPCODE_MOV_I8 0x2000
662 #define T_OPCODE_CMP_I8 0x2800
663 #define T_OPCODE_CMP_LR 0x4280
664 #define T_OPCODE_MOV_HR 0x4600
665 #define T_OPCODE_CMP_HR 0x4500
667 #define T_OPCODE_LDR_PC 0x4800
668 #define T_OPCODE_LDR_SP 0x9800
669 #define T_OPCODE_STR_SP 0x9000
670 #define T_OPCODE_LDR_IW 0x6800
671 #define T_OPCODE_STR_IW 0x6000
672 #define T_OPCODE_LDR_IH 0x8800
673 #define T_OPCODE_STR_IH 0x8000
674 #define T_OPCODE_LDR_IB 0x7800
675 #define T_OPCODE_STR_IB 0x7000
676 #define T_OPCODE_LDR_RW 0x5800
677 #define T_OPCODE_STR_RW 0x5000
678 #define T_OPCODE_LDR_RH 0x5a00
679 #define T_OPCODE_STR_RH 0x5200
680 #define T_OPCODE_LDR_RB 0x5c00
681 #define T_OPCODE_STR_RB 0x5400
683 #define T_OPCODE_PUSH 0xb400
684 #define T_OPCODE_POP 0xbc00
686 #define T_OPCODE_BRANCH 0xe000
688 #define THUMB_SIZE 2 /* Size of thumb instruction. */
689 #define THUMB_PP_PC_LR 0x0100
690 #define THUMB_LOAD_BIT 0x0800
691 #define THUMB2_LOAD_BIT 0x00100000
693 #define BAD_ARGS _("bad arguments to instruction")
694 #define BAD_SP _("r13 not allowed here")
695 #define BAD_PC _("r15 not allowed here")
696 #define BAD_COND _("instruction cannot be conditional")
697 #define BAD_OVERLAP _("registers may not be the same")
698 #define BAD_HIREG _("lo register required")
699 #define BAD_THUMB32 _("instruction not supported in Thumb16 mode")
700 #define BAD_ADDR_MODE _("instruction does not accept this addressing mode");
701 #define BAD_BRANCH _("branch must be last instruction in IT block")
702 #define BAD_NOT_IT _("instruction not allowed in IT block")
703 #define BAD_FPU _("selected FPU does not support instruction")
704 #define BAD_OUT_IT _("thumb conditional instruction should be in IT block")
705 #define BAD_IT_COND _("incorrect condition in IT block")
706 #define BAD_IT_IT _("IT falling in the range of a previous IT block")
707 #define MISSING_FNSTART _("missing .fnstart before unwinding directive")
709 static struct hash_control
* arm_ops_hsh
;
710 static struct hash_control
* arm_cond_hsh
;
711 static struct hash_control
* arm_shift_hsh
;
712 static struct hash_control
* arm_psr_hsh
;
713 static struct hash_control
* arm_v7m_psr_hsh
;
714 static struct hash_control
* arm_reg_hsh
;
715 static struct hash_control
* arm_reloc_hsh
;
716 static struct hash_control
* arm_barrier_opt_hsh
;
718 /* Stuff needed to resolve the label ambiguity
727 symbolS
* last_label_seen
;
728 static int label_is_thumb_function_name
= FALSE
;
730 /* Literal pool structure. Held on a per-section
731 and per-sub-section basis. */
733 #define MAX_LITERAL_POOL_SIZE 1024
734 typedef struct literal_pool
736 expressionS literals
[MAX_LITERAL_POOL_SIZE
];
737 unsigned int next_free_entry
;
742 struct literal_pool
* next
;
745 /* Pointer to a linked list of literal pools. */
746 literal_pool
* list_of_pools
= NULL
;
749 # define now_it seg_info (now_seg)->tc_segment_info_data.current_it
751 static struct current_it now_it
;
755 now_it_compatible (int cond
)
757 return (cond
& ~1) == (now_it
.cc
& ~1);
761 conditional_insn (void)
763 return inst
.cond
!= COND_ALWAYS
;
766 static int in_it_block (void);
768 static int handle_it_state (void);
770 static void force_automatic_it_block_close (void);
772 static void it_fsm_post_encode (void);
774 #define set_it_insn_type(type) \
777 inst.it_insn_type = type; \
778 if (handle_it_state () == FAIL) \
783 #define set_it_insn_type_nonvoid(type, failret) \
786 inst.it_insn_type = type; \
787 if (handle_it_state () == FAIL) \
792 #define set_it_insn_type_last() \
795 if (inst.cond == COND_ALWAYS) \
796 set_it_insn_type (IF_INSIDE_IT_LAST_INSN); \
798 set_it_insn_type (INSIDE_IT_LAST_INSN); \
804 /* This array holds the chars that always start a comment. If the
805 pre-processor is disabled, these aren't very useful. */
806 const char comment_chars
[] = "@";
808 /* This array holds the chars that only start a comment at the beginning of
809 a line. If the line seems to have the form '# 123 filename'
810 .line and .file directives will appear in the pre-processed output. */
811 /* Note that input_file.c hand checks for '#' at the beginning of the
812 first line of the input file. This is because the compiler outputs
813 #NO_APP at the beginning of its output. */
814 /* Also note that comments like this one will always work. */
815 const char line_comment_chars
[] = "#";
817 const char line_separator_chars
[] = ";";
819 /* Chars that can be used to separate mant
820 from exp in floating point numbers. */
821 const char EXP_CHARS
[] = "eE";
823 /* Chars that mean this number is a floating point constant. */
827 const char FLT_CHARS
[] = "rRsSfFdDxXeEpP";
829 /* Prefix characters that indicate the start of an immediate
831 #define is_immediate_prefix(C) ((C) == '#' || (C) == '$')
833 /* Separator character handling. */
835 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
838 skip_past_char (char ** str
, char c
)
849 #define skip_past_comma(str) skip_past_char (str, ',')
851 /* Arithmetic expressions (possibly involving symbols). */
853 /* Return TRUE if anything in the expression is a bignum. */
856 walk_no_bignums (symbolS
* sp
)
858 if (symbol_get_value_expression (sp
)->X_op
== O_big
)
861 if (symbol_get_value_expression (sp
)->X_add_symbol
)
863 return (walk_no_bignums (symbol_get_value_expression (sp
)->X_add_symbol
)
864 || (symbol_get_value_expression (sp
)->X_op_symbol
865 && walk_no_bignums (symbol_get_value_expression (sp
)->X_op_symbol
)));
871 static int in_my_get_expression
= 0;
873 /* Third argument to my_get_expression. */
874 #define GE_NO_PREFIX 0
875 #define GE_IMM_PREFIX 1
876 #define GE_OPT_PREFIX 2
877 /* This is a bit of a hack. Use an optional prefix, and also allow big (64-bit)
878 immediates, as can be used in Neon VMVN and VMOV immediate instructions. */
879 #define GE_OPT_PREFIX_BIG 3
882 my_get_expression (expressionS
* ep
, char ** str
, int prefix_mode
)
887 /* In unified syntax, all prefixes are optional. */
889 prefix_mode
= (prefix_mode
== GE_OPT_PREFIX_BIG
) ? prefix_mode
894 case GE_NO_PREFIX
: break;
896 if (!is_immediate_prefix (**str
))
898 inst
.error
= _("immediate expression requires a # prefix");
904 case GE_OPT_PREFIX_BIG
:
905 if (is_immediate_prefix (**str
))
911 memset (ep
, 0, sizeof (expressionS
));
913 save_in
= input_line_pointer
;
914 input_line_pointer
= *str
;
915 in_my_get_expression
= 1;
916 seg
= expression (ep
);
917 in_my_get_expression
= 0;
919 if (ep
->X_op
== O_illegal
|| ep
->X_op
== O_absent
)
921 /* We found a bad or missing expression in md_operand(). */
922 *str
= input_line_pointer
;
923 input_line_pointer
= save_in
;
924 if (inst
.error
== NULL
)
925 inst
.error
= (ep
->X_op
== O_absent
926 ? _("missing expression") :_("bad expression"));
931 if (seg
!= absolute_section
932 && seg
!= text_section
933 && seg
!= data_section
934 && seg
!= bss_section
935 && seg
!= undefined_section
)
937 inst
.error
= _("bad segment");
938 *str
= input_line_pointer
;
939 input_line_pointer
= save_in
;
944 /* Get rid of any bignums now, so that we don't generate an error for which
945 we can't establish a line number later on. Big numbers are never valid
946 in instructions, which is where this routine is always called. */
947 if (prefix_mode
!= GE_OPT_PREFIX_BIG
948 && (ep
->X_op
== O_big
950 && (walk_no_bignums (ep
->X_add_symbol
)
952 && walk_no_bignums (ep
->X_op_symbol
))))))
954 inst
.error
= _("invalid constant");
955 *str
= input_line_pointer
;
956 input_line_pointer
= save_in
;
960 *str
= input_line_pointer
;
961 input_line_pointer
= save_in
;
965 /* Turn a string in input_line_pointer into a floating point constant
966 of type TYPE, and store the appropriate bytes in *LITP. The number
967 of LITTLENUMS emitted is stored in *SIZEP. An error message is
968 returned, or NULL on OK.
970 Note that fp constants aren't represent in the normal way on the ARM.
971 In big endian mode, things are as expected. However, in little endian
972 mode fp constants are big-endian word-wise, and little-endian byte-wise
973 within the words. For example, (double) 1.1 in big endian mode is
974 the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is
975 the byte sequence 99 99 f1 3f 9a 99 99 99.
977 ??? The format of 12 byte floats is uncertain according to gcc's arm.h. */
980 md_atof (int type
, char * litP
, int * sizeP
)
983 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
1015 return _("Unrecognized or unsupported floating point constant");
1018 t
= atof_ieee (input_line_pointer
, type
, words
);
1020 input_line_pointer
= t
;
1021 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
1023 if (target_big_endian
)
1025 for (i
= 0; i
< prec
; i
++)
1027 md_number_to_chars (litP
, (valueT
) words
[i
], sizeof (LITTLENUM_TYPE
));
1028 litP
+= sizeof (LITTLENUM_TYPE
);
1033 if (ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_endian_pure
))
1034 for (i
= prec
- 1; i
>= 0; i
--)
1036 md_number_to_chars (litP
, (valueT
) words
[i
], sizeof (LITTLENUM_TYPE
));
1037 litP
+= sizeof (LITTLENUM_TYPE
);
1040 /* For a 4 byte float the order of elements in `words' is 1 0.
1041 For an 8 byte float the order is 1 0 3 2. */
1042 for (i
= 0; i
< prec
; i
+= 2)
1044 md_number_to_chars (litP
, (valueT
) words
[i
+ 1],
1045 sizeof (LITTLENUM_TYPE
));
1046 md_number_to_chars (litP
+ sizeof (LITTLENUM_TYPE
),
1047 (valueT
) words
[i
], sizeof (LITTLENUM_TYPE
));
1048 litP
+= 2 * sizeof (LITTLENUM_TYPE
);
1055 /* We handle all bad expressions here, so that we can report the faulty
1056 instruction in the error message. */
1058 md_operand (expressionS
* exp
)
1060 if (in_my_get_expression
)
1061 exp
->X_op
= O_illegal
;
1064 /* Immediate values. */
1066 /* Generic immediate-value read function for use in directives.
1067 Accepts anything that 'expression' can fold to a constant.
1068 *val receives the number. */
1071 immediate_for_directive (int *val
)
1074 exp
.X_op
= O_illegal
;
1076 if (is_immediate_prefix (*input_line_pointer
))
1078 input_line_pointer
++;
1082 if (exp
.X_op
!= O_constant
)
1084 as_bad (_("expected #constant"));
1085 ignore_rest_of_line ();
1088 *val
= exp
.X_add_number
;
1093 /* Register parsing. */
1095 /* Generic register parser. CCP points to what should be the
1096 beginning of a register name. If it is indeed a valid register
1097 name, advance CCP over it and return the reg_entry structure;
1098 otherwise return NULL. Does not issue diagnostics. */
1100 static struct reg_entry
*
1101 arm_reg_parse_multi (char **ccp
)
1105 struct reg_entry
*reg
;
1107 #ifdef REGISTER_PREFIX
1108 if (*start
!= REGISTER_PREFIX
)
1112 #ifdef OPTIONAL_REGISTER_PREFIX
1113 if (*start
== OPTIONAL_REGISTER_PREFIX
)
1118 if (!ISALPHA (*p
) || !is_name_beginner (*p
))
1123 while (ISALPHA (*p
) || ISDIGIT (*p
) || *p
== '_');
1125 reg
= (struct reg_entry
*) hash_find_n (arm_reg_hsh
, start
, p
- start
);
1135 arm_reg_alt_syntax (char **ccp
, char *start
, struct reg_entry
*reg
,
1136 enum arm_reg_type type
)
1138 /* Alternative syntaxes are accepted for a few register classes. */
1145 /* Generic coprocessor register names are allowed for these. */
1146 if (reg
&& reg
->type
== REG_TYPE_CN
)
1151 /* For backward compatibility, a bare number is valid here. */
1153 unsigned long processor
= strtoul (start
, ccp
, 10);
1154 if (*ccp
!= start
&& processor
<= 15)
1158 case REG_TYPE_MMXWC
:
1159 /* WC includes WCG. ??? I'm not sure this is true for all
1160 instructions that take WC registers. */
1161 if (reg
&& reg
->type
== REG_TYPE_MMXWCG
)
1172 /* As arm_reg_parse_multi, but the register must be of type TYPE, and the
1173 return value is the register number or FAIL. */
1176 arm_reg_parse (char **ccp
, enum arm_reg_type type
)
1179 struct reg_entry
*reg
= arm_reg_parse_multi (ccp
);
1182 /* Do not allow a scalar (reg+index) to parse as a register. */
1183 if (reg
&& reg
->neon
&& (reg
->neon
->defined
& NTA_HASINDEX
))
1186 if (reg
&& reg
->type
== type
)
1189 if ((ret
= arm_reg_alt_syntax (ccp
, start
, reg
, type
)) != FAIL
)
1196 /* Parse a Neon type specifier. *STR should point at the leading '.'
1197 character. Does no verification at this stage that the type fits the opcode
1204 Can all be legally parsed by this function.
1206 Fills in neon_type struct pointer with parsed information, and updates STR
1207 to point after the parsed type specifier. Returns SUCCESS if this was a legal
1208 type, FAIL if not. */
1211 parse_neon_type (struct neon_type
*type
, char **str
)
1218 while (type
->elems
< NEON_MAX_TYPE_ELS
)
1220 enum neon_el_type thistype
= NT_untyped
;
1221 unsigned thissize
= -1u;
1228 /* Just a size without an explicit type. */
1232 switch (TOLOWER (*ptr
))
1234 case 'i': thistype
= NT_integer
; break;
1235 case 'f': thistype
= NT_float
; break;
1236 case 'p': thistype
= NT_poly
; break;
1237 case 's': thistype
= NT_signed
; break;
1238 case 'u': thistype
= NT_unsigned
; break;
1240 thistype
= NT_float
;
1245 as_bad (_("unexpected character `%c' in type specifier"), *ptr
);
1251 /* .f is an abbreviation for .f32. */
1252 if (thistype
== NT_float
&& !ISDIGIT (*ptr
))
1257 thissize
= strtoul (ptr
, &ptr
, 10);
1259 if (thissize
!= 8 && thissize
!= 16 && thissize
!= 32
1262 as_bad (_("bad size %d in type specifier"), thissize
);
1270 type
->el
[type
->elems
].type
= thistype
;
1271 type
->el
[type
->elems
].size
= thissize
;
1276 /* Empty/missing type is not a successful parse. */
1277 if (type
->elems
== 0)
1285 /* Errors may be set multiple times during parsing or bit encoding
1286 (particularly in the Neon bits), but usually the earliest error which is set
1287 will be the most meaningful. Avoid overwriting it with later (cascading)
1288 errors by calling this function. */
1291 first_error (const char *err
)
1297 /* Parse a single type, e.g. ".s32", leading period included. */
1299 parse_neon_operand_type (struct neon_type_el
*vectype
, char **ccp
)
1302 struct neon_type optype
;
1306 if (parse_neon_type (&optype
, &str
) == SUCCESS
)
1308 if (optype
.elems
== 1)
1309 *vectype
= optype
.el
[0];
1312 first_error (_("only one type should be specified for operand"));
1318 first_error (_("vector type expected"));
1330 /* Special meanings for indices (which have a range of 0-7), which will fit into
1333 #define NEON_ALL_LANES 15
1334 #define NEON_INTERLEAVE_LANES 14
1336 /* Parse either a register or a scalar, with an optional type. Return the
1337 register number, and optionally fill in the actual type of the register
1338 when multiple alternatives were given (NEON_TYPE_NDQ) in *RTYPE, and
1339 type/index information in *TYPEINFO. */
1342 parse_typed_reg_or_scalar (char **ccp
, enum arm_reg_type type
,
1343 enum arm_reg_type
*rtype
,
1344 struct neon_typed_alias
*typeinfo
)
1347 struct reg_entry
*reg
= arm_reg_parse_multi (&str
);
1348 struct neon_typed_alias atype
;
1349 struct neon_type_el parsetype
;
1353 atype
.eltype
.type
= NT_invtype
;
1354 atype
.eltype
.size
= -1;
1356 /* Try alternate syntax for some types of register. Note these are mutually
1357 exclusive with the Neon syntax extensions. */
1360 int altreg
= arm_reg_alt_syntax (&str
, *ccp
, reg
, type
);
1368 /* Undo polymorphism when a set of register types may be accepted. */
1369 if ((type
== REG_TYPE_NDQ
1370 && (reg
->type
== REG_TYPE_NQ
|| reg
->type
== REG_TYPE_VFD
))
1371 || (type
== REG_TYPE_VFSD
1372 && (reg
->type
== REG_TYPE_VFS
|| reg
->type
== REG_TYPE_VFD
))
1373 || (type
== REG_TYPE_NSDQ
1374 && (reg
->type
== REG_TYPE_VFS
|| reg
->type
== REG_TYPE_VFD
1375 || reg
->type
== REG_TYPE_NQ
))
1376 || (type
== REG_TYPE_MMXWC
1377 && (reg
->type
== REG_TYPE_MMXWCG
)))
1378 type
= (enum arm_reg_type
) reg
->type
;
1380 if (type
!= reg
->type
)
1386 if (parse_neon_operand_type (&parsetype
, &str
) == SUCCESS
)
1388 if ((atype
.defined
& NTA_HASTYPE
) != 0)
1390 first_error (_("can't redefine type for operand"));
1393 atype
.defined
|= NTA_HASTYPE
;
1394 atype
.eltype
= parsetype
;
1397 if (skip_past_char (&str
, '[') == SUCCESS
)
1399 if (type
!= REG_TYPE_VFD
)
1401 first_error (_("only D registers may be indexed"));
1405 if ((atype
.defined
& NTA_HASINDEX
) != 0)
1407 first_error (_("can't change index for operand"));
1411 atype
.defined
|= NTA_HASINDEX
;
1413 if (skip_past_char (&str
, ']') == SUCCESS
)
1414 atype
.index
= NEON_ALL_LANES
;
1419 my_get_expression (&exp
, &str
, GE_NO_PREFIX
);
1421 if (exp
.X_op
!= O_constant
)
1423 first_error (_("constant expression required"));
1427 if (skip_past_char (&str
, ']') == FAIL
)
1430 atype
.index
= exp
.X_add_number
;
1445 /* Like arm_reg_parse, but allow allow the following extra features:
1446 - If RTYPE is non-zero, return the (possibly restricted) type of the
1447 register (e.g. Neon double or quad reg when either has been requested).
1448 - If this is a Neon vector type with additional type information, fill
1449 in the struct pointed to by VECTYPE (if non-NULL).
1450 This function will fault on encountering a scalar. */
1453 arm_typed_reg_parse (char **ccp
, enum arm_reg_type type
,
1454 enum arm_reg_type
*rtype
, struct neon_type_el
*vectype
)
1456 struct neon_typed_alias atype
;
1458 int reg
= parse_typed_reg_or_scalar (&str
, type
, rtype
, &atype
);
1463 /* Do not allow a scalar (reg+index) to parse as a register. */
1464 if ((atype
.defined
& NTA_HASINDEX
) != 0)
1466 first_error (_("register operand expected, but got scalar"));
1471 *vectype
= atype
.eltype
;
1478 #define NEON_SCALAR_REG(X) ((X) >> 4)
1479 #define NEON_SCALAR_INDEX(X) ((X) & 15)
1481 /* Parse a Neon scalar. Most of the time when we're parsing a scalar, we don't
1482 have enough information to be able to do a good job bounds-checking. So, we
1483 just do easy checks here, and do further checks later. */
1486 parse_scalar (char **ccp
, int elsize
, struct neon_type_el
*type
)
1490 struct neon_typed_alias atype
;
1492 reg
= parse_typed_reg_or_scalar (&str
, REG_TYPE_VFD
, NULL
, &atype
);
1494 if (reg
== FAIL
|| (atype
.defined
& NTA_HASINDEX
) == 0)
1497 if (atype
.index
== NEON_ALL_LANES
)
1499 first_error (_("scalar must have an index"));
1502 else if (atype
.index
>= 64 / elsize
)
1504 first_error (_("scalar index out of range"));
1509 *type
= atype
.eltype
;
1513 return reg
* 16 + atype
.index
;
1516 /* Parse an ARM register list. Returns the bitmask, or FAIL. */
1519 parse_reg_list (char ** strp
)
1521 char * str
= * strp
;
1525 /* We come back here if we get ranges concatenated by '+' or '|'. */
1540 if ((reg
= arm_reg_parse (&str
, REG_TYPE_RN
)) == FAIL
)
1542 first_error (_(reg_expected_msgs
[REG_TYPE_RN
]));
1552 first_error (_("bad range in register list"));
1556 for (i
= cur_reg
+ 1; i
< reg
; i
++)
1558 if (range
& (1 << i
))
1560 (_("Warning: duplicated register (r%d) in register list"),
1568 if (range
& (1 << reg
))
1569 as_tsktsk (_("Warning: duplicated register (r%d) in register list"),
1571 else if (reg
<= cur_reg
)
1572 as_tsktsk (_("Warning: register range not in ascending order"));
1577 while (skip_past_comma (&str
) != FAIL
1578 || (in_range
= 1, *str
++ == '-'));
1583 first_error (_("missing `}'"));
1591 if (my_get_expression (&exp
, &str
, GE_NO_PREFIX
))
1594 if (exp
.X_op
== O_constant
)
1596 if (exp
.X_add_number
1597 != (exp
.X_add_number
& 0x0000ffff))
1599 inst
.error
= _("invalid register mask");
1603 if ((range
& exp
.X_add_number
) != 0)
1605 int regno
= range
& exp
.X_add_number
;
1608 regno
= (1 << regno
) - 1;
1610 (_("Warning: duplicated register (r%d) in register list"),
1614 range
|= exp
.X_add_number
;
1618 if (inst
.reloc
.type
!= 0)
1620 inst
.error
= _("expression too complex");
1624 memcpy (&inst
.reloc
.exp
, &exp
, sizeof (expressionS
));
1625 inst
.reloc
.type
= BFD_RELOC_ARM_MULTI
;
1626 inst
.reloc
.pc_rel
= 0;
1630 if (*str
== '|' || *str
== '+')
1636 while (another_range
);
1642 /* Types of registers in a list. */
1651 /* Parse a VFP register list. If the string is invalid return FAIL.
1652 Otherwise return the number of registers, and set PBASE to the first
1653 register. Parses registers of type ETYPE.
1654 If REGLIST_NEON_D is used, several syntax enhancements are enabled:
1655 - Q registers can be used to specify pairs of D registers
1656 - { } can be omitted from around a singleton register list
1657 FIXME: This is not implemented, as it would require backtracking in
1660 This could be done (the meaning isn't really ambiguous), but doesn't
1661 fit in well with the current parsing framework.
1662 - 32 D registers may be used (also true for VFPv3).
1663 FIXME: Types are ignored in these register lists, which is probably a
1667 parse_vfp_reg_list (char **ccp
, unsigned int *pbase
, enum reg_list_els etype
)
1672 enum arm_reg_type regtype
= (enum arm_reg_type
) 0;
1676 unsigned long mask
= 0;
1681 inst
.error
= _("expecting {");
1690 regtype
= REG_TYPE_VFS
;
1695 regtype
= REG_TYPE_VFD
;
1698 case REGLIST_NEON_D
:
1699 regtype
= REG_TYPE_NDQ
;
1703 if (etype
!= REGLIST_VFP_S
)
1705 /* VFPv3 allows 32 D registers, except for the VFPv3-D16 variant. */
1706 if (ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_vfp_ext_d32
))
1710 ARM_MERGE_FEATURE_SETS (thumb_arch_used
, thumb_arch_used
,
1713 ARM_MERGE_FEATURE_SETS (arm_arch_used
, arm_arch_used
,
1720 base_reg
= max_regs
;
1724 int setmask
= 1, addregs
= 1;
1726 new_base
= arm_typed_reg_parse (&str
, regtype
, ®type
, NULL
);
1728 if (new_base
== FAIL
)
1730 first_error (_(reg_expected_msgs
[regtype
]));
1734 if (new_base
>= max_regs
)
1736 first_error (_("register out of range in list"));
1740 /* Note: a value of 2 * n is returned for the register Q<n>. */
1741 if (regtype
== REG_TYPE_NQ
)
1747 if (new_base
< base_reg
)
1748 base_reg
= new_base
;
1750 if (mask
& (setmask
<< new_base
))
1752 first_error (_("invalid register list"));
1756 if ((mask
>> new_base
) != 0 && ! warned
)
1758 as_tsktsk (_("register list not in ascending order"));
1762 mask
|= setmask
<< new_base
;
1765 if (*str
== '-') /* We have the start of a range expression */
1771 if ((high_range
= arm_typed_reg_parse (&str
, regtype
, NULL
, NULL
))
1774 inst
.error
= gettext (reg_expected_msgs
[regtype
]);
1778 if (high_range
>= max_regs
)
1780 first_error (_("register out of range in list"));
1784 if (regtype
== REG_TYPE_NQ
)
1785 high_range
= high_range
+ 1;
1787 if (high_range
<= new_base
)
1789 inst
.error
= _("register range not in ascending order");
1793 for (new_base
+= addregs
; new_base
<= high_range
; new_base
+= addregs
)
1795 if (mask
& (setmask
<< new_base
))
1797 inst
.error
= _("invalid register list");
1801 mask
|= setmask
<< new_base
;
1806 while (skip_past_comma (&str
) != FAIL
);
1810 /* Sanity check -- should have raised a parse error above. */
1811 if (count
== 0 || count
> max_regs
)
1816 /* Final test -- the registers must be consecutive. */
1818 for (i
= 0; i
< count
; i
++)
1820 if ((mask
& (1u << i
)) == 0)
1822 inst
.error
= _("non-contiguous register range");
1832 /* True if two alias types are the same. */
1835 neon_alias_types_same (struct neon_typed_alias
*a
, struct neon_typed_alias
*b
)
1843 if (a
->defined
!= b
->defined
)
1846 if ((a
->defined
& NTA_HASTYPE
) != 0
1847 && (a
->eltype
.type
!= b
->eltype
.type
1848 || a
->eltype
.size
!= b
->eltype
.size
))
1851 if ((a
->defined
& NTA_HASINDEX
) != 0
1852 && (a
->index
!= b
->index
))
1858 /* Parse element/structure lists for Neon VLD<n> and VST<n> instructions.
1859 The base register is put in *PBASE.
1860 The lane (or one of the NEON_*_LANES constants) is placed in bits [3:0] of
1862 The register stride (minus one) is put in bit 4 of the return value.
1863 Bits [6:5] encode the list length (minus one).
1864 The type of the list elements is put in *ELTYPE, if non-NULL. */
1866 #define NEON_LANE(X) ((X) & 0xf)
1867 #define NEON_REG_STRIDE(X) ((((X) >> 4) & 1) + 1)
1868 #define NEON_REGLIST_LENGTH(X) ((((X) >> 5) & 3) + 1)
1871 parse_neon_el_struct_list (char **str
, unsigned *pbase
,
1872 struct neon_type_el
*eltype
)
1879 int leading_brace
= 0;
1880 enum arm_reg_type rtype
= REG_TYPE_NDQ
;
1882 const char *const incr_error
= _("register stride must be 1 or 2");
1883 const char *const type_error
= _("mismatched element/structure types in list");
1884 struct neon_typed_alias firsttype
;
1886 if (skip_past_char (&ptr
, '{') == SUCCESS
)
1891 struct neon_typed_alias atype
;
1892 int getreg
= parse_typed_reg_or_scalar (&ptr
, rtype
, &rtype
, &atype
);
1896 first_error (_(reg_expected_msgs
[rtype
]));
1903 if (rtype
== REG_TYPE_NQ
)
1910 else if (reg_incr
== -1)
1912 reg_incr
= getreg
- base_reg
;
1913 if (reg_incr
< 1 || reg_incr
> 2)
1915 first_error (_(incr_error
));
1919 else if (getreg
!= base_reg
+ reg_incr
* count
)
1921 first_error (_(incr_error
));
1925 if (! neon_alias_types_same (&atype
, &firsttype
))
1927 first_error (_(type_error
));
1931 /* Handle Dn-Dm or Qn-Qm syntax. Can only be used with non-indexed list
1935 struct neon_typed_alias htype
;
1936 int hireg
, dregs
= (rtype
== REG_TYPE_NQ
) ? 2 : 1;
1938 lane
= NEON_INTERLEAVE_LANES
;
1939 else if (lane
!= NEON_INTERLEAVE_LANES
)
1941 first_error (_(type_error
));
1946 else if (reg_incr
!= 1)
1948 first_error (_("don't use Rn-Rm syntax with non-unit stride"));
1952 hireg
= parse_typed_reg_or_scalar (&ptr
, rtype
, NULL
, &htype
);
1955 first_error (_(reg_expected_msgs
[rtype
]));
1958 if (! neon_alias_types_same (&htype
, &firsttype
))
1960 first_error (_(type_error
));
1963 count
+= hireg
+ dregs
- getreg
;
1967 /* If we're using Q registers, we can't use [] or [n] syntax. */
1968 if (rtype
== REG_TYPE_NQ
)
1974 if ((atype
.defined
& NTA_HASINDEX
) != 0)
1978 else if (lane
!= atype
.index
)
1980 first_error (_(type_error
));
1984 else if (lane
== -1)
1985 lane
= NEON_INTERLEAVE_LANES
;
1986 else if (lane
!= NEON_INTERLEAVE_LANES
)
1988 first_error (_(type_error
));
1993 while ((count
!= 1 || leading_brace
) && skip_past_comma (&ptr
) != FAIL
);
1995 /* No lane set by [x]. We must be interleaving structures. */
1997 lane
= NEON_INTERLEAVE_LANES
;
2000 if (lane
== -1 || base_reg
== -1 || count
< 1 || count
> 4
2001 || (count
> 1 && reg_incr
== -1))
2003 first_error (_("error parsing element/structure list"));
2007 if ((count
> 1 || leading_brace
) && skip_past_char (&ptr
, '}') == FAIL
)
2009 first_error (_("expected }"));
2017 *eltype
= firsttype
.eltype
;
2022 return lane
| ((reg_incr
- 1) << 4) | ((count
- 1) << 5);
2025 /* Parse an explicit relocation suffix on an expression. This is
2026 either nothing, or a word in parentheses. Note that if !OBJ_ELF,
2027 arm_reloc_hsh contains no entries, so this function can only
2028 succeed if there is no () after the word. Returns -1 on error,
2029 BFD_RELOC_UNUSED if there wasn't any suffix. */
2031 parse_reloc (char **str
)
2033 struct reloc_entry
*r
;
2037 return BFD_RELOC_UNUSED
;
2042 while (*q
&& *q
!= ')' && *q
!= ',')
2047 if ((r
= (struct reloc_entry
*)
2048 hash_find_n (arm_reloc_hsh
, p
, q
- p
)) == NULL
)
2055 /* Directives: register aliases. */
2057 static struct reg_entry
*
2058 insert_reg_alias (char *str
, int number
, int type
)
2060 struct reg_entry
*new_reg
;
2063 if ((new_reg
= (struct reg_entry
*) hash_find (arm_reg_hsh
, str
)) != 0)
2065 if (new_reg
->builtin
)
2066 as_warn (_("ignoring attempt to redefine built-in register '%s'"), str
);
2068 /* Only warn about a redefinition if it's not defined as the
2070 else if (new_reg
->number
!= number
|| new_reg
->type
!= type
)
2071 as_warn (_("ignoring redefinition of register alias '%s'"), str
);
2076 name
= xstrdup (str
);
2077 new_reg
= (struct reg_entry
*) xmalloc (sizeof (struct reg_entry
));
2079 new_reg
->name
= name
;
2080 new_reg
->number
= number
;
2081 new_reg
->type
= type
;
2082 new_reg
->builtin
= FALSE
;
2083 new_reg
->neon
= NULL
;
2085 if (hash_insert (arm_reg_hsh
, name
, (void *) new_reg
))
2092 insert_neon_reg_alias (char *str
, int number
, int type
,
2093 struct neon_typed_alias
*atype
)
2095 struct reg_entry
*reg
= insert_reg_alias (str
, number
, type
);
2099 first_error (_("attempt to redefine typed alias"));
2105 reg
->neon
= (struct neon_typed_alias
*)
2106 xmalloc (sizeof (struct neon_typed_alias
));
2107 *reg
->neon
= *atype
;
2111 /* Look for the .req directive. This is of the form:
2113 new_register_name .req existing_register_name
2115 If we find one, or if it looks sufficiently like one that we want to
2116 handle any error here, return TRUE. Otherwise return FALSE. */
2119 create_register_alias (char * newname
, char *p
)
2121 struct reg_entry
*old
;
2122 char *oldname
, *nbuf
;
2125 /* The input scrubber ensures that whitespace after the mnemonic is
2126 collapsed to single spaces. */
2128 if (strncmp (oldname
, " .req ", 6) != 0)
2132 if (*oldname
== '\0')
2135 old
= (struct reg_entry
*) hash_find (arm_reg_hsh
, oldname
);
2138 as_warn (_("unknown register '%s' -- .req ignored"), oldname
);
2142 /* If TC_CASE_SENSITIVE is defined, then newname already points to
2143 the desired alias name, and p points to its end. If not, then
2144 the desired alias name is in the global original_case_string. */
2145 #ifdef TC_CASE_SENSITIVE
2148 newname
= original_case_string
;
2149 nlen
= strlen (newname
);
2152 nbuf
= (char *) alloca (nlen
+ 1);
2153 memcpy (nbuf
, newname
, nlen
);
2156 /* Create aliases under the new name as stated; an all-lowercase
2157 version of the new name; and an all-uppercase version of the new
2159 if (insert_reg_alias (nbuf
, old
->number
, old
->type
) != NULL
)
2161 for (p
= nbuf
; *p
; p
++)
2164 if (strncmp (nbuf
, newname
, nlen
))
2166 /* If this attempt to create an additional alias fails, do not bother
2167 trying to create the all-lower case alias. We will fail and issue
2168 a second, duplicate error message. This situation arises when the
2169 programmer does something like:
2172 The second .req creates the "Foo" alias but then fails to create
2173 the artificial FOO alias because it has already been created by the
2175 if (insert_reg_alias (nbuf
, old
->number
, old
->type
) == NULL
)
2179 for (p
= nbuf
; *p
; p
++)
2182 if (strncmp (nbuf
, newname
, nlen
))
2183 insert_reg_alias (nbuf
, old
->number
, old
->type
);
2189 /* Create a Neon typed/indexed register alias using directives, e.g.:
2194 These typed registers can be used instead of the types specified after the
2195 Neon mnemonic, so long as all operands given have types. Types can also be
2196 specified directly, e.g.:
2197 vadd d0.s32, d1.s32, d2.s32 */
2200 create_neon_reg_alias (char *newname
, char *p
)
2202 enum arm_reg_type basetype
;
2203 struct reg_entry
*basereg
;
2204 struct reg_entry mybasereg
;
2205 struct neon_type ntype
;
2206 struct neon_typed_alias typeinfo
;
2207 char *namebuf
, *nameend
;
2210 typeinfo
.defined
= 0;
2211 typeinfo
.eltype
.type
= NT_invtype
;
2212 typeinfo
.eltype
.size
= -1;
2213 typeinfo
.index
= -1;
2217 if (strncmp (p
, " .dn ", 5) == 0)
2218 basetype
= REG_TYPE_VFD
;
2219 else if (strncmp (p
, " .qn ", 5) == 0)
2220 basetype
= REG_TYPE_NQ
;
2229 basereg
= arm_reg_parse_multi (&p
);
2231 if (basereg
&& basereg
->type
!= basetype
)
2233 as_bad (_("bad type for register"));
2237 if (basereg
== NULL
)
2240 /* Try parsing as an integer. */
2241 my_get_expression (&exp
, &p
, GE_NO_PREFIX
);
2242 if (exp
.X_op
!= O_constant
)
2244 as_bad (_("expression must be constant"));
2247 basereg
= &mybasereg
;
2248 basereg
->number
= (basetype
== REG_TYPE_NQ
) ? exp
.X_add_number
* 2
2254 typeinfo
= *basereg
->neon
;
2256 if (parse_neon_type (&ntype
, &p
) == SUCCESS
)
2258 /* We got a type. */
2259 if (typeinfo
.defined
& NTA_HASTYPE
)
2261 as_bad (_("can't redefine the type of a register alias"));
2265 typeinfo
.defined
|= NTA_HASTYPE
;
2266 if (ntype
.elems
!= 1)
2268 as_bad (_("you must specify a single type only"));
2271 typeinfo
.eltype
= ntype
.el
[0];
2274 if (skip_past_char (&p
, '[') == SUCCESS
)
2277 /* We got a scalar index. */
2279 if (typeinfo
.defined
& NTA_HASINDEX
)
2281 as_bad (_("can't redefine the index of a scalar alias"));
2285 my_get_expression (&exp
, &p
, GE_NO_PREFIX
);
2287 if (exp
.X_op
!= O_constant
)
2289 as_bad (_("scalar index must be constant"));
2293 typeinfo
.defined
|= NTA_HASINDEX
;
2294 typeinfo
.index
= exp
.X_add_number
;
2296 if (skip_past_char (&p
, ']') == FAIL
)
2298 as_bad (_("expecting ]"));
2303 namelen
= nameend
- newname
;
2304 namebuf
= (char *) alloca (namelen
+ 1);
2305 strncpy (namebuf
, newname
, namelen
);
2306 namebuf
[namelen
] = '\0';
2308 insert_neon_reg_alias (namebuf
, basereg
->number
, basetype
,
2309 typeinfo
.defined
!= 0 ? &typeinfo
: NULL
);
2311 /* Insert name in all uppercase. */
2312 for (p
= namebuf
; *p
; p
++)
2315 if (strncmp (namebuf
, newname
, namelen
))
2316 insert_neon_reg_alias (namebuf
, basereg
->number
, basetype
,
2317 typeinfo
.defined
!= 0 ? &typeinfo
: NULL
);
2319 /* Insert name in all lowercase. */
2320 for (p
= namebuf
; *p
; p
++)
2323 if (strncmp (namebuf
, newname
, namelen
))
2324 insert_neon_reg_alias (namebuf
, basereg
->number
, basetype
,
2325 typeinfo
.defined
!= 0 ? &typeinfo
: NULL
);
2330 /* Should never be called, as .req goes between the alias and the
2331 register name, not at the beginning of the line. */
2334 s_req (int a ATTRIBUTE_UNUSED
)
2336 as_bad (_("invalid syntax for .req directive"));
2340 s_dn (int a ATTRIBUTE_UNUSED
)
2342 as_bad (_("invalid syntax for .dn directive"));
2346 s_qn (int a ATTRIBUTE_UNUSED
)
2348 as_bad (_("invalid syntax for .qn directive"));
2351 /* The .unreq directive deletes an alias which was previously defined
2352 by .req. For example:
2358 s_unreq (int a ATTRIBUTE_UNUSED
)
2363 name
= input_line_pointer
;
2365 while (*input_line_pointer
!= 0
2366 && *input_line_pointer
!= ' '
2367 && *input_line_pointer
!= '\n')
2368 ++input_line_pointer
;
2370 saved_char
= *input_line_pointer
;
2371 *input_line_pointer
= 0;
2374 as_bad (_("invalid syntax for .unreq directive"));
2377 struct reg_entry
*reg
= (struct reg_entry
*) hash_find (arm_reg_hsh
,
2381 as_bad (_("unknown register alias '%s'"), name
);
2382 else if (reg
->builtin
)
2383 as_warn (_("ignoring attempt to undefine built-in register '%s'"),
2390 hash_delete (arm_reg_hsh
, name
, FALSE
);
2391 free ((char *) reg
->name
);
2396 /* Also locate the all upper case and all lower case versions.
2397 Do not complain if we cannot find one or the other as it
2398 was probably deleted above. */
2400 nbuf
= strdup (name
);
2401 for (p
= nbuf
; *p
; p
++)
2403 reg
= (struct reg_entry
*) hash_find (arm_reg_hsh
, nbuf
);
2406 hash_delete (arm_reg_hsh
, nbuf
, FALSE
);
2407 free ((char *) reg
->name
);
2413 for (p
= nbuf
; *p
; p
++)
2415 reg
= (struct reg_entry
*) hash_find (arm_reg_hsh
, nbuf
);
2418 hash_delete (arm_reg_hsh
, nbuf
, FALSE
);
2419 free ((char *) reg
->name
);
2429 *input_line_pointer
= saved_char
;
2430 demand_empty_rest_of_line ();
2433 /* Directives: Instruction set selection. */
2436 /* This code is to handle mapping symbols as defined in the ARM ELF spec.
2437 (See "Mapping symbols", section 4.5.5, ARM AAELF version 1.0).
2438 Note that previously, $a and $t has type STT_FUNC (BSF_OBJECT flag),
2439 and $d has type STT_OBJECT (BSF_OBJECT flag). Now all three are untyped. */
2441 /* Create a new mapping symbol for the transition to STATE. */
2444 make_mapping_symbol (enum mstate state
, valueT value
, fragS
*frag
)
2447 const char * symname
;
2454 type
= BSF_NO_FLAGS
;
2458 type
= BSF_NO_FLAGS
;
2462 type
= BSF_NO_FLAGS
;
2468 symbolP
= symbol_new (symname
, now_seg
, value
, frag
);
2469 symbol_get_bfdsym (symbolP
)->flags
|= type
| BSF_LOCAL
;
2474 THUMB_SET_FUNC (symbolP
, 0);
2475 ARM_SET_THUMB (symbolP
, 0);
2476 ARM_SET_INTERWORK (symbolP
, support_interwork
);
2480 THUMB_SET_FUNC (symbolP
, 1);
2481 ARM_SET_THUMB (symbolP
, 1);
2482 ARM_SET_INTERWORK (symbolP
, support_interwork
);
2490 /* Save the mapping symbols for future reference. Also check that
2491 we do not place two mapping symbols at the same offset within a
2492 frag. We'll handle overlap between frags in
2493 check_mapping_symbols. */
2496 know (frag
->tc_frag_data
.first_map
== NULL
);
2497 frag
->tc_frag_data
.first_map
= symbolP
;
2499 if (frag
->tc_frag_data
.last_map
!= NULL
)
2500 know (S_GET_VALUE (frag
->tc_frag_data
.last_map
) < S_GET_VALUE (symbolP
));
2501 frag
->tc_frag_data
.last_map
= symbolP
;
2504 /* We must sometimes convert a region marked as code to data during
2505 code alignment, if an odd number of bytes have to be padded. The
2506 code mapping symbol is pushed to an aligned address. */
2509 insert_data_mapping_symbol (enum mstate state
,
2510 valueT value
, fragS
*frag
, offsetT bytes
)
2512 /* If there was already a mapping symbol, remove it. */
2513 if (frag
->tc_frag_data
.last_map
!= NULL
2514 && S_GET_VALUE (frag
->tc_frag_data
.last_map
) == frag
->fr_address
+ value
)
2516 symbolS
*symp
= frag
->tc_frag_data
.last_map
;
2520 know (frag
->tc_frag_data
.first_map
== symp
);
2521 frag
->tc_frag_data
.first_map
= NULL
;
2523 frag
->tc_frag_data
.last_map
= NULL
;
2524 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2527 make_mapping_symbol (MAP_DATA
, value
, frag
);
2528 make_mapping_symbol (state
, value
+ bytes
, frag
);
2531 static void mapping_state_2 (enum mstate state
, int max_chars
);
2533 /* Set the mapping state to STATE. Only call this when about to
2534 emit some STATE bytes to the file. */
2537 mapping_state (enum mstate state
)
2539 enum mstate mapstate
= seg_info (now_seg
)->tc_segment_info_data
.mapstate
;
2541 #define TRANSITION(from, to) (mapstate == (from) && state == (to))
2543 if (mapstate
== state
)
2544 /* The mapping symbol has already been emitted.
2545 There is nothing else to do. */
2547 else if (TRANSITION (MAP_UNDEFINED
, MAP_DATA
))
2548 /* This case will be evaluated later in the next else. */
2550 else if (TRANSITION (MAP_UNDEFINED
, MAP_ARM
)
2551 || TRANSITION (MAP_UNDEFINED
, MAP_THUMB
))
2553 /* Only add the symbol if the offset is > 0:
2554 if we're at the first frag, check it's size > 0;
2555 if we're not at the first frag, then for sure
2556 the offset is > 0. */
2557 struct frag
* const frag_first
= seg_info (now_seg
)->frchainP
->frch_root
;
2558 const int add_symbol
= (frag_now
!= frag_first
) || (frag_now_fix () > 0);
2561 make_mapping_symbol (MAP_DATA
, (valueT
) 0, frag_first
);
2564 mapping_state_2 (state
, 0);
2568 /* Same as mapping_state, but MAX_CHARS bytes have already been
2569 allocated. Put the mapping symbol that far back. */
2572 mapping_state_2 (enum mstate state
, int max_chars
)
2574 enum mstate mapstate
= seg_info (now_seg
)->tc_segment_info_data
.mapstate
;
2576 if (!SEG_NORMAL (now_seg
))
2579 if (mapstate
== state
)
2580 /* The mapping symbol has already been emitted.
2581 There is nothing else to do. */
2584 seg_info (now_seg
)->tc_segment_info_data
.mapstate
= state
;
2585 make_mapping_symbol (state
, (valueT
) frag_now_fix () - max_chars
, frag_now
);
2588 #define mapping_state(x) ((void)0)
2589 #define mapping_state_2(x, y) ((void)0)
2592 /* Find the real, Thumb encoded start of a Thumb function. */
2596 find_real_start (symbolS
* symbolP
)
2599 const char * name
= S_GET_NAME (symbolP
);
2600 symbolS
* new_target
;
2602 /* This definition must agree with the one in gcc/config/arm/thumb.c. */
2603 #define STUB_NAME ".real_start_of"
2608 /* The compiler may generate BL instructions to local labels because
2609 it needs to perform a branch to a far away location. These labels
2610 do not have a corresponding ".real_start_of" label. We check
2611 both for S_IS_LOCAL and for a leading dot, to give a way to bypass
2612 the ".real_start_of" convention for nonlocal branches. */
2613 if (S_IS_LOCAL (symbolP
) || name
[0] == '.')
2616 real_start
= ACONCAT ((STUB_NAME
, name
, NULL
));
2617 new_target
= symbol_find (real_start
);
2619 if (new_target
== NULL
)
2621 as_warn (_("Failed to find real start of function: %s\n"), name
);
2622 new_target
= symbolP
;
2630 opcode_select (int width
)
2637 if (!ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v4t
))
2638 as_bad (_("selected processor does not support THUMB opcodes"));
2641 /* No need to force the alignment, since we will have been
2642 coming from ARM mode, which is word-aligned. */
2643 record_alignment (now_seg
, 1);
2650 if (!ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v1
))
2651 as_bad (_("selected processor does not support ARM opcodes"));
2656 frag_align (2, 0, 0);
2658 record_alignment (now_seg
, 1);
2663 as_bad (_("invalid instruction size selected (%d)"), width
);
2668 s_arm (int ignore ATTRIBUTE_UNUSED
)
2671 demand_empty_rest_of_line ();
2675 s_thumb (int ignore ATTRIBUTE_UNUSED
)
2678 demand_empty_rest_of_line ();
2682 s_code (int unused ATTRIBUTE_UNUSED
)
2686 temp
= get_absolute_expression ();
2691 opcode_select (temp
);
2695 as_bad (_("invalid operand to .code directive (%d) (expecting 16 or 32)"), temp
);
2700 s_force_thumb (int ignore ATTRIBUTE_UNUSED
)
2702 /* If we are not already in thumb mode go into it, EVEN if
2703 the target processor does not support thumb instructions.
2704 This is used by gcc/config/arm/lib1funcs.asm for example
2705 to compile interworking support functions even if the
2706 target processor should not support interworking. */
2710 record_alignment (now_seg
, 1);
2713 demand_empty_rest_of_line ();
2717 s_thumb_func (int ignore ATTRIBUTE_UNUSED
)
2721 /* The following label is the name/address of the start of a Thumb function.
2722 We need to know this for the interworking support. */
2723 label_is_thumb_function_name
= TRUE
;
2726 /* Perform a .set directive, but also mark the alias as
2727 being a thumb function. */
2730 s_thumb_set (int equiv
)
2732 /* XXX the following is a duplicate of the code for s_set() in read.c
2733 We cannot just call that code as we need to get at the symbol that
2740 /* Especial apologies for the random logic:
2741 This just grew, and could be parsed much more simply!
2743 name
= input_line_pointer
;
2744 delim
= get_symbol_end ();
2745 end_name
= input_line_pointer
;
2748 if (*input_line_pointer
!= ',')
2751 as_bad (_("expected comma after name \"%s\""), name
);
2753 ignore_rest_of_line ();
2757 input_line_pointer
++;
2760 if (name
[0] == '.' && name
[1] == '\0')
2762 /* XXX - this should not happen to .thumb_set. */
2766 if ((symbolP
= symbol_find (name
)) == NULL
2767 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
2770 /* When doing symbol listings, play games with dummy fragments living
2771 outside the normal fragment chain to record the file and line info
2773 if (listing
& LISTING_SYMBOLS
)
2775 extern struct list_info_struct
* listing_tail
;
2776 fragS
* dummy_frag
= (fragS
* ) xmalloc (sizeof (fragS
));
2778 memset (dummy_frag
, 0, sizeof (fragS
));
2779 dummy_frag
->fr_type
= rs_fill
;
2780 dummy_frag
->line
= listing_tail
;
2781 symbolP
= symbol_new (name
, undefined_section
, 0, dummy_frag
);
2782 dummy_frag
->fr_symbol
= symbolP
;
2786 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2789 /* "set" symbols are local unless otherwise specified. */
2790 SF_SET_LOCAL (symbolP
);
2791 #endif /* OBJ_COFF */
2792 } /* Make a new symbol. */
2794 symbol_table_insert (symbolP
);
2799 && S_IS_DEFINED (symbolP
)
2800 && S_GET_SEGMENT (symbolP
) != reg_section
)
2801 as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP
));
2803 pseudo_set (symbolP
);
2805 demand_empty_rest_of_line ();
2807 /* XXX Now we come to the Thumb specific bit of code. */
2809 THUMB_SET_FUNC (symbolP
, 1);
2810 ARM_SET_THUMB (symbolP
, 1);
2811 #if defined OBJ_ELF || defined OBJ_COFF
2812 ARM_SET_INTERWORK (symbolP
, support_interwork
);
2816 /* Directives: Mode selection. */
2818 /* .syntax [unified|divided] - choose the new unified syntax
2819 (same for Arm and Thumb encoding, modulo slight differences in what
2820 can be represented) or the old divergent syntax for each mode. */
2822 s_syntax (int unused ATTRIBUTE_UNUSED
)
2826 name
= input_line_pointer
;
2827 delim
= get_symbol_end ();
2829 if (!strcasecmp (name
, "unified"))
2830 unified_syntax
= TRUE
;
2831 else if (!strcasecmp (name
, "divided"))
2832 unified_syntax
= FALSE
;
2835 as_bad (_("unrecognized syntax mode \"%s\""), name
);
2838 *input_line_pointer
= delim
;
2839 demand_empty_rest_of_line ();
2842 /* Directives: sectioning and alignment. */
2844 /* Same as s_align_ptwo but align 0 => align 2. */
2847 s_align (int unused ATTRIBUTE_UNUSED
)
2852 long max_alignment
= 15;
2854 temp
= get_absolute_expression ();
2855 if (temp
> max_alignment
)
2856 as_bad (_("alignment too large: %d assumed"), temp
= max_alignment
);
2859 as_bad (_("alignment negative. 0 assumed."));
2863 if (*input_line_pointer
== ',')
2865 input_line_pointer
++;
2866 temp_fill
= get_absolute_expression ();
2878 /* Only make a frag if we HAVE to. */
2879 if (temp
&& !need_pass_2
)
2881 if (!fill_p
&& subseg_text_p (now_seg
))
2882 frag_align_code (temp
, 0);
2884 frag_align (temp
, (int) temp_fill
, 0);
2886 demand_empty_rest_of_line ();
2888 record_alignment (now_seg
, temp
);
2892 s_bss (int ignore ATTRIBUTE_UNUSED
)
2894 /* We don't support putting frags in the BSS segment, we fake it by
2895 marking in_bss, then looking at s_skip for clues. */
2896 subseg_set (bss_section
, 0);
2897 demand_empty_rest_of_line ();
2899 #ifdef md_elf_section_change_hook
2900 md_elf_section_change_hook ();
2905 s_even (int ignore ATTRIBUTE_UNUSED
)
2907 /* Never make frag if expect extra pass. */
2909 frag_align (1, 0, 0);
2911 record_alignment (now_seg
, 1);
2913 demand_empty_rest_of_line ();
2916 /* Directives: Literal pools. */
2918 static literal_pool
*
2919 find_literal_pool (void)
2921 literal_pool
* pool
;
2923 for (pool
= list_of_pools
; pool
!= NULL
; pool
= pool
->next
)
2925 if (pool
->section
== now_seg
2926 && pool
->sub_section
== now_subseg
)
2933 static literal_pool
*
2934 find_or_make_literal_pool (void)
2936 /* Next literal pool ID number. */
2937 static unsigned int latest_pool_num
= 1;
2938 literal_pool
* pool
;
2940 pool
= find_literal_pool ();
2944 /* Create a new pool. */
2945 pool
= (literal_pool
*) xmalloc (sizeof (* pool
));
2949 pool
->next_free_entry
= 0;
2950 pool
->section
= now_seg
;
2951 pool
->sub_section
= now_subseg
;
2952 pool
->next
= list_of_pools
;
2953 pool
->symbol
= NULL
;
2955 /* Add it to the list. */
2956 list_of_pools
= pool
;
2959 /* New pools, and emptied pools, will have a NULL symbol. */
2960 if (pool
->symbol
== NULL
)
2962 pool
->symbol
= symbol_create (FAKE_LABEL_NAME
, undefined_section
,
2963 (valueT
) 0, &zero_address_frag
);
2964 pool
->id
= latest_pool_num
++;
2971 /* Add the literal in the global 'inst'
2972 structure to the relevant literal pool. */
2975 add_to_lit_pool (void)
2977 literal_pool
* pool
;
2980 pool
= find_or_make_literal_pool ();
2982 /* Check if this literal value is already in the pool. */
2983 for (entry
= 0; entry
< pool
->next_free_entry
; entry
++)
2985 if ((pool
->literals
[entry
].X_op
== inst
.reloc
.exp
.X_op
)
2986 && (inst
.reloc
.exp
.X_op
== O_constant
)
2987 && (pool
->literals
[entry
].X_add_number
2988 == inst
.reloc
.exp
.X_add_number
)
2989 && (pool
->literals
[entry
].X_unsigned
2990 == inst
.reloc
.exp
.X_unsigned
))
2993 if ((pool
->literals
[entry
].X_op
== inst
.reloc
.exp
.X_op
)
2994 && (inst
.reloc
.exp
.X_op
== O_symbol
)
2995 && (pool
->literals
[entry
].X_add_number
2996 == inst
.reloc
.exp
.X_add_number
)
2997 && (pool
->literals
[entry
].X_add_symbol
2998 == inst
.reloc
.exp
.X_add_symbol
)
2999 && (pool
->literals
[entry
].X_op_symbol
3000 == inst
.reloc
.exp
.X_op_symbol
))
3004 /* Do we need to create a new entry? */
3005 if (entry
== pool
->next_free_entry
)
3007 if (entry
>= MAX_LITERAL_POOL_SIZE
)
3009 inst
.error
= _("literal pool overflow");
3013 pool
->literals
[entry
] = inst
.reloc
.exp
;
3014 pool
->next_free_entry
+= 1;
3017 inst
.reloc
.exp
.X_op
= O_symbol
;
3018 inst
.reloc
.exp
.X_add_number
= ((int) entry
) * 4;
3019 inst
.reloc
.exp
.X_add_symbol
= pool
->symbol
;
3024 /* Can't use symbol_new here, so have to create a symbol and then at
3025 a later date assign it a value. Thats what these functions do. */
3028 symbol_locate (symbolS
* symbolP
,
3029 const char * name
, /* It is copied, the caller can modify. */
3030 segT segment
, /* Segment identifier (SEG_<something>). */
3031 valueT valu
, /* Symbol value. */
3032 fragS
* frag
) /* Associated fragment. */
3034 unsigned int name_length
;
3035 char * preserved_copy_of_name
;
3037 name_length
= strlen (name
) + 1; /* +1 for \0. */
3038 obstack_grow (¬es
, name
, name_length
);
3039 preserved_copy_of_name
= (char *) obstack_finish (¬es
);
3041 #ifdef tc_canonicalize_symbol_name
3042 preserved_copy_of_name
=
3043 tc_canonicalize_symbol_name (preserved_copy_of_name
);
3046 S_SET_NAME (symbolP
, preserved_copy_of_name
);
3048 S_SET_SEGMENT (symbolP
, segment
);
3049 S_SET_VALUE (symbolP
, valu
);
3050 symbol_clear_list_pointers (symbolP
);
3052 symbol_set_frag (symbolP
, frag
);
3054 /* Link to end of symbol chain. */
3056 extern int symbol_table_frozen
;
3058 if (symbol_table_frozen
)
3062 symbol_append (symbolP
, symbol_lastP
, & symbol_rootP
, & symbol_lastP
);
3064 obj_symbol_new_hook (symbolP
);
3066 #ifdef tc_symbol_new_hook
3067 tc_symbol_new_hook (symbolP
);
3071 verify_symbol_chain (symbol_rootP
, symbol_lastP
);
3072 #endif /* DEBUG_SYMS */
3077 s_ltorg (int ignored ATTRIBUTE_UNUSED
)
3080 literal_pool
* pool
;
3083 pool
= find_literal_pool ();
3085 || pool
->symbol
== NULL
3086 || pool
->next_free_entry
== 0)
3089 mapping_state (MAP_DATA
);
3091 /* Align pool as you have word accesses.
3092 Only make a frag if we have to. */
3094 frag_align (2, 0, 0);
3096 record_alignment (now_seg
, 2);
3098 sprintf (sym_name
, "$$lit_\002%x", pool
->id
);
3100 symbol_locate (pool
->symbol
, sym_name
, now_seg
,
3101 (valueT
) frag_now_fix (), frag_now
);
3102 symbol_table_insert (pool
->symbol
);
3104 ARM_SET_THUMB (pool
->symbol
, thumb_mode
);
3106 #if defined OBJ_COFF || defined OBJ_ELF
3107 ARM_SET_INTERWORK (pool
->symbol
, support_interwork
);
3110 for (entry
= 0; entry
< pool
->next_free_entry
; entry
++)
3111 /* First output the expression in the instruction to the pool. */
3112 emit_expr (&(pool
->literals
[entry
]), 4); /* .word */
3114 /* Mark the pool as empty. */
3115 pool
->next_free_entry
= 0;
3116 pool
->symbol
= NULL
;
3120 /* Forward declarations for functions below, in the MD interface
3122 static void fix_new_arm (fragS
*, int, short, expressionS
*, int, int);
3123 static valueT
create_unwind_entry (int);
3124 static void start_unwind_section (const segT
, int);
3125 static void add_unwind_opcode (valueT
, int);
3126 static void flush_pending_unwind (void);
3128 /* Directives: Data. */
3131 s_arm_elf_cons (int nbytes
)
3135 #ifdef md_flush_pending_output
3136 md_flush_pending_output ();
3139 if (is_it_end_of_statement ())
3141 demand_empty_rest_of_line ();
3145 #ifdef md_cons_align
3146 md_cons_align (nbytes
);
3149 mapping_state (MAP_DATA
);
3153 char *base
= input_line_pointer
;
3157 if (exp
.X_op
!= O_symbol
)
3158 emit_expr (&exp
, (unsigned int) nbytes
);
3161 char *before_reloc
= input_line_pointer
;
3162 reloc
= parse_reloc (&input_line_pointer
);
3165 as_bad (_("unrecognized relocation suffix"));
3166 ignore_rest_of_line ();
3169 else if (reloc
== BFD_RELOC_UNUSED
)
3170 emit_expr (&exp
, (unsigned int) nbytes
);
3173 reloc_howto_type
*howto
= (reloc_howto_type
*)
3174 bfd_reloc_type_lookup (stdoutput
,
3175 (bfd_reloc_code_real_type
) reloc
);
3176 int size
= bfd_get_reloc_size (howto
);
3178 if (reloc
== BFD_RELOC_ARM_PLT32
)
3180 as_bad (_("(plt) is only valid on branch targets"));
3181 reloc
= BFD_RELOC_UNUSED
;
3186 as_bad (_("%s relocations do not fit in %d bytes"),
3187 howto
->name
, nbytes
);
3190 /* We've parsed an expression stopping at O_symbol.
3191 But there may be more expression left now that we
3192 have parsed the relocation marker. Parse it again.
3193 XXX Surely there is a cleaner way to do this. */
3194 char *p
= input_line_pointer
;
3196 char *save_buf
= (char *) alloca (input_line_pointer
- base
);
3197 memcpy (save_buf
, base
, input_line_pointer
- base
);
3198 memmove (base
+ (input_line_pointer
- before_reloc
),
3199 base
, before_reloc
- base
);
3201 input_line_pointer
= base
+ (input_line_pointer
-before_reloc
);
3203 memcpy (base
, save_buf
, p
- base
);
3205 offset
= nbytes
- size
;
3206 p
= frag_more ((int) nbytes
);
3207 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
,
3208 size
, &exp
, 0, (enum bfd_reloc_code_real
) reloc
);
3213 while (*input_line_pointer
++ == ',');
3215 /* Put terminator back into stream. */
3216 input_line_pointer
--;
3217 demand_empty_rest_of_line ();
3220 /* Emit an expression containing a 32-bit thumb instruction.
3221 Implementation based on put_thumb32_insn. */
3224 emit_thumb32_expr (expressionS
* exp
)
3226 expressionS exp_high
= *exp
;
3228 exp_high
.X_add_number
= (unsigned long)exp_high
.X_add_number
>> 16;
3229 emit_expr (& exp_high
, (unsigned int) THUMB_SIZE
);
3230 exp
->X_add_number
&= 0xffff;
3231 emit_expr (exp
, (unsigned int) THUMB_SIZE
);
3234 /* Guess the instruction size based on the opcode. */
3237 thumb_insn_size (int opcode
)
3239 if ((unsigned int) opcode
< 0xe800u
)
3241 else if ((unsigned int) opcode
>= 0xe8000000u
)
3248 emit_insn (expressionS
*exp
, int nbytes
)
3252 if (exp
->X_op
== O_constant
)
3257 size
= thumb_insn_size (exp
->X_add_number
);
3261 if (size
== 2 && (unsigned int)exp
->X_add_number
> 0xffffu
)
3263 as_bad (_(".inst.n operand too big. "\
3264 "Use .inst.w instead"));
3269 if (now_it
.state
== AUTOMATIC_IT_BLOCK
)
3270 set_it_insn_type_nonvoid (OUTSIDE_IT_INSN
, 0);
3272 set_it_insn_type_nonvoid (NEUTRAL_IT_INSN
, 0);
3274 if (thumb_mode
&& (size
> THUMB_SIZE
) && !target_big_endian
)
3275 emit_thumb32_expr (exp
);
3277 emit_expr (exp
, (unsigned int) size
);
3279 it_fsm_post_encode ();
3283 as_bad (_("cannot determine Thumb instruction size. " \
3284 "Use .inst.n/.inst.w instead"));
3287 as_bad (_("constant expression required"));
3292 /* Like s_arm_elf_cons but do not use md_cons_align and
3293 set the mapping state to MAP_ARM/MAP_THUMB. */
3296 s_arm_elf_inst (int nbytes
)
3298 if (is_it_end_of_statement ())
3300 demand_empty_rest_of_line ();
3304 /* Calling mapping_state () here will not change ARM/THUMB,
3305 but will ensure not to be in DATA state. */
3308 mapping_state (MAP_THUMB
);
3313 as_bad (_("width suffixes are invalid in ARM mode"));
3314 ignore_rest_of_line ();
3320 mapping_state (MAP_ARM
);
3329 if (! emit_insn (& exp
, nbytes
))
3331 ignore_rest_of_line ();
3335 while (*input_line_pointer
++ == ',');
3337 /* Put terminator back into stream. */
3338 input_line_pointer
--;
3339 demand_empty_rest_of_line ();
3342 /* Parse a .rel31 directive. */
3345 s_arm_rel31 (int ignored ATTRIBUTE_UNUSED
)
3352 if (*input_line_pointer
== '1')
3353 highbit
= 0x80000000;
3354 else if (*input_line_pointer
!= '0')
3355 as_bad (_("expected 0 or 1"));
3357 input_line_pointer
++;
3358 if (*input_line_pointer
!= ',')
3359 as_bad (_("missing comma"));
3360 input_line_pointer
++;
3362 #ifdef md_flush_pending_output
3363 md_flush_pending_output ();
3366 #ifdef md_cons_align
3370 mapping_state (MAP_DATA
);
3375 md_number_to_chars (p
, highbit
, 4);
3376 fix_new_arm (frag_now
, p
- frag_now
->fr_literal
, 4, &exp
, 1,
3377 BFD_RELOC_ARM_PREL31
);
3379 demand_empty_rest_of_line ();
3382 /* Directives: AEABI stack-unwind tables. */
3384 /* Parse an unwind_fnstart directive. Simply records the current location. */
3387 s_arm_unwind_fnstart (int ignored ATTRIBUTE_UNUSED
)
3389 demand_empty_rest_of_line ();
3390 if (unwind
.proc_start
)
3392 as_bad (_("duplicate .fnstart directive"));
3396 /* Mark the start of the function. */
3397 unwind
.proc_start
= expr_build_dot ();
3399 /* Reset the rest of the unwind info. */
3400 unwind
.opcode_count
= 0;
3401 unwind
.table_entry
= NULL
;
3402 unwind
.personality_routine
= NULL
;
3403 unwind
.personality_index
= -1;
3404 unwind
.frame_size
= 0;
3405 unwind
.fp_offset
= 0;
3406 unwind
.fp_reg
= REG_SP
;
3408 unwind
.sp_restored
= 0;
3412 /* Parse a handlerdata directive. Creates the exception handling table entry
3413 for the function. */
3416 s_arm_unwind_handlerdata (int ignored ATTRIBUTE_UNUSED
)
3418 demand_empty_rest_of_line ();
3419 if (!unwind
.proc_start
)
3420 as_bad (MISSING_FNSTART
);
3422 if (unwind
.table_entry
)
3423 as_bad (_("duplicate .handlerdata directive"));
3425 create_unwind_entry (1);
3428 /* Parse an unwind_fnend directive. Generates the index table entry. */
3431 s_arm_unwind_fnend (int ignored ATTRIBUTE_UNUSED
)
3436 unsigned int marked_pr_dependency
;
3438 demand_empty_rest_of_line ();
3440 if (!unwind
.proc_start
)
3442 as_bad (_(".fnend directive without .fnstart"));
3446 /* Add eh table entry. */
3447 if (unwind
.table_entry
== NULL
)
3448 val
= create_unwind_entry (0);
3452 /* Add index table entry. This is two words. */
3453 start_unwind_section (unwind
.saved_seg
, 1);
3454 frag_align (2, 0, 0);
3455 record_alignment (now_seg
, 2);
3457 ptr
= frag_more (8);
3458 where
= frag_now_fix () - 8;
3460 /* Self relative offset of the function start. */
3461 fix_new (frag_now
, where
, 4, unwind
.proc_start
, 0, 1,
3462 BFD_RELOC_ARM_PREL31
);
3464 /* Indicate dependency on EHABI-defined personality routines to the
3465 linker, if it hasn't been done already. */
3466 marked_pr_dependency
3467 = seg_info (now_seg
)->tc_segment_info_data
.marked_pr_dependency
;
3468 if (unwind
.personality_index
>= 0 && unwind
.personality_index
< 3
3469 && !(marked_pr_dependency
& (1 << unwind
.personality_index
)))
3471 static const char *const name
[] =
3473 "__aeabi_unwind_cpp_pr0",
3474 "__aeabi_unwind_cpp_pr1",
3475 "__aeabi_unwind_cpp_pr2"
3477 symbolS
*pr
= symbol_find_or_make (name
[unwind
.personality_index
]);
3478 fix_new (frag_now
, where
, 0, pr
, 0, 1, BFD_RELOC_NONE
);
3479 seg_info (now_seg
)->tc_segment_info_data
.marked_pr_dependency
3480 |= 1 << unwind
.personality_index
;
3484 /* Inline exception table entry. */
3485 md_number_to_chars (ptr
+ 4, val
, 4);
3487 /* Self relative offset of the table entry. */
3488 fix_new (frag_now
, where
+ 4, 4, unwind
.table_entry
, 0, 1,
3489 BFD_RELOC_ARM_PREL31
);
3491 /* Restore the original section. */
3492 subseg_set (unwind
.saved_seg
, unwind
.saved_subseg
);
3494 unwind
.proc_start
= NULL
;
3498 /* Parse an unwind_cantunwind directive. */
3501 s_arm_unwind_cantunwind (int ignored ATTRIBUTE_UNUSED
)
3503 demand_empty_rest_of_line ();
3504 if (!unwind
.proc_start
)
3505 as_bad (MISSING_FNSTART
);
3507 if (unwind
.personality_routine
|| unwind
.personality_index
!= -1)
3508 as_bad (_("personality routine specified for cantunwind frame"));
3510 unwind
.personality_index
= -2;
3514 /* Parse a personalityindex directive. */
3517 s_arm_unwind_personalityindex (int ignored ATTRIBUTE_UNUSED
)
3521 if (!unwind
.proc_start
)
3522 as_bad (MISSING_FNSTART
);
3524 if (unwind
.personality_routine
|| unwind
.personality_index
!= -1)
3525 as_bad (_("duplicate .personalityindex directive"));
3529 if (exp
.X_op
!= O_constant
3530 || exp
.X_add_number
< 0 || exp
.X_add_number
> 15)
3532 as_bad (_("bad personality routine number"));
3533 ignore_rest_of_line ();
3537 unwind
.personality_index
= exp
.X_add_number
;
3539 demand_empty_rest_of_line ();
3543 /* Parse a personality directive. */
3546 s_arm_unwind_personality (int ignored ATTRIBUTE_UNUSED
)
3550 if (!unwind
.proc_start
)
3551 as_bad (MISSING_FNSTART
);
3553 if (unwind
.personality_routine
|| unwind
.personality_index
!= -1)
3554 as_bad (_("duplicate .personality directive"));
3556 name
= input_line_pointer
;
3557 c
= get_symbol_end ();
3558 p
= input_line_pointer
;
3559 unwind
.personality_routine
= symbol_find_or_make (name
);
3561 demand_empty_rest_of_line ();
3565 /* Parse a directive saving core registers. */
3568 s_arm_unwind_save_core (void)
3574 range
= parse_reg_list (&input_line_pointer
);
3577 as_bad (_("expected register list"));
3578 ignore_rest_of_line ();
3582 demand_empty_rest_of_line ();
3584 /* Turn .unwind_movsp ip followed by .unwind_save {..., ip, ...}
3585 into .unwind_save {..., sp...}. We aren't bothered about the value of
3586 ip because it is clobbered by calls. */
3587 if (unwind
.sp_restored
&& unwind
.fp_reg
== 12
3588 && (range
& 0x3000) == 0x1000)
3590 unwind
.opcode_count
--;
3591 unwind
.sp_restored
= 0;
3592 range
= (range
| 0x2000) & ~0x1000;
3593 unwind
.pending_offset
= 0;
3599 /* See if we can use the short opcodes. These pop a block of up to 8
3600 registers starting with r4, plus maybe r14. */
3601 for (n
= 0; n
< 8; n
++)
3603 /* Break at the first non-saved register. */
3604 if ((range
& (1 << (n
+ 4))) == 0)
3607 /* See if there are any other bits set. */
3608 if (n
== 0 || (range
& (0xfff0 << n
) & 0xbff0) != 0)
3610 /* Use the long form. */
3611 op
= 0x8000 | ((range
>> 4) & 0xfff);
3612 add_unwind_opcode (op
, 2);
3616 /* Use the short form. */
3618 op
= 0xa8; /* Pop r14. */
3620 op
= 0xa0; /* Do not pop r14. */
3622 add_unwind_opcode (op
, 1);
3629 op
= 0xb100 | (range
& 0xf);
3630 add_unwind_opcode (op
, 2);
3633 /* Record the number of bytes pushed. */
3634 for (n
= 0; n
< 16; n
++)
3636 if (range
& (1 << n
))
3637 unwind
.frame_size
+= 4;
3642 /* Parse a directive saving FPA registers. */
3645 s_arm_unwind_save_fpa (int reg
)
3651 /* Get Number of registers to transfer. */
3652 if (skip_past_comma (&input_line_pointer
) != FAIL
)
3655 exp
.X_op
= O_illegal
;
3657 if (exp
.X_op
!= O_constant
)
3659 as_bad (_("expected , <constant>"));
3660 ignore_rest_of_line ();
3664 num_regs
= exp
.X_add_number
;
3666 if (num_regs
< 1 || num_regs
> 4)
3668 as_bad (_("number of registers must be in the range [1:4]"));
3669 ignore_rest_of_line ();
3673 demand_empty_rest_of_line ();
3678 op
= 0xb4 | (num_regs
- 1);
3679 add_unwind_opcode (op
, 1);
3684 op
= 0xc800 | (reg
<< 4) | (num_regs
- 1);
3685 add_unwind_opcode (op
, 2);
3687 unwind
.frame_size
+= num_regs
* 12;
3691 /* Parse a directive saving VFP registers for ARMv6 and above. */
3694 s_arm_unwind_save_vfp_armv6 (void)
3699 int num_vfpv3_regs
= 0;
3700 int num_regs_below_16
;
3702 count
= parse_vfp_reg_list (&input_line_pointer
, &start
, REGLIST_VFP_D
);
3705 as_bad (_("expected register list"));
3706 ignore_rest_of_line ();
3710 demand_empty_rest_of_line ();
3712 /* We always generate FSTMD/FLDMD-style unwinding opcodes (rather
3713 than FSTMX/FLDMX-style ones). */
3715 /* Generate opcode for (VFPv3) registers numbered in the range 16 .. 31. */
3717 num_vfpv3_regs
= count
;
3718 else if (start
+ count
> 16)
3719 num_vfpv3_regs
= start
+ count
- 16;
3721 if (num_vfpv3_regs
> 0)
3723 int start_offset
= start
> 16 ? start
- 16 : 0;
3724 op
= 0xc800 | (start_offset
<< 4) | (num_vfpv3_regs
- 1);
3725 add_unwind_opcode (op
, 2);
3728 /* Generate opcode for registers numbered in the range 0 .. 15. */
3729 num_regs_below_16
= num_vfpv3_regs
> 0 ? 16 - (int) start
: count
;
3730 gas_assert (num_regs_below_16
+ num_vfpv3_regs
== count
);
3731 if (num_regs_below_16
> 0)
3733 op
= 0xc900 | (start
<< 4) | (num_regs_below_16
- 1);
3734 add_unwind_opcode (op
, 2);
3737 unwind
.frame_size
+= count
* 8;
3741 /* Parse a directive saving VFP registers for pre-ARMv6. */
3744 s_arm_unwind_save_vfp (void)
3750 count
= parse_vfp_reg_list (&input_line_pointer
, ®
, REGLIST_VFP_D
);
3753 as_bad (_("expected register list"));
3754 ignore_rest_of_line ();
3758 demand_empty_rest_of_line ();
3763 op
= 0xb8 | (count
- 1);
3764 add_unwind_opcode (op
, 1);
3769 op
= 0xb300 | (reg
<< 4) | (count
- 1);
3770 add_unwind_opcode (op
, 2);
3772 unwind
.frame_size
+= count
* 8 + 4;
3776 /* Parse a directive saving iWMMXt data registers. */
3779 s_arm_unwind_save_mmxwr (void)
3787 if (*input_line_pointer
== '{')
3788 input_line_pointer
++;
3792 reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_MMXWR
);
3796 as_bad ("%s", _(reg_expected_msgs
[REG_TYPE_MMXWR
]));
3801 as_tsktsk (_("register list not in ascending order"));
3804 if (*input_line_pointer
== '-')
3806 input_line_pointer
++;
3807 hi_reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_MMXWR
);
3810 as_bad ("%s", _(reg_expected_msgs
[REG_TYPE_MMXWR
]));
3813 else if (reg
>= hi_reg
)
3815 as_bad (_("bad register range"));
3818 for (; reg
< hi_reg
; reg
++)
3822 while (skip_past_comma (&input_line_pointer
) != FAIL
);
3824 if (*input_line_pointer
== '}')
3825 input_line_pointer
++;
3827 demand_empty_rest_of_line ();
3829 /* Generate any deferred opcodes because we're going to be looking at
3831 flush_pending_unwind ();
3833 for (i
= 0; i
< 16; i
++)
3835 if (mask
& (1 << i
))
3836 unwind
.frame_size
+= 8;
3839 /* Attempt to combine with a previous opcode. We do this because gcc
3840 likes to output separate unwind directives for a single block of
3842 if (unwind
.opcode_count
> 0)
3844 i
= unwind
.opcodes
[unwind
.opcode_count
- 1];
3845 if ((i
& 0xf8) == 0xc0)
3848 /* Only merge if the blocks are contiguous. */
3851 if ((mask
& 0xfe00) == (1 << 9))
3853 mask
|= ((1 << (i
+ 11)) - 1) & 0xfc00;
3854 unwind
.opcode_count
--;
3857 else if (i
== 6 && unwind
.opcode_count
>= 2)
3859 i
= unwind
.opcodes
[unwind
.opcode_count
- 2];
3863 op
= 0xffff << (reg
- 1);
3865 && ((mask
& op
) == (1u << (reg
- 1))))
3867 op
= (1 << (reg
+ i
+ 1)) - 1;
3868 op
&= ~((1 << reg
) - 1);
3870 unwind
.opcode_count
-= 2;
3877 /* We want to generate opcodes in the order the registers have been
3878 saved, ie. descending order. */
3879 for (reg
= 15; reg
>= -1; reg
--)
3881 /* Save registers in blocks. */
3883 || !(mask
& (1 << reg
)))
3885 /* We found an unsaved reg. Generate opcodes to save the
3892 op
= 0xc0 | (hi_reg
- 10);
3893 add_unwind_opcode (op
, 1);
3898 op
= 0xc600 | ((reg
+ 1) << 4) | ((hi_reg
- reg
) - 1);
3899 add_unwind_opcode (op
, 2);
3908 ignore_rest_of_line ();
3912 s_arm_unwind_save_mmxwcg (void)
3919 if (*input_line_pointer
== '{')
3920 input_line_pointer
++;
3924 reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_MMXWCG
);
3928 as_bad ("%s", _(reg_expected_msgs
[REG_TYPE_MMXWCG
]));
3934 as_tsktsk (_("register list not in ascending order"));
3937 if (*input_line_pointer
== '-')
3939 input_line_pointer
++;
3940 hi_reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_MMXWCG
);
3943 as_bad ("%s", _(reg_expected_msgs
[REG_TYPE_MMXWCG
]));
3946 else if (reg
>= hi_reg
)
3948 as_bad (_("bad register range"));
3951 for (; reg
< hi_reg
; reg
++)
3955 while (skip_past_comma (&input_line_pointer
) != FAIL
);
3957 if (*input_line_pointer
== '}')
3958 input_line_pointer
++;
3960 demand_empty_rest_of_line ();
3962 /* Generate any deferred opcodes because we're going to be looking at
3964 flush_pending_unwind ();
3966 for (reg
= 0; reg
< 16; reg
++)
3968 if (mask
& (1 << reg
))
3969 unwind
.frame_size
+= 4;
3972 add_unwind_opcode (op
, 2);
3975 ignore_rest_of_line ();
3979 /* Parse an unwind_save directive.
3980 If the argument is non-zero, this is a .vsave directive. */
3983 s_arm_unwind_save (int arch_v6
)
3986 struct reg_entry
*reg
;
3987 bfd_boolean had_brace
= FALSE
;
3989 if (!unwind
.proc_start
)
3990 as_bad (MISSING_FNSTART
);
3992 /* Figure out what sort of save we have. */
3993 peek
= input_line_pointer
;
4001 reg
= arm_reg_parse_multi (&peek
);
4005 as_bad (_("register expected"));
4006 ignore_rest_of_line ();
4015 as_bad (_("FPA .unwind_save does not take a register list"));
4016 ignore_rest_of_line ();
4019 input_line_pointer
= peek
;
4020 s_arm_unwind_save_fpa (reg
->number
);
4023 case REG_TYPE_RN
: s_arm_unwind_save_core (); return;
4026 s_arm_unwind_save_vfp_armv6 ();
4028 s_arm_unwind_save_vfp ();
4030 case REG_TYPE_MMXWR
: s_arm_unwind_save_mmxwr (); return;
4031 case REG_TYPE_MMXWCG
: s_arm_unwind_save_mmxwcg (); return;
4034 as_bad (_(".unwind_save does not support this kind of register"));
4035 ignore_rest_of_line ();
4040 /* Parse an unwind_movsp directive. */
4043 s_arm_unwind_movsp (int ignored ATTRIBUTE_UNUSED
)
4049 if (!unwind
.proc_start
)
4050 as_bad (MISSING_FNSTART
);
4052 reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_RN
);
4055 as_bad ("%s", _(reg_expected_msgs
[REG_TYPE_RN
]));
4056 ignore_rest_of_line ();
4060 /* Optional constant. */
4061 if (skip_past_comma (&input_line_pointer
) != FAIL
)
4063 if (immediate_for_directive (&offset
) == FAIL
)
4069 demand_empty_rest_of_line ();
4071 if (reg
== REG_SP
|| reg
== REG_PC
)
4073 as_bad (_("SP and PC not permitted in .unwind_movsp directive"));
4077 if (unwind
.fp_reg
!= REG_SP
)
4078 as_bad (_("unexpected .unwind_movsp directive"));
4080 /* Generate opcode to restore the value. */
4082 add_unwind_opcode (op
, 1);
4084 /* Record the information for later. */
4085 unwind
.fp_reg
= reg
;
4086 unwind
.fp_offset
= unwind
.frame_size
- offset
;
4087 unwind
.sp_restored
= 1;
4090 /* Parse an unwind_pad directive. */
4093 s_arm_unwind_pad (int ignored ATTRIBUTE_UNUSED
)
4097 if (!unwind
.proc_start
)
4098 as_bad (MISSING_FNSTART
);
4100 if (immediate_for_directive (&offset
) == FAIL
)
4105 as_bad (_("stack increment must be multiple of 4"));
4106 ignore_rest_of_line ();
4110 /* Don't generate any opcodes, just record the details for later. */
4111 unwind
.frame_size
+= offset
;
4112 unwind
.pending_offset
+= offset
;
4114 demand_empty_rest_of_line ();
4117 /* Parse an unwind_setfp directive. */
4120 s_arm_unwind_setfp (int ignored ATTRIBUTE_UNUSED
)
4126 if (!unwind
.proc_start
)
4127 as_bad (MISSING_FNSTART
);
4129 fp_reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_RN
);
4130 if (skip_past_comma (&input_line_pointer
) == FAIL
)
4133 sp_reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_RN
);
4135 if (fp_reg
== FAIL
|| sp_reg
== FAIL
)
4137 as_bad (_("expected <reg>, <reg>"));
4138 ignore_rest_of_line ();
4142 /* Optional constant. */
4143 if (skip_past_comma (&input_line_pointer
) != FAIL
)
4145 if (immediate_for_directive (&offset
) == FAIL
)
4151 demand_empty_rest_of_line ();
4153 if (sp_reg
!= REG_SP
&& sp_reg
!= unwind
.fp_reg
)
4155 as_bad (_("register must be either sp or set by a previous"
4156 "unwind_movsp directive"));
4160 /* Don't generate any opcodes, just record the information for later. */
4161 unwind
.fp_reg
= fp_reg
;
4163 if (sp_reg
== REG_SP
)
4164 unwind
.fp_offset
= unwind
.frame_size
- offset
;
4166 unwind
.fp_offset
-= offset
;
4169 /* Parse an unwind_raw directive. */
4172 s_arm_unwind_raw (int ignored ATTRIBUTE_UNUSED
)
4175 /* This is an arbitrary limit. */
4176 unsigned char op
[16];
4179 if (!unwind
.proc_start
)
4180 as_bad (MISSING_FNSTART
);
4183 if (exp
.X_op
== O_constant
4184 && skip_past_comma (&input_line_pointer
) != FAIL
)
4186 unwind
.frame_size
+= exp
.X_add_number
;
4190 exp
.X_op
= O_illegal
;
4192 if (exp
.X_op
!= O_constant
)
4194 as_bad (_("expected <offset>, <opcode>"));
4195 ignore_rest_of_line ();
4201 /* Parse the opcode. */
4206 as_bad (_("unwind opcode too long"));
4207 ignore_rest_of_line ();
4209 if (exp
.X_op
!= O_constant
|| exp
.X_add_number
& ~0xff)
4211 as_bad (_("invalid unwind opcode"));
4212 ignore_rest_of_line ();
4215 op
[count
++] = exp
.X_add_number
;
4217 /* Parse the next byte. */
4218 if (skip_past_comma (&input_line_pointer
) == FAIL
)
4224 /* Add the opcode bytes in reverse order. */
4226 add_unwind_opcode (op
[count
], 1);
4228 demand_empty_rest_of_line ();
4232 /* Parse a .eabi_attribute directive. */
4235 s_arm_eabi_attribute (int ignored ATTRIBUTE_UNUSED
)
4237 int tag
= s_vendor_attribute (OBJ_ATTR_PROC
);
4239 if (tag
< NUM_KNOWN_OBJ_ATTRIBUTES
)
4240 attributes_set_explicitly
[tag
] = 1;
4242 #endif /* OBJ_ELF */
4244 static void s_arm_arch (int);
4245 static void s_arm_object_arch (int);
4246 static void s_arm_cpu (int);
4247 static void s_arm_fpu (int);
4252 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED
)
4259 if (exp
.X_op
== O_symbol
)
4260 exp
.X_op
= O_secrel
;
4262 emit_expr (&exp
, 4);
4264 while (*input_line_pointer
++ == ',');
4266 input_line_pointer
--;
4267 demand_empty_rest_of_line ();
4271 /* This table describes all the machine specific pseudo-ops the assembler
4272 has to support. The fields are:
4273 pseudo-op name without dot
4274 function to call to execute this pseudo-op
4275 Integer arg to pass to the function. */
4277 const pseudo_typeS md_pseudo_table
[] =
4279 /* Never called because '.req' does not start a line. */
4280 { "req", s_req
, 0 },
4281 /* Following two are likewise never called. */
4284 { "unreq", s_unreq
, 0 },
4285 { "bss", s_bss
, 0 },
4286 { "align", s_align
, 0 },
4287 { "arm", s_arm
, 0 },
4288 { "thumb", s_thumb
, 0 },
4289 { "code", s_code
, 0 },
4290 { "force_thumb", s_force_thumb
, 0 },
4291 { "thumb_func", s_thumb_func
, 0 },
4292 { "thumb_set", s_thumb_set
, 0 },
4293 { "even", s_even
, 0 },
4294 { "ltorg", s_ltorg
, 0 },
4295 { "pool", s_ltorg
, 0 },
4296 { "syntax", s_syntax
, 0 },
4297 { "cpu", s_arm_cpu
, 0 },
4298 { "arch", s_arm_arch
, 0 },
4299 { "object_arch", s_arm_object_arch
, 0 },
4300 { "fpu", s_arm_fpu
, 0 },
4302 { "word", s_arm_elf_cons
, 4 },
4303 { "long", s_arm_elf_cons
, 4 },
4304 { "inst.n", s_arm_elf_inst
, 2 },
4305 { "inst.w", s_arm_elf_inst
, 4 },
4306 { "inst", s_arm_elf_inst
, 0 },
4307 { "rel31", s_arm_rel31
, 0 },
4308 { "fnstart", s_arm_unwind_fnstart
, 0 },
4309 { "fnend", s_arm_unwind_fnend
, 0 },
4310 { "cantunwind", s_arm_unwind_cantunwind
, 0 },
4311 { "personality", s_arm_unwind_personality
, 0 },
4312 { "personalityindex", s_arm_unwind_personalityindex
, 0 },
4313 { "handlerdata", s_arm_unwind_handlerdata
, 0 },
4314 { "save", s_arm_unwind_save
, 0 },
4315 { "vsave", s_arm_unwind_save
, 1 },
4316 { "movsp", s_arm_unwind_movsp
, 0 },
4317 { "pad", s_arm_unwind_pad
, 0 },
4318 { "setfp", s_arm_unwind_setfp
, 0 },
4319 { "unwind_raw", s_arm_unwind_raw
, 0 },
4320 { "eabi_attribute", s_arm_eabi_attribute
, 0 },
4324 /* These are used for dwarf. */
4328 /* These are used for dwarf2. */
4329 { "file", (void (*) (int)) dwarf2_directive_file
, 0 },
4330 { "loc", dwarf2_directive_loc
, 0 },
4331 { "loc_mark_labels", dwarf2_directive_loc_mark_labels
, 0 },
4333 { "extend", float_cons
, 'x' },
4334 { "ldouble", float_cons
, 'x' },
4335 { "packed", float_cons
, 'p' },
4337 {"secrel32", pe_directive_secrel
, 0},
4342 /* Parser functions used exclusively in instruction operands. */
4344 /* Generic immediate-value read function for use in insn parsing.
4345 STR points to the beginning of the immediate (the leading #);
4346 VAL receives the value; if the value is outside [MIN, MAX]
4347 issue an error. PREFIX_OPT is true if the immediate prefix is
4351 parse_immediate (char **str
, int *val
, int min
, int max
,
4352 bfd_boolean prefix_opt
)
4355 my_get_expression (&exp
, str
, prefix_opt
? GE_OPT_PREFIX
: GE_IMM_PREFIX
);
4356 if (exp
.X_op
!= O_constant
)
4358 inst
.error
= _("constant expression required");
4362 if (exp
.X_add_number
< min
|| exp
.X_add_number
> max
)
4364 inst
.error
= _("immediate value out of range");
4368 *val
= exp
.X_add_number
;
4372 /* Less-generic immediate-value read function with the possibility of loading a
4373 big (64-bit) immediate, as required by Neon VMOV, VMVN and logic immediate
4374 instructions. Puts the result directly in inst.operands[i]. */
4377 parse_big_immediate (char **str
, int i
)
4382 my_get_expression (&exp
, &ptr
, GE_OPT_PREFIX_BIG
);
4384 if (exp
.X_op
== O_constant
)
4386 inst
.operands
[i
].imm
= exp
.X_add_number
& 0xffffffff;
4387 /* If we're on a 64-bit host, then a 64-bit number can be returned using
4388 O_constant. We have to be careful not to break compilation for
4389 32-bit X_add_number, though. */
4390 if ((exp
.X_add_number
& ~0xffffffffl
) != 0)
4392 /* X >> 32 is illegal if sizeof (exp.X_add_number) == 4. */
4393 inst
.operands
[i
].reg
= ((exp
.X_add_number
>> 16) >> 16) & 0xffffffff;
4394 inst
.operands
[i
].regisimm
= 1;
4397 else if (exp
.X_op
== O_big
4398 && LITTLENUM_NUMBER_OF_BITS
* exp
.X_add_number
> 32
4399 && LITTLENUM_NUMBER_OF_BITS
* exp
.X_add_number
<= 64)
4401 unsigned parts
= 32 / LITTLENUM_NUMBER_OF_BITS
, j
, idx
= 0;
4402 /* Bignums have their least significant bits in
4403 generic_bignum[0]. Make sure we put 32 bits in imm and
4404 32 bits in reg, in a (hopefully) portable way. */
4405 gas_assert (parts
!= 0);
4406 inst
.operands
[i
].imm
= 0;
4407 for (j
= 0; j
< parts
; j
++, idx
++)
4408 inst
.operands
[i
].imm
|= generic_bignum
[idx
]
4409 << (LITTLENUM_NUMBER_OF_BITS
* j
);
4410 inst
.operands
[i
].reg
= 0;
4411 for (j
= 0; j
< parts
; j
++, idx
++)
4412 inst
.operands
[i
].reg
|= generic_bignum
[idx
]
4413 << (LITTLENUM_NUMBER_OF_BITS
* j
);
4414 inst
.operands
[i
].regisimm
= 1;
4424 /* Returns the pseudo-register number of an FPA immediate constant,
4425 or FAIL if there isn't a valid constant here. */
4428 parse_fpa_immediate (char ** str
)
4430 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
4436 /* First try and match exact strings, this is to guarantee
4437 that some formats will work even for cross assembly. */
4439 for (i
= 0; fp_const
[i
]; i
++)
4441 if (strncmp (*str
, fp_const
[i
], strlen (fp_const
[i
])) == 0)
4445 *str
+= strlen (fp_const
[i
]);
4446 if (is_end_of_line
[(unsigned char) **str
])
4452 /* Just because we didn't get a match doesn't mean that the constant
4453 isn't valid, just that it is in a format that we don't
4454 automatically recognize. Try parsing it with the standard
4455 expression routines. */
4457 memset (words
, 0, MAX_LITTLENUMS
* sizeof (LITTLENUM_TYPE
));
4459 /* Look for a raw floating point number. */
4460 if ((save_in
= atof_ieee (*str
, 'x', words
)) != NULL
4461 && is_end_of_line
[(unsigned char) *save_in
])
4463 for (i
= 0; i
< NUM_FLOAT_VALS
; i
++)
4465 for (j
= 0; j
< MAX_LITTLENUMS
; j
++)
4467 if (words
[j
] != fp_values
[i
][j
])
4471 if (j
== MAX_LITTLENUMS
)
4479 /* Try and parse a more complex expression, this will probably fail
4480 unless the code uses a floating point prefix (eg "0f"). */
4481 save_in
= input_line_pointer
;
4482 input_line_pointer
= *str
;
4483 if (expression (&exp
) == absolute_section
4484 && exp
.X_op
== O_big
4485 && exp
.X_add_number
< 0)
4487 /* FIXME: 5 = X_PRECISION, should be #define'd where we can use it.
4489 if (gen_to_words (words
, 5, (long) 15) == 0)
4491 for (i
= 0; i
< NUM_FLOAT_VALS
; i
++)
4493 for (j
= 0; j
< MAX_LITTLENUMS
; j
++)
4495 if (words
[j
] != fp_values
[i
][j
])
4499 if (j
== MAX_LITTLENUMS
)
4501 *str
= input_line_pointer
;
4502 input_line_pointer
= save_in
;
4509 *str
= input_line_pointer
;
4510 input_line_pointer
= save_in
;
4511 inst
.error
= _("invalid FPA immediate expression");
4515 /* Returns 1 if a number has "quarter-precision" float format
4516 0baBbbbbbc defgh000 00000000 00000000. */
4519 is_quarter_float (unsigned imm
)
4521 int bs
= (imm
& 0x20000000) ? 0x3e000000 : 0x40000000;
4522 return (imm
& 0x7ffff) == 0 && ((imm
& 0x7e000000) ^ bs
) == 0;
4525 /* Parse an 8-bit "quarter-precision" floating point number of the form:
4526 0baBbbbbbc defgh000 00000000 00000000.
4527 The zero and minus-zero cases need special handling, since they can't be
4528 encoded in the "quarter-precision" float format, but can nonetheless be
4529 loaded as integer constants. */
4532 parse_qfloat_immediate (char **ccp
, int *immed
)
4536 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
4537 int found_fpchar
= 0;
4539 skip_past_char (&str
, '#');
4541 /* We must not accidentally parse an integer as a floating-point number. Make
4542 sure that the value we parse is not an integer by checking for special
4543 characters '.' or 'e'.
4544 FIXME: This is a horrible hack, but doing better is tricky because type
4545 information isn't in a very usable state at parse time. */
4547 skip_whitespace (fpnum
);
4549 if (strncmp (fpnum
, "0x", 2) == 0)
4553 for (; *fpnum
!= '\0' && *fpnum
!= ' ' && *fpnum
!= '\n'; fpnum
++)
4554 if (*fpnum
== '.' || *fpnum
== 'e' || *fpnum
== 'E')
4564 if ((str
= atof_ieee (str
, 's', words
)) != NULL
)
4566 unsigned fpword
= 0;
4569 /* Our FP word must be 32 bits (single-precision FP). */
4570 for (i
= 0; i
< 32 / LITTLENUM_NUMBER_OF_BITS
; i
++)
4572 fpword
<<= LITTLENUM_NUMBER_OF_BITS
;
4576 if (is_quarter_float (fpword
) || (fpword
& 0x7fffffff) == 0)
4589 /* Shift operands. */
4592 SHIFT_LSL
, SHIFT_LSR
, SHIFT_ASR
, SHIFT_ROR
, SHIFT_RRX
4595 struct asm_shift_name
4598 enum shift_kind kind
;
4601 /* Third argument to parse_shift. */
4602 enum parse_shift_mode
4604 NO_SHIFT_RESTRICT
, /* Any kind of shift is accepted. */
4605 SHIFT_IMMEDIATE
, /* Shift operand must be an immediate. */
4606 SHIFT_LSL_OR_ASR_IMMEDIATE
, /* Shift must be LSL or ASR immediate. */
4607 SHIFT_ASR_IMMEDIATE
, /* Shift must be ASR immediate. */
4608 SHIFT_LSL_IMMEDIATE
, /* Shift must be LSL immediate. */
4611 /* Parse a <shift> specifier on an ARM data processing instruction.
4612 This has three forms:
4614 (LSL|LSR|ASL|ASR|ROR) Rs
4615 (LSL|LSR|ASL|ASR|ROR) #imm
4618 Note that ASL is assimilated to LSL in the instruction encoding, and
4619 RRX to ROR #0 (which cannot be written as such). */
4622 parse_shift (char **str
, int i
, enum parse_shift_mode mode
)
4624 const struct asm_shift_name
*shift_name
;
4625 enum shift_kind shift
;
4630 for (p
= *str
; ISALPHA (*p
); p
++)
4635 inst
.error
= _("shift expression expected");
4639 shift_name
= (const struct asm_shift_name
*) hash_find_n (arm_shift_hsh
, *str
,
4642 if (shift_name
== NULL
)
4644 inst
.error
= _("shift expression expected");
4648 shift
= shift_name
->kind
;
4652 case NO_SHIFT_RESTRICT
:
4653 case SHIFT_IMMEDIATE
: break;
4655 case SHIFT_LSL_OR_ASR_IMMEDIATE
:
4656 if (shift
!= SHIFT_LSL
&& shift
!= SHIFT_ASR
)
4658 inst
.error
= _("'LSL' or 'ASR' required");
4663 case SHIFT_LSL_IMMEDIATE
:
4664 if (shift
!= SHIFT_LSL
)
4666 inst
.error
= _("'LSL' required");
4671 case SHIFT_ASR_IMMEDIATE
:
4672 if (shift
!= SHIFT_ASR
)
4674 inst
.error
= _("'ASR' required");
4682 if (shift
!= SHIFT_RRX
)
4684 /* Whitespace can appear here if the next thing is a bare digit. */
4685 skip_whitespace (p
);
4687 if (mode
== NO_SHIFT_RESTRICT
4688 && (reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) != FAIL
)
4690 inst
.operands
[i
].imm
= reg
;
4691 inst
.operands
[i
].immisreg
= 1;
4693 else if (my_get_expression (&inst
.reloc
.exp
, &p
, GE_IMM_PREFIX
))
4696 inst
.operands
[i
].shift_kind
= shift
;
4697 inst
.operands
[i
].shifted
= 1;
4702 /* Parse a <shifter_operand> for an ARM data processing instruction:
4705 #<immediate>, <rotate>
4709 where <shift> is defined by parse_shift above, and <rotate> is a
4710 multiple of 2 between 0 and 30. Validation of immediate operands
4711 is deferred to md_apply_fix. */
4714 parse_shifter_operand (char **str
, int i
)
4719 if ((value
= arm_reg_parse (str
, REG_TYPE_RN
)) != FAIL
)
4721 inst
.operands
[i
].reg
= value
;
4722 inst
.operands
[i
].isreg
= 1;
4724 /* parse_shift will override this if appropriate */
4725 inst
.reloc
.exp
.X_op
= O_constant
;
4726 inst
.reloc
.exp
.X_add_number
= 0;
4728 if (skip_past_comma (str
) == FAIL
)
4731 /* Shift operation on register. */
4732 return parse_shift (str
, i
, NO_SHIFT_RESTRICT
);
4735 if (my_get_expression (&inst
.reloc
.exp
, str
, GE_IMM_PREFIX
))
4738 if (skip_past_comma (str
) == SUCCESS
)
4740 /* #x, y -- ie explicit rotation by Y. */
4741 if (my_get_expression (&exp
, str
, GE_NO_PREFIX
))
4744 if (exp
.X_op
!= O_constant
|| inst
.reloc
.exp
.X_op
!= O_constant
)
4746 inst
.error
= _("constant expression expected");
4750 value
= exp
.X_add_number
;
4751 if (value
< 0 || value
> 30 || value
% 2 != 0)
4753 inst
.error
= _("invalid rotation");
4756 if (inst
.reloc
.exp
.X_add_number
< 0 || inst
.reloc
.exp
.X_add_number
> 255)
4758 inst
.error
= _("invalid constant");
4762 /* Convert to decoded value. md_apply_fix will put it back. */
4763 inst
.reloc
.exp
.X_add_number
4764 = (((inst
.reloc
.exp
.X_add_number
<< (32 - value
))
4765 | (inst
.reloc
.exp
.X_add_number
>> value
)) & 0xffffffff);
4768 inst
.reloc
.type
= BFD_RELOC_ARM_IMMEDIATE
;
4769 inst
.reloc
.pc_rel
= 0;
4773 /* Group relocation information. Each entry in the table contains the
4774 textual name of the relocation as may appear in assembler source
4775 and must end with a colon.
4776 Along with this textual name are the relocation codes to be used if
4777 the corresponding instruction is an ALU instruction (ADD or SUB only),
4778 an LDR, an LDRS, or an LDC. */
4780 struct group_reloc_table_entry
4791 /* Varieties of non-ALU group relocation. */
4798 static struct group_reloc_table_entry group_reloc_table
[] =
4799 { /* Program counter relative: */
4801 BFD_RELOC_ARM_ALU_PC_G0_NC
, /* ALU */
4806 BFD_RELOC_ARM_ALU_PC_G0
, /* ALU */
4807 BFD_RELOC_ARM_LDR_PC_G0
, /* LDR */
4808 BFD_RELOC_ARM_LDRS_PC_G0
, /* LDRS */
4809 BFD_RELOC_ARM_LDC_PC_G0
}, /* LDC */
4811 BFD_RELOC_ARM_ALU_PC_G1_NC
, /* ALU */
4816 BFD_RELOC_ARM_ALU_PC_G1
, /* ALU */
4817 BFD_RELOC_ARM_LDR_PC_G1
, /* LDR */
4818 BFD_RELOC_ARM_LDRS_PC_G1
, /* LDRS */
4819 BFD_RELOC_ARM_LDC_PC_G1
}, /* LDC */
4821 BFD_RELOC_ARM_ALU_PC_G2
, /* ALU */
4822 BFD_RELOC_ARM_LDR_PC_G2
, /* LDR */
4823 BFD_RELOC_ARM_LDRS_PC_G2
, /* LDRS */
4824 BFD_RELOC_ARM_LDC_PC_G2
}, /* LDC */
4825 /* Section base relative */
4827 BFD_RELOC_ARM_ALU_SB_G0_NC
, /* ALU */
4832 BFD_RELOC_ARM_ALU_SB_G0
, /* ALU */
4833 BFD_RELOC_ARM_LDR_SB_G0
, /* LDR */
4834 BFD_RELOC_ARM_LDRS_SB_G0
, /* LDRS */
4835 BFD_RELOC_ARM_LDC_SB_G0
}, /* LDC */
4837 BFD_RELOC_ARM_ALU_SB_G1_NC
, /* ALU */
4842 BFD_RELOC_ARM_ALU_SB_G1
, /* ALU */
4843 BFD_RELOC_ARM_LDR_SB_G1
, /* LDR */
4844 BFD_RELOC_ARM_LDRS_SB_G1
, /* LDRS */
4845 BFD_RELOC_ARM_LDC_SB_G1
}, /* LDC */
4847 BFD_RELOC_ARM_ALU_SB_G2
, /* ALU */
4848 BFD_RELOC_ARM_LDR_SB_G2
, /* LDR */
4849 BFD_RELOC_ARM_LDRS_SB_G2
, /* LDRS */
4850 BFD_RELOC_ARM_LDC_SB_G2
} }; /* LDC */
4852 /* Given the address of a pointer pointing to the textual name of a group
4853 relocation as may appear in assembler source, attempt to find its details
4854 in group_reloc_table. The pointer will be updated to the character after
4855 the trailing colon. On failure, FAIL will be returned; SUCCESS
4856 otherwise. On success, *entry will be updated to point at the relevant
4857 group_reloc_table entry. */
4860 find_group_reloc_table_entry (char **str
, struct group_reloc_table_entry
**out
)
4863 for (i
= 0; i
< ARRAY_SIZE (group_reloc_table
); i
++)
4865 int length
= strlen (group_reloc_table
[i
].name
);
4867 if (strncasecmp (group_reloc_table
[i
].name
, *str
, length
) == 0
4868 && (*str
)[length
] == ':')
4870 *out
= &group_reloc_table
[i
];
4871 *str
+= (length
+ 1);
4879 /* Parse a <shifter_operand> for an ARM data processing instruction
4880 (as for parse_shifter_operand) where group relocations are allowed:
4883 #<immediate>, <rotate>
4884 #:<group_reloc>:<expression>
4888 where <group_reloc> is one of the strings defined in group_reloc_table.
4889 The hashes are optional.
4891 Everything else is as for parse_shifter_operand. */
4893 static parse_operand_result
4894 parse_shifter_operand_group_reloc (char **str
, int i
)
4896 /* Determine if we have the sequence of characters #: or just :
4897 coming next. If we do, then we check for a group relocation.
4898 If we don't, punt the whole lot to parse_shifter_operand. */
4900 if (((*str
)[0] == '#' && (*str
)[1] == ':')
4901 || (*str
)[0] == ':')
4903 struct group_reloc_table_entry
*entry
;
4905 if ((*str
)[0] == '#')
4910 /* Try to parse a group relocation. Anything else is an error. */
4911 if (find_group_reloc_table_entry (str
, &entry
) == FAIL
)
4913 inst
.error
= _("unknown group relocation");
4914 return PARSE_OPERAND_FAIL_NO_BACKTRACK
;
4917 /* We now have the group relocation table entry corresponding to
4918 the name in the assembler source. Next, we parse the expression. */
4919 if (my_get_expression (&inst
.reloc
.exp
, str
, GE_NO_PREFIX
))
4920 return PARSE_OPERAND_FAIL_NO_BACKTRACK
;
4922 /* Record the relocation type (always the ALU variant here). */
4923 inst
.reloc
.type
= (bfd_reloc_code_real_type
) entry
->alu_code
;
4924 gas_assert (inst
.reloc
.type
!= 0);
4926 return PARSE_OPERAND_SUCCESS
;
4929 return parse_shifter_operand (str
, i
) == SUCCESS
4930 ? PARSE_OPERAND_SUCCESS
: PARSE_OPERAND_FAIL
;
4932 /* Never reached. */
4935 /* Parse all forms of an ARM address expression. Information is written
4936 to inst.operands[i] and/or inst.reloc.
4938 Preindexed addressing (.preind=1):
4940 [Rn, #offset] .reg=Rn .reloc.exp=offset
4941 [Rn, +/-Rm] .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
4942 [Rn, +/-Rm, shift] .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
4943 .shift_kind=shift .reloc.exp=shift_imm
4945 These three may have a trailing ! which causes .writeback to be set also.
4947 Postindexed addressing (.postind=1, .writeback=1):
4949 [Rn], #offset .reg=Rn .reloc.exp=offset
4950 [Rn], +/-Rm .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
4951 [Rn], +/-Rm, shift .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
4952 .shift_kind=shift .reloc.exp=shift_imm
4954 Unindexed addressing (.preind=0, .postind=0):
4956 [Rn], {option} .reg=Rn .imm=option .immisreg=0
4960 [Rn]{!} shorthand for [Rn,#0]{!}
4961 =immediate .isreg=0 .reloc.exp=immediate
4962 label .reg=PC .reloc.pc_rel=1 .reloc.exp=label
4964 It is the caller's responsibility to check for addressing modes not
4965 supported by the instruction, and to set inst.reloc.type. */
4967 static parse_operand_result
4968 parse_address_main (char **str
, int i
, int group_relocations
,
4969 group_reloc_type group_type
)
4974 if (skip_past_char (&p
, '[') == FAIL
)
4976 if (skip_past_char (&p
, '=') == FAIL
)
4978 /* Bare address - translate to PC-relative offset. */
4979 inst
.reloc
.pc_rel
= 1;
4980 inst
.operands
[i
].reg
= REG_PC
;
4981 inst
.operands
[i
].isreg
= 1;
4982 inst
.operands
[i
].preind
= 1;
4984 /* Otherwise a load-constant pseudo op, no special treatment needed here. */
4986 if (my_get_expression (&inst
.reloc
.exp
, &p
, GE_NO_PREFIX
))
4987 return PARSE_OPERAND_FAIL
;
4990 return PARSE_OPERAND_SUCCESS
;
4993 if ((reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) == FAIL
)
4995 inst
.error
= _(reg_expected_msgs
[REG_TYPE_RN
]);
4996 return PARSE_OPERAND_FAIL
;
4998 inst
.operands
[i
].reg
= reg
;
4999 inst
.operands
[i
].isreg
= 1;
5001 if (skip_past_comma (&p
) == SUCCESS
)
5003 inst
.operands
[i
].preind
= 1;
5006 else if (*p
== '-') p
++, inst
.operands
[i
].negative
= 1;
5008 if ((reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) != FAIL
)
5010 inst
.operands
[i
].imm
= reg
;
5011 inst
.operands
[i
].immisreg
= 1;
5013 if (skip_past_comma (&p
) == SUCCESS
)
5014 if (parse_shift (&p
, i
, SHIFT_IMMEDIATE
) == FAIL
)
5015 return PARSE_OPERAND_FAIL
;
5017 else if (skip_past_char (&p
, ':') == SUCCESS
)
5019 /* FIXME: '@' should be used here, but it's filtered out by generic
5020 code before we get to see it here. This may be subject to
5023 my_get_expression (&exp
, &p
, GE_NO_PREFIX
);
5024 if (exp
.X_op
!= O_constant
)
5026 inst
.error
= _("alignment must be constant");
5027 return PARSE_OPERAND_FAIL
;
5029 inst
.operands
[i
].imm
= exp
.X_add_number
<< 8;
5030 inst
.operands
[i
].immisalign
= 1;
5031 /* Alignments are not pre-indexes. */
5032 inst
.operands
[i
].preind
= 0;
5036 if (inst
.operands
[i
].negative
)
5038 inst
.operands
[i
].negative
= 0;
5042 if (group_relocations
5043 && ((*p
== '#' && *(p
+ 1) == ':') || *p
== ':'))
5045 struct group_reloc_table_entry
*entry
;
5047 /* Skip over the #: or : sequence. */
5053 /* Try to parse a group relocation. Anything else is an
5055 if (find_group_reloc_table_entry (&p
, &entry
) == FAIL
)
5057 inst
.error
= _("unknown group relocation");
5058 return PARSE_OPERAND_FAIL_NO_BACKTRACK
;
5061 /* We now have the group relocation table entry corresponding to
5062 the name in the assembler source. Next, we parse the
5064 if (my_get_expression (&inst
.reloc
.exp
, &p
, GE_NO_PREFIX
))
5065 return PARSE_OPERAND_FAIL_NO_BACKTRACK
;
5067 /* Record the relocation type. */
5071 inst
.reloc
.type
= (bfd_reloc_code_real_type
) entry
->ldr_code
;
5075 inst
.reloc
.type
= (bfd_reloc_code_real_type
) entry
->ldrs_code
;
5079 inst
.reloc
.type
= (bfd_reloc_code_real_type
) entry
->ldc_code
;
5086 if (inst
.reloc
.type
== 0)
5088 inst
.error
= _("this group relocation is not allowed on this instruction");
5089 return PARSE_OPERAND_FAIL_NO_BACKTRACK
;
5093 if (my_get_expression (&inst
.reloc
.exp
, &p
, GE_IMM_PREFIX
))
5094 return PARSE_OPERAND_FAIL
;
5098 if (skip_past_char (&p
, ']') == FAIL
)
5100 inst
.error
= _("']' expected");
5101 return PARSE_OPERAND_FAIL
;
5104 if (skip_past_char (&p
, '!') == SUCCESS
)
5105 inst
.operands
[i
].writeback
= 1;
5107 else if (skip_past_comma (&p
) == SUCCESS
)
5109 if (skip_past_char (&p
, '{') == SUCCESS
)
5111 /* [Rn], {expr} - unindexed, with option */
5112 if (parse_immediate (&p
, &inst
.operands
[i
].imm
,
5113 0, 255, TRUE
) == FAIL
)
5114 return PARSE_OPERAND_FAIL
;
5116 if (skip_past_char (&p
, '}') == FAIL
)
5118 inst
.error
= _("'}' expected at end of 'option' field");
5119 return PARSE_OPERAND_FAIL
;
5121 if (inst
.operands
[i
].preind
)
5123 inst
.error
= _("cannot combine index with option");
5124 return PARSE_OPERAND_FAIL
;
5127 return PARSE_OPERAND_SUCCESS
;
5131 inst
.operands
[i
].postind
= 1;
5132 inst
.operands
[i
].writeback
= 1;
5134 if (inst
.operands
[i
].preind
)
5136 inst
.error
= _("cannot combine pre- and post-indexing");
5137 return PARSE_OPERAND_FAIL
;
5141 else if (*p
== '-') p
++, inst
.operands
[i
].negative
= 1;
5143 if ((reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) != FAIL
)
5145 /* We might be using the immediate for alignment already. If we
5146 are, OR the register number into the low-order bits. */
5147 if (inst
.operands
[i
].immisalign
)
5148 inst
.operands
[i
].imm
|= reg
;
5150 inst
.operands
[i
].imm
= reg
;
5151 inst
.operands
[i
].immisreg
= 1;
5153 if (skip_past_comma (&p
) == SUCCESS
)
5154 if (parse_shift (&p
, i
, SHIFT_IMMEDIATE
) == FAIL
)
5155 return PARSE_OPERAND_FAIL
;
5159 if (inst
.operands
[i
].negative
)
5161 inst
.operands
[i
].negative
= 0;
5164 if (my_get_expression (&inst
.reloc
.exp
, &p
, GE_IMM_PREFIX
))
5165 return PARSE_OPERAND_FAIL
;
5170 /* If at this point neither .preind nor .postind is set, we have a
5171 bare [Rn]{!}, which is shorthand for [Rn,#0]{!}. */
5172 if (inst
.operands
[i
].preind
== 0 && inst
.operands
[i
].postind
== 0)
5174 inst
.operands
[i
].preind
= 1;
5175 inst
.reloc
.exp
.X_op
= O_constant
;
5176 inst
.reloc
.exp
.X_add_number
= 0;
5179 return PARSE_OPERAND_SUCCESS
;
5183 parse_address (char **str
, int i
)
5185 return parse_address_main (str
, i
, 0, GROUP_LDR
) == PARSE_OPERAND_SUCCESS
5189 static parse_operand_result
5190 parse_address_group_reloc (char **str
, int i
, group_reloc_type type
)
5192 return parse_address_main (str
, i
, 1, type
);
5195 /* Parse an operand for a MOVW or MOVT instruction. */
5197 parse_half (char **str
)
5202 skip_past_char (&p
, '#');
5203 if (strncasecmp (p
, ":lower16:", 9) == 0)
5204 inst
.reloc
.type
= BFD_RELOC_ARM_MOVW
;
5205 else if (strncasecmp (p
, ":upper16:", 9) == 0)
5206 inst
.reloc
.type
= BFD_RELOC_ARM_MOVT
;
5208 if (inst
.reloc
.type
!= BFD_RELOC_UNUSED
)
5211 skip_whitespace (p
);
5214 if (my_get_expression (&inst
.reloc
.exp
, &p
, GE_NO_PREFIX
))
5217 if (inst
.reloc
.type
== BFD_RELOC_UNUSED
)
5219 if (inst
.reloc
.exp
.X_op
!= O_constant
)
5221 inst
.error
= _("constant expression expected");
5224 if (inst
.reloc
.exp
.X_add_number
< 0
5225 || inst
.reloc
.exp
.X_add_number
> 0xffff)
5227 inst
.error
= _("immediate value out of range");
5235 /* Miscellaneous. */
5237 /* Parse a PSR flag operand. The value returned is FAIL on syntax error,
5238 or a bitmask suitable to be or-ed into the ARM msr instruction. */
5240 parse_psr (char **str
)
5243 unsigned long psr_field
;
5244 const struct asm_psr
*psr
;
5247 /* CPSR's and SPSR's can now be lowercase. This is just a convenience
5248 feature for ease of use and backwards compatibility. */
5250 if (strncasecmp (p
, "SPSR", 4) == 0)
5251 psr_field
= SPSR_BIT
;
5252 else if (strncasecmp (p
, "CPSR", 4) == 0)
5259 while (ISALNUM (*p
) || *p
== '_');
5261 psr
= (const struct asm_psr
*) hash_find_n (arm_v7m_psr_hsh
, start
,
5273 /* A suffix follows. */
5279 while (ISALNUM (*p
) || *p
== '_');
5281 psr
= (const struct asm_psr
*) hash_find_n (arm_psr_hsh
, start
,
5286 psr_field
|= psr
->field
;
5291 goto error
; /* Garbage after "[CS]PSR". */
5293 psr_field
|= (PSR_c
| PSR_f
);
5299 inst
.error
= _("flag for {c}psr instruction expected");
5303 /* Parse the flags argument to CPSI[ED]. Returns FAIL on error, or a
5304 value suitable for splatting into the AIF field of the instruction. */
5307 parse_cps_flags (char **str
)
5316 case '\0': case ',':
5319 case 'a': case 'A': saw_a_flag
= 1; val
|= 0x4; break;
5320 case 'i': case 'I': saw_a_flag
= 1; val
|= 0x2; break;
5321 case 'f': case 'F': saw_a_flag
= 1; val
|= 0x1; break;
5324 inst
.error
= _("unrecognized CPS flag");
5329 if (saw_a_flag
== 0)
5331 inst
.error
= _("missing CPS flags");
5339 /* Parse an endian specifier ("BE" or "LE", case insensitive);
5340 returns 0 for big-endian, 1 for little-endian, FAIL for an error. */
5343 parse_endian_specifier (char **str
)
5348 if (strncasecmp (s
, "BE", 2))
5350 else if (strncasecmp (s
, "LE", 2))
5354 inst
.error
= _("valid endian specifiers are be or le");
5358 if (ISALNUM (s
[2]) || s
[2] == '_')
5360 inst
.error
= _("valid endian specifiers are be or le");
5365 return little_endian
;
5368 /* Parse a rotation specifier: ROR #0, #8, #16, #24. *val receives a
5369 value suitable for poking into the rotate field of an sxt or sxta
5370 instruction, or FAIL on error. */
5373 parse_ror (char **str
)
5378 if (strncasecmp (s
, "ROR", 3) == 0)
5382 inst
.error
= _("missing rotation field after comma");
5386 if (parse_immediate (&s
, &rot
, 0, 24, FALSE
) == FAIL
)
5391 case 0: *str
= s
; return 0x0;
5392 case 8: *str
= s
; return 0x1;
5393 case 16: *str
= s
; return 0x2;
5394 case 24: *str
= s
; return 0x3;
5397 inst
.error
= _("rotation can only be 0, 8, 16, or 24");
5402 /* Parse a conditional code (from conds[] below). The value returned is in the
5403 range 0 .. 14, or FAIL. */
5405 parse_cond (char **str
)
5408 const struct asm_cond
*c
;
5410 /* Condition codes are always 2 characters, so matching up to
5411 3 characters is sufficient. */
5416 while (ISALPHA (*q
) && n
< 3)
5418 cond
[n
] = TOLOWER (*q
);
5423 c
= (const struct asm_cond
*) hash_find_n (arm_cond_hsh
, cond
, n
);
5426 inst
.error
= _("condition required");
5434 /* Parse an option for a barrier instruction. Returns the encoding for the
5437 parse_barrier (char **str
)
5440 const struct asm_barrier_opt
*o
;
5443 while (ISALPHA (*q
))
5446 o
= (const struct asm_barrier_opt
*) hash_find_n (arm_barrier_opt_hsh
, p
,
5455 /* Parse the operands of a table branch instruction. Similar to a memory
5458 parse_tb (char **str
)
5463 if (skip_past_char (&p
, '[') == FAIL
)
5465 inst
.error
= _("'[' expected");
5469 if ((reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) == FAIL
)
5471 inst
.error
= _(reg_expected_msgs
[REG_TYPE_RN
]);
5474 inst
.operands
[0].reg
= reg
;
5476 if (skip_past_comma (&p
) == FAIL
)
5478 inst
.error
= _("',' expected");
5482 if ((reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) == FAIL
)
5484 inst
.error
= _(reg_expected_msgs
[REG_TYPE_RN
]);
5487 inst
.operands
[0].imm
= reg
;
5489 if (skip_past_comma (&p
) == SUCCESS
)
5491 if (parse_shift (&p
, 0, SHIFT_LSL_IMMEDIATE
) == FAIL
)
5493 if (inst
.reloc
.exp
.X_add_number
!= 1)
5495 inst
.error
= _("invalid shift");
5498 inst
.operands
[0].shifted
= 1;
5501 if (skip_past_char (&p
, ']') == FAIL
)
5503 inst
.error
= _("']' expected");
5510 /* Parse the operands of a Neon VMOV instruction. See do_neon_mov for more
5511 information on the types the operands can take and how they are encoded.
5512 Up to four operands may be read; this function handles setting the
5513 ".present" field for each read operand itself.
5514 Updates STR and WHICH_OPERAND if parsing is successful and returns SUCCESS,
5515 else returns FAIL. */
5518 parse_neon_mov (char **str
, int *which_operand
)
5520 int i
= *which_operand
, val
;
5521 enum arm_reg_type rtype
;
5523 struct neon_type_el optype
;
5525 if ((val
= parse_scalar (&ptr
, 8, &optype
)) != FAIL
)
5527 /* Case 4: VMOV<c><q>.<size> <Dn[x]>, <Rd>. */
5528 inst
.operands
[i
].reg
= val
;
5529 inst
.operands
[i
].isscalar
= 1;
5530 inst
.operands
[i
].vectype
= optype
;
5531 inst
.operands
[i
++].present
= 1;
5533 if (skip_past_comma (&ptr
) == FAIL
)
5536 if ((val
= arm_reg_parse (&ptr
, REG_TYPE_RN
)) == FAIL
)
5539 inst
.operands
[i
].reg
= val
;
5540 inst
.operands
[i
].isreg
= 1;
5541 inst
.operands
[i
].present
= 1;
5543 else if ((val
= arm_typed_reg_parse (&ptr
, REG_TYPE_NSDQ
, &rtype
, &optype
))
5546 /* Cases 0, 1, 2, 3, 5 (D only). */
5547 if (skip_past_comma (&ptr
) == FAIL
)
5550 inst
.operands
[i
].reg
= val
;
5551 inst
.operands
[i
].isreg
= 1;
5552 inst
.operands
[i
].isquad
= (rtype
== REG_TYPE_NQ
);
5553 inst
.operands
[i
].issingle
= (rtype
== REG_TYPE_VFS
);
5554 inst
.operands
[i
].isvec
= 1;
5555 inst
.operands
[i
].vectype
= optype
;
5556 inst
.operands
[i
++].present
= 1;
5558 if ((val
= arm_reg_parse (&ptr
, REG_TYPE_RN
)) != FAIL
)
5560 /* Case 5: VMOV<c><q> <Dm>, <Rd>, <Rn>.
5561 Case 13: VMOV <Sd>, <Rm> */
5562 inst
.operands
[i
].reg
= val
;
5563 inst
.operands
[i
].isreg
= 1;
5564 inst
.operands
[i
].present
= 1;
5566 if (rtype
== REG_TYPE_NQ
)
5568 first_error (_("can't use Neon quad register here"));
5571 else if (rtype
!= REG_TYPE_VFS
)
5574 if (skip_past_comma (&ptr
) == FAIL
)
5576 if ((val
= arm_reg_parse (&ptr
, REG_TYPE_RN
)) == FAIL
)
5578 inst
.operands
[i
].reg
= val
;
5579 inst
.operands
[i
].isreg
= 1;
5580 inst
.operands
[i
].present
= 1;
5583 else if ((val
= arm_typed_reg_parse (&ptr
, REG_TYPE_NSDQ
, &rtype
,
5586 /* Case 0: VMOV<c><q> <Qd>, <Qm>
5587 Case 1: VMOV<c><q> <Dd>, <Dm>
5588 Case 8: VMOV.F32 <Sd>, <Sm>
5589 Case 15: VMOV <Sd>, <Se>, <Rn>, <Rm> */
5591 inst
.operands
[i
].reg
= val
;
5592 inst
.operands
[i
].isreg
= 1;
5593 inst
.operands
[i
].isquad
= (rtype
== REG_TYPE_NQ
);
5594 inst
.operands
[i
].issingle
= (rtype
== REG_TYPE_VFS
);
5595 inst
.operands
[i
].isvec
= 1;
5596 inst
.operands
[i
].vectype
= optype
;
5597 inst
.operands
[i
].present
= 1;
5599 if (skip_past_comma (&ptr
) == SUCCESS
)
5604 if ((val
= arm_reg_parse (&ptr
, REG_TYPE_RN
)) == FAIL
)
5607 inst
.operands
[i
].reg
= val
;
5608 inst
.operands
[i
].isreg
= 1;
5609 inst
.operands
[i
++].present
= 1;
5611 if (skip_past_comma (&ptr
) == FAIL
)
5614 if ((val
= arm_reg_parse (&ptr
, REG_TYPE_RN
)) == FAIL
)
5617 inst
.operands
[i
].reg
= val
;
5618 inst
.operands
[i
].isreg
= 1;
5619 inst
.operands
[i
++].present
= 1;
5622 else if (parse_qfloat_immediate (&ptr
, &inst
.operands
[i
].imm
) == SUCCESS
)
5623 /* Case 2: VMOV<c><q>.<dt> <Qd>, #<float-imm>
5624 Case 3: VMOV<c><q>.<dt> <Dd>, #<float-imm>
5625 Case 10: VMOV.F32 <Sd>, #<imm>
5626 Case 11: VMOV.F64 <Dd>, #<imm> */
5627 inst
.operands
[i
].immisfloat
= 1;
5628 else if (parse_big_immediate (&ptr
, i
) == SUCCESS
)
5629 /* Case 2: VMOV<c><q>.<dt> <Qd>, #<imm>
5630 Case 3: VMOV<c><q>.<dt> <Dd>, #<imm> */
5634 first_error (_("expected <Rm> or <Dm> or <Qm> operand"));
5638 else if ((val
= arm_reg_parse (&ptr
, REG_TYPE_RN
)) != FAIL
)
5641 inst
.operands
[i
].reg
= val
;
5642 inst
.operands
[i
].isreg
= 1;
5643 inst
.operands
[i
++].present
= 1;
5645 if (skip_past_comma (&ptr
) == FAIL
)
5648 if ((val
= parse_scalar (&ptr
, 8, &optype
)) != FAIL
)
5650 /* Case 6: VMOV<c><q>.<dt> <Rd>, <Dn[x]> */
5651 inst
.operands
[i
].reg
= val
;
5652 inst
.operands
[i
].isscalar
= 1;
5653 inst
.operands
[i
].present
= 1;
5654 inst
.operands
[i
].vectype
= optype
;
5656 else if ((val
= arm_reg_parse (&ptr
, REG_TYPE_RN
)) != FAIL
)
5658 /* Case 7: VMOV<c><q> <Rd>, <Rn>, <Dm> */
5659 inst
.operands
[i
].reg
= val
;
5660 inst
.operands
[i
].isreg
= 1;
5661 inst
.operands
[i
++].present
= 1;
5663 if (skip_past_comma (&ptr
) == FAIL
)
5666 if ((val
= arm_typed_reg_parse (&ptr
, REG_TYPE_VFSD
, &rtype
, &optype
))
5669 first_error (_(reg_expected_msgs
[REG_TYPE_VFSD
]));
5673 inst
.operands
[i
].reg
= val
;
5674 inst
.operands
[i
].isreg
= 1;
5675 inst
.operands
[i
].isvec
= 1;
5676 inst
.operands
[i
].issingle
= (rtype
== REG_TYPE_VFS
);
5677 inst
.operands
[i
].vectype
= optype
;
5678 inst
.operands
[i
].present
= 1;
5680 if (rtype
== REG_TYPE_VFS
)
5684 if (skip_past_comma (&ptr
) == FAIL
)
5686 if ((val
= arm_typed_reg_parse (&ptr
, REG_TYPE_VFS
, NULL
,
5689 first_error (_(reg_expected_msgs
[REG_TYPE_VFS
]));
5692 inst
.operands
[i
].reg
= val
;
5693 inst
.operands
[i
].isreg
= 1;
5694 inst
.operands
[i
].isvec
= 1;
5695 inst
.operands
[i
].issingle
= 1;
5696 inst
.operands
[i
].vectype
= optype
;
5697 inst
.operands
[i
].present
= 1;
5700 else if ((val
= arm_typed_reg_parse (&ptr
, REG_TYPE_VFS
, NULL
, &optype
))
5704 inst
.operands
[i
].reg
= val
;
5705 inst
.operands
[i
].isreg
= 1;
5706 inst
.operands
[i
].isvec
= 1;
5707 inst
.operands
[i
].issingle
= 1;
5708 inst
.operands
[i
].vectype
= optype
;
5709 inst
.operands
[i
++].present
= 1;
5714 first_error (_("parse error"));
5718 /* Successfully parsed the operands. Update args. */
5724 first_error (_("expected comma"));
5728 first_error (_(reg_expected_msgs
[REG_TYPE_RN
]));
5732 /* Matcher codes for parse_operands. */
5733 enum operand_parse_code
5735 OP_stop
, /* end of line */
5737 OP_RR
, /* ARM register */
5738 OP_RRnpc
, /* ARM register, not r15 */
5739 OP_RRnpcb
, /* ARM register, not r15, in square brackets */
5740 OP_RRw
, /* ARM register, not r15, optional trailing ! */
5741 OP_RCP
, /* Coprocessor number */
5742 OP_RCN
, /* Coprocessor register */
5743 OP_RF
, /* FPA register */
5744 OP_RVS
, /* VFP single precision register */
5745 OP_RVD
, /* VFP double precision register (0..15) */
5746 OP_RND
, /* Neon double precision register (0..31) */
5747 OP_RNQ
, /* Neon quad precision register */
5748 OP_RVSD
, /* VFP single or double precision register */
5749 OP_RNDQ
, /* Neon double or quad precision register */
5750 OP_RNSDQ
, /* Neon single, double or quad precision register */
5751 OP_RNSC
, /* Neon scalar D[X] */
5752 OP_RVC
, /* VFP control register */
5753 OP_RMF
, /* Maverick F register */
5754 OP_RMD
, /* Maverick D register */
5755 OP_RMFX
, /* Maverick FX register */
5756 OP_RMDX
, /* Maverick DX register */
5757 OP_RMAX
, /* Maverick AX register */
5758 OP_RMDS
, /* Maverick DSPSC register */
5759 OP_RIWR
, /* iWMMXt wR register */
5760 OP_RIWC
, /* iWMMXt wC register */
5761 OP_RIWG
, /* iWMMXt wCG register */
5762 OP_RXA
, /* XScale accumulator register */
5764 OP_REGLST
, /* ARM register list */
5765 OP_VRSLST
, /* VFP single-precision register list */
5766 OP_VRDLST
, /* VFP double-precision register list */
5767 OP_VRSDLST
, /* VFP single or double-precision register list (& quad) */
5768 OP_NRDLST
, /* Neon double-precision register list (d0-d31, qN aliases) */
5769 OP_NSTRLST
, /* Neon element/structure list */
5771 OP_RNDQ_I0
, /* Neon D or Q reg, or immediate zero. */
5772 OP_RVSD_I0
, /* VFP S or D reg, or immediate zero. */
5773 OP_RR_RNSC
, /* ARM reg or Neon scalar. */
5774 OP_RNSDQ_RNSC
, /* Vector S, D or Q reg, or Neon scalar. */
5775 OP_RNDQ_RNSC
, /* Neon D or Q reg, or Neon scalar. */
5776 OP_RND_RNSC
, /* Neon D reg, or Neon scalar. */
5777 OP_VMOV
, /* Neon VMOV operands. */
5778 OP_RNDQ_Ibig
, /* Neon D or Q reg, or big immediate for logic and VMVN. */
5779 OP_RNDQ_I63b
, /* Neon D or Q reg, or immediate for shift. */
5780 OP_RIWR_I32z
, /* iWMMXt wR register, or immediate 0 .. 32 for iWMMXt2. */
5782 OP_I0
, /* immediate zero */
5783 OP_I7
, /* immediate value 0 .. 7 */
5784 OP_I15
, /* 0 .. 15 */
5785 OP_I16
, /* 1 .. 16 */
5786 OP_I16z
, /* 0 .. 16 */
5787 OP_I31
, /* 0 .. 31 */
5788 OP_I31w
, /* 0 .. 31, optional trailing ! */
5789 OP_I32
, /* 1 .. 32 */
5790 OP_I32z
, /* 0 .. 32 */
5791 OP_I63
, /* 0 .. 63 */
5792 OP_I63s
, /* -64 .. 63 */
5793 OP_I64
, /* 1 .. 64 */
5794 OP_I64z
, /* 0 .. 64 */
5795 OP_I255
, /* 0 .. 255 */
5797 OP_I4b
, /* immediate, prefix optional, 1 .. 4 */
5798 OP_I7b
, /* 0 .. 7 */
5799 OP_I15b
, /* 0 .. 15 */
5800 OP_I31b
, /* 0 .. 31 */
5802 OP_SH
, /* shifter operand */
5803 OP_SHG
, /* shifter operand with possible group relocation */
5804 OP_ADDR
, /* Memory address expression (any mode) */
5805 OP_ADDRGLDR
, /* Mem addr expr (any mode) with possible LDR group reloc */
5806 OP_ADDRGLDRS
, /* Mem addr expr (any mode) with possible LDRS group reloc */
5807 OP_ADDRGLDC
, /* Mem addr expr (any mode) with possible LDC group reloc */
5808 OP_EXP
, /* arbitrary expression */
5809 OP_EXPi
, /* same, with optional immediate prefix */
5810 OP_EXPr
, /* same, with optional relocation suffix */
5811 OP_HALF
, /* 0 .. 65535 or low/high reloc. */
5813 OP_CPSF
, /* CPS flags */
5814 OP_ENDI
, /* Endianness specifier */
5815 OP_PSR
, /* CPSR/SPSR mask for msr */
5816 OP_COND
, /* conditional code */
5817 OP_TB
, /* Table branch. */
5819 OP_RVC_PSR
, /* CPSR/SPSR mask for msr, or VFP control register. */
5820 OP_APSR_RR
, /* ARM register or "APSR_nzcv". */
5822 OP_RRnpc_I0
, /* ARM register or literal 0 */
5823 OP_RR_EXr
, /* ARM register or expression with opt. reloc suff. */
5824 OP_RR_EXi
, /* ARM register or expression with imm prefix */
5825 OP_RF_IF
, /* FPA register or immediate */
5826 OP_RIWR_RIWC
, /* iWMMXt R or C reg */
5827 OP_RIWC_RIWG
, /* iWMMXt wC or wCG reg */
5829 /* Optional operands. */
5830 OP_oI7b
, /* immediate, prefix optional, 0 .. 7 */
5831 OP_oI31b
, /* 0 .. 31 */
5832 OP_oI32b
, /* 1 .. 32 */
5833 OP_oIffffb
, /* 0 .. 65535 */
5834 OP_oI255c
, /* curly-brace enclosed, 0 .. 255 */
5836 OP_oRR
, /* ARM register */
5837 OP_oRRnpc
, /* ARM register, not the PC */
5838 OP_oRRw
, /* ARM register, not r15, optional trailing ! */
5839 OP_oRND
, /* Optional Neon double precision register */
5840 OP_oRNQ
, /* Optional Neon quad precision register */
5841 OP_oRNDQ
, /* Optional Neon double or quad precision register */
5842 OP_oRNSDQ
, /* Optional single, double or quad precision vector register */
5843 OP_oSHll
, /* LSL immediate */
5844 OP_oSHar
, /* ASR immediate */
5845 OP_oSHllar
, /* LSL or ASR immediate */
5846 OP_oROR
, /* ROR 0/8/16/24 */
5847 OP_oBARRIER
, /* Option argument for a barrier instruction. */
5849 OP_FIRST_OPTIONAL
= OP_oI7b
5852 /* Generic instruction operand parser. This does no encoding and no
5853 semantic validation; it merely squirrels values away in the inst
5854 structure. Returns SUCCESS or FAIL depending on whether the
5855 specified grammar matched. */
5857 parse_operands (char *str
, const unsigned char *pattern
)
5859 unsigned const char *upat
= pattern
;
5860 char *backtrack_pos
= 0;
5861 const char *backtrack_error
= 0;
5862 int i
, val
, backtrack_index
= 0;
5863 enum arm_reg_type rtype
;
5864 parse_operand_result result
;
5866 #define po_char_or_fail(chr) \
5869 if (skip_past_char (&str, chr) == FAIL) \
5874 #define po_reg_or_fail(regtype) \
5877 val = arm_typed_reg_parse (& str, regtype, & rtype, \
5878 & inst.operands[i].vectype); \
5881 first_error (_(reg_expected_msgs[regtype])); \
5884 inst.operands[i].reg = val; \
5885 inst.operands[i].isreg = 1; \
5886 inst.operands[i].isquad = (rtype == REG_TYPE_NQ); \
5887 inst.operands[i].issingle = (rtype == REG_TYPE_VFS); \
5888 inst.operands[i].isvec = (rtype == REG_TYPE_VFS \
5889 || rtype == REG_TYPE_VFD \
5890 || rtype == REG_TYPE_NQ); \
5894 #define po_reg_or_goto(regtype, label) \
5897 val = arm_typed_reg_parse (& str, regtype, & rtype, \
5898 & inst.operands[i].vectype); \
5902 inst.operands[i].reg = val; \
5903 inst.operands[i].isreg = 1; \
5904 inst.operands[i].isquad = (rtype == REG_TYPE_NQ); \
5905 inst.operands[i].issingle = (rtype == REG_TYPE_VFS); \
5906 inst.operands[i].isvec = (rtype == REG_TYPE_VFS \
5907 || rtype == REG_TYPE_VFD \
5908 || rtype == REG_TYPE_NQ); \
5912 #define po_imm_or_fail(min, max, popt) \
5915 if (parse_immediate (&str, &val, min, max, popt) == FAIL) \
5917 inst.operands[i].imm = val; \
5921 #define po_scalar_or_goto(elsz, label) \
5924 val = parse_scalar (& str, elsz, & inst.operands[i].vectype); \
5927 inst.operands[i].reg = val; \
5928 inst.operands[i].isscalar = 1; \
5932 #define po_misc_or_fail(expr) \
5940 #define po_misc_or_fail_no_backtrack(expr) \
5944 if (result == PARSE_OPERAND_FAIL_NO_BACKTRACK) \
5945 backtrack_pos = 0; \
5946 if (result != PARSE_OPERAND_SUCCESS) \
5951 skip_whitespace (str
);
5953 for (i
= 0; upat
[i
] != OP_stop
; i
++)
5955 if (upat
[i
] >= OP_FIRST_OPTIONAL
)
5957 /* Remember where we are in case we need to backtrack. */
5958 gas_assert (!backtrack_pos
);
5959 backtrack_pos
= str
;
5960 backtrack_error
= inst
.error
;
5961 backtrack_index
= i
;
5964 if (i
> 0 && (i
> 1 || inst
.operands
[0].present
))
5965 po_char_or_fail (',');
5973 case OP_RR
: po_reg_or_fail (REG_TYPE_RN
); break;
5974 case OP_RCP
: po_reg_or_fail (REG_TYPE_CP
); break;
5975 case OP_RCN
: po_reg_or_fail (REG_TYPE_CN
); break;
5976 case OP_RF
: po_reg_or_fail (REG_TYPE_FN
); break;
5977 case OP_RVS
: po_reg_or_fail (REG_TYPE_VFS
); break;
5978 case OP_RVD
: po_reg_or_fail (REG_TYPE_VFD
); break;
5980 case OP_RND
: po_reg_or_fail (REG_TYPE_VFD
); break;
5982 po_reg_or_goto (REG_TYPE_VFC
, coproc_reg
);
5984 /* Also accept generic coprocessor regs for unknown registers. */
5986 po_reg_or_fail (REG_TYPE_CN
);
5988 case OP_RMF
: po_reg_or_fail (REG_TYPE_MVF
); break;
5989 case OP_RMD
: po_reg_or_fail (REG_TYPE_MVD
); break;
5990 case OP_RMFX
: po_reg_or_fail (REG_TYPE_MVFX
); break;
5991 case OP_RMDX
: po_reg_or_fail (REG_TYPE_MVDX
); break;
5992 case OP_RMAX
: po_reg_or_fail (REG_TYPE_MVAX
); break;
5993 case OP_RMDS
: po_reg_or_fail (REG_TYPE_DSPSC
); break;
5994 case OP_RIWR
: po_reg_or_fail (REG_TYPE_MMXWR
); break;
5995 case OP_RIWC
: po_reg_or_fail (REG_TYPE_MMXWC
); break;
5996 case OP_RIWG
: po_reg_or_fail (REG_TYPE_MMXWCG
); break;
5997 case OP_RXA
: po_reg_or_fail (REG_TYPE_XSCALE
); break;
5999 case OP_RNQ
: po_reg_or_fail (REG_TYPE_NQ
); break;
6001 case OP_RNDQ
: po_reg_or_fail (REG_TYPE_NDQ
); break;
6002 case OP_RVSD
: po_reg_or_fail (REG_TYPE_VFSD
); break;
6004 case OP_RNSDQ
: po_reg_or_fail (REG_TYPE_NSDQ
); break;
6006 /* Neon scalar. Using an element size of 8 means that some invalid
6007 scalars are accepted here, so deal with those in later code. */
6008 case OP_RNSC
: po_scalar_or_goto (8, failure
); break;
6012 po_reg_or_goto (REG_TYPE_NDQ
, try_imm0
);
6015 po_imm_or_fail (0, 0, TRUE
);
6020 po_reg_or_goto (REG_TYPE_VFSD
, try_imm0
);
6025 po_scalar_or_goto (8, try_rr
);
6028 po_reg_or_fail (REG_TYPE_RN
);
6034 po_scalar_or_goto (8, try_nsdq
);
6037 po_reg_or_fail (REG_TYPE_NSDQ
);
6043 po_scalar_or_goto (8, try_ndq
);
6046 po_reg_or_fail (REG_TYPE_NDQ
);
6052 po_scalar_or_goto (8, try_vfd
);
6055 po_reg_or_fail (REG_TYPE_VFD
);
6060 /* WARNING: parse_neon_mov can move the operand counter, i. If we're
6061 not careful then bad things might happen. */
6062 po_misc_or_fail (parse_neon_mov (&str
, &i
) == FAIL
);
6067 po_reg_or_goto (REG_TYPE_NDQ
, try_immbig
);
6070 /* There's a possibility of getting a 64-bit immediate here, so
6071 we need special handling. */
6072 if (parse_big_immediate (&str
, i
) == FAIL
)
6074 inst
.error
= _("immediate value is out of range");
6082 po_reg_or_goto (REG_TYPE_NDQ
, try_shimm
);
6085 po_imm_or_fail (0, 63, TRUE
);
6090 po_char_or_fail ('[');
6091 po_reg_or_fail (REG_TYPE_RN
);
6092 po_char_or_fail (']');
6097 po_reg_or_fail (REG_TYPE_RN
);
6098 if (skip_past_char (&str
, '!') == SUCCESS
)
6099 inst
.operands
[i
].writeback
= 1;
6103 case OP_I7
: po_imm_or_fail ( 0, 7, FALSE
); break;
6104 case OP_I15
: po_imm_or_fail ( 0, 15, FALSE
); break;
6105 case OP_I16
: po_imm_or_fail ( 1, 16, FALSE
); break;
6106 case OP_I16z
: po_imm_or_fail ( 0, 16, FALSE
); break;
6107 case OP_I31
: po_imm_or_fail ( 0, 31, FALSE
); break;
6108 case OP_I32
: po_imm_or_fail ( 1, 32, FALSE
); break;
6109 case OP_I32z
: po_imm_or_fail ( 0, 32, FALSE
); break;
6110 case OP_I63s
: po_imm_or_fail (-64, 63, FALSE
); break;
6111 case OP_I63
: po_imm_or_fail ( 0, 63, FALSE
); break;
6112 case OP_I64
: po_imm_or_fail ( 1, 64, FALSE
); break;
6113 case OP_I64z
: po_imm_or_fail ( 0, 64, FALSE
); break;
6114 case OP_I255
: po_imm_or_fail ( 0, 255, FALSE
); break;
6116 case OP_I4b
: po_imm_or_fail ( 1, 4, TRUE
); break;
6118 case OP_I7b
: po_imm_or_fail ( 0, 7, TRUE
); break;
6119 case OP_I15b
: po_imm_or_fail ( 0, 15, TRUE
); break;
6121 case OP_I31b
: po_imm_or_fail ( 0, 31, TRUE
); break;
6122 case OP_oI32b
: po_imm_or_fail ( 1, 32, TRUE
); break;
6123 case OP_oIffffb
: po_imm_or_fail ( 0, 0xffff, TRUE
); break;
6125 /* Immediate variants */
6127 po_char_or_fail ('{');
6128 po_imm_or_fail (0, 255, TRUE
);
6129 po_char_or_fail ('}');
6133 /* The expression parser chokes on a trailing !, so we have
6134 to find it first and zap it. */
6137 while (*s
&& *s
!= ',')
6142 inst
.operands
[i
].writeback
= 1;
6144 po_imm_or_fail (0, 31, TRUE
);
6152 po_misc_or_fail (my_get_expression (&inst
.reloc
.exp
, &str
,
6157 po_misc_or_fail (my_get_expression (&inst
.reloc
.exp
, &str
,
6162 po_misc_or_fail (my_get_expression (&inst
.reloc
.exp
, &str
,
6164 if (inst
.reloc
.exp
.X_op
== O_symbol
)
6166 val
= parse_reloc (&str
);
6169 inst
.error
= _("unrecognized relocation suffix");
6172 else if (val
!= BFD_RELOC_UNUSED
)
6174 inst
.operands
[i
].imm
= val
;
6175 inst
.operands
[i
].hasreloc
= 1;
6180 /* Operand for MOVW or MOVT. */
6182 po_misc_or_fail (parse_half (&str
));
6185 /* Register or expression. */
6186 case OP_RR_EXr
: po_reg_or_goto (REG_TYPE_RN
, EXPr
); break;
6187 case OP_RR_EXi
: po_reg_or_goto (REG_TYPE_RN
, EXPi
); break;
6189 /* Register or immediate. */
6190 case OP_RRnpc_I0
: po_reg_or_goto (REG_TYPE_RN
, I0
); break;
6191 I0
: po_imm_or_fail (0, 0, FALSE
); break;
6193 case OP_RF_IF
: po_reg_or_goto (REG_TYPE_FN
, IF
); break;
6195 if (!is_immediate_prefix (*str
))
6198 val
= parse_fpa_immediate (&str
);
6201 /* FPA immediates are encoded as registers 8-15.
6202 parse_fpa_immediate has already applied the offset. */
6203 inst
.operands
[i
].reg
= val
;
6204 inst
.operands
[i
].isreg
= 1;
6207 case OP_RIWR_I32z
: po_reg_or_goto (REG_TYPE_MMXWR
, I32z
); break;
6208 I32z
: po_imm_or_fail (0, 32, FALSE
); break;
6210 /* Two kinds of register. */
6213 struct reg_entry
*rege
= arm_reg_parse_multi (&str
);
6215 || (rege
->type
!= REG_TYPE_MMXWR
6216 && rege
->type
!= REG_TYPE_MMXWC
6217 && rege
->type
!= REG_TYPE_MMXWCG
))
6219 inst
.error
= _("iWMMXt data or control register expected");
6222 inst
.operands
[i
].reg
= rege
->number
;
6223 inst
.operands
[i
].isreg
= (rege
->type
== REG_TYPE_MMXWR
);
6229 struct reg_entry
*rege
= arm_reg_parse_multi (&str
);
6231 || (rege
->type
!= REG_TYPE_MMXWC
6232 && rege
->type
!= REG_TYPE_MMXWCG
))
6234 inst
.error
= _("iWMMXt control register expected");
6237 inst
.operands
[i
].reg
= rege
->number
;
6238 inst
.operands
[i
].isreg
= 1;
6243 case OP_CPSF
: val
= parse_cps_flags (&str
); break;
6244 case OP_ENDI
: val
= parse_endian_specifier (&str
); break;
6245 case OP_oROR
: val
= parse_ror (&str
); break;
6246 case OP_PSR
: val
= parse_psr (&str
); break;
6247 case OP_COND
: val
= parse_cond (&str
); break;
6248 case OP_oBARRIER
:val
= parse_barrier (&str
); break;
6251 po_reg_or_goto (REG_TYPE_VFC
, try_psr
);
6252 inst
.operands
[i
].isvec
= 1; /* Mark VFP control reg as vector. */
6255 val
= parse_psr (&str
);
6259 po_reg_or_goto (REG_TYPE_RN
, try_apsr
);
6262 /* Parse "APSR_nvzc" operand (for FMSTAT-equivalent MRS
6264 if (strncasecmp (str
, "APSR_", 5) == 0)
6271 case 'c': found
= (found
& 1) ? 16 : found
| 1; break;
6272 case 'n': found
= (found
& 2) ? 16 : found
| 2; break;
6273 case 'z': found
= (found
& 4) ? 16 : found
| 4; break;
6274 case 'v': found
= (found
& 8) ? 16 : found
| 8; break;
6275 default: found
= 16;
6279 inst
.operands
[i
].isvec
= 1;
6280 /* APSR_nzcv is encoded in instructions as if it were the REG_PC. */
6281 inst
.operands
[i
].reg
= REG_PC
;
6288 po_misc_or_fail (parse_tb (&str
));
6291 /* Register lists. */
6293 val
= parse_reg_list (&str
);
6296 inst
.operands
[1].writeback
= 1;
6302 val
= parse_vfp_reg_list (&str
, &inst
.operands
[i
].reg
, REGLIST_VFP_S
);
6306 val
= parse_vfp_reg_list (&str
, &inst
.operands
[i
].reg
, REGLIST_VFP_D
);
6310 /* Allow Q registers too. */
6311 val
= parse_vfp_reg_list (&str
, &inst
.operands
[i
].reg
,
6316 val
= parse_vfp_reg_list (&str
, &inst
.operands
[i
].reg
,
6318 inst
.operands
[i
].issingle
= 1;
6323 val
= parse_vfp_reg_list (&str
, &inst
.operands
[i
].reg
,
6328 val
= parse_neon_el_struct_list (&str
, &inst
.operands
[i
].reg
,
6329 &inst
.operands
[i
].vectype
);
6332 /* Addressing modes */
6334 po_misc_or_fail (parse_address (&str
, i
));
6338 po_misc_or_fail_no_backtrack (
6339 parse_address_group_reloc (&str
, i
, GROUP_LDR
));
6343 po_misc_or_fail_no_backtrack (
6344 parse_address_group_reloc (&str
, i
, GROUP_LDRS
));
6348 po_misc_or_fail_no_backtrack (
6349 parse_address_group_reloc (&str
, i
, GROUP_LDC
));
6353 po_misc_or_fail (parse_shifter_operand (&str
, i
));
6357 po_misc_or_fail_no_backtrack (
6358 parse_shifter_operand_group_reloc (&str
, i
));
6362 po_misc_or_fail (parse_shift (&str
, i
, SHIFT_LSL_IMMEDIATE
));
6366 po_misc_or_fail (parse_shift (&str
, i
, SHIFT_ASR_IMMEDIATE
));
6370 po_misc_or_fail (parse_shift (&str
, i
, SHIFT_LSL_OR_ASR_IMMEDIATE
));
6374 as_fatal (_("unhandled operand code %d"), upat
[i
]);
6377 /* Various value-based sanity checks and shared operations. We
6378 do not signal immediate failures for the register constraints;
6379 this allows a syntax error to take precedence. */
6388 if (inst
.operands
[i
].isreg
&& inst
.operands
[i
].reg
== REG_PC
)
6389 inst
.error
= BAD_PC
;
6407 inst
.operands
[i
].imm
= val
;
6414 /* If we get here, this operand was successfully parsed. */
6415 inst
.operands
[i
].present
= 1;
6419 inst
.error
= BAD_ARGS
;
6424 /* The parse routine should already have set inst.error, but set a
6425 default here just in case. */
6427 inst
.error
= _("syntax error");
6431 /* Do not backtrack over a trailing optional argument that
6432 absorbed some text. We will only fail again, with the
6433 'garbage following instruction' error message, which is
6434 probably less helpful than the current one. */
6435 if (backtrack_index
== i
&& backtrack_pos
!= str
6436 && upat
[i
+1] == OP_stop
)
6439 inst
.error
= _("syntax error");
6443 /* Try again, skipping the optional argument at backtrack_pos. */
6444 str
= backtrack_pos
;
6445 inst
.error
= backtrack_error
;
6446 inst
.operands
[backtrack_index
].present
= 0;
6447 i
= backtrack_index
;
6451 /* Check that we have parsed all the arguments. */
6452 if (*str
!= '\0' && !inst
.error
)
6453 inst
.error
= _("garbage following instruction");
6455 return inst
.error
? FAIL
: SUCCESS
;
6458 #undef po_char_or_fail
6459 #undef po_reg_or_fail
6460 #undef po_reg_or_goto
6461 #undef po_imm_or_fail
6462 #undef po_scalar_or_fail
6464 /* Shorthand macro for instruction encoding functions issuing errors. */
6465 #define constraint(expr, err) \
6476 /* Reject "bad registers" for Thumb-2 instructions. Many Thumb-2
6477 instructions are unpredictable if these registers are used. This
6478 is the BadReg predicate in ARM's Thumb-2 documentation. */
6479 #define reject_bad_reg(reg) \
6481 if (reg == REG_SP || reg == REG_PC) \
6483 inst.error = (reg == REG_SP) ? BAD_SP : BAD_PC; \
6488 /* If REG is R13 (the stack pointer), warn that its use is
6490 #define warn_deprecated_sp(reg) \
6492 if (warn_on_deprecated && reg == REG_SP) \
6493 as_warn (_("use of r13 is deprecated")); \
6496 /* Functions for operand encoding. ARM, then Thumb. */
6498 #define rotate_left(v, n) (v << n | v >> (32 - n))
6500 /* If VAL can be encoded in the immediate field of an ARM instruction,
6501 return the encoded form. Otherwise, return FAIL. */
6504 encode_arm_immediate (unsigned int val
)
6508 for (i
= 0; i
< 32; i
+= 2)
6509 if ((a
= rotate_left (val
, i
)) <= 0xff)
6510 return a
| (i
<< 7); /* 12-bit pack: [shift-cnt,const]. */
6515 /* If VAL can be encoded in the immediate field of a Thumb32 instruction,
6516 return the encoded form. Otherwise, return FAIL. */
6518 encode_thumb32_immediate (unsigned int val
)
6525 for (i
= 1; i
<= 24; i
++)
6528 if ((val
& ~(0xff << i
)) == 0)
6529 return ((val
>> i
) & 0x7f) | ((32 - i
) << 7);
6533 if (val
== ((a
<< 16) | a
))
6535 if (val
== ((a
<< 24) | (a
<< 16) | (a
<< 8) | a
))
6539 if (val
== ((a
<< 16) | a
))
6540 return 0x200 | (a
>> 8);
6544 /* Encode a VFP SP or DP register number into inst.instruction. */
6547 encode_arm_vfp_reg (int reg
, enum vfp_reg_pos pos
)
6549 if ((pos
== VFP_REG_Dd
|| pos
== VFP_REG_Dn
|| pos
== VFP_REG_Dm
)
6552 if (ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_vfp_ext_d32
))
6555 ARM_MERGE_FEATURE_SETS (thumb_arch_used
, thumb_arch_used
,
6558 ARM_MERGE_FEATURE_SETS (arm_arch_used
, arm_arch_used
,
6563 first_error (_("D register out of range for selected VFP version"));
6571 inst
.instruction
|= ((reg
>> 1) << 12) | ((reg
& 1) << 22);
6575 inst
.instruction
|= ((reg
>> 1) << 16) | ((reg
& 1) << 7);
6579 inst
.instruction
|= ((reg
>> 1) << 0) | ((reg
& 1) << 5);
6583 inst
.instruction
|= ((reg
& 15) << 12) | ((reg
>> 4) << 22);
6587 inst
.instruction
|= ((reg
& 15) << 16) | ((reg
>> 4) << 7);
6591 inst
.instruction
|= (reg
& 15) | ((reg
>> 4) << 5);
6599 /* Encode a <shift> in an ARM-format instruction. The immediate,
6600 if any, is handled by md_apply_fix. */
6602 encode_arm_shift (int i
)
6604 if (inst
.operands
[i
].shift_kind
== SHIFT_RRX
)
6605 inst
.instruction
|= SHIFT_ROR
<< 5;
6608 inst
.instruction
|= inst
.operands
[i
].shift_kind
<< 5;
6609 if (inst
.operands
[i
].immisreg
)
6611 inst
.instruction
|= SHIFT_BY_REG
;
6612 inst
.instruction
|= inst
.operands
[i
].imm
<< 8;
6615 inst
.reloc
.type
= BFD_RELOC_ARM_SHIFT_IMM
;
6620 encode_arm_shifter_operand (int i
)
6622 if (inst
.operands
[i
].isreg
)
6624 inst
.instruction
|= inst
.operands
[i
].reg
;
6625 encode_arm_shift (i
);
6628 inst
.instruction
|= INST_IMMEDIATE
;
6631 /* Subroutine of encode_arm_addr_mode_2 and encode_arm_addr_mode_3. */
6633 encode_arm_addr_mode_common (int i
, bfd_boolean is_t
)
6635 gas_assert (inst
.operands
[i
].isreg
);
6636 inst
.instruction
|= inst
.operands
[i
].reg
<< 16;
6638 if (inst
.operands
[i
].preind
)
6642 inst
.error
= _("instruction does not accept preindexed addressing");
6645 inst
.instruction
|= PRE_INDEX
;
6646 if (inst
.operands
[i
].writeback
)
6647 inst
.instruction
|= WRITE_BACK
;
6650 else if (inst
.operands
[i
].postind
)
6652 gas_assert (inst
.operands
[i
].writeback
);
6654 inst
.instruction
|= WRITE_BACK
;
6656 else /* unindexed - only for coprocessor */
6658 inst
.error
= _("instruction does not accept unindexed addressing");
6662 if (((inst
.instruction
& WRITE_BACK
) || !(inst
.instruction
& PRE_INDEX
))
6663 && (((inst
.instruction
& 0x000f0000) >> 16)
6664 == ((inst
.instruction
& 0x0000f000) >> 12)))
6665 as_warn ((inst
.instruction
& LOAD_BIT
)
6666 ? _("destination register same as write-back base")
6667 : _("source register same as write-back base"));
6670 /* inst.operands[i] was set up by parse_address. Encode it into an
6671 ARM-format mode 2 load or store instruction. If is_t is true,
6672 reject forms that cannot be used with a T instruction (i.e. not
6675 encode_arm_addr_mode_2 (int i
, bfd_boolean is_t
)
6677 encode_arm_addr_mode_common (i
, is_t
);
6679 if (inst
.operands
[i
].immisreg
)
6681 inst
.instruction
|= INST_IMMEDIATE
; /* yes, this is backwards */
6682 inst
.instruction
|= inst
.operands
[i
].imm
;
6683 if (!inst
.operands
[i
].negative
)
6684 inst
.instruction
|= INDEX_UP
;
6685 if (inst
.operands
[i
].shifted
)
6687 if (inst
.operands
[i
].shift_kind
== SHIFT_RRX
)
6688 inst
.instruction
|= SHIFT_ROR
<< 5;
6691 inst
.instruction
|= inst
.operands
[i
].shift_kind
<< 5;
6692 inst
.reloc
.type
= BFD_RELOC_ARM_SHIFT_IMM
;
6696 else /* immediate offset in inst.reloc */
6698 if (inst
.reloc
.type
== BFD_RELOC_UNUSED
)
6699 inst
.reloc
.type
= BFD_RELOC_ARM_OFFSET_IMM
;
6703 /* inst.operands[i] was set up by parse_address. Encode it into an
6704 ARM-format mode 3 load or store instruction. Reject forms that
6705 cannot be used with such instructions. If is_t is true, reject
6706 forms that cannot be used with a T instruction (i.e. not
6709 encode_arm_addr_mode_3 (int i
, bfd_boolean is_t
)
6711 if (inst
.operands
[i
].immisreg
&& inst
.operands
[i
].shifted
)
6713 inst
.error
= _("instruction does not accept scaled register index");
6717 encode_arm_addr_mode_common (i
, is_t
);
6719 if (inst
.operands
[i
].immisreg
)
6721 inst
.instruction
|= inst
.operands
[i
].imm
;
6722 if (!inst
.operands
[i
].negative
)
6723 inst
.instruction
|= INDEX_UP
;
6725 else /* immediate offset in inst.reloc */
6727 inst
.instruction
|= HWOFFSET_IMM
;
6728 if (inst
.reloc
.type
== BFD_RELOC_UNUSED
)
6729 inst
.reloc
.type
= BFD_RELOC_ARM_OFFSET_IMM8
;
6733 /* inst.operands[i] was set up by parse_address. Encode it into an
6734 ARM-format instruction. Reject all forms which cannot be encoded
6735 into a coprocessor load/store instruction. If wb_ok is false,
6736 reject use of writeback; if unind_ok is false, reject use of
6737 unindexed addressing. If reloc_override is not 0, use it instead
6738 of BFD_ARM_CP_OFF_IMM, unless the initial relocation is a group one
6739 (in which case it is preserved). */
6742 encode_arm_cp_address (int i
, int wb_ok
, int unind_ok
, int reloc_override
)
6744 inst
.instruction
|= inst
.operands
[i
].reg
<< 16;
6746 gas_assert (!(inst
.operands
[i
].preind
&& inst
.operands
[i
].postind
));
6748 if (!inst
.operands
[i
].preind
&& !inst
.operands
[i
].postind
) /* unindexed */
6750 gas_assert (!inst
.operands
[i
].writeback
);
6753 inst
.error
= _("instruction does not support unindexed addressing");
6756 inst
.instruction
|= inst
.operands
[i
].imm
;
6757 inst
.instruction
|= INDEX_UP
;
6761 if (inst
.operands
[i
].preind
)
6762 inst
.instruction
|= PRE_INDEX
;
6764 if (inst
.operands
[i
].writeback
)
6766 if (inst
.operands
[i
].reg
== REG_PC
)
6768 inst
.error
= _("pc may not be used with write-back");
6773 inst
.error
= _("instruction does not support writeback");
6776 inst
.instruction
|= WRITE_BACK
;
6780 inst
.reloc
.type
= (bfd_reloc_code_real_type
) reloc_override
;
6781 else if ((inst
.reloc
.type
< BFD_RELOC_ARM_ALU_PC_G0_NC
6782 || inst
.reloc
.type
> BFD_RELOC_ARM_LDC_SB_G2
)
6783 && inst
.reloc
.type
!= BFD_RELOC_ARM_LDR_PC_G0
)
6786 inst
.reloc
.type
= BFD_RELOC_ARM_T32_CP_OFF_IMM
;
6788 inst
.reloc
.type
= BFD_RELOC_ARM_CP_OFF_IMM
;
6794 /* inst.reloc.exp describes an "=expr" load pseudo-operation.
6795 Determine whether it can be performed with a move instruction; if
6796 it can, convert inst.instruction to that move instruction and
6797 return TRUE; if it can't, convert inst.instruction to a literal-pool
6798 load and return FALSE. If this is not a valid thing to do in the
6799 current context, set inst.error and return TRUE.
6801 inst.operands[i] describes the destination register. */
6804 move_or_literal_pool (int i
, bfd_boolean thumb_p
, bfd_boolean mode_3
)
6809 tbit
= (inst
.instruction
> 0xffff) ? THUMB2_LOAD_BIT
: THUMB_LOAD_BIT
;
6813 if ((inst
.instruction
& tbit
) == 0)
6815 inst
.error
= _("invalid pseudo operation");
6818 if (inst
.reloc
.exp
.X_op
!= O_constant
&& inst
.reloc
.exp
.X_op
!= O_symbol
)
6820 inst
.error
= _("constant expression expected");
6823 if (inst
.reloc
.exp
.X_op
== O_constant
)
6827 if (!unified_syntax
&& (inst
.reloc
.exp
.X_add_number
& ~0xFF) == 0)
6829 /* This can be done with a mov(1) instruction. */
6830 inst
.instruction
= T_OPCODE_MOV_I8
| (inst
.operands
[i
].reg
<< 8);
6831 inst
.instruction
|= inst
.reloc
.exp
.X_add_number
;
6837 int value
= encode_arm_immediate (inst
.reloc
.exp
.X_add_number
);
6840 /* This can be done with a mov instruction. */
6841 inst
.instruction
&= LITERAL_MASK
;
6842 inst
.instruction
|= INST_IMMEDIATE
| (OPCODE_MOV
<< DATA_OP_SHIFT
);
6843 inst
.instruction
|= value
& 0xfff;
6847 value
= encode_arm_immediate (~inst
.reloc
.exp
.X_add_number
);
6850 /* This can be done with a mvn instruction. */
6851 inst
.instruction
&= LITERAL_MASK
;
6852 inst
.instruction
|= INST_IMMEDIATE
| (OPCODE_MVN
<< DATA_OP_SHIFT
);
6853 inst
.instruction
|= value
& 0xfff;
6859 if (add_to_lit_pool () == FAIL
)
6861 inst
.error
= _("literal pool insertion failed");
6864 inst
.operands
[1].reg
= REG_PC
;
6865 inst
.operands
[1].isreg
= 1;
6866 inst
.operands
[1].preind
= 1;
6867 inst
.reloc
.pc_rel
= 1;
6868 inst
.reloc
.type
= (thumb_p
6869 ? BFD_RELOC_ARM_THUMB_OFFSET
6871 ? BFD_RELOC_ARM_HWLITERAL
6872 : BFD_RELOC_ARM_LITERAL
));
6876 /* Functions for instruction encoding, sorted by sub-architecture.
6877 First some generics; their names are taken from the conventional
6878 bit positions for register arguments in ARM format instructions. */
6888 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6894 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6895 inst
.instruction
|= inst
.operands
[1].reg
;
6901 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6902 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
6908 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
6909 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
6915 unsigned Rn
= inst
.operands
[2].reg
;
6916 /* Enforce restrictions on SWP instruction. */
6917 if ((inst
.instruction
& 0x0fbfffff) == 0x01000090)
6918 constraint (Rn
== inst
.operands
[0].reg
|| Rn
== inst
.operands
[1].reg
,
6919 _("Rn must not overlap other operands"));
6920 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6921 inst
.instruction
|= inst
.operands
[1].reg
;
6922 inst
.instruction
|= Rn
<< 16;
6928 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6929 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
6930 inst
.instruction
|= inst
.operands
[2].reg
;
6936 inst
.instruction
|= inst
.operands
[0].reg
;
6937 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
6938 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
6944 inst
.instruction
|= inst
.operands
[0].imm
;
6950 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6951 encode_arm_cp_address (1, TRUE
, TRUE
, 0);
6954 /* ARM instructions, in alphabetical order by function name (except
6955 that wrapper functions appear immediately after the function they
6958 /* This is a pseudo-op of the form "adr rd, label" to be converted
6959 into a relative address of the form "add rd, pc, #label-.-8". */
6964 inst
.instruction
|= (inst
.operands
[0].reg
<< 12); /* Rd */
6966 /* Frag hacking will turn this into a sub instruction if the offset turns
6967 out to be negative. */
6968 inst
.reloc
.type
= BFD_RELOC_ARM_IMMEDIATE
;
6969 inst
.reloc
.pc_rel
= 1;
6970 inst
.reloc
.exp
.X_add_number
-= 8;
6973 /* This is a pseudo-op of the form "adrl rd, label" to be converted
6974 into a relative address of the form:
6975 add rd, pc, #low(label-.-8)"
6976 add rd, rd, #high(label-.-8)" */
6981 inst
.instruction
|= (inst
.operands
[0].reg
<< 12); /* Rd */
6983 /* Frag hacking will turn this into a sub instruction if the offset turns
6984 out to be negative. */
6985 inst
.reloc
.type
= BFD_RELOC_ARM_ADRL_IMMEDIATE
;
6986 inst
.reloc
.pc_rel
= 1;
6987 inst
.size
= INSN_SIZE
* 2;
6988 inst
.reloc
.exp
.X_add_number
-= 8;
6994 if (!inst
.operands
[1].present
)
6995 inst
.operands
[1].reg
= inst
.operands
[0].reg
;
6996 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6997 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
6998 encode_arm_shifter_operand (2);
7004 if (inst
.operands
[0].present
)
7006 constraint ((inst
.instruction
& 0xf0) != 0x40
7007 && inst
.operands
[0].imm
!= 0xf,
7008 _("bad barrier type"));
7009 inst
.instruction
|= inst
.operands
[0].imm
;
7012 inst
.instruction
|= 0xf;
7018 unsigned int msb
= inst
.operands
[1].imm
+ inst
.operands
[2].imm
;
7019 constraint (msb
> 32, _("bit-field extends past end of register"));
7020 /* The instruction encoding stores the LSB and MSB,
7021 not the LSB and width. */
7022 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7023 inst
.instruction
|= inst
.operands
[1].imm
<< 7;
7024 inst
.instruction
|= (msb
- 1) << 16;
7032 /* #0 in second position is alternative syntax for bfc, which is
7033 the same instruction but with REG_PC in the Rm field. */
7034 if (!inst
.operands
[1].isreg
)
7035 inst
.operands
[1].reg
= REG_PC
;
7037 msb
= inst
.operands
[2].imm
+ inst
.operands
[3].imm
;
7038 constraint (msb
> 32, _("bit-field extends past end of register"));
7039 /* The instruction encoding stores the LSB and MSB,
7040 not the LSB and width. */
7041 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7042 inst
.instruction
|= inst
.operands
[1].reg
;
7043 inst
.instruction
|= inst
.operands
[2].imm
<< 7;
7044 inst
.instruction
|= (msb
- 1) << 16;
7050 constraint (inst
.operands
[2].imm
+ inst
.operands
[3].imm
> 32,
7051 _("bit-field extends past end of register"));
7052 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7053 inst
.instruction
|= inst
.operands
[1].reg
;
7054 inst
.instruction
|= inst
.operands
[2].imm
<< 7;
7055 inst
.instruction
|= (inst
.operands
[3].imm
- 1) << 16;
7058 /* ARM V5 breakpoint instruction (argument parse)
7059 BKPT <16 bit unsigned immediate>
7060 Instruction is not conditional.
7061 The bit pattern given in insns[] has the COND_ALWAYS condition,
7062 and it is an error if the caller tried to override that. */
7067 /* Top 12 of 16 bits to bits 19:8. */
7068 inst
.instruction
|= (inst
.operands
[0].imm
& 0xfff0) << 4;
7070 /* Bottom 4 of 16 bits to bits 3:0. */
7071 inst
.instruction
|= inst
.operands
[0].imm
& 0xf;
7075 encode_branch (int default_reloc
)
7077 if (inst
.operands
[0].hasreloc
)
7079 constraint (inst
.operands
[0].imm
!= BFD_RELOC_ARM_PLT32
,
7080 _("the only suffix valid here is '(plt)'"));
7081 inst
.reloc
.type
= BFD_RELOC_ARM_PLT32
;
7085 inst
.reloc
.type
= (bfd_reloc_code_real_type
) default_reloc
;
7087 inst
.reloc
.pc_rel
= 1;
7094 if (EF_ARM_EABI_VERSION (meabi_flags
) >= EF_ARM_EABI_VER4
)
7095 encode_branch (BFD_RELOC_ARM_PCREL_JUMP
);
7098 encode_branch (BFD_RELOC_ARM_PCREL_BRANCH
);
7105 if (EF_ARM_EABI_VERSION (meabi_flags
) >= EF_ARM_EABI_VER4
)
7107 if (inst
.cond
== COND_ALWAYS
)
7108 encode_branch (BFD_RELOC_ARM_PCREL_CALL
);
7110 encode_branch (BFD_RELOC_ARM_PCREL_JUMP
);
7114 encode_branch (BFD_RELOC_ARM_PCREL_BRANCH
);
7117 /* ARM V5 branch-link-exchange instruction (argument parse)
7118 BLX <target_addr> ie BLX(1)
7119 BLX{<condition>} <Rm> ie BLX(2)
7120 Unfortunately, there are two different opcodes for this mnemonic.
7121 So, the insns[].value is not used, and the code here zaps values
7122 into inst.instruction.
7123 Also, the <target_addr> can be 25 bits, hence has its own reloc. */
7128 if (inst
.operands
[0].isreg
)
7130 /* Arg is a register; the opcode provided by insns[] is correct.
7131 It is not illegal to do "blx pc", just useless. */
7132 if (inst
.operands
[0].reg
== REG_PC
)
7133 as_tsktsk (_("use of r15 in blx in ARM mode is not really useful"));
7135 inst
.instruction
|= inst
.operands
[0].reg
;
7139 /* Arg is an address; this instruction cannot be executed
7140 conditionally, and the opcode must be adjusted.
7141 We retain the BFD_RELOC_ARM_PCREL_BLX till the very end
7142 where we generate out a BFD_RELOC_ARM_PCREL_CALL instead. */
7143 constraint (inst
.cond
!= COND_ALWAYS
, BAD_COND
);
7144 inst
.instruction
= 0xfa000000;
7145 encode_branch (BFD_RELOC_ARM_PCREL_BLX
);
7152 bfd_boolean want_reloc
;
7154 if (inst
.operands
[0].reg
== REG_PC
)
7155 as_tsktsk (_("use of r15 in bx in ARM mode is not really useful"));
7157 inst
.instruction
|= inst
.operands
[0].reg
;
7158 /* Output R_ARM_V4BX relocations if is an EABI object that looks like
7159 it is for ARMv4t or earlier. */
7160 want_reloc
= !ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5
);
7161 if (object_arch
&& !ARM_CPU_HAS_FEATURE (*object_arch
, arm_ext_v5
))
7165 if (EF_ARM_EABI_VERSION (meabi_flags
) < EF_ARM_EABI_VER4
)
7170 inst
.reloc
.type
= BFD_RELOC_ARM_V4BX
;
7174 /* ARM v5TEJ. Jump to Jazelle code. */
7179 if (inst
.operands
[0].reg
== REG_PC
)
7180 as_tsktsk (_("use of r15 in bxj is not really useful"));
7182 inst
.instruction
|= inst
.operands
[0].reg
;
7185 /* Co-processor data operation:
7186 CDP{cond} <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>{, <opcode_2>}
7187 CDP2 <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>{, <opcode_2>} */
7191 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7192 inst
.instruction
|= inst
.operands
[1].imm
<< 20;
7193 inst
.instruction
|= inst
.operands
[2].reg
<< 12;
7194 inst
.instruction
|= inst
.operands
[3].reg
<< 16;
7195 inst
.instruction
|= inst
.operands
[4].reg
;
7196 inst
.instruction
|= inst
.operands
[5].imm
<< 5;
7202 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
7203 encode_arm_shifter_operand (1);
7206 /* Transfer between coprocessor and ARM registers.
7207 MRC{cond} <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>{, <opcode_2>}
7212 No special properties. */
7219 Rd
= inst
.operands
[2].reg
;
7222 if (inst
.instruction
== 0xee000010
7223 || inst
.instruction
== 0xfe000010)
7225 reject_bad_reg (Rd
);
7228 constraint (Rd
== REG_SP
, BAD_SP
);
7233 if (inst
.instruction
== 0xe000010)
7234 constraint (Rd
== REG_PC
, BAD_PC
);
7238 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7239 inst
.instruction
|= inst
.operands
[1].imm
<< 21;
7240 inst
.instruction
|= Rd
<< 12;
7241 inst
.instruction
|= inst
.operands
[3].reg
<< 16;
7242 inst
.instruction
|= inst
.operands
[4].reg
;
7243 inst
.instruction
|= inst
.operands
[5].imm
<< 5;
7246 /* Transfer between coprocessor register and pair of ARM registers.
7247 MCRR{cond} <coproc>, <opcode>, <Rd>, <Rn>, <CRm>.
7252 Two XScale instructions are special cases of these:
7254 MAR{cond} acc0, <RdLo>, <RdHi> == MCRR{cond} p0, #0, <RdLo>, <RdHi>, c0
7255 MRA{cond} acc0, <RdLo>, <RdHi> == MRRC{cond} p0, #0, <RdLo>, <RdHi>, c0
7257 Result unpredictable if Rd or Rn is R15. */
7264 Rd
= inst
.operands
[2].reg
;
7265 Rn
= inst
.operands
[3].reg
;
7269 reject_bad_reg (Rd
);
7270 reject_bad_reg (Rn
);
7274 constraint (Rd
== REG_PC
, BAD_PC
);
7275 constraint (Rn
== REG_PC
, BAD_PC
);
7278 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7279 inst
.instruction
|= inst
.operands
[1].imm
<< 4;
7280 inst
.instruction
|= Rd
<< 12;
7281 inst
.instruction
|= Rn
<< 16;
7282 inst
.instruction
|= inst
.operands
[4].reg
;
7288 inst
.instruction
|= inst
.operands
[0].imm
<< 6;
7289 if (inst
.operands
[1].present
)
7291 inst
.instruction
|= CPSI_MMOD
;
7292 inst
.instruction
|= inst
.operands
[1].imm
;
7299 inst
.instruction
|= inst
.operands
[0].imm
;
7305 /* There is no IT instruction in ARM mode. We
7306 process it to do the validation as if in
7307 thumb mode, just in case the code gets
7308 assembled for thumb using the unified syntax. */
7313 set_it_insn_type (IT_INSN
);
7314 now_it
.mask
= (inst
.instruction
& 0xf) | 0x10;
7315 now_it
.cc
= inst
.operands
[0].imm
;
7322 int base_reg
= inst
.operands
[0].reg
;
7323 int range
= inst
.operands
[1].imm
;
7325 inst
.instruction
|= base_reg
<< 16;
7326 inst
.instruction
|= range
;
7328 if (inst
.operands
[1].writeback
)
7329 inst
.instruction
|= LDM_TYPE_2_OR_3
;
7331 if (inst
.operands
[0].writeback
)
7333 inst
.instruction
|= WRITE_BACK
;
7334 /* Check for unpredictable uses of writeback. */
7335 if (inst
.instruction
& LOAD_BIT
)
7337 /* Not allowed in LDM type 2. */
7338 if ((inst
.instruction
& LDM_TYPE_2_OR_3
)
7339 && ((range
& (1 << REG_PC
)) == 0))
7340 as_warn (_("writeback of base register is UNPREDICTABLE"));
7341 /* Only allowed if base reg not in list for other types. */
7342 else if (range
& (1 << base_reg
))
7343 as_warn (_("writeback of base register when in register list is UNPREDICTABLE"));
7347 /* Not allowed for type 2. */
7348 if (inst
.instruction
& LDM_TYPE_2_OR_3
)
7349 as_warn (_("writeback of base register is UNPREDICTABLE"));
7350 /* Only allowed if base reg not in list, or first in list. */
7351 else if ((range
& (1 << base_reg
))
7352 && (range
& ((1 << base_reg
) - 1)))
7353 as_warn (_("if writeback register is in list, it must be the lowest reg in the list"));
7358 /* ARMv5TE load-consecutive (argument parse)
7367 constraint (inst
.operands
[0].reg
% 2 != 0,
7368 _("first destination register must be even"));
7369 constraint (inst
.operands
[1].present
7370 && inst
.operands
[1].reg
!= inst
.operands
[0].reg
+ 1,
7371 _("can only load two consecutive registers"));
7372 constraint (inst
.operands
[0].reg
== REG_LR
, _("r14 not allowed here"));
7373 constraint (!inst
.operands
[2].isreg
, _("'[' expected"));
7375 if (!inst
.operands
[1].present
)
7376 inst
.operands
[1].reg
= inst
.operands
[0].reg
+ 1;
7378 if (inst
.instruction
& LOAD_BIT
)
7380 /* encode_arm_addr_mode_3 will diagnose overlap between the base
7381 register and the first register written; we have to diagnose
7382 overlap between the base and the second register written here. */
7384 if (inst
.operands
[2].reg
== inst
.operands
[1].reg
7385 && (inst
.operands
[2].writeback
|| inst
.operands
[2].postind
))
7386 as_warn (_("base register written back, and overlaps "
7387 "second destination register"));
7389 /* For an index-register load, the index register must not overlap the
7390 destination (even if not write-back). */
7391 else if (inst
.operands
[2].immisreg
7392 && ((unsigned) inst
.operands
[2].imm
== inst
.operands
[0].reg
7393 || (unsigned) inst
.operands
[2].imm
== inst
.operands
[1].reg
))
7394 as_warn (_("index register overlaps destination register"));
7397 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7398 encode_arm_addr_mode_3 (2, /*is_t=*/FALSE
);
7404 constraint (!inst
.operands
[1].isreg
|| !inst
.operands
[1].preind
7405 || inst
.operands
[1].postind
|| inst
.operands
[1].writeback
7406 || inst
.operands
[1].immisreg
|| inst
.operands
[1].shifted
7407 || inst
.operands
[1].negative
7408 /* This can arise if the programmer has written
7410 or if they have mistakenly used a register name as the last
7413 It is very difficult to distinguish between these two cases
7414 because "rX" might actually be a label. ie the register
7415 name has been occluded by a symbol of the same name. So we
7416 just generate a general 'bad addressing mode' type error
7417 message and leave it up to the programmer to discover the
7418 true cause and fix their mistake. */
7419 || (inst
.operands
[1].reg
== REG_PC
),
7422 constraint (inst
.reloc
.exp
.X_op
!= O_constant
7423 || inst
.reloc
.exp
.X_add_number
!= 0,
7424 _("offset must be zero in ARM encoding"));
7426 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7427 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7428 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
7434 constraint (inst
.operands
[0].reg
% 2 != 0,
7435 _("even register required"));
7436 constraint (inst
.operands
[1].present
7437 && inst
.operands
[1].reg
!= inst
.operands
[0].reg
+ 1,
7438 _("can only load two consecutive registers"));
7439 /* If op 1 were present and equal to PC, this function wouldn't
7440 have been called in the first place. */
7441 constraint (inst
.operands
[0].reg
== REG_LR
, _("r14 not allowed here"));
7443 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7444 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
7450 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7451 if (!inst
.operands
[1].isreg
)
7452 if (move_or_literal_pool (0, /*thumb_p=*/FALSE
, /*mode_3=*/FALSE
))
7454 encode_arm_addr_mode_2 (1, /*is_t=*/FALSE
);
7460 /* ldrt/strt always use post-indexed addressing. Turn [Rn] into [Rn]! and
7462 if (inst
.operands
[1].preind
)
7464 constraint (inst
.reloc
.exp
.X_op
!= O_constant
7465 || inst
.reloc
.exp
.X_add_number
!= 0,
7466 _("this instruction requires a post-indexed address"));
7468 inst
.operands
[1].preind
= 0;
7469 inst
.operands
[1].postind
= 1;
7470 inst
.operands
[1].writeback
= 1;
7472 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7473 encode_arm_addr_mode_2 (1, /*is_t=*/TRUE
);
7476 /* Halfword and signed-byte load/store operations. */
7481 constraint (inst
.operands
[0].reg
== REG_PC
, BAD_PC
);
7482 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7483 if (!inst
.operands
[1].isreg
)
7484 if (move_or_literal_pool (0, /*thumb_p=*/FALSE
, /*mode_3=*/TRUE
))
7486 encode_arm_addr_mode_3 (1, /*is_t=*/FALSE
);
7492 /* ldrt/strt always use post-indexed addressing. Turn [Rn] into [Rn]! and
7494 if (inst
.operands
[1].preind
)
7496 constraint (inst
.reloc
.exp
.X_op
!= O_constant
7497 || inst
.reloc
.exp
.X_add_number
!= 0,
7498 _("this instruction requires a post-indexed address"));
7500 inst
.operands
[1].preind
= 0;
7501 inst
.operands
[1].postind
= 1;
7502 inst
.operands
[1].writeback
= 1;
7504 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7505 encode_arm_addr_mode_3 (1, /*is_t=*/TRUE
);
7508 /* Co-processor register load/store.
7509 Format: <LDC|STC>{cond}[L] CP#,CRd,<address> */
7513 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7514 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
7515 encode_arm_cp_address (2, TRUE
, TRUE
, 0);
7521 /* This restriction does not apply to mls (nor to mla in v6 or later). */
7522 if (inst
.operands
[0].reg
== inst
.operands
[1].reg
7523 && !ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v6
)
7524 && !(inst
.instruction
& 0x00400000))
7525 as_tsktsk (_("Rd and Rm should be different in mla"));
7527 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
7528 inst
.instruction
|= inst
.operands
[1].reg
;
7529 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
7530 inst
.instruction
|= inst
.operands
[3].reg
<< 12;
7536 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7537 encode_arm_shifter_operand (1);
7540 /* ARM V6T2 16-bit immediate register load: MOV[WT]{cond} Rd, #<imm16>. */
7547 top
= (inst
.instruction
& 0x00400000) != 0;
7548 constraint (top
&& inst
.reloc
.type
== BFD_RELOC_ARM_MOVW
,
7549 _(":lower16: not allowed this instruction"));
7550 constraint (!top
&& inst
.reloc
.type
== BFD_RELOC_ARM_MOVT
,
7551 _(":upper16: not allowed instruction"));
7552 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7553 if (inst
.reloc
.type
== BFD_RELOC_UNUSED
)
7555 imm
= inst
.reloc
.exp
.X_add_number
;
7556 /* The value is in two pieces: 0:11, 16:19. */
7557 inst
.instruction
|= (imm
& 0x00000fff);
7558 inst
.instruction
|= (imm
& 0x0000f000) << 4;
7562 static void do_vfp_nsyn_opcode (const char *);
7565 do_vfp_nsyn_mrs (void)
7567 if (inst
.operands
[0].isvec
)
7569 if (inst
.operands
[1].reg
!= 1)
7570 first_error (_("operand 1 must be FPSCR"));
7571 memset (&inst
.operands
[0], '\0', sizeof (inst
.operands
[0]));
7572 memset (&inst
.operands
[1], '\0', sizeof (inst
.operands
[1]));
7573 do_vfp_nsyn_opcode ("fmstat");
7575 else if (inst
.operands
[1].isvec
)
7576 do_vfp_nsyn_opcode ("fmrx");
7584 do_vfp_nsyn_msr (void)
7586 if (inst
.operands
[0].isvec
)
7587 do_vfp_nsyn_opcode ("fmxr");
7597 unsigned Rt
= inst
.operands
[0].reg
;
7599 if (thumb_mode
&& inst
.operands
[0].reg
== REG_SP
)
7601 inst
.error
= BAD_SP
;
7605 /* APSR_ sets isvec. All other refs to PC are illegal. */
7606 if (!inst
.operands
[0].isvec
&& inst
.operands
[0].reg
== REG_PC
)
7608 inst
.error
= BAD_PC
;
7612 if (inst
.operands
[1].reg
!= 1)
7613 first_error (_("operand 1 must be FPSCR"));
7615 inst
.instruction
|= (Rt
<< 12);
7621 unsigned Rt
= inst
.operands
[1].reg
;
7624 reject_bad_reg (Rt
);
7625 else if (Rt
== REG_PC
)
7627 inst
.error
= BAD_PC
;
7631 if (inst
.operands
[0].reg
!= 1)
7632 first_error (_("operand 0 must be FPSCR"));
7634 inst
.instruction
|= (Rt
<< 12);
7640 if (do_vfp_nsyn_mrs () == SUCCESS
)
7643 /* mrs only accepts CPSR/SPSR/CPSR_all/SPSR_all. */
7644 constraint ((inst
.operands
[1].imm
& (PSR_c
|PSR_x
|PSR_s
|PSR_f
))
7646 _("'CPSR' or 'SPSR' expected"));
7647 constraint (inst
.operands
[0].reg
== REG_PC
, BAD_PC
);
7648 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7649 inst
.instruction
|= (inst
.operands
[1].imm
& SPSR_BIT
);
7652 /* Two possible forms:
7653 "{C|S}PSR_<field>, Rm",
7654 "{C|S}PSR_f, #expression". */
7659 if (do_vfp_nsyn_msr () == SUCCESS
)
7662 inst
.instruction
|= inst
.operands
[0].imm
;
7663 if (inst
.operands
[1].isreg
)
7664 inst
.instruction
|= inst
.operands
[1].reg
;
7667 inst
.instruction
|= INST_IMMEDIATE
;
7668 inst
.reloc
.type
= BFD_RELOC_ARM_IMMEDIATE
;
7669 inst
.reloc
.pc_rel
= 0;
7676 constraint (inst
.operands
[2].reg
== REG_PC
, BAD_PC
);
7678 if (!inst
.operands
[2].present
)
7679 inst
.operands
[2].reg
= inst
.operands
[0].reg
;
7680 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
7681 inst
.instruction
|= inst
.operands
[1].reg
;
7682 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
7684 if (inst
.operands
[0].reg
== inst
.operands
[1].reg
7685 && !ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v6
))
7686 as_tsktsk (_("Rd and Rm should be different in mul"));
7689 /* Long Multiply Parser
7690 UMULL RdLo, RdHi, Rm, Rs
7691 SMULL RdLo, RdHi, Rm, Rs
7692 UMLAL RdLo, RdHi, Rm, Rs
7693 SMLAL RdLo, RdHi, Rm, Rs. */
7698 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7699 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7700 inst
.instruction
|= inst
.operands
[2].reg
;
7701 inst
.instruction
|= inst
.operands
[3].reg
<< 8;
7703 /* rdhi and rdlo must be different. */
7704 if (inst
.operands
[0].reg
== inst
.operands
[1].reg
)
7705 as_tsktsk (_("rdhi and rdlo must be different"));
7707 /* rdhi, rdlo and rm must all be different before armv6. */
7708 if ((inst
.operands
[0].reg
== inst
.operands
[2].reg
7709 || inst
.operands
[1].reg
== inst
.operands
[2].reg
)
7710 && !ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v6
))
7711 as_tsktsk (_("rdhi, rdlo and rm must all be different"));
7717 if (inst
.operands
[0].present
7718 || ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v6k
))
7720 /* Architectural NOP hints are CPSR sets with no bits selected. */
7721 inst
.instruction
&= 0xf0000000;
7722 inst
.instruction
|= 0x0320f000;
7723 if (inst
.operands
[0].present
)
7724 inst
.instruction
|= inst
.operands
[0].imm
;
7728 /* ARM V6 Pack Halfword Bottom Top instruction (argument parse).
7729 PKHBT {<cond>} <Rd>, <Rn>, <Rm> {, LSL #<shift_imm>}
7730 Condition defaults to COND_ALWAYS.
7731 Error if Rd, Rn or Rm are R15. */
7736 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7737 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7738 inst
.instruction
|= inst
.operands
[2].reg
;
7739 if (inst
.operands
[3].present
)
7740 encode_arm_shift (3);
7743 /* ARM V6 PKHTB (Argument Parse). */
7748 if (!inst
.operands
[3].present
)
7750 /* If the shift specifier is omitted, turn the instruction
7751 into pkhbt rd, rm, rn. */
7752 inst
.instruction
&= 0xfff00010;
7753 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7754 inst
.instruction
|= inst
.operands
[1].reg
;
7755 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
7759 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7760 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7761 inst
.instruction
|= inst
.operands
[2].reg
;
7762 encode_arm_shift (3);
7766 /* ARMv5TE: Preload-Cache
7770 Syntactically, like LDR with B=1, W=0, L=1. */
7775 constraint (!inst
.operands
[0].isreg
,
7776 _("'[' expected after PLD mnemonic"));
7777 constraint (inst
.operands
[0].postind
,
7778 _("post-indexed expression used in preload instruction"));
7779 constraint (inst
.operands
[0].writeback
,
7780 _("writeback used in preload instruction"));
7781 constraint (!inst
.operands
[0].preind
,
7782 _("unindexed addressing used in preload instruction"));
7783 encode_arm_addr_mode_2 (0, /*is_t=*/FALSE
);
7786 /* ARMv7: PLI <addr_mode> */
7790 constraint (!inst
.operands
[0].isreg
,
7791 _("'[' expected after PLI mnemonic"));
7792 constraint (inst
.operands
[0].postind
,
7793 _("post-indexed expression used in preload instruction"));
7794 constraint (inst
.operands
[0].writeback
,
7795 _("writeback used in preload instruction"));
7796 constraint (!inst
.operands
[0].preind
,
7797 _("unindexed addressing used in preload instruction"));
7798 encode_arm_addr_mode_2 (0, /*is_t=*/FALSE
);
7799 inst
.instruction
&= ~PRE_INDEX
;
7805 inst
.operands
[1] = inst
.operands
[0];
7806 memset (&inst
.operands
[0], 0, sizeof inst
.operands
[0]);
7807 inst
.operands
[0].isreg
= 1;
7808 inst
.operands
[0].writeback
= 1;
7809 inst
.operands
[0].reg
= REG_SP
;
7813 /* ARM V6 RFE (Return from Exception) loads the PC and CPSR from the
7814 word at the specified address and the following word
7816 Unconditionally executed.
7817 Error if Rn is R15. */
7822 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
7823 if (inst
.operands
[0].writeback
)
7824 inst
.instruction
|= WRITE_BACK
;
7827 /* ARM V6 ssat (argument parse). */
7832 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7833 inst
.instruction
|= (inst
.operands
[1].imm
- 1) << 16;
7834 inst
.instruction
|= inst
.operands
[2].reg
;
7836 if (inst
.operands
[3].present
)
7837 encode_arm_shift (3);
7840 /* ARM V6 usat (argument parse). */
7845 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7846 inst
.instruction
|= inst
.operands
[1].imm
<< 16;
7847 inst
.instruction
|= inst
.operands
[2].reg
;
7849 if (inst
.operands
[3].present
)
7850 encode_arm_shift (3);
7853 /* ARM V6 ssat16 (argument parse). */
7858 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7859 inst
.instruction
|= ((inst
.operands
[1].imm
- 1) << 16);
7860 inst
.instruction
|= inst
.operands
[2].reg
;
7866 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7867 inst
.instruction
|= inst
.operands
[1].imm
<< 16;
7868 inst
.instruction
|= inst
.operands
[2].reg
;
7871 /* ARM V6 SETEND (argument parse). Sets the E bit in the CPSR while
7872 preserving the other bits.
7874 setend <endian_specifier>, where <endian_specifier> is either
7880 if (inst
.operands
[0].imm
)
7881 inst
.instruction
|= 0x200;
7887 unsigned int Rm
= (inst
.operands
[1].present
7888 ? inst
.operands
[1].reg
7889 : inst
.operands
[0].reg
);
7891 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7892 inst
.instruction
|= Rm
;
7893 if (inst
.operands
[2].isreg
) /* Rd, {Rm,} Rs */
7895 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
7896 inst
.instruction
|= SHIFT_BY_REG
;
7899 inst
.reloc
.type
= BFD_RELOC_ARM_SHIFT_IMM
;
7905 inst
.reloc
.type
= BFD_RELOC_ARM_SMC
;
7906 inst
.reloc
.pc_rel
= 0;
7912 inst
.reloc
.type
= BFD_RELOC_ARM_SWI
;
7913 inst
.reloc
.pc_rel
= 0;
7916 /* ARM V5E (El Segundo) signed-multiply-accumulate (argument parse)
7917 SMLAxy{cond} Rd,Rm,Rs,Rn
7918 SMLAWy{cond} Rd,Rm,Rs,Rn
7919 Error if any register is R15. */
7924 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
7925 inst
.instruction
|= inst
.operands
[1].reg
;
7926 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
7927 inst
.instruction
|= inst
.operands
[3].reg
<< 12;
7930 /* ARM V5E (El Segundo) signed-multiply-accumulate-long (argument parse)
7931 SMLALxy{cond} Rdlo,Rdhi,Rm,Rs
7932 Error if any register is R15.
7933 Warning if Rdlo == Rdhi. */
7938 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7939 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7940 inst
.instruction
|= inst
.operands
[2].reg
;
7941 inst
.instruction
|= inst
.operands
[3].reg
<< 8;
7943 if (inst
.operands
[0].reg
== inst
.operands
[1].reg
)
7944 as_tsktsk (_("rdhi and rdlo must be different"));
7947 /* ARM V5E (El Segundo) signed-multiply (argument parse)
7948 SMULxy{cond} Rd,Rm,Rs
7949 Error if any register is R15. */
7954 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
7955 inst
.instruction
|= inst
.operands
[1].reg
;
7956 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
7959 /* ARM V6 srs (argument parse). The variable fields in the encoding are
7960 the same for both ARM and Thumb-2. */
7967 if (inst
.operands
[0].present
)
7969 reg
= inst
.operands
[0].reg
;
7970 constraint (reg
!= REG_SP
, _("SRS base register must be r13"));
7975 inst
.instruction
|= reg
<< 16;
7976 inst
.instruction
|= inst
.operands
[1].imm
;
7977 if (inst
.operands
[0].writeback
|| inst
.operands
[1].writeback
)
7978 inst
.instruction
|= WRITE_BACK
;
7981 /* ARM V6 strex (argument parse). */
7986 constraint (!inst
.operands
[2].isreg
|| !inst
.operands
[2].preind
7987 || inst
.operands
[2].postind
|| inst
.operands
[2].writeback
7988 || inst
.operands
[2].immisreg
|| inst
.operands
[2].shifted
7989 || inst
.operands
[2].negative
7990 /* See comment in do_ldrex(). */
7991 || (inst
.operands
[2].reg
== REG_PC
),
7994 constraint (inst
.operands
[0].reg
== inst
.operands
[1].reg
7995 || inst
.operands
[0].reg
== inst
.operands
[2].reg
, BAD_OVERLAP
);
7997 constraint (inst
.reloc
.exp
.X_op
!= O_constant
7998 || inst
.reloc
.exp
.X_add_number
!= 0,
7999 _("offset must be zero in ARM encoding"));
8001 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8002 inst
.instruction
|= inst
.operands
[1].reg
;
8003 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
8004 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
8010 constraint (inst
.operands
[1].reg
% 2 != 0,
8011 _("even register required"));
8012 constraint (inst
.operands
[2].present
8013 && inst
.operands
[2].reg
!= inst
.operands
[1].reg
+ 1,
8014 _("can only store two consecutive registers"));
8015 /* If op 2 were present and equal to PC, this function wouldn't
8016 have been called in the first place. */
8017 constraint (inst
.operands
[1].reg
== REG_LR
, _("r14 not allowed here"));
8019 constraint (inst
.operands
[0].reg
== inst
.operands
[1].reg
8020 || inst
.operands
[0].reg
== inst
.operands
[1].reg
+ 1
8021 || inst
.operands
[0].reg
== inst
.operands
[3].reg
,
8024 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8025 inst
.instruction
|= inst
.operands
[1].reg
;
8026 inst
.instruction
|= inst
.operands
[3].reg
<< 16;
8029 /* ARM V6 SXTAH extracts a 16-bit value from a register, sign
8030 extends it to 32-bits, and adds the result to a value in another
8031 register. You can specify a rotation by 0, 8, 16, or 24 bits
8032 before extracting the 16-bit value.
8033 SXTAH{<cond>} <Rd>, <Rn>, <Rm>{, <rotation>}
8034 Condition defaults to COND_ALWAYS.
8035 Error if any register uses R15. */
8040 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8041 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
8042 inst
.instruction
|= inst
.operands
[2].reg
;
8043 inst
.instruction
|= inst
.operands
[3].imm
<< 10;
8048 SXTH {<cond>} <Rd>, <Rm>{, <rotation>}
8049 Condition defaults to COND_ALWAYS.
8050 Error if any register uses R15. */
8055 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8056 inst
.instruction
|= inst
.operands
[1].reg
;
8057 inst
.instruction
|= inst
.operands
[2].imm
<< 10;
8060 /* VFP instructions. In a logical order: SP variant first, monad
8061 before dyad, arithmetic then move then load/store. */
8064 do_vfp_sp_monadic (void)
8066 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
8067 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Sm
);
8071 do_vfp_sp_dyadic (void)
8073 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
8074 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Sn
);
8075 encode_arm_vfp_reg (inst
.operands
[2].reg
, VFP_REG_Sm
);
8079 do_vfp_sp_compare_z (void)
8081 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
8085 do_vfp_dp_sp_cvt (void)
8087 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dd
);
8088 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Sm
);
8092 do_vfp_sp_dp_cvt (void)
8094 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
8095 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Dm
);
8099 do_vfp_reg_from_sp (void)
8101 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8102 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Sn
);
8106 do_vfp_reg2_from_sp2 (void)
8108 constraint (inst
.operands
[2].imm
!= 2,
8109 _("only two consecutive VFP SP registers allowed here"));
8110 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8111 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
8112 encode_arm_vfp_reg (inst
.operands
[2].reg
, VFP_REG_Sm
);
8116 do_vfp_sp_from_reg (void)
8118 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sn
);
8119 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
8123 do_vfp_sp2_from_reg2 (void)
8125 constraint (inst
.operands
[0].imm
!= 2,
8126 _("only two consecutive VFP SP registers allowed here"));
8127 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sm
);
8128 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
8129 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
8133 do_vfp_sp_ldst (void)
8135 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
8136 encode_arm_cp_address (1, FALSE
, TRUE
, 0);
8140 do_vfp_dp_ldst (void)
8142 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dd
);
8143 encode_arm_cp_address (1, FALSE
, TRUE
, 0);
8148 vfp_sp_ldstm (enum vfp_ldstm_type ldstm_type
)
8150 if (inst
.operands
[0].writeback
)
8151 inst
.instruction
|= WRITE_BACK
;
8153 constraint (ldstm_type
!= VFP_LDSTMIA
,
8154 _("this addressing mode requires base-register writeback"));
8155 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
8156 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Sd
);
8157 inst
.instruction
|= inst
.operands
[1].imm
;
8161 vfp_dp_ldstm (enum vfp_ldstm_type ldstm_type
)
8165 if (inst
.operands
[0].writeback
)
8166 inst
.instruction
|= WRITE_BACK
;
8168 constraint (ldstm_type
!= VFP_LDSTMIA
&& ldstm_type
!= VFP_LDSTMIAX
,
8169 _("this addressing mode requires base-register writeback"));
8171 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
8172 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Dd
);
8174 count
= inst
.operands
[1].imm
<< 1;
8175 if (ldstm_type
== VFP_LDSTMIAX
|| ldstm_type
== VFP_LDSTMDBX
)
8178 inst
.instruction
|= count
;
8182 do_vfp_sp_ldstmia (void)
8184 vfp_sp_ldstm (VFP_LDSTMIA
);
8188 do_vfp_sp_ldstmdb (void)
8190 vfp_sp_ldstm (VFP_LDSTMDB
);
8194 do_vfp_dp_ldstmia (void)
8196 vfp_dp_ldstm (VFP_LDSTMIA
);
8200 do_vfp_dp_ldstmdb (void)
8202 vfp_dp_ldstm (VFP_LDSTMDB
);
8206 do_vfp_xp_ldstmia (void)
8208 vfp_dp_ldstm (VFP_LDSTMIAX
);
8212 do_vfp_xp_ldstmdb (void)
8214 vfp_dp_ldstm (VFP_LDSTMDBX
);
8218 do_vfp_dp_rd_rm (void)
8220 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dd
);
8221 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Dm
);
8225 do_vfp_dp_rn_rd (void)
8227 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dn
);
8228 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Dd
);
8232 do_vfp_dp_rd_rn (void)
8234 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dd
);
8235 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Dn
);
8239 do_vfp_dp_rd_rn_rm (void)
8241 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dd
);
8242 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Dn
);
8243 encode_arm_vfp_reg (inst
.operands
[2].reg
, VFP_REG_Dm
);
8249 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dd
);
8253 do_vfp_dp_rm_rd_rn (void)
8255 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dm
);
8256 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Dd
);
8257 encode_arm_vfp_reg (inst
.operands
[2].reg
, VFP_REG_Dn
);
8260 /* VFPv3 instructions. */
8262 do_vfp_sp_const (void)
8264 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
8265 inst
.instruction
|= (inst
.operands
[1].imm
& 0xf0) << 12;
8266 inst
.instruction
|= (inst
.operands
[1].imm
& 0x0f);
8270 do_vfp_dp_const (void)
8272 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dd
);
8273 inst
.instruction
|= (inst
.operands
[1].imm
& 0xf0) << 12;
8274 inst
.instruction
|= (inst
.operands
[1].imm
& 0x0f);
8278 vfp_conv (int srcsize
)
8280 unsigned immbits
= srcsize
- inst
.operands
[1].imm
;
8281 inst
.instruction
|= (immbits
& 1) << 5;
8282 inst
.instruction
|= (immbits
>> 1);
8286 do_vfp_sp_conv_16 (void)
8288 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
8293 do_vfp_dp_conv_16 (void)
8295 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dd
);
8300 do_vfp_sp_conv_32 (void)
8302 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
8307 do_vfp_dp_conv_32 (void)
8309 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Dd
);
8313 /* FPA instructions. Also in a logical order. */
8318 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
8319 inst
.instruction
|= inst
.operands
[1].reg
;
8323 do_fpa_ldmstm (void)
8325 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8326 switch (inst
.operands
[1].imm
)
8328 case 1: inst
.instruction
|= CP_T_X
; break;
8329 case 2: inst
.instruction
|= CP_T_Y
; break;
8330 case 3: inst
.instruction
|= CP_T_Y
| CP_T_X
; break;
8335 if (inst
.instruction
& (PRE_INDEX
| INDEX_UP
))
8337 /* The instruction specified "ea" or "fd", so we can only accept
8338 [Rn]{!}. The instruction does not really support stacking or
8339 unstacking, so we have to emulate these by setting appropriate
8340 bits and offsets. */
8341 constraint (inst
.reloc
.exp
.X_op
!= O_constant
8342 || inst
.reloc
.exp
.X_add_number
!= 0,
8343 _("this instruction does not support indexing"));
8345 if ((inst
.instruction
& PRE_INDEX
) || inst
.operands
[2].writeback
)
8346 inst
.reloc
.exp
.X_add_number
= 12 * inst
.operands
[1].imm
;
8348 if (!(inst
.instruction
& INDEX_UP
))
8349 inst
.reloc
.exp
.X_add_number
= -inst
.reloc
.exp
.X_add_number
;
8351 if (!(inst
.instruction
& PRE_INDEX
) && inst
.operands
[2].writeback
)
8353 inst
.operands
[2].preind
= 0;
8354 inst
.operands
[2].postind
= 1;
8358 encode_arm_cp_address (2, TRUE
, TRUE
, 0);
8361 /* iWMMXt instructions: strictly in alphabetical order. */
8364 do_iwmmxt_tandorc (void)
8366 constraint (inst
.operands
[0].reg
!= REG_PC
, _("only r15 allowed here"));
8370 do_iwmmxt_textrc (void)
8372 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8373 inst
.instruction
|= inst
.operands
[1].imm
;
8377 do_iwmmxt_textrm (void)
8379 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8380 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
8381 inst
.instruction
|= inst
.operands
[2].imm
;
8385 do_iwmmxt_tinsr (void)
8387 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
8388 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
8389 inst
.instruction
|= inst
.operands
[2].imm
;
8393 do_iwmmxt_tmia (void)
8395 inst
.instruction
|= inst
.operands
[0].reg
<< 5;
8396 inst
.instruction
|= inst
.operands
[1].reg
;
8397 inst
.instruction
|= inst
.operands
[2].reg
<< 12;
8401 do_iwmmxt_waligni (void)
8403 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8404 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
8405 inst
.instruction
|= inst
.operands
[2].reg
;
8406 inst
.instruction
|= inst
.operands
[3].imm
<< 20;
8410 do_iwmmxt_wmerge (void)
8412 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8413 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
8414 inst
.instruction
|= inst
.operands
[2].reg
;
8415 inst
.instruction
|= inst
.operands
[3].imm
<< 21;
8419 do_iwmmxt_wmov (void)
8421 /* WMOV rD, rN is an alias for WOR rD, rN, rN. */
8422 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8423 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
8424 inst
.instruction
|= inst
.operands
[1].reg
;
8428 do_iwmmxt_wldstbh (void)
8431 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8433 reloc
= BFD_RELOC_ARM_T32_CP_OFF_IMM_S2
;
8435 reloc
= BFD_RELOC_ARM_CP_OFF_IMM_S2
;
8436 encode_arm_cp_address (1, TRUE
, FALSE
, reloc
);
8440 do_iwmmxt_wldstw (void)
8442 /* RIWR_RIWC clears .isreg for a control register. */
8443 if (!inst
.operands
[0].isreg
)
8445 constraint (inst
.cond
!= COND_ALWAYS
, BAD_COND
);
8446 inst
.instruction
|= 0xf0000000;
8449 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8450 encode_arm_cp_address (1, TRUE
, TRUE
, 0);
8454 do_iwmmxt_wldstd (void)
8456 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8457 if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_cext_iwmmxt2
)
8458 && inst
.operands
[1].immisreg
)
8460 inst
.instruction
&= ~0x1a000ff;
8461 inst
.instruction
|= (0xf << 28);
8462 if (inst
.operands
[1].preind
)
8463 inst
.instruction
|= PRE_INDEX
;
8464 if (!inst
.operands
[1].negative
)
8465 inst
.instruction
|= INDEX_UP
;
8466 if (inst
.operands
[1].writeback
)
8467 inst
.instruction
|= WRITE_BACK
;
8468 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
8469 inst
.instruction
|= inst
.reloc
.exp
.X_add_number
<< 4;
8470 inst
.instruction
|= inst
.operands
[1].imm
;
8473 encode_arm_cp_address (1, TRUE
, FALSE
, 0);
8477 do_iwmmxt_wshufh (void)
8479 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8480 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
8481 inst
.instruction
|= ((inst
.operands
[2].imm
& 0xf0) << 16);
8482 inst
.instruction
|= (inst
.operands
[2].imm
& 0x0f);
8486 do_iwmmxt_wzero (void)
8488 /* WZERO reg is an alias for WANDN reg, reg, reg. */
8489 inst
.instruction
|= inst
.operands
[0].reg
;
8490 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8491 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
8495 do_iwmmxt_wrwrwr_or_imm5 (void)
8497 if (inst
.operands
[2].isreg
)
8500 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, arm_cext_iwmmxt2
),
8501 _("immediate operand requires iWMMXt2"));
8503 if (inst
.operands
[2].imm
== 0)
8505 switch ((inst
.instruction
>> 20) & 0xf)
8511 /* w...h wrd, wrn, #0 -> wrorh wrd, wrn, #16. */
8512 inst
.operands
[2].imm
= 16;
8513 inst
.instruction
= (inst
.instruction
& 0xff0fffff) | (0x7 << 20);
8519 /* w...w wrd, wrn, #0 -> wrorw wrd, wrn, #32. */
8520 inst
.operands
[2].imm
= 32;
8521 inst
.instruction
= (inst
.instruction
& 0xff0fffff) | (0xb << 20);
8528 /* w...d wrd, wrn, #0 -> wor wrd, wrn, wrn. */
8530 wrn
= (inst
.instruction
>> 16) & 0xf;
8531 inst
.instruction
&= 0xff0fff0f;
8532 inst
.instruction
|= wrn
;
8533 /* Bail out here; the instruction is now assembled. */
8538 /* Map 32 -> 0, etc. */
8539 inst
.operands
[2].imm
&= 0x1f;
8540 inst
.instruction
|= (0xf << 28) | ((inst
.operands
[2].imm
& 0x10) << 4) | (inst
.operands
[2].imm
& 0xf);
8544 /* Cirrus Maverick instructions. Simple 2-, 3-, and 4-register
8545 operations first, then control, shift, and load/store. */
8547 /* Insns like "foo X,Y,Z". */
8550 do_mav_triple (void)
8552 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
8553 inst
.instruction
|= inst
.operands
[1].reg
;
8554 inst
.instruction
|= inst
.operands
[2].reg
<< 12;
8557 /* Insns like "foo W,X,Y,Z".
8558 where W=MVAX[0:3] and X,Y,Z=MVFX[0:15]. */
8563 inst
.instruction
|= inst
.operands
[0].reg
<< 5;
8564 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
8565 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
8566 inst
.instruction
|= inst
.operands
[3].reg
;
8569 /* cfmvsc32<cond> DSPSC,MVDX[15:0]. */
8573 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
8576 /* Maverick shift immediate instructions.
8577 cfsh32<cond> MVFX[15:0],MVFX[15:0],Shift[6:0].
8578 cfsh64<cond> MVDX[15:0],MVDX[15:0],Shift[6:0]. */
8583 int imm
= inst
.operands
[2].imm
;
8585 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8586 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
8588 /* Bits 0-3 of the insn should have bits 0-3 of the immediate.
8589 Bits 5-7 of the insn should have bits 4-6 of the immediate.
8590 Bit 4 should be 0. */
8591 imm
= (imm
& 0xf) | ((imm
& 0x70) << 1);
8593 inst
.instruction
|= imm
;
8596 /* XScale instructions. Also sorted arithmetic before move. */
8598 /* Xscale multiply-accumulate (argument parse)
8601 MIAxycc acc0,Rm,Rs. */
8606 inst
.instruction
|= inst
.operands
[1].reg
;
8607 inst
.instruction
|= inst
.operands
[2].reg
<< 12;
8610 /* Xscale move-accumulator-register (argument parse)
8612 MARcc acc0,RdLo,RdHi. */
8617 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
8618 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
8621 /* Xscale move-register-accumulator (argument parse)
8623 MRAcc RdLo,RdHi,acc0. */
8628 constraint (inst
.operands
[0].reg
== inst
.operands
[1].reg
, BAD_OVERLAP
);
8629 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
8630 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
8633 /* Encoding functions relevant only to Thumb. */
8635 /* inst.operands[i] is a shifted-register operand; encode
8636 it into inst.instruction in the format used by Thumb32. */
8639 encode_thumb32_shifted_operand (int i
)
8641 unsigned int value
= inst
.reloc
.exp
.X_add_number
;
8642 unsigned int shift
= inst
.operands
[i
].shift_kind
;
8644 constraint (inst
.operands
[i
].immisreg
,
8645 _("shift by register not allowed in thumb mode"));
8646 inst
.instruction
|= inst
.operands
[i
].reg
;
8647 if (shift
== SHIFT_RRX
)
8648 inst
.instruction
|= SHIFT_ROR
<< 4;
8651 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
8652 _("expression too complex"));
8654 constraint (value
> 32
8655 || (value
== 32 && (shift
== SHIFT_LSL
8656 || shift
== SHIFT_ROR
)),
8657 _("shift expression is too large"));
8661 else if (value
== 32)
8664 inst
.instruction
|= shift
<< 4;
8665 inst
.instruction
|= (value
& 0x1c) << 10;
8666 inst
.instruction
|= (value
& 0x03) << 6;
8671 /* inst.operands[i] was set up by parse_address. Encode it into a
8672 Thumb32 format load or store instruction. Reject forms that cannot
8673 be used with such instructions. If is_t is true, reject forms that
8674 cannot be used with a T instruction; if is_d is true, reject forms
8675 that cannot be used with a D instruction. */
8678 encode_thumb32_addr_mode (int i
, bfd_boolean is_t
, bfd_boolean is_d
)
8680 bfd_boolean is_pc
= (inst
.operands
[i
].reg
== REG_PC
);
8682 constraint (!inst
.operands
[i
].isreg
,
8683 _("Instruction does not support =N addresses"));
8685 inst
.instruction
|= inst
.operands
[i
].reg
<< 16;
8686 if (inst
.operands
[i
].immisreg
)
8688 constraint (is_pc
, _("cannot use register index with PC-relative addressing"));
8689 constraint (is_t
|| is_d
, _("cannot use register index with this instruction"));
8690 constraint (inst
.operands
[i
].negative
,
8691 _("Thumb does not support negative register indexing"));
8692 constraint (inst
.operands
[i
].postind
,
8693 _("Thumb does not support register post-indexing"));
8694 constraint (inst
.operands
[i
].writeback
,
8695 _("Thumb does not support register indexing with writeback"));
8696 constraint (inst
.operands
[i
].shifted
&& inst
.operands
[i
].shift_kind
!= SHIFT_LSL
,
8697 _("Thumb supports only LSL in shifted register indexing"));
8699 inst
.instruction
|= inst
.operands
[i
].imm
;
8700 if (inst
.operands
[i
].shifted
)
8702 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
8703 _("expression too complex"));
8704 constraint (inst
.reloc
.exp
.X_add_number
< 0
8705 || inst
.reloc
.exp
.X_add_number
> 3,
8706 _("shift out of range"));
8707 inst
.instruction
|= inst
.reloc
.exp
.X_add_number
<< 4;
8709 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
8711 else if (inst
.operands
[i
].preind
)
8713 constraint (is_pc
&& inst
.operands
[i
].writeback
,
8714 _("cannot use writeback with PC-relative addressing"));
8715 constraint (is_t
&& inst
.operands
[i
].writeback
,
8716 _("cannot use writeback with this instruction"));
8720 inst
.instruction
|= 0x01000000;
8721 if (inst
.operands
[i
].writeback
)
8722 inst
.instruction
|= 0x00200000;
8726 inst
.instruction
|= 0x00000c00;
8727 if (inst
.operands
[i
].writeback
)
8728 inst
.instruction
|= 0x00000100;
8730 inst
.reloc
.type
= BFD_RELOC_ARM_T32_OFFSET_IMM
;
8732 else if (inst
.operands
[i
].postind
)
8734 gas_assert (inst
.operands
[i
].writeback
);
8735 constraint (is_pc
, _("cannot use post-indexing with PC-relative addressing"));
8736 constraint (is_t
, _("cannot use post-indexing with this instruction"));
8739 inst
.instruction
|= 0x00200000;
8741 inst
.instruction
|= 0x00000900;
8742 inst
.reloc
.type
= BFD_RELOC_ARM_T32_OFFSET_IMM
;
8744 else /* unindexed - only for coprocessor */
8745 inst
.error
= _("instruction does not accept unindexed addressing");
8748 /* Table of Thumb instructions which exist in both 16- and 32-bit
8749 encodings (the latter only in post-V6T2 cores). The index is the
8750 value used in the insns table below. When there is more than one
8751 possible 16-bit encoding for the instruction, this table always
8753 Also contains several pseudo-instructions used during relaxation. */
8754 #define T16_32_TAB \
8755 X(_adc, 4140, eb400000), \
8756 X(_adcs, 4140, eb500000), \
8757 X(_add, 1c00, eb000000), \
8758 X(_adds, 1c00, eb100000), \
8759 X(_addi, 0000, f1000000), \
8760 X(_addis, 0000, f1100000), \
8761 X(_add_pc,000f, f20f0000), \
8762 X(_add_sp,000d, f10d0000), \
8763 X(_adr, 000f, f20f0000), \
8764 X(_and, 4000, ea000000), \
8765 X(_ands, 4000, ea100000), \
8766 X(_asr, 1000, fa40f000), \
8767 X(_asrs, 1000, fa50f000), \
8768 X(_b, e000, f000b000), \
8769 X(_bcond, d000, f0008000), \
8770 X(_bic, 4380, ea200000), \
8771 X(_bics, 4380, ea300000), \
8772 X(_cmn, 42c0, eb100f00), \
8773 X(_cmp, 2800, ebb00f00), \
8774 X(_cpsie, b660, f3af8400), \
8775 X(_cpsid, b670, f3af8600), \
8776 X(_cpy, 4600, ea4f0000), \
8777 X(_dec_sp,80dd, f1ad0d00), \
8778 X(_eor, 4040, ea800000), \
8779 X(_eors, 4040, ea900000), \
8780 X(_inc_sp,00dd, f10d0d00), \
8781 X(_ldmia, c800, e8900000), \
8782 X(_ldr, 6800, f8500000), \
8783 X(_ldrb, 7800, f8100000), \
8784 X(_ldrh, 8800, f8300000), \
8785 X(_ldrsb, 5600, f9100000), \
8786 X(_ldrsh, 5e00, f9300000), \
8787 X(_ldr_pc,4800, f85f0000), \
8788 X(_ldr_pc2,4800, f85f0000), \
8789 X(_ldr_sp,9800, f85d0000), \
8790 X(_lsl, 0000, fa00f000), \
8791 X(_lsls, 0000, fa10f000), \
8792 X(_lsr, 0800, fa20f000), \
8793 X(_lsrs, 0800, fa30f000), \
8794 X(_mov, 2000, ea4f0000), \
8795 X(_movs, 2000, ea5f0000), \
8796 X(_mul, 4340, fb00f000), \
8797 X(_muls, 4340, ffffffff), /* no 32b muls */ \
8798 X(_mvn, 43c0, ea6f0000), \
8799 X(_mvns, 43c0, ea7f0000), \
8800 X(_neg, 4240, f1c00000), /* rsb #0 */ \
8801 X(_negs, 4240, f1d00000), /* rsbs #0 */ \
8802 X(_orr, 4300, ea400000), \
8803 X(_orrs, 4300, ea500000), \
8804 X(_pop, bc00, e8bd0000), /* ldmia sp!,... */ \
8805 X(_push, b400, e92d0000), /* stmdb sp!,... */ \
8806 X(_rev, ba00, fa90f080), \
8807 X(_rev16, ba40, fa90f090), \
8808 X(_revsh, bac0, fa90f0b0), \
8809 X(_ror, 41c0, fa60f000), \
8810 X(_rors, 41c0, fa70f000), \
8811 X(_sbc, 4180, eb600000), \
8812 X(_sbcs, 4180, eb700000), \
8813 X(_stmia, c000, e8800000), \
8814 X(_str, 6000, f8400000), \
8815 X(_strb, 7000, f8000000), \
8816 X(_strh, 8000, f8200000), \
8817 X(_str_sp,9000, f84d0000), \
8818 X(_sub, 1e00, eba00000), \
8819 X(_subs, 1e00, ebb00000), \
8820 X(_subi, 8000, f1a00000), \
8821 X(_subis, 8000, f1b00000), \
8822 X(_sxtb, b240, fa4ff080), \
8823 X(_sxth, b200, fa0ff080), \
8824 X(_tst, 4200, ea100f00), \
8825 X(_uxtb, b2c0, fa5ff080), \
8826 X(_uxth, b280, fa1ff080), \
8827 X(_nop, bf00, f3af8000), \
8828 X(_yield, bf10, f3af8001), \
8829 X(_wfe, bf20, f3af8002), \
8830 X(_wfi, bf30, f3af8003), \
8831 X(_sev, bf40, f3af8004),
8833 /* To catch errors in encoding functions, the codes are all offset by
8834 0xF800, putting them in one of the 32-bit prefix ranges, ergo undefined
8835 as 16-bit instructions. */
8836 #define X(a,b,c) T_MNEM##a
8837 enum t16_32_codes
{ T16_32_OFFSET
= 0xF7FF, T16_32_TAB
};
8840 #define X(a,b,c) 0x##b
8841 static const unsigned short thumb_op16
[] = { T16_32_TAB
};
8842 #define THUMB_OP16(n) (thumb_op16[(n) - (T16_32_OFFSET + 1)])
8845 #define X(a,b,c) 0x##c
8846 static const unsigned int thumb_op32
[] = { T16_32_TAB
};
8847 #define THUMB_OP32(n) (thumb_op32[(n) - (T16_32_OFFSET + 1)])
8848 #define THUMB_SETS_FLAGS(n) (THUMB_OP32 (n) & 0x00100000)
8852 /* Thumb instruction encoders, in alphabetical order. */
8857 do_t_add_sub_w (void)
8861 Rd
= inst
.operands
[0].reg
;
8862 Rn
= inst
.operands
[1].reg
;
8864 /* If Rn is REG_PC, this is ADR; if Rn is REG_SP, then this
8865 is the SP-{plus,minus}-immediate form of the instruction. */
8867 constraint (Rd
== REG_PC
, BAD_PC
);
8869 reject_bad_reg (Rd
);
8871 inst
.instruction
|= (Rn
<< 16) | (Rd
<< 8);
8872 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMM12
;
8875 /* Parse an add or subtract instruction. We get here with inst.instruction
8876 equalling any of THUMB_OPCODE_add, adds, sub, or subs. */
8883 Rd
= inst
.operands
[0].reg
;
8884 Rs
= (inst
.operands
[1].present
8885 ? inst
.operands
[1].reg
/* Rd, Rs, foo */
8886 : inst
.operands
[0].reg
); /* Rd, foo -> Rd, Rd, foo */
8889 set_it_insn_type_last ();
8897 flags
= (inst
.instruction
== T_MNEM_adds
8898 || inst
.instruction
== T_MNEM_subs
);
8900 narrow
= !in_it_block ();
8902 narrow
= in_it_block ();
8903 if (!inst
.operands
[2].isreg
)
8907 constraint (Rd
== REG_SP
&& Rs
!= REG_SP
, BAD_SP
);
8909 add
= (inst
.instruction
== T_MNEM_add
8910 || inst
.instruction
== T_MNEM_adds
);
8912 if (inst
.size_req
!= 4)
8914 /* Attempt to use a narrow opcode, with relaxation if
8916 if (Rd
== REG_SP
&& Rs
== REG_SP
&& !flags
)
8917 opcode
= add
? T_MNEM_inc_sp
: T_MNEM_dec_sp
;
8918 else if (Rd
<= 7 && Rs
== REG_SP
&& add
&& !flags
)
8919 opcode
= T_MNEM_add_sp
;
8920 else if (Rd
<= 7 && Rs
== REG_PC
&& add
&& !flags
)
8921 opcode
= T_MNEM_add_pc
;
8922 else if (Rd
<= 7 && Rs
<= 7 && narrow
)
8925 opcode
= add
? T_MNEM_addis
: T_MNEM_subis
;
8927 opcode
= add
? T_MNEM_addi
: T_MNEM_subi
;
8931 inst
.instruction
= THUMB_OP16(opcode
);
8932 inst
.instruction
|= (Rd
<< 4) | Rs
;
8933 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_ADD
;
8934 if (inst
.size_req
!= 2)
8935 inst
.relax
= opcode
;
8938 constraint (inst
.size_req
== 2, BAD_HIREG
);
8940 if (inst
.size_req
== 4
8941 || (inst
.size_req
!= 2 && !opcode
))
8945 constraint (add
, BAD_PC
);
8946 constraint (Rs
!= REG_LR
|| inst
.instruction
!= T_MNEM_subs
,
8947 _("only SUBS PC, LR, #const allowed"));
8948 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
8949 _("expression too complex"));
8950 constraint (inst
.reloc
.exp
.X_add_number
< 0
8951 || inst
.reloc
.exp
.X_add_number
> 0xff,
8952 _("immediate value out of range"));
8953 inst
.instruction
= T2_SUBS_PC_LR
8954 | inst
.reloc
.exp
.X_add_number
;
8955 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
8958 else if (Rs
== REG_PC
)
8960 /* Always use addw/subw. */
8961 inst
.instruction
= add
? 0xf20f0000 : 0xf2af0000;
8962 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMM12
;
8966 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
8967 inst
.instruction
= (inst
.instruction
& 0xe1ffffff)
8970 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
8972 inst
.reloc
.type
= BFD_RELOC_ARM_T32_ADD_IMM
;
8974 inst
.instruction
|= Rd
<< 8;
8975 inst
.instruction
|= Rs
<< 16;
8980 Rn
= inst
.operands
[2].reg
;
8981 /* See if we can do this with a 16-bit instruction. */
8982 if (!inst
.operands
[2].shifted
&& inst
.size_req
!= 4)
8984 if (Rd
> 7 || Rs
> 7 || Rn
> 7)
8989 inst
.instruction
= ((inst
.instruction
== T_MNEM_adds
8990 || inst
.instruction
== T_MNEM_add
)
8993 inst
.instruction
|= Rd
| (Rs
<< 3) | (Rn
<< 6);
8997 if (inst
.instruction
== T_MNEM_add
&& (Rd
== Rs
|| Rd
== Rn
))
8999 /* Thumb-1 cores (except v6-M) require at least one high
9000 register in a narrow non flag setting add. */
9001 if (Rd
> 7 || Rn
> 7
9002 || ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v6t2
)
9003 || ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_msr
))
9010 inst
.instruction
= T_OPCODE_ADD_HI
;
9011 inst
.instruction
|= (Rd
& 8) << 4;
9012 inst
.instruction
|= (Rd
& 7);
9013 inst
.instruction
|= Rn
<< 3;
9019 constraint (Rd
== REG_PC
, BAD_PC
);
9020 constraint (Rd
== REG_SP
&& Rs
!= REG_SP
, BAD_SP
);
9021 constraint (Rs
== REG_PC
, BAD_PC
);
9022 reject_bad_reg (Rn
);
9024 /* If we get here, it can't be done in 16 bits. */
9025 constraint (inst
.operands
[2].shifted
&& inst
.operands
[2].immisreg
,
9026 _("shift must be constant"));
9027 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
9028 inst
.instruction
|= Rd
<< 8;
9029 inst
.instruction
|= Rs
<< 16;
9030 encode_thumb32_shifted_operand (2);
9035 constraint (inst
.instruction
== T_MNEM_adds
9036 || inst
.instruction
== T_MNEM_subs
,
9039 if (!inst
.operands
[2].isreg
) /* Rd, Rs, #imm */
9041 constraint ((Rd
> 7 && (Rd
!= REG_SP
|| Rs
!= REG_SP
))
9042 || (Rs
> 7 && Rs
!= REG_SP
&& Rs
!= REG_PC
),
9045 inst
.instruction
= (inst
.instruction
== T_MNEM_add
9047 inst
.instruction
|= (Rd
<< 4) | Rs
;
9048 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_ADD
;
9052 Rn
= inst
.operands
[2].reg
;
9053 constraint (inst
.operands
[2].shifted
, _("unshifted register required"));
9055 /* We now have Rd, Rs, and Rn set to registers. */
9056 if (Rd
> 7 || Rs
> 7 || Rn
> 7)
9058 /* Can't do this for SUB. */
9059 constraint (inst
.instruction
== T_MNEM_sub
, BAD_HIREG
);
9060 inst
.instruction
= T_OPCODE_ADD_HI
;
9061 inst
.instruction
|= (Rd
& 8) << 4;
9062 inst
.instruction
|= (Rd
& 7);
9064 inst
.instruction
|= Rn
<< 3;
9066 inst
.instruction
|= Rs
<< 3;
9068 constraint (1, _("dest must overlap one source register"));
9072 inst
.instruction
= (inst
.instruction
== T_MNEM_add
9073 ? T_OPCODE_ADD_R3
: T_OPCODE_SUB_R3
);
9074 inst
.instruction
|= Rd
| (Rs
<< 3) | (Rn
<< 6);
9084 Rd
= inst
.operands
[0].reg
;
9085 reject_bad_reg (Rd
);
9087 if (unified_syntax
&& inst
.size_req
== 0 && Rd
<= 7)
9089 /* Defer to section relaxation. */
9090 inst
.relax
= inst
.instruction
;
9091 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9092 inst
.instruction
|= Rd
<< 4;
9094 else if (unified_syntax
&& inst
.size_req
!= 2)
9096 /* Generate a 32-bit opcode. */
9097 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
9098 inst
.instruction
|= Rd
<< 8;
9099 inst
.reloc
.type
= BFD_RELOC_ARM_T32_ADD_PC12
;
9100 inst
.reloc
.pc_rel
= 1;
9104 /* Generate a 16-bit opcode. */
9105 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9106 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_ADD
;
9107 inst
.reloc
.exp
.X_add_number
-= 4; /* PC relative adjust. */
9108 inst
.reloc
.pc_rel
= 1;
9110 inst
.instruction
|= Rd
<< 4;
9114 /* Arithmetic instructions for which there is just one 16-bit
9115 instruction encoding, and it allows only two low registers.
9116 For maximal compatibility with ARM syntax, we allow three register
9117 operands even when Thumb-32 instructions are not available, as long
9118 as the first two are identical. For instance, both "sbc r0,r1" and
9119 "sbc r0,r0,r1" are allowed. */
9125 Rd
= inst
.operands
[0].reg
;
9126 Rs
= (inst
.operands
[1].present
9127 ? inst
.operands
[1].reg
/* Rd, Rs, foo */
9128 : inst
.operands
[0].reg
); /* Rd, foo -> Rd, Rd, foo */
9129 Rn
= inst
.operands
[2].reg
;
9131 reject_bad_reg (Rd
);
9132 reject_bad_reg (Rs
);
9133 if (inst
.operands
[2].isreg
)
9134 reject_bad_reg (Rn
);
9138 if (!inst
.operands
[2].isreg
)
9140 /* For an immediate, we always generate a 32-bit opcode;
9141 section relaxation will shrink it later if possible. */
9142 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
9143 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
9144 inst
.instruction
|= Rd
<< 8;
9145 inst
.instruction
|= Rs
<< 16;
9146 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
9152 /* See if we can do this with a 16-bit instruction. */
9153 if (THUMB_SETS_FLAGS (inst
.instruction
))
9154 narrow
= !in_it_block ();
9156 narrow
= in_it_block ();
9158 if (Rd
> 7 || Rn
> 7 || Rs
> 7)
9160 if (inst
.operands
[2].shifted
)
9162 if (inst
.size_req
== 4)
9168 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9169 inst
.instruction
|= Rd
;
9170 inst
.instruction
|= Rn
<< 3;
9174 /* If we get here, it can't be done in 16 bits. */
9175 constraint (inst
.operands
[2].shifted
9176 && inst
.operands
[2].immisreg
,
9177 _("shift must be constant"));
9178 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
9179 inst
.instruction
|= Rd
<< 8;
9180 inst
.instruction
|= Rs
<< 16;
9181 encode_thumb32_shifted_operand (2);
9186 /* On its face this is a lie - the instruction does set the
9187 flags. However, the only supported mnemonic in this mode
9189 constraint (THUMB_SETS_FLAGS (inst
.instruction
), BAD_THUMB32
);
9191 constraint (!inst
.operands
[2].isreg
|| inst
.operands
[2].shifted
,
9192 _("unshifted register required"));
9193 constraint (Rd
> 7 || Rs
> 7 || Rn
> 7, BAD_HIREG
);
9194 constraint (Rd
!= Rs
,
9195 _("dest and source1 must be the same register"));
9197 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9198 inst
.instruction
|= Rd
;
9199 inst
.instruction
|= Rn
<< 3;
9203 /* Similarly, but for instructions where the arithmetic operation is
9204 commutative, so we can allow either of them to be different from
9205 the destination operand in a 16-bit instruction. For instance, all
9206 three of "adc r0,r1", "adc r0,r0,r1", and "adc r0,r1,r0" are
9213 Rd
= inst
.operands
[0].reg
;
9214 Rs
= (inst
.operands
[1].present
9215 ? inst
.operands
[1].reg
/* Rd, Rs, foo */
9216 : inst
.operands
[0].reg
); /* Rd, foo -> Rd, Rd, foo */
9217 Rn
= inst
.operands
[2].reg
;
9219 reject_bad_reg (Rd
);
9220 reject_bad_reg (Rs
);
9221 if (inst
.operands
[2].isreg
)
9222 reject_bad_reg (Rn
);
9226 if (!inst
.operands
[2].isreg
)
9228 /* For an immediate, we always generate a 32-bit opcode;
9229 section relaxation will shrink it later if possible. */
9230 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
9231 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
9232 inst
.instruction
|= Rd
<< 8;
9233 inst
.instruction
|= Rs
<< 16;
9234 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
9240 /* See if we can do this with a 16-bit instruction. */
9241 if (THUMB_SETS_FLAGS (inst
.instruction
))
9242 narrow
= !in_it_block ();
9244 narrow
= in_it_block ();
9246 if (Rd
> 7 || Rn
> 7 || Rs
> 7)
9248 if (inst
.operands
[2].shifted
)
9250 if (inst
.size_req
== 4)
9257 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9258 inst
.instruction
|= Rd
;
9259 inst
.instruction
|= Rn
<< 3;
9264 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9265 inst
.instruction
|= Rd
;
9266 inst
.instruction
|= Rs
<< 3;
9271 /* If we get here, it can't be done in 16 bits. */
9272 constraint (inst
.operands
[2].shifted
9273 && inst
.operands
[2].immisreg
,
9274 _("shift must be constant"));
9275 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
9276 inst
.instruction
|= Rd
<< 8;
9277 inst
.instruction
|= Rs
<< 16;
9278 encode_thumb32_shifted_operand (2);
9283 /* On its face this is a lie - the instruction does set the
9284 flags. However, the only supported mnemonic in this mode
9286 constraint (THUMB_SETS_FLAGS (inst
.instruction
), BAD_THUMB32
);
9288 constraint (!inst
.operands
[2].isreg
|| inst
.operands
[2].shifted
,
9289 _("unshifted register required"));
9290 constraint (Rd
> 7 || Rs
> 7 || Rn
> 7, BAD_HIREG
);
9292 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9293 inst
.instruction
|= Rd
;
9296 inst
.instruction
|= Rn
<< 3;
9298 inst
.instruction
|= Rs
<< 3;
9300 constraint (1, _("dest must overlap one source register"));
9307 if (inst
.operands
[0].present
)
9309 constraint ((inst
.instruction
& 0xf0) != 0x40
9310 && inst
.operands
[0].imm
!= 0xf,
9311 _("bad barrier type"));
9312 inst
.instruction
|= inst
.operands
[0].imm
;
9315 inst
.instruction
|= 0xf;
9322 unsigned int msb
= inst
.operands
[1].imm
+ inst
.operands
[2].imm
;
9323 constraint (msb
> 32, _("bit-field extends past end of register"));
9324 /* The instruction encoding stores the LSB and MSB,
9325 not the LSB and width. */
9326 Rd
= inst
.operands
[0].reg
;
9327 reject_bad_reg (Rd
);
9328 inst
.instruction
|= Rd
<< 8;
9329 inst
.instruction
|= (inst
.operands
[1].imm
& 0x1c) << 10;
9330 inst
.instruction
|= (inst
.operands
[1].imm
& 0x03) << 6;
9331 inst
.instruction
|= msb
- 1;
9340 Rd
= inst
.operands
[0].reg
;
9341 reject_bad_reg (Rd
);
9343 /* #0 in second position is alternative syntax for bfc, which is
9344 the same instruction but with REG_PC in the Rm field. */
9345 if (!inst
.operands
[1].isreg
)
9349 Rn
= inst
.operands
[1].reg
;
9350 reject_bad_reg (Rn
);
9353 msb
= inst
.operands
[2].imm
+ inst
.operands
[3].imm
;
9354 constraint (msb
> 32, _("bit-field extends past end of register"));
9355 /* The instruction encoding stores the LSB and MSB,
9356 not the LSB and width. */
9357 inst
.instruction
|= Rd
<< 8;
9358 inst
.instruction
|= Rn
<< 16;
9359 inst
.instruction
|= (inst
.operands
[2].imm
& 0x1c) << 10;
9360 inst
.instruction
|= (inst
.operands
[2].imm
& 0x03) << 6;
9361 inst
.instruction
|= msb
- 1;
9369 Rd
= inst
.operands
[0].reg
;
9370 Rn
= inst
.operands
[1].reg
;
9372 reject_bad_reg (Rd
);
9373 reject_bad_reg (Rn
);
9375 constraint (inst
.operands
[2].imm
+ inst
.operands
[3].imm
> 32,
9376 _("bit-field extends past end of register"));
9377 inst
.instruction
|= Rd
<< 8;
9378 inst
.instruction
|= Rn
<< 16;
9379 inst
.instruction
|= (inst
.operands
[2].imm
& 0x1c) << 10;
9380 inst
.instruction
|= (inst
.operands
[2].imm
& 0x03) << 6;
9381 inst
.instruction
|= inst
.operands
[3].imm
- 1;
9384 /* ARM V5 Thumb BLX (argument parse)
9385 BLX <target_addr> which is BLX(1)
9386 BLX <Rm> which is BLX(2)
9387 Unfortunately, there are two different opcodes for this mnemonic.
9388 So, the insns[].value is not used, and the code here zaps values
9389 into inst.instruction.
9391 ??? How to take advantage of the additional two bits of displacement
9392 available in Thumb32 mode? Need new relocation? */
9397 set_it_insn_type_last ();
9399 if (inst
.operands
[0].isreg
)
9401 constraint (inst
.operands
[0].reg
== REG_PC
, BAD_PC
);
9402 /* We have a register, so this is BLX(2). */
9403 inst
.instruction
|= inst
.operands
[0].reg
<< 3;
9407 /* No register. This must be BLX(1). */
9408 inst
.instruction
= 0xf000e800;
9409 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BLX
;
9410 inst
.reloc
.pc_rel
= 1;
9421 set_it_insn_type (IF_INSIDE_IT_LAST_INSN
);
9425 /* Conditional branches inside IT blocks are encoded as unconditional
9432 if (cond
!= COND_ALWAYS
)
9433 opcode
= T_MNEM_bcond
;
9435 opcode
= inst
.instruction
;
9437 if (unified_syntax
&& inst
.size_req
== 4)
9439 inst
.instruction
= THUMB_OP32(opcode
);
9440 if (cond
== COND_ALWAYS
)
9441 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH25
;
9444 gas_assert (cond
!= 0xF);
9445 inst
.instruction
|= cond
<< 22;
9446 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH20
;
9451 inst
.instruction
= THUMB_OP16(opcode
);
9452 if (cond
== COND_ALWAYS
)
9453 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH12
;
9456 inst
.instruction
|= cond
<< 8;
9457 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH9
;
9459 /* Allow section relaxation. */
9460 if (unified_syntax
&& inst
.size_req
!= 2)
9461 inst
.relax
= opcode
;
9464 inst
.reloc
.pc_rel
= 1;
9470 constraint (inst
.cond
!= COND_ALWAYS
,
9471 _("instruction is always unconditional"));
9472 if (inst
.operands
[0].present
)
9474 constraint (inst
.operands
[0].imm
> 255,
9475 _("immediate value out of range"));
9476 inst
.instruction
|= inst
.operands
[0].imm
;
9477 set_it_insn_type (NEUTRAL_IT_INSN
);
9482 do_t_branch23 (void)
9484 set_it_insn_type_last ();
9485 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH23
;
9486 inst
.reloc
.pc_rel
= 1;
9488 #if defined(OBJ_COFF)
9489 /* If the destination of the branch is a defined symbol which does not have
9490 the THUMB_FUNC attribute, then we must be calling a function which has
9491 the (interfacearm) attribute. We look for the Thumb entry point to that
9492 function and change the branch to refer to that function instead. */
9493 if ( inst
.reloc
.exp
.X_op
== O_symbol
9494 && inst
.reloc
.exp
.X_add_symbol
!= NULL
9495 && S_IS_DEFINED (inst
.reloc
.exp
.X_add_symbol
)
9496 && ! THUMB_IS_FUNC (inst
.reloc
.exp
.X_add_symbol
))
9497 inst
.reloc
.exp
.X_add_symbol
=
9498 find_real_start (inst
.reloc
.exp
.X_add_symbol
);
9505 set_it_insn_type_last ();
9506 inst
.instruction
|= inst
.operands
[0].reg
<< 3;
9507 /* ??? FIXME: Should add a hacky reloc here if reg is REG_PC. The reloc
9508 should cause the alignment to be checked once it is known. This is
9509 because BX PC only works if the instruction is word aligned. */
9517 set_it_insn_type_last ();
9518 Rm
= inst
.operands
[0].reg
;
9519 reject_bad_reg (Rm
);
9520 inst
.instruction
|= Rm
<< 16;
9529 Rd
= inst
.operands
[0].reg
;
9530 Rm
= inst
.operands
[1].reg
;
9532 reject_bad_reg (Rd
);
9533 reject_bad_reg (Rm
);
9535 inst
.instruction
|= Rd
<< 8;
9536 inst
.instruction
|= Rm
<< 16;
9537 inst
.instruction
|= Rm
;
9543 set_it_insn_type (OUTSIDE_IT_INSN
);
9544 inst
.instruction
|= inst
.operands
[0].imm
;
9550 set_it_insn_type (OUTSIDE_IT_INSN
);
9552 && (inst
.operands
[1].present
|| inst
.size_req
== 4)
9553 && ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v6_notm
))
9555 unsigned int imod
= (inst
.instruction
& 0x0030) >> 4;
9556 inst
.instruction
= 0xf3af8000;
9557 inst
.instruction
|= imod
<< 9;
9558 inst
.instruction
|= inst
.operands
[0].imm
<< 5;
9559 if (inst
.operands
[1].present
)
9560 inst
.instruction
|= 0x100 | inst
.operands
[1].imm
;
9564 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v1
)
9565 && (inst
.operands
[0].imm
& 4),
9566 _("selected processor does not support 'A' form "
9567 "of this instruction"));
9568 constraint (inst
.operands
[1].present
|| inst
.size_req
== 4,
9569 _("Thumb does not support the 2-argument "
9570 "form of this instruction"));
9571 inst
.instruction
|= inst
.operands
[0].imm
;
9575 /* THUMB CPY instruction (argument parse). */
9580 if (inst
.size_req
== 4)
9582 inst
.instruction
= THUMB_OP32 (T_MNEM_mov
);
9583 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
9584 inst
.instruction
|= inst
.operands
[1].reg
;
9588 inst
.instruction
|= (inst
.operands
[0].reg
& 0x8) << 4;
9589 inst
.instruction
|= (inst
.operands
[0].reg
& 0x7);
9590 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
9597 set_it_insn_type (OUTSIDE_IT_INSN
);
9598 constraint (inst
.operands
[0].reg
> 7, BAD_HIREG
);
9599 inst
.instruction
|= inst
.operands
[0].reg
;
9600 inst
.reloc
.pc_rel
= 1;
9601 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH7
;
9607 inst
.instruction
|= inst
.operands
[0].imm
;
9613 unsigned Rd
, Rn
, Rm
;
9615 Rd
= inst
.operands
[0].reg
;
9616 Rn
= (inst
.operands
[1].present
9617 ? inst
.operands
[1].reg
: Rd
);
9618 Rm
= inst
.operands
[2].reg
;
9620 reject_bad_reg (Rd
);
9621 reject_bad_reg (Rn
);
9622 reject_bad_reg (Rm
);
9624 inst
.instruction
|= Rd
<< 8;
9625 inst
.instruction
|= Rn
<< 16;
9626 inst
.instruction
|= Rm
;
9632 if (unified_syntax
&& inst
.size_req
== 4)
9633 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
9635 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9641 unsigned int cond
= inst
.operands
[0].imm
;
9643 set_it_insn_type (IT_INSN
);
9644 now_it
.mask
= (inst
.instruction
& 0xf) | 0x10;
9647 /* If the condition is a negative condition, invert the mask. */
9648 if ((cond
& 0x1) == 0x0)
9650 unsigned int mask
= inst
.instruction
& 0x000f;
9652 if ((mask
& 0x7) == 0)
9653 /* no conversion needed */;
9654 else if ((mask
& 0x3) == 0)
9656 else if ((mask
& 0x1) == 0)
9661 inst
.instruction
&= 0xfff0;
9662 inst
.instruction
|= mask
;
9665 inst
.instruction
|= cond
<< 4;
9668 /* Helper function used for both push/pop and ldm/stm. */
9670 encode_thumb2_ldmstm (int base
, unsigned mask
, bfd_boolean writeback
)
9674 load
= (inst
.instruction
& (1 << 20)) != 0;
9676 if (mask
& (1 << 13))
9677 inst
.error
= _("SP not allowed in register list");
9680 if (mask
& (1 << 15))
9682 if (mask
& (1 << 14))
9683 inst
.error
= _("LR and PC should not both be in register list");
9685 set_it_insn_type_last ();
9688 if ((mask
& (1 << base
)) != 0
9690 as_warn (_("base register should not be in register list "
9691 "when written back"));
9695 if (mask
& (1 << 15))
9696 inst
.error
= _("PC not allowed in register list");
9698 if (mask
& (1 << base
))
9699 as_warn (_("value stored for r%d is UNPREDICTABLE"), base
);
9702 if ((mask
& (mask
- 1)) == 0)
9704 /* Single register transfers implemented as str/ldr. */
9707 if (inst
.instruction
& (1 << 23))
9708 inst
.instruction
= 0x00000b04; /* ia! -> [base], #4 */
9710 inst
.instruction
= 0x00000d04; /* db! -> [base, #-4]! */
9714 if (inst
.instruction
& (1 << 23))
9715 inst
.instruction
= 0x00800000; /* ia -> [base] */
9717 inst
.instruction
= 0x00000c04; /* db -> [base, #-4] */
9720 inst
.instruction
|= 0xf8400000;
9722 inst
.instruction
|= 0x00100000;
9724 mask
= ffs (mask
) - 1;
9728 inst
.instruction
|= WRITE_BACK
;
9730 inst
.instruction
|= mask
;
9731 inst
.instruction
|= base
<< 16;
9737 /* This really doesn't seem worth it. */
9738 constraint (inst
.reloc
.type
!= BFD_RELOC_UNUSED
,
9739 _("expression too complex"));
9740 constraint (inst
.operands
[1].writeback
,
9741 _("Thumb load/store multiple does not support {reglist}^"));
9749 /* See if we can use a 16-bit instruction. */
9750 if (inst
.instruction
< 0xffff /* not ldmdb/stmdb */
9751 && inst
.size_req
!= 4
9752 && !(inst
.operands
[1].imm
& ~0xff))
9754 mask
= 1 << inst
.operands
[0].reg
;
9756 if (inst
.operands
[0].reg
<= 7
9757 && (inst
.instruction
== T_MNEM_stmia
9758 ? inst
.operands
[0].writeback
9759 : (inst
.operands
[0].writeback
9760 == !(inst
.operands
[1].imm
& mask
))))
9762 if (inst
.instruction
== T_MNEM_stmia
9763 && (inst
.operands
[1].imm
& mask
)
9764 && (inst
.operands
[1].imm
& (mask
- 1)))
9765 as_warn (_("value stored for r%d is UNPREDICTABLE"),
9766 inst
.operands
[0].reg
);
9768 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9769 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
9770 inst
.instruction
|= inst
.operands
[1].imm
;
9773 else if (inst
.operands
[0] .reg
== REG_SP
9774 && inst
.operands
[0].writeback
)
9776 inst
.instruction
= THUMB_OP16 (inst
.instruction
== T_MNEM_stmia
9777 ? T_MNEM_push
: T_MNEM_pop
);
9778 inst
.instruction
|= inst
.operands
[1].imm
;
9785 if (inst
.instruction
< 0xffff)
9786 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
9788 encode_thumb2_ldmstm (inst
.operands
[0].reg
, inst
.operands
[1].imm
,
9789 inst
.operands
[0].writeback
);
9794 constraint (inst
.operands
[0].reg
> 7
9795 || (inst
.operands
[1].imm
& ~0xff), BAD_HIREG
);
9796 constraint (inst
.instruction
!= T_MNEM_ldmia
9797 && inst
.instruction
!= T_MNEM_stmia
,
9798 _("Thumb-2 instruction only valid in unified syntax"));
9799 if (inst
.instruction
== T_MNEM_stmia
)
9801 if (!inst
.operands
[0].writeback
)
9802 as_warn (_("this instruction will write back the base register"));
9803 if ((inst
.operands
[1].imm
& (1 << inst
.operands
[0].reg
))
9804 && (inst
.operands
[1].imm
& ((1 << inst
.operands
[0].reg
) - 1)))
9805 as_warn (_("value stored for r%d is UNPREDICTABLE"),
9806 inst
.operands
[0].reg
);
9810 if (!inst
.operands
[0].writeback
9811 && !(inst
.operands
[1].imm
& (1 << inst
.operands
[0].reg
)))
9812 as_warn (_("this instruction will write back the base register"));
9813 else if (inst
.operands
[0].writeback
9814 && (inst
.operands
[1].imm
& (1 << inst
.operands
[0].reg
)))
9815 as_warn (_("this instruction will not write back the base register"));
9818 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9819 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
9820 inst
.instruction
|= inst
.operands
[1].imm
;
9827 constraint (!inst
.operands
[1].isreg
|| !inst
.operands
[1].preind
9828 || inst
.operands
[1].postind
|| inst
.operands
[1].writeback
9829 || inst
.operands
[1].immisreg
|| inst
.operands
[1].shifted
9830 || inst
.operands
[1].negative
,
9833 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
9834 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
9835 inst
.reloc
.type
= BFD_RELOC_ARM_T32_OFFSET_U8
;
9841 if (!inst
.operands
[1].present
)
9843 constraint (inst
.operands
[0].reg
== REG_LR
,
9844 _("r14 not allowed as first register "
9845 "when second register is omitted"));
9846 inst
.operands
[1].reg
= inst
.operands
[0].reg
+ 1;
9848 constraint (inst
.operands
[0].reg
== inst
.operands
[1].reg
,
9851 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
9852 inst
.instruction
|= inst
.operands
[1].reg
<< 8;
9853 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
9859 unsigned long opcode
;
9862 if (inst
.operands
[0].isreg
9863 && !inst
.operands
[0].preind
9864 && inst
.operands
[0].reg
== REG_PC
)
9865 set_it_insn_type_last ();
9867 opcode
= inst
.instruction
;
9870 if (!inst
.operands
[1].isreg
)
9872 if (opcode
<= 0xffff)
9873 inst
.instruction
= THUMB_OP32 (opcode
);
9874 if (move_or_literal_pool (0, /*thumb_p=*/TRUE
, /*mode_3=*/FALSE
))
9877 if (inst
.operands
[1].isreg
9878 && !inst
.operands
[1].writeback
9879 && !inst
.operands
[1].shifted
&& !inst
.operands
[1].postind
9880 && !inst
.operands
[1].negative
&& inst
.operands
[0].reg
<= 7
9882 && inst
.size_req
!= 4)
9884 /* Insn may have a 16-bit form. */
9885 Rn
= inst
.operands
[1].reg
;
9886 if (inst
.operands
[1].immisreg
)
9888 inst
.instruction
= THUMB_OP16 (opcode
);
9890 if (Rn
<= 7 && inst
.operands
[1].imm
<= 7)
9893 else if ((Rn
<= 7 && opcode
!= T_MNEM_ldrsh
9894 && opcode
!= T_MNEM_ldrsb
)
9895 || ((Rn
== REG_PC
|| Rn
== REG_SP
) && opcode
== T_MNEM_ldr
)
9896 || (Rn
== REG_SP
&& opcode
== T_MNEM_str
))
9903 if (inst
.reloc
.pc_rel
)
9904 opcode
= T_MNEM_ldr_pc2
;
9906 opcode
= T_MNEM_ldr_pc
;
9910 if (opcode
== T_MNEM_ldr
)
9911 opcode
= T_MNEM_ldr_sp
;
9913 opcode
= T_MNEM_str_sp
;
9915 inst
.instruction
= inst
.operands
[0].reg
<< 8;
9919 inst
.instruction
= inst
.operands
[0].reg
;
9920 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
9922 inst
.instruction
|= THUMB_OP16 (opcode
);
9923 if (inst
.size_req
== 2)
9924 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_OFFSET
;
9926 inst
.relax
= opcode
;
9930 /* Definitely a 32-bit variant. */
9931 inst
.instruction
= THUMB_OP32 (opcode
);
9932 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
9933 encode_thumb32_addr_mode (1, /*is_t=*/FALSE
, /*is_d=*/FALSE
);
9937 constraint (inst
.operands
[0].reg
> 7, BAD_HIREG
);
9939 if (inst
.instruction
== T_MNEM_ldrsh
|| inst
.instruction
== T_MNEM_ldrsb
)
9941 /* Only [Rn,Rm] is acceptable. */
9942 constraint (inst
.operands
[1].reg
> 7 || inst
.operands
[1].imm
> 7, BAD_HIREG
);
9943 constraint (!inst
.operands
[1].isreg
|| !inst
.operands
[1].immisreg
9944 || inst
.operands
[1].postind
|| inst
.operands
[1].shifted
9945 || inst
.operands
[1].negative
,
9946 _("Thumb does not support this addressing mode"));
9947 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9951 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
9952 if (!inst
.operands
[1].isreg
)
9953 if (move_or_literal_pool (0, /*thumb_p=*/TRUE
, /*mode_3=*/FALSE
))
9956 constraint (!inst
.operands
[1].preind
9957 || inst
.operands
[1].shifted
9958 || inst
.operands
[1].writeback
,
9959 _("Thumb does not support this addressing mode"));
9960 if (inst
.operands
[1].reg
== REG_PC
|| inst
.operands
[1].reg
== REG_SP
)
9962 constraint (inst
.instruction
& 0x0600,
9963 _("byte or halfword not valid for base register"));
9964 constraint (inst
.operands
[1].reg
== REG_PC
9965 && !(inst
.instruction
& THUMB_LOAD_BIT
),
9966 _("r15 based store not allowed"));
9967 constraint (inst
.operands
[1].immisreg
,
9968 _("invalid base register for register offset"));
9970 if (inst
.operands
[1].reg
== REG_PC
)
9971 inst
.instruction
= T_OPCODE_LDR_PC
;
9972 else if (inst
.instruction
& THUMB_LOAD_BIT
)
9973 inst
.instruction
= T_OPCODE_LDR_SP
;
9975 inst
.instruction
= T_OPCODE_STR_SP
;
9977 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
9978 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_OFFSET
;
9982 constraint (inst
.operands
[1].reg
> 7, BAD_HIREG
);
9983 if (!inst
.operands
[1].immisreg
)
9985 /* Immediate offset. */
9986 inst
.instruction
|= inst
.operands
[0].reg
;
9987 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
9988 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_OFFSET
;
9992 /* Register offset. */
9993 constraint (inst
.operands
[1].imm
> 7, BAD_HIREG
);
9994 constraint (inst
.operands
[1].negative
,
9995 _("Thumb does not support this addressing mode"));
9998 switch (inst
.instruction
)
10000 case T_OPCODE_STR_IW
: inst
.instruction
= T_OPCODE_STR_RW
; break;
10001 case T_OPCODE_STR_IH
: inst
.instruction
= T_OPCODE_STR_RH
; break;
10002 case T_OPCODE_STR_IB
: inst
.instruction
= T_OPCODE_STR_RB
; break;
10003 case T_OPCODE_LDR_IW
: inst
.instruction
= T_OPCODE_LDR_RW
; break;
10004 case T_OPCODE_LDR_IH
: inst
.instruction
= T_OPCODE_LDR_RH
; break;
10005 case T_OPCODE_LDR_IB
: inst
.instruction
= T_OPCODE_LDR_RB
; break;
10006 case 0x5600 /* ldrsb */:
10007 case 0x5e00 /* ldrsh */: break;
10011 inst
.instruction
|= inst
.operands
[0].reg
;
10012 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
10013 inst
.instruction
|= inst
.operands
[1].imm
<< 6;
10019 if (!inst
.operands
[1].present
)
10021 inst
.operands
[1].reg
= inst
.operands
[0].reg
+ 1;
10022 constraint (inst
.operands
[0].reg
== REG_LR
,
10023 _("r14 not allowed here"));
10025 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
10026 inst
.instruction
|= inst
.operands
[1].reg
<< 8;
10027 encode_thumb32_addr_mode (2, /*is_t=*/FALSE
, /*is_d=*/TRUE
);
10033 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
10034 encode_thumb32_addr_mode (1, /*is_t=*/TRUE
, /*is_d=*/FALSE
);
10040 unsigned Rd
, Rn
, Rm
, Ra
;
10042 Rd
= inst
.operands
[0].reg
;
10043 Rn
= inst
.operands
[1].reg
;
10044 Rm
= inst
.operands
[2].reg
;
10045 Ra
= inst
.operands
[3].reg
;
10047 reject_bad_reg (Rd
);
10048 reject_bad_reg (Rn
);
10049 reject_bad_reg (Rm
);
10050 reject_bad_reg (Ra
);
10052 inst
.instruction
|= Rd
<< 8;
10053 inst
.instruction
|= Rn
<< 16;
10054 inst
.instruction
|= Rm
;
10055 inst
.instruction
|= Ra
<< 12;
10061 unsigned RdLo
, RdHi
, Rn
, Rm
;
10063 RdLo
= inst
.operands
[0].reg
;
10064 RdHi
= inst
.operands
[1].reg
;
10065 Rn
= inst
.operands
[2].reg
;
10066 Rm
= inst
.operands
[3].reg
;
10068 reject_bad_reg (RdLo
);
10069 reject_bad_reg (RdHi
);
10070 reject_bad_reg (Rn
);
10071 reject_bad_reg (Rm
);
10073 inst
.instruction
|= RdLo
<< 12;
10074 inst
.instruction
|= RdHi
<< 8;
10075 inst
.instruction
|= Rn
<< 16;
10076 inst
.instruction
|= Rm
;
10080 do_t_mov_cmp (void)
10084 Rn
= inst
.operands
[0].reg
;
10085 Rm
= inst
.operands
[1].reg
;
10088 set_it_insn_type_last ();
10090 if (unified_syntax
)
10092 int r0off
= (inst
.instruction
== T_MNEM_mov
10093 || inst
.instruction
== T_MNEM_movs
) ? 8 : 16;
10094 unsigned long opcode
;
10095 bfd_boolean narrow
;
10096 bfd_boolean low_regs
;
10098 low_regs
= (Rn
<= 7 && Rm
<= 7);
10099 opcode
= inst
.instruction
;
10100 if (in_it_block ())
10101 narrow
= opcode
!= T_MNEM_movs
;
10103 narrow
= opcode
!= T_MNEM_movs
|| low_regs
;
10104 if (inst
.size_req
== 4
10105 || inst
.operands
[1].shifted
)
10108 /* MOVS PC, LR is encoded as SUBS PC, LR, #0. */
10109 if (opcode
== T_MNEM_movs
&& inst
.operands
[1].isreg
10110 && !inst
.operands
[1].shifted
10114 inst
.instruction
= T2_SUBS_PC_LR
;
10118 if (opcode
== T_MNEM_cmp
)
10120 constraint (Rn
== REG_PC
, BAD_PC
);
10123 /* In the Thumb-2 ISA, use of R13 as Rm is deprecated,
10125 warn_deprecated_sp (Rm
);
10126 /* R15 was documented as a valid choice for Rm in ARMv6,
10127 but as UNPREDICTABLE in ARMv7. ARM's proprietary
10128 tools reject R15, so we do too. */
10129 constraint (Rm
== REG_PC
, BAD_PC
);
10132 reject_bad_reg (Rm
);
10134 else if (opcode
== T_MNEM_mov
10135 || opcode
== T_MNEM_movs
)
10137 if (inst
.operands
[1].isreg
)
10139 if (opcode
== T_MNEM_movs
)
10141 reject_bad_reg (Rn
);
10142 reject_bad_reg (Rm
);
10144 else if ((Rn
== REG_SP
|| Rn
== REG_PC
)
10145 && (Rm
== REG_SP
|| Rm
== REG_PC
))
10146 reject_bad_reg (Rm
);
10149 reject_bad_reg (Rn
);
10152 if (!inst
.operands
[1].isreg
)
10154 /* Immediate operand. */
10155 if (!in_it_block () && opcode
== T_MNEM_mov
)
10157 if (low_regs
&& narrow
)
10159 inst
.instruction
= THUMB_OP16 (opcode
);
10160 inst
.instruction
|= Rn
<< 8;
10161 if (inst
.size_req
== 2)
10162 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_IMM
;
10164 inst
.relax
= opcode
;
10168 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
10169 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
10170 inst
.instruction
|= Rn
<< r0off
;
10171 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
10174 else if (inst
.operands
[1].shifted
&& inst
.operands
[1].immisreg
10175 && (inst
.instruction
== T_MNEM_mov
10176 || inst
.instruction
== T_MNEM_movs
))
10178 /* Register shifts are encoded as separate shift instructions. */
10179 bfd_boolean flags
= (inst
.instruction
== T_MNEM_movs
);
10181 if (in_it_block ())
10186 if (inst
.size_req
== 4)
10189 if (!low_regs
|| inst
.operands
[1].imm
> 7)
10195 switch (inst
.operands
[1].shift_kind
)
10198 opcode
= narrow
? T_OPCODE_LSL_R
: THUMB_OP32 (T_MNEM_lsl
);
10201 opcode
= narrow
? T_OPCODE_ASR_R
: THUMB_OP32 (T_MNEM_asr
);
10204 opcode
= narrow
? T_OPCODE_LSR_R
: THUMB_OP32 (T_MNEM_lsr
);
10207 opcode
= narrow
? T_OPCODE_ROR_R
: THUMB_OP32 (T_MNEM_ror
);
10213 inst
.instruction
= opcode
;
10216 inst
.instruction
|= Rn
;
10217 inst
.instruction
|= inst
.operands
[1].imm
<< 3;
10222 inst
.instruction
|= CONDS_BIT
;
10224 inst
.instruction
|= Rn
<< 8;
10225 inst
.instruction
|= Rm
<< 16;
10226 inst
.instruction
|= inst
.operands
[1].imm
;
10231 /* Some mov with immediate shift have narrow variants.
10232 Register shifts are handled above. */
10233 if (low_regs
&& inst
.operands
[1].shifted
10234 && (inst
.instruction
== T_MNEM_mov
10235 || inst
.instruction
== T_MNEM_movs
))
10237 if (in_it_block ())
10238 narrow
= (inst
.instruction
== T_MNEM_mov
);
10240 narrow
= (inst
.instruction
== T_MNEM_movs
);
10245 switch (inst
.operands
[1].shift_kind
)
10247 case SHIFT_LSL
: inst
.instruction
= T_OPCODE_LSL_I
; break;
10248 case SHIFT_LSR
: inst
.instruction
= T_OPCODE_LSR_I
; break;
10249 case SHIFT_ASR
: inst
.instruction
= T_OPCODE_ASR_I
; break;
10250 default: narrow
= FALSE
; break;
10256 inst
.instruction
|= Rn
;
10257 inst
.instruction
|= Rm
<< 3;
10258 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_SHIFT
;
10262 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
10263 inst
.instruction
|= Rn
<< r0off
;
10264 encode_thumb32_shifted_operand (1);
10268 switch (inst
.instruction
)
10271 inst
.instruction
= T_OPCODE_MOV_HR
;
10272 inst
.instruction
|= (Rn
& 0x8) << 4;
10273 inst
.instruction
|= (Rn
& 0x7);
10274 inst
.instruction
|= Rm
<< 3;
10278 /* We know we have low registers at this point.
10279 Generate ADD Rd, Rs, #0. */
10280 inst
.instruction
= T_OPCODE_ADD_I3
;
10281 inst
.instruction
|= Rn
;
10282 inst
.instruction
|= Rm
<< 3;
10288 inst
.instruction
= T_OPCODE_CMP_LR
;
10289 inst
.instruction
|= Rn
;
10290 inst
.instruction
|= Rm
<< 3;
10294 inst
.instruction
= T_OPCODE_CMP_HR
;
10295 inst
.instruction
|= (Rn
& 0x8) << 4;
10296 inst
.instruction
|= (Rn
& 0x7);
10297 inst
.instruction
|= Rm
<< 3;
10304 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
10306 /* PR 10443: Do not silently ignore shifted operands. */
10307 constraint (inst
.operands
[1].shifted
,
10308 _("shifts in CMP/MOV instructions are only supported in unified syntax"));
10310 if (inst
.operands
[1].isreg
)
10312 if (Rn
< 8 && Rm
< 8)
10314 /* A move of two lowregs is encoded as ADD Rd, Rs, #0
10315 since a MOV instruction produces unpredictable results. */
10316 if (inst
.instruction
== T_OPCODE_MOV_I8
)
10317 inst
.instruction
= T_OPCODE_ADD_I3
;
10319 inst
.instruction
= T_OPCODE_CMP_LR
;
10321 inst
.instruction
|= Rn
;
10322 inst
.instruction
|= Rm
<< 3;
10326 if (inst
.instruction
== T_OPCODE_MOV_I8
)
10327 inst
.instruction
= T_OPCODE_MOV_HR
;
10329 inst
.instruction
= T_OPCODE_CMP_HR
;
10335 constraint (Rn
> 7,
10336 _("only lo regs allowed with immediate"));
10337 inst
.instruction
|= Rn
<< 8;
10338 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_IMM
;
10349 top
= (inst
.instruction
& 0x00800000) != 0;
10350 if (inst
.reloc
.type
== BFD_RELOC_ARM_MOVW
)
10352 constraint (top
, _(":lower16: not allowed this instruction"));
10353 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_MOVW
;
10355 else if (inst
.reloc
.type
== BFD_RELOC_ARM_MOVT
)
10357 constraint (!top
, _(":upper16: not allowed this instruction"));
10358 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_MOVT
;
10361 Rd
= inst
.operands
[0].reg
;
10362 reject_bad_reg (Rd
);
10364 inst
.instruction
|= Rd
<< 8;
10365 if (inst
.reloc
.type
== BFD_RELOC_UNUSED
)
10367 imm
= inst
.reloc
.exp
.X_add_number
;
10368 inst
.instruction
|= (imm
& 0xf000) << 4;
10369 inst
.instruction
|= (imm
& 0x0800) << 15;
10370 inst
.instruction
|= (imm
& 0x0700) << 4;
10371 inst
.instruction
|= (imm
& 0x00ff);
10376 do_t_mvn_tst (void)
10380 Rn
= inst
.operands
[0].reg
;
10381 Rm
= inst
.operands
[1].reg
;
10383 if (inst
.instruction
== T_MNEM_cmp
10384 || inst
.instruction
== T_MNEM_cmn
)
10385 constraint (Rn
== REG_PC
, BAD_PC
);
10387 reject_bad_reg (Rn
);
10388 reject_bad_reg (Rm
);
10390 if (unified_syntax
)
10392 int r0off
= (inst
.instruction
== T_MNEM_mvn
10393 || inst
.instruction
== T_MNEM_mvns
) ? 8 : 16;
10394 bfd_boolean narrow
;
10396 if (inst
.size_req
== 4
10397 || inst
.instruction
> 0xffff
10398 || inst
.operands
[1].shifted
10399 || Rn
> 7 || Rm
> 7)
10401 else if (inst
.instruction
== T_MNEM_cmn
)
10403 else if (THUMB_SETS_FLAGS (inst
.instruction
))
10404 narrow
= !in_it_block ();
10406 narrow
= in_it_block ();
10408 if (!inst
.operands
[1].isreg
)
10410 /* For an immediate, we always generate a 32-bit opcode;
10411 section relaxation will shrink it later if possible. */
10412 if (inst
.instruction
< 0xffff)
10413 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
10414 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
10415 inst
.instruction
|= Rn
<< r0off
;
10416 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
10420 /* See if we can do this with a 16-bit instruction. */
10423 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
10424 inst
.instruction
|= Rn
;
10425 inst
.instruction
|= Rm
<< 3;
10429 constraint (inst
.operands
[1].shifted
10430 && inst
.operands
[1].immisreg
,
10431 _("shift must be constant"));
10432 if (inst
.instruction
< 0xffff)
10433 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
10434 inst
.instruction
|= Rn
<< r0off
;
10435 encode_thumb32_shifted_operand (1);
10441 constraint (inst
.instruction
> 0xffff
10442 || inst
.instruction
== T_MNEM_mvns
, BAD_THUMB32
);
10443 constraint (!inst
.operands
[1].isreg
|| inst
.operands
[1].shifted
,
10444 _("unshifted register required"));
10445 constraint (Rn
> 7 || Rm
> 7,
10448 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
10449 inst
.instruction
|= Rn
;
10450 inst
.instruction
|= Rm
<< 3;
10460 if (do_vfp_nsyn_mrs () == SUCCESS
)
10463 flags
= inst
.operands
[1].imm
& (PSR_c
|PSR_x
|PSR_s
|PSR_f
|SPSR_BIT
);
10466 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_m
),
10467 _("selected processor does not support "
10468 "requested special purpose register"));
10472 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v1
),
10473 _("selected processor does not support "
10474 "requested special purpose register"));
10475 /* mrs only accepts CPSR/SPSR/CPSR_all/SPSR_all. */
10476 constraint ((flags
& ~SPSR_BIT
) != (PSR_c
|PSR_f
),
10477 _("'CPSR' or 'SPSR' expected"));
10480 Rd
= inst
.operands
[0].reg
;
10481 reject_bad_reg (Rd
);
10483 inst
.instruction
|= Rd
<< 8;
10484 inst
.instruction
|= (flags
& SPSR_BIT
) >> 2;
10485 inst
.instruction
|= inst
.operands
[1].imm
& 0xff;
10494 if (do_vfp_nsyn_msr () == SUCCESS
)
10497 constraint (!inst
.operands
[1].isreg
,
10498 _("Thumb encoding does not support an immediate here"));
10499 flags
= inst
.operands
[0].imm
;
10502 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v1
),
10503 _("selected processor does not support "
10504 "requested special purpose register"));
10508 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_m
),
10509 _("selected processor does not support "
10510 "requested special purpose register"));
10514 Rn
= inst
.operands
[1].reg
;
10515 reject_bad_reg (Rn
);
10517 inst
.instruction
|= (flags
& SPSR_BIT
) >> 2;
10518 inst
.instruction
|= (flags
& ~SPSR_BIT
) >> 8;
10519 inst
.instruction
|= (flags
& 0xff);
10520 inst
.instruction
|= Rn
<< 16;
10526 bfd_boolean narrow
;
10527 unsigned Rd
, Rn
, Rm
;
10529 if (!inst
.operands
[2].present
)
10530 inst
.operands
[2].reg
= inst
.operands
[0].reg
;
10532 Rd
= inst
.operands
[0].reg
;
10533 Rn
= inst
.operands
[1].reg
;
10534 Rm
= inst
.operands
[2].reg
;
10536 if (unified_syntax
)
10538 if (inst
.size_req
== 4
10544 else if (inst
.instruction
== T_MNEM_muls
)
10545 narrow
= !in_it_block ();
10547 narrow
= in_it_block ();
10551 constraint (inst
.instruction
== T_MNEM_muls
, BAD_THUMB32
);
10552 constraint (Rn
> 7 || Rm
> 7,
10559 /* 16-bit MULS/Conditional MUL. */
10560 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
10561 inst
.instruction
|= Rd
;
10564 inst
.instruction
|= Rm
<< 3;
10566 inst
.instruction
|= Rn
<< 3;
10568 constraint (1, _("dest must overlap one source register"));
10572 constraint (inst
.instruction
!= T_MNEM_mul
,
10573 _("Thumb-2 MUL must not set flags"));
10575 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
10576 inst
.instruction
|= Rd
<< 8;
10577 inst
.instruction
|= Rn
<< 16;
10578 inst
.instruction
|= Rm
<< 0;
10580 reject_bad_reg (Rd
);
10581 reject_bad_reg (Rn
);
10582 reject_bad_reg (Rm
);
10589 unsigned RdLo
, RdHi
, Rn
, Rm
;
10591 RdLo
= inst
.operands
[0].reg
;
10592 RdHi
= inst
.operands
[1].reg
;
10593 Rn
= inst
.operands
[2].reg
;
10594 Rm
= inst
.operands
[3].reg
;
10596 reject_bad_reg (RdLo
);
10597 reject_bad_reg (RdHi
);
10598 reject_bad_reg (Rn
);
10599 reject_bad_reg (Rm
);
10601 inst
.instruction
|= RdLo
<< 12;
10602 inst
.instruction
|= RdHi
<< 8;
10603 inst
.instruction
|= Rn
<< 16;
10604 inst
.instruction
|= Rm
;
10607 as_tsktsk (_("rdhi and rdlo must be different"));
10613 set_it_insn_type (NEUTRAL_IT_INSN
);
10615 if (unified_syntax
)
10617 if (inst
.size_req
== 4 || inst
.operands
[0].imm
> 15)
10619 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
10620 inst
.instruction
|= inst
.operands
[0].imm
;
10624 /* PR9722: Check for Thumb2 availability before
10625 generating a thumb2 nop instruction. */
10626 if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_arch_t2
))
10628 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
10629 inst
.instruction
|= inst
.operands
[0].imm
<< 4;
10632 inst
.instruction
= 0x46c0;
10637 constraint (inst
.operands
[0].present
,
10638 _("Thumb does not support NOP with hints"));
10639 inst
.instruction
= 0x46c0;
10646 if (unified_syntax
)
10648 bfd_boolean narrow
;
10650 if (THUMB_SETS_FLAGS (inst
.instruction
))
10651 narrow
= !in_it_block ();
10653 narrow
= in_it_block ();
10654 if (inst
.operands
[0].reg
> 7 || inst
.operands
[1].reg
> 7)
10656 if (inst
.size_req
== 4)
10661 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
10662 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
10663 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
10667 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
10668 inst
.instruction
|= inst
.operands
[0].reg
;
10669 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
10674 constraint (inst
.operands
[0].reg
> 7 || inst
.operands
[1].reg
> 7,
10676 constraint (THUMB_SETS_FLAGS (inst
.instruction
), BAD_THUMB32
);
10678 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
10679 inst
.instruction
|= inst
.operands
[0].reg
;
10680 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
10689 Rd
= inst
.operands
[0].reg
;
10690 Rn
= inst
.operands
[1].present
? inst
.operands
[1].reg
: Rd
;
10692 reject_bad_reg (Rd
);
10693 /* Rn == REG_SP is unpredictable; Rn == REG_PC is MVN. */
10694 reject_bad_reg (Rn
);
10696 inst
.instruction
|= Rd
<< 8;
10697 inst
.instruction
|= Rn
<< 16;
10699 if (!inst
.operands
[2].isreg
)
10701 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
10702 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
10708 Rm
= inst
.operands
[2].reg
;
10709 reject_bad_reg (Rm
);
10711 constraint (inst
.operands
[2].shifted
10712 && inst
.operands
[2].immisreg
,
10713 _("shift must be constant"));
10714 encode_thumb32_shifted_operand (2);
10721 unsigned Rd
, Rn
, Rm
;
10723 Rd
= inst
.operands
[0].reg
;
10724 Rn
= inst
.operands
[1].reg
;
10725 Rm
= inst
.operands
[2].reg
;
10727 reject_bad_reg (Rd
);
10728 reject_bad_reg (Rn
);
10729 reject_bad_reg (Rm
);
10731 inst
.instruction
|= Rd
<< 8;
10732 inst
.instruction
|= Rn
<< 16;
10733 inst
.instruction
|= Rm
;
10734 if (inst
.operands
[3].present
)
10736 unsigned int val
= inst
.reloc
.exp
.X_add_number
;
10737 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
10738 _("expression too complex"));
10739 inst
.instruction
|= (val
& 0x1c) << 10;
10740 inst
.instruction
|= (val
& 0x03) << 6;
10747 if (!inst
.operands
[3].present
)
10751 inst
.instruction
&= ~0x00000020;
10753 /* PR 10168. Swap the Rm and Rn registers. */
10754 Rtmp
= inst
.operands
[1].reg
;
10755 inst
.operands
[1].reg
= inst
.operands
[2].reg
;
10756 inst
.operands
[2].reg
= Rtmp
;
10764 if (inst
.operands
[0].immisreg
)
10765 reject_bad_reg (inst
.operands
[0].imm
);
10767 encode_thumb32_addr_mode (0, /*is_t=*/FALSE
, /*is_d=*/FALSE
);
10771 do_t_push_pop (void)
10775 constraint (inst
.operands
[0].writeback
,
10776 _("push/pop do not support {reglist}^"));
10777 constraint (inst
.reloc
.type
!= BFD_RELOC_UNUSED
,
10778 _("expression too complex"));
10780 mask
= inst
.operands
[0].imm
;
10781 if ((mask
& ~0xff) == 0)
10782 inst
.instruction
= THUMB_OP16 (inst
.instruction
) | mask
;
10783 else if ((inst
.instruction
== T_MNEM_push
10784 && (mask
& ~0xff) == 1 << REG_LR
)
10785 || (inst
.instruction
== T_MNEM_pop
10786 && (mask
& ~0xff) == 1 << REG_PC
))
10788 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
10789 inst
.instruction
|= THUMB_PP_PC_LR
;
10790 inst
.instruction
|= mask
& 0xff;
10792 else if (unified_syntax
)
10794 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
10795 encode_thumb2_ldmstm (13, mask
, TRUE
);
10799 inst
.error
= _("invalid register list to push/pop instruction");
10809 Rd
= inst
.operands
[0].reg
;
10810 Rm
= inst
.operands
[1].reg
;
10812 reject_bad_reg (Rd
);
10813 reject_bad_reg (Rm
);
10815 inst
.instruction
|= Rd
<< 8;
10816 inst
.instruction
|= Rm
<< 16;
10817 inst
.instruction
|= Rm
;
10825 Rd
= inst
.operands
[0].reg
;
10826 Rm
= inst
.operands
[1].reg
;
10828 reject_bad_reg (Rd
);
10829 reject_bad_reg (Rm
);
10831 if (Rd
<= 7 && Rm
<= 7
10832 && inst
.size_req
!= 4)
10834 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
10835 inst
.instruction
|= Rd
;
10836 inst
.instruction
|= Rm
<< 3;
10838 else if (unified_syntax
)
10840 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
10841 inst
.instruction
|= Rd
<< 8;
10842 inst
.instruction
|= Rm
<< 16;
10843 inst
.instruction
|= Rm
;
10846 inst
.error
= BAD_HIREG
;
10854 Rd
= inst
.operands
[0].reg
;
10855 Rm
= inst
.operands
[1].reg
;
10857 reject_bad_reg (Rd
);
10858 reject_bad_reg (Rm
);
10860 inst
.instruction
|= Rd
<< 8;
10861 inst
.instruction
|= Rm
;
10869 Rd
= inst
.operands
[0].reg
;
10870 Rs
= (inst
.operands
[1].present
10871 ? inst
.operands
[1].reg
/* Rd, Rs, foo */
10872 : inst
.operands
[0].reg
); /* Rd, foo -> Rd, Rd, foo */
10874 reject_bad_reg (Rd
);
10875 reject_bad_reg (Rs
);
10876 if (inst
.operands
[2].isreg
)
10877 reject_bad_reg (inst
.operands
[2].reg
);
10879 inst
.instruction
|= Rd
<< 8;
10880 inst
.instruction
|= Rs
<< 16;
10881 if (!inst
.operands
[2].isreg
)
10883 bfd_boolean narrow
;
10885 if ((inst
.instruction
& 0x00100000) != 0)
10886 narrow
= !in_it_block ();
10888 narrow
= in_it_block ();
10890 if (Rd
> 7 || Rs
> 7)
10893 if (inst
.size_req
== 4 || !unified_syntax
)
10896 if (inst
.reloc
.exp
.X_op
!= O_constant
10897 || inst
.reloc
.exp
.X_add_number
!= 0)
10900 /* Turn rsb #0 into 16-bit neg. We should probably do this via
10901 relaxation, but it doesn't seem worth the hassle. */
10904 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
10905 inst
.instruction
= THUMB_OP16 (T_MNEM_negs
);
10906 inst
.instruction
|= Rs
<< 3;
10907 inst
.instruction
|= Rd
;
10911 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
10912 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
10916 encode_thumb32_shifted_operand (2);
10922 set_it_insn_type (OUTSIDE_IT_INSN
);
10923 if (inst
.operands
[0].imm
)
10924 inst
.instruction
|= 0x8;
10930 if (!inst
.operands
[1].present
)
10931 inst
.operands
[1].reg
= inst
.operands
[0].reg
;
10933 if (unified_syntax
)
10935 bfd_boolean narrow
;
10938 switch (inst
.instruction
)
10941 case T_MNEM_asrs
: shift_kind
= SHIFT_ASR
; break;
10943 case T_MNEM_lsls
: shift_kind
= SHIFT_LSL
; break;
10945 case T_MNEM_lsrs
: shift_kind
= SHIFT_LSR
; break;
10947 case T_MNEM_rors
: shift_kind
= SHIFT_ROR
; break;
10951 if (THUMB_SETS_FLAGS (inst
.instruction
))
10952 narrow
= !in_it_block ();
10954 narrow
= in_it_block ();
10955 if (inst
.operands
[0].reg
> 7 || inst
.operands
[1].reg
> 7)
10957 if (!inst
.operands
[2].isreg
&& shift_kind
== SHIFT_ROR
)
10959 if (inst
.operands
[2].isreg
10960 && (inst
.operands
[1].reg
!= inst
.operands
[0].reg
10961 || inst
.operands
[2].reg
> 7))
10963 if (inst
.size_req
== 4)
10966 reject_bad_reg (inst
.operands
[0].reg
);
10967 reject_bad_reg (inst
.operands
[1].reg
);
10971 if (inst
.operands
[2].isreg
)
10973 reject_bad_reg (inst
.operands
[2].reg
);
10974 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
10975 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
10976 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
10977 inst
.instruction
|= inst
.operands
[2].reg
;
10981 inst
.operands
[1].shifted
= 1;
10982 inst
.operands
[1].shift_kind
= shift_kind
;
10983 inst
.instruction
= THUMB_OP32 (THUMB_SETS_FLAGS (inst
.instruction
)
10984 ? T_MNEM_movs
: T_MNEM_mov
);
10985 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
10986 encode_thumb32_shifted_operand (1);
10987 /* Prevent the incorrect generation of an ARM_IMMEDIATE fixup. */
10988 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
10993 if (inst
.operands
[2].isreg
)
10995 switch (shift_kind
)
10997 case SHIFT_ASR
: inst
.instruction
= T_OPCODE_ASR_R
; break;
10998 case SHIFT_LSL
: inst
.instruction
= T_OPCODE_LSL_R
; break;
10999 case SHIFT_LSR
: inst
.instruction
= T_OPCODE_LSR_R
; break;
11000 case SHIFT_ROR
: inst
.instruction
= T_OPCODE_ROR_R
; break;
11004 inst
.instruction
|= inst
.operands
[0].reg
;
11005 inst
.instruction
|= inst
.operands
[2].reg
<< 3;
11009 switch (shift_kind
)
11011 case SHIFT_ASR
: inst
.instruction
= T_OPCODE_ASR_I
; break;
11012 case SHIFT_LSL
: inst
.instruction
= T_OPCODE_LSL_I
; break;
11013 case SHIFT_LSR
: inst
.instruction
= T_OPCODE_LSR_I
; break;
11016 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_SHIFT
;
11017 inst
.instruction
|= inst
.operands
[0].reg
;
11018 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
11024 constraint (inst
.operands
[0].reg
> 7
11025 || inst
.operands
[1].reg
> 7, BAD_HIREG
);
11026 constraint (THUMB_SETS_FLAGS (inst
.instruction
), BAD_THUMB32
);
11028 if (inst
.operands
[2].isreg
) /* Rd, {Rs,} Rn */
11030 constraint (inst
.operands
[2].reg
> 7, BAD_HIREG
);
11031 constraint (inst
.operands
[0].reg
!= inst
.operands
[1].reg
,
11032 _("source1 and dest must be same register"));
11034 switch (inst
.instruction
)
11036 case T_MNEM_asr
: inst
.instruction
= T_OPCODE_ASR_R
; break;
11037 case T_MNEM_lsl
: inst
.instruction
= T_OPCODE_LSL_R
; break;
11038 case T_MNEM_lsr
: inst
.instruction
= T_OPCODE_LSR_R
; break;
11039 case T_MNEM_ror
: inst
.instruction
= T_OPCODE_ROR_R
; break;
11043 inst
.instruction
|= inst
.operands
[0].reg
;
11044 inst
.instruction
|= inst
.operands
[2].reg
<< 3;
11048 switch (inst
.instruction
)
11050 case T_MNEM_asr
: inst
.instruction
= T_OPCODE_ASR_I
; break;
11051 case T_MNEM_lsl
: inst
.instruction
= T_OPCODE_LSL_I
; break;
11052 case T_MNEM_lsr
: inst
.instruction
= T_OPCODE_LSR_I
; break;
11053 case T_MNEM_ror
: inst
.error
= _("ror #imm not supported"); return;
11056 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_SHIFT
;
11057 inst
.instruction
|= inst
.operands
[0].reg
;
11058 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
11066 unsigned Rd
, Rn
, Rm
;
11068 Rd
= inst
.operands
[0].reg
;
11069 Rn
= inst
.operands
[1].reg
;
11070 Rm
= inst
.operands
[2].reg
;
11072 reject_bad_reg (Rd
);
11073 reject_bad_reg (Rn
);
11074 reject_bad_reg (Rm
);
11076 inst
.instruction
|= Rd
<< 8;
11077 inst
.instruction
|= Rn
<< 16;
11078 inst
.instruction
|= Rm
;
11084 unsigned Rd
, Rn
, Rm
;
11086 Rd
= inst
.operands
[0].reg
;
11087 Rm
= inst
.operands
[1].reg
;
11088 Rn
= inst
.operands
[2].reg
;
11090 reject_bad_reg (Rd
);
11091 reject_bad_reg (Rn
);
11092 reject_bad_reg (Rm
);
11094 inst
.instruction
|= Rd
<< 8;
11095 inst
.instruction
|= Rn
<< 16;
11096 inst
.instruction
|= Rm
;
11102 unsigned int value
= inst
.reloc
.exp
.X_add_number
;
11103 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
11104 _("expression too complex"));
11105 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
11106 inst
.instruction
|= (value
& 0xf000) >> 12;
11107 inst
.instruction
|= (value
& 0x0ff0);
11108 inst
.instruction
|= (value
& 0x000f) << 16;
11112 do_t_ssat_usat (int bias
)
11116 Rd
= inst
.operands
[0].reg
;
11117 Rn
= inst
.operands
[2].reg
;
11119 reject_bad_reg (Rd
);
11120 reject_bad_reg (Rn
);
11122 inst
.instruction
|= Rd
<< 8;
11123 inst
.instruction
|= inst
.operands
[1].imm
- bias
;
11124 inst
.instruction
|= Rn
<< 16;
11126 if (inst
.operands
[3].present
)
11128 offsetT shift_amount
= inst
.reloc
.exp
.X_add_number
;
11130 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
11132 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
11133 _("expression too complex"));
11135 if (shift_amount
!= 0)
11137 constraint (shift_amount
> 31,
11138 _("shift expression is too large"));
11140 if (inst
.operands
[3].shift_kind
== SHIFT_ASR
)
11141 inst
.instruction
|= 0x00200000; /* sh bit. */
11143 inst
.instruction
|= (shift_amount
& 0x1c) << 10;
11144 inst
.instruction
|= (shift_amount
& 0x03) << 6;
11152 do_t_ssat_usat (1);
11160 Rd
= inst
.operands
[0].reg
;
11161 Rn
= inst
.operands
[2].reg
;
11163 reject_bad_reg (Rd
);
11164 reject_bad_reg (Rn
);
11166 inst
.instruction
|= Rd
<< 8;
11167 inst
.instruction
|= inst
.operands
[1].imm
- 1;
11168 inst
.instruction
|= Rn
<< 16;
11174 constraint (!inst
.operands
[2].isreg
|| !inst
.operands
[2].preind
11175 || inst
.operands
[2].postind
|| inst
.operands
[2].writeback
11176 || inst
.operands
[2].immisreg
|| inst
.operands
[2].shifted
11177 || inst
.operands
[2].negative
,
11180 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
11181 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
11182 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
11183 inst
.reloc
.type
= BFD_RELOC_ARM_T32_OFFSET_U8
;
11189 if (!inst
.operands
[2].present
)
11190 inst
.operands
[2].reg
= inst
.operands
[1].reg
+ 1;
11192 constraint (inst
.operands
[0].reg
== inst
.operands
[1].reg
11193 || inst
.operands
[0].reg
== inst
.operands
[2].reg
11194 || inst
.operands
[0].reg
== inst
.operands
[3].reg
11195 || inst
.operands
[1].reg
== inst
.operands
[2].reg
,
11198 inst
.instruction
|= inst
.operands
[0].reg
;
11199 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
11200 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
11201 inst
.instruction
|= inst
.operands
[3].reg
<< 16;
11207 unsigned Rd
, Rn
, Rm
;
11209 Rd
= inst
.operands
[0].reg
;
11210 Rn
= inst
.operands
[1].reg
;
11211 Rm
= inst
.operands
[2].reg
;
11213 reject_bad_reg (Rd
);
11214 reject_bad_reg (Rn
);
11215 reject_bad_reg (Rm
);
11217 inst
.instruction
|= Rd
<< 8;
11218 inst
.instruction
|= Rn
<< 16;
11219 inst
.instruction
|= Rm
;
11220 inst
.instruction
|= inst
.operands
[3].imm
<< 4;
11228 Rd
= inst
.operands
[0].reg
;
11229 Rm
= inst
.operands
[1].reg
;
11231 reject_bad_reg (Rd
);
11232 reject_bad_reg (Rm
);
11234 if (inst
.instruction
<= 0xffff
11235 && inst
.size_req
!= 4
11236 && Rd
<= 7 && Rm
<= 7
11237 && (!inst
.operands
[2].present
|| inst
.operands
[2].imm
== 0))
11239 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
11240 inst
.instruction
|= Rd
;
11241 inst
.instruction
|= Rm
<< 3;
11243 else if (unified_syntax
)
11245 if (inst
.instruction
<= 0xffff)
11246 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
11247 inst
.instruction
|= Rd
<< 8;
11248 inst
.instruction
|= Rm
;
11249 inst
.instruction
|= inst
.operands
[2].imm
<< 4;
11253 constraint (inst
.operands
[2].present
&& inst
.operands
[2].imm
!= 0,
11254 _("Thumb encoding does not support rotation"));
11255 constraint (1, BAD_HIREG
);
11262 inst
.reloc
.type
= BFD_RELOC_ARM_SWI
;
11271 half
= (inst
.instruction
& 0x10) != 0;
11272 set_it_insn_type_last ();
11273 constraint (inst
.operands
[0].immisreg
,
11274 _("instruction requires register index"));
11276 Rn
= inst
.operands
[0].reg
;
11277 Rm
= inst
.operands
[0].imm
;
11279 constraint (Rn
== REG_SP
, BAD_SP
);
11280 reject_bad_reg (Rm
);
11282 constraint (!half
&& inst
.operands
[0].shifted
,
11283 _("instruction does not allow shifted index"));
11284 inst
.instruction
|= (Rn
<< 16) | Rm
;
11290 do_t_ssat_usat (0);
11298 Rd
= inst
.operands
[0].reg
;
11299 Rn
= inst
.operands
[2].reg
;
11301 reject_bad_reg (Rd
);
11302 reject_bad_reg (Rn
);
11304 inst
.instruction
|= Rd
<< 8;
11305 inst
.instruction
|= inst
.operands
[1].imm
;
11306 inst
.instruction
|= Rn
<< 16;
11309 /* Neon instruction encoder helpers. */
11311 /* Encodings for the different types for various Neon opcodes. */
11313 /* An "invalid" code for the following tables. */
11316 struct neon_tab_entry
11319 unsigned float_or_poly
;
11320 unsigned scalar_or_imm
;
11323 /* Map overloaded Neon opcodes to their respective encodings. */
11324 #define NEON_ENC_TAB \
11325 X(vabd, 0x0000700, 0x1200d00, N_INV), \
11326 X(vmax, 0x0000600, 0x0000f00, N_INV), \
11327 X(vmin, 0x0000610, 0x0200f00, N_INV), \
11328 X(vpadd, 0x0000b10, 0x1000d00, N_INV), \
11329 X(vpmax, 0x0000a00, 0x1000f00, N_INV), \
11330 X(vpmin, 0x0000a10, 0x1200f00, N_INV), \
11331 X(vadd, 0x0000800, 0x0000d00, N_INV), \
11332 X(vsub, 0x1000800, 0x0200d00, N_INV), \
11333 X(vceq, 0x1000810, 0x0000e00, 0x1b10100), \
11334 X(vcge, 0x0000310, 0x1000e00, 0x1b10080), \
11335 X(vcgt, 0x0000300, 0x1200e00, 0x1b10000), \
11336 /* Register variants of the following two instructions are encoded as
11337 vcge / vcgt with the operands reversed. */ \
11338 X(vclt, 0x0000300, 0x1200e00, 0x1b10200), \
11339 X(vcle, 0x0000310, 0x1000e00, 0x1b10180), \
11340 X(vfma, N_INV, 0x0000c10, N_INV), \
11341 X(vfms, N_INV, 0x0200c10, N_INV), \
11342 X(vmla, 0x0000900, 0x0000d10, 0x0800040), \
11343 X(vmls, 0x1000900, 0x0200d10, 0x0800440), \
11344 X(vmul, 0x0000910, 0x1000d10, 0x0800840), \
11345 X(vmull, 0x0800c00, 0x0800e00, 0x0800a40), /* polynomial not float. */ \
11346 X(vmlal, 0x0800800, N_INV, 0x0800240), \
11347 X(vmlsl, 0x0800a00, N_INV, 0x0800640), \
11348 X(vqdmlal, 0x0800900, N_INV, 0x0800340), \
11349 X(vqdmlsl, 0x0800b00, N_INV, 0x0800740), \
11350 X(vqdmull, 0x0800d00, N_INV, 0x0800b40), \
11351 X(vqdmulh, 0x0000b00, N_INV, 0x0800c40), \
11352 X(vqrdmulh, 0x1000b00, N_INV, 0x0800d40), \
11353 X(vshl, 0x0000400, N_INV, 0x0800510), \
11354 X(vqshl, 0x0000410, N_INV, 0x0800710), \
11355 X(vand, 0x0000110, N_INV, 0x0800030), \
11356 X(vbic, 0x0100110, N_INV, 0x0800030), \
11357 X(veor, 0x1000110, N_INV, N_INV), \
11358 X(vorn, 0x0300110, N_INV, 0x0800010), \
11359 X(vorr, 0x0200110, N_INV, 0x0800010), \
11360 X(vmvn, 0x1b00580, N_INV, 0x0800030), \
11361 X(vshll, 0x1b20300, N_INV, 0x0800a10), /* max shift, immediate. */ \
11362 X(vcvt, 0x1b30600, N_INV, 0x0800e10), /* integer, fixed-point. */ \
11363 X(vdup, 0xe800b10, N_INV, 0x1b00c00), /* arm, scalar. */ \
11364 X(vld1, 0x0200000, 0x0a00000, 0x0a00c00), /* interlv, lane, dup. */ \
11365 X(vst1, 0x0000000, 0x0800000, N_INV), \
11366 X(vld2, 0x0200100, 0x0a00100, 0x0a00d00), \
11367 X(vst2, 0x0000100, 0x0800100, N_INV), \
11368 X(vld3, 0x0200200, 0x0a00200, 0x0a00e00), \
11369 X(vst3, 0x0000200, 0x0800200, N_INV), \
11370 X(vld4, 0x0200300, 0x0a00300, 0x0a00f00), \
11371 X(vst4, 0x0000300, 0x0800300, N_INV), \
11372 X(vmovn, 0x1b20200, N_INV, N_INV), \
11373 X(vtrn, 0x1b20080, N_INV, N_INV), \
11374 X(vqmovn, 0x1b20200, N_INV, N_INV), \
11375 X(vqmovun, 0x1b20240, N_INV, N_INV), \
11376 X(vnmul, 0xe200a40, 0xe200b40, N_INV), \
11377 X(vnmla, 0xe100a40, 0xe100b40, N_INV), \
11378 X(vnmls, 0xe100a00, 0xe100b00, N_INV), \
11379 X(vfnma, 0xe900a40, 0xe900b40, N_INV), \
11380 X(vfnms, 0xe900a00, 0xe900b00, N_INV), \
11381 X(vcmp, 0xeb40a40, 0xeb40b40, N_INV), \
11382 X(vcmpz, 0xeb50a40, 0xeb50b40, N_INV), \
11383 X(vcmpe, 0xeb40ac0, 0xeb40bc0, N_INV), \
11384 X(vcmpez, 0xeb50ac0, 0xeb50bc0, N_INV)
11388 #define X(OPC,I,F,S) N_MNEM_##OPC
11393 static const struct neon_tab_entry neon_enc_tab
[] =
11395 #define X(OPC,I,F,S) { (I), (F), (S) }
11400 /* Do not use these macros; instead, use NEON_ENCODE defined below. */
11401 #define NEON_ENC_INTEGER_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
11402 #define NEON_ENC_ARMREG_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
11403 #define NEON_ENC_POLY_(X) (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
11404 #define NEON_ENC_FLOAT_(X) (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
11405 #define NEON_ENC_SCALAR_(X) (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
11406 #define NEON_ENC_IMMED_(X) (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
11407 #define NEON_ENC_INTERLV_(X) (neon_enc_tab[(X) & 0x0fffffff].integer)
11408 #define NEON_ENC_LANE_(X) (neon_enc_tab[(X) & 0x0fffffff].float_or_poly)
11409 #define NEON_ENC_DUP_(X) (neon_enc_tab[(X) & 0x0fffffff].scalar_or_imm)
11410 #define NEON_ENC_SINGLE_(X) \
11411 ((neon_enc_tab[(X) & 0x0fffffff].integer) | ((X) & 0xf0000000))
11412 #define NEON_ENC_DOUBLE_(X) \
11413 ((neon_enc_tab[(X) & 0x0fffffff].float_or_poly) | ((X) & 0xf0000000))
11415 #define NEON_ENCODE(type, inst) \
11418 inst.instruction = NEON_ENC_##type##_ (inst.instruction); \
11419 inst.is_neon = 1; \
11423 #define check_neon_suffixes \
11426 if (!inst.error && inst.vectype.elems > 0 && !inst.is_neon) \
11428 as_bad (_("invalid neon suffix for non neon instruction")); \
11434 /* Define shapes for instruction operands. The following mnemonic characters
11435 are used in this table:
11437 F - VFP S<n> register
11438 D - Neon D<n> register
11439 Q - Neon Q<n> register
11443 L - D<n> register list
11445 This table is used to generate various data:
11446 - enumerations of the form NS_DDR to be used as arguments to
11448 - a table classifying shapes into single, double, quad, mixed.
11449 - a table used to drive neon_select_shape. */
11451 #define NEON_SHAPE_DEF \
11452 X(3, (D, D, D), DOUBLE), \
11453 X(3, (Q, Q, Q), QUAD), \
11454 X(3, (D, D, I), DOUBLE), \
11455 X(3, (Q, Q, I), QUAD), \
11456 X(3, (D, D, S), DOUBLE), \
11457 X(3, (Q, Q, S), QUAD), \
11458 X(2, (D, D), DOUBLE), \
11459 X(2, (Q, Q), QUAD), \
11460 X(2, (D, S), DOUBLE), \
11461 X(2, (Q, S), QUAD), \
11462 X(2, (D, R), DOUBLE), \
11463 X(2, (Q, R), QUAD), \
11464 X(2, (D, I), DOUBLE), \
11465 X(2, (Q, I), QUAD), \
11466 X(3, (D, L, D), DOUBLE), \
11467 X(2, (D, Q), MIXED), \
11468 X(2, (Q, D), MIXED), \
11469 X(3, (D, Q, I), MIXED), \
11470 X(3, (Q, D, I), MIXED), \
11471 X(3, (Q, D, D), MIXED), \
11472 X(3, (D, Q, Q), MIXED), \
11473 X(3, (Q, Q, D), MIXED), \
11474 X(3, (Q, D, S), MIXED), \
11475 X(3, (D, Q, S), MIXED), \
11476 X(4, (D, D, D, I), DOUBLE), \
11477 X(4, (Q, Q, Q, I), QUAD), \
11478 X(2, (F, F), SINGLE), \
11479 X(3, (F, F, F), SINGLE), \
11480 X(2, (F, I), SINGLE), \
11481 X(2, (F, D), MIXED), \
11482 X(2, (D, F), MIXED), \
11483 X(3, (F, F, I), MIXED), \
11484 X(4, (R, R, F, F), SINGLE), \
11485 X(4, (F, F, R, R), SINGLE), \
11486 X(3, (D, R, R), DOUBLE), \
11487 X(3, (R, R, D), DOUBLE), \
11488 X(2, (S, R), SINGLE), \
11489 X(2, (R, S), SINGLE), \
11490 X(2, (F, R), SINGLE), \
11491 X(2, (R, F), SINGLE)
11493 #define S2(A,B) NS_##A##B
11494 #define S3(A,B,C) NS_##A##B##C
11495 #define S4(A,B,C,D) NS_##A##B##C##D
11497 #define X(N, L, C) S##N L
11510 enum neon_shape_class
11518 #define X(N, L, C) SC_##C
11520 static enum neon_shape_class neon_shape_class
[] =
11538 /* Register widths of above. */
11539 static unsigned neon_shape_el_size
[] =
11550 struct neon_shape_info
11553 enum neon_shape_el el
[NEON_MAX_TYPE_ELS
];
11556 #define S2(A,B) { SE_##A, SE_##B }
11557 #define S3(A,B,C) { SE_##A, SE_##B, SE_##C }
11558 #define S4(A,B,C,D) { SE_##A, SE_##B, SE_##C, SE_##D }
11560 #define X(N, L, C) { N, S##N L }
11562 static struct neon_shape_info neon_shape_tab
[] =
11572 /* Bit masks used in type checking given instructions.
11573 'N_EQK' means the type must be the same as (or based on in some way) the key
11574 type, which itself is marked with the 'N_KEY' bit. If the 'N_EQK' bit is
11575 set, various other bits can be set as well in order to modify the meaning of
11576 the type constraint. */
11578 enum neon_type_mask
11601 N_KEY
= 0x1000000, /* Key element (main type specifier). */
11602 N_EQK
= 0x2000000, /* Given operand has the same type & size as the key. */
11603 N_VFP
= 0x4000000, /* VFP mode: operand size must match register width. */
11604 N_DBL
= 0x0000001, /* If N_EQK, this operand is twice the size. */
11605 N_HLF
= 0x0000002, /* If N_EQK, this operand is half the size. */
11606 N_SGN
= 0x0000004, /* If N_EQK, this operand is forced to be signed. */
11607 N_UNS
= 0x0000008, /* If N_EQK, this operand is forced to be unsigned. */
11608 N_INT
= 0x0000010, /* If N_EQK, this operand is forced to be integer. */
11609 N_FLT
= 0x0000020, /* If N_EQK, this operand is forced to be float. */
11610 N_SIZ
= 0x0000040, /* If N_EQK, this operand is forced to be size-only. */
11612 N_MAX_NONSPECIAL
= N_F64
11615 #define N_ALLMODS (N_DBL | N_HLF | N_SGN | N_UNS | N_INT | N_FLT | N_SIZ)
11617 #define N_SU_ALL (N_S8 | N_S16 | N_S32 | N_S64 | N_U8 | N_U16 | N_U32 | N_U64)
11618 #define N_SU_32 (N_S8 | N_S16 | N_S32 | N_U8 | N_U16 | N_U32)
11619 #define N_SU_16_64 (N_S16 | N_S32 | N_S64 | N_U16 | N_U32 | N_U64)
11620 #define N_SUF_32 (N_SU_32 | N_F32)
11621 #define N_I_ALL (N_I8 | N_I16 | N_I32 | N_I64)
11622 #define N_IF_32 (N_I8 | N_I16 | N_I32 | N_F32)
11624 /* Pass this as the first type argument to neon_check_type to ignore types
11626 #define N_IGNORE_TYPE (N_KEY | N_EQK)
11628 /* Select a "shape" for the current instruction (describing register types or
11629 sizes) from a list of alternatives. Return NS_NULL if the current instruction
11630 doesn't fit. For non-polymorphic shapes, checking is usually done as a
11631 function of operand parsing, so this function doesn't need to be called.
11632 Shapes should be listed in order of decreasing length. */
11634 static enum neon_shape
11635 neon_select_shape (enum neon_shape shape
, ...)
11638 enum neon_shape first_shape
= shape
;
11640 /* Fix missing optional operands. FIXME: we don't know at this point how
11641 many arguments we should have, so this makes the assumption that we have
11642 > 1. This is true of all current Neon opcodes, I think, but may not be
11643 true in the future. */
11644 if (!inst
.operands
[1].present
)
11645 inst
.operands
[1] = inst
.operands
[0];
11647 va_start (ap
, shape
);
11649 for (; shape
!= NS_NULL
; shape
= (enum neon_shape
) va_arg (ap
, int))
11654 for (j
= 0; j
< neon_shape_tab
[shape
].els
; j
++)
11656 if (!inst
.operands
[j
].present
)
11662 switch (neon_shape_tab
[shape
].el
[j
])
11665 if (!(inst
.operands
[j
].isreg
11666 && inst
.operands
[j
].isvec
11667 && inst
.operands
[j
].issingle
11668 && !inst
.operands
[j
].isquad
))
11673 if (!(inst
.operands
[j
].isreg
11674 && inst
.operands
[j
].isvec
11675 && !inst
.operands
[j
].isquad
11676 && !inst
.operands
[j
].issingle
))
11681 if (!(inst
.operands
[j
].isreg
11682 && !inst
.operands
[j
].isvec
))
11687 if (!(inst
.operands
[j
].isreg
11688 && inst
.operands
[j
].isvec
11689 && inst
.operands
[j
].isquad
11690 && !inst
.operands
[j
].issingle
))
11695 if (!(!inst
.operands
[j
].isreg
11696 && !inst
.operands
[j
].isscalar
))
11701 if (!(!inst
.operands
[j
].isreg
11702 && inst
.operands
[j
].isscalar
))
11716 if (shape
== NS_NULL
&& first_shape
!= NS_NULL
)
11717 first_error (_("invalid instruction shape"));
11722 /* True if SHAPE is predominantly a quadword operation (most of the time, this
11723 means the Q bit should be set). */
11726 neon_quad (enum neon_shape shape
)
11728 return neon_shape_class
[shape
] == SC_QUAD
;
11732 neon_modify_type_size (unsigned typebits
, enum neon_el_type
*g_type
,
11735 /* Allow modification to be made to types which are constrained to be
11736 based on the key element, based on bits set alongside N_EQK. */
11737 if ((typebits
& N_EQK
) != 0)
11739 if ((typebits
& N_HLF
) != 0)
11741 else if ((typebits
& N_DBL
) != 0)
11743 if ((typebits
& N_SGN
) != 0)
11744 *g_type
= NT_signed
;
11745 else if ((typebits
& N_UNS
) != 0)
11746 *g_type
= NT_unsigned
;
11747 else if ((typebits
& N_INT
) != 0)
11748 *g_type
= NT_integer
;
11749 else if ((typebits
& N_FLT
) != 0)
11750 *g_type
= NT_float
;
11751 else if ((typebits
& N_SIZ
) != 0)
11752 *g_type
= NT_untyped
;
11756 /* Return operand OPNO promoted by bits set in THISARG. KEY should be the "key"
11757 operand type, i.e. the single type specified in a Neon instruction when it
11758 is the only one given. */
11760 static struct neon_type_el
11761 neon_type_promote (struct neon_type_el
*key
, unsigned thisarg
)
11763 struct neon_type_el dest
= *key
;
11765 gas_assert ((thisarg
& N_EQK
) != 0);
11767 neon_modify_type_size (thisarg
, &dest
.type
, &dest
.size
);
11772 /* Convert Neon type and size into compact bitmask representation. */
11774 static enum neon_type_mask
11775 type_chk_of_el_type (enum neon_el_type type
, unsigned size
)
11782 case 8: return N_8
;
11783 case 16: return N_16
;
11784 case 32: return N_32
;
11785 case 64: return N_64
;
11793 case 8: return N_I8
;
11794 case 16: return N_I16
;
11795 case 32: return N_I32
;
11796 case 64: return N_I64
;
11804 case 16: return N_F16
;
11805 case 32: return N_F32
;
11806 case 64: return N_F64
;
11814 case 8: return N_P8
;
11815 case 16: return N_P16
;
11823 case 8: return N_S8
;
11824 case 16: return N_S16
;
11825 case 32: return N_S32
;
11826 case 64: return N_S64
;
11834 case 8: return N_U8
;
11835 case 16: return N_U16
;
11836 case 32: return N_U32
;
11837 case 64: return N_U64
;
11848 /* Convert compact Neon bitmask type representation to a type and size. Only
11849 handles the case where a single bit is set in the mask. */
11852 el_type_of_type_chk (enum neon_el_type
*type
, unsigned *size
,
11853 enum neon_type_mask mask
)
11855 if ((mask
& N_EQK
) != 0)
11858 if ((mask
& (N_S8
| N_U8
| N_I8
| N_8
| N_P8
)) != 0)
11860 else if ((mask
& (N_S16
| N_U16
| N_I16
| N_16
| N_P16
)) != 0)
11862 else if ((mask
& (N_S32
| N_U32
| N_I32
| N_32
| N_F32
)) != 0)
11864 else if ((mask
& (N_S64
| N_U64
| N_I64
| N_64
| N_F64
)) != 0)
11869 if ((mask
& (N_S8
| N_S16
| N_S32
| N_S64
)) != 0)
11871 else if ((mask
& (N_U8
| N_U16
| N_U32
| N_U64
)) != 0)
11872 *type
= NT_unsigned
;
11873 else if ((mask
& (N_I8
| N_I16
| N_I32
| N_I64
)) != 0)
11874 *type
= NT_integer
;
11875 else if ((mask
& (N_8
| N_16
| N_32
| N_64
)) != 0)
11876 *type
= NT_untyped
;
11877 else if ((mask
& (N_P8
| N_P16
)) != 0)
11879 else if ((mask
& (N_F32
| N_F64
)) != 0)
11887 /* Modify a bitmask of allowed types. This is only needed for type
11891 modify_types_allowed (unsigned allowed
, unsigned mods
)
11894 enum neon_el_type type
;
11900 for (i
= 1; i
<= N_MAX_NONSPECIAL
; i
<<= 1)
11902 if (el_type_of_type_chk (&type
, &size
,
11903 (enum neon_type_mask
) (allowed
& i
)) == SUCCESS
)
11905 neon_modify_type_size (mods
, &type
, &size
);
11906 destmask
|= type_chk_of_el_type (type
, size
);
11913 /* Check type and return type classification.
11914 The manual states (paraphrase): If one datatype is given, it indicates the
11916 - the second operand, if there is one
11917 - the operand, if there is no second operand
11918 - the result, if there are no operands.
11919 This isn't quite good enough though, so we use a concept of a "key" datatype
11920 which is set on a per-instruction basis, which is the one which matters when
11921 only one data type is written.
11922 Note: this function has side-effects (e.g. filling in missing operands). All
11923 Neon instructions should call it before performing bit encoding. */
11925 static struct neon_type_el
11926 neon_check_type (unsigned els
, enum neon_shape ns
, ...)
11929 unsigned i
, pass
, key_el
= 0;
11930 unsigned types
[NEON_MAX_TYPE_ELS
];
11931 enum neon_el_type k_type
= NT_invtype
;
11932 unsigned k_size
= -1u;
11933 struct neon_type_el badtype
= {NT_invtype
, -1};
11934 unsigned key_allowed
= 0;
11936 /* Optional registers in Neon instructions are always (not) in operand 1.
11937 Fill in the missing operand here, if it was omitted. */
11938 if (els
> 1 && !inst
.operands
[1].present
)
11939 inst
.operands
[1] = inst
.operands
[0];
11941 /* Suck up all the varargs. */
11943 for (i
= 0; i
< els
; i
++)
11945 unsigned thisarg
= va_arg (ap
, unsigned);
11946 if (thisarg
== N_IGNORE_TYPE
)
11951 types
[i
] = thisarg
;
11952 if ((thisarg
& N_KEY
) != 0)
11957 if (inst
.vectype
.elems
> 0)
11958 for (i
= 0; i
< els
; i
++)
11959 if (inst
.operands
[i
].vectype
.type
!= NT_invtype
)
11961 first_error (_("types specified in both the mnemonic and operands"));
11965 /* Duplicate inst.vectype elements here as necessary.
11966 FIXME: No idea if this is exactly the same as the ARM assembler,
11967 particularly when an insn takes one register and one non-register
11969 if (inst
.vectype
.elems
== 1 && els
> 1)
11972 inst
.vectype
.elems
= els
;
11973 inst
.vectype
.el
[key_el
] = inst
.vectype
.el
[0];
11974 for (j
= 0; j
< els
; j
++)
11976 inst
.vectype
.el
[j
] = neon_type_promote (&inst
.vectype
.el
[key_el
],
11979 else if (inst
.vectype
.elems
== 0 && els
> 0)
11982 /* No types were given after the mnemonic, so look for types specified
11983 after each operand. We allow some flexibility here; as long as the
11984 "key" operand has a type, we can infer the others. */
11985 for (j
= 0; j
< els
; j
++)
11986 if (inst
.operands
[j
].vectype
.type
!= NT_invtype
)
11987 inst
.vectype
.el
[j
] = inst
.operands
[j
].vectype
;
11989 if (inst
.operands
[key_el
].vectype
.type
!= NT_invtype
)
11991 for (j
= 0; j
< els
; j
++)
11992 if (inst
.operands
[j
].vectype
.type
== NT_invtype
)
11993 inst
.vectype
.el
[j
] = neon_type_promote (&inst
.vectype
.el
[key_el
],
11998 first_error (_("operand types can't be inferred"));
12002 else if (inst
.vectype
.elems
!= els
)
12004 first_error (_("type specifier has the wrong number of parts"));
12008 for (pass
= 0; pass
< 2; pass
++)
12010 for (i
= 0; i
< els
; i
++)
12012 unsigned thisarg
= types
[i
];
12013 unsigned types_allowed
= ((thisarg
& N_EQK
) != 0 && pass
!= 0)
12014 ? modify_types_allowed (key_allowed
, thisarg
) : thisarg
;
12015 enum neon_el_type g_type
= inst
.vectype
.el
[i
].type
;
12016 unsigned g_size
= inst
.vectype
.el
[i
].size
;
12018 /* Decay more-specific signed & unsigned types to sign-insensitive
12019 integer types if sign-specific variants are unavailable. */
12020 if ((g_type
== NT_signed
|| g_type
== NT_unsigned
)
12021 && (types_allowed
& N_SU_ALL
) == 0)
12022 g_type
= NT_integer
;
12024 /* If only untyped args are allowed, decay any more specific types to
12025 them. Some instructions only care about signs for some element
12026 sizes, so handle that properly. */
12027 if ((g_size
== 8 && (types_allowed
& N_8
) != 0)
12028 || (g_size
== 16 && (types_allowed
& N_16
) != 0)
12029 || (g_size
== 32 && (types_allowed
& N_32
) != 0)
12030 || (g_size
== 64 && (types_allowed
& N_64
) != 0))
12031 g_type
= NT_untyped
;
12035 if ((thisarg
& N_KEY
) != 0)
12039 key_allowed
= thisarg
& ~N_KEY
;
12044 if ((thisarg
& N_VFP
) != 0)
12046 enum neon_shape_el regshape
= neon_shape_tab
[ns
].el
[i
];
12047 unsigned regwidth
= neon_shape_el_size
[regshape
], match
;
12049 /* In VFP mode, operands must match register widths. If we
12050 have a key operand, use its width, else use the width of
12051 the current operand. */
12057 if (regwidth
!= match
)
12059 first_error (_("operand size must match register width"));
12064 if ((thisarg
& N_EQK
) == 0)
12066 unsigned given_type
= type_chk_of_el_type (g_type
, g_size
);
12068 if ((given_type
& types_allowed
) == 0)
12070 first_error (_("bad type in Neon instruction"));
12076 enum neon_el_type mod_k_type
= k_type
;
12077 unsigned mod_k_size
= k_size
;
12078 neon_modify_type_size (thisarg
, &mod_k_type
, &mod_k_size
);
12079 if (g_type
!= mod_k_type
|| g_size
!= mod_k_size
)
12081 first_error (_("inconsistent types in Neon instruction"));
12089 return inst
.vectype
.el
[key_el
];
12092 /* Neon-style VFP instruction forwarding. */
12094 /* Thumb VFP instructions have 0xE in the condition field. */
12097 do_vfp_cond_or_thumb (void)
12102 inst
.instruction
|= 0xe0000000;
12104 inst
.instruction
|= inst
.cond
<< 28;
12107 /* Look up and encode a simple mnemonic, for use as a helper function for the
12108 Neon-style VFP syntax. This avoids duplication of bits of the insns table,
12109 etc. It is assumed that operand parsing has already been done, and that the
12110 operands are in the form expected by the given opcode (this isn't necessarily
12111 the same as the form in which they were parsed, hence some massaging must
12112 take place before this function is called).
12113 Checks current arch version against that in the looked-up opcode. */
12116 do_vfp_nsyn_opcode (const char *opname
)
12118 const struct asm_opcode
*opcode
;
12120 opcode
= (const struct asm_opcode
*) hash_find (arm_ops_hsh
, opname
);
12125 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
,
12126 thumb_mode
? *opcode
->tvariant
: *opcode
->avariant
),
12133 inst
.instruction
= opcode
->tvalue
;
12134 opcode
->tencode ();
12138 inst
.instruction
= (inst
.cond
<< 28) | opcode
->avalue
;
12139 opcode
->aencode ();
12144 do_vfp_nsyn_add_sub (enum neon_shape rs
)
12146 int is_add
= (inst
.instruction
& 0x0fffffff) == N_MNEM_vadd
;
12151 do_vfp_nsyn_opcode ("fadds");
12153 do_vfp_nsyn_opcode ("fsubs");
12158 do_vfp_nsyn_opcode ("faddd");
12160 do_vfp_nsyn_opcode ("fsubd");
12164 /* Check operand types to see if this is a VFP instruction, and if so call
12168 try_vfp_nsyn (int args
, void (*pfn
) (enum neon_shape
))
12170 enum neon_shape rs
;
12171 struct neon_type_el et
;
12176 rs
= neon_select_shape (NS_FF
, NS_DD
, NS_NULL
);
12177 et
= neon_check_type (2, rs
,
12178 N_EQK
| N_VFP
, N_F32
| N_F64
| N_KEY
| N_VFP
);
12182 rs
= neon_select_shape (NS_FFF
, NS_DDD
, NS_NULL
);
12183 et
= neon_check_type (3, rs
,
12184 N_EQK
| N_VFP
, N_EQK
| N_VFP
, N_F32
| N_F64
| N_KEY
| N_VFP
);
12191 if (et
.type
!= NT_invtype
)
12203 do_vfp_nsyn_mla_mls (enum neon_shape rs
)
12205 int is_mla
= (inst
.instruction
& 0x0fffffff) == N_MNEM_vmla
;
12210 do_vfp_nsyn_opcode ("fmacs");
12212 do_vfp_nsyn_opcode ("fnmacs");
12217 do_vfp_nsyn_opcode ("fmacd");
12219 do_vfp_nsyn_opcode ("fnmacd");
12224 do_vfp_nsyn_fma_fms (enum neon_shape rs
)
12226 int is_fma
= (inst
.instruction
& 0x0fffffff) == N_MNEM_vfma
;
12231 do_vfp_nsyn_opcode ("ffmas");
12233 do_vfp_nsyn_opcode ("ffnmas");
12238 do_vfp_nsyn_opcode ("ffmad");
12240 do_vfp_nsyn_opcode ("ffnmad");
12245 do_vfp_nsyn_mul (enum neon_shape rs
)
12248 do_vfp_nsyn_opcode ("fmuls");
12250 do_vfp_nsyn_opcode ("fmuld");
12254 do_vfp_nsyn_abs_neg (enum neon_shape rs
)
12256 int is_neg
= (inst
.instruction
& 0x80) != 0;
12257 neon_check_type (2, rs
, N_EQK
| N_VFP
, N_F32
| N_F64
| N_VFP
| N_KEY
);
12262 do_vfp_nsyn_opcode ("fnegs");
12264 do_vfp_nsyn_opcode ("fabss");
12269 do_vfp_nsyn_opcode ("fnegd");
12271 do_vfp_nsyn_opcode ("fabsd");
12275 /* Encode single-precision (only!) VFP fldm/fstm instructions. Double precision
12276 insns belong to Neon, and are handled elsewhere. */
12279 do_vfp_nsyn_ldm_stm (int is_dbmode
)
12281 int is_ldm
= (inst
.instruction
& (1 << 20)) != 0;
12285 do_vfp_nsyn_opcode ("fldmdbs");
12287 do_vfp_nsyn_opcode ("fldmias");
12292 do_vfp_nsyn_opcode ("fstmdbs");
12294 do_vfp_nsyn_opcode ("fstmias");
12299 do_vfp_nsyn_sqrt (void)
12301 enum neon_shape rs
= neon_select_shape (NS_FF
, NS_DD
, NS_NULL
);
12302 neon_check_type (2, rs
, N_EQK
| N_VFP
, N_F32
| N_F64
| N_KEY
| N_VFP
);
12305 do_vfp_nsyn_opcode ("fsqrts");
12307 do_vfp_nsyn_opcode ("fsqrtd");
12311 do_vfp_nsyn_div (void)
12313 enum neon_shape rs
= neon_select_shape (NS_FFF
, NS_DDD
, NS_NULL
);
12314 neon_check_type (3, rs
, N_EQK
| N_VFP
, N_EQK
| N_VFP
,
12315 N_F32
| N_F64
| N_KEY
| N_VFP
);
12318 do_vfp_nsyn_opcode ("fdivs");
12320 do_vfp_nsyn_opcode ("fdivd");
12324 do_vfp_nsyn_nmul (void)
12326 enum neon_shape rs
= neon_select_shape (NS_FFF
, NS_DDD
, NS_NULL
);
12327 neon_check_type (3, rs
, N_EQK
| N_VFP
, N_EQK
| N_VFP
,
12328 N_F32
| N_F64
| N_KEY
| N_VFP
);
12332 NEON_ENCODE (SINGLE
, inst
);
12333 do_vfp_sp_dyadic ();
12337 NEON_ENCODE (DOUBLE
, inst
);
12338 do_vfp_dp_rd_rn_rm ();
12340 do_vfp_cond_or_thumb ();
12344 do_vfp_nsyn_cmp (void)
12346 if (inst
.operands
[1].isreg
)
12348 enum neon_shape rs
= neon_select_shape (NS_FF
, NS_DD
, NS_NULL
);
12349 neon_check_type (2, rs
, N_EQK
| N_VFP
, N_F32
| N_F64
| N_KEY
| N_VFP
);
12353 NEON_ENCODE (SINGLE
, inst
);
12354 do_vfp_sp_monadic ();
12358 NEON_ENCODE (DOUBLE
, inst
);
12359 do_vfp_dp_rd_rm ();
12364 enum neon_shape rs
= neon_select_shape (NS_FI
, NS_DI
, NS_NULL
);
12365 neon_check_type (2, rs
, N_F32
| N_F64
| N_KEY
| N_VFP
, N_EQK
);
12367 switch (inst
.instruction
& 0x0fffffff)
12370 inst
.instruction
+= N_MNEM_vcmpz
- N_MNEM_vcmp
;
12373 inst
.instruction
+= N_MNEM_vcmpez
- N_MNEM_vcmpe
;
12381 NEON_ENCODE (SINGLE
, inst
);
12382 do_vfp_sp_compare_z ();
12386 NEON_ENCODE (DOUBLE
, inst
);
12390 do_vfp_cond_or_thumb ();
12394 nsyn_insert_sp (void)
12396 inst
.operands
[1] = inst
.operands
[0];
12397 memset (&inst
.operands
[0], '\0', sizeof (inst
.operands
[0]));
12398 inst
.operands
[0].reg
= REG_SP
;
12399 inst
.operands
[0].isreg
= 1;
12400 inst
.operands
[0].writeback
= 1;
12401 inst
.operands
[0].present
= 1;
12405 do_vfp_nsyn_push (void)
12408 if (inst
.operands
[1].issingle
)
12409 do_vfp_nsyn_opcode ("fstmdbs");
12411 do_vfp_nsyn_opcode ("fstmdbd");
12415 do_vfp_nsyn_pop (void)
12418 if (inst
.operands
[1].issingle
)
12419 do_vfp_nsyn_opcode ("fldmias");
12421 do_vfp_nsyn_opcode ("fldmiad");
12424 /* Fix up Neon data-processing instructions, ORing in the correct bits for
12425 ARM mode or Thumb mode and moving the encoded bit 24 to bit 28. */
12428 neon_dp_fixup (struct arm_it
* insn
)
12430 unsigned int i
= insn
->instruction
;
12435 /* The U bit is at bit 24 by default. Move to bit 28 in Thumb mode. */
12446 insn
->instruction
= i
;
12449 /* Turn a size (8, 16, 32, 64) into the respective bit number minus 3
12453 neon_logbits (unsigned x
)
12455 return ffs (x
) - 4;
12458 #define LOW4(R) ((R) & 0xf)
12459 #define HI1(R) (((R) >> 4) & 1)
12461 /* Encode insns with bit pattern:
12463 |28/24|23|22 |21 20|19 16|15 12|11 8|7|6|5|4|3 0|
12464 | U |x |D |size | Rn | Rd |x x x x|N|Q|M|x| Rm |
12466 SIZE is passed in bits. -1 means size field isn't changed, in case it has a
12467 different meaning for some instruction. */
12470 neon_three_same (int isquad
, int ubit
, int size
)
12472 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
12473 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
12474 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
12475 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
12476 inst
.instruction
|= LOW4 (inst
.operands
[2].reg
);
12477 inst
.instruction
|= HI1 (inst
.operands
[2].reg
) << 5;
12478 inst
.instruction
|= (isquad
!= 0) << 6;
12479 inst
.instruction
|= (ubit
!= 0) << 24;
12481 inst
.instruction
|= neon_logbits (size
) << 20;
12483 neon_dp_fixup (&inst
);
12486 /* Encode instructions of the form:
12488 |28/24|23|22|21 20|19 18|17 16|15 12|11 7|6|5|4|3 0|
12489 | U |x |D |x x |size |x x | Rd |x x x x x|Q|M|x| Rm |
12491 Don't write size if SIZE == -1. */
12494 neon_two_same (int qbit
, int ubit
, int size
)
12496 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
12497 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
12498 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
12499 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
12500 inst
.instruction
|= (qbit
!= 0) << 6;
12501 inst
.instruction
|= (ubit
!= 0) << 24;
12504 inst
.instruction
|= neon_logbits (size
) << 18;
12506 neon_dp_fixup (&inst
);
12509 /* Neon instruction encoders, in approximate order of appearance. */
12512 do_neon_dyadic_i_su (void)
12514 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12515 struct neon_type_el et
= neon_check_type (3, rs
,
12516 N_EQK
, N_EQK
, N_SU_32
| N_KEY
);
12517 neon_three_same (neon_quad (rs
), et
.type
== NT_unsigned
, et
.size
);
12521 do_neon_dyadic_i64_su (void)
12523 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12524 struct neon_type_el et
= neon_check_type (3, rs
,
12525 N_EQK
, N_EQK
, N_SU_ALL
| N_KEY
);
12526 neon_three_same (neon_quad (rs
), et
.type
== NT_unsigned
, et
.size
);
12530 neon_imm_shift (int write_ubit
, int uval
, int isquad
, struct neon_type_el et
,
12533 unsigned size
= et
.size
>> 3;
12534 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
12535 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
12536 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
12537 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
12538 inst
.instruction
|= (isquad
!= 0) << 6;
12539 inst
.instruction
|= immbits
<< 16;
12540 inst
.instruction
|= (size
>> 3) << 7;
12541 inst
.instruction
|= (size
& 0x7) << 19;
12543 inst
.instruction
|= (uval
!= 0) << 24;
12545 neon_dp_fixup (&inst
);
12549 do_neon_shl_imm (void)
12551 if (!inst
.operands
[2].isreg
)
12553 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
12554 struct neon_type_el et
= neon_check_type (2, rs
, N_EQK
, N_KEY
| N_I_ALL
);
12555 NEON_ENCODE (IMMED
, inst
);
12556 neon_imm_shift (FALSE
, 0, neon_quad (rs
), et
, inst
.operands
[2].imm
);
12560 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12561 struct neon_type_el et
= neon_check_type (3, rs
,
12562 N_EQK
, N_SU_ALL
| N_KEY
, N_EQK
| N_SGN
);
12565 /* VSHL/VQSHL 3-register variants have syntax such as:
12567 whereas other 3-register operations encoded by neon_three_same have
12570 (i.e. with Dn & Dm reversed). Swap operands[1].reg and operands[2].reg
12572 tmp
= inst
.operands
[2].reg
;
12573 inst
.operands
[2].reg
= inst
.operands
[1].reg
;
12574 inst
.operands
[1].reg
= tmp
;
12575 NEON_ENCODE (INTEGER
, inst
);
12576 neon_three_same (neon_quad (rs
), et
.type
== NT_unsigned
, et
.size
);
12581 do_neon_qshl_imm (void)
12583 if (!inst
.operands
[2].isreg
)
12585 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
12586 struct neon_type_el et
= neon_check_type (2, rs
, N_EQK
, N_SU_ALL
| N_KEY
);
12588 NEON_ENCODE (IMMED
, inst
);
12589 neon_imm_shift (TRUE
, et
.type
== NT_unsigned
, neon_quad (rs
), et
,
12590 inst
.operands
[2].imm
);
12594 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12595 struct neon_type_el et
= neon_check_type (3, rs
,
12596 N_EQK
, N_SU_ALL
| N_KEY
, N_EQK
| N_SGN
);
12599 /* See note in do_neon_shl_imm. */
12600 tmp
= inst
.operands
[2].reg
;
12601 inst
.operands
[2].reg
= inst
.operands
[1].reg
;
12602 inst
.operands
[1].reg
= tmp
;
12603 NEON_ENCODE (INTEGER
, inst
);
12604 neon_three_same (neon_quad (rs
), et
.type
== NT_unsigned
, et
.size
);
12609 do_neon_rshl (void)
12611 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12612 struct neon_type_el et
= neon_check_type (3, rs
,
12613 N_EQK
, N_EQK
, N_SU_ALL
| N_KEY
);
12616 tmp
= inst
.operands
[2].reg
;
12617 inst
.operands
[2].reg
= inst
.operands
[1].reg
;
12618 inst
.operands
[1].reg
= tmp
;
12619 neon_three_same (neon_quad (rs
), et
.type
== NT_unsigned
, et
.size
);
12623 neon_cmode_for_logic_imm (unsigned immediate
, unsigned *immbits
, int size
)
12625 /* Handle .I8 pseudo-instructions. */
12628 /* Unfortunately, this will make everything apart from zero out-of-range.
12629 FIXME is this the intended semantics? There doesn't seem much point in
12630 accepting .I8 if so. */
12631 immediate
|= immediate
<< 8;
12637 if (immediate
== (immediate
& 0x000000ff))
12639 *immbits
= immediate
;
12642 else if (immediate
== (immediate
& 0x0000ff00))
12644 *immbits
= immediate
>> 8;
12647 else if (immediate
== (immediate
& 0x00ff0000))
12649 *immbits
= immediate
>> 16;
12652 else if (immediate
== (immediate
& 0xff000000))
12654 *immbits
= immediate
>> 24;
12657 if ((immediate
& 0xffff) != (immediate
>> 16))
12658 goto bad_immediate
;
12659 immediate
&= 0xffff;
12662 if (immediate
== (immediate
& 0x000000ff))
12664 *immbits
= immediate
;
12667 else if (immediate
== (immediate
& 0x0000ff00))
12669 *immbits
= immediate
>> 8;
12674 first_error (_("immediate value out of range"));
12678 /* True if IMM has form 0bAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD for bits
12682 neon_bits_same_in_bytes (unsigned imm
)
12684 return ((imm
& 0x000000ff) == 0 || (imm
& 0x000000ff) == 0x000000ff)
12685 && ((imm
& 0x0000ff00) == 0 || (imm
& 0x0000ff00) == 0x0000ff00)
12686 && ((imm
& 0x00ff0000) == 0 || (imm
& 0x00ff0000) == 0x00ff0000)
12687 && ((imm
& 0xff000000) == 0 || (imm
& 0xff000000) == 0xff000000);
12690 /* For immediate of above form, return 0bABCD. */
12693 neon_squash_bits (unsigned imm
)
12695 return (imm
& 0x01) | ((imm
& 0x0100) >> 7) | ((imm
& 0x010000) >> 14)
12696 | ((imm
& 0x01000000) >> 21);
12699 /* Compress quarter-float representation to 0b...000 abcdefgh. */
12702 neon_qfloat_bits (unsigned imm
)
12704 return ((imm
>> 19) & 0x7f) | ((imm
>> 24) & 0x80);
12707 /* Returns CMODE. IMMBITS [7:0] is set to bits suitable for inserting into
12708 the instruction. *OP is passed as the initial value of the op field, and
12709 may be set to a different value depending on the constant (i.e.
12710 "MOV I64, 0bAAAAAAAABBBB..." which uses OP = 1 despite being MOV not
12711 MVN). If the immediate looks like a repeated pattern then also
12712 try smaller element sizes. */
12715 neon_cmode_for_move_imm (unsigned immlo
, unsigned immhi
, int float_p
,
12716 unsigned *immbits
, int *op
, int size
,
12717 enum neon_el_type type
)
12719 /* Only permit float immediates (including 0.0/-0.0) if the operand type is
12721 if (type
== NT_float
&& !float_p
)
12724 if (type
== NT_float
&& is_quarter_float (immlo
) && immhi
== 0)
12726 if (size
!= 32 || *op
== 1)
12728 *immbits
= neon_qfloat_bits (immlo
);
12734 if (neon_bits_same_in_bytes (immhi
)
12735 && neon_bits_same_in_bytes (immlo
))
12739 *immbits
= (neon_squash_bits (immhi
) << 4)
12740 | neon_squash_bits (immlo
);
12745 if (immhi
!= immlo
)
12751 if (immlo
== (immlo
& 0x000000ff))
12756 else if (immlo
== (immlo
& 0x0000ff00))
12758 *immbits
= immlo
>> 8;
12761 else if (immlo
== (immlo
& 0x00ff0000))
12763 *immbits
= immlo
>> 16;
12766 else if (immlo
== (immlo
& 0xff000000))
12768 *immbits
= immlo
>> 24;
12771 else if (immlo
== ((immlo
& 0x0000ff00) | 0x000000ff))
12773 *immbits
= (immlo
>> 8) & 0xff;
12776 else if (immlo
== ((immlo
& 0x00ff0000) | 0x0000ffff))
12778 *immbits
= (immlo
>> 16) & 0xff;
12782 if ((immlo
& 0xffff) != (immlo
>> 16))
12789 if (immlo
== (immlo
& 0x000000ff))
12794 else if (immlo
== (immlo
& 0x0000ff00))
12796 *immbits
= immlo
>> 8;
12800 if ((immlo
& 0xff) != (immlo
>> 8))
12805 if (immlo
== (immlo
& 0x000000ff))
12807 /* Don't allow MVN with 8-bit immediate. */
12817 /* Write immediate bits [7:0] to the following locations:
12819 |28/24|23 19|18 16|15 4|3 0|
12820 | 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|
12822 This function is used by VMOV/VMVN/VORR/VBIC. */
12825 neon_write_immbits (unsigned immbits
)
12827 inst
.instruction
|= immbits
& 0xf;
12828 inst
.instruction
|= ((immbits
>> 4) & 0x7) << 16;
12829 inst
.instruction
|= ((immbits
>> 7) & 0x1) << 24;
12832 /* Invert low-order SIZE bits of XHI:XLO. */
12835 neon_invert_size (unsigned *xlo
, unsigned *xhi
, int size
)
12837 unsigned immlo
= xlo
? *xlo
: 0;
12838 unsigned immhi
= xhi
? *xhi
: 0;
12843 immlo
= (~immlo
) & 0xff;
12847 immlo
= (~immlo
) & 0xffff;
12851 immhi
= (~immhi
) & 0xffffffff;
12852 /* fall through. */
12855 immlo
= (~immlo
) & 0xffffffff;
12870 do_neon_logic (void)
12872 if (inst
.operands
[2].present
&& inst
.operands
[2].isreg
)
12874 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12875 neon_check_type (3, rs
, N_IGNORE_TYPE
);
12876 /* U bit and size field were set as part of the bitmask. */
12877 NEON_ENCODE (INTEGER
, inst
);
12878 neon_three_same (neon_quad (rs
), 0, -1);
12882 const int three_ops_form
= (inst
.operands
[2].present
12883 && !inst
.operands
[2].isreg
);
12884 const int immoperand
= (three_ops_form
? 2 : 1);
12885 enum neon_shape rs
= (three_ops_form
12886 ? neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
)
12887 : neon_select_shape (NS_DI
, NS_QI
, NS_NULL
));
12888 struct neon_type_el et
= neon_check_type (2, rs
,
12889 N_I8
| N_I16
| N_I32
| N_I64
| N_F32
| N_KEY
, N_EQK
);
12890 enum neon_opc opcode
= (enum neon_opc
) inst
.instruction
& 0x0fffffff;
12894 if (et
.type
== NT_invtype
)
12897 if (three_ops_form
)
12898 constraint (inst
.operands
[0].reg
!= inst
.operands
[1].reg
,
12899 _("first and second operands shall be the same register"));
12901 NEON_ENCODE (IMMED
, inst
);
12903 immbits
= inst
.operands
[immoperand
].imm
;
12906 /* .i64 is a pseudo-op, so the immediate must be a repeating
12908 if (immbits
!= (inst
.operands
[immoperand
].regisimm
?
12909 inst
.operands
[immoperand
].reg
: 0))
12911 /* Set immbits to an invalid constant. */
12912 immbits
= 0xdeadbeef;
12919 cmode
= neon_cmode_for_logic_imm (immbits
, &immbits
, et
.size
);
12923 cmode
= neon_cmode_for_logic_imm (immbits
, &immbits
, et
.size
);
12927 /* Pseudo-instruction for VBIC. */
12928 neon_invert_size (&immbits
, 0, et
.size
);
12929 cmode
= neon_cmode_for_logic_imm (immbits
, &immbits
, et
.size
);
12933 /* Pseudo-instruction for VORR. */
12934 neon_invert_size (&immbits
, 0, et
.size
);
12935 cmode
= neon_cmode_for_logic_imm (immbits
, &immbits
, et
.size
);
12945 inst
.instruction
|= neon_quad (rs
) << 6;
12946 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
12947 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
12948 inst
.instruction
|= cmode
<< 8;
12949 neon_write_immbits (immbits
);
12951 neon_dp_fixup (&inst
);
12956 do_neon_bitfield (void)
12958 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12959 neon_check_type (3, rs
, N_IGNORE_TYPE
);
12960 neon_three_same (neon_quad (rs
), 0, -1);
12964 neon_dyadic_misc (enum neon_el_type ubit_meaning
, unsigned types
,
12967 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12968 struct neon_type_el et
= neon_check_type (3, rs
, N_EQK
| destbits
, N_EQK
,
12970 if (et
.type
== NT_float
)
12972 NEON_ENCODE (FLOAT
, inst
);
12973 neon_three_same (neon_quad (rs
), 0, -1);
12977 NEON_ENCODE (INTEGER
, inst
);
12978 neon_three_same (neon_quad (rs
), et
.type
== ubit_meaning
, et
.size
);
12983 do_neon_dyadic_if_su (void)
12985 neon_dyadic_misc (NT_unsigned
, N_SUF_32
, 0);
12989 do_neon_dyadic_if_su_d (void)
12991 /* This version only allow D registers, but that constraint is enforced during
12992 operand parsing so we don't need to do anything extra here. */
12993 neon_dyadic_misc (NT_unsigned
, N_SUF_32
, 0);
12997 do_neon_dyadic_if_i_d (void)
12999 /* The "untyped" case can't happen. Do this to stop the "U" bit being
13000 affected if we specify unsigned args. */
13001 neon_dyadic_misc (NT_untyped
, N_IF_32
, 0);
13004 enum vfp_or_neon_is_neon_bits
13007 NEON_CHECK_ARCH
= 2
13010 /* Call this function if an instruction which may have belonged to the VFP or
13011 Neon instruction sets, but turned out to be a Neon instruction (due to the
13012 operand types involved, etc.). We have to check and/or fix-up a couple of
13015 - Make sure the user hasn't attempted to make a Neon instruction
13017 - Alter the value in the condition code field if necessary.
13018 - Make sure that the arch supports Neon instructions.
13020 Which of these operations take place depends on bits from enum
13021 vfp_or_neon_is_neon_bits.
13023 WARNING: This function has side effects! If NEON_CHECK_CC is used and the
13024 current instruction's condition is COND_ALWAYS, the condition field is
13025 changed to inst.uncond_value. This is necessary because instructions shared
13026 between VFP and Neon may be conditional for the VFP variants only, and the
13027 unconditional Neon version must have, e.g., 0xF in the condition field. */
13030 vfp_or_neon_is_neon (unsigned check
)
13032 /* Conditions are always legal in Thumb mode (IT blocks). */
13033 if (!thumb_mode
&& (check
& NEON_CHECK_CC
))
13035 if (inst
.cond
!= COND_ALWAYS
)
13037 first_error (_(BAD_COND
));
13040 if (inst
.uncond_value
!= -1)
13041 inst
.instruction
|= inst
.uncond_value
<< 28;
13044 if ((check
& NEON_CHECK_ARCH
)
13045 && !ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_neon_ext_v1
))
13047 first_error (_(BAD_FPU
));
13055 do_neon_addsub_if_i (void)
13057 if (try_vfp_nsyn (3, do_vfp_nsyn_add_sub
) == SUCCESS
)
13060 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13063 /* The "untyped" case can't happen. Do this to stop the "U" bit being
13064 affected if we specify unsigned args. */
13065 neon_dyadic_misc (NT_untyped
, N_IF_32
| N_I64
, 0);
13068 /* Swaps operands 1 and 2. If operand 1 (optional arg) was omitted, we want the
13070 V<op> A,B (A is operand 0, B is operand 2)
13075 so handle that case specially. */
13078 neon_exchange_operands (void)
13080 void *scratch
= alloca (sizeof (inst
.operands
[0]));
13081 if (inst
.operands
[1].present
)
13083 /* Swap operands[1] and operands[2]. */
13084 memcpy (scratch
, &inst
.operands
[1], sizeof (inst
.operands
[0]));
13085 inst
.operands
[1] = inst
.operands
[2];
13086 memcpy (&inst
.operands
[2], scratch
, sizeof (inst
.operands
[0]));
13090 inst
.operands
[1] = inst
.operands
[2];
13091 inst
.operands
[2] = inst
.operands
[0];
13096 neon_compare (unsigned regtypes
, unsigned immtypes
, int invert
)
13098 if (inst
.operands
[2].isreg
)
13101 neon_exchange_operands ();
13102 neon_dyadic_misc (NT_unsigned
, regtypes
, N_SIZ
);
13106 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
13107 struct neon_type_el et
= neon_check_type (2, rs
,
13108 N_EQK
| N_SIZ
, immtypes
| N_KEY
);
13110 NEON_ENCODE (IMMED
, inst
);
13111 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13112 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13113 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13114 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13115 inst
.instruction
|= neon_quad (rs
) << 6;
13116 inst
.instruction
|= (et
.type
== NT_float
) << 10;
13117 inst
.instruction
|= neon_logbits (et
.size
) << 18;
13119 neon_dp_fixup (&inst
);
13126 neon_compare (N_SUF_32
, N_S8
| N_S16
| N_S32
| N_F32
, FALSE
);
13130 do_neon_cmp_inv (void)
13132 neon_compare (N_SUF_32
, N_S8
| N_S16
| N_S32
| N_F32
, TRUE
);
13138 neon_compare (N_IF_32
, N_IF_32
, FALSE
);
13141 /* For multiply instructions, we have the possibility of 16-bit or 32-bit
13142 scalars, which are encoded in 5 bits, M : Rm.
13143 For 16-bit scalars, the register is encoded in Rm[2:0] and the index in
13144 M:Rm[3], and for 32-bit scalars, the register is encoded in Rm[3:0] and the
13148 neon_scalar_for_mul (unsigned scalar
, unsigned elsize
)
13150 unsigned regno
= NEON_SCALAR_REG (scalar
);
13151 unsigned elno
= NEON_SCALAR_INDEX (scalar
);
13156 if (regno
> 7 || elno
> 3)
13158 return regno
| (elno
<< 3);
13161 if (regno
> 15 || elno
> 1)
13163 return regno
| (elno
<< 4);
13167 first_error (_("scalar out of range for multiply instruction"));
13173 /* Encode multiply / multiply-accumulate scalar instructions. */
13176 neon_mul_mac (struct neon_type_el et
, int ubit
)
13180 /* Give a more helpful error message if we have an invalid type. */
13181 if (et
.type
== NT_invtype
)
13184 scalar
= neon_scalar_for_mul (inst
.operands
[2].reg
, et
.size
);
13185 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13186 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13187 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
13188 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
13189 inst
.instruction
|= LOW4 (scalar
);
13190 inst
.instruction
|= HI1 (scalar
) << 5;
13191 inst
.instruction
|= (et
.type
== NT_float
) << 8;
13192 inst
.instruction
|= neon_logbits (et
.size
) << 20;
13193 inst
.instruction
|= (ubit
!= 0) << 24;
13195 neon_dp_fixup (&inst
);
13199 do_neon_mac_maybe_scalar (void)
13201 if (try_vfp_nsyn (3, do_vfp_nsyn_mla_mls
) == SUCCESS
)
13204 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13207 if (inst
.operands
[2].isscalar
)
13209 enum neon_shape rs
= neon_select_shape (NS_DDS
, NS_QQS
, NS_NULL
);
13210 struct neon_type_el et
= neon_check_type (3, rs
,
13211 N_EQK
, N_EQK
, N_I16
| N_I32
| N_F32
| N_KEY
);
13212 NEON_ENCODE (SCALAR
, inst
);
13213 neon_mul_mac (et
, neon_quad (rs
));
13217 /* The "untyped" case can't happen. Do this to stop the "U" bit being
13218 affected if we specify unsigned args. */
13219 neon_dyadic_misc (NT_untyped
, N_IF_32
, 0);
13224 do_neon_fmac (void)
13226 if (try_vfp_nsyn (3, do_vfp_nsyn_fma_fms
) == SUCCESS
)
13229 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13232 neon_dyadic_misc (NT_untyped
, N_IF_32
, 0);
13238 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
13239 struct neon_type_el et
= neon_check_type (3, rs
,
13240 N_EQK
, N_EQK
, N_8
| N_16
| N_32
| N_KEY
);
13241 neon_three_same (neon_quad (rs
), 0, et
.size
);
13244 /* VMUL with 3 registers allows the P8 type. The scalar version supports the
13245 same types as the MAC equivalents. The polynomial type for this instruction
13246 is encoded the same as the integer type. */
13251 if (try_vfp_nsyn (3, do_vfp_nsyn_mul
) == SUCCESS
)
13254 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13257 if (inst
.operands
[2].isscalar
)
13258 do_neon_mac_maybe_scalar ();
13260 neon_dyadic_misc (NT_poly
, N_I8
| N_I16
| N_I32
| N_F32
| N_P8
, 0);
13264 do_neon_qdmulh (void)
13266 if (inst
.operands
[2].isscalar
)
13268 enum neon_shape rs
= neon_select_shape (NS_DDS
, NS_QQS
, NS_NULL
);
13269 struct neon_type_el et
= neon_check_type (3, rs
,
13270 N_EQK
, N_EQK
, N_S16
| N_S32
| N_KEY
);
13271 NEON_ENCODE (SCALAR
, inst
);
13272 neon_mul_mac (et
, neon_quad (rs
));
13276 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
13277 struct neon_type_el et
= neon_check_type (3, rs
,
13278 N_EQK
, N_EQK
, N_S16
| N_S32
| N_KEY
);
13279 NEON_ENCODE (INTEGER
, inst
);
13280 /* The U bit (rounding) comes from bit mask. */
13281 neon_three_same (neon_quad (rs
), 0, et
.size
);
13286 do_neon_fcmp_absolute (void)
13288 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
13289 neon_check_type (3, rs
, N_EQK
, N_EQK
, N_F32
| N_KEY
);
13290 /* Size field comes from bit mask. */
13291 neon_three_same (neon_quad (rs
), 1, -1);
13295 do_neon_fcmp_absolute_inv (void)
13297 neon_exchange_operands ();
13298 do_neon_fcmp_absolute ();
13302 do_neon_step (void)
13304 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
13305 neon_check_type (3, rs
, N_EQK
, N_EQK
, N_F32
| N_KEY
);
13306 neon_three_same (neon_quad (rs
), 0, -1);
13310 do_neon_abs_neg (void)
13312 enum neon_shape rs
;
13313 struct neon_type_el et
;
13315 if (try_vfp_nsyn (2, do_vfp_nsyn_abs_neg
) == SUCCESS
)
13318 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13321 rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
13322 et
= neon_check_type (2, rs
, N_EQK
, N_S8
| N_S16
| N_S32
| N_F32
| N_KEY
);
13324 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13325 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13326 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13327 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13328 inst
.instruction
|= neon_quad (rs
) << 6;
13329 inst
.instruction
|= (et
.type
== NT_float
) << 10;
13330 inst
.instruction
|= neon_logbits (et
.size
) << 18;
13332 neon_dp_fixup (&inst
);
13338 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
13339 struct neon_type_el et
= neon_check_type (2, rs
,
13340 N_EQK
, N_8
| N_16
| N_32
| N_64
| N_KEY
);
13341 int imm
= inst
.operands
[2].imm
;
13342 constraint (imm
< 0 || (unsigned)imm
>= et
.size
,
13343 _("immediate out of range for insert"));
13344 neon_imm_shift (FALSE
, 0, neon_quad (rs
), et
, imm
);
13350 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
13351 struct neon_type_el et
= neon_check_type (2, rs
,
13352 N_EQK
, N_8
| N_16
| N_32
| N_64
| N_KEY
);
13353 int imm
= inst
.operands
[2].imm
;
13354 constraint (imm
< 1 || (unsigned)imm
> et
.size
,
13355 _("immediate out of range for insert"));
13356 neon_imm_shift (FALSE
, 0, neon_quad (rs
), et
, et
.size
- imm
);
13360 do_neon_qshlu_imm (void)
13362 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
13363 struct neon_type_el et
= neon_check_type (2, rs
,
13364 N_EQK
| N_UNS
, N_S8
| N_S16
| N_S32
| N_S64
| N_KEY
);
13365 int imm
= inst
.operands
[2].imm
;
13366 constraint (imm
< 0 || (unsigned)imm
>= et
.size
,
13367 _("immediate out of range for shift"));
13368 /* Only encodes the 'U present' variant of the instruction.
13369 In this case, signed types have OP (bit 8) set to 0.
13370 Unsigned types have OP set to 1. */
13371 inst
.instruction
|= (et
.type
== NT_unsigned
) << 8;
13372 /* The rest of the bits are the same as other immediate shifts. */
13373 neon_imm_shift (FALSE
, 0, neon_quad (rs
), et
, imm
);
13377 do_neon_qmovn (void)
13379 struct neon_type_el et
= neon_check_type (2, NS_DQ
,
13380 N_EQK
| N_HLF
, N_SU_16_64
| N_KEY
);
13381 /* Saturating move where operands can be signed or unsigned, and the
13382 destination has the same signedness. */
13383 NEON_ENCODE (INTEGER
, inst
);
13384 if (et
.type
== NT_unsigned
)
13385 inst
.instruction
|= 0xc0;
13387 inst
.instruction
|= 0x80;
13388 neon_two_same (0, 1, et
.size
/ 2);
13392 do_neon_qmovun (void)
13394 struct neon_type_el et
= neon_check_type (2, NS_DQ
,
13395 N_EQK
| N_HLF
| N_UNS
, N_S16
| N_S32
| N_S64
| N_KEY
);
13396 /* Saturating move with unsigned results. Operands must be signed. */
13397 NEON_ENCODE (INTEGER
, inst
);
13398 neon_two_same (0, 1, et
.size
/ 2);
13402 do_neon_rshift_sat_narrow (void)
13404 /* FIXME: Types for narrowing. If operands are signed, results can be signed
13405 or unsigned. If operands are unsigned, results must also be unsigned. */
13406 struct neon_type_el et
= neon_check_type (2, NS_DQI
,
13407 N_EQK
| N_HLF
, N_SU_16_64
| N_KEY
);
13408 int imm
= inst
.operands
[2].imm
;
13409 /* This gets the bounds check, size encoding and immediate bits calculation
13413 /* VQ{R}SHRN.I<size> <Dd>, <Qm>, #0 is a synonym for
13414 VQMOVN.I<size> <Dd>, <Qm>. */
13417 inst
.operands
[2].present
= 0;
13418 inst
.instruction
= N_MNEM_vqmovn
;
13423 constraint (imm
< 1 || (unsigned)imm
> et
.size
,
13424 _("immediate out of range"));
13425 neon_imm_shift (TRUE
, et
.type
== NT_unsigned
, 0, et
, et
.size
- imm
);
13429 do_neon_rshift_sat_narrow_u (void)
13431 /* FIXME: Types for narrowing. If operands are signed, results can be signed
13432 or unsigned. If operands are unsigned, results must also be unsigned. */
13433 struct neon_type_el et
= neon_check_type (2, NS_DQI
,
13434 N_EQK
| N_HLF
| N_UNS
, N_S16
| N_S32
| N_S64
| N_KEY
);
13435 int imm
= inst
.operands
[2].imm
;
13436 /* This gets the bounds check, size encoding and immediate bits calculation
13440 /* VQSHRUN.I<size> <Dd>, <Qm>, #0 is a synonym for
13441 VQMOVUN.I<size> <Dd>, <Qm>. */
13444 inst
.operands
[2].present
= 0;
13445 inst
.instruction
= N_MNEM_vqmovun
;
13450 constraint (imm
< 1 || (unsigned)imm
> et
.size
,
13451 _("immediate out of range"));
13452 /* FIXME: The manual is kind of unclear about what value U should have in
13453 VQ{R}SHRUN instructions, but U=0, op=0 definitely encodes VRSHR, so it
13455 neon_imm_shift (TRUE
, 1, 0, et
, et
.size
- imm
);
13459 do_neon_movn (void)
13461 struct neon_type_el et
= neon_check_type (2, NS_DQ
,
13462 N_EQK
| N_HLF
, N_I16
| N_I32
| N_I64
| N_KEY
);
13463 NEON_ENCODE (INTEGER
, inst
);
13464 neon_two_same (0, 1, et
.size
/ 2);
13468 do_neon_rshift_narrow (void)
13470 struct neon_type_el et
= neon_check_type (2, NS_DQI
,
13471 N_EQK
| N_HLF
, N_I16
| N_I32
| N_I64
| N_KEY
);
13472 int imm
= inst
.operands
[2].imm
;
13473 /* This gets the bounds check, size encoding and immediate bits calculation
13477 /* If immediate is zero then we are a pseudo-instruction for
13478 VMOVN.I<size> <Dd>, <Qm> */
13481 inst
.operands
[2].present
= 0;
13482 inst
.instruction
= N_MNEM_vmovn
;
13487 constraint (imm
< 1 || (unsigned)imm
> et
.size
,
13488 _("immediate out of range for narrowing operation"));
13489 neon_imm_shift (FALSE
, 0, 0, et
, et
.size
- imm
);
13493 do_neon_shll (void)
13495 /* FIXME: Type checking when lengthening. */
13496 struct neon_type_el et
= neon_check_type (2, NS_QDI
,
13497 N_EQK
| N_DBL
, N_I8
| N_I16
| N_I32
| N_KEY
);
13498 unsigned imm
= inst
.operands
[2].imm
;
13500 if (imm
== et
.size
)
13502 /* Maximum shift variant. */
13503 NEON_ENCODE (INTEGER
, inst
);
13504 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13505 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13506 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13507 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13508 inst
.instruction
|= neon_logbits (et
.size
) << 18;
13510 neon_dp_fixup (&inst
);
13514 /* A more-specific type check for non-max versions. */
13515 et
= neon_check_type (2, NS_QDI
,
13516 N_EQK
| N_DBL
, N_SU_32
| N_KEY
);
13517 NEON_ENCODE (IMMED
, inst
);
13518 neon_imm_shift (TRUE
, et
.type
== NT_unsigned
, 0, et
, imm
);
13522 /* Check the various types for the VCVT instruction, and return which version
13523 the current instruction is. */
13526 neon_cvt_flavour (enum neon_shape rs
)
13528 #define CVT_VAR(C,X,Y) \
13529 et = neon_check_type (2, rs, whole_reg | (X), whole_reg | (Y)); \
13530 if (et.type != NT_invtype) \
13532 inst.error = NULL; \
13535 struct neon_type_el et
;
13536 unsigned whole_reg
= (rs
== NS_FFI
|| rs
== NS_FD
|| rs
== NS_DF
13537 || rs
== NS_FF
) ? N_VFP
: 0;
13538 /* The instruction versions which take an immediate take one register
13539 argument, which is extended to the width of the full register. Thus the
13540 "source" and "destination" registers must have the same width. Hack that
13541 here by making the size equal to the key (wider, in this case) operand. */
13542 unsigned key
= (rs
== NS_QQI
|| rs
== NS_DDI
|| rs
== NS_FFI
) ? N_KEY
: 0;
13544 CVT_VAR (0, N_S32
, N_F32
);
13545 CVT_VAR (1, N_U32
, N_F32
);
13546 CVT_VAR (2, N_F32
, N_S32
);
13547 CVT_VAR (3, N_F32
, N_U32
);
13548 /* Half-precision conversions. */
13549 CVT_VAR (4, N_F32
, N_F16
);
13550 CVT_VAR (5, N_F16
, N_F32
);
13554 /* VFP instructions. */
13555 CVT_VAR (6, N_F32
, N_F64
);
13556 CVT_VAR (7, N_F64
, N_F32
);
13557 CVT_VAR (8, N_S32
, N_F64
| key
);
13558 CVT_VAR (9, N_U32
, N_F64
| key
);
13559 CVT_VAR (10, N_F64
| key
, N_S32
);
13560 CVT_VAR (11, N_F64
| key
, N_U32
);
13561 /* VFP instructions with bitshift. */
13562 CVT_VAR (12, N_F32
| key
, N_S16
);
13563 CVT_VAR (13, N_F32
| key
, N_U16
);
13564 CVT_VAR (14, N_F64
| key
, N_S16
);
13565 CVT_VAR (15, N_F64
| key
, N_U16
);
13566 CVT_VAR (16, N_S16
, N_F32
| key
);
13567 CVT_VAR (17, N_U16
, N_F32
| key
);
13568 CVT_VAR (18, N_S16
, N_F64
| key
);
13569 CVT_VAR (19, N_U16
, N_F64
| key
);
13575 /* Neon-syntax VFP conversions. */
13578 do_vfp_nsyn_cvt (enum neon_shape rs
, int flavour
)
13580 const char *opname
= 0;
13582 if (rs
== NS_DDI
|| rs
== NS_QQI
|| rs
== NS_FFI
)
13584 /* Conversions with immediate bitshift. */
13585 const char *enc
[] =
13609 if (flavour
>= 0 && flavour
< (int) ARRAY_SIZE (enc
))
13611 opname
= enc
[flavour
];
13612 constraint (inst
.operands
[0].reg
!= inst
.operands
[1].reg
,
13613 _("operands 0 and 1 must be the same register"));
13614 inst
.operands
[1] = inst
.operands
[2];
13615 memset (&inst
.operands
[2], '\0', sizeof (inst
.operands
[2]));
13620 /* Conversions without bitshift. */
13621 const char *enc
[] =
13637 if (flavour
>= 0 && flavour
< (int) ARRAY_SIZE (enc
))
13638 opname
= enc
[flavour
];
13642 do_vfp_nsyn_opcode (opname
);
13646 do_vfp_nsyn_cvtz (void)
13648 enum neon_shape rs
= neon_select_shape (NS_FF
, NS_FD
, NS_NULL
);
13649 int flavour
= neon_cvt_flavour (rs
);
13650 const char *enc
[] =
13664 if (flavour
>= 0 && flavour
< (int) ARRAY_SIZE (enc
) && enc
[flavour
])
13665 do_vfp_nsyn_opcode (enc
[flavour
]);
13671 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_FFI
, NS_DD
, NS_QQ
,
13672 NS_FD
, NS_DF
, NS_FF
, NS_QD
, NS_DQ
, NS_NULL
);
13673 int flavour
= neon_cvt_flavour (rs
);
13675 /* VFP rather than Neon conversions. */
13678 do_vfp_nsyn_cvt (rs
, flavour
);
13688 unsigned enctab
[] = { 0x0000100, 0x1000100, 0x0, 0x1000000 };
13690 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13693 /* Fixed-point conversion with #0 immediate is encoded as an
13694 integer conversion. */
13695 if (inst
.operands
[2].present
&& inst
.operands
[2].imm
== 0)
13697 immbits
= 32 - inst
.operands
[2].imm
;
13698 NEON_ENCODE (IMMED
, inst
);
13700 inst
.instruction
|= enctab
[flavour
];
13701 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13702 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13703 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13704 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13705 inst
.instruction
|= neon_quad (rs
) << 6;
13706 inst
.instruction
|= 1 << 21;
13707 inst
.instruction
|= immbits
<< 16;
13709 neon_dp_fixup (&inst
);
13717 unsigned enctab
[] = { 0x100, 0x180, 0x0, 0x080 };
13719 NEON_ENCODE (INTEGER
, inst
);
13721 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13725 inst
.instruction
|= enctab
[flavour
];
13727 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13728 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13729 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13730 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13731 inst
.instruction
|= neon_quad (rs
) << 6;
13732 inst
.instruction
|= 2 << 18;
13734 neon_dp_fixup (&inst
);
13738 /* Half-precision conversions for Advanced SIMD -- neon. */
13743 && (inst
.vectype
.el
[0].size
!= 16 || inst
.vectype
.el
[1].size
!= 32))
13745 as_bad (_("operand size must match register width"));
13750 && ((inst
.vectype
.el
[0].size
!= 32 || inst
.vectype
.el
[1].size
!= 16)))
13752 as_bad (_("operand size must match register width"));
13757 inst
.instruction
= 0x3b60600;
13759 inst
.instruction
= 0x3b60700;
13761 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13762 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13763 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13764 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13765 neon_dp_fixup (&inst
);
13769 /* Some VFP conversions go here (s32 <-> f32, u32 <-> f32). */
13770 do_vfp_nsyn_cvt (rs
, flavour
);
13775 do_neon_cvtb (void)
13777 inst
.instruction
= 0xeb20a40;
13779 /* The sizes are attached to the mnemonic. */
13780 if (inst
.vectype
.el
[0].type
!= NT_invtype
13781 && inst
.vectype
.el
[0].size
== 16)
13782 inst
.instruction
|= 0x00010000;
13784 /* Programmer's syntax: the sizes are attached to the operands. */
13785 else if (inst
.operands
[0].vectype
.type
!= NT_invtype
13786 && inst
.operands
[0].vectype
.size
== 16)
13787 inst
.instruction
|= 0x00010000;
13789 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
13790 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Sm
);
13791 do_vfp_cond_or_thumb ();
13796 do_neon_cvtt (void)
13799 inst
.instruction
|= 0x80;
13803 neon_move_immediate (void)
13805 enum neon_shape rs
= neon_select_shape (NS_DI
, NS_QI
, NS_NULL
);
13806 struct neon_type_el et
= neon_check_type (2, rs
,
13807 N_I8
| N_I16
| N_I32
| N_I64
| N_F32
| N_KEY
, N_EQK
);
13808 unsigned immlo
, immhi
= 0, immbits
;
13809 int op
, cmode
, float_p
;
13811 constraint (et
.type
== NT_invtype
,
13812 _("operand size must be specified for immediate VMOV"));
13814 /* We start out as an MVN instruction if OP = 1, MOV otherwise. */
13815 op
= (inst
.instruction
& (1 << 5)) != 0;
13817 immlo
= inst
.operands
[1].imm
;
13818 if (inst
.operands
[1].regisimm
)
13819 immhi
= inst
.operands
[1].reg
;
13821 constraint (et
.size
< 32 && (immlo
& ~((1 << et
.size
) - 1)) != 0,
13822 _("immediate has bits set outside the operand size"));
13824 float_p
= inst
.operands
[1].immisfloat
;
13826 if ((cmode
= neon_cmode_for_move_imm (immlo
, immhi
, float_p
, &immbits
, &op
,
13827 et
.size
, et
.type
)) == FAIL
)
13829 /* Invert relevant bits only. */
13830 neon_invert_size (&immlo
, &immhi
, et
.size
);
13831 /* Flip from VMOV/VMVN to VMVN/VMOV. Some immediate types are unavailable
13832 with one or the other; those cases are caught by
13833 neon_cmode_for_move_imm. */
13835 if ((cmode
= neon_cmode_for_move_imm (immlo
, immhi
, float_p
, &immbits
,
13836 &op
, et
.size
, et
.type
)) == FAIL
)
13838 first_error (_("immediate out of range"));
13843 inst
.instruction
&= ~(1 << 5);
13844 inst
.instruction
|= op
<< 5;
13846 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13847 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13848 inst
.instruction
|= neon_quad (rs
) << 6;
13849 inst
.instruction
|= cmode
<< 8;
13851 neon_write_immbits (immbits
);
13857 if (inst
.operands
[1].isreg
)
13859 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
13861 NEON_ENCODE (INTEGER
, inst
);
13862 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13863 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13864 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13865 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13866 inst
.instruction
|= neon_quad (rs
) << 6;
13870 NEON_ENCODE (IMMED
, inst
);
13871 neon_move_immediate ();
13874 neon_dp_fixup (&inst
);
13877 /* Encode instructions of form:
13879 |28/24|23|22|21 20|19 16|15 12|11 8|7|6|5|4|3 0|
13880 | U |x |D |size | Rn | Rd |x x x x|N|x|M|x| Rm | */
13883 neon_mixed_length (struct neon_type_el et
, unsigned size
)
13885 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13886 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13887 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
13888 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
13889 inst
.instruction
|= LOW4 (inst
.operands
[2].reg
);
13890 inst
.instruction
|= HI1 (inst
.operands
[2].reg
) << 5;
13891 inst
.instruction
|= (et
.type
== NT_unsigned
) << 24;
13892 inst
.instruction
|= neon_logbits (size
) << 20;
13894 neon_dp_fixup (&inst
);
13898 do_neon_dyadic_long (void)
13900 /* FIXME: Type checking for lengthening op. */
13901 struct neon_type_el et
= neon_check_type (3, NS_QDD
,
13902 N_EQK
| N_DBL
, N_EQK
, N_SU_32
| N_KEY
);
13903 neon_mixed_length (et
, et
.size
);
13907 do_neon_abal (void)
13909 struct neon_type_el et
= neon_check_type (3, NS_QDD
,
13910 N_EQK
| N_INT
| N_DBL
, N_EQK
, N_SU_32
| N_KEY
);
13911 neon_mixed_length (et
, et
.size
);
13915 neon_mac_reg_scalar_long (unsigned regtypes
, unsigned scalartypes
)
13917 if (inst
.operands
[2].isscalar
)
13919 struct neon_type_el et
= neon_check_type (3, NS_QDS
,
13920 N_EQK
| N_DBL
, N_EQK
, regtypes
| N_KEY
);
13921 NEON_ENCODE (SCALAR
, inst
);
13922 neon_mul_mac (et
, et
.type
== NT_unsigned
);
13926 struct neon_type_el et
= neon_check_type (3, NS_QDD
,
13927 N_EQK
| N_DBL
, N_EQK
, scalartypes
| N_KEY
);
13928 NEON_ENCODE (INTEGER
, inst
);
13929 neon_mixed_length (et
, et
.size
);
13934 do_neon_mac_maybe_scalar_long (void)
13936 neon_mac_reg_scalar_long (N_S16
| N_S32
| N_U16
| N_U32
, N_SU_32
);
13940 do_neon_dyadic_wide (void)
13942 struct neon_type_el et
= neon_check_type (3, NS_QQD
,
13943 N_EQK
| N_DBL
, N_EQK
| N_DBL
, N_SU_32
| N_KEY
);
13944 neon_mixed_length (et
, et
.size
);
13948 do_neon_dyadic_narrow (void)
13950 struct neon_type_el et
= neon_check_type (3, NS_QDD
,
13951 N_EQK
| N_DBL
, N_EQK
, N_I16
| N_I32
| N_I64
| N_KEY
);
13952 /* Operand sign is unimportant, and the U bit is part of the opcode,
13953 so force the operand type to integer. */
13954 et
.type
= NT_integer
;
13955 neon_mixed_length (et
, et
.size
/ 2);
13959 do_neon_mul_sat_scalar_long (void)
13961 neon_mac_reg_scalar_long (N_S16
| N_S32
, N_S16
| N_S32
);
13965 do_neon_vmull (void)
13967 if (inst
.operands
[2].isscalar
)
13968 do_neon_mac_maybe_scalar_long ();
13971 struct neon_type_el et
= neon_check_type (3, NS_QDD
,
13972 N_EQK
| N_DBL
, N_EQK
, N_SU_32
| N_P8
| N_KEY
);
13973 if (et
.type
== NT_poly
)
13974 NEON_ENCODE (POLY
, inst
);
13976 NEON_ENCODE (INTEGER
, inst
);
13977 /* For polynomial encoding, size field must be 0b00 and the U bit must be
13978 zero. Should be OK as-is. */
13979 neon_mixed_length (et
, et
.size
);
13986 enum neon_shape rs
= neon_select_shape (NS_DDDI
, NS_QQQI
, NS_NULL
);
13987 struct neon_type_el et
= neon_check_type (3, rs
,
13988 N_EQK
, N_EQK
, N_8
| N_16
| N_32
| N_64
| N_KEY
);
13989 unsigned imm
= (inst
.operands
[3].imm
* et
.size
) / 8;
13991 constraint (imm
>= (unsigned) (neon_quad (rs
) ? 16 : 8),
13992 _("shift out of range"));
13993 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13994 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13995 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
13996 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
13997 inst
.instruction
|= LOW4 (inst
.operands
[2].reg
);
13998 inst
.instruction
|= HI1 (inst
.operands
[2].reg
) << 5;
13999 inst
.instruction
|= neon_quad (rs
) << 6;
14000 inst
.instruction
|= imm
<< 8;
14002 neon_dp_fixup (&inst
);
14008 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14009 struct neon_type_el et
= neon_check_type (2, rs
,
14010 N_EQK
, N_8
| N_16
| N_32
| N_KEY
);
14011 unsigned op
= (inst
.instruction
>> 7) & 3;
14012 /* N (width of reversed regions) is encoded as part of the bitmask. We
14013 extract it here to check the elements to be reversed are smaller.
14014 Otherwise we'd get a reserved instruction. */
14015 unsigned elsize
= (op
== 2) ? 16 : (op
== 1) ? 32 : (op
== 0) ? 64 : 0;
14016 gas_assert (elsize
!= 0);
14017 constraint (et
.size
>= elsize
,
14018 _("elements must be smaller than reversal region"));
14019 neon_two_same (neon_quad (rs
), 1, et
.size
);
14025 if (inst
.operands
[1].isscalar
)
14027 enum neon_shape rs
= neon_select_shape (NS_DS
, NS_QS
, NS_NULL
);
14028 struct neon_type_el et
= neon_check_type (2, rs
,
14029 N_EQK
, N_8
| N_16
| N_32
| N_KEY
);
14030 unsigned sizebits
= et
.size
>> 3;
14031 unsigned dm
= NEON_SCALAR_REG (inst
.operands
[1].reg
);
14032 int logsize
= neon_logbits (et
.size
);
14033 unsigned x
= NEON_SCALAR_INDEX (inst
.operands
[1].reg
) << logsize
;
14035 if (vfp_or_neon_is_neon (NEON_CHECK_CC
) == FAIL
)
14038 NEON_ENCODE (SCALAR
, inst
);
14039 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
14040 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
14041 inst
.instruction
|= LOW4 (dm
);
14042 inst
.instruction
|= HI1 (dm
) << 5;
14043 inst
.instruction
|= neon_quad (rs
) << 6;
14044 inst
.instruction
|= x
<< 17;
14045 inst
.instruction
|= sizebits
<< 16;
14047 neon_dp_fixup (&inst
);
14051 enum neon_shape rs
= neon_select_shape (NS_DR
, NS_QR
, NS_NULL
);
14052 struct neon_type_el et
= neon_check_type (2, rs
,
14053 N_8
| N_16
| N_32
| N_KEY
, N_EQK
);
14054 /* Duplicate ARM register to lanes of vector. */
14055 NEON_ENCODE (ARMREG
, inst
);
14058 case 8: inst
.instruction
|= 0x400000; break;
14059 case 16: inst
.instruction
|= 0x000020; break;
14060 case 32: inst
.instruction
|= 0x000000; break;
14063 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 12;
14064 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 16;
14065 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 7;
14066 inst
.instruction
|= neon_quad (rs
) << 21;
14067 /* The encoding for this instruction is identical for the ARM and Thumb
14068 variants, except for the condition field. */
14069 do_vfp_cond_or_thumb ();
14073 /* VMOV has particularly many variations. It can be one of:
14074 0. VMOV<c><q> <Qd>, <Qm>
14075 1. VMOV<c><q> <Dd>, <Dm>
14076 (Register operations, which are VORR with Rm = Rn.)
14077 2. VMOV<c><q>.<dt> <Qd>, #<imm>
14078 3. VMOV<c><q>.<dt> <Dd>, #<imm>
14080 4. VMOV<c><q>.<size> <Dn[x]>, <Rd>
14081 (ARM register to scalar.)
14082 5. VMOV<c><q> <Dm>, <Rd>, <Rn>
14083 (Two ARM registers to vector.)
14084 6. VMOV<c><q>.<dt> <Rd>, <Dn[x]>
14085 (Scalar to ARM register.)
14086 7. VMOV<c><q> <Rd>, <Rn>, <Dm>
14087 (Vector to two ARM registers.)
14088 8. VMOV.F32 <Sd>, <Sm>
14089 9. VMOV.F64 <Dd>, <Dm>
14090 (VFP register moves.)
14091 10. VMOV.F32 <Sd>, #imm
14092 11. VMOV.F64 <Dd>, #imm
14093 (VFP float immediate load.)
14094 12. VMOV <Rd>, <Sm>
14095 (VFP single to ARM reg.)
14096 13. VMOV <Sd>, <Rm>
14097 (ARM reg to VFP single.)
14098 14. VMOV <Rd>, <Re>, <Sn>, <Sm>
14099 (Two ARM regs to two VFP singles.)
14100 15. VMOV <Sd>, <Se>, <Rn>, <Rm>
14101 (Two VFP singles to two ARM regs.)
14103 These cases can be disambiguated using neon_select_shape, except cases 1/9
14104 and 3/11 which depend on the operand type too.
14106 All the encoded bits are hardcoded by this function.
14108 Cases 4, 6 may be used with VFPv1 and above (only 32-bit transfers!).
14109 Cases 5, 7 may be used with VFPv2 and above.
14111 FIXME: Some of the checking may be a bit sloppy (in a couple of cases you
14112 can specify a type where it doesn't make sense to, and is ignored). */
14117 enum neon_shape rs
= neon_select_shape (NS_RRFF
, NS_FFRR
, NS_DRR
, NS_RRD
,
14118 NS_QQ
, NS_DD
, NS_QI
, NS_DI
, NS_SR
, NS_RS
, NS_FF
, NS_FI
, NS_RF
, NS_FR
,
14120 struct neon_type_el et
;
14121 const char *ldconst
= 0;
14125 case NS_DD
: /* case 1/9. */
14126 et
= neon_check_type (2, rs
, N_EQK
, N_F64
| N_KEY
);
14127 /* It is not an error here if no type is given. */
14129 if (et
.type
== NT_float
&& et
.size
== 64)
14131 do_vfp_nsyn_opcode ("fcpyd");
14134 /* fall through. */
14136 case NS_QQ
: /* case 0/1. */
14138 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
14140 /* The architecture manual I have doesn't explicitly state which
14141 value the U bit should have for register->register moves, but
14142 the equivalent VORR instruction has U = 0, so do that. */
14143 inst
.instruction
= 0x0200110;
14144 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
14145 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
14146 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
14147 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
14148 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
14149 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
14150 inst
.instruction
|= neon_quad (rs
) << 6;
14152 neon_dp_fixup (&inst
);
14156 case NS_DI
: /* case 3/11. */
14157 et
= neon_check_type (2, rs
, N_EQK
, N_F64
| N_KEY
);
14159 if (et
.type
== NT_float
&& et
.size
== 64)
14161 /* case 11 (fconstd). */
14162 ldconst
= "fconstd";
14163 goto encode_fconstd
;
14165 /* fall through. */
14167 case NS_QI
: /* case 2/3. */
14168 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
14170 inst
.instruction
= 0x0800010;
14171 neon_move_immediate ();
14172 neon_dp_fixup (&inst
);
14175 case NS_SR
: /* case 4. */
14177 unsigned bcdebits
= 0;
14179 unsigned dn
= NEON_SCALAR_REG (inst
.operands
[0].reg
);
14180 unsigned x
= NEON_SCALAR_INDEX (inst
.operands
[0].reg
);
14182 et
= neon_check_type (2, NS_NULL
, N_8
| N_16
| N_32
| N_KEY
, N_EQK
);
14183 logsize
= neon_logbits (et
.size
);
14185 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_vfp_ext_v1
),
14187 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_neon_ext_v1
)
14188 && et
.size
!= 32, _(BAD_FPU
));
14189 constraint (et
.type
== NT_invtype
, _("bad type for scalar"));
14190 constraint (x
>= 64 / et
.size
, _("scalar index out of range"));
14194 case 8: bcdebits
= 0x8; break;
14195 case 16: bcdebits
= 0x1; break;
14196 case 32: bcdebits
= 0x0; break;
14200 bcdebits
|= x
<< logsize
;
14202 inst
.instruction
= 0xe000b10;
14203 do_vfp_cond_or_thumb ();
14204 inst
.instruction
|= LOW4 (dn
) << 16;
14205 inst
.instruction
|= HI1 (dn
) << 7;
14206 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
14207 inst
.instruction
|= (bcdebits
& 3) << 5;
14208 inst
.instruction
|= (bcdebits
>> 2) << 21;
14212 case NS_DRR
: /* case 5 (fmdrr). */
14213 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_vfp_ext_v2
),
14216 inst
.instruction
= 0xc400b10;
14217 do_vfp_cond_or_thumb ();
14218 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
);
14219 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 5;
14220 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
14221 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
14224 case NS_RS
: /* case 6. */
14227 unsigned dn
= NEON_SCALAR_REG (inst
.operands
[1].reg
);
14228 unsigned x
= NEON_SCALAR_INDEX (inst
.operands
[1].reg
);
14229 unsigned abcdebits
= 0;
14231 et
= neon_check_type (2, NS_NULL
,
14232 N_EQK
, N_S8
| N_S16
| N_U8
| N_U16
| N_32
| N_KEY
);
14233 logsize
= neon_logbits (et
.size
);
14235 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_vfp_ext_v1
),
14237 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_neon_ext_v1
)
14238 && et
.size
!= 32, _(BAD_FPU
));
14239 constraint (et
.type
== NT_invtype
, _("bad type for scalar"));
14240 constraint (x
>= 64 / et
.size
, _("scalar index out of range"));
14244 case 8: abcdebits
= (et
.type
== NT_signed
) ? 0x08 : 0x18; break;
14245 case 16: abcdebits
= (et
.type
== NT_signed
) ? 0x01 : 0x11; break;
14246 case 32: abcdebits
= 0x00; break;
14250 abcdebits
|= x
<< logsize
;
14251 inst
.instruction
= 0xe100b10;
14252 do_vfp_cond_or_thumb ();
14253 inst
.instruction
|= LOW4 (dn
) << 16;
14254 inst
.instruction
|= HI1 (dn
) << 7;
14255 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
14256 inst
.instruction
|= (abcdebits
& 3) << 5;
14257 inst
.instruction
|= (abcdebits
>> 2) << 21;
14261 case NS_RRD
: /* case 7 (fmrrd). */
14262 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_vfp_ext_v2
),
14265 inst
.instruction
= 0xc500b10;
14266 do_vfp_cond_or_thumb ();
14267 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
14268 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
14269 inst
.instruction
|= LOW4 (inst
.operands
[2].reg
);
14270 inst
.instruction
|= HI1 (inst
.operands
[2].reg
) << 5;
14273 case NS_FF
: /* case 8 (fcpys). */
14274 do_vfp_nsyn_opcode ("fcpys");
14277 case NS_FI
: /* case 10 (fconsts). */
14278 ldconst
= "fconsts";
14280 if (is_quarter_float (inst
.operands
[1].imm
))
14282 inst
.operands
[1].imm
= neon_qfloat_bits (inst
.operands
[1].imm
);
14283 do_vfp_nsyn_opcode (ldconst
);
14286 first_error (_("immediate out of range"));
14289 case NS_RF
: /* case 12 (fmrs). */
14290 do_vfp_nsyn_opcode ("fmrs");
14293 case NS_FR
: /* case 13 (fmsr). */
14294 do_vfp_nsyn_opcode ("fmsr");
14297 /* The encoders for the fmrrs and fmsrr instructions expect three operands
14298 (one of which is a list), but we have parsed four. Do some fiddling to
14299 make the operands what do_vfp_reg2_from_sp2 and do_vfp_sp2_from_reg2
14301 case NS_RRFF
: /* case 14 (fmrrs). */
14302 constraint (inst
.operands
[3].reg
!= inst
.operands
[2].reg
+ 1,
14303 _("VFP registers must be adjacent"));
14304 inst
.operands
[2].imm
= 2;
14305 memset (&inst
.operands
[3], '\0', sizeof (inst
.operands
[3]));
14306 do_vfp_nsyn_opcode ("fmrrs");
14309 case NS_FFRR
: /* case 15 (fmsrr). */
14310 constraint (inst
.operands
[1].reg
!= inst
.operands
[0].reg
+ 1,
14311 _("VFP registers must be adjacent"));
14312 inst
.operands
[1] = inst
.operands
[2];
14313 inst
.operands
[2] = inst
.operands
[3];
14314 inst
.operands
[0].imm
= 2;
14315 memset (&inst
.operands
[3], '\0', sizeof (inst
.operands
[3]));
14316 do_vfp_nsyn_opcode ("fmsrr");
14325 do_neon_rshift_round_imm (void)
14327 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
14328 struct neon_type_el et
= neon_check_type (2, rs
, N_EQK
, N_SU_ALL
| N_KEY
);
14329 int imm
= inst
.operands
[2].imm
;
14331 /* imm == 0 case is encoded as VMOV for V{R}SHR. */
14334 inst
.operands
[2].present
= 0;
14339 constraint (imm
< 1 || (unsigned)imm
> et
.size
,
14340 _("immediate out of range for shift"));
14341 neon_imm_shift (TRUE
, et
.type
== NT_unsigned
, neon_quad (rs
), et
,
14346 do_neon_movl (void)
14348 struct neon_type_el et
= neon_check_type (2, NS_QD
,
14349 N_EQK
| N_DBL
, N_SU_32
| N_KEY
);
14350 unsigned sizebits
= et
.size
>> 3;
14351 inst
.instruction
|= sizebits
<< 19;
14352 neon_two_same (0, et
.type
== NT_unsigned
, -1);
14358 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14359 struct neon_type_el et
= neon_check_type (2, rs
,
14360 N_EQK
, N_8
| N_16
| N_32
| N_KEY
);
14361 NEON_ENCODE (INTEGER
, inst
);
14362 neon_two_same (neon_quad (rs
), 1, et
.size
);
14366 do_neon_zip_uzp (void)
14368 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14369 struct neon_type_el et
= neon_check_type (2, rs
,
14370 N_EQK
, N_8
| N_16
| N_32
| N_KEY
);
14371 if (rs
== NS_DD
&& et
.size
== 32)
14373 /* Special case: encode as VTRN.32 <Dd>, <Dm>. */
14374 inst
.instruction
= N_MNEM_vtrn
;
14378 neon_two_same (neon_quad (rs
), 1, et
.size
);
14382 do_neon_sat_abs_neg (void)
14384 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14385 struct neon_type_el et
= neon_check_type (2, rs
,
14386 N_EQK
, N_S8
| N_S16
| N_S32
| N_KEY
);
14387 neon_two_same (neon_quad (rs
), 1, et
.size
);
14391 do_neon_pair_long (void)
14393 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14394 struct neon_type_el et
= neon_check_type (2, rs
, N_EQK
, N_SU_32
| N_KEY
);
14395 /* Unsigned is encoded in OP field (bit 7) for these instruction. */
14396 inst
.instruction
|= (et
.type
== NT_unsigned
) << 7;
14397 neon_two_same (neon_quad (rs
), 1, et
.size
);
14401 do_neon_recip_est (void)
14403 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14404 struct neon_type_el et
= neon_check_type (2, rs
,
14405 N_EQK
| N_FLT
, N_F32
| N_U32
| N_KEY
);
14406 inst
.instruction
|= (et
.type
== NT_float
) << 8;
14407 neon_two_same (neon_quad (rs
), 1, et
.size
);
14413 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14414 struct neon_type_el et
= neon_check_type (2, rs
,
14415 N_EQK
, N_S8
| N_S16
| N_S32
| N_KEY
);
14416 neon_two_same (neon_quad (rs
), 1, et
.size
);
14422 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14423 struct neon_type_el et
= neon_check_type (2, rs
,
14424 N_EQK
, N_I8
| N_I16
| N_I32
| N_KEY
);
14425 neon_two_same (neon_quad (rs
), 1, et
.size
);
14431 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14432 struct neon_type_el et
= neon_check_type (2, rs
,
14433 N_EQK
| N_INT
, N_8
| N_KEY
);
14434 neon_two_same (neon_quad (rs
), 1, et
.size
);
14440 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14441 neon_two_same (neon_quad (rs
), 1, -1);
14445 do_neon_tbl_tbx (void)
14447 unsigned listlenbits
;
14448 neon_check_type (3, NS_DLD
, N_EQK
, N_EQK
, N_8
| N_KEY
);
14450 if (inst
.operands
[1].imm
< 1 || inst
.operands
[1].imm
> 4)
14452 first_error (_("bad list length for table lookup"));
14456 listlenbits
= inst
.operands
[1].imm
- 1;
14457 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
14458 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
14459 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
14460 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
14461 inst
.instruction
|= LOW4 (inst
.operands
[2].reg
);
14462 inst
.instruction
|= HI1 (inst
.operands
[2].reg
) << 5;
14463 inst
.instruction
|= listlenbits
<< 8;
14465 neon_dp_fixup (&inst
);
14469 do_neon_ldm_stm (void)
14471 /* P, U and L bits are part of bitmask. */
14472 int is_dbmode
= (inst
.instruction
& (1 << 24)) != 0;
14473 unsigned offsetbits
= inst
.operands
[1].imm
* 2;
14475 if (inst
.operands
[1].issingle
)
14477 do_vfp_nsyn_ldm_stm (is_dbmode
);
14481 constraint (is_dbmode
&& !inst
.operands
[0].writeback
,
14482 _("writeback (!) must be used for VLDMDB and VSTMDB"));
14484 constraint (inst
.operands
[1].imm
< 1 || inst
.operands
[1].imm
> 16,
14485 _("register list must contain at least 1 and at most 16 "
14488 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
14489 inst
.instruction
|= inst
.operands
[0].writeback
<< 21;
14490 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 12;
14491 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 22;
14493 inst
.instruction
|= offsetbits
;
14495 do_vfp_cond_or_thumb ();
14499 do_neon_ldr_str (void)
14501 int is_ldr
= (inst
.instruction
& (1 << 20)) != 0;
14503 if (inst
.operands
[0].issingle
)
14506 do_vfp_nsyn_opcode ("flds");
14508 do_vfp_nsyn_opcode ("fsts");
14513 do_vfp_nsyn_opcode ("fldd");
14515 do_vfp_nsyn_opcode ("fstd");
14519 /* "interleave" version also handles non-interleaving register VLD1/VST1
14523 do_neon_ld_st_interleave (void)
14525 struct neon_type_el et
= neon_check_type (1, NS_NULL
,
14526 N_8
| N_16
| N_32
| N_64
);
14527 unsigned alignbits
= 0;
14529 /* The bits in this table go:
14530 0: register stride of one (0) or two (1)
14531 1,2: register list length, minus one (1, 2, 3, 4).
14532 3,4: <n> in instruction type, minus one (VLD<n> / VST<n>).
14533 We use -1 for invalid entries. */
14534 const int typetable
[] =
14536 0x7, -1, 0xa, -1, 0x6, -1, 0x2, -1, /* VLD1 / VST1. */
14537 -1, -1, 0x8, 0x9, -1, -1, 0x3, -1, /* VLD2 / VST2. */
14538 -1, -1, -1, -1, 0x4, 0x5, -1, -1, /* VLD3 / VST3. */
14539 -1, -1, -1, -1, -1, -1, 0x0, 0x1 /* VLD4 / VST4. */
14543 if (et
.type
== NT_invtype
)
14546 if (inst
.operands
[1].immisalign
)
14547 switch (inst
.operands
[1].imm
>> 8)
14549 case 64: alignbits
= 1; break;
14551 if (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) == 3)
14552 goto bad_alignment
;
14556 if (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) == 3)
14557 goto bad_alignment
;
14562 first_error (_("bad alignment"));
14566 inst
.instruction
|= alignbits
<< 4;
14567 inst
.instruction
|= neon_logbits (et
.size
) << 6;
14569 /* Bits [4:6] of the immediate in a list specifier encode register stride
14570 (minus 1) in bit 4, and list length in bits [5:6]. We put the <n> of
14571 VLD<n>/VST<n> in bits [9:8] of the initial bitmask. Suck it out here, look
14572 up the right value for "type" in a table based on this value and the given
14573 list style, then stick it back. */
14574 idx
= ((inst
.operands
[0].imm
>> 4) & 7)
14575 | (((inst
.instruction
>> 8) & 3) << 3);
14577 typebits
= typetable
[idx
];
14579 constraint (typebits
== -1, _("bad list type for instruction"));
14581 inst
.instruction
&= ~0xf00;
14582 inst
.instruction
|= typebits
<< 8;
14585 /* Check alignment is valid for do_neon_ld_st_lane and do_neon_ld_dup.
14586 *DO_ALIGN is set to 1 if the relevant alignment bit should be set, 0
14587 otherwise. The variable arguments are a list of pairs of legal (size, align)
14588 values, terminated with -1. */
14591 neon_alignment_bit (int size
, int align
, int *do_align
, ...)
14594 int result
= FAIL
, thissize
, thisalign
;
14596 if (!inst
.operands
[1].immisalign
)
14602 va_start (ap
, do_align
);
14606 thissize
= va_arg (ap
, int);
14607 if (thissize
== -1)
14609 thisalign
= va_arg (ap
, int);
14611 if (size
== thissize
&& align
== thisalign
)
14614 while (result
!= SUCCESS
);
14618 if (result
== SUCCESS
)
14621 first_error (_("unsupported alignment for instruction"));
14627 do_neon_ld_st_lane (void)
14629 struct neon_type_el et
= neon_check_type (1, NS_NULL
, N_8
| N_16
| N_32
);
14630 int align_good
, do_align
= 0;
14631 int logsize
= neon_logbits (et
.size
);
14632 int align
= inst
.operands
[1].imm
>> 8;
14633 int n
= (inst
.instruction
>> 8) & 3;
14634 int max_el
= 64 / et
.size
;
14636 if (et
.type
== NT_invtype
)
14639 constraint (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) != n
+ 1,
14640 _("bad list length"));
14641 constraint (NEON_LANE (inst
.operands
[0].imm
) >= max_el
,
14642 _("scalar index out of range"));
14643 constraint (n
!= 0 && NEON_REG_STRIDE (inst
.operands
[0].imm
) == 2
14645 _("stride of 2 unavailable when element size is 8"));
14649 case 0: /* VLD1 / VST1. */
14650 align_good
= neon_alignment_bit (et
.size
, align
, &do_align
, 16, 16,
14652 if (align_good
== FAIL
)
14656 unsigned alignbits
= 0;
14659 case 16: alignbits
= 0x1; break;
14660 case 32: alignbits
= 0x3; break;
14663 inst
.instruction
|= alignbits
<< 4;
14667 case 1: /* VLD2 / VST2. */
14668 align_good
= neon_alignment_bit (et
.size
, align
, &do_align
, 8, 16, 16, 32,
14670 if (align_good
== FAIL
)
14673 inst
.instruction
|= 1 << 4;
14676 case 2: /* VLD3 / VST3. */
14677 constraint (inst
.operands
[1].immisalign
,
14678 _("can't use alignment with this instruction"));
14681 case 3: /* VLD4 / VST4. */
14682 align_good
= neon_alignment_bit (et
.size
, align
, &do_align
, 8, 32,
14683 16, 64, 32, 64, 32, 128, -1);
14684 if (align_good
== FAIL
)
14688 unsigned alignbits
= 0;
14691 case 8: alignbits
= 0x1; break;
14692 case 16: alignbits
= 0x1; break;
14693 case 32: alignbits
= (align
== 64) ? 0x1 : 0x2; break;
14696 inst
.instruction
|= alignbits
<< 4;
14703 /* Reg stride of 2 is encoded in bit 5 when size==16, bit 6 when size==32. */
14704 if (n
!= 0 && NEON_REG_STRIDE (inst
.operands
[0].imm
) == 2)
14705 inst
.instruction
|= 1 << (4 + logsize
);
14707 inst
.instruction
|= NEON_LANE (inst
.operands
[0].imm
) << (logsize
+ 5);
14708 inst
.instruction
|= logsize
<< 10;
14711 /* Encode single n-element structure to all lanes VLD<n> instructions. */
14714 do_neon_ld_dup (void)
14716 struct neon_type_el et
= neon_check_type (1, NS_NULL
, N_8
| N_16
| N_32
);
14717 int align_good
, do_align
= 0;
14719 if (et
.type
== NT_invtype
)
14722 switch ((inst
.instruction
>> 8) & 3)
14724 case 0: /* VLD1. */
14725 gas_assert (NEON_REG_STRIDE (inst
.operands
[0].imm
) != 2);
14726 align_good
= neon_alignment_bit (et
.size
, inst
.operands
[1].imm
>> 8,
14727 &do_align
, 16, 16, 32, 32, -1);
14728 if (align_good
== FAIL
)
14730 switch (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
))
14733 case 2: inst
.instruction
|= 1 << 5; break;
14734 default: first_error (_("bad list length")); return;
14736 inst
.instruction
|= neon_logbits (et
.size
) << 6;
14739 case 1: /* VLD2. */
14740 align_good
= neon_alignment_bit (et
.size
, inst
.operands
[1].imm
>> 8,
14741 &do_align
, 8, 16, 16, 32, 32, 64, -1);
14742 if (align_good
== FAIL
)
14744 constraint (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) != 2,
14745 _("bad list length"));
14746 if (NEON_REG_STRIDE (inst
.operands
[0].imm
) == 2)
14747 inst
.instruction
|= 1 << 5;
14748 inst
.instruction
|= neon_logbits (et
.size
) << 6;
14751 case 2: /* VLD3. */
14752 constraint (inst
.operands
[1].immisalign
,
14753 _("can't use alignment with this instruction"));
14754 constraint (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) != 3,
14755 _("bad list length"));
14756 if (NEON_REG_STRIDE (inst
.operands
[0].imm
) == 2)
14757 inst
.instruction
|= 1 << 5;
14758 inst
.instruction
|= neon_logbits (et
.size
) << 6;
14761 case 3: /* VLD4. */
14763 int align
= inst
.operands
[1].imm
>> 8;
14764 align_good
= neon_alignment_bit (et
.size
, align
, &do_align
, 8, 32,
14765 16, 64, 32, 64, 32, 128, -1);
14766 if (align_good
== FAIL
)
14768 constraint (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) != 4,
14769 _("bad list length"));
14770 if (NEON_REG_STRIDE (inst
.operands
[0].imm
) == 2)
14771 inst
.instruction
|= 1 << 5;
14772 if (et
.size
== 32 && align
== 128)
14773 inst
.instruction
|= 0x3 << 6;
14775 inst
.instruction
|= neon_logbits (et
.size
) << 6;
14782 inst
.instruction
|= do_align
<< 4;
14785 /* Disambiguate VLD<n> and VST<n> instructions, and fill in common bits (those
14786 apart from bits [11:4]. */
14789 do_neon_ldx_stx (void)
14791 if (inst
.operands
[1].isreg
)
14792 constraint (inst
.operands
[1].reg
== REG_PC
, BAD_PC
);
14794 switch (NEON_LANE (inst
.operands
[0].imm
))
14796 case NEON_INTERLEAVE_LANES
:
14797 NEON_ENCODE (INTERLV
, inst
);
14798 do_neon_ld_st_interleave ();
14801 case NEON_ALL_LANES
:
14802 NEON_ENCODE (DUP
, inst
);
14807 NEON_ENCODE (LANE
, inst
);
14808 do_neon_ld_st_lane ();
14811 /* L bit comes from bit mask. */
14812 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
14813 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
14814 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
14816 if (inst
.operands
[1].postind
)
14818 int postreg
= inst
.operands
[1].imm
& 0xf;
14819 constraint (!inst
.operands
[1].immisreg
,
14820 _("post-index must be a register"));
14821 constraint (postreg
== 0xd || postreg
== 0xf,
14822 _("bad register for post-index"));
14823 inst
.instruction
|= postreg
;
14825 else if (inst
.operands
[1].writeback
)
14827 inst
.instruction
|= 0xd;
14830 inst
.instruction
|= 0xf;
14833 inst
.instruction
|= 0xf9000000;
14835 inst
.instruction
|= 0xf4000000;
14838 /* Overall per-instruction processing. */
14840 /* We need to be able to fix up arbitrary expressions in some statements.
14841 This is so that we can handle symbols that are an arbitrary distance from
14842 the pc. The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
14843 which returns part of an address in a form which will be valid for
14844 a data instruction. We do this by pushing the expression into a symbol
14845 in the expr_section, and creating a fix for that. */
14848 fix_new_arm (fragS
* frag
,
14863 new_fix
= fix_new_exp (frag
, where
, size
, exp
, pc_rel
,
14864 (enum bfd_reloc_code_real
) reloc
);
14868 new_fix
= (fixS
*) fix_new (frag
, where
, size
, make_expr_symbol (exp
), 0,
14869 pc_rel
, (enum bfd_reloc_code_real
) reloc
);
14873 /* Mark whether the fix is to a THUMB instruction, or an ARM
14875 new_fix
->tc_fix_data
= thumb_mode
;
14878 /* Create a frg for an instruction requiring relaxation. */
14880 output_relax_insn (void)
14886 /* The size of the instruction is unknown, so tie the debug info to the
14887 start of the instruction. */
14888 dwarf2_emit_insn (0);
14890 switch (inst
.reloc
.exp
.X_op
)
14893 sym
= inst
.reloc
.exp
.X_add_symbol
;
14894 offset
= inst
.reloc
.exp
.X_add_number
;
14898 offset
= inst
.reloc
.exp
.X_add_number
;
14901 sym
= make_expr_symbol (&inst
.reloc
.exp
);
14905 to
= frag_var (rs_machine_dependent
, INSN_SIZE
, THUMB_SIZE
,
14906 inst
.relax
, sym
, offset
, NULL
/*offset, opcode*/);
14907 md_number_to_chars (to
, inst
.instruction
, THUMB_SIZE
);
14910 /* Write a 32-bit thumb instruction to buf. */
14912 put_thumb32_insn (char * buf
, unsigned long insn
)
14914 md_number_to_chars (buf
, insn
>> 16, THUMB_SIZE
);
14915 md_number_to_chars (buf
+ THUMB_SIZE
, insn
, THUMB_SIZE
);
14919 output_inst (const char * str
)
14925 as_bad ("%s -- `%s'", inst
.error
, str
);
14930 output_relax_insn ();
14933 if (inst
.size
== 0)
14936 to
= frag_more (inst
.size
);
14937 /* PR 9814: Record the thumb mode into the current frag so that we know
14938 what type of NOP padding to use, if necessary. We override any previous
14939 setting so that if the mode has changed then the NOPS that we use will
14940 match the encoding of the last instruction in the frag. */
14941 frag_now
->tc_frag_data
.thumb_mode
= thumb_mode
| MODE_RECORDED
;
14943 if (thumb_mode
&& (inst
.size
> THUMB_SIZE
))
14945 gas_assert (inst
.size
== (2 * THUMB_SIZE
));
14946 put_thumb32_insn (to
, inst
.instruction
);
14948 else if (inst
.size
> INSN_SIZE
)
14950 gas_assert (inst
.size
== (2 * INSN_SIZE
));
14951 md_number_to_chars (to
, inst
.instruction
, INSN_SIZE
);
14952 md_number_to_chars (to
+ INSN_SIZE
, inst
.instruction
, INSN_SIZE
);
14955 md_number_to_chars (to
, inst
.instruction
, inst
.size
);
14957 if (inst
.reloc
.type
!= BFD_RELOC_UNUSED
)
14958 fix_new_arm (frag_now
, to
- frag_now
->fr_literal
,
14959 inst
.size
, & inst
.reloc
.exp
, inst
.reloc
.pc_rel
,
14962 dwarf2_emit_insn (inst
.size
);
14966 output_it_inst (int cond
, int mask
, char * to
)
14968 unsigned long instruction
= 0xbf00;
14971 instruction
|= mask
;
14972 instruction
|= cond
<< 4;
14976 to
= frag_more (2);
14978 dwarf2_emit_insn (2);
14982 md_number_to_chars (to
, instruction
, 2);
14987 /* Tag values used in struct asm_opcode's tag field. */
14990 OT_unconditional
, /* Instruction cannot be conditionalized.
14991 The ARM condition field is still 0xE. */
14992 OT_unconditionalF
, /* Instruction cannot be conditionalized
14993 and carries 0xF in its ARM condition field. */
14994 OT_csuffix
, /* Instruction takes a conditional suffix. */
14995 OT_csuffixF
, /* Some forms of the instruction take a conditional
14996 suffix, others place 0xF where the condition field
14998 OT_cinfix3
, /* Instruction takes a conditional infix,
14999 beginning at character index 3. (In
15000 unified mode, it becomes a suffix.) */
15001 OT_cinfix3_deprecated
, /* The same as OT_cinfix3. This is used for
15002 tsts, cmps, cmns, and teqs. */
15003 OT_cinfix3_legacy
, /* Legacy instruction takes a conditional infix at
15004 character index 3, even in unified mode. Used for
15005 legacy instructions where suffix and infix forms
15006 may be ambiguous. */
15007 OT_csuf_or_in3
, /* Instruction takes either a conditional
15008 suffix or an infix at character index 3. */
15009 OT_odd_infix_unc
, /* This is the unconditional variant of an
15010 instruction that takes a conditional infix
15011 at an unusual position. In unified mode,
15012 this variant will accept a suffix. */
15013 OT_odd_infix_0
/* Values greater than or equal to OT_odd_infix_0
15014 are the conditional variants of instructions that
15015 take conditional infixes in unusual positions.
15016 The infix appears at character index
15017 (tag - OT_odd_infix_0). These are not accepted
15018 in unified mode. */
15021 /* Subroutine of md_assemble, responsible for looking up the primary
15022 opcode from the mnemonic the user wrote. STR points to the
15023 beginning of the mnemonic.
15025 This is not simply a hash table lookup, because of conditional
15026 variants. Most instructions have conditional variants, which are
15027 expressed with a _conditional affix_ to the mnemonic. If we were
15028 to encode each conditional variant as a literal string in the opcode
15029 table, it would have approximately 20,000 entries.
15031 Most mnemonics take this affix as a suffix, and in unified syntax,
15032 'most' is upgraded to 'all'. However, in the divided syntax, some
15033 instructions take the affix as an infix, notably the s-variants of
15034 the arithmetic instructions. Of those instructions, all but six
15035 have the infix appear after the third character of the mnemonic.
15037 Accordingly, the algorithm for looking up primary opcodes given
15040 1. Look up the identifier in the opcode table.
15041 If we find a match, go to step U.
15043 2. Look up the last two characters of the identifier in the
15044 conditions table. If we find a match, look up the first N-2
15045 characters of the identifier in the opcode table. If we
15046 find a match, go to step CE.
15048 3. Look up the fourth and fifth characters of the identifier in
15049 the conditions table. If we find a match, extract those
15050 characters from the identifier, and look up the remaining
15051 characters in the opcode table. If we find a match, go
15056 U. Examine the tag field of the opcode structure, in case this is
15057 one of the six instructions with its conditional infix in an
15058 unusual place. If it is, the tag tells us where to find the
15059 infix; look it up in the conditions table and set inst.cond
15060 accordingly. Otherwise, this is an unconditional instruction.
15061 Again set inst.cond accordingly. Return the opcode structure.
15063 CE. Examine the tag field to make sure this is an instruction that
15064 should receive a conditional suffix. If it is not, fail.
15065 Otherwise, set inst.cond from the suffix we already looked up,
15066 and return the opcode structure.
15068 CM. Examine the tag field to make sure this is an instruction that
15069 should receive a conditional infix after the third character.
15070 If it is not, fail. Otherwise, undo the edits to the current
15071 line of input and proceed as for case CE. */
15073 static const struct asm_opcode
*
15074 opcode_lookup (char **str
)
15078 const struct asm_opcode
*opcode
;
15079 const struct asm_cond
*cond
;
15082 /* Scan up to the end of the mnemonic, which must end in white space,
15083 '.' (in unified mode, or for Neon/VFP instructions), or end of string. */
15084 for (base
= end
= *str
; *end
!= '\0'; end
++)
15085 if (*end
== ' ' || *end
== '.')
15091 /* Handle a possible width suffix and/or Neon type suffix. */
15096 /* The .w and .n suffixes are only valid if the unified syntax is in
15098 if (unified_syntax
&& end
[1] == 'w')
15100 else if (unified_syntax
&& end
[1] == 'n')
15105 inst
.vectype
.elems
= 0;
15107 *str
= end
+ offset
;
15109 if (end
[offset
] == '.')
15111 /* See if we have a Neon type suffix (possible in either unified or
15112 non-unified ARM syntax mode). */
15113 if (parse_neon_type (&inst
.vectype
, str
) == FAIL
)
15116 else if (end
[offset
] != '\0' && end
[offset
] != ' ')
15122 /* Look for unaffixed or special-case affixed mnemonic. */
15123 opcode
= (const struct asm_opcode
*) hash_find_n (arm_ops_hsh
, base
,
15128 if (opcode
->tag
< OT_odd_infix_0
)
15130 inst
.cond
= COND_ALWAYS
;
15134 if (warn_on_deprecated
&& unified_syntax
)
15135 as_warn (_("conditional infixes are deprecated in unified syntax"));
15136 affix
= base
+ (opcode
->tag
- OT_odd_infix_0
);
15137 cond
= (const struct asm_cond
*) hash_find_n (arm_cond_hsh
, affix
, 2);
15140 inst
.cond
= cond
->value
;
15144 /* Cannot have a conditional suffix on a mnemonic of less than two
15146 if (end
- base
< 3)
15149 /* Look for suffixed mnemonic. */
15151 cond
= (const struct asm_cond
*) hash_find_n (arm_cond_hsh
, affix
, 2);
15152 opcode
= (const struct asm_opcode
*) hash_find_n (arm_ops_hsh
, base
,
15154 if (opcode
&& cond
)
15157 switch (opcode
->tag
)
15159 case OT_cinfix3_legacy
:
15160 /* Ignore conditional suffixes matched on infix only mnemonics. */
15164 case OT_cinfix3_deprecated
:
15165 case OT_odd_infix_unc
:
15166 if (!unified_syntax
)
15168 /* else fall through */
15172 case OT_csuf_or_in3
:
15173 inst
.cond
= cond
->value
;
15176 case OT_unconditional
:
15177 case OT_unconditionalF
:
15179 inst
.cond
= cond
->value
;
15182 /* Delayed diagnostic. */
15183 inst
.error
= BAD_COND
;
15184 inst
.cond
= COND_ALWAYS
;
15193 /* Cannot have a usual-position infix on a mnemonic of less than
15194 six characters (five would be a suffix). */
15195 if (end
- base
< 6)
15198 /* Look for infixed mnemonic in the usual position. */
15200 cond
= (const struct asm_cond
*) hash_find_n (arm_cond_hsh
, affix
, 2);
15204 memcpy (save
, affix
, 2);
15205 memmove (affix
, affix
+ 2, (end
- affix
) - 2);
15206 opcode
= (const struct asm_opcode
*) hash_find_n (arm_ops_hsh
, base
,
15208 memmove (affix
+ 2, affix
, (end
- affix
) - 2);
15209 memcpy (affix
, save
, 2);
15212 && (opcode
->tag
== OT_cinfix3
15213 || opcode
->tag
== OT_cinfix3_deprecated
15214 || opcode
->tag
== OT_csuf_or_in3
15215 || opcode
->tag
== OT_cinfix3_legacy
))
15218 if (warn_on_deprecated
&& unified_syntax
15219 && (opcode
->tag
== OT_cinfix3
15220 || opcode
->tag
== OT_cinfix3_deprecated
))
15221 as_warn (_("conditional infixes are deprecated in unified syntax"));
15223 inst
.cond
= cond
->value
;
15230 /* This function generates an initial IT instruction, leaving its block
15231 virtually open for the new instructions. Eventually,
15232 the mask will be updated by now_it_add_mask () each time
15233 a new instruction needs to be included in the IT block.
15234 Finally, the block is closed with close_automatic_it_block ().
15235 The block closure can be requested either from md_assemble (),
15236 a tencode (), or due to a label hook. */
15239 new_automatic_it_block (int cond
)
15241 now_it
.state
= AUTOMATIC_IT_BLOCK
;
15242 now_it
.mask
= 0x18;
15244 now_it
.block_length
= 1;
15245 mapping_state (MAP_THUMB
);
15246 now_it
.insn
= output_it_inst (cond
, now_it
.mask
, NULL
);
15249 /* Close an automatic IT block.
15250 See comments in new_automatic_it_block (). */
15253 close_automatic_it_block (void)
15255 now_it
.mask
= 0x10;
15256 now_it
.block_length
= 0;
15259 /* Update the mask of the current automatically-generated IT
15260 instruction. See comments in new_automatic_it_block (). */
15263 now_it_add_mask (int cond
)
15265 #define CLEAR_BIT(value, nbit) ((value) & ~(1 << (nbit)))
15266 #define SET_BIT_VALUE(value, bitvalue, nbit) (CLEAR_BIT (value, nbit) \
15267 | ((bitvalue) << (nbit)))
15268 const int resulting_bit
= (cond
& 1);
15270 now_it
.mask
&= 0xf;
15271 now_it
.mask
= SET_BIT_VALUE (now_it
.mask
,
15273 (5 - now_it
.block_length
));
15274 now_it
.mask
= SET_BIT_VALUE (now_it
.mask
,
15276 ((5 - now_it
.block_length
) - 1) );
15277 output_it_inst (now_it
.cc
, now_it
.mask
, now_it
.insn
);
15280 #undef SET_BIT_VALUE
15283 /* The IT blocks handling machinery is accessed through the these functions:
15284 it_fsm_pre_encode () from md_assemble ()
15285 set_it_insn_type () optional, from the tencode functions
15286 set_it_insn_type_last () ditto
15287 in_it_block () ditto
15288 it_fsm_post_encode () from md_assemble ()
15289 force_automatic_it_block_close () from label habdling functions
15292 1) md_assemble () calls it_fsm_pre_encode () before calling tencode (),
15293 initializing the IT insn type with a generic initial value depending
15294 on the inst.condition.
15295 2) During the tencode function, two things may happen:
15296 a) The tencode function overrides the IT insn type by
15297 calling either set_it_insn_type (type) or set_it_insn_type_last ().
15298 b) The tencode function queries the IT block state by
15299 calling in_it_block () (i.e. to determine narrow/not narrow mode).
15301 Both set_it_insn_type and in_it_block run the internal FSM state
15302 handling function (handle_it_state), because: a) setting the IT insn
15303 type may incur in an invalid state (exiting the function),
15304 and b) querying the state requires the FSM to be updated.
15305 Specifically we want to avoid creating an IT block for conditional
15306 branches, so it_fsm_pre_encode is actually a guess and we can't
15307 determine whether an IT block is required until the tencode () routine
15308 has decided what type of instruction this actually it.
15309 Because of this, if set_it_insn_type and in_it_block have to be used,
15310 set_it_insn_type has to be called first.
15312 set_it_insn_type_last () is a wrapper of set_it_insn_type (type), that
15313 determines the insn IT type depending on the inst.cond code.
15314 When a tencode () routine encodes an instruction that can be
15315 either outside an IT block, or, in the case of being inside, has to be
15316 the last one, set_it_insn_type_last () will determine the proper
15317 IT instruction type based on the inst.cond code. Otherwise,
15318 set_it_insn_type can be called for overriding that logic or
15319 for covering other cases.
15321 Calling handle_it_state () may not transition the IT block state to
15322 OUTSIDE_IT_BLOCK immediatelly, since the (current) state could be
15323 still queried. Instead, if the FSM determines that the state should
15324 be transitioned to OUTSIDE_IT_BLOCK, a flag is marked to be closed
15325 after the tencode () function: that's what it_fsm_post_encode () does.
15327 Since in_it_block () calls the state handling function to get an
15328 updated state, an error may occur (due to invalid insns combination).
15329 In that case, inst.error is set.
15330 Therefore, inst.error has to be checked after the execution of
15331 the tencode () routine.
15333 3) Back in md_assemble(), it_fsm_post_encode () is called to commit
15334 any pending state change (if any) that didn't take place in
15335 handle_it_state () as explained above. */
15338 it_fsm_pre_encode (void)
15340 if (inst
.cond
!= COND_ALWAYS
)
15341 inst
.it_insn_type
= INSIDE_IT_INSN
;
15343 inst
.it_insn_type
= OUTSIDE_IT_INSN
;
15345 now_it
.state_handled
= 0;
15348 /* IT state FSM handling function. */
15351 handle_it_state (void)
15353 now_it
.state_handled
= 1;
15355 switch (now_it
.state
)
15357 case OUTSIDE_IT_BLOCK
:
15358 switch (inst
.it_insn_type
)
15360 case OUTSIDE_IT_INSN
:
15363 case INSIDE_IT_INSN
:
15364 case INSIDE_IT_LAST_INSN
:
15365 if (thumb_mode
== 0)
15368 && !(implicit_it_mode
& IMPLICIT_IT_MODE_ARM
))
15369 as_tsktsk (_("Warning: conditional outside an IT block"\
15374 if ((implicit_it_mode
& IMPLICIT_IT_MODE_THUMB
)
15375 && ARM_CPU_HAS_FEATURE (cpu_variant
, arm_arch_t2
))
15377 /* Automatically generate the IT instruction. */
15378 new_automatic_it_block (inst
.cond
);
15379 if (inst
.it_insn_type
== INSIDE_IT_LAST_INSN
)
15380 close_automatic_it_block ();
15384 inst
.error
= BAD_OUT_IT
;
15390 case IF_INSIDE_IT_LAST_INSN
:
15391 case NEUTRAL_IT_INSN
:
15395 now_it
.state
= MANUAL_IT_BLOCK
;
15396 now_it
.block_length
= 0;
15401 case AUTOMATIC_IT_BLOCK
:
15402 /* Three things may happen now:
15403 a) We should increment current it block size;
15404 b) We should close current it block (closing insn or 4 insns);
15405 c) We should close current it block and start a new one (due
15406 to incompatible conditions or
15407 4 insns-length block reached). */
15409 switch (inst
.it_insn_type
)
15411 case OUTSIDE_IT_INSN
:
15412 /* The closure of the block shall happen immediatelly,
15413 so any in_it_block () call reports the block as closed. */
15414 force_automatic_it_block_close ();
15417 case INSIDE_IT_INSN
:
15418 case INSIDE_IT_LAST_INSN
:
15419 case IF_INSIDE_IT_LAST_INSN
:
15420 now_it
.block_length
++;
15422 if (now_it
.block_length
> 4
15423 || !now_it_compatible (inst
.cond
))
15425 force_automatic_it_block_close ();
15426 if (inst
.it_insn_type
!= IF_INSIDE_IT_LAST_INSN
)
15427 new_automatic_it_block (inst
.cond
);
15431 now_it_add_mask (inst
.cond
);
15434 if (now_it
.state
== AUTOMATIC_IT_BLOCK
15435 && (inst
.it_insn_type
== INSIDE_IT_LAST_INSN
15436 || inst
.it_insn_type
== IF_INSIDE_IT_LAST_INSN
))
15437 close_automatic_it_block ();
15440 case NEUTRAL_IT_INSN
:
15441 now_it
.block_length
++;
15443 if (now_it
.block_length
> 4)
15444 force_automatic_it_block_close ();
15446 now_it_add_mask (now_it
.cc
& 1);
15450 close_automatic_it_block ();
15451 now_it
.state
= MANUAL_IT_BLOCK
;
15456 case MANUAL_IT_BLOCK
:
15458 /* Check conditional suffixes. */
15459 const int cond
= now_it
.cc
^ ((now_it
.mask
>> 4) & 1) ^ 1;
15462 now_it
.mask
&= 0x1f;
15463 is_last
= (now_it
.mask
== 0x10);
15465 switch (inst
.it_insn_type
)
15467 case OUTSIDE_IT_INSN
:
15468 inst
.error
= BAD_NOT_IT
;
15471 case INSIDE_IT_INSN
:
15472 if (cond
!= inst
.cond
)
15474 inst
.error
= BAD_IT_COND
;
15479 case INSIDE_IT_LAST_INSN
:
15480 case IF_INSIDE_IT_LAST_INSN
:
15481 if (cond
!= inst
.cond
)
15483 inst
.error
= BAD_IT_COND
;
15488 inst
.error
= BAD_BRANCH
;
15493 case NEUTRAL_IT_INSN
:
15494 /* The BKPT instruction is unconditional even in an IT block. */
15498 inst
.error
= BAD_IT_IT
;
15509 it_fsm_post_encode (void)
15513 if (!now_it
.state_handled
)
15514 handle_it_state ();
15516 is_last
= (now_it
.mask
== 0x10);
15519 now_it
.state
= OUTSIDE_IT_BLOCK
;
15525 force_automatic_it_block_close (void)
15527 if (now_it
.state
== AUTOMATIC_IT_BLOCK
)
15529 close_automatic_it_block ();
15530 now_it
.state
= OUTSIDE_IT_BLOCK
;
15538 if (!now_it
.state_handled
)
15539 handle_it_state ();
15541 return now_it
.state
!= OUTSIDE_IT_BLOCK
;
15545 md_assemble (char *str
)
15548 const struct asm_opcode
* opcode
;
15550 /* Align the previous label if needed. */
15551 if (last_label_seen
!= NULL
)
15553 symbol_set_frag (last_label_seen
, frag_now
);
15554 S_SET_VALUE (last_label_seen
, (valueT
) frag_now_fix ());
15555 S_SET_SEGMENT (last_label_seen
, now_seg
);
15558 memset (&inst
, '\0', sizeof (inst
));
15559 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
15561 opcode
= opcode_lookup (&p
);
15564 /* It wasn't an instruction, but it might be a register alias of
15565 the form alias .req reg, or a Neon .dn/.qn directive. */
15566 if (! create_register_alias (str
, p
)
15567 && ! create_neon_reg_alias (str
, p
))
15568 as_bad (_("bad instruction `%s'"), str
);
15573 if (warn_on_deprecated
&& opcode
->tag
== OT_cinfix3_deprecated
)
15574 as_warn (_("s suffix on comparison instruction is deprecated"));
15576 /* The value which unconditional instructions should have in place of the
15577 condition field. */
15578 inst
.uncond_value
= (opcode
->tag
== OT_csuffixF
) ? 0xf : -1;
15582 arm_feature_set variant
;
15584 variant
= cpu_variant
;
15585 /* Only allow coprocessor instructions on Thumb-2 capable devices. */
15586 if (!ARM_CPU_HAS_FEATURE (variant
, arm_arch_t2
))
15587 ARM_CLEAR_FEATURE (variant
, variant
, fpu_any_hard
);
15588 /* Check that this instruction is supported for this CPU. */
15589 if (!opcode
->tvariant
15590 || (thumb_mode
== 1
15591 && !ARM_CPU_HAS_FEATURE (variant
, *opcode
->tvariant
)))
15593 as_bad (_("selected processor does not support `%s'"), str
);
15596 if (inst
.cond
!= COND_ALWAYS
&& !unified_syntax
15597 && opcode
->tencode
!= do_t_branch
)
15599 as_bad (_("Thumb does not support conditional execution"));
15603 if (!ARM_CPU_HAS_FEATURE (variant
, arm_ext_v6t2
))
15605 if (opcode
->tencode
!= do_t_blx
&& opcode
->tencode
!= do_t_branch23
15606 && !(ARM_CPU_HAS_FEATURE(*opcode
->tvariant
, arm_ext_msr
)
15607 || ARM_CPU_HAS_FEATURE(*opcode
->tvariant
, arm_ext_barrier
)))
15609 /* Two things are addressed here.
15610 1) Implicit require narrow instructions on Thumb-1.
15611 This avoids relaxation accidentally introducing Thumb-2
15613 2) Reject wide instructions in non Thumb-2 cores. */
15614 if (inst
.size_req
== 0)
15616 else if (inst
.size_req
== 4)
15618 as_bad (_("selected processor does not support `%s'"), str
);
15624 inst
.instruction
= opcode
->tvalue
;
15626 if (!parse_operands (p
, opcode
->operands
))
15628 /* Prepare the it_insn_type for those encodings that don't set
15630 it_fsm_pre_encode ();
15632 opcode
->tencode ();
15634 it_fsm_post_encode ();
15637 if (!(inst
.error
|| inst
.relax
))
15639 gas_assert (inst
.instruction
< 0xe800 || inst
.instruction
> 0xffff);
15640 inst
.size
= (inst
.instruction
> 0xffff ? 4 : 2);
15641 if (inst
.size_req
&& inst
.size_req
!= inst
.size
)
15643 as_bad (_("cannot honor width suffix -- `%s'"), str
);
15648 /* Something has gone badly wrong if we try to relax a fixed size
15650 gas_assert (inst
.size_req
== 0 || !inst
.relax
);
15652 ARM_MERGE_FEATURE_SETS (thumb_arch_used
, thumb_arch_used
,
15653 *opcode
->tvariant
);
15654 /* Many Thumb-2 instructions also have Thumb-1 variants, so explicitly
15655 set those bits when Thumb-2 32-bit instructions are seen. ie.
15656 anything other than bl/blx and v6-M instructions.
15657 This is overly pessimistic for relaxable instructions. */
15658 if (((inst
.size
== 4 && (inst
.instruction
& 0xf800e800) != 0xf000e800)
15660 && !(ARM_CPU_HAS_FEATURE (*opcode
->tvariant
, arm_ext_msr
)
15661 || ARM_CPU_HAS_FEATURE (*opcode
->tvariant
, arm_ext_barrier
)))
15662 ARM_MERGE_FEATURE_SETS (thumb_arch_used
, thumb_arch_used
,
15665 check_neon_suffixes
;
15669 mapping_state (MAP_THUMB
);
15672 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v1
))
15676 /* bx is allowed on v5 cores, and sometimes on v4 cores. */
15677 is_bx
= (opcode
->aencode
== do_bx
);
15679 /* Check that this instruction is supported for this CPU. */
15680 if (!(is_bx
&& fix_v4bx
)
15681 && !(opcode
->avariant
&&
15682 ARM_CPU_HAS_FEATURE (cpu_variant
, *opcode
->avariant
)))
15684 as_bad (_("selected processor does not support `%s'"), str
);
15689 as_bad (_("width suffixes are invalid in ARM mode -- `%s'"), str
);
15693 inst
.instruction
= opcode
->avalue
;
15694 if (opcode
->tag
== OT_unconditionalF
)
15695 inst
.instruction
|= 0xF << 28;
15697 inst
.instruction
|= inst
.cond
<< 28;
15698 inst
.size
= INSN_SIZE
;
15699 if (!parse_operands (p
, opcode
->operands
))
15701 it_fsm_pre_encode ();
15702 opcode
->aencode ();
15703 it_fsm_post_encode ();
15705 /* Arm mode bx is marked as both v4T and v5 because it's still required
15706 on a hypothetical non-thumb v5 core. */
15708 ARM_MERGE_FEATURE_SETS (arm_arch_used
, arm_arch_used
, arm_ext_v4t
);
15710 ARM_MERGE_FEATURE_SETS (arm_arch_used
, arm_arch_used
,
15711 *opcode
->avariant
);
15713 check_neon_suffixes
;
15717 mapping_state (MAP_ARM
);
15722 as_bad (_("attempt to use an ARM instruction on a Thumb-only processor "
15730 check_it_blocks_finished (void)
15735 for (sect
= stdoutput
->sections
; sect
!= NULL
; sect
= sect
->next
)
15736 if (seg_info (sect
)->tc_segment_info_data
.current_it
.state
15737 == MANUAL_IT_BLOCK
)
15739 as_warn (_("section '%s' finished with an open IT block."),
15743 if (now_it
.state
== MANUAL_IT_BLOCK
)
15744 as_warn (_("file finished with an open IT block."));
15748 /* Various frobbings of labels and their addresses. */
15751 arm_start_line_hook (void)
15753 last_label_seen
= NULL
;
15757 arm_frob_label (symbolS
* sym
)
15759 last_label_seen
= sym
;
15761 ARM_SET_THUMB (sym
, thumb_mode
);
15763 #if defined OBJ_COFF || defined OBJ_ELF
15764 ARM_SET_INTERWORK (sym
, support_interwork
);
15767 force_automatic_it_block_close ();
15769 /* Note - do not allow local symbols (.Lxxx) to be labelled
15770 as Thumb functions. This is because these labels, whilst
15771 they exist inside Thumb code, are not the entry points for
15772 possible ARM->Thumb calls. Also, these labels can be used
15773 as part of a computed goto or switch statement. eg gcc
15774 can generate code that looks like this:
15776 ldr r2, [pc, .Laaa]
15786 The first instruction loads the address of the jump table.
15787 The second instruction converts a table index into a byte offset.
15788 The third instruction gets the jump address out of the table.
15789 The fourth instruction performs the jump.
15791 If the address stored at .Laaa is that of a symbol which has the
15792 Thumb_Func bit set, then the linker will arrange for this address
15793 to have the bottom bit set, which in turn would mean that the
15794 address computation performed by the third instruction would end
15795 up with the bottom bit set. Since the ARM is capable of unaligned
15796 word loads, the instruction would then load the incorrect address
15797 out of the jump table, and chaos would ensue. */
15798 if (label_is_thumb_function_name
15799 && (S_GET_NAME (sym
)[0] != '.' || S_GET_NAME (sym
)[1] != 'L')
15800 && (bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
) != 0)
15802 /* When the address of a Thumb function is taken the bottom
15803 bit of that address should be set. This will allow
15804 interworking between Arm and Thumb functions to work
15807 THUMB_SET_FUNC (sym
, 1);
15809 label_is_thumb_function_name
= FALSE
;
15812 dwarf2_emit_label (sym
);
15816 arm_data_in_code (void)
15818 if (thumb_mode
&& ! strncmp (input_line_pointer
+ 1, "data:", 5))
15820 *input_line_pointer
= '/';
15821 input_line_pointer
+= 5;
15822 *input_line_pointer
= 0;
15830 arm_canonicalize_symbol_name (char * name
)
15834 if (thumb_mode
&& (len
= strlen (name
)) > 5
15835 && streq (name
+ len
- 5, "/data"))
15836 *(name
+ len
- 5) = 0;
15841 /* Table of all register names defined by default. The user can
15842 define additional names with .req. Note that all register names
15843 should appear in both upper and lowercase variants. Some registers
15844 also have mixed-case names. */
15846 #define REGDEF(s,n,t) { #s, n, REG_TYPE_##t, TRUE, 0 }
15847 #define REGNUM(p,n,t) REGDEF(p##n, n, t)
15848 #define REGNUM2(p,n,t) REGDEF(p##n, 2 * n, t)
15849 #define REGSET(p,t) \
15850 REGNUM(p, 0,t), REGNUM(p, 1,t), REGNUM(p, 2,t), REGNUM(p, 3,t), \
15851 REGNUM(p, 4,t), REGNUM(p, 5,t), REGNUM(p, 6,t), REGNUM(p, 7,t), \
15852 REGNUM(p, 8,t), REGNUM(p, 9,t), REGNUM(p,10,t), REGNUM(p,11,t), \
15853 REGNUM(p,12,t), REGNUM(p,13,t), REGNUM(p,14,t), REGNUM(p,15,t)
15854 #define REGSETH(p,t) \
15855 REGNUM(p,16,t), REGNUM(p,17,t), REGNUM(p,18,t), REGNUM(p,19,t), \
15856 REGNUM(p,20,t), REGNUM(p,21,t), REGNUM(p,22,t), REGNUM(p,23,t), \
15857 REGNUM(p,24,t), REGNUM(p,25,t), REGNUM(p,26,t), REGNUM(p,27,t), \
15858 REGNUM(p,28,t), REGNUM(p,29,t), REGNUM(p,30,t), REGNUM(p,31,t)
15859 #define REGSET2(p,t) \
15860 REGNUM2(p, 0,t), REGNUM2(p, 1,t), REGNUM2(p, 2,t), REGNUM2(p, 3,t), \
15861 REGNUM2(p, 4,t), REGNUM2(p, 5,t), REGNUM2(p, 6,t), REGNUM2(p, 7,t), \
15862 REGNUM2(p, 8,t), REGNUM2(p, 9,t), REGNUM2(p,10,t), REGNUM2(p,11,t), \
15863 REGNUM2(p,12,t), REGNUM2(p,13,t), REGNUM2(p,14,t), REGNUM2(p,15,t)
15865 static const struct reg_entry reg_names
[] =
15867 /* ARM integer registers. */
15868 REGSET(r
, RN
), REGSET(R
, RN
),
15870 /* ATPCS synonyms. */
15871 REGDEF(a1
,0,RN
), REGDEF(a2
,1,RN
), REGDEF(a3
, 2,RN
), REGDEF(a4
, 3,RN
),
15872 REGDEF(v1
,4,RN
), REGDEF(v2
,5,RN
), REGDEF(v3
, 6,RN
), REGDEF(v4
, 7,RN
),
15873 REGDEF(v5
,8,RN
), REGDEF(v6
,9,RN
), REGDEF(v7
,10,RN
), REGDEF(v8
,11,RN
),
15875 REGDEF(A1
,0,RN
), REGDEF(A2
,1,RN
), REGDEF(A3
, 2,RN
), REGDEF(A4
, 3,RN
),
15876 REGDEF(V1
,4,RN
), REGDEF(V2
,5,RN
), REGDEF(V3
, 6,RN
), REGDEF(V4
, 7,RN
),
15877 REGDEF(V5
,8,RN
), REGDEF(V6
,9,RN
), REGDEF(V7
,10,RN
), REGDEF(V8
,11,RN
),
15879 /* Well-known aliases. */
15880 REGDEF(wr
, 7,RN
), REGDEF(sb
, 9,RN
), REGDEF(sl
,10,RN
), REGDEF(fp
,11,RN
),
15881 REGDEF(ip
,12,RN
), REGDEF(sp
,13,RN
), REGDEF(lr
,14,RN
), REGDEF(pc
,15,RN
),
15883 REGDEF(WR
, 7,RN
), REGDEF(SB
, 9,RN
), REGDEF(SL
,10,RN
), REGDEF(FP
,11,RN
),
15884 REGDEF(IP
,12,RN
), REGDEF(SP
,13,RN
), REGDEF(LR
,14,RN
), REGDEF(PC
,15,RN
),
15886 /* Coprocessor numbers. */
15887 REGSET(p
, CP
), REGSET(P
, CP
),
15889 /* Coprocessor register numbers. The "cr" variants are for backward
15891 REGSET(c
, CN
), REGSET(C
, CN
),
15892 REGSET(cr
, CN
), REGSET(CR
, CN
),
15894 /* FPA registers. */
15895 REGNUM(f
,0,FN
), REGNUM(f
,1,FN
), REGNUM(f
,2,FN
), REGNUM(f
,3,FN
),
15896 REGNUM(f
,4,FN
), REGNUM(f
,5,FN
), REGNUM(f
,6,FN
), REGNUM(f
,7, FN
),
15898 REGNUM(F
,0,FN
), REGNUM(F
,1,FN
), REGNUM(F
,2,FN
), REGNUM(F
,3,FN
),
15899 REGNUM(F
,4,FN
), REGNUM(F
,5,FN
), REGNUM(F
,6,FN
), REGNUM(F
,7, FN
),
15901 /* VFP SP registers. */
15902 REGSET(s
,VFS
), REGSET(S
,VFS
),
15903 REGSETH(s
,VFS
), REGSETH(S
,VFS
),
15905 /* VFP DP Registers. */
15906 REGSET(d
,VFD
), REGSET(D
,VFD
),
15907 /* Extra Neon DP registers. */
15908 REGSETH(d
,VFD
), REGSETH(D
,VFD
),
15910 /* Neon QP registers. */
15911 REGSET2(q
,NQ
), REGSET2(Q
,NQ
),
15913 /* VFP control registers. */
15914 REGDEF(fpsid
,0,VFC
), REGDEF(fpscr
,1,VFC
), REGDEF(fpexc
,8,VFC
),
15915 REGDEF(FPSID
,0,VFC
), REGDEF(FPSCR
,1,VFC
), REGDEF(FPEXC
,8,VFC
),
15916 REGDEF(fpinst
,9,VFC
), REGDEF(fpinst2
,10,VFC
),
15917 REGDEF(FPINST
,9,VFC
), REGDEF(FPINST2
,10,VFC
),
15918 REGDEF(mvfr0
,7,VFC
), REGDEF(mvfr1
,6,VFC
),
15919 REGDEF(MVFR0
,7,VFC
), REGDEF(MVFR1
,6,VFC
),
15921 /* Maverick DSP coprocessor registers. */
15922 REGSET(mvf
,MVF
), REGSET(mvd
,MVD
), REGSET(mvfx
,MVFX
), REGSET(mvdx
,MVDX
),
15923 REGSET(MVF
,MVF
), REGSET(MVD
,MVD
), REGSET(MVFX
,MVFX
), REGSET(MVDX
,MVDX
),
15925 REGNUM(mvax
,0,MVAX
), REGNUM(mvax
,1,MVAX
),
15926 REGNUM(mvax
,2,MVAX
), REGNUM(mvax
,3,MVAX
),
15927 REGDEF(dspsc
,0,DSPSC
),
15929 REGNUM(MVAX
,0,MVAX
), REGNUM(MVAX
,1,MVAX
),
15930 REGNUM(MVAX
,2,MVAX
), REGNUM(MVAX
,3,MVAX
),
15931 REGDEF(DSPSC
,0,DSPSC
),
15933 /* iWMMXt data registers - p0, c0-15. */
15934 REGSET(wr
,MMXWR
), REGSET(wR
,MMXWR
), REGSET(WR
, MMXWR
),
15936 /* iWMMXt control registers - p1, c0-3. */
15937 REGDEF(wcid
, 0,MMXWC
), REGDEF(wCID
, 0,MMXWC
), REGDEF(WCID
, 0,MMXWC
),
15938 REGDEF(wcon
, 1,MMXWC
), REGDEF(wCon
, 1,MMXWC
), REGDEF(WCON
, 1,MMXWC
),
15939 REGDEF(wcssf
, 2,MMXWC
), REGDEF(wCSSF
, 2,MMXWC
), REGDEF(WCSSF
, 2,MMXWC
),
15940 REGDEF(wcasf
, 3,MMXWC
), REGDEF(wCASF
, 3,MMXWC
), REGDEF(WCASF
, 3,MMXWC
),
15942 /* iWMMXt scalar (constant/offset) registers - p1, c8-11. */
15943 REGDEF(wcgr0
, 8,MMXWCG
), REGDEF(wCGR0
, 8,MMXWCG
), REGDEF(WCGR0
, 8,MMXWCG
),
15944 REGDEF(wcgr1
, 9,MMXWCG
), REGDEF(wCGR1
, 9,MMXWCG
), REGDEF(WCGR1
, 9,MMXWCG
),
15945 REGDEF(wcgr2
,10,MMXWCG
), REGDEF(wCGR2
,10,MMXWCG
), REGDEF(WCGR2
,10,MMXWCG
),
15946 REGDEF(wcgr3
,11,MMXWCG
), REGDEF(wCGR3
,11,MMXWCG
), REGDEF(WCGR3
,11,MMXWCG
),
15948 /* XScale accumulator registers. */
15949 REGNUM(acc
,0,XSCALE
), REGNUM(ACC
,0,XSCALE
),
15955 /* Table of all PSR suffixes. Bare "CPSR" and "SPSR" are handled
15956 within psr_required_here. */
15957 static const struct asm_psr psrs
[] =
15959 /* Backward compatibility notation. Note that "all" is no longer
15960 truly all possible PSR bits. */
15961 {"all", PSR_c
| PSR_f
},
15965 /* Individual flags. */
15970 /* Combinations of flags. */
15971 {"fs", PSR_f
| PSR_s
},
15972 {"fx", PSR_f
| PSR_x
},
15973 {"fc", PSR_f
| PSR_c
},
15974 {"sf", PSR_s
| PSR_f
},
15975 {"sx", PSR_s
| PSR_x
},
15976 {"sc", PSR_s
| PSR_c
},
15977 {"xf", PSR_x
| PSR_f
},
15978 {"xs", PSR_x
| PSR_s
},
15979 {"xc", PSR_x
| PSR_c
},
15980 {"cf", PSR_c
| PSR_f
},
15981 {"cs", PSR_c
| PSR_s
},
15982 {"cx", PSR_c
| PSR_x
},
15983 {"fsx", PSR_f
| PSR_s
| PSR_x
},
15984 {"fsc", PSR_f
| PSR_s
| PSR_c
},
15985 {"fxs", PSR_f
| PSR_x
| PSR_s
},
15986 {"fxc", PSR_f
| PSR_x
| PSR_c
},
15987 {"fcs", PSR_f
| PSR_c
| PSR_s
},
15988 {"fcx", PSR_f
| PSR_c
| PSR_x
},
15989 {"sfx", PSR_s
| PSR_f
| PSR_x
},
15990 {"sfc", PSR_s
| PSR_f
| PSR_c
},
15991 {"sxf", PSR_s
| PSR_x
| PSR_f
},
15992 {"sxc", PSR_s
| PSR_x
| PSR_c
},
15993 {"scf", PSR_s
| PSR_c
| PSR_f
},
15994 {"scx", PSR_s
| PSR_c
| PSR_x
},
15995 {"xfs", PSR_x
| PSR_f
| PSR_s
},
15996 {"xfc", PSR_x
| PSR_f
| PSR_c
},
15997 {"xsf", PSR_x
| PSR_s
| PSR_f
},
15998 {"xsc", PSR_x
| PSR_s
| PSR_c
},
15999 {"xcf", PSR_x
| PSR_c
| PSR_f
},
16000 {"xcs", PSR_x
| PSR_c
| PSR_s
},
16001 {"cfs", PSR_c
| PSR_f
| PSR_s
},
16002 {"cfx", PSR_c
| PSR_f
| PSR_x
},
16003 {"csf", PSR_c
| PSR_s
| PSR_f
},
16004 {"csx", PSR_c
| PSR_s
| PSR_x
},
16005 {"cxf", PSR_c
| PSR_x
| PSR_f
},
16006 {"cxs", PSR_c
| PSR_x
| PSR_s
},
16007 {"fsxc", PSR_f
| PSR_s
| PSR_x
| PSR_c
},
16008 {"fscx", PSR_f
| PSR_s
| PSR_c
| PSR_x
},
16009 {"fxsc", PSR_f
| PSR_x
| PSR_s
| PSR_c
},
16010 {"fxcs", PSR_f
| PSR_x
| PSR_c
| PSR_s
},
16011 {"fcsx", PSR_f
| PSR_c
| PSR_s
| PSR_x
},
16012 {"fcxs", PSR_f
| PSR_c
| PSR_x
| PSR_s
},
16013 {"sfxc", PSR_s
| PSR_f
| PSR_x
| PSR_c
},
16014 {"sfcx", PSR_s
| PSR_f
| PSR_c
| PSR_x
},
16015 {"sxfc", PSR_s
| PSR_x
| PSR_f
| PSR_c
},
16016 {"sxcf", PSR_s
| PSR_x
| PSR_c
| PSR_f
},
16017 {"scfx", PSR_s
| PSR_c
| PSR_f
| PSR_x
},
16018 {"scxf", PSR_s
| PSR_c
| PSR_x
| PSR_f
},
16019 {"xfsc", PSR_x
| PSR_f
| PSR_s
| PSR_c
},
16020 {"xfcs", PSR_x
| PSR_f
| PSR_c
| PSR_s
},
16021 {"xsfc", PSR_x
| PSR_s
| PSR_f
| PSR_c
},
16022 {"xscf", PSR_x
| PSR_s
| PSR_c
| PSR_f
},
16023 {"xcfs", PSR_x
| PSR_c
| PSR_f
| PSR_s
},
16024 {"xcsf", PSR_x
| PSR_c
| PSR_s
| PSR_f
},
16025 {"cfsx", PSR_c
| PSR_f
| PSR_s
| PSR_x
},
16026 {"cfxs", PSR_c
| PSR_f
| PSR_x
| PSR_s
},
16027 {"csfx", PSR_c
| PSR_s
| PSR_f
| PSR_x
},
16028 {"csxf", PSR_c
| PSR_s
| PSR_x
| PSR_f
},
16029 {"cxfs", PSR_c
| PSR_x
| PSR_f
| PSR_s
},
16030 {"cxsf", PSR_c
| PSR_x
| PSR_s
| PSR_f
},
16033 /* Table of V7M psr names. */
16034 static const struct asm_psr v7m_psrs
[] =
16036 {"apsr", 0 }, {"APSR", 0 },
16037 {"iapsr", 1 }, {"IAPSR", 1 },
16038 {"eapsr", 2 }, {"EAPSR", 2 },
16039 {"psr", 3 }, {"PSR", 3 },
16040 {"xpsr", 3 }, {"XPSR", 3 }, {"xPSR", 3 },
16041 {"ipsr", 5 }, {"IPSR", 5 },
16042 {"epsr", 6 }, {"EPSR", 6 },
16043 {"iepsr", 7 }, {"IEPSR", 7 },
16044 {"msp", 8 }, {"MSP", 8 },
16045 {"psp", 9 }, {"PSP", 9 },
16046 {"primask", 16}, {"PRIMASK", 16},
16047 {"basepri", 17}, {"BASEPRI", 17},
16048 {"basepri_max", 18}, {"BASEPRI_MAX", 18},
16049 {"faultmask", 19}, {"FAULTMASK", 19},
16050 {"control", 20}, {"CONTROL", 20}
16053 /* Table of all shift-in-operand names. */
16054 static const struct asm_shift_name shift_names
[] =
16056 { "asl", SHIFT_LSL
}, { "ASL", SHIFT_LSL
},
16057 { "lsl", SHIFT_LSL
}, { "LSL", SHIFT_LSL
},
16058 { "lsr", SHIFT_LSR
}, { "LSR", SHIFT_LSR
},
16059 { "asr", SHIFT_ASR
}, { "ASR", SHIFT_ASR
},
16060 { "ror", SHIFT_ROR
}, { "ROR", SHIFT_ROR
},
16061 { "rrx", SHIFT_RRX
}, { "RRX", SHIFT_RRX
}
16064 /* Table of all explicit relocation names. */
16066 static struct reloc_entry reloc_names
[] =
16068 { "got", BFD_RELOC_ARM_GOT32
}, { "GOT", BFD_RELOC_ARM_GOT32
},
16069 { "gotoff", BFD_RELOC_ARM_GOTOFF
}, { "GOTOFF", BFD_RELOC_ARM_GOTOFF
},
16070 { "plt", BFD_RELOC_ARM_PLT32
}, { "PLT", BFD_RELOC_ARM_PLT32
},
16071 { "target1", BFD_RELOC_ARM_TARGET1
}, { "TARGET1", BFD_RELOC_ARM_TARGET1
},
16072 { "target2", BFD_RELOC_ARM_TARGET2
}, { "TARGET2", BFD_RELOC_ARM_TARGET2
},
16073 { "sbrel", BFD_RELOC_ARM_SBREL32
}, { "SBREL", BFD_RELOC_ARM_SBREL32
},
16074 { "tlsgd", BFD_RELOC_ARM_TLS_GD32
}, { "TLSGD", BFD_RELOC_ARM_TLS_GD32
},
16075 { "tlsldm", BFD_RELOC_ARM_TLS_LDM32
}, { "TLSLDM", BFD_RELOC_ARM_TLS_LDM32
},
16076 { "tlsldo", BFD_RELOC_ARM_TLS_LDO32
}, { "TLSLDO", BFD_RELOC_ARM_TLS_LDO32
},
16077 { "gottpoff",BFD_RELOC_ARM_TLS_IE32
}, { "GOTTPOFF",BFD_RELOC_ARM_TLS_IE32
},
16078 { "tpoff", BFD_RELOC_ARM_TLS_LE32
}, { "TPOFF", BFD_RELOC_ARM_TLS_LE32
}
16082 /* Table of all conditional affixes. 0xF is not defined as a condition code. */
16083 static const struct asm_cond conds
[] =
16087 {"cs", 0x2}, {"hs", 0x2},
16088 {"cc", 0x3}, {"ul", 0x3}, {"lo", 0x3},
16102 static struct asm_barrier_opt barrier_opt_names
[] =
16110 /* Table of ARM-format instructions. */
16112 /* Macros for gluing together operand strings. N.B. In all cases
16113 other than OPS0, the trailing OP_stop comes from default
16114 zero-initialization of the unspecified elements of the array. */
16115 #define OPS0() { OP_stop, }
16116 #define OPS1(a) { OP_##a, }
16117 #define OPS2(a,b) { OP_##a,OP_##b, }
16118 #define OPS3(a,b,c) { OP_##a,OP_##b,OP_##c, }
16119 #define OPS4(a,b,c,d) { OP_##a,OP_##b,OP_##c,OP_##d, }
16120 #define OPS5(a,b,c,d,e) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e, }
16121 #define OPS6(a,b,c,d,e,f) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e,OP_##f, }
16123 /* These macros abstract out the exact format of the mnemonic table and
16124 save some repeated characters. */
16126 /* The normal sort of mnemonic; has a Thumb variant; takes a conditional suffix. */
16127 #define TxCE(mnem, op, top, nops, ops, ae, te) \
16128 { mnem, OPS##nops ops, OT_csuffix, 0x##op, top, ARM_VARIANT, \
16129 THUMB_VARIANT, do_##ae, do_##te }
16131 /* Two variants of the above - TCE for a numeric Thumb opcode, tCE for
16132 a T_MNEM_xyz enumerator. */
16133 #define TCE(mnem, aop, top, nops, ops, ae, te) \
16134 TxCE (mnem, aop, 0x##top, nops, ops, ae, te)
16135 #define tCE(mnem, aop, top, nops, ops, ae, te) \
16136 TxCE (mnem, aop, T_MNEM##top, nops, ops, ae, te)
16138 /* Second most common sort of mnemonic: has a Thumb variant, takes a conditional
16139 infix after the third character. */
16140 #define TxC3(mnem, op, top, nops, ops, ae, te) \
16141 { mnem, OPS##nops ops, OT_cinfix3, 0x##op, top, ARM_VARIANT, \
16142 THUMB_VARIANT, do_##ae, do_##te }
16143 #define TxC3w(mnem, op, top, nops, ops, ae, te) \
16144 { mnem, OPS##nops ops, OT_cinfix3_deprecated, 0x##op, top, ARM_VARIANT, \
16145 THUMB_VARIANT, do_##ae, do_##te }
16146 #define TC3(mnem, aop, top, nops, ops, ae, te) \
16147 TxC3 (mnem, aop, 0x##top, nops, ops, ae, te)
16148 #define TC3w(mnem, aop, top, nops, ops, ae, te) \
16149 TxC3w (mnem, aop, 0x##top, nops, ops, ae, te)
16150 #define tC3(mnem, aop, top, nops, ops, ae, te) \
16151 TxC3 (mnem, aop, T_MNEM##top, nops, ops, ae, te)
16152 #define tC3w(mnem, aop, top, nops, ops, ae, te) \
16153 TxC3w (mnem, aop, T_MNEM##top, nops, ops, ae, te)
16155 /* Mnemonic with a conditional infix in an unusual place. Each and every variant has to
16156 appear in the condition table. */
16157 #define TxCM_(m1, m2, m3, op, top, nops, ops, ae, te) \
16158 { m1 #m2 m3, OPS##nops ops, sizeof (#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof (m1) - 1, \
16159 0x##op, top, ARM_VARIANT, THUMB_VARIANT, do_##ae, do_##te }
16161 #define TxCM(m1, m2, op, top, nops, ops, ae, te) \
16162 TxCM_ (m1, , m2, op, top, nops, ops, ae, te), \
16163 TxCM_ (m1, eq, m2, op, top, nops, ops, ae, te), \
16164 TxCM_ (m1, ne, m2, op, top, nops, ops, ae, te), \
16165 TxCM_ (m1, cs, m2, op, top, nops, ops, ae, te), \
16166 TxCM_ (m1, hs, m2, op, top, nops, ops, ae, te), \
16167 TxCM_ (m1, cc, m2, op, top, nops, ops, ae, te), \
16168 TxCM_ (m1, ul, m2, op, top, nops, ops, ae, te), \
16169 TxCM_ (m1, lo, m2, op, top, nops, ops, ae, te), \
16170 TxCM_ (m1, mi, m2, op, top, nops, ops, ae, te), \
16171 TxCM_ (m1, pl, m2, op, top, nops, ops, ae, te), \
16172 TxCM_ (m1, vs, m2, op, top, nops, ops, ae, te), \
16173 TxCM_ (m1, vc, m2, op, top, nops, ops, ae, te), \
16174 TxCM_ (m1, hi, m2, op, top, nops, ops, ae, te), \
16175 TxCM_ (m1, ls, m2, op, top, nops, ops, ae, te), \
16176 TxCM_ (m1, ge, m2, op, top, nops, ops, ae, te), \
16177 TxCM_ (m1, lt, m2, op, top, nops, ops, ae, te), \
16178 TxCM_ (m1, gt, m2, op, top, nops, ops, ae, te), \
16179 TxCM_ (m1, le, m2, op, top, nops, ops, ae, te), \
16180 TxCM_ (m1, al, m2, op, top, nops, ops, ae, te)
16182 #define TCM(m1,m2, aop, top, nops, ops, ae, te) \
16183 TxCM (m1,m2, aop, 0x##top, nops, ops, ae, te)
16184 #define tCM(m1,m2, aop, top, nops, ops, ae, te) \
16185 TxCM (m1,m2, aop, T_MNEM##top, nops, ops, ae, te)
16187 /* Mnemonic that cannot be conditionalized. The ARM condition-code
16188 field is still 0xE. Many of the Thumb variants can be executed
16189 conditionally, so this is checked separately. */
16190 #define TUE(mnem, op, top, nops, ops, ae, te) \
16191 { mnem, OPS##nops ops, OT_unconditional, 0x##op, 0x##top, ARM_VARIANT, \
16192 THUMB_VARIANT, do_##ae, do_##te }
16194 /* Mnemonic that cannot be conditionalized, and bears 0xF in its ARM
16195 condition code field. */
16196 #define TUF(mnem, op, top, nops, ops, ae, te) \
16197 { mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##top, ARM_VARIANT, \
16198 THUMB_VARIANT, do_##ae, do_##te }
16200 /* ARM-only variants of all the above. */
16201 #define CE(mnem, op, nops, ops, ae) \
16202 { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
16204 #define C3(mnem, op, nops, ops, ae) \
16205 { #mnem, OPS##nops ops, OT_cinfix3, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
16207 /* Legacy mnemonics that always have conditional infix after the third
16209 #define CL(mnem, op, nops, ops, ae) \
16210 { mnem, OPS##nops ops, OT_cinfix3_legacy, \
16211 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
16213 /* Coprocessor instructions. Isomorphic between Arm and Thumb-2. */
16214 #define cCE(mnem, op, nops, ops, ae) \
16215 { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
16217 /* Legacy coprocessor instructions where conditional infix and conditional
16218 suffix are ambiguous. For consistency this includes all FPA instructions,
16219 not just the potentially ambiguous ones. */
16220 #define cCL(mnem, op, nops, ops, ae) \
16221 { mnem, OPS##nops ops, OT_cinfix3_legacy, \
16222 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
16224 /* Coprocessor, takes either a suffix or a position-3 infix
16225 (for an FPA corner case). */
16226 #define C3E(mnem, op, nops, ops, ae) \
16227 { mnem, OPS##nops ops, OT_csuf_or_in3, \
16228 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
16230 #define xCM_(m1, m2, m3, op, nops, ops, ae) \
16231 { m1 #m2 m3, OPS##nops ops, \
16232 sizeof (#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof (m1) - 1, \
16233 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
16235 #define CM(m1, m2, op, nops, ops, ae) \
16236 xCM_ (m1, , m2, op, nops, ops, ae), \
16237 xCM_ (m1, eq, m2, op, nops, ops, ae), \
16238 xCM_ (m1, ne, m2, op, nops, ops, ae), \
16239 xCM_ (m1, cs, m2, op, nops, ops, ae), \
16240 xCM_ (m1, hs, m2, op, nops, ops, ae), \
16241 xCM_ (m1, cc, m2, op, nops, ops, ae), \
16242 xCM_ (m1, ul, m2, op, nops, ops, ae), \
16243 xCM_ (m1, lo, m2, op, nops, ops, ae), \
16244 xCM_ (m1, mi, m2, op, nops, ops, ae), \
16245 xCM_ (m1, pl, m2, op, nops, ops, ae), \
16246 xCM_ (m1, vs, m2, op, nops, ops, ae), \
16247 xCM_ (m1, vc, m2, op, nops, ops, ae), \
16248 xCM_ (m1, hi, m2, op, nops, ops, ae), \
16249 xCM_ (m1, ls, m2, op, nops, ops, ae), \
16250 xCM_ (m1, ge, m2, op, nops, ops, ae), \
16251 xCM_ (m1, lt, m2, op, nops, ops, ae), \
16252 xCM_ (m1, gt, m2, op, nops, ops, ae), \
16253 xCM_ (m1, le, m2, op, nops, ops, ae), \
16254 xCM_ (m1, al, m2, op, nops, ops, ae)
16256 #define UE(mnem, op, nops, ops, ae) \
16257 { #mnem, OPS##nops ops, OT_unconditional, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
16259 #define UF(mnem, op, nops, ops, ae) \
16260 { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
16262 /* Neon data-processing. ARM versions are unconditional with cond=0xf.
16263 The Thumb and ARM variants are mostly the same (bits 0-23 and 24/28), so we
16264 use the same encoding function for each. */
16265 #define NUF(mnem, op, nops, ops, enc) \
16266 { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##op, \
16267 ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
16269 /* Neon data processing, version which indirects through neon_enc_tab for
16270 the various overloaded versions of opcodes. */
16271 #define nUF(mnem, op, nops, ops, enc) \
16272 { #mnem, OPS##nops ops, OT_unconditionalF, N_MNEM##op, N_MNEM##op, \
16273 ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
16275 /* Neon insn with conditional suffix for the ARM version, non-overloaded
16277 #define NCE_tag(mnem, op, nops, ops, enc, tag) \
16278 { #mnem, OPS##nops ops, tag, 0x##op, 0x##op, ARM_VARIANT, \
16279 THUMB_VARIANT, do_##enc, do_##enc }
16281 #define NCE(mnem, op, nops, ops, enc) \
16282 NCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
16284 #define NCEF(mnem, op, nops, ops, enc) \
16285 NCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
16287 /* Neon insn with conditional suffix for the ARM version, overloaded types. */
16288 #define nCE_tag(mnem, op, nops, ops, enc, tag) \
16289 { #mnem, OPS##nops ops, tag, N_MNEM##op, N_MNEM##op, \
16290 ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
16292 #define nCE(mnem, op, nops, ops, enc) \
16293 nCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
16295 #define nCEF(mnem, op, nops, ops, enc) \
16296 nCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
16300 /* Thumb-only, unconditional. */
16301 #define UT(mnem, op, nops, ops, te) TUE (mnem, 0, op, nops, ops, 0, te)
16303 static const struct asm_opcode insns
[] =
16305 #define ARM_VARIANT &arm_ext_v1 /* Core ARM Instructions. */
16306 #define THUMB_VARIANT &arm_ext_v4t
16307 tCE("and", 0000000, _and
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16308 tC3("ands", 0100000, _ands
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16309 tCE("eor", 0200000, _eor
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16310 tC3("eors", 0300000, _eors
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16311 tCE("sub", 0400000, _sub
, 3, (RR
, oRR
, SH
), arit
, t_add_sub
),
16312 tC3("subs", 0500000, _subs
, 3, (RR
, oRR
, SH
), arit
, t_add_sub
),
16313 tCE("add", 0800000, _add
, 3, (RR
, oRR
, SHG
), arit
, t_add_sub
),
16314 tC3("adds", 0900000, _adds
, 3, (RR
, oRR
, SHG
), arit
, t_add_sub
),
16315 tCE("adc", 0a00000
, _adc
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16316 tC3("adcs", 0b00000, _adcs
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16317 tCE("sbc", 0c00000
, _sbc
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
16318 tC3("sbcs", 0d00000
, _sbcs
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
16319 tCE("orr", 1800000, _orr
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16320 tC3("orrs", 1900000, _orrs
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16321 tCE("bic", 1c00000
, _bic
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
16322 tC3("bics", 1d00000
, _bics
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
16324 /* The p-variants of tst/cmp/cmn/teq (below) are the pre-V6 mechanism
16325 for setting PSR flag bits. They are obsolete in V6 and do not
16326 have Thumb equivalents. */
16327 tCE("tst", 1100000, _tst
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16328 tC3w("tsts", 1100000, _tst
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16329 CL("tstp", 110f000
, 2, (RR
, SH
), cmp
),
16330 tCE("cmp", 1500000, _cmp
, 2, (RR
, SH
), cmp
, t_mov_cmp
),
16331 tC3w("cmps", 1500000, _cmp
, 2, (RR
, SH
), cmp
, t_mov_cmp
),
16332 CL("cmpp", 150f000
, 2, (RR
, SH
), cmp
),
16333 tCE("cmn", 1700000, _cmn
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16334 tC3w("cmns", 1700000, _cmn
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16335 CL("cmnp", 170f000
, 2, (RR
, SH
), cmp
),
16337 tCE("mov", 1a00000
, _mov
, 2, (RR
, SH
), mov
, t_mov_cmp
),
16338 tC3("movs", 1b00000
, _movs
, 2, (RR
, SH
), mov
, t_mov_cmp
),
16339 tCE("mvn", 1e00000
, _mvn
, 2, (RR
, SH
), mov
, t_mvn_tst
),
16340 tC3("mvns", 1f00000
, _mvns
, 2, (RR
, SH
), mov
, t_mvn_tst
),
16342 tCE("ldr", 4100000, _ldr
, 2, (RR
, ADDRGLDR
),ldst
, t_ldst
),
16343 tC3("ldrb", 4500000, _ldrb
, 2, (RR
, ADDRGLDR
),ldst
, t_ldst
),
16344 tCE("str", 4000000, _str
, 2, (RR
, ADDRGLDR
),ldst
, t_ldst
),
16345 tC3("strb", 4400000, _strb
, 2, (RR
, ADDRGLDR
),ldst
, t_ldst
),
16347 tCE("stm", 8800000, _stmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16348 tC3("stmia", 8800000, _stmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16349 tC3("stmea", 8800000, _stmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16350 tCE("ldm", 8900000, _ldmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16351 tC3("ldmia", 8900000, _ldmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16352 tC3("ldmfd", 8900000, _ldmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16354 TCE("swi", f000000
, df00
, 1, (EXPi
), swi
, t_swi
),
16355 TCE("svc", f000000
, df00
, 1, (EXPi
), swi
, t_swi
),
16356 tCE("b", a000000
, _b
, 1, (EXPr
), branch
, t_branch
),
16357 TCE("bl", b000000
, f000f800
, 1, (EXPr
), bl
, t_branch23
),
16360 tCE("adr", 28f0000
, _adr
, 2, (RR
, EXP
), adr
, t_adr
),
16361 C3(adrl
, 28f0000
, 2, (RR
, EXP
), adrl
),
16362 tCE("nop", 1a00000
, _nop
, 1, (oI255c
), nop
, t_nop
),
16364 /* Thumb-compatibility pseudo ops. */
16365 tCE("lsl", 1a00000
, _lsl
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16366 tC3("lsls", 1b00000
, _lsls
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16367 tCE("lsr", 1a00020
, _lsr
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16368 tC3("lsrs", 1b00020
, _lsrs
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16369 tCE("asr", 1a00040
, _asr
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16370 tC3("asrs", 1b00040
, _asrs
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16371 tCE("ror", 1a00060
, _ror
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16372 tC3("rors", 1b00060
, _rors
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16373 tCE("neg", 2600000, _neg
, 2, (RR
, RR
), rd_rn
, t_neg
),
16374 tC3("negs", 2700000, _negs
, 2, (RR
, RR
), rd_rn
, t_neg
),
16375 tCE("push", 92d0000
, _push
, 1, (REGLST
), push_pop
, t_push_pop
),
16376 tCE("pop", 8bd0000
, _pop
, 1, (REGLST
), push_pop
, t_push_pop
),
16378 /* These may simplify to neg. */
16379 TCE("rsb", 0600000, ebc00000
, 3, (RR
, oRR
, SH
), arit
, t_rsb
),
16380 TC3("rsbs", 0700000, ebd00000
, 3, (RR
, oRR
, SH
), arit
, t_rsb
),
16382 #undef THUMB_VARIANT
16383 #define THUMB_VARIANT & arm_ext_v6
16385 TCE("cpy", 1a00000
, 4600, 2, (RR
, RR
), rd_rm
, t_cpy
),
16387 /* V1 instructions with no Thumb analogue prior to V6T2. */
16388 #undef THUMB_VARIANT
16389 #define THUMB_VARIANT & arm_ext_v6t2
16391 TCE("teq", 1300000, ea900f00
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16392 TC3w("teqs", 1300000, ea900f00
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16393 CL("teqp", 130f000
, 2, (RR
, SH
), cmp
),
16395 TC3("ldrt", 4300000, f8500e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
16396 TC3("ldrbt", 4700000, f8100e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
16397 TC3("strt", 4200000, f8400e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
16398 TC3("strbt", 4600000, f8000e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
16400 TC3("stmdb", 9000000, e9000000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16401 TC3("stmfd", 9000000, e9000000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16403 TC3("ldmdb", 9100000, e9100000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16404 TC3("ldmea", 9100000, e9100000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16406 /* V1 instructions with no Thumb analogue at all. */
16407 CE("rsc", 0e00000
, 3, (RR
, oRR
, SH
), arit
),
16408 C3(rscs
, 0f00000
, 3, (RR
, oRR
, SH
), arit
),
16410 C3(stmib
, 9800000, 2, (RRw
, REGLST
), ldmstm
),
16411 C3(stmfa
, 9800000, 2, (RRw
, REGLST
), ldmstm
),
16412 C3(stmda
, 8000000, 2, (RRw
, REGLST
), ldmstm
),
16413 C3(stmed
, 8000000, 2, (RRw
, REGLST
), ldmstm
),
16414 C3(ldmib
, 9900000, 2, (RRw
, REGLST
), ldmstm
),
16415 C3(ldmed
, 9900000, 2, (RRw
, REGLST
), ldmstm
),
16416 C3(ldmda
, 8100000, 2, (RRw
, REGLST
), ldmstm
),
16417 C3(ldmfa
, 8100000, 2, (RRw
, REGLST
), ldmstm
),
16420 #define ARM_VARIANT & arm_ext_v2 /* ARM 2 - multiplies. */
16421 #undef THUMB_VARIANT
16422 #define THUMB_VARIANT & arm_ext_v4t
16424 tCE("mul", 0000090, _mul
, 3, (RRnpc
, RRnpc
, oRR
), mul
, t_mul
),
16425 tC3("muls", 0100090, _muls
, 3, (RRnpc
, RRnpc
, oRR
), mul
, t_mul
),
16427 #undef THUMB_VARIANT
16428 #define THUMB_VARIANT & arm_ext_v6t2
16430 TCE("mla", 0200090, fb000000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mlas
, t_mla
),
16431 C3(mlas
, 0300090, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mlas
),
16433 /* Generic coprocessor instructions. */
16434 TCE("cdp", e000000
, ee000000
, 6, (RCP
, I15b
, RCN
, RCN
, RCN
, oI7b
), cdp
, cdp
),
16435 TCE("ldc", c100000
, ec100000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16436 TC3("ldcl", c500000
, ec500000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16437 TCE("stc", c000000
, ec000000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16438 TC3("stcl", c400000
, ec400000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16439 TCE("mcr", e000010
, ee000010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
16440 TCE("mrc", e100010
, ee100010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
16443 #define ARM_VARIANT & arm_ext_v2s /* ARM 3 - swp instructions. */
16445 CE("swp", 1000090, 3, (RRnpc
, RRnpc
, RRnpcb
), rd_rm_rn
),
16446 C3(swpb
, 1400090, 3, (RRnpc
, RRnpc
, RRnpcb
), rd_rm_rn
),
16449 #define ARM_VARIANT & arm_ext_v3 /* ARM 6 Status register instructions. */
16450 #undef THUMB_VARIANT
16451 #define THUMB_VARIANT & arm_ext_msr
16453 TCE("mrs", 10f0000
, f3ef8000
, 2, (APSR_RR
, RVC_PSR
), mrs
, t_mrs
),
16454 TCE("msr", 120f000
, f3808000
, 2, (RVC_PSR
, RR_EXi
), msr
, t_msr
),
16457 #define ARM_VARIANT & arm_ext_v3m /* ARM 7M long multiplies. */
16458 #undef THUMB_VARIANT
16459 #define THUMB_VARIANT & arm_ext_v6t2
16461 TCE("smull", 0c00090
, fb800000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
16462 CM("smull","s", 0d00090
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
16463 TCE("umull", 0800090, fba00000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
16464 CM("umull","s", 0900090, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
16465 TCE("smlal", 0e00090
, fbc00000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
16466 CM("smlal","s", 0f00090
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
16467 TCE("umlal", 0a00090
, fbe00000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
16468 CM("umlal","s", 0b00090, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
16471 #define ARM_VARIANT & arm_ext_v4 /* ARM Architecture 4. */
16472 #undef THUMB_VARIANT
16473 #define THUMB_VARIANT & arm_ext_v4t
16475 tC3("ldrh", 01000b0
, _ldrh
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16476 tC3("strh", 00000b0
, _strh
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16477 tC3("ldrsh", 01000f0
, _ldrsh
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16478 tC3("ldrsb", 01000d0
, _ldrsb
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16479 tCM("ld","sh", 01000f0
, _ldrsh
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16480 tCM("ld","sb", 01000d0
, _ldrsb
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16483 #define ARM_VARIANT & arm_ext_v4t_5
16485 /* ARM Architecture 4T. */
16486 /* Note: bx (and blx) are required on V5, even if the processor does
16487 not support Thumb. */
16488 TCE("bx", 12fff10
, 4700, 1, (RR
), bx
, t_bx
),
16491 #define ARM_VARIANT & arm_ext_v5 /* ARM Architecture 5T. */
16492 #undef THUMB_VARIANT
16493 #define THUMB_VARIANT & arm_ext_v5t
16495 /* Note: blx has 2 variants; the .value coded here is for
16496 BLX(2). Only this variant has conditional execution. */
16497 TCE("blx", 12fff30
, 4780, 1, (RR_EXr
), blx
, t_blx
),
16498 TUE("bkpt", 1200070, be00
, 1, (oIffffb
), bkpt
, t_bkpt
),
16500 #undef THUMB_VARIANT
16501 #define THUMB_VARIANT & arm_ext_v6t2
16503 TCE("clz", 16f0f10
, fab0f080
, 2, (RRnpc
, RRnpc
), rd_rm
, t_clz
),
16504 TUF("ldc2", c100000
, fc100000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16505 TUF("ldc2l", c500000
, fc500000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16506 TUF("stc2", c000000
, fc000000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16507 TUF("stc2l", c400000
, fc400000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16508 TUF("cdp2", e000000
, fe000000
, 6, (RCP
, I15b
, RCN
, RCN
, RCN
, oI7b
), cdp
, cdp
),
16509 TUF("mcr2", e000010
, fe000010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
16510 TUF("mrc2", e100010
, fe100010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
16513 #define ARM_VARIANT & arm_ext_v5exp /* ARM Architecture 5TExP. */
16514 #undef THUMB_VARIANT
16515 #define THUMB_VARIANT &arm_ext_v5exp
16517 TCE("smlabb", 1000080, fb100000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16518 TCE("smlatb", 10000a0
, fb100020
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16519 TCE("smlabt", 10000c0
, fb100010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16520 TCE("smlatt", 10000e0
, fb100030
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16522 TCE("smlawb", 1200080, fb300000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16523 TCE("smlawt", 12000c0
, fb300010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16525 TCE("smlalbb", 1400080, fbc00080
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
16526 TCE("smlaltb", 14000a0
, fbc000a0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
16527 TCE("smlalbt", 14000c0
, fbc00090
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
16528 TCE("smlaltt", 14000e0
, fbc000b0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
16530 TCE("smulbb", 1600080, fb10f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16531 TCE("smultb", 16000a0
, fb10f020
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16532 TCE("smulbt", 16000c0
, fb10f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16533 TCE("smultt", 16000e0
, fb10f030
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16535 TCE("smulwb", 12000a0
, fb30f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16536 TCE("smulwt", 12000e0
, fb30f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16538 TCE("qadd", 1000050, fa80f080
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, t_simd2
),
16539 TCE("qdadd", 1400050, fa80f090
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, t_simd2
),
16540 TCE("qsub", 1200050, fa80f0a0
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, t_simd2
),
16541 TCE("qdsub", 1600050, fa80f0b0
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, t_simd2
),
16544 #define ARM_VARIANT & arm_ext_v5e /* ARM Architecture 5TE. */
16545 #undef THUMB_VARIANT
16546 #define THUMB_VARIANT &arm_ext_v6t2
16548 TUF("pld", 450f000
, f810f000
, 1, (ADDR
), pld
, t_pld
),
16549 TC3("ldrd", 00000d0
, e8500000
, 3, (RRnpc
, oRRnpc
, ADDRGLDRS
), ldrd
, t_ldstd
),
16550 TC3("strd", 00000f0
, e8400000
, 3, (RRnpc
, oRRnpc
, ADDRGLDRS
), ldrd
, t_ldstd
),
16552 TCE("mcrr", c400000
, ec400000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
16553 TCE("mrrc", c500000
, ec500000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
16556 #define ARM_VARIANT & arm_ext_v5j /* ARM Architecture 5TEJ. */
16558 TCE("bxj", 12fff20
, f3c08f00
, 1, (RR
), bxj
, t_bxj
),
16561 #define ARM_VARIANT & arm_ext_v6 /* ARM V6. */
16562 #undef THUMB_VARIANT
16563 #define THUMB_VARIANT & arm_ext_v6
16565 TUF("cpsie", 1080000, b660
, 2, (CPSF
, oI31b
), cpsi
, t_cpsi
),
16566 TUF("cpsid", 10c0000
, b670
, 2, (CPSF
, oI31b
), cpsi
, t_cpsi
),
16567 tCE("rev", 6bf0f30
, _rev
, 2, (RRnpc
, RRnpc
), rd_rm
, t_rev
),
16568 tCE("rev16", 6bf0fb0
, _rev16
, 2, (RRnpc
, RRnpc
), rd_rm
, t_rev
),
16569 tCE("revsh", 6ff0fb0
, _revsh
, 2, (RRnpc
, RRnpc
), rd_rm
, t_rev
),
16570 tCE("sxth", 6bf0070
, _sxth
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16571 tCE("uxth", 6ff0070
, _uxth
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16572 tCE("sxtb", 6af0070
, _sxtb
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16573 tCE("uxtb", 6ef0070
, _uxtb
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16574 TUF("setend", 1010000, b650
, 1, (ENDI
), setend
, t_setend
),
16576 #undef THUMB_VARIANT
16577 #define THUMB_VARIANT & arm_ext_v6t2
16579 TCE("ldrex", 1900f9f
, e8500f00
, 2, (RRnpc
, ADDR
), ldrex
, t_ldrex
),
16580 TCE("strex", 1800f90
, e8400000
, 3, (RRnpc
, RRnpc
, ADDR
), strex
, t_strex
),
16581 TUF("mcrr2", c400000
, fc400000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
16582 TUF("mrrc2", c500000
, fc500000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
16584 TCE("ssat", 6a00010
, f3000000
, 4, (RRnpc
, I32
, RRnpc
, oSHllar
),ssat
, t_ssat
),
16585 TCE("usat", 6e00010
, f3800000
, 4, (RRnpc
, I31
, RRnpc
, oSHllar
),usat
, t_usat
),
16587 /* ARM V6 not included in V7M. */
16588 #undef THUMB_VARIANT
16589 #define THUMB_VARIANT & arm_ext_v6_notm
16590 TUF("rfeia", 8900a00
, e990c000
, 1, (RRw
), rfe
, rfe
),
16591 UF(rfeib
, 9900a00
, 1, (RRw
), rfe
),
16592 UF(rfeda
, 8100a00
, 1, (RRw
), rfe
),
16593 TUF("rfedb", 9100a00
, e810c000
, 1, (RRw
), rfe
, rfe
),
16594 TUF("rfefd", 8900a00
, e990c000
, 1, (RRw
), rfe
, rfe
),
16595 UF(rfefa
, 9900a00
, 1, (RRw
), rfe
),
16596 UF(rfeea
, 8100a00
, 1, (RRw
), rfe
),
16597 TUF("rfeed", 9100a00
, e810c000
, 1, (RRw
), rfe
, rfe
),
16598 TUF("srsia", 8c00500
, e980c000
, 2, (oRRw
, I31w
), srs
, srs
),
16599 UF(srsib
, 9c00500
, 2, (oRRw
, I31w
), srs
),
16600 UF(srsda
, 8400500, 2, (oRRw
, I31w
), srs
),
16601 TUF("srsdb", 9400500, e800c000
, 2, (oRRw
, I31w
), srs
, srs
),
16603 /* ARM V6 not included in V7M (eg. integer SIMD). */
16604 #undef THUMB_VARIANT
16605 #define THUMB_VARIANT & arm_ext_v6_dsp
16606 TUF("cps", 1020000, f3af8100
, 1, (I31b
), imm0
, t_cps
),
16607 TCE("pkhbt", 6800010, eac00000
, 4, (RRnpc
, RRnpc
, RRnpc
, oSHll
), pkhbt
, t_pkhbt
),
16608 TCE("pkhtb", 6800050, eac00020
, 4, (RRnpc
, RRnpc
, RRnpc
, oSHar
), pkhtb
, t_pkhtb
),
16609 TCE("qadd16", 6200f10
, fa90f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16610 TCE("qadd8", 6200f90
, fa80f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16611 TCE("qasx", 6200f30
, faa0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16612 /* Old name for QASX. */
16613 TCE("qaddsubx", 6200f30
, faa0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16614 TCE("qsax", 6200f50
, fae0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16615 /* Old name for QSAX. */
16616 TCE("qsubaddx", 6200f50
, fae0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16617 TCE("qsub16", 6200f70
, fad0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16618 TCE("qsub8", 6200ff0
, fac0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16619 TCE("sadd16", 6100f10
, fa90f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16620 TCE("sadd8", 6100f90
, fa80f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16621 TCE("sasx", 6100f30
, faa0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16622 /* Old name for SASX. */
16623 TCE("saddsubx", 6100f30
, faa0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16624 TCE("shadd16", 6300f10
, fa90f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16625 TCE("shadd8", 6300f90
, fa80f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16626 TCE("shasx", 6300f30
, faa0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16627 /* Old name for SHASX. */
16628 TCE("shaddsubx", 6300f30
, faa0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16629 TCE("shsax", 6300f50
, fae0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16630 /* Old name for SHSAX. */
16631 TCE("shsubaddx", 6300f50
, fae0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16632 TCE("shsub16", 6300f70
, fad0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16633 TCE("shsub8", 6300ff0
, fac0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16634 TCE("ssax", 6100f50
, fae0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16635 /* Old name for SSAX. */
16636 TCE("ssubaddx", 6100f50
, fae0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16637 TCE("ssub16", 6100f70
, fad0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16638 TCE("ssub8", 6100ff0
, fac0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16639 TCE("uadd16", 6500f10
, fa90f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16640 TCE("uadd8", 6500f90
, fa80f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16641 TCE("uasx", 6500f30
, faa0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16642 /* Old name for UASX. */
16643 TCE("uaddsubx", 6500f30
, faa0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16644 TCE("uhadd16", 6700f10
, fa90f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16645 TCE("uhadd8", 6700f90
, fa80f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16646 TCE("uhasx", 6700f30
, faa0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16647 /* Old name for UHASX. */
16648 TCE("uhaddsubx", 6700f30
, faa0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16649 TCE("uhsax", 6700f50
, fae0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16650 /* Old name for UHSAX. */
16651 TCE("uhsubaddx", 6700f50
, fae0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16652 TCE("uhsub16", 6700f70
, fad0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16653 TCE("uhsub8", 6700ff0
, fac0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16654 TCE("uqadd16", 6600f10
, fa90f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16655 TCE("uqadd8", 6600f90
, fa80f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16656 TCE("uqasx", 6600f30
, faa0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16657 /* Old name for UQASX. */
16658 TCE("uqaddsubx", 6600f30
, faa0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16659 TCE("uqsax", 6600f50
, fae0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16660 /* Old name for UQSAX. */
16661 TCE("uqsubaddx", 6600f50
, fae0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16662 TCE("uqsub16", 6600f70
, fad0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16663 TCE("uqsub8", 6600ff0
, fac0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16664 TCE("usub16", 6500f70
, fad0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16665 TCE("usax", 6500f50
, fae0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16666 /* Old name for USAX. */
16667 TCE("usubaddx", 6500f50
, fae0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16668 TCE("usub8", 6500ff0
, fac0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16669 TCE("sxtah", 6b00070
, fa00f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16670 TCE("sxtab16", 6800070, fa20f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16671 TCE("sxtab", 6a00070
, fa40f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16672 TCE("sxtb16", 68f0070
, fa2ff080
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16673 TCE("uxtah", 6f00070
, fa10f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16674 TCE("uxtab16", 6c00070
, fa30f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16675 TCE("uxtab", 6e00070
, fa50f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16676 TCE("uxtb16", 6cf0070
, fa3ff080
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16677 TCE("sel", 6800fb0
, faa0f080
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16678 TCE("smlad", 7000010, fb200000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16679 TCE("smladx", 7000030, fb200010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16680 TCE("smlald", 7400010, fbc000c0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
16681 TCE("smlaldx", 7400030, fbc000d0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
16682 TCE("smlsd", 7000050, fb400000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16683 TCE("smlsdx", 7000070, fb400010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16684 TCE("smlsld", 7400050, fbd000c0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
16685 TCE("smlsldx", 7400070, fbd000d0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
16686 TCE("smmla", 7500010, fb500000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16687 TCE("smmlar", 7500030, fb500010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16688 TCE("smmls", 75000d0
, fb600000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16689 TCE("smmlsr", 75000f0
, fb600010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16690 TCE("smmul", 750f010
, fb50f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16691 TCE("smmulr", 750f030
, fb50f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16692 TCE("smuad", 700f010
, fb20f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16693 TCE("smuadx", 700f030
, fb20f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16694 TCE("smusd", 700f050
, fb40f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16695 TCE("smusdx", 700f070
, fb40f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16696 TCE("ssat16", 6a00f30
, f3200000
, 3, (RRnpc
, I16
, RRnpc
), ssat16
, t_ssat16
),
16697 TCE("umaal", 0400090, fbe00060
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
, t_mlal
),
16698 TCE("usad8", 780f010
, fb70f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16699 TCE("usada8", 7800010, fb700000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16700 TCE("usat16", 6e00f30
, f3a00000
, 3, (RRnpc
, I15
, RRnpc
), usat16
, t_usat16
),
16703 #define ARM_VARIANT & arm_ext_v6k
16704 #undef THUMB_VARIANT
16705 #define THUMB_VARIANT & arm_ext_v6k
16707 tCE("yield", 320f001
, _yield
, 0, (), noargs
, t_hint
),
16708 tCE("wfe", 320f002
, _wfe
, 0, (), noargs
, t_hint
),
16709 tCE("wfi", 320f003
, _wfi
, 0, (), noargs
, t_hint
),
16710 tCE("sev", 320f004
, _sev
, 0, (), noargs
, t_hint
),
16712 #undef THUMB_VARIANT
16713 #define THUMB_VARIANT & arm_ext_v6_notm
16715 TCE("ldrexd", 1b00f9f
, e8d0007f
, 3, (RRnpc
, oRRnpc
, RRnpcb
), ldrexd
, t_ldrexd
),
16716 TCE("strexd", 1a00f90
, e8c00070
, 4, (RRnpc
, RRnpc
, oRRnpc
, RRnpcb
), strexd
, t_strexd
),
16718 #undef THUMB_VARIANT
16719 #define THUMB_VARIANT & arm_ext_v6t2
16721 TCE("ldrexb", 1d00f9f
, e8d00f4f
, 2, (RRnpc
, RRnpcb
), rd_rn
, rd_rn
),
16722 TCE("ldrexh", 1f00f9f
, e8d00f5f
, 2, (RRnpc
, RRnpcb
), rd_rn
, rd_rn
),
16723 TCE("strexb", 1c00f90
, e8c00f40
, 3, (RRnpc
, RRnpc
, ADDR
), strex
, rm_rd_rn
),
16724 TCE("strexh", 1e00f90
, e8c00f50
, 3, (RRnpc
, RRnpc
, ADDR
), strex
, rm_rd_rn
),
16725 TUF("clrex", 57ff01f
, f3bf8f2f
, 0, (), noargs
, noargs
),
16728 #define ARM_VARIANT & arm_ext_v6z
16730 TCE("smc", 1600070, f7f08000
, 1, (EXPi
), smc
, t_smc
),
16733 #define ARM_VARIANT & arm_ext_v6t2
16735 TCE("bfc", 7c0001f
, f36f0000
, 3, (RRnpc
, I31
, I32
), bfc
, t_bfc
),
16736 TCE("bfi", 7c00010
, f3600000
, 4, (RRnpc
, RRnpc_I0
, I31
, I32
), bfi
, t_bfi
),
16737 TCE("sbfx", 7a00050
, f3400000
, 4, (RR
, RR
, I31
, I32
), bfx
, t_bfx
),
16738 TCE("ubfx", 7e00050
, f3c00000
, 4, (RR
, RR
, I31
, I32
), bfx
, t_bfx
),
16740 TCE("mls", 0600090, fb000010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mlas
, t_mla
),
16741 TCE("movw", 3000000, f2400000
, 2, (RRnpc
, HALF
), mov16
, t_mov16
),
16742 TCE("movt", 3400000, f2c00000
, 2, (RRnpc
, HALF
), mov16
, t_mov16
),
16743 TCE("rbit", 6ff0f30
, fa90f0a0
, 2, (RR
, RR
), rd_rm
, t_rbit
),
16745 TC3("ldrht", 03000b0
, f8300e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
16746 TC3("ldrsht", 03000f0
, f9300e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
16747 TC3("ldrsbt", 03000d0
, f9100e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
16748 TC3("strht", 02000b0
, f8200e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
16750 UT("cbnz", b900
, 2, (RR
, EXP
), t_cbz
),
16751 UT("cbz", b100
, 2, (RR
, EXP
), t_cbz
),
16753 /* ARM does not really have an IT instruction, so always allow it.
16754 The opcode is copied from Thumb in order to allow warnings in
16755 -mimplicit-it=[never | arm] modes. */
16757 #define ARM_VARIANT & arm_ext_v1
16759 TUE("it", bf08
, bf08
, 1, (COND
), it
, t_it
),
16760 TUE("itt", bf0c
, bf0c
, 1, (COND
), it
, t_it
),
16761 TUE("ite", bf04
, bf04
, 1, (COND
), it
, t_it
),
16762 TUE("ittt", bf0e
, bf0e
, 1, (COND
), it
, t_it
),
16763 TUE("itet", bf06
, bf06
, 1, (COND
), it
, t_it
),
16764 TUE("itte", bf0a
, bf0a
, 1, (COND
), it
, t_it
),
16765 TUE("itee", bf02
, bf02
, 1, (COND
), it
, t_it
),
16766 TUE("itttt", bf0f
, bf0f
, 1, (COND
), it
, t_it
),
16767 TUE("itett", bf07
, bf07
, 1, (COND
), it
, t_it
),
16768 TUE("ittet", bf0b
, bf0b
, 1, (COND
), it
, t_it
),
16769 TUE("iteet", bf03
, bf03
, 1, (COND
), it
, t_it
),
16770 TUE("ittte", bf0d
, bf0d
, 1, (COND
), it
, t_it
),
16771 TUE("itete", bf05
, bf05
, 1, (COND
), it
, t_it
),
16772 TUE("ittee", bf09
, bf09
, 1, (COND
), it
, t_it
),
16773 TUE("iteee", bf01
, bf01
, 1, (COND
), it
, t_it
),
16774 /* ARM/Thumb-2 instructions with no Thumb-1 equivalent. */
16775 TC3("rrx", 01a00060
, ea4f0030
, 2, (RR
, RR
), rd_rm
, t_rrx
),
16776 TC3("rrxs", 01b00060
, ea5f0030
, 2, (RR
, RR
), rd_rm
, t_rrx
),
16778 /* Thumb2 only instructions. */
16780 #define ARM_VARIANT NULL
16782 TCE("addw", 0, f2000000
, 3, (RR
, RR
, EXPi
), 0, t_add_sub_w
),
16783 TCE("subw", 0, f2a00000
, 3, (RR
, RR
, EXPi
), 0, t_add_sub_w
),
16784 TCE("orn", 0, ea600000
, 3, (RR
, oRR
, SH
), 0, t_orn
),
16785 TCE("orns", 0, ea700000
, 3, (RR
, oRR
, SH
), 0, t_orn
),
16786 TCE("tbb", 0, e8d0f000
, 1, (TB
), 0, t_tb
),
16787 TCE("tbh", 0, e8d0f010
, 1, (TB
), 0, t_tb
),
16789 /* Thumb-2 hardware division instructions (R and M profiles only). */
16790 #undef THUMB_VARIANT
16791 #define THUMB_VARIANT & arm_ext_div
16793 TCE("sdiv", 0, fb90f0f0
, 3, (RR
, oRR
, RR
), 0, t_div
),
16794 TCE("udiv", 0, fbb0f0f0
, 3, (RR
, oRR
, RR
), 0, t_div
),
16796 /* ARM V6M/V7 instructions. */
16798 #define ARM_VARIANT & arm_ext_barrier
16799 #undef THUMB_VARIANT
16800 #define THUMB_VARIANT & arm_ext_barrier
16802 TUF("dmb", 57ff050
, f3bf8f50
, 1, (oBARRIER
), barrier
, t_barrier
),
16803 TUF("dsb", 57ff040
, f3bf8f40
, 1, (oBARRIER
), barrier
, t_barrier
),
16804 TUF("isb", 57ff060
, f3bf8f60
, 1, (oBARRIER
), barrier
, t_barrier
),
16806 /* ARM V7 instructions. */
16808 #define ARM_VARIANT & arm_ext_v7
16809 #undef THUMB_VARIANT
16810 #define THUMB_VARIANT & arm_ext_v7
16812 TUF("pli", 450f000
, f910f000
, 1, (ADDR
), pli
, t_pld
),
16813 TCE("dbg", 320f0f0
, f3af80f0
, 1, (I15
), dbg
, t_dbg
),
16816 #define ARM_VARIANT & fpu_fpa_ext_v1 /* Core FPA instruction set (V1). */
16818 cCE("wfs", e200110
, 1, (RR
), rd
),
16819 cCE("rfs", e300110
, 1, (RR
), rd
),
16820 cCE("wfc", e400110
, 1, (RR
), rd
),
16821 cCE("rfc", e500110
, 1, (RR
), rd
),
16823 cCL("ldfs", c100100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16824 cCL("ldfd", c108100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16825 cCL("ldfe", c500100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16826 cCL("ldfp", c508100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16828 cCL("stfs", c000100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16829 cCL("stfd", c008100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16830 cCL("stfe", c400100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16831 cCL("stfp", c408100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16833 cCL("mvfs", e008100
, 2, (RF
, RF_IF
), rd_rm
),
16834 cCL("mvfsp", e008120
, 2, (RF
, RF_IF
), rd_rm
),
16835 cCL("mvfsm", e008140
, 2, (RF
, RF_IF
), rd_rm
),
16836 cCL("mvfsz", e008160
, 2, (RF
, RF_IF
), rd_rm
),
16837 cCL("mvfd", e008180
, 2, (RF
, RF_IF
), rd_rm
),
16838 cCL("mvfdp", e0081a0
, 2, (RF
, RF_IF
), rd_rm
),
16839 cCL("mvfdm", e0081c0
, 2, (RF
, RF_IF
), rd_rm
),
16840 cCL("mvfdz", e0081e0
, 2, (RF
, RF_IF
), rd_rm
),
16841 cCL("mvfe", e088100
, 2, (RF
, RF_IF
), rd_rm
),
16842 cCL("mvfep", e088120
, 2, (RF
, RF_IF
), rd_rm
),
16843 cCL("mvfem", e088140
, 2, (RF
, RF_IF
), rd_rm
),
16844 cCL("mvfez", e088160
, 2, (RF
, RF_IF
), rd_rm
),
16846 cCL("mnfs", e108100
, 2, (RF
, RF_IF
), rd_rm
),
16847 cCL("mnfsp", e108120
, 2, (RF
, RF_IF
), rd_rm
),
16848 cCL("mnfsm", e108140
, 2, (RF
, RF_IF
), rd_rm
),
16849 cCL("mnfsz", e108160
, 2, (RF
, RF_IF
), rd_rm
),
16850 cCL("mnfd", e108180
, 2, (RF
, RF_IF
), rd_rm
),
16851 cCL("mnfdp", e1081a0
, 2, (RF
, RF_IF
), rd_rm
),
16852 cCL("mnfdm", e1081c0
, 2, (RF
, RF_IF
), rd_rm
),
16853 cCL("mnfdz", e1081e0
, 2, (RF
, RF_IF
), rd_rm
),
16854 cCL("mnfe", e188100
, 2, (RF
, RF_IF
), rd_rm
),
16855 cCL("mnfep", e188120
, 2, (RF
, RF_IF
), rd_rm
),
16856 cCL("mnfem", e188140
, 2, (RF
, RF_IF
), rd_rm
),
16857 cCL("mnfez", e188160
, 2, (RF
, RF_IF
), rd_rm
),
16859 cCL("abss", e208100
, 2, (RF
, RF_IF
), rd_rm
),
16860 cCL("abssp", e208120
, 2, (RF
, RF_IF
), rd_rm
),
16861 cCL("abssm", e208140
, 2, (RF
, RF_IF
), rd_rm
),
16862 cCL("abssz", e208160
, 2, (RF
, RF_IF
), rd_rm
),
16863 cCL("absd", e208180
, 2, (RF
, RF_IF
), rd_rm
),
16864 cCL("absdp", e2081a0
, 2, (RF
, RF_IF
), rd_rm
),
16865 cCL("absdm", e2081c0
, 2, (RF
, RF_IF
), rd_rm
),
16866 cCL("absdz", e2081e0
, 2, (RF
, RF_IF
), rd_rm
),
16867 cCL("abse", e288100
, 2, (RF
, RF_IF
), rd_rm
),
16868 cCL("absep", e288120
, 2, (RF
, RF_IF
), rd_rm
),
16869 cCL("absem", e288140
, 2, (RF
, RF_IF
), rd_rm
),
16870 cCL("absez", e288160
, 2, (RF
, RF_IF
), rd_rm
),
16872 cCL("rnds", e308100
, 2, (RF
, RF_IF
), rd_rm
),
16873 cCL("rndsp", e308120
, 2, (RF
, RF_IF
), rd_rm
),
16874 cCL("rndsm", e308140
, 2, (RF
, RF_IF
), rd_rm
),
16875 cCL("rndsz", e308160
, 2, (RF
, RF_IF
), rd_rm
),
16876 cCL("rndd", e308180
, 2, (RF
, RF_IF
), rd_rm
),
16877 cCL("rnddp", e3081a0
, 2, (RF
, RF_IF
), rd_rm
),
16878 cCL("rnddm", e3081c0
, 2, (RF
, RF_IF
), rd_rm
),
16879 cCL("rnddz", e3081e0
, 2, (RF
, RF_IF
), rd_rm
),
16880 cCL("rnde", e388100
, 2, (RF
, RF_IF
), rd_rm
),
16881 cCL("rndep", e388120
, 2, (RF
, RF_IF
), rd_rm
),
16882 cCL("rndem", e388140
, 2, (RF
, RF_IF
), rd_rm
),
16883 cCL("rndez", e388160
, 2, (RF
, RF_IF
), rd_rm
),
16885 cCL("sqts", e408100
, 2, (RF
, RF_IF
), rd_rm
),
16886 cCL("sqtsp", e408120
, 2, (RF
, RF_IF
), rd_rm
),
16887 cCL("sqtsm", e408140
, 2, (RF
, RF_IF
), rd_rm
),
16888 cCL("sqtsz", e408160
, 2, (RF
, RF_IF
), rd_rm
),
16889 cCL("sqtd", e408180
, 2, (RF
, RF_IF
), rd_rm
),
16890 cCL("sqtdp", e4081a0
, 2, (RF
, RF_IF
), rd_rm
),
16891 cCL("sqtdm", e4081c0
, 2, (RF
, RF_IF
), rd_rm
),
16892 cCL("sqtdz", e4081e0
, 2, (RF
, RF_IF
), rd_rm
),
16893 cCL("sqte", e488100
, 2, (RF
, RF_IF
), rd_rm
),
16894 cCL("sqtep", e488120
, 2, (RF
, RF_IF
), rd_rm
),
16895 cCL("sqtem", e488140
, 2, (RF
, RF_IF
), rd_rm
),
16896 cCL("sqtez", e488160
, 2, (RF
, RF_IF
), rd_rm
),
16898 cCL("logs", e508100
, 2, (RF
, RF_IF
), rd_rm
),
16899 cCL("logsp", e508120
, 2, (RF
, RF_IF
), rd_rm
),
16900 cCL("logsm", e508140
, 2, (RF
, RF_IF
), rd_rm
),
16901 cCL("logsz", e508160
, 2, (RF
, RF_IF
), rd_rm
),
16902 cCL("logd", e508180
, 2, (RF
, RF_IF
), rd_rm
),
16903 cCL("logdp", e5081a0
, 2, (RF
, RF_IF
), rd_rm
),
16904 cCL("logdm", e5081c0
, 2, (RF
, RF_IF
), rd_rm
),
16905 cCL("logdz", e5081e0
, 2, (RF
, RF_IF
), rd_rm
),
16906 cCL("loge", e588100
, 2, (RF
, RF_IF
), rd_rm
),
16907 cCL("logep", e588120
, 2, (RF
, RF_IF
), rd_rm
),
16908 cCL("logem", e588140
, 2, (RF
, RF_IF
), rd_rm
),
16909 cCL("logez", e588160
, 2, (RF
, RF_IF
), rd_rm
),
16911 cCL("lgns", e608100
, 2, (RF
, RF_IF
), rd_rm
),
16912 cCL("lgnsp", e608120
, 2, (RF
, RF_IF
), rd_rm
),
16913 cCL("lgnsm", e608140
, 2, (RF
, RF_IF
), rd_rm
),
16914 cCL("lgnsz", e608160
, 2, (RF
, RF_IF
), rd_rm
),
16915 cCL("lgnd", e608180
, 2, (RF
, RF_IF
), rd_rm
),
16916 cCL("lgndp", e6081a0
, 2, (RF
, RF_IF
), rd_rm
),
16917 cCL("lgndm", e6081c0
, 2, (RF
, RF_IF
), rd_rm
),
16918 cCL("lgndz", e6081e0
, 2, (RF
, RF_IF
), rd_rm
),
16919 cCL("lgne", e688100
, 2, (RF
, RF_IF
), rd_rm
),
16920 cCL("lgnep", e688120
, 2, (RF
, RF_IF
), rd_rm
),
16921 cCL("lgnem", e688140
, 2, (RF
, RF_IF
), rd_rm
),
16922 cCL("lgnez", e688160
, 2, (RF
, RF_IF
), rd_rm
),
16924 cCL("exps", e708100
, 2, (RF
, RF_IF
), rd_rm
),
16925 cCL("expsp", e708120
, 2, (RF
, RF_IF
), rd_rm
),
16926 cCL("expsm", e708140
, 2, (RF
, RF_IF
), rd_rm
),
16927 cCL("expsz", e708160
, 2, (RF
, RF_IF
), rd_rm
),
16928 cCL("expd", e708180
, 2, (RF
, RF_IF
), rd_rm
),
16929 cCL("expdp", e7081a0
, 2, (RF
, RF_IF
), rd_rm
),
16930 cCL("expdm", e7081c0
, 2, (RF
, RF_IF
), rd_rm
),
16931 cCL("expdz", e7081e0
, 2, (RF
, RF_IF
), rd_rm
),
16932 cCL("expe", e788100
, 2, (RF
, RF_IF
), rd_rm
),
16933 cCL("expep", e788120
, 2, (RF
, RF_IF
), rd_rm
),
16934 cCL("expem", e788140
, 2, (RF
, RF_IF
), rd_rm
),
16935 cCL("expdz", e788160
, 2, (RF
, RF_IF
), rd_rm
),
16937 cCL("sins", e808100
, 2, (RF
, RF_IF
), rd_rm
),
16938 cCL("sinsp", e808120
, 2, (RF
, RF_IF
), rd_rm
),
16939 cCL("sinsm", e808140
, 2, (RF
, RF_IF
), rd_rm
),
16940 cCL("sinsz", e808160
, 2, (RF
, RF_IF
), rd_rm
),
16941 cCL("sind", e808180
, 2, (RF
, RF_IF
), rd_rm
),
16942 cCL("sindp", e8081a0
, 2, (RF
, RF_IF
), rd_rm
),
16943 cCL("sindm", e8081c0
, 2, (RF
, RF_IF
), rd_rm
),
16944 cCL("sindz", e8081e0
, 2, (RF
, RF_IF
), rd_rm
),
16945 cCL("sine", e888100
, 2, (RF
, RF_IF
), rd_rm
),
16946 cCL("sinep", e888120
, 2, (RF
, RF_IF
), rd_rm
),
16947 cCL("sinem", e888140
, 2, (RF
, RF_IF
), rd_rm
),
16948 cCL("sinez", e888160
, 2, (RF
, RF_IF
), rd_rm
),
16950 cCL("coss", e908100
, 2, (RF
, RF_IF
), rd_rm
),
16951 cCL("cossp", e908120
, 2, (RF
, RF_IF
), rd_rm
),
16952 cCL("cossm", e908140
, 2, (RF
, RF_IF
), rd_rm
),
16953 cCL("cossz", e908160
, 2, (RF
, RF_IF
), rd_rm
),
16954 cCL("cosd", e908180
, 2, (RF
, RF_IF
), rd_rm
),
16955 cCL("cosdp", e9081a0
, 2, (RF
, RF_IF
), rd_rm
),
16956 cCL("cosdm", e9081c0
, 2, (RF
, RF_IF
), rd_rm
),
16957 cCL("cosdz", e9081e0
, 2, (RF
, RF_IF
), rd_rm
),
16958 cCL("cose", e988100
, 2, (RF
, RF_IF
), rd_rm
),
16959 cCL("cosep", e988120
, 2, (RF
, RF_IF
), rd_rm
),
16960 cCL("cosem", e988140
, 2, (RF
, RF_IF
), rd_rm
),
16961 cCL("cosez", e988160
, 2, (RF
, RF_IF
), rd_rm
),
16963 cCL("tans", ea08100
, 2, (RF
, RF_IF
), rd_rm
),
16964 cCL("tansp", ea08120
, 2, (RF
, RF_IF
), rd_rm
),
16965 cCL("tansm", ea08140
, 2, (RF
, RF_IF
), rd_rm
),
16966 cCL("tansz", ea08160
, 2, (RF
, RF_IF
), rd_rm
),
16967 cCL("tand", ea08180
, 2, (RF
, RF_IF
), rd_rm
),
16968 cCL("tandp", ea081a0
, 2, (RF
, RF_IF
), rd_rm
),
16969 cCL("tandm", ea081c0
, 2, (RF
, RF_IF
), rd_rm
),
16970 cCL("tandz", ea081e0
, 2, (RF
, RF_IF
), rd_rm
),
16971 cCL("tane", ea88100
, 2, (RF
, RF_IF
), rd_rm
),
16972 cCL("tanep", ea88120
, 2, (RF
, RF_IF
), rd_rm
),
16973 cCL("tanem", ea88140
, 2, (RF
, RF_IF
), rd_rm
),
16974 cCL("tanez", ea88160
, 2, (RF
, RF_IF
), rd_rm
),
16976 cCL("asns", eb08100
, 2, (RF
, RF_IF
), rd_rm
),
16977 cCL("asnsp", eb08120
, 2, (RF
, RF_IF
), rd_rm
),
16978 cCL("asnsm", eb08140
, 2, (RF
, RF_IF
), rd_rm
),
16979 cCL("asnsz", eb08160
, 2, (RF
, RF_IF
), rd_rm
),
16980 cCL("asnd", eb08180
, 2, (RF
, RF_IF
), rd_rm
),
16981 cCL("asndp", eb081a0
, 2, (RF
, RF_IF
), rd_rm
),
16982 cCL("asndm", eb081c0
, 2, (RF
, RF_IF
), rd_rm
),
16983 cCL("asndz", eb081e0
, 2, (RF
, RF_IF
), rd_rm
),
16984 cCL("asne", eb88100
, 2, (RF
, RF_IF
), rd_rm
),
16985 cCL("asnep", eb88120
, 2, (RF
, RF_IF
), rd_rm
),
16986 cCL("asnem", eb88140
, 2, (RF
, RF_IF
), rd_rm
),
16987 cCL("asnez", eb88160
, 2, (RF
, RF_IF
), rd_rm
),
16989 cCL("acss", ec08100
, 2, (RF
, RF_IF
), rd_rm
),
16990 cCL("acssp", ec08120
, 2, (RF
, RF_IF
), rd_rm
),
16991 cCL("acssm", ec08140
, 2, (RF
, RF_IF
), rd_rm
),
16992 cCL("acssz", ec08160
, 2, (RF
, RF_IF
), rd_rm
),
16993 cCL("acsd", ec08180
, 2, (RF
, RF_IF
), rd_rm
),
16994 cCL("acsdp", ec081a0
, 2, (RF
, RF_IF
), rd_rm
),
16995 cCL("acsdm", ec081c0
, 2, (RF
, RF_IF
), rd_rm
),
16996 cCL("acsdz", ec081e0
, 2, (RF
, RF_IF
), rd_rm
),
16997 cCL("acse", ec88100
, 2, (RF
, RF_IF
), rd_rm
),
16998 cCL("acsep", ec88120
, 2, (RF
, RF_IF
), rd_rm
),
16999 cCL("acsem", ec88140
, 2, (RF
, RF_IF
), rd_rm
),
17000 cCL("acsez", ec88160
, 2, (RF
, RF_IF
), rd_rm
),
17002 cCL("atns", ed08100
, 2, (RF
, RF_IF
), rd_rm
),
17003 cCL("atnsp", ed08120
, 2, (RF
, RF_IF
), rd_rm
),
17004 cCL("atnsm", ed08140
, 2, (RF
, RF_IF
), rd_rm
),
17005 cCL("atnsz", ed08160
, 2, (RF
, RF_IF
), rd_rm
),
17006 cCL("atnd", ed08180
, 2, (RF
, RF_IF
), rd_rm
),
17007 cCL("atndp", ed081a0
, 2, (RF
, RF_IF
), rd_rm
),
17008 cCL("atndm", ed081c0
, 2, (RF
, RF_IF
), rd_rm
),
17009 cCL("atndz", ed081e0
, 2, (RF
, RF_IF
), rd_rm
),
17010 cCL("atne", ed88100
, 2, (RF
, RF_IF
), rd_rm
),
17011 cCL("atnep", ed88120
, 2, (RF
, RF_IF
), rd_rm
),
17012 cCL("atnem", ed88140
, 2, (RF
, RF_IF
), rd_rm
),
17013 cCL("atnez", ed88160
, 2, (RF
, RF_IF
), rd_rm
),
17015 cCL("urds", ee08100
, 2, (RF
, RF_IF
), rd_rm
),
17016 cCL("urdsp", ee08120
, 2, (RF
, RF_IF
), rd_rm
),
17017 cCL("urdsm", ee08140
, 2, (RF
, RF_IF
), rd_rm
),
17018 cCL("urdsz", ee08160
, 2, (RF
, RF_IF
), rd_rm
),
17019 cCL("urdd", ee08180
, 2, (RF
, RF_IF
), rd_rm
),
17020 cCL("urddp", ee081a0
, 2, (RF
, RF_IF
), rd_rm
),
17021 cCL("urddm", ee081c0
, 2, (RF
, RF_IF
), rd_rm
),
17022 cCL("urddz", ee081e0
, 2, (RF
, RF_IF
), rd_rm
),
17023 cCL("urde", ee88100
, 2, (RF
, RF_IF
), rd_rm
),
17024 cCL("urdep", ee88120
, 2, (RF
, RF_IF
), rd_rm
),
17025 cCL("urdem", ee88140
, 2, (RF
, RF_IF
), rd_rm
),
17026 cCL("urdez", ee88160
, 2, (RF
, RF_IF
), rd_rm
),
17028 cCL("nrms", ef08100
, 2, (RF
, RF_IF
), rd_rm
),
17029 cCL("nrmsp", ef08120
, 2, (RF
, RF_IF
), rd_rm
),
17030 cCL("nrmsm", ef08140
, 2, (RF
, RF_IF
), rd_rm
),
17031 cCL("nrmsz", ef08160
, 2, (RF
, RF_IF
), rd_rm
),
17032 cCL("nrmd", ef08180
, 2, (RF
, RF_IF
), rd_rm
),
17033 cCL("nrmdp", ef081a0
, 2, (RF
, RF_IF
), rd_rm
),
17034 cCL("nrmdm", ef081c0
, 2, (RF
, RF_IF
), rd_rm
),
17035 cCL("nrmdz", ef081e0
, 2, (RF
, RF_IF
), rd_rm
),
17036 cCL("nrme", ef88100
, 2, (RF
, RF_IF
), rd_rm
),
17037 cCL("nrmep", ef88120
, 2, (RF
, RF_IF
), rd_rm
),
17038 cCL("nrmem", ef88140
, 2, (RF
, RF_IF
), rd_rm
),
17039 cCL("nrmez", ef88160
, 2, (RF
, RF_IF
), rd_rm
),
17041 cCL("adfs", e000100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17042 cCL("adfsp", e000120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17043 cCL("adfsm", e000140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17044 cCL("adfsz", e000160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17045 cCL("adfd", e000180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17046 cCL("adfdp", e0001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17047 cCL("adfdm", e0001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17048 cCL("adfdz", e0001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17049 cCL("adfe", e080100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17050 cCL("adfep", e080120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17051 cCL("adfem", e080140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17052 cCL("adfez", e080160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17054 cCL("sufs", e200100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17055 cCL("sufsp", e200120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17056 cCL("sufsm", e200140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17057 cCL("sufsz", e200160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17058 cCL("sufd", e200180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17059 cCL("sufdp", e2001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17060 cCL("sufdm", e2001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17061 cCL("sufdz", e2001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17062 cCL("sufe", e280100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17063 cCL("sufep", e280120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17064 cCL("sufem", e280140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17065 cCL("sufez", e280160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17067 cCL("rsfs", e300100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17068 cCL("rsfsp", e300120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17069 cCL("rsfsm", e300140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17070 cCL("rsfsz", e300160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17071 cCL("rsfd", e300180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17072 cCL("rsfdp", e3001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17073 cCL("rsfdm", e3001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17074 cCL("rsfdz", e3001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17075 cCL("rsfe", e380100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17076 cCL("rsfep", e380120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17077 cCL("rsfem", e380140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17078 cCL("rsfez", e380160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17080 cCL("mufs", e100100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17081 cCL("mufsp", e100120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17082 cCL("mufsm", e100140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17083 cCL("mufsz", e100160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17084 cCL("mufd", e100180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17085 cCL("mufdp", e1001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17086 cCL("mufdm", e1001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17087 cCL("mufdz", e1001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17088 cCL("mufe", e180100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17089 cCL("mufep", e180120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17090 cCL("mufem", e180140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17091 cCL("mufez", e180160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17093 cCL("dvfs", e400100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17094 cCL("dvfsp", e400120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17095 cCL("dvfsm", e400140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17096 cCL("dvfsz", e400160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17097 cCL("dvfd", e400180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17098 cCL("dvfdp", e4001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17099 cCL("dvfdm", e4001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17100 cCL("dvfdz", e4001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17101 cCL("dvfe", e480100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17102 cCL("dvfep", e480120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17103 cCL("dvfem", e480140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17104 cCL("dvfez", e480160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17106 cCL("rdfs", e500100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17107 cCL("rdfsp", e500120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17108 cCL("rdfsm", e500140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17109 cCL("rdfsz", e500160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17110 cCL("rdfd", e500180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17111 cCL("rdfdp", e5001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17112 cCL("rdfdm", e5001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17113 cCL("rdfdz", e5001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17114 cCL("rdfe", e580100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17115 cCL("rdfep", e580120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17116 cCL("rdfem", e580140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17117 cCL("rdfez", e580160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17119 cCL("pows", e600100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17120 cCL("powsp", e600120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17121 cCL("powsm", e600140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17122 cCL("powsz", e600160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17123 cCL("powd", e600180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17124 cCL("powdp", e6001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17125 cCL("powdm", e6001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17126 cCL("powdz", e6001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17127 cCL("powe", e680100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17128 cCL("powep", e680120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17129 cCL("powem", e680140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17130 cCL("powez", e680160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17132 cCL("rpws", e700100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17133 cCL("rpwsp", e700120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17134 cCL("rpwsm", e700140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17135 cCL("rpwsz", e700160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17136 cCL("rpwd", e700180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17137 cCL("rpwdp", e7001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17138 cCL("rpwdm", e7001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17139 cCL("rpwdz", e7001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17140 cCL("rpwe", e780100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17141 cCL("rpwep", e780120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17142 cCL("rpwem", e780140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17143 cCL("rpwez", e780160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17145 cCL("rmfs", e800100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17146 cCL("rmfsp", e800120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17147 cCL("rmfsm", e800140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17148 cCL("rmfsz", e800160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17149 cCL("rmfd", e800180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17150 cCL("rmfdp", e8001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17151 cCL("rmfdm", e8001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17152 cCL("rmfdz", e8001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17153 cCL("rmfe", e880100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17154 cCL("rmfep", e880120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17155 cCL("rmfem", e880140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17156 cCL("rmfez", e880160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17158 cCL("fmls", e900100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17159 cCL("fmlsp", e900120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17160 cCL("fmlsm", e900140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17161 cCL("fmlsz", e900160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17162 cCL("fmld", e900180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17163 cCL("fmldp", e9001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17164 cCL("fmldm", e9001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17165 cCL("fmldz", e9001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17166 cCL("fmle", e980100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17167 cCL("fmlep", e980120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17168 cCL("fmlem", e980140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17169 cCL("fmlez", e980160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17171 cCL("fdvs", ea00100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17172 cCL("fdvsp", ea00120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17173 cCL("fdvsm", ea00140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17174 cCL("fdvsz", ea00160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17175 cCL("fdvd", ea00180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17176 cCL("fdvdp", ea001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17177 cCL("fdvdm", ea001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17178 cCL("fdvdz", ea001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17179 cCL("fdve", ea80100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17180 cCL("fdvep", ea80120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17181 cCL("fdvem", ea80140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17182 cCL("fdvez", ea80160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17184 cCL("frds", eb00100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17185 cCL("frdsp", eb00120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17186 cCL("frdsm", eb00140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17187 cCL("frdsz", eb00160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17188 cCL("frdd", eb00180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17189 cCL("frddp", eb001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17190 cCL("frddm", eb001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17191 cCL("frddz", eb001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17192 cCL("frde", eb80100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17193 cCL("frdep", eb80120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17194 cCL("frdem", eb80140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17195 cCL("frdez", eb80160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17197 cCL("pols", ec00100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17198 cCL("polsp", ec00120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17199 cCL("polsm", ec00140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17200 cCL("polsz", ec00160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17201 cCL("pold", ec00180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17202 cCL("poldp", ec001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17203 cCL("poldm", ec001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17204 cCL("poldz", ec001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17205 cCL("pole", ec80100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17206 cCL("polep", ec80120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17207 cCL("polem", ec80140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17208 cCL("polez", ec80160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17210 cCE("cmf", e90f110
, 2, (RF
, RF_IF
), fpa_cmp
),
17211 C3E("cmfe", ed0f110
, 2, (RF
, RF_IF
), fpa_cmp
),
17212 cCE("cnf", eb0f110
, 2, (RF
, RF_IF
), fpa_cmp
),
17213 C3E("cnfe", ef0f110
, 2, (RF
, RF_IF
), fpa_cmp
),
17215 cCL("flts", e000110
, 2, (RF
, RR
), rn_rd
),
17216 cCL("fltsp", e000130
, 2, (RF
, RR
), rn_rd
),
17217 cCL("fltsm", e000150
, 2, (RF
, RR
), rn_rd
),
17218 cCL("fltsz", e000170
, 2, (RF
, RR
), rn_rd
),
17219 cCL("fltd", e000190
, 2, (RF
, RR
), rn_rd
),
17220 cCL("fltdp", e0001b0
, 2, (RF
, RR
), rn_rd
),
17221 cCL("fltdm", e0001d0
, 2, (RF
, RR
), rn_rd
),
17222 cCL("fltdz", e0001f0
, 2, (RF
, RR
), rn_rd
),
17223 cCL("flte", e080110
, 2, (RF
, RR
), rn_rd
),
17224 cCL("fltep", e080130
, 2, (RF
, RR
), rn_rd
),
17225 cCL("fltem", e080150
, 2, (RF
, RR
), rn_rd
),
17226 cCL("fltez", e080170
, 2, (RF
, RR
), rn_rd
),
17228 /* The implementation of the FIX instruction is broken on some
17229 assemblers, in that it accepts a precision specifier as well as a
17230 rounding specifier, despite the fact that this is meaningless.
17231 To be more compatible, we accept it as well, though of course it
17232 does not set any bits. */
17233 cCE("fix", e100110
, 2, (RR
, RF
), rd_rm
),
17234 cCL("fixp", e100130
, 2, (RR
, RF
), rd_rm
),
17235 cCL("fixm", e100150
, 2, (RR
, RF
), rd_rm
),
17236 cCL("fixz", e100170
, 2, (RR
, RF
), rd_rm
),
17237 cCL("fixsp", e100130
, 2, (RR
, RF
), rd_rm
),
17238 cCL("fixsm", e100150
, 2, (RR
, RF
), rd_rm
),
17239 cCL("fixsz", e100170
, 2, (RR
, RF
), rd_rm
),
17240 cCL("fixdp", e100130
, 2, (RR
, RF
), rd_rm
),
17241 cCL("fixdm", e100150
, 2, (RR
, RF
), rd_rm
),
17242 cCL("fixdz", e100170
, 2, (RR
, RF
), rd_rm
),
17243 cCL("fixep", e100130
, 2, (RR
, RF
), rd_rm
),
17244 cCL("fixem", e100150
, 2, (RR
, RF
), rd_rm
),
17245 cCL("fixez", e100170
, 2, (RR
, RF
), rd_rm
),
17247 /* Instructions that were new with the real FPA, call them V2. */
17249 #define ARM_VARIANT & fpu_fpa_ext_v2
17251 cCE("lfm", c100200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17252 cCL("lfmfd", c900200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17253 cCL("lfmea", d100200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17254 cCE("sfm", c000200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17255 cCL("sfmfd", d000200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17256 cCL("sfmea", c800200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17259 #define ARM_VARIANT & fpu_vfp_ext_v1xd /* VFP V1xD (single precision). */
17261 /* Moves and type conversions. */
17262 cCE("fcpys", eb00a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17263 cCE("fmrs", e100a10
, 2, (RR
, RVS
), vfp_reg_from_sp
),
17264 cCE("fmsr", e000a10
, 2, (RVS
, RR
), vfp_sp_from_reg
),
17265 cCE("fmstat", ef1fa10
, 0, (), noargs
),
17266 cCE("vmrs", ef10a10
, 2, (APSR_RR
, RVC
), vmrs
),
17267 cCE("vmsr", ee10a10
, 2, (RVC
, RR
), vmsr
),
17268 cCE("fsitos", eb80ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17269 cCE("fuitos", eb80a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17270 cCE("ftosis", ebd0a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17271 cCE("ftosizs", ebd0ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17272 cCE("ftouis", ebc0a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17273 cCE("ftouizs", ebc0ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17274 cCE("fmrx", ef00a10
, 2, (RR
, RVC
), rd_rn
),
17275 cCE("fmxr", ee00a10
, 2, (RVC
, RR
), rn_rd
),
17277 /* Memory operations. */
17278 cCE("flds", d100a00
, 2, (RVS
, ADDRGLDC
), vfp_sp_ldst
),
17279 cCE("fsts", d000a00
, 2, (RVS
, ADDRGLDC
), vfp_sp_ldst
),
17280 cCE("fldmias", c900a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
17281 cCE("fldmfds", c900a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
17282 cCE("fldmdbs", d300a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
17283 cCE("fldmeas", d300a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
17284 cCE("fldmiax", c900b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
17285 cCE("fldmfdx", c900b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
17286 cCE("fldmdbx", d300b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
17287 cCE("fldmeax", d300b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
17288 cCE("fstmias", c800a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
17289 cCE("fstmeas", c800a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
17290 cCE("fstmdbs", d200a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
17291 cCE("fstmfds", d200a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
17292 cCE("fstmiax", c800b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
17293 cCE("fstmeax", c800b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
17294 cCE("fstmdbx", d200b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
17295 cCE("fstmfdx", d200b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
17297 /* Monadic operations. */
17298 cCE("fabss", eb00ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17299 cCE("fnegs", eb10a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17300 cCE("fsqrts", eb10ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17302 /* Dyadic operations. */
17303 cCE("fadds", e300a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17304 cCE("fsubs", e300a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17305 cCE("fmuls", e200a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17306 cCE("fdivs", e800a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17307 cCE("fmacs", e000a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17308 cCE("fmscs", e100a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17309 cCE("fnmuls", e200a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17310 cCE("fnmacs", e000a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17311 cCE("fnmscs", e100a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17314 cCE("fcmps", eb40a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17315 cCE("fcmpzs", eb50a40
, 1, (RVS
), vfp_sp_compare_z
),
17316 cCE("fcmpes", eb40ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17317 cCE("fcmpezs", eb50ac0
, 1, (RVS
), vfp_sp_compare_z
),
17319 /* Double precision load/store are still present on single precision
17320 implementations. */
17321 cCE("fldd", d100b00
, 2, (RVD
, ADDRGLDC
), vfp_dp_ldst
),
17322 cCE("fstd", d000b00
, 2, (RVD
, ADDRGLDC
), vfp_dp_ldst
),
17323 cCE("fldmiad", c900b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
17324 cCE("fldmfdd", c900b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
17325 cCE("fldmdbd", d300b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
17326 cCE("fldmead", d300b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
17327 cCE("fstmiad", c800b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
17328 cCE("fstmead", c800b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
17329 cCE("fstmdbd", d200b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
17330 cCE("fstmfdd", d200b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
17333 #define ARM_VARIANT & fpu_vfp_ext_v1 /* VFP V1 (Double precision). */
17335 /* Moves and type conversions. */
17336 cCE("fcpyd", eb00b40
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17337 cCE("fcvtds", eb70ac0
, 2, (RVD
, RVS
), vfp_dp_sp_cvt
),
17338 cCE("fcvtsd", eb70bc0
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
17339 cCE("fmdhr", e200b10
, 2, (RVD
, RR
), vfp_dp_rn_rd
),
17340 cCE("fmdlr", e000b10
, 2, (RVD
, RR
), vfp_dp_rn_rd
),
17341 cCE("fmrdh", e300b10
, 2, (RR
, RVD
), vfp_dp_rd_rn
),
17342 cCE("fmrdl", e100b10
, 2, (RR
, RVD
), vfp_dp_rd_rn
),
17343 cCE("fsitod", eb80bc0
, 2, (RVD
, RVS
), vfp_dp_sp_cvt
),
17344 cCE("fuitod", eb80b40
, 2, (RVD
, RVS
), vfp_dp_sp_cvt
),
17345 cCE("ftosid", ebd0b40
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
17346 cCE("ftosizd", ebd0bc0
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
17347 cCE("ftouid", ebc0b40
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
17348 cCE("ftouizd", ebc0bc0
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
17350 /* Monadic operations. */
17351 cCE("fabsd", eb00bc0
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17352 cCE("fnegd", eb10b40
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17353 cCE("fsqrtd", eb10bc0
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17355 /* Dyadic operations. */
17356 cCE("faddd", e300b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17357 cCE("fsubd", e300b40
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17358 cCE("fmuld", e200b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17359 cCE("fdivd", e800b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17360 cCE("fmacd", e000b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17361 cCE("fmscd", e100b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17362 cCE("fnmuld", e200b40
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17363 cCE("fnmacd", e000b40
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17364 cCE("fnmscd", e100b40
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17367 cCE("fcmpd", eb40b40
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17368 cCE("fcmpzd", eb50b40
, 1, (RVD
), vfp_dp_rd
),
17369 cCE("fcmped", eb40bc0
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17370 cCE("fcmpezd", eb50bc0
, 1, (RVD
), vfp_dp_rd
),
17373 #define ARM_VARIANT & fpu_vfp_ext_v2
17375 cCE("fmsrr", c400a10
, 3, (VRSLST
, RR
, RR
), vfp_sp2_from_reg2
),
17376 cCE("fmrrs", c500a10
, 3, (RR
, RR
, VRSLST
), vfp_reg2_from_sp2
),
17377 cCE("fmdrr", c400b10
, 3, (RVD
, RR
, RR
), vfp_dp_rm_rd_rn
),
17378 cCE("fmrrd", c500b10
, 3, (RR
, RR
, RVD
), vfp_dp_rd_rn_rm
),
17380 /* Instructions which may belong to either the Neon or VFP instruction sets.
17381 Individual encoder functions perform additional architecture checks. */
17383 #define ARM_VARIANT & fpu_vfp_ext_v1xd
17384 #undef THUMB_VARIANT
17385 #define THUMB_VARIANT & fpu_vfp_ext_v1xd
17387 /* These mnemonics are unique to VFP. */
17388 NCE(vsqrt
, 0, 2, (RVSD
, RVSD
), vfp_nsyn_sqrt
),
17389 NCE(vdiv
, 0, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_div
),
17390 nCE(vnmul
, _vnmul
, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_nmul
),
17391 nCE(vnmla
, _vnmla
, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_nmul
),
17392 nCE(vnmls
, _vnmls
, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_nmul
),
17393 nCE(vcmp
, _vcmp
, 2, (RVSD
, RVSD_I0
), vfp_nsyn_cmp
),
17394 nCE(vcmpe
, _vcmpe
, 2, (RVSD
, RVSD_I0
), vfp_nsyn_cmp
),
17395 NCE(vpush
, 0, 1, (VRSDLST
), vfp_nsyn_push
),
17396 NCE(vpop
, 0, 1, (VRSDLST
), vfp_nsyn_pop
),
17397 NCE(vcvtz
, 0, 2, (RVSD
, RVSD
), vfp_nsyn_cvtz
),
17399 /* Mnemonics shared by Neon and VFP. */
17400 nCEF(vmul
, _vmul
, 3, (RNSDQ
, oRNSDQ
, RNSDQ_RNSC
), neon_mul
),
17401 nCEF(vmla
, _vmla
, 3, (RNSDQ
, oRNSDQ
, RNSDQ_RNSC
), neon_mac_maybe_scalar
),
17402 nCEF(vmls
, _vmls
, 3, (RNSDQ
, oRNSDQ
, RNSDQ_RNSC
), neon_mac_maybe_scalar
),
17404 nCEF(vadd
, _vadd
, 3, (RNSDQ
, oRNSDQ
, RNSDQ
), neon_addsub_if_i
),
17405 nCEF(vsub
, _vsub
, 3, (RNSDQ
, oRNSDQ
, RNSDQ
), neon_addsub_if_i
),
17407 NCEF(vabs
, 1b10300
, 2, (RNSDQ
, RNSDQ
), neon_abs_neg
),
17408 NCEF(vneg
, 1b10380
, 2, (RNSDQ
, RNSDQ
), neon_abs_neg
),
17410 NCE(vldm
, c900b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17411 NCE(vldmia
, c900b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17412 NCE(vldmdb
, d100b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17413 NCE(vstm
, c800b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17414 NCE(vstmia
, c800b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17415 NCE(vstmdb
, d000b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17416 NCE(vldr
, d100b00
, 2, (RVSD
, ADDRGLDC
), neon_ldr_str
),
17417 NCE(vstr
, d000b00
, 2, (RVSD
, ADDRGLDC
), neon_ldr_str
),
17419 nCEF(vcvt
, _vcvt
, 3, (RNSDQ
, RNSDQ
, oI32b
), neon_cvt
),
17420 nCEF(vcvtb
, _vcvt
, 2, (RVS
, RVS
), neon_cvtb
),
17421 nCEF(vcvtt
, _vcvt
, 2, (RVS
, RVS
), neon_cvtt
),
17424 /* NOTE: All VMOV encoding is special-cased! */
17425 NCE(vmov
, 0, 1, (VMOV
), neon_mov
),
17426 NCE(vmovq
, 0, 1, (VMOV
), neon_mov
),
17428 #undef THUMB_VARIANT
17429 #define THUMB_VARIANT & fpu_neon_ext_v1
17431 #define ARM_VARIANT & fpu_neon_ext_v1
17433 /* Data processing with three registers of the same length. */
17434 /* integer ops, valid types S8 S16 S32 U8 U16 U32. */
17435 NUF(vaba
, 0000710, 3, (RNDQ
, RNDQ
, RNDQ
), neon_dyadic_i_su
),
17436 NUF(vabaq
, 0000710, 3, (RNQ
, RNQ
, RNQ
), neon_dyadic_i_su
),
17437 NUF(vhadd
, 0000000, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_i_su
),
17438 NUF(vhaddq
, 0000000, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_i_su
),
17439 NUF(vrhadd
, 0000100, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_i_su
),
17440 NUF(vrhaddq
, 0000100, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_i_su
),
17441 NUF(vhsub
, 0000200, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_i_su
),
17442 NUF(vhsubq
, 0000200, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_i_su
),
17443 /* integer ops, valid types S8 S16 S32 S64 U8 U16 U32 U64. */
17444 NUF(vqadd
, 0000010, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_i64_su
),
17445 NUF(vqaddq
, 0000010, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_i64_su
),
17446 NUF(vqsub
, 0000210, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_i64_su
),
17447 NUF(vqsubq
, 0000210, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_i64_su
),
17448 NUF(vrshl
, 0000500, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_rshl
),
17449 NUF(vrshlq
, 0000500, 3, (RNQ
, oRNQ
, RNQ
), neon_rshl
),
17450 NUF(vqrshl
, 0000510, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_rshl
),
17451 NUF(vqrshlq
, 0000510, 3, (RNQ
, oRNQ
, RNQ
), neon_rshl
),
17452 /* If not immediate, fall back to neon_dyadic_i64_su.
17453 shl_imm should accept I8 I16 I32 I64,
17454 qshl_imm should accept S8 S16 S32 S64 U8 U16 U32 U64. */
17455 nUF(vshl
, _vshl
, 3, (RNDQ
, oRNDQ
, RNDQ_I63b
), neon_shl_imm
),
17456 nUF(vshlq
, _vshl
, 3, (RNQ
, oRNQ
, RNDQ_I63b
), neon_shl_imm
),
17457 nUF(vqshl
, _vqshl
, 3, (RNDQ
, oRNDQ
, RNDQ_I63b
), neon_qshl_imm
),
17458 nUF(vqshlq
, _vqshl
, 3, (RNQ
, oRNQ
, RNDQ_I63b
), neon_qshl_imm
),
17459 /* Logic ops, types optional & ignored. */
17460 nUF(vand
, _vand
, 3, (RNDQ
, oRNDQ
, RNDQ_Ibig
), neon_logic
),
17461 nUF(vandq
, _vand
, 3, (RNQ
, oRNQ
, RNDQ_Ibig
), neon_logic
),
17462 nUF(vbic
, _vbic
, 3, (RNDQ
, oRNDQ
, RNDQ_Ibig
), neon_logic
),
17463 nUF(vbicq
, _vbic
, 3, (RNQ
, oRNQ
, RNDQ_Ibig
), neon_logic
),
17464 nUF(vorr
, _vorr
, 3, (RNDQ
, oRNDQ
, RNDQ_Ibig
), neon_logic
),
17465 nUF(vorrq
, _vorr
, 3, (RNQ
, oRNQ
, RNDQ_Ibig
), neon_logic
),
17466 nUF(vorn
, _vorn
, 3, (RNDQ
, oRNDQ
, RNDQ_Ibig
), neon_logic
),
17467 nUF(vornq
, _vorn
, 3, (RNQ
, oRNQ
, RNDQ_Ibig
), neon_logic
),
17468 nUF(veor
, _veor
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_logic
),
17469 nUF(veorq
, _veor
, 3, (RNQ
, oRNQ
, RNQ
), neon_logic
),
17470 /* Bitfield ops, untyped. */
17471 NUF(vbsl
, 1100110, 3, (RNDQ
, RNDQ
, RNDQ
), neon_bitfield
),
17472 NUF(vbslq
, 1100110, 3, (RNQ
, RNQ
, RNQ
), neon_bitfield
),
17473 NUF(vbit
, 1200110, 3, (RNDQ
, RNDQ
, RNDQ
), neon_bitfield
),
17474 NUF(vbitq
, 1200110, 3, (RNQ
, RNQ
, RNQ
), neon_bitfield
),
17475 NUF(vbif
, 1300110, 3, (RNDQ
, RNDQ
, RNDQ
), neon_bitfield
),
17476 NUF(vbifq
, 1300110, 3, (RNQ
, RNQ
, RNQ
), neon_bitfield
),
17477 /* Int and float variants, types S8 S16 S32 U8 U16 U32 F32. */
17478 nUF(vabd
, _vabd
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_if_su
),
17479 nUF(vabdq
, _vabd
, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_if_su
),
17480 nUF(vmax
, _vmax
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_if_su
),
17481 nUF(vmaxq
, _vmax
, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_if_su
),
17482 nUF(vmin
, _vmin
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_if_su
),
17483 nUF(vminq
, _vmin
, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_if_su
),
17484 /* Comparisons. Types S8 S16 S32 U8 U16 U32 F32. Non-immediate versions fall
17485 back to neon_dyadic_if_su. */
17486 nUF(vcge
, _vcge
, 3, (RNDQ
, oRNDQ
, RNDQ_I0
), neon_cmp
),
17487 nUF(vcgeq
, _vcge
, 3, (RNQ
, oRNQ
, RNDQ_I0
), neon_cmp
),
17488 nUF(vcgt
, _vcgt
, 3, (RNDQ
, oRNDQ
, RNDQ_I0
), neon_cmp
),
17489 nUF(vcgtq
, _vcgt
, 3, (RNQ
, oRNQ
, RNDQ_I0
), neon_cmp
),
17490 nUF(vclt
, _vclt
, 3, (RNDQ
, oRNDQ
, RNDQ_I0
), neon_cmp_inv
),
17491 nUF(vcltq
, _vclt
, 3, (RNQ
, oRNQ
, RNDQ_I0
), neon_cmp_inv
),
17492 nUF(vcle
, _vcle
, 3, (RNDQ
, oRNDQ
, RNDQ_I0
), neon_cmp_inv
),
17493 nUF(vcleq
, _vcle
, 3, (RNQ
, oRNQ
, RNDQ_I0
), neon_cmp_inv
),
17494 /* Comparison. Type I8 I16 I32 F32. */
17495 nUF(vceq
, _vceq
, 3, (RNDQ
, oRNDQ
, RNDQ_I0
), neon_ceq
),
17496 nUF(vceqq
, _vceq
, 3, (RNQ
, oRNQ
, RNDQ_I0
), neon_ceq
),
17497 /* As above, D registers only. */
17498 nUF(vpmax
, _vpmax
, 3, (RND
, oRND
, RND
), neon_dyadic_if_su_d
),
17499 nUF(vpmin
, _vpmin
, 3, (RND
, oRND
, RND
), neon_dyadic_if_su_d
),
17500 /* Int and float variants, signedness unimportant. */
17501 nUF(vmlaq
, _vmla
, 3, (RNQ
, oRNQ
, RNDQ_RNSC
), neon_mac_maybe_scalar
),
17502 nUF(vmlsq
, _vmls
, 3, (RNQ
, oRNQ
, RNDQ_RNSC
), neon_mac_maybe_scalar
),
17503 nUF(vpadd
, _vpadd
, 3, (RND
, oRND
, RND
), neon_dyadic_if_i_d
),
17504 /* Add/sub take types I8 I16 I32 I64 F32. */
17505 nUF(vaddq
, _vadd
, 3, (RNQ
, oRNQ
, RNQ
), neon_addsub_if_i
),
17506 nUF(vsubq
, _vsub
, 3, (RNQ
, oRNQ
, RNQ
), neon_addsub_if_i
),
17507 /* vtst takes sizes 8, 16, 32. */
17508 NUF(vtst
, 0000810, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_tst
),
17509 NUF(vtstq
, 0000810, 3, (RNQ
, oRNQ
, RNQ
), neon_tst
),
17510 /* VMUL takes I8 I16 I32 F32 P8. */
17511 nUF(vmulq
, _vmul
, 3, (RNQ
, oRNQ
, RNDQ_RNSC
), neon_mul
),
17512 /* VQD{R}MULH takes S16 S32. */
17513 nUF(vqdmulh
, _vqdmulh
, 3, (RNDQ
, oRNDQ
, RNDQ_RNSC
), neon_qdmulh
),
17514 nUF(vqdmulhq
, _vqdmulh
, 3, (RNQ
, oRNQ
, RNDQ_RNSC
), neon_qdmulh
),
17515 nUF(vqrdmulh
, _vqrdmulh
, 3, (RNDQ
, oRNDQ
, RNDQ_RNSC
), neon_qdmulh
),
17516 nUF(vqrdmulhq
, _vqrdmulh
, 3, (RNQ
, oRNQ
, RNDQ_RNSC
), neon_qdmulh
),
17517 NUF(vacge
, 0000e10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_fcmp_absolute
),
17518 NUF(vacgeq
, 0000e10
, 3, (RNQ
, oRNQ
, RNQ
), neon_fcmp_absolute
),
17519 NUF(vacgt
, 0200e10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_fcmp_absolute
),
17520 NUF(vacgtq
, 0200e10
, 3, (RNQ
, oRNQ
, RNQ
), neon_fcmp_absolute
),
17521 NUF(vaclt
, 0200e10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_fcmp_absolute_inv
),
17522 NUF(vacltq
, 0200e10
, 3, (RNQ
, oRNQ
, RNQ
), neon_fcmp_absolute_inv
),
17523 NUF(vacle
, 0000e10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_fcmp_absolute_inv
),
17524 NUF(vacleq
, 0000e10
, 3, (RNQ
, oRNQ
, RNQ
), neon_fcmp_absolute_inv
),
17525 NUF(vrecps
, 0000f10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_step
),
17526 NUF(vrecpsq
, 0000f10
, 3, (RNQ
, oRNQ
, RNQ
), neon_step
),
17527 NUF(vrsqrts
, 0200f10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_step
),
17528 NUF(vrsqrtsq
, 0200f10
, 3, (RNQ
, oRNQ
, RNQ
), neon_step
),
17530 /* Two address, int/float. Types S8 S16 S32 F32. */
17531 NUF(vabsq
, 1b10300
, 2, (RNQ
, RNQ
), neon_abs_neg
),
17532 NUF(vnegq
, 1b10380
, 2, (RNQ
, RNQ
), neon_abs_neg
),
17534 /* Data processing with two registers and a shift amount. */
17535 /* Right shifts, and variants with rounding.
17536 Types accepted S8 S16 S32 S64 U8 U16 U32 U64. */
17537 NUF(vshr
, 0800010, 3, (RNDQ
, oRNDQ
, I64z
), neon_rshift_round_imm
),
17538 NUF(vshrq
, 0800010, 3, (RNQ
, oRNQ
, I64z
), neon_rshift_round_imm
),
17539 NUF(vrshr
, 0800210, 3, (RNDQ
, oRNDQ
, I64z
), neon_rshift_round_imm
),
17540 NUF(vrshrq
, 0800210, 3, (RNQ
, oRNQ
, I64z
), neon_rshift_round_imm
),
17541 NUF(vsra
, 0800110, 3, (RNDQ
, oRNDQ
, I64
), neon_rshift_round_imm
),
17542 NUF(vsraq
, 0800110, 3, (RNQ
, oRNQ
, I64
), neon_rshift_round_imm
),
17543 NUF(vrsra
, 0800310, 3, (RNDQ
, oRNDQ
, I64
), neon_rshift_round_imm
),
17544 NUF(vrsraq
, 0800310, 3, (RNQ
, oRNQ
, I64
), neon_rshift_round_imm
),
17545 /* Shift and insert. Sizes accepted 8 16 32 64. */
17546 NUF(vsli
, 1800510, 3, (RNDQ
, oRNDQ
, I63
), neon_sli
),
17547 NUF(vsliq
, 1800510, 3, (RNQ
, oRNQ
, I63
), neon_sli
),
17548 NUF(vsri
, 1800410, 3, (RNDQ
, oRNDQ
, I64
), neon_sri
),
17549 NUF(vsriq
, 1800410, 3, (RNQ
, oRNQ
, I64
), neon_sri
),
17550 /* QSHL{U} immediate accepts S8 S16 S32 S64 U8 U16 U32 U64. */
17551 NUF(vqshlu
, 1800610, 3, (RNDQ
, oRNDQ
, I63
), neon_qshlu_imm
),
17552 NUF(vqshluq
, 1800610, 3, (RNQ
, oRNQ
, I63
), neon_qshlu_imm
),
17553 /* Right shift immediate, saturating & narrowing, with rounding variants.
17554 Types accepted S16 S32 S64 U16 U32 U64. */
17555 NUF(vqshrn
, 0800910, 3, (RND
, RNQ
, I32z
), neon_rshift_sat_narrow
),
17556 NUF(vqrshrn
, 0800950, 3, (RND
, RNQ
, I32z
), neon_rshift_sat_narrow
),
17557 /* As above, unsigned. Types accepted S16 S32 S64. */
17558 NUF(vqshrun
, 0800810, 3, (RND
, RNQ
, I32z
), neon_rshift_sat_narrow_u
),
17559 NUF(vqrshrun
, 0800850, 3, (RND
, RNQ
, I32z
), neon_rshift_sat_narrow_u
),
17560 /* Right shift narrowing. Types accepted I16 I32 I64. */
17561 NUF(vshrn
, 0800810, 3, (RND
, RNQ
, I32z
), neon_rshift_narrow
),
17562 NUF(vrshrn
, 0800850, 3, (RND
, RNQ
, I32z
), neon_rshift_narrow
),
17563 /* Special case. Types S8 S16 S32 U8 U16 U32. Handles max shift variant. */
17564 nUF(vshll
, _vshll
, 3, (RNQ
, RND
, I32
), neon_shll
),
17565 /* CVT with optional immediate for fixed-point variant. */
17566 nUF(vcvtq
, _vcvt
, 3, (RNQ
, RNQ
, oI32b
), neon_cvt
),
17568 nUF(vmvn
, _vmvn
, 2, (RNDQ
, RNDQ_Ibig
), neon_mvn
),
17569 nUF(vmvnq
, _vmvn
, 2, (RNQ
, RNDQ_Ibig
), neon_mvn
),
17571 /* Data processing, three registers of different lengths. */
17572 /* Dyadic, long insns. Types S8 S16 S32 U8 U16 U32. */
17573 NUF(vabal
, 0800500, 3, (RNQ
, RND
, RND
), neon_abal
),
17574 NUF(vabdl
, 0800700, 3, (RNQ
, RND
, RND
), neon_dyadic_long
),
17575 NUF(vaddl
, 0800000, 3, (RNQ
, RND
, RND
), neon_dyadic_long
),
17576 NUF(vsubl
, 0800200, 3, (RNQ
, RND
, RND
), neon_dyadic_long
),
17577 /* If not scalar, fall back to neon_dyadic_long.
17578 Vector types as above, scalar types S16 S32 U16 U32. */
17579 nUF(vmlal
, _vmlal
, 3, (RNQ
, RND
, RND_RNSC
), neon_mac_maybe_scalar_long
),
17580 nUF(vmlsl
, _vmlsl
, 3, (RNQ
, RND
, RND_RNSC
), neon_mac_maybe_scalar_long
),
17581 /* Dyadic, widening insns. Types S8 S16 S32 U8 U16 U32. */
17582 NUF(vaddw
, 0800100, 3, (RNQ
, oRNQ
, RND
), neon_dyadic_wide
),
17583 NUF(vsubw
, 0800300, 3, (RNQ
, oRNQ
, RND
), neon_dyadic_wide
),
17584 /* Dyadic, narrowing insns. Types I16 I32 I64. */
17585 NUF(vaddhn
, 0800400, 3, (RND
, RNQ
, RNQ
), neon_dyadic_narrow
),
17586 NUF(vraddhn
, 1800400, 3, (RND
, RNQ
, RNQ
), neon_dyadic_narrow
),
17587 NUF(vsubhn
, 0800600, 3, (RND
, RNQ
, RNQ
), neon_dyadic_narrow
),
17588 NUF(vrsubhn
, 1800600, 3, (RND
, RNQ
, RNQ
), neon_dyadic_narrow
),
17589 /* Saturating doubling multiplies. Types S16 S32. */
17590 nUF(vqdmlal
, _vqdmlal
, 3, (RNQ
, RND
, RND_RNSC
), neon_mul_sat_scalar_long
),
17591 nUF(vqdmlsl
, _vqdmlsl
, 3, (RNQ
, RND
, RND_RNSC
), neon_mul_sat_scalar_long
),
17592 nUF(vqdmull
, _vqdmull
, 3, (RNQ
, RND
, RND_RNSC
), neon_mul_sat_scalar_long
),
17593 /* VMULL. Vector types S8 S16 S32 U8 U16 U32 P8, scalar types
17594 S16 S32 U16 U32. */
17595 nUF(vmull
, _vmull
, 3, (RNQ
, RND
, RND_RNSC
), neon_vmull
),
17597 /* Extract. Size 8. */
17598 NUF(vext
, 0b00000, 4, (RNDQ
, oRNDQ
, RNDQ
, I15
), neon_ext
),
17599 NUF(vextq
, 0b00000, 4, (RNQ
, oRNQ
, RNQ
, I15
), neon_ext
),
17601 /* Two registers, miscellaneous. */
17602 /* Reverse. Sizes 8 16 32 (must be < size in opcode). */
17603 NUF(vrev64
, 1b00000
, 2, (RNDQ
, RNDQ
), neon_rev
),
17604 NUF(vrev64q
, 1b00000
, 2, (RNQ
, RNQ
), neon_rev
),
17605 NUF(vrev32
, 1b00080
, 2, (RNDQ
, RNDQ
), neon_rev
),
17606 NUF(vrev32q
, 1b00080
, 2, (RNQ
, RNQ
), neon_rev
),
17607 NUF(vrev16
, 1b00100
, 2, (RNDQ
, RNDQ
), neon_rev
),
17608 NUF(vrev16q
, 1b00100
, 2, (RNQ
, RNQ
), neon_rev
),
17609 /* Vector replicate. Sizes 8 16 32. */
17610 nCE(vdup
, _vdup
, 2, (RNDQ
, RR_RNSC
), neon_dup
),
17611 nCE(vdupq
, _vdup
, 2, (RNQ
, RR_RNSC
), neon_dup
),
17612 /* VMOVL. Types S8 S16 S32 U8 U16 U32. */
17613 NUF(vmovl
, 0800a10
, 2, (RNQ
, RND
), neon_movl
),
17614 /* VMOVN. Types I16 I32 I64. */
17615 nUF(vmovn
, _vmovn
, 2, (RND
, RNQ
), neon_movn
),
17616 /* VQMOVN. Types S16 S32 S64 U16 U32 U64. */
17617 nUF(vqmovn
, _vqmovn
, 2, (RND
, RNQ
), neon_qmovn
),
17618 /* VQMOVUN. Types S16 S32 S64. */
17619 nUF(vqmovun
, _vqmovun
, 2, (RND
, RNQ
), neon_qmovun
),
17620 /* VZIP / VUZP. Sizes 8 16 32. */
17621 NUF(vzip
, 1b20180
, 2, (RNDQ
, RNDQ
), neon_zip_uzp
),
17622 NUF(vzipq
, 1b20180
, 2, (RNQ
, RNQ
), neon_zip_uzp
),
17623 NUF(vuzp
, 1b20100
, 2, (RNDQ
, RNDQ
), neon_zip_uzp
),
17624 NUF(vuzpq
, 1b20100
, 2, (RNQ
, RNQ
), neon_zip_uzp
),
17625 /* VQABS / VQNEG. Types S8 S16 S32. */
17626 NUF(vqabs
, 1b00700
, 2, (RNDQ
, RNDQ
), neon_sat_abs_neg
),
17627 NUF(vqabsq
, 1b00700
, 2, (RNQ
, RNQ
), neon_sat_abs_neg
),
17628 NUF(vqneg
, 1b00780
, 2, (RNDQ
, RNDQ
), neon_sat_abs_neg
),
17629 NUF(vqnegq
, 1b00780
, 2, (RNQ
, RNQ
), neon_sat_abs_neg
),
17630 /* Pairwise, lengthening. Types S8 S16 S32 U8 U16 U32. */
17631 NUF(vpadal
, 1b00600
, 2, (RNDQ
, RNDQ
), neon_pair_long
),
17632 NUF(vpadalq
, 1b00600
, 2, (RNQ
, RNQ
), neon_pair_long
),
17633 NUF(vpaddl
, 1b00200
, 2, (RNDQ
, RNDQ
), neon_pair_long
),
17634 NUF(vpaddlq
, 1b00200
, 2, (RNQ
, RNQ
), neon_pair_long
),
17635 /* Reciprocal estimates. Types U32 F32. */
17636 NUF(vrecpe
, 1b30400
, 2, (RNDQ
, RNDQ
), neon_recip_est
),
17637 NUF(vrecpeq
, 1b30400
, 2, (RNQ
, RNQ
), neon_recip_est
),
17638 NUF(vrsqrte
, 1b30480
, 2, (RNDQ
, RNDQ
), neon_recip_est
),
17639 NUF(vrsqrteq
, 1b30480
, 2, (RNQ
, RNQ
), neon_recip_est
),
17640 /* VCLS. Types S8 S16 S32. */
17641 NUF(vcls
, 1b00400
, 2, (RNDQ
, RNDQ
), neon_cls
),
17642 NUF(vclsq
, 1b00400
, 2, (RNQ
, RNQ
), neon_cls
),
17643 /* VCLZ. Types I8 I16 I32. */
17644 NUF(vclz
, 1b00480
, 2, (RNDQ
, RNDQ
), neon_clz
),
17645 NUF(vclzq
, 1b00480
, 2, (RNQ
, RNQ
), neon_clz
),
17646 /* VCNT. Size 8. */
17647 NUF(vcnt
, 1b00500
, 2, (RNDQ
, RNDQ
), neon_cnt
),
17648 NUF(vcntq
, 1b00500
, 2, (RNQ
, RNQ
), neon_cnt
),
17649 /* Two address, untyped. */
17650 NUF(vswp
, 1b20000
, 2, (RNDQ
, RNDQ
), neon_swp
),
17651 NUF(vswpq
, 1b20000
, 2, (RNQ
, RNQ
), neon_swp
),
17652 /* VTRN. Sizes 8 16 32. */
17653 nUF(vtrn
, _vtrn
, 2, (RNDQ
, RNDQ
), neon_trn
),
17654 nUF(vtrnq
, _vtrn
, 2, (RNQ
, RNQ
), neon_trn
),
17656 /* Table lookup. Size 8. */
17657 NUF(vtbl
, 1b00800
, 3, (RND
, NRDLST
, RND
), neon_tbl_tbx
),
17658 NUF(vtbx
, 1b00840
, 3, (RND
, NRDLST
, RND
), neon_tbl_tbx
),
17660 #undef THUMB_VARIANT
17661 #define THUMB_VARIANT & fpu_vfp_v3_or_neon_ext
17663 #define ARM_VARIANT & fpu_vfp_v3_or_neon_ext
17665 /* Neon element/structure load/store. */
17666 nUF(vld1
, _vld1
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17667 nUF(vst1
, _vst1
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17668 nUF(vld2
, _vld2
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17669 nUF(vst2
, _vst2
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17670 nUF(vld3
, _vld3
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17671 nUF(vst3
, _vst3
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17672 nUF(vld4
, _vld4
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17673 nUF(vst4
, _vst4
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17675 #undef THUMB_VARIANT
17676 #define THUMB_VARIANT &fpu_vfp_ext_v3xd
17678 #define ARM_VARIANT &fpu_vfp_ext_v3xd
17679 cCE("fconsts", eb00a00
, 2, (RVS
, I255
), vfp_sp_const
),
17680 cCE("fshtos", eba0a40
, 2, (RVS
, I16z
), vfp_sp_conv_16
),
17681 cCE("fsltos", eba0ac0
, 2, (RVS
, I32
), vfp_sp_conv_32
),
17682 cCE("fuhtos", ebb0a40
, 2, (RVS
, I16z
), vfp_sp_conv_16
),
17683 cCE("fultos", ebb0ac0
, 2, (RVS
, I32
), vfp_sp_conv_32
),
17684 cCE("ftoshs", ebe0a40
, 2, (RVS
, I16z
), vfp_sp_conv_16
),
17685 cCE("ftosls", ebe0ac0
, 2, (RVS
, I32
), vfp_sp_conv_32
),
17686 cCE("ftouhs", ebf0a40
, 2, (RVS
, I16z
), vfp_sp_conv_16
),
17687 cCE("ftouls", ebf0ac0
, 2, (RVS
, I32
), vfp_sp_conv_32
),
17689 #undef THUMB_VARIANT
17690 #define THUMB_VARIANT & fpu_vfp_ext_v3
17692 #define ARM_VARIANT & fpu_vfp_ext_v3
17694 cCE("fconstd", eb00b00
, 2, (RVD
, I255
), vfp_dp_const
),
17695 cCE("fshtod", eba0b40
, 2, (RVD
, I16z
), vfp_dp_conv_16
),
17696 cCE("fsltod", eba0bc0
, 2, (RVD
, I32
), vfp_dp_conv_32
),
17697 cCE("fuhtod", ebb0b40
, 2, (RVD
, I16z
), vfp_dp_conv_16
),
17698 cCE("fultod", ebb0bc0
, 2, (RVD
, I32
), vfp_dp_conv_32
),
17699 cCE("ftoshd", ebe0b40
, 2, (RVD
, I16z
), vfp_dp_conv_16
),
17700 cCE("ftosld", ebe0bc0
, 2, (RVD
, I32
), vfp_dp_conv_32
),
17701 cCE("ftouhd", ebf0b40
, 2, (RVD
, I16z
), vfp_dp_conv_16
),
17702 cCE("ftould", ebf0bc0
, 2, (RVD
, I32
), vfp_dp_conv_32
),
17705 #define ARM_VARIANT &fpu_vfp_ext_fma
17706 #undef THUMB_VARIANT
17707 #define THUMB_VARIANT &fpu_vfp_ext_fma
17708 /* Mnemonics shared by Neon and VFP. These are included in the
17709 VFP FMA variant; NEON and VFP FMA always includes the NEON
17710 FMA instructions. */
17711 nCEF(vfma
, _vfma
, 3, (RNSDQ
, oRNSDQ
, RNSDQ
), neon_fmac
),
17712 nCEF(vfms
, _vfms
, 3, (RNSDQ
, oRNSDQ
, RNSDQ
), neon_fmac
),
17713 /* ffmas/ffmad/ffmss/ffmsd are dummy mnemonics to satisfy gas;
17714 the v form should always be used. */
17715 cCE("ffmas", ea00a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17716 cCE("ffnmas", ea00a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17717 cCE("ffmad", ea00b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17718 cCE("ffnmad", ea00b40
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17719 nCE(vfnma
, _vfnma
, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_nmul
),
17720 nCE(vfnms
, _vfnms
, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_nmul
),
17722 #undef THUMB_VARIANT
17724 #define ARM_VARIANT & arm_cext_xscale /* Intel XScale extensions. */
17726 cCE("mia", e200010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17727 cCE("miaph", e280010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17728 cCE("miabb", e2c0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17729 cCE("miabt", e2d0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17730 cCE("miatb", e2e0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17731 cCE("miatt", e2f0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17732 cCE("mar", c400000
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mar
),
17733 cCE("mra", c500000
, 3, (RRnpc
, RRnpc
, RXA
), xsc_mra
),
17736 #define ARM_VARIANT & arm_cext_iwmmxt /* Intel Wireless MMX technology. */
17738 cCE("tandcb", e13f130
, 1, (RR
), iwmmxt_tandorc
),
17739 cCE("tandch", e53f130
, 1, (RR
), iwmmxt_tandorc
),
17740 cCE("tandcw", e93f130
, 1, (RR
), iwmmxt_tandorc
),
17741 cCE("tbcstb", e400010
, 2, (RIWR
, RR
), rn_rd
),
17742 cCE("tbcsth", e400050
, 2, (RIWR
, RR
), rn_rd
),
17743 cCE("tbcstw", e400090
, 2, (RIWR
, RR
), rn_rd
),
17744 cCE("textrcb", e130170
, 2, (RR
, I7
), iwmmxt_textrc
),
17745 cCE("textrch", e530170
, 2, (RR
, I7
), iwmmxt_textrc
),
17746 cCE("textrcw", e930170
, 2, (RR
, I7
), iwmmxt_textrc
),
17747 cCE("textrmub", e100070
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17748 cCE("textrmuh", e500070
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17749 cCE("textrmuw", e900070
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17750 cCE("textrmsb", e100078
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17751 cCE("textrmsh", e500078
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17752 cCE("textrmsw", e900078
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17753 cCE("tinsrb", e600010
, 3, (RIWR
, RR
, I7
), iwmmxt_tinsr
),
17754 cCE("tinsrh", e600050
, 3, (RIWR
, RR
, I7
), iwmmxt_tinsr
),
17755 cCE("tinsrw", e600090
, 3, (RIWR
, RR
, I7
), iwmmxt_tinsr
),
17756 cCE("tmcr", e000110
, 2, (RIWC_RIWG
, RR
), rn_rd
),
17757 cCE("tmcrr", c400000
, 3, (RIWR
, RR
, RR
), rm_rd_rn
),
17758 cCE("tmia", e200010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17759 cCE("tmiaph", e280010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17760 cCE("tmiabb", e2c0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17761 cCE("tmiabt", e2d0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17762 cCE("tmiatb", e2e0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17763 cCE("tmiatt", e2f0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17764 cCE("tmovmskb", e100030
, 2, (RR
, RIWR
), rd_rn
),
17765 cCE("tmovmskh", e500030
, 2, (RR
, RIWR
), rd_rn
),
17766 cCE("tmovmskw", e900030
, 2, (RR
, RIWR
), rd_rn
),
17767 cCE("tmrc", e100110
, 2, (RR
, RIWC_RIWG
), rd_rn
),
17768 cCE("tmrrc", c500000
, 3, (RR
, RR
, RIWR
), rd_rn_rm
),
17769 cCE("torcb", e13f150
, 1, (RR
), iwmmxt_tandorc
),
17770 cCE("torch", e53f150
, 1, (RR
), iwmmxt_tandorc
),
17771 cCE("torcw", e93f150
, 1, (RR
), iwmmxt_tandorc
),
17772 cCE("waccb", e0001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17773 cCE("wacch", e4001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17774 cCE("waccw", e8001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17775 cCE("waddbss", e300180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17776 cCE("waddb", e000180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17777 cCE("waddbus", e100180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17778 cCE("waddhss", e700180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17779 cCE("waddh", e400180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17780 cCE("waddhus", e500180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17781 cCE("waddwss", eb00180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17782 cCE("waddw", e800180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17783 cCE("waddwus", e900180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17784 cCE("waligni", e000020
, 4, (RIWR
, RIWR
, RIWR
, I7
), iwmmxt_waligni
),
17785 cCE("walignr0", e800020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17786 cCE("walignr1", e900020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17787 cCE("walignr2", ea00020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17788 cCE("walignr3", eb00020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17789 cCE("wand", e200000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17790 cCE("wandn", e300000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17791 cCE("wavg2b", e800000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17792 cCE("wavg2br", e900000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17793 cCE("wavg2h", ec00000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17794 cCE("wavg2hr", ed00000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17795 cCE("wcmpeqb", e000060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17796 cCE("wcmpeqh", e400060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17797 cCE("wcmpeqw", e800060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17798 cCE("wcmpgtub", e100060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17799 cCE("wcmpgtuh", e500060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17800 cCE("wcmpgtuw", e900060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17801 cCE("wcmpgtsb", e300060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17802 cCE("wcmpgtsh", e700060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17803 cCE("wcmpgtsw", eb00060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17804 cCE("wldrb", c100000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
17805 cCE("wldrh", c500000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
17806 cCE("wldrw", c100100
, 2, (RIWR_RIWC
, ADDR
), iwmmxt_wldstw
),
17807 cCE("wldrd", c500100
, 2, (RIWR
, ADDR
), iwmmxt_wldstd
),
17808 cCE("wmacs", e600100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17809 cCE("wmacsz", e700100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17810 cCE("wmacu", e400100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17811 cCE("wmacuz", e500100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17812 cCE("wmadds", ea00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17813 cCE("wmaddu", e800100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17814 cCE("wmaxsb", e200160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17815 cCE("wmaxsh", e600160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17816 cCE("wmaxsw", ea00160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17817 cCE("wmaxub", e000160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17818 cCE("wmaxuh", e400160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17819 cCE("wmaxuw", e800160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17820 cCE("wminsb", e300160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17821 cCE("wminsh", e700160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17822 cCE("wminsw", eb00160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17823 cCE("wminub", e100160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17824 cCE("wminuh", e500160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17825 cCE("wminuw", e900160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17826 cCE("wmov", e000000
, 2, (RIWR
, RIWR
), iwmmxt_wmov
),
17827 cCE("wmulsm", e300100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17828 cCE("wmulsl", e200100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17829 cCE("wmulum", e100100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17830 cCE("wmulul", e000100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17831 cCE("wor", e000000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17832 cCE("wpackhss", e700080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17833 cCE("wpackhus", e500080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17834 cCE("wpackwss", eb00080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17835 cCE("wpackwus", e900080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17836 cCE("wpackdss", ef00080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17837 cCE("wpackdus", ed00080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17838 cCE("wrorh", e700040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17839 cCE("wrorhg", e700148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17840 cCE("wrorw", eb00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17841 cCE("wrorwg", eb00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17842 cCE("wrord", ef00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17843 cCE("wrordg", ef00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17844 cCE("wsadb", e000120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17845 cCE("wsadbz", e100120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17846 cCE("wsadh", e400120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17847 cCE("wsadhz", e500120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17848 cCE("wshufh", e0001e0
, 3, (RIWR
, RIWR
, I255
), iwmmxt_wshufh
),
17849 cCE("wsllh", e500040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17850 cCE("wsllhg", e500148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17851 cCE("wsllw", e900040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17852 cCE("wsllwg", e900148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17853 cCE("wslld", ed00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17854 cCE("wslldg", ed00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17855 cCE("wsrah", e400040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17856 cCE("wsrahg", e400148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17857 cCE("wsraw", e800040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17858 cCE("wsrawg", e800148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17859 cCE("wsrad", ec00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17860 cCE("wsradg", ec00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17861 cCE("wsrlh", e600040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17862 cCE("wsrlhg", e600148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17863 cCE("wsrlw", ea00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17864 cCE("wsrlwg", ea00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17865 cCE("wsrld", ee00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17866 cCE("wsrldg", ee00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17867 cCE("wstrb", c000000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
17868 cCE("wstrh", c400000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
17869 cCE("wstrw", c000100
, 2, (RIWR_RIWC
, ADDR
), iwmmxt_wldstw
),
17870 cCE("wstrd", c400100
, 2, (RIWR
, ADDR
), iwmmxt_wldstd
),
17871 cCE("wsubbss", e3001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17872 cCE("wsubb", e0001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17873 cCE("wsubbus", e1001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17874 cCE("wsubhss", e7001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17875 cCE("wsubh", e4001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17876 cCE("wsubhus", e5001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17877 cCE("wsubwss", eb001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17878 cCE("wsubw", e8001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17879 cCE("wsubwus", e9001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17880 cCE("wunpckehub",e0000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17881 cCE("wunpckehuh",e4000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17882 cCE("wunpckehuw",e8000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17883 cCE("wunpckehsb",e2000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17884 cCE("wunpckehsh",e6000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17885 cCE("wunpckehsw",ea000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17886 cCE("wunpckihb", e1000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17887 cCE("wunpckihh", e5000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17888 cCE("wunpckihw", e9000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17889 cCE("wunpckelub",e0000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17890 cCE("wunpckeluh",e4000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17891 cCE("wunpckeluw",e8000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17892 cCE("wunpckelsb",e2000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17893 cCE("wunpckelsh",e6000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17894 cCE("wunpckelsw",ea000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17895 cCE("wunpckilb", e1000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17896 cCE("wunpckilh", e5000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17897 cCE("wunpckilw", e9000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17898 cCE("wxor", e100000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17899 cCE("wzero", e300000
, 1, (RIWR
), iwmmxt_wzero
),
17902 #define ARM_VARIANT & arm_cext_iwmmxt2 /* Intel Wireless MMX technology, version 2. */
17904 cCE("torvscb", e12f190
, 1, (RR
), iwmmxt_tandorc
),
17905 cCE("torvsch", e52f190
, 1, (RR
), iwmmxt_tandorc
),
17906 cCE("torvscw", e92f190
, 1, (RR
), iwmmxt_tandorc
),
17907 cCE("wabsb", e2001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17908 cCE("wabsh", e6001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17909 cCE("wabsw", ea001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17910 cCE("wabsdiffb", e1001c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17911 cCE("wabsdiffh", e5001c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17912 cCE("wabsdiffw", e9001c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17913 cCE("waddbhusl", e2001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17914 cCE("waddbhusm", e6001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17915 cCE("waddhc", e600180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17916 cCE("waddwc", ea00180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17917 cCE("waddsubhx", ea001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17918 cCE("wavg4", e400000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17919 cCE("wavg4r", e500000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17920 cCE("wmaddsn", ee00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17921 cCE("wmaddsx", eb00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17922 cCE("wmaddun", ec00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17923 cCE("wmaddux", e900100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17924 cCE("wmerge", e000080
, 4, (RIWR
, RIWR
, RIWR
, I7
), iwmmxt_wmerge
),
17925 cCE("wmiabb", e0000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17926 cCE("wmiabt", e1000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17927 cCE("wmiatb", e2000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17928 cCE("wmiatt", e3000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17929 cCE("wmiabbn", e4000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17930 cCE("wmiabtn", e5000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17931 cCE("wmiatbn", e6000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17932 cCE("wmiattn", e7000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17933 cCE("wmiawbb", e800120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17934 cCE("wmiawbt", e900120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17935 cCE("wmiawtb", ea00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17936 cCE("wmiawtt", eb00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17937 cCE("wmiawbbn", ec00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17938 cCE("wmiawbtn", ed00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17939 cCE("wmiawtbn", ee00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17940 cCE("wmiawttn", ef00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17941 cCE("wmulsmr", ef00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17942 cCE("wmulumr", ed00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17943 cCE("wmulwumr", ec000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17944 cCE("wmulwsmr", ee000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17945 cCE("wmulwum", ed000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17946 cCE("wmulwsm", ef000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17947 cCE("wmulwl", eb000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17948 cCE("wqmiabb", e8000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17949 cCE("wqmiabt", e9000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17950 cCE("wqmiatb", ea000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17951 cCE("wqmiatt", eb000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17952 cCE("wqmiabbn", ec000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17953 cCE("wqmiabtn", ed000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17954 cCE("wqmiatbn", ee000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17955 cCE("wqmiattn", ef000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17956 cCE("wqmulm", e100080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17957 cCE("wqmulmr", e300080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17958 cCE("wqmulwm", ec000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17959 cCE("wqmulwmr", ee000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17960 cCE("wsubaddhx", ed001c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17963 #define ARM_VARIANT & arm_cext_maverick /* Cirrus Maverick instructions. */
17965 cCE("cfldrs", c100400
, 2, (RMF
, ADDRGLDC
), rd_cpaddr
),
17966 cCE("cfldrd", c500400
, 2, (RMD
, ADDRGLDC
), rd_cpaddr
),
17967 cCE("cfldr32", c100500
, 2, (RMFX
, ADDRGLDC
), rd_cpaddr
),
17968 cCE("cfldr64", c500500
, 2, (RMDX
, ADDRGLDC
), rd_cpaddr
),
17969 cCE("cfstrs", c000400
, 2, (RMF
, ADDRGLDC
), rd_cpaddr
),
17970 cCE("cfstrd", c400400
, 2, (RMD
, ADDRGLDC
), rd_cpaddr
),
17971 cCE("cfstr32", c000500
, 2, (RMFX
, ADDRGLDC
), rd_cpaddr
),
17972 cCE("cfstr64", c400500
, 2, (RMDX
, ADDRGLDC
), rd_cpaddr
),
17973 cCE("cfmvsr", e000450
, 2, (RMF
, RR
), rn_rd
),
17974 cCE("cfmvrs", e100450
, 2, (RR
, RMF
), rd_rn
),
17975 cCE("cfmvdlr", e000410
, 2, (RMD
, RR
), rn_rd
),
17976 cCE("cfmvrdl", e100410
, 2, (RR
, RMD
), rd_rn
),
17977 cCE("cfmvdhr", e000430
, 2, (RMD
, RR
), rn_rd
),
17978 cCE("cfmvrdh", e100430
, 2, (RR
, RMD
), rd_rn
),
17979 cCE("cfmv64lr", e000510
, 2, (RMDX
, RR
), rn_rd
),
17980 cCE("cfmvr64l", e100510
, 2, (RR
, RMDX
), rd_rn
),
17981 cCE("cfmv64hr", e000530
, 2, (RMDX
, RR
), rn_rd
),
17982 cCE("cfmvr64h", e100530
, 2, (RR
, RMDX
), rd_rn
),
17983 cCE("cfmval32", e200440
, 2, (RMAX
, RMFX
), rd_rn
),
17984 cCE("cfmv32al", e100440
, 2, (RMFX
, RMAX
), rd_rn
),
17985 cCE("cfmvam32", e200460
, 2, (RMAX
, RMFX
), rd_rn
),
17986 cCE("cfmv32am", e100460
, 2, (RMFX
, RMAX
), rd_rn
),
17987 cCE("cfmvah32", e200480
, 2, (RMAX
, RMFX
), rd_rn
),
17988 cCE("cfmv32ah", e100480
, 2, (RMFX
, RMAX
), rd_rn
),
17989 cCE("cfmva32", e2004a0
, 2, (RMAX
, RMFX
), rd_rn
),
17990 cCE("cfmv32a", e1004a0
, 2, (RMFX
, RMAX
), rd_rn
),
17991 cCE("cfmva64", e2004c0
, 2, (RMAX
, RMDX
), rd_rn
),
17992 cCE("cfmv64a", e1004c0
, 2, (RMDX
, RMAX
), rd_rn
),
17993 cCE("cfmvsc32", e2004e0
, 2, (RMDS
, RMDX
), mav_dspsc
),
17994 cCE("cfmv32sc", e1004e0
, 2, (RMDX
, RMDS
), rd
),
17995 cCE("cfcpys", e000400
, 2, (RMF
, RMF
), rd_rn
),
17996 cCE("cfcpyd", e000420
, 2, (RMD
, RMD
), rd_rn
),
17997 cCE("cfcvtsd", e000460
, 2, (RMD
, RMF
), rd_rn
),
17998 cCE("cfcvtds", e000440
, 2, (RMF
, RMD
), rd_rn
),
17999 cCE("cfcvt32s", e000480
, 2, (RMF
, RMFX
), rd_rn
),
18000 cCE("cfcvt32d", e0004a0
, 2, (RMD
, RMFX
), rd_rn
),
18001 cCE("cfcvt64s", e0004c0
, 2, (RMF
, RMDX
), rd_rn
),
18002 cCE("cfcvt64d", e0004e0
, 2, (RMD
, RMDX
), rd_rn
),
18003 cCE("cfcvts32", e100580
, 2, (RMFX
, RMF
), rd_rn
),
18004 cCE("cfcvtd32", e1005a0
, 2, (RMFX
, RMD
), rd_rn
),
18005 cCE("cftruncs32",e1005c0
, 2, (RMFX
, RMF
), rd_rn
),
18006 cCE("cftruncd32",e1005e0
, 2, (RMFX
, RMD
), rd_rn
),
18007 cCE("cfrshl32", e000550
, 3, (RMFX
, RMFX
, RR
), mav_triple
),
18008 cCE("cfrshl64", e000570
, 3, (RMDX
, RMDX
, RR
), mav_triple
),
18009 cCE("cfsh32", e000500
, 3, (RMFX
, RMFX
, I63s
), mav_shift
),
18010 cCE("cfsh64", e200500
, 3, (RMDX
, RMDX
, I63s
), mav_shift
),
18011 cCE("cfcmps", e100490
, 3, (RR
, RMF
, RMF
), rd_rn_rm
),
18012 cCE("cfcmpd", e1004b0
, 3, (RR
, RMD
, RMD
), rd_rn_rm
),
18013 cCE("cfcmp32", e100590
, 3, (RR
, RMFX
, RMFX
), rd_rn_rm
),
18014 cCE("cfcmp64", e1005b0
, 3, (RR
, RMDX
, RMDX
), rd_rn_rm
),
18015 cCE("cfabss", e300400
, 2, (RMF
, RMF
), rd_rn
),
18016 cCE("cfabsd", e300420
, 2, (RMD
, RMD
), rd_rn
),
18017 cCE("cfnegs", e300440
, 2, (RMF
, RMF
), rd_rn
),
18018 cCE("cfnegd", e300460
, 2, (RMD
, RMD
), rd_rn
),
18019 cCE("cfadds", e300480
, 3, (RMF
, RMF
, RMF
), rd_rn_rm
),
18020 cCE("cfaddd", e3004a0
, 3, (RMD
, RMD
, RMD
), rd_rn_rm
),
18021 cCE("cfsubs", e3004c0
, 3, (RMF
, RMF
, RMF
), rd_rn_rm
),
18022 cCE("cfsubd", e3004e0
, 3, (RMD
, RMD
, RMD
), rd_rn_rm
),
18023 cCE("cfmuls", e100400
, 3, (RMF
, RMF
, RMF
), rd_rn_rm
),
18024 cCE("cfmuld", e100420
, 3, (RMD
, RMD
, RMD
), rd_rn_rm
),
18025 cCE("cfabs32", e300500
, 2, (RMFX
, RMFX
), rd_rn
),
18026 cCE("cfabs64", e300520
, 2, (RMDX
, RMDX
), rd_rn
),
18027 cCE("cfneg32", e300540
, 2, (RMFX
, RMFX
), rd_rn
),
18028 cCE("cfneg64", e300560
, 2, (RMDX
, RMDX
), rd_rn
),
18029 cCE("cfadd32", e300580
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
18030 cCE("cfadd64", e3005a0
, 3, (RMDX
, RMDX
, RMDX
), rd_rn_rm
),
18031 cCE("cfsub32", e3005c0
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
18032 cCE("cfsub64", e3005e0
, 3, (RMDX
, RMDX
, RMDX
), rd_rn_rm
),
18033 cCE("cfmul32", e100500
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
18034 cCE("cfmul64", e100520
, 3, (RMDX
, RMDX
, RMDX
), rd_rn_rm
),
18035 cCE("cfmac32", e100540
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
18036 cCE("cfmsc32", e100560
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
18037 cCE("cfmadd32", e000600
, 4, (RMAX
, RMFX
, RMFX
, RMFX
), mav_quad
),
18038 cCE("cfmsub32", e100600
, 4, (RMAX
, RMFX
, RMFX
, RMFX
), mav_quad
),
18039 cCE("cfmadda32", e200600
, 4, (RMAX
, RMAX
, RMFX
, RMFX
), mav_quad
),
18040 cCE("cfmsuba32", e300600
, 4, (RMAX
, RMAX
, RMFX
, RMFX
), mav_quad
),
18043 #undef THUMB_VARIANT
18070 /* MD interface: bits in the object file. */
18072 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
18073 for use in the a.out file, and stores them in the array pointed to by buf.
18074 This knows about the endian-ness of the target machine and does
18075 THE RIGHT THING, whatever it is. Possible values for n are 1 (byte)
18076 2 (short) and 4 (long) Floating numbers are put out as a series of
18077 LITTLENUMS (shorts, here at least). */
18080 md_number_to_chars (char * buf
, valueT val
, int n
)
18082 if (target_big_endian
)
18083 number_to_chars_bigendian (buf
, val
, n
);
18085 number_to_chars_littleendian (buf
, val
, n
);
18089 md_chars_to_number (char * buf
, int n
)
18092 unsigned char * where
= (unsigned char *) buf
;
18094 if (target_big_endian
)
18099 result
|= (*where
++ & 255);
18107 result
|= (where
[n
] & 255);
18114 /* MD interface: Sections. */
18116 /* Estimate the size of a frag before relaxing. Assume everything fits in
18120 md_estimate_size_before_relax (fragS
* fragp
,
18121 segT segtype ATTRIBUTE_UNUSED
)
18127 /* Convert a machine dependent frag. */
18130 md_convert_frag (bfd
*abfd
, segT asec ATTRIBUTE_UNUSED
, fragS
*fragp
)
18132 unsigned long insn
;
18133 unsigned long old_op
;
18141 buf
= fragp
->fr_literal
+ fragp
->fr_fix
;
18143 old_op
= bfd_get_16(abfd
, buf
);
18144 if (fragp
->fr_symbol
)
18146 exp
.X_op
= O_symbol
;
18147 exp
.X_add_symbol
= fragp
->fr_symbol
;
18151 exp
.X_op
= O_constant
;
18153 exp
.X_add_number
= fragp
->fr_offset
;
18154 opcode
= fragp
->fr_subtype
;
18157 case T_MNEM_ldr_pc
:
18158 case T_MNEM_ldr_pc2
:
18159 case T_MNEM_ldr_sp
:
18160 case T_MNEM_str_sp
:
18167 if (fragp
->fr_var
== 4)
18169 insn
= THUMB_OP32 (opcode
);
18170 if ((old_op
>> 12) == 4 || (old_op
>> 12) == 9)
18172 insn
|= (old_op
& 0x700) << 4;
18176 insn
|= (old_op
& 7) << 12;
18177 insn
|= (old_op
& 0x38) << 13;
18179 insn
|= 0x00000c00;
18180 put_thumb32_insn (buf
, insn
);
18181 reloc_type
= BFD_RELOC_ARM_T32_OFFSET_IMM
;
18185 reloc_type
= BFD_RELOC_ARM_THUMB_OFFSET
;
18187 pc_rel
= (opcode
== T_MNEM_ldr_pc2
);
18190 if (fragp
->fr_var
== 4)
18192 insn
= THUMB_OP32 (opcode
);
18193 insn
|= (old_op
& 0xf0) << 4;
18194 put_thumb32_insn (buf
, insn
);
18195 reloc_type
= BFD_RELOC_ARM_T32_ADD_PC12
;
18199 reloc_type
= BFD_RELOC_ARM_THUMB_ADD
;
18200 exp
.X_add_number
-= 4;
18208 if (fragp
->fr_var
== 4)
18210 int r0off
= (opcode
== T_MNEM_mov
18211 || opcode
== T_MNEM_movs
) ? 0 : 8;
18212 insn
= THUMB_OP32 (opcode
);
18213 insn
= (insn
& 0xe1ffffff) | 0x10000000;
18214 insn
|= (old_op
& 0x700) << r0off
;
18215 put_thumb32_insn (buf
, insn
);
18216 reloc_type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
18220 reloc_type
= BFD_RELOC_ARM_THUMB_IMM
;
18225 if (fragp
->fr_var
== 4)
18227 insn
= THUMB_OP32(opcode
);
18228 put_thumb32_insn (buf
, insn
);
18229 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH25
;
18232 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH12
;
18236 if (fragp
->fr_var
== 4)
18238 insn
= THUMB_OP32(opcode
);
18239 insn
|= (old_op
& 0xf00) << 14;
18240 put_thumb32_insn (buf
, insn
);
18241 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH20
;
18244 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH9
;
18247 case T_MNEM_add_sp
:
18248 case T_MNEM_add_pc
:
18249 case T_MNEM_inc_sp
:
18250 case T_MNEM_dec_sp
:
18251 if (fragp
->fr_var
== 4)
18253 /* ??? Choose between add and addw. */
18254 insn
= THUMB_OP32 (opcode
);
18255 insn
|= (old_op
& 0xf0) << 4;
18256 put_thumb32_insn (buf
, insn
);
18257 if (opcode
== T_MNEM_add_pc
)
18258 reloc_type
= BFD_RELOC_ARM_T32_IMM12
;
18260 reloc_type
= BFD_RELOC_ARM_T32_ADD_IMM
;
18263 reloc_type
= BFD_RELOC_ARM_THUMB_ADD
;
18271 if (fragp
->fr_var
== 4)
18273 insn
= THUMB_OP32 (opcode
);
18274 insn
|= (old_op
& 0xf0) << 4;
18275 insn
|= (old_op
& 0xf) << 16;
18276 put_thumb32_insn (buf
, insn
);
18277 if (insn
& (1 << 20))
18278 reloc_type
= BFD_RELOC_ARM_T32_ADD_IMM
;
18280 reloc_type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
18283 reloc_type
= BFD_RELOC_ARM_THUMB_ADD
;
18289 fixp
= fix_new_exp (fragp
, fragp
->fr_fix
, fragp
->fr_var
, &exp
, pc_rel
,
18290 (enum bfd_reloc_code_real
) reloc_type
);
18291 fixp
->fx_file
= fragp
->fr_file
;
18292 fixp
->fx_line
= fragp
->fr_line
;
18293 fragp
->fr_fix
+= fragp
->fr_var
;
18296 /* Return the size of a relaxable immediate operand instruction.
18297 SHIFT and SIZE specify the form of the allowable immediate. */
18299 relax_immediate (fragS
*fragp
, int size
, int shift
)
18305 /* ??? Should be able to do better than this. */
18306 if (fragp
->fr_symbol
)
18309 low
= (1 << shift
) - 1;
18310 mask
= (1 << (shift
+ size
)) - (1 << shift
);
18311 offset
= fragp
->fr_offset
;
18312 /* Force misaligned offsets to 32-bit variant. */
18315 if (offset
& ~mask
)
18320 /* Get the address of a symbol during relaxation. */
18322 relaxed_symbol_addr (fragS
*fragp
, long stretch
)
18328 sym
= fragp
->fr_symbol
;
18329 sym_frag
= symbol_get_frag (sym
);
18330 know (S_GET_SEGMENT (sym
) != absolute_section
18331 || sym_frag
== &zero_address_frag
);
18332 addr
= S_GET_VALUE (sym
) + fragp
->fr_offset
;
18334 /* If frag has yet to be reached on this pass, assume it will
18335 move by STRETCH just as we did. If this is not so, it will
18336 be because some frag between grows, and that will force
18340 && sym_frag
->relax_marker
!= fragp
->relax_marker
)
18344 /* Adjust stretch for any alignment frag. Note that if have
18345 been expanding the earlier code, the symbol may be
18346 defined in what appears to be an earlier frag. FIXME:
18347 This doesn't handle the fr_subtype field, which specifies
18348 a maximum number of bytes to skip when doing an
18350 for (f
= fragp
; f
!= NULL
&& f
!= sym_frag
; f
= f
->fr_next
)
18352 if (f
->fr_type
== rs_align
|| f
->fr_type
== rs_align_code
)
18355 stretch
= - ((- stretch
)
18356 & ~ ((1 << (int) f
->fr_offset
) - 1));
18358 stretch
&= ~ ((1 << (int) f
->fr_offset
) - 1);
18370 /* Return the size of a relaxable adr pseudo-instruction or PC-relative
18373 relax_adr (fragS
*fragp
, asection
*sec
, long stretch
)
18378 /* Assume worst case for symbols not known to be in the same section. */
18379 if (fragp
->fr_symbol
== NULL
18380 || !S_IS_DEFINED (fragp
->fr_symbol
)
18381 || sec
!= S_GET_SEGMENT (fragp
->fr_symbol
))
18384 val
= relaxed_symbol_addr (fragp
, stretch
);
18385 addr
= fragp
->fr_address
+ fragp
->fr_fix
;
18386 addr
= (addr
+ 4) & ~3;
18387 /* Force misaligned targets to 32-bit variant. */
18391 if (val
< 0 || val
> 1020)
18396 /* Return the size of a relaxable add/sub immediate instruction. */
18398 relax_addsub (fragS
*fragp
, asection
*sec
)
18403 buf
= fragp
->fr_literal
+ fragp
->fr_fix
;
18404 op
= bfd_get_16(sec
->owner
, buf
);
18405 if ((op
& 0xf) == ((op
>> 4) & 0xf))
18406 return relax_immediate (fragp
, 8, 0);
18408 return relax_immediate (fragp
, 3, 0);
18412 /* Return the size of a relaxable branch instruction. BITS is the
18413 size of the offset field in the narrow instruction. */
18416 relax_branch (fragS
*fragp
, asection
*sec
, int bits
, long stretch
)
18422 /* Assume worst case for symbols not known to be in the same section. */
18423 if (!S_IS_DEFINED (fragp
->fr_symbol
)
18424 || sec
!= S_GET_SEGMENT (fragp
->fr_symbol
))
18428 if (S_IS_DEFINED (fragp
->fr_symbol
)
18429 && ARM_IS_FUNC (fragp
->fr_symbol
))
18433 val
= relaxed_symbol_addr (fragp
, stretch
);
18434 addr
= fragp
->fr_address
+ fragp
->fr_fix
+ 4;
18437 /* Offset is a signed value *2 */
18439 if (val
>= limit
|| val
< -limit
)
18445 /* Relax a machine dependent frag. This returns the amount by which
18446 the current size of the frag should change. */
18449 arm_relax_frag (asection
*sec
, fragS
*fragp
, long stretch
)
18454 oldsize
= fragp
->fr_var
;
18455 switch (fragp
->fr_subtype
)
18457 case T_MNEM_ldr_pc2
:
18458 newsize
= relax_adr (fragp
, sec
, stretch
);
18460 case T_MNEM_ldr_pc
:
18461 case T_MNEM_ldr_sp
:
18462 case T_MNEM_str_sp
:
18463 newsize
= relax_immediate (fragp
, 8, 2);
18467 newsize
= relax_immediate (fragp
, 5, 2);
18471 newsize
= relax_immediate (fragp
, 5, 1);
18475 newsize
= relax_immediate (fragp
, 5, 0);
18478 newsize
= relax_adr (fragp
, sec
, stretch
);
18484 newsize
= relax_immediate (fragp
, 8, 0);
18487 newsize
= relax_branch (fragp
, sec
, 11, stretch
);
18490 newsize
= relax_branch (fragp
, sec
, 8, stretch
);
18492 case T_MNEM_add_sp
:
18493 case T_MNEM_add_pc
:
18494 newsize
= relax_immediate (fragp
, 8, 2);
18496 case T_MNEM_inc_sp
:
18497 case T_MNEM_dec_sp
:
18498 newsize
= relax_immediate (fragp
, 7, 2);
18504 newsize
= relax_addsub (fragp
, sec
);
18510 fragp
->fr_var
= newsize
;
18511 /* Freeze wide instructions that are at or before the same location as
18512 in the previous pass. This avoids infinite loops.
18513 Don't freeze them unconditionally because targets may be artificially
18514 misaligned by the expansion of preceding frags. */
18515 if (stretch
<= 0 && newsize
> 2)
18517 md_convert_frag (sec
->owner
, sec
, fragp
);
18521 return newsize
- oldsize
;
18524 /* Round up a section size to the appropriate boundary. */
18527 md_section_align (segT segment ATTRIBUTE_UNUSED
,
18530 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
18531 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
18533 /* For a.out, force the section size to be aligned. If we don't do
18534 this, BFD will align it for us, but it will not write out the
18535 final bytes of the section. This may be a bug in BFD, but it is
18536 easier to fix it here since that is how the other a.out targets
18540 align
= bfd_get_section_alignment (stdoutput
, segment
);
18541 size
= ((size
+ (1 << align
) - 1) & ((valueT
) -1 << align
));
18548 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
18549 of an rs_align_code fragment. */
18552 arm_handle_align (fragS
* fragP
)
18554 static char const arm_noop
[2][2][4] =
18557 {0x00, 0x00, 0xa0, 0xe1}, /* LE */
18558 {0xe1, 0xa0, 0x00, 0x00}, /* BE */
18561 {0x00, 0xf0, 0x20, 0xe3}, /* LE */
18562 {0xe3, 0x20, 0xf0, 0x00}, /* BE */
18565 static char const thumb_noop
[2][2][2] =
18568 {0xc0, 0x46}, /* LE */
18569 {0x46, 0xc0}, /* BE */
18572 {0x00, 0xbf}, /* LE */
18573 {0xbf, 0x00} /* BE */
18576 static char const wide_thumb_noop
[2][4] =
18577 { /* Wide Thumb-2 */
18578 {0xaf, 0xf3, 0x00, 0x80}, /* LE */
18579 {0xf3, 0xaf, 0x80, 0x00}, /* BE */
18582 unsigned bytes
, fix
, noop_size
;
18585 const char *narrow_noop
= NULL
;
18590 if (fragP
->fr_type
!= rs_align_code
)
18593 bytes
= fragP
->fr_next
->fr_address
- fragP
->fr_address
- fragP
->fr_fix
;
18594 p
= fragP
->fr_literal
+ fragP
->fr_fix
;
18597 if (bytes
> MAX_MEM_FOR_RS_ALIGN_CODE
)
18598 bytes
&= MAX_MEM_FOR_RS_ALIGN_CODE
;
18600 gas_assert ((fragP
->tc_frag_data
.thumb_mode
& MODE_RECORDED
) != 0);
18602 if (fragP
->tc_frag_data
.thumb_mode
& (~ MODE_RECORDED
))
18604 if (ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v6t2
))
18606 narrow_noop
= thumb_noop
[1][target_big_endian
];
18607 noop
= wide_thumb_noop
[target_big_endian
];
18610 noop
= thumb_noop
[0][target_big_endian
];
18618 noop
= arm_noop
[ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v6k
) != 0]
18619 [target_big_endian
];
18626 fragP
->fr_var
= noop_size
;
18628 if (bytes
& (noop_size
- 1))
18630 fix
= bytes
& (noop_size
- 1);
18632 insert_data_mapping_symbol (state
, fragP
->fr_fix
, fragP
, fix
);
18634 memset (p
, 0, fix
);
18641 if (bytes
& noop_size
)
18643 /* Insert a narrow noop. */
18644 memcpy (p
, narrow_noop
, noop_size
);
18646 bytes
-= noop_size
;
18650 /* Use wide noops for the remainder */
18654 while (bytes
>= noop_size
)
18656 memcpy (p
, noop
, noop_size
);
18658 bytes
-= noop_size
;
18662 fragP
->fr_fix
+= fix
;
18665 /* Called from md_do_align. Used to create an alignment
18666 frag in a code section. */
18669 arm_frag_align_code (int n
, int max
)
18673 /* We assume that there will never be a requirement
18674 to support alignments greater than MAX_MEM_FOR_RS_ALIGN_CODE bytes. */
18675 if (max
> MAX_MEM_FOR_RS_ALIGN_CODE
)
18680 _("alignments greater than %d bytes not supported in .text sections."),
18681 MAX_MEM_FOR_RS_ALIGN_CODE
+ 1);
18682 as_fatal ("%s", err_msg
);
18685 p
= frag_var (rs_align_code
,
18686 MAX_MEM_FOR_RS_ALIGN_CODE
,
18688 (relax_substateT
) max
,
18695 /* Perform target specific initialisation of a frag.
18696 Note - despite the name this initialisation is not done when the frag
18697 is created, but only when its type is assigned. A frag can be created
18698 and used a long time before its type is set, so beware of assuming that
18699 this initialisationis performed first. */
18703 arm_init_frag (fragS
* fragP
, int max_chars ATTRIBUTE_UNUSED
)
18705 /* Record whether this frag is in an ARM or a THUMB area. */
18706 fragP
->tc_frag_data
.thumb_mode
= thumb_mode
| MODE_RECORDED
;
18709 #else /* OBJ_ELF is defined. */
18711 arm_init_frag (fragS
* fragP
, int max_chars
)
18713 /* If the current ARM vs THUMB mode has not already
18714 been recorded into this frag then do so now. */
18715 if ((fragP
->tc_frag_data
.thumb_mode
& MODE_RECORDED
) == 0)
18717 fragP
->tc_frag_data
.thumb_mode
= thumb_mode
| MODE_RECORDED
;
18719 /* Record a mapping symbol for alignment frags. We will delete this
18720 later if the alignment ends up empty. */
18721 switch (fragP
->fr_type
)
18724 case rs_align_test
:
18726 mapping_state_2 (MAP_DATA
, max_chars
);
18728 case rs_align_code
:
18729 mapping_state_2 (thumb_mode
? MAP_THUMB
: MAP_ARM
, max_chars
);
18737 /* When we change sections we need to issue a new mapping symbol. */
18740 arm_elf_change_section (void)
18742 /* Link an unlinked unwind index table section to the .text section. */
18743 if (elf_section_type (now_seg
) == SHT_ARM_EXIDX
18744 && elf_linked_to_section (now_seg
) == NULL
)
18745 elf_linked_to_section (now_seg
) = text_section
;
18749 arm_elf_section_type (const char * str
, size_t len
)
18751 if (len
== 5 && strncmp (str
, "exidx", 5) == 0)
18752 return SHT_ARM_EXIDX
;
18757 /* Code to deal with unwinding tables. */
18759 static void add_unwind_adjustsp (offsetT
);
18761 /* Generate any deferred unwind frame offset. */
18764 flush_pending_unwind (void)
18768 offset
= unwind
.pending_offset
;
18769 unwind
.pending_offset
= 0;
18771 add_unwind_adjustsp (offset
);
18774 /* Add an opcode to this list for this function. Two-byte opcodes should
18775 be passed as op[0] << 8 | op[1]. The list of opcodes is built in reverse
18779 add_unwind_opcode (valueT op
, int length
)
18781 /* Add any deferred stack adjustment. */
18782 if (unwind
.pending_offset
)
18783 flush_pending_unwind ();
18785 unwind
.sp_restored
= 0;
18787 if (unwind
.opcode_count
+ length
> unwind
.opcode_alloc
)
18789 unwind
.opcode_alloc
+= ARM_OPCODE_CHUNK_SIZE
;
18790 if (unwind
.opcodes
)
18791 unwind
.opcodes
= (unsigned char *) xrealloc (unwind
.opcodes
,
18792 unwind
.opcode_alloc
);
18794 unwind
.opcodes
= (unsigned char *) xmalloc (unwind
.opcode_alloc
);
18799 unwind
.opcodes
[unwind
.opcode_count
] = op
& 0xff;
18801 unwind
.opcode_count
++;
18805 /* Add unwind opcodes to adjust the stack pointer. */
18808 add_unwind_adjustsp (offsetT offset
)
18812 if (offset
> 0x200)
18814 /* We need at most 5 bytes to hold a 32-bit value in a uleb128. */
18819 /* Long form: 0xb2, uleb128. */
18820 /* This might not fit in a word so add the individual bytes,
18821 remembering the list is built in reverse order. */
18822 o
= (valueT
) ((offset
- 0x204) >> 2);
18824 add_unwind_opcode (0, 1);
18826 /* Calculate the uleb128 encoding of the offset. */
18830 bytes
[n
] = o
& 0x7f;
18836 /* Add the insn. */
18838 add_unwind_opcode (bytes
[n
- 1], 1);
18839 add_unwind_opcode (0xb2, 1);
18841 else if (offset
> 0x100)
18843 /* Two short opcodes. */
18844 add_unwind_opcode (0x3f, 1);
18845 op
= (offset
- 0x104) >> 2;
18846 add_unwind_opcode (op
, 1);
18848 else if (offset
> 0)
18850 /* Short opcode. */
18851 op
= (offset
- 4) >> 2;
18852 add_unwind_opcode (op
, 1);
18854 else if (offset
< 0)
18857 while (offset
> 0x100)
18859 add_unwind_opcode (0x7f, 1);
18862 op
= ((offset
- 4) >> 2) | 0x40;
18863 add_unwind_opcode (op
, 1);
18867 /* Finish the list of unwind opcodes for this function. */
18869 finish_unwind_opcodes (void)
18873 if (unwind
.fp_used
)
18875 /* Adjust sp as necessary. */
18876 unwind
.pending_offset
+= unwind
.fp_offset
- unwind
.frame_size
;
18877 flush_pending_unwind ();
18879 /* After restoring sp from the frame pointer. */
18880 op
= 0x90 | unwind
.fp_reg
;
18881 add_unwind_opcode (op
, 1);
18884 flush_pending_unwind ();
18888 /* Start an exception table entry. If idx is nonzero this is an index table
18892 start_unwind_section (const segT text_seg
, int idx
)
18894 const char * text_name
;
18895 const char * prefix
;
18896 const char * prefix_once
;
18897 const char * group_name
;
18901 size_t sec_name_len
;
18908 prefix
= ELF_STRING_ARM_unwind
;
18909 prefix_once
= ELF_STRING_ARM_unwind_once
;
18910 type
= SHT_ARM_EXIDX
;
18914 prefix
= ELF_STRING_ARM_unwind_info
;
18915 prefix_once
= ELF_STRING_ARM_unwind_info_once
;
18916 type
= SHT_PROGBITS
;
18919 text_name
= segment_name (text_seg
);
18920 if (streq (text_name
, ".text"))
18923 if (strncmp (text_name
, ".gnu.linkonce.t.",
18924 strlen (".gnu.linkonce.t.")) == 0)
18926 prefix
= prefix_once
;
18927 text_name
+= strlen (".gnu.linkonce.t.");
18930 prefix_len
= strlen (prefix
);
18931 text_len
= strlen (text_name
);
18932 sec_name_len
= prefix_len
+ text_len
;
18933 sec_name
= (char *) xmalloc (sec_name_len
+ 1);
18934 memcpy (sec_name
, prefix
, prefix_len
);
18935 memcpy (sec_name
+ prefix_len
, text_name
, text_len
);
18936 sec_name
[prefix_len
+ text_len
] = '\0';
18942 /* Handle COMDAT group. */
18943 if (prefix
!= prefix_once
&& (text_seg
->flags
& SEC_LINK_ONCE
) != 0)
18945 group_name
= elf_group_name (text_seg
);
18946 if (group_name
== NULL
)
18948 as_bad (_("Group section `%s' has no group signature"),
18949 segment_name (text_seg
));
18950 ignore_rest_of_line ();
18953 flags
|= SHF_GROUP
;
18957 obj_elf_change_section (sec_name
, type
, flags
, 0, group_name
, linkonce
, 0);
18959 /* Set the section link for index tables. */
18961 elf_linked_to_section (now_seg
) = text_seg
;
18965 /* Start an unwind table entry. HAVE_DATA is nonzero if we have additional
18966 personality routine data. Returns zero, or the index table value for
18967 and inline entry. */
18970 create_unwind_entry (int have_data
)
18975 /* The current word of data. */
18977 /* The number of bytes left in this word. */
18980 finish_unwind_opcodes ();
18982 /* Remember the current text section. */
18983 unwind
.saved_seg
= now_seg
;
18984 unwind
.saved_subseg
= now_subseg
;
18986 start_unwind_section (now_seg
, 0);
18988 if (unwind
.personality_routine
== NULL
)
18990 if (unwind
.personality_index
== -2)
18993 as_bad (_("handlerdata in cantunwind frame"));
18994 return 1; /* EXIDX_CANTUNWIND. */
18997 /* Use a default personality routine if none is specified. */
18998 if (unwind
.personality_index
== -1)
19000 if (unwind
.opcode_count
> 3)
19001 unwind
.personality_index
= 1;
19003 unwind
.personality_index
= 0;
19006 /* Space for the personality routine entry. */
19007 if (unwind
.personality_index
== 0)
19009 if (unwind
.opcode_count
> 3)
19010 as_bad (_("too many unwind opcodes for personality routine 0"));
19014 /* All the data is inline in the index table. */
19017 while (unwind
.opcode_count
> 0)
19019 unwind
.opcode_count
--;
19020 data
= (data
<< 8) | unwind
.opcodes
[unwind
.opcode_count
];
19024 /* Pad with "finish" opcodes. */
19026 data
= (data
<< 8) | 0xb0;
19033 /* We get two opcodes "free" in the first word. */
19034 size
= unwind
.opcode_count
- 2;
19037 /* An extra byte is required for the opcode count. */
19038 size
= unwind
.opcode_count
+ 1;
19040 size
= (size
+ 3) >> 2;
19042 as_bad (_("too many unwind opcodes"));
19044 frag_align (2, 0, 0);
19045 record_alignment (now_seg
, 2);
19046 unwind
.table_entry
= expr_build_dot ();
19048 /* Allocate the table entry. */
19049 ptr
= frag_more ((size
<< 2) + 4);
19050 where
= frag_now_fix () - ((size
<< 2) + 4);
19052 switch (unwind
.personality_index
)
19055 /* ??? Should this be a PLT generating relocation? */
19056 /* Custom personality routine. */
19057 fix_new (frag_now
, where
, 4, unwind
.personality_routine
, 0, 1,
19058 BFD_RELOC_ARM_PREL31
);
19063 /* Set the first byte to the number of additional words. */
19068 /* ABI defined personality routines. */
19070 /* Three opcodes bytes are packed into the first word. */
19077 /* The size and first two opcode bytes go in the first word. */
19078 data
= ((0x80 + unwind
.personality_index
) << 8) | size
;
19083 /* Should never happen. */
19087 /* Pack the opcodes into words (MSB first), reversing the list at the same
19089 while (unwind
.opcode_count
> 0)
19093 md_number_to_chars (ptr
, data
, 4);
19098 unwind
.opcode_count
--;
19100 data
= (data
<< 8) | unwind
.opcodes
[unwind
.opcode_count
];
19103 /* Finish off the last word. */
19106 /* Pad with "finish" opcodes. */
19108 data
= (data
<< 8) | 0xb0;
19110 md_number_to_chars (ptr
, data
, 4);
19115 /* Add an empty descriptor if there is no user-specified data. */
19116 ptr
= frag_more (4);
19117 md_number_to_chars (ptr
, 0, 4);
19124 /* Initialize the DWARF-2 unwind information for this procedure. */
19127 tc_arm_frame_initial_instructions (void)
19129 cfi_add_CFA_def_cfa (REG_SP
, 0);
19131 #endif /* OBJ_ELF */
19133 /* Convert REGNAME to a DWARF-2 register number. */
19136 tc_arm_regname_to_dw2regnum (char *regname
)
19138 int reg
= arm_reg_parse (®name
, REG_TYPE_RN
);
19148 tc_pe_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
19152 exp
.X_op
= O_secrel
;
19153 exp
.X_add_symbol
= symbol
;
19154 exp
.X_add_number
= 0;
19155 emit_expr (&exp
, size
);
19159 /* MD interface: Symbol and relocation handling. */
19161 /* Return the address within the segment that a PC-relative fixup is
19162 relative to. For ARM, PC-relative fixups applied to instructions
19163 are generally relative to the location of the fixup plus 8 bytes.
19164 Thumb branches are offset by 4, and Thumb loads relative to PC
19165 require special handling. */
19168 md_pcrel_from_section (fixS
* fixP
, segT seg
)
19170 offsetT base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
19172 /* If this is pc-relative and we are going to emit a relocation
19173 then we just want to put out any pipeline compensation that the linker
19174 will need. Otherwise we want to use the calculated base.
19175 For WinCE we skip the bias for externals as well, since this
19176 is how the MS ARM-CE assembler behaves and we want to be compatible. */
19178 && ((fixP
->fx_addsy
&& S_GET_SEGMENT (fixP
->fx_addsy
) != seg
)
19179 || (arm_force_relocation (fixP
)
19181 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
19187 switch (fixP
->fx_r_type
)
19189 /* PC relative addressing on the Thumb is slightly odd as the
19190 bottom two bits of the PC are forced to zero for the
19191 calculation. This happens *after* application of the
19192 pipeline offset. However, Thumb adrl already adjusts for
19193 this, so we need not do it again. */
19194 case BFD_RELOC_ARM_THUMB_ADD
:
19197 case BFD_RELOC_ARM_THUMB_OFFSET
:
19198 case BFD_RELOC_ARM_T32_OFFSET_IMM
:
19199 case BFD_RELOC_ARM_T32_ADD_PC12
:
19200 case BFD_RELOC_ARM_T32_CP_OFF_IMM
:
19201 return (base
+ 4) & ~3;
19203 /* Thumb branches are simply offset by +4. */
19204 case BFD_RELOC_THUMB_PCREL_BRANCH7
:
19205 case BFD_RELOC_THUMB_PCREL_BRANCH9
:
19206 case BFD_RELOC_THUMB_PCREL_BRANCH12
:
19207 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
19208 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
19211 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
19213 && ARM_IS_FUNC (fixP
->fx_addsy
)
19214 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
19215 base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
19218 /* BLX is like branches above, but forces the low two bits of PC to
19220 case BFD_RELOC_THUMB_PCREL_BLX
:
19222 && THUMB_IS_FUNC (fixP
->fx_addsy
)
19223 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
19224 base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
19225 return (base
+ 4) & ~3;
19227 /* ARM mode branches are offset by +8. However, the Windows CE
19228 loader expects the relocation not to take this into account. */
19229 case BFD_RELOC_ARM_PCREL_BLX
:
19231 && ARM_IS_FUNC (fixP
->fx_addsy
)
19232 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
19233 base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
19236 case BFD_RELOC_ARM_PCREL_CALL
:
19238 && THUMB_IS_FUNC (fixP
->fx_addsy
)
19239 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
19240 base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
19243 case BFD_RELOC_ARM_PCREL_BRANCH
:
19244 case BFD_RELOC_ARM_PCREL_JUMP
:
19245 case BFD_RELOC_ARM_PLT32
:
19247 /* When handling fixups immediately, because we have already
19248 discovered the value of a symbol, or the address of the frag involved
19249 we must account for the offset by +8, as the OS loader will never see the reloc.
19250 see fixup_segment() in write.c
19251 The S_IS_EXTERNAL test handles the case of global symbols.
19252 Those need the calculated base, not just the pipe compensation the linker will need. */
19254 && fixP
->fx_addsy
!= NULL
19255 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
19256 && (S_IS_EXTERNAL (fixP
->fx_addsy
) || !arm_force_relocation (fixP
)))
19264 /* ARM mode loads relative to PC are also offset by +8. Unlike
19265 branches, the Windows CE loader *does* expect the relocation
19266 to take this into account. */
19267 case BFD_RELOC_ARM_OFFSET_IMM
:
19268 case BFD_RELOC_ARM_OFFSET_IMM8
:
19269 case BFD_RELOC_ARM_HWLITERAL
:
19270 case BFD_RELOC_ARM_LITERAL
:
19271 case BFD_RELOC_ARM_CP_OFF_IMM
:
19275 /* Other PC-relative relocations are un-offset. */
19281 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
19282 Otherwise we have no need to default values of symbols. */
19285 md_undefined_symbol (char * name ATTRIBUTE_UNUSED
)
19288 if (name
[0] == '_' && name
[1] == 'G'
19289 && streq (name
, GLOBAL_OFFSET_TABLE_NAME
))
19293 if (symbol_find (name
))
19294 as_bad (_("GOT already in the symbol table"));
19296 GOT_symbol
= symbol_new (name
, undefined_section
,
19297 (valueT
) 0, & zero_address_frag
);
19307 /* Subroutine of md_apply_fix. Check to see if an immediate can be
19308 computed as two separate immediate values, added together. We
19309 already know that this value cannot be computed by just one ARM
19312 static unsigned int
19313 validate_immediate_twopart (unsigned int val
,
19314 unsigned int * highpart
)
19319 for (i
= 0; i
< 32; i
+= 2)
19320 if (((a
= rotate_left (val
, i
)) & 0xff) != 0)
19326 * highpart
= (a
>> 8) | ((i
+ 24) << 7);
19328 else if (a
& 0xff0000)
19330 if (a
& 0xff000000)
19332 * highpart
= (a
>> 16) | ((i
+ 16) << 7);
19336 gas_assert (a
& 0xff000000);
19337 * highpart
= (a
>> 24) | ((i
+ 8) << 7);
19340 return (a
& 0xff) | (i
<< 7);
19347 validate_offset_imm (unsigned int val
, int hwse
)
19349 if ((hwse
&& val
> 255) || val
> 4095)
19354 /* Subroutine of md_apply_fix. Do those data_ops which can take a
19355 negative immediate constant by altering the instruction. A bit of
19360 by inverting the second operand, and
19363 by negating the second operand. */
19366 negate_data_op (unsigned long * instruction
,
19367 unsigned long value
)
19370 unsigned long negated
, inverted
;
19372 negated
= encode_arm_immediate (-value
);
19373 inverted
= encode_arm_immediate (~value
);
19375 op
= (*instruction
>> DATA_OP_SHIFT
) & 0xf;
19378 /* First negates. */
19379 case OPCODE_SUB
: /* ADD <-> SUB */
19380 new_inst
= OPCODE_ADD
;
19385 new_inst
= OPCODE_SUB
;
19389 case OPCODE_CMP
: /* CMP <-> CMN */
19390 new_inst
= OPCODE_CMN
;
19395 new_inst
= OPCODE_CMP
;
19399 /* Now Inverted ops. */
19400 case OPCODE_MOV
: /* MOV <-> MVN */
19401 new_inst
= OPCODE_MVN
;
19406 new_inst
= OPCODE_MOV
;
19410 case OPCODE_AND
: /* AND <-> BIC */
19411 new_inst
= OPCODE_BIC
;
19416 new_inst
= OPCODE_AND
;
19420 case OPCODE_ADC
: /* ADC <-> SBC */
19421 new_inst
= OPCODE_SBC
;
19426 new_inst
= OPCODE_ADC
;
19430 /* We cannot do anything. */
19435 if (value
== (unsigned) FAIL
)
19438 *instruction
&= OPCODE_MASK
;
19439 *instruction
|= new_inst
<< DATA_OP_SHIFT
;
19443 /* Like negate_data_op, but for Thumb-2. */
19445 static unsigned int
19446 thumb32_negate_data_op (offsetT
*instruction
, unsigned int value
)
19450 unsigned int negated
, inverted
;
19452 negated
= encode_thumb32_immediate (-value
);
19453 inverted
= encode_thumb32_immediate (~value
);
19455 rd
= (*instruction
>> 8) & 0xf;
19456 op
= (*instruction
>> T2_DATA_OP_SHIFT
) & 0xf;
19459 /* ADD <-> SUB. Includes CMP <-> CMN. */
19460 case T2_OPCODE_SUB
:
19461 new_inst
= T2_OPCODE_ADD
;
19465 case T2_OPCODE_ADD
:
19466 new_inst
= T2_OPCODE_SUB
;
19470 /* ORR <-> ORN. Includes MOV <-> MVN. */
19471 case T2_OPCODE_ORR
:
19472 new_inst
= T2_OPCODE_ORN
;
19476 case T2_OPCODE_ORN
:
19477 new_inst
= T2_OPCODE_ORR
;
19481 /* AND <-> BIC. TST has no inverted equivalent. */
19482 case T2_OPCODE_AND
:
19483 new_inst
= T2_OPCODE_BIC
;
19490 case T2_OPCODE_BIC
:
19491 new_inst
= T2_OPCODE_AND
;
19496 case T2_OPCODE_ADC
:
19497 new_inst
= T2_OPCODE_SBC
;
19501 case T2_OPCODE_SBC
:
19502 new_inst
= T2_OPCODE_ADC
;
19506 /* We cannot do anything. */
19511 if (value
== (unsigned int)FAIL
)
19514 *instruction
&= T2_OPCODE_MASK
;
19515 *instruction
|= new_inst
<< T2_DATA_OP_SHIFT
;
19519 /* Read a 32-bit thumb instruction from buf. */
19520 static unsigned long
19521 get_thumb32_insn (char * buf
)
19523 unsigned long insn
;
19524 insn
= md_chars_to_number (buf
, THUMB_SIZE
) << 16;
19525 insn
|= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
19531 /* We usually want to set the low bit on the address of thumb function
19532 symbols. In particular .word foo - . should have the low bit set.
19533 Generic code tries to fold the difference of two symbols to
19534 a constant. Prevent this and force a relocation when the first symbols
19535 is a thumb function. */
19538 arm_optimize_expr (expressionS
*l
, operatorT op
, expressionS
*r
)
19540 if (op
== O_subtract
19541 && l
->X_op
== O_symbol
19542 && r
->X_op
== O_symbol
19543 && THUMB_IS_FUNC (l
->X_add_symbol
))
19545 l
->X_op
= O_subtract
;
19546 l
->X_op_symbol
= r
->X_add_symbol
;
19547 l
->X_add_number
-= r
->X_add_number
;
19551 /* Process as normal. */
19555 /* Encode Thumb2 unconditional branches and calls. The encoding
19556 for the 2 are identical for the immediate values. */
19559 encode_thumb2_b_bl_offset (char * buf
, offsetT value
)
19561 #define T2I1I2MASK ((1 << 13) | (1 << 11))
19564 addressT S
, I1
, I2
, lo
, hi
;
19566 S
= (value
>> 24) & 0x01;
19567 I1
= (value
>> 23) & 0x01;
19568 I2
= (value
>> 22) & 0x01;
19569 hi
= (value
>> 12) & 0x3ff;
19570 lo
= (value
>> 1) & 0x7ff;
19571 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
19572 newval2
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
19573 newval
|= (S
<< 10) | hi
;
19574 newval2
&= ~T2I1I2MASK
;
19575 newval2
|= (((I1
^ S
) << 13) | ((I2
^ S
) << 11) | lo
) ^ T2I1I2MASK
;
19576 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
19577 md_number_to_chars (buf
+ THUMB_SIZE
, newval2
, THUMB_SIZE
);
19581 md_apply_fix (fixS
* fixP
,
19585 offsetT value
= * valP
;
19587 unsigned int newimm
;
19588 unsigned long temp
;
19590 char * buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
19592 gas_assert (fixP
->fx_r_type
<= BFD_RELOC_UNUSED
);
19594 /* Note whether this will delete the relocation. */
19596 if (fixP
->fx_addsy
== 0 && !fixP
->fx_pcrel
)
19599 /* On a 64-bit host, silently truncate 'value' to 32 bits for
19600 consistency with the behaviour on 32-bit hosts. Remember value
19602 value
&= 0xffffffff;
19603 value
^= 0x80000000;
19604 value
-= 0x80000000;
19607 fixP
->fx_addnumber
= value
;
19609 /* Same treatment for fixP->fx_offset. */
19610 fixP
->fx_offset
&= 0xffffffff;
19611 fixP
->fx_offset
^= 0x80000000;
19612 fixP
->fx_offset
-= 0x80000000;
19614 switch (fixP
->fx_r_type
)
19616 case BFD_RELOC_NONE
:
19617 /* This will need to go in the object file. */
19621 case BFD_RELOC_ARM_IMMEDIATE
:
19622 /* We claim that this fixup has been processed here,
19623 even if in fact we generate an error because we do
19624 not have a reloc for it, so tc_gen_reloc will reject it. */
19628 && ! S_IS_DEFINED (fixP
->fx_addsy
))
19630 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19631 _("undefined symbol %s used as an immediate value"),
19632 S_GET_NAME (fixP
->fx_addsy
));
19637 && S_GET_SEGMENT (fixP
->fx_addsy
) != seg
)
19639 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19640 _("symbol %s is in a different section"),
19641 S_GET_NAME (fixP
->fx_addsy
));
19645 newimm
= encode_arm_immediate (value
);
19646 temp
= md_chars_to_number (buf
, INSN_SIZE
);
19648 /* If the instruction will fail, see if we can fix things up by
19649 changing the opcode. */
19650 if (newimm
== (unsigned int) FAIL
19651 && (newimm
= negate_data_op (&temp
, value
)) == (unsigned int) FAIL
)
19653 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19654 _("invalid constant (%lx) after fixup"),
19655 (unsigned long) value
);
19659 newimm
|= (temp
& 0xfffff000);
19660 md_number_to_chars (buf
, (valueT
) newimm
, INSN_SIZE
);
19663 case BFD_RELOC_ARM_ADRL_IMMEDIATE
:
19665 unsigned int highpart
= 0;
19666 unsigned int newinsn
= 0xe1a00000; /* nop. */
19669 && ! S_IS_DEFINED (fixP
->fx_addsy
))
19671 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19672 _("undefined symbol %s used as an immediate value"),
19673 S_GET_NAME (fixP
->fx_addsy
));
19678 && S_GET_SEGMENT (fixP
->fx_addsy
) != seg
)
19680 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19681 _("symbol %s is in a different section"),
19682 S_GET_NAME (fixP
->fx_addsy
));
19686 newimm
= encode_arm_immediate (value
);
19687 temp
= md_chars_to_number (buf
, INSN_SIZE
);
19689 /* If the instruction will fail, see if we can fix things up by
19690 changing the opcode. */
19691 if (newimm
== (unsigned int) FAIL
19692 && (newimm
= negate_data_op (& temp
, value
)) == (unsigned int) FAIL
)
19694 /* No ? OK - try using two ADD instructions to generate
19696 newimm
= validate_immediate_twopart (value
, & highpart
);
19698 /* Yes - then make sure that the second instruction is
19700 if (newimm
!= (unsigned int) FAIL
)
19702 /* Still No ? Try using a negated value. */
19703 else if ((newimm
= validate_immediate_twopart (- value
, & highpart
)) != (unsigned int) FAIL
)
19704 temp
= newinsn
= (temp
& OPCODE_MASK
) | OPCODE_SUB
<< DATA_OP_SHIFT
;
19705 /* Otherwise - give up. */
19708 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19709 _("unable to compute ADRL instructions for PC offset of 0x%lx"),
19714 /* Replace the first operand in the 2nd instruction (which
19715 is the PC) with the destination register. We have
19716 already added in the PC in the first instruction and we
19717 do not want to do it again. */
19718 newinsn
&= ~ 0xf0000;
19719 newinsn
|= ((newinsn
& 0x0f000) << 4);
19722 newimm
|= (temp
& 0xfffff000);
19723 md_number_to_chars (buf
, (valueT
) newimm
, INSN_SIZE
);
19725 highpart
|= (newinsn
& 0xfffff000);
19726 md_number_to_chars (buf
+ INSN_SIZE
, (valueT
) highpart
, INSN_SIZE
);
19730 case BFD_RELOC_ARM_OFFSET_IMM
:
19731 if (!fixP
->fx_done
&& seg
->use_rela_p
)
19734 case BFD_RELOC_ARM_LITERAL
:
19740 if (validate_offset_imm (value
, 0) == FAIL
)
19742 if (fixP
->fx_r_type
== BFD_RELOC_ARM_LITERAL
)
19743 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19744 _("invalid literal constant: pool needs to be closer"));
19746 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19747 _("bad immediate value for offset (%ld)"),
19752 newval
= md_chars_to_number (buf
, INSN_SIZE
);
19753 newval
&= 0xff7ff000;
19754 newval
|= value
| (sign
? INDEX_UP
: 0);
19755 md_number_to_chars (buf
, newval
, INSN_SIZE
);
19758 case BFD_RELOC_ARM_OFFSET_IMM8
:
19759 case BFD_RELOC_ARM_HWLITERAL
:
19765 if (validate_offset_imm (value
, 1) == FAIL
)
19767 if (fixP
->fx_r_type
== BFD_RELOC_ARM_HWLITERAL
)
19768 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19769 _("invalid literal constant: pool needs to be closer"));
19771 as_bad (_("bad immediate value for 8-bit offset (%ld)"),
19776 newval
= md_chars_to_number (buf
, INSN_SIZE
);
19777 newval
&= 0xff7ff0f0;
19778 newval
|= ((value
>> 4) << 8) | (value
& 0xf) | (sign
? INDEX_UP
: 0);
19779 md_number_to_chars (buf
, newval
, INSN_SIZE
);
19782 case BFD_RELOC_ARM_T32_OFFSET_U8
:
19783 if (value
< 0 || value
> 1020 || value
% 4 != 0)
19784 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19785 _("bad immediate value for offset (%ld)"), (long) value
);
19788 newval
= md_chars_to_number (buf
+2, THUMB_SIZE
);
19790 md_number_to_chars (buf
+2, newval
, THUMB_SIZE
);
19793 case BFD_RELOC_ARM_T32_OFFSET_IMM
:
19794 /* This is a complicated relocation used for all varieties of Thumb32
19795 load/store instruction with immediate offset:
19797 1110 100P u1WL NNNN XXXX YYYY iiii iiii - +/-(U) pre/post(P) 8-bit,
19798 *4, optional writeback(W)
19799 (doubleword load/store)
19801 1111 100S uTTL 1111 XXXX iiii iiii iiii - +/-(U) 12-bit PC-rel
19802 1111 100S 0TTL NNNN XXXX 1Pu1 iiii iiii - +/-(U) pre/post(P) 8-bit
19803 1111 100S 0TTL NNNN XXXX 1110 iiii iiii - positive 8-bit (T instruction)
19804 1111 100S 1TTL NNNN XXXX iiii iiii iiii - positive 12-bit
19805 1111 100S 0TTL NNNN XXXX 1100 iiii iiii - negative 8-bit
19807 Uppercase letters indicate bits that are already encoded at
19808 this point. Lowercase letters are our problem. For the
19809 second block of instructions, the secondary opcode nybble
19810 (bits 8..11) is present, and bit 23 is zero, even if this is
19811 a PC-relative operation. */
19812 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
19814 newval
|= md_chars_to_number (buf
+THUMB_SIZE
, THUMB_SIZE
);
19816 if ((newval
& 0xf0000000) == 0xe0000000)
19818 /* Doubleword load/store: 8-bit offset, scaled by 4. */
19820 newval
|= (1 << 23);
19823 if (value
% 4 != 0)
19825 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19826 _("offset not a multiple of 4"));
19832 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19833 _("offset out of range"));
19838 else if ((newval
& 0x000f0000) == 0x000f0000)
19840 /* PC-relative, 12-bit offset. */
19842 newval
|= (1 << 23);
19847 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19848 _("offset out of range"));
19853 else if ((newval
& 0x00000100) == 0x00000100)
19855 /* Writeback: 8-bit, +/- offset. */
19857 newval
|= (1 << 9);
19862 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19863 _("offset out of range"));
19868 else if ((newval
& 0x00000f00) == 0x00000e00)
19870 /* T-instruction: positive 8-bit offset. */
19871 if (value
< 0 || value
> 0xff)
19873 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19874 _("offset out of range"));
19882 /* Positive 12-bit or negative 8-bit offset. */
19886 newval
|= (1 << 23);
19896 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19897 _("offset out of range"));
19904 md_number_to_chars (buf
, (newval
>> 16) & 0xffff, THUMB_SIZE
);
19905 md_number_to_chars (buf
+ THUMB_SIZE
, newval
& 0xffff, THUMB_SIZE
);
19908 case BFD_RELOC_ARM_SHIFT_IMM
:
19909 newval
= md_chars_to_number (buf
, INSN_SIZE
);
19910 if (((unsigned long) value
) > 32
19912 && (((newval
& 0x60) == 0) || (newval
& 0x60) == 0x60)))
19914 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19915 _("shift expression is too large"));
19920 /* Shifts of zero must be done as lsl. */
19922 else if (value
== 32)
19924 newval
&= 0xfffff07f;
19925 newval
|= (value
& 0x1f) << 7;
19926 md_number_to_chars (buf
, newval
, INSN_SIZE
);
19929 case BFD_RELOC_ARM_T32_IMMEDIATE
:
19930 case BFD_RELOC_ARM_T32_ADD_IMM
:
19931 case BFD_RELOC_ARM_T32_IMM12
:
19932 case BFD_RELOC_ARM_T32_ADD_PC12
:
19933 /* We claim that this fixup has been processed here,
19934 even if in fact we generate an error because we do
19935 not have a reloc for it, so tc_gen_reloc will reject it. */
19939 && ! S_IS_DEFINED (fixP
->fx_addsy
))
19941 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19942 _("undefined symbol %s used as an immediate value"),
19943 S_GET_NAME (fixP
->fx_addsy
));
19947 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
19949 newval
|= md_chars_to_number (buf
+2, THUMB_SIZE
);
19952 if (fixP
->fx_r_type
== BFD_RELOC_ARM_T32_IMMEDIATE
19953 || fixP
->fx_r_type
== BFD_RELOC_ARM_T32_ADD_IMM
)
19955 newimm
= encode_thumb32_immediate (value
);
19956 if (newimm
== (unsigned int) FAIL
)
19957 newimm
= thumb32_negate_data_op (&newval
, value
);
19959 if (fixP
->fx_r_type
!= BFD_RELOC_ARM_T32_IMMEDIATE
19960 && newimm
== (unsigned int) FAIL
)
19962 /* Turn add/sum into addw/subw. */
19963 if (fixP
->fx_r_type
== BFD_RELOC_ARM_T32_ADD_IMM
)
19964 newval
= (newval
& 0xfeffffff) | 0x02000000;
19966 /* 12 bit immediate for addw/subw. */
19970 newval
^= 0x00a00000;
19973 newimm
= (unsigned int) FAIL
;
19978 if (newimm
== (unsigned int)FAIL
)
19980 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19981 _("invalid constant (%lx) after fixup"),
19982 (unsigned long) value
);
19986 newval
|= (newimm
& 0x800) << 15;
19987 newval
|= (newimm
& 0x700) << 4;
19988 newval
|= (newimm
& 0x0ff);
19990 md_number_to_chars (buf
, (valueT
) ((newval
>> 16) & 0xffff), THUMB_SIZE
);
19991 md_number_to_chars (buf
+2, (valueT
) (newval
& 0xffff), THUMB_SIZE
);
19994 case BFD_RELOC_ARM_SMC
:
19995 if (((unsigned long) value
) > 0xffff)
19996 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19997 _("invalid smc expression"));
19998 newval
= md_chars_to_number (buf
, INSN_SIZE
);
19999 newval
|= (value
& 0xf) | ((value
& 0xfff0) << 4);
20000 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20003 case BFD_RELOC_ARM_SWI
:
20004 if (fixP
->tc_fix_data
!= 0)
20006 if (((unsigned long) value
) > 0xff)
20007 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20008 _("invalid swi expression"));
20009 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20011 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20015 if (((unsigned long) value
) > 0x00ffffff)
20016 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20017 _("invalid swi expression"));
20018 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20020 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20024 case BFD_RELOC_ARM_MULTI
:
20025 if (((unsigned long) value
) > 0xffff)
20026 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20027 _("invalid expression in load/store multiple"));
20028 newval
= value
| md_chars_to_number (buf
, INSN_SIZE
);
20029 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20033 case BFD_RELOC_ARM_PCREL_CALL
:
20035 if (ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
)
20037 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20038 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20039 && THUMB_IS_FUNC (fixP
->fx_addsy
))
20040 /* Flip the bl to blx. This is a simple flip
20041 bit here because we generate PCREL_CALL for
20042 unconditional bls. */
20044 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20045 newval
= newval
| 0x10000000;
20046 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20052 goto arm_branch_common
;
20054 case BFD_RELOC_ARM_PCREL_JUMP
:
20055 if (ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
)
20057 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20058 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20059 && THUMB_IS_FUNC (fixP
->fx_addsy
))
20061 /* This would map to a bl<cond>, b<cond>,
20062 b<always> to a Thumb function. We
20063 need to force a relocation for this particular
20065 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20069 case BFD_RELOC_ARM_PLT32
:
20071 case BFD_RELOC_ARM_PCREL_BRANCH
:
20073 goto arm_branch_common
;
20075 case BFD_RELOC_ARM_PCREL_BLX
:
20078 if (ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
)
20080 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20081 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20082 && ARM_IS_FUNC (fixP
->fx_addsy
))
20084 /* Flip the blx to a bl and warn. */
20085 const char *name
= S_GET_NAME (fixP
->fx_addsy
);
20086 newval
= 0xeb000000;
20087 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
20088 _("blx to '%s' an ARM ISA state function changed to bl"),
20090 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20096 if (EF_ARM_EABI_VERSION (meabi_flags
) >= EF_ARM_EABI_VER4
)
20097 fixP
->fx_r_type
= BFD_RELOC_ARM_PCREL_CALL
;
20101 /* We are going to store value (shifted right by two) in the
20102 instruction, in a 24 bit, signed field. Bits 26 through 32 either
20103 all clear or all set and bit 0 must be clear. For B/BL bit 1 must
20104 also be be clear. */
20106 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20107 _("misaligned branch destination"));
20108 if ((value
& (offsetT
)0xfe000000) != (offsetT
)0
20109 && (value
& (offsetT
)0xfe000000) != (offsetT
)0xfe000000)
20110 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20111 _("branch out of range"));
20113 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20115 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20116 newval
|= (value
>> 2) & 0x00ffffff;
20117 /* Set the H bit on BLX instructions. */
20121 newval
|= 0x01000000;
20123 newval
&= ~0x01000000;
20125 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20129 case BFD_RELOC_THUMB_PCREL_BRANCH7
: /* CBZ */
20130 /* CBZ can only branch forward. */
20132 /* Attempts to use CBZ to branch to the next instruction
20133 (which, strictly speaking, are prohibited) will be turned into
20136 FIXME: It may be better to remove the instruction completely and
20137 perform relaxation. */
20140 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20141 newval
= 0xbf00; /* NOP encoding T1 */
20142 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20147 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20148 _("branch out of range"));
20150 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20152 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20153 newval
|= ((value
& 0x3e) << 2) | ((value
& 0x40) << 3);
20154 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20159 case BFD_RELOC_THUMB_PCREL_BRANCH9
: /* Conditional branch. */
20160 if ((value
& ~0xff) && ((value
& ~0xff) != ~0xff))
20161 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20162 _("branch out of range"));
20164 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20166 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20167 newval
|= (value
& 0x1ff) >> 1;
20168 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20172 case BFD_RELOC_THUMB_PCREL_BRANCH12
: /* Unconditional branch. */
20173 if ((value
& ~0x7ff) && ((value
& ~0x7ff) != ~0x7ff))
20174 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20175 _("branch out of range"));
20177 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20179 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20180 newval
|= (value
& 0xfff) >> 1;
20181 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20185 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
20187 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20188 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20189 && S_IS_DEFINED (fixP
->fx_addsy
)
20190 && ARM_IS_FUNC (fixP
->fx_addsy
)
20191 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
20193 /* Force a relocation for a branch 20 bits wide. */
20196 if ((value
& ~0x1fffff) && ((value
& ~0x1fffff) != ~0x1fffff))
20197 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20198 _("conditional branch out of range"));
20200 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20203 addressT S
, J1
, J2
, lo
, hi
;
20205 S
= (value
& 0x00100000) >> 20;
20206 J2
= (value
& 0x00080000) >> 19;
20207 J1
= (value
& 0x00040000) >> 18;
20208 hi
= (value
& 0x0003f000) >> 12;
20209 lo
= (value
& 0x00000ffe) >> 1;
20211 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20212 newval2
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
20213 newval
|= (S
<< 10) | hi
;
20214 newval2
|= (J1
<< 13) | (J2
<< 11) | lo
;
20215 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20216 md_number_to_chars (buf
+ THUMB_SIZE
, newval2
, THUMB_SIZE
);
20220 case BFD_RELOC_THUMB_PCREL_BLX
:
20222 /* If there is a blx from a thumb state function to
20223 another thumb function flip this to a bl and warn
20227 && S_IS_DEFINED (fixP
->fx_addsy
)
20228 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20229 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20230 && THUMB_IS_FUNC (fixP
->fx_addsy
))
20232 const char *name
= S_GET_NAME (fixP
->fx_addsy
);
20233 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
20234 _("blx to Thumb func '%s' from Thumb ISA state changed to bl"),
20236 newval
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
20237 newval
= newval
| 0x1000;
20238 md_number_to_chars (buf
+THUMB_SIZE
, newval
, THUMB_SIZE
);
20239 fixP
->fx_r_type
= BFD_RELOC_THUMB_PCREL_BRANCH23
;
20244 goto thumb_bl_common
;
20246 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
20248 /* A bl from Thumb state ISA to an internal ARM state function
20249 is converted to a blx. */
20251 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20252 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20253 && S_IS_DEFINED (fixP
->fx_addsy
)
20254 && ARM_IS_FUNC (fixP
->fx_addsy
)
20255 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
20257 newval
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
20258 newval
= newval
& ~0x1000;
20259 md_number_to_chars (buf
+THUMB_SIZE
, newval
, THUMB_SIZE
);
20260 fixP
->fx_r_type
= BFD_RELOC_THUMB_PCREL_BLX
;
20267 if (EF_ARM_EABI_VERSION (meabi_flags
) >= EF_ARM_EABI_VER4
&&
20268 fixP
->fx_r_type
== BFD_RELOC_THUMB_PCREL_BLX
)
20269 fixP
->fx_r_type
= BFD_RELOC_THUMB_PCREL_BRANCH23
;
20272 if (fixP
->fx_r_type
== BFD_RELOC_THUMB_PCREL_BLX
)
20273 /* For a BLX instruction, make sure that the relocation is rounded up
20274 to a word boundary. This follows the semantics of the instruction
20275 which specifies that bit 1 of the target address will come from bit
20276 1 of the base address. */
20277 value
= (value
+ 1) & ~ 1;
20280 if ((value
& ~0x3fffff) && ((value
& ~0x3fffff) != ~0x3fffff))
20282 if (!(ARM_CPU_HAS_FEATURE (cpu_variant
, arm_arch_t2
)))
20284 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20285 _("branch out of range"));
20287 else if ((value
& ~0x1ffffff)
20288 && ((value
& ~0x1ffffff) != ~0x1ffffff))
20290 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20291 _("Thumb2 branch out of range"));
20295 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20296 encode_thumb2_b_bl_offset (buf
, value
);
20300 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
20301 if ((value
& ~0x1ffffff) && ((value
& ~0x1ffffff) != ~0x1ffffff))
20302 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20303 _("branch out of range"));
20305 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20306 encode_thumb2_b_bl_offset (buf
, value
);
20311 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20312 md_number_to_chars (buf
, value
, 1);
20316 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20317 md_number_to_chars (buf
, value
, 2);
20321 case BFD_RELOC_ARM_TLS_GD32
:
20322 case BFD_RELOC_ARM_TLS_LE32
:
20323 case BFD_RELOC_ARM_TLS_IE32
:
20324 case BFD_RELOC_ARM_TLS_LDM32
:
20325 case BFD_RELOC_ARM_TLS_LDO32
:
20326 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
20329 case BFD_RELOC_ARM_GOT32
:
20330 case BFD_RELOC_ARM_GOTOFF
:
20331 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20332 md_number_to_chars (buf
, 0, 4);
20335 case BFD_RELOC_ARM_TARGET2
:
20336 /* TARGET2 is not partial-inplace, so we need to write the
20337 addend here for REL targets, because it won't be written out
20338 during reloc processing later. */
20339 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20340 md_number_to_chars (buf
, fixP
->fx_offset
, 4);
20344 case BFD_RELOC_RVA
:
20346 case BFD_RELOC_ARM_TARGET1
:
20347 case BFD_RELOC_ARM_ROSEGREL32
:
20348 case BFD_RELOC_ARM_SBREL32
:
20349 case BFD_RELOC_32_PCREL
:
20351 case BFD_RELOC_32_SECREL
:
20353 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20355 /* For WinCE we only do this for pcrel fixups. */
20356 if (fixP
->fx_done
|| fixP
->fx_pcrel
)
20358 md_number_to_chars (buf
, value
, 4);
20362 case BFD_RELOC_ARM_PREL31
:
20363 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20365 newval
= md_chars_to_number (buf
, 4) & 0x80000000;
20366 if ((value
^ (value
>> 1)) & 0x40000000)
20368 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20369 _("rel31 relocation overflow"));
20371 newval
|= value
& 0x7fffffff;
20372 md_number_to_chars (buf
, newval
, 4);
20377 case BFD_RELOC_ARM_CP_OFF_IMM
:
20378 case BFD_RELOC_ARM_T32_CP_OFF_IMM
:
20379 if (value
< -1023 || value
> 1023 || (value
& 3))
20380 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20381 _("co-processor offset out of range"));
20386 if (fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM
20387 || fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM_S2
)
20388 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20390 newval
= get_thumb32_insn (buf
);
20391 newval
&= 0xff7fff00;
20392 newval
|= (value
>> 2) | (sign
? INDEX_UP
: 0);
20393 if (fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM
20394 || fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM_S2
)
20395 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20397 put_thumb32_insn (buf
, newval
);
20400 case BFD_RELOC_ARM_CP_OFF_IMM_S2
:
20401 case BFD_RELOC_ARM_T32_CP_OFF_IMM_S2
:
20402 if (value
< -255 || value
> 255)
20403 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20404 _("co-processor offset out of range"));
20406 goto cp_off_common
;
20408 case BFD_RELOC_ARM_THUMB_OFFSET
:
20409 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20410 /* Exactly what ranges, and where the offset is inserted depends
20411 on the type of instruction, we can establish this from the
20413 switch (newval
>> 12)
20415 case 4: /* PC load. */
20416 /* Thumb PC loads are somewhat odd, bit 1 of the PC is
20417 forced to zero for these loads; md_pcrel_from has already
20418 compensated for this. */
20420 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20421 _("invalid offset, target not word aligned (0x%08lX)"),
20422 (((unsigned long) fixP
->fx_frag
->fr_address
20423 + (unsigned long) fixP
->fx_where
) & ~3)
20424 + (unsigned long) value
);
20426 if (value
& ~0x3fc)
20427 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20428 _("invalid offset, value too big (0x%08lX)"),
20431 newval
|= value
>> 2;
20434 case 9: /* SP load/store. */
20435 if (value
& ~0x3fc)
20436 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20437 _("invalid offset, value too big (0x%08lX)"),
20439 newval
|= value
>> 2;
20442 case 6: /* Word load/store. */
20444 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20445 _("invalid offset, value too big (0x%08lX)"),
20447 newval
|= value
<< 4; /* 6 - 2. */
20450 case 7: /* Byte load/store. */
20452 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20453 _("invalid offset, value too big (0x%08lX)"),
20455 newval
|= value
<< 6;
20458 case 8: /* Halfword load/store. */
20460 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20461 _("invalid offset, value too big (0x%08lX)"),
20463 newval
|= value
<< 5; /* 6 - 1. */
20467 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20468 "Unable to process relocation for thumb opcode: %lx",
20469 (unsigned long) newval
);
20472 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20475 case BFD_RELOC_ARM_THUMB_ADD
:
20476 /* This is a complicated relocation, since we use it for all of
20477 the following immediate relocations:
20481 9bit ADD/SUB SP word-aligned
20482 10bit ADD PC/SP word-aligned
20484 The type of instruction being processed is encoded in the
20491 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20493 int rd
= (newval
>> 4) & 0xf;
20494 int rs
= newval
& 0xf;
20495 int subtract
= !!(newval
& 0x8000);
20497 /* Check for HI regs, only very restricted cases allowed:
20498 Adjusting SP, and using PC or SP to get an address. */
20499 if ((rd
> 7 && (rd
!= REG_SP
|| rs
!= REG_SP
))
20500 || (rs
> 7 && rs
!= REG_SP
&& rs
!= REG_PC
))
20501 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20502 _("invalid Hi register with immediate"));
20504 /* If value is negative, choose the opposite instruction. */
20508 subtract
= !subtract
;
20510 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20511 _("immediate value out of range"));
20516 if (value
& ~0x1fc)
20517 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20518 _("invalid immediate for stack address calculation"));
20519 newval
= subtract
? T_OPCODE_SUB_ST
: T_OPCODE_ADD_ST
;
20520 newval
|= value
>> 2;
20522 else if (rs
== REG_PC
|| rs
== REG_SP
)
20524 if (subtract
|| value
& ~0x3fc)
20525 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20526 _("invalid immediate for address calculation (value = 0x%08lX)"),
20527 (unsigned long) value
);
20528 newval
= (rs
== REG_PC
? T_OPCODE_ADD_PC
: T_OPCODE_ADD_SP
);
20530 newval
|= value
>> 2;
20535 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20536 _("immediate value out of range"));
20537 newval
= subtract
? T_OPCODE_SUB_I8
: T_OPCODE_ADD_I8
;
20538 newval
|= (rd
<< 8) | value
;
20543 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20544 _("immediate value out of range"));
20545 newval
= subtract
? T_OPCODE_SUB_I3
: T_OPCODE_ADD_I3
;
20546 newval
|= rd
| (rs
<< 3) | (value
<< 6);
20549 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20552 case BFD_RELOC_ARM_THUMB_IMM
:
20553 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20554 if (value
< 0 || value
> 255)
20555 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20556 _("invalid immediate: %ld is out of range"),
20559 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20562 case BFD_RELOC_ARM_THUMB_SHIFT
:
20563 /* 5bit shift value (0..32). LSL cannot take 32. */
20564 newval
= md_chars_to_number (buf
, THUMB_SIZE
) & 0xf83f;
20565 temp
= newval
& 0xf800;
20566 if (value
< 0 || value
> 32 || (value
== 32 && temp
== T_OPCODE_LSL_I
))
20567 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20568 _("invalid shift value: %ld"), (long) value
);
20569 /* Shifts of zero must be encoded as LSL. */
20571 newval
= (newval
& 0x003f) | T_OPCODE_LSL_I
;
20572 /* Shifts of 32 are encoded as zero. */
20573 else if (value
== 32)
20575 newval
|= value
<< 6;
20576 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20579 case BFD_RELOC_VTABLE_INHERIT
:
20580 case BFD_RELOC_VTABLE_ENTRY
:
20584 case BFD_RELOC_ARM_MOVW
:
20585 case BFD_RELOC_ARM_MOVT
:
20586 case BFD_RELOC_ARM_THUMB_MOVW
:
20587 case BFD_RELOC_ARM_THUMB_MOVT
:
20588 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20590 /* REL format relocations are limited to a 16-bit addend. */
20591 if (!fixP
->fx_done
)
20593 if (value
< -0x8000 || value
> 0x7fff)
20594 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20595 _("offset out of range"));
20597 else if (fixP
->fx_r_type
== BFD_RELOC_ARM_MOVT
20598 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVT
)
20603 if (fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVW
20604 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVT
)
20606 newval
= get_thumb32_insn (buf
);
20607 newval
&= 0xfbf08f00;
20608 newval
|= (value
& 0xf000) << 4;
20609 newval
|= (value
& 0x0800) << 15;
20610 newval
|= (value
& 0x0700) << 4;
20611 newval
|= (value
& 0x00ff);
20612 put_thumb32_insn (buf
, newval
);
20616 newval
= md_chars_to_number (buf
, 4);
20617 newval
&= 0xfff0f000;
20618 newval
|= value
& 0x0fff;
20619 newval
|= (value
& 0xf000) << 4;
20620 md_number_to_chars (buf
, newval
, 4);
20625 case BFD_RELOC_ARM_ALU_PC_G0_NC
:
20626 case BFD_RELOC_ARM_ALU_PC_G0
:
20627 case BFD_RELOC_ARM_ALU_PC_G1_NC
:
20628 case BFD_RELOC_ARM_ALU_PC_G1
:
20629 case BFD_RELOC_ARM_ALU_PC_G2
:
20630 case BFD_RELOC_ARM_ALU_SB_G0_NC
:
20631 case BFD_RELOC_ARM_ALU_SB_G0
:
20632 case BFD_RELOC_ARM_ALU_SB_G1_NC
:
20633 case BFD_RELOC_ARM_ALU_SB_G1
:
20634 case BFD_RELOC_ARM_ALU_SB_G2
:
20635 gas_assert (!fixP
->fx_done
);
20636 if (!seg
->use_rela_p
)
20639 bfd_vma encoded_addend
;
20640 bfd_vma addend_abs
= abs (value
);
20642 /* Check that the absolute value of the addend can be
20643 expressed as an 8-bit constant plus a rotation. */
20644 encoded_addend
= encode_arm_immediate (addend_abs
);
20645 if (encoded_addend
== (unsigned int) FAIL
)
20646 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20647 _("the offset 0x%08lX is not representable"),
20648 (unsigned long) addend_abs
);
20650 /* Extract the instruction. */
20651 insn
= md_chars_to_number (buf
, INSN_SIZE
);
20653 /* If the addend is positive, use an ADD instruction.
20654 Otherwise use a SUB. Take care not to destroy the S bit. */
20655 insn
&= 0xff1fffff;
20661 /* Place the encoded addend into the first 12 bits of the
20663 insn
&= 0xfffff000;
20664 insn
|= encoded_addend
;
20666 /* Update the instruction. */
20667 md_number_to_chars (buf
, insn
, INSN_SIZE
);
20671 case BFD_RELOC_ARM_LDR_PC_G0
:
20672 case BFD_RELOC_ARM_LDR_PC_G1
:
20673 case BFD_RELOC_ARM_LDR_PC_G2
:
20674 case BFD_RELOC_ARM_LDR_SB_G0
:
20675 case BFD_RELOC_ARM_LDR_SB_G1
:
20676 case BFD_RELOC_ARM_LDR_SB_G2
:
20677 gas_assert (!fixP
->fx_done
);
20678 if (!seg
->use_rela_p
)
20681 bfd_vma addend_abs
= abs (value
);
20683 /* Check that the absolute value of the addend can be
20684 encoded in 12 bits. */
20685 if (addend_abs
>= 0x1000)
20686 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20687 _("bad offset 0x%08lX (only 12 bits available for the magnitude)"),
20688 (unsigned long) addend_abs
);
20690 /* Extract the instruction. */
20691 insn
= md_chars_to_number (buf
, INSN_SIZE
);
20693 /* If the addend is negative, clear bit 23 of the instruction.
20694 Otherwise set it. */
20696 insn
&= ~(1 << 23);
20700 /* Place the absolute value of the addend into the first 12 bits
20701 of the instruction. */
20702 insn
&= 0xfffff000;
20703 insn
|= addend_abs
;
20705 /* Update the instruction. */
20706 md_number_to_chars (buf
, insn
, INSN_SIZE
);
20710 case BFD_RELOC_ARM_LDRS_PC_G0
:
20711 case BFD_RELOC_ARM_LDRS_PC_G1
:
20712 case BFD_RELOC_ARM_LDRS_PC_G2
:
20713 case BFD_RELOC_ARM_LDRS_SB_G0
:
20714 case BFD_RELOC_ARM_LDRS_SB_G1
:
20715 case BFD_RELOC_ARM_LDRS_SB_G2
:
20716 gas_assert (!fixP
->fx_done
);
20717 if (!seg
->use_rela_p
)
20720 bfd_vma addend_abs
= abs (value
);
20722 /* Check that the absolute value of the addend can be
20723 encoded in 8 bits. */
20724 if (addend_abs
>= 0x100)
20725 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20726 _("bad offset 0x%08lX (only 8 bits available for the magnitude)"),
20727 (unsigned long) addend_abs
);
20729 /* Extract the instruction. */
20730 insn
= md_chars_to_number (buf
, INSN_SIZE
);
20732 /* If the addend is negative, clear bit 23 of the instruction.
20733 Otherwise set it. */
20735 insn
&= ~(1 << 23);
20739 /* Place the first four bits of the absolute value of the addend
20740 into the first 4 bits of the instruction, and the remaining
20741 four into bits 8 .. 11. */
20742 insn
&= 0xfffff0f0;
20743 insn
|= (addend_abs
& 0xf) | ((addend_abs
& 0xf0) << 4);
20745 /* Update the instruction. */
20746 md_number_to_chars (buf
, insn
, INSN_SIZE
);
20750 case BFD_RELOC_ARM_LDC_PC_G0
:
20751 case BFD_RELOC_ARM_LDC_PC_G1
:
20752 case BFD_RELOC_ARM_LDC_PC_G2
:
20753 case BFD_RELOC_ARM_LDC_SB_G0
:
20754 case BFD_RELOC_ARM_LDC_SB_G1
:
20755 case BFD_RELOC_ARM_LDC_SB_G2
:
20756 gas_assert (!fixP
->fx_done
);
20757 if (!seg
->use_rela_p
)
20760 bfd_vma addend_abs
= abs (value
);
20762 /* Check that the absolute value of the addend is a multiple of
20763 four and, when divided by four, fits in 8 bits. */
20764 if (addend_abs
& 0x3)
20765 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20766 _("bad offset 0x%08lX (must be word-aligned)"),
20767 (unsigned long) addend_abs
);
20769 if ((addend_abs
>> 2) > 0xff)
20770 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20771 _("bad offset 0x%08lX (must be an 8-bit number of words)"),
20772 (unsigned long) addend_abs
);
20774 /* Extract the instruction. */
20775 insn
= md_chars_to_number (buf
, INSN_SIZE
);
20777 /* If the addend is negative, clear bit 23 of the instruction.
20778 Otherwise set it. */
20780 insn
&= ~(1 << 23);
20784 /* Place the addend (divided by four) into the first eight
20785 bits of the instruction. */
20786 insn
&= 0xfffffff0;
20787 insn
|= addend_abs
>> 2;
20789 /* Update the instruction. */
20790 md_number_to_chars (buf
, insn
, INSN_SIZE
);
20794 case BFD_RELOC_ARM_V4BX
:
20795 /* This will need to go in the object file. */
20799 case BFD_RELOC_UNUSED
:
20801 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20802 _("bad relocation fixup type (%d)"), fixP
->fx_r_type
);
20806 /* Translate internal representation of relocation info to BFD target
20810 tc_gen_reloc (asection
*section
, fixS
*fixp
)
20813 bfd_reloc_code_real_type code
;
20815 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
20817 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
20818 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
20819 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
20821 if (fixp
->fx_pcrel
)
20823 if (section
->use_rela_p
)
20824 fixp
->fx_offset
-= md_pcrel_from_section (fixp
, section
);
20826 fixp
->fx_offset
= reloc
->address
;
20828 reloc
->addend
= fixp
->fx_offset
;
20830 switch (fixp
->fx_r_type
)
20833 if (fixp
->fx_pcrel
)
20835 code
= BFD_RELOC_8_PCREL
;
20840 if (fixp
->fx_pcrel
)
20842 code
= BFD_RELOC_16_PCREL
;
20847 if (fixp
->fx_pcrel
)
20849 code
= BFD_RELOC_32_PCREL
;
20853 case BFD_RELOC_ARM_MOVW
:
20854 if (fixp
->fx_pcrel
)
20856 code
= BFD_RELOC_ARM_MOVW_PCREL
;
20860 case BFD_RELOC_ARM_MOVT
:
20861 if (fixp
->fx_pcrel
)
20863 code
= BFD_RELOC_ARM_MOVT_PCREL
;
20867 case BFD_RELOC_ARM_THUMB_MOVW
:
20868 if (fixp
->fx_pcrel
)
20870 code
= BFD_RELOC_ARM_THUMB_MOVW_PCREL
;
20874 case BFD_RELOC_ARM_THUMB_MOVT
:
20875 if (fixp
->fx_pcrel
)
20877 code
= BFD_RELOC_ARM_THUMB_MOVT_PCREL
;
20881 case BFD_RELOC_NONE
:
20882 case BFD_RELOC_ARM_PCREL_BRANCH
:
20883 case BFD_RELOC_ARM_PCREL_BLX
:
20884 case BFD_RELOC_RVA
:
20885 case BFD_RELOC_THUMB_PCREL_BRANCH7
:
20886 case BFD_RELOC_THUMB_PCREL_BRANCH9
:
20887 case BFD_RELOC_THUMB_PCREL_BRANCH12
:
20888 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
20889 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
20890 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
20891 case BFD_RELOC_VTABLE_ENTRY
:
20892 case BFD_RELOC_VTABLE_INHERIT
:
20894 case BFD_RELOC_32_SECREL
:
20896 code
= fixp
->fx_r_type
;
20899 case BFD_RELOC_THUMB_PCREL_BLX
:
20901 if (EF_ARM_EABI_VERSION (meabi_flags
) >= EF_ARM_EABI_VER4
)
20902 code
= BFD_RELOC_THUMB_PCREL_BRANCH23
;
20905 code
= BFD_RELOC_THUMB_PCREL_BLX
;
20908 case BFD_RELOC_ARM_LITERAL
:
20909 case BFD_RELOC_ARM_HWLITERAL
:
20910 /* If this is called then the a literal has
20911 been referenced across a section boundary. */
20912 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
20913 _("literal referenced across section boundary"));
20917 case BFD_RELOC_ARM_GOT32
:
20918 case BFD_RELOC_ARM_GOTOFF
:
20919 case BFD_RELOC_ARM_PLT32
:
20920 case BFD_RELOC_ARM_TARGET1
:
20921 case BFD_RELOC_ARM_ROSEGREL32
:
20922 case BFD_RELOC_ARM_SBREL32
:
20923 case BFD_RELOC_ARM_PREL31
:
20924 case BFD_RELOC_ARM_TARGET2
:
20925 case BFD_RELOC_ARM_TLS_LE32
:
20926 case BFD_RELOC_ARM_TLS_LDO32
:
20927 case BFD_RELOC_ARM_PCREL_CALL
:
20928 case BFD_RELOC_ARM_PCREL_JUMP
:
20929 case BFD_RELOC_ARM_ALU_PC_G0_NC
:
20930 case BFD_RELOC_ARM_ALU_PC_G0
:
20931 case BFD_RELOC_ARM_ALU_PC_G1_NC
:
20932 case BFD_RELOC_ARM_ALU_PC_G1
:
20933 case BFD_RELOC_ARM_ALU_PC_G2
:
20934 case BFD_RELOC_ARM_LDR_PC_G0
:
20935 case BFD_RELOC_ARM_LDR_PC_G1
:
20936 case BFD_RELOC_ARM_LDR_PC_G2
:
20937 case BFD_RELOC_ARM_LDRS_PC_G0
:
20938 case BFD_RELOC_ARM_LDRS_PC_G1
:
20939 case BFD_RELOC_ARM_LDRS_PC_G2
:
20940 case BFD_RELOC_ARM_LDC_PC_G0
:
20941 case BFD_RELOC_ARM_LDC_PC_G1
:
20942 case BFD_RELOC_ARM_LDC_PC_G2
:
20943 case BFD_RELOC_ARM_ALU_SB_G0_NC
:
20944 case BFD_RELOC_ARM_ALU_SB_G0
:
20945 case BFD_RELOC_ARM_ALU_SB_G1_NC
:
20946 case BFD_RELOC_ARM_ALU_SB_G1
:
20947 case BFD_RELOC_ARM_ALU_SB_G2
:
20948 case BFD_RELOC_ARM_LDR_SB_G0
:
20949 case BFD_RELOC_ARM_LDR_SB_G1
:
20950 case BFD_RELOC_ARM_LDR_SB_G2
:
20951 case BFD_RELOC_ARM_LDRS_SB_G0
:
20952 case BFD_RELOC_ARM_LDRS_SB_G1
:
20953 case BFD_RELOC_ARM_LDRS_SB_G2
:
20954 case BFD_RELOC_ARM_LDC_SB_G0
:
20955 case BFD_RELOC_ARM_LDC_SB_G1
:
20956 case BFD_RELOC_ARM_LDC_SB_G2
:
20957 case BFD_RELOC_ARM_V4BX
:
20958 code
= fixp
->fx_r_type
;
20961 case BFD_RELOC_ARM_TLS_GD32
:
20962 case BFD_RELOC_ARM_TLS_IE32
:
20963 case BFD_RELOC_ARM_TLS_LDM32
:
20964 /* BFD will include the symbol's address in the addend.
20965 But we don't want that, so subtract it out again here. */
20966 if (!S_IS_COMMON (fixp
->fx_addsy
))
20967 reloc
->addend
-= (*reloc
->sym_ptr_ptr
)->value
;
20968 code
= fixp
->fx_r_type
;
20972 case BFD_RELOC_ARM_IMMEDIATE
:
20973 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
20974 _("internal relocation (type: IMMEDIATE) not fixed up"));
20977 case BFD_RELOC_ARM_ADRL_IMMEDIATE
:
20978 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
20979 _("ADRL used for a symbol not defined in the same file"));
20982 case BFD_RELOC_ARM_OFFSET_IMM
:
20983 if (section
->use_rela_p
)
20985 code
= fixp
->fx_r_type
;
20989 if (fixp
->fx_addsy
!= NULL
20990 && !S_IS_DEFINED (fixp
->fx_addsy
)
20991 && S_IS_LOCAL (fixp
->fx_addsy
))
20993 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
20994 _("undefined local label `%s'"),
20995 S_GET_NAME (fixp
->fx_addsy
));
20999 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
21000 _("internal_relocation (type: OFFSET_IMM) not fixed up"));
21007 switch (fixp
->fx_r_type
)
21009 case BFD_RELOC_NONE
: type
= "NONE"; break;
21010 case BFD_RELOC_ARM_OFFSET_IMM8
: type
= "OFFSET_IMM8"; break;
21011 case BFD_RELOC_ARM_SHIFT_IMM
: type
= "SHIFT_IMM"; break;
21012 case BFD_RELOC_ARM_SMC
: type
= "SMC"; break;
21013 case BFD_RELOC_ARM_SWI
: type
= "SWI"; break;
21014 case BFD_RELOC_ARM_MULTI
: type
= "MULTI"; break;
21015 case BFD_RELOC_ARM_CP_OFF_IMM
: type
= "CP_OFF_IMM"; break;
21016 case BFD_RELOC_ARM_T32_CP_OFF_IMM
: type
= "T32_CP_OFF_IMM"; break;
21017 case BFD_RELOC_ARM_THUMB_ADD
: type
= "THUMB_ADD"; break;
21018 case BFD_RELOC_ARM_THUMB_SHIFT
: type
= "THUMB_SHIFT"; break;
21019 case BFD_RELOC_ARM_THUMB_IMM
: type
= "THUMB_IMM"; break;
21020 case BFD_RELOC_ARM_THUMB_OFFSET
: type
= "THUMB_OFFSET"; break;
21021 default: type
= _("<unknown>"); break;
21023 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
21024 _("cannot represent %s relocation in this object file format"),
21031 if ((code
== BFD_RELOC_32_PCREL
|| code
== BFD_RELOC_32
)
21033 && fixp
->fx_addsy
== GOT_symbol
)
21035 code
= BFD_RELOC_ARM_GOTPC
;
21036 reloc
->addend
= fixp
->fx_offset
= reloc
->address
;
21040 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
21042 if (reloc
->howto
== NULL
)
21044 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
21045 _("cannot represent %s relocation in this object file format"),
21046 bfd_get_reloc_code_name (code
));
21050 /* HACK: Since arm ELF uses Rel instead of Rela, encode the
21051 vtable entry to be used in the relocation's section offset. */
21052 if (fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
21053 reloc
->address
= fixp
->fx_offset
;
21058 /* This fix_new is called by cons via TC_CONS_FIX_NEW. */
21061 cons_fix_new_arm (fragS
* frag
,
21066 bfd_reloc_code_real_type type
;
21070 FIXME: @@ Should look at CPU word size. */
21074 type
= BFD_RELOC_8
;
21077 type
= BFD_RELOC_16
;
21081 type
= BFD_RELOC_32
;
21084 type
= BFD_RELOC_64
;
21089 if (exp
->X_op
== O_secrel
)
21091 exp
->X_op
= O_symbol
;
21092 type
= BFD_RELOC_32_SECREL
;
21096 fix_new_exp (frag
, where
, (int) size
, exp
, pcrel
, type
);
21099 #if defined (OBJ_COFF)
21101 arm_validate_fix (fixS
* fixP
)
21103 /* If the destination of the branch is a defined symbol which does not have
21104 the THUMB_FUNC attribute, then we must be calling a function which has
21105 the (interfacearm) attribute. We look for the Thumb entry point to that
21106 function and change the branch to refer to that function instead. */
21107 if (fixP
->fx_r_type
== BFD_RELOC_THUMB_PCREL_BRANCH23
21108 && fixP
->fx_addsy
!= NULL
21109 && S_IS_DEFINED (fixP
->fx_addsy
)
21110 && ! THUMB_IS_FUNC (fixP
->fx_addsy
))
21112 fixP
->fx_addsy
= find_real_start (fixP
->fx_addsy
);
21119 arm_force_relocation (struct fix
* fixp
)
21121 #if defined (OBJ_COFF) && defined (TE_PE)
21122 if (fixp
->fx_r_type
== BFD_RELOC_RVA
)
21126 /* In case we have a call or a branch to a function in ARM ISA mode from
21127 a thumb function or vice-versa force the relocation. These relocations
21128 are cleared off for some cores that might have blx and simple transformations
21132 switch (fixp
->fx_r_type
)
21134 case BFD_RELOC_ARM_PCREL_JUMP
:
21135 case BFD_RELOC_ARM_PCREL_CALL
:
21136 case BFD_RELOC_THUMB_PCREL_BLX
:
21137 if (THUMB_IS_FUNC (fixp
->fx_addsy
))
21141 case BFD_RELOC_ARM_PCREL_BLX
:
21142 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
21143 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
21144 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
21145 if (ARM_IS_FUNC (fixp
->fx_addsy
))
21154 /* Resolve these relocations even if the symbol is extern or weak. */
21155 if (fixp
->fx_r_type
== BFD_RELOC_ARM_IMMEDIATE
21156 || fixp
->fx_r_type
== BFD_RELOC_ARM_OFFSET_IMM
21157 || fixp
->fx_r_type
== BFD_RELOC_ARM_ADRL_IMMEDIATE
21158 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_ADD_IMM
21159 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_IMMEDIATE
21160 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_IMM12
21161 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_ADD_PC12
)
21164 /* Always leave these relocations for the linker. */
21165 if ((fixp
->fx_r_type
>= BFD_RELOC_ARM_ALU_PC_G0_NC
21166 && fixp
->fx_r_type
<= BFD_RELOC_ARM_LDC_SB_G2
)
21167 || fixp
->fx_r_type
== BFD_RELOC_ARM_LDR_PC_G0
)
21170 /* Always generate relocations against function symbols. */
21171 if (fixp
->fx_r_type
== BFD_RELOC_32
21173 && (symbol_get_bfdsym (fixp
->fx_addsy
)->flags
& BSF_FUNCTION
))
21176 return generic_force_reloc (fixp
);
21179 #if defined (OBJ_ELF) || defined (OBJ_COFF)
21180 /* Relocations against function names must be left unadjusted,
21181 so that the linker can use this information to generate interworking
21182 stubs. The MIPS version of this function
21183 also prevents relocations that are mips-16 specific, but I do not
21184 know why it does this.
21187 There is one other problem that ought to be addressed here, but
21188 which currently is not: Taking the address of a label (rather
21189 than a function) and then later jumping to that address. Such
21190 addresses also ought to have their bottom bit set (assuming that
21191 they reside in Thumb code), but at the moment they will not. */
21194 arm_fix_adjustable (fixS
* fixP
)
21196 if (fixP
->fx_addsy
== NULL
)
21199 /* Preserve relocations against symbols with function type. */
21200 if (symbol_get_bfdsym (fixP
->fx_addsy
)->flags
& BSF_FUNCTION
)
21203 if (THUMB_IS_FUNC (fixP
->fx_addsy
)
21204 && fixP
->fx_subsy
== NULL
)
21207 /* We need the symbol name for the VTABLE entries. */
21208 if ( fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
21209 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
21212 /* Don't allow symbols to be discarded on GOT related relocs. */
21213 if (fixP
->fx_r_type
== BFD_RELOC_ARM_PLT32
21214 || fixP
->fx_r_type
== BFD_RELOC_ARM_GOT32
21215 || fixP
->fx_r_type
== BFD_RELOC_ARM_GOTOFF
21216 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_GD32
21217 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_LE32
21218 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_IE32
21219 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_LDM32
21220 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_LDO32
21221 || fixP
->fx_r_type
== BFD_RELOC_ARM_TARGET2
)
21224 /* Similarly for group relocations. */
21225 if ((fixP
->fx_r_type
>= BFD_RELOC_ARM_ALU_PC_G0_NC
21226 && fixP
->fx_r_type
<= BFD_RELOC_ARM_LDC_SB_G2
)
21227 || fixP
->fx_r_type
== BFD_RELOC_ARM_LDR_PC_G0
)
21230 /* MOVW/MOVT REL relocations have limited offsets, so keep the symbols. */
21231 if (fixP
->fx_r_type
== BFD_RELOC_ARM_MOVW
21232 || fixP
->fx_r_type
== BFD_RELOC_ARM_MOVT
21233 || fixP
->fx_r_type
== BFD_RELOC_ARM_MOVW_PCREL
21234 || fixP
->fx_r_type
== BFD_RELOC_ARM_MOVT_PCREL
21235 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVW
21236 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVT
21237 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVW_PCREL
21238 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVT_PCREL
)
21243 #endif /* defined (OBJ_ELF) || defined (OBJ_COFF) */
21248 elf32_arm_target_format (void)
21251 return (target_big_endian
21252 ? "elf32-bigarm-symbian"
21253 : "elf32-littlearm-symbian");
21254 #elif defined (TE_VXWORKS)
21255 return (target_big_endian
21256 ? "elf32-bigarm-vxworks"
21257 : "elf32-littlearm-vxworks");
21259 if (target_big_endian
)
21260 return "elf32-bigarm";
21262 return "elf32-littlearm";
21267 armelf_frob_symbol (symbolS
* symp
,
21270 elf_frob_symbol (symp
, puntp
);
21274 /* MD interface: Finalization. */
21279 literal_pool
* pool
;
21281 /* Ensure that all the IT blocks are properly closed. */
21282 check_it_blocks_finished ();
21284 for (pool
= list_of_pools
; pool
; pool
= pool
->next
)
21286 /* Put it at the end of the relevant section. */
21287 subseg_set (pool
->section
, pool
->sub_section
);
21289 arm_elf_change_section ();
21296 /* Remove any excess mapping symbols generated for alignment frags in
21297 SEC. We may have created a mapping symbol before a zero byte
21298 alignment; remove it if there's a mapping symbol after the
21301 check_mapping_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
21302 void *dummy ATTRIBUTE_UNUSED
)
21304 segment_info_type
*seginfo
= seg_info (sec
);
21307 if (seginfo
== NULL
|| seginfo
->frchainP
== NULL
)
21310 for (fragp
= seginfo
->frchainP
->frch_root
;
21312 fragp
= fragp
->fr_next
)
21314 symbolS
*sym
= fragp
->tc_frag_data
.last_map
;
21315 fragS
*next
= fragp
->fr_next
;
21317 /* Variable-sized frags have been converted to fixed size by
21318 this point. But if this was variable-sized to start with,
21319 there will be a fixed-size frag after it. So don't handle
21321 if (sym
== NULL
|| next
== NULL
)
21324 if (S_GET_VALUE (sym
) < next
->fr_address
)
21325 /* Not at the end of this frag. */
21327 know (S_GET_VALUE (sym
) == next
->fr_address
);
21331 if (next
->tc_frag_data
.first_map
!= NULL
)
21333 /* Next frag starts with a mapping symbol. Discard this
21335 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
21339 if (next
->fr_next
== NULL
)
21341 /* This mapping symbol is at the end of the section. Discard
21343 know (next
->fr_fix
== 0 && next
->fr_var
== 0);
21344 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
21348 /* As long as we have empty frags without any mapping symbols,
21350 /* If the next frag is non-empty and does not start with a
21351 mapping symbol, then this mapping symbol is required. */
21352 if (next
->fr_address
!= next
->fr_next
->fr_address
)
21355 next
= next
->fr_next
;
21357 while (next
!= NULL
);
21362 /* Adjust the symbol table. This marks Thumb symbols as distinct from
21366 arm_adjust_symtab (void)
21371 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
21373 if (ARM_IS_THUMB (sym
))
21375 if (THUMB_IS_FUNC (sym
))
21377 /* Mark the symbol as a Thumb function. */
21378 if ( S_GET_STORAGE_CLASS (sym
) == C_STAT
21379 || S_GET_STORAGE_CLASS (sym
) == C_LABEL
) /* This can happen! */
21380 S_SET_STORAGE_CLASS (sym
, C_THUMBSTATFUNC
);
21382 else if (S_GET_STORAGE_CLASS (sym
) == C_EXT
)
21383 S_SET_STORAGE_CLASS (sym
, C_THUMBEXTFUNC
);
21385 as_bad (_("%s: unexpected function type: %d"),
21386 S_GET_NAME (sym
), S_GET_STORAGE_CLASS (sym
));
21388 else switch (S_GET_STORAGE_CLASS (sym
))
21391 S_SET_STORAGE_CLASS (sym
, C_THUMBEXT
);
21394 S_SET_STORAGE_CLASS (sym
, C_THUMBSTAT
);
21397 S_SET_STORAGE_CLASS (sym
, C_THUMBLABEL
);
21405 if (ARM_IS_INTERWORK (sym
))
21406 coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_flags
= 0xFF;
21413 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
21415 if (ARM_IS_THUMB (sym
))
21417 elf_symbol_type
* elf_sym
;
21419 elf_sym
= elf_symbol (symbol_get_bfdsym (sym
));
21420 bind
= ELF_ST_BIND (elf_sym
->internal_elf_sym
.st_info
);
21422 if (! bfd_is_arm_special_symbol_name (elf_sym
->symbol
.name
,
21423 BFD_ARM_SPECIAL_SYM_TYPE_ANY
))
21425 /* If it's a .thumb_func, declare it as so,
21426 otherwise tag label as .code 16. */
21427 if (THUMB_IS_FUNC (sym
))
21428 elf_sym
->internal_elf_sym
.st_info
=
21429 ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
21430 else if (EF_ARM_EABI_VERSION (meabi_flags
) < EF_ARM_EABI_VER4
)
21431 elf_sym
->internal_elf_sym
.st_info
=
21432 ELF_ST_INFO (bind
, STT_ARM_16BIT
);
21437 /* Remove any overlapping mapping symbols generated by alignment frags. */
21438 bfd_map_over_sections (stdoutput
, check_mapping_symbols
, (char *) 0);
21442 /* MD interface: Initialization. */
21445 set_constant_flonums (void)
21449 for (i
= 0; i
< NUM_FLOAT_VALS
; i
++)
21450 if (atof_ieee ((char *) fp_const
[i
], 'x', fp_values
[i
]) == NULL
)
21454 /* Auto-select Thumb mode if it's the only available instruction set for the
21455 given architecture. */
21458 autoselect_thumb_from_cpu_variant (void)
21460 if (!ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v1
))
21461 opcode_select (16);
21470 if ( (arm_ops_hsh
= hash_new ()) == NULL
21471 || (arm_cond_hsh
= hash_new ()) == NULL
21472 || (arm_shift_hsh
= hash_new ()) == NULL
21473 || (arm_psr_hsh
= hash_new ()) == NULL
21474 || (arm_v7m_psr_hsh
= hash_new ()) == NULL
21475 || (arm_reg_hsh
= hash_new ()) == NULL
21476 || (arm_reloc_hsh
= hash_new ()) == NULL
21477 || (arm_barrier_opt_hsh
= hash_new ()) == NULL
)
21478 as_fatal (_("virtual memory exhausted"));
21480 for (i
= 0; i
< sizeof (insns
) / sizeof (struct asm_opcode
); i
++)
21481 hash_insert (arm_ops_hsh
, insns
[i
].template_name
, (void *) (insns
+ i
));
21482 for (i
= 0; i
< sizeof (conds
) / sizeof (struct asm_cond
); i
++)
21483 hash_insert (arm_cond_hsh
, conds
[i
].template_name
, (void *) (conds
+ i
));
21484 for (i
= 0; i
< sizeof (shift_names
) / sizeof (struct asm_shift_name
); i
++)
21485 hash_insert (arm_shift_hsh
, shift_names
[i
].name
, (void *) (shift_names
+ i
));
21486 for (i
= 0; i
< sizeof (psrs
) / sizeof (struct asm_psr
); i
++)
21487 hash_insert (arm_psr_hsh
, psrs
[i
].template_name
, (void *) (psrs
+ i
));
21488 for (i
= 0; i
< sizeof (v7m_psrs
) / sizeof (struct asm_psr
); i
++)
21489 hash_insert (arm_v7m_psr_hsh
, v7m_psrs
[i
].template_name
,
21490 (void *) (v7m_psrs
+ i
));
21491 for (i
= 0; i
< sizeof (reg_names
) / sizeof (struct reg_entry
); i
++)
21492 hash_insert (arm_reg_hsh
, reg_names
[i
].name
, (void *) (reg_names
+ i
));
21494 i
< sizeof (barrier_opt_names
) / sizeof (struct asm_barrier_opt
);
21496 hash_insert (arm_barrier_opt_hsh
, barrier_opt_names
[i
].template_name
,
21497 (void *) (barrier_opt_names
+ i
));
21499 for (i
= 0; i
< sizeof (reloc_names
) / sizeof (struct reloc_entry
); i
++)
21500 hash_insert (arm_reloc_hsh
, reloc_names
[i
].name
, (void *) (reloc_names
+ i
));
21503 set_constant_flonums ();
21505 /* Set the cpu variant based on the command-line options. We prefer
21506 -mcpu= over -march= if both are set (as for GCC); and we prefer
21507 -mfpu= over any other way of setting the floating point unit.
21508 Use of legacy options with new options are faulted. */
21511 if (mcpu_cpu_opt
|| march_cpu_opt
)
21512 as_bad (_("use of old and new-style options to set CPU type"));
21514 mcpu_cpu_opt
= legacy_cpu
;
21516 else if (!mcpu_cpu_opt
)
21517 mcpu_cpu_opt
= march_cpu_opt
;
21522 as_bad (_("use of old and new-style options to set FPU type"));
21524 mfpu_opt
= legacy_fpu
;
21526 else if (!mfpu_opt
)
21528 #if !(defined (EABI_DEFAULT) || defined (TE_LINUX) \
21529 || defined (TE_NetBSD) || defined (TE_VXWORKS))
21530 /* Some environments specify a default FPU. If they don't, infer it
21531 from the processor. */
21533 mfpu_opt
= mcpu_fpu_opt
;
21535 mfpu_opt
= march_fpu_opt
;
21537 mfpu_opt
= &fpu_default
;
21543 if (mcpu_cpu_opt
!= NULL
)
21544 mfpu_opt
= &fpu_default
;
21545 else if (mcpu_fpu_opt
!= NULL
&& ARM_CPU_HAS_FEATURE (*mcpu_fpu_opt
, arm_ext_v5
))
21546 mfpu_opt
= &fpu_arch_vfp_v2
;
21548 mfpu_opt
= &fpu_arch_fpa
;
21554 mcpu_cpu_opt
= &cpu_default
;
21555 selected_cpu
= cpu_default
;
21559 selected_cpu
= *mcpu_cpu_opt
;
21561 mcpu_cpu_opt
= &arm_arch_any
;
21564 ARM_MERGE_FEATURE_SETS (cpu_variant
, *mcpu_cpu_opt
, *mfpu_opt
);
21566 autoselect_thumb_from_cpu_variant ();
21568 arm_arch_used
= thumb_arch_used
= arm_arch_none
;
21570 #if defined OBJ_COFF || defined OBJ_ELF
21572 unsigned int flags
= 0;
21574 #if defined OBJ_ELF
21575 flags
= meabi_flags
;
21577 switch (meabi_flags
)
21579 case EF_ARM_EABI_UNKNOWN
:
21581 /* Set the flags in the private structure. */
21582 if (uses_apcs_26
) flags
|= F_APCS26
;
21583 if (support_interwork
) flags
|= F_INTERWORK
;
21584 if (uses_apcs_float
) flags
|= F_APCS_FLOAT
;
21585 if (pic_code
) flags
|= F_PIC
;
21586 if (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_any_hard
))
21587 flags
|= F_SOFT_FLOAT
;
21589 switch (mfloat_abi_opt
)
21591 case ARM_FLOAT_ABI_SOFT
:
21592 case ARM_FLOAT_ABI_SOFTFP
:
21593 flags
|= F_SOFT_FLOAT
;
21596 case ARM_FLOAT_ABI_HARD
:
21597 if (flags
& F_SOFT_FLOAT
)
21598 as_bad (_("hard-float conflicts with specified fpu"));
21602 /* Using pure-endian doubles (even if soft-float). */
21603 if (ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_endian_pure
))
21604 flags
|= F_VFP_FLOAT
;
21606 #if defined OBJ_ELF
21607 if (ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_arch_maverick
))
21608 flags
|= EF_ARM_MAVERICK_FLOAT
;
21611 case EF_ARM_EABI_VER4
:
21612 case EF_ARM_EABI_VER5
:
21613 /* No additional flags to set. */
21620 bfd_set_private_flags (stdoutput
, flags
);
21622 /* We have run out flags in the COFF header to encode the
21623 status of ATPCS support, so instead we create a dummy,
21624 empty, debug section called .arm.atpcs. */
21629 sec
= bfd_make_section (stdoutput
, ".arm.atpcs");
21633 bfd_set_section_flags
21634 (stdoutput
, sec
, SEC_READONLY
| SEC_DEBUGGING
/* | SEC_HAS_CONTENTS */);
21635 bfd_set_section_size (stdoutput
, sec
, 0);
21636 bfd_set_section_contents (stdoutput
, sec
, NULL
, 0, 0);
21642 /* Record the CPU type as well. */
21643 if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_cext_iwmmxt2
))
21644 mach
= bfd_mach_arm_iWMMXt2
;
21645 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_cext_iwmmxt
))
21646 mach
= bfd_mach_arm_iWMMXt
;
21647 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_cext_xscale
))
21648 mach
= bfd_mach_arm_XScale
;
21649 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_cext_maverick
))
21650 mach
= bfd_mach_arm_ep9312
;
21651 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v5e
))
21652 mach
= bfd_mach_arm_5TE
;
21653 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v5
))
21655 if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v4t
))
21656 mach
= bfd_mach_arm_5T
;
21658 mach
= bfd_mach_arm_5
;
21660 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v4
))
21662 if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v4t
))
21663 mach
= bfd_mach_arm_4T
;
21665 mach
= bfd_mach_arm_4
;
21667 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v3m
))
21668 mach
= bfd_mach_arm_3M
;
21669 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v3
))
21670 mach
= bfd_mach_arm_3
;
21671 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v2s
))
21672 mach
= bfd_mach_arm_2a
;
21673 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v2
))
21674 mach
= bfd_mach_arm_2
;
21676 mach
= bfd_mach_arm_unknown
;
21678 bfd_set_arch_mach (stdoutput
, TARGET_ARCH
, mach
);
21681 /* Command line processing. */
21684 Invocation line includes a switch not recognized by the base assembler.
21685 See if it's a processor-specific option.
21687 This routine is somewhat complicated by the need for backwards
21688 compatibility (since older releases of gcc can't be changed).
21689 The new options try to make the interface as compatible as
21692 New options (supported) are:
21694 -mcpu=<cpu name> Assemble for selected processor
21695 -march=<architecture name> Assemble for selected architecture
21696 -mfpu=<fpu architecture> Assemble for selected FPU.
21697 -EB/-mbig-endian Big-endian
21698 -EL/-mlittle-endian Little-endian
21699 -k Generate PIC code
21700 -mthumb Start in Thumb mode
21701 -mthumb-interwork Code supports ARM/Thumb interworking
21703 -m[no-]warn-deprecated Warn about deprecated features
21705 For now we will also provide support for:
21707 -mapcs-32 32-bit Program counter
21708 -mapcs-26 26-bit Program counter
21709 -macps-float Floats passed in FP registers
21710 -mapcs-reentrant Reentrant code
21712 (sometime these will probably be replaced with -mapcs=<list of options>
21713 and -matpcs=<list of options>)
21715 The remaining options are only supported for back-wards compatibility.
21716 Cpu variants, the arm part is optional:
21717 -m[arm]1 Currently not supported.
21718 -m[arm]2, -m[arm]250 Arm 2 and Arm 250 processor
21719 -m[arm]3 Arm 3 processor
21720 -m[arm]6[xx], Arm 6 processors
21721 -m[arm]7[xx][t][[d]m] Arm 7 processors
21722 -m[arm]8[10] Arm 8 processors
21723 -m[arm]9[20][tdmi] Arm 9 processors
21724 -mstrongarm[110[0]] StrongARM processors
21725 -mxscale XScale processors
21726 -m[arm]v[2345[t[e]]] Arm architectures
21727 -mall All (except the ARM1)
21729 -mfpa10, -mfpa11 FPA10 and 11 co-processor instructions
21730 -mfpe-old (No float load/store multiples)
21731 -mvfpxd VFP Single precision
21733 -mno-fpu Disable all floating point instructions
21735 The following CPU names are recognized:
21736 arm1, arm2, arm250, arm3, arm6, arm600, arm610, arm620,
21737 arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700,
21738 arm700i, arm710 arm710t, arm720, arm720t, arm740t, arm710c,
21739 arm7100, arm7500, arm7500fe, arm7tdmi, arm8, arm810, arm9,
21740 arm920, arm920t, arm940t, arm946, arm966, arm9tdmi, arm9e,
21741 arm10t arm10e, arm1020t, arm1020e, arm10200e,
21742 strongarm, strongarm110, strongarm1100, strongarm1110, xscale.
21746 const char * md_shortopts
= "m:k";
21748 #ifdef ARM_BI_ENDIAN
21749 #define OPTION_EB (OPTION_MD_BASE + 0)
21750 #define OPTION_EL (OPTION_MD_BASE + 1)
21752 #if TARGET_BYTES_BIG_ENDIAN
21753 #define OPTION_EB (OPTION_MD_BASE + 0)
21755 #define OPTION_EL (OPTION_MD_BASE + 1)
21758 #define OPTION_FIX_V4BX (OPTION_MD_BASE + 2)
21760 struct option md_longopts
[] =
21763 {"EB", no_argument
, NULL
, OPTION_EB
},
21766 {"EL", no_argument
, NULL
, OPTION_EL
},
21768 {"fix-v4bx", no_argument
, NULL
, OPTION_FIX_V4BX
},
21769 {NULL
, no_argument
, NULL
, 0}
21772 size_t md_longopts_size
= sizeof (md_longopts
);
21774 struct arm_option_table
21776 char *option
; /* Option name to match. */
21777 char *help
; /* Help information. */
21778 int *var
; /* Variable to change. */
21779 int value
; /* What to change it to. */
21780 char *deprecated
; /* If non-null, print this message. */
21783 struct arm_option_table arm_opts
[] =
21785 {"k", N_("generate PIC code"), &pic_code
, 1, NULL
},
21786 {"mthumb", N_("assemble Thumb code"), &thumb_mode
, 1, NULL
},
21787 {"mthumb-interwork", N_("support ARM/Thumb interworking"),
21788 &support_interwork
, 1, NULL
},
21789 {"mapcs-32", N_("code uses 32-bit program counter"), &uses_apcs_26
, 0, NULL
},
21790 {"mapcs-26", N_("code uses 26-bit program counter"), &uses_apcs_26
, 1, NULL
},
21791 {"mapcs-float", N_("floating point args are in fp regs"), &uses_apcs_float
,
21793 {"mapcs-reentrant", N_("re-entrant code"), &pic_code
, 1, NULL
},
21794 {"matpcs", N_("code is ATPCS conformant"), &atpcs
, 1, NULL
},
21795 {"mbig-endian", N_("assemble for big-endian"), &target_big_endian
, 1, NULL
},
21796 {"mlittle-endian", N_("assemble for little-endian"), &target_big_endian
, 0,
21799 /* These are recognized by the assembler, but have no affect on code. */
21800 {"mapcs-frame", N_("use frame pointer"), NULL
, 0, NULL
},
21801 {"mapcs-stack-check", N_("use stack size checking"), NULL
, 0, NULL
},
21803 {"mwarn-deprecated", NULL
, &warn_on_deprecated
, 1, NULL
},
21804 {"mno-warn-deprecated", N_("do not warn on use of deprecated feature"),
21805 &warn_on_deprecated
, 0, NULL
},
21806 {NULL
, NULL
, NULL
, 0, NULL
}
21809 struct arm_legacy_option_table
21811 char *option
; /* Option name to match. */
21812 const arm_feature_set
**var
; /* Variable to change. */
21813 const arm_feature_set value
; /* What to change it to. */
21814 char *deprecated
; /* If non-null, print this message. */
21817 const struct arm_legacy_option_table arm_legacy_opts
[] =
21819 /* DON'T add any new processors to this list -- we want the whole list
21820 to go away... Add them to the processors table instead. */
21821 {"marm1", &legacy_cpu
, ARM_ARCH_V1
, N_("use -mcpu=arm1")},
21822 {"m1", &legacy_cpu
, ARM_ARCH_V1
, N_("use -mcpu=arm1")},
21823 {"marm2", &legacy_cpu
, ARM_ARCH_V2
, N_("use -mcpu=arm2")},
21824 {"m2", &legacy_cpu
, ARM_ARCH_V2
, N_("use -mcpu=arm2")},
21825 {"marm250", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm250")},
21826 {"m250", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm250")},
21827 {"marm3", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm3")},
21828 {"m3", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm3")},
21829 {"marm6", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm6")},
21830 {"m6", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm6")},
21831 {"marm600", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm600")},
21832 {"m600", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm600")},
21833 {"marm610", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm610")},
21834 {"m610", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm610")},
21835 {"marm620", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm620")},
21836 {"m620", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm620")},
21837 {"marm7", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7")},
21838 {"m7", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7")},
21839 {"marm70", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm70")},
21840 {"m70", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm70")},
21841 {"marm700", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700")},
21842 {"m700", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700")},
21843 {"marm700i", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700i")},
21844 {"m700i", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700i")},
21845 {"marm710", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710")},
21846 {"m710", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710")},
21847 {"marm710c", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710c")},
21848 {"m710c", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710c")},
21849 {"marm720", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm720")},
21850 {"m720", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm720")},
21851 {"marm7d", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7d")},
21852 {"m7d", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7d")},
21853 {"marm7di", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7di")},
21854 {"m7di", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7di")},
21855 {"marm7m", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7m")},
21856 {"m7m", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7m")},
21857 {"marm7dm", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dm")},
21858 {"m7dm", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dm")},
21859 {"marm7dmi", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dmi")},
21860 {"m7dmi", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dmi")},
21861 {"marm7100", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7100")},
21862 {"m7100", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7100")},
21863 {"marm7500", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500")},
21864 {"m7500", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500")},
21865 {"marm7500fe", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500fe")},
21866 {"m7500fe", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500fe")},
21867 {"marm7t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
21868 {"m7t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
21869 {"marm7tdmi", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
21870 {"m7tdmi", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
21871 {"marm710t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm710t")},
21872 {"m710t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm710t")},
21873 {"marm720t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm720t")},
21874 {"m720t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm720t")},
21875 {"marm740t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm740t")},
21876 {"m740t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm740t")},
21877 {"marm8", &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm8")},
21878 {"m8", &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm8")},
21879 {"marm810", &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm810")},
21880 {"m810", &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm810")},
21881 {"marm9", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9")},
21882 {"m9", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9")},
21883 {"marm9tdmi", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9tdmi")},
21884 {"m9tdmi", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9tdmi")},
21885 {"marm920", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm920")},
21886 {"m920", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm920")},
21887 {"marm940", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm940")},
21888 {"m940", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm940")},
21889 {"mstrongarm", &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=strongarm")},
21890 {"mstrongarm110", &legacy_cpu
, ARM_ARCH_V4
,
21891 N_("use -mcpu=strongarm110")},
21892 {"mstrongarm1100", &legacy_cpu
, ARM_ARCH_V4
,
21893 N_("use -mcpu=strongarm1100")},
21894 {"mstrongarm1110", &legacy_cpu
, ARM_ARCH_V4
,
21895 N_("use -mcpu=strongarm1110")},
21896 {"mxscale", &legacy_cpu
, ARM_ARCH_XSCALE
, N_("use -mcpu=xscale")},
21897 {"miwmmxt", &legacy_cpu
, ARM_ARCH_IWMMXT
, N_("use -mcpu=iwmmxt")},
21898 {"mall", &legacy_cpu
, ARM_ANY
, N_("use -mcpu=all")},
21900 /* Architecture variants -- don't add any more to this list either. */
21901 {"mv2", &legacy_cpu
, ARM_ARCH_V2
, N_("use -march=armv2")},
21902 {"marmv2", &legacy_cpu
, ARM_ARCH_V2
, N_("use -march=armv2")},
21903 {"mv2a", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -march=armv2a")},
21904 {"marmv2a", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -march=armv2a")},
21905 {"mv3", &legacy_cpu
, ARM_ARCH_V3
, N_("use -march=armv3")},
21906 {"marmv3", &legacy_cpu
, ARM_ARCH_V3
, N_("use -march=armv3")},
21907 {"mv3m", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -march=armv3m")},
21908 {"marmv3m", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -march=armv3m")},
21909 {"mv4", &legacy_cpu
, ARM_ARCH_V4
, N_("use -march=armv4")},
21910 {"marmv4", &legacy_cpu
, ARM_ARCH_V4
, N_("use -march=armv4")},
21911 {"mv4t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -march=armv4t")},
21912 {"marmv4t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -march=armv4t")},
21913 {"mv5", &legacy_cpu
, ARM_ARCH_V5
, N_("use -march=armv5")},
21914 {"marmv5", &legacy_cpu
, ARM_ARCH_V5
, N_("use -march=armv5")},
21915 {"mv5t", &legacy_cpu
, ARM_ARCH_V5T
, N_("use -march=armv5t")},
21916 {"marmv5t", &legacy_cpu
, ARM_ARCH_V5T
, N_("use -march=armv5t")},
21917 {"mv5e", &legacy_cpu
, ARM_ARCH_V5TE
, N_("use -march=armv5te")},
21918 {"marmv5e", &legacy_cpu
, ARM_ARCH_V5TE
, N_("use -march=armv5te")},
21920 /* Floating point variants -- don't add any more to this list either. */
21921 {"mfpe-old", &legacy_fpu
, FPU_ARCH_FPE
, N_("use -mfpu=fpe")},
21922 {"mfpa10", &legacy_fpu
, FPU_ARCH_FPA
, N_("use -mfpu=fpa10")},
21923 {"mfpa11", &legacy_fpu
, FPU_ARCH_FPA
, N_("use -mfpu=fpa11")},
21924 {"mno-fpu", &legacy_fpu
, ARM_ARCH_NONE
,
21925 N_("use either -mfpu=softfpa or -mfpu=softvfp")},
21927 {NULL
, NULL
, ARM_ARCH_NONE
, NULL
}
21930 struct arm_cpu_option_table
21933 const arm_feature_set value
;
21934 /* For some CPUs we assume an FPU unless the user explicitly sets
21936 const arm_feature_set default_fpu
;
21937 /* The canonical name of the CPU, or NULL to use NAME converted to upper
21939 const char *canonical_name
;
21942 /* This list should, at a minimum, contain all the cpu names
21943 recognized by GCC. */
21944 static const struct arm_cpu_option_table arm_cpus
[] =
21946 {"all", ARM_ANY
, FPU_ARCH_FPA
, NULL
},
21947 {"arm1", ARM_ARCH_V1
, FPU_ARCH_FPA
, NULL
},
21948 {"arm2", ARM_ARCH_V2
, FPU_ARCH_FPA
, NULL
},
21949 {"arm250", ARM_ARCH_V2S
, FPU_ARCH_FPA
, NULL
},
21950 {"arm3", ARM_ARCH_V2S
, FPU_ARCH_FPA
, NULL
},
21951 {"arm6", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21952 {"arm60", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21953 {"arm600", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21954 {"arm610", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21955 {"arm620", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21956 {"arm7", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21957 {"arm7m", ARM_ARCH_V3M
, FPU_ARCH_FPA
, NULL
},
21958 {"arm7d", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21959 {"arm7dm", ARM_ARCH_V3M
, FPU_ARCH_FPA
, NULL
},
21960 {"arm7di", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21961 {"arm7dmi", ARM_ARCH_V3M
, FPU_ARCH_FPA
, NULL
},
21962 {"arm70", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21963 {"arm700", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21964 {"arm700i", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21965 {"arm710", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21966 {"arm710t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21967 {"arm720", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21968 {"arm720t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21969 {"arm740t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21970 {"arm710c", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21971 {"arm7100", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21972 {"arm7500", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21973 {"arm7500fe", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21974 {"arm7t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21975 {"arm7tdmi", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21976 {"arm7tdmi-s", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21977 {"arm8", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
21978 {"arm810", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
21979 {"strongarm", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
21980 {"strongarm1", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
21981 {"strongarm110", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
21982 {"strongarm1100", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
21983 {"strongarm1110", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
21984 {"arm9", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21985 {"arm920", ARM_ARCH_V4T
, FPU_ARCH_FPA
, "ARM920T"},
21986 {"arm920t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21987 {"arm922t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21988 {"arm940t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21989 {"arm9tdmi", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
21990 {"fa526", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
21991 {"fa626", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
21992 /* For V5 or later processors we default to using VFP; but the user
21993 should really set the FPU type explicitly. */
21994 {"arm9e-r0", ARM_ARCH_V5TExP
, FPU_ARCH_VFP_V2
, NULL
},
21995 {"arm9e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
21996 {"arm926ej", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
, "ARM926EJ-S"},
21997 {"arm926ejs", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
, "ARM926EJ-S"},
21998 {"arm926ej-s", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
, NULL
},
21999 {"arm946e-r0", ARM_ARCH_V5TExP
, FPU_ARCH_VFP_V2
, NULL
},
22000 {"arm946e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, "ARM946E-S"},
22001 {"arm946e-s", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22002 {"arm966e-r0", ARM_ARCH_V5TExP
, FPU_ARCH_VFP_V2
, NULL
},
22003 {"arm966e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, "ARM966E-S"},
22004 {"arm966e-s", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22005 {"arm968e-s", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22006 {"arm10t", ARM_ARCH_V5T
, FPU_ARCH_VFP_V1
, NULL
},
22007 {"arm10tdmi", ARM_ARCH_V5T
, FPU_ARCH_VFP_V1
, NULL
},
22008 {"arm10e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22009 {"arm1020", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, "ARM1020E"},
22010 {"arm1020t", ARM_ARCH_V5T
, FPU_ARCH_VFP_V1
, NULL
},
22011 {"arm1020e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22012 {"arm1022e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22013 {"arm1026ejs", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
, "ARM1026EJ-S"},
22014 {"arm1026ej-s", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
, NULL
},
22015 {"fa626te", ARM_ARCH_V5TE
, FPU_NONE
, NULL
},
22016 {"fa726te", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22017 {"arm1136js", ARM_ARCH_V6
, FPU_NONE
, "ARM1136J-S"},
22018 {"arm1136j-s", ARM_ARCH_V6
, FPU_NONE
, NULL
},
22019 {"arm1136jfs", ARM_ARCH_V6
, FPU_ARCH_VFP_V2
, "ARM1136JF-S"},
22020 {"arm1136jf-s", ARM_ARCH_V6
, FPU_ARCH_VFP_V2
, NULL
},
22021 {"mpcore", ARM_ARCH_V6K
, FPU_ARCH_VFP_V2
, NULL
},
22022 {"mpcorenovfp", ARM_ARCH_V6K
, FPU_NONE
, NULL
},
22023 {"arm1156t2-s", ARM_ARCH_V6T2
, FPU_NONE
, NULL
},
22024 {"arm1156t2f-s", ARM_ARCH_V6T2
, FPU_ARCH_VFP_V2
, NULL
},
22025 {"arm1176jz-s", ARM_ARCH_V6ZK
, FPU_NONE
, NULL
},
22026 {"arm1176jzf-s", ARM_ARCH_V6ZK
, FPU_ARCH_VFP_V2
, NULL
},
22027 {"cortex-a5", ARM_ARCH_V7A
, FPU_NONE
, NULL
},
22028 {"cortex-a8", ARM_ARCH_V7A
, ARM_FEATURE (0, FPU_VFP_V3
22029 | FPU_NEON_EXT_V1
),
22031 {"cortex-a9", ARM_ARCH_V7A
, ARM_FEATURE (0, FPU_VFP_V3
22032 | FPU_NEON_EXT_V1
),
22034 {"cortex-r4", ARM_ARCH_V7R
, FPU_NONE
, NULL
},
22035 {"cortex-r4f", ARM_ARCH_V7R
, FPU_ARCH_VFP_V3D16
, NULL
},
22036 {"cortex-m3", ARM_ARCH_V7M
, FPU_NONE
, NULL
},
22037 {"cortex-m1", ARM_ARCH_V6M
, FPU_NONE
, NULL
},
22038 {"cortex-m0", ARM_ARCH_V6M
, FPU_NONE
, NULL
},
22039 /* ??? XSCALE is really an architecture. */
22040 {"xscale", ARM_ARCH_XSCALE
, FPU_ARCH_VFP_V2
, NULL
},
22041 /* ??? iwmmxt is not a processor. */
22042 {"iwmmxt", ARM_ARCH_IWMMXT
, FPU_ARCH_VFP_V2
, NULL
},
22043 {"iwmmxt2", ARM_ARCH_IWMMXT2
,FPU_ARCH_VFP_V2
, NULL
},
22044 {"i80200", ARM_ARCH_XSCALE
, FPU_ARCH_VFP_V2
, NULL
},
22046 {"ep9312", ARM_FEATURE (ARM_AEXT_V4T
, ARM_CEXT_MAVERICK
), FPU_ARCH_MAVERICK
, "ARM920T"},
22047 {NULL
, ARM_ARCH_NONE
, ARM_ARCH_NONE
, NULL
}
22050 struct arm_arch_option_table
22053 const arm_feature_set value
;
22054 const arm_feature_set default_fpu
;
22057 /* This list should, at a minimum, contain all the architecture names
22058 recognized by GCC. */
22059 static const struct arm_arch_option_table arm_archs
[] =
22061 {"all", ARM_ANY
, FPU_ARCH_FPA
},
22062 {"armv1", ARM_ARCH_V1
, FPU_ARCH_FPA
},
22063 {"armv2", ARM_ARCH_V2
, FPU_ARCH_FPA
},
22064 {"armv2a", ARM_ARCH_V2S
, FPU_ARCH_FPA
},
22065 {"armv2s", ARM_ARCH_V2S
, FPU_ARCH_FPA
},
22066 {"armv3", ARM_ARCH_V3
, FPU_ARCH_FPA
},
22067 {"armv3m", ARM_ARCH_V3M
, FPU_ARCH_FPA
},
22068 {"armv4", ARM_ARCH_V4
, FPU_ARCH_FPA
},
22069 {"armv4xm", ARM_ARCH_V4xM
, FPU_ARCH_FPA
},
22070 {"armv4t", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
22071 {"armv4txm", ARM_ARCH_V4TxM
, FPU_ARCH_FPA
},
22072 {"armv5", ARM_ARCH_V5
, FPU_ARCH_VFP
},
22073 {"armv5t", ARM_ARCH_V5T
, FPU_ARCH_VFP
},
22074 {"armv5txm", ARM_ARCH_V5TxM
, FPU_ARCH_VFP
},
22075 {"armv5te", ARM_ARCH_V5TE
, FPU_ARCH_VFP
},
22076 {"armv5texp", ARM_ARCH_V5TExP
, FPU_ARCH_VFP
},
22077 {"armv5tej", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP
},
22078 {"armv6", ARM_ARCH_V6
, FPU_ARCH_VFP
},
22079 {"armv6j", ARM_ARCH_V6
, FPU_ARCH_VFP
},
22080 {"armv6k", ARM_ARCH_V6K
, FPU_ARCH_VFP
},
22081 {"armv6z", ARM_ARCH_V6Z
, FPU_ARCH_VFP
},
22082 {"armv6zk", ARM_ARCH_V6ZK
, FPU_ARCH_VFP
},
22083 {"armv6t2", ARM_ARCH_V6T2
, FPU_ARCH_VFP
},
22084 {"armv6kt2", ARM_ARCH_V6KT2
, FPU_ARCH_VFP
},
22085 {"armv6zt2", ARM_ARCH_V6ZT2
, FPU_ARCH_VFP
},
22086 {"armv6zkt2", ARM_ARCH_V6ZKT2
, FPU_ARCH_VFP
},
22087 {"armv6-m", ARM_ARCH_V6M
, FPU_ARCH_VFP
},
22088 {"armv7", ARM_ARCH_V7
, FPU_ARCH_VFP
},
22089 /* The official spelling of the ARMv7 profile variants is the dashed form.
22090 Accept the non-dashed form for compatibility with old toolchains. */
22091 {"armv7a", ARM_ARCH_V7A
, FPU_ARCH_VFP
},
22092 {"armv7r", ARM_ARCH_V7R
, FPU_ARCH_VFP
},
22093 {"armv7m", ARM_ARCH_V7M
, FPU_ARCH_VFP
},
22094 {"armv7-a", ARM_ARCH_V7A
, FPU_ARCH_VFP
},
22095 {"armv7-r", ARM_ARCH_V7R
, FPU_ARCH_VFP
},
22096 {"armv7-m", ARM_ARCH_V7M
, FPU_ARCH_VFP
},
22097 {"armv7e-m", ARM_ARCH_V7EM
, FPU_ARCH_VFP
},
22098 {"xscale", ARM_ARCH_XSCALE
, FPU_ARCH_VFP
},
22099 {"iwmmxt", ARM_ARCH_IWMMXT
, FPU_ARCH_VFP
},
22100 {"iwmmxt2", ARM_ARCH_IWMMXT2
,FPU_ARCH_VFP
},
22101 {NULL
, ARM_ARCH_NONE
, ARM_ARCH_NONE
}
22104 /* ISA extensions in the co-processor space. */
22105 struct arm_option_cpu_value_table
22108 const arm_feature_set value
;
22111 static const struct arm_option_cpu_value_table arm_extensions
[] =
22113 {"maverick", ARM_FEATURE (0, ARM_CEXT_MAVERICK
)},
22114 {"xscale", ARM_FEATURE (0, ARM_CEXT_XSCALE
)},
22115 {"iwmmxt", ARM_FEATURE (0, ARM_CEXT_IWMMXT
)},
22116 {"iwmmxt2", ARM_FEATURE (0, ARM_CEXT_IWMMXT2
)},
22117 {NULL
, ARM_ARCH_NONE
}
22120 /* This list should, at a minimum, contain all the fpu names
22121 recognized by GCC. */
22122 static const struct arm_option_cpu_value_table arm_fpus
[] =
22124 {"softfpa", FPU_NONE
},
22125 {"fpe", FPU_ARCH_FPE
},
22126 {"fpe2", FPU_ARCH_FPE
},
22127 {"fpe3", FPU_ARCH_FPA
}, /* Third release supports LFM/SFM. */
22128 {"fpa", FPU_ARCH_FPA
},
22129 {"fpa10", FPU_ARCH_FPA
},
22130 {"fpa11", FPU_ARCH_FPA
},
22131 {"arm7500fe", FPU_ARCH_FPA
},
22132 {"softvfp", FPU_ARCH_VFP
},
22133 {"softvfp+vfp", FPU_ARCH_VFP_V2
},
22134 {"vfp", FPU_ARCH_VFP_V2
},
22135 {"vfp9", FPU_ARCH_VFP_V2
},
22136 {"vfp3", FPU_ARCH_VFP_V3
}, /* For backwards compatbility. */
22137 {"vfp10", FPU_ARCH_VFP_V2
},
22138 {"vfp10-r0", FPU_ARCH_VFP_V1
},
22139 {"vfpxd", FPU_ARCH_VFP_V1xD
},
22140 {"vfpv2", FPU_ARCH_VFP_V2
},
22141 {"vfpv3", FPU_ARCH_VFP_V3
},
22142 {"vfpv3-fp16", FPU_ARCH_VFP_V3_FP16
},
22143 {"vfpv3-d16", FPU_ARCH_VFP_V3D16
},
22144 {"vfpv3-d16-fp16", FPU_ARCH_VFP_V3D16_FP16
},
22145 {"vfpv3xd", FPU_ARCH_VFP_V3xD
},
22146 {"vfpv3xd-fp16", FPU_ARCH_VFP_V3xD_FP16
},
22147 {"arm1020t", FPU_ARCH_VFP_V1
},
22148 {"arm1020e", FPU_ARCH_VFP_V2
},
22149 {"arm1136jfs", FPU_ARCH_VFP_V2
},
22150 {"arm1136jf-s", FPU_ARCH_VFP_V2
},
22151 {"maverick", FPU_ARCH_MAVERICK
},
22152 {"neon", FPU_ARCH_VFP_V3_PLUS_NEON_V1
},
22153 {"neon-fp16", FPU_ARCH_NEON_FP16
},
22154 {"vfpv4", FPU_ARCH_VFP_V4
},
22155 {"vfpv4-d16", FPU_ARCH_VFP_V4D16
},
22156 {"fpv4-sp-d16", FPU_ARCH_VFP_V4_SP_D16
},
22157 {"neon-vfpv4", FPU_ARCH_NEON_VFP_V4
},
22158 {NULL
, ARM_ARCH_NONE
}
22161 struct arm_option_value_table
22167 static const struct arm_option_value_table arm_float_abis
[] =
22169 {"hard", ARM_FLOAT_ABI_HARD
},
22170 {"softfp", ARM_FLOAT_ABI_SOFTFP
},
22171 {"soft", ARM_FLOAT_ABI_SOFT
},
22176 /* We only know how to output GNU and ver 4/5 (AAELF) formats. */
22177 static const struct arm_option_value_table arm_eabis
[] =
22179 {"gnu", EF_ARM_EABI_UNKNOWN
},
22180 {"4", EF_ARM_EABI_VER4
},
22181 {"5", EF_ARM_EABI_VER5
},
22186 struct arm_long_option_table
22188 char * option
; /* Substring to match. */
22189 char * help
; /* Help information. */
22190 int (* func
) (char * subopt
); /* Function to decode sub-option. */
22191 char * deprecated
; /* If non-null, print this message. */
22195 arm_parse_extension (char * str
, const arm_feature_set
**opt_p
)
22197 arm_feature_set
*ext_set
= (arm_feature_set
*)
22198 xmalloc (sizeof (arm_feature_set
));
22200 /* Copy the feature set, so that we can modify it. */
22201 *ext_set
= **opt_p
;
22204 while (str
!= NULL
&& *str
!= 0)
22206 const struct arm_option_cpu_value_table
* opt
;
22212 as_bad (_("invalid architectural extension"));
22217 ext
= strchr (str
, '+');
22220 optlen
= ext
- str
;
22222 optlen
= strlen (str
);
22226 as_bad (_("missing architectural extension"));
22230 for (opt
= arm_extensions
; opt
->name
!= NULL
; opt
++)
22231 if (strncmp (opt
->name
, str
, optlen
) == 0)
22233 ARM_MERGE_FEATURE_SETS (*ext_set
, *ext_set
, opt
->value
);
22237 if (opt
->name
== NULL
)
22239 as_bad (_("unknown architectural extension `%s'"), str
);
22250 arm_parse_cpu (char * str
)
22252 const struct arm_cpu_option_table
* opt
;
22253 char * ext
= strchr (str
, '+');
22257 optlen
= ext
- str
;
22259 optlen
= strlen (str
);
22263 as_bad (_("missing cpu name `%s'"), str
);
22267 for (opt
= arm_cpus
; opt
->name
!= NULL
; opt
++)
22268 if (strncmp (opt
->name
, str
, optlen
) == 0)
22270 mcpu_cpu_opt
= &opt
->value
;
22271 mcpu_fpu_opt
= &opt
->default_fpu
;
22272 if (opt
->canonical_name
)
22273 strcpy (selected_cpu_name
, opt
->canonical_name
);
22278 for (i
= 0; i
< optlen
; i
++)
22279 selected_cpu_name
[i
] = TOUPPER (opt
->name
[i
]);
22280 selected_cpu_name
[i
] = 0;
22284 return arm_parse_extension (ext
, &mcpu_cpu_opt
);
22289 as_bad (_("unknown cpu `%s'"), str
);
22294 arm_parse_arch (char * str
)
22296 const struct arm_arch_option_table
*opt
;
22297 char *ext
= strchr (str
, '+');
22301 optlen
= ext
- str
;
22303 optlen
= strlen (str
);
22307 as_bad (_("missing architecture name `%s'"), str
);
22311 for (opt
= arm_archs
; opt
->name
!= NULL
; opt
++)
22312 if (streq (opt
->name
, str
))
22314 march_cpu_opt
= &opt
->value
;
22315 march_fpu_opt
= &opt
->default_fpu
;
22316 strcpy (selected_cpu_name
, opt
->name
);
22319 return arm_parse_extension (ext
, &march_cpu_opt
);
22324 as_bad (_("unknown architecture `%s'\n"), str
);
22329 arm_parse_fpu (char * str
)
22331 const struct arm_option_cpu_value_table
* opt
;
22333 for (opt
= arm_fpus
; opt
->name
!= NULL
; opt
++)
22334 if (streq (opt
->name
, str
))
22336 mfpu_opt
= &opt
->value
;
22340 as_bad (_("unknown floating point format `%s'\n"), str
);
22345 arm_parse_float_abi (char * str
)
22347 const struct arm_option_value_table
* opt
;
22349 for (opt
= arm_float_abis
; opt
->name
!= NULL
; opt
++)
22350 if (streq (opt
->name
, str
))
22352 mfloat_abi_opt
= opt
->value
;
22356 as_bad (_("unknown floating point abi `%s'\n"), str
);
22362 arm_parse_eabi (char * str
)
22364 const struct arm_option_value_table
*opt
;
22366 for (opt
= arm_eabis
; opt
->name
!= NULL
; opt
++)
22367 if (streq (opt
->name
, str
))
22369 meabi_flags
= opt
->value
;
22372 as_bad (_("unknown EABI `%s'\n"), str
);
22378 arm_parse_it_mode (char * str
)
22380 bfd_boolean ret
= TRUE
;
22382 if (streq ("arm", str
))
22383 implicit_it_mode
= IMPLICIT_IT_MODE_ARM
;
22384 else if (streq ("thumb", str
))
22385 implicit_it_mode
= IMPLICIT_IT_MODE_THUMB
;
22386 else if (streq ("always", str
))
22387 implicit_it_mode
= IMPLICIT_IT_MODE_ALWAYS
;
22388 else if (streq ("never", str
))
22389 implicit_it_mode
= IMPLICIT_IT_MODE_NEVER
;
22392 as_bad (_("unknown implicit IT mode `%s', should be "\
22393 "arm, thumb, always, or never."), str
);
22400 struct arm_long_option_table arm_long_opts
[] =
22402 {"mcpu=", N_("<cpu name>\t assemble for CPU <cpu name>"),
22403 arm_parse_cpu
, NULL
},
22404 {"march=", N_("<arch name>\t assemble for architecture <arch name>"),
22405 arm_parse_arch
, NULL
},
22406 {"mfpu=", N_("<fpu name>\t assemble for FPU architecture <fpu name>"),
22407 arm_parse_fpu
, NULL
},
22408 {"mfloat-abi=", N_("<abi>\t assemble for floating point ABI <abi>"),
22409 arm_parse_float_abi
, NULL
},
22411 {"meabi=", N_("<ver>\t\t assemble for eabi version <ver>"),
22412 arm_parse_eabi
, NULL
},
22414 {"mimplicit-it=", N_("<mode>\t controls implicit insertion of IT instructions"),
22415 arm_parse_it_mode
, NULL
},
22416 {NULL
, NULL
, 0, NULL
}
22420 md_parse_option (int c
, char * arg
)
22422 struct arm_option_table
*opt
;
22423 const struct arm_legacy_option_table
*fopt
;
22424 struct arm_long_option_table
*lopt
;
22430 target_big_endian
= 1;
22436 target_big_endian
= 0;
22440 case OPTION_FIX_V4BX
:
22445 /* Listing option. Just ignore these, we don't support additional
22450 for (opt
= arm_opts
; opt
->option
!= NULL
; opt
++)
22452 if (c
== opt
->option
[0]
22453 && ((arg
== NULL
&& opt
->option
[1] == 0)
22454 || streq (arg
, opt
->option
+ 1)))
22456 /* If the option is deprecated, tell the user. */
22457 if (warn_on_deprecated
&& opt
->deprecated
!= NULL
)
22458 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c
,
22459 arg
? arg
: "", _(opt
->deprecated
));
22461 if (opt
->var
!= NULL
)
22462 *opt
->var
= opt
->value
;
22468 for (fopt
= arm_legacy_opts
; fopt
->option
!= NULL
; fopt
++)
22470 if (c
== fopt
->option
[0]
22471 && ((arg
== NULL
&& fopt
->option
[1] == 0)
22472 || streq (arg
, fopt
->option
+ 1)))
22474 /* If the option is deprecated, tell the user. */
22475 if (warn_on_deprecated
&& fopt
->deprecated
!= NULL
)
22476 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c
,
22477 arg
? arg
: "", _(fopt
->deprecated
));
22479 if (fopt
->var
!= NULL
)
22480 *fopt
->var
= &fopt
->value
;
22486 for (lopt
= arm_long_opts
; lopt
->option
!= NULL
; lopt
++)
22488 /* These options are expected to have an argument. */
22489 if (c
== lopt
->option
[0]
22491 && strncmp (arg
, lopt
->option
+ 1,
22492 strlen (lopt
->option
+ 1)) == 0)
22494 /* If the option is deprecated, tell the user. */
22495 if (warn_on_deprecated
&& lopt
->deprecated
!= NULL
)
22496 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c
, arg
,
22497 _(lopt
->deprecated
));
22499 /* Call the sup-option parser. */
22500 return lopt
->func (arg
+ strlen (lopt
->option
) - 1);
22511 md_show_usage (FILE * fp
)
22513 struct arm_option_table
*opt
;
22514 struct arm_long_option_table
*lopt
;
22516 fprintf (fp
, _(" ARM-specific assembler options:\n"));
22518 for (opt
= arm_opts
; opt
->option
!= NULL
; opt
++)
22519 if (opt
->help
!= NULL
)
22520 fprintf (fp
, " -%-23s%s\n", opt
->option
, _(opt
->help
));
22522 for (lopt
= arm_long_opts
; lopt
->option
!= NULL
; lopt
++)
22523 if (lopt
->help
!= NULL
)
22524 fprintf (fp
, " -%s%s\n", lopt
->option
, _(lopt
->help
));
22528 -EB assemble code for a big-endian cpu\n"));
22533 -EL assemble code for a little-endian cpu\n"));
22537 --fix-v4bx Allow BX in ARMv4 code\n"));
22545 arm_feature_set flags
;
22546 } cpu_arch_ver_table
;
22548 /* Mapping from CPU features to EABI CPU arch values. Table must be sorted
22549 least features first. */
22550 static const cpu_arch_ver_table cpu_arch_ver
[] =
22556 {4, ARM_ARCH_V5TE
},
22557 {5, ARM_ARCH_V5TEJ
},
22561 {11, ARM_ARCH_V6M
},
22562 {8, ARM_ARCH_V6T2
},
22563 {10, ARM_ARCH_V7A
},
22564 {10, ARM_ARCH_V7R
},
22565 {10, ARM_ARCH_V7M
},
22569 /* Set an attribute if it has not already been set by the user. */
22571 aeabi_set_attribute_int (int tag
, int value
)
22574 || tag
>= NUM_KNOWN_OBJ_ATTRIBUTES
22575 || !attributes_set_explicitly
[tag
])
22576 bfd_elf_add_proc_attr_int (stdoutput
, tag
, value
);
22580 aeabi_set_attribute_string (int tag
, const char *value
)
22583 || tag
>= NUM_KNOWN_OBJ_ATTRIBUTES
22584 || !attributes_set_explicitly
[tag
])
22585 bfd_elf_add_proc_attr_string (stdoutput
, tag
, value
);
22588 /* Set the public EABI object attributes. */
22590 aeabi_set_public_attributes (void)
22593 arm_feature_set flags
;
22594 arm_feature_set tmp
;
22595 const cpu_arch_ver_table
*p
;
22597 /* Choose the architecture based on the capabilities of the requested cpu
22598 (if any) and/or the instructions actually used. */
22599 ARM_MERGE_FEATURE_SETS (flags
, arm_arch_used
, thumb_arch_used
);
22600 ARM_MERGE_FEATURE_SETS (flags
, flags
, *mfpu_opt
);
22601 ARM_MERGE_FEATURE_SETS (flags
, flags
, selected_cpu
);
22602 /*Allow the user to override the reported architecture. */
22605 ARM_CLEAR_FEATURE (flags
, flags
, arm_arch_any
);
22606 ARM_MERGE_FEATURE_SETS (flags
, flags
, *object_arch
);
22611 for (p
= cpu_arch_ver
; p
->val
; p
++)
22613 if (ARM_CPU_HAS_FEATURE (tmp
, p
->flags
))
22616 ARM_CLEAR_FEATURE (tmp
, tmp
, p
->flags
);
22620 /* The table lookup above finds the last architecture to contribute
22621 a new feature. Unfortunately, Tag13 is a subset of the union of
22622 v6T2 and v7-M, so it is never seen as contributing a new feature.
22623 We can not search for the last entry which is entirely used,
22624 because if no CPU is specified we build up only those flags
22625 actually used. Perhaps we should separate out the specified
22626 and implicit cases. Avoid taking this path for -march=all by
22627 checking for contradictory v7-A / v7-M features. */
22629 && !ARM_CPU_HAS_FEATURE (flags
, arm_ext_v7a
)
22630 && ARM_CPU_HAS_FEATURE (flags
, arm_ext_v7m
)
22631 && ARM_CPU_HAS_FEATURE (flags
, arm_ext_v6_dsp
))
22634 /* Tag_CPU_name. */
22635 if (selected_cpu_name
[0])
22639 q
= selected_cpu_name
;
22640 if (strncmp (q
, "armv", 4) == 0)
22645 for (i
= 0; q
[i
]; i
++)
22646 q
[i
] = TOUPPER (q
[i
]);
22648 aeabi_set_attribute_string (Tag_CPU_name
, q
);
22651 /* Tag_CPU_arch. */
22652 aeabi_set_attribute_int (Tag_CPU_arch
, arch
);
22654 /* Tag_CPU_arch_profile. */
22655 if (ARM_CPU_HAS_FEATURE (flags
, arm_ext_v7a
))
22656 aeabi_set_attribute_int (Tag_CPU_arch_profile
, 'A');
22657 else if (ARM_CPU_HAS_FEATURE (flags
, arm_ext_v7r
))
22658 aeabi_set_attribute_int (Tag_CPU_arch_profile
, 'R');
22659 else if (ARM_CPU_HAS_FEATURE (flags
, arm_ext_m
))
22660 aeabi_set_attribute_int (Tag_CPU_arch_profile
, 'M');
22662 /* Tag_ARM_ISA_use. */
22663 if (ARM_CPU_HAS_FEATURE (flags
, arm_ext_v1
)
22665 aeabi_set_attribute_int (Tag_ARM_ISA_use
, 1);
22667 /* Tag_THUMB_ISA_use. */
22668 if (ARM_CPU_HAS_FEATURE (flags
, arm_ext_v4t
)
22670 aeabi_set_attribute_int (Tag_THUMB_ISA_use
,
22671 ARM_CPU_HAS_FEATURE (flags
, arm_arch_t2
) ? 2 : 1);
22673 /* Tag_VFP_arch. */
22674 if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_fma
))
22675 aeabi_set_attribute_int (Tag_VFP_arch
,
22676 ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_d32
)
22678 else if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_d32
))
22679 aeabi_set_attribute_int (Tag_VFP_arch
, 3);
22680 else if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_v3xd
))
22681 aeabi_set_attribute_int (Tag_VFP_arch
, 4);
22682 else if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_v2
))
22683 aeabi_set_attribute_int (Tag_VFP_arch
, 2);
22684 else if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_v1
)
22685 || ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_v1xd
))
22686 aeabi_set_attribute_int (Tag_VFP_arch
, 1);
22688 /* Tag_WMMX_arch. */
22689 if (ARM_CPU_HAS_FEATURE (flags
, arm_cext_iwmmxt2
))
22690 aeabi_set_attribute_int (Tag_WMMX_arch
, 2);
22691 else if (ARM_CPU_HAS_FEATURE (flags
, arm_cext_iwmmxt
))
22692 aeabi_set_attribute_int (Tag_WMMX_arch
, 1);
22694 /* Tag_Advanced_SIMD_arch (formerly Tag_NEON_arch). */
22695 if (ARM_CPU_HAS_FEATURE (flags
, fpu_neon_ext_v1
))
22696 aeabi_set_attribute_int
22697 (Tag_Advanced_SIMD_arch
, (ARM_CPU_HAS_FEATURE (flags
, fpu_neon_ext_fma
)
22700 /* Tag_VFP_HP_extension (formerly Tag_NEON_FP16_arch). */
22701 if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_fp16
))
22702 aeabi_set_attribute_int (Tag_VFP_HP_extension
, 1);
22705 /* Add the default contents for the .ARM.attributes section. */
22709 if (EF_ARM_EABI_VERSION (meabi_flags
) < EF_ARM_EABI_VER4
)
22712 aeabi_set_public_attributes ();
22714 #endif /* OBJ_ELF */
22717 /* Parse a .cpu directive. */
22720 s_arm_cpu (int ignored ATTRIBUTE_UNUSED
)
22722 const struct arm_cpu_option_table
*opt
;
22726 name
= input_line_pointer
;
22727 while (*input_line_pointer
&& !ISSPACE (*input_line_pointer
))
22728 input_line_pointer
++;
22729 saved_char
= *input_line_pointer
;
22730 *input_line_pointer
= 0;
22732 /* Skip the first "all" entry. */
22733 for (opt
= arm_cpus
+ 1; opt
->name
!= NULL
; opt
++)
22734 if (streq (opt
->name
, name
))
22736 mcpu_cpu_opt
= &opt
->value
;
22737 selected_cpu
= opt
->value
;
22738 if (opt
->canonical_name
)
22739 strcpy (selected_cpu_name
, opt
->canonical_name
);
22743 for (i
= 0; opt
->name
[i
]; i
++)
22744 selected_cpu_name
[i
] = TOUPPER (opt
->name
[i
]);
22745 selected_cpu_name
[i
] = 0;
22747 ARM_MERGE_FEATURE_SETS (cpu_variant
, *mcpu_cpu_opt
, *mfpu_opt
);
22748 *input_line_pointer
= saved_char
;
22749 demand_empty_rest_of_line ();
22752 as_bad (_("unknown cpu `%s'"), name
);
22753 *input_line_pointer
= saved_char
;
22754 ignore_rest_of_line ();
22758 /* Parse a .arch directive. */
22761 s_arm_arch (int ignored ATTRIBUTE_UNUSED
)
22763 const struct arm_arch_option_table
*opt
;
22767 name
= input_line_pointer
;
22768 while (*input_line_pointer
&& !ISSPACE (*input_line_pointer
))
22769 input_line_pointer
++;
22770 saved_char
= *input_line_pointer
;
22771 *input_line_pointer
= 0;
22773 /* Skip the first "all" entry. */
22774 for (opt
= arm_archs
+ 1; opt
->name
!= NULL
; opt
++)
22775 if (streq (opt
->name
, name
))
22777 mcpu_cpu_opt
= &opt
->value
;
22778 selected_cpu
= opt
->value
;
22779 strcpy (selected_cpu_name
, opt
->name
);
22780 ARM_MERGE_FEATURE_SETS (cpu_variant
, *mcpu_cpu_opt
, *mfpu_opt
);
22781 *input_line_pointer
= saved_char
;
22782 demand_empty_rest_of_line ();
22786 as_bad (_("unknown architecture `%s'\n"), name
);
22787 *input_line_pointer
= saved_char
;
22788 ignore_rest_of_line ();
22792 /* Parse a .object_arch directive. */
22795 s_arm_object_arch (int ignored ATTRIBUTE_UNUSED
)
22797 const struct arm_arch_option_table
*opt
;
22801 name
= input_line_pointer
;
22802 while (*input_line_pointer
&& !ISSPACE (*input_line_pointer
))
22803 input_line_pointer
++;
22804 saved_char
= *input_line_pointer
;
22805 *input_line_pointer
= 0;
22807 /* Skip the first "all" entry. */
22808 for (opt
= arm_archs
+ 1; opt
->name
!= NULL
; opt
++)
22809 if (streq (opt
->name
, name
))
22811 object_arch
= &opt
->value
;
22812 *input_line_pointer
= saved_char
;
22813 demand_empty_rest_of_line ();
22817 as_bad (_("unknown architecture `%s'\n"), name
);
22818 *input_line_pointer
= saved_char
;
22819 ignore_rest_of_line ();
22822 /* Parse a .fpu directive. */
22825 s_arm_fpu (int ignored ATTRIBUTE_UNUSED
)
22827 const struct arm_option_cpu_value_table
*opt
;
22831 name
= input_line_pointer
;
22832 while (*input_line_pointer
&& !ISSPACE (*input_line_pointer
))
22833 input_line_pointer
++;
22834 saved_char
= *input_line_pointer
;
22835 *input_line_pointer
= 0;
22837 for (opt
= arm_fpus
; opt
->name
!= NULL
; opt
++)
22838 if (streq (opt
->name
, name
))
22840 mfpu_opt
= &opt
->value
;
22841 ARM_MERGE_FEATURE_SETS (cpu_variant
, *mcpu_cpu_opt
, *mfpu_opt
);
22842 *input_line_pointer
= saved_char
;
22843 demand_empty_rest_of_line ();
22847 as_bad (_("unknown floating point format `%s'\n"), name
);
22848 *input_line_pointer
= saved_char
;
22849 ignore_rest_of_line ();
22852 /* Copy symbol information. */
22855 arm_copy_symbol_attributes (symbolS
*dest
, symbolS
*src
)
22857 ARM_GET_FLAG (dest
) = ARM_GET_FLAG (src
);
22861 /* Given a symbolic attribute NAME, return the proper integer value.
22862 Returns -1 if the attribute is not known. */
22865 arm_convert_symbolic_attribute (const char *name
)
22867 static const struct
22872 attribute_table
[] =
22874 /* When you modify this table you should
22875 also modify the list in doc/c-arm.texi. */
22876 #define T(tag) {#tag, tag}
22877 T (Tag_CPU_raw_name
),
22880 T (Tag_CPU_arch_profile
),
22881 T (Tag_ARM_ISA_use
),
22882 T (Tag_THUMB_ISA_use
),
22885 T (Tag_Advanced_SIMD_arch
),
22886 T (Tag_PCS_config
),
22887 T (Tag_ABI_PCS_R9_use
),
22888 T (Tag_ABI_PCS_RW_data
),
22889 T (Tag_ABI_PCS_RO_data
),
22890 T (Tag_ABI_PCS_GOT_use
),
22891 T (Tag_ABI_PCS_wchar_t
),
22892 T (Tag_ABI_FP_rounding
),
22893 T (Tag_ABI_FP_denormal
),
22894 T (Tag_ABI_FP_exceptions
),
22895 T (Tag_ABI_FP_user_exceptions
),
22896 T (Tag_ABI_FP_number_model
),
22897 T (Tag_ABI_align8_needed
),
22898 T (Tag_ABI_align8_preserved
),
22899 T (Tag_ABI_enum_size
),
22900 T (Tag_ABI_HardFP_use
),
22901 T (Tag_ABI_VFP_args
),
22902 T (Tag_ABI_WMMX_args
),
22903 T (Tag_ABI_optimization_goals
),
22904 T (Tag_ABI_FP_optimization_goals
),
22905 T (Tag_compatibility
),
22906 T (Tag_CPU_unaligned_access
),
22907 T (Tag_VFP_HP_extension
),
22908 T (Tag_ABI_FP_16bit_format
),
22909 T (Tag_nodefaults
),
22910 T (Tag_also_compatible_with
),
22911 T (Tag_conformance
),
22913 T (Tag_Virtualization_use
),
22914 T (Tag_MPextension_use
)
22922 for (i
= 0; i
< ARRAY_SIZE (attribute_table
); i
++)
22923 if (streq (name
, attribute_table
[i
].name
))
22924 return attribute_table
[i
].tag
;
22930 /* Apply sym value for relocations only in the case that
22931 they are for local symbols and you have the respective
22932 architectural feature for blx and simple switches. */
22934 arm_apply_sym_value (struct fix
* fixP
)
22937 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
)
22938 && !S_IS_EXTERNAL (fixP
->fx_addsy
))
22940 switch (fixP
->fx_r_type
)
22942 case BFD_RELOC_ARM_PCREL_BLX
:
22943 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
22944 if (ARM_IS_FUNC (fixP
->fx_addsy
))
22948 case BFD_RELOC_ARM_PCREL_CALL
:
22949 case BFD_RELOC_THUMB_PCREL_BLX
:
22950 if (THUMB_IS_FUNC (fixP
->fx_addsy
))
22961 #endif /* OBJ_ELF */