opcodes/aarch64-asm.c

   1 /* aarch64-asm.c -- AArch64 assembler support.
   2    Copyright (C) 2012-2019 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 <stdarg.h>
  23 #include "libiberty.h"
  24 #include "aarch64-asm.h"
  25 #include "opintl.h"
  26
  27 /* Utilities.  */
  28
  29 /* The unnamed arguments consist of the number of fields and information about
  30    these fields where the VALUE will be inserted into CODE.  MASK can be zero or
  31    the base mask of the opcode.
  32
  33    N.B. the fields are required to be in such an order than the least signficant
  34    field for VALUE comes the first, e.g. the <index> in
  35     SQDMLAL <Va><d>, <Vb><n>, <Vm>.<Ts>[<index>]
  36    is encoded in H:L:M in some cases, the fields H:L:M should be passed in
  37    the order of M, L, H.  */
  38
  39 static inline void
  40 insert_fields (aarch64_insn *code, aarch64_insn value, aarch64_insn mask, ...)
  41 {
  42   uint32_t num;
  43   const aarch64_field *field;
  44   enum aarch64_field_kind kind;
  45   va_list va;
  46
  47   va_start (va, mask);
  48   num = va_arg (va, uint32_t);
  49   assert (num <= 5);
  50   while (num--)
  51     {
  52       kind = va_arg (va, enum aarch64_field_kind);
  53       field = &fields[kind];
  54       insert_field (kind, code, value, mask);
  55       value >>= field->width;
  56     }
  57   va_end (va);
  58 }
  59
  60 /* Insert a raw field value VALUE into all fields in SELF->fields.
  61    The least significant bit goes in the final field.  */
  62
  63 static void
  64 insert_all_fields (const aarch64_operand *self, aarch64_insn *code,
  65                    aarch64_insn value)
  66 {
  67   unsigned int i;
  68   enum aarch64_field_kind kind;
  69
  70   for (i = ARRAY_SIZE (self->fields); i-- > 0; )
  71     if (self->fields[i] != FLD_NIL)
  72       {
  73         kind = self->fields[i];
  74         insert_field (kind, code, value, 0);
  75         value >>= fields[kind].width;
  76       }
  77 }
  78
  79 /* Operand inserters.  */
  80
  81 /* Insert register number.  */
  82 bfd_boolean
  83 aarch64_ins_regno (const aarch64_operand *self, const aarch64_opnd_info *info,
  84                    aarch64_insn *code,
  85                    const aarch64_inst *inst ATTRIBUTE_UNUSED,
  86                    aarch64_operand_error *errors ATTRIBUTE_UNUSED)
  87 {
  88   insert_field (self->fields[0], code, info->reg.regno, 0);
  89   return TRUE;
  90 }
  91
  92 /* Insert register number, index and/or other data for SIMD register element
  93    operand, e.g. the last source operand in
  94      SQDMLAL <Va><d>, <Vb><n>, <Vm>.<Ts>[<index>].  */
  95 bfd_boolean
  96 aarch64_ins_reglane (const aarch64_operand *self, const aarch64_opnd_info *info,
  97                      aarch64_insn *code, const aarch64_inst *inst,
  98                      aarch64_operand_error *errors ATTRIBUTE_UNUSED)
  99 {
 100   /* regno */
 101   insert_field (self->fields[0], code, info->reglane.regno, inst->opcode->mask);
 102   /* index and/or type */
 103   if (inst->opcode->iclass == asisdone || inst->opcode->iclass == asimdins)
 104     {
 105       int pos = info->qualifier - AARCH64_OPND_QLF_S_B;
 106       if (info->type == AARCH64_OPND_En
 107           && inst->opcode->operands[0] == AARCH64_OPND_Ed)
 108         {
 109           /* index2 for e.g. INS <Vd>.<Ts>[<index1>], <Vn>.<Ts>[<index2>].  */
 110           assert (info->idx == 1);      /* Vn */
 111           aarch64_insn value = info->reglane.index << pos;
 112           insert_field (FLD_imm4, code, value, 0);
 113         }
 114       else
 115         {
 116           /* index and type for e.g. DUP <V><d>, <Vn>.<T>[<index>].
 117              imm5<3:0>  <V>
 118              0000       RESERVED
 119              xxx1       B
 120              xx10       H
 121              x100       S
 122              1000       D  */
 123           aarch64_insn value = ((info->reglane.index << 1) | 1) << pos;
 124           insert_field (FLD_imm5, code, value, 0);
 125         }
 126     }
 127   else if (inst->opcode->iclass == dotproduct)
 128     {
 129       unsigned reglane_index = info->reglane.index;
 130       switch (info->qualifier)
 131         {
 132         case AARCH64_OPND_QLF_S_4B:
 133           /* L:H */
 134           assert (reglane_index < 4);
 135           insert_fields (code, reglane_index, 0, 2, FLD_L, FLD_H);
 136           break;
 137         default:
 138           assert (0);
 139         }
 140     }
 141   else if (inst->opcode->iclass == cryptosm3)
 142     {
 143       /* index for e.g. SM3TT2A <Vd>.4S, <Vn>.4S, <Vm>S[<imm2>].  */
 144       unsigned reglane_index = info->reglane.index;
 145       assert (reglane_index < 4);
 146       insert_field (FLD_SM3_imm2, code, reglane_index, 0);
 147     }
 148   else
 149     {
 150       /* index for e.g. SQDMLAL <Va><d>, <Vb><n>, <Vm>.<Ts>[<index>]
 151          or SQDMLAL <Va><d>, <Vb><n>, <Vm>.<Ts>[<index>].  */
 152       unsigned reglane_index = info->reglane.index;
 153
 154       if (inst->opcode->op == OP_FCMLA_ELEM)
 155         /* Complex operand takes two elements.  */
 156         reglane_index *= 2;
 157
 158       switch (info->qualifier)
 159         {
 160         case AARCH64_OPND_QLF_S_H:
 161           /* H:L:M */
 162           assert (reglane_index < 8);
 163           insert_fields (code, reglane_index, 0, 3, FLD_M, FLD_L, FLD_H);
 164           break;
 165         case AARCH64_OPND_QLF_S_S:
 166           /* H:L */
 167           assert (reglane_index < 4);
 168           insert_fields (code, reglane_index, 0, 2, FLD_L, FLD_H);
 169           break;
 170         case AARCH64_OPND_QLF_S_D:
 171           /* H */
 172           assert (reglane_index < 2);
 173           insert_field (FLD_H, code, reglane_index, 0);
 174           break;
 175         default:
 176           assert (0);
 177         }
 178     }
 179   return TRUE;
 180 }
 181
 182 /* Insert regno and len field of a register list operand, e.g. Vn in TBL.  */
 183 bfd_boolean
 184 aarch64_ins_reglist (const aarch64_operand *self, const aarch64_opnd_info *info,
 185                      aarch64_insn *code,
 186                      const aarch64_inst *inst ATTRIBUTE_UNUSED,
 187                      aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 188 {
 189   /* R */
 190   insert_field (self->fields[0], code, info->reglist.first_regno, 0);
 191   /* len */
 192   insert_field (FLD_len, code, info->reglist.num_regs - 1, 0);
 193   return TRUE;
 194 }
 195
 196 /* Insert Rt and opcode fields for a register list operand, e.g. Vt
 197    in AdvSIMD load/store instructions.  */
 198 bfd_boolean
 199 aarch64_ins_ldst_reglist (const aarch64_operand *self ATTRIBUTE_UNUSED,
 200                           const aarch64_opnd_info *info, aarch64_insn *code,
 201                           const aarch64_inst *inst,
 202                           aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 203 {
 204   aarch64_insn value = 0;
 205   /* Number of elements in each structure to be loaded/stored.  */
 206   unsigned num = get_opcode_dependent_value (inst->opcode);
 207
 208   /* Rt */
 209   insert_field (FLD_Rt, code, info->reglist.first_regno, 0);
 210   /* opcode */
 211   switch (num)
 212     {
 213     case 1:
 214       switch (info->reglist.num_regs)
 215         {
 216         case 1: value = 0x7; break;
 217         case 2: value = 0xa; break;
 218         case 3: value = 0x6; break;
 219         case 4: value = 0x2; break;
 220         default: assert (0);
 221         }
 222       break;
 223     case 2:
 224       value = info->reglist.num_regs == 4 ? 0x3 : 0x8;
 225       break;
 226     case 3:
 227       value = 0x4;
 228       break;
 229     case 4:
 230       value = 0x0;
 231       break;
 232     default:
 233       assert (0);
 234     }
 235   insert_field (FLD_opcode, code, value, 0);
 236
 237   return TRUE;
 238 }
 239
 240 /* Insert Rt and S fields for a register list operand, e.g. Vt in AdvSIMD load
 241    single structure to all lanes instructions.  */
 242 bfd_boolean
 243 aarch64_ins_ldst_reglist_r (const aarch64_operand *self ATTRIBUTE_UNUSED,
 244                             const aarch64_opnd_info *info, aarch64_insn *code,
 245                             const aarch64_inst *inst,
 246                             aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 247 {
 248   aarch64_insn value;
 249   /* The opcode dependent area stores the number of elements in
 250      each structure to be loaded/stored.  */
 251   int is_ld1r = get_opcode_dependent_value (inst->opcode) == 1;
 252
 253   /* Rt */
 254   insert_field (FLD_Rt, code, info->reglist.first_regno, 0);
 255   /* S */
 256   value = (aarch64_insn) 0;
 257   if (is_ld1r && info->reglist.num_regs == 2)
 258     /* OP_LD1R does not have alternating variant, but have "two consecutive"
 259        instead.  */
 260     value = (aarch64_insn) 1;
 261   insert_field (FLD_S, code, value, 0);
 262
 263   return TRUE;
 264 }
 265
 266 /* Insert Q, opcode<2:1>, S, size and Rt fields for a register element list
 267    operand e.g. Vt in AdvSIMD load/store single element instructions.  */
 268 bfd_boolean
 269 aarch64_ins_ldst_elemlist (const aarch64_operand *self ATTRIBUTE_UNUSED,
 270                            const aarch64_opnd_info *info, aarch64_insn *code,
 271                            const aarch64_inst *inst ATTRIBUTE_UNUSED,
 272                            aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 273 {
 274   aarch64_field field = {0, 0};
 275   aarch64_insn QSsize = 0;      /* fields Q:S:size.  */
 276   aarch64_insn opcodeh2 = 0;    /* opcode<2:1> */
 277
 278   assert (info->reglist.has_index);
 279
 280   /* Rt */
 281   insert_field (FLD_Rt, code, info->reglist.first_regno, 0);
 282   /* Encode the index, opcode<2:1> and size.  */
 283   switch (info->qualifier)
 284     {
 285     case AARCH64_OPND_QLF_S_B:
 286       /* Index encoded in "Q:S:size".  */
 287       QSsize = info->reglist.index;
 288       opcodeh2 = 0x0;
 289       break;
 290     case AARCH64_OPND_QLF_S_H:
 291       /* Index encoded in "Q:S:size<1>".  */
 292       QSsize = info->reglist.index << 1;
 293       opcodeh2 = 0x1;
 294       break;
 295     case AARCH64_OPND_QLF_S_S:
 296       /* Index encoded in "Q:S".  */
 297       QSsize = info->reglist.index << 2;
 298       opcodeh2 = 0x2;
 299       break;
 300     case AARCH64_OPND_QLF_S_D:
 301       /* Index encoded in "Q".  */
 302       QSsize = info->reglist.index << 3 | 0x1;
 303       opcodeh2 = 0x2;
 304       break;
 305     default:
 306       assert (0);
 307     }
 308   insert_fields (code, QSsize, 0, 3, FLD_vldst_size, FLD_S, FLD_Q);
 309   gen_sub_field (FLD_asisdlso_opcode, 1, 2, &field);
 310   insert_field_2 (&field, code, opcodeh2, 0);
 311
 312   return TRUE;
 313 }
 314
 315 /* Insert fields immh:immb and/or Q for e.g. the shift immediate in
 316    SSHR <Vd>.<T>, <Vn>.<T>, #<shift>
 317    or SSHR <V><d>, <V><n>, #<shift>.  */
 318 bfd_boolean
 319 aarch64_ins_advsimd_imm_shift (const aarch64_operand *self ATTRIBUTE_UNUSED,
 320                                const aarch64_opnd_info *info,
 321                                aarch64_insn *code, const aarch64_inst *inst,
 322                                aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 323 {
 324   unsigned val = aarch64_get_qualifier_standard_value (info->qualifier);
 325   aarch64_insn Q, imm;
 326
 327   if (inst->opcode->iclass == asimdshf)
 328     {
 329       /* Q
 330          immh   Q       <T>
 331          0000   x       SEE AdvSIMD modified immediate
 332          0001   0       8B
 333          0001   1       16B
 334          001x   0       4H
 335          001x   1       8H
 336          01xx   0       2S
 337          01xx   1       4S
 338          1xxx   0       RESERVED
 339          1xxx   1       2D  */
 340       Q = (val & 0x1) ? 1 : 0;
 341       insert_field (FLD_Q, code, Q, inst->opcode->mask);
 342       val >>= 1;
 343     }
 344
 345   assert (info->type == AARCH64_OPND_IMM_VLSR
 346           || info->type == AARCH64_OPND_IMM_VLSL);
 347
 348   if (info->type == AARCH64_OPND_IMM_VLSR)
 349     /* immh:immb
 350        immh     <shift>
 351        0000     SEE AdvSIMD modified immediate
 352        0001     (16-UInt(immh:immb))
 353        001x     (32-UInt(immh:immb))
 354        01xx     (64-UInt(immh:immb))
 355        1xxx     (128-UInt(immh:immb))  */
 356     imm = (16 << (unsigned)val) - info->imm.value;
 357   else
 358     /* immh:immb
 359        immh     <shift>
 360        0000     SEE AdvSIMD modified immediate
 361        0001     (UInt(immh:immb)-8)
 362        001x     (UInt(immh:immb)-16)
 363        01xx     (UInt(immh:immb)-32)
 364        1xxx     (UInt(immh:immb)-64)  */
 365     imm = info->imm.value + (8 << (unsigned)val);
 366   insert_fields (code, imm, 0, 2, FLD_immb, FLD_immh);
 367
 368   return TRUE;
 369 }
 370
 371 /* Insert fields for e.g. the immediate operands in
 372    BFM <Wd>, <Wn>, #<immr>, #<imms>.  */
 373 bfd_boolean
 374 aarch64_ins_imm (const aarch64_operand *self, const aarch64_opnd_info *info,
 375                  aarch64_insn *code,
 376                  const aarch64_inst *inst ATTRIBUTE_UNUSED,
 377                  aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 378 {
 379   int64_t imm;
 380
 381   imm = info->imm.value;
 382   if (operand_need_shift_by_two (self))
 383     imm >>= 2;
 384   if (operand_need_shift_by_four (self))
 385     imm >>= 4;
 386   insert_all_fields (self, code, imm);
 387   return TRUE;
 388 }
 389
 390 /* Insert immediate and its shift amount for e.g. the last operand in
 391      MOVZ <Wd>, #<imm16>{, LSL #<shift>}.  */
 392 bfd_boolean
 393 aarch64_ins_imm_half (const aarch64_operand *self, const aarch64_opnd_info *info,
 394                       aarch64_insn *code, const aarch64_inst *inst,
 395                       aarch64_operand_error *errors)
 396 {
 397   /* imm16 */
 398   aarch64_ins_imm (self, info, code, inst, errors);
 399   /* hw */
 400   insert_field (FLD_hw, code, info->shifter.amount >> 4, 0);
 401   return TRUE;
 402 }
 403
 404 /* Insert cmode and "a:b:c:d:e:f:g:h" fields for e.g. the last operand in
 405      MOVI <Vd>.<T>, #<imm8> {, LSL #<amount>}.  */
 406 bfd_boolean
 407 aarch64_ins_advsimd_imm_modified (const aarch64_operand *self ATTRIBUTE_UNUSED,
 408                                   const aarch64_opnd_info *info,
 409                                   aarch64_insn *code,
 410                                   const aarch64_inst *inst ATTRIBUTE_UNUSED,
 411                                   aarch64_operand_error *errors
 412                                         ATTRIBUTE_UNUSED)
 413 {
 414   enum aarch64_opnd_qualifier opnd0_qualifier = inst->operands[0].qualifier;
 415   uint64_t imm = info->imm.value;
 416   enum aarch64_modifier_kind kind = info->shifter.kind;
 417   int amount = info->shifter.amount;
 418   aarch64_field field = {0, 0};
 419
 420   /* a:b:c:d:e:f:g:h */
 421   if (!info->imm.is_fp && aarch64_get_qualifier_esize (opnd0_qualifier) == 8)
 422     {
 423       /* Either MOVI <Dd>, #<imm>
 424          or     MOVI <Vd>.2D, #<imm>.
 425          <imm> is a 64-bit immediate
 426          "aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffgggggggghhhhhhhh",
 427          encoded in "a:b:c:d:e:f:g:h".  */
 428       imm = aarch64_shrink_expanded_imm8 (imm);
 429       assert ((int)imm >= 0);
 430     }
 431   insert_fields (code, imm, 0, 2, FLD_defgh, FLD_abc);
 432
 433   if (kind == AARCH64_MOD_NONE)
 434     return TRUE;
 435
 436   /* shift amount partially in cmode */
 437   assert (kind == AARCH64_MOD_LSL || kind == AARCH64_MOD_MSL);
 438   if (kind == AARCH64_MOD_LSL)
 439     {
 440       /* AARCH64_MOD_LSL: shift zeros.  */
 441       int esize = aarch64_get_qualifier_esize (opnd0_qualifier);
 442       assert (esize == 4 || esize == 2 || esize == 1);
 443       /* For 8-bit move immediate, the optional LSL #0 does not require
 444          encoding.  */
 445       if (esize == 1)
 446         return TRUE;
 447       amount >>= 3;
 448       if (esize == 4)
 449         gen_sub_field (FLD_cmode, 1, 2, &field);        /* per word */
 450       else
 451         gen_sub_field (FLD_cmode, 1, 1, &field);        /* per halfword */
 452     }
 453   else
 454     {
 455       /* AARCH64_MOD_MSL: shift ones.  */
 456       amount >>= 4;
 457       gen_sub_field (FLD_cmode, 0, 1, &field);          /* per word */
 458     }
 459   insert_field_2 (&field, code, amount, 0);
 460
 461   return TRUE;
 462 }
 463
 464 /* Insert fields for an 8-bit floating-point immediate.  */
 465 bfd_boolean
 466 aarch64_ins_fpimm (const aarch64_operand *self, const aarch64_opnd_info *info,
 467                    aarch64_insn *code,
 468                    const aarch64_inst *inst ATTRIBUTE_UNUSED,
 469                    aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 470 {
 471   insert_all_fields (self, code, info->imm.value);
 472   return TRUE;
 473 }
 474
 475 /* Insert 1-bit rotation immediate (#90 or #270).  */
 476 bfd_boolean
 477 aarch64_ins_imm_rotate1 (const aarch64_operand *self,
 478                          const aarch64_opnd_info *info,
 479                          aarch64_insn *code, const aarch64_inst *inst,
 480                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 481 {
 482   uint64_t rot = (info->imm.value - 90) / 180;
 483   assert (rot < 2U);
 484   insert_field (self->fields[0], code, rot, inst->opcode->mask);
 485   return TRUE;
 486 }
 487
 488 /* Insert 2-bit rotation immediate (#0, #90, #180 or #270).  */
 489 bfd_boolean
 490 aarch64_ins_imm_rotate2 (const aarch64_operand *self,
 491                          const aarch64_opnd_info *info,
 492                          aarch64_insn *code, const aarch64_inst *inst,
 493                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 494 {
 495   uint64_t rot = info->imm.value / 90;
 496   assert (rot < 4U);
 497   insert_field (self->fields[0], code, rot, inst->opcode->mask);
 498   return TRUE;
 499 }
 500
 501 /* Insert #<fbits> for the immediate operand in fp fix-point instructions,
 502    e.g.  SCVTF <Dd>, <Wn>, #<fbits>.  */
 503 bfd_boolean
 504 aarch64_ins_fbits (const aarch64_operand *self, const aarch64_opnd_info *info,
 505                    aarch64_insn *code,
 506                    const aarch64_inst *inst ATTRIBUTE_UNUSED,
 507                    aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 508 {
 509   insert_field (self->fields[0], code, 64 - info->imm.value, 0);
 510   return TRUE;
 511 }
 512
 513 /* Insert arithmetic immediate for e.g. the last operand in
 514      SUBS <Wd>, <Wn|WSP>, #<imm> {, <shift>}.  */
 515 bfd_boolean
 516 aarch64_ins_aimm (const aarch64_operand *self, const aarch64_opnd_info *info,
 517                   aarch64_insn *code, const aarch64_inst *inst ATTRIBUTE_UNUSED,
 518                   aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 519 {
 520   /* shift */
 521   aarch64_insn value = info->shifter.amount ? 1 : 0;
 522   insert_field (self->fields[0], code, value, 0);
 523   /* imm12 (unsigned) */
 524   insert_field (self->fields[1], code, info->imm.value, 0);
 525   return TRUE;
 526 }
 527
 528 /* Common routine shared by aarch64_ins{,_inv}_limm.  INVERT_P says whether
 529    the operand should be inverted before encoding.  */
 530 static bfd_boolean
 531 aarch64_ins_limm_1 (const aarch64_operand *self,
 532                     const aarch64_opnd_info *info, aarch64_insn *code,
 533                     const aarch64_inst *inst, bfd_boolean invert_p,
 534                     aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 535 {
 536   aarch64_insn value;
 537   uint64_t imm = info->imm.value;
 538   int esize = aarch64_get_qualifier_esize (inst->operands[0].qualifier);
 539
 540   if (invert_p)
 541     imm = ~imm;
 542   /* The constraint check should have guaranteed this wouldn't happen.  */
 543   assert (aarch64_logical_immediate_p (imm, esize, &value));
 544
 545   insert_fields (code, value, 0, 3, self->fields[2], self->fields[1],
 546                  self->fields[0]);
 547   return TRUE;
 548 }
 549
 550 /* Insert logical/bitmask immediate for e.g. the last operand in
 551      ORR <Wd|WSP>, <Wn>, #<imm>.  */
 552 bfd_boolean
 553 aarch64_ins_limm (const aarch64_operand *self, const aarch64_opnd_info *info,
 554                   aarch64_insn *code, const aarch64_inst *inst,
 555                   aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 556 {
 557   return aarch64_ins_limm_1 (self, info, code, inst,
 558                              inst->opcode->op == OP_BIC, errors);
 559 }
 560
 561 /* Insert a logical/bitmask immediate for the BIC alias of AND (etc.).  */
 562 bfd_boolean
 563 aarch64_ins_inv_limm (const aarch64_operand *self,
 564                       const aarch64_opnd_info *info, aarch64_insn *code,
 565                       const aarch64_inst *inst,
 566                       aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 567 {
 568   return aarch64_ins_limm_1 (self, info, code, inst, TRUE, errors);
 569 }
 570
 571 /* Encode Ft for e.g. STR <Qt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}]
 572    or LDP <Qt1>, <Qt2>, [<Xn|SP>], #<imm>.  */
 573 bfd_boolean
 574 aarch64_ins_ft (const aarch64_operand *self, const aarch64_opnd_info *info,
 575                 aarch64_insn *code, const aarch64_inst *inst,
 576                 aarch64_operand_error *errors)
 577 {
 578   aarch64_insn value = 0;
 579
 580   assert (info->idx == 0);
 581
 582   /* Rt */
 583   aarch64_ins_regno (self, info, code, inst, errors);
 584   if (inst->opcode->iclass == ldstpair_indexed
 585       || inst->opcode->iclass == ldstnapair_offs
 586       || inst->opcode->iclass == ldstpair_off
 587       || inst->opcode->iclass == loadlit)
 588     {
 589       /* size */
 590       switch (info->qualifier)
 591         {
 592         case AARCH64_OPND_QLF_S_S: value = 0; break;
 593         case AARCH64_OPND_QLF_S_D: value = 1; break;
 594         case AARCH64_OPND_QLF_S_Q: value = 2; break;
 595         default: assert (0);
 596         }
 597       insert_field (FLD_ldst_size, code, value, 0);
 598     }
 599   else
 600     {
 601       /* opc[1]:size */
 602       value = aarch64_get_qualifier_standard_value (info->qualifier);
 603       insert_fields (code, value, 0, 2, FLD_ldst_size, FLD_opc1);
 604     }
 605
 606   return TRUE;
 607 }
 608
 609 /* Encode the address operand for e.g. STXRB <Ws>, <Wt>, [<Xn|SP>{,#0}].  */
 610 bfd_boolean
 611 aarch64_ins_addr_simple (const aarch64_operand *self ATTRIBUTE_UNUSED,
 612                          const aarch64_opnd_info *info, aarch64_insn *code,
 613                          const aarch64_inst *inst ATTRIBUTE_UNUSED,
 614                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 615 {
 616   /* Rn */
 617   insert_field (FLD_Rn, code, info->addr.base_regno, 0);
 618   return TRUE;
 619 }
 620
 621 /* Encode the address operand for e.g.
 622      STR <Qt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}].  */
 623 bfd_boolean
 624 aarch64_ins_addr_regoff (const aarch64_operand *self ATTRIBUTE_UNUSED,
 625                          const aarch64_opnd_info *info, aarch64_insn *code,
 626                          const aarch64_inst *inst ATTRIBUTE_UNUSED,
 627                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 628 {
 629   aarch64_insn S;
 630   enum aarch64_modifier_kind kind = info->shifter.kind;
 631
 632   /* Rn */
 633   insert_field (FLD_Rn, code, info->addr.base_regno, 0);
 634   /* Rm */
 635   insert_field (FLD_Rm, code, info->addr.offset.regno, 0);
 636   /* option */
 637   if (kind == AARCH64_MOD_LSL)
 638     kind = AARCH64_MOD_UXTX;    /* Trick to enable the table-driven.  */
 639   insert_field (FLD_option, code, aarch64_get_operand_modifier_value (kind), 0);
 640   /* S */
 641   if (info->qualifier != AARCH64_OPND_QLF_S_B)
 642     S = info->shifter.amount != 0;
 643   else
 644     /* For STR <Bt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}},
 645        S        <amount>
 646        0        [absent]
 647        1        #0
 648        Must be #0 if <extend> is explicitly LSL.  */
 649     S = info->shifter.operator_present && info->shifter.amount_present;
 650   insert_field (FLD_S, code, S, 0);
 651
 652   return TRUE;
 653 }
 654
 655 /* Encode the address operand for e.g.
 656      stlur <Xt>, [<Xn|SP>{, <amount>}].  */
 657 bfd_boolean
 658 aarch64_ins_addr_offset (const aarch64_operand *self ATTRIBUTE_UNUSED,
 659                          const aarch64_opnd_info *info, aarch64_insn *code,
 660                          const aarch64_inst *inst ATTRIBUTE_UNUSED,
 661                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 662 {
 663   /* Rn */
 664   insert_field (self->fields[0], code, info->addr.base_regno, 0);
 665
 666   /* simm9 */
 667   int imm = info->addr.offset.imm;
 668   insert_field (self->fields[1], code, imm, 0);
 669
 670   /* writeback */
 671   if (info->addr.writeback)
 672     {
 673       assert (info->addr.preind == 1 && info->addr.postind == 0);
 674       insert_field (self->fields[2], code, 1, 0);
 675     }
 676   return TRUE;
 677 }
 678
 679 /* Encode the address operand for e.g. LDRSW <Xt>, [<Xn|SP>, #<simm>]!.  */
 680 bfd_boolean
 681 aarch64_ins_addr_simm (const aarch64_operand *self,
 682                        const aarch64_opnd_info *info,
 683                        aarch64_insn *code,
 684                        const aarch64_inst *inst ATTRIBUTE_UNUSED,
 685                        aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 686 {
 687   int imm;
 688
 689   /* Rn */
 690   insert_field (FLD_Rn, code, info->addr.base_regno, 0);
 691   /* simm (imm9 or imm7) */
 692   imm = info->addr.offset.imm;
 693   if (self->fields[0] == FLD_imm7
 694      || info->qualifier == AARCH64_OPND_QLF_imm_tag)
 695     /* scaled immediate in ld/st pair instructions..  */
 696     imm >>= get_logsz (aarch64_get_qualifier_esize (info->qualifier));
 697   insert_field (self->fields[0], code, imm, 0);
 698   /* pre/post- index */
 699   if (info->addr.writeback)
 700     {
 701       assert (inst->opcode->iclass != ldst_unscaled
 702               && inst->opcode->iclass != ldstnapair_offs
 703               && inst->opcode->iclass != ldstpair_off
 704               && inst->opcode->iclass != ldst_unpriv);
 705       assert (info->addr.preind != info->addr.postind);
 706       if (info->addr.preind)
 707         insert_field (self->fields[1], code, 1, 0);
 708     }
 709
 710   return TRUE;
 711 }
 712
 713 /* Encode the address operand for e.g. LDRAA <Xt>, [<Xn|SP>{, #<simm>}].  */
 714 bfd_boolean
 715 aarch64_ins_addr_simm10 (const aarch64_operand *self,
 716                          const aarch64_opnd_info *info,
 717                          aarch64_insn *code,
 718                          const aarch64_inst *inst ATTRIBUTE_UNUSED,
 719                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 720 {
 721   int imm;
 722
 723   /* Rn */
 724   insert_field (self->fields[0], code, info->addr.base_regno, 0);
 725   /* simm10 */
 726   imm = info->addr.offset.imm >> 3;
 727   insert_field (self->fields[1], code, imm >> 9, 0);
 728   insert_field (self->fields[2], code, imm, 0);
 729   /* writeback */
 730   if (info->addr.writeback)
 731     {
 732       assert (info->addr.preind == 1 && info->addr.postind == 0);
 733       insert_field (self->fields[3], code, 1, 0);
 734     }
 735   return TRUE;
 736 }
 737
 738 /* Encode the address operand for e.g. LDRSW <Xt>, [<Xn|SP>{, #<pimm>}].  */
 739 bfd_boolean
 740 aarch64_ins_addr_uimm12 (const aarch64_operand *self,
 741                          const aarch64_opnd_info *info,
 742                          aarch64_insn *code,
 743                          const aarch64_inst *inst ATTRIBUTE_UNUSED,
 744                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 745 {
 746   int shift = get_logsz (aarch64_get_qualifier_esize (info->qualifier));
 747
 748   /* Rn */
 749   insert_field (self->fields[0], code, info->addr.base_regno, 0);
 750   /* uimm12 */
 751   insert_field (self->fields[1], code,info->addr.offset.imm >> shift, 0);
 752   return TRUE;
 753 }
 754
 755 /* Encode the address operand for e.g.
 756      LD1 {<Vt>.<T>, <Vt2>.<T>, <Vt3>.<T>}, [<Xn|SP>], <Xm|#<amount>>.  */
 757 bfd_boolean
 758 aarch64_ins_simd_addr_post (const aarch64_operand *self ATTRIBUTE_UNUSED,
 759                             const aarch64_opnd_info *info, aarch64_insn *code,
 760                             const aarch64_inst *inst ATTRIBUTE_UNUSED,
 761                             aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 762 {
 763   /* Rn */
 764   insert_field (FLD_Rn, code, info->addr.base_regno, 0);
 765   /* Rm | #<amount>  */
 766   if (info->addr.offset.is_reg)
 767     insert_field (FLD_Rm, code, info->addr.offset.regno, 0);
 768   else
 769     insert_field (FLD_Rm, code, 0x1f, 0);
 770   return TRUE;
 771 }
 772
 773 /* Encode the condition operand for e.g. CSEL <Xd>, <Xn>, <Xm>, <cond>.  */
 774 bfd_boolean
 775 aarch64_ins_cond (const aarch64_operand *self ATTRIBUTE_UNUSED,
 776                   const aarch64_opnd_info *info, aarch64_insn *code,
 777                   const aarch64_inst *inst ATTRIBUTE_UNUSED,
 778                   aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 779 {
 780   /* cond */
 781   insert_field (FLD_cond, code, info->cond->value, 0);
 782   return TRUE;
 783 }
 784
 785 /* Encode the system register operand for e.g. MRS <Xt>, <systemreg>.  */
 786 bfd_boolean
 787 aarch64_ins_sysreg (const aarch64_operand *self ATTRIBUTE_UNUSED,
 788                     const aarch64_opnd_info *info, aarch64_insn *code,
 789                     const aarch64_inst *inst,
 790                     aarch64_operand_error *detail ATTRIBUTE_UNUSED)
 791 {
 792    /* If a system instruction check if we have any restrictions on which
 793       registers it can use.  */
 794    if (inst->opcode->iclass == ic_system)
 795      {
 796         uint64_t opcode_flags
 797           = inst->opcode->flags & (F_SYS_READ | F_SYS_WRITE);
 798         uint32_t sysreg_flags
 799           = info->sysreg.flags & (F_REG_READ | F_REG_WRITE);
 800
 801         /* Check to see if it's read-only, else check if it's write only.
 802            if it's both or unspecified don't care.  */
 803         if (opcode_flags == F_SYS_READ
 804             && sysreg_flags
 805             && sysreg_flags != F_REG_READ)
 806           {
 807                 detail->kind = AARCH64_OPDE_SYNTAX_ERROR;
 808                 detail->error = _("specified register cannot be read from");
 809                 detail->index = info->idx;
 810                 detail->non_fatal = TRUE;
 811           }
 812         else if (opcode_flags == F_SYS_WRITE
 813                  && sysreg_flags
 814                  && sysreg_flags != F_REG_WRITE)
 815           {
 816                 detail->kind = AARCH64_OPDE_SYNTAX_ERROR;
 817                 detail->error = _("specified register cannot be written to");
 818                 detail->index = info->idx;
 819                 detail->non_fatal = TRUE;
 820           }
 821      }
 822   /* op0:op1:CRn:CRm:op2 */
 823   insert_fields (code, info->sysreg.value, inst->opcode->mask, 5,
 824                  FLD_op2, FLD_CRm, FLD_CRn, FLD_op1, FLD_op0);
 825   return TRUE;
 826 }
 827
 828 /* Encode the PSTATE field operand for e.g. MSR <pstatefield>, #<imm>.  */
 829 bfd_boolean
 830 aarch64_ins_pstatefield (const aarch64_operand *self ATTRIBUTE_UNUSED,
 831                          const aarch64_opnd_info *info, aarch64_insn *code,
 832                          const aarch64_inst *inst ATTRIBUTE_UNUSED,
 833                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 834 {
 835   /* op1:op2 */
 836   insert_fields (code, info->pstatefield, inst->opcode->mask, 2,
 837                  FLD_op2, FLD_op1);
 838   return TRUE;
 839 }
 840
 841 /* Encode the system instruction op operand for e.g. AT <at_op>, <Xt>.  */
 842 bfd_boolean
 843 aarch64_ins_sysins_op (const aarch64_operand *self ATTRIBUTE_UNUSED,
 844                        const aarch64_opnd_info *info, aarch64_insn *code,
 845                        const aarch64_inst *inst ATTRIBUTE_UNUSED,
 846                        aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 847 {
 848   /* op1:CRn:CRm:op2 */
 849   insert_fields (code, info->sysins_op->value, inst->opcode->mask, 4,
 850                  FLD_op2, FLD_CRm, FLD_CRn, FLD_op1);
 851   return TRUE;
 852 }
 853
 854 /* Encode the memory barrier option operand for e.g. DMB <option>|#<imm>.  */
 855
 856 bfd_boolean
 857 aarch64_ins_barrier (const aarch64_operand *self ATTRIBUTE_UNUSED,
 858                      const aarch64_opnd_info *info, aarch64_insn *code,
 859                      const aarch64_inst *inst ATTRIBUTE_UNUSED,
 860                      aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 861 {
 862   /* CRm */
 863   insert_field (FLD_CRm, code, info->barrier->value, 0);
 864   return TRUE;
 865 }
 866
 867 /* Encode the prefetch operation option operand for e.g.
 868      PRFM <prfop>, [<Xn|SP>{, #<pimm>}].  */
 869
 870 bfd_boolean
 871 aarch64_ins_prfop (const aarch64_operand *self ATTRIBUTE_UNUSED,
 872                    const aarch64_opnd_info *info, aarch64_insn *code,
 873                    const aarch64_inst *inst ATTRIBUTE_UNUSED,
 874                    aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 875 {
 876   /* prfop in Rt */
 877   insert_field (FLD_Rt, code, info->prfop->value, 0);
 878   return TRUE;
 879 }
 880
 881 /* Encode the hint number for instructions that alias HINT but take an
 882    operand.  */
 883
 884 bfd_boolean
 885 aarch64_ins_hint (const aarch64_operand *self ATTRIBUTE_UNUSED,
 886                   const aarch64_opnd_info *info, aarch64_insn *code,
 887                   const aarch64_inst *inst ATTRIBUTE_UNUSED,
 888                   aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 889 {
 890   /* CRm:op2.  */
 891   insert_fields (code, info->hint_option->value, 0, 2, FLD_op2, FLD_CRm);
 892   return TRUE;
 893 }
 894
 895 /* Encode the extended register operand for e.g.
 896      STR <Qt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}].  */
 897 bfd_boolean
 898 aarch64_ins_reg_extended (const aarch64_operand *self ATTRIBUTE_UNUSED,
 899                           const aarch64_opnd_info *info, aarch64_insn *code,
 900                           const aarch64_inst *inst ATTRIBUTE_UNUSED,
 901                           aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 902 {
 903   enum aarch64_modifier_kind kind;
 904
 905   /* Rm */
 906   insert_field (FLD_Rm, code, info->reg.regno, 0);
 907   /* option */
 908   kind = info->shifter.kind;
 909   if (kind == AARCH64_MOD_LSL)
 910     kind = info->qualifier == AARCH64_OPND_QLF_W
 911       ? AARCH64_MOD_UXTW : AARCH64_MOD_UXTX;
 912   insert_field (FLD_option, code, aarch64_get_operand_modifier_value (kind), 0);
 913   /* imm3 */
 914   insert_field (FLD_imm3, code, info->shifter.amount, 0);
 915
 916   return TRUE;
 917 }
 918
 919 /* Encode the shifted register operand for e.g.
 920      SUBS <Xd>, <Xn>, <Xm> {, <shift> #<amount>}.  */
 921 bfd_boolean
 922 aarch64_ins_reg_shifted (const aarch64_operand *self ATTRIBUTE_UNUSED,
 923                          const aarch64_opnd_info *info, aarch64_insn *code,
 924                          const aarch64_inst *inst ATTRIBUTE_UNUSED,
 925                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 926 {
 927   /* Rm */
 928   insert_field (FLD_Rm, code, info->reg.regno, 0);
 929   /* shift */
 930   insert_field (FLD_shift, code,
 931                 aarch64_get_operand_modifier_value (info->shifter.kind), 0);
 932   /* imm6 */
 933   insert_field (FLD_imm6, code, info->shifter.amount, 0);
 934
 935   return TRUE;
 936 }
 937
 938 /* Encode an SVE address [<base>, #<simm4>*<factor>, MUL VL],
 939    where <simm4> is a 4-bit signed value and where <factor> is 1 plus
 940    SELF's operand-dependent value.  fields[0] specifies the field that
 941    holds <base>.  <simm4> is encoded in the SVE_imm4 field.  */
 942 bfd_boolean
 943 aarch64_ins_sve_addr_ri_s4xvl (const aarch64_operand *self,
 944                                const aarch64_opnd_info *info,
 945                                aarch64_insn *code,
 946                                const aarch64_inst *inst ATTRIBUTE_UNUSED,
 947                                aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 948 {
 949   int factor = 1 + get_operand_specific_data (self);
 950   insert_field (self->fields[0], code, info->addr.base_regno, 0);
 951   insert_field (FLD_SVE_imm4, code, info->addr.offset.imm / factor, 0);
 952   return TRUE;
 953 }
 954
 955 /* Encode an SVE address [<base>, #<simm6>*<factor>, MUL VL],
 956    where <simm6> is a 6-bit signed value and where <factor> is 1 plus
 957    SELF's operand-dependent value.  fields[0] specifies the field that
 958    holds <base>.  <simm6> is encoded in the SVE_imm6 field.  */
 959 bfd_boolean
 960 aarch64_ins_sve_addr_ri_s6xvl (const aarch64_operand *self,
 961                                const aarch64_opnd_info *info,
 962                                aarch64_insn *code,
 963                                const aarch64_inst *inst ATTRIBUTE_UNUSED,
 964                                aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 965 {
 966   int factor = 1 + get_operand_specific_data (self);
 967   insert_field (self->fields[0], code, info->addr.base_regno, 0);
 968   insert_field (FLD_SVE_imm6, code, info->addr.offset.imm / factor, 0);
 969   return TRUE;
 970 }
 971
 972 /* Encode an SVE address [<base>, #<simm9>*<factor>, MUL VL],
 973    where <simm9> is a 9-bit signed value and where <factor> is 1 plus
 974    SELF's operand-dependent value.  fields[0] specifies the field that
 975    holds <base>.  <simm9> is encoded in the concatenation of the SVE_imm6
 976    and imm3 fields, with imm3 being the less-significant part.  */
 977 bfd_boolean
 978 aarch64_ins_sve_addr_ri_s9xvl (const aarch64_operand *self,
 979                                const aarch64_opnd_info *info,
 980                                aarch64_insn *code,
 981                                const aarch64_inst *inst ATTRIBUTE_UNUSED,
 982                                aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 983 {
 984   int factor = 1 + get_operand_specific_data (self);
 985   insert_field (self->fields[0], code, info->addr.base_regno, 0);
 986   insert_fields (code, info->addr.offset.imm / factor, 0,
 987                  2, FLD_imm3, FLD_SVE_imm6);
 988   return TRUE;
 989 }
 990
 991 /* Encode an SVE address [X<n>, #<SVE_imm4> << <shift>], where <SVE_imm4>
 992    is a 4-bit signed number and where <shift> is SELF's operand-dependent
 993    value.  fields[0] specifies the base register field.  */
 994 bfd_boolean
 995 aarch64_ins_sve_addr_ri_s4 (const aarch64_operand *self,
 996                             const aarch64_opnd_info *info, aarch64_insn *code,
 997                             const aarch64_inst *inst ATTRIBUTE_UNUSED,
 998                             aarch64_operand_error *errors ATTRIBUTE_UNUSED)
 999 {
1000   int factor = 1 << get_operand_specific_data (self);
1001   insert_field (self->fields[0], code, info->addr.base_regno, 0);
1002   insert_field (FLD_SVE_imm4, code, info->addr.offset.imm / factor, 0);
1003   return TRUE;
1004 }
1005
1006 /* Encode an SVE address [X<n>, #<SVE_imm6> << <shift>], where <SVE_imm6>
1007    is a 6-bit unsigned number and where <shift> is SELF's operand-dependent
1008    value.  fields[0] specifies the base register field.  */
1009 bfd_boolean
1010 aarch64_ins_sve_addr_ri_u6 (const aarch64_operand *self,
1011                             const aarch64_opnd_info *info, aarch64_insn *code,
1012                             const aarch64_inst *inst ATTRIBUTE_UNUSED,
1013                             aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1014 {
1015   int factor = 1 << get_operand_specific_data (self);
1016   insert_field (self->fields[0], code, info->addr.base_regno, 0);
1017   insert_field (FLD_SVE_imm6, code, info->addr.offset.imm / factor, 0);
1018   return TRUE;
1019 }
1020
1021 /* Encode an SVE address [X<n>, X<m>{, LSL #<shift>}], where <shift>
1022    is SELF's operand-dependent value.  fields[0] specifies the base
1023    register field and fields[1] specifies the offset register field.  */
1024 bfd_boolean
1025 aarch64_ins_sve_addr_rr_lsl (const aarch64_operand *self,
1026                              const aarch64_opnd_info *info, aarch64_insn *code,
1027                              const aarch64_inst *inst ATTRIBUTE_UNUSED,
1028                              aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1029 {
1030   insert_field (self->fields[0], code, info->addr.base_regno, 0);
1031   insert_field (self->fields[1], code, info->addr.offset.regno, 0);
1032   return TRUE;
1033 }
1034
1035 /* Encode an SVE address [X<n>, Z<m>.<T>, (S|U)XTW {#<shift>}], where
1036    <shift> is SELF's operand-dependent value.  fields[0] specifies the
1037    base register field, fields[1] specifies the offset register field and
1038    fields[2] is a single-bit field that selects SXTW over UXTW.  */
1039 bfd_boolean
1040 aarch64_ins_sve_addr_rz_xtw (const aarch64_operand *self,
1041                              const aarch64_opnd_info *info, aarch64_insn *code,
1042                              const aarch64_inst *inst ATTRIBUTE_UNUSED,
1043                              aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1044 {
1045   insert_field (self->fields[0], code, info->addr.base_regno, 0);
1046   insert_field (self->fields[1], code, info->addr.offset.regno, 0);
1047   if (info->shifter.kind == AARCH64_MOD_UXTW)
1048     insert_field (self->fields[2], code, 0, 0);
1049   else
1050     insert_field (self->fields[2], code, 1, 0);
1051   return TRUE;
1052 }
1053
1054 /* Encode an SVE address [Z<n>.<T>, #<imm5> << <shift>], where <imm5> is a
1055    5-bit unsigned number and where <shift> is SELF's operand-dependent value.
1056    fields[0] specifies the base register field.  */
1057 bfd_boolean
1058 aarch64_ins_sve_addr_zi_u5 (const aarch64_operand *self,
1059                             const aarch64_opnd_info *info, aarch64_insn *code,
1060                             const aarch64_inst *inst ATTRIBUTE_UNUSED,
1061                             aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1062 {
1063   int factor = 1 << get_operand_specific_data (self);
1064   insert_field (self->fields[0], code, info->addr.base_regno, 0);
1065   insert_field (FLD_imm5, code, info->addr.offset.imm / factor, 0);
1066   return TRUE;
1067 }
1068
1069 /* Encode an SVE address [Z<n>.<T>, Z<m>.<T>{, <modifier> {#<msz>}}],
1070    where <modifier> is fixed by the instruction and where <msz> is a
1071    2-bit unsigned number.  fields[0] specifies the base register field
1072    and fields[1] specifies the offset register field.  */
1073 static bfd_boolean
1074 aarch64_ext_sve_addr_zz (const aarch64_operand *self,
1075                          const aarch64_opnd_info *info, aarch64_insn *code,
1076                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1077 {
1078   insert_field (self->fields[0], code, info->addr.base_regno, 0);
1079   insert_field (self->fields[1], code, info->addr.offset.regno, 0);
1080   insert_field (FLD_SVE_msz, code, info->shifter.amount, 0);
1081   return TRUE;
1082 }
1083
1084 /* Encode an SVE address [Z<n>.<T>, Z<m>.<T>{, LSL #<msz>}], where
1085    <msz> is a 2-bit unsigned number.  fields[0] specifies the base register
1086    field and fields[1] specifies the offset register field.  */
1087 bfd_boolean
1088 aarch64_ins_sve_addr_zz_lsl (const aarch64_operand *self,
1089                              const aarch64_opnd_info *info, aarch64_insn *code,
1090                              const aarch64_inst *inst ATTRIBUTE_UNUSED,
1091                              aarch64_operand_error *errors)
1092 {
1093   return aarch64_ext_sve_addr_zz (self, info, code, errors);
1094 }
1095
1096 /* Encode an SVE address [Z<n>.<T>, Z<m>.<T>, SXTW {#<msz>}], where
1097    <msz> is a 2-bit unsigned number.  fields[0] specifies the base register
1098    field and fields[1] specifies the offset register field.  */
1099 bfd_boolean
1100 aarch64_ins_sve_addr_zz_sxtw (const aarch64_operand *self,
1101                               const aarch64_opnd_info *info,
1102                               aarch64_insn *code,
1103                               const aarch64_inst *inst ATTRIBUTE_UNUSED,
1104                               aarch64_operand_error *errors)
1105 {
1106   return aarch64_ext_sve_addr_zz (self, info, code, errors);
1107 }
1108
1109 /* Encode an SVE address [Z<n>.<T>, Z<m>.<T>, UXTW {#<msz>}], where
1110    <msz> is a 2-bit unsigned number.  fields[0] specifies the base register
1111    field and fields[1] specifies the offset register field.  */
1112 bfd_boolean
1113 aarch64_ins_sve_addr_zz_uxtw (const aarch64_operand *self,
1114                               const aarch64_opnd_info *info,
1115                               aarch64_insn *code,
1116                               const aarch64_inst *inst ATTRIBUTE_UNUSED,
1117                               aarch64_operand_error *errors)
1118 {
1119   return aarch64_ext_sve_addr_zz (self, info, code, errors);
1120 }
1121
1122 /* Encode an SVE ADD/SUB immediate.  */
1123 bfd_boolean
1124 aarch64_ins_sve_aimm (const aarch64_operand *self,
1125                       const aarch64_opnd_info *info, aarch64_insn *code,
1126                       const aarch64_inst *inst ATTRIBUTE_UNUSED,
1127                       aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1128 {
1129   if (info->shifter.amount == 8)
1130     insert_all_fields (self, code, (info->imm.value & 0xff) | 256);
1131   else if (info->imm.value != 0 && (info->imm.value & 0xff) == 0)
1132     insert_all_fields (self, code, ((info->imm.value / 256) & 0xff) | 256);
1133   else
1134     insert_all_fields (self, code, info->imm.value & 0xff);
1135   return TRUE;
1136 }
1137
1138 /* Encode an SVE CPY/DUP immediate.  */
1139 bfd_boolean
1140 aarch64_ins_sve_asimm (const aarch64_operand *self,
1141                        const aarch64_opnd_info *info, aarch64_insn *code,
1142                        const aarch64_inst *inst,
1143                        aarch64_operand_error *errors)
1144 {
1145   return aarch64_ins_sve_aimm (self, info, code, inst, errors);
1146 }
1147
1148 /* Encode Zn[MM], where MM has a 7-bit triangular encoding.  The fields
1149    array specifies which field to use for Zn.  MM is encoded in the
1150    concatenation of imm5 and SVE_tszh, with imm5 being the less
1151    significant part.  */
1152 bfd_boolean
1153 aarch64_ins_sve_index (const aarch64_operand *self,
1154                        const aarch64_opnd_info *info, aarch64_insn *code,
1155                        const aarch64_inst *inst ATTRIBUTE_UNUSED,
1156                        aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1157 {
1158   unsigned int esize = aarch64_get_qualifier_esize (info->qualifier);
1159   insert_field (self->fields[0], code, info->reglane.regno, 0);
1160   insert_fields (code, (info->reglane.index * 2 + 1) * esize, 0,
1161                  2, FLD_imm5, FLD_SVE_tszh);
1162   return TRUE;
1163 }
1164
1165 /* Encode a logical/bitmask immediate for the MOV alias of SVE DUPM.  */
1166 bfd_boolean
1167 aarch64_ins_sve_limm_mov (const aarch64_operand *self,
1168                           const aarch64_opnd_info *info, aarch64_insn *code,
1169                           const aarch64_inst *inst,
1170                           aarch64_operand_error *errors)
1171 {
1172   return aarch64_ins_limm (self, info, code, inst, errors);
1173 }
1174
1175 /* Encode Zn[MM], where Zn occupies the least-significant part of the field
1176    and where MM occupies the most-significant part.  The operand-dependent
1177    value specifies the number of bits in Zn.  */
1178 bfd_boolean
1179 aarch64_ins_sve_quad_index (const aarch64_operand *self,
1180                             const aarch64_opnd_info *info, aarch64_insn *code,
1181                             const aarch64_inst *inst ATTRIBUTE_UNUSED,
1182                             aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1183 {
1184   unsigned int reg_bits = get_operand_specific_data (self);
1185   assert (info->reglane.regno < (1U << reg_bits));
1186   unsigned int val = (info->reglane.index << reg_bits) + info->reglane.regno;
1187   insert_all_fields (self, code, val);
1188   return TRUE;
1189 }
1190
1191 /* Encode {Zn.<T> - Zm.<T>}.  The fields array specifies which field
1192    to use for Zn.  */
1193 bfd_boolean
1194 aarch64_ins_sve_reglist (const aarch64_operand *self,
1195                          const aarch64_opnd_info *info, aarch64_insn *code,
1196                          const aarch64_inst *inst ATTRIBUTE_UNUSED,
1197                          aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1198 {
1199   insert_field (self->fields[0], code, info->reglist.first_regno, 0);
1200   return TRUE;
1201 }
1202
1203 /* Encode <pattern>{, MUL #<amount>}.  The fields array specifies which
1204    fields to use for <pattern>.  <amount> - 1 is encoded in the SVE_imm4
1205    field.  */
1206 bfd_boolean
1207 aarch64_ins_sve_scale (const aarch64_operand *self,
1208                        const aarch64_opnd_info *info, aarch64_insn *code,
1209                        const aarch64_inst *inst ATTRIBUTE_UNUSED,
1210                        aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1211 {
1212   insert_all_fields (self, code, info->imm.value);
1213   insert_field (FLD_SVE_imm4, code, info->shifter.amount - 1, 0);
1214   return TRUE;
1215 }
1216
1217 /* Encode an SVE shift left immediate.  */
1218 bfd_boolean
1219 aarch64_ins_sve_shlimm (const aarch64_operand *self,
1220                         const aarch64_opnd_info *info, aarch64_insn *code,
1221                         const aarch64_inst *inst,
1222                         aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1223 {
1224   const aarch64_opnd_info *prev_operand;
1225   unsigned int esize;
1226
1227   assert (info->idx > 0);
1228   prev_operand = &inst->operands[info->idx - 1];
1229   esize = aarch64_get_qualifier_esize (prev_operand->qualifier);
1230   insert_all_fields (self, code, 8 * esize + info->imm.value);
1231   return TRUE;
1232 }
1233
1234 /* Encode an SVE shift right immediate.  */
1235 bfd_boolean
1236 aarch64_ins_sve_shrimm (const aarch64_operand *self,
1237                         const aarch64_opnd_info *info, aarch64_insn *code,
1238                         const aarch64_inst *inst,
1239                         aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1240 {
1241   const aarch64_opnd_info *prev_operand;
1242   unsigned int esize;
1243
1244   unsigned int opnd_backshift = get_operand_specific_data (self);
1245   assert (info->idx >= (int)opnd_backshift);
1246   prev_operand = &inst->operands[info->idx - opnd_backshift];
1247   esize = aarch64_get_qualifier_esize (prev_operand->qualifier);
1248   insert_all_fields (self, code, 16 * esize - info->imm.value);
1249   return TRUE;
1250 }
1251
1252 /* Encode a single-bit immediate that selects between #0.5 and #1.0.
1253    The fields array specifies which field to use.  */
1254 bfd_boolean
1255 aarch64_ins_sve_float_half_one (const aarch64_operand *self,
1256                                 const aarch64_opnd_info *info,
1257                                 aarch64_insn *code,
1258                                 const aarch64_inst *inst ATTRIBUTE_UNUSED,
1259                                 aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1260 {
1261   if (info->imm.value == 0x3f000000)
1262     insert_field (self->fields[0], code, 0, 0);
1263   else
1264     insert_field (self->fields[0], code, 1, 0);
1265   return TRUE;
1266 }
1267
1268 /* Encode a single-bit immediate that selects between #0.5 and #2.0.
1269    The fields array specifies which field to use.  */
1270 bfd_boolean
1271 aarch64_ins_sve_float_half_two (const aarch64_operand *self,
1272                                 const aarch64_opnd_info *info,
1273                                 aarch64_insn *code,
1274                                 const aarch64_inst *inst ATTRIBUTE_UNUSED,
1275                                 aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1276 {
1277   if (info->imm.value == 0x3f000000)
1278     insert_field (self->fields[0], code, 0, 0);
1279   else
1280     insert_field (self->fields[0], code, 1, 0);
1281   return TRUE;
1282 }
1283
1284 /* Encode a single-bit immediate that selects between #0.0 and #1.0.
1285    The fields array specifies which field to use.  */
1286 bfd_boolean
1287 aarch64_ins_sve_float_zero_one (const aarch64_operand *self,
1288                                 const aarch64_opnd_info *info,
1289                                 aarch64_insn *code,
1290                                 const aarch64_inst *inst ATTRIBUTE_UNUSED,
1291                                 aarch64_operand_error *errors ATTRIBUTE_UNUSED)
1292 {
1293   if (info->imm.value == 0)
1294     insert_field (self->fields[0], code, 0, 0);
1295   else
1296     insert_field (self->fields[0], code, 1, 0);
1297   return TRUE;
1298 }
1299
1300 /* Miscellaneous encoding functions.  */
1301
1302 /* Encode size[0], i.e. bit 22, for
1303      e.g. FCVTN<Q> <Vd>.<Tb>, <Vn>.<Ta>.  */
1304
1305 static void
1306 encode_asimd_fcvt (aarch64_inst *inst)
1307 {
1308   aarch64_insn value;
1309   aarch64_field field = {0, 0};
1310   enum aarch64_opnd_qualifier qualifier;
1311
1312   switch (inst->opcode->op)
1313     {
1314     case OP_FCVTN:
1315     case OP_FCVTN2:
1316       /* FCVTN<Q> <Vd>.<Tb>, <Vn>.<Ta>.  */
1317       qualifier = inst->operands[1].qualifier;
1318       break;
1319     case OP_FCVTL:
1320     case OP_FCVTL2:
1321       /* FCVTL<Q> <Vd>.<Ta>, <Vn>.<Tb>.  */
1322       qualifier = inst->operands[0].qualifier;
1323       break;
1324     default:
1325       assert (0);
1326     }
1327   assert (qualifier == AARCH64_OPND_QLF_V_4S
1328           || qualifier == AARCH64_OPND_QLF_V_2D);
1329   value = (qualifier == AARCH64_OPND_QLF_V_4S) ? 0 : 1;
1330   gen_sub_field (FLD_size, 0, 1, &field);
1331   insert_field_2 (&field, &inst->value, value, 0);
1332 }
1333
1334 /* Encode size[0], i.e. bit 22, for
1335      e.g. FCVTXN <Vb><d>, <Va><n>.  */
1336
1337 static void
1338 encode_asisd_fcvtxn (aarch64_inst *inst)
1339 {
1340   aarch64_insn val = 1;
1341   aarch64_field field = {0, 0};
1342   assert (inst->operands[0].qualifier == AARCH64_OPND_QLF_S_S);
1343   gen_sub_field (FLD_size, 0, 1, &field);
1344   insert_field_2 (&field, &inst->value, val, 0);
1345 }
1346
1347 /* Encode the 'opc' field for e.g. FCVT <Dd>, <Sn>.  */
1348 static void
1349 encode_fcvt (aarch64_inst *inst)
1350 {
1351   aarch64_insn val;
1352   const aarch64_field field = {15, 2};
1353
1354   /* opc dstsize */
1355   switch (inst->operands[0].qualifier)
1356     {
1357     case AARCH64_OPND_QLF_S_S: val = 0; break;
1358     case AARCH64_OPND_QLF_S_D: val = 1; break;
1359     case AARCH64_OPND_QLF_S_H: val = 3; break;
1360     default: abort ();
1361     }
1362   insert_field_2 (&field, &inst->value, val, 0);
1363
1364   return;
1365 }
1366
1367 /* Return the index in qualifiers_list that INST is using.  Should only
1368    be called once the qualifiers are known to be valid.  */
1369
1370 static int
1371 aarch64_get_variant (struct aarch64_inst *inst)
1372 {
1373   int i, nops, variant;
1374
1375   nops = aarch64_num_of_operands (inst->opcode);
1376   for (variant = 0; variant < AARCH64_MAX_QLF_SEQ_NUM; ++variant)
1377     {
1378       for (i = 0; i < nops; ++i)
1379         if (inst->opcode->qualifiers_list[variant][i]
1380             != inst->operands[i].qualifier)
1381           break;
1382       if (i == nops)
1383         return variant;
1384     }
1385   abort ();
1386 }
1387
1388 /* Do miscellaneous encodings that are not common enough to be driven by
1389    flags.  */
1390
1391 static void
1392 do_misc_encoding (aarch64_inst *inst)
1393 {
1394   unsigned int value;
1395
1396   switch (inst->opcode->op)
1397     {
1398     case OP_FCVT:
1399       encode_fcvt (inst);
1400       break;
1401     case OP_FCVTN:
1402     case OP_FCVTN2:
1403     case OP_FCVTL:
1404     case OP_FCVTL2:
1405       encode_asimd_fcvt (inst);
1406       break;
1407     case OP_FCVTXN_S:
1408       encode_asisd_fcvtxn (inst);
1409       break;
1410     case OP_MOV_P_P:
1411     case OP_MOVS_P_P:
1412       /* Copy Pn to Pm and Pg.  */
1413       value = extract_field (FLD_SVE_Pn, inst->value, 0);
1414       insert_field (FLD_SVE_Pm, &inst->value, value, 0);
1415       insert_field (FLD_SVE_Pg4_10, &inst->value, value, 0);
1416       break;
1417     case OP_MOV_Z_P_Z:
1418       /* Copy Zd to Zm.  */
1419       value = extract_field (FLD_SVE_Zd, inst->value, 0);
1420       insert_field (FLD_SVE_Zm_16, &inst->value, value, 0);
1421       break;
1422     case OP_MOV_Z_V:
1423       /* Fill in the zero immediate.  */
1424       insert_fields (&inst->value, 1 << aarch64_get_variant (inst), 0,
1425                      2, FLD_imm5, FLD_SVE_tszh);
1426       break;
1427     case OP_MOV_Z_Z:
1428       /* Copy Zn to Zm.  */
1429       value = extract_field (FLD_SVE_Zn, inst->value, 0);
1430       insert_field (FLD_SVE_Zm_16, &inst->value, value, 0);
1431       break;
1432     case OP_MOV_Z_Zi:
1433       break;
1434     case OP_MOVM_P_P_P:
1435       /* Copy Pd to Pm.  */
1436       value = extract_field (FLD_SVE_Pd, inst->value, 0);
1437       insert_field (FLD_SVE_Pm, &inst->value, value, 0);
1438       break;
1439     case OP_MOVZS_P_P_P:
1440     case OP_MOVZ_P_P_P:
1441       /* Copy Pn to Pm.  */
1442       value = extract_field (FLD_SVE_Pn, inst->value, 0);
1443       insert_field (FLD_SVE_Pm, &inst->value, value, 0);
1444       break;
1445     case OP_NOTS_P_P_P_Z:
1446     case OP_NOT_P_P_P_Z:
1447       /* Copy Pg to Pm.  */
1448       value = extract_field (FLD_SVE_Pg4_10, inst->value, 0);
1449       insert_field (FLD_SVE_Pm, &inst->value, value, 0);
1450       break;
1451     default: break;
1452     }
1453 }
1454
1455 /* Encode the 'size' and 'Q' field for e.g. SHADD.  */
1456 static void
1457 encode_sizeq (aarch64_inst *inst)
1458 {
1459   aarch64_insn sizeq;
1460   enum aarch64_field_kind kind;
1461   int idx;
1462
1463   /* Get the index of the operand whose information we are going to use
1464      to encode the size and Q fields.
1465      This is deduced from the possible valid qualifier lists.  */
1466   idx = aarch64_select_operand_for_sizeq_field_coding (inst->opcode);
1467   DEBUG_TRACE ("idx: %d; qualifier: %s", idx,
1468                aarch64_get_qualifier_name (inst->operands[idx].qualifier));
1469   sizeq = aarch64_get_qualifier_standard_value (inst->operands[idx].qualifier);
1470   /* Q */
1471   insert_field (FLD_Q, &inst->value, sizeq & 0x1, inst->opcode->mask);
1472   /* size */
1473   if (inst->opcode->iclass == asisdlse
1474      || inst->opcode->iclass == asisdlsep
1475      || inst->opcode->iclass == asisdlso
1476      || inst->opcode->iclass == asisdlsop)
1477     kind = FLD_vldst_size;
1478   else
1479     kind = FLD_size;
1480   insert_field (kind, &inst->value, (sizeq >> 1) & 0x3, inst->opcode->mask);
1481 }
1482
1483 /* Opcodes that have fields shared by multiple operands are usually flagged
1484    with flags.  In this function, we detect such flags and use the
1485    information in one of the related operands to do the encoding.  The 'one'
1486    operand is not any operand but one of the operands that has the enough
1487    information for such an encoding.  */
1488
1489 static void
1490 do_special_encoding (struct aarch64_inst *inst)
1491 {
1492   int idx;
1493   aarch64_insn value = 0;
1494
1495   DEBUG_TRACE ("enter with coding 0x%x", (uint32_t) inst->value);
1496
1497   /* Condition for truly conditional executed instructions, e.g. b.cond.  */
1498   if (inst->opcode->flags & F_COND)
1499     {
1500       insert_field (FLD_cond2, &inst->value, inst->cond->value, 0);
1501     }
1502   if (inst->opcode->flags & F_SF)
1503     {
1504       idx = select_operand_for_sf_field_coding (inst->opcode);
1505       value = (inst->operands[idx].qualifier == AARCH64_OPND_QLF_X
1506                || inst->operands[idx].qualifier == AARCH64_OPND_QLF_SP)
1507         ? 1 : 0;
1508       insert_field (FLD_sf, &inst->value, value, 0);
1509       if (inst->opcode->flags & F_N)
1510         insert_field (FLD_N, &inst->value, value, inst->opcode->mask);
1511     }
1512   if (inst->opcode->flags & F_LSE_SZ)
1513     {
1514       idx = select_operand_for_sf_field_coding (inst->opcode);
1515       value = (inst->operands[idx].qualifier == AARCH64_OPND_QLF_X
1516                || inst->operands[idx].qualifier == AARCH64_OPND_QLF_SP)
1517         ? 1 : 0;
1518       insert_field (FLD_lse_sz, &inst->value, value, 0);
1519     }
1520   if (inst->opcode->flags & F_SIZEQ)
1521     encode_sizeq (inst);
1522   if (inst->opcode->flags & F_FPTYPE)
1523     {
1524       idx = select_operand_for_fptype_field_coding (inst->opcode);
1525       switch (inst->operands[idx].qualifier)
1526         {
1527         case AARCH64_OPND_QLF_S_S: value = 0; break;
1528         case AARCH64_OPND_QLF_S_D: value = 1; break;
1529         case AARCH64_OPND_QLF_S_H: value = 3; break;
1530         default: assert (0);
1531         }
1532       insert_field (FLD_type, &inst->value, value, 0);
1533     }
1534   if (inst->opcode->flags & F_SSIZE)
1535     {
1536       enum aarch64_opnd_qualifier qualifier;
1537       idx = select_operand_for_scalar_size_field_coding (inst->opcode);
1538       qualifier = inst->operands[idx].qualifier;
1539       assert (qualifier >= AARCH64_OPND_QLF_S_B
1540               && qualifier <= AARCH64_OPND_QLF_S_Q);
1541       value = aarch64_get_qualifier_standard_value (qualifier);
1542       insert_field (FLD_size, &inst->value, value, inst->opcode->mask);
1543     }
1544   if (inst->opcode->flags & F_T)
1545     {
1546       int num;  /* num of consecutive '0's on the right side of imm5<3:0>.  */
1547       aarch64_field field = {0, 0};
1548       enum aarch64_opnd_qualifier qualifier;
1549
1550       idx = 0;
1551       qualifier = inst->operands[idx].qualifier;
1552       assert (aarch64_get_operand_class (inst->opcode->operands[0])
1553               == AARCH64_OPND_CLASS_SIMD_REG
1554               && qualifier >= AARCH64_OPND_QLF_V_8B
1555               && qualifier <= AARCH64_OPND_QLF_V_2D);
1556       /* imm5<3:0>      q       <t>
1557          0000           x       reserved
1558          xxx1           0       8b
1559          xxx1           1       16b
1560          xx10           0       4h
1561          xx10           1       8h
1562          x100           0       2s
1563          x100           1       4s
1564          1000           0       reserved
1565          1000           1       2d  */
1566       value = aarch64_get_qualifier_standard_value (qualifier);
1567       insert_field (FLD_Q, &inst->value, value & 0x1, inst->opcode->mask);
1568       num = (int) value >> 1;
1569       assert (num >= 0 && num <= 3);
1570       gen_sub_field (FLD_imm5, 0, num + 1, &field);
1571       insert_field_2 (&field, &inst->value, 1 << num, inst->opcode->mask);
1572     }
1573   if (inst->opcode->flags & F_GPRSIZE_IN_Q)
1574     {
1575       /* Use Rt to encode in the case of e.g.
1576          STXP <Ws>, <Xt1>, <Xt2>, [<Xn|SP>{,#0}].  */
1577       enum aarch64_opnd_qualifier qualifier;
1578       idx = aarch64_operand_index (inst->opcode->operands, AARCH64_OPND_Rt);
1579       if (idx == -1)
1580         /* Otherwise use the result operand, which has to be a integer
1581            register.  */
1582         idx = 0;
1583       assert (idx == 0 || idx == 1);
1584       assert (aarch64_get_operand_class (inst->opcode->operands[idx])
1585               == AARCH64_OPND_CLASS_INT_REG);
1586       qualifier = inst->operands[idx].qualifier;
1587       insert_field (FLD_Q, &inst->value,
1588                     aarch64_get_qualifier_standard_value (qualifier), 0);
1589     }
1590   if (inst->opcode->flags & F_LDS_SIZE)
1591     {
1592       /* e.g. LDRSB <Wt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}].  */
1593       enum aarch64_opnd_qualifier qualifier;
1594       aarch64_field field = {0, 0};
1595       assert (aarch64_get_operand_class (inst->opcode->operands[0])
1596               == AARCH64_OPND_CLASS_INT_REG);
1597       gen_sub_field (FLD_opc, 0, 1, &field);
1598       qualifier = inst->operands[0].qualifier;
1599       insert_field_2 (&field, &inst->value,
1600                       1 - aarch64_get_qualifier_standard_value (qualifier), 0);
1601     }
1602   /* Miscellaneous encoding as the last step.  */
1603   if (inst->opcode->flags & F_MISC)
1604     do_misc_encoding (inst);
1605
1606   DEBUG_TRACE ("exit with coding 0x%x", (uint32_t) inst->value);
1607 }
1608
1609 /* Some instructions (including all SVE ones) use the instruction class
1610    to describe how a qualifiers_list index is represented in the instruction
1611    encoding.  If INST is such an instruction, encode the chosen qualifier
1612    variant.  */
1613
1614 static void
1615 aarch64_encode_variant_using_iclass (struct aarch64_inst *inst)
1616 {
1617   int variant = 0;
1618   switch (inst->opcode->iclass)
1619     {
1620     case sve_cpy:
1621       insert_fields (&inst->value, aarch64_get_variant (inst),
1622                      0, 2, FLD_SVE_M_14, FLD_size);
1623       break;
1624
1625     case sve_index:
1626     case sve_shift_pred:
1627     case sve_shift_unpred:
1628     case sve_shift_tsz_hsd:
1629     case sve_shift_tsz_bhsd:
1630       /* For indices and shift amounts, the variant is encoded as
1631          part of the immediate.  */
1632       break;
1633
1634     case sve_limm:
1635       /* For sve_limm, the .B, .H, and .S forms are just a convenience
1636          and depend on the immediate.  They don't have a separate
1637          encoding.  */
1638       break;
1639
1640     case sve_misc:
1641       /* sve_misc instructions have only a single variant.  */
1642       break;
1643
1644     case sve_movprfx:
1645       insert_fields (&inst->value, aarch64_get_variant (inst),
1646                      0, 2, FLD_SVE_M_16, FLD_size);
1647       break;
1648
1649     case sve_pred_zm:
1650       insert_field (FLD_SVE_M_4, &inst->value, aarch64_get_variant (inst), 0);
1651       break;
1652
1653     case sve_size_bhs:
1654     case sve_size_bhsd:
1655       insert_field (FLD_size, &inst->value, aarch64_get_variant (inst), 0);
1656       break;
1657
1658     case sve_size_hsd:
1659       insert_field (FLD_size, &inst->value, aarch64_get_variant (inst) + 1, 0);
1660       break;
1661
1662     case sve_size_bh:
1663     case sve_size_sd:
1664       insert_field (FLD_SVE_sz, &inst->value, aarch64_get_variant (inst), 0);
1665       break;
1666
1667     case sve_size_sd2:
1668       insert_field (FLD_SVE_sz2, &inst->value, aarch64_get_variant (inst), 0);
1669       break;
1670
1671     case sve_size_hsd2:
1672       insert_field (FLD_SVE_size, &inst->value,
1673                     aarch64_get_variant (inst) + 1, 0);
1674       break;
1675
1676     case sve_size_tsz_bhs:
1677       insert_fields (&inst->value,
1678                      (1 << aarch64_get_variant (inst)),
1679                      0, 2, FLD_SVE_tszl_19, FLD_SVE_sz);
1680       break;
1681
1682     case sve_size_013:
1683       variant = aarch64_get_variant (inst);
1684       if (variant == 2)
1685           variant = 3;
1686       insert_field (FLD_size, &inst->value, variant, 0);
1687       break;
1688
1689     default:
1690       break;
1691     }
1692 }
1693
1694 /* Converters converting an alias opcode instruction to its real form.  */
1695
1696 /* ROR <Wd>, <Ws>, #<shift>
1697      is equivalent to:
1698    EXTR <Wd>, <Ws>, <Ws>, #<shift>.  */
1699 static void
1700 convert_ror_to_extr (aarch64_inst *inst)
1701 {
1702   copy_operand_info (inst, 3, 2);
1703   copy_operand_info (inst, 2, 1);
1704 }
1705
1706 /* UXTL<Q> <Vd>.<Ta>, <Vn>.<Tb>
1707      is equivalent to:
1708    USHLL<Q> <Vd>.<Ta>, <Vn>.<Tb>, #0.  */
1709 static void
1710 convert_xtl_to_shll (aarch64_inst *inst)
1711 {
1712   inst->operands[2].qualifier = inst->operands[1].qualifier;
1713   inst->operands[2].imm.value = 0;
1714 }
1715
1716 /* Convert
1717      LSR <Xd>, <Xn>, #<shift>
1718    to
1719      UBFM <Xd>, <Xn>, #<shift>, #63.  */
1720 static void
1721 convert_sr_to_bfm (aarch64_inst *inst)
1722 {
1723   inst->operands[3].imm.value =
1724     inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31 ? 31 : 63;
1725 }
1726
1727 /* Convert MOV to ORR.  */
1728 static void
1729 convert_mov_to_orr (aarch64_inst *inst)
1730 {
1731   /* MOV <Vd>.<T>, <Vn>.<T>
1732      is equivalent to:
1733      ORR <Vd>.<T>, <Vn>.<T>, <Vn>.<T>.  */
1734   copy_operand_info (inst, 2, 1);
1735 }
1736
1737 /* When <imms> >= <immr>, the instruction written:
1738      SBFX <Xd>, <Xn>, #<lsb>, #<width>
1739    is equivalent to:
1740      SBFM <Xd>, <Xn>, #<lsb>, #(<lsb>+<width>-1).  */
1741
1742 static void
1743 convert_bfx_to_bfm (aarch64_inst *inst)
1744 {
1745   int64_t lsb, width;
1746
1747   /* Convert the operand.  */
1748   lsb = inst->operands[2].imm.value;
1749   width = inst->operands[3].imm.value;
1750   inst->operands[2].imm.value = lsb;
1751   inst->operands[3].imm.value = lsb + width - 1;
1752 }
1753
1754 /* When <imms> < <immr>, the instruction written:
1755      SBFIZ <Xd>, <Xn>, #<lsb>, #<width>
1756    is equivalent to:
1757      SBFM <Xd>, <Xn>, #((64-<lsb>)&0x3f), #(<width>-1).  */
1758
1759 static void
1760 convert_bfi_to_bfm (aarch64_inst *inst)
1761 {
1762   int64_t lsb, width;
1763
1764   /* Convert the operand.  */
1765   lsb = inst->operands[2].imm.value;
1766   width = inst->operands[3].imm.value;
1767   if (inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31)
1768     {
1769       inst->operands[2].imm.value = (32 - lsb) & 0x1f;
1770       inst->operands[3].imm.value = width - 1;
1771     }
1772   else
1773     {
1774       inst->operands[2].imm.value = (64 - lsb) & 0x3f;
1775       inst->operands[3].imm.value = width - 1;
1776     }
1777 }
1778
1779 /* The instruction written:
1780      BFC <Xd>, #<lsb>, #<width>
1781    is equivalent to:
1782      BFM <Xd>, XZR, #((64-<lsb>)&0x3f), #(<width>-1).  */
1783
1784 static void
1785 convert_bfc_to_bfm (aarch64_inst *inst)
1786 {
1787   int64_t lsb, width;
1788
1789   /* Insert XZR.  */
1790   copy_operand_info (inst, 3, 2);
1791   copy_operand_info (inst, 2, 1);
1792   copy_operand_info (inst, 1, 0);
1793   inst->operands[1].reg.regno = 0x1f;
1794
1795   /* Convert the immediate operand.  */
1796   lsb = inst->operands[2].imm.value;
1797   width = inst->operands[3].imm.value;
1798   if (inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31)
1799     {
1800       inst->operands[2].imm.value = (32 - lsb) & 0x1f;
1801       inst->operands[3].imm.value = width - 1;
1802     }
1803   else
1804     {
1805       inst->operands[2].imm.value = (64 - lsb) & 0x3f;
1806       inst->operands[3].imm.value = width - 1;
1807     }
1808 }
1809
1810 /* The instruction written:
1811      LSL <Xd>, <Xn>, #<shift>
1812    is equivalent to:
1813      UBFM <Xd>, <Xn>, #((64-<shift>)&0x3f), #(63-<shift>).  */
1814
1815 static void
1816 convert_lsl_to_ubfm (aarch64_inst *inst)
1817 {
1818   int64_t shift = inst->operands[2].imm.value;
1819
1820   if (inst->operands[2].qualifier == AARCH64_OPND_QLF_imm_0_31)
1821     {
1822       inst->operands[2].imm.value = (32 - shift) & 0x1f;
1823       inst->operands[3].imm.value = 31 - shift;
1824     }
1825   else
1826     {
1827       inst->operands[2].imm.value = (64 - shift) & 0x3f;
1828       inst->operands[3].imm.value = 63 - shift;
1829     }
1830 }
1831
1832 /* CINC <Wd>, <Wn>, <cond>
1833      is equivalent to:
1834    CSINC <Wd>, <Wn>, <Wn>, invert(<cond>).  */
1835
1836 static void
1837 convert_to_csel (aarch64_inst *inst)
1838 {
1839   copy_operand_info (inst, 3, 2);
1840   copy_operand_info (inst, 2, 1);
1841   inst->operands[3].cond = get_inverted_cond (inst->operands[3].cond);
1842 }
1843
1844 /* CSET <Wd>, <cond>
1845      is equivalent to:
1846    CSINC <Wd>, WZR, WZR, invert(<cond>).  */
1847
1848 static void
1849 convert_cset_to_csinc (aarch64_inst *inst)
1850 {
1851   copy_operand_info (inst, 3, 1);
1852   copy_operand_info (inst, 2, 0);
1853   copy_operand_info (inst, 1, 0);
1854   inst->operands[1].reg.regno = 0x1f;
1855   inst->operands[2].reg.regno = 0x1f;
1856   inst->operands[3].cond = get_inverted_cond (inst->operands[3].cond);
1857 }
1858
1859 /* MOV <Wd>, #<imm>
1860    is equivalent to:
1861    MOVZ <Wd>, #<imm16>, LSL #<shift>.  */
1862
1863 static void
1864 convert_mov_to_movewide (aarch64_inst *inst)
1865 {
1866   int is32;
1867   uint32_t shift_amount;
1868   uint64_t value;
1869
1870   switch (inst->opcode->op)
1871     {
1872     case OP_MOV_IMM_WIDE:
1873       value = inst->operands[1].imm.value;
1874       break;
1875     case OP_MOV_IMM_WIDEN:
1876       value = ~inst->operands[1].imm.value;
1877       break;
1878     default:
1879       assert (0);
1880     }
1881   inst->operands[1].type = AARCH64_OPND_HALF;
1882   is32 = inst->operands[0].qualifier == AARCH64_OPND_QLF_W;
1883   if (! aarch64_wide_constant_p (value, is32, &shift_amount))
1884     /* The constraint check should have guaranteed this wouldn't happen.  */
1885     assert (0);
1886   value >>= shift_amount;
1887   value &= 0xffff;
1888   inst->operands[1].imm.value = value;
1889   inst->operands[1].shifter.kind = AARCH64_MOD_LSL;
1890   inst->operands[1].shifter.amount = shift_amount;
1891 }
1892
1893 /* MOV <Wd>, #<imm>
1894      is equivalent to:
1895    ORR <Wd>, WZR, #<imm>.  */
1896
1897 static void
1898 convert_mov_to_movebitmask (aarch64_inst *inst)
1899 {
1900   copy_operand_info (inst, 2, 1);
1901   inst->operands[1].reg.regno = 0x1f;
1902   inst->operands[1].skip = 0;
1903 }
1904
1905 /* Some alias opcodes are assembled by being converted to their real-form.  */
1906
1907 static void
1908 convert_to_real (aarch64_inst *inst, const aarch64_opcode *real)
1909 {
1910   const aarch64_opcode *alias = inst->opcode;
1911
1912   if ((alias->flags & F_CONV) == 0)
1913     goto convert_to_real_return;
1914
1915   switch (alias->op)
1916     {
1917     case OP_ASR_IMM:
1918     case OP_LSR_IMM:
1919       convert_sr_to_bfm (inst);
1920       break;
1921     case OP_LSL_IMM:
1922       convert_lsl_to_ubfm (inst);
1923       break;
1924     case OP_CINC:
1925     case OP_CINV:
1926     case OP_CNEG:
1927       convert_to_csel (inst);
1928       break;
1929     case OP_CSET:
1930     case OP_CSETM:
1931       convert_cset_to_csinc (inst);
1932       break;
1933     case OP_UBFX:
1934     case OP_BFXIL:
1935     case OP_SBFX:
1936       convert_bfx_to_bfm (inst);
1937       break;
1938     case OP_SBFIZ:
1939     case OP_BFI:
1940     case OP_UBFIZ:
1941       convert_bfi_to_bfm (inst);
1942       break;
1943     case OP_BFC:
1944       convert_bfc_to_bfm (inst);
1945       break;
1946     case OP_MOV_V:
1947       convert_mov_to_orr (inst);
1948       break;
1949     case OP_MOV_IMM_WIDE:
1950     case OP_MOV_IMM_WIDEN:
1951       convert_mov_to_movewide (inst);
1952       break;
1953     case OP_MOV_IMM_LOG:
1954       convert_mov_to_movebitmask (inst);
1955       break;
1956     case OP_ROR_IMM:
1957       convert_ror_to_extr (inst);
1958       break;
1959     case OP_SXTL:
1960     case OP_SXTL2:
1961     case OP_UXTL:
1962     case OP_UXTL2:
1963       convert_xtl_to_shll (inst);
1964       break;
1965     default:
1966       break;
1967     }
1968
1969 convert_to_real_return:
1970   aarch64_replace_opcode (inst, real);
1971 }
1972
1973 /* Encode *INST_ORI of the opcode code OPCODE.
1974    Return the encoded result in *CODE and if QLF_SEQ is not NULL, return the
1975    matched operand qualifier sequence in *QLF_SEQ.  */
1976
1977 bfd_boolean
1978 aarch64_opcode_encode (const aarch64_opcode *opcode,
1979                        const aarch64_inst *inst_ori, aarch64_insn *code,
1980                        aarch64_opnd_qualifier_t *qlf_seq,
1981                        aarch64_operand_error *mismatch_detail,
1982                        aarch64_instr_sequence* insn_sequence)
1983 {
1984   int i;
1985   const aarch64_opcode *aliased;
1986   aarch64_inst copy, *inst;
1987
1988   DEBUG_TRACE ("enter with %s", opcode->name);
1989
1990   /* Create a copy of *INST_ORI, so that we can do any change we want.  */
1991   copy = *inst_ori;
1992   inst = &copy;
1993
1994   assert (inst->opcode == NULL || inst->opcode == opcode);
1995   if (inst->opcode == NULL)
1996     inst->opcode = opcode;
1997
1998   /* Constrain the operands.
1999      After passing this, the encoding is guaranteed to succeed.  */
2000   if (aarch64_match_operands_constraint (inst, mismatch_detail) == 0)
2001     {
2002       DEBUG_TRACE ("FAIL since operand constraint not met");
2003       return 0;
2004     }
2005
2006   /* Get the base value.
2007      Note: this has to be before the aliasing handling below in order to
2008      get the base value from the alias opcode before we move on to the
2009      aliased opcode for encoding.  */
2010   inst->value = opcode->opcode;
2011
2012   /* No need to do anything else if the opcode does not have any operand.  */
2013   if (aarch64_num_of_operands (opcode) == 0)
2014     goto encoding_exit;
2015
2016   /* Assign operand indexes and check types.  Also put the matched
2017      operand qualifiers in *QLF_SEQ to return.  */
2018   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i)
2019     {
2020       assert (opcode->operands[i] == inst->operands[i].type);
2021       inst->operands[i].idx = i;
2022       if (qlf_seq != NULL)
2023         *qlf_seq = inst->operands[i].qualifier;
2024     }
2025
2026   aliased = aarch64_find_real_opcode (opcode);
2027   /* If the opcode is an alias and it does not ask for direct encoding by
2028      itself, the instruction will be transformed to the form of real opcode
2029      and the encoding will be carried out using the rules for the aliased
2030      opcode.  */
2031   if (aliased != NULL && (opcode->flags & F_CONV))
2032     {
2033       DEBUG_TRACE ("real opcode '%s' has been found for the alias  %s",
2034                    aliased->name, opcode->name);
2035       /* Convert the operands to the form of the real opcode.  */
2036       convert_to_real (inst, aliased);
2037       opcode = aliased;
2038     }
2039
2040   aarch64_opnd_info *info = inst->operands;
2041
2042   /* Call the inserter of each operand.  */
2043   for (i = 0; i < AARCH64_MAX_OPND_NUM; ++i, ++info)
2044     {
2045       const aarch64_operand *opnd;
2046       enum aarch64_opnd type = opcode->operands[i];
2047       if (type == AARCH64_OPND_NIL)
2048         break;
2049       if (info->skip)
2050         {
2051           DEBUG_TRACE ("skip the incomplete operand %d", i);
2052           continue;
2053         }
2054       opnd = &aarch64_operands[type];
2055       if (operand_has_inserter (opnd)
2056           && !aarch64_insert_operand (opnd, info, &inst->value, inst,
2057                                       mismatch_detail))
2058             return FALSE;
2059     }
2060
2061   /* Call opcode encoders indicated by flags.  */
2062   if (opcode_has_special_coder (opcode))
2063     do_special_encoding (inst);
2064
2065   /* Possibly use the instruction class to encode the chosen qualifier
2066      variant.  */
2067   aarch64_encode_variant_using_iclass (inst);
2068
2069   /* Run a verifier if the instruction has one set.  */
2070   if (opcode->verifier)
2071     {
2072       enum err_type result = opcode->verifier (inst, *code, 0, TRUE,
2073                                                mismatch_detail, insn_sequence);
2074       switch (result)
2075         {
2076         case ERR_UND:
2077         case ERR_UNP:
2078         case ERR_NYI:
2079           return FALSE;
2080         default:
2081           break;
2082         }
2083     }
2084
2085   /* Always run constrain verifiers, this is needed because constrains need to
2086      maintain a global state.  Regardless if the instruction has the flag set
2087      or not.  */
2088   enum err_type result = verify_constraints (inst, *code, 0, TRUE,
2089                                              mismatch_detail, insn_sequence);
2090   switch (result)
2091     {
2092     case ERR_UND:
2093     case ERR_UNP:
2094     case ERR_NYI:
2095       return FALSE;
2096     default:
2097       break;
2098     }
2099
2100
2101 encoding_exit:
2102   DEBUG_TRACE ("exit with %s", opcode->name);
2103
2104   *code = inst->value;
2105
2106   return TRUE;
2107 }