dis_mips.c

umon bootloader source code, support mips cpu.

		rs();
		break;
	case RD_RS:
		rd(), comma(), rs();
		break;
	case RD_RS_RT:
		rd(), comma();
	case RS_RT:
		rs(), comma(), rt();
		break;
	case RD_RT_SFT:
		rd(), comma(), rt(), comma();
		sprintf(tmp, "0x%lx", SHAMT_(inst));
		strcat(dest, tmp);
		mkcomment(dest, "# %d", SHAMT_(inst));
		break;
	case RS_RT_OFF:
	case RS_OFF:
		rs(), comma();
		if (pt->type == RS_RT_OFF)
			rt(), comma();
	case OFF:
		v = IMM_(inst);
		if (v & (1L << 15))
			v |= 0xffff0000L;
		v1 = addr + 4L + (v << 2);
		sprintf(tmp, "%lx", v1);
		strcat(dest, tmp);
		mkcomment(dest, "# 0x%08lx", v1);
		break;
	case BPCODE:
		sprintf(tmp, "%ld", (inst >> 16) & 0x3ff);
		strcat(dest, tmp);
		break;
	case COFUN:
		sprintf(tmp, "0x%lx", inst & 0x01ffffffL);
		strcat(dest, tmp);
		break;
	case NONE:
		break;
	case TARGET:
		v = (inst & 0x03ffffffL) << 2;
		v |= (addr & 0xf0000000L);
		sprintf(tmp, "%lx", v);
		strcat(dest, tmp);
		mkcomment(dest, "# 0x%08lx", v);
		break;
	case JALR:
		if (RD_(inst) != 31L)
			rd(), comma();
		rs();
		break;
	case LDSTC0:
		v = IMM_(inst);
		if (v & (1L << 15))
			v |= 0xffff0000L;
		c0ft(), comma();
		sprintf(tmp, "%ld(", v);
		strcat(dest, tmp);
		rs();
		strcat(dest, ")");
		mkcomment(dest, "# 0x%x", v);
		break;
	case LDSTC1:
		v = IMM_(inst);
		if (v & (1L << 15))
			v |= 0xffff0000L;
		c1ft(), comma();
		sprintf(tmp, "%ld(", v);
		strcat(dest, tmp);
		rs();
		strcat(dest, ")");
		mkcomment(dest, "# 0x%x", v);
		break;
	case LDSTCN:
		v = IMM_(inst);
		if (v & (1L << 15))
			v |= 0xffff0000L;
		cnft(), comma();
		sprintf(tmp, "%ld(", v);
		strcat(dest, tmp);
		rs();
		strcat(dest, ")");
		mkcomment(dest, "# 0x%x", v);
		break;
	case CACHE_OP:
		v = IMM_(inst);
		if (v & (1L << 15))
			v |= 0xffff0000L;
		sprintf(tmp, "%ld,%ld(", RT_(inst), v);
		strcat(dest, tmp);
		rs();
		strcat(dest, ")");
		mkcomment(dest, "# 0x%x", v);
		break;
	case OFF_BASE:
		v = IMM_(inst);
		if (v & (1L << 15))
			v |= 0xffff0000L;
		sprintf(tmp, "%ld(", v);
		strcat(dest, tmp);
		rs();
		strcat(dest, ")");
		mkcomment(dest, "# 0x%x", v);
		break;
	case LOAD_STORE:
		v = IMM_(inst);
		if (v & (1L << 15))
			v |= 0xffff0000L;
		rt(), comma();
		sprintf(tmp, "%ld(", v);
		strcat(dest, tmp);
		rs();
		strcat(dest, ")");
		mkcomment(dest, "# 0x%x", v);
		break;
	case RT_C2:
	case RT_CC2:
		sprintf(tmp, "%08lx", inst);
		strcat(dest, tmp);
#if INCLUDE_MKCOMMENT
		strcat(dest, "      # ");
#endif
		p = (char *) &inst;
		for (i = 0; i < 4; i++) {
			v = *p++;
			if (isprint(v))
				strccat(dest, v);
			else
				strccat(dest, '.');
		}
		break;
	case WORD:
		sprintf(tmp, "%08lx", inst);
		strcat(dest, tmp);
		break;
	}
	return (addr + 4L);
}

/*************************************************************
*  DISTBL *get_distbl(bits)
*/
DISTBL *
get_distbl(long bits)
{
	DISTBL *pt = distbl;

	while ((bits & pt->mask) != pt->code)
		++pt;
	return (pt);
}


/*************************************************************
*  int is_branch(adr)
*/
int 
is_branch(unsigned long adr)
{
	DISTBL *pt;
	unsigned long inst;

	inst = *(unsigned long *)(adr);
	pt = get_distbl(inst);
	switch (pt->type) {
	case OFF:
	case RS_RT_OFF:
	case RS_OFF:
	case TARGET:
	case JALR:
	case JR:
		return (1);
	default:
		return (0);
	}
}

/*************************************************************
*  int is_branch_likely(adr)
*	returns true if instr at adr is a branch likely instr
*/
int 
is_branch_likely(unsigned long adr)
{
	DISTBL *pt;
	unsigned long inst;
	int len;

	inst = *(unsigned long *)(adr);
	pt = get_distbl(inst);
	if (pt->str[0] != 'b')
		return (0);
	len = strlen(pt->str);
	if (pt->str[len - 1] == 'l' && pt->str[len - 2] != 'a')
		return (1);
	return (0);
}

/*************************************************************
*  int is_conditional_branch(adr)
*/
int 
is_conditional_branch(unsigned long adr)
{
	DISTBL *pt;
	unsigned long inst;

	inst = *(unsigned long *)(adr);
	pt = get_distbl(inst);
	switch (pt->type) {
	case OFF:
	case RS_RT_OFF:
	case RS_OFF:
		return (1);
	default:
		return (0);
	}
}

/*************************************************************
*  is_jr(adr)
*/
int
is_jr(unsigned long adr)
{
	DISTBL *pt;
	unsigned long inst;

	inst = *(unsigned long *)(adr);
	pt = get_distbl(inst);
	if (pt->type == JR)
		return (1);
	return (0);
}

/*************************************************************
*  is_jal(adr)
*/
int
is_jal(unsigned long adr)
{
	unsigned long inst;
	int op;

	inst = *(unsigned long *)(adr);
	op = getfield(inst, 6, 26);
	if (op == 3)
		return (1);
	if (op == 0 && getfield(inst, 6, 0) == 9)
		return (1);
	return (0);
}

/*************************************************************
*  unsigned long branch_target_address(adr)
*/
unsigned long 
branch_target_address(adr)
unsigned long adr;
{
	DISTBL *pt;
	unsigned long val;
	unsigned long inst;
	extern unsigned long regtbl[];

	inst = *(unsigned long *)(adr);
	pt = get_distbl(inst);
	switch (pt->type) {
	case OFF:
	case RS_RT_OFF:
	case RS_OFF:
		val = inst & 0xffff;
		if (val & 0x8000)
			val |= 0xffff0000;
		return (adr + 4 + (val << 2));
	case TARGET:
		val = inst & 0x3ffffff;
		return (((adr + 4) & 0xf0000000) | (val << 2));
	case JALR:
	case JR:
		val = RS_(inst);
		return (regtbl[val]);
	default:
		return (0);
	}
}

/*************************************************************
*  is_writeable(adr)
*/
int
is_writeable(adr)
unsigned long adr;
{
	unsigned long x;

	x = *(unsigned long *)(adr);
	*(long *)adr =  ~x;
	flushDcache((char *)adr,4);
	if (*(unsigned long *)(adr) != ~x)
		return (0);
	*(long *)adr = x;
	return (1);
}

/*************************************************************
*  simm(dest)
*	signed immediate value
*/
int
simm(char *dest)
{
	char tmp[20];
	long v;

	v = IMM_(inst);
	sprintf(tmp, "0x%lx", v);
	strcat(dest, tmp);
	if (v >= 0 && v <= 9)
		return(0);
	if (v & (1L << 15))
		v |= 0xffff0000L;
	mkcomment(dest, "# %d", v);
	return(0);
}

/*************************************************************
*  imm(dest)
*	unsigned immediate value
*/
int
imm(char *dest)
{
	char tmp[20];
	long v;

	v = IMM_(inst);
	sprintf(tmp, "0x%lx", v);
	strcat(dest, tmp);
	if (v >= 0 && v <= 9)
		return(0);
	mkcomment(dest, "# %d", v);
	return(0);
}

#if INCLUDE_MKCOMMENT
/*************************************************************
*  mkcomment(p,fmt,v)
*	generate an appropriate comment
*/
int
mkcomment(char *p, char *fmt, long v)
{
	char tmp[20];
	int n;

	if (v >= 0 && v <= 9)
		return(0);
	for (n = 60 - strlen(p); n > 0; n--)
		strcat(p, " ");
	sprintf(tmp, fmt, v);
	strcat(p, tmp);
	return(0);
}
#endif

char *
DisHelp[] = {
	"Disassemble memory",
	"-[m]    {address} [linecount]",
	0,
};

/************************************************************************
 *                          dis
 ************************************************************************/
int
Dis(int argc, char *argv[])
{
	long	adr, lcnt;
	int		i, opt, more;

	lcnt = 8;
    more  = 0;
	while ((opt = getopt(argc,argv,"m")) != -1) {
		switch(opt) {
		case 'm':
			more = 1;
			break;
		default:
			return(0);
		}
	}

	if (argc < (optind+1))
		return(CMD_PARAM_ERROR);

	adr = strtoul(argv[optind],0,0);
	if (argc == (optind+2))
		lcnt = strtol(argv[optind+1],0,0);

	while (1) {
		for(i=0;i<lcnt;i++) {
			adr = disasm(prnbuf, adr, *(ulong *)(adr));
			printf("%s\n",prnbuf);
		}
		if (!more)
			break;
		if (!More())
			break;
	}
	return(CMD_SUCCESS);
}

#endif