opcodes/aarch64-asm.c

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