opcodes/aarch64-dis.c

   1 /* aarch64-dis.c -- AArch64 disassembler.
   2    Copyright (C) 2009-2016 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 "bfd_stdint.h"
  23 #include "dis-asm.h"
  24 #include "libiberty.h"
  25 #include "opintl.h"
  26 #include "aarch64-dis.h"
  27 #include "elf-bfd.h"
  28
  29 #define ERR_OK   0
  30 #define ERR_UND -1
  31 #define ERR_UNP -3
  32 #define ERR_NYI -5
  33
  34 #define INSNLEN 4
  35
  36 /* Cached mapping symbol state.  */
  37 enum map_type
  38 {
  39   MAP_INSN,
  40   MAP_DATA
  41 };
  42
  43 static enum map_type last_type;
  44 static int last_mapping_sym = -1;
  45 static bfd_vma last_mapping_addr = 0;
  46
  47 /* Other options */
  48 static int no_aliases = 0;      /* If set disassemble as most general inst.  */
  49 \f
  50
  51 static void
  52 set_default_aarch64_dis_options (struct disassemble_info *info ATTRIBUTE_UNUSED)
  53 {
  54 }
  55
  56 static void
  57 parse_aarch64_dis_option (const char *option, unsigned int len ATTRIBUTE_UNUSED)
  58 {
  59   /* Try to match options that are simple flags */
  60   if (CONST_STRNEQ (option, "no-aliases"))
  61     {
  62       no_aliases = 1;
  63       return;
  64     }
  65
  66   if (CONST_STRNEQ (option, "aliases"))
  67     {
  68       no_aliases = 0;
  69       return;
  70     }
  71
  72 #ifdef DEBUG_AARCH64
  73   if (CONST_STRNEQ (option, "debug_dump"))
  74     {
  75       debug_dump = 1;
  76       return;
  77     }
  78 #endif /* DEBUG_AARCH64 */
  79
  80   /* Invalid option.  */
  81   fprintf (stderr, _("Unrecognised disassembler option: %s\n"), option);
  82 }
  83
  84 static void
  85 parse_aarch64_dis_options (const char *options)
  86 {
  87   const char *option_end;
  88
  89   if (options == NULL)
  90     return;
  91
  92   while (*options != '\0')
  93     {
  94       /* Skip empty options.  */
  95       if (*options == ',')
  96         {
  97           options++;
  98           continue;
  99         }
 100
 101       /* We know that *options is neither NUL or a comma.  */
 102       option_end = options + 1;
 103       while (*option_end != ',' && *option_end != '\0')
 104         option_end++;
 105
 106       parse_aarch64_dis_option (options, option_end - options);
 107
 108       /* Go on to the next one.  If option_end points to a comma, it
 109          will be skipped above.  */
 110       options = option_end;
 111     }
 112 }
 113 \f
 114 /* Functions doing the instruction disassembling.  */
 115
 116 /* The unnamed arguments consist of the number of fields and information about
 117    these fields where the VALUE will be extracted from CODE and returned.
 118    MASK can be zero or the base mask of the opcode.
 119
 120    N.B. the fields are required to be in such an order than the most signficant
 121    field for VALUE comes the first, e.g. the <index> in
 122     SQDMLAL <Va><d>, <Vb><n>, <Vm>.<Ts>[<index>]
 123    is encoded in H:L:M in some cases, the fields H:L:M should be passed in
 124    the order of H, L, M.  */
 125
 126 aarch64_insn
 127 extract_fields (aarch64_insn code, aarch64_insn mask, ...)
 128 {
 129   uint32_t num;
 130   const aarch64_field *field;
 131   enum aarch64_field_kind kind;
 132   va_list va;
 133
 134   va_start (va, mask);
 135   num = va_arg (va, uint32_t);
 136   assert (num <= 5);
 137   aarch64_insn value = 0x0;
 138   while (num--)
 139     {
 140       kind = va_arg (va, enum aarch64_field_kind);
 141       field = &fields[kind];
 142       value <<= field->width;
 143       value |= extract_field (kind, code, mask);
 144     }
 145   return value;
 146 }
 147
 148 /* Extract the value of all fields in SELF->fields from instruction CODE.
 149    The least significant bit comes from the final field.  */
 150
 151 static aarch64_insn
 152 extract_all_fields (const aarch64_operand *self, aarch64_insn code)
 153 {
 154   aarch64_insn value;
 155   unsigned int i;
 156   enum aarch64_field_kind kind;
 157
 158   value = 0;
 159   for (i = 0; i < ARRAY_SIZE (self->fields) && self->fields[i] != FLD_NIL; ++i)
 160     {
 161       kind = self->fields[i];
 162       value <<= fields[kind].width;
 163       value |= extract_field (kind, code, 0);
 164     }
 165   return value;
 166 }
 167
 168 /* Sign-extend bit I of VALUE.  */
 169 static inline int32_t
 170 sign_extend (aarch64_insn value, unsigned i)
 171 {
 172   uint32_t ret = value;
 173
 174   assert (i < 32);
 175   if ((value >> i) & 0x1)
 176     {
 177       uint32_t val = (uint32_t)(-1) << i;
 178       ret = ret | val;
 179     }
 180   return (int32_t) ret;
 181 }
 182
 183 /* N.B. the following inline helpfer functions create a dependency on the
 184    order of operand qualifier enumerators.  */
 185
 186 /* Given VALUE, return qualifier for a general purpose register.  */
 187 static inline enum aarch64_opnd_qualifier
 188 get_greg_qualifier_from_value (aarch64_insn value)
 189 {
 190   enum aarch64_opnd_qualifier qualifier = AARCH64_OPND_QLF_W + value;
 191   assert (value <= 0x1
 192           && aarch64_get_qualifier_standard_value (qualifier) == value);
 193   return qualifier;
 194 }
 195
 196 /* Given VALUE, return qualifier for a vector register.  This does not support
 197    decoding instructions that accept the 2H vector type.  */
 198
 199 static inline enum aarch64_opnd_qualifier
 200 get_vreg_qualifier_from_value (aarch64_insn value)
 201 {
 202   enum aarch64_opnd_qualifier qualifier = AARCH64_OPND_QLF_V_8B + value;
 203
 204   /* Instructions using vector type 2H should not call this function.  Skip over
 205      the 2H qualifier.  */
 206   if (qualifier >= AARCH64_OPND_QLF_V_2H)
 207     qualifier += 1;
 208
 209   assert (value <= 0x8
 210           && aarch64_get_qualifier_standard_value (qualifier) == value);
 211   return qualifier;
 212 }
 213
 214 /* Given VALUE, return qualifier for an FP or AdvSIMD scalar register.  */
 215 static inline enum aarch64_opnd_qualifier
 216 get_sreg_qualifier_from_value (aarch64_insn value)
 217 {
 218   enum aarch64_opnd_qualifier qualifier = AARCH64_OPND_QLF_S_B + value;
 219
 220   assert (value <= 0x4
 221           && aarch64_get_qualifier_standard_value (qualifier) == value);
 222   return qualifier;
 223 }
 224
 225 /* Given the instruction in *INST which is probably half way through the
 226    decoding and our caller wants to know the expected qualifier for operand
 227    I.  Return such a qualifier if we can establish it; otherwise return
 228    AARCH64_OPND_QLF_NIL.  */
 229
 230 static aarch64_opnd_qualifier_t
 231 get_expected_qualifier (const aarch64_inst *inst, int i)
 232 {
 233   aarch64_opnd_qualifier_seq_t qualifiers;
 234   /* Should not be called if the qualifier is known.  */
 235   assert (inst->operands[i].qualifier == AARCH64_OPND_QLF_NIL);
 236   if (aarch64_find_best_match (inst, inst->opcode->qualifiers_list,
 237                                i, qualifiers))
 238     return qualifiers[i];
 239   else
 240     return AARCH64_OPND_QLF_NIL;
 241 }
 242
 243 /* Operand extractors.  */
 244
 245 int
 246 aarch64_ext_regno (const aarch64_operand *self, aarch64_opnd_info *info,
 247                    const aarch64_insn code,
 248                    const aarch64_inst *inst ATTRIBUTE_UNUSED)
 249 {
 250   info->reg.regno = extract_field (self->fields[0], code, 0);
 251   return 1;
 252 }
 253
 254 int
 255 aarch64_ext_regno_pair (const aarch64_operand *self ATTRIBUTE_UNUSED, aarch64_opnd_info *info,
 256                    const aarch64_insn code ATTRIBUTE_UNUSED,
 257                    const aarch64_inst *inst ATTRIBUTE_UNUSED)
 258 {
 259   assert (info->idx == 1
 260           || info->idx ==3);
 261   info->reg.regno = inst->operands[info->idx - 1].reg.regno + 1;
 262   return 1;
 263 }
 264
 265 /* e.g. IC <ic_op>{, <Xt>}.  */
 266 int
 267 aarch64_ext_regrt_sysins (const aarch64_operand *self, aarch64_opnd_info *info,
 268                           const aarch64_insn code,
 269                           const aarch64_inst *inst ATTRIBUTE_UNUSED)
 270 {
 271   info->reg.regno = extract_field (self->fields[0], code, 0);
 272   assert (info->idx == 1
 273           && (aarch64_get_operand_class (inst->operands[0].type)
 274               == AARCH64_OPND_CLASS_SYSTEM));
 275   /* This will make the constraint checking happy and more importantly will
 276      help the disassembler determine whether this operand is optional or
 277      not.  */
 278   info->present = aarch64_sys_ins_reg_has_xt (inst->operands[0].sysins_op);
 279
 280   return 1;
 281 }
 282
 283 /* e.g. SQDMLAL <Va><d>, <Vb><n>, <Vm>.<Ts>[<index>].  */
 284 int
 285 aarch64_ext_reglane (const aarch64_operand *self, aarch64_opnd_info *info,
 286                      const aarch64_insn code,
 287                      const aarch64_inst *inst ATTRIBUTE_UNUSED)
 288 {
 289   /* regno */
 290   info->reglane.regno = extract_field (self->fields[0], code,
 291                                        inst->opcode->mask);
 292
 293   /* Index and/or type.  */
 294   if (inst->opcode->iclass == asisdone
 295     || inst->opcode->iclass == asimdins)
 296     {
 297       if (info->type == AARCH64_OPND_En
 298           && inst->opcode->operands[0] == AARCH64_OPND_Ed)
 299         {
 300           unsigned shift;
 301           /* index2 for e.g. INS <Vd>.<Ts>[<index1>], <Vn>.<Ts>[<index2>].  */
 302           assert (info->idx == 1);      /* Vn */
 303           aarch64_insn value = extract_field (FLD_imm4, code, 0);
 304           /* Depend on AARCH64_OPND_Ed to determine the qualifier.  */
 305           info->qualifier = get_expected_qualifier (inst, info->idx);
 306           shift = get_logsz (aarch64_get_qualifier_esize (info->qualifier));
 307           info->reglane.index = value >> shift;
 308         }
 309       else
 310         {
 311           /* index and type for e.g. DUP <V><d>, <Vn>.<T>[<index>].
 312              imm5<3:0>  <V>
 313              0000       RESERVED
 314              xxx1       B
 315              xx10       H
 316              x100       S
 317              1000       D  */
 318           int pos = -1;
 319           aarch64_insn value = extract_field (FLD_imm5, code, 0);
 320           while (++pos <= 3 && (value & 0x1) == 0)
 321             value >>= 1;
 322           if (pos > 3)
 323             return 0;
 324           info->qualifier = get_sreg_qualifier_from_value (pos);
 325           info->reglane.index = (unsigned) (value >> 1);
 326         }
 327     }
 328   else
 329     {
 330       /* Index only for e.g. SQDMLAL <Va><d>, <Vb><n>, <Vm>.<Ts>[<index>]
 331          or SQDMLAL <Va><d>, <Vb><n>, <Vm>.<Ts>[<index>].  */
 332
 333       /* Need information in other operand(s) to help decoding.  */
 334       info->qualifier = get_expected_qualifier (inst, info->idx);
 335       switch (info->qualifier)
 336         {
 337         case AARCH64_OPND_QLF_S_H:
 338           /* h:l:m */
 339           info->reglane.index = extract_fields (code, 0, 3, FLD_H, FLD_L,
 340                                                 FLD_M);
 341           info->reglane.regno &= 0xf;
 342           break;
 343         case AARCH64_OPND_QLF_S_S:
 344           /* h:l */
 345           info->reglane.index = extract_fields (code, 0, 2, FLD_H, FLD_L);
 346           break;
 347         case AARCH64_OPND_QLF_S_D:
 348           /* H */
 349           info->reglane.index = extract_field (FLD_H, code, 0);
 350           break;
 351         default:
 352           return 0;
 353         }
 354     }
 355
 356   return 1;
 357 }
 358
 359 int
 360 aarch64_ext_reglist (const aarch64_operand *self, aarch64_opnd_info *info,
 361                      const aarch64_insn code,
 362                      const aarch64_inst *inst ATTRIBUTE_UNUSED)
 363 {
 364   /* R */
 365   info->reglist.first_regno = extract_field (self->fields[0], code, 0);
 366   /* len */
 367   info->reglist.num_regs = extract_field (FLD_len, code, 0) + 1;
 368   return 1;
 369 }
 370
 371 /* Decode Rt and opcode fields of Vt in AdvSIMD load/store instructions.  */
 372 int
 373 aarch64_ext_ldst_reglist (const aarch64_operand *self ATTRIBUTE_UNUSED,
 374                           aarch64_opnd_info *info, const aarch64_insn code,
 375                           const aarch64_inst *inst)
 376 {
 377   aarch64_insn value;
 378   /* Number of elements in each structure to be loaded/stored.  */
 379   unsigned expected_num = get_opcode_dependent_value (inst->opcode);
 380
 381   struct
 382     {
 383       unsigned is_reserved;
 384       unsigned num_regs;
 385       unsigned num_elements;
 386     } data [] =
 387   {   {0, 4, 4},
 388       {1, 4, 4},
 389       {0, 4, 1},
 390       {0, 4, 2},
 391       {0, 3, 3},
 392       {1, 3, 3},
 393       {0, 3, 1},
 394       {0, 1, 1},
 395       {0, 2, 2},
 396       {1, 2, 2},
 397       {0, 2, 1},
 398   };
 399
 400   /* Rt */
 401   info->reglist.first_regno = extract_field (FLD_Rt, code, 0);
 402   /* opcode */
 403   value = extract_field (FLD_opcode, code, 0);
 404   if (expected_num != data[value].num_elements || data[value].is_reserved)
 405     return 0;
 406   info->reglist.num_regs = data[value].num_regs;
 407
 408   return 1;
 409 }
 410
 411 /* Decode Rt and S fields of Vt in AdvSIMD load single structure to all
 412    lanes instructions.  */
 413 int
 414 aarch64_ext_ldst_reglist_r (const aarch64_operand *self ATTRIBUTE_UNUSED,
 415                             aarch64_opnd_info *info, const aarch64_insn code,
 416                             const aarch64_inst *inst)
 417 {
 418   aarch64_insn value;
 419
 420   /* Rt */
 421   info->reglist.first_regno = extract_field (FLD_Rt, code, 0);
 422   /* S */
 423   value = extract_field (FLD_S, code, 0);
 424
 425   /* Number of registers is equal to the number of elements in
 426      each structure to be loaded/stored.  */
 427   info->reglist.num_regs = get_opcode_dependent_value (inst->opcode);
 428   assert (info->reglist.num_regs >= 1 && info->reglist.num_regs <= 4);
 429
 430   /* Except when it is LD1R.  */
 431   if (info->reglist.num_regs == 1 && value == (aarch64_insn) 1)
 432     info->reglist.num_regs = 2;
 433
 434   return 1;
 435 }
 436
 437 /* Decode Q, opcode<2:1>, S, size and Rt fields of Vt in AdvSIMD
 438    load/store single element instructions.  */
 439 int
 440 aarch64_ext_ldst_elemlist (const aarch64_operand *self ATTRIBUTE_UNUSED,
 441                            aarch64_opnd_info *info, const aarch64_insn code,
 442                            const aarch64_inst *inst ATTRIBUTE_UNUSED)
 443 {
 444   aarch64_field field = {0, 0};
 445   aarch64_insn QSsize;          /* fields Q:S:size.  */
 446   aarch64_insn opcodeh2;        /* opcode<2:1> */
 447
 448   /* Rt */
 449   info->reglist.first_regno = extract_field (FLD_Rt, code, 0);
 450
 451   /* Decode the index, opcode<2:1> and size.  */
 452   gen_sub_field (FLD_asisdlso_opcode, 1, 2, &field);
 453   opcodeh2 = extract_field_2 (&field, code, 0);
 454   QSsize = extract_fields (code, 0, 3, FLD_Q, FLD_S, FLD_vldst_size);
 455   switch (opcodeh2)
 456     {
 457     case 0x0:
 458       info->qualifier = AARCH64_OPND_QLF_S_B;
 459       /* Index encoded in "Q:S:size".  */
 460       info->reglist.index = QSsize;
 461       break;
 462     case 0x1:
 463       if (QSsize & 0x1)
 464         /* UND.  */
 465         return 0;
 466       info->qualifier = AARCH64_OPND_QLF_S_H;
 467       /* Index encoded in "Q:S:size<1>".  */
 468       info->reglist.index = QSsize >> 1;
 469       break;
 470     case 0x2:
 471       if ((QSsize >> 1) & 0x1)
 472         /* UND.  */
 473         return 0;
 474       if ((QSsize & 0x1) == 0)
 475         {
 476           info->qualifier = AARCH64_OPND_QLF_S_S;
 477           /* Index encoded in "Q:S".  */
 478           info->reglist.index = QSsize >> 2;
 479         }
 480       else
 481         {
 482           if (extract_field (FLD_S, code, 0))
 483             /* UND */
 484             return 0;
 485           info->qualifier = AARCH64_OPND_QLF_S_D;
 486           /* Index encoded in "Q".  */
 487           info->reglist.index = QSsize >> 3;
 488         }
 489       break;
 490     default:
 491       return 0;
 492     }
 493
 494   info->reglist.has_index = 1;
 495   info->reglist.num_regs = 0;
 496   /* Number of registers is equal to the number of elements in
 497      each structure to be loaded/stored.  */
 498   info->reglist.num_regs = get_opcode_dependent_value (inst->opcode);
 499   assert (info->reglist.num_regs >= 1 && info->reglist.num_regs <= 4);
 500
 501   return 1;
 502 }
 503
 504 /* Decode fields immh:immb and/or Q for e.g.
 505    SSHR <Vd>.<T>, <Vn>.<T>, #<shift>
 506    or SSHR <V><d>, <V><n>, #<shift>.  */
 507
 508 int
 509 aarch64_ext_advsimd_imm_shift (const aarch64_operand *self ATTRIBUTE_UNUSED,
 510                                aarch64_opnd_info *info, const aarch64_insn code,
 511                                const aarch64_inst *inst)
 512 {
 513   int pos;
 514   aarch64_insn Q, imm, immh;
 515   enum aarch64_insn_class iclass = inst->opcode->iclass;
 516
 517   immh = extract_field (FLD_immh, code, 0);
 518   if (immh == 0)
 519     return 0;
 520   imm = extract_fields (code, 0, 2, FLD_immh, FLD_immb);
 521   pos = 4;
 522   /* Get highest set bit in immh.  */
 523   while (--pos >= 0 && (immh & 0x8) == 0)
 524     immh <<= 1;
 525
 526   assert ((iclass == asimdshf || iclass == asisdshf)
 527           && (info->type == AARCH64_OPND_IMM_VLSR
 528               || info->type == AARCH64_OPND_IMM_VLSL));
 529
 530   if (iclass == asimdshf)
 531     {
 532       Q = extract_field (FLD_Q, code, 0);
 533       /* immh   Q       <T>
 534          0000   x       SEE AdvSIMD modified immediate
 535          0001   0       8B
 536          0001   1       16B
 537          001x   0       4H
 538          001x   1       8H
 539          01xx   0       2S
 540          01xx   1       4S
 541          1xxx   0       RESERVED
 542          1xxx   1       2D  */
 543       info->qualifier =
 544         get_vreg_qualifier_from_value ((pos << 1) | (int) Q);
 545     }
 546   else
 547     info->qualifier = get_sreg_qualifier_from_value (pos);
 548
 549   if (info->type == AARCH64_OPND_IMM_VLSR)
 550     /* immh     <shift>
 551        0000     SEE AdvSIMD modified immediate
 552        0001     (16-UInt(immh:immb))
 553        001x     (32-UInt(immh:immb))
 554        01xx     (64-UInt(immh:immb))
 555        1xxx     (128-UInt(immh:immb))  */
 556     info->imm.value = (16 << pos) - imm;
 557   else
 558     /* immh:immb
 559        immh     <shift>
 560        0000     SEE AdvSIMD modified immediate
 561        0001     (UInt(immh:immb)-8)
 562        001x     (UInt(immh:immb)-16)
 563        01xx     (UInt(immh:immb)-32)
 564        1xxx     (UInt(immh:immb)-64)  */
 565     info->imm.value = imm - (8 << pos);
 566
 567   return 1;
 568 }
 569
 570 /* Decode shift immediate for e.g. sshr (imm).  */
 571 int
 572 aarch64_ext_shll_imm (const aarch64_operand *self ATTRIBUTE_UNUSED,
 573                       aarch64_opnd_info *info, const aarch64_insn code,
 574                       const aarch64_inst *inst ATTRIBUTE_UNUSED)
 575 {
 576   int64_t imm;
 577   aarch64_insn val;
 578   val = extract_field (FLD_size, code, 0);
 579   switch (val)
 580     {
 581     case 0: imm = 8; break;
 582     case 1: imm = 16; break;
 583     case 2: imm = 32; break;
 584     default: return 0;
 585     }
 586   info->imm.value = imm;
 587   return 1;
 588 }
 589
 590 /* Decode imm for e.g. BFM <Wd>, <Wn>, #<immr>, #<imms>.
 591    value in the field(s) will be extracted as unsigned immediate value.  */
 592 int
 593 aarch64_ext_imm (const aarch64_operand *self, aarch64_opnd_info *info,
 594                  const aarch64_insn code,
 595                  const aarch64_inst *inst ATTRIBUTE_UNUSED)
 596 {
 597   int64_t imm;
 598
 599   imm = extract_all_fields (self, code);
 600
 601   if (operand_need_sign_extension (self))
 602     imm = sign_extend (imm, get_operand_fields_width (self) - 1);
 603
 604   if (operand_need_shift_by_two (self))
 605     imm <<= 2;
 606
 607   if (info->type == AARCH64_OPND_ADDR_ADRP)
 608     imm <<= 12;
 609
 610   info->imm.value = imm;
 611   return 1;
 612 }
 613
 614 /* Decode imm and its shifter for e.g. MOVZ <Wd>, #<imm16>{, LSL #<shift>}.  */
 615 int
 616 aarch64_ext_imm_half (const aarch64_operand *self, aarch64_opnd_info *info,
 617                       const aarch64_insn code,
 618                       const aarch64_inst *inst ATTRIBUTE_UNUSED)
 619 {
 620   aarch64_ext_imm (self, info, code, inst);
 621   info->shifter.kind = AARCH64_MOD_LSL;
 622   info->shifter.amount = extract_field (FLD_hw, code, 0) << 4;
 623   return 1;
 624 }
 625
 626 /* Decode cmode and "a:b:c:d:e:f:g:h" for e.g.
 627      MOVI <Vd>.<T>, #<imm8> {, LSL #<amount>}.  */
 628 int
 629 aarch64_ext_advsimd_imm_modified (const aarch64_operand *self ATTRIBUTE_UNUSED,
 630                                   aarch64_opnd_info *info,
 631                                   const aarch64_insn code,
 632                                   const aarch64_inst *inst ATTRIBUTE_UNUSED)
 633 {
 634   uint64_t imm;
 635   enum aarch64_opnd_qualifier opnd0_qualifier = inst->operands[0].qualifier;
 636   aarch64_field field = {0, 0};
 637
 638   assert (info->idx == 1);
 639
 640   if (info->type == AARCH64_OPND_SIMD_FPIMM)
 641     info->imm.is_fp = 1;
 642
 643   /* a:b:c:d:e:f:g:h */
 644   imm = extract_fields (code, 0, 2, FLD_abc, FLD_defgh);
 645   if (!info->imm.is_fp && aarch64_get_qualifier_esize (opnd0_qualifier) == 8)
 646     {
 647       /* Either MOVI <Dd>, #<imm>
 648          or     MOVI <Vd>.2D, #<imm>.
 649          <imm> is a 64-bit immediate
 650          'aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffgggggggghhhhhhhh',
 651          encoded in "a:b:c:d:e:f:g:h".  */
 652       int i;
 653       unsigned abcdefgh = imm;
 654       for (imm = 0ull, i = 0; i < 8; i++)
 655         if (((abcdefgh >> i) & 0x1) != 0)
 656           imm |= 0xffull << (8 * i);
 657     }
 658   info->imm.value = imm;
 659
 660   /* cmode */
 661   info->qualifier = get_expected_qualifier (inst, info->idx);
 662   switch (info->qualifier)
 663     {
 664     case AARCH64_OPND_QLF_NIL:
 665       /* no shift */
 666       info->shifter.kind = AARCH64_MOD_NONE;
 667       return 1;
 668     case AARCH64_OPND_QLF_LSL:
 669       /* shift zeros */
 670       info->shifter.kind = AARCH64_MOD_LSL;
 671       switch (aarch64_get_qualifier_esize (opnd0_qualifier))
 672         {
 673         case 4: gen_sub_field (FLD_cmode, 1, 2, &field); break; /* per word */
 674         case 2: gen_sub_field (FLD_cmode, 1, 1, &field); break; /* per half */
 675         case 1: gen_sub_field (FLD_cmode, 1, 0, &field); break; /* per byte */
 676         default: assert (0); return 0;
 677         }
 678       /* 00: 0; 01: 8; 10:16; 11:24.  */
 679       info->shifter.amount = extract_field_2 (&field, code, 0) << 3;
 680       break;
 681     case AARCH64_OPND_QLF_MSL:
 682       /* shift ones */
 683       info->shifter.kind = AARCH64_MOD_MSL;
 684       gen_sub_field (FLD_cmode, 0, 1, &field);          /* per word */
 685       info->shifter.amount = extract_field_2 (&field, code, 0) ? 16 : 8;
 686       break;
 687     default:
 688       assert (0);
 689       return 0;
 690     }
 691
 692   return 1;
 693 }
 694
 695 /* Decode an 8-bit floating-point immediate.  */
 696 int
 697 aarch64_ext_fpimm (const aarch64_operand *self, aarch64_opnd_info *info,
 698                    const aarch64_insn code,
 699                    const aarch64_inst *inst ATTRIBUTE_UNUSED)
 700 {
 701   info->imm.value = extract_all_fields (self, code);
 702   info->imm.is_fp = 1;
 703   return 1;
 704 }
 705
 706 /* Decode scale for e.g. SCVTF <Dd>, <Wn>, #<fbits>.  */
 707 int
 708 aarch64_ext_fbits (const aarch64_operand *self ATTRIBUTE_UNUSED,
 709                    aarch64_opnd_info *info, const aarch64_insn code,
 710                    const aarch64_inst *inst ATTRIBUTE_UNUSED)
 711 {
 712   info->imm.value = 64- extract_field (FLD_scale, code, 0);
 713   return 1;
 714 }
 715
 716 /* Decode arithmetic immediate for e.g.
 717      SUBS <Wd>, <Wn|WSP>, #<imm> {, <shift>}.  */
 718 int
 719 aarch64_ext_aimm (const aarch64_operand *self ATTRIBUTE_UNUSED,
 720                   aarch64_opnd_info *info, const aarch64_insn code,
 721                   const aarch64_inst *inst ATTRIBUTE_UNUSED)
 722 {
 723   aarch64_insn value;
 724
 725   info->shifter.kind = AARCH64_MOD_LSL;
 726   /* shift */
 727   value = extract_field (FLD_shift, code, 0);
 728   if (value >= 2)
 729     return 0;
 730   info->shifter.amount = value ? 12 : 0;
 731   /* imm12 (unsigned) */
 732   info->imm.value = extract_field (FLD_imm12, code, 0);
 733
 734   return 1;
 735 }
 736
 737 /* Return true if VALUE is a valid logical immediate encoding, storing the
 738    decoded value in *RESULT if so.  ESIZE is the number of bytes in the
 739    decoded immediate.  */
 740 static int
 741 decode_limm (uint32_t esize, aarch64_insn value, int64_t *result)
 742 {
 743   uint64_t imm, mask;
 744   uint32_t N, R, S;
 745   unsigned simd_size;
 746
 747   /* value is N:immr:imms.  */
 748   S = value & 0x3f;
 749   R = (value >> 6) & 0x3f;
 750   N = (value >> 12) & 0x1;
 751
 752   /* The immediate value is S+1 bits to 1, left rotated by SIMDsize - R
 753      (in other words, right rotated by R), then replicated.  */
 754   if (N != 0)
 755     {
 756       simd_size = 64;
 757       mask = 0xffffffffffffffffull;
 758     }
 759   else
 760     {
 761       switch (S)
 762         {
 763         case 0x00 ... 0x1f: /* 0xxxxx */ simd_size = 32;           break;
 764         case 0x20 ... 0x2f: /* 10xxxx */ simd_size = 16; S &= 0xf; break;
 765         case 0x30 ... 0x37: /* 110xxx */ simd_size =  8; S &= 0x7; break;
 766         case 0x38 ... 0x3b: /* 1110xx */ simd_size =  4; S &= 0x3; break;
 767         case 0x3c ... 0x3d: /* 11110x */ simd_size =  2; S &= 0x1; break;
 768         default: return 0;
 769         }
 770       mask = (1ull << simd_size) - 1;
 771       /* Top bits are IGNORED.  */
 772       R &= simd_size - 1;
 773     }
 774
 775   if (simd_size > esize * 8)
 776     return 0;
 777
 778   /* NOTE: if S = simd_size - 1 we get 0xf..f which is rejected.  */
 779   if (S == simd_size - 1)
 780     return 0;
 781   /* S+1 consecutive bits to 1.  */
 782   /* NOTE: S can't be 63 due to detection above.  */
 783   imm = (1ull << (S + 1)) - 1;
 784   /* Rotate to the left by simd_size - R.  */
 785   if (R != 0)
 786     imm = ((imm << (simd_size - R)) & mask) | (imm >> R);
 787   /* Replicate the value according to SIMD size.  */
 788   switch (simd_size)
 789     {
 790     case  2: imm = (imm <<  2) | imm;
 791       /* Fall through.  */
 792     case  4: imm = (imm <<  4) | imm;
 793       /* Fall through.  */
 794     case  8: imm = (imm <<  8) | imm;
 795       /* Fall through.  */
 796     case 16: imm = (imm << 16) | imm;
 797       /* Fall through.  */
 798     case 32: imm = (imm << 32) | imm;
 799       /* Fall through.  */
 800     case 64: break;
 801     default: assert (0); return 0;
 802     }
 803
 804   *result = imm & ~((uint64_t) -1 << (esize * 4) << (esize * 4));
 805
 806   return 1;
 807 }
 808
 809 /* Decode a logical immediate for e.g. ORR <Wd|WSP>, <Wn>, #<imm>.  */
 810 int
 811 aarch64_ext_limm (const aarch64_operand *self,
 812                   aarch64_opnd_info *info, const aarch64_insn code,
 813                   const aarch64_inst *inst)
 814 {
 815   uint32_t esize;
 816   aarch64_insn value;
 817
 818   value = extract_fields (code, 0, 3, self->fields[0], self->fields[1],
 819                           self->fields[2]);
 820   esize = aarch64_get_qualifier_esize (inst->operands[0].qualifier);
 821   return decode_limm (esize, value, &info->imm.value);
 822 }
 823
 824 /* Decode a logical immediate for the BIC alias of AND (etc.).  */
 825 int
 826 aarch64_ext_inv_limm (const aarch64_operand *self,
 827                       aarch64_opnd_info *info, const aarch64_insn code,
 828                       const aarch64_inst *inst)
 829 {
 830   if (!aarch64_ext_limm (self, info, code, inst))
 831     return 0;
 832   info->imm.value = ~info->imm.value;
 833   return 1;
 834 }
 835
 836 /* Decode Ft for e.g. STR <Qt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}]
 837    or LDP <Qt1>, <Qt2>, [<Xn|SP>], #<imm>.  */
 838 int
 839 aarch64_ext_ft (const aarch64_operand *self ATTRIBUTE_UNUSED,
 840                 aarch64_opnd_info *info,
 841                 const aarch64_insn code, const aarch64_inst *inst)
 842 {
 843   aarch64_insn value;
 844
 845   /* Rt */
 846   info->reg.regno = extract_field (FLD_Rt, code, 0);
 847
 848   /* size */
 849   value = extract_field (FLD_ldst_size, code, 0);
 850   if (inst->opcode->iclass == ldstpair_indexed
 851       || inst->opcode->iclass == ldstnapair_offs
 852       || inst->opcode->iclass == ldstpair_off
 853       || inst->opcode->iclass == loadlit)
 854     {
 855       enum aarch64_opnd_qualifier qualifier;
 856       switch (value)
 857         {
 858         case 0: qualifier = AARCH64_OPND_QLF_S_S; break;
 859         case 1: qualifier = AARCH64_OPND_QLF_S_D; break;
 860         case 2: qualifier = AARCH64_OPND_QLF_S_Q; break;
 861         default: return 0;
 862         }
 863       info->qualifier = qualifier;
 864     }
 865   else
 866     {
 867       /* opc1:size */
 868       value = extract_fields (code, 0, 2, FLD_opc1, FLD_ldst_size);
 869       if (value > 0x4)
 870         return 0;
 871       info->qualifier = get_sreg_qualifier_from_value (value);
 872     }
 873
 874   return 1;
 875 }
 876
 877 /* Decode the address operand for e.g. STXRB <Ws>, <Wt>, [<Xn|SP>{,#0}].  */
 878 int
 879 aarch64_ext_addr_simple (const aarch64_operand *self ATTRIBUTE_UNUSED,
 880                          aarch64_opnd_info *info,
 881                          aarch64_insn code,
 882                          const aarch64_inst *inst ATTRIBUTE_UNUSED)
 883 {
 884   /* Rn */
 885   info->addr.base_regno = extract_field (FLD_Rn, code, 0);
 886   return 1;
 887 }
 888
 889 /* Decode the address operand for e.g.
 890      STR <Qt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}].  */
 891 int
 892 aarch64_ext_addr_regoff (const aarch64_operand *self ATTRIBUTE_UNUSED,
 893                          aarch64_opnd_info *info,
 894                          aarch64_insn code, const aarch64_inst *inst)
 895 {
 896   aarch64_insn S, value;
 897
 898   /* Rn */
 899   info->addr.base_regno = extract_field (FLD_Rn, code, 0);
 900   /* Rm */
 901   info->addr.offset.regno = extract_field (FLD_Rm, code, 0);
 902   /* option */
 903   value = extract_field (FLD_option, code, 0);
 904   info->shifter.kind =
 905     aarch64_get_operand_modifier_from_value (value, TRUE /* extend_p */);
 906   /* Fix-up the shifter kind; although the table-driven approach is
 907      efficient, it is slightly inflexible, thus needing this fix-up.  */
 908   if (info->shifter.kind == AARCH64_MOD_UXTX)
 909     info->shifter.kind = AARCH64_MOD_LSL;
 910   /* S */
 911   S = extract_field (FLD_S, code, 0);
 912   if (S == 0)
 913     {
 914       info->shifter.amount = 0;
 915       info->shifter.amount_present = 0;
 916     }
 917   else
 918     {
 919       int size;
 920       /* Need information in other operand(s) to help achieve the decoding
 921          from 'S' field.  */
 922       info->qualifier = get_expected_qualifier (inst, info->idx);
 923       /* Get the size of the data element that is accessed, which may be
 924          different from that of the source register size, e.g. in strb/ldrb.  */
 925       size = aarch64_get_qualifier_esize (info->qualifier);
 926       info->shifter.amount = get_logsz (size);
 927       info->shifter.amount_present = 1;
 928     }
 929
 930   return 1;
 931 }
 932
 933 /* Decode the address operand for e.g. LDRSW <Xt>, [<Xn|SP>], #<simm>.  */
 934 int
 935 aarch64_ext_addr_simm (const aarch64_operand *self, aarch64_opnd_info *info,
 936                        aarch64_insn code, const aarch64_inst *inst)
 937 {
 938   aarch64_insn imm;
 939   info->qualifier = get_expected_qualifier (inst, info->idx);
 940
 941   /* Rn */
 942   info->addr.base_regno = extract_field (FLD_Rn, code, 0);
 943   /* simm (imm9 or imm7)  */
 944   imm = extract_field (self->fields[0], code, 0);
 945   info->addr.offset.imm = sign_extend (imm, fields[self->fields[0]].width - 1);
 946   if (self->fields[0] == FLD_imm7)
 947     /* scaled immediate in ld/st pair instructions.  */
 948     info->addr.offset.imm *= aarch64_get_qualifier_esize (info->qualifier);
 949   /* qualifier */
 950   if (inst->opcode->iclass == ldst_unscaled
 951       || inst->opcode->iclass == ldstnapair_offs
 952       || inst->opcode->iclass == ldstpair_off
 953       || inst->opcode->iclass == ldst_unpriv)
 954     info->addr.writeback = 0;
 955   else
 956     {
 957       /* pre/post- index */
 958       info->addr.writeback = 1;
 959       if (extract_field (self->fields[1], code, 0) == 1)
 960         info->addr.preind = 1;
 961       else
 962         info->addr.postind = 1;
 963     }
 964
 965   return 1;
 966 }
 967
 968 /* Decode the address operand for e.g. LDRSW <Xt>, [<Xn|SP>{, #<simm>}].  */
 969 int
 970 aarch64_ext_addr_uimm12 (const aarch64_operand *self, aarch64_opnd_info *info,
 971                          aarch64_insn code,
 972                          const aarch64_inst *inst ATTRIBUTE_UNUSED)
 973 {
 974   int shift;
 975   info->qualifier = get_expected_qualifier (inst, info->idx);
 976   shift = get_logsz (aarch64_get_qualifier_esize (info->qualifier));
 977   /* Rn */
 978   info->addr.base_regno = extract_field (self->fields[0], code, 0);
 979   /* uimm12 */
 980   info->addr.offset.imm = extract_field (self->fields[1], code, 0) << shift;
 981   return 1;
 982 }
 983
 984 /* Decode the address operand for e.g.
 985      LD1 {<Vt>.<T>, <Vt2>.<T>, <Vt3>.<T>}, [<Xn|SP>], <Xm|#<amount>>.  */
 986 int
 987 aarch64_ext_simd_addr_post (const aarch64_operand *self ATTRIBUTE_UNUSED,
 988                             aarch64_opnd_info *info,
 989                             aarch64_insn code, const aarch64_inst *inst)
 990 {
 991   /* The opcode dependent area stores the number of elements in
 992      each structure to be loaded/stored.  */
 993   int is_ld1r = get_opcode_dependent_value (inst->opcode) == 1;
 994
 995   /* Rn */
 996   info->addr.base_regno = extract_field (FLD_Rn, code, 0);
 997   /* Rm | #<amount>  */
 998   info->addr.offset.regno = extract_field (FLD_Rm, code, 0);
 999   if (info->addr.offset.regno == 31)
1000     {
1001       if (inst->opcode->operands[0] == AARCH64_OPND_LVt_AL)
1002         /* Special handling of loading single structure to all lane.  */
1003         info->addr.offset.imm = (is_ld1r ? 1
1004                                  : inst->operands[0].reglist.num_regs)
1005           * aarch64_get_qualifier_esize (inst->operands[0].qualifier);
1006       else
1007         info->addr.offset.imm = inst->operands[0].reglist.num_regs
1008           * aarch64_get_qualifier_esize (inst->operands[0].qualifier)
1009           * aarch64_get_qualifier_nelem (inst->operands[0].qualifier);
1010     }
1011   else
1012     info->addr.offset.is_reg = 1;
1013   info->addr.writeback = 1;
1014
1015   return 1;
1016 }
1017
1018 /* Decode the condition operand for e.g. CSEL <Xd>, <Xn>, <Xm>, <cond>.  */
1019 int
1020 aarch64_ext_cond (const aarch64_operand *self ATTRIBUTE_UNUSED,
1021                   aarch64_opnd_info *info,
1022                   aarch64_insn code, const aarch64_inst *inst ATTRIBUTE_UNUSED)
1023 {
1024   aarch64_insn value;
1025   /* cond */
1026   value = extract_field (FLD_cond, code, 0);
1027   info->cond = get_cond_from_value (value);
1028   return 1;
1029 }
1030
1031 /* Decode the system register operand for e.g. MRS <Xt>, <systemreg>.  */
1032 int
1033 aarch64_ext_sysreg (const aarch64_operand *self ATTRIBUTE_UNUSED,
1034                     aarch64_opnd_info *info,
1035                     aarch64_insn code,
1036                     const aarch64_inst *inst ATTRIBUTE_UNUSED)
1037 {
1038   /* op0:op1:CRn:CRm:op2 */
1039   info->sysreg = extract_fields (code, 0, 5, FLD_op0, FLD_op1, FLD_CRn,
1040                                  FLD_CRm, FLD_op2);
1041   return 1;
1042 }
1043
1044 /* Decode the PSTATE field operand for e.g. MSR <pstatefield>, #<imm>.  */
1045 int
1046 aarch64_ext_pstatefield (const aarch64_operand *self ATTRIBUTE_UNUSED,
1047                          aarch64_opnd_info *info, aarch64_insn code,
1048                          const aarch64_inst *inst ATTRIBUTE_UNUSED)
1049 {
1050   int i;
1051   /* op1:op2 */
1052   info->pstatefield = extract_fields (code, 0, 2, FLD_op1, FLD_op2);
1053   for (i = 0; aarch64_pstatefields[i].name != NULL; ++i)
1054     if (aarch64_pstatefields[i].value == (aarch64_insn)info->pstatefield)
1055       return 1;
1056   /* Reserved value in <pstatefield>.  */
1057   return 0;
1058 }
1059
1060 /* Decode the system instruction op operand for e.g. AT <at_op>, <Xt>.  */
1061 int
1062 aarch64_ext_sysins_op (const aarch64_operand *self ATTRIBUTE_UNUSED,
1063                        aarch64_opnd_info *info,
1064                        aarch64_insn code,
1065                        const aarch64_inst *inst ATTRIBUTE_UNUSED)
1066 {
1067   int i;
1068   aarch64_insn value;
1069   const aarch64_sys_ins_reg *sysins_ops;
1070   /* op0:op1:CRn:CRm:op2 */
1071   value = extract_fields (code, 0, 5,
1072                           FLD_op0, FLD_op1, FLD_CRn,
1073                           FLD_CRm, FLD_op2);
1074
1075   switch (info->type)
1076     {
1077     case AARCH64_OPND_SYSREG_AT: sysins_ops = aarch64_sys_regs_at; break;
1078     case AARCH64_OPND_SYSREG_DC: sysins_ops = aarch64_sys_regs_dc; break;
1079     case AARCH64_OPND_SYSREG_IC: sysins_ops = aarch64_sys_regs_ic; break;
1080     case AARCH64_OPND_SYSREG_TLBI: sysins_ops = aarch64_sys_regs_tlbi; break;
1081     default: assert (0); return 0;
1082     }
1083
1084   for (i = 0; sysins_ops[i].name != NULL; ++i)
1085     if (sysins_ops[i].value == value)
1086       {
1087         info->sysins_op = sysins_ops + i;
1088         DEBUG_TRACE ("%s found value: %x, has_xt: %d, i: %d.",
1089                      info->sysins_op->name,
1090                      (unsigned)info->sysins_op->value,
1091                      aarch64_sys_ins_reg_has_xt (info->sysins_op), i);
1092         return 1;
1093       }
1094
1095   return 0;
1096 }
1097
1098 /* Decode the memory barrier option operand for e.g. DMB <option>|#<imm>.  */
1099
1100 int
1101 aarch64_ext_barrier (const aarch64_operand *self ATTRIBUTE_UNUSED,
1102                      aarch64_opnd_info *info,
1103                      aarch64_insn code,
1104                      const aarch64_inst *inst ATTRIBUTE_UNUSED)
1105 {
1106   /* CRm */
1107   info->barrier = aarch64_barrier_options + extract_field (FLD_CRm, code, 0);
1108   return 1;
1109 }
1110
1111 /* Decode the prefetch operation option operand for e.g.
1112      PRFM <prfop>, [<Xn|SP>{, #<pimm>}].  */
1113
1114 int
1115 aarch64_ext_prfop (const aarch64_operand *self ATTRIBUTE_UNUSED,
1116                    aarch64_opnd_info *info,
1117                    aarch64_insn code, const aarch64_inst *inst ATTRIBUTE_UNUSED)
1118 {
1119   /* prfop in Rt */
1120   info->prfop = aarch64_prfops + extract_field (FLD_Rt, code, 0);
1121   return 1;
1122 }
1123
1124 /* Decode the hint number for an alias taking an operand.  Set info->hint_option
1125    to the matching name/value pair in aarch64_hint_options.  */
1126
1127 int
1128 aarch64_ext_hint (const aarch64_operand *self ATTRIBUTE_UNUSED,
1129                   aarch64_opnd_info *info,
1130                   aarch64_insn code,
1131                   const aarch64_inst *inst ATTRIBUTE_UNUSED)
1132 {
1133   /* CRm:op2.  */
1134   unsigned hint_number;
1135   int i;
1136
1137   hint_number = extract_fields (code, 0, 2, FLD_CRm, FLD_op2);
1138
1139   for (i = 0; aarch64_hint_options[i].name != NULL; i++)
1140     {
1141       if (hint_number == aarch64_hint_options[i].value)
1142         {
1143           info->hint_option = &(aarch64_hint_options[i]);
1144           return 1;
1145         }
1146     }
1147
1148   return 0;
1149 }
1150
1151 /* Decode the extended register operand for e.g.
1152      STR <Qt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}].  */
1153 int
1154 aarch64_ext_reg_extended (const aarch64_operand *self ATTRIBUTE_UNUSED,
1155                           aarch64_opnd_info *info,
1156                           aarch64_insn code,
1157                           const aarch64_inst *inst ATTRIBUTE_UNUSED)
1158 {
1159   aarch64_insn value;
1160
1161   /* Rm */
1162   info->reg.regno = extract_field (FLD_Rm, code, 0);
1163   /* option */
1164   value = extract_field (FLD_option, code, 0);
1165   info->shifter.kind =
1166     aarch64_get_operand_modifier_from_value (value, TRUE /* extend_p */);
1167   /* imm3 */
1168   info->shifter.amount = extract_field (FLD_imm3, code,  0);
1169
1170   /* This makes the constraint checking happy.  */
1171   info->shifter.operator_present = 1;
1172
1173   /* Assume inst->operands[0].qualifier has been resolved.  */
1174   assert (inst->operands[0].qualifier != AARCH64_OPND_QLF_NIL);
1175   info->qualifier = AARCH64_OPND_QLF_W;
1176   if (inst->operands[0].qualifier == AARCH64_OPND_QLF_X
1177       && (info->shifter.kind == AARCH64_MOD_UXTX
1178           || info->shifter.kind == AARCH64_MOD_SXTX))
1179     info->qualifier = AARCH64_OPND_QLF_X;
1180
1181   return 1;
1182 }
1183
1184 /* Decode the shifted register operand for e.g.
1185      SUBS <Xd>, <Xn>, <Xm> {, <shift> #<amount>}.  */
1186 int
1187 aarch64_ext_reg_shifted (const aarch64_operand *self ATTRIBUTE_UNUSED,
1188                          aarch64_opnd_info *info,
1189                          aarch64_insn code,
1190                          const aarch64_inst *inst ATTRIBUTE_UNUSED)
1191 {
1192   aarch64_insn value;
1193
1194   /* Rm */
1195   info->reg.regno = extract_field (FLD_Rm, code, 0);
1196   /* shift */
1197   value = extract_field (FLD_shift, code, 0);
1198   info->shifter.kind =
1199     aarch64_get_operand_modifier_from_value (value, FALSE /* extend_p */);
1200   if (info->shifter.kind == AARCH64_MOD_ROR
1201       && inst->opcode->iclass != log_shift)
1202     /* ROR is not available for the shifted register operand in arithmetic
1203        instructions.  */
1204     return 0;
1205   /* imm6 */
1206   info->shifter.amount = extract_field (FLD_imm6, code,  0);
1207
1208   /* This makes the constraint checking happy.  */
1209   info->shifter.operator_present = 1;
1210
1211   return 1;
1212 }
1213
1214 /* Decode an SVE address [<base>, #<offset>*<factor>, MUL VL],
1215    where <offset> is given by the OFFSET parameter and where <factor> is
1216    1 plus SELF's operand-dependent value.  fields[0] specifies the field
1217    that holds <base>.  */
1218 static int
1219 aarch64_ext_sve_addr_reg_mul_vl (const aarch64_operand *self,
1220                                  aarch64_opnd_info *info, aarch64_insn code,
1221                                  int64_t offset)
1222 {
1223   info->addr.base_regno = extract_field (self->fields[0], code, 0);
1224   info->addr.offset.imm = offset * (1 + get_operand_specific_data (self));
1225   info->addr.offset.is_reg = FALSE;
1226   info->addr.writeback = FALSE;
1227   info->addr.preind = TRUE;
1228   if (offset != 0)
1229     info->shifter.kind = AARCH64_MOD_MUL_VL;
1230   info->shifter.amount = 1;
1231   info->shifter.operator_present = (info->addr.offset.imm != 0);
1232   info->shifter.amount_present = FALSE;
1233   return 1;
1234 }
1235
1236 /* Decode an SVE address [<base>, #<simm4>*<factor>, MUL VL],
1237    where <simm4> is a 4-bit signed value and where <factor> is 1 plus
1238    SELF's operand-dependent value.  fields[0] specifies the field that
1239    holds <base>.  <simm4> is encoded in the SVE_imm4 field.  */
1240 int
1241 aarch64_ext_sve_addr_ri_s4xvl (const aarch64_operand *self,
1242                                aarch64_opnd_info *info, aarch64_insn code,
1243                                const aarch64_inst *inst ATTRIBUTE_UNUSED)
1244 {
1245   int offset;
1246
1247   offset = extract_field (FLD_SVE_imm4, code, 0);
1248   offset = ((offset + 8) & 15) - 8;
1249   return aarch64_ext_sve_addr_reg_mul_vl (self, info, code, offset);
1250 }
1251
1252 /* Decode an SVE address [<base>, #<simm6>*<factor>, MUL VL],
1253    where <simm6> is a 6-bit signed value and where <factor> is 1 plus
1254    SELF's operand-dependent value.  fields[0] specifies the field that
1255    holds <base>.  <simm6> is encoded in the SVE_imm6 field.  */
1256 int
1257 aarch64_ext_sve_addr_ri_s6xvl (const aarch64_operand *self,
1258                                aarch64_opnd_info *info, aarch64_insn code,
1259                                const aarch64_inst *inst ATTRIBUTE_UNUSED)
1260 {
1261   int offset;
1262
1263   offset = extract_field (FLD_SVE_imm6, code, 0);
1264   offset = (((offset + 32) & 63) - 32);
1265   return aarch64_ext_sve_addr_reg_mul_vl (self, info, code, offset);
1266 }
1267
1268 /* Decode an SVE address [<base>, #<simm9>*<factor>, MUL VL],
1269    where <simm9> is a 9-bit signed value and where <factor> is 1 plus
1270    SELF's operand-dependent value.  fields[0] specifies the field that
1271    holds <base>.  <simm9> is encoded in the concatenation of the SVE_imm6
1272    and imm3 fields, with imm3 being the less-significant part.  */
1273 int
1274 aarch64_ext_sve_addr_ri_s9xvl (const aarch64_operand *self,
1275                                aarch64_opnd_info *info,
1276                                aarch64_insn code,
1277                                const aarch64_inst *inst ATTRIBUTE_UNUSED)
1278 {
1279   int offset;
1280
1281   offset = extract_fields (code, 0, 2, FLD_SVE_imm6, FLD_imm3);
1282   offset = (((offset + 256) & 511) - 256);
1283   return aarch64_ext_sve_addr_reg_mul_vl (self, info, code, offset);
1284 }
1285
1286 /* Decode an SVE address [<base>, #<offset> << <shift>], where <offset>
1287    is given by the OFFSET parameter and where <shift> is SELF's operand-
1288    dependent value.  fields[0] specifies the base register field <base>.  */
1289 static int
1290 aarch64_ext_sve_addr_reg_imm (const aarch64_operand *self,
1291                               aarch64_opnd_info *info, aarch64_insn code,
1292                               int64_t offset)
1293 {
1294   info->addr.base_regno = extract_field (self->fields[0], code, 0);
1295   info->addr.offset.imm = offset * (1 << get_operand_specific_data (self));
1296   info->addr.offset.is_reg = FALSE;
1297   info->addr.writeback = FALSE;
1298   info->addr.preind = TRUE;
1299   info->shifter.operator_present = FALSE;
1300   info->shifter.amount_present = FALSE;
1301   return 1;
1302 }
1303
1304 /* Decode an SVE address [X<n>, #<SVE_imm6> << <shift>], where <SVE_imm6>
1305    is a 6-bit unsigned number and where <shift> is SELF's operand-dependent
1306    value.  fields[0] specifies the base register field.  */
1307 int
1308 aarch64_ext_sve_addr_ri_u6 (const aarch64_operand *self,
1309                             aarch64_opnd_info *info, aarch64_insn code,
1310                             const aarch64_inst *inst ATTRIBUTE_UNUSED)
1311 {
1312   int offset = extract_field (FLD_SVE_imm6, code, 0);
1313   return aarch64_ext_sve_addr_reg_imm (self, info, code, offset);
1314 }
1315
1316 /* Decode an SVE address [X<n>, X<m>{, LSL #<shift>}], where <shift>
1317    is SELF's operand-dependent value.  fields[0] specifies the base
1318    register field and fields[1] specifies the offset register field.  */
1319 int
1320 aarch64_ext_sve_addr_rr_lsl (const aarch64_operand *self,
1321                              aarch64_opnd_info *info, aarch64_insn code,
1322                              const aarch64_inst *inst ATTRIBUTE_UNUSED)
1323 {
1324   int index;
1325
1326   index = extract_field (self->fields[1], code, 0);
1327   if (index == 31 && (self->flags & OPD_F_NO_ZR) != 0)
1328     return 0;
1329
1330   info->addr.base_regno = extract_field (self->fields[0], code, 0);
1331   info->addr.offset.regno = index;
1332   info->addr.offset.is_reg = TRUE;
1333   info->addr.writeback = FALSE;
1334   info->addr.preind = TRUE;
1335   info->shifter.kind = AARCH64_MOD_LSL;
1336   info->shifter.amount = get_operand_specific_data (self);
1337   info->shifter.operator_present = (info->shifter.amount != 0);
1338   info->shifter.amount_present = (info->shifter.amount != 0);
1339   return 1;
1340 }
1341
1342 /* Decode an SVE address [X<n>, Z<m>.<T>, (S|U)XTW {#<shift>}], where
1343    <shift> is SELF's operand-dependent value.  fields[0] specifies the
1344    base register field, fields[1] specifies the offset register field and
1345    fields[2] is a single-bit field that selects SXTW over UXTW.  */
1346 int
1347 aarch64_ext_sve_addr_rz_xtw (const aarch64_operand *self,
1348                              aarch64_opnd_info *info, aarch64_insn code,
1349                              const aarch64_inst *inst ATTRIBUTE_UNUSED)
1350 {
1351   info->addr.base_regno = extract_field (self->fields[0], code, 0);
1352   info->addr.offset.regno = extract_field (self->fields[1], code, 0);
1353   info->addr.offset.is_reg = TRUE;
1354   info->addr.writeback = FALSE;
1355   info->addr.preind = TRUE;
1356   if (extract_field (self->fields[2], code, 0))
1357     info->shifter.kind = AARCH64_MOD_SXTW;
1358   else
1359     info->shifter.kind = AARCH64_MOD_UXTW;
1360   info->shifter.amount = get_operand_specific_data (self);
1361   info->shifter.operator_present = TRUE;
1362   info->shifter.amount_present = (info->shifter.amount != 0);
1363   return 1;
1364 }
1365
1366 /* Decode an SVE address [Z<n>.<T>, #<imm5> << <shift>], where <imm5> is a
1367    5-bit unsigned number and where <shift> is SELF's operand-dependent value.
1368    fields[0] specifies the base register field.  */
1369 int
1370 aarch64_ext_sve_addr_zi_u5 (const aarch64_operand *self,
1371                             aarch64_opnd_info *info, aarch64_insn code,
1372                             const aarch64_inst *inst ATTRIBUTE_UNUSED)
1373 {
1374   int offset = extract_field (FLD_imm5, code, 0);
1375   return aarch64_ext_sve_addr_reg_imm (self, info, code, offset);
1376 }
1377
1378 /* Decode an SVE address [Z<n>.<T>, Z<m>.<T>{, <modifier> {#<msz>}}],
1379    where <modifier> is given by KIND and where <msz> is a 2-bit unsigned
1380    number.  fields[0] specifies the base register field and fields[1]
1381    specifies the offset register field.  */
1382 static int
1383 aarch64_ext_sve_addr_zz (const aarch64_operand *self, aarch64_opnd_info *info,
1384                          aarch64_insn code, enum aarch64_modifier_kind kind)
1385 {
1386   info->addr.base_regno = extract_field (self->fields[0], code, 0);
1387   info->addr.offset.regno = extract_field (self->fields[1], code, 0);
1388   info->addr.offset.is_reg = TRUE;
1389   info->addr.writeback = FALSE;
1390   info->addr.preind = TRUE;
1391   info->shifter.kind = kind;
1392   info->shifter.amount = extract_field (FLD_SVE_msz, code, 0);
1393   info->shifter.operator_present = (kind != AARCH64_MOD_LSL
1394                                     || info->shifter.amount != 0);
1395   info->shifter.amount_present = (info->shifter.amount != 0);
1396   return 1;
1397 }
1398
1399 /* Decode an SVE address [Z<n>.<T>, Z<m>.<T>{, LSL #<msz>}], where
1400    <msz> is a 2-bit unsigned number.  fields[0] specifies the base register
1401    field and fields[1] specifies the offset register field.  */
1402 int
1403 aarch64_ext_sve_addr_zz_lsl (const aarch64_operand *self,
1404                              aarch64_opnd_info *info, aarch64_insn code,
1405                              const aarch64_inst *inst ATTRIBUTE_UNUSED)
1406 {
1407   return aarch64_ext_sve_addr_zz (self, info, code, AARCH64_MOD_LSL);
1408 }
1409
1410 /* Decode an SVE address [Z<n>.<T>, Z<m>.<T>, SXTW {#<msz>}], where
1411    <msz> is a 2-bit unsigned number.  fields[0] specifies the base register
1412    field and fields[1] specifies the offset register field.  */
1413 int
1414 aarch64_ext_sve_addr_zz_sxtw (const aarch64_operand *self,
1415                               aarch64_opnd_info *info, aarch64_insn code,
1416                               const aarch64_inst *inst ATTRIBUTE_UNUSED)
1417 {
1418   return aarch64_ext_sve_addr_zz (self, info, code, AARCH64_MOD_SXTW);
1419 }
1420
1421 /* Decode an SVE address [Z<n>.<T>, Z<m>.<T>, UXTW {#<msz>}], where
1422    <msz> is a 2-bit unsigned number.  fields[0] specifies the base register
1423    field and fields[1] specifies the offset register field.  */
1424 int
1425 aarch64_ext_sve_addr_zz_uxtw (const aarch64_operand *self,
1426                               aarch64_opnd_info *info, aarch64_insn code,
1427                               const aarch64_inst *inst ATTRIBUTE_UNUSED)
1428 {
1429   return aarch64_ext_sve_addr_zz (self, info, code, AARCH64_MOD_UXTW);
1430 }
1431
1432 /* Finish decoding an SVE arithmetic immediate, given that INFO already
1433    has the raw field value and that the low 8 bits decode to VALUE.  */
1434 static int
1435 decode_sve_aimm (aarch64_opnd_info *info, int64_t value)
1436 {
1437   info->shifter.kind = AARCH64_MOD_LSL;
1438   info->shifter.amount = 0;
1439   if (info->imm.value & 0x100)
1440     {
1441       if (value == 0)
1442         /* Decode 0x100 as #0, LSL #8.  */
1443         info->shifter.amount = 8;
1444       else
1445         value *= 256;
1446     }
1447   info->shifter.operator_present = (info->shifter.amount != 0);
1448   info->shifter.amount_present = (info->shifter.amount != 0);
1449   info->imm.value = value;
1450   return 1;
1451 }
1452
1453 /* Decode an SVE ADD/SUB immediate.  */
1454 int
1455 aarch64_ext_sve_aimm (const aarch64_operand *self,
1456                       aarch64_opnd_info *info, const aarch64_insn code,
1457                       const aarch64_inst *inst)
1458 {
1459   return (aarch64_ext_imm (self, info, code, inst)
1460           && decode_sve_aimm (info, (uint8_t) info->imm.value));
1461 }
1462
1463 /* Decode an SVE CPY/DUP immediate.  */
1464 int
1465 aarch64_ext_sve_asimm (const aarch64_operand *self,
1466                        aarch64_opnd_info *info, const aarch64_insn code,
1467                        const aarch64_inst *inst)
1468 {
1469   return (aarch64_ext_imm (self, info, code, inst)
1470           && decode_sve_aimm (info, (int8_t) info->imm.value));
1471 }
1472
1473 /* Decode a single-bit immediate that selects between #0.5 and #1.0.
1474    The fields array specifies which field to use.  */
1475 int
1476 aarch64_ext_sve_float_half_one (const aarch64_operand *self,
1477                                 aarch64_opnd_info *info, aarch64_insn code,
1478                                 const aarch64_inst *inst ATTRIBUTE_UNUSED)
1479 {
1480   if (extract_field (self->fields[0], code, 0))
1481     info->imm.value = 0x3f800000;
1482   else
1483     info->imm.value = 0x3f000000;
1484   info->imm.is_fp = TRUE;
1485   return 1;
1486 }
1487
1488 /* Decode a single-bit immediate that selects between #0.5 and #2.0.
1489    The fields array specifies which field to use.  */
1490 int
1491 aarch64_ext_sve_float_half_two (const aarch64_operand *self,
1492                                 aarch64_opnd_info *info, aarch64_insn code,
1493                                 const aarch64_inst *inst ATTRIBUTE_UNUSED)
1494 {
1495   if (extract_field (self->fields[0], code, 0))
1496     info->imm.value = 0x40000000;
1497   else
1498     info->imm.value = 0x3f000000;
1499   info->imm.is_fp = TRUE;
1500   return 1;
1501 }
1502
1503 /* Decode a single-bit immediate that selects between #0.0 and #1.0.
1504    The fields array specifies which field to use.  */
1505 int
1506 aarch64_ext_sve_float_zero_one (const aarch64_operand *self,
1507                                 aarch64_opnd_info *info, aarch64_insn code,
1508                                 const aarch64_inst *inst ATTRIBUTE_UNUSED)
1509 {
1510   if (extract_field (self->fields[0], code, 0))
1511     info->imm.value = 0x3f800000;
1512   else
1513     info->imm.value = 0x0;
1514   info->imm.is_fp = TRUE;
1515   return 1;
1516 }
1517
1518 /* Decode Zn[MM], where MM has a 7-bit triangular encoding.  The fields
1519    array specifies which field to use for Zn.  MM is encoded in the
1520    concatenation of imm5 and SVE_tszh, with imm5 being the less
1521    significant part.  */
1522 int
1523 aarch64_ext_sve_index (const aarch64_operand *self,
1524                        aarch64_opnd_info *info, aarch64_insn code,
1525                        const aarch64_inst *inst ATTRIBUTE_UNUSED)
1526 {
1527   int val;
1528
1529   info->reglane.regno = extract_field (self->fields[0], code, 0);
1530   val = extract_fields (code, 0, 2, FLD_SVE_tszh, FLD_imm5);
1531   if ((val & 15) == 0)
1532     return 0;
1533   while ((val & 1) == 0)
1534     val /= 2;
1535   info->reglane.index = val / 2;
1536   return 1;
1537 }
1538
1539 /* Decode a logical immediate for the MOV alias of SVE DUPM.  */
1540 int
1541 aarch64_ext_sve_limm_mov (const aarch64_operand *self,
1542                           aarch64_opnd_info *info, const aarch64_insn code,
1543                           const aarch64_inst *inst)
1544 {
1545   int esize = aarch64_get_qualifier_esize (inst->operands[0].qualifier);
1546   return (aarch64_ext_limm (self, info, code, inst)
1547           && aarch64_sve_dupm_mov_immediate_p (info->imm.value, esize));
1548 }
1549
1550 /* Decode {Zn.<T> - Zm.<T>}.  The fields array specifies which field
1551    to use for Zn.  The opcode-dependent value specifies the number
1552    of registers in the list.  */
1553 int
1554 aarch64_ext_sve_reglist (const aarch64_operand *self,
1555                          aarch64_opnd_info *info, aarch64_insn code,
1556                          const aarch64_inst *inst ATTRIBUTE_UNUSED)
1557 {
1558   info->reglist.first_regno = extract_field (self->fields[0], code, 0);
1559   info->reglist.num_regs = get_opcode_dependent_value (inst->opcode);
1560   return 1;
1561 }
1562
1563 /* Decode <pattern>{, MUL #<amount>}.  The fields array specifies which
1564    fields to use for <pattern>.  <amount> - 1 is encoded in the SVE_imm4
1565    field.  */
1566 int
1567 aarch64_ext_sve_scale (const aarch64_operand *self,
1568                        aarch64_opnd_info *info, aarch64_insn code,
1569                        const aarch64_inst *inst)
1570 {
1571   int val;
1572
1573   if (!aarch64_ext_imm (self, info, code, inst))
1574     return 0;
1575   val = extract_field (FLD_SVE_imm4, code, 0);
1576   info->shifter.kind = AARCH64_MOD_MUL;
1577   info->shifter.amount = val + 1;
1578   info->shifter.operator_present = (val != 0);
1579   info->shifter.amount_present = (val != 0);
1580   return 1;
1581 }
1582
1583 /* Return the top set bit in VALUE, which is expected to be relatively
1584    small.  */
1585 static uint64_t
1586 get_top_bit (uint64_t value)
1587 {
1588   while ((value & -value) != value)
1589     value -= value & -value;
1590   return value;
1591 }
1592
1593 /* Decode an SVE shift-left immediate.  */
1594 int
1595 aarch64_ext_sve_shlimm (const aarch64_operand *self,
1596                         aarch64_opnd_info *info, const aarch64_insn code,
1597                         const aarch64_inst *inst)
1598 {
1599   if (!aarch64_ext_imm (self, info, code, inst)
1600       || info->imm.value == 0)
1601     return 0;
1602
1603   info->imm.value -= get_top_bit (info->imm.value);
1604   return 1;
1605 }
1606
1607 /* Decode an SVE shift-right immediate.  */
1608 int
1609 aarch64_ext_sve_shrimm (const aarch64_operand *self,
1610                         aarch64_opnd_info *info, const aarch64_insn code,
1611                         const aarch64_inst *inst)
1612 {
1613   if (!aarch64_ext_imm (self, info, code, inst)
1614       || info->imm.value == 0)
1615     return 0;
1616
1617   info->imm.value = get_top_bit (info->imm.value) * 2 - info->imm.value;
1618   return 1;
1619 }
1620 \f
1621 /* Bitfields that are commonly used to encode certain operands' information
1622    may be partially used as part of the base opcode in some instructions.
1623    For example, the bit 1 of the field 'size' in
1624      FCVTXN <Vb><d>, <Va><n>
1625    is actually part of the base opcode, while only size<0> is available
1626    for encoding the register type.  Another example is the AdvSIMD
1627    instruction ORR (register), in which the field 'size' is also used for
1628    the base opcode, leaving only the field 'Q' available to encode the
1629    vector register arrangement specifier '8B' or '16B'.
1630
1631    This function tries to deduce the qualifier from the value of partially
1632    constrained field(s).  Given the VALUE of such a field or fields, the
1633    qualifiers CANDIDATES and the MASK (indicating which bits are valid for
1634    operand encoding), the function returns the matching qualifier or
1635    AARCH64_OPND_QLF_NIL if nothing matches.
1636
1637    N.B. CANDIDATES is a group of possible qualifiers that are valid for
1638    one operand; it has a maximum of AARCH64_MAX_QLF_SEQ_NUM qualifiers and
1639    may end with AARCH64_OPND_QLF_NIL.  */
1640
1641 static enum aarch64_opnd_qualifier
1642 get_qualifier_from_partial_encoding (aarch64_insn value,
1643                                      const enum aarch64_opnd_qualifier* \
1644                                      candidates,
1645                                      aarch64_insn mask)
1646 {
1647   int i;
1648   DEBUG_TRACE ("enter with value: %d, mask: %d", (int)value, (int)mask);
1649   for (i = 0; i < AARCH64_MAX_QLF_SEQ_NUM; ++i)
1650     {
1651       aarch64_insn standard_value;
1652       if (candidates[i] == AARCH64_OPND_QLF_NIL)
1653         break;
1654       standard_value = aarch64_get_qualifier_standard_value (candidates[i]);
1655       if ((standard_value & mask) == (value & mask))
1656         return candidates[i];
1657     }
1658   return AARCH64_OPND_QLF_NIL;
1659 }
1660
1661 /* Given a list of qualifier sequences, return all possible valid qualifiers
1662    for operand IDX in QUALIFIERS.
1663    Assume QUALIFIERS is an array whose length is large enough.  */
1664
1665 static void
1666 get_operand_possible_qualifiers (int idx,
1667                                  const aarch64_opnd_qualifier_seq_t *list,
1668                                  enum aarch64_opnd_qualifier *qualifiers)
1669 {
1670   int i;
1671   for (i = 0; i < AARCH64_MAX_QLF_SEQ_NUM; ++i)
1672     if ((qualifiers[i] = list[i][idx]) == AARCH64_OPND_QLF_NIL)
1673       break;
1674 }
1675
1676 /* Decode the size Q field for e.g. SHADD.
1677    We tag one operand with the qualifer according to the code;
1678    whether the qualifier is valid for this opcode or not, it is the
1679    duty of the semantic checking.  */
1680
1681 static int
1682 decode_sizeq (aarch64_inst *inst)
1683 {
1684   int idx;
1685   enum aarch64_opnd_qualifier qualifier;
1686   aarch64_insn code;
1687   aarch64_insn value, mask;
1688   enum aarch64_field_kind fld_sz;
1689   enum aarch64_opnd_qualifier candidates[AARCH64_MAX_QLF_SEQ_NUM];
1690
1691   if (inst->opcode->iclass == asisdlse
1692      || inst->opcode->iclass == asisdlsep
1693      || inst->opcode->iclass == asisdlso
1694      || inst->opcode->iclass == asisdlsop)
1695     fld_sz = FLD_vldst_size;
1696   else
1697     fld_sz = FLD_size;
1698
1699   code = inst->value;
1700   value = extract_fields (code, inst->opcode->mask, 2, fld_sz, FLD_Q);
1701   /* Obtain the info that which bits of fields Q and size are actually
1702      available for operand encoding.  Opcodes like FMAXNM and FMLA have
1703      size[1] unavailable.  */
1704   mask = extract_fields (~inst->opcode->mask, 0, 2, fld_sz, FLD_Q);
1705
1706   /* The index of the operand we are going to tag a qualifier and the qualifer
1707      itself are reasoned from the value of the size and Q fields and the
1708      possible valid qualifier lists.  */
1709   idx = aarch64_select_operand_for_sizeq_field_coding (inst->opcode);
1710   DEBUG_TRACE ("key idx: %d", idx);
1711
1712   /* For most related instruciton, size:Q are fully available for operand
1713      encoding.  */
1714   if (mask == 0x7)
1715     {
1716       inst->operands[idx].qualifier = get_vreg_qualifier_from_value (value);
1717       return 1;
1718     }
1719
1720   get_operand_possible_qualifiers (idx, inst->opcode->qualifiers_list,
1721                                    candidates);
1722 #ifdef DEBUG_AARCH64
1723   if (debug_dump)
1724     {
1725       int i;
1726       for (i = 0; candidates[i] != AARCH64_OPND_QLF_NIL
1727            && i < AARCH64_MAX_QLF_SEQ_NUM; ++i)
1728         DEBUG_TRACE ("qualifier %d: %s", i,
1729                      aarch64_get_qualifier_name(candidates[i]));
1730       DEBUG_TRACE ("%d, %d", (int)value, (int)mask);
1731     }
1732 #endif /* DEBUG_AARCH64 */
1733
1734   qualifier = get_qualifier_from_partial_encoding (value, candidates, mask);
1735
1736   if (qualifier == AARCH64_OPND_QLF_NIL)
1737     return 0;
1738
1739   inst->operands[idx].qualifier = qualifier;
1740   return 1;
1741 }
1742
1743 /* Decode size[0]:Q, i.e. bit 22 and bit 30, for
1744      e.g. FCVTN<Q> <Vd>.<Tb>, <Vn>.<Ta>.  */
1745
1746 static int
1747 decode_asimd_fcvt (aarch64_inst *inst)
1748 {
1749   aarch64_field field = {0, 0};
1750   aarch64_insn value;
1751   enum aarch64_opnd_qualifier qualifier;
1752
1753   gen_sub_field (FLD_size, 0, 1, &field);
1754   value = extract_field_2 (&field, inst->value, 0);
1755   qualifier = value == 0 ? AARCH64_OPND_QLF_V_4S
1756     : AARCH64_OPND_QLF_V_2D;
1757   switch (inst->opcode->op)
1758     {
1759     case OP_FCVTN:
1760     case OP_FCVTN2:
1761       /* FCVTN<Q> <Vd>.<Tb>, <Vn>.<Ta>.  */
1762       inst->operands[1].qualifier = qualifier;
1763       break;
1764     case OP_FCVTL:
1765     case OP_FCVTL2:
1766       /* FCVTL<Q> <Vd>.<Ta>, <Vn>.<Tb>.  */
1767       inst->operands[0].qualifier = qualifier;
1768       break;
1769     default:
1770       assert (0);
1771       return 0;
1772     }
1773
1774   return 1;
1775 }
1776
1777 /* Decode size[0], i.e. bit 22, for
1778      e.g. FCVTXN <Vb><d>, <Va><n>.  */
1779
1780 static int
1781 decode_asisd_fcvtxn (aarch64_inst *inst)
1782 {
1783   aarch64_field field = {0, 0};
1784   gen_sub_field (FLD_size, 0, 1, &field);
1785   if (!extract_field_2 (&field, inst->value, 0))
1786     return 0;
1787   inst->operands[0].qualifier = AARCH64_OPND_QLF_S_S;
1788   return 1;
1789 }
1790
1791 /* Decode the 'opc' field for e.g. FCVT <Dd>, <Sn>.  */
1792 static int
1793 decode_fcvt (aarch64_inst *inst)
1794 {
1795   enum aarch64_opnd_qualifier qualifier;
1796   aarch64_insn value;
1797   const aarch64_field field = {15, 2};
1798
1799   /* opc dstsize */
1800   value = extract_field_2 (&field, inst->value, 0);
1801   switch (value)
1802     {
1803     case 0: qualifier = AARCH64_OPND_QLF_S_S; break;
1804     case 1: qualifier = AARCH64_OPND_QLF_S_D; break;
1805     case 3: qualifier = AARCH64_OPND_QLF_S_H; break;
1806     default: return 0;
1807     }
1808   inst->operands[0].qualifier = qualifier;
1809
1810   return 1;
1811 }
1812
1813 /* Do miscellaneous decodings that are not common enough to be driven by
1814    flags.  */
1815
1816 static int
1817 do_misc_decoding (aarch64_inst *inst)
1818 {
1819   unsigned int value;
1820   switch (inst->opcode->op)
1821     {
1822     case OP_FCVT:
1823       return decode_fcvt (inst);
1824
1825     case OP_FCVTN:
1826     case OP_FCVTN2:
1827     case OP_FCVTL:
1828     case OP_FCVTL2:
1829       return decode_asimd_fcvt (inst);
1830
1831     case OP_FCVTXN_S:
1832       return decode_asisd_fcvtxn (inst);
1833
1834     case OP_MOV_P_P:
1835     case OP_MOVS_P_P:
1836       value = extract_field (FLD_SVE_Pn, inst->value, 0);
1837       return (value == extract_field (FLD_SVE_Pm, inst->value, 0)
1838               && value == extract_field (FLD_SVE_Pg4_10, inst->value, 0));
1839
1840     case OP_MOV_Z_P_Z:
1841       return (extract_field (FLD_SVE_Zd, inst->value, 0)
1842               == extract_field (FLD_SVE_Zm_16, inst->value, 0));
1843
1844     case OP_MOV_Z_V:
1845       /* Index must be zero.  */
1846       value = extract_fields (inst->value, 0, 2, FLD_SVE_tszh, FLD_imm5);
1847       return value == 1 || value == 2 || value == 4 || value == 8;
1848
1849     case OP_MOV_Z_Z:
1850       return (extract_field (FLD_SVE_Zn, inst->value, 0)
1851               == extract_field (FLD_SVE_Zm_16, inst->value, 0));
1852
1853     case OP_MOV_Z_Zi:
1854       /* Index must be nonzero.  */
1855       value = extract_fields (inst->value, 0, 2, FLD_SVE_tszh, FLD_imm5);
1856       return value != 1 && value != 2 && value != 4 && value != 8;
1857
1858     case OP_MOVM_P_P_P:
1859       return (extract_field (FLD_SVE_Pd, inst->value, 0)
1860               == extract_field (FLD_SVE_Pm, inst->value, 0));
1861
1862     case OP_MOVZS_P_P_P:
1863     case OP_MOVZ_P_P_P:
1864       return (extract_field (FLD_SVE_Pn, inst->value, 0)
1865               == extract_field (FLD_SVE_Pm, inst->value, 0));
1866
1867     case OP_NOTS_P_P_P_Z:
1868     case OP_NOT_P_P_P_Z:
1869       return (extract_field (FLD_SVE_Pm, inst->value, 0)
1870               == extract_field (FLD_SVE_Pg4_10, inst->value, 0));
1871
1872     default:
1873       return 0;
1874     }
1875 }
1876
1877 /* Opcodes that have fields shared by multiple operands are usually flagged
1878    with flags.  In this function, we detect such flags, decode the related
1879    field(s) and store the information in one of the related operands.  The
1880    'one' operand is not any operand but one of the operands that can
1881    accommadate all the information that has been decoded.  */
1882
1883 static int
1884 do_special_decoding (aarch64_inst *inst)
1885 {
1886   int idx;
1887   aarch64_insn value;
1888   /* Condition for truly conditional executed instructions, e.g. b.cond.  */
1889   if (inst->opcode->flags & F_COND)
1890     {
1891       value = extract_field (FLD_cond2, inst->value, 0);
1892       inst->cond = get_cond_from_value (value);
1893     }
1894   /* 'sf' field.  */
1895   if (inst->opcode->flags & F_SF)
1896     {
1897       idx = select_operand_for_sf_field_coding (inst->opcode);
1898       value = extract_field (FLD_sf, inst->value, 0);
1899       inst->operands[idx].qualifier = get_greg_qualifier_from_value (value);
1900       if ((inst->opcode->flags & F_N)
1901           && extract_field (FLD_N, inst->value, 0) != value)
1902         return 0;
1903     }
1904   /* 'sf' field.  */
1905   if (inst->opcode->flags & F_LSE_SZ)
1906     {
1907       idx = select_operand_for_sf_field_coding (inst->opcode);
1908       value = extract_field (FLD_lse_sz, inst->value, 0);
1909       inst->operands[idx].qualifier = get_greg_qualifier_from_value (value);
1910     }
1911   /* size:Q fields.  */
1912   if (inst->opcode->flags & F_SIZEQ)
1913     return decode_sizeq (inst);
1914
1915   if (inst->opcode->flags & F_FPTYPE)
1916     {
1917       idx = select_operand_for_fptype_field_coding (inst->opcode);
1918       value = extract_field (FLD_type, inst->value, 0);
1919       switch (value)
1920         {
1921         case 0: inst->operands[idx].qualifier = AARCH64_OPND_QLF_S_S; break;
1922         case 1: inst->operands[idx].qualifier = AARCH64_OPND_QLF_S_D; break;
1923         case 3: inst->operands[idx].qualifier = AARCH64_OPND_QLF_S_H; break;
1924         default: return 0;
1925         }
1926     }
1927
1928   if (inst->opcode->flags & F_SSIZE)
1929     {
1930       /* N.B. some opcodes like FCMGT <V><d>, <V><n>, #0 have the size[1] as part
1931          of the base opcode.  */
1932       aarch64_insn mask;
1933       enum aarch64_opnd_qualifier candidates[AARCH64_MAX_QLF_SEQ_NUM];
1934       idx = select_operand_for_scalar_size_field_coding (inst->opcode);
1935       value = extract_field (FLD_size, inst->value, inst->opcode->mask);
1936       mask = extract_field (FLD_size, ~inst->opcode->mask, 0);
1937       /* For most related instruciton, the 'size' field is fully available for
1938          operand encoding.  */
1939       if (mask == 0x3)
1940         inst->operands[idx].qualifier = get_sreg_qualifier_from_value (value);
1941       else
1942         {
1943           get_operand_possible_qualifiers (idx, inst->opcode->qualifiers_list,
1944                                            candidates);
1945           inst->operands[idx].qualifier
1946             = get_qualifier_from_partial_encoding (value, candidates, mask);
1947         }
1948     }
1949
1950   if (inst->opcode->flags & F_T)
1951     {
1952       /* Num of consecutive '0's on the right side of imm5<3:0>.  */
1953       int num = 0;
1954       unsigned val, Q;
1955       assert (aarch64_get_operand_class (inst->opcode->operands[0])
1956               == AARCH64_OPND_CLASS_SIMD_REG);
1957       /* imm5<3:0>      q       <t>
1958          0000           x       reserved
1959          xxx1           0       8b
1960          xxx1           1       16b
1961          xx10           0       4h
1962          xx10           1       8h
1963          x100           0       2s
1964          x100           1       4s
1965          1000           0       reserved
1966          1000           1       2d  */
1967       val = extract_field (FLD_imm5, inst->value, 0);
1968       while ((val & 0x1) == 0 && ++num <= 3)
1969         val >>= 1;
1970       if (num > 3)
1971         return 0;
1972       Q = (unsigned) extract_field (FLD_Q, inst->value, inst->opcode->mask);
1973       inst->operands[0].qualifier =
1974         get_vreg_qualifier_from_value ((num << 1) | Q);
1975     }
1976
1977   if (inst->opcode->flags & F_GPRSIZE_IN_Q)
1978     {
1979       /* Use Rt to encode in the case of e.g.
1980          STXP <Ws>, <Xt1>, <Xt2>, [<Xn|SP>{,#0}].  */
1981       idx = aarch64_operand_index (inst->opcode->operands, AARCH64_OPND_Rt);
1982       if (idx == -1)
1983         {
1984           /* Otherwise use the result operand, which has to be a integer
1985              register.  */
1986           assert (aarch64_get_operand_class (inst->opcode->operands[0])
1987                   == AARCH64_OPND_CLASS_INT_REG);
1988           idx = 0;
1989         }
1990       assert (idx == 0 || idx == 1);
1991       value = extract_field (FLD_Q, inst->value, 0);
1992       inst->operands[idx].qualifier = get_greg_qualifier_from_value (value);
1993     }
1994
1995   if (inst->opcode->flags & F_LDS_SIZE)
1996     {
1997       aarch64_field field = {0, 0};
1998       assert (aarch64_get_operand_class (inst->opcode->operands[0])
1999               == AARCH64_OPND_CLASS_INT_REG);
2000       gen_sub_field (FLD_opc, 0, 1, &field);
2001       value = extract_field_2 (&field, inst->value, 0);
2002       inst->operands[0].qualifier
2003         = value ? AARCH64_OPND_QLF_W : AARCH64_OPND_QLF_X;
2004     }
2005
2006   /* Miscellaneous decoding; done as the last step.  */
2007   if (inst->opcode->flags & F_MISC)
2008     return do_misc_decoding (inst);
2009
2010   return 1;
2011 }
2012
2013 /* Converters converting a real opcode instruction to its alias form.  */
2014
2015 /* ROR <Wd>, <Ws>, #<shift>
2016      is equivalent to:
2017    EXTR <Wd>, <Ws>, <Ws>, #<shift>.  */
2018 static int
2019 convert_extr_to_ror (aarch64_inst *inst)
2020 {
2021   if (inst->operands[1].reg.regno == inst->operands[2].reg.regno)
2022     {
2023       copy_operand_info (inst, 2, 3);
2024       inst->operands[3].type = AARCH64_OPND_NIL;
2025       return 1;
2026     }
2027   return 0;
2028 }
2029
2030 /* UXTL<Q> <Vd>.<Ta>, <Vn>.<Tb>
2031      is equivalent to:
2032    USHLL<Q> <Vd>.<Ta>, <Vn>.<Tb>, #0.  */
2033 static int
2034 convert_shll_to_xtl (aarch64_inst *inst)
2035 {
2036   if (inst->operands[2].imm.value == 0)
2037     {
2038       inst->operands[2].type = AARCH64_OPND_NIL;
2039       return 1;
2040     }
2041   return 0;
2042 }
2043
2044 /* Convert
2045      UBFM <Xd>, <Xn>, #<shift>, #63.
2046    to
2047      LSR <Xd>, <Xn>, #<shift>.  */
2048 static int
2049 convert_bfm_to_sr (aarch64_inst *inst)
2050 {
2051   int64_t imms, val;
2052
2053   imms = inst->operands[3].imm.value;
2054   val = inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31 ? 31 : 63;
2055   if (imms == val)
2056     {
2057       inst->operands[3].type = AARCH64_OPND_NIL;
2058       return 1;
2059     }
2060
2061   return 0;
2062 }
2063
2064 /* Convert MOV to ORR.  */
2065 static int
2066 convert_orr_to_mov (aarch64_inst *inst)
2067 {
2068   /* MOV <Vd>.<T>, <Vn>.<T>
2069      is equivalent to:
2070      ORR <Vd>.<T>, <Vn>.<T>, <Vn>.<T>.  */
2071   if (inst->operands[1].reg.regno == inst->operands[2].reg.regno)
2072     {
2073       inst->operands[2].type = AARCH64_OPND_NIL;
2074       return 1;
2075     }
2076   return 0;
2077 }
2078
2079 /* When <imms> >= <immr>, the instruction written:
2080      SBFX <Xd>, <Xn>, #<lsb>, #<width>
2081    is equivalent to:
2082      SBFM <Xd>, <Xn>, #<lsb>, #(<lsb>+<width>-1).  */
2083
2084 static int
2085 convert_bfm_to_bfx (aarch64_inst *inst)
2086 {
2087   int64_t immr, imms;
2088
2089   immr = inst->operands[2].imm.value;
2090   imms = inst->operands[3].imm.value;
2091   if (imms >= immr)
2092     {
2093       int64_t lsb = immr;
2094       inst->operands[2].imm.value = lsb;
2095       inst->operands[3].imm.value = imms + 1 - lsb;
2096       /* The two opcodes have different qualifiers for
2097          the immediate operands; reset to help the checking.  */
2098       reset_operand_qualifier (inst, 2);
2099       reset_operand_qualifier (inst, 3);
2100       return 1;
2101     }
2102
2103   return 0;
2104 }
2105
2106 /* When <imms> < <immr>, the instruction written:
2107      SBFIZ <Xd>, <Xn>, #<lsb>, #<width>
2108    is equivalent to:
2109      SBFM <Xd>, <Xn>, #((64-<lsb>)&0x3f), #(<width>-1).  */
2110
2111 static int
2112 convert_bfm_to_bfi (aarch64_inst *inst)
2113 {
2114   int64_t immr, imms, val;
2115
2116   immr = inst->operands[2].imm.value;
2117   imms = inst->operands[3].imm.value;
2118   val = inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31 ? 32 : 64;
2119   if (imms < immr)
2120     {
2121       inst->operands[2].imm.value = (val - immr) & (val - 1);
2122       inst->operands[3].imm.value = imms + 1;
2123       /* The two opcodes have different qualifiers for
2124          the immediate operands; reset to help the checking.  */
2125       reset_operand_qualifier (inst, 2);
2126       reset_operand_qualifier (inst, 3);
2127       return 1;
2128     }
2129
2130   return 0;
2131 }
2132
2133 /* The instruction written:
2134      BFC <Xd>, #<lsb>, #<width>
2135    is equivalent to:
2136      BFM <Xd>, XZR, #((64-<lsb>)&0x3f), #(<width>-1).  */
2137
2138 static int
2139 convert_bfm_to_bfc (aarch64_inst *inst)
2140 {
2141   int64_t immr, imms, val;
2142
2143   /* Should have been assured by the base opcode value.  */
2144   assert (inst->operands[1].reg.regno == 0x1f);
2145
2146   immr = inst->operands[2].imm.value;
2147   imms = inst->operands[3].imm.value;
2148   val = inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31 ? 32 : 64;
2149   if (imms < immr)
2150     {
2151       /* Drop XZR from the second operand.  */
2152       copy_operand_info (inst, 1, 2);
2153       copy_operand_info (inst, 2, 3);
2154       inst->operands[3].type = AARCH64_OPND_NIL;
2155
2156       /* Recalculate the immediates.  */
2157       inst->operands[1].imm.value = (val - immr) & (val - 1);
2158       inst->operands[2].imm.value = imms + 1;
2159
2160       /* The two opcodes have different qualifiers for the operands; reset to
2161          help the checking.  */
2162       reset_operand_qualifier (inst, 1);
2163       reset_operand_qualifier (inst, 2);
2164       reset_operand_qualifier (inst, 3);
2165
2166       return 1;
2167     }
2168
2169   return 0;
2170 }
2171
2172 /* The instruction written:
2173      LSL <Xd>, <Xn>, #<shift>
2174    is equivalent to:
2175      UBFM <Xd>, <Xn>, #((64-<shift>)&0x3f), #(63-<shift>).  */
2176
2177 static int
2178 convert_ubfm_to_lsl (aarch64_inst *inst)
2179 {
2180   int64_t immr = inst->operands[2].imm.value;
2181   int64_t imms = inst->operands[3].imm.value;
2182   int64_t val
2183     = inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31 ? 31 : 63;
2184
2185   if ((immr == 0 && imms == val) || immr == imms + 1)
2186     {
2187       inst->operands[3].type = AARCH64_OPND_NIL;
2188       inst->operands[2].imm.value = val - imms;
2189       return 1;
2190     }
2191
2192   return 0;
2193 }
2194
2195 /* CINC <Wd>, <Wn>, <cond>
2196      is equivalent to:
2197    CSINC <Wd>, <Wn>, <Wn>, invert(<cond>)
2198      where <cond> is not AL or NV.  */
2199
2200 static int
2201 convert_from_csel (aarch64_inst *inst)
2202 {
2203   if (inst->operands[1].reg.regno == inst->operands[2].reg.regno
2204       && (inst->operands[3].cond->value & 0xe) != 0xe)
2205     {
2206       copy_operand_info (inst, 2, 3);
2207       inst->operands[2].cond = get_inverted_cond (inst->operands[3].cond);
2208       inst->operands[3].type = AARCH64_OPND_NIL;
2209       return 1;
2210     }
2211   return 0;
2212 }
2213
2214 /* CSET <Wd>, <cond>
2215      is equivalent to:
2216    CSINC <Wd>, WZR, WZR, invert(<cond>)
2217      where <cond> is not AL or NV.  */
2218
2219 static int
2220 convert_csinc_to_cset (aarch64_inst *inst)
2221 {
2222   if (inst->operands[1].reg.regno == 0x1f
2223       && inst->operands[2].reg.regno == 0x1f
2224       && (inst->operands[3].cond->value & 0xe) != 0xe)
2225     {
2226       copy_operand_info (inst, 1, 3);
2227       inst->operands[1].cond = get_inverted_cond (inst->operands[3].cond);
2228       inst->operands[3].type = AARCH64_OPND_NIL;
2229       inst->operands[2].type = AARCH64_OPND_NIL;
2230       return 1;
2231     }
2232   return 0;
2233 }
2234
2235 /* MOV <Wd>, #<imm>
2236      is equivalent to:
2237    MOVZ <Wd>, #<imm16>, LSL #<shift>.
2238
2239    A disassembler may output ORR, MOVZ and MOVN as a MOV mnemonic, except when
2240    ORR has an immediate that could be generated by a MOVZ or MOVN instruction,
2241    or where a MOVN has an immediate that could be encoded by MOVZ, or where
2242    MOVZ/MOVN #0 have a shift amount other than LSL #0, in which case the
2243    machine-instruction mnemonic must be used.  */
2244
2245 static int
2246 convert_movewide_to_mov (aarch64_inst *inst)
2247 {
2248   uint64_t value = inst->operands[1].imm.value;
2249   /* MOVZ/MOVN #0 have a shift amount other than LSL #0.  */
2250   if (value == 0 && inst->operands[1].shifter.amount != 0)
2251     return 0;
2252   inst->operands[1].type = AARCH64_OPND_IMM_MOV;
2253   inst->operands[1].shifter.kind = AARCH64_MOD_NONE;
2254   value <<= inst->operands[1].shifter.amount;
2255   /* As an alias convertor, it has to be clear that the INST->OPCODE
2256      is the opcode of the real instruction.  */
2257   if (inst->opcode->op == OP_MOVN)
2258     {
2259       int is32 = inst->operands[0].qualifier == AARCH64_OPND_QLF_W;
2260       value = ~value;
2261       /* A MOVN has an immediate that could be encoded by MOVZ.  */
2262       if (aarch64_wide_constant_p (value, is32, NULL) == TRUE)
2263         return 0;
2264     }
2265   inst->operands[1].imm.value = value;
2266   inst->operands[1].shifter.amount = 0;
2267   return 1;
2268 }
2269
2270 /* MOV <Wd>, #<imm>
2271      is equivalent to:
2272    ORR <Wd>, WZR, #<imm>.
2273
2274    A disassembler may output ORR, MOVZ and MOVN as a MOV mnemonic, except when
2275    ORR has an immediate that could be generated by a MOVZ or MOVN instruction,
2276    or where a MOVN has an immediate that could be encoded by MOVZ, or where
2277    MOVZ/MOVN #0 have a shift amount other than LSL #0, in which case the
2278    machine-instruction mnemonic must be used.  */
2279
2280 static int
2281 convert_movebitmask_to_mov (aarch64_inst *inst)
2282 {
2283   int is32;
2284   uint64_t value;
2285
2286   /* Should have been assured by the base opcode value.  */
2287   assert (inst->operands[1].reg.regno == 0x1f);
2288   copy_operand_info (inst, 1, 2);
2289   is32 = inst->operands[0].qualifier == AARCH64_OPND_QLF_W;
2290   inst->operands[1].type = AARCH64_OPND_IMM_MOV;
2291   value = inst->operands[1].imm.value;
2292   /* ORR has an immediate that could be generated by a MOVZ or MOVN
2293      instruction.  */
2294   if (inst->operands[0].reg.regno != 0x1f
2295       && (aarch64_wide_constant_p (value, is32, NULL) == TRUE
2296           || aarch64_wide_constant_p (~value, is32, NULL) == TRUE))
2297     return 0;
2298
2299   inst->operands[2].type = AARCH64_OPND_NIL;
2300   return 1;
2301 }
2302
2303 /* Some alias opcodes are disassembled by being converted from their real-form.
2304    N.B. INST->OPCODE is the real opcode rather than the alias.  */
2305
2306 static int
2307 convert_to_alias (aarch64_inst *inst, const aarch64_opcode *alias)
2308 {
2309   switch (alias->op)
2310     {
2311     case OP_ASR_IMM:
2312     case OP_LSR_IMM:
2313       return convert_bfm_to_sr (inst);
2314     case OP_LSL_IMM:
2315       return convert_ubfm_to_lsl (inst);
2316     case OP_CINC:
2317     case OP_CINV:
2318     case OP_CNEG:
2319       return convert_from_csel (inst);
2320     case OP_CSET:
2321     case OP_CSETM:
2322       return convert_csinc_to_cset (inst);
2323     case OP_UBFX:
2324     case OP_BFXIL:
2325     case OP_SBFX:
2326       return convert_bfm_to_bfx (inst);
2327     case OP_SBFIZ:
2328     case OP_BFI:
2329     case OP_UBFIZ:
2330       return convert_bfm_to_bfi (inst);
2331     case OP_BFC:
2332       return convert_bfm_to_bfc (inst);
2333     case OP_MOV_V:
2334       return convert_orr_to_mov (inst);
2335     case OP_MOV_IMM_WIDE:
2336     case OP_MOV_IMM_WIDEN:
2337       return convert_movewide_to_mov (inst);
2338     case OP_MOV_IMM_LOG:
2339       return convert_movebitmask_to_mov (inst);
2340     case OP_ROR_IMM:
2341       return convert_extr_to_ror (inst);
2342     case OP_SXTL:
2343     case OP_SXTL2:
2344     case OP_UXTL:
2345     case OP_UXTL2:
2346       return convert_shll_to_xtl (inst);
2347     default:
2348       return 0;
2349     }
2350 }
2351
2352 static int aarch64_opcode_decode (const aarch64_opcode *, const aarch64_insn,
2353                                   aarch64_inst *, int);
2354
2355 /* Given the instruction information in *INST, check if the instruction has
2356    any alias form that can be used to represent *INST.  If the answer is yes,
2357    update *INST to be in the form of the determined alias.  */
2358
2359 /* In the opcode description table, the following flags are used in opcode
2360    entries to help establish the relations between the real and alias opcodes:
2361
2362         F_ALIAS:        opcode is an alias
2363         F_HAS_ALIAS:    opcode has alias(es)
2364         F_P1
2365         F_P2
2366         F_P3:           Disassembly preference priority 1-3 (the larger the
2367                         higher).  If nothing is specified, it is the priority
2368                         0 by default, i.e. the lowest priority.
2369
2370    Although the relation between the machine and the alias instructions are not
2371    explicitly described, it can be easily determined from the base opcode
2372    values, masks and the flags F_ALIAS and F_HAS_ALIAS in their opcode
2373    description entries:
2374
2375    The mask of an alias opcode must be equal to or a super-set (i.e. more
2376    constrained) of that of the aliased opcode; so is the base opcode value.
2377
2378    if (opcode_has_alias (real) && alias_opcode_p (opcode)
2379        && (opcode->mask & real->mask) == real->mask
2380        && (real->mask & opcode->opcode) == (real->mask & real->opcode))
2381    then OPCODE is an alias of, and only of, the REAL instruction
2382
2383    The alias relationship is forced flat-structured to keep related algorithm
2384    simple; an opcode entry cannot be flagged with both F_ALIAS and F_HAS_ALIAS.
2385
2386    During the disassembling, the decoding decision tree (in
2387    opcodes/aarch64-dis-2.c) always returns an machine instruction opcode entry;
2388    if the decoding of such a machine instruction succeeds (and -Mno-aliases is
2389    not specified), the disassembler will check whether there is any alias
2390    instruction exists for this real instruction.  If there is, the disassembler
2391    will try to disassemble the 32-bit binary again using the alias's rule, or
2392    try to convert the IR to the form of the alias.  In the case of the multiple
2393    aliases, the aliases are tried one by one from the highest priority
2394    (currently the flag F_P3) to the lowest priority (no priority flag), and the
2395    first succeeds first adopted.
2396
2397    You may ask why there is a need for the conversion of IR from one form to
2398    another in handling certain aliases.  This is because on one hand it avoids
2399    adding more operand code to handle unusual encoding/decoding; on other
2400    hand, during the disassembling, the conversion is an effective approach to
2401    check the condition of an alias (as an alias may be adopted only if certain
2402    conditions are met).
2403
2404    In order to speed up the alias opcode lookup, aarch64-gen has preprocessed
2405    aarch64_opcode_table and generated aarch64_find_alias_opcode and
2406    aarch64_find_next_alias_opcode (in opcodes/aarch64-dis-2.c) to help.  */
2407
2408 static void
2409 determine_disassembling_preference (struct aarch64_inst *inst)
2410 {
2411   const aarch64_opcode *opcode;
2412   const aarch64_opcode *alias;
2413
2414   opcode = inst->opcode;
2415
2416   /* This opcode does not have an alias, so use itself.  */
2417   if (opcode_has_alias (opcode) == FALSE)
2418     return;
2419
2420   alias = aarch64_find_alias_opcode (opcode);
2421   assert (alias);
2422
2423 #ifdef DEBUG_AARCH64
2424   if (debug_dump)
2425     {
2426       const aarch64_opcode *tmp = alias;
2427       printf ("####   LIST    orderd: ");
2428       while (tmp)
2429         {
2430           printf ("%s, ", tmp->name);
2431           tmp = aarch64_find_next_alias_opcode (tmp);
2432         }
2433       printf ("\n");
2434     }
2435 #endif /* DEBUG_AARCH64 */
2436
2437   for (; alias; alias = aarch64_find_next_alias_opcode (alias))
2438     {
2439       DEBUG_TRACE ("try %s", alias->name);
2440       assert (alias_opcode_p (alias) || opcode_has_alias (opcode));
2441
2442       /* An alias can be a pseudo opcode which will never be used in the
2443          disassembly, e.g. BIC logical immediate is such a pseudo opcode
2444          aliasing AND.  */
2445       if (pseudo_opcode_p (alias))
2446         {
2447           DEBUG_TRACE ("skip pseudo %s", alias->name);
2448           continue;
2449         }
2450
2451       if ((inst->value & alias->mask) != alias->opcode)
2452         {
2453           DEBUG_TRACE ("skip %s as base opcode not match", alias->name);
2454           continue;
2455         }
2456       /* No need to do any complicated transformation on operands, if the alias
2457          opcode does not have any operand.  */
2458       if (aarch64_num_of_operands (alias) == 0 && alias->opcode == inst->value)
2459         {
2460           DEBUG_TRACE ("succeed with 0-operand opcode %s", alias->name);
2461           aarch64_replace_opcode (inst, alias);
2462           return;
2463         }
2464       if (alias->flags & F_CONV)
2465         {
2466           aarch64_inst copy;
2467           memcpy (&copy, inst, sizeof (aarch64_inst));
2468           /* ALIAS is the preference as long as the instruction can be
2469              successfully converted to the form of ALIAS.  */
2470           if (convert_to_alias (&copy, alias) == 1)
2471             {
2472               aarch64_replace_opcode (&copy, alias);
2473               assert (aarch64_match_operands_constraint (&copy, NULL));
2474               DEBUG_TRACE ("succeed with %s via conversion", alias->name);
2475               memcpy (inst, &copy, sizeof (aarch64_inst));
2476               return;
2477             }
2478         }
2479       else
2480         {
2481           /* Directly decode the alias opcode.  */
2482           aarch64_inst temp;
2483           memset (&temp, '\0', sizeof (aarch64_inst));
2484           if (aarch64_opcode_decode (alias, inst->value, &temp, 1) == 1)
2485             {
2486               DEBUG_TRACE ("succeed with %s via direct decoding", alias->name);
2487               memcpy (inst, &temp, sizeof (aarch64_inst));
2488               return;
2489             }
2490         }
2491     }
2492 }
2493
2494 /* Some instructions (including all SVE ones) use the instruction class
2495    to describe how a qualifiers_list index is represented in the instruction
2496    encoding.  If INST is such an instruction, decode the appropriate fields
2497    and fill in the operand qualifiers accordingly.  Return true if no
2498    problems are found.  */
2499
2500 static bfd_boolean
2501 aarch64_decode_variant_using_iclass (aarch64_inst *inst)
2502 {
2503   int i, variant;
2504
2505   variant = 0;
2506   switch (inst->opcode->iclass)
2507     {
2508     case sve_cpy:
2509       variant = extract_fields (inst->value, 0, 2, FLD_size, FLD_SVE_M_14);
2510       break;
2511
2512     case sve_index:
2513       i = extract_field (FLD_SVE_tsz, inst->value, 0);
2514       if (i == 0)
2515         return FALSE;
2516       while ((i & 1) == 0)
2517         {
2518           i >>= 1;
2519           variant += 1;
2520         }
2521       break;
2522
2523     case sve_limm:
2524       /* Pick the smallest applicable element size.  */
2525       if ((inst->value & 0x20600) == 0x600)
2526         variant = 0;
2527       else if ((inst->value & 0x20400) == 0x400)
2528         variant = 1;
2529       else if ((inst->value & 0x20000) == 0)
2530         variant = 2;
2531       else
2532         variant = 3;
2533       break;
2534
2535     case sve_misc:
2536       /* sve_misc instructions have only a single variant.  */
2537       break;
2538
2539     case sve_movprfx:
2540       variant = extract_fields (inst->value, 0, 2, FLD_size, FLD_SVE_M_16);
2541       break;
2542
2543     case sve_pred_zm:
2544       variant = extract_field (FLD_SVE_M_4, inst->value, 0);
2545       break;
2546
2547     case sve_shift_pred:
2548       i = extract_fields (inst->value, 0, 2, FLD_SVE_tszh, FLD_SVE_tszl_8);
2549     sve_shift:
2550       if (i == 0)
2551         return FALSE;
2552       while (i != 1)
2553         {
2554           i >>= 1;
2555           variant += 1;
2556         }
2557       break;
2558
2559     case sve_shift_unpred:
2560       i = extract_fields (inst->value, 0, 2, FLD_SVE_tszh, FLD_SVE_tszl_19);
2561       goto sve_shift;
2562
2563     case sve_size_bhs:
2564       variant = extract_field (FLD_size, inst->value, 0);
2565       if (variant >= 3)
2566         return FALSE;
2567       break;
2568
2569     case sve_size_bhsd:
2570       variant = extract_field (FLD_size, inst->value, 0);
2571       break;
2572
2573     case sve_size_hsd:
2574       i = extract_field (FLD_size, inst->value, 0);
2575       if (i < 1)
2576         return FALSE;
2577       variant = i - 1;
2578       break;
2579
2580     case sve_size_sd:
2581       variant = extract_field (FLD_SVE_sz, inst->value, 0);
2582       break;
2583
2584     default:
2585       /* No mapping between instruction class and qualifiers.  */
2586       return TRUE;
2587     }
2588
2589   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2590     inst->operands[i].qualifier = inst->opcode->qualifiers_list[variant][i];
2591   return TRUE;
2592 }
2593 /* Decode the CODE according to OPCODE; fill INST.  Return 0 if the decoding
2594    fails, which meanes that CODE is not an instruction of OPCODE; otherwise
2595    return 1.
2596
2597    If OPCODE has alias(es) and NOALIASES_P is 0, an alias opcode may be
2598    determined and used to disassemble CODE; this is done just before the
2599    return.  */
2600
2601 static int
2602 aarch64_opcode_decode (const aarch64_opcode *opcode, const aarch64_insn code,
2603                        aarch64_inst *inst, int noaliases_p)
2604 {
2605   int i;
2606
2607   DEBUG_TRACE ("enter with %s", opcode->name);
2608
2609   assert (opcode && inst);
2610
2611   /* Check the base opcode.  */
2612   if ((code & opcode->mask) != (opcode->opcode & opcode->mask))
2613     {
2614       DEBUG_TRACE ("base opcode match FAIL");
2615       goto decode_fail;
2616     }
2617
2618   /* Clear inst.  */
2619   memset (inst, '\0', sizeof (aarch64_inst));
2620
2621   inst->opcode = opcode;
2622   inst->value = code;
2623
2624   /* Assign operand codes and indexes.  */
2625   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2626     {
2627       if (opcode->operands[i] == AARCH64_OPND_NIL)
2628         break;
2629       inst->operands[i].type = opcode->operands[i];
2630       inst->operands[i].idx = i;
2631     }
2632
2633   /* Call the opcode decoder indicated by flags.  */
2634   if (opcode_has_special_coder (opcode) && do_special_decoding (inst) == 0)
2635     {
2636       DEBUG_TRACE ("opcode flag-based decoder FAIL");
2637       goto decode_fail;
2638     }
2639
2640   /* Possibly use the instruction class to determine the correct
2641      qualifier.  */
2642   if (!aarch64_decode_variant_using_iclass (inst))
2643     {
2644       DEBUG_TRACE ("iclass-based decoder FAIL");
2645       goto decode_fail;
2646     }
2647
2648   /* Call operand decoders.  */
2649   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2650     {
2651       const aarch64_operand *opnd;
2652       enum aarch64_opnd type;
2653
2654       type = opcode->operands[i];
2655       if (type == AARCH64_OPND_NIL)
2656         break;
2657       opnd = &aarch64_operands[type];
2658       if (operand_has_extractor (opnd)
2659           && (! aarch64_extract_operand (opnd, &inst->operands[i], code, inst)))
2660         {
2661           DEBUG_TRACE ("operand decoder FAIL at operand %d", i);
2662           goto decode_fail;
2663         }
2664     }
2665
2666   /* If the opcode has a verifier, then check it now.  */
2667   if (opcode->verifier && ! opcode->verifier (opcode, code))
2668     {
2669       DEBUG_TRACE ("operand verifier FAIL");
2670       goto decode_fail;
2671     }
2672
2673   /* Match the qualifiers.  */
2674   if (aarch64_match_operands_constraint (inst, NULL) == 1)
2675     {
2676       /* Arriving here, the CODE has been determined as a valid instruction
2677          of OPCODE and *INST has been filled with information of this OPCODE
2678          instruction.  Before the return, check if the instruction has any
2679          alias and should be disassembled in the form of its alias instead.
2680          If the answer is yes, *INST will be updated.  */
2681       if (!noaliases_p)
2682         determine_disassembling_preference (inst);
2683       DEBUG_TRACE ("SUCCESS");
2684       return 1;
2685     }
2686   else
2687     {
2688       DEBUG_TRACE ("constraint matching FAIL");
2689     }
2690
2691 decode_fail:
2692   return 0;
2693 }
2694 \f
2695 /* This does some user-friendly fix-up to *INST.  It is currently focus on
2696    the adjustment of qualifiers to help the printed instruction
2697    recognized/understood more easily.  */
2698
2699 static void
2700 user_friendly_fixup (aarch64_inst *inst)
2701 {
2702   switch (inst->opcode->iclass)
2703     {
2704     case testbranch:
2705       /* TBNZ Xn|Wn, #uimm6, label
2706          Test and Branch Not Zero: conditionally jumps to label if bit number
2707          uimm6 in register Xn is not zero.  The bit number implies the width of
2708          the register, which may be written and should be disassembled as Wn if
2709          uimm is less than 32. Limited to a branch offset range of +/- 32KiB.
2710          */
2711       if (inst->operands[1].imm.value < 32)
2712         inst->operands[0].qualifier = AARCH64_OPND_QLF_W;
2713       break;
2714     default: break;
2715     }
2716 }
2717
2718 /* Decode INSN and fill in *INST the instruction information.  An alias
2719    opcode may be filled in *INSN if NOALIASES_P is FALSE.  Return zero on
2720    success.  */
2721
2722 int
2723 aarch64_decode_insn (aarch64_insn insn, aarch64_inst *inst,
2724                      bfd_boolean noaliases_p)
2725 {
2726   const aarch64_opcode *opcode = aarch64_opcode_lookup (insn);
2727
2728 #ifdef DEBUG_AARCH64
2729   if (debug_dump)
2730     {
2731       const aarch64_opcode *tmp = opcode;
2732       printf ("\n");
2733       DEBUG_TRACE ("opcode lookup:");
2734       while (tmp != NULL)
2735         {
2736           aarch64_verbose ("  %s", tmp->name);
2737           tmp = aarch64_find_next_opcode (tmp);
2738         }
2739     }
2740 #endif /* DEBUG_AARCH64 */
2741
2742   /* A list of opcodes may have been found, as aarch64_opcode_lookup cannot
2743      distinguish some opcodes, e.g. SSHR and MOVI, which almost share the same
2744      opcode field and value, apart from the difference that one of them has an
2745      extra field as part of the opcode, but such a field is used for operand
2746      encoding in other opcode(s) ('immh' in the case of the example).  */
2747   while (opcode != NULL)
2748     {
2749       /* But only one opcode can be decoded successfully for, as the
2750          decoding routine will check the constraint carefully.  */
2751       if (aarch64_opcode_decode (opcode, insn, inst, noaliases_p) == 1)
2752         return ERR_OK;
2753       opcode = aarch64_find_next_opcode (opcode);
2754     }
2755
2756   return ERR_UND;
2757 }
2758
2759 /* Print operands.  */
2760
2761 static void
2762 print_operands (bfd_vma pc, const aarch64_opcode *opcode,
2763                 const aarch64_opnd_info *opnds, struct disassemble_info *info)
2764 {
2765   int i, pcrel_p, num_printed;
2766   for (i = 0, num_printed = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2767     {
2768       char str[128];
2769       /* We regard the opcode operand info more, however we also look into
2770          the inst->operands to support the disassembling of the optional
2771          operand.
2772          The two operand code should be the same in all cases, apart from
2773          when the operand can be optional.  */
2774       if (opcode->operands[i] == AARCH64_OPND_NIL
2775           || opnds[i].type == AARCH64_OPND_NIL)
2776         break;
2777
2778       /* Generate the operand string in STR.  */
2779       aarch64_print_operand (str, sizeof (str), pc, opcode, opnds, i, &pcrel_p,
2780                              &info->target);
2781
2782       /* Print the delimiter (taking account of omitted operand(s)).  */
2783       if (str[0] != '\0')
2784         (*info->fprintf_func) (info->stream, "%s",
2785                                num_printed++ == 0 ? "\t" : ", ");
2786
2787       /* Print the operand.  */
2788       if (pcrel_p)
2789         (*info->print_address_func) (info->target, info);
2790       else
2791         (*info->fprintf_func) (info->stream, "%s", str);
2792     }
2793 }
2794
2795 /* Set NAME to a copy of INST's mnemonic with the "." suffix removed.  */
2796
2797 static void
2798 remove_dot_suffix (char *name, const aarch64_inst *inst)
2799 {
2800   char *ptr;
2801   size_t len;
2802
2803   ptr = strchr (inst->opcode->name, '.');
2804   assert (ptr && inst->cond);
2805   len = ptr - inst->opcode->name;
2806   assert (len < 8);
2807   strncpy (name, inst->opcode->name, len);
2808   name[len] = '\0';
2809 }
2810
2811 /* Print the instruction mnemonic name.  */
2812
2813 static void
2814 print_mnemonic_name (const aarch64_inst *inst, struct disassemble_info *info)
2815 {
2816   if (inst->opcode->flags & F_COND)
2817     {
2818       /* For instructions that are truly conditionally executed, e.g. b.cond,
2819          prepare the full mnemonic name with the corresponding condition
2820          suffix.  */
2821       char name[8];
2822
2823       remove_dot_suffix (name, inst);
2824       (*info->fprintf_func) (info->stream, "%s.%s", name, inst->cond->names[0]);
2825     }
2826   else
2827     (*info->fprintf_func) (info->stream, "%s", inst->opcode->name);
2828 }
2829
2830 /* Decide whether we need to print a comment after the operands of
2831    instruction INST.  */
2832
2833 static void
2834 print_comment (const aarch64_inst *inst, struct disassemble_info *info)
2835 {
2836   if (inst->opcode->flags & F_COND)
2837     {
2838       char name[8];
2839       unsigned int i, num_conds;
2840
2841       remove_dot_suffix (name, inst);
2842       num_conds = ARRAY_SIZE (inst->cond->names);
2843       for (i = 1; i < num_conds && inst->cond->names[i]; ++i)
2844         (*info->fprintf_func) (info->stream, "%s %s.%s",
2845                                i == 1 ? "  //" : ",",
2846                                name, inst->cond->names[i]);
2847     }
2848 }
2849
2850 /* Print the instruction according to *INST.  */
2851
2852 static void
2853 print_aarch64_insn (bfd_vma pc, const aarch64_inst *inst,
2854                     struct disassemble_info *info)
2855 {
2856   print_mnemonic_name (inst, info);
2857   print_operands (pc, inst->opcode, inst->operands, info);
2858   print_comment (inst, info);
2859 }
2860
2861 /* Entry-point of the instruction disassembler and printer.  */
2862
2863 static void
2864 print_insn_aarch64_word (bfd_vma pc,
2865                          uint32_t word,
2866                          struct disassemble_info *info)
2867 {
2868   static const char *err_msg[6] =
2869     {
2870       [ERR_OK]   = "_",
2871       [-ERR_UND] = "undefined",
2872       [-ERR_UNP] = "unpredictable",
2873       [-ERR_NYI] = "NYI"
2874     };
2875
2876   int ret;
2877   aarch64_inst inst;
2878
2879   info->insn_info_valid = 1;
2880   info->branch_delay_insns = 0;
2881   info->data_size = 0;
2882   info->target = 0;
2883   info->target2 = 0;
2884
2885   if (info->flags & INSN_HAS_RELOC)
2886     /* If the instruction has a reloc associated with it, then
2887        the offset field in the instruction will actually be the
2888        addend for the reloc.  (If we are using REL type relocs).
2889        In such cases, we can ignore the pc when computing
2890        addresses, since the addend is not currently pc-relative.  */
2891     pc = 0;
2892
2893   ret = aarch64_decode_insn (word, &inst, no_aliases);
2894
2895   if (((word >> 21) & 0x3ff) == 1)
2896     {
2897       /* RESERVED for ALES.  */
2898       assert (ret != ERR_OK);
2899       ret = ERR_NYI;
2900     }
2901
2902   switch (ret)
2903     {
2904     case ERR_UND:
2905     case ERR_UNP:
2906     case ERR_NYI:
2907       /* Handle undefined instructions.  */
2908       info->insn_type = dis_noninsn;
2909       (*info->fprintf_func) (info->stream,".inst\t0x%08x ; %s",
2910                              word, err_msg[-ret]);
2911       break;
2912     case ERR_OK:
2913       user_friendly_fixup (&inst);
2914       print_aarch64_insn (pc, &inst, info);
2915       break;
2916     default:
2917       abort ();
2918     }
2919 }
2920
2921 /* Disallow mapping symbols ($x, $d etc) from
2922    being displayed in symbol relative addresses.  */
2923
2924 bfd_boolean
2925 aarch64_symbol_is_valid (asymbol * sym,
2926                          struct disassemble_info * info ATTRIBUTE_UNUSED)
2927 {
2928   const char * name;
2929
2930   if (sym == NULL)
2931     return FALSE;
2932
2933   name = bfd_asymbol_name (sym);
2934
2935   return name
2936     && (name[0] != '$'
2937         || (name[1] != 'x' && name[1] != 'd')
2938         || (name[2] != '\0' && name[2] != '.'));
2939 }
2940
2941 /* Print data bytes on INFO->STREAM.  */
2942
2943 static void
2944 print_insn_data (bfd_vma pc ATTRIBUTE_UNUSED,
2945                  uint32_t word,
2946                  struct disassemble_info *info)
2947 {
2948   switch (info->bytes_per_chunk)
2949     {
2950     case 1:
2951       info->fprintf_func (info->stream, ".byte\t0x%02x", word);
2952       break;
2953     case 2:
2954       info->fprintf_func (info->stream, ".short\t0x%04x", word);
2955       break;
2956     case 4:
2957       info->fprintf_func (info->stream, ".word\t0x%08x", word);
2958       break;
2959     default:
2960       abort ();
2961     }
2962 }
2963
2964 /* Try to infer the code or data type from a symbol.
2965    Returns nonzero if *MAP_TYPE was set.  */
2966
2967 static int
2968 get_sym_code_type (struct disassemble_info *info, int n,
2969                    enum map_type *map_type)
2970 {
2971   elf_symbol_type *es;
2972   unsigned int type;
2973   const char *name;
2974
2975   es = *(elf_symbol_type **)(info->symtab + n);
2976   type = ELF_ST_TYPE (es->internal_elf_sym.st_info);
2977
2978   /* If the symbol has function type then use that.  */
2979   if (type == STT_FUNC)
2980     {
2981       *map_type = MAP_INSN;
2982       return TRUE;
2983     }
2984
2985   /* Check for mapping symbols.  */
2986   name = bfd_asymbol_name(info->symtab[n]);
2987   if (name[0] == '$'
2988       && (name[1] == 'x' || name[1] == 'd')
2989       && (name[2] == '\0' || name[2] == '.'))
2990     {
2991       *map_type = (name[1] == 'x' ? MAP_INSN : MAP_DATA);
2992       return TRUE;
2993     }
2994
2995   return FALSE;
2996 }
2997
2998 /* Entry-point of the AArch64 disassembler.  */
2999
3000 int
3001 print_insn_aarch64 (bfd_vma pc,
3002                     struct disassemble_info *info)
3003 {
3004   bfd_byte      buffer[INSNLEN];
3005   int           status;
3006   void          (*printer) (bfd_vma, uint32_t, struct disassemble_info *);
3007   bfd_boolean   found = FALSE;
3008   unsigned int  size = 4;
3009   unsigned long data;
3010
3011   if (info->disassembler_options)
3012     {
3013       set_default_aarch64_dis_options (info);
3014
3015       parse_aarch64_dis_options (info->disassembler_options);
3016
3017       /* To avoid repeated parsing of these options, we remove them here.  */
3018       info->disassembler_options = NULL;
3019     }
3020
3021   /* Aarch64 instructions are always little-endian */
3022   info->endian_code = BFD_ENDIAN_LITTLE;
3023
3024   /* First check the full symtab for a mapping symbol, even if there
3025      are no usable non-mapping symbols for this address.  */
3026   if (info->symtab_size != 0
3027       && bfd_asymbol_flavour (*info->symtab) == bfd_target_elf_flavour)
3028     {
3029       enum map_type type = MAP_INSN;
3030       int last_sym = -1;
3031       bfd_vma addr;
3032       int n;
3033
3034       if (pc <= last_mapping_addr)
3035         last_mapping_sym = -1;
3036
3037       /* Start scanning at the start of the function, or wherever
3038          we finished last time.  */
3039       n = info->symtab_pos + 1;
3040       if (n < last_mapping_sym)
3041         n = last_mapping_sym;
3042
3043       /* Scan up to the location being disassembled.  */
3044       for (; n < info->symtab_size; n++)
3045         {
3046           addr = bfd_asymbol_value (info->symtab[n]);
3047           if (addr > pc)
3048             break;
3049           if ((info->section == NULL
3050                || info->section == info->symtab[n]->section)
3051               && get_sym_code_type (info, n, &type))
3052             {
3053               last_sym = n;
3054               found = TRUE;
3055             }
3056         }
3057
3058       if (!found)
3059         {
3060           n = info->symtab_pos;
3061           if (n < last_mapping_sym)
3062             n = last_mapping_sym;
3063
3064           /* No mapping symbol found at this address.  Look backwards
3065              for a preceeding one.  */
3066           for (; n >= 0; n--)
3067             {
3068               if (get_sym_code_type (info, n, &type))
3069                 {
3070                   last_sym = n;
3071                   found = TRUE;
3072                   break;
3073                 }
3074             }
3075         }
3076
3077       last_mapping_sym = last_sym;
3078       last_type = type;
3079
3080       /* Look a little bit ahead to see if we should print out
3081          less than four bytes of data.  If there's a symbol,
3082          mapping or otherwise, after two bytes then don't
3083          print more.  */
3084       if (last_type == MAP_DATA)
3085         {
3086           size = 4 - (pc & 3);
3087           for (n = last_sym + 1; n < info->symtab_size; n++)
3088             {
3089               addr = bfd_asymbol_value (info->symtab[n]);
3090               if (addr > pc)
3091                 {
3092                   if (addr - pc < size)
3093                     size = addr - pc;
3094                   break;
3095                 }
3096             }
3097           /* If the next symbol is after three bytes, we need to
3098              print only part of the data, so that we can use either
3099              .byte or .short.  */
3100           if (size == 3)
3101             size = (pc & 1) ? 1 : 2;
3102         }
3103     }
3104
3105   if (last_type == MAP_DATA)
3106     {
3107       /* size was set above.  */
3108       info->bytes_per_chunk = size;
3109       info->display_endian = info->endian;
3110       printer = print_insn_data;
3111     }
3112   else
3113     {
3114       info->bytes_per_chunk = size = INSNLEN;
3115       info->display_endian = info->endian_code;
3116       printer = print_insn_aarch64_word;
3117     }
3118
3119   status = (*info->read_memory_func) (pc, buffer, size, info);
3120   if (status != 0)
3121     {
3122       (*info->memory_error_func) (status, pc, info);
3123       return -1;
3124     }
3125
3126   data = bfd_get_bits (buffer, size * 8,
3127                        info->display_endian == BFD_ENDIAN_BIG);
3128
3129   (*printer) (pc, data, info);
3130
3131   return size;
3132 }
3133 \f
3134 void
3135 print_aarch64_disassembler_options (FILE *stream)
3136 {
3137   fprintf (stream, _("\n\
3138 The following AARCH64 specific disassembler options are supported for use\n\
3139 with the -M switch (multiple options should be separated by commas):\n"));
3140
3141   fprintf (stream, _("\n\
3142   no-aliases         Don't print instruction aliases.\n"));
3143
3144   fprintf (stream, _("\n\
3145   aliases            Do print instruction aliases.\n"));
3146
3147 #ifdef DEBUG_AARCH64
3148   fprintf (stream, _("\n\
3149   debug_dump         Temp switch for debug trace.\n"));
3150 #endif /* DEBUG_AARCH64 */
3151
3152   fprintf (stream, _("\n"));
3153 }