Subversion Repositories openrisc_2011-10-31

// ----------------------------------------------------------------------------
 
// Matchpoint hash table: definition
 
// Copyright (C) 2008  Embecosm Limited <info@embecosm.com>
 
// Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
// This file is part of 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: MpHash.cpp 331 2009-03-12 17:01:48Z jeremy $
 
#include <cstdlib>
 
#include "MpHash.h"
 
 
//! Constructor
 
//! Allocate the hash table
//! @param[in] size  Number of slots in the  hash table. Defaults to
//!                  DEFAULT_MP_HASH_SIZE.
MpHash::MpHash (int  _size) :
  size (_size)
{
  // Allocate and clear the hash table
  hashTab = new MpEntry *[size];
 
  for (int  i = 0; i < size; i++)
    {
      hashTab[i] = NULL;
    }
}	// MpHash ()
 
 
//! Destructor
 
//! Free the hash table
MpHash::~MpHash ()
{
  delete [] hashTab;
 
}	// ~MpHash ()
 
 
//! Add an entry to the hash table
 
//! Add the entry if it wasn't already there. If it was there do nothing. The
//! match just be on type and addr. The instr need not match, since if this is
//! a duplicate insertion (perhaps due to a lost packet) they will be
//! different.
 
//! @note This method allocates memory. Care must be taken to delete it when
//! done.
 
//! @param[in] type   The type of matchpoint
//! @param[in] addr   The address of the matchpoint
//! @para[in]  instr  The instruction to associate with the address
void
MpHash::add (MpType    type,
	     uint32_t  addr,
	     uint32_t  instr)
{
  int      hv    = addr % size;
  MpEntry *curr;
 
  // See if we already have the entry
  for(curr = hashTab[hv]; NULL != curr; curr = curr->next)
    {
      if ((type == curr->type) && (addr == curr->addr))
	{
	  return;		// We already have the entry
	}
    }
 
  // Insert the new entry at the head of the chain
  curr = new MpEntry ();
 
  curr->type  = type;
  curr->addr  = addr;
  curr->instr = instr;
  curr->next  = hashTab[hv];
 
  hashTab[hv] = curr;
 
}	// add ()
 
 
//!Look up an entry in the matchpoint hash table
 
//! The match must be on type AND addr.
 
//! @param[in] type   The type of matchpoint
//! @param[in] addr   The address of the matchpoint
 
//! @return  The entry found, or NULL if the entry was not found
MpEntry *
MpHash::lookup (MpType    type,
		uint32_t  addr)
{
  int      hv   = addr % size;
 
  // Search
  for (MpEntry *curr = hashTab[hv]; NULL != curr; curr = curr->next)
    {
      if ((type == curr->type) && (addr == curr->addr))
	{
	  return  curr;		// The entry found
	}
    }
 
  return  NULL;			// Not found
 
}	// lookup ()
 
 
//! Delete an entry from the matchpoint hash table
 
//! If it is there the entry is deleted from the hash table. If it is not
//! there, no action is taken. The match must be on type AND addr. The entry
//! (MpEntry::) is itself deleted
 
//! The usual fun and games tracking the previous entry, so we can delete
//! things.
 
//! @param[in]  type   The type of matchpoint
//! @param[in]  addr   The address of the matchpoint
//! @param[out] instr  Location to place the instruction found. If NULL (the
//!                    default) then the instruction is not written back.
 
//! @return  TRUE if an entry was found and deleted
bool
MpHash::remove (MpType    type,
		uint32_t  addr,
		uint32_t *instr)
{
  int      hv   = addr % size;
  MpEntry *prev = NULL;
  MpEntry *curr;
 
  // Search
  for (curr  = hashTab[hv]; NULL != curr; curr = curr->next)
    {
      if ((type == curr->type) && (addr == curr->addr))
	{
	  // Found - delete. Method depends on whether we are the head of
	  // chain.
	  if (NULL == prev)
	    {
	      hashTab[hv] = curr->next;
	    }
	  else
	    {
	      prev->next = curr->next;
	    }
 
	  if (NULL != instr)
	    {
	      *instr = curr->instr;	// Return the found instruction
	    }
 
	  delete curr;
	  return true;			// Success
	}
 
      prev = curr;
    }
 
  return  false;			// Not found
 
}	// remove ()