mpc.c

Coldfire MCF5282 DBug bootloader

		case 149:
			append_string(dstr,"DER");
			break;
		case 150:
			append_string(dstr,"COUNTA");
			break;
		case 151:
			append_string(dstr,"COUNTB");
			break;
		case 152:
			append_string(dstr,"CMPE");
			break;
		case 153:
			append_string(dstr,"CMPF");
			break;
		case 154:
			append_string(dstr,"CMPG");
			break;
		case 155:
			append_string(dstr,"CMPH");
			break;
		case 156:
			append_string(dstr,"LCTRL1");
			break;
		case 157:
			append_string(dstr,"LCTRL2");
			break;
		case 158:
			append_string(dstr,"ICTRL");
			break;
		case 159:
			append_string(dstr,"BAR");
			break;
		case 272:
			append_string(dstr,"SPRG0");
			break;
		case 273:
			append_string(dstr,"SPRG1");
			break;
		case 274:
			append_string(dstr,"SPRG2");
			break;
		case 275:
			append_string(dstr,"SPRG3");
			break;
		case 268:
		case 284:
			append_string(dstr,"TBL");
			break;
		case 269:
		case 285:
			append_string(dstr,"TBU");
			break;
		case 287:
			append_string(dstr,"PVR");
			break;
		case 528:
			append_string(dstr,"MI_GRA");
			break;
		case 536:
			append_string(dstr,"L2U_GRA");
			break;
		case 560:
			append_string(dstr,"BBCMCR");
			break;
		case 568:
			append_string(dstr,"L2U_MCR");
			break;
		case 630:
			append_string(dstr,"DPDR");
			break;
		case 638:
			append_string(dstr,"IMMR");
			break;
		case 784:
			append_string(dstr,"MI_RBA0");
			break;
		case 785:
			append_string(dstr,"MI_RBA1");
			break;
		case 786:
			append_string(dstr,"MI_RBA2");
			break;
		case 787:
			append_string(dstr,"MI_RBA3");
			break;
		case 792:
			append_string(dstr,"L2U_RBA0");
			break;
		case 793:
			append_string(dstr,"L2U_RBA1");
			break;
		case 794:
			append_string(dstr,"L2U_RBA2");
			break;
		case 795:
			append_string(dstr,"L2U_RBA3");
			break;
		case 816:
			append_string(dstr,"MI_RA0");
			break;
		case 817:
			append_string(dstr,"MI_RA1");
			break;
		case 818:
			append_string(dstr,"MI_RA2");
			break;
		case 819:
			append_string(dstr,"MI_RA3");
			break;
		case 824:
			append_string(dstr,"L2U_RA0");
			break;
		case 825:
			append_string(dstr,"L2U_RA1");
			break;
		case 826:
			append_string(dstr,"L2U_RA2");
			break;	
		case 827:
			append_string(dstr,"L2U_RA3");
			break;		
		case 1022:
			append_string(dstr,"FPECR");
			break;
#endif
		default:
			if (cpu_get_spr_name(opw1) != NULL)
				append_string(dstr,cpu_get_spr_name(opw1));
			else
				append_Xbit_number(dstr,opw1,10,22);
			break;
	}
	if (((opword & 0x000007FE) >> 1) == 467)	/* mtspr */
	{
		append_string(dstr,COMMA);
		append_register(dstr,opword,REG_INT,6);
	}
}

/********************************************************************/
static void
func29 (unsigned int opword)
{
	append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);
	append_Xbit_number(dstr,opword,5,11);
}

/********************************************************************/
static void
func30 (unsigned int opword)
{
	append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,16);
}

/********************************************************************/
static void
func31 (unsigned int opword)
{
	unsigned int opw1, opw2;

	/* the TBR field is split, knock it out and put it together */
	/* as a single 10-bit field.								*/
	opw1 = (opword & 0x001F0000) >> 16;
	opw2 = (opword & 0x0000F800) >> 6;
	opw1 = opw1 | opw2;

	append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);
	switch (opw1)
	{
		case 268:
			append_string(dstr,"TBL");
			break;
		case 269:
			append_string(dstr,"TBU");
			break;
		default:
			append_Xbit_number(dstr,opw1,10,22);
			break;
	}
}

/********************************************************************/
static void
func32 (unsigned int opword)
{
	append_Xbit_number(dstr,opword,8,12);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,6);
}

/********************************************************************/
static void
func33 (unsigned int opword)
{
	append_Xbit_number(dstr,opword,5,6);
}

/********************************************************************/
static void
func34 (unsigned int opword)
{
	append_Xbit_number(dstr,opword,8,7);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_FLOAT,16);
}

/********************************************************************/
static void
func35 (unsigned int opword)
{
	append_Xbit_number(dstr,opword,3,6);
	append_string(dstr,COMMA);
	append_Xbit_number(dstr,opword,4,16);
}

/********************************************************************/
static void
func36 (unsigned int opword)
{
	append_Xbit_number(dstr,opword,5,11);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,6);
}

/********************************************************************/
static void
func37 (unsigned int opword)
{
	append_register(dstr,opword,REG_INT,11);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);
	append_value(dstr,opword & 0x0000FFFF,16);
}

#if 0
/* needed for 64-bit implementations */
/********************************************************************/
static void
func38 (unsigned int opword)
{
	int mb;

	append_register(dstr,opword,REG_INT,11);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,16);
	append_string(dstr,COMMA);

	if (opword & 0x00000020)	/* mb[5] */
	{
		mb = 0x00000020 | ((opword & 0x000007C0) >> 6);
	}
	else
	{
		mb = ((opword & 0x000007C0) >> 6);
	}
	append_Xbit_number(dstr,mb,6,26);
}

/********************************************************************/
static void
func39 (unsigned int opword)
{
	int mb;

	append_register(dstr,opword,REG_INT,11);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);

	if (opword & 0x00000800)	/* sh[5] */
	{
		mb = 0x00000020 | ((opword & 0x0000F000) >> 12);
	}
	else
	{
		mb = ((opword & 0x0000F000) >> 12);
	}
	append_Xbit_number(dstr,mb,5,27);

	append_string(dstr,COMMA);

	if (opword & 0x00000020)	/* mb[5] */
	{
		mb = 0x00000020 | ((opword & 0x000007C0) >> 6);
	}
	else
	{
		mb = ((opword & 0x000007C0) >> 6);
	}
	append_Xbit_number(dstr,mb,6,26);
}
#endif

/********************************************************************/
static void
func40 (unsigned int opword)
{
	append_register(dstr,opword,REG_INT,11);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);
	append_Xbit_number(dstr,opword,5,16);
	append_string(dstr,COMMA);
	append_Xbit_number(dstr,opword,5,21);
	append_string(dstr,COMMA);
	append_Xbit_number(dstr,opword,5,26);
}

/********************************************************************/
static void
func41 (unsigned int opword)
{
	append_register(dstr,opword,REG_INT,11);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,16);
	append_string(dstr,COMMA);
	append_Xbit_number(dstr,opword,5,21);
	append_string(dstr,COMMA);
	append_Xbit_number(dstr,opword,5,26);
}

/********************************************************************/
static void
func42 (unsigned int opword)
{
	append_register(dstr,opword,REG_INT,11);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);
	append_Xbit_number(dstr,opword,5,16);
}

/********************************************************************/
static void
func43 (unsigned int opword)
{
	append_Xbit_number(dstr,opword,5,6);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,11);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,16);
}

/********************************************************************/
static void
func44 (unsigned int opword)
{
	append_Xbit_number(dstr,opword,5,6);
	append_string(dstr,COMMA);
	append_register(dstr,opword,REG_INT,11);
	append_string(dstr,COMMA);
	append_value(dstr,opword & 0x0000FFFF,16);
}

/********************************************************************/
static void
func45 (unsigned int opword)
{
	append_register(dstr,opword,REG_INT,16);
}

/********************************************************************/
static void
func46 (unsigned int opword)
{
	/*
	 * This routine processes ADDIS, and also looks for
	 * a following ORI in order to do symbol table lookups.
	 */
	/* int reg1, reg2; */
	INSTRUCTION opword2;
	char sstr[40];

	/*reg1 =*/ append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);
	/*reg2 =*/ append_register(dstr,opword,REG_INT,11);
	append_string(dstr,COMMA);

#ifdef SYMBOL_TABLE
	opword2 = *(INSTRUCTION *)(disasm_pc + 4);
	if ((opword2 & 0xFC000000) == 0x60000000)
	{
		/*
		 * We have an ADDIS ORI pair, do symbol table lookup
		 */
		uint32 address;

		address = (opword & 0x0000FFFF) << 16;
		address |= (opword2 & 0x0000FFFF);

		if (symtab_convert_address(address,sstr))
		{
			append_string(dstr,"(");
			append_string(dstr,sstr);
			append_string(dstr,")@h");
		}
		else
		{
			append_value(dstr,opword & 0x0000FFFF,16);
		}
	}
	else
	{
		append_value(dstr,opword & 0x0000FFFF,16);
	}
#else
	append_value(dstr,opword & 0x0000FFFF,16);
#endif
}

/********************************************************************/
static void
func47 (unsigned int opword)
{
	/*
	 * This routine processes ORI, and also looks for
	 * a preceding ADDIS in order to do symbol table lookups.
	 */
	/*int reg1, reg2;*/
	INSTRUCTION opword2;
	char sstr[40];

	/*reg1 =*/ append_register(dstr,opword,REG_INT,11);
	append_string(dstr,COMMA);
	/*reg2 =*/ append_register(dstr,opword,REG_INT,6);
	append_string(dstr,COMMA);

#ifdef SYMBOL_TABLE
	opword2 = *(INSTRUCTION *)(disasm_pc - 4);
	if ((opword2 & 0xFC000000) == 0x3C000000)
	{
		/*
		 * We have an ADDIS ORI pair, do symbol table lookup
		 */
		uint32 address;

		address = (opword2 & 0x0000FFFF) << 16;
		address |= (opword & 0x0000FFFF);

		if (symtab_convert_address(address,sstr))
		{
			append_string(dstr,"(");
			append_string(dstr,sstr);
			append_string(dstr,")@l");
		}
		else
		{
			append_value(dstr,opword & 0x0000FFFF,16);
		}
	}
	else
	{
		append_value(dstr,opword & 0x0000FFFF,16);
	}
#else
	append_value(dstr,opword & 0x0000FFFF,16);
#endif
}

/********************************************************************/
/********************************************************************/
/********************************************************************/
/********************************************************************/

#define rDshift 21
#define rAshift 16
#define rBshift 11
#define rSshift 21
#define BOshift 21
#define BIshift 16
#define Lshift  21
#define crfDshift  23
#define crfSshift  18
#define crbDshift 21
#define crbAshift 16
#define crbBshift 11
#define frDshift 21
#define frAshift 16
#define frBshift 11
#define frCshift 6
#define SRshift 16
#define SHshift 11
#define MBshift 6
#define MEshift 1
#define TOshift 21

/********************************************************************/

static int
parse_args (
	char **tok1, char **tok2, char **tok3, char **tok4, char **tok5)
{
	/*
	 * This routine examines 'dstr' for upto 5 comma separated tokens.
	 * Examples:
	 *
	 * arg1,arg2
	 * arg1,arg2,arg3
	 * arg1,arg2,arg3,arg4
	 * arg1,arg2,arg3,arg4,arg5
	 *
	 * The number of args found is returned.
	 */
	int arg = 0;
	char *p = dstr;
	char **tokens[5];

	tokens[0] = tok1;
	tokens[1] = tok2;
	tokens[2] = tok3;
	tokens[3] = tok4;
	tokens[4] = tok5;

	*tok1 = dstr;
	if (tok2 != NULL) *tok2 = NULL;
	if (tok3 != NULL) *tok3 = NULL;
	if (tok4 != NULL) *tok4 = NULL;
	if (tok5 != NULL) *tok5 = NULL;

	while (*p != '\0')
	{
		if (*p == ',')
		{
			*p = '\0';
			if (++arg < 5)
			{
				if (tokens[arg] != NULL)
					*tokens[arg] = (p + 1);
			}
			else
				return -1;
		}
		++p;
	}
	return arg+1;
}

/********************************************************************/
static int
parse_offset (char *drA, char **d, char **rA)
{
	/*
	 * This routine breaks 'drA' into 'd' and 'rA', with 'drA'
	 * expecting format d(rA).
	 */
	int retval = -1;
	char *p = drA;

	*d  = drA;
	*rA = NULL;

	while (*p != '\0')
	{
		if ((*p == '(') || (*p == ')'))
		{
			if (*p == '(')
			{
				*rA = (p + 1);
			}
			else
			{
				if (*(p + 1) == '\0')	/* no trailing garbage */
					retval = 0;
			}
			*p = '\0';
		}
		++p;
	}
	return retval;
}

/********************************************************************/
static int
gpr_value (char *regstr)
{
	int reg;
	char *p;

	reg = strtoul(regstr, &p, 10);
	if ((reg == 0) && (p == regstr))
	{
		/* invalid numeric value, check for 'r' */
		if ((*regstr == 'r') || (*regstr == 'R'))
		{
			reg = strtoul(&regstr[1], &p, 10);
			if ((reg == 0) && (p == &regstr[1]))
				return -1;
		}
		else
			return -1;
	}
	if ((reg < 0) || (reg > 31))
		return -1;

	return reg;
}

/********************************************************************/
static int
fpr_value (char *regstr)
{
	int reg; char *p;

	reg = strtoul(regstr, &p, 10);
	if ((reg == 0) && (p == regstr))
	{
		/* invalid numeric value, check for 'f' */
		if ((*regstr == 'f') || (*regstr == 'F'))
		{
			reg = strtoul(&regstr[1], &p, 10);
			if ((reg == 0) && (p == &regstr[1]))
				return -1;
		}
		else
			return -1;
	}
	if ((reg < 0) || (reg > 31))
		return -1;

	return reg;
}