simulator.cpp

一个用C++实现的C的Compiler。 代码风格良好。 原作者自己写了这个编译器

		break;
	case 1: //BTNEZ
		if ((offset & 0x80) != 0)
			offset |= 0xFF00;
		printf("BTNEZ");
		break;
	case 2: //SW-RA-SP
		printf("SW-RS");
		break;
	case 3: // ADDIU_SP
		if ((offset & 0x80) != 0)
			offset |= 0xFF00;
		printf("ADDSP");
		break;
	case 7: //MOVE
		index2 = (offset & 0x7);
		offset >>= 3;
		if ((offset & 0x3) != 0)
		{
			unknown_printf();
			return ;
		}
		offset >>= 2;
		index1 = (offset & 0x7);
		printf("MOVE R%x R%x",index1,index2);
		return ;
	default:
		unknown_printf();
		return ;
	}
	printf(" %04x",offset);
}

//LI
void decode_13(word code)
{
	offset = (code & 0xFF);
	code >>= 8;
	index1 = (code & 0x7);
	printf("LI    R%x %04x",index1,offset);
}

//CMPI
void decode_14(word code)
{
	offset = (code & 0xFF);
	code >>= 8;
	index1 = (code & 0x7);
	printf("CMPI  R%x %04x",index1,offset);
}

//LW-SP
void decode_18(word code)
{
	offset = (code & 0xFF);
	code >>= 8;
	index1 = (code & 0x7);
	printf("LW-SP R%x %04x",index1,offset);
}

//LW
void decode_19(word code)
{
	offset = (code & 0x1F);
	code >>= 5;
	index2 = (code & 0x7);
	code >>= 3;
	index1 = (code & 0x7);
	printf("LW    R%x R%x %04x",index1,index2,offset);
}

//SW-SP
void decode_26(word code)
{
	offset = (code & 0xFF);
	code >>= 8;
	index1 = (code & 0x7);
	printf("SW-SP R%x %04x",index1,offset);
}

//SW
void decode_27(word code)
{
	offset = (code & 0x1F);
	code >>= 5;
	index2 = (code & 0x7);
	code >>= 3;
	index1 = (code & 0x7);
	printf("SW    R%x R%x %04x",index1,index2,offset);
}

//ADDU SUBU
void decode_28(word code)
{
	offset = (code & 0x3);
	code >>= 2;
	index3 = (code & 0x7);
	code >>= 3;
	index2 = (code & 0x7);
	code >>= 3;
	index1 = code & 0x7;
	switch (offset)
	{
	case 1: //ADDU
		printf("ADDU  R%x R%x R%x",index1,index2,index3);
		break;
	case 3: //SUBU
		printf("SUBU  R%x R%x R%x",index1,index2,index3);
		break;
	default: unknown_printf();
	}
}

//JR(ra) JR MFHI MFLO JALR SLT SLTU SLLV SRLV SRAV CMP NEG AND OR XOR NOT MULT MULTU DIV DIVU
void decode_29(word code)
{
	index3 = (code & 0x1F);
	code >>= 5;
	index2 = (code & 0x7);
	code >>= 3;
	index1 = (code & 0x7);
	if (index3 == 0)
	{
		switch (index2)
		{
		case 0: //JR
			printf("JR    R%x",index1);
			return ;
		case 2: //MFPC
			printf("MFPC  R%x",index1);
			return ;
		case 1: //JR (ra)
			if (index1 != 0)
				unknown_printf();
			else printf("JR(RA)");
			return ;
		case 6: //JALR
			printf("JALR  R%x",index1);
			return ;
		default: 
			unknown_printf();
			return ;
		}
	}
	switch (index3)
	{
	case 2: //SLT
		printf("SLT  ");
		break;
	case 3: //SLTU
		printf("SLTU ");
		break;
	case 4: //SLLV
		printf("SLLV ");
		break;
	case 6: //SRLV
		printf("SRLV ");
		break;
	case 7: //SRAV
		printf("SRAV ");
		break;
	case 10: //CMP
		printf("CMP  ");
		break;
	case 11: //NEG
		printf("NEG  ");
		break;
	case 12: //AND
		printf("AND  ");
		break;
	case 13: //OR
		printf("OR   ");
		break;
	case 14: //XOR
		printf("XOR  ");
		break;
	case 15: //NOT
		printf("NOT  ");
		break;
	case 16: //MFHI
		printf("MFHI ");
		printf(" R%x",index1);
		return ;
	case 18: //MFLO
		printf("MFLO ");
		printf(" R%x",index1);
		return ;
	case 24: //MULT
		printf("MULT ");
		break;
	case 25: //MULTU
		printf("MULTU");
		break;
	case 26: //DIV
		printf("DIV  ");
		break;
	case 27: //DIVU
		printf("DIVU ");
		break;
	default:
		unknown_printf();
		return ;
	}
	printf(" R%x R%x",index1,index2);
}

//*****************************************************************************
//模拟
func asm_set[32];
decode code_set[32];
void init()
{
	memset(asm_set,0,sizeof(func)*32);
	for (int i=0;i<32;i++)
		code_set[i] = unknown_decode;
	asm_set[0] = asm_00;
//	asm_set[1] = asm_01;
	asm_set[2] = asm_02;
//	asm_set[3] = asm_03;
	asm_set[4] = asm_04;
	asm_set[5] = asm_05;
	asm_set[6] = asm_06;
//	asm_set[7] = asm_07;
	asm_set[8] = asm_08;
	asm_set[9] = asm_09;
	asm_set[10] = asm_10;
	asm_set[11] = asm_11;
	asm_set[12] = asm_12;
	asm_set[13] = asm_13;
	asm_set[14] = asm_14;
//	asm_set[15] = asm_15;
//	asm_set[16] = asm_16;
//	asm_set[17] = asm_17;
	asm_set[18] = asm_18;
	asm_set[19] = asm_19;
//	asm_set[20] = asm_20;
//	asm_set[21] = asm_21;
//	asm_set[22] = asm_22;
//	asm_set[23] = asm_23;
//	asm_set[24] = asm_24;
//	asm_set[25] = asm_25;
	asm_set[26] = asm_26;
	asm_set[27] = asm_27;
	asm_set[28] = asm_28;
	asm_set[29] = asm_29;
//	asm_set[30] = asm_30;
//	asm_set[31] = asm_31;

	code_set[0] = decode_00;
//	code_set[1] = decode_01;
	code_set[2] = decode_02;
//	code_set[3] = decode_03;
	code_set[4] = decode_04;
	code_set[5] = decode_05;
	code_set[6] = decode_06;
//	code_set[7] = decode_07;
	code_set[8] = decode_08;
	code_set[9] = decode_09;
	code_set[10] = decode_10;
	code_set[11] = decode_11;
	code_set[12] = decode_12;
	code_set[13] = decode_13;
	code_set[14] = decode_14;
//	code_set[15] = decode_15;
//	code_set[16] = decode_16;
//	code_set[17] = decode_17;
	code_set[18] = decode_18;
	code_set[19] = decode_19;
//	code_set[20] = decode_20;
//	code_set[21] = decode_21;
//	code_set[22] = decode_22;
//	code_set[23] = decode_23;
//	code_set[24] = decode_24;
//	code_set[25] = decode_25;
	code_set[26] = decode_26;
	code_set[27] = decode_27;
	code_set[28] = decode_28;
	code_set[29] = decode_29;
//	code_set[30] = decode_30;
//	code_set[31] = decode_31;
}

struct BreakStack
{
	int btotal;
	int bsize;
	word *list;
	BreakStack()
	{
		btotal = 0;
		bsize = 4;
		list = (word *)malloc(sizeof(word)*bsize);
	}
	word binsert(word addr)
	{
		word tmp;
		if ((tmp = mem.can_vst(addr)) != 0) return tmp;
		for (int i=0;i<btotal;i++)
		{
			if (list[i] == addr)
				return 0;
		}
		list[btotal++] = addr;
		if (btotal == bsize)
		{
			bsize <<= 1;
			word *temp = (word *)malloc(sizeof(word)*bsize);
			for (int i=0;i<btotal;i++)
				temp[i] = list[i];
			free(list);
			list = temp;
		}
		for (int i=0;i<btotal-1;i++)
		{
			int min = i;
			for (int j=i+1;j<btotal;j++)
			{
				if (list[j] < list[min])
					min = j;
			}
			if (min == i)
				continue;
			word tmp = list[i];
			list[i] = list[min];
			list[min] = tmp;
		}
		return 0;
	}
	void delbp(int index)
	{
		if (index >= 0 && index < btotal)
		{
			for (int i=index+1;i<btotal;i++)
				list[i-1] = list[i];
			btotal --;
		}
	}
	int is_break(word addr)
	{
		for (int i=0;i<btotal;i++)
		{
			if (list[i] < addr)
				continue;
			if (list[i] == addr)
				return 1;
			if (list[i] > addr)
				return 0;
		}
		return 0;
	}
	void list_break()
	{
		printf("\n   > BreakPoints: total = %d\n",btotal);
		for (int i=0;i<btotal;i++)
			printf("      %d\t%04x\n",i,list[i]);
	}
};


struct BreakStack breakstack;

struct AsmID
{
	char *name;
	int id;
};

struct AsmID IDList[] = {
//	{"ADDSP",0},
	{"B",1},
	{"BEQZ",4},
	{"BNEZ",5},
	{"SLL",6},
	{"SRL",6},
	{"SRA",6},
//	{"ADDIU",8,9},
	{"SLTI",10},
	{"SLTUI",11},
	{"BTEQZ",12},
	{"BTNEZ",12},
	{"SW-RS",12},
//	{"ADDSP",12},
	{"MOVE",12},
	{"LI",13},
	{"CMPI",14},
	{"LW-SP",18},
	{"LW",19},
	{"SW-SP",26},
	{"SW",27},
	{"ADDU",28},
	{"SUBU",28},
	{"JR",29},
	{"MFHI",29},
	{"MFLO",29},
	{"JALR",29},
	{"SLT",29},
	{"SLTU",29},
	{"SLLV",29},
	{"SRLV",29},
	{"SRAV",29},
	{"CMP",29},
	{"NEG",29},
	{"AND",29},
	{"OR",29},
	{"XOR",29},
	{"NOT",29},
	{"MULT",29},
	{"MULTU",29},
	{"DIV",29},
	{"DIVU",29},
	{"MFPC",29}
};

AsmID RegsList[] = {
	{"R0",0},
	{"R1",1},
	{"R2",2},
	{"R3",3},
	{"R4",4},
	{"R5",5},
	{"R6",6},
	{"R7",7}
};

word IR = 0;
word PC = reg.PC;
//执行一条指令
word pc_step(int next = 0)
{
	PC = reg.PC;
	if ((t = mem.can_vst(PC)) != 0) return t;
	IR = mem.read_mem(PC);
	if (next == 0 && breakstack.is_break(PC) != 0)
		return C_SBREAK;
	index1 = ((IR >> 11)& 0x001F);
	if (asm_set[index1] == NULL)
		return E_NOFUNC;
	else 
	{
		reg.PC++;
		return asm_set[index1](IR);
	}
}
int get_regs_id(char argv[])
{
	if (strlen(argv) != 2)
		return -1;
	for (int i=0;i<8;i++)
	{
		if (strcmp(argv,RegsList[i].name) == 0)
			return RegsList[i].id;
	}
	return -1;
}

int get_number_10(char argv[],int lenlimit)
{
	int value = 0, len = strlen(argv);
	char ch;
	for (int i=0;i<len;i++)
	{
		ch = argv[i];
		value *= 10;
		if (ch >= '0' && ch <= '9')
			value |= (ch-'0') & 0xF;
		else return -1;
	}
	if (value >> lenlimit != 0)
		return -1;
	return value;
}

int get_number(char argv[],int lenlimit)
{
	int value = 0, len = strlen(argv);
	char ch;
	for (int i=0;i<len;i++)
	{
		ch = argv[i];
		value <<= 4;
		if (ch >= '0' && ch <= '9')
			value |= (ch-'0') & 0xF;
		else if (ch >= 'A' && ch <= 'F')
			value |= (ch-'A'+10) & 0xF;
		else if (ch >= 'a' && ch <= 'f')
			value |= (ch-'a'+10) & 0xF;
		else return -1;
	}
	if (value >> lenlimit != 0)
		return -1;
	return value;
}

void pc_decode(word code)
{
	index1 = ((code >> 11) & 0x1F);
	code_set[index1](code);
}

void run_regs(int ,char *[]);

void run_continue(int argc,char *argv[])
{
	if (argc == 2 && strcmp(argv[1],"--help") == 0)
	{
		printf("\n usage:\n");
		printf("  help\n");
		return ;
	}
	if (argc != 1)
	{
		printf ("\n Unknown control identifier `%s'.\n", argv [1]);
		return ;
	}
	printf("\n");
	word err;
	char ch;
	int step = 0;
	while ((err = pc_step()) == 0)
	{
		if (step == 0x100)
		{
			if (kbhit())
			{
				while (kbhit())
				{
					ch = getch();
					if (ch == 7)
					{
						run_regs(1,argv);
						return ;
					}
				}
			}
			step = 0;
		}
		step ++;
	}
	switch (err)
	{
	case C_SBREAK:
		printf("\n    [%04x] %04x   ",PC,IR);
		pc_decode(IR);
		break;
	case E_NOFUNC:
		printf("\n    no such function\n");
		break ;
	case E_MMNVST:
		printf("\n    Can not read memory :  [%04x]  ",PC);
		pc_decode(IR);
		break ;
	default: printf("\n    error %d\n",err);
		break;
	}
}

void run_step(int argc,char *argv[])
{
	if (argc == 2 && strcmp(argv[1],"--help") == 0)
	{
		printf("\n usage:\n");
		printf("  help\n");
		return ;
	}
	word err;
	if (argc == 1)
	{
		err = pc_step(1);
		PC = reg.PC;
		if (mem.can_vst(PC) != 0)
			printf("mem cannot read\n");
		else
		{
			IR = mem.read_mem(PC);
			printf("\n   [%04x]  %04x  ",PC,IR);
			pc_decode(IR);
		}
	}
	else
	{
		int value = get_number(argv[1],16);
		if (value == -1)
		{
			printf ("\n Unknown control identifier `%s'.\n", argv [1]);
			return ;
		}
		for (int i=0;i<value;i++)
		{
			err = pc_step(1);
			if (err != 0)
			{
				PC = reg.PC;
				if (mem.can_vst(PC) != 0)
				printf("\n    mem cannot read\n");
				else
				{
					IR = mem.read_mem(PC);
					printf("\n   [%04x]  %04x  ",PC,IR);
					pc_decode(IR);
				}
				break;
			}
		}
		run_regs(1,argv);
	}
}

void run_quit(int argc,char *argv[])
{
	if (argc == 2 && strcmp(argv[1],"--help") == 0)
	{
		printf("\n usage:\n");
		printf("  help\n");
		return ;
	}
	if (argc != 1)
	{
		printf ("\n Unknown control identifier `%s'.\n", argv [1]);
		return ;
	}
	else
	{
		printf("\n\n");
		exit(0);
	}
}

void run_setbreak(int argc,char *argv[])
{
	if (argc == 2 && strcmp(argv[1],"--help") == 0)
	{
		printf("\n usage:\n");
		printf("  help\n");
		return ;