193 lines
10 KiB
C
193 lines
10 KiB
C
// SPDX-FileCopyrightText: 2017 deroad <wargio@libero.it>
|
|
// SPDX-License-Identifier: LGPL-3.0-only
|
|
#include "libps.h"
|
|
#include "libps_internal.h"
|
|
|
|
ps_operand_t ps_operands_array[] = {
|
|
{ 0, 0 }, // No Operand
|
|
{ 5, 16 }, // FA
|
|
{ 5, 11 }, // FB
|
|
{ 5, 6 }, // FC
|
|
{ 5, 21 }, // FD/FS
|
|
{ 3, 23 }, // crfD,
|
|
{ 1, 16 }, // WB,
|
|
{ 3, 12 }, // IB,
|
|
{ 1, 10 }, // WC,
|
|
{ 3, 7 }, // IC,
|
|
{ 5, 16 }, // RA
|
|
{ 5, 11 }, // RB
|
|
{ 5, 16 }, // DRA,
|
|
{ 5, 11 }, // DRB,
|
|
};
|
|
|
|
ps_opcode_t ps_opcodes_array[] = {
|
|
{ psq_lx, "psq_lx", OPM(4, 6), OPM_MASK, { OP_FD, OP_RA, OP_RB, OP_WC, OP_IC }, "Paired Single Quantized Load Indexed" },
|
|
{ psq_stx, "psq_stx", OPM(4, 7), OPM_MASK, { OP_FS, OP_RA, OP_RB, OP_WC, OP_IC }, "Paired Single Quantized Store Indexed" },
|
|
{ psq_lux, "psq_lux", OPM(4, 38), OPM_MASK, { OP_FD, OP_RA, OP_RB, OP_WC, OP_IC }, "Paired Single Quantized Load with update Indexed" },
|
|
{ psq_stux, "psq_stux", OPM(4, 39), OPM_MASK, { OP_FS, OP_RA, OP_RB, OP_WC, OP_IC }, "Paired Single Quantized Store with update Indexed" },
|
|
|
|
{ psq_l, "psq_l", OP(56), OP_MASK, { OP_FD, OP_DRA, OP_WB, OP_IB }, "Paired Single Quantized Load" },
|
|
{ psq_lu, "psq_lu", OP(57), OP_MASK, { OP_FD, OP_DRA, OP_WB, OP_IB }, "Paired Single Quantized Load with Update" },
|
|
{ psq_st, "psq_st", OP(60), OP_MASK, { OP_FS, OP_DRA, OP_WB, OP_IB }, "Paired Single Quantized Store" },
|
|
{ psq_stu, "psq_stu", OP(61), OP_MASK, { OP_FS, OP_DRA, OP_WB, OP_IB }, "Paired Single Quantized Store with update" },
|
|
|
|
{ ps_div, "ps_div", OPSC(4, 18, 0), OPS_MASK, { OP_FD, OP_FA, OP_FB }, "Paired Single Divide" },
|
|
{ ps_div_dot, "ps_div.", OPSC(4, 18, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FB }, "Paired Single Divide" },
|
|
{ ps_sub, "ps_sub", OPSC(4, 20, 0), OPS_MASK, { OP_FD, OP_FA, OP_FB }, "Paired Single Subtract" },
|
|
{ ps_sub_dot, "ps_sub.", OPSC(4, 20, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FB }, "Paired Single Subtract" },
|
|
{ ps_add, "ps_add", OPSC(4, 21, 0), OPS_MASK, { OP_FD, OP_FA, OP_FB }, "Paired Single Add" },
|
|
{ ps_add_dot, "ps_add.", OPSC(4, 21, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FB }, "Paired Single Add" },
|
|
{ ps_sel, "ps_sel", OPSC(4, 23, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Select" },
|
|
{ ps_sel_dot, "ps_sel.", OPSC(4, 23, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Select" },
|
|
{ ps_res, "ps_res", OPSC(4, 24, 0), OPS_MASK, { OP_FD, OP_FB }, "Paired Single Reciprocal Estimate" },
|
|
{ ps_res_dot, "ps_res.", OPSC(4, 24, 1), OPS_MASK_DOT, { OP_FD, OP_FB }, "Paired Single Reciprocal Estimate" },
|
|
{ ps_mul, "ps_mul", OPSC(4, 25, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC }, "Paired Single Multiply" },
|
|
{ ps_mul_dot, "ps_mul.", OPSC(4, 25, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC }, "Paired Single Multiply" },
|
|
{ ps_rsqrte, "ps_rsqrte", OPSC(4, 26, 0), OPS_MASK, { OP_FD, OP_FB }, "Paired Single Reciprocal Square Root Estimate" },
|
|
{ ps_rsqrte_dot, "ps_rsqrte.", OPSC(4, 26, 1), OPS_MASK_DOT, { OP_FD, OP_FB }, "Paired Single Reciprocal Square Root Estimate" },
|
|
{ ps_msub, "ps_msub", OPSC(4, 28, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Multiply-Subtract" },
|
|
{ ps_msub_dot, "ps_msub.", OPSC(4, 28, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Multiply-Subtract" },
|
|
{ ps_madd, "ps_madd", OPSC(4, 29, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Multiply-Add" },
|
|
{ ps_madd_dot, "ps_madd.", OPSC(4, 29, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Multiply-Add" },
|
|
{ ps_nmsub, "ps_nmsub", OPSC(4, 30, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Negative Multiply-Subtract" },
|
|
{ ps_nmsub_dot, "ps_nmsub.", OPSC(4, 30, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Negative Multiply-Subtract" },
|
|
{ ps_nmadd, "ps_nmadd", OPSC(4, 31, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Negative Multiply-Add" },
|
|
{ ps_nmadd_dot, "ps_nmadd.", OPSC(4, 31, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Negative Multiply-Add" },
|
|
|
|
{ ps_neg, "ps_neg", OPLC(4, 40, 0), OPL_MASK, { OP_FD, OP_FB }, "Paired Single Negate" },
|
|
{ ps_neg_dot, "ps_neg.", OPLC(4, 40, 1), OPL_MASK_DOT, { OP_FD, OP_FB }, "Paired Single Negate" },
|
|
{ ps_mr, "ps_mr", OPLC(4, 72, 0), OPL_MASK, { OP_FD, OP_FB }, "Paired Single Move Register" },
|
|
{ ps_mr_dot, "ps_mr.", OPLC(4, 72, 1), OPL_MASK_DOT, { OP_FD, OP_FB }, "Paired Single Move Register" },
|
|
{ ps_nabs, "ps_nabs", OPLC(4, 136, 0), OPL_MASK, { OP_FD, OP_FB }, "Paired Single Negative Absolute Value" },
|
|
{ ps_nabs_dot, "ps_nabs.", OPLC(4, 136, 1), OPL_MASK_DOT, { OP_FD, OP_FB }, "Paired Single Negative Absolute Value" },
|
|
{ ps_abs, "ps_abs", OPLC(4, 264, 0), OPL_MASK, { OP_FD, OP_FB }, "Paired Single Absolute Value" },
|
|
{ ps_abs_dot, "ps_abs.", OPLC(4, 264, 1), OPL_MASK_DOT, { OP_FD, OP_FB }, "Paired Single Absolute Value" },
|
|
|
|
{ ps_sum0, "ps_sum0", OPSC(4, 10, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single vector SUM high" },
|
|
{ ps_sum0_dot, "ps_sum0.", OPSC(4, 10, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single vector SUM high" },
|
|
{ ps_sum1, "ps_sum1", OPSC(4, 11, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single vector SUM low" },
|
|
{ ps_sum1_dot, "ps_sum1.", OPSC(4, 11, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single vector SUM low" },
|
|
{ ps_muls0, "ps_muls0", OPSC(4, 12, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC }, "Paired Single Multiply Scalar high" },
|
|
{ ps_muls0_dot, "ps_muls0.", OPSC(4, 12, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC }, "Paired Single Multiply Scalar high" },
|
|
{ ps_muls1, "ps_muls1", OPSC(4, 13, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC }, "Paired Single Multiply Scalar low" },
|
|
{ ps_muls1_dot, "ps_muls1.", OPSC(4, 13, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC }, "Paired Single Multiply Scalar low" },
|
|
{ ps_madds0, "ps_madds0", OPSC(4, 14, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Multiply-Add Scalar high" },
|
|
{ ps_madds0_dot, "ps_madds0.", OPSC(4, 14, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Multiply-Add Scalar high" },
|
|
{ ps_madds1, "ps_madds1", OPSC(4, 15, 0), OPS_MASK, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Multiply-Add Scalar low" },
|
|
{ ps_madds1_dot, "ps_madds1.", OPSC(4, 15, 1), OPS_MASK_DOT, { OP_FD, OP_FA, OP_FC, OP_FB }, "Paired Single Multiply-Add Scalar low" },
|
|
|
|
{ ps_cmpu0, "ps_cmpu0", OPL(4, 0), OPL_MASK, { OP_crfD, OP_FA, OP_FB }, "Paired Singles Compare Unordered High" },
|
|
{ ps_cmpo0, "ps_cmpo0", OPL(4, 32), OPL_MASK, { OP_crfD, OP_FA, OP_FB }, "Paired Singles Compare Ordered High" },
|
|
{ ps_cmpu1, "ps_cmpu1", OPL(4, 64), OPL_MASK, { OP_crfD, OP_FA, OP_FB }, "Paired Singles Compare Unordered Low" },
|
|
{ ps_cmpo1, "ps_cmpo1", OPL(4, 96), OPL_MASK, { OP_crfD, OP_FA, OP_FB }, "Paired Singles Compare Ordered Low" },
|
|
|
|
{ ps_merge00, "ps_merge00", OPLC(4, 528, 0), OPL_MASK, { OP_FD, OP_FA, OP_FB }, "Paired Single MERGE high" },
|
|
{ ps_merge00_dot, "ps_merge00.", OPLC(4, 528, 1), OPL_MASK_DOT, { OP_FD, OP_FA, OP_FB }, "Paired Single MERGE high" },
|
|
{ ps_merge01, "ps_merge01", OPLC(4, 560, 0), OPL_MASK, { OP_FD, OP_FA, OP_FB }, "Paired Single MERGE direct" },
|
|
{ ps_merge01_dot, "ps_merge01.", OPLC(4, 560, 1), OPL_MASK_DOT, { OP_FD, OP_FA, OP_FB }, "Paired Single MERGE direct" },
|
|
{ ps_merge10, "ps_merge10", OPLC(4, 592, 0), OPL_MASK, { OP_FD, OP_FA, OP_FB }, "Paired Single MERGE swapped" },
|
|
{ ps_merge10_dot, "ps_merge10.", OPLC(4, 592, 1), OPL_MASK_DOT, { OP_FD, OP_FA, OP_FB }, "Paired Single MERGE swapped" },
|
|
{ ps_merge11, "ps_merge11", OPLC(4, 624, 0), OPL_MASK, { OP_FD, OP_FA, OP_FB }, "Paired Single MERGE low" },
|
|
{ ps_merge11_dot, "ps_merge11.", OPLC(4, 624, 1), OPL_MASK_DOT, { OP_FD, OP_FA, OP_FB }, "Paired Single MERGE low" },
|
|
|
|
{ ps_dcbz_l, "dcbz_l", OPL(4, 1014), OPL_MASK, { OP_RA, OP_RB }, "Data Cache Block Set to Zero Locked" },
|
|
|
|
};
|
|
|
|
bool libps_decode(ut32 data, ppcps_t *ps) {
|
|
ut32 op = (data & OP_MASK);
|
|
|
|
if ((op == OP(4)) || (op == OP(56)) ||
|
|
(op == OP(57)) || (op == OP(60)) ||
|
|
(op == OP(61))) {
|
|
ut32 size = sizeof(ps_opcodes_array) / sizeof(ps_opcode_t);
|
|
ps_opcode_t *instruction = ps_opcodes_array;
|
|
|
|
ut32 l, j;
|
|
for (l = 0; l < size; l++) {
|
|
if ((data & instruction->mask) == instruction->opcode) {
|
|
j = 0;
|
|
for (; j < 6 && instruction->operands[j] != 0; j++) {
|
|
ppcps_field_t *field = &ps->operands[j];
|
|
ps_operand_t *ps_operand = &ps_operands_array[instruction->operands[j]];
|
|
|
|
int bits = (data >> ps_operand->shift) & ((1 << ps_operand->bits) - 1);
|
|
// int ext_bits = (bits << (32 - ps_operand->bits)) >> (32 - ps_operand->bits);
|
|
|
|
switch (instruction->operands[j]) {
|
|
case OP_FA:
|
|
case OP_FB:
|
|
case OP_FC:
|
|
case OP_FD: {
|
|
field->type = TYPE_REG;
|
|
field->value = bits;
|
|
break;
|
|
}
|
|
|
|
case OP_RA:
|
|
case OP_RB: {
|
|
field->type = TYPE_REG;
|
|
field->value = bits;
|
|
break;
|
|
}
|
|
|
|
case OP_crfD: {
|
|
field->type = TYPE_CR;
|
|
field->value = bits;
|
|
break;
|
|
}
|
|
case OP_WB:
|
|
case OP_IB:
|
|
case OP_WC:
|
|
case OP_IC: {
|
|
field->type = TYPE_IMM;
|
|
field->value = bits;
|
|
break;
|
|
}
|
|
|
|
case OP_DRA: {
|
|
ut16 imm = (ut16)(data & 0x7FF);
|
|
ut16 sign = (ut16)(data & 0x800);
|
|
st16 displacement = 0;
|
|
if (sign == 0) {
|
|
displacement = imm;
|
|
} else {
|
|
displacement = -1 * imm;
|
|
}
|
|
field->type = TYPE_MEM;
|
|
field->value = bits + displacement;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
ps->n = j;
|
|
ps->name = instruction->name;
|
|
ps->op = instruction->insn;
|
|
return true;
|
|
}
|
|
instruction++;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void libps_snprint(char *str, int size, ut64 addr, ppcps_t *instr) {
|
|
ut32 i;
|
|
int bufsize = size, add = 0;
|
|
add = snprintf(str, bufsize, "%s", instr->name);
|
|
for (i = 0; add > 0 && i < instr->n && add < bufsize; i++) {
|
|
if (instr->operands[i].type == TYPE_REG) {
|
|
add += snprintf(str + add, bufsize - add, " fr%u", instr->operands[i].value);
|
|
} else if (instr->operands[i].type == TYPE_IMM) {
|
|
add += snprintf(str + add, bufsize - add, " 0x%x", instr->operands[i].value);
|
|
} else if (instr->operands[i].type == TYPE_MEM) {
|
|
add += snprintf(str + add, bufsize - add, " 0x%x(r%d)", instr->operands[i].value, instr->operands[i + 1].value);
|
|
i++;
|
|
} else if (instr->operands[i].type == TYPE_CR) {
|
|
add += snprintf(str + add, bufsize - add, " cr%u", instr->operands[i].value);
|
|
}
|
|
}
|
|
}
|