projects / deliverable / binutils-gdb.git / blob
? search:


2a10f005a7ed6536846e38cf513e28fb25629ecc
[deliverable/binutils-gdb.git] / opcodes / aarch64-opc.c
1 /* aarch64-opc.c -- AArch64 opcode support.
2 Copyright (C) 2009-2018 Free Software Foundation, Inc.
3 Contributed by ARM Ltd.
4
5 This file is part of the GNU opcodes library.
6
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)
10 any later version.
11
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.
16
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/>. */
20
21 #include "sysdep.h"
22 #include <assert.h>
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <stdint.h>
26 #include <stdarg.h>
27 #include <inttypes.h>
28
29 #include "opintl.h"
30 #include "libiberty.h"
31
32 #include "aarch64-opc.h"
33
34 #ifdef DEBUG_AARCH64
35 int debug_dump = FALSE;
36 #endif /* DEBUG_AARCH64 */
37
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] = {
41 /* 0-7. */
42 "pow2",
43 "vl1",
44 "vl2",
45 "vl3",
46 "vl4",
47 "vl5",
48 "vl6",
49 "vl7",
50 /* 8-15. */
51 "vl8",
52 "vl16",
53 "vl32",
54 "vl64",
55 "vl128",
56 "vl256",
57 0,
58 0,
59 /* 16-23. */
60 0,
61 0,
62 0,
63 0,
64 0,
65 0,
66 0,
67 0,
68 /* 24-31. */
69 0,
70 0,
71 0,
72 0,
73 0,
74 "mul4",
75 "mul3",
76 "all"
77 };
78
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] = {
82 /* 0-7. */
83 "pldl1keep",
84 "pldl1strm",
85 "pldl2keep",
86 "pldl2strm",
87 "pldl3keep",
88 "pldl3strm",
89 0,
90 0,
91 /* 8-15. */
92 "pstl1keep",
93 "pstl1strm",
94 "pstl2keep",
95 "pstl2strm",
96 "pstl3keep",
97 "pstl3strm",
98 0,
99 0
100 };
101
102 /* Helper functions to determine which operand to be used to encode/decode
103 the size:Q fields for AdvSIMD instructions. */
104
105 static inline bfd_boolean
106 vector_qualifier_p (enum aarch64_opnd_qualifier qualifier)
107 {
108 return ((qualifier >= AARCH64_OPND_QLF_V_8B
109 && qualifier <= AARCH64_OPND_QLF_V_1Q) ? TRUE
110 : FALSE);
111 }
112
113 static inline bfd_boolean
114 fp_qualifier_p (enum aarch64_opnd_qualifier qualifier)
115 {
116 return ((qualifier >= AARCH64_OPND_QLF_S_B
117 && qualifier <= AARCH64_OPND_QLF_S_Q) ? TRUE
118 : FALSE);
119 }
120
121 enum data_pattern
122 {
123 DP_UNKNOWN,
124 DP_VECTOR_3SAME,
125 DP_VECTOR_LONG,
126 DP_VECTOR_WIDE,
127 DP_VECTOR_ACROSS_LANES,
128 };
129
130 static const char significant_operand_index [] =
131 {
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 */
137 };
138
139 /* Given a sequence of qualifiers in QUALIFIERS, determine and return
140 the data pattern.
141 N.B. QUALIFIERS is a possible sequence of qualifiers each of which
142 corresponds to one of a sequence of operands. */
143
144 static enum data_pattern
145 get_data_pattern (const aarch64_opnd_qualifier_seq_t qualifiers)
146 {
147 if (vector_qualifier_p (qualifiers[0]) == TRUE)
148 {
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].
160 or v.8h, v.16b. */
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;
175 }
176 else if (fp_qualifier_p (qualifiers[0]) == TRUE)
177 {
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;
182 }
183
184 return DP_UNKNOWN;
185 }
186
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
193 benefit. */
194
195 int
196 aarch64_select_operand_for_sizeq_field_coding (const aarch64_opcode *opcode)
197 {
198 return
199 significant_operand_index [get_data_pattern (opcode->qualifiers_list[0])];
200 }
201 \f
202 const aarch64_field fields[] =
203 {
204 { 0, 0 }, /* NIL. */
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 { 15, 6 }, /* imm6_2: in rmif instructions. */
244 { 11, 4 }, /* imm4: in advsimd ext and advsimd ins instructions. */
245 { 0, 4 }, /* imm4_2: in rmif instructions. */
246 { 16, 5 }, /* imm5: in conditional compare (immediate) instructions. */
247 { 15, 7 }, /* imm7: in load/store pair pre/post index instructions. */
248 { 13, 8 }, /* imm8: in floating-point scalar move immediate inst. */
249 { 12, 9 }, /* imm9: in load/store pre/post index instructions. */
250 { 10, 12 }, /* imm12: in ld/st unsigned imm or add/sub shifted inst. */
251 { 5, 14 }, /* imm14: in test bit and branch instructions. */
252 { 5, 16 }, /* imm16: in exception instructions. */
253 { 0, 26 }, /* imm26: in unconditional branch instructions. */
254 { 10, 6 }, /* imms: in bitfield and logical immediate instructions. */
255 { 16, 6 }, /* immr: in bitfield and logical immediate instructions. */
256 { 16, 3 }, /* immb: in advsimd shift by immediate instructions. */
257 { 19, 4 }, /* immh: in advsimd shift by immediate instructions. */
258 { 22, 1 }, /* S: in LDRAA and LDRAB instructions. */
259 { 22, 1 }, /* N: in logical (immediate) instructions. */
260 { 11, 1 }, /* index: in ld/st inst deciding the pre/post-index. */
261 { 24, 1 }, /* index2: in ld/st pair inst deciding the pre/post-index. */
262 { 31, 1 }, /* sf: in integer data processing instructions. */
263 { 30, 1 }, /* lse_size: in LSE extension atomic instructions. */
264 { 11, 1 }, /* H: in advsimd scalar x indexed element instructions. */
265 { 21, 1 }, /* L: in advsimd scalar x indexed element instructions. */
266 { 20, 1 }, /* M: in advsimd scalar x indexed element instructions. */
267 { 31, 1 }, /* b5: in the test bit and branch instructions. */
268 { 19, 5 }, /* b40: in the test bit and branch instructions. */
269 { 10, 6 }, /* scale: in the fixed-point scalar to fp converting inst. */
270 { 4, 1 }, /* SVE_M_4: Merge/zero select, bit 4. */
271 { 14, 1 }, /* SVE_M_14: Merge/zero select, bit 14. */
272 { 16, 1 }, /* SVE_M_16: Merge/zero select, bit 16. */
273 { 17, 1 }, /* SVE_N: SVE equivalent of N. */
274 { 0, 4 }, /* SVE_Pd: p0-p15, bits [3,0]. */
275 { 10, 3 }, /* SVE_Pg3: p0-p7, bits [12,10]. */
276 { 5, 4 }, /* SVE_Pg4_5: p0-p15, bits [8,5]. */
277 { 10, 4 }, /* SVE_Pg4_10: p0-p15, bits [13,10]. */
278 { 16, 4 }, /* SVE_Pg4_16: p0-p15, bits [19,16]. */
279 { 16, 4 }, /* SVE_Pm: p0-p15, bits [19,16]. */
280 { 5, 4 }, /* SVE_Pn: p0-p15, bits [8,5]. */
281 { 0, 4 }, /* SVE_Pt: p0-p15, bits [3,0]. */
282 { 5, 5 }, /* SVE_Rm: SVE alternative position for Rm. */
283 { 16, 5 }, /* SVE_Rn: SVE alternative position for Rn. */
284 { 0, 5 }, /* SVE_Vd: Scalar SIMD&FP register, bits [4,0]. */
285 { 5, 5 }, /* SVE_Vm: Scalar SIMD&FP register, bits [9,5]. */
286 { 5, 5 }, /* SVE_Vn: Scalar SIMD&FP register, bits [9,5]. */
287 { 5, 5 }, /* SVE_Za_5: SVE vector register, bits [9,5]. */
288 { 16, 5 }, /* SVE_Za_16: SVE vector register, bits [20,16]. */
289 { 0, 5 }, /* SVE_Zd: SVE vector register. bits [4,0]. */
290 { 5, 5 }, /* SVE_Zm_5: SVE vector register, bits [9,5]. */
291 { 16, 5 }, /* SVE_Zm_16: SVE vector register, bits [20,16]. */
292 { 5, 5 }, /* SVE_Zn: SVE vector register, bits [9,5]. */
293 { 0, 5 }, /* SVE_Zt: SVE vector register, bits [4,0]. */
294 { 5, 1 }, /* SVE_i1: single-bit immediate. */
295 { 22, 1 }, /* SVE_i3h: high bit of 3-bit immediate. */
296 { 16, 3 }, /* SVE_imm3: 3-bit immediate field. */
297 { 16, 4 }, /* SVE_imm4: 4-bit immediate field. */
298 { 5, 5 }, /* SVE_imm5: 5-bit immediate field. */
299 { 16, 5 }, /* SVE_imm5b: secondary 5-bit immediate field. */
300 { 16, 6 }, /* SVE_imm6: 6-bit immediate field. */
301 { 14, 7 }, /* SVE_imm7: 7-bit immediate field. */
302 { 5, 8 }, /* SVE_imm8: 8-bit immediate field. */
303 { 5, 9 }, /* SVE_imm9: 9-bit immediate field. */
304 { 11, 6 }, /* SVE_immr: SVE equivalent of immr. */
305 { 5, 6 }, /* SVE_imms: SVE equivalent of imms. */
306 { 10, 2 }, /* SVE_msz: 2-bit shift amount for ADR. */
307 { 5, 5 }, /* SVE_pattern: vector pattern enumeration. */
308 { 0, 4 }, /* SVE_prfop: prefetch operation for SVE PRF[BHWD]. */
309 { 16, 1 }, /* SVE_rot1: 1-bit rotation amount. */
310 { 10, 2 }, /* SVE_rot2: 2-bit rotation amount. */
311 { 22, 1 }, /* SVE_sz: 1-bit element size select. */
312 { 16, 4 }, /* SVE_tsz: triangular size select. */
313 { 22, 2 }, /* SVE_tszh: triangular size select high, bits [23,22]. */
314 { 8, 2 }, /* SVE_tszl_8: triangular size select low, bits [9,8]. */
315 { 19, 2 }, /* SVE_tszl_19: triangular size select low, bits [20,19]. */
316 { 14, 1 }, /* SVE_xs_14: UXTW/SXTW select (bit 14). */
317 { 22, 1 }, /* SVE_xs_22: UXTW/SXTW select (bit 22). */
318 { 11, 2 }, /* rotate1: FCMLA immediate rotate. */
319 { 13, 2 }, /* rotate2: Indexed element FCMLA immediate rotate. */
320 { 12, 1 }, /* rotate3: FCADD immediate rotate. */
321 { 12, 2 }, /* SM3: Indexed element SM3 2 bits index immediate. */
322 };
323
324 enum aarch64_operand_class
325 aarch64_get_operand_class (enum aarch64_opnd type)
326 {
327 return aarch64_operands[type].op_class;
328 }
329
330 const char *
331 aarch64_get_operand_name (enum aarch64_opnd type)
332 {
333 return aarch64_operands[type].name;
334 }
335
336 /* Get operand description string.
337 This is usually for the diagnosis purpose. */
338 const char *
339 aarch64_get_operand_desc (enum aarch64_opnd type)
340 {
341 return aarch64_operands[type].desc;
342 }
343
344 /* Table of all conditional affixes. */
345 const aarch64_cond aarch64_conds[16] =
346 {
347 {{"eq", "none"}, 0x0},
348 {{"ne", "any"}, 0x1},
349 {{"cs", "hs", "nlast"}, 0x2},
350 {{"cc", "lo", "ul", "last"}, 0x3},
351 {{"mi", "first"}, 0x4},
352 {{"pl", "nfrst"}, 0x5},
353 {{"vs"}, 0x6},
354 {{"vc"}, 0x7},
355 {{"hi", "pmore"}, 0x8},
356 {{"ls", "plast"}, 0x9},
357 {{"ge", "tcont"}, 0xa},
358 {{"lt", "tstop"}, 0xb},
359 {{"gt"}, 0xc},
360 {{"le"}, 0xd},
361 {{"al"}, 0xe},
362 {{"nv"}, 0xf},
363 };
364
365 const aarch64_cond *
366 get_cond_from_value (aarch64_insn value)
367 {
368 assert (value < 16);
369 return &aarch64_conds[(unsigned int) value];
370 }
371
372 const aarch64_cond *
373 get_inverted_cond (const aarch64_cond *cond)
374 {
375 return &aarch64_conds[cond->value ^ 0x1];
376 }
377
378 /* Table describing the operand extension/shifting operators; indexed by
379 enum aarch64_modifier_kind.
380
381 The value column provides the most common values for encoding modifiers,
382 which enables table-driven encoding/decoding for the modifiers. */
383 const struct aarch64_name_value_pair aarch64_operand_modifiers [] =
384 {
385 {"none", 0x0},
386 {"msl", 0x0},
387 {"ror", 0x3},
388 {"asr", 0x2},
389 {"lsr", 0x1},
390 {"lsl", 0x0},
391 {"uxtb", 0x0},
392 {"uxth", 0x1},
393 {"uxtw", 0x2},
394 {"uxtx", 0x3},
395 {"sxtb", 0x4},
396 {"sxth", 0x5},
397 {"sxtw", 0x6},
398 {"sxtx", 0x7},
399 {"mul", 0x0},
400 {"mul vl", 0x0},
401 {NULL, 0},
402 };
403
404 enum aarch64_modifier_kind
405 aarch64_get_operand_modifier (const struct aarch64_name_value_pair *desc)
406 {
407 return desc - aarch64_operand_modifiers;
408 }
409
410 aarch64_insn
411 aarch64_get_operand_modifier_value (enum aarch64_modifier_kind kind)
412 {
413 return aarch64_operand_modifiers[kind].value;
414 }
415
416 enum aarch64_modifier_kind
417 aarch64_get_operand_modifier_from_value (aarch64_insn value,
418 bfd_boolean extend_p)
419 {
420 if (extend_p == TRUE)
421 return AARCH64_MOD_UXTB + value;
422 else
423 return AARCH64_MOD_LSL - value;
424 }
425
426 bfd_boolean
427 aarch64_extend_operator_p (enum aarch64_modifier_kind kind)
428 {
429 return (kind > AARCH64_MOD_LSL && kind <= AARCH64_MOD_SXTX)
430 ? TRUE : FALSE;
431 }
432
433 static inline bfd_boolean
434 aarch64_shift_operator_p (enum aarch64_modifier_kind kind)
435 {
436 return (kind >= AARCH64_MOD_ROR && kind <= AARCH64_MOD_LSL)
437 ? TRUE : FALSE;
438 }
439
440 const struct aarch64_name_value_pair aarch64_barrier_options[16] =
441 {
442 { "#0x00", 0x0 },
443 { "oshld", 0x1 },
444 { "oshst", 0x2 },
445 { "osh", 0x3 },
446 { "#0x04", 0x4 },
447 { "nshld", 0x5 },
448 { "nshst", 0x6 },
449 { "nsh", 0x7 },
450 { "#0x08", 0x8 },
451 { "ishld", 0x9 },
452 { "ishst", 0xa },
453 { "ish", 0xb },
454 { "#0x0c", 0xc },
455 { "ld", 0xd },
456 { "st", 0xe },
457 { "sy", 0xf },
458 };
459
460 /* Table describing the operands supported by the aliases of the HINT
461 instruction.
462
463 The name column is the operand that is accepted for the alias. The value
464 column is the hint number of the alias. The list of operands is terminated
465 by NULL in the name column. */
466
467 const struct aarch64_name_value_pair aarch64_hint_options[] =
468 {
469 { "csync", 0x11 }, /* PSB CSYNC. */
470 { NULL, 0x0 },
471 };
472
473 /* op -> op: load = 0 instruction = 1 store = 2
474 l -> level: 1-3
475 t -> temporal: temporal (retained) = 0 non-temporal (streaming) = 1 */
476 #define B(op,l,t) (((op) << 3) | (((l) - 1) << 1) | (t))
477 const struct aarch64_name_value_pair aarch64_prfops[32] =
478 {
479 { "pldl1keep", B(0, 1, 0) },
480 { "pldl1strm", B(0, 1, 1) },
481 { "pldl2keep", B(0, 2, 0) },
482 { "pldl2strm", B(0, 2, 1) },
483 { "pldl3keep", B(0, 3, 0) },
484 { "pldl3strm", B(0, 3, 1) },
485 { NULL, 0x06 },
486 { NULL, 0x07 },
487 { "plil1keep", B(1, 1, 0) },
488 { "plil1strm", B(1, 1, 1) },
489 { "plil2keep", B(1, 2, 0) },
490 { "plil2strm", B(1, 2, 1) },
491 { "plil3keep", B(1, 3, 0) },
492 { "plil3strm", B(1, 3, 1) },
493 { NULL, 0x0e },
494 { NULL, 0x0f },
495 { "pstl1keep", B(2, 1, 0) },
496 { "pstl1strm", B(2, 1, 1) },
497 { "pstl2keep", B(2, 2, 0) },
498 { "pstl2strm", B(2, 2, 1) },
499 { "pstl3keep", B(2, 3, 0) },
500 { "pstl3strm", B(2, 3, 1) },
501 { NULL, 0x16 },
502 { NULL, 0x17 },
503 { NULL, 0x18 },
504 { NULL, 0x19 },
505 { NULL, 0x1a },
506 { NULL, 0x1b },
507 { NULL, 0x1c },
508 { NULL, 0x1d },
509 { NULL, 0x1e },
510 { NULL, 0x1f },
511 };
512 #undef B
513 \f
514 /* Utilities on value constraint. */
515
516 static inline int
517 value_in_range_p (int64_t value, int low, int high)
518 {
519 return (value >= low && value <= high) ? 1 : 0;
520 }
521
522 /* Return true if VALUE is a multiple of ALIGN. */
523 static inline int
524 value_aligned_p (int64_t value, int align)
525 {
526 return (value % align) == 0;
527 }
528
529 /* A signed value fits in a field. */
530 static inline int
531 value_fit_signed_field_p (int64_t value, unsigned width)
532 {
533 assert (width < 32);
534 if (width < sizeof (value) * 8)
535 {
536 int64_t lim = (int64_t)1 << (width - 1);
537 if (value >= -lim && value < lim)
538 return 1;
539 }
540 return 0;
541 }
542
543 /* An unsigned value fits in a field. */
544 static inline int
545 value_fit_unsigned_field_p (int64_t value, unsigned width)
546 {
547 assert (width < 32);
548 if (width < sizeof (value) * 8)
549 {
550 int64_t lim = (int64_t)1 << width;
551 if (value >= 0 && value < lim)
552 return 1;
553 }
554 return 0;
555 }
556
557 /* Return 1 if OPERAND is SP or WSP. */
558 int
559 aarch64_stack_pointer_p (const aarch64_opnd_info *operand)
560 {
561 return ((aarch64_get_operand_class (operand->type)
562 == AARCH64_OPND_CLASS_INT_REG)
563 && operand_maybe_stack_pointer (aarch64_operands + operand->type)
564 && operand->reg.regno == 31);
565 }
566
567 /* Return 1 if OPERAND is XZR or WZP. */
568 int
569 aarch64_zero_register_p (const aarch64_opnd_info *operand)
570 {
571 return ((aarch64_get_operand_class (operand->type)
572 == AARCH64_OPND_CLASS_INT_REG)
573 && !operand_maybe_stack_pointer (aarch64_operands + operand->type)
574 && operand->reg.regno == 31);
575 }
576
577 /* Return true if the operand *OPERAND that has the operand code
578 OPERAND->TYPE and been qualified by OPERAND->QUALIFIER can be also
579 qualified by the qualifier TARGET. */
580
581 static inline int
582 operand_also_qualified_p (const struct aarch64_opnd_info *operand,
583 aarch64_opnd_qualifier_t target)
584 {
585 switch (operand->qualifier)
586 {
587 case AARCH64_OPND_QLF_W:
588 if (target == AARCH64_OPND_QLF_WSP && aarch64_stack_pointer_p (operand))
589 return 1;
590 break;
591 case AARCH64_OPND_QLF_X:
592 if (target == AARCH64_OPND_QLF_SP && aarch64_stack_pointer_p (operand))
593 return 1;
594 break;
595 case AARCH64_OPND_QLF_WSP:
596 if (target == AARCH64_OPND_QLF_W
597 && operand_maybe_stack_pointer (aarch64_operands + operand->type))
598 return 1;
599 break;
600 case AARCH64_OPND_QLF_SP:
601 if (target == AARCH64_OPND_QLF_X
602 && operand_maybe_stack_pointer (aarch64_operands + operand->type))
603 return 1;
604 break;
605 default:
606 break;
607 }
608
609 return 0;
610 }
611
612 /* Given qualifier sequence list QSEQ_LIST and the known qualifier KNOWN_QLF
613 for operand KNOWN_IDX, return the expected qualifier for operand IDX.
614
615 Return NIL if more than one expected qualifiers are found. */
616
617 aarch64_opnd_qualifier_t
618 aarch64_get_expected_qualifier (const aarch64_opnd_qualifier_seq_t *qseq_list,
619 int idx,
620 const aarch64_opnd_qualifier_t known_qlf,
621 int known_idx)
622 {
623 int i, saved_i;
624
625 /* Special case.
626
627 When the known qualifier is NIL, we have to assume that there is only
628 one qualifier sequence in the *QSEQ_LIST and return the corresponding
629 qualifier directly. One scenario is that for instruction
630 PRFM <prfop>, [<Xn|SP>, #:lo12:<symbol>]
631 which has only one possible valid qualifier sequence
632 NIL, S_D
633 the caller may pass NIL in KNOWN_QLF to obtain S_D so that it can
634 determine the correct relocation type (i.e. LDST64_LO12) for PRFM.
635
636 Because the qualifier NIL has dual roles in the qualifier sequence:
637 it can mean no qualifier for the operand, or the qualifer sequence is
638 not in use (when all qualifiers in the sequence are NILs), we have to
639 handle this special case here. */
640 if (known_qlf == AARCH64_OPND_NIL)
641 {
642 assert (qseq_list[0][known_idx] == AARCH64_OPND_NIL);
643 return qseq_list[0][idx];
644 }
645
646 for (i = 0, saved_i = -1; i < AARCH64_MAX_QLF_SEQ_NUM; ++i)
647 {
648 if (qseq_list[i][known_idx] == known_qlf)
649 {
650 if (saved_i != -1)
651 /* More than one sequences are found to have KNOWN_QLF at
652 KNOWN_IDX. */
653 return AARCH64_OPND_NIL;
654 saved_i = i;
655 }
656 }
657
658 return qseq_list[saved_i][idx];
659 }
660
661 enum operand_qualifier_kind
662 {
663 OQK_NIL,
664 OQK_OPD_VARIANT,
665 OQK_VALUE_IN_RANGE,
666 OQK_MISC,
667 };
668
669 /* Operand qualifier description. */
670 struct operand_qualifier_data
671 {
672 /* The usage of the three data fields depends on the qualifier kind. */
673 int data0;
674 int data1;
675 int data2;
676 /* Description. */
677 const char *desc;
678 /* Kind. */
679 enum operand_qualifier_kind kind;
680 };
681
682 /* Indexed by the operand qualifier enumerators. */
683 struct operand_qualifier_data aarch64_opnd_qualifiers[] =
684 {
685 {0, 0, 0, "NIL", OQK_NIL},
686
687 /* Operand variant qualifiers.
688 First 3 fields:
689 element size, number of elements and common value for encoding. */
690
691 {4, 1, 0x0, "w", OQK_OPD_VARIANT},
692 {8, 1, 0x1, "x", OQK_OPD_VARIANT},
693 {4, 1, 0x0, "wsp", OQK_OPD_VARIANT},
694 {8, 1, 0x1, "sp", OQK_OPD_VARIANT},
695
696 {1, 1, 0x0, "b", OQK_OPD_VARIANT},
697 {2, 1, 0x1, "h", OQK_OPD_VARIANT},
698 {4, 1, 0x2, "s", OQK_OPD_VARIANT},
699 {8, 1, 0x3, "d", OQK_OPD_VARIANT},
700 {16, 1, 0x4, "q", OQK_OPD_VARIANT},
701 {1, 4, 0x0, "4b", OQK_OPD_VARIANT},
702
703 {1, 4, 0x0, "4b", OQK_OPD_VARIANT},
704 {1, 8, 0x0, "8b", OQK_OPD_VARIANT},
705 {1, 16, 0x1, "16b", OQK_OPD_VARIANT},
706 {2, 2, 0x0, "2h", OQK_OPD_VARIANT},
707 {2, 4, 0x2, "4h", OQK_OPD_VARIANT},
708 {2, 8, 0x3, "8h", OQK_OPD_VARIANT},
709 {4, 2, 0x4, "2s", OQK_OPD_VARIANT},
710 {4, 4, 0x5, "4s", OQK_OPD_VARIANT},
711 {8, 1, 0x6, "1d", OQK_OPD_VARIANT},
712 {8, 2, 0x7, "2d", OQK_OPD_VARIANT},
713 {16, 1, 0x8, "1q", OQK_OPD_VARIANT},
714
715 {0, 0, 0, "z", OQK_OPD_VARIANT},
716 {0, 0, 0, "m", OQK_OPD_VARIANT},
717
718 /* Qualifiers constraining the value range.
719 First 3 fields:
720 Lower bound, higher bound, unused. */
721
722 {0, 15, 0, "CR", OQK_VALUE_IN_RANGE},
723 {0, 7, 0, "imm_0_7" , OQK_VALUE_IN_RANGE},
724 {0, 15, 0, "imm_0_15", OQK_VALUE_IN_RANGE},
725 {0, 31, 0, "imm_0_31", OQK_VALUE_IN_RANGE},
726 {0, 63, 0, "imm_0_63", OQK_VALUE_IN_RANGE},
727 {1, 32, 0, "imm_1_32", OQK_VALUE_IN_RANGE},
728 {1, 64, 0, "imm_1_64", OQK_VALUE_IN_RANGE},
729
730 /* Qualifiers for miscellaneous purpose.
731 First 3 fields:
732 unused, unused and unused. */
733
734 {0, 0, 0, "lsl", 0},
735 {0, 0, 0, "msl", 0},
736
737 {0, 0, 0, "retrieving", 0},
738 };
739
740 static inline bfd_boolean
741 operand_variant_qualifier_p (aarch64_opnd_qualifier_t qualifier)
742 {
743 return (aarch64_opnd_qualifiers[qualifier].kind == OQK_OPD_VARIANT)
744 ? TRUE : FALSE;
745 }
746
747 static inline bfd_boolean
748 qualifier_value_in_range_constraint_p (aarch64_opnd_qualifier_t qualifier)
749 {
750 return (aarch64_opnd_qualifiers[qualifier].kind == OQK_VALUE_IN_RANGE)
751 ? TRUE : FALSE;
752 }
753
754 const char*
755 aarch64_get_qualifier_name (aarch64_opnd_qualifier_t qualifier)
756 {
757 return aarch64_opnd_qualifiers[qualifier].desc;
758 }
759
760 /* Given an operand qualifier, return the expected data element size
761 of a qualified operand. */
762 unsigned char
763 aarch64_get_qualifier_esize (aarch64_opnd_qualifier_t qualifier)
764 {
765 assert (operand_variant_qualifier_p (qualifier) == TRUE);
766 return aarch64_opnd_qualifiers[qualifier].data0;
767 }
768
769 unsigned char
770 aarch64_get_qualifier_nelem (aarch64_opnd_qualifier_t qualifier)
771 {
772 assert (operand_variant_qualifier_p (qualifier) == TRUE);
773 return aarch64_opnd_qualifiers[qualifier].data1;
774 }
775
776 aarch64_insn
777 aarch64_get_qualifier_standard_value (aarch64_opnd_qualifier_t qualifier)
778 {
779 assert (operand_variant_qualifier_p (qualifier) == TRUE);
780 return aarch64_opnd_qualifiers[qualifier].data2;
781 }
782
783 static int
784 get_lower_bound (aarch64_opnd_qualifier_t qualifier)
785 {
786 assert (qualifier_value_in_range_constraint_p (qualifier) == TRUE);
787 return aarch64_opnd_qualifiers[qualifier].data0;
788 }
789
790 static int
791 get_upper_bound (aarch64_opnd_qualifier_t qualifier)
792 {
793 assert (qualifier_value_in_range_constraint_p (qualifier) == TRUE);
794 return aarch64_opnd_qualifiers[qualifier].data1;
795 }
796
797 #ifdef DEBUG_AARCH64
798 void
799 aarch64_verbose (const char *str, ...)
800 {
801 va_list ap;
802 va_start (ap, str);
803 printf ("#### ");
804 vprintf (str, ap);
805 printf ("\n");
806 va_end (ap);
807 }
808
809 static inline void
810 dump_qualifier_sequence (const aarch64_opnd_qualifier_t *qualifier)
811 {
812 int i;
813 printf ("#### \t");
814 for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i, ++qualifier)
815 printf ("%s,", aarch64_get_qualifier_name (*qualifier));
816 printf ("\n");
817 }
818
819 static void
820 dump_match_qualifiers (const struct aarch64_opnd_info *opnd,
821 const aarch64_opnd_qualifier_t *qualifier)
822 {
823 int i;
824 aarch64_opnd_qualifier_t curr[AARCH64_MAX_OPND_NUM];
825
826 aarch64_verbose ("dump_match_qualifiers:");
827 for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
828 curr[i] = opnd[i].qualifier;
829 dump_qualifier_sequence (curr);
830 aarch64_verbose ("against");
831 dump_qualifier_sequence (qualifier);
832 }
833 #endif /* DEBUG_AARCH64 */
834
835 /* TODO improve this, we can have an extra field at the runtime to
836 store the number of operands rather than calculating it every time. */
837
838 int
839 aarch64_num_of_operands (const aarch64_opcode *opcode)
840 {
841 int i = 0;
842 const enum aarch64_opnd *opnds = opcode->operands;
843 while (opnds[i++] != AARCH64_OPND_NIL)
844 ;
845 --i;
846 assert (i >= 0 && i <= AARCH64_MAX_OPND_NUM);
847 return i;
848 }
849
850 /* Find the best matched qualifier sequence in *QUALIFIERS_LIST for INST.
851 If succeeds, fill the found sequence in *RET, return 1; otherwise return 0.
852
853 N.B. on the entry, it is very likely that only some operands in *INST
854 have had their qualifiers been established.
855
856 If STOP_AT is not -1, the function will only try to match
857 the qualifier sequence for operands before and including the operand
858 of index STOP_AT; and on success *RET will only be filled with the first
859 (STOP_AT+1) qualifiers.
860
861 A couple examples of the matching algorithm:
862
863 X,W,NIL should match
864 X,W,NIL
865
866 NIL,NIL should match
867 X ,NIL
868
869 Apart from serving the main encoding routine, this can also be called
870 during or after the operand decoding. */
871
872 int
873 aarch64_find_best_match (const aarch64_inst *inst,
874 const aarch64_opnd_qualifier_seq_t *qualifiers_list,
875 int stop_at, aarch64_opnd_qualifier_t *ret)
876 {
877 int found = 0;
878 int i, num_opnds;
879 const aarch64_opnd_qualifier_t *qualifiers;
880
881 num_opnds = aarch64_num_of_operands (inst->opcode);
882 if (num_opnds == 0)
883 {
884 DEBUG_TRACE ("SUCCEED: no operand");
885 return 1;
886 }
887
888 if (stop_at < 0 || stop_at >= num_opnds)
889 stop_at = num_opnds - 1;
890
891 /* For each pattern. */
892 for (i = 0; i < AARCH64_MAX_QLF_SEQ_NUM; ++i, ++qualifiers_list)
893 {
894 int j;
895 qualifiers = *qualifiers_list;
896
897 /* Start as positive. */
898 found = 1;
899
900 DEBUG_TRACE ("%d", i);
901 #ifdef DEBUG_AARCH64
902 if (debug_dump)
903 dump_match_qualifiers (inst->operands, qualifiers);
904 #endif
905
906 /* Most opcodes has much fewer patterns in the list.
907 First NIL qualifier indicates the end in the list. */
908 if (empty_qualifier_sequence_p (qualifiers) == TRUE)
909 {
910 DEBUG_TRACE_IF (i == 0, "SUCCEED: empty qualifier list");
911 if (i)
912 found = 0;
913 break;
914 }
915
916 for (j = 0; j < num_opnds && j <= stop_at; ++j, ++qualifiers)
917 {
918 if (inst->operands[j].qualifier == AARCH64_OPND_QLF_NIL)
919 {
920 /* Either the operand does not have qualifier, or the qualifier
921 for the operand needs to be deduced from the qualifier
922 sequence.
923 In the latter case, any constraint checking related with
924 the obtained qualifier should be done later in
925 operand_general_constraint_met_p. */
926 continue;
927 }
928 else if (*qualifiers != inst->operands[j].qualifier)
929 {
930 /* Unless the target qualifier can also qualify the operand
931 (which has already had a non-nil qualifier), non-equal
932 qualifiers are generally un-matched. */
933 if (operand_also_qualified_p (inst->operands + j, *qualifiers))
934 continue;
935 else
936 {
937 found = 0;
938 break;
939 }
940 }
941 else
942 continue; /* Equal qualifiers are certainly matched. */
943 }
944
945 /* Qualifiers established. */
946 if (found == 1)
947 break;
948 }
949
950 if (found == 1)
951 {
952 /* Fill the result in *RET. */
953 int j;
954 qualifiers = *qualifiers_list;
955
956 DEBUG_TRACE ("complete qualifiers using list %d", i);
957 #ifdef DEBUG_AARCH64
958 if (debug_dump)
959 dump_qualifier_sequence (qualifiers);
960 #endif
961
962 for (j = 0; j <= stop_at; ++j, ++qualifiers)
963 ret[j] = *qualifiers;
964 for (; j < AARCH64_MAX_OPND_NUM; ++j)
965 ret[j] = AARCH64_OPND_QLF_NIL;
966
967 DEBUG_TRACE ("SUCCESS");
968 return 1;
969 }
970
971 DEBUG_TRACE ("FAIL");
972 return 0;
973 }
974
975 /* Operand qualifier matching and resolving.
976
977 Return 1 if the operand qualifier(s) in *INST match one of the qualifier
978 sequences in INST->OPCODE->qualifiers_list; otherwise return 0.
979
980 if UPDATE_P == TRUE, update the qualifier(s) in *INST after the matching
981 succeeds. */
982
983 static int
984 match_operands_qualifier (aarch64_inst *inst, bfd_boolean update_p)
985 {
986 int i, nops;
987 aarch64_opnd_qualifier_seq_t qualifiers;
988
989 if (!aarch64_find_best_match (inst, inst->opcode->qualifiers_list, -1,
990 qualifiers))
991 {
992 DEBUG_TRACE ("matching FAIL");
993 return 0;
994 }
995
996 if (inst->opcode->flags & F_STRICT)
997 {
998 /* Require an exact qualifier match, even for NIL qualifiers. */
999 nops = aarch64_num_of_operands (inst->opcode);
1000 for (i = 0; i < nops; ++i)
1001 if (inst->operands[i].qualifier != qualifiers[i])
1002 return FALSE;
1003 }
1004
1005 /* Update the qualifiers. */
1006 if (update_p == TRUE)
1007 for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
1008 {
1009 if (inst->opcode->operands[i] == AARCH64_OPND_NIL)
1010 break;
1011 DEBUG_TRACE_IF (inst->operands[i].qualifier != qualifiers[i],
1012 "update %s with %s for operand %d",
1013 aarch64_get_qualifier_name (inst->operands[i].qualifier),
1014 aarch64_get_qualifier_name (qualifiers[i]), i);
1015 inst->operands[i].qualifier = qualifiers[i];
1016 }
1017
1018 DEBUG_TRACE ("matching SUCCESS");
1019 return 1;
1020 }
1021
1022 /* Return TRUE if VALUE is a wide constant that can be moved into a general
1023 register by MOVZ.
1024
1025 IS32 indicates whether value is a 32-bit immediate or not.
1026 If SHIFT_AMOUNT is not NULL, on the return of TRUE, the logical left shift
1027 amount will be returned in *SHIFT_AMOUNT. */
1028
1029 bfd_boolean
1030 aarch64_wide_constant_p (int64_t value, int is32, unsigned int *shift_amount)
1031 {
1032 int amount;
1033
1034 DEBUG_TRACE ("enter with 0x%" PRIx64 "(%" PRIi64 ")", value, value);
1035
1036 if (is32)
1037 {
1038 /* Allow all zeros or all ones in top 32-bits, so that
1039 32-bit constant expressions like ~0x80000000 are
1040 permitted. */
1041 uint64_t ext = value;
1042 if (ext >> 32 != 0 && ext >> 32 != (uint64_t) 0xffffffff)
1043 /* Immediate out of range. */
1044 return FALSE;
1045 value &= (int64_t) 0xffffffff;
1046 }
1047
1048 /* first, try movz then movn */
1049 amount = -1;
1050 if ((value & ((int64_t) 0xffff << 0)) == value)
1051 amount = 0;
1052 else if ((value & ((int64_t) 0xffff << 16)) == value)
1053 amount = 16;
1054 else if (!is32 && (value & ((int64_t) 0xffff << 32)) == value)
1055 amount = 32;
1056 else if (!is32 && (value & ((int64_t) 0xffff << 48)) == value)
1057 amount = 48;
1058
1059 if (amount == -1)
1060 {
1061 DEBUG_TRACE ("exit FALSE with 0x%" PRIx64 "(%" PRIi64 ")", value, value);
1062 return FALSE;
1063 }
1064
1065 if (shift_amount != NULL)
1066 *shift_amount = amount;
1067
1068 DEBUG_TRACE ("exit TRUE with amount %d", amount);
1069
1070 return TRUE;
1071 }
1072
1073 /* Build the accepted values for immediate logical SIMD instructions.
1074
1075 The standard encodings of the immediate value are:
1076 N imms immr SIMD size R S
1077 1 ssssss rrrrrr 64 UInt(rrrrrr) UInt(ssssss)
1078 0 0sssss 0rrrrr 32 UInt(rrrrr) UInt(sssss)
1079 0 10ssss 00rrrr 16 UInt(rrrr) UInt(ssss)
1080 0 110sss 000rrr 8 UInt(rrr) UInt(sss)
1081 0 1110ss 0000rr 4 UInt(rr) UInt(ss)
1082 0 11110s 00000r 2 UInt(r) UInt(s)
1083 where all-ones value of S is reserved.
1084
1085 Let's call E the SIMD size.
1086
1087 The immediate value is: S+1 bits '1' rotated to the right by R.
1088
1089 The total of valid encodings is 64*63 + 32*31 + ... + 2*1 = 5334
1090 (remember S != E - 1). */
1091
1092 #define TOTAL_IMM_NB 5334
1093
1094 typedef struct
1095 {
1096 uint64_t imm;
1097 aarch64_insn encoding;
1098 } simd_imm_encoding;
1099
1100 static simd_imm_encoding simd_immediates[TOTAL_IMM_NB];
1101
1102 static int
1103 simd_imm_encoding_cmp(const void *i1, const void *i2)
1104 {
1105 const simd_imm_encoding *imm1 = (const simd_imm_encoding *)i1;
1106 const simd_imm_encoding *imm2 = (const simd_imm_encoding *)i2;
1107
1108 if (imm1->imm < imm2->imm)
1109 return -1;
1110 if (imm1->imm > imm2->imm)
1111 return +1;
1112 return 0;
1113 }
1114
1115 /* immediate bitfield standard encoding
1116 imm13<12> imm13<5:0> imm13<11:6> SIMD size R S
1117 1 ssssss rrrrrr 64 rrrrrr ssssss
1118 0 0sssss 0rrrrr 32 rrrrr sssss
1119 0 10ssss 00rrrr 16 rrrr ssss
1120 0 110sss 000rrr 8 rrr sss
1121 0 1110ss 0000rr 4 rr ss
1122 0 11110s 00000r 2 r s */
1123 static inline int
1124 encode_immediate_bitfield (int is64, uint32_t s, uint32_t r)
1125 {
1126 return (is64 << 12) | (r << 6) | s;
1127 }
1128
1129 static void
1130 build_immediate_table (void)
1131 {
1132 uint32_t log_e, e, s, r, s_mask;
1133 uint64_t mask, imm;
1134 int nb_imms;
1135 int is64;
1136
1137 nb_imms = 0;
1138 for (log_e = 1; log_e <= 6; log_e++)
1139 {
1140 /* Get element size. */
1141 e = 1u << log_e;
1142 if (log_e == 6)
1143 {
1144 is64 = 1;
1145 mask = 0xffffffffffffffffull;
1146 s_mask = 0;
1147 }
1148 else
1149 {
1150 is64 = 0;
1151 mask = (1ull << e) - 1;
1152 /* log_e s_mask
1153 1 ((1 << 4) - 1) << 2 = 111100
1154 2 ((1 << 3) - 1) << 3 = 111000
1155 3 ((1 << 2) - 1) << 4 = 110000
1156 4 ((1 << 1) - 1) << 5 = 100000
1157 5 ((1 << 0) - 1) << 6 = 000000 */
1158 s_mask = ((1u << (5 - log_e)) - 1) << (log_e + 1);
1159 }
1160 for (s = 0; s < e - 1; s++)
1161 for (r = 0; r < e; r++)
1162 {
1163 /* s+1 consecutive bits to 1 (s < 63) */
1164 imm = (1ull << (s + 1)) - 1;
1165 /* rotate right by r */
1166 if (r != 0)
1167 imm = (imm >> r) | ((imm << (e - r)) & mask);
1168 /* replicate the constant depending on SIMD size */
1169 switch (log_e)
1170 {
1171 case 1: imm = (imm << 2) | imm;
1172 /* Fall through. */
1173 case 2: imm = (imm << 4) | imm;
1174 /* Fall through. */
1175 case 3: imm = (imm << 8) | imm;
1176 /* Fall through. */
1177 case 4: imm = (imm << 16) | imm;
1178 /* Fall through. */
1179 case 5: imm = (imm << 32) | imm;
1180 /* Fall through. */
1181 case 6: break;
1182 default: abort ();
1183 }
1184 simd_immediates[nb_imms].imm = imm;
1185 simd_immediates[nb_imms].encoding =
1186 encode_immediate_bitfield(is64, s | s_mask, r);
1187 nb_imms++;
1188 }
1189 }
1190 assert (nb_imms == TOTAL_IMM_NB);
1191 qsort(simd_immediates, nb_imms,
1192 sizeof(simd_immediates[0]), simd_imm_encoding_cmp);
1193 }
1194
1195 /* Return TRUE if VALUE is a valid logical immediate, i.e. bitmask, that can
1196 be accepted by logical (immediate) instructions
1197 e.g. ORR <Xd|SP>, <Xn>, #<imm>.
1198
1199 ESIZE is the number of bytes in the decoded immediate value.
1200 If ENCODING is not NULL, on the return of TRUE, the standard encoding for
1201 VALUE will be returned in *ENCODING. */
1202
1203 bfd_boolean
1204 aarch64_logical_immediate_p (uint64_t value, int esize, aarch64_insn *encoding)
1205 {
1206 simd_imm_encoding imm_enc;
1207 const simd_imm_encoding *imm_encoding;
1208 static bfd_boolean initialized = FALSE;
1209 uint64_t upper;
1210 int i;
1211
1212 DEBUG_TRACE ("enter with 0x%" PRIx64 "(%" PRIi64 "), esize: %d", value,
1213 value, esize);
1214
1215 if (!initialized)
1216 {
1217 build_immediate_table ();
1218 initialized = TRUE;
1219 }
1220
1221 /* Allow all zeros or all ones in top bits, so that
1222 constant expressions like ~1 are permitted. */
1223 upper = (uint64_t) -1 << (esize * 4) << (esize * 4);
1224 if ((value & ~upper) != value && (value | upper) != value)
1225 return FALSE;
1226
1227 /* Replicate to a full 64-bit value. */
1228 value &= ~upper;
1229 for (i = esize * 8; i < 64; i *= 2)
1230 value |= (value << i);
1231
1232 imm_enc.imm = value;
1233 imm_encoding = (const simd_imm_encoding *)
1234 bsearch(&imm_enc, simd_immediates, TOTAL_IMM_NB,
1235 sizeof(simd_immediates[0]), simd_imm_encoding_cmp);
1236 if (imm_encoding == NULL)
1237 {
1238 DEBUG_TRACE ("exit with FALSE");
1239 return FALSE;
1240 }
1241 if (encoding != NULL)
1242 *encoding = imm_encoding->encoding;
1243 DEBUG_TRACE ("exit with TRUE");
1244 return TRUE;
1245 }
1246
1247 /* If 64-bit immediate IMM is in the format of
1248 "aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffgggggggghhhhhhhh",
1249 where a, b, c, d, e, f, g and h are independently 0 or 1, return an integer
1250 of value "abcdefgh". Otherwise return -1. */
1251 int
1252 aarch64_shrink_expanded_imm8 (uint64_t imm)
1253 {
1254 int i, ret;
1255 uint32_t byte;
1256
1257 ret = 0;
1258 for (i = 0; i < 8; i++)
1259 {
1260 byte = (imm >> (8 * i)) & 0xff;
1261 if (byte == 0xff)
1262 ret |= 1 << i;
1263 else if (byte != 0x00)
1264 return -1;
1265 }
1266 return ret;
1267 }
1268
1269 /* Utility inline functions for operand_general_constraint_met_p. */
1270
1271 static inline void
1272 set_error (aarch64_operand_error *mismatch_detail,
1273 enum aarch64_operand_error_kind kind, int idx,
1274 const char* error)
1275 {
1276 if (mismatch_detail == NULL)
1277 return;
1278 mismatch_detail->kind = kind;
1279 mismatch_detail->index = idx;
1280 mismatch_detail->error = error;
1281 }
1282
1283 static inline void
1284 set_syntax_error (aarch64_operand_error *mismatch_detail, int idx,
1285 const char* error)
1286 {
1287 if (mismatch_detail == NULL)
1288 return;
1289 set_error (mismatch_detail, AARCH64_OPDE_SYNTAX_ERROR, idx, error);
1290 }
1291
1292 static inline void
1293 set_out_of_range_error (aarch64_operand_error *mismatch_detail,
1294 int idx, int lower_bound, int upper_bound,
1295 const char* error)
1296 {
1297 if (mismatch_detail == NULL)
1298 return;
1299 set_error (mismatch_detail, AARCH64_OPDE_OUT_OF_RANGE, idx, error);
1300 mismatch_detail->data[0] = lower_bound;
1301 mismatch_detail->data[1] = upper_bound;
1302 }
1303
1304 static inline void
1305 set_imm_out_of_range_error (aarch64_operand_error *mismatch_detail,
1306 int idx, int lower_bound, int upper_bound)
1307 {
1308 if (mismatch_detail == NULL)
1309 return;
1310 set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1311 _("immediate value"));
1312 }
1313
1314 static inline void
1315 set_offset_out_of_range_error (aarch64_operand_error *mismatch_detail,
1316 int idx, int lower_bound, int upper_bound)
1317 {
1318 if (mismatch_detail == NULL)
1319 return;
1320 set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1321 _("immediate offset"));
1322 }
1323
1324 static inline void
1325 set_regno_out_of_range_error (aarch64_operand_error *mismatch_detail,
1326 int idx, int lower_bound, int upper_bound)
1327 {
1328 if (mismatch_detail == NULL)
1329 return;
1330 set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1331 _("register number"));
1332 }
1333
1334 static inline void
1335 set_elem_idx_out_of_range_error (aarch64_operand_error *mismatch_detail,
1336 int idx, int lower_bound, int upper_bound)
1337 {
1338 if (mismatch_detail == NULL)
1339 return;
1340 set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1341 _("register element index"));
1342 }
1343
1344 static inline void
1345 set_sft_amount_out_of_range_error (aarch64_operand_error *mismatch_detail,
1346 int idx, int lower_bound, int upper_bound)
1347 {
1348 if (mismatch_detail == NULL)
1349 return;
1350 set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1351 _("shift amount"));
1352 }
1353
1354 /* Report that the MUL modifier in operand IDX should be in the range
1355 [LOWER_BOUND, UPPER_BOUND]. */
1356 static inline void
1357 set_multiplier_out_of_range_error (aarch64_operand_error *mismatch_detail,
1358 int idx, int lower_bound, int upper_bound)
1359 {
1360 if (mismatch_detail == NULL)
1361 return;
1362 set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1363 _("multiplier"));
1364 }
1365
1366 static inline void
1367 set_unaligned_error (aarch64_operand_error *mismatch_detail, int idx,
1368 int alignment)
1369 {
1370 if (mismatch_detail == NULL)
1371 return;
1372 set_error (mismatch_detail, AARCH64_OPDE_UNALIGNED, idx, NULL);
1373 mismatch_detail->data[0] = alignment;
1374 }
1375
1376 static inline void
1377 set_reg_list_error (aarch64_operand_error *mismatch_detail, int idx,
1378 int expected_num)
1379 {
1380 if (mismatch_detail == NULL)
1381 return;
1382 set_error (mismatch_detail, AARCH64_OPDE_REG_LIST, idx, NULL);
1383 mismatch_detail->data[0] = expected_num;
1384 }
1385
1386 static inline void
1387 set_other_error (aarch64_operand_error *mismatch_detail, int idx,
1388 const char* error)
1389 {
1390 if (mismatch_detail == NULL)
1391 return;
1392 set_error (mismatch_detail, AARCH64_OPDE_OTHER_ERROR, idx, error);
1393 }
1394
1395 /* General constraint checking based on operand code.
1396
1397 Return 1 if OPNDS[IDX] meets the general constraint of operand code TYPE
1398 as the IDXth operand of opcode OPCODE. Otherwise return 0.
1399
1400 This function has to be called after the qualifiers for all operands
1401 have been resolved.
1402
1403 Mismatching error message is returned in *MISMATCH_DETAIL upon request,
1404 i.e. when MISMATCH_DETAIL is non-NULL. This avoids the generation
1405 of error message during the disassembling where error message is not
1406 wanted. We avoid the dynamic construction of strings of error messages
1407 here (i.e. in libopcodes), as it is costly and complicated; instead, we
1408 use a combination of error code, static string and some integer data to
1409 represent an error. */
1410
1411 static int
1412 operand_general_constraint_met_p (const aarch64_opnd_info *opnds, int idx,
1413 enum aarch64_opnd type,
1414 const aarch64_opcode *opcode,
1415 aarch64_operand_error *mismatch_detail)
1416 {
1417 unsigned num, modifiers, shift;
1418 unsigned char size;
1419 int64_t imm, min_value, max_value;
1420 uint64_t uvalue, mask;
1421 const aarch64_opnd_info *opnd = opnds + idx;
1422 aarch64_opnd_qualifier_t qualifier = opnd->qualifier;
1423
1424 assert (opcode->operands[idx] == opnd->type && opnd->type == type);
1425
1426 switch (aarch64_operands[type].op_class)
1427 {
1428 case AARCH64_OPND_CLASS_INT_REG:
1429 /* Check pair reg constraints for cas* instructions. */
1430 if (type == AARCH64_OPND_PAIRREG)
1431 {
1432 assert (idx == 1 || idx == 3);
1433 if (opnds[idx - 1].reg.regno % 2 != 0)
1434 {
1435 set_syntax_error (mismatch_detail, idx - 1,
1436 _("reg pair must start from even reg"));
1437 return 0;
1438 }
1439 if (opnds[idx].reg.regno != opnds[idx - 1].reg.regno + 1)
1440 {
1441 set_syntax_error (mismatch_detail, idx,
1442 _("reg pair must be contiguous"));
1443 return 0;
1444 }
1445 break;
1446 }
1447
1448 /* <Xt> may be optional in some IC and TLBI instructions. */
1449 if (type == AARCH64_OPND_Rt_SYS)
1450 {
1451 assert (idx == 1 && (aarch64_get_operand_class (opnds[0].type)
1452 == AARCH64_OPND_CLASS_SYSTEM));
1453 if (opnds[1].present
1454 && !aarch64_sys_ins_reg_has_xt (opnds[0].sysins_op))
1455 {
1456 set_other_error (mismatch_detail, idx, _("extraneous register"));
1457 return 0;
1458 }
1459 if (!opnds[1].present
1460 && aarch64_sys_ins_reg_has_xt (opnds[0].sysins_op))
1461 {
1462 set_other_error (mismatch_detail, idx, _("missing register"));
1463 return 0;
1464 }
1465 }
1466 switch (qualifier)
1467 {
1468 case AARCH64_OPND_QLF_WSP:
1469 case AARCH64_OPND_QLF_SP:
1470 if (!aarch64_stack_pointer_p (opnd))
1471 {
1472 set_other_error (mismatch_detail, idx,
1473 _("stack pointer register expected"));
1474 return 0;
1475 }
1476 break;
1477 default:
1478 break;
1479 }
1480 break;
1481
1482 case AARCH64_OPND_CLASS_SVE_REG:
1483 switch (type)
1484 {
1485 case AARCH64_OPND_SVE_Zm3_INDEX:
1486 case AARCH64_OPND_SVE_Zm3_22_INDEX:
1487 case AARCH64_OPND_SVE_Zm4_INDEX:
1488 size = get_operand_fields_width (get_operand_from_code (type));
1489 shift = get_operand_specific_data (&aarch64_operands[type]);
1490 mask = (1 << shift) - 1;
1491 if (opnd->reg.regno > mask)
1492 {
1493 assert (mask == 7 || mask == 15);
1494 set_other_error (mismatch_detail, idx,
1495 mask == 15
1496 ? _("z0-z15 expected")
1497 : _("z0-z7 expected"));
1498 return 0;
1499 }
1500 mask = (1 << (size - shift)) - 1;
1501 if (!value_in_range_p (opnd->reglane.index, 0, mask))
1502 {
1503 set_elem_idx_out_of_range_error (mismatch_detail, idx, 0, mask);
1504 return 0;
1505 }
1506 break;
1507
1508 case AARCH64_OPND_SVE_Zn_INDEX:
1509 size = aarch64_get_qualifier_esize (opnd->qualifier);
1510 if (!value_in_range_p (opnd->reglane.index, 0, 64 / size - 1))
1511 {
1512 set_elem_idx_out_of_range_error (mismatch_detail, idx,
1513 0, 64 / size - 1);
1514 return 0;
1515 }
1516 break;
1517
1518 case AARCH64_OPND_SVE_ZnxN:
1519 case AARCH64_OPND_SVE_ZtxN:
1520 if (opnd->reglist.num_regs != get_opcode_dependent_value (opcode))
1521 {
1522 set_other_error (mismatch_detail, idx,
1523 _("invalid register list"));
1524 return 0;
1525 }
1526 break;
1527
1528 default:
1529 break;
1530 }
1531 break;
1532
1533 case AARCH64_OPND_CLASS_PRED_REG:
1534 if (opnd->reg.regno >= 8
1535 && get_operand_fields_width (get_operand_from_code (type)) == 3)
1536 {
1537 set_other_error (mismatch_detail, idx, _("p0-p7 expected"));
1538 return 0;
1539 }
1540 break;
1541
1542 case AARCH64_OPND_CLASS_COND:
1543 if (type == AARCH64_OPND_COND1
1544 && (opnds[idx].cond->value & 0xe) == 0xe)
1545 {
1546 /* Not allow AL or NV. */
1547 set_syntax_error (mismatch_detail, idx, NULL);
1548 }
1549 break;
1550
1551 case AARCH64_OPND_CLASS_ADDRESS:
1552 /* Check writeback. */
1553 switch (opcode->iclass)
1554 {
1555 case ldst_pos:
1556 case ldst_unscaled:
1557 case ldstnapair_offs:
1558 case ldstpair_off:
1559 case ldst_unpriv:
1560 if (opnd->addr.writeback == 1)
1561 {
1562 set_syntax_error (mismatch_detail, idx,
1563 _("unexpected address writeback"));
1564 return 0;
1565 }
1566 break;
1567 case ldst_imm10:
1568 if (opnd->addr.writeback == 1 && opnd->addr.preind != 1)
1569 {
1570 set_syntax_error (mismatch_detail, idx,
1571 _("unexpected address writeback"));
1572 return 0;
1573 }
1574 break;
1575 case ldst_imm9:
1576 case ldstpair_indexed:
1577 case asisdlsep:
1578 case asisdlsop:
1579 if (opnd->addr.writeback == 0)
1580 {
1581 set_syntax_error (mismatch_detail, idx,
1582 _("address writeback expected"));
1583 return 0;
1584 }
1585 break;
1586 default:
1587 assert (opnd->addr.writeback == 0);
1588 break;
1589 }
1590 switch (type)
1591 {
1592 case AARCH64_OPND_ADDR_SIMM7:
1593 /* Scaled signed 7 bits immediate offset. */
1594 /* Get the size of the data element that is accessed, which may be
1595 different from that of the source register size,
1596 e.g. in strb/ldrb. */
1597 size = aarch64_get_qualifier_esize (opnd->qualifier);
1598 if (!value_in_range_p (opnd->addr.offset.imm, -64 * size, 63 * size))
1599 {
1600 set_offset_out_of_range_error (mismatch_detail, idx,
1601 -64 * size, 63 * size);
1602 return 0;
1603 }
1604 if (!value_aligned_p (opnd->addr.offset.imm, size))
1605 {
1606 set_unaligned_error (mismatch_detail, idx, size);
1607 return 0;
1608 }
1609 break;
1610 case AARCH64_OPND_ADDR_OFFSET:
1611 case AARCH64_OPND_ADDR_SIMM9:
1612 /* Unscaled signed 9 bits immediate offset. */
1613 if (!value_in_range_p (opnd->addr.offset.imm, -256, 255))
1614 {
1615 set_offset_out_of_range_error (mismatch_detail, idx, -256, 255);
1616 return 0;
1617 }
1618 break;
1619
1620 case AARCH64_OPND_ADDR_SIMM9_2:
1621 /* Unscaled signed 9 bits immediate offset, which has to be negative
1622 or unaligned. */
1623 size = aarch64_get_qualifier_esize (qualifier);
1624 if ((value_in_range_p (opnd->addr.offset.imm, 0, 255)
1625 && !value_aligned_p (opnd->addr.offset.imm, size))
1626 || value_in_range_p (opnd->addr.offset.imm, -256, -1))
1627 return 1;
1628 set_other_error (mismatch_detail, idx,
1629 _("negative or unaligned offset expected"));
1630 return 0;
1631
1632 case AARCH64_OPND_ADDR_SIMM10:
1633 /* Scaled signed 10 bits immediate offset. */
1634 if (!value_in_range_p (opnd->addr.offset.imm, -4096, 4088))
1635 {
1636 set_offset_out_of_range_error (mismatch_detail, idx, -4096, 4088);
1637 return 0;
1638 }
1639 if (!value_aligned_p (opnd->addr.offset.imm, 8))
1640 {
1641 set_unaligned_error (mismatch_detail, idx, 8);
1642 return 0;
1643 }
1644 break;
1645
1646 case AARCH64_OPND_SIMD_ADDR_POST:
1647 /* AdvSIMD load/store multiple structures, post-index. */
1648 assert (idx == 1);
1649 if (opnd->addr.offset.is_reg)
1650 {
1651 if (value_in_range_p (opnd->addr.offset.regno, 0, 30))
1652 return 1;
1653 else
1654 {
1655 set_other_error (mismatch_detail, idx,
1656 _("invalid register offset"));
1657 return 0;
1658 }
1659 }
1660 else
1661 {
1662 const aarch64_opnd_info *prev = &opnds[idx-1];
1663 unsigned num_bytes; /* total number of bytes transferred. */
1664 /* The opcode dependent area stores the number of elements in
1665 each structure to be loaded/stored. */
1666 int is_ld1r = get_opcode_dependent_value (opcode) == 1;
1667 if (opcode->operands[0] == AARCH64_OPND_LVt_AL)
1668 /* Special handling of loading single structure to all lane. */
1669 num_bytes = (is_ld1r ? 1 : prev->reglist.num_regs)
1670 * aarch64_get_qualifier_esize (prev->qualifier);
1671 else
1672 num_bytes = prev->reglist.num_regs
1673 * aarch64_get_qualifier_esize (prev->qualifier)
1674 * aarch64_get_qualifier_nelem (prev->qualifier);
1675 if ((int) num_bytes != opnd->addr.offset.imm)
1676 {
1677 set_other_error (mismatch_detail, idx,
1678 _("invalid post-increment amount"));
1679 return 0;
1680 }
1681 }
1682 break;
1683
1684 case AARCH64_OPND_ADDR_REGOFF:
1685 /* Get the size of the data element that is accessed, which may be
1686 different from that of the source register size,
1687 e.g. in strb/ldrb. */
1688 size = aarch64_get_qualifier_esize (opnd->qualifier);
1689 /* It is either no shift or shift by the binary logarithm of SIZE. */
1690 if (opnd->shifter.amount != 0
1691 && opnd->shifter.amount != (int)get_logsz (size))
1692 {
1693 set_other_error (mismatch_detail, idx,
1694 _("invalid shift amount"));
1695 return 0;
1696 }
1697 /* Only UXTW, LSL, SXTW and SXTX are the accepted extending
1698 operators. */
1699 switch (opnd->shifter.kind)
1700 {
1701 case AARCH64_MOD_UXTW:
1702 case AARCH64_MOD_LSL:
1703 case AARCH64_MOD_SXTW:
1704 case AARCH64_MOD_SXTX: break;
1705 default:
1706 set_other_error (mismatch_detail, idx,
1707 _("invalid extend/shift operator"));
1708 return 0;
1709 }
1710 break;
1711
1712 case AARCH64_OPND_ADDR_UIMM12:
1713 imm = opnd->addr.offset.imm;
1714 /* Get the size of the data element that is accessed, which may be
1715 different from that of the source register size,
1716 e.g. in strb/ldrb. */
1717 size = aarch64_get_qualifier_esize (qualifier);
1718 if (!value_in_range_p (opnd->addr.offset.imm, 0, 4095 * size))
1719 {
1720 set_offset_out_of_range_error (mismatch_detail, idx,
1721 0, 4095 * size);
1722 return 0;
1723 }
1724 if (!value_aligned_p (opnd->addr.offset.imm, size))
1725 {
1726 set_unaligned_error (mismatch_detail, idx, size);
1727 return 0;
1728 }
1729 break;
1730
1731 case AARCH64_OPND_ADDR_PCREL14:
1732 case AARCH64_OPND_ADDR_PCREL19:
1733 case AARCH64_OPND_ADDR_PCREL21:
1734 case AARCH64_OPND_ADDR_PCREL26:
1735 imm = opnd->imm.value;
1736 if (operand_need_shift_by_two (get_operand_from_code (type)))
1737 {
1738 /* The offset value in a PC-relative branch instruction is alway
1739 4-byte aligned and is encoded without the lowest 2 bits. */
1740 if (!value_aligned_p (imm, 4))
1741 {
1742 set_unaligned_error (mismatch_detail, idx, 4);
1743 return 0;
1744 }
1745 /* Right shift by 2 so that we can carry out the following check
1746 canonically. */
1747 imm >>= 2;
1748 }
1749 size = get_operand_fields_width (get_operand_from_code (type));
1750 if (!value_fit_signed_field_p (imm, size))
1751 {
1752 set_other_error (mismatch_detail, idx,
1753 _("immediate out of range"));
1754 return 0;
1755 }
1756 break;
1757
1758 case AARCH64_OPND_SVE_ADDR_RI_S4xVL:
1759 case AARCH64_OPND_SVE_ADDR_RI_S4x2xVL:
1760 case AARCH64_OPND_SVE_ADDR_RI_S4x3xVL:
1761 case AARCH64_OPND_SVE_ADDR_RI_S4x4xVL:
1762 min_value = -8;
1763 max_value = 7;
1764 sve_imm_offset_vl:
1765 assert (!opnd->addr.offset.is_reg);
1766 assert (opnd->addr.preind);
1767 num = 1 + get_operand_specific_data (&aarch64_operands[type]);
1768 min_value *= num;
1769 max_value *= num;
1770 if ((opnd->addr.offset.imm != 0 && !opnd->shifter.operator_present)
1771 || (opnd->shifter.operator_present
1772 && opnd->shifter.kind != AARCH64_MOD_MUL_VL))
1773 {
1774 set_other_error (mismatch_detail, idx,
1775 _("invalid addressing mode"));
1776 return 0;
1777 }
1778 if (!value_in_range_p (opnd->addr.offset.imm, min_value, max_value))
1779 {
1780 set_offset_out_of_range_error (mismatch_detail, idx,
1781 min_value, max_value);
1782 return 0;
1783 }
1784 if (!value_aligned_p (opnd->addr.offset.imm, num))
1785 {
1786 set_unaligned_error (mismatch_detail, idx, num);
1787 return 0;
1788 }
1789 break;
1790
1791 case AARCH64_OPND_SVE_ADDR_RI_S6xVL:
1792 min_value = -32;
1793 max_value = 31;
1794 goto sve_imm_offset_vl;
1795
1796 case AARCH64_OPND_SVE_ADDR_RI_S9xVL:
1797 min_value = -256;
1798 max_value = 255;
1799 goto sve_imm_offset_vl;
1800
1801 case AARCH64_OPND_SVE_ADDR_RI_U6:
1802 case AARCH64_OPND_SVE_ADDR_RI_U6x2:
1803 case AARCH64_OPND_SVE_ADDR_RI_U6x4:
1804 case AARCH64_OPND_SVE_ADDR_RI_U6x8:
1805 min_value = 0;
1806 max_value = 63;
1807 sve_imm_offset:
1808 assert (!opnd->addr.offset.is_reg);
1809 assert (opnd->addr.preind);
1810 num = 1 << get_operand_specific_data (&aarch64_operands[type]);
1811 min_value *= num;
1812 max_value *= num;
1813 if (opnd->shifter.operator_present
1814 || opnd->shifter.amount_present)
1815 {
1816 set_other_error (mismatch_detail, idx,
1817 _("invalid addressing mode"));
1818 return 0;
1819 }
1820 if (!value_in_range_p (opnd->addr.offset.imm, min_value, max_value))
1821 {
1822 set_offset_out_of_range_error (mismatch_detail, idx,
1823 min_value, max_value);
1824 return 0;
1825 }
1826 if (!value_aligned_p (opnd->addr.offset.imm, num))
1827 {
1828 set_unaligned_error (mismatch_detail, idx, num);
1829 return 0;
1830 }
1831 break;
1832
1833 case AARCH64_OPND_SVE_ADDR_RI_S4x16:
1834 min_value = -8;
1835 max_value = 7;
1836 goto sve_imm_offset;
1837
1838 case AARCH64_OPND_SVE_ADDR_R:
1839 case AARCH64_OPND_SVE_ADDR_RR:
1840 case AARCH64_OPND_SVE_ADDR_RR_LSL1:
1841 case AARCH64_OPND_SVE_ADDR_RR_LSL2:
1842 case AARCH64_OPND_SVE_ADDR_RR_LSL3:
1843 case AARCH64_OPND_SVE_ADDR_RX:
1844 case AARCH64_OPND_SVE_ADDR_RX_LSL1:
1845 case AARCH64_OPND_SVE_ADDR_RX_LSL2:
1846 case AARCH64_OPND_SVE_ADDR_RX_LSL3:
1847 case AARCH64_OPND_SVE_ADDR_RZ:
1848 case AARCH64_OPND_SVE_ADDR_RZ_LSL1:
1849 case AARCH64_OPND_SVE_ADDR_RZ_LSL2:
1850 case AARCH64_OPND_SVE_ADDR_RZ_LSL3:
1851 modifiers = 1 << AARCH64_MOD_LSL;
1852 sve_rr_operand:
1853 assert (opnd->addr.offset.is_reg);
1854 assert (opnd->addr.preind);
1855 if ((aarch64_operands[type].flags & OPD_F_NO_ZR) != 0
1856 && opnd->addr.offset.regno == 31)
1857 {
1858 set_other_error (mismatch_detail, idx,
1859 _("index register xzr is not allowed"));
1860 return 0;
1861 }
1862 if (((1 << opnd->shifter.kind) & modifiers) == 0
1863 || (opnd->shifter.amount
1864 != get_operand_specific_data (&aarch64_operands[type])))
1865 {
1866 set_other_error (mismatch_detail, idx,
1867 _("invalid addressing mode"));
1868 return 0;
1869 }
1870 break;
1871
1872 case AARCH64_OPND_SVE_ADDR_RZ_XTW_14:
1873 case AARCH64_OPND_SVE_ADDR_RZ_XTW_22:
1874 case AARCH64_OPND_SVE_ADDR_RZ_XTW1_14:
1875 case AARCH64_OPND_SVE_ADDR_RZ_XTW1_22:
1876 case AARCH64_OPND_SVE_ADDR_RZ_XTW2_14:
1877 case AARCH64_OPND_SVE_ADDR_RZ_XTW2_22:
1878 case AARCH64_OPND_SVE_ADDR_RZ_XTW3_14:
1879 case AARCH64_OPND_SVE_ADDR_RZ_XTW3_22:
1880 modifiers = (1 << AARCH64_MOD_SXTW) | (1 << AARCH64_MOD_UXTW);
1881 goto sve_rr_operand;
1882
1883 case AARCH64_OPND_SVE_ADDR_ZI_U5:
1884 case AARCH64_OPND_SVE_ADDR_ZI_U5x2:
1885 case AARCH64_OPND_SVE_ADDR_ZI_U5x4:
1886 case AARCH64_OPND_SVE_ADDR_ZI_U5x8:
1887 min_value = 0;
1888 max_value = 31;
1889 goto sve_imm_offset;
1890
1891 case AARCH64_OPND_SVE_ADDR_ZZ_LSL:
1892 modifiers = 1 << AARCH64_MOD_LSL;
1893 sve_zz_operand:
1894 assert (opnd->addr.offset.is_reg);
1895 assert (opnd->addr.preind);
1896 if (((1 << opnd->shifter.kind) & modifiers) == 0
1897 || opnd->shifter.amount < 0
1898 || opnd->shifter.amount > 3)
1899 {
1900 set_other_error (mismatch_detail, idx,
1901 _("invalid addressing mode"));
1902 return 0;
1903 }
1904 break;
1905
1906 case AARCH64_OPND_SVE_ADDR_ZZ_SXTW:
1907 modifiers = (1 << AARCH64_MOD_SXTW);
1908 goto sve_zz_operand;
1909
1910 case AARCH64_OPND_SVE_ADDR_ZZ_UXTW:
1911 modifiers = 1 << AARCH64_MOD_UXTW;
1912 goto sve_zz_operand;
1913
1914 default:
1915 break;
1916 }
1917 break;
1918
1919 case AARCH64_OPND_CLASS_SIMD_REGLIST:
1920 if (type == AARCH64_OPND_LEt)
1921 {
1922 /* Get the upper bound for the element index. */
1923 num = 16 / aarch64_get_qualifier_esize (qualifier) - 1;
1924 if (!value_in_range_p (opnd->reglist.index, 0, num))
1925 {
1926 set_elem_idx_out_of_range_error (mismatch_detail, idx, 0, num);
1927 return 0;
1928 }
1929 }
1930 /* The opcode dependent area stores the number of elements in
1931 each structure to be loaded/stored. */
1932 num = get_opcode_dependent_value (opcode);
1933 switch (type)
1934 {
1935 case AARCH64_OPND_LVt:
1936 assert (num >= 1 && num <= 4);
1937 /* Unless LD1/ST1, the number of registers should be equal to that
1938 of the structure elements. */
1939 if (num != 1 && opnd->reglist.num_regs != num)
1940 {
1941 set_reg_list_error (mismatch_detail, idx, num);
1942 return 0;
1943 }
1944 break;
1945 case AARCH64_OPND_LVt_AL:
1946 case AARCH64_OPND_LEt:
1947 assert (num >= 1 && num <= 4);
1948 /* The number of registers should be equal to that of the structure
1949 elements. */
1950 if (opnd->reglist.num_regs != num)
1951 {
1952 set_reg_list_error (mismatch_detail, idx, num);
1953 return 0;
1954 }
1955 break;
1956 default:
1957 break;
1958 }
1959 break;
1960
1961 case AARCH64_OPND_CLASS_IMMEDIATE:
1962 /* Constraint check on immediate operand. */
1963 imm = opnd->imm.value;
1964 /* E.g. imm_0_31 constrains value to be 0..31. */
1965 if (qualifier_value_in_range_constraint_p (qualifier)
1966 && !value_in_range_p (imm, get_lower_bound (qualifier),
1967 get_upper_bound (qualifier)))
1968 {
1969 set_imm_out_of_range_error (mismatch_detail, idx,
1970 get_lower_bound (qualifier),
1971 get_upper_bound (qualifier));
1972 return 0;
1973 }
1974
1975 switch (type)
1976 {
1977 case AARCH64_OPND_AIMM:
1978 if (opnd->shifter.kind != AARCH64_MOD_LSL)
1979 {
1980 set_other_error (mismatch_detail, idx,
1981 _("invalid shift operator"));
1982 return 0;
1983 }
1984 if (opnd->shifter.amount != 0 && opnd->shifter.amount != 12)
1985 {
1986 set_other_error (mismatch_detail, idx,
1987 _("shift amount must be 0 or 12"));
1988 return 0;
1989 }
1990 if (!value_fit_unsigned_field_p (opnd->imm.value, 12))
1991 {
1992 set_other_error (mismatch_detail, idx,
1993 _("immediate out of range"));
1994 return 0;
1995 }
1996 break;
1997
1998 case AARCH64_OPND_HALF:
1999 assert (idx == 1 && opnds[0].type == AARCH64_OPND_Rd);
2000 if (opnd->shifter.kind != AARCH64_MOD_LSL)
2001 {
2002 set_other_error (mismatch_detail, idx,
2003 _("invalid shift operator"));
2004 return 0;
2005 }
2006 size = aarch64_get_qualifier_esize (opnds[0].qualifier);
2007 if (!value_aligned_p (opnd->shifter.amount, 16))
2008 {
2009 set_other_error (mismatch_detail, idx,
2010 _("shift amount must be a multiple of 16"));
2011 return 0;
2012 }
2013 if (!value_in_range_p (opnd->shifter.amount, 0, size * 8 - 16))
2014 {
2015 set_sft_amount_out_of_range_error (mismatch_detail, idx,
2016 0, size * 8 - 16);
2017 return 0;
2018 }
2019 if (opnd->imm.value < 0)
2020 {
2021 set_other_error (mismatch_detail, idx,
2022 _("negative immediate value not allowed"));
2023 return 0;
2024 }
2025 if (!value_fit_unsigned_field_p (opnd->imm.value, 16))
2026 {
2027 set_other_error (mismatch_detail, idx,
2028 _("immediate out of range"));
2029 return 0;
2030 }
2031 break;
2032
2033 case AARCH64_OPND_IMM_MOV:
2034 {
2035 int esize = aarch64_get_qualifier_esize (opnds[0].qualifier);
2036 imm = opnd->imm.value;
2037 assert (idx == 1);
2038 switch (opcode->op)
2039 {
2040 case OP_MOV_IMM_WIDEN:
2041 imm = ~imm;
2042 /* Fall through. */
2043 case OP_MOV_IMM_WIDE:
2044 if (!aarch64_wide_constant_p (imm, esize == 4, NULL))
2045 {
2046 set_other_error (mismatch_detail, idx,
2047 _("immediate out of range"));
2048 return 0;
2049 }
2050 break;
2051 case OP_MOV_IMM_LOG:
2052 if (!aarch64_logical_immediate_p (imm, esize, NULL))
2053 {
2054 set_other_error (mismatch_detail, idx,
2055 _("immediate out of range"));
2056 return 0;
2057 }
2058 break;
2059 default:
2060 assert (0);
2061 return 0;
2062 }
2063 }
2064 break;
2065
2066 case AARCH64_OPND_NZCV:
2067 case AARCH64_OPND_CCMP_IMM:
2068 case AARCH64_OPND_EXCEPTION:
2069 case AARCH64_OPND_UIMM4:
2070 case AARCH64_OPND_UIMM7:
2071 case AARCH64_OPND_UIMM3_OP1:
2072 case AARCH64_OPND_UIMM3_OP2:
2073 case AARCH64_OPND_SVE_UIMM3:
2074 case AARCH64_OPND_SVE_UIMM7:
2075 case AARCH64_OPND_SVE_UIMM8:
2076 case AARCH64_OPND_SVE_UIMM8_53:
2077 size = get_operand_fields_width (get_operand_from_code (type));
2078 assert (size < 32);
2079 if (!value_fit_unsigned_field_p (opnd->imm.value, size))
2080 {
2081 set_imm_out_of_range_error (mismatch_detail, idx, 0,
2082 (1 << size) - 1);
2083 return 0;
2084 }
2085 break;
2086
2087 case AARCH64_OPND_SIMM5:
2088 case AARCH64_OPND_SVE_SIMM5:
2089 case AARCH64_OPND_SVE_SIMM5B:
2090 case AARCH64_OPND_SVE_SIMM6:
2091 case AARCH64_OPND_SVE_SIMM8:
2092 size = get_operand_fields_width (get_operand_from_code (type));
2093 assert (size < 32);
2094 if (!value_fit_signed_field_p (opnd->imm.value, size))
2095 {
2096 set_imm_out_of_range_error (mismatch_detail, idx,
2097 -(1 << (size - 1)),
2098 (1 << (size - 1)) - 1);
2099 return 0;
2100 }
2101 break;
2102
2103 case AARCH64_OPND_WIDTH:
2104 assert (idx > 1 && opnds[idx-1].type == AARCH64_OPND_IMM
2105 && opnds[0].type == AARCH64_OPND_Rd);
2106 size = get_upper_bound (qualifier);
2107 if (opnd->imm.value + opnds[idx-1].imm.value > size)
2108 /* lsb+width <= reg.size */
2109 {
2110 set_imm_out_of_range_error (mismatch_detail, idx, 1,
2111 size - opnds[idx-1].imm.value);
2112 return 0;
2113 }
2114 break;
2115
2116 case AARCH64_OPND_LIMM:
2117 case AARCH64_OPND_SVE_LIMM:
2118 {
2119 int esize = aarch64_get_qualifier_esize (opnds[0].qualifier);
2120 uint64_t uimm = opnd->imm.value;
2121 if (opcode->op == OP_BIC)
2122 uimm = ~uimm;
2123 if (!aarch64_logical_immediate_p (uimm, esize, NULL))
2124 {
2125 set_other_error (mismatch_detail, idx,
2126 _("immediate out of range"));
2127 return 0;
2128 }
2129 }
2130 break;
2131
2132 case AARCH64_OPND_IMM0:
2133 case AARCH64_OPND_FPIMM0:
2134 if (opnd->imm.value != 0)
2135 {
2136 set_other_error (mismatch_detail, idx,
2137 _("immediate zero expected"));
2138 return 0;
2139 }
2140 break;
2141
2142 case AARCH64_OPND_IMM_ROT1:
2143 case AARCH64_OPND_IMM_ROT2:
2144 case AARCH64_OPND_SVE_IMM_ROT2:
2145 if (opnd->imm.value != 0
2146 && opnd->imm.value != 90
2147 && opnd->imm.value != 180
2148 && opnd->imm.value != 270)
2149 {
2150 set_other_error (mismatch_detail, idx,
2151 _("rotate expected to be 0, 90, 180 or 270"));
2152 return 0;
2153 }
2154 break;
2155
2156 case AARCH64_OPND_IMM_ROT3:
2157 case AARCH64_OPND_SVE_IMM_ROT1:
2158 if (opnd->imm.value != 90 && opnd->imm.value != 270)
2159 {
2160 set_other_error (mismatch_detail, idx,
2161 _("rotate expected to be 90 or 270"));
2162 return 0;
2163 }
2164 break;
2165
2166 case AARCH64_OPND_SHLL_IMM:
2167 assert (idx == 2);
2168 size = 8 * aarch64_get_qualifier_esize (opnds[idx - 1].qualifier);
2169 if (opnd->imm.value != size)
2170 {
2171 set_other_error (mismatch_detail, idx,
2172 _("invalid shift amount"));
2173 return 0;
2174 }
2175 break;
2176
2177 case AARCH64_OPND_IMM_VLSL:
2178 size = aarch64_get_qualifier_esize (qualifier);
2179 if (!value_in_range_p (opnd->imm.value, 0, size * 8 - 1))
2180 {
2181 set_imm_out_of_range_error (mismatch_detail, idx, 0,
2182 size * 8 - 1);
2183 return 0;
2184 }
2185 break;
2186
2187 case AARCH64_OPND_IMM_VLSR:
2188 size = aarch64_get_qualifier_esize (qualifier);
2189 if (!value_in_range_p (opnd->imm.value, 1, size * 8))
2190 {
2191 set_imm_out_of_range_error (mismatch_detail, idx, 1, size * 8);
2192 return 0;
2193 }
2194 break;
2195
2196 case AARCH64_OPND_SIMD_IMM:
2197 case AARCH64_OPND_SIMD_IMM_SFT:
2198 /* Qualifier check. */
2199 switch (qualifier)
2200 {
2201 case AARCH64_OPND_QLF_LSL:
2202 if (opnd->shifter.kind != AARCH64_MOD_LSL)
2203 {
2204 set_other_error (mismatch_detail, idx,
2205 _("invalid shift operator"));
2206 return 0;
2207 }
2208 break;
2209 case AARCH64_OPND_QLF_MSL:
2210 if (opnd->shifter.kind != AARCH64_MOD_MSL)
2211 {
2212 set_other_error (mismatch_detail, idx,
2213 _("invalid shift operator"));
2214 return 0;
2215 }
2216 break;
2217 case AARCH64_OPND_QLF_NIL:
2218 if (opnd->shifter.kind != AARCH64_MOD_NONE)
2219 {
2220 set_other_error (mismatch_detail, idx,
2221 _("shift is not permitted"));
2222 return 0;
2223 }
2224 break;
2225 default:
2226 assert (0);
2227 return 0;
2228 }
2229 /* Is the immediate valid? */
2230 assert (idx == 1);
2231 if (aarch64_get_qualifier_esize (opnds[0].qualifier) != 8)
2232 {
2233 /* uimm8 or simm8 */
2234 if (!value_in_range_p (opnd->imm.value, -128, 255))
2235 {
2236 set_imm_out_of_range_error (mismatch_detail, idx, -128, 255);
2237 return 0;
2238 }
2239 }
2240 else if (aarch64_shrink_expanded_imm8 (opnd->imm.value) < 0)
2241 {
2242 /* uimm64 is not
2243 'aaaaaaaabbbbbbbbccccccccddddddddeeeeeeee
2244 ffffffffgggggggghhhhhhhh'. */
2245 set_other_error (mismatch_detail, idx,
2246 _("invalid value for immediate"));
2247 return 0;
2248 }
2249 /* Is the shift amount valid? */
2250 switch (opnd->shifter.kind)
2251 {
2252 case AARCH64_MOD_LSL:
2253 size = aarch64_get_qualifier_esize (opnds[0].qualifier);
2254 if (!value_in_range_p (opnd->shifter.amount, 0, (size - 1) * 8))
2255 {
2256 set_sft_amount_out_of_range_error (mismatch_detail, idx, 0,
2257 (size - 1) * 8);
2258 return 0;
2259 }
2260 if (!value_aligned_p (opnd->shifter.amount, 8))
2261 {
2262 set_unaligned_error (mismatch_detail, idx, 8);
2263 return 0;
2264 }
2265 break;
2266 case AARCH64_MOD_MSL:
2267 /* Only 8 and 16 are valid shift amount. */
2268 if (opnd->shifter.amount != 8 && opnd->shifter.amount != 16)
2269 {
2270 set_other_error (mismatch_detail, idx,
2271 _("shift amount must be 0 or 16"));
2272 return 0;
2273 }
2274 break;
2275 default:
2276 if (opnd->shifter.kind != AARCH64_MOD_NONE)
2277 {
2278 set_other_error (mismatch_detail, idx,
2279 _("invalid shift operator"));
2280 return 0;
2281 }
2282 break;
2283 }
2284 break;
2285
2286 case AARCH64_OPND_FPIMM:
2287 case AARCH64_OPND_SIMD_FPIMM:
2288 case AARCH64_OPND_SVE_FPIMM8:
2289 if (opnd->imm.is_fp == 0)
2290 {
2291 set_other_error (mismatch_detail, idx,
2292 _("floating-point immediate expected"));
2293 return 0;
2294 }
2295 /* The value is expected to be an 8-bit floating-point constant with
2296 sign, 3-bit exponent and normalized 4 bits of precision, encoded
2297 in "a:b:c:d:e:f:g:h" or FLD_imm8 (depending on the type of the
2298 instruction). */
2299 if (!value_in_range_p (opnd->imm.value, 0, 255))
2300 {
2301 set_other_error (mismatch_detail, idx,
2302 _("immediate out of range"));
2303 return 0;
2304 }
2305 if (opnd->shifter.kind != AARCH64_MOD_NONE)
2306 {
2307 set_other_error (mismatch_detail, idx,
2308 _("invalid shift operator"));
2309 return 0;
2310 }
2311 break;
2312
2313 case AARCH64_OPND_SVE_AIMM:
2314 min_value = 0;
2315 sve_aimm:
2316 assert (opnd->shifter.kind == AARCH64_MOD_LSL);
2317 size = aarch64_get_qualifier_esize (opnds[0].qualifier);
2318 mask = ~((uint64_t) -1 << (size * 4) << (size * 4));
2319 uvalue = opnd->imm.value;
2320 shift = opnd->shifter.amount;
2321 if (size == 1)
2322 {
2323 if (shift != 0)
2324 {
2325 set_other_error (mismatch_detail, idx,
2326 _("no shift amount allowed for"
2327 " 8-bit constants"));
2328 return 0;
2329 }
2330 }
2331 else
2332 {
2333 if (shift != 0 && shift != 8)
2334 {
2335 set_other_error (mismatch_detail, idx,
2336 _("shift amount must be 0 or 8"));
2337 return 0;
2338 }
2339 if (shift == 0 && (uvalue & 0xff) == 0)
2340 {
2341 shift = 8;
2342 uvalue = (int64_t) uvalue / 256;
2343 }
2344 }
2345 mask >>= shift;
2346 if ((uvalue & mask) != uvalue && (uvalue | ~mask) != uvalue)
2347 {
2348 set_other_error (mismatch_detail, idx,
2349 _("immediate too big for element size"));
2350 return 0;
2351 }
2352 uvalue = (uvalue - min_value) & mask;
2353 if (uvalue > 0xff)
2354 {
2355 set_other_error (mismatch_detail, idx,
2356 _("invalid arithmetic immediate"));
2357 return 0;
2358 }
2359 break;
2360
2361 case AARCH64_OPND_SVE_ASIMM:
2362 min_value = -128;
2363 goto sve_aimm;
2364
2365 case AARCH64_OPND_SVE_I1_HALF_ONE:
2366 assert (opnd->imm.is_fp);
2367 if (opnd->imm.value != 0x3f000000 && opnd->imm.value != 0x3f800000)
2368 {
2369 set_other_error (mismatch_detail, idx,
2370 _("floating-point value must be 0.5 or 1.0"));
2371 return 0;
2372 }
2373 break;
2374
2375 case AARCH64_OPND_SVE_I1_HALF_TWO:
2376 assert (opnd->imm.is_fp);
2377 if (opnd->imm.value != 0x3f000000 && opnd->imm.value != 0x40000000)
2378 {
2379 set_other_error (mismatch_detail, idx,
2380 _("floating-point value must be 0.5 or 2.0"));
2381 return 0;
2382 }
2383 break;
2384
2385 case AARCH64_OPND_SVE_I1_ZERO_ONE:
2386 assert (opnd->imm.is_fp);
2387 if (opnd->imm.value != 0 && opnd->imm.value != 0x3f800000)
2388 {
2389 set_other_error (mismatch_detail, idx,
2390 _("floating-point value must be 0.0 or 1.0"));
2391 return 0;
2392 }
2393 break;
2394
2395 case AARCH64_OPND_SVE_INV_LIMM:
2396 {
2397 int esize = aarch64_get_qualifier_esize (opnds[0].qualifier);
2398 uint64_t uimm = ~opnd->imm.value;
2399 if (!aarch64_logical_immediate_p (uimm, esize, NULL))
2400 {
2401 set_other_error (mismatch_detail, idx,
2402 _("immediate out of range"));
2403 return 0;
2404 }
2405 }
2406 break;
2407
2408 case AARCH64_OPND_SVE_LIMM_MOV:
2409 {
2410 int esize = aarch64_get_qualifier_esize (opnds[0].qualifier);
2411 uint64_t uimm = opnd->imm.value;
2412 if (!aarch64_logical_immediate_p (uimm, esize, NULL))
2413 {
2414 set_other_error (mismatch_detail, idx,
2415 _("immediate out of range"));
2416 return 0;
2417 }
2418 if (!aarch64_sve_dupm_mov_immediate_p (uimm, esize))
2419 {
2420 set_other_error (mismatch_detail, idx,
2421 _("invalid replicated MOV immediate"));
2422 return 0;
2423 }
2424 }
2425 break;
2426
2427 case AARCH64_OPND_SVE_PATTERN_SCALED:
2428 assert (opnd->shifter.kind == AARCH64_MOD_MUL);
2429 if (!value_in_range_p (opnd->shifter.amount, 1, 16))
2430 {
2431 set_multiplier_out_of_range_error (mismatch_detail, idx, 1, 16);
2432 return 0;
2433 }
2434 break;
2435
2436 case AARCH64_OPND_SVE_SHLIMM_PRED:
2437 case AARCH64_OPND_SVE_SHLIMM_UNPRED:
2438 size = aarch64_get_qualifier_esize (opnds[idx - 1].qualifier);
2439 if (!value_in_range_p (opnd->imm.value, 0, 8 * size - 1))
2440 {
2441 set_imm_out_of_range_error (mismatch_detail, idx,
2442 0, 8 * size - 1);
2443 return 0;
2444 }
2445 break;
2446
2447 case AARCH64_OPND_SVE_SHRIMM_PRED:
2448 case AARCH64_OPND_SVE_SHRIMM_UNPRED:
2449 size = aarch64_get_qualifier_esize (opnds[idx - 1].qualifier);
2450 if (!value_in_range_p (opnd->imm.value, 1, 8 * size))
2451 {
2452 set_imm_out_of_range_error (mismatch_detail, idx, 1, 8 * size);
2453 return 0;
2454 }
2455 break;
2456
2457 default:
2458 break;
2459 }
2460 break;
2461
2462 case AARCH64_OPND_CLASS_SYSTEM:
2463 switch (type)
2464 {
2465 case AARCH64_OPND_PSTATEFIELD:
2466 assert (idx == 0 && opnds[1].type == AARCH64_OPND_UIMM4);
2467 /* MSR UAO, #uimm4
2468 MSR PAN, #uimm4
2469 The immediate must be #0 or #1. */
2470 if ((opnd->pstatefield == 0x03 /* UAO. */
2471 || opnd->pstatefield == 0x04 /* PAN. */
2472 || opnd->pstatefield == 0x1a) /* DIT. */
2473 && opnds[1].imm.value > 1)
2474 {
2475 set_imm_out_of_range_error (mismatch_detail, idx, 0, 1);
2476 return 0;
2477 }
2478 /* MSR SPSel, #uimm4
2479 Uses uimm4 as a control value to select the stack pointer: if
2480 bit 0 is set it selects the current exception level's stack
2481 pointer, if bit 0 is clear it selects shared EL0 stack pointer.
2482 Bits 1 to 3 of uimm4 are reserved and should be zero. */
2483 if (opnd->pstatefield == 0x05 /* spsel */ && opnds[1].imm.value > 1)
2484 {
2485 set_imm_out_of_range_error (mismatch_detail, idx, 0, 1);
2486 return 0;
2487 }
2488 break;
2489 default:
2490 break;
2491 }
2492 break;
2493
2494 case AARCH64_OPND_CLASS_SIMD_ELEMENT:
2495 /* Get the upper bound for the element index. */
2496 if (opcode->op == OP_FCMLA_ELEM)
2497 /* FCMLA index range depends on the vector size of other operands
2498 and is halfed because complex numbers take two elements. */
2499 num = aarch64_get_qualifier_nelem (opnds[0].qualifier)
2500 * aarch64_get_qualifier_esize (opnds[0].qualifier) / 2;
2501 else
2502 num = 16;
2503 num = num / aarch64_get_qualifier_esize (qualifier) - 1;
2504
2505 /* Index out-of-range. */
2506 if (!value_in_range_p (opnd->reglane.index, 0, num))
2507 {
2508 set_elem_idx_out_of_range_error (mismatch_detail, idx, 0, num);
2509 return 0;
2510 }
2511 /* SMLAL<Q> <Vd>.<Ta>, <Vn>.<Tb>, <Vm>.<Ts>[<index>].
2512 <Vm> Is the vector register (V0-V31) or (V0-V15), whose
2513 number is encoded in "size:M:Rm":
2514 size <Vm>
2515 00 RESERVED
2516 01 0:Rm
2517 10 M:Rm
2518 11 RESERVED */
2519 if (type == AARCH64_OPND_Em16 && qualifier == AARCH64_OPND_QLF_S_H
2520 && !value_in_range_p (opnd->reglane.regno, 0, 15))
2521 {
2522 set_regno_out_of_range_error (mismatch_detail, idx, 0, 15);
2523 return 0;
2524 }
2525 break;
2526
2527 case AARCH64_OPND_CLASS_MODIFIED_REG:
2528 assert (idx == 1 || idx == 2);
2529 switch (type)
2530 {
2531 case AARCH64_OPND_Rm_EXT:
2532 if (!aarch64_extend_operator_p (opnd->shifter.kind)
2533 && opnd->shifter.kind != AARCH64_MOD_LSL)
2534 {
2535 set_other_error (mismatch_detail, idx,
2536 _("extend operator expected"));
2537 return 0;
2538 }
2539 /* It is not optional unless at least one of "Rd" or "Rn" is '11111'
2540 (i.e. SP), in which case it defaults to LSL. The LSL alias is
2541 only valid when "Rd" or "Rn" is '11111', and is preferred in that
2542 case. */
2543 if (!aarch64_stack_pointer_p (opnds + 0)
2544 && (idx != 2 || !aarch64_stack_pointer_p (opnds + 1)))
2545 {
2546 if (!opnd->shifter.operator_present)
2547 {
2548 set_other_error (mismatch_detail, idx,
2549 _("missing extend operator"));
2550 return 0;
2551 }
2552 else if (opnd->shifter.kind == AARCH64_MOD_LSL)
2553 {
2554 set_other_error (mismatch_detail, idx,
2555 _("'LSL' operator not allowed"));
2556 return 0;
2557 }
2558 }
2559 assert (opnd->shifter.operator_present /* Default to LSL. */
2560 || opnd->shifter.kind == AARCH64_MOD_LSL);
2561 if (!value_in_range_p (opnd->shifter.amount, 0, 4))
2562 {
2563 set_sft_amount_out_of_range_error (mismatch_detail, idx, 0, 4);
2564 return 0;
2565 }
2566 /* In the 64-bit form, the final register operand is written as Wm
2567 for all but the (possibly omitted) UXTX/LSL and SXTX
2568 operators.
2569 N.B. GAS allows X register to be used with any operator as a
2570 programming convenience. */
2571 if (qualifier == AARCH64_OPND_QLF_X
2572 && opnd->shifter.kind != AARCH64_MOD_LSL
2573 && opnd->shifter.kind != AARCH64_MOD_UXTX
2574 && opnd->shifter.kind != AARCH64_MOD_SXTX)
2575 {
2576 set_other_error (mismatch_detail, idx, _("W register expected"));
2577 return 0;
2578 }
2579 break;
2580
2581 case AARCH64_OPND_Rm_SFT:
2582 /* ROR is not available to the shifted register operand in
2583 arithmetic instructions. */
2584 if (!aarch64_shift_operator_p (opnd->shifter.kind))
2585 {
2586 set_other_error (mismatch_detail, idx,
2587 _("shift operator expected"));
2588 return 0;
2589 }
2590 if (opnd->shifter.kind == AARCH64_MOD_ROR
2591 && opcode->iclass != log_shift)
2592 {
2593 set_other_error (mismatch_detail, idx,
2594 _("'ROR' operator not allowed"));
2595 return 0;
2596 }
2597 num = qualifier == AARCH64_OPND_QLF_W ? 31 : 63;
2598 if (!value_in_range_p (opnd->shifter.amount, 0, num))
2599 {
2600 set_sft_amount_out_of_range_error (mismatch_detail, idx, 0, num);
2601 return 0;
2602 }
2603 break;
2604
2605 default:
2606 break;
2607 }
2608 break;
2609
2610 default:
2611 break;
2612 }
2613
2614 return 1;
2615 }
2616
2617 /* Main entrypoint for the operand constraint checking.
2618
2619 Return 1 if operands of *INST meet the constraint applied by the operand
2620 codes and operand qualifiers; otherwise return 0 and if MISMATCH_DETAIL is
2621 not NULL, return the detail of the error in *MISMATCH_DETAIL. N.B. when
2622 adding more constraint checking, make sure MISMATCH_DETAIL->KIND is set
2623 with a proper error kind rather than AARCH64_OPDE_NIL (GAS asserts non-NIL
2624 error kind when it is notified that an instruction does not pass the check).
2625
2626 Un-determined operand qualifiers may get established during the process. */
2627
2628 int
2629 aarch64_match_operands_constraint (aarch64_inst *inst,
2630 aarch64_operand_error *mismatch_detail)
2631 {
2632 int i;
2633
2634 DEBUG_TRACE ("enter");
2635
2636 /* Check for cases where a source register needs to be the same as the
2637 destination register. Do this before matching qualifiers since if
2638 an instruction has both invalid tying and invalid qualifiers,
2639 the error about qualifiers would suggest several alternative
2640 instructions that also have invalid tying. */
2641 i = inst->opcode->tied_operand;
2642 if (i > 0 && (inst->operands[0].reg.regno != inst->operands[i].reg.regno))
2643 {
2644 if (mismatch_detail)
2645 {
2646 mismatch_detail->kind = AARCH64_OPDE_UNTIED_OPERAND;
2647 mismatch_detail->index = i;
2648 mismatch_detail->error = NULL;
2649 }
2650 return 0;
2651 }
2652
2653 /* Match operands' qualifier.
2654 *INST has already had qualifier establish for some, if not all, of
2655 its operands; we need to find out whether these established
2656 qualifiers match one of the qualifier sequence in
2657 INST->OPCODE->QUALIFIERS_LIST. If yes, we will assign each operand
2658 with the corresponding qualifier in such a sequence.
2659 Only basic operand constraint checking is done here; the more thorough
2660 constraint checking will carried out by operand_general_constraint_met_p,
2661 which has be to called after this in order to get all of the operands'
2662 qualifiers established. */
2663 if (match_operands_qualifier (inst, TRUE /* update_p */) == 0)
2664 {
2665 DEBUG_TRACE ("FAIL on operand qualifier matching");
2666 if (mismatch_detail)
2667 {
2668 /* Return an error type to indicate that it is the qualifier
2669 matching failure; we don't care about which operand as there
2670 are enough information in the opcode table to reproduce it. */
2671 mismatch_detail->kind = AARCH64_OPDE_INVALID_VARIANT;
2672 mismatch_detail->index = -1;
2673 mismatch_detail->error = NULL;
2674 }
2675 return 0;
2676 }
2677
2678 /* Match operands' constraint. */
2679 for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2680 {
2681 enum aarch64_opnd type = inst->opcode->operands[i];
2682 if (type == AARCH64_OPND_NIL)
2683 break;
2684 if (inst->operands[i].skip)
2685 {
2686 DEBUG_TRACE ("skip the incomplete operand %d", i);
2687 continue;
2688 }
2689 if (operand_general_constraint_met_p (inst->operands, i, type,
2690 inst->opcode, mismatch_detail) == 0)
2691 {
2692 DEBUG_TRACE ("FAIL on operand %d", i);
2693 return 0;
2694 }
2695 }
2696
2697 DEBUG_TRACE ("PASS");
2698
2699 return 1;
2700 }
2701
2702 /* Replace INST->OPCODE with OPCODE and return the replaced OPCODE.
2703 Also updates the TYPE of each INST->OPERANDS with the corresponding
2704 value of OPCODE->OPERANDS.
2705
2706 Note that some operand qualifiers may need to be manually cleared by
2707 the caller before it further calls the aarch64_opcode_encode; by
2708 doing this, it helps the qualifier matching facilities work
2709 properly. */
2710
2711 const aarch64_opcode*
2712 aarch64_replace_opcode (aarch64_inst *inst, const aarch64_opcode *opcode)
2713 {
2714 int i;
2715 const aarch64_opcode *old = inst->opcode;
2716
2717 inst->opcode = opcode;
2718
2719 /* Update the operand types. */
2720 for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2721 {
2722 inst->operands[i].type = opcode->operands[i];
2723 if (opcode->operands[i] == AARCH64_OPND_NIL)
2724 break;
2725 }
2726
2727 DEBUG_TRACE ("replace %s with %s", old->name, opcode->name);
2728
2729 return old;
2730 }
2731
2732 int
2733 aarch64_operand_index (const enum aarch64_opnd *operands, enum aarch64_opnd operand)
2734 {
2735 int i;
2736 for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2737 if (operands[i] == operand)
2738 return i;
2739 else if (operands[i] == AARCH64_OPND_NIL)
2740 break;
2741 return -1;
2742 }
2743 \f
2744 /* R0...R30, followed by FOR31. */
2745 #define BANK(R, FOR31) \
2746 { R (0), R (1), R (2), R (3), R (4), R (5), R (6), R (7), \
2747 R (8), R (9), R (10), R (11), R (12), R (13), R (14), R (15), \
2748 R (16), R (17), R (18), R (19), R (20), R (21), R (22), R (23), \
2749 R (24), R (25), R (26), R (27), R (28), R (29), R (30), FOR31 }
2750 /* [0][0] 32-bit integer regs with sp Wn
2751 [0][1] 64-bit integer regs with sp Xn sf=1
2752 [1][0] 32-bit integer regs with #0 Wn
2753 [1][1] 64-bit integer regs with #0 Xn sf=1 */
2754 static const char *int_reg[2][2][32] = {
2755 #define R32(X) "w" #X
2756 #define R64(X) "x" #X
2757 { BANK (R32, "wsp"), BANK (R64, "sp") },
2758 { BANK (R32, "wzr"), BANK (R64, "xzr") }
2759 #undef R64
2760 #undef R32
2761 };
2762
2763 /* Names of the SVE vector registers, first with .S suffixes,
2764 then with .D suffixes. */
2765
2766 static const char *sve_reg[2][32] = {
2767 #define ZS(X) "z" #X ".s"
2768 #define ZD(X) "z" #X ".d"
2769 BANK (ZS, ZS (31)), BANK (ZD, ZD (31))
2770 #undef ZD
2771 #undef ZS
2772 };
2773 #undef BANK
2774
2775 /* Return the integer register name.
2776 if SP_REG_P is not 0, R31 is an SP reg, other R31 is the zero reg. */
2777
2778 static inline const char *
2779 get_int_reg_name (int regno, aarch64_opnd_qualifier_t qualifier, int sp_reg_p)
2780 {
2781 const int has_zr = sp_reg_p ? 0 : 1;
2782 const int is_64 = aarch64_get_qualifier_esize (qualifier) == 4 ? 0 : 1;
2783 return int_reg[has_zr][is_64][regno];
2784 }
2785
2786 /* Like get_int_reg_name, but IS_64 is always 1. */
2787
2788 static inline const char *
2789 get_64bit_int_reg_name (int regno, int sp_reg_p)
2790 {
2791 const int has_zr = sp_reg_p ? 0 : 1;
2792 return int_reg[has_zr][1][regno];
2793 }
2794
2795 /* Get the name of the integer offset register in OPND, using the shift type
2796 to decide whether it's a word or doubleword. */
2797
2798 static inline const char *
2799 get_offset_int_reg_name (const aarch64_opnd_info *opnd)
2800 {
2801 switch (opnd->shifter.kind)
2802 {
2803 case AARCH64_MOD_UXTW:
2804 case AARCH64_MOD_SXTW:
2805 return get_int_reg_name (opnd->addr.offset.regno, AARCH64_OPND_QLF_W, 0);
2806
2807 case AARCH64_MOD_LSL:
2808 case AARCH64_MOD_SXTX:
2809 return get_int_reg_name (opnd->addr.offset.regno, AARCH64_OPND_QLF_X, 0);
2810
2811 default:
2812 abort ();
2813 }
2814 }
2815
2816 /* Get the name of the SVE vector offset register in OPND, using the operand
2817 qualifier to decide whether the suffix should be .S or .D. */
2818
2819 static inline const char *
2820 get_addr_sve_reg_name (int regno, aarch64_opnd_qualifier_t qualifier)
2821 {
2822 assert (qualifier == AARCH64_OPND_QLF_S_S
2823 || qualifier == AARCH64_OPND_QLF_S_D);
2824 return sve_reg[qualifier == AARCH64_OPND_QLF_S_D][regno];
2825 }
2826
2827 /* Types for expanding an encoded 8-bit value to a floating-point value. */
2828
2829 typedef union
2830 {
2831 uint64_t i;
2832 double d;
2833 } double_conv_t;
2834
2835 typedef union
2836 {
2837 uint32_t i;
2838 float f;
2839 } single_conv_t;
2840
2841 typedef union
2842 {
2843 uint32_t i;
2844 float f;
2845 } half_conv_t;
2846
2847 /* IMM8 is an 8-bit floating-point constant with sign, 3-bit exponent and
2848 normalized 4 bits of precision, encoded in "a:b:c:d:e:f:g:h" or FLD_imm8
2849 (depending on the type of the instruction). IMM8 will be expanded to a
2850 single-precision floating-point value (SIZE == 4) or a double-precision
2851 floating-point value (SIZE == 8). A half-precision floating-point value
2852 (SIZE == 2) is expanded to a single-precision floating-point value. The
2853 expanded value is returned. */
2854
2855 static uint64_t
2856 expand_fp_imm (int size, uint32_t imm8)
2857 {
2858 uint64_t imm = 0;
2859 uint32_t imm8_7, imm8_6_0, imm8_6, imm8_6_repl4;
2860
2861 imm8_7 = (imm8 >> 7) & 0x01; /* imm8<7> */
2862 imm8_6_0 = imm8 & 0x7f; /* imm8<6:0> */
2863 imm8_6 = imm8_6_0 >> 6; /* imm8<6> */
2864 imm8_6_repl4 = (imm8_6 << 3) | (imm8_6 << 2)
2865 | (imm8_6 << 1) | imm8_6; /* Replicate(imm8<6>,4) */
2866 if (size == 8)
2867 {
2868 imm = (imm8_7 << (63-32)) /* imm8<7> */
2869 | ((imm8_6 ^ 1) << (62-32)) /* NOT(imm8<6) */
2870 | (imm8_6_repl4 << (58-32)) | (imm8_6 << (57-32))
2871 | (imm8_6 << (56-32)) | (imm8_6 << (55-32)) /* Replicate(imm8<6>,7) */
2872 | (imm8_6_0 << (48-32)); /* imm8<6>:imm8<5:0> */
2873 imm <<= 32;
2874 }
2875 else if (size == 4 || size == 2)
2876 {
2877 imm = (imm8_7 << 31) /* imm8<7> */
2878 | ((imm8_6 ^ 1) << 30) /* NOT(imm8<6>) */
2879 | (imm8_6_repl4 << 26) /* Replicate(imm8<6>,4) */
2880 | (imm8_6_0 << 19); /* imm8<6>:imm8<5:0> */
2881 }
2882 else
2883 {
2884 /* An unsupported size. */
2885 assert (0);
2886 }
2887
2888 return imm;
2889 }
2890
2891 /* Produce the string representation of the register list operand *OPND
2892 in the buffer pointed by BUF of size SIZE. PREFIX is the part of
2893 the register name that comes before the register number, such as "v". */
2894 static void
2895 print_register_list (char *buf, size_t size, const aarch64_opnd_info *opnd,
2896 const char *prefix)
2897 {
2898 const int num_regs = opnd->reglist.num_regs;
2899 const int first_reg = opnd->reglist.first_regno;
2900 const int last_reg = (first_reg + num_regs - 1) & 0x1f;
2901 const char *qlf_name = aarch64_get_qualifier_name (opnd->qualifier);
2902 char tb[8]; /* Temporary buffer. */
2903
2904 assert (opnd->type != AARCH64_OPND_LEt || opnd->reglist.has_index);
2905 assert (num_regs >= 1 && num_regs <= 4);
2906
2907 /* Prepare the index if any. */
2908 if (opnd->reglist.has_index)
2909 /* PR 21096: The %100 is to silence a warning about possible truncation. */
2910 snprintf (tb, 8, "[%" PRIi64 "]", (opnd->reglist.index % 100));
2911 else
2912 tb[0] = '\0';
2913
2914 /* The hyphenated form is preferred for disassembly if there are
2915 more than two registers in the list, and the register numbers
2916 are monotonically increasing in increments of one. */
2917 if (num_regs > 2 && last_reg > first_reg)
2918 snprintf (buf, size, "{%s%d.%s-%s%d.%s}%s", prefix, first_reg, qlf_name,
2919 prefix, last_reg, qlf_name, tb);
2920 else
2921 {
2922 const int reg0 = first_reg;
2923 const int reg1 = (first_reg + 1) & 0x1f;
2924 const int reg2 = (first_reg + 2) & 0x1f;
2925 const int reg3 = (first_reg + 3) & 0x1f;
2926
2927 switch (num_regs)
2928 {
2929 case 1:
2930 snprintf (buf, size, "{%s%d.%s}%s", prefix, reg0, qlf_name, tb);
2931 break;
2932 case 2:
2933 snprintf (buf, size, "{%s%d.%s, %s%d.%s}%s", prefix, reg0, qlf_name,
2934 prefix, reg1, qlf_name, tb);
2935 break;
2936 case 3:
2937 snprintf (buf, size, "{%s%d.%s, %s%d.%s, %s%d.%s}%s",
2938 prefix, reg0, qlf_name, prefix, reg1, qlf_name,
2939 prefix, reg2, qlf_name, tb);
2940 break;
2941 case 4:
2942 snprintf (buf, size, "{%s%d.%s, %s%d.%s, %s%d.%s, %s%d.%s}%s",
2943 prefix, reg0, qlf_name, prefix, reg1, qlf_name,
2944 prefix, reg2, qlf_name, prefix, reg3, qlf_name, tb);
2945 break;
2946 }
2947 }
2948 }
2949
2950 /* Print the register+immediate address in OPND to BUF, which has SIZE
2951 characters. BASE is the name of the base register. */
2952
2953 static void
2954 print_immediate_offset_address (char *buf, size_t size,
2955 const aarch64_opnd_info *opnd,
2956 const char *base)
2957 {
2958 if (opnd->addr.writeback)
2959 {
2960 if (opnd->addr.preind)
2961 snprintf (buf, size, "[%s, #%d]!", base, opnd->addr.offset.imm);
2962 else
2963 snprintf (buf, size, "[%s], #%d", base, opnd->addr.offset.imm);
2964 }
2965 else
2966 {
2967 if (opnd->shifter.operator_present)
2968 {
2969 assert (opnd->shifter.kind == AARCH64_MOD_MUL_VL);
2970 snprintf (buf, size, "[%s, #%d, mul vl]",
2971 base, opnd->addr.offset.imm);
2972 }
2973 else if (opnd->addr.offset.imm)
2974 snprintf (buf, size, "[%s, #%d]", base, opnd->addr.offset.imm);
2975 else
2976 snprintf (buf, size, "[%s]", base);
2977 }
2978 }
2979
2980 /* Produce the string representation of the register offset address operand
2981 *OPND in the buffer pointed by BUF of size SIZE. BASE and OFFSET are
2982 the names of the base and offset registers. */
2983 static void
2984 print_register_offset_address (char *buf, size_t size,
2985 const aarch64_opnd_info *opnd,
2986 const char *base, const char *offset)
2987 {
2988 char tb[16]; /* Temporary buffer. */
2989 bfd_boolean print_extend_p = TRUE;
2990 bfd_boolean print_amount_p = TRUE;
2991 const char *shift_name = aarch64_operand_modifiers[opnd->shifter.kind].name;
2992
2993 if (!opnd->shifter.amount && (opnd->qualifier != AARCH64_OPND_QLF_S_B
2994 || !opnd->shifter.amount_present))
2995 {
2996 /* Not print the shift/extend amount when the amount is zero and
2997 when it is not the special case of 8-bit load/store instruction. */
2998 print_amount_p = FALSE;
2999 /* Likewise, no need to print the shift operator LSL in such a
3000 situation. */
3001 if (opnd->shifter.kind == AARCH64_MOD_LSL)
3002 print_extend_p = FALSE;
3003 }
3004
3005 /* Prepare for the extend/shift. */
3006 if (print_extend_p)
3007 {
3008 if (print_amount_p)
3009 snprintf (tb, sizeof (tb), ", %s #%" PRIi64, shift_name,
3010 /* PR 21096: The %100 is to silence a warning about possible truncation. */
3011 (opnd->shifter.amount % 100));
3012 else
3013 snprintf (tb, sizeof (tb), ", %s", shift_name);
3014 }
3015 else
3016 tb[0] = '\0';
3017
3018 snprintf (buf, size, "[%s, %s%s]", base, offset, tb);
3019 }
3020
3021 /* Generate the string representation of the operand OPNDS[IDX] for OPCODE
3022 in *BUF. The caller should pass in the maximum size of *BUF in SIZE.
3023 PC, PCREL_P and ADDRESS are used to pass in and return information about
3024 the PC-relative address calculation, where the PC value is passed in
3025 PC. If the operand is pc-relative related, *PCREL_P (if PCREL_P non-NULL)
3026 will return 1 and *ADDRESS (if ADDRESS non-NULL) will return the
3027 calculated address; otherwise, *PCREL_P (if PCREL_P non-NULL) returns 0.
3028
3029 The function serves both the disassembler and the assembler diagnostics
3030 issuer, which is the reason why it lives in this file. */
3031
3032 void
3033 aarch64_print_operand (char *buf, size_t size, bfd_vma pc,
3034 const aarch64_opcode *opcode,
3035 const aarch64_opnd_info *opnds, int idx, int *pcrel_p,
3036 bfd_vma *address, char** notes ATTRIBUTE_UNUSED)
3037 {
3038 unsigned int i, num_conds;
3039 const char *name = NULL;
3040 const aarch64_opnd_info *opnd = opnds + idx;
3041 enum aarch64_modifier_kind kind;
3042 uint64_t addr, enum_value;
3043
3044 buf[0] = '\0';
3045 if (pcrel_p)
3046 *pcrel_p = 0;
3047
3048 switch (opnd->type)
3049 {
3050 case AARCH64_OPND_Rd:
3051 case AARCH64_OPND_Rn:
3052 case AARCH64_OPND_Rm:
3053 case AARCH64_OPND_Rt:
3054 case AARCH64_OPND_Rt2:
3055 case AARCH64_OPND_Rs:
3056 case AARCH64_OPND_Ra:
3057 case AARCH64_OPND_Rt_SYS:
3058 case AARCH64_OPND_PAIRREG:
3059 case AARCH64_OPND_SVE_Rm:
3060 /* The optional-ness of <Xt> in e.g. IC <ic_op>{, <Xt>} is determined by
3061 the <ic_op>, therefore we use opnd->present to override the
3062 generic optional-ness information. */
3063 if (opnd->type == AARCH64_OPND_Rt_SYS)
3064 {
3065 if (!opnd->present)
3066 break;
3067 }
3068 /* Omit the operand, e.g. RET. */
3069 else if (optional_operand_p (opcode, idx)
3070 && (opnd->reg.regno
3071 == get_optional_operand_default_value (opcode)))
3072 break;
3073 assert (opnd->qualifier == AARCH64_OPND_QLF_W
3074 || opnd->qualifier == AARCH64_OPND_QLF_X);
3075 snprintf (buf, size, "%s",
3076 get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0));
3077 break;
3078
3079 case AARCH64_OPND_Rd_SP:
3080 case AARCH64_OPND_Rn_SP:
3081 case AARCH64_OPND_SVE_Rn_SP:
3082 case AARCH64_OPND_Rm_SP:
3083 assert (opnd->qualifier == AARCH64_OPND_QLF_W
3084 || opnd->qualifier == AARCH64_OPND_QLF_WSP
3085 || opnd->qualifier == AARCH64_OPND_QLF_X
3086 || opnd->qualifier == AARCH64_OPND_QLF_SP);
3087 snprintf (buf, size, "%s",
3088 get_int_reg_name (opnd->reg.regno, opnd->qualifier, 1));
3089 break;
3090
3091 case AARCH64_OPND_Rm_EXT:
3092 kind = opnd->shifter.kind;
3093 assert (idx == 1 || idx == 2);
3094 if ((aarch64_stack_pointer_p (opnds)
3095 || (idx == 2 && aarch64_stack_pointer_p (opnds + 1)))
3096 && ((opnd->qualifier == AARCH64_OPND_QLF_W
3097 && opnds[0].qualifier == AARCH64_OPND_QLF_W
3098 && kind == AARCH64_MOD_UXTW)
3099 || (opnd->qualifier == AARCH64_OPND_QLF_X
3100 && kind == AARCH64_MOD_UXTX)))
3101 {
3102 /* 'LSL' is the preferred form in this case. */
3103 kind = AARCH64_MOD_LSL;
3104 if (opnd->shifter.amount == 0)
3105 {
3106 /* Shifter omitted. */
3107 snprintf (buf, size, "%s",
3108 get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0));
3109 break;
3110 }
3111 }
3112 if (opnd->shifter.amount)
3113 snprintf (buf, size, "%s, %s #%" PRIi64,
3114 get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0),
3115 aarch64_operand_modifiers[kind].name,
3116 opnd->shifter.amount);
3117 else
3118 snprintf (buf, size, "%s, %s",
3119 get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0),
3120 aarch64_operand_modifiers[kind].name);
3121 break;
3122
3123 case AARCH64_OPND_Rm_SFT:
3124 assert (opnd->qualifier == AARCH64_OPND_QLF_W
3125 || opnd->qualifier == AARCH64_OPND_QLF_X);
3126 if (opnd->shifter.amount == 0 && opnd->shifter.kind == AARCH64_MOD_LSL)
3127 snprintf (buf, size, "%s",
3128 get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0));
3129 else
3130 snprintf (buf, size, "%s, %s #%" PRIi64,
3131 get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0),
3132 aarch64_operand_modifiers[opnd->shifter.kind].name,
3133 opnd->shifter.amount);
3134 break;
3135
3136 case AARCH64_OPND_Fd:
3137 case AARCH64_OPND_Fn:
3138 case AARCH64_OPND_Fm:
3139 case AARCH64_OPND_Fa:
3140 case AARCH64_OPND_Ft:
3141 case AARCH64_OPND_Ft2:
3142 case AARCH64_OPND_Sd:
3143 case AARCH64_OPND_Sn:
3144 case AARCH64_OPND_Sm:
3145 case AARCH64_OPND_SVE_VZn:
3146 case AARCH64_OPND_SVE_Vd:
3147 case AARCH64_OPND_SVE_Vm:
3148 case AARCH64_OPND_SVE_Vn:
3149 snprintf (buf, size, "%s%d", aarch64_get_qualifier_name (opnd->qualifier),
3150 opnd->reg.regno);
3151 break;
3152
3153 case AARCH64_OPND_Va:
3154 case AARCH64_OPND_Vd:
3155 case AARCH64_OPND_Vn:
3156 case AARCH64_OPND_Vm:
3157 snprintf (buf, size, "v%d.%s", opnd->reg.regno,
3158 aarch64_get_qualifier_name (opnd->qualifier));
3159 break;
3160
3161 case AARCH64_OPND_Ed:
3162 case AARCH64_OPND_En:
3163 case AARCH64_OPND_Em:
3164 case AARCH64_OPND_Em16:
3165 case AARCH64_OPND_SM3_IMM2:
3166 snprintf (buf, size, "v%d.%s[%" PRIi64 "]", opnd->reglane.regno,
3167 aarch64_get_qualifier_name (opnd->qualifier),
3168 opnd->reglane.index);
3169 break;
3170
3171 case AARCH64_OPND_VdD1:
3172 case AARCH64_OPND_VnD1:
3173 snprintf (buf, size, "v%d.d[1]", opnd->reg.regno);
3174 break;
3175
3176 case AARCH64_OPND_LVn:
3177 case AARCH64_OPND_LVt:
3178 case AARCH64_OPND_LVt_AL:
3179 case AARCH64_OPND_LEt:
3180 print_register_list (buf, size, opnd, "v");
3181 break;
3182
3183 case AARCH64_OPND_SVE_Pd:
3184 case AARCH64_OPND_SVE_Pg3:
3185 case AARCH64_OPND_SVE_Pg4_5:
3186 case AARCH64_OPND_SVE_Pg4_10:
3187 case AARCH64_OPND_SVE_Pg4_16:
3188 case AARCH64_OPND_SVE_Pm:
3189 case AARCH64_OPND_SVE_Pn:
3190 case AARCH64_OPND_SVE_Pt:
3191 if (opnd->qualifier == AARCH64_OPND_QLF_NIL)
3192 snprintf (buf, size, "p%d", opnd->reg.regno);
3193 else if (opnd->qualifier == AARCH64_OPND_QLF_P_Z
3194 || opnd->qualifier == AARCH64_OPND_QLF_P_M)
3195 snprintf (buf, size, "p%d/%s", opnd->reg.regno,
3196 aarch64_get_qualifier_name (opnd->qualifier));
3197 else
3198 snprintf (buf, size, "p%d.%s", opnd->reg.regno,
3199 aarch64_get_qualifier_name (opnd->qualifier));
3200 break;
3201
3202 case AARCH64_OPND_SVE_Za_5:
3203 case AARCH64_OPND_SVE_Za_16:
3204 case AARCH64_OPND_SVE_Zd:
3205 case AARCH64_OPND_SVE_Zm_5:
3206 case AARCH64_OPND_SVE_Zm_16:
3207 case AARCH64_OPND_SVE_Zn:
3208 case AARCH64_OPND_SVE_Zt:
3209 if (opnd->qualifier == AARCH64_OPND_QLF_NIL)
3210 snprintf (buf, size, "z%d", opnd->reg.regno);
3211 else
3212 snprintf (buf, size, "z%d.%s", opnd->reg.regno,
3213 aarch64_get_qualifier_name (opnd->qualifier));
3214 break;
3215
3216 case AARCH64_OPND_SVE_ZnxN:
3217 case AARCH64_OPND_SVE_ZtxN:
3218 print_register_list (buf, size, opnd, "z");
3219 break;
3220
3221 case AARCH64_OPND_SVE_Zm3_INDEX:
3222 case AARCH64_OPND_SVE_Zm3_22_INDEX:
3223 case AARCH64_OPND_SVE_Zm4_INDEX:
3224 case AARCH64_OPND_SVE_Zn_INDEX:
3225 snprintf (buf, size, "z%d.%s[%" PRIi64 "]", opnd->reglane.regno,
3226 aarch64_get_qualifier_name (opnd->qualifier),
3227 opnd->reglane.index);
3228 break;
3229
3230 case AARCH64_OPND_CRn:
3231 case AARCH64_OPND_CRm:
3232 snprintf (buf, size, "C%" PRIi64, opnd->imm.value);
3233 break;
3234
3235 case AARCH64_OPND_IDX:
3236 case AARCH64_OPND_MASK:
3237 case AARCH64_OPND_IMM:
3238 case AARCH64_OPND_IMM_2:
3239 case AARCH64_OPND_WIDTH:
3240 case AARCH64_OPND_UIMM3_OP1:
3241 case AARCH64_OPND_UIMM3_OP2:
3242 case AARCH64_OPND_BIT_NUM:
3243 case AARCH64_OPND_IMM_VLSL:
3244 case AARCH64_OPND_IMM_VLSR:
3245 case AARCH64_OPND_SHLL_IMM:
3246 case AARCH64_OPND_IMM0:
3247 case AARCH64_OPND_IMMR:
3248 case AARCH64_OPND_IMMS:
3249 case AARCH64_OPND_FBITS:
3250 case AARCH64_OPND_SIMM5:
3251 case AARCH64_OPND_SVE_SHLIMM_PRED:
3252 case AARCH64_OPND_SVE_SHLIMM_UNPRED:
3253 case AARCH64_OPND_SVE_SHRIMM_PRED:
3254 case AARCH64_OPND_SVE_SHRIMM_UNPRED:
3255 case AARCH64_OPND_SVE_SIMM5:
3256 case AARCH64_OPND_SVE_SIMM5B:
3257 case AARCH64_OPND_SVE_SIMM6:
3258 case AARCH64_OPND_SVE_SIMM8:
3259 case AARCH64_OPND_SVE_UIMM3:
3260 case AARCH64_OPND_SVE_UIMM7:
3261 case AARCH64_OPND_SVE_UIMM8:
3262 case AARCH64_OPND_SVE_UIMM8_53:
3263 case AARCH64_OPND_IMM_ROT1:
3264 case AARCH64_OPND_IMM_ROT2:
3265 case AARCH64_OPND_IMM_ROT3:
3266 case AARCH64_OPND_SVE_IMM_ROT1:
3267 case AARCH64_OPND_SVE_IMM_ROT2:
3268 snprintf (buf, size, "#%" PRIi64, opnd->imm.value);
3269 break;
3270
3271 case AARCH64_OPND_SVE_I1_HALF_ONE:
3272 case AARCH64_OPND_SVE_I1_HALF_TWO:
3273 case AARCH64_OPND_SVE_I1_ZERO_ONE:
3274 {
3275 single_conv_t c;
3276 c.i = opnd->imm.value;
3277 snprintf (buf, size, "#%.1f", c.f);
3278 break;
3279 }
3280
3281 case AARCH64_OPND_SVE_PATTERN:
3282 if (optional_operand_p (opcode, idx)
3283 && opnd->imm.value == get_optional_operand_default_value (opcode))
3284 break;
3285 enum_value = opnd->imm.value;
3286 assert (enum_value < ARRAY_SIZE (aarch64_sve_pattern_array));
3287 if (aarch64_sve_pattern_array[enum_value])
3288 snprintf (buf, size, "%s", aarch64_sve_pattern_array[enum_value]);
3289 else
3290 snprintf (buf, size, "#%" PRIi64, opnd->imm.value);
3291 break;
3292
3293 case AARCH64_OPND_SVE_PATTERN_SCALED:
3294 if (optional_operand_p (opcode, idx)
3295 && !opnd->shifter.operator_present
3296 && opnd->imm.value == get_optional_operand_default_value (opcode))
3297 break;
3298 enum_value = opnd->imm.value;
3299 assert (enum_value < ARRAY_SIZE (aarch64_sve_pattern_array));
3300 if (aarch64_sve_pattern_array[opnd->imm.value])
3301 snprintf (buf, size, "%s", aarch64_sve_pattern_array[opnd->imm.value]);
3302 else
3303 snprintf (buf, size, "#%" PRIi64, opnd->imm.value);
3304 if (opnd->shifter.operator_present)
3305 {
3306 size_t len = strlen (buf);
3307 snprintf (buf + len, size - len, ", %s #%" PRIi64,
3308 aarch64_operand_modifiers[opnd->shifter.kind].name,
3309 opnd->shifter.amount);
3310 }
3311 break;
3312
3313 case AARCH64_OPND_SVE_PRFOP:
3314 enum_value = opnd->imm.value;
3315 assert (enum_value < ARRAY_SIZE (aarch64_sve_prfop_array));
3316 if (aarch64_sve_prfop_array[enum_value])
3317 snprintf (buf, size, "%s", aarch64_sve_prfop_array[enum_value]);
3318 else
3319 snprintf (buf, size, "#%" PRIi64, opnd->imm.value);
3320 break;
3321
3322 case AARCH64_OPND_IMM_MOV:
3323 switch (aarch64_get_qualifier_esize (opnds[0].qualifier))
3324 {
3325 case 4: /* e.g. MOV Wd, #<imm32>. */
3326 {
3327 int imm32 = opnd->imm.value;
3328 snprintf (buf, size, "#0x%-20x\t// #%d", imm32, imm32);
3329 }
3330 break;
3331 case 8: /* e.g. MOV Xd, #<imm64>. */
3332 snprintf (buf, size, "#0x%-20" PRIx64 "\t// #%" PRIi64,
3333 opnd->imm.value, opnd->imm.value);
3334 break;
3335 default: assert (0);
3336 }
3337 break;
3338
3339 case AARCH64_OPND_FPIMM0:
3340 snprintf (buf, size, "#0.0");
3341 break;
3342
3343 case AARCH64_OPND_LIMM:
3344 case AARCH64_OPND_AIMM:
3345 case AARCH64_OPND_HALF:
3346 case AARCH64_OPND_SVE_INV_LIMM:
3347 case AARCH64_OPND_SVE_LIMM:
3348 case AARCH64_OPND_SVE_LIMM_MOV:
3349 if (opnd->shifter.amount)
3350 snprintf (buf, size, "#0x%" PRIx64 ", lsl #%" PRIi64, opnd->imm.value,
3351 opnd->shifter.amount);
3352 else
3353 snprintf (buf, size, "#0x%" PRIx64, opnd->imm.value);
3354 break;
3355
3356 case AARCH64_OPND_SIMD_IMM:
3357 case AARCH64_OPND_SIMD_IMM_SFT:
3358 if ((! opnd->shifter.amount && opnd->shifter.kind == AARCH64_MOD_LSL)
3359 || opnd->shifter.kind == AARCH64_MOD_NONE)
3360 snprintf (buf, size, "#0x%" PRIx64, opnd->imm.value);
3361 else
3362 snprintf (buf, size, "#0x%" PRIx64 ", %s #%" PRIi64, opnd->imm.value,
3363 aarch64_operand_modifiers[opnd->shifter.kind].name,
3364 opnd->shifter.amount);
3365 break;
3366
3367 case AARCH64_OPND_SVE_AIMM:
3368 case AARCH64_OPND_SVE_ASIMM:
3369 if (opnd->shifter.amount)
3370 snprintf (buf, size, "#%" PRIi64 ", lsl #%" PRIi64, opnd->imm.value,
3371 opnd->shifter.amount);
3372 else
3373 snprintf (buf, size, "#%" PRIi64, opnd->imm.value);
3374 break;
3375
3376 case AARCH64_OPND_FPIMM:
3377 case AARCH64_OPND_SIMD_FPIMM:
3378 case AARCH64_OPND_SVE_FPIMM8:
3379 switch (aarch64_get_qualifier_esize (opnds[0].qualifier))
3380 {
3381 case 2: /* e.g. FMOV <Hd>, #<imm>. */
3382 {
3383 half_conv_t c;
3384 c.i = expand_fp_imm (2, opnd->imm.value);
3385 snprintf (buf, size, "#%.18e", c.f);
3386 }
3387 break;
3388 case 4: /* e.g. FMOV <Vd>.4S, #<imm>. */
3389 {
3390 single_conv_t c;
3391 c.i = expand_fp_imm (4, opnd->imm.value);
3392 snprintf (buf, size, "#%.18e", c.f);
3393 }
3394 break;
3395 case 8: /* e.g. FMOV <Sd>, #<imm>. */
3396 {
3397 double_conv_t c;
3398 c.i = expand_fp_imm (8, opnd->imm.value);
3399 snprintf (buf, size, "#%.18e", c.d);
3400 }
3401 break;
3402 default: assert (0);
3403 }
3404 break;
3405
3406 case AARCH64_OPND_CCMP_IMM:
3407 case AARCH64_OPND_NZCV:
3408 case AARCH64_OPND_EXCEPTION:
3409 case AARCH64_OPND_UIMM4:
3410 case AARCH64_OPND_UIMM7:
3411 if (optional_operand_p (opcode, idx) == TRUE
3412 && (opnd->imm.value ==
3413 (int64_t) get_optional_operand_default_value (opcode)))
3414 /* Omit the operand, e.g. DCPS1. */
3415 break;
3416 snprintf (buf, size, "#0x%x", (unsigned int)opnd->imm.value);
3417 break;
3418
3419 case AARCH64_OPND_COND:
3420 case AARCH64_OPND_COND1:
3421 snprintf (buf, size, "%s", opnd->cond->names[0]);
3422 num_conds = ARRAY_SIZE (opnd->cond->names);
3423 for (i = 1; i < num_conds && opnd->cond->names[i]; ++i)
3424 {
3425 size_t len = strlen (buf);
3426 if (i == 1)
3427 snprintf (buf + len, size - len, " // %s = %s",
3428 opnd->cond->names[0], opnd->cond->names[i]);
3429 else
3430 snprintf (buf + len, size - len, ", %s",
3431 opnd->cond->names[i]);
3432 }
3433 break;
3434
3435 case AARCH64_OPND_ADDR_ADRP:
3436 addr = ((pc + AARCH64_PCREL_OFFSET) & ~(uint64_t)0xfff)
3437 + opnd->imm.value;
3438 if (pcrel_p)
3439 *pcrel_p = 1;
3440 if (address)
3441 *address = addr;
3442 /* This is not necessary during the disassembling, as print_address_func
3443 in the disassemble_info will take care of the printing. But some
3444 other callers may be still interested in getting the string in *STR,
3445 so here we do snprintf regardless. */
3446 snprintf (buf, size, "#0x%" PRIx64, addr);
3447 break;
3448
3449 case AARCH64_OPND_ADDR_PCREL14:
3450 case AARCH64_OPND_ADDR_PCREL19:
3451 case AARCH64_OPND_ADDR_PCREL21:
3452 case AARCH64_OPND_ADDR_PCREL26:
3453 addr = pc + AARCH64_PCREL_OFFSET + opnd->imm.value;
3454 if (pcrel_p)
3455 *pcrel_p = 1;
3456 if (address)
3457 *address = addr;
3458 /* This is not necessary during the disassembling, as print_address_func
3459 in the disassemble_info will take care of the printing. But some
3460 other callers may be still interested in getting the string in *STR,
3461 so here we do snprintf regardless. */
3462 snprintf (buf, size, "#0x%" PRIx64, addr);
3463 break;
3464
3465 case AARCH64_OPND_ADDR_SIMPLE:
3466 case AARCH64_OPND_SIMD_ADDR_SIMPLE:
3467 case AARCH64_OPND_SIMD_ADDR_POST:
3468 name = get_64bit_int_reg_name (opnd->addr.base_regno, 1);
3469 if (opnd->type == AARCH64_OPND_SIMD_ADDR_POST)
3470 {
3471 if (opnd->addr.offset.is_reg)
3472 snprintf (buf, size, "[%s], x%d", name, opnd->addr.offset.regno);
3473 else
3474 snprintf (buf, size, "[%s], #%d", name, opnd->addr.offset.imm);
3475 }
3476 else
3477 snprintf (buf, size, "[%s]", name);
3478 break;
3479
3480 case AARCH64_OPND_ADDR_REGOFF:
3481 case AARCH64_OPND_SVE_ADDR_R:
3482 case AARCH64_OPND_SVE_ADDR_RR:
3483 case AARCH64_OPND_SVE_ADDR_RR_LSL1:
3484 case AARCH64_OPND_SVE_ADDR_RR_LSL2:
3485 case AARCH64_OPND_SVE_ADDR_RR_LSL3:
3486 case AARCH64_OPND_SVE_ADDR_RX:
3487 case AARCH64_OPND_SVE_ADDR_RX_LSL1:
3488 case AARCH64_OPND_SVE_ADDR_RX_LSL2:
3489 case AARCH64_OPND_SVE_ADDR_RX_LSL3:
3490 print_register_offset_address
3491 (buf, size, opnd, get_64bit_int_reg_name (opnd->addr.base_regno, 1),
3492 get_offset_int_reg_name (opnd));
3493 break;
3494
3495 case AARCH64_OPND_SVE_ADDR_RZ:
3496 case AARCH64_OPND_SVE_ADDR_RZ_LSL1:
3497 case AARCH64_OPND_SVE_ADDR_RZ_LSL2:
3498 case AARCH64_OPND_SVE_ADDR_RZ_LSL3:
3499 case AARCH64_OPND_SVE_ADDR_RZ_XTW_14:
3500 case AARCH64_OPND_SVE_ADDR_RZ_XTW_22:
3501 case AARCH64_OPND_SVE_ADDR_RZ_XTW1_14:
3502 case AARCH64_OPND_SVE_ADDR_RZ_XTW1_22:
3503 case AARCH64_OPND_SVE_ADDR_RZ_XTW2_14:
3504 case AARCH64_OPND_SVE_ADDR_RZ_XTW2_22:
3505 case AARCH64_OPND_SVE_ADDR_RZ_XTW3_14:
3506 case AARCH64_OPND_SVE_ADDR_RZ_XTW3_22:
3507 print_register_offset_address
3508 (buf, size, opnd, get_64bit_int_reg_name (opnd->addr.base_regno, 1),
3509 get_addr_sve_reg_name (opnd->addr.offset.regno, opnd->qualifier));
3510 break;
3511
3512 case AARCH64_OPND_ADDR_SIMM7:
3513 case AARCH64_OPND_ADDR_SIMM9:
3514 case AARCH64_OPND_ADDR_SIMM9_2:
3515 case AARCH64_OPND_ADDR_SIMM10:
3516 case AARCH64_OPND_ADDR_OFFSET:
3517 case AARCH64_OPND_SVE_ADDR_RI_S4x16:
3518 case AARCH64_OPND_SVE_ADDR_RI_S4xVL:
3519 case AARCH64_OPND_SVE_ADDR_RI_S4x2xVL:
3520 case AARCH64_OPND_SVE_ADDR_RI_S4x3xVL:
3521 case AARCH64_OPND_SVE_ADDR_RI_S4x4xVL:
3522 case AARCH64_OPND_SVE_ADDR_RI_S6xVL:
3523 case AARCH64_OPND_SVE_ADDR_RI_S9xVL:
3524 case AARCH64_OPND_SVE_ADDR_RI_U6:
3525 case AARCH64_OPND_SVE_ADDR_RI_U6x2:
3526 case AARCH64_OPND_SVE_ADDR_RI_U6x4:
3527 case AARCH64_OPND_SVE_ADDR_RI_U6x8:
3528 print_immediate_offset_address
3529 (buf, size, opnd, get_64bit_int_reg_name (opnd->addr.base_regno, 1));
3530 break;
3531
3532 case AARCH64_OPND_SVE_ADDR_ZI_U5:
3533 case AARCH64_OPND_SVE_ADDR_ZI_U5x2:
3534 case AARCH64_OPND_SVE_ADDR_ZI_U5x4:
3535 case AARCH64_OPND_SVE_ADDR_ZI_U5x8:
3536 print_immediate_offset_address
3537 (buf, size, opnd,
3538 get_addr_sve_reg_name (opnd->addr.base_regno, opnd->qualifier));
3539 break;
3540
3541 case AARCH64_OPND_SVE_ADDR_ZZ_LSL:
3542 case AARCH64_OPND_SVE_ADDR_ZZ_SXTW:
3543 case AARCH64_OPND_SVE_ADDR_ZZ_UXTW:
3544 print_register_offset_address
3545 (buf, size, opnd,
3546 get_addr_sve_reg_name (opnd->addr.base_regno, opnd->qualifier),
3547 get_addr_sve_reg_name (opnd->addr.offset.regno, opnd->qualifier));
3548 break;
3549
3550 case AARCH64_OPND_ADDR_UIMM12:
3551 name = get_64bit_int_reg_name (opnd->addr.base_regno, 1);
3552 if (opnd->addr.offset.imm)
3553 snprintf (buf, size, "[%s, #%d]", name, opnd->addr.offset.imm);
3554 else
3555 snprintf (buf, size, "[%s]", name);
3556 break;
3557
3558 case AARCH64_OPND_SYSREG:
3559 for (i = 0; aarch64_sys_regs[i].name; ++i)
3560 {
3561 bfd_boolean exact_match
3562 = (aarch64_sys_regs[i].flags & opnd->sysreg.flags)
3563 == opnd->sysreg.flags;
3564
3565 /* Try and find an exact match, But if that fails, return the first
3566 partial match that was found. */
3567 if (aarch64_sys_regs[i].value == opnd->sysreg.value
3568 && ! aarch64_sys_reg_deprecated_p (&aarch64_sys_regs[i])
3569 && (name == NULL || exact_match))
3570 {
3571 name = aarch64_sys_regs[i].name;
3572 if (exact_match)
3573 {
3574 if (notes)
3575 *notes = NULL;
3576 break;
3577 }
3578
3579 /* If we didn't match exactly, that means the presense of a flag
3580 indicates what we didn't want for this instruction. e.g. If
3581 F_REG_READ is there, that means we were looking for a write
3582 register. See aarch64_ext_sysreg. */
3583 if (aarch64_sys_regs[i].flags & F_REG_WRITE)
3584 *notes = _("reading from a write-only register.");
3585 else if (aarch64_sys_regs[i].flags & F_REG_READ)
3586 *notes = _("writing to a read-only register.");
3587 }
3588 }
3589
3590 if (name)
3591 snprintf (buf, size, "%s", name);
3592 else
3593 {
3594 /* Implementation defined system register. */
3595 unsigned int value = opnd->sysreg.value;
3596 snprintf (buf, size, "s%u_%u_c%u_c%u_%u", (value >> 14) & 0x3,
3597 (value >> 11) & 0x7, (value >> 7) & 0xf, (value >> 3) & 0xf,
3598 value & 0x7);
3599 }
3600 break;
3601
3602 case AARCH64_OPND_PSTATEFIELD:
3603 for (i = 0; aarch64_pstatefields[i].name; ++i)
3604 if (aarch64_pstatefields[i].value == opnd->pstatefield)
3605 break;
3606 assert (aarch64_pstatefields[i].name);
3607 snprintf (buf, size, "%s", aarch64_pstatefields[i].name);
3608 break;
3609
3610 case AARCH64_OPND_SYSREG_AT:
3611 case AARCH64_OPND_SYSREG_DC:
3612 case AARCH64_OPND_SYSREG_IC:
3613 case AARCH64_OPND_SYSREG_TLBI:
3614 snprintf (buf, size, "%s", opnd->sysins_op->name);
3615 break;
3616
3617 case AARCH64_OPND_BARRIER:
3618 snprintf (buf, size, "%s", opnd->barrier->name);
3619 break;
3620
3621 case AARCH64_OPND_BARRIER_ISB:
3622 /* Operand can be omitted, e.g. in DCPS1. */
3623 if (! optional_operand_p (opcode, idx)
3624 || (opnd->barrier->value
3625 != get_optional_operand_default_value (opcode)))
3626 snprintf (buf, size, "#0x%x", opnd->barrier->value);
3627 break;
3628
3629 case AARCH64_OPND_PRFOP:
3630 if (opnd->prfop->name != NULL)
3631 snprintf (buf, size, "%s", opnd->prfop->name);
3632 else
3633 snprintf (buf, size, "#0x%02x", opnd->prfop->value);
3634 break;
3635
3636 case AARCH64_OPND_BARRIER_PSB:
3637 snprintf (buf, size, "%s", opnd->hint_option->name);
3638 break;
3639
3640 default:
3641 assert (0);
3642 }
3643 }
3644 \f
3645 #define CPENC(op0,op1,crn,crm,op2) \
3646 ((((op0) << 19) | ((op1) << 16) | ((crn) << 12) | ((crm) << 8) | ((op2) << 5)) >> 5)
3647 /* for 3.9.3 Instructions for Accessing Special Purpose Registers */
3648 #define CPEN_(op1,crm,op2) CPENC(3,(op1),4,(crm),(op2))
3649 /* for 3.9.10 System Instructions */
3650 #define CPENS(op1,crn,crm,op2) CPENC(1,(op1),(crn),(crm),(op2))
3651
3652 #define C0 0
3653 #define C1 1
3654 #define C2 2
3655 #define C3 3
3656 #define C4 4
3657 #define C5 5
3658 #define C6 6
3659 #define C7 7
3660 #define C8 8
3661 #define C9 9
3662 #define C10 10
3663 #define C11 11
3664 #define C12 12
3665 #define C13 13
3666 #define C14 14
3667 #define C15 15
3668
3669 /* TODO there is one more issues need to be resolved
3670 1. handle cpu-implementation-defined system registers. */
3671 const aarch64_sys_reg aarch64_sys_regs [] =
3672 {
3673 { "spsr_el1", CPEN_(0,C0,0), 0 }, /* = spsr_svc */
3674 { "spsr_el12", CPEN_ (5, C0, 0), F_ARCHEXT },
3675 { "elr_el1", CPEN_(0,C0,1), 0 },
3676 { "elr_el12", CPEN_ (5, C0, 1), F_ARCHEXT },
3677 { "sp_el0", CPEN_(0,C1,0), 0 },
3678 { "spsel", CPEN_(0,C2,0), 0 },
3679 { "daif", CPEN_(3,C2,1), 0 },
3680 { "currentel", CPEN_(0,C2,2), F_REG_READ }, /* RO */
3681 { "pan", CPEN_(0,C2,3), F_ARCHEXT },
3682 { "uao", CPEN_ (0, C2, 4), F_ARCHEXT },
3683 { "nzcv", CPEN_(3,C2,0), 0 },
3684 { "fpcr", CPEN_(3,C4,0), 0 },
3685 { "fpsr", CPEN_(3,C4,1), 0 },
3686 { "dspsr_el0", CPEN_(3,C5,0), 0 },
3687 { "dlr_el0", CPEN_(3,C5,1), 0 },
3688 { "spsr_el2", CPEN_(4,C0,0), 0 }, /* = spsr_hyp */
3689 { "elr_el2", CPEN_(4,C0,1), 0 },
3690 { "sp_el1", CPEN_(4,C1,0), 0 },
3691 { "spsr_irq", CPEN_(4,C3,0), 0 },
3692 { "spsr_abt", CPEN_(4,C3,1), 0 },
3693 { "spsr_und", CPEN_(4,C3,2), 0 },
3694 { "spsr_fiq", CPEN_(4,C3,3), 0 },
3695 { "spsr_el3", CPEN_(6,C0,0), 0 },
3696 { "elr_el3", CPEN_(6,C0,1), 0 },
3697 { "sp_el2", CPEN_(6,C1,0), 0 },
3698 { "spsr_svc", CPEN_(0,C0,0), F_DEPRECATED }, /* = spsr_el1 */
3699 { "spsr_hyp", CPEN_(4,C0,0), F_DEPRECATED }, /* = spsr_el2 */
3700 { "midr_el1", CPENC(3,0,C0,C0,0), F_REG_READ }, /* RO */
3701 { "ctr_el0", CPENC(3,3,C0,C0,1), F_REG_READ }, /* RO */
3702 { "mpidr_el1", CPENC(3,0,C0,C0,5), F_REG_READ }, /* RO */
3703 { "revidr_el1", CPENC(3,0,C0,C0,6), F_REG_READ }, /* RO */
3704 { "aidr_el1", CPENC(3,1,C0,C0,7), F_REG_READ }, /* RO */
3705 { "dczid_el0", CPENC(3,3,C0,C0,7), F_REG_READ }, /* RO */
3706 { "id_dfr0_el1", CPENC(3,0,C0,C1,2), F_REG_READ }, /* RO */
3707 { "id_pfr0_el1", CPENC(3,0,C0,C1,0), F_REG_READ }, /* RO */
3708 { "id_pfr1_el1", CPENC(3,0,C0,C1,1), F_REG_READ }, /* RO */
3709 { "id_afr0_el1", CPENC(3,0,C0,C1,3), F_REG_READ }, /* RO */
3710 { "id_mmfr0_el1", CPENC(3,0,C0,C1,4), F_REG_READ }, /* RO */
3711 { "id_mmfr1_el1", CPENC(3,0,C0,C1,5), F_REG_READ }, /* RO */
3712 { "id_mmfr2_el1", CPENC(3,0,C0,C1,6), F_REG_READ }, /* RO */
3713 { "id_mmfr3_el1", CPENC(3,0,C0,C1,7), F_REG_READ }, /* RO */
3714 { "id_mmfr4_el1", CPENC(3,0,C0,C2,6), F_REG_READ }, /* RO */
3715 { "id_isar0_el1", CPENC(3,0,C0,C2,0), F_REG_READ }, /* RO */
3716 { "id_isar1_el1", CPENC(3,0,C0,C2,1), F_REG_READ }, /* RO */
3717 { "id_isar2_el1", CPENC(3,0,C0,C2,2), F_REG_READ }, /* RO */
3718 { "id_isar3_el1", CPENC(3,0,C0,C2,3), F_REG_READ }, /* RO */
3719 { "id_isar4_el1", CPENC(3,0,C0,C2,4), F_REG_READ }, /* RO */
3720 { "id_isar5_el1", CPENC(3,0,C0,C2,5), F_REG_READ }, /* RO */
3721 { "mvfr0_el1", CPENC(3,0,C0,C3,0), F_REG_READ }, /* RO */
3722 { "mvfr1_el1", CPENC(3,0,C0,C3,1), F_REG_READ }, /* RO */
3723 { "mvfr2_el1", CPENC(3,0,C0,C3,2), F_REG_READ }, /* RO */
3724 { "ccsidr_el1", CPENC(3,1,C0,C0,0), F_REG_READ }, /* RO */
3725 { "id_aa64pfr0_el1", CPENC(3,0,C0,C4,0), F_REG_READ }, /* RO */
3726 { "id_aa64pfr1_el1", CPENC(3,0,C0,C4,1), F_REG_READ }, /* RO */
3727 { "id_aa64dfr0_el1", CPENC(3,0,C0,C5,0), F_REG_READ }, /* RO */
3728 { "id_aa64dfr1_el1", CPENC(3,0,C0,C5,1), F_REG_READ }, /* RO */
3729 { "id_aa64isar0_el1", CPENC(3,0,C0,C6,0), F_REG_READ }, /* RO */
3730 { "id_aa64isar1_el1", CPENC(3,0,C0,C6,1), F_REG_READ }, /* RO */
3731 { "id_aa64mmfr0_el1", CPENC(3,0,C0,C7,0), F_REG_READ }, /* RO */
3732 { "id_aa64mmfr1_el1", CPENC(3,0,C0,C7,1), F_REG_READ }, /* RO */
3733 { "id_aa64mmfr2_el1", CPENC (3, 0, C0, C7, 2), F_ARCHEXT | F_REG_READ }, /* RO */
3734 { "id_aa64afr0_el1", CPENC(3,0,C0,C5,4), F_REG_READ }, /* RO */
3735 { "id_aa64afr1_el1", CPENC(3,0,C0,C5,5), F_REG_READ }, /* RO */
3736 { "id_aa64zfr0_el1", CPENC (3, 0, C0, C4, 4), F_ARCHEXT | F_REG_READ }, /* RO */
3737 { "clidr_el1", CPENC(3,1,C0,C0,1), F_REG_READ }, /* RO */
3738 { "csselr_el1", CPENC(3,2,C0,C0,0), F_REG_READ }, /* RO */
3739 { "vpidr_el2", CPENC(3,4,C0,C0,0), 0 },
3740 { "vmpidr_el2", CPENC(3,4,C0,C0,5), 0 },
3741 { "sctlr_el1", CPENC(3,0,C1,C0,0), 0 },
3742 { "sctlr_el2", CPENC(3,4,C1,C0,0), 0 },
3743 { "sctlr_el3", CPENC(3,6,C1,C0,0), 0 },
3744 { "sctlr_el12", CPENC (3, 5, C1, C0, 0), F_ARCHEXT },
3745 { "actlr_el1", CPENC(3,0,C1,C0,1), 0 },
3746 { "actlr_el2", CPENC(3,4,C1,C0,1), 0 },
3747 { "actlr_el3", CPENC(3,6,C1,C0,1), 0 },
3748 { "cpacr_el1", CPENC(3,0,C1,C0,2), 0 },
3749 { "cpacr_el12", CPENC (3, 5, C1, C0, 2), F_ARCHEXT },
3750 { "cptr_el2", CPENC(3,4,C1,C1,2), 0 },
3751 { "cptr_el3", CPENC(3,6,C1,C1,2), 0 },
3752 { "scr_el3", CPENC(3,6,C1,C1,0), 0 },
3753 { "hcr_el2", CPENC(3,4,C1,C1,0), 0 },
3754 { "mdcr_el2", CPENC(3,4,C1,C1,1), 0 },
3755 { "mdcr_el3", CPENC(3,6,C1,C3,1), 0 },
3756 { "hstr_el2", CPENC(3,4,C1,C1,3), 0 },
3757 { "hacr_el2", CPENC(3,4,C1,C1,7), 0 },
3758 { "zcr_el1", CPENC (3, 0, C1, C2, 0), F_ARCHEXT },
3759 { "zcr_el12", CPENC (3, 5, C1, C2, 0), F_ARCHEXT },
3760 { "zcr_el2", CPENC (3, 4, C1, C2, 0), F_ARCHEXT },
3761 { "zcr_el3", CPENC (3, 6, C1, C2, 0), F_ARCHEXT },
3762 { "zidr_el1", CPENC (3, 0, C0, C0, 7), F_ARCHEXT },
3763 { "ttbr0_el1", CPENC(3,0,C2,C0,0), 0 },
3764 { "ttbr1_el1", CPENC(3,0,C2,C0,1), 0 },
3765 { "ttbr0_el2", CPENC(3,4,C2,C0,0), 0 },
3766 { "ttbr1_el2", CPENC (3, 4, C2, C0, 1), F_ARCHEXT },
3767 { "ttbr0_el3", CPENC(3,6,C2,C0,0), 0 },
3768 { "ttbr0_el12", CPENC (3, 5, C2, C0, 0), F_ARCHEXT },
3769 { "ttbr1_el12", CPENC (3, 5, C2, C0, 1), F_ARCHEXT },
3770 { "vttbr_el2", CPENC(3,4,C2,C1,0), 0 },
3771 { "tcr_el1", CPENC(3,0,C2,C0,2), 0 },
3772 { "tcr_el2", CPENC(3,4,C2,C0,2), 0 },
3773 { "tcr_el3", CPENC(3,6,C2,C0,2), 0 },
3774 { "tcr_el12", CPENC (3, 5, C2, C0, 2), F_ARCHEXT },
3775 { "vtcr_el2", CPENC(3,4,C2,C1,2), 0 },
3776 { "apiakeylo_el1", CPENC (3, 0, C2, C1, 0), F_ARCHEXT },
3777 { "apiakeyhi_el1", CPENC (3, 0, C2, C1, 1), F_ARCHEXT },
3778 { "apibkeylo_el1", CPENC (3, 0, C2, C1, 2), F_ARCHEXT },
3779 { "apibkeyhi_el1", CPENC (3, 0, C2, C1, 3), F_ARCHEXT },
3780 { "apdakeylo_el1", CPENC (3, 0, C2, C2, 0), F_ARCHEXT },
3781 { "apdakeyhi_el1", CPENC (3, 0, C2, C2, 1), F_ARCHEXT },
3782 { "apdbkeylo_el1", CPENC (3, 0, C2, C2, 2), F_ARCHEXT },
3783 { "apdbkeyhi_el1", CPENC (3, 0, C2, C2, 3), F_ARCHEXT },
3784 { "apgakeylo_el1", CPENC (3, 0, C2, C3, 0), F_ARCHEXT },
3785 { "apgakeyhi_el1", CPENC (3, 0, C2, C3, 1), F_ARCHEXT },
3786 { "afsr0_el1", CPENC(3,0,C5,C1,0), 0 },
3787 { "afsr1_el1", CPENC(3,0,C5,C1,1), 0 },
3788 { "afsr0_el2", CPENC(3,4,C5,C1,0), 0 },
3789 { "afsr1_el2", CPENC(3,4,C5,C1,1), 0 },
3790 { "afsr0_el3", CPENC(3,6,C5,C1,0), 0 },
3791 { "afsr0_el12", CPENC (3, 5, C5, C1, 0), F_ARCHEXT },
3792 { "afsr1_el3", CPENC(3,6,C5,C1,1), 0 },
3793 { "afsr1_el12", CPENC (3, 5, C5, C1, 1), F_ARCHEXT },
3794 { "esr_el1", CPENC(3,0,C5,C2,0), 0 },
3795 { "esr_el2", CPENC(3,4,C5,C2,0), 0 },
3796 { "esr_el3", CPENC(3,6,C5,C2,0), 0 },
3797 { "esr_el12", CPENC (3, 5, C5, C2, 0), F_ARCHEXT },
3798 { "vsesr_el2", CPENC (3, 4, C5, C2, 3), F_ARCHEXT | F_REG_READ }, /* RO */
3799 { "fpexc32_el2", CPENC(3,4,C5,C3,0), 0 },
3800 { "erridr_el1", CPENC (3, 0, C5, C3, 0), F_ARCHEXT | F_REG_READ }, /* RO */
3801 { "errselr_el1", CPENC (3, 0, C5, C3, 1), F_ARCHEXT },
3802 { "erxfr_el1", CPENC (3, 0, C5, C4, 0), F_ARCHEXT | F_REG_READ }, /* RO */
3803 { "erxctlr_el1", CPENC (3, 0, C5, C4, 1), F_ARCHEXT },
3804 { "erxstatus_el1", CPENC (3, 0, C5, C4, 2), F_ARCHEXT },
3805 { "erxaddr_el1", CPENC (3, 0, C5, C4, 3), F_ARCHEXT },
3806 { "erxmisc0_el1", CPENC (3, 0, C5, C5, 0), F_ARCHEXT },
3807 { "erxmisc1_el1", CPENC (3, 0, C5, C5, 1), F_ARCHEXT },
3808 { "far_el1", CPENC(3,0,C6,C0,0), 0 },
3809 { "far_el2", CPENC(3,4,C6,C0,0), 0 },
3810 { "far_el3", CPENC(3,6,C6,C0,0), 0 },
3811 { "far_el12", CPENC (3, 5, C6, C0, 0), F_ARCHEXT },
3812 { "hpfar_el2", CPENC(3,4,C6,C0,4), 0 },
3813 { "par_el1", CPENC(3,0,C7,C4,0), 0 },
3814 { "mair_el1", CPENC(3,0,C10,C2,0), 0 },
3815 { "mair_el2", CPENC(3,4,C10,C2,0), 0 },
3816 { "mair_el3", CPENC(3,6,C10,C2,0), 0 },
3817 { "mair_el12", CPENC (3, 5, C10, C2, 0), F_ARCHEXT },
3818 { "amair_el1", CPENC(3,0,C10,C3,0), 0 },
3819 { "amair_el2", CPENC(3,4,C10,C3,0), 0 },
3820 { "amair_el3", CPENC(3,6,C10,C3,0), 0 },
3821 { "amair_el12", CPENC (3, 5, C10, C3, 0), F_ARCHEXT },
3822 { "vbar_el1", CPENC(3,0,C12,C0,0), 0 },
3823 { "vbar_el2", CPENC(3,4,C12,C0,0), 0 },
3824 { "vbar_el3", CPENC(3,6,C12,C0,0), 0 },
3825 { "vbar_el12", CPENC (3, 5, C12, C0, 0), F_ARCHEXT },
3826 { "rvbar_el1", CPENC(3,0,C12,C0,1), F_REG_READ }, /* RO */
3827 { "rvbar_el2", CPENC(3,4,C12,C0,1), F_REG_READ }, /* RO */
3828 { "rvbar_el3", CPENC(3,6,C12,C0,1), F_REG_READ }, /* RO */
3829 { "rmr_el1", CPENC(3,0,C12,C0,2), 0 },
3830 { "rmr_el2", CPENC(3,4,C12,C0,2), 0 },
3831 { "rmr_el3", CPENC(3,6,C12,C0,2), 0 },
3832 { "isr_el1", CPENC(3,0,C12,C1,0), F_REG_READ }, /* RO */
3833 { "disr_el1", CPENC (3, 0, C12, C1, 1), F_ARCHEXT },
3834 { "vdisr_el2", CPENC (3, 4, C12, C1, 1), F_ARCHEXT },
3835 { "contextidr_el1", CPENC(3,0,C13,C0,1), 0 },
3836 { "contextidr_el2", CPENC (3, 4, C13, C0, 1), F_ARCHEXT },
3837 { "contextidr_el12", CPENC (3, 5, C13, C0, 1), F_ARCHEXT },
3838 { "tpidr_el0", CPENC(3,3,C13,C0,2), 0 },
3839 { "tpidrro_el0", CPENC(3,3,C13,C0,3), 0 }, /* RW */
3840 { "tpidr_el1", CPENC(3,0,C13,C0,4), 0 },
3841 { "tpidr_el2", CPENC(3,4,C13,C0,2), 0 },
3842 { "tpidr_el3", CPENC(3,6,C13,C0,2), 0 },
3843 { "teecr32_el1", CPENC(2,2,C0, C0,0), 0 }, /* See section 3.9.7.1 */
3844 { "cntfrq_el0", CPENC(3,3,C14,C0,0), 0 }, /* RW */
3845 { "cntpct_el0", CPENC(3,3,C14,C0,1), F_REG_READ }, /* RO */
3846 { "cntvct_el0", CPENC(3,3,C14,C0,2), F_REG_READ }, /* RO */
3847 { "cntvoff_el2", CPENC(3,4,C14,C0,3), 0 },
3848 { "cntkctl_el1", CPENC(3,0,C14,C1,0), 0 },
3849 { "cntkctl_el12", CPENC (3, 5, C14, C1, 0), F_ARCHEXT },
3850 { "cnthctl_el2", CPENC(3,4,C14,C1,0), 0 },
3851 { "cntp_tval_el0", CPENC(3,3,C14,C2,0), 0 },
3852 { "cntp_tval_el02", CPENC (3, 5, C14, C2, 0), F_ARCHEXT },
3853 { "cntp_ctl_el0", CPENC(3,3,C14,C2,1), 0 },
3854 { "cntp_ctl_el02", CPENC (3, 5, C14, C2, 1), F_ARCHEXT },
3855 { "cntp_cval_el0", CPENC(3,3,C14,C2,2), 0 },
3856 { "cntp_cval_el02", CPENC (3, 5, C14, C2, 2), F_ARCHEXT },
3857 { "cntv_tval_el0", CPENC(3,3,C14,C3,0), 0 },
3858 { "cntv_tval_el02", CPENC (3, 5, C14, C3, 0), F_ARCHEXT },
3859 { "cntv_ctl_el0", CPENC(3,3,C14,C3,1), 0 },
3860 { "cntv_ctl_el02", CPENC (3, 5, C14, C3, 1), F_ARCHEXT },
3861 { "cntv_cval_el0", CPENC(3,3,C14,C3,2), 0 },
3862 { "cntv_cval_el02", CPENC (3, 5, C14, C3, 2), F_ARCHEXT },
3863 { "cnthp_tval_el2", CPENC(3,4,C14,C2,0), 0 },
3864 { "cnthp_ctl_el2", CPENC(3,4,C14,C2,1), 0 },
3865 { "cnthp_cval_el2", CPENC(3,4,C14,C2,2), 0 },
3866 { "cntps_tval_el1", CPENC(3,7,C14,C2,0), 0 },
3867 { "cntps_ctl_el1", CPENC(3,7,C14,C2,1), 0 },
3868 { "cntps_cval_el1", CPENC(3,7,C14,C2,2), 0 },
3869 { "cnthv_tval_el2", CPENC (3, 4, C14, C3, 0), F_ARCHEXT },
3870 { "cnthv_ctl_el2", CPENC (3, 4, C14, C3, 1), F_ARCHEXT },
3871 { "cnthv_cval_el2", CPENC (3, 4, C14, C3, 2), F_ARCHEXT },
3872 { "dacr32_el2", CPENC(3,4,C3,C0,0), 0 },
3873 { "ifsr32_el2", CPENC(3,4,C5,C0,1), 0 },
3874 { "teehbr32_el1", CPENC(2,2,C1,C0,0), 0 },
3875 { "sder32_el3", CPENC(3,6,C1,C1,1), 0 },
3876 { "mdscr_el1", CPENC(2,0,C0, C2, 2), 0 },
3877 { "mdccsr_el0", CPENC(2,3,C0, C1, 0), F_REG_READ }, /* r */
3878 { "mdccint_el1", CPENC(2,0,C0, C2, 0), 0 },
3879 { "dbgdtr_el0", CPENC(2,3,C0, C4, 0), 0 },
3880 { "dbgdtrrx_el0", CPENC(2,3,C0, C5, 0), F_REG_READ }, /* r */
3881 { "dbgdtrtx_el0", CPENC(2,3,C0, C5, 0), F_REG_WRITE }, /* w */
3882 { "osdtrrx_el1", CPENC(2,0,C0, C0, 2), F_REG_READ }, /* r */
3883 { "osdtrtx_el1", CPENC(2,0,C0, C3, 2), F_REG_WRITE }, /* w */
3884 { "oseccr_el1", CPENC(2,0,C0, C6, 2), 0 },
3885 { "dbgvcr32_el2", CPENC(2,4,C0, C7, 0), 0 },
3886 { "dbgbvr0_el1", CPENC(2,0,C0, C0, 4), 0 },
3887 { "dbgbvr1_el1", CPENC(2,0,C0, C1, 4), 0 },
3888 { "dbgbvr2_el1", CPENC(2,0,C0, C2, 4), 0 },
3889 { "dbgbvr3_el1", CPENC(2,0,C0, C3, 4), 0 },
3890 { "dbgbvr4_el1", CPENC(2,0,C0, C4, 4), 0 },
3891 { "dbgbvr5_el1", CPENC(2,0,C0, C5, 4), 0 },
3892 { "dbgbvr6_el1", CPENC(2,0,C0, C6, 4), 0 },
3893 { "dbgbvr7_el1", CPENC(2,0,C0, C7, 4), 0 },
3894 { "dbgbvr8_el1", CPENC(2,0,C0, C8, 4), 0 },
3895 { "dbgbvr9_el1", CPENC(2,0,C0, C9, 4), 0 },
3896 { "dbgbvr10_el1", CPENC(2,0,C0, C10,4), 0 },
3897 { "dbgbvr11_el1", CPENC(2,0,C0, C11,4), 0 },
3898 { "dbgbvr12_el1", CPENC(2,0,C0, C12,4), 0 },
3899 { "dbgbvr13_el1", CPENC(2,0,C0, C13,4), 0 },
3900 { "dbgbvr14_el1", CPENC(2,0,C0, C14,4), 0 },
3901 { "dbgbvr15_el1", CPENC(2,0,C0, C15,4), 0 },
3902 { "dbgbcr0_el1", CPENC(2,0,C0, C0, 5), 0 },
3903 { "dbgbcr1_el1", CPENC(2,0,C0, C1, 5), 0 },
3904 { "dbgbcr2_el1", CPENC(2,0,C0, C2, 5), 0 },
3905 { "dbgbcr3_el1", CPENC(2,0,C0, C3, 5), 0 },
3906 { "dbgbcr4_el1", CPENC(2,0,C0, C4, 5), 0 },
3907 { "dbgbcr5_el1", CPENC(2,0,C0, C5, 5), 0 },
3908 { "dbgbcr6_el1", CPENC(2,0,C0, C6, 5), 0 },
3909 { "dbgbcr7_el1", CPENC(2,0,C0, C7, 5), 0 },
3910 { "dbgbcr8_el1", CPENC(2,0,C0, C8, 5), 0 },
3911 { "dbgbcr9_el1", CPENC(2,0,C0, C9, 5), 0 },
3912 { "dbgbcr10_el1", CPENC(2,0,C0, C10,5), 0 },
3913 { "dbgbcr11_el1", CPENC(2,0,C0, C11,5), 0 },
3914 { "dbgbcr12_el1", CPENC(2,0,C0, C12,5), 0 },
3915 { "dbgbcr13_el1", CPENC(2,0,C0, C13,5), 0 },
3916 { "dbgbcr14_el1", CPENC(2,0,C0, C14,5), 0 },
3917 { "dbgbcr15_el1", CPENC(2,0,C0, C15,5), 0 },
3918 { "dbgwvr0_el1", CPENC(2,0,C0, C0, 6), 0 },
3919 { "dbgwvr1_el1", CPENC(2,0,C0, C1, 6), 0 },
3920 { "dbgwvr2_el1", CPENC(2,0,C0, C2, 6), 0 },
3921 { "dbgwvr3_el1", CPENC(2,0,C0, C3, 6), 0 },
3922 { "dbgwvr4_el1", CPENC(2,0,C0, C4, 6), 0 },
3923 { "dbgwvr5_el1", CPENC(2,0,C0, C5, 6), 0 },
3924 { "dbgwvr6_el1", CPENC(2,0,C0, C6, 6), 0 },
3925 { "dbgwvr7_el1", CPENC(2,0,C0, C7, 6), 0 },
3926 { "dbgwvr8_el1", CPENC(2,0,C0, C8, 6), 0 },
3927 { "dbgwvr9_el1", CPENC(2,0,C0, C9, 6), 0 },
3928 { "dbgwvr10_el1", CPENC(2,0,C0, C10,6), 0 },
3929 { "dbgwvr11_el1", CPENC(2,0,C0, C11,6), 0 },
3930 { "dbgwvr12_el1", CPENC(2,0,C0, C12,6), 0 },
3931 { "dbgwvr13_el1", CPENC(2,0,C0, C13,6), 0 },
3932 { "dbgwvr14_el1", CPENC(2,0,C0, C14,6), 0 },
3933 { "dbgwvr15_el1", CPENC(2,0,C0, C15,6), 0 },
3934 { "dbgwcr0_el1", CPENC(2,0,C0, C0, 7), 0 },
3935 { "dbgwcr1_el1", CPENC(2,0,C0, C1, 7), 0 },
3936 { "dbgwcr2_el1", CPENC(2,0,C0, C2, 7), 0 },
3937 { "dbgwcr3_el1", CPENC(2,0,C0, C3, 7), 0 },
3938 { "dbgwcr4_el1", CPENC(2,0,C0, C4, 7), 0 },
3939 { "dbgwcr5_el1", CPENC(2,0,C0, C5, 7), 0 },
3940 { "dbgwcr6_el1", CPENC(2,0,C0, C6, 7), 0 },
3941 { "dbgwcr7_el1", CPENC(2,0,C0, C7, 7), 0 },
3942 { "dbgwcr8_el1", CPENC(2,0,C0, C8, 7), 0 },
3943 { "dbgwcr9_el1", CPENC(2,0,C0, C9, 7), 0 },
3944 { "dbgwcr10_el1", CPENC(2,0,C0, C10,7), 0 },
3945 { "dbgwcr11_el1", CPENC(2,0,C0, C11,7), 0 },
3946 { "dbgwcr12_el1", CPENC(2,0,C0, C12,7), 0 },
3947 { "dbgwcr13_el1", CPENC(2,0,C0, C13,7), 0 },
3948 { "dbgwcr14_el1", CPENC(2,0,C0, C14,7), 0 },
3949 { "dbgwcr15_el1", CPENC(2,0,C0, C15,7), 0 },
3950 { "mdrar_el1", CPENC(2,0,C1, C0, 0), F_REG_READ }, /* r */
3951 { "oslar_el1", CPENC(2,0,C1, C0, 4), F_REG_WRITE }, /* w */
3952 { "oslsr_el1", CPENC(2,0,C1, C1, 4), F_REG_READ }, /* r */
3953 { "osdlr_el1", CPENC(2,0,C1, C3, 4), 0 },
3954 { "dbgprcr_el1", CPENC(2,0,C1, C4, 4), 0 },
3955 { "dbgclaimset_el1", CPENC(2,0,C7, C8, 6), 0 },
3956 { "dbgclaimclr_el1", CPENC(2,0,C7, C9, 6), 0 },
3957 { "dbgauthstatus_el1", CPENC(2,0,C7, C14,6), F_REG_READ }, /* r */
3958 { "pmblimitr_el1", CPENC (3, 0, C9, C10, 0), F_ARCHEXT }, /* rw */
3959 { "pmbptr_el1", CPENC (3, 0, C9, C10, 1), F_ARCHEXT }, /* rw */
3960 { "pmbsr_el1", CPENC (3, 0, C9, C10, 3), F_ARCHEXT }, /* rw */
3961 { "pmbidr_el1", CPENC (3, 0, C9, C10, 7), F_ARCHEXT | F_REG_READ }, /* ro */
3962 { "pmscr_el1", CPENC (3, 0, C9, C9, 0), F_ARCHEXT }, /* rw */
3963 { "pmsicr_el1", CPENC (3, 0, C9, C9, 2), F_ARCHEXT }, /* rw */
3964 { "pmsirr_el1", CPENC (3, 0, C9, C9, 3), F_ARCHEXT }, /* rw */
3965 { "pmsfcr_el1", CPENC (3, 0, C9, C9, 4), F_ARCHEXT }, /* rw */
3966 { "pmsevfr_el1", CPENC (3, 0, C9, C9, 5), F_ARCHEXT }, /* rw */
3967 { "pmslatfr_el1", CPENC (3, 0, C9, C9, 6), F_ARCHEXT }, /* rw */
3968 { "pmsidr_el1", CPENC (3, 0, C9, C9, 7), F_ARCHEXT | F_REG_READ }, /* ro */
3969 { "pmscr_el2", CPENC (3, 4, C9, C9, 0), F_ARCHEXT }, /* rw */
3970 { "pmscr_el12", CPENC (3, 5, C9, C9, 0), F_ARCHEXT }, /* rw */
3971 { "pmcr_el0", CPENC(3,3,C9,C12, 0), 0 },
3972 { "pmcntenset_el0", CPENC(3,3,C9,C12, 1), 0 },
3973 { "pmcntenclr_el0", CPENC(3,3,C9,C12, 2), 0 },
3974 { "pmovsclr_el0", CPENC(3,3,C9,C12, 3), 0 },
3975 { "pmswinc_el0", CPENC(3,3,C9,C12, 4), F_REG_WRITE }, /* w */
3976 { "pmselr_el0", CPENC(3,3,C9,C12, 5), 0 },
3977 { "pmceid0_el0", CPENC(3,3,C9,C12, 6), F_REG_READ }, /* r */
3978 { "pmceid1_el0", CPENC(3,3,C9,C12, 7), F_REG_READ }, /* r */
3979 { "pmccntr_el0", CPENC(3,3,C9,C13, 0), 0 },
3980 { "pmxevtyper_el0", CPENC(3,3,C9,C13, 1), 0 },
3981 { "pmxevcntr_el0", CPENC(3,3,C9,C13, 2), 0 },
3982 { "pmuserenr_el0", CPENC(3,3,C9,C14, 0), 0 },
3983 { "pmintenset_el1", CPENC(3,0,C9,C14, 1), 0 },
3984 { "pmintenclr_el1", CPENC(3,0,C9,C14, 2), 0 },
3985 { "pmovsset_el0", CPENC(3,3,C9,C14, 3), 0 },
3986 { "pmevcntr0_el0", CPENC(3,3,C14,C8, 0), 0 },
3987 { "pmevcntr1_el0", CPENC(3,3,C14,C8, 1), 0 },
3988 { "pmevcntr2_el0", CPENC(3,3,C14,C8, 2), 0 },
3989 { "pmevcntr3_el0", CPENC(3,3,C14,C8, 3), 0 },
3990 { "pmevcntr4_el0", CPENC(3,3,C14,C8, 4), 0 },
3991 { "pmevcntr5_el0", CPENC(3,3,C14,C8, 5), 0 },
3992 { "pmevcntr6_el0", CPENC(3,3,C14,C8, 6), 0 },
3993 { "pmevcntr7_el0", CPENC(3,3,C14,C8, 7), 0 },
3994 { "pmevcntr8_el0", CPENC(3,3,C14,C9, 0), 0 },
3995 { "pmevcntr9_el0", CPENC(3,3,C14,C9, 1), 0 },
3996 { "pmevcntr10_el0", CPENC(3,3,C14,C9, 2), 0 },
3997 { "pmevcntr11_el0", CPENC(3,3,C14,C9, 3), 0 },
3998 { "pmevcntr12_el0", CPENC(3,3,C14,C9, 4), 0 },
3999 { "pmevcntr13_el0", CPENC(3,3,C14,C9, 5), 0 },
4000 { "pmevcntr14_el0", CPENC(3,3,C14,C9, 6), 0 },
4001 { "pmevcntr15_el0", CPENC(3,3,C14,C9, 7), 0 },
4002 { "pmevcntr16_el0", CPENC(3,3,C14,C10,0), 0 },
4003 { "pmevcntr17_el0", CPENC(3,3,C14,C10,1), 0 },
4004 { "pmevcntr18_el0", CPENC(3,3,C14,C10,2), 0 },
4005 { "pmevcntr19_el0", CPENC(3,3,C14,C10,3), 0 },
4006 { "pmevcntr20_el0", CPENC(3,3,C14,C10,4), 0 },
4007 { "pmevcntr21_el0", CPENC(3,3,C14,C10,5), 0 },
4008 { "pmevcntr22_el0", CPENC(3,3,C14,C10,6), 0 },
4009 { "pmevcntr23_el0", CPENC(3,3,C14,C10,7), 0 },
4010 { "pmevcntr24_el0", CPENC(3,3,C14,C11,0), 0 },
4011 { "pmevcntr25_el0", CPENC(3,3,C14,C11,1), 0 },
4012 { "pmevcntr26_el0", CPENC(3,3,C14,C11,2), 0 },
4013 { "pmevcntr27_el0", CPENC(3,3,C14,C11,3), 0 },
4014 { "pmevcntr28_el0", CPENC(3,3,C14,C11,4), 0 },
4015 { "pmevcntr29_el0", CPENC(3,3,C14,C11,5), 0 },
4016 { "pmevcntr30_el0", CPENC(3,3,C14,C11,6), 0 },
4017 { "pmevtyper0_el0", CPENC(3,3,C14,C12,0), 0 },
4018 { "pmevtyper1_el0", CPENC(3,3,C14,C12,1), 0 },
4019 { "pmevtyper2_el0", CPENC(3,3,C14,C12,2), 0 },
4020 { "pmevtyper3_el0", CPENC(3,3,C14,C12,3), 0 },
4021 { "pmevtyper4_el0", CPENC(3,3,C14,C12,4), 0 },
4022 { "pmevtyper5_el0", CPENC(3,3,C14,C12,5), 0 },
4023 { "pmevtyper6_el0", CPENC(3,3,C14,C12,6), 0 },
4024 { "pmevtyper7_el0", CPENC(3,3,C14,C12,7), 0 },
4025 { "pmevtyper8_el0", CPENC(3,3,C14,C13,0), 0 },
4026 { "pmevtyper9_el0", CPENC(3,3,C14,C13,1), 0 },
4027 { "pmevtyper10_el0", CPENC(3,3,C14,C13,2), 0 },
4028 { "pmevtyper11_el0", CPENC(3,3,C14,C13,3), 0 },
4029 { "pmevtyper12_el0", CPENC(3,3,C14,C13,4), 0 },
4030 { "pmevtyper13_el0", CPENC(3,3,C14,C13,5), 0 },
4031 { "pmevtyper14_el0", CPENC(3,3,C14,C13,6), 0 },
4032 { "pmevtyper15_el0", CPENC(3,3,C14,C13,7), 0 },
4033 { "pmevtyper16_el0", CPENC(3,3,C14,C14,0), 0 },
4034 { "pmevtyper17_el0", CPENC(3,3,C14,C14,1), 0 },
4035 { "pmevtyper18_el0", CPENC(3,3,C14,C14,2), 0 },
4036 { "pmevtyper19_el0", CPENC(3,3,C14,C14,3), 0 },
4037 { "pmevtyper20_el0", CPENC(3,3,C14,C14,4), 0 },
4038 { "pmevtyper21_el0", CPENC(3,3,C14,C14,5), 0 },
4039 { "pmevtyper22_el0", CPENC(3,3,C14,C14,6), 0 },
4040 { "pmevtyper23_el0", CPENC(3,3,C14,C14,7), 0 },
4041 { "pmevtyper24_el0", CPENC(3,3,C14,C15,0), 0 },
4042 { "pmevtyper25_el0", CPENC(3,3,C14,C15,1), 0 },
4043 { "pmevtyper26_el0", CPENC(3,3,C14,C15,2), 0 },
4044 { "pmevtyper27_el0", CPENC(3,3,C14,C15,3), 0 },
4045 { "pmevtyper28_el0", CPENC(3,3,C14,C15,4), 0 },
4046 { "pmevtyper29_el0", CPENC(3,3,C14,C15,5), 0 },
4047 { "pmevtyper30_el0", CPENC(3,3,C14,C15,6), 0 },
4048 { "pmccfiltr_el0", CPENC(3,3,C14,C15,7), 0 },
4049
4050 { "dit", CPEN_ (3, C2, 5), F_ARCHEXT },
4051 { "vstcr_el2", CPENC(3, 4, C2, C6, 2), F_ARCHEXT },
4052 { "vsttbr_el2", CPENC(3, 4, C2, C6, 0), F_ARCHEXT },
4053 { "cnthvs_tval_el2", CPENC(3, 4, C14, C4, 0), F_ARCHEXT },
4054 { "cnthvs_cval_el2", CPENC(3, 4, C14, C4, 2), F_ARCHEXT },
4055 { "cnthvs_ctl_el2", CPENC(3, 4, C14, C4, 1), F_ARCHEXT },
4056 { "cnthps_tval_el2", CPENC(3, 4, C14, C5, 0), F_ARCHEXT },
4057 { "cnthps_cval_el2", CPENC(3, 4, C14, C5, 2), F_ARCHEXT },
4058 { "cnthps_ctl_el2", CPENC(3, 4, C14, C5, 1), F_ARCHEXT },
4059 { "sder32_el2", CPENC(3, 4, C1, C3, 1), F_ARCHEXT },
4060 { "vncr_el2", CPENC(3, 4, C2, C2, 0), F_ARCHEXT },
4061 { 0, CPENC(0,0,0,0,0), 0 },
4062 };
4063
4064 bfd_boolean
4065 aarch64_sys_reg_deprecated_p (const aarch64_sys_reg *reg)
4066 {
4067 return (reg->flags & F_DEPRECATED) != 0;
4068 }
4069
4070 bfd_boolean
4071 aarch64_sys_reg_supported_p (const aarch64_feature_set features,
4072 const aarch64_sys_reg *reg)
4073 {
4074 if (!(reg->flags & F_ARCHEXT))
4075 return TRUE;
4076
4077 /* PAN. Values are from aarch64_sys_regs. */
4078 if (reg->value == CPEN_(0,C2,3)
4079 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_PAN))
4080 return FALSE;
4081
4082 /* Virtualization host extensions: system registers. */
4083 if ((reg->value == CPENC (3, 4, C2, C0, 1)
4084 || reg->value == CPENC (3, 4, C13, C0, 1)
4085 || reg->value == CPENC (3, 4, C14, C3, 0)
4086 || reg->value == CPENC (3, 4, C14, C3, 1)
4087 || reg->value == CPENC (3, 4, C14, C3, 2))
4088 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_1))
4089 return FALSE;
4090
4091 /* Virtualization host extensions: *_el12 names of *_el1 registers. */
4092 if ((reg->value == CPEN_ (5, C0, 0)
4093 || reg->value == CPEN_ (5, C0, 1)
4094 || reg->value == CPENC (3, 5, C1, C0, 0)
4095 || reg->value == CPENC (3, 5, C1, C0, 2)
4096 || reg->value == CPENC (3, 5, C2, C0, 0)
4097 || reg->value == CPENC (3, 5, C2, C0, 1)
4098 || reg->value == CPENC (3, 5, C2, C0, 2)
4099 || reg->value == CPENC (3, 5, C5, C1, 0)
4100 || reg->value == CPENC (3, 5, C5, C1, 1)
4101 || reg->value == CPENC (3, 5, C5, C2, 0)
4102 || reg->value == CPENC (3, 5, C6, C0, 0)
4103 || reg->value == CPENC (3, 5, C10, C2, 0)
4104 || reg->value == CPENC (3, 5, C10, C3, 0)
4105 || reg->value == CPENC (3, 5, C12, C0, 0)
4106 || reg->value == CPENC (3, 5, C13, C0, 1)
4107 || reg->value == CPENC (3, 5, C14, C1, 0))
4108 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_1))
4109 return FALSE;
4110
4111 /* Virtualization host extensions: *_el02 names of *_el0 registers. */
4112 if ((reg->value == CPENC (3, 5, C14, C2, 0)
4113 || reg->value == CPENC (3, 5, C14, C2, 1)
4114 || reg->value == CPENC (3, 5, C14, C2, 2)
4115 || reg->value == CPENC (3, 5, C14, C3, 0)
4116 || reg->value == CPENC (3, 5, C14, C3, 1)
4117 || reg->value == CPENC (3, 5, C14, C3, 2))
4118 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_1))
4119 return FALSE;
4120
4121 /* ARMv8.2 features. */
4122
4123 /* ID_AA64MMFR2_EL1. */
4124 if (reg->value == CPENC (3, 0, C0, C7, 2)
4125 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_2))
4126 return FALSE;
4127
4128 /* PSTATE.UAO. */
4129 if (reg->value == CPEN_ (0, C2, 4)
4130 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_2))
4131 return FALSE;
4132
4133 /* RAS extension. */
4134
4135 /* ERRIDR_EL1, ERRSELR_EL1, ERXFR_EL1, ERXCTLR_EL1, ERXSTATUS_EL, ERXADDR_EL1,
4136 ERXMISC0_EL1 AND ERXMISC1_EL1. */
4137 if ((reg->value == CPENC (3, 0, C5, C3, 0)
4138 || reg->value == CPENC (3, 0, C5, C3, 1)
4139 || reg->value == CPENC (3, 0, C5, C3, 2)
4140 || reg->value == CPENC (3, 0, C5, C3, 3)
4141 || reg->value == CPENC (3, 0, C5, C4, 0)
4142 || reg->value == CPENC (3, 0, C5, C4, 1)
4143 || reg->value == CPENC (3, 0, C5, C4, 2)
4144 || reg->value == CPENC (3, 0, C5, C4, 3)
4145 || reg->value == CPENC (3, 0, C5, C5, 0)
4146 || reg->value == CPENC (3, 0, C5, C5, 1))
4147 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_RAS))
4148 return FALSE;
4149
4150 /* VSESR_EL2, DISR_EL1 and VDISR_EL2. */
4151 if ((reg->value == CPENC (3, 4, C5, C2, 3)
4152 || reg->value == CPENC (3, 0, C12, C1, 1)
4153 || reg->value == CPENC (3, 4, C12, C1, 1))
4154 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_RAS))
4155 return FALSE;
4156
4157 /* Statistical Profiling extension. */
4158 if ((reg->value == CPENC (3, 0, C9, C10, 0)
4159 || reg->value == CPENC (3, 0, C9, C10, 1)
4160 || reg->value == CPENC (3, 0, C9, C10, 3)
4161 || reg->value == CPENC (3, 0, C9, C10, 7)
4162 || reg->value == CPENC (3, 0, C9, C9, 0)
4163 || reg->value == CPENC (3, 0, C9, C9, 2)
4164 || reg->value == CPENC (3, 0, C9, C9, 3)
4165 || reg->value == CPENC (3, 0, C9, C9, 4)
4166 || reg->value == CPENC (3, 0, C9, C9, 5)
4167 || reg->value == CPENC (3, 0, C9, C9, 6)
4168 || reg->value == CPENC (3, 0, C9, C9, 7)
4169 || reg->value == CPENC (3, 4, C9, C9, 0)
4170 || reg->value == CPENC (3, 5, C9, C9, 0))
4171 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_PROFILE))
4172 return FALSE;
4173
4174 /* ARMv8.3 Pointer authentication keys. */
4175 if ((reg->value == CPENC (3, 0, C2, C1, 0)
4176 || reg->value == CPENC (3, 0, C2, C1, 1)
4177 || reg->value == CPENC (3, 0, C2, C1, 2)
4178 || reg->value == CPENC (3, 0, C2, C1, 3)
4179 || reg->value == CPENC (3, 0, C2, C2, 0)
4180 || reg->value == CPENC (3, 0, C2, C2, 1)
4181 || reg->value == CPENC (3, 0, C2, C2, 2)
4182 || reg->value == CPENC (3, 0, C2, C2, 3)
4183 || reg->value == CPENC (3, 0, C2, C3, 0)
4184 || reg->value == CPENC (3, 0, C2, C3, 1))
4185 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_3))
4186 return FALSE;
4187
4188 /* SVE. */
4189 if ((reg->value == CPENC (3, 0, C0, C4, 4)
4190 || reg->value == CPENC (3, 0, C1, C2, 0)
4191 || reg->value == CPENC (3, 4, C1, C2, 0)
4192 || reg->value == CPENC (3, 6, C1, C2, 0)
4193 || reg->value == CPENC (3, 5, C1, C2, 0)
4194 || reg->value == CPENC (3, 0, C0, C0, 7))
4195 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_SVE))
4196 return FALSE;
4197
4198 /* ARMv8.4 features. */
4199
4200 /* PSTATE.DIT. */
4201 if (reg->value == CPEN_ (3, C2, 5)
4202 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_4))
4203 return FALSE;
4204
4205 /* Virtualization extensions. */
4206 if ((reg->value == CPENC(3, 4, C2, C6, 2)
4207 || reg->value == CPENC(3, 4, C2, C6, 0)
4208 || reg->value == CPENC(3, 4, C14, C4, 0)
4209 || reg->value == CPENC(3, 4, C14, C4, 2)
4210 || reg->value == CPENC(3, 4, C14, C4, 1)
4211 || reg->value == CPENC(3, 4, C14, C5, 0)
4212 || reg->value == CPENC(3, 4, C14, C5, 2)
4213 || reg->value == CPENC(3, 4, C14, C5, 1)
4214 || reg->value == CPENC(3, 4, C1, C3, 1)
4215 || reg->value == CPENC(3, 4, C2, C2, 0))
4216 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_4))
4217 return FALSE;
4218
4219 /* ARMv8.4 TLB instructions. */
4220 if ((reg->value == CPENS (0, C8, C1, 0)
4221 || reg->value == CPENS (0, C8, C1, 1)
4222 || reg->value == CPENS (0, C8, C1, 2)
4223 || reg->value == CPENS (0, C8, C1, 3)
4224 || reg->value == CPENS (0, C8, C1, 5)
4225 || reg->value == CPENS (0, C8, C1, 7)
4226 || reg->value == CPENS (4, C8, C4, 0)
4227 || reg->value == CPENS (4, C8, C4, 4)
4228 || reg->value == CPENS (4, C8, C1, 1)
4229 || reg->value == CPENS (4, C8, C1, 5)
4230 || reg->value == CPENS (4, C8, C1, 6)
4231 || reg->value == CPENS (6, C8, C1, 1)
4232 || reg->value == CPENS (6, C8, C1, 5)
4233 || reg->value == CPENS (4, C8, C1, 0)
4234 || reg->value == CPENS (4, C8, C1, 4)
4235 || reg->value == CPENS (6, C8, C1, 0)
4236 || reg->value == CPENS (0, C8, C6, 1)
4237 || reg->value == CPENS (0, C8, C6, 3)
4238 || reg->value == CPENS (0, C8, C6, 5)
4239 || reg->value == CPENS (0, C8, C6, 7)
4240 || reg->value == CPENS (0, C8, C2, 1)
4241 || reg->value == CPENS (0, C8, C2, 3)
4242 || reg->value == CPENS (0, C8, C2, 5)
4243 || reg->value == CPENS (0, C8, C2, 7)
4244 || reg->value == CPENS (0, C8, C5, 1)
4245 || reg->value == CPENS (0, C8, C5, 3)
4246 || reg->value == CPENS (0, C8, C5, 5)
4247 || reg->value == CPENS (0, C8, C5, 7)
4248 || reg->value == CPENS (4, C8, C0, 2)
4249 || reg->value == CPENS (4, C8, C0, 6)
4250 || reg->value == CPENS (4, C8, C4, 2)
4251 || reg->value == CPENS (4, C8, C4, 6)
4252 || reg->value == CPENS (4, C8, C4, 3)
4253 || reg->value == CPENS (4, C8, C4, 7)
4254 || reg->value == CPENS (4, C8, C6, 1)
4255 || reg->value == CPENS (4, C8, C6, 5)
4256 || reg->value == CPENS (4, C8, C2, 1)
4257 || reg->value == CPENS (4, C8, C2, 5)
4258 || reg->value == CPENS (4, C8, C5, 1)
4259 || reg->value == CPENS (4, C8, C5, 5)
4260 || reg->value == CPENS (6, C8, C6, 1)
4261 || reg->value == CPENS (6, C8, C6, 5)
4262 || reg->value == CPENS (6, C8, C2, 1)
4263 || reg->value == CPENS (6, C8, C2, 5)
4264 || reg->value == CPENS (6, C8, C5, 1)
4265 || reg->value == CPENS (6, C8, C5, 5))
4266 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_4))
4267 return FALSE;
4268
4269 return TRUE;
4270 }
4271
4272 /* The CPENC below is fairly misleading, the fields
4273 here are not in CPENC form. They are in op2op1 form. The fields are encoded
4274 by ins_pstatefield, which just shifts the value by the width of the fields
4275 in a loop. So if you CPENC them only the first value will be set, the rest
4276 are masked out to 0. As an example. op2 = 3, op1=2. CPENC would produce a
4277 value of 0b110000000001000000 (0x30040) while what you want is
4278 0b011010 (0x1a). */
4279 const aarch64_sys_reg aarch64_pstatefields [] =
4280 {
4281 { "spsel", 0x05, 0 },
4282 { "daifset", 0x1e, 0 },
4283 { "daifclr", 0x1f, 0 },
4284 { "pan", 0x04, F_ARCHEXT },
4285 { "uao", 0x03, F_ARCHEXT },
4286 { "dit", 0x1a, F_ARCHEXT },
4287 { 0, CPENC(0,0,0,0,0), 0 },
4288 };
4289
4290 bfd_boolean
4291 aarch64_pstatefield_supported_p (const aarch64_feature_set features,
4292 const aarch64_sys_reg *reg)
4293 {
4294 if (!(reg->flags & F_ARCHEXT))
4295 return TRUE;
4296
4297 /* PAN. Values are from aarch64_pstatefields. */
4298 if (reg->value == 0x04
4299 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_PAN))
4300 return FALSE;
4301
4302 /* UAO. Values are from aarch64_pstatefields. */
4303 if (reg->value == 0x03
4304 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_2))
4305 return FALSE;
4306
4307 /* DIT. Values are from aarch64_pstatefields. */
4308 if (reg->value == 0x1a
4309 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_4))
4310 return FALSE;
4311
4312 return TRUE;
4313 }
4314
4315 const aarch64_sys_ins_reg aarch64_sys_regs_ic[] =
4316 {
4317 { "ialluis", CPENS(0,C7,C1,0), 0 },
4318 { "iallu", CPENS(0,C7,C5,0), 0 },
4319 { "ivau", CPENS (3, C7, C5, 1), F_HASXT },
4320 { 0, CPENS(0,0,0,0), 0 }
4321 };
4322
4323 const aarch64_sys_ins_reg aarch64_sys_regs_dc[] =
4324 {
4325 { "zva", CPENS (3, C7, C4, 1), F_HASXT },
4326 { "ivac", CPENS (0, C7, C6, 1), F_HASXT },
4327 { "isw", CPENS (0, C7, C6, 2), F_HASXT },
4328 { "cvac", CPENS (3, C7, C10, 1), F_HASXT },
4329 { "csw", CPENS (0, C7, C10, 2), F_HASXT },
4330 { "cvau", CPENS (3, C7, C11, 1), F_HASXT },
4331 { "cvap", CPENS (3, C7, C12, 1), F_HASXT | F_ARCHEXT },
4332 { "civac", CPENS (3, C7, C14, 1), F_HASXT },
4333 { "cisw", CPENS (0, C7, C14, 2), F_HASXT },
4334 { 0, CPENS(0,0,0,0), 0 }
4335 };
4336
4337 const aarch64_sys_ins_reg aarch64_sys_regs_at[] =
4338 {
4339 { "s1e1r", CPENS (0, C7, C8, 0), F_HASXT },
4340 { "s1e1w", CPENS (0, C7, C8, 1), F_HASXT },
4341 { "s1e0r", CPENS (0, C7, C8, 2), F_HASXT },
4342 { "s1e0w", CPENS (0, C7, C8, 3), F_HASXT },
4343 { "s12e1r", CPENS (4, C7, C8, 4), F_HASXT },
4344 { "s12e1w", CPENS (4, C7, C8, 5), F_HASXT },
4345 { "s12e0r", CPENS (4, C7, C8, 6), F_HASXT },
4346 { "s12e0w", CPENS (4, C7, C8, 7), F_HASXT },
4347 { "s1e2r", CPENS (4, C7, C8, 0), F_HASXT },
4348 { "s1e2w", CPENS (4, C7, C8, 1), F_HASXT },
4349 { "s1e3r", CPENS (6, C7, C8, 0), F_HASXT },
4350 { "s1e3w", CPENS (6, C7, C8, 1), F_HASXT },
4351 { "s1e1rp", CPENS (0, C7, C9, 0), F_HASXT | F_ARCHEXT },
4352 { "s1e1wp", CPENS (0, C7, C9, 1), F_HASXT | F_ARCHEXT },
4353 { 0, CPENS(0,0,0,0), 0 }
4354 };
4355
4356 const aarch64_sys_ins_reg aarch64_sys_regs_tlbi[] =
4357 {
4358 { "vmalle1", CPENS(0,C8,C7,0), 0 },
4359 { "vae1", CPENS (0, C8, C7, 1), F_HASXT },
4360 { "aside1", CPENS (0, C8, C7, 2), F_HASXT },
4361 { "vaae1", CPENS (0, C8, C7, 3), F_HASXT },
4362 { "vmalle1is", CPENS(0,C8,C3,0), 0 },
4363 { "vae1is", CPENS (0, C8, C3, 1), F_HASXT },
4364 { "aside1is", CPENS (0, C8, C3, 2), F_HASXT },
4365 { "vaae1is", CPENS (0, C8, C3, 3), F_HASXT },
4366 { "ipas2e1is", CPENS (4, C8, C0, 1), F_HASXT },
4367 { "ipas2le1is",CPENS (4, C8, C0, 5), F_HASXT },
4368 { "ipas2e1", CPENS (4, C8, C4, 1), F_HASXT },
4369 { "ipas2le1", CPENS (4, C8, C4, 5), F_HASXT },
4370 { "vae2", CPENS (4, C8, C7, 1), F_HASXT },
4371 { "vae2is", CPENS (4, C8, C3, 1), F_HASXT },
4372 { "vmalls12e1",CPENS(4,C8,C7,6), 0 },
4373 { "vmalls12e1is",CPENS(4,C8,C3,6), 0 },
4374 { "vae3", CPENS (6, C8, C7, 1), F_HASXT },
4375 { "vae3is", CPENS (6, C8, C3, 1), F_HASXT },
4376 { "alle2", CPENS(4,C8,C7,0), 0 },
4377 { "alle2is", CPENS(4,C8,C3,0), 0 },
4378 { "alle1", CPENS(4,C8,C7,4), 0 },
4379 { "alle1is", CPENS(4,C8,C3,4), 0 },
4380 { "alle3", CPENS(6,C8,C7,0), 0 },
4381 { "alle3is", CPENS(6,C8,C3,0), 0 },
4382 { "vale1is", CPENS (0, C8, C3, 5), F_HASXT },
4383 { "vale2is", CPENS (4, C8, C3, 5), F_HASXT },
4384 { "vale3is", CPENS (6, C8, C3, 5), F_HASXT },
4385 { "vaale1is", CPENS (0, C8, C3, 7), F_HASXT },
4386 { "vale1", CPENS (0, C8, C7, 5), F_HASXT },
4387 { "vale2", CPENS (4, C8, C7, 5), F_HASXT },
4388 { "vale3", CPENS (6, C8, C7, 5), F_HASXT },
4389 { "vaale1", CPENS (0, C8, C7, 7), F_HASXT },
4390
4391 { "vmalle1os", CPENS (0, C8, C1, 0), F_ARCHEXT },
4392 { "vae1os", CPENS (0, C8, C1, 1), F_HASXT | F_ARCHEXT },
4393 { "aside1os", CPENS (0, C8, C1, 2), F_HASXT | F_ARCHEXT },
4394 { "vaae1os", CPENS (0, C8, C1, 3), F_HASXT | F_ARCHEXT },
4395 { "vale1os", CPENS (0, C8, C1, 5), F_HASXT | F_ARCHEXT },
4396 { "vaale1os", CPENS (0, C8, C1, 7), F_HASXT | F_ARCHEXT },
4397 { "ipas2e1os", CPENS (4, C8, C4, 0), F_HASXT | F_ARCHEXT },
4398 { "ipas2le1os", CPENS (4, C8, C4, 4), F_HASXT | F_ARCHEXT },
4399 { "vae2os", CPENS (4, C8, C1, 1), F_HASXT | F_ARCHEXT },
4400 { "vale2os", CPENS (4, C8, C1, 5), F_HASXT | F_ARCHEXT },
4401 { "vmalls12e1os", CPENS (4, C8, C1, 6), F_ARCHEXT },
4402 { "vae3os", CPENS (6, C8, C1, 1), F_HASXT | F_ARCHEXT },
4403 { "vale3os", CPENS (6, C8, C1, 5), F_HASXT | F_ARCHEXT },
4404 { "alle2os", CPENS (4, C8, C1, 0), F_ARCHEXT },
4405 { "alle1os", CPENS (4, C8, C1, 4), F_ARCHEXT },
4406 { "alle3os", CPENS (6, C8, C1, 0), F_ARCHEXT },
4407
4408 { "rvae1", CPENS (0, C8, C6, 1), F_HASXT | F_ARCHEXT },
4409 { "rvaae1", CPENS (0, C8, C6, 3), F_HASXT | F_ARCHEXT },
4410 { "rvale1", CPENS (0, C8, C6, 5), F_HASXT | F_ARCHEXT },
4411 { "rvaale1", CPENS (0, C8, C6, 7), F_HASXT | F_ARCHEXT },
4412 { "rvae1is", CPENS (0, C8, C2, 1), F_HASXT | F_ARCHEXT },
4413 { "rvaae1is", CPENS (0, C8, C2, 3), F_HASXT | F_ARCHEXT },
4414 { "rvale1is", CPENS (0, C8, C2, 5), F_HASXT | F_ARCHEXT },
4415 { "rvaale1is", CPENS (0, C8, C2, 7), F_HASXT | F_ARCHEXT },
4416 { "rvae1os", CPENS (0, C8, C5, 1), F_HASXT | F_ARCHEXT },
4417 { "rvaae1os", CPENS (0, C8, C5, 3), F_HASXT | F_ARCHEXT },
4418 { "rvale1os", CPENS (0, C8, C5, 5), F_HASXT | F_ARCHEXT },
4419 { "rvaale1os", CPENS (0, C8, C5, 7), F_HASXT | F_ARCHEXT },
4420 { "ripas2e1is", CPENS (4, C8, C0, 2), F_HASXT | F_ARCHEXT },
4421 { "ripas2le1is",CPENS (4, C8, C0, 6), F_HASXT | F_ARCHEXT },
4422 { "ripas2e1", CPENS (4, C8, C4, 2), F_HASXT | F_ARCHEXT },
4423 { "ripas2le1", CPENS (4, C8, C4, 6), F_HASXT | F_ARCHEXT },
4424 { "ripas2e1os", CPENS (4, C8, C4, 3), F_HASXT | F_ARCHEXT },
4425 { "ripas2le1os",CPENS (4, C8, C4, 7), F_HASXT | F_ARCHEXT },
4426 { "rvae2", CPENS (4, C8, C6, 1), F_HASXT | F_ARCHEXT },
4427 { "rvale2", CPENS (4, C8, C6, 5), F_HASXT | F_ARCHEXT },
4428 { "rvae2is", CPENS (4, C8, C2, 1), F_HASXT | F_ARCHEXT },
4429 { "rvale2is", CPENS (4, C8, C2, 5), F_HASXT | F_ARCHEXT },
4430 { "rvae2os", CPENS (4, C8, C5, 1), F_HASXT | F_ARCHEXT },
4431 { "rvale2os", CPENS (4, C8, C5, 5), F_HASXT | F_ARCHEXT },
4432 { "rvae3", CPENS (6, C8, C6, 1), F_HASXT | F_ARCHEXT },
4433 { "rvale3", CPENS (6, C8, C6, 5), F_HASXT | F_ARCHEXT },
4434 { "rvae3is", CPENS (6, C8, C2, 1), F_HASXT | F_ARCHEXT },
4435 { "rvale3is", CPENS (6, C8, C2, 5), F_HASXT | F_ARCHEXT },
4436 { "rvae3os", CPENS (6, C8, C5, 1), F_HASXT | F_ARCHEXT },
4437 { "rvale3os", CPENS (6, C8, C5, 5), F_HASXT | F_ARCHEXT },
4438
4439 { 0, CPENS(0,0,0,0), 0 }
4440 };
4441
4442 bfd_boolean
4443 aarch64_sys_ins_reg_has_xt (const aarch64_sys_ins_reg *sys_ins_reg)
4444 {
4445 return (sys_ins_reg->flags & F_HASXT) != 0;
4446 }
4447
4448 extern bfd_boolean
4449 aarch64_sys_ins_reg_supported_p (const aarch64_feature_set features,
4450 const aarch64_sys_ins_reg *reg)
4451 {
4452 if (!(reg->flags & F_ARCHEXT))
4453 return TRUE;
4454
4455 /* DC CVAP. Values are from aarch64_sys_regs_dc. */
4456 if (reg->value == CPENS (3, C7, C12, 1)
4457 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_2))
4458 return FALSE;
4459
4460 /* AT S1E1RP, AT S1E1WP. Values are from aarch64_sys_regs_at. */
4461 if ((reg->value == CPENS (0, C7, C9, 0)
4462 || reg->value == CPENS (0, C7, C9, 1))
4463 && !AARCH64_CPU_HAS_FEATURE (features, AARCH64_FEATURE_V8_2))
4464 return FALSE;
4465
4466 return TRUE;
4467 }
4468
4469 #undef C0
4470 #undef C1
4471 #undef C2
4472 #undef C3
4473 #undef C4
4474 #undef C5
4475 #undef C6
4476 #undef C7
4477 #undef C8
4478 #undef C9
4479 #undef C10
4480 #undef C11
4481 #undef C12
4482 #undef C13
4483 #undef C14
4484 #undef C15
4485
4486 #define BIT(INSN,BT) (((INSN) >> (BT)) & 1)
4487 #define BITS(INSN,HI,LO) (((INSN) >> (LO)) & ((1 << (((HI) - (LO)) + 1)) - 1))
4488
4489 static bfd_boolean
4490 verify_ldpsw (const struct aarch64_opcode * opcode ATTRIBUTE_UNUSED,
4491 const aarch64_insn insn)
4492 {
4493 int t = BITS (insn, 4, 0);
4494 int n = BITS (insn, 9, 5);
4495 int t2 = BITS (insn, 14, 10);
4496
4497 if (BIT (insn, 23))
4498 {
4499 /* Write back enabled. */
4500 if ((t == n || t2 == n) && n != 31)
4501 return FALSE;
4502 }
4503
4504 if (BIT (insn, 22))
4505 {
4506 /* Load */
4507 if (t == t2)
4508 return FALSE;
4509 }
4510
4511 return TRUE;
4512 }
4513
4514 /* Return true if VALUE cannot be moved into an SVE register using DUP
4515 (with any element size, not just ESIZE) and if using DUPM would
4516 therefore be OK. ESIZE is the number of bytes in the immediate. */
4517
4518 bfd_boolean
4519 aarch64_sve_dupm_mov_immediate_p (uint64_t uvalue, int esize)
4520 {
4521 int64_t svalue = uvalue;
4522 uint64_t upper = (uint64_t) -1 << (esize * 4) << (esize * 4);
4523
4524 if ((uvalue & ~upper) != uvalue && (uvalue | upper) != uvalue)
4525 return FALSE;
4526 if (esize <= 4 || (uint32_t) uvalue == (uint32_t) (uvalue >> 32))
4527 {
4528 svalue = (int32_t) uvalue;
4529 if (esize <= 2 || (uint16_t) uvalue == (uint16_t) (uvalue >> 16))
4530 {
4531 svalue = (int16_t) uvalue;
4532 if (esize == 1 || (uint8_t) uvalue == (uint8_t) (uvalue >> 8))
4533 return FALSE;
4534 }
4535 }
4536 if ((svalue & 0xff) == 0)
4537 svalue /= 256;
4538 return svalue < -128 || svalue >= 128;
4539 }
4540
4541 /* Include the opcode description table as well as the operand description
4542 table. */
4543 #define VERIFIER(x) verify_##x
4544 #include "aarch64-tbl.h"
GDB Binutils - Deliverables
This page took 0.172483 seconds and 3 git commands to generate.