opcodes/aarch64-dis.c

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