#include <rz_types.h>
#include "pic_pic18.h"

Macros
#define	NO_ARG 0

#define	DAF_T 1

#define	F32_T 2

#define	BAF_T 3

#define	K_T 4

#define	N_T 5

#define	CALL_T 6

#define	NEX_T 7

#define	AF_T 8

#define	GOTO_T 9

#define	SHK_T 10

#define	S_T 11

#define	LFSR_T 12

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

Variables
static char *	fsr [] = { "fsr0", "fsr1", "fsr2", "reserved" }

struct {
ut16 opmin

ut16 opmax

char * name

ut8 optype

}	ops []

Macro Definition Documentation

◆ AF_T

#define AF_T 8

Definition at line 20 of file pic_pic18.c.

◆ BAF_T

#define BAF_T 3

Definition at line 15 of file pic_pic18.c.

◆ CALL_T

#define CALL_T 6

Definition at line 18 of file pic_pic18.c.

◆ DAF_T

#define DAF_T 1

Definition at line 13 of file pic_pic18.c.

◆ F32_T

#define F32_T 2

Definition at line 14 of file pic_pic18.c.

◆ GOTO_T

#define GOTO_T 9

Definition at line 21 of file pic_pic18.c.

◆ K_T

#define K_T 4

Definition at line 16 of file pic_pic18.c.

◆ LFSR_T

#define LFSR_T 12

Definition at line 24 of file pic_pic18.c.

◆ N_T

#define N_T 5

Definition at line 17 of file pic_pic18.c.

◆ NEX_T

#define NEX_T 7

Definition at line 19 of file pic_pic18.c.

◆ NO_ARG

#define NO_ARG 0

Definition at line 12 of file pic_pic18.c.

◆ S_T

#define S_T 11

Definition at line 23 of file pic_pic18.c.

◆ SHK_T

#define SHK_T 10

Definition at line 22 of file pic_pic18.c.

Function Documentation

◆ pic_pic18_disassemble()

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

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