opcodes/aarch64-opc.c

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