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 static inline 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 (info->type == AARCH64_OPND_FPIMM)
 602     info->imm.is_fp = 1;
 603
 604   if (operand_need_sign_extension (self))
 605     imm = sign_extend (imm, get_operand_fields_width (self) - 1);
 606
 607   if (operand_need_shift_by_two (self))
 608     imm <<= 2;
 609
 610   if (info->type == AARCH64_OPND_ADDR_ADRP)
 611     imm <<= 12;
 612
 613   info->imm.value = imm;
 614   return 1;
 615 }
 616
 617 /* Decode imm and its shifter for e.g. MOVZ <Wd>, #<imm16>{, LSL #<shift>}.  */
 618 int
 619 aarch64_ext_imm_half (const aarch64_operand *self, aarch64_opnd_info *info,
 620                       const aarch64_insn code,
 621                       const aarch64_inst *inst ATTRIBUTE_UNUSED)
 622 {
 623   aarch64_ext_imm (self, info, code, inst);
 624   info->shifter.kind = AARCH64_MOD_LSL;
 625   info->shifter.amount = extract_field (FLD_hw, code, 0) << 4;
 626   return 1;
 627 }
 628
 629 /* Decode cmode and "a:b:c:d:e:f:g:h" for e.g.
 630      MOVI <Vd>.<T>, #<imm8> {, LSL #<amount>}.  */
 631 int
 632 aarch64_ext_advsimd_imm_modified (const aarch64_operand *self ATTRIBUTE_UNUSED,
 633                                   aarch64_opnd_info *info,
 634                                   const aarch64_insn code,
 635                                   const aarch64_inst *inst ATTRIBUTE_UNUSED)
 636 {
 637   uint64_t imm;
 638   enum aarch64_opnd_qualifier opnd0_qualifier = inst->operands[0].qualifier;
 639   aarch64_field field = {0, 0};
 640
 641   assert (info->idx == 1);
 642
 643   if (info->type == AARCH64_OPND_SIMD_FPIMM)
 644     info->imm.is_fp = 1;
 645
 646   /* a:b:c:d:e:f:g:h */
 647   imm = extract_fields (code, 0, 2, FLD_abc, FLD_defgh);
 648   if (!info->imm.is_fp && aarch64_get_qualifier_esize (opnd0_qualifier) == 8)
 649     {
 650       /* Either MOVI <Dd>, #<imm>
 651          or     MOVI <Vd>.2D, #<imm>.
 652          <imm> is a 64-bit immediate
 653          'aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffgggggggghhhhhhhh',
 654          encoded in "a:b:c:d:e:f:g:h".  */
 655       int i;
 656       unsigned abcdefgh = imm;
 657       for (imm = 0ull, i = 0; i < 8; i++)
 658         if (((abcdefgh >> i) & 0x1) != 0)
 659           imm |= 0xffull << (8 * i);
 660     }
 661   info->imm.value = imm;
 662
 663   /* cmode */
 664   info->qualifier = get_expected_qualifier (inst, info->idx);
 665   switch (info->qualifier)
 666     {
 667     case AARCH64_OPND_QLF_NIL:
 668       /* no shift */
 669       info->shifter.kind = AARCH64_MOD_NONE;
 670       return 1;
 671     case AARCH64_OPND_QLF_LSL:
 672       /* shift zeros */
 673       info->shifter.kind = AARCH64_MOD_LSL;
 674       switch (aarch64_get_qualifier_esize (opnd0_qualifier))
 675         {
 676         case 4: gen_sub_field (FLD_cmode, 1, 2, &field); break; /* per word */
 677         case 2: gen_sub_field (FLD_cmode, 1, 1, &field); break; /* per half */
 678         case 1: gen_sub_field (FLD_cmode, 1, 0, &field); break; /* per byte */
 679         default: assert (0); return 0;
 680         }
 681       /* 00: 0; 01: 8; 10:16; 11:24.  */
 682       info->shifter.amount = extract_field_2 (&field, code, 0) << 3;
 683       break;
 684     case AARCH64_OPND_QLF_MSL:
 685       /* shift ones */
 686       info->shifter.kind = AARCH64_MOD_MSL;
 687       gen_sub_field (FLD_cmode, 0, 1, &field);          /* per word */
 688       info->shifter.amount = extract_field_2 (&field, code, 0) ? 16 : 8;
 689       break;
 690     default:
 691       assert (0);
 692       return 0;
 693     }
 694
 695   return 1;
 696 }
 697
 698 /* Decode scale for e.g. SCVTF <Dd>, <Wn>, #<fbits>.  */
 699 int
 700 aarch64_ext_fbits (const aarch64_operand *self ATTRIBUTE_UNUSED,
 701                    aarch64_opnd_info *info, const aarch64_insn code,
 702                    const aarch64_inst *inst ATTRIBUTE_UNUSED)
 703 {
 704   info->imm.value = 64- extract_field (FLD_scale, code, 0);
 705   return 1;
 706 }
 707
 708 /* Decode arithmetic immediate for e.g.
 709      SUBS <Wd>, <Wn|WSP>, #<imm> {, <shift>}.  */
 710 int
 711 aarch64_ext_aimm (const aarch64_operand *self ATTRIBUTE_UNUSED,
 712                   aarch64_opnd_info *info, const aarch64_insn code,
 713                   const aarch64_inst *inst ATTRIBUTE_UNUSED)
 714 {
 715   aarch64_insn value;
 716
 717   info->shifter.kind = AARCH64_MOD_LSL;
 718   /* shift */
 719   value = extract_field (FLD_shift, code, 0);
 720   if (value >= 2)
 721     return 0;
 722   info->shifter.amount = value ? 12 : 0;
 723   /* imm12 (unsigned) */
 724   info->imm.value = extract_field (FLD_imm12, code, 0);
 725
 726   return 1;
 727 }
 728
 729 /* Decode logical immediate for e.g. ORR <Wd|WSP>, <Wn>, #<imm>.  */
 730
 731 int
 732 aarch64_ext_limm (const aarch64_operand *self ATTRIBUTE_UNUSED,
 733                   aarch64_opnd_info *info, const aarch64_insn code,
 734                   const aarch64_inst *inst ATTRIBUTE_UNUSED)
 735 {
 736   uint64_t imm, mask;
 737   uint32_t sf;
 738   uint32_t N, R, S;
 739   unsigned simd_size;
 740   aarch64_insn value;
 741
 742   value = extract_fields (code, 0, 3, FLD_N, FLD_immr, FLD_imms);
 743   assert (inst->operands[0].qualifier == AARCH64_OPND_QLF_W
 744           || inst->operands[0].qualifier == AARCH64_OPND_QLF_X);
 745   sf = aarch64_get_qualifier_esize (inst->operands[0].qualifier) != 4;
 746
 747   /* value is N:immr:imms.  */
 748   S = value & 0x3f;
 749   R = (value >> 6) & 0x3f;
 750   N = (value >> 12) & 0x1;
 751
 752   if (sf == 0 && N == 1)
 753     return 0;
 754
 755   /* The immediate value is S+1 bits to 1, left rotated by SIMDsize - R
 756      (in other words, right rotated by R), then replicated.  */
 757   if (N != 0)
 758     {
 759       simd_size = 64;
 760       mask = 0xffffffffffffffffull;
 761     }
 762   else
 763     {
 764       switch (S)
 765         {
 766         case 0x00 ... 0x1f: /* 0xxxxx */ simd_size = 32;           break;
 767         case 0x20 ... 0x2f: /* 10xxxx */ simd_size = 16; S &= 0xf; break;
 768         case 0x30 ... 0x37: /* 110xxx */ simd_size =  8; S &= 0x7; break;
 769         case 0x38 ... 0x3b: /* 1110xx */ simd_size =  4; S &= 0x3; break;
 770         case 0x3c ... 0x3d: /* 11110x */ simd_size =  2; S &= 0x1; break;
 771         default: return 0;
 772         }
 773       mask = (1ull << simd_size) - 1;
 774       /* Top bits are IGNORED.  */
 775       R &= simd_size - 1;
 776     }
 777   /* NOTE: if S = simd_size - 1 we get 0xf..f which is rejected.  */
 778   if (S == simd_size - 1)
 779     return 0;
 780   /* S+1 consecutive bits to 1.  */
 781   /* NOTE: S can't be 63 due to detection above.  */
 782   imm = (1ull << (S + 1)) - 1;
 783   /* Rotate to the left by simd_size - R.  */
 784   if (R != 0)
 785     imm = ((imm << (simd_size - R)) & mask) | (imm >> R);
 786   /* Replicate the value according to SIMD size.  */
 787   switch (simd_size)
 788     {
 789     case  2: imm = (imm <<  2) | imm;
 790     case  4: imm = (imm <<  4) | imm;
 791     case  8: imm = (imm <<  8) | imm;
 792     case 16: imm = (imm << 16) | imm;
 793     case 32: imm = (imm << 32) | imm;
 794     case 64: break;
 795     default: assert (0); return 0;
 796     }
 797
 798   info->imm.value = sf ? imm : imm & 0xffffffff;
 799
 800   return 1;
 801 }
 802
 803 /* Decode Ft for e.g. STR <Qt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}]
 804    or LDP <Qt1>, <Qt2>, [<Xn|SP>], #<imm>.  */
 805 int
 806 aarch64_ext_ft (const aarch64_operand *self ATTRIBUTE_UNUSED,
 807                 aarch64_opnd_info *info,
 808                 const aarch64_insn code, const aarch64_inst *inst)
 809 {
 810   aarch64_insn value;
 811
 812   /* Rt */
 813   info->reg.regno = extract_field (FLD_Rt, code, 0);
 814
 815   /* size */
 816   value = extract_field (FLD_ldst_size, code, 0);
 817   if (inst->opcode->iclass == ldstpair_indexed
 818       || inst->opcode->iclass == ldstnapair_offs
 819       || inst->opcode->iclass == ldstpair_off
 820       || inst->opcode->iclass == loadlit)
 821     {
 822       enum aarch64_opnd_qualifier qualifier;
 823       switch (value)
 824         {
 825         case 0: qualifier = AARCH64_OPND_QLF_S_S; break;
 826         case 1: qualifier = AARCH64_OPND_QLF_S_D; break;
 827         case 2: qualifier = AARCH64_OPND_QLF_S_Q; break;
 828         default: return 0;
 829         }
 830       info->qualifier = qualifier;
 831     }
 832   else
 833     {
 834       /* opc1:size */
 835       value = extract_fields (code, 0, 2, FLD_opc1, FLD_ldst_size);
 836       if (value > 0x4)
 837         return 0;
 838       info->qualifier = get_sreg_qualifier_from_value (value);
 839     }
 840
 841   return 1;
 842 }
 843
 844 /* Decode the address operand for e.g. STXRB <Ws>, <Wt>, [<Xn|SP>{,#0}].  */
 845 int
 846 aarch64_ext_addr_simple (const aarch64_operand *self ATTRIBUTE_UNUSED,
 847                          aarch64_opnd_info *info,
 848                          aarch64_insn code,
 849                          const aarch64_inst *inst ATTRIBUTE_UNUSED)
 850 {
 851   /* Rn */
 852   info->addr.base_regno = extract_field (FLD_Rn, code, 0);
 853   return 1;
 854 }
 855
 856 /* Decode the address operand for e.g.
 857      STR <Qt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}].  */
 858 int
 859 aarch64_ext_addr_regoff (const aarch64_operand *self ATTRIBUTE_UNUSED,
 860                          aarch64_opnd_info *info,
 861                          aarch64_insn code, const aarch64_inst *inst)
 862 {
 863   aarch64_insn S, value;
 864
 865   /* Rn */
 866   info->addr.base_regno = extract_field (FLD_Rn, code, 0);
 867   /* Rm */
 868   info->addr.offset.regno = extract_field (FLD_Rm, code, 0);
 869   /* option */
 870   value = extract_field (FLD_option, code, 0);
 871   info->shifter.kind =
 872     aarch64_get_operand_modifier_from_value (value, TRUE /* extend_p */);
 873   /* Fix-up the shifter kind; although the table-driven approach is
 874      efficient, it is slightly inflexible, thus needing this fix-up.  */
 875   if (info->shifter.kind == AARCH64_MOD_UXTX)
 876     info->shifter.kind = AARCH64_MOD_LSL;
 877   /* S */
 878   S = extract_field (FLD_S, code, 0);
 879   if (S == 0)
 880     {
 881       info->shifter.amount = 0;
 882       info->shifter.amount_present = 0;
 883     }
 884   else
 885     {
 886       int size;
 887       /* Need information in other operand(s) to help achieve the decoding
 888          from 'S' field.  */
 889       info->qualifier = get_expected_qualifier (inst, info->idx);
 890       /* Get the size of the data element that is accessed, which may be
 891          different from that of the source register size, e.g. in strb/ldrb.  */
 892       size = aarch64_get_qualifier_esize (info->qualifier);
 893       info->shifter.amount = get_logsz (size);
 894       info->shifter.amount_present = 1;
 895     }
 896
 897   return 1;
 898 }
 899
 900 /* Decode the address operand for e.g. LDRSW <Xt>, [<Xn|SP>], #<simm>.  */
 901 int
 902 aarch64_ext_addr_simm (const aarch64_operand *self, aarch64_opnd_info *info,
 903                        aarch64_insn code, const aarch64_inst *inst)
 904 {
 905   aarch64_insn imm;
 906   info->qualifier = get_expected_qualifier (inst, info->idx);
 907
 908   /* Rn */
 909   info->addr.base_regno = extract_field (FLD_Rn, code, 0);
 910   /* simm (imm9 or imm7)  */
 911   imm = extract_field (self->fields[0], code, 0);
 912   info->addr.offset.imm = sign_extend (imm, fields[self->fields[0]].width - 1);
 913   if (self->fields[0] == FLD_imm7)
 914     /* scaled immediate in ld/st pair instructions.  */
 915     info->addr.offset.imm *= aarch64_get_qualifier_esize (info->qualifier);
 916   /* qualifier */
 917   if (inst->opcode->iclass == ldst_unscaled
 918       || inst->opcode->iclass == ldstnapair_offs
 919       || inst->opcode->iclass == ldstpair_off
 920       || inst->opcode->iclass == ldst_unpriv)
 921     info->addr.writeback = 0;
 922   else
 923     {
 924       /* pre/post- index */
 925       info->addr.writeback = 1;
 926       if (extract_field (self->fields[1], code, 0) == 1)
 927         info->addr.preind = 1;
 928       else
 929         info->addr.postind = 1;
 930     }
 931
 932   return 1;
 933 }
 934
 935 /* Decode the address operand for e.g. LDRSW <Xt>, [<Xn|SP>{, #<simm>}].  */
 936 int
 937 aarch64_ext_addr_uimm12 (const aarch64_operand *self, aarch64_opnd_info *info,
 938                          aarch64_insn code,
 939                          const aarch64_inst *inst ATTRIBUTE_UNUSED)
 940 {
 941   int shift;
 942   info->qualifier = get_expected_qualifier (inst, info->idx);
 943   shift = get_logsz (aarch64_get_qualifier_esize (info->qualifier));
 944   /* Rn */
 945   info->addr.base_regno = extract_field (self->fields[0], code, 0);
 946   /* uimm12 */
 947   info->addr.offset.imm = extract_field (self->fields[1], code, 0) << shift;
 948   return 1;
 949 }
 950
 951 /* Decode the address operand for e.g.
 952      LD1 {<Vt>.<T>, <Vt2>.<T>, <Vt3>.<T>}, [<Xn|SP>], <Xm|#<amount>>.  */
 953 int
 954 aarch64_ext_simd_addr_post (const aarch64_operand *self ATTRIBUTE_UNUSED,
 955                             aarch64_opnd_info *info,
 956                             aarch64_insn code, const aarch64_inst *inst)
 957 {
 958   /* The opcode dependent area stores the number of elements in
 959      each structure to be loaded/stored.  */
 960   int is_ld1r = get_opcode_dependent_value (inst->opcode) == 1;
 961
 962   /* Rn */
 963   info->addr.base_regno = extract_field (FLD_Rn, code, 0);
 964   /* Rm | #<amount>  */
 965   info->addr.offset.regno = extract_field (FLD_Rm, code, 0);
 966   if (info->addr.offset.regno == 31)
 967     {
 968       if (inst->opcode->operands[0] == AARCH64_OPND_LVt_AL)
 969         /* Special handling of loading single structure to all lane.  */
 970         info->addr.offset.imm = (is_ld1r ? 1
 971                                  : inst->operands[0].reglist.num_regs)
 972           * aarch64_get_qualifier_esize (inst->operands[0].qualifier);
 973       else
 974         info->addr.offset.imm = inst->operands[0].reglist.num_regs
 975           * aarch64_get_qualifier_esize (inst->operands[0].qualifier)
 976           * aarch64_get_qualifier_nelem (inst->operands[0].qualifier);
 977     }
 978   else
 979     info->addr.offset.is_reg = 1;
 980   info->addr.writeback = 1;
 981
 982   return 1;
 983 }
 984
 985 /* Decode the condition operand for e.g. CSEL <Xd>, <Xn>, <Xm>, <cond>.  */
 986 int
 987 aarch64_ext_cond (const aarch64_operand *self ATTRIBUTE_UNUSED,
 988                   aarch64_opnd_info *info,
 989                   aarch64_insn code, const aarch64_inst *inst ATTRIBUTE_UNUSED)
 990 {
 991   aarch64_insn value;
 992   /* cond */
 993   value = extract_field (FLD_cond, code, 0);
 994   info->cond = get_cond_from_value (value);
 995   return 1;
 996 }
 997
 998 /* Decode the system register operand for e.g. MRS <Xt>, <systemreg>.  */
 999 int
1000 aarch64_ext_sysreg (const aarch64_operand *self ATTRIBUTE_UNUSED,
1001                     aarch64_opnd_info *info,
1002                     aarch64_insn code,
1003                     const aarch64_inst *inst ATTRIBUTE_UNUSED)
1004 {
1005   /* op0:op1:CRn:CRm:op2 */
1006   info->sysreg = extract_fields (code, 0, 5, FLD_op0, FLD_op1, FLD_CRn,
1007                                  FLD_CRm, FLD_op2);
1008   return 1;
1009 }
1010
1011 /* Decode the PSTATE field operand for e.g. MSR <pstatefield>, #<imm>.  */
1012 int
1013 aarch64_ext_pstatefield (const aarch64_operand *self ATTRIBUTE_UNUSED,
1014                          aarch64_opnd_info *info, aarch64_insn code,
1015                          const aarch64_inst *inst ATTRIBUTE_UNUSED)
1016 {
1017   int i;
1018   /* op1:op2 */
1019   info->pstatefield = extract_fields (code, 0, 2, FLD_op1, FLD_op2);
1020   for (i = 0; aarch64_pstatefields[i].name != NULL; ++i)
1021     if (aarch64_pstatefields[i].value == (aarch64_insn)info->pstatefield)
1022       return 1;
1023   /* Reserved value in <pstatefield>.  */
1024   return 0;
1025 }
1026
1027 /* Decode the system instruction op operand for e.g. AT <at_op>, <Xt>.  */
1028 int
1029 aarch64_ext_sysins_op (const aarch64_operand *self ATTRIBUTE_UNUSED,
1030                        aarch64_opnd_info *info,
1031                        aarch64_insn code,
1032                        const aarch64_inst *inst ATTRIBUTE_UNUSED)
1033 {
1034   int i;
1035   aarch64_insn value;
1036   const aarch64_sys_ins_reg *sysins_ops;
1037   /* op0:op1:CRn:CRm:op2 */
1038   value = extract_fields (code, 0, 5,
1039                           FLD_op0, FLD_op1, FLD_CRn,
1040                           FLD_CRm, FLD_op2);
1041
1042   switch (info->type)
1043     {
1044     case AARCH64_OPND_SYSREG_AT: sysins_ops = aarch64_sys_regs_at; break;
1045     case AARCH64_OPND_SYSREG_DC: sysins_ops = aarch64_sys_regs_dc; break;
1046     case AARCH64_OPND_SYSREG_IC: sysins_ops = aarch64_sys_regs_ic; break;
1047     case AARCH64_OPND_SYSREG_TLBI: sysins_ops = aarch64_sys_regs_tlbi; break;
1048     default: assert (0); return 0;
1049     }
1050
1051   for (i = 0; sysins_ops[i].name != NULL; ++i)
1052     if (sysins_ops[i].value == value)
1053       {
1054         info->sysins_op = sysins_ops + i;
1055         DEBUG_TRACE ("%s found value: %x, has_xt: %d, i: %d.",
1056                      info->sysins_op->name,
1057                      (unsigned)info->sysins_op->value,
1058                      aarch64_sys_ins_reg_has_xt (info->sysins_op), i);
1059         return 1;
1060       }
1061
1062   return 0;
1063 }
1064
1065 /* Decode the memory barrier option operand for e.g. DMB <option>|#<imm>.  */
1066
1067 int
1068 aarch64_ext_barrier (const aarch64_operand *self ATTRIBUTE_UNUSED,
1069                      aarch64_opnd_info *info,
1070                      aarch64_insn code,
1071                      const aarch64_inst *inst ATTRIBUTE_UNUSED)
1072 {
1073   /* CRm */
1074   info->barrier = aarch64_barrier_options + extract_field (FLD_CRm, code, 0);
1075   return 1;
1076 }
1077
1078 /* Decode the prefetch operation option operand for e.g.
1079      PRFM <prfop>, [<Xn|SP>{, #<pimm>}].  */
1080
1081 int
1082 aarch64_ext_prfop (const aarch64_operand *self ATTRIBUTE_UNUSED,
1083                    aarch64_opnd_info *info,
1084                    aarch64_insn code, const aarch64_inst *inst ATTRIBUTE_UNUSED)
1085 {
1086   /* prfop in Rt */
1087   info->prfop = aarch64_prfops + extract_field (FLD_Rt, code, 0);
1088   return 1;
1089 }
1090
1091 /* Decode the hint number for an alias taking an operand.  Set info->hint_option
1092    to the matching name/value pair in aarch64_hint_options.  */
1093
1094 int
1095 aarch64_ext_hint (const aarch64_operand *self ATTRIBUTE_UNUSED,
1096                   aarch64_opnd_info *info,
1097                   aarch64_insn code,
1098                   const aarch64_inst *inst ATTRIBUTE_UNUSED)
1099 {
1100   /* CRm:op2.  */
1101   unsigned hint_number;
1102   int i;
1103
1104   hint_number = extract_fields (code, 0, 2, FLD_CRm, FLD_op2);
1105
1106   for (i = 0; aarch64_hint_options[i].name != NULL; i++)
1107     {
1108       if (hint_number == aarch64_hint_options[i].value)
1109         {
1110           info->hint_option = &(aarch64_hint_options[i]);
1111           return 1;
1112         }
1113     }
1114
1115   return 0;
1116 }
1117
1118 /* Decode the extended register operand for e.g.
1119      STR <Qt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}].  */
1120 int
1121 aarch64_ext_reg_extended (const aarch64_operand *self ATTRIBUTE_UNUSED,
1122                           aarch64_opnd_info *info,
1123                           aarch64_insn code,
1124                           const aarch64_inst *inst ATTRIBUTE_UNUSED)
1125 {
1126   aarch64_insn value;
1127
1128   /* Rm */
1129   info->reg.regno = extract_field (FLD_Rm, code, 0);
1130   /* option */
1131   value = extract_field (FLD_option, code, 0);
1132   info->shifter.kind =
1133     aarch64_get_operand_modifier_from_value (value, TRUE /* extend_p */);
1134   /* imm3 */
1135   info->shifter.amount = extract_field (FLD_imm3, code,  0);
1136
1137   /* This makes the constraint checking happy.  */
1138   info->shifter.operator_present = 1;
1139
1140   /* Assume inst->operands[0].qualifier has been resolved.  */
1141   assert (inst->operands[0].qualifier != AARCH64_OPND_QLF_NIL);
1142   info->qualifier = AARCH64_OPND_QLF_W;
1143   if (inst->operands[0].qualifier == AARCH64_OPND_QLF_X
1144       && (info->shifter.kind == AARCH64_MOD_UXTX
1145           || info->shifter.kind == AARCH64_MOD_SXTX))
1146     info->qualifier = AARCH64_OPND_QLF_X;
1147
1148   return 1;
1149 }
1150
1151 /* Decode the shifted register operand for e.g.
1152      SUBS <Xd>, <Xn>, <Xm> {, <shift> #<amount>}.  */
1153 int
1154 aarch64_ext_reg_shifted (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   /* shift */
1164   value = extract_field (FLD_shift, code, 0);
1165   info->shifter.kind =
1166     aarch64_get_operand_modifier_from_value (value, FALSE /* extend_p */);
1167   if (info->shifter.kind == AARCH64_MOD_ROR
1168       && inst->opcode->iclass != log_shift)
1169     /* ROR is not available for the shifted register operand in arithmetic
1170        instructions.  */
1171     return 0;
1172   /* imm6 */
1173   info->shifter.amount = extract_field (FLD_imm6, code,  0);
1174
1175   /* This makes the constraint checking happy.  */
1176   info->shifter.operator_present = 1;
1177
1178   return 1;
1179 }
1180 \f
1181 /* Bitfields that are commonly used to encode certain operands' information
1182    may be partially used as part of the base opcode in some instructions.
1183    For example, the bit 1 of the field 'size' in
1184      FCVTXN <Vb><d>, <Va><n>
1185    is actually part of the base opcode, while only size<0> is available
1186    for encoding the register type.  Another example is the AdvSIMD
1187    instruction ORR (register), in which the field 'size' is also used for
1188    the base opcode, leaving only the field 'Q' available to encode the
1189    vector register arrangement specifier '8B' or '16B'.
1190
1191    This function tries to deduce the qualifier from the value of partially
1192    constrained field(s).  Given the VALUE of such a field or fields, the
1193    qualifiers CANDIDATES and the MASK (indicating which bits are valid for
1194    operand encoding), the function returns the matching qualifier or
1195    AARCH64_OPND_QLF_NIL if nothing matches.
1196
1197    N.B. CANDIDATES is a group of possible qualifiers that are valid for
1198    one operand; it has a maximum of AARCH64_MAX_QLF_SEQ_NUM qualifiers and
1199    may end with AARCH64_OPND_QLF_NIL.  */
1200
1201 static enum aarch64_opnd_qualifier
1202 get_qualifier_from_partial_encoding (aarch64_insn value,
1203                                      const enum aarch64_opnd_qualifier* \
1204                                      candidates,
1205                                      aarch64_insn mask)
1206 {
1207   int i;
1208   DEBUG_TRACE ("enter with value: %d, mask: %d", (int)value, (int)mask);
1209   for (i = 0; i < AARCH64_MAX_QLF_SEQ_NUM; ++i)
1210     {
1211       aarch64_insn standard_value;
1212       if (candidates[i] == AARCH64_OPND_QLF_NIL)
1213         break;
1214       standard_value = aarch64_get_qualifier_standard_value (candidates[i]);
1215       if ((standard_value & mask) == (value & mask))
1216         return candidates[i];
1217     }
1218   return AARCH64_OPND_QLF_NIL;
1219 }
1220
1221 /* Given a list of qualifier sequences, return all possible valid qualifiers
1222    for operand IDX in QUALIFIERS.
1223    Assume QUALIFIERS is an array whose length is large enough.  */
1224
1225 static void
1226 get_operand_possible_qualifiers (int idx,
1227                                  const aarch64_opnd_qualifier_seq_t *list,
1228                                  enum aarch64_opnd_qualifier *qualifiers)
1229 {
1230   int i;
1231   for (i = 0; i < AARCH64_MAX_QLF_SEQ_NUM; ++i)
1232     if ((qualifiers[i] = list[i][idx]) == AARCH64_OPND_QLF_NIL)
1233       break;
1234 }
1235
1236 /* Decode the size Q field for e.g. SHADD.
1237    We tag one operand with the qualifer according to the code;
1238    whether the qualifier is valid for this opcode or not, it is the
1239    duty of the semantic checking.  */
1240
1241 static int
1242 decode_sizeq (aarch64_inst *inst)
1243 {
1244   int idx;
1245   enum aarch64_opnd_qualifier qualifier;
1246   aarch64_insn code;
1247   aarch64_insn value, mask;
1248   enum aarch64_field_kind fld_sz;
1249   enum aarch64_opnd_qualifier candidates[AARCH64_MAX_QLF_SEQ_NUM];
1250
1251   if (inst->opcode->iclass == asisdlse
1252      || inst->opcode->iclass == asisdlsep
1253      || inst->opcode->iclass == asisdlso
1254      || inst->opcode->iclass == asisdlsop)
1255     fld_sz = FLD_vldst_size;
1256   else
1257     fld_sz = FLD_size;
1258
1259   code = inst->value;
1260   value = extract_fields (code, inst->opcode->mask, 2, fld_sz, FLD_Q);
1261   /* Obtain the info that which bits of fields Q and size are actually
1262      available for operand encoding.  Opcodes like FMAXNM and FMLA have
1263      size[1] unavailable.  */
1264   mask = extract_fields (~inst->opcode->mask, 0, 2, fld_sz, FLD_Q);
1265
1266   /* The index of the operand we are going to tag a qualifier and the qualifer
1267      itself are reasoned from the value of the size and Q fields and the
1268      possible valid qualifier lists.  */
1269   idx = aarch64_select_operand_for_sizeq_field_coding (inst->opcode);
1270   DEBUG_TRACE ("key idx: %d", idx);
1271
1272   /* For most related instruciton, size:Q are fully available for operand
1273      encoding.  */
1274   if (mask == 0x7)
1275     {
1276       inst->operands[idx].qualifier = get_vreg_qualifier_from_value (value);
1277       return 1;
1278     }
1279
1280   get_operand_possible_qualifiers (idx, inst->opcode->qualifiers_list,
1281                                    candidates);
1282 #ifdef DEBUG_AARCH64
1283   if (debug_dump)
1284     {
1285       int i;
1286       for (i = 0; candidates[i] != AARCH64_OPND_QLF_NIL
1287            && i < AARCH64_MAX_QLF_SEQ_NUM; ++i)
1288         DEBUG_TRACE ("qualifier %d: %s", i,
1289                      aarch64_get_qualifier_name(candidates[i]));
1290       DEBUG_TRACE ("%d, %d", (int)value, (int)mask);
1291     }
1292 #endif /* DEBUG_AARCH64 */
1293
1294   qualifier = get_qualifier_from_partial_encoding (value, candidates, mask);
1295
1296   if (qualifier == AARCH64_OPND_QLF_NIL)
1297     return 0;
1298
1299   inst->operands[idx].qualifier = qualifier;
1300   return 1;
1301 }
1302
1303 /* Decode size[0]:Q, i.e. bit 22 and bit 30, for
1304      e.g. FCVTN<Q> <Vd>.<Tb>, <Vn>.<Ta>.  */
1305
1306 static int
1307 decode_asimd_fcvt (aarch64_inst *inst)
1308 {
1309   aarch64_field field = {0, 0};
1310   aarch64_insn value;
1311   enum aarch64_opnd_qualifier qualifier;
1312
1313   gen_sub_field (FLD_size, 0, 1, &field);
1314   value = extract_field_2 (&field, inst->value, 0);
1315   qualifier = value == 0 ? AARCH64_OPND_QLF_V_4S
1316     : AARCH64_OPND_QLF_V_2D;
1317   switch (inst->opcode->op)
1318     {
1319     case OP_FCVTN:
1320     case OP_FCVTN2:
1321       /* FCVTN<Q> <Vd>.<Tb>, <Vn>.<Ta>.  */
1322       inst->operands[1].qualifier = qualifier;
1323       break;
1324     case OP_FCVTL:
1325     case OP_FCVTL2:
1326       /* FCVTL<Q> <Vd>.<Ta>, <Vn>.<Tb>.  */
1327       inst->operands[0].qualifier = qualifier;
1328       break;
1329     default:
1330       assert (0);
1331       return 0;
1332     }
1333
1334   return 1;
1335 }
1336
1337 /* Decode size[0], i.e. bit 22, for
1338      e.g. FCVTXN <Vb><d>, <Va><n>.  */
1339
1340 static int
1341 decode_asisd_fcvtxn (aarch64_inst *inst)
1342 {
1343   aarch64_field field = {0, 0};
1344   gen_sub_field (FLD_size, 0, 1, &field);
1345   if (!extract_field_2 (&field, inst->value, 0))
1346     return 0;
1347   inst->operands[0].qualifier = AARCH64_OPND_QLF_S_S;
1348   return 1;
1349 }
1350
1351 /* Decode the 'opc' field for e.g. FCVT <Dd>, <Sn>.  */
1352 static int
1353 decode_fcvt (aarch64_inst *inst)
1354 {
1355   enum aarch64_opnd_qualifier qualifier;
1356   aarch64_insn value;
1357   const aarch64_field field = {15, 2};
1358
1359   /* opc dstsize */
1360   value = extract_field_2 (&field, inst->value, 0);
1361   switch (value)
1362     {
1363     case 0: qualifier = AARCH64_OPND_QLF_S_S; break;
1364     case 1: qualifier = AARCH64_OPND_QLF_S_D; break;
1365     case 3: qualifier = AARCH64_OPND_QLF_S_H; break;
1366     default: return 0;
1367     }
1368   inst->operands[0].qualifier = qualifier;
1369
1370   return 1;
1371 }
1372
1373 /* Do miscellaneous decodings that are not common enough to be driven by
1374    flags.  */
1375
1376 static int
1377 do_misc_decoding (aarch64_inst *inst)
1378 {
1379   switch (inst->opcode->op)
1380     {
1381     case OP_FCVT:
1382       return decode_fcvt (inst);
1383     case OP_FCVTN:
1384     case OP_FCVTN2:
1385     case OP_FCVTL:
1386     case OP_FCVTL2:
1387       return decode_asimd_fcvt (inst);
1388     case OP_FCVTXN_S:
1389       return decode_asisd_fcvtxn (inst);
1390     default:
1391       return 0;
1392     }
1393 }
1394
1395 /* Opcodes that have fields shared by multiple operands are usually flagged
1396    with flags.  In this function, we detect such flags, decode the related
1397    field(s) and store the information in one of the related operands.  The
1398    'one' operand is not any operand but one of the operands that can
1399    accommadate all the information that has been decoded.  */
1400
1401 static int
1402 do_special_decoding (aarch64_inst *inst)
1403 {
1404   int idx;
1405   aarch64_insn value;
1406   /* Condition for truly conditional executed instructions, e.g. b.cond.  */
1407   if (inst->opcode->flags & F_COND)
1408     {
1409       value = extract_field (FLD_cond2, inst->value, 0);
1410       inst->cond = get_cond_from_value (value);
1411     }
1412   /* 'sf' field.  */
1413   if (inst->opcode->flags & F_SF)
1414     {
1415       idx = select_operand_for_sf_field_coding (inst->opcode);
1416       value = extract_field (FLD_sf, inst->value, 0);
1417       inst->operands[idx].qualifier = get_greg_qualifier_from_value (value);
1418       if ((inst->opcode->flags & F_N)
1419           && extract_field (FLD_N, inst->value, 0) != value)
1420         return 0;
1421     }
1422   /* 'sf' field.  */
1423   if (inst->opcode->flags & F_LSE_SZ)
1424     {
1425       idx = select_operand_for_sf_field_coding (inst->opcode);
1426       value = extract_field (FLD_lse_sz, inst->value, 0);
1427       inst->operands[idx].qualifier = get_greg_qualifier_from_value (value);
1428     }
1429   /* size:Q fields.  */
1430   if (inst->opcode->flags & F_SIZEQ)
1431     return decode_sizeq (inst);
1432
1433   if (inst->opcode->flags & F_FPTYPE)
1434     {
1435       idx = select_operand_for_fptype_field_coding (inst->opcode);
1436       value = extract_field (FLD_type, inst->value, 0);
1437       switch (value)
1438         {
1439         case 0: inst->operands[idx].qualifier = AARCH64_OPND_QLF_S_S; break;
1440         case 1: inst->operands[idx].qualifier = AARCH64_OPND_QLF_S_D; break;
1441         case 3: inst->operands[idx].qualifier = AARCH64_OPND_QLF_S_H; break;
1442         default: return 0;
1443         }
1444     }
1445
1446   if (inst->opcode->flags & F_SSIZE)
1447     {
1448       /* N.B. some opcodes like FCMGT <V><d>, <V><n>, #0 have the size[1] as part
1449          of the base opcode.  */
1450       aarch64_insn mask;
1451       enum aarch64_opnd_qualifier candidates[AARCH64_MAX_QLF_SEQ_NUM];
1452       idx = select_operand_for_scalar_size_field_coding (inst->opcode);
1453       value = extract_field (FLD_size, inst->value, inst->opcode->mask);
1454       mask = extract_field (FLD_size, ~inst->opcode->mask, 0);
1455       /* For most related instruciton, the 'size' field is fully available for
1456          operand encoding.  */
1457       if (mask == 0x3)
1458         inst->operands[idx].qualifier = get_sreg_qualifier_from_value (value);
1459       else
1460         {
1461           get_operand_possible_qualifiers (idx, inst->opcode->qualifiers_list,
1462                                            candidates);
1463           inst->operands[idx].qualifier
1464             = get_qualifier_from_partial_encoding (value, candidates, mask);
1465         }
1466     }
1467
1468   if (inst->opcode->flags & F_T)
1469     {
1470       /* Num of consecutive '0's on the right side of imm5<3:0>.  */
1471       int num = 0;
1472       unsigned val, Q;
1473       assert (aarch64_get_operand_class (inst->opcode->operands[0])
1474               == AARCH64_OPND_CLASS_SIMD_REG);
1475       /* imm5<3:0>      q       <t>
1476          0000           x       reserved
1477          xxx1           0       8b
1478          xxx1           1       16b
1479          xx10           0       4h
1480          xx10           1       8h
1481          x100           0       2s
1482          x100           1       4s
1483          1000           0       reserved
1484          1000           1       2d  */
1485       val = extract_field (FLD_imm5, inst->value, 0);
1486       while ((val & 0x1) == 0 && ++num <= 3)
1487         val >>= 1;
1488       if (num > 3)
1489         return 0;
1490       Q = (unsigned) extract_field (FLD_Q, inst->value, inst->opcode->mask);
1491       inst->operands[0].qualifier =
1492         get_vreg_qualifier_from_value ((num << 1) | Q);
1493     }
1494
1495   if (inst->opcode->flags & F_GPRSIZE_IN_Q)
1496     {
1497       /* Use Rt to encode in the case of e.g.
1498          STXP <Ws>, <Xt1>, <Xt2>, [<Xn|SP>{,#0}].  */
1499       idx = aarch64_operand_index (inst->opcode->operands, AARCH64_OPND_Rt);
1500       if (idx == -1)
1501         {
1502           /* Otherwise use the result operand, which has to be a integer
1503              register.  */
1504           assert (aarch64_get_operand_class (inst->opcode->operands[0])
1505                   == AARCH64_OPND_CLASS_INT_REG);
1506           idx = 0;
1507         }
1508       assert (idx == 0 || idx == 1);
1509       value = extract_field (FLD_Q, inst->value, 0);
1510       inst->operands[idx].qualifier = get_greg_qualifier_from_value (value);
1511     }
1512
1513   if (inst->opcode->flags & F_LDS_SIZE)
1514     {
1515       aarch64_field field = {0, 0};
1516       assert (aarch64_get_operand_class (inst->opcode->operands[0])
1517               == AARCH64_OPND_CLASS_INT_REG);
1518       gen_sub_field (FLD_opc, 0, 1, &field);
1519       value = extract_field_2 (&field, inst->value, 0);
1520       inst->operands[0].qualifier
1521         = value ? AARCH64_OPND_QLF_W : AARCH64_OPND_QLF_X;
1522     }
1523
1524   /* Miscellaneous decoding; done as the last step.  */
1525   if (inst->opcode->flags & F_MISC)
1526     return do_misc_decoding (inst);
1527
1528   return 1;
1529 }
1530
1531 /* Converters converting a real opcode instruction to its alias form.  */
1532
1533 /* ROR <Wd>, <Ws>, #<shift>
1534      is equivalent to:
1535    EXTR <Wd>, <Ws>, <Ws>, #<shift>.  */
1536 static int
1537 convert_extr_to_ror (aarch64_inst *inst)
1538 {
1539   if (inst->operands[1].reg.regno == inst->operands[2].reg.regno)
1540     {
1541       copy_operand_info (inst, 2, 3);
1542       inst->operands[3].type = AARCH64_OPND_NIL;
1543       return 1;
1544     }
1545   return 0;
1546 }
1547
1548 /* UXTL<Q> <Vd>.<Ta>, <Vn>.<Tb>
1549      is equivalent to:
1550    USHLL<Q> <Vd>.<Ta>, <Vn>.<Tb>, #0.  */
1551 static int
1552 convert_shll_to_xtl (aarch64_inst *inst)
1553 {
1554   if (inst->operands[2].imm.value == 0)
1555     {
1556       inst->operands[2].type = AARCH64_OPND_NIL;
1557       return 1;
1558     }
1559   return 0;
1560 }
1561
1562 /* Convert
1563      UBFM <Xd>, <Xn>, #<shift>, #63.
1564    to
1565      LSR <Xd>, <Xn>, #<shift>.  */
1566 static int
1567 convert_bfm_to_sr (aarch64_inst *inst)
1568 {
1569   int64_t imms, val;
1570
1571   imms = inst->operands[3].imm.value;
1572   val = inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31 ? 31 : 63;
1573   if (imms == val)
1574     {
1575       inst->operands[3].type = AARCH64_OPND_NIL;
1576       return 1;
1577     }
1578
1579   return 0;
1580 }
1581
1582 /* Convert MOV to ORR.  */
1583 static int
1584 convert_orr_to_mov (aarch64_inst *inst)
1585 {
1586   /* MOV <Vd>.<T>, <Vn>.<T>
1587      is equivalent to:
1588      ORR <Vd>.<T>, <Vn>.<T>, <Vn>.<T>.  */
1589   if (inst->operands[1].reg.regno == inst->operands[2].reg.regno)
1590     {
1591       inst->operands[2].type = AARCH64_OPND_NIL;
1592       return 1;
1593     }
1594   return 0;
1595 }
1596
1597 /* When <imms> >= <immr>, the instruction written:
1598      SBFX <Xd>, <Xn>, #<lsb>, #<width>
1599    is equivalent to:
1600      SBFM <Xd>, <Xn>, #<lsb>, #(<lsb>+<width>-1).  */
1601
1602 static int
1603 convert_bfm_to_bfx (aarch64_inst *inst)
1604 {
1605   int64_t immr, imms;
1606
1607   immr = inst->operands[2].imm.value;
1608   imms = inst->operands[3].imm.value;
1609   if (imms >= immr)
1610     {
1611       int64_t lsb = immr;
1612       inst->operands[2].imm.value = lsb;
1613       inst->operands[3].imm.value = imms + 1 - lsb;
1614       /* The two opcodes have different qualifiers for
1615          the immediate operands; reset to help the checking.  */
1616       reset_operand_qualifier (inst, 2);
1617       reset_operand_qualifier (inst, 3);
1618       return 1;
1619     }
1620
1621   return 0;
1622 }
1623
1624 /* When <imms> < <immr>, the instruction written:
1625      SBFIZ <Xd>, <Xn>, #<lsb>, #<width>
1626    is equivalent to:
1627      SBFM <Xd>, <Xn>, #((64-<lsb>)&0x3f), #(<width>-1).  */
1628
1629 static int
1630 convert_bfm_to_bfi (aarch64_inst *inst)
1631 {
1632   int64_t immr, imms, val;
1633
1634   immr = inst->operands[2].imm.value;
1635   imms = inst->operands[3].imm.value;
1636   val = inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31 ? 32 : 64;
1637   if (imms < immr)
1638     {
1639       inst->operands[2].imm.value = (val - immr) & (val - 1);
1640       inst->operands[3].imm.value = imms + 1;
1641       /* The two opcodes have different qualifiers for
1642          the immediate operands; reset to help the checking.  */
1643       reset_operand_qualifier (inst, 2);
1644       reset_operand_qualifier (inst, 3);
1645       return 1;
1646     }
1647
1648   return 0;
1649 }
1650
1651 /* The instruction written:
1652      BFC <Xd>, #<lsb>, #<width>
1653    is equivalent to:
1654      BFM <Xd>, XZR, #((64-<lsb>)&0x3f), #(<width>-1).  */
1655
1656 static int
1657 convert_bfm_to_bfc (aarch64_inst *inst)
1658 {
1659   int64_t immr, imms, val;
1660
1661   /* Should have been assured by the base opcode value.  */
1662   assert (inst->operands[1].reg.regno == 0x1f);
1663
1664   immr = inst->operands[2].imm.value;
1665   imms = inst->operands[3].imm.value;
1666   val = inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31 ? 32 : 64;
1667   if (imms < immr)
1668     {
1669       /* Drop XZR from the second operand.  */
1670       copy_operand_info (inst, 1, 2);
1671       copy_operand_info (inst, 2, 3);
1672       inst->operands[3].type = AARCH64_OPND_NIL;
1673
1674       /* Recalculate the immediates.  */
1675       inst->operands[1].imm.value = (val - immr) & (val - 1);
1676       inst->operands[2].imm.value = imms + 1;
1677
1678       /* The two opcodes have different qualifiers for the operands; reset to
1679          help the checking.  */
1680       reset_operand_qualifier (inst, 1);
1681       reset_operand_qualifier (inst, 2);
1682       reset_operand_qualifier (inst, 3);
1683
1684       return 1;
1685     }
1686
1687   return 0;
1688 }
1689
1690 /* The instruction written:
1691      LSL <Xd>, <Xn>, #<shift>
1692    is equivalent to:
1693      UBFM <Xd>, <Xn>, #((64-<shift>)&0x3f), #(63-<shift>).  */
1694
1695 static int
1696 convert_ubfm_to_lsl (aarch64_inst *inst)
1697 {
1698   int64_t immr = inst->operands[2].imm.value;
1699   int64_t imms = inst->operands[3].imm.value;
1700   int64_t val
1701     = inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31 ? 31 : 63;
1702
1703   if ((immr == 0 && imms == val) || immr == imms + 1)
1704     {
1705       inst->operands[3].type = AARCH64_OPND_NIL;
1706       inst->operands[2].imm.value = val - imms;
1707       return 1;
1708     }
1709
1710   return 0;
1711 }
1712
1713 /* CINC <Wd>, <Wn>, <cond>
1714      is equivalent to:
1715    CSINC <Wd>, <Wn>, <Wn>, invert(<cond>)
1716      where <cond> is not AL or NV.  */
1717
1718 static int
1719 convert_from_csel (aarch64_inst *inst)
1720 {
1721   if (inst->operands[1].reg.regno == inst->operands[2].reg.regno
1722       && (inst->operands[3].cond->value & 0xe) != 0xe)
1723     {
1724       copy_operand_info (inst, 2, 3);
1725       inst->operands[2].cond = get_inverted_cond (inst->operands[3].cond);
1726       inst->operands[3].type = AARCH64_OPND_NIL;
1727       return 1;
1728     }
1729   return 0;
1730 }
1731
1732 /* CSET <Wd>, <cond>
1733      is equivalent to:
1734    CSINC <Wd>, WZR, WZR, invert(<cond>)
1735      where <cond> is not AL or NV.  */
1736
1737 static int
1738 convert_csinc_to_cset (aarch64_inst *inst)
1739 {
1740   if (inst->operands[1].reg.regno == 0x1f
1741       && inst->operands[2].reg.regno == 0x1f
1742       && (inst->operands[3].cond->value & 0xe) != 0xe)
1743     {
1744       copy_operand_info (inst, 1, 3);
1745       inst->operands[1].cond = get_inverted_cond (inst->operands[3].cond);
1746       inst->operands[3].type = AARCH64_OPND_NIL;
1747       inst->operands[2].type = AARCH64_OPND_NIL;
1748       return 1;
1749     }
1750   return 0;
1751 }
1752
1753 /* MOV <Wd>, #<imm>
1754      is equivalent to:
1755    MOVZ <Wd>, #<imm16>, LSL #<shift>.
1756
1757    A disassembler may output ORR, MOVZ and MOVN as a MOV mnemonic, except when
1758    ORR has an immediate that could be generated by a MOVZ or MOVN instruction,
1759    or where a MOVN has an immediate that could be encoded by MOVZ, or where
1760    MOVZ/MOVN #0 have a shift amount other than LSL #0, in which case the
1761    machine-instruction mnemonic must be used.  */
1762
1763 static int
1764 convert_movewide_to_mov (aarch64_inst *inst)
1765 {
1766   uint64_t value = inst->operands[1].imm.value;
1767   /* MOVZ/MOVN #0 have a shift amount other than LSL #0.  */
1768   if (value == 0 && inst->operands[1].shifter.amount != 0)
1769     return 0;
1770   inst->operands[1].type = AARCH64_OPND_IMM_MOV;
1771   inst->operands[1].shifter.kind = AARCH64_MOD_NONE;
1772   value <<= inst->operands[1].shifter.amount;
1773   /* As an alias convertor, it has to be clear that the INST->OPCODE
1774      is the opcode of the real instruction.  */
1775   if (inst->opcode->op == OP_MOVN)
1776     {
1777       int is32 = inst->operands[0].qualifier == AARCH64_OPND_QLF_W;
1778       value = ~value;
1779       /* A MOVN has an immediate that could be encoded by MOVZ.  */
1780       if (aarch64_wide_constant_p (value, is32, NULL) == TRUE)
1781         return 0;
1782     }
1783   inst->operands[1].imm.value = value;
1784   inst->operands[1].shifter.amount = 0;
1785   return 1;
1786 }
1787
1788 /* MOV <Wd>, #<imm>
1789      is equivalent to:
1790    ORR <Wd>, WZR, #<imm>.
1791
1792    A disassembler may output ORR, MOVZ and MOVN as a MOV mnemonic, except when
1793    ORR has an immediate that could be generated by a MOVZ or MOVN instruction,
1794    or where a MOVN has an immediate that could be encoded by MOVZ, or where
1795    MOVZ/MOVN #0 have a shift amount other than LSL #0, in which case the
1796    machine-instruction mnemonic must be used.  */
1797
1798 static int
1799 convert_movebitmask_to_mov (aarch64_inst *inst)
1800 {
1801   int is32;
1802   uint64_t value;
1803
1804   /* Should have been assured by the base opcode value.  */
1805   assert (inst->operands[1].reg.regno == 0x1f);
1806   copy_operand_info (inst, 1, 2);
1807   is32 = inst->operands[0].qualifier == AARCH64_OPND_QLF_W;
1808   inst->operands[1].type = AARCH64_OPND_IMM_MOV;
1809   value = inst->operands[1].imm.value;
1810   /* ORR has an immediate that could be generated by a MOVZ or MOVN
1811      instruction.  */
1812   if (inst->operands[0].reg.regno != 0x1f
1813       && (aarch64_wide_constant_p (value, is32, NULL) == TRUE
1814           || aarch64_wide_constant_p (~value, is32, NULL) == TRUE))
1815     return 0;
1816
1817   inst->operands[2].type = AARCH64_OPND_NIL;
1818   return 1;
1819 }
1820
1821 /* Some alias opcodes are disassembled by being converted from their real-form.
1822    N.B. INST->OPCODE is the real opcode rather than the alias.  */
1823
1824 static int
1825 convert_to_alias (aarch64_inst *inst, const aarch64_opcode *alias)
1826 {
1827   switch (alias->op)
1828     {
1829     case OP_ASR_IMM:
1830     case OP_LSR_IMM:
1831       return convert_bfm_to_sr (inst);
1832     case OP_LSL_IMM:
1833       return convert_ubfm_to_lsl (inst);
1834     case OP_CINC:
1835     case OP_CINV:
1836     case OP_CNEG:
1837       return convert_from_csel (inst);
1838     case OP_CSET:
1839     case OP_CSETM:
1840       return convert_csinc_to_cset (inst);
1841     case OP_UBFX:
1842     case OP_BFXIL:
1843     case OP_SBFX:
1844       return convert_bfm_to_bfx (inst);
1845     case OP_SBFIZ:
1846     case OP_BFI:
1847     case OP_UBFIZ:
1848       return convert_bfm_to_bfi (inst);
1849     case OP_BFC:
1850       return convert_bfm_to_bfc (inst);
1851     case OP_MOV_V:
1852       return convert_orr_to_mov (inst);
1853     case OP_MOV_IMM_WIDE:
1854     case OP_MOV_IMM_WIDEN:
1855       return convert_movewide_to_mov (inst);
1856     case OP_MOV_IMM_LOG:
1857       return convert_movebitmask_to_mov (inst);
1858     case OP_ROR_IMM:
1859       return convert_extr_to_ror (inst);
1860     case OP_SXTL:
1861     case OP_SXTL2:
1862     case OP_UXTL:
1863     case OP_UXTL2:
1864       return convert_shll_to_xtl (inst);
1865     default:
1866       return 0;
1867     }
1868 }
1869
1870 static int aarch64_opcode_decode (const aarch64_opcode *, const aarch64_insn,
1871                                   aarch64_inst *, int);
1872
1873 /* Given the instruction information in *INST, check if the instruction has
1874    any alias form that can be used to represent *INST.  If the answer is yes,
1875    update *INST to be in the form of the determined alias.  */
1876
1877 /* In the opcode description table, the following flags are used in opcode
1878    entries to help establish the relations between the real and alias opcodes:
1879
1880         F_ALIAS:        opcode is an alias
1881         F_HAS_ALIAS:    opcode has alias(es)
1882         F_P1
1883         F_P2
1884         F_P3:           Disassembly preference priority 1-3 (the larger the
1885                         higher).  If nothing is specified, it is the priority
1886                         0 by default, i.e. the lowest priority.
1887
1888    Although the relation between the machine and the alias instructions are not
1889    explicitly described, it can be easily determined from the base opcode
1890    values, masks and the flags F_ALIAS and F_HAS_ALIAS in their opcode
1891    description entries:
1892
1893    The mask of an alias opcode must be equal to or a super-set (i.e. more
1894    constrained) of that of the aliased opcode; so is the base opcode value.
1895
1896    if (opcode_has_alias (real) && alias_opcode_p (opcode)
1897        && (opcode->mask & real->mask) == real->mask
1898        && (real->mask & opcode->opcode) == (real->mask & real->opcode))
1899    then OPCODE is an alias of, and only of, the REAL instruction
1900
1901    The alias relationship is forced flat-structured to keep related algorithm
1902    simple; an opcode entry cannot be flagged with both F_ALIAS and F_HAS_ALIAS.
1903
1904    During the disassembling, the decoding decision tree (in
1905    opcodes/aarch64-dis-2.c) always returns an machine instruction opcode entry;
1906    if the decoding of such a machine instruction succeeds (and -Mno-aliases is
1907    not specified), the disassembler will check whether there is any alias
1908    instruction exists for this real instruction.  If there is, the disassembler
1909    will try to disassemble the 32-bit binary again using the alias's rule, or
1910    try to convert the IR to the form of the alias.  In the case of the multiple
1911    aliases, the aliases are tried one by one from the highest priority
1912    (currently the flag F_P3) to the lowest priority (no priority flag), and the
1913    first succeeds first adopted.
1914
1915    You may ask why there is a need for the conversion of IR from one form to
1916    another in handling certain aliases.  This is because on one hand it avoids
1917    adding more operand code to handle unusual encoding/decoding; on other
1918    hand, during the disassembling, the conversion is an effective approach to
1919    check the condition of an alias (as an alias may be adopted only if certain
1920    conditions are met).
1921
1922    In order to speed up the alias opcode lookup, aarch64-gen has preprocessed
1923    aarch64_opcode_table and generated aarch64_find_alias_opcode and
1924    aarch64_find_next_alias_opcode (in opcodes/aarch64-dis-2.c) to help.  */
1925
1926 static void
1927 determine_disassembling_preference (struct aarch64_inst *inst)
1928 {
1929   const aarch64_opcode *opcode;
1930   const aarch64_opcode *alias;
1931
1932   opcode = inst->opcode;
1933
1934   /* This opcode does not have an alias, so use itself.  */
1935   if (opcode_has_alias (opcode) == FALSE)
1936     return;
1937
1938   alias = aarch64_find_alias_opcode (opcode);
1939   assert (alias);
1940
1941 #ifdef DEBUG_AARCH64
1942   if (debug_dump)
1943     {
1944       const aarch64_opcode *tmp = alias;
1945       printf ("####   LIST    orderd: ");
1946       while (tmp)
1947         {
1948           printf ("%s, ", tmp->name);
1949           tmp = aarch64_find_next_alias_opcode (tmp);
1950         }
1951       printf ("\n");
1952     }
1953 #endif /* DEBUG_AARCH64 */
1954
1955   for (; alias; alias = aarch64_find_next_alias_opcode (alias))
1956     {
1957       DEBUG_TRACE ("try %s", alias->name);
1958       assert (alias_opcode_p (alias) || opcode_has_alias (opcode));
1959
1960       /* An alias can be a pseudo opcode which will never be used in the
1961          disassembly, e.g. BIC logical immediate is such a pseudo opcode
1962          aliasing AND.  */
1963       if (pseudo_opcode_p (alias))
1964         {
1965           DEBUG_TRACE ("skip pseudo %s", alias->name);
1966           continue;
1967         }
1968
1969       if ((inst->value & alias->mask) != alias->opcode)
1970         {
1971           DEBUG_TRACE ("skip %s as base opcode not match", alias->name);
1972           continue;
1973         }
1974       /* No need to do any complicated transformation on operands, if the alias
1975          opcode does not have any operand.  */
1976       if (aarch64_num_of_operands (alias) == 0 && alias->opcode == inst->value)
1977         {
1978           DEBUG_TRACE ("succeed with 0-operand opcode %s", alias->name);
1979           aarch64_replace_opcode (inst, alias);
1980           return;
1981         }
1982       if (alias->flags & F_CONV)
1983         {
1984           aarch64_inst copy;
1985           memcpy (&copy, inst, sizeof (aarch64_inst));
1986           /* ALIAS is the preference as long as the instruction can be
1987              successfully converted to the form of ALIAS.  */
1988           if (convert_to_alias (&copy, alias) == 1)
1989             {
1990               aarch64_replace_opcode (&copy, alias);
1991               assert (aarch64_match_operands_constraint (&copy, NULL));
1992               DEBUG_TRACE ("succeed with %s via conversion", alias->name);
1993               memcpy (inst, &copy, sizeof (aarch64_inst));
1994               return;
1995             }
1996         }
1997       else
1998         {
1999           /* Directly decode the alias opcode.  */
2000           aarch64_inst temp;
2001           memset (&temp, '\0', sizeof (aarch64_inst));
2002           if (aarch64_opcode_decode (alias, inst->value, &temp, 1) == 1)
2003             {
2004               DEBUG_TRACE ("succeed with %s via direct decoding", alias->name);
2005               memcpy (inst, &temp, sizeof (aarch64_inst));
2006               return;
2007             }
2008         }
2009     }
2010 }
2011
2012 /* Decode the CODE according to OPCODE; fill INST.  Return 0 if the decoding
2013    fails, which meanes that CODE is not an instruction of OPCODE; otherwise
2014    return 1.
2015
2016    If OPCODE has alias(es) and NOALIASES_P is 0, an alias opcode may be
2017    determined and used to disassemble CODE; this is done just before the
2018    return.  */
2019
2020 static int
2021 aarch64_opcode_decode (const aarch64_opcode *opcode, const aarch64_insn code,
2022                        aarch64_inst *inst, int noaliases_p)
2023 {
2024   int i;
2025
2026   DEBUG_TRACE ("enter with %s", opcode->name);
2027
2028   assert (opcode && inst);
2029
2030   /* Check the base opcode.  */
2031   if ((code & opcode->mask) != (opcode->opcode & opcode->mask))
2032     {
2033       DEBUG_TRACE ("base opcode match FAIL");
2034       goto decode_fail;
2035     }
2036
2037   /* Clear inst.  */
2038   memset (inst, '\0', sizeof (aarch64_inst));
2039
2040   inst->opcode = opcode;
2041   inst->value = code;
2042
2043   /* Assign operand codes and indexes.  */
2044   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2045     {
2046       if (opcode->operands[i] == AARCH64_OPND_NIL)
2047         break;
2048       inst->operands[i].type = opcode->operands[i];
2049       inst->operands[i].idx = i;
2050     }
2051
2052   /* Call the opcode decoder indicated by flags.  */
2053   if (opcode_has_special_coder (opcode) && do_special_decoding (inst) == 0)
2054     {
2055       DEBUG_TRACE ("opcode flag-based decoder FAIL");
2056       goto decode_fail;
2057     }
2058
2059   /* Call operand decoders.  */
2060   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2061     {
2062       const aarch64_operand *opnd;
2063       enum aarch64_opnd type;
2064
2065       type = opcode->operands[i];
2066       if (type == AARCH64_OPND_NIL)
2067         break;
2068       opnd = &aarch64_operands[type];
2069       if (operand_has_extractor (opnd)
2070           && (! aarch64_extract_operand (opnd, &inst->operands[i], code, inst)))
2071         {
2072           DEBUG_TRACE ("operand decoder FAIL at operand %d", i);
2073           goto decode_fail;
2074         }
2075     }
2076
2077   /* If the opcode has a verifier, then check it now.  */
2078   if (opcode->verifier && ! opcode->verifier (opcode, code))
2079     {
2080       DEBUG_TRACE ("operand verifier FAIL");
2081       goto decode_fail;
2082     }
2083
2084   /* Match the qualifiers.  */
2085   if (aarch64_match_operands_constraint (inst, NULL) == 1)
2086     {
2087       /* Arriving here, the CODE has been determined as a valid instruction
2088          of OPCODE and *INST has been filled with information of this OPCODE
2089          instruction.  Before the return, check if the instruction has any
2090          alias and should be disassembled in the form of its alias instead.
2091          If the answer is yes, *INST will be updated.  */
2092       if (!noaliases_p)
2093         determine_disassembling_preference (inst);
2094       DEBUG_TRACE ("SUCCESS");
2095       return 1;
2096     }
2097   else
2098     {
2099       DEBUG_TRACE ("constraint matching FAIL");
2100     }
2101
2102 decode_fail:
2103   return 0;
2104 }
2105 \f
2106 /* This does some user-friendly fix-up to *INST.  It is currently focus on
2107    the adjustment of qualifiers to help the printed instruction
2108    recognized/understood more easily.  */
2109
2110 static void
2111 user_friendly_fixup (aarch64_inst *inst)
2112 {
2113   switch (inst->opcode->iclass)
2114     {
2115     case testbranch:
2116       /* TBNZ Xn|Wn, #uimm6, label
2117          Test and Branch Not Zero: conditionally jumps to label if bit number
2118          uimm6 in register Xn is not zero.  The bit number implies the width of
2119          the register, which may be written and should be disassembled as Wn if
2120          uimm is less than 32. Limited to a branch offset range of +/- 32KiB.
2121          */
2122       if (inst->operands[1].imm.value < 32)
2123         inst->operands[0].qualifier = AARCH64_OPND_QLF_W;
2124       break;
2125     default: break;
2126     }
2127 }
2128
2129 /* Decode INSN and fill in *INST the instruction information.  An alias
2130    opcode may be filled in *INSN if NOALIASES_P is FALSE.  Return zero on
2131    success.  */
2132
2133 int
2134 aarch64_decode_insn (aarch64_insn insn, aarch64_inst *inst,
2135                      bfd_boolean noaliases_p)
2136 {
2137   const aarch64_opcode *opcode = aarch64_opcode_lookup (insn);
2138
2139 #ifdef DEBUG_AARCH64
2140   if (debug_dump)
2141     {
2142       const aarch64_opcode *tmp = opcode;
2143       printf ("\n");
2144       DEBUG_TRACE ("opcode lookup:");
2145       while (tmp != NULL)
2146         {
2147           aarch64_verbose ("  %s", tmp->name);
2148           tmp = aarch64_find_next_opcode (tmp);
2149         }
2150     }
2151 #endif /* DEBUG_AARCH64 */
2152
2153   /* A list of opcodes may have been found, as aarch64_opcode_lookup cannot
2154      distinguish some opcodes, e.g. SSHR and MOVI, which almost share the same
2155      opcode field and value, apart from the difference that one of them has an
2156      extra field as part of the opcode, but such a field is used for operand
2157      encoding in other opcode(s) ('immh' in the case of the example).  */
2158   while (opcode != NULL)
2159     {
2160       /* But only one opcode can be decoded successfully for, as the
2161          decoding routine will check the constraint carefully.  */
2162       if (aarch64_opcode_decode (opcode, insn, inst, noaliases_p) == 1)
2163         return ERR_OK;
2164       opcode = aarch64_find_next_opcode (opcode);
2165     }
2166
2167   return ERR_UND;
2168 }
2169
2170 /* Print operands.  */
2171
2172 static void
2173 print_operands (bfd_vma pc, const aarch64_opcode *opcode,
2174                 const aarch64_opnd_info *opnds, struct disassemble_info *info)
2175 {
2176   int i, pcrel_p, num_printed;
2177   for (i = 0, num_printed = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2178     {
2179       char str[128];
2180       /* We regard the opcode operand info more, however we also look into
2181          the inst->operands to support the disassembling of the optional
2182          operand.
2183          The two operand code should be the same in all cases, apart from
2184          when the operand can be optional.  */
2185       if (opcode->operands[i] == AARCH64_OPND_NIL
2186           || opnds[i].type == AARCH64_OPND_NIL)
2187         break;
2188
2189       /* Generate the operand string in STR.  */
2190       aarch64_print_operand (str, sizeof (str), pc, opcode, opnds, i, &pcrel_p,
2191                              &info->target);
2192
2193       /* Print the delimiter (taking account of omitted operand(s)).  */
2194       if (str[0] != '\0')
2195         (*info->fprintf_func) (info->stream, "%s",
2196                                num_printed++ == 0 ? "\t" : ", ");
2197
2198       /* Print the operand.  */
2199       if (pcrel_p)
2200         (*info->print_address_func) (info->target, info);
2201       else
2202         (*info->fprintf_func) (info->stream, "%s", str);
2203     }
2204 }
2205
2206 /* Print the instruction mnemonic name.  */
2207
2208 static void
2209 print_mnemonic_name (const aarch64_inst *inst, struct disassemble_info *info)
2210 {
2211   if (inst->opcode->flags & F_COND)
2212     {
2213       /* For instructions that are truly conditionally executed, e.g. b.cond,
2214          prepare the full mnemonic name with the corresponding condition
2215          suffix.  */
2216       char name[8], *ptr;
2217       size_t len;
2218
2219       ptr = strchr (inst->opcode->name, '.');
2220       assert (ptr && inst->cond);
2221       len = ptr - inst->opcode->name;
2222       assert (len < 8);
2223       strncpy (name, inst->opcode->name, len);
2224       name [len] = '\0';
2225       (*info->fprintf_func) (info->stream, "%s.%s", name, inst->cond->names[0]);
2226     }
2227   else
2228     (*info->fprintf_func) (info->stream, "%s", inst->opcode->name);
2229 }
2230
2231 /* Print the instruction according to *INST.  */
2232
2233 static void
2234 print_aarch64_insn (bfd_vma pc, const aarch64_inst *inst,
2235                     struct disassemble_info *info)
2236 {
2237   print_mnemonic_name (inst, info);
2238   print_operands (pc, inst->opcode, inst->operands, info);
2239 }
2240
2241 /* Entry-point of the instruction disassembler and printer.  */
2242
2243 static void
2244 print_insn_aarch64_word (bfd_vma pc,
2245                          uint32_t word,
2246                          struct disassemble_info *info)
2247 {
2248   static const char *err_msg[6] =
2249     {
2250       [ERR_OK]   = "_",
2251       [-ERR_UND] = "undefined",
2252       [-ERR_UNP] = "unpredictable",
2253       [-ERR_NYI] = "NYI"
2254     };
2255
2256   int ret;
2257   aarch64_inst inst;
2258
2259   info->insn_info_valid = 1;
2260   info->branch_delay_insns = 0;
2261   info->data_size = 0;
2262   info->target = 0;
2263   info->target2 = 0;
2264
2265   if (info->flags & INSN_HAS_RELOC)
2266     /* If the instruction has a reloc associated with it, then
2267        the offset field in the instruction will actually be the
2268        addend for the reloc.  (If we are using REL type relocs).
2269        In such cases, we can ignore the pc when computing
2270        addresses, since the addend is not currently pc-relative.  */
2271     pc = 0;
2272
2273   ret = aarch64_decode_insn (word, &inst, no_aliases);
2274
2275   if (((word >> 21) & 0x3ff) == 1)
2276     {
2277       /* RESERVED for ALES.  */
2278       assert (ret != ERR_OK);
2279       ret = ERR_NYI;
2280     }
2281
2282   switch (ret)
2283     {
2284     case ERR_UND:
2285     case ERR_UNP:
2286     case ERR_NYI:
2287       /* Handle undefined instructions.  */
2288       info->insn_type = dis_noninsn;
2289       (*info->fprintf_func) (info->stream,".inst\t0x%08x ; %s",
2290                              word, err_msg[-ret]);
2291       break;
2292     case ERR_OK:
2293       user_friendly_fixup (&inst);
2294       print_aarch64_insn (pc, &inst, info);
2295       break;
2296     default:
2297       abort ();
2298     }
2299 }
2300
2301 /* Disallow mapping symbols ($x, $d etc) from
2302    being displayed in symbol relative addresses.  */
2303
2304 bfd_boolean
2305 aarch64_symbol_is_valid (asymbol * sym,
2306                          struct disassemble_info * info ATTRIBUTE_UNUSED)
2307 {
2308   const char * name;
2309
2310   if (sym == NULL)
2311     return FALSE;
2312
2313   name = bfd_asymbol_name (sym);
2314
2315   return name
2316     && (name[0] != '$'
2317         || (name[1] != 'x' && name[1] != 'd')
2318         || (name[2] != '\0' && name[2] != '.'));
2319 }
2320
2321 /* Print data bytes on INFO->STREAM.  */
2322
2323 static void
2324 print_insn_data (bfd_vma pc ATTRIBUTE_UNUSED,
2325                  uint32_t word,
2326                  struct disassemble_info *info)
2327 {
2328   switch (info->bytes_per_chunk)
2329     {
2330     case 1:
2331       info->fprintf_func (info->stream, ".byte\t0x%02x", word);
2332       break;
2333     case 2:
2334       info->fprintf_func (info->stream, ".short\t0x%04x", word);
2335       break;
2336     case 4:
2337       info->fprintf_func (info->stream, ".word\t0x%08x", word);
2338       break;
2339     default:
2340       abort ();
2341     }
2342 }
2343
2344 /* Try to infer the code or data type from a symbol.
2345    Returns nonzero if *MAP_TYPE was set.  */
2346
2347 static int
2348 get_sym_code_type (struct disassemble_info *info, int n,
2349                    enum map_type *map_type)
2350 {
2351   elf_symbol_type *es;
2352   unsigned int type;
2353   const char *name;
2354
2355   es = *(elf_symbol_type **)(info->symtab + n);
2356   type = ELF_ST_TYPE (es->internal_elf_sym.st_info);
2357
2358   /* If the symbol has function type then use that.  */
2359   if (type == STT_FUNC)
2360     {
2361       *map_type = MAP_INSN;
2362       return TRUE;
2363     }
2364
2365   /* Check for mapping symbols.  */
2366   name = bfd_asymbol_name(info->symtab[n]);
2367   if (name[0] == '$'
2368       && (name[1] == 'x' || name[1] == 'd')
2369       && (name[2] == '\0' || name[2] == '.'))
2370     {
2371       *map_type = (name[1] == 'x' ? MAP_INSN : MAP_DATA);
2372       return TRUE;
2373     }
2374
2375   return FALSE;
2376 }
2377
2378 /* Entry-point of the AArch64 disassembler.  */
2379
2380 int
2381 print_insn_aarch64 (bfd_vma pc,
2382                     struct disassemble_info *info)
2383 {
2384   bfd_byte      buffer[INSNLEN];
2385   int           status;
2386   void          (*printer) (bfd_vma, uint32_t, struct disassemble_info *);
2387   bfd_boolean   found = FALSE;
2388   unsigned int  size = 4;
2389   unsigned long data;
2390
2391   if (info->disassembler_options)
2392     {
2393       set_default_aarch64_dis_options (info);
2394
2395       parse_aarch64_dis_options (info->disassembler_options);
2396
2397       /* To avoid repeated parsing of these options, we remove them here.  */
2398       info->disassembler_options = NULL;
2399     }
2400
2401   /* Aarch64 instructions are always little-endian */
2402   info->endian_code = BFD_ENDIAN_LITTLE;
2403
2404   /* First check the full symtab for a mapping symbol, even if there
2405      are no usable non-mapping symbols for this address.  */
2406   if (info->symtab_size != 0
2407       && bfd_asymbol_flavour (*info->symtab) == bfd_target_elf_flavour)
2408     {
2409       enum map_type type = MAP_INSN;
2410       int last_sym = -1;
2411       bfd_vma addr;
2412       int n;
2413
2414       if (pc <= last_mapping_addr)
2415         last_mapping_sym = -1;
2416
2417       /* Start scanning at the start of the function, or wherever
2418          we finished last time.  */
2419       n = info->symtab_pos + 1;
2420       if (n < last_mapping_sym)
2421         n = last_mapping_sym;
2422
2423       /* Scan up to the location being disassembled.  */
2424       for (; n < info->symtab_size; n++)
2425         {
2426           addr = bfd_asymbol_value (info->symtab[n]);
2427           if (addr > pc)
2428             break;
2429           if ((info->section == NULL
2430                || info->section == info->symtab[n]->section)
2431               && get_sym_code_type (info, n, &type))
2432             {
2433               last_sym = n;
2434               found = TRUE;
2435             }
2436         }
2437
2438       if (!found)
2439         {
2440           n = info->symtab_pos;
2441           if (n < last_mapping_sym)
2442             n = last_mapping_sym;
2443
2444           /* No mapping symbol found at this address.  Look backwards
2445              for a preceeding one.  */
2446           for (; n >= 0; n--)
2447             {
2448               if (get_sym_code_type (info, n, &type))
2449                 {
2450                   last_sym = n;
2451                   found = TRUE;
2452                   break;
2453                 }
2454             }
2455         }
2456
2457       last_mapping_sym = last_sym;
2458       last_type = type;
2459
2460       /* Look a little bit ahead to see if we should print out
2461          less than four bytes of data.  If there's a symbol,
2462          mapping or otherwise, after two bytes then don't
2463          print more.  */
2464       if (last_type == MAP_DATA)
2465         {
2466           size = 4 - (pc & 3);
2467           for (n = last_sym + 1; n < info->symtab_size; n++)
2468             {
2469               addr = bfd_asymbol_value (info->symtab[n]);
2470               if (addr > pc)
2471                 {
2472                   if (addr - pc < size)
2473                     size = addr - pc;
2474                   break;
2475                 }
2476             }
2477           /* If the next symbol is after three bytes, we need to
2478              print only part of the data, so that we can use either
2479              .byte or .short.  */
2480           if (size == 3)
2481             size = (pc & 1) ? 1 : 2;
2482         }
2483     }
2484
2485   if (last_type == MAP_DATA)
2486     {
2487       /* size was set above.  */
2488       info->bytes_per_chunk = size;
2489       info->display_endian = info->endian;
2490       printer = print_insn_data;
2491     }
2492   else
2493     {
2494       info->bytes_per_chunk = size = INSNLEN;
2495       info->display_endian = info->endian_code;
2496       printer = print_insn_aarch64_word;
2497     }
2498
2499   status = (*info->read_memory_func) (pc, buffer, size, info);
2500   if (status != 0)
2501     {
2502       (*info->memory_error_func) (status, pc, info);
2503       return -1;
2504     }
2505
2506   data = bfd_get_bits (buffer, size * 8,
2507                        info->display_endian == BFD_ENDIAN_BIG);
2508
2509   (*printer) (pc, data, info);
2510
2511   return size;
2512 }
2513 \f
2514 void
2515 print_aarch64_disassembler_options (FILE *stream)
2516 {
2517   fprintf (stream, _("\n\
2518 The following AARCH64 specific disassembler options are supported for use\n\
2519 with the -M switch (multiple options should be separated by commas):\n"));
2520
2521   fprintf (stream, _("\n\
2522   no-aliases         Don't print instruction aliases.\n"));
2523
2524   fprintf (stream, _("\n\
2525   aliases            Do print instruction aliases.\n"));
2526
2527 #ifdef DEBUG_AARCH64
2528   fprintf (stream, _("\n\
2529   debug_dump         Temp switch for debug trace.\n"));
2530 #endif /* DEBUG_AARCH64 */
2531
2532   fprintf (stream, _("\n"));
2533 }