1 /* tc-arm.c -- Assemble for the ARM
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
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 2, 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
31 #include "safe-ctype.h"
33 /* Need TARGET_CPU. */
40 #include "opcode/arm.h"
44 #include "dwarf2dbg.h"
45 #include "dw2gencfi.h"
48 /* XXX Set this to 1 after the next binutils release. */
49 #define WARN_DEPRECATED 0
52 /* Must be at least the size of the largest unwind opcode (currently two). */
53 #define ARM_OPCODE_CHUNK_SIZE 8
55 /* This structure holds the unwinding state. */
60 symbolS
* table_entry
;
61 symbolS
* personality_routine
;
62 int personality_index
;
63 /* The segment containing the function. */
66 /* Opcodes generated from this function. */
67 unsigned char * opcodes
;
70 /* The number of bytes pushed to the stack. */
72 /* We don't add stack adjustment opcodes immediately so that we can merge
73 multiple adjustments. We can also omit the final adjustment
74 when using a frame pointer. */
75 offsetT pending_offset
;
76 /* These two fields are set by both unwind_movsp and unwind_setfp. They
77 hold the reg+offset to use when restoring sp from a frame pointer. */
80 /* Nonzero if an unwind_setfp directive has been seen. */
82 /* Nonzero if the last opcode restores sp from fp_reg. */
83 unsigned sp_restored
:1;
86 /* Bit N indicates that an R_ARM_NONE relocation has been output for
87 __aeabi_unwind_cpp_prN already if set. This enables dependencies to be
88 emitted only once per section, to save unnecessary bloat. */
89 static unsigned int marked_pr_dependency
= 0;
100 /* Types of processor to assemble for. */
101 #define ARM_1 ARM_ARCH_V1
102 #define ARM_2 ARM_ARCH_V2
103 #define ARM_3 ARM_ARCH_V2S
104 #define ARM_250 ARM_ARCH_V2S
105 #define ARM_6 ARM_ARCH_V3
106 #define ARM_7 ARM_ARCH_V3
107 #define ARM_8 ARM_ARCH_V4
108 #define ARM_9 ARM_ARCH_V4T
109 #define ARM_STRONG ARM_ARCH_V4
110 #define ARM_CPU_MASK 0x0000000f /* XXX? */
113 #if defined __XSCALE__
114 #define CPU_DEFAULT (ARM_ARCH_XSCALE)
116 #if defined __thumb__
117 #define CPU_DEFAULT (ARM_ARCH_V5T)
119 #define CPU_DEFAULT ARM_ANY
126 # define FPU_DEFAULT FPU_ARCH_FPA
127 # elif defined (TE_NetBSD)
129 # define FPU_DEFAULT FPU_ARCH_VFP /* Soft-float, but VFP order. */
131 /* Legacy a.out format. */
132 # define FPU_DEFAULT FPU_ARCH_FPA /* Soft-float, but FPA order. */
134 # elif defined (TE_VXWORKS)
135 # define FPU_DEFAULT FPU_ARCH_VFP /* Soft-float, VFP order. */
137 /* For backwards compatibility, default to FPA. */
138 # define FPU_DEFAULT FPU_ARCH_FPA
140 #endif /* ifndef FPU_DEFAULT */
142 #define streq(a, b) (strcmp (a, b) == 0)
144 static unsigned long cpu_variant
;
146 /* Flags stored in private area of BFD structure. */
147 static int uses_apcs_26
= FALSE
;
148 static int atpcs
= FALSE
;
149 static int support_interwork
= FALSE
;
150 static int uses_apcs_float
= FALSE
;
151 static int pic_code
= FALSE
;
153 /* Variables that we set while parsing command-line options. Once all
154 options have been read we re-process these values to set the real
156 static int legacy_cpu
= -1;
157 static int legacy_fpu
= -1;
159 static int mcpu_cpu_opt
= -1;
160 static int mcpu_fpu_opt
= -1;
161 static int march_cpu_opt
= -1;
162 static int march_fpu_opt
= -1;
163 static int mfpu_opt
= -1;
164 static int mfloat_abi_opt
= -1;
167 static int meabi_flags
= EABI_DEFAULT
;
169 static int meabi_flags
= EF_ARM_EABI_UNKNOWN
;
174 /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
175 symbolS
* GOT_symbol
;
178 /* 0: assemble for ARM,
179 1: assemble for Thumb,
180 2: assemble for Thumb even though target CPU does not support thumb
182 static int thumb_mode
= 0;
184 /* If unified_syntax is true, we are processing the new unified
185 ARM/Thumb syntax. Important differences from the old ARM mode:
187 - Immediate operands do not require a # prefix.
188 - Conditional affixes always appear at the end of the
189 instruction. (For backward compatibility, those instructions
190 that formerly had them in the middle, continue to accept them
192 - The IT instruction may appear, and if it does is validated
193 against subsequent conditional affixes. It does not generate
196 Important differences from the old Thumb mode:
198 - Immediate operands do not require a # prefix.
199 - Most of the V6T2 instructions are only available in unified mode.
200 - The .N and .W suffixes are recognized and honored (it is an error
201 if they cannot be honored).
202 - All instructions set the flags if and only if they have an 's' affix.
203 - Conditional affixes may be used. They are validated against
204 preceding IT instructions. Unlike ARM mode, you cannot use a
205 conditional affix except in the scope of an IT instruction. */
207 static bfd_boolean unified_syntax
= FALSE
;
212 unsigned long instruction
;
216 /* Set to the opcode if the instruction needs relaxation.
217 Zero if the instruction is not relaxed. */
221 bfd_reloc_code_real_type type
;
230 unsigned present
: 1; /* Operand present. */
231 unsigned isreg
: 1; /* Operand was a register. */
232 unsigned immisreg
: 1; /* .imm field is a second register. */
233 unsigned hasreloc
: 1; /* Operand has relocation suffix. */
234 unsigned writeback
: 1; /* Operand has trailing ! */
235 unsigned preind
: 1; /* Preindexed address. */
236 unsigned postind
: 1; /* Postindexed address. */
237 unsigned negative
: 1; /* Index register was negated. */
238 unsigned shifted
: 1; /* Shift applied to operation. */
239 unsigned shift_kind
: 3; /* Shift operation (enum shift_kind). */
243 static struct arm_it inst
;
245 #define NUM_FLOAT_VALS 8
247 const char * fp_const
[] =
249 "0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0", 0
252 /* Number of littlenums required to hold an extended precision number. */
253 #define MAX_LITTLENUMS 6
255 LITTLENUM_TYPE fp_values
[NUM_FLOAT_VALS
][MAX_LITTLENUMS
];
265 #define CP_T_X 0x00008000
266 #define CP_T_Y 0x00400000
268 #define CONDS_BIT 0x00100000
269 #define LOAD_BIT 0x00100000
271 #define DOUBLE_LOAD_FLAG 0x00000001
275 const char * template;
279 #define COND_ALWAYS 0xE
283 const char *template;
287 /* The bit that distinguishes CPSR and SPSR. */
288 #define SPSR_BIT (1 << 22)
290 /* The individual PSR flag bits. */
291 #define PSR_c (1 << 16)
292 #define PSR_x (1 << 17)
293 #define PSR_s (1 << 18)
294 #define PSR_f (1 << 19)
299 bfd_reloc_code_real_type reloc
;
304 VFP_REG_Sd
, VFP_REG_Sm
, VFP_REG_Sn
309 VFP_LDSTMIA
, VFP_LDSTMDB
, VFP_LDSTMIAX
, VFP_LDSTMDBX
312 /* ARM register categories. This includes coprocessor numbers and various
313 architecture extensions' registers. */
335 /* Structure for a hash table entry for a register. */
339 unsigned char number
;
341 unsigned char builtin
;
344 /* Diagnostics used when we don't get a register of the expected type. */
345 const char *const reg_expected_msgs
[] =
347 N_("ARM register expected"),
348 N_("bad or missing co-processor number"),
349 N_("co-processor register expected"),
350 N_("FPA register expected"),
351 N_("VFP single precision register expected"),
352 N_("VFP double precision register expected"),
353 N_("VFP system register expected"),
354 N_("Maverick MVF register expected"),
355 N_("Maverick MVD register expected"),
356 N_("Maverick MVFX register expected"),
357 N_("Maverick MVDX register expected"),
358 N_("Maverick MVAX register expected"),
359 N_("Maverick DSPSC register expected"),
360 N_("iWMMXt data register expected"),
361 N_("iWMMXt control register expected"),
362 N_("iWMMXt scalar register expected"),
363 N_("XScale accumulator register expected"),
366 /* Some well known registers that we refer to directly elsewhere. */
371 /* ARM instructions take 4bytes in the object file, Thumb instructions
377 /* Basic string to match. */
378 const char *template;
380 /* Parameters to instruction. */
381 unsigned char operands
[8];
383 /* Conditional tag - see opcode_lookup. */
384 unsigned int tag
: 4;
386 /* Basic instruction code. */
387 unsigned int avalue
: 28;
389 /* Thumb-format instruction code. */
392 /* Which architecture variant provides this instruction. */
393 unsigned long avariant
;
394 unsigned long tvariant
;
396 /* Function to call to encode instruction in ARM format. */
397 void (* aencode
) (void);
399 /* Function to call to encode instruction in Thumb format. */
400 void (* tencode
) (void);
403 /* Defines for various bits that we will want to toggle. */
404 #define INST_IMMEDIATE 0x02000000
405 #define OFFSET_REG 0x02000000
406 #define HWOFFSET_IMM 0x00400000
407 #define SHIFT_BY_REG 0x00000010
408 #define PRE_INDEX 0x01000000
409 #define INDEX_UP 0x00800000
410 #define WRITE_BACK 0x00200000
411 #define LDM_TYPE_2_OR_3 0x00400000
413 #define LITERAL_MASK 0xf000f000
414 #define OPCODE_MASK 0xfe1fffff
415 #define V4_STR_BIT 0x00000020
417 #define DATA_OP_SHIFT 21
419 /* Codes to distinguish the arithmetic instructions. */
430 #define OPCODE_CMP 10
431 #define OPCODE_CMN 11
432 #define OPCODE_ORR 12
433 #define OPCODE_MOV 13
434 #define OPCODE_BIC 14
435 #define OPCODE_MVN 15
437 #define T_OPCODE_MUL 0x4340
438 #define T_OPCODE_TST 0x4200
439 #define T_OPCODE_CMN 0x42c0
440 #define T_OPCODE_NEG 0x4240
441 #define T_OPCODE_MVN 0x43c0
443 #define T_OPCODE_ADD_R3 0x1800
444 #define T_OPCODE_SUB_R3 0x1a00
445 #define T_OPCODE_ADD_HI 0x4400
446 #define T_OPCODE_ADD_ST 0xb000
447 #define T_OPCODE_SUB_ST 0xb080
448 #define T_OPCODE_ADD_SP 0xa800
449 #define T_OPCODE_ADD_PC 0xa000
450 #define T_OPCODE_ADD_I8 0x3000
451 #define T_OPCODE_SUB_I8 0x3800
452 #define T_OPCODE_ADD_I3 0x1c00
453 #define T_OPCODE_SUB_I3 0x1e00
455 #define T_OPCODE_ASR_R 0x4100
456 #define T_OPCODE_LSL_R 0x4080
457 #define T_OPCODE_LSR_R 0x40c0
458 #define T_OPCODE_ROR_R 0x41c0
459 #define T_OPCODE_ASR_I 0x1000
460 #define T_OPCODE_LSL_I 0x0000
461 #define T_OPCODE_LSR_I 0x0800
463 #define T_OPCODE_MOV_I8 0x2000
464 #define T_OPCODE_CMP_I8 0x2800
465 #define T_OPCODE_CMP_LR 0x4280
466 #define T_OPCODE_MOV_HR 0x4600
467 #define T_OPCODE_CMP_HR 0x4500
469 #define T_OPCODE_LDR_PC 0x4800
470 #define T_OPCODE_LDR_SP 0x9800
471 #define T_OPCODE_STR_SP 0x9000
472 #define T_OPCODE_LDR_IW 0x6800
473 #define T_OPCODE_STR_IW 0x6000
474 #define T_OPCODE_LDR_IH 0x8800
475 #define T_OPCODE_STR_IH 0x8000
476 #define T_OPCODE_LDR_IB 0x7800
477 #define T_OPCODE_STR_IB 0x7000
478 #define T_OPCODE_LDR_RW 0x5800
479 #define T_OPCODE_STR_RW 0x5000
480 #define T_OPCODE_LDR_RH 0x5a00
481 #define T_OPCODE_STR_RH 0x5200
482 #define T_OPCODE_LDR_RB 0x5c00
483 #define T_OPCODE_STR_RB 0x5400
485 #define T_OPCODE_PUSH 0xb400
486 #define T_OPCODE_POP 0xbc00
488 #define T_OPCODE_BRANCH 0xe000
490 #define THUMB_SIZE 2 /* Size of thumb instruction. */
491 #define THUMB_PP_PC_LR 0x0100
492 #define THUMB_LOAD_BIT 0x0800
494 #define BAD_ARGS _("bad arguments to instruction")
495 #define BAD_PC _("r15 not allowed here")
496 #define BAD_COND _("instruction cannot be conditional")
497 #define BAD_OVERLAP _("registers may not be the same")
498 #define BAD_HIREG _("lo register required")
499 #define BAD_THUMB32 _("instruction not supported in Thumb16 mode")
501 static struct hash_control
*arm_ops_hsh
;
502 static struct hash_control
*arm_cond_hsh
;
503 static struct hash_control
*arm_shift_hsh
;
504 static struct hash_control
*arm_psr_hsh
;
505 static struct hash_control
*arm_reg_hsh
;
506 static struct hash_control
*arm_reloc_hsh
;
508 /* Stuff needed to resolve the label ambiguity
518 symbolS
* last_label_seen
;
519 static int label_is_thumb_function_name
= FALSE
;
521 /* Literal pool structure. Held on a per-section
522 and per-sub-section basis. */
524 #define MAX_LITERAL_POOL_SIZE 1024
525 typedef struct literal_pool
527 expressionS literals
[MAX_LITERAL_POOL_SIZE
];
528 unsigned int next_free_entry
;
533 struct literal_pool
* next
;
536 /* Pointer to a linked list of literal pools. */
537 literal_pool
* list_of_pools
= NULL
;
539 /* State variables for IT block handling. */
540 static bfd_boolean current_it_mask
= 0;
541 static int current_cc
;
546 /* This array holds the chars that always start a comment. If the
547 pre-processor is disabled, these aren't very useful. */
548 const char comment_chars
[] = "@";
550 /* This array holds the chars that only start a comment at the beginning of
551 a line. If the line seems to have the form '# 123 filename'
552 .line and .file directives will appear in the pre-processed output. */
553 /* Note that input_file.c hand checks for '#' at the beginning of the
554 first line of the input file. This is because the compiler outputs
555 #NO_APP at the beginning of its output. */
556 /* Also note that comments like this one will always work. */
557 const char line_comment_chars
[] = "#";
559 const char line_separator_chars
[] = ";";
561 /* Chars that can be used to separate mant
562 from exp in floating point numbers. */
563 const char EXP_CHARS
[] = "eE";
565 /* Chars that mean this number is a floating point constant. */
569 const char FLT_CHARS
[] = "rRsSfFdDxXeEpP";
571 /* Prefix characters that indicate the start of an immediate
573 #define is_immediate_prefix(C) ((C) == '#' || (C) == '$')
575 /* Separator character handling. */
577 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0)
580 skip_past_char (char ** str
, char c
)
590 #define skip_past_comma(str) skip_past_char (str, ',')
592 /* Arithmetic expressions (possibly involving symbols). */
594 /* Return TRUE if anything in the expression is a bignum. */
597 walk_no_bignums (symbolS
* sp
)
599 if (symbol_get_value_expression (sp
)->X_op
== O_big
)
602 if (symbol_get_value_expression (sp
)->X_add_symbol
)
604 return (walk_no_bignums (symbol_get_value_expression (sp
)->X_add_symbol
)
605 || (symbol_get_value_expression (sp
)->X_op_symbol
606 && walk_no_bignums (symbol_get_value_expression (sp
)->X_op_symbol
)));
612 static int in_my_get_expression
= 0;
614 /* Third argument to my_get_expression. */
615 #define GE_NO_PREFIX 0
616 #define GE_IMM_PREFIX 1
617 #define GE_OPT_PREFIX 2
620 my_get_expression (expressionS
* ep
, char ** str
, int prefix_mode
)
625 /* In unified syntax, all prefixes are optional. */
627 prefix_mode
= GE_OPT_PREFIX
;
631 case GE_NO_PREFIX
: break;
633 if (!is_immediate_prefix (**str
))
635 inst
.error
= _("immediate expression requires a # prefix");
641 if (is_immediate_prefix (**str
))
647 memset (ep
, 0, sizeof (expressionS
));
649 save_in
= input_line_pointer
;
650 input_line_pointer
= *str
;
651 in_my_get_expression
= 1;
652 seg
= expression (ep
);
653 in_my_get_expression
= 0;
655 if (ep
->X_op
== O_illegal
)
657 /* We found a bad expression in md_operand(). */
658 *str
= input_line_pointer
;
659 input_line_pointer
= save_in
;
660 if (inst
.error
== NULL
)
661 inst
.error
= _("bad expression");
666 if (seg
!= absolute_section
667 && seg
!= text_section
668 && seg
!= data_section
669 && seg
!= bss_section
670 && seg
!= undefined_section
)
672 inst
.error
= _("bad segment");
673 *str
= input_line_pointer
;
674 input_line_pointer
= save_in
;
679 /* Get rid of any bignums now, so that we don't generate an error for which
680 we can't establish a line number later on. Big numbers are never valid
681 in instructions, which is where this routine is always called. */
682 if (ep
->X_op
== O_big
684 && (walk_no_bignums (ep
->X_add_symbol
)
686 && walk_no_bignums (ep
->X_op_symbol
)))))
688 inst
.error
= _("invalid constant");
689 *str
= input_line_pointer
;
690 input_line_pointer
= save_in
;
694 *str
= input_line_pointer
;
695 input_line_pointer
= save_in
;
699 /* Turn a string in input_line_pointer into a floating point constant
700 of type TYPE, and store the appropriate bytes in *LITP. The number
701 of LITTLENUMS emitted is stored in *SIZEP. An error message is
702 returned, or NULL on OK.
704 Note that fp constants aren't represent in the normal way on the ARM.
705 In big endian mode, things are as expected. However, in little endian
706 mode fp constants are big-endian word-wise, and little-endian byte-wise
707 within the words. For example, (double) 1.1 in big endian mode is
708 the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is
709 the byte sequence 99 99 f1 3f 9a 99 99 99.
711 ??? The format of 12 byte floats is uncertain according to gcc's arm.h. */
714 md_atof (int type
, char * litP
, int * sizeP
)
717 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
749 return _("bad call to MD_ATOF()");
752 t
= atof_ieee (input_line_pointer
, type
, words
);
754 input_line_pointer
= t
;
757 if (target_big_endian
)
759 for (i
= 0; i
< prec
; i
++)
761 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
767 if (cpu_variant
& FPU_ARCH_VFP
)
768 for (i
= prec
- 1; i
>= 0; i
--)
770 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
774 /* For a 4 byte float the order of elements in `words' is 1 0.
775 For an 8 byte float the order is 1 0 3 2. */
776 for (i
= 0; i
< prec
; i
+= 2)
778 md_number_to_chars (litP
, (valueT
) words
[i
+ 1], 2);
779 md_number_to_chars (litP
+ 2, (valueT
) words
[i
], 2);
787 /* We handle all bad expressions here, so that we can report the faulty
788 instruction in the error message. */
790 md_operand (expressionS
* expr
)
792 if (in_my_get_expression
)
793 expr
->X_op
= O_illegal
;
796 /* Immediate values. */
798 /* Generic immediate-value read function for use in directives.
799 Accepts anything that 'expression' can fold to a constant.
800 *val receives the number. */
803 immediate_for_directive (int *val
)
806 exp
.X_op
= O_illegal
;
808 if (is_immediate_prefix (*input_line_pointer
))
810 input_line_pointer
++;
814 if (exp
.X_op
!= O_constant
)
816 as_bad (_("expected #constant"));
817 ignore_rest_of_line ();
820 *val
= exp
.X_add_number
;
825 /* Register parsing. */
827 /* Generic register parser. CCP points to what should be the
828 beginning of a register name. If it is indeed a valid register
829 name, advance CCP over it and return the reg_entry structure;
830 otherwise return NULL. Does not issue diagnostics. */
832 static struct reg_entry
*
833 arm_reg_parse_multi (char **ccp
)
837 struct reg_entry
*reg
;
839 #ifdef REGISTER_PREFIX
840 if (*start
!= REGISTER_PREFIX
)
844 #ifdef OPTIONAL_REGISTER_PREFIX
845 if (*start
== OPTIONAL_REGISTER_PREFIX
)
850 if (!ISALPHA (*p
) || !is_name_beginner (*p
))
855 while (ISALPHA (*p
) || ISDIGIT (*p
) || *p
== '_');
857 reg
= (struct reg_entry
*) hash_find_n (arm_reg_hsh
, start
, p
- start
);
866 /* As above, but the register must be of type TYPE, and the return
867 value is the register number or NULL. */
870 arm_reg_parse (char **ccp
, enum arm_reg_type type
)
873 struct reg_entry
*reg
= arm_reg_parse_multi (ccp
);
875 if (reg
&& reg
->type
== type
)
878 /* Alternative syntaxes are accepted for a few register classes. */
885 /* Generic coprocessor register names are allowed for these. */
886 if (reg
->type
== REG_TYPE_CN
)
891 /* For backward compatibility, a bare number is valid here. */
893 unsigned long processor
= strtoul (start
, ccp
, 10);
894 if (*ccp
!= start
&& processor
<= 15)
899 /* WC includes WCG. ??? I'm not sure this is true for all
900 instructions that take WC registers. */
901 if (reg
->type
== REG_TYPE_MMXWCG
)
913 /* Parse an ARM register list. Returns the bitmask, or FAIL. */
915 parse_reg_list (char ** strp
)
921 /* We come back here if we get ranges concatenated by '+' or '|'. */
936 if ((reg
= arm_reg_parse (&str
, REG_TYPE_RN
)) == FAIL
)
938 inst
.error
= _(reg_expected_msgs
[REG_TYPE_RN
]);
948 inst
.error
= _("bad range in register list");
952 for (i
= cur_reg
+ 1; i
< reg
; i
++)
954 if (range
& (1 << i
))
956 (_("Warning: duplicated register (r%d) in register list"),
964 if (range
& (1 << reg
))
965 as_tsktsk (_("Warning: duplicated register (r%d) in register list"),
967 else if (reg
<= cur_reg
)
968 as_tsktsk (_("Warning: register range not in ascending order"));
973 while (skip_past_comma (&str
) != FAIL
974 || (in_range
= 1, *str
++ == '-'));
979 inst
.error
= _("missing `}'");
987 if (my_get_expression (&expr
, &str
, GE_NO_PREFIX
))
990 if (expr
.X_op
== O_constant
)
992 if (expr
.X_add_number
993 != (expr
.X_add_number
& 0x0000ffff))
995 inst
.error
= _("invalid register mask");
999 if ((range
& expr
.X_add_number
) != 0)
1001 int regno
= range
& expr
.X_add_number
;
1004 regno
= (1 << regno
) - 1;
1006 (_("Warning: duplicated register (r%d) in register list"),
1010 range
|= expr
.X_add_number
;
1014 if (inst
.reloc
.type
!= 0)
1016 inst
.error
= _("expression too complex");
1020 memcpy (&inst
.reloc
.exp
, &expr
, sizeof (expressionS
));
1021 inst
.reloc
.type
= BFD_RELOC_ARM_MULTI
;
1022 inst
.reloc
.pc_rel
= 0;
1026 if (*str
== '|' || *str
== '+')
1032 while (another_range
);
1038 /* Parse a VFP register list. If the string is invalid return FAIL.
1039 Otherwise return the number of registers, and set PBASE to the first
1040 register. Double precision registers are matched if DP is nonzero. */
1043 parse_vfp_reg_list (char **str
, unsigned int *pbase
, int dp
)
1051 unsigned long mask
= 0;
1061 regtype
= REG_TYPE_VFD
;
1066 regtype
= REG_TYPE_VFS
;
1070 base_reg
= max_regs
;
1074 new_base
= arm_reg_parse (str
, regtype
);
1075 if (new_base
== FAIL
)
1077 inst
.error
= gettext (reg_expected_msgs
[regtype
]);
1081 if (new_base
< base_reg
)
1082 base_reg
= new_base
;
1084 if (mask
& (1 << new_base
))
1086 inst
.error
= _("invalid register list");
1090 if ((mask
>> new_base
) != 0 && ! warned
)
1092 as_tsktsk (_("register list not in ascending order"));
1096 mask
|= 1 << new_base
;
1099 if (**str
== '-') /* We have the start of a range expression */
1105 if ((high_range
= arm_reg_parse (str
, regtype
)) == FAIL
)
1107 inst
.error
= gettext (reg_expected_msgs
[regtype
]);
1111 if (high_range
<= new_base
)
1113 inst
.error
= _("register range not in ascending order");
1117 for (new_base
++; new_base
<= high_range
; new_base
++)
1119 if (mask
& (1 << new_base
))
1121 inst
.error
= _("invalid register list");
1125 mask
|= 1 << new_base
;
1130 while (skip_past_comma (str
) != FAIL
);
1134 /* Sanity check -- should have raised a parse error above. */
1135 if (count
== 0 || count
> max_regs
)
1140 /* Final test -- the registers must be consecutive. */
1142 for (i
= 0; i
< count
; i
++)
1144 if ((mask
& (1u << i
)) == 0)
1146 inst
.error
= _("non-contiguous register range");
1154 /* Parse an explicit relocation suffix on an expression. This is
1155 either nothing, or a word in parentheses. Note that if !OBJ_ELF,
1156 arm_reloc_hsh contains no entries, so this function can only
1157 succeed if there is no () after the word. Returns -1 on error,
1158 BFD_RELOC_UNUSED if there wasn't any suffix. */
1160 parse_reloc (char **str
)
1162 struct reloc_entry
*r
;
1166 return BFD_RELOC_UNUSED
;
1171 while (*q
&& *q
!= ')' && *q
!= ',')
1176 if ((r
= hash_find_n (arm_reloc_hsh
, p
, q
- p
)) == NULL
)
1183 /* Directives: register aliases. */
1186 insert_reg_alias (char *str
, int number
, int type
)
1188 struct reg_entry
*new;
1191 if ((new = hash_find (arm_reg_hsh
, str
)) != 0)
1194 as_warn (_("ignoring attempt to redefine built-in register '%s'"), str
);
1196 /* Only warn about a redefinition if it's not defined as the
1198 else if (new->number
!= number
|| new->type
!= type
)
1199 as_warn (_("ignoring redefinition of register alias '%s'"), str
);
1204 name
= xstrdup (str
);
1205 new = xmalloc (sizeof (struct reg_entry
));
1208 new->number
= number
;
1210 new->builtin
= FALSE
;
1212 if (hash_insert (arm_reg_hsh
, name
, (PTR
) new))
1216 /* Look for the .req directive. This is of the form:
1218 new_register_name .req existing_register_name
1220 If we find one, or if it looks sufficiently like one that we want to
1221 handle any error here, return non-zero. Otherwise return zero. */
1224 create_register_alias (char * newname
, char *p
)
1226 struct reg_entry
*old
;
1227 char *oldname
, *nbuf
;
1230 /* The input scrubber ensures that whitespace after the mnemonic is
1231 collapsed to single spaces. */
1233 if (strncmp (oldname
, " .req ", 6) != 0)
1237 if (*oldname
== '\0')
1240 old
= hash_find (arm_reg_hsh
, oldname
);
1243 as_warn (_("unknown register '%s' -- .req ignored"), oldname
);
1247 /* If TC_CASE_SENSITIVE is defined, then newname already points to
1248 the desired alias name, and p points to its end. If not, then
1249 the desired alias name is in the global original_case_string. */
1250 #ifdef TC_CASE_SENSITIVE
1253 newname
= original_case_string
;
1254 nlen
= strlen (newname
);
1257 nbuf
= alloca (nlen
+ 1);
1258 memcpy (nbuf
, newname
, nlen
);
1261 /* Create aliases under the new name as stated; an all-lowercase
1262 version of the new name; and an all-uppercase version of the new
1264 insert_reg_alias (nbuf
, old
->number
, old
->type
);
1266 for (p
= nbuf
; *p
; p
++)
1269 if (strncmp (nbuf
, newname
, nlen
))
1270 insert_reg_alias (nbuf
, old
->number
, old
->type
);
1272 for (p
= nbuf
; *p
; p
++)
1275 if (strncmp (nbuf
, newname
, nlen
))
1276 insert_reg_alias (nbuf
, old
->number
, old
->type
);
1281 /* Should never be called, as .req goes between the alias and the
1282 register name, not at the beginning of the line. */
1284 s_req (int a ATTRIBUTE_UNUSED
)
1286 as_bad (_("invalid syntax for .req directive"));
1289 /* The .unreq directive deletes an alias which was previously defined
1290 by .req. For example:
1296 s_unreq (int a ATTRIBUTE_UNUSED
)
1301 name
= input_line_pointer
;
1303 while (*input_line_pointer
!= 0
1304 && *input_line_pointer
!= ' '
1305 && *input_line_pointer
!= '\n')
1306 ++input_line_pointer
;
1308 saved_char
= *input_line_pointer
;
1309 *input_line_pointer
= 0;
1312 as_bad (_("invalid syntax for .unreq directive"));
1315 struct reg_entry
*reg
= hash_find (arm_reg_hsh
, name
);
1318 as_bad (_("unknown register alias '%s'"), name
);
1319 else if (reg
->builtin
)
1320 as_warn (_("ignoring attempt to undefine built-in register '%s'"),
1324 hash_delete (arm_reg_hsh
, name
);
1325 free ((char *) reg
->name
);
1330 *input_line_pointer
= saved_char
;
1331 demand_empty_rest_of_line ();
1334 /* Directives: Instruction set selection. */
1337 /* This code is to handle mapping symbols as defined in the ARM ELF spec.
1338 (See "Mapping symbols", section 4.5.5, ARM AAELF version 1.0).
1339 Note that previously, $a and $t has type STT_FUNC (BSF_OBJECT flag),
1340 and $d has type STT_OBJECT (BSF_OBJECT flag). Now all three are untyped. */
1342 static enum mstate mapstate
= MAP_UNDEFINED
;
1345 mapping_state (enum mstate state
)
1348 const char * symname
;
1351 if (mapstate
== state
)
1352 /* The mapping symbol has already been emitted.
1353 There is nothing else to do. */
1362 type
= BSF_NO_FLAGS
;
1366 type
= BSF_NO_FLAGS
;
1370 type
= BSF_NO_FLAGS
;
1378 seg_info (now_seg
)->tc_segment_info_data
.mapstate
= state
;
1380 symbolP
= symbol_new (symname
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
1381 symbol_table_insert (symbolP
);
1382 symbol_get_bfdsym (symbolP
)->flags
|= type
| BSF_LOCAL
;
1387 THUMB_SET_FUNC (symbolP
, 0);
1388 ARM_SET_THUMB (symbolP
, 0);
1389 ARM_SET_INTERWORK (symbolP
, support_interwork
);
1393 THUMB_SET_FUNC (symbolP
, 1);
1394 ARM_SET_THUMB (symbolP
, 1);
1395 ARM_SET_INTERWORK (symbolP
, support_interwork
);
1404 #define mapping_state(x) /* nothing */
1407 /* Find the real, Thumb encoded start of a Thumb function. */
1410 find_real_start (symbolS
* symbolP
)
1413 const char * name
= S_GET_NAME (symbolP
);
1414 symbolS
* new_target
;
1416 /* This definition must agree with the one in gcc/config/arm/thumb.c. */
1417 #define STUB_NAME ".real_start_of"
1422 /* The compiler may generate BL instructions to local labels because
1423 it needs to perform a branch to a far away location. These labels
1424 do not have a corresponding ".real_start_of" label. We check
1425 both for S_IS_LOCAL and for a leading dot, to give a way to bypass
1426 the ".real_start_of" convention for nonlocal branches. */
1427 if (S_IS_LOCAL (symbolP
) || name
[0] == '.')
1430 real_start
= ACONCAT ((STUB_NAME
, name
, NULL
));
1431 new_target
= symbol_find (real_start
);
1433 if (new_target
== NULL
)
1435 as_warn ("Failed to find real start of function: %s\n", name
);
1436 new_target
= symbolP
;
1443 opcode_select (int width
)
1450 if (! (cpu_variant
& ARM_EXT_V4T
))
1451 as_bad (_("selected processor does not support THUMB opcodes"));
1454 /* No need to force the alignment, since we will have been
1455 coming from ARM mode, which is word-aligned. */
1456 record_alignment (now_seg
, 1);
1458 mapping_state (MAP_THUMB
);
1464 if ((cpu_variant
& ARM_ALL
) == ARM_EXT_V4T
)
1465 as_bad (_("selected processor does not support ARM opcodes"));
1470 frag_align (2, 0, 0);
1472 record_alignment (now_seg
, 1);
1474 mapping_state (MAP_ARM
);
1478 as_bad (_("invalid instruction size selected (%d)"), width
);
1483 s_arm (int ignore ATTRIBUTE_UNUSED
)
1486 demand_empty_rest_of_line ();
1490 s_thumb (int ignore ATTRIBUTE_UNUSED
)
1493 demand_empty_rest_of_line ();
1497 s_code (int unused ATTRIBUTE_UNUSED
)
1501 temp
= get_absolute_expression ();
1506 opcode_select (temp
);
1510 as_bad (_("invalid operand to .code directive (%d) (expecting 16 or 32)"), temp
);
1515 s_force_thumb (int ignore ATTRIBUTE_UNUSED
)
1517 /* If we are not already in thumb mode go into it, EVEN if
1518 the target processor does not support thumb instructions.
1519 This is used by gcc/config/arm/lib1funcs.asm for example
1520 to compile interworking support functions even if the
1521 target processor should not support interworking. */
1525 record_alignment (now_seg
, 1);
1528 demand_empty_rest_of_line ();
1532 s_thumb_func (int ignore ATTRIBUTE_UNUSED
)
1536 /* The following label is the name/address of the start of a Thumb function.
1537 We need to know this for the interworking support. */
1538 label_is_thumb_function_name
= TRUE
;
1541 /* Perform a .set directive, but also mark the alias as
1542 being a thumb function. */
1545 s_thumb_set (int equiv
)
1547 /* XXX the following is a duplicate of the code for s_set() in read.c
1548 We cannot just call that code as we need to get at the symbol that
1555 /* Especial apologies for the random logic:
1556 This just grew, and could be parsed much more simply!
1558 name
= input_line_pointer
;
1559 delim
= get_symbol_end ();
1560 end_name
= input_line_pointer
;
1563 if (*input_line_pointer
!= ',')
1566 as_bad (_("expected comma after name \"%s\""), name
);
1568 ignore_rest_of_line ();
1572 input_line_pointer
++;
1575 if (name
[0] == '.' && name
[1] == '\0')
1577 /* XXX - this should not happen to .thumb_set. */
1581 if ((symbolP
= symbol_find (name
)) == NULL
1582 && (symbolP
= md_undefined_symbol (name
)) == NULL
)
1585 /* When doing symbol listings, play games with dummy fragments living
1586 outside the normal fragment chain to record the file and line info
1588 if (listing
& LISTING_SYMBOLS
)
1590 extern struct list_info_struct
* listing_tail
;
1591 fragS
* dummy_frag
= xmalloc (sizeof (fragS
));
1593 memset (dummy_frag
, 0, sizeof (fragS
));
1594 dummy_frag
->fr_type
= rs_fill
;
1595 dummy_frag
->line
= listing_tail
;
1596 symbolP
= symbol_new (name
, undefined_section
, 0, dummy_frag
);
1597 dummy_frag
->fr_symbol
= symbolP
;
1601 symbolP
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
1604 /* "set" symbols are local unless otherwise specified. */
1605 SF_SET_LOCAL (symbolP
);
1606 #endif /* OBJ_COFF */
1607 } /* Make a new symbol. */
1609 symbol_table_insert (symbolP
);
1614 && S_IS_DEFINED (symbolP
)
1615 && S_GET_SEGMENT (symbolP
) != reg_section
)
1616 as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP
));
1618 pseudo_set (symbolP
);
1620 demand_empty_rest_of_line ();
1622 /* XXX Now we come to the Thumb specific bit of code. */
1624 THUMB_SET_FUNC (symbolP
, 1);
1625 ARM_SET_THUMB (symbolP
, 1);
1626 #if defined OBJ_ELF || defined OBJ_COFF
1627 ARM_SET_INTERWORK (symbolP
, support_interwork
);
1631 /* Directives: Mode selection. */
1633 /* .syntax [unified|divided] - choose the new unified syntax
1634 (same for Arm and Thumb encoding, modulo slight differences in what
1635 can be represented) or the old divergent syntax for each mode. */
1637 s_syntax (int unused ATTRIBUTE_UNUSED
)
1641 name
= input_line_pointer
;
1642 delim
= get_symbol_end ();
1644 if (!strcasecmp (name
, "unified"))
1645 unified_syntax
= TRUE
;
1646 else if (!strcasecmp (name
, "divided"))
1647 unified_syntax
= FALSE
;
1650 as_bad (_("unrecognized syntax mode \"%s\""), name
);
1653 *input_line_pointer
= delim
;
1654 demand_empty_rest_of_line ();
1657 /* Directives: sectioning and alignment. */
1659 /* Same as s_align_ptwo but align 0 => align 2. */
1662 s_align (int unused ATTRIBUTE_UNUSED
)
1666 long max_alignment
= 15;
1668 temp
= get_absolute_expression ();
1669 if (temp
> max_alignment
)
1670 as_bad (_("alignment too large: %d assumed"), temp
= max_alignment
);
1673 as_bad (_("alignment negative. 0 assumed."));
1677 if (*input_line_pointer
== ',')
1679 input_line_pointer
++;
1680 temp_fill
= get_absolute_expression ();
1688 /* Only make a frag if we HAVE to. */
1689 if (temp
&& !need_pass_2
)
1690 frag_align (temp
, (int) temp_fill
, 0);
1691 demand_empty_rest_of_line ();
1693 record_alignment (now_seg
, temp
);
1697 s_bss (int ignore ATTRIBUTE_UNUSED
)
1699 /* We don't support putting frags in the BSS segment, we fake it by
1700 marking in_bss, then looking at s_skip for clues. */
1701 subseg_set (bss_section
, 0);
1702 demand_empty_rest_of_line ();
1703 mapping_state (MAP_DATA
);
1707 s_even (int ignore ATTRIBUTE_UNUSED
)
1709 /* Never make frag if expect extra pass. */
1711 frag_align (1, 0, 0);
1713 record_alignment (now_seg
, 1);
1715 demand_empty_rest_of_line ();
1718 /* Directives: Literal pools. */
1720 static literal_pool
*
1721 find_literal_pool (void)
1723 literal_pool
* pool
;
1725 for (pool
= list_of_pools
; pool
!= NULL
; pool
= pool
->next
)
1727 if (pool
->section
== now_seg
1728 && pool
->sub_section
== now_subseg
)
1735 static literal_pool
*
1736 find_or_make_literal_pool (void)
1738 /* Next literal pool ID number. */
1739 static unsigned int latest_pool_num
= 1;
1740 literal_pool
* pool
;
1742 pool
= find_literal_pool ();
1746 /* Create a new pool. */
1747 pool
= xmalloc (sizeof (* pool
));
1751 pool
->next_free_entry
= 0;
1752 pool
->section
= now_seg
;
1753 pool
->sub_section
= now_subseg
;
1754 pool
->next
= list_of_pools
;
1755 pool
->symbol
= NULL
;
1757 /* Add it to the list. */
1758 list_of_pools
= pool
;
1761 /* New pools, and emptied pools, will have a NULL symbol. */
1762 if (pool
->symbol
== NULL
)
1764 pool
->symbol
= symbol_create (FAKE_LABEL_NAME
, undefined_section
,
1765 (valueT
) 0, &zero_address_frag
);
1766 pool
->id
= latest_pool_num
++;
1773 /* Add the literal in the global 'inst'
1774 structure to the relevent literal pool. */
1777 add_to_lit_pool (void)
1779 literal_pool
* pool
;
1782 pool
= find_or_make_literal_pool ();
1784 /* Check if this literal value is already in the pool. */
1785 for (entry
= 0; entry
< pool
->next_free_entry
; entry
++)
1787 if ((pool
->literals
[entry
].X_op
== inst
.reloc
.exp
.X_op
)
1788 && (inst
.reloc
.exp
.X_op
== O_constant
)
1789 && (pool
->literals
[entry
].X_add_number
1790 == inst
.reloc
.exp
.X_add_number
)
1791 && (pool
->literals
[entry
].X_unsigned
1792 == inst
.reloc
.exp
.X_unsigned
))
1795 if ((pool
->literals
[entry
].X_op
== inst
.reloc
.exp
.X_op
)
1796 && (inst
.reloc
.exp
.X_op
== O_symbol
)
1797 && (pool
->literals
[entry
].X_add_number
1798 == inst
.reloc
.exp
.X_add_number
)
1799 && (pool
->literals
[entry
].X_add_symbol
1800 == inst
.reloc
.exp
.X_add_symbol
)
1801 && (pool
->literals
[entry
].X_op_symbol
1802 == inst
.reloc
.exp
.X_op_symbol
))
1806 /* Do we need to create a new entry? */
1807 if (entry
== pool
->next_free_entry
)
1809 if (entry
>= MAX_LITERAL_POOL_SIZE
)
1811 inst
.error
= _("literal pool overflow");
1815 pool
->literals
[entry
] = inst
.reloc
.exp
;
1816 pool
->next_free_entry
+= 1;
1819 inst
.reloc
.exp
.X_op
= O_symbol
;
1820 inst
.reloc
.exp
.X_add_number
= ((int) entry
) * 4;
1821 inst
.reloc
.exp
.X_add_symbol
= pool
->symbol
;
1826 /* Can't use symbol_new here, so have to create a symbol and then at
1827 a later date assign it a value. Thats what these functions do. */
1830 symbol_locate (symbolS
* symbolP
,
1831 const char * name
, /* It is copied, the caller can modify. */
1832 segT segment
, /* Segment identifier (SEG_<something>). */
1833 valueT valu
, /* Symbol value. */
1834 fragS
* frag
) /* Associated fragment. */
1836 unsigned int name_length
;
1837 char * preserved_copy_of_name
;
1839 name_length
= strlen (name
) + 1; /* +1 for \0. */
1840 obstack_grow (¬es
, name
, name_length
);
1841 preserved_copy_of_name
= obstack_finish (¬es
);
1843 #ifdef tc_canonicalize_symbol_name
1844 preserved_copy_of_name
=
1845 tc_canonicalize_symbol_name (preserved_copy_of_name
);
1848 S_SET_NAME (symbolP
, preserved_copy_of_name
);
1850 S_SET_SEGMENT (symbolP
, segment
);
1851 S_SET_VALUE (symbolP
, valu
);
1852 symbol_clear_list_pointers (symbolP
);
1854 symbol_set_frag (symbolP
, frag
);
1856 /* Link to end of symbol chain. */
1858 extern int symbol_table_frozen
;
1860 if (symbol_table_frozen
)
1864 symbol_append (symbolP
, symbol_lastP
, & symbol_rootP
, & symbol_lastP
);
1866 obj_symbol_new_hook (symbolP
);
1868 #ifdef tc_symbol_new_hook
1869 tc_symbol_new_hook (symbolP
);
1873 verify_symbol_chain (symbol_rootP
, symbol_lastP
);
1874 #endif /* DEBUG_SYMS */
1879 s_ltorg (int ignored ATTRIBUTE_UNUSED
)
1882 literal_pool
* pool
;
1885 pool
= find_literal_pool ();
1887 || pool
->symbol
== NULL
1888 || pool
->next_free_entry
== 0)
1891 mapping_state (MAP_DATA
);
1893 /* Align pool as you have word accesses.
1894 Only make a frag if we have to. */
1896 frag_align (2, 0, 0);
1898 record_alignment (now_seg
, 2);
1900 sprintf (sym_name
, "$$lit_\002%x", pool
->id
);
1902 symbol_locate (pool
->symbol
, sym_name
, now_seg
,
1903 (valueT
) frag_now_fix (), frag_now
);
1904 symbol_table_insert (pool
->symbol
);
1906 ARM_SET_THUMB (pool
->symbol
, thumb_mode
);
1908 #if defined OBJ_COFF || defined OBJ_ELF
1909 ARM_SET_INTERWORK (pool
->symbol
, support_interwork
);
1912 for (entry
= 0; entry
< pool
->next_free_entry
; entry
++)
1913 /* First output the expression in the instruction to the pool. */
1914 emit_expr (&(pool
->literals
[entry
]), 4); /* .word */
1916 /* Mark the pool as empty. */
1917 pool
->next_free_entry
= 0;
1918 pool
->symbol
= NULL
;
1922 /* Forward declarations for functions below, in the MD interface
1924 static void fix_new_arm (fragS
*, int, short, expressionS
*, int, int);
1925 static valueT
create_unwind_entry (int);
1926 static void start_unwind_section (const segT
, int);
1927 static void add_unwind_opcode (valueT
, int);
1928 static void flush_pending_unwind (void);
1930 /* Directives: Data. */
1933 s_arm_elf_cons (int nbytes
)
1937 #ifdef md_flush_pending_output
1938 md_flush_pending_output ();
1941 if (is_it_end_of_statement ())
1943 demand_empty_rest_of_line ();
1947 #ifdef md_cons_align
1948 md_cons_align (nbytes
);
1951 mapping_state (MAP_DATA
);
1955 char *base
= input_line_pointer
;
1959 if (exp
.X_op
!= O_symbol
)
1960 emit_expr (&exp
, (unsigned int) nbytes
);
1963 char *before_reloc
= input_line_pointer
;
1964 reloc
= parse_reloc (&input_line_pointer
);
1967 as_bad (_("unrecognized relocation suffix"));
1968 ignore_rest_of_line ();
1971 else if (reloc
== BFD_RELOC_UNUSED
)
1972 emit_expr (&exp
, (unsigned int) nbytes
);
1975 reloc_howto_type
*howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
1976 int size
= bfd_get_reloc_size (howto
);
1978 if (reloc
== BFD_RELOC_ARM_PLT32
)
1980 as_bad (_("(plt) is only valid on branch targets"));
1981 reloc
= BFD_RELOC_UNUSED
;
1986 as_bad (_("%s relocations do not fit in %d bytes"),
1987 howto
->name
, nbytes
);
1990 /* We've parsed an expression stopping at O_symbol.
1991 But there may be more expression left now that we
1992 have parsed the relocation marker. Parse it again.
1993 XXX Surely there is a cleaner way to do this. */
1994 char *p
= input_line_pointer
;
1996 char *save_buf
= alloca (input_line_pointer
- base
);
1997 memcpy (save_buf
, base
, input_line_pointer
- base
);
1998 memmove (base
+ (input_line_pointer
- before_reloc
),
1999 base
, before_reloc
- base
);
2001 input_line_pointer
= base
+ (input_line_pointer
-before_reloc
);
2003 memcpy (base
, save_buf
, p
- base
);
2005 offset
= nbytes
- size
;
2006 p
= frag_more ((int) nbytes
);
2007 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ offset
,
2008 size
, &exp
, 0, reloc
);
2013 while (*input_line_pointer
++ == ',');
2015 /* Put terminator back into stream. */
2016 input_line_pointer
--;
2017 demand_empty_rest_of_line ();
2021 /* Parse a .rel31 directive. */
2024 s_arm_rel31 (int ignored ATTRIBUTE_UNUSED
)
2031 if (*input_line_pointer
== '1')
2032 highbit
= 0x80000000;
2033 else if (*input_line_pointer
!= '0')
2034 as_bad (_("expected 0 or 1"));
2036 input_line_pointer
++;
2037 if (*input_line_pointer
!= ',')
2038 as_bad (_("missing comma"));
2039 input_line_pointer
++;
2041 #ifdef md_flush_pending_output
2042 md_flush_pending_output ();
2045 #ifdef md_cons_align
2049 mapping_state (MAP_DATA
);
2054 md_number_to_chars (p
, highbit
, 4);
2055 fix_new_arm (frag_now
, p
- frag_now
->fr_literal
, 4, &exp
, 1,
2056 BFD_RELOC_ARM_PREL31
);
2058 demand_empty_rest_of_line ();
2061 /* Directives: AEABI stack-unwind tables. */
2063 /* Parse an unwind_fnstart directive. Simply records the current location. */
2066 s_arm_unwind_fnstart (int ignored ATTRIBUTE_UNUSED
)
2068 demand_empty_rest_of_line ();
2069 /* Mark the start of the function. */
2070 unwind
.proc_start
= expr_build_dot ();
2072 /* Reset the rest of the unwind info. */
2073 unwind
.opcode_count
= 0;
2074 unwind
.table_entry
= NULL
;
2075 unwind
.personality_routine
= NULL
;
2076 unwind
.personality_index
= -1;
2077 unwind
.frame_size
= 0;
2078 unwind
.fp_offset
= 0;
2081 unwind
.sp_restored
= 0;
2085 /* Parse a handlerdata directive. Creates the exception handling table entry
2086 for the function. */
2089 s_arm_unwind_handlerdata (int ignored ATTRIBUTE_UNUSED
)
2091 demand_empty_rest_of_line ();
2092 if (unwind
.table_entry
)
2093 as_bad (_("dupicate .handlerdata directive"));
2095 create_unwind_entry (1);
2098 /* Parse an unwind_fnend directive. Generates the index table entry. */
2101 s_arm_unwind_fnend (int ignored ATTRIBUTE_UNUSED
)
2107 demand_empty_rest_of_line ();
2109 /* Add eh table entry. */
2110 if (unwind
.table_entry
== NULL
)
2111 val
= create_unwind_entry (0);
2115 /* Add index table entry. This is two words. */
2116 start_unwind_section (unwind
.saved_seg
, 1);
2117 frag_align (2, 0, 0);
2118 record_alignment (now_seg
, 2);
2120 ptr
= frag_more (8);
2121 where
= frag_now_fix () - 8;
2123 /* Self relative offset of the function start. */
2124 fix_new (frag_now
, where
, 4, unwind
.proc_start
, 0, 1,
2125 BFD_RELOC_ARM_PREL31
);
2127 /* Indicate dependency on EHABI-defined personality routines to the
2128 linker, if it hasn't been done already. */
2129 if (unwind
.personality_index
>= 0 && unwind
.personality_index
< 3
2130 && !(marked_pr_dependency
& (1 << unwind
.personality_index
)))
2132 static const char *const name
[] = {
2133 "__aeabi_unwind_cpp_pr0",
2134 "__aeabi_unwind_cpp_pr1",
2135 "__aeabi_unwind_cpp_pr2"
2137 symbolS
*pr
= symbol_find_or_make (name
[unwind
.personality_index
]);
2138 fix_new (frag_now
, where
, 0, pr
, 0, 1, BFD_RELOC_NONE
);
2139 marked_pr_dependency
|= 1 << unwind
.personality_index
;
2140 seg_info (now_seg
)->tc_segment_info_data
.marked_pr_dependency
2141 = marked_pr_dependency
;
2145 /* Inline exception table entry. */
2146 md_number_to_chars (ptr
+ 4, val
, 4);
2148 /* Self relative offset of the table entry. */
2149 fix_new (frag_now
, where
+ 4, 4, unwind
.table_entry
, 0, 1,
2150 BFD_RELOC_ARM_PREL31
);
2152 /* Restore the original section. */
2153 subseg_set (unwind
.saved_seg
, unwind
.saved_subseg
);
2157 /* Parse an unwind_cantunwind directive. */
2160 s_arm_unwind_cantunwind (int ignored ATTRIBUTE_UNUSED
)
2162 demand_empty_rest_of_line ();
2163 if (unwind
.personality_routine
|| unwind
.personality_index
!= -1)
2164 as_bad (_("personality routine specified for cantunwind frame"));
2166 unwind
.personality_index
= -2;
2170 /* Parse a personalityindex directive. */
2173 s_arm_unwind_personalityindex (int ignored ATTRIBUTE_UNUSED
)
2177 if (unwind
.personality_routine
|| unwind
.personality_index
!= -1)
2178 as_bad (_("duplicate .personalityindex directive"));
2182 if (exp
.X_op
!= O_constant
2183 || exp
.X_add_number
< 0 || exp
.X_add_number
> 15)
2185 as_bad (_("bad personality routine number"));
2186 ignore_rest_of_line ();
2190 unwind
.personality_index
= exp
.X_add_number
;
2192 demand_empty_rest_of_line ();
2196 /* Parse a personality directive. */
2199 s_arm_unwind_personality (int ignored ATTRIBUTE_UNUSED
)
2203 if (unwind
.personality_routine
|| unwind
.personality_index
!= -1)
2204 as_bad (_("duplicate .personality directive"));
2206 name
= input_line_pointer
;
2207 c
= get_symbol_end ();
2208 p
= input_line_pointer
;
2209 unwind
.personality_routine
= symbol_find_or_make (name
);
2211 demand_empty_rest_of_line ();
2215 /* Parse a directive saving core registers. */
2218 s_arm_unwind_save_core (void)
2224 range
= parse_reg_list (&input_line_pointer
);
2227 as_bad (_("expected register list"));
2228 ignore_rest_of_line ();
2232 demand_empty_rest_of_line ();
2234 /* Turn .unwind_movsp ip followed by .unwind_save {..., ip, ...}
2235 into .unwind_save {..., sp...}. We aren't bothered about the value of
2236 ip because it is clobbered by calls. */
2237 if (unwind
.sp_restored
&& unwind
.fp_reg
== 12
2238 && (range
& 0x3000) == 0x1000)
2240 unwind
.opcode_count
--;
2241 unwind
.sp_restored
= 0;
2242 range
= (range
| 0x2000) & ~0x1000;
2243 unwind
.pending_offset
= 0;
2246 /* See if we can use the short opcodes. These pop a block of upto 8
2247 registers starting with r4, plus maybe r14. */
2248 for (n
= 0; n
< 8; n
++)
2250 /* Break at the first non-saved register. */
2251 if ((range
& (1 << (n
+ 4))) == 0)
2254 /* See if there are any other bits set. */
2255 if (n
== 0 || (range
& (0xfff0 << n
) & 0xbff0) != 0)
2257 /* Use the long form. */
2258 op
= 0x8000 | ((range
>> 4) & 0xfff);
2259 add_unwind_opcode (op
, 2);
2263 /* Use the short form. */
2265 op
= 0xa8; /* Pop r14. */
2267 op
= 0xa0; /* Do not pop r14. */
2269 add_unwind_opcode (op
, 1);
2275 op
= 0xb100 | (range
& 0xf);
2276 add_unwind_opcode (op
, 2);
2279 /* Record the number of bytes pushed. */
2280 for (n
= 0; n
< 16; n
++)
2282 if (range
& (1 << n
))
2283 unwind
.frame_size
+= 4;
2288 /* Parse a directive saving FPA registers. */
2291 s_arm_unwind_save_fpa (int reg
)
2297 /* Get Number of registers to transfer. */
2298 if (skip_past_comma (&input_line_pointer
) != FAIL
)
2301 exp
.X_op
= O_illegal
;
2303 if (exp
.X_op
!= O_constant
)
2305 as_bad (_("expected , <constant>"));
2306 ignore_rest_of_line ();
2310 num_regs
= exp
.X_add_number
;
2312 if (num_regs
< 1 || num_regs
> 4)
2314 as_bad (_("number of registers must be in the range [1:4]"));
2315 ignore_rest_of_line ();
2319 demand_empty_rest_of_line ();
2324 op
= 0xb4 | (num_regs
- 1);
2325 add_unwind_opcode (op
, 1);
2330 op
= 0xc800 | (reg
<< 4) | (num_regs
- 1);
2331 add_unwind_opcode (op
, 2);
2333 unwind
.frame_size
+= num_regs
* 12;
2337 /* Parse a directive saving VFP registers. */
2340 s_arm_unwind_save_vfp (void)
2346 count
= parse_vfp_reg_list (&input_line_pointer
, ®
, 1);
2349 as_bad (_("expected register list"));
2350 ignore_rest_of_line ();
2354 demand_empty_rest_of_line ();
2359 op
= 0xb8 | (count
- 1);
2360 add_unwind_opcode (op
, 1);
2365 op
= 0xb300 | (reg
<< 4) | (count
- 1);
2366 add_unwind_opcode (op
, 2);
2368 unwind
.frame_size
+= count
* 8 + 4;
2372 /* Parse a directive saving iWMMXt data registers. */
2375 s_arm_unwind_save_mmxwr (void)
2383 if (*input_line_pointer
== '{')
2384 input_line_pointer
++;
2388 reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_MMXWR
);
2392 as_bad (_(reg_expected_msgs
[REG_TYPE_MMXWR
]));
2397 as_tsktsk (_("register list not in ascending order"));
2400 if (*input_line_pointer
== '-')
2402 input_line_pointer
++;
2403 hi_reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_MMXWR
);
2406 as_bad (_(reg_expected_msgs
[REG_TYPE_MMXWR
]));
2409 else if (reg
>= hi_reg
)
2411 as_bad (_("bad register range"));
2414 for (; reg
< hi_reg
; reg
++)
2418 while (skip_past_comma (&input_line_pointer
) != FAIL
);
2420 if (*input_line_pointer
== '}')
2421 input_line_pointer
++;
2423 demand_empty_rest_of_line ();
2425 /* Generate any deferred opcodes becuuse we're going to be looking at
2427 flush_pending_unwind ();
2429 for (i
= 0; i
< 16; i
++)
2431 if (mask
& (1 << i
))
2432 unwind
.frame_size
+= 8;
2435 /* Attempt to combine with a previous opcode. We do this because gcc
2436 likes to output separate unwind directives for a single block of
2438 if (unwind
.opcode_count
> 0)
2440 i
= unwind
.opcodes
[unwind
.opcode_count
- 1];
2441 if ((i
& 0xf8) == 0xc0)
2444 /* Only merge if the blocks are contiguous. */
2447 if ((mask
& 0xfe00) == (1 << 9))
2449 mask
|= ((1 << (i
+ 11)) - 1) & 0xfc00;
2450 unwind
.opcode_count
--;
2453 else if (i
== 6 && unwind
.opcode_count
>= 2)
2455 i
= unwind
.opcodes
[unwind
.opcode_count
- 2];
2459 op
= 0xffff << (reg
- 1);
2461 || ((mask
& op
) == (1u << (reg
- 1))))
2463 op
= (1 << (reg
+ i
+ 1)) - 1;
2464 op
&= ~((1 << reg
) - 1);
2466 unwind
.opcode_count
-= 2;
2473 /* We want to generate opcodes in the order the registers have been
2474 saved, ie. descending order. */
2475 for (reg
= 15; reg
>= -1; reg
--)
2477 /* Save registers in blocks. */
2479 || !(mask
& (1 << reg
)))
2481 /* We found an unsaved reg. Generate opcodes to save the
2482 preceeding block. */
2488 op
= 0xc0 | (hi_reg
- 10);
2489 add_unwind_opcode (op
, 1);
2494 op
= 0xc600 | ((reg
+ 1) << 4) | ((hi_reg
- reg
) - 1);
2495 add_unwind_opcode (op
, 2);
2504 ignore_rest_of_line ();
2508 s_arm_unwind_save_mmxwcg (void)
2515 if (*input_line_pointer
== '{')
2516 input_line_pointer
++;
2520 reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_MMXWCG
);
2524 as_bad (_(reg_expected_msgs
[REG_TYPE_MMXWCG
]));
2530 as_tsktsk (_("register list not in ascending order"));
2533 if (*input_line_pointer
== '-')
2535 input_line_pointer
++;
2536 hi_reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_MMXWCG
);
2539 as_bad (_(reg_expected_msgs
[REG_TYPE_MMXWCG
]));
2542 else if (reg
>= hi_reg
)
2544 as_bad (_("bad register range"));
2547 for (; reg
< hi_reg
; reg
++)
2551 while (skip_past_comma (&input_line_pointer
) != FAIL
);
2553 if (*input_line_pointer
== '}')
2554 input_line_pointer
++;
2556 demand_empty_rest_of_line ();
2558 /* Generate any deferred opcodes becuuse we're going to be looking at
2560 flush_pending_unwind ();
2562 for (reg
= 0; reg
< 16; reg
++)
2564 if (mask
& (1 << reg
))
2565 unwind
.frame_size
+= 4;
2568 add_unwind_opcode (op
, 2);
2571 ignore_rest_of_line ();
2575 /* Parse an unwind_save directive. */
2578 s_arm_unwind_save (int ignored ATTRIBUTE_UNUSED
)
2581 struct reg_entry
*reg
;
2582 bfd_boolean had_brace
= FALSE
;
2584 /* Figure out what sort of save we have. */
2585 peek
= input_line_pointer
;
2593 reg
= arm_reg_parse_multi (&peek
);
2597 as_bad (_("register expected"));
2598 ignore_rest_of_line ();
2607 as_bad (_("FPA .unwind_save does not take a register list"));
2608 ignore_rest_of_line ();
2611 s_arm_unwind_save_fpa (reg
->number
);
2614 case REG_TYPE_RN
: s_arm_unwind_save_core (); return;
2615 case REG_TYPE_VFD
: s_arm_unwind_save_vfp (); return;
2616 case REG_TYPE_MMXWR
: s_arm_unwind_save_mmxwr (); return;
2617 case REG_TYPE_MMXWCG
: s_arm_unwind_save_mmxwcg (); return;
2620 as_bad (_(".unwind_save does not support this kind of register"));
2621 ignore_rest_of_line ();
2626 /* Parse an unwind_movsp directive. */
2629 s_arm_unwind_movsp (int ignored ATTRIBUTE_UNUSED
)
2634 reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_RN
);
2637 as_bad (_(reg_expected_msgs
[REG_TYPE_RN
]));
2638 ignore_rest_of_line ();
2641 demand_empty_rest_of_line ();
2643 if (reg
== REG_SP
|| reg
== REG_PC
)
2645 as_bad (_("SP and PC not permitted in .unwind_movsp directive"));
2649 if (unwind
.fp_reg
!= REG_SP
)
2650 as_bad (_("unexpected .unwind_movsp directive"));
2652 /* Generate opcode to restore the value. */
2654 add_unwind_opcode (op
, 1);
2656 /* Record the information for later. */
2657 unwind
.fp_reg
= reg
;
2658 unwind
.fp_offset
= unwind
.frame_size
;
2659 unwind
.sp_restored
= 1;
2662 /* Parse an unwind_pad directive. */
2665 s_arm_unwind_pad (int ignored ATTRIBUTE_UNUSED
)
2669 if (immediate_for_directive (&offset
) == FAIL
)
2674 as_bad (_("stack increment must be multiple of 4"));
2675 ignore_rest_of_line ();
2679 /* Don't generate any opcodes, just record the details for later. */
2680 unwind
.frame_size
+= offset
;
2681 unwind
.pending_offset
+= offset
;
2683 demand_empty_rest_of_line ();
2686 /* Parse an unwind_setfp directive. */
2689 s_arm_unwind_setfp (int ignored ATTRIBUTE_UNUSED
)
2695 fp_reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_RN
);
2696 if (skip_past_comma (&input_line_pointer
) == FAIL
)
2699 sp_reg
= arm_reg_parse (&input_line_pointer
, REG_TYPE_RN
);
2701 if (fp_reg
== FAIL
|| sp_reg
== FAIL
)
2703 as_bad (_("expected <reg>, <reg>"));
2704 ignore_rest_of_line ();
2708 /* Optional constant. */
2709 if (skip_past_comma (&input_line_pointer
) != FAIL
)
2711 if (immediate_for_directive (&offset
) == FAIL
)
2717 demand_empty_rest_of_line ();
2719 if (sp_reg
!= 13 && sp_reg
!= unwind
.fp_reg
)
2721 as_bad (_("register must be either sp or set by a previous"
2722 "unwind_movsp directive"));
2726 /* Don't generate any opcodes, just record the information for later. */
2727 unwind
.fp_reg
= fp_reg
;
2730 unwind
.fp_offset
= unwind
.frame_size
- offset
;
2732 unwind
.fp_offset
-= offset
;
2735 /* Parse an unwind_raw directive. */
2738 s_arm_unwind_raw (int ignored ATTRIBUTE_UNUSED
)
2741 /* This is an arbitary limit. */
2742 unsigned char op
[16];
2746 if (exp
.X_op
== O_constant
2747 && skip_past_comma (&input_line_pointer
) != FAIL
)
2749 unwind
.frame_size
+= exp
.X_add_number
;
2753 exp
.X_op
= O_illegal
;
2755 if (exp
.X_op
!= O_constant
)
2757 as_bad (_("expected <offset>, <opcode>"));
2758 ignore_rest_of_line ();
2764 /* Parse the opcode. */
2769 as_bad (_("unwind opcode too long"));
2770 ignore_rest_of_line ();
2772 if (exp
.X_op
!= O_constant
|| exp
.X_add_number
& ~0xff)
2774 as_bad (_("invalid unwind opcode"));
2775 ignore_rest_of_line ();
2778 op
[count
++] = exp
.X_add_number
;
2780 /* Parse the next byte. */
2781 if (skip_past_comma (&input_line_pointer
) == FAIL
)
2787 /* Add the opcode bytes in reverse order. */
2789 add_unwind_opcode (op
[count
], 1);
2791 demand_empty_rest_of_line ();
2793 #endif /* OBJ_ELF */
2795 /* This table describes all the machine specific pseudo-ops the assembler
2796 has to support. The fields are:
2797 pseudo-op name without dot
2798 function to call to execute this pseudo-op
2799 Integer arg to pass to the function. */
2801 const pseudo_typeS md_pseudo_table
[] =
2803 /* Never called because '.req' does not start a line. */
2804 { "req", s_req
, 0 },
2805 { "unreq", s_unreq
, 0 },
2806 { "bss", s_bss
, 0 },
2807 { "align", s_align
, 0 },
2808 { "arm", s_arm
, 0 },
2809 { "thumb", s_thumb
, 0 },
2810 { "code", s_code
, 0 },
2811 { "force_thumb", s_force_thumb
, 0 },
2812 { "thumb_func", s_thumb_func
, 0 },
2813 { "thumb_set", s_thumb_set
, 0 },
2814 { "even", s_even
, 0 },
2815 { "ltorg", s_ltorg
, 0 },
2816 { "pool", s_ltorg
, 0 },
2817 { "syntax", s_syntax
, 0 },
2819 { "word", s_arm_elf_cons
, 4 },
2820 { "long", s_arm_elf_cons
, 4 },
2821 { "rel31", s_arm_rel31
, 0 },
2822 { "fnstart", s_arm_unwind_fnstart
, 0 },
2823 { "fnend", s_arm_unwind_fnend
, 0 },
2824 { "cantunwind", s_arm_unwind_cantunwind
, 0 },
2825 { "personality", s_arm_unwind_personality
, 0 },
2826 { "personalityindex", s_arm_unwind_personalityindex
, 0 },
2827 { "handlerdata", s_arm_unwind_handlerdata
, 0 },
2828 { "save", s_arm_unwind_save
, 0 },
2829 { "movsp", s_arm_unwind_movsp
, 0 },
2830 { "pad", s_arm_unwind_pad
, 0 },
2831 { "setfp", s_arm_unwind_setfp
, 0 },
2832 { "unwind_raw", s_arm_unwind_raw
, 0 },
2836 { "extend", float_cons
, 'x' },
2837 { "ldouble", float_cons
, 'x' },
2838 { "packed", float_cons
, 'p' },
2842 /* Parser functions used exclusively in instruction operands. */
2844 /* Generic immediate-value read function for use in insn parsing.
2845 STR points to the beginning of the immediate (the leading #);
2846 VAL receives the value; if the value is outside [MIN, MAX]
2847 issue an error. PREFIX_OPT is true if the immediate prefix is
2851 parse_immediate (char **str
, int *val
, int min
, int max
,
2852 bfd_boolean prefix_opt
)
2855 my_get_expression (&exp
, str
, prefix_opt
? GE_OPT_PREFIX
: GE_IMM_PREFIX
);
2856 if (exp
.X_op
!= O_constant
)
2858 inst
.error
= _("constant expression required");
2862 if (exp
.X_add_number
< min
|| exp
.X_add_number
> max
)
2864 inst
.error
= _("immediate value out of range");
2868 *val
= exp
.X_add_number
;
2872 /* Returns the pseudo-register number of an FPA immediate constant,
2873 or FAIL if there isn't a valid constant here. */
2876 parse_fpa_immediate (char ** str
)
2878 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
2884 /* First try and match exact strings, this is to guarantee
2885 that some formats will work even for cross assembly. */
2887 for (i
= 0; fp_const
[i
]; i
++)
2889 if (strncmp (*str
, fp_const
[i
], strlen (fp_const
[i
])) == 0)
2893 *str
+= strlen (fp_const
[i
]);
2894 if (is_end_of_line
[(unsigned char) **str
])
2900 /* Just because we didn't get a match doesn't mean that the constant
2901 isn't valid, just that it is in a format that we don't
2902 automatically recognize. Try parsing it with the standard
2903 expression routines. */
2905 memset (words
, 0, MAX_LITTLENUMS
* sizeof (LITTLENUM_TYPE
));
2907 /* Look for a raw floating point number. */
2908 if ((save_in
= atof_ieee (*str
, 'x', words
)) != NULL
2909 && is_end_of_line
[(unsigned char) *save_in
])
2911 for (i
= 0; i
< NUM_FLOAT_VALS
; i
++)
2913 for (j
= 0; j
< MAX_LITTLENUMS
; j
++)
2915 if (words
[j
] != fp_values
[i
][j
])
2919 if (j
== MAX_LITTLENUMS
)
2927 /* Try and parse a more complex expression, this will probably fail
2928 unless the code uses a floating point prefix (eg "0f"). */
2929 save_in
= input_line_pointer
;
2930 input_line_pointer
= *str
;
2931 if (expression (&exp
) == absolute_section
2932 && exp
.X_op
== O_big
2933 && exp
.X_add_number
< 0)
2935 /* FIXME: 5 = X_PRECISION, should be #define'd where we can use it.
2937 if (gen_to_words (words
, 5, (long) 15) == 0)
2939 for (i
= 0; i
< NUM_FLOAT_VALS
; i
++)
2941 for (j
= 0; j
< MAX_LITTLENUMS
; j
++)
2943 if (words
[j
] != fp_values
[i
][j
])
2947 if (j
== MAX_LITTLENUMS
)
2949 *str
= input_line_pointer
;
2950 input_line_pointer
= save_in
;
2957 *str
= input_line_pointer
;
2958 input_line_pointer
= save_in
;
2959 inst
.error
= _("invalid FPA immediate expression");
2963 /* Shift operands. */
2966 SHIFT_LSL
, SHIFT_LSR
, SHIFT_ASR
, SHIFT_ROR
, SHIFT_RRX
2969 struct asm_shift_name
2972 enum shift_kind kind
;
2975 /* Third argument to parse_shift. */
2976 enum parse_shift_mode
2978 NO_SHIFT_RESTRICT
, /* Any kind of shift is accepted. */
2979 SHIFT_IMMEDIATE
, /* Shift operand must be an immediate. */
2980 SHIFT_LSL_OR_ASR_IMMEDIATE
, /* Shift must be LSL or ASR immediate. */
2981 SHIFT_ASR_IMMEDIATE
, /* Shift must be ASR immediate. */
2982 SHIFT_LSL_IMMEDIATE
, /* Shift must be LSL immediate. */
2985 /* Parse a <shift> specifier on an ARM data processing instruction.
2986 This has three forms:
2988 (LSL|LSR|ASL|ASR|ROR) Rs
2989 (LSL|LSR|ASL|ASR|ROR) #imm
2992 Note that ASL is assimilated to LSL in the instruction encoding, and
2993 RRX to ROR #0 (which cannot be written as such). */
2996 parse_shift (char **str
, int i
, enum parse_shift_mode mode
)
2998 const struct asm_shift_name
*shift_name
;
2999 enum shift_kind shift
;
3004 for (p
= *str
; ISALPHA (*p
); p
++)
3009 inst
.error
= _("shift expression expected");
3013 shift_name
= hash_find_n (arm_shift_hsh
, *str
, p
- *str
);
3015 if (shift_name
== NULL
)
3017 inst
.error
= _("shift expression expected");
3021 shift
= shift_name
->kind
;
3025 case NO_SHIFT_RESTRICT
:
3026 case SHIFT_IMMEDIATE
: break;
3028 case SHIFT_LSL_OR_ASR_IMMEDIATE
:
3029 if (shift
!= SHIFT_LSL
&& shift
!= SHIFT_ASR
)
3031 inst
.error
= _("'LSL' or 'ASR' required");
3036 case SHIFT_LSL_IMMEDIATE
:
3037 if (shift
!= SHIFT_LSL
)
3039 inst
.error
= _("'LSL' required");
3044 case SHIFT_ASR_IMMEDIATE
:
3045 if (shift
!= SHIFT_ASR
)
3047 inst
.error
= _("'ASR' required");
3055 if (shift
!= SHIFT_RRX
)
3057 /* Whitespace can appear here if the next thing is a bare digit. */
3058 skip_whitespace (p
);
3060 if (mode
== NO_SHIFT_RESTRICT
3061 && (reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) != FAIL
)
3063 inst
.operands
[i
].imm
= reg
;
3064 inst
.operands
[i
].immisreg
= 1;
3066 else if (my_get_expression (&inst
.reloc
.exp
, &p
, GE_IMM_PREFIX
))
3069 inst
.operands
[i
].shift_kind
= shift
;
3070 inst
.operands
[i
].shifted
= 1;
3075 /* Parse a <shifter_operand> for an ARM data processing instruction:
3078 #<immediate>, <rotate>
3082 where <shift> is defined by parse_shift above, and <rotate> is a
3083 multiple of 2 between 0 and 30. Validation of immediate operands
3084 is deferred to md_apply_fix. */
3087 parse_shifter_operand (char **str
, int i
)
3092 if ((value
= arm_reg_parse (str
, REG_TYPE_RN
)) != FAIL
)
3094 inst
.operands
[i
].reg
= value
;
3095 inst
.operands
[i
].isreg
= 1;
3097 /* parse_shift will override this if appropriate */
3098 inst
.reloc
.exp
.X_op
= O_constant
;
3099 inst
.reloc
.exp
.X_add_number
= 0;
3101 if (skip_past_comma (str
) == FAIL
)
3104 /* Shift operation on register. */
3105 return parse_shift (str
, i
, NO_SHIFT_RESTRICT
);
3108 if (my_get_expression (&inst
.reloc
.exp
, str
, GE_IMM_PREFIX
))
3111 if (skip_past_comma (str
) == SUCCESS
)
3113 /* #x, y -- ie explicit rotation by Y. */
3114 if (my_get_expression (&expr
, str
, GE_NO_PREFIX
))
3117 if (expr
.X_op
!= O_constant
|| inst
.reloc
.exp
.X_op
!= O_constant
)
3119 inst
.error
= _("constant expression expected");
3123 value
= expr
.X_add_number
;
3124 if (value
< 0 || value
> 30 || value
% 2 != 0)
3126 inst
.error
= _("invalid rotation");
3129 if (inst
.reloc
.exp
.X_add_number
< 0 || inst
.reloc
.exp
.X_add_number
> 255)
3131 inst
.error
= _("invalid constant");
3135 /* Convert to decoded value. md_apply_fix will put it back. */
3136 inst
.reloc
.exp
.X_add_number
3137 = (((inst
.reloc
.exp
.X_add_number
<< (32 - value
))
3138 | (inst
.reloc
.exp
.X_add_number
>> value
)) & 0xffffffff);
3141 inst
.reloc
.type
= BFD_RELOC_ARM_IMMEDIATE
;
3142 inst
.reloc
.pc_rel
= 0;
3146 /* Parse all forms of an ARM address expression. Information is written
3147 to inst.operands[i] and/or inst.reloc.
3149 Preindexed addressing (.preind=1):
3151 [Rn, #offset] .reg=Rn .reloc.exp=offset
3152 [Rn, +/-Rm] .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
3153 [Rn, +/-Rm, shift] .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
3154 .shift_kind=shift .reloc.exp=shift_imm
3156 These three may have a trailing ! which causes .writeback to be set also.
3158 Postindexed addressing (.postind=1, .writeback=1):
3160 [Rn], #offset .reg=Rn .reloc.exp=offset
3161 [Rn], +/-Rm .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
3162 [Rn], +/-Rm, shift .reg=Rn .imm=Rm .immisreg=1 .negative=0/1
3163 .shift_kind=shift .reloc.exp=shift_imm
3165 Unindexed addressing (.preind=0, .postind=0):
3167 [Rn], {option} .reg=Rn .imm=option .immisreg=0
3171 [Rn]{!} shorthand for [Rn,#0]{!}
3172 =immediate .isreg=0 .reloc.exp=immediate
3173 label .reg=PC .reloc.pc_rel=1 .reloc.exp=label
3175 It is the caller's responsibility to check for addressing modes not
3176 supported by the instruction, and to set inst.reloc.type. */
3179 parse_address (char **str
, int i
)
3184 if (skip_past_char (&p
, '[') == FAIL
)
3186 if (skip_past_char (&p
, '=') == FAIL
)
3188 /* bare address - translate to PC-relative offset */
3189 inst
.reloc
.pc_rel
= 1;
3190 inst
.operands
[i
].reg
= REG_PC
;
3191 inst
.operands
[i
].isreg
= 1;
3192 inst
.operands
[i
].preind
= 1;
3194 /* else a load-constant pseudo op, no special treatment needed here */
3196 if (my_get_expression (&inst
.reloc
.exp
, &p
, GE_NO_PREFIX
))
3203 if ((reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) == FAIL
)
3205 inst
.error
= _(reg_expected_msgs
[REG_TYPE_RN
]);
3208 inst
.operands
[i
].reg
= reg
;
3209 inst
.operands
[i
].isreg
= 1;
3211 if (skip_past_comma (&p
) == SUCCESS
)
3213 inst
.operands
[i
].preind
= 1;
3216 else if (*p
== '-') p
++, inst
.operands
[i
].negative
= 1;
3218 if ((reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) != FAIL
)
3220 inst
.operands
[i
].imm
= reg
;
3221 inst
.operands
[i
].immisreg
= 1;
3223 if (skip_past_comma (&p
) == SUCCESS
)
3224 if (parse_shift (&p
, i
, SHIFT_IMMEDIATE
) == FAIL
)
3229 if (inst
.operands
[i
].negative
)
3231 inst
.operands
[i
].negative
= 0;
3234 if (my_get_expression (&inst
.reloc
.exp
, &p
, GE_IMM_PREFIX
))
3239 if (skip_past_char (&p
, ']') == FAIL
)
3241 inst
.error
= _("']' expected");
3245 if (skip_past_char (&p
, '!') == SUCCESS
)
3246 inst
.operands
[i
].writeback
= 1;
3248 else if (skip_past_comma (&p
) == SUCCESS
)
3250 if (skip_past_char (&p
, '{') == SUCCESS
)
3252 /* [Rn], {expr} - unindexed, with option */
3253 if (parse_immediate (&p
, &inst
.operands
[i
].imm
,
3254 0, 255, TRUE
) == FAIL
)
3257 if (skip_past_char (&p
, '}') == FAIL
)
3259 inst
.error
= _("'}' expected at end of 'option' field");
3262 if (inst
.operands
[i
].preind
)
3264 inst
.error
= _("cannot combine index with option");
3272 inst
.operands
[i
].postind
= 1;
3273 inst
.operands
[i
].writeback
= 1;
3275 if (inst
.operands
[i
].preind
)
3277 inst
.error
= _("cannot combine pre- and post-indexing");
3282 else if (*p
== '-') p
++, inst
.operands
[i
].negative
= 1;
3284 if ((reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) != FAIL
)
3286 inst
.operands
[i
].imm
= reg
;
3287 inst
.operands
[i
].immisreg
= 1;
3289 if (skip_past_comma (&p
) == SUCCESS
)
3290 if (parse_shift (&p
, i
, SHIFT_IMMEDIATE
) == FAIL
)
3295 if (inst
.operands
[i
].negative
)
3297 inst
.operands
[i
].negative
= 0;
3300 if (my_get_expression (&inst
.reloc
.exp
, &p
, GE_IMM_PREFIX
))
3306 /* If at this point neither .preind nor .postind is set, we have a
3307 bare [Rn]{!}, which is shorthand for [Rn,#0]{!}. */
3308 if (inst
.operands
[i
].preind
== 0 && inst
.operands
[i
].postind
== 0)
3310 inst
.operands
[i
].preind
= 1;
3311 inst
.reloc
.exp
.X_op
= O_constant
;
3312 inst
.reloc
.exp
.X_add_number
= 0;
3318 /* Miscellaneous. */
3320 /* Parse a PSR flag operand. The value returned is FAIL on syntax error,
3321 or a bitmask suitable to be or-ed into the ARM msr instruction. */
3323 parse_psr (char **str
)
3326 unsigned long psr_field
;
3328 /* CPSR's and SPSR's can now be lowercase. This is just a convenience
3329 feature for ease of use and backwards compatibility. */
3331 if (*p
== 's' || *p
== 'S')
3332 psr_field
= SPSR_BIT
;
3333 else if (*p
== 'c' || *p
== 'C')
3339 if (strncasecmp (p
, "PSR", 3) != 0)
3345 /* A suffix follows. */
3346 const struct asm_psr
*psr
;
3354 while (ISALNUM (*p
) || *p
== '_');
3356 psr
= hash_find_n (arm_psr_hsh
, start
, p
- start
);
3360 psr_field
|= psr
->field
;
3365 goto error
; /* Garbage after "[CS]PSR". */
3367 psr_field
|= (PSR_c
| PSR_f
);
3373 inst
.error
= _("flag for {c}psr instruction expected");
3377 /* Parse the flags argument to CPSI[ED]. Returns FAIL on error, or a
3378 value suitable for splatting into the AIF field of the instruction. */
3381 parse_cps_flags (char **str
)
3390 case '\0': case ',':
3393 case 'a': case 'A': saw_a_flag
= 1; val
|= 0x4; break;
3394 case 'i': case 'I': saw_a_flag
= 1; val
|= 0x2; break;
3395 case 'f': case 'F': saw_a_flag
= 1; val
|= 0x1; break;
3398 inst
.error
= _("unrecognized CPS flag");
3403 if (saw_a_flag
== 0)
3405 inst
.error
= _("missing CPS flags");
3413 /* Parse an endian specifier ("BE" or "LE", case insensitive);
3414 returns 0 for big-endian, 1 for little-endian, FAIL for an error. */
3417 parse_endian_specifier (char **str
)
3422 if (strncasecmp (s
, "BE", 2))
3424 else if (strncasecmp (s
, "LE", 2))
3428 inst
.error
= _("valid endian specifiers are be or le");
3432 if (ISALNUM (s
[2]) || s
[2] == '_')
3434 inst
.error
= _("valid endian specifiers are be or le");
3439 return little_endian
;
3442 /* Parse a rotation specifier: ROR #0, #8, #16, #24. *val receives a
3443 value suitable for poking into the rotate field of an sxt or sxta
3444 instruction, or FAIL on error. */
3447 parse_ror (char **str
)
3452 if (strncasecmp (s
, "ROR", 3) == 0)
3456 inst
.error
= _("missing rotation field after comma");
3460 if (parse_immediate (&s
, &rot
, 0, 24, FALSE
) == FAIL
)
3465 case 0: *str
= s
; return 0x0;
3466 case 8: *str
= s
; return 0x1;
3467 case 16: *str
= s
; return 0x2;
3468 case 24: *str
= s
; return 0x3;
3471 inst
.error
= _("rotation can only be 0, 8, 16, or 24");
3476 /* Parse a conditional code (from conds[] below). The value returned is in the
3477 range 0 .. 14, or FAIL. */
3479 parse_cond (char **str
)
3482 const struct asm_cond
*c
;
3485 while (ISALPHA (*q
))
3488 c
= hash_find_n (arm_cond_hsh
, p
, q
- p
);
3491 inst
.error
= _("condition required");
3499 /* Parse the operands of a table branch instruction. Similar to a memory
3502 parse_tb (char **str
)
3507 if (skip_past_char (&p
, '[') == FAIL
)
3510 if ((reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) == FAIL
)
3512 inst
.error
= _(reg_expected_msgs
[REG_TYPE_RN
]);
3515 inst
.operands
[0].reg
= reg
;
3517 if (skip_past_comma (&p
) == FAIL
)
3520 if ((reg
= arm_reg_parse (&p
, REG_TYPE_RN
)) == FAIL
)
3522 inst
.error
= _(reg_expected_msgs
[REG_TYPE_RN
]);
3525 inst
.operands
[0].imm
= reg
;
3527 if (skip_past_comma (&p
) == SUCCESS
)
3529 if (parse_shift (&p
, 0, SHIFT_LSL_IMMEDIATE
) == FAIL
)
3531 if (inst
.reloc
.exp
.X_add_number
!= 1)
3533 inst
.error
= _("invalid shift");
3536 inst
.operands
[0].shifted
= 1;
3539 if (skip_past_char (&p
, ']') == FAIL
)
3541 inst
.error
= _("']' expected");
3548 /* Matcher codes for parse_operands. */
3549 enum operand_parse_code
3551 OP_stop
, /* end of line */
3553 OP_RR
, /* ARM register */
3554 OP_RRnpc
, /* ARM register, not r15 */
3555 OP_RRnpcb
, /* ARM register, not r15, in square brackets */
3556 OP_RRw
, /* ARM register, not r15, optional trailing ! */
3557 OP_RCP
, /* Coprocessor number */
3558 OP_RCN
, /* Coprocessor register */
3559 OP_RF
, /* FPA register */
3560 OP_RVS
, /* VFP single precision register */
3561 OP_RVD
, /* VFP double precision register */
3562 OP_RVC
, /* VFP control register */
3563 OP_RMF
, /* Maverick F register */
3564 OP_RMD
, /* Maverick D register */
3565 OP_RMFX
, /* Maverick FX register */
3566 OP_RMDX
, /* Maverick DX register */
3567 OP_RMAX
, /* Maverick AX register */
3568 OP_RMDS
, /* Maverick DSPSC register */
3569 OP_RIWR
, /* iWMMXt wR register */
3570 OP_RIWC
, /* iWMMXt wC register */
3571 OP_RIWG
, /* iWMMXt wCG register */
3572 OP_RXA
, /* XScale accumulator register */
3574 OP_REGLST
, /* ARM register list */
3575 OP_VRSLST
, /* VFP single-precision register list */
3576 OP_VRDLST
, /* VFP double-precision register list */
3578 OP_I7
, /* immediate value 0 .. 7 */
3579 OP_I15
, /* 0 .. 15 */
3580 OP_I16
, /* 1 .. 16 */
3581 OP_I31
, /* 0 .. 31 */
3582 OP_I31w
, /* 0 .. 31, optional trailing ! */
3583 OP_I32
, /* 1 .. 32 */
3584 OP_I63s
, /* -64 .. 63 */
3585 OP_I255
, /* 0 .. 255 */
3586 OP_Iffff
, /* 0 .. 65535 */
3588 OP_I4b
, /* immediate, prefix optional, 1 .. 4 */
3589 OP_I7b
, /* 0 .. 7 */
3590 OP_I15b
, /* 0 .. 15 */
3591 OP_I31b
, /* 0 .. 31 */
3593 OP_SH
, /* shifter operand */
3594 OP_ADDR
, /* Memory address expression (any mode) */
3595 OP_EXP
, /* arbitrary expression */
3596 OP_EXPi
, /* same, with optional immediate prefix */
3597 OP_EXPr
, /* same, with optional relocation suffix */
3599 OP_CPSF
, /* CPS flags */
3600 OP_ENDI
, /* Endianness specifier */
3601 OP_PSR
, /* CPSR/SPSR mask for msr */
3602 OP_COND
, /* conditional code */
3603 OP_TB
, /* Table branch. */
3605 OP_RRnpc_I0
, /* ARM register or literal 0 */
3606 OP_RR_EXr
, /* ARM register or expression with opt. reloc suff. */
3607 OP_RR_EXi
, /* ARM register or expression with imm prefix */
3608 OP_RF_IF
, /* FPA register or immediate */
3609 OP_RIWR_RIWC
, /* iWMMXt R or C reg */
3611 /* Optional operands. */
3612 OP_oI7b
, /* immediate, prefix optional, 0 .. 7 */
3613 OP_oI31b
, /* 0 .. 31 */
3614 OP_oIffffb
, /* 0 .. 65535 */
3615 OP_oI255c
, /* curly-brace enclosed, 0 .. 255 */
3617 OP_oRR
, /* ARM register */
3618 OP_oRRnpc
, /* ARM register, not the PC */
3619 OP_oSHll
, /* LSL immediate */
3620 OP_oSHar
, /* ASR immediate */
3621 OP_oSHllar
, /* LSL or ASR immediate */
3622 OP_oROR
, /* ROR 0/8/16/24 */
3624 OP_FIRST_OPTIONAL
= OP_oI7b
3627 /* Generic instruction operand parser. This does no encoding and no
3628 semantic validation; it merely squirrels values away in the inst
3629 structure. Returns SUCCESS or FAIL depending on whether the
3630 specified grammar matched. */
3632 parse_operands (char *str
, const unsigned char *pattern
)
3634 unsigned const char *upat
= pattern
;
3635 char *backtrack_pos
= 0;
3636 const char *backtrack_error
= 0;
3637 int i
, val
, backtrack_index
= 0;
3639 #define po_char_or_fail(chr) do { \
3640 if (skip_past_char (&str, chr) == FAIL) \
3644 #define po_reg_or_fail(regtype) do { \
3645 val = arm_reg_parse (&str, regtype); \
3648 inst.error = _(reg_expected_msgs[regtype]); \
3651 inst.operands[i].reg = val; \
3652 inst.operands[i].isreg = 1; \
3655 #define po_reg_or_goto(regtype, label) do { \
3656 val = arm_reg_parse (&str, regtype); \
3660 inst.operands[i].reg = val; \
3661 inst.operands[i].isreg = 1; \
3664 #define po_imm_or_fail(min, max, popt) do { \
3665 if (parse_immediate (&str, &val, min, max, popt) == FAIL) \
3667 inst.operands[i].imm = val; \
3670 #define po_misc_or_fail(expr) do { \
3675 skip_whitespace (str
);
3677 for (i
= 0; upat
[i
] != OP_stop
; i
++)
3679 if (upat
[i
] >= OP_FIRST_OPTIONAL
)
3681 /* Remember where we are in case we need to backtrack. */
3682 assert (!backtrack_pos
);
3683 backtrack_pos
= str
;
3684 backtrack_error
= inst
.error
;
3685 backtrack_index
= i
;
3689 po_char_or_fail (',');
3697 case OP_RR
: po_reg_or_fail (REG_TYPE_RN
); break;
3698 case OP_RCP
: po_reg_or_fail (REG_TYPE_CP
); break;
3699 case OP_RCN
: po_reg_or_fail (REG_TYPE_CN
); break;
3700 case OP_RF
: po_reg_or_fail (REG_TYPE_FN
); break;
3701 case OP_RVS
: po_reg_or_fail (REG_TYPE_VFS
); break;
3702 case OP_RVD
: po_reg_or_fail (REG_TYPE_VFD
); break;
3703 case OP_RVC
: po_reg_or_fail (REG_TYPE_VFC
); break;
3704 case OP_RMF
: po_reg_or_fail (REG_TYPE_MVF
); break;
3705 case OP_RMD
: po_reg_or_fail (REG_TYPE_MVD
); break;
3706 case OP_RMFX
: po_reg_or_fail (REG_TYPE_MVFX
); break;
3707 case OP_RMDX
: po_reg_or_fail (REG_TYPE_MVDX
); break;
3708 case OP_RMAX
: po_reg_or_fail (REG_TYPE_MVAX
); break;
3709 case OP_RMDS
: po_reg_or_fail (REG_TYPE_DSPSC
); break;
3710 case OP_RIWR
: po_reg_or_fail (REG_TYPE_MMXWR
); break;
3711 case OP_RIWC
: po_reg_or_fail (REG_TYPE_MMXWC
); break;
3712 case OP_RIWG
: po_reg_or_fail (REG_TYPE_MMXWCG
); break;
3713 case OP_RXA
: po_reg_or_fail (REG_TYPE_XSCALE
); break;
3716 po_char_or_fail ('[');
3717 po_reg_or_fail (REG_TYPE_RN
);
3718 po_char_or_fail (']');
3722 po_reg_or_fail (REG_TYPE_RN
);
3723 if (skip_past_char (&str
, '!') == SUCCESS
)
3724 inst
.operands
[i
].writeback
= 1;
3728 case OP_I7
: po_imm_or_fail ( 0, 7, FALSE
); break;
3729 case OP_I15
: po_imm_or_fail ( 0, 15, FALSE
); break;
3730 case OP_I16
: po_imm_or_fail ( 1, 16, FALSE
); break;
3731 case OP_I31
: po_imm_or_fail ( 0, 31, FALSE
); break;
3732 case OP_I32
: po_imm_or_fail ( 1, 32, FALSE
); break;
3733 case OP_I63s
: po_imm_or_fail (-64, 63, FALSE
); break;
3734 case OP_I255
: po_imm_or_fail ( 0, 255, FALSE
); break;
3735 case OP_Iffff
: po_imm_or_fail ( 0, 0xffff, FALSE
); break;
3737 case OP_I4b
: po_imm_or_fail ( 1, 4, TRUE
); break;
3739 case OP_I7b
: po_imm_or_fail ( 0, 7, TRUE
); break;
3740 case OP_I15b
: po_imm_or_fail ( 0, 15, TRUE
); break;
3742 case OP_I31b
: po_imm_or_fail ( 0, 31, TRUE
); break;
3743 case OP_oIffffb
: po_imm_or_fail ( 0, 0xffff, TRUE
); break;
3745 /* Immediate variants */
3747 po_char_or_fail ('{');
3748 po_imm_or_fail (0, 255, TRUE
);
3749 po_char_or_fail ('}');
3753 /* The expression parser chokes on a trailing !, so we have
3754 to find it first and zap it. */
3757 while (*s
&& *s
!= ',')
3762 inst
.operands
[i
].writeback
= 1;
3764 po_imm_or_fail (0, 31, TRUE
);
3772 po_misc_or_fail (my_get_expression (&inst
.reloc
.exp
, &str
,
3777 po_misc_or_fail (my_get_expression (&inst
.reloc
.exp
, &str
,
3782 po_misc_or_fail (my_get_expression (&inst
.reloc
.exp
, &str
,
3784 if (inst
.reloc
.exp
.X_op
== O_symbol
)
3786 val
= parse_reloc (&str
);
3789 inst
.error
= _("unrecognized relocation suffix");
3792 else if (val
!= BFD_RELOC_UNUSED
)
3794 inst
.operands
[i
].imm
= val
;
3795 inst
.operands
[i
].hasreloc
= 1;
3800 /* Register or expression */
3801 case OP_RR_EXr
: po_reg_or_goto (REG_TYPE_RN
, EXPr
); break;
3802 case OP_RR_EXi
: po_reg_or_goto (REG_TYPE_RN
, EXPi
); break;
3804 /* Register or immediate */
3805 case OP_RRnpc_I0
: po_reg_or_goto (REG_TYPE_RN
, I0
); break;
3806 I0
: po_imm_or_fail (0, 0, FALSE
); break;
3808 case OP_RF_IF
: po_reg_or_goto (REG_TYPE_FN
, IF
); break;
3810 if (!is_immediate_prefix (*str
))
3813 val
= parse_fpa_immediate (&str
);
3816 /* FPA immediates are encoded as registers 8-15.
3817 parse_fpa_immediate has already applied the offset. */
3818 inst
.operands
[i
].reg
= val
;
3819 inst
.operands
[i
].isreg
= 1;
3822 /* Two kinds of register */
3825 struct reg_entry
*rege
= arm_reg_parse_multi (&str
);
3826 if (rege
->type
!= REG_TYPE_MMXWR
3827 && rege
->type
!= REG_TYPE_MMXWC
3828 && rege
->type
!= REG_TYPE_MMXWCG
)
3830 inst
.error
= _("iWMMXt data or control register expected");
3833 inst
.operands
[i
].reg
= rege
->number
;
3834 inst
.operands
[i
].isreg
= (rege
->type
== REG_TYPE_MMXWR
);
3839 case OP_CPSF
: val
= parse_cps_flags (&str
); break;
3840 case OP_ENDI
: val
= parse_endian_specifier (&str
); break;
3841 case OP_oROR
: val
= parse_ror (&str
); break;
3842 case OP_PSR
: val
= parse_psr (&str
); break;
3843 case OP_COND
: val
= parse_cond (&str
); break;
3846 po_misc_or_fail (parse_tb (&str
));
3849 /* Register lists */
3851 val
= parse_reg_list (&str
);
3854 inst
.operands
[1].writeback
= 1;
3860 val
= parse_vfp_reg_list (&str
, &inst
.operands
[i
].reg
, 0);
3864 val
= parse_vfp_reg_list (&str
, &inst
.operands
[i
].reg
, 1);
3867 /* Addressing modes */
3869 po_misc_or_fail (parse_address (&str
, i
));
3873 po_misc_or_fail (parse_shifter_operand (&str
, i
));
3877 po_misc_or_fail (parse_shift (&str
, i
, SHIFT_LSL_IMMEDIATE
));
3881 po_misc_or_fail (parse_shift (&str
, i
, SHIFT_ASR_IMMEDIATE
));
3885 po_misc_or_fail (parse_shift (&str
, i
, SHIFT_LSL_OR_ASR_IMMEDIATE
));
3889 as_fatal ("unhandled operand code %d", upat
[i
]);
3892 /* Various value-based sanity checks and shared operations. We
3893 do not signal immediate failures for the register constraints;
3894 this allows a syntax error to take precedence. */
3902 if (inst
.operands
[i
].isreg
&& inst
.operands
[i
].reg
== REG_PC
)
3903 inst
.error
= BAD_PC
;
3916 inst
.operands
[i
].imm
= val
;
3923 /* If we get here, this operand was successfully parsed. */
3924 inst
.operands
[i
].present
= 1;
3928 inst
.error
= BAD_ARGS
;
3934 /* Do not backtrack over a trailing optional argument that
3935 absorbed some text. We will only fail again, with the
3936 'garbage following instruction' error message, which is
3937 probably less helpful than the current one. */
3938 if (backtrack_index
== i
&& backtrack_pos
!= str
3939 && upat
[i
+1] == OP_stop
)
3942 /* Try again, skipping the optional argument at backtrack_pos. */
3943 str
= backtrack_pos
;
3944 inst
.error
= backtrack_error
;
3945 inst
.operands
[backtrack_index
].present
= 0;
3946 i
= backtrack_index
;
3950 /* Check that we have parsed all the arguments. */
3951 if (*str
!= '\0' && !inst
.error
)
3952 inst
.error
= _("garbage following instruction");
3954 return inst
.error
? FAIL
: SUCCESS
;
3957 #undef po_char_or_fail
3958 #undef po_reg_or_fail
3959 #undef po_reg_or_goto
3960 #undef po_imm_or_fail
3962 /* Shorthand macro for instruction encoding functions issuing errors. */
3963 #define constraint(expr, err) do { \
3971 /* Functions for operand encoding. ARM, then Thumb. */
3973 #define rotate_left(v, n) (v << n | v >> (32 - n))
3975 /* If VAL can be encoded in the immediate field of an ARM instruction,
3976 return the encoded form. Otherwise, return FAIL. */
3979 encode_arm_immediate (unsigned int val
)
3983 for (i
= 0; i
< 32; i
+= 2)
3984 if ((a
= rotate_left (val
, i
)) <= 0xff)
3985 return a
| (i
<< 7); /* 12-bit pack: [shift-cnt,const]. */
3990 /* If VAL can be encoded in the immediate field of a Thumb32 instruction,
3991 return the encoded form. Otherwise, return FAIL. */
3993 encode_thumb32_immediate (unsigned int val
)
4000 for (i
= 1; i
<= 24; i
++)
4003 if ((val
& ~(0xff << i
)) == 0)
4004 return ((val
>> i
) & 0x7f) | ((32 - i
) << 7);
4008 if (val
== ((a
<< 16) | a
))
4010 if (val
== ((a
<< 24) | (a
<< 16) | (a
<< 8) | a
))
4014 if (val
== ((a
<< 16) | a
))
4015 return 0x200 | (a
>> 8);
4019 /* Encode a VFP SP register number into inst.instruction. */
4022 encode_arm_vfp_sp_reg (int reg
, enum vfp_sp_reg_pos pos
)
4027 inst
.instruction
|= ((reg
>> 1) << 12) | ((reg
& 1) << 22);
4031 inst
.instruction
|= ((reg
>> 1) << 16) | ((reg
& 1) << 7);
4035 inst
.instruction
|= ((reg
>> 1) << 0) | ((reg
& 1) << 5);
4043 /* Encode a <shift> in an ARM-format instruction. The immediate,
4044 if any, is handled by md_apply_fix. */
4046 encode_arm_shift (int i
)
4048 if (inst
.operands
[i
].shift_kind
== SHIFT_RRX
)
4049 inst
.instruction
|= SHIFT_ROR
<< 5;
4052 inst
.instruction
|= inst
.operands
[i
].shift_kind
<< 5;
4053 if (inst
.operands
[i
].immisreg
)
4055 inst
.instruction
|= SHIFT_BY_REG
;
4056 inst
.instruction
|= inst
.operands
[i
].imm
<< 8;
4059 inst
.reloc
.type
= BFD_RELOC_ARM_SHIFT_IMM
;
4064 encode_arm_shifter_operand (int i
)
4066 if (inst
.operands
[i
].isreg
)
4068 inst
.instruction
|= inst
.operands
[i
].reg
;
4069 encode_arm_shift (i
);
4072 inst
.instruction
|= INST_IMMEDIATE
;
4075 /* Subroutine of encode_arm_addr_mode_2 and encode_arm_addr_mode_3. */
4077 encode_arm_addr_mode_common (int i
, bfd_boolean is_t
)
4079 assert (inst
.operands
[i
].isreg
);
4080 inst
.instruction
|= inst
.operands
[i
].reg
<< 16;
4082 if (inst
.operands
[i
].preind
)
4086 inst
.error
= _("instruction does not accept preindexed addressing");
4089 inst
.instruction
|= PRE_INDEX
;
4090 if (inst
.operands
[i
].writeback
)
4091 inst
.instruction
|= WRITE_BACK
;
4094 else if (inst
.operands
[i
].postind
)
4096 assert (inst
.operands
[i
].writeback
);
4098 inst
.instruction
|= WRITE_BACK
;
4100 else /* unindexed - only for coprocessor */
4102 inst
.error
= _("instruction does not accept unindexed addressing");
4106 if (((inst
.instruction
& WRITE_BACK
) || !(inst
.instruction
& PRE_INDEX
))
4107 && (((inst
.instruction
& 0x000f0000) >> 16)
4108 == ((inst
.instruction
& 0x0000f000) >> 12)))
4109 as_warn ((inst
.instruction
& LOAD_BIT
)
4110 ? _("destination register same as write-back base")
4111 : _("source register same as write-back base"));
4114 /* inst.operands[i] was set up by parse_address. Encode it into an
4115 ARM-format mode 2 load or store instruction. If is_t is true,
4116 reject forms that cannot be used with a T instruction (i.e. not
4119 encode_arm_addr_mode_2 (int i
, bfd_boolean is_t
)
4121 encode_arm_addr_mode_common (i
, is_t
);
4123 if (inst
.operands
[i
].immisreg
)
4125 inst
.instruction
|= INST_IMMEDIATE
; /* yes, this is backwards */
4126 inst
.instruction
|= inst
.operands
[i
].imm
;
4127 if (!inst
.operands
[i
].negative
)
4128 inst
.instruction
|= INDEX_UP
;
4129 if (inst
.operands
[i
].shifted
)
4131 if (inst
.operands
[i
].shift_kind
== SHIFT_RRX
)
4132 inst
.instruction
|= SHIFT_ROR
<< 5;
4135 inst
.instruction
|= inst
.operands
[i
].shift_kind
<< 5;
4136 inst
.reloc
.type
= BFD_RELOC_ARM_SHIFT_IMM
;
4140 else /* immediate offset in inst.reloc */
4142 if (inst
.reloc
.type
== BFD_RELOC_UNUSED
)
4143 inst
.reloc
.type
= BFD_RELOC_ARM_OFFSET_IMM
;
4147 /* inst.operands[i] was set up by parse_address. Encode it into an
4148 ARM-format mode 3 load or store instruction. Reject forms that
4149 cannot be used with such instructions. If is_t is true, reject
4150 forms that cannot be used with a T instruction (i.e. not
4153 encode_arm_addr_mode_3 (int i
, bfd_boolean is_t
)
4155 if (inst
.operands
[i
].immisreg
&& inst
.operands
[i
].shifted
)
4157 inst
.error
= _("instruction does not accept scaled register index");
4161 encode_arm_addr_mode_common (i
, is_t
);
4163 if (inst
.operands
[i
].immisreg
)
4165 inst
.instruction
|= inst
.operands
[i
].imm
;
4166 if (!inst
.operands
[i
].negative
)
4167 inst
.instruction
|= INDEX_UP
;
4169 else /* immediate offset in inst.reloc */
4171 inst
.instruction
|= HWOFFSET_IMM
;
4172 if (inst
.reloc
.type
== BFD_RELOC_UNUSED
)
4173 inst
.reloc
.type
= BFD_RELOC_ARM_OFFSET_IMM8
;
4177 /* inst.operands[i] was set up by parse_address. Encode it into an
4178 ARM-format instruction. Reject all forms which cannot be encoded
4179 into a coprocessor load/store instruction. If wb_ok is false,
4180 reject use of writeback; if unind_ok is false, reject use of
4181 unindexed addressing. If reloc_override is not 0, use it instead
4182 of BFD_ARM_CP_OFF_IMM. */
4185 encode_arm_cp_address (int i
, int wb_ok
, int unind_ok
, int reloc_override
)
4187 inst
.instruction
|= inst
.operands
[i
].reg
<< 16;
4189 assert (!(inst
.operands
[i
].preind
&& inst
.operands
[i
].postind
));
4191 if (!inst
.operands
[i
].preind
&& !inst
.operands
[i
].postind
) /* unindexed */
4193 assert (!inst
.operands
[i
].writeback
);
4196 inst
.error
= _("instruction does not support unindexed addressing");
4199 inst
.instruction
|= inst
.operands
[i
].imm
;
4200 inst
.instruction
|= INDEX_UP
;
4204 if (inst
.operands
[i
].preind
)
4205 inst
.instruction
|= PRE_INDEX
;
4207 if (inst
.operands
[i
].writeback
)
4209 if (inst
.operands
[i
].reg
== REG_PC
)
4211 inst
.error
= _("pc may not be used with write-back");
4216 inst
.error
= _("instruction does not support writeback");
4219 inst
.instruction
|= WRITE_BACK
;
4223 inst
.reloc
.type
= reloc_override
;
4224 else if (thumb_mode
)
4225 inst
.reloc
.type
= BFD_RELOC_ARM_T32_CP_OFF_IMM
;
4227 inst
.reloc
.type
= BFD_RELOC_ARM_CP_OFF_IMM
;
4231 /* inst.reloc.exp describes an "=expr" load pseudo-operation.
4232 Determine whether it can be performed with a move instruction; if
4233 it can, convert inst.instruction to that move instruction and
4234 return 1; if it can't, convert inst.instruction to a literal-pool
4235 load and return 0. If this is not a valid thing to do in the
4236 current context, set inst.error and return 1.
4238 inst.operands[i] describes the destination register. */
4241 move_or_literal_pool (int i
, bfd_boolean thumb_p
, bfd_boolean mode_3
)
4243 if ((inst
.instruction
& (thumb_p
? THUMB_LOAD_BIT
: LOAD_BIT
)) == 0)
4245 inst
.error
= _("invalid pseudo operation");
4248 if (inst
.reloc
.exp
.X_op
!= O_constant
&& inst
.reloc
.exp
.X_op
!= O_symbol
)
4250 inst
.error
= _("constant expression expected");
4253 if (inst
.reloc
.exp
.X_op
== O_constant
)
4257 if ((inst
.reloc
.exp
.X_add_number
& ~0xFF) == 0)
4259 /* This can be done with a mov(1) instruction. */
4260 inst
.instruction
= T_OPCODE_MOV_I8
| (inst
.operands
[i
].reg
<< 8);
4261 inst
.instruction
|= inst
.reloc
.exp
.X_add_number
;
4267 int value
= encode_arm_immediate (inst
.reloc
.exp
.X_add_number
);
4270 /* This can be done with a mov instruction. */
4271 inst
.instruction
&= LITERAL_MASK
;
4272 inst
.instruction
|= INST_IMMEDIATE
| (OPCODE_MOV
<< DATA_OP_SHIFT
);
4273 inst
.instruction
|= value
& 0xfff;
4277 value
= encode_arm_immediate (~inst
.reloc
.exp
.X_add_number
);
4280 /* This can be done with a mvn instruction. */
4281 inst
.instruction
&= LITERAL_MASK
;
4282 inst
.instruction
|= INST_IMMEDIATE
| (OPCODE_MVN
<< DATA_OP_SHIFT
);
4283 inst
.instruction
|= value
& 0xfff;
4289 if (add_to_lit_pool () == FAIL
)
4291 inst
.error
= _("literal pool insertion failed");
4294 inst
.operands
[1].reg
= REG_PC
;
4295 inst
.operands
[1].isreg
= 1;
4296 inst
.operands
[1].preind
= 1;
4297 inst
.reloc
.pc_rel
= 1;
4298 inst
.reloc
.type
= (thumb_p
4299 ? BFD_RELOC_ARM_THUMB_OFFSET
4301 ? BFD_RELOC_ARM_HWLITERAL
4302 : BFD_RELOC_ARM_LITERAL
));
4306 /* Functions for instruction encoding, sorted by subarchitecture.
4307 First some generics; their names are taken from the conventional
4308 bit positions for register arguments in ARM format instructions. */
4318 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4324 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4325 inst
.instruction
|= inst
.operands
[1].reg
;
4331 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4332 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
4338 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
4339 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
4345 unsigned Rn
= inst
.operands
[2].reg
;
4346 /* Enforce resutrictions on SWP instruction. */
4347 if ((inst
.instruction
& 0x0fbfffff) == 0x01000090)
4348 constraint (Rn
== inst
.operands
[0].reg
|| Rn
== inst
.operands
[1].reg
,
4349 _("Rn must not overlap other operands"));
4350 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4351 inst
.instruction
|= inst
.operands
[1].reg
;
4352 inst
.instruction
|= Rn
<< 16;
4358 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4359 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
4360 inst
.instruction
|= inst
.operands
[2].reg
;
4366 inst
.instruction
|= inst
.operands
[0].reg
;
4367 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
4368 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
4374 inst
.instruction
|= inst
.operands
[0].imm
;
4380 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4381 encode_arm_cp_address (1, TRUE
, TRUE
, 0);
4384 /* ARM instructions, in alphabetical order by function name (except
4385 that wrapper functions appear immediately after the function they
4388 /* This is a pseudo-op of the form "adr rd, label" to be converted
4389 into a relative address of the form "add rd, pc, #label-.-8". */
4394 inst
.instruction
|= (inst
.operands
[0].reg
<< 12); /* Rd */
4396 /* Frag hacking will turn this into a sub instruction if the offset turns
4397 out to be negative. */
4398 inst
.reloc
.type
= BFD_RELOC_ARM_IMMEDIATE
;
4399 inst
.reloc
.pc_rel
= 1;
4400 inst
.reloc
.exp
.X_add_number
-= 8;
4403 /* This is a pseudo-op of the form "adrl rd, label" to be converted
4404 into a relative address of the form:
4405 add rd, pc, #low(label-.-8)"
4406 add rd, rd, #high(label-.-8)" */
4411 inst
.instruction
|= (inst
.operands
[0].reg
<< 12); /* Rd */
4413 /* Frag hacking will turn this into a sub instruction if the offset turns
4414 out to be negative. */
4415 inst
.reloc
.type
= BFD_RELOC_ARM_ADRL_IMMEDIATE
;
4416 inst
.reloc
.pc_rel
= 1;
4417 inst
.size
= INSN_SIZE
* 2;
4418 inst
.reloc
.exp
.X_add_number
-= 8;
4424 if (!inst
.operands
[1].present
)
4425 inst
.operands
[1].reg
= inst
.operands
[0].reg
;
4426 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4427 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
4428 encode_arm_shifter_operand (2);
4434 unsigned int msb
= inst
.operands
[1].imm
+ inst
.operands
[2].imm
;
4435 constraint (msb
> 32, _("bit-field extends past end of register"));
4436 /* The instruction encoding stores the LSB and MSB,
4437 not the LSB and width. */
4438 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4439 inst
.instruction
|= inst
.operands
[1].imm
<< 7;
4440 inst
.instruction
|= (msb
- 1) << 16;
4448 /* #0 in second position is alternative syntax for bfc, which is
4449 the same instruction but with REG_PC in the Rm field. */
4450 if (!inst
.operands
[1].isreg
)
4451 inst
.operands
[1].reg
= REG_PC
;
4453 msb
= inst
.operands
[2].imm
+ inst
.operands
[3].imm
;
4454 constraint (msb
> 32, _("bit-field extends past end of register"));
4455 /* The instruction encoding stores the LSB and MSB,
4456 not the LSB and width. */
4457 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4458 inst
.instruction
|= inst
.operands
[1].reg
;
4459 inst
.instruction
|= inst
.operands
[2].imm
<< 7;
4460 inst
.instruction
|= (msb
- 1) << 16;
4466 constraint (inst
.operands
[2].imm
+ inst
.operands
[3].imm
> 32,
4467 _("bit-field extends past end of register"));
4468 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4469 inst
.instruction
|= inst
.operands
[1].reg
;
4470 inst
.instruction
|= inst
.operands
[2].imm
<< 7;
4471 inst
.instruction
|= (inst
.operands
[3].imm
- 1) << 16;
4474 /* ARM V5 breakpoint instruction (argument parse)
4475 BKPT <16 bit unsigned immediate>
4476 Instruction is not conditional.
4477 The bit pattern given in insns[] has the COND_ALWAYS condition,
4478 and it is an error if the caller tried to override that. */
4483 /* Top 12 of 16 bits to bits 19:8. */
4484 inst
.instruction
|= (inst
.operands
[0].imm
& 0xfff0) << 4;
4486 /* Bottom 4 of 16 bits to bits 3:0. */
4487 inst
.instruction
|= inst
.operands
[0].imm
& 0xf;
4491 encode_branch (int default_reloc
)
4493 if (inst
.operands
[0].hasreloc
)
4495 constraint (inst
.operands
[0].imm
!= BFD_RELOC_ARM_PLT32
,
4496 _("the only suffix valid here is '(plt)'"));
4497 inst
.reloc
.type
= BFD_RELOC_ARM_PLT32
;
4501 inst
.reloc
.type
= default_reloc
;
4503 inst
.reloc
.pc_rel
= 1;
4509 encode_branch (BFD_RELOC_ARM_PCREL_BRANCH
);
4512 /* ARM V5 branch-link-exchange instruction (argument parse)
4513 BLX <target_addr> ie BLX(1)
4514 BLX{<condition>} <Rm> ie BLX(2)
4515 Unfortunately, there are two different opcodes for this mnemonic.
4516 So, the insns[].value is not used, and the code here zaps values
4517 into inst.instruction.
4518 Also, the <target_addr> can be 25 bits, hence has its own reloc. */
4523 if (inst
.operands
[0].isreg
)
4525 /* Arg is a register; the opcode provided by insns[] is correct.
4526 It is not illegal to do "blx pc", just useless. */
4527 if (inst
.operands
[0].reg
== REG_PC
)
4528 as_tsktsk (_("use of r15 in blx in ARM mode is not really useful"));
4530 inst
.instruction
|= inst
.operands
[0].reg
;
4534 /* Arg is an address; this instruction cannot be executed
4535 conditionally, and the opcode must be adjusted. */
4536 constraint (inst
.cond
!= COND_ALWAYS
, BAD_COND
);
4537 inst
.instruction
= 0xfa000000;
4538 encode_branch (BFD_RELOC_ARM_PCREL_BLX
);
4545 if (inst
.operands
[0].reg
== REG_PC
)
4546 as_tsktsk (_("use of r15 in bx in ARM mode is not really useful"));
4548 inst
.instruction
|= inst
.operands
[0].reg
;
4552 /* ARM v5TEJ. Jump to Jazelle code. */
4557 if (inst
.operands
[0].reg
== REG_PC
)
4558 as_tsktsk (_("use of r15 in bxj is not really useful"));
4560 inst
.instruction
|= inst
.operands
[0].reg
;
4563 /* Co-processor data operation:
4564 CDP{cond} <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>{, <opcode_2>}
4565 CDP2 <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>{, <opcode_2>} */
4569 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
4570 inst
.instruction
|= inst
.operands
[1].imm
<< 20;
4571 inst
.instruction
|= inst
.operands
[2].reg
<< 12;
4572 inst
.instruction
|= inst
.operands
[3].reg
<< 16;
4573 inst
.instruction
|= inst
.operands
[4].reg
;
4574 inst
.instruction
|= inst
.operands
[5].imm
<< 5;
4580 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
4581 encode_arm_shifter_operand (1);
4584 /* Transfer between coprocessor and ARM registers.
4585 MRC{cond} <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>{, <opcode_2>}
4590 No special properties. */
4595 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
4596 inst
.instruction
|= inst
.operands
[1].imm
<< 21;
4597 inst
.instruction
|= inst
.operands
[2].reg
<< 12;
4598 inst
.instruction
|= inst
.operands
[3].reg
<< 16;
4599 inst
.instruction
|= inst
.operands
[4].reg
;
4600 inst
.instruction
|= inst
.operands
[5].imm
<< 5;
4603 /* Transfer between coprocessor register and pair of ARM registers.
4604 MCRR{cond} <coproc>, <opcode>, <Rd>, <Rn>, <CRm>.
4609 Two XScale instructions are special cases of these:
4611 MAR{cond} acc0, <RdLo>, <RdHi> == MCRR{cond} p0, #0, <RdLo>, <RdHi>, c0
4612 MRA{cond} acc0, <RdLo>, <RdHi> == MRRC{cond} p0, #0, <RdLo>, <RdHi>, c0
4614 Result unpredicatable if Rd or Rn is R15. */
4619 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
4620 inst
.instruction
|= inst
.operands
[1].imm
<< 4;
4621 inst
.instruction
|= inst
.operands
[2].reg
<< 12;
4622 inst
.instruction
|= inst
.operands
[3].reg
<< 16;
4623 inst
.instruction
|= inst
.operands
[4].reg
;
4629 inst
.instruction
|= inst
.operands
[0].imm
<< 6;
4630 inst
.instruction
|= inst
.operands
[1].imm
;
4636 /* There is no IT instruction in ARM mode. We
4637 process it but do not generate code for it. */
4644 int base_reg
= inst
.operands
[0].reg
;
4645 int range
= inst
.operands
[1].imm
;
4647 inst
.instruction
|= base_reg
<< 16;
4648 inst
.instruction
|= range
;
4650 if (inst
.operands
[1].writeback
)
4651 inst
.instruction
|= LDM_TYPE_2_OR_3
;
4653 if (inst
.operands
[0].writeback
)
4655 inst
.instruction
|= WRITE_BACK
;
4656 /* Check for unpredictable uses of writeback. */
4657 if (inst
.instruction
& LOAD_BIT
)
4659 /* Not allowed in LDM type 2. */
4660 if ((inst
.instruction
& LDM_TYPE_2_OR_3
)
4661 && ((range
& (1 << REG_PC
)) == 0))
4662 as_warn (_("writeback of base register is UNPREDICTABLE"));
4663 /* Only allowed if base reg not in list for other types. */
4664 else if (range
& (1 << base_reg
))
4665 as_warn (_("writeback of base register when in register list is UNPREDICTABLE"));
4669 /* Not allowed for type 2. */
4670 if (inst
.instruction
& LDM_TYPE_2_OR_3
)
4671 as_warn (_("writeback of base register is UNPREDICTABLE"));
4672 /* Only allowed if base reg not in list, or first in list. */
4673 else if ((range
& (1 << base_reg
))
4674 && (range
& ((1 << base_reg
) - 1)))
4675 as_warn (_("if writeback register is in list, it must be the lowest reg in the list"));
4680 /* ARMv5TE load-consecutive (argument parse)
4689 constraint (inst
.operands
[0].reg
% 2 != 0,
4690 _("first destination register must be even"));
4691 constraint (inst
.operands
[1].present
4692 && inst
.operands
[1].reg
!= inst
.operands
[0].reg
+ 1,
4693 _("can only load two consecutive registers"));
4694 constraint (inst
.operands
[0].reg
== REG_LR
, _("r14 not allowed here"));
4695 constraint (!inst
.operands
[2].isreg
, _("'[' expected"));
4697 if (!inst
.operands
[1].present
)
4698 inst
.operands
[1].reg
= inst
.operands
[0].reg
+ 1;
4700 if (inst
.instruction
& LOAD_BIT
)
4702 /* encode_arm_addr_mode_3 will diagnose overlap between the base
4703 register and the first register written; we have to diagnose
4704 overlap between the base and the second register written here. */
4706 if (inst
.operands
[2].reg
== inst
.operands
[1].reg
4707 && (inst
.operands
[2].writeback
|| inst
.operands
[2].postind
))
4708 as_warn (_("base register written back, and overlaps "
4709 "second destination register"));
4711 /* For an index-register load, the index register must not overlap the
4712 destination (even if not write-back). */
4713 else if (inst
.operands
[2].immisreg
4714 && ((unsigned) inst
.operands
[2].imm
== inst
.operands
[0].reg
4715 || (unsigned) inst
.operands
[2].imm
== inst
.operands
[1].reg
))
4716 as_warn (_("index register overlaps destination register"));
4719 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4720 encode_arm_addr_mode_3 (2, /*is_t=*/FALSE
);
4726 constraint (!inst
.operands
[1].isreg
|| !inst
.operands
[1].preind
4727 || inst
.operands
[1].postind
|| inst
.operands
[1].writeback
4728 || inst
.operands
[1].immisreg
|| inst
.operands
[1].shifted
4729 || inst
.operands
[1].negative
,
4730 _("instruction does not accept this addressing mode"));
4732 constraint (inst
.operands
[1].reg
== REG_PC
, BAD_PC
);
4734 constraint (inst
.reloc
.exp
.X_op
!= O_constant
4735 || inst
.reloc
.exp
.X_add_number
!= 0,
4736 _("offset must be zero in ARM encoding"));
4738 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4739 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
4740 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
4746 constraint (inst
.operands
[0].reg
% 2 != 0,
4747 _("even register required"));
4748 constraint (inst
.operands
[1].present
4749 && inst
.operands
[1].reg
!= inst
.operands
[0].reg
+ 1,
4750 _("can only load two consecutive registers"));
4751 /* If op 1 were present and equal to PC, this function wouldn't
4752 have been called in the first place. */
4753 constraint (inst
.operands
[0].reg
== REG_LR
, _("r14 not allowed here"));
4755 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4756 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
4762 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4763 if (!inst
.operands
[1].isreg
)
4764 if (move_or_literal_pool (0, /*thumb_p=*/FALSE
, /*mode_3=*/FALSE
))
4766 encode_arm_addr_mode_2 (1, /*is_t=*/FALSE
);
4772 /* ldrt/strt always use post-indexed addressing. Turn [Rn] into [Rn]! and
4774 if (inst
.operands
[1].preind
)
4776 constraint (inst
.reloc
.exp
.X_op
!= O_constant
||
4777 inst
.reloc
.exp
.X_add_number
!= 0,
4778 _("this instruction requires a post-indexed address"));
4780 inst
.operands
[1].preind
= 0;
4781 inst
.operands
[1].postind
= 1;
4782 inst
.operands
[1].writeback
= 1;
4784 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4785 encode_arm_addr_mode_2 (1, /*is_t=*/TRUE
);
4788 /* Halfword and signed-byte load/store operations. */
4793 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4794 if (!inst
.operands
[1].isreg
)
4795 if (move_or_literal_pool (0, /*thumb_p=*/FALSE
, /*mode_3=*/TRUE
))
4797 encode_arm_addr_mode_3 (1, /*is_t=*/FALSE
);
4803 /* ldrt/strt always use post-indexed addressing. Turn [Rn] into [Rn]! and
4805 if (inst
.operands
[1].preind
)
4807 constraint (inst
.reloc
.exp
.X_op
!= O_constant
||
4808 inst
.reloc
.exp
.X_add_number
!= 0,
4809 _("this instruction requires a post-indexed address"));
4811 inst
.operands
[1].preind
= 0;
4812 inst
.operands
[1].postind
= 1;
4813 inst
.operands
[1].writeback
= 1;
4815 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4816 encode_arm_addr_mode_3 (1, /*is_t=*/TRUE
);
4819 /* Co-processor register load/store.
4820 Format: <LDC|STC>{cond}[L] CP#,CRd,<address> */
4824 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
4825 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
4826 encode_arm_cp_address (2, TRUE
, TRUE
, 0);
4832 /* This restriction does not apply to mls (nor to mla in v6, but
4833 that's hard to detect at present). */
4834 if (inst
.operands
[0].reg
== inst
.operands
[1].reg
4835 && !(inst
.instruction
& 0x00400000))
4836 as_tsktsk (_("rd and rm should be different in mla"));
4838 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
4839 inst
.instruction
|= inst
.operands
[1].reg
;
4840 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
4841 inst
.instruction
|= inst
.operands
[3].reg
<< 12;
4848 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4849 encode_arm_shifter_operand (1);
4852 /* ARM V6T2 16-bit immediate register load: MOV[WT]{cond} Rd, #<imm16>. */
4856 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4857 /* The value is in two pieces: 0:11, 16:19. */
4858 inst
.instruction
|= (inst
.operands
[1].imm
& 0x00000fff);
4859 inst
.instruction
|= (inst
.operands
[1].imm
& 0x0000f000) << 4;
4865 /* mrs only accepts CPSR/SPSR/CPSR_all/SPSR_all. */
4866 constraint ((inst
.operands
[1].imm
& (PSR_c
|PSR_x
|PSR_s
|PSR_f
))
4868 _("'CPSR' or 'SPSR' expected"));
4869 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4870 inst
.instruction
|= (inst
.operands
[1].imm
& SPSR_BIT
);
4873 /* Two possible forms:
4874 "{C|S}PSR_<field>, Rm",
4875 "{C|S}PSR_f, #expression". */
4880 inst
.instruction
|= inst
.operands
[0].imm
;
4881 if (inst
.operands
[1].isreg
)
4882 inst
.instruction
|= inst
.operands
[1].reg
;
4885 inst
.instruction
|= INST_IMMEDIATE
;
4886 inst
.reloc
.type
= BFD_RELOC_ARM_IMMEDIATE
;
4887 inst
.reloc
.pc_rel
= 0;
4894 if (!inst
.operands
[2].present
)
4895 inst
.operands
[2].reg
= inst
.operands
[0].reg
;
4896 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
4897 inst
.instruction
|= inst
.operands
[1].reg
;
4898 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
4900 if (inst
.operands
[0].reg
== inst
.operands
[1].reg
)
4901 as_tsktsk (_("rd and rm should be different in mul"));
4904 /* Long Multiply Parser
4905 UMULL RdLo, RdHi, Rm, Rs
4906 SMULL RdLo, RdHi, Rm, Rs
4907 UMLAL RdLo, RdHi, Rm, Rs
4908 SMLAL RdLo, RdHi, Rm, Rs. */
4913 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4914 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
4915 inst
.instruction
|= inst
.operands
[2].reg
;
4916 inst
.instruction
|= inst
.operands
[3].reg
<< 8;
4918 /* rdhi, rdlo and rm must all be different. */
4919 if (inst
.operands
[0].reg
== inst
.operands
[1].reg
4920 || inst
.operands
[0].reg
== inst
.operands
[2].reg
4921 || inst
.operands
[1].reg
== inst
.operands
[2].reg
)
4922 as_tsktsk (_("rdhi, rdlo and rm must all be different"));
4928 if (inst
.operands
[0].present
)
4930 /* Architectural NOP hints are CPSR sets with no bits selected. */
4931 inst
.instruction
&= 0xf0000000;
4932 inst
.instruction
|= 0x0320f000 + inst
.operands
[0].imm
;
4936 /* ARM V6 Pack Halfword Bottom Top instruction (argument parse).
4937 PKHBT {<cond>} <Rd>, <Rn>, <Rm> {, LSL #<shift_imm>}
4938 Condition defaults to COND_ALWAYS.
4939 Error if Rd, Rn or Rm are R15. */
4944 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4945 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
4946 inst
.instruction
|= inst
.operands
[2].reg
;
4947 if (inst
.operands
[3].present
)
4948 encode_arm_shift (3);
4951 /* ARM V6 PKHTB (Argument Parse). */
4956 if (!inst
.operands
[3].present
)
4958 /* If the shift specifier is omitted, turn the instruction
4959 into pkhbt rd, rm, rn. */
4960 inst
.instruction
&= 0xfff00010;
4961 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4962 inst
.instruction
|= inst
.operands
[1].reg
;
4963 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
4967 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
4968 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
4969 inst
.instruction
|= inst
.operands
[2].reg
;
4970 encode_arm_shift (3);
4974 /* ARMv5TE: Preload-Cache
4978 Syntactically, like LDR with B=1, W=0, L=1. */
4983 constraint (!inst
.operands
[0].isreg
,
4984 _("'[' expected after PLD mnemonic"));
4985 constraint (inst
.operands
[0].postind
,
4986 _("post-indexed expression used in preload instruction"));
4987 constraint (inst
.operands
[0].writeback
,
4988 _("writeback used in preload instruction"));
4989 constraint (!inst
.operands
[0].preind
,
4990 _("unindexed addressing used in preload instruction"));
4991 inst
.instruction
|= inst
.operands
[0].reg
;
4992 encode_arm_addr_mode_2 (0, /*is_t=*/FALSE
);
4998 inst
.operands
[1] = inst
.operands
[0];
4999 memset (&inst
.operands
[0], 0, sizeof inst
.operands
[0]);
5000 inst
.operands
[0].isreg
= 1;
5001 inst
.operands
[0].writeback
= 1;
5002 inst
.operands
[0].reg
= REG_SP
;
5006 /* ARM V6 RFE (Return from Exception) loads the PC and CPSR from the
5007 word at the specified address and the following word
5009 Unconditionally executed.
5010 Error if Rn is R15. */
5015 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
5016 if (inst
.operands
[0].writeback
)
5017 inst
.instruction
|= WRITE_BACK
;
5020 /* ARM V6 ssat (argument parse). */
5025 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5026 inst
.instruction
|= (inst
.operands
[1].imm
- 1) << 16;
5027 inst
.instruction
|= inst
.operands
[2].reg
;
5029 if (inst
.operands
[3].present
)
5030 encode_arm_shift (3);
5033 /* ARM V6 usat (argument parse). */
5038 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5039 inst
.instruction
|= inst
.operands
[1].imm
<< 16;
5040 inst
.instruction
|= inst
.operands
[2].reg
;
5042 if (inst
.operands
[3].present
)
5043 encode_arm_shift (3);
5046 /* ARM V6 ssat16 (argument parse). */
5051 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5052 inst
.instruction
|= ((inst
.operands
[1].imm
- 1) << 16);
5053 inst
.instruction
|= inst
.operands
[2].reg
;
5059 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5060 inst
.instruction
|= inst
.operands
[1].imm
<< 16;
5061 inst
.instruction
|= inst
.operands
[2].reg
;
5064 /* ARM V6 SETEND (argument parse). Sets the E bit in the CPSR while
5065 preserving the other bits.
5067 setend <endian_specifier>, where <endian_specifier> is either
5073 if (inst
.operands
[0].imm
)
5074 inst
.instruction
|= 0x200;
5080 unsigned int Rm
= (inst
.operands
[1].present
5081 ? inst
.operands
[1].reg
5082 : inst
.operands
[0].reg
);
5084 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5085 inst
.instruction
|= Rm
;
5086 if (inst
.operands
[2].isreg
) /* Rd, {Rm,} Rs */
5088 constraint (inst
.operands
[0].reg
!= Rm
,
5089 _("source1 and dest must be same register"));
5090 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
5091 inst
.instruction
|= SHIFT_BY_REG
;
5094 inst
.reloc
.type
= BFD_RELOC_ARM_SHIFT_IMM
;
5100 inst
.reloc
.type
= BFD_RELOC_ARM_SMC
;
5101 inst
.reloc
.pc_rel
= 0;
5107 inst
.reloc
.type
= BFD_RELOC_ARM_SWI
;
5108 inst
.reloc
.pc_rel
= 0;
5111 /* ARM V5E (El Segundo) signed-multiply-accumulate (argument parse)
5112 SMLAxy{cond} Rd,Rm,Rs,Rn
5113 SMLAWy{cond} Rd,Rm,Rs,Rn
5114 Error if any register is R15. */
5119 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
5120 inst
.instruction
|= inst
.operands
[1].reg
;
5121 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
5122 inst
.instruction
|= inst
.operands
[3].reg
<< 12;
5125 /* ARM V5E (El Segundo) signed-multiply-accumulate-long (argument parse)
5126 SMLALxy{cond} Rdlo,Rdhi,Rm,Rs
5127 Error if any register is R15.
5128 Warning if Rdlo == Rdhi. */
5133 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5134 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
5135 inst
.instruction
|= inst
.operands
[2].reg
;
5136 inst
.instruction
|= inst
.operands
[3].reg
<< 8;
5138 if (inst
.operands
[0].reg
== inst
.operands
[1].reg
)
5139 as_tsktsk (_("rdhi and rdlo must be different"));
5142 /* ARM V5E (El Segundo) signed-multiply (argument parse)
5143 SMULxy{cond} Rd,Rm,Rs
5144 Error if any register is R15. */
5149 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
5150 inst
.instruction
|= inst
.operands
[1].reg
;
5151 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
5154 /* ARM V6 srs (argument parse). */
5159 inst
.instruction
|= inst
.operands
[0].imm
;
5160 if (inst
.operands
[0].writeback
)
5161 inst
.instruction
|= WRITE_BACK
;
5164 /* ARM V6 strex (argument parse). */
5169 constraint (!inst
.operands
[2].isreg
|| !inst
.operands
[2].preind
5170 || inst
.operands
[2].postind
|| inst
.operands
[2].writeback
5171 || inst
.operands
[2].immisreg
|| inst
.operands
[2].shifted
5172 || inst
.operands
[2].negative
,
5173 _("instruction does not accept this addressing mode"));
5175 constraint (inst
.operands
[2].reg
== REG_PC
, BAD_PC
);
5177 constraint (inst
.operands
[0].reg
== inst
.operands
[1].reg
5178 || inst
.operands
[0].reg
== inst
.operands
[2].reg
, BAD_OVERLAP
);
5180 constraint (inst
.reloc
.exp
.X_op
!= O_constant
5181 || inst
.reloc
.exp
.X_add_number
!= 0,
5182 _("offset must be zero in ARM encoding"));
5184 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5185 inst
.instruction
|= inst
.operands
[1].reg
;
5186 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
5187 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
5193 constraint (inst
.operands
[1].reg
% 2 != 0,
5194 _("even register required"));
5195 constraint (inst
.operands
[2].present
5196 && inst
.operands
[2].reg
!= inst
.operands
[1].reg
+ 1,
5197 _("can only store two consecutive registers"));
5198 /* If op 2 were present and equal to PC, this function wouldn't
5199 have been called in the first place. */
5200 constraint (inst
.operands
[1].reg
== REG_LR
, _("r14 not allowed here"));
5202 constraint (inst
.operands
[0].reg
== inst
.operands
[1].reg
5203 || inst
.operands
[0].reg
== inst
.operands
[1].reg
+ 1
5204 || inst
.operands
[0].reg
== inst
.operands
[3].reg
,
5207 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5208 inst
.instruction
|= inst
.operands
[1].reg
;
5209 inst
.instruction
|= inst
.operands
[3].reg
<< 16;
5212 /* ARM V6 SXTAH extracts a 16-bit value from a register, sign
5213 extends it to 32-bits, and adds the result to a value in another
5214 register. You can specify a rotation by 0, 8, 16, or 24 bits
5215 before extracting the 16-bit value.
5216 SXTAH{<cond>} <Rd>, <Rn>, <Rm>{, <rotation>}
5217 Condition defaults to COND_ALWAYS.
5218 Error if any register uses R15. */
5223 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5224 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
5225 inst
.instruction
|= inst
.operands
[2].reg
;
5226 inst
.instruction
|= inst
.operands
[3].imm
<< 10;
5231 SXTH {<cond>} <Rd>, <Rm>{, <rotation>}
5232 Condition defaults to COND_ALWAYS.
5233 Error if any register uses R15. */
5238 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5239 inst
.instruction
|= inst
.operands
[1].reg
;
5240 inst
.instruction
|= inst
.operands
[2].imm
<< 10;
5243 /* VFP instructions. In a logical order: SP variant first, monad
5244 before dyad, arithmetic then move then load/store. */
5247 do_vfp_sp_monadic (void)
5249 encode_arm_vfp_sp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
5250 encode_arm_vfp_sp_reg (inst
.operands
[1].reg
, VFP_REG_Sm
);
5254 do_vfp_sp_dyadic (void)
5256 encode_arm_vfp_sp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
5257 encode_arm_vfp_sp_reg (inst
.operands
[1].reg
, VFP_REG_Sn
);
5258 encode_arm_vfp_sp_reg (inst
.operands
[2].reg
, VFP_REG_Sm
);
5262 do_vfp_sp_compare_z (void)
5264 encode_arm_vfp_sp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
5268 do_vfp_dp_sp_cvt (void)
5270 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5271 encode_arm_vfp_sp_reg (inst
.operands
[1].reg
, VFP_REG_Sm
);
5275 do_vfp_sp_dp_cvt (void)
5277 encode_arm_vfp_sp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
5278 inst
.instruction
|= inst
.operands
[1].reg
;
5282 do_vfp_reg_from_sp (void)
5284 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5285 encode_arm_vfp_sp_reg (inst
.operands
[1].reg
, VFP_REG_Sn
);
5289 do_vfp_reg2_from_sp2 (void)
5291 constraint (inst
.operands
[2].imm
!= 2,
5292 _("only two consecutive VFP SP registers allowed here"));
5293 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5294 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
5295 encode_arm_vfp_sp_reg (inst
.operands
[2].reg
, VFP_REG_Sm
);
5299 do_vfp_sp_from_reg (void)
5301 encode_arm_vfp_sp_reg (inst
.operands
[0].reg
, VFP_REG_Sn
);
5302 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
5306 do_vfp_sp2_from_reg2 (void)
5308 constraint (inst
.operands
[0].imm
!= 2,
5309 _("only two consecutive VFP SP registers allowed here"));
5310 encode_arm_vfp_sp_reg (inst
.operands
[0].reg
, VFP_REG_Sm
);
5311 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
5312 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
5316 do_vfp_sp_ldst (void)
5318 encode_arm_vfp_sp_reg (inst
.operands
[0].reg
, VFP_REG_Sd
);
5319 encode_arm_cp_address (1, FALSE
, TRUE
, 0);
5323 do_vfp_dp_ldst (void)
5325 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5326 encode_arm_cp_address (1, FALSE
, TRUE
, 0);
5331 vfp_sp_ldstm (enum vfp_ldstm_type ldstm_type
)
5333 if (inst
.operands
[0].writeback
)
5334 inst
.instruction
|= WRITE_BACK
;
5336 constraint (ldstm_type
!= VFP_LDSTMIA
,
5337 _("this addressing mode requires base-register writeback"));
5338 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
5339 encode_arm_vfp_sp_reg (inst
.operands
[1].reg
, VFP_REG_Sd
);
5340 inst
.instruction
|= inst
.operands
[1].imm
;
5344 vfp_dp_ldstm (enum vfp_ldstm_type ldstm_type
)
5348 if (inst
.operands
[0].writeback
)
5349 inst
.instruction
|= WRITE_BACK
;
5351 constraint (ldstm_type
!= VFP_LDSTMIA
&& ldstm_type
!= VFP_LDSTMIAX
,
5352 _("this addressing mode requires base-register writeback"));
5354 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
5355 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
5357 count
= inst
.operands
[1].imm
<< 1;
5358 if (ldstm_type
== VFP_LDSTMIAX
|| ldstm_type
== VFP_LDSTMDBX
)
5361 inst
.instruction
|= count
;
5365 do_vfp_sp_ldstmia (void)
5367 vfp_sp_ldstm (VFP_LDSTMIA
);
5371 do_vfp_sp_ldstmdb (void)
5373 vfp_sp_ldstm (VFP_LDSTMDB
);
5377 do_vfp_dp_ldstmia (void)
5379 vfp_dp_ldstm (VFP_LDSTMIA
);
5383 do_vfp_dp_ldstmdb (void)
5385 vfp_dp_ldstm (VFP_LDSTMDB
);
5389 do_vfp_xp_ldstmia (void)
5391 vfp_dp_ldstm (VFP_LDSTMIAX
);
5395 do_vfp_xp_ldstmdb (void)
5397 vfp_dp_ldstm (VFP_LDSTMDBX
);
5400 /* FPA instructions. Also in a logical order. */
5405 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
5406 inst
.instruction
|= inst
.operands
[1].reg
;
5410 do_fpa_ldmstm (void)
5412 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5413 switch (inst
.operands
[1].imm
)
5415 case 1: inst
.instruction
|= CP_T_X
; break;
5416 case 2: inst
.instruction
|= CP_T_Y
; break;
5417 case 3: inst
.instruction
|= CP_T_Y
| CP_T_X
; break;
5422 if (inst
.instruction
& (PRE_INDEX
| INDEX_UP
))
5424 /* The instruction specified "ea" or "fd", so we can only accept
5425 [Rn]{!}. The instruction does not really support stacking or
5426 unstacking, so we have to emulate these by setting appropriate
5427 bits and offsets. */
5428 constraint (inst
.reloc
.exp
.X_op
!= O_constant
5429 || inst
.reloc
.exp
.X_add_number
!= 0,
5430 _("this instruction does not support indexing"));
5432 if ((inst
.instruction
& PRE_INDEX
) || inst
.operands
[2].writeback
)
5433 inst
.reloc
.exp
.X_add_number
= 12 * inst
.operands
[1].imm
;
5435 if (!(inst
.instruction
& INDEX_UP
))
5436 inst
.reloc
.exp
.X_add_number
= -inst
.reloc
.exp
.X_add_number
;
5438 if (!(inst
.instruction
& PRE_INDEX
) && inst
.operands
[2].writeback
)
5440 inst
.operands
[2].preind
= 0;
5441 inst
.operands
[2].postind
= 1;
5445 encode_arm_cp_address (2, TRUE
, TRUE
, 0);
5448 /* iWMMXt instructions: strictly in alphabetical order. */
5451 do_iwmmxt_tandorc (void)
5453 constraint (inst
.operands
[0].reg
!= REG_PC
, _("only r15 allowed here"));
5457 do_iwmmxt_textrc (void)
5459 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5460 inst
.instruction
|= inst
.operands
[1].imm
;
5464 do_iwmmxt_textrm (void)
5466 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5467 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
5468 inst
.instruction
|= inst
.operands
[2].imm
;
5472 do_iwmmxt_tinsr (void)
5474 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
5475 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
5476 inst
.instruction
|= inst
.operands
[2].imm
;
5480 do_iwmmxt_tmia (void)
5482 inst
.instruction
|= inst
.operands
[0].reg
<< 5;
5483 inst
.instruction
|= inst
.operands
[1].reg
;
5484 inst
.instruction
|= inst
.operands
[2].reg
<< 12;
5488 do_iwmmxt_waligni (void)
5490 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5491 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
5492 inst
.instruction
|= inst
.operands
[2].reg
;
5493 inst
.instruction
|= inst
.operands
[3].imm
<< 20;
5497 do_iwmmxt_wmov (void)
5499 /* WMOV rD, rN is an alias for WOR rD, rN, rN. */
5500 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5501 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
5502 inst
.instruction
|= inst
.operands
[1].reg
;
5506 do_iwmmxt_wldstbh (void)
5509 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5510 inst
.reloc
.exp
.X_add_number
*= 4;
5512 reloc
= BFD_RELOC_ARM_T32_CP_OFF_IMM_S2
;
5514 reloc
= BFD_RELOC_ARM_CP_OFF_IMM_S2
;
5515 encode_arm_cp_address (1, TRUE
, FALSE
, reloc
);
5519 do_iwmmxt_wldstw (void)
5521 /* RIWR_RIWC clears .isreg for a control register. */
5522 if (!inst
.operands
[0].isreg
)
5524 constraint (inst
.cond
!= COND_ALWAYS
, BAD_COND
);
5525 inst
.instruction
|= 0xf0000000;
5528 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5529 encode_arm_cp_address (1, TRUE
, TRUE
, 0);
5533 do_iwmmxt_wldstd (void)
5535 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5536 encode_arm_cp_address (1, TRUE
, FALSE
, 0);
5540 do_iwmmxt_wshufh (void)
5542 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5543 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
5544 inst
.instruction
|= ((inst
.operands
[2].imm
& 0xf0) << 16);
5545 inst
.instruction
|= (inst
.operands
[2].imm
& 0x0f);
5549 do_iwmmxt_wzero (void)
5551 /* WZERO reg is an alias for WANDN reg, reg, reg. */
5552 inst
.instruction
|= inst
.operands
[0].reg
;
5553 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5554 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
5557 /* Cirrus Maverick instructions. Simple 2-, 3-, and 4-register
5558 operations first, then control, shift, and load/store. */
5560 /* Insns like "foo X,Y,Z". */
5563 do_mav_triple (void)
5565 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
5566 inst
.instruction
|= inst
.operands
[1].reg
;
5567 inst
.instruction
|= inst
.operands
[2].reg
<< 12;
5570 /* Insns like "foo W,X,Y,Z".
5571 where W=MVAX[0:3] and X,Y,Z=MVFX[0:15]. */
5576 inst
.instruction
|= inst
.operands
[0].reg
<< 5;
5577 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
5578 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
5579 inst
.instruction
|= inst
.operands
[3].reg
;
5582 /* cfmvsc32<cond> DSPSC,MVDX[15:0]. */
5586 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
5589 /* Maverick shift immediate instructions.
5590 cfsh32<cond> MVFX[15:0],MVFX[15:0],Shift[6:0].
5591 cfsh64<cond> MVDX[15:0],MVDX[15:0],Shift[6:0]. */
5596 int imm
= inst
.operands
[2].imm
;
5598 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5599 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
5601 /* Bits 0-3 of the insn should have bits 0-3 of the immediate.
5602 Bits 5-7 of the insn should have bits 4-6 of the immediate.
5603 Bit 4 should be 0. */
5604 imm
= (imm
& 0xf) | ((imm
& 0x70) << 1);
5606 inst
.instruction
|= imm
;
5609 /* XScale instructions. Also sorted arithmetic before move. */
5611 /* Xscale multiply-accumulate (argument parse)
5614 MIAxycc acc0,Rm,Rs. */
5619 inst
.instruction
|= inst
.operands
[1].reg
;
5620 inst
.instruction
|= inst
.operands
[2].reg
<< 12;
5623 /* Xscale move-accumulator-register (argument parse)
5625 MARcc acc0,RdLo,RdHi. */
5630 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
5631 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
5634 /* Xscale move-register-accumulator (argument parse)
5636 MRAcc RdLo,RdHi,acc0. */
5641 constraint (inst
.operands
[0].reg
== inst
.operands
[1].reg
, BAD_OVERLAP
);
5642 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
5643 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
5646 /* Encoding functions relevant only to Thumb. */
5648 /* inst.operands[i] is a shifted-register operand; encode
5649 it into inst.instruction in the format used by Thumb32. */
5652 encode_thumb32_shifted_operand (int i
)
5654 unsigned int value
= inst
.reloc
.exp
.X_add_number
;
5655 unsigned int shift
= inst
.operands
[i
].shift_kind
;
5657 constraint (inst
.operands
[i
].immisreg
,
5658 _("shift by register not allowed in thumb mode"));
5659 inst
.instruction
|= inst
.operands
[i
].reg
;
5660 if (shift
== SHIFT_RRX
)
5661 inst
.instruction
|= SHIFT_ROR
<< 4;
5664 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
5665 _("expression too complex"));
5667 constraint (value
> 32
5668 || (value
== 32 && (shift
== SHIFT_LSL
5669 || shift
== SHIFT_ROR
)),
5670 _("shift expression is too large"));
5674 else if (value
== 32)
5677 inst
.instruction
|= shift
<< 4;
5678 inst
.instruction
|= (value
& 0x1c) << 10;
5679 inst
.instruction
|= (value
& 0x03) << 6;
5684 /* inst.operands[i] was set up by parse_address. Encode it into a
5685 Thumb32 format load or store instruction. Reject forms that cannot
5686 be used with such instructions. If is_t is true, reject forms that
5687 cannot be used with a T instruction; if is_d is true, reject forms
5688 that cannot be used with a D instruction. */
5691 encode_thumb32_addr_mode (int i
, bfd_boolean is_t
, bfd_boolean is_d
)
5693 bfd_boolean is_pc
= (inst
.operands
[i
].reg
== REG_PC
);
5695 constraint (!inst
.operands
[i
].isreg
,
5696 _("Thumb does not support the ldr =N pseudo-operation"));
5698 inst
.instruction
|= inst
.operands
[i
].reg
<< 16;
5699 if (inst
.operands
[i
].immisreg
)
5701 constraint (is_pc
, _("cannot use register index with PC-relative addressing"));
5702 constraint (is_t
|| is_d
, _("cannot use register index with this instruction"));
5703 constraint (inst
.operands
[i
].negative
,
5704 _("Thumb does not support negative register indexing"));
5705 constraint (inst
.operands
[i
].postind
,
5706 _("Thumb does not support register post-indexing"));
5707 constraint (inst
.operands
[i
].writeback
,
5708 _("Thumb does not support register indexing with writeback"));
5709 constraint (inst
.operands
[i
].shifted
&& inst
.operands
[i
].shift_kind
!= SHIFT_LSL
,
5710 _("Thumb supports only LSL in shifted register indexing"));
5712 inst
.instruction
|= inst
.operands
[1].imm
;
5713 if (inst
.operands
[i
].shifted
)
5715 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
5716 _("expression too complex"));
5717 constraint (inst
.reloc
.exp
.X_add_number
< 0
5718 || inst
.reloc
.exp
.X_add_number
> 3,
5719 _("shift out of range"));
5720 inst
.instruction
|= inst
.reloc
.exp
.X_add_number
<< 4;
5722 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
5724 else if (inst
.operands
[i
].preind
)
5726 constraint (is_pc
&& inst
.operands
[i
].writeback
,
5727 _("cannot use writeback with PC-relative addressing"));
5728 constraint (is_t
&& inst
.operands
[1].writeback
,
5729 _("cannot use writeback with this instruction"));
5733 inst
.instruction
|= 0x01000000;
5734 if (inst
.operands
[i
].writeback
)
5735 inst
.instruction
|= 0x00200000;
5739 inst
.instruction
|= 0x00000c00;
5740 if (inst
.operands
[i
].writeback
)
5741 inst
.instruction
|= 0x00000100;
5743 inst
.reloc
.type
= BFD_RELOC_ARM_T32_OFFSET_IMM
;
5745 else if (inst
.operands
[i
].postind
)
5747 assert (inst
.operands
[i
].writeback
);
5748 constraint (is_pc
, _("cannot use post-indexing with PC-relative addressing"));
5749 constraint (is_t
, _("cannot use post-indexing with this instruction"));
5752 inst
.instruction
|= 0x00200000;
5754 inst
.instruction
|= 0x00000900;
5755 inst
.reloc
.type
= BFD_RELOC_ARM_T32_OFFSET_IMM
;
5757 else /* unindexed - only for coprocessor */
5758 inst
.error
= _("instruction does not accept unindexed addressing");
5761 /* Table of Thumb instructions which exist in both 16- and 32-bit
5762 encodings (the latter only in post-V6T2 cores). The index is the
5763 value used in the insns table below. When there is more than one
5764 possible 16-bit encoding for the instruction, this table always
5766 Also contains several pseudo-instructions used during relaxation. */
5767 #define T16_32_TAB \
5768 X(adc, 4140, eb400000), \
5769 X(adcs, 4140, eb500000), \
5770 X(add, 1c00, eb000000), \
5771 X(adds, 1c00, eb100000), \
5772 X(addi, 0000, f1000000), \
5773 X(addis, 0000, f1100000), \
5774 X(add_pc,000f, f20f0000), \
5775 X(add_sp,000d, f10d0000), \
5776 X(adr, 000f, f20f0000), \
5777 X(and, 4000, ea000000), \
5778 X(ands, 4000, ea100000), \
5779 X(asr, 1000, fa40f000), \
5780 X(asrs, 1000, fa50f000), \
5781 X(b, e000, f000b000), \
5782 X(bcond, d000, f0008000), \
5783 X(bic, 4380, ea200000), \
5784 X(bics, 4380, ea300000), \
5785 X(cmn, 42c0, eb100f00), \
5786 X(cmp, 2800, ebb00f00), \
5787 X(cpsie, b660, f3af8400), \
5788 X(cpsid, b670, f3af8600), \
5789 X(cpy, 4600, ea4f0000), \
5790 X(dec_sp,80dd, f1bd0d00), \
5791 X(eor, 4040, ea800000), \
5792 X(eors, 4040, ea900000), \
5793 X(inc_sp,00dd, f10d0d00), \
5794 X(ldmia, c800, e8900000), \
5795 X(ldr, 6800, f8500000), \
5796 X(ldrb, 7800, f8100000), \
5797 X(ldrh, 8800, f8300000), \
5798 X(ldrsb, 5600, f9100000), \
5799 X(ldrsh, 5e00, f9300000), \
5800 X(ldr_pc,4800, f85f0000), \
5801 X(ldr_pc2,4800, f85f0000), \
5802 X(ldr_sp,9800, f85d0000), \
5803 X(lsl, 0000, fa00f000), \
5804 X(lsls, 0000, fa10f000), \
5805 X(lsr, 0800, fa20f000), \
5806 X(lsrs, 0800, fa30f000), \
5807 X(mov, 2000, ea4f0000), \
5808 X(movs, 2000, ea5f0000), \
5809 X(mul, 4340, fb00f000), \
5810 X(muls, 4340, ffffffff), /* no 32b muls */ \
5811 X(mvn, 43c0, ea6f0000), \
5812 X(mvns, 43c0, ea7f0000), \
5813 X(neg, 4240, f1c00000), /* rsb #0 */ \
5814 X(negs, 4240, f1d00000), /* rsbs #0 */ \
5815 X(orr, 4300, ea400000), \
5816 X(orrs, 4300, ea500000), \
5817 X(pop, bc00, e8bd0000), /* ldmia sp!,... */ \
5818 X(push, b400, e92d0000), /* stmdb sp!,... */ \
5819 X(rev, ba00, fa90f080), \
5820 X(rev16, ba40, fa90f090), \
5821 X(revsh, bac0, fa90f0b0), \
5822 X(ror, 41c0, fa60f000), \
5823 X(rors, 41c0, fa70f000), \
5824 X(sbc, 4180, eb600000), \
5825 X(sbcs, 4180, eb700000), \
5826 X(stmia, c000, e8800000), \
5827 X(str, 6000, f8400000), \
5828 X(strb, 7000, f8000000), \
5829 X(strh, 8000, f8200000), \
5830 X(str_sp,9000, f84d0000), \
5831 X(sub, 1e00, eba00000), \
5832 X(subs, 1e00, ebb00000), \
5833 X(subi, 8000, f1a00000), \
5834 X(subis, 8000, f1b00000), \
5835 X(sxtb, b240, fa4ff080), \
5836 X(sxth, b200, fa0ff080), \
5837 X(tst, 4200, ea100f00), \
5838 X(uxtb, b2c0, fa5ff080), \
5839 X(uxth, b280, fa1ff080), \
5840 X(nop, bf00, f3af8000), \
5841 X(yield, bf10, f3af8001), \
5842 X(wfe, bf20, f3af8002), \
5843 X(wfi, bf30, f3af8003), \
5844 X(sev, bf40, f3af9004), /* typo, 8004? */
5846 /* To catch errors in encoding functions, the codes are all offset by
5847 0xF800, putting them in one of the 32-bit prefix ranges, ergo undefined
5848 as 16-bit instructions. */
5849 #define X(a,b,c) T_MNEM_##a
5850 enum t16_32_codes
{ T16_32_OFFSET
= 0xF7FF, T16_32_TAB
};
5853 #define X(a,b,c) 0x##b
5854 static const unsigned short thumb_op16
[] = { T16_32_TAB
};
5855 #define THUMB_OP16(n) (thumb_op16[(n) - (T16_32_OFFSET + 1)])
5858 #define X(a,b,c) 0x##c
5859 static const unsigned int thumb_op32
[] = { T16_32_TAB
};
5860 #define THUMB_OP32(n) (thumb_op32[(n) - (T16_32_OFFSET + 1)])
5861 #define THUMB_SETS_FLAGS(n) (THUMB_OP32 (n) & 0x00100000)
5865 /* Thumb instruction encoders, in alphabetical order. */
5869 do_t_add_sub_w (void)
5873 Rd
= inst
.operands
[0].reg
;
5874 Rn
= inst
.operands
[1].reg
;
5876 constraint (Rd
== 15, _("PC not allowed as destination"));
5877 inst
.instruction
|= (Rn
<< 16) | (Rd
<< 8);
5878 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMM12
;
5881 /* Parse an add or subtract instruction. We get here with inst.instruction
5882 equalling any of THUMB_OPCODE_add, adds, sub, or subs. */
5889 Rd
= inst
.operands
[0].reg
;
5890 Rs
= (inst
.operands
[1].present
5891 ? inst
.operands
[1].reg
/* Rd, Rs, foo */
5892 : inst
.operands
[0].reg
); /* Rd, foo -> Rd, Rd, foo */
5900 flags
= (inst
.instruction
== T_MNEM_adds
5901 || inst
.instruction
== T_MNEM_subs
);
5903 narrow
= (current_it_mask
== 0);
5905 narrow
= (current_it_mask
!= 0);
5906 if (!inst
.operands
[2].isreg
)
5909 if (inst
.size_req
!= 4)
5913 add
= (inst
.instruction
== T_MNEM_add
5914 || inst
.instruction
== T_MNEM_adds
);
5915 /* Attempt to use a narrow opcode, with relaxation if
5917 if (Rd
== REG_SP
&& Rs
== REG_SP
&& !flags
)
5918 opcode
= add
? T_MNEM_inc_sp
: T_MNEM_dec_sp
;
5919 else if (Rd
<= 7 && Rs
== REG_SP
&& add
&& !flags
)
5920 opcode
= T_MNEM_add_sp
;
5921 else if (Rd
<= 7 && Rs
== REG_PC
&& add
&& !flags
)
5922 opcode
= T_MNEM_add_pc
;
5923 else if (Rd
<= 7 && Rs
<= 7 && narrow
)
5926 opcode
= add
? T_MNEM_addis
: T_MNEM_subis
;
5928 opcode
= add
? T_MNEM_addi
: T_MNEM_subi
;
5932 inst
.instruction
= THUMB_OP16(opcode
);
5933 inst
.instruction
|= (Rd
<< 4) | Rs
;
5934 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_ADD
;
5935 if (inst
.size_req
!= 2)
5936 inst
.relax
= opcode
;
5939 constraint (inst
.size_req
== 2, BAD_HIREG
);
5941 if (inst
.size_req
== 4
5942 || (inst
.size_req
!= 2 && !opcode
))
5944 /* ??? Convert large immediates to addw/subw. */
5945 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
5946 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
5947 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
5948 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
5949 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
5954 Rn
= inst
.operands
[2].reg
;
5955 /* See if we can do this with a 16-bit instruction. */
5956 if (!inst
.operands
[2].shifted
&& inst
.size_req
!= 4)
5958 if (Rd
> 7 || Rs
> 7 || Rn
> 7)
5963 inst
.instruction
= ((inst
.instruction
== T_MNEM_adds
5964 || inst
.instruction
== T_MNEM_add
)
5967 inst
.instruction
|= Rd
| (Rs
<< 3) | (Rn
<< 6);
5971 if (inst
.instruction
== T_MNEM_add
)
5975 inst
.instruction
= T_OPCODE_ADD_HI
;
5976 inst
.instruction
|= (Rd
& 8) << 4;
5977 inst
.instruction
|= (Rd
& 7);
5978 inst
.instruction
|= Rn
<< 3;
5981 /* ... because addition is commutative! */
5984 inst
.instruction
= T_OPCODE_ADD_HI
;
5985 inst
.instruction
|= (Rd
& 8) << 4;
5986 inst
.instruction
|= (Rd
& 7);
5987 inst
.instruction
|= Rs
<< 3;
5992 /* If we get here, it can't be done in 16 bits. */
5993 constraint (inst
.operands
[2].shifted
&& inst
.operands
[2].immisreg
,
5994 _("shift must be constant"));
5995 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
5996 inst
.instruction
|= Rd
<< 8;
5997 inst
.instruction
|= Rs
<< 16;
5998 encode_thumb32_shifted_operand (2);
6003 constraint (inst
.instruction
== T_MNEM_adds
6004 || inst
.instruction
== T_MNEM_subs
,
6007 if (!inst
.operands
[2].isreg
) /* Rd, Rs, #imm */
6009 constraint ((Rd
> 7 && (Rd
!= REG_SP
|| Rs
!= REG_SP
))
6010 || (Rs
> 7 && Rs
!= REG_SP
&& Rs
!= REG_PC
),
6013 inst
.instruction
= (inst
.instruction
== T_MNEM_add
6015 inst
.instruction
|= (Rd
<< 4) | Rs
;
6016 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_ADD
;
6020 Rn
= inst
.operands
[2].reg
;
6021 constraint (inst
.operands
[2].shifted
, _("unshifted register required"));
6023 /* We now have Rd, Rs, and Rn set to registers. */
6024 if (Rd
> 7 || Rs
> 7 || Rn
> 7)
6026 /* Can't do this for SUB. */
6027 constraint (inst
.instruction
== T_MNEM_sub
, BAD_HIREG
);
6028 inst
.instruction
= T_OPCODE_ADD_HI
;
6029 inst
.instruction
|= (Rd
& 8) << 4;
6030 inst
.instruction
|= (Rd
& 7);
6032 inst
.instruction
|= Rn
<< 3;
6034 inst
.instruction
|= Rs
<< 3;
6036 constraint (1, _("dest must overlap one source register"));
6040 inst
.instruction
= (inst
.instruction
== T_MNEM_add
6041 ? T_OPCODE_ADD_R3
: T_OPCODE_SUB_R3
);
6042 inst
.instruction
|= Rd
| (Rs
<< 3) | (Rn
<< 6);
6050 if (unified_syntax
&& inst
.size_req
== 0 && inst
.operands
[0].reg
<= 7)
6052 /* Defer to section relaxation. */
6053 inst
.relax
= inst
.instruction
;
6054 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6055 inst
.instruction
|= inst
.operands
[0].reg
<< 4;
6057 else if (unified_syntax
&& inst
.size_req
!= 2)
6059 /* Generate a 32-bit opcode. */
6060 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6061 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6062 inst
.reloc
.type
= BFD_RELOC_ARM_T32_ADD_PC12
;
6063 inst
.reloc
.pc_rel
= 1;
6067 /* Generate a 16-bit opcode. */
6068 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6069 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_ADD
;
6070 inst
.reloc
.exp
.X_add_number
-= 4; /* PC relative adjust. */
6071 inst
.reloc
.pc_rel
= 1;
6073 inst
.instruction
|= inst
.operands
[0].reg
<< 4;
6077 /* Arithmetic instructions for which there is just one 16-bit
6078 instruction encoding, and it allows only two low registers.
6079 For maximal compatibility with ARM syntax, we allow three register
6080 operands even when Thumb-32 instructions are not available, as long
6081 as the first two are identical. For instance, both "sbc r0,r1" and
6082 "sbc r0,r0,r1" are allowed. */
6088 Rd
= inst
.operands
[0].reg
;
6089 Rs
= (inst
.operands
[1].present
6090 ? inst
.operands
[1].reg
/* Rd, Rs, foo */
6091 : inst
.operands
[0].reg
); /* Rd, foo -> Rd, Rd, foo */
6092 Rn
= inst
.operands
[2].reg
;
6096 if (!inst
.operands
[2].isreg
)
6098 /* For an immediate, we always generate a 32-bit opcode;
6099 section relaxation will shrink it later if possible. */
6100 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6101 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
6102 inst
.instruction
|= Rd
<< 8;
6103 inst
.instruction
|= Rs
<< 16;
6104 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
6110 /* See if we can do this with a 16-bit instruction. */
6111 if (THUMB_SETS_FLAGS (inst
.instruction
))
6112 narrow
= current_it_mask
== 0;
6114 narrow
= current_it_mask
!= 0;
6116 if (Rd
> 7 || Rn
> 7 || Rs
> 7)
6118 if (inst
.operands
[2].shifted
)
6120 if (inst
.size_req
== 4)
6126 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6127 inst
.instruction
|= Rd
;
6128 inst
.instruction
|= Rn
<< 3;
6132 /* If we get here, it can't be done in 16 bits. */
6133 constraint (inst
.operands
[2].shifted
6134 && inst
.operands
[2].immisreg
,
6135 _("shift must be constant"));
6136 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6137 inst
.instruction
|= Rd
<< 8;
6138 inst
.instruction
|= Rs
<< 16;
6139 encode_thumb32_shifted_operand (2);
6144 /* On its face this is a lie - the instruction does set the
6145 flags. However, the only supported mnemonic in this mode
6147 constraint (THUMB_SETS_FLAGS (inst
.instruction
), BAD_THUMB32
);
6149 constraint (!inst
.operands
[2].isreg
|| inst
.operands
[2].shifted
,
6150 _("unshifted register required"));
6151 constraint (Rd
> 7 || Rs
> 7 || Rn
> 7, BAD_HIREG
);
6152 constraint (Rd
!= Rs
,
6153 _("dest and source1 must be the same register"));
6155 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6156 inst
.instruction
|= Rd
;
6157 inst
.instruction
|= Rn
<< 3;
6161 /* Similarly, but for instructions where the arithmetic operation is
6162 commutative, so we can allow either of them to be different from
6163 the destination operand in a 16-bit instruction. For instance, all
6164 three of "adc r0,r1", "adc r0,r0,r1", and "adc r0,r1,r0" are
6171 Rd
= inst
.operands
[0].reg
;
6172 Rs
= (inst
.operands
[1].present
6173 ? inst
.operands
[1].reg
/* Rd, Rs, foo */
6174 : inst
.operands
[0].reg
); /* Rd, foo -> Rd, Rd, foo */
6175 Rn
= inst
.operands
[2].reg
;
6179 if (!inst
.operands
[2].isreg
)
6181 /* For an immediate, we always generate a 32-bit opcode;
6182 section relaxation will shrink it later if possible. */
6183 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6184 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
6185 inst
.instruction
|= Rd
<< 8;
6186 inst
.instruction
|= Rs
<< 16;
6187 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
6193 /* See if we can do this with a 16-bit instruction. */
6194 if (THUMB_SETS_FLAGS (inst
.instruction
))
6195 narrow
= current_it_mask
== 0;
6197 narrow
= current_it_mask
!= 0;
6199 if (Rd
> 7 || Rn
> 7 || Rs
> 7)
6201 if (inst
.operands
[2].shifted
)
6203 if (inst
.size_req
== 4)
6210 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6211 inst
.instruction
|= Rd
;
6212 inst
.instruction
|= Rn
<< 3;
6217 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6218 inst
.instruction
|= Rd
;
6219 inst
.instruction
|= Rs
<< 3;
6224 /* If we get here, it can't be done in 16 bits. */
6225 constraint (inst
.operands
[2].shifted
6226 && inst
.operands
[2].immisreg
,
6227 _("shift must be constant"));
6228 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6229 inst
.instruction
|= Rd
<< 8;
6230 inst
.instruction
|= Rs
<< 16;
6231 encode_thumb32_shifted_operand (2);
6236 /* On its face this is a lie - the instruction does set the
6237 flags. However, the only supported mnemonic in this mode
6239 constraint (THUMB_SETS_FLAGS (inst
.instruction
), BAD_THUMB32
);
6241 constraint (!inst
.operands
[2].isreg
|| inst
.operands
[2].shifted
,
6242 _("unshifted register required"));
6243 constraint (Rd
> 7 || Rs
> 7 || Rn
> 7, BAD_HIREG
);
6245 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6246 inst
.instruction
|= Rd
;
6249 inst
.instruction
|= Rn
<< 3;
6251 inst
.instruction
|= Rs
<< 3;
6253 constraint (1, _("dest must overlap one source register"));
6260 unsigned int msb
= inst
.operands
[1].imm
+ inst
.operands
[2].imm
;
6261 constraint (msb
> 32, _("bit-field extends past end of register"));
6262 /* The instruction encoding stores the LSB and MSB,
6263 not the LSB and width. */
6264 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6265 inst
.instruction
|= (inst
.operands
[1].imm
& 0x1c) << 10;
6266 inst
.instruction
|= (inst
.operands
[1].imm
& 0x03) << 6;
6267 inst
.instruction
|= msb
- 1;
6275 /* #0 in second position is alternative syntax for bfc, which is
6276 the same instruction but with REG_PC in the Rm field. */
6277 if (!inst
.operands
[1].isreg
)
6278 inst
.operands
[1].reg
= REG_PC
;
6280 msb
= inst
.operands
[2].imm
+ inst
.operands
[3].imm
;
6281 constraint (msb
> 32, _("bit-field extends past end of register"));
6282 /* The instruction encoding stores the LSB and MSB,
6283 not the LSB and width. */
6284 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6285 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
6286 inst
.instruction
|= (inst
.operands
[2].imm
& 0x1c) << 10;
6287 inst
.instruction
|= (inst
.operands
[2].imm
& 0x03) << 6;
6288 inst
.instruction
|= msb
- 1;
6294 constraint (inst
.operands
[2].imm
+ inst
.operands
[3].imm
> 32,
6295 _("bit-field extends past end of register"));
6296 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6297 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
6298 inst
.instruction
|= (inst
.operands
[2].imm
& 0x1c) << 10;
6299 inst
.instruction
|= (inst
.operands
[2].imm
& 0x03) << 6;
6300 inst
.instruction
|= inst
.operands
[3].imm
- 1;
6303 /* ARM V5 Thumb BLX (argument parse)
6304 BLX <target_addr> which is BLX(1)
6305 BLX <Rm> which is BLX(2)
6306 Unfortunately, there are two different opcodes for this mnemonic.
6307 So, the insns[].value is not used, and the code here zaps values
6308 into inst.instruction.
6310 ??? How to take advantage of the additional two bits of displacement
6311 available in Thumb32 mode? Need new relocation? */
6316 if (inst
.operands
[0].isreg
)
6317 /* We have a register, so this is BLX(2). */
6318 inst
.instruction
|= inst
.operands
[0].reg
<< 3;
6321 /* No register. This must be BLX(1). */
6322 inst
.instruction
= 0xf000e800;
6323 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BLX
;
6324 inst
.reloc
.pc_rel
= 1;
6332 if (inst
.cond
!= COND_ALWAYS
)
6333 opcode
= T_MNEM_bcond
;
6335 opcode
= inst
.instruction
;
6337 if (unified_syntax
&& inst
.size_req
== 4)
6339 inst
.instruction
= THUMB_OP32(opcode
);
6340 if (inst
.cond
== COND_ALWAYS
)
6341 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH25
;
6344 assert (inst
.cond
!= 0xF);
6345 inst
.instruction
|= inst
.cond
<< 22;
6346 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH20
;
6351 inst
.instruction
= THUMB_OP16(opcode
);
6352 if (inst
.cond
== COND_ALWAYS
)
6353 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH12
;
6356 inst
.instruction
|= inst
.cond
<< 8;
6357 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH9
;
6359 /* Allow section relaxation. */
6360 if (unified_syntax
&& inst
.size_req
!= 2)
6361 inst
.relax
= opcode
;
6364 inst
.reloc
.pc_rel
= 1;
6370 if (inst
.operands
[0].present
)
6372 constraint (inst
.operands
[0].imm
> 255,
6373 _("immediate value out of range"));
6374 inst
.instruction
|= inst
.operands
[0].imm
;
6379 do_t_branch23 (void)
6381 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH23
;
6382 inst
.reloc
.pc_rel
= 1;
6384 /* If the destination of the branch is a defined symbol which does not have
6385 the THUMB_FUNC attribute, then we must be calling a function which has
6386 the (interfacearm) attribute. We look for the Thumb entry point to that
6387 function and change the branch to refer to that function instead. */
6388 if ( inst
.reloc
.exp
.X_op
== O_symbol
6389 && inst
.reloc
.exp
.X_add_symbol
!= NULL
6390 && S_IS_DEFINED (inst
.reloc
.exp
.X_add_symbol
)
6391 && ! THUMB_IS_FUNC (inst
.reloc
.exp
.X_add_symbol
))
6392 inst
.reloc
.exp
.X_add_symbol
=
6393 find_real_start (inst
.reloc
.exp
.X_add_symbol
);
6399 inst
.instruction
|= inst
.operands
[0].reg
<< 3;
6400 /* ??? FIXME: Should add a hacky reloc here if reg is REG_PC. The reloc
6401 should cause the alignment to be checked once it is known. This is
6402 because BX PC only works if the instruction is word aligned. */
6408 if (inst
.operands
[0].reg
== REG_PC
)
6409 as_tsktsk (_("use of r15 in bxj is not really useful"));
6411 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
6417 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6418 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
6419 inst
.instruction
|= inst
.operands
[1].reg
;
6426 && (inst
.operands
[1].present
|| inst
.size_req
== 4))
6428 unsigned int imod
= (inst
.instruction
& 0x0030) >> 4;
6429 inst
.instruction
= 0xf3af8000;
6430 inst
.instruction
|= imod
<< 9;
6431 inst
.instruction
|= inst
.operands
[0].imm
<< 5;
6432 if (inst
.operands
[1].present
)
6433 inst
.instruction
|= 0x100 | inst
.operands
[1].imm
;
6437 constraint (inst
.operands
[1].present
,
6438 _("Thumb does not support the 2-argument "
6439 "form of this instruction"));
6440 inst
.instruction
|= inst
.operands
[0].imm
;
6444 /* THUMB CPY instruction (argument parse). */
6449 if (inst
.size_req
== 4)
6451 inst
.instruction
= THUMB_OP32 (T_MNEM_mov
);
6452 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6453 inst
.instruction
|= inst
.operands
[1].reg
;
6457 inst
.instruction
|= (inst
.operands
[0].reg
& 0x8) << 4;
6458 inst
.instruction
|= (inst
.operands
[0].reg
& 0x7);
6459 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
6466 constraint (inst
.operands
[0].reg
> 7, BAD_HIREG
);
6467 inst
.instruction
|= inst
.operands
[0].reg
;
6468 inst
.reloc
.pc_rel
= 1;
6469 inst
.reloc
.type
= BFD_RELOC_THUMB_PCREL_BRANCH7
;
6475 if (unified_syntax
&& inst
.size_req
== 4)
6476 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6478 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6484 unsigned int cond
= inst
.operands
[0].imm
;
6486 current_it_mask
= (inst
.instruction
& 0xf) | 0x10;
6489 /* If the condition is a negative condition, invert the mask. */
6490 if ((cond
& 0x1) == 0x0)
6492 unsigned int mask
= inst
.instruction
& 0x000f;
6494 if ((mask
& 0x7) == 0)
6495 /* no conversion needed */;
6496 else if ((mask
& 0x3) == 0)
6498 else if ((mask
& 0x1) == 0)
6503 inst
.instruction
&= 0xfff0;
6504 inst
.instruction
|= mask
;
6507 inst
.instruction
|= cond
<< 4;
6513 /* This really doesn't seem worth it. */
6514 constraint (inst
.reloc
.type
!= BFD_RELOC_UNUSED
,
6515 _("expression too complex"));
6516 constraint (inst
.operands
[1].writeback
,
6517 _("Thumb load/store multiple does not support {reglist}^"));
6521 /* See if we can use a 16-bit instruction. */
6522 if (inst
.instruction
< 0xffff /* not ldmdb/stmdb */
6523 && inst
.size_req
!= 4
6524 && inst
.operands
[0].reg
<= 7
6525 && !(inst
.operands
[1].imm
& ~0xff)
6526 && (inst
.instruction
== T_MNEM_stmia
6527 ? inst
.operands
[0].writeback
6528 : (inst
.operands
[0].writeback
6529 == !(inst
.operands
[1].imm
& (1 << inst
.operands
[0].reg
)))))
6531 if (inst
.instruction
== T_MNEM_stmia
6532 && (inst
.operands
[1].imm
& (1 << inst
.operands
[0].reg
))
6533 && (inst
.operands
[1].imm
& ((1 << inst
.operands
[0].reg
) - 1)))
6534 as_warn (_("value stored for r%d is UNPREDICTABLE"),
6535 inst
.operands
[0].reg
);
6537 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6538 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6539 inst
.instruction
|= inst
.operands
[1].imm
;
6543 if (inst
.operands
[1].imm
& (1 << 13))
6544 as_warn (_("SP should not be in register list"));
6545 if (inst
.instruction
== T_MNEM_stmia
)
6547 if (inst
.operands
[1].imm
& (1 << 15))
6548 as_warn (_("PC should not be in register list"));
6549 if (inst
.operands
[1].imm
& (1 << inst
.operands
[0].reg
))
6550 as_warn (_("value stored for r%d is UNPREDICTABLE"),
6551 inst
.operands
[0].reg
);
6555 if (inst
.operands
[1].imm
& (1 << 14)
6556 && inst
.operands
[1].imm
& (1 << 15))
6557 as_warn (_("LR and PC should not both be in register list"));
6558 if ((inst
.operands
[1].imm
& (1 << inst
.operands
[0].reg
))
6559 && inst
.operands
[0].writeback
)
6560 as_warn (_("base register should not be in register list "
6561 "when written back"));
6563 if (inst
.instruction
< 0xffff)
6564 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6565 inst
.instruction
|= inst
.operands
[0].reg
<< 16;
6566 inst
.instruction
|= inst
.operands
[1].imm
;
6567 if (inst
.operands
[0].writeback
)
6568 inst
.instruction
|= WRITE_BACK
;
6573 constraint (inst
.operands
[0].reg
> 7
6574 || (inst
.operands
[1].imm
& ~0xff), BAD_HIREG
);
6575 if (inst
.instruction
== T_MNEM_stmia
)
6577 if (!inst
.operands
[0].writeback
)
6578 as_warn (_("this instruction will write back the base register"));
6579 if ((inst
.operands
[1].imm
& (1 << inst
.operands
[0].reg
))
6580 && (inst
.operands
[1].imm
& ((1 << inst
.operands
[0].reg
) - 1)))
6581 as_warn (_("value stored for r%d is UNPREDICTABLE"),
6582 inst
.operands
[0].reg
);
6586 if (!inst
.operands
[0].writeback
6587 && !(inst
.operands
[1].imm
& (1 << inst
.operands
[0].reg
)))
6588 as_warn (_("this instruction will write back the base register"));
6589 else if (inst
.operands
[0].writeback
6590 && (inst
.operands
[1].imm
& (1 << inst
.operands
[0].reg
)))
6591 as_warn (_("this instruction will not write back the base register"));
6594 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6595 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6596 inst
.instruction
|= inst
.operands
[1].imm
;
6603 constraint (!inst
.operands
[1].isreg
|| !inst
.operands
[1].preind
6604 || inst
.operands
[1].postind
|| inst
.operands
[1].writeback
6605 || inst
.operands
[1].immisreg
|| inst
.operands
[1].shifted
6606 || inst
.operands
[1].negative
,
6607 _("instruction does not accept this addressing mode"));
6609 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6610 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
6611 inst
.reloc
.type
= BFD_RELOC_ARM_T32_OFFSET_U8
;
6617 if (!inst
.operands
[1].present
)
6619 constraint (inst
.operands
[0].reg
== REG_LR
,
6620 _("r14 not allowed as first register "
6621 "when second register is omitted"));
6622 inst
.operands
[1].reg
= inst
.operands
[0].reg
+ 1;
6624 constraint (inst
.operands
[0].reg
== inst
.operands
[1].reg
,
6627 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6628 inst
.instruction
|= inst
.operands
[1].reg
<< 8;
6629 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
6635 unsigned long opcode
;
6638 opcode
= inst
.instruction
;
6641 if (inst
.operands
[1].isreg
6642 && !inst
.operands
[1].writeback
6643 && !inst
.operands
[1].shifted
&& !inst
.operands
[1].postind
6644 && !inst
.operands
[1].negative
&& inst
.operands
[0].reg
<= 7
6646 && inst
.size_req
!= 4)
6648 /* Insn may have a 16-bit form. */
6649 Rn
= inst
.operands
[1].reg
;
6650 if (inst
.operands
[1].immisreg
)
6652 inst
.instruction
= THUMB_OP16 (opcode
);
6654 if (Rn
<= 7 && inst
.operands
[1].imm
<= 7)
6657 else if ((Rn
<= 7 && opcode
!= T_MNEM_ldrsh
6658 && opcode
!= T_MNEM_ldrsb
)
6659 || ((Rn
== REG_PC
|| Rn
== REG_SP
) && opcode
== T_MNEM_ldr
)
6660 || (Rn
== REG_SP
&& opcode
== T_MNEM_str
))
6667 if (inst
.reloc
.pc_rel
)
6668 opcode
= T_MNEM_ldr_pc2
;
6670 opcode
= T_MNEM_ldr_pc
;
6674 if (opcode
== T_MNEM_ldr
)
6675 opcode
= T_MNEM_ldr_sp
;
6677 opcode
= T_MNEM_str_sp
;
6679 inst
.instruction
= inst
.operands
[0].reg
<< 8;
6683 inst
.instruction
= inst
.operands
[0].reg
;
6684 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
6686 inst
.instruction
|= THUMB_OP16 (opcode
);
6687 if (inst
.size_req
== 2)
6688 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_OFFSET
;
6690 inst
.relax
= opcode
;
6694 /* Definitely a 32-bit variant. */
6695 inst
.instruction
= THUMB_OP32 (opcode
);
6696 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6697 encode_thumb32_addr_mode (1, /*is_t=*/FALSE
, /*is_d=*/FALSE
);
6701 constraint (inst
.operands
[0].reg
> 7, BAD_HIREG
);
6703 if (inst
.instruction
== T_MNEM_ldrsh
|| inst
.instruction
== T_MNEM_ldrsb
)
6705 /* Only [Rn,Rm] is acceptable. */
6706 constraint (inst
.operands
[1].reg
> 7 || inst
.operands
[1].imm
> 7, BAD_HIREG
);
6707 constraint (!inst
.operands
[1].isreg
|| !inst
.operands
[1].immisreg
6708 || inst
.operands
[1].postind
|| inst
.operands
[1].shifted
6709 || inst
.operands
[1].negative
,
6710 _("Thumb does not support this addressing mode"));
6711 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6715 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6716 if (!inst
.operands
[1].isreg
)
6717 if (move_or_literal_pool (0, /*thumb_p=*/TRUE
, /*mode_3=*/FALSE
))
6720 constraint (!inst
.operands
[1].preind
6721 || inst
.operands
[1].shifted
6722 || inst
.operands
[1].writeback
,
6723 _("Thumb does not support this addressing mode"));
6724 if (inst
.operands
[1].reg
== REG_PC
|| inst
.operands
[1].reg
== REG_SP
)
6726 constraint (inst
.instruction
& 0x0600,
6727 _("byte or halfword not valid for base register"));
6728 constraint (inst
.operands
[1].reg
== REG_PC
6729 && !(inst
.instruction
& THUMB_LOAD_BIT
),
6730 _("r15 based store not allowed"));
6731 constraint (inst
.operands
[1].immisreg
,
6732 _("invalid base register for register offset"));
6734 if (inst
.operands
[1].reg
== REG_PC
)
6735 inst
.instruction
= T_OPCODE_LDR_PC
;
6736 else if (inst
.instruction
& THUMB_LOAD_BIT
)
6737 inst
.instruction
= T_OPCODE_LDR_SP
;
6739 inst
.instruction
= T_OPCODE_STR_SP
;
6741 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6742 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_OFFSET
;
6746 constraint (inst
.operands
[1].reg
> 7, BAD_HIREG
);
6747 if (!inst
.operands
[1].immisreg
)
6749 /* Immediate offset. */
6750 inst
.instruction
|= inst
.operands
[0].reg
;
6751 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
6752 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_OFFSET
;
6756 /* Register offset. */
6757 constraint (inst
.operands
[1].imm
> 7, BAD_HIREG
);
6758 constraint (inst
.operands
[1].negative
,
6759 _("Thumb does not support this addressing mode"));
6762 switch (inst
.instruction
)
6764 case T_OPCODE_STR_IW
: inst
.instruction
= T_OPCODE_STR_RW
; break;
6765 case T_OPCODE_STR_IH
: inst
.instruction
= T_OPCODE_STR_RH
; break;
6766 case T_OPCODE_STR_IB
: inst
.instruction
= T_OPCODE_STR_RB
; break;
6767 case T_OPCODE_LDR_IW
: inst
.instruction
= T_OPCODE_LDR_RW
; break;
6768 case T_OPCODE_LDR_IH
: inst
.instruction
= T_OPCODE_LDR_RH
; break;
6769 case T_OPCODE_LDR_IB
: inst
.instruction
= T_OPCODE_LDR_RB
; break;
6770 case 0x5600 /* ldrsb */:
6771 case 0x5e00 /* ldrsh */: break;
6775 inst
.instruction
|= inst
.operands
[0].reg
;
6776 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
6777 inst
.instruction
|= inst
.operands
[1].imm
<< 6;
6783 if (!inst
.operands
[1].present
)
6785 inst
.operands
[1].reg
= inst
.operands
[0].reg
+ 1;
6786 constraint (inst
.operands
[0].reg
== REG_LR
,
6787 _("r14 not allowed here"));
6789 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6790 inst
.instruction
|= inst
.operands
[1].reg
<< 8;
6791 encode_thumb32_addr_mode (2, /*is_t=*/FALSE
, /*is_d=*/TRUE
);
6798 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6799 encode_thumb32_addr_mode (1, /*is_t=*/TRUE
, /*is_d=*/FALSE
);
6805 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6806 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
6807 inst
.instruction
|= inst
.operands
[2].reg
;
6808 inst
.instruction
|= inst
.operands
[3].reg
<< 12;
6814 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
6815 inst
.instruction
|= inst
.operands
[1].reg
<< 8;
6816 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
6817 inst
.instruction
|= inst
.operands
[3].reg
;
6825 int r0off
= (inst
.instruction
== T_MNEM_mov
6826 || inst
.instruction
== T_MNEM_movs
) ? 8 : 16;
6827 unsigned long opcode
;
6829 bfd_boolean low_regs
;
6831 low_regs
= (inst
.operands
[0].reg
<= 7 && inst
.operands
[1].reg
<= 7);
6832 opcode
= inst
.instruction
;
6833 if (current_it_mask
)
6834 narrow
= opcode
!= T_MNEM_movs
;
6836 narrow
= opcode
!= T_MNEM_movs
|| low_regs
;
6837 if (inst
.size_req
== 4
6838 || inst
.operands
[1].shifted
)
6841 if (!inst
.operands
[1].isreg
)
6843 /* Immediate operand. */
6844 if (current_it_mask
== 0 && opcode
== T_MNEM_mov
)
6846 if (low_regs
&& narrow
)
6848 inst
.instruction
= THUMB_OP16 (opcode
);
6849 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6850 if (inst
.size_req
== 2)
6851 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_IMM
;
6853 inst
.relax
= opcode
;
6857 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6858 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
6859 inst
.instruction
|= inst
.operands
[0].reg
<< r0off
;
6860 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
6865 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6866 inst
.instruction
|= inst
.operands
[0].reg
<< r0off
;
6867 encode_thumb32_shifted_operand (1);
6870 switch (inst
.instruction
)
6873 inst
.instruction
= T_OPCODE_MOV_HR
;
6874 inst
.instruction
|= (inst
.operands
[0].reg
& 0x8) << 4;
6875 inst
.instruction
|= (inst
.operands
[0].reg
& 0x7);
6876 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
6880 /* We know we have low registers at this point.
6881 Generate ADD Rd, Rs, #0. */
6882 inst
.instruction
= T_OPCODE_ADD_I3
;
6883 inst
.instruction
|= inst
.operands
[0].reg
;
6884 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
6890 inst
.instruction
= T_OPCODE_CMP_LR
;
6891 inst
.instruction
|= inst
.operands
[0].reg
;
6892 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
6896 inst
.instruction
= T_OPCODE_CMP_HR
;
6897 inst
.instruction
|= (inst
.operands
[0].reg
& 0x8) << 4;
6898 inst
.instruction
|= (inst
.operands
[0].reg
& 0x7);
6899 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
6906 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6907 if (inst
.operands
[1].isreg
)
6909 if (inst
.operands
[0].reg
< 8 && inst
.operands
[1].reg
< 8)
6911 /* A move of two lowregs is encoded as ADD Rd, Rs, #0
6912 since a MOV instruction produces unpredictable results. */
6913 if (inst
.instruction
== T_OPCODE_MOV_I8
)
6914 inst
.instruction
= T_OPCODE_ADD_I3
;
6916 inst
.instruction
= T_OPCODE_CMP_LR
;
6918 inst
.instruction
|= inst
.operands
[0].reg
;
6919 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
6923 if (inst
.instruction
== T_OPCODE_MOV_I8
)
6924 inst
.instruction
= T_OPCODE_MOV_HR
;
6926 inst
.instruction
= T_OPCODE_CMP_HR
;
6932 constraint (inst
.operands
[0].reg
> 7,
6933 _("only lo regs allowed with immediate"));
6934 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6935 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_IMM
;
6942 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
6943 inst
.instruction
|= (inst
.operands
[1].imm
& 0xf000) << 4;
6944 inst
.instruction
|= (inst
.operands
[1].imm
& 0x0800) << 15;
6945 inst
.instruction
|= (inst
.operands
[1].imm
& 0x0700) << 4;
6946 inst
.instruction
|= (inst
.operands
[1].imm
& 0x00ff);
6954 int r0off
= (inst
.instruction
== T_MNEM_mvn
6955 || inst
.instruction
== T_MNEM_mvns
) ? 8 : 16;
6958 if (inst
.size_req
== 4
6959 || inst
.instruction
> 0xffff
6960 || inst
.operands
[1].shifted
6961 || inst
.operands
[0].reg
> 7 || inst
.operands
[1].reg
> 7)
6963 else if (inst
.instruction
== T_MNEM_cmn
)
6965 else if (THUMB_SETS_FLAGS (inst
.instruction
))
6966 narrow
= (current_it_mask
== 0);
6968 narrow
= (current_it_mask
!= 0);
6970 if (!inst
.operands
[1].isreg
)
6972 /* For an immediate, we always generate a 32-bit opcode;
6973 section relaxation will shrink it later if possible. */
6974 if (inst
.instruction
< 0xffff)
6975 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6976 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
6977 inst
.instruction
|= inst
.operands
[0].reg
<< r0off
;
6978 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
6982 /* See if we can do this with a 16-bit instruction. */
6985 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
6986 inst
.instruction
|= inst
.operands
[0].reg
;
6987 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
6991 constraint (inst
.operands
[1].shifted
6992 && inst
.operands
[1].immisreg
,
6993 _("shift must be constant"));
6994 if (inst
.instruction
< 0xffff)
6995 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
6996 inst
.instruction
|= inst
.operands
[0].reg
<< r0off
;
6997 encode_thumb32_shifted_operand (1);
7003 constraint (inst
.instruction
> 0xffff
7004 || inst
.instruction
== T_MNEM_mvns
, BAD_THUMB32
);
7005 constraint (!inst
.operands
[1].isreg
|| inst
.operands
[1].shifted
,
7006 _("unshifted register required"));
7007 constraint (inst
.operands
[0].reg
> 7 || inst
.operands
[1].reg
> 7,
7010 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
7011 inst
.instruction
|= inst
.operands
[0].reg
;
7012 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
7019 /* mrs only accepts CPSR/SPSR/CPSR_all/SPSR_all. */
7020 constraint ((inst
.operands
[1].imm
& (PSR_c
|PSR_x
|PSR_s
|PSR_f
))
7022 _("'CPSR' or 'SPSR' expected"));
7023 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7024 inst
.instruction
|= (inst
.operands
[1].imm
& SPSR_BIT
) >> 2;
7030 constraint (!inst
.operands
[1].isreg
,
7031 _("Thumb encoding does not support an immediate here"));
7032 inst
.instruction
|= (inst
.operands
[0].imm
& SPSR_BIT
) >> 2;
7033 inst
.instruction
|= (inst
.operands
[0].imm
& ~SPSR_BIT
) >> 8;
7034 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7040 if (!inst
.operands
[2].present
)
7041 inst
.operands
[2].reg
= inst
.operands
[0].reg
;
7043 /* There is no 32-bit MULS and no 16-bit MUL. */
7044 if (unified_syntax
&& inst
.instruction
== T_MNEM_mul
)
7046 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
7047 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7048 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7049 inst
.instruction
|= inst
.operands
[2].reg
<< 0;
7053 constraint (!unified_syntax
7054 && inst
.instruction
== T_MNEM_muls
, BAD_THUMB32
);
7055 constraint (inst
.operands
[0].reg
> 7 || inst
.operands
[1].reg
> 7,
7058 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
7059 inst
.instruction
|= inst
.operands
[0].reg
;
7061 if (inst
.operands
[0].reg
== inst
.operands
[1].reg
)
7062 inst
.instruction
|= inst
.operands
[2].reg
<< 3;
7063 else if (inst
.operands
[0].reg
== inst
.operands
[2].reg
)
7064 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
7066 constraint (1, _("dest must overlap one source register"));
7073 inst
.instruction
|= inst
.operands
[0].reg
<< 12;
7074 inst
.instruction
|= inst
.operands
[1].reg
<< 8;
7075 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
7076 inst
.instruction
|= inst
.operands
[3].reg
;
7078 if (inst
.operands
[0].reg
== inst
.operands
[1].reg
)
7079 as_tsktsk (_("rdhi and rdlo must be different"));
7087 if (inst
.size_req
== 4 || inst
.operands
[0].imm
> 15)
7089 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
7090 inst
.instruction
|= inst
.operands
[0].imm
;
7094 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
7095 inst
.instruction
|= inst
.operands
[0].imm
<< 4;
7100 constraint (inst
.operands
[0].present
,
7101 _("Thumb does not support NOP with hints"));
7102 inst
.instruction
= 0x46c0;
7113 if (THUMB_SETS_FLAGS (inst
.instruction
))
7114 narrow
= (current_it_mask
== 0);
7116 narrow
= (current_it_mask
!= 0);
7117 if (inst
.operands
[0].reg
> 7 || inst
.operands
[1].reg
> 7)
7119 if (inst
.size_req
== 4)
7124 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
7125 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7126 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7130 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
7131 inst
.instruction
|= inst
.operands
[0].reg
;
7132 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
7137 constraint (inst
.operands
[0].reg
> 7 || inst
.operands
[1].reg
> 7,
7139 constraint (THUMB_SETS_FLAGS (inst
.instruction
), BAD_THUMB32
);
7141 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
7142 inst
.instruction
|= inst
.operands
[0].reg
;
7143 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
7150 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7151 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7152 inst
.instruction
|= inst
.operands
[2].reg
;
7153 if (inst
.operands
[3].present
)
7155 unsigned int val
= inst
.reloc
.exp
.X_add_number
;
7156 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
7157 _("expression too complex"));
7158 inst
.instruction
|= (val
& 0x1c) << 10;
7159 inst
.instruction
|= (val
& 0x03) << 6;
7166 if (!inst
.operands
[3].present
)
7167 inst
.instruction
&= ~0x00000020;
7174 encode_thumb32_addr_mode (0, /*is_t=*/FALSE
, /*is_d=*/FALSE
);
7178 do_t_push_pop (void)
7182 constraint (inst
.operands
[0].writeback
,
7183 _("push/pop do not support {reglist}^"));
7184 constraint (inst
.reloc
.type
!= BFD_RELOC_UNUSED
,
7185 _("expression too complex"));
7187 mask
= inst
.operands
[0].imm
;
7188 if ((mask
& ~0xff) == 0)
7189 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
7190 else if ((inst
.instruction
== T_MNEM_push
7191 && (mask
& ~0xff) == 1 << REG_LR
)
7192 || (inst
.instruction
== T_MNEM_pop
7193 && (mask
& ~0xff) == 1 << REG_PC
))
7195 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
7196 inst
.instruction
|= THUMB_PP_PC_LR
;
7199 else if (unified_syntax
)
7201 if (mask
& (1 << 13))
7202 inst
.error
= _("SP not allowed in register list");
7203 if (inst
.instruction
== T_MNEM_push
)
7205 if (mask
& (1 << 15))
7206 inst
.error
= _("PC not allowed in register list");
7210 if (mask
& (1 << 14)
7211 && mask
& (1 << 15))
7212 inst
.error
= _("LR and PC should not both be in register list");
7214 if ((mask
& (mask
- 1)) == 0)
7216 /* Single register push/pop implemented as str/ldr. */
7217 if (inst
.instruction
== T_MNEM_push
)
7218 inst
.instruction
= 0xf84d0d04; /* str reg, [sp, #-4]! */
7220 inst
.instruction
= 0xf85d0b04; /* ldr reg, [sp], #4 */
7221 mask
= ffs(mask
) - 1;
7225 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
7229 inst
.error
= _("invalid register list to push/pop instruction");
7233 inst
.instruction
|= mask
;
7239 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7240 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7246 if (inst
.operands
[0].reg
<= 7 && inst
.operands
[1].reg
<= 7
7247 && inst
.size_req
!= 4)
7249 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
7250 inst
.instruction
|= inst
.operands
[0].reg
;
7251 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
7253 else if (unified_syntax
)
7255 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
7256 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7257 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7258 inst
.instruction
|= inst
.operands
[1].reg
;
7261 inst
.error
= BAD_HIREG
;
7269 Rd
= inst
.operands
[0].reg
;
7270 Rs
= (inst
.operands
[1].present
7271 ? inst
.operands
[1].reg
/* Rd, Rs, foo */
7272 : inst
.operands
[0].reg
); /* Rd, foo -> Rd, Rd, foo */
7274 inst
.instruction
|= Rd
<< 8;
7275 inst
.instruction
|= Rs
<< 16;
7276 if (!inst
.operands
[2].isreg
)
7278 inst
.instruction
= (inst
.instruction
& 0xe1ffffff) | 0x10000000;
7279 inst
.reloc
.type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
7282 encode_thumb32_shifted_operand (2);
7288 if (inst
.operands
[0].imm
)
7289 inst
.instruction
|= 0x8;
7295 if (!inst
.operands
[1].present
)
7296 inst
.operands
[1].reg
= inst
.operands
[0].reg
;
7303 switch (inst
.instruction
)
7306 case T_MNEM_asrs
: shift_kind
= SHIFT_ASR
; break;
7308 case T_MNEM_lsls
: shift_kind
= SHIFT_LSL
; break;
7310 case T_MNEM_lsrs
: shift_kind
= SHIFT_LSR
; break;
7312 case T_MNEM_rors
: shift_kind
= SHIFT_ROR
; break;
7316 if (THUMB_SETS_FLAGS (inst
.instruction
))
7317 narrow
= (current_it_mask
== 0);
7319 narrow
= (current_it_mask
!= 0);
7320 if (inst
.operands
[0].reg
> 7 || inst
.operands
[1].reg
> 7)
7322 if (!inst
.operands
[2].isreg
&& shift_kind
== SHIFT_ROR
)
7324 if (inst
.operands
[2].isreg
7325 && (inst
.operands
[1].reg
!= inst
.operands
[0].reg
7326 || inst
.operands
[2].reg
> 7))
7328 if (inst
.size_req
== 4)
7333 if (inst
.operands
[2].isreg
)
7335 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
7336 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7337 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7338 inst
.instruction
|= inst
.operands
[2].reg
;
7342 inst
.operands
[1].shifted
= 1;
7343 inst
.operands
[1].shift_kind
= shift_kind
;
7344 inst
.instruction
= THUMB_OP32 (THUMB_SETS_FLAGS (inst
.instruction
)
7345 ? T_MNEM_movs
: T_MNEM_mov
);
7346 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7347 encode_thumb32_shifted_operand (1);
7348 /* Prevent the incorrect generation of an ARM_IMMEDIATE fixup. */
7349 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
7354 if (inst
.operands
[2].isreg
)
7358 case SHIFT_ASR
: inst
.instruction
= T_OPCODE_ASR_R
; break;
7359 case SHIFT_LSL
: inst
.instruction
= T_OPCODE_LSL_R
; break;
7360 case SHIFT_LSR
: inst
.instruction
= T_OPCODE_LSR_R
; break;
7361 case SHIFT_ROR
: inst
.instruction
= T_OPCODE_ROR_R
; break;
7365 inst
.instruction
|= inst
.operands
[0].reg
;
7366 inst
.instruction
|= inst
.operands
[2].reg
<< 3;
7372 case SHIFT_ASR
: inst
.instruction
= T_OPCODE_ASR_I
; break;
7373 case SHIFT_LSL
: inst
.instruction
= T_OPCODE_LSL_I
; break;
7374 case SHIFT_LSR
: inst
.instruction
= T_OPCODE_LSR_I
; break;
7377 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_SHIFT
;
7378 inst
.instruction
|= inst
.operands
[0].reg
;
7379 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
7385 constraint (inst
.operands
[0].reg
> 7
7386 || inst
.operands
[1].reg
> 7, BAD_HIREG
);
7387 constraint (THUMB_SETS_FLAGS (inst
.instruction
), BAD_THUMB32
);
7389 if (inst
.operands
[2].isreg
) /* Rd, {Rs,} Rn */
7391 constraint (inst
.operands
[2].reg
> 7, BAD_HIREG
);
7392 constraint (inst
.operands
[0].reg
!= inst
.operands
[1].reg
,
7393 _("source1 and dest must be same register"));
7395 switch (inst
.instruction
)
7397 case T_MNEM_asr
: inst
.instruction
= T_OPCODE_ASR_R
; break;
7398 case T_MNEM_lsl
: inst
.instruction
= T_OPCODE_LSL_R
; break;
7399 case T_MNEM_lsr
: inst
.instruction
= T_OPCODE_LSR_R
; break;
7400 case T_MNEM_ror
: inst
.instruction
= T_OPCODE_ROR_R
; break;
7404 inst
.instruction
|= inst
.operands
[0].reg
;
7405 inst
.instruction
|= inst
.operands
[2].reg
<< 3;
7409 switch (inst
.instruction
)
7411 case T_MNEM_asr
: inst
.instruction
= T_OPCODE_ASR_I
; break;
7412 case T_MNEM_lsl
: inst
.instruction
= T_OPCODE_LSL_I
; break;
7413 case T_MNEM_lsr
: inst
.instruction
= T_OPCODE_LSR_I
; break;
7414 case T_MNEM_ror
: inst
.error
= _("ror #imm not supported"); return;
7417 inst
.reloc
.type
= BFD_RELOC_ARM_THUMB_SHIFT
;
7418 inst
.instruction
|= inst
.operands
[0].reg
;
7419 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
7427 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7428 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7429 inst
.instruction
|= inst
.operands
[2].reg
;
7435 unsigned int value
= inst
.reloc
.exp
.X_add_number
;
7436 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
7437 _("expression too complex"));
7438 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
7439 inst
.instruction
|= (value
& 0xf000) >> 12;
7440 inst
.instruction
|= (value
& 0x0ff0);
7441 inst
.instruction
|= (value
& 0x000f) << 16;
7447 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7448 inst
.instruction
|= inst
.operands
[1].imm
- 1;
7449 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
7451 if (inst
.operands
[3].present
)
7453 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
7454 _("expression too complex"));
7456 if (inst
.reloc
.exp
.X_add_number
!= 0)
7458 if (inst
.operands
[3].shift_kind
== SHIFT_ASR
)
7459 inst
.instruction
|= 0x00200000; /* sh bit */
7460 inst
.instruction
|= (inst
.reloc
.exp
.X_add_number
& 0x1c) << 10;
7461 inst
.instruction
|= (inst
.reloc
.exp
.X_add_number
& 0x03) << 6;
7463 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
7470 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7471 inst
.instruction
|= inst
.operands
[1].imm
- 1;
7472 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
7478 constraint (!inst
.operands
[2].isreg
|| !inst
.operands
[2].preind
7479 || inst
.operands
[2].postind
|| inst
.operands
[2].writeback
7480 || inst
.operands
[2].immisreg
|| inst
.operands
[2].shifted
7481 || inst
.operands
[2].negative
,
7482 _("instruction does not accept this addressing mode"));
7484 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7485 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
7486 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
7487 inst
.reloc
.type
= BFD_RELOC_ARM_T32_OFFSET_U8
;
7493 if (!inst
.operands
[2].present
)
7494 inst
.operands
[2].reg
= inst
.operands
[1].reg
+ 1;
7496 constraint (inst
.operands
[0].reg
== inst
.operands
[1].reg
7497 || inst
.operands
[0].reg
== inst
.operands
[2].reg
7498 || inst
.operands
[0].reg
== inst
.operands
[3].reg
7499 || inst
.operands
[1].reg
== inst
.operands
[2].reg
,
7502 inst
.instruction
|= inst
.operands
[0].reg
;
7503 inst
.instruction
|= inst
.operands
[1].reg
<< 12;
7504 inst
.instruction
|= inst
.operands
[2].reg
<< 8;
7505 inst
.instruction
|= inst
.operands
[3].reg
<< 16;
7511 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7512 inst
.instruction
|= inst
.operands
[1].reg
<< 16;
7513 inst
.instruction
|= inst
.operands
[2].reg
;
7514 inst
.instruction
|= inst
.operands
[3].imm
<< 4;
7520 if (inst
.instruction
<= 0xffff && inst
.size_req
!= 4
7521 && inst
.operands
[0].reg
<= 7 && inst
.operands
[1].reg
<= 7
7522 && (!inst
.operands
[2].present
|| inst
.operands
[2].imm
== 0))
7524 inst
.instruction
= THUMB_OP16 (inst
.instruction
);
7525 inst
.instruction
|= inst
.operands
[0].reg
;
7526 inst
.instruction
|= inst
.operands
[1].reg
<< 3;
7528 else if (unified_syntax
)
7530 if (inst
.instruction
<= 0xffff)
7531 inst
.instruction
= THUMB_OP32 (inst
.instruction
);
7532 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7533 inst
.instruction
|= inst
.operands
[1].reg
;
7534 inst
.instruction
|= inst
.operands
[2].imm
<< 4;
7538 constraint (inst
.operands
[2].present
&& inst
.operands
[2].imm
!= 0,
7539 _("Thumb encoding does not support rotation"));
7540 constraint (1, BAD_HIREG
);
7547 inst
.reloc
.type
= BFD_RELOC_ARM_SWI
;
7555 half
= (inst
.instruction
& 0x10) != 0;
7556 constraint (inst
.operands
[0].imm
== 15,
7557 _("PC is not a valid index register"));
7558 constraint (!half
&& inst
.operands
[0].shifted
,
7559 _("instruction does not allow shifted index"));
7560 constraint (half
&& !inst
.operands
[0].shifted
,
7561 _("instruction requires shifted index"));
7562 inst
.instruction
|= (inst
.operands
[0].reg
<< 16) | inst
.operands
[0].imm
;
7568 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7569 inst
.instruction
|= inst
.operands
[1].imm
;
7570 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
7572 if (inst
.operands
[3].present
)
7574 constraint (inst
.reloc
.exp
.X_op
!= O_constant
,
7575 _("expression too complex"));
7576 if (inst
.reloc
.exp
.X_add_number
!= 0)
7578 if (inst
.operands
[3].shift_kind
== SHIFT_ASR
)
7579 inst
.instruction
|= 0x00200000; /* sh bit */
7581 inst
.instruction
|= (inst
.reloc
.exp
.X_add_number
& 0x1c) << 10;
7582 inst
.instruction
|= (inst
.reloc
.exp
.X_add_number
& 0x03) << 6;
7584 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
7591 inst
.instruction
|= inst
.operands
[0].reg
<< 8;
7592 inst
.instruction
|= inst
.operands
[1].imm
;
7593 inst
.instruction
|= inst
.operands
[2].reg
<< 16;
7596 /* Overall per-instruction processing. */
7598 /* We need to be able to fix up arbitrary expressions in some statements.
7599 This is so that we can handle symbols that are an arbitrary distance from
7600 the pc. The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
7601 which returns part of an address in a form which will be valid for
7602 a data instruction. We do this by pushing the expression into a symbol
7603 in the expr_section, and creating a fix for that. */
7606 fix_new_arm (fragS
* frag
,
7621 new_fix
= fix_new_exp (frag
, where
, size
, exp
, pc_rel
, reloc
);
7625 new_fix
= fix_new (frag
, where
, size
, make_expr_symbol (exp
), 0,
7630 /* Mark whether the fix is to a THUMB instruction, or an ARM
7632 new_fix
->tc_fix_data
= thumb_mode
;
7635 /* Create a frg for an instruction requiring relaxation. */
7637 output_relax_insn (void)
7643 switch (inst
.reloc
.exp
.X_op
)
7646 sym
= inst
.reloc
.exp
.X_add_symbol
;
7647 offset
= inst
.reloc
.exp
.X_add_number
;
7651 offset
= inst
.reloc
.exp
.X_add_number
;
7654 sym
= make_expr_symbol (&inst
.reloc
.exp
);
7658 to
= frag_var (rs_machine_dependent
, INSN_SIZE
, THUMB_SIZE
,
7659 inst
.relax
, sym
, offset
, NULL
/*offset, opcode*/);
7660 md_number_to_chars (to
, inst
.instruction
, THUMB_SIZE
);
7663 dwarf2_emit_insn (INSN_SIZE
);
7667 /* Write a 32-bit thumb instruction to buf. */
7669 put_thumb32_insn (char * buf
, unsigned long insn
)
7671 md_number_to_chars (buf
, insn
>> 16, THUMB_SIZE
);
7672 md_number_to_chars (buf
+ THUMB_SIZE
, insn
, THUMB_SIZE
);
7676 output_inst (const char * str
)
7682 as_bad ("%s -- `%s'", inst
.error
, str
);
7686 output_relax_insn();
7692 to
= frag_more (inst
.size
);
7694 if (thumb_mode
&& (inst
.size
> THUMB_SIZE
))
7696 assert (inst
.size
== (2 * THUMB_SIZE
));
7697 put_thumb32_insn (to
, inst
.instruction
);
7699 else if (inst
.size
> INSN_SIZE
)
7701 assert (inst
.size
== (2 * INSN_SIZE
));
7702 md_number_to_chars (to
, inst
.instruction
, INSN_SIZE
);
7703 md_number_to_chars (to
+ INSN_SIZE
, inst
.instruction
, INSN_SIZE
);
7706 md_number_to_chars (to
, inst
.instruction
, inst
.size
);
7708 if (inst
.reloc
.type
!= BFD_RELOC_UNUSED
)
7709 fix_new_arm (frag_now
, to
- frag_now
->fr_literal
,
7710 inst
.size
, & inst
.reloc
.exp
, inst
.reloc
.pc_rel
,
7714 dwarf2_emit_insn (inst
.size
);
7718 /* Tag values used in struct asm_opcode's tag field. */
7721 OT_unconditional
, /* Instruction cannot be conditionalized.
7722 The ARM condition field is still 0xE. */
7723 OT_unconditionalF
, /* Instruction cannot be conditionalized
7724 and carries 0xF in its ARM condition field. */
7725 OT_csuffix
, /* Instruction takes a conditional suffix. */
7726 OT_cinfix3
, /* Instruction takes a conditional infix,
7727 beginning at character index 3. (In
7728 unified mode, it becomes a suffix.) */
7729 OT_csuf_or_in3
, /* Instruction takes either a conditional
7730 suffix or an infix at character index 3.
7731 (In unified mode, a suffix only. */
7732 OT_odd_infix_unc
, /* This is the unconditional variant of an
7733 instruction that takes a conditional infix
7734 at an unusual position. In unified mode,
7735 this variant will accept a suffix. */
7736 OT_odd_infix_0
/* Values greater than or equal to OT_odd_infix_0
7737 are the conditional variants of instructions that
7738 take conditional infixes in unusual positions.
7739 The infix appears at character index
7740 (tag - OT_odd_infix_0). These are not accepted
7744 /* Subroutine of md_assemble, responsible for looking up the primary
7745 opcode from the mnemonic the user wrote. STR points to the
7746 beginning of the mnemonic.
7748 This is not simply a hash table lookup, because of conditional
7749 variants. Most instructions have conditional variants, which are
7750 expressed with a _conditional affix_ to the mnemonic. If we were
7751 to encode each conditional variant as a literal string in the opcode
7752 table, it would have approximately 20,000 entries.
7754 Most mnemonics take this affix as a suffix, and in unified syntax,
7755 'most' is upgraded to 'all'. However, in the divided syntax, some
7756 instructions take the affix as an infix, notably the s-variants of
7757 the arithmetic instructions. Of those instructions, all but six
7758 have the infix appear after the third character of the mnemonic.
7760 Accordingly, the algorithm for looking up primary opcodes given
7763 1. Look up the identifier in the opcode table.
7764 If we find a match, go to step U.
7766 2. Look up the last two characters of the identifier in the
7767 conditions table. If we find a match, look up the first N-2
7768 characters of the identifier in the opcode table. If we
7769 find a match, go to step CE.
7771 3. Look up the fourth and fifth characters of the identifier in
7772 the conditions table. If we find a match, extract those
7773 characters from the identifier, and look up the remaining
7774 characters in the opcode table. If we find a match, go
7779 U. Examine the tag field of the opcode structure, in case this is
7780 one of the six instructions with its conditional infix in an
7781 unusual place. If it is, the tag tells us where to find the
7782 infix; look it up in the conditions table and set inst.cond
7783 accordingly. Otherwise, this is an unconditional instruction.
7784 Again set inst.cond accordingly. Return the opcode structure.
7786 CE. Examine the tag field to make sure this is an instruction that
7787 should receive a conditional suffix. If it is not, fail.
7788 Otherwise, set inst.cond from the suffix we already looked up,
7789 and return the opcode structure.
7791 CM. Examine the tag field to make sure this is an instruction that
7792 should receive a conditional infix after the third character.
7793 If it is not, fail. Otherwise, undo the edits to the current
7794 line of input and proceed as for case CE. */
7796 static const struct asm_opcode
*
7797 opcode_lookup (char **str
)
7801 const struct asm_opcode
*opcode
;
7802 const struct asm_cond
*cond
;
7804 /* Scan up to the end of the mnemonic, which must end in white space,
7805 '.' (in unified mode only), or end of string. */
7806 for (base
= end
= *str
; *end
!= '\0'; end
++)
7807 if (*end
== ' ' || (unified_syntax
&& *end
== '.'))
7813 /* Handle a possible width suffix. */
7816 if (end
[1] == 'w' && (end
[2] == ' ' || end
[2] == '\0'))
7818 else if (end
[1] == 'n' && (end
[2] == ' ' || end
[2] == '\0'))
7828 /* Look for unaffixed or special-case affixed mnemonic. */
7829 opcode
= hash_find_n (arm_ops_hsh
, base
, end
- base
);
7833 if (opcode
->tag
< OT_odd_infix_0
)
7835 inst
.cond
= COND_ALWAYS
;
7840 as_warn (_("conditional infixes are deprecated in unified syntax"));
7841 affix
= base
+ (opcode
->tag
- OT_odd_infix_0
);
7842 cond
= hash_find_n (arm_cond_hsh
, affix
, 2);
7845 inst
.cond
= cond
->value
;
7849 /* Cannot have a conditional suffix on a mnemonic of less than two
7854 /* Look for suffixed mnemonic. */
7856 cond
= hash_find_n (arm_cond_hsh
, affix
, 2);
7857 opcode
= hash_find_n (arm_ops_hsh
, base
, affix
- base
);
7861 switch (opcode
->tag
)
7864 case OT_odd_infix_unc
:
7865 /* Some mnemonics are ambiguous between infix and suffix
7866 conditions. Disambiguate based on assembly syntax. */
7867 if (!unified_syntax
)
7869 /* else fall through */
7872 case OT_csuf_or_in3
:
7873 inst
.cond
= cond
->value
;
7876 case OT_unconditional
:
7877 case OT_unconditionalF
:
7878 /* delayed diagnostic */
7879 inst
.error
= BAD_COND
;
7880 inst
.cond
= COND_ALWAYS
;
7888 /* Cannot have a usual-position infix on a mnemonic of less than
7889 six characters (five would be a suffix). */
7893 /* Look for infixed mnemonic in the usual position. */
7895 cond
= hash_find_n (arm_cond_hsh
, affix
, 2);
7899 memcpy (save
, affix
, 2);
7900 memmove (affix
, affix
+ 2, (end
- affix
) - 2);
7901 opcode
= hash_find_n (arm_ops_hsh
, base
, (end
- base
) - 2);
7902 memmove (affix
+ 2, affix
, (end
- affix
) - 2);
7903 memcpy (affix
, save
, 2);
7905 if (opcode
&& (opcode
->tag
== OT_cinfix3
|| opcode
->tag
== OT_csuf_or_in3
))
7909 as_warn (_("conditional infixes are deprecated in unified syntax"));
7911 inst
.cond
= cond
->value
;
7919 md_assemble (char *str
)
7922 const struct asm_opcode
* opcode
;
7924 /* Align the previous label if needed. */
7925 if (last_label_seen
!= NULL
)
7927 symbol_set_frag (last_label_seen
, frag_now
);
7928 S_SET_VALUE (last_label_seen
, (valueT
) frag_now_fix ());
7929 S_SET_SEGMENT (last_label_seen
, now_seg
);
7932 memset (&inst
, '\0', sizeof (inst
));
7933 inst
.reloc
.type
= BFD_RELOC_UNUSED
;
7935 opcode
= opcode_lookup (&p
);
7938 /* It wasn't an instruction, but it might be a register alias of
7939 the form alias .req reg. */
7940 if (!create_register_alias (str
, p
))
7941 as_bad (_("bad instruction `%s'"), str
);
7948 unsigned long variant
;
7950 variant
= cpu_variant
;
7951 /* Only allow coprocessor instructions on Thumb-2 capable devices. */
7952 if ((variant
& ARM_EXT_V6T2
) == 0)
7954 /* Check that this instruction is supported for this CPU. */
7955 if (thumb_mode
== 1 && (opcode
->tvariant
& variant
) == 0)
7957 as_bad (_("selected processor does not support `%s'"), str
);
7960 if (inst
.cond
!= COND_ALWAYS
&& !unified_syntax
7961 && opcode
->tencode
!= do_t_branch
)
7963 as_bad (_("Thumb does not support conditional execution"));
7967 /* Check conditional suffixes. */
7968 if (current_it_mask
)
7971 cond
= current_cc
^ ((current_it_mask
>> 4) & 1) ^ 1;
7972 if (cond
!= inst
.cond
)
7974 as_bad (_("incorrect condition in IT block"));
7977 current_it_mask
<<= 1;
7978 current_it_mask
&= 0x1f;
7980 else if (inst
.cond
!= COND_ALWAYS
&& opcode
->tencode
!= do_t_branch
)
7982 as_bad (_("thumb conditional instrunction not in IT block"));
7986 mapping_state (MAP_THUMB
);
7987 inst
.instruction
= opcode
->tvalue
;
7989 if (!parse_operands (p
, opcode
->operands
))
7992 /* Clear current_it_mask at the end of an IT block. */
7993 if (current_it_mask
== 0x10)
7994 current_it_mask
= 0;
7996 if (!(inst
.error
|| inst
.relax
))
7998 assert (inst
.instruction
< 0xe800 || inst
.instruction
> 0xffff);
7999 inst
.size
= (inst
.instruction
> 0xffff ? 4 : 2);
8000 if (inst
.size_req
&& inst
.size_req
!= inst
.size
)
8002 as_bad (_("cannot honor width suffix -- `%s'"), str
);
8009 /* Check that this instruction is supported for this CPU. */
8010 if ((opcode
->avariant
& cpu_variant
) == 0)
8012 as_bad (_("selected processor does not support `%s'"), str
);
8017 as_bad (_("width suffixes are invalid in ARM mode -- `%s'"), str
);
8021 mapping_state (MAP_ARM
);
8022 inst
.instruction
= opcode
->avalue
;
8023 if (opcode
->tag
== OT_unconditionalF
)
8024 inst
.instruction
|= 0xF << 28;
8026 inst
.instruction
|= inst
.cond
<< 28;
8027 inst
.size
= INSN_SIZE
;
8028 if (!parse_operands (p
, opcode
->operands
))
8034 /* Various frobbings of labels and their addresses. */
8037 arm_start_line_hook (void)
8039 last_label_seen
= NULL
;
8043 arm_frob_label (symbolS
* sym
)
8045 last_label_seen
= sym
;
8047 ARM_SET_THUMB (sym
, thumb_mode
);
8049 #if defined OBJ_COFF || defined OBJ_ELF
8050 ARM_SET_INTERWORK (sym
, support_interwork
);
8053 /* Note - do not allow local symbols (.Lxxx) to be labeled
8054 as Thumb functions. This is because these labels, whilst
8055 they exist inside Thumb code, are not the entry points for
8056 possible ARM->Thumb calls. Also, these labels can be used
8057 as part of a computed goto or switch statement. eg gcc
8058 can generate code that looks like this:
8070 The first instruction loads the address of the jump table.
8071 The second instruction converts a table index into a byte offset.
8072 The third instruction gets the jump address out of the table.
8073 The fourth instruction performs the jump.
8075 If the address stored at .Laaa is that of a symbol which has the
8076 Thumb_Func bit set, then the linker will arrange for this address
8077 to have the bottom bit set, which in turn would mean that the
8078 address computation performed by the third instruction would end
8079 up with the bottom bit set. Since the ARM is capable of unaligned
8080 word loads, the instruction would then load the incorrect address
8081 out of the jump table, and chaos would ensue. */
8082 if (label_is_thumb_function_name
8083 && (S_GET_NAME (sym
)[0] != '.' || S_GET_NAME (sym
)[1] != 'L')
8084 && (bfd_get_section_flags (stdoutput
, now_seg
) & SEC_CODE
) != 0)
8086 /* When the address of a Thumb function is taken the bottom
8087 bit of that address should be set. This will allow
8088 interworking between Arm and Thumb functions to work
8091 THUMB_SET_FUNC (sym
, 1);
8093 label_is_thumb_function_name
= FALSE
;
8097 dwarf2_emit_label (sym
);
8102 arm_data_in_code (void)
8104 if (thumb_mode
&& ! strncmp (input_line_pointer
+ 1, "data:", 5))
8106 *input_line_pointer
= '/';
8107 input_line_pointer
+= 5;
8108 *input_line_pointer
= 0;
8116 arm_canonicalize_symbol_name (char * name
)
8120 if (thumb_mode
&& (len
= strlen (name
)) > 5
8121 && streq (name
+ len
- 5, "/data"))
8122 *(name
+ len
- 5) = 0;
8127 /* Table of all register names defined by default. The user can
8128 define additional names with .req. Note that all register names
8129 should appear in both upper and lowercase variants. Some registers
8130 also have mixed-case names. */
8132 #define REGDEF(s,n,t) { #s, n, REG_TYPE_##t, TRUE }
8133 #define REGNUM(p,n,t) REGDEF(p##n, n, t)
8134 #define REGSET(p,t) \
8135 REGNUM(p, 0,t), REGNUM(p, 1,t), REGNUM(p, 2,t), REGNUM(p, 3,t), \
8136 REGNUM(p, 4,t), REGNUM(p, 5,t), REGNUM(p, 6,t), REGNUM(p, 7,t), \
8137 REGNUM(p, 8,t), REGNUM(p, 9,t), REGNUM(p,10,t), REGNUM(p,11,t), \
8138 REGNUM(p,12,t), REGNUM(p,13,t), REGNUM(p,14,t), REGNUM(p,15,t)
8140 static const struct reg_entry reg_names
[] =
8142 /* ARM integer registers. */
8143 REGSET(r
, RN
), REGSET(R
, RN
),
8145 /* ATPCS synonyms. */
8146 REGDEF(a1
,0,RN
), REGDEF(a2
,1,RN
), REGDEF(a3
, 2,RN
), REGDEF(a4
, 3,RN
),
8147 REGDEF(v1
,4,RN
), REGDEF(v2
,5,RN
), REGDEF(v3
, 6,RN
), REGDEF(v4
, 7,RN
),
8148 REGDEF(v5
,8,RN
), REGDEF(v6
,9,RN
), REGDEF(v7
,10,RN
), REGDEF(v8
,11,RN
),
8150 REGDEF(A1
,0,RN
), REGDEF(A2
,1,RN
), REGDEF(A3
, 2,RN
), REGDEF(A4
, 3,RN
),
8151 REGDEF(V1
,4,RN
), REGDEF(V2
,5,RN
), REGDEF(V3
, 6,RN
), REGDEF(V4
, 7,RN
),
8152 REGDEF(V5
,8,RN
), REGDEF(V6
,9,RN
), REGDEF(V7
,10,RN
), REGDEF(V8
,11,RN
),
8154 /* Well-known aliases. */
8155 REGDEF(wr
, 7,RN
), REGDEF(sb
, 9,RN
), REGDEF(sl
,10,RN
), REGDEF(fp
,11,RN
),
8156 REGDEF(ip
,12,RN
), REGDEF(sp
,13,RN
), REGDEF(lr
,14,RN
), REGDEF(pc
,15,RN
),
8158 REGDEF(WR
, 7,RN
), REGDEF(SB
, 9,RN
), REGDEF(SL
,10,RN
), REGDEF(FP
,11,RN
),
8159 REGDEF(IP
,12,RN
), REGDEF(SP
,13,RN
), REGDEF(LR
,14,RN
), REGDEF(PC
,15,RN
),
8161 /* Coprocessor numbers. */
8162 REGSET(p
, CP
), REGSET(P
, CP
),
8164 /* Coprocessor register numbers. The "cr" variants are for backward
8166 REGSET(c
, CN
), REGSET(C
, CN
),
8167 REGSET(cr
, CN
), REGSET(CR
, CN
),
8169 /* FPA registers. */
8170 REGNUM(f
,0,FN
), REGNUM(f
,1,FN
), REGNUM(f
,2,FN
), REGNUM(f
,3,FN
),
8171 REGNUM(f
,4,FN
), REGNUM(f
,5,FN
), REGNUM(f
,6,FN
), REGNUM(f
,7, FN
),
8173 REGNUM(F
,0,FN
), REGNUM(F
,1,FN
), REGNUM(F
,2,FN
), REGNUM(F
,3,FN
),
8174 REGNUM(F
,4,FN
), REGNUM(F
,5,FN
), REGNUM(F
,6,FN
), REGNUM(F
,7, FN
),
8176 /* VFP SP registers. */
8178 REGNUM(s
,16,VFS
), REGNUM(s
,17,VFS
), REGNUM(s
,18,VFS
), REGNUM(s
,19,VFS
),
8179 REGNUM(s
,20,VFS
), REGNUM(s
,21,VFS
), REGNUM(s
,22,VFS
), REGNUM(s
,23,VFS
),
8180 REGNUM(s
,24,VFS
), REGNUM(s
,25,VFS
), REGNUM(s
,26,VFS
), REGNUM(s
,27,VFS
),
8181 REGNUM(s
,28,VFS
), REGNUM(s
,29,VFS
), REGNUM(s
,30,VFS
), REGNUM(s
,31,VFS
),
8184 REGNUM(S
,16,VFS
), REGNUM(S
,17,VFS
), REGNUM(S
,18,VFS
), REGNUM(S
,19,VFS
),
8185 REGNUM(S
,20,VFS
), REGNUM(S
,21,VFS
), REGNUM(S
,22,VFS
), REGNUM(S
,23,VFS
),
8186 REGNUM(S
,24,VFS
), REGNUM(S
,25,VFS
), REGNUM(S
,26,VFS
), REGNUM(S
,27,VFS
),
8187 REGNUM(S
,28,VFS
), REGNUM(S
,29,VFS
), REGNUM(S
,30,VFS
), REGNUM(S
,31,VFS
),
8189 /* VFP DP Registers. */
8190 REGSET(d
,VFD
), REGSET(D
,VFS
),
8192 /* VFP control registers. */
8193 REGDEF(fpsid
,0,VFC
), REGDEF(fpscr
,1,VFC
), REGDEF(fpexc
,8,VFC
),
8194 REGDEF(FPSID
,0,VFC
), REGDEF(FPSCR
,1,VFC
), REGDEF(FPEXC
,8,VFC
),
8196 /* Maverick DSP coprocessor registers. */
8197 REGSET(mvf
,MVF
), REGSET(mvd
,MVD
), REGSET(mvfx
,MVFX
), REGSET(mvdx
,MVDX
),
8198 REGSET(MVF
,MVF
), REGSET(MVD
,MVD
), REGSET(MVFX
,MVFX
), REGSET(MVDX
,MVDX
),
8200 REGNUM(mvax
,0,MVAX
), REGNUM(mvax
,1,MVAX
),
8201 REGNUM(mvax
,2,MVAX
), REGNUM(mvax
,3,MVAX
),
8202 REGDEF(dspsc
,0,DSPSC
),
8204 REGNUM(MVAX
,0,MVAX
), REGNUM(MVAX
,1,MVAX
),
8205 REGNUM(MVAX
,2,MVAX
), REGNUM(MVAX
,3,MVAX
),
8206 REGDEF(DSPSC
,0,DSPSC
),
8208 /* iWMMXt data registers - p0, c0-15. */
8209 REGSET(wr
,MMXWR
), REGSET(wR
,MMXWR
), REGSET(WR
, MMXWR
),
8211 /* iWMMXt control registers - p1, c0-3. */
8212 REGDEF(wcid
, 0,MMXWC
), REGDEF(wCID
, 0,MMXWC
), REGDEF(WCID
, 0,MMXWC
),
8213 REGDEF(wcon
, 1,MMXWC
), REGDEF(wCon
, 1,MMXWC
), REGDEF(WCON
, 1,MMXWC
),
8214 REGDEF(wcssf
, 2,MMXWC
), REGDEF(wCSSF
, 2,MMXWC
), REGDEF(WCSSF
, 2,MMXWC
),
8215 REGDEF(wcasf
, 3,MMXWC
), REGDEF(wCASF
, 3,MMXWC
), REGDEF(WCASF
, 3,MMXWC
),
8217 /* iWMMXt scalar (constant/offset) registers - p1, c8-11. */
8218 REGDEF(wcgr0
, 8,MMXWCG
), REGDEF(wCGR0
, 8,MMXWCG
), REGDEF(WCGR0
, 8,MMXWCG
),
8219 REGDEF(wcgr1
, 9,MMXWCG
), REGDEF(wCGR1
, 9,MMXWCG
), REGDEF(WCGR1
, 9,MMXWCG
),
8220 REGDEF(wcgr2
,10,MMXWCG
), REGDEF(wCGR2
,10,MMXWCG
), REGDEF(WCGR2
,10,MMXWCG
),
8221 REGDEF(wcgr3
,11,MMXWCG
), REGDEF(wCGR3
,11,MMXWCG
), REGDEF(WCGR3
,11,MMXWCG
),
8223 /* XScale accumulator registers. */
8224 REGNUM(acc
,0,XSCALE
), REGNUM(ACC
,0,XSCALE
),
8230 /* Table of all PSR suffixes. Bare "CPSR" and "SPSR" are handled
8231 within psr_required_here. */
8232 static const struct asm_psr psrs
[] =
8234 /* Backward compatibility notation. Note that "all" is no longer
8235 truly all possible PSR bits. */
8236 {"all", PSR_c
| PSR_f
},
8240 /* Individual flags. */
8245 /* Combinations of flags. */
8246 {"fs", PSR_f
| PSR_s
},
8247 {"fx", PSR_f
| PSR_x
},
8248 {"fc", PSR_f
| PSR_c
},
8249 {"sf", PSR_s
| PSR_f
},
8250 {"sx", PSR_s
| PSR_x
},
8251 {"sc", PSR_s
| PSR_c
},
8252 {"xf", PSR_x
| PSR_f
},
8253 {"xs", PSR_x
| PSR_s
},
8254 {"xc", PSR_x
| PSR_c
},
8255 {"cf", PSR_c
| PSR_f
},
8256 {"cs", PSR_c
| PSR_s
},
8257 {"cx", PSR_c
| PSR_x
},
8258 {"fsx", PSR_f
| PSR_s
| PSR_x
},
8259 {"fsc", PSR_f
| PSR_s
| PSR_c
},
8260 {"fxs", PSR_f
| PSR_x
| PSR_s
},
8261 {"fxc", PSR_f
| PSR_x
| PSR_c
},
8262 {"fcs", PSR_f
| PSR_c
| PSR_s
},
8263 {"fcx", PSR_f
| PSR_c
| PSR_x
},
8264 {"sfx", PSR_s
| PSR_f
| PSR_x
},
8265 {"sfc", PSR_s
| PSR_f
| PSR_c
},
8266 {"sxf", PSR_s
| PSR_x
| PSR_f
},
8267 {"sxc", PSR_s
| PSR_x
| PSR_c
},
8268 {"scf", PSR_s
| PSR_c
| PSR_f
},
8269 {"scx", PSR_s
| PSR_c
| PSR_x
},
8270 {"xfs", PSR_x
| PSR_f
| PSR_s
},
8271 {"xfc", PSR_x
| PSR_f
| PSR_c
},
8272 {"xsf", PSR_x
| PSR_s
| PSR_f
},
8273 {"xsc", PSR_x
| PSR_s
| PSR_c
},
8274 {"xcf", PSR_x
| PSR_c
| PSR_f
},
8275 {"xcs", PSR_x
| PSR_c
| PSR_s
},
8276 {"cfs", PSR_c
| PSR_f
| PSR_s
},
8277 {"cfx", PSR_c
| PSR_f
| PSR_x
},
8278 {"csf", PSR_c
| PSR_s
| PSR_f
},
8279 {"csx", PSR_c
| PSR_s
| PSR_x
},
8280 {"cxf", PSR_c
| PSR_x
| PSR_f
},
8281 {"cxs", PSR_c
| PSR_x
| PSR_s
},
8282 {"fsxc", PSR_f
| PSR_s
| PSR_x
| PSR_c
},
8283 {"fscx", PSR_f
| PSR_s
| PSR_c
| PSR_x
},
8284 {"fxsc", PSR_f
| PSR_x
| PSR_s
| PSR_c
},
8285 {"fxcs", PSR_f
| PSR_x
| PSR_c
| PSR_s
},
8286 {"fcsx", PSR_f
| PSR_c
| PSR_s
| PSR_x
},
8287 {"fcxs", PSR_f
| PSR_c
| PSR_x
| PSR_s
},
8288 {"sfxc", PSR_s
| PSR_f
| PSR_x
| PSR_c
},
8289 {"sfcx", PSR_s
| PSR_f
| PSR_c
| PSR_x
},
8290 {"sxfc", PSR_s
| PSR_x
| PSR_f
| PSR_c
},
8291 {"sxcf", PSR_s
| PSR_x
| PSR_c
| PSR_f
},
8292 {"scfx", PSR_s
| PSR_c
| PSR_f
| PSR_x
},
8293 {"scxf", PSR_s
| PSR_c
| PSR_x
| PSR_f
},
8294 {"xfsc", PSR_x
| PSR_f
| PSR_s
| PSR_c
},
8295 {"xfcs", PSR_x
| PSR_f
| PSR_c
| PSR_s
},
8296 {"xsfc", PSR_x
| PSR_s
| PSR_f
| PSR_c
},
8297 {"xscf", PSR_x
| PSR_s
| PSR_c
| PSR_f
},
8298 {"xcfs", PSR_x
| PSR_c
| PSR_f
| PSR_s
},
8299 {"xcsf", PSR_x
| PSR_c
| PSR_s
| PSR_f
},
8300 {"cfsx", PSR_c
| PSR_f
| PSR_s
| PSR_x
},
8301 {"cfxs", PSR_c
| PSR_f
| PSR_x
| PSR_s
},
8302 {"csfx", PSR_c
| PSR_s
| PSR_f
| PSR_x
},
8303 {"csxf", PSR_c
| PSR_s
| PSR_x
| PSR_f
},
8304 {"cxfs", PSR_c
| PSR_x
| PSR_f
| PSR_s
},
8305 {"cxsf", PSR_c
| PSR_x
| PSR_s
| PSR_f
},
8308 /* Table of all shift-in-operand names. */
8309 static const struct asm_shift_name shift_names
[] =
8311 { "asl", SHIFT_LSL
}, { "ASL", SHIFT_LSL
},
8312 { "lsl", SHIFT_LSL
}, { "LSL", SHIFT_LSL
},
8313 { "lsr", SHIFT_LSR
}, { "LSR", SHIFT_LSR
},
8314 { "asr", SHIFT_ASR
}, { "ASR", SHIFT_ASR
},
8315 { "ror", SHIFT_ROR
}, { "ROR", SHIFT_ROR
},
8316 { "rrx", SHIFT_RRX
}, { "RRX", SHIFT_RRX
}
8319 /* Table of all explicit relocation names. */
8321 static struct reloc_entry reloc_names
[] =
8323 { "got", BFD_RELOC_ARM_GOT32
}, { "GOT", BFD_RELOC_ARM_GOT32
},
8324 { "gotoff", BFD_RELOC_ARM_GOTOFF
}, { "GOTOFF", BFD_RELOC_ARM_GOTOFF
},
8325 { "plt", BFD_RELOC_ARM_PLT32
}, { "PLT", BFD_RELOC_ARM_PLT32
},
8326 { "target1", BFD_RELOC_ARM_TARGET1
}, { "TARGET1", BFD_RELOC_ARM_TARGET1
},
8327 { "target2", BFD_RELOC_ARM_TARGET2
}, { "TARGET2", BFD_RELOC_ARM_TARGET2
},
8328 { "sbrel", BFD_RELOC_ARM_SBREL32
}, { "SBREL", BFD_RELOC_ARM_SBREL32
},
8329 { "tlsgd", BFD_RELOC_ARM_TLS_GD32
}, { "TLSGD", BFD_RELOC_ARM_TLS_GD32
},
8330 { "tlsldm", BFD_RELOC_ARM_TLS_LDM32
}, { "TLSLDM", BFD_RELOC_ARM_TLS_LDM32
},
8331 { "tlsldo", BFD_RELOC_ARM_TLS_LDO32
}, { "TLSLDO", BFD_RELOC_ARM_TLS_LDO32
},
8332 { "gottpoff",BFD_RELOC_ARM_TLS_IE32
}, { "GOTTPOFF",BFD_RELOC_ARM_TLS_IE32
},
8333 { "tpoff", BFD_RELOC_ARM_TLS_LE32
}, { "TPOFF", BFD_RELOC_ARM_TLS_LE32
}
8337 /* Table of all conditional affixes. 0xF is not defined as a condition code. */
8338 static const struct asm_cond conds
[] =
8342 {"cs", 0x2}, {"hs", 0x2},
8343 {"cc", 0x3}, {"ul", 0x3}, {"lo", 0x3},
8357 /* Table of ARM-format instructions. */
8359 /* Macros for gluing together operand strings. N.B. In all cases
8360 other than OPS0, the trailing OP_stop comes from default
8361 zero-initialization of the unspecified elements of the array. */
8362 #define OPS0() { OP_stop, }
8363 #define OPS1(a) { OP_##a, }
8364 #define OPS2(a,b) { OP_##a,OP_##b, }
8365 #define OPS3(a,b,c) { OP_##a,OP_##b,OP_##c, }
8366 #define OPS4(a,b,c,d) { OP_##a,OP_##b,OP_##c,OP_##d, }
8367 #define OPS5(a,b,c,d,e) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e, }
8368 #define OPS6(a,b,c,d,e,f) { OP_##a,OP_##b,OP_##c,OP_##d,OP_##e,OP_##f, }
8370 /* These macros abstract out the exact format of the mnemonic table and
8371 save some repeated characters. */
8373 /* The normal sort of mnemonic; has a Thumb variant; takes a conditional suffix. */
8374 #define TxCE(mnem, op, top, nops, ops, ae, te) \
8375 { #mnem, OPS##nops ops, OT_csuffix, 0x##op, top, ARM_VARIANT, \
8376 THUMB_VARIANT, do_##ae, do_##te }
8378 /* Two variants of the above - TCE for a numeric Thumb opcode, tCE for
8379 a T_MNEM_xyz enumerator. */
8380 #define TCE(mnem, aop, top, nops, ops, ae, te) \
8381 TxCE(mnem, aop, 0x##top, nops, ops, ae, te)
8382 #define tCE(mnem, aop, top, nops, ops, ae, te) \
8383 TxCE(mnem, aop, T_MNEM_##top, nops, ops, ae, te)
8385 /* Second most common sort of mnemonic: has a Thumb variant, takes a conditional
8386 infix after the third character. */
8387 #define TxC3(mnem, op, top, nops, ops, ae, te) \
8388 { #mnem, OPS##nops ops, OT_cinfix3, 0x##op, top, ARM_VARIANT, \
8389 THUMB_VARIANT, do_##ae, do_##te }
8390 #define TC3(mnem, aop, top, nops, ops, ae, te) \
8391 TxC3(mnem, aop, 0x##top, nops, ops, ae, te)
8392 #define tC3(mnem, aop, top, nops, ops, ae, te) \
8393 TxC3(mnem, aop, T_MNEM_##top, nops, ops, ae, te)
8395 /* Mnemonic with a conditional infix in an unusual place. Each and every variant has to
8396 appear in the condition table. */
8397 #define TxCM_(m1, m2, m3, op, top, nops, ops, ae, te) \
8398 { #m1 #m2 #m3, OPS##nops ops, sizeof(#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof(#m1) - 1, \
8399 0x##op, top, ARM_VARIANT, THUMB_VARIANT, do_##ae, do_##te }
8401 #define TxCM(m1, m2, op, top, nops, ops, ae, te) \
8402 TxCM_(m1, , m2, op, top, nops, ops, ae, te), \
8403 TxCM_(m1, eq, m2, op, top, nops, ops, ae, te), \
8404 TxCM_(m1, ne, m2, op, top, nops, ops, ae, te), \
8405 TxCM_(m1, cs, m2, op, top, nops, ops, ae, te), \
8406 TxCM_(m1, hs, m2, op, top, nops, ops, ae, te), \
8407 TxCM_(m1, cc, m2, op, top, nops, ops, ae, te), \
8408 TxCM_(m1, ul, m2, op, top, nops, ops, ae, te), \
8409 TxCM_(m1, lo, m2, op, top, nops, ops, ae, te), \
8410 TxCM_(m1, mi, m2, op, top, nops, ops, ae, te), \
8411 TxCM_(m1, pl, m2, op, top, nops, ops, ae, te), \
8412 TxCM_(m1, vs, m2, op, top, nops, ops, ae, te), \
8413 TxCM_(m1, vc, m2, op, top, nops, ops, ae, te), \
8414 TxCM_(m1, hi, m2, op, top, nops, ops, ae, te), \
8415 TxCM_(m1, ls, m2, op, top, nops, ops, ae, te), \
8416 TxCM_(m1, ge, m2, op, top, nops, ops, ae, te), \
8417 TxCM_(m1, lt, m2, op, top, nops, ops, ae, te), \
8418 TxCM_(m1, gt, m2, op, top, nops, ops, ae, te), \
8419 TxCM_(m1, le, m2, op, top, nops, ops, ae, te), \
8420 TxCM_(m1, al, m2, op, top, nops, ops, ae, te)
8422 #define TCM(m1,m2, aop, top, nops, ops, ae, te) \
8423 TxCM(m1,m2, aop, 0x##top, nops, ops, ae, te)
8424 #define tCM(m1,m2, aop, top, nops, ops, ae, te) \
8425 TxCM(m1,m2, aop, T_MNEM_##top, nops, ops, ae, te)
8427 /* Mnemonic that cannot be conditionalized. The ARM condition-code
8428 field is still 0xE. */
8429 #define TUE(mnem, op, top, nops, ops, ae, te) \
8430 { #mnem, OPS##nops ops, OT_unconditional, 0x##op, 0x##top, ARM_VARIANT, \
8431 THUMB_VARIANT, do_##ae, do_##te }
8433 /* Mnemonic that cannot be conditionalized, and bears 0xF in its ARM
8434 condition code field. */
8435 #define TUF(mnem, op, top, nops, ops, ae, te) \
8436 { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0x##top, ARM_VARIANT, \
8437 THUMB_VARIANT, do_##ae, do_##te }
8439 /* ARM-only variants of all the above. */
8440 #define CE(mnem, op, nops, ops, ae) \
8441 { #mnem, OPS##nops ops, OT_csuffix, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
8443 #define C3(mnem, op, nops, ops, ae) \
8444 { #mnem, OPS##nops ops, OT_cinfix3, 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
8446 /* Coprocessor instructions. Isomorphic between Arm and Thumb-2. */
8447 #define cCE(mnem, op, nops, ops, ae) \
8448 { #mnem, OPS##nops ops, OT_csuffix, 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
8450 #define cC3(mnem, op, nops, ops, ae) \
8451 { #mnem, OPS##nops ops, OT_cinfix3, 0x##op, 0xe##op, ARM_VARIANT, ARM_VARIANT, do_##ae, do_##ae }
8453 #define xCM_(m1, m2, m3, op, nops, ops, ae) \
8454 { #m1 #m2 #m3, OPS##nops ops, \
8455 sizeof(#m2) == 1 ? OT_odd_infix_unc : OT_odd_infix_0 + sizeof(#m1) - 1, \
8456 0x##op, 0x0, ARM_VARIANT, 0, do_##ae, NULL }
8458 #define CM(m1, m2, op, nops, ops, ae) \
8459 xCM_(m1, , m2, op, nops, ops, ae), \
8460 xCM_(m1, eq, m2, op, nops, ops, ae), \
8461 xCM_(m1, ne, m2, op, nops, ops, ae), \
8462 xCM_(m1, cs, m2, op, nops, ops, ae), \
8463 xCM_(m1, hs, m2, op, nops, ops, ae), \
8464 xCM_(m1, cc, m2, op, nops, ops, ae), \
8465 xCM_(m1, ul, m2, op, nops, ops, ae), \
8466 xCM_(m1, lo, m2, op, nops, ops, ae), \
8467 xCM_(m1, mi, m2, op, nops, ops, ae), \
8468 xCM_(m1, pl, m2, op, nops, ops, ae), \
8469 xCM_(m1, vs, m2, op, nops, ops, ae), \
8470 xCM_(m1, vc, m2, op, nops, ops, ae), \
8471 xCM_(m1, hi, m2, op, nops, ops, ae), \
8472 xCM_(m1, ls, m2, op, nops, ops, ae), \
8473 xCM_(m1, ge, m2, op, nops, ops, ae), \
8474 xCM_(m1, lt, m2, op, nops, ops, ae), \
8475 xCM_(m1, gt, m2, op, nops, ops, ae), \
8476 xCM_(m1, le, m2, op, nops, ops, ae), \
8477 xCM_(m1, al, m2, op, nops, ops, ae)
8479 #define UE(mnem, op, nops, ops, ae) \
8480 { #mnem, OPS##nops ops, OT_unconditional, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
8482 #define UF(mnem, op, nops, ops, ae) \
8483 { #mnem, OPS##nops ops, OT_unconditionalF, 0x##op, 0, ARM_VARIANT, 0, do_##ae, NULL }
8487 /* Thumb-only, unconditional. */
8488 #define UT(mnem, op, nops, ops, te) TUE(mnem, 0, op, nops, ops, 0, te)
8490 /* ARM-only, takes either a suffix or a position-3 infix
8491 (for an FPA corner case). */
8492 #define C3E(mnem, op, nops, ops, ae) \
8493 { #mnem, OPS##nops ops, OT_csuf_or_in3, 0x##op, 0, ARM_VARIANT, 0, do_##ae, 0 }
8495 static const struct asm_opcode insns
[] =
8497 #define ARM_VARIANT ARM_EXT_V1 /* Core ARM Instructions. */
8498 #define THUMB_VARIANT ARM_EXT_V4T
8499 tCE(and, 0000000, and, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
8500 tC3(ands
, 0100000, ands
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
8501 tCE(eor
, 0200000, eor
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
8502 tC3(eors
, 0300000, eors
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
8503 tCE(sub
, 0400000, sub
, 3, (RR
, oRR
, SH
), arit
, t_add_sub
),
8504 tC3(subs
, 0500000, subs
, 3, (RR
, oRR
, SH
), arit
, t_add_sub
),
8505 tCE(add
, 0800000, add
, 3, (RR
, oRR
, SH
), arit
, t_add_sub
),
8506 tC3(adds
, 0900000, adds
, 3, (RR
, oRR
, SH
), arit
, t_add_sub
),
8507 tCE(adc
, 0a00000
, adc
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
8508 tC3(adcs
, 0b00000, adcs
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
8509 tCE(sbc
, 0c00000
, sbc
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
8510 tC3(sbcs
, 0d00000
, sbcs
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
8511 tCE(orr
, 1800000, orr
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
8512 tC3(orrs
, 1900000, orrs
, 3, (RR
, oRR
, SH
), arit
, t_arit3c
),
8513 tCE(bic
, 1c00000
, bic
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
8514 tC3(bics
, 1d00000
, bics
, 3, (RR
, oRR
, SH
), arit
, t_arit3
),
8516 /* The p-variants of tst/cmp/cmn/teq (below) are the pre-V6 mechanism
8517 for setting PSR flag bits. They are obsolete in V6 and do not
8518 have Thumb equivalents. */
8519 tCE(tst
, 1100000, tst
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
8520 tC3(tsts
, 1100000, tst
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
8521 C3(tstp
, 110f000
, 2, (RR
, SH
), cmp
),
8522 tCE(cmp
, 1500000, cmp
, 2, (RR
, SH
), cmp
, t_mov_cmp
),
8523 tC3(cmps
, 1500000, cmp
, 2, (RR
, SH
), cmp
, t_mov_cmp
),
8524 C3(cmpp
, 150f000
, 2, (RR
, SH
), cmp
),
8525 tCE(cmn
, 1700000, cmn
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
8526 tC3(cmns
, 1700000, cmn
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
8527 C3(cmnp
, 170f000
, 2, (RR
, SH
), cmp
),
8529 tCE(mov
, 1a00000
, mov
, 2, (RR
, SH
), mov
, t_mov_cmp
),
8530 tC3(movs
, 1b00000
, movs
, 2, (RR
, SH
), mov
, t_mov_cmp
),
8531 tCE(mvn
, 1e00000
, mvn
, 2, (RR
, SH
), mov
, t_mvn_tst
),
8532 tC3(mvns
, 1f00000
, mvns
, 2, (RR
, SH
), mov
, t_mvn_tst
),
8534 tCE(ldr
, 4100000, ldr
, 2, (RR
, ADDR
), ldst
, t_ldst
),
8535 tC3(ldrb
, 4500000, ldrb
, 2, (RR
, ADDR
), ldst
, t_ldst
),
8536 tCE(str
, 4000000, str
, 2, (RR
, ADDR
), ldst
, t_ldst
),
8537 tC3(strb
, 4400000, strb
, 2, (RR
, ADDR
), ldst
, t_ldst
),
8539 tC3(stmia
, 8800000, stmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
8540 tC3(stmea
, 8800000, stmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
8541 tC3(ldmia
, 8900000, ldmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
8542 tC3(ldmfd
, 8900000, ldmia
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
8544 TCE(swi
, f000000
, df00
, 1, (EXPi
), swi
, t_swi
),
8545 tCE(b
, a000000
, b
, 1, (EXPr
), branch
, t_branch
),
8546 TCE(bl
, b000000
, f000f800
, 1, (EXPr
), branch
, t_branch23
),
8549 tCE(adr
, 28f0000
, adr
, 2, (RR
, EXP
), adr
, t_adr
),
8550 C3(adrl
, 28f0000
, 2, (RR
, EXP
), adrl
),
8551 tCE(nop
, 1a00000
, nop
, 1, (oI255c
), nop
, t_nop
),
8553 /* Thumb-compatibility pseudo ops. */
8554 tCE(lsl
, 1a00000
, lsl
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
8555 tC3(lsls
, 1b00000
, lsls
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
8556 tCE(lsr
, 1a00020
, lsr
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
8557 tC3(lsrs
, 1b00020
, lsrs
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
8558 tCE(asr
, 1a00040
, asr
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
8559 tC3(asrs
, 1b00040
, asrs
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
8560 tCE(ror
, 1a00060
, ror
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
8561 tC3(rors
, 1b00060
, rors
, 3, (RR
, oRR
, SH
), shift
, t_shift
),
8562 tCE(neg
, 2600000, neg
, 2, (RR
, RR
), rd_rn
, t_neg
),
8563 tC3(negs
, 2700000, negs
, 2, (RR
, RR
), rd_rn
, t_neg
),
8564 tCE(push
, 92d0000
, push
, 1, (REGLST
), push_pop
, t_push_pop
),
8565 tCE(pop
, 8bd0000
, pop
, 1, (REGLST
), push_pop
, t_push_pop
),
8567 #undef THUMB_VARIANT
8568 #define THUMB_VARIANT ARM_EXT_V6
8569 TCE(cpy
, 1a00000
, 4600, 2, (RR
, RR
), rd_rm
, t_cpy
),
8571 /* V1 instructions with no Thumb analogue prior to V6T2. */
8572 #undef THUMB_VARIANT
8573 #define THUMB_VARIANT ARM_EXT_V6T2
8574 TCE(rsb
, 0600000, ebc00000
, 3, (RR
, oRR
, SH
), arit
, t_rsb
),
8575 TC3(rsbs
, 0700000, ebd00000
, 3, (RR
, oRR
, SH
), arit
, t_rsb
),
8576 TCE(teq
, 1300000, ea900f00
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
8577 TC3(teqs
, 1300000, ea900f00
, 2, (RR
, SH
), cmp
, t_mvn_tst
),
8578 C3(teqp
, 130f000
, 2, (RR
, SH
), cmp
),
8580 TC3(ldrt
, 4300000, f8500e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
8581 TC3(ldrbt
, 4700000, f8300e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
8582 TC3(strt
, 4200000, f8400e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
8583 TC3(strbt
, 4600000, f8200e00
, 2, (RR
, ADDR
), ldstt
, t_ldstt
),
8585 TC3(stmdb
, 9000000, e9000000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
8586 TC3(stmfd
, 9000000, e9000000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
8588 TC3(ldmdb
, 9100000, e9100000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
8589 TC3(ldmea
, 9100000, e9100000
, 2, (RRw
, REGLST
), ldmstm
, t_ldmstm
),
8591 /* V1 instructions with no Thumb analogue at all. */
8592 CE(rsc
, 0e00000
, 3, (RR
, oRR
, SH
), arit
),
8593 C3(rscs
, 0f00000
, 3, (RR
, oRR
, SH
), arit
),
8595 C3(stmib
, 9800000, 2, (RRw
, REGLST
), ldmstm
),
8596 C3(stmfa
, 9800000, 2, (RRw
, REGLST
), ldmstm
),
8597 C3(stmda
, 8000000, 2, (RRw
, REGLST
), ldmstm
),
8598 C3(stmed
, 8000000, 2, (RRw
, REGLST
), ldmstm
),
8599 C3(ldmib
, 9900000, 2, (RRw
, REGLST
), ldmstm
),
8600 C3(ldmed
, 9900000, 2, (RRw
, REGLST
), ldmstm
),
8601 C3(ldmda
, 8100000, 2, (RRw
, REGLST
), ldmstm
),
8602 C3(ldmfa
, 8100000, 2, (RRw
, REGLST
), ldmstm
),
8605 #define ARM_VARIANT ARM_EXT_V2 /* ARM 2 - multiplies. */
8606 #undef THUMB_VARIANT
8607 #define THUMB_VARIANT ARM_EXT_V4T
8608 tCE(mul
, 0000090, mul
, 3, (RRnpc
, RRnpc
, oRR
), mul
, t_mul
),
8609 tC3(muls
, 0100090, muls
, 3, (RRnpc
, RRnpc
, oRR
), mul
, t_mul
),
8611 #undef THUMB_VARIANT
8612 #define THUMB_VARIANT ARM_EXT_V6T2
8613 TCE(mla
, 0200090, fb000000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mlas
, t_mla
),
8614 C3(mlas
, 0300090, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mlas
),
8616 /* Generic coprocessor instructions. */
8617 TCE(cdp
, e000000
, ee000000
, 6, (RCP
, I15b
, RCN
, RCN
, RCN
, oI7b
), cdp
, cdp
),
8618 TCE(ldc
, c100000
, ec100000
, 3, (RCP
, RCN
, ADDR
), lstc
, lstc
),
8619 TC3(ldcl
, c500000
, ec500000
, 3, (RCP
, RCN
, ADDR
), lstc
, lstc
),
8620 TCE(stc
, c000000
, ec000000
, 3, (RCP
, RCN
, ADDR
), lstc
, lstc
),
8621 TC3(stcl
, c400000
, ec400000
, 3, (RCP
, RCN
, ADDR
), lstc
, lstc
),
8622 TCE(mcr
, e000010
, ee000010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
8623 TCE(mrc
, e100010
, ee100010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
8626 #define ARM_VARIANT ARM_EXT_V2S /* ARM 3 - swp instructions. */
8627 CE(swp
, 1000090, 3, (RRnpc
, RRnpc
, RRnpcb
), rd_rm_rn
),
8628 C3(swpb
, 1400090, 3, (RRnpc
, RRnpc
, RRnpcb
), rd_rm_rn
),
8631 #define ARM_VARIANT ARM_EXT_V3 /* ARM 6 Status register instructions. */
8632 TCE(mrs
, 10f0000
, f3ef8000
, 2, (RR
, PSR
), mrs
, t_mrs
),
8633 TCE(msr
, 120f000
, f3808000
, 2, (PSR
, RR_EXi
), msr
, t_msr
),
8636 #define ARM_VARIANT ARM_EXT_V3M /* ARM 7M long multiplies. */
8637 TCE(smull
, 0c00090
, fb800000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
8638 CM(smull
,s
, 0d00090
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
8639 TCE(umull
, 0800090, fba00000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
8640 CM(umull
,s
, 0900090, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
8641 TCE(smlal
, 0e00090
, fbc00000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
8642 CM(smlal
,s
, 0f00090
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
8643 TCE(umlal
, 0a00090
, fbe00000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
, t_mull
),
8644 CM(umlal
,s
, 0b00090, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mull
),
8647 #define ARM_VARIANT ARM_EXT_V4 /* ARM Architecture 4. */
8648 #undef THUMB_VARIANT
8649 #define THUMB_VARIANT ARM_EXT_V4T
8650 tC3(ldrh
, 01000b0
, ldrh
, 2, (RR
, ADDR
), ldstv4
, t_ldst
),
8651 tC3(strh
, 00000b0
, strh
, 2, (RR
, ADDR
), ldstv4
, t_ldst
),
8652 tC3(ldrsh
, 01000f0
, ldrsh
, 2, (RR
, ADDR
), ldstv4
, t_ldst
),
8653 tC3(ldrsb
, 01000d0
, ldrsb
, 2, (RR
, ADDR
), ldstv4
, t_ldst
),
8654 tCM(ld
,sh
, 01000f0
, ldrsh
, 2, (RR
, ADDR
), ldstv4
, t_ldst
),
8655 tCM(ld
,sb
, 01000d0
, ldrsb
, 2, (RR
, ADDR
), ldstv4
, t_ldst
),
8658 #define ARM_VARIANT ARM_EXT_V4T|ARM_EXT_V5
8659 /* ARM Architecture 4T. */
8660 /* Note: bx (and blx) are required on V5, even if the processor does
8661 not support Thumb. */
8662 TCE(bx
, 12fff10
, 4700, 1, (RR
), bx
, t_bx
),
8665 #define ARM_VARIANT ARM_EXT_V5 /* ARM Architecture 5T. */
8666 #undef THUMB_VARIANT
8667 #define THUMB_VARIANT ARM_EXT_V5T
8668 /* Note: blx has 2 variants; the .value coded here is for
8669 BLX(2). Only this variant has conditional execution. */
8670 TCE(blx
, 12fff30
, 4780, 1, (RR_EXr
), blx
, t_blx
),
8671 TUE(bkpt
, 1200070, be00
, 1, (oIffffb
), bkpt
, t_bkpt
),
8673 #undef THUMB_VARIANT
8674 #define THUMB_VARIANT ARM_EXT_V6T2
8675 TCE(clz
, 16f0f10
, fab0f080
, 2, (RRnpc
, RRnpc
), rd_rm
, t_clz
),
8676 TUF(ldc2
, c100000
, fc100000
, 3, (RCP
, RCN
, ADDR
), lstc
, lstc
),
8677 TUF(ldc2l
, c500000
, fc500000
, 3, (RCP
, RCN
, ADDR
), lstc
, lstc
),
8678 TUF(stc2
, c000000
, fc000000
, 3, (RCP
, RCN
, ADDR
), lstc
, lstc
),
8679 TUF(stc2l
, c400000
, fc400000
, 3, (RCP
, RCN
, ADDR
), lstc
, lstc
),
8680 TUF(cdp2
, e000000
, fe000000
, 6, (RCP
, I15b
, RCN
, RCN
, RCN
, oI7b
), cdp
, cdp
),
8681 TUF(mcr2
, e000010
, fe000010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
8682 TUF(mrc2
, e100010
, fe100010
, 6, (RCP
, I7b
, RR
, RCN
, RCN
, oI7b
), co_reg
, co_reg
),
8685 #define ARM_VARIANT ARM_EXT_V5ExP /* ARM Architecture 5TExP. */
8686 TCE(smlabb
, 1000080, fb100000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
8687 TCE(smlatb
, 10000a0
, fb100020
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
8688 TCE(smlabt
, 10000c0
, fb100010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
8689 TCE(smlatt
, 10000e0
, fb100030
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
8691 TCE(smlawb
, 1200080, fb300000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
8692 TCE(smlawt
, 12000c0
, fb300010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smla
, t_mla
),
8694 TCE(smlalbb
, 1400080, fbc00080
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
8695 TCE(smlaltb
, 14000a0
, fbc000a0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
8696 TCE(smlalbt
, 14000c0
, fbc00090
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
8697 TCE(smlaltt
, 14000e0
, fbc000b0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), smlal
, t_mlal
),
8699 TCE(smulbb
, 1600080, fb10f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8700 TCE(smultb
, 16000a0
, fb10f020
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8701 TCE(smulbt
, 16000c0
, fb10f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8702 TCE(smultt
, 16000e0
, fb10f030
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8704 TCE(smulwb
, 12000a0
, fb30f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8705 TCE(smulwt
, 12000e0
, fb30f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8707 TCE(qadd
, 1000050, fa80f080
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, rd_rm_rn
),
8708 TCE(qdadd
, 1400050, fa80f090
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, rd_rm_rn
),
8709 TCE(qsub
, 1200050, fa80f0a0
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, rd_rm_rn
),
8710 TCE(qdsub
, 1600050, fa80f0b0
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rm_rn
, rd_rm_rn
),
8713 #define ARM_VARIANT ARM_EXT_V5E /* ARM Architecture 5TE. */
8714 TUF(pld
, 450f000
, f810f000
, 1, (ADDR
), pld
, t_pld
),
8715 TC3(ldrd
, 00000d0
, e9500000
, 3, (RRnpc
, oRRnpc
, ADDR
), ldrd
, t_ldstd
),
8716 TC3(strd
, 00000f0
, e9400000
, 3, (RRnpc
, oRRnpc
, ADDR
), ldrd
, t_ldstd
),
8718 TCE(mcrr
, c400000
, ec400000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
8719 TCE(mrrc
, c500000
, ec500000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
8722 #define ARM_VARIANT ARM_EXT_V5J /* ARM Architecture 5TEJ. */
8723 TCE(bxj
, 12fff20
, f3c08f00
, 1, (RR
), bxj
, t_bxj
),
8726 #define ARM_VARIANT ARM_EXT_V6 /* ARM V6. */
8727 #undef THUMB_VARIANT
8728 #define THUMB_VARIANT ARM_EXT_V6
8729 TUF(cpsie
, 1080000, b660
, 2, (CPSF
, oI31b
), cpsi
, t_cpsi
),
8730 TUF(cpsid
, 10c0000
, b670
, 2, (CPSF
, oI31b
), cpsi
, t_cpsi
),
8731 tCE(rev
, 6bf0f30
, rev
, 2, (RRnpc
, RRnpc
), rd_rm
, t_rev
),
8732 tCE(rev16
, 6bf0fb0
, rev16
, 2, (RRnpc
, RRnpc
), rd_rm
, t_rev
),
8733 tCE(revsh
, 6ff0fb0
, revsh
, 2, (RRnpc
, RRnpc
), rd_rm
, t_rev
),
8734 tCE(sxth
, 6bf0070
, sxth
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
8735 tCE(uxth
, 6ff0070
, uxth
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
8736 tCE(sxtb
, 6af0070
, sxtb
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
8737 tCE(uxtb
, 6ef0070
, uxtb
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
8738 TUF(setend
, 1010000, b650
, 1, (ENDI
), setend
, t_setend
),
8740 #undef THUMB_VARIANT
8741 #define THUMB_VARIANT ARM_EXT_V6T2
8742 TUF(cps
, 1020000, f3af8100
, 1, (I31b
), imm0
, imm0
),
8743 TCE(ldrex
, 1900f9f
, e8500f00
, 2, (RRnpc
, ADDR
), ldrex
, t_ldrex
),
8744 TUF(mcrr2
, c400000
, fc400000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
8745 TUF(mrrc2
, c500000
, fc500000
, 5, (RCP
, I15b
, RRnpc
, RRnpc
, RCN
), co_reg2c
, co_reg2c
),
8746 TCE(pkhbt
, 6800010, eac00000
, 4, (RRnpc
, RRnpc
, RRnpc
, oSHll
), pkhbt
, t_pkhbt
),
8747 TCE(pkhtb
, 6800050, eac00020
, 4, (RRnpc
, RRnpc
, RRnpc
, oSHar
), pkhtb
, t_pkhtb
),
8748 TCE(qadd16
, 6200f10
, fa90f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8749 TCE(qadd8
, 6200f90
, fa80f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8750 TCE(qaddsubx
, 6200f30
, faa0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8751 TCE(qsub16
, 6200f70
, fad0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8752 TCE(qsub8
, 6200ff0
, fac0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8753 TCE(qsubaddx
, 6200f50
, fae0f010
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8754 TCE(sadd16
, 6100f10
, fa90f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8755 TCE(sadd8
, 6100f90
, fa80f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8756 TCE(saddsubx
, 6100f30
, faa0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8757 TCE(shadd16
, 6300f10
, fa90f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8758 TCE(shadd8
, 6300f90
, fa80f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8759 TCE(shaddsubx
, 6300f30
, faa0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8760 TCE(shsub16
, 6300f70
, fad0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8761 TCE(shsub8
, 6300ff0
, fac0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8762 TCE(shsubaddx
, 6300f50
, fae0f020
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8763 TCE(ssub16
, 6100f70
, fad0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8764 TCE(ssub8
, 6100ff0
, fac0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8765 TCE(ssubaddx
, 6100f50
, fae0f000
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8766 TCE(uadd16
, 6500f10
, fa90f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8767 TCE(uadd8
, 6500f90
, fa80f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8768 TCE(uaddsubx
, 6500f30
, faa0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8769 TCE(uhadd16
, 6700f10
, fa90f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8770 TCE(uhadd8
, 6700f90
, fa80f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8771 TCE(uhaddsubx
, 6700f30
, faa0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8772 TCE(uhsub16
, 6700f70
, fad0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8773 TCE(uhsub8
, 6700ff0
, fac0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8774 TCE(uhsubaddx
, 6700f50
, fae0f060
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8775 TCE(uqadd16
, 6600f10
, fa90f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8776 TCE(uqadd8
, 6600f90
, fa80f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8777 TCE(uqaddsubx
, 6600f30
, faa0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8778 TCE(uqsub16
, 6600f70
, fad0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8779 TCE(uqsub8
, 6600ff0
, fac0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8780 TCE(uqsubaddx
, 6600f50
, fae0f050
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8781 TCE(usub16
, 6500f70
, fad0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8782 TCE(usub8
, 6500ff0
, fac0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8783 TCE(usubaddx
, 6500f50
, fae0f040
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8784 TUF(rfeia
, 8900a00
, e990c000
, 1, (RRw
), rfe
, rfe
),
8785 UF(rfeib
, 9900a00
, 1, (RRw
), rfe
),
8786 UF(rfeda
, 8100a00
, 1, (RRw
), rfe
),
8787 TUF(rfedb
, 9100a00
, e810c000
, 1, (RRw
), rfe
, rfe
),
8788 TUF(rfefd
, 8900a00
, e990c000
, 1, (RRw
), rfe
, rfe
),
8789 UF(rfefa
, 9900a00
, 1, (RRw
), rfe
),
8790 UF(rfeea
, 8100a00
, 1, (RRw
), rfe
),
8791 TUF(rfeed
, 9100a00
, e810c000
, 1, (RRw
), rfe
, rfe
),
8792 TCE(sxtah
, 6b00070
, fa00f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
8793 TCE(sxtab16
, 6800070, fa20f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
8794 TCE(sxtab
, 6a00070
, fa40f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
8795 TCE(sxtb16
, 68f0070
, fa2ff080
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
8796 TCE(uxtah
, 6f00070
, fa10f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
8797 TCE(uxtab16
, 6c00070
, fa30f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
8798 TCE(uxtab
, 6e00070
, fa50f080
, 4, (RRnpc
, RRnpc
, RRnpc
, oROR
), sxtah
, t_sxtah
),
8799 TCE(uxtb16
, 6cf0070
, fa3ff080
, 3, (RRnpc
, RRnpc
, oROR
), sxth
, t_sxth
),
8800 TCE(sel
, 68000b0
, faa0f080
, 3, (RRnpc
, RRnpc
, RRnpc
), rd_rn_rm
, t_simd
),
8801 TCE(smlad
, 7000010, fb200000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
8802 TCE(smladx
, 7000030, fb200010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
8803 TCE(smlald
, 7400010, fbc000c0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
8804 TCE(smlaldx
, 7400030, fbc000d0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
8805 TCE(smlsd
, 7000050, fb400000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
8806 TCE(smlsdx
, 7000070, fb400010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
8807 TCE(smlsld
, 7400050, fbd000c0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
8808 TCE(smlsldx
, 7400070, fbd000d0
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
,t_mlal
),
8809 TCE(smmla
, 7500010, fb500000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
8810 TCE(smmlar
, 7500030, fb500010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
8811 TCE(smmls
, 75000d0
, fb600000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
8812 TCE(smmlsr
, 75000f0
, fb600010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
8813 TCE(smmul
, 750f010
, fb50f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8814 TCE(smmulr
, 750f030
, fb50f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8815 TCE(smuad
, 700f010
, fb20f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8816 TCE(smuadx
, 700f030
, fb20f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8817 TCE(smusd
, 700f050
, fb40f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8818 TCE(smusdx
, 700f070
, fb40f010
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8819 TUF(srsia
, 8cd0500
, e980c000
, 1, (I31w
), srs
, srs
),
8820 UF(srsib
, 9cd0500
, 1, (I31w
), srs
),
8821 UF(srsda
, 84d0500
, 1, (I31w
), srs
),
8822 TUF(srsdb
, 94d0500
, e800c000
, 1, (I31w
), srs
, srs
),
8823 TCE(ssat
, 6a00010
, f3000000
, 4, (RRnpc
, I32
, RRnpc
, oSHllar
),ssat
, t_ssat
),
8824 TCE(ssat16
, 6a00f30
, f3200000
, 3, (RRnpc
, I16
, RRnpc
), ssat16
, t_ssat16
),
8825 TCE(strex
, 1800f90
, e8400000
, 3, (RRnpc
, RRnpc
, ADDR
), strex
, t_strex
),
8826 TCE(umaal
, 0400090, fbe00060
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smlal
, t_mlal
),
8827 TCE(usad8
, 780f010
, fb70f000
, 3, (RRnpc
, RRnpc
, RRnpc
), smul
, t_simd
),
8828 TCE(usada8
, 7800010, fb700000
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
),smla
, t_mla
),
8829 TCE(usat
, 6e00010
, f3800000
, 4, (RRnpc
, I31
, RRnpc
, oSHllar
),usat
, t_usat
),
8830 TCE(usat16
, 6e00f30
, f3a00000
, 3, (RRnpc
, I15
, RRnpc
), usat16
, t_usat16
),
8833 #define ARM_VARIANT ARM_EXT_V6K
8834 #undef THUMB_VARIANT
8835 #define THUMB_VARIANT ARM_EXT_V6K
8836 tCE(yield
, 320f001
, yield
, 0, (), noargs
, t_hint
),
8837 tCE(wfe
, 320f002
, wfe
, 0, (), noargs
, t_hint
),
8838 tCE(wfi
, 320f003
, wfi
, 0, (), noargs
, t_hint
),
8839 tCE(sev
, 320f004
, sev
, 0, (), noargs
, t_hint
),
8841 #undef THUMB_VARIANT
8842 #define THUMB_VARIANT ARM_EXT_V6T2
8843 TCE(ldrexb
, 1d00f9f
, e8d00f4f
, 2, (RRnpc
, RRnpcb
), rd_rn
, rd_rn
),
8844 TCE(ldrexh
, 1f00f9f
, e8d00f5f
, 2, (RRnpc
, RRnpcb
), rd_rn
, rd_rn
),
8845 TCE(ldrexd
, 1b00f9f
, e8d0007f
, 3, (RRnpc
, oRRnpc
, RRnpcb
), ldrexd
, t_ldrexd
),
8846 TCE(strexb
, 1c00f90
, e8c00f40
, 3, (RRnpc
, RRnpc
, ADDR
), strex
, rm_rd_rn
),
8847 TCE(strexh
, 1e00f90
, e8c00f50
, 3, (RRnpc
, RRnpc
, ADDR
), strex
, rm_rd_rn
),
8848 TCE(strexd
, 1a00f90
, e8c00070
, 4, (RRnpc
, RRnpc
, oRRnpc
, RRnpcb
), strexd
, t_strexd
),
8849 TUF(clrex
, 57ff01f
, f3bf8f2f
, 0, (), noargs
, noargs
),
8852 #define ARM_VARIANT ARM_EXT_V6Z
8853 TCE(smc
, 1600070, f7f08000
, 1, (EXPi
), smc
, t_smc
),
8856 #define ARM_VARIANT ARM_EXT_V6T2
8857 TCE(bfc
, 7c0001f
, f36f0000
, 3, (RRnpc
, I31
, I32
), bfc
, t_bfc
),
8858 TCE(bfi
, 7c00010
, f3600000
, 4, (RRnpc
, RRnpc_I0
, I31
, I32
), bfi
, t_bfi
),
8859 TCE(sbfx
, 7a00050
, f3400000
, 4, (RR
, RR
, I31
, I32
), bfx
, t_bfx
),
8860 TCE(ubfx
, 7e00050
, f3c00000
, 4, (RR
, RR
, I31
, I32
), bfx
, t_bfx
),
8862 TCE(mls
, 0600090, fb000010
, 4, (RRnpc
, RRnpc
, RRnpc
, RRnpc
), mlas
, t_mla
),
8863 TCE(movw
, 3000000, f2400000
, 2, (RRnpc
, Iffff
), mov16
, t_mov16
),
8864 TCE(movt
, 3400000, f2c00000
, 2, (RRnpc
, Iffff
), mov16
, t_mov16
),
8865 TCE(rbit
, 3ff0f30
, fa90f0a0
, 2, (RR
, RR
), rd_rm
, t_rbit
),
8867 TC3(ldrht
, 03000b0
, f8300e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
8868 TC3(ldrsht
, 03000f0
, f9300e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
8869 TC3(ldrsbt
, 03000d0
, f9100e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
8870 TC3(strht
, 02000b0
, f8200e00
, 2, (RR
, ADDR
), ldsttv4
, t_ldstt
),
8872 UT(cbnz
, b900
, 2, (RR
, EXP
), t_czb
),
8873 UT(cbz
, b100
, 2, (RR
, EXP
), t_czb
),
8874 /* ARM does not really have an IT instruction. */
8875 TUE(it
, 0, bf08
, 1, (COND
), it
, t_it
),
8876 TUE(itt
, 0, bf0c
, 1, (COND
), it
, t_it
),
8877 TUE(ite
, 0, bf04
, 1, (COND
), it
, t_it
),
8878 TUE(ittt
, 0, bf0e
, 1, (COND
), it
, t_it
),
8879 TUE(itet
, 0, bf06
, 1, (COND
), it
, t_it
),
8880 TUE(itte
, 0, bf0a
, 1, (COND
), it
, t_it
),
8881 TUE(itee
, 0, bf02
, 1, (COND
), it
, t_it
),
8882 TUE(itttt
, 0, bf0f
, 1, (COND
), it
, t_it
),
8883 TUE(itett
, 0, bf07
, 1, (COND
), it
, t_it
),
8884 TUE(ittet
, 0, bf0b
, 1, (COND
), it
, t_it
),
8885 TUE(iteet
, 0, bf03
, 1, (COND
), it
, t_it
),
8886 TUE(ittte
, 0, bf0d
, 1, (COND
), it
, t_it
),
8887 TUE(itete
, 0, bf05
, 1, (COND
), it
, t_it
),
8888 TUE(ittee
, 0, bf09
, 1, (COND
), it
, t_it
),
8889 TUE(iteee
, 0, bf01
, 1, (COND
), it
, t_it
),
8891 /* Thumb2 only instructions. */
8893 #define ARM_VARIANT 0
8895 TCE(addw
, 0, f2000000
, 3, (RR
, RR
, EXPi
), 0, t_add_sub_w
),
8896 TCE(subw
, 0, f2a00000
, 3, (RR
, RR
, EXPi
), 0, t_add_sub_w
),
8897 TCE(tbb
, 0, e8d0f000
, 1, (TB
), 0, t_tb
),
8898 TCE(tbh
, 0, e8d0f010
, 1, (TB
), 0, t_tb
),
8901 #define ARM_VARIANT FPU_FPA_EXT_V1 /* Core FPA instruction set (V1). */
8902 cCE(wfs
, e200110
, 1, (RR
), rd
),
8903 cCE(rfs
, e300110
, 1, (RR
), rd
),
8904 cCE(wfc
, e400110
, 1, (RR
), rd
),
8905 cCE(rfc
, e500110
, 1, (RR
), rd
),
8907 cC3(ldfs
, c100100
, 2, (RF
, ADDR
), rd_cpaddr
),
8908 cC3(ldfd
, c108100
, 2, (RF
, ADDR
), rd_cpaddr
),
8909 cC3(ldfe
, c500100
, 2, (RF
, ADDR
), rd_cpaddr
),
8910 cC3(ldfp
, c508100
, 2, (RF
, ADDR
), rd_cpaddr
),
8912 cC3(stfs
, c000100
, 2, (RF
, ADDR
), rd_cpaddr
),
8913 cC3(stfd
, c008100
, 2, (RF
, ADDR
), rd_cpaddr
),
8914 cC3(stfe
, c400100
, 2, (RF
, ADDR
), rd_cpaddr
),
8915 cC3(stfp
, c408100
, 2, (RF
, ADDR
), rd_cpaddr
),
8917 cC3(mvfs
, e008100
, 2, (RF
, RF_IF
), rd_rm
),
8918 cC3(mvfsp
, e008120
, 2, (RF
, RF_IF
), rd_rm
),
8919 cC3(mvfsm
, e008140
, 2, (RF
, RF_IF
), rd_rm
),
8920 cC3(mvfsz
, e008160
, 2, (RF
, RF_IF
), rd_rm
),
8921 cC3(mvfd
, e008180
, 2, (RF
, RF_IF
), rd_rm
),
8922 cC3(mvfdp
, e0081a0
, 2, (RF
, RF_IF
), rd_rm
),
8923 cC3(mvfdm
, e0081c0
, 2, (RF
, RF_IF
), rd_rm
),
8924 cC3(mvfdz
, e0081e0
, 2, (RF
, RF_IF
), rd_rm
),
8925 cC3(mvfe
, e088100
, 2, (RF
, RF_IF
), rd_rm
),
8926 cC3(mvfep
, e088120
, 2, (RF
, RF_IF
), rd_rm
),
8927 cC3(mvfem
, e088140
, 2, (RF
, RF_IF
), rd_rm
),
8928 cC3(mvfez
, e088160
, 2, (RF
, RF_IF
), rd_rm
),
8930 cC3(mnfs
, e108100
, 2, (RF
, RF_IF
), rd_rm
),
8931 cC3(mnfsp
, e108120
, 2, (RF
, RF_IF
), rd_rm
),
8932 cC3(mnfsm
, e108140
, 2, (RF
, RF_IF
), rd_rm
),
8933 cC3(mnfsz
, e108160
, 2, (RF
, RF_IF
), rd_rm
),
8934 cC3(mnfd
, e108180
, 2, (RF
, RF_IF
), rd_rm
),
8935 cC3(mnfdp
, e1081a0
, 2, (RF
, RF_IF
), rd_rm
),
8936 cC3(mnfdm
, e1081c0
, 2, (RF
, RF_IF
), rd_rm
),
8937 cC3(mnfdz
, e1081e0
, 2, (RF
, RF_IF
), rd_rm
),
8938 cC3(mnfe
, e188100
, 2, (RF
, RF_IF
), rd_rm
),
8939 cC3(mnfep
, e188120
, 2, (RF
, RF_IF
), rd_rm
),
8940 cC3(mnfem
, e188140
, 2, (RF
, RF_IF
), rd_rm
),
8941 cC3(mnfez
, e188160
, 2, (RF
, RF_IF
), rd_rm
),
8943 cC3(abss
, e208100
, 2, (RF
, RF_IF
), rd_rm
),
8944 cC3(abssp
, e208120
, 2, (RF
, RF_IF
), rd_rm
),
8945 cC3(abssm
, e208140
, 2, (RF
, RF_IF
), rd_rm
),
8946 cC3(abssz
, e208160
, 2, (RF
, RF_IF
), rd_rm
),
8947 cC3(absd
, e208180
, 2, (RF
, RF_IF
), rd_rm
),
8948 cC3(absdp
, e2081a0
, 2, (RF
, RF_IF
), rd_rm
),
8949 cC3(absdm
, e2081c0
, 2, (RF
, RF_IF
), rd_rm
),
8950 cC3(absdz
, e2081e0
, 2, (RF
, RF_IF
), rd_rm
),
8951 cC3(abse
, e288100
, 2, (RF
, RF_IF
), rd_rm
),
8952 cC3(absep
, e288120
, 2, (RF
, RF_IF
), rd_rm
),
8953 cC3(absem
, e288140
, 2, (RF
, RF_IF
), rd_rm
),
8954 cC3(absez
, e288160
, 2, (RF
, RF_IF
), rd_rm
),
8956 cC3(rnds
, e308100
, 2, (RF
, RF_IF
), rd_rm
),
8957 cC3(rndsp
, e308120
, 2, (RF
, RF_IF
), rd_rm
),
8958 cC3(rndsm
, e308140
, 2, (RF
, RF_IF
), rd_rm
),
8959 cC3(rndsz
, e308160
, 2, (RF
, RF_IF
), rd_rm
),
8960 cC3(rndd
, e308180
, 2, (RF
, RF_IF
), rd_rm
),
8961 cC3(rnddp
, e3081a0
, 2, (RF
, RF_IF
), rd_rm
),
8962 cC3(rnddm
, e3081c0
, 2, (RF
, RF_IF
), rd_rm
),
8963 cC3(rnddz
, e3081e0
, 2, (RF
, RF_IF
), rd_rm
),
8964 cC3(rnde
, e388100
, 2, (RF
, RF_IF
), rd_rm
),
8965 cC3(rndep
, e388120
, 2, (RF
, RF_IF
), rd_rm
),
8966 cC3(rndem
, e388140
, 2, (RF
, RF_IF
), rd_rm
),
8967 cC3(rndez
, e388160
, 2, (RF
, RF_IF
), rd_rm
),
8969 cC3(sqts
, e408100
, 2, (RF
, RF_IF
), rd_rm
),
8970 cC3(sqtsp
, e408120
, 2, (RF
, RF_IF
), rd_rm
),
8971 cC3(sqtsm
, e408140
, 2, (RF
, RF_IF
), rd_rm
),
8972 cC3(sqtsz
, e408160
, 2, (RF
, RF_IF
), rd_rm
),
8973 cC3(sqtd
, e408180
, 2, (RF
, RF_IF
), rd_rm
),
8974 cC3(sqtdp
, e4081a0
, 2, (RF
, RF_IF
), rd_rm
),
8975 cC3(sqtdm
, e4081c0
, 2, (RF
, RF_IF
), rd_rm
),
8976 cC3(sqtdz
, e4081e0
, 2, (RF
, RF_IF
), rd_rm
),
8977 cC3(sqte
, e488100
, 2, (RF
, RF_IF
), rd_rm
),
8978 cC3(sqtep
, e488120
, 2, (RF
, RF_IF
), rd_rm
),
8979 cC3(sqtem
, e488140
, 2, (RF
, RF_IF
), rd_rm
),
8980 cC3(sqtez
, e488160
, 2, (RF
, RF_IF
), rd_rm
),
8982 cC3(logs
, e508100
, 2, (RF
, RF_IF
), rd_rm
),
8983 cC3(logsp
, e508120
, 2, (RF
, RF_IF
), rd_rm
),
8984 cC3(logsm
, e508140
, 2, (RF
, RF_IF
), rd_rm
),
8985 cC3(logsz
, e508160
, 2, (RF
, RF_IF
), rd_rm
),
8986 cC3(logd
, e508180
, 2, (RF
, RF_IF
), rd_rm
),
8987 cC3(logdp
, e5081a0
, 2, (RF
, RF_IF
), rd_rm
),
8988 cC3(logdm
, e5081c0
, 2, (RF
, RF_IF
), rd_rm
),
8989 cC3(logdz
, e5081e0
, 2, (RF
, RF_IF
), rd_rm
),
8990 cC3(loge
, e588100
, 2, (RF
, RF_IF
), rd_rm
),
8991 cC3(logep
, e588120
, 2, (RF
, RF_IF
), rd_rm
),
8992 cC3(logem
, e588140
, 2, (RF
, RF_IF
), rd_rm
),
8993 cC3(logez
, e588160
, 2, (RF
, RF_IF
), rd_rm
),
8995 cC3(lgns
, e608100
, 2, (RF
, RF_IF
), rd_rm
),
8996 cC3(lgnsp
, e608120
, 2, (RF
, RF_IF
), rd_rm
),
8997 cC3(lgnsm
, e608140
, 2, (RF
, RF_IF
), rd_rm
),
8998 cC3(lgnsz
, e608160
, 2, (RF
, RF_IF
), rd_rm
),
8999 cC3(lgnd
, e608180
, 2, (RF
, RF_IF
), rd_rm
),
9000 cC3(lgndp
, e6081a0
, 2, (RF
, RF_IF
), rd_rm
),
9001 cC3(lgndm
, e6081c0
, 2, (RF
, RF_IF
), rd_rm
),
9002 cC3(lgndz
, e6081e0
, 2, (RF
, RF_IF
), rd_rm
),
9003 cC3(lgne
, e688100
, 2, (RF
, RF_IF
), rd_rm
),
9004 cC3(lgnep
, e688120
, 2, (RF
, RF_IF
), rd_rm
),
9005 cC3(lgnem
, e688140
, 2, (RF
, RF_IF
), rd_rm
),
9006 cC3(lgnez
, e688160
, 2, (RF
, RF_IF
), rd_rm
),
9008 cC3(exps
, e708100
, 2, (RF
, RF_IF
), rd_rm
),
9009 cC3(expsp
, e708120
, 2, (RF
, RF_IF
), rd_rm
),
9010 cC3(expsm
, e708140
, 2, (RF
, RF_IF
), rd_rm
),
9011 cC3(expsz
, e708160
, 2, (RF
, RF_IF
), rd_rm
),
9012 cC3(expd
, e708180
, 2, (RF
, RF_IF
), rd_rm
),
9013 cC3(expdp
, e7081a0
, 2, (RF
, RF_IF
), rd_rm
),
9014 cC3(expdm
, e7081c0
, 2, (RF
, RF_IF
), rd_rm
),
9015 cC3(expdz
, e7081e0
, 2, (RF
, RF_IF
), rd_rm
),
9016 cC3(expe
, e788100
, 2, (RF
, RF_IF
), rd_rm
),
9017 cC3(expep
, e788120
, 2, (RF
, RF_IF
), rd_rm
),
9018 cC3(expem
, e788140
, 2, (RF
, RF_IF
), rd_rm
),
9019 cC3(expdz
, e788160
, 2, (RF
, RF_IF
), rd_rm
),
9021 cC3(sins
, e808100
, 2, (RF
, RF_IF
), rd_rm
),
9022 cC3(sinsp
, e808120
, 2, (RF
, RF_IF
), rd_rm
),
9023 cC3(sinsm
, e808140
, 2, (RF
, RF_IF
), rd_rm
),
9024 cC3(sinsz
, e808160
, 2, (RF
, RF_IF
), rd_rm
),
9025 cC3(sind
, e808180
, 2, (RF
, RF_IF
), rd_rm
),
9026 cC3(sindp
, e8081a0
, 2, (RF
, RF_IF
), rd_rm
),
9027 cC3(sindm
, e8081c0
, 2, (RF
, RF_IF
), rd_rm
),
9028 cC3(sindz
, e8081e0
, 2, (RF
, RF_IF
), rd_rm
),
9029 cC3(sine
, e888100
, 2, (RF
, RF_IF
), rd_rm
),
9030 cC3(sinep
, e888120
, 2, (RF
, RF_IF
), rd_rm
),
9031 cC3(sinem
, e888140
, 2, (RF
, RF_IF
), rd_rm
),
9032 cC3(sinez
, e888160
, 2, (RF
, RF_IF
), rd_rm
),
9034 cC3(coss
, e908100
, 2, (RF
, RF_IF
), rd_rm
),
9035 cC3(cossp
, e908120
, 2, (RF
, RF_IF
), rd_rm
),
9036 cC3(cossm
, e908140
, 2, (RF
, RF_IF
), rd_rm
),
9037 cC3(cossz
, e908160
, 2, (RF
, RF_IF
), rd_rm
),
9038 cC3(cosd
, e908180
, 2, (RF
, RF_IF
), rd_rm
),
9039 cC3(cosdp
, e9081a0
, 2, (RF
, RF_IF
), rd_rm
),
9040 cC3(cosdm
, e9081c0
, 2, (RF
, RF_IF
), rd_rm
),
9041 cC3(cosdz
, e9081e0
, 2, (RF
, RF_IF
), rd_rm
),
9042 cC3(cose
, e988100
, 2, (RF
, RF_IF
), rd_rm
),
9043 cC3(cosep
, e988120
, 2, (RF
, RF_IF
), rd_rm
),
9044 cC3(cosem
, e988140
, 2, (RF
, RF_IF
), rd_rm
),
9045 cC3(cosez
, e988160
, 2, (RF
, RF_IF
), rd_rm
),
9047 cC3(tans
, ea08100
, 2, (RF
, RF_IF
), rd_rm
),
9048 cC3(tansp
, ea08120
, 2, (RF
, RF_IF
), rd_rm
),
9049 cC3(tansm
, ea08140
, 2, (RF
, RF_IF
), rd_rm
),
9050 cC3(tansz
, ea08160
, 2, (RF
, RF_IF
), rd_rm
),
9051 cC3(tand
, ea08180
, 2, (RF
, RF_IF
), rd_rm
),
9052 cC3(tandp
, ea081a0
, 2, (RF
, RF_IF
), rd_rm
),
9053 cC3(tandm
, ea081c0
, 2, (RF
, RF_IF
), rd_rm
),
9054 cC3(tandz
, ea081e0
, 2, (RF
, RF_IF
), rd_rm
),
9055 cC3(tane
, ea88100
, 2, (RF
, RF_IF
), rd_rm
),
9056 cC3(tanep
, ea88120
, 2, (RF
, RF_IF
), rd_rm
),
9057 cC3(tanem
, ea88140
, 2, (RF
, RF_IF
), rd_rm
),
9058 cC3(tanez
, ea88160
, 2, (RF
, RF_IF
), rd_rm
),
9060 cC3(asns
, eb08100
, 2, (RF
, RF_IF
), rd_rm
),
9061 cC3(asnsp
, eb08120
, 2, (RF
, RF_IF
), rd_rm
),
9062 cC3(asnsm
, eb08140
, 2, (RF
, RF_IF
), rd_rm
),
9063 cC3(asnsz
, eb08160
, 2, (RF
, RF_IF
), rd_rm
),
9064 cC3(asnd
, eb08180
, 2, (RF
, RF_IF
), rd_rm
),
9065 cC3(asndp
, eb081a0
, 2, (RF
, RF_IF
), rd_rm
),
9066 cC3(asndm
, eb081c0
, 2, (RF
, RF_IF
), rd_rm
),
9067 cC3(asndz
, eb081e0
, 2, (RF
, RF_IF
), rd_rm
),
9068 cC3(asne
, eb88100
, 2, (RF
, RF_IF
), rd_rm
),
9069 cC3(asnep
, eb88120
, 2, (RF
, RF_IF
), rd_rm
),
9070 cC3(asnem
, eb88140
, 2, (RF
, RF_IF
), rd_rm
),
9071 cC3(asnez
, eb88160
, 2, (RF
, RF_IF
), rd_rm
),
9073 cC3(acss
, ec08100
, 2, (RF
, RF_IF
), rd_rm
),
9074 cC3(acssp
, ec08120
, 2, (RF
, RF_IF
), rd_rm
),
9075 cC3(acssm
, ec08140
, 2, (RF
, RF_IF
), rd_rm
),
9076 cC3(acssz
, ec08160
, 2, (RF
, RF_IF
), rd_rm
),
9077 cC3(acsd
, ec08180
, 2, (RF
, RF_IF
), rd_rm
),
9078 cC3(acsdp
, ec081a0
, 2, (RF
, RF_IF
), rd_rm
),
9079 cC3(acsdm
, ec081c0
, 2, (RF
, RF_IF
), rd_rm
),
9080 cC3(acsdz
, ec081e0
, 2, (RF
, RF_IF
), rd_rm
),
9081 cC3(acse
, ec88100
, 2, (RF
, RF_IF
), rd_rm
),
9082 cC3(acsep
, ec88120
, 2, (RF
, RF_IF
), rd_rm
),
9083 cC3(acsem
, ec88140
, 2, (RF
, RF_IF
), rd_rm
),
9084 cC3(acsez
, ec88160
, 2, (RF
, RF_IF
), rd_rm
),
9086 cC3(atns
, ed08100
, 2, (RF
, RF_IF
), rd_rm
),
9087 cC3(atnsp
, ed08120
, 2, (RF
, RF_IF
), rd_rm
),
9088 cC3(atnsm
, ed08140
, 2, (RF
, RF_IF
), rd_rm
),
9089 cC3(atnsz
, ed08160
, 2, (RF
, RF_IF
), rd_rm
),
9090 cC3(atnd
, ed08180
, 2, (RF
, RF_IF
), rd_rm
),
9091 cC3(atndp
, ed081a0
, 2, (RF
, RF_IF
), rd_rm
),
9092 cC3(atndm
, ed081c0
, 2, (RF
, RF_IF
), rd_rm
),
9093 cC3(atndz
, ed081e0
, 2, (RF
, RF_IF
), rd_rm
),
9094 cC3(atne
, ed88100
, 2, (RF
, RF_IF
), rd_rm
),
9095 cC3(atnep
, ed88120
, 2, (RF
, RF_IF
), rd_rm
),
9096 cC3(atnem
, ed88140
, 2, (RF
, RF_IF
), rd_rm
),
9097 cC3(atnez
, ed88160
, 2, (RF
, RF_IF
), rd_rm
),
9099 cC3(urds
, ee08100
, 2, (RF
, RF_IF
), rd_rm
),
9100 cC3(urdsp
, ee08120
, 2, (RF
, RF_IF
), rd_rm
),
9101 cC3(urdsm
, ee08140
, 2, (RF
, RF_IF
), rd_rm
),
9102 cC3(urdsz
, ee08160
, 2, (RF
, RF_IF
), rd_rm
),
9103 cC3(urdd
, ee08180
, 2, (RF
, RF_IF
), rd_rm
),
9104 cC3(urddp
, ee081a0
, 2, (RF
, RF_IF
), rd_rm
),
9105 cC3(urddm
, ee081c0
, 2, (RF
, RF_IF
), rd_rm
),
9106 cC3(urddz
, ee081e0
, 2, (RF
, RF_IF
), rd_rm
),
9107 cC3(urde
, ee88100
, 2, (RF
, RF_IF
), rd_rm
),
9108 cC3(urdep
, ee88120
, 2, (RF
, RF_IF
), rd_rm
),
9109 cC3(urdem
, ee88140
, 2, (RF
, RF_IF
), rd_rm
),
9110 cC3(urdez
, ee88160
, 2, (RF
, RF_IF
), rd_rm
),
9112 cC3(nrms
, ef08100
, 2, (RF
, RF_IF
), rd_rm
),
9113 cC3(nrmsp
, ef08120
, 2, (RF
, RF_IF
), rd_rm
),
9114 cC3(nrmsm
, ef08140
, 2, (RF
, RF_IF
), rd_rm
),
9115 cC3(nrmsz
, ef08160
, 2, (RF
, RF_IF
), rd_rm
),
9116 cC3(nrmd
, ef08180
, 2, (RF
, RF_IF
), rd_rm
),
9117 cC3(nrmdp
, ef081a0
, 2, (RF
, RF_IF
), rd_rm
),
9118 cC3(nrmdm
, ef081c0
, 2, (RF
, RF_IF
), rd_rm
),
9119 cC3(nrmdz
, ef081e0
, 2, (RF
, RF_IF
), rd_rm
),
9120 cC3(nrme
, ef88100
, 2, (RF
, RF_IF
), rd_rm
),
9121 cC3(nrmep
, ef88120
, 2, (RF
, RF_IF
), rd_rm
),
9122 cC3(nrmem
, ef88140
, 2, (RF
, RF_IF
), rd_rm
),
9123 cC3(nrmez
, ef88160
, 2, (RF
, RF_IF
), rd_rm
),
9125 cC3(adfs
, e000100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9126 cC3(adfsp
, e000120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9127 cC3(adfsm
, e000140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9128 cC3(adfsz
, e000160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9129 cC3(adfd
, e000180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9130 cC3(adfdp
, e0001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9131 cC3(adfdm
, e0001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9132 cC3(adfdz
, e0001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9133 cC3(adfe
, e080100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9134 cC3(adfep
, e080120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9135 cC3(adfem
, e080140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9136 cC3(adfez
, e080160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9138 cC3(sufs
, e200100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9139 cC3(sufsp
, e200120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9140 cC3(sufsm
, e200140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9141 cC3(sufsz
, e200160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9142 cC3(sufd
, e200180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9143 cC3(sufdp
, e2001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9144 cC3(sufdm
, e2001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9145 cC3(sufdz
, e2001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9146 cC3(sufe
, e280100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9147 cC3(sufep
, e280120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9148 cC3(sufem
, e280140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9149 cC3(sufez
, e280160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9151 cC3(rsfs
, e300100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9152 cC3(rsfsp
, e300120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9153 cC3(rsfsm
, e300140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9154 cC3(rsfsz
, e300160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9155 cC3(rsfd
, e300180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9156 cC3(rsfdp
, e3001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9157 cC3(rsfdm
, e3001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9158 cC3(rsfdz
, e3001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9159 cC3(rsfe
, e380100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9160 cC3(rsfep
, e380120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9161 cC3(rsfem
, e380140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9162 cC3(rsfez
, e380160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9164 cC3(mufs
, e100100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9165 cC3(mufsp
, e100120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9166 cC3(mufsm
, e100140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9167 cC3(mufsz
, e100160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9168 cC3(mufd
, e100180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9169 cC3(mufdp
, e1001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9170 cC3(mufdm
, e1001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9171 cC3(mufdz
, e1001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9172 cC3(mufe
, e180100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9173 cC3(mufep
, e180120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9174 cC3(mufem
, e180140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9175 cC3(mufez
, e180160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9177 cC3(dvfs
, e400100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9178 cC3(dvfsp
, e400120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9179 cC3(dvfsm
, e400140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9180 cC3(dvfsz
, e400160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9181 cC3(dvfd
, e400180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9182 cC3(dvfdp
, e4001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9183 cC3(dvfdm
, e4001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9184 cC3(dvfdz
, e4001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9185 cC3(dvfe
, e480100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9186 cC3(dvfep
, e480120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9187 cC3(dvfem
, e480140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9188 cC3(dvfez
, e480160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9190 cC3(rdfs
, e500100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9191 cC3(rdfsp
, e500120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9192 cC3(rdfsm
, e500140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9193 cC3(rdfsz
, e500160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9194 cC3(rdfd
, e500180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9195 cC3(rdfdp
, e5001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9196 cC3(rdfdm
, e5001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9197 cC3(rdfdz
, e5001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9198 cC3(rdfe
, e580100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9199 cC3(rdfep
, e580120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9200 cC3(rdfem
, e580140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9201 cC3(rdfez
, e580160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9203 cC3(pows
, e600100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9204 cC3(powsp
, e600120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9205 cC3(powsm
, e600140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9206 cC3(powsz
, e600160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9207 cC3(powd
, e600180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9208 cC3(powdp
, e6001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9209 cC3(powdm
, e6001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9210 cC3(powdz
, e6001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9211 cC3(powe
, e680100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9212 cC3(powep
, e680120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9213 cC3(powem
, e680140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9214 cC3(powez
, e680160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9216 cC3(rpws
, e700100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9217 cC3(rpwsp
, e700120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9218 cC3(rpwsm
, e700140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9219 cC3(rpwsz
, e700160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9220 cC3(rpwd
, e700180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9221 cC3(rpwdp
, e7001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9222 cC3(rpwdm
, e7001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9223 cC3(rpwdz
, e7001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9224 cC3(rpwe
, e780100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9225 cC3(rpwep
, e780120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9226 cC3(rpwem
, e780140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9227 cC3(rpwez
, e780160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9229 cC3(rmfs
, e800100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9230 cC3(rmfsp
, e800120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9231 cC3(rmfsm
, e800140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9232 cC3(rmfsz
, e800160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9233 cC3(rmfd
, e800180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9234 cC3(rmfdp
, e8001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9235 cC3(rmfdm
, e8001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9236 cC3(rmfdz
, e8001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9237 cC3(rmfe
, e880100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9238 cC3(rmfep
, e880120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9239 cC3(rmfem
, e880140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9240 cC3(rmfez
, e880160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9242 cC3(fmls
, e900100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9243 cC3(fmlsp
, e900120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9244 cC3(fmlsm
, e900140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9245 cC3(fmlsz
, e900160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9246 cC3(fmld
, e900180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9247 cC3(fmldp
, e9001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9248 cC3(fmldm
, e9001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9249 cC3(fmldz
, e9001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9250 cC3(fmle
, e980100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9251 cC3(fmlep
, e980120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9252 cC3(fmlem
, e980140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9253 cC3(fmlez
, e980160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9255 cC3(fdvs
, ea00100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9256 cC3(fdvsp
, ea00120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9257 cC3(fdvsm
, ea00140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9258 cC3(fdvsz
, ea00160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9259 cC3(fdvd
, ea00180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9260 cC3(fdvdp
, ea001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9261 cC3(fdvdm
, ea001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9262 cC3(fdvdz
, ea001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9263 cC3(fdve
, ea80100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9264 cC3(fdvep
, ea80120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9265 cC3(fdvem
, ea80140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9266 cC3(fdvez
, ea80160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9268 cC3(frds
, eb00100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9269 cC3(frdsp
, eb00120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9270 cC3(frdsm
, eb00140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9271 cC3(frdsz
, eb00160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9272 cC3(frdd
, eb00180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9273 cC3(frddp
, eb001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9274 cC3(frddm
, eb001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9275 cC3(frddz
, eb001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9276 cC3(frde
, eb80100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9277 cC3(frdep
, eb80120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9278 cC3(frdem
, eb80140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9279 cC3(frdez
, eb80160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9281 cC3(pols
, ec00100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9282 cC3(polsp
, ec00120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9283 cC3(polsm
, ec00140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9284 cC3(polsz
, ec00160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9285 cC3(pold
, ec00180
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9286 cC3(poldp
, ec001a0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9287 cC3(poldm
, ec001c0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9288 cC3(poldz
, ec001e0
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9289 cC3(pole
, ec80100
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9290 cC3(polep
, ec80120
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9291 cC3(polem
, ec80140
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9292 cC3(polez
, ec80160
, 3, (RF
, RF
, RF_IF
), rd_rn_rm
),
9294 cCE(cmf
, e90f110
, 2, (RF
, RF_IF
), fpa_cmp
),
9295 C3E(cmfe
, ed0f110
, 2, (RF
, RF_IF
), fpa_cmp
),
9296 cCE(cnf
, eb0f110
, 2, (RF
, RF_IF
), fpa_cmp
),
9297 C3E(cnfe
, ef0f110
, 2, (RF
, RF_IF
), fpa_cmp
),
9299 cC3(flts
, e000110
, 2, (RF
, RR
), rn_rd
),
9300 cC3(fltsp
, e000130
, 2, (RF
, RR
), rn_rd
),
9301 cC3(fltsm
, e000150
, 2, (RF
, RR
), rn_rd
),
9302 cC3(fltsz
, e000170
, 2, (RF
, RR
), rn_rd
),
9303 cC3(fltd
, e000190
, 2, (RF
, RR
), rn_rd
),
9304 cC3(fltdp
, e0001b0
, 2, (RF
, RR
), rn_rd
),
9305 cC3(fltdm
, e0001d0
, 2, (RF
, RR
), rn_rd
),
9306 cC3(fltdz
, e0001f0
, 2, (RF
, RR
), rn_rd
),
9307 cC3(flte
, e080110
, 2, (RF
, RR
), rn_rd
),
9308 cC3(fltep
, e080130
, 2, (RF
, RR
), rn_rd
),
9309 cC3(fltem
, e080150
, 2, (RF
, RR
), rn_rd
),
9310 cC3(fltez
, e080170
, 2, (RF
, RR
), rn_rd
),
9312 /* The implementation of the FIX instruction is broken on some
9313 assemblers, in that it accepts a precision specifier as well as a
9314 rounding specifier, despite the fact that this is meaningless.
9315 To be more compatible, we accept it as well, though of course it
9316 does not set any bits. */
9317 cCE(fix
, e100110
, 2, (RR
, RF
), rd_rm
),
9318 cC3(fixp
, e100130
, 2, (RR
, RF
), rd_rm
),
9319 cC3(fixm
, e100150
, 2, (RR
, RF
), rd_rm
),
9320 cC3(fixz
, e100170
, 2, (RR
, RF
), rd_rm
),
9321 cC3(fixsp
, e100130
, 2, (RR
, RF
), rd_rm
),
9322 cC3(fixsm
, e100150
, 2, (RR
, RF
), rd_rm
),
9323 cC3(fixsz
, e100170
, 2, (RR
, RF
), rd_rm
),
9324 cC3(fixdp
, e100130
, 2, (RR
, RF
), rd_rm
),
9325 cC3(fixdm
, e100150
, 2, (RR
, RF
), rd_rm
),
9326 cC3(fixdz
, e100170
, 2, (RR
, RF
), rd_rm
),
9327 cC3(fixep
, e100130
, 2, (RR
, RF
), rd_rm
),
9328 cC3(fixem
, e100150
, 2, (RR
, RF
), rd_rm
),
9329 cC3(fixez
, e100170
, 2, (RR
, RF
), rd_rm
),
9331 /* Instructions that were new with the real FPA, call them V2. */
9333 #define ARM_VARIANT FPU_FPA_EXT_V2
9334 cCE(lfm
, c100200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
9335 cC3(lfmfd
, c900200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
9336 cC3(lfmea
, d100200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
9337 cCE(sfm
, c000200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
9338 cC3(sfmfd
, d000200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
9339 cC3(sfmea
, c800200
, 3, (RF
, I4b
, ADDR
), fpa_ldmstm
),
9342 #define ARM_VARIANT FPU_VFP_EXT_V1xD /* VFP V1xD (single precision). */
9343 /* Moves and type conversions. */
9344 cCE(fcpys
, eb00a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9345 cCE(fmrs
, e100a10
, 2, (RR
, RVS
), vfp_reg_from_sp
),
9346 cCE(fmsr
, e000a10
, 2, (RVS
, RR
), vfp_sp_from_reg
),
9347 cCE(fmstat
, ef1fa10
, 0, (), noargs
),
9348 cCE(fsitos
, eb80ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9349 cCE(fuitos
, eb80a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9350 cCE(ftosis
, ebd0a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9351 cCE(ftosizs
, ebd0ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9352 cCE(ftouis
, ebc0a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9353 cCE(ftouizs
, ebc0ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9354 cCE(fmrx
, ef00a10
, 2, (RR
, RVC
), rd_rn
),
9355 cCE(fmxr
, ee00a10
, 2, (RVC
, RR
), rn_rd
),
9357 /* Memory operations. */
9358 cCE(flds
, d100a00
, 2, (RVS
, ADDR
), vfp_sp_ldst
),
9359 cCE(fsts
, d000a00
, 2, (RVS
, ADDR
), vfp_sp_ldst
),
9360 cCE(fldmias
, c900a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
9361 cCE(fldmfds
, c900a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
9362 cCE(fldmdbs
, d300a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
9363 cCE(fldmeas
, d300a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
9364 cCE(fldmiax
, c900b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
9365 cCE(fldmfdx
, c900b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
9366 cCE(fldmdbx
, d300b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
9367 cCE(fldmeax
, d300b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
9368 cCE(fstmias
, c800a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
9369 cCE(fstmeas
, c800a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmia
),
9370 cCE(fstmdbs
, d200a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
9371 cCE(fstmfds
, d200a00
, 2, (RRw
, VRSLST
), vfp_sp_ldstmdb
),
9372 cCE(fstmiax
, c800b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
9373 cCE(fstmeax
, c800b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmia
),
9374 cCE(fstmdbx
, d200b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
9375 cCE(fstmfdx
, d200b00
, 2, (RRw
, VRDLST
), vfp_xp_ldstmdb
),
9377 /* Monadic operations. */
9378 cCE(fabss
, eb00ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9379 cCE(fnegs
, eb10a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9380 cCE(fsqrts
, eb10ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9382 /* Dyadic operations. */
9383 cCE(fadds
, e300a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
9384 cCE(fsubs
, e300a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
9385 cCE(fmuls
, e200a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
9386 cCE(fdivs
, e800a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
9387 cCE(fmacs
, e000a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
9388 cCE(fmscs
, e100a00
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
9389 cCE(fnmuls
, e200a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
9390 cCE(fnmacs
, e000a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
9391 cCE(fnmscs
, e100a40
, 3, (RVS
, RVS
, RVS
), vfp_sp_dyadic
),
9394 cCE(fcmps
, eb40a40
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9395 cCE(fcmpzs
, eb50a40
, 1, (RVS
), vfp_sp_compare_z
),
9396 cCE(fcmpes
, eb40ac0
, 2, (RVS
, RVS
), vfp_sp_monadic
),
9397 cCE(fcmpezs
, eb50ac0
, 1, (RVS
), vfp_sp_compare_z
),
9400 #define ARM_VARIANT FPU_VFP_EXT_V1 /* VFP V1 (Double precision). */
9401 /* Moves and type conversions. */
9402 cCE(fcpyd
, eb00b40
, 2, (RVD
, RVD
), rd_rm
),
9403 cCE(fcvtds
, eb70ac0
, 2, (RVD
, RVS
), vfp_dp_sp_cvt
),
9404 cCE(fcvtsd
, eb70bc0
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
9405 cCE(fmdhr
, e200b10
, 2, (RVD
, RR
), rn_rd
),
9406 cCE(fmdlr
, e000b10
, 2, (RVD
, RR
), rn_rd
),
9407 cCE(fmrdh
, e300b10
, 2, (RR
, RVD
), rd_rn
),
9408 cCE(fmrdl
, e100b10
, 2, (RR
, RVD
), rd_rn
),
9409 cCE(fsitod
, eb80bc0
, 2, (RVD
, RVS
), vfp_dp_sp_cvt
),
9410 cCE(fuitod
, eb80b40
, 2, (RVD
, RVS
), vfp_dp_sp_cvt
),
9411 cCE(ftosid
, ebd0b40
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
9412 cCE(ftosizd
, ebd0bc0
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
9413 cCE(ftouid
, ebc0b40
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
9414 cCE(ftouizd
, ebc0bc0
, 2, (RVS
, RVD
), vfp_sp_dp_cvt
),
9416 /* Memory operations. */
9417 cCE(fldd
, d100b00
, 2, (RVD
, ADDR
), vfp_dp_ldst
),
9418 cCE(fstd
, d000b00
, 2, (RVD
, ADDR
), vfp_dp_ldst
),
9419 cCE(fldmiad
, c900b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
9420 cCE(fldmfdd
, c900b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
9421 cCE(fldmdbd
, d300b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
9422 cCE(fldmead
, d300b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
9423 cCE(fstmiad
, c800b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
9424 cCE(fstmead
, c800b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmia
),
9425 cCE(fstmdbd
, d200b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
9426 cCE(fstmfdd
, d200b00
, 2, (RRw
, VRDLST
), vfp_dp_ldstmdb
),
9428 /* Monadic operations. */
9429 cCE(fabsd
, eb00bc0
, 2, (RVD
, RVD
), rd_rm
),
9430 cCE(fnegd
, eb10b40
, 2, (RVD
, RVD
), rd_rm
),
9431 cCE(fsqrtd
, eb10bc0
, 2, (RVD
, RVD
), rd_rm
),
9433 /* Dyadic operations. */
9434 cCE(faddd
, e300b00
, 3, (RVD
, RVD
, RVD
), rd_rn_rm
),
9435 cCE(fsubd
, e300b40
, 3, (RVD
, RVD
, RVD
), rd_rn_rm
),
9436 cCE(fmuld
, e200b00
, 3, (RVD
, RVD
, RVD
), rd_rn_rm
),
9437 cCE(fdivd
, e800b00
, 3, (RVD
, RVD
, RVD
), rd_rn_rm
),
9438 cCE(fmacd
, e000b00
, 3, (RVD
, RVD
, RVD
), rd_rn_rm
),
9439 cCE(fmscd
, e100b00
, 3, (RVD
, RVD
, RVD
), rd_rn_rm
),
9440 cCE(fnmuld
, e200b40
, 3, (RVD
, RVD
, RVD
), rd_rn_rm
),
9441 cCE(fnmacd
, e000b40
, 3, (RVD
, RVD
, RVD
), rd_rn_rm
),
9442 cCE(fnmscd
, e100b40
, 3, (RVD
, RVD
, RVD
), rd_rn_rm
),
9445 cCE(fcmpd
, eb40b40
, 2, (RVD
, RVD
), rd_rm
),
9446 cCE(fcmpzd
, eb50b40
, 1, (RVD
), rd
),
9447 cCE(fcmped
, eb40bc0
, 2, (RVD
, RVD
), rd_rm
),
9448 cCE(fcmpezd
, eb50bc0
, 1, (RVD
), rd
),
9451 #define ARM_VARIANT FPU_VFP_EXT_V2
9452 cCE(fmsrr
, c400a10
, 3, (VRSLST
, RR
, RR
), vfp_sp2_from_reg2
),
9453 cCE(fmrrs
, c500a10
, 3, (RR
, RR
, VRSLST
), vfp_reg2_from_sp2
),
9454 cCE(fmdrr
, c400b10
, 3, (RVD
, RR
, RR
), rm_rd_rn
),
9455 cCE(fmrrd
, c500b10
, 3, (RR
, RR
, RVD
), rd_rn_rm
),
9458 #define ARM_VARIANT ARM_CEXT_XSCALE /* Intel XScale extensions. */
9459 cCE(mia
, e200010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
9460 cCE(miaph
, e280010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
9461 cCE(miabb
, e2c0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
9462 cCE(miabt
, e2d0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
9463 cCE(miatb
, e2e0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
9464 cCE(miatt
, e2f0010
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mia
),
9465 cCE(mar
, c400000
, 3, (RXA
, RRnpc
, RRnpc
), xsc_mar
),
9466 cCE(mra
, c500000
, 3, (RRnpc
, RRnpc
, RXA
), xsc_mra
),
9469 #define ARM_VARIANT ARM_CEXT_IWMMXT /* Intel Wireless MMX technology. */
9470 cCE(tandcb
, e13f130
, 1, (RR
), iwmmxt_tandorc
),
9471 cCE(tandch
, e53f130
, 1, (RR
), iwmmxt_tandorc
),
9472 cCE(tandcw
, e93f130
, 1, (RR
), iwmmxt_tandorc
),
9473 cCE(tbcstb
, e400010
, 2, (RIWR
, RR
), rn_rd
),
9474 cCE(tbcsth
, e400050
, 2, (RIWR
, RR
), rn_rd
),
9475 cCE(tbcstw
, e400090
, 2, (RIWR
, RR
), rn_rd
),
9476 cCE(textrcb
, e130170
, 2, (RR
, I7
), iwmmxt_textrc
),
9477 cCE(textrch
, e530170
, 2, (RR
, I7
), iwmmxt_textrc
),
9478 cCE(textrcw
, e930170
, 2, (RR
, I7
), iwmmxt_textrc
),
9479 cCE(textrmub
, e100070
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
9480 cCE(textrmuh
, e500070
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
9481 cCE(textrmuw
, e900070
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
9482 cCE(textrmsb
, e100078
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
9483 cCE(textrmsh
, e500078
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
9484 cCE(textrmsw
, e900078
, 3, (RR
, RIWR
, I7
), iwmmxt_textrm
),
9485 cCE(tinsrb
, e600010
, 3, (RIWR
, RR
, I7
), iwmmxt_tinsr
),
9486 cCE(tinsrh
, e600050
, 3, (RIWR
, RR
, I7
), iwmmxt_tinsr
),
9487 cCE(tinsrw
, e600090
, 3, (RIWR
, RR
, I7
), iwmmxt_tinsr
),
9488 cCE(tmcr
, e000110
, 2, (RIWC
, RR
), rn_rd
),
9489 cCE(tmcrr
, c400000
, 3, (RIWR
, RR
, RR
), rm_rd_rn
),
9490 cCE(tmia
, e200010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
9491 cCE(tmiaph
, e280010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
9492 cCE(tmiabb
, e2c0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
9493 cCE(tmiabt
, e2d0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
9494 cCE(tmiatb
, e2e0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
9495 cCE(tmiatt
, e2f0010
, 3, (RIWR
, RR
, RR
), iwmmxt_tmia
),
9496 cCE(tmovmskb
, e100030
, 2, (RR
, RIWR
), rd_rn
),
9497 cCE(tmovmskh
, e500030
, 2, (RR
, RIWR
), rd_rn
),
9498 cCE(tmovmskw
, e900030
, 2, (RR
, RIWR
), rd_rn
),
9499 cCE(tmrc
, e100110
, 2, (RR
, RIWC
), rd_rn
),
9500 cCE(tmrrc
, c500000
, 3, (RR
, RR
, RIWR
), rd_rn_rm
),
9501 cCE(torcb
, e13f150
, 1, (RR
), iwmmxt_tandorc
),
9502 cCE(torch
, e53f150
, 1, (RR
), iwmmxt_tandorc
),
9503 cCE(torcw
, e93f150
, 1, (RR
), iwmmxt_tandorc
),
9504 cCE(waccb
, e0001c0
, 2, (RIWR
, RIWR
), rd_rn
),
9505 cCE(wacch
, e4001c0
, 2, (RIWR
, RIWR
), rd_rn
),
9506 cCE(waccw
, e8001c0
, 2, (RIWR
, RIWR
), rd_rn
),
9507 cCE(waddbss
, e300180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9508 cCE(waddb
, e000180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9509 cCE(waddbus
, e100180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9510 cCE(waddhss
, e700180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9511 cCE(waddh
, e400180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9512 cCE(waddhus
, e500180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9513 cCE(waddwss
, eb00180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9514 cCE(waddw
, e800180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9515 cCE(waddwus
, e900180
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9516 cCE(waligni
, e000020
, 4, (RIWR
, RIWR
, RIWR
, I7
), iwmmxt_waligni
),
9517 cCE(walignr0
, e800020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9518 cCE(walignr1
, e900020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9519 cCE(walignr2
, ea00020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9520 cCE(walignr3
, eb00020
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9521 cCE(wand
, e200000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9522 cCE(wandn
, e300000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9523 cCE(wavg2b
, e800000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9524 cCE(wavg2br
, e900000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9525 cCE(wavg2h
, ec00000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9526 cCE(wavg2hr
, ed00000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9527 cCE(wcmpeqb
, e000060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9528 cCE(wcmpeqh
, e400060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9529 cCE(wcmpeqw
, e800060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9530 cCE(wcmpgtub
, e100060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9531 cCE(wcmpgtuh
, e500060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9532 cCE(wcmpgtuw
, e900060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9533 cCE(wcmpgtsb
, e300060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9534 cCE(wcmpgtsh
, e700060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9535 cCE(wcmpgtsw
, eb00060
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9536 cCE(wldrb
, c100000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
9537 cCE(wldrh
, c500000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
9538 cCE(wldrw
, c100100
, 2, (RIWR_RIWC
, ADDR
), iwmmxt_wldstw
),
9539 cCE(wldrd
, c500100
, 2, (RIWR
, ADDR
), iwmmxt_wldstd
),
9540 cCE(wmacs
, e600100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9541 cCE(wmacsz
, e700100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9542 cCE(wmacu
, e400100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9543 cCE(wmacuz
, e500100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9544 cCE(wmadds
, ea00100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9545 cCE(wmaddu
, e800100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9546 cCE(wmaxsb
, e200160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9547 cCE(wmaxsh
, e600160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9548 cCE(wmaxsw
, ea00160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9549 cCE(wmaxub
, e000160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9550 cCE(wmaxuh
, e400160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9551 cCE(wmaxuw
, e800160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9552 cCE(wminsb
, e300160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9553 cCE(wminsh
, e700160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9554 cCE(wminsw
, eb00160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9555 cCE(wminub
, e100160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9556 cCE(wminuh
, e500160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9557 cCE(wminuw
, e900160
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9558 cCE(wmov
, e000000
, 2, (RIWR
, RIWR
), iwmmxt_wmov
),
9559 cCE(wmulsm
, e300100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9560 cCE(wmulsl
, e200100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9561 cCE(wmulum
, e100100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9562 cCE(wmulul
, e000100
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9563 cCE(wor
, e000000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9564 cCE(wpackhss
, e700080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9565 cCE(wpackhus
, e500080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9566 cCE(wpackwss
, eb00080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9567 cCE(wpackwus
, e900080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9568 cCE(wpackdss
, ef00080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9569 cCE(wpackdus
, ed00080
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9570 cCE(wrorh
, e700040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9571 cCE(wrorhg
, e700148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9572 cCE(wrorw
, eb00040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9573 cCE(wrorwg
, eb00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9574 cCE(wrord
, ef00040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9575 cCE(wrordg
, ef00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9576 cCE(wsadb
, e000120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9577 cCE(wsadbz
, e100120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9578 cCE(wsadh
, e400120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9579 cCE(wsadhz
, e500120
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9580 cCE(wshufh
, e0001e0
, 3, (RIWR
, RIWR
, I255
), iwmmxt_wshufh
),
9581 cCE(wsllh
, e500040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9582 cCE(wsllhg
, e500148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9583 cCE(wsllw
, e900040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9584 cCE(wsllwg
, e900148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9585 cCE(wslld
, ed00040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9586 cCE(wslldg
, ed00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9587 cCE(wsrah
, e400040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9588 cCE(wsrahg
, e400148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9589 cCE(wsraw
, e800040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9590 cCE(wsrawg
, e800148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9591 cCE(wsrad
, ec00040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9592 cCE(wsradg
, ec00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9593 cCE(wsrlh
, e600040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9594 cCE(wsrlhg
, e600148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9595 cCE(wsrlw
, ea00040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9596 cCE(wsrlwg
, ea00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9597 cCE(wsrld
, ee00040
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9598 cCE(wsrldg
, ee00148
, 3, (RIWR
, RIWR
, RIWG
), rd_rn_rm
),
9599 cCE(wstrb
, c000000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
9600 cCE(wstrh
, c400000
, 2, (RIWR
, ADDR
), iwmmxt_wldstbh
),
9601 cCE(wstrw
, c000100
, 2, (RIWR_RIWC
, ADDR
), iwmmxt_wldstw
),
9602 cCE(wstrd
, c400100
, 2, (RIWR
, ADDR
), iwmmxt_wldstd
),
9603 cCE(wsubbss
, e3001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9604 cCE(wsubb
, e0001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9605 cCE(wsubbus
, e1001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9606 cCE(wsubhss
, e7001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9607 cCE(wsubh
, e4001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9608 cCE(wsubhus
, e5001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9609 cCE(wsubwss
, eb001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9610 cCE(wsubw
, e8001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9611 cCE(wsubwus
, e9001a0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9612 cCE(wunpckehub
,e0000c0
, 2, (RIWR
, RIWR
), rd_rn
),
9613 cCE(wunpckehuh
,e4000c0
, 2, (RIWR
, RIWR
), rd_rn
),
9614 cCE(wunpckehuw
,e8000c0
, 2, (RIWR
, RIWR
), rd_rn
),
9615 cCE(wunpckehsb
,e2000c0
, 2, (RIWR
, RIWR
), rd_rn
),
9616 cCE(wunpckehsh
,e6000c0
, 2, (RIWR
, RIWR
), rd_rn
),
9617 cCE(wunpckehsw
,ea000c0
, 2, (RIWR
, RIWR
), rd_rn
),
9618 cCE(wunpckihb
, e1000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9619 cCE(wunpckihh
, e5000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9620 cCE(wunpckihw
, e9000c0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9621 cCE(wunpckelub
,e0000e0
, 2, (RIWR
, RIWR
), rd_rn
),
9622 cCE(wunpckeluh
,e4000e0
, 2, (RIWR
, RIWR
), rd_rn
),
9623 cCE(wunpckeluw
,e8000e0
, 2, (RIWR
, RIWR
), rd_rn
),
9624 cCE(wunpckelsb
,e2000e0
, 2, (RIWR
, RIWR
), rd_rn
),
9625 cCE(wunpckelsh
,e6000e0
, 2, (RIWR
, RIWR
), rd_rn
),
9626 cCE(wunpckelsw
,ea000e0
, 2, (RIWR
, RIWR
), rd_rn
),
9627 cCE(wunpckilb
, e1000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9628 cCE(wunpckilh
, e5000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9629 cCE(wunpckilw
, e9000e0
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9630 cCE(wxor
, e100000
, 3, (RIWR
, RIWR
, RIWR
), rd_rn_rm
),
9631 cCE(wzero
, e300000
, 1, (RIWR
), iwmmxt_wzero
),
9634 #define ARM_VARIANT ARM_CEXT_MAVERICK /* Cirrus Maverick instructions. */
9635 cCE(cfldrs
, c100400
, 2, (RMF
, ADDR
), rd_cpaddr
),
9636 cCE(cfldrd
, c500400
, 2, (RMD
, ADDR
), rd_cpaddr
),
9637 cCE(cfldr32
, c100500
, 2, (RMFX
, ADDR
), rd_cpaddr
),
9638 cCE(cfldr64
, c500500
, 2, (RMDX
, ADDR
), rd_cpaddr
),
9639 cCE(cfstrs
, c000400
, 2, (RMF
, ADDR
), rd_cpaddr
),
9640 cCE(cfstrd
, c400400
, 2, (RMD
, ADDR
), rd_cpaddr
),
9641 cCE(cfstr32
, c000500
, 2, (RMFX
, ADDR
), rd_cpaddr
),
9642 cCE(cfstr64
, c400500
, 2, (RMDX
, ADDR
), rd_cpaddr
),
9643 cCE(cfmvsr
, e000450
, 2, (RMF
, RR
), rn_rd
),
9644 cCE(cfmvrs
, e100450
, 2, (RR
, RMF
), rd_rn
),
9645 cCE(cfmvdlr
, e000410
, 2, (RMD
, RR
), rn_rd
),
9646 cCE(cfmvrdl
, e100410
, 2, (RR
, RMD
), rd_rn
),
9647 cCE(cfmvdhr
, e000430
, 2, (RMD
, RR
), rn_rd
),
9648 cCE(cfmvrdh
, e100430
, 2, (RR
, RMD
), rd_rn
),
9649 cCE(cfmv64lr
, e000510
, 2, (RMDX
, RR
), rn_rd
),
9650 cCE(cfmvr64l
, e100510
, 2, (RR
, RMDX
), rd_rn
),
9651 cCE(cfmv64hr
, e000530
, 2, (RMDX
, RR
), rn_rd
),
9652 cCE(cfmvr64h
, e100530
, 2, (RR
, RMDX
), rd_rn
),
9653 cCE(cfmval32
, e200440
, 2, (RMAX
, RMFX
), rd_rn
),
9654 cCE(cfmv32al
, e100440
, 2, (RMFX
, RMAX
), rd_rn
),
9655 cCE(cfmvam32
, e200460
, 2, (RMAX
, RMFX
), rd_rn
),
9656 cCE(cfmv32am
, e100460
, 2, (RMFX
, RMAX
), rd_rn
),
9657 cCE(cfmvah32
, e200480
, 2, (RMAX
, RMFX
), rd_rn
),
9658 cCE(cfmv32ah
, e100480
, 2, (RMFX
, RMAX
), rd_rn
),
9659 cCE(cfmva32
, e2004a0
, 2, (RMAX
, RMFX
), rd_rn
),
9660 cCE(cfmv32a
, e1004a0
, 2, (RMFX
, RMAX
), rd_rn
),
9661 cCE(cfmva64
, e2004c0
, 2, (RMAX
, RMDX
), rd_rn
),
9662 cCE(cfmv64a
, e1004c0
, 2, (RMDX
, RMAX
), rd_rn
),
9663 cCE(cfmvsc32
, e2004e0
, 2, (RMDS
, RMDX
), mav_dspsc
),
9664 cCE(cfmv32sc
, e1004e0
, 2, (RMDX
, RMDS
), rd
),
9665 cCE(cfcpys
, e000400
, 2, (RMF
, RMF
), rd_rn
),
9666 cCE(cfcpyd
, e000420
, 2, (RMD
, RMD
), rd_rn
),
9667 cCE(cfcvtsd
, e000460
, 2, (RMD
, RMF
), rd_rn
),
9668 cCE(cfcvtds
, e000440
, 2, (RMF
, RMD
), rd_rn
),
9669 cCE(cfcvt32s
, e000480
, 2, (RMF
, RMFX
), rd_rn
),
9670 cCE(cfcvt32d
, e0004a0
, 2, (RMD
, RMFX
), rd_rn
),
9671 cCE(cfcvt64s
, e0004c0
, 2, (RMF
, RMDX
), rd_rn
),
9672 cCE(cfcvt64d
, e0004e0
, 2, (RMD
, RMDX
), rd_rn
),
9673 cCE(cfcvts32
, e100580
, 2, (RMFX
, RMF
), rd_rn
),
9674 cCE(cfcvtd32
, e1005a0
, 2, (RMFX
, RMD
), rd_rn
),
9675 cCE(cftruncs32
,e1005c0
, 2, (RMFX
, RMF
), rd_rn
),
9676 cCE(cftruncd32
,e1005e0
, 2, (RMFX
, RMD
), rd_rn
),
9677 cCE(cfrshl32
, e000550
, 3, (RMFX
, RMFX
, RR
), mav_triple
),
9678 cCE(cfrshl64
, e000570
, 3, (RMDX
, RMDX
, RR
), mav_triple
),
9679 cCE(cfsh32
, e000500
, 3, (RMFX
, RMFX
, I63s
), mav_shift
),
9680 cCE(cfsh64
, e200500
, 3, (RMDX
, RMDX
, I63s
), mav_shift
),
9681 cCE(cfcmps
, e100490
, 3, (RR
, RMF
, RMF
), rd_rn_rm
),
9682 cCE(cfcmpd
, e1004b0
, 3, (RR
, RMD
, RMD
), rd_rn_rm
),
9683 cCE(cfcmp32
, e100590
, 3, (RR
, RMFX
, RMFX
), rd_rn_rm
),
9684 cCE(cfcmp64
, e1005b0
, 3, (RR
, RMDX
, RMDX
), rd_rn_rm
),
9685 cCE(cfabss
, e300400
, 2, (RMF
, RMF
), rd_rn
),
9686 cCE(cfabsd
, e300420
, 2, (RMD
, RMD
), rd_rn
),
9687 cCE(cfnegs
, e300440
, 2, (RMF
, RMF
), rd_rn
),
9688 cCE(cfnegd
, e300460
, 2, (RMD
, RMD
), rd_rn
),
9689 cCE(cfadds
, e300480
, 3, (RMF
, RMF
, RMF
), rd_rn_rm
),
9690 cCE(cfaddd
, e3004a0
, 3, (RMD
, RMD
, RMD
), rd_rn_rm
),
9691 cCE(cfsubs
, e3004c0
, 3, (RMF
, RMF
, RMF
), rd_rn_rm
),
9692 cCE(cfsubd
, e3004e0
, 3, (RMD
, RMD
, RMD
), rd_rn_rm
),
9693 cCE(cfmuls
, e100400
, 3, (RMF
, RMF
, RMF
), rd_rn_rm
),
9694 cCE(cfmuld
, e100420
, 3, (RMD
, RMD
, RMD
), rd_rn_rm
),
9695 cCE(cfabs32
, e300500
, 2, (RMFX
, RMFX
), rd_rn
),
9696 cCE(cfabs64
, e300520
, 2, (RMDX
, RMDX
), rd_rn
),
9697 cCE(cfneg32
, e300540
, 2, (RMFX
, RMFX
), rd_rn
),
9698 cCE(cfneg64
, e300560
, 2, (RMDX
, RMDX
), rd_rn
),
9699 cCE(cfadd32
, e300580
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
9700 cCE(cfadd64
, e3005a0
, 3, (RMDX
, RMDX
, RMDX
), rd_rn_rm
),
9701 cCE(cfsub32
, e3005c0
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
9702 cCE(cfsub64
, e3005e0
, 3, (RMDX
, RMDX
, RMDX
), rd_rn_rm
),
9703 cCE(cfmul32
, e100500
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
9704 cCE(cfmul64
, e100520
, 3, (RMDX
, RMDX
, RMDX
), rd_rn_rm
),
9705 cCE(cfmac32
, e100540
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
9706 cCE(cfmsc32
, e100560
, 3, (RMFX
, RMFX
, RMFX
), rd_rn_rm
),
9707 cCE(cfmadd32
, e000600
, 4, (RMAX
, RMFX
, RMFX
, RMFX
), mav_quad
),
9708 cCE(cfmsub32
, e100600
, 4, (RMAX
, RMFX
, RMFX
, RMFX
), mav_quad
),
9709 cCE(cfmadda32
, e200600
, 4, (RMAX
, RMAX
, RMFX
, RMFX
), mav_quad
),
9710 cCE(cfmsuba32
, e300600
, 4, (RMAX
, RMAX
, RMFX
, RMFX
), mav_quad
),
9713 #undef THUMB_VARIANT
9735 /* MD interface: bits in the object file. */
9737 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
9738 for use in the a.out file, and stores them in the array pointed to by buf.
9739 This knows about the endian-ness of the target machine and does
9740 THE RIGHT THING, whatever it is. Possible values for n are 1 (byte)
9741 2 (short) and 4 (long) Floating numbers are put out as a series of
9742 LITTLENUMS (shorts, here at least). */
9745 md_number_to_chars (char * buf
, valueT val
, int n
)
9747 if (target_big_endian
)
9748 number_to_chars_bigendian (buf
, val
, n
);
9750 number_to_chars_littleendian (buf
, val
, n
);
9754 md_chars_to_number (char * buf
, int n
)
9757 unsigned char * where
= (unsigned char *) buf
;
9759 if (target_big_endian
)
9764 result
|= (*where
++ & 255);
9772 result
|= (where
[n
] & 255);
9779 /* MD interface: Sections. */
9781 /* Estimate the size of a frag before relaxing. Assume everything fits in
9785 md_estimate_size_before_relax (fragS
* fragp
,
9786 segT segtype ATTRIBUTE_UNUSED
)
9792 /* Convert a machine dependent frag. */
9795 md_convert_frag (bfd
*abfd
, segT asec ATTRIBUTE_UNUSED
, fragS
*fragp
)
9798 unsigned long old_op
;
9806 buf
= fragp
->fr_literal
+ fragp
->fr_fix
;
9808 old_op
= bfd_get_16(abfd
, buf
);
9809 if (fragp
->fr_symbol
) {
9810 exp
.X_op
= O_symbol
;
9811 exp
.X_add_symbol
= fragp
->fr_symbol
;
9813 exp
.X_op
= O_constant
;
9815 exp
.X_add_number
= fragp
->fr_offset
;
9816 opcode
= fragp
->fr_subtype
;
9820 case T_MNEM_ldr_pc2
:
9829 if (fragp
->fr_var
== 4)
9831 insn
= THUMB_OP32(opcode
);
9832 if ((old_op
>> 12) == 4 || (old_op
>> 12) == 9)
9834 insn
|= (old_op
& 0x700) << 4;
9838 insn
|= (old_op
& 7) << 12;
9839 insn
|= (old_op
& 0x38) << 13;
9842 put_thumb32_insn (buf
, insn
);
9843 reloc_type
= BFD_RELOC_ARM_T32_OFFSET_IMM
;
9847 reloc_type
= BFD_RELOC_ARM_THUMB_OFFSET
;
9849 pc_rel
= (opcode
== T_MNEM_ldr_pc2
);
9852 if (fragp
->fr_var
== 4)
9854 insn
= THUMB_OP32 (opcode
);
9855 insn
|= (old_op
& 0xf0) << 4;
9856 put_thumb32_insn (buf
, insn
);
9857 reloc_type
= BFD_RELOC_ARM_T32_ADD_PC12
;
9861 reloc_type
= BFD_RELOC_ARM_THUMB_ADD
;
9862 exp
.X_add_number
-= 4;
9870 if (fragp
->fr_var
== 4)
9872 int r0off
= (opcode
== T_MNEM_mov
9873 || opcode
== T_MNEM_movs
) ? 0 : 8;
9874 insn
= THUMB_OP32 (opcode
);
9875 insn
= (insn
& 0xe1ffffff) | 0x10000000;
9876 insn
|= (old_op
& 0x700) << r0off
;
9877 put_thumb32_insn (buf
, insn
);
9878 reloc_type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
9882 reloc_type
= BFD_RELOC_ARM_THUMB_IMM
;
9887 if (fragp
->fr_var
== 4)
9889 insn
= THUMB_OP32(opcode
);
9890 put_thumb32_insn (buf
, insn
);
9891 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH25
;
9894 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH12
;
9898 if (fragp
->fr_var
== 4)
9900 insn
= THUMB_OP32(opcode
);
9901 insn
|= (old_op
& 0xf00) << 14;
9902 put_thumb32_insn (buf
, insn
);
9903 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH20
;
9906 reloc_type
= BFD_RELOC_THUMB_PCREL_BRANCH9
;
9913 if (fragp
->fr_var
== 4)
9915 /* ??? Choose between add and addw. */
9916 insn
= THUMB_OP32 (opcode
);
9917 insn
|= (old_op
& 0xf0) << 4;
9918 put_thumb32_insn (buf
, insn
);
9919 reloc_type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
9922 reloc_type
= BFD_RELOC_ARM_THUMB_ADD
;
9930 if (fragp
->fr_var
== 4)
9932 insn
= THUMB_OP32 (opcode
);
9933 insn
|= (old_op
& 0xf0) << 4;
9934 insn
|= (old_op
& 0xf) << 16;
9935 put_thumb32_insn (buf
, insn
);
9936 reloc_type
= BFD_RELOC_ARM_T32_IMMEDIATE
;
9939 reloc_type
= BFD_RELOC_ARM_THUMB_ADD
;
9945 fixp
= fix_new_exp (fragp
, fragp
->fr_fix
, fragp
->fr_var
, &exp
, pc_rel
,
9947 fixp
->fx_file
= fragp
->fr_file
;
9948 fixp
->fx_line
= fragp
->fr_line
;
9949 fragp
->fr_fix
+= fragp
->fr_var
;
9952 /* Return the size of a relaxable immediate operand instruction.
9953 SHIFT and SIZE specify the form of the allowable immediate. */
9955 relax_immediate (fragS
*fragp
, int size
, int shift
)
9961 /* ??? Should be able to do better than this. */
9962 if (fragp
->fr_symbol
)
9965 low
= (1 << shift
) - 1;
9966 mask
= (1 << (shift
+ size
)) - (1 << shift
);
9967 offset
= fragp
->fr_offset
;
9968 /* Force misaligned offsets to 32-bit variant. */
9976 /* Return the size of a relaxable adr pseudo-instruction or PC-relative
9979 relax_adr (fragS
*fragp
, asection
*sec
)
9984 /* Assume worst case for symbols not known to be in the same section. */
9985 if (!S_IS_DEFINED(fragp
->fr_symbol
)
9986 || sec
!= S_GET_SEGMENT (fragp
->fr_symbol
))
9989 val
= S_GET_VALUE(fragp
->fr_symbol
) + fragp
->fr_offset
;
9990 addr
= fragp
->fr_address
+ fragp
->fr_fix
;
9991 addr
= (addr
+ 4) & ~3;
9992 /* Fix the insn as the 4-byte version if the target address is not
9993 sufficiently aligned. This is prevents an infinite loop when two
9994 instructions have contradictory range/alignment requirements. */
9998 if (val
< 0 || val
> 1020)
10003 /* Return the size of a relaxable add/sub immediate instruction. */
10005 relax_addsub (fragS
*fragp
, asection
*sec
)
10010 buf
= fragp
->fr_literal
+ fragp
->fr_fix
;
10011 op
= bfd_get_16(sec
->owner
, buf
);
10012 if ((op
& 0xf) == ((op
>> 4) & 0xf))
10013 return relax_immediate (fragp
, 8, 0);
10015 return relax_immediate (fragp
, 3, 0);
10019 /* Return the size of a relaxable branch instruction. BITS is the
10020 size of the offset field in the narrow instruction. */
10023 relax_branch (fragS
*fragp
, asection
*sec
, int bits
)
10029 /* Assume worst case for symbols not known to be in the same section. */
10030 if (!S_IS_DEFINED(fragp
->fr_symbol
)
10031 || sec
!= S_GET_SEGMENT (fragp
->fr_symbol
))
10034 val
= S_GET_VALUE(fragp
->fr_symbol
) + fragp
->fr_offset
;
10035 addr
= fragp
->fr_address
+ fragp
->fr_fix
+ 4;
10038 /* Offset is a signed value *2 */
10040 if (val
>= limit
|| val
< -limit
)
10046 /* Relax a machine dependent frag. This returns the amount by which
10047 the current size of the frag should change. */
10050 arm_relax_frag (asection
*sec
, fragS
*fragp
, long stretch ATTRIBUTE_UNUSED
)
10055 oldsize
= fragp
->fr_var
;
10056 switch (fragp
->fr_subtype
)
10058 case T_MNEM_ldr_pc2
:
10059 newsize
= relax_adr(fragp
, sec
);
10061 case T_MNEM_ldr_pc
:
10062 case T_MNEM_ldr_sp
:
10063 case T_MNEM_str_sp
:
10064 newsize
= relax_immediate(fragp
, 8, 2);
10068 newsize
= relax_immediate(fragp
, 5, 2);
10072 newsize
= relax_immediate(fragp
, 5, 1);
10076 newsize
= relax_immediate(fragp
, 5, 0);
10079 newsize
= relax_adr(fragp
, sec
);
10085 newsize
= relax_immediate(fragp
, 8, 0);
10088 newsize
= relax_branch(fragp
, sec
, 11);
10091 newsize
= relax_branch(fragp
, sec
, 8);
10093 case T_MNEM_add_sp
:
10094 case T_MNEM_add_pc
:
10095 newsize
= relax_immediate (fragp
, 8, 2);
10097 case T_MNEM_inc_sp
:
10098 case T_MNEM_dec_sp
:
10099 newsize
= relax_immediate (fragp
, 7, 2);
10105 newsize
= relax_addsub (fragp
, sec
);
10112 fragp
->fr_var
= -newsize
;
10113 md_convert_frag (sec
->owner
, sec
, fragp
);
10115 return -(newsize
+ oldsize
);
10117 fragp
->fr_var
= newsize
;
10118 return newsize
- oldsize
;
10121 /* Round up a section size to the appropriate boundary. */
10124 md_section_align (segT segment ATTRIBUTE_UNUSED
,
10130 /* Round all sects to multiple of 4. */
10131 return (size
+ 3) & ~3;
10135 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
10136 of an rs_align_code fragment. */
10139 arm_handle_align (fragS
* fragP
)
10141 static char const arm_noop
[4] = { 0x00, 0x00, 0xa0, 0xe1 };
10142 static char const thumb_noop
[2] = { 0xc0, 0x46 };
10143 static char const arm_bigend_noop
[4] = { 0xe1, 0xa0, 0x00, 0x00 };
10144 static char const thumb_bigend_noop
[2] = { 0x46, 0xc0 };
10146 int bytes
, fix
, noop_size
;
10150 if (fragP
->fr_type
!= rs_align_code
)
10153 bytes
= fragP
->fr_next
->fr_address
- fragP
->fr_address
- fragP
->fr_fix
;
10154 p
= fragP
->fr_literal
+ fragP
->fr_fix
;
10157 if (bytes
> MAX_MEM_FOR_RS_ALIGN_CODE
)
10158 bytes
&= MAX_MEM_FOR_RS_ALIGN_CODE
;
10160 if (fragP
->tc_frag_data
)
10162 if (target_big_endian
)
10163 noop
= thumb_bigend_noop
;
10166 noop_size
= sizeof (thumb_noop
);
10170 if (target_big_endian
)
10171 noop
= arm_bigend_noop
;
10174 noop_size
= sizeof (arm_noop
);
10177 if (bytes
& (noop_size
- 1))
10179 fix
= bytes
& (noop_size
- 1);
10180 memset (p
, 0, fix
);
10185 while (bytes
>= noop_size
)
10187 memcpy (p
, noop
, noop_size
);
10189 bytes
-= noop_size
;
10193 fragP
->fr_fix
+= fix
;
10194 fragP
->fr_var
= noop_size
;
10197 /* Called from md_do_align. Used to create an alignment
10198 frag in a code section. */
10201 arm_frag_align_code (int n
, int max
)
10205 /* We assume that there will never be a requirement
10206 to support alignments greater than 32 bytes. */
10207 if (max
> MAX_MEM_FOR_RS_ALIGN_CODE
)
10208 as_fatal (_("alignments greater than 32 bytes not supported in .text sections."));
10210 p
= frag_var (rs_align_code
,
10211 MAX_MEM_FOR_RS_ALIGN_CODE
,
10213 (relax_substateT
) max
,
10220 /* Perform target specific initialisation of a frag. */
10223 arm_init_frag (fragS
* fragP
)
10225 /* Record whether this frag is in an ARM or a THUMB area. */
10226 fragP
->tc_frag_data
= thumb_mode
;
10230 /* When we change sections we need to issue a new mapping symbol. */
10233 arm_elf_change_section (void)
10236 segment_info_type
*seginfo
;
10238 /* Link an unlinked unwind index table section to the .text section. */
10239 if (elf_section_type (now_seg
) == SHT_ARM_EXIDX
10240 && elf_linked_to_section (now_seg
) == NULL
)
10241 elf_linked_to_section (now_seg
) = text_section
;
10243 if (!SEG_NORMAL (now_seg
))
10246 flags
= bfd_get_section_flags (stdoutput
, now_seg
);
10248 /* We can ignore sections that only contain debug info. */
10249 if ((flags
& SEC_ALLOC
) == 0)
10252 seginfo
= seg_info (now_seg
);
10253 mapstate
= seginfo
->tc_segment_info_data
.mapstate
;
10254 marked_pr_dependency
= seginfo
->tc_segment_info_data
.marked_pr_dependency
;
10258 arm_elf_section_type (const char * str
, size_t len
)
10260 if (len
== 5 && strncmp (str
, "exidx", 5) == 0)
10261 return SHT_ARM_EXIDX
;
10266 /* Code to deal with unwinding tables. */
10268 static void add_unwind_adjustsp (offsetT
);
10270 /* Cenerate and deferred unwind frame offset. */
10273 flush_pending_unwind (void)
10277 offset
= unwind
.pending_offset
;
10278 unwind
.pending_offset
= 0;
10280 add_unwind_adjustsp (offset
);
10283 /* Add an opcode to this list for this function. Two-byte opcodes should
10284 be passed as op[0] << 8 | op[1]. The list of opcodes is built in reverse
10288 add_unwind_opcode (valueT op
, int length
)
10290 /* Add any deferred stack adjustment. */
10291 if (unwind
.pending_offset
)
10292 flush_pending_unwind ();
10294 unwind
.sp_restored
= 0;
10296 if (unwind
.opcode_count
+ length
> unwind
.opcode_alloc
)
10298 unwind
.opcode_alloc
+= ARM_OPCODE_CHUNK_SIZE
;
10299 if (unwind
.opcodes
)
10300 unwind
.opcodes
= xrealloc (unwind
.opcodes
,
10301 unwind
.opcode_alloc
);
10303 unwind
.opcodes
= xmalloc (unwind
.opcode_alloc
);
10308 unwind
.opcodes
[unwind
.opcode_count
] = op
& 0xff;
10310 unwind
.opcode_count
++;
10314 /* Add unwind opcodes to adjust the stack pointer. */
10317 add_unwind_adjustsp (offsetT offset
)
10321 if (offset
> 0x200)
10323 /* We need at most 5 bytes to hold a 32-bit value in a uleb128. */
10328 /* Long form: 0xb2, uleb128. */
10329 /* This might not fit in a word so add the individual bytes,
10330 remembering the list is built in reverse order. */
10331 o
= (valueT
) ((offset
- 0x204) >> 2);
10333 add_unwind_opcode (0, 1);
10335 /* Calculate the uleb128 encoding of the offset. */
10339 bytes
[n
] = o
& 0x7f;
10345 /* Add the insn. */
10347 add_unwind_opcode (bytes
[n
- 1], 1);
10348 add_unwind_opcode (0xb2, 1);
10350 else if (offset
> 0x100)
10352 /* Two short opcodes. */
10353 add_unwind_opcode (0x3f, 1);
10354 op
= (offset
- 0x104) >> 2;
10355 add_unwind_opcode (op
, 1);
10357 else if (offset
> 0)
10359 /* Short opcode. */
10360 op
= (offset
- 4) >> 2;
10361 add_unwind_opcode (op
, 1);
10363 else if (offset
< 0)
10366 while (offset
> 0x100)
10368 add_unwind_opcode (0x7f, 1);
10371 op
= ((offset
- 4) >> 2) | 0x40;
10372 add_unwind_opcode (op
, 1);
10376 /* Finish the list of unwind opcodes for this function. */
10378 finish_unwind_opcodes (void)
10382 if (unwind
.fp_used
)
10384 /* Adjust sp as neccessary. */
10385 unwind
.pending_offset
+= unwind
.fp_offset
- unwind
.frame_size
;
10386 flush_pending_unwind ();
10388 /* After restoring sp from the frame pointer. */
10389 op
= 0x90 | unwind
.fp_reg
;
10390 add_unwind_opcode (op
, 1);
10393 flush_pending_unwind ();
10397 /* Start an exception table entry. If idx is nonzero this is an index table
10401 start_unwind_section (const segT text_seg
, int idx
)
10403 const char * text_name
;
10404 const char * prefix
;
10405 const char * prefix_once
;
10406 const char * group_name
;
10410 size_t sec_name_len
;
10417 prefix
= ELF_STRING_ARM_unwind
;
10418 prefix_once
= ELF_STRING_ARM_unwind_once
;
10419 type
= SHT_ARM_EXIDX
;
10423 prefix
= ELF_STRING_ARM_unwind_info
;
10424 prefix_once
= ELF_STRING_ARM_unwind_info_once
;
10425 type
= SHT_PROGBITS
;
10428 text_name
= segment_name (text_seg
);
10429 if (streq (text_name
, ".text"))
10432 if (strncmp (text_name
, ".gnu.linkonce.t.",
10433 strlen (".gnu.linkonce.t.")) == 0)
10435 prefix
= prefix_once
;
10436 text_name
+= strlen (".gnu.linkonce.t.");
10439 prefix_len
= strlen (prefix
);
10440 text_len
= strlen (text_name
);
10441 sec_name_len
= prefix_len
+ text_len
;
10442 sec_name
= xmalloc (sec_name_len
+ 1);
10443 memcpy (sec_name
, prefix
, prefix_len
);
10444 memcpy (sec_name
+ prefix_len
, text_name
, text_len
);
10445 sec_name
[prefix_len
+ text_len
] = '\0';
10451 /* Handle COMDAT group. */
10452 if (prefix
!= prefix_once
&& (text_seg
->flags
& SEC_LINK_ONCE
) != 0)
10454 group_name
= elf_group_name (text_seg
);
10455 if (group_name
== NULL
)
10457 as_bad ("Group section `%s' has no group signature",
10458 segment_name (text_seg
));
10459 ignore_rest_of_line ();
10462 flags
|= SHF_GROUP
;
10466 obj_elf_change_section (sec_name
, type
, flags
, 0, group_name
, linkonce
, 0);
10468 /* Set the setion link for index tables. */
10470 elf_linked_to_section (now_seg
) = text_seg
;
10474 /* Start an unwind table entry. HAVE_DATA is nonzero if we have additional
10475 personality routine data. Returns zero, or the index table value for
10476 and inline entry. */
10479 create_unwind_entry (int have_data
)
10484 /* The current word of data. */
10486 /* The number of bytes left in this word. */
10489 finish_unwind_opcodes ();
10491 /* Remember the current text section. */
10492 unwind
.saved_seg
= now_seg
;
10493 unwind
.saved_subseg
= now_subseg
;
10495 start_unwind_section (now_seg
, 0);
10497 if (unwind
.personality_routine
== NULL
)
10499 if (unwind
.personality_index
== -2)
10502 as_bad (_("handerdata in cantunwind frame"));
10503 return 1; /* EXIDX_CANTUNWIND. */
10506 /* Use a default personality routine if none is specified. */
10507 if (unwind
.personality_index
== -1)
10509 if (unwind
.opcode_count
> 3)
10510 unwind
.personality_index
= 1;
10512 unwind
.personality_index
= 0;
10515 /* Space for the personality routine entry. */
10516 if (unwind
.personality_index
== 0)
10518 if (unwind
.opcode_count
> 3)
10519 as_bad (_("too many unwind opcodes for personality routine 0"));
10523 /* All the data is inline in the index table. */
10526 while (unwind
.opcode_count
> 0)
10528 unwind
.opcode_count
--;
10529 data
= (data
<< 8) | unwind
.opcodes
[unwind
.opcode_count
];
10533 /* Pad with "finish" opcodes. */
10535 data
= (data
<< 8) | 0xb0;
10542 /* We get two opcodes "free" in the first word. */
10543 size
= unwind
.opcode_count
- 2;
10546 /* An extra byte is required for the opcode count. */
10547 size
= unwind
.opcode_count
+ 1;
10549 size
= (size
+ 3) >> 2;
10551 as_bad (_("too many unwind opcodes"));
10553 frag_align (2, 0, 0);
10554 record_alignment (now_seg
, 2);
10555 unwind
.table_entry
= expr_build_dot ();
10557 /* Allocate the table entry. */
10558 ptr
= frag_more ((size
<< 2) + 4);
10559 where
= frag_now_fix () - ((size
<< 2) + 4);
10561 switch (unwind
.personality_index
)
10564 /* ??? Should this be a PLT generating relocation? */
10565 /* Custom personality routine. */
10566 fix_new (frag_now
, where
, 4, unwind
.personality_routine
, 0, 1,
10567 BFD_RELOC_ARM_PREL31
);
10572 /* Set the first byte to the number of additional words. */
10577 /* ABI defined personality routines. */
10579 /* Three opcodes bytes are packed into the first word. */
10586 /* The size and first two opcode bytes go in the first word. */
10587 data
= ((0x80 + unwind
.personality_index
) << 8) | size
;
10592 /* Should never happen. */
10596 /* Pack the opcodes into words (MSB first), reversing the list at the same
10598 while (unwind
.opcode_count
> 0)
10602 md_number_to_chars (ptr
, data
, 4);
10607 unwind
.opcode_count
--;
10609 data
= (data
<< 8) | unwind
.opcodes
[unwind
.opcode_count
];
10612 /* Finish off the last word. */
10615 /* Pad with "finish" opcodes. */
10617 data
= (data
<< 8) | 0xb0;
10619 md_number_to_chars (ptr
, data
, 4);
10624 /* Add an empty descriptor if there is no user-specified data. */
10625 ptr
= frag_more (4);
10626 md_number_to_chars (ptr
, 0, 4);
10632 /* Convert REGNAME to a DWARF-2 register number. */
10635 tc_arm_regname_to_dw2regnum (const char *regname
)
10637 int reg
= arm_reg_parse ((char **) ®name
, REG_TYPE_RN
);
10645 /* Initialize the DWARF-2 unwind information for this procedure. */
10648 tc_arm_frame_initial_instructions (void)
10650 cfi_add_CFA_def_cfa (REG_SP
, 0);
10652 #endif /* OBJ_ELF */
10655 /* MD interface: Symbol and relocation handling. */
10657 /* Return the address within the segment that a PC-relative fixup is
10658 relative to. For ARM, PC-relative fixups applied to instructions
10659 are generally relative to the location of the fixup plus 8 bytes.
10660 Thumb branches are offset by 4, and Thumb loads relative to PC
10661 require special handling. */
10664 md_pcrel_from_section (fixS
* fixP
, segT seg
)
10666 offsetT base
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
10668 /* If this is pc-relative and we are going to emit a relocation
10669 then we just want to put out any pipeline compensation that the linker
10670 will need. Otherwise we want to use the calculated base. */
10672 && ((fixP
->fx_addsy
&& S_GET_SEGMENT (fixP
->fx_addsy
) != seg
)
10673 || arm_force_relocation (fixP
)))
10676 switch (fixP
->fx_r_type
)
10678 /* PC relative addressing on the Thumb is slightly odd as the
10679 bottom two bits of the PC are forced to zero for the
10680 calculation. This happens *after* application of the
10681 pipeline offset. However, Thumb adrl already adjusts for
10682 this, so we need not do it again. */
10683 case BFD_RELOC_ARM_THUMB_ADD
:
10686 case BFD_RELOC_ARM_THUMB_OFFSET
:
10687 case BFD_RELOC_ARM_T32_OFFSET_IMM
:
10688 case BFD_RELOC_ARM_T32_ADD_PC12
:
10689 case BFD_RELOC_ARM_T32_CP_OFF_IMM
:
10690 return (base
+ 4) & ~3;
10692 /* Thumb branches are simply offset by +4. */
10693 case BFD_RELOC_THUMB_PCREL_BRANCH7
:
10694 case BFD_RELOC_THUMB_PCREL_BRANCH9
:
10695 case BFD_RELOC_THUMB_PCREL_BRANCH12
:
10696 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
10697 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
10698 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
10699 case BFD_RELOC_THUMB_PCREL_BLX
:
10702 /* ARM mode branches are offset by +8. However, the Windows CE
10703 loader expects the relocation not to take this into account. */
10704 case BFD_RELOC_ARM_PCREL_BRANCH
:
10705 case BFD_RELOC_ARM_PCREL_BLX
:
10706 case BFD_RELOC_ARM_PLT32
:
10713 /* ARM mode loads relative to PC are also offset by +8. Unlike
10714 branches, the Windows CE loader *does* expect the relocation
10715 to take this into account. */
10716 case BFD_RELOC_ARM_OFFSET_IMM
:
10717 case BFD_RELOC_ARM_OFFSET_IMM8
:
10718 case BFD_RELOC_ARM_HWLITERAL
:
10719 case BFD_RELOC_ARM_LITERAL
:
10720 case BFD_RELOC_ARM_CP_OFF_IMM
:
10724 /* Other PC-relative relocations are un-offset. */
10730 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
10731 Otherwise we have no need to default values of symbols. */
10734 md_undefined_symbol (char * name ATTRIBUTE_UNUSED
)
10737 if (name
[0] == '_' && name
[1] == 'G'
10738 && streq (name
, GLOBAL_OFFSET_TABLE_NAME
))
10742 if (symbol_find (name
))
10743 as_bad ("GOT already in the symbol table");
10745 GOT_symbol
= symbol_new (name
, undefined_section
,
10746 (valueT
) 0, & zero_address_frag
);
10756 /* Subroutine of md_apply_fix. Check to see if an immediate can be
10757 computed as two separate immediate values, added together. We
10758 already know that this value cannot be computed by just one ARM
10761 static unsigned int
10762 validate_immediate_twopart (unsigned int val
,
10763 unsigned int * highpart
)
10768 for (i
= 0; i
< 32; i
+= 2)
10769 if (((a
= rotate_left (val
, i
)) & 0xff) != 0)
10775 * highpart
= (a
>> 8) | ((i
+ 24) << 7);
10777 else if (a
& 0xff0000)
10779 if (a
& 0xff000000)
10781 * highpart
= (a
>> 16) | ((i
+ 16) << 7);
10785 assert (a
& 0xff000000);
10786 * highpart
= (a
>> 24) | ((i
+ 8) << 7);
10789 return (a
& 0xff) | (i
<< 7);
10796 validate_offset_imm (unsigned int val
, int hwse
)
10798 if ((hwse
&& val
> 255) || val
> 4095)
10803 /* Subroutine of md_apply_fix. Do those data_ops which can take a
10804 negative immediate constant by altering the instruction. A bit of
10809 by inverting the second operand, and
10812 by negating the second operand. */
10815 negate_data_op (unsigned long * instruction
,
10816 unsigned long value
)
10819 unsigned long negated
, inverted
;
10821 negated
= encode_arm_immediate (-value
);
10822 inverted
= encode_arm_immediate (~value
);
10824 op
= (*instruction
>> DATA_OP_SHIFT
) & 0xf;
10827 /* First negates. */
10828 case OPCODE_SUB
: /* ADD <-> SUB */
10829 new_inst
= OPCODE_ADD
;
10834 new_inst
= OPCODE_SUB
;
10838 case OPCODE_CMP
: /* CMP <-> CMN */
10839 new_inst
= OPCODE_CMN
;
10844 new_inst
= OPCODE_CMP
;
10848 /* Now Inverted ops. */
10849 case OPCODE_MOV
: /* MOV <-> MVN */
10850 new_inst
= OPCODE_MVN
;
10855 new_inst
= OPCODE_MOV
;
10859 case OPCODE_AND
: /* AND <-> BIC */
10860 new_inst
= OPCODE_BIC
;
10865 new_inst
= OPCODE_AND
;
10869 case OPCODE_ADC
: /* ADC <-> SBC */
10870 new_inst
= OPCODE_SBC
;
10875 new_inst
= OPCODE_ADC
;
10879 /* We cannot do anything. */
10884 if (value
== (unsigned) FAIL
)
10887 *instruction
&= OPCODE_MASK
;
10888 *instruction
|= new_inst
<< DATA_OP_SHIFT
;
10892 /* Read a 32-bit thumb instruction from buf. */
10893 static unsigned long
10894 get_thumb32_insn (char * buf
)
10896 unsigned long insn
;
10897 insn
= md_chars_to_number (buf
, THUMB_SIZE
) << 16;
10898 insn
|= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
10904 md_apply_fix (fixS
* fixP
,
10908 offsetT value
= * valP
;
10910 unsigned int newimm
;
10911 unsigned long temp
;
10913 char * buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
10915 assert (fixP
->fx_r_type
<= BFD_RELOC_UNUSED
);
10917 /* Note whether this will delete the relocation. */
10918 if (fixP
->fx_addsy
== 0 && !fixP
->fx_pcrel
)
10921 /* On a 64-bit host, silently truncate 'value' to 32 bits for
10922 consistency with the behavior on 32-bit hosts. Remember value
10924 value
&= 0xffffffff;
10925 value
^= 0x80000000;
10926 value
-= 0x80000000;
10929 fixP
->fx_addnumber
= value
;
10931 /* Same treatment for fixP->fx_offset. */
10932 fixP
->fx_offset
&= 0xffffffff;
10933 fixP
->fx_offset
^= 0x80000000;
10934 fixP
->fx_offset
-= 0x80000000;
10936 switch (fixP
->fx_r_type
)
10938 case BFD_RELOC_NONE
:
10939 /* This will need to go in the object file. */
10943 case BFD_RELOC_ARM_IMMEDIATE
:
10944 /* We claim that this fixup has been processed here,
10945 even if in fact we generate an error because we do
10946 not have a reloc for it, so tc_gen_reloc will reject it. */
10950 && ! S_IS_DEFINED (fixP
->fx_addsy
))
10952 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
10953 _("undefined symbol %s used as an immediate value"),
10954 S_GET_NAME (fixP
->fx_addsy
));
10958 newimm
= encode_arm_immediate (value
);
10959 temp
= md_chars_to_number (buf
, INSN_SIZE
);
10961 /* If the instruction will fail, see if we can fix things up by
10962 changing the opcode. */
10963 if (newimm
== (unsigned int) FAIL
10964 && (newimm
= negate_data_op (&temp
, value
)) == (unsigned int) FAIL
)
10966 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
10967 _("invalid constant (%lx) after fixup"),
10968 (unsigned long) value
);
10972 newimm
|= (temp
& 0xfffff000);
10973 md_number_to_chars (buf
, (valueT
) newimm
, INSN_SIZE
);
10976 case BFD_RELOC_ARM_ADRL_IMMEDIATE
:
10978 unsigned int highpart
= 0;
10979 unsigned int newinsn
= 0xe1a00000; /* nop. */
10981 newimm
= encode_arm_immediate (value
);
10982 temp
= md_chars_to_number (buf
, INSN_SIZE
);
10984 /* If the instruction will fail, see if we can fix things up by
10985 changing the opcode. */
10986 if (newimm
== (unsigned int) FAIL
10987 && (newimm
= negate_data_op (& temp
, value
)) == (unsigned int) FAIL
)
10989 /* No ? OK - try using two ADD instructions to generate
10991 newimm
= validate_immediate_twopart (value
, & highpart
);
10993 /* Yes - then make sure that the second instruction is
10995 if (newimm
!= (unsigned int) FAIL
)
10997 /* Still No ? Try using a negated value. */
10998 else if ((newimm
= validate_immediate_twopart (- value
, & highpart
)) != (unsigned int) FAIL
)
10999 temp
= newinsn
= (temp
& OPCODE_MASK
) | OPCODE_SUB
<< DATA_OP_SHIFT
;
11000 /* Otherwise - give up. */
11003 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11004 _("unable to compute ADRL instructions for PC offset of 0x%lx"),
11009 /* Replace the first operand in the 2nd instruction (which
11010 is the PC) with the destination register. We have
11011 already added in the PC in the first instruction and we
11012 do not want to do it again. */
11013 newinsn
&= ~ 0xf0000;
11014 newinsn
|= ((newinsn
& 0x0f000) << 4);
11017 newimm
|= (temp
& 0xfffff000);
11018 md_number_to_chars (buf
, (valueT
) newimm
, INSN_SIZE
);
11020 highpart
|= (newinsn
& 0xfffff000);
11021 md_number_to_chars (buf
+ INSN_SIZE
, (valueT
) highpart
, INSN_SIZE
);
11025 case BFD_RELOC_ARM_OFFSET_IMM
:
11026 case BFD_RELOC_ARM_LITERAL
:
11032 if (validate_offset_imm (value
, 0) == FAIL
)
11034 if (fixP
->fx_r_type
== BFD_RELOC_ARM_LITERAL
)
11035 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11036 _("invalid literal constant: pool needs to be closer"));
11038 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11039 _("bad immediate value for offset (%ld)"),
11044 newval
= md_chars_to_number (buf
, INSN_SIZE
);
11045 newval
&= 0xff7ff000;
11046 newval
|= value
| (sign
? INDEX_UP
: 0);
11047 md_number_to_chars (buf
, newval
, INSN_SIZE
);
11050 case BFD_RELOC_ARM_OFFSET_IMM8
:
11051 case BFD_RELOC_ARM_HWLITERAL
:
11057 if (validate_offset_imm (value
, 1) == FAIL
)
11059 if (fixP
->fx_r_type
== BFD_RELOC_ARM_HWLITERAL
)
11060 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11061 _("invalid literal constant: pool needs to be closer"));
11063 as_bad (_("bad immediate value for half-word offset (%ld)"),
11068 newval
= md_chars_to_number (buf
, INSN_SIZE
);
11069 newval
&= 0xff7ff0f0;
11070 newval
|= ((value
>> 4) << 8) | (value
& 0xf) | (sign
? INDEX_UP
: 0);
11071 md_number_to_chars (buf
, newval
, INSN_SIZE
);
11074 case BFD_RELOC_ARM_T32_OFFSET_U8
:
11075 if (value
< 0 || value
> 1020 || value
% 4 != 0)
11076 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11077 _("bad immediate value for offset (%ld)"), (long) value
);
11080 newval
= md_chars_to_number (buf
+2, THUMB_SIZE
);
11082 md_number_to_chars (buf
+2, newval
, THUMB_SIZE
);
11085 case BFD_RELOC_ARM_T32_OFFSET_IMM
:
11086 /* This is a complicated relocation used for all varieties of Thumb32
11087 load/store instruction with immediate offset:
11089 1110 100P u1WL NNNN XXXX YYYY iiii iiii - +/-(U) pre/post(P) 8-bit,
11090 *4, optional writeback(W)
11091 (doubleword load/store)
11093 1111 100S uTTL 1111 XXXX iiii iiii iiii - +/-(U) 12-bit PC-rel
11094 1111 100S 0TTL NNNN XXXX 1Pu1 iiii iiii - +/-(U) pre/post(P) 8-bit
11095 1111 100S 0TTL NNNN XXXX 1110 iiii iiii - positive 8-bit (T instruction)
11096 1111 100S 1TTL NNNN XXXX iiii iiii iiii - positive 12-bit
11097 1111 100S 0TTL NNNN XXXX 1100 iiii iiii - negative 8-bit
11099 Uppercase letters indicate bits that are already encoded at
11100 this point. Lowercase letters are our problem. For the
11101 second block of instructions, the secondary opcode nybble
11102 (bits 8..11) is present, and bit 23 is zero, even if this is
11103 a PC-relative operation. */
11104 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11106 newval
|= md_chars_to_number (buf
+THUMB_SIZE
, THUMB_SIZE
);
11108 if ((newval
& 0xf0000000) == 0xe0000000)
11110 /* Doubleword load/store: 8-bit offset, scaled by 4. */
11112 newval
|= (1 << 23);
11115 if (value
% 4 != 0)
11117 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11118 _("offset not a multiple of 4"));
11124 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11125 _("offset out of range"));
11130 else if ((newval
& 0x000f0000) == 0x000f0000)
11132 /* PC-relative, 12-bit offset. */
11134 newval
|= (1 << 23);
11137 if (value
>= 0xfff)
11139 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11140 _("offset out of range"));
11145 else if ((newval
& 0x00000100) == 0x00000100)
11147 /* Writeback: 8-bit, +/- offset. */
11149 newval
|= (1 << 9);
11154 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11155 _("offset out of range"));
11160 else if ((newval
& 0x00000f00) == 0x00000e00)
11162 /* T-instruction: positive 8-bit offset. */
11163 if (value
< 0 || value
>= 0xff)
11165 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11166 _("offset out of range"));
11174 /* Positive 12-bit or negative 8-bit offset. */
11178 newval
|= (1 << 23);
11188 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11189 _("offset out of range"));
11196 md_number_to_chars (buf
, (newval
>> 16) & 0xffff, THUMB_SIZE
);
11197 md_number_to_chars (buf
+ THUMB_SIZE
, newval
& 0xffff, THUMB_SIZE
);
11200 case BFD_RELOC_ARM_SHIFT_IMM
:
11201 newval
= md_chars_to_number (buf
, INSN_SIZE
);
11202 if (((unsigned long) value
) > 32
11204 && (((newval
& 0x60) == 0) || (newval
& 0x60) == 0x60)))
11206 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11207 _("shift expression is too large"));
11212 /* Shifts of zero must be done as lsl. */
11214 else if (value
== 32)
11216 newval
&= 0xfffff07f;
11217 newval
|= (value
& 0x1f) << 7;
11218 md_number_to_chars (buf
, newval
, INSN_SIZE
);
11221 case BFD_RELOC_ARM_T32_IMMEDIATE
:
11222 case BFD_RELOC_ARM_T32_IMM12
:
11223 case BFD_RELOC_ARM_T32_ADD_PC12
:
11224 /* We claim that this fixup has been processed here,
11225 even if in fact we generate an error because we do
11226 not have a reloc for it, so tc_gen_reloc will reject it. */
11230 && ! S_IS_DEFINED (fixP
->fx_addsy
))
11232 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11233 _("undefined symbol %s used as an immediate value"),
11234 S_GET_NAME (fixP
->fx_addsy
));
11238 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11240 newval
|= md_chars_to_number (buf
+2, THUMB_SIZE
);
11242 /* FUTURE: Implement analogue of negate_data_op for T32. */
11243 if (fixP
->fx_r_type
== BFD_RELOC_ARM_T32_IMMEDIATE
)
11244 newimm
= encode_thumb32_immediate (value
);
11247 /* 12 bit immediate for addw/subw. */
11251 newval
^= 0x00a00000;
11254 newimm
= (unsigned int) FAIL
;
11259 if (newimm
== (unsigned int)FAIL
)
11261 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11262 _("invalid constant (%lx) after fixup"),
11263 (unsigned long) value
);
11267 newval
|= (newimm
& 0x800) << 15;
11268 newval
|= (newimm
& 0x700) << 4;
11269 newval
|= (newimm
& 0x0ff);
11271 md_number_to_chars (buf
, (valueT
) ((newval
>> 16) & 0xffff), THUMB_SIZE
);
11272 md_number_to_chars (buf
+2, (valueT
) (newval
& 0xffff), THUMB_SIZE
);
11275 case BFD_RELOC_ARM_SMC
:
11276 if (((unsigned long) value
) > 0xffff)
11277 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11278 _("invalid smc expression"));
11279 newval
= md_chars_to_number (buf
, INSN_SIZE
);
11280 newval
|= (value
& 0xf) | ((value
& 0xfff0) << 4);
11281 md_number_to_chars (buf
, newval
, INSN_SIZE
);
11284 case BFD_RELOC_ARM_SWI
:
11285 if (fixP
->tc_fix_data
!= 0)
11287 if (((unsigned long) value
) > 0xff)
11288 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11289 _("invalid swi expression"));
11290 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11292 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11296 if (((unsigned long) value
) > 0x00ffffff)
11297 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11298 _("invalid swi expression"));
11299 newval
= md_chars_to_number (buf
, INSN_SIZE
);
11301 md_number_to_chars (buf
, newval
, INSN_SIZE
);
11305 case BFD_RELOC_ARM_MULTI
:
11306 if (((unsigned long) value
) > 0xffff)
11307 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11308 _("invalid expression in load/store multiple"));
11309 newval
= value
| md_chars_to_number (buf
, INSN_SIZE
);
11310 md_number_to_chars (buf
, newval
, INSN_SIZE
);
11313 case BFD_RELOC_ARM_PCREL_BRANCH
:
11315 case BFD_RELOC_ARM_PLT32
:
11318 /* We are going to store value (shifted right by two) in the
11319 instruction, in a 24 bit, signed field. Bits 0 and 1 must be
11320 clear, and bits 26 through 32 either all clear or all set. */
11321 if (value
& 0x00000003)
11322 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11323 _("misaligned branch destination"));
11324 if ((value
& (offsetT
)0xfe000000) != (offsetT
)0
11325 && (value
& (offsetT
)0xfe000000) != (offsetT
)0xfe000000)
11326 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11327 _("branch out of range"));
11329 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11331 newval
= md_chars_to_number (buf
, INSN_SIZE
);
11332 newval
|= (value
>> 2) & 0x00ffffff;
11333 md_number_to_chars (buf
, newval
, INSN_SIZE
);
11337 case BFD_RELOC_ARM_PCREL_BLX
:
11338 /* BLX allows bit 1 to be set in the branch destination, since
11339 it targets a Thumb instruction which is only required to be
11340 aligned modulo 2. Other constraints are as for B/BL. */
11341 if (value
& 0x00000001)
11342 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11343 _("misaligned BLX destination"));
11344 if ((value
& (offsetT
)0xfe000000) != (offsetT
)0
11345 && (value
& (offsetT
)0xfe000000) != (offsetT
)0xfe000000)
11346 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11347 _("branch out of range"));
11349 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11352 hbit
= (value
>> 1) & 1;
11353 value
= (value
>> 2) & 0x00ffffff;
11355 newval
= md_chars_to_number (buf
, INSN_SIZE
);
11356 newval
|= value
| hbit
<< 24;
11357 md_number_to_chars (buf
, newval
, INSN_SIZE
);
11361 case BFD_RELOC_THUMB_PCREL_BRANCH7
: /* CZB */
11362 /* CZB can only branch forward. */
11364 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11365 _("branch out of range"));
11367 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11369 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11370 newval
|= ((value
& 0x2e) << 2) | ((value
& 0x40) << 3);
11371 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11375 case BFD_RELOC_THUMB_PCREL_BRANCH9
: /* Conditional branch. */
11376 if ((value
& ~0xff) && ((value
& ~0xff) != ~0xff))
11377 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11378 _("branch out of range"));
11380 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11382 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11383 newval
|= (value
& 0x1ff) >> 1;
11384 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11388 case BFD_RELOC_THUMB_PCREL_BRANCH12
: /* Unconditional branch. */
11389 if ((value
& ~0x7ff) && ((value
& ~0x7ff) != ~0x7ff))
11390 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11391 _("branch out of range"));
11393 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11395 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11396 newval
|= (value
& 0xfff) >> 1;
11397 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11401 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
11402 if ((value
& ~0x1fffff) && ((value
& ~0x1fffff) != ~0x1fffff))
11403 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11404 _("conditional branch out of range"));
11406 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11409 addressT S
, J1
, J2
, lo
, hi
;
11411 S
= (value
& 0x00100000) >> 20;
11412 J2
= (value
& 0x00080000) >> 19;
11413 J1
= (value
& 0x00040000) >> 18;
11414 hi
= (value
& 0x0003f000) >> 12;
11415 lo
= (value
& 0x00000ffe) >> 1;
11417 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11418 newval2
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
11419 newval
|= (S
<< 10) | hi
;
11420 newval2
|= (J1
<< 13) | (J2
<< 11) | lo
;
11421 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11422 md_number_to_chars (buf
+ THUMB_SIZE
, newval2
, THUMB_SIZE
);
11426 case BFD_RELOC_THUMB_PCREL_BLX
:
11427 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
11428 if ((value
& ~0x3fffff) && ((value
& ~0x3fffff) != ~0x3fffff))
11429 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11430 _("branch out of range"));
11432 if (fixP
->fx_r_type
== BFD_RELOC_THUMB_PCREL_BLX
)
11433 /* For a BLX instruction, make sure that the relocation is rounded up
11434 to a word boundary. This follows the semantics of the instruction
11435 which specifies that bit 1 of the target address will come from bit
11436 1 of the base address. */
11437 value
= (value
+ 1) & ~ 1;
11439 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11443 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11444 newval2
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
11445 newval
|= (value
& 0x7fffff) >> 12;
11446 newval2
|= (value
& 0xfff) >> 1;
11447 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11448 md_number_to_chars (buf
+ THUMB_SIZE
, newval2
, THUMB_SIZE
);
11452 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
11453 if ((value
& ~0x1ffffff) && ((value
& ~0x1ffffff) != ~0x1ffffff))
11454 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11455 _("branch out of range"));
11457 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11460 addressT S
, I1
, I2
, lo
, hi
;
11462 S
= (value
& 0x01000000) >> 24;
11463 I1
= (value
& 0x00800000) >> 23;
11464 I2
= (value
& 0x00400000) >> 22;
11465 hi
= (value
& 0x003ff000) >> 12;
11466 lo
= (value
& 0x00000ffe) >> 1;
11471 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11472 newval2
= md_chars_to_number (buf
+ THUMB_SIZE
, THUMB_SIZE
);
11473 newval
|= (S
<< 10) | hi
;
11474 newval2
|= (I1
<< 13) | (I2
<< 11) | lo
;
11475 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11476 md_number_to_chars (buf
+ THUMB_SIZE
, newval2
, THUMB_SIZE
);
11481 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11482 md_number_to_chars (buf
, value
, 1);
11486 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11487 md_number_to_chars (buf
, value
, 2);
11491 case BFD_RELOC_ARM_TLS_GD32
:
11492 case BFD_RELOC_ARM_TLS_LE32
:
11493 case BFD_RELOC_ARM_TLS_IE32
:
11494 case BFD_RELOC_ARM_TLS_LDM32
:
11495 case BFD_RELOC_ARM_TLS_LDO32
:
11496 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
11499 case BFD_RELOC_ARM_GOT32
:
11500 case BFD_RELOC_ARM_GOTOFF
:
11501 case BFD_RELOC_ARM_TARGET2
:
11502 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11503 md_number_to_chars (buf
, 0, 4);
11507 case BFD_RELOC_RVA
:
11509 case BFD_RELOC_ARM_TARGET1
:
11510 case BFD_RELOC_ARM_ROSEGREL32
:
11511 case BFD_RELOC_ARM_SBREL32
:
11512 case BFD_RELOC_32_PCREL
:
11513 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11514 md_number_to_chars (buf
, value
, 4);
11518 case BFD_RELOC_ARM_PREL31
:
11519 if (fixP
->fx_done
|| !seg
->use_rela_p
)
11521 newval
= md_chars_to_number (buf
, 4) & 0x80000000;
11522 if ((value
^ (value
>> 1)) & 0x40000000)
11524 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11525 _("rel31 relocation overflow"));
11527 newval
|= value
& 0x7fffffff;
11528 md_number_to_chars (buf
, newval
, 4);
11533 case BFD_RELOC_ARM_CP_OFF_IMM
:
11534 case BFD_RELOC_ARM_T32_CP_OFF_IMM
:
11535 if (value
< -1023 || value
> 1023 || (value
& 3))
11536 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11537 _("co-processor offset out of range"));
11542 if (fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM
11543 || fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM_S2
)
11544 newval
= md_chars_to_number (buf
, INSN_SIZE
);
11546 newval
= get_thumb32_insn (buf
);
11547 newval
&= 0xff7fff00;
11548 newval
|= (value
>> 2) | (sign
? INDEX_UP
: 0);
11550 newval
&= ~WRITE_BACK
;
11551 if (fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM
11552 || fixP
->fx_r_type
== BFD_RELOC_ARM_CP_OFF_IMM_S2
)
11553 md_number_to_chars (buf
, newval
, INSN_SIZE
);
11555 put_thumb32_insn (buf
, newval
);
11558 case BFD_RELOC_ARM_CP_OFF_IMM_S2
:
11559 case BFD_RELOC_ARM_T32_CP_OFF_IMM_S2
:
11560 if (value
< -255 || value
> 255)
11561 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11562 _("co-processor offset out of range"));
11563 goto cp_off_common
;
11565 case BFD_RELOC_ARM_THUMB_OFFSET
:
11566 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11567 /* Exactly what ranges, and where the offset is inserted depends
11568 on the type of instruction, we can establish this from the
11570 switch (newval
>> 12)
11572 case 4: /* PC load. */
11573 /* Thumb PC loads are somewhat odd, bit 1 of the PC is
11574 forced to zero for these loads; md_pcrel_from has already
11575 compensated for this. */
11577 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11578 _("invalid offset, target not word aligned (0x%08lX)"),
11579 (((unsigned int) fixP
->fx_frag
->fr_address
11580 + (unsigned int) fixP
->fx_where
) & ~3) + value
);
11582 if (value
& ~0x3fc)
11583 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11584 _("invalid offset, value too big (0x%08lX)"),
11587 newval
|= value
>> 2;
11590 case 9: /* SP load/store. */
11591 if (value
& ~0x3fc)
11592 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11593 _("invalid offset, value too big (0x%08lX)"),
11595 newval
|= value
>> 2;
11598 case 6: /* Word load/store. */
11600 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11601 _("invalid offset, value too big (0x%08lX)"),
11603 newval
|= value
<< 4; /* 6 - 2. */
11606 case 7: /* Byte load/store. */
11608 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11609 _("invalid offset, value too big (0x%08lX)"),
11611 newval
|= value
<< 6;
11614 case 8: /* Halfword load/store. */
11616 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11617 _("invalid offset, value too big (0x%08lX)"),
11619 newval
|= value
<< 5; /* 6 - 1. */
11623 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11624 "Unable to process relocation for thumb opcode: %lx",
11625 (unsigned long) newval
);
11628 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11631 case BFD_RELOC_ARM_THUMB_ADD
:
11632 /* This is a complicated relocation, since we use it for all of
11633 the following immediate relocations:
11637 9bit ADD/SUB SP word-aligned
11638 10bit ADD PC/SP word-aligned
11640 The type of instruction being processed is encoded in the
11647 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11649 int rd
= (newval
>> 4) & 0xf;
11650 int rs
= newval
& 0xf;
11651 int subtract
= !!(newval
& 0x8000);
11653 /* Check for HI regs, only very restricted cases allowed:
11654 Adjusting SP, and using PC or SP to get an address. */
11655 if ((rd
> 7 && (rd
!= REG_SP
|| rs
!= REG_SP
))
11656 || (rs
> 7 && rs
!= REG_SP
&& rs
!= REG_PC
))
11657 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11658 _("invalid Hi register with immediate"));
11660 /* If value is negative, choose the opposite instruction. */
11664 subtract
= !subtract
;
11666 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11667 _("immediate value out of range"));
11672 if (value
& ~0x1fc)
11673 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11674 _("invalid immediate for stack address calculation"));
11675 newval
= subtract
? T_OPCODE_SUB_ST
: T_OPCODE_ADD_ST
;
11676 newval
|= value
>> 2;
11678 else if (rs
== REG_PC
|| rs
== REG_SP
)
11680 if (subtract
|| value
& ~0x3fc)
11681 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11682 _("invalid immediate for address calculation (value = 0x%08lX)"),
11683 (unsigned long) value
);
11684 newval
= (rs
== REG_PC
? T_OPCODE_ADD_PC
: T_OPCODE_ADD_SP
);
11686 newval
|= value
>> 2;
11691 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11692 _("immediate value out of range"));
11693 newval
= subtract
? T_OPCODE_SUB_I8
: T_OPCODE_ADD_I8
;
11694 newval
|= (rd
<< 8) | value
;
11699 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11700 _("immediate value out of range"));
11701 newval
= subtract
? T_OPCODE_SUB_I3
: T_OPCODE_ADD_I3
;
11702 newval
|= rd
| (rs
<< 3) | (value
<< 6);
11705 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11708 case BFD_RELOC_ARM_THUMB_IMM
:
11709 newval
= md_chars_to_number (buf
, THUMB_SIZE
);
11710 if (value
< 0 || value
> 255)
11711 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11712 _("invalid immediate: %ld is too large"),
11715 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11718 case BFD_RELOC_ARM_THUMB_SHIFT
:
11719 /* 5bit shift value (0..32). LSL cannot take 32. */
11720 newval
= md_chars_to_number (buf
, THUMB_SIZE
) & 0xf83f;
11721 temp
= newval
& 0xf800;
11722 if (value
< 0 || value
> 32 || (value
== 32 && temp
== T_OPCODE_LSL_I
))
11723 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11724 _("invalid shift value: %ld"), (long) value
);
11725 /* Shifts of zero must be encoded as LSL. */
11727 newval
= (newval
& 0x003f) | T_OPCODE_LSL_I
;
11728 /* Shifts of 32 are encoded as zero. */
11729 else if (value
== 32)
11731 newval
|= value
<< 6;
11732 md_number_to_chars (buf
, newval
, THUMB_SIZE
);
11735 case BFD_RELOC_VTABLE_INHERIT
:
11736 case BFD_RELOC_VTABLE_ENTRY
:
11740 case BFD_RELOC_UNUSED
:
11742 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
11743 _("bad relocation fixup type (%d)"), fixP
->fx_r_type
);
11747 /* Translate internal representation of relocation info to BFD target
11751 tc_gen_reloc (asection
* section ATTRIBUTE_UNUSED
,
11755 bfd_reloc_code_real_type code
;
11757 reloc
= xmalloc (sizeof (arelent
));
11759 reloc
->sym_ptr_ptr
= xmalloc (sizeof (asymbol
*));
11760 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
11761 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
11763 if (fixp
->fx_pcrel
)
11764 fixp
->fx_offset
= reloc
->address
;
11765 reloc
->addend
= fixp
->fx_offset
;
11767 switch (fixp
->fx_r_type
)
11770 if (fixp
->fx_pcrel
)
11772 code
= BFD_RELOC_8_PCREL
;
11777 if (fixp
->fx_pcrel
)
11779 code
= BFD_RELOC_16_PCREL
;
11784 if (fixp
->fx_pcrel
)
11786 code
= BFD_RELOC_32_PCREL
;
11790 case BFD_RELOC_NONE
:
11791 case BFD_RELOC_ARM_PCREL_BRANCH
:
11792 case BFD_RELOC_ARM_PCREL_BLX
:
11793 case BFD_RELOC_RVA
:
11794 case BFD_RELOC_THUMB_PCREL_BRANCH7
:
11795 case BFD_RELOC_THUMB_PCREL_BRANCH9
:
11796 case BFD_RELOC_THUMB_PCREL_BRANCH12
:
11797 case BFD_RELOC_THUMB_PCREL_BRANCH20
:
11798 case BFD_RELOC_THUMB_PCREL_BRANCH23
:
11799 case BFD_RELOC_THUMB_PCREL_BRANCH25
:
11800 case BFD_RELOC_THUMB_PCREL_BLX
:
11801 case BFD_RELOC_VTABLE_ENTRY
:
11802 case BFD_RELOC_VTABLE_INHERIT
:
11803 code
= fixp
->fx_r_type
;
11806 case BFD_RELOC_ARM_LITERAL
:
11807 case BFD_RELOC_ARM_HWLITERAL
:
11808 /* If this is called then the a literal has
11809 been referenced across a section boundary. */
11810 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
11811 _("literal referenced across section boundary"));
11815 case BFD_RELOC_ARM_GOT32
:
11816 case BFD_RELOC_ARM_GOTOFF
:
11817 case BFD_RELOC_ARM_PLT32
:
11818 case BFD_RELOC_ARM_TARGET1
:
11819 case BFD_RELOC_ARM_ROSEGREL32
:
11820 case BFD_RELOC_ARM_SBREL32
:
11821 case BFD_RELOC_ARM_PREL31
:
11822 case BFD_RELOC_ARM_TARGET2
:
11823 case BFD_RELOC_ARM_TLS_LE32
:
11824 case BFD_RELOC_ARM_TLS_LDO32
:
11825 code
= fixp
->fx_r_type
;
11828 case BFD_RELOC_ARM_TLS_GD32
:
11829 case BFD_RELOC_ARM_TLS_IE32
:
11830 case BFD_RELOC_ARM_TLS_LDM32
:
11831 /* BFD will include the symbol's address in the addend.
11832 But we don't want that, so subtract it out again here. */
11833 if (!S_IS_COMMON (fixp
->fx_addsy
))
11834 reloc
->addend
-= (*reloc
->sym_ptr_ptr
)->value
;
11835 code
= fixp
->fx_r_type
;
11839 case BFD_RELOC_ARM_IMMEDIATE
:
11840 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
11841 _("internal relocation (type: IMMEDIATE) not fixed up"));
11844 case BFD_RELOC_ARM_ADRL_IMMEDIATE
:
11845 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
11846 _("ADRL used for a symbol not defined in the same file"));
11849 case BFD_RELOC_ARM_OFFSET_IMM
:
11850 if (fixp
->fx_addsy
!= NULL
11851 && !S_IS_DEFINED (fixp
->fx_addsy
)
11852 && S_IS_LOCAL (fixp
->fx_addsy
))
11854 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
11855 _("undefined local label `%s'"),
11856 S_GET_NAME (fixp
->fx_addsy
));
11860 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
11861 _("internal_relocation (type: OFFSET_IMM) not fixed up"));
11868 switch (fixp
->fx_r_type
)
11870 case BFD_RELOC_NONE
: type
= "NONE"; break;
11871 case BFD_RELOC_ARM_OFFSET_IMM8
: type
= "OFFSET_IMM8"; break;
11872 case BFD_RELOC_ARM_SHIFT_IMM
: type
= "SHIFT_IMM"; break;
11873 case BFD_RELOC_ARM_SMC
: type
= "SMC"; break;
11874 case BFD_RELOC_ARM_SWI
: type
= "SWI"; break;
11875 case BFD_RELOC_ARM_MULTI
: type
= "MULTI"; break;
11876 case BFD_RELOC_ARM_CP_OFF_IMM
: type
= "CP_OFF_IMM"; break;
11877 case BFD_RELOC_ARM_T32_CP_OFF_IMM
: type
= "T32_CP_OFF_IMM"; break;
11878 case BFD_RELOC_ARM_THUMB_ADD
: type
= "THUMB_ADD"; break;
11879 case BFD_RELOC_ARM_THUMB_SHIFT
: type
= "THUMB_SHIFT"; break;
11880 case BFD_RELOC_ARM_THUMB_IMM
: type
= "THUMB_IMM"; break;
11881 case BFD_RELOC_ARM_THUMB_OFFSET
: type
= "THUMB_OFFSET"; break;
11882 default: type
= _("<unknown>"); break;
11884 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
11885 _("cannot represent %s relocation in this object file format"),
11892 if ((code
== BFD_RELOC_32_PCREL
|| code
== BFD_RELOC_32
)
11894 && fixp
->fx_addsy
== GOT_symbol
)
11896 code
= BFD_RELOC_ARM_GOTPC
;
11897 reloc
->addend
= fixp
->fx_offset
= reloc
->address
;
11901 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
11903 if (reloc
->howto
== NULL
)
11905 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
11906 _("cannot represent %s relocation in this object file format"),
11907 bfd_get_reloc_code_name (code
));
11911 /* HACK: Since arm ELF uses Rel instead of Rela, encode the
11912 vtable entry to be used in the relocation's section offset. */
11913 if (fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
11914 reloc
->address
= fixp
->fx_offset
;
11919 /* This fix_new is called by cons via TC_CONS_FIX_NEW. */
11922 cons_fix_new_arm (fragS
* frag
,
11927 bfd_reloc_code_real_type type
;
11931 FIXME: @@ Should look at CPU word size. */
11935 type
= BFD_RELOC_8
;
11938 type
= BFD_RELOC_16
;
11942 type
= BFD_RELOC_32
;
11945 type
= BFD_RELOC_64
;
11949 fix_new_exp (frag
, where
, (int) size
, exp
, pcrel
, type
);
11952 #if defined OBJ_COFF || defined OBJ_ELF
11954 arm_validate_fix (fixS
* fixP
)
11956 /* If the destination of the branch is a defined symbol which does not have
11957 the THUMB_FUNC attribute, then we must be calling a function which has
11958 the (interfacearm) attribute. We look for the Thumb entry point to that
11959 function and change the branch to refer to that function instead. */
11960 if (fixP
->fx_r_type
== BFD_RELOC_THUMB_PCREL_BRANCH23
11961 && fixP
->fx_addsy
!= NULL
11962 && S_IS_DEFINED (fixP
->fx_addsy
)
11963 && ! THUMB_IS_FUNC (fixP
->fx_addsy
))
11965 fixP
->fx_addsy
= find_real_start (fixP
->fx_addsy
);
11971 arm_force_relocation (struct fix
* fixp
)
11973 #if defined (OBJ_COFF) && defined (TE_PE)
11974 if (fixp
->fx_r_type
== BFD_RELOC_RVA
)
11978 /* Resolve these relocations even if the symbol is extern or weak. */
11979 if (fixp
->fx_r_type
== BFD_RELOC_ARM_IMMEDIATE
11980 || fixp
->fx_r_type
== BFD_RELOC_ARM_OFFSET_IMM
11981 || fixp
->fx_r_type
== BFD_RELOC_ARM_ADRL_IMMEDIATE
11982 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_IMMEDIATE
11983 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_IMM12
11984 || fixp
->fx_r_type
== BFD_RELOC_ARM_T32_ADD_PC12
)
11987 return generic_force_reloc (fixp
);
11991 /* This is a little hack to help the gas/arm/adrl.s test. It prevents
11992 local labels from being added to the output symbol table when they
11993 are used with the ADRL pseudo op. The ADRL relocation should always
11994 be resolved before the binbary is emitted, so it is safe to say that
11995 it is adjustable. */
11998 arm_fix_adjustable (fixS
* fixP
)
12000 if (fixP
->fx_r_type
== BFD_RELOC_ARM_ADRL_IMMEDIATE
)
12007 /* Relocations against Thumb function names must be left unadjusted,
12008 so that the linker can use this information to correctly set the
12009 bottom bit of their addresses. The MIPS version of this function
12010 also prevents relocations that are mips-16 specific, but I do not
12011 know why it does this.
12014 There is one other problem that ought to be addressed here, but
12015 which currently is not: Taking the address of a label (rather
12016 than a function) and then later jumping to that address. Such
12017 addresses also ought to have their bottom bit set (assuming that
12018 they reside in Thumb code), but at the moment they will not. */
12021 arm_fix_adjustable (fixS
* fixP
)
12023 if (fixP
->fx_addsy
== NULL
)
12026 if (THUMB_IS_FUNC (fixP
->fx_addsy
)
12027 && fixP
->fx_subsy
== NULL
)
12030 /* We need the symbol name for the VTABLE entries. */
12031 if ( fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
12032 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
12035 /* Don't allow symbols to be discarded on GOT related relocs. */
12036 if (fixP
->fx_r_type
== BFD_RELOC_ARM_PLT32
12037 || fixP
->fx_r_type
== BFD_RELOC_ARM_GOT32
12038 || fixP
->fx_r_type
== BFD_RELOC_ARM_GOTOFF
12039 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_GD32
12040 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_LE32
12041 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_IE32
12042 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_LDM32
12043 || fixP
->fx_r_type
== BFD_RELOC_ARM_TLS_LDO32
12044 || fixP
->fx_r_type
== BFD_RELOC_ARM_TARGET2
)
12051 elf32_arm_target_format (void)
12054 return (target_big_endian
12055 ? "elf32-bigarm-symbian"
12056 : "elf32-littlearm-symbian");
12057 #elif defined (TE_VXWORKS)
12058 return (target_big_endian
12059 ? "elf32-bigarm-vxworks"
12060 : "elf32-littlearm-vxworks");
12062 if (target_big_endian
)
12063 return "elf32-bigarm";
12065 return "elf32-littlearm";
12070 armelf_frob_symbol (symbolS
* symp
,
12073 elf_frob_symbol (symp
, puntp
);
12077 /* MD interface: Finalization. */
12079 /* A good place to do this, although this was probably not intended
12080 for this kind of use. We need to dump the literal pool before
12081 references are made to a null symbol pointer. */
12086 literal_pool
* pool
;
12088 for (pool
= list_of_pools
; pool
; pool
= pool
->next
)
12090 /* Put it at the end of the relevent section. */
12091 subseg_set (pool
->section
, pool
->sub_section
);
12093 arm_elf_change_section ();
12099 /* Adjust the symbol table. This marks Thumb symbols as distinct from
12103 arm_adjust_symtab (void)
12108 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
12110 if (ARM_IS_THUMB (sym
))
12112 if (THUMB_IS_FUNC (sym
))
12114 /* Mark the symbol as a Thumb function. */
12115 if ( S_GET_STORAGE_CLASS (sym
) == C_STAT
12116 || S_GET_STORAGE_CLASS (sym
) == C_LABEL
) /* This can happen! */
12117 S_SET_STORAGE_CLASS (sym
, C_THUMBSTATFUNC
);
12119 else if (S_GET_STORAGE_CLASS (sym
) == C_EXT
)
12120 S_SET_STORAGE_CLASS (sym
, C_THUMBEXTFUNC
);
12122 as_bad (_("%s: unexpected function type: %d"),
12123 S_GET_NAME (sym
), S_GET_STORAGE_CLASS (sym
));
12125 else switch (S_GET_STORAGE_CLASS (sym
))
12128 S_SET_STORAGE_CLASS (sym
, C_THUMBEXT
);
12131 S_SET_STORAGE_CLASS (sym
, C_THUMBSTAT
);
12134 S_SET_STORAGE_CLASS (sym
, C_THUMBLABEL
);
12142 if (ARM_IS_INTERWORK (sym
))
12143 coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_flags
= 0xFF;
12150 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
12152 if (ARM_IS_THUMB (sym
))
12154 elf_symbol_type
* elf_sym
;
12156 elf_sym
= elf_symbol (symbol_get_bfdsym (sym
));
12157 bind
= ELF_ST_BIND (elf_sym
->internal_elf_sym
.st_info
);
12159 if (! bfd_is_arm_mapping_symbol_name (elf_sym
->symbol
.name
))
12161 /* If it's a .thumb_func, declare it as so,
12162 otherwise tag label as .code 16. */
12163 if (THUMB_IS_FUNC (sym
))
12164 elf_sym
->internal_elf_sym
.st_info
=
12165 ELF_ST_INFO (bind
, STT_ARM_TFUNC
);
12167 elf_sym
->internal_elf_sym
.st_info
=
12168 ELF_ST_INFO (bind
, STT_ARM_16BIT
);
12175 /* MD interface: Initialization. */
12178 set_constant_flonums (void)
12182 for (i
= 0; i
< NUM_FLOAT_VALS
; i
++)
12183 if (atof_ieee ((char *) fp_const
[i
], 'x', fp_values
[i
]) == NULL
)
12193 if ( (arm_ops_hsh
= hash_new ()) == NULL
12194 || (arm_cond_hsh
= hash_new ()) == NULL
12195 || (arm_shift_hsh
= hash_new ()) == NULL
12196 || (arm_psr_hsh
= hash_new ()) == NULL
12197 || (arm_reg_hsh
= hash_new ()) == NULL
12198 || (arm_reloc_hsh
= hash_new ()) == NULL
)
12199 as_fatal (_("virtual memory exhausted"));
12201 for (i
= 0; i
< sizeof (insns
) / sizeof (struct asm_opcode
); i
++)
12202 hash_insert (arm_ops_hsh
, insns
[i
].template, (PTR
) (insns
+ i
));
12203 for (i
= 0; i
< sizeof (conds
) / sizeof (struct asm_cond
); i
++)
12204 hash_insert (arm_cond_hsh
, conds
[i
].template, (PTR
) (conds
+ i
));
12205 for (i
= 0; i
< sizeof (shift_names
) / sizeof (struct asm_shift_name
); i
++)
12206 hash_insert (arm_shift_hsh
, shift_names
[i
].name
, (PTR
) (shift_names
+ i
));
12207 for (i
= 0; i
< sizeof (psrs
) / sizeof (struct asm_psr
); i
++)
12208 hash_insert (arm_psr_hsh
, psrs
[i
].template, (PTR
) (psrs
+ i
));
12209 for (i
= 0; i
< sizeof (reg_names
) / sizeof (struct reg_entry
); i
++)
12210 hash_insert (arm_reg_hsh
, reg_names
[i
].name
, (PTR
) (reg_names
+ i
));
12212 for (i
= 0; i
< sizeof (reloc_names
) / sizeof (struct reloc_entry
); i
++)
12213 hash_insert (arm_reloc_hsh
, reloc_names
[i
].name
, (PTR
) (reloc_names
+ i
));
12216 set_constant_flonums ();
12218 /* Set the cpu variant based on the command-line options. We prefer
12219 -mcpu= over -march= if both are set (as for GCC); and we prefer
12220 -mfpu= over any other way of setting the floating point unit.
12221 Use of legacy options with new options are faulted. */
12222 if (legacy_cpu
!= -1)
12224 if (mcpu_cpu_opt
!= -1 || march_cpu_opt
!= -1)
12225 as_bad (_("use of old and new-style options to set CPU type"));
12227 mcpu_cpu_opt
= legacy_cpu
;
12229 else if (mcpu_cpu_opt
== -1)
12230 mcpu_cpu_opt
= march_cpu_opt
;
12232 if (legacy_fpu
!= -1)
12234 if (mfpu_opt
!= -1)
12235 as_bad (_("use of old and new-style options to set FPU type"));
12237 mfpu_opt
= legacy_fpu
;
12239 else if (mfpu_opt
== -1)
12241 #if !(defined (TE_LINUX) || defined (TE_NetBSD) || defined (TE_VXWORKS))
12242 /* Some environments specify a default FPU. If they don't, infer it
12243 from the processor. */
12244 if (mcpu_fpu_opt
!= -1)
12245 mfpu_opt
= mcpu_fpu_opt
;
12247 mfpu_opt
= march_fpu_opt
;
12249 mfpu_opt
= FPU_DEFAULT
;
12253 if (mfpu_opt
== -1)
12255 if (mcpu_cpu_opt
== -1)
12256 mfpu_opt
= FPU_DEFAULT
;
12257 else if (mcpu_cpu_opt
& ARM_EXT_V5
)
12258 mfpu_opt
= FPU_ARCH_VFP_V2
;
12260 mfpu_opt
= FPU_ARCH_FPA
;
12263 if (mcpu_cpu_opt
== -1)
12264 mcpu_cpu_opt
= CPU_DEFAULT
;
12266 cpu_variant
= mcpu_cpu_opt
| mfpu_opt
;
12268 #if defined OBJ_COFF || defined OBJ_ELF
12270 unsigned int flags
= 0;
12272 #if defined OBJ_ELF
12273 flags
= meabi_flags
;
12275 switch (meabi_flags
)
12277 case EF_ARM_EABI_UNKNOWN
:
12279 /* Set the flags in the private structure. */
12280 if (uses_apcs_26
) flags
|= F_APCS26
;
12281 if (support_interwork
) flags
|= F_INTERWORK
;
12282 if (uses_apcs_float
) flags
|= F_APCS_FLOAT
;
12283 if (pic_code
) flags
|= F_PIC
;
12284 if ((cpu_variant
& FPU_ANY
) == FPU_NONE
12285 || (cpu_variant
& FPU_ANY
) == FPU_ARCH_VFP
) /* VFP layout only. */
12286 flags
|= F_SOFT_FLOAT
;
12288 switch (mfloat_abi_opt
)
12290 case ARM_FLOAT_ABI_SOFT
:
12291 case ARM_FLOAT_ABI_SOFTFP
:
12292 flags
|= F_SOFT_FLOAT
;
12295 case ARM_FLOAT_ABI_HARD
:
12296 if (flags
& F_SOFT_FLOAT
)
12297 as_bad (_("hard-float conflicts with specified fpu"));
12301 /* Using VFP conventions (even if soft-float). */
12302 if (cpu_variant
& FPU_VFP_EXT_NONE
)
12303 flags
|= F_VFP_FLOAT
;
12305 #if defined OBJ_ELF
12306 if (cpu_variant
& FPU_ARCH_MAVERICK
)
12307 flags
|= EF_ARM_MAVERICK_FLOAT
;
12310 case EF_ARM_EABI_VER4
:
12311 /* No additional flags to set. */
12318 bfd_set_private_flags (stdoutput
, flags
);
12320 /* We have run out flags in the COFF header to encode the
12321 status of ATPCS support, so instead we create a dummy,
12322 empty, debug section called .arm.atpcs. */
12327 sec
= bfd_make_section (stdoutput
, ".arm.atpcs");
12331 bfd_set_section_flags
12332 (stdoutput
, sec
, SEC_READONLY
| SEC_DEBUGGING
/* | SEC_HAS_CONTENTS */);
12333 bfd_set_section_size (stdoutput
, sec
, 0);
12334 bfd_set_section_contents (stdoutput
, sec
, NULL
, 0, 0);
12340 /* Record the CPU type as well. */
12341 switch (cpu_variant
& ARM_CPU_MASK
)
12344 mach
= bfd_mach_arm_2
;
12347 case ARM_3
: /* Also ARM_250. */
12348 mach
= bfd_mach_arm_2a
;
12351 case ARM_6
: /* Also ARM_7. */
12352 mach
= bfd_mach_arm_3
;
12356 mach
= bfd_mach_arm_unknown
;
12360 /* Catch special cases. */
12361 if (cpu_variant
& ARM_CEXT_IWMMXT
)
12362 mach
= bfd_mach_arm_iWMMXt
;
12363 else if (cpu_variant
& ARM_CEXT_XSCALE
)
12364 mach
= bfd_mach_arm_XScale
;
12365 else if (cpu_variant
& ARM_CEXT_MAVERICK
)
12366 mach
= bfd_mach_arm_ep9312
;
12367 else if (cpu_variant
& ARM_EXT_V5E
)
12368 mach
= bfd_mach_arm_5TE
;
12369 else if (cpu_variant
& ARM_EXT_V5
)
12371 if (cpu_variant
& ARM_EXT_V4T
)
12372 mach
= bfd_mach_arm_5T
;
12374 mach
= bfd_mach_arm_5
;
12376 else if (cpu_variant
& ARM_EXT_V4
)
12378 if (cpu_variant
& ARM_EXT_V4T
)
12379 mach
= bfd_mach_arm_4T
;
12381 mach
= bfd_mach_arm_4
;
12383 else if (cpu_variant
& ARM_EXT_V3M
)
12384 mach
= bfd_mach_arm_3M
;
12386 bfd_set_arch_mach (stdoutput
, TARGET_ARCH
, mach
);
12389 /* Command line processing. */
12392 Invocation line includes a switch not recognized by the base assembler.
12393 See if it's a processor-specific option.
12395 This routine is somewhat complicated by the need for backwards
12396 compatibility (since older releases of gcc can't be changed).
12397 The new options try to make the interface as compatible as
12400 New options (supported) are:
12402 -mcpu=<cpu name> Assemble for selected processor
12403 -march=<architecture name> Assemble for selected architecture
12404 -mfpu=<fpu architecture> Assemble for selected FPU.
12405 -EB/-mbig-endian Big-endian
12406 -EL/-mlittle-endian Little-endian
12407 -k Generate PIC code
12408 -mthumb Start in Thumb mode
12409 -mthumb-interwork Code supports ARM/Thumb interworking
12411 For now we will also provide support for:
12413 -mapcs-32 32-bit Program counter
12414 -mapcs-26 26-bit Program counter
12415 -macps-float Floats passed in FP registers
12416 -mapcs-reentrant Reentrant code
12418 (sometime these will probably be replaced with -mapcs=<list of options>
12419 and -matpcs=<list of options>)
12421 The remaining options are only supported for back-wards compatibility.
12422 Cpu variants, the arm part is optional:
12423 -m[arm]1 Currently not supported.
12424 -m[arm]2, -m[arm]250 Arm 2 and Arm 250 processor
12425 -m[arm]3 Arm 3 processor
12426 -m[arm]6[xx], Arm 6 processors
12427 -m[arm]7[xx][t][[d]m] Arm 7 processors
12428 -m[arm]8[10] Arm 8 processors
12429 -m[arm]9[20][tdmi] Arm 9 processors
12430 -mstrongarm[110[0]] StrongARM processors
12431 -mxscale XScale processors
12432 -m[arm]v[2345[t[e]]] Arm architectures
12433 -mall All (except the ARM1)
12435 -mfpa10, -mfpa11 FPA10 and 11 co-processor instructions
12436 -mfpe-old (No float load/store multiples)
12437 -mvfpxd VFP Single precision
12439 -mno-fpu Disable all floating point instructions
12441 The following CPU names are recognized:
12442 arm1, arm2, arm250, arm3, arm6, arm600, arm610, arm620,
12443 arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700,
12444 arm700i, arm710 arm710t, arm720, arm720t, arm740t, arm710c,
12445 arm7100, arm7500, arm7500fe, arm7tdmi, arm8, arm810, arm9,
12446 arm920, arm920t, arm940t, arm946, arm966, arm9tdmi, arm9e,
12447 arm10t arm10e, arm1020t, arm1020e, arm10200e,
12448 strongarm, strongarm110, strongarm1100, strongarm1110, xscale.
12452 const char * md_shortopts
= "m:k";
12454 #ifdef ARM_BI_ENDIAN
12455 #define OPTION_EB (OPTION_MD_BASE + 0)
12456 #define OPTION_EL (OPTION_MD_BASE + 1)
12458 #if TARGET_BYTES_BIG_ENDIAN
12459 #define OPTION_EB (OPTION_MD_BASE + 0)
12461 #define OPTION_EL (OPTION_MD_BASE + 1)
12465 struct option md_longopts
[] =
12468 {"EB", no_argument
, NULL
, OPTION_EB
},
12471 {"EL", no_argument
, NULL
, OPTION_EL
},
12473 {NULL
, no_argument
, NULL
, 0}
12476 size_t md_longopts_size
= sizeof (md_longopts
);
12478 struct arm_option_table
12480 char *option
; /* Option name to match. */
12481 char *help
; /* Help information. */
12482 int *var
; /* Variable to change. */
12483 int value
; /* What to change it to. */
12484 char *deprecated
; /* If non-null, print this message. */
12487 struct arm_option_table arm_opts
[] =
12489 {"k", N_("generate PIC code"), &pic_code
, 1, NULL
},
12490 {"mthumb", N_("assemble Thumb code"), &thumb_mode
, 1, NULL
},
12491 {"mthumb-interwork", N_("support ARM/Thumb interworking"),
12492 &support_interwork
, 1, NULL
},
12493 {"mapcs-32", N_("code uses 32-bit program counter"), &uses_apcs_26
, 0, NULL
},
12494 {"mapcs-26", N_("code uses 26-bit program counter"), &uses_apcs_26
, 1, NULL
},
12495 {"mapcs-float", N_("floating point args are in fp regs"), &uses_apcs_float
,
12497 {"mapcs-reentrant", N_("re-entrant code"), &pic_code
, 1, NULL
},
12498 {"matpcs", N_("code is ATPCS conformant"), &atpcs
, 1, NULL
},
12499 {"mbig-endian", N_("assemble for big-endian"), &target_big_endian
, 1, NULL
},
12500 {"mlittle-endian", N_("assemble for little-endian"), &target_big_endian
, 0,
12503 /* These are recognized by the assembler, but have no affect on code. */
12504 {"mapcs-frame", N_("use frame pointer"), NULL
, 0, NULL
},
12505 {"mapcs-stack-check", N_("use stack size checking"), NULL
, 0, NULL
},
12507 /* DON'T add any new processors to this list -- we want the whole list
12508 to go away... Add them to the processors table instead. */
12509 {"marm1", NULL
, &legacy_cpu
, ARM_ARCH_V1
, N_("use -mcpu=arm1")},
12510 {"m1", NULL
, &legacy_cpu
, ARM_ARCH_V1
, N_("use -mcpu=arm1")},
12511 {"marm2", NULL
, &legacy_cpu
, ARM_ARCH_V2
, N_("use -mcpu=arm2")},
12512 {"m2", NULL
, &legacy_cpu
, ARM_ARCH_V2
, N_("use -mcpu=arm2")},
12513 {"marm250", NULL
, &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm250")},
12514 {"m250", NULL
, &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm250")},
12515 {"marm3", NULL
, &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm3")},
12516 {"m3", NULL
, &legacy_cpu
, ARM_ARCH_V2S
, N_("use -mcpu=arm3")},
12517 {"marm6", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm6")},
12518 {"m6", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm6")},
12519 {"marm600", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm600")},
12520 {"m600", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm600")},
12521 {"marm610", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm610")},
12522 {"m610", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm610")},
12523 {"marm620", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm620")},
12524 {"m620", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm620")},
12525 {"marm7", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7")},
12526 {"m7", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7")},
12527 {"marm70", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm70")},
12528 {"m70", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm70")},
12529 {"marm700", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700")},
12530 {"m700", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700")},
12531 {"marm700i", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700i")},
12532 {"m700i", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm700i")},
12533 {"marm710", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710")},
12534 {"m710", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710")},
12535 {"marm710c", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710c")},
12536 {"m710c", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm710c")},
12537 {"marm720", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm720")},
12538 {"m720", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm720")},
12539 {"marm7d", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7d")},
12540 {"m7d", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7d")},
12541 {"marm7di", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7di")},
12542 {"m7di", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7di")},
12543 {"marm7m", NULL
, &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7m")},
12544 {"m7m", NULL
, &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7m")},
12545 {"marm7dm", NULL
, &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dm")},
12546 {"m7dm", NULL
, &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dm")},
12547 {"marm7dmi", NULL
, &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dmi")},
12548 {"m7dmi", NULL
, &legacy_cpu
, ARM_ARCH_V3M
, N_("use -mcpu=arm7dmi")},
12549 {"marm7100", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7100")},
12550 {"m7100", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7100")},
12551 {"marm7500", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500")},
12552 {"m7500", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500")},
12553 {"marm7500fe", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500fe")},
12554 {"m7500fe", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -mcpu=arm7500fe")},
12555 {"marm7t", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
12556 {"m7t", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
12557 {"marm7tdmi", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
12558 {"m7tdmi", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm7tdmi")},
12559 {"marm710t", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm710t")},
12560 {"m710t", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm710t")},
12561 {"marm720t", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm720t")},
12562 {"m720t", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm720t")},
12563 {"marm740t", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm740t")},
12564 {"m740t", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm740t")},
12565 {"marm8", NULL
, &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm8")},
12566 {"m8", NULL
, &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm8")},
12567 {"marm810", NULL
, &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm810")},
12568 {"m810", NULL
, &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=arm810")},
12569 {"marm9", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9")},
12570 {"m9", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9")},
12571 {"marm9tdmi", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9tdmi")},
12572 {"m9tdmi", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm9tdmi")},
12573 {"marm920", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm920")},
12574 {"m920", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm920")},
12575 {"marm940", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm940")},
12576 {"m940", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -mcpu=arm940")},
12577 {"mstrongarm", NULL
, &legacy_cpu
, ARM_ARCH_V4
, N_("use -mcpu=strongarm")},
12578 {"mstrongarm110", NULL
, &legacy_cpu
, ARM_ARCH_V4
,
12579 N_("use -mcpu=strongarm110")},
12580 {"mstrongarm1100", NULL
, &legacy_cpu
, ARM_ARCH_V4
,
12581 N_("use -mcpu=strongarm1100")},
12582 {"mstrongarm1110", NULL
, &legacy_cpu
, ARM_ARCH_V4
,
12583 N_("use -mcpu=strongarm1110")},
12584 {"mxscale", NULL
, &legacy_cpu
, ARM_ARCH_XSCALE
, N_("use -mcpu=xscale")},
12585 {"miwmmxt", NULL
, &legacy_cpu
, ARM_ARCH_IWMMXT
, N_("use -mcpu=iwmmxt")},
12586 {"mall", NULL
, &legacy_cpu
, ARM_ANY
, N_("use -mcpu=all")},
12588 /* Architecture variants -- don't add any more to this list either. */
12589 {"mv2", NULL
, &legacy_cpu
, ARM_ARCH_V2
, N_("use -march=armv2")},
12590 {"marmv2", NULL
, &legacy_cpu
, ARM_ARCH_V2
, N_("use -march=armv2")},
12591 {"mv2a", NULL
, &legacy_cpu
, ARM_ARCH_V2S
, N_("use -march=armv2a")},
12592 {"marmv2a", NULL
, &legacy_cpu
, ARM_ARCH_V2S
, N_("use -march=armv2a")},
12593 {"mv3", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -march=armv3")},
12594 {"marmv3", NULL
, &legacy_cpu
, ARM_ARCH_V3
, N_("use -march=armv3")},
12595 {"mv3m", NULL
, &legacy_cpu
, ARM_ARCH_V3M
, N_("use -march=armv3m")},
12596 {"marmv3m", NULL
, &legacy_cpu
, ARM_ARCH_V3M
, N_("use -march=armv3m")},
12597 {"mv4", NULL
, &legacy_cpu
, ARM_ARCH_V4
, N_("use -march=armv4")},
12598 {"marmv4", NULL
, &legacy_cpu
, ARM_ARCH_V4
, N_("use -march=armv4")},
12599 {"mv4t", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -march=armv4t")},
12600 {"marmv4t", NULL
, &legacy_cpu
, ARM_ARCH_V4T
, N_("use -march=armv4t")},
12601 {"mv5", NULL
, &legacy_cpu
, ARM_ARCH_V5
, N_("use -march=armv5")},
12602 {"marmv5", NULL
, &legacy_cpu
, ARM_ARCH_V5
, N_("use -march=armv5")},
12603 {"mv5t", NULL
, &legacy_cpu
, ARM_ARCH_V5T
, N_("use -march=armv5t")},
12604 {"marmv5t", NULL
, &legacy_cpu
, ARM_ARCH_V5T
, N_("use -march=armv5t")},
12605 {"mv5e", NULL
, &legacy_cpu
, ARM_ARCH_V5TE
, N_("use -march=armv5te")},
12606 {"marmv5e", NULL
, &legacy_cpu
, ARM_ARCH_V5TE
, N_("use -march=armv5te")},
12608 /* Floating point variants -- don't add any more to this list either. */
12609 {"mfpe-old", NULL
, &legacy_fpu
, FPU_ARCH_FPE
, N_("use -mfpu=fpe")},
12610 {"mfpa10", NULL
, &legacy_fpu
, FPU_ARCH_FPA
, N_("use -mfpu=fpa10")},
12611 {"mfpa11", NULL
, &legacy_fpu
, FPU_ARCH_FPA
, N_("use -mfpu=fpa11")},
12612 {"mno-fpu", NULL
, &legacy_fpu
, 0,
12613 N_("use either -mfpu=softfpa or -mfpu=softvfp")},
12615 {NULL
, NULL
, NULL
, 0, NULL
}
12618 struct arm_cpu_option_table
12622 /* For some CPUs we assume an FPU unless the user explicitly sets
12627 /* This list should, at a minimum, contain all the cpu names
12628 recognized by GCC. */
12629 static struct arm_cpu_option_table arm_cpus
[] =
12631 {"all", ARM_ANY
, FPU_ARCH_FPA
},
12632 {"arm1", ARM_ARCH_V1
, FPU_ARCH_FPA
},
12633 {"arm2", ARM_ARCH_V2
, FPU_ARCH_FPA
},
12634 {"arm250", ARM_ARCH_V2S
, FPU_ARCH_FPA
},
12635 {"arm3", ARM_ARCH_V2S
, FPU_ARCH_FPA
},
12636 {"arm6", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12637 {"arm60", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12638 {"arm600", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12639 {"arm610", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12640 {"arm620", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12641 {"arm7", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12642 {"arm7m", ARM_ARCH_V3M
, FPU_ARCH_FPA
},
12643 {"arm7d", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12644 {"arm7dm", ARM_ARCH_V3M
, FPU_ARCH_FPA
},
12645 {"arm7di", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12646 {"arm7dmi", ARM_ARCH_V3M
, FPU_ARCH_FPA
},
12647 {"arm70", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12648 {"arm700", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12649 {"arm700i", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12650 {"arm710", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12651 {"arm710t", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12652 {"arm720", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12653 {"arm720t", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12654 {"arm740t", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12655 {"arm710c", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12656 {"arm7100", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12657 {"arm7500", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12658 {"arm7500fe", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12659 {"arm7t", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12660 {"arm7tdmi", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12661 {"arm7tdmi-s", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12662 {"arm8", ARM_ARCH_V4
, FPU_ARCH_FPA
},
12663 {"arm810", ARM_ARCH_V4
, FPU_ARCH_FPA
},
12664 {"strongarm", ARM_ARCH_V4
, FPU_ARCH_FPA
},
12665 {"strongarm1", ARM_ARCH_V4
, FPU_ARCH_FPA
},
12666 {"strongarm110", ARM_ARCH_V4
, FPU_ARCH_FPA
},
12667 {"strongarm1100", ARM_ARCH_V4
, FPU_ARCH_FPA
},
12668 {"strongarm1110", ARM_ARCH_V4
, FPU_ARCH_FPA
},
12669 {"arm9", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12670 {"arm920", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12671 {"arm920t", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12672 {"arm922t", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12673 {"arm940t", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12674 {"arm9tdmi", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12675 /* For V5 or later processors we default to using VFP; but the user
12676 should really set the FPU type explicitly. */
12677 {"arm9e-r0", ARM_ARCH_V5TExP
, FPU_ARCH_VFP_V2
},
12678 {"arm9e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
},
12679 {"arm926ej", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
},
12680 {"arm926ejs", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
},
12681 {"arm926ej-s", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
},
12682 {"arm946e-r0", ARM_ARCH_V5TExP
, FPU_ARCH_VFP_V2
},
12683 {"arm946e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
},
12684 {"arm966e-r0", ARM_ARCH_V5TExP
, FPU_ARCH_VFP_V2
},
12685 {"arm966e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
},
12686 {"arm10t", ARM_ARCH_V5T
, FPU_ARCH_VFP_V1
},
12687 {"arm10e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
},
12688 {"arm1020", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
},
12689 {"arm1020t", ARM_ARCH_V5T
, FPU_ARCH_VFP_V1
},
12690 {"arm1020e", ARM_ARCH_V5TE
, FPU_ARCH_VFP_V2
},
12691 {"arm1026ejs", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
},
12692 {"arm1026ej-s", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP_V2
},
12693 {"arm1136js", ARM_ARCH_V6
, FPU_NONE
},
12694 {"arm1136j-s", ARM_ARCH_V6
, FPU_NONE
},
12695 {"arm1136jfs", ARM_ARCH_V6
, FPU_ARCH_VFP_V2
},
12696 {"arm1136jf-s", ARM_ARCH_V6
, FPU_ARCH_VFP_V2
},
12697 {"mpcore", ARM_ARCH_V6K
, FPU_ARCH_VFP_V2
},
12698 {"mpcorenovfp", ARM_ARCH_V6K
, FPU_NONE
},
12699 {"arm1176jz-s", ARM_ARCH_V6ZK
, FPU_NONE
},
12700 {"arm1176jzf-s", ARM_ARCH_V6ZK
, FPU_ARCH_VFP_V2
},
12701 /* ??? XSCALE is really an architecture. */
12702 {"xscale", ARM_ARCH_XSCALE
, FPU_ARCH_VFP_V2
},
12703 /* ??? iwmmxt is not a processor. */
12704 {"iwmmxt", ARM_ARCH_IWMMXT
, FPU_ARCH_VFP_V2
},
12705 {"i80200", ARM_ARCH_XSCALE
, FPU_ARCH_VFP_V2
},
12707 {"ep9312", ARM_ARCH_V4T
| ARM_CEXT_MAVERICK
, FPU_ARCH_MAVERICK
},
12711 struct arm_arch_option_table
12718 /* This list should, at a minimum, contain all the architecture names
12719 recognized by GCC. */
12720 static struct arm_arch_option_table arm_archs
[] =
12722 {"all", ARM_ANY
, FPU_ARCH_FPA
},
12723 {"armv1", ARM_ARCH_V1
, FPU_ARCH_FPA
},
12724 {"armv2", ARM_ARCH_V2
, FPU_ARCH_FPA
},
12725 {"armv2a", ARM_ARCH_V2S
, FPU_ARCH_FPA
},
12726 {"armv2s", ARM_ARCH_V2S
, FPU_ARCH_FPA
},
12727 {"armv3", ARM_ARCH_V3
, FPU_ARCH_FPA
},
12728 {"armv3m", ARM_ARCH_V3M
, FPU_ARCH_FPA
},
12729 {"armv4", ARM_ARCH_V4
, FPU_ARCH_FPA
},
12730 {"armv4xm", ARM_ARCH_V4xM
, FPU_ARCH_FPA
},
12731 {"armv4t", ARM_ARCH_V4T
, FPU_ARCH_FPA
},
12732 {"armv4txm", ARM_ARCH_V4TxM
, FPU_ARCH_FPA
},
12733 {"armv5", ARM_ARCH_V5
, FPU_ARCH_VFP
},
12734 {"armv5t", ARM_ARCH_V5T
, FPU_ARCH_VFP
},
12735 {"armv5txm", ARM_ARCH_V5TxM
, FPU_ARCH_VFP
},
12736 {"armv5te", ARM_ARCH_V5TE
, FPU_ARCH_VFP
},
12737 {"armv5texp", ARM_ARCH_V5TExP
, FPU_ARCH_VFP
},
12738 {"armv5tej", ARM_ARCH_V5TEJ
, FPU_ARCH_VFP
},
12739 {"armv6", ARM_ARCH_V6
, FPU_ARCH_VFP
},
12740 {"armv6j", ARM_ARCH_V6
, FPU_ARCH_VFP
},
12741 {"armv6k", ARM_ARCH_V6K
, FPU_ARCH_VFP
},
12742 {"armv6z", ARM_ARCH_V6Z
, FPU_ARCH_VFP
},
12743 {"armv6zk", ARM_ARCH_V6ZK
, FPU_ARCH_VFP
},
12744 {"armv6t2", ARM_ARCH_V6T2
, FPU_ARCH_VFP
},
12745 {"armv6kt2", ARM_ARCH_V6KT2
, FPU_ARCH_VFP
},
12746 {"armv6zt2", ARM_ARCH_V6ZT2
, FPU_ARCH_VFP
},
12747 {"armv6zkt2", ARM_ARCH_V6ZKT2
, FPU_ARCH_VFP
},
12748 {"xscale", ARM_ARCH_XSCALE
, FPU_ARCH_VFP
},
12749 {"iwmmxt", ARM_ARCH_IWMMXT
, FPU_ARCH_VFP
},
12753 /* ISA extensions in the co-processor space. */
12754 struct arm_option_value_table
12760 static struct arm_option_value_table arm_extensions
[] =
12762 {"maverick", ARM_CEXT_MAVERICK
},
12763 {"xscale", ARM_CEXT_XSCALE
},
12764 {"iwmmxt", ARM_CEXT_IWMMXT
},
12768 /* This list should, at a minimum, contain all the fpu names
12769 recognized by GCC. */
12770 static struct arm_option_value_table arm_fpus
[] =
12772 {"softfpa", FPU_NONE
},
12773 {"fpe", FPU_ARCH_FPE
},
12774 {"fpe2", FPU_ARCH_FPE
},
12775 {"fpe3", FPU_ARCH_FPA
}, /* Third release supports LFM/SFM. */
12776 {"fpa", FPU_ARCH_FPA
},
12777 {"fpa10", FPU_ARCH_FPA
},
12778 {"fpa11", FPU_ARCH_FPA
},
12779 {"arm7500fe", FPU_ARCH_FPA
},
12780 {"softvfp", FPU_ARCH_VFP
},
12781 {"softvfp+vfp", FPU_ARCH_VFP_V2
},
12782 {"vfp", FPU_ARCH_VFP_V2
},
12783 {"vfp9", FPU_ARCH_VFP_V2
},
12784 {"vfp10", FPU_ARCH_VFP_V2
},
12785 {"vfp10-r0", FPU_ARCH_VFP_V1
},
12786 {"vfpxd", FPU_ARCH_VFP_V1xD
},
12787 {"arm1020t", FPU_ARCH_VFP_V1
},
12788 {"arm1020e", FPU_ARCH_VFP_V2
},
12789 {"arm1136jfs", FPU_ARCH_VFP_V2
},
12790 {"arm1136jf-s", FPU_ARCH_VFP_V2
},
12791 {"maverick", FPU_ARCH_MAVERICK
},
12795 static struct arm_option_value_table arm_float_abis
[] =
12797 {"hard", ARM_FLOAT_ABI_HARD
},
12798 {"softfp", ARM_FLOAT_ABI_SOFTFP
},
12799 {"soft", ARM_FLOAT_ABI_SOFT
},
12804 /* We only know how to output GNU and ver 4 (AAELF) formats. */
12805 static struct arm_option_value_table arm_eabis
[] =
12807 {"gnu", EF_ARM_EABI_UNKNOWN
},
12808 {"4", EF_ARM_EABI_VER4
},
12813 struct arm_long_option_table
12815 char * option
; /* Substring to match. */
12816 char * help
; /* Help information. */
12817 int (* func
) (char * subopt
); /* Function to decode sub-option. */
12818 char * deprecated
; /* If non-null, print this message. */
12822 arm_parse_extension (char * str
, int * opt_p
)
12824 while (str
!= NULL
&& *str
!= 0)
12826 struct arm_option_value_table
* opt
;
12832 as_bad (_("invalid architectural extension"));
12837 ext
= strchr (str
, '+');
12840 optlen
= ext
- str
;
12842 optlen
= strlen (str
);
12846 as_bad (_("missing architectural extension"));
12850 for (opt
= arm_extensions
; opt
->name
!= NULL
; opt
++)
12851 if (strncmp (opt
->name
, str
, optlen
) == 0)
12853 *opt_p
|= opt
->value
;
12857 if (opt
->name
== NULL
)
12859 as_bad (_("unknown architectural extnsion `%s'"), str
);
12870 arm_parse_cpu (char * str
)
12872 struct arm_cpu_option_table
* opt
;
12873 char * ext
= strchr (str
, '+');
12877 optlen
= ext
- str
;
12879 optlen
= strlen (str
);
12883 as_bad (_("missing cpu name `%s'"), str
);
12887 for (opt
= arm_cpus
; opt
->name
!= NULL
; opt
++)
12888 if (strncmp (opt
->name
, str
, optlen
) == 0)
12890 mcpu_cpu_opt
= opt
->value
;
12891 mcpu_fpu_opt
= opt
->default_fpu
;
12894 return arm_parse_extension (ext
, &mcpu_cpu_opt
);
12899 as_bad (_("unknown cpu `%s'"), str
);
12904 arm_parse_arch (char * str
)
12906 struct arm_arch_option_table
*opt
;
12907 char *ext
= strchr (str
, '+');
12911 optlen
= ext
- str
;
12913 optlen
= strlen (str
);
12917 as_bad (_("missing architecture name `%s'"), str
);
12922 for (opt
= arm_archs
; opt
->name
!= NULL
; opt
++)
12923 if (streq (opt
->name
, str
))
12925 march_cpu_opt
= opt
->value
;
12926 march_fpu_opt
= opt
->default_fpu
;
12929 return arm_parse_extension (ext
, &march_cpu_opt
);
12934 as_bad (_("unknown architecture `%s'\n"), str
);
12939 arm_parse_fpu (char * str
)
12941 struct arm_option_value_table
* opt
;
12943 for (opt
= arm_fpus
; opt
->name
!= NULL
; opt
++)
12944 if (streq (opt
->name
, str
))
12946 mfpu_opt
= opt
->value
;
12950 as_bad (_("unknown floating point format `%s'\n"), str
);
12955 arm_parse_float_abi (char * str
)
12957 struct arm_option_value_table
* opt
;
12959 for (opt
= arm_float_abis
; opt
->name
!= NULL
; opt
++)
12960 if (streq (opt
->name
, str
))
12962 mfloat_abi_opt
= opt
->value
;
12966 as_bad (_("unknown floating point abi `%s'\n"), str
);
12972 arm_parse_eabi (char * str
)
12974 struct arm_option_value_table
*opt
;
12976 for (opt
= arm_eabis
; opt
->name
!= NULL
; opt
++)
12977 if (streq (opt
->name
, str
))
12979 meabi_flags
= opt
->value
;
12982 as_bad (_("unknown EABI `%s'\n"), str
);
12987 struct arm_long_option_table arm_long_opts
[] =
12989 {"mcpu=", N_("<cpu name>\t assemble for CPU <cpu name>"),
12990 arm_parse_cpu
, NULL
},
12991 {"march=", N_("<arch name>\t assemble for architecture <arch name>"),
12992 arm_parse_arch
, NULL
},
12993 {"mfpu=", N_("<fpu name>\t assemble for FPU architecture <fpu name>"),
12994 arm_parse_fpu
, NULL
},
12995 {"mfloat-abi=", N_("<abi>\t assemble for floating point ABI <abi>"),
12996 arm_parse_float_abi
, NULL
},
12998 {"meabi=", N_("<ver>\t assemble for eabi version <ver>"),
12999 arm_parse_eabi
, NULL
},
13001 {NULL
, NULL
, 0, NULL
}
13005 md_parse_option (int c
, char * arg
)
13007 struct arm_option_table
*opt
;
13008 struct arm_long_option_table
*lopt
;
13014 target_big_endian
= 1;
13020 target_big_endian
= 0;
13025 /* Listing option. Just ignore these, we don't support additional
13030 for (opt
= arm_opts
; opt
->option
!= NULL
; opt
++)
13032 if (c
== opt
->option
[0]
13033 && ((arg
== NULL
&& opt
->option
[1] == 0)
13034 || streq (arg
, opt
->option
+ 1)))
13036 #if WARN_DEPRECATED
13037 /* If the option is deprecated, tell the user. */
13038 if (opt
->deprecated
!= NULL
)
13039 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c
,
13040 arg
? arg
: "", _(opt
->deprecated
));
13043 if (opt
->var
!= NULL
)
13044 *opt
->var
= opt
->value
;
13050 for (lopt
= arm_long_opts
; lopt
->option
!= NULL
; lopt
++)
13052 /* These options are expected to have an argument. */
13053 if (c
== lopt
->option
[0]
13055 && strncmp (arg
, lopt
->option
+ 1,
13056 strlen (lopt
->option
+ 1)) == 0)
13058 #if WARN_DEPRECATED
13059 /* If the option is deprecated, tell the user. */
13060 if (lopt
->deprecated
!= NULL
)
13061 as_tsktsk (_("option `-%c%s' is deprecated: %s"), c
, arg
,
13062 _(lopt
->deprecated
));
13065 /* Call the sup-option parser. */
13066 return lopt
->func (arg
+ strlen (lopt
->option
) - 1);
13077 md_show_usage (FILE * fp
)
13079 struct arm_option_table
*opt
;
13080 struct arm_long_option_table
*lopt
;
13082 fprintf (fp
, _(" ARM-specific assembler options:\n"));
13084 for (opt
= arm_opts
; opt
->option
!= NULL
; opt
++)
13085 if (opt
->help
!= NULL
)
13086 fprintf (fp
, " -%-23s%s\n", opt
->option
, _(opt
->help
));
13088 for (lopt
= arm_long_opts
; lopt
->option
!= NULL
; lopt
++)
13089 if (lopt
->help
!= NULL
)
13090 fprintf (fp
, " -%s%s\n", lopt
->option
, _(lopt
->help
));
13094 -EB assemble code for a big-endian cpu\n"));
13099 -EL assemble code for a little-endian cpu\n"));