libps.c File Reference

#include "libps.h"
#include "libps_internal.h"

Go to the source code of this file.

Functions
bool	libps_decode (ut32 data, ppcps_t *ps)
void	libps_snprint (char *str, int size, ut64 addr, ppcps_t *instr)

Variables
ps_operand_t	ps_operands_array []
ps_opcode_t	ps_opcodes_array []

Function Documentation

libps_decode()

bool libps_decode	(	ut32	data,
		ppcps_t *	ps
	)

Definition at line 97 of file libps.c.

                                          {
    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;
}

References ps_operand_t::bits, bits(), imm, ppcps_t::n, ppcps_t::name, OP, ppcps_t::op, OP_crfD, OP_DRA, OP_FA, OP_FB, OP_FC, OP_FD, OP_IB, OP_IC, OP_MASK, OP_RA, OP_RB, OP_WB, OP_WC, ppcps_t::operands, ps_opcodes_array, ps_operands_array, ps_operand_t::shift, st16, ppcps_field_t::type, TYPE_CR, TYPE_IMM, TYPE_MEM, TYPE_REG, and ppcps_field_t::value.

Referenced by decompile_ps().

libps_snprint()

void libps_snprint	(	char *	str,
		int	size,
		ut64	addr,
		ppcps_t *	instr
	)

Definition at line 177 of file libps.c.

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

References add(), i, ppcps_t::n, ppcps_t::name, ppcps_t::operands, snprintf, cmd_descs_generate::str, ppcps_field_t::type, TYPE_CR, TYPE_IMM, TYPE_MEM, TYPE_REG, and ppcps_field_t::value.

Referenced by decompile_ps().

Variable Documentation

ps_opcodes_array

ps_opcode_t ps_opcodes_array[]

Definition at line 23 of file libps.c.

Referenced by libps_decode().

ps_operands_array

ps_operand_t ps_operands_array[]

Initial value:

= {
    { 0, 0 }, 
    { 5, 16 }, 
    { 5, 11 }, 
    { 5, 6 }, 
    { 5, 21 }, 
    { 3, 23 }, 
    { 1, 16 }, 
    { 3, 12 }, 
    { 1, 10 }, 
    { 3, 7 }, 
    { 5, 16 }, 
    { 5, 11 }, 
    { 5, 16 }, 
    { 5, 11 }, 
}

Definition at line 6 of file libps.c.

Referenced by libps_decode().