1 /* aarch64-opc.c -- AArch64 opcode support.
2 Copyright (C) 2009-2016 Free Software Foundation, Inc.
3 Contributed by ARM Ltd.
5 This file is part of the GNU opcodes library.
7 This library is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 It is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; see the file COPYING3. If not,
19 see <http://www.gnu.org/licenses/>. */
30 #include "libiberty.h"
32 #include "aarch64-opc.h"
35 int debug_dump
= FALSE
;
36 #endif /* DEBUG_AARCH64 */
38 /* The enumeration strings associated with each value of a 5-bit SVE
39 pattern operand. A null entry indicates a reserved meaning. */
40 const char *const aarch64_sve_pattern_array
[32] = {
79 /* The enumeration strings associated with each value of a 4-bit SVE
80 prefetch operand. A null entry indicates a reserved meaning. */
81 const char *const aarch64_sve_prfop_array
[16] = {
102 /* Helper functions to determine which operand to be used to encode/decode
103 the size:Q fields for AdvSIMD instructions. */
105 static inline bfd_boolean
106 vector_qualifier_p (enum aarch64_opnd_qualifier qualifier
)
108 return ((qualifier
>= AARCH64_OPND_QLF_V_8B
109 && qualifier
<= AARCH64_OPND_QLF_V_1Q
) ? TRUE
113 static inline bfd_boolean
114 fp_qualifier_p (enum aarch64_opnd_qualifier qualifier
)
116 return ((qualifier
>= AARCH64_OPND_QLF_S_B
117 && qualifier
<= AARCH64_OPND_QLF_S_Q
) ? TRUE
127 DP_VECTOR_ACROSS_LANES
,
130 static const char significant_operand_index
[] =
132 0, /* DP_UNKNOWN, by default using operand 0. */
133 0, /* DP_VECTOR_3SAME */
134 1, /* DP_VECTOR_LONG */
135 2, /* DP_VECTOR_WIDE */
136 1, /* DP_VECTOR_ACROSS_LANES */
139 /* Given a sequence of qualifiers in QUALIFIERS, determine and return
141 N.B. QUALIFIERS is a possible sequence of qualifiers each of which
142 corresponds to one of a sequence of operands. */
144 static enum data_pattern
145 get_data_pattern (const aarch64_opnd_qualifier_seq_t qualifiers
)
147 if (vector_qualifier_p (qualifiers
[0]) == TRUE
)
149 /* e.g. v.4s, v.4s, v.4s
150 or v.4h, v.4h, v.h[3]. */
151 if (qualifiers
[0] == qualifiers
[1]
152 && vector_qualifier_p (qualifiers
[2]) == TRUE
153 && (aarch64_get_qualifier_esize (qualifiers
[0])
154 == aarch64_get_qualifier_esize (qualifiers
[1]))
155 && (aarch64_get_qualifier_esize (qualifiers
[0])
156 == aarch64_get_qualifier_esize (qualifiers
[2])))
157 return DP_VECTOR_3SAME
;
158 /* e.g. v.8h, v.8b, v.8b.
159 or v.4s, v.4h, v.h[2].
161 if (vector_qualifier_p (qualifiers
[1]) == TRUE
162 && aarch64_get_qualifier_esize (qualifiers
[0]) != 0
163 && (aarch64_get_qualifier_esize (qualifiers
[0])
164 == aarch64_get_qualifier_esize (qualifiers
[1]) << 1))
165 return DP_VECTOR_LONG
;
166 /* e.g. v.8h, v.8h, v.8b. */
167 if (qualifiers
[0] == qualifiers
[1]
168 && vector_qualifier_p (qualifiers
[2]) == TRUE
169 && aarch64_get_qualifier_esize (qualifiers
[0]) != 0
170 && (aarch64_get_qualifier_esize (qualifiers
[0])
171 == aarch64_get_qualifier_esize (qualifiers
[2]) << 1)
172 && (aarch64_get_qualifier_esize (qualifiers
[0])
173 == aarch64_get_qualifier_esize (qualifiers
[1])))
174 return DP_VECTOR_WIDE
;
176 else if (fp_qualifier_p (qualifiers
[0]) == TRUE
)
178 /* e.g. SADDLV <V><d>, <Vn>.<T>. */
179 if (vector_qualifier_p (qualifiers
[1]) == TRUE
180 && qualifiers
[2] == AARCH64_OPND_QLF_NIL
)
181 return DP_VECTOR_ACROSS_LANES
;
187 /* Select the operand to do the encoding/decoding of the 'size:Q' fields in
188 the AdvSIMD instructions. */
189 /* N.B. it is possible to do some optimization that doesn't call
190 get_data_pattern each time when we need to select an operand. We can
191 either buffer the caculated the result or statically generate the data,
192 however, it is not obvious that the optimization will bring significant
196 aarch64_select_operand_for_sizeq_field_coding (const aarch64_opcode
*opcode
)
199 significant_operand_index
[get_data_pattern (opcode
->qualifiers_list
[0])];
202 const aarch64_field fields
[] =
205 { 0, 4 }, /* cond2: condition in truly conditional-executed inst. */
206 { 0, 4 }, /* nzcv: flag bit specifier, encoded in the "nzcv" field. */
207 { 5, 5 }, /* defgh: d:e:f:g:h bits in AdvSIMD modified immediate. */
208 { 16, 3 }, /* abc: a:b:c bits in AdvSIMD modified immediate. */
209 { 5, 19 }, /* imm19: e.g. in CBZ. */
210 { 5, 19 }, /* immhi: e.g. in ADRP. */
211 { 29, 2 }, /* immlo: e.g. in ADRP. */
212 { 22, 2 }, /* size: in most AdvSIMD and floating-point instructions. */
213 { 10, 2 }, /* vldst_size: size field in the AdvSIMD load/store inst. */
214 { 29, 1 }, /* op: in AdvSIMD modified immediate instructions. */
215 { 30, 1 }, /* Q: in most AdvSIMD instructions. */
216 { 0, 5 }, /* Rt: in load/store instructions. */
217 { 0, 5 }, /* Rd: in many integer instructions. */
218 { 5, 5 }, /* Rn: in many integer instructions. */
219 { 10, 5 }, /* Rt2: in load/store pair instructions. */
220 { 10, 5 }, /* Ra: in fp instructions. */
221 { 5, 3 }, /* op2: in the system instructions. */
222 { 8, 4 }, /* CRm: in the system instructions. */
223 { 12, 4 }, /* CRn: in the system instructions. */
224 { 16, 3 }, /* op1: in the system instructions. */
225 { 19, 2 }, /* op0: in the system instructions. */
226 { 10, 3 }, /* imm3: in add/sub extended reg instructions. */
227 { 12, 4 }, /* cond: condition flags as a source operand. */
228 { 12, 4 }, /* opcode: in advsimd load/store instructions. */
229 { 12, 4 }, /* cmode: in advsimd modified immediate instructions. */
230 { 13, 3 }, /* asisdlso_opcode: opcode in advsimd ld/st single element. */
231 { 13, 2 }, /* len: in advsimd tbl/tbx instructions. */
232 { 16, 5 }, /* Rm: in ld/st reg offset and some integer inst. */
233 { 16, 5 }, /* Rs: in load/store exclusive instructions. */
234 { 13, 3 }, /* option: in ld/st reg offset + add/sub extended reg inst. */
235 { 12, 1 }, /* S: in load/store reg offset instructions. */
236 { 21, 2 }, /* hw: in move wide constant instructions. */
237 { 22, 2 }, /* opc: in load/store reg offset instructions. */
238 { 23, 1 }, /* opc1: in load/store reg offset instructions. */
239 { 22, 2 }, /* shift: in add/sub reg/imm shifted instructions. */
240 { 22, 2 }, /* type: floating point type field in fp data inst. */
241 { 30, 2 }, /* ldst_size: size field in ld/st reg offset inst. */
242 { 10, 6 }, /* imm6: in add/sub reg shifted instructions. */
243 { 11, 4 }, /* imm4: in advsimd ext and advsimd ins instructions. */
244 { 16, 5 }, /* imm5: in conditional compare (immediate) instructions. */
245 { 15, 7 }, /* imm7: in load/store pair pre/post index instructions. */
246 { 13, 8 }, /* imm8: in floating-point scalar move immediate inst. */
247 { 12, 9 }, /* imm9: in load/store pre/post index instructions. */
248 { 10, 12 }, /* imm12: in ld/st unsigned imm or add/sub shifted inst. */
249 { 5, 14 }, /* imm14: in test bit and branch instructions. */
250 { 5, 16 }, /* imm16: in exception instructions. */
251 { 0, 26 }, /* imm26: in unconditional branch instructions. */
252 { 10, 6 }, /* imms: in bitfield and logical immediate instructions. */
253 { 16, 6 }, /* immr: in bitfield and logical immediate instructions. */
254 { 16, 3 }, /* immb: in advsimd shift by immediate instructions. */
255 { 19, 4 }, /* immh: in advsimd shift by immediate instructions. */
256 { 22, 1 }, /* N: in logical (immediate) instructions. */
257 { 11, 1 }, /* index: in ld/st inst deciding the pre/post-index. */
258 { 24, 1 }, /* index2: in ld/st pair inst deciding the pre/post-index. */
259 { 31, 1 }, /* sf: in integer data processing instructions. */
260 { 30, 1 }, /* lse_size: in LSE extension atomic instructions. */
261 { 11, 1 }, /* H: in advsimd scalar x indexed element instructions. */
262 { 21, 1 }, /* L: in advsimd scalar x indexed element instructions. */
263 { 20, 1 }, /* M: in advsimd scalar x indexed element instructions. */
264 { 31, 1 }, /* b5: in the test bit and branch instructions. */
265 { 19, 5 }, /* b40: in the test bit and branch instructions. */
266 { 10, 6 }, /* scale: in the fixed-point scalar to fp converting inst. */
267 { 17, 1 }, /* SVE_N: SVE equivalent of N. */
268 { 0, 4 }, /* SVE_Pd: p0-p15, bits [3,0]. */
269 { 10, 3 }, /* SVE_Pg3: p0-p7, bits [12,10]. */
270 { 5, 4 }, /* SVE_Pg4_5: p0-p15, bits [8,5]. */
271 { 10, 4 }, /* SVE_Pg4_10: p0-p15, bits [13,10]. */
272 { 16, 4 }, /* SVE_Pg4_16: p0-p15, bits [19,16]. */
273 { 16, 4 }, /* SVE_Pm: p0-p15, bits [19,16]. */
274 { 5, 4 }, /* SVE_Pn: p0-p15, bits [8,5]. */
275 { 0, 4 }, /* SVE_Pt: p0-p15, bits [3,0]. */
276 { 5, 5 }, /* SVE_Za_5: SVE vector register, bits [9,5]. */
277 { 16, 5 }, /* SVE_Za_16: SVE vector register, bits [20,16]. */
278 { 0, 5 }, /* SVE_Zd: SVE vector register. bits [4,0]. */
279 { 5, 5 }, /* SVE_Zm_5: SVE vector register, bits [9,5]. */
280 { 16, 5 }, /* SVE_Zm_16: SVE vector register, bits [20,16]. */
281 { 5, 5 }, /* SVE_Zn: SVE vector register, bits [9,5]. */
282 { 0, 5 }, /* SVE_Zt: SVE vector register, bits [4,0]. */
283 { 16, 3 }, /* SVE_imm3: 3-bit immediate field. */
284 { 16, 4 }, /* SVE_imm4: 4-bit immediate field. */
285 { 5, 5 }, /* SVE_imm5: 5-bit immediate field. */
286 { 16, 5 }, /* SVE_imm5b: secondary 5-bit immediate field. */
287 { 16, 6 }, /* SVE_imm6: 6-bit immediate field. */
288 { 14, 7 }, /* SVE_imm7: 7-bit immediate field. */
289 { 5, 8 }, /* SVE_imm8: 8-bit immediate field. */
290 { 5, 9 }, /* SVE_imm9: 9-bit immediate field. */
291 { 11, 6 }, /* SVE_immr: SVE equivalent of immr. */
292 { 5, 6 }, /* SVE_imms: SVE equivalent of imms. */
293 { 10, 2 }, /* SVE_msz: 2-bit shift amount for ADR. */
294 { 5, 5 }, /* SVE_pattern: vector pattern enumeration. */
295 { 0, 4 }, /* SVE_prfop: prefetch operation for SVE PRF[BHWD]. */
296 { 22, 2 }, /* SVE_tszh: triangular size select high, bits [23,22]. */
297 { 14, 1 }, /* SVE_xs_14: UXTW/SXTW select (bit 14). */
298 { 22, 1 } /* SVE_xs_22: UXTW/SXTW select (bit 22). */
301 enum aarch64_operand_class
302 aarch64_get_operand_class (enum aarch64_opnd type
)
304 return aarch64_operands
[type
].op_class
;
308 aarch64_get_operand_name (enum aarch64_opnd type
)
310 return aarch64_operands
[type
].name
;
313 /* Get operand description string.
314 This is usually for the diagnosis purpose. */
316 aarch64_get_operand_desc (enum aarch64_opnd type
)
318 return aarch64_operands
[type
].desc
;
321 /* Table of all conditional affixes. */
322 const aarch64_cond aarch64_conds
[16] =
327 {{"cc", "lo", "ul"}, 0x3},
343 get_cond_from_value (aarch64_insn value
)
346 return &aarch64_conds
[(unsigned int) value
];
350 get_inverted_cond (const aarch64_cond
*cond
)
352 return &aarch64_conds
[cond
->value
^ 0x1];
355 /* Table describing the operand extension/shifting operators; indexed by
356 enum aarch64_modifier_kind.
358 The value column provides the most common values for encoding modifiers,
359 which enables table-driven encoding/decoding for the modifiers. */
360 const struct aarch64_name_value_pair aarch64_operand_modifiers
[] =
381 enum aarch64_modifier_kind
382 aarch64_get_operand_modifier (const struct aarch64_name_value_pair
*desc
)
384 return desc
- aarch64_operand_modifiers
;
388 aarch64_get_operand_modifier_value (enum aarch64_modifier_kind kind
)
390 return aarch64_operand_modifiers
[kind
].value
;
393 enum aarch64_modifier_kind
394 aarch64_get_operand_modifier_from_value (aarch64_insn value
,
395 bfd_boolean extend_p
)
397 if (extend_p
== TRUE
)
398 return AARCH64_MOD_UXTB
+ value
;
400 return AARCH64_MOD_LSL
- value
;
404 aarch64_extend_operator_p (enum aarch64_modifier_kind kind
)
406 return (kind
> AARCH64_MOD_LSL
&& kind
<= AARCH64_MOD_SXTX
)
410 static inline bfd_boolean
411 aarch64_shift_operator_p (enum aarch64_modifier_kind kind
)
413 return (kind
>= AARCH64_MOD_ROR
&& kind
<= AARCH64_MOD_LSL
)
417 const struct aarch64_name_value_pair aarch64_barrier_options
[16] =
437 /* Table describing the operands supported by the aliases of the HINT
440 The name column is the operand that is accepted for the alias. The value
441 column is the hint number of the alias. The list of operands is terminated
442 by NULL in the name column. */
444 const struct aarch64_name_value_pair aarch64_hint_options
[] =
446 { "csync", 0x11 }, /* PSB CSYNC. */
450 /* op -> op: load = 0 instruction = 1 store = 2
452 t -> temporal: temporal (retained) = 0 non-temporal (streaming) = 1 */
453 #define B(op,l,t) (((op) << 3) | (((l) - 1) << 1) | (t))
454 const struct aarch64_name_value_pair aarch64_prfops
[32] =
456 { "pldl1keep", B(0, 1, 0) },
457 { "pldl1strm", B(0, 1, 1) },
458 { "pldl2keep", B(0, 2, 0) },
459 { "pldl2strm", B(0, 2, 1) },
460 { "pldl3keep", B(0, 3, 0) },
461 { "pldl3strm", B(0, 3, 1) },
464 { "plil1keep", B(1, 1, 0) },
465 { "plil1strm", B(1, 1, 1) },
466 { "plil2keep", B(1, 2, 0) },
467 { "plil2strm", B(1, 2, 1) },
468 { "plil3keep", B(1, 3, 0) },
469 { "plil3strm", B(1, 3, 1) },
472 { "pstl1keep", B(2, 1, 0) },
473 { "pstl1strm", B(2, 1, 1) },
474 { "pstl2keep", B(2, 2, 0) },
475 { "pstl2strm", B(2, 2, 1) },
476 { "pstl3keep", B(2, 3, 0) },
477 { "pstl3strm", B(2, 3, 1) },
491 /* Utilities on value constraint. */
494 value_in_range_p (int64_t value
, int low
, int high
)
496 return (value
>= low
&& value
<= high
) ? 1 : 0;
499 /* Return true if VALUE is a multiple of ALIGN. */
501 value_aligned_p (int64_t value
, int align
)
503 return (value
% align
) == 0;
506 /* A signed value fits in a field. */
508 value_fit_signed_field_p (int64_t value
, unsigned width
)
511 if (width
< sizeof (value
) * 8)
513 int64_t lim
= (int64_t)1 << (width
- 1);
514 if (value
>= -lim
&& value
< lim
)
520 /* An unsigned value fits in a field. */
522 value_fit_unsigned_field_p (int64_t value
, unsigned width
)
525 if (width
< sizeof (value
) * 8)
527 int64_t lim
= (int64_t)1 << width
;
528 if (value
>= 0 && value
< lim
)
534 /* Return 1 if OPERAND is SP or WSP. */
536 aarch64_stack_pointer_p (const aarch64_opnd_info
*operand
)
538 return ((aarch64_get_operand_class (operand
->type
)
539 == AARCH64_OPND_CLASS_INT_REG
)
540 && operand_maybe_stack_pointer (aarch64_operands
+ operand
->type
)
541 && operand
->reg
.regno
== 31);
544 /* Return 1 if OPERAND is XZR or WZP. */
546 aarch64_zero_register_p (const aarch64_opnd_info
*operand
)
548 return ((aarch64_get_operand_class (operand
->type
)
549 == AARCH64_OPND_CLASS_INT_REG
)
550 && !operand_maybe_stack_pointer (aarch64_operands
+ operand
->type
)
551 && operand
->reg
.regno
== 31);
554 /* Return true if the operand *OPERAND that has the operand code
555 OPERAND->TYPE and been qualified by OPERAND->QUALIFIER can be also
556 qualified by the qualifier TARGET. */
559 operand_also_qualified_p (const struct aarch64_opnd_info
*operand
,
560 aarch64_opnd_qualifier_t target
)
562 switch (operand
->qualifier
)
564 case AARCH64_OPND_QLF_W
:
565 if (target
== AARCH64_OPND_QLF_WSP
&& aarch64_stack_pointer_p (operand
))
568 case AARCH64_OPND_QLF_X
:
569 if (target
== AARCH64_OPND_QLF_SP
&& aarch64_stack_pointer_p (operand
))
572 case AARCH64_OPND_QLF_WSP
:
573 if (target
== AARCH64_OPND_QLF_W
574 && operand_maybe_stack_pointer (aarch64_operands
+ operand
->type
))
577 case AARCH64_OPND_QLF_SP
:
578 if (target
== AARCH64_OPND_QLF_X
579 && operand_maybe_stack_pointer (aarch64_operands
+ operand
->type
))
589 /* Given qualifier sequence list QSEQ_LIST and the known qualifier KNOWN_QLF
590 for operand KNOWN_IDX, return the expected qualifier for operand IDX.
592 Return NIL if more than one expected qualifiers are found. */
594 aarch64_opnd_qualifier_t
595 aarch64_get_expected_qualifier (const aarch64_opnd_qualifier_seq_t
*qseq_list
,
597 const aarch64_opnd_qualifier_t known_qlf
,
604 When the known qualifier is NIL, we have to assume that there is only
605 one qualifier sequence in the *QSEQ_LIST and return the corresponding
606 qualifier directly. One scenario is that for instruction
607 PRFM <prfop>, [<Xn|SP>, #:lo12:<symbol>]
608 which has only one possible valid qualifier sequence
610 the caller may pass NIL in KNOWN_QLF to obtain S_D so that it can
611 determine the correct relocation type (i.e. LDST64_LO12) for PRFM.
613 Because the qualifier NIL has dual roles in the qualifier sequence:
614 it can mean no qualifier for the operand, or the qualifer sequence is
615 not in use (when all qualifiers in the sequence are NILs), we have to
616 handle this special case here. */
617 if (known_qlf
== AARCH64_OPND_NIL
)
619 assert (qseq_list
[0][known_idx
] == AARCH64_OPND_NIL
);
620 return qseq_list
[0][idx
];
623 for (i
= 0, saved_i
= -1; i
< AARCH64_MAX_QLF_SEQ_NUM
; ++i
)
625 if (qseq_list
[i
][known_idx
] == known_qlf
)
628 /* More than one sequences are found to have KNOWN_QLF at
630 return AARCH64_OPND_NIL
;
635 return qseq_list
[saved_i
][idx
];
638 enum operand_qualifier_kind
646 /* Operand qualifier description. */
647 struct operand_qualifier_data
649 /* The usage of the three data fields depends on the qualifier kind. */
656 enum operand_qualifier_kind kind
;
659 /* Indexed by the operand qualifier enumerators. */
660 struct operand_qualifier_data aarch64_opnd_qualifiers
[] =
662 {0, 0, 0, "NIL", OQK_NIL
},
664 /* Operand variant qualifiers.
666 element size, number of elements and common value for encoding. */
668 {4, 1, 0x0, "w", OQK_OPD_VARIANT
},
669 {8, 1, 0x1, "x", OQK_OPD_VARIANT
},
670 {4, 1, 0x0, "wsp", OQK_OPD_VARIANT
},
671 {8, 1, 0x1, "sp", OQK_OPD_VARIANT
},
673 {1, 1, 0x0, "b", OQK_OPD_VARIANT
},
674 {2, 1, 0x1, "h", OQK_OPD_VARIANT
},
675 {4, 1, 0x2, "s", OQK_OPD_VARIANT
},
676 {8, 1, 0x3, "d", OQK_OPD_VARIANT
},
677 {16, 1, 0x4, "q", OQK_OPD_VARIANT
},
679 {1, 8, 0x0, "8b", OQK_OPD_VARIANT
},
680 {1, 16, 0x1, "16b", OQK_OPD_VARIANT
},
681 {2, 2, 0x0, "2h", OQK_OPD_VARIANT
},
682 {2, 4, 0x2, "4h", OQK_OPD_VARIANT
},
683 {2, 8, 0x3, "8h", OQK_OPD_VARIANT
},
684 {4, 2, 0x4, "2s", OQK_OPD_VARIANT
},
685 {4, 4, 0x5, "4s", OQK_OPD_VARIANT
},
686 {8, 1, 0x6, "1d", OQK_OPD_VARIANT
},
687 {8, 2, 0x7, "2d", OQK_OPD_VARIANT
},
688 {16, 1, 0x8, "1q", OQK_OPD_VARIANT
},
690 {0, 0, 0, "z", OQK_OPD_VARIANT
},
691 {0, 0, 0, "m", OQK_OPD_VARIANT
},
693 /* Qualifiers constraining the value range.
695 Lower bound, higher bound, unused. */
697 {0, 7, 0, "imm_0_7" , OQK_VALUE_IN_RANGE
},
698 {0, 15, 0, "imm_0_15", OQK_VALUE_IN_RANGE
},
699 {0, 31, 0, "imm_0_31", OQK_VALUE_IN_RANGE
},
700 {0, 63, 0, "imm_0_63", OQK_VALUE_IN_RANGE
},
701 {1, 32, 0, "imm_1_32", OQK_VALUE_IN_RANGE
},
702 {1, 64, 0, "imm_1_64", OQK_VALUE_IN_RANGE
},
704 /* Qualifiers for miscellaneous purpose.
706 unused, unused and unused. */
711 {0, 0, 0, "retrieving", 0},
714 static inline bfd_boolean
715 operand_variant_qualifier_p (aarch64_opnd_qualifier_t qualifier
)
717 return (aarch64_opnd_qualifiers
[qualifier
].kind
== OQK_OPD_VARIANT
)
721 static inline bfd_boolean
722 qualifier_value_in_range_constraint_p (aarch64_opnd_qualifier_t qualifier
)
724 return (aarch64_opnd_qualifiers
[qualifier
].kind
== OQK_VALUE_IN_RANGE
)
729 aarch64_get_qualifier_name (aarch64_opnd_qualifier_t qualifier
)
731 return aarch64_opnd_qualifiers
[qualifier
].desc
;
734 /* Given an operand qualifier, return the expected data element size
735 of a qualified operand. */
737 aarch64_get_qualifier_esize (aarch64_opnd_qualifier_t qualifier
)
739 assert (operand_variant_qualifier_p (qualifier
) == TRUE
);
740 return aarch64_opnd_qualifiers
[qualifier
].data0
;
744 aarch64_get_qualifier_nelem (aarch64_opnd_qualifier_t qualifier
)
746 assert (operand_variant_qualifier_p (qualifier
) == TRUE
);
747 return aarch64_opnd_qualifiers
[qualifier
].data1
;
751 aarch64_get_qualifier_standard_value (aarch64_opnd_qualifier_t qualifier
)
753 assert (operand_variant_qualifier_p (qualifier
) == TRUE
);
754 return aarch64_opnd_qualifiers
[qualifier
].data2
;
758 get_lower_bound (aarch64_opnd_qualifier_t qualifier
)
760 assert (qualifier_value_in_range_constraint_p (qualifier
) == TRUE
);
761 return aarch64_opnd_qualifiers
[qualifier
].data0
;
765 get_upper_bound (aarch64_opnd_qualifier_t qualifier
)
767 assert (qualifier_value_in_range_constraint_p (qualifier
) == TRUE
);
768 return aarch64_opnd_qualifiers
[qualifier
].data1
;
773 aarch64_verbose (const char *str
, ...)
784 dump_qualifier_sequence (const aarch64_opnd_qualifier_t
*qualifier
)
788 for (i
= 0; i
< AARCH64_MAX_OPND_NUM
; ++i
, ++qualifier
)
789 printf ("%s,", aarch64_get_qualifier_name (*qualifier
));
794 dump_match_qualifiers (const struct aarch64_opnd_info
*opnd
,
795 const aarch64_opnd_qualifier_t
*qualifier
)
798 aarch64_opnd_qualifier_t curr
[AARCH64_MAX_OPND_NUM
];
800 aarch64_verbose ("dump_match_qualifiers:");
801 for (i
= 0; i
< AARCH64_MAX_OPND_NUM
; ++i
)
802 curr
[i
] = opnd
[i
].qualifier
;
803 dump_qualifier_sequence (curr
);
804 aarch64_verbose ("against");
805 dump_qualifier_sequence (qualifier
);
807 #endif /* DEBUG_AARCH64 */
809 /* TODO improve this, we can have an extra field at the runtime to
810 store the number of operands rather than calculating it every time. */
813 aarch64_num_of_operands (const aarch64_opcode
*opcode
)
816 const enum aarch64_opnd
*opnds
= opcode
->operands
;
817 while (opnds
[i
++] != AARCH64_OPND_NIL
)
820 assert (i
>= 0 && i
<= AARCH64_MAX_OPND_NUM
);
824 /* Find the best matched qualifier sequence in *QUALIFIERS_LIST for INST.
825 If succeeds, fill the found sequence in *RET, return 1; otherwise return 0.
827 N.B. on the entry, it is very likely that only some operands in *INST
828 have had their qualifiers been established.
830 If STOP_AT is not -1, the function will only try to match
831 the qualifier sequence for operands before and including the operand
832 of index STOP_AT; and on success *RET will only be filled with the first
833 (STOP_AT+1) qualifiers.
835 A couple examples of the matching algorithm:
843 Apart from serving the main encoding routine, this can also be called
844 during or after the operand decoding. */
847 aarch64_find_best_match (const aarch64_inst
*inst
,
848 const aarch64_opnd_qualifier_seq_t
*qualifiers_list
,
849 int stop_at
, aarch64_opnd_qualifier_t
*ret
)
853 const aarch64_opnd_qualifier_t
*qualifiers
;
855 num_opnds
= aarch64_num_of_operands (inst
->opcode
);
858 DEBUG_TRACE ("SUCCEED: no operand");
862 if (stop_at
< 0 || stop_at
>= num_opnds
)
863 stop_at
= num_opnds
- 1;
865 /* For each pattern. */
866 for (i
= 0; i
< AARCH64_MAX_QLF_SEQ_NUM
; ++i
, ++qualifiers_list
)
869 qualifiers
= *qualifiers_list
;
871 /* Start as positive. */
874 DEBUG_TRACE ("%d", i
);
877 dump_match_qualifiers (inst
->operands
, qualifiers
);
880 /* Most opcodes has much fewer patterns in the list.
881 First NIL qualifier indicates the end in the list. */
882 if (empty_qualifier_sequence_p (qualifiers
) == TRUE
)
884 DEBUG_TRACE_IF (i
== 0, "SUCCEED: empty qualifier list");
890 for (j
= 0; j
< num_opnds
&& j
<= stop_at
; ++j
, ++qualifiers
)
892 if (inst
->operands
[j
].qualifier
== AARCH64_OPND_QLF_NIL
)
894 /* Either the operand does not have qualifier, or the qualifier
895 for the operand needs to be deduced from the qualifier
897 In the latter case, any constraint checking related with
898 the obtained qualifier should be done later in
899 operand_general_constraint_met_p. */
902 else if (*qualifiers
!= inst
->operands
[j
].qualifier
)
904 /* Unless the target qualifier can also qualify the operand
905 (which has already had a non-nil qualifier), non-equal
906 qualifiers are generally un-matched. */
907 if (operand_also_qualified_p (inst
->operands
+ j
, *qualifiers
))
916 continue; /* Equal qualifiers are certainly matched. */
919 /* Qualifiers established. */
926 /* Fill the result in *RET. */
928 qualifiers
= *qualifiers_list
;
930 DEBUG_TRACE ("complete qualifiers using list %d", i
);
933 dump_qualifier_sequence (qualifiers
);
936 for (j
= 0; j
<= stop_at
; ++j
, ++qualifiers
)
937 ret
[j
] = *qualifiers
;
938 for (; j
< AARCH64_MAX_OPND_NUM
; ++j
)
939 ret
[j
] = AARCH64_OPND_QLF_NIL
;
941 DEBUG_TRACE ("SUCCESS");
945 DEBUG_TRACE ("FAIL");
949 /* Operand qualifier matching and resolving.
951 Return 1 if the operand qualifier(s) in *INST match one of the qualifier
952 sequences in INST->OPCODE->qualifiers_list; otherwise return 0.
954 if UPDATE_P == TRUE, update the qualifier(s) in *INST after the matching
958 match_operands_qualifier (aarch64_inst
*inst
, bfd_boolean update_p
)
961 aarch64_opnd_qualifier_seq_t qualifiers
;
963 if (!aarch64_find_best_match (inst
, inst
->opcode
->qualifiers_list
, -1,
966 DEBUG_TRACE ("matching FAIL");
970 if (inst
->opcode
->flags
& F_STRICT
)
972 /* Require an exact qualifier match, even for NIL qualifiers. */
973 nops
= aarch64_num_of_operands (inst
->opcode
);
974 for (i
= 0; i
< nops
; ++i
)
975 if (inst
->operands
[i
].qualifier
!= qualifiers
[i
])
979 /* Update the qualifiers. */
980 if (update_p
== TRUE
)
981 for (i
= 0; i
< AARCH64_MAX_OPND_NUM
; ++i
)
983 if (inst
->opcode
->operands
[i
] == AARCH64_OPND_NIL
)
985 DEBUG_TRACE_IF (inst
->operands
[i
].qualifier
!= qualifiers
[i
],
986 "update %s with %s for operand %d",
987 aarch64_get_qualifier_name (inst
->operands
[i
].qualifier
),
988 aarch64_get_qualifier_name (qualifiers
[i
]), i
);
989 inst
->operands
[i
].qualifier
= qualifiers
[i
];
992 DEBUG_TRACE ("matching SUCCESS");
996 /* Return TRUE if VALUE is a wide constant that can be moved into a general
999 IS32 indicates whether value is a 32-bit immediate or not.
1000 If SHIFT_AMOUNT is not NULL, on the return of TRUE, the logical left shift
1001 amount will be returned in *SHIFT_AMOUNT. */
1004 aarch64_wide_constant_p (int64_t value
, int is32
, unsigned int *shift_amount
)
1008 DEBUG_TRACE ("enter with 0x%" PRIx64
"(%" PRIi64
")", value
, value
);
1012 /* Allow all zeros or all ones in top 32-bits, so that
1013 32-bit constant expressions like ~0x80000000 are
1015 uint64_t ext
= value
;
1016 if (ext
>> 32 != 0 && ext
>> 32 != (uint64_t) 0xffffffff)
1017 /* Immediate out of range. */
1019 value
&= (int64_t) 0xffffffff;
1022 /* first, try movz then movn */
1024 if ((value
& ((int64_t) 0xffff << 0)) == value
)
1026 else if ((value
& ((int64_t) 0xffff << 16)) == value
)
1028 else if (!is32
&& (value
& ((int64_t) 0xffff << 32)) == value
)
1030 else if (!is32
&& (value
& ((int64_t) 0xffff << 48)) == value
)
1035 DEBUG_TRACE ("exit FALSE with 0x%" PRIx64
"(%" PRIi64
")", value
, value
);
1039 if (shift_amount
!= NULL
)
1040 *shift_amount
= amount
;
1042 DEBUG_TRACE ("exit TRUE with amount %d", amount
);
1047 /* Build the accepted values for immediate logical SIMD instructions.
1049 The standard encodings of the immediate value are:
1050 N imms immr SIMD size R S
1051 1 ssssss rrrrrr 64 UInt(rrrrrr) UInt(ssssss)
1052 0 0sssss 0rrrrr 32 UInt(rrrrr) UInt(sssss)
1053 0 10ssss 00rrrr 16 UInt(rrrr) UInt(ssss)
1054 0 110sss 000rrr 8 UInt(rrr) UInt(sss)
1055 0 1110ss 0000rr 4 UInt(rr) UInt(ss)
1056 0 11110s 00000r 2 UInt(r) UInt(s)
1057 where all-ones value of S is reserved.
1059 Let's call E the SIMD size.
1061 The immediate value is: S+1 bits '1' rotated to the right by R.
1063 The total of valid encodings is 64*63 + 32*31 + ... + 2*1 = 5334
1064 (remember S != E - 1). */
1066 #define TOTAL_IMM_NB 5334
1071 aarch64_insn encoding
;
1072 } simd_imm_encoding
;
1074 static simd_imm_encoding simd_immediates
[TOTAL_IMM_NB
];
1077 simd_imm_encoding_cmp(const void *i1
, const void *i2
)
1079 const simd_imm_encoding
*imm1
= (const simd_imm_encoding
*)i1
;
1080 const simd_imm_encoding
*imm2
= (const simd_imm_encoding
*)i2
;
1082 if (imm1
->imm
< imm2
->imm
)
1084 if (imm1
->imm
> imm2
->imm
)
1089 /* immediate bitfield standard encoding
1090 imm13<12> imm13<5:0> imm13<11:6> SIMD size R S
1091 1 ssssss rrrrrr 64 rrrrrr ssssss
1092 0 0sssss 0rrrrr 32 rrrrr sssss
1093 0 10ssss 00rrrr 16 rrrr ssss
1094 0 110sss 000rrr 8 rrr sss
1095 0 1110ss 0000rr 4 rr ss
1096 0 11110s 00000r 2 r s */
1098 encode_immediate_bitfield (int is64
, uint32_t s
, uint32_t r
)
1100 return (is64
<< 12) | (r
<< 6) | s
;
1104 build_immediate_table (void)
1106 uint32_t log_e
, e
, s
, r
, s_mask
;
1112 for (log_e
= 1; log_e
<= 6; log_e
++)
1114 /* Get element size. */
1119 mask
= 0xffffffffffffffffull
;
1125 mask
= (1ull << e
) - 1;
1127 1 ((1 << 4) - 1) << 2 = 111100
1128 2 ((1 << 3) - 1) << 3 = 111000
1129 3 ((1 << 2) - 1) << 4 = 110000
1130 4 ((1 << 1) - 1) << 5 = 100000
1131 5 ((1 << 0) - 1) << 6 = 000000 */
1132 s_mask
= ((1u << (5 - log_e
)) - 1) << (log_e
+ 1);
1134 for (s
= 0; s
< e
- 1; s
++)
1135 for (r
= 0; r
< e
; r
++)
1137 /* s+1 consecutive bits to 1 (s < 63) */
1138 imm
= (1ull << (s
+ 1)) - 1;
1139 /* rotate right by r */
1141 imm
= (imm
>> r
) | ((imm
<< (e
- r
)) & mask
);
1142 /* replicate the constant depending on SIMD size */
1145 case 1: imm
= (imm
<< 2) | imm
;
1146 case 2: imm
= (imm
<< 4) | imm
;
1147 case 3: imm
= (imm
<< 8) | imm
;
1148 case 4: imm
= (imm
<< 16) | imm
;
1149 case 5: imm
= (imm
<< 32) | imm
;
1153 simd_immediates
[nb_imms
].imm
= imm
;
1154 simd_immediates
[nb_imms
].encoding
=
1155 encode_immediate_bitfield(is64
, s
| s_mask
, r
);
1159 assert (nb_imms
== TOTAL_IMM_NB
);
1160 qsort(simd_immediates
, nb_imms
,
1161 sizeof(simd_immediates
[0]), simd_imm_encoding_cmp
);
1164 /* Return TRUE if VALUE is a valid logical immediate, i.e. bitmask, that can
1165 be accepted by logical (immediate) instructions
1166 e.g. ORR <Xd|SP>, <Xn>, #<imm>.
1168 ESIZE is the number of bytes in the decoded immediate value.
1169 If ENCODING is not NULL, on the return of TRUE, the standard encoding for
1170 VALUE will be returned in *ENCODING. */
1173 aarch64_logical_immediate_p (uint64_t value
, int esize
, aarch64_insn
*encoding
)
1175 simd_imm_encoding imm_enc
;
1176 const simd_imm_encoding
*imm_encoding
;
1177 static bfd_boolean initialized
= FALSE
;
1181 DEBUG_TRACE ("enter with 0x%" PRIx64
"(%" PRIi64
"), is32: %d", value
,
1184 if (initialized
== FALSE
)
1186 build_immediate_table ();
1190 /* Allow all zeros or all ones in top bits, so that
1191 constant expressions like ~1 are permitted. */
1192 upper
= (uint64_t) -1 << (esize
* 4) << (esize
* 4);
1193 if ((value
& ~upper
) != value
&& (value
| upper
) != value
)
1196 /* Replicate to a full 64-bit value. */
1198 for (i
= esize
* 8; i
< 64; i
*= 2)
1199 value
|= (value
<< i
);
1201 imm_enc
.imm
= value
;
1202 imm_encoding
= (const simd_imm_encoding
*)
1203 bsearch(&imm_enc
, simd_immediates
, TOTAL_IMM_NB
,
1204 sizeof(simd_immediates
[0]), simd_imm_encoding_cmp
);
1205 if (imm_encoding
== NULL
)
1207 DEBUG_TRACE ("exit with FALSE");
1210 if (encoding
!= NULL
)
1211 *encoding
= imm_encoding
->encoding
;
1212 DEBUG_TRACE ("exit with TRUE");
1216 /* If 64-bit immediate IMM is in the format of
1217 "aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffgggggggghhhhhhhh",
1218 where a, b, c, d, e, f, g and h are independently 0 or 1, return an integer
1219 of value "abcdefgh". Otherwise return -1. */
1221 aarch64_shrink_expanded_imm8 (uint64_t imm
)
1227 for (i
= 0; i
< 8; i
++)
1229 byte
= (imm
>> (8 * i
)) & 0xff;
1232 else if (byte
!= 0x00)
1238 /* Utility inline functions for operand_general_constraint_met_p. */
1241 set_error (aarch64_operand_error
*mismatch_detail
,
1242 enum aarch64_operand_error_kind kind
, int idx
,
1245 if (mismatch_detail
== NULL
)
1247 mismatch_detail
->kind
= kind
;
1248 mismatch_detail
->index
= idx
;
1249 mismatch_detail
->error
= error
;
1253 set_syntax_error (aarch64_operand_error
*mismatch_detail
, int idx
,
1256 if (mismatch_detail
== NULL
)
1258 set_error (mismatch_detail
, AARCH64_OPDE_SYNTAX_ERROR
, idx
, error
);
1262 set_out_of_range_error (aarch64_operand_error
*mismatch_detail
,
1263 int idx
, int lower_bound
, int upper_bound
,
1266 if (mismatch_detail
== NULL
)
1268 set_error (mismatch_detail
, AARCH64_OPDE_OUT_OF_RANGE
, idx
, error
);
1269 mismatch_detail
->data
[0] = lower_bound
;
1270 mismatch_detail
->data
[1] = upper_bound
;
1274 set_imm_out_of_range_error (aarch64_operand_error
*mismatch_detail
,
1275 int idx
, int lower_bound
, int upper_bound
)
1277 if (mismatch_detail
== NULL
)
1279 set_out_of_range_error (mismatch_detail
, idx
, lower_bound
, upper_bound
,
1280 _("immediate value"));
1284 set_offset_out_of_range_error (aarch64_operand_error
*mismatch_detail
,
1285 int idx
, int lower_bound
, int upper_bound
)
1287 if (mismatch_detail
== NULL
)
1289 set_out_of_range_error (mismatch_detail
, idx
, lower_bound
, upper_bound
,
1290 _("immediate offset"));
1294 set_regno_out_of_range_error (aarch64_operand_error
*mismatch_detail
,
1295 int idx
, int lower_bound
, int upper_bound
)
1297 if (mismatch_detail
== NULL
)
1299 set_out_of_range_error (mismatch_detail
, idx
, lower_bound
, upper_bound
,
1300 _("register number"));
1304 set_elem_idx_out_of_range_error (aarch64_operand_error
*mismatch_detail
,
1305 int idx
, int lower_bound
, int upper_bound
)
1307 if (mismatch_detail
== NULL
)
1309 set_out_of_range_error (mismatch_detail
, idx
, lower_bound
, upper_bound
,
1310 _("register element index"));
1314 set_sft_amount_out_of_range_error (aarch64_operand_error
*mismatch_detail
,
1315 int idx
, int lower_bound
, int upper_bound
)
1317 if (mismatch_detail
== NULL
)
1319 set_out_of_range_error (mismatch_detail
, idx
, lower_bound
, upper_bound
,
1323 /* Report that the MUL modifier in operand IDX should be in the range
1324 [LOWER_BOUND, UPPER_BOUND]. */
1326 set_multiplier_out_of_range_error (aarch64_operand_error
*mismatch_detail
,
1327 int idx
, int lower_bound
, int upper_bound
)
1329 if (mismatch_detail
== NULL
)
1331 set_out_of_range_error (mismatch_detail
, idx
, lower_bound
, upper_bound
,
1336 set_unaligned_error (aarch64_operand_error
*mismatch_detail
, int idx
,
1339 if (mismatch_detail
== NULL
)
1341 set_error (mismatch_detail
, AARCH64_OPDE_UNALIGNED
, idx
, NULL
);
1342 mismatch_detail
->data
[0] = alignment
;
1346 set_reg_list_error (aarch64_operand_error
*mismatch_detail
, int idx
,
1349 if (mismatch_detail
== NULL
)
1351 set_error (mismatch_detail
, AARCH64_OPDE_REG_LIST
, idx
, NULL
);
1352 mismatch_detail
->data
[0] = expected_num
;
1356 set_other_error (aarch64_operand_error
*mismatch_detail
, int idx
,
1359 if (mismatch_detail
== NULL
)
1361 set_error (mismatch_detail
, AARCH64_OPDE_OTHER_ERROR
, idx
, error
);
1364 /* General constraint checking based on operand code.
1366 Return 1 if OPNDS[IDX] meets the general constraint of operand code TYPE
1367 as the IDXth operand of opcode OPCODE. Otherwise return 0.
1369 This function has to be called after the qualifiers for all operands
1372 Mismatching error message is returned in *MISMATCH_DETAIL upon request,
1373 i.e. when MISMATCH_DETAIL is non-NULL. This avoids the generation
1374 of error message during the disassembling where error message is not
1375 wanted. We avoid the dynamic construction of strings of error messages
1376 here (i.e. in libopcodes), as it is costly and complicated; instead, we
1377 use a combination of error code, static string and some integer data to
1378 represent an error. */
1381 operand_general_constraint_met_p (const aarch64_opnd_info
*opnds
, int idx
,
1382 enum aarch64_opnd type
,
1383 const aarch64_opcode
*opcode
,
1384 aarch64_operand_error
*mismatch_detail
)
1386 unsigned num
, modifiers
, shift
;
1388 int64_t imm
, min_value
, max_value
;
1389 uint64_t uvalue
, mask
;
1390 const aarch64_opnd_info
*opnd
= opnds
+ idx
;
1391 aarch64_opnd_qualifier_t qualifier
= opnd
->qualifier
;
1393 assert (opcode
->operands
[idx
] == opnd
->type
&& opnd
->type
== type
);
1395 switch (aarch64_operands
[type
].op_class
)
1397 case AARCH64_OPND_CLASS_INT_REG
:
1398 /* Check pair reg constraints for cas* instructions. */
1399 if (type
== AARCH64_OPND_PAIRREG
)
1401 assert (idx
== 1 || idx
== 3);
1402 if (opnds
[idx
- 1].reg
.regno
% 2 != 0)
1404 set_syntax_error (mismatch_detail
, idx
- 1,
1405 _("reg pair must start from even reg"));
1408 if (opnds
[idx
].reg
.regno
!= opnds
[idx
- 1].reg
.regno
+ 1)
1410 set_syntax_error (mismatch_detail
, idx
,
1411 _("reg pair must be contiguous"));
1417 /* <Xt> may be optional in some IC and TLBI instructions. */
1418 if (type
== AARCH64_OPND_Rt_SYS
)
1420 assert (idx
== 1 && (aarch64_get_operand_class (opnds
[0].type
)
1421 == AARCH64_OPND_CLASS_SYSTEM
));
1422 if (opnds
[1].present
1423 && !aarch64_sys_ins_reg_has_xt (opnds
[0].sysins_op
))
1425 set_other_error (mismatch_detail
, idx
, _("extraneous register"));
1428 if (!opnds
[1].present
1429 && aarch64_sys_ins_reg_has_xt (opnds
[0].sysins_op
))
1431 set_other_error (mismatch_detail
, idx
, _("missing register"));
1437 case AARCH64_OPND_QLF_WSP
:
1438 case AARCH64_OPND_QLF_SP
:
1439 if (!aarch64_stack_pointer_p (opnd
))
1441 set_other_error (mismatch_detail
, idx
,
1442 _("stack pointer register expected"));
1451 case AARCH64_OPND_CLASS_SVE_REG
:
1454 case AARCH64_OPND_SVE_Zn_INDEX
:
1455 size
= aarch64_get_qualifier_esize (opnd
->qualifier
);
1456 if (!value_in_range_p (opnd
->reglane
.index
, 0, 64 / size
- 1))
1458 set_elem_idx_out_of_range_error (mismatch_detail
, idx
,
1464 case AARCH64_OPND_SVE_ZnxN
:
1465 case AARCH64_OPND_SVE_ZtxN
:
1466 if (opnd
->reglist
.num_regs
!= get_opcode_dependent_value (opcode
))
1468 set_other_error (mismatch_detail
, idx
,
1469 _("invalid register list"));
1479 case AARCH64_OPND_CLASS_PRED_REG
:
1480 if (opnd
->reg
.regno
>= 8
1481 && get_operand_fields_width (get_operand_from_code (type
)) == 3)
1483 set_other_error (mismatch_detail
, idx
, _("p0-p7 expected"));
1488 case AARCH64_OPND_CLASS_COND
:
1489 if (type
== AARCH64_OPND_COND1
1490 && (opnds
[idx
].cond
->value
& 0xe) == 0xe)
1492 /* Not allow AL or NV. */
1493 set_syntax_error (mismatch_detail
, idx
, NULL
);
1497 case AARCH64_OPND_CLASS_ADDRESS
:
1498 /* Check writeback. */
1499 switch (opcode
->iclass
)
1503 case ldstnapair_offs
:
1506 if (opnd
->addr
.writeback
== 1)
1508 set_syntax_error (mismatch_detail
, idx
,
1509 _("unexpected address writeback"));
1514 case ldstpair_indexed
:
1517 if (opnd
->addr
.writeback
== 0)
1519 set_syntax_error (mismatch_detail
, idx
,
1520 _("address writeback expected"));
1525 assert (opnd
->addr
.writeback
== 0);
1530 case AARCH64_OPND_ADDR_SIMM7
:
1531 /* Scaled signed 7 bits immediate offset. */
1532 /* Get the size of the data element that is accessed, which may be
1533 different from that of the source register size,
1534 e.g. in strb/ldrb. */
1535 size
= aarch64_get_qualifier_esize (opnd
->qualifier
);
1536 if (!value_in_range_p (opnd
->addr
.offset
.imm
, -64 * size
, 63 * size
))
1538 set_offset_out_of_range_error (mismatch_detail
, idx
,
1539 -64 * size
, 63 * size
);
1542 if (!value_aligned_p (opnd
->addr
.offset
.imm
, size
))
1544 set_unaligned_error (mismatch_detail
, idx
, size
);
1548 case AARCH64_OPND_ADDR_SIMM9
:
1549 /* Unscaled signed 9 bits immediate offset. */
1550 if (!value_in_range_p (opnd
->addr
.offset
.imm
, -256, 255))
1552 set_offset_out_of_range_error (mismatch_detail
, idx
, -256, 255);
1557 case AARCH64_OPND_ADDR_SIMM9_2
:
1558 /* Unscaled signed 9 bits immediate offset, which has to be negative
1560 size
= aarch64_get_qualifier_esize (qualifier
);
1561 if ((value_in_range_p (opnd
->addr
.offset
.imm
, 0, 255)
1562 && !value_aligned_p (opnd
->addr
.offset
.imm
, size
))
1563 || value_in_range_p (opnd
->addr
.offset
.imm
, -256, -1))
1565 set_other_error (mismatch_detail
, idx
,
1566 _("negative or unaligned offset expected"));
1569 case AARCH64_OPND_SIMD_ADDR_POST
:
1570 /* AdvSIMD load/store multiple structures, post-index. */
1572 if (opnd
->addr
.offset
.is_reg
)
1574 if (value_in_range_p (opnd
->addr
.offset
.regno
, 0, 30))
1578 set_other_error (mismatch_detail
, idx
,
1579 _("invalid register offset"));
1585 const aarch64_opnd_info
*prev
= &opnds
[idx
-1];
1586 unsigned num_bytes
; /* total number of bytes transferred. */
1587 /* The opcode dependent area stores the number of elements in
1588 each structure to be loaded/stored. */
1589 int is_ld1r
= get_opcode_dependent_value (opcode
) == 1;
1590 if (opcode
->operands
[0] == AARCH64_OPND_LVt_AL
)
1591 /* Special handling of loading single structure to all lane. */
1592 num_bytes
= (is_ld1r
? 1 : prev
->reglist
.num_regs
)
1593 * aarch64_get_qualifier_esize (prev
->qualifier
);
1595 num_bytes
= prev
->reglist
.num_regs
1596 * aarch64_get_qualifier_esize (prev
->qualifier
)
1597 * aarch64_get_qualifier_nelem (prev
->qualifier
);
1598 if ((int) num_bytes
!= opnd
->addr
.offset
.imm
)
1600 set_other_error (mismatch_detail
, idx
,
1601 _("invalid post-increment amount"));
1607 case AARCH64_OPND_ADDR_REGOFF
:
1608 /* Get the size of the data element that is accessed, which may be
1609 different from that of the source register size,
1610 e.g. in strb/ldrb. */
1611 size
= aarch64_get_qualifier_esize (opnd
->qualifier
);
1612 /* It is either no shift or shift by the binary logarithm of SIZE. */
1613 if (opnd
->shifter
.amount
!= 0
1614 && opnd
->shifter
.amount
!= (int)get_logsz (size
))
1616 set_other_error (mismatch_detail
, idx
,
1617 _("invalid shift amount"));
1620 /* Only UXTW, LSL, SXTW and SXTX are the accepted extending
1622 switch (opnd
->shifter
.kind
)
1624 case AARCH64_MOD_UXTW
:
1625 case AARCH64_MOD_LSL
:
1626 case AARCH64_MOD_SXTW
:
1627 case AARCH64_MOD_SXTX
: break;
1629 set_other_error (mismatch_detail
, idx
,
1630 _("invalid extend/shift operator"));
1635 case AARCH64_OPND_ADDR_UIMM12
:
1636 imm
= opnd
->addr
.offset
.imm
;
1637 /* Get the size of the data element that is accessed, which may be
1638 different from that of the source register size,
1639 e.g. in strb/ldrb. */
1640 size
= aarch64_get_qualifier_esize (qualifier
);
1641 if (!value_in_range_p (opnd
->addr
.offset
.imm
, 0, 4095 * size
))
1643 set_offset_out_of_range_error (mismatch_detail
, idx
,
1647 if (!value_aligned_p (opnd
->addr
.offset
.imm
, size
))
1649 set_unaligned_error (mismatch_detail
, idx
, size
);
1654 case AARCH64_OPND_ADDR_PCREL14
:
1655 case AARCH64_OPND_ADDR_PCREL19
:
1656 case AARCH64_OPND_ADDR_PCREL21
:
1657 case AARCH64_OPND_ADDR_PCREL26
:
1658 imm
= opnd
->imm
.value
;
1659 if (operand_need_shift_by_two (get_operand_from_code (type
)))
1661 /* The offset value in a PC-relative branch instruction is alway
1662 4-byte aligned and is encoded without the lowest 2 bits. */
1663 if (!value_aligned_p (imm
, 4))
1665 set_unaligned_error (mismatch_detail
, idx
, 4);
1668 /* Right shift by 2 so that we can carry out the following check
1672 size
= get_operand_fields_width (get_operand_from_code (type
));
1673 if (!value_fit_signed_field_p (imm
, size
))
1675 set_other_error (mismatch_detail
, idx
,
1676 _("immediate out of range"));
1681 case AARCH64_OPND_SVE_ADDR_RI_S4xVL
:
1682 case AARCH64_OPND_SVE_ADDR_RI_S4x2xVL
:
1683 case AARCH64_OPND_SVE_ADDR_RI_S4x3xVL
:
1684 case AARCH64_OPND_SVE_ADDR_RI_S4x4xVL
:
1688 assert (!opnd
->addr
.offset
.is_reg
);
1689 assert (opnd
->addr
.preind
);
1690 num
= 1 + get_operand_specific_data (&aarch64_operands
[type
]);
1693 if ((opnd
->addr
.offset
.imm
!= 0 && !opnd
->shifter
.operator_present
)
1694 || (opnd
->shifter
.operator_present
1695 && opnd
->shifter
.kind
!= AARCH64_MOD_MUL_VL
))
1697 set_other_error (mismatch_detail
, idx
,
1698 _("invalid addressing mode"));
1701 if (!value_in_range_p (opnd
->addr
.offset
.imm
, min_value
, max_value
))
1703 set_offset_out_of_range_error (mismatch_detail
, idx
,
1704 min_value
, max_value
);
1707 if (!value_aligned_p (opnd
->addr
.offset
.imm
, num
))
1709 set_unaligned_error (mismatch_detail
, idx
, num
);
1714 case AARCH64_OPND_SVE_ADDR_RI_S6xVL
:
1717 goto sve_imm_offset_vl
;
1719 case AARCH64_OPND_SVE_ADDR_RI_S9xVL
:
1722 goto sve_imm_offset_vl
;
1724 case AARCH64_OPND_SVE_ADDR_RI_U6
:
1725 case AARCH64_OPND_SVE_ADDR_RI_U6x2
:
1726 case AARCH64_OPND_SVE_ADDR_RI_U6x4
:
1727 case AARCH64_OPND_SVE_ADDR_RI_U6x8
:
1731 assert (!opnd
->addr
.offset
.is_reg
);
1732 assert (opnd
->addr
.preind
);
1733 num
= 1 << get_operand_specific_data (&aarch64_operands
[type
]);
1736 if (opnd
->shifter
.operator_present
1737 || opnd
->shifter
.amount_present
)
1739 set_other_error (mismatch_detail
, idx
,
1740 _("invalid addressing mode"));
1743 if (!value_in_range_p (opnd
->addr
.offset
.imm
, min_value
, max_value
))
1745 set_offset_out_of_range_error (mismatch_detail
, idx
,
1746 min_value
, max_value
);
1749 if (!value_aligned_p (opnd
->addr
.offset
.imm
, num
))
1751 set_unaligned_error (mismatch_detail
, idx
, num
);
1756 case AARCH64_OPND_SVE_ADDR_RR
:
1757 case AARCH64_OPND_SVE_ADDR_RR_LSL1
:
1758 case AARCH64_OPND_SVE_ADDR_RR_LSL2
:
1759 case AARCH64_OPND_SVE_ADDR_RR_LSL3
:
1760 case AARCH64_OPND_SVE_ADDR_RX
:
1761 case AARCH64_OPND_SVE_ADDR_RX_LSL1
:
1762 case AARCH64_OPND_SVE_ADDR_RX_LSL2
:
1763 case AARCH64_OPND_SVE_ADDR_RX_LSL3
:
1764 case AARCH64_OPND_SVE_ADDR_RZ
:
1765 case AARCH64_OPND_SVE_ADDR_RZ_LSL1
:
1766 case AARCH64_OPND_SVE_ADDR_RZ_LSL2
:
1767 case AARCH64_OPND_SVE_ADDR_RZ_LSL3
:
1768 modifiers
= 1 << AARCH64_MOD_LSL
;
1770 assert (opnd
->addr
.offset
.is_reg
);
1771 assert (opnd
->addr
.preind
);
1772 if ((aarch64_operands
[type
].flags
& OPD_F_NO_ZR
) != 0
1773 && opnd
->addr
.offset
.regno
== 31)
1775 set_other_error (mismatch_detail
, idx
,
1776 _("index register xzr is not allowed"));
1779 if (((1 << opnd
->shifter
.kind
) & modifiers
) == 0
1780 || (opnd
->shifter
.amount
1781 != get_operand_specific_data (&aarch64_operands
[type
])))
1783 set_other_error (mismatch_detail
, idx
,
1784 _("invalid addressing mode"));
1789 case AARCH64_OPND_SVE_ADDR_RZ_XTW_14
:
1790 case AARCH64_OPND_SVE_ADDR_RZ_XTW_22
:
1791 case AARCH64_OPND_SVE_ADDR_RZ_XTW1_14
:
1792 case AARCH64_OPND_SVE_ADDR_RZ_XTW1_22
:
1793 case AARCH64_OPND_SVE_ADDR_RZ_XTW2_14
:
1794 case AARCH64_OPND_SVE_ADDR_RZ_XTW2_22
:
1795 case AARCH64_OPND_SVE_ADDR_RZ_XTW3_14
:
1796 case AARCH64_OPND_SVE_ADDR_RZ_XTW3_22
:
1797 modifiers
= (1 << AARCH64_MOD_SXTW
) | (1 << AARCH64_MOD_UXTW
);
1798 goto sve_rr_operand
;
1800 case AARCH64_OPND_SVE_ADDR_ZI_U5
:
1801 case AARCH64_OPND_SVE_ADDR_ZI_U5x2
:
1802 case AARCH64_OPND_SVE_ADDR_ZI_U5x4
:
1803 case AARCH64_OPND_SVE_ADDR_ZI_U5x8
:
1806 goto sve_imm_offset
;
1808 case AARCH64_OPND_SVE_ADDR_ZZ_LSL
:
1809 modifiers
= 1 << AARCH64_MOD_LSL
;
1811 assert (opnd
->addr
.offset
.is_reg
);
1812 assert (opnd
->addr
.preind
);
1813 if (((1 << opnd
->shifter
.kind
) & modifiers
) == 0
1814 || opnd
->shifter
.amount
< 0
1815 || opnd
->shifter
.amount
> 3)
1817 set_other_error (mismatch_detail
, idx
,
1818 _("invalid addressing mode"));
1823 case AARCH64_OPND_SVE_ADDR_ZZ_SXTW
:
1824 modifiers
= (1 << AARCH64_MOD_SXTW
);
1825 goto sve_zz_operand
;
1827 case AARCH64_OPND_SVE_ADDR_ZZ_UXTW
:
1828 modifiers
= 1 << AARCH64_MOD_UXTW
;
1829 goto sve_zz_operand
;
1836 case AARCH64_OPND_CLASS_SIMD_REGLIST
:
1837 if (type
== AARCH64_OPND_LEt
)
1839 /* Get the upper bound for the element index. */
1840 num
= 16 / aarch64_get_qualifier_esize (qualifier
) - 1;
1841 if (!value_in_range_p (opnd
->reglist
.index
, 0, num
))
1843 set_elem_idx_out_of_range_error (mismatch_detail
, idx
, 0, num
);
1847 /* The opcode dependent area stores the number of elements in
1848 each structure to be loaded/stored. */
1849 num
= get_opcode_dependent_value (opcode
);
1852 case AARCH64_OPND_LVt
:
1853 assert (num
>= 1 && num
<= 4);
1854 /* Unless LD1/ST1, the number of registers should be equal to that
1855 of the structure elements. */
1856 if (num
!= 1 && opnd
->reglist
.num_regs
!= num
)
1858 set_reg_list_error (mismatch_detail
, idx
, num
);
1862 case AARCH64_OPND_LVt_AL
:
1863 case AARCH64_OPND_LEt
:
1864 assert (num
>= 1 && num
<= 4);
1865 /* The number of registers should be equal to that of the structure
1867 if (opnd
->reglist
.num_regs
!= num
)
1869 set_reg_list_error (mismatch_detail
, idx
, num
);
1878 case AARCH64_OPND_CLASS_IMMEDIATE
:
1879 /* Constraint check on immediate operand. */
1880 imm
= opnd
->imm
.value
;
1881 /* E.g. imm_0_31 constrains value to be 0..31. */
1882 if (qualifier_value_in_range_constraint_p (qualifier
)
1883 && !value_in_range_p (imm
, get_lower_bound (qualifier
),
1884 get_upper_bound (qualifier
)))
1886 set_imm_out_of_range_error (mismatch_detail
, idx
,
1887 get_lower_bound (qualifier
),
1888 get_upper_bound (qualifier
));
1894 case AARCH64_OPND_AIMM
:
1895 if (opnd
->shifter
.kind
!= AARCH64_MOD_LSL
)
1897 set_other_error (mismatch_detail
, idx
,
1898 _("invalid shift operator"));
1901 if (opnd
->shifter
.amount
!= 0 && opnd
->shifter
.amount
!= 12)
1903 set_other_error (mismatch_detail
, idx
,
1904 _("shift amount expected to be 0 or 12"));
1907 if (!value_fit_unsigned_field_p (opnd
->imm
.value
, 12))
1909 set_other_error (mismatch_detail
, idx
,
1910 _("immediate out of range"));
1915 case AARCH64_OPND_HALF
:
1916 assert (idx
== 1 && opnds
[0].type
== AARCH64_OPND_Rd
);
1917 if (opnd
->shifter
.kind
!= AARCH64_MOD_LSL
)
1919 set_other_error (mismatch_detail
, idx
,
1920 _("invalid shift operator"));
1923 size
= aarch64_get_qualifier_esize (opnds
[0].qualifier
);
1924 if (!value_aligned_p (opnd
->shifter
.amount
, 16))
1926 set_other_error (mismatch_detail
, idx
,
1927 _("shift amount should be a multiple of 16"));
1930 if (!value_in_range_p (opnd
->shifter
.amount
, 0, size
* 8 - 16))
1932 set_sft_amount_out_of_range_error (mismatch_detail
, idx
,
1936 if (opnd
->imm
.value
< 0)
1938 set_other_error (mismatch_detail
, idx
,
1939 _("negative immediate value not allowed"));
1942 if (!value_fit_unsigned_field_p (opnd
->imm
.value
, 16))
1944 set_other_error (mismatch_detail
, idx
,
1945 _("immediate out of range"));
1950 case AARCH64_OPND_IMM_MOV
:
1952 int esize
= aarch64_get_qualifier_esize (opnds
[0].qualifier
);
1953 imm
= opnd
->imm
.value
;
1957 case OP_MOV_IMM_WIDEN
:
1959 /* Fall through... */
1960 case OP_MOV_IMM_WIDE
:
1961 if (!aarch64_wide_constant_p (imm
, esize
== 4, NULL
))
1963 set_other_error (mismatch_detail
, idx
,
1964 _("immediate out of range"));
1968 case OP_MOV_IMM_LOG
:
1969 if (!aarch64_logical_immediate_p (imm
, esize
, NULL
))
1971 set_other_error (mismatch_detail
, idx
,
1972 _("immediate out of range"));
1983 case AARCH64_OPND_NZCV
:
1984 case AARCH64_OPND_CCMP_IMM
:
1985 case AARCH64_OPND_EXCEPTION
:
1986 case AARCH64_OPND_UIMM4
:
1987 case AARCH64_OPND_UIMM7
:
1988 case AARCH64_OPND_UIMM3_OP1
:
1989 case AARCH64_OPND_UIMM3_OP2
:
1990 case AARCH64_OPND_SVE_UIMM3
:
1991 case AARCH64_OPND_SVE_UIMM7
:
1992 case AARCH64_OPND_SVE_UIMM8
:
1993 case AARCH64_OPND_SVE_UIMM8_53
:
1994 size
= get_operand_fields_width (get_operand_from_code (type
));
1996 if (!value_fit_unsigned_field_p (opnd
->imm
.value
, size
))
1998 set_imm_out_of_range_error (mismatch_detail
, idx
, 0,
2004 case AARCH64_OPND_SIMM5
:
2005 case AARCH64_OPND_SVE_SIMM5
:
2006 case AARCH64_OPND_SVE_SIMM5B
:
2007 case AARCH64_OPND_SVE_SIMM6
:
2008 case AARCH64_OPND_SVE_SIMM8
:
2009 size
= get_operand_fields_width (get_operand_from_code (type
));
2011 if (!value_fit_signed_field_p (opnd
->imm
.value
, size
))
2013 set_imm_out_of_range_error (mismatch_detail
, idx
,
2015 (1 << (size
- 1)) - 1);
2020 case AARCH64_OPND_WIDTH
:
2021 assert (idx
> 1 && opnds
[idx
-1].type
== AARCH64_OPND_IMM
2022 && opnds
[0].type
== AARCH64_OPND_Rd
);
2023 size
= get_upper_bound (qualifier
);
2024 if (opnd
->imm
.value
+ opnds
[idx
-1].imm
.value
> size
)
2025 /* lsb+width <= reg.size */
2027 set_imm_out_of_range_error (mismatch_detail
, idx
, 1,
2028 size
- opnds
[idx
-1].imm
.value
);
2033 case AARCH64_OPND_LIMM
:
2034 case AARCH64_OPND_SVE_LIMM
:
2036 int esize
= aarch64_get_qualifier_esize (opnds
[0].qualifier
);
2037 uint64_t uimm
= opnd
->imm
.value
;
2038 if (opcode
->op
== OP_BIC
)
2040 if (aarch64_logical_immediate_p (uimm
, esize
, NULL
) == FALSE
)
2042 set_other_error (mismatch_detail
, idx
,
2043 _("immediate out of range"));
2049 case AARCH64_OPND_IMM0
:
2050 case AARCH64_OPND_FPIMM0
:
2051 if (opnd
->imm
.value
!= 0)
2053 set_other_error (mismatch_detail
, idx
,
2054 _("immediate zero expected"));
2059 case AARCH64_OPND_SHLL_IMM
:
2061 size
= 8 * aarch64_get_qualifier_esize (opnds
[idx
- 1].qualifier
);
2062 if (opnd
->imm
.value
!= size
)
2064 set_other_error (mismatch_detail
, idx
,
2065 _("invalid shift amount"));
2070 case AARCH64_OPND_IMM_VLSL
:
2071 size
= aarch64_get_qualifier_esize (qualifier
);
2072 if (!value_in_range_p (opnd
->imm
.value
, 0, size
* 8 - 1))
2074 set_imm_out_of_range_error (mismatch_detail
, idx
, 0,
2080 case AARCH64_OPND_IMM_VLSR
:
2081 size
= aarch64_get_qualifier_esize (qualifier
);
2082 if (!value_in_range_p (opnd
->imm
.value
, 1, size
* 8))
2084 set_imm_out_of_range_error (mismatch_detail
, idx
, 1, size
* 8);
2089 case AARCH64_OPND_SIMD_IMM
:
2090 case AARCH64_OPND_SIMD_IMM_SFT
:
2091 /* Qualifier check. */
2094 case AARCH64_OPND_QLF_LSL
:
2095 if (opnd
->shifter
.kind
!= AARCH64_MOD_LSL
)
2097 set_other_error (mismatch_detail
, idx
,
2098 _("invalid shift operator"));
2102 case AARCH64_OPND_QLF_MSL
:
2103 if (opnd
->shifter
.kind
!= AARCH64_MOD_MSL
)
2105 set_other_error (mismatch_detail
, idx
,
2106 _("invalid shift operator"));
2110 case AARCH64_OPND_QLF_NIL
:
2111 if (opnd
->shifter
.kind
!= AARCH64_MOD_NONE
)
2113 set_other_error (mismatch_detail
, idx
,
2114 _("shift is not permitted"));
2122 /* Is the immediate valid? */
2124 if (aarch64_get_qualifier_esize (opnds
[0].qualifier
) != 8)
2126 /* uimm8 or simm8 */
2127 if (!value_in_range_p (opnd
->imm
.value
, -128, 255))
2129 set_imm_out_of_range_error (mismatch_detail
, idx
, -128, 255);
2133 else if (aarch64_shrink_expanded_imm8 (opnd
->imm
.value
) < 0)
2136 'aaaaaaaabbbbbbbbccccccccddddddddeeeeeeee
2137 ffffffffgggggggghhhhhhhh'. */
2138 set_other_error (mismatch_detail
, idx
,
2139 _("invalid value for immediate"));
2142 /* Is the shift amount valid? */
2143 switch (opnd
->shifter
.kind
)
2145 case AARCH64_MOD_LSL
:
2146 size
= aarch64_get_qualifier_esize (opnds
[0].qualifier
);
2147 if (!value_in_range_p (opnd
->shifter
.amount
, 0, (size
- 1) * 8))
2149 set_sft_amount_out_of_range_error (mismatch_detail
, idx
, 0,
2153 if (!value_aligned_p (opnd
->shifter
.amount
, 8))
2155 set_unaligned_error (mismatch_detail
, idx
, 8);
2159 case AARCH64_MOD_MSL
:
2160 /* Only 8 and 16 are valid shift amount. */
2161 if (opnd
->shifter
.amount
!= 8 && opnd
->shifter
.amount
!= 16)
2163 set_other_error (mismatch_detail
, idx
,
2164 _("shift amount expected to be 0 or 16"));
2169 if (opnd
->shifter
.kind
!= AARCH64_MOD_NONE
)
2171 set_other_error (mismatch_detail
, idx
,
2172 _("invalid shift operator"));
2179 case AARCH64_OPND_FPIMM
:
2180 case AARCH64_OPND_SIMD_FPIMM
:
2181 if (opnd
->imm
.is_fp
== 0)
2183 set_other_error (mismatch_detail
, idx
,
2184 _("floating-point immediate expected"));
2187 /* The value is expected to be an 8-bit floating-point constant with
2188 sign, 3-bit exponent and normalized 4 bits of precision, encoded
2189 in "a:b:c:d:e:f:g:h" or FLD_imm8 (depending on the type of the
2191 if (!value_in_range_p (opnd
->imm
.value
, 0, 255))
2193 set_other_error (mismatch_detail
, idx
,
2194 _("immediate out of range"));
2197 if (opnd
->shifter
.kind
!= AARCH64_MOD_NONE
)
2199 set_other_error (mismatch_detail
, idx
,
2200 _("invalid shift operator"));
2205 case AARCH64_OPND_SVE_AIMM
:
2208 assert (opnd
->shifter
.kind
== AARCH64_MOD_LSL
);
2209 size
= aarch64_get_qualifier_esize (opnds
[0].qualifier
);
2210 mask
= ~((uint64_t) -1 << (size
* 4) << (size
* 4));
2211 uvalue
= opnd
->imm
.value
;
2212 shift
= opnd
->shifter
.amount
;
2217 set_other_error (mismatch_detail
, idx
,
2218 _("no shift amount allowed for"
2219 " 8-bit constants"));
2225 if (shift
!= 0 && shift
!= 8)
2227 set_other_error (mismatch_detail
, idx
,
2228 _("shift amount must be 0 or 8"));
2231 if (shift
== 0 && (uvalue
& 0xff) == 0)
2234 uvalue
= (int64_t) uvalue
/ 256;
2238 if ((uvalue
& mask
) != uvalue
&& (uvalue
| ~mask
) != uvalue
)
2240 set_other_error (mismatch_detail
, idx
,
2241 _("immediate too big for element size"));
2244 uvalue
= (uvalue
- min_value
) & mask
;
2247 set_other_error (mismatch_detail
, idx
,
2248 _("invalid arithmetic immediate"));
2253 case AARCH64_OPND_SVE_ASIMM
:
2257 case AARCH64_OPND_SVE_INV_LIMM
:
2259 int esize
= aarch64_get_qualifier_esize (opnds
[0].qualifier
);
2260 uint64_t uimm
= ~opnd
->imm
.value
;
2261 if (!aarch64_logical_immediate_p (uimm
, esize
, NULL
))
2263 set_other_error (mismatch_detail
, idx
,
2264 _("immediate out of range"));
2270 case AARCH64_OPND_SVE_LIMM_MOV
:
2272 int esize
= aarch64_get_qualifier_esize (opnds
[0].qualifier
);
2273 uint64_t uimm
= opnd
->imm
.value
;
2274 if (!aarch64_logical_immediate_p (uimm
, esize
, NULL
))
2276 set_other_error (mismatch_detail
, idx
,
2277 _("immediate out of range"));
2280 if (!aarch64_sve_dupm_mov_immediate_p (uimm
, esize
))
2282 set_other_error (mismatch_detail
, idx
,
2283 _("invalid replicated MOV immediate"));
2289 case AARCH64_OPND_SVE_PATTERN_SCALED
:
2290 assert (opnd
->shifter
.kind
== AARCH64_MOD_MUL
);
2291 if (!value_in_range_p (opnd
->shifter
.amount
, 1, 16))
2293 set_multiplier_out_of_range_error (mismatch_detail
, idx
, 1, 16);
2298 case AARCH64_OPND_SVE_SHLIMM_PRED
:
2299 case AARCH64_OPND_SVE_SHLIMM_UNPRED
:
2300 size
= aarch64_get_qualifier_esize (opnds
[idx
- 1].qualifier
);
2301 if (!value_in_range_p (opnd
->imm
.value
, 0, 8 * size
- 1))
2303 set_imm_out_of_range_error (mismatch_detail
, idx
,
2309 case AARCH64_OPND_SVE_SHRIMM_PRED
:
2310 case AARCH64_OPND_SVE_SHRIMM_UNPRED
:
2311 size
= aarch64_get_qualifier_esize (opnds
[idx
- 1].qualifier
);
2312 if (!value_in_range_p (opnd
->imm
.value
, 1, 8 * size
))
2314 set_imm_out_of_range_error (mismatch_detail
, idx
, 1, 8 * size
);
2324 case AARCH64_OPND_CLASS_CP_REG
:
2325 /* Cn or Cm: 4-bit opcode field named for historical reasons.
2326 valid range: C0 - C15. */
2327 if (opnd
->reg
.regno
> 15)
2329 set_regno_out_of_range_error (mismatch_detail
, idx
, 0, 15);
2334 case AARCH64_OPND_CLASS_SYSTEM
:
2337 case AARCH64_OPND_PSTATEFIELD
:
2338 assert (idx
== 0 && opnds
[1].type
== AARCH64_OPND_UIMM4
);
2341 The immediate must be #0 or #1. */
2342 if ((opnd
->pstatefield
== 0x03 /* UAO. */
2343 || opnd
->pstatefield
== 0x04) /* PAN. */
2344 && opnds
[1].imm
.value
> 1)
2346 set_imm_out_of_range_error (mismatch_detail
, idx
, 0, 1);
2349 /* MSR SPSel, #uimm4
2350 Uses uimm4 as a control value to select the stack pointer: if
2351 bit 0 is set it selects the current exception level's stack
2352 pointer, if bit 0 is clear it selects shared EL0 stack pointer.
2353 Bits 1 to 3 of uimm4 are reserved and should be zero. */
2354 if (opnd
->pstatefield
== 0x05 /* spsel */ && opnds
[1].imm
.value
> 1)
2356 set_imm_out_of_range_error (mismatch_detail
, idx
, 0, 1);
2365 case AARCH64_OPND_CLASS_SIMD_ELEMENT
:
2366 /* Get the upper bound for the element index. */
2367 num
= 16 / aarch64_get_qualifier_esize (qualifier
) - 1;
2368 /* Index out-of-range. */
2369 if (!value_in_range_p (opnd
->reglane
.index
, 0, num
))
2371 set_elem_idx_out_of_range_error (mismatch_detail
, idx
, 0, num
);
2374 /* SMLAL<Q> <Vd>.<Ta>, <Vn>.<Tb>, <Vm>.<Ts>[<index>].
2375 <Vm> Is the vector register (V0-V31) or (V0-V15), whose
2376 number is encoded in "size:M:Rm":
2382 if (type
== AARCH64_OPND_Em
&& qualifier
== AARCH64_OPND_QLF_S_H
2383 && !value_in_range_p (opnd
->reglane
.regno
, 0, 15))
2385 set_regno_out_of_range_error (mismatch_detail
, idx
, 0, 15);
2390 case AARCH64_OPND_CLASS_MODIFIED_REG
:
2391 assert (idx
== 1 || idx
== 2);
2394 case AARCH64_OPND_Rm_EXT
:
2395 if (aarch64_extend_operator_p (opnd
->shifter
.kind
) == FALSE
2396 && opnd
->shifter
.kind
!= AARCH64_MOD_LSL
)
2398 set_other_error (mismatch_detail
, idx
,
2399 _("extend operator expected"));
2402 /* It is not optional unless at least one of "Rd" or "Rn" is '11111'
2403 (i.e. SP), in which case it defaults to LSL. The LSL alias is
2404 only valid when "Rd" or "Rn" is '11111', and is preferred in that
2406 if (!aarch64_stack_pointer_p (opnds
+ 0)
2407 && (idx
!= 2 || !aarch64_stack_pointer_p (opnds
+ 1)))
2409 if (!opnd
->shifter
.operator_present
)
2411 set_other_error (mismatch_detail
, idx
,
2412 _("missing extend operator"));
2415 else if (opnd
->shifter
.kind
== AARCH64_MOD_LSL
)
2417 set_other_error (mismatch_detail
, idx
,
2418 _("'LSL' operator not allowed"));
2422 assert (opnd
->shifter
.operator_present
/* Default to LSL. */
2423 || opnd
->shifter
.kind
== AARCH64_MOD_LSL
);
2424 if (!value_in_range_p (opnd
->shifter
.amount
, 0, 4))
2426 set_sft_amount_out_of_range_error (mismatch_detail
, idx
, 0, 4);
2429 /* In the 64-bit form, the final register operand is written as Wm
2430 for all but the (possibly omitted) UXTX/LSL and SXTX
2432 N.B. GAS allows X register to be used with any operator as a
2433 programming convenience. */
2434 if (qualifier
== AARCH64_OPND_QLF_X
2435 && opnd
->shifter
.kind
!= AARCH64_MOD_LSL
2436 && opnd
->shifter
.kind
!= AARCH64_MOD_UXTX
2437 && opnd
->shifter
.kind
!= AARCH64_MOD_SXTX
)
2439 set_other_error (mismatch_detail
, idx
, _("W register expected"));
2444 case AARCH64_OPND_Rm_SFT
:
2445 /* ROR is not available to the shifted register operand in
2446 arithmetic instructions. */
2447 if (aarch64_shift_operator_p (opnd
->shifter
.kind
) == FALSE
)
2449 set_other_error (mismatch_detail
, idx
,
2450 _("shift operator expected"));
2453 if (opnd
->shifter
.kind
== AARCH64_MOD_ROR
2454 && opcode
->iclass
!= log_shift
)
2456 set_other_error (mismatch_detail
, idx
,
2457 _("'ROR' operator not allowed"));
2460 num
= qualifier
== AARCH64_OPND_QLF_W
? 31 : 63;
2461 if (!value_in_range_p (opnd
->shifter
.amount
, 0, num
))
2463 set_sft_amount_out_of_range_error (mismatch_detail
, idx
, 0, num
);
2480 /* Main entrypoint for the operand constraint checking.
2482 Return 1 if operands of *INST meet the constraint applied by the operand
2483 codes and operand qualifiers; otherwise return 0 and if MISMATCH_DETAIL is
2484 not NULL, return the detail of the error in *MISMATCH_DETAIL. N.B. when
2485 adding more constraint checking, make sure MISMATCH_DETAIL->KIND is set
2486 with a proper error kind rather than AARCH64_OPDE_NIL (GAS asserts non-NIL
2487 error kind when it is notified that an instruction does not pass the check).
2489 Un-determined operand qualifiers may get established during the process. */
2492 aarch64_match_operands_constraint (aarch64_inst
*inst
,
2493 aarch64_operand_error
*mismatch_detail
)
2497 DEBUG_TRACE ("enter");
2499 /* Check for cases where a source register needs to be the same as the
2500 destination register. Do this before matching qualifiers since if
2501 an instruction has both invalid tying and invalid qualifiers,
2502 the error about qualifiers would suggest several alternative
2503 instructions that also have invalid tying. */
2504 i
= inst
->opcode
->tied_operand
;
2505 if (i
> 0 && (inst
->operands
[0].reg
.regno
!= inst
->operands
[i
].reg
.regno
))
2507 if (mismatch_detail
)
2509 mismatch_detail
->kind
= AARCH64_OPDE_UNTIED_OPERAND
;
2510 mismatch_detail
->index
= i
;
2511 mismatch_detail
->error
= NULL
;
2516 /* Match operands' qualifier.
2517 *INST has already had qualifier establish for some, if not all, of
2518 its operands; we need to find out whether these established
2519 qualifiers match one of the qualifier sequence in
2520 INST->OPCODE->QUALIFIERS_LIST. If yes, we will assign each operand
2521 with the corresponding qualifier in such a sequence.
2522 Only basic operand constraint checking is done here; the more thorough
2523 constraint checking will carried out by operand_general_constraint_met_p,
2524 which has be to called after this in order to get all of the operands'
2525 qualifiers established. */
2526 if (match_operands_qualifier (inst
, TRUE
/* update_p */) == 0)
2528 DEBUG_TRACE ("FAIL on operand qualifier matching");
2529 if (mismatch_detail
)
2531 /* Return an error type to indicate that it is the qualifier
2532 matching failure; we don't care about which operand as there
2533 are enough information in the opcode table to reproduce it. */
2534 mismatch_detail
->kind
= AARCH64_OPDE_INVALID_VARIANT
;
2535 mismatch_detail
->index
= -1;
2536 mismatch_detail
->error
= NULL
;
2541 /* Match operands' constraint. */
2542 for (i
= 0; i
< AARCH64_MAX_OPND_NUM
; ++i
)
2544 enum aarch64_opnd type
= inst
->opcode
->operands
[i
];
2545 if (type
== AARCH64_OPND_NIL
)
2547 if (inst
->operands
[i
].skip
)
2549 DEBUG_TRACE ("skip the incomplete operand %d", i
);
2552 if (operand_general_constraint_met_p (inst
->operands
, i
, type
,
2553 inst
->opcode
, mismatch_detail
) == 0)
2555 DEBUG_TRACE ("FAIL on operand %d", i
);
2560 DEBUG_TRACE ("PASS");
2565 /* Replace INST->OPCODE with OPCODE and return the replaced OPCODE.
2566 Also updates the TYPE of each INST->OPERANDS with the corresponding
2567 value of OPCODE->OPERANDS.
2569 Note that some operand qualifiers may need to be manually cleared by
2570 the caller before it further calls the aarch64_opcode_encode; by
2571 doing this, it helps the qualifier matching facilities work
2574 const aarch64_opcode
*
2575 aarch64_replace_opcode (aarch64_inst
*inst
, const aarch64_opcode
*opcode
)
2578 const aarch64_opcode
*old
= inst
->opcode
;
2580 inst
->opcode
= opcode
;
2582 /* Update the operand types. */
2583 for (i
= 0; i
< AARCH64_MAX_OPND_NUM
; ++i
)
2585 inst
->operands
[i
].type
= opcode
->operands
[i
];
2586 if (opcode
->operands
[i
] == AARCH64_OPND_NIL
)
2590 DEBUG_TRACE ("replace %s with %s", old
->name
, opcode
->name
);
2596 aarch64_operand_index (const enum aarch64_opnd
*operands
, enum aarch64_opnd operand
)
2599 for (i
= 0; i
< AARCH64_MAX_OPND_NUM
; ++i
)
2600 if (operands
[i
] == operand
)
2602 else if (operands
[i
] == AARCH64_OPND_NIL
)
2607 /* R0...R30, followed by FOR31. */
2608 #define BANK(R, FOR31) \
2609 { R (0), R (1), R (2), R (3), R (4), R (5), R (6), R (7), \
2610 R (8), R (9), R (10), R (11), R (12), R (13), R (14), R (15), \
2611 R (16), R (17), R (18), R (19), R (20), R (21), R (22), R (23), \
2612 R (24), R (25), R (26), R (27), R (28), R (29), R (30), FOR31 }
2613 /* [0][0] 32-bit integer regs with sp Wn
2614 [0][1] 64-bit integer regs with sp Xn sf=1
2615 [1][0] 32-bit integer regs with #0 Wn
2616 [1][1] 64-bit integer regs with #0 Xn sf=1 */
2617 static const char *int_reg
[2][2][32] = {
2618 #define R32(X) "w" #X
2619 #define R64(X) "x" #X
2620 { BANK (R32
, "wsp"), BANK (R64
, "sp") },
2621 { BANK (R32
, "wzr"), BANK (R64
, "xzr") }
2626 /* Names of the SVE vector registers, first with .S suffixes,
2627 then with .D suffixes. */
2629 static const char *sve_reg
[2][32] = {
2630 #define ZS(X) "z" #X ".s"
2631 #define ZD(X) "z" #X ".d"
2632 BANK (ZS
, ZS (31)), BANK (ZD
, ZD (31))
2638 /* Return the integer register name.
2639 if SP_REG_P is not 0, R31 is an SP reg, other R31 is the zero reg. */
2641 static inline const char *
2642 get_int_reg_name (int regno
, aarch64_opnd_qualifier_t qualifier
, int sp_reg_p
)
2644 const int has_zr
= sp_reg_p
? 0 : 1;
2645 const int is_64
= aarch64_get_qualifier_esize (qualifier
) == 4 ? 0 : 1;
2646 return int_reg
[has_zr
][is_64
][regno
];
2649 /* Like get_int_reg_name, but IS_64 is always 1. */
2651 static inline const char *
2652 get_64bit_int_reg_name (int regno
, int sp_reg_p
)
2654 const int has_zr
= sp_reg_p
? 0 : 1;
2655 return int_reg
[has_zr
][1][regno
];
2658 /* Get the name of the integer offset register in OPND, using the shift type
2659 to decide whether it's a word or doubleword. */
2661 static inline const char *
2662 get_offset_int_reg_name (const aarch64_opnd_info
*opnd
)
2664 switch (opnd
->shifter
.kind
)
2666 case AARCH64_MOD_UXTW
:
2667 case AARCH64_MOD_SXTW
:
2668 return get_int_reg_name (opnd
->addr
.offset
.regno
, AARCH64_OPND_QLF_W
, 0);
2670 case AARCH64_MOD_LSL
:
2671 case AARCH64_MOD_SXTX
:
2672 return get_int_reg_name (opnd
->addr
.offset
.regno
, AARCH64_OPND_QLF_X
, 0);
2679 /* Get the name of the SVE vector offset register in OPND, using the operand
2680 qualifier to decide whether the suffix should be .S or .D. */
2682 static inline const char *
2683 get_addr_sve_reg_name (int regno
, aarch64_opnd_qualifier_t qualifier
)
2685 assert (qualifier
== AARCH64_OPND_QLF_S_S
2686 || qualifier
== AARCH64_OPND_QLF_S_D
);
2687 return sve_reg
[qualifier
== AARCH64_OPND_QLF_S_D
][regno
];
2690 /* Types for expanding an encoded 8-bit value to a floating-point value. */
2710 /* IMM8 is an 8-bit floating-point constant with sign, 3-bit exponent and
2711 normalized 4 bits of precision, encoded in "a:b:c:d:e:f:g:h" or FLD_imm8
2712 (depending on the type of the instruction). IMM8 will be expanded to a
2713 single-precision floating-point value (SIZE == 4) or a double-precision
2714 floating-point value (SIZE == 8). A half-precision floating-point value
2715 (SIZE == 2) is expanded to a single-precision floating-point value. The
2716 expanded value is returned. */
2719 expand_fp_imm (int size
, uint32_t imm8
)
2722 uint32_t imm8_7
, imm8_6_0
, imm8_6
, imm8_6_repl4
;
2724 imm8_7
= (imm8
>> 7) & 0x01; /* imm8<7> */
2725 imm8_6_0
= imm8
& 0x7f; /* imm8<6:0> */
2726 imm8_6
= imm8_6_0
>> 6; /* imm8<6> */
2727 imm8_6_repl4
= (imm8_6
<< 3) | (imm8_6
<< 2)
2728 | (imm8_6
<< 1) | imm8_6
; /* Replicate(imm8<6>,4) */
2731 imm
= (imm8_7
<< (63-32)) /* imm8<7> */
2732 | ((imm8_6
^ 1) << (62-32)) /* NOT(imm8<6) */
2733 | (imm8_6_repl4
<< (58-32)) | (imm8_6
<< (57-32))
2734 | (imm8_6
<< (56-32)) | (imm8_6
<< (55-32)) /* Replicate(imm8<6>,7) */
2735 | (imm8_6_0
<< (48-32)); /* imm8<6>:imm8<5:0> */
2738 else if (size
== 4 || size
== 2)
2740 imm
= (imm8_7
<< 31) /* imm8<7> */
2741 | ((imm8_6
^ 1) << 30) /* NOT(imm8<6>) */
2742 | (imm8_6_repl4
<< 26) /* Replicate(imm8<6>,4) */
2743 | (imm8_6_0
<< 19); /* imm8<6>:imm8<5:0> */
2747 /* An unsupported size. */
2754 /* Produce the string representation of the register list operand *OPND
2755 in the buffer pointed by BUF of size SIZE. PREFIX is the part of
2756 the register name that comes before the register number, such as "v". */
2758 print_register_list (char *buf
, size_t size
, const aarch64_opnd_info
*opnd
,
2761 const int num_regs
= opnd
->reglist
.num_regs
;
2762 const int first_reg
= opnd
->reglist
.first_regno
;
2763 const int last_reg
= (first_reg
+ num_regs
- 1) & 0x1f;
2764 const char *qlf_name
= aarch64_get_qualifier_name (opnd
->qualifier
);
2765 char tb
[8]; /* Temporary buffer. */
2767 assert (opnd
->type
!= AARCH64_OPND_LEt
|| opnd
->reglist
.has_index
);
2768 assert (num_regs
>= 1 && num_regs
<= 4);
2770 /* Prepare the index if any. */
2771 if (opnd
->reglist
.has_index
)
2772 snprintf (tb
, 8, "[%" PRIi64
"]", opnd
->reglist
.index
);
2776 /* The hyphenated form is preferred for disassembly if there are
2777 more than two registers in the list, and the register numbers
2778 are monotonically increasing in increments of one. */
2779 if (num_regs
> 2 && last_reg
> first_reg
)
2780 snprintf (buf
, size
, "{%s%d.%s-%s%d.%s}%s", prefix
, first_reg
, qlf_name
,
2781 prefix
, last_reg
, qlf_name
, tb
);
2784 const int reg0
= first_reg
;
2785 const int reg1
= (first_reg
+ 1) & 0x1f;
2786 const int reg2
= (first_reg
+ 2) & 0x1f;
2787 const int reg3
= (first_reg
+ 3) & 0x1f;
2792 snprintf (buf
, size
, "{%s%d.%s}%s", prefix
, reg0
, qlf_name
, tb
);
2795 snprintf (buf
, size
, "{%s%d.%s, %s%d.%s}%s", prefix
, reg0
, qlf_name
,
2796 prefix
, reg1
, qlf_name
, tb
);
2799 snprintf (buf
, size
, "{%s%d.%s, %s%d.%s, %s%d.%s}%s",
2800 prefix
, reg0
, qlf_name
, prefix
, reg1
, qlf_name
,
2801 prefix
, reg2
, qlf_name
, tb
);
2804 snprintf (buf
, size
, "{%s%d.%s, %s%d.%s, %s%d.%s, %s%d.%s}%s",
2805 prefix
, reg0
, qlf_name
, prefix
, reg1
, qlf_name
,
2806 prefix
, reg2
, qlf_name
, prefix
, reg3
, qlf_name
, tb
);
2812 /* Print the register+immediate address in OPND to BUF, which has SIZE
2813 characters. BASE is the name of the base register. */
2816 print_immediate_offset_address (char *buf
, size_t size
,
2817 const aarch64_opnd_info
*opnd
,
2820 if (opnd
->addr
.writeback
)
2822 if (opnd
->addr
.preind
)
2823 snprintf (buf
, size
, "[%s,#%d]!", base
, opnd
->addr
.offset
.imm
);
2825 snprintf (buf
, size
, "[%s],#%d", base
, opnd
->addr
.offset
.imm
);
2829 if (opnd
->shifter
.operator_present
)
2831 assert (opnd
->shifter
.kind
== AARCH64_MOD_MUL_VL
);
2832 snprintf (buf
, size
, "[%s,#%d,mul vl]",
2833 base
, opnd
->addr
.offset
.imm
);
2835 else if (opnd
->addr
.offset
.imm
)
2836 snprintf (buf
, size
, "[%s,#%d]", base
, opnd
->addr
.offset
.imm
);
2838 snprintf (buf
, size
, "[%s]", base
);
2842 /* Produce the string representation of the register offset address operand
2843 *OPND in the buffer pointed by BUF of size SIZE. BASE and OFFSET are
2844 the names of the base and offset registers. */
2846 print_register_offset_address (char *buf
, size_t size
,
2847 const aarch64_opnd_info
*opnd
,
2848 const char *base
, const char *offset
)
2850 char tb
[16]; /* Temporary buffer. */
2851 bfd_boolean print_extend_p
= TRUE
;
2852 bfd_boolean print_amount_p
= TRUE
;
2853 const char *shift_name
= aarch64_operand_modifiers
[opnd
->shifter
.kind
].name
;
2855 if (!opnd
->shifter
.amount
&& (opnd
->qualifier
!= AARCH64_OPND_QLF_S_B
2856 || !opnd
->shifter
.amount_present
))
2858 /* Not print the shift/extend amount when the amount is zero and
2859 when it is not the special case of 8-bit load/store instruction. */
2860 print_amount_p
= FALSE
;
2861 /* Likewise, no need to print the shift operator LSL in such a
2863 if (opnd
->shifter
.kind
== AARCH64_MOD_LSL
)
2864 print_extend_p
= FALSE
;
2867 /* Prepare for the extend/shift. */
2871 snprintf (tb
, sizeof (tb
), ",%s #%" PRIi64
, shift_name
,
2872 opnd
->shifter
.amount
);
2874 snprintf (tb
, sizeof (tb
), ",%s", shift_name
);
2879 snprintf (buf
, size
, "[%s,%s%s]", base
, offset
, tb
);
2882 /* Generate the string representation of the operand OPNDS[IDX] for OPCODE
2883 in *BUF. The caller should pass in the maximum size of *BUF in SIZE.
2884 PC, PCREL_P and ADDRESS are used to pass in and return information about
2885 the PC-relative address calculation, where the PC value is passed in
2886 PC. If the operand is pc-relative related, *PCREL_P (if PCREL_P non-NULL)
2887 will return 1 and *ADDRESS (if ADDRESS non-NULL) will return the
2888 calculated address; otherwise, *PCREL_P (if PCREL_P non-NULL) returns 0.
2890 The function serves both the disassembler and the assembler diagnostics
2891 issuer, which is the reason why it lives in this file. */
2894 aarch64_print_operand (char *buf
, size_t size
, bfd_vma pc
,
2895 const aarch64_opcode
*opcode
,
2896 const aarch64_opnd_info
*opnds
, int idx
, int *pcrel_p
,
2900 const char *name
= NULL
;
2901 const aarch64_opnd_info
*opnd
= opnds
+ idx
;
2902 enum aarch64_modifier_kind kind
;
2903 uint64_t addr
, enum_value
;
2911 case AARCH64_OPND_Rd
:
2912 case AARCH64_OPND_Rn
:
2913 case AARCH64_OPND_Rm
:
2914 case AARCH64_OPND_Rt
:
2915 case AARCH64_OPND_Rt2
:
2916 case AARCH64_OPND_Rs
:
2917 case AARCH64_OPND_Ra
:
2918 case AARCH64_OPND_Rt_SYS
:
2919 case AARCH64_OPND_PAIRREG
:
2920 /* The optional-ness of <Xt> in e.g. IC <ic_op>{, <Xt>} is determined by
2921 the <ic_op>, therefore we we use opnd->present to override the
2922 generic optional-ness information. */
2923 if (opnd
->type
== AARCH64_OPND_Rt_SYS
&& !opnd
->present
)
2925 /* Omit the operand, e.g. RET. */
2926 if (optional_operand_p (opcode
, idx
)
2927 && opnd
->reg
.regno
== get_optional_operand_default_value (opcode
))
2929 assert (opnd
->qualifier
== AARCH64_OPND_QLF_W
2930 || opnd
->qualifier
== AARCH64_OPND_QLF_X
);
2931 snprintf (buf
, size
, "%s",
2932 get_int_reg_name (opnd
->reg
.regno
, opnd
->qualifier
, 0));
2935 case AARCH64_OPND_Rd_SP
:
2936 case AARCH64_OPND_Rn_SP
:
2937 assert (opnd
->qualifier
== AARCH64_OPND_QLF_W
2938 || opnd
->qualifier
== AARCH64_OPND_QLF_WSP
2939 || opnd
->qualifier
== AARCH64_OPND_QLF_X
2940 || opnd
->qualifier
== AARCH64_OPND_QLF_SP
);
2941 snprintf (buf
, size
, "%s",
2942 get_int_reg_name (opnd
->reg
.regno
, opnd
->qualifier
, 1));
2945 case AARCH64_OPND_Rm_EXT
:
2946 kind
= opnd
->shifter
.kind
;
2947 assert (idx
== 1 || idx
== 2);
2948 if ((aarch64_stack_pointer_p (opnds
)
2949 || (idx
== 2 && aarch64_stack_pointer_p (opnds
+ 1)))
2950 && ((opnd
->qualifier
== AARCH64_OPND_QLF_W
2951 && opnds
[0].qualifier
== AARCH64_OPND_QLF_W
2952 && kind
== AARCH64_MOD_UXTW
)
2953 || (opnd
->qualifier
== AARCH64_OPND_QLF_X
2954 && kind
== AARCH64_MOD_UXTX
)))
2956 /* 'LSL' is the preferred form in this case. */
2957 kind
= AARCH64_MOD_LSL
;
2958 if (opnd
->shifter
.amount
== 0)
2960 /* Shifter omitted. */
2961 snprintf (buf
, size
, "%s",
2962 get_int_reg_name (opnd
->reg
.regno
, opnd
->qualifier
, 0));
2966 if (opnd
->shifter
.amount
)
2967 snprintf (buf
, size
, "%s, %s #%" PRIi64
,
2968 get_int_reg_name (opnd
->reg
.regno
, opnd
->qualifier
, 0),
2969 aarch64_operand_modifiers
[kind
].name
,
2970 opnd
->shifter
.amount
);
2972 snprintf (buf
, size
, "%s, %s",
2973 get_int_reg_name (opnd
->reg
.regno
, opnd
->qualifier
, 0),
2974 aarch64_operand_modifiers
[kind
].name
);
2977 case AARCH64_OPND_Rm_SFT
:
2978 assert (opnd
->qualifier
== AARCH64_OPND_QLF_W
2979 || opnd
->qualifier
== AARCH64_OPND_QLF_X
);
2980 if (opnd
->shifter
.amount
== 0 && opnd
->shifter
.kind
== AARCH64_MOD_LSL
)
2981 snprintf (buf
, size
, "%s",
2982 get_int_reg_name (opnd
->reg
.regno
, opnd
->qualifier
, 0));
2984 snprintf (buf
, size
, "%s, %s #%" PRIi64
,
2985 get_int_reg_name (opnd
->reg
.regno
, opnd
->qualifier
, 0),
2986 aarch64_operand_modifiers
[opnd
->shifter
.kind
].name
,
2987 opnd
->shifter
.amount
);
2990 case AARCH64_OPND_Fd
:
2991 case AARCH64_OPND_Fn
:
2992 case AARCH64_OPND_Fm
:
2993 case AARCH64_OPND_Fa
:
2994 case AARCH64_OPND_Ft
:
2995 case AARCH64_OPND_Ft2
:
2996 case AARCH64_OPND_Sd
:
2997 case AARCH64_OPND_Sn
:
2998 case AARCH64_OPND_Sm
:
2999 snprintf (buf
, size
, "%s%d", aarch64_get_qualifier_name (opnd
->qualifier
),
3003 case AARCH64_OPND_Vd
:
3004 case AARCH64_OPND_Vn
:
3005 case AARCH64_OPND_Vm
:
3006 snprintf (buf
, size
, "v%d.%s", opnd
->reg
.regno
,
3007 aarch64_get_qualifier_name (opnd
->qualifier
));
3010 case AARCH64_OPND_Ed
:
3011 case AARCH64_OPND_En
:
3012 case AARCH64_OPND_Em
:
3013 snprintf (buf
, size
, "v%d.%s[%" PRIi64
"]", opnd
->reglane
.regno
,
3014 aarch64_get_qualifier_name (opnd
->qualifier
),
3015 opnd
->reglane
.index
);
3018 case AARCH64_OPND_VdD1
:
3019 case AARCH64_OPND_VnD1
:
3020 snprintf (buf
, size
, "v%d.d[1]", opnd
->reg
.regno
);
3023 case AARCH64_OPND_LVn
:
3024 case AARCH64_OPND_LVt
:
3025 case AARCH64_OPND_LVt_AL
:
3026 case AARCH64_OPND_LEt
:
3027 print_register_list (buf
, size
, opnd
, "v");
3030 case AARCH64_OPND_SVE_Pd
:
3031 case AARCH64_OPND_SVE_Pg3
:
3032 case AARCH64_OPND_SVE_Pg4_5
:
3033 case AARCH64_OPND_SVE_Pg4_10
:
3034 case AARCH64_OPND_SVE_Pg4_16
:
3035 case AARCH64_OPND_SVE_Pm
:
3036 case AARCH64_OPND_SVE_Pn
:
3037 case AARCH64_OPND_SVE_Pt
:
3038 if (opnd
->qualifier
== AARCH64_OPND_QLF_NIL
)
3039 snprintf (buf
, size
, "p%d", opnd
->reg
.regno
);
3040 else if (opnd
->qualifier
== AARCH64_OPND_QLF_P_Z
3041 || opnd
->qualifier
== AARCH64_OPND_QLF_P_M
)
3042 snprintf (buf
, size
, "p%d/%s", opnd
->reg
.regno
,
3043 aarch64_get_qualifier_name (opnd
->qualifier
));
3045 snprintf (buf
, size
, "p%d.%s", opnd
->reg
.regno
,
3046 aarch64_get_qualifier_name (opnd
->qualifier
));
3049 case AARCH64_OPND_SVE_Za_5
:
3050 case AARCH64_OPND_SVE_Za_16
:
3051 case AARCH64_OPND_SVE_Zd
:
3052 case AARCH64_OPND_SVE_Zm_5
:
3053 case AARCH64_OPND_SVE_Zm_16
:
3054 case AARCH64_OPND_SVE_Zn
:
3055 case AARCH64_OPND_SVE_Zt
:
3056 if (opnd
->qualifier
== AARCH64_OPND_QLF_NIL
)
3057 snprintf (buf
, size
, "z%d", opnd
->reg
.regno
);
3059 snprintf (buf
, size
, "z%d.%s", opnd
->reg
.regno
,
3060 aarch64_get_qualifier_name (opnd
->qualifier
));
3063 case AARCH64_OPND_SVE_ZnxN
:
3064 case AARCH64_OPND_SVE_ZtxN
:
3065 print_register_list (buf
, size
, opnd
, "z");
3068 case AARCH64_OPND_SVE_Zn_INDEX
:
3069 snprintf (buf
, size
, "z%d.%s[%" PRIi64
"]", opnd
->reglane
.regno
,
3070 aarch64_get_qualifier_name (opnd
->qualifier
),
3071 opnd
->reglane
.index
);
3074 case AARCH64_OPND_Cn
:
3075 case AARCH64_OPND_Cm
:
3076 snprintf (buf
, size
, "C%d", opnd
->reg
.regno
);
3079 case AARCH64_OPND_IDX
:
3080 case AARCH64_OPND_IMM
:
3081 case AARCH64_OPND_WIDTH
:
3082 case AARCH64_OPND_UIMM3_OP1
:
3083 case AARCH64_OPND_UIMM3_OP2
:
3084 case AARCH64_OPND_BIT_NUM
:
3085 case AARCH64_OPND_IMM_VLSL
:
3086 case AARCH64_OPND_IMM_VLSR
:
3087 case AARCH64_OPND_SHLL_IMM
:
3088 case AARCH64_OPND_IMM0
:
3089 case AARCH64_OPND_IMMR
:
3090 case AARCH64_OPND_IMMS
:
3091 case AARCH64_OPND_FBITS
:
3092 case AARCH64_OPND_SIMM5
:
3093 case AARCH64_OPND_SVE_SHLIMM_PRED
:
3094 case AARCH64_OPND_SVE_SHLIMM_UNPRED
:
3095 case AARCH64_OPND_SVE_SHRIMM_PRED
:
3096 case AARCH64_OPND_SVE_SHRIMM_UNPRED
:
3097 case AARCH64_OPND_SVE_SIMM5
:
3098 case AARCH64_OPND_SVE_SIMM5B
:
3099 case AARCH64_OPND_SVE_SIMM6
:
3100 case AARCH64_OPND_SVE_SIMM8
:
3101 case AARCH64_OPND_SVE_UIMM3
:
3102 case AARCH64_OPND_SVE_UIMM7
:
3103 case AARCH64_OPND_SVE_UIMM8
:
3104 case AARCH64_OPND_SVE_UIMM8_53
:
3105 snprintf (buf
, size
, "#%" PRIi64
, opnd
->imm
.value
);
3108 case AARCH64_OPND_SVE_PATTERN
:
3109 if (optional_operand_p (opcode
, idx
)
3110 && opnd
->imm
.value
== get_optional_operand_default_value (opcode
))
3112 enum_value
= opnd
->imm
.value
;
3113 assert (enum_value
< ARRAY_SIZE (aarch64_sve_pattern_array
));
3114 if (aarch64_sve_pattern_array
[enum_value
])
3115 snprintf (buf
, size
, "%s", aarch64_sve_pattern_array
[enum_value
]);
3117 snprintf (buf
, size
, "#%" PRIi64
, opnd
->imm
.value
);
3120 case AARCH64_OPND_SVE_PATTERN_SCALED
:
3121 if (optional_operand_p (opcode
, idx
)
3122 && !opnd
->shifter
.operator_present
3123 && opnd
->imm
.value
== get_optional_operand_default_value (opcode
))
3125 enum_value
= opnd
->imm
.value
;
3126 assert (enum_value
< ARRAY_SIZE (aarch64_sve_pattern_array
));
3127 if (aarch64_sve_pattern_array
[opnd
->imm
.value
])
3128 snprintf (buf
, size
, "%s", aarch64_sve_pattern_array
[opnd
->imm
.value
]);
3130 snprintf (buf
, size
, "#%" PRIi64
, opnd
->imm
.value
);
3131 if (opnd
->shifter
.operator_present
)
3133 size_t len
= strlen (buf
);
3134 snprintf (buf
+ len
, size
- len
, ", %s #%" PRIi64
,
3135 aarch64_operand_modifiers
[opnd
->shifter
.kind
].name
,
3136 opnd
->shifter
.amount
);
3140 case AARCH64_OPND_SVE_PRFOP
:
3141 enum_value
= opnd
->imm
.value
;
3142 assert (enum_value
< ARRAY_SIZE (aarch64_sve_prfop_array
));
3143 if (aarch64_sve_prfop_array
[enum_value
])
3144 snprintf (buf
, size
, "%s", aarch64_sve_prfop_array
[enum_value
]);
3146 snprintf (buf
, size
, "#%" PRIi64
, opnd
->imm
.value
);
3149 case AARCH64_OPND_IMM_MOV
:
3150 switch (aarch64_get_qualifier_esize (opnds
[0].qualifier
))
3152 case 4: /* e.g. MOV Wd, #<imm32>. */
3154 int imm32
= opnd
->imm
.value
;
3155 snprintf (buf
, size
, "#0x%-20x\t// #%d", imm32
, imm32
);
3158 case 8: /* e.g. MOV Xd, #<imm64>. */
3159 snprintf (buf
, size
, "#0x%-20" PRIx64
"\t// #%" PRIi64
,
3160 opnd
->imm
.value
, opnd
->imm
.value
);
3162 default: assert (0);
3166 case AARCH64_OPND_FPIMM0
:
3167 snprintf (buf
, size
, "#0.0");
3170 case AARCH64_OPND_LIMM
:
3171 case AARCH64_OPND_AIMM
:
3172 case AARCH64_OPND_HALF
:
3173 case AARCH64_OPND_SVE_INV_LIMM
:
3174 case AARCH64_OPND_SVE_LIMM
:
3175 case AARCH64_OPND_SVE_LIMM_MOV
:
3176 if (opnd
->shifter
.amount
)
3177 snprintf (buf
, size
, "#0x%" PRIx64
", lsl #%" PRIi64
, opnd
->imm
.value
,
3178 opnd
->shifter
.amount
);
3180 snprintf (buf
, size
, "#0x%" PRIx64
, opnd
->imm
.value
);
3183 case AARCH64_OPND_SIMD_IMM
:
3184 case AARCH64_OPND_SIMD_IMM_SFT
:
3185 if ((! opnd
->shifter
.amount
&& opnd
->shifter
.kind
== AARCH64_MOD_LSL
)
3186 || opnd
->shifter
.kind
== AARCH64_MOD_NONE
)
3187 snprintf (buf
, size
, "#0x%" PRIx64
, opnd
->imm
.value
);
3189 snprintf (buf
, size
, "#0x%" PRIx64
", %s #%" PRIi64
, opnd
->imm
.value
,
3190 aarch64_operand_modifiers
[opnd
->shifter
.kind
].name
,
3191 opnd
->shifter
.amount
);
3194 case AARCH64_OPND_SVE_AIMM
:
3195 case AARCH64_OPND_SVE_ASIMM
:
3196 if (opnd
->shifter
.amount
)
3197 snprintf (buf
, size
, "#%" PRIi64
", lsl #%" PRIi64
, opnd
->imm
.value
,
3198 opnd
->shifter
.amount
);
3200 snprintf (buf
, size
, "#%" PRIi64
, opnd
->imm
.value
);
3203 case AARCH64_OPND_FPIMM
:
3204 case AARCH64_OPND_SIMD_FPIMM
:
3205 switch (aarch64_get_qualifier_esize (opnds
[0].qualifier
))
3207 case 2: /* e.g. FMOV <Hd>, #<imm>. */
3210 c
.i
= expand_fp_imm (2, opnd
->imm
.value
);
3211 snprintf (buf
, size
, "#%.18e", c
.f
);
3214 case 4: /* e.g. FMOV <Vd>.4S, #<imm>. */
3217 c
.i
= expand_fp_imm (4, opnd
->imm
.value
);
3218 snprintf (buf
, size
, "#%.18e", c
.f
);
3221 case 8: /* e.g. FMOV <Sd>, #<imm>. */
3224 c
.i
= expand_fp_imm (8, opnd
->imm
.value
);
3225 snprintf (buf
, size
, "#%.18e", c
.d
);
3228 default: assert (0);
3232 case AARCH64_OPND_CCMP_IMM
:
3233 case AARCH64_OPND_NZCV
:
3234 case AARCH64_OPND_EXCEPTION
:
3235 case AARCH64_OPND_UIMM4
:
3236 case AARCH64_OPND_UIMM7
:
3237 if (optional_operand_p (opcode
, idx
) == TRUE
3238 && (opnd
->imm
.value
==
3239 (int64_t) get_optional_operand_default_value (opcode
)))
3240 /* Omit the operand, e.g. DCPS1. */
3242 snprintf (buf
, size
, "#0x%x", (unsigned int)opnd
->imm
.value
);
3245 case AARCH64_OPND_COND
:
3246 case AARCH64_OPND_COND1
:
3247 snprintf (buf
, size
, "%s", opnd
->cond
->names
[0]);
3250 case AARCH64_OPND_ADDR_ADRP
:
3251 addr
= ((pc
+ AARCH64_PCREL_OFFSET
) & ~(uint64_t)0xfff)
3257 /* This is not necessary during the disassembling, as print_address_func
3258 in the disassemble_info will take care of the printing. But some
3259 other callers may be still interested in getting the string in *STR,
3260 so here we do snprintf regardless. */
3261 snprintf (buf
, size
, "#0x%" PRIx64
, addr
);
3264 case AARCH64_OPND_ADDR_PCREL14
:
3265 case AARCH64_OPND_ADDR_PCREL19
:
3266 case AARCH64_OPND_ADDR_PCREL21
:
3267 case AARCH64_OPND_ADDR_PCREL26
:
3268 addr
= pc
+ AARCH64_PCREL_OFFSET
+ opnd
->imm
.value
;
3273 /* This is not necessary during the disassembling, as print_address_func
3274 in the disassemble_info will take care of the printing. But some
3275 other callers may be still interested in getting the string in *STR,
3276 so here we do snprintf regardless. */
3277 snprintf (buf
, size
, "#0x%" PRIx64
, addr
);
3280 case AARCH64_OPND_ADDR_SIMPLE
:
3281 case AARCH64_OPND_SIMD_ADDR_SIMPLE
:
3282 case AARCH64_OPND_SIMD_ADDR_POST
:
3283 name
= get_64bit_int_reg_name (opnd
->addr
.base_regno
, 1);
3284 if (opnd
->type
== AARCH64_OPND_SIMD_ADDR_POST
)
3286 if (opnd
->addr
.offset
.is_reg
)
3287 snprintf (buf
, size
, "[%s], x%d", name
, opnd
->addr
.offset
.regno
);
3289 snprintf (buf
, size
, "[%s], #%d", name
, opnd
->addr
.offset
.imm
);
3292 snprintf (buf
, size
, "[%s]", name
);
3295 case AARCH64_OPND_ADDR_REGOFF
:
3296 case AARCH64_OPND_SVE_ADDR_RR
:
3297 case AARCH64_OPND_SVE_ADDR_RR_LSL1
:
3298 case AARCH64_OPND_SVE_ADDR_RR_LSL2
:
3299 case AARCH64_OPND_SVE_ADDR_RR_LSL3
:
3300 case AARCH64_OPND_SVE_ADDR_RX
:
3301 case AARCH64_OPND_SVE_ADDR_RX_LSL1
:
3302 case AARCH64_OPND_SVE_ADDR_RX_LSL2
:
3303 case AARCH64_OPND_SVE_ADDR_RX_LSL3
:
3304 print_register_offset_address
3305 (buf
, size
, opnd
, get_64bit_int_reg_name (opnd
->addr
.base_regno
, 1),
3306 get_offset_int_reg_name (opnd
));
3309 case AARCH64_OPND_SVE_ADDR_RZ
:
3310 case AARCH64_OPND_SVE_ADDR_RZ_LSL1
:
3311 case AARCH64_OPND_SVE_ADDR_RZ_LSL2
:
3312 case AARCH64_OPND_SVE_ADDR_RZ_LSL3
:
3313 case AARCH64_OPND_SVE_ADDR_RZ_XTW_14
:
3314 case AARCH64_OPND_SVE_ADDR_RZ_XTW_22
:
3315 case AARCH64_OPND_SVE_ADDR_RZ_XTW1_14
:
3316 case AARCH64_OPND_SVE_ADDR_RZ_XTW1_22
:
3317 case AARCH64_OPND_SVE_ADDR_RZ_XTW2_14
:
3318 case AARCH64_OPND_SVE_ADDR_RZ_XTW2_22
:
3319 case AARCH64_OPND_SVE_ADDR_RZ_XTW3_14
:
3320 case AARCH64_OPND_SVE_ADDR_RZ_XTW3_22
:
3321 print_register_offset_address
3322 (buf
, size
, opnd
, get_64bit_int_reg_name (opnd
->addr
.base_regno
, 1),
3323 get_addr_sve_reg_name (opnd
->addr
.offset
.regno
, opnd
->qualifier
));
3326 case AARCH64_OPND_ADDR_SIMM7
:
3327 case AARCH64_OPND_ADDR_SIMM9
:
3328 case AARCH64_OPND_ADDR_SIMM9_2
:
3329 case AARCH64_OPND_SVE_ADDR_RI_S4xVL
:
3330 case AARCH64_OPND_SVE_ADDR_RI_S4x2xVL
:
3331 case AARCH64_OPND_SVE_ADDR_RI_S4x3xVL
:
3332 case AARCH64_OPND_SVE_ADDR_RI_S4x4xVL
:
3333 case AARCH64_OPND_SVE_ADDR_RI_S6xVL
:
3334 case AARCH64_OPND_SVE_ADDR_RI_S9xVL
:
3335 case AARCH64_OPND_SVE_ADDR_RI_U6
:
3336 case AARCH64_OPND_SVE_ADDR_RI_U6x2
:
3337 case AARCH64_OPND_SVE_ADDR_RI_U6x4
:
3338 case AARCH64_OPND_SVE_ADDR_RI_U6x8
:
3339 print_immediate_offset_address
3340 (buf
, size
, opnd
, get_64bit_int_reg_name (opnd
->addr
.base_regno
, 1));
3343 case AARCH64_OPND_SVE_ADDR_ZI_U5
:
3344 case AARCH64_OPND_SVE_ADDR_ZI_U5x2
:
3345 case AARCH64_OPND_SVE_ADDR_ZI_U5x4
:
3346 case AARCH64_OPND_SVE_ADDR_ZI_U5x8
:
3347 print_immediate_offset_address
3349 get_addr_sve_reg_name (opnd
->addr
.base_regno
, opnd
->qualifier
));
3352 case AARCH64_OPND_SVE_ADDR_ZZ_LSL
:
3353 case AARCH64_OPND_SVE_ADDR_ZZ_SXTW
:
3354 case AARCH64_OPND_SVE_ADDR_ZZ_UXTW
:
3355 print_register_offset_address
3357 get_addr_sve_reg_name (opnd
->addr
.base_regno
, opnd
->qualifier
),
3358 get_addr_sve_reg_name (opnd
->addr
.offset
.regno
, opnd
->qualifier
));
3361 case AARCH64_OPND_ADDR_UIMM12
:
3362 name
= get_64bit_int_reg_name (opnd
->addr
.base_regno
, 1);
3363 if (opnd
->addr
.offset
.imm
)
3364 snprintf (buf
, size
, "[%s,#%d]", name
, opnd
->addr
.offset
.imm
);
3366 snprintf (buf
, size
, "[%s]", name
);
3369 case AARCH64_OPND_SYSREG
:
3370 for (i
= 0; aarch64_sys_regs
[i
].name
; ++i
)
3371 if (aarch64_sys_regs
[i
].value
== opnd
->sysreg
3372 && ! aarch64_sys_reg_deprecated_p (&aarch64_sys_regs
[i
]))
3374 if (aarch64_sys_regs
[i
].name
)
3375 snprintf (buf
, size
, "%s", aarch64_sys_regs
[i
].name
);
3378 /* Implementation defined system register. */
3379 unsigned int value
= opnd
->sysreg
;
3380 snprintf (buf
, size
, "s%u_%u_c%u_c%u_%u", (value
>> 14) & 0x3,
3381 (value
>> 11) & 0x7, (value
>> 7) & 0xf, (value
>> 3) & 0xf,
3386 case AARCH64_OPND_PSTATEFIELD
:
3387 for (i
= 0; aarch64_pstatefields
[i
].name
; ++i
)
3388 if (aarch64_pstatefields
[i
].value
== opnd
->pstatefield
)
3390 assert (aarch64_pstatefields
[i
].name
);
3391 snprintf (buf
, size
, "%s", aarch64_pstatefields
[i
].name
);
3394 case AARCH64_OPND_SYSREG_AT
:
3395 case AARCH64_OPND_SYSREG_DC
:
3396 case AARCH64_OPND_SYSREG_IC
:
3397 case AARCH64_OPND_SYSREG_TLBI
:
3398 snprintf (buf
, size
, "%s", opnd
->sysins_op
->name
);
3401 case AARCH64_OPND_BARRIER
:
3402 snprintf (buf
, size
, "%s", opnd
->barrier
->name
);
3405 case AARCH64_OPND_BARRIER_ISB
:
3406 /* Operand can be omitted, e.g. in DCPS1. */
3407 if (! optional_operand_p (opcode
, idx
)
3408 || (opnd
->barrier
->value
3409 != get_optional_operand_default_value (opcode
)))
3410 snprintf (buf
, size
, "#0x%x", opnd
->barrier
->value
);
3413 case AARCH64_OPND_PRFOP
:
3414 if (opnd
->prfop
->name
!= NULL
)
3415 snprintf (buf
, size
, "%s", opnd
->prfop
->name
);
3417 snprintf (buf
, size
, "#0x%02x", opnd
->prfop
->value
);
3420 case AARCH64_OPND_BARRIER_PSB
:
3421 snprintf (buf
, size
, "%s", opnd
->hint_option
->name
);
3429 #define CPENC(op0,op1,crn,crm,op2) \
3430 ((((op0) << 19) | ((op1) << 16) | ((crn) << 12) | ((crm) << 8) | ((op2) << 5)) >> 5)
3431 /* for 3.9.3 Instructions for Accessing Special Purpose Registers */
3432 #define CPEN_(op1,crm,op2) CPENC(3,(op1),4,(crm),(op2))
3433 /* for 3.9.10 System Instructions */
3434 #define CPENS(op1,crn,crm,op2) CPENC(1,(op1),(crn),(crm),(op2))
3456 #define F_DEPRECATED 0x1 /* Deprecated system register. */
3461 #define F_ARCHEXT 0x2 /* Architecture dependent system register. */
3466 #define F_HASXT 0x4 /* System instruction register <Xt>
3470 /* TODO there are two more issues need to be resolved
3471 1. handle read-only and write-only system registers
3472 2. handle cpu-implementation-defined system registers. */
3473 const aarch64_sys_reg aarch64_sys_regs
[] =
3475 { "spsr_el1", CPEN_(0,C0
,0), 0 }, /* = spsr_svc */
3476 { "spsr_el12", CPEN_ (5, C0
, 0), F_ARCHEXT
},
3477 { "elr_el1", CPEN_(0,C0
,1), 0 },
3478 { "elr_el12", CPEN_ (5, C0
, 1), F_ARCHEXT
},
3479 { "sp_el0", CPEN_(0,C1
,0), 0 },
3480 { "spsel", CPEN_(0,C2
,0), 0 },
3481 { "daif", CPEN_(3,C2
,1), 0 },
3482 { "currentel", CPEN_(0,C2
,2), 0 }, /* RO */
3483 { "pan", CPEN_(0,C2
,3), F_ARCHEXT
},
3484 { "uao", CPEN_ (0, C2
, 4), F_ARCHEXT
},
3485 { "nzcv", CPEN_(3,C2
,0), 0 },
3486 { "fpcr", CPEN_(3,C4
,0), 0 },
3487 { "fpsr", CPEN_(3,C4
,1), 0 },
3488 { "dspsr_el0", CPEN_(3,C5
,0), 0 },
3489 { "dlr_el0", CPEN_(3,C5
,1), 0 },
3490 { "spsr_el2", CPEN_(4,C0
,0), 0 }, /* = spsr_hyp */
3491 { "elr_el2", CPEN_(4,C0
,1), 0 },
3492 { "sp_el1", CPEN_(4,C1
,0), 0 },
3493 { "spsr_irq", CPEN_(4,C3
,0), 0 },
3494 { "spsr_abt", CPEN_(4,C3
,1), 0 },
3495 { "spsr_und", CPEN_(4,C3
,2), 0 },
3496 { "spsr_fiq", CPEN_(4,C3
,3), 0 },
3497 { "spsr_el3", CPEN_(6,C0
,0), 0 },
3498 { "elr_el3", CPEN_(6,C0
,1), 0 },
3499 { "sp_el2", CPEN_(6,C1
,0), 0 },
3500 { "spsr_svc", CPEN_(0,C0
,0), F_DEPRECATED
}, /* = spsr_el1 */
3501 { "spsr_hyp", CPEN_(4,C0
,0), F_DEPRECATED
}, /* = spsr_el2 */
3502 { "midr_el1", CPENC(3,0,C0
,C0
,0), 0 }, /* RO */
3503 { "ctr_el0", CPENC(3,3,C0
,C0
,1), 0 }, /* RO */
3504 { "mpidr_el1", CPENC(3,0,C0
,C0
,5), 0 }, /* RO */
3505 { "revidr_el1", CPENC(3,0,C0
,C0
,6), 0 }, /* RO */
3506 { "aidr_el1", CPENC(3,1,C0
,C0
,7), 0 }, /* RO */
3507 { "dczid_el0", CPENC(3,3,C0
,C0
,7), 0 }, /* RO */
3508 { "id_dfr0_el1", CPENC(3,0,C0
,C1
,2), 0 }, /* RO */
3509 { "id_pfr0_el1", CPENC(3,0,C0
,C1
,0), 0 }, /* RO */
3510 { "id_pfr1_el1", CPENC(3,0,C0
,C1
,1), 0 }, /* RO */
3511 { "id_afr0_el1", CPENC(3,0,C0
,C1
,3), 0 }, /* RO */
3512 { "id_mmfr0_el1", CPENC(3,0,C0
,C1
,4), 0 }, /* RO */
3513 { "id_mmfr1_el1", CPENC(3,0,C0
,C1
,5), 0 }, /* RO */
3514 { "id_mmfr2_el1", CPENC(3,0,C0
,C1
,6), 0 }, /* RO */
3515 { "id_mmfr3_el1", CPENC(3,0,C0
,C1
,7), 0 }, /* RO */
3516 { "id_mmfr4_el1", CPENC(3,0,C0
,C2
,6), 0 }, /* RO */
3517 { "id_isar0_el1", CPENC(3,0,C0
,C2
,0), 0 }, /* RO */
3518 { "id_isar1_el1", CPENC(3,0,C0
,C2
,1), 0 }, /* RO */
3519 { "id_isar2_el1", CPENC(3,0,C0
,C2
,2), 0 }, /* RO */
3520 { "id_isar3_el1", CPENC(3,0,C0
,C2
,3), 0 }, /* RO */
3521 { "id_isar4_el1", CPENC(3,0,C0
,C2
,4), 0 }, /* RO */
3522 { "id_isar5_el1", CPENC(3,0,C0
,C2
,5), 0 }, /* RO */
3523 { "mvfr0_el1", CPENC(3,0,C0
,C3
,0), 0 }, /* RO */
3524 { "mvfr1_el1", CPENC(3,0,C0
,C3
,1), 0 }, /* RO */
3525 { "mvfr2_el1", CPENC(3,0,C0
,C3
,2), 0 }, /* RO */
3526 { "ccsidr_el1", CPENC(3,1,C0
,C0
,0), 0 }, /* RO */
3527 { "id_aa64pfr0_el1", CPENC(3,0,C0
,C4
,0), 0 }, /* RO */
3528 { "id_aa64pfr1_el1", CPENC(3,0,C0
,C4
,1), 0 }, /* RO */
3529 { "id_aa64dfr0_el1", CPENC(3,0,C0
,C5
,0), 0 }, /* RO */
3530 { "id_aa64dfr1_el1", CPENC(3,0,C0
,C5
,1), 0 }, /* RO */
3531 { "id_aa64isar0_el1", CPENC(3,0,C0
,C6
,0), 0 }, /* RO */
3532 { "id_aa64isar1_el1", CPENC(3,0,C0
,C6
,1), 0 }, /* RO */
3533 { "id_aa64mmfr0_el1", CPENC(3,0,C0
,C7
,0), 0 }, /* RO */
3534 { "id_aa64mmfr1_el1", CPENC(3,0,C0
,C7
,1), 0 }, /* RO */
3535 { "id_aa64mmfr2_el1", CPENC (3, 0, C0
, C7
, 2), F_ARCHEXT
}, /* RO */
3536 { "id_aa64afr0_el1", CPENC(3,0,C0
,C5
,4), 0 }, /* RO */
3537 { "id_aa64afr1_el1", CPENC(3,0,C0
,C5
,5), 0 }, /* RO */
3538 { "clidr_el1", CPENC(3,1,C0
,C0
,1), 0 }, /* RO */
3539 { "csselr_el1", CPENC(3,2,C0
,C0
,0), 0 }, /* RO */
3540 { "vpidr_el2", CPENC(3,4,C0
,C0
,0), 0 },
3541 { "vmpidr_el2", CPENC(3,4,C0
,C0
,5), 0 },
3542 { "sctlr_el1", CPENC(3,0,C1
,C0
,0), 0 },
3543 { "sctlr_el2", CPENC(3,4,C1
,C0
,0), 0 },
3544 { "sctlr_el3", CPENC(3,6,C1
,C0
,0), 0 },
3545 { "sctlr_el12", CPENC (3, 5, C1
, C0
, 0), F_ARCHEXT
},
3546 { "actlr_el1", CPENC(3,0,C1
,C0
,1), 0 },
3547 { "actlr_el2", CPENC(3,4,C1
,C0
,1), 0 },
3548 { "actlr_el3", CPENC(3,6,C1
,C0
,1), 0 },
3549 { "cpacr_el1", CPENC(3,0,C1
,C0
,2), 0 },
3550 { "cpacr_el12", CPENC (3, 5, C1
, C0
, 2), F_ARCHEXT
},
3551 { "cptr_el2", CPENC(3,4,C1
,C1
,2), 0 },
3552 { "cptr_el3", CPENC(3,6,C1
,C1
,2), 0 },
3553 { "scr_el3", CPENC(3,6,C1
,C1
,0), 0 },
3554 { "hcr_el2", CPENC(3,4,C1
,C1
,0), 0 },
3555 { "mdcr_el2", CPENC(3,4,C1
,C1
,1), 0 },
3556 { "mdcr_el3", CPENC(3,6,C1
,C3
,1), 0 },
3557 { "hstr_el2", CPENC(3,4,C1
,C1
,3), 0 },
3558 { "hacr_el2", CPENC(3,4,C1
,C1
,7), 0 },
3559 { "ttbr0_el1", CPENC(3,0,C2
,C0
,0), 0 },
3560 { "ttbr1_el1", CPENC(3,0,C2
,C0
,1), 0 },
3561 { "ttbr0_el2", CPENC(3,4,C2
,C0
,0), 0 },
3562 { "ttbr1_el2", CPENC (3, 4, C2
, C0
, 1), F_ARCHEXT
},
3563 { "ttbr0_el3", CPENC(3,6,C2
,C0
,0), 0 },
3564 { "ttbr0_el12", CPENC (3, 5, C2
, C0
, 0), F_ARCHEXT
},
3565 { "ttbr1_el12", CPENC (3, 5, C2
, C0
, 1), F_ARCHEXT
},
3566 { "vttbr_el2", CPENC(3,4,C2
,C1
,0), 0 },
3567 { "tcr_el1", CPENC(3,0,C2
,C0
,2), 0 },
3568 { "tcr_el2", CPENC(3,4,C2
,C0
,2), 0 },
3569 { "tcr_el3", CPENC(3,6,C2
,C0
,2), 0 },
3570 { "tcr_el12", CPENC (3, 5, C2
, C0
, 2), F_ARCHEXT
},
3571 { "vtcr_el2", CPENC(3,4,C2
,C1
,2), 0 },
3572 { "afsr0_el1", CPENC(3,0,C5
,C1
,0), 0 },
3573 { "afsr1_el1", CPENC(3,0,C5
,C1
,1), 0 },
3574 { "afsr0_el2", CPENC(3,4,C5
,C1
,0), 0 },
3575 { "afsr1_el2", CPENC(3,4,C5
,C1
,1), 0 },
3576 { "afsr0_el3", CPENC(3,6,C5
,C1
,0), 0 },
3577 { "afsr0_el12", CPENC (3, 5, C5
, C1
, 0), F_ARCHEXT
},
3578 { "afsr1_el3", CPENC(3,6,C5
,C1
,1), 0 },
3579 { "afsr1_el12", CPENC (3, 5, C5
, C1
, 1), F_ARCHEXT
},
3580 { "esr_el1", CPENC(3,0,C5
,C2
,0), 0 },
3581 { "esr_el2", CPENC(3,4,C5
,C2
,0), 0 },
3582 { "esr_el3", CPENC(3,6,C5
,C2
,0), 0 },
3583 { "esr_el12", CPENC (3, 5, C5
, C2
, 0), F_ARCHEXT
},
3584 { "vsesr_el2", CPENC (3, 4, C5
, C2
, 3), F_ARCHEXT
}, /* RO */
3585 { "fpexc32_el2", CPENC(3,4,C5
,C3
,0), 0 },
3586 { "erridr_el1", CPENC (3, 0, C5
, C3
, 0), F_ARCHEXT
}, /* RO */
3587 { "errselr_el1", CPENC (3, 0, C5
, C3
, 1), F_ARCHEXT
},
3588 { "erxfr_el1", CPENC (3, 0, C5
, C4
, 0), F_ARCHEXT
}, /* RO */
3589 { "erxctlr_el1", CPENC (3, 0, C5
, C4
, 1), F_ARCHEXT
},
3590 { "erxstatus_el1", CPENC (3, 0, C5
, C4
, 2), F_ARCHEXT
},
3591 { "erxaddr_el1", CPENC (3, 0, C5
, C4
, 3), F_ARCHEXT
},
3592 { "erxmisc0_el1", CPENC (3, 0, C5
, C5
, 0), F_ARCHEXT
},
3593 { "erxmisc1_el1", CPENC (3, 0, C5
, C5
, 1), F_ARCHEXT
},
3594 { "far_el1", CPENC(3,0,C6
,C0
,0), 0 },
3595 { "far_el2", CPENC(3,4,C6
,C0
,0), 0 },
3596 { "far_el3", CPENC(3,6,C6
,C0
,0), 0 },
3597 { "far_el12", CPENC (3, 5, C6
, C0
, 0), F_ARCHEXT
},
3598 { "hpfar_el2", CPENC(3,4,C6
,C0
,4), 0 },
3599 { "par_el1", CPENC(3,0,C7
,C4
,0), 0 },
3600 { "mair_el1", CPENC(3,0,C10
,C2
,0), 0 },
3601 { "mair_el2", CPENC(3,4,C10
,C2
,0), 0 },
3602 { "mair_el3", CPENC(3,6,C10
,C2
,0), 0 },
3603 { "mair_el12", CPENC (3, 5, C10
, C2
, 0), F_ARCHEXT
},
3604 { "amair_el1", CPENC(3,0,C10
,C3
,0), 0 },
3605 { "amair_el2", CPENC(3,4,C10
,C3
,0), 0 },
3606 { "amair_el3", CPENC(3,6,C10
,C3
,0), 0 },
3607 { "amair_el12", CPENC (3, 5, C10
, C3
, 0), F_ARCHEXT
},
3608 { "vbar_el1", CPENC(3,0,C12
,C0
,0), 0 },
3609 { "vbar_el2", CPENC(3,4,C12
,C0
,0), 0 },
3610 { "vbar_el3", CPENC(3,6,C12
,C0
,0), 0 },
3611 { "vbar_el12", CPENC (3, 5, C12
, C0
, 0), F_ARCHEXT
},
3612 { "rvbar_el1", CPENC(3,0,C12
,C0
,1), 0 }, /* RO */
3613 { "rvbar_el2", CPENC(3,4,C12
,C0
,1), 0 }, /* RO */
3614 { "rvbar_el3", CPENC(3,6,C12
,C0
,1), 0 }, /* RO */
3615 { "rmr_el1", CPENC(3,0,C12
,C0
,2), 0 },
3616 { "rmr_el2", CPENC(3,4,C12
,C0
,2), 0 },
3617 { "rmr_el3", CPENC(3,6,C12
,C0
,2), 0 },
3618 { "isr_el1", CPENC(3,0,C12
,C1
,0), 0 }, /* RO */
3619 { "disr_el1", CPENC (3, 0, C12
, C1
, 1), F_ARCHEXT
},
3620 { "vdisr_el2", CPENC (3, 4, C12
, C1
, 1), F_ARCHEXT
},
3621 { "contextidr_el1", CPENC(3,0,C13
,C0
,1), 0 },
3622 { "contextidr_el2", CPENC (3, 4, C13
, C0
, 1), F_ARCHEXT
},
3623 { "contextidr_el12", CPENC (3, 5, C13
, C0
, 1), F_ARCHEXT
},
3624 { "tpidr_el0", CPENC(3,3,C13
,C0
,2), 0 },
3625 { "tpidrro_el0", CPENC(3,3,C13
,C0
,3), 0 }, /* RO */
3626 { "tpidr_el1", CPENC(3,0,C13
,C0
,4), 0 },
3627 { "tpidr_el2", CPENC(3,4,C13
,C0
,2), 0 },
3628 { "tpidr_el3", CPENC(3,6,C13
,C0
,2), 0 },
3629 { "teecr32_el1", CPENC(2,2,C0
, C0
,0), 0 }, /* See section 3.9.7.1 */
3630 { "cntfrq_el0", CPENC(3,3,C14
,C0
,0), 0 }, /* RO */
3631 { "cntpct_el0", CPENC(3,3,C14
,C0
,1), 0 }, /* RO */
3632 { "cntvct_el0", CPENC(3,3,C14
,C0
,2), 0 }, /* RO */
3633 { "cntvoff_el2", CPENC(3,4,C14
,C0
,3), 0 },
3634 { "cntkctl_el1", CPENC(3,0,C14
,C1
,0), 0 },
3635 { "cntkctl_el12", CPENC (3, 5, C14
, C1
, 0), F_ARCHEXT
},
3636 { "cnthctl_el2", CPENC(3,4,C14
,C1
,0), 0 },
3637 { "cntp_tval_el0", CPENC(3,3,C14
,C2
,0), 0 },
3638 { "cntp_tval_el02", CPENC (3, 5, C14
, C2
, 0), F_ARCHEXT
},
3639 { "cntp_ctl_el0", CPENC(3,3,C14
,C2
,1), 0 },
3640 { "cntp_ctl_el02", CPENC (3, 5, C14
, C2
, 1), F_ARCHEXT
},
3641 { "cntp_cval_el0", CPENC(3,3,C14
,C2
,2), 0 },
3642 { "cntp_cval_el02", CPENC (3, 5, C14
, C2
, 2), F_ARCHEXT
},
3643 { "cntv_tval_el0", CPENC(3,3,C14
,C3
,0), 0 },
3644 { "cntv_tval_el02", CPENC (3, 5, C14
, C3
, 0), F_ARCHEXT
},
3645 { "cntv_ctl_el0", CPENC(3,3,C14
,C3
,1), 0 },
3646 { "cntv_ctl_el02", CPENC (3, 5, C14
, C3
, 1), F_ARCHEXT
},
3647 { "cntv_cval_el0", CPENC(3,3,C14
,C3
,2), 0 },
3648 { "cntv_cval_el02", CPENC (3, 5, C14
, C3
, 2), F_ARCHEXT
},
3649 { "cnthp_tval_el2", CPENC(3,4,C14
,C2
,0), 0 },
3650 { "cnthp_ctl_el2", CPENC(3,4,C14
,C2
,1), 0 },
3651 { "cnthp_cval_el2", CPENC(3,4,C14
,C2
,2), 0 },
3652 { "cntps_tval_el1", CPENC(3,7,C14
,C2
,0), 0 },
3653 { "cntps_ctl_el1", CPENC(3,7,C14
,C2
,1), 0 },
3654 { "cntps_cval_el1", CPENC(3,7,C14
,C2
,2), 0 },
3655 { "cnthv_tval_el2", CPENC (3, 4, C14
, C3
, 0), F_ARCHEXT
},
3656 { "cnthv_ctl_el2", CPENC (3, 4, C14
, C3
, 1), F_ARCHEXT
},
3657 { "cnthv_cval_el2", CPENC (3, 4, C14
, C3
, 2), F_ARCHEXT
},
3658 { "dacr32_el2", CPENC(3,4,C3
,C0
,0), 0 },
3659 { "ifsr32_el2", CPENC(3,4,C5
,C0
,1), 0 },
3660 { "teehbr32_el1", CPENC(2,2,C1
,C0
,0), 0 },
3661 { "sder32_el3", CPENC(3,6,C1
,C1
,1), 0 },
3662 { "mdscr_el1", CPENC(2,0,C0
, C2
, 2), 0 },
3663 { "mdccsr_el0", CPENC(2,3,C0
, C1
, 0), 0 }, /* r */
3664 { "mdccint_el1", CPENC(2,0,C0
, C2
, 0), 0 },
3665 { "dbgdtr_el0", CPENC(2,3,C0
, C4
, 0), 0 },
3666 { "dbgdtrrx_el0", CPENC(2,3,C0
, C5
, 0), 0 }, /* r */
3667 { "dbgdtrtx_el0", CPENC(2,3,C0
, C5
, 0), 0 }, /* w */
3668 { "osdtrrx_el1", CPENC(2,0,C0
, C0
, 2), 0 }, /* r */
3669 { "osdtrtx_el1", CPENC(2,0,C0
, C3
, 2), 0 }, /* w */
3670 { "oseccr_el1", CPENC(2,0,C0
, C6
, 2), 0 },
3671 { "dbgvcr32_el2", CPENC(2,4,C0
, C7
, 0), 0 },
3672 { "dbgbvr0_el1", CPENC(2,0,C0
, C0
, 4), 0 },
3673 { "dbgbvr1_el1", CPENC(2,0,C0
, C1
, 4), 0 },
3674 { "dbgbvr2_el1", CPENC(2,0,C0
, C2
, 4), 0 },
3675 { "dbgbvr3_el1", CPENC(2,0,C0
, C3
, 4), 0 },
3676 { "dbgbvr4_el1", CPENC(2,0,C0
, C4
, 4), 0 },
3677 { "dbgbvr5_el1", CPENC(2,0,C0
, C5
, 4), 0 },
3678 { "dbgbvr6_el1", CPENC(2,0,C0
, C6
, 4), 0 },
3679 { "dbgbvr7_el1", CPENC(2,0,C0
, C7
, 4), 0 },
3680 { "dbgbvr8_el1", CPENC(2,0,C0
, C8
, 4), 0 },
3681 { "dbgbvr9_el1", CPENC(2,0,C0
, C9
, 4), 0 },
3682 { "dbgbvr10_el1", CPENC(2,0,C0
, C10
,4), 0 },
3683 { "dbgbvr11_el1", CPENC(2,0,C0
, C11
,4), 0 },
3684 { "dbgbvr12_el1", CPENC(2,0,C0
, C12
,4), 0 },
3685 { "dbgbvr13_el1", CPENC(2,0,C0
, C13
,4), 0 },
3686 { "dbgbvr14_el1", CPENC(2,0,C0
, C14
,4), 0 },
3687 { "dbgbvr15_el1", CPENC(2,0,C0
, C15
,4), 0 },
3688 { "dbgbcr0_el1", CPENC(2,0,C0
, C0
, 5), 0 },
3689 { "dbgbcr1_el1", CPENC(2,0,C0
, C1
, 5), 0 },
3690 { "dbgbcr2_el1", CPENC(2,0,C0
, C2
, 5), 0 },
3691 { "dbgbcr3_el1", CPENC(2,0,C0
, C3
, 5), 0 },
3692 { "dbgbcr4_el1", CPENC(2,0,C0
, C4
, 5), 0 },
3693 { "dbgbcr5_el1", CPENC(2,0,C0
, C5
, 5), 0 },
3694 { "dbgbcr6_el1", CPENC(2,0,C0
, C6
, 5), 0 },
3695 { "dbgbcr7_el1", CPENC(2,0,C0
, C7
, 5), 0 },
3696 { "dbgbcr8_el1", CPENC(2,0,C0
, C8
, 5), 0 },
3697 { "dbgbcr9_el1", CPENC(2,0,C0
, C9
, 5), 0 },
3698 { "dbgbcr10_el1", CPENC(2,0,C0
, C10
,5), 0 },
3699 { "dbgbcr11_el1", CPENC(2,0,C0
, C11
,5), 0 },
3700 { "dbgbcr12_el1", CPENC(2,0,C0
, C12
,5), 0 },
3701 { "dbgbcr13_el1", CPENC(2,0,C0
, C13
,5), 0 },
3702 { "dbgbcr14_el1", CPENC(2,0,C0
, C14
,5), 0 },
3703 { "dbgbcr15_el1", CPENC(2,0,C0
, C15
,5), 0 },
3704 { "dbgwvr0_el1", CPENC(2,0,C0
, C0
, 6), 0 },
3705 { "dbgwvr1_el1", CPENC(2,0,C0
, C1
, 6), 0 },
3706 { "dbgwvr2_el1", CPENC(2,0,C0
, C2
, 6), 0 },
3707 { "dbgwvr3_el1", CPENC(2,0,C0
, C3
, 6), 0 },
3708 { "dbgwvr4_el1", CPENC(2,0,C0
, C4
, 6), 0 },
3709 { "dbgwvr5_el1", CPENC(2,0,C0
, C5
, 6), 0 },
3710 { "dbgwvr6_el1", CPENC(2,0,C0
, C6
, 6), 0 },
3711 { "dbgwvr7_el1", CPENC(2,0,C0
, C7
, 6), 0 },
3712 { "dbgwvr8_el1", CPENC(2,0,C0
, C8
, 6), 0 },
3713 { "dbgwvr9_el1", CPENC(2,0,C0
, C9
, 6), 0 },
3714 { "dbgwvr10_el1", CPENC(2,0,C0
, C10
,6), 0 },
3715 { "dbgwvr11_el1", CPENC(2,0,C0
, C11
,6), 0 },
3716 { "dbgwvr12_el1", CPENC(2,0,C0
, C12
,6), 0 },
3717 { "dbgwvr13_el1", CPENC(2,0,C0
, C13
,6), 0 },
3718 { "dbgwvr14_el1", CPENC(2,0,C0
, C14
,6), 0 },
3719 { "dbgwvr15_el1", CPENC(2,0,C0
, C15
,6), 0 },
3720 { "dbgwcr0_el1", CPENC(2,0,C0
, C0
, 7), 0 },
3721 { "dbgwcr1_el1", CPENC(2,0,C0
, C1
, 7), 0 },
3722 { "dbgwcr2_el1", CPENC(2,0,C0
, C2
, 7), 0 },
3723 { "dbgwcr3_el1", CPENC(2,0,C0
, C3
, 7), 0 },
3724 { "dbgwcr4_el1", CPENC(2,0,C0
, C4
, 7), 0 },
3725 { "dbgwcr5_el1", CPENC(2,0,C0
, C5
, 7), 0 },
3726 { "dbgwcr6_el1", CPENC(2,0,C0
, C6
, 7), 0 },
3727 { "dbgwcr7_el1", CPENC(2,0,C0
, C7
, 7), 0 },
3728 { "dbgwcr8_el1", CPENC(2,0,C0
, C8
, 7), 0 },
3729 { "dbgwcr9_el1", CPENC(2,0,C0
, C9
, 7), 0 },
3730 { "dbgwcr10_el1", CPENC(2,0,C0
, C10
,7), 0 },
3731 { "dbgwcr11_el1", CPENC(2,0,C0
, C11
,7), 0 },
3732 { "dbgwcr12_el1", CPENC(2,0,C0
, C12
,7), 0 },
3733 { "dbgwcr13_el1", CPENC(2,0,C0
, C13
,7), 0 },
3734 { "dbgwcr14_el1", CPENC(2,0,C0
, C14
,7), 0 },
3735 { "dbgwcr15_el1", CPENC(2,0,C0
, C15
,7), 0 },
3736 { "mdrar_el1", CPENC(2,0,C1
, C0
, 0), 0 }, /* r */
3737 { "oslar_el1", CPENC(2,0,C1
, C0
, 4), 0 }, /* w */
3738 { "oslsr_el1", CPENC(2,0,C1
, C1
, 4), 0 }, /* r */
3739 { "osdlr_el1", CPENC(2,0,C1
, C3
, 4), 0 },
3740 { "dbgprcr_el1", CPENC(2,0,C1
, C4
, 4), 0 },
3741 { "dbgclaimset_el1", CPENC(2,0,C7
, C8
, 6), 0 },
3742 { "dbgclaimclr_el1", CPENC(2,0,C7
, C9
, 6), 0 },
3743 { "dbgauthstatus_el1", CPENC(2,0,C7
, C14
,6), 0 }, /* r */
3744 { "pmblimitr_el1", CPENC (3, 0, C9
, C10
, 0), F_ARCHEXT
}, /* rw */
3745 { "pmbptr_el1", CPENC (3, 0, C9
, C10
, 1), F_ARCHEXT
}, /* rw */
3746 { "pmbsr_el1", CPENC (3, 0, C9
, C10
, 3), F_ARCHEXT
}, /* rw */
3747 { "pmbidr_el1", CPENC (3, 0, C9
, C10
, 7), F_ARCHEXT
}, /* ro */
3748 { "pmscr_el1", CPENC (3, 0, C9
, C9
, 0), F_ARCHEXT
}, /* rw */
3749 { "pmsicr_el1", CPENC (3, 0, C9
, C9
, 2), F_ARCHEXT
}, /* rw */
3750 { "pmsirr_el1", CPENC (3, 0, C9
, C9
, 3), F_ARCHEXT
}, /* rw */
3751 { "pmsfcr_el1", CPENC (3, 0, C9
, C9
, 4), F_ARCHEXT
}, /* rw */
3752 { "pmsevfr_el1", CPENC (3, 0, C9
, C9
, 5), F_ARCHEXT
}, /* rw */
3753 { "pmslatfr_el1", CPENC (3, 0, C9
, C9
, 6), F_ARCHEXT
}, /* rw */
3754 { "pmsidr_el1", CPENC (3, 0, C9
, C9
, 7), F_ARCHEXT
}, /* ro */
3755 { "pmscr_el2", CPENC (3, 4, C9
, C9
, 0), F_ARCHEXT
}, /* rw */
3756 { "pmscr_el12", CPENC (3, 5, C9
, C9
, 0), F_ARCHEXT
}, /* rw */
3757 { "pmcr_el0", CPENC(3,3,C9
,C12
, 0), 0 },
3758 { "pmcntenset_el0", CPENC(3,3,C9
,C12
, 1), 0 },
3759 { "pmcntenclr_el0", CPENC(3,3,C9
,C12
, 2), 0 },
3760 { "pmovsclr_el0", CPENC(3,3,C9
,C12
, 3), 0 },
3761 { "pmswinc_el0", CPENC(3,3,C9
,C12
, 4), 0 }, /* w */
3762 { "pmselr_el0", CPENC(3,3,C9
,C12
, 5), 0 },
3763 { "pmceid0_el0", CPENC(3,3,C9
,C12
, 6), 0 }, /* r */
3764 { "pmceid1_el0", CPENC(3,3,C9
,C12
, 7), 0 }, /* r */
3765 { "pmccntr_el0", CPENC(3,3,C9
,C13
, 0), 0 },
3766 { "pmxevtyper_el0", CPENC(3,3,C9
,C13
, 1), 0 },
3767 { "pmxevcntr_el0", CPENC(3,3,C9
,C13
, 2), 0 },
3768 { "pmuserenr_el0", CPENC(3,3,C9
,C14
, 0), 0 },
3769 { "pmintenset_el1", CPENC(3,0,C9
,C14
, 1), 0 },
3770 { "pmintenclr_el1", CPENC(3,0,C9
,C14
, 2), 0 },
3771 { "pmovsset_el0", CPENC(3,3,C9
,C14
, 3), 0 },
3772 { "pmevcntr0_el0", CPENC(3,3,C14
,C8
, 0), 0 },
3773 { "pmevcntr1_el0", CPENC(3,3,C14
,C8
, 1), 0 },
3774 { "pmevcntr2_el0", CPENC(3,3,C14
,C8
, 2), 0 },
3775 { "pmevcntr3_el0", CPENC(3,3,C14
,C8
, 3), 0 },
3776 { "pmevcntr4_el0", CPENC(3,3,C14
,C8
, 4), 0 },
3777 { "pmevcntr5_el0", CPENC(3,3,C14
,C8
, 5), 0 },
3778 { "pmevcntr6_el0", CPENC(3,3,C14
,C8
, 6), 0 },
3779 { "pmevcntr7_el0", CPENC(3,3,C14
,C8
, 7), 0 },
3780 { "pmevcntr8_el0", CPENC(3,3,C14
,C9
, 0), 0 },
3781 { "pmevcntr9_el0", CPENC(3,3,C14
,C9
, 1), 0 },
3782 { "pmevcntr10_el0", CPENC(3,3,C14
,C9
, 2), 0 },
3783 { "pmevcntr11_el0", CPENC(3,3,C14
,C9
, 3), 0 },
3784 { "pmevcntr12_el0", CPENC(3,3,C14
,C9
, 4), 0 },
3785 { "pmevcntr13_el0", CPENC(3,3,C14
,C9
, 5), 0 },
3786 { "pmevcntr14_el0", CPENC(3,3,C14
,C9
, 6), 0 },
3787 { "pmevcntr15_el0", CPENC(3,3,C14
,C9
, 7), 0 },
3788 { "pmevcntr16_el0", CPENC(3,3,C14
,C10
,0), 0 },
3789 { "pmevcntr17_el0", CPENC(3,3,C14
,C10
,1), 0 },
3790 { "pmevcntr18_el0", CPENC(3,3,C14
,C10
,2), 0 },
3791 { "pmevcntr19_el0", CPENC(3,3,C14
,C10
,3), 0 },
3792 { "pmevcntr20_el0", CPENC(3,3,C14
,C10
,4), 0 },
3793 { "pmevcntr21_el0", CPENC(3,3,C14
,C10
,5), 0 },
3794 { "pmevcntr22_el0", CPENC(3,3,C14
,C10
,6), 0 },
3795 { "pmevcntr23_el0", CPENC(3,3,C14
,C10
,7), 0 },
3796 { "pmevcntr24_el0", CPENC(3,3,C14
,C11
,0), 0 },
3797 { "pmevcntr25_el0", CPENC(3,3,C14
,C11
,1), 0 },
3798 { "pmevcntr26_el0", CPENC(3,3,C14
,C11
,2), 0 },
3799 { "pmevcntr27_el0", CPENC(3,3,C14
,C11
,3), 0 },
3800 { "pmevcntr28_el0", CPENC(3,3,C14
,C11
,4), 0 },
3801 { "pmevcntr29_el0", CPENC(3,3,C14
,C11
,5), 0 },
3802 { "pmevcntr30_el0", CPENC(3,3,C14
,C11
,6), 0 },
3803 { "pmevtyper0_el0", CPENC(3,3,C14
,C12
,0), 0 },
3804 { "pmevtyper1_el0", CPENC(3,3,C14
,C12
,1), 0 },
3805 { "pmevtyper2_el0", CPENC(3,3,C14
,C12
,2), 0 },
3806 { "pmevtyper3_el0", CPENC(3,3,C14
,C12
,3), 0 },
3807 { "pmevtyper4_el0", CPENC(3,3,C14
,C12
,4), 0 },
3808 { "pmevtyper5_el0", CPENC(3,3,C14
,C12
,5), 0 },
3809 { "pmevtyper6_el0", CPENC(3,3,C14
,C12
,6), 0 },
3810 { "pmevtyper7_el0", CPENC(3,3,C14
,C12
,7), 0 },
3811 { "pmevtyper8_el0", CPENC(3,3,C14
,C13
,0), 0 },
3812 { "pmevtyper9_el0", CPENC(3,3,C14
,C13
,1), 0 },
3813 { "pmevtyper10_el0", CPENC(3,3,C14
,C13
,2), 0 },
3814 { "pmevtyper11_el0", CPENC(3,3,C14
,C13
,3), 0 },
3815 { "pmevtyper12_el0", CPENC(3,3,C14
,C13
,4), 0 },
3816 { "pmevtyper13_el0", CPENC(3,3,C14
,C13
,5), 0 },
3817 { "pmevtyper14_el0", CPENC(3,3,C14
,C13
,6), 0 },
3818 { "pmevtyper15_el0", CPENC(3,3,C14
,C13
,7), 0 },
3819 { "pmevtyper16_el0", CPENC(3,3,C14
,C14
,0), 0 },
3820 { "pmevtyper17_el0", CPENC(3,3,C14
,C14
,1), 0 },
3821 { "pmevtyper18_el0", CPENC(3,3,C14
,C14
,2), 0 },
3822 { "pmevtyper19_el0", CPENC(3,3,C14
,C14
,3), 0 },
3823 { "pmevtyper20_el0", CPENC(3,3,C14
,C14
,4), 0 },
3824 { "pmevtyper21_el0", CPENC(3,3,C14
,C14
,5), 0 },
3825 { "pmevtyper22_el0", CPENC(3,3,C14
,C14
,6), 0 },
3826 { "pmevtyper23_el0", CPENC(3,3,C14
,C14
,7), 0 },
3827 { "pmevtyper24_el0", CPENC(3,3,C14
,C15
,0), 0 },
3828 { "pmevtyper25_el0", CPENC(3,3,C14
,C15
,1), 0 },
3829 { "pmevtyper26_el0", CPENC(3,3,C14
,C15
,2), 0 },
3830 { "pmevtyper27_el0", CPENC(3,3,C14
,C15
,3), 0 },
3831 { "pmevtyper28_el0", CPENC(3,3,C14
,C15
,4), 0 },
3832 { "pmevtyper29_el0", CPENC(3,3,C14
,C15
,5), 0 },
3833 { "pmevtyper30_el0", CPENC(3,3,C14
,C15
,6), 0 },
3834 { "pmccfiltr_el0", CPENC(3,3,C14
,C15
,7), 0 },
3835 { 0, CPENC(0,0,0,0,0), 0 },
3839 aarch64_sys_reg_deprecated_p (const aarch64_sys_reg
*reg
)
3841 return (reg
->flags
& F_DEPRECATED
) != 0;
3845 aarch64_sys_reg_supported_p (const aarch64_feature_set features
,
3846 const aarch64_sys_reg
*reg
)
3848 if (!(reg
->flags
& F_ARCHEXT
))
3851 /* PAN. Values are from aarch64_sys_regs. */
3852 if (reg
->value
== CPEN_(0,C2
,3)
3853 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_PAN
))
3856 /* Virtualization host extensions: system registers. */
3857 if ((reg
->value
== CPENC (3, 4, C2
, C0
, 1)
3858 || reg
->value
== CPENC (3, 4, C13
, C0
, 1)
3859 || reg
->value
== CPENC (3, 4, C14
, C3
, 0)
3860 || reg
->value
== CPENC (3, 4, C14
, C3
, 1)
3861 || reg
->value
== CPENC (3, 4, C14
, C3
, 2))
3862 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_V8_1
))
3865 /* Virtualization host extensions: *_el12 names of *_el1 registers. */
3866 if ((reg
->value
== CPEN_ (5, C0
, 0)
3867 || reg
->value
== CPEN_ (5, C0
, 1)
3868 || reg
->value
== CPENC (3, 5, C1
, C0
, 0)
3869 || reg
->value
== CPENC (3, 5, C1
, C0
, 2)
3870 || reg
->value
== CPENC (3, 5, C2
, C0
, 0)
3871 || reg
->value
== CPENC (3, 5, C2
, C0
, 1)
3872 || reg
->value
== CPENC (3, 5, C2
, C0
, 2)
3873 || reg
->value
== CPENC (3, 5, C5
, C1
, 0)
3874 || reg
->value
== CPENC (3, 5, C5
, C1
, 1)
3875 || reg
->value
== CPENC (3, 5, C5
, C2
, 0)
3876 || reg
->value
== CPENC (3, 5, C6
, C0
, 0)
3877 || reg
->value
== CPENC (3, 5, C10
, C2
, 0)
3878 || reg
->value
== CPENC (3, 5, C10
, C3
, 0)
3879 || reg
->value
== CPENC (3, 5, C12
, C0
, 0)
3880 || reg
->value
== CPENC (3, 5, C13
, C0
, 1)
3881 || reg
->value
== CPENC (3, 5, C14
, C1
, 0))
3882 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_V8_1
))
3885 /* Virtualization host extensions: *_el02 names of *_el0 registers. */
3886 if ((reg
->value
== CPENC (3, 5, C14
, C2
, 0)
3887 || reg
->value
== CPENC (3, 5, C14
, C2
, 1)
3888 || reg
->value
== CPENC (3, 5, C14
, C2
, 2)
3889 || reg
->value
== CPENC (3, 5, C14
, C3
, 0)
3890 || reg
->value
== CPENC (3, 5, C14
, C3
, 1)
3891 || reg
->value
== CPENC (3, 5, C14
, C3
, 2))
3892 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_V8_1
))
3895 /* ARMv8.2 features. */
3897 /* ID_AA64MMFR2_EL1. */
3898 if (reg
->value
== CPENC (3, 0, C0
, C7
, 2)
3899 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_V8_2
))
3903 if (reg
->value
== CPEN_ (0, C2
, 4)
3904 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_V8_2
))
3907 /* RAS extension. */
3909 /* ERRIDR_EL1, ERRSELR_EL1, ERXFR_EL1, ERXCTLR_EL1, ERXSTATUS_EL, ERXADDR_EL1,
3910 ERXMISC0_EL1 AND ERXMISC1_EL1. */
3911 if ((reg
->value
== CPENC (3, 0, C5
, C3
, 0)
3912 || reg
->value
== CPENC (3, 0, C5
, C3
, 1)
3913 || reg
->value
== CPENC (3, 0, C5
, C3
, 2)
3914 || reg
->value
== CPENC (3, 0, C5
, C3
, 3)
3915 || reg
->value
== CPENC (3, 0, C5
, C4
, 0)
3916 || reg
->value
== CPENC (3, 0, C5
, C4
, 1)
3917 || reg
->value
== CPENC (3, 0, C5
, C4
, 2)
3918 || reg
->value
== CPENC (3, 0, C5
, C4
, 3)
3919 || reg
->value
== CPENC (3, 0, C5
, C5
, 0)
3920 || reg
->value
== CPENC (3, 0, C5
, C5
, 1))
3921 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_RAS
))
3924 /* VSESR_EL2, DISR_EL1 and VDISR_EL2. */
3925 if ((reg
->value
== CPENC (3, 4, C5
, C2
, 3)
3926 || reg
->value
== CPENC (3, 0, C12
, C1
, 1)
3927 || reg
->value
== CPENC (3, 4, C12
, C1
, 1))
3928 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_RAS
))
3931 /* Statistical Profiling extension. */
3932 if ((reg
->value
== CPENC (3, 0, C9
, C10
, 0)
3933 || reg
->value
== CPENC (3, 0, C9
, C10
, 1)
3934 || reg
->value
== CPENC (3, 0, C9
, C10
, 3)
3935 || reg
->value
== CPENC (3, 0, C9
, C10
, 7)
3936 || reg
->value
== CPENC (3, 0, C9
, C9
, 0)
3937 || reg
->value
== CPENC (3, 0, C9
, C9
, 2)
3938 || reg
->value
== CPENC (3, 0, C9
, C9
, 3)
3939 || reg
->value
== CPENC (3, 0, C9
, C9
, 4)
3940 || reg
->value
== CPENC (3, 0, C9
, C9
, 5)
3941 || reg
->value
== CPENC (3, 0, C9
, C9
, 6)
3942 || reg
->value
== CPENC (3, 0, C9
, C9
, 7)
3943 || reg
->value
== CPENC (3, 4, C9
, C9
, 0)
3944 || reg
->value
== CPENC (3, 5, C9
, C9
, 0))
3945 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_PROFILE
))
3951 const aarch64_sys_reg aarch64_pstatefields
[] =
3953 { "spsel", 0x05, 0 },
3954 { "daifset", 0x1e, 0 },
3955 { "daifclr", 0x1f, 0 },
3956 { "pan", 0x04, F_ARCHEXT
},
3957 { "uao", 0x03, F_ARCHEXT
},
3958 { 0, CPENC(0,0,0,0,0), 0 },
3962 aarch64_pstatefield_supported_p (const aarch64_feature_set features
,
3963 const aarch64_sys_reg
*reg
)
3965 if (!(reg
->flags
& F_ARCHEXT
))
3968 /* PAN. Values are from aarch64_pstatefields. */
3969 if (reg
->value
== 0x04
3970 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_PAN
))
3973 /* UAO. Values are from aarch64_pstatefields. */
3974 if (reg
->value
== 0x03
3975 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_V8_2
))
3981 const aarch64_sys_ins_reg aarch64_sys_regs_ic
[] =
3983 { "ialluis", CPENS(0,C7
,C1
,0), 0 },
3984 { "iallu", CPENS(0,C7
,C5
,0), 0 },
3985 { "ivau", CPENS (3, C7
, C5
, 1), F_HASXT
},
3986 { 0, CPENS(0,0,0,0), 0 }
3989 const aarch64_sys_ins_reg aarch64_sys_regs_dc
[] =
3991 { "zva", CPENS (3, C7
, C4
, 1), F_HASXT
},
3992 { "ivac", CPENS (0, C7
, C6
, 1), F_HASXT
},
3993 { "isw", CPENS (0, C7
, C6
, 2), F_HASXT
},
3994 { "cvac", CPENS (3, C7
, C10
, 1), F_HASXT
},
3995 { "csw", CPENS (0, C7
, C10
, 2), F_HASXT
},
3996 { "cvau", CPENS (3, C7
, C11
, 1), F_HASXT
},
3997 { "cvap", CPENS (3, C7
, C12
, 1), F_HASXT
| F_ARCHEXT
},
3998 { "civac", CPENS (3, C7
, C14
, 1), F_HASXT
},
3999 { "cisw", CPENS (0, C7
, C14
, 2), F_HASXT
},
4000 { 0, CPENS(0,0,0,0), 0 }
4003 const aarch64_sys_ins_reg aarch64_sys_regs_at
[] =
4005 { "s1e1r", CPENS (0, C7
, C8
, 0), F_HASXT
},
4006 { "s1e1w", CPENS (0, C7
, C8
, 1), F_HASXT
},
4007 { "s1e0r", CPENS (0, C7
, C8
, 2), F_HASXT
},
4008 { "s1e0w", CPENS (0, C7
, C8
, 3), F_HASXT
},
4009 { "s12e1r", CPENS (4, C7
, C8
, 4), F_HASXT
},
4010 { "s12e1w", CPENS (4, C7
, C8
, 5), F_HASXT
},
4011 { "s12e0r", CPENS (4, C7
, C8
, 6), F_HASXT
},
4012 { "s12e0w", CPENS (4, C7
, C8
, 7), F_HASXT
},
4013 { "s1e2r", CPENS (4, C7
, C8
, 0), F_HASXT
},
4014 { "s1e2w", CPENS (4, C7
, C8
, 1), F_HASXT
},
4015 { "s1e3r", CPENS (6, C7
, C8
, 0), F_HASXT
},
4016 { "s1e3w", CPENS (6, C7
, C8
, 1), F_HASXT
},
4017 { "s1e1rp", CPENS (0, C7
, C9
, 0), F_HASXT
| F_ARCHEXT
},
4018 { "s1e1wp", CPENS (0, C7
, C9
, 1), F_HASXT
| F_ARCHEXT
},
4019 { 0, CPENS(0,0,0,0), 0 }
4022 const aarch64_sys_ins_reg aarch64_sys_regs_tlbi
[] =
4024 { "vmalle1", CPENS(0,C8
,C7
,0), 0 },
4025 { "vae1", CPENS (0, C8
, C7
, 1), F_HASXT
},
4026 { "aside1", CPENS (0, C8
, C7
, 2), F_HASXT
},
4027 { "vaae1", CPENS (0, C8
, C7
, 3), F_HASXT
},
4028 { "vmalle1is", CPENS(0,C8
,C3
,0), 0 },
4029 { "vae1is", CPENS (0, C8
, C3
, 1), F_HASXT
},
4030 { "aside1is", CPENS (0, C8
, C3
, 2), F_HASXT
},
4031 { "vaae1is", CPENS (0, C8
, C3
, 3), F_HASXT
},
4032 { "ipas2e1is", CPENS (4, C8
, C0
, 1), F_HASXT
},
4033 { "ipas2le1is",CPENS (4, C8
, C0
, 5), F_HASXT
},
4034 { "ipas2e1", CPENS (4, C8
, C4
, 1), F_HASXT
},
4035 { "ipas2le1", CPENS (4, C8
, C4
, 5), F_HASXT
},
4036 { "vae2", CPENS (4, C8
, C7
, 1), F_HASXT
},
4037 { "vae2is", CPENS (4, C8
, C3
, 1), F_HASXT
},
4038 { "vmalls12e1",CPENS(4,C8
,C7
,6), 0 },
4039 { "vmalls12e1is",CPENS(4,C8
,C3
,6), 0 },
4040 { "vae3", CPENS (6, C8
, C7
, 1), F_HASXT
},
4041 { "vae3is", CPENS (6, C8
, C3
, 1), F_HASXT
},
4042 { "alle2", CPENS(4,C8
,C7
,0), 0 },
4043 { "alle2is", CPENS(4,C8
,C3
,0), 0 },
4044 { "alle1", CPENS(4,C8
,C7
,4), 0 },
4045 { "alle1is", CPENS(4,C8
,C3
,4), 0 },
4046 { "alle3", CPENS(6,C8
,C7
,0), 0 },
4047 { "alle3is", CPENS(6,C8
,C3
,0), 0 },
4048 { "vale1is", CPENS (0, C8
, C3
, 5), F_HASXT
},
4049 { "vale2is", CPENS (4, C8
, C3
, 5), F_HASXT
},
4050 { "vale3is", CPENS (6, C8
, C3
, 5), F_HASXT
},
4051 { "vaale1is", CPENS (0, C8
, C3
, 7), F_HASXT
},
4052 { "vale1", CPENS (0, C8
, C7
, 5), F_HASXT
},
4053 { "vale2", CPENS (4, C8
, C7
, 5), F_HASXT
},
4054 { "vale3", CPENS (6, C8
, C7
, 5), F_HASXT
},
4055 { "vaale1", CPENS (0, C8
, C7
, 7), F_HASXT
},
4056 { 0, CPENS(0,0,0,0), 0 }
4060 aarch64_sys_ins_reg_has_xt (const aarch64_sys_ins_reg
*sys_ins_reg
)
4062 return (sys_ins_reg
->flags
& F_HASXT
) != 0;
4066 aarch64_sys_ins_reg_supported_p (const aarch64_feature_set features
,
4067 const aarch64_sys_ins_reg
*reg
)
4069 if (!(reg
->flags
& F_ARCHEXT
))
4072 /* DC CVAP. Values are from aarch64_sys_regs_dc. */
4073 if (reg
->value
== CPENS (3, C7
, C12
, 1)
4074 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_V8_2
))
4077 /* AT S1E1RP, AT S1E1WP. Values are from aarch64_sys_regs_at. */
4078 if ((reg
->value
== CPENS (0, C7
, C9
, 0)
4079 || reg
->value
== CPENS (0, C7
, C9
, 1))
4080 && !AARCH64_CPU_HAS_FEATURE (features
, AARCH64_FEATURE_V8_2
))
4103 #define BIT(INSN,BT) (((INSN) >> (BT)) & 1)
4104 #define BITS(INSN,HI,LO) (((INSN) >> (LO)) & ((1 << (((HI) - (LO)) + 1)) - 1))
4107 verify_ldpsw (const struct aarch64_opcode
* opcode ATTRIBUTE_UNUSED
,
4108 const aarch64_insn insn
)
4110 int t
= BITS (insn
, 4, 0);
4111 int n
= BITS (insn
, 9, 5);
4112 int t2
= BITS (insn
, 14, 10);
4116 /* Write back enabled. */
4117 if ((t
== n
|| t2
== n
) && n
!= 31)
4131 /* Return true if VALUE cannot be moved into an SVE register using DUP
4132 (with any element size, not just ESIZE) and if using DUPM would
4133 therefore be OK. ESIZE is the number of bytes in the immediate. */
4136 aarch64_sve_dupm_mov_immediate_p (uint64_t uvalue
, int esize
)
4138 int64_t svalue
= uvalue
;
4139 uint64_t upper
= (uint64_t) -1 << (esize
* 4) << (esize
* 4);
4141 if ((uvalue
& ~upper
) != uvalue
&& (uvalue
| upper
) != uvalue
)
4143 if (esize
<= 4 || (uint32_t) uvalue
== (uint32_t) (uvalue
>> 32))
4145 svalue
= (int32_t) uvalue
;
4146 if (esize
<= 2 || (uint16_t) uvalue
== (uint16_t) (uvalue
>> 16))
4148 svalue
= (int16_t) uvalue
;
4149 if (esize
== 1 || (uint8_t) uvalue
== (uint8_t) (uvalue
>> 8))
4153 if ((svalue
& 0xff) == 0)
4155 return svalue
< -128 || svalue
>= 128;
4158 /* Include the opcode description table as well as the operand description
4160 #define VERIFIER(x) verify_##x
4161 #include "aarch64-tbl.h"