Subversion Repositories openrisc_me

// ----------------------------------------------------------------------------

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