disassemble.c

T－Kernel Shell Sample

/*""FILE COMMENT""*************************************************************
*   System Name : RENESAS uT-Engine
*   File Name   : disassemble.c 
*   Version     : 1.01.00
*   Contents    : Disassemble memory 
*   Model       : SH7145 micro T-Engine
*   CPU         : SH7145
*   Compiler    : GNU
*   OS          : T-Kernel
*
*   note        : The Software is being delivered to you "AS IS" 
*               : and Renesas,whether explicitly or implicitly makes  
*               : no warranty as to its Use or performance. 
*               : RENESAS AND ITS SUPPLIER DO NOT AND CANNOT WARRANT 
*               : THE PERFORMANCE OR RESULTS YOU MAY OBTAIN  BY USING 
*               : THE SOFTWARE. AS TO ANY MATTER INCLUDING WITHOUT 
*               : LIMITATION NONINFRINGEMENT OF THIRD PARTY RIGHTS,
*               : MERCHANTABILITY, INTEGRATION, SATISFACTORY QUALITY, 
*               : OR FITNESS FOR ANY PARTICULAR PURPOSE.
*
*   Copyright (c) 2004-2006 RENESAS TECHNOLOGY CORP. All Rights Reserved.
*   AND RENESAS SOLUTIONS CORP. All Rights Reserved.
*
*   history     : 2004.12.21 ver1.00.00
*               : 2006.02.01 ver1.01.00
*""FILE COMMENT END""*********************************************************/

#ifdef _MIC_SH7145_
#include <tk/tkernel.h>
#include "shell.h"
#include "shelldisp.h"

#define ADDROFFSET	0x10

extern int argcnt;
extern char *cmdargs[];
extern W errcode;

extern char strstrstr[];
void disasmword();

typedef struct mnemonictbldata {
	unsigned short data;
	char           *inst; 
} MnemonicTable;

const MnemonicTable noArgsMnemonicTbl[8] = {
	{ 0x0009,"NOP "},
	{ 0x000B,"RTS "},
	{ 0x002B,"RTE "},
	{ 0x0018,"SETT"},
	{ 0x001B,"SLEEP "},
	{ 0x0008,"CLRT"},
	{ 0x0028,"CLRMAC"},
	{ 0x0019,"DIV0U "}
};
const MnemonicTable mnemonicTbl0[9] = {
      /* 1234567890123456789 */
	 { 4, "MOV.B   R%d,@(R0,R%d)"},
	 { 5, "MOV.W   R%d,@(R0,R%d)"},
	 { 6, "MOV.L   R%d,@(R0,R%d)"},
	 { 7, "MUL.L   R%d,R%d"},      
	 { 9, "MOVT    R%d"},          
	{ 12, "MOV.B   @(R0,R%d),R%d"},
	{ 13, "MOV.W   @(R0,R%d),R%d"},
	{ 14, "MOV.L   @(R0,R%d),R%d"},
	{ 15, "MAC.L   @R%d+,@R%d+"},  
};
const char *mnemonicTbl0_STC[3] = {
  /* 1234567890123456789 */
	"STC     SR,R%d",
	"STC     GBR,R%d",
	"STC     VBR,R%d"
};
const char *mnemonicTbl0_STS[3] = {
  /* 1234567890123456789 */
	"STS     MACH,R%d",
	"STS     MACL,R%d",
	"STS     PR,R%d"
};
const char *mnemonicTbl0_BRA[2] = {
  /* 1234567890123456789 */
	"BSRF    R%d",
	"BRAF    R%d"
};
const char *mnemonicTbl2[16] = {
  /* 1234567890123456789 */
	"MOV.B   R%d,@R%d",
	"MOV.W   R%d,@R%d",
	"MOV.L   R%d,@R%d",
	0,
	"MOV.B   R%d,@-R%d",
	"MOV.W   R%d,@-R%d",
	"MOV.L   R%d,@-R%d",
	"DIV0S   R%d,R%d",
	"TST     R%d,R%d",
	"AND     R%d,R%d",
	"XOR     R%d,R%d",
	"OR      R%d,R%d",
	"CMP/STR R%d,R%d",
	"XTRCT   R%d,R%d",
	"MULU.W  R%d,R%d",
	"MULS.W  R%d,R%d",
};
const char *mnemonicTbl3[16] = {
	"CMP/EQ  R%d,R%d",
	0,
	"CMP/HS  R%d,R%d",
	"CMP/GE  R%d,R%d",
	"DIV1    R%d,R%d",
	"DMULU.L R%d,R%d",
	"CMP/HI  R%d,R%d",
	"CMP/GT  R%d,R%d",
	"SUB     R%d,R%d",
	0,
	"SUBC    R%d,R%d",
	"SUBV    R%d,R%d",
	"ADD     R%d,R%d",
	"DMULS.L R%d,R%d",
	"ADDC    R%d,R%d",
	"ADDV    R%d,R%d",
};

const char *mnemonicTbl4[] = {
	/*  0 */ "SHLL    R%d",       "DT      R%d",       "SHAL    R%d",
	/*  1 */ "SHLR    R%d",       "CMP/PZ  R%d",       "SHAR    R%d",
	/*  2 */ "STS.L   MACH,@-R%d","STS.L   MACL,@-R%d","STS.L   PR,@-R%d",
	/*  3 */ "STC.L   SR,@-R%d",  "STC.L   GBR,@-R%d", "STC.L   VBR,@-R%d",
	/*  4 */ "ROTL    R%d",       "ROTCL   R%d",
	/*  5 */ "ROTR    R%d",       "CMP/PL  R%d",       "ROTCR   R%d",
	/*  6 */ "LDS.L   @R%d+,MACH","LDS.L   @R%d+,MACL","LDS.L   @R%d+,PR",
	/*  7 */ "LDC.L   @R%d+,SR",  "LDC.L   @R%d+,GBR", "LDC.L   @R%d+,VBR",
	/*  8 */ "SHLL2   R%d",       "SHLL8   R%d",       "SHLL16  R%d",
	/*  9 */ "SHLR2   R%d",       "SHLR8   R%d",       "SHLR16  R%d",
	/* 10 */ "LDS     R%d,MACH",  "LDS     R%d,MACL",  "LDS     R%d,PR",
	/* 11 */ "JSR     @R%d",      "TAS.B   @R%d",      "JMP     @R%d",
	/* 14 */ "LDC     R%d,SR",    "LDC     R%d,GBR",   "LDC     R%d,VBR",
	/* 15 */ "MAC.W   @R%d+,@R%d+"
};
int Tbl4offset[] = { 0,3,6,9,12,14,17,20,23,26,29,32,0,0,35,38 };

const char *mnemonicTbl6[16] = {
  /* 1234567890123456789 */
	"MOV.B   @R%d,R%d",
	"MOV.W   @R%d,R%d",
	"MOV.L   @R%d,R%d",
	"MOV     R%d,R%d",
	"MOV.B   @R%d+,R%d",
	"MOV.W   @R%d+,R%d",
	"MOV.L   @R%d+,R%d",
	"NOT     R%d,R%d",
	"SWAP.B  R%d,R%d",
	"SWAP.W  R%d,R%d",
	"NEGC    R%d,R%d",
	"NEG     R%d,R%d",
	"EXTU.B  R%d,R%d",
	"EXTU.W  R%d,R%d",
	"EXTS.B  R%d,R%d",
	"EXTS.W  R%d,R%d",
};
const MnemonicTable mnemonicTbl8[16] = {
     /* 1234567890123456789 */
	 { 0,"MOV.B   R0,@(H'%02X:4,R%d)"},
	 { 2,"MOV.W   R0,@(H'%02X:4,R%d)"},
	 { 0xFFFF,0},
	 { 0xFFFF,0},
	 { 0,"MOV.B   @(H'%02X:4,R%d),R0"},
	 { 2,"MOV.W   @(H'%02X:4,R%d),R0"},
	 { 0xFFFF,0},
	 { 0xFFFF,0},
	 { 0,"CMP/EQ  #H'%02X,R0"},
	 { 0x12,"BT      @H'%X:8"},
	 { 0xFFFF,0},
	 { 0x12,"BF      @H'%X:8"},
	 { 0xFFFF,0},
	 { 0x12,"BT/S    @H'%X:8"},
	 { 0xFFFF,0},
	 { 0x12,"BF/S    @H'%X:8"},
};
const MnemonicTable mnemonicTbl12[16] = {
  /* 1234567890123456789 */
	{ 0,"MOV.B   R0,@(H'%04X:8,GBR)"},
	{ 2,"MOV.W   R0,@(H'%04X:8,GBR)"},
	{ 4,"MOV.L   R0,@(H'%04X:8,GBR)"},
	{ 0,"TRAPA   #H'%02X"},
	{ 0,"MOV.B   @(H'%04X:8,GBR),R0"},
	{ 2,"MOV.W   @(H'%04X:8,GBR),R0"},
	{ 4,"MOV.L   @(H'%04X:8,GBR),R0"},
	{ 4,"MOVA    @(H'%04X:8,PC),R0"},
	{ 0,"TST     #H'%02X,R0"},
	{ 0,"AND     #H'%02X,R0"},
	{ 0,"XOR     #H'%02X,R0"},
	{ 0,"OR      #H'%02X,R0"},
	{ 0,"TST.B   #H'%02X,@(R0,GBR)"},
	{ 0,"AND.B   #H'%02X,@(R0,GBR)"},
	{ 0,"XOR.B   #H'%02X,@(R0,GBR)"},
	{ 0,"OR.B    #H'%02X,@(R0,GBR)"},
};

/*""FUNC COMMENT""*******************************************************
 * ID          : X.Y.Z
 * Abstructs   : Disassemble memory
 *-----------------------------------------------------------------------
 * Include     : 
 *-----------------------------------------------------------------------
 * Definition  : void DISASM_cmd()
 *-----------------------------------------------------------------------
 * Function    : Disassemble memory
 *-----------------------------------------------------------------------
 * Argument    : None
 *----------------------------------------------------------------------- 
 * Return      : None
 *-----------------------------------------------------------------------
 * Input       : int argcnt;      input command count 
 *             : char *cmdargs[]; input command data
 * Output      : None 
 *-----------------------------------------------------------------------
 * Used Func   : disasemline()
 *             : convertstring()
 *             : _PutString() 
 *-----------------------------------------------------------------------
 * Notice      : None
 *""FUNC COMMENT END""***************************************************/
void DISASM_cmd() {
	int      i,ercd,count;
	unsigned long startaddr,endaddr;
	unsigned short *addr_offset;

	if(argcnt) {
		startaddr = get_ulnum(cmdargs[1],&ercd);
		if(ercd) goto illegalpar_return;
		if(startaddr%02) goto illegalpar_return; 
		count = ADDROFFSET;
		if(argcnt == 2) { 
			endaddr = get_ulnum(cmdargs[2],&ercd);
			if(ercd) goto illegalpar_return;
			if(endaddr < startaddr) goto illegalpar_return;
			count = (endaddr - startaddr)>>1; 
		}
    } else {
		errcode = ER_LESSPAR;
		return;
	}

	addr_offset = (unsigned short *)startaddr;

	for(i=0;i<count;i++){
		printargs[0] = (VP)addr_offset;
		printargs[1] = (VP)(*(addr_offset));
		convertstring(strstrstr,"%08X %04X ",printargs);
		DSP;
		disasmword(addr_offset);
		DSP_LF;
		addr_offset++;
	}
	return;
illegalpar_return:
	errcode = ER_ILLEGALPAR;
	return;
}
/*""FUNC COMMENT""*******************************************************
 * ID          : X.Y.Z
 * Abstructs   : Disassemble 1word(16bit) data
 *-----------------------------------------------------------------------
 * Include     : 
 *-----------------------------------------------------------------------
 * Definition  : void disasmword(unsigned short *)
 *-----------------------------------------------------------------------
 * Function    : Disassemble 1word(16bit) data
 *-----------------------------------------------------------------------
 * Argument    : unsigned short *addr; 
 *----------------------------------------------------------------------- 
 * Return      : nmonic code string
 *-----------------------------------------------------------------------
 * Input       : None 
 * Output      : None 
 *-----------------------------------------------------------------------
 * Used Func   : convertstring()
 *             : _PutString() 
 *-----------------------------------------------------------------------
 * Notice      : None
 *""FUNC COMMENT END""***************************************************/
void disasmword(unsigned short *addr){
	int i,offset;
	unsigned short data0,data1,data2,data3;
	unsigned short data;
	short          pcdisp;

	data = *addr;

	data0 = (data & 0xf000) >> 12;
	data1  = (data & 0x0f00) >> 8;
	data2   = (data & 0x00f0) >> 4;
	data3   = (data & 0x000f);

	if(data0 == 15) goto data_return; /* "DATA" */

	switch(data0){
		case  0:
			/* check no args instruction */
			for(i=0;i<8;i++) {
				if(data == noArgsMnemonicTbl[i].data) {
					_PutString(noArgsMnemonicTbl[i].inst);
					return;
				}
			}
			
    		/* check args instruction */
			switch(data3){
				case 0:
				case 1:
				case 8:
					goto data_return;
					break;
				case 2:
					if(data2>2) goto data_return;
					printargs[0] = (VP)data1;
					convertstring(strstrstr,(unsigned char *)mnemonicTbl0_STC[data2],printargs);
					DSP;
					break;
				case 3:
					if((!data2)||(data2==2)) {
						printargs[0] = (VP)data1;
						if(data2) offset = 1;
						else offset = 0;
						convertstring(strstrstr,(unsigned char *)mnemonicTbl0_BRA[offset],printargs);
						DSP;
					} else  goto data_return;
					break;
				case 10:
					if(data2>2) goto data_return;
					printargs[0] = (VP)data1;
					convertstring(strstrstr,(unsigned char *)mnemonicTbl0_STS[data2],printargs);
					DSP;
					break;
				
				default:
					for(i=0;i<9;i++) {
						if( data3 == mnemonicTbl0[i].data) {
							if(data3 == 9 ) {
								if(data2 != 2) goto data_return;
								else printargs[0] = (VP)data1;
							} else {
								printargs[0] = (VP)data2;
								printargs[1] = (VP)data1;
							}
							convertstring(strstrstr,(unsigned char *)mnemonicTbl0[i].inst,printargs);
							DSP;
							return;
							break;
						}
					}
					goto data_return;
					break;
			}
			break; 
		case  1: /* "MOV.L Rm,@(disp,Rn)" data1=n,2=m,3=disp */
			printargs[0] = (VP)data2;
			printargs[1] = (VP)(data3*4);
			printargs[2] = (VP)data1;
			convertstring(strstrstr,"MOV.L   R%d,@(H'%02X:4,R%d)",printargs);
			DSP;
			break;
		case  2: /* data1=n,data2=m */
			if(data3 == 3) goto data_return;
			printargs[0] = (VP)data2;
			printargs[1] = (VP)data1;
			convertstring(strstrstr,(unsigned char *)mnemonicTbl2[data3],printargs);	
			DSP;
			break;
		case  3:
			if((data3 == 1)||(data3 == 9)) goto data_return; 
			printargs[0] = (VP)data2;
			printargs[1] = (VP)data1;
			convertstring(strstrstr,(unsigned char *)mnemonicTbl3[data3],printargs);	
			DSP;
			break;
		case  4:
			switch(data3){
				case  4:
					if((data2>2)||(data2==1)) goto data_return;
					if(data2) offset = Tbl4offset[4] + 1;
					else offset = Tbl4offset[4];
					break;
				case 12:
				case 13:
					goto data_return; break;
				case 15:
					printargs[0] = (VP)data2;
					printargs[1] = (VP)data1;
					convertstring(strstrstr,(unsigned char *)mnemonicTbl4[38],printargs);
					DSP;
					return;
					break;
				default:
					if(data2>2) goto data_return;
					offset = Tbl4offset[data3]+data2;	
					break;
			}
			printargs[0] = (VP)data1;
			convertstring(strstrstr,(unsigned char *)mnemonicTbl4[offset],printargs);
			DSP;
			break;
		case  5: /* "MOV.L @(disp,Rm),Rn" data1=n,2=m,3=disp */
			printargs[0] = (VP)(data3*4);
			printargs[1] = (VP)data2;
			printargs[2] = (VP)data1;
			convertstring(strstrstr,"MOV.L   @(H'%02X:4,R%d),R%d",printargs);
			DSP;
			break;
		case  6:
			printargs[0] = (VP)data2;
			printargs[1] = (VP)data1;
			convertstring(strstrstr,(unsigned char *)mnemonicTbl6[data3],printargs);	
			DSP;
			break;
		case  7: /* "ADD  #imm,Rn" data1=n,2,3=imm */
		case 14: /* "MOV  #imm,Rn" data1=n,2,3=imm */
			if(data0 == 7) printargs[0] = (VP)"ADD";
			else printargs[0] = (VP)"MOV";
			printargs[1] = (VP)(data&0x00FF);
			printargs[2] = (VP)data1;
			convertstring(strstrstr,"%s     #H'%02X,R%d",printargs);
			DSP;
			break;
		case  8:
			if(mnemonicTbl8[data1].data != 0xFFFF) {
				if( data1 >=8 ){
					if(data1 == 8 ) {
						printargs[0] = (VP)(data&0x00FF);
					} else {
						pcdisp = (data&0x00FF); 
						if(pcdisp & 0x0080) pcdisp -= 0x100;
						printargs[0] = (VP)(pcdisp+addr+2);
					}
				} else {
					if(mnemonicTbl8[data1].data) printargs[0] = (VP)(data3*2);
					else printargs[0] = (VP)data3;
					printargs[1] = (VP)data2;
				}
				convertstring(strstrstr,(unsigned char *)mnemonicTbl8[data1].inst,printargs);
				DSP;
				return;
			} else goto data_return;
			break;
		case  9: /* "MOV.W @(disp,PC),Rn" data1=n,2,3=disp */
		case 13: /* "MOV.L @(disp,PC),Rn" data1=n,2,3=disp */
			if(data0 == 9) {
				printargs[0] = (VP)"W";
				printargs[1] = (VP)((data&0x00FF)*2);
			} else {
				printargs[0] = (VP)"L";
				printargs[1] = (VP)((data&0x00FF)*4);
			}
			printargs[2] = (VP)data1;
			convertstring(strstrstr,"MOV.%s   @(H'%04X:8,PC),R%d",printargs);
			DSP;
			break;
		case 10: /* "BRA   label" data1,2,3=label */
		case 11: /* "BSR   label" data1,2,3=label */
			if(data0 == 10) printargs[0] = (VP)"RA";
			else printargs[0] = (VP)"SR";
			pcdisp = (data&0x0FFF); 
			if(pcdisp & 0x0800) pcdisp -= 0x1000;
			printargs[1] = (VP)(pcdisp+addr+2);
			convertstring(strstrstr,"B%s     @H'%X:12",printargs);
			DSP;
			break;
		case 12:
			i = mnemonicTbl12[data1].data;
			if(i>0) printargs[0] = (VP)((data&0x00FF)*i);
			else printargs[0] = (VP)(data&0x00FF);
			convertstring(strstrstr,(unsigned char *)mnemonicTbl12[data1].inst,printargs);	
			DSP;
			break;
		case 15:
			goto data_return; break;
	}
	return;
data_return:
	_PutString("DATA");
	return;
}
#endif // _MIC_SH7145_