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