// 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);
		}
	}
}
