binutils-gdb/sim/arm/bag.c

167 lines
3.8 KiB
C
Raw Normal View History

/* bag.c -- ARMulator support code: ARM6 Instruction Emulator.
Copyright (C) 1994 Advanced RISC Machines Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/********************************************************************/
/* bag.c: */
/* Offers a data structure for storing and getting pairs of number. */
/* The numbers are stored together, put one can be looked up by */
/* quoting the other. If a new pair is entered and one of the */
/* numbers is a repeat of a previous pair, then the previos pair */
/* is deleted. */
/********************************************************************/
#include "bag.h"
2000-02-08 21:54:27 +01:00
#include <stdlib.h>
#define HASH_TABLE_SIZE 256
#define hash(x) (((x)&0xff)^(((x)>>8)&0xff)^(((x)>>16)&0xff)^(((x)>>24)&0xff))
2000-02-05 08:30:26 +01:00
typedef struct hashentry
{
struct hashentry *next;
int first;
int second;
2000-02-05 08:30:26 +01:00
}
Hashentry;
Hashentry *lookupbyfirst[HASH_TABLE_SIZE];
Hashentry *lookupbysecond[HASH_TABLE_SIZE];
2000-02-05 08:30:26 +01:00
void
addtolist (Hashentry ** add, long first, long second)
{
while (*add)
add = &((*add)->next);
/* Malloc will never fail? :o( */
2000-02-05 08:30:26 +01:00
(*add) = (Hashentry *) malloc (sizeof (Hashentry));
(*add)->next = (Hashentry *) 0;
(*add)->first = first;
(*add)->second = second;
}
2000-02-05 08:30:26 +01:00
void
killwholelist (Hashentry * p)
{
Hashentry *q;
2000-02-05 08:30:26 +01:00
while (p)
{
q = p;
p = p->next;
free (q);
}
}
2000-02-08 21:54:27 +01:00
static void
removefromlist (Hashentry ** p, long first)
2000-02-05 08:30:26 +01:00
{
Hashentry *q;
2000-02-05 08:30:26 +01:00
while (*p)
{
if ((*p)->first == first)
{
q = (*p)->next;
free (*p);
*p = q;
return;
}
p = &((*p)->next);
}
}
2000-02-05 08:30:26 +01:00
void
BAG_putpair (long first, long second)
{
long junk;
2000-02-05 08:30:26 +01:00
if (BAG_getfirst (&junk, second) != NO_SUCH_PAIR)
BAG_killpair_bysecond (second);
addtolist (&lookupbyfirst[hash (first)], first, second);
addtolist (&lookupbysecond[hash (second)], first, second);
}
2000-02-05 08:30:26 +01:00
Bag_error
BAG_getfirst (long *first, long second)
{
Hashentry *look;
2000-02-05 08:30:26 +01:00
look = lookupbysecond[hash (second)];
while (look)
if (look->second == second)
{
*first = look->first;
return NO_ERROR;
}
return NO_SUCH_PAIR;
}
2000-02-05 08:30:26 +01:00
Bag_error
BAG_getsecond (long first, long *second)
{
Hashentry *look;
2000-02-05 08:30:26 +01:00
look = lookupbyfirst[hash (first)];
while (look)
{
if (look->first == first)
{
*second = look->second;
return NO_ERROR;
}
look = look->next;
}
return NO_SUCH_PAIR;
}
2000-02-05 08:30:26 +01:00
Bag_error
BAG_killpair_byfirst (long first)
{
long second;
2000-02-05 08:30:26 +01:00
if (BAG_getsecond (first, &second) == NO_SUCH_PAIR)
return NO_SUCH_PAIR;
2000-02-08 21:54:27 +01:00
removefromlist (&lookupbyfirst[hash (first)], first);
removefromlist (&lookupbysecond[hash (second)], first);
return NO_ERROR;
}
2000-02-05 08:30:26 +01:00
Bag_error
BAG_killpair_bysecond (long second)
{
long first;
2000-02-05 08:30:26 +01:00
if (BAG_getfirst (&first, second) == NO_SUCH_PAIR)
return NO_SUCH_PAIR;
2000-02-08 21:54:27 +01:00
removefromlist (&lookupbyfirst[hash (first)], first);
removefromlist (&lookupbysecond[hash (second)], first);
return NO_ERROR;
}
2000-02-05 08:30:26 +01:00
void
BAG_newbag ()
{
int i;
2000-02-05 08:30:26 +01:00
for (i = 0; i < 256; i++)
{
killwholelist (lookupbyfirst[i]);
killwholelist (lookupbysecond[i]);
lookupbyfirst[i] = lookupbysecond[i] = (Hashentry *) 0;
}
}