main.cpp

SystemC 实现 MIPS 处理器 源代码

		register_data=&(mips_reg_file.reg_data[0]);
	
		sc_signal<bool> reg_file_RegWrite;
		sc_signal<sc_uint<32> > WriteData;
		sc_signal<sc_uint<32> > result0,result1;

		mips_reg_file.clk(clk);
		mips_reg_file.read_reg0(rs);
		mips_reg_file.read_reg1(rt);

		//mips_reg_file.write_reg(rd);
		//mips_reg_file.write_data(WriteData);
		//mips_reg_file.write_enabled(reg_file_RegWrite);
		mips_reg_file.result0(result0);
		mips_reg_file.result1(result1);

	//比较器
	Equal mips_equal("equal");
		
		mips_equal.A(result0);
		mips_equal.B(result1);

		sc_signal<bool> isEqual;
		mips_equal.isEqual(isEqual);

	//立即数扩展
	imm_extender mips_imm_extender("imm_extender");

		mips_imm_extender.imm(imm);
		
		sc_signal<sc_uint<32> > imm_extend;
		
		mips_imm_extender.imm_extend(imm_extend);

	//branch指令PC计算器
	branch_pc mips_branch_pc("branch_pc");

		mips_branch_pc.pc_in(pc_out2);
		mips_branch_pc.offset(imm_extend);

		sc_signal<sc_uint<32> > branch_pc_out;

		mips_branch_pc.pc_out(branch_pc_out);

	//控制器
	Control_Unit mips_con_unit("Control_Unit");

		mips_con_unit.instr(instr_out);
		
		mips_con_unit.ALUC(ALUC);
		mips_con_unit.RegDst(RegDst);
		mips_con_unit.ALUSrc(ALUSrc);
		mips_con_unit.Branch(Branch);
		mips_con_unit.MemRead(MemRead);
		mips_con_unit.MemWrite(MemWrite);
		mips_con_unit.RegWrite(RegWrite);
		mips_con_unit.MemtoReg(MemtoReg);
		mips_con_unit.isEqual(isEqual);
		mips_con_unit.Jump(Jump);

	//选择跳转地址
	Mux_2x32 mips_branch_address("mips_branch_address");
		mips_branch_address.S(Jump);
		mips_branch_address.A0(branch_pc_out);
		mips_branch_address.A1(jump_address);

		sc_signal<sc_uint<32> > branch_address;
		mips_branch_address.out(branch_address);

	//PC指令选择器
	Mux_2x32 mips_branch_mux("branch_mux");
		
		mips_branch_mux.S(Branch);
		mips_branch_mux.A0(adder_pc_out);
		mips_branch_mux.A1(branch_address);

		mips_branch_mux.out(START_IF_pc_in);

	//ID_EX中间寄存器
	ID_EX mips_ID_EX("ID_EX");

		mips_ID_EX.ALUC(ALUC);
		mips_ID_EX.RegDst(RegDst);
		mips_ID_EX.ALUSrc(ALUSrc);
		mips_ID_EX.Branch(Branch);
		mips_ID_EX.MemRead(MemRead);
		mips_ID_EX.MemWrite(MemWrite);
		mips_ID_EX.RegWrite(RegWrite);
		mips_ID_EX.MemtoReg(MemtoReg);

		mips_ID_EX.pc_in(pc_out2);
		mips_ID_EX.reg_result0(result0);
		mips_ID_EX.reg_result1(result1);
		mips_ID_EX.imm_extend(imm_extend);
		mips_ID_EX.rt(rt_next);
		mips_ID_EX.rd(rd_next);
		mips_ID_EX.rs(rs_next);

		mips_ID_EX.clk(clk);

		sc_signal<bool> ID_EX_RegDst_out,ID_EX_ALUSrc_out,ID_EX_Branch_out,
				ID_EX_MemRead_out,ID_EX_MemWrite_out,ID_EX_RegWrite_out,ID_EX_MemtoReg_out;
		sc_signal<sc_uint<6> > ID_EX_ALUC_out;

		sc_signal<sc_uint<32> > ID_EX_pc_out;

		//寄存器得到的数值
		sc_signal<sc_uint<32> > ID_EX_result0_out,ID_EX_result1_out;
		//立即数扩展得到的数值
		sc_signal<sc_uint<32> > ID_EX_imm_extend_out;

		//rt,rd两个寄存器的值
		sc_signal<sc_uint<5> > ID_EX_rt_out,ID_EX_rd_out,ID_EX_rs_out;

		mips_ID_EX.ALUC_out(ID_EX_ALUC_out);
		mips_ID_EX.RegDst_out(ID_EX_RegDst_out);
		mips_ID_EX.ALUSrc_out(ID_EX_ALUSrc_out);
		mips_ID_EX.Branch_out(ID_EX_Branch_out);
		mips_ID_EX.MemRead_out(ID_EX_MemRead_out);
		mips_ID_EX.MemWrite_out(ID_EX_MemWrite_out);
		mips_ID_EX.RegWrite_out(ID_EX_RegWrite_out);
		mips_ID_EX.MemtoReg_out(ID_EX_MemtoReg_out);

		mips_ID_EX.pc_out(ID_EX_pc_out);
		mips_ID_EX.result0_out(ID_EX_result0_out);
		mips_ID_EX.result1_out(ID_EX_result1_out);
		mips_ID_EX.imm_extend_out(ID_EX_imm_extend_out);
		mips_ID_EX.rt_out(ID_EX_rt_out);
		mips_ID_EX.rd_out(ID_EX_rd_out);
		mips_ID_EX.rs_out(ID_EX_rs_out);

	//二路选择器，在alu之前的
	Mux_2x32 mips_alu_mux("mux_alu");
		
		mips_alu_mux.A0(ID_EX_result1_out);
		mips_alu_mux.A1(ID_EX_imm_extend_out);
		mips_alu_mux.S(ID_EX_ALUSrc_out);

		sc_signal<sc_uint<32> > mux_alu_out;
		mips_alu_mux.out(mux_alu_out);

	//转发单元
	Forward mips_forward("forward");
		
		mips_forward.EX_MEM_RegRd(EX_MEM_RegWrite_address_out);
		mips_forward.MEM_WB_RegRd(MEM_WB_Reg_address_out);
		mips_forward.rs(ID_EX_rs_out);
		mips_forward.rt(ID_EX_rt_out);
		mips_forward.ALUSrc(ID_EX_ALUSrc_out);
		mips_forward.MemtoReg(MEM_WB_MemtoReg_out);

		sc_signal<sc_uint<2> > ForwardA,ForwardB;
		mips_forward.ForwardA(ForwardA);
		mips_forward.ForwardB(ForwardB);

	//三路选择器，选择正式进入alu的值
	Mux_3x32 mips_alu_A("mux_alu_A");
		mips_alu_A.Forward(ForwardA);
		mips_alu_A.ID_EX_data(ID_EX_result0_out);
		mips_alu_A.EX_MEM_data(EX_MEM_ALU_result_out);
		mips_alu_A.MEM_WB_data(MEM_WB_ALUresult_out);

		sc_signal<sc_uint<32> > alu_A;
		mips_alu_A.data_out(alu_A);

	Mux_3x32 mips_alu_B("mux_alu_B");
		mips_alu_B.Forward(ForwardB);
		mips_alu_B.ID_EX_data(mux_alu_out);
		mips_alu_B.EX_MEM_data(EX_MEM_ALU_result_out);
		mips_alu_B.MEM_WB_data(MEM_WB_ALUresult_out);

		sc_signal<sc_uint<32> > alu_B;
		mips_alu_B.data_out(alu_B);
		
	//运算器
	ALU mips_ALU("ALU");
		
		mips_ALU.A(alu_A);
		mips_ALU.B(alu_B);
		mips_ALU.ALUC(ID_EX_ALUC_out);

		sc_signal<bool> alu_isZero;
		sc_signal<sc_uint<32> > alu_out;

		mips_ALU.R(alu_out);
		mips_ALU.isZero(alu_isZero);
	

	//二路选择器，选择写入寄存器的地址
	Mux_2x5 mips_reg_mux("mux_reg");

		mips_reg_mux.A0(ID_EX_rt_out);
		mips_reg_mux.A1(ID_EX_rd_out);
		mips_reg_mux.S(ID_EX_RegDst_out);

		sc_signal<sc_uint<5> > mux_reg_out;
		mips_reg_mux.out(mux_reg_out);


	//EX_MEM中间寄存器
	EX_MEM mips_EX_MEM("EX_MEM");

		mips_EX_MEM.clk(clk);

		mips_EX_MEM.ALU_result(alu_out);
		mips_EX_MEM.Branch(ID_EX_Branch_out);
		mips_EX_MEM.isZero(alu_isZero);
		mips_EX_MEM.MemRead(ID_EX_MemRead_out);
		mips_EX_MEM.MemtoReg(ID_EX_MemtoReg_out);
		mips_EX_MEM.MemWrite(ID_EX_MemWrite_out);
		mips_EX_MEM.MemWrite_data(ID_EX_result1_out);
		mips_EX_MEM.pc_in(ID_EX_pc_out);
		mips_EX_MEM.RegWrite(ID_EX_RegWrite_out);
		mips_EX_MEM.RegWrite_address(mux_reg_out);

		mips_EX_MEM.Branch_out(EX_MEM_Branch_out);
		mips_EX_MEM.MemRead_out(EX_MEM_MemRead_out);
		mips_EX_MEM.MemWrite_out(EX_MEM_MemWrite_out);
		mips_EX_MEM.RegWrite_out(EX_MEM_RegWrite_out);
		mips_EX_MEM.MemtoReg_out(EX_MEM_MemtoReg_out);
		mips_EX_MEM.pc_out(EX_MEM_pc_out);
		mips_EX_MEM.isZero_out(EX_MEM_isZero_out);
		mips_EX_MEM.ALU_result_out(EX_MEM_ALU_result_out);
		mips_EX_MEM.MemWrite_data_out(EX_MEM_MemWrite_data_out);
		mips_EX_MEM.RegWrite_address_out(EX_MEM_RegWrite_address_out);

	//数据存储器
	Data_Memory mips_data_memory("Data_Memory");
		
		mips_data_memory.clk(clk);
		
		mips_data_memory.address(EX_MEM_ALU_result_out);
		mips_data_memory.write_data(EX_MEM_MemWrite_data_out);
		mips_data_memory.MemWrite(EX_MEM_MemWrite_out);
		mips_data_memory.MemRead(EX_MEM_MemRead_out);
		
		sc_signal<sc_uint<32> > mem_data_out;
		mips_data_memory.data_out(mem_data_out);

	//MEM_WB 中间寄存器
	MEM_WB mips_MEM_WB("MEM_WB");

		mips_MEM_WB.clk(clk);

		mips_MEM_WB.ALUresult(EX_MEM_ALU_result_out);
		mips_MEM_WB.Memdata(mem_data_out);
		mips_MEM_WB.Reg_address(EX_MEM_RegWrite_address_out);
		mips_MEM_WB.RegWrite(EX_MEM_RegWrite_out);
		mips_MEM_WB.MemtoReg(EX_MEM_MemtoReg_out);
		
		mips_MEM_WB.ALUresult_out(MEM_WB_ALUresult_out);
		mips_MEM_WB.Memdata_out(MEM_WB_Memdata_out);
		mips_MEM_WB.MemtoReg_out(MEM_WB_MemtoReg_out);
		mips_MEM_WB.Reg_address_out(MEM_WB_Reg_address_out);
		mips_MEM_WB.RegWrite_out(MEM_WB_RegWrite_out);

	//二路选择器，选择输入寄存器的内容
	Mux_2x32 mux_memtoreg("memtoreg_mux");
		
		mux_memtoreg.A1(MEM_WB_Memdata_out);
		mux_memtoreg.A0(MEM_WB_ALUresult_out);
		mux_memtoreg.S(MEM_WB_MemtoReg_out);

		sc_signal<sc_uint<32> > memtoreg_data;
		
		mux_memtoreg.out(memtoreg_data);

	//反馈线
	mips_reg_file.write_enabled(MEM_WB_RegWrite_out);
	mips_reg_file.write_reg(MEM_WB_Reg_address_out);
	mips_reg_file.write_data(memtoreg_data);
	/*
	int j;
	for (j=0;j<10;++j) 
	{
		cout<<j<<": "; Print(mips_reg_file.reg_data[j],cout);
	}

	cout<<"--------------"<<endl;

	for (j=0;j<6;++j)
	{
		cout<<j<<": "; Print(mips_data_memory.mem_data[j],cout);
	}

	cout<<endl;
	cout<<endl;
	cout<<"After running..."<<endl;
	*/
/*
	sc_start(RunningTime);

	int j;
	//int j;
	for (j=0;j<10;++j) 
	{
		cout<<j<<": "; Print(mips_reg_file.reg_data[j],cout);
	}

	cout<<"--------------"<<endl;

	for (j=0;j<4;++j)
	{
		cout<<j<<": "; Print(mips_data_memory.mem_data[j],cout);
	}

	//
	fout<<endl;
	fout<<endl;
	fout<<"After running..."<<endl;

	for (j=0;j<10;++j) 
	{
		fout<<j<<": "; Print(mips_reg_file.reg_data[j],fout);
	}

	fout<<"--------------"<<endl;

	for (j=0;j<4;++j)
	{
		fout<<j<<": "; Print(mips_data_memory.mem_data[j],fout);
	}

	system("pause");
	return 0;
}
*/

/*
	pc s_pc("pc");

	adder_pc s_adder_pc("adder_pc");

	Instr_Memory s_instr_mem("Instr_Memory");

	Register_File s_reg_file("Register_File");


	ALU s_alu("ALU");

	//Data_Memory s_data_memory("Data_Memory");
	
	Control_Unit s_con_unit("Control_Unit");

	ID s_id("ID");

	sc_clock clk("clk",10);
	sc_signal<sc_uint<32> > pc_in,pc_out;
	
	s_pc.clk(clk);
	s_pc.pc_in(pc_in);
	s_pc.pc_out(pc_out);

	s_adder_pc.pc_in(pc_out);
	s_adder_pc.pc_out(pc_in);

	s_instr_mem.address(pc_out);

	sc_signal<sc_uint<32> > instr;
	s_instr_mem.instr(instr);
	s_con_unit.instr(instr);
	s_id.instr(instr);

	sc_signal<bool> write_reg;
	s_con_unit.RegWrite(write_reg);
	s_reg_file.write_enabled(write_reg);

	sc_signal<sc_uint<5> > rs,rt,rd;
	sc_signal<sc_uint<6> > calc;
	sc_signal<bool> isZero;

	s_alu.isZero(isZero);

	s_id.rs(rs);
	s_id.rt(rt);
	s_id.rd(rd);
	s_id.calc(calc);

	s_reg_file.clk(clk);
	s_reg_file.read_reg0(rs);
	s_reg_file.read_reg1(rt);
	s_reg_file.write_reg(rd);
	
	sc_signal<sc_uint<32> > a,b,r;
	s_reg_file.result0(a);
	s_reg_file.result1(b);
	s_alu.A(a);
	s_alu.B(b);
	s_alu.R(r);
	s_alu.ALUC(calc);
	s_reg_file.write_data(r);

	cout<<"init finish"<<endl;
	system("pause");

	sc_start(100);

	int j;
	for (j=0;j<10;++j) 
	{
		cout<<j<<": "; Print(s_reg_file.reg_data[j]);
	}
*/