tobin.cpp

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

			}
			for (int i = 0; i < RegCount; i ++) p->work_space[i] = 0;
			for (int i = 0; i < RegCount; i ++) p->phi2[i] = p->phi1[i];
			allocate(p->phi2, p->use, p->usereg, p->live1, p->work_space);
			for (int i = 0; i < RegCount; i ++) p->phi3[i] = p->phi2[i];
			allocate(p->phi3, p->def, p->defreg, p->live2, p->work_space);

/*		printf("*************");
		p->print();
		printf("\n");
		printf("\t\tphi 1:\t");	for (int i = 0; i < RegCount; i ++) printf("%d\t", p->phi1[i]);		printf("\n");
		printf("\t\tphi 2:\t");	for (int i = 0; i < RegCount; i ++) printf("%d\t", p->phi2[i]);		printf("\n");
		printf("\t\tphi 3:\t");	for (int i = 0; i < RegCount; i ++) printf("%d\t", p->phi3[i]);		printf("\n");*/

			if (p->op == "BEGIN")
			{
				memset(p->phi3, 0xff, sizeof(p->phi3));
			}

			list <TTACEntry> :: iterator q = p;
			q ++;
			if (p->op == "JMP")
			{
				int label_name;
				sscanf(p->var1.c_str(), "L%d", &label_name);
				q = LabelEntry[label_name];
				q ++;
			}
			if (q != FuncEntry[func_name].ins.end())
			{
				changed |= improve_phi(p->phi3, q->phi1, q->phi3);
			}
		}
		for (list <TTACEntry> :: iterator p = FuncEntry[func_name].ins.begin(); p != FuncEntry[func_name].ins.end(); p ++)
		{
			if (p->op == "JE" || p->op == "JNE" || p->op == "JL" || p->op == "JLE" || p->op == "JG" || p->op == "JGE")
			{
				int label_name;
				sscanf(p->var3.c_str(), "L%d", &label_name);
				list <TTACEntry> :: iterator q = LabelEntry[label_name];
				q ++;
				if (q != FuncEntry[func_name].ins.end())
				{
					changed |= improve_phi(p->phi3, q->phi1, q->phi3);
				}
			}
		}
	}

	for (list <TTACEntry> :: iterator p = FuncEntry[func_name].ins.begin(); p != FuncEntry[func_name].ins.end(); p ++)
	{
		if (p->op == "ASM" || p->op == "RREAD" || p->op == "RWRITE")
		{
			for (int i = 0; i < RegCount; i ++) p->phi1[i] = p->phi2[i] = p->phi3[i] = -2;
			continue;
		}

		if (p->op == "RICALL")
		{
			for (int i = 0; i < RegCount; i ++) p->phi1[i] = -2;
		}
		for (int i = 0; i < RegCount; i ++) p->work_space[i] = 0;
		for (int i = 0; i < RegCount; i ++) p->phi2[i] = p->phi1[i];
		allocate(p->phi2, p->use, p->usereg, p->live1, p->work_space);
		for (int i = 0; i < RegCount; i ++) p->phi3[i] = p->phi2[i];
		allocate(p->phi3, p->def, p->defreg, p->live2, p->work_space);

/*		printf("*************");
	p->print();
	printf("\n");
	printf("\t\tphi 1:\t");	for (int i = 0; i < RegCount; i ++) printf("%d\t", p->phi1[i]);		printf("\n");
	printf("\t\tphi 2:\t");	for (int i = 0; i < RegCount; i ++) printf("%d\t", p->phi2[i]);		printf("\n");
	printf("\t\tphi 3:\t");	for (int i = 0; i < RegCount; i ++) printf("%d\t", p->phi3[i]);		printf("\n");*/

		if (p->op == "BEGIN")
		{
			memset(p->phi3, 0xff, sizeof(p->phi3));
		}
	}
/*	printf("phi : \n");
	for (list <TTACEntry> :: iterator p = FuncEntry[func_name].ins.begin(); p != FuncEntry[func_name].ins.end(); p ++)
	{
		p->print();
		printf("\n");
		printf("\t\tuse :\t"); printintlist(p->use); printf("\n");
		printf("\t\tusereg :\t"); printintlist(p->usereg); printf("\n");
		printf("\t\tdef :\t"); printintlist(p->def); printf("\n");
		printf("\t\tdefreg :\t"); printintlist(p->defreg); printf("\n");
		printf("\t\tphi 1:\t");	for (int i = 0; i < RegCount; i ++) printf("%d\t", p->phi1[i]);		printf("\n");
		printf("\t\tphi 2:\t");	for (int i = 0; i < RegCount; i ++) printf("%d\t", p->phi2[i]);		printf("\n");
		printf("\t\tphi 3:\t");	for (int i = 0; i < RegCount; i ++) printf("%d\t", p->phi3[i]);		printf("\n");
	}*/
}

void register_allocate(int func_name)
{
	calc_live(func_name);
	color_graph(func_name);
	make_phi(func_name);
}

TBinEntry create_bincode(int bincode_type, int code, int label_name = 0, int func_name = 0, int reg_name = 0, int jmpreg1 = 0, int jmpreg2 = 0, int short_num = 0)
{
	TBinEntry Bentry;
	Bentry.bincode_type = bincode_type;
	Bentry.code = code;
	Bentry.label_name = label_name;
	Bentry.func_name = func_name;
	Bentry.reg_name = reg_name;
	Bentry.jmpreg1 = jmpreg1;
	Bentry.jmpreg2 = jmpreg2;
	Bentry.short_num = short_num;
	return Bentry;
}

int __get_bincode_size(int bincode_type)
{
	if (bincode_type == bincode_type_begin || bincode_type == bincode_type_empty)
	{
		return 0;
	}
	else if (bincode_type == bincode_type_normal)
	{
		return 1;
	}
	else if (bincode_type >= bincode_type_B && bincode_type <= bincode_type_BNEZ)
	{
		return 2;
	}
	else if (bincode_type >= bincode_type_B_L && bincode_type <= bincode_type_BNEZ_L)
	{
		return 9;
	}
	else
	{
		return 3;		
	}
}

int tempvar2reg(int var_name, int phi[RegCount])
{
	for (int i = 0; i < RegCount; i ++)
	{
		if (phi[i] == VarEntry[var_name].color)
		{
			return i;
		}
	}
	printf("Temp var not found in phi.\n");
	exit(0);
}

int to_unsign_number(int number)
{
	if (number < 0) number += (maxword + 1); 
	return number;
}

unsigned short encode(char* fstr, int x = 0, int y = 0, int z = 0)
{
	int cntx = 0, cnty = 0, cntz = 0;
	unsigned short ret = 0;
	for (unsigned short i = 0; i < 16; i++)
	{
//		printf ("%c", fstr[15-i]);
		if (fstr[15 - i] == '0')
		{
		}
		else if (fstr[15 - i] == '1')
		{
			ret += ((unsigned short) 1 << i);
		}
		else if (fstr[15 - i] == 'X')
		{
			if ((1 << (cntx ++)) & x)
			{
				ret += ((unsigned short) 1 << i);
			}
		}
		else if (fstr[15 - i] == 'Y')
		{
			if ((1 << (cnty ++)) & y)
			{
				ret += ((unsigned short) 1 << i);
			}
		}
		else if (fstr[15 - i] == 'Z')
		{
			if ((1 << (cntz ++)) & z)
			{
				ret += ((unsigned short) 1 << i);
			}
		}
	}
	if (ret == 0xd701)
		printf("******%d\n", ret);
	return ret;
}

//TBinEntry create_bincode(int bincode_type, int code, int label_name = 0, int func_name = 0, int reg_name = 0, int jmpreg1 = 0, int jmpreg2 = 0, int short_num = 0)
void ASM_B_TEMP(list <TBinEntry> :: iterator bin_label, list <TBinEntry> :: iterator p)
{
	TBinEntry bin_entry;
	bin_entry.bincode_type = bincode_type_B;
	bin_entry.bin_label = bin_label;
	bincode.insert(p, bin_entry);
}

void ASM_B_TEMP(int label_name, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_B, 0, label_name));
}

void ASM_BTEQZ_TEMP(int label_name, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_BTEQZ, 0, label_name));
}

void ASM_BTNEZ_TEMP(int label_name, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_BTNEZ, 0, label_name));
}

void ASM_BEQZ_TEMP(int rx, int label_name, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_BEQZ, 0, label_name, 0, rx));
}

void ASM_BNEZ_TEMP(int rx, int label_name, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_BNEZ, 0, label_name, 0, rx));
}

void ASM_MOVE(int ry, int rz, list <TBinEntry> :: iterator p);
void ASM_B(int offset, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("00010XXXXXXXXXXX", offset & 0x7ff)));
	bincode.insert(p, create_bincode(bincode_type_normal, encode("0000100000000000")));
}

void ASM_BTEQZ(int offset, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01100000XXXXXXXX", offset & 0xff)));
	bincode.insert(p, create_bincode(bincode_type_normal, encode("0000100000000000")));
}

void ASM_BTNEZ(int offset, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01100001XXXXXXXX", offset & 0xff)));
	bincode.insert(p, create_bincode(bincode_type_normal, encode("0000100000000000")));
}

void ASM_BEQZ(int rx, int offset, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("00100XXXYYYYYYYY", rx & 0x7, offset & 0xff)));
	bincode.insert(p, create_bincode(bincode_type_normal, encode("0000100000000000")));
}

void ASM_BNEZ(int rx, int offset, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("00101XXXYYYYYYYY", rx & 0x7, offset & 0xff)));
	bincode.insert(p, create_bincode(bincode_type_normal, encode("0000100000000000")));
}

void ASM_JR(int rx, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXX00000000", rx & 0x7)));
	bincode.insert(p, create_bincode(bincode_type_normal, encode("0000100000000000")));
}

void ASM_JR_RA(list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("1110100000100000")));
	bincode.insert(p, create_bincode(bincode_type_normal, encode("0000100000000000")));
}

void ASM_SW(int rx, int ry, int offset, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11011XXXYYYZZZZZ", rx & 0x7, ry & 0x7, offset & 0x1f)));
}

void ASM_SW_SP(int rx, int offset, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11010XXXYYYYYYYY", rx & 0x7, offset & 0xff)));
}

void ASM_SW_RA_SP(int offset, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01100010XXXXXXXX", offset & 0xff)));
}

void ASM_DIV(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY11010", rx & 0x7, ry & 0x7)));
}

void ASM_DIVU(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY11011", rx & 0x7, ry & 0x7)));
}

void ASM_MULT(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY11000", rx & 0x7, ry & 0x7)));
}

void ASM_MULTU(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY11001", rx & 0x7, ry & 0x7)));
}

void ASM_LW(int rx, int ry, int offset, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("10011XXXYYYZZZZZ", rx & 0x7, ry & 0x7, offset & 0x1f)));
}

void ASM_LW_SP(int rx, int offset, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("10010XXXYYYYYYYY", rx & 0x7, offset & 0xff)));
}

void ASM_LI(int rx, int immediate, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01101XXXYYYYYYYY", rx & 0x7, immediate & 0xff)));
}

void ASM_ADDIU(int rx, int immediate, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01001XXXYYYYYYYY", rx & 0x7, immediate & 0xff)));
}

void ASM_ADDU(int rx, int ry, int rz, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11100XXXYYYZZZ01", rx & 0x7, ry & 0x7, rz & 0x7)));
}

void ASM_SUBU(int rx, int ry, int rz, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11100XXXYYYZZZ11", rx & 0x7, ry & 0x7, rz & 0x7)));
}

void ASM_AND(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY01100", rx & 0x7, ry & 0x7)));
}

void ASM_OR(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY01101", rx & 0x7, ry & 0x7)));
}

void ASM_NOT(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY01111", rx & 0x7, ry & 0x7)));
}

void ASM_CMP(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY01010", rx & 0x7, ry & 0x7)));
}

void ASM_CMPI(int rx, int immediate, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01110XXXYYYYYYYY", rx & 0x7, immediate & 0xff)));
}

void ASM_SLT(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY00010", rx & 0x7, ry & 0x7)));
}

void ASM_SLL(int rx, int ry, int sa, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("00110XXXYYYZZZ00", rx & 0x7, ry & 0x7, sa & 0x7)));
}

void ASM_SLTI(int rx, int immediate, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01010XXXYYYYYYYY", rx & 0x7, immediate & 0xff)));
}

void ASM_SLTUI(int rx, int immediate, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01011XXXYYYYYYYY", rx & 0x7, immediate & 0xff)));
}

void ASM_SLTU(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY00011", rx & 0x7, ry & 0x7)));
}

void ASM_NEG(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY01011", rx & 0x7, ry & 0x7)));
}

void ASM_MOVE(int ry, int rz, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01100111YYY00ZZZ", 0, ry & 0x7, rz & 0x7)));
}

void ASM_XOR(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY01110", rx & 0x7, ry & 0x7)));
}

void ASM_SRA(int rx, int ry, int sa, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("00110XXXYYYZZZ11", rx & 0x7, ry & 0x7, sa & 0x7)));
}

void ASM_SRAV(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY00111", rx & 0x7, ry & 0x7)));
}

void ASM_SLLV(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY00100", rx & 0x7, ry & 0x7)));
}

void ASM_SRL(int rx, int ry, int sa, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("00110XXXYYYZZZ10", rx & 0x7, ry & 0x7, sa & 0x7)));
}

void ASM_SRLV(int rx, int ry, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXXYYY00110", rx & 0x7, ry & 0x7)));
}

void ASM_ADDIU_SP(int immediate, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01100011XXXXXXXX", immediate & 0xff)));
}

void ASM_ADDIU_30P(int rx, int ry, int immediate, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01000XXXYYY0ZZZZ", rx & 0x7, ry & 0x7, immediate & 0xf)));
}

void ASM_ADDIU_SP_30P(int rx, int immediate, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("00000XXXYYYYYYYY", rx & 0x7, immediate & 0xff)));
}

void ASM_JALR(int rx, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXX11000000", rx & 0x7)));
	bincode.insert(p, create_bincode(bincode_type_normal, encode("0000100000000000")));
}

void ASM_MFHI(int rx, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXX00010000", rx & 0x7)));
}

void ASM_MFLO(int rx, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXX00010010", rx & 0x7)));
}

void ASM_MTSP(int rx, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("01100100XXX00000", rx & 0x7)));
}

void ASM_MFPC(int rx, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("11101XXX01000000", rx & 0x7)));
}

void ASM_INT(int immediate, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_normal, encode("111110000000XXXX", immediate & 0xf)));
}

//TBinEntry create_bincode(int bincode_type, int code, int label_name = 0, int func_name = 0, int reg_name = 0, int jmpreg1 = 0, int jmpreg2 = 0, int short_num = 0)
void bin_load_constant_front(int reg_name, int short_num, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_load_const_front, 0, 0, 0, reg_name, 0, 0, short_num));
}

void bin_load_constant_back(int reg_name, int short_num, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_load_const_back, 0, 0, 0, reg_name, 0, 0, short_num));
}

void bin_load_funcaddr(int reg_name, int func_name, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_load_func, 0, 0, func_name, reg_name));
}

void bin_load_global_var(int reg_name, int short_num, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_load_global_var, 0, 0, 0, reg_name, 0, 0, short_num));
}

void bin_load_global_const(int reg_name, int short_num, list <TBinEntry> :: iterator p)
{
	bincode.insert(p, create_bincode(bincode_type_load_global_const, 0, 0, 0, reg_name, 0, 0, short_num));
}

void bin_load_immediate(int reg, int number, list <TBinEntry> :: iterator p)