Subversion Repositories openrisc

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

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