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 (selected_cpu
, arm_ext_v6t2
))
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
;
12047 unsigned regwidth
, match
;
12049 /* PR 11136: Catch the case where we are passed a shape of NS_NULL. */
12052 first_error (_("invalid instruction shape"));
12055 regshape
= neon_shape_tab
[ns
].el
[i
];
12056 regwidth
= neon_shape_el_size
[regshape
];
12058 /* In VFP mode, operands must match register widths. If we
12059 have a key operand, use its width, else use the width of
12060 the current operand. */
12066 if (regwidth
!= match
)
12068 first_error (_("operand size must match register width"));
12073 if ((thisarg
& N_EQK
) == 0)
12075 unsigned given_type
= type_chk_of_el_type (g_type
, g_size
);
12077 if ((given_type
& types_allowed
) == 0)
12079 first_error (_("bad type in Neon instruction"));
12085 enum neon_el_type mod_k_type
= k_type
;
12086 unsigned mod_k_size
= k_size
;
12087 neon_modify_type_size (thisarg
, &mod_k_type
, &mod_k_size
);
12088 if (g_type
!= mod_k_type
|| g_size
!= mod_k_size
)
12090 first_error (_("inconsistent types in Neon instruction"));
12098 return inst
.vectype
.el
[key_el
];
12101 /* Neon-style VFP instruction forwarding. */
12103 /* Thumb VFP instructions have 0xE in the condition field. */
12106 do_vfp_cond_or_thumb (void)
12111 inst
.instruction
|= 0xe0000000;
12113 inst
.instruction
|= inst
.cond
<< 28;
12116 /* Look up and encode a simple mnemonic, for use as a helper function for the
12117 Neon-style VFP syntax. This avoids duplication of bits of the insns table,
12118 etc. It is assumed that operand parsing has already been done, and that the
12119 operands are in the form expected by the given opcode (this isn't necessarily
12120 the same as the form in which they were parsed, hence some massaging must
12121 take place before this function is called).
12122 Checks current arch version against that in the looked-up opcode. */
12125 do_vfp_nsyn_opcode (const char *opname
)
12127 const struct asm_opcode
*opcode
;
12129 opcode
= (const struct asm_opcode
*) hash_find (arm_ops_hsh
, opname
);
12134 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
,
12135 thumb_mode
? *opcode
->tvariant
: *opcode
->avariant
),
12142 inst
.instruction
= opcode
->tvalue
;
12143 opcode
->tencode ();
12147 inst
.instruction
= (inst
.cond
<< 28) | opcode
->avalue
;
12148 opcode
->aencode ();
12153 do_vfp_nsyn_add_sub (enum neon_shape rs
)
12155 int is_add
= (inst
.instruction
& 0x0fffffff) == N_MNEM_vadd
;
12160 do_vfp_nsyn_opcode ("fadds");
12162 do_vfp_nsyn_opcode ("fsubs");
12167 do_vfp_nsyn_opcode ("faddd");
12169 do_vfp_nsyn_opcode ("fsubd");
12173 /* Check operand types to see if this is a VFP instruction, and if so call
12177 try_vfp_nsyn (int args
, void (*pfn
) (enum neon_shape
))
12179 enum neon_shape rs
;
12180 struct neon_type_el et
;
12185 rs
= neon_select_shape (NS_FF
, NS_DD
, NS_NULL
);
12186 et
= neon_check_type (2, rs
,
12187 N_EQK
| N_VFP
, N_F32
| N_F64
| N_KEY
| N_VFP
);
12191 rs
= neon_select_shape (NS_FFF
, NS_DDD
, NS_NULL
);
12192 et
= neon_check_type (3, rs
,
12193 N_EQK
| N_VFP
, N_EQK
| N_VFP
, N_F32
| N_F64
| N_KEY
| N_VFP
);
12200 if (et
.type
!= NT_invtype
)
12211 do_vfp_nsyn_mla_mls (enum neon_shape rs
)
12213 int is_mla
= (inst
.instruction
& 0x0fffffff) == N_MNEM_vmla
;
12218 do_vfp_nsyn_opcode ("fmacs");
12220 do_vfp_nsyn_opcode ("fnmacs");
12225 do_vfp_nsyn_opcode ("fmacd");
12227 do_vfp_nsyn_opcode ("fnmacd");
12232 do_vfp_nsyn_fma_fms (enum neon_shape rs
)
12234 int is_fma
= (inst
.instruction
& 0x0fffffff) == N_MNEM_vfma
;
12239 do_vfp_nsyn_opcode ("ffmas");
12241 do_vfp_nsyn_opcode ("ffnmas");
12246 do_vfp_nsyn_opcode ("ffmad");
12248 do_vfp_nsyn_opcode ("ffnmad");
12253 do_vfp_nsyn_mul (enum neon_shape rs
)
12256 do_vfp_nsyn_opcode ("fmuls");
12258 do_vfp_nsyn_opcode ("fmuld");
12262 do_vfp_nsyn_abs_neg (enum neon_shape rs
)
12264 int is_neg
= (inst
.instruction
& 0x80) != 0;
12265 neon_check_type (2, rs
, N_EQK
| N_VFP
, N_F32
| N_F64
| N_VFP
| N_KEY
);
12270 do_vfp_nsyn_opcode ("fnegs");
12272 do_vfp_nsyn_opcode ("fabss");
12277 do_vfp_nsyn_opcode ("fnegd");
12279 do_vfp_nsyn_opcode ("fabsd");
12283 /* Encode single-precision (only!) VFP fldm/fstm instructions. Double precision
12284 insns belong to Neon, and are handled elsewhere. */
12287 do_vfp_nsyn_ldm_stm (int is_dbmode
)
12289 int is_ldm
= (inst
.instruction
& (1 << 20)) != 0;
12293 do_vfp_nsyn_opcode ("fldmdbs");
12295 do_vfp_nsyn_opcode ("fldmias");
12300 do_vfp_nsyn_opcode ("fstmdbs");
12302 do_vfp_nsyn_opcode ("fstmias");
12307 do_vfp_nsyn_sqrt (void)
12309 enum neon_shape rs
= neon_select_shape (NS_FF
, NS_DD
, NS_NULL
);
12310 neon_check_type (2, rs
, N_EQK
| N_VFP
, N_F32
| N_F64
| N_KEY
| N_VFP
);
12313 do_vfp_nsyn_opcode ("fsqrts");
12315 do_vfp_nsyn_opcode ("fsqrtd");
12319 do_vfp_nsyn_div (void)
12321 enum neon_shape rs
= neon_select_shape (NS_FFF
, NS_DDD
, NS_NULL
);
12322 neon_check_type (3, rs
, N_EQK
| N_VFP
, N_EQK
| N_VFP
,
12323 N_F32
| N_F64
| N_KEY
| N_VFP
);
12326 do_vfp_nsyn_opcode ("fdivs");
12328 do_vfp_nsyn_opcode ("fdivd");
12332 do_vfp_nsyn_nmul (void)
12334 enum neon_shape rs
= neon_select_shape (NS_FFF
, NS_DDD
, NS_NULL
);
12335 neon_check_type (3, rs
, N_EQK
| N_VFP
, N_EQK
| N_VFP
,
12336 N_F32
| N_F64
| N_KEY
| N_VFP
);
12340 NEON_ENCODE (SINGLE
, inst
);
12341 do_vfp_sp_dyadic ();
12345 NEON_ENCODE (DOUBLE
, inst
);
12346 do_vfp_dp_rd_rn_rm ();
12348 do_vfp_cond_or_thumb ();
12352 do_vfp_nsyn_cmp (void)
12354 if (inst
.operands
[1].isreg
)
12356 enum neon_shape rs
= neon_select_shape (NS_FF
, NS_DD
, NS_NULL
);
12357 neon_check_type (2, rs
, N_EQK
| N_VFP
, N_F32
| N_F64
| N_KEY
| N_VFP
);
12361 NEON_ENCODE (SINGLE
, inst
);
12362 do_vfp_sp_monadic ();
12366 NEON_ENCODE (DOUBLE
, inst
);
12367 do_vfp_dp_rd_rm ();
12372 enum neon_shape rs
= neon_select_shape (NS_FI
, NS_DI
, NS_NULL
);
12373 neon_check_type (2, rs
, N_F32
| N_F64
| N_KEY
| N_VFP
, N_EQK
);
12375 switch (inst
.instruction
& 0x0fffffff)
12378 inst
.instruction
+= N_MNEM_vcmpz
- N_MNEM_vcmp
;
12381 inst
.instruction
+= N_MNEM_vcmpez
- N_MNEM_vcmpe
;
12389 NEON_ENCODE (SINGLE
, inst
);
12390 do_vfp_sp_compare_z ();
12394 NEON_ENCODE (DOUBLE
, inst
);
12398 do_vfp_cond_or_thumb ();
12402 nsyn_insert_sp (void)
12404 inst
.operands
[1] = inst
.operands
[0];
12405 memset (&inst
.operands
[0], '\0', sizeof (inst
.operands
[0]));
12406 inst
.operands
[0].reg
= REG_SP
;
12407 inst
.operands
[0].isreg
= 1;
12408 inst
.operands
[0].writeback
= 1;
12409 inst
.operands
[0].present
= 1;
12413 do_vfp_nsyn_push (void)
12416 if (inst
.operands
[1].issingle
)
12417 do_vfp_nsyn_opcode ("fstmdbs");
12419 do_vfp_nsyn_opcode ("fstmdbd");
12423 do_vfp_nsyn_pop (void)
12426 if (inst
.operands
[1].issingle
)
12427 do_vfp_nsyn_opcode ("fldmias");
12429 do_vfp_nsyn_opcode ("fldmiad");
12432 /* Fix up Neon data-processing instructions, ORing in the correct bits for
12433 ARM mode or Thumb mode and moving the encoded bit 24 to bit 28. */
12436 neon_dp_fixup (struct arm_it
* insn
)
12438 unsigned int i
= insn
->instruction
;
12443 /* The U bit is at bit 24 by default. Move to bit 28 in Thumb mode. */
12454 insn
->instruction
= i
;
12457 /* Turn a size (8, 16, 32, 64) into the respective bit number minus 3
12461 neon_logbits (unsigned x
)
12463 return ffs (x
) - 4;
12466 #define LOW4(R) ((R) & 0xf)
12467 #define HI1(R) (((R) >> 4) & 1)
12469 /* Encode insns with bit pattern:
12471 |28/24|23|22 |21 20|19 16|15 12|11 8|7|6|5|4|3 0|
12472 | U |x |D |size | Rn | Rd |x x x x|N|Q|M|x| Rm |
12474 SIZE is passed in bits. -1 means size field isn't changed, in case it has a
12475 different meaning for some instruction. */
12478 neon_three_same (int isquad
, int ubit
, int size
)
12480 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
12481 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
12482 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
12483 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
12484 inst
.instruction
|= LOW4 (inst
.operands
[2].reg
);
12485 inst
.instruction
|= HI1 (inst
.operands
[2].reg
) << 5;
12486 inst
.instruction
|= (isquad
!= 0) << 6;
12487 inst
.instruction
|= (ubit
!= 0) << 24;
12489 inst
.instruction
|= neon_logbits (size
) << 20;
12491 neon_dp_fixup (&inst
);
12494 /* Encode instructions of the form:
12496 |28/24|23|22|21 20|19 18|17 16|15 12|11 7|6|5|4|3 0|
12497 | U |x |D |x x |size |x x | Rd |x x x x x|Q|M|x| Rm |
12499 Don't write size if SIZE == -1. */
12502 neon_two_same (int qbit
, int ubit
, int size
)
12504 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
12505 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
12506 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
12507 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
12508 inst
.instruction
|= (qbit
!= 0) << 6;
12509 inst
.instruction
|= (ubit
!= 0) << 24;
12512 inst
.instruction
|= neon_logbits (size
) << 18;
12514 neon_dp_fixup (&inst
);
12517 /* Neon instruction encoders, in approximate order of appearance. */
12520 do_neon_dyadic_i_su (void)
12522 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12523 struct neon_type_el et
= neon_check_type (3, rs
,
12524 N_EQK
, N_EQK
, N_SU_32
| N_KEY
);
12525 neon_three_same (neon_quad (rs
), et
.type
== NT_unsigned
, et
.size
);
12529 do_neon_dyadic_i64_su (void)
12531 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12532 struct neon_type_el et
= neon_check_type (3, rs
,
12533 N_EQK
, N_EQK
, N_SU_ALL
| N_KEY
);
12534 neon_three_same (neon_quad (rs
), et
.type
== NT_unsigned
, et
.size
);
12538 neon_imm_shift (int write_ubit
, int uval
, int isquad
, struct neon_type_el et
,
12541 unsigned size
= et
.size
>> 3;
12542 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
12543 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
12544 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
12545 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
12546 inst
.instruction
|= (isquad
!= 0) << 6;
12547 inst
.instruction
|= immbits
<< 16;
12548 inst
.instruction
|= (size
>> 3) << 7;
12549 inst
.instruction
|= (size
& 0x7) << 19;
12551 inst
.instruction
|= (uval
!= 0) << 24;
12553 neon_dp_fixup (&inst
);
12557 do_neon_shl_imm (void)
12559 if (!inst
.operands
[2].isreg
)
12561 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
12562 struct neon_type_el et
= neon_check_type (2, rs
, N_EQK
, N_KEY
| N_I_ALL
);
12563 NEON_ENCODE (IMMED
, inst
);
12564 neon_imm_shift (FALSE
, 0, neon_quad (rs
), et
, inst
.operands
[2].imm
);
12568 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12569 struct neon_type_el et
= neon_check_type (3, rs
,
12570 N_EQK
, N_SU_ALL
| N_KEY
, N_EQK
| N_SGN
);
12573 /* VSHL/VQSHL 3-register variants have syntax such as:
12575 whereas other 3-register operations encoded by neon_three_same have
12578 (i.e. with Dn & Dm reversed). Swap operands[1].reg and operands[2].reg
12580 tmp
= inst
.operands
[2].reg
;
12581 inst
.operands
[2].reg
= inst
.operands
[1].reg
;
12582 inst
.operands
[1].reg
= tmp
;
12583 NEON_ENCODE (INTEGER
, inst
);
12584 neon_three_same (neon_quad (rs
), et
.type
== NT_unsigned
, et
.size
);
12589 do_neon_qshl_imm (void)
12591 if (!inst
.operands
[2].isreg
)
12593 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
12594 struct neon_type_el et
= neon_check_type (2, rs
, N_EQK
, N_SU_ALL
| N_KEY
);
12596 NEON_ENCODE (IMMED
, inst
);
12597 neon_imm_shift (TRUE
, et
.type
== NT_unsigned
, neon_quad (rs
), et
,
12598 inst
.operands
[2].imm
);
12602 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12603 struct neon_type_el et
= neon_check_type (3, rs
,
12604 N_EQK
, N_SU_ALL
| N_KEY
, N_EQK
| N_SGN
);
12607 /* See note in do_neon_shl_imm. */
12608 tmp
= inst
.operands
[2].reg
;
12609 inst
.operands
[2].reg
= inst
.operands
[1].reg
;
12610 inst
.operands
[1].reg
= tmp
;
12611 NEON_ENCODE (INTEGER
, inst
);
12612 neon_three_same (neon_quad (rs
), et
.type
== NT_unsigned
, et
.size
);
12617 do_neon_rshl (void)
12619 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12620 struct neon_type_el et
= neon_check_type (3, rs
,
12621 N_EQK
, N_EQK
, N_SU_ALL
| N_KEY
);
12624 tmp
= inst
.operands
[2].reg
;
12625 inst
.operands
[2].reg
= inst
.operands
[1].reg
;
12626 inst
.operands
[1].reg
= tmp
;
12627 neon_three_same (neon_quad (rs
), et
.type
== NT_unsigned
, et
.size
);
12631 neon_cmode_for_logic_imm (unsigned immediate
, unsigned *immbits
, int size
)
12633 /* Handle .I8 pseudo-instructions. */
12636 /* Unfortunately, this will make everything apart from zero out-of-range.
12637 FIXME is this the intended semantics? There doesn't seem much point in
12638 accepting .I8 if so. */
12639 immediate
|= immediate
<< 8;
12645 if (immediate
== (immediate
& 0x000000ff))
12647 *immbits
= immediate
;
12650 else if (immediate
== (immediate
& 0x0000ff00))
12652 *immbits
= immediate
>> 8;
12655 else if (immediate
== (immediate
& 0x00ff0000))
12657 *immbits
= immediate
>> 16;
12660 else if (immediate
== (immediate
& 0xff000000))
12662 *immbits
= immediate
>> 24;
12665 if ((immediate
& 0xffff) != (immediate
>> 16))
12666 goto bad_immediate
;
12667 immediate
&= 0xffff;
12670 if (immediate
== (immediate
& 0x000000ff))
12672 *immbits
= immediate
;
12675 else if (immediate
== (immediate
& 0x0000ff00))
12677 *immbits
= immediate
>> 8;
12682 first_error (_("immediate value out of range"));
12686 /* True if IMM has form 0bAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD for bits
12690 neon_bits_same_in_bytes (unsigned imm
)
12692 return ((imm
& 0x000000ff) == 0 || (imm
& 0x000000ff) == 0x000000ff)
12693 && ((imm
& 0x0000ff00) == 0 || (imm
& 0x0000ff00) == 0x0000ff00)
12694 && ((imm
& 0x00ff0000) == 0 || (imm
& 0x00ff0000) == 0x00ff0000)
12695 && ((imm
& 0xff000000) == 0 || (imm
& 0xff000000) == 0xff000000);
12698 /* For immediate of above form, return 0bABCD. */
12701 neon_squash_bits (unsigned imm
)
12703 return (imm
& 0x01) | ((imm
& 0x0100) >> 7) | ((imm
& 0x010000) >> 14)
12704 | ((imm
& 0x01000000) >> 21);
12707 /* Compress quarter-float representation to 0b...000 abcdefgh. */
12710 neon_qfloat_bits (unsigned imm
)
12712 return ((imm
>> 19) & 0x7f) | ((imm
>> 24) & 0x80);
12715 /* Returns CMODE. IMMBITS [7:0] is set to bits suitable for inserting into
12716 the instruction. *OP is passed as the initial value of the op field, and
12717 may be set to a different value depending on the constant (i.e.
12718 "MOV I64, 0bAAAAAAAABBBB..." which uses OP = 1 despite being MOV not
12719 MVN). If the immediate looks like a repeated pattern then also
12720 try smaller element sizes. */
12723 neon_cmode_for_move_imm (unsigned immlo
, unsigned immhi
, int float_p
,
12724 unsigned *immbits
, int *op
, int size
,
12725 enum neon_el_type type
)
12727 /* Only permit float immediates (including 0.0/-0.0) if the operand type is
12729 if (type
== NT_float
&& !float_p
)
12732 if (type
== NT_float
&& is_quarter_float (immlo
) && immhi
== 0)
12734 if (size
!= 32 || *op
== 1)
12736 *immbits
= neon_qfloat_bits (immlo
);
12742 if (neon_bits_same_in_bytes (immhi
)
12743 && neon_bits_same_in_bytes (immlo
))
12747 *immbits
= (neon_squash_bits (immhi
) << 4)
12748 | neon_squash_bits (immlo
);
12753 if (immhi
!= immlo
)
12759 if (immlo
== (immlo
& 0x000000ff))
12764 else if (immlo
== (immlo
& 0x0000ff00))
12766 *immbits
= immlo
>> 8;
12769 else if (immlo
== (immlo
& 0x00ff0000))
12771 *immbits
= immlo
>> 16;
12774 else if (immlo
== (immlo
& 0xff000000))
12776 *immbits
= immlo
>> 24;
12779 else if (immlo
== ((immlo
& 0x0000ff00) | 0x000000ff))
12781 *immbits
= (immlo
>> 8) & 0xff;
12784 else if (immlo
== ((immlo
& 0x00ff0000) | 0x0000ffff))
12786 *immbits
= (immlo
>> 16) & 0xff;
12790 if ((immlo
& 0xffff) != (immlo
>> 16))
12797 if (immlo
== (immlo
& 0x000000ff))
12802 else if (immlo
== (immlo
& 0x0000ff00))
12804 *immbits
= immlo
>> 8;
12808 if ((immlo
& 0xff) != (immlo
>> 8))
12813 if (immlo
== (immlo
& 0x000000ff))
12815 /* Don't allow MVN with 8-bit immediate. */
12825 /* Write immediate bits [7:0] to the following locations:
12827 |28/24|23 19|18 16|15 4|3 0|
12828 | 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|
12830 This function is used by VMOV/VMVN/VORR/VBIC. */
12833 neon_write_immbits (unsigned immbits
)
12835 inst
.instruction
|= immbits
& 0xf;
12836 inst
.instruction
|= ((immbits
>> 4) & 0x7) << 16;
12837 inst
.instruction
|= ((immbits
>> 7) & 0x1) << 24;
12840 /* Invert low-order SIZE bits of XHI:XLO. */
12843 neon_invert_size (unsigned *xlo
, unsigned *xhi
, int size
)
12845 unsigned immlo
= xlo
? *xlo
: 0;
12846 unsigned immhi
= xhi
? *xhi
: 0;
12851 immlo
= (~immlo
) & 0xff;
12855 immlo
= (~immlo
) & 0xffff;
12859 immhi
= (~immhi
) & 0xffffffff;
12860 /* fall through. */
12863 immlo
= (~immlo
) & 0xffffffff;
12878 do_neon_logic (void)
12880 if (inst
.operands
[2].present
&& inst
.operands
[2].isreg
)
12882 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12883 neon_check_type (3, rs
, N_IGNORE_TYPE
);
12884 /* U bit and size field were set as part of the bitmask. */
12885 NEON_ENCODE (INTEGER
, inst
);
12886 neon_three_same (neon_quad (rs
), 0, -1);
12890 const int three_ops_form
= (inst
.operands
[2].present
12891 && !inst
.operands
[2].isreg
);
12892 const int immoperand
= (three_ops_form
? 2 : 1);
12893 enum neon_shape rs
= (three_ops_form
12894 ? neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
)
12895 : neon_select_shape (NS_DI
, NS_QI
, NS_NULL
));
12896 struct neon_type_el et
= neon_check_type (2, rs
,
12897 N_I8
| N_I16
| N_I32
| N_I64
| N_F32
| N_KEY
, N_EQK
);
12898 enum neon_opc opcode
= (enum neon_opc
) inst
.instruction
& 0x0fffffff;
12902 if (et
.type
== NT_invtype
)
12905 if (three_ops_form
)
12906 constraint (inst
.operands
[0].reg
!= inst
.operands
[1].reg
,
12907 _("first and second operands shall be the same register"));
12909 NEON_ENCODE (IMMED
, inst
);
12911 immbits
= inst
.operands
[immoperand
].imm
;
12914 /* .i64 is a pseudo-op, so the immediate must be a repeating
12916 if (immbits
!= (inst
.operands
[immoperand
].regisimm
?
12917 inst
.operands
[immoperand
].reg
: 0))
12919 /* Set immbits to an invalid constant. */
12920 immbits
= 0xdeadbeef;
12927 cmode
= neon_cmode_for_logic_imm (immbits
, &immbits
, et
.size
);
12931 cmode
= neon_cmode_for_logic_imm (immbits
, &immbits
, et
.size
);
12935 /* Pseudo-instruction for VBIC. */
12936 neon_invert_size (&immbits
, 0, et
.size
);
12937 cmode
= neon_cmode_for_logic_imm (immbits
, &immbits
, et
.size
);
12941 /* Pseudo-instruction for VORR. */
12942 neon_invert_size (&immbits
, 0, et
.size
);
12943 cmode
= neon_cmode_for_logic_imm (immbits
, &immbits
, et
.size
);
12953 inst
.instruction
|= neon_quad (rs
) << 6;
12954 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
12955 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
12956 inst
.instruction
|= cmode
<< 8;
12957 neon_write_immbits (immbits
);
12959 neon_dp_fixup (&inst
);
12964 do_neon_bitfield (void)
12966 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12967 neon_check_type (3, rs
, N_IGNORE_TYPE
);
12968 neon_three_same (neon_quad (rs
), 0, -1);
12972 neon_dyadic_misc (enum neon_el_type ubit_meaning
, unsigned types
,
12975 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
12976 struct neon_type_el et
= neon_check_type (3, rs
, N_EQK
| destbits
, N_EQK
,
12978 if (et
.type
== NT_float
)
12980 NEON_ENCODE (FLOAT
, inst
);
12981 neon_three_same (neon_quad (rs
), 0, -1);
12985 NEON_ENCODE (INTEGER
, inst
);
12986 neon_three_same (neon_quad (rs
), et
.type
== ubit_meaning
, et
.size
);
12991 do_neon_dyadic_if_su (void)
12993 neon_dyadic_misc (NT_unsigned
, N_SUF_32
, 0);
12997 do_neon_dyadic_if_su_d (void)
12999 /* This version only allow D registers, but that constraint is enforced during
13000 operand parsing so we don't need to do anything extra here. */
13001 neon_dyadic_misc (NT_unsigned
, N_SUF_32
, 0);
13005 do_neon_dyadic_if_i_d (void)
13007 /* The "untyped" case can't happen. Do this to stop the "U" bit being
13008 affected if we specify unsigned args. */
13009 neon_dyadic_misc (NT_untyped
, N_IF_32
, 0);
13012 enum vfp_or_neon_is_neon_bits
13015 NEON_CHECK_ARCH
= 2
13018 /* Call this function if an instruction which may have belonged to the VFP or
13019 Neon instruction sets, but turned out to be a Neon instruction (due to the
13020 operand types involved, etc.). We have to check and/or fix-up a couple of
13023 - Make sure the user hasn't attempted to make a Neon instruction
13025 - Alter the value in the condition code field if necessary.
13026 - Make sure that the arch supports Neon instructions.
13028 Which of these operations take place depends on bits from enum
13029 vfp_or_neon_is_neon_bits.
13031 WARNING: This function has side effects! If NEON_CHECK_CC is used and the
13032 current instruction's condition is COND_ALWAYS, the condition field is
13033 changed to inst.uncond_value. This is necessary because instructions shared
13034 between VFP and Neon may be conditional for the VFP variants only, and the
13035 unconditional Neon version must have, e.g., 0xF in the condition field. */
13038 vfp_or_neon_is_neon (unsigned check
)
13040 /* Conditions are always legal in Thumb mode (IT blocks). */
13041 if (!thumb_mode
&& (check
& NEON_CHECK_CC
))
13043 if (inst
.cond
!= COND_ALWAYS
)
13045 first_error (_(BAD_COND
));
13048 if (inst
.uncond_value
!= -1)
13049 inst
.instruction
|= inst
.uncond_value
<< 28;
13052 if ((check
& NEON_CHECK_ARCH
)
13053 && !ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_neon_ext_v1
))
13055 first_error (_(BAD_FPU
));
13063 do_neon_addsub_if_i (void)
13065 if (try_vfp_nsyn (3, do_vfp_nsyn_add_sub
) == SUCCESS
)
13068 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13071 /* The "untyped" case can't happen. Do this to stop the "U" bit being
13072 affected if we specify unsigned args. */
13073 neon_dyadic_misc (NT_untyped
, N_IF_32
| N_I64
, 0);
13076 /* Swaps operands 1 and 2. If operand 1 (optional arg) was omitted, we want the
13078 V<op> A,B (A is operand 0, B is operand 2)
13083 so handle that case specially. */
13086 neon_exchange_operands (void)
13088 void *scratch
= alloca (sizeof (inst
.operands
[0]));
13089 if (inst
.operands
[1].present
)
13091 /* Swap operands[1] and operands[2]. */
13092 memcpy (scratch
, &inst
.operands
[1], sizeof (inst
.operands
[0]));
13093 inst
.operands
[1] = inst
.operands
[2];
13094 memcpy (&inst
.operands
[2], scratch
, sizeof (inst
.operands
[0]));
13098 inst
.operands
[1] = inst
.operands
[2];
13099 inst
.operands
[2] = inst
.operands
[0];
13104 neon_compare (unsigned regtypes
, unsigned immtypes
, int invert
)
13106 if (inst
.operands
[2].isreg
)
13109 neon_exchange_operands ();
13110 neon_dyadic_misc (NT_unsigned
, regtypes
, N_SIZ
);
13114 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
13115 struct neon_type_el et
= neon_check_type (2, rs
,
13116 N_EQK
| N_SIZ
, immtypes
| N_KEY
);
13118 NEON_ENCODE (IMMED
, inst
);
13119 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13120 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13121 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13122 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13123 inst
.instruction
|= neon_quad (rs
) << 6;
13124 inst
.instruction
|= (et
.type
== NT_float
) << 10;
13125 inst
.instruction
|= neon_logbits (et
.size
) << 18;
13127 neon_dp_fixup (&inst
);
13134 neon_compare (N_SUF_32
, N_S8
| N_S16
| N_S32
| N_F32
, FALSE
);
13138 do_neon_cmp_inv (void)
13140 neon_compare (N_SUF_32
, N_S8
| N_S16
| N_S32
| N_F32
, TRUE
);
13146 neon_compare (N_IF_32
, N_IF_32
, FALSE
);
13149 /* For multiply instructions, we have the possibility of 16-bit or 32-bit
13150 scalars, which are encoded in 5 bits, M : Rm.
13151 For 16-bit scalars, the register is encoded in Rm[2:0] and the index in
13152 M:Rm[3], and for 32-bit scalars, the register is encoded in Rm[3:0] and the
13156 neon_scalar_for_mul (unsigned scalar
, unsigned elsize
)
13158 unsigned regno
= NEON_SCALAR_REG (scalar
);
13159 unsigned elno
= NEON_SCALAR_INDEX (scalar
);
13164 if (regno
> 7 || elno
> 3)
13166 return regno
| (elno
<< 3);
13169 if (regno
> 15 || elno
> 1)
13171 return regno
| (elno
<< 4);
13175 first_error (_("scalar out of range for multiply instruction"));
13181 /* Encode multiply / multiply-accumulate scalar instructions. */
13184 neon_mul_mac (struct neon_type_el et
, int ubit
)
13188 /* Give a more helpful error message if we have an invalid type. */
13189 if (et
.type
== NT_invtype
)
13192 scalar
= neon_scalar_for_mul (inst
.operands
[2].reg
, et
.size
);
13193 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13194 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13195 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
13196 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
13197 inst
.instruction
|= LOW4 (scalar
);
13198 inst
.instruction
|= HI1 (scalar
) << 5;
13199 inst
.instruction
|= (et
.type
== NT_float
) << 8;
13200 inst
.instruction
|= neon_logbits (et
.size
) << 20;
13201 inst
.instruction
|= (ubit
!= 0) << 24;
13203 neon_dp_fixup (&inst
);
13207 do_neon_mac_maybe_scalar (void)
13209 if (try_vfp_nsyn (3, do_vfp_nsyn_mla_mls
) == SUCCESS
)
13212 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13215 if (inst
.operands
[2].isscalar
)
13217 enum neon_shape rs
= neon_select_shape (NS_DDS
, NS_QQS
, NS_NULL
);
13218 struct neon_type_el et
= neon_check_type (3, rs
,
13219 N_EQK
, N_EQK
, N_I16
| N_I32
| N_F32
| N_KEY
);
13220 NEON_ENCODE (SCALAR
, inst
);
13221 neon_mul_mac (et
, neon_quad (rs
));
13225 /* The "untyped" case can't happen. Do this to stop the "U" bit being
13226 affected if we specify unsigned args. */
13227 neon_dyadic_misc (NT_untyped
, N_IF_32
, 0);
13232 do_neon_fmac (void)
13234 if (try_vfp_nsyn (3, do_vfp_nsyn_fma_fms
) == SUCCESS
)
13237 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13240 neon_dyadic_misc (NT_untyped
, N_IF_32
, 0);
13246 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
13247 struct neon_type_el et
= neon_check_type (3, rs
,
13248 N_EQK
, N_EQK
, N_8
| N_16
| N_32
| N_KEY
);
13249 neon_three_same (neon_quad (rs
), 0, et
.size
);
13252 /* VMUL with 3 registers allows the P8 type. The scalar version supports the
13253 same types as the MAC equivalents. The polynomial type for this instruction
13254 is encoded the same as the integer type. */
13259 if (try_vfp_nsyn (3, do_vfp_nsyn_mul
) == SUCCESS
)
13262 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13265 if (inst
.operands
[2].isscalar
)
13266 do_neon_mac_maybe_scalar ();
13268 neon_dyadic_misc (NT_poly
, N_I8
| N_I16
| N_I32
| N_F32
| N_P8
, 0);
13272 do_neon_qdmulh (void)
13274 if (inst
.operands
[2].isscalar
)
13276 enum neon_shape rs
= neon_select_shape (NS_DDS
, NS_QQS
, 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 (SCALAR
, inst
);
13280 neon_mul_mac (et
, neon_quad (rs
));
13284 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
13285 struct neon_type_el et
= neon_check_type (3, rs
,
13286 N_EQK
, N_EQK
, N_S16
| N_S32
| N_KEY
);
13287 NEON_ENCODE (INTEGER
, inst
);
13288 /* The U bit (rounding) comes from bit mask. */
13289 neon_three_same (neon_quad (rs
), 0, et
.size
);
13294 do_neon_fcmp_absolute (void)
13296 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
13297 neon_check_type (3, rs
, N_EQK
, N_EQK
, N_F32
| N_KEY
);
13298 /* Size field comes from bit mask. */
13299 neon_three_same (neon_quad (rs
), 1, -1);
13303 do_neon_fcmp_absolute_inv (void)
13305 neon_exchange_operands ();
13306 do_neon_fcmp_absolute ();
13310 do_neon_step (void)
13312 enum neon_shape rs
= neon_select_shape (NS_DDD
, NS_QQQ
, NS_NULL
);
13313 neon_check_type (3, rs
, N_EQK
, N_EQK
, N_F32
| N_KEY
);
13314 neon_three_same (neon_quad (rs
), 0, -1);
13318 do_neon_abs_neg (void)
13320 enum neon_shape rs
;
13321 struct neon_type_el et
;
13323 if (try_vfp_nsyn (2, do_vfp_nsyn_abs_neg
) == SUCCESS
)
13326 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13329 rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
13330 et
= neon_check_type (2, rs
, N_EQK
, N_S8
| N_S16
| N_S32
| N_F32
| N_KEY
);
13332 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13333 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13334 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13335 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13336 inst
.instruction
|= neon_quad (rs
) << 6;
13337 inst
.instruction
|= (et
.type
== NT_float
) << 10;
13338 inst
.instruction
|= neon_logbits (et
.size
) << 18;
13340 neon_dp_fixup (&inst
);
13346 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
13347 struct neon_type_el et
= neon_check_type (2, rs
,
13348 N_EQK
, N_8
| N_16
| N_32
| N_64
| N_KEY
);
13349 int imm
= inst
.operands
[2].imm
;
13350 constraint (imm
< 0 || (unsigned)imm
>= et
.size
,
13351 _("immediate out of range for insert"));
13352 neon_imm_shift (FALSE
, 0, neon_quad (rs
), et
, imm
);
13358 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
13359 struct neon_type_el et
= neon_check_type (2, rs
,
13360 N_EQK
, N_8
| N_16
| N_32
| N_64
| N_KEY
);
13361 int imm
= inst
.operands
[2].imm
;
13362 constraint (imm
< 1 || (unsigned)imm
> et
.size
,
13363 _("immediate out of range for insert"));
13364 neon_imm_shift (FALSE
, 0, neon_quad (rs
), et
, et
.size
- imm
);
13368 do_neon_qshlu_imm (void)
13370 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
13371 struct neon_type_el et
= neon_check_type (2, rs
,
13372 N_EQK
| N_UNS
, N_S8
| N_S16
| N_S32
| N_S64
| N_KEY
);
13373 int imm
= inst
.operands
[2].imm
;
13374 constraint (imm
< 0 || (unsigned)imm
>= et
.size
,
13375 _("immediate out of range for shift"));
13376 /* Only encodes the 'U present' variant of the instruction.
13377 In this case, signed types have OP (bit 8) set to 0.
13378 Unsigned types have OP set to 1. */
13379 inst
.instruction
|= (et
.type
== NT_unsigned
) << 8;
13380 /* The rest of the bits are the same as other immediate shifts. */
13381 neon_imm_shift (FALSE
, 0, neon_quad (rs
), et
, imm
);
13385 do_neon_qmovn (void)
13387 struct neon_type_el et
= neon_check_type (2, NS_DQ
,
13388 N_EQK
| N_HLF
, N_SU_16_64
| N_KEY
);
13389 /* Saturating move where operands can be signed or unsigned, and the
13390 destination has the same signedness. */
13391 NEON_ENCODE (INTEGER
, inst
);
13392 if (et
.type
== NT_unsigned
)
13393 inst
.instruction
|= 0xc0;
13395 inst
.instruction
|= 0x80;
13396 neon_two_same (0, 1, et
.size
/ 2);
13400 do_neon_qmovun (void)
13402 struct neon_type_el et
= neon_check_type (2, NS_DQ
,
13403 N_EQK
| N_HLF
| N_UNS
, N_S16
| N_S32
| N_S64
| N_KEY
);
13404 /* Saturating move with unsigned results. Operands must be signed. */
13405 NEON_ENCODE (INTEGER
, inst
);
13406 neon_two_same (0, 1, et
.size
/ 2);
13410 do_neon_rshift_sat_narrow (void)
13412 /* FIXME: Types for narrowing. If operands are signed, results can be signed
13413 or unsigned. If operands are unsigned, results must also be unsigned. */
13414 struct neon_type_el et
= neon_check_type (2, NS_DQI
,
13415 N_EQK
| N_HLF
, N_SU_16_64
| N_KEY
);
13416 int imm
= inst
.operands
[2].imm
;
13417 /* This gets the bounds check, size encoding and immediate bits calculation
13421 /* VQ{R}SHRN.I<size> <Dd>, <Qm>, #0 is a synonym for
13422 VQMOVN.I<size> <Dd>, <Qm>. */
13425 inst
.operands
[2].present
= 0;
13426 inst
.instruction
= N_MNEM_vqmovn
;
13431 constraint (imm
< 1 || (unsigned)imm
> et
.size
,
13432 _("immediate out of range"));
13433 neon_imm_shift (TRUE
, et
.type
== NT_unsigned
, 0, et
, et
.size
- imm
);
13437 do_neon_rshift_sat_narrow_u (void)
13439 /* FIXME: Types for narrowing. If operands are signed, results can be signed
13440 or unsigned. If operands are unsigned, results must also be unsigned. */
13441 struct neon_type_el et
= neon_check_type (2, NS_DQI
,
13442 N_EQK
| N_HLF
| N_UNS
, N_S16
| N_S32
| N_S64
| N_KEY
);
13443 int imm
= inst
.operands
[2].imm
;
13444 /* This gets the bounds check, size encoding and immediate bits calculation
13448 /* VQSHRUN.I<size> <Dd>, <Qm>, #0 is a synonym for
13449 VQMOVUN.I<size> <Dd>, <Qm>. */
13452 inst
.operands
[2].present
= 0;
13453 inst
.instruction
= N_MNEM_vqmovun
;
13458 constraint (imm
< 1 || (unsigned)imm
> et
.size
,
13459 _("immediate out of range"));
13460 /* FIXME: The manual is kind of unclear about what value U should have in
13461 VQ{R}SHRUN instructions, but U=0, op=0 definitely encodes VRSHR, so it
13463 neon_imm_shift (TRUE
, 1, 0, et
, et
.size
- imm
);
13467 do_neon_movn (void)
13469 struct neon_type_el et
= neon_check_type (2, NS_DQ
,
13470 N_EQK
| N_HLF
, N_I16
| N_I32
| N_I64
| N_KEY
);
13471 NEON_ENCODE (INTEGER
, inst
);
13472 neon_two_same (0, 1, et
.size
/ 2);
13476 do_neon_rshift_narrow (void)
13478 struct neon_type_el et
= neon_check_type (2, NS_DQI
,
13479 N_EQK
| N_HLF
, N_I16
| N_I32
| N_I64
| N_KEY
);
13480 int imm
= inst
.operands
[2].imm
;
13481 /* This gets the bounds check, size encoding and immediate bits calculation
13485 /* If immediate is zero then we are a pseudo-instruction for
13486 VMOVN.I<size> <Dd>, <Qm> */
13489 inst
.operands
[2].present
= 0;
13490 inst
.instruction
= N_MNEM_vmovn
;
13495 constraint (imm
< 1 || (unsigned)imm
> et
.size
,
13496 _("immediate out of range for narrowing operation"));
13497 neon_imm_shift (FALSE
, 0, 0, et
, et
.size
- imm
);
13501 do_neon_shll (void)
13503 /* FIXME: Type checking when lengthening. */
13504 struct neon_type_el et
= neon_check_type (2, NS_QDI
,
13505 N_EQK
| N_DBL
, N_I8
| N_I16
| N_I32
| N_KEY
);
13506 unsigned imm
= inst
.operands
[2].imm
;
13508 if (imm
== et
.size
)
13510 /* Maximum shift variant. */
13511 NEON_ENCODE (INTEGER
, inst
);
13512 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13513 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13514 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13515 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13516 inst
.instruction
|= neon_logbits (et
.size
) << 18;
13518 neon_dp_fixup (&inst
);
13522 /* A more-specific type check for non-max versions. */
13523 et
= neon_check_type (2, NS_QDI
,
13524 N_EQK
| N_DBL
, N_SU_32
| N_KEY
);
13525 NEON_ENCODE (IMMED
, inst
);
13526 neon_imm_shift (TRUE
, et
.type
== NT_unsigned
, 0, et
, imm
);
13530 /* Check the various types for the VCVT instruction, and return which version
13531 the current instruction is. */
13534 neon_cvt_flavour (enum neon_shape rs
)
13536 #define CVT_VAR(C,X,Y) \
13537 et = neon_check_type (2, rs, whole_reg | (X), whole_reg | (Y)); \
13538 if (et.type != NT_invtype) \
13540 inst.error = NULL; \
13543 struct neon_type_el et
;
13544 unsigned whole_reg
= (rs
== NS_FFI
|| rs
== NS_FD
|| rs
== NS_DF
13545 || rs
== NS_FF
) ? N_VFP
: 0;
13546 /* The instruction versions which take an immediate take one register
13547 argument, which is extended to the width of the full register. Thus the
13548 "source" and "destination" registers must have the same width. Hack that
13549 here by making the size equal to the key (wider, in this case) operand. */
13550 unsigned key
= (rs
== NS_QQI
|| rs
== NS_DDI
|| rs
== NS_FFI
) ? N_KEY
: 0;
13552 CVT_VAR (0, N_S32
, N_F32
);
13553 CVT_VAR (1, N_U32
, N_F32
);
13554 CVT_VAR (2, N_F32
, N_S32
);
13555 CVT_VAR (3, N_F32
, N_U32
);
13556 /* Half-precision conversions. */
13557 CVT_VAR (4, N_F32
, N_F16
);
13558 CVT_VAR (5, N_F16
, N_F32
);
13562 /* VFP instructions. */
13563 CVT_VAR (6, N_F32
, N_F64
);
13564 CVT_VAR (7, N_F64
, N_F32
);
13565 CVT_VAR (8, N_S32
, N_F64
| key
);
13566 CVT_VAR (9, N_U32
, N_F64
| key
);
13567 CVT_VAR (10, N_F64
| key
, N_S32
);
13568 CVT_VAR (11, N_F64
| key
, N_U32
);
13569 /* VFP instructions with bitshift. */
13570 CVT_VAR (12, N_F32
| key
, N_S16
);
13571 CVT_VAR (13, N_F32
| key
, N_U16
);
13572 CVT_VAR (14, N_F64
| key
, N_S16
);
13573 CVT_VAR (15, N_F64
| key
, N_U16
);
13574 CVT_VAR (16, N_S16
, N_F32
| key
);
13575 CVT_VAR (17, N_U16
, N_F32
| key
);
13576 CVT_VAR (18, N_S16
, N_F64
| key
);
13577 CVT_VAR (19, N_U16
, N_F64
| key
);
13583 /* Neon-syntax VFP conversions. */
13586 do_vfp_nsyn_cvt (enum neon_shape rs
, int flavour
)
13588 const char *opname
= 0;
13590 if (rs
== NS_DDI
|| rs
== NS_QQI
|| rs
== NS_FFI
)
13592 /* Conversions with immediate bitshift. */
13593 const char *enc
[] =
13617 if (flavour
>= 0 && flavour
< (int) ARRAY_SIZE (enc
))
13619 opname
= enc
[flavour
];
13620 constraint (inst
.operands
[0].reg
!= inst
.operands
[1].reg
,
13621 _("operands 0 and 1 must be the same register"));
13622 inst
.operands
[1] = inst
.operands
[2];
13623 memset (&inst
.operands
[2], '\0', sizeof (inst
.operands
[2]));
13628 /* Conversions without bitshift. */
13629 const char *enc
[] =
13645 if (flavour
>= 0 && flavour
< (int) ARRAY_SIZE (enc
))
13646 opname
= enc
[flavour
];
13650 do_vfp_nsyn_opcode (opname
);
13654 do_vfp_nsyn_cvtz (void)
13656 enum neon_shape rs
= neon_select_shape (NS_FF
, NS_FD
, NS_NULL
);
13657 int flavour
= neon_cvt_flavour (rs
);
13658 const char *enc
[] =
13672 if (flavour
>= 0 && flavour
< (int) ARRAY_SIZE (enc
) && enc
[flavour
])
13673 do_vfp_nsyn_opcode (enc
[flavour
]);
13677 do_neon_cvt_1 (bfd_boolean round_to_zero ATTRIBUTE_UNUSED
)
13679 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_FFI
, NS_DD
, NS_QQ
,
13680 NS_FD
, NS_DF
, NS_FF
, NS_QD
, NS_DQ
, NS_NULL
);
13681 int flavour
= neon_cvt_flavour (rs
);
13683 /* PR11109: Handle round-to-zero for VCVT conversions. */
13685 && ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_arch_vfp_v2
)
13686 && (flavour
== 0 || flavour
== 1 || flavour
== 8 || flavour
== 9)
13687 && (rs
== NS_FD
|| rs
== NS_FF
))
13689 do_vfp_nsyn_cvtz ();
13693 /* VFP rather than Neon conversions. */
13696 do_vfp_nsyn_cvt (rs
, flavour
);
13706 unsigned enctab
[] = { 0x0000100, 0x1000100, 0x0, 0x1000000 };
13708 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13711 /* Fixed-point conversion with #0 immediate is encoded as an
13712 integer conversion. */
13713 if (inst
.operands
[2].present
&& inst
.operands
[2].imm
== 0)
13715 immbits
= 32 - inst
.operands
[2].imm
;
13716 NEON_ENCODE (IMMED
, inst
);
13718 inst
.instruction
|= enctab
[flavour
];
13719 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13720 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13721 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13722 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13723 inst
.instruction
|= neon_quad (rs
) << 6;
13724 inst
.instruction
|= 1 << 21;
13725 inst
.instruction
|= immbits
<< 16;
13727 neon_dp_fixup (&inst
);
13735 unsigned enctab
[] = { 0x100, 0x180, 0x0, 0x080 };
13737 NEON_ENCODE (INTEGER
, inst
);
13739 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
13743 inst
.instruction
|= enctab
[flavour
];
13745 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13746 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13747 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13748 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13749 inst
.instruction
|= neon_quad (rs
) << 6;
13750 inst
.instruction
|= 2 << 18;
13752 neon_dp_fixup (&inst
);
13756 /* Half-precision conversions for Advanced SIMD -- neon. */
13761 && (inst
.vectype
.el
[0].size
!= 16 || inst
.vectype
.el
[1].size
!= 32))
13763 as_bad (_("operand size must match register width"));
13768 && ((inst
.vectype
.el
[0].size
!= 32 || inst
.vectype
.el
[1].size
!= 16)))
13770 as_bad (_("operand size must match register width"));
13775 inst
.instruction
= 0x3b60600;
13777 inst
.instruction
= 0x3b60700;
13779 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13780 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13781 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13782 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13783 neon_dp_fixup (&inst
);
13787 /* Some VFP conversions go here (s32 <-> f32, u32 <-> f32). */
13788 do_vfp_nsyn_cvt (rs
, flavour
);
13793 do_neon_cvtr (void)
13795 do_neon_cvt_1 (FALSE
);
13801 do_neon_cvt_1 (TRUE
);
13805 do_neon_cvtb (void)
13807 inst
.instruction
= 0xeb20a40;
13809 /* The sizes are attached to the mnemonic. */
13810 if (inst
.vectype
.el
[0].type
!= NT_invtype
13811 && inst
.vectype
.el
[0].size
== 16)
13812 inst
.instruction
|= 0x00010000;
13814 /* Programmer's syntax: the sizes are attached to the operands. */
13815 else if (inst
.operands
[0].vectype
.type
!= NT_invtype
13816 && inst
.operands
[0].vectype
.size
== 16)
13817 inst
.instruction
|= 0x00010000;
13819 encode_arm_vfp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
13820 encode_arm_vfp_reg (inst
.operands
[1].reg
, VFP_REG_Sm
);
13821 do_vfp_cond_or_thumb ();
13826 do_neon_cvtt (void)
13829 inst
.instruction
|= 0x80;
13833 neon_move_immediate (void)
13835 enum neon_shape rs
= neon_select_shape (NS_DI
, NS_QI
, NS_NULL
);
13836 struct neon_type_el et
= neon_check_type (2, rs
,
13837 N_I8
| N_I16
| N_I32
| N_I64
| N_F32
| N_KEY
, N_EQK
);
13838 unsigned immlo
, immhi
= 0, immbits
;
13839 int op
, cmode
, float_p
;
13841 constraint (et
.type
== NT_invtype
,
13842 _("operand size must be specified for immediate VMOV"));
13844 /* We start out as an MVN instruction if OP = 1, MOV otherwise. */
13845 op
= (inst
.instruction
& (1 << 5)) != 0;
13847 immlo
= inst
.operands
[1].imm
;
13848 if (inst
.operands
[1].regisimm
)
13849 immhi
= inst
.operands
[1].reg
;
13851 constraint (et
.size
< 32 && (immlo
& ~((1 << et
.size
) - 1)) != 0,
13852 _("immediate has bits set outside the operand size"));
13854 float_p
= inst
.operands
[1].immisfloat
;
13856 if ((cmode
= neon_cmode_for_move_imm (immlo
, immhi
, float_p
, &immbits
, &op
,
13857 et
.size
, et
.type
)) == FAIL
)
13859 /* Invert relevant bits only. */
13860 neon_invert_size (&immlo
, &immhi
, et
.size
);
13861 /* Flip from VMOV/VMVN to VMVN/VMOV. Some immediate types are unavailable
13862 with one or the other; those cases are caught by
13863 neon_cmode_for_move_imm. */
13865 if ((cmode
= neon_cmode_for_move_imm (immlo
, immhi
, float_p
, &immbits
,
13866 &op
, et
.size
, et
.type
)) == FAIL
)
13868 first_error (_("immediate out of range"));
13873 inst
.instruction
&= ~(1 << 5);
13874 inst
.instruction
|= op
<< 5;
13876 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13877 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13878 inst
.instruction
|= neon_quad (rs
) << 6;
13879 inst
.instruction
|= cmode
<< 8;
13881 neon_write_immbits (immbits
);
13887 if (inst
.operands
[1].isreg
)
13889 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
13891 NEON_ENCODE (INTEGER
, inst
);
13892 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13893 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13894 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
13895 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
13896 inst
.instruction
|= neon_quad (rs
) << 6;
13900 NEON_ENCODE (IMMED
, inst
);
13901 neon_move_immediate ();
13904 neon_dp_fixup (&inst
);
13907 /* Encode instructions of form:
13909 |28/24|23|22|21 20|19 16|15 12|11 8|7|6|5|4|3 0|
13910 | U |x |D |size | Rn | Rd |x x x x|N|x|M|x| Rm | */
13913 neon_mixed_length (struct neon_type_el et
, unsigned size
)
13915 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
13916 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
13917 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
13918 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
13919 inst
.instruction
|= LOW4 (inst
.operands
[2].reg
);
13920 inst
.instruction
|= HI1 (inst
.operands
[2].reg
) << 5;
13921 inst
.instruction
|= (et
.type
== NT_unsigned
) << 24;
13922 inst
.instruction
|= neon_logbits (size
) << 20;
13924 neon_dp_fixup (&inst
);
13928 do_neon_dyadic_long (void)
13930 /* FIXME: Type checking for lengthening op. */
13931 struct neon_type_el et
= neon_check_type (3, NS_QDD
,
13932 N_EQK
| N_DBL
, N_EQK
, N_SU_32
| N_KEY
);
13933 neon_mixed_length (et
, et
.size
);
13937 do_neon_abal (void)
13939 struct neon_type_el et
= neon_check_type (3, NS_QDD
,
13940 N_EQK
| N_INT
| N_DBL
, N_EQK
, N_SU_32
| N_KEY
);
13941 neon_mixed_length (et
, et
.size
);
13945 neon_mac_reg_scalar_long (unsigned regtypes
, unsigned scalartypes
)
13947 if (inst
.operands
[2].isscalar
)
13949 struct neon_type_el et
= neon_check_type (3, NS_QDS
,
13950 N_EQK
| N_DBL
, N_EQK
, regtypes
| N_KEY
);
13951 NEON_ENCODE (SCALAR
, inst
);
13952 neon_mul_mac (et
, et
.type
== NT_unsigned
);
13956 struct neon_type_el et
= neon_check_type (3, NS_QDD
,
13957 N_EQK
| N_DBL
, N_EQK
, scalartypes
| N_KEY
);
13958 NEON_ENCODE (INTEGER
, inst
);
13959 neon_mixed_length (et
, et
.size
);
13964 do_neon_mac_maybe_scalar_long (void)
13966 neon_mac_reg_scalar_long (N_S16
| N_S32
| N_U16
| N_U32
, N_SU_32
);
13970 do_neon_dyadic_wide (void)
13972 struct neon_type_el et
= neon_check_type (3, NS_QQD
,
13973 N_EQK
| N_DBL
, N_EQK
| N_DBL
, N_SU_32
| N_KEY
);
13974 neon_mixed_length (et
, et
.size
);
13978 do_neon_dyadic_narrow (void)
13980 struct neon_type_el et
= neon_check_type (3, NS_QDD
,
13981 N_EQK
| N_DBL
, N_EQK
, N_I16
| N_I32
| N_I64
| N_KEY
);
13982 /* Operand sign is unimportant, and the U bit is part of the opcode,
13983 so force the operand type to integer. */
13984 et
.type
= NT_integer
;
13985 neon_mixed_length (et
, et
.size
/ 2);
13989 do_neon_mul_sat_scalar_long (void)
13991 neon_mac_reg_scalar_long (N_S16
| N_S32
, N_S16
| N_S32
);
13995 do_neon_vmull (void)
13997 if (inst
.operands
[2].isscalar
)
13998 do_neon_mac_maybe_scalar_long ();
14001 struct neon_type_el et
= neon_check_type (3, NS_QDD
,
14002 N_EQK
| N_DBL
, N_EQK
, N_SU_32
| N_P8
| N_KEY
);
14003 if (et
.type
== NT_poly
)
14004 NEON_ENCODE (POLY
, inst
);
14006 NEON_ENCODE (INTEGER
, inst
);
14007 /* For polynomial encoding, size field must be 0b00 and the U bit must be
14008 zero. Should be OK as-is. */
14009 neon_mixed_length (et
, et
.size
);
14016 enum neon_shape rs
= neon_select_shape (NS_DDDI
, NS_QQQI
, NS_NULL
);
14017 struct neon_type_el et
= neon_check_type (3, rs
,
14018 N_EQK
, N_EQK
, N_8
| N_16
| N_32
| N_64
| N_KEY
);
14019 unsigned imm
= (inst
.operands
[3].imm
* et
.size
) / 8;
14021 constraint (imm
>= (unsigned) (neon_quad (rs
) ? 16 : 8),
14022 _("shift out of range"));
14023 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
14024 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
14025 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
14026 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
14027 inst
.instruction
|= LOW4 (inst
.operands
[2].reg
);
14028 inst
.instruction
|= HI1 (inst
.operands
[2].reg
) << 5;
14029 inst
.instruction
|= neon_quad (rs
) << 6;
14030 inst
.instruction
|= imm
<< 8;
14032 neon_dp_fixup (&inst
);
14038 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14039 struct neon_type_el et
= neon_check_type (2, rs
,
14040 N_EQK
, N_8
| N_16
| N_32
| N_KEY
);
14041 unsigned op
= (inst
.instruction
>> 7) & 3;
14042 /* N (width of reversed regions) is encoded as part of the bitmask. We
14043 extract it here to check the elements to be reversed are smaller.
14044 Otherwise we'd get a reserved instruction. */
14045 unsigned elsize
= (op
== 2) ? 16 : (op
== 1) ? 32 : (op
== 0) ? 64 : 0;
14046 gas_assert (elsize
!= 0);
14047 constraint (et
.size
>= elsize
,
14048 _("elements must be smaller than reversal region"));
14049 neon_two_same (neon_quad (rs
), 1, et
.size
);
14055 if (inst
.operands
[1].isscalar
)
14057 enum neon_shape rs
= neon_select_shape (NS_DS
, NS_QS
, NS_NULL
);
14058 struct neon_type_el et
= neon_check_type (2, rs
,
14059 N_EQK
, N_8
| N_16
| N_32
| N_KEY
);
14060 unsigned sizebits
= et
.size
>> 3;
14061 unsigned dm
= NEON_SCALAR_REG (inst
.operands
[1].reg
);
14062 int logsize
= neon_logbits (et
.size
);
14063 unsigned x
= NEON_SCALAR_INDEX (inst
.operands
[1].reg
) << logsize
;
14065 if (vfp_or_neon_is_neon (NEON_CHECK_CC
) == FAIL
)
14068 NEON_ENCODE (SCALAR
, inst
);
14069 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
14070 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
14071 inst
.instruction
|= LOW4 (dm
);
14072 inst
.instruction
|= HI1 (dm
) << 5;
14073 inst
.instruction
|= neon_quad (rs
) << 6;
14074 inst
.instruction
|= x
<< 17;
14075 inst
.instruction
|= sizebits
<< 16;
14077 neon_dp_fixup (&inst
);
14081 enum neon_shape rs
= neon_select_shape (NS_DR
, NS_QR
, NS_NULL
);
14082 struct neon_type_el et
= neon_check_type (2, rs
,
14083 N_8
| N_16
| N_32
| N_KEY
, N_EQK
);
14084 /* Duplicate ARM register to lanes of vector. */
14085 NEON_ENCODE (ARMREG
, inst
);
14088 case 8: inst
.instruction
|= 0x400000; break;
14089 case 16: inst
.instruction
|= 0x000020; break;
14090 case 32: inst
.instruction
|= 0x000000; break;
14093 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 12;
14094 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 16;
14095 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 7;
14096 inst
.instruction
|= neon_quad (rs
) << 21;
14097 /* The encoding for this instruction is identical for the ARM and Thumb
14098 variants, except for the condition field. */
14099 do_vfp_cond_or_thumb ();
14103 /* VMOV has particularly many variations. It can be one of:
14104 0. VMOV<c><q> <Qd>, <Qm>
14105 1. VMOV<c><q> <Dd>, <Dm>
14106 (Register operations, which are VORR with Rm = Rn.)
14107 2. VMOV<c><q>.<dt> <Qd>, #<imm>
14108 3. VMOV<c><q>.<dt> <Dd>, #<imm>
14110 4. VMOV<c><q>.<size> <Dn[x]>, <Rd>
14111 (ARM register to scalar.)
14112 5. VMOV<c><q> <Dm>, <Rd>, <Rn>
14113 (Two ARM registers to vector.)
14114 6. VMOV<c><q>.<dt> <Rd>, <Dn[x]>
14115 (Scalar to ARM register.)
14116 7. VMOV<c><q> <Rd>, <Rn>, <Dm>
14117 (Vector to two ARM registers.)
14118 8. VMOV.F32 <Sd>, <Sm>
14119 9. VMOV.F64 <Dd>, <Dm>
14120 (VFP register moves.)
14121 10. VMOV.F32 <Sd>, #imm
14122 11. VMOV.F64 <Dd>, #imm
14123 (VFP float immediate load.)
14124 12. VMOV <Rd>, <Sm>
14125 (VFP single to ARM reg.)
14126 13. VMOV <Sd>, <Rm>
14127 (ARM reg to VFP single.)
14128 14. VMOV <Rd>, <Re>, <Sn>, <Sm>
14129 (Two ARM regs to two VFP singles.)
14130 15. VMOV <Sd>, <Se>, <Rn>, <Rm>
14131 (Two VFP singles to two ARM regs.)
14133 These cases can be disambiguated using neon_select_shape, except cases 1/9
14134 and 3/11 which depend on the operand type too.
14136 All the encoded bits are hardcoded by this function.
14138 Cases 4, 6 may be used with VFPv1 and above (only 32-bit transfers!).
14139 Cases 5, 7 may be used with VFPv2 and above.
14141 FIXME: Some of the checking may be a bit sloppy (in a couple of cases you
14142 can specify a type where it doesn't make sense to, and is ignored). */
14147 enum neon_shape rs
= neon_select_shape (NS_RRFF
, NS_FFRR
, NS_DRR
, NS_RRD
,
14148 NS_QQ
, NS_DD
, NS_QI
, NS_DI
, NS_SR
, NS_RS
, NS_FF
, NS_FI
, NS_RF
, NS_FR
,
14150 struct neon_type_el et
;
14151 const char *ldconst
= 0;
14155 case NS_DD
: /* case 1/9. */
14156 et
= neon_check_type (2, rs
, N_EQK
, N_F64
| N_KEY
);
14157 /* It is not an error here if no type is given. */
14159 if (et
.type
== NT_float
&& et
.size
== 64)
14161 do_vfp_nsyn_opcode ("fcpyd");
14164 /* fall through. */
14166 case NS_QQ
: /* case 0/1. */
14168 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
14170 /* The architecture manual I have doesn't explicitly state which
14171 value the U bit should have for register->register moves, but
14172 the equivalent VORR instruction has U = 0, so do that. */
14173 inst
.instruction
= 0x0200110;
14174 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
14175 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
14176 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
);
14177 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 5;
14178 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
14179 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
14180 inst
.instruction
|= neon_quad (rs
) << 6;
14182 neon_dp_fixup (&inst
);
14186 case NS_DI
: /* case 3/11. */
14187 et
= neon_check_type (2, rs
, N_EQK
, N_F64
| N_KEY
);
14189 if (et
.type
== NT_float
&& et
.size
== 64)
14191 /* case 11 (fconstd). */
14192 ldconst
= "fconstd";
14193 goto encode_fconstd
;
14195 /* fall through. */
14197 case NS_QI
: /* case 2/3. */
14198 if (vfp_or_neon_is_neon (NEON_CHECK_CC
| NEON_CHECK_ARCH
) == FAIL
)
14200 inst
.instruction
= 0x0800010;
14201 neon_move_immediate ();
14202 neon_dp_fixup (&inst
);
14205 case NS_SR
: /* case 4. */
14207 unsigned bcdebits
= 0;
14209 unsigned dn
= NEON_SCALAR_REG (inst
.operands
[0].reg
);
14210 unsigned x
= NEON_SCALAR_INDEX (inst
.operands
[0].reg
);
14212 et
= neon_check_type (2, NS_NULL
, N_8
| N_16
| N_32
| N_KEY
, N_EQK
);
14213 logsize
= neon_logbits (et
.size
);
14215 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_vfp_ext_v1
),
14217 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_neon_ext_v1
)
14218 && et
.size
!= 32, _(BAD_FPU
));
14219 constraint (et
.type
== NT_invtype
, _("bad type for scalar"));
14220 constraint (x
>= 64 / et
.size
, _("scalar index out of range"));
14224 case 8: bcdebits
= 0x8; break;
14225 case 16: bcdebits
= 0x1; break;
14226 case 32: bcdebits
= 0x0; break;
14230 bcdebits
|= x
<< logsize
;
14232 inst
.instruction
= 0xe000b10;
14233 do_vfp_cond_or_thumb ();
14234 inst
.instruction
|= LOW4 (dn
) << 16;
14235 inst
.instruction
|= HI1 (dn
) << 7;
14236 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
14237 inst
.instruction
|= (bcdebits
& 3) << 5;
14238 inst
.instruction
|= (bcdebits
>> 2) << 21;
14242 case NS_DRR
: /* case 5 (fmdrr). */
14243 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_vfp_ext_v2
),
14246 inst
.instruction
= 0xc400b10;
14247 do_vfp_cond_or_thumb ();
14248 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
);
14249 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 5;
14250 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
14251 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
14254 case NS_RS
: /* case 6. */
14257 unsigned dn
= NEON_SCALAR_REG (inst
.operands
[1].reg
);
14258 unsigned x
= NEON_SCALAR_INDEX (inst
.operands
[1].reg
);
14259 unsigned abcdebits
= 0;
14261 et
= neon_check_type (2, NS_NULL
,
14262 N_EQK
, N_S8
| N_S16
| N_U8
| N_U16
| N_32
| N_KEY
);
14263 logsize
= neon_logbits (et
.size
);
14265 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_vfp_ext_v1
),
14267 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_neon_ext_v1
)
14268 && et
.size
!= 32, _(BAD_FPU
));
14269 constraint (et
.type
== NT_invtype
, _("bad type for scalar"));
14270 constraint (x
>= 64 / et
.size
, _("scalar index out of range"));
14274 case 8: abcdebits
= (et
.type
== NT_signed
) ? 0x08 : 0x18; break;
14275 case 16: abcdebits
= (et
.type
== NT_signed
) ? 0x01 : 0x11; break;
14276 case 32: abcdebits
= 0x00; break;
14280 abcdebits
|= x
<< logsize
;
14281 inst
.instruction
= 0xe100b10;
14282 do_vfp_cond_or_thumb ();
14283 inst
.instruction
|= LOW4 (dn
) << 16;
14284 inst
.instruction
|= HI1 (dn
) << 7;
14285 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
14286 inst
.instruction
|= (abcdebits
& 3) << 5;
14287 inst
.instruction
|= (abcdebits
>> 2) << 21;
14291 case NS_RRD
: /* case 7 (fmrrd). */
14292 constraint (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_vfp_ext_v2
),
14295 inst
.instruction
= 0xc500b10;
14296 do_vfp_cond_or_thumb ();
14297 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
14298 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
14299 inst
.instruction
|= LOW4 (inst
.operands
[2].reg
);
14300 inst
.instruction
|= HI1 (inst
.operands
[2].reg
) << 5;
14303 case NS_FF
: /* case 8 (fcpys). */
14304 do_vfp_nsyn_opcode ("fcpys");
14307 case NS_FI
: /* case 10 (fconsts). */
14308 ldconst
= "fconsts";
14310 if (is_quarter_float (inst
.operands
[1].imm
))
14312 inst
.operands
[1].imm
= neon_qfloat_bits (inst
.operands
[1].imm
);
14313 do_vfp_nsyn_opcode (ldconst
);
14316 first_error (_("immediate out of range"));
14319 case NS_RF
: /* case 12 (fmrs). */
14320 do_vfp_nsyn_opcode ("fmrs");
14323 case NS_FR
: /* case 13 (fmsr). */
14324 do_vfp_nsyn_opcode ("fmsr");
14327 /* The encoders for the fmrrs and fmsrr instructions expect three operands
14328 (one of which is a list), but we have parsed four. Do some fiddling to
14329 make the operands what do_vfp_reg2_from_sp2 and do_vfp_sp2_from_reg2
14331 case NS_RRFF
: /* case 14 (fmrrs). */
14332 constraint (inst
.operands
[3].reg
!= inst
.operands
[2].reg
+ 1,
14333 _("VFP registers must be adjacent"));
14334 inst
.operands
[2].imm
= 2;
14335 memset (&inst
.operands
[3], '\0', sizeof (inst
.operands
[3]));
14336 do_vfp_nsyn_opcode ("fmrrs");
14339 case NS_FFRR
: /* case 15 (fmsrr). */
14340 constraint (inst
.operands
[1].reg
!= inst
.operands
[0].reg
+ 1,
14341 _("VFP registers must be adjacent"));
14342 inst
.operands
[1] = inst
.operands
[2];
14343 inst
.operands
[2] = inst
.operands
[3];
14344 inst
.operands
[0].imm
= 2;
14345 memset (&inst
.operands
[3], '\0', sizeof (inst
.operands
[3]));
14346 do_vfp_nsyn_opcode ("fmsrr");
14355 do_neon_rshift_round_imm (void)
14357 enum neon_shape rs
= neon_select_shape (NS_DDI
, NS_QQI
, NS_NULL
);
14358 struct neon_type_el et
= neon_check_type (2, rs
, N_EQK
, N_SU_ALL
| N_KEY
);
14359 int imm
= inst
.operands
[2].imm
;
14361 /* imm == 0 case is encoded as VMOV for V{R}SHR. */
14364 inst
.operands
[2].present
= 0;
14369 constraint (imm
< 1 || (unsigned)imm
> et
.size
,
14370 _("immediate out of range for shift"));
14371 neon_imm_shift (TRUE
, et
.type
== NT_unsigned
, neon_quad (rs
), et
,
14376 do_neon_movl (void)
14378 struct neon_type_el et
= neon_check_type (2, NS_QD
,
14379 N_EQK
| N_DBL
, N_SU_32
| N_KEY
);
14380 unsigned sizebits
= et
.size
>> 3;
14381 inst
.instruction
|= sizebits
<< 19;
14382 neon_two_same (0, et
.type
== NT_unsigned
, -1);
14388 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14389 struct neon_type_el et
= neon_check_type (2, rs
,
14390 N_EQK
, N_8
| N_16
| N_32
| N_KEY
);
14391 NEON_ENCODE (INTEGER
, inst
);
14392 neon_two_same (neon_quad (rs
), 1, et
.size
);
14396 do_neon_zip_uzp (void)
14398 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14399 struct neon_type_el et
= neon_check_type (2, rs
,
14400 N_EQK
, N_8
| N_16
| N_32
| N_KEY
);
14401 if (rs
== NS_DD
&& et
.size
== 32)
14403 /* Special case: encode as VTRN.32 <Dd>, <Dm>. */
14404 inst
.instruction
= N_MNEM_vtrn
;
14408 neon_two_same (neon_quad (rs
), 1, et
.size
);
14412 do_neon_sat_abs_neg (void)
14414 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14415 struct neon_type_el et
= neon_check_type (2, rs
,
14416 N_EQK
, N_S8
| N_S16
| N_S32
| N_KEY
);
14417 neon_two_same (neon_quad (rs
), 1, et
.size
);
14421 do_neon_pair_long (void)
14423 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14424 struct neon_type_el et
= neon_check_type (2, rs
, N_EQK
, N_SU_32
| N_KEY
);
14425 /* Unsigned is encoded in OP field (bit 7) for these instruction. */
14426 inst
.instruction
|= (et
.type
== NT_unsigned
) << 7;
14427 neon_two_same (neon_quad (rs
), 1, et
.size
);
14431 do_neon_recip_est (void)
14433 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14434 struct neon_type_el et
= neon_check_type (2, rs
,
14435 N_EQK
| N_FLT
, N_F32
| N_U32
| N_KEY
);
14436 inst
.instruction
|= (et
.type
== NT_float
) << 8;
14437 neon_two_same (neon_quad (rs
), 1, et
.size
);
14443 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14444 struct neon_type_el et
= neon_check_type (2, rs
,
14445 N_EQK
, N_S8
| N_S16
| N_S32
| N_KEY
);
14446 neon_two_same (neon_quad (rs
), 1, et
.size
);
14452 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14453 struct neon_type_el et
= neon_check_type (2, rs
,
14454 N_EQK
, N_I8
| N_I16
| N_I32
| N_KEY
);
14455 neon_two_same (neon_quad (rs
), 1, et
.size
);
14461 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14462 struct neon_type_el et
= neon_check_type (2, rs
,
14463 N_EQK
| N_INT
, N_8
| N_KEY
);
14464 neon_two_same (neon_quad (rs
), 1, et
.size
);
14470 enum neon_shape rs
= neon_select_shape (NS_DD
, NS_QQ
, NS_NULL
);
14471 neon_two_same (neon_quad (rs
), 1, -1);
14475 do_neon_tbl_tbx (void)
14477 unsigned listlenbits
;
14478 neon_check_type (3, NS_DLD
, N_EQK
, N_EQK
, N_8
| N_KEY
);
14480 if (inst
.operands
[1].imm
< 1 || inst
.operands
[1].imm
> 4)
14482 first_error (_("bad list length for table lookup"));
14486 listlenbits
= inst
.operands
[1].imm
- 1;
14487 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
14488 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
14489 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 16;
14490 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 7;
14491 inst
.instruction
|= LOW4 (inst
.operands
[2].reg
);
14492 inst
.instruction
|= HI1 (inst
.operands
[2].reg
) << 5;
14493 inst
.instruction
|= listlenbits
<< 8;
14495 neon_dp_fixup (&inst
);
14499 do_neon_ldm_stm (void)
14501 /* P, U and L bits are part of bitmask. */
14502 int is_dbmode
= (inst
.instruction
& (1 << 24)) != 0;
14503 unsigned offsetbits
= inst
.operands
[1].imm
* 2;
14505 if (inst
.operands
[1].issingle
)
14507 do_vfp_nsyn_ldm_stm (is_dbmode
);
14511 constraint (is_dbmode
&& !inst
.operands
[0].writeback
,
14512 _("writeback (!) must be used for VLDMDB and VSTMDB"));
14514 constraint (inst
.operands
[1].imm
< 1 || inst
.operands
[1].imm
> 16,
14515 _("register list must contain at least 1 and at most 16 "
14518 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
14519 inst
.instruction
|= inst
.operands
[0].writeback
<< 21;
14520 inst
.instruction
|= LOW4 (inst
.operands
[1].reg
) << 12;
14521 inst
.instruction
|= HI1 (inst
.operands
[1].reg
) << 22;
14523 inst
.instruction
|= offsetbits
;
14525 do_vfp_cond_or_thumb ();
14529 do_neon_ldr_str (void)
14531 int is_ldr
= (inst
.instruction
& (1 << 20)) != 0;
14533 if (inst
.operands
[0].issingle
)
14536 do_vfp_nsyn_opcode ("flds");
14538 do_vfp_nsyn_opcode ("fsts");
14543 do_vfp_nsyn_opcode ("fldd");
14545 do_vfp_nsyn_opcode ("fstd");
14549 /* "interleave" version also handles non-interleaving register VLD1/VST1
14553 do_neon_ld_st_interleave (void)
14555 struct neon_type_el et
= neon_check_type (1, NS_NULL
,
14556 N_8
| N_16
| N_32
| N_64
);
14557 unsigned alignbits
= 0;
14559 /* The bits in this table go:
14560 0: register stride of one (0) or two (1)
14561 1,2: register list length, minus one (1, 2, 3, 4).
14562 3,4: <n> in instruction type, minus one (VLD<n> / VST<n>).
14563 We use -1 for invalid entries. */
14564 const int typetable
[] =
14566 0x7, -1, 0xa, -1, 0x6, -1, 0x2, -1, /* VLD1 / VST1. */
14567 -1, -1, 0x8, 0x9, -1, -1, 0x3, -1, /* VLD2 / VST2. */
14568 -1, -1, -1, -1, 0x4, 0x5, -1, -1, /* VLD3 / VST3. */
14569 -1, -1, -1, -1, -1, -1, 0x0, 0x1 /* VLD4 / VST4. */
14573 if (et
.type
== NT_invtype
)
14576 if (inst
.operands
[1].immisalign
)
14577 switch (inst
.operands
[1].imm
>> 8)
14579 case 64: alignbits
= 1; break;
14581 if (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) == 3)
14582 goto bad_alignment
;
14586 if (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) == 3)
14587 goto bad_alignment
;
14592 first_error (_("bad alignment"));
14596 inst
.instruction
|= alignbits
<< 4;
14597 inst
.instruction
|= neon_logbits (et
.size
) << 6;
14599 /* Bits [4:6] of the immediate in a list specifier encode register stride
14600 (minus 1) in bit 4, and list length in bits [5:6]. We put the <n> of
14601 VLD<n>/VST<n> in bits [9:8] of the initial bitmask. Suck it out here, look
14602 up the right value for "type" in a table based on this value and the given
14603 list style, then stick it back. */
14604 idx
= ((inst
.operands
[0].imm
>> 4) & 7)
14605 | (((inst
.instruction
>> 8) & 3) << 3);
14607 typebits
= typetable
[idx
];
14609 constraint (typebits
== -1, _("bad list type for instruction"));
14611 inst
.instruction
&= ~0xf00;
14612 inst
.instruction
|= typebits
<< 8;
14615 /* Check alignment is valid for do_neon_ld_st_lane and do_neon_ld_dup.
14616 *DO_ALIGN is set to 1 if the relevant alignment bit should be set, 0
14617 otherwise. The variable arguments are a list of pairs of legal (size, align)
14618 values, terminated with -1. */
14621 neon_alignment_bit (int size
, int align
, int *do_align
, ...)
14624 int result
= FAIL
, thissize
, thisalign
;
14626 if (!inst
.operands
[1].immisalign
)
14632 va_start (ap
, do_align
);
14636 thissize
= va_arg (ap
, int);
14637 if (thissize
== -1)
14639 thisalign
= va_arg (ap
, int);
14641 if (size
== thissize
&& align
== thisalign
)
14644 while (result
!= SUCCESS
);
14648 if (result
== SUCCESS
)
14651 first_error (_("unsupported alignment for instruction"));
14657 do_neon_ld_st_lane (void)
14659 struct neon_type_el et
= neon_check_type (1, NS_NULL
, N_8
| N_16
| N_32
);
14660 int align_good
, do_align
= 0;
14661 int logsize
= neon_logbits (et
.size
);
14662 int align
= inst
.operands
[1].imm
>> 8;
14663 int n
= (inst
.instruction
>> 8) & 3;
14664 int max_el
= 64 / et
.size
;
14666 if (et
.type
== NT_invtype
)
14669 constraint (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) != n
+ 1,
14670 _("bad list length"));
14671 constraint (NEON_LANE (inst
.operands
[0].imm
) >= max_el
,
14672 _("scalar index out of range"));
14673 constraint (n
!= 0 && NEON_REG_STRIDE (inst
.operands
[0].imm
) == 2
14675 _("stride of 2 unavailable when element size is 8"));
14679 case 0: /* VLD1 / VST1. */
14680 align_good
= neon_alignment_bit (et
.size
, align
, &do_align
, 16, 16,
14682 if (align_good
== FAIL
)
14686 unsigned alignbits
= 0;
14689 case 16: alignbits
= 0x1; break;
14690 case 32: alignbits
= 0x3; break;
14693 inst
.instruction
|= alignbits
<< 4;
14697 case 1: /* VLD2 / VST2. */
14698 align_good
= neon_alignment_bit (et
.size
, align
, &do_align
, 8, 16, 16, 32,
14700 if (align_good
== FAIL
)
14703 inst
.instruction
|= 1 << 4;
14706 case 2: /* VLD3 / VST3. */
14707 constraint (inst
.operands
[1].immisalign
,
14708 _("can't use alignment with this instruction"));
14711 case 3: /* VLD4 / VST4. */
14712 align_good
= neon_alignment_bit (et
.size
, align
, &do_align
, 8, 32,
14713 16, 64, 32, 64, 32, 128, -1);
14714 if (align_good
== FAIL
)
14718 unsigned alignbits
= 0;
14721 case 8: alignbits
= 0x1; break;
14722 case 16: alignbits
= 0x1; break;
14723 case 32: alignbits
= (align
== 64) ? 0x1 : 0x2; break;
14726 inst
.instruction
|= alignbits
<< 4;
14733 /* Reg stride of 2 is encoded in bit 5 when size==16, bit 6 when size==32. */
14734 if (n
!= 0 && NEON_REG_STRIDE (inst
.operands
[0].imm
) == 2)
14735 inst
.instruction
|= 1 << (4 + logsize
);
14737 inst
.instruction
|= NEON_LANE (inst
.operands
[0].imm
) << (logsize
+ 5);
14738 inst
.instruction
|= logsize
<< 10;
14741 /* Encode single n-element structure to all lanes VLD<n> instructions. */
14744 do_neon_ld_dup (void)
14746 struct neon_type_el et
= neon_check_type (1, NS_NULL
, N_8
| N_16
| N_32
);
14747 int align_good
, do_align
= 0;
14749 if (et
.type
== NT_invtype
)
14752 switch ((inst
.instruction
>> 8) & 3)
14754 case 0: /* VLD1. */
14755 gas_assert (NEON_REG_STRIDE (inst
.operands
[0].imm
) != 2);
14756 align_good
= neon_alignment_bit (et
.size
, inst
.operands
[1].imm
>> 8,
14757 &do_align
, 16, 16, 32, 32, -1);
14758 if (align_good
== FAIL
)
14760 switch (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
))
14763 case 2: inst
.instruction
|= 1 << 5; break;
14764 default: first_error (_("bad list length")); return;
14766 inst
.instruction
|= neon_logbits (et
.size
) << 6;
14769 case 1: /* VLD2. */
14770 align_good
= neon_alignment_bit (et
.size
, inst
.operands
[1].imm
>> 8,
14771 &do_align
, 8, 16, 16, 32, 32, 64, -1);
14772 if (align_good
== FAIL
)
14774 constraint (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) != 2,
14775 _("bad list length"));
14776 if (NEON_REG_STRIDE (inst
.operands
[0].imm
) == 2)
14777 inst
.instruction
|= 1 << 5;
14778 inst
.instruction
|= neon_logbits (et
.size
) << 6;
14781 case 2: /* VLD3. */
14782 constraint (inst
.operands
[1].immisalign
,
14783 _("can't use alignment with this instruction"));
14784 constraint (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) != 3,
14785 _("bad list length"));
14786 if (NEON_REG_STRIDE (inst
.operands
[0].imm
) == 2)
14787 inst
.instruction
|= 1 << 5;
14788 inst
.instruction
|= neon_logbits (et
.size
) << 6;
14791 case 3: /* VLD4. */
14793 int align
= inst
.operands
[1].imm
>> 8;
14794 align_good
= neon_alignment_bit (et
.size
, align
, &do_align
, 8, 32,
14795 16, 64, 32, 64, 32, 128, -1);
14796 if (align_good
== FAIL
)
14798 constraint (NEON_REGLIST_LENGTH (inst
.operands
[0].imm
) != 4,
14799 _("bad list length"));
14800 if (NEON_REG_STRIDE (inst
.operands
[0].imm
) == 2)
14801 inst
.instruction
|= 1 << 5;
14802 if (et
.size
== 32 && align
== 128)
14803 inst
.instruction
|= 0x3 << 6;
14805 inst
.instruction
|= neon_logbits (et
.size
) << 6;
14812 inst
.instruction
|= do_align
<< 4;
14815 /* Disambiguate VLD<n> and VST<n> instructions, and fill in common bits (those
14816 apart from bits [11:4]. */
14819 do_neon_ldx_stx (void)
14821 if (inst
.operands
[1].isreg
)
14822 constraint (inst
.operands
[1].reg
== REG_PC
, BAD_PC
);
14824 switch (NEON_LANE (inst
.operands
[0].imm
))
14826 case NEON_INTERLEAVE_LANES
:
14827 NEON_ENCODE (INTERLV
, inst
);
14828 do_neon_ld_st_interleave ();
14831 case NEON_ALL_LANES
:
14832 NEON_ENCODE (DUP
, inst
);
14837 NEON_ENCODE (LANE
, inst
);
14838 do_neon_ld_st_lane ();
14841 /* L bit comes from bit mask. */
14842 inst
.instruction
|= LOW4 (inst
.operands
[0].reg
) << 12;
14843 inst
.instruction
|= HI1 (inst
.operands
[0].reg
) << 22;
14844 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
14846 if (inst
.operands
[1].postind
)
14848 int postreg
= inst
.operands
[1].imm
& 0xf;
14849 constraint (!inst
.operands
[1].immisreg
,
14850 _("post-index must be a register"));
14851 constraint (postreg
== 0xd || postreg
== 0xf,
14852 _("bad register for post-index"));
14853 inst
.instruction
|= postreg
;
14855 else if (inst
.operands
[1].writeback
)
14857 inst
.instruction
|= 0xd;
14860 inst
.instruction
|= 0xf;
14863 inst
.instruction
|= 0xf9000000;
14865 inst
.instruction
|= 0xf4000000;
14868 /* Overall per-instruction processing. */
14870 /* We need to be able to fix up arbitrary expressions in some statements.
14871 This is so that we can handle symbols that are an arbitrary distance from
14872 the pc. The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
14873 which returns part of an address in a form which will be valid for
14874 a data instruction. We do this by pushing the expression into a symbol
14875 in the expr_section, and creating a fix for that. */
14878 fix_new_arm (fragS
* frag
,
14893 new_fix
= fix_new_exp (frag
, where
, size
, exp
, pc_rel
,
14894 (enum bfd_reloc_code_real
) reloc
);
14898 new_fix
= (fixS
*) fix_new (frag
, where
, size
, make_expr_symbol (exp
), 0,
14899 pc_rel
, (enum bfd_reloc_code_real
) reloc
);
14903 /* Mark whether the fix is to a THUMB instruction, or an ARM
14905 new_fix
->tc_fix_data
= thumb_mode
;
14908 /* Create a frg for an instruction requiring relaxation. */
14910 output_relax_insn (void)
14916 /* The size of the instruction is unknown, so tie the debug info to the
14917 start of the instruction. */
14918 dwarf2_emit_insn (0);
14920 switch (inst
.reloc
.exp
.X_op
)
14923 sym
= inst
.reloc
.exp
.X_add_symbol
;
14924 offset
= inst
.reloc
.exp
.X_add_number
;
14928 offset
= inst
.reloc
.exp
.X_add_number
;
14931 sym
= make_expr_symbol (&inst
.reloc
.exp
);
14935 to
= frag_var (rs_machine_dependent
, INSN_SIZE
, THUMB_SIZE
,
14936 inst
.relax
, sym
, offset
, NULL
/*offset, opcode*/);
14937 md_number_to_chars (to
, inst
.instruction
, THUMB_SIZE
);
14940 /* Write a 32-bit thumb instruction to buf. */
14942 put_thumb32_insn (char * buf
, unsigned long insn
)
14944 md_number_to_chars (buf
, insn
>> 16, THUMB_SIZE
);
14945 md_number_to_chars (buf
+ THUMB_SIZE
, insn
, THUMB_SIZE
);
14949 output_inst (const char * str
)
14955 as_bad ("%s -- `%s'", inst
.error
, str
);
14960 output_relax_insn ();
14963 if (inst
.size
== 0)
14966 to
= frag_more (inst
.size
);
14967 /* PR 9814: Record the thumb mode into the current frag so that we know
14968 what type of NOP padding to use, if necessary. We override any previous
14969 setting so that if the mode has changed then the NOPS that we use will
14970 match the encoding of the last instruction in the frag. */
14971 frag_now
->tc_frag_data
.thumb_mode
= thumb_mode
| MODE_RECORDED
;
14973 if (thumb_mode
&& (inst
.size
> THUMB_SIZE
))
14975 gas_assert (inst
.size
== (2 * THUMB_SIZE
));
14976 put_thumb32_insn (to
, inst
.instruction
);
14978 else if (inst
.size
> INSN_SIZE
)
14980 gas_assert (inst
.size
== (2 * INSN_SIZE
));
14981 md_number_to_chars (to
, inst
.instruction
, INSN_SIZE
);
14982 md_number_to_chars (to
+ INSN_SIZE
, inst
.instruction
, INSN_SIZE
);
14985 md_number_to_chars (to
, inst
.instruction
, inst
.size
);
14987 if (inst
.reloc
.type
!= BFD_RELOC_UNUSED
)
14988 fix_new_arm (frag_now
, to
- frag_now
->fr_literal
,
14989 inst
.size
, & inst
.reloc
.exp
, inst
.reloc
.pc_rel
,
14992 dwarf2_emit_insn (inst
.size
);
14996 output_it_inst (int cond
, int mask
, char * to
)
14998 unsigned long instruction
= 0xbf00;
15001 instruction
|= mask
;
15002 instruction
|= cond
<< 4;
15006 to
= frag_more (2);
15008 dwarf2_emit_insn (2);
15012 md_number_to_chars (to
, instruction
, 2);
15017 /* Tag values used in struct asm_opcode's tag field. */
15020 OT_unconditional
, /* Instruction cannot be conditionalized.
15021 The ARM condition field is still 0xE. */
15022 OT_unconditionalF
, /* Instruction cannot be conditionalized
15023 and carries 0xF in its ARM condition field. */
15024 OT_csuffix
, /* Instruction takes a conditional suffix. */
15025 OT_csuffixF
, /* Some forms of the instruction take a conditional
15026 suffix, others place 0xF where the condition field
15028 OT_cinfix3
, /* Instruction takes a conditional infix,
15029 beginning at character index 3. (In
15030 unified mode, it becomes a suffix.) */
15031 OT_cinfix3_deprecated
, /* The same as OT_cinfix3. This is used for
15032 tsts, cmps, cmns, and teqs. */
15033 OT_cinfix3_legacy
, /* Legacy instruction takes a conditional infix at
15034 character index 3, even in unified mode. Used for
15035 legacy instructions where suffix and infix forms
15036 may be ambiguous. */
15037 OT_csuf_or_in3
, /* Instruction takes either a conditional
15038 suffix or an infix at character index 3. */
15039 OT_odd_infix_unc
, /* This is the unconditional variant of an
15040 instruction that takes a conditional infix
15041 at an unusual position. In unified mode,
15042 this variant will accept a suffix. */
15043 OT_odd_infix_0
/* Values greater than or equal to OT_odd_infix_0
15044 are the conditional variants of instructions that
15045 take conditional infixes in unusual positions.
15046 The infix appears at character index
15047 (tag - OT_odd_infix_0). These are not accepted
15048 in unified mode. */
15051 /* Subroutine of md_assemble, responsible for looking up the primary
15052 opcode from the mnemonic the user wrote. STR points to the
15053 beginning of the mnemonic.
15055 This is not simply a hash table lookup, because of conditional
15056 variants. Most instructions have conditional variants, which are
15057 expressed with a _conditional affix_ to the mnemonic. If we were
15058 to encode each conditional variant as a literal string in the opcode
15059 table, it would have approximately 20,000 entries.
15061 Most mnemonics take this affix as a suffix, and in unified syntax,
15062 'most' is upgraded to 'all'. However, in the divided syntax, some
15063 instructions take the affix as an infix, notably the s-variants of
15064 the arithmetic instructions. Of those instructions, all but six
15065 have the infix appear after the third character of the mnemonic.
15067 Accordingly, the algorithm for looking up primary opcodes given
15070 1. Look up the identifier in the opcode table.
15071 If we find a match, go to step U.
15073 2. Look up the last two characters of the identifier in the
15074 conditions table. If we find a match, look up the first N-2
15075 characters of the identifier in the opcode table. If we
15076 find a match, go to step CE.
15078 3. Look up the fourth and fifth characters of the identifier in
15079 the conditions table. If we find a match, extract those
15080 characters from the identifier, and look up the remaining
15081 characters in the opcode table. If we find a match, go
15086 U. Examine the tag field of the opcode structure, in case this is
15087 one of the six instructions with its conditional infix in an
15088 unusual place. If it is, the tag tells us where to find the
15089 infix; look it up in the conditions table and set inst.cond
15090 accordingly. Otherwise, this is an unconditional instruction.
15091 Again set inst.cond accordingly. Return the opcode structure.
15093 CE. Examine the tag field to make sure this is an instruction that
15094 should receive a conditional suffix. If it is not, fail.
15095 Otherwise, set inst.cond from the suffix we already looked up,
15096 and return the opcode structure.
15098 CM. Examine the tag field to make sure this is an instruction that
15099 should receive a conditional infix after the third character.
15100 If it is not, fail. Otherwise, undo the edits to the current
15101 line of input and proceed as for case CE. */
15103 static const struct asm_opcode
*
15104 opcode_lookup (char **str
)
15108 const struct asm_opcode
*opcode
;
15109 const struct asm_cond
*cond
;
15112 /* Scan up to the end of the mnemonic, which must end in white space,
15113 '.' (in unified mode, or for Neon/VFP instructions), or end of string. */
15114 for (base
= end
= *str
; *end
!= '\0'; end
++)
15115 if (*end
== ' ' || *end
== '.')
15121 /* Handle a possible width suffix and/or Neon type suffix. */
15126 /* The .w and .n suffixes are only valid if the unified syntax is in
15128 if (unified_syntax
&& end
[1] == 'w')
15130 else if (unified_syntax
&& end
[1] == 'n')
15135 inst
.vectype
.elems
= 0;
15137 *str
= end
+ offset
;
15139 if (end
[offset
] == '.')
15141 /* See if we have a Neon type suffix (possible in either unified or
15142 non-unified ARM syntax mode). */
15143 if (parse_neon_type (&inst
.vectype
, str
) == FAIL
)
15146 else if (end
[offset
] != '\0' && end
[offset
] != ' ')
15152 /* Look for unaffixed or special-case affixed mnemonic. */
15153 opcode
= (const struct asm_opcode
*) hash_find_n (arm_ops_hsh
, base
,
15158 if (opcode
->tag
< OT_odd_infix_0
)
15160 inst
.cond
= COND_ALWAYS
;
15164 if (warn_on_deprecated
&& unified_syntax
)
15165 as_warn (_("conditional infixes are deprecated in unified syntax"));
15166 affix
= base
+ (opcode
->tag
- OT_odd_infix_0
);
15167 cond
= (const struct asm_cond
*) hash_find_n (arm_cond_hsh
, affix
, 2);
15170 inst
.cond
= cond
->value
;
15174 /* Cannot have a conditional suffix on a mnemonic of less than two
15176 if (end
- base
< 3)
15179 /* Look for suffixed mnemonic. */
15181 cond
= (const struct asm_cond
*) hash_find_n (arm_cond_hsh
, affix
, 2);
15182 opcode
= (const struct asm_opcode
*) hash_find_n (arm_ops_hsh
, base
,
15184 if (opcode
&& cond
)
15187 switch (opcode
->tag
)
15189 case OT_cinfix3_legacy
:
15190 /* Ignore conditional suffixes matched on infix only mnemonics. */
15194 case OT_cinfix3_deprecated
:
15195 case OT_odd_infix_unc
:
15196 if (!unified_syntax
)
15198 /* else fall through */
15202 case OT_csuf_or_in3
:
15203 inst
.cond
= cond
->value
;
15206 case OT_unconditional
:
15207 case OT_unconditionalF
:
15209 inst
.cond
= cond
->value
;
15212 /* Delayed diagnostic. */
15213 inst
.error
= BAD_COND
;
15214 inst
.cond
= COND_ALWAYS
;
15223 /* Cannot have a usual-position infix on a mnemonic of less than
15224 six characters (five would be a suffix). */
15225 if (end
- base
< 6)
15228 /* Look for infixed mnemonic in the usual position. */
15230 cond
= (const struct asm_cond
*) hash_find_n (arm_cond_hsh
, affix
, 2);
15234 memcpy (save
, affix
, 2);
15235 memmove (affix
, affix
+ 2, (end
- affix
) - 2);
15236 opcode
= (const struct asm_opcode
*) hash_find_n (arm_ops_hsh
, base
,
15238 memmove (affix
+ 2, affix
, (end
- affix
) - 2);
15239 memcpy (affix
, save
, 2);
15242 && (opcode
->tag
== OT_cinfix3
15243 || opcode
->tag
== OT_cinfix3_deprecated
15244 || opcode
->tag
== OT_csuf_or_in3
15245 || opcode
->tag
== OT_cinfix3_legacy
))
15248 if (warn_on_deprecated
&& unified_syntax
15249 && (opcode
->tag
== OT_cinfix3
15250 || opcode
->tag
== OT_cinfix3_deprecated
))
15251 as_warn (_("conditional infixes are deprecated in unified syntax"));
15253 inst
.cond
= cond
->value
;
15260 /* This function generates an initial IT instruction, leaving its block
15261 virtually open for the new instructions. Eventually,
15262 the mask will be updated by now_it_add_mask () each time
15263 a new instruction needs to be included in the IT block.
15264 Finally, the block is closed with close_automatic_it_block ().
15265 The block closure can be requested either from md_assemble (),
15266 a tencode (), or due to a label hook. */
15269 new_automatic_it_block (int cond
)
15271 now_it
.state
= AUTOMATIC_IT_BLOCK
;
15272 now_it
.mask
= 0x18;
15274 now_it
.block_length
= 1;
15275 mapping_state (MAP_THUMB
);
15276 now_it
.insn
= output_it_inst (cond
, now_it
.mask
, NULL
);
15279 /* Close an automatic IT block.
15280 See comments in new_automatic_it_block (). */
15283 close_automatic_it_block (void)
15285 now_it
.mask
= 0x10;
15286 now_it
.block_length
= 0;
15289 /* Update the mask of the current automatically-generated IT
15290 instruction. See comments in new_automatic_it_block (). */
15293 now_it_add_mask (int cond
)
15295 #define CLEAR_BIT(value, nbit) ((value) & ~(1 << (nbit)))
15296 #define SET_BIT_VALUE(value, bitvalue, nbit) (CLEAR_BIT (value, nbit) \
15297 | ((bitvalue) << (nbit)))
15298 const int resulting_bit
= (cond
& 1);
15300 now_it
.mask
&= 0xf;
15301 now_it
.mask
= SET_BIT_VALUE (now_it
.mask
,
15303 (5 - now_it
.block_length
));
15304 now_it
.mask
= SET_BIT_VALUE (now_it
.mask
,
15306 ((5 - now_it
.block_length
) - 1) );
15307 output_it_inst (now_it
.cc
, now_it
.mask
, now_it
.insn
);
15310 #undef SET_BIT_VALUE
15313 /* The IT blocks handling machinery is accessed through the these functions:
15314 it_fsm_pre_encode () from md_assemble ()
15315 set_it_insn_type () optional, from the tencode functions
15316 set_it_insn_type_last () ditto
15317 in_it_block () ditto
15318 it_fsm_post_encode () from md_assemble ()
15319 force_automatic_it_block_close () from label habdling functions
15322 1) md_assemble () calls it_fsm_pre_encode () before calling tencode (),
15323 initializing the IT insn type with a generic initial value depending
15324 on the inst.condition.
15325 2) During the tencode function, two things may happen:
15326 a) The tencode function overrides the IT insn type by
15327 calling either set_it_insn_type (type) or set_it_insn_type_last ().
15328 b) The tencode function queries the IT block state by
15329 calling in_it_block () (i.e. to determine narrow/not narrow mode).
15331 Both set_it_insn_type and in_it_block run the internal FSM state
15332 handling function (handle_it_state), because: a) setting the IT insn
15333 type may incur in an invalid state (exiting the function),
15334 and b) querying the state requires the FSM to be updated.
15335 Specifically we want to avoid creating an IT block for conditional
15336 branches, so it_fsm_pre_encode is actually a guess and we can't
15337 determine whether an IT block is required until the tencode () routine
15338 has decided what type of instruction this actually it.
15339 Because of this, if set_it_insn_type and in_it_block have to be used,
15340 set_it_insn_type has to be called first.
15342 set_it_insn_type_last () is a wrapper of set_it_insn_type (type), that
15343 determines the insn IT type depending on the inst.cond code.
15344 When a tencode () routine encodes an instruction that can be
15345 either outside an IT block, or, in the case of being inside, has to be
15346 the last one, set_it_insn_type_last () will determine the proper
15347 IT instruction type based on the inst.cond code. Otherwise,
15348 set_it_insn_type can be called for overriding that logic or
15349 for covering other cases.
15351 Calling handle_it_state () may not transition the IT block state to
15352 OUTSIDE_IT_BLOCK immediatelly, since the (current) state could be
15353 still queried. Instead, if the FSM determines that the state should
15354 be transitioned to OUTSIDE_IT_BLOCK, a flag is marked to be closed
15355 after the tencode () function: that's what it_fsm_post_encode () does.
15357 Since in_it_block () calls the state handling function to get an
15358 updated state, an error may occur (due to invalid insns combination).
15359 In that case, inst.error is set.
15360 Therefore, inst.error has to be checked after the execution of
15361 the tencode () routine.
15363 3) Back in md_assemble(), it_fsm_post_encode () is called to commit
15364 any pending state change (if any) that didn't take place in
15365 handle_it_state () as explained above. */
15368 it_fsm_pre_encode (void)
15370 if (inst
.cond
!= COND_ALWAYS
)
15371 inst
.it_insn_type
= INSIDE_IT_INSN
;
15373 inst
.it_insn_type
= OUTSIDE_IT_INSN
;
15375 now_it
.state_handled
= 0;
15378 /* IT state FSM handling function. */
15381 handle_it_state (void)
15383 now_it
.state_handled
= 1;
15385 switch (now_it
.state
)
15387 case OUTSIDE_IT_BLOCK
:
15388 switch (inst
.it_insn_type
)
15390 case OUTSIDE_IT_INSN
:
15393 case INSIDE_IT_INSN
:
15394 case INSIDE_IT_LAST_INSN
:
15395 if (thumb_mode
== 0)
15398 && !(implicit_it_mode
& IMPLICIT_IT_MODE_ARM
))
15399 as_tsktsk (_("Warning: conditional outside an IT block"\
15404 if ((implicit_it_mode
& IMPLICIT_IT_MODE_THUMB
)
15405 && ARM_CPU_HAS_FEATURE (cpu_variant
, arm_arch_t2
))
15407 /* Automatically generate the IT instruction. */
15408 new_automatic_it_block (inst
.cond
);
15409 if (inst
.it_insn_type
== INSIDE_IT_LAST_INSN
)
15410 close_automatic_it_block ();
15414 inst
.error
= BAD_OUT_IT
;
15420 case IF_INSIDE_IT_LAST_INSN
:
15421 case NEUTRAL_IT_INSN
:
15425 now_it
.state
= MANUAL_IT_BLOCK
;
15426 now_it
.block_length
= 0;
15431 case AUTOMATIC_IT_BLOCK
:
15432 /* Three things may happen now:
15433 a) We should increment current it block size;
15434 b) We should close current it block (closing insn or 4 insns);
15435 c) We should close current it block and start a new one (due
15436 to incompatible conditions or
15437 4 insns-length block reached). */
15439 switch (inst
.it_insn_type
)
15441 case OUTSIDE_IT_INSN
:
15442 /* The closure of the block shall happen immediatelly,
15443 so any in_it_block () call reports the block as closed. */
15444 force_automatic_it_block_close ();
15447 case INSIDE_IT_INSN
:
15448 case INSIDE_IT_LAST_INSN
:
15449 case IF_INSIDE_IT_LAST_INSN
:
15450 now_it
.block_length
++;
15452 if (now_it
.block_length
> 4
15453 || !now_it_compatible (inst
.cond
))
15455 force_automatic_it_block_close ();
15456 if (inst
.it_insn_type
!= IF_INSIDE_IT_LAST_INSN
)
15457 new_automatic_it_block (inst
.cond
);
15461 now_it_add_mask (inst
.cond
);
15464 if (now_it
.state
== AUTOMATIC_IT_BLOCK
15465 && (inst
.it_insn_type
== INSIDE_IT_LAST_INSN
15466 || inst
.it_insn_type
== IF_INSIDE_IT_LAST_INSN
))
15467 close_automatic_it_block ();
15470 case NEUTRAL_IT_INSN
:
15471 now_it
.block_length
++;
15473 if (now_it
.block_length
> 4)
15474 force_automatic_it_block_close ();
15476 now_it_add_mask (now_it
.cc
& 1);
15480 close_automatic_it_block ();
15481 now_it
.state
= MANUAL_IT_BLOCK
;
15486 case MANUAL_IT_BLOCK
:
15488 /* Check conditional suffixes. */
15489 const int cond
= now_it
.cc
^ ((now_it
.mask
>> 4) & 1) ^ 1;
15492 now_it
.mask
&= 0x1f;
15493 is_last
= (now_it
.mask
== 0x10);
15495 switch (inst
.it_insn_type
)
15497 case OUTSIDE_IT_INSN
:
15498 inst
.error
= BAD_NOT_IT
;
15501 case INSIDE_IT_INSN
:
15502 if (cond
!= inst
.cond
)
15504 inst
.error
= BAD_IT_COND
;
15509 case INSIDE_IT_LAST_INSN
:
15510 case IF_INSIDE_IT_LAST_INSN
:
15511 if (cond
!= inst
.cond
)
15513 inst
.error
= BAD_IT_COND
;
15518 inst
.error
= BAD_BRANCH
;
15523 case NEUTRAL_IT_INSN
:
15524 /* The BKPT instruction is unconditional even in an IT block. */
15528 inst
.error
= BAD_IT_IT
;
15539 it_fsm_post_encode (void)
15543 if (!now_it
.state_handled
)
15544 handle_it_state ();
15546 is_last
= (now_it
.mask
== 0x10);
15549 now_it
.state
= OUTSIDE_IT_BLOCK
;
15555 force_automatic_it_block_close (void)
15557 if (now_it
.state
== AUTOMATIC_IT_BLOCK
)
15559 close_automatic_it_block ();
15560 now_it
.state
= OUTSIDE_IT_BLOCK
;
15568 if (!now_it
.state_handled
)
15569 handle_it_state ();
15571 return now_it
.state
!= OUTSIDE_IT_BLOCK
;
15575 md_assemble (char *str
)
15578 const struct asm_opcode
* opcode
;
15580 /* Align the previous label if needed. */
15581 if (last_label_seen
!= NULL
)
15583 symbol_set_frag (last_label_seen
, frag_now
);
15584 S_SET_VALUE (last_label_seen
, (valueT
) frag_now_fix ());
15585 S_SET_SEGMENT (last_label_seen
, now_seg
);
15588 memset (&inst
, '\0', sizeof (inst
));
15589 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
15591 opcode
= opcode_lookup (&p
);
15594 /* It wasn't an instruction, but it might be a register alias of
15595 the form alias .req reg, or a Neon .dn/.qn directive. */
15596 if (! create_register_alias (str
, p
)
15597 && ! create_neon_reg_alias (str
, p
))
15598 as_bad (_("bad instruction `%s'"), str
);
15603 if (warn_on_deprecated
&& opcode
->tag
== OT_cinfix3_deprecated
)
15604 as_warn (_("s suffix on comparison instruction is deprecated"));
15606 /* The value which unconditional instructions should have in place of the
15607 condition field. */
15608 inst
.uncond_value
= (opcode
->tag
== OT_csuffixF
) ? 0xf : -1;
15612 arm_feature_set variant
;
15614 variant
= cpu_variant
;
15615 /* Only allow coprocessor instructions on Thumb-2 capable devices. */
15616 if (!ARM_CPU_HAS_FEATURE (variant
, arm_arch_t2
))
15617 ARM_CLEAR_FEATURE (variant
, variant
, fpu_any_hard
);
15618 /* Check that this instruction is supported for this CPU. */
15619 if (!opcode
->tvariant
15620 || (thumb_mode
== 1
15621 && !ARM_CPU_HAS_FEATURE (variant
, *opcode
->tvariant
)))
15623 as_bad (_("selected processor does not support `%s'"), str
);
15626 if (inst
.cond
!= COND_ALWAYS
&& !unified_syntax
15627 && opcode
->tencode
!= do_t_branch
)
15629 as_bad (_("Thumb does not support conditional execution"));
15633 if (!ARM_CPU_HAS_FEATURE (variant
, arm_ext_v6t2
))
15635 if (opcode
->tencode
!= do_t_blx
&& opcode
->tencode
!= do_t_branch23
15636 && !(ARM_CPU_HAS_FEATURE(*opcode
->tvariant
, arm_ext_msr
)
15637 || ARM_CPU_HAS_FEATURE(*opcode
->tvariant
, arm_ext_barrier
)))
15639 /* Two things are addressed here.
15640 1) Implicit require narrow instructions on Thumb-1.
15641 This avoids relaxation accidentally introducing Thumb-2
15643 2) Reject wide instructions in non Thumb-2 cores. */
15644 if (inst
.size_req
== 0)
15646 else if (inst
.size_req
== 4)
15648 as_bad (_("selected processor does not support `%s'"), str
);
15654 inst
.instruction
= opcode
->tvalue
;
15656 if (!parse_operands (p
, opcode
->operands
))
15658 /* Prepare the it_insn_type for those encodings that don't set
15660 it_fsm_pre_encode ();
15662 opcode
->tencode ();
15664 it_fsm_post_encode ();
15667 if (!(inst
.error
|| inst
.relax
))
15669 gas_assert (inst
.instruction
< 0xe800 || inst
.instruction
> 0xffff);
15670 inst
.size
= (inst
.instruction
> 0xffff ? 4 : 2);
15671 if (inst
.size_req
&& inst
.size_req
!= inst
.size
)
15673 as_bad (_("cannot honor width suffix -- `%s'"), str
);
15678 /* Something has gone badly wrong if we try to relax a fixed size
15680 gas_assert (inst
.size_req
== 0 || !inst
.relax
);
15682 ARM_MERGE_FEATURE_SETS (thumb_arch_used
, thumb_arch_used
,
15683 *opcode
->tvariant
);
15684 /* Many Thumb-2 instructions also have Thumb-1 variants, so explicitly
15685 set those bits when Thumb-2 32-bit instructions are seen. ie.
15686 anything other than bl/blx and v6-M instructions.
15687 This is overly pessimistic for relaxable instructions. */
15688 if (((inst
.size
== 4 && (inst
.instruction
& 0xf800e800) != 0xf000e800)
15690 && !(ARM_CPU_HAS_FEATURE (*opcode
->tvariant
, arm_ext_msr
)
15691 || ARM_CPU_HAS_FEATURE (*opcode
->tvariant
, arm_ext_barrier
)))
15692 ARM_MERGE_FEATURE_SETS (thumb_arch_used
, thumb_arch_used
,
15695 check_neon_suffixes
;
15699 mapping_state (MAP_THUMB
);
15702 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v1
))
15706 /* bx is allowed on v5 cores, and sometimes on v4 cores. */
15707 is_bx
= (opcode
->aencode
== do_bx
);
15709 /* Check that this instruction is supported for this CPU. */
15710 if (!(is_bx
&& fix_v4bx
)
15711 && !(opcode
->avariant
&&
15712 ARM_CPU_HAS_FEATURE (cpu_variant
, *opcode
->avariant
)))
15714 as_bad (_("selected processor does not support `%s'"), str
);
15719 as_bad (_("width suffixes are invalid in ARM mode -- `%s'"), str
);
15723 inst
.instruction
= opcode
->avalue
;
15724 if (opcode
->tag
== OT_unconditionalF
)
15725 inst
.instruction
|= 0xF << 28;
15727 inst
.instruction
|= inst
.cond
<< 28;
15728 inst
.size
= INSN_SIZE
;
15729 if (!parse_operands (p
, opcode
->operands
))
15731 it_fsm_pre_encode ();
15732 opcode
->aencode ();
15733 it_fsm_post_encode ();
15735 /* Arm mode bx is marked as both v4T and v5 because it's still required
15736 on a hypothetical non-thumb v5 core. */
15738 ARM_MERGE_FEATURE_SETS (arm_arch_used
, arm_arch_used
, arm_ext_v4t
);
15740 ARM_MERGE_FEATURE_SETS (arm_arch_used
, arm_arch_used
,
15741 *opcode
->avariant
);
15743 check_neon_suffixes
;
15747 mapping_state (MAP_ARM
);
15752 as_bad (_("attempt to use an ARM instruction on a Thumb-only processor "
15760 check_it_blocks_finished (void)
15765 for (sect
= stdoutput
->sections
; sect
!= NULL
; sect
= sect
->next
)
15766 if (seg_info (sect
)->tc_segment_info_data
.current_it
.state
15767 == MANUAL_IT_BLOCK
)
15769 as_warn (_("section '%s' finished with an open IT block."),
15773 if (now_it
.state
== MANUAL_IT_BLOCK
)
15774 as_warn (_("file finished with an open IT block."));
15778 /* Various frobbings of labels and their addresses. */
15781 arm_start_line_hook (void)
15783 last_label_seen
= NULL
;
15787 arm_frob_label (symbolS
* sym
)
15789 last_label_seen
= sym
;
15791 ARM_SET_THUMB (sym
, thumb_mode
);
15793 #if defined OBJ_COFF || defined OBJ_ELF
15794 ARM_SET_INTERWORK (sym
, support_interwork
);
15797 force_automatic_it_block_close ();
15799 /* Note - do not allow local symbols (.Lxxx) to be labelled
15800 as Thumb functions. This is because these labels, whilst
15801 they exist inside Thumb code, are not the entry points for
15802 possible ARM->Thumb calls. Also, these labels can be used
15803 as part of a computed goto or switch statement. eg gcc
15804 can generate code that looks like this:
15806 ldr r2, [pc, .Laaa]
15816 The first instruction loads the address of the jump table.
15817 The second instruction converts a table index into a byte offset.
15818 The third instruction gets the jump address out of the table.
15819 The fourth instruction performs the jump.
15821 If the address stored at .Laaa is that of a symbol which has the
15822 Thumb_Func bit set, then the linker will arrange for this address
15823 to have the bottom bit set, which in turn would mean that the
15824 address computation performed by the third instruction would end
15825 up with the bottom bit set. Since the ARM is capable of unaligned
15826 word loads, the instruction would then load the incorrect address
15827 out of the jump table, and chaos would ensue. */
15828 if (label_is_thumb_function_name
15829 && (S_GET_NAME (sym
)[0] != '.' || S_GET_NAME (sym
)[1] != 'L')
15830 && (bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
) != 0)
15832 /* When the address of a Thumb function is taken the bottom
15833 bit of that address should be set. This will allow
15834 interworking between Arm and Thumb functions to work
15837 THUMB_SET_FUNC (sym
, 1);
15839 label_is_thumb_function_name
= FALSE
;
15842 dwarf2_emit_label (sym
);
15846 arm_data_in_code (void)
15848 if (thumb_mode
&& ! strncmp (input_line_pointer
+ 1, "data:", 5))
15850 *input_line_pointer
= '/';
15851 input_line_pointer
+= 5;
15852 *input_line_pointer
= 0;
15860 arm_canonicalize_symbol_name (char * name
)
15864 if (thumb_mode
&& (len
= strlen (name
)) > 5
15865 && streq (name
+ len
- 5, "/data"))
15866 *(name
+ len
- 5) = 0;
15871 /* Table of all register names defined by default. The user can
15872 define additional names with .req. Note that all register names
15873 should appear in both upper and lowercase variants. Some registers
15874 also have mixed-case names. */
15876 #define REGDEF(s,n,t) { #s, n, REG_TYPE_##t, TRUE, 0 }
15877 #define REGNUM(p,n,t) REGDEF(p##n, n, t)
15878 #define REGNUM2(p,n,t) REGDEF(p##n, 2 * n, t)
15879 #define REGSET(p,t) \
15880 REGNUM(p, 0,t), REGNUM(p, 1,t), REGNUM(p, 2,t), REGNUM(p, 3,t), \
15881 REGNUM(p, 4,t), REGNUM(p, 5,t), REGNUM(p, 6,t), REGNUM(p, 7,t), \
15882 REGNUM(p, 8,t), REGNUM(p, 9,t), REGNUM(p,10,t), REGNUM(p,11,t), \
15883 REGNUM(p,12,t), REGNUM(p,13,t), REGNUM(p,14,t), REGNUM(p,15,t)
15884 #define REGSETH(p,t) \
15885 REGNUM(p,16,t), REGNUM(p,17,t), REGNUM(p,18,t), REGNUM(p,19,t), \
15886 REGNUM(p,20,t), REGNUM(p,21,t), REGNUM(p,22,t), REGNUM(p,23,t), \
15887 REGNUM(p,24,t), REGNUM(p,25,t), REGNUM(p,26,t), REGNUM(p,27,t), \
15888 REGNUM(p,28,t), REGNUM(p,29,t), REGNUM(p,30,t), REGNUM(p,31,t)
15889 #define REGSET2(p,t) \
15890 REGNUM2(p, 0,t), REGNUM2(p, 1,t), REGNUM2(p, 2,t), REGNUM2(p, 3,t), \
15891 REGNUM2(p, 4,t), REGNUM2(p, 5,t), REGNUM2(p, 6,t), REGNUM2(p, 7,t), \
15892 REGNUM2(p, 8,t), REGNUM2(p, 9,t), REGNUM2(p,10,t), REGNUM2(p,11,t), \
15893 REGNUM2(p,12,t), REGNUM2(p,13,t), REGNUM2(p,14,t), REGNUM2(p,15,t)
15895 static const struct reg_entry reg_names
[] =
15897 /* ARM integer registers. */
15898 REGSET(r
, RN
), REGSET(R
, RN
),
15900 /* ATPCS synonyms. */
15901 REGDEF(a1
,0,RN
), REGDEF(a2
,1,RN
), REGDEF(a3
, 2,RN
), REGDEF(a4
, 3,RN
),
15902 REGDEF(v1
,4,RN
), REGDEF(v2
,5,RN
), REGDEF(v3
, 6,RN
), REGDEF(v4
, 7,RN
),
15903 REGDEF(v5
,8,RN
), REGDEF(v6
,9,RN
), REGDEF(v7
,10,RN
), REGDEF(v8
,11,RN
),
15905 REGDEF(A1
,0,RN
), REGDEF(A2
,1,RN
), REGDEF(A3
, 2,RN
), REGDEF(A4
, 3,RN
),
15906 REGDEF(V1
,4,RN
), REGDEF(V2
,5,RN
), REGDEF(V3
, 6,RN
), REGDEF(V4
, 7,RN
),
15907 REGDEF(V5
,8,RN
), REGDEF(V6
,9,RN
), REGDEF(V7
,10,RN
), REGDEF(V8
,11,RN
),
15909 /* Well-known aliases. */
15910 REGDEF(wr
, 7,RN
), REGDEF(sb
, 9,RN
), REGDEF(sl
,10,RN
), REGDEF(fp
,11,RN
),
15911 REGDEF(ip
,12,RN
), REGDEF(sp
,13,RN
), REGDEF(lr
,14,RN
), REGDEF(pc
,15,RN
),
15913 REGDEF(WR
, 7,RN
), REGDEF(SB
, 9,RN
), REGDEF(SL
,10,RN
), REGDEF(FP
,11,RN
),
15914 REGDEF(IP
,12,RN
), REGDEF(SP
,13,RN
), REGDEF(LR
,14,RN
), REGDEF(PC
,15,RN
),
15916 /* Coprocessor numbers. */
15917 REGSET(p
, CP
), REGSET(P
, CP
),
15919 /* Coprocessor register numbers. The "cr" variants are for backward
15921 REGSET(c
, CN
), REGSET(C
, CN
),
15922 REGSET(cr
, CN
), REGSET(CR
, CN
),
15924 /* FPA registers. */
15925 REGNUM(f
,0,FN
), REGNUM(f
,1,FN
), REGNUM(f
,2,FN
), REGNUM(f
,3,FN
),
15926 REGNUM(f
,4,FN
), REGNUM(f
,5,FN
), REGNUM(f
,6,FN
), REGNUM(f
,7, FN
),
15928 REGNUM(F
,0,FN
), REGNUM(F
,1,FN
), REGNUM(F
,2,FN
), REGNUM(F
,3,FN
),
15929 REGNUM(F
,4,FN
), REGNUM(F
,5,FN
), REGNUM(F
,6,FN
), REGNUM(F
,7, FN
),
15931 /* VFP SP registers. */
15932 REGSET(s
,VFS
), REGSET(S
,VFS
),
15933 REGSETH(s
,VFS
), REGSETH(S
,VFS
),
15935 /* VFP DP Registers. */
15936 REGSET(d
,VFD
), REGSET(D
,VFD
),
15937 /* Extra Neon DP registers. */
15938 REGSETH(d
,VFD
), REGSETH(D
,VFD
),
15940 /* Neon QP registers. */
15941 REGSET2(q
,NQ
), REGSET2(Q
,NQ
),
15943 /* VFP control registers. */
15944 REGDEF(fpsid
,0,VFC
), REGDEF(fpscr
,1,VFC
), REGDEF(fpexc
,8,VFC
),
15945 REGDEF(FPSID
,0,VFC
), REGDEF(FPSCR
,1,VFC
), REGDEF(FPEXC
,8,VFC
),
15946 REGDEF(fpinst
,9,VFC
), REGDEF(fpinst2
,10,VFC
),
15947 REGDEF(FPINST
,9,VFC
), REGDEF(FPINST2
,10,VFC
),
15948 REGDEF(mvfr0
,7,VFC
), REGDEF(mvfr1
,6,VFC
),
15949 REGDEF(MVFR0
,7,VFC
), REGDEF(MVFR1
,6,VFC
),
15951 /* Maverick DSP coprocessor registers. */
15952 REGSET(mvf
,MVF
), REGSET(mvd
,MVD
), REGSET(mvfx
,MVFX
), REGSET(mvdx
,MVDX
),
15953 REGSET(MVF
,MVF
), REGSET(MVD
,MVD
), REGSET(MVFX
,MVFX
), REGSET(MVDX
,MVDX
),
15955 REGNUM(mvax
,0,MVAX
), REGNUM(mvax
,1,MVAX
),
15956 REGNUM(mvax
,2,MVAX
), REGNUM(mvax
,3,MVAX
),
15957 REGDEF(dspsc
,0,DSPSC
),
15959 REGNUM(MVAX
,0,MVAX
), REGNUM(MVAX
,1,MVAX
),
15960 REGNUM(MVAX
,2,MVAX
), REGNUM(MVAX
,3,MVAX
),
15961 REGDEF(DSPSC
,0,DSPSC
),
15963 /* iWMMXt data registers - p0, c0-15. */
15964 REGSET(wr
,MMXWR
), REGSET(wR
,MMXWR
), REGSET(WR
, MMXWR
),
15966 /* iWMMXt control registers - p1, c0-3. */
15967 REGDEF(wcid
, 0,MMXWC
), REGDEF(wCID
, 0,MMXWC
), REGDEF(WCID
, 0,MMXWC
),
15968 REGDEF(wcon
, 1,MMXWC
), REGDEF(wCon
, 1,MMXWC
), REGDEF(WCON
, 1,MMXWC
),
15969 REGDEF(wcssf
, 2,MMXWC
), REGDEF(wCSSF
, 2,MMXWC
), REGDEF(WCSSF
, 2,MMXWC
),
15970 REGDEF(wcasf
, 3,MMXWC
), REGDEF(wCASF
, 3,MMXWC
), REGDEF(WCASF
, 3,MMXWC
),
15972 /* iWMMXt scalar (constant/offset) registers - p1, c8-11. */
15973 REGDEF(wcgr0
, 8,MMXWCG
), REGDEF(wCGR0
, 8,MMXWCG
), REGDEF(WCGR0
, 8,MMXWCG
),
15974 REGDEF(wcgr1
, 9,MMXWCG
), REGDEF(wCGR1
, 9,MMXWCG
), REGDEF(WCGR1
, 9,MMXWCG
),
15975 REGDEF(wcgr2
,10,MMXWCG
), REGDEF(wCGR2
,10,MMXWCG
), REGDEF(WCGR2
,10,MMXWCG
),
15976 REGDEF(wcgr3
,11,MMXWCG
), REGDEF(wCGR3
,11,MMXWCG
), REGDEF(WCGR3
,11,MMXWCG
),
15978 /* XScale accumulator registers. */
15979 REGNUM(acc
,0,XSCALE
), REGNUM(ACC
,0,XSCALE
),
15985 /* Table of all PSR suffixes. Bare "CPSR" and "SPSR" are handled
15986 within psr_required_here. */
15987 static const struct asm_psr psrs
[] =
15989 /* Backward compatibility notation. Note that "all" is no longer
15990 truly all possible PSR bits. */
15991 {"all", PSR_c
| PSR_f
},
15995 /* Individual flags. */
16000 /* Combinations of flags. */
16001 {"fs", PSR_f
| PSR_s
},
16002 {"fx", PSR_f
| PSR_x
},
16003 {"fc", PSR_f
| PSR_c
},
16004 {"sf", PSR_s
| PSR_f
},
16005 {"sx", PSR_s
| PSR_x
},
16006 {"sc", PSR_s
| PSR_c
},
16007 {"xf", PSR_x
| PSR_f
},
16008 {"xs", PSR_x
| PSR_s
},
16009 {"xc", PSR_x
| PSR_c
},
16010 {"cf", PSR_c
| PSR_f
},
16011 {"cs", PSR_c
| PSR_s
},
16012 {"cx", PSR_c
| PSR_x
},
16013 {"fsx", PSR_f
| PSR_s
| PSR_x
},
16014 {"fsc", PSR_f
| PSR_s
| PSR_c
},
16015 {"fxs", PSR_f
| PSR_x
| PSR_s
},
16016 {"fxc", PSR_f
| PSR_x
| PSR_c
},
16017 {"fcs", PSR_f
| PSR_c
| PSR_s
},
16018 {"fcx", PSR_f
| PSR_c
| PSR_x
},
16019 {"sfx", PSR_s
| PSR_f
| PSR_x
},
16020 {"sfc", PSR_s
| PSR_f
| PSR_c
},
16021 {"sxf", PSR_s
| PSR_x
| PSR_f
},
16022 {"sxc", PSR_s
| PSR_x
| PSR_c
},
16023 {"scf", PSR_s
| PSR_c
| PSR_f
},
16024 {"scx", PSR_s
| PSR_c
| PSR_x
},
16025 {"xfs", PSR_x
| PSR_f
| PSR_s
},
16026 {"xfc", PSR_x
| PSR_f
| PSR_c
},
16027 {"xsf", PSR_x
| PSR_s
| PSR_f
},
16028 {"xsc", PSR_x
| PSR_s
| PSR_c
},
16029 {"xcf", PSR_x
| PSR_c
| PSR_f
},
16030 {"xcs", PSR_x
| PSR_c
| PSR_s
},
16031 {"cfs", PSR_c
| PSR_f
| PSR_s
},
16032 {"cfx", PSR_c
| PSR_f
| PSR_x
},
16033 {"csf", PSR_c
| PSR_s
| PSR_f
},
16034 {"csx", PSR_c
| PSR_s
| PSR_x
},
16035 {"cxf", PSR_c
| PSR_x
| PSR_f
},
16036 {"cxs", PSR_c
| PSR_x
| PSR_s
},
16037 {"fsxc", PSR_f
| PSR_s
| PSR_x
| PSR_c
},
16038 {"fscx", PSR_f
| PSR_s
| PSR_c
| PSR_x
},
16039 {"fxsc", PSR_f
| PSR_x
| PSR_s
| PSR_c
},
16040 {"fxcs", PSR_f
| PSR_x
| PSR_c
| PSR_s
},
16041 {"fcsx", PSR_f
| PSR_c
| PSR_s
| PSR_x
},
16042 {"fcxs", PSR_f
| PSR_c
| PSR_x
| PSR_s
},
16043 {"sfxc", PSR_s
| PSR_f
| PSR_x
| PSR_c
},
16044 {"sfcx", PSR_s
| PSR_f
| PSR_c
| PSR_x
},
16045 {"sxfc", PSR_s
| PSR_x
| PSR_f
| PSR_c
},
16046 {"sxcf", PSR_s
| PSR_x
| PSR_c
| PSR_f
},
16047 {"scfx", PSR_s
| PSR_c
| PSR_f
| PSR_x
},
16048 {"scxf", PSR_s
| PSR_c
| PSR_x
| PSR_f
},
16049 {"xfsc", PSR_x
| PSR_f
| PSR_s
| PSR_c
},
16050 {"xfcs", PSR_x
| PSR_f
| PSR_c
| PSR_s
},
16051 {"xsfc", PSR_x
| PSR_s
| PSR_f
| PSR_c
},
16052 {"xscf", PSR_x
| PSR_s
| PSR_c
| PSR_f
},
16053 {"xcfs", PSR_x
| PSR_c
| PSR_f
| PSR_s
},
16054 {"xcsf", PSR_x
| PSR_c
| PSR_s
| PSR_f
},
16055 {"cfsx", PSR_c
| PSR_f
| PSR_s
| PSR_x
},
16056 {"cfxs", PSR_c
| PSR_f
| PSR_x
| PSR_s
},
16057 {"csfx", PSR_c
| PSR_s
| PSR_f
| PSR_x
},
16058 {"csxf", PSR_c
| PSR_s
| PSR_x
| PSR_f
},
16059 {"cxfs", PSR_c
| PSR_x
| PSR_f
| PSR_s
},
16060 {"cxsf", PSR_c
| PSR_x
| PSR_s
| PSR_f
},
16063 /* Table of V7M psr names. */
16064 static const struct asm_psr v7m_psrs
[] =
16066 {"apsr", 0 }, {"APSR", 0 },
16067 {"iapsr", 1 }, {"IAPSR", 1 },
16068 {"eapsr", 2 }, {"EAPSR", 2 },
16069 {"psr", 3 }, {"PSR", 3 },
16070 {"xpsr", 3 }, {"XPSR", 3 }, {"xPSR", 3 },
16071 {"ipsr", 5 }, {"IPSR", 5 },
16072 {"epsr", 6 }, {"EPSR", 6 },
16073 {"iepsr", 7 }, {"IEPSR", 7 },
16074 {"msp", 8 }, {"MSP", 8 },
16075 {"psp", 9 }, {"PSP", 9 },
16076 {"primask", 16}, {"PRIMASK", 16},
16077 {"basepri", 17}, {"BASEPRI", 17},
16078 {"basepri_max", 18}, {"BASEPRI_MAX", 18},
16079 {"faultmask", 19}, {"FAULTMASK", 19},
16080 {"control", 20}, {"CONTROL", 20}
16083 /* Table of all shift-in-operand names. */
16084 static const struct asm_shift_name shift_names
[] =
16086 { "asl", SHIFT_LSL
}, { "ASL", SHIFT_LSL
},
16087 { "lsl", SHIFT_LSL
}, { "LSL", SHIFT_LSL
},
16088 { "lsr", SHIFT_LSR
}, { "LSR", SHIFT_LSR
},
16089 { "asr", SHIFT_ASR
}, { "ASR", SHIFT_ASR
},
16090 { "ror", SHIFT_ROR
}, { "ROR", SHIFT_ROR
},
16091 { "rrx", SHIFT_RRX
}, { "RRX", SHIFT_RRX
}
16094 /* Table of all explicit relocation names. */
16096 static struct reloc_entry reloc_names
[] =
16098 { "got", BFD_RELOC_ARM_GOT32
}, { "GOT", BFD_RELOC_ARM_GOT32
},
16099 { "gotoff", BFD_RELOC_ARM_GOTOFF
}, { "GOTOFF", BFD_RELOC_ARM_GOTOFF
},
16100 { "plt", BFD_RELOC_ARM_PLT32
}, { "PLT", BFD_RELOC_ARM_PLT32
},
16101 { "target1", BFD_RELOC_ARM_TARGET1
}, { "TARGET1", BFD_RELOC_ARM_TARGET1
},
16102 { "target2", BFD_RELOC_ARM_TARGET2
}, { "TARGET2", BFD_RELOC_ARM_TARGET2
},
16103 { "sbrel", BFD_RELOC_ARM_SBREL32
}, { "SBREL", BFD_RELOC_ARM_SBREL32
},
16104 { "tlsgd", BFD_RELOC_ARM_TLS_GD32
}, { "TLSGD", BFD_RELOC_ARM_TLS_GD32
},
16105 { "tlsldm", BFD_RELOC_ARM_TLS_LDM32
}, { "TLSLDM", BFD_RELOC_ARM_TLS_LDM32
},
16106 { "tlsldo", BFD_RELOC_ARM_TLS_LDO32
}, { "TLSLDO", BFD_RELOC_ARM_TLS_LDO32
},
16107 { "gottpoff",BFD_RELOC_ARM_TLS_IE32
}, { "GOTTPOFF",BFD_RELOC_ARM_TLS_IE32
},
16108 { "tpoff", BFD_RELOC_ARM_TLS_LE32
}, { "TPOFF", BFD_RELOC_ARM_TLS_LE32
}
16112 /* Table of all conditional affixes. 0xF is not defined as a condition code. */
16113 static const struct asm_cond conds
[] =
16117 {"cs", 0x2}, {"hs", 0x2},
16118 {"cc", 0x3}, {"ul", 0x3}, {"lo", 0x3},
16132 static struct asm_barrier_opt barrier_opt_names
[] =
16140 /* Table of ARM-format instructions. */
16142 /* Macros for gluing together operand strings. N.B. In all cases
16143 other than OPS0, the trailing OP_stop comes from default
16144 zero-initialization of the unspecified elements of the array. */
16145 #define OPS0() { OP_stop, }
16146 #define OPS1(a) { OP_##a, }
16147 #define OPS2(a,b) { OP_##a,OP_##b, }
16148 #define OPS3(a,b,c) { OP_##a,OP_##b,OP_##c, }
16149 #define OPS4(a,b,c,d) { OP_##a,OP_##b,OP_##c,OP_##d, }
16150 #define OPS5(a,b,c,d,e) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e, }
16151 #define OPS6(a,b,c,d,e,f) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e,OP_##f, }
16153 /* These macros abstract out the exact format of the mnemonic table and
16154 save some repeated characters. */
16156 /* The normal sort of mnemonic; has a Thumb variant; takes a conditional suffix. */
16157 #define TxCE(mnem, op, top, nops, ops, ae, te) \
16158 { mnem, OPS##nops ops, OT_csuffix, 0x##op, top, ARM_VARIANT, \
16159 THUMB_VARIANT, do_##ae, do_##te }
16161 /* Two variants of the above - TCE for a numeric Thumb opcode, tCE for
16162 a T_MNEM_xyz enumerator. */
16163 #define TCE(mnem, aop, top, nops, ops, ae, te) \
16164 TxCE (mnem, aop, 0x##top, nops, ops, ae, te)
16165 #define tCE(mnem, aop, top, nops, ops, ae, te) \
16166 TxCE (mnem, aop, T_MNEM##top, nops, ops, ae, te)
16168 /* Second most common sort of mnemonic: has a Thumb variant, takes a conditional
16169 infix after the third character. */
16170 #define TxC3(mnem, op, top, nops, ops, ae, te) \
16171 { mnem, OPS##nops ops, OT_cinfix3, 0x##op, top, ARM_VARIANT, \
16172 THUMB_VARIANT, do_##ae, do_##te }
16173 #define TxC3w(mnem, op, top, nops, ops, ae, te) \
16174 { mnem, OPS##nops ops, OT_cinfix3_deprecated, 0x##op, top, ARM_VARIANT, \
16175 THUMB_VARIANT, do_##ae, do_##te }
16176 #define TC3(mnem, aop, top, nops, ops, ae, te) \
16177 TxC3 (mnem, aop, 0x##top, nops, ops, ae, te)
16178 #define TC3w(mnem, aop, top, nops, ops, ae, te) \
16179 TxC3w (mnem, aop, 0x##top, nops, ops, ae, te)
16180 #define tC3(mnem, aop, top, nops, ops, ae, te) \
16181 TxC3 (mnem, aop, T_MNEM##top, nops, ops, ae, te)
16182 #define tC3w(mnem, aop, top, nops, ops, ae, te) \
16183 TxC3w (mnem, aop, T_MNEM##top, nops, ops, ae, te)
16185 /* Mnemonic with a conditional infix in an unusual place. Each and every variant has to
16186 appear in the condition table. */
16187 #define TxCM_(m1, m2, m3, op, top, nops, ops, ae, te) \
16188 { m1 #m2 m3, OPS##nops ops, sizeof (#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof (m1) - 1, \
16189 0x##op, top, ARM_VARIANT, THUMB_VARIANT, do_##ae, do_##te }
16191 #define TxCM(m1, m2, op, top, nops, ops, ae, te) \
16192 TxCM_ (m1, , m2, op, top, nops, ops, ae, te), \
16193 TxCM_ (m1, eq, m2, op, top, nops, ops, ae, te), \
16194 TxCM_ (m1, ne, m2, op, top, nops, ops, ae, te), \
16195 TxCM_ (m1, cs, m2, op, top, nops, ops, ae, te), \
16196 TxCM_ (m1, hs, m2, op, top, nops, ops, ae, te), \
16197 TxCM_ (m1, cc, m2, op, top, nops, ops, ae, te), \
16198 TxCM_ (m1, ul, m2, op, top, nops, ops, ae, te), \
16199 TxCM_ (m1, lo, m2, op, top, nops, ops, ae, te), \
16200 TxCM_ (m1, mi, m2, op, top, nops, ops, ae, te), \
16201 TxCM_ (m1, pl, m2, op, top, nops, ops, ae, te), \
16202 TxCM_ (m1, vs, m2, op, top, nops, ops, ae, te), \
16203 TxCM_ (m1, vc, m2, op, top, nops, ops, ae, te), \
16204 TxCM_ (m1, hi, m2, op, top, nops, ops, ae, te), \
16205 TxCM_ (m1, ls, m2, op, top, nops, ops, ae, te), \
16206 TxCM_ (m1, ge, m2, op, top, nops, ops, ae, te), \
16207 TxCM_ (m1, lt, m2, op, top, nops, ops, ae, te), \
16208 TxCM_ (m1, gt, m2, op, top, nops, ops, ae, te), \
16209 TxCM_ (m1, le, m2, op, top, nops, ops, ae, te), \
16210 TxCM_ (m1, al, m2, op, top, nops, ops, ae, te)
16212 #define TCM(m1,m2, aop, top, nops, ops, ae, te) \
16213 TxCM (m1,m2, aop, 0x##top, nops, ops, ae, te)
16214 #define tCM(m1,m2, aop, top, nops, ops, ae, te) \
16215 TxCM (m1,m2, aop, T_MNEM##top, nops, ops, ae, te)
16217 /* Mnemonic that cannot be conditionalized. The ARM condition-code
16218 field is still 0xE. Many of the Thumb variants can be executed
16219 conditionally, so this is checked separately. */
16220 #define TUE(mnem, op, top, nops, ops, ae, te) \
16221 { mnem, OPS##nops ops, OT_unconditional, 0x##op, 0x##top, ARM_VARIANT, \
16222 THUMB_VARIANT, do_##ae, do_##te }
16224 /* Mnemonic that cannot be conditionalized, and bears 0xF in its ARM
16225 condition code field. */
16226 #define TUF(mnem, op, top, nops, ops, ae, te) \
16227 { mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##top, ARM_VARIANT, \
16228 THUMB_VARIANT, do_##ae, do_##te }
16230 /* ARM-only variants of all the above. */
16231 #define CE(mnem, op, nops, ops, ae) \
16232 { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
16234 #define C3(mnem, op, nops, ops, ae) \
16235 { #mnem, OPS##nops ops, OT_cinfix3, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
16237 /* Legacy mnemonics that always have conditional infix after the third
16239 #define CL(mnem, op, nops, ops, ae) \
16240 { mnem, OPS##nops ops, OT_cinfix3_legacy, \
16241 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
16243 /* Coprocessor instructions. Isomorphic between Arm and Thumb-2. */
16244 #define cCE(mnem, op, nops, ops, ae) \
16245 { mnem, OPS##nops ops, OT_csuffix, 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
16247 /* Legacy coprocessor instructions where conditional infix and conditional
16248 suffix are ambiguous. For consistency this includes all FPA instructions,
16249 not just the potentially ambiguous ones. */
16250 #define cCL(mnem, op, nops, ops, ae) \
16251 { mnem, OPS##nops ops, OT_cinfix3_legacy, \
16252 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
16254 /* Coprocessor, takes either a suffix or a position-3 infix
16255 (for an FPA corner case). */
16256 #define C3E(mnem, op, nops, ops, ae) \
16257 { mnem, OPS##nops ops, OT_csuf_or_in3, \
16258 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
16260 #define xCM_(m1, m2, m3, op, nops, ops, ae) \
16261 { m1 #m2 m3, OPS##nops ops, \
16262 sizeof (#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof (m1) - 1, \
16263 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
16265 #define CM(m1, m2, op, nops, ops, ae) \
16266 xCM_ (m1, , m2, op, nops, ops, ae), \
16267 xCM_ (m1, eq, m2, op, nops, ops, ae), \
16268 xCM_ (m1, ne, m2, op, nops, ops, ae), \
16269 xCM_ (m1, cs, m2, op, nops, ops, ae), \
16270 xCM_ (m1, hs, m2, op, nops, ops, ae), \
16271 xCM_ (m1, cc, m2, op, nops, ops, ae), \
16272 xCM_ (m1, ul, m2, op, nops, ops, ae), \
16273 xCM_ (m1, lo, m2, op, nops, ops, ae), \
16274 xCM_ (m1, mi, m2, op, nops, ops, ae), \
16275 xCM_ (m1, pl, m2, op, nops, ops, ae), \
16276 xCM_ (m1, vs, m2, op, nops, ops, ae), \
16277 xCM_ (m1, vc, m2, op, nops, ops, ae), \
16278 xCM_ (m1, hi, m2, op, nops, ops, ae), \
16279 xCM_ (m1, ls, m2, op, nops, ops, ae), \
16280 xCM_ (m1, ge, m2, op, nops, ops, ae), \
16281 xCM_ (m1, lt, m2, op, nops, ops, ae), \
16282 xCM_ (m1, gt, m2, op, nops, ops, ae), \
16283 xCM_ (m1, le, m2, op, nops, ops, ae), \
16284 xCM_ (m1, al, m2, op, nops, ops, ae)
16286 #define UE(mnem, op, nops, ops, ae) \
16287 { #mnem, OPS##nops ops, OT_unconditional, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
16289 #define UF(mnem, op, nops, ops, ae) \
16290 { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
16292 /* Neon data-processing. ARM versions are unconditional with cond=0xf.
16293 The Thumb and ARM variants are mostly the same (bits 0-23 and 24/28), so we
16294 use the same encoding function for each. */
16295 #define NUF(mnem, op, nops, ops, enc) \
16296 { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##op, \
16297 ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
16299 /* Neon data processing, version which indirects through neon_enc_tab for
16300 the various overloaded versions of opcodes. */
16301 #define nUF(mnem, op, nops, ops, enc) \
16302 { #mnem, OPS##nops ops, OT_unconditionalF, N_MNEM##op, N_MNEM##op, \
16303 ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
16305 /* Neon insn with conditional suffix for the ARM version, non-overloaded
16307 #define NCE_tag(mnem, op, nops, ops, enc, tag) \
16308 { #mnem, OPS##nops ops, tag, 0x##op, 0x##op, ARM_VARIANT, \
16309 THUMB_VARIANT, do_##enc, do_##enc }
16311 #define NCE(mnem, op, nops, ops, enc) \
16312 NCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
16314 #define NCEF(mnem, op, nops, ops, enc) \
16315 NCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
16317 /* Neon insn with conditional suffix for the ARM version, overloaded types. */
16318 #define nCE_tag(mnem, op, nops, ops, enc, tag) \
16319 { #mnem, OPS##nops ops, tag, N_MNEM##op, N_MNEM##op, \
16320 ARM_VARIANT, THUMB_VARIANT, do_##enc, do_##enc }
16322 #define nCE(mnem, op, nops, ops, enc) \
16323 nCE_tag (mnem, op, nops, ops, enc, OT_csuffix)
16325 #define nCEF(mnem, op, nops, ops, enc) \
16326 nCE_tag (mnem, op, nops, ops, enc, OT_csuffixF)
16330 /* Thumb-only, unconditional. */
16331 #define UT(mnem, op, nops, ops, te) TUE (mnem, 0, op, nops, ops, 0, te)
16333 static const struct asm_opcode insns
[] =
16335 #define ARM_VARIANT &arm_ext_v1 /* Core ARM Instructions. */
16336 #define THUMB_VARIANT &arm_ext_v4t
16337 tCE("and", 0000000, _and
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16338 tC3("ands", 0100000, _ands
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16339 tCE("eor", 0200000, _eor
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16340 tC3("eors", 0300000, _eors
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16341 tCE("sub", 0400000, _sub
, 3, (RR
, oRR
, SH
), arit
, t_add_sub
),
16342 tC3("subs", 0500000, _subs
, 3, (RR
, oRR
, SH
), arit
, t_add_sub
),
16343 tCE("add", 0800000, _add
, 3, (RR
, oRR
, SHG
), arit
, t_add_sub
),
16344 tC3("adds", 0900000, _adds
, 3, (RR
, oRR
, SHG
), arit
, t_add_sub
),
16345 tCE("adc", 0a00000
, _adc
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16346 tC3("adcs", 0b00000, _adcs
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16347 tCE("sbc", 0c00000
, _sbc
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
16348 tC3("sbcs", 0d00000
, _sbcs
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
16349 tCE("orr", 1800000, _orr
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16350 tC3("orrs", 1900000, _orrs
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
16351 tCE("bic", 1c00000
, _bic
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
16352 tC3("bics", 1d00000
, _bics
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
16354 /* The p-variants of tst/cmp/cmn/teq (below) are the pre-V6 mechanism
16355 for setting PSR flag bits. They are obsolete in V6 and do not
16356 have Thumb equivalents. */
16357 tCE("tst", 1100000, _tst
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16358 tC3w("tsts", 1100000, _tst
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16359 CL("tstp", 110f000
, 2, (RR
, SH
), cmp
),
16360 tCE("cmp", 1500000, _cmp
, 2, (RR
, SH
), cmp
, t_mov_cmp
),
16361 tC3w("cmps", 1500000, _cmp
, 2, (RR
, SH
), cmp
, t_mov_cmp
),
16362 CL("cmpp", 150f000
, 2, (RR
, SH
), cmp
),
16363 tCE("cmn", 1700000, _cmn
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16364 tC3w("cmns", 1700000, _cmn
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16365 CL("cmnp", 170f000
, 2, (RR
, SH
), cmp
),
16367 tCE("mov", 1a00000
, _mov
, 2, (RR
, SH
), mov
, t_mov_cmp
),
16368 tC3("movs", 1b00000
, _movs
, 2, (RR
, SH
), mov
, t_mov_cmp
),
16369 tCE("mvn", 1e00000
, _mvn
, 2, (RR
, SH
), mov
, t_mvn_tst
),
16370 tC3("mvns", 1f00000
, _mvns
, 2, (RR
, SH
), mov
, t_mvn_tst
),
16372 tCE("ldr", 4100000, _ldr
, 2, (RR
, ADDRGLDR
),ldst
, t_ldst
),
16373 tC3("ldrb", 4500000, _ldrb
, 2, (RR
, ADDRGLDR
),ldst
, t_ldst
),
16374 tCE("str", 4000000, _str
, 2, (RR
, ADDRGLDR
),ldst
, t_ldst
),
16375 tC3("strb", 4400000, _strb
, 2, (RR
, ADDRGLDR
),ldst
, t_ldst
),
16377 tCE("stm", 8800000, _stmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16378 tC3("stmia", 8800000, _stmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16379 tC3("stmea", 8800000, _stmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16380 tCE("ldm", 8900000, _ldmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16381 tC3("ldmia", 8900000, _ldmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16382 tC3("ldmfd", 8900000, _ldmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16384 TCE("swi", f000000
, df00
, 1, (EXPi
), swi
, t_swi
),
16385 TCE("svc", f000000
, df00
, 1, (EXPi
), swi
, t_swi
),
16386 tCE("b", a000000
, _b
, 1, (EXPr
), branch
, t_branch
),
16387 TCE("bl", b000000
, f000f800
, 1, (EXPr
), bl
, t_branch23
),
16390 tCE("adr", 28f0000
, _adr
, 2, (RR
, EXP
), adr
, t_adr
),
16391 C3(adrl
, 28f0000
, 2, (RR
, EXP
), adrl
),
16392 tCE("nop", 1a00000
, _nop
, 1, (oI255c
), nop
, t_nop
),
16394 /* Thumb-compatibility pseudo ops. */
16395 tCE("lsl", 1a00000
, _lsl
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16396 tC3("lsls", 1b00000
, _lsls
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16397 tCE("lsr", 1a00020
, _lsr
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16398 tC3("lsrs", 1b00020
, _lsrs
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16399 tCE("asr", 1a00040
, _asr
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16400 tC3("asrs", 1b00040
, _asrs
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16401 tCE("ror", 1a00060
, _ror
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16402 tC3("rors", 1b00060
, _rors
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
16403 tCE("neg", 2600000, _neg
, 2, (RR
, RR
), rd_rn
, t_neg
),
16404 tC3("negs", 2700000, _negs
, 2, (RR
, RR
), rd_rn
, t_neg
),
16405 tCE("push", 92d0000
, _push
, 1, (REGLST
), push_pop
, t_push_pop
),
16406 tCE("pop", 8bd0000
, _pop
, 1, (REGLST
), push_pop
, t_push_pop
),
16408 /* These may simplify to neg. */
16409 TCE("rsb", 0600000, ebc00000
, 3, (RR
, oRR
, SH
), arit
, t_rsb
),
16410 TC3("rsbs", 0700000, ebd00000
, 3, (RR
, oRR
, SH
), arit
, t_rsb
),
16412 #undef THUMB_VARIANT
16413 #define THUMB_VARIANT & arm_ext_v6
16415 TCE("cpy", 1a00000
, 4600, 2, (RR
, RR
), rd_rm
, t_cpy
),
16417 /* V1 instructions with no Thumb analogue prior to V6T2. */
16418 #undef THUMB_VARIANT
16419 #define THUMB_VARIANT & arm_ext_v6t2
16421 TCE("teq", 1300000, ea900f00
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16422 TC3w("teqs", 1300000, ea900f00
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
16423 CL("teqp", 130f000
, 2, (RR
, SH
), cmp
),
16425 TC3("ldrt", 4300000, f8500e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
16426 TC3("ldrbt", 4700000, f8100e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
16427 TC3("strt", 4200000, f8400e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
16428 TC3("strbt", 4600000, f8000e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
16430 TC3("stmdb", 9000000, e9000000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16431 TC3("stmfd", 9000000, e9000000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16433 TC3("ldmdb", 9100000, e9100000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16434 TC3("ldmea", 9100000, e9100000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
16436 /* V1 instructions with no Thumb analogue at all. */
16437 CE("rsc", 0e00000
, 3, (RR
, oRR
, SH
), arit
),
16438 C3(rscs
, 0f00000
, 3, (RR
, oRR
, SH
), arit
),
16440 C3(stmib
, 9800000, 2, (RRw
, REGLST
), ldmstm
),
16441 C3(stmfa
, 9800000, 2, (RRw
, REGLST
), ldmstm
),
16442 C3(stmda
, 8000000, 2, (RRw
, REGLST
), ldmstm
),
16443 C3(stmed
, 8000000, 2, (RRw
, REGLST
), ldmstm
),
16444 C3(ldmib
, 9900000, 2, (RRw
, REGLST
), ldmstm
),
16445 C3(ldmed
, 9900000, 2, (RRw
, REGLST
), ldmstm
),
16446 C3(ldmda
, 8100000, 2, (RRw
, REGLST
), ldmstm
),
16447 C3(ldmfa
, 8100000, 2, (RRw
, REGLST
), ldmstm
),
16450 #define ARM_VARIANT & arm_ext_v2 /* ARM 2 - multiplies. */
16451 #undef THUMB_VARIANT
16452 #define THUMB_VARIANT & arm_ext_v4t
16454 tCE("mul", 0000090, _mul
, 3, (RRnpc
, RRnpc
, oRR
), mul
, t_mul
),
16455 tC3("muls", 0100090, _muls
, 3, (RRnpc
, RRnpc
, oRR
), mul
, t_mul
),
16457 #undef THUMB_VARIANT
16458 #define THUMB_VARIANT & arm_ext_v6t2
16460 TCE("mla", 0200090, fb000000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mlas
, t_mla
),
16461 C3(mlas
, 0300090, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mlas
),
16463 /* Generic coprocessor instructions. */
16464 TCE("cdp", e000000
, ee000000
, 6, (RCP
, I15b
, RCN
, RCN
, RCN
, oI7b
), cdp
, cdp
),
16465 TCE("ldc", c100000
, ec100000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16466 TC3("ldcl", c500000
, ec500000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16467 TCE("stc", c000000
, ec000000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16468 TC3("stcl", c400000
, ec400000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16469 TCE("mcr", e000010
, ee000010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
16470 TCE("mrc", e100010
, ee100010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
16473 #define ARM_VARIANT & arm_ext_v2s /* ARM 3 - swp instructions. */
16475 CE("swp", 1000090, 3, (RRnpc
, RRnpc
, RRnpcb
), rd_rm_rn
),
16476 C3(swpb
, 1400090, 3, (RRnpc
, RRnpc
, RRnpcb
), rd_rm_rn
),
16479 #define ARM_VARIANT & arm_ext_v3 /* ARM 6 Status register instructions. */
16480 #undef THUMB_VARIANT
16481 #define THUMB_VARIANT & arm_ext_msr
16483 TCE("mrs", 10f0000
, f3ef8000
, 2, (APSR_RR
, RVC_PSR
), mrs
, t_mrs
),
16484 TCE("msr", 120f000
, f3808000
, 2, (RVC_PSR
, RR_EXi
), msr
, t_msr
),
16487 #define ARM_VARIANT & arm_ext_v3m /* ARM 7M long multiplies. */
16488 #undef THUMB_VARIANT
16489 #define THUMB_VARIANT & arm_ext_v6t2
16491 TCE("smull", 0c00090
, fb800000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
16492 CM("smull","s", 0d00090
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
16493 TCE("umull", 0800090, fba00000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
16494 CM("umull","s", 0900090, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
16495 TCE("smlal", 0e00090
, fbc00000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
16496 CM("smlal","s", 0f00090
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
16497 TCE("umlal", 0a00090
, fbe00000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
16498 CM("umlal","s", 0b00090, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
16501 #define ARM_VARIANT & arm_ext_v4 /* ARM Architecture 4. */
16502 #undef THUMB_VARIANT
16503 #define THUMB_VARIANT & arm_ext_v4t
16505 tC3("ldrh", 01000b0
, _ldrh
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16506 tC3("strh", 00000b0
, _strh
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16507 tC3("ldrsh", 01000f0
, _ldrsh
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16508 tC3("ldrsb", 01000d0
, _ldrsb
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16509 tCM("ld","sh", 01000f0
, _ldrsh
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16510 tCM("ld","sb", 01000d0
, _ldrsb
, 2, (RR
, ADDRGLDRS
), ldstv4
, t_ldst
),
16513 #define ARM_VARIANT & arm_ext_v4t_5
16515 /* ARM Architecture 4T. */
16516 /* Note: bx (and blx) are required on V5, even if the processor does
16517 not support Thumb. */
16518 TCE("bx", 12fff10
, 4700, 1, (RR
), bx
, t_bx
),
16521 #define ARM_VARIANT & arm_ext_v5 /* ARM Architecture 5T. */
16522 #undef THUMB_VARIANT
16523 #define THUMB_VARIANT & arm_ext_v5t
16525 /* Note: blx has 2 variants; the .value coded here is for
16526 BLX(2). Only this variant has conditional execution. */
16527 TCE("blx", 12fff30
, 4780, 1, (RR_EXr
), blx
, t_blx
),
16528 TUE("bkpt", 1200070, be00
, 1, (oIffffb
), bkpt
, t_bkpt
),
16530 #undef THUMB_VARIANT
16531 #define THUMB_VARIANT & arm_ext_v6t2
16533 TCE("clz", 16f0f10
, fab0f080
, 2, (RRnpc
, RRnpc
), rd_rm
, t_clz
),
16534 TUF("ldc2", c100000
, fc100000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16535 TUF("ldc2l", c500000
, fc500000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16536 TUF("stc2", c000000
, fc000000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16537 TUF("stc2l", c400000
, fc400000
, 3, (RCP
, RCN
, ADDRGLDC
), lstc
, lstc
),
16538 TUF("cdp2", e000000
, fe000000
, 6, (RCP
, I15b
, RCN
, RCN
, RCN
, oI7b
), cdp
, cdp
),
16539 TUF("mcr2", e000010
, fe000010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
16540 TUF("mrc2", e100010
, fe100010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
16543 #define ARM_VARIANT & arm_ext_v5exp /* ARM Architecture 5TExP. */
16544 #undef THUMB_VARIANT
16545 #define THUMB_VARIANT &arm_ext_v5exp
16547 TCE("smlabb", 1000080, fb100000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16548 TCE("smlatb", 10000a0
, fb100020
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16549 TCE("smlabt", 10000c0
, fb100010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16550 TCE("smlatt", 10000e0
, fb100030
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16552 TCE("smlawb", 1200080, fb300000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16553 TCE("smlawt", 12000c0
, fb300010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
16555 TCE("smlalbb", 1400080, fbc00080
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
16556 TCE("smlaltb", 14000a0
, fbc000a0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
16557 TCE("smlalbt", 14000c0
, fbc00090
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
16558 TCE("smlaltt", 14000e0
, fbc000b0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
16560 TCE("smulbb", 1600080, fb10f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16561 TCE("smultb", 16000a0
, fb10f020
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16562 TCE("smulbt", 16000c0
, fb10f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16563 TCE("smultt", 16000e0
, fb10f030
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16565 TCE("smulwb", 12000a0
, fb30f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16566 TCE("smulwt", 12000e0
, fb30f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16568 TCE("qadd", 1000050, fa80f080
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, t_simd2
),
16569 TCE("qdadd", 1400050, fa80f090
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, t_simd2
),
16570 TCE("qsub", 1200050, fa80f0a0
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, t_simd2
),
16571 TCE("qdsub", 1600050, fa80f0b0
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, t_simd2
),
16574 #define ARM_VARIANT & arm_ext_v5e /* ARM Architecture 5TE. */
16575 #undef THUMB_VARIANT
16576 #define THUMB_VARIANT &arm_ext_v6t2
16578 TUF("pld", 450f000
, f810f000
, 1, (ADDR
), pld
, t_pld
),
16579 TC3("ldrd", 00000d0
, e8500000
, 3, (RRnpc
, oRRnpc
, ADDRGLDRS
), ldrd
, t_ldstd
),
16580 TC3("strd", 00000f0
, e8400000
, 3, (RRnpc
, oRRnpc
, ADDRGLDRS
), ldrd
, t_ldstd
),
16582 TCE("mcrr", c400000
, ec400000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
16583 TCE("mrrc", c500000
, ec500000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
16586 #define ARM_VARIANT & arm_ext_v5j /* ARM Architecture 5TEJ. */
16588 TCE("bxj", 12fff20
, f3c08f00
, 1, (RR
), bxj
, t_bxj
),
16591 #define ARM_VARIANT & arm_ext_v6 /* ARM V6. */
16592 #undef THUMB_VARIANT
16593 #define THUMB_VARIANT & arm_ext_v6
16595 TUF("cpsie", 1080000, b660
, 2, (CPSF
, oI31b
), cpsi
, t_cpsi
),
16596 TUF("cpsid", 10c0000
, b670
, 2, (CPSF
, oI31b
), cpsi
, t_cpsi
),
16597 tCE("rev", 6bf0f30
, _rev
, 2, (RRnpc
, RRnpc
), rd_rm
, t_rev
),
16598 tCE("rev16", 6bf0fb0
, _rev16
, 2, (RRnpc
, RRnpc
), rd_rm
, t_rev
),
16599 tCE("revsh", 6ff0fb0
, _revsh
, 2, (RRnpc
, RRnpc
), rd_rm
, t_rev
),
16600 tCE("sxth", 6bf0070
, _sxth
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16601 tCE("uxth", 6ff0070
, _uxth
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16602 tCE("sxtb", 6af0070
, _sxtb
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16603 tCE("uxtb", 6ef0070
, _uxtb
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16604 TUF("setend", 1010000, b650
, 1, (ENDI
), setend
, t_setend
),
16606 #undef THUMB_VARIANT
16607 #define THUMB_VARIANT & arm_ext_v6t2
16609 TCE("ldrex", 1900f9f
, e8500f00
, 2, (RRnpc
, ADDR
), ldrex
, t_ldrex
),
16610 TCE("strex", 1800f90
, e8400000
, 3, (RRnpc
, RRnpc
, ADDR
), strex
, t_strex
),
16611 TUF("mcrr2", c400000
, fc400000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
16612 TUF("mrrc2", c500000
, fc500000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
16614 TCE("ssat", 6a00010
, f3000000
, 4, (RRnpc
, I32
, RRnpc
, oSHllar
),ssat
, t_ssat
),
16615 TCE("usat", 6e00010
, f3800000
, 4, (RRnpc
, I31
, RRnpc
, oSHllar
),usat
, t_usat
),
16617 /* ARM V6 not included in V7M. */
16618 #undef THUMB_VARIANT
16619 #define THUMB_VARIANT & arm_ext_v6_notm
16620 TUF("rfeia", 8900a00
, e990c000
, 1, (RRw
), rfe
, rfe
),
16621 UF(rfeib
, 9900a00
, 1, (RRw
), rfe
),
16622 UF(rfeda
, 8100a00
, 1, (RRw
), rfe
),
16623 TUF("rfedb", 9100a00
, e810c000
, 1, (RRw
), rfe
, rfe
),
16624 TUF("rfefd", 8900a00
, e990c000
, 1, (RRw
), rfe
, rfe
),
16625 UF(rfefa
, 9900a00
, 1, (RRw
), rfe
),
16626 UF(rfeea
, 8100a00
, 1, (RRw
), rfe
),
16627 TUF("rfeed", 9100a00
, e810c000
, 1, (RRw
), rfe
, rfe
),
16628 TUF("srsia", 8c00500
, e980c000
, 2, (oRRw
, I31w
), srs
, srs
),
16629 UF(srsib
, 9c00500
, 2, (oRRw
, I31w
), srs
),
16630 UF(srsda
, 8400500, 2, (oRRw
, I31w
), srs
),
16631 TUF("srsdb", 9400500, e800c000
, 2, (oRRw
, I31w
), srs
, srs
),
16633 /* ARM V6 not included in V7M (eg. integer SIMD). */
16634 #undef THUMB_VARIANT
16635 #define THUMB_VARIANT & arm_ext_v6_dsp
16636 TUF("cps", 1020000, f3af8100
, 1, (I31b
), imm0
, t_cps
),
16637 TCE("pkhbt", 6800010, eac00000
, 4, (RRnpc
, RRnpc
, RRnpc
, oSHll
), pkhbt
, t_pkhbt
),
16638 TCE("pkhtb", 6800050, eac00020
, 4, (RRnpc
, RRnpc
, RRnpc
, oSHar
), pkhtb
, t_pkhtb
),
16639 TCE("qadd16", 6200f10
, fa90f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16640 TCE("qadd8", 6200f90
, fa80f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16641 TCE("qasx", 6200f30
, faa0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16642 /* Old name for QASX. */
16643 TCE("qaddsubx", 6200f30
, faa0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16644 TCE("qsax", 6200f50
, fae0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16645 /* Old name for QSAX. */
16646 TCE("qsubaddx", 6200f50
, fae0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16647 TCE("qsub16", 6200f70
, fad0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16648 TCE("qsub8", 6200ff0
, fac0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16649 TCE("sadd16", 6100f10
, fa90f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16650 TCE("sadd8", 6100f90
, fa80f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16651 TCE("sasx", 6100f30
, faa0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16652 /* Old name for SASX. */
16653 TCE("saddsubx", 6100f30
, faa0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16654 TCE("shadd16", 6300f10
, fa90f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16655 TCE("shadd8", 6300f90
, fa80f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16656 TCE("shasx", 6300f30
, faa0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16657 /* Old name for SHASX. */
16658 TCE("shaddsubx", 6300f30
, faa0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16659 TCE("shsax", 6300f50
, fae0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16660 /* Old name for SHSAX. */
16661 TCE("shsubaddx", 6300f50
, fae0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16662 TCE("shsub16", 6300f70
, fad0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16663 TCE("shsub8", 6300ff0
, fac0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16664 TCE("ssax", 6100f50
, fae0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16665 /* Old name for SSAX. */
16666 TCE("ssubaddx", 6100f50
, fae0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16667 TCE("ssub16", 6100f70
, fad0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16668 TCE("ssub8", 6100ff0
, fac0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16669 TCE("uadd16", 6500f10
, fa90f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16670 TCE("uadd8", 6500f90
, fa80f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16671 TCE("uasx", 6500f30
, faa0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16672 /* Old name for UASX. */
16673 TCE("uaddsubx", 6500f30
, faa0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16674 TCE("uhadd16", 6700f10
, fa90f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16675 TCE("uhadd8", 6700f90
, fa80f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16676 TCE("uhasx", 6700f30
, faa0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16677 /* Old name for UHASX. */
16678 TCE("uhaddsubx", 6700f30
, faa0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16679 TCE("uhsax", 6700f50
, fae0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16680 /* Old name for UHSAX. */
16681 TCE("uhsubaddx", 6700f50
, fae0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16682 TCE("uhsub16", 6700f70
, fad0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16683 TCE("uhsub8", 6700ff0
, fac0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16684 TCE("uqadd16", 6600f10
, fa90f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16685 TCE("uqadd8", 6600f90
, fa80f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16686 TCE("uqasx", 6600f30
, faa0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16687 /* Old name for UQASX. */
16688 TCE("uqaddsubx", 6600f30
, faa0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16689 TCE("uqsax", 6600f50
, fae0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16690 /* Old name for UQSAX. */
16691 TCE("uqsubaddx", 6600f50
, fae0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16692 TCE("uqsub16", 6600f70
, fad0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16693 TCE("uqsub8", 6600ff0
, fac0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16694 TCE("usub16", 6500f70
, fad0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16695 TCE("usax", 6500f50
, fae0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16696 /* Old name for USAX. */
16697 TCE("usubaddx", 6500f50
, fae0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16698 TCE("usub8", 6500ff0
, fac0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16699 TCE("sxtah", 6b00070
, fa00f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16700 TCE("sxtab16", 6800070, fa20f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16701 TCE("sxtab", 6a00070
, fa40f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16702 TCE("sxtb16", 68f0070
, fa2ff080
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16703 TCE("uxtah", 6f00070
, fa10f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16704 TCE("uxtab16", 6c00070
, fa30f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16705 TCE("uxtab", 6e00070
, fa50f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
16706 TCE("uxtb16", 6cf0070
, fa3ff080
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
16707 TCE("sel", 6800fb0
, faa0f080
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
16708 TCE("smlad", 7000010, fb200000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16709 TCE("smladx", 7000030, fb200010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16710 TCE("smlald", 7400010, fbc000c0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
16711 TCE("smlaldx", 7400030, fbc000d0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
16712 TCE("smlsd", 7000050, fb400000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16713 TCE("smlsdx", 7000070, fb400010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16714 TCE("smlsld", 7400050, fbd000c0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
16715 TCE("smlsldx", 7400070, fbd000d0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
16716 TCE("smmla", 7500010, fb500000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16717 TCE("smmlar", 7500030, fb500010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16718 TCE("smmls", 75000d0
, fb600000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16719 TCE("smmlsr", 75000f0
, fb600010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16720 TCE("smmul", 750f010
, fb50f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16721 TCE("smmulr", 750f030
, fb50f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16722 TCE("smuad", 700f010
, fb20f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16723 TCE("smuadx", 700f030
, fb20f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16724 TCE("smusd", 700f050
, fb40f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16725 TCE("smusdx", 700f070
, fb40f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16726 TCE("ssat16", 6a00f30
, f3200000
, 3, (RRnpc
, I16
, RRnpc
), ssat16
, t_ssat16
),
16727 TCE("umaal", 0400090, fbe00060
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
, t_mlal
),
16728 TCE("usad8", 780f010
, fb70f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
16729 TCE("usada8", 7800010, fb700000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
16730 TCE("usat16", 6e00f30
, f3a00000
, 3, (RRnpc
, I15
, RRnpc
), usat16
, t_usat16
),
16733 #define ARM_VARIANT & arm_ext_v6k
16734 #undef THUMB_VARIANT
16735 #define THUMB_VARIANT & arm_ext_v6k
16737 tCE("yield", 320f001
, _yield
, 0, (), noargs
, t_hint
),
16738 tCE("wfe", 320f002
, _wfe
, 0, (), noargs
, t_hint
),
16739 tCE("wfi", 320f003
, _wfi
, 0, (), noargs
, t_hint
),
16740 tCE("sev", 320f004
, _sev
, 0, (), noargs
, t_hint
),
16742 #undef THUMB_VARIANT
16743 #define THUMB_VARIANT & arm_ext_v6_notm
16745 TCE("ldrexd", 1b00f9f
, e8d0007f
, 3, (RRnpc
, oRRnpc
, RRnpcb
), ldrexd
, t_ldrexd
),
16746 TCE("strexd", 1a00f90
, e8c00070
, 4, (RRnpc
, RRnpc
, oRRnpc
, RRnpcb
), strexd
, t_strexd
),
16748 #undef THUMB_VARIANT
16749 #define THUMB_VARIANT & arm_ext_v6t2
16751 TCE("ldrexb", 1d00f9f
, e8d00f4f
, 2, (RRnpc
, RRnpcb
), rd_rn
, rd_rn
),
16752 TCE("ldrexh", 1f00f9f
, e8d00f5f
, 2, (RRnpc
, RRnpcb
), rd_rn
, rd_rn
),
16753 TCE("strexb", 1c00f90
, e8c00f40
, 3, (RRnpc
, RRnpc
, ADDR
), strex
, rm_rd_rn
),
16754 TCE("strexh", 1e00f90
, e8c00f50
, 3, (RRnpc
, RRnpc
, ADDR
), strex
, rm_rd_rn
),
16755 TUF("clrex", 57ff01f
, f3bf8f2f
, 0, (), noargs
, noargs
),
16758 #define ARM_VARIANT & arm_ext_v6z
16760 TCE("smc", 1600070, f7f08000
, 1, (EXPi
), smc
, t_smc
),
16763 #define ARM_VARIANT & arm_ext_v6t2
16765 TCE("bfc", 7c0001f
, f36f0000
, 3, (RRnpc
, I31
, I32
), bfc
, t_bfc
),
16766 TCE("bfi", 7c00010
, f3600000
, 4, (RRnpc
, RRnpc_I0
, I31
, I32
), bfi
, t_bfi
),
16767 TCE("sbfx", 7a00050
, f3400000
, 4, (RR
, RR
, I31
, I32
), bfx
, t_bfx
),
16768 TCE("ubfx", 7e00050
, f3c00000
, 4, (RR
, RR
, I31
, I32
), bfx
, t_bfx
),
16770 TCE("mls", 0600090, fb000010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mlas
, t_mla
),
16771 TCE("movw", 3000000, f2400000
, 2, (RRnpc
, HALF
), mov16
, t_mov16
),
16772 TCE("movt", 3400000, f2c00000
, 2, (RRnpc
, HALF
), mov16
, t_mov16
),
16773 TCE("rbit", 6ff0f30
, fa90f0a0
, 2, (RR
, RR
), rd_rm
, t_rbit
),
16775 TC3("ldrht", 03000b0
, f8300e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
16776 TC3("ldrsht", 03000f0
, f9300e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
16777 TC3("ldrsbt", 03000d0
, f9100e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
16778 TC3("strht", 02000b0
, f8200e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
16780 UT("cbnz", b900
, 2, (RR
, EXP
), t_cbz
),
16781 UT("cbz", b100
, 2, (RR
, EXP
), t_cbz
),
16783 /* ARM does not really have an IT instruction, so always allow it.
16784 The opcode is copied from Thumb in order to allow warnings in
16785 -mimplicit-it=[never | arm] modes. */
16787 #define ARM_VARIANT & arm_ext_v1
16789 TUE("it", bf08
, bf08
, 1, (COND
), it
, t_it
),
16790 TUE("itt", bf0c
, bf0c
, 1, (COND
), it
, t_it
),
16791 TUE("ite", bf04
, bf04
, 1, (COND
), it
, t_it
),
16792 TUE("ittt", bf0e
, bf0e
, 1, (COND
), it
, t_it
),
16793 TUE("itet", bf06
, bf06
, 1, (COND
), it
, t_it
),
16794 TUE("itte", bf0a
, bf0a
, 1, (COND
), it
, t_it
),
16795 TUE("itee", bf02
, bf02
, 1, (COND
), it
, t_it
),
16796 TUE("itttt", bf0f
, bf0f
, 1, (COND
), it
, t_it
),
16797 TUE("itett", bf07
, bf07
, 1, (COND
), it
, t_it
),
16798 TUE("ittet", bf0b
, bf0b
, 1, (COND
), it
, t_it
),
16799 TUE("iteet", bf03
, bf03
, 1, (COND
), it
, t_it
),
16800 TUE("ittte", bf0d
, bf0d
, 1, (COND
), it
, t_it
),
16801 TUE("itete", bf05
, bf05
, 1, (COND
), it
, t_it
),
16802 TUE("ittee", bf09
, bf09
, 1, (COND
), it
, t_it
),
16803 TUE("iteee", bf01
, bf01
, 1, (COND
), it
, t_it
),
16804 /* ARM/Thumb-2 instructions with no Thumb-1 equivalent. */
16805 TC3("rrx", 01a00060
, ea4f0030
, 2, (RR
, RR
), rd_rm
, t_rrx
),
16806 TC3("rrxs", 01b00060
, ea5f0030
, 2, (RR
, RR
), rd_rm
, t_rrx
),
16808 /* Thumb2 only instructions. */
16810 #define ARM_VARIANT NULL
16812 TCE("addw", 0, f2000000
, 3, (RR
, RR
, EXPi
), 0, t_add_sub_w
),
16813 TCE("subw", 0, f2a00000
, 3, (RR
, RR
, EXPi
), 0, t_add_sub_w
),
16814 TCE("orn", 0, ea600000
, 3, (RR
, oRR
, SH
), 0, t_orn
),
16815 TCE("orns", 0, ea700000
, 3, (RR
, oRR
, SH
), 0, t_orn
),
16816 TCE("tbb", 0, e8d0f000
, 1, (TB
), 0, t_tb
),
16817 TCE("tbh", 0, e8d0f010
, 1, (TB
), 0, t_tb
),
16819 /* Thumb-2 hardware division instructions (R and M profiles only). */
16820 #undef THUMB_VARIANT
16821 #define THUMB_VARIANT & arm_ext_div
16823 TCE("sdiv", 0, fb90f0f0
, 3, (RR
, oRR
, RR
), 0, t_div
),
16824 TCE("udiv", 0, fbb0f0f0
, 3, (RR
, oRR
, RR
), 0, t_div
),
16826 /* ARM V6M/V7 instructions. */
16828 #define ARM_VARIANT & arm_ext_barrier
16829 #undef THUMB_VARIANT
16830 #define THUMB_VARIANT & arm_ext_barrier
16832 TUF("dmb", 57ff050
, f3bf8f50
, 1, (oBARRIER
), barrier
, t_barrier
),
16833 TUF("dsb", 57ff040
, f3bf8f40
, 1, (oBARRIER
), barrier
, t_barrier
),
16834 TUF("isb", 57ff060
, f3bf8f60
, 1, (oBARRIER
), barrier
, t_barrier
),
16836 /* ARM V7 instructions. */
16838 #define ARM_VARIANT & arm_ext_v7
16839 #undef THUMB_VARIANT
16840 #define THUMB_VARIANT & arm_ext_v7
16842 TUF("pli", 450f000
, f910f000
, 1, (ADDR
), pli
, t_pld
),
16843 TCE("dbg", 320f0f0
, f3af80f0
, 1, (I15
), dbg
, t_dbg
),
16846 #define ARM_VARIANT & fpu_fpa_ext_v1 /* Core FPA instruction set (V1). */
16848 cCE("wfs", e200110
, 1, (RR
), rd
),
16849 cCE("rfs", e300110
, 1, (RR
), rd
),
16850 cCE("wfc", e400110
, 1, (RR
), rd
),
16851 cCE("rfc", e500110
, 1, (RR
), rd
),
16853 cCL("ldfs", c100100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16854 cCL("ldfd", c108100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16855 cCL("ldfe", c500100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16856 cCL("ldfp", c508100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16858 cCL("stfs", c000100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16859 cCL("stfd", c008100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16860 cCL("stfe", c400100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16861 cCL("stfp", c408100
, 2, (RF
, ADDRGLDC
), rd_cpaddr
),
16863 cCL("mvfs", e008100
, 2, (RF
, RF_IF
), rd_rm
),
16864 cCL("mvfsp", e008120
, 2, (RF
, RF_IF
), rd_rm
),
16865 cCL("mvfsm", e008140
, 2, (RF
, RF_IF
), rd_rm
),
16866 cCL("mvfsz", e008160
, 2, (RF
, RF_IF
), rd_rm
),
16867 cCL("mvfd", e008180
, 2, (RF
, RF_IF
), rd_rm
),
16868 cCL("mvfdp", e0081a0
, 2, (RF
, RF_IF
), rd_rm
),
16869 cCL("mvfdm", e0081c0
, 2, (RF
, RF_IF
), rd_rm
),
16870 cCL("mvfdz", e0081e0
, 2, (RF
, RF_IF
), rd_rm
),
16871 cCL("mvfe", e088100
, 2, (RF
, RF_IF
), rd_rm
),
16872 cCL("mvfep", e088120
, 2, (RF
, RF_IF
), rd_rm
),
16873 cCL("mvfem", e088140
, 2, (RF
, RF_IF
), rd_rm
),
16874 cCL("mvfez", e088160
, 2, (RF
, RF_IF
), rd_rm
),
16876 cCL("mnfs", e108100
, 2, (RF
, RF_IF
), rd_rm
),
16877 cCL("mnfsp", e108120
, 2, (RF
, RF_IF
), rd_rm
),
16878 cCL("mnfsm", e108140
, 2, (RF
, RF_IF
), rd_rm
),
16879 cCL("mnfsz", e108160
, 2, (RF
, RF_IF
), rd_rm
),
16880 cCL("mnfd", e108180
, 2, (RF
, RF_IF
), rd_rm
),
16881 cCL("mnfdp", e1081a0
, 2, (RF
, RF_IF
), rd_rm
),
16882 cCL("mnfdm", e1081c0
, 2, (RF
, RF_IF
), rd_rm
),
16883 cCL("mnfdz", e1081e0
, 2, (RF
, RF_IF
), rd_rm
),
16884 cCL("mnfe", e188100
, 2, (RF
, RF_IF
), rd_rm
),
16885 cCL("mnfep", e188120
, 2, (RF
, RF_IF
), rd_rm
),
16886 cCL("mnfem", e188140
, 2, (RF
, RF_IF
), rd_rm
),
16887 cCL("mnfez", e188160
, 2, (RF
, RF_IF
), rd_rm
),
16889 cCL("abss", e208100
, 2, (RF
, RF_IF
), rd_rm
),
16890 cCL("abssp", e208120
, 2, (RF
, RF_IF
), rd_rm
),
16891 cCL("abssm", e208140
, 2, (RF
, RF_IF
), rd_rm
),
16892 cCL("abssz", e208160
, 2, (RF
, RF_IF
), rd_rm
),
16893 cCL("absd", e208180
, 2, (RF
, RF_IF
), rd_rm
),
16894 cCL("absdp", e2081a0
, 2, (RF
, RF_IF
), rd_rm
),
16895 cCL("absdm", e2081c0
, 2, (RF
, RF_IF
), rd_rm
),
16896 cCL("absdz", e2081e0
, 2, (RF
, RF_IF
), rd_rm
),
16897 cCL("abse", e288100
, 2, (RF
, RF_IF
), rd_rm
),
16898 cCL("absep", e288120
, 2, (RF
, RF_IF
), rd_rm
),
16899 cCL("absem", e288140
, 2, (RF
, RF_IF
), rd_rm
),
16900 cCL("absez", e288160
, 2, (RF
, RF_IF
), rd_rm
),
16902 cCL("rnds", e308100
, 2, (RF
, RF_IF
), rd_rm
),
16903 cCL("rndsp", e308120
, 2, (RF
, RF_IF
), rd_rm
),
16904 cCL("rndsm", e308140
, 2, (RF
, RF_IF
), rd_rm
),
16905 cCL("rndsz", e308160
, 2, (RF
, RF_IF
), rd_rm
),
16906 cCL("rndd", e308180
, 2, (RF
, RF_IF
), rd_rm
),
16907 cCL("rnddp", e3081a0
, 2, (RF
, RF_IF
), rd_rm
),
16908 cCL("rnddm", e3081c0
, 2, (RF
, RF_IF
), rd_rm
),
16909 cCL("rnddz", e3081e0
, 2, (RF
, RF_IF
), rd_rm
),
16910 cCL("rnde", e388100
, 2, (RF
, RF_IF
), rd_rm
),
16911 cCL("rndep", e388120
, 2, (RF
, RF_IF
), rd_rm
),
16912 cCL("rndem", e388140
, 2, (RF
, RF_IF
), rd_rm
),
16913 cCL("rndez", e388160
, 2, (RF
, RF_IF
), rd_rm
),
16915 cCL("sqts", e408100
, 2, (RF
, RF_IF
), rd_rm
),
16916 cCL("sqtsp", e408120
, 2, (RF
, RF_IF
), rd_rm
),
16917 cCL("sqtsm", e408140
, 2, (RF
, RF_IF
), rd_rm
),
16918 cCL("sqtsz", e408160
, 2, (RF
, RF_IF
), rd_rm
),
16919 cCL("sqtd", e408180
, 2, (RF
, RF_IF
), rd_rm
),
16920 cCL("sqtdp", e4081a0
, 2, (RF
, RF_IF
), rd_rm
),
16921 cCL("sqtdm", e4081c0
, 2, (RF
, RF_IF
), rd_rm
),
16922 cCL("sqtdz", e4081e0
, 2, (RF
, RF_IF
), rd_rm
),
16923 cCL("sqte", e488100
, 2, (RF
, RF_IF
), rd_rm
),
16924 cCL("sqtep", e488120
, 2, (RF
, RF_IF
), rd_rm
),
16925 cCL("sqtem", e488140
, 2, (RF
, RF_IF
), rd_rm
),
16926 cCL("sqtez", e488160
, 2, (RF
, RF_IF
), rd_rm
),
16928 cCL("logs", e508100
, 2, (RF
, RF_IF
), rd_rm
),
16929 cCL("logsp", e508120
, 2, (RF
, RF_IF
), rd_rm
),
16930 cCL("logsm", e508140
, 2, (RF
, RF_IF
), rd_rm
),
16931 cCL("logsz", e508160
, 2, (RF
, RF_IF
), rd_rm
),
16932 cCL("logd", e508180
, 2, (RF
, RF_IF
), rd_rm
),
16933 cCL("logdp", e5081a0
, 2, (RF
, RF_IF
), rd_rm
),
16934 cCL("logdm", e5081c0
, 2, (RF
, RF_IF
), rd_rm
),
16935 cCL("logdz", e5081e0
, 2, (RF
, RF_IF
), rd_rm
),
16936 cCL("loge", e588100
, 2, (RF
, RF_IF
), rd_rm
),
16937 cCL("logep", e588120
, 2, (RF
, RF_IF
), rd_rm
),
16938 cCL("logem", e588140
, 2, (RF
, RF_IF
), rd_rm
),
16939 cCL("logez", e588160
, 2, (RF
, RF_IF
), rd_rm
),
16941 cCL("lgns", e608100
, 2, (RF
, RF_IF
), rd_rm
),
16942 cCL("lgnsp", e608120
, 2, (RF
, RF_IF
), rd_rm
),
16943 cCL("lgnsm", e608140
, 2, (RF
, RF_IF
), rd_rm
),
16944 cCL("lgnsz", e608160
, 2, (RF
, RF_IF
), rd_rm
),
16945 cCL("lgnd", e608180
, 2, (RF
, RF_IF
), rd_rm
),
16946 cCL("lgndp", e6081a0
, 2, (RF
, RF_IF
), rd_rm
),
16947 cCL("lgndm", e6081c0
, 2, (RF
, RF_IF
), rd_rm
),
16948 cCL("lgndz", e6081e0
, 2, (RF
, RF_IF
), rd_rm
),
16949 cCL("lgne", e688100
, 2, (RF
, RF_IF
), rd_rm
),
16950 cCL("lgnep", e688120
, 2, (RF
, RF_IF
), rd_rm
),
16951 cCL("lgnem", e688140
, 2, (RF
, RF_IF
), rd_rm
),
16952 cCL("lgnez", e688160
, 2, (RF
, RF_IF
), rd_rm
),
16954 cCL("exps", e708100
, 2, (RF
, RF_IF
), rd_rm
),
16955 cCL("expsp", e708120
, 2, (RF
, RF_IF
), rd_rm
),
16956 cCL("expsm", e708140
, 2, (RF
, RF_IF
), rd_rm
),
16957 cCL("expsz", e708160
, 2, (RF
, RF_IF
), rd_rm
),
16958 cCL("expd", e708180
, 2, (RF
, RF_IF
), rd_rm
),
16959 cCL("expdp", e7081a0
, 2, (RF
, RF_IF
), rd_rm
),
16960 cCL("expdm", e7081c0
, 2, (RF
, RF_IF
), rd_rm
),
16961 cCL("expdz", e7081e0
, 2, (RF
, RF_IF
), rd_rm
),
16962 cCL("expe", e788100
, 2, (RF
, RF_IF
), rd_rm
),
16963 cCL("expep", e788120
, 2, (RF
, RF_IF
), rd_rm
),
16964 cCL("expem", e788140
, 2, (RF
, RF_IF
), rd_rm
),
16965 cCL("expdz", e788160
, 2, (RF
, RF_IF
), rd_rm
),
16967 cCL("sins", e808100
, 2, (RF
, RF_IF
), rd_rm
),
16968 cCL("sinsp", e808120
, 2, (RF
, RF_IF
), rd_rm
),
16969 cCL("sinsm", e808140
, 2, (RF
, RF_IF
), rd_rm
),
16970 cCL("sinsz", e808160
, 2, (RF
, RF_IF
), rd_rm
),
16971 cCL("sind", e808180
, 2, (RF
, RF_IF
), rd_rm
),
16972 cCL("sindp", e8081a0
, 2, (RF
, RF_IF
), rd_rm
),
16973 cCL("sindm", e8081c0
, 2, (RF
, RF_IF
), rd_rm
),
16974 cCL("sindz", e8081e0
, 2, (RF
, RF_IF
), rd_rm
),
16975 cCL("sine", e888100
, 2, (RF
, RF_IF
), rd_rm
),
16976 cCL("sinep", e888120
, 2, (RF
, RF_IF
), rd_rm
),
16977 cCL("sinem", e888140
, 2, (RF
, RF_IF
), rd_rm
),
16978 cCL("sinez", e888160
, 2, (RF
, RF_IF
), rd_rm
),
16980 cCL("coss", e908100
, 2, (RF
, RF_IF
), rd_rm
),
16981 cCL("cossp", e908120
, 2, (RF
, RF_IF
), rd_rm
),
16982 cCL("cossm", e908140
, 2, (RF
, RF_IF
), rd_rm
),
16983 cCL("cossz", e908160
, 2, (RF
, RF_IF
), rd_rm
),
16984 cCL("cosd", e908180
, 2, (RF
, RF_IF
), rd_rm
),
16985 cCL("cosdp", e9081a0
, 2, (RF
, RF_IF
), rd_rm
),
16986 cCL("cosdm", e9081c0
, 2, (RF
, RF_IF
), rd_rm
),
16987 cCL("cosdz", e9081e0
, 2, (RF
, RF_IF
), rd_rm
),
16988 cCL("cose", e988100
, 2, (RF
, RF_IF
), rd_rm
),
16989 cCL("cosep", e988120
, 2, (RF
, RF_IF
), rd_rm
),
16990 cCL("cosem", e988140
, 2, (RF
, RF_IF
), rd_rm
),
16991 cCL("cosez", e988160
, 2, (RF
, RF_IF
), rd_rm
),
16993 cCL("tans", ea08100
, 2, (RF
, RF_IF
), rd_rm
),
16994 cCL("tansp", ea08120
, 2, (RF
, RF_IF
), rd_rm
),
16995 cCL("tansm", ea08140
, 2, (RF
, RF_IF
), rd_rm
),
16996 cCL("tansz", ea08160
, 2, (RF
, RF_IF
), rd_rm
),
16997 cCL("tand", ea08180
, 2, (RF
, RF_IF
), rd_rm
),
16998 cCL("tandp", ea081a0
, 2, (RF
, RF_IF
), rd_rm
),
16999 cCL("tandm", ea081c0
, 2, (RF
, RF_IF
), rd_rm
),
17000 cCL("tandz", ea081e0
, 2, (RF
, RF_IF
), rd_rm
),
17001 cCL("tane", ea88100
, 2, (RF
, RF_IF
), rd_rm
),
17002 cCL("tanep", ea88120
, 2, (RF
, RF_IF
), rd_rm
),
17003 cCL("tanem", ea88140
, 2, (RF
, RF_IF
), rd_rm
),
17004 cCL("tanez", ea88160
, 2, (RF
, RF_IF
), rd_rm
),
17006 cCL("asns", eb08100
, 2, (RF
, RF_IF
), rd_rm
),
17007 cCL("asnsp", eb08120
, 2, (RF
, RF_IF
), rd_rm
),
17008 cCL("asnsm", eb08140
, 2, (RF
, RF_IF
), rd_rm
),
17009 cCL("asnsz", eb08160
, 2, (RF
, RF_IF
), rd_rm
),
17010 cCL("asnd", eb08180
, 2, (RF
, RF_IF
), rd_rm
),
17011 cCL("asndp", eb081a0
, 2, (RF
, RF_IF
), rd_rm
),
17012 cCL("asndm", eb081c0
, 2, (RF
, RF_IF
), rd_rm
),
17013 cCL("asndz", eb081e0
, 2, (RF
, RF_IF
), rd_rm
),
17014 cCL("asne", eb88100
, 2, (RF
, RF_IF
), rd_rm
),
17015 cCL("asnep", eb88120
, 2, (RF
, RF_IF
), rd_rm
),
17016 cCL("asnem", eb88140
, 2, (RF
, RF_IF
), rd_rm
),
17017 cCL("asnez", eb88160
, 2, (RF
, RF_IF
), rd_rm
),
17019 cCL("acss", ec08100
, 2, (RF
, RF_IF
), rd_rm
),
17020 cCL("acssp", ec08120
, 2, (RF
, RF_IF
), rd_rm
),
17021 cCL("acssm", ec08140
, 2, (RF
, RF_IF
), rd_rm
),
17022 cCL("acssz", ec08160
, 2, (RF
, RF_IF
), rd_rm
),
17023 cCL("acsd", ec08180
, 2, (RF
, RF_IF
), rd_rm
),
17024 cCL("acsdp", ec081a0
, 2, (RF
, RF_IF
), rd_rm
),
17025 cCL("acsdm", ec081c0
, 2, (RF
, RF_IF
), rd_rm
),
17026 cCL("acsdz", ec081e0
, 2, (RF
, RF_IF
), rd_rm
),
17027 cCL("acse", ec88100
, 2, (RF
, RF_IF
), rd_rm
),
17028 cCL("acsep", ec88120
, 2, (RF
, RF_IF
), rd_rm
),
17029 cCL("acsem", ec88140
, 2, (RF
, RF_IF
), rd_rm
),
17030 cCL("acsez", ec88160
, 2, (RF
, RF_IF
), rd_rm
),
17032 cCL("atns", ed08100
, 2, (RF
, RF_IF
), rd_rm
),
17033 cCL("atnsp", ed08120
, 2, (RF
, RF_IF
), rd_rm
),
17034 cCL("atnsm", ed08140
, 2, (RF
, RF_IF
), rd_rm
),
17035 cCL("atnsz", ed08160
, 2, (RF
, RF_IF
), rd_rm
),
17036 cCL("atnd", ed08180
, 2, (RF
, RF_IF
), rd_rm
),
17037 cCL("atndp", ed081a0
, 2, (RF
, RF_IF
), rd_rm
),
17038 cCL("atndm", ed081c0
, 2, (RF
, RF_IF
), rd_rm
),
17039 cCL("atndz", ed081e0
, 2, (RF
, RF_IF
), rd_rm
),
17040 cCL("atne", ed88100
, 2, (RF
, RF_IF
), rd_rm
),
17041 cCL("atnep", ed88120
, 2, (RF
, RF_IF
), rd_rm
),
17042 cCL("atnem", ed88140
, 2, (RF
, RF_IF
), rd_rm
),
17043 cCL("atnez", ed88160
, 2, (RF
, RF_IF
), rd_rm
),
17045 cCL("urds", ee08100
, 2, (RF
, RF_IF
), rd_rm
),
17046 cCL("urdsp", ee08120
, 2, (RF
, RF_IF
), rd_rm
),
17047 cCL("urdsm", ee08140
, 2, (RF
, RF_IF
), rd_rm
),
17048 cCL("urdsz", ee08160
, 2, (RF
, RF_IF
), rd_rm
),
17049 cCL("urdd", ee08180
, 2, (RF
, RF_IF
), rd_rm
),
17050 cCL("urddp", ee081a0
, 2, (RF
, RF_IF
), rd_rm
),
17051 cCL("urddm", ee081c0
, 2, (RF
, RF_IF
), rd_rm
),
17052 cCL("urddz", ee081e0
, 2, (RF
, RF_IF
), rd_rm
),
17053 cCL("urde", ee88100
, 2, (RF
, RF_IF
), rd_rm
),
17054 cCL("urdep", ee88120
, 2, (RF
, RF_IF
), rd_rm
),
17055 cCL("urdem", ee88140
, 2, (RF
, RF_IF
), rd_rm
),
17056 cCL("urdez", ee88160
, 2, (RF
, RF_IF
), rd_rm
),
17058 cCL("nrms", ef08100
, 2, (RF
, RF_IF
), rd_rm
),
17059 cCL("nrmsp", ef08120
, 2, (RF
, RF_IF
), rd_rm
),
17060 cCL("nrmsm", ef08140
, 2, (RF
, RF_IF
), rd_rm
),
17061 cCL("nrmsz", ef08160
, 2, (RF
, RF_IF
), rd_rm
),
17062 cCL("nrmd", ef08180
, 2, (RF
, RF_IF
), rd_rm
),
17063 cCL("nrmdp", ef081a0
, 2, (RF
, RF_IF
), rd_rm
),
17064 cCL("nrmdm", ef081c0
, 2, (RF
, RF_IF
), rd_rm
),
17065 cCL("nrmdz", ef081e0
, 2, (RF
, RF_IF
), rd_rm
),
17066 cCL("nrme", ef88100
, 2, (RF
, RF_IF
), rd_rm
),
17067 cCL("nrmep", ef88120
, 2, (RF
, RF_IF
), rd_rm
),
17068 cCL("nrmem", ef88140
, 2, (RF
, RF_IF
), rd_rm
),
17069 cCL("nrmez", ef88160
, 2, (RF
, RF_IF
), rd_rm
),
17071 cCL("adfs", e000100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17072 cCL("adfsp", e000120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17073 cCL("adfsm", e000140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17074 cCL("adfsz", e000160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17075 cCL("adfd", e000180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17076 cCL("adfdp", e0001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17077 cCL("adfdm", e0001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17078 cCL("adfdz", e0001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17079 cCL("adfe", e080100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17080 cCL("adfep", e080120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17081 cCL("adfem", e080140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17082 cCL("adfez", e080160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17084 cCL("sufs", e200100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17085 cCL("sufsp", e200120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17086 cCL("sufsm", e200140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17087 cCL("sufsz", e200160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17088 cCL("sufd", e200180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17089 cCL("sufdp", e2001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17090 cCL("sufdm", e2001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17091 cCL("sufdz", e2001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17092 cCL("sufe", e280100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17093 cCL("sufep", e280120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17094 cCL("sufem", e280140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17095 cCL("sufez", e280160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17097 cCL("rsfs", e300100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17098 cCL("rsfsp", e300120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17099 cCL("rsfsm", e300140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17100 cCL("rsfsz", e300160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17101 cCL("rsfd", e300180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17102 cCL("rsfdp", e3001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17103 cCL("rsfdm", e3001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17104 cCL("rsfdz", e3001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17105 cCL("rsfe", e380100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17106 cCL("rsfep", e380120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17107 cCL("rsfem", e380140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17108 cCL("rsfez", e380160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17110 cCL("mufs", e100100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17111 cCL("mufsp", e100120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17112 cCL("mufsm", e100140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17113 cCL("mufsz", e100160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17114 cCL("mufd", e100180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17115 cCL("mufdp", e1001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17116 cCL("mufdm", e1001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17117 cCL("mufdz", e1001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17118 cCL("mufe", e180100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17119 cCL("mufep", e180120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17120 cCL("mufem", e180140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17121 cCL("mufez", e180160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17123 cCL("dvfs", e400100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17124 cCL("dvfsp", e400120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17125 cCL("dvfsm", e400140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17126 cCL("dvfsz", e400160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17127 cCL("dvfd", e400180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17128 cCL("dvfdp", e4001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17129 cCL("dvfdm", e4001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17130 cCL("dvfdz", e4001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17131 cCL("dvfe", e480100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17132 cCL("dvfep", e480120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17133 cCL("dvfem", e480140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17134 cCL("dvfez", e480160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17136 cCL("rdfs", e500100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17137 cCL("rdfsp", e500120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17138 cCL("rdfsm", e500140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17139 cCL("rdfsz", e500160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17140 cCL("rdfd", e500180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17141 cCL("rdfdp", e5001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17142 cCL("rdfdm", e5001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17143 cCL("rdfdz", e5001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17144 cCL("rdfe", e580100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17145 cCL("rdfep", e580120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17146 cCL("rdfem", e580140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17147 cCL("rdfez", e580160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17149 cCL("pows", e600100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17150 cCL("powsp", e600120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17151 cCL("powsm", e600140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17152 cCL("powsz", e600160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17153 cCL("powd", e600180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17154 cCL("powdp", e6001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17155 cCL("powdm", e6001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17156 cCL("powdz", e6001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17157 cCL("powe", e680100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17158 cCL("powep", e680120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17159 cCL("powem", e680140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17160 cCL("powez", e680160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17162 cCL("rpws", e700100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17163 cCL("rpwsp", e700120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17164 cCL("rpwsm", e700140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17165 cCL("rpwsz", e700160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17166 cCL("rpwd", e700180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17167 cCL("rpwdp", e7001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17168 cCL("rpwdm", e7001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17169 cCL("rpwdz", e7001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17170 cCL("rpwe", e780100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17171 cCL("rpwep", e780120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17172 cCL("rpwem", e780140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17173 cCL("rpwez", e780160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17175 cCL("rmfs", e800100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17176 cCL("rmfsp", e800120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17177 cCL("rmfsm", e800140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17178 cCL("rmfsz", e800160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17179 cCL("rmfd", e800180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17180 cCL("rmfdp", e8001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17181 cCL("rmfdm", e8001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17182 cCL("rmfdz", e8001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17183 cCL("rmfe", e880100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17184 cCL("rmfep", e880120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17185 cCL("rmfem", e880140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17186 cCL("rmfez", e880160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17188 cCL("fmls", e900100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17189 cCL("fmlsp", e900120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17190 cCL("fmlsm", e900140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17191 cCL("fmlsz", e900160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17192 cCL("fmld", e900180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17193 cCL("fmldp", e9001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17194 cCL("fmldm", e9001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17195 cCL("fmldz", e9001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17196 cCL("fmle", e980100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17197 cCL("fmlep", e980120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17198 cCL("fmlem", e980140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17199 cCL("fmlez", e980160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17201 cCL("fdvs", ea00100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17202 cCL("fdvsp", ea00120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17203 cCL("fdvsm", ea00140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17204 cCL("fdvsz", ea00160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17205 cCL("fdvd", ea00180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17206 cCL("fdvdp", ea001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17207 cCL("fdvdm", ea001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17208 cCL("fdvdz", ea001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17209 cCL("fdve", ea80100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17210 cCL("fdvep", ea80120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17211 cCL("fdvem", ea80140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17212 cCL("fdvez", ea80160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17214 cCL("frds", eb00100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17215 cCL("frdsp", eb00120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17216 cCL("frdsm", eb00140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17217 cCL("frdsz", eb00160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17218 cCL("frdd", eb00180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17219 cCL("frddp", eb001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17220 cCL("frddm", eb001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17221 cCL("frddz", eb001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17222 cCL("frde", eb80100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17223 cCL("frdep", eb80120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17224 cCL("frdem", eb80140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17225 cCL("frdez", eb80160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17227 cCL("pols", ec00100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17228 cCL("polsp", ec00120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17229 cCL("polsm", ec00140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17230 cCL("polsz", ec00160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17231 cCL("pold", ec00180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17232 cCL("poldp", ec001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17233 cCL("poldm", ec001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17234 cCL("poldz", ec001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17235 cCL("pole", ec80100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17236 cCL("polep", ec80120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17237 cCL("polem", ec80140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17238 cCL("polez", ec80160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
17240 cCE("cmf", e90f110
, 2, (RF
, RF_IF
), fpa_cmp
),
17241 C3E("cmfe", ed0f110
, 2, (RF
, RF_IF
), fpa_cmp
),
17242 cCE("cnf", eb0f110
, 2, (RF
, RF_IF
), fpa_cmp
),
17243 C3E("cnfe", ef0f110
, 2, (RF
, RF_IF
), fpa_cmp
),
17245 cCL("flts", e000110
, 2, (RF
, RR
), rn_rd
),
17246 cCL("fltsp", e000130
, 2, (RF
, RR
), rn_rd
),
17247 cCL("fltsm", e000150
, 2, (RF
, RR
), rn_rd
),
17248 cCL("fltsz", e000170
, 2, (RF
, RR
), rn_rd
),
17249 cCL("fltd", e000190
, 2, (RF
, RR
), rn_rd
),
17250 cCL("fltdp", e0001b0
, 2, (RF
, RR
), rn_rd
),
17251 cCL("fltdm", e0001d0
, 2, (RF
, RR
), rn_rd
),
17252 cCL("fltdz", e0001f0
, 2, (RF
, RR
), rn_rd
),
17253 cCL("flte", e080110
, 2, (RF
, RR
), rn_rd
),
17254 cCL("fltep", e080130
, 2, (RF
, RR
), rn_rd
),
17255 cCL("fltem", e080150
, 2, (RF
, RR
), rn_rd
),
17256 cCL("fltez", e080170
, 2, (RF
, RR
), rn_rd
),
17258 /* The implementation of the FIX instruction is broken on some
17259 assemblers, in that it accepts a precision specifier as well as a
17260 rounding specifier, despite the fact that this is meaningless.
17261 To be more compatible, we accept it as well, though of course it
17262 does not set any bits. */
17263 cCE("fix", e100110
, 2, (RR
, RF
), rd_rm
),
17264 cCL("fixp", e100130
, 2, (RR
, RF
), rd_rm
),
17265 cCL("fixm", e100150
, 2, (RR
, RF
), rd_rm
),
17266 cCL("fixz", e100170
, 2, (RR
, RF
), rd_rm
),
17267 cCL("fixsp", e100130
, 2, (RR
, RF
), rd_rm
),
17268 cCL("fixsm", e100150
, 2, (RR
, RF
), rd_rm
),
17269 cCL("fixsz", e100170
, 2, (RR
, RF
), rd_rm
),
17270 cCL("fixdp", e100130
, 2, (RR
, RF
), rd_rm
),
17271 cCL("fixdm", e100150
, 2, (RR
, RF
), rd_rm
),
17272 cCL("fixdz", e100170
, 2, (RR
, RF
), rd_rm
),
17273 cCL("fixep", e100130
, 2, (RR
, RF
), rd_rm
),
17274 cCL("fixem", e100150
, 2, (RR
, RF
), rd_rm
),
17275 cCL("fixez", e100170
, 2, (RR
, RF
), rd_rm
),
17277 /* Instructions that were new with the real FPA, call them V2. */
17279 #define ARM_VARIANT & fpu_fpa_ext_v2
17281 cCE("lfm", c100200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17282 cCL("lfmfd", c900200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17283 cCL("lfmea", d100200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17284 cCE("sfm", c000200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17285 cCL("sfmfd", d000200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17286 cCL("sfmea", c800200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
17289 #define ARM_VARIANT & fpu_vfp_ext_v1xd /* VFP V1xD (single precision). */
17291 /* Moves and type conversions. */
17292 cCE("fcpys", eb00a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17293 cCE("fmrs", e100a10
, 2, (RR
, RVS
), vfp_reg_from_sp
),
17294 cCE("fmsr", e000a10
, 2, (RVS
, RR
), vfp_sp_from_reg
),
17295 cCE("fmstat", ef1fa10
, 0, (), noargs
),
17296 cCE("vmrs", ef10a10
, 2, (APSR_RR
, RVC
), vmrs
),
17297 cCE("vmsr", ee10a10
, 2, (RVC
, RR
), vmsr
),
17298 cCE("fsitos", eb80ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17299 cCE("fuitos", eb80a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17300 cCE("ftosis", ebd0a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17301 cCE("ftosizs", ebd0ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17302 cCE("ftouis", ebc0a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17303 cCE("ftouizs", ebc0ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17304 cCE("fmrx", ef00a10
, 2, (RR
, RVC
), rd_rn
),
17305 cCE("fmxr", ee00a10
, 2, (RVC
, RR
), rn_rd
),
17307 /* Memory operations. */
17308 cCE("flds", d100a00
, 2, (RVS
, ADDRGLDC
), vfp_sp_ldst
),
17309 cCE("fsts", d000a00
, 2, (RVS
, ADDRGLDC
), vfp_sp_ldst
),
17310 cCE("fldmias", c900a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
17311 cCE("fldmfds", c900a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
17312 cCE("fldmdbs", d300a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
17313 cCE("fldmeas", d300a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
17314 cCE("fldmiax", c900b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
17315 cCE("fldmfdx", c900b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
17316 cCE("fldmdbx", d300b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
17317 cCE("fldmeax", d300b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
17318 cCE("fstmias", c800a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
17319 cCE("fstmeas", c800a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
17320 cCE("fstmdbs", d200a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
17321 cCE("fstmfds", d200a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
17322 cCE("fstmiax", c800b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
17323 cCE("fstmeax", c800b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
17324 cCE("fstmdbx", d200b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
17325 cCE("fstmfdx", d200b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
17327 /* Monadic operations. */
17328 cCE("fabss", eb00ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17329 cCE("fnegs", eb10a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17330 cCE("fsqrts", eb10ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17332 /* Dyadic operations. */
17333 cCE("fadds", e300a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17334 cCE("fsubs", e300a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17335 cCE("fmuls", e200a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17336 cCE("fdivs", e800a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17337 cCE("fmacs", e000a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17338 cCE("fmscs", e100a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17339 cCE("fnmuls", e200a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17340 cCE("fnmacs", e000a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17341 cCE("fnmscs", e100a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17344 cCE("fcmps", eb40a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17345 cCE("fcmpzs", eb50a40
, 1, (RVS
), vfp_sp_compare_z
),
17346 cCE("fcmpes", eb40ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
17347 cCE("fcmpezs", eb50ac0
, 1, (RVS
), vfp_sp_compare_z
),
17349 /* Double precision load/store are still present on single precision
17350 implementations. */
17351 cCE("fldd", d100b00
, 2, (RVD
, ADDRGLDC
), vfp_dp_ldst
),
17352 cCE("fstd", d000b00
, 2, (RVD
, ADDRGLDC
), vfp_dp_ldst
),
17353 cCE("fldmiad", c900b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
17354 cCE("fldmfdd", c900b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
17355 cCE("fldmdbd", d300b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
17356 cCE("fldmead", d300b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
17357 cCE("fstmiad", c800b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
17358 cCE("fstmead", c800b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
17359 cCE("fstmdbd", d200b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
17360 cCE("fstmfdd", d200b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
17363 #define ARM_VARIANT & fpu_vfp_ext_v1 /* VFP V1 (Double precision). */
17365 /* Moves and type conversions. */
17366 cCE("fcpyd", eb00b40
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17367 cCE("fcvtds", eb70ac0
, 2, (RVD
, RVS
), vfp_dp_sp_cvt
),
17368 cCE("fcvtsd", eb70bc0
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
17369 cCE("fmdhr", e200b10
, 2, (RVD
, RR
), vfp_dp_rn_rd
),
17370 cCE("fmdlr", e000b10
, 2, (RVD
, RR
), vfp_dp_rn_rd
),
17371 cCE("fmrdh", e300b10
, 2, (RR
, RVD
), vfp_dp_rd_rn
),
17372 cCE("fmrdl", e100b10
, 2, (RR
, RVD
), vfp_dp_rd_rn
),
17373 cCE("fsitod", eb80bc0
, 2, (RVD
, RVS
), vfp_dp_sp_cvt
),
17374 cCE("fuitod", eb80b40
, 2, (RVD
, RVS
), vfp_dp_sp_cvt
),
17375 cCE("ftosid", ebd0b40
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
17376 cCE("ftosizd", ebd0bc0
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
17377 cCE("ftouid", ebc0b40
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
17378 cCE("ftouizd", ebc0bc0
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
17380 /* Monadic operations. */
17381 cCE("fabsd", eb00bc0
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17382 cCE("fnegd", eb10b40
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17383 cCE("fsqrtd", eb10bc0
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17385 /* Dyadic operations. */
17386 cCE("faddd", e300b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17387 cCE("fsubd", e300b40
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17388 cCE("fmuld", e200b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17389 cCE("fdivd", e800b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17390 cCE("fmacd", e000b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17391 cCE("fmscd", e100b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17392 cCE("fnmuld", e200b40
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17393 cCE("fnmacd", e000b40
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17394 cCE("fnmscd", e100b40
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17397 cCE("fcmpd", eb40b40
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17398 cCE("fcmpzd", eb50b40
, 1, (RVD
), vfp_dp_rd
),
17399 cCE("fcmped", eb40bc0
, 2, (RVD
, RVD
), vfp_dp_rd_rm
),
17400 cCE("fcmpezd", eb50bc0
, 1, (RVD
), vfp_dp_rd
),
17403 #define ARM_VARIANT & fpu_vfp_ext_v2
17405 cCE("fmsrr", c400a10
, 3, (VRSLST
, RR
, RR
), vfp_sp2_from_reg2
),
17406 cCE("fmrrs", c500a10
, 3, (RR
, RR
, VRSLST
), vfp_reg2_from_sp2
),
17407 cCE("fmdrr", c400b10
, 3, (RVD
, RR
, RR
), vfp_dp_rm_rd_rn
),
17408 cCE("fmrrd", c500b10
, 3, (RR
, RR
, RVD
), vfp_dp_rd_rn_rm
),
17410 /* Instructions which may belong to either the Neon or VFP instruction sets.
17411 Individual encoder functions perform additional architecture checks. */
17413 #define ARM_VARIANT & fpu_vfp_ext_v1xd
17414 #undef THUMB_VARIANT
17415 #define THUMB_VARIANT & fpu_vfp_ext_v1xd
17417 /* These mnemonics are unique to VFP. */
17418 NCE(vsqrt
, 0, 2, (RVSD
, RVSD
), vfp_nsyn_sqrt
),
17419 NCE(vdiv
, 0, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_div
),
17420 nCE(vnmul
, _vnmul
, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_nmul
),
17421 nCE(vnmla
, _vnmla
, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_nmul
),
17422 nCE(vnmls
, _vnmls
, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_nmul
),
17423 nCE(vcmp
, _vcmp
, 2, (RVSD
, RVSD_I0
), vfp_nsyn_cmp
),
17424 nCE(vcmpe
, _vcmpe
, 2, (RVSD
, RVSD_I0
), vfp_nsyn_cmp
),
17425 NCE(vpush
, 0, 1, (VRSDLST
), vfp_nsyn_push
),
17426 NCE(vpop
, 0, 1, (VRSDLST
), vfp_nsyn_pop
),
17427 NCE(vcvtz
, 0, 2, (RVSD
, RVSD
), vfp_nsyn_cvtz
),
17429 /* Mnemonics shared by Neon and VFP. */
17430 nCEF(vmul
, _vmul
, 3, (RNSDQ
, oRNSDQ
, RNSDQ_RNSC
), neon_mul
),
17431 nCEF(vmla
, _vmla
, 3, (RNSDQ
, oRNSDQ
, RNSDQ_RNSC
), neon_mac_maybe_scalar
),
17432 nCEF(vmls
, _vmls
, 3, (RNSDQ
, oRNSDQ
, RNSDQ_RNSC
), neon_mac_maybe_scalar
),
17434 nCEF(vadd
, _vadd
, 3, (RNSDQ
, oRNSDQ
, RNSDQ
), neon_addsub_if_i
),
17435 nCEF(vsub
, _vsub
, 3, (RNSDQ
, oRNSDQ
, RNSDQ
), neon_addsub_if_i
),
17437 NCEF(vabs
, 1b10300
, 2, (RNSDQ
, RNSDQ
), neon_abs_neg
),
17438 NCEF(vneg
, 1b10380
, 2, (RNSDQ
, RNSDQ
), neon_abs_neg
),
17440 NCE(vldm
, c900b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17441 NCE(vldmia
, c900b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17442 NCE(vldmdb
, d100b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17443 NCE(vstm
, c800b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17444 NCE(vstmia
, c800b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17445 NCE(vstmdb
, d000b00
, 2, (RRw
, VRSDLST
), neon_ldm_stm
),
17446 NCE(vldr
, d100b00
, 2, (RVSD
, ADDRGLDC
), neon_ldr_str
),
17447 NCE(vstr
, d000b00
, 2, (RVSD
, ADDRGLDC
), neon_ldr_str
),
17449 nCEF(vcvt
, _vcvt
, 3, (RNSDQ
, RNSDQ
, oI32b
), neon_cvt
),
17450 nCEF(vcvtr
, _vcvt
, 2, (RNSDQ
, RNSDQ
), neon_cvtr
),
17451 nCEF(vcvtb
, _vcvt
, 2, (RVS
, RVS
), neon_cvtb
),
17452 nCEF(vcvtt
, _vcvt
, 2, (RVS
, RVS
), neon_cvtt
),
17455 /* NOTE: All VMOV encoding is special-cased! */
17456 NCE(vmov
, 0, 1, (VMOV
), neon_mov
),
17457 NCE(vmovq
, 0, 1, (VMOV
), neon_mov
),
17459 #undef THUMB_VARIANT
17460 #define THUMB_VARIANT & fpu_neon_ext_v1
17462 #define ARM_VARIANT & fpu_neon_ext_v1
17464 /* Data processing with three registers of the same length. */
17465 /* integer ops, valid types S8 S16 S32 U8 U16 U32. */
17466 NUF(vaba
, 0000710, 3, (RNDQ
, RNDQ
, RNDQ
), neon_dyadic_i_su
),
17467 NUF(vabaq
, 0000710, 3, (RNQ
, RNQ
, RNQ
), neon_dyadic_i_su
),
17468 NUF(vhadd
, 0000000, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_i_su
),
17469 NUF(vhaddq
, 0000000, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_i_su
),
17470 NUF(vrhadd
, 0000100, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_i_su
),
17471 NUF(vrhaddq
, 0000100, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_i_su
),
17472 NUF(vhsub
, 0000200, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_i_su
),
17473 NUF(vhsubq
, 0000200, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_i_su
),
17474 /* integer ops, valid types S8 S16 S32 S64 U8 U16 U32 U64. */
17475 NUF(vqadd
, 0000010, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_i64_su
),
17476 NUF(vqaddq
, 0000010, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_i64_su
),
17477 NUF(vqsub
, 0000210, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_i64_su
),
17478 NUF(vqsubq
, 0000210, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_i64_su
),
17479 NUF(vrshl
, 0000500, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_rshl
),
17480 NUF(vrshlq
, 0000500, 3, (RNQ
, oRNQ
, RNQ
), neon_rshl
),
17481 NUF(vqrshl
, 0000510, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_rshl
),
17482 NUF(vqrshlq
, 0000510, 3, (RNQ
, oRNQ
, RNQ
), neon_rshl
),
17483 /* If not immediate, fall back to neon_dyadic_i64_su.
17484 shl_imm should accept I8 I16 I32 I64,
17485 qshl_imm should accept S8 S16 S32 S64 U8 U16 U32 U64. */
17486 nUF(vshl
, _vshl
, 3, (RNDQ
, oRNDQ
, RNDQ_I63b
), neon_shl_imm
),
17487 nUF(vshlq
, _vshl
, 3, (RNQ
, oRNQ
, RNDQ_I63b
), neon_shl_imm
),
17488 nUF(vqshl
, _vqshl
, 3, (RNDQ
, oRNDQ
, RNDQ_I63b
), neon_qshl_imm
),
17489 nUF(vqshlq
, _vqshl
, 3, (RNQ
, oRNQ
, RNDQ_I63b
), neon_qshl_imm
),
17490 /* Logic ops, types optional & ignored. */
17491 nUF(vand
, _vand
, 3, (RNDQ
, oRNDQ
, RNDQ_Ibig
), neon_logic
),
17492 nUF(vandq
, _vand
, 3, (RNQ
, oRNQ
, RNDQ_Ibig
), neon_logic
),
17493 nUF(vbic
, _vbic
, 3, (RNDQ
, oRNDQ
, RNDQ_Ibig
), neon_logic
),
17494 nUF(vbicq
, _vbic
, 3, (RNQ
, oRNQ
, RNDQ_Ibig
), neon_logic
),
17495 nUF(vorr
, _vorr
, 3, (RNDQ
, oRNDQ
, RNDQ_Ibig
), neon_logic
),
17496 nUF(vorrq
, _vorr
, 3, (RNQ
, oRNQ
, RNDQ_Ibig
), neon_logic
),
17497 nUF(vorn
, _vorn
, 3, (RNDQ
, oRNDQ
, RNDQ_Ibig
), neon_logic
),
17498 nUF(vornq
, _vorn
, 3, (RNQ
, oRNQ
, RNDQ_Ibig
), neon_logic
),
17499 nUF(veor
, _veor
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_logic
),
17500 nUF(veorq
, _veor
, 3, (RNQ
, oRNQ
, RNQ
), neon_logic
),
17501 /* Bitfield ops, untyped. */
17502 NUF(vbsl
, 1100110, 3, (RNDQ
, RNDQ
, RNDQ
), neon_bitfield
),
17503 NUF(vbslq
, 1100110, 3, (RNQ
, RNQ
, RNQ
), neon_bitfield
),
17504 NUF(vbit
, 1200110, 3, (RNDQ
, RNDQ
, RNDQ
), neon_bitfield
),
17505 NUF(vbitq
, 1200110, 3, (RNQ
, RNQ
, RNQ
), neon_bitfield
),
17506 NUF(vbif
, 1300110, 3, (RNDQ
, RNDQ
, RNDQ
), neon_bitfield
),
17507 NUF(vbifq
, 1300110, 3, (RNQ
, RNQ
, RNQ
), neon_bitfield
),
17508 /* Int and float variants, types S8 S16 S32 U8 U16 U32 F32. */
17509 nUF(vabd
, _vabd
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_if_su
),
17510 nUF(vabdq
, _vabd
, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_if_su
),
17511 nUF(vmax
, _vmax
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_if_su
),
17512 nUF(vmaxq
, _vmax
, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_if_su
),
17513 nUF(vmin
, _vmin
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_dyadic_if_su
),
17514 nUF(vminq
, _vmin
, 3, (RNQ
, oRNQ
, RNQ
), neon_dyadic_if_su
),
17515 /* Comparisons. Types S8 S16 S32 U8 U16 U32 F32. Non-immediate versions fall
17516 back to neon_dyadic_if_su. */
17517 nUF(vcge
, _vcge
, 3, (RNDQ
, oRNDQ
, RNDQ_I0
), neon_cmp
),
17518 nUF(vcgeq
, _vcge
, 3, (RNQ
, oRNQ
, RNDQ_I0
), neon_cmp
),
17519 nUF(vcgt
, _vcgt
, 3, (RNDQ
, oRNDQ
, RNDQ_I0
), neon_cmp
),
17520 nUF(vcgtq
, _vcgt
, 3, (RNQ
, oRNQ
, RNDQ_I0
), neon_cmp
),
17521 nUF(vclt
, _vclt
, 3, (RNDQ
, oRNDQ
, RNDQ_I0
), neon_cmp_inv
),
17522 nUF(vcltq
, _vclt
, 3, (RNQ
, oRNQ
, RNDQ_I0
), neon_cmp_inv
),
17523 nUF(vcle
, _vcle
, 3, (RNDQ
, oRNDQ
, RNDQ_I0
), neon_cmp_inv
),
17524 nUF(vcleq
, _vcle
, 3, (RNQ
, oRNQ
, RNDQ_I0
), neon_cmp_inv
),
17525 /* Comparison. Type I8 I16 I32 F32. */
17526 nUF(vceq
, _vceq
, 3, (RNDQ
, oRNDQ
, RNDQ_I0
), neon_ceq
),
17527 nUF(vceqq
, _vceq
, 3, (RNQ
, oRNQ
, RNDQ_I0
), neon_ceq
),
17528 /* As above, D registers only. */
17529 nUF(vpmax
, _vpmax
, 3, (RND
, oRND
, RND
), neon_dyadic_if_su_d
),
17530 nUF(vpmin
, _vpmin
, 3, (RND
, oRND
, RND
), neon_dyadic_if_su_d
),
17531 /* Int and float variants, signedness unimportant. */
17532 nUF(vmlaq
, _vmla
, 3, (RNQ
, oRNQ
, RNDQ_RNSC
), neon_mac_maybe_scalar
),
17533 nUF(vmlsq
, _vmls
, 3, (RNQ
, oRNQ
, RNDQ_RNSC
), neon_mac_maybe_scalar
),
17534 nUF(vpadd
, _vpadd
, 3, (RND
, oRND
, RND
), neon_dyadic_if_i_d
),
17535 /* Add/sub take types I8 I16 I32 I64 F32. */
17536 nUF(vaddq
, _vadd
, 3, (RNQ
, oRNQ
, RNQ
), neon_addsub_if_i
),
17537 nUF(vsubq
, _vsub
, 3, (RNQ
, oRNQ
, RNQ
), neon_addsub_if_i
),
17538 /* vtst takes sizes 8, 16, 32. */
17539 NUF(vtst
, 0000810, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_tst
),
17540 NUF(vtstq
, 0000810, 3, (RNQ
, oRNQ
, RNQ
), neon_tst
),
17541 /* VMUL takes I8 I16 I32 F32 P8. */
17542 nUF(vmulq
, _vmul
, 3, (RNQ
, oRNQ
, RNDQ_RNSC
), neon_mul
),
17543 /* VQD{R}MULH takes S16 S32. */
17544 nUF(vqdmulh
, _vqdmulh
, 3, (RNDQ
, oRNDQ
, RNDQ_RNSC
), neon_qdmulh
),
17545 nUF(vqdmulhq
, _vqdmulh
, 3, (RNQ
, oRNQ
, RNDQ_RNSC
), neon_qdmulh
),
17546 nUF(vqrdmulh
, _vqrdmulh
, 3, (RNDQ
, oRNDQ
, RNDQ_RNSC
), neon_qdmulh
),
17547 nUF(vqrdmulhq
, _vqrdmulh
, 3, (RNQ
, oRNQ
, RNDQ_RNSC
), neon_qdmulh
),
17548 NUF(vacge
, 0000e10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_fcmp_absolute
),
17549 NUF(vacgeq
, 0000e10
, 3, (RNQ
, oRNQ
, RNQ
), neon_fcmp_absolute
),
17550 NUF(vacgt
, 0200e10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_fcmp_absolute
),
17551 NUF(vacgtq
, 0200e10
, 3, (RNQ
, oRNQ
, RNQ
), neon_fcmp_absolute
),
17552 NUF(vaclt
, 0200e10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_fcmp_absolute_inv
),
17553 NUF(vacltq
, 0200e10
, 3, (RNQ
, oRNQ
, RNQ
), neon_fcmp_absolute_inv
),
17554 NUF(vacle
, 0000e10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_fcmp_absolute_inv
),
17555 NUF(vacleq
, 0000e10
, 3, (RNQ
, oRNQ
, RNQ
), neon_fcmp_absolute_inv
),
17556 NUF(vrecps
, 0000f10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_step
),
17557 NUF(vrecpsq
, 0000f10
, 3, (RNQ
, oRNQ
, RNQ
), neon_step
),
17558 NUF(vrsqrts
, 0200f10
, 3, (RNDQ
, oRNDQ
, RNDQ
), neon_step
),
17559 NUF(vrsqrtsq
, 0200f10
, 3, (RNQ
, oRNQ
, RNQ
), neon_step
),
17561 /* Two address, int/float. Types S8 S16 S32 F32. */
17562 NUF(vabsq
, 1b10300
, 2, (RNQ
, RNQ
), neon_abs_neg
),
17563 NUF(vnegq
, 1b10380
, 2, (RNQ
, RNQ
), neon_abs_neg
),
17565 /* Data processing with two registers and a shift amount. */
17566 /* Right shifts, and variants with rounding.
17567 Types accepted S8 S16 S32 S64 U8 U16 U32 U64. */
17568 NUF(vshr
, 0800010, 3, (RNDQ
, oRNDQ
, I64z
), neon_rshift_round_imm
),
17569 NUF(vshrq
, 0800010, 3, (RNQ
, oRNQ
, I64z
), neon_rshift_round_imm
),
17570 NUF(vrshr
, 0800210, 3, (RNDQ
, oRNDQ
, I64z
), neon_rshift_round_imm
),
17571 NUF(vrshrq
, 0800210, 3, (RNQ
, oRNQ
, I64z
), neon_rshift_round_imm
),
17572 NUF(vsra
, 0800110, 3, (RNDQ
, oRNDQ
, I64
), neon_rshift_round_imm
),
17573 NUF(vsraq
, 0800110, 3, (RNQ
, oRNQ
, I64
), neon_rshift_round_imm
),
17574 NUF(vrsra
, 0800310, 3, (RNDQ
, oRNDQ
, I64
), neon_rshift_round_imm
),
17575 NUF(vrsraq
, 0800310, 3, (RNQ
, oRNQ
, I64
), neon_rshift_round_imm
),
17576 /* Shift and insert. Sizes accepted 8 16 32 64. */
17577 NUF(vsli
, 1800510, 3, (RNDQ
, oRNDQ
, I63
), neon_sli
),
17578 NUF(vsliq
, 1800510, 3, (RNQ
, oRNQ
, I63
), neon_sli
),
17579 NUF(vsri
, 1800410, 3, (RNDQ
, oRNDQ
, I64
), neon_sri
),
17580 NUF(vsriq
, 1800410, 3, (RNQ
, oRNQ
, I64
), neon_sri
),
17581 /* QSHL{U} immediate accepts S8 S16 S32 S64 U8 U16 U32 U64. */
17582 NUF(vqshlu
, 1800610, 3, (RNDQ
, oRNDQ
, I63
), neon_qshlu_imm
),
17583 NUF(vqshluq
, 1800610, 3, (RNQ
, oRNQ
, I63
), neon_qshlu_imm
),
17584 /* Right shift immediate, saturating & narrowing, with rounding variants.
17585 Types accepted S16 S32 S64 U16 U32 U64. */
17586 NUF(vqshrn
, 0800910, 3, (RND
, RNQ
, I32z
), neon_rshift_sat_narrow
),
17587 NUF(vqrshrn
, 0800950, 3, (RND
, RNQ
, I32z
), neon_rshift_sat_narrow
),
17588 /* As above, unsigned. Types accepted S16 S32 S64. */
17589 NUF(vqshrun
, 0800810, 3, (RND
, RNQ
, I32z
), neon_rshift_sat_narrow_u
),
17590 NUF(vqrshrun
, 0800850, 3, (RND
, RNQ
, I32z
), neon_rshift_sat_narrow_u
),
17591 /* Right shift narrowing. Types accepted I16 I32 I64. */
17592 NUF(vshrn
, 0800810, 3, (RND
, RNQ
, I32z
), neon_rshift_narrow
),
17593 NUF(vrshrn
, 0800850, 3, (RND
, RNQ
, I32z
), neon_rshift_narrow
),
17594 /* Special case. Types S8 S16 S32 U8 U16 U32. Handles max shift variant. */
17595 nUF(vshll
, _vshll
, 3, (RNQ
, RND
, I32
), neon_shll
),
17596 /* CVT with optional immediate for fixed-point variant. */
17597 nUF(vcvtq
, _vcvt
, 3, (RNQ
, RNQ
, oI32b
), neon_cvt
),
17599 nUF(vmvn
, _vmvn
, 2, (RNDQ
, RNDQ_Ibig
), neon_mvn
),
17600 nUF(vmvnq
, _vmvn
, 2, (RNQ
, RNDQ_Ibig
), neon_mvn
),
17602 /* Data processing, three registers of different lengths. */
17603 /* Dyadic, long insns. Types S8 S16 S32 U8 U16 U32. */
17604 NUF(vabal
, 0800500, 3, (RNQ
, RND
, RND
), neon_abal
),
17605 NUF(vabdl
, 0800700, 3, (RNQ
, RND
, RND
), neon_dyadic_long
),
17606 NUF(vaddl
, 0800000, 3, (RNQ
, RND
, RND
), neon_dyadic_long
),
17607 NUF(vsubl
, 0800200, 3, (RNQ
, RND
, RND
), neon_dyadic_long
),
17608 /* If not scalar, fall back to neon_dyadic_long.
17609 Vector types as above, scalar types S16 S32 U16 U32. */
17610 nUF(vmlal
, _vmlal
, 3, (RNQ
, RND
, RND_RNSC
), neon_mac_maybe_scalar_long
),
17611 nUF(vmlsl
, _vmlsl
, 3, (RNQ
, RND
, RND_RNSC
), neon_mac_maybe_scalar_long
),
17612 /* Dyadic, widening insns. Types S8 S16 S32 U8 U16 U32. */
17613 NUF(vaddw
, 0800100, 3, (RNQ
, oRNQ
, RND
), neon_dyadic_wide
),
17614 NUF(vsubw
, 0800300, 3, (RNQ
, oRNQ
, RND
), neon_dyadic_wide
),
17615 /* Dyadic, narrowing insns. Types I16 I32 I64. */
17616 NUF(vaddhn
, 0800400, 3, (RND
, RNQ
, RNQ
), neon_dyadic_narrow
),
17617 NUF(vraddhn
, 1800400, 3, (RND
, RNQ
, RNQ
), neon_dyadic_narrow
),
17618 NUF(vsubhn
, 0800600, 3, (RND
, RNQ
, RNQ
), neon_dyadic_narrow
),
17619 NUF(vrsubhn
, 1800600, 3, (RND
, RNQ
, RNQ
), neon_dyadic_narrow
),
17620 /* Saturating doubling multiplies. Types S16 S32. */
17621 nUF(vqdmlal
, _vqdmlal
, 3, (RNQ
, RND
, RND_RNSC
), neon_mul_sat_scalar_long
),
17622 nUF(vqdmlsl
, _vqdmlsl
, 3, (RNQ
, RND
, RND_RNSC
), neon_mul_sat_scalar_long
),
17623 nUF(vqdmull
, _vqdmull
, 3, (RNQ
, RND
, RND_RNSC
), neon_mul_sat_scalar_long
),
17624 /* VMULL. Vector types S8 S16 S32 U8 U16 U32 P8, scalar types
17625 S16 S32 U16 U32. */
17626 nUF(vmull
, _vmull
, 3, (RNQ
, RND
, RND_RNSC
), neon_vmull
),
17628 /* Extract. Size 8. */
17629 NUF(vext
, 0b00000, 4, (RNDQ
, oRNDQ
, RNDQ
, I15
), neon_ext
),
17630 NUF(vextq
, 0b00000, 4, (RNQ
, oRNQ
, RNQ
, I15
), neon_ext
),
17632 /* Two registers, miscellaneous. */
17633 /* Reverse. Sizes 8 16 32 (must be < size in opcode). */
17634 NUF(vrev64
, 1b00000
, 2, (RNDQ
, RNDQ
), neon_rev
),
17635 NUF(vrev64q
, 1b00000
, 2, (RNQ
, RNQ
), neon_rev
),
17636 NUF(vrev32
, 1b00080
, 2, (RNDQ
, RNDQ
), neon_rev
),
17637 NUF(vrev32q
, 1b00080
, 2, (RNQ
, RNQ
), neon_rev
),
17638 NUF(vrev16
, 1b00100
, 2, (RNDQ
, RNDQ
), neon_rev
),
17639 NUF(vrev16q
, 1b00100
, 2, (RNQ
, RNQ
), neon_rev
),
17640 /* Vector replicate. Sizes 8 16 32. */
17641 nCE(vdup
, _vdup
, 2, (RNDQ
, RR_RNSC
), neon_dup
),
17642 nCE(vdupq
, _vdup
, 2, (RNQ
, RR_RNSC
), neon_dup
),
17643 /* VMOVL. Types S8 S16 S32 U8 U16 U32. */
17644 NUF(vmovl
, 0800a10
, 2, (RNQ
, RND
), neon_movl
),
17645 /* VMOVN. Types I16 I32 I64. */
17646 nUF(vmovn
, _vmovn
, 2, (RND
, RNQ
), neon_movn
),
17647 /* VQMOVN. Types S16 S32 S64 U16 U32 U64. */
17648 nUF(vqmovn
, _vqmovn
, 2, (RND
, RNQ
), neon_qmovn
),
17649 /* VQMOVUN. Types S16 S32 S64. */
17650 nUF(vqmovun
, _vqmovun
, 2, (RND
, RNQ
), neon_qmovun
),
17651 /* VZIP / VUZP. Sizes 8 16 32. */
17652 NUF(vzip
, 1b20180
, 2, (RNDQ
, RNDQ
), neon_zip_uzp
),
17653 NUF(vzipq
, 1b20180
, 2, (RNQ
, RNQ
), neon_zip_uzp
),
17654 NUF(vuzp
, 1b20100
, 2, (RNDQ
, RNDQ
), neon_zip_uzp
),
17655 NUF(vuzpq
, 1b20100
, 2, (RNQ
, RNQ
), neon_zip_uzp
),
17656 /* VQABS / VQNEG. Types S8 S16 S32. */
17657 NUF(vqabs
, 1b00700
, 2, (RNDQ
, RNDQ
), neon_sat_abs_neg
),
17658 NUF(vqabsq
, 1b00700
, 2, (RNQ
, RNQ
), neon_sat_abs_neg
),
17659 NUF(vqneg
, 1b00780
, 2, (RNDQ
, RNDQ
), neon_sat_abs_neg
),
17660 NUF(vqnegq
, 1b00780
, 2, (RNQ
, RNQ
), neon_sat_abs_neg
),
17661 /* Pairwise, lengthening. Types S8 S16 S32 U8 U16 U32. */
17662 NUF(vpadal
, 1b00600
, 2, (RNDQ
, RNDQ
), neon_pair_long
),
17663 NUF(vpadalq
, 1b00600
, 2, (RNQ
, RNQ
), neon_pair_long
),
17664 NUF(vpaddl
, 1b00200
, 2, (RNDQ
, RNDQ
), neon_pair_long
),
17665 NUF(vpaddlq
, 1b00200
, 2, (RNQ
, RNQ
), neon_pair_long
),
17666 /* Reciprocal estimates. Types U32 F32. */
17667 NUF(vrecpe
, 1b30400
, 2, (RNDQ
, RNDQ
), neon_recip_est
),
17668 NUF(vrecpeq
, 1b30400
, 2, (RNQ
, RNQ
), neon_recip_est
),
17669 NUF(vrsqrte
, 1b30480
, 2, (RNDQ
, RNDQ
), neon_recip_est
),
17670 NUF(vrsqrteq
, 1b30480
, 2, (RNQ
, RNQ
), neon_recip_est
),
17671 /* VCLS. Types S8 S16 S32. */
17672 NUF(vcls
, 1b00400
, 2, (RNDQ
, RNDQ
), neon_cls
),
17673 NUF(vclsq
, 1b00400
, 2, (RNQ
, RNQ
), neon_cls
),
17674 /* VCLZ. Types I8 I16 I32. */
17675 NUF(vclz
, 1b00480
, 2, (RNDQ
, RNDQ
), neon_clz
),
17676 NUF(vclzq
, 1b00480
, 2, (RNQ
, RNQ
), neon_clz
),
17677 /* VCNT. Size 8. */
17678 NUF(vcnt
, 1b00500
, 2, (RNDQ
, RNDQ
), neon_cnt
),
17679 NUF(vcntq
, 1b00500
, 2, (RNQ
, RNQ
), neon_cnt
),
17680 /* Two address, untyped. */
17681 NUF(vswp
, 1b20000
, 2, (RNDQ
, RNDQ
), neon_swp
),
17682 NUF(vswpq
, 1b20000
, 2, (RNQ
, RNQ
), neon_swp
),
17683 /* VTRN. Sizes 8 16 32. */
17684 nUF(vtrn
, _vtrn
, 2, (RNDQ
, RNDQ
), neon_trn
),
17685 nUF(vtrnq
, _vtrn
, 2, (RNQ
, RNQ
), neon_trn
),
17687 /* Table lookup. Size 8. */
17688 NUF(vtbl
, 1b00800
, 3, (RND
, NRDLST
, RND
), neon_tbl_tbx
),
17689 NUF(vtbx
, 1b00840
, 3, (RND
, NRDLST
, RND
), neon_tbl_tbx
),
17691 #undef THUMB_VARIANT
17692 #define THUMB_VARIANT & fpu_vfp_v3_or_neon_ext
17694 #define ARM_VARIANT & fpu_vfp_v3_or_neon_ext
17696 /* Neon element/structure load/store. */
17697 nUF(vld1
, _vld1
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17698 nUF(vst1
, _vst1
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17699 nUF(vld2
, _vld2
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17700 nUF(vst2
, _vst2
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17701 nUF(vld3
, _vld3
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17702 nUF(vst3
, _vst3
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17703 nUF(vld4
, _vld4
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17704 nUF(vst4
, _vst4
, 2, (NSTRLST
, ADDR
), neon_ldx_stx
),
17706 #undef THUMB_VARIANT
17707 #define THUMB_VARIANT &fpu_vfp_ext_v3xd
17709 #define ARM_VARIANT &fpu_vfp_ext_v3xd
17710 cCE("fconsts", eb00a00
, 2, (RVS
, I255
), vfp_sp_const
),
17711 cCE("fshtos", eba0a40
, 2, (RVS
, I16z
), vfp_sp_conv_16
),
17712 cCE("fsltos", eba0ac0
, 2, (RVS
, I32
), vfp_sp_conv_32
),
17713 cCE("fuhtos", ebb0a40
, 2, (RVS
, I16z
), vfp_sp_conv_16
),
17714 cCE("fultos", ebb0ac0
, 2, (RVS
, I32
), vfp_sp_conv_32
),
17715 cCE("ftoshs", ebe0a40
, 2, (RVS
, I16z
), vfp_sp_conv_16
),
17716 cCE("ftosls", ebe0ac0
, 2, (RVS
, I32
), vfp_sp_conv_32
),
17717 cCE("ftouhs", ebf0a40
, 2, (RVS
, I16z
), vfp_sp_conv_16
),
17718 cCE("ftouls", ebf0ac0
, 2, (RVS
, I32
), vfp_sp_conv_32
),
17720 #undef THUMB_VARIANT
17721 #define THUMB_VARIANT & fpu_vfp_ext_v3
17723 #define ARM_VARIANT & fpu_vfp_ext_v3
17725 cCE("fconstd", eb00b00
, 2, (RVD
, I255
), vfp_dp_const
),
17726 cCE("fshtod", eba0b40
, 2, (RVD
, I16z
), vfp_dp_conv_16
),
17727 cCE("fsltod", eba0bc0
, 2, (RVD
, I32
), vfp_dp_conv_32
),
17728 cCE("fuhtod", ebb0b40
, 2, (RVD
, I16z
), vfp_dp_conv_16
),
17729 cCE("fultod", ebb0bc0
, 2, (RVD
, I32
), vfp_dp_conv_32
),
17730 cCE("ftoshd", ebe0b40
, 2, (RVD
, I16z
), vfp_dp_conv_16
),
17731 cCE("ftosld", ebe0bc0
, 2, (RVD
, I32
), vfp_dp_conv_32
),
17732 cCE("ftouhd", ebf0b40
, 2, (RVD
, I16z
), vfp_dp_conv_16
),
17733 cCE("ftould", ebf0bc0
, 2, (RVD
, I32
), vfp_dp_conv_32
),
17736 #define ARM_VARIANT &fpu_vfp_ext_fma
17737 #undef THUMB_VARIANT
17738 #define THUMB_VARIANT &fpu_vfp_ext_fma
17739 /* Mnemonics shared by Neon and VFP. These are included in the
17740 VFP FMA variant; NEON and VFP FMA always includes the NEON
17741 FMA instructions. */
17742 nCEF(vfma
, _vfma
, 3, (RNSDQ
, oRNSDQ
, RNSDQ
), neon_fmac
),
17743 nCEF(vfms
, _vfms
, 3, (RNSDQ
, oRNSDQ
, RNSDQ
), neon_fmac
),
17744 /* ffmas/ffmad/ffmss/ffmsd are dummy mnemonics to satisfy gas;
17745 the v form should always be used. */
17746 cCE("ffmas", ea00a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17747 cCE("ffnmas", ea00a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
17748 cCE("ffmad", ea00b00
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17749 cCE("ffnmad", ea00b40
, 3, (RVD
, RVD
, RVD
), vfp_dp_rd_rn_rm
),
17750 nCE(vfnma
, _vfnma
, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_nmul
),
17751 nCE(vfnms
, _vfnms
, 3, (RVSD
, RVSD
, RVSD
), vfp_nsyn_nmul
),
17753 #undef THUMB_VARIANT
17755 #define ARM_VARIANT & arm_cext_xscale /* Intel XScale extensions. */
17757 cCE("mia", e200010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17758 cCE("miaph", e280010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17759 cCE("miabb", e2c0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17760 cCE("miabt", e2d0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17761 cCE("miatb", e2e0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17762 cCE("miatt", e2f0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
17763 cCE("mar", c400000
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mar
),
17764 cCE("mra", c500000
, 3, (RRnpc
, RRnpc
, RXA
), xsc_mra
),
17767 #define ARM_VARIANT & arm_cext_iwmmxt /* Intel Wireless MMX technology. */
17769 cCE("tandcb", e13f130
, 1, (RR
), iwmmxt_tandorc
),
17770 cCE("tandch", e53f130
, 1, (RR
), iwmmxt_tandorc
),
17771 cCE("tandcw", e93f130
, 1, (RR
), iwmmxt_tandorc
),
17772 cCE("tbcstb", e400010
, 2, (RIWR
, RR
), rn_rd
),
17773 cCE("tbcsth", e400050
, 2, (RIWR
, RR
), rn_rd
),
17774 cCE("tbcstw", e400090
, 2, (RIWR
, RR
), rn_rd
),
17775 cCE("textrcb", e130170
, 2, (RR
, I7
), iwmmxt_textrc
),
17776 cCE("textrch", e530170
, 2, (RR
, I7
), iwmmxt_textrc
),
17777 cCE("textrcw", e930170
, 2, (RR
, I7
), iwmmxt_textrc
),
17778 cCE("textrmub", e100070
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17779 cCE("textrmuh", e500070
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17780 cCE("textrmuw", e900070
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17781 cCE("textrmsb", e100078
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17782 cCE("textrmsh", e500078
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17783 cCE("textrmsw", e900078
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
17784 cCE("tinsrb", e600010
, 3, (RIWR
, RR
, I7
), iwmmxt_tinsr
),
17785 cCE("tinsrh", e600050
, 3, (RIWR
, RR
, I7
), iwmmxt_tinsr
),
17786 cCE("tinsrw", e600090
, 3, (RIWR
, RR
, I7
), iwmmxt_tinsr
),
17787 cCE("tmcr", e000110
, 2, (RIWC_RIWG
, RR
), rn_rd
),
17788 cCE("tmcrr", c400000
, 3, (RIWR
, RR
, RR
), rm_rd_rn
),
17789 cCE("tmia", e200010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17790 cCE("tmiaph", e280010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17791 cCE("tmiabb", e2c0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17792 cCE("tmiabt", e2d0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17793 cCE("tmiatb", e2e0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17794 cCE("tmiatt", e2f0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
17795 cCE("tmovmskb", e100030
, 2, (RR
, RIWR
), rd_rn
),
17796 cCE("tmovmskh", e500030
, 2, (RR
, RIWR
), rd_rn
),
17797 cCE("tmovmskw", e900030
, 2, (RR
, RIWR
), rd_rn
),
17798 cCE("tmrc", e100110
, 2, (RR
, RIWC_RIWG
), rd_rn
),
17799 cCE("tmrrc", c500000
, 3, (RR
, RR
, RIWR
), rd_rn_rm
),
17800 cCE("torcb", e13f150
, 1, (RR
), iwmmxt_tandorc
),
17801 cCE("torch", e53f150
, 1, (RR
), iwmmxt_tandorc
),
17802 cCE("torcw", e93f150
, 1, (RR
), iwmmxt_tandorc
),
17803 cCE("waccb", e0001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17804 cCE("wacch", e4001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17805 cCE("waccw", e8001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17806 cCE("waddbss", e300180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17807 cCE("waddb", e000180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17808 cCE("waddbus", e100180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17809 cCE("waddhss", e700180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17810 cCE("waddh", e400180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17811 cCE("waddhus", e500180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17812 cCE("waddwss", eb00180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17813 cCE("waddw", e800180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17814 cCE("waddwus", e900180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17815 cCE("waligni", e000020
, 4, (RIWR
, RIWR
, RIWR
, I7
), iwmmxt_waligni
),
17816 cCE("walignr0", e800020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17817 cCE("walignr1", e900020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17818 cCE("walignr2", ea00020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17819 cCE("walignr3", eb00020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17820 cCE("wand", e200000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17821 cCE("wandn", e300000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17822 cCE("wavg2b", e800000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17823 cCE("wavg2br", e900000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17824 cCE("wavg2h", ec00000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17825 cCE("wavg2hr", ed00000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17826 cCE("wcmpeqb", e000060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17827 cCE("wcmpeqh", e400060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17828 cCE("wcmpeqw", e800060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17829 cCE("wcmpgtub", e100060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17830 cCE("wcmpgtuh", e500060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17831 cCE("wcmpgtuw", e900060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17832 cCE("wcmpgtsb", e300060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17833 cCE("wcmpgtsh", e700060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17834 cCE("wcmpgtsw", eb00060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17835 cCE("wldrb", c100000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
17836 cCE("wldrh", c500000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
17837 cCE("wldrw", c100100
, 2, (RIWR_RIWC
, ADDR
), iwmmxt_wldstw
),
17838 cCE("wldrd", c500100
, 2, (RIWR
, ADDR
), iwmmxt_wldstd
),
17839 cCE("wmacs", e600100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17840 cCE("wmacsz", e700100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17841 cCE("wmacu", e400100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17842 cCE("wmacuz", e500100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17843 cCE("wmadds", ea00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17844 cCE("wmaddu", e800100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17845 cCE("wmaxsb", e200160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17846 cCE("wmaxsh", e600160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17847 cCE("wmaxsw", ea00160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17848 cCE("wmaxub", e000160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17849 cCE("wmaxuh", e400160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17850 cCE("wmaxuw", e800160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17851 cCE("wminsb", e300160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17852 cCE("wminsh", e700160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17853 cCE("wminsw", eb00160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17854 cCE("wminub", e100160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17855 cCE("wminuh", e500160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17856 cCE("wminuw", e900160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17857 cCE("wmov", e000000
, 2, (RIWR
, RIWR
), iwmmxt_wmov
),
17858 cCE("wmulsm", e300100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17859 cCE("wmulsl", e200100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17860 cCE("wmulum", e100100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17861 cCE("wmulul", e000100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17862 cCE("wor", e000000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17863 cCE("wpackhss", e700080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17864 cCE("wpackhus", e500080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17865 cCE("wpackwss", eb00080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17866 cCE("wpackwus", e900080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17867 cCE("wpackdss", ef00080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17868 cCE("wpackdus", ed00080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17869 cCE("wrorh", e700040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17870 cCE("wrorhg", e700148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17871 cCE("wrorw", eb00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17872 cCE("wrorwg", eb00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17873 cCE("wrord", ef00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17874 cCE("wrordg", ef00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17875 cCE("wsadb", e000120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17876 cCE("wsadbz", e100120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17877 cCE("wsadh", e400120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17878 cCE("wsadhz", e500120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17879 cCE("wshufh", e0001e0
, 3, (RIWR
, RIWR
, I255
), iwmmxt_wshufh
),
17880 cCE("wsllh", e500040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17881 cCE("wsllhg", e500148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17882 cCE("wsllw", e900040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17883 cCE("wsllwg", e900148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17884 cCE("wslld", ed00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17885 cCE("wslldg", ed00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17886 cCE("wsrah", e400040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17887 cCE("wsrahg", e400148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17888 cCE("wsraw", e800040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17889 cCE("wsrawg", e800148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17890 cCE("wsrad", ec00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17891 cCE("wsradg", ec00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17892 cCE("wsrlh", e600040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17893 cCE("wsrlhg", e600148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17894 cCE("wsrlw", ea00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17895 cCE("wsrlwg", ea00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17896 cCE("wsrld", ee00040
, 3, (RIWR
, RIWR
, RIWR_I32z
),iwmmxt_wrwrwr_or_imm5
),
17897 cCE("wsrldg", ee00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
17898 cCE("wstrb", c000000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
17899 cCE("wstrh", c400000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
17900 cCE("wstrw", c000100
, 2, (RIWR_RIWC
, ADDR
), iwmmxt_wldstw
),
17901 cCE("wstrd", c400100
, 2, (RIWR
, ADDR
), iwmmxt_wldstd
),
17902 cCE("wsubbss", e3001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17903 cCE("wsubb", e0001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17904 cCE("wsubbus", e1001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17905 cCE("wsubhss", e7001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17906 cCE("wsubh", e4001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17907 cCE("wsubhus", e5001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17908 cCE("wsubwss", eb001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17909 cCE("wsubw", e8001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17910 cCE("wsubwus", e9001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17911 cCE("wunpckehub",e0000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17912 cCE("wunpckehuh",e4000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17913 cCE("wunpckehuw",e8000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17914 cCE("wunpckehsb",e2000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17915 cCE("wunpckehsh",e6000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17916 cCE("wunpckehsw",ea000c0
, 2, (RIWR
, RIWR
), rd_rn
),
17917 cCE("wunpckihb", e1000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17918 cCE("wunpckihh", e5000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17919 cCE("wunpckihw", e9000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17920 cCE("wunpckelub",e0000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17921 cCE("wunpckeluh",e4000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17922 cCE("wunpckeluw",e8000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17923 cCE("wunpckelsb",e2000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17924 cCE("wunpckelsh",e6000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17925 cCE("wunpckelsw",ea000e0
, 2, (RIWR
, RIWR
), rd_rn
),
17926 cCE("wunpckilb", e1000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17927 cCE("wunpckilh", e5000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17928 cCE("wunpckilw", e9000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17929 cCE("wxor", e100000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17930 cCE("wzero", e300000
, 1, (RIWR
), iwmmxt_wzero
),
17933 #define ARM_VARIANT & arm_cext_iwmmxt2 /* Intel Wireless MMX technology, version 2. */
17935 cCE("torvscb", e12f190
, 1, (RR
), iwmmxt_tandorc
),
17936 cCE("torvsch", e52f190
, 1, (RR
), iwmmxt_tandorc
),
17937 cCE("torvscw", e92f190
, 1, (RR
), iwmmxt_tandorc
),
17938 cCE("wabsb", e2001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17939 cCE("wabsh", e6001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17940 cCE("wabsw", ea001c0
, 2, (RIWR
, RIWR
), rd_rn
),
17941 cCE("wabsdiffb", e1001c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17942 cCE("wabsdiffh", e5001c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17943 cCE("wabsdiffw", e9001c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17944 cCE("waddbhusl", e2001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17945 cCE("waddbhusm", e6001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17946 cCE("waddhc", e600180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17947 cCE("waddwc", ea00180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17948 cCE("waddsubhx", ea001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17949 cCE("wavg4", e400000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17950 cCE("wavg4r", e500000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17951 cCE("wmaddsn", ee00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17952 cCE("wmaddsx", eb00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17953 cCE("wmaddun", ec00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17954 cCE("wmaddux", e900100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17955 cCE("wmerge", e000080
, 4, (RIWR
, RIWR
, RIWR
, I7
), iwmmxt_wmerge
),
17956 cCE("wmiabb", e0000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17957 cCE("wmiabt", e1000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17958 cCE("wmiatb", e2000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17959 cCE("wmiatt", e3000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17960 cCE("wmiabbn", e4000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17961 cCE("wmiabtn", e5000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17962 cCE("wmiatbn", e6000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17963 cCE("wmiattn", e7000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17964 cCE("wmiawbb", e800120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17965 cCE("wmiawbt", e900120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17966 cCE("wmiawtb", ea00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17967 cCE("wmiawtt", eb00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17968 cCE("wmiawbbn", ec00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17969 cCE("wmiawbtn", ed00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17970 cCE("wmiawtbn", ee00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17971 cCE("wmiawttn", ef00120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17972 cCE("wmulsmr", ef00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17973 cCE("wmulumr", ed00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17974 cCE("wmulwumr", ec000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17975 cCE("wmulwsmr", ee000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17976 cCE("wmulwum", ed000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17977 cCE("wmulwsm", ef000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17978 cCE("wmulwl", eb000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17979 cCE("wqmiabb", e8000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17980 cCE("wqmiabt", e9000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17981 cCE("wqmiatb", ea000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17982 cCE("wqmiatt", eb000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17983 cCE("wqmiabbn", ec000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17984 cCE("wqmiabtn", ed000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17985 cCE("wqmiatbn", ee000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17986 cCE("wqmiattn", ef000a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17987 cCE("wqmulm", e100080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17988 cCE("wqmulmr", e300080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17989 cCE("wqmulwm", ec000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17990 cCE("wqmulwmr", ee000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17991 cCE("wsubaddhx", ed001c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
17994 #define ARM_VARIANT & arm_cext_maverick /* Cirrus Maverick instructions. */
17996 cCE("cfldrs", c100400
, 2, (RMF
, ADDRGLDC
), rd_cpaddr
),
17997 cCE("cfldrd", c500400
, 2, (RMD
, ADDRGLDC
), rd_cpaddr
),
17998 cCE("cfldr32", c100500
, 2, (RMFX
, ADDRGLDC
), rd_cpaddr
),
17999 cCE("cfldr64", c500500
, 2, (RMDX
, ADDRGLDC
), rd_cpaddr
),
18000 cCE("cfstrs", c000400
, 2, (RMF
, ADDRGLDC
), rd_cpaddr
),
18001 cCE("cfstrd", c400400
, 2, (RMD
, ADDRGLDC
), rd_cpaddr
),
18002 cCE("cfstr32", c000500
, 2, (RMFX
, ADDRGLDC
), rd_cpaddr
),
18003 cCE("cfstr64", c400500
, 2, (RMDX
, ADDRGLDC
), rd_cpaddr
),
18004 cCE("cfmvsr", e000450
, 2, (RMF
, RR
), rn_rd
),
18005 cCE("cfmvrs", e100450
, 2, (RR
, RMF
), rd_rn
),
18006 cCE("cfmvdlr", e000410
, 2, (RMD
, RR
), rn_rd
),
18007 cCE("cfmvrdl", e100410
, 2, (RR
, RMD
), rd_rn
),
18008 cCE("cfmvdhr", e000430
, 2, (RMD
, RR
), rn_rd
),
18009 cCE("cfmvrdh", e100430
, 2, (RR
, RMD
), rd_rn
),
18010 cCE("cfmv64lr", e000510
, 2, (RMDX
, RR
), rn_rd
),
18011 cCE("cfmvr64l", e100510
, 2, (RR
, RMDX
), rd_rn
),
18012 cCE("cfmv64hr", e000530
, 2, (RMDX
, RR
), rn_rd
),
18013 cCE("cfmvr64h", e100530
, 2, (RR
, RMDX
), rd_rn
),
18014 cCE("cfmval32", e200440
, 2, (RMAX
, RMFX
), rd_rn
),
18015 cCE("cfmv32al", e100440
, 2, (RMFX
, RMAX
), rd_rn
),
18016 cCE("cfmvam32", e200460
, 2, (RMAX
, RMFX
), rd_rn
),
18017 cCE("cfmv32am", e100460
, 2, (RMFX
, RMAX
), rd_rn
),
18018 cCE("cfmvah32", e200480
, 2, (RMAX
, RMFX
), rd_rn
),
18019 cCE("cfmv32ah", e100480
, 2, (RMFX
, RMAX
), rd_rn
),
18020 cCE("cfmva32", e2004a0
, 2, (RMAX
, RMFX
), rd_rn
),
18021 cCE("cfmv32a", e1004a0
, 2, (RMFX
, RMAX
), rd_rn
),
18022 cCE("cfmva64", e2004c0
, 2, (RMAX
, RMDX
), rd_rn
),
18023 cCE("cfmv64a", e1004c0
, 2, (RMDX
, RMAX
), rd_rn
),
18024 cCE("cfmvsc32", e2004e0
, 2, (RMDS
, RMDX
), mav_dspsc
),
18025 cCE("cfmv32sc", e1004e0
, 2, (RMDX
, RMDS
), rd
),
18026 cCE("cfcpys", e000400
, 2, (RMF
, RMF
), rd_rn
),
18027 cCE("cfcpyd", e000420
, 2, (RMD
, RMD
), rd_rn
),
18028 cCE("cfcvtsd", e000460
, 2, (RMD
, RMF
), rd_rn
),
18029 cCE("cfcvtds", e000440
, 2, (RMF
, RMD
), rd_rn
),
18030 cCE("cfcvt32s", e000480
, 2, (RMF
, RMFX
), rd_rn
),
18031 cCE("cfcvt32d", e0004a0
, 2, (RMD
, RMFX
), rd_rn
),
18032 cCE("cfcvt64s", e0004c0
, 2, (RMF
, RMDX
), rd_rn
),
18033 cCE("cfcvt64d", e0004e0
, 2, (RMD
, RMDX
), rd_rn
),
18034 cCE("cfcvts32", e100580
, 2, (RMFX
, RMF
), rd_rn
),
18035 cCE("cfcvtd32", e1005a0
, 2, (RMFX
, RMD
), rd_rn
),
18036 cCE("cftruncs32",e1005c0
, 2, (RMFX
, RMF
), rd_rn
),
18037 cCE("cftruncd32",e1005e0
, 2, (RMFX
, RMD
), rd_rn
),
18038 cCE("cfrshl32", e000550
, 3, (RMFX
, RMFX
, RR
), mav_triple
),
18039 cCE("cfrshl64", e000570
, 3, (RMDX
, RMDX
, RR
), mav_triple
),
18040 cCE("cfsh32", e000500
, 3, (RMFX
, RMFX
, I63s
), mav_shift
),
18041 cCE("cfsh64", e200500
, 3, (RMDX
, RMDX
, I63s
), mav_shift
),
18042 cCE("cfcmps", e100490
, 3, (RR
, RMF
, RMF
), rd_rn_rm
),
18043 cCE("cfcmpd", e1004b0
, 3, (RR
, RMD
, RMD
), rd_rn_rm
),
18044 cCE("cfcmp32", e100590
, 3, (RR
, RMFX
, RMFX
), rd_rn_rm
),
18045 cCE("cfcmp64", e1005b0
, 3, (RR
, RMDX
, RMDX
), rd_rn_rm
),
18046 cCE("cfabss", e300400
, 2, (RMF
, RMF
), rd_rn
),
18047 cCE("cfabsd", e300420
, 2, (RMD
, RMD
), rd_rn
),
18048 cCE("cfnegs", e300440
, 2, (RMF
, RMF
), rd_rn
),
18049 cCE("cfnegd", e300460
, 2, (RMD
, RMD
), rd_rn
),
18050 cCE("cfadds", e300480
, 3, (RMF
, RMF
, RMF
), rd_rn_rm
),
18051 cCE("cfaddd", e3004a0
, 3, (RMD
, RMD
, RMD
), rd_rn_rm
),
18052 cCE("cfsubs", e3004c0
, 3, (RMF
, RMF
, RMF
), rd_rn_rm
),
18053 cCE("cfsubd", e3004e0
, 3, (RMD
, RMD
, RMD
), rd_rn_rm
),
18054 cCE("cfmuls", e100400
, 3, (RMF
, RMF
, RMF
), rd_rn_rm
),
18055 cCE("cfmuld", e100420
, 3, (RMD
, RMD
, RMD
), rd_rn_rm
),
18056 cCE("cfabs32", e300500
, 2, (RMFX
, RMFX
), rd_rn
),
18057 cCE("cfabs64", e300520
, 2, (RMDX
, RMDX
), rd_rn
),
18058 cCE("cfneg32", e300540
, 2, (RMFX
, RMFX
), rd_rn
),
18059 cCE("cfneg64", e300560
, 2, (RMDX
, RMDX
), rd_rn
),
18060 cCE("cfadd32", e300580
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
18061 cCE("cfadd64", e3005a0
, 3, (RMDX
, RMDX
, RMDX
), rd_rn_rm
),
18062 cCE("cfsub32", e3005c0
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
18063 cCE("cfsub64", e3005e0
, 3, (RMDX
, RMDX
, RMDX
), rd_rn_rm
),
18064 cCE("cfmul32", e100500
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
18065 cCE("cfmul64", e100520
, 3, (RMDX
, RMDX
, RMDX
), rd_rn_rm
),
18066 cCE("cfmac32", e100540
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
18067 cCE("cfmsc32", e100560
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
18068 cCE("cfmadd32", e000600
, 4, (RMAX
, RMFX
, RMFX
, RMFX
), mav_quad
),
18069 cCE("cfmsub32", e100600
, 4, (RMAX
, RMFX
, RMFX
, RMFX
), mav_quad
),
18070 cCE("cfmadda32", e200600
, 4, (RMAX
, RMAX
, RMFX
, RMFX
), mav_quad
),
18071 cCE("cfmsuba32", e300600
, 4, (RMAX
, RMAX
, RMFX
, RMFX
), mav_quad
),
18074 #undef THUMB_VARIANT
18101 /* MD interface: bits in the object file. */
18103 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
18104 for use in the a.out file, and stores them in the array pointed to by buf.
18105 This knows about the endian-ness of the target machine and does
18106 THE RIGHT THING, whatever it is. Possible values for n are 1 (byte)
18107 2 (short) and 4 (long) Floating numbers are put out as a series of
18108 LITTLENUMS (shorts, here at least). */
18111 md_number_to_chars (char * buf
, valueT val
, int n
)
18113 if (target_big_endian
)
18114 number_to_chars_bigendian (buf
, val
, n
);
18116 number_to_chars_littleendian (buf
, val
, n
);
18120 md_chars_to_number (char * buf
, int n
)
18123 unsigned char * where
= (unsigned char *) buf
;
18125 if (target_big_endian
)
18130 result
|= (*where
++ & 255);
18138 result
|= (where
[n
] & 255);
18145 /* MD interface: Sections. */
18147 /* Estimate the size of a frag before relaxing. Assume everything fits in
18151 md_estimate_size_before_relax (fragS
* fragp
,
18152 segT segtype ATTRIBUTE_UNUSED
)
18158 /* Convert a machine dependent frag. */
18161 md_convert_frag (bfd
*abfd
, segT asec ATTRIBUTE_UNUSED
, fragS
*fragp
)
18163 unsigned long insn
;
18164 unsigned long old_op
;
18172 buf
= fragp
->fr_literal
+ fragp
->fr_fix
;
18174 old_op
= bfd_get_16(abfd
, buf
);
18175 if (fragp
->fr_symbol
)
18177 exp
.X_op
= O_symbol
;
18178 exp
.X_add_symbol
= fragp
->fr_symbol
;
18182 exp
.X_op
= O_constant
;
18184 exp
.X_add_number
= fragp
->fr_offset
;
18185 opcode
= fragp
->fr_subtype
;
18188 case T_MNEM_ldr_pc
:
18189 case T_MNEM_ldr_pc2
:
18190 case T_MNEM_ldr_sp
:
18191 case T_MNEM_str_sp
:
18198 if (fragp
->fr_var
== 4)
18200 insn
= THUMB_OP32 (opcode
);
18201 if ((old_op
>> 12) == 4 || (old_op
>> 12) == 9)
18203 insn
|= (old_op
& 0x700) << 4;
18207 insn
|= (old_op
& 7) << 12;
18208 insn
|= (old_op
& 0x38) << 13;
18210 insn
|= 0x00000c00;
18211 put_thumb32_insn (buf
, insn
);
18212 reloc_type
= BFD_RELOC_ARM_T32_OFFSET_IMM
;
18216 reloc_type
= BFD_RELOC_ARM_THUMB_OFFSET
;
18218 pc_rel
= (opcode
== T_MNEM_ldr_pc2
);
18221 if (fragp
->fr_var
== 4)
18223 insn
= THUMB_OP32 (opcode
);
18224 insn
|= (old_op
& 0xf0) << 4;
18225 put_thumb32_insn (buf
, insn
);
18226 reloc_type
= BFD_RELOC_ARM_T32_ADD_PC12
;
18230 reloc_type
= BFD_RELOC_ARM_THUMB_ADD
;
18231 exp
.X_add_number
-= 4;
18239 if (fragp
->fr_var
== 4)
18241 int r0off
= (opcode
== T_MNEM_mov
18242 || opcode
== T_MNEM_movs
) ? 0 : 8;
18243 insn
= THUMB_OP32 (opcode
);
18244 insn
= (insn
& 0xe1ffffff) | 0x10000000;
18245 insn
|= (old_op
& 0x700) << r0off
;
18246 put_thumb32_insn (buf
, insn
);
18247 reloc_type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
18251 reloc_type
= BFD_RELOC_ARM_THUMB_IMM
;
18256 if (fragp
->fr_var
== 4)
18258 insn
= THUMB_OP32(opcode
);
18259 put_thumb32_insn (buf
, insn
);
18260 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH25
;
18263 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH12
;
18267 if (fragp
->fr_var
== 4)
18269 insn
= THUMB_OP32(opcode
);
18270 insn
|= (old_op
& 0xf00) << 14;
18271 put_thumb32_insn (buf
, insn
);
18272 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH20
;
18275 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH9
;
18278 case T_MNEM_add_sp
:
18279 case T_MNEM_add_pc
:
18280 case T_MNEM_inc_sp
:
18281 case T_MNEM_dec_sp
:
18282 if (fragp
->fr_var
== 4)
18284 /* ??? Choose between add and addw. */
18285 insn
= THUMB_OP32 (opcode
);
18286 insn
|= (old_op
& 0xf0) << 4;
18287 put_thumb32_insn (buf
, insn
);
18288 if (opcode
== T_MNEM_add_pc
)
18289 reloc_type
= BFD_RELOC_ARM_T32_IMM12
;
18291 reloc_type
= BFD_RELOC_ARM_T32_ADD_IMM
;
18294 reloc_type
= BFD_RELOC_ARM_THUMB_ADD
;
18302 if (fragp
->fr_var
== 4)
18304 insn
= THUMB_OP32 (opcode
);
18305 insn
|= (old_op
& 0xf0) << 4;
18306 insn
|= (old_op
& 0xf) << 16;
18307 put_thumb32_insn (buf
, insn
);
18308 if (insn
& (1 << 20))
18309 reloc_type
= BFD_RELOC_ARM_T32_ADD_IMM
;
18311 reloc_type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
18314 reloc_type
= BFD_RELOC_ARM_THUMB_ADD
;
18320 fixp
= fix_new_exp (fragp
, fragp
->fr_fix
, fragp
->fr_var
, &exp
, pc_rel
,
18321 (enum bfd_reloc_code_real
) reloc_type
);
18322 fixp
->fx_file
= fragp
->fr_file
;
18323 fixp
->fx_line
= fragp
->fr_line
;
18324 fragp
->fr_fix
+= fragp
->fr_var
;
18327 /* Return the size of a relaxable immediate operand instruction.
18328 SHIFT and SIZE specify the form of the allowable immediate. */
18330 relax_immediate (fragS
*fragp
, int size
, int shift
)
18336 /* ??? Should be able to do better than this. */
18337 if (fragp
->fr_symbol
)
18340 low
= (1 << shift
) - 1;
18341 mask
= (1 << (shift
+ size
)) - (1 << shift
);
18342 offset
= fragp
->fr_offset
;
18343 /* Force misaligned offsets to 32-bit variant. */
18346 if (offset
& ~mask
)
18351 /* Get the address of a symbol during relaxation. */
18353 relaxed_symbol_addr (fragS
*fragp
, long stretch
)
18359 sym
= fragp
->fr_symbol
;
18360 sym_frag
= symbol_get_frag (sym
);
18361 know (S_GET_SEGMENT (sym
) != absolute_section
18362 || sym_frag
== &zero_address_frag
);
18363 addr
= S_GET_VALUE (sym
) + fragp
->fr_offset
;
18365 /* If frag has yet to be reached on this pass, assume it will
18366 move by STRETCH just as we did. If this is not so, it will
18367 be because some frag between grows, and that will force
18371 && sym_frag
->relax_marker
!= fragp
->relax_marker
)
18375 /* Adjust stretch for any alignment frag. Note that if have
18376 been expanding the earlier code, the symbol may be
18377 defined in what appears to be an earlier frag. FIXME:
18378 This doesn't handle the fr_subtype field, which specifies
18379 a maximum number of bytes to skip when doing an
18381 for (f
= fragp
; f
!= NULL
&& f
!= sym_frag
; f
= f
->fr_next
)
18383 if (f
->fr_type
== rs_align
|| f
->fr_type
== rs_align_code
)
18386 stretch
= - ((- stretch
)
18387 & ~ ((1 << (int) f
->fr_offset
) - 1));
18389 stretch
&= ~ ((1 << (int) f
->fr_offset
) - 1);
18401 /* Return the size of a relaxable adr pseudo-instruction or PC-relative
18404 relax_adr (fragS
*fragp
, asection
*sec
, long stretch
)
18409 /* Assume worst case for symbols not known to be in the same section. */
18410 if (fragp
->fr_symbol
== NULL
18411 || !S_IS_DEFINED (fragp
->fr_symbol
)
18412 || sec
!= S_GET_SEGMENT (fragp
->fr_symbol
))
18415 val
= relaxed_symbol_addr (fragp
, stretch
);
18416 addr
= fragp
->fr_address
+ fragp
->fr_fix
;
18417 addr
= (addr
+ 4) & ~3;
18418 /* Force misaligned targets to 32-bit variant. */
18422 if (val
< 0 || val
> 1020)
18427 /* Return the size of a relaxable add/sub immediate instruction. */
18429 relax_addsub (fragS
*fragp
, asection
*sec
)
18434 buf
= fragp
->fr_literal
+ fragp
->fr_fix
;
18435 op
= bfd_get_16(sec
->owner
, buf
);
18436 if ((op
& 0xf) == ((op
>> 4) & 0xf))
18437 return relax_immediate (fragp
, 8, 0);
18439 return relax_immediate (fragp
, 3, 0);
18443 /* Return the size of a relaxable branch instruction. BITS is the
18444 size of the offset field in the narrow instruction. */
18447 relax_branch (fragS
*fragp
, asection
*sec
, int bits
, long stretch
)
18453 /* Assume worst case for symbols not known to be in the same section. */
18454 if (!S_IS_DEFINED (fragp
->fr_symbol
)
18455 || sec
!= S_GET_SEGMENT (fragp
->fr_symbol
))
18459 if (S_IS_DEFINED (fragp
->fr_symbol
)
18460 && ARM_IS_FUNC (fragp
->fr_symbol
))
18464 val
= relaxed_symbol_addr (fragp
, stretch
);
18465 addr
= fragp
->fr_address
+ fragp
->fr_fix
+ 4;
18468 /* Offset is a signed value *2 */
18470 if (val
>= limit
|| val
< -limit
)
18476 /* Relax a machine dependent frag. This returns the amount by which
18477 the current size of the frag should change. */
18480 arm_relax_frag (asection
*sec
, fragS
*fragp
, long stretch
)
18485 oldsize
= fragp
->fr_var
;
18486 switch (fragp
->fr_subtype
)
18488 case T_MNEM_ldr_pc2
:
18489 newsize
= relax_adr (fragp
, sec
, stretch
);
18491 case T_MNEM_ldr_pc
:
18492 case T_MNEM_ldr_sp
:
18493 case T_MNEM_str_sp
:
18494 newsize
= relax_immediate (fragp
, 8, 2);
18498 newsize
= relax_immediate (fragp
, 5, 2);
18502 newsize
= relax_immediate (fragp
, 5, 1);
18506 newsize
= relax_immediate (fragp
, 5, 0);
18509 newsize
= relax_adr (fragp
, sec
, stretch
);
18515 newsize
= relax_immediate (fragp
, 8, 0);
18518 newsize
= relax_branch (fragp
, sec
, 11, stretch
);
18521 newsize
= relax_branch (fragp
, sec
, 8, stretch
);
18523 case T_MNEM_add_sp
:
18524 case T_MNEM_add_pc
:
18525 newsize
= relax_immediate (fragp
, 8, 2);
18527 case T_MNEM_inc_sp
:
18528 case T_MNEM_dec_sp
:
18529 newsize
= relax_immediate (fragp
, 7, 2);
18535 newsize
= relax_addsub (fragp
, sec
);
18541 fragp
->fr_var
= newsize
;
18542 /* Freeze wide instructions that are at or before the same location as
18543 in the previous pass. This avoids infinite loops.
18544 Don't freeze them unconditionally because targets may be artificially
18545 misaligned by the expansion of preceding frags. */
18546 if (stretch
<= 0 && newsize
> 2)
18548 md_convert_frag (sec
->owner
, sec
, fragp
);
18552 return newsize
- oldsize
;
18555 /* Round up a section size to the appropriate boundary. */
18558 md_section_align (segT segment ATTRIBUTE_UNUSED
,
18561 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
18562 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
18564 /* For a.out, force the section size to be aligned. If we don't do
18565 this, BFD will align it for us, but it will not write out the
18566 final bytes of the section. This may be a bug in BFD, but it is
18567 easier to fix it here since that is how the other a.out targets
18571 align
= bfd_get_section_alignment (stdoutput
, segment
);
18572 size
= ((size
+ (1 << align
) - 1) & ((valueT
) -1 << align
));
18579 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
18580 of an rs_align_code fragment. */
18583 arm_handle_align (fragS
* fragP
)
18585 static char const arm_noop
[2][2][4] =
18588 {0x00, 0x00, 0xa0, 0xe1}, /* LE */
18589 {0xe1, 0xa0, 0x00, 0x00}, /* BE */
18592 {0x00, 0xf0, 0x20, 0xe3}, /* LE */
18593 {0xe3, 0x20, 0xf0, 0x00}, /* BE */
18596 static char const thumb_noop
[2][2][2] =
18599 {0xc0, 0x46}, /* LE */
18600 {0x46, 0xc0}, /* BE */
18603 {0x00, 0xbf}, /* LE */
18604 {0xbf, 0x00} /* BE */
18607 static char const wide_thumb_noop
[2][4] =
18608 { /* Wide Thumb-2 */
18609 {0xaf, 0xf3, 0x00, 0x80}, /* LE */
18610 {0xf3, 0xaf, 0x80, 0x00}, /* BE */
18613 unsigned bytes
, fix
, noop_size
;
18616 const char *narrow_noop
= NULL
;
18621 if (fragP
->fr_type
!= rs_align_code
)
18624 bytes
= fragP
->fr_next
->fr_address
- fragP
->fr_address
- fragP
->fr_fix
;
18625 p
= fragP
->fr_literal
+ fragP
->fr_fix
;
18628 if (bytes
> MAX_MEM_FOR_RS_ALIGN_CODE
)
18629 bytes
&= MAX_MEM_FOR_RS_ALIGN_CODE
;
18631 gas_assert ((fragP
->tc_frag_data
.thumb_mode
& MODE_RECORDED
) != 0);
18633 if (fragP
->tc_frag_data
.thumb_mode
& (~ MODE_RECORDED
))
18635 if (ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v6t2
))
18637 narrow_noop
= thumb_noop
[1][target_big_endian
];
18638 noop
= wide_thumb_noop
[target_big_endian
];
18641 noop
= thumb_noop
[0][target_big_endian
];
18649 noop
= arm_noop
[ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v6k
) != 0]
18650 [target_big_endian
];
18657 fragP
->fr_var
= noop_size
;
18659 if (bytes
& (noop_size
- 1))
18661 fix
= bytes
& (noop_size
- 1);
18663 insert_data_mapping_symbol (state
, fragP
->fr_fix
, fragP
, fix
);
18665 memset (p
, 0, fix
);
18672 if (bytes
& noop_size
)
18674 /* Insert a narrow noop. */
18675 memcpy (p
, narrow_noop
, noop_size
);
18677 bytes
-= noop_size
;
18681 /* Use wide noops for the remainder */
18685 while (bytes
>= noop_size
)
18687 memcpy (p
, noop
, noop_size
);
18689 bytes
-= noop_size
;
18693 fragP
->fr_fix
+= fix
;
18696 /* Called from md_do_align. Used to create an alignment
18697 frag in a code section. */
18700 arm_frag_align_code (int n
, int max
)
18704 /* We assume that there will never be a requirement
18705 to support alignments greater than MAX_MEM_FOR_RS_ALIGN_CODE bytes. */
18706 if (max
> MAX_MEM_FOR_RS_ALIGN_CODE
)
18711 _("alignments greater than %d bytes not supported in .text sections."),
18712 MAX_MEM_FOR_RS_ALIGN_CODE
+ 1);
18713 as_fatal ("%s", err_msg
);
18716 p
= frag_var (rs_align_code
,
18717 MAX_MEM_FOR_RS_ALIGN_CODE
,
18719 (relax_substateT
) max
,
18726 /* Perform target specific initialisation of a frag.
18727 Note - despite the name this initialisation is not done when the frag
18728 is created, but only when its type is assigned. A frag can be created
18729 and used a long time before its type is set, so beware of assuming that
18730 this initialisationis performed first. */
18734 arm_init_frag (fragS
* fragP
, int max_chars ATTRIBUTE_UNUSED
)
18736 /* Record whether this frag is in an ARM or a THUMB area. */
18737 fragP
->tc_frag_data
.thumb_mode
= thumb_mode
| MODE_RECORDED
;
18740 #else /* OBJ_ELF is defined. */
18742 arm_init_frag (fragS
* fragP
, int max_chars
)
18744 /* If the current ARM vs THUMB mode has not already
18745 been recorded into this frag then do so now. */
18746 if ((fragP
->tc_frag_data
.thumb_mode
& MODE_RECORDED
) == 0)
18748 fragP
->tc_frag_data
.thumb_mode
= thumb_mode
| MODE_RECORDED
;
18750 /* Record a mapping symbol for alignment frags. We will delete this
18751 later if the alignment ends up empty. */
18752 switch (fragP
->fr_type
)
18755 case rs_align_test
:
18757 mapping_state_2 (MAP_DATA
, max_chars
);
18759 case rs_align_code
:
18760 mapping_state_2 (thumb_mode
? MAP_THUMB
: MAP_ARM
, max_chars
);
18768 /* When we change sections we need to issue a new mapping symbol. */
18771 arm_elf_change_section (void)
18773 /* Link an unlinked unwind index table section to the .text section. */
18774 if (elf_section_type (now_seg
) == SHT_ARM_EXIDX
18775 && elf_linked_to_section (now_seg
) == NULL
)
18776 elf_linked_to_section (now_seg
) = text_section
;
18780 arm_elf_section_type (const char * str
, size_t len
)
18782 if (len
== 5 && strncmp (str
, "exidx", 5) == 0)
18783 return SHT_ARM_EXIDX
;
18788 /* Code to deal with unwinding tables. */
18790 static void add_unwind_adjustsp (offsetT
);
18792 /* Generate any deferred unwind frame offset. */
18795 flush_pending_unwind (void)
18799 offset
= unwind
.pending_offset
;
18800 unwind
.pending_offset
= 0;
18802 add_unwind_adjustsp (offset
);
18805 /* Add an opcode to this list for this function. Two-byte opcodes should
18806 be passed as op[0] << 8 | op[1]. The list of opcodes is built in reverse
18810 add_unwind_opcode (valueT op
, int length
)
18812 /* Add any deferred stack adjustment. */
18813 if (unwind
.pending_offset
)
18814 flush_pending_unwind ();
18816 unwind
.sp_restored
= 0;
18818 if (unwind
.opcode_count
+ length
> unwind
.opcode_alloc
)
18820 unwind
.opcode_alloc
+= ARM_OPCODE_CHUNK_SIZE
;
18821 if (unwind
.opcodes
)
18822 unwind
.opcodes
= (unsigned char *) xrealloc (unwind
.opcodes
,
18823 unwind
.opcode_alloc
);
18825 unwind
.opcodes
= (unsigned char *) xmalloc (unwind
.opcode_alloc
);
18830 unwind
.opcodes
[unwind
.opcode_count
] = op
& 0xff;
18832 unwind
.opcode_count
++;
18836 /* Add unwind opcodes to adjust the stack pointer. */
18839 add_unwind_adjustsp (offsetT offset
)
18843 if (offset
> 0x200)
18845 /* We need at most 5 bytes to hold a 32-bit value in a uleb128. */
18850 /* Long form: 0xb2, uleb128. */
18851 /* This might not fit in a word so add the individual bytes,
18852 remembering the list is built in reverse order. */
18853 o
= (valueT
) ((offset
- 0x204) >> 2);
18855 add_unwind_opcode (0, 1);
18857 /* Calculate the uleb128 encoding of the offset. */
18861 bytes
[n
] = o
& 0x7f;
18867 /* Add the insn. */
18869 add_unwind_opcode (bytes
[n
- 1], 1);
18870 add_unwind_opcode (0xb2, 1);
18872 else if (offset
> 0x100)
18874 /* Two short opcodes. */
18875 add_unwind_opcode (0x3f, 1);
18876 op
= (offset
- 0x104) >> 2;
18877 add_unwind_opcode (op
, 1);
18879 else if (offset
> 0)
18881 /* Short opcode. */
18882 op
= (offset
- 4) >> 2;
18883 add_unwind_opcode (op
, 1);
18885 else if (offset
< 0)
18888 while (offset
> 0x100)
18890 add_unwind_opcode (0x7f, 1);
18893 op
= ((offset
- 4) >> 2) | 0x40;
18894 add_unwind_opcode (op
, 1);
18898 /* Finish the list of unwind opcodes for this function. */
18900 finish_unwind_opcodes (void)
18904 if (unwind
.fp_used
)
18906 /* Adjust sp as necessary. */
18907 unwind
.pending_offset
+= unwind
.fp_offset
- unwind
.frame_size
;
18908 flush_pending_unwind ();
18910 /* After restoring sp from the frame pointer. */
18911 op
= 0x90 | unwind
.fp_reg
;
18912 add_unwind_opcode (op
, 1);
18915 flush_pending_unwind ();
18919 /* Start an exception table entry. If idx is nonzero this is an index table
18923 start_unwind_section (const segT text_seg
, int idx
)
18925 const char * text_name
;
18926 const char * prefix
;
18927 const char * prefix_once
;
18928 const char * group_name
;
18932 size_t sec_name_len
;
18939 prefix
= ELF_STRING_ARM_unwind
;
18940 prefix_once
= ELF_STRING_ARM_unwind_once
;
18941 type
= SHT_ARM_EXIDX
;
18945 prefix
= ELF_STRING_ARM_unwind_info
;
18946 prefix_once
= ELF_STRING_ARM_unwind_info_once
;
18947 type
= SHT_PROGBITS
;
18950 text_name
= segment_name (text_seg
);
18951 if (streq (text_name
, ".text"))
18954 if (strncmp (text_name
, ".gnu.linkonce.t.",
18955 strlen (".gnu.linkonce.t.")) == 0)
18957 prefix
= prefix_once
;
18958 text_name
+= strlen (".gnu.linkonce.t.");
18961 prefix_len
= strlen (prefix
);
18962 text_len
= strlen (text_name
);
18963 sec_name_len
= prefix_len
+ text_len
;
18964 sec_name
= (char *) xmalloc (sec_name_len
+ 1);
18965 memcpy (sec_name
, prefix
, prefix_len
);
18966 memcpy (sec_name
+ prefix_len
, text_name
, text_len
);
18967 sec_name
[prefix_len
+ text_len
] = '\0';
18973 /* Handle COMDAT group. */
18974 if (prefix
!= prefix_once
&& (text_seg
->flags
& SEC_LINK_ONCE
) != 0)
18976 group_name
= elf_group_name (text_seg
);
18977 if (group_name
== NULL
)
18979 as_bad (_("Group section `%s' has no group signature"),
18980 segment_name (text_seg
));
18981 ignore_rest_of_line ();
18984 flags
|= SHF_GROUP
;
18988 obj_elf_change_section (sec_name
, type
, flags
, 0, group_name
, linkonce
, 0);
18990 /* Set the section link for index tables. */
18992 elf_linked_to_section (now_seg
) = text_seg
;
18996 /* Start an unwind table entry. HAVE_DATA is nonzero if we have additional
18997 personality routine data. Returns zero, or the index table value for
18998 and inline entry. */
19001 create_unwind_entry (int have_data
)
19006 /* The current word of data. */
19008 /* The number of bytes left in this word. */
19011 finish_unwind_opcodes ();
19013 /* Remember the current text section. */
19014 unwind
.saved_seg
= now_seg
;
19015 unwind
.saved_subseg
= now_subseg
;
19017 start_unwind_section (now_seg
, 0);
19019 if (unwind
.personality_routine
== NULL
)
19021 if (unwind
.personality_index
== -2)
19024 as_bad (_("handlerdata in cantunwind frame"));
19025 return 1; /* EXIDX_CANTUNWIND. */
19028 /* Use a default personality routine if none is specified. */
19029 if (unwind
.personality_index
== -1)
19031 if (unwind
.opcode_count
> 3)
19032 unwind
.personality_index
= 1;
19034 unwind
.personality_index
= 0;
19037 /* Space for the personality routine entry. */
19038 if (unwind
.personality_index
== 0)
19040 if (unwind
.opcode_count
> 3)
19041 as_bad (_("too many unwind opcodes for personality routine 0"));
19045 /* All the data is inline in the index table. */
19048 while (unwind
.opcode_count
> 0)
19050 unwind
.opcode_count
--;
19051 data
= (data
<< 8) | unwind
.opcodes
[unwind
.opcode_count
];
19055 /* Pad with "finish" opcodes. */
19057 data
= (data
<< 8) | 0xb0;
19064 /* We get two opcodes "free" in the first word. */
19065 size
= unwind
.opcode_count
- 2;
19068 /* An extra byte is required for the opcode count. */
19069 size
= unwind
.opcode_count
+ 1;
19071 size
= (size
+ 3) >> 2;
19073 as_bad (_("too many unwind opcodes"));
19075 frag_align (2, 0, 0);
19076 record_alignment (now_seg
, 2);
19077 unwind
.table_entry
= expr_build_dot ();
19079 /* Allocate the table entry. */
19080 ptr
= frag_more ((size
<< 2) + 4);
19081 where
= frag_now_fix () - ((size
<< 2) + 4);
19083 switch (unwind
.personality_index
)
19086 /* ??? Should this be a PLT generating relocation? */
19087 /* Custom personality routine. */
19088 fix_new (frag_now
, where
, 4, unwind
.personality_routine
, 0, 1,
19089 BFD_RELOC_ARM_PREL31
);
19094 /* Set the first byte to the number of additional words. */
19099 /* ABI defined personality routines. */
19101 /* Three opcodes bytes are packed into the first word. */
19108 /* The size and first two opcode bytes go in the first word. */
19109 data
= ((0x80 + unwind
.personality_index
) << 8) | size
;
19114 /* Should never happen. */
19118 /* Pack the opcodes into words (MSB first), reversing the list at the same
19120 while (unwind
.opcode_count
> 0)
19124 md_number_to_chars (ptr
, data
, 4);
19129 unwind
.opcode_count
--;
19131 data
= (data
<< 8) | unwind
.opcodes
[unwind
.opcode_count
];
19134 /* Finish off the last word. */
19137 /* Pad with "finish" opcodes. */
19139 data
= (data
<< 8) | 0xb0;
19141 md_number_to_chars (ptr
, data
, 4);
19146 /* Add an empty descriptor if there is no user-specified data. */
19147 ptr
= frag_more (4);
19148 md_number_to_chars (ptr
, 0, 4);
19155 /* Initialize the DWARF-2 unwind information for this procedure. */
19158 tc_arm_frame_initial_instructions (void)
19160 cfi_add_CFA_def_cfa (REG_SP
, 0);
19162 #endif /* OBJ_ELF */
19164 /* Convert REGNAME to a DWARF-2 register number. */
19167 tc_arm_regname_to_dw2regnum (char *regname
)
19169 int reg
= arm_reg_parse (®name
, REG_TYPE_RN
);
19179 tc_pe_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
19183 exp
.X_op
= O_secrel
;
19184 exp
.X_add_symbol
= symbol
;
19185 exp
.X_add_number
= 0;
19186 emit_expr (&exp
, size
);
19190 /* MD interface: Symbol and relocation handling. */
19192 /* Return the address within the segment that a PC-relative fixup is
19193 relative to. For ARM, PC-relative fixups applied to instructions
19194 are generally relative to the location of the fixup plus 8 bytes.
19195 Thumb branches are offset by 4, and Thumb loads relative to PC
19196 require special handling. */
19199 md_pcrel_from_section (fixS
* fixP
, segT seg
)
19201 offsetT base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
19203 /* If this is pc-relative and we are going to emit a relocation
19204 then we just want to put out any pipeline compensation that the linker
19205 will need. Otherwise we want to use the calculated base.
19206 For WinCE we skip the bias for externals as well, since this
19207 is how the MS ARM-CE assembler behaves and we want to be compatible. */
19209 && ((fixP
->fx_addsy
&& S_GET_SEGMENT (fixP
->fx_addsy
) != seg
)
19210 || (arm_force_relocation (fixP
)
19212 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
19218 switch (fixP
->fx_r_type
)
19220 /* PC relative addressing on the Thumb is slightly odd as the
19221 bottom two bits of the PC are forced to zero for the
19222 calculation. This happens *after* application of the
19223 pipeline offset. However, Thumb adrl already adjusts for
19224 this, so we need not do it again. */
19225 case BFD_RELOC_ARM_THUMB_ADD
:
19228 case BFD_RELOC_ARM_THUMB_OFFSET
:
19229 case BFD_RELOC_ARM_T32_OFFSET_IMM
:
19230 case BFD_RELOC_ARM_T32_ADD_PC12
:
19231 case BFD_RELOC_ARM_T32_CP_OFF_IMM
:
19232 return (base
+ 4) & ~3;
19234 /* Thumb branches are simply offset by +4. */
19235 case BFD_RELOC_THUMB_PCREL_BRANCH7
:
19236 case BFD_RELOC_THUMB_PCREL_BRANCH9
:
19237 case BFD_RELOC_THUMB_PCREL_BRANCH12
:
19238 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
19239 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
19242 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
19244 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
19245 && (!S_IS_EXTERNAL (fixP
->fx_addsy
))
19246 && ARM_IS_FUNC (fixP
->fx_addsy
)
19247 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
19248 base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
19251 /* BLX is like branches above, but forces the low two bits of PC to
19253 case BFD_RELOC_THUMB_PCREL_BLX
:
19255 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
19256 && (!S_IS_EXTERNAL (fixP
->fx_addsy
))
19257 && THUMB_IS_FUNC (fixP
->fx_addsy
)
19258 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
19259 base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
19260 return (base
+ 4) & ~3;
19262 /* ARM mode branches are offset by +8. However, the Windows CE
19263 loader expects the relocation not to take this into account. */
19264 case BFD_RELOC_ARM_PCREL_BLX
:
19266 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
19267 && (!S_IS_EXTERNAL (fixP
->fx_addsy
))
19268 && ARM_IS_FUNC (fixP
->fx_addsy
)
19269 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
19270 base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
19273 case BFD_RELOC_ARM_PCREL_CALL
:
19275 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
19276 && (!S_IS_EXTERNAL (fixP
->fx_addsy
))
19277 && THUMB_IS_FUNC (fixP
->fx_addsy
)
19278 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
19279 base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
19282 case BFD_RELOC_ARM_PCREL_BRANCH
:
19283 case BFD_RELOC_ARM_PCREL_JUMP
:
19284 case BFD_RELOC_ARM_PLT32
:
19286 /* When handling fixups immediately, because we have already
19287 discovered the value of a symbol, or the address of the frag involved
19288 we must account for the offset by +8, as the OS loader will never see the reloc.
19289 see fixup_segment() in write.c
19290 The S_IS_EXTERNAL test handles the case of global symbols.
19291 Those need the calculated base, not just the pipe compensation the linker will need. */
19293 && fixP
->fx_addsy
!= NULL
19294 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
19295 && (S_IS_EXTERNAL (fixP
->fx_addsy
) || !arm_force_relocation (fixP
)))
19303 /* ARM mode loads relative to PC are also offset by +8. Unlike
19304 branches, the Windows CE loader *does* expect the relocation
19305 to take this into account. */
19306 case BFD_RELOC_ARM_OFFSET_IMM
:
19307 case BFD_RELOC_ARM_OFFSET_IMM8
:
19308 case BFD_RELOC_ARM_HWLITERAL
:
19309 case BFD_RELOC_ARM_LITERAL
:
19310 case BFD_RELOC_ARM_CP_OFF_IMM
:
19314 /* Other PC-relative relocations are un-offset. */
19320 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
19321 Otherwise we have no need to default values of symbols. */
19324 md_undefined_symbol (char * name ATTRIBUTE_UNUSED
)
19327 if (name
[0] == '_' && name
[1] == 'G'
19328 && streq (name
, GLOBAL_OFFSET_TABLE_NAME
))
19332 if (symbol_find (name
))
19333 as_bad (_("GOT already in the symbol table"));
19335 GOT_symbol
= symbol_new (name
, undefined_section
,
19336 (valueT
) 0, & zero_address_frag
);
19346 /* Subroutine of md_apply_fix. Check to see if an immediate can be
19347 computed as two separate immediate values, added together. We
19348 already know that this value cannot be computed by just one ARM
19351 static unsigned int
19352 validate_immediate_twopart (unsigned int val
,
19353 unsigned int * highpart
)
19358 for (i
= 0; i
< 32; i
+= 2)
19359 if (((a
= rotate_left (val
, i
)) & 0xff) != 0)
19365 * highpart
= (a
>> 8) | ((i
+ 24) << 7);
19367 else if (a
& 0xff0000)
19369 if (a
& 0xff000000)
19371 * highpart
= (a
>> 16) | ((i
+ 16) << 7);
19375 gas_assert (a
& 0xff000000);
19376 * highpart
= (a
>> 24) | ((i
+ 8) << 7);
19379 return (a
& 0xff) | (i
<< 7);
19386 validate_offset_imm (unsigned int val
, int hwse
)
19388 if ((hwse
&& val
> 255) || val
> 4095)
19393 /* Subroutine of md_apply_fix. Do those data_ops which can take a
19394 negative immediate constant by altering the instruction. A bit of
19399 by inverting the second operand, and
19402 by negating the second operand. */
19405 negate_data_op (unsigned long * instruction
,
19406 unsigned long value
)
19409 unsigned long negated
, inverted
;
19411 negated
= encode_arm_immediate (-value
);
19412 inverted
= encode_arm_immediate (~value
);
19414 op
= (*instruction
>> DATA_OP_SHIFT
) & 0xf;
19417 /* First negates. */
19418 case OPCODE_SUB
: /* ADD <-> SUB */
19419 new_inst
= OPCODE_ADD
;
19424 new_inst
= OPCODE_SUB
;
19428 case OPCODE_CMP
: /* CMP <-> CMN */
19429 new_inst
= OPCODE_CMN
;
19434 new_inst
= OPCODE_CMP
;
19438 /* Now Inverted ops. */
19439 case OPCODE_MOV
: /* MOV <-> MVN */
19440 new_inst
= OPCODE_MVN
;
19445 new_inst
= OPCODE_MOV
;
19449 case OPCODE_AND
: /* AND <-> BIC */
19450 new_inst
= OPCODE_BIC
;
19455 new_inst
= OPCODE_AND
;
19459 case OPCODE_ADC
: /* ADC <-> SBC */
19460 new_inst
= OPCODE_SBC
;
19465 new_inst
= OPCODE_ADC
;
19469 /* We cannot do anything. */
19474 if (value
== (unsigned) FAIL
)
19477 *instruction
&= OPCODE_MASK
;
19478 *instruction
|= new_inst
<< DATA_OP_SHIFT
;
19482 /* Like negate_data_op, but for Thumb-2. */
19484 static unsigned int
19485 thumb32_negate_data_op (offsetT
*instruction
, unsigned int value
)
19489 unsigned int negated
, inverted
;
19491 negated
= encode_thumb32_immediate (-value
);
19492 inverted
= encode_thumb32_immediate (~value
);
19494 rd
= (*instruction
>> 8) & 0xf;
19495 op
= (*instruction
>> T2_DATA_OP_SHIFT
) & 0xf;
19498 /* ADD <-> SUB. Includes CMP <-> CMN. */
19499 case T2_OPCODE_SUB
:
19500 new_inst
= T2_OPCODE_ADD
;
19504 case T2_OPCODE_ADD
:
19505 new_inst
= T2_OPCODE_SUB
;
19509 /* ORR <-> ORN. Includes MOV <-> MVN. */
19510 case T2_OPCODE_ORR
:
19511 new_inst
= T2_OPCODE_ORN
;
19515 case T2_OPCODE_ORN
:
19516 new_inst
= T2_OPCODE_ORR
;
19520 /* AND <-> BIC. TST has no inverted equivalent. */
19521 case T2_OPCODE_AND
:
19522 new_inst
= T2_OPCODE_BIC
;
19529 case T2_OPCODE_BIC
:
19530 new_inst
= T2_OPCODE_AND
;
19535 case T2_OPCODE_ADC
:
19536 new_inst
= T2_OPCODE_SBC
;
19540 case T2_OPCODE_SBC
:
19541 new_inst
= T2_OPCODE_ADC
;
19545 /* We cannot do anything. */
19550 if (value
== (unsigned int)FAIL
)
19553 *instruction
&= T2_OPCODE_MASK
;
19554 *instruction
|= new_inst
<< T2_DATA_OP_SHIFT
;
19558 /* Read a 32-bit thumb instruction from buf. */
19559 static unsigned long
19560 get_thumb32_insn (char * buf
)
19562 unsigned long insn
;
19563 insn
= md_chars_to_number (buf
, THUMB_SIZE
) << 16;
19564 insn
|= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
19570 /* We usually want to set the low bit on the address of thumb function
19571 symbols. In particular .word foo - . should have the low bit set.
19572 Generic code tries to fold the difference of two symbols to
19573 a constant. Prevent this and force a relocation when the first symbols
19574 is a thumb function. */
19577 arm_optimize_expr (expressionS
*l
, operatorT op
, expressionS
*r
)
19579 if (op
== O_subtract
19580 && l
->X_op
== O_symbol
19581 && r
->X_op
== O_symbol
19582 && THUMB_IS_FUNC (l
->X_add_symbol
))
19584 l
->X_op
= O_subtract
;
19585 l
->X_op_symbol
= r
->X_add_symbol
;
19586 l
->X_add_number
-= r
->X_add_number
;
19590 /* Process as normal. */
19594 /* Encode Thumb2 unconditional branches and calls. The encoding
19595 for the 2 are identical for the immediate values. */
19598 encode_thumb2_b_bl_offset (char * buf
, offsetT value
)
19600 #define T2I1I2MASK ((1 << 13) | (1 << 11))
19603 addressT S
, I1
, I2
, lo
, hi
;
19605 S
= (value
>> 24) & 0x01;
19606 I1
= (value
>> 23) & 0x01;
19607 I2
= (value
>> 22) & 0x01;
19608 hi
= (value
>> 12) & 0x3ff;
19609 lo
= (value
>> 1) & 0x7ff;
19610 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
19611 newval2
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
19612 newval
|= (S
<< 10) | hi
;
19613 newval2
&= ~T2I1I2MASK
;
19614 newval2
|= (((I1
^ S
) << 13) | ((I2
^ S
) << 11) | lo
) ^ T2I1I2MASK
;
19615 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
19616 md_number_to_chars (buf
+ THUMB_SIZE
, newval2
, THUMB_SIZE
);
19620 md_apply_fix (fixS
* fixP
,
19624 offsetT value
= * valP
;
19626 unsigned int newimm
;
19627 unsigned long temp
;
19629 char * buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
19631 gas_assert (fixP
->fx_r_type
<= BFD_RELOC_UNUSED
);
19633 /* Note whether this will delete the relocation. */
19635 if (fixP
->fx_addsy
== 0 && !fixP
->fx_pcrel
)
19638 /* On a 64-bit host, silently truncate 'value' to 32 bits for
19639 consistency with the behaviour on 32-bit hosts. Remember value
19641 value
&= 0xffffffff;
19642 value
^= 0x80000000;
19643 value
-= 0x80000000;
19646 fixP
->fx_addnumber
= value
;
19648 /* Same treatment for fixP->fx_offset. */
19649 fixP
->fx_offset
&= 0xffffffff;
19650 fixP
->fx_offset
^= 0x80000000;
19651 fixP
->fx_offset
-= 0x80000000;
19653 switch (fixP
->fx_r_type
)
19655 case BFD_RELOC_NONE
:
19656 /* This will need to go in the object file. */
19660 case BFD_RELOC_ARM_IMMEDIATE
:
19661 /* We claim that this fixup has been processed here,
19662 even if in fact we generate an error because we do
19663 not have a reloc for it, so tc_gen_reloc will reject it. */
19667 && ! S_IS_DEFINED (fixP
->fx_addsy
))
19669 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19670 _("undefined symbol %s used as an immediate value"),
19671 S_GET_NAME (fixP
->fx_addsy
));
19676 && S_GET_SEGMENT (fixP
->fx_addsy
) != seg
)
19678 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19679 _("symbol %s is in a different section"),
19680 S_GET_NAME (fixP
->fx_addsy
));
19684 newimm
= encode_arm_immediate (value
);
19685 temp
= md_chars_to_number (buf
, INSN_SIZE
);
19687 /* If the instruction will fail, see if we can fix things up by
19688 changing the opcode. */
19689 if (newimm
== (unsigned int) FAIL
19690 && (newimm
= negate_data_op (&temp
, value
)) == (unsigned int) FAIL
)
19692 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19693 _("invalid constant (%lx) after fixup"),
19694 (unsigned long) value
);
19698 newimm
|= (temp
& 0xfffff000);
19699 md_number_to_chars (buf
, (valueT
) newimm
, INSN_SIZE
);
19702 case BFD_RELOC_ARM_ADRL_IMMEDIATE
:
19704 unsigned int highpart
= 0;
19705 unsigned int newinsn
= 0xe1a00000; /* nop. */
19708 && ! S_IS_DEFINED (fixP
->fx_addsy
))
19710 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19711 _("undefined symbol %s used as an immediate value"),
19712 S_GET_NAME (fixP
->fx_addsy
));
19717 && S_GET_SEGMENT (fixP
->fx_addsy
) != seg
)
19719 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19720 _("symbol %s is in a different section"),
19721 S_GET_NAME (fixP
->fx_addsy
));
19725 newimm
= encode_arm_immediate (value
);
19726 temp
= md_chars_to_number (buf
, INSN_SIZE
);
19728 /* If the instruction will fail, see if we can fix things up by
19729 changing the opcode. */
19730 if (newimm
== (unsigned int) FAIL
19731 && (newimm
= negate_data_op (& temp
, value
)) == (unsigned int) FAIL
)
19733 /* No ? OK - try using two ADD instructions to generate
19735 newimm
= validate_immediate_twopart (value
, & highpart
);
19737 /* Yes - then make sure that the second instruction is
19739 if (newimm
!= (unsigned int) FAIL
)
19741 /* Still No ? Try using a negated value. */
19742 else if ((newimm
= validate_immediate_twopart (- value
, & highpart
)) != (unsigned int) FAIL
)
19743 temp
= newinsn
= (temp
& OPCODE_MASK
) | OPCODE_SUB
<< DATA_OP_SHIFT
;
19744 /* Otherwise - give up. */
19747 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19748 _("unable to compute ADRL instructions for PC offset of 0x%lx"),
19753 /* Replace the first operand in the 2nd instruction (which
19754 is the PC) with the destination register. We have
19755 already added in the PC in the first instruction and we
19756 do not want to do it again. */
19757 newinsn
&= ~ 0xf0000;
19758 newinsn
|= ((newinsn
& 0x0f000) << 4);
19761 newimm
|= (temp
& 0xfffff000);
19762 md_number_to_chars (buf
, (valueT
) newimm
, INSN_SIZE
);
19764 highpart
|= (newinsn
& 0xfffff000);
19765 md_number_to_chars (buf
+ INSN_SIZE
, (valueT
) highpart
, INSN_SIZE
);
19769 case BFD_RELOC_ARM_OFFSET_IMM
:
19770 if (!fixP
->fx_done
&& seg
->use_rela_p
)
19773 case BFD_RELOC_ARM_LITERAL
:
19779 if (validate_offset_imm (value
, 0) == FAIL
)
19781 if (fixP
->fx_r_type
== BFD_RELOC_ARM_LITERAL
)
19782 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19783 _("invalid literal constant: pool needs to be closer"));
19785 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19786 _("bad immediate value for offset (%ld)"),
19791 newval
= md_chars_to_number (buf
, INSN_SIZE
);
19792 newval
&= 0xff7ff000;
19793 newval
|= value
| (sign
? INDEX_UP
: 0);
19794 md_number_to_chars (buf
, newval
, INSN_SIZE
);
19797 case BFD_RELOC_ARM_OFFSET_IMM8
:
19798 case BFD_RELOC_ARM_HWLITERAL
:
19804 if (validate_offset_imm (value
, 1) == FAIL
)
19806 if (fixP
->fx_r_type
== BFD_RELOC_ARM_HWLITERAL
)
19807 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19808 _("invalid literal constant: pool needs to be closer"));
19810 as_bad (_("bad immediate value for 8-bit offset (%ld)"),
19815 newval
= md_chars_to_number (buf
, INSN_SIZE
);
19816 newval
&= 0xff7ff0f0;
19817 newval
|= ((value
>> 4) << 8) | (value
& 0xf) | (sign
? INDEX_UP
: 0);
19818 md_number_to_chars (buf
, newval
, INSN_SIZE
);
19821 case BFD_RELOC_ARM_T32_OFFSET_U8
:
19822 if (value
< 0 || value
> 1020 || value
% 4 != 0)
19823 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19824 _("bad immediate value for offset (%ld)"), (long) value
);
19827 newval
= md_chars_to_number (buf
+2, THUMB_SIZE
);
19829 md_number_to_chars (buf
+2, newval
, THUMB_SIZE
);
19832 case BFD_RELOC_ARM_T32_OFFSET_IMM
:
19833 /* This is a complicated relocation used for all varieties of Thumb32
19834 load/store instruction with immediate offset:
19836 1110 100P u1WL NNNN XXXX YYYY iiii iiii - +/-(U) pre/post(P) 8-bit,
19837 *4, optional writeback(W)
19838 (doubleword load/store)
19840 1111 100S uTTL 1111 XXXX iiii iiii iiii - +/-(U) 12-bit PC-rel
19841 1111 100S 0TTL NNNN XXXX 1Pu1 iiii iiii - +/-(U) pre/post(P) 8-bit
19842 1111 100S 0TTL NNNN XXXX 1110 iiii iiii - positive 8-bit (T instruction)
19843 1111 100S 1TTL NNNN XXXX iiii iiii iiii - positive 12-bit
19844 1111 100S 0TTL NNNN XXXX 1100 iiii iiii - negative 8-bit
19846 Uppercase letters indicate bits that are already encoded at
19847 this point. Lowercase letters are our problem. For the
19848 second block of instructions, the secondary opcode nybble
19849 (bits 8..11) is present, and bit 23 is zero, even if this is
19850 a PC-relative operation. */
19851 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
19853 newval
|= md_chars_to_number (buf
+THUMB_SIZE
, THUMB_SIZE
);
19855 if ((newval
& 0xf0000000) == 0xe0000000)
19857 /* Doubleword load/store: 8-bit offset, scaled by 4. */
19859 newval
|= (1 << 23);
19862 if (value
% 4 != 0)
19864 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19865 _("offset not a multiple of 4"));
19871 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19872 _("offset out of range"));
19877 else if ((newval
& 0x000f0000) == 0x000f0000)
19879 /* PC-relative, 12-bit offset. */
19881 newval
|= (1 << 23);
19886 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19887 _("offset out of range"));
19892 else if ((newval
& 0x00000100) == 0x00000100)
19894 /* Writeback: 8-bit, +/- offset. */
19896 newval
|= (1 << 9);
19901 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19902 _("offset out of range"));
19907 else if ((newval
& 0x00000f00) == 0x00000e00)
19909 /* T-instruction: positive 8-bit offset. */
19910 if (value
< 0 || value
> 0xff)
19912 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19913 _("offset out of range"));
19921 /* Positive 12-bit or negative 8-bit offset. */
19925 newval
|= (1 << 23);
19935 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19936 _("offset out of range"));
19943 md_number_to_chars (buf
, (newval
>> 16) & 0xffff, THUMB_SIZE
);
19944 md_number_to_chars (buf
+ THUMB_SIZE
, newval
& 0xffff, THUMB_SIZE
);
19947 case BFD_RELOC_ARM_SHIFT_IMM
:
19948 newval
= md_chars_to_number (buf
, INSN_SIZE
);
19949 if (((unsigned long) value
) > 32
19951 && (((newval
& 0x60) == 0) || (newval
& 0x60) == 0x60)))
19953 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19954 _("shift expression is too large"));
19959 /* Shifts of zero must be done as lsl. */
19961 else if (value
== 32)
19963 newval
&= 0xfffff07f;
19964 newval
|= (value
& 0x1f) << 7;
19965 md_number_to_chars (buf
, newval
, INSN_SIZE
);
19968 case BFD_RELOC_ARM_T32_IMMEDIATE
:
19969 case BFD_RELOC_ARM_T32_ADD_IMM
:
19970 case BFD_RELOC_ARM_T32_IMM12
:
19971 case BFD_RELOC_ARM_T32_ADD_PC12
:
19972 /* We claim that this fixup has been processed here,
19973 even if in fact we generate an error because we do
19974 not have a reloc for it, so tc_gen_reloc will reject it. */
19978 && ! S_IS_DEFINED (fixP
->fx_addsy
))
19980 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
19981 _("undefined symbol %s used as an immediate value"),
19982 S_GET_NAME (fixP
->fx_addsy
));
19986 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
19988 newval
|= md_chars_to_number (buf
+2, THUMB_SIZE
);
19991 if (fixP
->fx_r_type
== BFD_RELOC_ARM_T32_IMMEDIATE
19992 || fixP
->fx_r_type
== BFD_RELOC_ARM_T32_ADD_IMM
)
19994 newimm
= encode_thumb32_immediate (value
);
19995 if (newimm
== (unsigned int) FAIL
)
19996 newimm
= thumb32_negate_data_op (&newval
, value
);
19998 if (fixP
->fx_r_type
!= BFD_RELOC_ARM_T32_IMMEDIATE
19999 && newimm
== (unsigned int) FAIL
)
20001 /* Turn add/sum into addw/subw. */
20002 if (fixP
->fx_r_type
== BFD_RELOC_ARM_T32_ADD_IMM
)
20003 newval
= (newval
& 0xfeffffff) | 0x02000000;
20005 /* 12 bit immediate for addw/subw. */
20009 newval
^= 0x00a00000;
20012 newimm
= (unsigned int) FAIL
;
20017 if (newimm
== (unsigned int)FAIL
)
20019 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20020 _("invalid constant (%lx) after fixup"),
20021 (unsigned long) value
);
20025 newval
|= (newimm
& 0x800) << 15;
20026 newval
|= (newimm
& 0x700) << 4;
20027 newval
|= (newimm
& 0x0ff);
20029 md_number_to_chars (buf
, (valueT
) ((newval
>> 16) & 0xffff), THUMB_SIZE
);
20030 md_number_to_chars (buf
+2, (valueT
) (newval
& 0xffff), THUMB_SIZE
);
20033 case BFD_RELOC_ARM_SMC
:
20034 if (((unsigned long) value
) > 0xffff)
20035 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20036 _("invalid smc expression"));
20037 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20038 newval
|= (value
& 0xf) | ((value
& 0xfff0) << 4);
20039 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20042 case BFD_RELOC_ARM_SWI
:
20043 if (fixP
->tc_fix_data
!= 0)
20045 if (((unsigned long) value
) > 0xff)
20046 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20047 _("invalid swi expression"));
20048 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20050 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20054 if (((unsigned long) value
) > 0x00ffffff)
20055 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20056 _("invalid swi expression"));
20057 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20059 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20063 case BFD_RELOC_ARM_MULTI
:
20064 if (((unsigned long) value
) > 0xffff)
20065 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20066 _("invalid expression in load/store multiple"));
20067 newval
= value
| md_chars_to_number (buf
, INSN_SIZE
);
20068 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20072 case BFD_RELOC_ARM_PCREL_CALL
:
20074 if (ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
)
20076 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20077 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20078 && THUMB_IS_FUNC (fixP
->fx_addsy
))
20079 /* Flip the bl to blx. This is a simple flip
20080 bit here because we generate PCREL_CALL for
20081 unconditional bls. */
20083 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20084 newval
= newval
| 0x10000000;
20085 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20091 goto arm_branch_common
;
20093 case BFD_RELOC_ARM_PCREL_JUMP
:
20094 if (ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
)
20096 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20097 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20098 && THUMB_IS_FUNC (fixP
->fx_addsy
))
20100 /* This would map to a bl<cond>, b<cond>,
20101 b<always> to a Thumb function. We
20102 need to force a relocation for this particular
20104 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20108 case BFD_RELOC_ARM_PLT32
:
20110 case BFD_RELOC_ARM_PCREL_BRANCH
:
20112 goto arm_branch_common
;
20114 case BFD_RELOC_ARM_PCREL_BLX
:
20117 if (ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
)
20119 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20120 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20121 && ARM_IS_FUNC (fixP
->fx_addsy
))
20123 /* Flip the blx to a bl and warn. */
20124 const char *name
= S_GET_NAME (fixP
->fx_addsy
);
20125 newval
= 0xeb000000;
20126 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
20127 _("blx to '%s' an ARM ISA state function changed to bl"),
20129 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20135 if (EF_ARM_EABI_VERSION (meabi_flags
) >= EF_ARM_EABI_VER4
)
20136 fixP
->fx_r_type
= BFD_RELOC_ARM_PCREL_CALL
;
20140 /* We are going to store value (shifted right by two) in the
20141 instruction, in a 24 bit, signed field. Bits 26 through 32 either
20142 all clear or all set and bit 0 must be clear. For B/BL bit 1 must
20143 also be be clear. */
20145 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20146 _("misaligned branch destination"));
20147 if ((value
& (offsetT
)0xfe000000) != (offsetT
)0
20148 && (value
& (offsetT
)0xfe000000) != (offsetT
)0xfe000000)
20149 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20150 _("branch out of range"));
20152 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20154 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20155 newval
|= (value
>> 2) & 0x00ffffff;
20156 /* Set the H bit on BLX instructions. */
20160 newval
|= 0x01000000;
20162 newval
&= ~0x01000000;
20164 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20168 case BFD_RELOC_THUMB_PCREL_BRANCH7
: /* CBZ */
20169 /* CBZ can only branch forward. */
20171 /* Attempts to use CBZ to branch to the next instruction
20172 (which, strictly speaking, are prohibited) will be turned into
20175 FIXME: It may be better to remove the instruction completely and
20176 perform relaxation. */
20179 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20180 newval
= 0xbf00; /* NOP encoding T1 */
20181 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20186 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20187 _("branch out of range"));
20189 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20191 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20192 newval
|= ((value
& 0x3e) << 2) | ((value
& 0x40) << 3);
20193 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20198 case BFD_RELOC_THUMB_PCREL_BRANCH9
: /* Conditional branch. */
20199 if ((value
& ~0xff) && ((value
& ~0xff) != ~0xff))
20200 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20201 _("branch out of range"));
20203 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20205 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20206 newval
|= (value
& 0x1ff) >> 1;
20207 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20211 case BFD_RELOC_THUMB_PCREL_BRANCH12
: /* Unconditional branch. */
20212 if ((value
& ~0x7ff) && ((value
& ~0x7ff) != ~0x7ff))
20213 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20214 _("branch out of range"));
20216 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20218 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20219 newval
|= (value
& 0xfff) >> 1;
20220 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20224 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
20226 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20227 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20228 && S_IS_DEFINED (fixP
->fx_addsy
)
20229 && ARM_IS_FUNC (fixP
->fx_addsy
)
20230 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
20232 /* Force a relocation for a branch 20 bits wide. */
20235 if ((value
& ~0x1fffff) && ((value
& ~0x1fffff) != ~0x1fffff))
20236 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20237 _("conditional branch out of range"));
20239 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20242 addressT S
, J1
, J2
, lo
, hi
;
20244 S
= (value
& 0x00100000) >> 20;
20245 J2
= (value
& 0x00080000) >> 19;
20246 J1
= (value
& 0x00040000) >> 18;
20247 hi
= (value
& 0x0003f000) >> 12;
20248 lo
= (value
& 0x00000ffe) >> 1;
20250 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20251 newval2
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
20252 newval
|= (S
<< 10) | hi
;
20253 newval2
|= (J1
<< 13) | (J2
<< 11) | lo
;
20254 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20255 md_number_to_chars (buf
+ THUMB_SIZE
, newval2
, THUMB_SIZE
);
20259 case BFD_RELOC_THUMB_PCREL_BLX
:
20261 /* If there is a blx from a thumb state function to
20262 another thumb function flip this to a bl and warn
20266 && S_IS_DEFINED (fixP
->fx_addsy
)
20267 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20268 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20269 && THUMB_IS_FUNC (fixP
->fx_addsy
))
20271 const char *name
= S_GET_NAME (fixP
->fx_addsy
);
20272 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
20273 _("blx to Thumb func '%s' from Thumb ISA state changed to bl"),
20275 newval
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
20276 newval
= newval
| 0x1000;
20277 md_number_to_chars (buf
+THUMB_SIZE
, newval
, THUMB_SIZE
);
20278 fixP
->fx_r_type
= BFD_RELOC_THUMB_PCREL_BRANCH23
;
20283 goto thumb_bl_common
;
20285 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
20287 /* A bl from Thumb state ISA to an internal ARM state function
20288 is converted to a blx. */
20290 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
)
20291 && !S_IS_EXTERNAL (fixP
->fx_addsy
)
20292 && S_IS_DEFINED (fixP
->fx_addsy
)
20293 && ARM_IS_FUNC (fixP
->fx_addsy
)
20294 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
))
20296 newval
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
20297 newval
= newval
& ~0x1000;
20298 md_number_to_chars (buf
+THUMB_SIZE
, newval
, THUMB_SIZE
);
20299 fixP
->fx_r_type
= BFD_RELOC_THUMB_PCREL_BLX
;
20306 if (EF_ARM_EABI_VERSION (meabi_flags
) >= EF_ARM_EABI_VER4
&&
20307 fixP
->fx_r_type
== BFD_RELOC_THUMB_PCREL_BLX
)
20308 fixP
->fx_r_type
= BFD_RELOC_THUMB_PCREL_BRANCH23
;
20311 if (fixP
->fx_r_type
== BFD_RELOC_THUMB_PCREL_BLX
)
20312 /* For a BLX instruction, make sure that the relocation is rounded up
20313 to a word boundary. This follows the semantics of the instruction
20314 which specifies that bit 1 of the target address will come from bit
20315 1 of the base address. */
20316 value
= (value
+ 1) & ~ 1;
20319 if ((value
& ~0x3fffff) && ((value
& ~0x3fffff) != ~0x3fffff))
20321 if (!(ARM_CPU_HAS_FEATURE (cpu_variant
, arm_arch_t2
)))
20323 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20324 _("branch out of range"));
20326 else if ((value
& ~0x1ffffff)
20327 && ((value
& ~0x1ffffff) != ~0x1ffffff))
20329 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20330 _("Thumb2 branch out of range"));
20334 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20335 encode_thumb2_b_bl_offset (buf
, value
);
20339 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
20340 if ((value
& ~0x1ffffff) && ((value
& ~0x1ffffff) != ~0x1ffffff))
20341 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20342 _("branch out of range"));
20344 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20345 encode_thumb2_b_bl_offset (buf
, value
);
20350 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20351 md_number_to_chars (buf
, value
, 1);
20355 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20356 md_number_to_chars (buf
, value
, 2);
20360 case BFD_RELOC_ARM_TLS_GD32
:
20361 case BFD_RELOC_ARM_TLS_LE32
:
20362 case BFD_RELOC_ARM_TLS_IE32
:
20363 case BFD_RELOC_ARM_TLS_LDM32
:
20364 case BFD_RELOC_ARM_TLS_LDO32
:
20365 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
20368 case BFD_RELOC_ARM_GOT32
:
20369 case BFD_RELOC_ARM_GOTOFF
:
20370 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20371 md_number_to_chars (buf
, 0, 4);
20374 case BFD_RELOC_ARM_TARGET2
:
20375 /* TARGET2 is not partial-inplace, so we need to write the
20376 addend here for REL targets, because it won't be written out
20377 during reloc processing later. */
20378 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20379 md_number_to_chars (buf
, fixP
->fx_offset
, 4);
20383 case BFD_RELOC_RVA
:
20385 case BFD_RELOC_ARM_TARGET1
:
20386 case BFD_RELOC_ARM_ROSEGREL32
:
20387 case BFD_RELOC_ARM_SBREL32
:
20388 case BFD_RELOC_32_PCREL
:
20390 case BFD_RELOC_32_SECREL
:
20392 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20394 /* For WinCE we only do this for pcrel fixups. */
20395 if (fixP
->fx_done
|| fixP
->fx_pcrel
)
20397 md_number_to_chars (buf
, value
, 4);
20401 case BFD_RELOC_ARM_PREL31
:
20402 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20404 newval
= md_chars_to_number (buf
, 4) & 0x80000000;
20405 if ((value
^ (value
>> 1)) & 0x40000000)
20407 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20408 _("rel31 relocation overflow"));
20410 newval
|= value
& 0x7fffffff;
20411 md_number_to_chars (buf
, newval
, 4);
20416 case BFD_RELOC_ARM_CP_OFF_IMM
:
20417 case BFD_RELOC_ARM_T32_CP_OFF_IMM
:
20418 if (value
< -1023 || value
> 1023 || (value
& 3))
20419 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20420 _("co-processor offset out of range"));
20425 if (fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM
20426 || fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM_S2
)
20427 newval
= md_chars_to_number (buf
, INSN_SIZE
);
20429 newval
= get_thumb32_insn (buf
);
20430 newval
&= 0xff7fff00;
20431 newval
|= (value
>> 2) | (sign
? INDEX_UP
: 0);
20432 if (fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM
20433 || fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM_S2
)
20434 md_number_to_chars (buf
, newval
, INSN_SIZE
);
20436 put_thumb32_insn (buf
, newval
);
20439 case BFD_RELOC_ARM_CP_OFF_IMM_S2
:
20440 case BFD_RELOC_ARM_T32_CP_OFF_IMM_S2
:
20441 if (value
< -255 || value
> 255)
20442 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20443 _("co-processor offset out of range"));
20445 goto cp_off_common
;
20447 case BFD_RELOC_ARM_THUMB_OFFSET
:
20448 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20449 /* Exactly what ranges, and where the offset is inserted depends
20450 on the type of instruction, we can establish this from the
20452 switch (newval
>> 12)
20454 case 4: /* PC load. */
20455 /* Thumb PC loads are somewhat odd, bit 1 of the PC is
20456 forced to zero for these loads; md_pcrel_from has already
20457 compensated for this. */
20459 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20460 _("invalid offset, target not word aligned (0x%08lX)"),
20461 (((unsigned long) fixP
->fx_frag
->fr_address
20462 + (unsigned long) fixP
->fx_where
) & ~3)
20463 + (unsigned long) value
);
20465 if (value
& ~0x3fc)
20466 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20467 _("invalid offset, value too big (0x%08lX)"),
20470 newval
|= value
>> 2;
20473 case 9: /* SP load/store. */
20474 if (value
& ~0x3fc)
20475 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20476 _("invalid offset, value too big (0x%08lX)"),
20478 newval
|= value
>> 2;
20481 case 6: /* Word load/store. */
20483 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20484 _("invalid offset, value too big (0x%08lX)"),
20486 newval
|= value
<< 4; /* 6 - 2. */
20489 case 7: /* Byte load/store. */
20491 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20492 _("invalid offset, value too big (0x%08lX)"),
20494 newval
|= value
<< 6;
20497 case 8: /* Halfword load/store. */
20499 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20500 _("invalid offset, value too big (0x%08lX)"),
20502 newval
|= value
<< 5; /* 6 - 1. */
20506 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20507 "Unable to process relocation for thumb opcode: %lx",
20508 (unsigned long) newval
);
20511 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20514 case BFD_RELOC_ARM_THUMB_ADD
:
20515 /* This is a complicated relocation, since we use it for all of
20516 the following immediate relocations:
20520 9bit ADD/SUB SP word-aligned
20521 10bit ADD PC/SP word-aligned
20523 The type of instruction being processed is encoded in the
20530 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20532 int rd
= (newval
>> 4) & 0xf;
20533 int rs
= newval
& 0xf;
20534 int subtract
= !!(newval
& 0x8000);
20536 /* Check for HI regs, only very restricted cases allowed:
20537 Adjusting SP, and using PC or SP to get an address. */
20538 if ((rd
> 7 && (rd
!= REG_SP
|| rs
!= REG_SP
))
20539 || (rs
> 7 && rs
!= REG_SP
&& rs
!= REG_PC
))
20540 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20541 _("invalid Hi register with immediate"));
20543 /* If value is negative, choose the opposite instruction. */
20547 subtract
= !subtract
;
20549 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20550 _("immediate value out of range"));
20555 if (value
& ~0x1fc)
20556 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20557 _("invalid immediate for stack address calculation"));
20558 newval
= subtract
? T_OPCODE_SUB_ST
: T_OPCODE_ADD_ST
;
20559 newval
|= value
>> 2;
20561 else if (rs
== REG_PC
|| rs
== REG_SP
)
20563 if (subtract
|| value
& ~0x3fc)
20564 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20565 _("invalid immediate for address calculation (value = 0x%08lX)"),
20566 (unsigned long) value
);
20567 newval
= (rs
== REG_PC
? T_OPCODE_ADD_PC
: T_OPCODE_ADD_SP
);
20569 newval
|= value
>> 2;
20574 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20575 _("immediate value out of range"));
20576 newval
= subtract
? T_OPCODE_SUB_I8
: T_OPCODE_ADD_I8
;
20577 newval
|= (rd
<< 8) | value
;
20582 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20583 _("immediate value out of range"));
20584 newval
= subtract
? T_OPCODE_SUB_I3
: T_OPCODE_ADD_I3
;
20585 newval
|= rd
| (rs
<< 3) | (value
<< 6);
20588 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20591 case BFD_RELOC_ARM_THUMB_IMM
:
20592 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
20593 if (value
< 0 || value
> 255)
20594 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20595 _("invalid immediate: %ld is out of range"),
20598 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20601 case BFD_RELOC_ARM_THUMB_SHIFT
:
20602 /* 5bit shift value (0..32). LSL cannot take 32. */
20603 newval
= md_chars_to_number (buf
, THUMB_SIZE
) & 0xf83f;
20604 temp
= newval
& 0xf800;
20605 if (value
< 0 || value
> 32 || (value
== 32 && temp
== T_OPCODE_LSL_I
))
20606 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20607 _("invalid shift value: %ld"), (long) value
);
20608 /* Shifts of zero must be encoded as LSL. */
20610 newval
= (newval
& 0x003f) | T_OPCODE_LSL_I
;
20611 /* Shifts of 32 are encoded as zero. */
20612 else if (value
== 32)
20614 newval
|= value
<< 6;
20615 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
20618 case BFD_RELOC_VTABLE_INHERIT
:
20619 case BFD_RELOC_VTABLE_ENTRY
:
20623 case BFD_RELOC_ARM_MOVW
:
20624 case BFD_RELOC_ARM_MOVT
:
20625 case BFD_RELOC_ARM_THUMB_MOVW
:
20626 case BFD_RELOC_ARM_THUMB_MOVT
:
20627 if (fixP
->fx_done
|| !seg
->use_rela_p
)
20629 /* REL format relocations are limited to a 16-bit addend. */
20630 if (!fixP
->fx_done
)
20632 if (value
< -0x8000 || value
> 0x7fff)
20633 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20634 _("offset out of range"));
20636 else if (fixP
->fx_r_type
== BFD_RELOC_ARM_MOVT
20637 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVT
)
20642 if (fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVW
20643 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVT
)
20645 newval
= get_thumb32_insn (buf
);
20646 newval
&= 0xfbf08f00;
20647 newval
|= (value
& 0xf000) << 4;
20648 newval
|= (value
& 0x0800) << 15;
20649 newval
|= (value
& 0x0700) << 4;
20650 newval
|= (value
& 0x00ff);
20651 put_thumb32_insn (buf
, newval
);
20655 newval
= md_chars_to_number (buf
, 4);
20656 newval
&= 0xfff0f000;
20657 newval
|= value
& 0x0fff;
20658 newval
|= (value
& 0xf000) << 4;
20659 md_number_to_chars (buf
, newval
, 4);
20664 case BFD_RELOC_ARM_ALU_PC_G0_NC
:
20665 case BFD_RELOC_ARM_ALU_PC_G0
:
20666 case BFD_RELOC_ARM_ALU_PC_G1_NC
:
20667 case BFD_RELOC_ARM_ALU_PC_G1
:
20668 case BFD_RELOC_ARM_ALU_PC_G2
:
20669 case BFD_RELOC_ARM_ALU_SB_G0_NC
:
20670 case BFD_RELOC_ARM_ALU_SB_G0
:
20671 case BFD_RELOC_ARM_ALU_SB_G1_NC
:
20672 case BFD_RELOC_ARM_ALU_SB_G1
:
20673 case BFD_RELOC_ARM_ALU_SB_G2
:
20674 gas_assert (!fixP
->fx_done
);
20675 if (!seg
->use_rela_p
)
20678 bfd_vma encoded_addend
;
20679 bfd_vma addend_abs
= abs (value
);
20681 /* Check that the absolute value of the addend can be
20682 expressed as an 8-bit constant plus a rotation. */
20683 encoded_addend
= encode_arm_immediate (addend_abs
);
20684 if (encoded_addend
== (unsigned int) FAIL
)
20685 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20686 _("the offset 0x%08lX is not representable"),
20687 (unsigned long) addend_abs
);
20689 /* Extract the instruction. */
20690 insn
= md_chars_to_number (buf
, INSN_SIZE
);
20692 /* If the addend is positive, use an ADD instruction.
20693 Otherwise use a SUB. Take care not to destroy the S bit. */
20694 insn
&= 0xff1fffff;
20700 /* Place the encoded addend into the first 12 bits of the
20702 insn
&= 0xfffff000;
20703 insn
|= encoded_addend
;
20705 /* Update the instruction. */
20706 md_number_to_chars (buf
, insn
, INSN_SIZE
);
20710 case BFD_RELOC_ARM_LDR_PC_G0
:
20711 case BFD_RELOC_ARM_LDR_PC_G1
:
20712 case BFD_RELOC_ARM_LDR_PC_G2
:
20713 case BFD_RELOC_ARM_LDR_SB_G0
:
20714 case BFD_RELOC_ARM_LDR_SB_G1
:
20715 case BFD_RELOC_ARM_LDR_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 12 bits. */
20724 if (addend_abs
>= 0x1000)
20725 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20726 _("bad offset 0x%08lX (only 12 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 absolute value of the addend into the first 12 bits
20740 of the instruction. */
20741 insn
&= 0xfffff000;
20742 insn
|= addend_abs
;
20744 /* Update the instruction. */
20745 md_number_to_chars (buf
, insn
, INSN_SIZE
);
20749 case BFD_RELOC_ARM_LDRS_PC_G0
:
20750 case BFD_RELOC_ARM_LDRS_PC_G1
:
20751 case BFD_RELOC_ARM_LDRS_PC_G2
:
20752 case BFD_RELOC_ARM_LDRS_SB_G0
:
20753 case BFD_RELOC_ARM_LDRS_SB_G1
:
20754 case BFD_RELOC_ARM_LDRS_SB_G2
:
20755 gas_assert (!fixP
->fx_done
);
20756 if (!seg
->use_rela_p
)
20759 bfd_vma addend_abs
= abs (value
);
20761 /* Check that the absolute value of the addend can be
20762 encoded in 8 bits. */
20763 if (addend_abs
>= 0x100)
20764 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20765 _("bad offset 0x%08lX (only 8 bits available for the magnitude)"),
20766 (unsigned long) addend_abs
);
20768 /* Extract the instruction. */
20769 insn
= md_chars_to_number (buf
, INSN_SIZE
);
20771 /* If the addend is negative, clear bit 23 of the instruction.
20772 Otherwise set it. */
20774 insn
&= ~(1 << 23);
20778 /* Place the first four bits of the absolute value of the addend
20779 into the first 4 bits of the instruction, and the remaining
20780 four into bits 8 .. 11. */
20781 insn
&= 0xfffff0f0;
20782 insn
|= (addend_abs
& 0xf) | ((addend_abs
& 0xf0) << 4);
20784 /* Update the instruction. */
20785 md_number_to_chars (buf
, insn
, INSN_SIZE
);
20789 case BFD_RELOC_ARM_LDC_PC_G0
:
20790 case BFD_RELOC_ARM_LDC_PC_G1
:
20791 case BFD_RELOC_ARM_LDC_PC_G2
:
20792 case BFD_RELOC_ARM_LDC_SB_G0
:
20793 case BFD_RELOC_ARM_LDC_SB_G1
:
20794 case BFD_RELOC_ARM_LDC_SB_G2
:
20795 gas_assert (!fixP
->fx_done
);
20796 if (!seg
->use_rela_p
)
20799 bfd_vma addend_abs
= abs (value
);
20801 /* Check that the absolute value of the addend is a multiple of
20802 four and, when divided by four, fits in 8 bits. */
20803 if (addend_abs
& 0x3)
20804 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20805 _("bad offset 0x%08lX (must be word-aligned)"),
20806 (unsigned long) addend_abs
);
20808 if ((addend_abs
>> 2) > 0xff)
20809 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20810 _("bad offset 0x%08lX (must be an 8-bit number of words)"),
20811 (unsigned long) addend_abs
);
20813 /* Extract the instruction. */
20814 insn
= md_chars_to_number (buf
, INSN_SIZE
);
20816 /* If the addend is negative, clear bit 23 of the instruction.
20817 Otherwise set it. */
20819 insn
&= ~(1 << 23);
20823 /* Place the addend (divided by four) into the first eight
20824 bits of the instruction. */
20825 insn
&= 0xfffffff0;
20826 insn
|= addend_abs
>> 2;
20828 /* Update the instruction. */
20829 md_number_to_chars (buf
, insn
, INSN_SIZE
);
20833 case BFD_RELOC_ARM_V4BX
:
20834 /* This will need to go in the object file. */
20838 case BFD_RELOC_UNUSED
:
20840 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
20841 _("bad relocation fixup type (%d)"), fixP
->fx_r_type
);
20845 /* Translate internal representation of relocation info to BFD target
20849 tc_gen_reloc (asection
*section
, fixS
*fixp
)
20852 bfd_reloc_code_real_type code
;
20854 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
20856 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
20857 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
20858 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
20860 if (fixp
->fx_pcrel
)
20862 if (section
->use_rela_p
)
20863 fixp
->fx_offset
-= md_pcrel_from_section (fixp
, section
);
20865 fixp
->fx_offset
= reloc
->address
;
20867 reloc
->addend
= fixp
->fx_offset
;
20869 switch (fixp
->fx_r_type
)
20872 if (fixp
->fx_pcrel
)
20874 code
= BFD_RELOC_8_PCREL
;
20879 if (fixp
->fx_pcrel
)
20881 code
= BFD_RELOC_16_PCREL
;
20886 if (fixp
->fx_pcrel
)
20888 code
= BFD_RELOC_32_PCREL
;
20892 case BFD_RELOC_ARM_MOVW
:
20893 if (fixp
->fx_pcrel
)
20895 code
= BFD_RELOC_ARM_MOVW_PCREL
;
20899 case BFD_RELOC_ARM_MOVT
:
20900 if (fixp
->fx_pcrel
)
20902 code
= BFD_RELOC_ARM_MOVT_PCREL
;
20906 case BFD_RELOC_ARM_THUMB_MOVW
:
20907 if (fixp
->fx_pcrel
)
20909 code
= BFD_RELOC_ARM_THUMB_MOVW_PCREL
;
20913 case BFD_RELOC_ARM_THUMB_MOVT
:
20914 if (fixp
->fx_pcrel
)
20916 code
= BFD_RELOC_ARM_THUMB_MOVT_PCREL
;
20920 case BFD_RELOC_NONE
:
20921 case BFD_RELOC_ARM_PCREL_BRANCH
:
20922 case BFD_RELOC_ARM_PCREL_BLX
:
20923 case BFD_RELOC_RVA
:
20924 case BFD_RELOC_THUMB_PCREL_BRANCH7
:
20925 case BFD_RELOC_THUMB_PCREL_BRANCH9
:
20926 case BFD_RELOC_THUMB_PCREL_BRANCH12
:
20927 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
20928 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
20929 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
20930 case BFD_RELOC_VTABLE_ENTRY
:
20931 case BFD_RELOC_VTABLE_INHERIT
:
20933 case BFD_RELOC_32_SECREL
:
20935 code
= fixp
->fx_r_type
;
20938 case BFD_RELOC_THUMB_PCREL_BLX
:
20940 if (EF_ARM_EABI_VERSION (meabi_flags
) >= EF_ARM_EABI_VER4
)
20941 code
= BFD_RELOC_THUMB_PCREL_BRANCH23
;
20944 code
= BFD_RELOC_THUMB_PCREL_BLX
;
20947 case BFD_RELOC_ARM_LITERAL
:
20948 case BFD_RELOC_ARM_HWLITERAL
:
20949 /* If this is called then the a literal has
20950 been referenced across a section boundary. */
20951 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
20952 _("literal referenced across section boundary"));
20956 case BFD_RELOC_ARM_GOT32
:
20957 case BFD_RELOC_ARM_GOTOFF
:
20958 case BFD_RELOC_ARM_PLT32
:
20959 case BFD_RELOC_ARM_TARGET1
:
20960 case BFD_RELOC_ARM_ROSEGREL32
:
20961 case BFD_RELOC_ARM_SBREL32
:
20962 case BFD_RELOC_ARM_PREL31
:
20963 case BFD_RELOC_ARM_TARGET2
:
20964 case BFD_RELOC_ARM_TLS_LE32
:
20965 case BFD_RELOC_ARM_TLS_LDO32
:
20966 case BFD_RELOC_ARM_PCREL_CALL
:
20967 case BFD_RELOC_ARM_PCREL_JUMP
:
20968 case BFD_RELOC_ARM_ALU_PC_G0_NC
:
20969 case BFD_RELOC_ARM_ALU_PC_G0
:
20970 case BFD_RELOC_ARM_ALU_PC_G1_NC
:
20971 case BFD_RELOC_ARM_ALU_PC_G1
:
20972 case BFD_RELOC_ARM_ALU_PC_G2
:
20973 case BFD_RELOC_ARM_LDR_PC_G0
:
20974 case BFD_RELOC_ARM_LDR_PC_G1
:
20975 case BFD_RELOC_ARM_LDR_PC_G2
:
20976 case BFD_RELOC_ARM_LDRS_PC_G0
:
20977 case BFD_RELOC_ARM_LDRS_PC_G1
:
20978 case BFD_RELOC_ARM_LDRS_PC_G2
:
20979 case BFD_RELOC_ARM_LDC_PC_G0
:
20980 case BFD_RELOC_ARM_LDC_PC_G1
:
20981 case BFD_RELOC_ARM_LDC_PC_G2
:
20982 case BFD_RELOC_ARM_ALU_SB_G0_NC
:
20983 case BFD_RELOC_ARM_ALU_SB_G0
:
20984 case BFD_RELOC_ARM_ALU_SB_G1_NC
:
20985 case BFD_RELOC_ARM_ALU_SB_G1
:
20986 case BFD_RELOC_ARM_ALU_SB_G2
:
20987 case BFD_RELOC_ARM_LDR_SB_G0
:
20988 case BFD_RELOC_ARM_LDR_SB_G1
:
20989 case BFD_RELOC_ARM_LDR_SB_G2
:
20990 case BFD_RELOC_ARM_LDRS_SB_G0
:
20991 case BFD_RELOC_ARM_LDRS_SB_G1
:
20992 case BFD_RELOC_ARM_LDRS_SB_G2
:
20993 case BFD_RELOC_ARM_LDC_SB_G0
:
20994 case BFD_RELOC_ARM_LDC_SB_G1
:
20995 case BFD_RELOC_ARM_LDC_SB_G2
:
20996 case BFD_RELOC_ARM_V4BX
:
20997 code
= fixp
->fx_r_type
;
21000 case BFD_RELOC_ARM_TLS_GD32
:
21001 case BFD_RELOC_ARM_TLS_IE32
:
21002 case BFD_RELOC_ARM_TLS_LDM32
:
21003 /* BFD will include the symbol's address in the addend.
21004 But we don't want that, so subtract it out again here. */
21005 if (!S_IS_COMMON (fixp
->fx_addsy
))
21006 reloc
->addend
-= (*reloc
->sym_ptr_ptr
)->value
;
21007 code
= fixp
->fx_r_type
;
21011 case BFD_RELOC_ARM_IMMEDIATE
:
21012 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
21013 _("internal relocation (type: IMMEDIATE) not fixed up"));
21016 case BFD_RELOC_ARM_ADRL_IMMEDIATE
:
21017 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
21018 _("ADRL used for a symbol not defined in the same file"));
21021 case BFD_RELOC_ARM_OFFSET_IMM
:
21022 if (section
->use_rela_p
)
21024 code
= fixp
->fx_r_type
;
21028 if (fixp
->fx_addsy
!= NULL
21029 && !S_IS_DEFINED (fixp
->fx_addsy
)
21030 && S_IS_LOCAL (fixp
->fx_addsy
))
21032 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
21033 _("undefined local label `%s'"),
21034 S_GET_NAME (fixp
->fx_addsy
));
21038 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
21039 _("internal_relocation (type: OFFSET_IMM) not fixed up"));
21046 switch (fixp
->fx_r_type
)
21048 case BFD_RELOC_NONE
: type
= "NONE"; break;
21049 case BFD_RELOC_ARM_OFFSET_IMM8
: type
= "OFFSET_IMM8"; break;
21050 case BFD_RELOC_ARM_SHIFT_IMM
: type
= "SHIFT_IMM"; break;
21051 case BFD_RELOC_ARM_SMC
: type
= "SMC"; break;
21052 case BFD_RELOC_ARM_SWI
: type
= "SWI"; break;
21053 case BFD_RELOC_ARM_MULTI
: type
= "MULTI"; break;
21054 case BFD_RELOC_ARM_CP_OFF_IMM
: type
= "CP_OFF_IMM"; break;
21055 case BFD_RELOC_ARM_T32_CP_OFF_IMM
: type
= "T32_CP_OFF_IMM"; break;
21056 case BFD_RELOC_ARM_THUMB_ADD
: type
= "THUMB_ADD"; break;
21057 case BFD_RELOC_ARM_THUMB_SHIFT
: type
= "THUMB_SHIFT"; break;
21058 case BFD_RELOC_ARM_THUMB_IMM
: type
= "THUMB_IMM"; break;
21059 case BFD_RELOC_ARM_THUMB_OFFSET
: type
= "THUMB_OFFSET"; break;
21060 default: type
= _("<unknown>"); break;
21062 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
21063 _("cannot represent %s relocation in this object file format"),
21070 if ((code
== BFD_RELOC_32_PCREL
|| code
== BFD_RELOC_32
)
21072 && fixp
->fx_addsy
== GOT_symbol
)
21074 code
= BFD_RELOC_ARM_GOTPC
;
21075 reloc
->addend
= fixp
->fx_offset
= reloc
->address
;
21079 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
21081 if (reloc
->howto
== NULL
)
21083 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
21084 _("cannot represent %s relocation in this object file format"),
21085 bfd_get_reloc_code_name (code
));
21089 /* HACK: Since arm ELF uses Rel instead of Rela, encode the
21090 vtable entry to be used in the relocation's section offset. */
21091 if (fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
21092 reloc
->address
= fixp
->fx_offset
;
21097 /* This fix_new is called by cons via TC_CONS_FIX_NEW. */
21100 cons_fix_new_arm (fragS
* frag
,
21105 bfd_reloc_code_real_type type
;
21109 FIXME: @@ Should look at CPU word size. */
21113 type
= BFD_RELOC_8
;
21116 type
= BFD_RELOC_16
;
21120 type
= BFD_RELOC_32
;
21123 type
= BFD_RELOC_64
;
21128 if (exp
->X_op
== O_secrel
)
21130 exp
->X_op
= O_symbol
;
21131 type
= BFD_RELOC_32_SECREL
;
21135 fix_new_exp (frag
, where
, (int) size
, exp
, pcrel
, type
);
21138 #if defined (OBJ_COFF)
21140 arm_validate_fix (fixS
* fixP
)
21142 /* If the destination of the branch is a defined symbol which does not have
21143 the THUMB_FUNC attribute, then we must be calling a function which has
21144 the (interfacearm) attribute. We look for the Thumb entry point to that
21145 function and change the branch to refer to that function instead. */
21146 if (fixP
->fx_r_type
== BFD_RELOC_THUMB_PCREL_BRANCH23
21147 && fixP
->fx_addsy
!= NULL
21148 && S_IS_DEFINED (fixP
->fx_addsy
)
21149 && ! THUMB_IS_FUNC (fixP
->fx_addsy
))
21151 fixP
->fx_addsy
= find_real_start (fixP
->fx_addsy
);
21158 arm_force_relocation (struct fix
* fixp
)
21160 #if defined (OBJ_COFF) && defined (TE_PE)
21161 if (fixp
->fx_r_type
== BFD_RELOC_RVA
)
21165 /* In case we have a call or a branch to a function in ARM ISA mode from
21166 a thumb function or vice-versa force the relocation. These relocations
21167 are cleared off for some cores that might have blx and simple transformations
21171 switch (fixp
->fx_r_type
)
21173 case BFD_RELOC_ARM_PCREL_JUMP
:
21174 case BFD_RELOC_ARM_PCREL_CALL
:
21175 case BFD_RELOC_THUMB_PCREL_BLX
:
21176 if (THUMB_IS_FUNC (fixp
->fx_addsy
))
21180 case BFD_RELOC_ARM_PCREL_BLX
:
21181 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
21182 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
21183 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
21184 if (ARM_IS_FUNC (fixp
->fx_addsy
))
21193 /* Resolve these relocations even if the symbol is extern or weak. */
21194 if (fixp
->fx_r_type
== BFD_RELOC_ARM_IMMEDIATE
21195 || fixp
->fx_r_type
== BFD_RELOC_ARM_OFFSET_IMM
21196 || fixp
->fx_r_type
== BFD_RELOC_ARM_ADRL_IMMEDIATE
21197 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_ADD_IMM
21198 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_IMMEDIATE
21199 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_IMM12
21200 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_ADD_PC12
)
21203 /* Always leave these relocations for the linker. */
21204 if ((fixp
->fx_r_type
>= BFD_RELOC_ARM_ALU_PC_G0_NC
21205 && fixp
->fx_r_type
<= BFD_RELOC_ARM_LDC_SB_G2
)
21206 || fixp
->fx_r_type
== BFD_RELOC_ARM_LDR_PC_G0
)
21209 /* Always generate relocations against function symbols. */
21210 if (fixp
->fx_r_type
== BFD_RELOC_32
21212 && (symbol_get_bfdsym (fixp
->fx_addsy
)->flags
& BSF_FUNCTION
))
21215 return generic_force_reloc (fixp
);
21218 #if defined (OBJ_ELF) || defined (OBJ_COFF)
21219 /* Relocations against function names must be left unadjusted,
21220 so that the linker can use this information to generate interworking
21221 stubs. The MIPS version of this function
21222 also prevents relocations that are mips-16 specific, but I do not
21223 know why it does this.
21226 There is one other problem that ought to be addressed here, but
21227 which currently is not: Taking the address of a label (rather
21228 than a function) and then later jumping to that address. Such
21229 addresses also ought to have their bottom bit set (assuming that
21230 they reside in Thumb code), but at the moment they will not. */
21233 arm_fix_adjustable (fixS
* fixP
)
21235 if (fixP
->fx_addsy
== NULL
)
21238 /* Preserve relocations against symbols with function type. */
21239 if (symbol_get_bfdsym (fixP
->fx_addsy
)->flags
& BSF_FUNCTION
)
21242 if (THUMB_IS_FUNC (fixP
->fx_addsy
)
21243 && fixP
->fx_subsy
== NULL
)
21246 /* We need the symbol name for the VTABLE entries. */
21247 if ( fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
21248 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
21251 /* Don't allow symbols to be discarded on GOT related relocs. */
21252 if (fixP
->fx_r_type
== BFD_RELOC_ARM_PLT32
21253 || fixP
->fx_r_type
== BFD_RELOC_ARM_GOT32
21254 || fixP
->fx_r_type
== BFD_RELOC_ARM_GOTOFF
21255 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_GD32
21256 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_LE32
21257 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_IE32
21258 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_LDM32
21259 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_LDO32
21260 || fixP
->fx_r_type
== BFD_RELOC_ARM_TARGET2
)
21263 /* Similarly for group relocations. */
21264 if ((fixP
->fx_r_type
>= BFD_RELOC_ARM_ALU_PC_G0_NC
21265 && fixP
->fx_r_type
<= BFD_RELOC_ARM_LDC_SB_G2
)
21266 || fixP
->fx_r_type
== BFD_RELOC_ARM_LDR_PC_G0
)
21269 /* MOVW/MOVT REL relocations have limited offsets, so keep the symbols. */
21270 if (fixP
->fx_r_type
== BFD_RELOC_ARM_MOVW
21271 || fixP
->fx_r_type
== BFD_RELOC_ARM_MOVT
21272 || fixP
->fx_r_type
== BFD_RELOC_ARM_MOVW_PCREL
21273 || fixP
->fx_r_type
== BFD_RELOC_ARM_MOVT_PCREL
21274 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVW
21275 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVT
21276 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVW_PCREL
21277 || fixP
->fx_r_type
== BFD_RELOC_ARM_THUMB_MOVT_PCREL
)
21282 #endif /* defined (OBJ_ELF) || defined (OBJ_COFF) */
21287 elf32_arm_target_format (void)
21290 return (target_big_endian
21291 ? "elf32-bigarm-symbian"
21292 : "elf32-littlearm-symbian");
21293 #elif defined (TE_VXWORKS)
21294 return (target_big_endian
21295 ? "elf32-bigarm-vxworks"
21296 : "elf32-littlearm-vxworks");
21298 if (target_big_endian
)
21299 return "elf32-bigarm";
21301 return "elf32-littlearm";
21306 armelf_frob_symbol (symbolS
* symp
,
21309 elf_frob_symbol (symp
, puntp
);
21313 /* MD interface: Finalization. */
21318 literal_pool
* pool
;
21320 /* Ensure that all the IT blocks are properly closed. */
21321 check_it_blocks_finished ();
21323 for (pool
= list_of_pools
; pool
; pool
= pool
->next
)
21325 /* Put it at the end of the relevant section. */
21326 subseg_set (pool
->section
, pool
->sub_section
);
21328 arm_elf_change_section ();
21335 /* Remove any excess mapping symbols generated for alignment frags in
21336 SEC. We may have created a mapping symbol before a zero byte
21337 alignment; remove it if there's a mapping symbol after the
21340 check_mapping_symbols (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
21341 void *dummy ATTRIBUTE_UNUSED
)
21343 segment_info_type
*seginfo
= seg_info (sec
);
21346 if (seginfo
== NULL
|| seginfo
->frchainP
== NULL
)
21349 for (fragp
= seginfo
->frchainP
->frch_root
;
21351 fragp
= fragp
->fr_next
)
21353 symbolS
*sym
= fragp
->tc_frag_data
.last_map
;
21354 fragS
*next
= fragp
->fr_next
;
21356 /* Variable-sized frags have been converted to fixed size by
21357 this point. But if this was variable-sized to start with,
21358 there will be a fixed-size frag after it. So don't handle
21360 if (sym
== NULL
|| next
== NULL
)
21363 if (S_GET_VALUE (sym
) < next
->fr_address
)
21364 /* Not at the end of this frag. */
21366 know (S_GET_VALUE (sym
) == next
->fr_address
);
21370 if (next
->tc_frag_data
.first_map
!= NULL
)
21372 /* Next frag starts with a mapping symbol. Discard this
21374 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
21378 if (next
->fr_next
== NULL
)
21380 /* This mapping symbol is at the end of the section. Discard
21382 know (next
->fr_fix
== 0 && next
->fr_var
== 0);
21383 symbol_remove (sym
, &symbol_rootP
, &symbol_lastP
);
21387 /* As long as we have empty frags without any mapping symbols,
21389 /* If the next frag is non-empty and does not start with a
21390 mapping symbol, then this mapping symbol is required. */
21391 if (next
->fr_address
!= next
->fr_next
->fr_address
)
21394 next
= next
->fr_next
;
21396 while (next
!= NULL
);
21401 /* Adjust the symbol table. This marks Thumb symbols as distinct from
21405 arm_adjust_symtab (void)
21410 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
21412 if (ARM_IS_THUMB (sym
))
21414 if (THUMB_IS_FUNC (sym
))
21416 /* Mark the symbol as a Thumb function. */
21417 if ( S_GET_STORAGE_CLASS (sym
) == C_STAT
21418 || S_GET_STORAGE_CLASS (sym
) == C_LABEL
) /* This can happen! */
21419 S_SET_STORAGE_CLASS (sym
, C_THUMBSTATFUNC
);
21421 else if (S_GET_STORAGE_CLASS (sym
) == C_EXT
)
21422 S_SET_STORAGE_CLASS (sym
, C_THUMBEXTFUNC
);
21424 as_bad (_("%s: unexpected function type: %d"),
21425 S_GET_NAME (sym
), S_GET_STORAGE_CLASS (sym
));
21427 else switch (S_GET_STORAGE_CLASS (sym
))
21430 S_SET_STORAGE_CLASS (sym
, C_THUMBEXT
);
21433 S_SET_STORAGE_CLASS (sym
, C_THUMBSTAT
);
21436 S_SET_STORAGE_CLASS (sym
, C_THUMBLABEL
);
21444 if (ARM_IS_INTERWORK (sym
))
21445 coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_flags
= 0xFF;
21452 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
21454 if (ARM_IS_THUMB (sym
))
21456 elf_symbol_type
* elf_sym
;
21458 elf_sym
= elf_symbol (symbol_get_bfdsym (sym
));
21459 bind
= ELF_ST_BIND (elf_sym
->internal_elf_sym
.st_info
);
21461 if (! bfd_is_arm_special_symbol_name (elf_sym
->symbol
.name
,
21462 BFD_ARM_SPECIAL_SYM_TYPE_ANY
))
21464 /* If it's a .thumb_func, declare it as so,
21465 otherwise tag label as .code 16. */
21466 if (THUMB_IS_FUNC (sym
))
21467 elf_sym
->internal_elf_sym
.st_info
=
21468 ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
21469 else if (EF_ARM_EABI_VERSION (meabi_flags
) < EF_ARM_EABI_VER4
)
21470 elf_sym
->internal_elf_sym
.st_info
=
21471 ELF_ST_INFO (bind
, STT_ARM_16BIT
);
21476 /* Remove any overlapping mapping symbols generated by alignment frags. */
21477 bfd_map_over_sections (stdoutput
, check_mapping_symbols
, (char *) 0);
21481 /* MD interface: Initialization. */
21484 set_constant_flonums (void)
21488 for (i
= 0; i
< NUM_FLOAT_VALS
; i
++)
21489 if (atof_ieee ((char *) fp_const
[i
], 'x', fp_values
[i
]) == NULL
)
21493 /* Auto-select Thumb mode if it's the only available instruction set for the
21494 given architecture. */
21497 autoselect_thumb_from_cpu_variant (void)
21499 if (!ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v1
))
21500 opcode_select (16);
21509 if ( (arm_ops_hsh
= hash_new ()) == NULL
21510 || (arm_cond_hsh
= hash_new ()) == NULL
21511 || (arm_shift_hsh
= hash_new ()) == NULL
21512 || (arm_psr_hsh
= hash_new ()) == NULL
21513 || (arm_v7m_psr_hsh
= hash_new ()) == NULL
21514 || (arm_reg_hsh
= hash_new ()) == NULL
21515 || (arm_reloc_hsh
= hash_new ()) == NULL
21516 || (arm_barrier_opt_hsh
= hash_new ()) == NULL
)
21517 as_fatal (_("virtual memory exhausted"));
21519 for (i
= 0; i
< sizeof (insns
) / sizeof (struct asm_opcode
); i
++)
21520 hash_insert (arm_ops_hsh
, insns
[i
].template_name
, (void *) (insns
+ i
));
21521 for (i
= 0; i
< sizeof (conds
) / sizeof (struct asm_cond
); i
++)
21522 hash_insert (arm_cond_hsh
, conds
[i
].template_name
, (void *) (conds
+ i
));
21523 for (i
= 0; i
< sizeof (shift_names
) / sizeof (struct asm_shift_name
); i
++)
21524 hash_insert (arm_shift_hsh
, shift_names
[i
].name
, (void *) (shift_names
+ i
));
21525 for (i
= 0; i
< sizeof (psrs
) / sizeof (struct asm_psr
); i
++)
21526 hash_insert (arm_psr_hsh
, psrs
[i
].template_name
, (void *) (psrs
+ i
));
21527 for (i
= 0; i
< sizeof (v7m_psrs
) / sizeof (struct asm_psr
); i
++)
21528 hash_insert (arm_v7m_psr_hsh
, v7m_psrs
[i
].template_name
,
21529 (void *) (v7m_psrs
+ i
));
21530 for (i
= 0; i
< sizeof (reg_names
) / sizeof (struct reg_entry
); i
++)
21531 hash_insert (arm_reg_hsh
, reg_names
[i
].name
, (void *) (reg_names
+ i
));
21533 i
< sizeof (barrier_opt_names
) / sizeof (struct asm_barrier_opt
);
21535 hash_insert (arm_barrier_opt_hsh
, barrier_opt_names
[i
].template_name
,
21536 (void *) (barrier_opt_names
+ i
));
21538 for (i
= 0; i
< sizeof (reloc_names
) / sizeof (struct reloc_entry
); i
++)
21539 hash_insert (arm_reloc_hsh
, reloc_names
[i
].name
, (void *) (reloc_names
+ i
));
21542 set_constant_flonums ();
21544 /* Set the cpu variant based on the command-line options. We prefer
21545 -mcpu= over -march= if both are set (as for GCC); and we prefer
21546 -mfpu= over any other way of setting the floating point unit.
21547 Use of legacy options with new options are faulted. */
21550 if (mcpu_cpu_opt
|| march_cpu_opt
)
21551 as_bad (_("use of old and new-style options to set CPU type"));
21553 mcpu_cpu_opt
= legacy_cpu
;
21555 else if (!mcpu_cpu_opt
)
21556 mcpu_cpu_opt
= march_cpu_opt
;
21561 as_bad (_("use of old and new-style options to set FPU type"));
21563 mfpu_opt
= legacy_fpu
;
21565 else if (!mfpu_opt
)
21567 #if !(defined (EABI_DEFAULT) || defined (TE_LINUX) \
21568 || defined (TE_NetBSD) || defined (TE_VXWORKS))
21569 /* Some environments specify a default FPU. If they don't, infer it
21570 from the processor. */
21572 mfpu_opt
= mcpu_fpu_opt
;
21574 mfpu_opt
= march_fpu_opt
;
21576 mfpu_opt
= &fpu_default
;
21582 if (mcpu_cpu_opt
!= NULL
)
21583 mfpu_opt
= &fpu_default
;
21584 else if (mcpu_fpu_opt
!= NULL
&& ARM_CPU_HAS_FEATURE (*mcpu_fpu_opt
, arm_ext_v5
))
21585 mfpu_opt
= &fpu_arch_vfp_v2
;
21587 mfpu_opt
= &fpu_arch_fpa
;
21593 mcpu_cpu_opt
= &cpu_default
;
21594 selected_cpu
= cpu_default
;
21598 selected_cpu
= *mcpu_cpu_opt
;
21600 mcpu_cpu_opt
= &arm_arch_any
;
21603 ARM_MERGE_FEATURE_SETS (cpu_variant
, *mcpu_cpu_opt
, *mfpu_opt
);
21605 autoselect_thumb_from_cpu_variant ();
21607 arm_arch_used
= thumb_arch_used
= arm_arch_none
;
21609 #if defined OBJ_COFF || defined OBJ_ELF
21611 unsigned int flags
= 0;
21613 #if defined OBJ_ELF
21614 flags
= meabi_flags
;
21616 switch (meabi_flags
)
21618 case EF_ARM_EABI_UNKNOWN
:
21620 /* Set the flags in the private structure. */
21621 if (uses_apcs_26
) flags
|= F_APCS26
;
21622 if (support_interwork
) flags
|= F_INTERWORK
;
21623 if (uses_apcs_float
) flags
|= F_APCS_FLOAT
;
21624 if (pic_code
) flags
|= F_PIC
;
21625 if (!ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_any_hard
))
21626 flags
|= F_SOFT_FLOAT
;
21628 switch (mfloat_abi_opt
)
21630 case ARM_FLOAT_ABI_SOFT
:
21631 case ARM_FLOAT_ABI_SOFTFP
:
21632 flags
|= F_SOFT_FLOAT
;
21635 case ARM_FLOAT_ABI_HARD
:
21636 if (flags
& F_SOFT_FLOAT
)
21637 as_bad (_("hard-float conflicts with specified fpu"));
21641 /* Using pure-endian doubles (even if soft-float). */
21642 if (ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_endian_pure
))
21643 flags
|= F_VFP_FLOAT
;
21645 #if defined OBJ_ELF
21646 if (ARM_CPU_HAS_FEATURE (cpu_variant
, fpu_arch_maverick
))
21647 flags
|= EF_ARM_MAVERICK_FLOAT
;
21650 case EF_ARM_EABI_VER4
:
21651 case EF_ARM_EABI_VER5
:
21652 /* No additional flags to set. */
21659 bfd_set_private_flags (stdoutput
, flags
);
21661 /* We have run out flags in the COFF header to encode the
21662 status of ATPCS support, so instead we create a dummy,
21663 empty, debug section called .arm.atpcs. */
21668 sec
= bfd_make_section (stdoutput
, ".arm.atpcs");
21672 bfd_set_section_flags
21673 (stdoutput
, sec
, SEC_READONLY
| SEC_DEBUGGING
/* | SEC_HAS_CONTENTS */);
21674 bfd_set_section_size (stdoutput
, sec
, 0);
21675 bfd_set_section_contents (stdoutput
, sec
, NULL
, 0, 0);
21681 /* Record the CPU type as well. */
21682 if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_cext_iwmmxt2
))
21683 mach
= bfd_mach_arm_iWMMXt2
;
21684 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_cext_iwmmxt
))
21685 mach
= bfd_mach_arm_iWMMXt
;
21686 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_cext_xscale
))
21687 mach
= bfd_mach_arm_XScale
;
21688 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_cext_maverick
))
21689 mach
= bfd_mach_arm_ep9312
;
21690 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v5e
))
21691 mach
= bfd_mach_arm_5TE
;
21692 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v5
))
21694 if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v4t
))
21695 mach
= bfd_mach_arm_5T
;
21697 mach
= bfd_mach_arm_5
;
21699 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v4
))
21701 if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v4t
))
21702 mach
= bfd_mach_arm_4T
;
21704 mach
= bfd_mach_arm_4
;
21706 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v3m
))
21707 mach
= bfd_mach_arm_3M
;
21708 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v3
))
21709 mach
= bfd_mach_arm_3
;
21710 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v2s
))
21711 mach
= bfd_mach_arm_2a
;
21712 else if (ARM_CPU_HAS_FEATURE (cpu_variant
, arm_ext_v2
))
21713 mach
= bfd_mach_arm_2
;
21715 mach
= bfd_mach_arm_unknown
;
21717 bfd_set_arch_mach (stdoutput
, TARGET_ARCH
, mach
);
21720 /* Command line processing. */
21723 Invocation line includes a switch not recognized by the base assembler.
21724 See if it's a processor-specific option.
21726 This routine is somewhat complicated by the need for backwards
21727 compatibility (since older releases of gcc can't be changed).
21728 The new options try to make the interface as compatible as
21731 New options (supported) are:
21733 -mcpu=<cpu name> Assemble for selected processor
21734 -march=<architecture name> Assemble for selected architecture
21735 -mfpu=<fpu architecture> Assemble for selected FPU.
21736 -EB/-mbig-endian Big-endian
21737 -EL/-mlittle-endian Little-endian
21738 -k Generate PIC code
21739 -mthumb Start in Thumb mode
21740 -mthumb-interwork Code supports ARM/Thumb interworking
21742 -m[no-]warn-deprecated Warn about deprecated features
21744 For now we will also provide support for:
21746 -mapcs-32 32-bit Program counter
21747 -mapcs-26 26-bit Program counter
21748 -macps-float Floats passed in FP registers
21749 -mapcs-reentrant Reentrant code
21751 (sometime these will probably be replaced with -mapcs=<list of options>
21752 and -matpcs=<list of options>)
21754 The remaining options are only supported for back-wards compatibility.
21755 Cpu variants, the arm part is optional:
21756 -m[arm]1 Currently not supported.
21757 -m[arm]2, -m[arm]250 Arm 2 and Arm 250 processor
21758 -m[arm]3 Arm 3 processor
21759 -m[arm]6[xx], Arm 6 processors
21760 -m[arm]7[xx][t][[d]m] Arm 7 processors
21761 -m[arm]8[10] Arm 8 processors
21762 -m[arm]9[20][tdmi] Arm 9 processors
21763 -mstrongarm[110[0]] StrongARM processors
21764 -mxscale XScale processors
21765 -m[arm]v[2345[t[e]]] Arm architectures
21766 -mall All (except the ARM1)
21768 -mfpa10, -mfpa11 FPA10 and 11 co-processor instructions
21769 -mfpe-old (No float load/store multiples)
21770 -mvfpxd VFP Single precision
21772 -mno-fpu Disable all floating point instructions
21774 The following CPU names are recognized:
21775 arm1, arm2, arm250, arm3, arm6, arm600, arm610, arm620,
21776 arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700,
21777 arm700i, arm710 arm710t, arm720, arm720t, arm740t, arm710c,
21778 arm7100, arm7500, arm7500fe, arm7tdmi, arm8, arm810, arm9,
21779 arm920, arm920t, arm940t, arm946, arm966, arm9tdmi, arm9e,
21780 arm10t arm10e, arm1020t, arm1020e, arm10200e,
21781 strongarm, strongarm110, strongarm1100, strongarm1110, xscale.
21785 const char * md_shortopts
= "m:k";
21787 #ifdef ARM_BI_ENDIAN
21788 #define OPTION_EB (OPTION_MD_BASE + 0)
21789 #define OPTION_EL (OPTION_MD_BASE + 1)
21791 #if TARGET_BYTES_BIG_ENDIAN
21792 #define OPTION_EB (OPTION_MD_BASE + 0)
21794 #define OPTION_EL (OPTION_MD_BASE + 1)
21797 #define OPTION_FIX_V4BX (OPTION_MD_BASE + 2)
21799 struct option md_longopts
[] =
21802 {"EB", no_argument
, NULL
, OPTION_EB
},
21805 {"EL", no_argument
, NULL
, OPTION_EL
},
21807 {"fix-v4bx", no_argument
, NULL
, OPTION_FIX_V4BX
},
21808 {NULL
, no_argument
, NULL
, 0}
21811 size_t md_longopts_size
= sizeof (md_longopts
);
21813 struct arm_option_table
21815 char *option
; /* Option name to match. */
21816 char *help
; /* Help information. */
21817 int *var
; /* Variable to change. */
21818 int value
; /* What to change it to. */
21819 char *deprecated
; /* If non-null, print this message. */
21822 struct arm_option_table arm_opts
[] =
21824 {"k", N_("generate PIC code"), &pic_code
, 1, NULL
},
21825 {"mthumb", N_("assemble Thumb code"), &thumb_mode
, 1, NULL
},
21826 {"mthumb-interwork", N_("support ARM/Thumb interworking"),
21827 &support_interwork
, 1, NULL
},
21828 {"mapcs-32", N_("code uses 32-bit program counter"), &uses_apcs_26
, 0, NULL
},
21829 {"mapcs-26", N_("code uses 26-bit program counter"), &uses_apcs_26
, 1, NULL
},
21830 {"mapcs-float", N_("floating point args are in fp regs"), &uses_apcs_float
,
21832 {"mapcs-reentrant", N_("re-entrant code"), &pic_code
, 1, NULL
},
21833 {"matpcs", N_("code is ATPCS conformant"), &atpcs
, 1, NULL
},
21834 {"mbig-endian", N_("assemble for big-endian"), &target_big_endian
, 1, NULL
},
21835 {"mlittle-endian", N_("assemble for little-endian"), &target_big_endian
, 0,
21838 /* These are recognized by the assembler, but have no affect on code. */
21839 {"mapcs-frame", N_("use frame pointer"), NULL
, 0, NULL
},
21840 {"mapcs-stack-check", N_("use stack size checking"), NULL
, 0, NULL
},
21842 {"mwarn-deprecated", NULL
, &warn_on_deprecated
, 1, NULL
},
21843 {"mno-warn-deprecated", N_("do not warn on use of deprecated feature"),
21844 &warn_on_deprecated
, 0, NULL
},
21845 {NULL
, NULL
, NULL
, 0, NULL
}
21848 struct arm_legacy_option_table
21850 char *option
; /* Option name to match. */
21851 const arm_feature_set
**var
; /* Variable to change. */
21852 const arm_feature_set value
; /* What to change it to. */
21853 char *deprecated
; /* If non-null, print this message. */
21856 const struct arm_legacy_option_table arm_legacy_opts
[] =
21858 /* DON'T add any new processors to this list -- we want the whole list
21859 to go away... Add them to the processors table instead. */
21860 {"marm1", &legacy_cpu
, ARM_ARCH_V1
, N_("use -mcpu=arm1")},
21861 {"m1", &legacy_cpu
, ARM_ARCH_V1
, N_("use -mcpu=arm1")},
21862 {"marm2", &legacy_cpu
, ARM_ARCH_V2
, N_("use -mcpu=arm2")},
21863 {"m2", &legacy_cpu
, ARM_ARCH_V2
, N_("use -mcpu=arm2")},
21864 {"marm250", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm250")},
21865 {"m250", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm250")},
21866 {"marm3", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm3")},
21867 {"m3", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm3")},
21868 {"marm6", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm6")},
21869 {"m6", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm6")},
21870 {"marm600", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm600")},
21871 {"m600", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm600")},
21872 {"marm610", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm610")},
21873 {"m610", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm610")},
21874 {"marm620", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm620")},
21875 {"m620", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm620")},
21876 {"marm7", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7")},
21877 {"m7", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7")},
21878 {"marm70", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm70")},
21879 {"m70", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm70")},
21880 {"marm700", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700")},
21881 {"m700", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700")},
21882 {"marm700i", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700i")},
21883 {"m700i", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700i")},
21884 {"marm710", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710")},
21885 {"m710", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710")},
21886 {"marm710c", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710c")},
21887 {"m710c", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710c")},
21888 {"marm720", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm720")},
21889 {"m720", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm720")},
21890 {"marm7d", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7d")},
21891 {"m7d", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7d")},
21892 {"marm7di", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7di")},
21893 {"m7di", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7di")},
21894 {"marm7m", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7m")},
21895 {"m7m", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7m")},
21896 {"marm7dm", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dm")},
21897 {"m7dm", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dm")},
21898 {"marm7dmi", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dmi")},
21899 {"m7dmi", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dmi")},
21900 {"marm7100", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7100")},
21901 {"m7100", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7100")},
21902 {"marm7500", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500")},
21903 {"m7500", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500")},
21904 {"marm7500fe", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500fe")},
21905 {"m7500fe", &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500fe")},
21906 {"marm7t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
21907 {"m7t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
21908 {"marm7tdmi", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
21909 {"m7tdmi", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
21910 {"marm710t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm710t")},
21911 {"m710t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm710t")},
21912 {"marm720t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm720t")},
21913 {"m720t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm720t")},
21914 {"marm740t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm740t")},
21915 {"m740t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm740t")},
21916 {"marm8", &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm8")},
21917 {"m8", &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm8")},
21918 {"marm810", &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm810")},
21919 {"m810", &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm810")},
21920 {"marm9", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9")},
21921 {"m9", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9")},
21922 {"marm9tdmi", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9tdmi")},
21923 {"m9tdmi", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9tdmi")},
21924 {"marm920", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm920")},
21925 {"m920", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm920")},
21926 {"marm940", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm940")},
21927 {"m940", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm940")},
21928 {"mstrongarm", &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=strongarm")},
21929 {"mstrongarm110", &legacy_cpu
, ARM_ARCH_V4
,
21930 N_("use -mcpu=strongarm110")},
21931 {"mstrongarm1100", &legacy_cpu
, ARM_ARCH_V4
,
21932 N_("use -mcpu=strongarm1100")},
21933 {"mstrongarm1110", &legacy_cpu
, ARM_ARCH_V4
,
21934 N_("use -mcpu=strongarm1110")},
21935 {"mxscale", &legacy_cpu
, ARM_ARCH_XSCALE
, N_("use -mcpu=xscale")},
21936 {"miwmmxt", &legacy_cpu
, ARM_ARCH_IWMMXT
, N_("use -mcpu=iwmmxt")},
21937 {"mall", &legacy_cpu
, ARM_ANY
, N_("use -mcpu=all")},
21939 /* Architecture variants -- don't add any more to this list either. */
21940 {"mv2", &legacy_cpu
, ARM_ARCH_V2
, N_("use -march=armv2")},
21941 {"marmv2", &legacy_cpu
, ARM_ARCH_V2
, N_("use -march=armv2")},
21942 {"mv2a", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -march=armv2a")},
21943 {"marmv2a", &legacy_cpu
, ARM_ARCH_V2S
, N_("use -march=armv2a")},
21944 {"mv3", &legacy_cpu
, ARM_ARCH_V3
, N_("use -march=armv3")},
21945 {"marmv3", &legacy_cpu
, ARM_ARCH_V3
, N_("use -march=armv3")},
21946 {"mv3m", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -march=armv3m")},
21947 {"marmv3m", &legacy_cpu
, ARM_ARCH_V3M
, N_("use -march=armv3m")},
21948 {"mv4", &legacy_cpu
, ARM_ARCH_V4
, N_("use -march=armv4")},
21949 {"marmv4", &legacy_cpu
, ARM_ARCH_V4
, N_("use -march=armv4")},
21950 {"mv4t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -march=armv4t")},
21951 {"marmv4t", &legacy_cpu
, ARM_ARCH_V4T
, N_("use -march=armv4t")},
21952 {"mv5", &legacy_cpu
, ARM_ARCH_V5
, N_("use -march=armv5")},
21953 {"marmv5", &legacy_cpu
, ARM_ARCH_V5
, N_("use -march=armv5")},
21954 {"mv5t", &legacy_cpu
, ARM_ARCH_V5T
, N_("use -march=armv5t")},
21955 {"marmv5t", &legacy_cpu
, ARM_ARCH_V5T
, N_("use -march=armv5t")},
21956 {"mv5e", &legacy_cpu
, ARM_ARCH_V5TE
, N_("use -march=armv5te")},
21957 {"marmv5e", &legacy_cpu
, ARM_ARCH_V5TE
, N_("use -march=armv5te")},
21959 /* Floating point variants -- don't add any more to this list either. */
21960 {"mfpe-old", &legacy_fpu
, FPU_ARCH_FPE
, N_("use -mfpu=fpe")},
21961 {"mfpa10", &legacy_fpu
, FPU_ARCH_FPA
, N_("use -mfpu=fpa10")},
21962 {"mfpa11", &legacy_fpu
, FPU_ARCH_FPA
, N_("use -mfpu=fpa11")},
21963 {"mno-fpu", &legacy_fpu
, ARM_ARCH_NONE
,
21964 N_("use either -mfpu=softfpa or -mfpu=softvfp")},
21966 {NULL
, NULL
, ARM_ARCH_NONE
, NULL
}
21969 struct arm_cpu_option_table
21972 const arm_feature_set value
;
21973 /* For some CPUs we assume an FPU unless the user explicitly sets
21975 const arm_feature_set default_fpu
;
21976 /* The canonical name of the CPU, or NULL to use NAME converted to upper
21978 const char *canonical_name
;
21981 /* This list should, at a minimum, contain all the cpu names
21982 recognized by GCC. */
21983 static const struct arm_cpu_option_table arm_cpus
[] =
21985 {"all", ARM_ANY
, FPU_ARCH_FPA
, NULL
},
21986 {"arm1", ARM_ARCH_V1
, FPU_ARCH_FPA
, NULL
},
21987 {"arm2", ARM_ARCH_V2
, FPU_ARCH_FPA
, NULL
},
21988 {"arm250", ARM_ARCH_V2S
, FPU_ARCH_FPA
, NULL
},
21989 {"arm3", ARM_ARCH_V2S
, FPU_ARCH_FPA
, NULL
},
21990 {"arm6", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21991 {"arm60", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21992 {"arm600", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21993 {"arm610", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21994 {"arm620", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21995 {"arm7", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21996 {"arm7m", ARM_ARCH_V3M
, FPU_ARCH_FPA
, NULL
},
21997 {"arm7d", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
21998 {"arm7dm", ARM_ARCH_V3M
, FPU_ARCH_FPA
, NULL
},
21999 {"arm7di", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
22000 {"arm7dmi", ARM_ARCH_V3M
, FPU_ARCH_FPA
, NULL
},
22001 {"arm70", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
22002 {"arm700", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
22003 {"arm700i", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
22004 {"arm710", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
22005 {"arm710t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22006 {"arm720", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
22007 {"arm720t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22008 {"arm740t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22009 {"arm710c", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
22010 {"arm7100", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
22011 {"arm7500", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
22012 {"arm7500fe", ARM_ARCH_V3
, FPU_ARCH_FPA
, NULL
},
22013 {"arm7t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22014 {"arm7tdmi", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22015 {"arm7tdmi-s", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22016 {"arm8", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
22017 {"arm810", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
22018 {"strongarm", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
22019 {"strongarm1", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
22020 {"strongarm110", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
22021 {"strongarm1100", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
22022 {"strongarm1110", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
22023 {"arm9", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22024 {"arm920", ARM_ARCH_V4T
, FPU_ARCH_FPA
, "ARM920T"},
22025 {"arm920t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22026 {"arm922t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22027 {"arm940t", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22028 {"arm9tdmi", ARM_ARCH_V4T
, FPU_ARCH_FPA
, NULL
},
22029 {"fa526", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
22030 {"fa626", ARM_ARCH_V4
, FPU_ARCH_FPA
, NULL
},
22031 /* For V5 or later processors we default to using VFP; but the user
22032 should really set the FPU type explicitly. */
22033 {"arm9e-r0", ARM_ARCH_V5TExP
, FPU_ARCH_VFP_V2
, NULL
},
22034 {"arm9e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22035 {"arm926ej", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
, "ARM926EJ-S"},
22036 {"arm926ejs", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
, "ARM926EJ-S"},
22037 {"arm926ej-s", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
, NULL
},
22038 {"arm946e-r0", ARM_ARCH_V5TExP
, FPU_ARCH_VFP_V2
, NULL
},
22039 {"arm946e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, "ARM946E-S"},
22040 {"arm946e-s", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22041 {"arm966e-r0", ARM_ARCH_V5TExP
, FPU_ARCH_VFP_V2
, NULL
},
22042 {"arm966e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, "ARM966E-S"},
22043 {"arm966e-s", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22044 {"arm968e-s", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22045 {"arm10t", ARM_ARCH_V5T
, FPU_ARCH_VFP_V1
, NULL
},
22046 {"arm10tdmi", ARM_ARCH_V5T
, FPU_ARCH_VFP_V1
, NULL
},
22047 {"arm10e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22048 {"arm1020", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, "ARM1020E"},
22049 {"arm1020t", ARM_ARCH_V5T
, FPU_ARCH_VFP_V1
, NULL
},
22050 {"arm1020e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22051 {"arm1022e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22052 {"arm1026ejs", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
, "ARM1026EJ-S"},
22053 {"arm1026ej-s", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
, NULL
},
22054 {"fa626te", ARM_ARCH_V5TE
, FPU_NONE
, NULL
},
22055 {"fa726te", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
, NULL
},
22056 {"arm1136js", ARM_ARCH_V6
, FPU_NONE
, "ARM1136J-S"},
22057 {"arm1136j-s", ARM_ARCH_V6
, FPU_NONE
, NULL
},
22058 {"arm1136jfs", ARM_ARCH_V6
, FPU_ARCH_VFP_V2
, "ARM1136JF-S"},
22059 {"arm1136jf-s", ARM_ARCH_V6
, FPU_ARCH_VFP_V2
, NULL
},
22060 {"mpcore", ARM_ARCH_V6K
, FPU_ARCH_VFP_V2
, NULL
},
22061 {"mpcorenovfp", ARM_ARCH_V6K
, FPU_NONE
, NULL
},
22062 {"arm1156t2-s", ARM_ARCH_V6T2
, FPU_NONE
, NULL
},
22063 {"arm1156t2f-s", ARM_ARCH_V6T2
, FPU_ARCH_VFP_V2
, NULL
},
22064 {"arm1176jz-s", ARM_ARCH_V6ZK
, FPU_NONE
, NULL
},
22065 {"arm1176jzf-s", ARM_ARCH_V6ZK
, FPU_ARCH_VFP_V2
, NULL
},
22066 {"cortex-a5", ARM_ARCH_V7A
, FPU_NONE
, NULL
},
22067 {"cortex-a8", ARM_ARCH_V7A
, ARM_FEATURE (0, FPU_VFP_V3
22068 | FPU_NEON_EXT_V1
),
22070 {"cortex-a9", ARM_ARCH_V7A
, ARM_FEATURE (0, FPU_VFP_V3
22071 | FPU_NEON_EXT_V1
),
22073 {"cortex-r4", ARM_ARCH_V7R
, FPU_NONE
, NULL
},
22074 {"cortex-r4f", ARM_ARCH_V7R
, FPU_ARCH_VFP_V3D16
, NULL
},
22075 {"cortex-m3", ARM_ARCH_V7M
, FPU_NONE
, NULL
},
22076 {"cortex-m1", ARM_ARCH_V6M
, FPU_NONE
, NULL
},
22077 {"cortex-m0", ARM_ARCH_V6M
, FPU_NONE
, NULL
},
22078 /* ??? XSCALE is really an architecture. */
22079 {"xscale", ARM_ARCH_XSCALE
, FPU_ARCH_VFP_V2
, NULL
},
22080 /* ??? iwmmxt is not a processor. */
22081 {"iwmmxt", ARM_ARCH_IWMMXT
, FPU_ARCH_VFP_V2
, NULL
},
22082 {"iwmmxt2", ARM_ARCH_IWMMXT2
,FPU_ARCH_VFP_V2
, NULL
},
22083 {"i80200", ARM_ARCH_XSCALE
, FPU_ARCH_VFP_V2
, NULL
},
22085 {"ep9312", ARM_FEATURE (ARM_AEXT_V4T
, ARM_CEXT_MAVERICK
), FPU_ARCH_MAVERICK
, "ARM920T"},
22086 {NULL
, ARM_ARCH_NONE
, ARM_ARCH_NONE
, NULL
}
22089 struct arm_arch_option_table
22092 const arm_feature_set value
;
22093 const arm_feature_set default_fpu
;
22096 /* This list should, at a minimum, contain all the architecture names
22097 recognized by GCC. */
22098 static const struct arm_arch_option_table arm_archs
[] =
22100 {"all", ARM_ANY
, FPU_ARCH_FPA
},
22101 {"armv1", ARM_ARCH_V1
, FPU_ARCH_FPA
},
22102 {"armv2", ARM_ARCH_V2
, FPU_ARCH_FPA
},
22103 {"armv2a", ARM_ARCH_V2S
, FPU_ARCH_FPA
},
22104 {"armv2s", ARM_ARCH_V2S
, FPU_ARCH_FPA
},
22105 {"armv3", ARM_ARCH_V3
, FPU_ARCH_FPA
},
22106 {"armv3m", ARM_ARCH_V3M
, FPU_ARCH_FPA
},
22107 {"armv4", ARM_ARCH_V4
, FPU_ARCH_FPA
},
22108 {"armv4xm", ARM_ARCH_V4xM
, FPU_ARCH_FPA
},
22109 {"armv4t", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
22110 {"armv4txm", ARM_ARCH_V4TxM
, FPU_ARCH_FPA
},
22111 {"armv5", ARM_ARCH_V5
, FPU_ARCH_VFP
},
22112 {"armv5t", ARM_ARCH_V5T
, FPU_ARCH_VFP
},
22113 {"armv5txm", ARM_ARCH_V5TxM
, FPU_ARCH_VFP
},
22114 {"armv5te", ARM_ARCH_V5TE
, FPU_ARCH_VFP
},
22115 {"armv5texp", ARM_ARCH_V5TExP
, FPU_ARCH_VFP
},
22116 {"armv5tej", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP
},
22117 {"armv6", ARM_ARCH_V6
, FPU_ARCH_VFP
},
22118 {"armv6j", ARM_ARCH_V6
, FPU_ARCH_VFP
},
22119 {"armv6k", ARM_ARCH_V6K
, FPU_ARCH_VFP
},
22120 {"armv6z", ARM_ARCH_V6Z
, FPU_ARCH_VFP
},
22121 {"armv6zk", ARM_ARCH_V6ZK
, FPU_ARCH_VFP
},
22122 {"armv6t2", ARM_ARCH_V6T2
, FPU_ARCH_VFP
},
22123 {"armv6kt2", ARM_ARCH_V6KT2
, FPU_ARCH_VFP
},
22124 {"armv6zt2", ARM_ARCH_V6ZT2
, FPU_ARCH_VFP
},
22125 {"armv6zkt2", ARM_ARCH_V6ZKT2
, FPU_ARCH_VFP
},
22126 {"armv6-m", ARM_ARCH_V6M
, FPU_ARCH_VFP
},
22127 {"armv7", ARM_ARCH_V7
, FPU_ARCH_VFP
},
22128 /* The official spelling of the ARMv7 profile variants is the dashed form.
22129 Accept the non-dashed form for compatibility with old toolchains. */
22130 {"armv7a", ARM_ARCH_V7A
, FPU_ARCH_VFP
},
22131 {"armv7r", ARM_ARCH_V7R
, FPU_ARCH_VFP
},
22132 {"armv7m", ARM_ARCH_V7M
, FPU_ARCH_VFP
},
22133 {"armv7-a", ARM_ARCH_V7A
, FPU_ARCH_VFP
},
22134 {"armv7-r", ARM_ARCH_V7R
, FPU_ARCH_VFP
},
22135 {"armv7-m", ARM_ARCH_V7M
, FPU_ARCH_VFP
},
22136 {"armv7e-m", ARM_ARCH_V7EM
, FPU_ARCH_VFP
},
22137 {"xscale", ARM_ARCH_XSCALE
, FPU_ARCH_VFP
},
22138 {"iwmmxt", ARM_ARCH_IWMMXT
, FPU_ARCH_VFP
},
22139 {"iwmmxt2", ARM_ARCH_IWMMXT2
,FPU_ARCH_VFP
},
22140 {NULL
, ARM_ARCH_NONE
, ARM_ARCH_NONE
}
22143 /* ISA extensions in the co-processor space. */
22144 struct arm_option_cpu_value_table
22147 const arm_feature_set value
;
22150 static const struct arm_option_cpu_value_table arm_extensions
[] =
22152 {"maverick", ARM_FEATURE (0, ARM_CEXT_MAVERICK
)},
22153 {"xscale", ARM_FEATURE (0, ARM_CEXT_XSCALE
)},
22154 {"iwmmxt", ARM_FEATURE (0, ARM_CEXT_IWMMXT
)},
22155 {"iwmmxt2", ARM_FEATURE (0, ARM_CEXT_IWMMXT2
)},
22156 {NULL
, ARM_ARCH_NONE
}
22159 /* This list should, at a minimum, contain all the fpu names
22160 recognized by GCC. */
22161 static const struct arm_option_cpu_value_table arm_fpus
[] =
22163 {"softfpa", FPU_NONE
},
22164 {"fpe", FPU_ARCH_FPE
},
22165 {"fpe2", FPU_ARCH_FPE
},
22166 {"fpe3", FPU_ARCH_FPA
}, /* Third release supports LFM/SFM. */
22167 {"fpa", FPU_ARCH_FPA
},
22168 {"fpa10", FPU_ARCH_FPA
},
22169 {"fpa11", FPU_ARCH_FPA
},
22170 {"arm7500fe", FPU_ARCH_FPA
},
22171 {"softvfp", FPU_ARCH_VFP
},
22172 {"softvfp+vfp", FPU_ARCH_VFP_V2
},
22173 {"vfp", FPU_ARCH_VFP_V2
},
22174 {"vfp9", FPU_ARCH_VFP_V2
},
22175 {"vfp3", FPU_ARCH_VFP_V3
}, /* For backwards compatbility. */
22176 {"vfp10", FPU_ARCH_VFP_V2
},
22177 {"vfp10-r0", FPU_ARCH_VFP_V1
},
22178 {"vfpxd", FPU_ARCH_VFP_V1xD
},
22179 {"vfpv2", FPU_ARCH_VFP_V2
},
22180 {"vfpv3", FPU_ARCH_VFP_V3
},
22181 {"vfpv3-fp16", FPU_ARCH_VFP_V3_FP16
},
22182 {"vfpv3-d16", FPU_ARCH_VFP_V3D16
},
22183 {"vfpv3-d16-fp16", FPU_ARCH_VFP_V3D16_FP16
},
22184 {"vfpv3xd", FPU_ARCH_VFP_V3xD
},
22185 {"vfpv3xd-fp16", FPU_ARCH_VFP_V3xD_FP16
},
22186 {"arm1020t", FPU_ARCH_VFP_V1
},
22187 {"arm1020e", FPU_ARCH_VFP_V2
},
22188 {"arm1136jfs", FPU_ARCH_VFP_V2
},
22189 {"arm1136jf-s", FPU_ARCH_VFP_V2
},
22190 {"maverick", FPU_ARCH_MAVERICK
},
22191 {"neon", FPU_ARCH_VFP_V3_PLUS_NEON_V1
},
22192 {"neon-fp16", FPU_ARCH_NEON_FP16
},
22193 {"vfpv4", FPU_ARCH_VFP_V4
},
22194 {"vfpv4-d16", FPU_ARCH_VFP_V4D16
},
22195 {"fpv4-sp-d16", FPU_ARCH_VFP_V4_SP_D16
},
22196 {"neon-vfpv4", FPU_ARCH_NEON_VFP_V4
},
22197 {NULL
, ARM_ARCH_NONE
}
22200 struct arm_option_value_table
22206 static const struct arm_option_value_table arm_float_abis
[] =
22208 {"hard", ARM_FLOAT_ABI_HARD
},
22209 {"softfp", ARM_FLOAT_ABI_SOFTFP
},
22210 {"soft", ARM_FLOAT_ABI_SOFT
},
22215 /* We only know how to output GNU and ver 4/5 (AAELF) formats. */
22216 static const struct arm_option_value_table arm_eabis
[] =
22218 {"gnu", EF_ARM_EABI_UNKNOWN
},
22219 {"4", EF_ARM_EABI_VER4
},
22220 {"5", EF_ARM_EABI_VER5
},
22225 struct arm_long_option_table
22227 char * option
; /* Substring to match. */
22228 char * help
; /* Help information. */
22229 int (* func
) (char * subopt
); /* Function to decode sub-option. */
22230 char * deprecated
; /* If non-null, print this message. */
22234 arm_parse_extension (char * str
, const arm_feature_set
**opt_p
)
22236 arm_feature_set
*ext_set
= (arm_feature_set
*)
22237 xmalloc (sizeof (arm_feature_set
));
22239 /* Copy the feature set, so that we can modify it. */
22240 *ext_set
= **opt_p
;
22243 while (str
!= NULL
&& *str
!= 0)
22245 const struct arm_option_cpu_value_table
* opt
;
22251 as_bad (_("invalid architectural extension"));
22256 ext
= strchr (str
, '+');
22259 optlen
= ext
- str
;
22261 optlen
= strlen (str
);
22265 as_bad (_("missing architectural extension"));
22269 for (opt
= arm_extensions
; opt
->name
!= NULL
; opt
++)
22270 if (strncmp (opt
->name
, str
, optlen
) == 0)
22272 ARM_MERGE_FEATURE_SETS (*ext_set
, *ext_set
, opt
->value
);
22276 if (opt
->name
== NULL
)
22278 as_bad (_("unknown architectural extension `%s'"), str
);
22289 arm_parse_cpu (char * str
)
22291 const struct arm_cpu_option_table
* opt
;
22292 char * ext
= strchr (str
, '+');
22296 optlen
= ext
- str
;
22298 optlen
= strlen (str
);
22302 as_bad (_("missing cpu name `%s'"), str
);
22306 for (opt
= arm_cpus
; opt
->name
!= NULL
; opt
++)
22307 if (strncmp (opt
->name
, str
, optlen
) == 0)
22309 mcpu_cpu_opt
= &opt
->value
;
22310 mcpu_fpu_opt
= &opt
->default_fpu
;
22311 if (opt
->canonical_name
)
22312 strcpy (selected_cpu_name
, opt
->canonical_name
);
22317 for (i
= 0; i
< optlen
; i
++)
22318 selected_cpu_name
[i
] = TOUPPER (opt
->name
[i
]);
22319 selected_cpu_name
[i
] = 0;
22323 return arm_parse_extension (ext
, &mcpu_cpu_opt
);
22328 as_bad (_("unknown cpu `%s'"), str
);
22333 arm_parse_arch (char * str
)
22335 const struct arm_arch_option_table
*opt
;
22336 char *ext
= strchr (str
, '+');
22340 optlen
= ext
- str
;
22342 optlen
= strlen (str
);
22346 as_bad (_("missing architecture name `%s'"), str
);
22350 for (opt
= arm_archs
; opt
->name
!= NULL
; opt
++)
22351 if (streq (opt
->name
, str
))
22353 march_cpu_opt
= &opt
->value
;
22354 march_fpu_opt
= &opt
->default_fpu
;
22355 strcpy (selected_cpu_name
, opt
->name
);
22358 return arm_parse_extension (ext
, &march_cpu_opt
);
22363 as_bad (_("unknown architecture `%s'\n"), str
);
22368 arm_parse_fpu (char * str
)
22370 const struct arm_option_cpu_value_table
* opt
;
22372 for (opt
= arm_fpus
; opt
->name
!= NULL
; opt
++)
22373 if (streq (opt
->name
, str
))
22375 mfpu_opt
= &opt
->value
;
22379 as_bad (_("unknown floating point format `%s'\n"), str
);
22384 arm_parse_float_abi (char * str
)
22386 const struct arm_option_value_table
* opt
;
22388 for (opt
= arm_float_abis
; opt
->name
!= NULL
; opt
++)
22389 if (streq (opt
->name
, str
))
22391 mfloat_abi_opt
= opt
->value
;
22395 as_bad (_("unknown floating point abi `%s'\n"), str
);
22401 arm_parse_eabi (char * str
)
22403 const struct arm_option_value_table
*opt
;
22405 for (opt
= arm_eabis
; opt
->name
!= NULL
; opt
++)
22406 if (streq (opt
->name
, str
))
22408 meabi_flags
= opt
->value
;
22411 as_bad (_("unknown EABI `%s'\n"), str
);
22417 arm_parse_it_mode (char * str
)
22419 bfd_boolean ret
= TRUE
;
22421 if (streq ("arm", str
))
22422 implicit_it_mode
= IMPLICIT_IT_MODE_ARM
;
22423 else if (streq ("thumb", str
))
22424 implicit_it_mode
= IMPLICIT_IT_MODE_THUMB
;
22425 else if (streq ("always", str
))
22426 implicit_it_mode
= IMPLICIT_IT_MODE_ALWAYS
;
22427 else if (streq ("never", str
))
22428 implicit_it_mode
= IMPLICIT_IT_MODE_NEVER
;
22431 as_bad (_("unknown implicit IT mode `%s', should be "\
22432 "arm, thumb, always, or never."), str
);
22439 struct arm_long_option_table arm_long_opts
[] =
22441 {"mcpu=", N_("<cpu name>\t assemble for CPU <cpu name>"),
22442 arm_parse_cpu
, NULL
},
22443 {"march=", N_("<arch name>\t assemble for architecture <arch name>"),
22444 arm_parse_arch
, NULL
},
22445 {"mfpu=", N_("<fpu name>\t assemble for FPU architecture <fpu name>"),
22446 arm_parse_fpu
, NULL
},
22447 {"mfloat-abi=", N_("<abi>\t assemble for floating point ABI <abi>"),
22448 arm_parse_float_abi
, NULL
},
22450 {"meabi=", N_("<ver>\t\t assemble for eabi version <ver>"),
22451 arm_parse_eabi
, NULL
},
22453 {"mimplicit-it=", N_("<mode>\t controls implicit insertion of IT instructions"),
22454 arm_parse_it_mode
, NULL
},
22455 {NULL
, NULL
, 0, NULL
}
22459 md_parse_option (int c
, char * arg
)
22461 struct arm_option_table
*opt
;
22462 const struct arm_legacy_option_table
*fopt
;
22463 struct arm_long_option_table
*lopt
;
22469 target_big_endian
= 1;
22475 target_big_endian
= 0;
22479 case OPTION_FIX_V4BX
:
22484 /* Listing option. Just ignore these, we don't support additional
22489 for (opt
= arm_opts
; opt
->option
!= NULL
; opt
++)
22491 if (c
== opt
->option
[0]
22492 && ((arg
== NULL
&& opt
->option
[1] == 0)
22493 || streq (arg
, opt
->option
+ 1)))
22495 /* If the option is deprecated, tell the user. */
22496 if (warn_on_deprecated
&& opt
->deprecated
!= NULL
)
22497 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c
,
22498 arg
? arg
: "", _(opt
->deprecated
));
22500 if (opt
->var
!= NULL
)
22501 *opt
->var
= opt
->value
;
22507 for (fopt
= arm_legacy_opts
; fopt
->option
!= NULL
; fopt
++)
22509 if (c
== fopt
->option
[0]
22510 && ((arg
== NULL
&& fopt
->option
[1] == 0)
22511 || streq (arg
, fopt
->option
+ 1)))
22513 /* If the option is deprecated, tell the user. */
22514 if (warn_on_deprecated
&& fopt
->deprecated
!= NULL
)
22515 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c
,
22516 arg
? arg
: "", _(fopt
->deprecated
));
22518 if (fopt
->var
!= NULL
)
22519 *fopt
->var
= &fopt
->value
;
22525 for (lopt
= arm_long_opts
; lopt
->option
!= NULL
; lopt
++)
22527 /* These options are expected to have an argument. */
22528 if (c
== lopt
->option
[0]
22530 && strncmp (arg
, lopt
->option
+ 1,
22531 strlen (lopt
->option
+ 1)) == 0)
22533 /* If the option is deprecated, tell the user. */
22534 if (warn_on_deprecated
&& lopt
->deprecated
!= NULL
)
22535 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c
, arg
,
22536 _(lopt
->deprecated
));
22538 /* Call the sup-option parser. */
22539 return lopt
->func (arg
+ strlen (lopt
->option
) - 1);
22550 md_show_usage (FILE * fp
)
22552 struct arm_option_table
*opt
;
22553 struct arm_long_option_table
*lopt
;
22555 fprintf (fp
, _(" ARM-specific assembler options:\n"));
22557 for (opt
= arm_opts
; opt
->option
!= NULL
; opt
++)
22558 if (opt
->help
!= NULL
)
22559 fprintf (fp
, " -%-23s%s\n", opt
->option
, _(opt
->help
));
22561 for (lopt
= arm_long_opts
; lopt
->option
!= NULL
; lopt
++)
22562 if (lopt
->help
!= NULL
)
22563 fprintf (fp
, " -%s%s\n", lopt
->option
, _(lopt
->help
));
22567 -EB assemble code for a big-endian cpu\n"));
22572 -EL assemble code for a little-endian cpu\n"));
22576 --fix-v4bx Allow BX in ARMv4 code\n"));
22584 arm_feature_set flags
;
22585 } cpu_arch_ver_table
;
22587 /* Mapping from CPU features to EABI CPU arch values. Table must be sorted
22588 least features first. */
22589 static const cpu_arch_ver_table cpu_arch_ver
[] =
22595 {4, ARM_ARCH_V5TE
},
22596 {5, ARM_ARCH_V5TEJ
},
22600 {11, ARM_ARCH_V6M
},
22601 {8, ARM_ARCH_V6T2
},
22602 {10, ARM_ARCH_V7A
},
22603 {10, ARM_ARCH_V7R
},
22604 {10, ARM_ARCH_V7M
},
22608 /* Set an attribute if it has not already been set by the user. */
22610 aeabi_set_attribute_int (int tag
, int value
)
22613 || tag
>= NUM_KNOWN_OBJ_ATTRIBUTES
22614 || !attributes_set_explicitly
[tag
])
22615 bfd_elf_add_proc_attr_int (stdoutput
, tag
, value
);
22619 aeabi_set_attribute_string (int tag
, const char *value
)
22622 || tag
>= NUM_KNOWN_OBJ_ATTRIBUTES
22623 || !attributes_set_explicitly
[tag
])
22624 bfd_elf_add_proc_attr_string (stdoutput
, tag
, value
);
22627 /* Set the public EABI object attributes. */
22629 aeabi_set_public_attributes (void)
22632 arm_feature_set flags
;
22633 arm_feature_set tmp
;
22634 const cpu_arch_ver_table
*p
;
22636 /* Choose the architecture based on the capabilities of the requested cpu
22637 (if any) and/or the instructions actually used. */
22638 ARM_MERGE_FEATURE_SETS (flags
, arm_arch_used
, thumb_arch_used
);
22639 ARM_MERGE_FEATURE_SETS (flags
, flags
, *mfpu_opt
);
22640 ARM_MERGE_FEATURE_SETS (flags
, flags
, selected_cpu
);
22641 /*Allow the user to override the reported architecture. */
22644 ARM_CLEAR_FEATURE (flags
, flags
, arm_arch_any
);
22645 ARM_MERGE_FEATURE_SETS (flags
, flags
, *object_arch
);
22650 for (p
= cpu_arch_ver
; p
->val
; p
++)
22652 if (ARM_CPU_HAS_FEATURE (tmp
, p
->flags
))
22655 ARM_CLEAR_FEATURE (tmp
, tmp
, p
->flags
);
22659 /* The table lookup above finds the last architecture to contribute
22660 a new feature. Unfortunately, Tag13 is a subset of the union of
22661 v6T2 and v7-M, so it is never seen as contributing a new feature.
22662 We can not search for the last entry which is entirely used,
22663 because if no CPU is specified we build up only those flags
22664 actually used. Perhaps we should separate out the specified
22665 and implicit cases. Avoid taking this path for -march=all by
22666 checking for contradictory v7-A / v7-M features. */
22668 && !ARM_CPU_HAS_FEATURE (flags
, arm_ext_v7a
)
22669 && ARM_CPU_HAS_FEATURE (flags
, arm_ext_v7m
)
22670 && ARM_CPU_HAS_FEATURE (flags
, arm_ext_v6_dsp
))
22673 /* Tag_CPU_name. */
22674 if (selected_cpu_name
[0])
22678 q
= selected_cpu_name
;
22679 if (strncmp (q
, "armv", 4) == 0)
22684 for (i
= 0; q
[i
]; i
++)
22685 q
[i
] = TOUPPER (q
[i
]);
22687 aeabi_set_attribute_string (Tag_CPU_name
, q
);
22690 /* Tag_CPU_arch. */
22691 aeabi_set_attribute_int (Tag_CPU_arch
, arch
);
22693 /* Tag_CPU_arch_profile. */
22694 if (ARM_CPU_HAS_FEATURE (flags
, arm_ext_v7a
))
22695 aeabi_set_attribute_int (Tag_CPU_arch_profile
, 'A');
22696 else if (ARM_CPU_HAS_FEATURE (flags
, arm_ext_v7r
))
22697 aeabi_set_attribute_int (Tag_CPU_arch_profile
, 'R');
22698 else if (ARM_CPU_HAS_FEATURE (flags
, arm_ext_m
))
22699 aeabi_set_attribute_int (Tag_CPU_arch_profile
, 'M');
22701 /* Tag_ARM_ISA_use. */
22702 if (ARM_CPU_HAS_FEATURE (flags
, arm_ext_v1
)
22704 aeabi_set_attribute_int (Tag_ARM_ISA_use
, 1);
22706 /* Tag_THUMB_ISA_use. */
22707 if (ARM_CPU_HAS_FEATURE (flags
, arm_ext_v4t
)
22709 aeabi_set_attribute_int (Tag_THUMB_ISA_use
,
22710 ARM_CPU_HAS_FEATURE (flags
, arm_arch_t2
) ? 2 : 1);
22712 /* Tag_VFP_arch. */
22713 if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_fma
))
22714 aeabi_set_attribute_int (Tag_VFP_arch
,
22715 ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_d32
)
22717 else if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_d32
))
22718 aeabi_set_attribute_int (Tag_VFP_arch
, 3);
22719 else if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_v3xd
))
22720 aeabi_set_attribute_int (Tag_VFP_arch
, 4);
22721 else if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_v2
))
22722 aeabi_set_attribute_int (Tag_VFP_arch
, 2);
22723 else if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_v1
)
22724 || ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_ext_v1xd
))
22725 aeabi_set_attribute_int (Tag_VFP_arch
, 1);
22727 /* Tag_WMMX_arch. */
22728 if (ARM_CPU_HAS_FEATURE (flags
, arm_cext_iwmmxt2
))
22729 aeabi_set_attribute_int (Tag_WMMX_arch
, 2);
22730 else if (ARM_CPU_HAS_FEATURE (flags
, arm_cext_iwmmxt
))
22731 aeabi_set_attribute_int (Tag_WMMX_arch
, 1);
22733 /* Tag_Advanced_SIMD_arch (formerly Tag_NEON_arch). */
22734 if (ARM_CPU_HAS_FEATURE (flags
, fpu_neon_ext_v1
))
22735 aeabi_set_attribute_int
22736 (Tag_Advanced_SIMD_arch
, (ARM_CPU_HAS_FEATURE (flags
, fpu_neon_ext_fma
)
22739 /* Tag_VFP_HP_extension (formerly Tag_NEON_FP16_arch). */
22740 if (ARM_CPU_HAS_FEATURE (flags
, fpu_vfp_fp16
))
22741 aeabi_set_attribute_int (Tag_VFP_HP_extension
, 1);
22744 /* Add the default contents for the .ARM.attributes section. */
22748 if (EF_ARM_EABI_VERSION (meabi_flags
) < EF_ARM_EABI_VER4
)
22751 aeabi_set_public_attributes ();
22753 #endif /* OBJ_ELF */
22756 /* Parse a .cpu directive. */
22759 s_arm_cpu (int ignored ATTRIBUTE_UNUSED
)
22761 const struct arm_cpu_option_table
*opt
;
22765 name
= input_line_pointer
;
22766 while (*input_line_pointer
&& !ISSPACE (*input_line_pointer
))
22767 input_line_pointer
++;
22768 saved_char
= *input_line_pointer
;
22769 *input_line_pointer
= 0;
22771 /* Skip the first "all" entry. */
22772 for (opt
= arm_cpus
+ 1; opt
->name
!= NULL
; opt
++)
22773 if (streq (opt
->name
, name
))
22775 mcpu_cpu_opt
= &opt
->value
;
22776 selected_cpu
= opt
->value
;
22777 if (opt
->canonical_name
)
22778 strcpy (selected_cpu_name
, opt
->canonical_name
);
22782 for (i
= 0; opt
->name
[i
]; i
++)
22783 selected_cpu_name
[i
] = TOUPPER (opt
->name
[i
]);
22784 selected_cpu_name
[i
] = 0;
22786 ARM_MERGE_FEATURE_SETS (cpu_variant
, *mcpu_cpu_opt
, *mfpu_opt
);
22787 *input_line_pointer
= saved_char
;
22788 demand_empty_rest_of_line ();
22791 as_bad (_("unknown cpu `%s'"), name
);
22792 *input_line_pointer
= saved_char
;
22793 ignore_rest_of_line ();
22797 /* Parse a .arch directive. */
22800 s_arm_arch (int ignored ATTRIBUTE_UNUSED
)
22802 const struct arm_arch_option_table
*opt
;
22806 name
= input_line_pointer
;
22807 while (*input_line_pointer
&& !ISSPACE (*input_line_pointer
))
22808 input_line_pointer
++;
22809 saved_char
= *input_line_pointer
;
22810 *input_line_pointer
= 0;
22812 /* Skip the first "all" entry. */
22813 for (opt
= arm_archs
+ 1; opt
->name
!= NULL
; opt
++)
22814 if (streq (opt
->name
, name
))
22816 mcpu_cpu_opt
= &opt
->value
;
22817 selected_cpu
= opt
->value
;
22818 strcpy (selected_cpu_name
, opt
->name
);
22819 ARM_MERGE_FEATURE_SETS (cpu_variant
, *mcpu_cpu_opt
, *mfpu_opt
);
22820 *input_line_pointer
= saved_char
;
22821 demand_empty_rest_of_line ();
22825 as_bad (_("unknown architecture `%s'\n"), name
);
22826 *input_line_pointer
= saved_char
;
22827 ignore_rest_of_line ();
22831 /* Parse a .object_arch directive. */
22834 s_arm_object_arch (int ignored ATTRIBUTE_UNUSED
)
22836 const struct arm_arch_option_table
*opt
;
22840 name
= input_line_pointer
;
22841 while (*input_line_pointer
&& !ISSPACE (*input_line_pointer
))
22842 input_line_pointer
++;
22843 saved_char
= *input_line_pointer
;
22844 *input_line_pointer
= 0;
22846 /* Skip the first "all" entry. */
22847 for (opt
= arm_archs
+ 1; opt
->name
!= NULL
; opt
++)
22848 if (streq (opt
->name
, name
))
22850 object_arch
= &opt
->value
;
22851 *input_line_pointer
= saved_char
;
22852 demand_empty_rest_of_line ();
22856 as_bad (_("unknown architecture `%s'\n"), name
);
22857 *input_line_pointer
= saved_char
;
22858 ignore_rest_of_line ();
22861 /* Parse a .fpu directive. */
22864 s_arm_fpu (int ignored ATTRIBUTE_UNUSED
)
22866 const struct arm_option_cpu_value_table
*opt
;
22870 name
= input_line_pointer
;
22871 while (*input_line_pointer
&& !ISSPACE (*input_line_pointer
))
22872 input_line_pointer
++;
22873 saved_char
= *input_line_pointer
;
22874 *input_line_pointer
= 0;
22876 for (opt
= arm_fpus
; opt
->name
!= NULL
; opt
++)
22877 if (streq (opt
->name
, name
))
22879 mfpu_opt
= &opt
->value
;
22880 ARM_MERGE_FEATURE_SETS (cpu_variant
, *mcpu_cpu_opt
, *mfpu_opt
);
22881 *input_line_pointer
= saved_char
;
22882 demand_empty_rest_of_line ();
22886 as_bad (_("unknown floating point format `%s'\n"), name
);
22887 *input_line_pointer
= saved_char
;
22888 ignore_rest_of_line ();
22891 /* Copy symbol information. */
22894 arm_copy_symbol_attributes (symbolS
*dest
, symbolS
*src
)
22896 ARM_GET_FLAG (dest
) = ARM_GET_FLAG (src
);
22900 /* Given a symbolic attribute NAME, return the proper integer value.
22901 Returns -1 if the attribute is not known. */
22904 arm_convert_symbolic_attribute (const char *name
)
22906 static const struct
22911 attribute_table
[] =
22913 /* When you modify this table you should
22914 also modify the list in doc/c-arm.texi. */
22915 #define T(tag) {#tag, tag}
22916 T (Tag_CPU_raw_name
),
22919 T (Tag_CPU_arch_profile
),
22920 T (Tag_ARM_ISA_use
),
22921 T (Tag_THUMB_ISA_use
),
22924 T (Tag_Advanced_SIMD_arch
),
22925 T (Tag_PCS_config
),
22926 T (Tag_ABI_PCS_R9_use
),
22927 T (Tag_ABI_PCS_RW_data
),
22928 T (Tag_ABI_PCS_RO_data
),
22929 T (Tag_ABI_PCS_GOT_use
),
22930 T (Tag_ABI_PCS_wchar_t
),
22931 T (Tag_ABI_FP_rounding
),
22932 T (Tag_ABI_FP_denormal
),
22933 T (Tag_ABI_FP_exceptions
),
22934 T (Tag_ABI_FP_user_exceptions
),
22935 T (Tag_ABI_FP_number_model
),
22936 T (Tag_ABI_align8_needed
),
22937 T (Tag_ABI_align8_preserved
),
22938 T (Tag_ABI_enum_size
),
22939 T (Tag_ABI_HardFP_use
),
22940 T (Tag_ABI_VFP_args
),
22941 T (Tag_ABI_WMMX_args
),
22942 T (Tag_ABI_optimization_goals
),
22943 T (Tag_ABI_FP_optimization_goals
),
22944 T (Tag_compatibility
),
22945 T (Tag_CPU_unaligned_access
),
22946 T (Tag_VFP_HP_extension
),
22947 T (Tag_ABI_FP_16bit_format
),
22948 T (Tag_nodefaults
),
22949 T (Tag_also_compatible_with
),
22950 T (Tag_conformance
),
22952 T (Tag_Virtualization_use
),
22953 T (Tag_MPextension_use
)
22961 for (i
= 0; i
< ARRAY_SIZE (attribute_table
); i
++)
22962 if (streq (name
, attribute_table
[i
].name
))
22963 return attribute_table
[i
].tag
;
22969 /* Apply sym value for relocations only in the case that
22970 they are for local symbols and you have the respective
22971 architectural feature for blx and simple switches. */
22973 arm_apply_sym_value (struct fix
* fixP
)
22976 && ARM_CPU_HAS_FEATURE (selected_cpu
, arm_ext_v5t
)
22977 && !S_IS_EXTERNAL (fixP
->fx_addsy
))
22979 switch (fixP
->fx_r_type
)
22981 case BFD_RELOC_ARM_PCREL_BLX
:
22982 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
22983 if (ARM_IS_FUNC (fixP
->fx_addsy
))
22987 case BFD_RELOC_ARM_PCREL_CALL
:
22988 case BFD_RELOC_THUMB_PCREL_BLX
:
22989 if (THUMB_IS_FUNC (fixP
->fx_addsy
))
23000 #endif /* OBJ_ELF */