opcodes/aarch64-opc.c

   1 /* aarch64-opc.c -- AArch64 opcode support.
   2    Copyright 2009, 2010, 2011, 2012  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
  31 #include "aarch64-opc.h"
  32
  33 #ifdef DEBUG_AARCH64
  34 int debug_dump = FALSE;
  35 #endif /* DEBUG_AARCH64 */
  36
  37 /* Helper functions to determine which operand to be used to encode/decode
  38    the size:Q fields for AdvSIMD instructions.  */
  39
  40 static inline bfd_boolean
  41 vector_qualifier_p (enum aarch64_opnd_qualifier qualifier)
  42 {
  43   return ((qualifier >= AARCH64_OPND_QLF_V_8B
  44           && qualifier <= AARCH64_OPND_QLF_V_1Q) ? TRUE
  45           : FALSE);
  46 }
  47
  48 static inline bfd_boolean
  49 fp_qualifier_p (enum aarch64_opnd_qualifier qualifier)
  50 {
  51   return ((qualifier >= AARCH64_OPND_QLF_S_B
  52           && qualifier <= AARCH64_OPND_QLF_S_Q) ? TRUE
  53           : FALSE);
  54 }
  55
  56 enum data_pattern
  57 {
  58   DP_UNKNOWN,
  59   DP_VECTOR_3SAME,
  60   DP_VECTOR_LONG,
  61   DP_VECTOR_WIDE,
  62   DP_VECTOR_ACROSS_LANES,
  63 };
  64
  65 static const char significant_operand_index [] =
  66 {
  67   0,    /* DP_UNKNOWN, by default using operand 0.  */
  68   0,    /* DP_VECTOR_3SAME */
  69   1,    /* DP_VECTOR_LONG */
  70   2,    /* DP_VECTOR_WIDE */
  71   1,    /* DP_VECTOR_ACROSS_LANES */
  72 };
  73
  74 /* Given a sequence of qualifiers in QUALIFIERS, determine and return
  75    the data pattern.
  76    N.B. QUALIFIERS is a possible sequence of qualifiers each of which
  77    corresponds to one of a sequence of operands.  */
  78
  79 static enum data_pattern
  80 get_data_pattern (const aarch64_opnd_qualifier_seq_t qualifiers)
  81 {
  82   if (vector_qualifier_p (qualifiers[0]) == TRUE)
  83     {
  84       /* e.g. v.4s, v.4s, v.4s
  85            or v.4h, v.4h, v.h[3].  */
  86       if (qualifiers[0] == qualifiers[1]
  87           && vector_qualifier_p (qualifiers[2]) == TRUE
  88           && (aarch64_get_qualifier_esize (qualifiers[0])
  89               == aarch64_get_qualifier_esize (qualifiers[1]))
  90           && (aarch64_get_qualifier_esize (qualifiers[0])
  91               == aarch64_get_qualifier_esize (qualifiers[2])))
  92         return DP_VECTOR_3SAME;
  93       /* e.g. v.8h, v.8b, v.8b.
  94            or v.4s, v.4h, v.h[2].
  95            or v.8h, v.16b.  */
  96       if (vector_qualifier_p (qualifiers[1]) == TRUE
  97           && aarch64_get_qualifier_esize (qualifiers[0]) != 0
  98           && (aarch64_get_qualifier_esize (qualifiers[0])
  99               == aarch64_get_qualifier_esize (qualifiers[1]) << 1))
 100         return DP_VECTOR_LONG;
 101       /* e.g. v.8h, v.8h, v.8b.  */
 102       if (qualifiers[0] == qualifiers[1]
 103           && vector_qualifier_p (qualifiers[2]) == TRUE
 104           && aarch64_get_qualifier_esize (qualifiers[0]) != 0
 105           && (aarch64_get_qualifier_esize (qualifiers[0])
 106               == aarch64_get_qualifier_esize (qualifiers[2]) << 1)
 107           && (aarch64_get_qualifier_esize (qualifiers[0])
 108               == aarch64_get_qualifier_esize (qualifiers[1])))
 109         return DP_VECTOR_WIDE;
 110     }
 111   else if (fp_qualifier_p (qualifiers[0]) == TRUE)
 112     {
 113       /* e.g. SADDLV <V><d>, <Vn>.<T>.  */
 114       if (vector_qualifier_p (qualifiers[1]) == TRUE
 115           && qualifiers[2] == AARCH64_OPND_QLF_NIL)
 116         return DP_VECTOR_ACROSS_LANES;
 117     }
 118
 119   return DP_UNKNOWN;
 120 }
 121
 122 /* Select the operand to do the encoding/decoding of the 'size:Q' fields in
 123    the AdvSIMD instructions.  */
 124 /* N.B. it is possible to do some optimization that doesn't call
 125    get_data_pattern each time when we need to select an operand.  We can
 126    either buffer the caculated the result or statically generate the data,
 127    however, it is not obvious that the optimization will bring significant
 128    benefit.  */
 129
 130 int
 131 aarch64_select_operand_for_sizeq_field_coding (const aarch64_opcode *opcode)
 132 {
 133   return
 134     significant_operand_index [get_data_pattern (opcode->qualifiers_list[0])];
 135 }
 136 \f
 137 const aarch64_field fields[] =
 138 {
 139     {  0,  0 }, /* NIL.  */
 140     {  0,  4 }, /* cond2: condition in truly conditional-executed inst.  */
 141     {  0,  4 }, /* nzcv: flag bit specifier, encoded in the "nzcv" field.  */
 142     {  5,  5 }, /* defgh: d:e:f:g:h bits in AdvSIMD modified immediate.  */
 143     { 16,  3 }, /* abc: a:b:c bits in AdvSIMD modified immediate.  */
 144     {  5, 19 }, /* imm19: e.g. in CBZ.  */
 145     {  5, 19 }, /* immhi: e.g. in ADRP.  */
 146     { 29,  2 }, /* immlo: e.g. in ADRP.  */
 147     { 22,  2 }, /* size: in most AdvSIMD and floating-point instructions.  */
 148     { 10,  2 }, /* vldst_size: size field in the AdvSIMD load/store inst.  */
 149     { 29,  1 }, /* op: in AdvSIMD modified immediate instructions.  */
 150     { 30,  1 }, /* Q: in most AdvSIMD instructions.  */
 151     {  0,  5 }, /* Rt: in load/store instructions.  */
 152     {  0,  5 }, /* Rd: in many integer instructions.  */
 153     {  5,  5 }, /* Rn: in many integer instructions.  */
 154     { 10,  5 }, /* Rt2: in load/store pair instructions.  */
 155     { 10,  5 }, /* Ra: in fp instructions.  */
 156     {  5,  3 }, /* op2: in the system instructions.  */
 157     {  8,  4 }, /* CRm: in the system instructions.  */
 158     { 12,  4 }, /* CRn: in the system instructions.  */
 159     { 16,  3 }, /* op1: in the system instructions.  */
 160     { 19,  2 }, /* op0: in the system instructions.  */
 161     { 10,  3 }, /* imm3: in add/sub extended reg instructions.  */
 162     { 12,  4 }, /* cond: condition flags as a source operand.  */
 163     { 12,  4 }, /* opcode: in advsimd load/store instructions.  */
 164     { 12,  4 }, /* cmode: in advsimd modified immediate instructions.  */
 165     { 13,  3 }, /* asisdlso_opcode: opcode in advsimd ld/st single element.  */
 166     { 13,  2 }, /* len: in advsimd tbl/tbx instructions.  */
 167     { 16,  5 }, /* Rm: in ld/st reg offset and some integer inst.  */
 168     { 16,  5 }, /* Rs: in load/store exclusive instructions.  */
 169     { 13,  3 }, /* option: in ld/st reg offset + add/sub extended reg inst.  */
 170     { 12,  1 }, /* S: in load/store reg offset instructions.  */
 171     { 21,  2 }, /* hw: in move wide constant instructions.  */
 172     { 22,  2 }, /* opc: in load/store reg offset instructions.  */
 173     { 23,  1 }, /* opc1: in load/store reg offset instructions.  */
 174     { 22,  2 }, /* shift: in add/sub reg/imm shifted instructions.  */
 175     { 22,  2 }, /* type: floating point type field in fp data inst.  */
 176     { 30,  2 }, /* ldst_size: size field in ld/st reg offset inst.  */
 177     { 10,  6 }, /* imm6: in add/sub reg shifted instructions.  */
 178     { 11,  4 }, /* imm4: in advsimd ext and advsimd ins instructions.  */
 179     { 16,  5 }, /* imm5: in conditional compare (immediate) instructions.  */
 180     { 15,  7 }, /* imm7: in load/store pair pre/post index instructions.  */
 181     { 13,  8 }, /* imm8: in floating-point scalar move immediate inst.  */
 182     { 12,  9 }, /* imm9: in load/store pre/post index instructions.  */
 183     { 10, 12 }, /* imm12: in ld/st unsigned imm or add/sub shifted inst.  */
 184     {  5, 14 }, /* imm14: in test bit and branch instructions.  */
 185     {  5, 16 }, /* imm16: in exception instructions.  */
 186     {  0, 26 }, /* imm26: in unconditional branch instructions.  */
 187     { 10,  6 }, /* imms: in bitfield and logical immediate instructions.  */
 188     { 16,  6 }, /* immr: in bitfield and logical immediate instructions.  */
 189     { 16,  3 }, /* immb: in advsimd shift by immediate instructions.  */
 190     { 19,  4 }, /* immh: in advsimd shift by immediate instructions.  */
 191     { 22,  1 }, /* N: in logical (immediate) instructions.  */
 192     { 11,  1 }, /* index: in ld/st inst deciding the pre/post-index.  */
 193     { 24,  1 }, /* index2: in ld/st pair inst deciding the pre/post-index.  */
 194     { 31,  1 }, /* sf: in integer data processing instructions.  */
 195     { 11,  1 }, /* H: in advsimd scalar x indexed element instructions.  */
 196     { 21,  1 }, /* L: in advsimd scalar x indexed element instructions.  */
 197     { 20,  1 }, /* M: in advsimd scalar x indexed element instructions.  */
 198     { 31,  1 }, /* b5: in the test bit and branch instructions.  */
 199     { 19,  5 }, /* b40: in the test bit and branch instructions.  */
 200     { 10,  6 }, /* scale: in the fixed-point scalar to fp converting inst.  */
 201 };
 202
 203 enum aarch64_operand_class
 204 aarch64_get_operand_class (enum aarch64_opnd type)
 205 {
 206   return aarch64_operands[type].op_class;
 207 }
 208
 209 const char *
 210 aarch64_get_operand_name (enum aarch64_opnd type)
 211 {
 212   return aarch64_operands[type].name;
 213 }
 214
 215 /* Get operand description string.
 216    This is usually for the diagnosis purpose.  */
 217 const char *
 218 aarch64_get_operand_desc (enum aarch64_opnd type)
 219 {
 220   return aarch64_operands[type].desc;
 221 }
 222
 223 /* Table of all conditional affixes.  */
 224 const aarch64_cond aarch64_conds[16] =
 225 {
 226   {{"eq"}, 0x0},
 227   {{"ne"}, 0x1},
 228   {{"cs", "hs"}, 0x2},
 229   {{"cc", "lo", "ul"}, 0x3},
 230   {{"mi"}, 0x4},
 231   {{"pl"}, 0x5},
 232   {{"vs"}, 0x6},
 233   {{"vc"}, 0x7},
 234   {{"hi"}, 0x8},
 235   {{"ls"}, 0x9},
 236   {{"ge"}, 0xa},
 237   {{"lt"}, 0xb},
 238   {{"gt"}, 0xc},
 239   {{"le"}, 0xd},
 240   {{"al"}, 0xe},
 241   {{"nv"}, 0xf},
 242 };
 243
 244 const aarch64_cond *
 245 get_cond_from_value (aarch64_insn value)
 246 {
 247   assert (value < 16);
 248   return &aarch64_conds[(unsigned int) value];
 249 }
 250
 251 const aarch64_cond *
 252 get_inverted_cond (const aarch64_cond *cond)
 253 {
 254   return &aarch64_conds[cond->value ^ 0x1];
 255 }
 256
 257 /* Table describing the operand extension/shifting operators; indexed by
 258    enum aarch64_modifier_kind.
 259
 260    The value column provides the most common values for encoding modifiers,
 261    which enables table-driven encoding/decoding for the modifiers.  */
 262 const struct aarch64_name_value_pair aarch64_operand_modifiers [] =
 263 {
 264     {"none", 0x0},
 265     {"msl",  0x0},
 266     {"ror",  0x3},
 267     {"asr",  0x2},
 268     {"lsr",  0x1},
 269     {"lsl",  0x0},
 270     {"uxtb", 0x0},
 271     {"uxth", 0x1},
 272     {"uxtw", 0x2},
 273     {"uxtx", 0x3},
 274     {"sxtb", 0x4},
 275     {"sxth", 0x5},
 276     {"sxtw", 0x6},
 277     {"sxtx", 0x7},
 278     {NULL, 0},
 279 };
 280
 281 enum aarch64_modifier_kind
 282 aarch64_get_operand_modifier (const struct aarch64_name_value_pair *desc)
 283 {
 284   return desc - aarch64_operand_modifiers;
 285 }
 286
 287 aarch64_insn
 288 aarch64_get_operand_modifier_value (enum aarch64_modifier_kind kind)
 289 {
 290   return aarch64_operand_modifiers[kind].value;
 291 }
 292
 293 enum aarch64_modifier_kind
 294 aarch64_get_operand_modifier_from_value (aarch64_insn value,
 295                                          bfd_boolean extend_p)
 296 {
 297   if (extend_p == TRUE)
 298     return AARCH64_MOD_UXTB + value;
 299   else
 300     return AARCH64_MOD_LSL - value;
 301 }
 302
 303 bfd_boolean
 304 aarch64_extend_operator_p (enum aarch64_modifier_kind kind)
 305 {
 306   return (kind > AARCH64_MOD_LSL && kind <= AARCH64_MOD_SXTX)
 307     ? TRUE : FALSE;
 308 }
 309
 310 static inline bfd_boolean
 311 aarch64_shift_operator_p (enum aarch64_modifier_kind kind)
 312 {
 313   return (kind >= AARCH64_MOD_ROR && kind <= AARCH64_MOD_LSL)
 314     ? TRUE : FALSE;
 315 }
 316
 317 const struct aarch64_name_value_pair aarch64_barrier_options[16] =
 318 {
 319     { "#0x00", 0x0 },
 320     { "oshld", 0x1 },
 321     { "oshst", 0x2 },
 322     { "osh",   0x3 },
 323     { "#0x04", 0x4 },
 324     { "nshld", 0x5 },
 325     { "nshst", 0x6 },
 326     { "nsh",   0x7 },
 327     { "#0x08", 0x8 },
 328     { "ishld", 0x9 },
 329     { "ishst", 0xa },
 330     { "ish",   0xb },
 331     { "#0x0c", 0xc },
 332     { "ld",    0xd },
 333     { "st",    0xe },
 334     { "sy",    0xf },
 335 };
 336
 337 /* op -> op:       load = 0 store = 1
 338    l  -> level:    1-3
 339    t  -> temporal: temporal (retained) = 0 non-temporal (streaming) = 1   */
 340 #define B(op,l,t) ((((op) * 2) << 3) | (((l) - 1) << 1) | (t))
 341 const struct aarch64_name_value_pair aarch64_prfops[32] =
 342 {
 343   { "pldl1keep", B(0, 1, 0) },
 344   { "pldl1strm", B(0, 1, 1) },
 345   { "pldl2keep", B(0, 2, 0) },
 346   { "pldl2strm", B(0, 2, 1) },
 347   { "pldl3keep", B(0, 3, 0) },
 348   { "pldl3strm", B(0, 3, 1) },
 349   { "#0x06", 0x06 },
 350   { "#0x07", 0x07 },
 351   { "#0x08", 0x08 },
 352   { "#0x09", 0x09 },
 353   { "#0x0a", 0x0a },
 354   { "#0x0b", 0x0b },
 355   { "#0x0c", 0x0c },
 356   { "#0x0d", 0x0d },
 357   { "#0x0e", 0x0e },
 358   { "#0x0f", 0x0f },
 359   { "pstl1keep", B(1, 1, 0) },
 360   { "pstl1strm", B(1, 1, 1) },
 361   { "pstl2keep", B(1, 2, 0) },
 362   { "pstl2strm", B(1, 2, 1) },
 363   { "pstl3keep", B(1, 3, 0) },
 364   { "pstl3strm", B(1, 3, 1) },
 365   { "#0x16", 0x16 },
 366   { "#0x17", 0x17 },
 367   { "#0x18", 0x18 },
 368   { "#0x19", 0x19 },
 369   { "#0x1a", 0x1a },
 370   { "#0x1b", 0x1b },
 371   { "#0x1c", 0x1c },
 372   { "#0x1d", 0x1d },
 373   { "#0x1e", 0x1e },
 374   { "#0x1f", 0x1f },
 375 };
 376 #undef B
 377 \f
 378 /* Utilities on value constraint.  */
 379
 380 static inline int
 381 value_in_range_p (int64_t value, int low, int high)
 382 {
 383   return (value >= low && value <= high) ? 1 : 0;
 384 }
 385
 386 static inline int
 387 value_aligned_p (int64_t value, int align)
 388 {
 389   return ((value & (align - 1)) == 0) ? 1 : 0;
 390 }
 391
 392 /* A signed value fits in a field.  */
 393 static inline int
 394 value_fit_signed_field_p (int64_t value, unsigned width)
 395 {
 396   assert (width < 32);
 397   if (width < sizeof (value) * 8)
 398     {
 399       int64_t lim = (int64_t)1 << (width - 1);
 400       if (value >= -lim && value < lim)
 401         return 1;
 402     }
 403   return 0;
 404 }
 405
 406 /* An unsigned value fits in a field.  */
 407 static inline int
 408 value_fit_unsigned_field_p (int64_t value, unsigned width)
 409 {
 410   assert (width < 32);
 411   if (width < sizeof (value) * 8)
 412     {
 413       int64_t lim = (int64_t)1 << width;
 414       if (value >= 0 && value < lim)
 415         return 1;
 416     }
 417   return 0;
 418 }
 419
 420 /* Return 1 if OPERAND is SP or WSP.  */
 421 int
 422 aarch64_stack_pointer_p (const aarch64_opnd_info *operand)
 423 {
 424   return ((aarch64_get_operand_class (operand->type)
 425            == AARCH64_OPND_CLASS_INT_REG)
 426           && operand_maybe_stack_pointer (aarch64_operands + operand->type)
 427           && operand->reg.regno == 31);
 428 }
 429
 430 /* Return 1 if OPERAND is XZR or WZP.  */
 431 int
 432 aarch64_zero_register_p (const aarch64_opnd_info *operand)
 433 {
 434   return ((aarch64_get_operand_class (operand->type)
 435            == AARCH64_OPND_CLASS_INT_REG)
 436           && !operand_maybe_stack_pointer (aarch64_operands + operand->type)
 437           && operand->reg.regno == 31);
 438 }
 439
 440 /* Return true if the operand *OPERAND that has the operand code
 441    OPERAND->TYPE and been qualified by OPERAND->QUALIFIER can be also
 442    qualified by the qualifier TARGET.  */
 443
 444 static inline int
 445 operand_also_qualified_p (const struct aarch64_opnd_info *operand,
 446                           aarch64_opnd_qualifier_t target)
 447 {
 448   switch (operand->qualifier)
 449     {
 450     case AARCH64_OPND_QLF_W:
 451       if (target == AARCH64_OPND_QLF_WSP && aarch64_stack_pointer_p (operand))
 452         return 1;
 453       break;
 454     case AARCH64_OPND_QLF_X:
 455       if (target == AARCH64_OPND_QLF_SP && aarch64_stack_pointer_p (operand))
 456         return 1;
 457       break;
 458     case AARCH64_OPND_QLF_WSP:
 459       if (target == AARCH64_OPND_QLF_W
 460           && operand_maybe_stack_pointer (aarch64_operands + operand->type))
 461         return 1;
 462       break;
 463     case AARCH64_OPND_QLF_SP:
 464       if (target == AARCH64_OPND_QLF_X
 465           && operand_maybe_stack_pointer (aarch64_operands + operand->type))
 466         return 1;
 467       break;
 468     default:
 469       break;
 470     }
 471
 472   return 0;
 473 }
 474
 475 /* Given qualifier sequence list QSEQ_LIST and the known qualifier KNOWN_QLF
 476    for operand KNOWN_IDX, return the expected qualifier for operand IDX.
 477
 478    Return NIL if more than one expected qualifiers are found.  */
 479
 480 aarch64_opnd_qualifier_t
 481 aarch64_get_expected_qualifier (const aarch64_opnd_qualifier_seq_t *qseq_list,
 482                                 int idx,
 483                                 const aarch64_opnd_qualifier_t known_qlf,
 484                                 int known_idx)
 485 {
 486   int i, saved_i;
 487
 488   /* Special case.
 489
 490      When the known qualifier is NIL, we have to assume that there is only
 491      one qualifier sequence in the *QSEQ_LIST and return the corresponding
 492      qualifier directly.  One scenario is that for instruction
 493         PRFM <prfop>, [<Xn|SP>, #:lo12:<symbol>]
 494      which has only one possible valid qualifier sequence
 495         NIL, S_D
 496      the caller may pass NIL in KNOWN_QLF to obtain S_D so that it can
 497      determine the correct relocation type (i.e. LDST64_LO12) for PRFM.
 498
 499      Because the qualifier NIL has dual roles in the qualifier sequence:
 500      it can mean no qualifier for the operand, or the qualifer sequence is
 501      not in use (when all qualifiers in the sequence are NILs), we have to
 502      handle this special case here.  */
 503   if (known_qlf == AARCH64_OPND_NIL)
 504     {
 505       assert (qseq_list[0][known_idx] == AARCH64_OPND_NIL);
 506       return qseq_list[0][idx];
 507     }
 508
 509   for (i = 0, saved_i = -1; i < AARCH64_MAX_QLF_SEQ_NUM; ++i)
 510     {
 511       if (qseq_list[i][known_idx] == known_qlf)
 512         {
 513           if (saved_i != -1)
 514             /* More than one sequences are found to have KNOWN_QLF at
 515                KNOWN_IDX.  */
 516             return AARCH64_OPND_NIL;
 517           saved_i = i;
 518         }
 519     }
 520
 521   return qseq_list[saved_i][idx];
 522 }
 523
 524 enum operand_qualifier_kind
 525 {
 526   OQK_NIL,
 527   OQK_OPD_VARIANT,
 528   OQK_VALUE_IN_RANGE,
 529   OQK_MISC,
 530 };
 531
 532 /* Operand qualifier description.  */
 533 struct operand_qualifier_data
 534 {
 535   /* The usage of the three data fields depends on the qualifier kind.  */
 536   int data0;
 537   int data1;
 538   int data2;
 539   /* Description.  */
 540   const char *desc;
 541   /* Kind.  */
 542   enum operand_qualifier_kind kind;
 543 };
 544
 545 /* Indexed by the operand qualifier enumerators.  */
 546 struct operand_qualifier_data aarch64_opnd_qualifiers[] =
 547 {
 548   {0, 0, 0, "NIL", OQK_NIL},
 549
 550   /* Operand variant qualifiers.
 551      First 3 fields:
 552      element size, number of elements and common value for encoding.  */
 553
 554   {4, 1, 0x0, "w", OQK_OPD_VARIANT},
 555   {8, 1, 0x1, "x", OQK_OPD_VARIANT},
 556   {4, 1, 0x0, "wsp", OQK_OPD_VARIANT},
 557   {8, 1, 0x1, "sp", OQK_OPD_VARIANT},
 558
 559   {1, 1, 0x0, "b", OQK_OPD_VARIANT},
 560   {2, 1, 0x1, "h", OQK_OPD_VARIANT},
 561   {4, 1, 0x2, "s", OQK_OPD_VARIANT},
 562   {8, 1, 0x3, "d", OQK_OPD_VARIANT},
 563   {16, 1, 0x4, "q", OQK_OPD_VARIANT},
 564
 565   {1, 8, 0x0, "8b", OQK_OPD_VARIANT},
 566   {1, 16, 0x1, "16b", OQK_OPD_VARIANT},
 567   {2, 4, 0x2, "4h", OQK_OPD_VARIANT},
 568   {2, 8, 0x3, "8h", OQK_OPD_VARIANT},
 569   {4, 2, 0x4, "2s", OQK_OPD_VARIANT},
 570   {4, 4, 0x5, "4s", OQK_OPD_VARIANT},
 571   {8, 1, 0x6, "1d", OQK_OPD_VARIANT},
 572   {8, 2, 0x7, "2d", OQK_OPD_VARIANT},
 573   {16, 1, 0x8, "1q", OQK_OPD_VARIANT},
 574
 575   /* Qualifiers constraining the value range.
 576      First 3 fields:
 577      Lower bound, higher bound, unused.  */
 578
 579   {0,  7, 0, "imm_0_7" , OQK_VALUE_IN_RANGE},
 580   {0, 15, 0, "imm_0_15", OQK_VALUE_IN_RANGE},
 581   {0, 31, 0, "imm_0_31", OQK_VALUE_IN_RANGE},
 582   {0, 63, 0, "imm_0_63", OQK_VALUE_IN_RANGE},
 583   {1, 32, 0, "imm_1_32", OQK_VALUE_IN_RANGE},
 584   {1, 64, 0, "imm_1_64", OQK_VALUE_IN_RANGE},
 585
 586   /* Qualifiers for miscellaneous purpose.
 587      First 3 fields:
 588      unused, unused and unused.  */
 589
 590   {0, 0, 0, "lsl", 0},
 591   {0, 0, 0, "msl", 0},
 592
 593   {0, 0, 0, "retrieving", 0},
 594 };
 595
 596 static inline bfd_boolean
 597 operand_variant_qualifier_p (aarch64_opnd_qualifier_t qualifier)
 598 {
 599   return (aarch64_opnd_qualifiers[qualifier].kind == OQK_OPD_VARIANT)
 600     ? TRUE : FALSE;
 601 }
 602
 603 static inline bfd_boolean
 604 qualifier_value_in_range_constraint_p (aarch64_opnd_qualifier_t qualifier)
 605 {
 606   return (aarch64_opnd_qualifiers[qualifier].kind == OQK_VALUE_IN_RANGE)
 607     ? TRUE : FALSE;
 608 }
 609
 610 const char*
 611 aarch64_get_qualifier_name (aarch64_opnd_qualifier_t qualifier)
 612 {
 613   return aarch64_opnd_qualifiers[qualifier].desc;
 614 }
 615
 616 /* Given an operand qualifier, return the expected data element size
 617    of a qualified operand.  */
 618 unsigned char
 619 aarch64_get_qualifier_esize (aarch64_opnd_qualifier_t qualifier)
 620 {
 621   assert (operand_variant_qualifier_p (qualifier) == TRUE);
 622   return aarch64_opnd_qualifiers[qualifier].data0;
 623 }
 624
 625 unsigned char
 626 aarch64_get_qualifier_nelem (aarch64_opnd_qualifier_t qualifier)
 627 {
 628   assert (operand_variant_qualifier_p (qualifier) == TRUE);
 629   return aarch64_opnd_qualifiers[qualifier].data1;
 630 }
 631
 632 aarch64_insn
 633 aarch64_get_qualifier_standard_value (aarch64_opnd_qualifier_t qualifier)
 634 {
 635   assert (operand_variant_qualifier_p (qualifier) == TRUE);
 636   return aarch64_opnd_qualifiers[qualifier].data2;
 637 }
 638
 639 static int
 640 get_lower_bound (aarch64_opnd_qualifier_t qualifier)
 641 {
 642   assert (qualifier_value_in_range_constraint_p (qualifier) == TRUE);
 643   return aarch64_opnd_qualifiers[qualifier].data0;
 644 }
 645
 646 static int
 647 get_upper_bound (aarch64_opnd_qualifier_t qualifier)
 648 {
 649   assert (qualifier_value_in_range_constraint_p (qualifier) == TRUE);
 650   return aarch64_opnd_qualifiers[qualifier].data1;
 651 }
 652
 653 #ifdef DEBUG_AARCH64
 654 void
 655 aarch64_verbose (const char *str, ...)
 656 {
 657   va_list ap;
 658   va_start (ap, str);
 659   printf ("#### ");
 660   vprintf (str, ap);
 661   printf ("\n");
 662   va_end (ap);
 663 }
 664
 665 static inline void
 666 dump_qualifier_sequence (const aarch64_opnd_qualifier_t *qualifier)
 667 {
 668   int i;
 669   printf ("#### \t");
 670   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i, ++qualifier)
 671     printf ("%s,", aarch64_get_qualifier_name (*qualifier));
 672   printf ("\n");
 673 }
 674
 675 static void
 676 dump_match_qualifiers (const struct aarch64_opnd_info *opnd,
 677                        const aarch64_opnd_qualifier_t *qualifier)
 678 {
 679   int i;
 680   aarch64_opnd_qualifier_t curr[AARCH64_MAX_OPND_NUM];
 681
 682   aarch64_verbose ("dump_match_qualifiers:");
 683   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
 684     curr[i] = opnd[i].qualifier;
 685   dump_qualifier_sequence (curr);
 686   aarch64_verbose ("against");
 687   dump_qualifier_sequence (qualifier);
 688 }
 689 #endif /* DEBUG_AARCH64 */
 690
 691 /* TODO improve this, we can have an extra field at the runtime to
 692    store the number of operands rather than calculating it every time.  */
 693
 694 int
 695 aarch64_num_of_operands (const aarch64_opcode *opcode)
 696 {
 697   int i = 0;
 698   const enum aarch64_opnd *opnds = opcode->operands;
 699   while (opnds[i++] != AARCH64_OPND_NIL)
 700     ;
 701   --i;
 702   assert (i >= 0 && i <= AARCH64_MAX_OPND_NUM);
 703   return i;
 704 }
 705
 706 /* Find the best matched qualifier sequence in *QUALIFIERS_LIST for INST.
 707    If succeeds, fill the found sequence in *RET, return 1; otherwise return 0.
 708
 709    N.B. on the entry, it is very likely that only some operands in *INST
 710    have had their qualifiers been established.
 711
 712    If STOP_AT is not -1, the function will only try to match
 713    the qualifier sequence for operands before and including the operand
 714    of index STOP_AT; and on success *RET will only be filled with the first
 715    (STOP_AT+1) qualifiers.
 716
 717    A couple examples of the matching algorithm:
 718
 719    X,W,NIL should match
 720    X,W,NIL
 721
 722    NIL,NIL should match
 723    X  ,NIL
 724
 725    Apart from serving the main encoding routine, this can also be called
 726    during or after the operand decoding.  */
 727
 728 int
 729 aarch64_find_best_match (const aarch64_inst *inst,
 730                          const aarch64_opnd_qualifier_seq_t *qualifiers_list,
 731                          int stop_at, aarch64_opnd_qualifier_t *ret)
 732 {
 733   int found = 0;
 734   int i, num_opnds;
 735   const aarch64_opnd_qualifier_t *qualifiers;
 736
 737   num_opnds = aarch64_num_of_operands (inst->opcode);
 738   if (num_opnds == 0)
 739     {
 740       DEBUG_TRACE ("SUCCEED: no operand");
 741       return 1;
 742     }
 743
 744   if (stop_at < 0 || stop_at >= num_opnds)
 745     stop_at = num_opnds - 1;
 746
 747   /* For each pattern.  */
 748   for (i = 0; i < AARCH64_MAX_QLF_SEQ_NUM; ++i, ++qualifiers_list)
 749     {
 750       int j;
 751       qualifiers = *qualifiers_list;
 752
 753       /* Start as positive.  */
 754       found = 1;
 755
 756       DEBUG_TRACE ("%d", i);
 757 #ifdef DEBUG_AARCH64
 758       if (debug_dump)
 759         dump_match_qualifiers (inst->operands, qualifiers);
 760 #endif
 761
 762       /* Most opcodes has much fewer patterns in the list.
 763          First NIL qualifier indicates the end in the list.   */
 764       if (empty_qualifier_sequence_p (qualifiers) == TRUE)
 765         {
 766           DEBUG_TRACE_IF (i == 0, "SUCCEED: empty qualifier list");
 767           if (i)
 768             found = 0;
 769           break;
 770         }
 771
 772       for (j = 0; j < num_opnds && j <= stop_at; ++j, ++qualifiers)
 773         {
 774           if (inst->operands[j].qualifier == AARCH64_OPND_QLF_NIL)
 775             {
 776               /* Either the operand does not have qualifier, or the qualifier
 777                  for the operand needs to be deduced from the qualifier
 778                  sequence.
 779                  In the latter case, any constraint checking related with
 780                  the obtained qualifier should be done later in
 781                  operand_general_constraint_met_p.  */
 782               continue;
 783             }
 784           else if (*qualifiers != inst->operands[j].qualifier)
 785             {
 786               /* Unless the target qualifier can also qualify the operand
 787                  (which has already had a non-nil qualifier), non-equal
 788                  qualifiers are generally un-matched.  */
 789               if (operand_also_qualified_p (inst->operands + j, *qualifiers))
 790                 continue;
 791               else
 792                 {
 793                   found = 0;
 794                   break;
 795                 }
 796             }
 797           else
 798             continue;   /* Equal qualifiers are certainly matched.  */
 799         }
 800
 801       /* Qualifiers established.  */
 802       if (found == 1)
 803         break;
 804     }
 805
 806   if (found == 1)
 807     {
 808       /* Fill the result in *RET.  */
 809       int j;
 810       qualifiers = *qualifiers_list;
 811
 812       DEBUG_TRACE ("complete qualifiers using list %d", i);
 813 #ifdef DEBUG_AARCH64
 814       if (debug_dump)
 815         dump_qualifier_sequence (qualifiers);
 816 #endif
 817
 818       for (j = 0; j <= stop_at; ++j, ++qualifiers)
 819         ret[j] = *qualifiers;
 820       for (; j < AARCH64_MAX_OPND_NUM; ++j)
 821         ret[j] = AARCH64_OPND_QLF_NIL;
 822
 823       DEBUG_TRACE ("SUCCESS");
 824       return 1;
 825     }
 826
 827   DEBUG_TRACE ("FAIL");
 828   return 0;
 829 }
 830
 831 /* Operand qualifier matching and resolving.
 832
 833    Return 1 if the operand qualifier(s) in *INST match one of the qualifier
 834    sequences in INST->OPCODE->qualifiers_list; otherwise return 0.
 835
 836    if UPDATE_P == TRUE, update the qualifier(s) in *INST after the matching
 837    succeeds.  */
 838
 839 static int
 840 match_operands_qualifier (aarch64_inst *inst, bfd_boolean update_p)
 841 {
 842   int i;
 843   aarch64_opnd_qualifier_seq_t qualifiers;
 844
 845   if (!aarch64_find_best_match (inst, inst->opcode->qualifiers_list, -1,
 846                                qualifiers))
 847     {
 848       DEBUG_TRACE ("matching FAIL");
 849       return 0;
 850     }
 851
 852   /* Update the qualifiers.  */
 853   if (update_p == TRUE)
 854     for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
 855       {
 856         if (inst->opcode->operands[i] == AARCH64_OPND_NIL)
 857           break;
 858         DEBUG_TRACE_IF (inst->operands[i].qualifier != qualifiers[i],
 859                         "update %s with %s for operand %d",
 860                         aarch64_get_qualifier_name (inst->operands[i].qualifier),
 861                         aarch64_get_qualifier_name (qualifiers[i]), i);
 862         inst->operands[i].qualifier = qualifiers[i];
 863       }
 864
 865   DEBUG_TRACE ("matching SUCCESS");
 866   return 1;
 867 }
 868
 869 /* Return TRUE if VALUE is a wide constant that can be moved into a general
 870    register by MOVZ.
 871
 872    IS32 indicates whether value is a 32-bit immediate or not.
 873    If SHIFT_AMOUNT is not NULL, on the return of TRUE, the logical left shift
 874    amount will be returned in *SHIFT_AMOUNT.  */
 875
 876 bfd_boolean
 877 aarch64_wide_constant_p (int64_t value, int is32, unsigned int *shift_amount)
 878 {
 879   int amount;
 880
 881   DEBUG_TRACE ("enter with 0x%" PRIx64 "(%" PRIi64 ")", value, value);
 882
 883   if (is32)
 884     {
 885       /* Allow all zeros or all ones in top 32-bits, so that
 886          32-bit constant expressions like ~0x80000000 are
 887          permitted.  */
 888       uint64_t ext = value;
 889       if (ext >> 32 != 0 && ext >> 32 != (uint64_t) 0xffffffff)
 890         /* Immediate out of range.  */
 891         return FALSE;
 892       value &= (int64_t) 0xffffffff;
 893     }
 894
 895   /* first, try movz then movn */
 896   amount = -1;
 897   if ((value & ((int64_t) 0xffff << 0)) == value)
 898     amount = 0;
 899   else if ((value & ((int64_t) 0xffff << 16)) == value)
 900     amount = 16;
 901   else if (!is32 && (value & ((int64_t) 0xffff << 32)) == value)
 902     amount = 32;
 903   else if (!is32 && (value & ((int64_t) 0xffff << 48)) == value)
 904     amount = 48;
 905
 906   if (amount == -1)
 907     {
 908       DEBUG_TRACE ("exit FALSE with 0x%" PRIx64 "(%" PRIi64 ")", value, value);
 909       return FALSE;
 910     }
 911
 912   if (shift_amount != NULL)
 913     *shift_amount = amount;
 914
 915   DEBUG_TRACE ("exit TRUE with amount %d", amount);
 916
 917   return TRUE;
 918 }
 919
 920 /* Build the accepted values for immediate logical SIMD instructions.
 921
 922    The standard encodings of the immediate value are:
 923      N      imms     immr         SIMD size  R             S
 924      1      ssssss   rrrrrr       64      UInt(rrrrrr)  UInt(ssssss)
 925      0      0sssss   0rrrrr       32      UInt(rrrrr)   UInt(sssss)
 926      0      10ssss   00rrrr       16      UInt(rrrr)    UInt(ssss)
 927      0      110sss   000rrr       8       UInt(rrr)     UInt(sss)
 928      0      1110ss   0000rr       4       UInt(rr)      UInt(ss)
 929      0      11110s   00000r       2       UInt(r)       UInt(s)
 930    where all-ones value of S is reserved.
 931
 932    Let's call E the SIMD size.
 933
 934    The immediate value is: S+1 bits '1' rotated to the right by R.
 935
 936    The total of valid encodings is 64*63 + 32*31 + ... + 2*1 = 5334
 937    (remember S != E - 1).  */
 938
 939 #define TOTAL_IMM_NB  5334
 940
 941 typedef struct
 942 {
 943   uint64_t imm;
 944   aarch64_insn encoding;
 945 } simd_imm_encoding;
 946
 947 static simd_imm_encoding simd_immediates[TOTAL_IMM_NB];
 948
 949 static int
 950 simd_imm_encoding_cmp(const void *i1, const void *i2)
 951 {
 952   const simd_imm_encoding *imm1 = (const simd_imm_encoding *)i1;
 953   const simd_imm_encoding *imm2 = (const simd_imm_encoding *)i2;
 954
 955   if (imm1->imm < imm2->imm)
 956     return -1;
 957   if (imm1->imm > imm2->imm)
 958     return +1;
 959   return 0;
 960 }
 961
 962 /* immediate bitfield standard encoding
 963    imm13<12> imm13<5:0> imm13<11:6> SIMD size R      S
 964    1         ssssss     rrrrrr      64        rrrrrr ssssss
 965    0         0sssss     0rrrrr      32        rrrrr  sssss
 966    0         10ssss     00rrrr      16        rrrr   ssss
 967    0         110sss     000rrr      8         rrr    sss
 968    0         1110ss     0000rr      4         rr     ss
 969    0         11110s     00000r      2         r      s  */
 970 static inline int
 971 encode_immediate_bitfield (int is64, uint32_t s, uint32_t r)
 972 {
 973   return (is64 << 12) | (r << 6) | s;
 974 }
 975
 976 static void
 977 build_immediate_table (void)
 978 {
 979   uint32_t log_e, e, s, r, s_mask;
 980   uint64_t mask, imm;
 981   int nb_imms;
 982   int is64;
 983
 984   nb_imms = 0;
 985   for (log_e = 1; log_e <= 6; log_e++)
 986     {
 987       /* Get element size.  */
 988       e = 1u << log_e;
 989       if (log_e == 6)
 990         {
 991           is64 = 1;
 992           mask = 0xffffffffffffffffull;
 993           s_mask = 0;
 994         }
 995       else
 996         {
 997           is64 = 0;
 998           mask = (1ull << e) - 1;
 999           /* log_e  s_mask
1000              1     ((1 << 4) - 1) << 2 = 111100
1001              2     ((1 << 3) - 1) << 3 = 111000
1002              3     ((1 << 2) - 1) << 4 = 110000
1003              4     ((1 << 1) - 1) << 5 = 100000
1004              5     ((1 << 0) - 1) << 6 = 000000  */
1005           s_mask = ((1u << (5 - log_e)) - 1) << (log_e + 1);
1006         }
1007       for (s = 0; s < e - 1; s++)
1008         for (r = 0; r < e; r++)
1009           {
1010             /* s+1 consecutive bits to 1 (s < 63) */
1011             imm = (1ull << (s + 1)) - 1;
1012             /* rotate right by r */
1013             if (r != 0)
1014               imm = (imm >> r) | ((imm << (e - r)) & mask);
1015             /* replicate the constant depending on SIMD size */
1016             switch (log_e)
1017               {
1018               case 1: imm = (imm <<  2) | imm;
1019               case 2: imm = (imm <<  4) | imm;
1020               case 3: imm = (imm <<  8) | imm;
1021               case 4: imm = (imm << 16) | imm;
1022               case 5: imm = (imm << 32) | imm;
1023               case 6: break;
1024               default: abort ();
1025               }
1026             simd_immediates[nb_imms].imm = imm;
1027             simd_immediates[nb_imms].encoding =
1028               encode_immediate_bitfield(is64, s | s_mask, r);
1029             nb_imms++;
1030           }
1031     }
1032   assert (nb_imms == TOTAL_IMM_NB);
1033   qsort(simd_immediates, nb_imms,
1034         sizeof(simd_immediates[0]), simd_imm_encoding_cmp);
1035 }
1036
1037 /* Return TRUE if VALUE is a valid logical immediate, i.e. bitmask, that can
1038    be accepted by logical (immediate) instructions
1039    e.g. ORR <Xd|SP>, <Xn>, #<imm>.
1040
1041    IS32 indicates whether or not VALUE is a 32-bit immediate.
1042    If ENCODING is not NULL, on the return of TRUE, the standard encoding for
1043    VALUE will be returned in *ENCODING.  */
1044
1045 bfd_boolean
1046 aarch64_logical_immediate_p (uint64_t value, int is32, aarch64_insn *encoding)
1047 {
1048   simd_imm_encoding imm_enc;
1049   const simd_imm_encoding *imm_encoding;
1050   static bfd_boolean initialized = FALSE;
1051
1052   DEBUG_TRACE ("enter with 0x%" PRIx64 "(%" PRIi64 "), is32: %d", value,
1053                value, is32);
1054
1055   if (initialized == FALSE)
1056     {
1057       build_immediate_table ();
1058       initialized = TRUE;
1059     }
1060
1061   if (is32)
1062     {
1063       /* Allow all zeros or all ones in top 32-bits, so that
1064          constant expressions like ~1 are permitted.  */
1065       if (value >> 32 != 0 && value >> 32 != 0xffffffff)
1066         return 0xffffffff;
1067       /* Replicate the 32 lower bits to the 32 upper bits.  */
1068       value &= 0xffffffff;
1069       value |= value << 32;
1070     }
1071
1072   imm_enc.imm = value;
1073   imm_encoding = (const simd_imm_encoding *)
1074     bsearch(&imm_enc, simd_immediates, TOTAL_IMM_NB,
1075             sizeof(simd_immediates[0]), simd_imm_encoding_cmp);
1076   if (imm_encoding == NULL)
1077     {
1078       DEBUG_TRACE ("exit with FALSE");
1079       return FALSE;
1080     }
1081   if (encoding != NULL)
1082     *encoding = imm_encoding->encoding;
1083   DEBUG_TRACE ("exit with TRUE");
1084   return TRUE;
1085 }
1086
1087 /* If 64-bit immediate IMM is in the format of
1088    "aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffgggggggghhhhhhhh",
1089    where a, b, c, d, e, f, g and h are independently 0 or 1, return an integer
1090    of value "abcdefgh".  Otherwise return -1.  */
1091 int
1092 aarch64_shrink_expanded_imm8 (uint64_t imm)
1093 {
1094   int i, ret;
1095   uint32_t byte;
1096
1097   ret = 0;
1098   for (i = 0; i < 8; i++)
1099     {
1100       byte = (imm >> (8 * i)) & 0xff;
1101       if (byte == 0xff)
1102         ret |= 1 << i;
1103       else if (byte != 0x00)
1104         return -1;
1105     }
1106   return ret;
1107 }
1108
1109 /* Utility inline functions for operand_general_constraint_met_p.  */
1110
1111 static inline void
1112 set_error (aarch64_operand_error *mismatch_detail,
1113            enum aarch64_operand_error_kind kind, int idx,
1114            const char* error)
1115 {
1116   if (mismatch_detail == NULL)
1117     return;
1118   mismatch_detail->kind = kind;
1119   mismatch_detail->index = idx;
1120   mismatch_detail->error = error;
1121 }
1122
1123 static inline void
1124 set_out_of_range_error (aarch64_operand_error *mismatch_detail,
1125                         int idx, int lower_bound, int upper_bound,
1126                         const char* error)
1127 {
1128   if (mismatch_detail == NULL)
1129     return;
1130   set_error (mismatch_detail, AARCH64_OPDE_OUT_OF_RANGE, idx, error);
1131   mismatch_detail->data[0] = lower_bound;
1132   mismatch_detail->data[1] = upper_bound;
1133 }
1134
1135 static inline void
1136 set_imm_out_of_range_error (aarch64_operand_error *mismatch_detail,
1137                             int idx, int lower_bound, int upper_bound)
1138 {
1139   if (mismatch_detail == NULL)
1140     return;
1141   set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1142                           _("immediate value"));
1143 }
1144
1145 static inline void
1146 set_offset_out_of_range_error (aarch64_operand_error *mismatch_detail,
1147                                int idx, int lower_bound, int upper_bound)
1148 {
1149   if (mismatch_detail == NULL)
1150     return;
1151   set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1152                           _("immediate offset"));
1153 }
1154
1155 static inline void
1156 set_regno_out_of_range_error (aarch64_operand_error *mismatch_detail,
1157                               int idx, int lower_bound, int upper_bound)
1158 {
1159   if (mismatch_detail == NULL)
1160     return;
1161   set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1162                           _("register number"));
1163 }
1164
1165 static inline void
1166 set_elem_idx_out_of_range_error (aarch64_operand_error *mismatch_detail,
1167                                  int idx, int lower_bound, int upper_bound)
1168 {
1169   if (mismatch_detail == NULL)
1170     return;
1171   set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1172                           _("register element index"));
1173 }
1174
1175 static inline void
1176 set_sft_amount_out_of_range_error (aarch64_operand_error *mismatch_detail,
1177                                    int idx, int lower_bound, int upper_bound)
1178 {
1179   if (mismatch_detail == NULL)
1180     return;
1181   set_out_of_range_error (mismatch_detail, idx, lower_bound, upper_bound,
1182                           _("shift amount"));
1183 }
1184
1185 static inline void
1186 set_unaligned_error (aarch64_operand_error *mismatch_detail, int idx,
1187                      int alignment)
1188 {
1189   if (mismatch_detail == NULL)
1190     return;
1191   set_error (mismatch_detail, AARCH64_OPDE_UNALIGNED, idx, NULL);
1192   mismatch_detail->data[0] = alignment;
1193 }
1194
1195 static inline void
1196 set_reg_list_error (aarch64_operand_error *mismatch_detail, int idx,
1197                     int expected_num)
1198 {
1199   if (mismatch_detail == NULL)
1200     return;
1201   set_error (mismatch_detail, AARCH64_OPDE_REG_LIST, idx, NULL);
1202   mismatch_detail->data[0] = expected_num;
1203 }
1204
1205 static inline void
1206 set_other_error (aarch64_operand_error *mismatch_detail, int idx,
1207                  const char* error)
1208 {
1209   if (mismatch_detail == NULL)
1210     return;
1211   set_error (mismatch_detail, AARCH64_OPDE_OTHER_ERROR, idx, error);
1212 }
1213
1214 /* General constraint checking based on operand code.
1215
1216    Return 1 if OPNDS[IDX] meets the general constraint of operand code TYPE
1217    as the IDXth operand of opcode OPCODE.  Otherwise return 0.
1218
1219    This function has to be called after the qualifiers for all operands
1220    have been resolved.
1221
1222    Mismatching error message is returned in *MISMATCH_DETAIL upon request,
1223    i.e. when MISMATCH_DETAIL is non-NULL.  This avoids the generation
1224    of error message during the disassembling where error message is not
1225    wanted.  We avoid the dynamic construction of strings of error messages
1226    here (i.e. in libopcodes), as it is costly and complicated; instead, we
1227    use a combination of error code, static string and some integer data to
1228    represent an error.  */
1229
1230 static int
1231 operand_general_constraint_met_p (const aarch64_opnd_info *opnds, int idx,
1232                                   enum aarch64_opnd type,
1233                                   const aarch64_opcode *opcode,
1234                                   aarch64_operand_error *mismatch_detail)
1235 {
1236   unsigned num;
1237   unsigned char size;
1238   int64_t imm;
1239   const aarch64_opnd_info *opnd = opnds + idx;
1240   aarch64_opnd_qualifier_t qualifier = opnd->qualifier;
1241
1242   assert (opcode->operands[idx] == opnd->type && opnd->type == type);
1243
1244   switch (aarch64_operands[type].op_class)
1245     {
1246     case AARCH64_OPND_CLASS_INT_REG:
1247       /* <Xt> may be optional in some IC and TLBI instructions.  */
1248       if (type == AARCH64_OPND_Rt_SYS)
1249         {
1250           assert (idx == 1 && (aarch64_get_operand_class (opnds[0].type)
1251                                == AARCH64_OPND_CLASS_SYSTEM));
1252           if (opnds[1].present && !opnds[0].sysins_op->has_xt)
1253             {
1254               set_other_error (mismatch_detail, idx, _("extraneous register"));
1255               return 0;
1256             }
1257           if (!opnds[1].present && opnds[0].sysins_op->has_xt)
1258             {
1259               set_other_error (mismatch_detail, idx, _("missing register"));
1260               return 0;
1261             }
1262         }
1263       switch (qualifier)
1264         {
1265         case AARCH64_OPND_QLF_WSP:
1266         case AARCH64_OPND_QLF_SP:
1267           if (!aarch64_stack_pointer_p (opnd))
1268             {
1269               set_other_error (mismatch_detail, idx,
1270                                _("stack pointer register expected"));
1271               return 0;
1272             }
1273           break;
1274         default:
1275           break;
1276         }
1277       break;
1278
1279     case AARCH64_OPND_CLASS_ADDRESS:
1280       /* Check writeback.  */
1281       switch (opcode->iclass)
1282         {
1283         case ldst_pos:
1284         case ldst_unscaled:
1285         case ldstnapair_offs:
1286         case ldstpair_off:
1287         case ldst_unpriv:
1288           if (opnd->addr.writeback == 1)
1289             {
1290               set_other_error (mismatch_detail, idx,
1291                                _("unexpected address writeback"));
1292               return 0;
1293             }
1294           break;
1295         case ldst_imm9:
1296         case ldstpair_indexed:
1297         case asisdlsep:
1298         case asisdlsop:
1299           if (opnd->addr.writeback == 0)
1300             {
1301               set_other_error (mismatch_detail, idx,
1302                                _("address writeback expected"));
1303               return 0;
1304             }
1305           break;
1306         default:
1307           assert (opnd->addr.writeback == 0);
1308           break;
1309         }
1310       switch (type)
1311         {
1312         case AARCH64_OPND_ADDR_SIMM7:
1313           /* Scaled signed 7 bits immediate offset.  */
1314           /* Get the size of the data element that is accessed, which may be
1315              different from that of the source register size,
1316              e.g. in strb/ldrb.  */
1317           size = aarch64_get_qualifier_esize (opnd->qualifier);
1318           if (!value_in_range_p (opnd->addr.offset.imm, -64 * size, 63 * size))
1319             {
1320               set_offset_out_of_range_error (mismatch_detail, idx,
1321                                              -64 * size, 63 * size);
1322               return 0;
1323             }
1324           if (!value_aligned_p (opnd->addr.offset.imm, size))
1325             {
1326               set_unaligned_error (mismatch_detail, idx, size);
1327               return 0;
1328             }
1329           break;
1330         case AARCH64_OPND_ADDR_SIMM9:
1331           /* Unscaled signed 9 bits immediate offset.  */
1332           if (!value_in_range_p (opnd->addr.offset.imm, -256, 255))
1333             {
1334               set_offset_out_of_range_error (mismatch_detail, idx, -256, 255);
1335               return 0;
1336             }
1337           break;
1338
1339         case AARCH64_OPND_ADDR_SIMM9_2:
1340           /* Unscaled signed 9 bits immediate offset, which has to be negative
1341              or unaligned.  */
1342           size = aarch64_get_qualifier_esize (qualifier);
1343           if ((value_in_range_p (opnd->addr.offset.imm, 0, 255)
1344                && !value_aligned_p (opnd->addr.offset.imm, size))
1345               || value_in_range_p (opnd->addr.offset.imm, -256, -1))
1346             return 1;
1347           set_other_error (mismatch_detail, idx,
1348                            _("negative or unaligned offset expected"));
1349           return 0;
1350
1351         case AARCH64_OPND_SIMD_ADDR_POST:
1352           /* AdvSIMD load/store multiple structures, post-index.  */
1353           assert (idx == 1);
1354           if (opnd->addr.offset.is_reg)
1355             {
1356               if (value_in_range_p (opnd->addr.offset.regno, 0, 30))
1357                 return 1;
1358               else
1359                 {
1360                   set_other_error (mismatch_detail, idx,
1361                                    _("invalid register offset"));
1362                   return 0;
1363                 }
1364             }
1365           else
1366             {
1367               const aarch64_opnd_info *prev = &opnds[idx-1];
1368               unsigned num_bytes; /* total number of bytes transferred.  */
1369               /* The opcode dependent area stores the number of elements in
1370                  each structure to be loaded/stored.  */
1371               int is_ld1r = get_opcode_dependent_value (opcode) == 1;
1372               if (opcode->operands[0] == AARCH64_OPND_LVt_AL)
1373                 /* Special handling of loading single structure to all lane.  */
1374                 num_bytes = (is_ld1r ? 1 : prev->reglist.num_regs)
1375                   * aarch64_get_qualifier_esize (prev->qualifier);
1376               else
1377                 num_bytes = prev->reglist.num_regs
1378                   * aarch64_get_qualifier_esize (prev->qualifier)
1379                   * aarch64_get_qualifier_nelem (prev->qualifier);
1380               if ((int) num_bytes != opnd->addr.offset.imm)
1381                 {
1382                   set_other_error (mismatch_detail, idx,
1383                                    _("invalid post-increment amount"));
1384                   return 0;
1385                 }
1386             }
1387           break;
1388
1389         case AARCH64_OPND_ADDR_REGOFF:
1390           /* Get the size of the data element that is accessed, which may be
1391              different from that of the source register size,
1392              e.g. in strb/ldrb.  */
1393           size = aarch64_get_qualifier_esize (opnd->qualifier);
1394           /* It is either no shift or shift by the binary logarithm of SIZE.  */
1395           if (opnd->shifter.amount != 0
1396               && opnd->shifter.amount != (int)get_logsz (size))
1397             {
1398               set_other_error (mismatch_detail, idx,
1399                                _("invalid shift amount"));
1400               return 0;
1401             }
1402           /* Only UXTW, LSL, SXTW and SXTX are the accepted extending
1403              operators.  */
1404           switch (opnd->shifter.kind)
1405             {
1406             case AARCH64_MOD_UXTW:
1407             case AARCH64_MOD_LSL:
1408             case AARCH64_MOD_SXTW:
1409             case AARCH64_MOD_SXTX: break;
1410             default:
1411               set_other_error (mismatch_detail, idx,
1412                                _("invalid extend/shift operator"));
1413               return 0;
1414             }
1415           break;
1416
1417         case AARCH64_OPND_ADDR_UIMM12:
1418           imm = opnd->addr.offset.imm;
1419           /* Get the size of the data element that is accessed, which may be
1420              different from that of the source register size,
1421              e.g. in strb/ldrb.  */
1422           size = aarch64_get_qualifier_esize (qualifier);
1423           if (!value_in_range_p (opnd->addr.offset.imm, 0, 4095 * size))
1424             {
1425               set_offset_out_of_range_error (mismatch_detail, idx,
1426                                              0, 4095 * size);
1427               return 0;
1428             }
1429           if (!value_aligned_p (opnd->shifter.amount, size))
1430             {
1431               set_unaligned_error (mismatch_detail, idx, size);
1432               return 0;
1433             }
1434           break;
1435
1436         case AARCH64_OPND_ADDR_PCREL14:
1437         case AARCH64_OPND_ADDR_PCREL19:
1438         case AARCH64_OPND_ADDR_PCREL21:
1439         case AARCH64_OPND_ADDR_PCREL26:
1440           imm = opnd->imm.value;
1441           if (operand_need_shift_by_two (get_operand_from_code (type)))
1442             {
1443               /* The offset value in a PC-relative branch instruction is alway
1444                  4-byte aligned and is encoded without the lowest 2 bits.  */
1445               if (!value_aligned_p (imm, 4))
1446                 {
1447                   set_unaligned_error (mismatch_detail, idx, 4);
1448                   return 0;
1449                 }
1450               /* Right shift by 2 so that we can carry out the following check
1451                  canonically.  */
1452               imm >>= 2;
1453             }
1454           size = get_operand_fields_width (get_operand_from_code (type));
1455           if (!value_fit_signed_field_p (imm, size))
1456             {
1457               set_other_error (mismatch_detail, idx,
1458                                _("immediate out of range"));
1459               return 0;
1460             }
1461           break;
1462
1463         default:
1464           break;
1465         }
1466       break;
1467
1468     case AARCH64_OPND_CLASS_SIMD_REGLIST:
1469       /* The opcode dependent area stores the number of elements in
1470          each structure to be loaded/stored.  */
1471       num = get_opcode_dependent_value (opcode);
1472       switch (type)
1473         {
1474         case AARCH64_OPND_LVt:
1475           assert (num >= 1 && num <= 4);
1476           /* Unless LD1/ST1, the number of registers should be equal to that
1477              of the structure elements.  */
1478           if (num != 1 && opnd->reglist.num_regs != num)
1479             {
1480               set_reg_list_error (mismatch_detail, idx, num);
1481               return 0;
1482             }
1483           break;
1484         case AARCH64_OPND_LVt_AL:
1485         case AARCH64_OPND_LEt:
1486           assert (num >= 1 && num <= 4);
1487           /* The number of registers should be equal to that of the structure
1488              elements.  */
1489           if (opnd->reglist.num_regs != num)
1490             {
1491               set_reg_list_error (mismatch_detail, idx, num);
1492               return 0;
1493             }
1494           break;
1495         default:
1496           break;
1497         }
1498       break;
1499
1500     case AARCH64_OPND_CLASS_IMMEDIATE:
1501       /* Constraint check on immediate operand.  */
1502       imm = opnd->imm.value;
1503       /* E.g. imm_0_31 constrains value to be 0..31.  */
1504       if (qualifier_value_in_range_constraint_p (qualifier)
1505           && !value_in_range_p (imm, get_lower_bound (qualifier),
1506                                 get_upper_bound (qualifier)))
1507         {
1508           set_imm_out_of_range_error (mismatch_detail, idx,
1509                                       get_lower_bound (qualifier),
1510                                       get_upper_bound (qualifier));
1511           return 0;
1512         }
1513
1514       switch (type)
1515         {
1516         case AARCH64_OPND_AIMM:
1517           if (opnd->shifter.kind != AARCH64_MOD_LSL)
1518             {
1519               set_other_error (mismatch_detail, idx,
1520                                _("invalid shift operator"));
1521               return 0;
1522             }
1523           if (opnd->shifter.amount != 0 && opnd->shifter.amount != 12)
1524             {
1525               set_other_error (mismatch_detail, idx,
1526                                _("shift amount expected to be 0 or 12"));
1527               return 0;
1528             }
1529           if (!value_fit_unsigned_field_p (opnd->imm.value, 12))
1530             {
1531               set_other_error (mismatch_detail, idx,
1532                                _("immediate out of range"));
1533               return 0;
1534             }
1535           break;
1536
1537         case AARCH64_OPND_HALF:
1538           assert (idx == 1 && opnds[0].type == AARCH64_OPND_Rd);
1539           if (opnd->shifter.kind != AARCH64_MOD_LSL)
1540             {
1541               set_other_error (mismatch_detail, idx,
1542                                _("invalid shift operator"));
1543               return 0;
1544             }
1545           size = aarch64_get_qualifier_esize (opnds[0].qualifier);
1546           if (!value_aligned_p (opnd->shifter.amount, 16))
1547             {
1548               set_other_error (mismatch_detail, idx,
1549                                _("shift amount should be a multiple of 16"));
1550               return 0;
1551             }
1552           if (!value_in_range_p (opnd->shifter.amount, 0, size * 8 - 16))
1553             {
1554               set_sft_amount_out_of_range_error (mismatch_detail, idx,
1555                                                  0, size * 8 - 16);
1556               return 0;
1557             }
1558           if (opnd->imm.value < 0)
1559             {
1560               set_other_error (mismatch_detail, idx,
1561                                _("negative immediate value not allowed"));
1562               return 0;
1563             }
1564           if (!value_fit_unsigned_field_p (opnd->imm.value, 16))
1565             {
1566               set_other_error (mismatch_detail, idx,
1567                                _("immediate out of range"));
1568               return 0;
1569             }
1570           break;
1571
1572         case AARCH64_OPND_IMM_MOV:
1573             {
1574               int is32 = aarch64_get_qualifier_esize (opnds[0].qualifier) == 4;
1575               imm = opnd->imm.value;
1576               assert (idx == 1);
1577               switch (opcode->op)
1578                 {
1579                 case OP_MOV_IMM_WIDEN:
1580                   imm = ~imm;
1581                   /* Fall through...  */
1582                 case OP_MOV_IMM_WIDE:
1583                   if (!aarch64_wide_constant_p (imm, is32, NULL))
1584                     {
1585                       set_other_error (mismatch_detail, idx,
1586                                        _("immediate out of range"));
1587                       return 0;
1588                     }
1589                   break;
1590                 case OP_MOV_IMM_LOG:
1591                   if (!aarch64_logical_immediate_p (imm, is32, NULL))
1592                     {
1593                       set_other_error (mismatch_detail, idx,
1594                                        _("immediate out of range"));
1595                       return 0;
1596                     }
1597                   break;
1598                 default:
1599                   assert (0);
1600                   return 0;
1601                 }
1602             }
1603           break;
1604
1605         case AARCH64_OPND_NZCV:
1606         case AARCH64_OPND_CCMP_IMM:
1607         case AARCH64_OPND_EXCEPTION:
1608         case AARCH64_OPND_UIMM4:
1609         case AARCH64_OPND_UIMM7:
1610         case AARCH64_OPND_UIMM3_OP1:
1611         case AARCH64_OPND_UIMM3_OP2:
1612           size = get_operand_fields_width (get_operand_from_code (type));
1613           assert (size < 32);
1614           if (!value_fit_unsigned_field_p (opnd->imm.value, size))
1615             {
1616               set_imm_out_of_range_error (mismatch_detail, idx, 0,
1617                                           (1 << size) - 1);
1618               return 0;
1619             }
1620           break;
1621
1622         case AARCH64_OPND_WIDTH:
1623           assert (idx == 3 && opnds[idx-1].type == AARCH64_OPND_IMM
1624                   && opnds[0].type == AARCH64_OPND_Rd);
1625           size = get_upper_bound (qualifier);
1626           if (opnd->imm.value + opnds[idx-1].imm.value > size)
1627             /* lsb+width <= reg.size  */
1628             {
1629               set_imm_out_of_range_error (mismatch_detail, idx, 1,
1630                                           size - opnds[idx-1].imm.value);
1631               return 0;
1632             }
1633           break;
1634
1635         case AARCH64_OPND_LIMM:
1636             {
1637               int is32 = opnds[0].qualifier == AARCH64_OPND_QLF_W;
1638               uint64_t uimm = opnd->imm.value;
1639               if (opcode->op == OP_BIC)
1640                 uimm = ~uimm;
1641               if (aarch64_logical_immediate_p (uimm, is32, NULL) == FALSE)
1642                 {
1643                   set_other_error (mismatch_detail, idx,
1644                                    _("immediate out of range"));
1645                   return 0;
1646                 }
1647             }
1648           break;
1649
1650         case AARCH64_OPND_IMM0:
1651         case AARCH64_OPND_FPIMM0:
1652           if (opnd->imm.value != 0)
1653             {
1654               set_other_error (mismatch_detail, idx,
1655                                _("immediate zero expected"));
1656               return 0;
1657             }
1658           break;
1659
1660         case AARCH64_OPND_SHLL_IMM:
1661           assert (idx == 2);
1662           size = 8 * aarch64_get_qualifier_esize (opnds[idx - 1].qualifier);
1663           if (opnd->imm.value != size)
1664             {
1665               set_other_error (mismatch_detail, idx,
1666                                _("invalid shift amount"));
1667               return 0;
1668             }
1669           break;
1670
1671         case AARCH64_OPND_IMM_VLSL:
1672           size = aarch64_get_qualifier_esize (qualifier);
1673           if (!value_in_range_p (opnd->imm.value, 0, size * 8 - 1))
1674             {
1675               set_imm_out_of_range_error (mismatch_detail, idx, 0,
1676                                           size * 8 - 1);
1677               return 0;
1678             }
1679           break;
1680
1681         case AARCH64_OPND_IMM_VLSR:
1682           size = aarch64_get_qualifier_esize (qualifier);
1683           if (!value_in_range_p (opnd->imm.value, 1, size * 8))
1684             {
1685               set_imm_out_of_range_error (mismatch_detail, idx, 1, size * 8);
1686               return 0;
1687             }
1688           break;
1689
1690         case AARCH64_OPND_SIMD_IMM:
1691         case AARCH64_OPND_SIMD_IMM_SFT:
1692           /* Qualifier check.  */
1693           switch (qualifier)
1694             {
1695             case AARCH64_OPND_QLF_LSL:
1696               if (opnd->shifter.kind != AARCH64_MOD_LSL)
1697                 {
1698                   set_other_error (mismatch_detail, idx,
1699                                    _("invalid shift operator"));
1700                   return 0;
1701                 }
1702               break;
1703             case AARCH64_OPND_QLF_MSL:
1704               if (opnd->shifter.kind != AARCH64_MOD_MSL)
1705                 {
1706                   set_other_error (mismatch_detail, idx,
1707                                    _("invalid shift operator"));
1708                   return 0;
1709                 }
1710               break;
1711             case AARCH64_OPND_QLF_NIL:
1712               if (opnd->shifter.kind != AARCH64_MOD_NONE)
1713                 {
1714                   set_other_error (mismatch_detail, idx,
1715                                    _("shift is not permitted"));
1716                   return 0;
1717                 }
1718               break;
1719             default:
1720               assert (0);
1721               return 0;
1722             }
1723           /* Is the immediate valid?  */
1724           assert (idx == 1);
1725           if (aarch64_get_qualifier_esize (opnds[0].qualifier) != 8)
1726             {
1727               /* uimm8 */
1728               if (!value_in_range_p (opnd->imm.value, 0, 255))
1729                 {
1730                   set_imm_out_of_range_error (mismatch_detail, idx, 0, 255);
1731                   return 0;
1732                 }
1733             }
1734           else if (aarch64_shrink_expanded_imm8 (opnd->imm.value) < 0)
1735             {
1736               /* uimm64 is not
1737                  'aaaaaaaabbbbbbbbccccccccddddddddeeeeeeee
1738                  ffffffffgggggggghhhhhhhh'.  */
1739               set_other_error (mismatch_detail, idx,
1740                                _("invalid value for immediate"));
1741               return 0;
1742             }
1743           /* Is the shift amount valid?  */
1744           switch (opnd->shifter.kind)
1745             {
1746             case AARCH64_MOD_LSL:
1747               size = aarch64_get_qualifier_esize (opnds[0].qualifier);
1748               if (!value_aligned_p (opnd->shifter.amount, 8))
1749                 {
1750                   set_unaligned_error (mismatch_detail, idx, 8);
1751                   return 0;
1752                 }
1753               if (!value_in_range_p (opnd->shifter.amount, 0, (size - 1) * 8))
1754                 {
1755                   set_imm_out_of_range_error (mismatch_detail, idx, 0,
1756                                               (size - 1) * 8);
1757                   return 0;
1758                 }
1759               break;
1760             case AARCH64_MOD_MSL:
1761               /* Only 8 and 16 are valid shift amount.  */
1762               if (opnd->shifter.amount != 8 && opnd->shifter.amount != 16)
1763                 {
1764                   set_other_error (mismatch_detail, idx,
1765                                    _("shift amount expected to be 0 or 16"));
1766                   return 0;
1767                 }
1768               break;
1769             default:
1770               if (opnd->shifter.kind != AARCH64_MOD_NONE)
1771                 {
1772                   set_other_error (mismatch_detail, idx,
1773                                    _("invalid shift operator"));
1774                   return 0;
1775                 }
1776               break;
1777             }
1778           break;
1779
1780         case AARCH64_OPND_FPIMM:
1781         case AARCH64_OPND_SIMD_FPIMM:
1782           if (opnd->imm.is_fp == 0)
1783             {
1784               set_other_error (mismatch_detail, idx,
1785                                _("floating-point immediate expected"));
1786               return 0;
1787             }
1788           /* The value is expected to be an 8-bit floating-point constant with
1789              sign, 3-bit exponent and normalized 4 bits of precision, encoded
1790              in "a:b:c:d:e:f:g:h" or FLD_imm8 (depending on the type of the
1791              instruction).  */
1792           if (!value_in_range_p (opnd->imm.value, 0, 255))
1793             {
1794               set_other_error (mismatch_detail, idx,
1795                                _("immediate out of range"));
1796               return 0;
1797             }
1798           if (opnd->shifter.kind != AARCH64_MOD_NONE)
1799             {
1800               set_other_error (mismatch_detail, idx,
1801                                _("invalid shift operator"));
1802               return 0;
1803             }
1804           break;
1805
1806         default:
1807           break;
1808         }
1809       break;
1810
1811     case AARCH64_OPND_CLASS_CP_REG:
1812       /* Cn or Cm: 4-bit opcode field named for historical reasons.
1813          valid range: C0 - C15.  */
1814       if (opnd->reg.regno > 15)
1815         {
1816           set_regno_out_of_range_error (mismatch_detail, idx, 0, 15);
1817           return 0;
1818         }
1819       break;
1820
1821     case AARCH64_OPND_CLASS_SYSTEM:
1822       switch (type)
1823         {
1824         case AARCH64_OPND_PSTATEFIELD:
1825           assert (idx == 0 && opnds[1].type == AARCH64_OPND_UIMM4);
1826           /* MSR SPSel, #uimm4
1827              Uses uimm4 as a control value to select the stack pointer: if
1828              bit 0 is set it selects the current exception level's stack
1829              pointer, if bit 0 is clear it selects shared EL0 stack pointer.
1830              Bits 1 to 3 of uimm4 are reserved and should be zero.  */
1831           if (opnd->pstatefield == 0x05 /* spsel */ && opnds[1].imm.value > 1)
1832             {
1833               set_imm_out_of_range_error (mismatch_detail, idx, 0, 1);
1834               return 0;
1835             }
1836           break;
1837         default:
1838           break;
1839         }
1840       break;
1841
1842     case AARCH64_OPND_CLASS_SIMD_ELEMENT:
1843       /* Get the upper bound for the element index.  */
1844       num = 16 / aarch64_get_qualifier_esize (qualifier) - 1;
1845       /* Index out-of-range.  */
1846       if (!value_in_range_p (opnd->reglane.index, 0, num))
1847         {
1848           set_elem_idx_out_of_range_error (mismatch_detail, idx, 0, num);
1849           return 0;
1850         }
1851       /* SMLAL<Q> <Vd>.<Ta>, <Vn>.<Tb>, <Vm>.<Ts>[<index>].
1852          <Vm>   Is the vector register (V0-V31) or (V0-V15), whose
1853          number is encoded in "size:M:Rm":
1854          size   <Vm>
1855          00             RESERVED
1856          01             0:Rm
1857          10             M:Rm
1858          11             RESERVED  */
1859       if (type == AARCH64_OPND_Em && qualifier == AARCH64_OPND_QLF_S_H
1860           && !value_in_range_p (opnd->reglane.regno, 0, 15))
1861         {
1862           set_regno_out_of_range_error (mismatch_detail, idx, 0, 15);
1863           return 0;
1864         }
1865       break;
1866
1867     case AARCH64_OPND_CLASS_MODIFIED_REG:
1868       assert (idx == 1 || idx == 2);
1869       switch (type)
1870         {
1871         case AARCH64_OPND_Rm_EXT:
1872           if (aarch64_extend_operator_p (opnd->shifter.kind) == FALSE
1873               && opnd->shifter.kind != AARCH64_MOD_LSL)
1874             {
1875               set_other_error (mismatch_detail, idx,
1876                                _("extend operator expected"));
1877               return 0;
1878             }
1879           /* It is not optional unless at least one of "Rd" or "Rn" is '11111'
1880              (i.e. SP), in which case it defaults to LSL. The LSL alias is
1881              only valid when "Rd" or "Rn" is '11111', and is preferred in that
1882              case.  */
1883           if (!aarch64_stack_pointer_p (opnds + 0)
1884               && (idx != 2 || !aarch64_stack_pointer_p (opnds + 1)))
1885             {
1886               if (!opnd->shifter.operator_present)
1887                 {
1888                   set_other_error (mismatch_detail, idx,
1889                                    _("missing extend operator"));
1890                   return 0;
1891                 }
1892               else if (opnd->shifter.kind == AARCH64_MOD_LSL)
1893                 {
1894                   set_other_error (mismatch_detail, idx,
1895                                    _("'LSL' operator not allowed"));
1896                   return 0;
1897                 }
1898             }
1899           assert (opnd->shifter.operator_present        /* Default to LSL.  */
1900                   || opnd->shifter.kind == AARCH64_MOD_LSL);
1901           if (!value_in_range_p (opnd->shifter.amount, 0, 4))
1902             {
1903               set_sft_amount_out_of_range_error (mismatch_detail, idx, 0, 4);
1904               return 0;
1905             }
1906           /* In the 64-bit form, the final register operand is written as Wm
1907              for all but the (possibly omitted) UXTX/LSL and SXTX
1908              operators.
1909              N.B. GAS allows X register to be used with any operator as a
1910              programming convenience.  */
1911           if (qualifier == AARCH64_OPND_QLF_X
1912               && opnd->shifter.kind != AARCH64_MOD_LSL
1913               && opnd->shifter.kind != AARCH64_MOD_UXTX
1914               && opnd->shifter.kind != AARCH64_MOD_SXTX)
1915             {
1916               set_other_error (mismatch_detail, idx, _("W register expected"));
1917               return 0;
1918             }
1919           break;
1920
1921         case AARCH64_OPND_Rm_SFT:
1922           /* ROR is not available to the shifted register operand in
1923              arithmetic instructions.  */
1924           if (aarch64_shift_operator_p (opnd->shifter.kind) == FALSE)
1925             {
1926               set_other_error (mismatch_detail, idx,
1927                                _("shift operator expected"));
1928               return 0;
1929             }
1930           if (opnd->shifter.kind == AARCH64_MOD_ROR
1931               && opcode->iclass != log_shift)
1932             {
1933               set_other_error (mismatch_detail, idx,
1934                                _("'ROR' operator not allowed"));
1935               return 0;
1936             }
1937           num = qualifier == AARCH64_OPND_QLF_W ? 31 : 63;
1938           if (!value_in_range_p (opnd->shifter.amount, 0, num))
1939             {
1940               set_sft_amount_out_of_range_error (mismatch_detail, idx, 0, num);
1941               return 0;
1942             }
1943           break;
1944
1945         default:
1946           break;
1947         }
1948       break;
1949
1950     default:
1951       break;
1952     }
1953
1954   return 1;
1955 }
1956
1957 /* Main entrypoint for the operand constraint checking.
1958
1959    Return 1 if operands of *INST meet the constraint applied by the operand
1960    codes and operand qualifiers; otherwise return 0 and if MISMATCH_DETAIL is
1961    not NULL, return the detail of the error in *MISMATCH_DETAIL.  N.B. when
1962    adding more constraint checking, make sure MISMATCH_DETAIL->KIND is set
1963    with a proper error kind rather than AARCH64_OPDE_NIL (GAS asserts non-NIL
1964    error kind when it is notified that an instruction does not pass the check).
1965
1966    Un-determined operand qualifiers may get established during the process.  */
1967
1968 int
1969 aarch64_match_operands_constraint (aarch64_inst *inst,
1970                                    aarch64_operand_error *mismatch_detail)
1971 {
1972   int i;
1973
1974   DEBUG_TRACE ("enter");
1975
1976   /* Match operands' qualifier.
1977      *INST has already had qualifier establish for some, if not all, of
1978      its operands; we need to find out whether these established
1979      qualifiers match one of the qualifier sequence in
1980      INST->OPCODE->QUALIFIERS_LIST.  If yes, we will assign each operand
1981      with the corresponding qualifier in such a sequence.
1982      Only basic operand constraint checking is done here; the more thorough
1983      constraint checking will carried out by operand_general_constraint_met_p,
1984      which has be to called after this in order to get all of the operands'
1985      qualifiers established.  */
1986   if (match_operands_qualifier (inst, TRUE /* update_p */) == 0)
1987     {
1988       DEBUG_TRACE ("FAIL on operand qualifier matching");
1989       if (mismatch_detail)
1990         {
1991           /* Return an error type to indicate that it is the qualifier
1992              matching failure; we don't care about which operand as there
1993              are enough information in the opcode table to reproduce it.  */
1994           mismatch_detail->kind = AARCH64_OPDE_INVALID_VARIANT;
1995           mismatch_detail->index = -1;
1996           mismatch_detail->error = NULL;
1997         }
1998       return 0;
1999     }
2000
2001   /* Match operands' constraint.  */
2002   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2003     {
2004       enum aarch64_opnd type = inst->opcode->operands[i];
2005       if (type == AARCH64_OPND_NIL)
2006         break;
2007       if (inst->operands[i].skip)
2008         {
2009           DEBUG_TRACE ("skip the incomplete operand %d", i);
2010           continue;
2011         }
2012       if (operand_general_constraint_met_p (inst->operands, i, type,
2013                                             inst->opcode, mismatch_detail) == 0)
2014         {
2015           DEBUG_TRACE ("FAIL on operand %d", i);
2016           return 0;
2017         }
2018     }
2019
2020   DEBUG_TRACE ("PASS");
2021
2022   return 1;
2023 }
2024
2025 /* Replace INST->OPCODE with OPCODE and return the replaced OPCODE.
2026    Also updates the TYPE of each INST->OPERANDS with the corresponding
2027    value of OPCODE->OPERANDS.
2028
2029    Note that some operand qualifiers may need to be manually cleared by
2030    the caller before it further calls the aarch64_opcode_encode; by
2031    doing this, it helps the qualifier matching facilities work
2032    properly.  */
2033
2034 const aarch64_opcode*
2035 aarch64_replace_opcode (aarch64_inst *inst, const aarch64_opcode *opcode)
2036 {
2037   int i;
2038   const aarch64_opcode *old = inst->opcode;
2039
2040   inst->opcode = opcode;
2041
2042   /* Update the operand types.  */
2043   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2044     {
2045       inst->operands[i].type = opcode->operands[i];
2046       if (opcode->operands[i] == AARCH64_OPND_NIL)
2047         break;
2048     }
2049
2050   DEBUG_TRACE ("replace %s with %s", old->name, opcode->name);
2051
2052   return old;
2053 }
2054
2055 int
2056 aarch64_operand_index (const enum aarch64_opnd *operands, enum aarch64_opnd operand)
2057 {
2058   int i;
2059   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2060     if (operands[i] == operand)
2061       return i;
2062     else if (operands[i] == AARCH64_OPND_NIL)
2063       break;
2064   return -1;
2065 }
2066 \f
2067 /* [0][0]  32-bit integer regs with sp   Wn
2068    [0][1]  64-bit integer regs with sp   Xn  sf=1
2069    [1][0]  32-bit integer regs with #0   Wn
2070    [1][1]  64-bit integer regs with #0   Xn  sf=1 */
2071 static const char *int_reg[2][2][32] = {
2072 #define R32 "w"
2073 #define R64 "x"
2074   { { R32  "0", R32  "1", R32  "2", R32  "3", R32  "4", R32  "5", R32  "6", R32  "7",
2075       R32  "8", R32  "9", R32 "10", R32 "11", R32 "12", R32 "13", R32 "14", R32 "15",
2076       R32 "16", R32 "17", R32 "18", R32 "19", R32 "20", R32 "21", R32 "22", R32 "23",
2077       R32 "24", R32 "25", R32 "26", R32 "27", R32 "28", R32 "29", R32 "30",    "wsp" },
2078     { R64  "0", R64  "1", R64  "2", R64  "3", R64  "4", R64  "5", R64  "6", R64  "7",
2079       R64  "8", R64  "9", R64 "10", R64 "11", R64 "12", R64 "13", R64 "14", R64 "15",
2080       R64 "16", R64 "17", R64 "18", R64 "19", R64 "20", R64 "21", R64 "22", R64 "23",
2081       R64 "24", R64 "25", R64 "26", R64 "27", R64 "28", R64 "29", R64 "30",     "sp" } },
2082   { { R32  "0", R32  "1", R32  "2", R32  "3", R32  "4", R32  "5", R32  "6", R32  "7",
2083       R32  "8", R32  "9", R32 "10", R32 "11", R32 "12", R32 "13", R32 "14", R32 "15",
2084       R32 "16", R32 "17", R32 "18", R32 "19", R32 "20", R32 "21", R32 "22", R32 "23",
2085       R32 "24", R32 "25", R32 "26", R32 "27", R32 "28", R32 "29", R32 "30", R32 "zr" },
2086     { R64  "0", R64  "1", R64  "2", R64  "3", R64  "4", R64  "5", R64  "6", R64  "7",
2087       R64  "8", R64  "9", R64 "10", R64 "11", R64 "12", R64 "13", R64 "14", R64 "15",
2088       R64 "16", R64 "17", R64 "18", R64 "19", R64 "20", R64 "21", R64 "22", R64 "23",
2089       R64 "24", R64 "25", R64 "26", R64 "27", R64 "28", R64 "29", R64 "30", R64 "zr" } }
2090 #undef R64
2091 #undef R32
2092 };
2093
2094 /* Return the integer register name.
2095    if SP_REG_P is not 0, R31 is an SP reg, other R31 is the zero reg.  */
2096
2097 static inline const char *
2098 get_int_reg_name (int regno, aarch64_opnd_qualifier_t qualifier, int sp_reg_p)
2099 {
2100   const int has_zr = sp_reg_p ? 0 : 1;
2101   const int is_64 = aarch64_get_qualifier_esize (qualifier) == 4 ? 0 : 1;
2102   return int_reg[has_zr][is_64][regno];
2103 }
2104
2105 /* Like get_int_reg_name, but IS_64 is always 1.  */
2106
2107 static inline const char *
2108 get_64bit_int_reg_name (int regno, int sp_reg_p)
2109 {
2110   const int has_zr = sp_reg_p ? 0 : 1;
2111   return int_reg[has_zr][1][regno];
2112 }
2113
2114 /* Types for expanding an encoded 8-bit value to a floating-point value.  */
2115
2116 typedef union
2117 {
2118   uint64_t i;
2119   double   d;
2120 } double_conv_t;
2121
2122 typedef union
2123 {
2124   uint32_t i;
2125   float    f;
2126 } single_conv_t;
2127
2128 /* IMM8 is an 8-bit floating-point constant with sign, 3-bit exponent and
2129    normalized 4 bits of precision, encoded in "a:b:c:d:e:f:g:h" or FLD_imm8
2130    (depending on the type of the instruction).  IMM8 will be expanded to a
2131    single-precision floating-point value (IS_DP == 0) or a double-precision
2132    floating-point value (IS_DP == 1).  The expanded value is returned.  */
2133
2134 static uint64_t
2135 expand_fp_imm (int is_dp, uint32_t imm8)
2136 {
2137   uint64_t imm;
2138   uint32_t imm8_7, imm8_6_0, imm8_6, imm8_6_repl4;
2139
2140   imm8_7 = (imm8 >> 7) & 0x01;  /* imm8<7>   */
2141   imm8_6_0 = imm8 & 0x7f;       /* imm8<6:0> */
2142   imm8_6 = imm8_6_0 >> 6;       /* imm8<6>   */
2143   imm8_6_repl4 = (imm8_6 << 3) | (imm8_6 << 2)
2144     | (imm8_6 << 1) | imm8_6;   /* Replicate(imm8<6>,4) */
2145   if (is_dp)
2146     {
2147       imm = (imm8_7 << (63-32))         /* imm8<7>  */
2148         | ((imm8_6 ^ 1) << (62-32))     /* NOT(imm8<6)  */
2149         | (imm8_6_repl4 << (58-32)) | (imm8_6 << (57-32))
2150         | (imm8_6 << (56-32)) | (imm8_6 << (55-32)) /* Replicate(imm8<6>,7) */
2151         | (imm8_6_0 << (48-32));        /* imm8<6>:imm8<5:0>    */
2152       imm <<= 32;
2153     }
2154   else
2155     {
2156       imm = (imm8_7 << 31)      /* imm8<7>              */
2157         | ((imm8_6 ^ 1) << 30)  /* NOT(imm8<6>)         */
2158         | (imm8_6_repl4 << 26)  /* Replicate(imm8<6>,4) */
2159         | (imm8_6_0 << 19);     /* imm8<6>:imm8<5:0>    */
2160     }
2161
2162   return imm;
2163 }
2164
2165 /* Produce the string representation of the register list operand *OPND
2166    in the buffer pointed by BUF of size SIZE.  */
2167 static void
2168 print_register_list (char *buf, size_t size, const aarch64_opnd_info *opnd)
2169 {
2170   const int num_regs = opnd->reglist.num_regs;
2171   const int first_reg = opnd->reglist.first_regno;
2172   const int last_reg = (first_reg + num_regs - 1) & 0x1f;
2173   const char *qlf_name = aarch64_get_qualifier_name (opnd->qualifier);
2174   char tb[8];   /* Temporary buffer.  */
2175
2176   assert (opnd->type != AARCH64_OPND_LEt || opnd->reglist.has_index);
2177   assert (num_regs >= 1 && num_regs <= 4);
2178
2179   /* Prepare the index if any.  */
2180   if (opnd->reglist.has_index)
2181     snprintf (tb, 8, "[%d]", opnd->reglist.index);
2182   else
2183     tb[0] = '\0';
2184
2185   /* The hyphenated form is preferred for disassembly if there are
2186      more than two registers in the list, and the register numbers
2187      are monotonically increasing in increments of one.  */
2188   if (num_regs > 2 && last_reg > first_reg)
2189     snprintf (buf, size, "{v%d.%s-v%d.%s}%s", first_reg, qlf_name,
2190               last_reg, qlf_name, tb);
2191   else
2192     {
2193       const int reg0 = first_reg;
2194       const int reg1 = (first_reg + 1) & 0x1f;
2195       const int reg2 = (first_reg + 2) & 0x1f;
2196       const int reg3 = (first_reg + 3) & 0x1f;
2197
2198       switch (num_regs)
2199         {
2200         case 1:
2201           snprintf (buf, size, "{v%d.%s}%s", reg0, qlf_name, tb);
2202           break;
2203         case 2:
2204           snprintf (buf, size, "{v%d.%s, v%d.%s}%s", reg0, qlf_name,
2205                     reg1, qlf_name, tb);
2206           break;
2207         case 3:
2208           snprintf (buf, size, "{v%d.%s, v%d.%s, v%d.%s}%s", reg0, qlf_name,
2209                     reg1, qlf_name, reg2, qlf_name, tb);
2210           break;
2211         case 4:
2212           snprintf (buf, size, "{v%d.%s, v%d.%s, v%d.%s, v%d.%s}%s",
2213                     reg0, qlf_name, reg1, qlf_name, reg2, qlf_name,
2214                     reg3, qlf_name, tb);
2215           break;
2216         }
2217     }
2218 }
2219
2220 /* Produce the string representation of the register offset address operand
2221    *OPND in the buffer pointed by BUF of size SIZE.  */
2222 static void
2223 print_register_offset_address (char *buf, size_t size,
2224                                const aarch64_opnd_info *opnd)
2225 {
2226   const size_t tblen = 16;
2227   char tb[tblen];               /* Temporary buffer.  */
2228   bfd_boolean lsl_p = FALSE;    /* Is LSL shift operator?  */
2229   bfd_boolean wm_p = FALSE;     /* Should Rm be Wm?  */
2230   bfd_boolean print_extend_p = TRUE;
2231   bfd_boolean print_amount_p = TRUE;
2232   const char *shift_name = aarch64_operand_modifiers[opnd->shifter.kind].name;
2233
2234   switch (opnd->shifter.kind)
2235     {
2236     case AARCH64_MOD_UXTW: wm_p = TRUE; break;
2237     case AARCH64_MOD_LSL : lsl_p = TRUE; break;
2238     case AARCH64_MOD_SXTW: wm_p = TRUE; break;
2239     case AARCH64_MOD_SXTX: break;
2240     default: assert (0);
2241     }
2242
2243   if (!opnd->shifter.amount && (opnd->qualifier != AARCH64_OPND_QLF_S_B
2244                                 || !opnd->shifter.amount_present))
2245     {
2246       /* Not print the shift/extend amount when the amount is zero and
2247          when it is not the special case of 8-bit load/store instruction.  */
2248       print_amount_p = FALSE;
2249       /* Likewise, no need to print the shift operator LSL in such a
2250          situation.  */
2251       if (lsl_p)
2252         print_extend_p = FALSE;
2253     }
2254
2255   /* Prepare for the extend/shift.  */
2256   if (print_extend_p)
2257     {
2258       if (print_amount_p)
2259         snprintf (tb, tblen, ",%s #%d", shift_name, opnd->shifter.amount);
2260       else
2261         snprintf (tb, tblen, ",%s", shift_name);
2262     }
2263   else
2264     tb[0] = '\0';
2265
2266   snprintf (buf, size, "[%s,%c%d%s]",
2267             get_64bit_int_reg_name (opnd->addr.base_regno, 1),
2268             wm_p ? 'w' : 'x', opnd->addr.offset.regno, tb);
2269 }
2270
2271 /* Generate the string representation of the operand OPNDS[IDX] for OPCODE
2272    in *BUF.  The caller should pass in the maximum size of *BUF in SIZE.
2273    PC, PCREL_P and ADDRESS are used to pass in and return information about
2274    the PC-relative address calculation, where the PC value is passed in
2275    PC.  If the operand is pc-relative related, *PCREL_P (if PCREL_P non-NULL)
2276    will return 1 and *ADDRESS (if ADDRESS non-NULL) will return the
2277    calculated address; otherwise, *PCREL_P (if PCREL_P non-NULL) returns 0.
2278
2279    The function serves both the disassembler and the assembler diagnostics
2280    issuer, which is the reason why it lives in this file.  */
2281
2282 void
2283 aarch64_print_operand (char *buf, size_t size, bfd_vma pc,
2284                        const aarch64_opcode *opcode,
2285                        const aarch64_opnd_info *opnds, int idx, int *pcrel_p,
2286                        bfd_vma *address)
2287 {
2288   int i;
2289   const char *name = NULL;
2290   const aarch64_opnd_info *opnd = opnds + idx;
2291   enum aarch64_modifier_kind kind;
2292   uint64_t addr;
2293
2294   buf[0] = '\0';
2295   if (pcrel_p)
2296     *pcrel_p = 0;
2297
2298   switch (opnd->type)
2299     {
2300     case AARCH64_OPND_Rd:
2301     case AARCH64_OPND_Rn:
2302     case AARCH64_OPND_Rm:
2303     case AARCH64_OPND_Rt:
2304     case AARCH64_OPND_Rt2:
2305     case AARCH64_OPND_Rs:
2306     case AARCH64_OPND_Ra:
2307     case AARCH64_OPND_Rt_SYS:
2308       /* The optional-ness of <Xt> in e.g. IC <ic_op>{, <Xt>} is determined by
2309          the <ic_op>, therefore we we use opnd->present to override the
2310          generic optional-ness information.  */
2311       if (opnd->type == AARCH64_OPND_Rt_SYS && !opnd->present)
2312         break;
2313       /* Omit the operand, e.g. RET.  */
2314       if (optional_operand_p (opcode, idx)
2315           && opnd->reg.regno == get_optional_operand_default_value (opcode))
2316         break;
2317       assert (opnd->qualifier == AARCH64_OPND_QLF_W
2318               || opnd->qualifier == AARCH64_OPND_QLF_X);
2319       snprintf (buf, size, "%s",
2320                 get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0));
2321       break;
2322
2323     case AARCH64_OPND_Rd_SP:
2324     case AARCH64_OPND_Rn_SP:
2325       assert (opnd->qualifier == AARCH64_OPND_QLF_W
2326               || opnd->qualifier == AARCH64_OPND_QLF_WSP
2327               || opnd->qualifier == AARCH64_OPND_QLF_X
2328               || opnd->qualifier == AARCH64_OPND_QLF_SP);
2329       snprintf (buf, size, "%s",
2330                 get_int_reg_name (opnd->reg.regno, opnd->qualifier, 1));
2331       break;
2332
2333     case AARCH64_OPND_Rm_EXT:
2334       kind = opnd->shifter.kind;
2335       assert (idx == 1 || idx == 2);
2336       if ((aarch64_stack_pointer_p (opnds)
2337            || (idx == 2 && aarch64_stack_pointer_p (opnds + 1)))
2338           && ((opnd->qualifier == AARCH64_OPND_QLF_W
2339                && opnds[0].qualifier == AARCH64_OPND_QLF_W
2340                && kind == AARCH64_MOD_UXTW)
2341               || (opnd->qualifier == AARCH64_OPND_QLF_X
2342                   && kind == AARCH64_MOD_UXTX)))
2343         {
2344           /* 'LSL' is the preferred form in this case.  */
2345           kind = AARCH64_MOD_LSL;
2346           if (opnd->shifter.amount == 0)
2347             {
2348               /* Shifter omitted.  */
2349               snprintf (buf, size, "%s",
2350                         get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0));
2351               break;
2352             }
2353         }
2354       if (opnd->shifter.amount)
2355         snprintf (buf, size, "%s, %s #%d",
2356                   get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0),
2357                   aarch64_operand_modifiers[kind].name,
2358                   opnd->shifter.amount);
2359       else
2360         snprintf (buf, size, "%s, %s",
2361                   get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0),
2362                   aarch64_operand_modifiers[kind].name);
2363       break;
2364
2365     case AARCH64_OPND_Rm_SFT:
2366       assert (opnd->qualifier == AARCH64_OPND_QLF_W
2367               || opnd->qualifier == AARCH64_OPND_QLF_X);
2368       if (opnd->shifter.amount == 0 && opnd->shifter.kind == AARCH64_MOD_LSL)
2369         snprintf (buf, size, "%s",
2370                   get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0));
2371       else
2372         snprintf (buf, size, "%s, %s #%d",
2373                   get_int_reg_name (opnd->reg.regno, opnd->qualifier, 0),
2374                   aarch64_operand_modifiers[opnd->shifter.kind].name,
2375                   opnd->shifter.amount);
2376       break;
2377
2378     case AARCH64_OPND_Fd:
2379     case AARCH64_OPND_Fn:
2380     case AARCH64_OPND_Fm:
2381     case AARCH64_OPND_Fa:
2382     case AARCH64_OPND_Ft:
2383     case AARCH64_OPND_Ft2:
2384     case AARCH64_OPND_Sd:
2385     case AARCH64_OPND_Sn:
2386     case AARCH64_OPND_Sm:
2387       snprintf (buf, size, "%s%d", aarch64_get_qualifier_name (opnd->qualifier),
2388                 opnd->reg.regno);
2389       break;
2390
2391     case AARCH64_OPND_Vd:
2392     case AARCH64_OPND_Vn:
2393     case AARCH64_OPND_Vm:
2394       snprintf (buf, size, "v%d.%s", opnd->reg.regno,
2395                 aarch64_get_qualifier_name (opnd->qualifier));
2396       break;
2397
2398     case AARCH64_OPND_Ed:
2399     case AARCH64_OPND_En:
2400     case AARCH64_OPND_Em:
2401       snprintf (buf, size, "v%d.%s[%d]", opnd->reglane.regno,
2402                 aarch64_get_qualifier_name (opnd->qualifier),
2403                 opnd->reglane.index);
2404       break;
2405
2406     case AARCH64_OPND_VdD1:
2407     case AARCH64_OPND_VnD1:
2408       snprintf (buf, size, "v%d.d[1]", opnd->reg.regno);
2409       break;
2410
2411     case AARCH64_OPND_LVn:
2412     case AARCH64_OPND_LVt:
2413     case AARCH64_OPND_LVt_AL:
2414     case AARCH64_OPND_LEt:
2415       print_register_list (buf, size, opnd);
2416       break;
2417
2418     case AARCH64_OPND_Cn:
2419     case AARCH64_OPND_Cm:
2420       snprintf (buf, size, "C%d", opnd->reg.regno);
2421       break;
2422
2423     case AARCH64_OPND_IDX:
2424     case AARCH64_OPND_IMM:
2425     case AARCH64_OPND_WIDTH:
2426     case AARCH64_OPND_UIMM3_OP1:
2427     case AARCH64_OPND_UIMM3_OP2:
2428     case AARCH64_OPND_BIT_NUM:
2429     case AARCH64_OPND_IMM_VLSL:
2430     case AARCH64_OPND_IMM_VLSR:
2431     case AARCH64_OPND_SHLL_IMM:
2432     case AARCH64_OPND_IMM0:
2433     case AARCH64_OPND_IMMR:
2434     case AARCH64_OPND_IMMS:
2435     case AARCH64_OPND_FBITS:
2436     case AARCH64_OPND_IMM_MOV:
2437       snprintf (buf, size, "#%" PRIi64, opnd->imm.value);
2438       break;
2439
2440     case AARCH64_OPND_FPIMM0:
2441       snprintf (buf, size, "#0.0");
2442       break;
2443
2444     case AARCH64_OPND_LIMM:
2445     case AARCH64_OPND_AIMM:
2446     case AARCH64_OPND_HALF:
2447       if (opnd->shifter.amount)
2448         snprintf (buf, size, "#0x%" PRIx64 ", lsl #%d", opnd->imm.value,
2449                   opnd->shifter.amount);
2450       else
2451         snprintf (buf, size, "#0x%" PRIx64, opnd->imm.value);
2452       break;
2453
2454     case AARCH64_OPND_SIMD_IMM:
2455     case AARCH64_OPND_SIMD_IMM_SFT:
2456       if ((! opnd->shifter.amount && opnd->shifter.kind == AARCH64_MOD_LSL)
2457           || opnd->shifter.kind == AARCH64_MOD_NONE)
2458         snprintf (buf, size, "#0x%" PRIx64, opnd->imm.value);
2459       else
2460         snprintf (buf, size, "#0x%" PRIx64 ", %s #%d", opnd->imm.value,
2461                   aarch64_operand_modifiers[opnd->shifter.kind].name,
2462                   opnd->shifter.amount);
2463       break;
2464
2465     case AARCH64_OPND_FPIMM:
2466     case AARCH64_OPND_SIMD_FPIMM:
2467       switch (aarch64_get_qualifier_esize (opnds[0].qualifier))
2468         {
2469         case 4: /* e.g. FMOV <Vd>.4S, #<imm>.  */
2470             {
2471               single_conv_t c;
2472               c.i = expand_fp_imm (0, opnd->imm.value);
2473               snprintf (buf, size,  "#%.18e", c.f);
2474             }
2475           break;
2476         case 8: /* e.g. FMOV <Sd>, #<imm>.  */
2477             {
2478               double_conv_t c;
2479               c.i = expand_fp_imm (1, opnd->imm.value);
2480               snprintf (buf, size,  "#%.18e", c.d);
2481             }
2482           break;
2483         default: assert (0);
2484         }
2485       break;
2486
2487     case AARCH64_OPND_CCMP_IMM:
2488     case AARCH64_OPND_NZCV:
2489     case AARCH64_OPND_EXCEPTION:
2490     case AARCH64_OPND_UIMM4:
2491     case AARCH64_OPND_UIMM7:
2492       if (optional_operand_p (opcode, idx) == TRUE
2493           && (opnd->imm.value ==
2494               (int64_t) get_optional_operand_default_value (opcode)))
2495         /* Omit the operand, e.g. DCPS1.  */
2496         break;
2497       snprintf (buf, size, "#0x%x", (unsigned int)opnd->imm.value);
2498       break;
2499
2500     case AARCH64_OPND_COND:
2501       snprintf (buf, size, "%s", opnd->cond->names[0]);
2502       break;
2503
2504     case AARCH64_OPND_ADDR_ADRP:
2505       addr = ((pc + AARCH64_PCREL_OFFSET) & ~(uint64_t)0xfff)
2506         + opnd->imm.value;
2507       if (pcrel_p)
2508         *pcrel_p = 1;
2509       if (address)
2510         *address = addr;
2511       /* This is not necessary during the disassembling, as print_address_func
2512          in the disassemble_info will take care of the printing.  But some
2513          other callers may be still interested in getting the string in *STR,
2514          so here we do snprintf regardless.  */
2515       snprintf (buf, size, "#0x%" PRIx64, addr);
2516       break;
2517
2518     case AARCH64_OPND_ADDR_PCREL14:
2519     case AARCH64_OPND_ADDR_PCREL19:
2520     case AARCH64_OPND_ADDR_PCREL21:
2521     case AARCH64_OPND_ADDR_PCREL26:
2522       addr = pc + AARCH64_PCREL_OFFSET + opnd->imm.value;
2523       if (pcrel_p)
2524         *pcrel_p = 1;
2525       if (address)
2526         *address = addr;
2527       /* This is not necessary during the disassembling, as print_address_func
2528          in the disassemble_info will take care of the printing.  But some
2529          other callers may be still interested in getting the string in *STR,
2530          so here we do snprintf regardless.  */
2531       snprintf (buf, size, "#0x%" PRIx64, addr);
2532       break;
2533
2534     case AARCH64_OPND_ADDR_SIMPLE:
2535     case AARCH64_OPND_SIMD_ADDR_SIMPLE:
2536     case AARCH64_OPND_SIMD_ADDR_POST:
2537       name = get_64bit_int_reg_name (opnd->addr.base_regno, 1);
2538       if (opnd->type == AARCH64_OPND_SIMD_ADDR_POST)
2539         {
2540           if (opnd->addr.offset.is_reg)
2541             snprintf (buf, size, "[%s], x%d", name, opnd->addr.offset.regno);
2542           else
2543             snprintf (buf, size, "[%s], #%d", name, opnd->addr.offset.imm);
2544         }
2545       else
2546         snprintf (buf, size, "[%s]", name);
2547       break;
2548
2549     case AARCH64_OPND_ADDR_REGOFF:
2550       print_register_offset_address (buf, size, opnd);
2551       break;
2552
2553     case AARCH64_OPND_ADDR_SIMM7:
2554     case AARCH64_OPND_ADDR_SIMM9:
2555     case AARCH64_OPND_ADDR_SIMM9_2:
2556       name = get_64bit_int_reg_name (opnd->addr.base_regno, 1);
2557       if (opnd->addr.writeback)
2558         {
2559           if (opnd->addr.preind)
2560             snprintf (buf, size, "[%s,#%d]!", name, opnd->addr.offset.imm);
2561           else
2562             snprintf (buf, size, "[%s],#%d", name, opnd->addr.offset.imm);
2563         }
2564       else
2565         {
2566           if (opnd->addr.offset.imm)
2567             snprintf (buf, size, "[%s,#%d]", name, opnd->addr.offset.imm);
2568           else
2569             snprintf (buf, size, "[%s]", name);
2570         }
2571       break;
2572
2573     case AARCH64_OPND_ADDR_UIMM12:
2574       name = get_64bit_int_reg_name (opnd->addr.base_regno, 1);
2575       if (opnd->addr.offset.imm)
2576         snprintf (buf, size, "[%s,#%d]", name, opnd->addr.offset.imm);
2577       else
2578         snprintf (buf, size, "[%s]", name);
2579       break;
2580
2581     case AARCH64_OPND_SYSREG:
2582       for (i = 0; aarch64_sys_regs[i].name; ++i)
2583         if (aarch64_sys_regs[i].value == opnd->sysreg)
2584           break;
2585       if (aarch64_sys_regs[i].name)
2586         snprintf (buf, size, "%s", aarch64_sys_regs[i].name);
2587       else
2588         {
2589           /* Implementation defined system register.  */
2590           unsigned int value = opnd->sysreg;
2591           snprintf (buf, size, "s%u_%u_c%u_c%u_%u", (value >> 14) & 0x3,
2592                     (value >> 11) & 0x7, (value >> 7) & 0xf, (value >> 3) & 0xf,
2593                     value & 0x7);
2594         }
2595       break;
2596
2597     case AARCH64_OPND_PSTATEFIELD:
2598       for (i = 0; aarch64_pstatefields[i].name; ++i)
2599         if (aarch64_pstatefields[i].value == opnd->pstatefield)
2600           break;
2601       assert (aarch64_pstatefields[i].name);
2602       snprintf (buf, size, "%s", aarch64_pstatefields[i].name);
2603       break;
2604
2605     case AARCH64_OPND_SYSREG_AT:
2606     case AARCH64_OPND_SYSREG_DC:
2607     case AARCH64_OPND_SYSREG_IC:
2608     case AARCH64_OPND_SYSREG_TLBI:
2609       snprintf (buf, size, "%s", opnd->sysins_op->template);
2610       break;
2611
2612     case AARCH64_OPND_BARRIER:
2613       snprintf (buf, size, "%s", opnd->barrier->name);
2614       break;
2615
2616     case AARCH64_OPND_BARRIER_ISB:
2617       /* Operand can be omitted, e.g. in DCPS1.  */
2618       if (! optional_operand_p (opcode, idx)
2619           || (opnd->barrier->value
2620               != get_optional_operand_default_value (opcode)))
2621         snprintf (buf, size, "#0x%x", opnd->barrier->value);
2622       break;
2623
2624     case AARCH64_OPND_PRFOP:
2625       snprintf (buf, size, "%s", opnd->prfop->name);
2626       break;
2627
2628     default:
2629       assert (0);
2630     }
2631 }
2632 \f
2633 #define CPENC(op0,op1,crn,crm,op2) \
2634   ((((op0) << 19) | ((op1) << 16) | ((crn) << 12) | ((crm) << 8) | ((op2) << 5)) >> 5)
2635   /* for 3.9.3 Instructions for Accessing Special Purpose Registers */
2636 #define CPEN_(op1,crm,op2) CPENC(3,(op1),4,(crm),(op2))
2637   /* for 3.9.10 System Instructions */
2638 #define CPENS(op1,crn,crm,op2) CPENC(1,(op1),(crn),(crm),(op2))
2639
2640 #define C0  0
2641 #define C1  1
2642 #define C2  2
2643 #define C3  3
2644 #define C4  4
2645 #define C5  5
2646 #define C6  6
2647 #define C7  7
2648 #define C8  8
2649 #define C9  9
2650 #define C10 10
2651 #define C11 11
2652 #define C12 12
2653 #define C13 13
2654 #define C14 14
2655 #define C15 15
2656
2657 /* TODO there are two more issues need to be resolved
2658    1. handle read-only and write-only system registers
2659    2. handle cpu-implementation-defined system registers.  */
2660 const struct aarch64_name_value_pair aarch64_sys_regs [] =
2661 {
2662   { "spsr_el1",         CPEN_(0,C0,0)  }, /* = spsr_svc */
2663   { "elr_el1",          CPEN_(0,C0,1)  },
2664   { "sp_el0",           CPEN_(0,C1,0)  },
2665   { "spsel",            CPEN_(0,C2,0)  },
2666   { "daif",             CPEN_(3,C2,1)  },
2667   { "currentel",        CPEN_(0,C2,2)  }, /* RO */
2668   { "nzcv",             CPEN_(3,C2,0)  },
2669   { "fpcr",             CPEN_(3,C4,0)  },
2670   { "fpsr",             CPEN_(3,C4,1)  },
2671   { "dspsr_el0",        CPEN_(3,C5,0)  },
2672   { "dlr_el0",          CPEN_(3,C5,1)  },
2673   { "spsr_el2",         CPEN_(4,C0,0)  }, /* = spsr_hyp */
2674   { "elr_el2",          CPEN_(4,C0,1)  },
2675   { "sp_el1",           CPEN_(4,C1,0)  },
2676   { "spsr_irq",         CPEN_(4,C3,0)  },
2677   { "spsr_abt",         CPEN_(4,C3,1)  },
2678   { "spsr_und",         CPEN_(4,C3,2)  },
2679   { "spsr_fiq",         CPEN_(4,C3,3)  },
2680   { "spsr_el3",         CPEN_(6,C0,0)  },
2681   { "elr_el3",          CPEN_(6,C0,1)  },
2682   { "sp_el2",           CPEN_(6,C1,0)  },
2683   { "spsr_svc",         CPEN_(0,C0,0)  }, /* = spsr_el1 */
2684   { "spsr_hyp",         CPEN_(4,C0,0)  }, /* = spsr_el2 */
2685   { "midr_el1",         CPENC(3,0,C0,C0,0)  }, /* RO */
2686   { "ctr_el0",          CPENC(3,3,C0,C0,1)  }, /* RO */
2687   { "mpidr_el1",        CPENC(3,0,C0,C0,5)  }, /* RO */
2688   { "revidr_el1",       CPENC(3,0,C0,C0,6)  }, /* RO */
2689   { "aidr_el1",         CPENC(3,1,C0,C0,7)  }, /* RO */
2690   { "dczid_el0",        CPENC(3,3,C0,C0,7)  }, /* RO */
2691   { "id_dfr0_el1",      CPENC(3,0,C0,C1,2)  }, /* RO */
2692   { "id_pfr0_el1",      CPENC(3,0,C0,C1,0)  }, /* RO */
2693   { "id_pfr1_el1",      CPENC(3,0,C0,C1,1)  }, /* RO */
2694   { "id_afr0_el1",      CPENC(3,0,C0,C1,3)  }, /* RO */
2695   { "id_mmfr0_el1",     CPENC(3,0,C0,C1,4)  }, /* RO */
2696   { "id_mmfr1_el1",     CPENC(3,0,C0,C1,5)  }, /* RO */
2697   { "id_mmfr2_el1",     CPENC(3,0,C0,C1,6)  }, /* RO */
2698   { "id_mmfr3_el1",     CPENC(3,0,C0,C1,7)  }, /* RO */
2699   { "id_isar0_el1",     CPENC(3,0,C0,C2,0)  }, /* RO */
2700   { "id_isar1_el1",     CPENC(3,0,C0,C2,1)  }, /* RO */
2701   { "id_isar2_el1",     CPENC(3,0,C0,C2,2)  }, /* RO */
2702   { "id_isar3_el1",     CPENC(3,0,C0,C2,3)  }, /* RO */
2703   { "id_isar4_el1",     CPENC(3,0,C0,C2,4)  }, /* RO */
2704   { "id_isar5_el1",     CPENC(3,0,C0,C2,5)  }, /* RO */
2705   { "mvfr0_el1",        CPENC(3,0,C0,C3,0)  }, /* RO */
2706   { "mvfr1_el1",        CPENC(3,0,C0,C3,1)  }, /* RO */
2707   { "mvfr2_el1",        CPENC(3,0,C0,C3,2)  }, /* RO */
2708   { "ccsidr_el1",       CPENC(3,1,C0,C0,0)  }, /* RO */
2709   { "id_aa64pfr0_el1",  CPENC(3,0,C0,C4,0)  }, /* RO */
2710   { "id_aa64pfr1_el1",  CPENC(3,0,C0,C4,1)  }, /* RO */
2711   { "id_aa64dfr0_el1",  CPENC(3,0,C0,C5,0)  }, /* RO */
2712   { "id_aa64dfr1_el1",  CPENC(3,0,C0,C5,1)  }, /* RO */
2713   { "id_aa64isar0_el1", CPENC(3,0,C0,C6,0)  }, /* RO */
2714   { "id_aa64isar1_el1", CPENC(3,0,C0,C6,1)  }, /* RO */
2715   { "id_aa64mmfr0_el1", CPENC(3,0,C0,C7,0)  }, /* RO */
2716   { "id_aa64mmfr1_el1", CPENC(3,0,C0,C7,1)  }, /* RO */
2717   { "id_aa64afr0_el1",  CPENC(3,0,C0,C5,4)  }, /* RO */
2718   { "id_aa64afr1_el1",  CPENC(3,0,C0,C5,5)  }, /* RO */
2719   { "clidr_el1",        CPENC(3,1,C0,C0,1)  }, /* RO */
2720   { "csselr_el1",       CPENC(3,2,C0,C0,0)  }, /* RO */
2721   { "vpidr_el2",        CPENC(3,4,C0,C0,0)  },
2722   { "vmpidr_el2",       CPENC(3,4,C0,C0,5)  },
2723   { "sctlr_el1",        CPENC(3,0,C1,C0,0)  },
2724   { "sctlr_el2",        CPENC(3,4,C1,C0,0)  },
2725   { "sctlr_el3",        CPENC(3,6,C1,C0,0)  },
2726   { "actlr_el1",        CPENC(3,0,C1,C0,1)  },
2727   { "actlr_el2",        CPENC(3,4,C1,C0,1)  },
2728   { "actlr_el3",        CPENC(3,6,C1,C0,1)  },
2729   { "cpacr_el1",        CPENC(3,0,C1,C0,2)  },
2730   { "cptr_el2",         CPENC(3,4,C1,C1,2)  },
2731   { "cptr_el3",         CPENC(3,6,C1,C1,2)  },
2732   { "scr_el3",          CPENC(3,6,C1,C1,0)  },
2733   { "hcr_el2",          CPENC(3,4,C1,C1,0)  },
2734   { "mdcr_el2",         CPENC(3,4,C1,C1,1)  },
2735   { "mdcr_el3",         CPENC(3,6,C1,C3,1)  },
2736   { "hstr_el2",         CPENC(3,4,C1,C1,3)  },
2737   { "hacr_el2",         CPENC(3,4,C1,C1,7)  },
2738   { "ttbr0_el1",        CPENC(3,0,C2,C0,0)  },
2739   { "ttbr1_el1",        CPENC(3,0,C2,C0,1)  },
2740   { "ttbr0_el2",        CPENC(3,4,C2,C0,0)  },
2741   { "ttbr0_el3",        CPENC(3,6,C2,C0,0)  },
2742   { "vttbr_el2",        CPENC(3,4,C2,C1,0)  },
2743   { "tcr_el1",          CPENC(3,0,C2,C0,2)  },
2744   { "tcr_el2",          CPENC(3,4,C2,C0,2)  },
2745   { "tcr_el3",          CPENC(3,6,C2,C0,2)  },
2746   { "vtcr_el2",         CPENC(3,4,C2,C1,2)  },
2747   { "afsr0_el1",        CPENC(3,0,C5,C1,0)  },
2748   { "afsr1_el1",        CPENC(3,0,C5,C1,1)  },
2749   { "afsr0_el2",        CPENC(3,4,C5,C1,0)  },
2750   { "afsr1_el2",        CPENC(3,4,C5,C1,1)  },
2751   { "afsr0_el3",        CPENC(3,6,C5,C1,0)  },
2752   { "afsr1_el3",        CPENC(3,6,C5,C1,1)  },
2753   { "esr_el1",          CPENC(3,0,C5,C2,0)  },
2754   { "esr_el2",          CPENC(3,4,C5,C2,0)  },
2755   { "esr_el3",          CPENC(3,6,C5,C2,0)  },
2756   { "fpexc32_el2",      CPENC(3,4,C5,C3,0)  },
2757   { "far_el1",          CPENC(3,0,C6,C0,0)  },
2758   { "far_el2",          CPENC(3,4,C6,C0,0)  },
2759   { "far_el3",          CPENC(3,6,C6,C0,0)  },
2760   { "hpfar_el2",        CPENC(3,4,C6,C0,4)  },
2761   { "par_el1",          CPENC(3,0,C7,C4,0)  },
2762   { "mair_el1",         CPENC(3,0,C10,C2,0) },
2763   { "mair_el2",         CPENC(3,4,C10,C2,0) },
2764   { "mair_el3",         CPENC(3,6,C10,C2,0) },
2765   { "amair_el1",        CPENC(3,0,C10,C3,0) },
2766   { "amair_el2",        CPENC(3,4,C10,C3,0) },
2767   { "amair_el3",        CPENC(3,6,C10,C3,0) },
2768   { "vbar_el1",         CPENC(3,0,C12,C0,0) },
2769   { "vbar_el2",         CPENC(3,4,C12,C0,0) },
2770   { "vbar_el3",         CPENC(3,6,C12,C0,0) },
2771   { "rvbar_el1",        CPENC(3,0,C12,C0,1) }, /* RO */
2772   { "rvbar_el2",        CPENC(3,4,C12,C0,1) }, /* RO */
2773   { "rvbar_el3",        CPENC(3,6,C12,C0,1) }, /* RO */
2774   { "isr_el1",          CPENC(3,0,C12,C1,0) }, /* RO */
2775   { "contextidr_el1",   CPENC(3,0,C13,C0,1) },
2776   { "tpidr_el0",        CPENC(3,3,C13,C0,2) },
2777   { "tpidrro_el0",      CPENC(3,3,C13,C0,3) }, /* RO */
2778   { "tpidr_el1",        CPENC(3,0,C13,C0,4) },
2779   { "tpidr_el2",        CPENC(3,4,C13,C0,2) },
2780   { "tpidr_el3",        CPENC(3,6,C13,C0,2) },
2781   { "teecr32_el1",      CPENC(2,2,C0, C0,0) }, /* See section 3.9.7.1 */
2782   { "cntfrq_el0",       CPENC(3,3,C14,C0,0) }, /* RO */
2783   { "cntpct_el0",       CPENC(3,3,C14,C0,1) }, /* RO */
2784   { "cntvct_el0",       CPENC(3,3,C14,C0,2) }, /* RO */
2785   { "cntvoff_el2",      CPENC(3,4,C14,C0,3) },
2786   { "cntkctl_el1",      CPENC(3,0,C14,C1,0) },
2787   { "cnthctl_el2",      CPENC(3,4,C14,C1,0) },
2788   { "cntp_tval_el0",    CPENC(3,3,C14,C2,0) },
2789   { "cntp_ctl_el0",     CPENC(3,3,C14,C2,1) },
2790   { "cntp_cval_el0",    CPENC(3,3,C14,C2,2) },
2791   { "cntv_tval_el0",    CPENC(3,3,C14,C3,0) },
2792   { "cntv_ctl_el0",     CPENC(3,3,C14,C3,1) },
2793   { "cntv_cval_el0",    CPENC(3,3,C14,C3,2) },
2794   { "cnthp_tval_el2",   CPENC(3,4,C14,C2,0) },
2795   { "cnthp_ctl_el2",    CPENC(3,4,C14,C2,1) },
2796   { "cnthp_cval_el2",   CPENC(3,4,C14,C2,2) },
2797   { "cntps_tval_el1",   CPENC(3,7,C14,C2,0) },
2798   { "cntps_ctl_el1",    CPENC(3,7,C14,C2,1) },
2799   { "cntps_cval_el1",   CPENC(3,7,C14,C2,2) },
2800   { "dacr32_el2",       CPENC(3,4,C3,C0,0)  },
2801   { "ifsr32_el2",       CPENC(3,4,C5,C0,1)  },
2802   { "teehbr32_el1",     CPENC(2,2,C1,C0,0)  },
2803   { "sder32_el3",       CPENC(3,6,C1,C1,1)  },
2804   { "mdscr_el1",         CPENC(2,0,C0, C2, 2) },
2805   { "mdccsr_el0",        CPENC(2,3,C0, C1, 0) },  /* r */
2806   { "mdccint_el1",       CPENC(2,0,C0, C2, 0) },
2807   { "dbgdtr_el0",        CPENC(2,3,C0, C4, 0) },
2808   { "dbgdtrrx_el0",      CPENC(2,3,C0, C5, 0) },  /* r */
2809   { "dbgdtrtx_el0",      CPENC(2,3,C0, C5, 0) },  /* w */
2810   { "osdtrrx_el1",       CPENC(2,0,C0, C0, 2) },  /* r */
2811   { "osdtrtx_el1",       CPENC(2,0,C0, C3, 2) },  /* w */
2812   { "oseccr_el1",        CPENC(2,0,C0, C6, 2) },
2813   { "dbgvcr32_el2",      CPENC(2,4,C0, C7, 0) },
2814   { "dbgbvr0_el1",       CPENC(2,0,C0, C0, 4) },
2815   { "dbgbvr1_el1",       CPENC(2,0,C0, C1, 4) },
2816   { "dbgbvr2_el1",       CPENC(2,0,C0, C2, 4) },
2817   { "dbgbvr3_el1",       CPENC(2,0,C0, C3, 4) },
2818   { "dbgbvr4_el1",       CPENC(2,0,C0, C4, 4) },
2819   { "dbgbvr5_el1",       CPENC(2,0,C0, C5, 4) },
2820   { "dbgbvr6_el1",       CPENC(2,0,C0, C6, 4) },
2821   { "dbgbvr7_el1",       CPENC(2,0,C0, C7, 4) },
2822   { "dbgbvr8_el1",       CPENC(2,0,C0, C8, 4) },
2823   { "dbgbvr9_el1",       CPENC(2,0,C0, C9, 4) },
2824   { "dbgbvr10_el1",      CPENC(2,0,C0, C10,4) },
2825   { "dbgbvr11_el1",      CPENC(2,0,C0, C11,4) },
2826   { "dbgbvr12_el1",      CPENC(2,0,C0, C12,4) },
2827   { "dbgbvr13_el1",      CPENC(2,0,C0, C13,4) },
2828   { "dbgbvr14_el1",      CPENC(2,0,C0, C14,4) },
2829   { "dbgbvr15_el1",      CPENC(2,0,C0, C15,4) },
2830   { "dbgbcr0_el1",       CPENC(2,0,C0, C0, 5) },
2831   { "dbgbcr1_el1",       CPENC(2,0,C0, C1, 5) },
2832   { "dbgbcr2_el1",       CPENC(2,0,C0, C2, 5) },
2833   { "dbgbcr3_el1",       CPENC(2,0,C0, C3, 5) },
2834   { "dbgbcr4_el1",       CPENC(2,0,C0, C4, 5) },
2835   { "dbgbcr5_el1",       CPENC(2,0,C0, C5, 5) },
2836   { "dbgbcr6_el1",       CPENC(2,0,C0, C6, 5) },
2837   { "dbgbcr7_el1",       CPENC(2,0,C0, C7, 5) },
2838   { "dbgbcr8_el1",       CPENC(2,0,C0, C8, 5) },
2839   { "dbgbcr9_el1",       CPENC(2,0,C0, C9, 5) },
2840   { "dbgbcr10_el1",      CPENC(2,0,C0, C10,5) },
2841   { "dbgbcr11_el1",      CPENC(2,0,C0, C11,5) },
2842   { "dbgbcr12_el1",      CPENC(2,0,C0, C12,5) },
2843   { "dbgbcr13_el1",      CPENC(2,0,C0, C13,5) },
2844   { "dbgbcr14_el1",      CPENC(2,0,C0, C14,5) },
2845   { "dbgbcr15_el1",      CPENC(2,0,C0, C15,5) },
2846   { "dbgwvr0_el1",       CPENC(2,0,C0, C0, 6) },
2847   { "dbgwvr1_el1",       CPENC(2,0,C0, C1, 6) },
2848   { "dbgwvr2_el1",       CPENC(2,0,C0, C2, 6) },
2849   { "dbgwvr3_el1",       CPENC(2,0,C0, C3, 6) },
2850   { "dbgwvr4_el1",       CPENC(2,0,C0, C4, 6) },
2851   { "dbgwvr5_el1",       CPENC(2,0,C0, C5, 6) },
2852   { "dbgwvr6_el1",       CPENC(2,0,C0, C6, 6) },
2853   { "dbgwvr7_el1",       CPENC(2,0,C0, C7, 6) },
2854   { "dbgwvr8_el1",       CPENC(2,0,C0, C8, 6) },
2855   { "dbgwvr9_el1",       CPENC(2,0,C0, C9, 6) },
2856   { "dbgwvr10_el1",      CPENC(2,0,C0, C10,6) },
2857   { "dbgwvr11_el1",      CPENC(2,0,C0, C11,6) },
2858   { "dbgwvr12_el1",      CPENC(2,0,C0, C12,6) },
2859   { "dbgwvr13_el1",      CPENC(2,0,C0, C13,6) },
2860   { "dbgwvr14_el1",      CPENC(2,0,C0, C14,6) },
2861   { "dbgwvr15_el1",      CPENC(2,0,C0, C15,6) },
2862   { "dbgwcr0_el1",       CPENC(2,0,C0, C0, 7) },
2863   { "dbgwcr1_el1",       CPENC(2,0,C0, C1, 7) },
2864   { "dbgwcr2_el1",       CPENC(2,0,C0, C2, 7) },
2865   { "dbgwcr3_el1",       CPENC(2,0,C0, C3, 7) },
2866   { "dbgwcr4_el1",       CPENC(2,0,C0, C4, 7) },
2867   { "dbgwcr5_el1",       CPENC(2,0,C0, C5, 7) },
2868   { "dbgwcr6_el1",       CPENC(2,0,C0, C6, 7) },
2869   { "dbgwcr7_el1",       CPENC(2,0,C0, C7, 7) },
2870   { "dbgwcr8_el1",       CPENC(2,0,C0, C8, 7) },
2871   { "dbgwcr9_el1",       CPENC(2,0,C0, C9, 7) },
2872   { "dbgwcr10_el1",      CPENC(2,0,C0, C10,7) },
2873   { "dbgwcr11_el1",      CPENC(2,0,C0, C11,7) },
2874   { "dbgwcr12_el1",      CPENC(2,0,C0, C12,7) },
2875   { "dbgwcr13_el1",      CPENC(2,0,C0, C13,7) },
2876   { "dbgwcr14_el1",      CPENC(2,0,C0, C14,7) },
2877   { "dbgwcr15_el1",      CPENC(2,0,C0, C15,7) },
2878   { "mdrar_el1",         CPENC(2,0,C1, C0, 0) },  /* r */
2879   { "oslar_el1",         CPENC(2,0,C1, C0, 4) },  /* w */
2880   { "oslsr_el1",         CPENC(2,0,C1, C1, 4) },  /* r */
2881   { "osdlr_el1",         CPENC(2,0,C1, C3, 4) },
2882   { "dbgprcr_el1",       CPENC(2,0,C1, C4, 4) },
2883   { "dbgclaimset_el1",   CPENC(2,0,C7, C8, 6) },
2884   { "dbgclaimclr_el1",   CPENC(2,0,C7, C9, 6) },
2885   { "dbgauthstatus_el1", CPENC(2,0,C7, C14,6) },  /* r */
2886
2887   { "pmcr_el0",          CPENC(3,3,C9,C12, 0) },
2888   { "pmcntenset_el0",    CPENC(3,3,C9,C12, 1) },
2889   { "pmcntenclr_el0",    CPENC(3,3,C9,C12, 2) },
2890   { "pmovsclr_el0",      CPENC(3,3,C9,C12, 3) },
2891   { "pmswinc_el0",       CPENC(3,3,C9,C12, 4) },  /* w */
2892   { "pmselr_el0",        CPENC(3,3,C9,C12, 5) },
2893   { "pmceid0_el0",       CPENC(3,3,C9,C12, 6) },  /* r */
2894   { "pmceid1_el0",       CPENC(3,3,C9,C12, 7) },  /* r */
2895   { "pmccntr_el0",       CPENC(3,3,C9,C13, 0) },
2896   { "pmxevtyper_el0",    CPENC(3,3,C9,C13, 1) },
2897   { "pmxevcntr_el0",     CPENC(3,3,C9,C13, 2) },
2898   { "pmuserenr_el0",     CPENC(3,3,C9,C14, 0) },
2899   { "pmintenset_el1",    CPENC(3,0,C9,C14, 1) },
2900   { "pmintenclr_el1",    CPENC(3,0,C9,C14, 2) },
2901   { "pmovsset_el0",      CPENC(3,3,C9,C14, 3) },
2902   { "pmevcntr0_el0",     CPENC(3,3,C14,C8, 0) },
2903   { "pmevcntr1_el0",     CPENC(3,3,C14,C8, 1) },
2904   { "pmevcntr2_el0",     CPENC(3,3,C14,C8, 2) },
2905   { "pmevcntr3_el0",     CPENC(3,3,C14,C8, 3) },
2906   { "pmevcntr4_el0",     CPENC(3,3,C14,C8, 4) },
2907   { "pmevcntr5_el0",     CPENC(3,3,C14,C8, 5) },
2908   { "pmevcntr6_el0",     CPENC(3,3,C14,C8, 6) },
2909   { "pmevcntr7_el0",     CPENC(3,3,C14,C8, 7) },
2910   { "pmevcntr8_el0",     CPENC(3,3,C14,C9, 0) },
2911   { "pmevcntr9_el0",     CPENC(3,3,C14,C9, 1) },
2912   { "pmevcntr10_el0",    CPENC(3,3,C14,C9, 2) },
2913   { "pmevcntr11_el0",    CPENC(3,3,C14,C9, 3) },
2914   { "pmevcntr12_el0",    CPENC(3,3,C14,C9, 4) },
2915   { "pmevcntr13_el0",    CPENC(3,3,C14,C9, 5) },
2916   { "pmevcntr14_el0",    CPENC(3,3,C14,C9, 6) },
2917   { "pmevcntr15_el0",    CPENC(3,3,C14,C9, 7) },
2918   { "pmevcntr16_el0",    CPENC(3,3,C14,C10,0) },
2919   { "pmevcntr17_el0",    CPENC(3,3,C14,C10,1) },
2920   { "pmevcntr18_el0",    CPENC(3,3,C14,C10,2) },
2921   { "pmevcntr19_el0",    CPENC(3,3,C14,C10,3) },
2922   { "pmevcntr20_el0",    CPENC(3,3,C14,C10,4) },
2923   { "pmevcntr21_el0",    CPENC(3,3,C14,C10,5) },
2924   { "pmevcntr22_el0",    CPENC(3,3,C14,C10,6) },
2925   { "pmevcntr23_el0",    CPENC(3,3,C14,C10,7) },
2926   { "pmevcntr24_el0",    CPENC(3,3,C14,C11,0) },
2927   { "pmevcntr25_el0",    CPENC(3,3,C14,C11,1) },
2928   { "pmevcntr26_el0",    CPENC(3,3,C14,C11,2) },
2929   { "pmevcntr27_el0",    CPENC(3,3,C14,C11,3) },
2930   { "pmevcntr28_el0",    CPENC(3,3,C14,C11,4) },
2931   { "pmevcntr29_el0",    CPENC(3,3,C14,C11,5) },
2932   { "pmevcntr30_el0",    CPENC(3,3,C14,C11,6) },
2933   { "pmevtyper0_el0",    CPENC(3,3,C14,C12,0) },
2934   { "pmevtyper1_el0",    CPENC(3,3,C14,C12,1) },
2935   { "pmevtyper2_el0",    CPENC(3,3,C14,C12,2) },
2936   { "pmevtyper3_el0",    CPENC(3,3,C14,C12,3) },
2937   { "pmevtyper4_el0",    CPENC(3,3,C14,C12,4) },
2938   { "pmevtyper5_el0",    CPENC(3,3,C14,C12,5) },
2939   { "pmevtyper6_el0",    CPENC(3,3,C14,C12,6) },
2940   { "pmevtyper7_el0",    CPENC(3,3,C14,C12,7) },
2941   { "pmevtyper8_el0",    CPENC(3,3,C14,C13,0) },
2942   { "pmevtyper9_el0",    CPENC(3,3,C14,C13,1) },
2943   { "pmevtyper10_el0",   CPENC(3,3,C14,C13,2) },
2944   { "pmevtyper11_el0",   CPENC(3,3,C14,C13,3) },
2945   { "pmevtyper12_el0",   CPENC(3,3,C14,C13,4) },
2946   { "pmevtyper13_el0",   CPENC(3,3,C14,C13,5) },
2947   { "pmevtyper14_el0",   CPENC(3,3,C14,C13,6) },
2948   { "pmevtyper15_el0",   CPENC(3,3,C14,C13,7) },
2949   { "pmevtyper16_el0",   CPENC(3,3,C14,C14,0) },
2950   { "pmevtyper17_el0",   CPENC(3,3,C14,C14,1) },
2951   { "pmevtyper18_el0",   CPENC(3,3,C14,C14,2) },
2952   { "pmevtyper19_el0",   CPENC(3,3,C14,C14,3) },
2953   { "pmevtyper20_el0",   CPENC(3,3,C14,C14,4) },
2954   { "pmevtyper21_el0",   CPENC(3,3,C14,C14,5) },
2955   { "pmevtyper22_el0",   CPENC(3,3,C14,C14,6) },
2956   { "pmevtyper23_el0",   CPENC(3,3,C14,C14,7) },
2957   { "pmevtyper24_el0",   CPENC(3,3,C14,C15,0) },
2958   { "pmevtyper25_el0",   CPENC(3,3,C14,C15,1) },
2959   { "pmevtyper26_el0",   CPENC(3,3,C14,C15,2) },
2960   { "pmevtyper27_el0",   CPENC(3,3,C14,C15,3) },
2961   { "pmevtyper28_el0",   CPENC(3,3,C14,C15,4) },
2962   { "pmevtyper29_el0",   CPENC(3,3,C14,C15,5) },
2963   { "pmevtyper30_el0",   CPENC(3,3,C14,C15,6) },
2964   { "pmccfiltr_el0",     CPENC(3,3,C14,C15,7) },
2965
2966   { "daifset",          CPENC(0,3,C4,C0,6)  },
2967   { "daifclr",          CPENC(0,3,C4,C0,7)  },
2968
2969   { 0,          CPENC(0,0,0,0,0)  },
2970 };
2971
2972 const struct aarch64_name_value_pair aarch64_pstatefields [] =
2973 {
2974   { "spsel",            0x05  },
2975   { "daifset",          0x1e  },
2976   { "daifclr",          0x1f  },
2977   { 0,          CPENC(0,0,0,0,0)  },
2978 };
2979
2980 const aarch64_sys_ins_reg aarch64_sys_regs_ic[] =
2981 {
2982     { "ialluis", CPENS(0,C7,C1,0), 0 },
2983     { "iallu",   CPENS(0,C7,C5,0), 0 },
2984     { "ivau",    CPENS(3,C7,C5,1), 1 },
2985     { 0, CPENS(0,0,0,0), 0 }
2986 };
2987
2988 const aarch64_sys_ins_reg aarch64_sys_regs_dc[] =
2989 {
2990     { "zva",        CPENS(3,C7,C4,1),  1 },
2991     { "ivac",       CPENS(0,C7,C6,1),  1 },
2992     { "isw",        CPENS(0,C7,C6,2),  1 },
2993     { "cvac",       CPENS(3,C7,C10,1), 1 },
2994     { "csw",        CPENS(0,C7,C10,2), 1 },
2995     { "cvau",       CPENS(3,C7,C11,1), 1 },
2996     { "civac",      CPENS(3,C7,C14,1), 1 },
2997     { "cisw",       CPENS(0,C7,C14,2), 1 },
2998     { 0,       CPENS(0,0,0,0), 0 }
2999 };
3000
3001 const aarch64_sys_ins_reg aarch64_sys_regs_at[] =
3002 {
3003     { "s1e1r",      CPENS(0,C7,C8,0), 1 },
3004     { "s1e1w",      CPENS(0,C7,C8,1), 1 },
3005     { "s1e0r",      CPENS(0,C7,C8,2), 1 },
3006     { "s1e0w",      CPENS(0,C7,C8,3), 1 },
3007     { "s12e1r",     CPENS(4,C7,C8,4), 1 },
3008     { "s12e1w",     CPENS(4,C7,C8,5), 1 },
3009     { "s12e0r",     CPENS(4,C7,C8,6), 1 },
3010     { "s12e0w",     CPENS(4,C7,C8,7), 1 },
3011     { "s1e2r",      CPENS(4,C7,C8,0), 1 },
3012     { "s1e2w",      CPENS(4,C7,C8,1), 1 },
3013     { "s1e3r",      CPENS(6,C7,C8,0), 1 },
3014     { "s1e3w",      CPENS(6,C7,C8,1), 1 },
3015     { 0,       CPENS(0,0,0,0), 0 }
3016 };
3017
3018 const aarch64_sys_ins_reg aarch64_sys_regs_tlbi[] =
3019 {
3020     { "vmalle1",   CPENS(0,C8,C7,0), 0 },
3021     { "vae1",      CPENS(0,C8,C7,1), 1 },
3022     { "aside1",    CPENS(0,C8,C7,2), 1 },
3023     { "vaae1",     CPENS(0,C8,C7,3), 1 },
3024     { "vmalle1is", CPENS(0,C8,C3,0), 0 },
3025     { "vae1is",    CPENS(0,C8,C3,1), 1 },
3026     { "aside1is",  CPENS(0,C8,C3,2), 1 },
3027     { "vaae1is",   CPENS(0,C8,C3,3), 1 },
3028     { "ipas2e1is", CPENS(4,C8,C0,1), 1 },
3029     { "ipas2le1is",CPENS(4,C8,C0,5), 1 },
3030     { "ipas2e1",   CPENS(4,C8,C4,1), 1 },
3031     { "ipas2le1",  CPENS(4,C8,C4,5), 1 },
3032     { "vae2",      CPENS(4,C8,C7,1), 1 },
3033     { "vae2is",    CPENS(4,C8,C3,1), 1 },
3034     { "vmalls12e1",CPENS(4,C8,C7,6), 0 },
3035     { "vmalls12e1is",CPENS(4,C8,C3,6), 0 },
3036     { "vae3",      CPENS(6,C8,C7,1), 1 },
3037     { "vae3is",    CPENS(6,C8,C3,1), 1 },
3038     { "alle2",     CPENS(4,C8,C7,0), 0 },
3039     { "alle2is",   CPENS(4,C8,C3,0), 0 },
3040     { "alle1",     CPENS(4,C8,C7,4), 0 },
3041     { "alle1is",   CPENS(4,C8,C3,4), 0 },
3042     { "alle3",     CPENS(6,C8,C7,0), 0 },
3043     { "alle3is",   CPENS(6,C8,C3,0), 0 },
3044     { "vale1is",   CPENS(0,C8,C3,5), 1 },
3045     { "vale2is",   CPENS(4,C8,C3,5), 1 },
3046     { "vale3is",   CPENS(6,C8,C3,5), 1 },
3047     { "vaale1is",  CPENS(0,C8,C3,7), 1 },
3048     { "vale1",     CPENS(0,C8,C7,5), 1 },
3049     { "vale2",     CPENS(4,C8,C7,5), 1 },
3050     { "vale3",     CPENS(6,C8,C7,5), 1 },
3051     { "vaale1",    CPENS(0,C8,C7,7), 1 },
3052     { 0,       CPENS(0,0,0,0), 0 }
3053 };
3054
3055 #undef C0
3056 #undef C1
3057 #undef C2
3058 #undef C3
3059 #undef C4
3060 #undef C5
3061 #undef C6
3062 #undef C7
3063 #undef C8
3064 #undef C9
3065 #undef C10
3066 #undef C11
3067 #undef C12
3068 #undef C13
3069 #undef C14
3070 #undef C15
3071
3072 /* Include the opcode description table as well as the operand description
3073    table.  */
3074 #include "aarch64-tbl.h"