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 ()