disasm.c

Coldfire MCF5282 DBug bootloader

					}
					ea = IM;
					break;
			}
		default:
			break;
	}
	if (!(ea_mask & ea))
	{
		/* EA was not one of ones in mask */
		valid_instruction = FALSE;
	}
	return ea;	/* needed by MOVE */
}

/********************************************************************/
#if 0
static void
func (int index, uint16 opword)
{
	sprintf(dstr,"%s -- ??????",isa[index].instruction);
}
#endif

/********************************************************************/
static void
func1 (int index, uint16 opword)
{
	/* BTST, BCLR, BCHG, BSET statics */
	int data;
	data = (int)((uint16)cpu_read_data((ADDRESS)disasm_pc,16));
	inc_disasm_pc(2);

	if (0xFF00 & data)
	{
		valid_instruction = FALSE;
		return;
	}
	append_string(dstr,"#");
	append_value(dstr,data,8);
	append_string(dstr,",");
	append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
#ifndef CPU_FAM_MCF5XXX
static void
func2 (int index, uint16 opword)
{
	/* ORI ANDI EORI to CCR */
	int data;

	(void)index;
	(void)opword;

	data = (int)((uint32)cpu_read_data((ADDRESS)disasm_pc,16));
	inc_disasm_pc(2);
	append_string(dstr,"#");
	append_value(dstr,data,8);
	append_string(dstr,",CCR");
}

/********************************************************************/
static void
func3 (int index, uint16 opword)
{
	/* ORI ANDI EORI to SR */
	int data;

	(void)index;
	(void)opword;

	data = (int)((uint32)cpu_read_data((ADDRESS)disasm_pc,16));
	inc_disasm_pc(2);
	append_string(dstr,"#");
	append_value(dstr,data,16);
	append_string(dstr,",SR");
}

/********************************************************************/
static void
func4 (int index, uint16 opword)
{
	/* RTM */

	(void)index;
	(void)opword;

	append_register(dstr,opword,3,2);
}

/********************************************************************/
static void
func5 (int index, uint16 opword)
{
	/* CALLM */
	int data;

	data = (int)((uint32)cpu_read_data((ADDRESS)disasm_pc,16));
	inc_disasm_pc(2);
	append_string(dstr,"#");
	append_value(dstr,data,8);
	append_string(dstr,",");
	append_ea(dstr,opword,5,isa[index].ea_mask);
}
#endif /* CPU_FAM_MCF5XXX */

/********************************************************************/
static void
func6 (int index, uint16 opword)
{
	/* ORI EORI ANDI SUBI ADDI CMPI  */
	int data;

	append_size(dstr,opword,7,TRUE);
	append_string(dstr,"#");

	switch (disasm_op_size)
	{
		case SIZE_BYTE:
			data = (int)((uint32)cpu_read_data((ADDRESS)disasm_pc,16));
			inc_disasm_pc(2);
			append_value(dstr,data,8);
			break;
		case SIZE_WORD:
			data = (int)((uint32)cpu_read_data((ADDRESS)disasm_pc,16));
			inc_disasm_pc(2);
			append_value(dstr,data,16);
			break;
		case SIZE_LONG:
			data = (int)((uint32)cpu_read_data((ADDRESS)disasm_pc,32));
			inc_disasm_pc(4);
			append_value(dstr,data,32);
			break;
	}

	append_string(dstr,",");
	append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func7 (int index, uint16 opword)
{
	/* BTST, BCHG, BSET, BCLR reg */
	append_register(dstr,opword,DATA_REGISTER,11);
	append_string(dstr,",");
	append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func8 (int index, uint16 opword)
{
	/* MOVE .b,.w,.l */
	int opw1, opw2;
#ifdef CPU_FAM_MCF5XXX
	int sea;
#endif

	/* the destination <ea> is swapped from the form expected by */
	/* append_ea().  so make it look right */
	opw1 = opword & 0x0FC0;
	opword = opword & 0xF03F;		/* punch out dest */
	opw2 = (opw1 & 0x01C0) << 3;	/* mode */
	opword = (uint16)(opword | opw2);			/* swapped mode */
	opw2 = (opw1 & 0x0E00) >> 3;	/* reg */
	opword = (uint16)(opword | opw2);			/* swapped reg */

	append_size2(dstr,opword,13,TRUE);
#ifndef CPU_FAM_MCF5XXX
	append_ea(dstr,opword,5,EA_ALL);
	append_string(dstr,",");
	append_ea(dstr,opword,11,isa[index].ea_mask);
#endif

#ifdef CPU_FAM_MCF5XXX
	sea = append_ea(dstr,opword,5,isa[index].ea_mask);
	append_string(dstr,",");

	/* NOTE: On Coldfire, not all dest <ea> are possible! */
	/* See MCF5200 Family Programmer's Reference Manual,  */
	/* pages 4-53 thru 4-55 for further information.      */

	switch (sea)
	{
		case DRD:
		case ARD:
		case ARI:
		case ARIPO:
		case ARIPR:
			append_ea(dstr,opword,11,
				(DRD | ARD | ARI | ARIPO | ARIPR | ARID | ARII8 \
				| AS | AL));
			break;
		case ARID:
		case PCID:
		case IM:
			append_ea(dstr,opword,11,
				(DRD | ARD | ARI | ARIPO | ARIPR | ARID));
			break;
		case ARII8:
		case PCII8:
		case AS:
		case AL:
			append_ea(dstr,opword,11,
				(DRD | ARD | ARI | ARIPO | ARIPR));
			break;
		default:
			valid_instruction = FALSE;
			break;
	}
#endif

}

/********************************************************************/
static void
func9 (int index, uint16 opword)
{
	/* MOVE from SR */
	append_string(dstr,"SR,");
	append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func10 (int index, uint16 opword)
{
	/* MOVE to SR */
	disasm_op_size = SIZE_WORD;
	append_ea(dstr,opword,5,isa[index].ea_mask);
	append_string(dstr,",SR");
}

/********************************************************************/
static void
func11 (int index, uint16 opword)
{
	/* MOVE from CCR */
	append_string(dstr,"CCR,");
	append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func12 (int index, uint16 opword)
{
	/* MOVE to CCR */
	disasm_op_size = SIZE_WORD;
	append_ea(dstr,opword,5,isa[index].ea_mask);
	append_string(dstr,",CCR");
}

/********************************************************************/
static void
func13 (int index, uint16 opword)
{
	/* SWAP EXT EXTB */
	(void)index;
	append_register(dstr,opword,DATA_REGISTER,2);
}

/********************************************************************/
static void
func14 (int index, uint16 opword)
{
	/* ADDX SUBX */
	(void)index;
	append_size(dstr,opword,7,TRUE);

	if (opword & 0x0008)
	{
		/* ADDX/SUBX -(Ax),-(Ay) */
		append_string(dstr,"-(");
		append_register(dstr,opword,ADDRESS_REGISTER,2);
		append_string(dstr,"),-(");
		append_register(dstr,opword,ADDRESS_REGISTER,11);
		append_string(dstr,")");
	}
	else
	{
		/* ADDX/SUBX Dx,Dy */
		append_register(dstr,opword,DATA_REGISTER,2);
		append_string(dstr,",");
		append_register(dstr,opword,DATA_REGISTER,11);
	}
}

/********************************************************************/
static void
func15 (int index, uint16 opword)
{
	/* NEGX NEG NOT CLR WDDATA */
	append_size(dstr,opword,7,TRUE);
	append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
static void
func16 (int index, uint16 opword)
{
	/* LINK word */
	int disp;
	char buffer[20];

	(void)index;
	disp = (int)((int16)cpu_read_data((ADDRESS)disasm_pc,16));
	inc_disasm_pc(2);
	append_register(dstr,opword,ADDRESS_REGISTER,2);
	append_string(dstr,",#");
	sprintf(buffer,"%d",disp);
	append_string(dstr,buffer);
}

/********************************************************************/
static void
func17 (int index, uint16 opword)
{
	/* RTE HALT RTS NOP */
	/* instruction printed by calling routine */
	(void)index;
	(void)opword;
}

/********************************************************************/
static void
func18 (int index, uint16 opword)
{
	/* ASL ASR LSL LSR ROR ROL ROXL ROXR NBCD PEA JSR JMP TAS */
	append_ea(dstr,opword,5,isa[index].ea_mask);
}

/********************************************************************/
#ifndef CPU_FAM_MCF5XXX
static void
func19 (int index, uint16 opword)
{
	/* CMP2 and CHK2 */
	int opword2;

	opword2 = (int)((uint16)cpu_read_data((ADDRESS)disasm_pc,16));
	inc_disasm_pc(2);

	/* both instruction have same EA mask */
	if (opword2 & 0x000800)
	{
		append_instruction(dstr,"CHK2");
	}
	else
	{
		append_instruction(dstr,"CMP2");
	}
	append_size(dstr,opword,10,TRUE);
	append_ea(dstr,opword,5,isa[index].ea_mask);
	append_string(dstr,",");
	append_register(dstr,opword2,15,14);
}

/********************************************************************/
#if 0
static void
func20 (int index, uint16 opword)
{
	int data;

	(void)index;

	append_string(dstr,"#");
	data = opword & 0x0007;
	append_value(dstr,data,8);
}
#endif
#endif /* CPU_FAM_MCF5XXX */

/********************************************************************/
static void
func21 (int index, uint16 opword)
{
	(void)index;
	append_register(dstr,opword,ADDRESS_REGISTER,2);
}

/********************************************************************/
static void
func22 (int index, uint16 opword)
{
	/* TRAP */
	int data;
	(void)index;
	append_string(dstr,"#");
	data = opword & 0x000F;
	append_value(dstr,data,8);
}

/********************************************************************/
static void
func23 (int index, uint16 opword)
{
	/* STOP RTD */
	int data;

	(void)index;
	(void)opword;
	append_string(dstr,"#");
	data = (int)((uint16)cpu_read_data((ADDRESS)disasm_pc,16));
	inc_disasm_pc(2);
	append_value(dstr,data,16);
}

/********************************************************************/
static void
func24 (int index, uint16 opword)
{
	/* MOVEQ */
	int data;

	(void)index;
	append_string(dstr,"#");
	data = opword & 0x00FF;
	append_value(dstr,data,8);
	append_string(dstr,",");
	append_register(dstr,opword,DATA_REGISTER,11);
}

/********************************************************************/
static void
func25 (int index, uint16 opword)
{
	/* Bcc */
	int disp, target;
#if (defined(SYMBOL_TABLE))
	char tstr[100];
#endif

	(void)index;
	disp = opword & 0x00FF;
	if (disp == 0)
	{
		/* 16 bit disp */
		disp = (int)((int16)cpu_read_data((ADDRESS)disasm_pc,16));
		target = (int)disasm_pc + disp;
		inc_disasm_pc(2);
	}
	else if (disp == 0x00FF)
	{
		#if (defined(CPU_MCF5407))
			/* 32 bit disp */
			disp = (int)((int32)cpu_read_data((ADDRESS)disasm_pc,32));
			target = (int)disasm_pc + disp;
			inc_disasm_pc(4);
		#else
			/* 32 bit disp */ 
			valid_instruction = FALSE;
			return;
		#endif
	}
	else
	{
		/* 8 bit disp */
		disp = (int)((int8)disp);
		target = (int)disasm_pc + disp;
	}

#if (defined(SYMBOL_TABLE))
	if (symtab_convert_address((ADDRESS)target,tstr))
	{
		append_string(dstr,tstr);
	}
	else
		append_value(dstr,target,32);
#else
	append_value(dstr,target,32);
#endif
}

/********************************************************************/
static void
func26 (int index, uint16 opword)
{
	/* MOVEA */

	append_size2(dstr,opword,13,TRUE);
	append_ea(dstr,opword,5,isa[index].ea_mask);
	append_string(dstr,",");
	append_register(dstr,opword,ADDRESS_REGISTER,11);
}

/********************************************************************/
static int
more_bits_set (int cm, int cc, int dir, int reg_mask)
{
	/* cm = current mask, cc = current count */
	switch (dir)
	{
		case 1:
			cm = cm << 1;
			break;
		case -1:
			cm = cm >> 1;
			break;
	}
	++cc;
	while (cc < 8)
	{
		if (cm & reg_mask)
		{
			return TRUE;
		}
		switch (dir)
		{
			case 1:
				cm = cm << 1;
				break;
			case -1:
				cm = cm >> 1;
				break;
		}
		++cc;
	}
	return FALSE;
}

/********************************************************************/
static void
append_reg_list (int reg_mask, int opword)
{
	int mask, i, j, first, need_slash, dir, next_set, some_set;
	char buffer[9];
	char *reg;
	char regA[] = "A";
	char regD[] = "D";

	/* Check for predecrement mode */
	if ((opword & 0x0038) == 0x0020)
	{
		/* predecrement */
		dir = -1;
	}
	else
	{
		dir = 1;
	}

	need_slash = FALSE;
	for (j = 0; j < 2; j++)
	{
		if (j == 0)
		{
			switch (dir)
			{
				case 1:
					mask = 0x0001;
					break;
				case -1:
				default:
					mask = 0x8000;
					break;
			}
			reg = regD;
		}
		else
		{
			switch (dir)
			{
				case 1:
					mask = 0x0100;
					break;
				case -1:
				default:
					mask = 0x0080;
					break;
			}
			reg = regA;
			if (need_slash)
				append_string(dstr,"/");
		}

		some_set = FALSE;
		first = TRUE;
		need_slash = FALSE;

		for (i = 0; i < 8; i++)
		{
			if (reg_mask & mask)
			{
				some_set = TRUE;
				if (first)
				{
					/* first one in subrange */
					if (need_slash)
					{
						append_string(dstr,"/");
						need_slash = FALSE;
					}
					append_string(dstr,reg);
					sprintf(buffer,"%d",i);
					append_string(dstr,buffer);
					if (!more_bits_set(mask,i,dir,reg_mask))
						need_slash = TRUE;
					first = FALSE;
				}
				else
				{
					/* check to see if next set */
					switch (dir)
					{
						case 1:
							next_set = (((reg_mask & (mask << 1))) &&
								(i != 7));
							break;
						default:
						case -1:
							next_set = (((reg_mask & (mask >> 1))) &&
								(i != 7));
							break;
					}
					if (!next_set)
					{
						/* the next isn't set, so display */
						append_string(dstr,"-");
						append_string(dstr,reg);
						sprintf(buffer,"%d",i);
						append_string(dstr,buffer);
							need_slash = TRUE;
						first = TRUE;
					}
				}
			}
			else first = TRUE;
			switch (dir)
			{
				case 1:
					mask = mask << 1;
					break;
				case -1:
					mask = mask >> 1;
					break;
			}
		}
		if ((i == 8) && (j == 0) && some_set)
		{
			switch (dir)
			{
				case 1:
					need_slash = more_bits_set(0x0080,-1,dir,reg_mask);
					break;
				case -1:
					need_slash = more_bits_set(0x0100,-1,dir,reg_mask);
					break;
				default:
					break;
			}
		}
	}
}

/********************************************************************/
static void
func27 (int index, uint16 opword)
{
	/* MOVEM */