⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 dis_cf.c

📁 umon bootloader source code, support mips cpu.
💻 C
📖 第 1 页 / 共 5 页
字号:
🔍
12345 
{
	/* SWAP EXT EXTB */
	(void)index;
	append_register(dstr,opword,DATA_REGISTER,2);
}

static void
func14 (int index, WORD 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, WORD 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, WORD opword)
{
	/* LINK word */
	int disp;
	char buffer[20];

	(void)index;
	disp = (int)((SWORD)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, WORD opword)
{
	/* RTE HALT RTS NOP */
	/* instruction printed by calling routine */
	(void)index;
	(void)opword;
}

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

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

	opword2 = (int)((WORD)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, WORD opword)
{
	int data;

	(void)index;

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

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

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

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

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

static void
func24 (int index, WORD 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, WORD opword)
{
	/* Bcc */
	int disp, target;
#ifdef SYMBOL_TABLE
	char tstr[100];
#endif

	(void)index;
	disp = opword & 0x00FF;
	if (disp == 0)
	{
		/* 16 bit disp */
		disp = (int)((SWORD)cpu_read_data((ADDRESS)disasm_pc,16));
		target = (int)disasm_pc + disp;
		inc_disasm_pc(2);
	}
	else
	{
		if (disp == 0x00FF)
		{
			/* 32 bit disp */
			valid_instruction = FALSE;
			return;
		}
		else
		{
			/* 8 bit disp */
			disp = (int)((SBYTE)disp);
			target = (int)disasm_pc + disp;
		}
	}
#ifdef 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, WORD 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);
}

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";

	next_set = mask = 0;

	/* 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:
					mask = 0x8000;
					break;
			}
			reg = regD;
		}
		else
		{
			switch (dir)
			{
				case 1:
					mask = 0x0100;
					break;
				case -1:
					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;
						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, WORD opword)
{
	/* MOVEM */
	int mask;

	mask = (int)((WORD)cpu_read_data((ADDRESS)disasm_pc,16));
	inc_disasm_pc(2);

	if (opword & 0x0040)
	{
		/* long */
		append_size(dstr,0x0002,1,TRUE);
	}
	else
	{
		/* word */
		append_size(dstr,0x0002,2,TRUE);
	}

	if (opword & 0x0400)
	{
		/* memory to register */
		append_ea(dstr,opword,5,isa[index].ea_mask);
		append_string(dstr,",");
		append_reg_list(mask,opword);
	}
	else
	{
		/* register to memory */
		append_reg_list(mask,opword);
		append_string(dstr,",");
		append_ea(dstr,opword,5,isa[index].ea_mask);
	}
}

static void
func28 (int index, WORD opword)
{
	/* CMPA ADDA SUBA */

	if (opword & 0x0100)
	{
		/* long */
		append_size(dstr,0x0002,1,TRUE);
	}
	else
	{
		/* word */
		append_size(dstr,0x0002,2,TRUE);
	}
	append_ea(dstr,opword,5,isa[index].ea_mask);
	append_string(dstr,",");
	append_register(dstr,opword,ADDRESS_REGISTER,11);
}


static void
func29 (int index, WORD opword)
{
	/* SUBQ ADDQ */
	int data;

	data = ((opword & 0x0E00) >> 9);
	if (data == 0)
		data = 8;

	append_size(dstr,opword,7,TRUE);
	append_string(dstr,"#");
	append_value(dstr,data,8);
	append_string(dstr,",");
	append_ea(dstr,opword,5,isa[index].ea_mask);
}

#ifndef MCF5200
static void
func30 (int index, WORD opword)
{
	/* MOVES */
	int opword2;

	append_size(dstr,opword,7,TRUE);
	opword2 = (int)((WORD)cpu_read_data((ADDRESS)disasm_pc,16));
	inc_disasm_pc(2);

	if (opword2 & 0x000800)
	{
		/* MOVES Rn,<ea> */
		append_register(dstr,opword2,15,14);
		append_string(dstr,",");
		append_ea(dstr,opword,5,isa[index].ea_mask);
	}
	else
	{
		/* MOVES <ea>,Rn */
		append_ea(dstr,opword,5,isa[index].ea_mask);
		append_string(dstr,",");
		append_register(dstr,opword2,15,14);
	}
}
#endif /* MCF5200 */


static void
func31 (int index, WORD opword)
{
	/* AND OR EOR */
	append_size(dstr,opword,7,TRUE);
	append_register(dstr,opword,DATA_REGISTER,11);
	append_string(dstr,",");
	append_ea(dstr,opword,5,isa[index].ea_mask);
}


static void
func32 (int index, WORD opword)
{
	/* LEA */
	append_ea(dstr,opword,5,isa[index].ea_mask);
	append_string(dstr,",");
	append_register(dstr,opword,ADDRESS_REGISTER,11);
}


static void
func33 (int index, WORD opword)
{
	/* SUB AND ADD OR CMP */
	append_size(dstr,opword,7,TRUE);
	append_ea(dstr,opword,5,isa[index].ea_mask);
	append_string(dstr,",");
	append_register(dstr,opword,DATA_REGISTER,11);
}

static void
func34 (int index, WORD opword)
{
	/* LSL,LSR,ROL,ROR,ROXL,ROXR,ASL,ASR #<data> */
	int data;

	(void)index;
	data = ((opword & 0x0E00) >> 9);
	if (data == 0)
		data = 8;
	append_size(dstr,opword,7,TRUE);
	append_string(dstr,"#");
	append_value(dstr,data,8);
	append_string(dstr,",");
	append_register(dstr,opword,DATA_REGISTER,2);
}

static void
func35 (int index, WORD opword)
{
	/* LSL,LSR,ROL,ROR,ROXL,ROXR,ASL,ASR Dx */

	(void)index;
	append_size(dstr,opword,7,TRUE);
	append_register(dstr,opword,DATA_REGISTER,11);
	append_string(dstr,",");
	append_register(dstr,opword,DATA_REGISTER,2);
}

static void
func36 (int index, WORD opword)
{
	/* MOVEC */
	int opword2;
	char buffer[9];

	(void)index;
	opword2 = (int)((WORD)cpu_read_data((ADDRESS)disasm_pc,16));
	inc_disasm_pc(2);

	if (opword & 0x0001)
	{
		append_register(dstr,opword2,15,14);
		append_string(dstr,",");
	}

	switch (opword2 & 0x0FFF)
	{
#if (defined(MCF5202) || defined(MCF5204) || defined(MCF5206))
		case 0x002:
			append_string(dstr,"CACR");
12345

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -