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