dis_cf.c

umon bootloader source code, support mips cpu.

	}
}

static int
append_ea (char *buf, int opword, int offset, int ea_mask)
{
	/*
	 * This routine creates the addressing mode.  The
	 * extensions for the addressing mode, if necessary,
	 * start at disasm_pc
	 */
	int i, mask, mode, reg, ea;
	char buffer[9];
#ifdef SYMBOL_TABLE
	char tstr[100];
#endif

	ea = EA_NONE;

	/* get addressing mode */
	mask = 0x7;	/* 3 bits */
	for (i = 2; i < offset; i++)
		mask = mask << 1;
	mode = (opword & mask) >> (offset - 2);

	/* get register */
	mask = 0x7;	/* 3 bits */
	for (i = 2; i < (offset - 3); i++)
		mask = mask << 1;
	reg = (opword & mask) >> (offset -3 - 2);

	switch (mode)
	{
		case 0:	/* data register direct mode */
			append_register(buf,reg,DATA_REGISTER,2);
			ea = DRD;
			break;
		case 1:	/* address register direct mode */
			append_register(buf,reg,ADDRESS_REGISTER,2);
			ea = ARD;
			break;
		case 2:	/* address register indirect mode (ARI) */
			append_string(buf,"(");
			append_register(buf,reg,ADDRESS_REGISTER,2);
			append_string(buf,")");
			ea = ARI;
			break;
		case 3:	/* ARI with postincrement mode */
			append_string(buf,"(");
			append_register(buf,reg,ADDRESS_REGISTER,2);
			append_string(buf,")+");
			ea = ARIPO;
			break;
		case 4:	/* ARI with predecrement mode */
			append_string(buf,"-(");
			append_register(buf,reg,ADDRESS_REGISTER,2);
			append_string(buf,")");
			ea = ARIPR;
			break;
		case 5:	/* ARI with displacement mode */
			{
				int disp;
				disp = (int)((SWORD)cpu_read_data((ADDRESS)disasm_pc,16));
				inc_disasm_pc(2);
				sprintf(buffer,"%d",disp);
				append_string(buf,buffer);
				append_string(buf,"(");
				append_register(buf,reg,ADDRESS_REGISTER,2);
				append_string(buf,")");
				ea = ARID;
			}
			break;
		case 6:
			{
				/* this mode is overloaded.  the encoding in the */
				/* extension byte indicate which of the 4 modes  */
				/*                                               */
				/* [xxxxxxx0xxxx0000] ARI 8bit displacement      */
				/* [xxxxxxx1xxxx0000] ARI base displacement      */
				/* [xxxxxxx1xxxx00xx] memory indirect pre index  */
				/* [xxxxxxx1xxxx01xx] memory indirect post index */
				/*                                               */

				int extension;

				extension = (int)*(WORD *)disasm_pc;
				inc_disasm_pc(2);

				if (extension & 0x0100)
				{
					/* ARI base or memory indirects */
					if (extension & 0x0007)
					{
						/* memory indirects */
						if (extension & 0x0004)
						{
							/* memory indirect post index */
							append_string(buf,"(");
							append_string(buf,"[");
							append_displacement(buf,extension,5);
							append_string(buf,",");
							append_register(buf,reg,ADDRESS_REGISTER,2);
							append_string(buf,"]");
							append_string(buf,",");
							append_register(buf,extension,15,14);
							append_size_scale(buf,extension,11,10);
							append_string(buf,",");
							append_displacement(buf,extension,1);
							ea = MIPO;
						}
						else
						{
							/* memory indirect pre index */
							append_string(buf,"(");
							append_string(buf,"[");
							append_displacement(buf,extension,5);
							append_string(buf,",");
							append_register(buf,reg,ADDRESS_REGISTER,2);
							append_string(buf,",");
							append_register(buf,extension,15,14);
							append_size_scale(buf,extension,11,10);
							append_string(buf,"]");
							append_string(buf,",");
							append_displacement(buf,extension,1);
							ea = MIPR;
						}
					}
					else
					{
						/* ARI with BASE displacement */
						append_string(buf,"(");
						append_displacement(buf,extension,5);
						append_string(buf,",");
						append_register(buf,reg,ADDRESS_REGISTER,2);
						append_string(buf,",");
						append_register(buf,extension,15,14);
						append_size_scale(buf,extension,11,10);
						ea = ARIIB;
					}
				}
				else
				{
					SBYTE disp8;

					disp8 = (SBYTE)(extension & 0x00FF);
					sprintf(buffer,"%d",disp8);
					append_string(buf,buffer);
					append_string(buf,"(");
					append_register(buf,reg,ADDRESS_REGISTER,2);
					append_string(buf,",");
					append_register(buf,extension,15,14);
					append_size_scale(buf,extension,11,10);
					ea = ARII8;
				}
			append_string(buf,")");
			}
			break;
		case 7:
			switch (reg)
			{
				case 0x0:
					{
						int data;
						data = (int)((SWORD)cpu_read_data((ADDRESS)disasm_pc,16));
						inc_disasm_pc(2);
						append_string(buf,"(");
						append_value(buf,data,16);
						append_string(buf,".W");
						append_string(buf,")");
					}
					ea = AS;
					break;
				case 0x1:
					{
						int data;
						data = (int)((SLONG)cpu_read_data((ADDRESS)disasm_pc,32));
						inc_disasm_pc(4);

#ifdef SYMBOL_TABLE
						if (symtab_convert_address((ADDRESS)data,tstr))
						{
							append_string(buf,tstr);
						}
						else
						{
							append_string(buf,"(");
							append_value(buf,data,32);
							append_string(buf,".L");
							append_string(buf,")");
						}
#else
						append_string(buf,"(");
						append_value(buf,data,32);
						append_string(buf,".L");
						append_string(buf,")");
#endif
					}
					ea = AL;
					break;
				case 0x2:
					{
						int disp;
						disp = (int)((SWORD)cpu_read_data((ADDRESS)disasm_pc,16));
						inc_disasm_pc(2);
						sprintf(buffer,"%d",disp);
						append_string(buf,buffer);
						append_string(buf,"(PC)");
					}
					ea = PCID;
					break;
				case 0x3:
					{
						int extension, disp;

						extension = (int)*(WORD *)disasm_pc;
						inc_disasm_pc(2);

						/* this mode is overloaded.  the encoding in the */
						/* extension byte indicate which of the 4 modes  */
						/*                                               */
						/* [xxxxxxx0xxxx0000] PC  8bit displacement      */
						/* [xxxxxxx1xxxx0000] PC  base displacement      */
						/* [xxxxxxx1xxxx00xx] PC mem indirect pre index  */
						/* [xxxxxxx1xxxx01xx] PC mem indirect post index */
						/*                                               */

						if (extension & 0x0100)
						{
							/* PC base or PC memory indirects */
							if (extension & 0x0007)
							{
								/* PC memory indirects */
								if (extension & 0x0004)
								{
									/* memory indirect post index */
									append_string(buf,"(");
									append_string(buf,"[");
									append_displacement(buf,extension,5);
									append_string(buf,",PC],");
									append_register(buf,extension,15,14);
									append_size_scale(buf,extension,11,10);
									append_string(buf,",");
									append_displacement(buf,extension,1);
									ea = PCMIPO;
								}
								else
								{
									/* memory indirect pre index */
									append_string(buf,"(");
									append_string(buf,"[");
									append_displacement(buf,extension,5);
									append_string(buf,",PC,");
									append_register(buf,extension,15,14);
									append_size_scale(buf,extension,11,10);
									append_string(buf,"]");
									append_string(buf,",");
									append_displacement(buf,extension,1);
									ea = PCMIPR;
								}
							}
							else
							{
								/* base disp */
								append_string(buf,"(");
								append_displacement(buf,extension,5);
								append_string(buf,",PC,");
								append_register(buf,extension,15,14);
								append_size_scale(buf,extension,11,10);
								ea = PCIIB;
							}
						}
						else
						{
							disp = (int)((SBYTE)(extension & 0x00FF));
							sprintf(buffer,"%d",disp);
							append_string(buf,buffer);
							append_string(buf,"(PC,");
							append_register(buf,extension,15,14);
							append_size_scale(buf,extension,11,10);
							append_string(buf,")");
							ea = PCII8;
						}
					}
					break;
				case 0x4:
					{
						int data;
						switch (disasm_op_size)
						{
							case SIZE_BYTE:
								data = (int)((WORD)cpu_read_data((ADDRESS)disasm_pc,16));
								inc_disasm_pc(2);
								data = (int)(data & 0x00FF);
								append_string(buf,"#");
								append_value(buf,data,8);
								break;
							case SIZE_WORD:
								data = (int)((WORD)cpu_read_data((ADDRESS)disasm_pc,16));
								inc_disasm_pc(2);
								append_string(buf,"#");
								append_value(buf,data,16);
								break;
							case SIZE_LONG:
								data = (int)((LONG)cpu_read_data((ADDRESS)disasm_pc,32));
								inc_disasm_pc(4);
								append_string(buf,"#");
#ifdef SYMBOL_TABLE
								if (symtab_convert_address((ADDRESS)data,tstr))
								{
									append_string(buf,tstr);
								}
								else
									append_value(buf,data,32);
#else
								append_value(buf,data,32);
#endif
								break;
							default:
								break;
						}
					}
					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, WORD opword)
{
	sprintf(dstr,"%s -- ??????",isa[index].instruction);
}
#endif

static void
func1 (int index, WORD opword)
{
	/* BTST, BCLR, BCHG, BSET statics */
	int data;
	data = (int)((WORD)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 MCF5200
static void
func2 (int index, WORD opword)
{
	/* ORI ANDI EORI to CCR */
	int data;

	(void)index;
	(void)opword;

	data = (int)((LONG)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, WORD opword)
{
	/* ORI ANDI EORI to SR */
	int data;

	(void)index;
	(void)opword;

	data = (int)((LONG)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, WORD opword)
{
	/* RTM */

	(void)index;
	(void)opword;

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

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

	data = (int)((LONG)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 /* MCF5200 */

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

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

	switch (disasm_op_size)
	{
		case SIZE_BYTE:
			data = (int)((LONG)cpu_read_data((ADDRESS)disasm_pc,16));
			inc_disasm_pc(2);
			append_value(dstr,data,8);
			break;
		case SIZE_WORD:
			data = (int)((LONG)cpu_read_data((ADDRESS)disasm_pc,16));
			inc_disasm_pc(2);
			append_value(dstr,data,16);
			break;
		case SIZE_LONG:
			data = (int)((LONG)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, WORD 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, WORD opword)
{
	/* MOVE .b,.w,.l */
	int opw1, opw2;
#ifdef MCF5200
	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 = opword | opw2;			/* swapped mode */
	opw2 = (opw1 & 0x0E00) >> 3;	/* reg */
	opword = opword | opw2;			/* swapped reg */

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

#ifdef MCF5200
	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:
			append_ea(dstr,opword,11,
				(DRD | ARD | ARI | ARIPO | ARIPR | ARID));
			break;
		case ARII8:
		case PCII8:
		case AS:
		case AL:
		case IM:
			append_ea(dstr,opword,11,
				(DRD | ARD | ARI | ARIPO | ARIPR));
			break;
		default:
			valid_instruction = FALSE;
			break;
	}
#endif

}

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

static void
func10 (int index, WORD 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, WORD opword)
{
	/* MOVE from CCR */
	append_string(dstr,"CCR,");
	append_ea(dstr,opword,5,isa[index].ea_mask);
}

static void
func12 (int index, WORD 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, WORD opword)