166d29a5eSTaylor Simpson /* 214edcf11SMatheus Tavares Bernardino * Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved. 366d29a5eSTaylor Simpson * 466d29a5eSTaylor Simpson * This program is free software; you can redistribute it and/or modify 566d29a5eSTaylor Simpson * it under the terms of the GNU General Public License as published by 666d29a5eSTaylor Simpson * the Free Software Foundation; either version 2 of the License, or 766d29a5eSTaylor Simpson * (at your option) any later version. 866d29a5eSTaylor Simpson * 966d29a5eSTaylor Simpson * This program is distributed in the hope that it will be useful, 1066d29a5eSTaylor Simpson * but WITHOUT ANY WARRANTY; without even the implied warranty of 1166d29a5eSTaylor Simpson * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1266d29a5eSTaylor Simpson * GNU General Public License for more details. 1366d29a5eSTaylor Simpson * 1466d29a5eSTaylor Simpson * You should have received a copy of the GNU General Public License 1566d29a5eSTaylor Simpson * along with this program; if not, see <http://www.gnu.org/licenses/>. 1666d29a5eSTaylor Simpson */ 1766d29a5eSTaylor Simpson 1866d29a5eSTaylor Simpson #include "qemu/osdep.h" 1966d29a5eSTaylor Simpson #include "iclass.h" 2066d29a5eSTaylor Simpson #include "attribs.h" 2166d29a5eSTaylor Simpson #include "genptr.h" 2266d29a5eSTaylor Simpson #include "decode.h" 2366d29a5eSTaylor Simpson #include "insn.h" 2466d29a5eSTaylor Simpson #include "printinsn.h" 2560d1180bSTaylor Simpson #include "mmvec/decode_ext_mmvec.h" 2666d29a5eSTaylor Simpson 2766d29a5eSTaylor Simpson #define fZXTN(N, M, VAL) ((VAL) & ((1LL << (N)) - 1)) 2866d29a5eSTaylor Simpson 2966d29a5eSTaylor Simpson enum { 3066d29a5eSTaylor Simpson EXT_IDX_noext = 0, 3166d29a5eSTaylor Simpson EXT_IDX_noext_AFTER = 4, 3266d29a5eSTaylor Simpson EXT_IDX_mmvec = 4, 3366d29a5eSTaylor Simpson EXT_IDX_mmvec_AFTER = 8, 3466d29a5eSTaylor Simpson XX_LAST_EXT_IDX 3566d29a5eSTaylor Simpson }; 3666d29a5eSTaylor Simpson 3766d29a5eSTaylor Simpson /* 3866d29a5eSTaylor Simpson * Certain operand types represent a non-contiguous set of values. 3966d29a5eSTaylor Simpson * For example, the compound compare-and-jump instruction can only access 4066d29a5eSTaylor Simpson * registers R0-R7 and R16-23. 4166d29a5eSTaylor Simpson * This table represents the mapping from the encoding to the actual values. 4266d29a5eSTaylor Simpson */ 4366d29a5eSTaylor Simpson 4466d29a5eSTaylor Simpson #define DEF_REGMAP(NAME, ELEMENTS, ...) \ 4566d29a5eSTaylor Simpson static const unsigned int DECODE_REGISTER_##NAME[ELEMENTS] = \ 4666d29a5eSTaylor Simpson { __VA_ARGS__ }; 4766d29a5eSTaylor Simpson /* Name Num Table */ 4866d29a5eSTaylor Simpson DEF_REGMAP(R_16, 16, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23) 4966d29a5eSTaylor Simpson DEF_REGMAP(R__8, 8, 0, 2, 4, 6, 16, 18, 20, 22) 5061c9aab0STaylor Simpson DEF_REGMAP(R_8, 8, 0, 1, 2, 3, 4, 5, 6, 7) 5166d29a5eSTaylor Simpson 521de468b3STaylor Simpson #define DECODE_MAPPED_REG(OPNUM, NAME) \ 531de468b3STaylor Simpson insn->regno[OPNUM] = DECODE_REGISTER_##NAME[insn->regno[OPNUM]]; 5466d29a5eSTaylor Simpson 551547a2d3STaylor Simpson /* Helper functions for decode_*_generated.c.inc */ 561547a2d3STaylor Simpson #define DECODE_MAPPED(NAME) \ 571547a2d3STaylor Simpson static int decode_mapped_reg_##NAME(DisasContext *ctx, int x) \ 581547a2d3STaylor Simpson { \ 591547a2d3STaylor Simpson return DECODE_REGISTER_##NAME[x]; \ 601547a2d3STaylor Simpson } 611547a2d3STaylor Simpson DECODE_MAPPED(R_16) 621547a2d3STaylor Simpson DECODE_MAPPED(R_8) 63*f6c01009STaylor Simpson DECODE_MAPPED(R__8) 641547a2d3STaylor Simpson 651547a2d3STaylor Simpson /* Helper function for decodetree_trans_funcs_generated.c.inc */ 661547a2d3STaylor Simpson static int shift_left(DisasContext *ctx, int x, int n, int immno) 671547a2d3STaylor Simpson { 681547a2d3STaylor Simpson int ret = x; 691547a2d3STaylor Simpson Insn *insn = ctx->insn; 701547a2d3STaylor Simpson if (!insn->extension_valid || 711547a2d3STaylor Simpson insn->which_extended != immno) { 721547a2d3STaylor Simpson ret <<= n; 731547a2d3STaylor Simpson } 741547a2d3STaylor Simpson return ret; 751547a2d3STaylor Simpson } 761547a2d3STaylor Simpson 771547a2d3STaylor Simpson /* Include the generated decoder for 32 bit insn */ 781547a2d3STaylor Simpson #include "decode_normal_generated.c.inc" 791547a2d3STaylor Simpson #include "decode_hvx_generated.c.inc" 801547a2d3STaylor Simpson 81*f6c01009STaylor Simpson /* Include the generated decoder for 16 bit insn */ 82*f6c01009STaylor Simpson #include "decode_subinsn_a_generated.c.inc" 83*f6c01009STaylor Simpson #include "decode_subinsn_l1_generated.c.inc" 84*f6c01009STaylor Simpson #include "decode_subinsn_l2_generated.c.inc" 85*f6c01009STaylor Simpson #include "decode_subinsn_s1_generated.c.inc" 86*f6c01009STaylor Simpson #include "decode_subinsn_s2_generated.c.inc" 87*f6c01009STaylor Simpson 881547a2d3STaylor Simpson /* Include the generated helpers for the decoder */ 891547a2d3STaylor Simpson #include "decodetree_trans_funcs_generated.c.inc" 901547a2d3STaylor Simpson 9166d29a5eSTaylor Simpson typedef struct { 9266d29a5eSTaylor Simpson const struct DectreeTable *table_link; 9366d29a5eSTaylor Simpson const struct DectreeTable *table_link_b; 9466d29a5eSTaylor Simpson Opcode opcode; 9566d29a5eSTaylor Simpson enum { 9666d29a5eSTaylor Simpson DECTREE_ENTRY_INVALID, 9766d29a5eSTaylor Simpson DECTREE_TABLE_LINK, 9866d29a5eSTaylor Simpson DECTREE_SUBINSNS, 9966d29a5eSTaylor Simpson DECTREE_EXTSPACE, 10066d29a5eSTaylor Simpson DECTREE_TERMINAL 10166d29a5eSTaylor Simpson } type; 10266d29a5eSTaylor Simpson } DectreeEntry; 10366d29a5eSTaylor Simpson 10466d29a5eSTaylor Simpson typedef struct DectreeTable { 10566d29a5eSTaylor Simpson unsigned int (*lookup_function)(int startbit, int width, uint32_t opcode); 10666d29a5eSTaylor Simpson unsigned int size; 10766d29a5eSTaylor Simpson unsigned int startbit; 10866d29a5eSTaylor Simpson unsigned int width; 10966d29a5eSTaylor Simpson const DectreeEntry table[]; 11066d29a5eSTaylor Simpson } DectreeTable; 11166d29a5eSTaylor Simpson 11266d29a5eSTaylor Simpson #define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT) \ 11366d29a5eSTaylor Simpson static const DectreeTable dectree_table_##TAG; 11466d29a5eSTaylor Simpson #define TABLE_LINK(TABLE) /* NOTHING */ 11566d29a5eSTaylor Simpson #define TERMINAL(TAG, ENC) /* NOTHING */ 11666d29a5eSTaylor Simpson #define SUBINSNS(TAG, CLASSA, CLASSB, ENC) /* NOTHING */ 11766d29a5eSTaylor Simpson #define EXTSPACE(TAG, ENC) /* NOTHING */ 11866d29a5eSTaylor Simpson #define INVALID() /* NOTHING */ 11966d29a5eSTaylor Simpson #define DECODE_END_TABLE(...) /* NOTHING */ 12066d29a5eSTaylor Simpson #define DECODE_MATCH_INFO(...) /* NOTHING */ 12166d29a5eSTaylor Simpson #define DECODE_LEGACY_MATCH_INFO(...) /* NOTHING */ 12266d29a5eSTaylor Simpson #define DECODE_OPINFO(...) /* NOTHING */ 12366d29a5eSTaylor Simpson 12466d29a5eSTaylor Simpson #include "dectree_generated.h.inc" 12566d29a5eSTaylor Simpson 12666d29a5eSTaylor Simpson #undef DECODE_OPINFO 12766d29a5eSTaylor Simpson #undef DECODE_MATCH_INFO 12866d29a5eSTaylor Simpson #undef DECODE_LEGACY_MATCH_INFO 12966d29a5eSTaylor Simpson #undef DECODE_END_TABLE 13066d29a5eSTaylor Simpson #undef INVALID 13166d29a5eSTaylor Simpson #undef TERMINAL 13266d29a5eSTaylor Simpson #undef SUBINSNS 13366d29a5eSTaylor Simpson #undef EXTSPACE 13466d29a5eSTaylor Simpson #undef TABLE_LINK 13566d29a5eSTaylor Simpson #undef DECODE_NEW_TABLE 13666d29a5eSTaylor Simpson #undef DECODE_SEPARATOR_BITS 13766d29a5eSTaylor Simpson 13866d29a5eSTaylor Simpson #define DECODE_SEPARATOR_BITS(START, WIDTH) NULL, START, WIDTH 13966d29a5eSTaylor Simpson #define DECODE_NEW_TABLE_HELPER(TAG, SIZE, FN, START, WIDTH) \ 14066d29a5eSTaylor Simpson static const DectreeTable dectree_table_##TAG = { \ 14166d29a5eSTaylor Simpson .size = SIZE, \ 14266d29a5eSTaylor Simpson .lookup_function = FN, \ 14366d29a5eSTaylor Simpson .startbit = START, \ 14466d29a5eSTaylor Simpson .width = WIDTH, \ 14566d29a5eSTaylor Simpson .table = { 14666d29a5eSTaylor Simpson #define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT) \ 14766d29a5eSTaylor Simpson DECODE_NEW_TABLE_HELPER(TAG, SIZE, WHATNOT) 14866d29a5eSTaylor Simpson 14966d29a5eSTaylor Simpson #define TABLE_LINK(TABLE) \ 15066d29a5eSTaylor Simpson { .type = DECTREE_TABLE_LINK, .table_link = &dectree_table_##TABLE }, 15166d29a5eSTaylor Simpson #define TERMINAL(TAG, ENC) \ 15266d29a5eSTaylor Simpson { .type = DECTREE_TERMINAL, .opcode = TAG }, 15366d29a5eSTaylor Simpson #define SUBINSNS(TAG, CLASSA, CLASSB, ENC) \ 15466d29a5eSTaylor Simpson { \ 15566d29a5eSTaylor Simpson .type = DECTREE_SUBINSNS, \ 15666d29a5eSTaylor Simpson .table_link = &dectree_table_DECODE_SUBINSN_##CLASSA, \ 15766d29a5eSTaylor Simpson .table_link_b = &dectree_table_DECODE_SUBINSN_##CLASSB \ 15866d29a5eSTaylor Simpson }, 15966d29a5eSTaylor Simpson #define EXTSPACE(TAG, ENC) { .type = DECTREE_EXTSPACE }, 16066d29a5eSTaylor Simpson #define INVALID() { .type = DECTREE_ENTRY_INVALID, .opcode = XX_LAST_OPCODE }, 16166d29a5eSTaylor Simpson 16266d29a5eSTaylor Simpson #define DECODE_END_TABLE(...) } }; 16366d29a5eSTaylor Simpson 16466d29a5eSTaylor Simpson #define DECODE_MATCH_INFO(...) /* NOTHING */ 16566d29a5eSTaylor Simpson #define DECODE_LEGACY_MATCH_INFO(...) /* NOTHING */ 16666d29a5eSTaylor Simpson #define DECODE_OPINFO(...) /* NOTHING */ 16766d29a5eSTaylor Simpson 16866d29a5eSTaylor Simpson #include "dectree_generated.h.inc" 16966d29a5eSTaylor Simpson 17066d29a5eSTaylor Simpson #undef DECODE_OPINFO 17166d29a5eSTaylor Simpson #undef DECODE_MATCH_INFO 17266d29a5eSTaylor Simpson #undef DECODE_LEGACY_MATCH_INFO 17366d29a5eSTaylor Simpson #undef DECODE_END_TABLE 17466d29a5eSTaylor Simpson #undef INVALID 17566d29a5eSTaylor Simpson #undef TERMINAL 17666d29a5eSTaylor Simpson #undef SUBINSNS 17766d29a5eSTaylor Simpson #undef EXTSPACE 17866d29a5eSTaylor Simpson #undef TABLE_LINK 17966d29a5eSTaylor Simpson #undef DECODE_NEW_TABLE 18066d29a5eSTaylor Simpson #undef DECODE_NEW_TABLE_HELPER 18166d29a5eSTaylor Simpson #undef DECODE_SEPARATOR_BITS 18266d29a5eSTaylor Simpson 18366d29a5eSTaylor Simpson static const DectreeTable dectree_table_DECODE_EXT_EXT_noext = { 18466d29a5eSTaylor Simpson .size = 1, .lookup_function = NULL, .startbit = 0, .width = 0, 18566d29a5eSTaylor Simpson .table = { 18666d29a5eSTaylor Simpson { .type = DECTREE_ENTRY_INVALID, .opcode = XX_LAST_OPCODE }, 18766d29a5eSTaylor Simpson } 18866d29a5eSTaylor Simpson }; 18966d29a5eSTaylor Simpson 19066d29a5eSTaylor Simpson static const DectreeTable *ext_trees[XX_LAST_EXT_IDX]; 19166d29a5eSTaylor Simpson 19266d29a5eSTaylor Simpson static void decode_ext_init(void) 19366d29a5eSTaylor Simpson { 19466d29a5eSTaylor Simpson int i; 19566d29a5eSTaylor Simpson for (i = EXT_IDX_noext; i < EXT_IDX_noext_AFTER; i++) { 19666d29a5eSTaylor Simpson ext_trees[i] = &dectree_table_DECODE_EXT_EXT_noext; 19766d29a5eSTaylor Simpson } 19861c9aab0STaylor Simpson for (i = EXT_IDX_mmvec; i < EXT_IDX_mmvec_AFTER; i++) { 19961c9aab0STaylor Simpson ext_trees[i] = &dectree_table_DECODE_EXT_EXT_mmvec; 20061c9aab0STaylor Simpson } 20166d29a5eSTaylor Simpson } 20266d29a5eSTaylor Simpson 20366d29a5eSTaylor Simpson typedef struct { 20466d29a5eSTaylor Simpson uint32_t mask; 20566d29a5eSTaylor Simpson uint32_t match; 20666d29a5eSTaylor Simpson } DecodeITableEntry; 20766d29a5eSTaylor Simpson 20866d29a5eSTaylor Simpson #define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT) /* NOTHING */ 20966d29a5eSTaylor Simpson #define TABLE_LINK(TABLE) /* NOTHING */ 21066d29a5eSTaylor Simpson #define TERMINAL(TAG, ENC) /* NOTHING */ 21166d29a5eSTaylor Simpson #define SUBINSNS(TAG, CLASSA, CLASSB, ENC) /* NOTHING */ 21266d29a5eSTaylor Simpson #define EXTSPACE(TAG, ENC) /* NOTHING */ 21366d29a5eSTaylor Simpson #define INVALID() /* NOTHING */ 21466d29a5eSTaylor Simpson #define DECODE_END_TABLE(...) /* NOTHING */ 21566d29a5eSTaylor Simpson #define DECODE_OPINFO(...) /* NOTHING */ 21666d29a5eSTaylor Simpson 21766d29a5eSTaylor Simpson #define DECODE_MATCH_INFO_NORMAL(TAG, MASK, MATCH) \ 21866d29a5eSTaylor Simpson [TAG] = { \ 21966d29a5eSTaylor Simpson .mask = MASK, \ 22066d29a5eSTaylor Simpson .match = MATCH, \ 22166d29a5eSTaylor Simpson }, 22266d29a5eSTaylor Simpson 22366d29a5eSTaylor Simpson #define DECODE_MATCH_INFO_NULL(TAG, MASK, MATCH) \ 22466d29a5eSTaylor Simpson [TAG] = { .match = ~0 }, 22566d29a5eSTaylor Simpson 22666d29a5eSTaylor Simpson #define DECODE_MATCH_INFO(...) DECODE_MATCH_INFO_NORMAL(__VA_ARGS__) 22766d29a5eSTaylor Simpson #define DECODE_LEGACY_MATCH_INFO(...) /* NOTHING */ 22866d29a5eSTaylor Simpson 22966d29a5eSTaylor Simpson static const DecodeITableEntry decode_itable[XX_LAST_OPCODE] = { 23066d29a5eSTaylor Simpson #include "dectree_generated.h.inc" 23166d29a5eSTaylor Simpson }; 23266d29a5eSTaylor Simpson 23366d29a5eSTaylor Simpson #undef DECODE_MATCH_INFO 23466d29a5eSTaylor Simpson #define DECODE_MATCH_INFO(...) DECODE_MATCH_INFO_NULL(__VA_ARGS__) 23566d29a5eSTaylor Simpson 23666d29a5eSTaylor Simpson #undef DECODE_LEGACY_MATCH_INFO 23766d29a5eSTaylor Simpson #define DECODE_LEGACY_MATCH_INFO(...) DECODE_MATCH_INFO_NORMAL(__VA_ARGS__) 23866d29a5eSTaylor Simpson 23966d29a5eSTaylor Simpson static const DecodeITableEntry decode_legacy_itable[XX_LAST_OPCODE] = { 24066d29a5eSTaylor Simpson #include "dectree_generated.h.inc" 24166d29a5eSTaylor Simpson }; 24266d29a5eSTaylor Simpson 24366d29a5eSTaylor Simpson #undef DECODE_OPINFO 24466d29a5eSTaylor Simpson #undef DECODE_MATCH_INFO 24566d29a5eSTaylor Simpson #undef DECODE_LEGACY_MATCH_INFO 24666d29a5eSTaylor Simpson #undef DECODE_END_TABLE 24766d29a5eSTaylor Simpson #undef INVALID 24866d29a5eSTaylor Simpson #undef TERMINAL 24966d29a5eSTaylor Simpson #undef SUBINSNS 25066d29a5eSTaylor Simpson #undef EXTSPACE 25166d29a5eSTaylor Simpson #undef TABLE_LINK 25266d29a5eSTaylor Simpson #undef DECODE_NEW_TABLE 25366d29a5eSTaylor Simpson #undef DECODE_SEPARATOR_BITS 25466d29a5eSTaylor Simpson 25566d29a5eSTaylor Simpson void decode_init(void) 25666d29a5eSTaylor Simpson { 25766d29a5eSTaylor Simpson decode_ext_init(); 25866d29a5eSTaylor Simpson } 25966d29a5eSTaylor Simpson 26066d29a5eSTaylor Simpson void decode_send_insn_to(Packet *packet, int start, int newloc) 26166d29a5eSTaylor Simpson { 26266d29a5eSTaylor Simpson Insn tmpinsn; 26366d29a5eSTaylor Simpson int direction; 26466d29a5eSTaylor Simpson int i; 26566d29a5eSTaylor Simpson if (start == newloc) { 26666d29a5eSTaylor Simpson return; 26766d29a5eSTaylor Simpson } 26866d29a5eSTaylor Simpson if (start < newloc) { 26966d29a5eSTaylor Simpson /* Move towards end */ 27066d29a5eSTaylor Simpson direction = 1; 27166d29a5eSTaylor Simpson } else { 27266d29a5eSTaylor Simpson /* move towards beginning */ 27366d29a5eSTaylor Simpson direction = -1; 27466d29a5eSTaylor Simpson } 27566d29a5eSTaylor Simpson for (i = start; i != newloc; i += direction) { 27666d29a5eSTaylor Simpson tmpinsn = packet->insn[i]; 27766d29a5eSTaylor Simpson packet->insn[i] = packet->insn[i + direction]; 27866d29a5eSTaylor Simpson packet->insn[i + direction] = tmpinsn; 27966d29a5eSTaylor Simpson } 28066d29a5eSTaylor Simpson } 28166d29a5eSTaylor Simpson 28266d29a5eSTaylor Simpson /* Fill newvalue registers with the correct regno */ 28366d29a5eSTaylor Simpson static void 28466d29a5eSTaylor Simpson decode_fill_newvalue_regno(Packet *packet) 28566d29a5eSTaylor Simpson { 28666d29a5eSTaylor Simpson int i, use_regidx, offset, def_idx, dst_idx; 28766d29a5eSTaylor Simpson uint16_t def_opcode, use_opcode; 28866d29a5eSTaylor Simpson char *dststr; 28966d29a5eSTaylor Simpson 29066d29a5eSTaylor Simpson for (i = 1; i < packet->num_insns; i++) { 29166d29a5eSTaylor Simpson if (GET_ATTRIB(packet->insn[i].opcode, A_DOTNEWVALUE) && 29266d29a5eSTaylor Simpson !GET_ATTRIB(packet->insn[i].opcode, A_EXTENSION)) { 29366d29a5eSTaylor Simpson use_opcode = packet->insn[i].opcode; 29466d29a5eSTaylor Simpson 29566d29a5eSTaylor Simpson /* It's a store, so we're adjusting the Nt field */ 29666d29a5eSTaylor Simpson if (GET_ATTRIB(use_opcode, A_STORE)) { 29766d29a5eSTaylor Simpson use_regidx = strchr(opcode_reginfo[use_opcode], 't') - 29866d29a5eSTaylor Simpson opcode_reginfo[use_opcode]; 29966d29a5eSTaylor Simpson } else { /* It's a Jump, so we're adjusting the Ns field */ 30066d29a5eSTaylor Simpson use_regidx = strchr(opcode_reginfo[use_opcode], 's') - 30166d29a5eSTaylor Simpson opcode_reginfo[use_opcode]; 30266d29a5eSTaylor Simpson } 30366d29a5eSTaylor Simpson 30466d29a5eSTaylor Simpson /* 30566d29a5eSTaylor Simpson * What's encoded at the N-field is the offset to who's producing 30666d29a5eSTaylor Simpson * the value. Shift off the LSB which indicates odd/even register, 30766d29a5eSTaylor Simpson * then walk backwards and skip over the constant extenders. 30866d29a5eSTaylor Simpson */ 30966d29a5eSTaylor Simpson offset = packet->insn[i].regno[use_regidx] >> 1; 31066d29a5eSTaylor Simpson def_idx = i - offset; 31166d29a5eSTaylor Simpson for (int j = 0; j < offset; j++) { 31266d29a5eSTaylor Simpson if (GET_ATTRIB(packet->insn[i - j - 1].opcode, A_IT_EXTENDER)) { 31366d29a5eSTaylor Simpson def_idx--; 31466d29a5eSTaylor Simpson } 31566d29a5eSTaylor Simpson } 31666d29a5eSTaylor Simpson 31766d29a5eSTaylor Simpson /* 31866d29a5eSTaylor Simpson * Check for a badly encoded N-field which points to an instruction 31966d29a5eSTaylor Simpson * out-of-range 32066d29a5eSTaylor Simpson */ 32166d29a5eSTaylor Simpson g_assert(!((def_idx < 0) || (def_idx > (packet->num_insns - 1)))); 32266d29a5eSTaylor Simpson 32366d29a5eSTaylor Simpson /* 32466d29a5eSTaylor Simpson * packet->insn[def_idx] is the producer 32566d29a5eSTaylor Simpson * Figure out which type of destination it produces 32666d29a5eSTaylor Simpson * and the corresponding index in the reginfo 32766d29a5eSTaylor Simpson */ 32866d29a5eSTaylor Simpson def_opcode = packet->insn[def_idx].opcode; 32966d29a5eSTaylor Simpson dststr = strstr(opcode_wregs[def_opcode], "Rd"); 33066d29a5eSTaylor Simpson if (dststr) { 33166d29a5eSTaylor Simpson dststr = strchr(opcode_reginfo[def_opcode], 'd'); 33266d29a5eSTaylor Simpson } else { 33366d29a5eSTaylor Simpson dststr = strstr(opcode_wregs[def_opcode], "Rx"); 33466d29a5eSTaylor Simpson if (dststr) { 33566d29a5eSTaylor Simpson dststr = strchr(opcode_reginfo[def_opcode], 'x'); 33666d29a5eSTaylor Simpson } else { 33766d29a5eSTaylor Simpson dststr = strstr(opcode_wregs[def_opcode], "Re"); 33866d29a5eSTaylor Simpson if (dststr) { 33966d29a5eSTaylor Simpson dststr = strchr(opcode_reginfo[def_opcode], 'e'); 34066d29a5eSTaylor Simpson } else { 34166d29a5eSTaylor Simpson dststr = strstr(opcode_wregs[def_opcode], "Ry"); 34266d29a5eSTaylor Simpson if (dststr) { 34366d29a5eSTaylor Simpson dststr = strchr(opcode_reginfo[def_opcode], 'y'); 34466d29a5eSTaylor Simpson } else { 34566d29a5eSTaylor Simpson g_assert_not_reached(); 34666d29a5eSTaylor Simpson } 34766d29a5eSTaylor Simpson } 34866d29a5eSTaylor Simpson } 34966d29a5eSTaylor Simpson } 35066d29a5eSTaylor Simpson g_assert(dststr != NULL); 35166d29a5eSTaylor Simpson 35266d29a5eSTaylor Simpson /* Now patch up the consumer with the register number */ 35366d29a5eSTaylor Simpson dst_idx = dststr - opcode_reginfo[def_opcode]; 35466d29a5eSTaylor Simpson packet->insn[i].regno[use_regidx] = 35566d29a5eSTaylor Simpson packet->insn[def_idx].regno[dst_idx]; 35666d29a5eSTaylor Simpson /* 35766d29a5eSTaylor Simpson * We need to remember who produces this value to later 35866d29a5eSTaylor Simpson * check if it was dynamically cancelled 35966d29a5eSTaylor Simpson */ 36066d29a5eSTaylor Simpson packet->insn[i].new_value_producer_slot = 36166d29a5eSTaylor Simpson packet->insn[def_idx].slot; 36266d29a5eSTaylor Simpson } 36366d29a5eSTaylor Simpson } 36466d29a5eSTaylor Simpson } 36566d29a5eSTaylor Simpson 36666d29a5eSTaylor Simpson /* Split CJ into a compare and a jump */ 36766d29a5eSTaylor Simpson static void decode_split_cmpjump(Packet *pkt) 36866d29a5eSTaylor Simpson { 36966d29a5eSTaylor Simpson int last, i; 37066d29a5eSTaylor Simpson int numinsns = pkt->num_insns; 37166d29a5eSTaylor Simpson 37266d29a5eSTaylor Simpson /* 37366d29a5eSTaylor Simpson * First, split all compare-jumps. 37466d29a5eSTaylor Simpson * The compare is sent to the end as a new instruction. 37566d29a5eSTaylor Simpson * Do it this way so we don't reorder dual jumps. Those need to stay in 37666d29a5eSTaylor Simpson * original order. 37766d29a5eSTaylor Simpson */ 37866d29a5eSTaylor Simpson for (i = 0; i < numinsns; i++) { 37966d29a5eSTaylor Simpson /* It's a cmp-jump */ 38066d29a5eSTaylor Simpson if (GET_ATTRIB(pkt->insn[i].opcode, A_NEWCMPJUMP)) { 38166d29a5eSTaylor Simpson last = pkt->num_insns; 38266d29a5eSTaylor Simpson pkt->insn[last] = pkt->insn[i]; /* copy the instruction */ 38392cfa25fSTaylor Simpson pkt->insn[last].part1 = true; /* last insn does the CMP */ 38492cfa25fSTaylor Simpson pkt->insn[i].part1 = false; /* existing insn does the JUMP */ 38566d29a5eSTaylor Simpson pkt->num_insns++; 38666d29a5eSTaylor Simpson } 38766d29a5eSTaylor Simpson } 38866d29a5eSTaylor Simpson 38966d29a5eSTaylor Simpson /* Now re-shuffle all the compares back to the beginning */ 39066d29a5eSTaylor Simpson for (i = 0; i < pkt->num_insns; i++) { 39166d29a5eSTaylor Simpson if (pkt->insn[i].part1) { 39266d29a5eSTaylor Simpson decode_send_insn_to(pkt, i, 0); 39366d29a5eSTaylor Simpson } 39466d29a5eSTaylor Simpson } 39566d29a5eSTaylor Simpson } 39666d29a5eSTaylor Simpson 39792cfa25fSTaylor Simpson static bool decode_opcode_can_jump(int opcode) 39866d29a5eSTaylor Simpson { 39966d29a5eSTaylor Simpson if ((GET_ATTRIB(opcode, A_JUMP)) || 40066d29a5eSTaylor Simpson (GET_ATTRIB(opcode, A_CALL)) || 40166d29a5eSTaylor Simpson (opcode == J2_trap0) || 40266d29a5eSTaylor Simpson (opcode == J2_pause)) { 40366d29a5eSTaylor Simpson /* Exception to A_JUMP attribute */ 40466d29a5eSTaylor Simpson if (opcode == J4_hintjumpr) { 40592cfa25fSTaylor Simpson return false; 40666d29a5eSTaylor Simpson } 40792cfa25fSTaylor Simpson return true; 40866d29a5eSTaylor Simpson } 40966d29a5eSTaylor Simpson 41092cfa25fSTaylor Simpson return false; 41166d29a5eSTaylor Simpson } 41266d29a5eSTaylor Simpson 41392cfa25fSTaylor Simpson static bool decode_opcode_ends_loop(int opcode) 41466d29a5eSTaylor Simpson { 41566d29a5eSTaylor Simpson return GET_ATTRIB(opcode, A_HWLOOP0_END) || 41666d29a5eSTaylor Simpson GET_ATTRIB(opcode, A_HWLOOP1_END); 41766d29a5eSTaylor Simpson } 41866d29a5eSTaylor Simpson 41966d29a5eSTaylor Simpson /* Set the is_* fields in each instruction */ 42066d29a5eSTaylor Simpson static void decode_set_insn_attr_fields(Packet *pkt) 42166d29a5eSTaylor Simpson { 42266d29a5eSTaylor Simpson int i; 42366d29a5eSTaylor Simpson int numinsns = pkt->num_insns; 42466d29a5eSTaylor Simpson uint16_t opcode; 42566d29a5eSTaylor Simpson 42692cfa25fSTaylor Simpson pkt->pkt_has_cof = false; 427fb67c2bfSTaylor Simpson pkt->pkt_has_multi_cof = false; 42892cfa25fSTaylor Simpson pkt->pkt_has_endloop = false; 42992cfa25fSTaylor Simpson pkt->pkt_has_dczeroa = false; 43066d29a5eSTaylor Simpson 43166d29a5eSTaylor Simpson for (i = 0; i < numinsns; i++) { 43266d29a5eSTaylor Simpson opcode = pkt->insn[i].opcode; 43366d29a5eSTaylor Simpson if (pkt->insn[i].part1) { 43466d29a5eSTaylor Simpson continue; /* Skip compare of cmp-jumps */ 43566d29a5eSTaylor Simpson } 43666d29a5eSTaylor Simpson 43766d29a5eSTaylor Simpson if (GET_ATTRIB(opcode, A_DCZEROA)) { 43892cfa25fSTaylor Simpson pkt->pkt_has_dczeroa = true; 43966d29a5eSTaylor Simpson } 44066d29a5eSTaylor Simpson 44166d29a5eSTaylor Simpson if (GET_ATTRIB(opcode, A_STORE)) { 442e2be9a5cSTaylor Simpson if (GET_ATTRIB(opcode, A_SCALAR_STORE) && 443e2be9a5cSTaylor Simpson !GET_ATTRIB(opcode, A_MEMSIZE_0B)) { 44466d29a5eSTaylor Simpson if (pkt->insn[i].slot == 0) { 44592cfa25fSTaylor Simpson pkt->pkt_has_store_s0 = true; 44666d29a5eSTaylor Simpson } else { 44792cfa25fSTaylor Simpson pkt->pkt_has_store_s1 = true; 44866d29a5eSTaylor Simpson } 44966d29a5eSTaylor Simpson } 450e2be9a5cSTaylor Simpson } 45166d29a5eSTaylor Simpson 452fb67c2bfSTaylor Simpson if (decode_opcode_can_jump(opcode)) { 453fb67c2bfSTaylor Simpson if (pkt->pkt_has_cof) { 454fb67c2bfSTaylor Simpson pkt->pkt_has_multi_cof = true; 455fb67c2bfSTaylor Simpson } 456fb67c2bfSTaylor Simpson pkt->pkt_has_cof = true; 457fb67c2bfSTaylor Simpson } 45866d29a5eSTaylor Simpson 45966d29a5eSTaylor Simpson pkt->insn[i].is_endloop = decode_opcode_ends_loop(opcode); 46066d29a5eSTaylor Simpson 46166d29a5eSTaylor Simpson pkt->pkt_has_endloop |= pkt->insn[i].is_endloop; 46266d29a5eSTaylor Simpson 463fb67c2bfSTaylor Simpson if (pkt->pkt_has_endloop) { 464fb67c2bfSTaylor Simpson if (pkt->pkt_has_cof) { 465fb67c2bfSTaylor Simpson pkt->pkt_has_multi_cof = true; 466fb67c2bfSTaylor Simpson } 467fb67c2bfSTaylor Simpson pkt->pkt_has_cof = true; 468fb67c2bfSTaylor Simpson } 46966d29a5eSTaylor Simpson } 47066d29a5eSTaylor Simpson } 47166d29a5eSTaylor Simpson 47266d29a5eSTaylor Simpson /* 47366d29a5eSTaylor Simpson * Shuffle for execution 47466d29a5eSTaylor Simpson * Move stores to end (in same order as encoding) 47566d29a5eSTaylor Simpson * Move compares to beginning (for use by .new insns) 47666d29a5eSTaylor Simpson */ 47766d29a5eSTaylor Simpson static void decode_shuffle_for_execution(Packet *packet) 47866d29a5eSTaylor Simpson { 47992cfa25fSTaylor Simpson bool changed = false; 48066d29a5eSTaylor Simpson int i; 48192cfa25fSTaylor Simpson bool flag; /* flag means we've seen a non-memory instruction */ 48266d29a5eSTaylor Simpson int n_mems; 48366d29a5eSTaylor Simpson int last_insn = packet->num_insns - 1; 48466d29a5eSTaylor Simpson 48566d29a5eSTaylor Simpson /* 48666d29a5eSTaylor Simpson * Skip end loops, somehow an end loop is getting in and messing 48766d29a5eSTaylor Simpson * up the order 48866d29a5eSTaylor Simpson */ 48966d29a5eSTaylor Simpson if (decode_opcode_ends_loop(packet->insn[last_insn].opcode)) { 49066d29a5eSTaylor Simpson last_insn--; 49166d29a5eSTaylor Simpson } 49266d29a5eSTaylor Simpson 49366d29a5eSTaylor Simpson do { 49492cfa25fSTaylor Simpson changed = false; 49566d29a5eSTaylor Simpson /* 49666d29a5eSTaylor Simpson * Stores go last, must not reorder. 49766d29a5eSTaylor Simpson * Cannot shuffle stores past loads, either. 49866d29a5eSTaylor Simpson * Iterate backwards. If we see a non-memory instruction, 49966d29a5eSTaylor Simpson * then a store, shuffle the store to the front. Don't shuffle 50066d29a5eSTaylor Simpson * stores wrt each other or a load. 50166d29a5eSTaylor Simpson */ 50292cfa25fSTaylor Simpson for (flag = false, n_mems = 0, i = last_insn; i >= 0; i--) { 50366d29a5eSTaylor Simpson int opcode = packet->insn[i].opcode; 50466d29a5eSTaylor Simpson 50566d29a5eSTaylor Simpson if (flag && GET_ATTRIB(opcode, A_STORE)) { 50666d29a5eSTaylor Simpson decode_send_insn_to(packet, i, last_insn - n_mems); 50766d29a5eSTaylor Simpson n_mems++; 50892cfa25fSTaylor Simpson changed = true; 50966d29a5eSTaylor Simpson } else if (GET_ATTRIB(opcode, A_STORE)) { 51066d29a5eSTaylor Simpson n_mems++; 51166d29a5eSTaylor Simpson } else if (GET_ATTRIB(opcode, A_LOAD)) { 51266d29a5eSTaylor Simpson /* 51366d29a5eSTaylor Simpson * Don't set flag, since we don't want to shuffle a 51466d29a5eSTaylor Simpson * store past a load 51566d29a5eSTaylor Simpson */ 51666d29a5eSTaylor Simpson n_mems++; 51766d29a5eSTaylor Simpson } else if (GET_ATTRIB(opcode, A_DOTNEWVALUE)) { 51866d29a5eSTaylor Simpson /* 51966d29a5eSTaylor Simpson * Don't set flag, since we don't want to shuffle past 52066d29a5eSTaylor Simpson * a .new value 52166d29a5eSTaylor Simpson */ 52266d29a5eSTaylor Simpson } else { 52392cfa25fSTaylor Simpson flag = true; 52466d29a5eSTaylor Simpson } 52566d29a5eSTaylor Simpson } 52666d29a5eSTaylor Simpson 52766d29a5eSTaylor Simpson if (changed) { 52866d29a5eSTaylor Simpson continue; 52966d29a5eSTaylor Simpson } 53066d29a5eSTaylor Simpson /* Compares go first, may be reordered wrt each other */ 53192cfa25fSTaylor Simpson for (flag = false, i = 0; i < last_insn + 1; i++) { 53266d29a5eSTaylor Simpson int opcode = packet->insn[i].opcode; 53366d29a5eSTaylor Simpson 53466d29a5eSTaylor Simpson if ((strstr(opcode_wregs[opcode], "Pd4") || 53566d29a5eSTaylor Simpson strstr(opcode_wregs[opcode], "Pe4")) && 53666d29a5eSTaylor Simpson GET_ATTRIB(opcode, A_STORE) == 0) { 53766d29a5eSTaylor Simpson /* This should be a compare (not a store conditional) */ 53866d29a5eSTaylor Simpson if (flag) { 53966d29a5eSTaylor Simpson decode_send_insn_to(packet, i, 0); 54092cfa25fSTaylor Simpson changed = true; 54166d29a5eSTaylor Simpson continue; 54266d29a5eSTaylor Simpson } 54366d29a5eSTaylor Simpson } else if (GET_ATTRIB(opcode, A_IMPLICIT_WRITES_P3) && 54466d29a5eSTaylor Simpson !decode_opcode_ends_loop(packet->insn[i].opcode)) { 54566d29a5eSTaylor Simpson /* 54666d29a5eSTaylor Simpson * spNloop instruction 54766d29a5eSTaylor Simpson * Don't reorder endloops; they are not valid for .new uses, 54866d29a5eSTaylor Simpson * and we want to match HW 54966d29a5eSTaylor Simpson */ 55066d29a5eSTaylor Simpson if (flag) { 55166d29a5eSTaylor Simpson decode_send_insn_to(packet, i, 0); 55292cfa25fSTaylor Simpson changed = true; 55366d29a5eSTaylor Simpson continue; 55466d29a5eSTaylor Simpson } 55566d29a5eSTaylor Simpson } else if (GET_ATTRIB(opcode, A_IMPLICIT_WRITES_P0) && 55666d29a5eSTaylor Simpson !GET_ATTRIB(opcode, A_NEWCMPJUMP)) { 55766d29a5eSTaylor Simpson if (flag) { 55866d29a5eSTaylor Simpson decode_send_insn_to(packet, i, 0); 55992cfa25fSTaylor Simpson changed = true; 56066d29a5eSTaylor Simpson continue; 56166d29a5eSTaylor Simpson } 56266d29a5eSTaylor Simpson } else { 56392cfa25fSTaylor Simpson flag = true; 56466d29a5eSTaylor Simpson } 56566d29a5eSTaylor Simpson } 56666d29a5eSTaylor Simpson if (changed) { 56766d29a5eSTaylor Simpson continue; 56866d29a5eSTaylor Simpson } 56966d29a5eSTaylor Simpson } while (changed); 57066d29a5eSTaylor Simpson 57166d29a5eSTaylor Simpson /* 57266d29a5eSTaylor Simpson * If we have a .new register compare/branch, move that to the very 57366d29a5eSTaylor Simpson * very end, past stores 57466d29a5eSTaylor Simpson */ 57566d29a5eSTaylor Simpson for (i = 0; i < last_insn; i++) { 57666d29a5eSTaylor Simpson if (GET_ATTRIB(packet->insn[i].opcode, A_DOTNEWVALUE)) { 57766d29a5eSTaylor Simpson decode_send_insn_to(packet, i, last_insn); 57866d29a5eSTaylor Simpson break; 57966d29a5eSTaylor Simpson } 58066d29a5eSTaylor Simpson } 58166d29a5eSTaylor Simpson } 58266d29a5eSTaylor Simpson 58366d29a5eSTaylor Simpson static void 58466d29a5eSTaylor Simpson apply_extender(Packet *pkt, int i, uint32_t extender) 58566d29a5eSTaylor Simpson { 58666d29a5eSTaylor Simpson int immed_num; 58766d29a5eSTaylor Simpson uint32_t base_immed; 58866d29a5eSTaylor Simpson 5891547a2d3STaylor Simpson immed_num = pkt->insn[i].which_extended; 5901547a2d3STaylor Simpson g_assert(immed_num == opcode_which_immediate_is_extended(pkt->insn[i].opcode)); 59166d29a5eSTaylor Simpson base_immed = pkt->insn[i].immed[immed_num]; 59266d29a5eSTaylor Simpson 59366d29a5eSTaylor Simpson pkt->insn[i].immed[immed_num] = extender | fZXTN(6, 32, base_immed); 59466d29a5eSTaylor Simpson } 59566d29a5eSTaylor Simpson 59666d29a5eSTaylor Simpson static void decode_apply_extenders(Packet *packet) 59766d29a5eSTaylor Simpson { 59866d29a5eSTaylor Simpson int i; 59966d29a5eSTaylor Simpson for (i = 0; i < packet->num_insns; i++) { 60066d29a5eSTaylor Simpson if (GET_ATTRIB(packet->insn[i].opcode, A_IT_EXTENDER)) { 60192cfa25fSTaylor Simpson packet->insn[i + 1].extension_valid = true; 60266d29a5eSTaylor Simpson apply_extender(packet, i + 1, packet->insn[i].immed[0]); 60366d29a5eSTaylor Simpson } 60466d29a5eSTaylor Simpson } 60566d29a5eSTaylor Simpson } 60666d29a5eSTaylor Simpson 60766d29a5eSTaylor Simpson static void decode_remove_extenders(Packet *packet) 60866d29a5eSTaylor Simpson { 60966d29a5eSTaylor Simpson int i, j; 61066d29a5eSTaylor Simpson for (i = 0; i < packet->num_insns; i++) { 61166d29a5eSTaylor Simpson if (GET_ATTRIB(packet->insn[i].opcode, A_IT_EXTENDER)) { 61266d29a5eSTaylor Simpson /* Remove this one by moving the remaining instructions down */ 61366d29a5eSTaylor Simpson for (j = i; 61466d29a5eSTaylor Simpson (j < packet->num_insns - 1) && (j < INSTRUCTIONS_MAX - 1); 61566d29a5eSTaylor Simpson j++) { 61666d29a5eSTaylor Simpson packet->insn[j] = packet->insn[j + 1]; 61766d29a5eSTaylor Simpson } 61866d29a5eSTaylor Simpson packet->num_insns--; 61966d29a5eSTaylor Simpson } 62066d29a5eSTaylor Simpson } 62166d29a5eSTaylor Simpson } 62266d29a5eSTaylor Simpson 62366d29a5eSTaylor Simpson static SlotMask get_valid_slots(const Packet *pkt, unsigned int slot) 62466d29a5eSTaylor Simpson { 62560d1180bSTaylor Simpson if (GET_ATTRIB(pkt->insn[slot].opcode, A_EXTENSION)) { 62660d1180bSTaylor Simpson return mmvec_ext_decode_find_iclass_slots(pkt->insn[slot].opcode); 62760d1180bSTaylor Simpson } else { 62866d29a5eSTaylor Simpson return find_iclass_slots(pkt->insn[slot].opcode, 62966d29a5eSTaylor Simpson pkt->insn[slot].iclass); 63066d29a5eSTaylor Simpson } 63160d1180bSTaylor Simpson } 63266d29a5eSTaylor Simpson 63366d29a5eSTaylor Simpson #define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT) /* NOTHING */ 63466d29a5eSTaylor Simpson #define TABLE_LINK(TABLE) /* NOTHING */ 63566d29a5eSTaylor Simpson #define TERMINAL(TAG, ENC) /* NOTHING */ 63666d29a5eSTaylor Simpson #define SUBINSNS(TAG, CLASSA, CLASSB, ENC) /* NOTHING */ 63766d29a5eSTaylor Simpson #define EXTSPACE(TAG, ENC) /* NOTHING */ 63866d29a5eSTaylor Simpson #define INVALID() /* NOTHING */ 63966d29a5eSTaylor Simpson #define DECODE_END_TABLE(...) /* NOTHING */ 64066d29a5eSTaylor Simpson #define DECODE_MATCH_INFO(...) /* NOTHING */ 64166d29a5eSTaylor Simpson #define DECODE_LEGACY_MATCH_INFO(...) /* NOTHING */ 64266d29a5eSTaylor Simpson 64366d29a5eSTaylor Simpson #define DECODE_REG(REGNO, WIDTH, STARTBIT) \ 64466d29a5eSTaylor Simpson insn->regno[REGNO] = ((encoding >> STARTBIT) & ((1 << WIDTH) - 1)); 64566d29a5eSTaylor Simpson 64666d29a5eSTaylor Simpson #define DECODE_IMPL_REG(REGNO, VAL) \ 64766d29a5eSTaylor Simpson insn->regno[REGNO] = VAL; 64866d29a5eSTaylor Simpson 64966d29a5eSTaylor Simpson #define DECODE_IMM(IMMNO, WIDTH, STARTBIT, VALSTART) \ 65066d29a5eSTaylor Simpson insn->immed[IMMNO] |= (((encoding >> STARTBIT) & ((1 << WIDTH) - 1))) << \ 65166d29a5eSTaylor Simpson (VALSTART); 65266d29a5eSTaylor Simpson 65366d29a5eSTaylor Simpson #define DECODE_IMM_SXT(IMMNO, WIDTH) \ 65466d29a5eSTaylor Simpson insn->immed[IMMNO] = ((((int32_t)insn->immed[IMMNO]) << (32 - WIDTH)) >> \ 65566d29a5eSTaylor Simpson (32 - WIDTH)); 65666d29a5eSTaylor Simpson 65766d29a5eSTaylor Simpson #define DECODE_IMM_NEG(IMMNO, WIDTH) \ 65866d29a5eSTaylor Simpson insn->immed[IMMNO] = -insn->immed[IMMNO]; 65966d29a5eSTaylor Simpson 66066d29a5eSTaylor Simpson #define DECODE_IMM_SHIFT(IMMNO, SHAMT) \ 66166d29a5eSTaylor Simpson if ((!insn->extension_valid) || \ 66266d29a5eSTaylor Simpson (insn->which_extended != IMMNO)) { \ 66366d29a5eSTaylor Simpson insn->immed[IMMNO] <<= SHAMT; \ 66466d29a5eSTaylor Simpson } 66566d29a5eSTaylor Simpson 66666d29a5eSTaylor Simpson #define DECODE_OPINFO(TAG, BEH) \ 66766d29a5eSTaylor Simpson case TAG: \ 66866d29a5eSTaylor Simpson { BEH } \ 66966d29a5eSTaylor Simpson break; \ 67066d29a5eSTaylor Simpson 67166d29a5eSTaylor Simpson /* 67266d29a5eSTaylor Simpson * Fill in the operands of the instruction 67366d29a5eSTaylor Simpson * dectree_generated.h.inc has a DECODE_OPINFO entry for each opcode 67466d29a5eSTaylor Simpson * For example, 67566d29a5eSTaylor Simpson * DECODE_OPINFO(A2_addi, 67666d29a5eSTaylor Simpson * DECODE_REG(0,5,0) 67766d29a5eSTaylor Simpson * DECODE_REG(1,5,16) 67866d29a5eSTaylor Simpson * DECODE_IMM(0,7,21,9) 67966d29a5eSTaylor Simpson * DECODE_IMM(0,9,5,0) 68066d29a5eSTaylor Simpson * DECODE_IMM_SXT(0,16) 68166d29a5eSTaylor Simpson * with the macros defined above, we'll fill in a switch statement 68266d29a5eSTaylor Simpson * where each case is an opcode tag. 68366d29a5eSTaylor Simpson */ 68466d29a5eSTaylor Simpson static void 68566d29a5eSTaylor Simpson decode_op(Insn *insn, Opcode tag, uint32_t encoding) 68666d29a5eSTaylor Simpson { 68766d29a5eSTaylor Simpson insn->immed[0] = 0; 68866d29a5eSTaylor Simpson insn->immed[1] = 0; 68966d29a5eSTaylor Simpson insn->opcode = tag; 69066d29a5eSTaylor Simpson if (insn->extension_valid) { 69166d29a5eSTaylor Simpson insn->which_extended = opcode_which_immediate_is_extended(tag); 69266d29a5eSTaylor Simpson } 69366d29a5eSTaylor Simpson 69466d29a5eSTaylor Simpson switch (tag) { 69566d29a5eSTaylor Simpson #include "dectree_generated.h.inc" 69666d29a5eSTaylor Simpson default: 69766d29a5eSTaylor Simpson break; 69866d29a5eSTaylor Simpson } 69966d29a5eSTaylor Simpson 70066d29a5eSTaylor Simpson insn->generate = opcode_genptr[tag]; 70166d29a5eSTaylor Simpson 70266d29a5eSTaylor Simpson insn->iclass = iclass_bits(encoding); 70366d29a5eSTaylor Simpson } 70466d29a5eSTaylor Simpson 70566d29a5eSTaylor Simpson #undef DECODE_REG 70666d29a5eSTaylor Simpson #undef DECODE_IMPL_REG 70766d29a5eSTaylor Simpson #undef DECODE_IMM 70866d29a5eSTaylor Simpson #undef DECODE_IMM_SHIFT 70966d29a5eSTaylor Simpson #undef DECODE_OPINFO 71066d29a5eSTaylor Simpson #undef DECODE_MATCH_INFO 71166d29a5eSTaylor Simpson #undef DECODE_LEGACY_MATCH_INFO 71266d29a5eSTaylor Simpson #undef DECODE_END_TABLE 71366d29a5eSTaylor Simpson #undef INVALID 71466d29a5eSTaylor Simpson #undef TERMINAL 71566d29a5eSTaylor Simpson #undef SUBINSNS 71666d29a5eSTaylor Simpson #undef EXTSPACE 71766d29a5eSTaylor Simpson #undef TABLE_LINK 71866d29a5eSTaylor Simpson #undef DECODE_NEW_TABLE 71966d29a5eSTaylor Simpson #undef DECODE_SEPARATOR_BITS 72066d29a5eSTaylor Simpson 72166d29a5eSTaylor Simpson static unsigned int 72266d29a5eSTaylor Simpson decode_subinsn_tablewalk(Insn *insn, const DectreeTable *table, 72366d29a5eSTaylor Simpson uint32_t encoding) 72466d29a5eSTaylor Simpson { 72566d29a5eSTaylor Simpson unsigned int i; 72666d29a5eSTaylor Simpson Opcode opc; 72766d29a5eSTaylor Simpson if (table->lookup_function) { 72866d29a5eSTaylor Simpson i = table->lookup_function(table->startbit, table->width, encoding); 72966d29a5eSTaylor Simpson } else { 73066d29a5eSTaylor Simpson i = extract32(encoding, table->startbit, table->width); 73166d29a5eSTaylor Simpson } 73266d29a5eSTaylor Simpson if (table->table[i].type == DECTREE_TABLE_LINK) { 73366d29a5eSTaylor Simpson return decode_subinsn_tablewalk(insn, table->table[i].table_link, 73466d29a5eSTaylor Simpson encoding); 73566d29a5eSTaylor Simpson } else if (table->table[i].type == DECTREE_TERMINAL) { 73666d29a5eSTaylor Simpson opc = table->table[i].opcode; 73766d29a5eSTaylor Simpson if ((encoding & decode_itable[opc].mask) != decode_itable[opc].match) { 73866d29a5eSTaylor Simpson return 0; 73966d29a5eSTaylor Simpson } 74066d29a5eSTaylor Simpson decode_op(insn, opc, encoding); 74166d29a5eSTaylor Simpson return 1; 74266d29a5eSTaylor Simpson } else { 74366d29a5eSTaylor Simpson return 0; 74466d29a5eSTaylor Simpson } 74566d29a5eSTaylor Simpson } 74666d29a5eSTaylor Simpson 74766d29a5eSTaylor Simpson static unsigned int get_insn_a(uint32_t encoding) 74866d29a5eSTaylor Simpson { 74966d29a5eSTaylor Simpson return extract32(encoding, 0, 13); 75066d29a5eSTaylor Simpson } 75166d29a5eSTaylor Simpson 75266d29a5eSTaylor Simpson static unsigned int get_insn_b(uint32_t encoding) 75366d29a5eSTaylor Simpson { 75466d29a5eSTaylor Simpson return extract32(encoding, 16, 13); 75566d29a5eSTaylor Simpson } 75666d29a5eSTaylor Simpson 75766d29a5eSTaylor Simpson static unsigned int 75866d29a5eSTaylor Simpson decode_insns_tablewalk(Insn *insn, const DectreeTable *table, 75966d29a5eSTaylor Simpson uint32_t encoding) 76066d29a5eSTaylor Simpson { 76166d29a5eSTaylor Simpson unsigned int i; 76266d29a5eSTaylor Simpson unsigned int a, b; 76366d29a5eSTaylor Simpson Opcode opc; 76466d29a5eSTaylor Simpson if (table->lookup_function) { 76566d29a5eSTaylor Simpson i = table->lookup_function(table->startbit, table->width, encoding); 76666d29a5eSTaylor Simpson } else { 76766d29a5eSTaylor Simpson i = extract32(encoding, table->startbit, table->width); 76866d29a5eSTaylor Simpson } 76966d29a5eSTaylor Simpson if (table->table[i].type == DECTREE_TABLE_LINK) { 77066d29a5eSTaylor Simpson return decode_insns_tablewalk(insn, table->table[i].table_link, 77166d29a5eSTaylor Simpson encoding); 77266d29a5eSTaylor Simpson } else if (table->table[i].type == DECTREE_SUBINSNS) { 77366d29a5eSTaylor Simpson a = get_insn_a(encoding); 77466d29a5eSTaylor Simpson b = get_insn_b(encoding); 77566d29a5eSTaylor Simpson b = decode_subinsn_tablewalk(insn, table->table[i].table_link_b, b); 77666d29a5eSTaylor Simpson a = decode_subinsn_tablewalk(insn + 1, table->table[i].table_link, a); 77766d29a5eSTaylor Simpson if ((a == 0) || (b == 0)) { 77866d29a5eSTaylor Simpson return 0; 77966d29a5eSTaylor Simpson } 78066d29a5eSTaylor Simpson return 2; 78166d29a5eSTaylor Simpson } else if (table->table[i].type == DECTREE_TERMINAL) { 78266d29a5eSTaylor Simpson opc = table->table[i].opcode; 78366d29a5eSTaylor Simpson if ((encoding & decode_itable[opc].mask) != decode_itable[opc].match) { 78466d29a5eSTaylor Simpson if ((encoding & decode_legacy_itable[opc].mask) != 78566d29a5eSTaylor Simpson decode_legacy_itable[opc].match) { 78666d29a5eSTaylor Simpson return 0; 78766d29a5eSTaylor Simpson } 78866d29a5eSTaylor Simpson } 78966d29a5eSTaylor Simpson decode_op(insn, opc, encoding); 79066d29a5eSTaylor Simpson return 1; 79160d1180bSTaylor Simpson } else if (table->table[i].type == DECTREE_EXTSPACE) { 79260d1180bSTaylor Simpson /* 79360d1180bSTaylor Simpson * For now, HVX will be the only coproc 79460d1180bSTaylor Simpson */ 79560d1180bSTaylor Simpson return decode_insns_tablewalk(insn, ext_trees[EXT_IDX_mmvec], encoding); 79666d29a5eSTaylor Simpson } else { 79766d29a5eSTaylor Simpson return 0; 79866d29a5eSTaylor Simpson } 79966d29a5eSTaylor Simpson } 80066d29a5eSTaylor Simpson 801*f6c01009STaylor Simpson /* 802*f6c01009STaylor Simpson * Section 10.3 of the Hexagon V73 Programmer's Reference Manual 803*f6c01009STaylor Simpson * 804*f6c01009STaylor Simpson * A duplex is encoded as a 32-bit instruction with bits [15:14] set to 00. 805*f6c01009STaylor Simpson * The sub-instructions that comprise a duplex are encoded as 13-bit fields 806*f6c01009STaylor Simpson * in the duplex. 807*f6c01009STaylor Simpson * 808*f6c01009STaylor Simpson * Per table 10-4, the 4-bit duplex iclass is encoded in bits 31:29, 13 809*f6c01009STaylor Simpson */ 810*f6c01009STaylor Simpson static uint32_t get_duplex_iclass(uint32_t encoding) 811*f6c01009STaylor Simpson { 812*f6c01009STaylor Simpson uint32_t iclass = extract32(encoding, 13, 1); 813*f6c01009STaylor Simpson iclass = deposit32(iclass, 1, 3, extract32(encoding, 29, 3)); 814*f6c01009STaylor Simpson return iclass; 815*f6c01009STaylor Simpson } 816*f6c01009STaylor Simpson 817*f6c01009STaylor Simpson /* 818*f6c01009STaylor Simpson * Per table 10-5, the duplex ICLASS field values that specify the group of 819*f6c01009STaylor Simpson * each sub-instruction in a duplex 820*f6c01009STaylor Simpson * 821*f6c01009STaylor Simpson * This table points to the decode instruction for each entry in the table 822*f6c01009STaylor Simpson */ 823*f6c01009STaylor Simpson typedef bool (*subinsn_decode_func)(DisasContext *ctx, uint16_t insn); 824*f6c01009STaylor Simpson typedef struct { 825*f6c01009STaylor Simpson subinsn_decode_func decode_slot0_subinsn; 826*f6c01009STaylor Simpson subinsn_decode_func decode_slot1_subinsn; 827*f6c01009STaylor Simpson } subinsn_decode_groups; 828*f6c01009STaylor Simpson 829*f6c01009STaylor Simpson static const subinsn_decode_groups decode_groups[16] = { 830*f6c01009STaylor Simpson [0x0] = { decode_subinsn_l1, decode_subinsn_l1 }, 831*f6c01009STaylor Simpson [0x1] = { decode_subinsn_l2, decode_subinsn_l1 }, 832*f6c01009STaylor Simpson [0x2] = { decode_subinsn_l2, decode_subinsn_l2 }, 833*f6c01009STaylor Simpson [0x3] = { decode_subinsn_a, decode_subinsn_a }, 834*f6c01009STaylor Simpson [0x4] = { decode_subinsn_l1, decode_subinsn_a }, 835*f6c01009STaylor Simpson [0x5] = { decode_subinsn_l2, decode_subinsn_a }, 836*f6c01009STaylor Simpson [0x6] = { decode_subinsn_s1, decode_subinsn_a }, 837*f6c01009STaylor Simpson [0x7] = { decode_subinsn_s2, decode_subinsn_a }, 838*f6c01009STaylor Simpson [0x8] = { decode_subinsn_s1, decode_subinsn_l1 }, 839*f6c01009STaylor Simpson [0x9] = { decode_subinsn_s1, decode_subinsn_l2 }, 840*f6c01009STaylor Simpson [0xa] = { decode_subinsn_s1, decode_subinsn_s1 }, 841*f6c01009STaylor Simpson [0xb] = { decode_subinsn_s2, decode_subinsn_s1 }, 842*f6c01009STaylor Simpson [0xc] = { decode_subinsn_s2, decode_subinsn_l1 }, 843*f6c01009STaylor Simpson [0xd] = { decode_subinsn_s2, decode_subinsn_l2 }, 844*f6c01009STaylor Simpson [0xe] = { decode_subinsn_s2, decode_subinsn_s2 }, 845*f6c01009STaylor Simpson [0xf] = { NULL, NULL }, /* Reserved */ 846*f6c01009STaylor Simpson }; 847*f6c01009STaylor Simpson 848*f6c01009STaylor Simpson static uint16_t get_slot0_subinsn(uint32_t encoding) 849*f6c01009STaylor Simpson { 850*f6c01009STaylor Simpson return extract32(encoding, 0, 13); 851*f6c01009STaylor Simpson } 852*f6c01009STaylor Simpson 853*f6c01009STaylor Simpson static uint16_t get_slot1_subinsn(uint32_t encoding) 854*f6c01009STaylor Simpson { 855*f6c01009STaylor Simpson return extract32(encoding, 16, 13); 856*f6c01009STaylor Simpson } 857*f6c01009STaylor Simpson 85866d29a5eSTaylor Simpson static unsigned int 8591547a2d3STaylor Simpson decode_insns(DisasContext *ctx, Insn *insn, uint32_t encoding) 86066d29a5eSTaylor Simpson { 86166d29a5eSTaylor Simpson const DectreeTable *table; 86266d29a5eSTaylor Simpson if (parse_bits(encoding) != 0) { 8631547a2d3STaylor Simpson if (decode_normal(ctx, encoding) || 8641547a2d3STaylor Simpson decode_hvx(ctx, encoding)) { 8651547a2d3STaylor Simpson insn->generate = opcode_genptr[insn->opcode]; 8661547a2d3STaylor Simpson insn->iclass = iclass_bits(encoding); 8671547a2d3STaylor Simpson return 1; 8681547a2d3STaylor Simpson } 86966d29a5eSTaylor Simpson /* Start with PP table - 32 bit instructions */ 87066d29a5eSTaylor Simpson table = &dectree_table_DECODE_ROOT_32; 8711547a2d3STaylor Simpson g_assert_not_reached(); 87266d29a5eSTaylor Simpson } else { 873*f6c01009STaylor Simpson uint32_t iclass = get_duplex_iclass(encoding); 874*f6c01009STaylor Simpson unsigned int slot0_subinsn = get_slot0_subinsn(encoding); 875*f6c01009STaylor Simpson unsigned int slot1_subinsn = get_slot1_subinsn(encoding); 876*f6c01009STaylor Simpson subinsn_decode_func decode_slot0_subinsn = 877*f6c01009STaylor Simpson decode_groups[iclass].decode_slot0_subinsn; 878*f6c01009STaylor Simpson subinsn_decode_func decode_slot1_subinsn = 879*f6c01009STaylor Simpson decode_groups[iclass].decode_slot1_subinsn; 880*f6c01009STaylor Simpson 881*f6c01009STaylor Simpson /* The slot1 subinsn needs to be in the packet first */ 882*f6c01009STaylor Simpson if (decode_slot1_subinsn(ctx, slot1_subinsn)) { 883*f6c01009STaylor Simpson insn->generate = opcode_genptr[insn->opcode]; 884*f6c01009STaylor Simpson insn->iclass = iclass_bits(encoding); 885*f6c01009STaylor Simpson ctx->insn = ++insn; 886*f6c01009STaylor Simpson if (decode_slot0_subinsn(ctx, slot0_subinsn)) { 887*f6c01009STaylor Simpson insn->generate = opcode_genptr[insn->opcode]; 888*f6c01009STaylor Simpson insn->iclass = iclass_bits(encoding); 889*f6c01009STaylor Simpson return 2; 890*f6c01009STaylor Simpson } 891*f6c01009STaylor Simpson } 89266d29a5eSTaylor Simpson /* start with EE table - duplex instructions */ 89366d29a5eSTaylor Simpson table = &dectree_table_DECODE_ROOT_EE; 894*f6c01009STaylor Simpson g_assert_not_reached(); 89566d29a5eSTaylor Simpson } 89666d29a5eSTaylor Simpson return decode_insns_tablewalk(insn, table, encoding); 89766d29a5eSTaylor Simpson } 89866d29a5eSTaylor Simpson 89966d29a5eSTaylor Simpson static void decode_add_endloop_insn(Insn *insn, int loopnum) 90066d29a5eSTaylor Simpson { 90166d29a5eSTaylor Simpson if (loopnum == 10) { 90266d29a5eSTaylor Simpson insn->opcode = J2_endloop01; 90366d29a5eSTaylor Simpson insn->generate = opcode_genptr[J2_endloop01]; 90466d29a5eSTaylor Simpson } else if (loopnum == 1) { 90566d29a5eSTaylor Simpson insn->opcode = J2_endloop1; 90666d29a5eSTaylor Simpson insn->generate = opcode_genptr[J2_endloop1]; 90766d29a5eSTaylor Simpson } else if (loopnum == 0) { 90866d29a5eSTaylor Simpson insn->opcode = J2_endloop0; 90966d29a5eSTaylor Simpson insn->generate = opcode_genptr[J2_endloop0]; 91066d29a5eSTaylor Simpson } else { 91166d29a5eSTaylor Simpson g_assert_not_reached(); 91266d29a5eSTaylor Simpson } 91366d29a5eSTaylor Simpson } 91466d29a5eSTaylor Simpson 91592cfa25fSTaylor Simpson static bool decode_parsebits_is_loopend(uint32_t encoding32) 91666d29a5eSTaylor Simpson { 91766d29a5eSTaylor Simpson uint32_t bits = parse_bits(encoding32); 91866d29a5eSTaylor Simpson return bits == 0x2; 91966d29a5eSTaylor Simpson } 92066d29a5eSTaylor Simpson 92114edcf11SMatheus Tavares Bernardino static bool has_valid_slot_assignment(Packet *pkt) 92214edcf11SMatheus Tavares Bernardino { 92314edcf11SMatheus Tavares Bernardino int used_slots = 0; 92414edcf11SMatheus Tavares Bernardino for (int i = 0; i < pkt->num_insns; i++) { 92514edcf11SMatheus Tavares Bernardino int slot_mask; 92614edcf11SMatheus Tavares Bernardino Insn *insn = &pkt->insn[i]; 92714edcf11SMatheus Tavares Bernardino if (decode_opcode_ends_loop(insn->opcode)) { 92814edcf11SMatheus Tavares Bernardino /* We overload slot 0 for endloop. */ 92914edcf11SMatheus Tavares Bernardino continue; 93014edcf11SMatheus Tavares Bernardino } 93114edcf11SMatheus Tavares Bernardino slot_mask = 1 << insn->slot; 93214edcf11SMatheus Tavares Bernardino if (used_slots & slot_mask) { 93314edcf11SMatheus Tavares Bernardino return false; 93414edcf11SMatheus Tavares Bernardino } 93514edcf11SMatheus Tavares Bernardino used_slots |= slot_mask; 93614edcf11SMatheus Tavares Bernardino } 93714edcf11SMatheus Tavares Bernardino return true; 93814edcf11SMatheus Tavares Bernardino } 93914edcf11SMatheus Tavares Bernardino 94014edcf11SMatheus Tavares Bernardino static bool 94166d29a5eSTaylor Simpson decode_set_slot_number(Packet *pkt) 94266d29a5eSTaylor Simpson { 94366d29a5eSTaylor Simpson int slot; 94466d29a5eSTaylor Simpson int i; 94592cfa25fSTaylor Simpson bool hit_mem_insn = false; 94692cfa25fSTaylor Simpson bool hit_duplex = false; 94792cfa25fSTaylor Simpson bool slot0_found = false; 94892cfa25fSTaylor Simpson bool slot1_found = false; 94992cfa25fSTaylor Simpson int slot1_iidx = 0; 95066d29a5eSTaylor Simpson 95166d29a5eSTaylor Simpson /* 95266d29a5eSTaylor Simpson * The slots are encoded in reverse order 95366d29a5eSTaylor Simpson * For each instruction, count down until you find a suitable slot 95466d29a5eSTaylor Simpson */ 95566d29a5eSTaylor Simpson for (i = 0, slot = 3; i < pkt->num_insns; i++) { 95666d29a5eSTaylor Simpson SlotMask valid_slots = get_valid_slots(pkt, i); 95766d29a5eSTaylor Simpson 95866d29a5eSTaylor Simpson while (!(valid_slots & (1 << slot))) { 95966d29a5eSTaylor Simpson slot--; 96066d29a5eSTaylor Simpson } 96166d29a5eSTaylor Simpson pkt->insn[i].slot = slot; 96266d29a5eSTaylor Simpson if (slot) { 96366d29a5eSTaylor Simpson /* I've assigned the slot, now decrement it for the next insn */ 96466d29a5eSTaylor Simpson slot--; 96566d29a5eSTaylor Simpson } 96666d29a5eSTaylor Simpson } 96766d29a5eSTaylor Simpson 96866d29a5eSTaylor Simpson /* Fix the exceptions - mem insns to slot 0,1 */ 96966d29a5eSTaylor Simpson for (i = pkt->num_insns - 1; i >= 0; i--) { 97066d29a5eSTaylor Simpson /* First memory instruction always goes to slot 0 */ 97166d29a5eSTaylor Simpson if ((GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE) || 97266d29a5eSTaylor Simpson GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE_PACKET_RULES)) && 97366d29a5eSTaylor Simpson !hit_mem_insn) { 97492cfa25fSTaylor Simpson hit_mem_insn = true; 97566d29a5eSTaylor Simpson pkt->insn[i].slot = 0; 97666d29a5eSTaylor Simpson continue; 97766d29a5eSTaylor Simpson } 97866d29a5eSTaylor Simpson 97966d29a5eSTaylor Simpson /* Next memory instruction always goes to slot 1 */ 98066d29a5eSTaylor Simpson if ((GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE) || 98166d29a5eSTaylor Simpson GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE_PACKET_RULES)) && 98266d29a5eSTaylor Simpson hit_mem_insn) { 98366d29a5eSTaylor Simpson pkt->insn[i].slot = 1; 98466d29a5eSTaylor Simpson } 98566d29a5eSTaylor Simpson } 98666d29a5eSTaylor Simpson 98766d29a5eSTaylor Simpson /* Fix the exceptions - duplex always slot 0,1 */ 98866d29a5eSTaylor Simpson for (i = pkt->num_insns - 1; i >= 0; i--) { 98966d29a5eSTaylor Simpson /* First subinsn always goes to slot 0 */ 99066d29a5eSTaylor Simpson if (GET_ATTRIB(pkt->insn[i].opcode, A_SUBINSN) && !hit_duplex) { 99192cfa25fSTaylor Simpson hit_duplex = true; 99266d29a5eSTaylor Simpson pkt->insn[i].slot = 0; 99366d29a5eSTaylor Simpson continue; 99466d29a5eSTaylor Simpson } 99566d29a5eSTaylor Simpson 99666d29a5eSTaylor Simpson /* Next subinsn always goes to slot 1 */ 99766d29a5eSTaylor Simpson if (GET_ATTRIB(pkt->insn[i].opcode, A_SUBINSN) && hit_duplex) { 99866d29a5eSTaylor Simpson pkt->insn[i].slot = 1; 99966d29a5eSTaylor Simpson } 100066d29a5eSTaylor Simpson } 100166d29a5eSTaylor Simpson 100266d29a5eSTaylor Simpson /* Fix the exceptions - slot 1 is never empty, always aligns to slot 0 */ 100366d29a5eSTaylor Simpson for (i = pkt->num_insns - 1; i >= 0; i--) { 100466d29a5eSTaylor Simpson /* Is slot0 used? */ 100566d29a5eSTaylor Simpson if (pkt->insn[i].slot == 0) { 100692cfa25fSTaylor Simpson bool is_endloop = (pkt->insn[i].opcode == J2_endloop01); 100766d29a5eSTaylor Simpson is_endloop |= (pkt->insn[i].opcode == J2_endloop0); 100866d29a5eSTaylor Simpson is_endloop |= (pkt->insn[i].opcode == J2_endloop1); 100966d29a5eSTaylor Simpson 101066d29a5eSTaylor Simpson /* 101166d29a5eSTaylor Simpson * Make sure it's not endloop since, we're overloading 101266d29a5eSTaylor Simpson * slot0 for endloop 101366d29a5eSTaylor Simpson */ 101466d29a5eSTaylor Simpson if (!is_endloop) { 101592cfa25fSTaylor Simpson slot0_found = true; 101666d29a5eSTaylor Simpson } 101766d29a5eSTaylor Simpson } 101866d29a5eSTaylor Simpson /* Is slot1 used? */ 101966d29a5eSTaylor Simpson if (pkt->insn[i].slot == 1) { 102092cfa25fSTaylor Simpson slot1_found = true; 102166d29a5eSTaylor Simpson slot1_iidx = i; 102266d29a5eSTaylor Simpson } 102366d29a5eSTaylor Simpson } 102466d29a5eSTaylor Simpson /* Is slot0 empty and slot1 used? */ 102592cfa25fSTaylor Simpson if ((!slot0_found) && slot1_found) { 102666d29a5eSTaylor Simpson /* Then push it to slot0 */ 102766d29a5eSTaylor Simpson pkt->insn[slot1_iidx].slot = 0; 102866d29a5eSTaylor Simpson } 102914edcf11SMatheus Tavares Bernardino 103014edcf11SMatheus Tavares Bernardino return has_valid_slot_assignment(pkt); 103166d29a5eSTaylor Simpson } 103266d29a5eSTaylor Simpson 103366d29a5eSTaylor Simpson /* 103466d29a5eSTaylor Simpson * decode_packet 103566d29a5eSTaylor Simpson * Decodes packet with given words 103666d29a5eSTaylor Simpson * Returns 0 on insufficient words, 103766d29a5eSTaylor Simpson * or number of words used on success 103866d29a5eSTaylor Simpson */ 103966d29a5eSTaylor Simpson 10401547a2d3STaylor Simpson int decode_packet(DisasContext *ctx, int max_words, const uint32_t *words, 10411547a2d3STaylor Simpson Packet *pkt, bool disas_only) 104266d29a5eSTaylor Simpson { 104366d29a5eSTaylor Simpson int num_insns = 0; 104466d29a5eSTaylor Simpson int words_read = 0; 104592cfa25fSTaylor Simpson bool end_of_packet = false; 104666d29a5eSTaylor Simpson int new_insns = 0; 104760d1180bSTaylor Simpson int i; 104866d29a5eSTaylor Simpson uint32_t encoding32; 104966d29a5eSTaylor Simpson 105066d29a5eSTaylor Simpson /* Initialize */ 105166d29a5eSTaylor Simpson memset(pkt, 0, sizeof(*pkt)); 105266d29a5eSTaylor Simpson /* Try to build packet */ 105366d29a5eSTaylor Simpson while (!end_of_packet && (words_read < max_words)) { 10541547a2d3STaylor Simpson Insn *insn = &pkt->insn[num_insns]; 10551547a2d3STaylor Simpson ctx->insn = insn; 105666d29a5eSTaylor Simpson encoding32 = words[words_read]; 105766d29a5eSTaylor Simpson end_of_packet = is_packet_end(encoding32); 10581547a2d3STaylor Simpson new_insns = decode_insns(ctx, insn, encoding32); 105966d29a5eSTaylor Simpson g_assert(new_insns > 0); 106066d29a5eSTaylor Simpson /* 106166d29a5eSTaylor Simpson * If we saw an extender, mark next word extended so immediate 106266d29a5eSTaylor Simpson * decode works 106366d29a5eSTaylor Simpson */ 106466d29a5eSTaylor Simpson if (pkt->insn[num_insns].opcode == A4_ext) { 106592cfa25fSTaylor Simpson pkt->insn[num_insns + 1].extension_valid = true; 106666d29a5eSTaylor Simpson } 106766d29a5eSTaylor Simpson num_insns += new_insns; 106866d29a5eSTaylor Simpson words_read++; 106966d29a5eSTaylor Simpson } 107066d29a5eSTaylor Simpson 107166d29a5eSTaylor Simpson pkt->num_insns = num_insns; 107266d29a5eSTaylor Simpson if (!end_of_packet) { 107366d29a5eSTaylor Simpson /* Ran out of words! */ 107466d29a5eSTaylor Simpson return 0; 107566d29a5eSTaylor Simpson } 107666d29a5eSTaylor Simpson pkt->encod_pkt_size_in_bytes = words_read * 4; 107760d1180bSTaylor Simpson pkt->pkt_has_hvx = false; 107860d1180bSTaylor Simpson for (i = 0; i < num_insns; i++) { 107960d1180bSTaylor Simpson pkt->pkt_has_hvx |= 108060d1180bSTaylor Simpson GET_ATTRIB(pkt->insn[i].opcode, A_CVI); 108160d1180bSTaylor Simpson } 108266d29a5eSTaylor Simpson 108366d29a5eSTaylor Simpson /* 108466d29a5eSTaylor Simpson * Check for :endloop in the parse bits 108566d29a5eSTaylor Simpson * Section 10.6 of the Programmer's Reference describes the encoding 108666d29a5eSTaylor Simpson * The end of hardware loop 0 can be encoded with 2 words 108766d29a5eSTaylor Simpson * The end of hardware loop 1 needs 3 words 108866d29a5eSTaylor Simpson */ 108966d29a5eSTaylor Simpson if ((words_read == 2) && (decode_parsebits_is_loopend(words[0]))) { 109066d29a5eSTaylor Simpson decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 0); 109166d29a5eSTaylor Simpson } 109266d29a5eSTaylor Simpson if (words_read >= 3) { 109392cfa25fSTaylor Simpson bool has_loop0, has_loop1; 109466d29a5eSTaylor Simpson has_loop0 = decode_parsebits_is_loopend(words[0]); 109566d29a5eSTaylor Simpson has_loop1 = decode_parsebits_is_loopend(words[1]); 109666d29a5eSTaylor Simpson if (has_loop0 && has_loop1) { 109766d29a5eSTaylor Simpson decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 10); 109866d29a5eSTaylor Simpson } else if (has_loop1) { 109966d29a5eSTaylor Simpson decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 1); 110066d29a5eSTaylor Simpson } else if (has_loop0) { 110166d29a5eSTaylor Simpson decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 0); 110266d29a5eSTaylor Simpson } 110366d29a5eSTaylor Simpson } 110466d29a5eSTaylor Simpson 110566d29a5eSTaylor Simpson decode_apply_extenders(pkt); 110666d29a5eSTaylor Simpson if (!disas_only) { 110766d29a5eSTaylor Simpson decode_remove_extenders(pkt); 110814edcf11SMatheus Tavares Bernardino if (!decode_set_slot_number(pkt)) { 110914edcf11SMatheus Tavares Bernardino /* Invalid packet */ 111014edcf11SMatheus Tavares Bernardino return 0; 111166d29a5eSTaylor Simpson } 111214edcf11SMatheus Tavares Bernardino } 111366d29a5eSTaylor Simpson decode_fill_newvalue_regno(pkt); 111466d29a5eSTaylor Simpson 111560d1180bSTaylor Simpson if (pkt->pkt_has_hvx) { 111660d1180bSTaylor Simpson mmvec_ext_decode_checks(pkt, disas_only); 111760d1180bSTaylor Simpson } 111860d1180bSTaylor Simpson 111966d29a5eSTaylor Simpson if (!disas_only) { 112066d29a5eSTaylor Simpson decode_shuffle_for_execution(pkt); 112166d29a5eSTaylor Simpson decode_split_cmpjump(pkt); 112266d29a5eSTaylor Simpson decode_set_insn_attr_fields(pkt); 112366d29a5eSTaylor Simpson } 112466d29a5eSTaylor Simpson 112566d29a5eSTaylor Simpson return words_read; 112666d29a5eSTaylor Simpson } 112766d29a5eSTaylor Simpson 112866d29a5eSTaylor Simpson /* Used for "-d in_asm" logging */ 112966d29a5eSTaylor Simpson int disassemble_hexagon(uint32_t *words, int nwords, bfd_vma pc, 113066d29a5eSTaylor Simpson GString *buf) 113166d29a5eSTaylor Simpson { 11321547a2d3STaylor Simpson DisasContext ctx; 113366d29a5eSTaylor Simpson Packet pkt; 113466d29a5eSTaylor Simpson 11351547a2d3STaylor Simpson memset(&ctx, 0, sizeof(DisasContext)); 11361547a2d3STaylor Simpson ctx.pkt = &pkt; 11371547a2d3STaylor Simpson 11381547a2d3STaylor Simpson if (decode_packet(&ctx, nwords, words, &pkt, true) > 0) { 113966d29a5eSTaylor Simpson snprint_a_pkt_disas(buf, &pkt, words, pc); 114066d29a5eSTaylor Simpson return pkt.encod_pkt_size_in_bytes; 114166d29a5eSTaylor Simpson } else { 114266d29a5eSTaylor Simpson g_string_assign(buf, "<invalid>"); 114366d29a5eSTaylor Simpson return 0; 114466d29a5eSTaylor Simpson } 114566d29a5eSTaylor Simpson } 1146