registersbinding.cpp

ppc750 system design simulator using system c

	return -1;
}

tag_t RegistersBinding::AllocateCTRRenameBuffer()
{
	int tag;
	
	for(tag = 0; tag < nCTRRenameBuffers; tag++)
	{
		if(!ctrRenameBuffers[tag].renameCTR)
		{
			ctrRenameBuffers[tag].renameCTR = true;
			ctrRenameBuffers[tag].prev = ctrRename;
			if(ctrRename >= 0)
				ctrRenameBuffers[ctrRename].next = tag;
			ctrRenameBuffers[tag].next = -1;
			ctrRenameBuffers[tag].valid = false;
			ctrRename = tag;
			ctrFreeRenames--;

#ifdef DEBUG
			if(Debug(DebugRegistersBinding))
				cout << "Renaming CTR by rename buffer #" << (int) tag << endl;
#endif
			return tag;
		}
	}
	return -1;
}

tag_t RegistersBinding::GetCRRenameBuffer(fieldnum_t crf) const
{
	   return crRenames[crf];
}

tag_t RegistersBinding::GetLRRenameBuffer() const
{
	return lrRename;
}

tag_t RegistersBinding::GetCTRRenameBuffer() const
{
	return ctrRename;
}

void RegistersBinding::FreeCRRenameBuffer(tag_t tag)
{
	if(crRenameBuffers[tag].crfield >= 0)
	{
#ifdef DEBUG
		if(Debug(DebugRegistersBinding))
			cout << "Freeing CR rename buffer #" << (int) tag << endl;
#endif
		if(crRenameBuffers[tag].next >= 0)
		{
			crRenameBuffers[crRenameBuffers[tag].next].prev = -1;
		}
		else
		{
			crRenames[crRenameBuffers[tag].crfield] = -1;
		}
		crRenameBuffers[tag].crfield = -1;
		crRenameBuffers[tag].valid = false;
		crFreeRenames++;
	}
}

void RegistersBinding::FreeCRRenameBufferReverseOrder(tag_t tag)
{
	if(crRenameBuffers[tag].crfield >= 0)
	{
#ifdef DEBUG
		if(Debug(DebugRegistersBinding))
			cout << "Freeing CR rename buffer #" << (int) tag << endl;
#endif
		crRenames[crRenameBuffers[tag].crfield] = crRenameBuffers[tag].prev;
		if(crRenameBuffers[tag].prev >= 0)
			crRenameBuffers[crRenameBuffers[tag].prev].next = -1;
		crRenameBuffers[tag].crfield = -1;
		crRenameBuffers[tag].valid = false;
		crFreeRenames++;
	}
}

void RegistersBinding::FreeLRRenameBuffer(tag_t tag)
{
	if(lrRenameBuffers[tag].renameLR)
	{
#ifdef DEBUG
		if(Debug(DebugRegistersBinding))
			cout << "Freeing LR rename buffer #" << (int) tag << endl;
#endif
		if(lrRenameBuffers[tag].next >= 0)
		{
			lrRenameBuffers[lrRenameBuffers[tag].next].prev = -1;
		}
		else
		{
			lrRename = -1;
		}
		lrRenameBuffers[tag].renameLR = false;
		lrRenameBuffers[tag].valid = false;
		lrFreeRenames++;
	}
}

void RegistersBinding::FreeLRRenameBufferReverseOrder(tag_t tag)
{
	if(lrRenameBuffers[tag].renameLR)
	{
#ifdef DEBUG
		if(Debug(DebugRegistersBinding))
			cout << "Freeing LR rename buffer #" << (int) tag << endl;
#endif
		lrRename = lrRenameBuffers[tag].prev;
		if(lrRenameBuffers[tag].prev >= 0)
			lrRenameBuffers[lrRenameBuffers[tag].prev].next = -1;
		lrRenameBuffers[tag].renameLR = false;
		lrRenameBuffers[tag].valid = false;
		lrFreeRenames++;
	}
}

void RegistersBinding::FreeCTRRenameBuffer(tag_t tag)
{
	if(ctrRenameBuffers[tag].renameCTR)
	{
#ifdef DEBUG
		if(Debug(DebugRegistersBinding))
			cout << "Freeing CTR rename buffer #" << (int) tag << endl;
#endif
		if(ctrRenameBuffers[tag].next >= 0)
		{
			ctrRenameBuffers[ctrRenameBuffers[tag].next].prev = -1;
		}
		else
		{
			ctrRename = -1;
		}
		ctrRenameBuffers[tag].renameCTR = false;
		ctrRenameBuffers[tag].valid = false;
		ctrFreeRenames++;
	}
}

void RegistersBinding::FreeCTRRenameBufferReverseOrder(tag_t tag)
{
	if(ctrRenameBuffers[tag].renameCTR)
	{
#ifdef DEBUG
		if(Debug(DebugRegistersBinding))
			cout << "Freeing CTR rename buffer #" << (int) tag << endl;
#endif
		ctrRename = ctrRenameBuffers[tag].prev;
		if(ctrRenameBuffers[tag].prev >= 0)
			ctrRenameBuffers[ctrRenameBuffers[tag].prev].next = -1;
		ctrRenameBuffers[tag].renameCTR = false;
		ctrRenameBuffers[tag].valid = false;
		ctrFreeRenames++;
	}
}

void RegistersBinding::ValidateRenameBuffer(tag_t tag)
{
	renameBuffers[tag].valid = true;
}

void RegistersBinding::ValidateFloatingPointRenameBuffer(tag_t tag)
{
	fpRenameBuffers[tag].valid = true;
}

void RegistersBinding::ValidateCRRenameBuffer(tag_t tag)
{
	crRenameBuffers[tag].valid = true;
}

void RegistersBinding::ValidateLRRenameBuffer(tag_t tag)
{
	lrRenameBuffers[tag].valid = true;
}

void RegistersBinding::ValidateCTRRenameBuffer(tag_t tag)
{
	ctrRenameBuffers[tag].valid = true;
}

bool RegistersBinding::RenameBufferValid(tag_t tag) const
{
	return renameBuffers[tag].valid;
}

bool RegistersBinding::FloatingPointRenameBufferValid(tag_t tag) const
{
	return fpRenameBuffers[tag].valid;
}

bool RegistersBinding::CRRenameBufferValid(tag_t tag) const
{
	return crRenameBuffers[tag].valid;
}

bool RegistersBinding::LRRenameBufferValid(tag_t tag) const
{
	return lrRenameBuffers[tag].valid;
}

bool RegistersBinding::CTRRenameBufferValid(tag_t tag) const
{
	return ctrRenameBuffers[tag].valid;
}

ostream& operator << (ostream& os, const RegistersBinding& registersBinding)
{
	int i;
	
	for(i = 0; i < nRegisters; i++)
	{
		if(registersBinding.renames[i] >= 0)
		{
			os << "r" << i << " renamed by rr" << (int) registersBinding.renames[i] << endl;
		}
	}
	for(i = 0; i < nFloatingPointRegisters; i++)
	{
		if(registersBinding.fpRenames[i] >= 0)
		{
			os << "r" << i << " renamed by rfp" << (int) registersBinding.fpRenames[i] << endl;
		}
	}
	for(i = 0; i < 8; i++)
	{
		if(registersBinding.crRenames[i] >= 0)
		{
			os << "CR" << i << " renamed by CR rename buffer #" << (int) registersBinding.crRenames[i] << endl;
		}
	}
	if(registersBinding.lrRename >= 0)
		os << "LR renamed by LR rename buffer #" << registersBinding.lrRename << endl;
	if(registersBinding.ctrRename >= 0)
		os << "CTR renamed by CTR rename buffer #" << registersBinding.ctrRename << endl;
	
	for(i = 0; i < nRenameBuffers; i++)
	{
		if(registersBinding.renameBuffers[i].renamedRegister >= 0)
		{
			os << "rr" << i << " renames r" << (int) registersBinding.renameBuffers[i].renamedRegister << "(";
			if(registersBinding.renameBuffers[i].valid)
				os << "valid";
			else
				os << "not valid";
			os << ")";
			if(registersBinding.renameBuffers[i].prev >= 0)
				os << " previously renamed by rr" << (int) registersBinding.renameBuffers[i].prev;
			os << endl;
		}
	}
	
	for(i = 0; i < nFloatingPointRenameBuffers; i++)
	{
		if(registersBinding.fpRenameBuffers[i].renamedRegister >= 0)
		{
			os << "rfp" << i << " renames fp" << (int) registersBinding.fpRenameBuffers[i].renamedRegister << "(";
			if(registersBinding.fpRenameBuffers[i].valid)
				os << "valid";
			else
				os << "not valid";
			os << ")";
			if(registersBinding.fpRenameBuffers[i].prev >= 0)
				os << " previously renamed by rfp" << (int) registersBinding.fpRenameBuffers[i].prev;
			os << endl;
		}
	}
	
	for(i = 0; i < nCRRenameBuffers; i++)
	{
		if(registersBinding.crRenameBuffers[i].crfield >= 0)
		{
			os << "CR rename buffer #" << i << " renames CR" << (int) registersBinding.crRenameBuffers[i].crfield << "(";
			
			if(registersBinding.crRenameBuffers[i].valid)
				os << "valid";
			else
				os << "not valid";
			os << ")";
			
			if(registersBinding.crRenameBuffers[i].prev >= 0)
				os << " previously renamed by CR rename buffer #" << (int) registersBinding.crRenameBuffers[i].prev;
			os << endl;
		}
	}
	
	for(i = 0; i < nLRRenameBuffers; i++)
	{
		if(registersBinding.lrRenameBuffers[i].renameLR)
		{
			os << "LR rename buffer #" << i << " renames LR (";
			
			if(registersBinding.lrRenameBuffers[i].valid)
				os << "valid";
			else
				os << "not valid";
			os << ")";
			
			if(registersBinding.lrRenameBuffers[i].prev >= 0)
				os << " previously renamed by LR rename buffer #" << (int) registersBinding.lrRenameBuffers[i].prev;
			os << endl;
		}
	}
	
	for(i = 0; i < nCTRRenameBuffers; i++)
	{
		if(registersBinding.ctrRenameBuffers[i].renameCTR)
		{
			os << "CTR rename buffer #" << i << " renames CTR (";
			
			if(registersBinding.ctrRenameBuffers[i].valid)
				os << "valid";
			else
				os << "not valid";
			os << ")";
			
			if(registersBinding.ctrRenameBuffers[i].prev >= 0)
				os << " previously renamed by CTR rename buffer #" << (int) registersBinding.ctrRenameBuffers[i].prev;
			os << endl;
		}
	}
	return os;
}

bool RegistersBinding::Precondition()
{
	bool visited[nRenameBuffers];
	
	tag_t tag;
	for(tag = 0; tag < nRenameBuffers; tag++)
	{
		visited[tag] = false;
	}
	
	regnum_t num;
	for(num = 0; num < nRegisters; num++)
	{
		tag_t tag = renames[num];
		
		while(tag >= 0)
		{
			if(visited[tag]) return false;
			if(renameBuffers[tag].renamedRegister  != num) return false;
			visited[tag] = true;
			tag = renameBuffers[tag].prev;
		}
	}
	
	for(tag = 0; tag < nRenameBuffers; tag++)
	{
		if(!visited[tag])
		{
			if(renameBuffers[tag].renamedRegister >= 0) return false;
		}
	}
	return true;
}