powerpc.cpp

ppc750 system design simulator using system c

		readRenameCRNumber[i].write(0);
		readRenameCRData[i].write(0);
	}
	cr.write(conditionRegister->cr);
	
	/* Link Register */
	for(i = 0; i < nReadRenameLRPorts; i++)
	{
		readRenameLRNumber[i].write(0);
		readRenameLRData[i].write(0);
	}
	lr.write(linkRegister->lr);
	
	/* Count Register */
	for(i = 0; i < nReadRenameCRPorts; i++)
	{
		readRenameCTRNumber[i].write(0);
		readRenameCTRData[i].write(0);
	}
	ctr.write(countRegister->ctr);
	
	/* XER Register */
	overflow.write(xerRegister->overflow);
	carry.write(xerRegister->carry);
	summaryOverflow.write(xerRegister->summaryOverflow);
	
	/* Integer units */
	for(i = 0; i < nIntegerUnit; i++)
	{
		integerBusy[i].write(false);
		integerDispatched[i].write(false);
		integerExecute[i].write(false);
	}
	
	/* Floating Point units */
	for(i = 0; i < nFloatingPointUnits; i++)
	{
		floatingPointBusy[i].write(false);
		floatingPointDispatched[i].write(false);
		floatingPointExecute[i].write(false);
	}
	
	/* Load/store unit */
	loadStoreBusy.write(false);
	loadStoreDispatched.write(false);
	loadStoreBranchCounter.write(0);
	storeQueueStalled.write(false);
	loadQueueStalled.write(false);
	
	/* Branch unit */
	branchBusy.write(false);
	branchDispatched.write(false);
	
	/* system register unit */
	systemRegisterDispatched.write(false);
	systemRegisterBusy.write(false);
	systemRegisterExecute.write(false);

	/* L1 Data cache */	
	lsu2dcacheReq.write(false);
	lsu2dcacheWrite.write(false);
	lsu2dcacheAddr.write(0);
	lsu2dcacheSize.write(0);
	dcache2lsuAck.write(false);
	dcache2lsuHit.write(false);

	/* Bus interface */
	dcache2biuReq.write(false);
	dcache2biuWrite.write(false);
	dcache2biuAddr.write(0);

	biu2dcacheAck.write(false);
	
	/* Integer units results */
	for(i = 0; i < nIntegerUnit; i++)
	{
		integerFinished[i].write(false);
		integerTag[i].write(-1);
		integerResultValid[i].write(false);
		integerResultTag[i].write(-1);
		integerResultData[i].write(0);
		integerResultCRValid[i].write(false);
		integerResultCRTag[i].write(-1);
		integerResultCRData[i].write(0);
		integerOverflow[i].write(false);
		integerCarry[i].write(false);
	}
	
	/* Floating point units results */
	for(i = 0; i < nFloatingPointUnits; i++)
	{
		floatingPointFinished[i].write(false);
		floatingPointTag[i].write(-1);
		floatingPointResultValid[i].write(false);
		floatingPointResultTag[i].write(-1);
		floatingPointResultData[i].write(0);
		floatingPointResultCRValid[i].write(false);
		floatingPointResultCRTag[i].write(-1);
		floatingPointResultCRData[i].write(0);
	}
	
	/* Load/Store unit results */
	for(i = 0; i < 2; i++)
	{
		loadStoreFinished[i].write(false);
		loadStoreTag[i].write(-1);
	}
	for(i = 0; i < 2; i++)
	{
		loadStoreResultValid[i].write(false);
		loadStoreResultTag[i].write(-1);
		loadStoreResultData[i].write(0);
	}
	loadStoreFloatingPointResultValid.write(false);
	loadStoreFloatingPointResultData.write(0);
	
	/* Branch unit results */
	branchFinished.write(false);
	branchTag.write(-1);
	
	branchResultLRValid.write(false);
	branchResultLRTag.write(-1);
	branchResultLRData.write(0);
	
	branchResultCTRValid.write(false);
	branchResultCTRTag.write(-1);
	branchResultCTRData.write(0);
	
	branchPC.write(0);
	mispredictedBranch.write(false);
	
	updateBHT.write(false);
	updateBHTPC.write(0);
	updateBHTTakenBranch.write(false);
	
	/* System register unit results */
	systemRegisterFinished.write(false);
	systemRegisterTag.write(-1);
	
	systemRegisterResultValid.write(false);
	systemRegisterResultTag.write(-1);
	systemRegisterResultData.write(0);
	
	systemRegisterResultLRValid.write(false);
	systemRegisterResultLRTag.write(-1);
	systemRegisterResultLRData.write(0);
	
	systemRegisterResultCTRValid.write(false);
	systemRegisterResultCTRTag.write(-1);
	systemRegisterResultCTRData.write(0);

	systemRegisterResultCRValid.write(false);
	systemRegisterResultCRTag.write(-1);
	systemRegisterResultCRData.write(0);
	
	/* Write back */
	for(i = 0; i < nWriteBackPorts; i++)
	{
		writeBack[i].write(false);
		writeBackRegisterNumber[i].write(0);
		writeBackRenameNumber[i].write(0);
	}
	
	for(i = 0; i < nWriteBackFloatingPointPorts; i++)
	{
		writeBackFloatingPoint[i].write(false);
		writeBackFloatingPointRegisterNumber[i].write(0);
		writeBackFloatingPointRenameNumber[i].write(0);
	}
	
	for(i = 0; i < nWriteBackCRPorts; i++)
	{
		writeBackCR[i].write(false);
		writeBackCRRenameNumber[i].write(0);
		writeBackCRFieldNumber[i].write(0);
	}
	
	for(i = 0; i < nWriteBackLRPorts; i++)
	{
		writeBackLR[i].write(false);
		writeBackLRRenameNumber[i].write(0);
	}

	for(i = 0; i < nWriteBackCTRPorts; i++)
	{
		writeBackCTR[i].write(false);
		writeBackCTRRenameNumber[i].write(0);
	}
	
	for(i = 0; i < nMemoryWriteBackPorts; i++)
	{
		memoryWriteBack[i].write(false);
		memoryWriteBackTag[i].write(0);
	}

	writeCarry.write(false);
	writeCarryData.write(false);
	writeOverflow.write(false);
	writeOverflowData.write(false);
	
	writeCR.write(false);
	
	/* Interlock */
	clearInterlock.write(false);
	
	fetchUnit->Reset();
	dcache->Reset();
	icache->Reset();
	busInterfaceUnit->Reset();
	dispatchUnit->Reset();
	
	for(i = 0; i < nIntegerUnit; i++)
		integerUnit[i]->Reset();
		
	for(i = 0; i < nFloatingPointUnits; i++)
		floatingPointUnit[i]->Reset();
		
	loadStoreUnit->Reset();
	branchUnit->Reset();
	systemRegisterUnit->Reset();
	completionUnit->Reset();
	reorderBuffer->Flush();
	registersBinding->Reset();
}

bool PowerPC::LoadBinary(UInt32 addr, const char *filename)
{
	FILE *fobj = fopen(filename, "rb");
	if(fobj == NULL) return false;
	
	long size;
	fseek(fobj, 0, SEEK_END);
	size = ftell(fobj);
	fseek(fobj, 0, SEEK_SET);

	UInt8 *buffer = (UInt8 *) malloc(size);
	fread(buffer, size, 1, fobj);
	busInterfaceUnit->MemoryWrite(addr, buffer, size);
	free(buffer);
	fclose(fobj);
	return true;
}

bool PowerPC::LoadProgram(const char *filename, int argc, char *argv[], char *envp[])
{
	Elf32_Ehdr *hdr;
	Elf32_Phdr *phdr;
	Elf32_Shdr *shdr;
	char *string_table;
	Elf32_Shdr *shdr_new_section;
	Elf32_Word new_section_size, new_section_type;
	void *new_section;
	Elf32_Addr new_section_addr;
	int i;	
	FILE *fobj;
	UInt32 data_base = 0;
	UInt32 data_size = 0;

	/* Load the program into the simulator memory */
	fobj = fopen(filename, "rb");
	if(fobj == NULL) return false;

	hdr = ReadElfHeader(fobj);
	
	if(hdr == NULL)
	{
		fprintf(stderr, "Could not read ELF32 header or this is not an ELF32 file.\n");
		exit(1);
	}
		
	phdr = ReadProgramHeaders(hdr, fobj);

	for(i=0; i<hdr->e_phnum; i++)
	{
	    if ( (phdr[i].p_type == PT_LOAD) /* Loadable Program Segment */
		 &&
		 ((phdr->p_flags & PF_X) != 0 /* not text segment => data segment */))
	    {
		data_base = phdr[i].p_vaddr;
		data_size = phdr[i].p_memsz;
	    }
	}

	shdr = ReadSectionHeaders(hdr, fobj);
	
	if(shdr == NULL)
	{
		fprintf(stderr, "Can't read section headers from executable\n");
		exit(1);
	}
	string_table = LoadStringTable(hdr, shdr, fobj);

	for(i = 0; i < hdr->e_shnum; i++)
	{
		shdr_new_section = &shdr[i];

		new_section_type = GetSectionType(shdr_new_section);
		if ( (new_section_type == SHT_PROGBITS)
			||
			(new_section_type == SHT_NOBITS) )
		{
			new_section_size = shdr_new_section ? GetSectionSize(shdr_new_section) : 0;
			new_section_addr = GetSectionAddr(shdr_new_section);
			
//			cerr << "Loading " << GetSymbolName(shdr[i].sh_name, string_table) << " (" << new_section_size << " bytes) of type " << new_section_type << " at "; WriteHex(cerr, (UInt32) new_section_addr); cerr << endl;
		
			if (new_section_size)
			{
				new_section = malloc(new_section_size);
				LoadSection(shdr_new_section, new_section, fobj);
				if ( (strcmp(GetSymbolName(shdr[i].sh_name, string_table), ".bss") == 0)
						||
					(strcmp(GetSymbolName(shdr[i].sh_name, string_table), ".sbss") == 0) )
				{
					/* unitialized section => write 0s */
					busInterfaceUnit->ZeroMemory(new_section_addr, new_section_size);
				}
				else
				{
					/* initialized section => copy from objfile */
					if (strcmp(GetSymbolName(shdr[i].sh_name, string_table), ".text") == 0)
					{
						busInterfaceUnit->MemoryWrite(new_section_addr, (UInt8 *) new_section, new_section_size);
						busInterfaceUnit->ZeroMemory(new_section_addr + new_section_size, 128);
						fetchUnit->programCounter = new_section_addr;
					}
					else
					{
						busInterfaceUnit->MemoryWrite(new_section_addr, (UInt8 *) new_section, new_section_size);
					}

				}
		
				free(new_section);
			}
		}
	}
	
	fclose(fobj);
	
	UInt32 envAddr, argAddr;
	int nEnvStrings;
	UInt32 strSize;
	
	busInterfaceUnit->ZeroMemory(StackBase - StackSize, StackSize);
	
	UInt32& sp = registerFile->registers[1];
	sp = StackBase - MaxEnviron;
	
	envAddr = sp;
	argAddr = sp;
	
	for(nEnvStrings = 0; envp[nEnvStrings]; nEnvStrings++)
	{
		strSize = strlen(envp[nEnvStrings]) + 1;
		busInterfaceUnit->MemoryWrite(envAddr, (UInt8 *) envp[nEnvStrings], strSize);
		envAddr += strSize;
	}
	
	for(i = argc - 1; i >= 0; i--)
	{
		strSize = strlen(argv[i]) + 1;
		sp -= strSize;
		busInterfaceUnit->MemoryWrite(sp, (UInt8 *) argv[i], strSize);
	}
	
	sp -= sp % 4;
	sp -= 4;
	busInterfaceUnit->WriteWord(sp, 0);
	
	for(i = nEnvStrings - 1; i >= 0; i--)
	{
		strSize = strlen(envp[i]) + 1;
		envAddr -= strSize;
		sp -= 4;
		busInterfaceUnit->WriteWord(sp, envAddr);
	}
	
	sp -= 4;
	busInterfaceUnit->WriteWord(sp, 0);
	
	for(i = argc - 1; i >= 0; i--)
	{
		strSize = strlen(argv[i]) + 1;
		argAddr -= strSize;
		sp -= 4;
		busInterfaceUnit->WriteWord(sp, argAddr);
	}
	
	sp -= 4;
	busInterfaceUnit->WriteWord(sp, argc);
	return true;
}

#ifdef EMULATE
void PowerPC::CheckRegisters()
{
	int num;
	
	for(num = 0; num < nRegisters; num++)
	{
		if(GPR(num) != powerpc->registerFile->registers[num])
		{
			cout << "Simulator r" << num << " (";
			WriteHex(cout, powerpc->registerFile->registers[num]);
			cout << ") != " << " Emulator r" << num << " (";
			WriteHex(cout, (UInt32) GPR(num));