registersbinding.cpp

ppc750 system design simulator using system c

/***************************************************************************
                          RegistersBinding.cpp  -  Register renaming
                             -------------------
    begin                : Fri Apr 6 2001
    copyright            : (C) 2001 Universite Paris Sud and CEA
    author               : Gilles Mouchard
    email                : [e-mail], gilles.mouchard@.cea.fr
 ***************************************************************************/

#include <systemc.h>
#include <RegistersBinding.h>
#include <stdlib.h>

#ifdef DEBUG
#define CONDITION
#endif

RegistersBinding::RegistersBinding()
{
	Reset();	
}

void RegistersBinding::Reset()
{
	regnum_t num;
	tag_t tag;
	fieldnum_t crf;

	nfree = nRenameBuffers;
	
	for(num = 0; num < nRegisters; num++)
	{
		renames[num] = -1;
	}
	
	for(tag = 0; tag < nRenameBuffers; tag++)
	{
		renameBuffers[tag].renamedRegister = -1;
		renameBuffers[tag].valid = false;
		renameBuffers[tag].prev = -1;
		renameBuffers[tag].next = -1;
	}
	
	nfpfree = nFloatingPointRenameBuffers;
	
	for(num = 0; num < nFloatingPointRegisters; num++)
	{
		fpRenames[num] = -1;
	}
	
	for(tag = 0; tag < nFloatingPointRenameBuffers; tag++)
	{
		fpRenameBuffers[tag].renamedRegister = -1;
		fpRenameBuffers[tag].valid = false;
		fpRenameBuffers[tag].prev = -1;
		fpRenameBuffers[tag].next = -1;
	}
	
	crFreeRenames = nCRRenameBuffers;
	for(crf = 0; crf < 8; crf++)
	{
		crRenames[crf] = -1;
	}
	
	for(tag = 0; tag < nCRRenameBuffers; tag++)
	{
		crRenameBuffers[tag].crfield = -1;
		crRenameBuffers[tag].valid = false;
		crRenameBuffers[tag].prev = -1;
		crRenameBuffers[tag].next = -1;
	}

	lrFreeRenames = nLRRenameBuffers;
	lrRename = -1;
	
	for(tag = 0; tag < nLRRenameBuffers; tag++)
	{
		lrRenameBuffers[tag].renameLR = false;
		lrRenameBuffers[tag].valid = false;
		lrRenameBuffers[tag].prev = -1;
		lrRenameBuffers[tag].next = -1;
	}

	ctrFreeRenames = nCTRRenameBuffers;
	ctrRename = -1;
	
	for(tag = 0; tag < nCTRRenameBuffers; tag++)
	{
		ctrRenameBuffers[tag].renameCTR = false;
		ctrRenameBuffers[tag].valid = false;
		ctrRenameBuffers[tag].prev = -1;
		ctrRenameBuffers[tag].next = -1;
	}
}

tag_t RegistersBinding::AllocateRenameBuffer(regnum_t regNum)
{
	tag_t tag;
#ifdef CONDITION
	if(!Precondition())
	{
		cout << "Precondition not valid before AllocateRenameBuffer" << endl;
		cout << *this;
		StopSimulation();
	}
#endif
	
	for(tag = 0; tag < nRenameBuffers; tag++)
	{
		if(renameBuffers[tag].renamedRegister < 0)
		{
			renameBuffers[tag].renamedRegister = regNum;
			renameBuffers[tag].prev = renames[regNum];
			if(renames[regNum] >= 0)
				renameBuffers[renames[regNum]].next = tag;
			renameBuffers[tag].next = -1;
			renameBuffers[tag].valid = false;
			renames[regNum] = tag;
			nfree--;
#ifdef DEBUG
			if(Debug(DebugRegistersBinding))
				cout << "Renaming register #" << (int) regNum << " by rename buffer #" << (int) tag << endl;
#endif
#ifdef CONDITION
			if(!Precondition())
			{
				cout << "Postcondition not valid after AllocateRenameBuffer" << endl;
				cout << *this;
				StopSimulation();
			}
#endif
			return tag;
		}
	}
	return -1;
}

tag_t RegistersBinding::AllocateFloatingPointRenameBuffer(regnum_t regNum)
{
	tag_t tag;
	
	for(tag = 0; tag < nFloatingPointRenameBuffers; tag++)
	{
		if(fpRenameBuffers[tag].renamedRegister < 0)
		{
			fpRenameBuffers[tag].renamedRegister = regNum;
			fpRenameBuffers[tag].prev = fpRenames[regNum];
			if(fpRenames[regNum] >= 0)
				fpRenameBuffers[fpRenames[regNum]].next = tag;
			fpRenameBuffers[tag].next = -1;
			fpRenameBuffers[tag].valid = false;
			fpRenames[regNum] = tag;
			nfpfree--;
#ifdef DEBUG
			if(Debug(DebugRegistersBinding))
				cout << "Renaming floating point register #" << (int) regNum << " by floating point rename buffer #" << (int) tag << endl;
#endif
			return tag;
		}
	}
	return -1;
}

regnum_t RegistersBinding::GetRegister(tag_t tag) const
{
	return renameBuffers[tag].renamedRegister;
}

regnum_t RegistersBinding::GetFloatingPointRegister(tag_t tag) const
{
	return fpRenameBuffers[tag].renamedRegister;
}

tag_t RegistersBinding::GetRenameBuffer(regnum_t regNum) const
{
	return renames[regNum];
}

tag_t RegistersBinding::GetFloatingPointRenameBuffer(regnum_t regNum) const
{
	return fpRenames[regNum];
}

void RegistersBinding::FreeRenameBuffer(tag_t tag)
{
#ifdef CONDITION
	if(!Precondition())
	{
		cout << "Precondition not valid before FreeRenameBuffer" << endl;
		cout << *this;
		ABORT();
	}
	if(renameBuffers[tag].prev >= 0)
	{
		cout << "FreeRenameBuffer (tag = " << (int) tag << ") is not called in order" << endl;
		cout << *this;
		ABORT();
	}
#endif
	if(renameBuffers[tag].renamedRegister >= 0)
	{
#ifdef DEBUG
		if(Debug(DebugRegistersBinding))
			cout << "Freeing rename buffer #" << (int) tag << endl;
#endif
		if(renameBuffers[tag].next >= 0)
		{
			renameBuffers[renameBuffers[tag].next].prev = -1;
		}
		else
		{
			renames[renameBuffers[tag].renamedRegister] = -1;
		}
		renameBuffers[tag].renamedRegister = -1;
		renameBuffers[tag].valid = false;
		nfree++;
	}

#ifdef CONDITION
	if(!Precondition())
	{
		cout << "Postcondition not valid after FreeRenameBuffer" << endl;
		cout << *this;
		ABORT();
	}
#endif
}

void RegistersBinding::FreeFloatingPointRenameBuffer(tag_t tag)
{
	if(fpRenameBuffers[tag].renamedRegister >= 0)
	{
#ifdef DEBUG
		if(Debug(DebugRegistersBinding))
			cout << "Freeing floating point rename buffer #" << (int) tag << endl;
#endif
		if(fpRenameBuffers[tag].next >= 0)
		{
			fpRenameBuffers[fpRenameBuffers[tag].next].prev = -1;
		}
		else
		{
			fpRenames[fpRenameBuffers[tag].renamedRegister] = -1;
		}
		fpRenameBuffers[tag].renamedRegister = -1;
		fpRenameBuffers[tag].valid = false;
		nfpfree++;
	}
}

void RegistersBinding::FreeRenameBufferReverseOrder(tag_t tag)
{
#ifdef CONDITION
	if(!Precondition())
	{
		cout << "Precondition not valid before FreeRenameBufferReverseOrder" << endl;
		cout << *this;
		ABORT();
	}
	if(renameBuffers[tag].next >= 0)
	{
		cout << "FreeRenameBufferReverseOrder (tag = " << (int) tag << ") is not called in reverse order" << endl;
		cout << *this;
		ABORT();
	}
#endif
	if(renameBuffers[tag].renamedRegister >= 0)
	{
#ifdef DEBUG
		if(Debug(DebugRegistersBinding))
			cout << "Freeing rename buffer #" << (int) tag << endl;
#endif
		renames[renameBuffers[tag].renamedRegister] = renameBuffers[tag].prev;
		if(renameBuffers[tag].prev >= 0)
			renameBuffers[renameBuffers[tag].prev].next = -1;
		renameBuffers[tag].renamedRegister = -1;
		renameBuffers[tag].valid = false;
		nfree++;
	}
#ifdef CONDITION
	if(!Precondition())
	{
		cout << "Postcondition not valid after FreeRenameBufferReverseOrder" << endl;
		cout << *this;
		ABORT();
	}
#endif
}

void RegistersBinding::FreeFloatingPointRenameBufferReverseOrder(tag_t tag)
{
	if(fpRenameBuffers[tag].renamedRegister >= 0)
	{
#ifdef DEBUG
		if(Debug(DebugRegistersBinding))
			cout << "Freeing floating point rename buffer #" << (int) tag << endl;
#endif
		fpRenames[fpRenameBuffers[tag].renamedRegister] = fpRenameBuffers[tag].prev;
		if(fpRenameBuffers[tag].prev >= 0)
			fpRenameBuffers[fpRenameBuffers[tag].prev].next = -1;
		fpRenameBuffers[tag].renamedRegister = -1;
		fpRenameBuffers[tag].valid = false;
		nfpfree++;
	}
}

tag_t RegistersBinding::AllocateCRRenameBuffer(fieldnum_t crf)
{
	tag_t tag;
	
	if(crf < 0) return -1;
	
	for(tag = 0; tag < nCRRenameBuffers; tag++)
	{
		if(crRenameBuffers[tag].crfield < 0)
		{
			crRenameBuffers[tag].crfield = crf;
			crRenameBuffers[tag].prev = crRenames[crf];
			if(crRenames[crf] >= 0)
				crRenameBuffers[crRenames[crf]].next = tag;
			crRenameBuffers[tag].next = -1;
			crRenameBuffers[tag].valid = false;
			crRenames[crf] = tag;
			crFreeRenames--;

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

fieldnum_t RegistersBinding::GetField(tag_t tag) const
{
	return crRenameBuffers[tag].crfield;
}

tag_t RegistersBinding::AllocateLRRenameBuffer()
{
	tag_t tag;
	
	for(tag = 0; tag < nLRRenameBuffers; tag++)
	{
		if(!lrRenameBuffers[tag].renameLR)
		{
			lrRenameBuffers[tag].renameLR = true;
			lrRenameBuffers[tag].prev = lrRename;
			if(lrRename >= 0)
				lrRenameBuffers[lrRename].next = tag;
			lrRenameBuffers[tag].next = -1;
			lrRenameBuffers[tag].valid = false;
			lrRename = tag;
			lrFreeRenames--;

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