opcodes/aarch64-opc.c

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