powerpc.cpp

ppc750 system design simulator using system c

			cout << ")  !" << endl;
			ppc_debug_dump_registers(stdout);
			cout << *powerpc->registerFile;
			cout << "XER[SO] = " << powerpc->xerRegister->summaryOverflow << endl;
			cout << "XER[OV] = " << powerpc->xerRegister->overflow << endl;
			cout << "XER[CA] = " << powerpc->xerRegister->carry << endl;
			cout << "PC = "; WriteHex(cout, PC); cout << endl;
			cout << "time stamp = " << sim_time_stamp() << endl;
			ABORT();
		}
	}
	for(num = 0; num < nFloatingPointRegisters; num++)
	{
		if(FPR_DW(num) != powerpc->registerFile->floatingPointRegisters[num])
		{
			cout << "Simulator f" << num << " (";
			WriteHex(cout, powerpc->registerFile->floatingPointRegisters[num]);
			cout << ") != " << " Emulator f" << num << " (";
			WriteHex(cout, (UInt64) FPR_DW(num));
			cout << ")  !" << endl;
			ppc_debug_dump_registers(stdout);
			cout << *powerpc->registerFile;
			cout << "XER[SO] = " << powerpc->xerRegister->summaryOverflow << endl;
			cout << "XER[OV] = " << powerpc->xerRegister->overflow << endl;
			cout << "XER[CA] = " << powerpc->xerRegister->carry << endl;
			cout << "PC = "; WriteHex(cout, PC); cout << endl;
			cout << "time stamp = " << sim_time_stamp() << endl;
			ABORT();
		}
	}
	if(LR != powerpc->linkRegister->lr)
	{
		cout << "Simulator LR (";
		WriteHex(cout, powerpc->linkRegister->lr);
		cout << ") != " << " Emulator LR (";
		WriteHex(cout, (UInt32) LR);
		cout << ")  !" << endl;
		ppc_debug_dump_registers(stdout);
		cout << *powerpc->registerFile;
		cout << "XER[SO] = " << powerpc->xerRegister->summaryOverflow << endl;
		cout << "XER[OV] = " << powerpc->xerRegister->overflow << endl;
		cout << "XER[CA] = " << powerpc->xerRegister->carry << endl;
		cout << "PC = "; WriteHex(cout, PC); cout << endl;
		cout << "time stamp = " << sim_time_stamp() << endl;
		ABORT();
	}
	if(CTR != powerpc->countRegister->ctr)
	{
		cout << "Simulator CTR (";
		WriteHex(cout, powerpc->countRegister->ctr);
		cout << ") != " << " Emulator CTR (";
		WriteHex(cout, (UInt32) CTR);
		cout << ")  !" << endl;
		ppc_debug_dump_registers(stdout);
		cout << *powerpc->registerFile;
		cout << "XER[SO] = " << powerpc->xerRegister->summaryOverflow << endl;
		cout << "XER[OV] = " << powerpc->xerRegister->overflow << endl;
		cout << "XER[CA] = " << powerpc->xerRegister->carry << endl;
		cout << "PC = "; WriteHex(cout, PC); cout << endl;
		cout << "time stamp = " << sim_time_stamp() << endl;
		ABORT();
	}
	if(CR != powerpc->conditionRegister->cr)
	{
		cout << "Simulator CR (";
		WriteHex(cout, powerpc->conditionRegister->cr);
		cout << ") != " << " Emulator CR (";
		WriteHex(cout, (UInt32) CR);
		cout << ")  !" << endl;
		cout << "time stamp = " << sim_time_stamp() << endl;
		ppc_debug_dump_registers(stdout);
		cout << *powerpc->registerFile;
		cout << "XER[SO] = " << powerpc->xerRegister->summaryOverflow << endl;
		cout << "XER[OV] = " << powerpc->xerRegister->overflow << endl;
		cout << "XER[CA] = " << powerpc->xerRegister->carry << endl;
		cout << "PC = "; WriteHex(cout, PC); cout << endl;
		cout << "time stamp = " << sim_time_stamp() << endl;
		ABORT();
	}
		
	bool carry = ((XER >> 29) & 0x1) ? true : false;
	if(carry != powerpc->xerRegister->carry)
	{
		cout << "Simulator carry (" << powerpc->xerRegister->carry << ") != Emulator carry (" << carry << ")   !" << endl;
		cout << "PC = "; WriteHex(cout, PC); cout << endl;
		cout << "time stamp = " << sim_time_stamp() << endl;
		ABORT();
	}
	
	bool overflow = ((XER >> 30) & 0x1) ? true : false;
	if(overflow != powerpc->xerRegister->overflow)
	{
		cout << "Simulator overflow (" << powerpc->xerRegister->overflow << ") != Emulator overflow (" << overflow << ")   !" << endl;
		cout << "PC = "; WriteHex(cout, PC); cout << endl;
		cout << "time stamp = " << sim_time_stamp() << endl;
		ABORT();
	}
	
	bool summaryOverflow = ((XER >> 31) & 0x1) ? true : false;
	if(summaryOverflow != powerpc->xerRegister->summaryOverflow)
	{
		cout << "Simulator summary overflow (" << powerpc->xerRegister->summaryOverflow << ") != Emulator summary overflow (" << summaryOverflow << ")   !" << endl;
		cout << "PC = "; WriteHex(cout, PC); cout << endl;
		cout << "time stamp = " << sim_time_stamp() << endl;
		ABORT();
	}
}
#endif

void PowerPC::write_gpr(void *instance, int num, word_t value)
{
	powerpc->registerFile->registers[num] = value;
	GPR(num) = value;
}

word_t PowerPC::read_gpr(void *instance, int num)
{
#ifdef EMULATE
	powerpc->CheckRegisters();
#endif
	return powerpc->registerFile->registers[num];
}

void PowerPC::write_fpr(void *instance, int num, dword_t value)
{
	powerpc->registerFile->floatingPointRegisters[num] = value;
}

dword_t PowerPC::read_fpr(void *instance, int num)
{
#ifdef EMULATE
	powerpc->CheckRegisters();
#endif
	return powerpc->registerFile->floatingPointRegisters[num];
}

void PowerPC::write_cr(void *instance, word_t value)
{
	powerpc->conditionRegister->cr = value;
}

word_t PowerPC::read_cr(void *instance)
{
#ifdef EMULATE
	powerpc->CheckRegisters();
#endif
	return powerpc->conditionRegister->cr;
}

void PowerPC::write_lr(void *instance, word_t value)
{
	powerpc->linkRegister->lr = value;
}

word_t PowerPC::read_lr(void *instance)
{
#ifdef EMULATE
	powerpc->CheckRegisters();
#endif
	return powerpc->linkRegister->lr;
}

void PowerPC::write_ctr(void *instance, word_t value)
{
	powerpc->countRegister->ctr = value;
}

word_t PowerPC::read_ctr(void *instance)
{
#ifdef EMULATE
	powerpc->CheckRegisters();
#endif
	return powerpc->countRegister->ctr;
}

void PowerPC::write_xer(void *instance, word_t value)
{
	powerpc->xerRegister->overflow = ((value >> 30) & 1) ? true : false;
	powerpc->xerRegister->summaryOverflow = ((value >> 31) & 1) ? true : false;
	powerpc->xerRegister->carry = ((value >> 29) & 1) ? true : false;
}

word_t PowerPC::read_xer(void *instance)
{
#ifdef EMULATE
	powerpc->CheckRegisters();
#endif
	return (powerpc->xerRegister->overflow ? (1 << 30) : 0)
	     | (powerpc->xerRegister->summaryOverflow ? (1 << 31) : 0)
	     | (powerpc->xerRegister->carry ? (1 << 29) : 0);
}

void PowerPC::write_fpscr(void *instance, word_t value)
{
	/* unimplemented */
}

word_t PowerPC::read_fpscr(void *instance)
{
#ifdef EMULATE
	powerpc->CheckRegisters();
#endif
	/* unimplemented */
	return 0;
}

void PowerPC::write_pc(void *instance, word_t value)
{
	powerpc->fetchUnit->programCounter = value;
}

word_t PowerPC::read_pc(void *instance)
{
#ifdef EMULATE
	powerpc->CheckRegisters();
#endif
	return powerpc->fetchUnit->programCounter;
}



void PowerPC::reset_cr0so(void *instance)
{
	powerpc->conditionRegister->Write(powerpc->conditionRegister->cr & 0xefffffff); // CR0[SO] = 1
	CR = CR & 0xefffffff;
}

void PowerPC::set_cr0so(void *instance)
{
	powerpc->conditionRegister->Write(powerpc->conditionRegister->cr | 0x10000000); // CR0[SO] = 0
	CR = CR | 0x10000000;
}

byte_t PowerPC::mem_read_byte(void *instance, addr_t addr)
{
	byte_t value;
	
	if(powerpc->dcache->ReadByte(addr, value))
	{
#ifdef EMULATE		
		if(::MEM_READ_BYTE(addr) != value)
		{
			cout << "PowerPC::mem_read_byte() : data at "; WriteHex(cout, addr); cout << " is not the same into emulator and simulator (data cache)" << endl;
			StopSimulation();
		}
#endif		
		return value;
	}
	value = powerpc->busInterfaceUnit->ReadByte(addr);
	
#ifdef EMULATE		
	if(::MEM_READ_BYTE(addr) != value)
	{
		cout << "PowerPC::mem_read_byte() : data at "; WriteHex(cout, addr); cout << " is not the same into emulator and simulator (memory)" << endl;
		StopSimulation();
	}
#endif
	return value;
}

void PowerPC::mem_write_byte(void *instance, addr_t addr, byte_t value)
{
	powerpc->dcache->WriteByte(addr, value);
	powerpc->busInterfaceUnit->WriteByte(addr, value);
	::MEM_WRITE_BYTE(addr, value);
}

halfword_t PowerPC::mem_read_half_word(void *instance, addr_t addr)
{
	halfword_t value;
	
	if(powerpc->dcache->ReadHalfWord(addr, value))
	{
#ifdef EMULATE		
		if(::MEM_READ_HALF_WORD(addr) != value)
		{
			cout << "PowerPC::mem_read_halfword() : data at "; WriteHex(cout, addr); cout << " is not the same into emulator and simulator (data cache)" << endl;
			StopSimulation();
		}
#endif		
		return value;
	}
	value = powerpc->busInterfaceUnit->ReadHalfWord(addr);
	
#ifdef EMULATE		
	if(::MEM_READ_HALF_WORD(addr) != value)
	{
		cout << "PowerPC::mem_read_halfword() : data at "; WriteHex(cout, addr); cout << " is not the same into emulator and simulator (memory)" << endl;
		StopSimulation();
	}
#endif
	return value;
}

void PowerPC::mem_write_half_word(void *instance, addr_t addr, halfword_t value)
{
	powerpc->dcache->WriteHalfWord(addr, value);
	powerpc->busInterfaceUnit->WriteHalfWord(addr, value);
	::MEM_WRITE_HALF_WORD(addr, value);
}

word_t PowerPC::mem_read_word(void *instance, addr_t addr)
{
	word_t value;
	
	if(powerpc->dcache->ReadWord(addr, value))
	{
#ifdef EMULATE		
		if(::MEM_READ_WORD(addr) != value)
		{
			cout << "PowerPC::mem_read_word() : data at "; WriteHex(cout, addr); cout << " is not the same into emulator and simulator (data cache)" << endl;
			StopSimulation();
		}
#endif		
		return value;
	}
	value = powerpc->busInterfaceUnit->ReadWord(addr);
	
#ifdef EMULATE		
	if(::MEM_READ_WORD(addr) != value)
	{
		cout << "PowerPC::mem_read_word() : data at "; WriteHex(cout, addr); cout << " is not the same into emulator and simulator (memory)" << endl;
		StopSimulation();
	}
#endif
	return value;
}

void PowerPC::mem_write_word(void *instance, addr_t addr, word_t value)
{
	powerpc->dcache->WriteWord(addr, value);
	powerpc->busInterfaceUnit->WriteWord(addr, value);
	::MEM_WRITE_WORD(addr, value);
}

dword_t PowerPC::mem_read_dword(void *instance, addr_t addr)
{
	dword_t value;
	
	if(powerpc->dcache->ReadDWord(addr, value))
	{
#ifdef EMULATE		
		if(::MEM_READ_DWORD(addr) != value)
		{
			cout << "PowerPC::mem_read_dword() : data at "; WriteHex(cout, addr); cout << " is not the same into emulator and simulator (data cache)" << endl;
			StopSimulation();
		}
#endif		
		return value;
	}
	value = powerpc->busInterfaceUnit->ReadDWord(addr);
	
#ifdef EMULATE		
	if(::MEM_READ_DWORD(addr) != value)
	{
		cout << "PowerPC::mem_read_dword() : data at "; WriteHex(cout, addr); cout << " is not the same into emulator and simulator (memory)" << endl;
		StopSimulation();
	}
#endif
	return value;
}

void PowerPC::mem_write_dword(void *instance, addr_t addr, dword_t value)
{
	powerpc->dcache->WriteDWord(addr, value);
	powerpc->busInterfaceUnit->WriteDWord(addr, value);
	::MEM_WRITE_DWORD(addr, value);
}

void PowerPC::mem_set(void *instance, addr_t addr, byte_t value, int size)
{
	powerpc->dcache->MemorySet(addr, value, size);
	powerpc->busInterfaceUnit->MemorySet(addr, value, size);
	::MEM_SET(addr, value, size);
}

void PowerPC::mem_read(void *instance, void *buf, addr_t addr, int size)
{
	powerpc->busInterfaceUnit->MemoryRead((UInt8 *) buf, addr, size);
	powerpc->dcache->MemoryRead((UInt8 *) buf, addr, size);
#ifdef EMULATE
	void *buf2 = malloc(size);
	::MEM_READ(buf2, addr, size);
	if(memcmp(buf, buf2, size) != 0)
	{
		cout << "PowerPC::mem_read : data at "; WriteHex(cout, addr); cout << " is not the same into emulator and simulator" << endl;
	}
	free(buf2);
#endif	
}

void PowerPC::mem_write(void *instance, addr_t addr, void *buf, int size)
{
	powerpc->dcache->MemoryWrite(addr, (UInt8 *) buf, size);
	powerpc->busInterfaceUnit->MemoryWrite(addr, (UInt8 *) buf, size);
	::MEM_WRITE(addr, buf, size);
}

void PowerPC::Stop(int ninstructions)
{
	completionUnit->Stop(ninstructions);
	dcache->ResetStats();
	icache->ResetStats();
}