Subversion Repositories openrisc

// ----------------------------------------------------------------------------
 
// Debug Unit memory cache: implementation
 
// Copyright (C) 2008  Embecosm Limited <info@embecosm.com>
 
// Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
// This file is part of the GDB interface to the cycle accurate model of the
// OpenRISC 1000 based system-on-chip, ORPSoC, built using Verilator.
 
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
 
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
// License for more details.
 
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
// ----------------------------------------------------------------------------
 
// $Id: MemCache.cpp 326 2009-03-07 16:47:31Z jeremy $
 
#include <cstring>
 
#include "MemCache.h"
 
//! Constructor
 
//! Allocate a closed hash table of the specified size and clear it.
 
//! @param[in] _tableSize  The desire hash table size. A prime number is
//!                         recommended.
 
MemCache::MemCache(int _tableSize):tableSize(_tableSize)
{
	tabIsValid = new bool[tableSize];
	tabKeyAddr = new uint32_t[tableSize];
	tabValue = new uint32_t[tableSize];
 
	clear();
 
}				// MemCache ()
 
//! Destructor
 
//! Free the hash table arrays
 
MemCache::~MemCache()
{
	delete[]tabIsValid;
	delete[]tabKeyAddr;
	delete[]tabValue;
 
}				// ~MemCache ()
 
//! Empty the hash table
 
//! Only need to worry about the validity field
void
 MemCache::clear()
{
	memset(tabIsValid, false, sizeof(tabIsValid));
 
}				// clear ()
 
//! Write a new value into the hash table
 
//! Will trash anything already there.
 
//! @param[in] addr   The address being written to
//! @param[in] value  The value to write
void MemCache::write(uint32_t addr, uint32_t value)
{
	int keyAddr = addr % tableSize;
 
	tabIsValid[keyAddr] = true;
	tabKeyAddr[keyAddr] = addr;
	tabValue[keyAddr] = value;
 
}				// write ()
 
//! Try to read a value from the hash table
 
//! The entry must be valid and the address must match
 
//! @param[in]  addr   The address being read from
//! @param[out] value  The value read, if there was one there
 
//! @return  True if the value was found in the hash table
 
bool MemCache::read(uint32_t addr, uint32_t & value)
{
	int keyAddr = addr % tableSize;
 
	if (tabIsValid[keyAddr] & (tabKeyAddr[keyAddr] == addr)) {
		value = tabValue[keyAddr];
		return true;
	} else {
		return false;
	}
}				// read ()