2021-02-08 06:46:03 +01:00
|
|
|
/*
|
|
|
|
* Copyright(c) 2019-2021 Qualcomm Innovation Center, Inc. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "qemu/osdep.h"
|
|
|
|
#include "qemu/log.h"
|
|
|
|
#include "iclass.h"
|
|
|
|
#include "attribs.h"
|
|
|
|
#include "genptr.h"
|
|
|
|
#include "decode.h"
|
|
|
|
#include "insn.h"
|
|
|
|
#include "printinsn.h"
|
|
|
|
|
|
|
|
#define fZXTN(N, M, VAL) ((VAL) & ((1LL << (N)) - 1))
|
|
|
|
|
|
|
|
enum {
|
|
|
|
EXT_IDX_noext = 0,
|
|
|
|
EXT_IDX_noext_AFTER = 4,
|
|
|
|
EXT_IDX_mmvec = 4,
|
|
|
|
EXT_IDX_mmvec_AFTER = 8,
|
|
|
|
XX_LAST_EXT_IDX
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Certain operand types represent a non-contiguous set of values.
|
|
|
|
* For example, the compound compare-and-jump instruction can only access
|
|
|
|
* registers R0-R7 and R16-23.
|
|
|
|
* This table represents the mapping from the encoding to the actual values.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define DEF_REGMAP(NAME, ELEMENTS, ...) \
|
|
|
|
static const unsigned int DECODE_REGISTER_##NAME[ELEMENTS] = \
|
|
|
|
{ __VA_ARGS__ };
|
|
|
|
/* Name Num Table */
|
|
|
|
DEF_REGMAP(R_16, 16, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23)
|
|
|
|
DEF_REGMAP(R__8, 8, 0, 2, 4, 6, 16, 18, 20, 22)
|
|
|
|
|
2021-03-15 05:54:09 +01:00
|
|
|
#define DECODE_MAPPED_REG(OPNUM, NAME) \
|
|
|
|
insn->regno[OPNUM] = DECODE_REGISTER_##NAME[insn->regno[OPNUM]];
|
2021-02-08 06:46:03 +01:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
const struct DectreeTable *table_link;
|
|
|
|
const struct DectreeTable *table_link_b;
|
|
|
|
Opcode opcode;
|
|
|
|
enum {
|
|
|
|
DECTREE_ENTRY_INVALID,
|
|
|
|
DECTREE_TABLE_LINK,
|
|
|
|
DECTREE_SUBINSNS,
|
|
|
|
DECTREE_EXTSPACE,
|
|
|
|
DECTREE_TERMINAL
|
|
|
|
} type;
|
|
|
|
} DectreeEntry;
|
|
|
|
|
|
|
|
typedef struct DectreeTable {
|
|
|
|
unsigned int (*lookup_function)(int startbit, int width, uint32_t opcode);
|
|
|
|
unsigned int size;
|
|
|
|
unsigned int startbit;
|
|
|
|
unsigned int width;
|
|
|
|
const DectreeEntry table[];
|
|
|
|
} DectreeTable;
|
|
|
|
|
|
|
|
#define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT) \
|
|
|
|
static const DectreeTable dectree_table_##TAG;
|
|
|
|
#define TABLE_LINK(TABLE) /* NOTHING */
|
|
|
|
#define TERMINAL(TAG, ENC) /* NOTHING */
|
|
|
|
#define SUBINSNS(TAG, CLASSA, CLASSB, ENC) /* NOTHING */
|
|
|
|
#define EXTSPACE(TAG, ENC) /* NOTHING */
|
|
|
|
#define INVALID() /* NOTHING */
|
|
|
|
#define DECODE_END_TABLE(...) /* NOTHING */
|
|
|
|
#define DECODE_MATCH_INFO(...) /* NOTHING */
|
|
|
|
#define DECODE_LEGACY_MATCH_INFO(...) /* NOTHING */
|
|
|
|
#define DECODE_OPINFO(...) /* NOTHING */
|
|
|
|
|
|
|
|
#include "dectree_generated.h.inc"
|
|
|
|
|
|
|
|
#undef DECODE_OPINFO
|
|
|
|
#undef DECODE_MATCH_INFO
|
|
|
|
#undef DECODE_LEGACY_MATCH_INFO
|
|
|
|
#undef DECODE_END_TABLE
|
|
|
|
#undef INVALID
|
|
|
|
#undef TERMINAL
|
|
|
|
#undef SUBINSNS
|
|
|
|
#undef EXTSPACE
|
|
|
|
#undef TABLE_LINK
|
|
|
|
#undef DECODE_NEW_TABLE
|
|
|
|
#undef DECODE_SEPARATOR_BITS
|
|
|
|
|
|
|
|
#define DECODE_SEPARATOR_BITS(START, WIDTH) NULL, START, WIDTH
|
|
|
|
#define DECODE_NEW_TABLE_HELPER(TAG, SIZE, FN, START, WIDTH) \
|
|
|
|
static const DectreeTable dectree_table_##TAG = { \
|
|
|
|
.size = SIZE, \
|
|
|
|
.lookup_function = FN, \
|
|
|
|
.startbit = START, \
|
|
|
|
.width = WIDTH, \
|
|
|
|
.table = {
|
|
|
|
#define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT) \
|
|
|
|
DECODE_NEW_TABLE_HELPER(TAG, SIZE, WHATNOT)
|
|
|
|
|
|
|
|
#define TABLE_LINK(TABLE) \
|
|
|
|
{ .type = DECTREE_TABLE_LINK, .table_link = &dectree_table_##TABLE },
|
|
|
|
#define TERMINAL(TAG, ENC) \
|
|
|
|
{ .type = DECTREE_TERMINAL, .opcode = TAG },
|
|
|
|
#define SUBINSNS(TAG, CLASSA, CLASSB, ENC) \
|
|
|
|
{ \
|
|
|
|
.type = DECTREE_SUBINSNS, \
|
|
|
|
.table_link = &dectree_table_DECODE_SUBINSN_##CLASSA, \
|
|
|
|
.table_link_b = &dectree_table_DECODE_SUBINSN_##CLASSB \
|
|
|
|
},
|
|
|
|
#define EXTSPACE(TAG, ENC) { .type = DECTREE_EXTSPACE },
|
|
|
|
#define INVALID() { .type = DECTREE_ENTRY_INVALID, .opcode = XX_LAST_OPCODE },
|
|
|
|
|
|
|
|
#define DECODE_END_TABLE(...) } };
|
|
|
|
|
|
|
|
#define DECODE_MATCH_INFO(...) /* NOTHING */
|
|
|
|
#define DECODE_LEGACY_MATCH_INFO(...) /* NOTHING */
|
|
|
|
#define DECODE_OPINFO(...) /* NOTHING */
|
|
|
|
|
|
|
|
#include "dectree_generated.h.inc"
|
|
|
|
|
|
|
|
#undef DECODE_OPINFO
|
|
|
|
#undef DECODE_MATCH_INFO
|
|
|
|
#undef DECODE_LEGACY_MATCH_INFO
|
|
|
|
#undef DECODE_END_TABLE
|
|
|
|
#undef INVALID
|
|
|
|
#undef TERMINAL
|
|
|
|
#undef SUBINSNS
|
|
|
|
#undef EXTSPACE
|
|
|
|
#undef TABLE_LINK
|
|
|
|
#undef DECODE_NEW_TABLE
|
|
|
|
#undef DECODE_NEW_TABLE_HELPER
|
|
|
|
#undef DECODE_SEPARATOR_BITS
|
|
|
|
|
|
|
|
static const DectreeTable dectree_table_DECODE_EXT_EXT_noext = {
|
|
|
|
.size = 1, .lookup_function = NULL, .startbit = 0, .width = 0,
|
|
|
|
.table = {
|
|
|
|
{ .type = DECTREE_ENTRY_INVALID, .opcode = XX_LAST_OPCODE },
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const DectreeTable *ext_trees[XX_LAST_EXT_IDX];
|
|
|
|
|
|
|
|
static void decode_ext_init(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = EXT_IDX_noext; i < EXT_IDX_noext_AFTER; i++) {
|
|
|
|
ext_trees[i] = &dectree_table_DECODE_EXT_EXT_noext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
uint32_t mask;
|
|
|
|
uint32_t match;
|
|
|
|
} DecodeITableEntry;
|
|
|
|
|
|
|
|
#define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT) /* NOTHING */
|
|
|
|
#define TABLE_LINK(TABLE) /* NOTHING */
|
|
|
|
#define TERMINAL(TAG, ENC) /* NOTHING */
|
|
|
|
#define SUBINSNS(TAG, CLASSA, CLASSB, ENC) /* NOTHING */
|
|
|
|
#define EXTSPACE(TAG, ENC) /* NOTHING */
|
|
|
|
#define INVALID() /* NOTHING */
|
|
|
|
#define DECODE_END_TABLE(...) /* NOTHING */
|
|
|
|
#define DECODE_OPINFO(...) /* NOTHING */
|
|
|
|
|
|
|
|
#define DECODE_MATCH_INFO_NORMAL(TAG, MASK, MATCH) \
|
|
|
|
[TAG] = { \
|
|
|
|
.mask = MASK, \
|
|
|
|
.match = MATCH, \
|
|
|
|
},
|
|
|
|
|
|
|
|
#define DECODE_MATCH_INFO_NULL(TAG, MASK, MATCH) \
|
|
|
|
[TAG] = { .match = ~0 },
|
|
|
|
|
|
|
|
#define DECODE_MATCH_INFO(...) DECODE_MATCH_INFO_NORMAL(__VA_ARGS__)
|
|
|
|
#define DECODE_LEGACY_MATCH_INFO(...) /* NOTHING */
|
|
|
|
|
|
|
|
static const DecodeITableEntry decode_itable[XX_LAST_OPCODE] = {
|
|
|
|
#include "dectree_generated.h.inc"
|
|
|
|
};
|
|
|
|
|
|
|
|
#undef DECODE_MATCH_INFO
|
|
|
|
#define DECODE_MATCH_INFO(...) DECODE_MATCH_INFO_NULL(__VA_ARGS__)
|
|
|
|
|
|
|
|
#undef DECODE_LEGACY_MATCH_INFO
|
|
|
|
#define DECODE_LEGACY_MATCH_INFO(...) DECODE_MATCH_INFO_NORMAL(__VA_ARGS__)
|
|
|
|
|
|
|
|
static const DecodeITableEntry decode_legacy_itable[XX_LAST_OPCODE] = {
|
|
|
|
#include "dectree_generated.h.inc"
|
|
|
|
};
|
|
|
|
|
|
|
|
#undef DECODE_OPINFO
|
|
|
|
#undef DECODE_MATCH_INFO
|
|
|
|
#undef DECODE_LEGACY_MATCH_INFO
|
|
|
|
#undef DECODE_END_TABLE
|
|
|
|
#undef INVALID
|
|
|
|
#undef TERMINAL
|
|
|
|
#undef SUBINSNS
|
|
|
|
#undef EXTSPACE
|
|
|
|
#undef TABLE_LINK
|
|
|
|
#undef DECODE_NEW_TABLE
|
|
|
|
#undef DECODE_SEPARATOR_BITS
|
|
|
|
|
|
|
|
void decode_init(void)
|
|
|
|
{
|
|
|
|
decode_ext_init();
|
|
|
|
}
|
|
|
|
|
|
|
|
void decode_send_insn_to(Packet *packet, int start, int newloc)
|
|
|
|
{
|
|
|
|
Insn tmpinsn;
|
|
|
|
int direction;
|
|
|
|
int i;
|
|
|
|
if (start == newloc) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (start < newloc) {
|
|
|
|
/* Move towards end */
|
|
|
|
direction = 1;
|
|
|
|
} else {
|
|
|
|
/* move towards beginning */
|
|
|
|
direction = -1;
|
|
|
|
}
|
|
|
|
for (i = start; i != newloc; i += direction) {
|
|
|
|
tmpinsn = packet->insn[i];
|
|
|
|
packet->insn[i] = packet->insn[i + direction];
|
|
|
|
packet->insn[i + direction] = tmpinsn;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill newvalue registers with the correct regno */
|
|
|
|
static void
|
|
|
|
decode_fill_newvalue_regno(Packet *packet)
|
|
|
|
{
|
|
|
|
int i, use_regidx, offset, def_idx, dst_idx;
|
|
|
|
uint16_t def_opcode, use_opcode;
|
|
|
|
char *dststr;
|
|
|
|
|
|
|
|
for (i = 1; i < packet->num_insns; i++) {
|
|
|
|
if (GET_ATTRIB(packet->insn[i].opcode, A_DOTNEWVALUE) &&
|
|
|
|
!GET_ATTRIB(packet->insn[i].opcode, A_EXTENSION)) {
|
|
|
|
use_opcode = packet->insn[i].opcode;
|
|
|
|
|
|
|
|
/* It's a store, so we're adjusting the Nt field */
|
|
|
|
if (GET_ATTRIB(use_opcode, A_STORE)) {
|
|
|
|
use_regidx = strchr(opcode_reginfo[use_opcode], 't') -
|
|
|
|
opcode_reginfo[use_opcode];
|
|
|
|
} else { /* It's a Jump, so we're adjusting the Ns field */
|
|
|
|
use_regidx = strchr(opcode_reginfo[use_opcode], 's') -
|
|
|
|
opcode_reginfo[use_opcode];
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* What's encoded at the N-field is the offset to who's producing
|
|
|
|
* the value. Shift off the LSB which indicates odd/even register,
|
|
|
|
* then walk backwards and skip over the constant extenders.
|
|
|
|
*/
|
|
|
|
offset = packet->insn[i].regno[use_regidx] >> 1;
|
|
|
|
def_idx = i - offset;
|
|
|
|
for (int j = 0; j < offset; j++) {
|
|
|
|
if (GET_ATTRIB(packet->insn[i - j - 1].opcode, A_IT_EXTENDER)) {
|
|
|
|
def_idx--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for a badly encoded N-field which points to an instruction
|
|
|
|
* out-of-range
|
|
|
|
*/
|
|
|
|
g_assert(!((def_idx < 0) || (def_idx > (packet->num_insns - 1))));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* packet->insn[def_idx] is the producer
|
|
|
|
* Figure out which type of destination it produces
|
|
|
|
* and the corresponding index in the reginfo
|
|
|
|
*/
|
|
|
|
def_opcode = packet->insn[def_idx].opcode;
|
|
|
|
dststr = strstr(opcode_wregs[def_opcode], "Rd");
|
|
|
|
if (dststr) {
|
|
|
|
dststr = strchr(opcode_reginfo[def_opcode], 'd');
|
|
|
|
} else {
|
|
|
|
dststr = strstr(opcode_wregs[def_opcode], "Rx");
|
|
|
|
if (dststr) {
|
|
|
|
dststr = strchr(opcode_reginfo[def_opcode], 'x');
|
|
|
|
} else {
|
|
|
|
dststr = strstr(opcode_wregs[def_opcode], "Re");
|
|
|
|
if (dststr) {
|
|
|
|
dststr = strchr(opcode_reginfo[def_opcode], 'e');
|
|
|
|
} else {
|
|
|
|
dststr = strstr(opcode_wregs[def_opcode], "Ry");
|
|
|
|
if (dststr) {
|
|
|
|
dststr = strchr(opcode_reginfo[def_opcode], 'y');
|
|
|
|
} else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_assert(dststr != NULL);
|
|
|
|
|
|
|
|
/* Now patch up the consumer with the register number */
|
|
|
|
dst_idx = dststr - opcode_reginfo[def_opcode];
|
|
|
|
packet->insn[i].regno[use_regidx] =
|
|
|
|
packet->insn[def_idx].regno[dst_idx];
|
|
|
|
/*
|
|
|
|
* We need to remember who produces this value to later
|
|
|
|
* check if it was dynamically cancelled
|
|
|
|
*/
|
|
|
|
packet->insn[i].new_value_producer_slot =
|
|
|
|
packet->insn[def_idx].slot;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Split CJ into a compare and a jump */
|
|
|
|
static void decode_split_cmpjump(Packet *pkt)
|
|
|
|
{
|
|
|
|
int last, i;
|
|
|
|
int numinsns = pkt->num_insns;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First, split all compare-jumps.
|
|
|
|
* The compare is sent to the end as a new instruction.
|
|
|
|
* Do it this way so we don't reorder dual jumps. Those need to stay in
|
|
|
|
* original order.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < numinsns; i++) {
|
|
|
|
/* It's a cmp-jump */
|
|
|
|
if (GET_ATTRIB(pkt->insn[i].opcode, A_NEWCMPJUMP)) {
|
|
|
|
last = pkt->num_insns;
|
|
|
|
pkt->insn[last] = pkt->insn[i]; /* copy the instruction */
|
2021-04-09 03:07:35 +02:00
|
|
|
pkt->insn[last].part1 = true; /* last insn does the CMP */
|
|
|
|
pkt->insn[i].part1 = false; /* existing insn does the JUMP */
|
2021-02-08 06:46:03 +01:00
|
|
|
pkt->num_insns++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now re-shuffle all the compares back to the beginning */
|
|
|
|
for (i = 0; i < pkt->num_insns; i++) {
|
|
|
|
if (pkt->insn[i].part1) {
|
|
|
|
decode_send_insn_to(pkt, i, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-09 03:07:35 +02:00
|
|
|
static bool decode_opcode_can_jump(int opcode)
|
2021-02-08 06:46:03 +01:00
|
|
|
{
|
|
|
|
if ((GET_ATTRIB(opcode, A_JUMP)) ||
|
|
|
|
(GET_ATTRIB(opcode, A_CALL)) ||
|
|
|
|
(opcode == J2_trap0) ||
|
|
|
|
(opcode == J2_pause)) {
|
|
|
|
/* Exception to A_JUMP attribute */
|
|
|
|
if (opcode == J4_hintjumpr) {
|
2021-04-09 03:07:35 +02:00
|
|
|
return false;
|
2021-02-08 06:46:03 +01:00
|
|
|
}
|
2021-04-09 03:07:35 +02:00
|
|
|
return true;
|
2021-02-08 06:46:03 +01:00
|
|
|
}
|
|
|
|
|
2021-04-09 03:07:35 +02:00
|
|
|
return false;
|
2021-02-08 06:46:03 +01:00
|
|
|
}
|
|
|
|
|
2021-04-09 03:07:35 +02:00
|
|
|
static bool decode_opcode_ends_loop(int opcode)
|
2021-02-08 06:46:03 +01:00
|
|
|
{
|
|
|
|
return GET_ATTRIB(opcode, A_HWLOOP0_END) ||
|
|
|
|
GET_ATTRIB(opcode, A_HWLOOP1_END);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set the is_* fields in each instruction */
|
|
|
|
static void decode_set_insn_attr_fields(Packet *pkt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int numinsns = pkt->num_insns;
|
|
|
|
uint16_t opcode;
|
|
|
|
|
2021-04-09 03:07:35 +02:00
|
|
|
pkt->pkt_has_cof = false;
|
|
|
|
pkt->pkt_has_endloop = false;
|
|
|
|
pkt->pkt_has_dczeroa = false;
|
2021-02-08 06:46:03 +01:00
|
|
|
|
|
|
|
for (i = 0; i < numinsns; i++) {
|
|
|
|
opcode = pkt->insn[i].opcode;
|
|
|
|
if (pkt->insn[i].part1) {
|
|
|
|
continue; /* Skip compare of cmp-jumps */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (GET_ATTRIB(opcode, A_DCZEROA)) {
|
2021-04-09 03:07:35 +02:00
|
|
|
pkt->pkt_has_dczeroa = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (GET_ATTRIB(opcode, A_STORE)) {
|
|
|
|
if (pkt->insn[i].slot == 0) {
|
2021-04-09 03:07:35 +02:00
|
|
|
pkt->pkt_has_store_s0 = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
} else {
|
2021-04-09 03:07:35 +02:00
|
|
|
pkt->pkt_has_store_s1 = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pkt->pkt_has_cof |= decode_opcode_can_jump(opcode);
|
|
|
|
|
|
|
|
pkt->insn[i].is_endloop = decode_opcode_ends_loop(opcode);
|
|
|
|
|
|
|
|
pkt->pkt_has_endloop |= pkt->insn[i].is_endloop;
|
|
|
|
|
|
|
|
pkt->pkt_has_cof |= pkt->pkt_has_endloop;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shuffle for execution
|
|
|
|
* Move stores to end (in same order as encoding)
|
|
|
|
* Move compares to beginning (for use by .new insns)
|
|
|
|
*/
|
|
|
|
static void decode_shuffle_for_execution(Packet *packet)
|
|
|
|
{
|
2021-04-09 03:07:35 +02:00
|
|
|
bool changed = false;
|
2021-02-08 06:46:03 +01:00
|
|
|
int i;
|
2021-04-09 03:07:35 +02:00
|
|
|
bool flag; /* flag means we've seen a non-memory instruction */
|
2021-02-08 06:46:03 +01:00
|
|
|
int n_mems;
|
|
|
|
int last_insn = packet->num_insns - 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Skip end loops, somehow an end loop is getting in and messing
|
|
|
|
* up the order
|
|
|
|
*/
|
|
|
|
if (decode_opcode_ends_loop(packet->insn[last_insn].opcode)) {
|
|
|
|
last_insn--;
|
|
|
|
}
|
|
|
|
|
|
|
|
do {
|
2021-04-09 03:07:35 +02:00
|
|
|
changed = false;
|
2021-02-08 06:46:03 +01:00
|
|
|
/*
|
|
|
|
* Stores go last, must not reorder.
|
|
|
|
* Cannot shuffle stores past loads, either.
|
|
|
|
* Iterate backwards. If we see a non-memory instruction,
|
|
|
|
* then a store, shuffle the store to the front. Don't shuffle
|
|
|
|
* stores wrt each other or a load.
|
|
|
|
*/
|
2021-04-09 03:07:35 +02:00
|
|
|
for (flag = false, n_mems = 0, i = last_insn; i >= 0; i--) {
|
2021-02-08 06:46:03 +01:00
|
|
|
int opcode = packet->insn[i].opcode;
|
|
|
|
|
|
|
|
if (flag && GET_ATTRIB(opcode, A_STORE)) {
|
|
|
|
decode_send_insn_to(packet, i, last_insn - n_mems);
|
|
|
|
n_mems++;
|
2021-04-09 03:07:35 +02:00
|
|
|
changed = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
} else if (GET_ATTRIB(opcode, A_STORE)) {
|
|
|
|
n_mems++;
|
|
|
|
} else if (GET_ATTRIB(opcode, A_LOAD)) {
|
|
|
|
/*
|
|
|
|
* Don't set flag, since we don't want to shuffle a
|
|
|
|
* store past a load
|
|
|
|
*/
|
|
|
|
n_mems++;
|
|
|
|
} else if (GET_ATTRIB(opcode, A_DOTNEWVALUE)) {
|
|
|
|
/*
|
|
|
|
* Don't set flag, since we don't want to shuffle past
|
|
|
|
* a .new value
|
|
|
|
*/
|
|
|
|
} else {
|
2021-04-09 03:07:35 +02:00
|
|
|
flag = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (changed) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* Compares go first, may be reordered wrt each other */
|
2021-04-09 03:07:35 +02:00
|
|
|
for (flag = false, i = 0; i < last_insn + 1; i++) {
|
2021-02-08 06:46:03 +01:00
|
|
|
int opcode = packet->insn[i].opcode;
|
|
|
|
|
|
|
|
if ((strstr(opcode_wregs[opcode], "Pd4") ||
|
|
|
|
strstr(opcode_wregs[opcode], "Pe4")) &&
|
|
|
|
GET_ATTRIB(opcode, A_STORE) == 0) {
|
|
|
|
/* This should be a compare (not a store conditional) */
|
|
|
|
if (flag) {
|
|
|
|
decode_send_insn_to(packet, i, 0);
|
2021-04-09 03:07:35 +02:00
|
|
|
changed = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else if (GET_ATTRIB(opcode, A_IMPLICIT_WRITES_P3) &&
|
|
|
|
!decode_opcode_ends_loop(packet->insn[i].opcode)) {
|
|
|
|
/*
|
|
|
|
* spNloop instruction
|
|
|
|
* Don't reorder endloops; they are not valid for .new uses,
|
|
|
|
* and we want to match HW
|
|
|
|
*/
|
|
|
|
if (flag) {
|
|
|
|
decode_send_insn_to(packet, i, 0);
|
2021-04-09 03:07:35 +02:00
|
|
|
changed = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else if (GET_ATTRIB(opcode, A_IMPLICIT_WRITES_P0) &&
|
|
|
|
!GET_ATTRIB(opcode, A_NEWCMPJUMP)) {
|
|
|
|
if (flag) {
|
|
|
|
decode_send_insn_to(packet, i, 0);
|
2021-04-09 03:07:35 +02:00
|
|
|
changed = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else {
|
2021-04-09 03:07:35 +02:00
|
|
|
flag = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (changed) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} while (changed);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have a .new register compare/branch, move that to the very
|
|
|
|
* very end, past stores
|
|
|
|
*/
|
|
|
|
for (i = 0; i < last_insn; i++) {
|
|
|
|
if (GET_ATTRIB(packet->insn[i].opcode, A_DOTNEWVALUE)) {
|
|
|
|
decode_send_insn_to(packet, i, last_insn);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
apply_extender(Packet *pkt, int i, uint32_t extender)
|
|
|
|
{
|
|
|
|
int immed_num;
|
|
|
|
uint32_t base_immed;
|
|
|
|
|
|
|
|
immed_num = opcode_which_immediate_is_extended(pkt->insn[i].opcode);
|
|
|
|
base_immed = pkt->insn[i].immed[immed_num];
|
|
|
|
|
|
|
|
pkt->insn[i].immed[immed_num] = extender | fZXTN(6, 32, base_immed);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void decode_apply_extenders(Packet *packet)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < packet->num_insns; i++) {
|
|
|
|
if (GET_ATTRIB(packet->insn[i].opcode, A_IT_EXTENDER)) {
|
2021-04-09 03:07:35 +02:00
|
|
|
packet->insn[i + 1].extension_valid = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
apply_extender(packet, i + 1, packet->insn[i].immed[0]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void decode_remove_extenders(Packet *packet)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
for (i = 0; i < packet->num_insns; i++) {
|
|
|
|
if (GET_ATTRIB(packet->insn[i].opcode, A_IT_EXTENDER)) {
|
|
|
|
/* Remove this one by moving the remaining instructions down */
|
|
|
|
for (j = i;
|
|
|
|
(j < packet->num_insns - 1) && (j < INSTRUCTIONS_MAX - 1);
|
|
|
|
j++) {
|
|
|
|
packet->insn[j] = packet->insn[j + 1];
|
|
|
|
}
|
|
|
|
packet->num_insns--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static SlotMask get_valid_slots(const Packet *pkt, unsigned int slot)
|
|
|
|
{
|
|
|
|
return find_iclass_slots(pkt->insn[slot].opcode,
|
|
|
|
pkt->insn[slot].iclass);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define DECODE_NEW_TABLE(TAG, SIZE, WHATNOT) /* NOTHING */
|
|
|
|
#define TABLE_LINK(TABLE) /* NOTHING */
|
|
|
|
#define TERMINAL(TAG, ENC) /* NOTHING */
|
|
|
|
#define SUBINSNS(TAG, CLASSA, CLASSB, ENC) /* NOTHING */
|
|
|
|
#define EXTSPACE(TAG, ENC) /* NOTHING */
|
|
|
|
#define INVALID() /* NOTHING */
|
|
|
|
#define DECODE_END_TABLE(...) /* NOTHING */
|
|
|
|
#define DECODE_MATCH_INFO(...) /* NOTHING */
|
|
|
|
#define DECODE_LEGACY_MATCH_INFO(...) /* NOTHING */
|
|
|
|
|
|
|
|
#define DECODE_REG(REGNO, WIDTH, STARTBIT) \
|
|
|
|
insn->regno[REGNO] = ((encoding >> STARTBIT) & ((1 << WIDTH) - 1));
|
|
|
|
|
|
|
|
#define DECODE_IMPL_REG(REGNO, VAL) \
|
|
|
|
insn->regno[REGNO] = VAL;
|
|
|
|
|
|
|
|
#define DECODE_IMM(IMMNO, WIDTH, STARTBIT, VALSTART) \
|
|
|
|
insn->immed[IMMNO] |= (((encoding >> STARTBIT) & ((1 << WIDTH) - 1))) << \
|
|
|
|
(VALSTART);
|
|
|
|
|
|
|
|
#define DECODE_IMM_SXT(IMMNO, WIDTH) \
|
|
|
|
insn->immed[IMMNO] = ((((int32_t)insn->immed[IMMNO]) << (32 - WIDTH)) >> \
|
|
|
|
(32 - WIDTH));
|
|
|
|
|
|
|
|
#define DECODE_IMM_NEG(IMMNO, WIDTH) \
|
|
|
|
insn->immed[IMMNO] = -insn->immed[IMMNO];
|
|
|
|
|
|
|
|
#define DECODE_IMM_SHIFT(IMMNO, SHAMT) \
|
|
|
|
if ((!insn->extension_valid) || \
|
|
|
|
(insn->which_extended != IMMNO)) { \
|
|
|
|
insn->immed[IMMNO] <<= SHAMT; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define DECODE_OPINFO(TAG, BEH) \
|
|
|
|
case TAG: \
|
|
|
|
{ BEH } \
|
|
|
|
break; \
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in the operands of the instruction
|
|
|
|
* dectree_generated.h.inc has a DECODE_OPINFO entry for each opcode
|
|
|
|
* For example,
|
|
|
|
* DECODE_OPINFO(A2_addi,
|
|
|
|
* DECODE_REG(0,5,0)
|
|
|
|
* DECODE_REG(1,5,16)
|
|
|
|
* DECODE_IMM(0,7,21,9)
|
|
|
|
* DECODE_IMM(0,9,5,0)
|
|
|
|
* DECODE_IMM_SXT(0,16)
|
|
|
|
* with the macros defined above, we'll fill in a switch statement
|
|
|
|
* where each case is an opcode tag.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
decode_op(Insn *insn, Opcode tag, uint32_t encoding)
|
|
|
|
{
|
|
|
|
insn->immed[0] = 0;
|
|
|
|
insn->immed[1] = 0;
|
|
|
|
insn->opcode = tag;
|
|
|
|
if (insn->extension_valid) {
|
|
|
|
insn->which_extended = opcode_which_immediate_is_extended(tag);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (tag) {
|
|
|
|
#include "dectree_generated.h.inc"
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
insn->generate = opcode_genptr[tag];
|
|
|
|
|
|
|
|
insn->iclass = iclass_bits(encoding);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef DECODE_REG
|
|
|
|
#undef DECODE_IMPL_REG
|
|
|
|
#undef DECODE_IMM
|
|
|
|
#undef DECODE_IMM_SHIFT
|
|
|
|
#undef DECODE_OPINFO
|
|
|
|
#undef DECODE_MATCH_INFO
|
|
|
|
#undef DECODE_LEGACY_MATCH_INFO
|
|
|
|
#undef DECODE_END_TABLE
|
|
|
|
#undef INVALID
|
|
|
|
#undef TERMINAL
|
|
|
|
#undef SUBINSNS
|
|
|
|
#undef EXTSPACE
|
|
|
|
#undef TABLE_LINK
|
|
|
|
#undef DECODE_NEW_TABLE
|
|
|
|
#undef DECODE_SEPARATOR_BITS
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
decode_subinsn_tablewalk(Insn *insn, const DectreeTable *table,
|
|
|
|
uint32_t encoding)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
Opcode opc;
|
|
|
|
if (table->lookup_function) {
|
|
|
|
i = table->lookup_function(table->startbit, table->width, encoding);
|
|
|
|
} else {
|
|
|
|
i = extract32(encoding, table->startbit, table->width);
|
|
|
|
}
|
|
|
|
if (table->table[i].type == DECTREE_TABLE_LINK) {
|
|
|
|
return decode_subinsn_tablewalk(insn, table->table[i].table_link,
|
|
|
|
encoding);
|
|
|
|
} else if (table->table[i].type == DECTREE_TERMINAL) {
|
|
|
|
opc = table->table[i].opcode;
|
|
|
|
if ((encoding & decode_itable[opc].mask) != decode_itable[opc].match) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
decode_op(insn, opc, encoding);
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int get_insn_a(uint32_t encoding)
|
|
|
|
{
|
|
|
|
return extract32(encoding, 0, 13);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int get_insn_b(uint32_t encoding)
|
|
|
|
{
|
|
|
|
return extract32(encoding, 16, 13);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
decode_insns_tablewalk(Insn *insn, const DectreeTable *table,
|
|
|
|
uint32_t encoding)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
unsigned int a, b;
|
|
|
|
Opcode opc;
|
|
|
|
if (table->lookup_function) {
|
|
|
|
i = table->lookup_function(table->startbit, table->width, encoding);
|
|
|
|
} else {
|
|
|
|
i = extract32(encoding, table->startbit, table->width);
|
|
|
|
}
|
|
|
|
if (table->table[i].type == DECTREE_TABLE_LINK) {
|
|
|
|
return decode_insns_tablewalk(insn, table->table[i].table_link,
|
|
|
|
encoding);
|
|
|
|
} else if (table->table[i].type == DECTREE_SUBINSNS) {
|
|
|
|
a = get_insn_a(encoding);
|
|
|
|
b = get_insn_b(encoding);
|
|
|
|
b = decode_subinsn_tablewalk(insn, table->table[i].table_link_b, b);
|
|
|
|
a = decode_subinsn_tablewalk(insn + 1, table->table[i].table_link, a);
|
|
|
|
if ((a == 0) || (b == 0)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 2;
|
|
|
|
} else if (table->table[i].type == DECTREE_TERMINAL) {
|
|
|
|
opc = table->table[i].opcode;
|
|
|
|
if ((encoding & decode_itable[opc].mask) != decode_itable[opc].match) {
|
|
|
|
if ((encoding & decode_legacy_itable[opc].mask) !=
|
|
|
|
decode_legacy_itable[opc].match) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
decode_op(insn, opc, encoding);
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
decode_insns(Insn *insn, uint32_t encoding)
|
|
|
|
{
|
|
|
|
const DectreeTable *table;
|
|
|
|
if (parse_bits(encoding) != 0) {
|
|
|
|
/* Start with PP table - 32 bit instructions */
|
|
|
|
table = &dectree_table_DECODE_ROOT_32;
|
|
|
|
} else {
|
|
|
|
/* start with EE table - duplex instructions */
|
|
|
|
table = &dectree_table_DECODE_ROOT_EE;
|
|
|
|
}
|
|
|
|
return decode_insns_tablewalk(insn, table, encoding);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void decode_add_endloop_insn(Insn *insn, int loopnum)
|
|
|
|
{
|
|
|
|
if (loopnum == 10) {
|
|
|
|
insn->opcode = J2_endloop01;
|
|
|
|
insn->generate = opcode_genptr[J2_endloop01];
|
|
|
|
} else if (loopnum == 1) {
|
|
|
|
insn->opcode = J2_endloop1;
|
|
|
|
insn->generate = opcode_genptr[J2_endloop1];
|
|
|
|
} else if (loopnum == 0) {
|
|
|
|
insn->opcode = J2_endloop0;
|
|
|
|
insn->generate = opcode_genptr[J2_endloop0];
|
|
|
|
} else {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-09 03:07:35 +02:00
|
|
|
static bool decode_parsebits_is_loopend(uint32_t encoding32)
|
2021-02-08 06:46:03 +01:00
|
|
|
{
|
|
|
|
uint32_t bits = parse_bits(encoding32);
|
|
|
|
return bits == 0x2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
decode_set_slot_number(Packet *pkt)
|
|
|
|
{
|
|
|
|
int slot;
|
|
|
|
int i;
|
2021-04-09 03:07:35 +02:00
|
|
|
bool hit_mem_insn = false;
|
|
|
|
bool hit_duplex = false;
|
|
|
|
bool slot0_found = false;
|
|
|
|
bool slot1_found = false;
|
|
|
|
int slot1_iidx = 0;
|
2021-02-08 06:46:03 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The slots are encoded in reverse order
|
|
|
|
* For each instruction, count down until you find a suitable slot
|
|
|
|
*/
|
|
|
|
for (i = 0, slot = 3; i < pkt->num_insns; i++) {
|
|
|
|
SlotMask valid_slots = get_valid_slots(pkt, i);
|
|
|
|
|
|
|
|
while (!(valid_slots & (1 << slot))) {
|
|
|
|
slot--;
|
|
|
|
}
|
|
|
|
pkt->insn[i].slot = slot;
|
|
|
|
if (slot) {
|
|
|
|
/* I've assigned the slot, now decrement it for the next insn */
|
|
|
|
slot--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fix the exceptions - mem insns to slot 0,1 */
|
|
|
|
for (i = pkt->num_insns - 1; i >= 0; i--) {
|
|
|
|
/* First memory instruction always goes to slot 0 */
|
|
|
|
if ((GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE) ||
|
|
|
|
GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE_PACKET_RULES)) &&
|
|
|
|
!hit_mem_insn) {
|
2021-04-09 03:07:35 +02:00
|
|
|
hit_mem_insn = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
pkt->insn[i].slot = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Next memory instruction always goes to slot 1 */
|
|
|
|
if ((GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE) ||
|
|
|
|
GET_ATTRIB(pkt->insn[i].opcode, A_MEMLIKE_PACKET_RULES)) &&
|
|
|
|
hit_mem_insn) {
|
|
|
|
pkt->insn[i].slot = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fix the exceptions - duplex always slot 0,1 */
|
|
|
|
for (i = pkt->num_insns - 1; i >= 0; i--) {
|
|
|
|
/* First subinsn always goes to slot 0 */
|
|
|
|
if (GET_ATTRIB(pkt->insn[i].opcode, A_SUBINSN) && !hit_duplex) {
|
2021-04-09 03:07:35 +02:00
|
|
|
hit_duplex = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
pkt->insn[i].slot = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Next subinsn always goes to slot 1 */
|
|
|
|
if (GET_ATTRIB(pkt->insn[i].opcode, A_SUBINSN) && hit_duplex) {
|
|
|
|
pkt->insn[i].slot = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fix the exceptions - slot 1 is never empty, always aligns to slot 0 */
|
|
|
|
for (i = pkt->num_insns - 1; i >= 0; i--) {
|
|
|
|
/* Is slot0 used? */
|
|
|
|
if (pkt->insn[i].slot == 0) {
|
2021-04-09 03:07:35 +02:00
|
|
|
bool is_endloop = (pkt->insn[i].opcode == J2_endloop01);
|
2021-02-08 06:46:03 +01:00
|
|
|
is_endloop |= (pkt->insn[i].opcode == J2_endloop0);
|
|
|
|
is_endloop |= (pkt->insn[i].opcode == J2_endloop1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure it's not endloop since, we're overloading
|
|
|
|
* slot0 for endloop
|
|
|
|
*/
|
|
|
|
if (!is_endloop) {
|
2021-04-09 03:07:35 +02:00
|
|
|
slot0_found = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Is slot1 used? */
|
|
|
|
if (pkt->insn[i].slot == 1) {
|
2021-04-09 03:07:35 +02:00
|
|
|
slot1_found = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
slot1_iidx = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Is slot0 empty and slot1 used? */
|
2021-04-09 03:07:35 +02:00
|
|
|
if ((!slot0_found) && slot1_found) {
|
2021-02-08 06:46:03 +01:00
|
|
|
/* Then push it to slot0 */
|
|
|
|
pkt->insn[slot1_iidx].slot = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* decode_packet
|
|
|
|
* Decodes packet with given words
|
|
|
|
* Returns 0 on insufficient words,
|
|
|
|
* or number of words used on success
|
|
|
|
*/
|
|
|
|
|
|
|
|
int decode_packet(int max_words, const uint32_t *words, Packet *pkt,
|
|
|
|
bool disas_only)
|
|
|
|
{
|
|
|
|
int num_insns = 0;
|
|
|
|
int words_read = 0;
|
2021-04-09 03:07:35 +02:00
|
|
|
bool end_of_packet = false;
|
2021-02-08 06:46:03 +01:00
|
|
|
int new_insns = 0;
|
|
|
|
uint32_t encoding32;
|
|
|
|
|
|
|
|
/* Initialize */
|
|
|
|
memset(pkt, 0, sizeof(*pkt));
|
|
|
|
/* Try to build packet */
|
|
|
|
while (!end_of_packet && (words_read < max_words)) {
|
|
|
|
encoding32 = words[words_read];
|
|
|
|
end_of_packet = is_packet_end(encoding32);
|
|
|
|
new_insns = decode_insns(&pkt->insn[num_insns], encoding32);
|
|
|
|
g_assert(new_insns > 0);
|
|
|
|
/*
|
|
|
|
* If we saw an extender, mark next word extended so immediate
|
|
|
|
* decode works
|
|
|
|
*/
|
|
|
|
if (pkt->insn[num_insns].opcode == A4_ext) {
|
2021-04-09 03:07:35 +02:00
|
|
|
pkt->insn[num_insns + 1].extension_valid = true;
|
2021-02-08 06:46:03 +01:00
|
|
|
}
|
|
|
|
num_insns += new_insns;
|
|
|
|
words_read++;
|
|
|
|
}
|
|
|
|
|
|
|
|
pkt->num_insns = num_insns;
|
|
|
|
if (!end_of_packet) {
|
|
|
|
/* Ran out of words! */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
pkt->encod_pkt_size_in_bytes = words_read * 4;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for :endloop in the parse bits
|
|
|
|
* Section 10.6 of the Programmer's Reference describes the encoding
|
|
|
|
* The end of hardware loop 0 can be encoded with 2 words
|
|
|
|
* The end of hardware loop 1 needs 3 words
|
|
|
|
*/
|
|
|
|
if ((words_read == 2) && (decode_parsebits_is_loopend(words[0]))) {
|
|
|
|
decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 0);
|
|
|
|
}
|
|
|
|
if (words_read >= 3) {
|
2021-04-09 03:07:35 +02:00
|
|
|
bool has_loop0, has_loop1;
|
2021-02-08 06:46:03 +01:00
|
|
|
has_loop0 = decode_parsebits_is_loopend(words[0]);
|
|
|
|
has_loop1 = decode_parsebits_is_loopend(words[1]);
|
|
|
|
if (has_loop0 && has_loop1) {
|
|
|
|
decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 10);
|
|
|
|
} else if (has_loop1) {
|
|
|
|
decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 1);
|
|
|
|
} else if (has_loop0) {
|
|
|
|
decode_add_endloop_insn(&pkt->insn[pkt->num_insns++], 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
decode_apply_extenders(pkt);
|
|
|
|
if (!disas_only) {
|
|
|
|
decode_remove_extenders(pkt);
|
|
|
|
}
|
|
|
|
decode_set_slot_number(pkt);
|
|
|
|
decode_fill_newvalue_regno(pkt);
|
|
|
|
|
|
|
|
if (!disas_only) {
|
|
|
|
decode_shuffle_for_execution(pkt);
|
|
|
|
decode_split_cmpjump(pkt);
|
|
|
|
decode_set_insn_attr_fields(pkt);
|
|
|
|
}
|
|
|
|
|
|
|
|
return words_read;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Used for "-d in_asm" logging */
|
|
|
|
int disassemble_hexagon(uint32_t *words, int nwords, bfd_vma pc,
|
|
|
|
GString *buf)
|
|
|
|
{
|
|
|
|
Packet pkt;
|
|
|
|
|
|
|
|
if (decode_packet(nwords, words, &pkt, true) > 0) {
|
|
|
|
snprint_a_pkt_disas(buf, &pkt, words, pc);
|
|
|
|
return pkt.encod_pkt_size_in_bytes;
|
|
|
|
} else {
|
|
|
|
g_string_assign(buf, "<invalid>");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|