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


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