opcodes/aarch64-opc.c

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