pic_pic18.h File Reference

#include <rz_asm.h>

Go to the source code of this file.

Functions
int	pic_pic18_disassemble (RzAsmOp *op, char *opbuf, const ut8 *b, int l)

Function Documentation

pic_pic18_disassemble()

int pic_pic18_disassemble	(	RzAsmOp *	op,
		char *	opbuf,
		const ut8 *	b,
		int	l
	)

Definition at line 114 of file pic_pic18.c.

                                                                            {
    int i;
    if (blen < 2) { // well noone loves reading bitstream of size zero or 1 !!
        strcpy(opbuf, "invalid");
        op->size = blen;
        return -1;
    }
    ut16 instr = rz_read_le16(b); // instruction
    // if still redundan code is reported think of this of instr=0x2
    const char *buf_asm = "invalid";
    strcpy(opbuf, buf_asm);
 
    for (i = 0; ops[i].opmin != (ops[i].opmin & instr) || ops[i].opmax != (ops[i].opmax | instr); i++) {
        ;
    }
    if (ops[i].opmin == 0 && ops[i].opmax == 0xffff) {
        strcpy(opbuf, ops[i].name);
        op->size = 2;
        return -1;
    }
    op->size = 2;
    switch (ops[i].optype) {
    case NO_ARG:
        buf_asm = ops[i].name;
        break;
    case N_T:
    case K_T:
        buf_asm = sdb_fmt("%s 0x%x", ops[i].name, instr & 0xff);
        break;
    case DAF_T:
        buf_asm = sdb_fmt("%s 0x%x, %d, %d", ops[i].name, instr & 0xff, (instr >> 9) & 1, (instr >> 8) & 1);
        break;
    case AF_T:
        buf_asm = sdb_fmt("%s 0x%x, %d", ops[i].name, instr & 0xff, (instr >> 8) & 1);
        break;
    case BAF_T:
        buf_asm = sdb_fmt("%s 0x%x, %d, %d", ops[i].name, instr & 0xff, (instr >> 9) & 0x7, (instr >> 8) & 0x1);
        break;
    case NEX_T:
        buf_asm = sdb_fmt("%s 0x%x", ops[i].name, instr & 0x7ff);
        break;
    case CALL_T:
        if (blen < 4) {
            return -1;
        }
        op->size = 4;
        {
            ut32 dword_instr = rz_read_le32(b);
            // I dont even know how the bits are arranged but it works !!!
            //`the wierdness of little endianess`
            if (dword_instr >> 28 != 0xf) {
                return -1;
            }
            buf_asm = sdb_fmt("%s 0x%x, %d", ops[i].name,
                (dword_instr & 0xff) | (dword_instr >> 8 & 0xfff00), (dword_instr >> 8) & 0x1);
        }
        break;
    case GOTO_T:
        if (blen < 4) {
            return -1;
        }
        {
            op->size = 4;
            ut32 dword_instr = rz_read_le32(b);
            if (dword_instr >> 28 != 0xf) {
                return -1;
            }
            buf_asm = sdb_fmt("%s 0x%x", ops[i].name,
                ((dword_instr & 0xff) | ((dword_instr & 0xfff0000) >> 8)) * 2);
        }
        break;
    case F32_T:
        if (blen < 4) {
            return -1;
        }
        op->size = 4;
        {
            ut32 dword_instr = rz_read_le32(b);
            if (dword_instr >> 28 != 0xf) {
                return -1;
            }
            buf_asm = sdb_fmt("%s 0x%x, 0x%x", ops[i].name,
                dword_instr & 0xfff, (dword_instr >> 16) & 0xfff);
        }
        break;
    case SHK_T:
        buf_asm = sdb_fmt("%s 0x%x", ops[i].name, instr & 0xf);
        break;
    case S_T:
        buf_asm = sdb_fmt("%s %d", ops[i].name, instr & 0x1);
        break;
    case LFSR_T: {
        if (blen < 4) {
            return -1;
        }
        op->size = 4;
        ut32 dword_instr = rz_read_le32(b);
        if (dword_instr >> 28 != 0xf) {
            return -1;
        }
        ut8 reg_n = (dword_instr >> 4) & 0x3;
        buf_asm = sdb_fmt("%s %s, %d", ops[i].name, fsr[reg_n],
            (dword_instr & 0xf) << 8 | ((dword_instr >> 16) & 0xff));
        break;
    }
    default:
        buf_asm = "unknown args";
    };
    strcpy(opbuf, buf_asm);
    return op->size;
}

References AF_T, b, BAF_T, CALL_T, DAF_T, F32_T, fsr, GOTO_T, i, K_T, LFSR_T, N_T, NEX_T, NO_ARG, opmax, opmin, ops, rz_read_le16(), rz_read_le32(), S_T, sdb_fmt(), and SHK_T.

Referenced by asm_pic_disassemble().