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