target/hexagon/decode.c

   1 /*
   2  *  Copyright(c) 2019-2021 Qualcomm Innovation Center, Inc. All Rights Reserved.
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "qemu/osdep.h"
  19 #include "iclass.h"
  20 #include "attribs.h"
  21 #include "genptr.h"
  22 #include "decode.h"
  23 #include "insn.h"
  24 #include "printinsn.h"
  25 #include "mmvec/decode_ext_mmvec.h"
  26
  27 #define fZXTN(N, M, VAL) ((VAL) & ((1LL << (N)) - 1))
  28
  29 enum {
  30     EXT_IDX_noext = 0,
  31     EXT_IDX_noext_AFTER = 4,
  32     EXT_IDX_mmvec = 4,
  33     EXT_IDX_mmvec_AFTER = 8,
  34     XX_LAST_EXT_IDX
  35 };
  36
  37 /*
  38  *  Certain operand types represent a non-contiguous set of values.
  39  *  For example, the compound compare-and-jump instruction can only access
  40  *  registers R0-R7 and R16-23.
  41  *  This table represents the mapping from the encoding to the actual values.
  42  */
  43
  44 #define DEF_REGMAP(NAME, ELEMENTS, ...) \
  45     static const unsigned int DECODE_REGISTER_##NAME[ELEMENTS] = \
  46     { __VA_ARGS__ };
  47         /* Name   Num Table */
  48 DEF_REGMAP(R_16,  16, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23)
  49 DEF_REGMAP(R__8,  8,  0, 2, 4, 6, 16, 18, 20, 22)
  50 DEF_REGMAP(R_8,   8,  0, 1, 2, 3, 4, 5, 6, 7)
  51
  52 #define DECODE_MAPPED_REG(OPNUM, NAME) \
  53     insn->regno[OPNUM] = DECODE_REGISTER_##NAME[insn->regno[OPNUM]];
  54
  55 typedef struct {
  56     const struct DectreeTable *table_link;
  57     const struct DectreeTable *table_link_b;
  58     Opcode opcode;
  59     enum {
  60         DECTREE_ENTRY_INVALID,
  61         DECTREE_TABLE_LINK,
  62         DECTREE_SUBINSNS,
  63         DECTREE_EXTSPACE,
  64         DECTREE_TERMINAL
  65     } type;
  66 } DectreeEntry;
  67
  68 typedef struct DectreeTable {
  69     unsigned int (*lookup_function)(int startbit, int width, uint32_t opcode);
  70     unsigned int size;
  71     unsigned int startbit;
  72     unsigned int width;
  73     const DectreeEntry table[];
  74 } DectreeTable;
  75
  76 #define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT) \
  77     static const DectreeTable dectree_table_##TAG;
  78 #define TABLE_LINK(TABLE)                     /* NOTHING */
  79 #define TERMINAL(TAG, ENC)                    /* NOTHING */
  80 #define SUBINSNS(TAG, CLASSA, CLASSB, ENC)    /* NOTHING */
  81 #define EXTSPACE(TAG, ENC)                    /* NOTHING */
  82 #define INVALID()                             /* NOTHING */
  83 #define DECODE_END_TABLE(...)                 /* NOTHING */
  84 #define DECODE_MATCH_INFO(...)                /* NOTHING */
  85 #define DECODE_LEGACY_MATCH_INFO(...)         /* NOTHING */
  86 #define DECODE_OPINFO(...)                    /* NOTHING */
  87
  88 #include "dectree_generated.h.inc"
  89
  90 #undef DECODE_OPINFO
  91 #undef DECODE_MATCH_INFO
  92 #undef DECODE_LEGACY_MATCH_INFO
  93 #undef DECODE_END_TABLE
  94 #undef INVALID
  95 #undef TERMINAL
  96 #undef SUBINSNS
  97 #undef EXTSPACE
  98 #undef TABLE_LINK
  99 #undef DECODE_NEW_TABLE
 100 #undef DECODE_SEPARATOR_BITS
 101
 102 #define DECODE_SEPARATOR_BITS(START, WIDTH) NULL, START, WIDTH
 103 #define DECODE_NEW_TABLE_HELPER(TAG, SIZE, FN, START, WIDTH) \
 104     static const DectreeTable dectree_table_##TAG = { \
 105         .size = SIZE, \
 106         .lookup_function = FN, \
 107         .startbit = START, \
 108         .width = WIDTH, \
 109         .table = {
 110 #define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT) \
 111     DECODE_NEW_TABLE_HELPER(TAG, SIZE, WHATNOT)
 112
 113 #define TABLE_LINK(TABLE) \
 114     { .type = DECTREE_TABLE_LINK, .table_link = &dectree_table_##TABLE },
 115 #define TERMINAL(TAG, ENC) \
 116     { .type = DECTREE_TERMINAL, .opcode = TAG  },
 117 #define SUBINSNS(TAG, CLASSA, CLASSB, ENC) \
 118     { \
 119         .type = DECTREE_SUBINSNS, \
 120         .table_link = &dectree_table_DECODE_SUBINSN_##CLASSA, \
 121         .table_link_b = &dectree_table_DECODE_SUBINSN_##CLASSB \
 122     },
 123 #define EXTSPACE(TAG, ENC) { .type = DECTREE_EXTSPACE },
 124 #define INVALID() { .type = DECTREE_ENTRY_INVALID, .opcode = XX_LAST_OPCODE },
 125
 126 #define DECODE_END_TABLE(...) } };
 127
 128 #define DECODE_MATCH_INFO(...)                /* NOTHING */
 129 #define DECODE_LEGACY_MATCH_INFO(...)         /* NOTHING */
 130 #define DECODE_OPINFO(...)                    /* NOTHING */
 131
 132 #include "dectree_generated.h.inc"
 133
 134 #undef DECODE_OPINFO
 135 #undef DECODE_MATCH_INFO
 136 #undef DECODE_LEGACY_MATCH_INFO
 137 #undef DECODE_END_TABLE
 138 #undef INVALID
 139 #undef TERMINAL
 140 #undef SUBINSNS
 141 #undef EXTSPACE
 142 #undef TABLE_LINK
 143 #undef DECODE_NEW_TABLE
 144 #undef DECODE_NEW_TABLE_HELPER
 145 #undef DECODE_SEPARATOR_BITS
 146
 147 static const DectreeTable dectree_table_DECODE_EXT_EXT_noext = {
 148     .size = 1, .lookup_function = NULL, .startbit = 0, .width = 0,
 149     .table = {
 150         { .type = DECTREE_ENTRY_INVALID, .opcode = XX_LAST_OPCODE },
 151     }
 152 };
 153
 154 static const DectreeTable *ext_trees[XX_LAST_EXT_IDX];
 155
 156 static void decode_ext_init(void)
 157 {
 158     int i;
 159     for (i = EXT_IDX_noext; i < EXT_IDX_noext_AFTER; i++) {
 160         ext_trees[i] = &dectree_table_DECODE_EXT_EXT_noext;
 161     }
 162     for (i = EXT_IDX_mmvec; i < EXT_IDX_mmvec_AFTER; i++) {
 163         ext_trees[i] = &dectree_table_DECODE_EXT_EXT_mmvec;
 164     }
 165 }
 166
 167 typedef struct {
 168     uint32_t mask;
 169     uint32_t match;
 170 } DecodeITableEntry;
 171
 172 #define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT)  /* NOTHING */
 173 #define TABLE_LINK(TABLE)                     /* NOTHING */
 174 #define TERMINAL(TAG, ENC)                    /* NOTHING */
 175 #define SUBINSNS(TAG, CLASSA, CLASSB, ENC)    /* NOTHING */
 176 #define EXTSPACE(TAG, ENC)                    /* NOTHING */
 177 #define INVALID()                             /* NOTHING */
 178 #define DECODE_END_TABLE(...)                 /* NOTHING */
 179 #define DECODE_OPINFO(...)                    /* NOTHING */
 180
 181 #define DECODE_MATCH_INFO_NORMAL(TAG, MASK, MATCH) \
 182     [TAG] = { \
 183         .mask = MASK, \
 184         .match = MATCH, \
 185     },
 186
 187 #define DECODE_MATCH_INFO_NULL(TAG, MASK, MATCH) \
 188     [TAG] = { .match = ~0 },
 189
 190 #define DECODE_MATCH_INFO(...) DECODE_MATCH_INFO_NORMAL(__VA_ARGS__)
 191 #define DECODE_LEGACY_MATCH_INFO(...) /* NOTHING */
 192
 193 static const DecodeITableEntry decode_itable[XX_LAST_OPCODE] = {
 194 #include "dectree_generated.h.inc"
 195 };
 196
 197 #undef DECODE_MATCH_INFO
 198 #define DECODE_MATCH_INFO(...) DECODE_MATCH_INFO_NULL(__VA_ARGS__)
 199
 200 #undef DECODE_LEGACY_MATCH_INFO
 201 #define DECODE_LEGACY_MATCH_INFO(...) DECODE_MATCH_INFO_NORMAL(__VA_ARGS__)
 202
 203 static const DecodeITableEntry decode_legacy_itable[XX_LAST_OPCODE] = {
 204 #include "dectree_generated.h.inc"
 205 };
 206
 207 #undef DECODE_OPINFO
 208 #undef DECODE_MATCH_INFO
 209 #undef DECODE_LEGACY_MATCH_INFO
 210 #undef DECODE_END_TABLE
 211 #undef INVALID
 212 #undef TERMINAL
 213 #undef SUBINSNS
 214 #undef EXTSPACE
 215 #undef TABLE_LINK
 216 #undef DECODE_NEW_TABLE
 217 #undef DECODE_SEPARATOR_BITS
 218
 219 void decode_init(void)
 220 {
 221     decode_ext_init();
 222 }
 223
 224 void decode_send_insn_to(Packet *packet, int start, int newloc)
 225 {
 226     Insn tmpinsn;
 227     int direction;
 228     int i;
 229     if (start == newloc) {
 230         return;
 231     }
 232     if (start < newloc) {
 233         /* Move towards end */
 234         direction = 1;
 235     } else {
 236         /* move towards beginning */
 237         direction = -1;
 238     }
 239     for (i = start; i != newloc; i += direction) {
 240         tmpinsn = packet->insn[i];
 241         packet->insn[i] = packet->insn[i + direction];
 242         packet->insn[i + direction] = tmpinsn;
 243     }
 244 }
 245
 246 /* Fill newvalue registers with the correct regno */
 247 static void
 248 decode_fill_newvalue_regno(Packet *packet)
 249 {
 250     int i, use_regidx, offset, def_idx, dst_idx;
 251     uint16_t def_opcode, use_opcode;
 252     char *dststr;
 253
 254     for (i = 1; i < packet->num_insns; i++) {
 255         if (GET_ATTRIB(packet->insn[i].opcode, A_DOTNEWVALUE) &&
 256             !GET_ATTRIB(packet->insn[i].opcode, A_EXTENSION)) {
 257             use_opcode = packet->insn[i].opcode;
 258
 259             /* It's a store, so we're adjusting the Nt field */
 260             if (GET_ATTRIB(use_opcode, A_STORE)) {
 261                 use_regidx = strchr(opcode_reginfo[use_opcode], 't') -
 262                     opcode_reginfo[use_opcode];
 263             } else {    /* It's a Jump, so we're adjusting the Ns field */
 264                 use_regidx = strchr(opcode_reginfo[use_opcode], 's') -
 265                     opcode_reginfo[use_opcode];
 266             }
 267
 268             /*
 269              * What's encoded at the N-field is the offset to who's producing
 270              * the value.  Shift off the LSB which indicates odd/even register,
 271              * then walk backwards and skip over the constant extenders.
 272              */
 273             offset = packet->insn[i].regno[use_regidx] >> 1;
 274             def_idx = i - offset;
 275             for (int j = 0; j < offset; j++) {
 276                 if (GET_ATTRIB(packet->insn[i - j - 1].opcode, A_IT_EXTENDER)) {
 277                     def_idx--;
 278                 }
 279             }
 280
 281             /*
 282              * Check for a badly encoded N-field which points to an instruction
 283              * out-of-range
 284              */
 285             g_assert(!((def_idx < 0) || (def_idx > (packet->num_insns - 1))));
 286
 287             /*
 288              * packet->insn[def_idx] is the producer
 289              * Figure out which type of destination it produces
 290              * and the corresponding index in the reginfo
 291              */
 292             def_opcode = packet->insn[def_idx].opcode;
 293             dststr = strstr(opcode_wregs[def_opcode], "Rd");
 294             if (dststr) {
 295                 dststr = strchr(opcode_reginfo[def_opcode], 'd');
 296             } else {
 297                 dststr = strstr(opcode_wregs[def_opcode], "Rx");
 298                 if (dststr) {
 299                     dststr = strchr(opcode_reginfo[def_opcode], 'x');
 300                 } else {
 301                     dststr = strstr(opcode_wregs[def_opcode], "Re");
 302                     if (dststr) {
 303                         dststr = strchr(opcode_reginfo[def_opcode], 'e');
 304                     } else {
 305                         dststr = strstr(opcode_wregs[def_opcode], "Ry");
 306                         if (dststr) {
 307                             dststr = strchr(opcode_reginfo[def_opcode], 'y');
 308                         } else {
 309                             g_assert_not_reached();
 310                         }
 311                     }
 312                 }
 313             }
 314             g_assert(dststr != NULL);
 315
 316             /* Now patch up the consumer with the register number */
 317             dst_idx = dststr - opcode_reginfo[def_opcode];
 318             packet->insn[i].regno[use_regidx] =
 319                 packet->insn[def_idx].regno[dst_idx];
 320             /*
 321              * We need to remember who produces this value to later
 322              * check if it was dynamically cancelled
 323              */
 324             packet->insn[i].new_value_producer_slot =
 325                 packet->insn[def_idx].slot;
 326         }
 327     }
 328 }
 329
 330 /* Split CJ into a compare and a jump */
 331 static void decode_split_cmpjump(Packet *pkt)
 332 {
 333     int last, i;
 334     int numinsns = pkt->num_insns;
 335
 336     /*
 337      * First, split all compare-jumps.
 338      * The compare is sent to the end as a new instruction.
 339      * Do it this way so we don't reorder dual jumps. Those need to stay in
 340      * original order.
 341      */
 342     for (i = 0; i < numinsns; i++) {
 343         /* It's a cmp-jump */
 344         if (GET_ATTRIB(pkt->insn[i].opcode, A_NEWCMPJUMP)) {
 345             last = pkt->num_insns;
 346             pkt->insn[last] = pkt->insn[i];    /* copy the instruction */
 347             pkt->insn[last].part1 = true;      /* last insn does the CMP */
 348             pkt->insn[i].part1 = false;        /* existing insn does the JUMP */
 349             pkt->num_insns++;
 350         }
 351     }
 352
 353     /* Now re-shuffle all the compares back to the beginning */
 354     for (i = 0; i < pkt->num_insns; i++) {
 355         if (pkt->insn[i].part1) {
 356             decode_send_insn_to(pkt, i, 0);
 357         }
 358     }
 359 }
 360
 361 static bool decode_opcode_can_jump(int opcode)
 362 {
 363     if ((GET_ATTRIB(opcode, A_JUMP)) ||
 364         (GET_ATTRIB(opcode, A_CALL)) ||
 365         (opcode == J2_trap0) ||
 366         (opcode == J2_pause)) {
 367         /* Exception to A_JUMP attribute */
 368         if (opcode == J4_hintjumpr) {
 369             return false;
 370         }
 371         return true;
 372     }
 373
 374     return false;
 375 }
 376
 377 static bool decode_opcode_ends_loop(int opcode)
 378 {
 379     return GET_ATTRIB(opcode, A_HWLOOP0_END) ||
 380            GET_ATTRIB(opcode, A_HWLOOP1_END);
 381 }
 382
 383 /* Set the is_* fields in each instruction */
 384 static void decode_set_insn_attr_fields(Packet *pkt)
 385 {
 386     int i;
 387     int numinsns = pkt->num_insns;
 388     uint16_t opcode;
 389
 390     pkt->pkt_has_cof = false;
 391     pkt->pkt_has_endloop = false;
 392     pkt->pkt_has_dczeroa = false;
 393
 394     for (i = 0; i < numinsns; i++) {
 395         opcode = pkt->insn[i].opcode;
 396         if (pkt->insn[i].part1) {
 397             continue;    /* Skip compare of cmp-jumps */
 398         }
 399
 400         if (GET_ATTRIB(opcode, A_DCZEROA)) {
 401             pkt->pkt_has_dczeroa = true;
 402         }
 403
 404         if (GET_ATTRIB(opcode, A_STORE)) {
 405             if (pkt->insn[i].slot == 0) {
 406                 pkt->pkt_has_store_s0 = true;
 407             } else {
 408                 pkt->pkt_has_store_s1 = true;
 409             }
 410         }
 411
 412         pkt->pkt_has_cof |= decode_opcode_can_jump(opcode);
 413
 414         pkt->insn[i].is_endloop = decode_opcode_ends_loop(opcode);
 415
 416         pkt->pkt_has_endloop |= pkt->insn[i].is_endloop;
 417
 418         pkt->pkt_has_cof |= pkt->pkt_has_endloop;
 419     }
 420 }
 421
 422 /*
 423  * Shuffle for execution
 424  * Move stores to end (in same order as encoding)
 425  * Move compares to beginning (for use by .new insns)
 426  */
 427 static void decode_shuffle_for_execution(Packet *packet)
 428 {
 429     bool changed = false;
 430     int i;
 431     bool flag;    /* flag means we've seen a non-memory instruction */
 432     int n_mems;
 433     int last_insn = packet->num_insns - 1;
 434
 435     /*
 436      * Skip end loops, somehow an end loop is getting in and messing
 437      * up the order
 438      */
 439     if (decode_opcode_ends_loop(packet->insn[last_insn].opcode)) {
 440         last_insn--;
 441     }
 442
 443     do {
 444         changed = false;
 445         /*
 446          * Stores go last, must not reorder.
 447          * Cannot shuffle stores past loads, either.
 448          * Iterate backwards.  If we see a non-memory instruction,
 449          * then a store, shuffle the store to the front.  Don't shuffle
 450          * stores wrt each other or a load.
 451          */
 452         for (flag = false, n_mems = 0, i = last_insn; i >= 0; i--) {
 453             int opcode = packet->insn[i].opcode;
 454
 455             if (flag && GET_ATTRIB(opcode, A_STORE)) {
 456                 decode_send_insn_to(packet, i, last_insn - n_mems);
 457                 n_mems++;
 458                 changed = true;
 459             } else if (GET_ATTRIB(opcode, A_STORE)) {
 460                 n_mems++;
 461             } else if (GET_ATTRIB(opcode, A_LOAD)) {
 462                 /*
 463                  * Don't set flag, since we don't want to shuffle a
 464                  * store past a load
 465                  */
 466                 n_mems++;
 467             } else if (GET_ATTRIB(opcode, A_DOTNEWVALUE)) {
 468                 /*
 469                  * Don't set flag, since we don't want to shuffle past
 470                  * a .new value
 471                  */
 472             } else {
 473                 flag = true;
 474             }
 475         }
 476
 477         if (changed) {
 478             continue;
 479         }
 480         /* Compares go first, may be reordered wrt each other */
 481         for (flag = false, i = 0; i < last_insn + 1; i++) {
 482             int opcode = packet->insn[i].opcode;
 483
 484             if ((strstr(opcode_wregs[opcode], "Pd4") ||
 485                  strstr(opcode_wregs[opcode], "Pe4")) &&
 486                 GET_ATTRIB(opcode, A_STORE) == 0) {
 487                 /* This should be a compare (not a store conditional) */
 488                 if (flag) {
 489                     decode_send_insn_to(packet, i, 0);
 490                     changed = true;
 491                     continue;
 492                 }
 493             } else if (GET_ATTRIB(opcode, A_IMPLICIT_WRITES_P3) &&
 494                        !decode_opcode_ends_loop(packet->insn[i].opcode)) {
 495                 /*
 496                  * spNloop instruction
 497                  * Don't reorder endloops; they are not valid for .new uses,
 498                  * and we want to match HW
 499                  */
 500                 if (flag) {
 501                     decode_send_insn_to(packet, i, 0);
 502                     changed = true;
 503                     continue;
 504                 }
 505             } else if (GET_ATTRIB(opcode, A_IMPLICIT_WRITES_P0) &&
 506                        !GET_ATTRIB(opcode, A_NEWCMPJUMP)) {
 507                 if (flag) {
 508                     decode_send_insn_to(packet, i, 0);
 509                     changed = true;
 510                     continue;
 511                 }
 512             } else {
 513                 flag = true;
 514             }
 515         }
 516         if (changed) {
 517             continue;
 518         }
 519     } while (changed);
 520
 521     /*
 522      * If we have a .new register compare/branch, move that to the very
 523      * very end, past stores
 524      */
 525     for (i = 0; i < last_insn; i++) {
 526         if (GET_ATTRIB(packet->insn[i].opcode, A_DOTNEWVALUE)) {
 527             decode_send_insn_to(packet, i, last_insn);
 528             break;
 529         }
 530     }
 531 }
 532
 533 static void
 534 apply_extender(Packet *pkt, int i, uint32_t extender)
 535 {
 536     int immed_num;
 537     uint32_t base_immed;
 538
 539     immed_num = opcode_which_immediate_is_extended(pkt->insn[i].opcode);
 540     base_immed = pkt->insn[i].immed[immed_num];
 541
 542     pkt->insn[i].immed[immed_num] = extender | fZXTN(6, 32, base_immed);
 543 }
 544
 545 static void decode_apply_extenders(Packet *packet)
 546 {
 547     int i;
 548     for (i = 0; i < packet->num_insns; i++) {
 549         if (GET_ATTRIB(packet->insn[i].opcode, A_IT_EXTENDER)) {
 550             packet->insn[i + 1].extension_valid = true;
 551             apply_extender(packet, i + 1, packet->insn[i].immed[0]);
 552         }
 553     }
 554 }
 555
 556 static void decode_remove_extenders(Packet *packet)
 557 {
 558     int i, j;
 559     for (i = 0; i < packet->num_insns; i++) {
 560         if (GET_ATTRIB(packet->insn[i].opcode, A_IT_EXTENDER)) {
 561             /* Remove this one by moving the remaining instructions down */
 562             for (j = i;
 563                 (j < packet->num_insns - 1) && (j < INSTRUCTIONS_MAX - 1);
 564                 j++) {
 565                 packet->insn[j] = packet->insn[j + 1];
 566             }
 567             packet->num_insns--;
 568         }
 569     }
 570 }
 571
 572 static SlotMask get_valid_slots(const Packet *pkt, unsigned int slot)
 573 {
 574     if (GET_ATTRIB(pkt->insn[slot].opcode, A_EXTENSION)) {
 575         return mmvec_ext_decode_find_iclass_slots(pkt->insn[slot].opcode);
 576     } else {
 577         return find_iclass_slots(pkt->insn[slot].opcode,
 578                                  pkt->insn[slot].iclass);
 579     }
 580 }
 581
 582 #define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT)     /* NOTHING */
 583 #define TABLE_LINK(TABLE)                        /* NOTHING */
 584 #define TERMINAL(TAG, ENC)                       /* NOTHING */
 585 #define SUBINSNS(TAG, CLASSA, CLASSB, ENC)       /* NOTHING */
 586 #define EXTSPACE(TAG, ENC)                       /* NOTHING */
 587 #define INVALID()                                /* NOTHING */
 588 #define DECODE_END_TABLE(...)                    /* NOTHING */
 589 #define DECODE_MATCH_INFO(...)                   /* NOTHING */
 590 #define DECODE_LEGACY_MATCH_INFO(...)            /* NOTHING */
 591
 592 #define DECODE_REG(REGNO, WIDTH, STARTBIT) \
 593     insn->regno[REGNO] = ((encoding >> STARTBIT) & ((1 << WIDTH) - 1));
 594
 595 #define DECODE_IMPL_REG(REGNO, VAL) \
 596     insn->regno[REGNO] = VAL;
 597
 598 #define DECODE_IMM(IMMNO, WIDTH, STARTBIT, VALSTART) \
 599     insn->immed[IMMNO] |= (((encoding >> STARTBIT) & ((1 << WIDTH) - 1))) << \
 600                           (VALSTART);
 601
 602 #define DECODE_IMM_SXT(IMMNO, WIDTH) \
 603     insn->immed[IMMNO] = ((((int32_t)insn->immed[IMMNO]) << (32 - WIDTH)) >> \
 604                           (32 - WIDTH));
 605
 606 #define DECODE_IMM_NEG(IMMNO, WIDTH) \
 607     insn->immed[IMMNO] = -insn->immed[IMMNO];
 608
 609 #define DECODE_IMM_SHIFT(IMMNO, SHAMT)                                 \
 610     if ((!insn->extension_valid) || \
 611         (insn->which_extended != IMMNO)) { \
 612         insn->immed[IMMNO] <<= SHAMT; \
 613     }
 614
 615 #define DECODE_OPINFO(TAG, BEH) \
 616     case TAG: \
 617         { BEH  } \
 618         break; \
 619
 620 /*
 621  * Fill in the operands of the instruction
 622  * dectree_generated.h.inc has a DECODE_OPINFO entry for each opcode
 623  * For example,
 624  *     DECODE_OPINFO(A2_addi,
 625  *          DECODE_REG(0,5,0)
 626  *          DECODE_REG(1,5,16)
 627  *          DECODE_IMM(0,7,21,9)
 628  *          DECODE_IMM(0,9,5,0)
 629  *          DECODE_IMM_SXT(0,16)
 630  * with the macros defined above, we'll fill in a switch statement
 631  * where each case is an opcode tag.
 632  */
 633 static void
 634 decode_op(Insn *insn, Opcode tag, uint32_t encoding)
 635 {
 636     insn->immed[0] = 0;
 637     insn->immed[1] = 0;
 638     insn->opcode = tag;
 639     if (insn->extension_valid) {
 640         insn->which_extended = opcode_which_immediate_is_extended(tag);
 641     }
 642
 643     switch (tag) {
 644 #include "dectree_generated.h.inc"
 645     default:
 646         break;
 647     }
 648
 649     insn->generate = opcode_genptr[tag];
 650
 651     insn->iclass = iclass_bits(encoding);
 652 }
 653
 654 #undef DECODE_REG
 655 #undef DECODE_IMPL_REG
 656 #undef DECODE_IMM
 657 #undef DECODE_IMM_SHIFT
 658 #undef DECODE_OPINFO
 659 #undef DECODE_MATCH_INFO
 660 #undef DECODE_LEGACY_MATCH_INFO
 661 #undef DECODE_END_TABLE
 662 #undef INVALID
 663 #undef TERMINAL
 664 #undef SUBINSNS
 665 #undef EXTSPACE
 666 #undef TABLE_LINK
 667 #undef DECODE_NEW_TABLE
 668 #undef DECODE_SEPARATOR_BITS
 669
 670 static unsigned int
 671 decode_subinsn_tablewalk(Insn *insn, const DectreeTable *table,
 672                          uint32_t encoding)
 673 {
 674     unsigned int i;
 675     Opcode opc;
 676     if (table->lookup_function) {
 677         i = table->lookup_function(table->startbit, table->width, encoding);
 678     } else {
 679         i = extract32(encoding, table->startbit, table->width);
 680     }
 681     if (table->table[i].type == DECTREE_TABLE_LINK) {
 682         return decode_subinsn_tablewalk(insn, table->table[i].table_link,
 683                                         encoding);
 684     } else if (table->table[i].type == DECTREE_TERMINAL) {
 685         opc = table->table[i].opcode;
 686         if ((encoding & decode_itable[opc].mask) != decode_itable[opc].match) {
 687             return 0;
 688         }
 689         decode_op(insn, opc, encoding);
 690         return 1;
 691     } else {
 692         return 0;
 693     }
 694 }
 695
 696 static unsigned int get_insn_a(uint32_t encoding)
 697 {
 698     return extract32(encoding, 0, 13);
 699 }
 700
 701 static unsigned int get_insn_b(uint32_t encoding)
 702 {
 703     return extract32(encoding, 16, 13);
 704 }
 705
 706 static unsigned int
 707 decode_insns_tablewalk(Insn *insn, const DectreeTable *table,
 708                        uint32_t encoding)
 709 {
 710     unsigned int i;
 711     unsigned int a, b;
 712     Opcode opc;
 713     if (table->lookup_function) {
 714         i = table->lookup_function(table->startbit, table->width, encoding);
 715     } else {
 716         i = extract32(encoding, table->startbit, table->width);
 717     }
 718     if (table->table[i].type == DECTREE_TABLE_LINK) {
 719         return decode_insns_tablewalk(insn, table->table[i].table_link,
 720                                       encoding);
 721     } else if (table->table[i].type == DECTREE_SUBINSNS) {
 722         a = get_insn_a(encoding);
 723         b = get_insn_b(encoding);
 724         b = decode_subinsn_tablewalk(insn, table->table[i].table_link_b, b);
 725         a = decode_subinsn_tablewalk(insn + 1, table->table[i].table_link, a);
 726         if ((a == 0) || (b == 0)) {
 727             return 0;
 728         }
 729         return 2;
 730     } else if (table->table[i].type == DECTREE_TERMINAL) {
 731         opc = table->table[i].opcode;
 732         if ((encoding & decode_itable[opc].mask) != decode_itable[opc].match) {
 733             if ((encoding & decode_legacy_itable[opc].mask) !=
 734                 decode_legacy_itable[opc].match) {
 735                 return 0;
 736             }
 737         }
 738         decode_op(insn, opc, encoding);
 739         return 1;
 740     } else if (table->table[i].type == DECTREE_EXTSPACE) {
 741         /*
 742          * For now, HVX will be the only coproc
 743          */
 744         return decode_insns_tablewalk(insn, ext_trees[EXT_IDX_mmvec], encoding);
 745     } else {
 746         return 0;
 747     }
 748 }
 749
 750 static unsigned int
 751 decode_insns(Insn *insn, uint32_t encoding)
 752 {
 753     const DectreeTable *table;
 754     if (parse_bits(encoding) != 0) {
 755         /* Start with PP table - 32 bit instructions */
 756         table = &dectree_table_DECODE_ROOT_32;
 757     } else {
 758         /* start with EE table - duplex instructions */
 759         table = &dectree_table_DECODE_ROOT_EE;
 760     }
 761     return decode_insns_tablewalk(insn, table, encoding);
 762 }
 763
 764 static void decode_add_endloop_insn(Insn *insn, int loopnum)
 765 {
 766     if (loopnum == 10) {
 767         insn->opcode = J2_endloop01;
 768         insn->generate = opcode_genptr[J2_endloop01];
 769     } else if (loopnum == 1) {
 770         insn->opcode = J2_endloop1;
 771         insn->generate = opcode_genptr[J2_endloop1];
 772     } else if (loopnum == 0) {
 773         insn->opcode = J2_endloop0;
 774         insn->generate = opcode_genptr[J2_endloop0];
 775     } else {
 776         g_assert_not_reached();
 777     }
 778 }
 779
 780 static bool decode_parsebits_is_loopend(uint32_t encoding32)
 781 {
 782     uint32_t bits = parse_bits(encoding32);
 783     return bits == 0x2;
 784 }
 785
 786 static void
 787 decode_set_slot_number(Packet *pkt)
 788 {
 789     int slot;
 790     int i;
 791     bool hit_mem_insn = false;
 792     bool hit_duplex = false;
 793     bool slot0_found = false;
 794     bool slot1_found = false;
 795     int slot1_iidx = 0;
 796
 797     /*
 798      * The slots are encoded in reverse order
 799      * For each instruction, count down until you find a suitable slot
 800      */
 801     for (i = 0, slot = 3; i < pkt->num_insns; i++) {
 802         SlotMask valid_slots = get_valid_slots(pkt, i);
 803
 804         while (!(valid_slots & (1 << slot))) {
 805             slot--;
 806         }
 807         pkt->insn[i].slot = slot;
 808         if (slot) {
 809             /* I've assigned the slot, now decrement it for the next insn */
 810             slot--;
 811         }
 812     }
 813
 814     /* Fix the exceptions - mem insns to slot 0,1 */
 815     for (i = pkt->num_insns - 1; i >= 0; i--) {
 816         /* First memory instruction always goes to slot 0 */
 817         if ((GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE) ||
 818              GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE_PACKET_RULES)) &&
 819             !hit_mem_insn) {
 820             hit_mem_insn = true;
 821             pkt->insn[i].slot = 0;
 822             continue;
 823         }
 824
 825         /* Next memory instruction always goes to slot 1 */
 826         if ((GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE) ||
 827              GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE_PACKET_RULES)) &&
 828             hit_mem_insn) {
 829             pkt->insn[i].slot = 1;
 830         }
 831     }
 832
 833     /* Fix the exceptions - duplex always slot 0,1 */
 834     for (i = pkt->num_insns - 1; i >= 0; i--) {
 835         /* First subinsn always goes to slot 0 */
 836         if (GET_ATTRIB(pkt->insn[i].opcode, A_SUBINSN) && !hit_duplex) {
 837             hit_duplex = true;
 838             pkt->insn[i].slot = 0;
 839             continue;
 840         }
 841
 842         /* Next subinsn always goes to slot 1 */
 843         if (GET_ATTRIB(pkt->insn[i].opcode, A_SUBINSN) && hit_duplex) {
 844             pkt->insn[i].slot = 1;
 845         }
 846     }
 847
 848     /* Fix the exceptions - slot 1 is never empty, always aligns to slot 0 */
 849     for (i = pkt->num_insns - 1; i >= 0; i--) {
 850         /* Is slot0 used? */
 851         if (pkt->insn[i].slot == 0) {
 852             bool is_endloop = (pkt->insn[i].opcode == J2_endloop01);
 853             is_endloop |= (pkt->insn[i].opcode == J2_endloop0);
 854             is_endloop |= (pkt->insn[i].opcode == J2_endloop1);
 855
 856             /*
 857              * Make sure it's not endloop since, we're overloading
 858              * slot0 for endloop
 859              */
 860             if (!is_endloop) {
 861                 slot0_found = true;
 862             }
 863         }
 864         /* Is slot1 used? */
 865         if (pkt->insn[i].slot == 1) {
 866             slot1_found = true;
 867             slot1_iidx = i;
 868         }
 869     }
 870     /* Is slot0 empty and slot1 used? */
 871     if ((!slot0_found) && slot1_found) {
 872         /* Then push it to slot0 */
 873         pkt->insn[slot1_iidx].slot = 0;
 874     }
 875 }
 876
 877 /*
 878  * decode_packet
 879  * Decodes packet with given words
 880  * Returns 0 on insufficient words,
 881  * or number of words used on success
 882  */
 883
 884 int decode_packet(int max_words, const uint32_t *words, Packet *pkt,
 885                   bool disas_only)
 886 {
 887     int num_insns = 0;
 888     int words_read = 0;
 889     bool end_of_packet = false;
 890     int new_insns = 0;
 891     int i;
 892     uint32_t encoding32;
 893
 894     /* Initialize */
 895     memset(pkt, 0, sizeof(*pkt));
 896     /* Try to build packet */
 897     while (!end_of_packet && (words_read < max_words)) {
 898         encoding32 = words[words_read];
 899         end_of_packet = is_packet_end(encoding32);
 900         new_insns = decode_insns(&pkt->insn[num_insns], encoding32);
 901         g_assert(new_insns > 0);
 902         /*
 903          * If we saw an extender, mark next word extended so immediate
 904          * decode works
 905          */
 906         if (pkt->insn[num_insns].opcode == A4_ext) {
 907             pkt->insn[num_insns + 1].extension_valid = true;
 908         }
 909         num_insns += new_insns;
 910         words_read++;
 911     }
 912
 913     pkt->num_insns = num_insns;
 914     if (!end_of_packet) {
 915         /* Ran out of words! */
 916         return 0;
 917     }
 918     pkt->encod_pkt_size_in_bytes = words_read * 4;
 919     pkt->pkt_has_hvx = false;
 920     for (i = 0; i < num_insns; i++) {
 921         pkt->pkt_has_hvx |=
 922             GET_ATTRIB(pkt->insn[i].opcode, A_CVI);
 923     }
 924
 925     /*
 926      * Check for :endloop in the parse bits
 927      * Section 10.6 of the Programmer's Reference describes the encoding
 928      *     The end of hardware loop 0 can be encoded with 2 words
 929      *     The end of hardware loop 1 needs 3 words
 930      */
 931     if ((words_read == 2) && (decode_parsebits_is_loopend(words[0]))) {
 932         decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 0);
 933     }
 934     if (words_read >= 3) {
 935         bool has_loop0, has_loop1;
 936         has_loop0 = decode_parsebits_is_loopend(words[0]);
 937         has_loop1 = decode_parsebits_is_loopend(words[1]);
 938         if (has_loop0 && has_loop1) {
 939             decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 10);
 940         } else if (has_loop1) {
 941             decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 1);
 942         } else if (has_loop0) {
 943             decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 0);
 944         }
 945     }
 946
 947     decode_apply_extenders(pkt);
 948     if (!disas_only) {
 949         decode_remove_extenders(pkt);
 950     }
 951     decode_set_slot_number(pkt);
 952     decode_fill_newvalue_regno(pkt);
 953
 954     if (pkt->pkt_has_hvx) {
 955         mmvec_ext_decode_checks(pkt, disas_only);
 956     }
 957
 958     if (!disas_only) {
 959         decode_shuffle_for_execution(pkt);
 960         decode_split_cmpjump(pkt);
 961         decode_set_insn_attr_fields(pkt);
 962     }
 963
 964     return words_read;
 965 }
 966
 967 /* Used for "-d in_asm" logging */
 968 int disassemble_hexagon(uint32_t *words, int nwords, bfd_vma pc,
 969                         GString *buf)
 970 {
 971     Packet pkt;
 972
 973     if (decode_packet(nwords, words, &pkt, true) > 0) {
 974         snprint_a_pkt_disas(buf, &pkt, words, pc);
 975         return pkt.encod_pkt_size_in_bytes;
 976     } else {
 977         g_string_assign(buf, "<invalid>");
 978         return 0;
 979     }
 980 }