OpenE2K/binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

(hash_ask): Call strcmp instead of expanding it inline.

Browse Source 
(hash_code): Replaced with a version from bfd.
This commit is contained in:
Ken Raeburn 1995-01-18 18:52:08 +00:00
parent 958998b7aa
commit 95ac738e70
1 changed files with 571 additions and 569 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

332
gas/hash.c
View File

@ -1,5 +1,5 @@
/* hash.c - hash table lookup strings -
Copyright (C) 1987, 1990, 1991 Free Software Foundation, Inc.
Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
@ -67,12 +67,13 @@
/*
* The code and its structures are re-enterent.
*
* Before you do anything else, you must call hash_new() which will
* return the address of a hash-table-control-block (or NULL if there
* is not enough memory). You then use this address as a handle of the
* symbol table by passing it to all the other hash_...() functions.
* The only approved way to recover the memory used by the symbol table
* is to call hash_die() with the handle of the symbol table.
* return the address of a hash-table-control-block. You then use
* this address as a handle of the symbol table by passing it to all
* the other hash_...() functions. The only approved way to recover
* the memory used by the symbol table is to call hash_die() with the
* handle of the symbol table.
*
* Before you call hash_die() you normally delete anything pointed to
* by individual symbols. After hash_die() you can't use that symbol
@ -103,8 +104,7 @@
* (total hashes,collisions) for (reads,writes) (*)
* All of the above values vary in time.
* (*) some of these numbers will not be meaningful if we change the
* internals.
*/
* internals. */
/*
* I N T E R N A L
@ -136,23 +136,21 @@
#define error as_fatal
#define DELETED ((char *)1) /* guarenteed invalid address */
#define START_POWER (11) /* power of two: size of new hash table *//* JF was 6 */
/* JF These next two aren't used any more. */
/* #define START_SIZE (64) / * 2 ** START_POWER */
/* #define START_FULL (32) / * number of entries before table expands */
#define islive(ptr) (ptr->hash_string && ptr->hash_string!=DELETED)
/* above TRUE if a symbol is in entry @ ptr */
#define DELETED ((PTR)1) /* guarenteed invalid address */
#define START_POWER (11) /* power of two: size of new hash table */
#define STAT_SIZE (0) /* number of slots in hash table */
/* the wall does not count here */
/* we expect this is always a power of 2 */
/* TRUE if a symbol is in entry @ ptr. */
#define islive(ptr) (ptr->hash_string && ptr->hash_string!=DELETED)
/* Number of slots in hash table. The wall does not count here.
We expect this is always a power of 2. */
#define STAT_SIZE (0)
#define STAT_ACCESS (1) /* number of hash_ask()s */
#define STAT__READ (0) /* reading */
#define STAT__WRITE (1) /* writing */
#define STAT_COLLIDE (3) /* number of collisions (total) */
/* this may exceed STAT_ACCESS if we have */
/* lots of collisions/access */
/* Number of collisions (total). This may exceed STAT_ACCESS if we
have lots of collisions/access. */
#define STAT_COLLIDE (3)
#define STAT_USED (5) /* slots used right now */
#define STATLENGTH (6) /* size of statistics block */
#if STATLENGTH != HASH_STATLENGTH
@ -162,7 +160,8 @@ Panic! Please make #include "stat.h" agree with previous definitions!
/* #define SUSPECT to do runtime checks */
/* #define TEST to be a test jig for hash...() */
#ifdef TEST /* TEST: use smaller hash table */
#ifdef TEST
/* TEST: use smaller hash table */
#undef START_POWER
#define START_POWER (3)
#undef START_SIZE
@ -180,7 +179,7 @@ Panic! Please make #include "stat.h" agree with previous definitions!
char * s; symbol string (address) [ key ]
char * v; value string (address) [datum]
boolean f; TRUE if we found s in hash table i
char * t; error string; "" means OK
char * t; error string; 0 means OK
int a; access type [0...n) i
c=hash_new () create new hash_control
@ -229,47 +228,37 @@ Panic! Please make #include "stat.h" agree with previous definitions!
*/
static char hash_found; /* returned by hash_ask() to stop extra */
/* testing. hash_ask() wants to return both */
/* a slot and a status. This is the status. */
/* TRUE: found symbol */
/* FALSE: absent: empty or deleted slot */
/* Also returned by hash_jam(). */
/* TRUE: we replaced a value */
/* FALSE: we inserted a value */
/* Returned by hash_ask() to stop extra testing. hash_ask() wants to
return both a slot and a status. This is the status. TRUE: found
symbol FALSE: absent: empty or deleted slot Also returned by
hash_jam(). TRUE: we replaced a value FALSE: we inserted a value. */
static char hash_found;
static struct hash_entry * hash_ask();
static int hash_code ();
static char * hash_grow();
static struct hash_entry *hash_ask PARAMS ((struct hash_control *,
const char *, int));
static int hash_code PARAMS ((struct hash_control *, const char *));
static const char *hash_grow PARAMS ((struct hash_control *));
/*
* h a s h _ n e w ( )
*
*/
/* Create a new hash table. Return NULL if failed; otherwise return handle
(address of struct hash). */
struct hash_control *
hash_new() /* create a new hash table */
/* return NULL if failed */
/* return handle (address of struct hash) */
hash_new ()
{
register struct hash_control * retval;
register struct hash_entry * room; /* points to hash table */
register struct hash_entry * wall;
register struct hash_entry * entry;
register int * ip; /* scan stats block of struct hash_control */
register int * nd; /* limit of stats block */
struct hash_control *retval;
struct hash_entry *room; /* points to hash table */
struct hash_entry *wall;
struct hash_entry *entry;
int *ip; /* scan stats block of struct hash_control */
int *nd; /* limit of stats block */
if (( room = (struct hash_entry *) malloc( sizeof(struct
hash_entry)*((1<<START_POWER) + 1) ) ) != NULL)
room = (struct hash_entry *) xmalloc (sizeof (struct hash_entry)
/* +1 for the wall entry */
{
if (( retval = (struct hash_control *) malloc(sizeof(struct
hash_control)) ) != NULL)
{
* ((1 << START_POWER) + 1));
retval = (struct hash_control *) xmalloc (sizeof (struct hash_control));
nd = retval->hash_stat + STATLENGTH;
for (ip = retval->hash_stat; ip < nd; ip++)
{
*ip = 0;
}
retval->hash_stat[STAT_SIZE] = 1 << START_POWER;
retval->hash_mask = (1 << START_POWER) - 1;
@ -280,16 +269,8 @@ struct hash_control *
wall = room + (1 << START_POWER);
retval->hash_full = (1 << START_POWER) / 2;
for (entry = room; entry <= wall; entry++)
{
entry->hash_string = NULL;
}
}
}
else
{
retval = NULL; /* no room for table: fake a failure */
}
return(retval); /* return NULL or set-up structs */
return retval;
}
/*
@ -325,12 +306,12 @@ struct hash_control * handle;
*/
void
hash_say (handle, buffer, bufsiz)
register struct hash_control * handle;
register int buffer[/*bufsiz*/];
register int bufsiz;
struct hash_control *handle;
int buffer[ /*bufsiz*/ ];
int bufsiz;
{
register int * nd; /* limit of statistics block */
register int * ip; /* scan statistics */
int *nd; /* limit of statistics block */
int *ip; /* scan statistics */
ip = handle->hash_stat;
nd = ip + min (bufsiz - 1, STATLENGTH);
@ -353,21 +334,21 @@ register int bufsiz;
* Anyway, the symbol is not present after this function.
*
*/
char * /* NULL if string not in table, else */
PTR /* NULL if string not in table, else */
/* returns value of deleted symbol */
hash_delete (handle, string)
register struct hash_control * handle;
register char * string;
struct hash_control *handle;
const char *string;
{
register char * retval; /* NULL if string not in table */
register struct hash_entry * entry; /* NULL or entry of this symbol */
PTR retval;
struct hash_entry *entry;
entry = hash_ask (handle, string, STAT__WRITE);
if (hash_found)
{
retval = entry->hash_value;
entry -> hash_string = DELETED; /* mark as deleted */
handle -> hash_stat[STAT_USED] -= 1; /* slots-in-use count */
entry->hash_string = DELETED;
handle->hash_stat[STAT_USED] -= 1;
#ifdef SUSPECT
if (handle->hash_stat[STAT_USED] < 0)
{
@ -390,14 +371,14 @@ register char * string;
* Return NULL and don't change the table if the symbol is not already
* in the table.
*/
char *
PTR
hash_replace (handle, string, value)
register struct hash_control * handle;
register char * string;
register char * value;
struct hash_control *handle;
const char *string;
PTR value;
{
register struct hash_entry * entry;
register char * retval;
struct hash_entry *entry;
char *retval;
entry = hash_ask (handle, string, STAT__WRITE);
if (hash_found)
@ -410,32 +391,32 @@ register char * value;
retval = NULL;
}
;
return (retval);
return retval;
}
/*
* h a s h _ i n s e r t ( )
*
* Insert a (symbol-string, value) into the hash table.
* Return an error string, "" means OK.
* Return an error string, 0 means OK.
* It is an 'error' to insert an existing symbol.
*/
char * /* return error string */
const char * /* return error string */
hash_insert (handle, string, value)
register struct hash_control * handle;
register char * string;
register char * value;
struct hash_control *handle;
const char *string;
PTR value;
{
register struct hash_entry * entry;
register char * retval;
struct hash_entry *entry;
const char *retval;
retval = "";
retval = 0;
if (handle->hash_stat[STAT_USED] > handle->hash_full)
{
retval = hash_grow (handle);
}
if ( ! * retval)
if (!retval)
{
entry = hash_ask (handle, string, STAT__WRITE);
if (hash_found)
@ -449,7 +430,7 @@ register char * value;
handle->hash_stat[STAT_USED] += 1;
}
}
return(retval);
return retval;
}
/*
@ -458,7 +439,7 @@ register char * value;
* Regardless of what was in the symbol table before, after hash_jam()
* the named symbol has the given value. The symbol is either inserted or
* (its value is) relpaced.
* An error message string is returned, "" means OK.
* An error message string is returned, 0 means OK.
*
* WARNING: this may decide to grow the hashed symbol table.
* To do this, we call hash_grow(), WHICH WILL recursively CALL US.
@ -466,21 +447,21 @@ register char * value;
* We report status internally: hash_found is TRUE if we replaced, but
* false if we inserted.
*/
char *
const char *
hash_jam (handle, string, value)
register struct hash_control * handle;
register char * string;
register char * value;
struct hash_control *handle;
const char *string;
PTR value;
{
register char * retval;
register struct hash_entry * entry;
const char *retval;
struct hash_entry *entry;
retval = "";
retval = 0;
if (handle->hash_stat[STAT_USED] > handle->hash_full)
{
retval = hash_grow (handle);
}
if (! * retval)
if (!retval)
{
entry = hash_ask (handle, string, STAT__WRITE);
if (!hash_found)
@ -490,7 +471,7 @@ register char * value;
}
entry->hash_value = value;
}
return(retval);
return retval;
}
/*
@ -498,26 +479,26 @@ register char * value;
*
* Grow a new (bigger) hash table from the old one.
* We choose to double the hash table's size.
* Return a human-scrutible error string: "" if OK.
* Return a human-scrutible error string: 0 if OK.
* Warning! This uses hash_jam(), which had better not recurse
* back here! Hash_jam() conditionally calls us, but we ALWAYS
* call hash_jam()!
* Internal.
*/
static char *
static const char *
hash_grow (handle) /* make a hash table grow */
struct hash_control *handle;
{
register struct hash_entry * newwall;
register struct hash_entry * newwhere;
struct hash_entry *newwall;
struct hash_entry *newwhere;
struct hash_entry *newtrack;
register struct hash_entry * oldtrack;
register struct hash_entry * oldwhere;
register struct hash_entry * oldwall;
register int temp;
struct hash_entry *oldtrack;
struct hash_entry *oldwhere;
struct hash_entry *oldwall;
int temp;
int newsize;
char * string;
char * retval;
const char *string;
const char *retval;
#ifdef SUSPECT
int oldused;
#endif
@ -534,11 +515,13 @@ struct hash_control * handle;
* attempt to get enough room for a hash table twice as big
*/
temp = handle->hash_stat[STAT_SIZE];
if (( newwhere = (struct hash_entry *)
xmalloc((long)((temp+temp+1)*sizeof(struct hash_entry)))) != NULL)
if ((newwhere = ((struct hash_entry *)
xmalloc ((unsigned long) ((temp + temp + 1)
* sizeof (struct hash_entry)))))
!= NULL)
/* +1 for wall slot */
{
retval = ""; /* assume success until proven otherwise */
retval = 0; /* assume success until proven otherwise */
/*
* have enough room: now we do all the work.
* double the size of everything in handle,
@ -566,22 +549,17 @@ struct hash_control * handle;
*/
handle->hash_stat[STAT_USED] = 0; /* inserts will bump it up to correct */
for (oldtrack = oldwhere; oldtrack < oldwall; oldtrack++)
{
if (((string = oldtrack->hash_string) != NULL) && string != DELETED)
{
if ( * (retval = hash_jam(handle,string,oldtrack->hash_value) ) )
{
if ((retval = hash_jam (handle, string, oldtrack->hash_value)))
break;
}
}
}
#ifdef SUSPECT
if ( !*retval && handle->hash_stat[STAT_USED] != oldused)
if (!retval && handle->hash_stat[STAT_USED] != oldused)
{
retval = "hash_used";
}
#endif
if (!*retval)
if (!retval)
{
/*
* we have a completely faked up control block.
@ -589,7 +567,7 @@ struct hash_control * handle;
*/
free ((char *) oldwhere);
/*
* Here with success. retval is already "".
* Here with success. retval is already 0.
*/
}
}
@ -597,7 +575,7 @@ struct hash_control * handle;
{
retval = "no room";
}
return(retval);
return retval;
}
/*
@ -651,8 +629,8 @@ char *
struct hash_control *handle;
char *(*function) ();
{
register struct hash_entry * entry;
register struct hash_entry * wall;
struct hash_entry *entry;
struct hash_entry *wall;
wall = handle->hash_wall;
for (entry = handle->hash_where; entry < wall; entry++)
@ -671,24 +649,18 @@ char* (*function)();
* Given symbol string, find value (if any).
* Return found value or NULL.
*/
char *
hash_find(handle,string) /* return char* or NULL */
PTR
hash_find (handle, string)
struct hash_control *handle;
char * string;
const char *string;
{
register struct hash_entry * entry;
register char * retval;
struct hash_entry *entry;
entry = hash_ask (handle, string, STAT__READ);
if (hash_found)
{
retval = entry->hash_value;
}
return entry->hash_value;
else
{
retval = NULL;
}
return(retval);
return NULL;
}
/*
@ -703,23 +675,31 @@ char * string;
static struct hash_entry * /* string slot, may be empty or deleted */
hash_ask (handle, string, access)
struct hash_control *handle;
char * string;
const char *string;
int access; /* access type */
{
register char *string1; /* JF avoid strcmp calls */
register char * s;
register int c;
register struct hash_entry * slot;
register int collision; /* count collisions */
const char *string1; /* JF avoid strcmp calls */
const char *s;
int c;
struct hash_entry *slot;
int collision; /* count collisions */
/* start looking here */
slot = handle->hash_where + hash_code (handle, string);
slot = handle->hash_where + hash_code(handle,string); /* start looking here */
handle->hash_stat[STAT_ACCESS + access] += 1;
collision = 0;
hash_found = FALSE;
while (((s = slot->hash_string) != NULL) && s != DELETED)
{
for(string1=string;;) {
if((c= *s++) == 0) {
#if 1
if (string == s || !strcmp (string, s))
hash_found = TRUE;
#else
for (string1 = string;;)
{
if ((c = *s++) == 0)
{
if (!*string1)
hash_found = TRUE;
break;
@ -727,6 +707,7 @@ int access; /* access type */
if (*string1++ != c)
break;
}
#endif
if (hash_found)
break;
collision++;
@ -745,14 +726,21 @@ int access; /* access type */
slot = handle->hash_where;/* now look again */
while (((s = slot->hash_string) != NULL) && s != DELETED)
{
for(string1=string;*s;string1++,s++) {
#if 0
for (string1 = string; *s; string1++, s++)
{
if (*string1 != *s)
break;
}
if(*s==*string1) {
if (*s == *string1)
{
hash_found = TRUE;
break;
}
#else
if (string == s || !strcmp (string, s))
hash_found = TRUE;
#endif
collision++;
slot++;
}
@ -764,7 +752,6 @@ int access; /* access type */
* DELETED:dig here slot
*/
}
/* fprintf(stderr,"hash_ask(%s)->%d(%d)\n",string,hash_code(handle,string),collision); */
handle->hash_stat[STAT_COLLIDE + access] += collision;
return (slot); /* also return hash_found */
}
@ -778,11 +765,12 @@ int access; /* access type */
static int
hash_code (handle, string)
struct hash_control *handle;
register char * string;
const char *string;
{
register long h; /* hash code built here */
register long c; /* each character lands here */
register int n; /* Amount to shift h by */
#if 0
long h; /* hash code built here */
long c; /* each character lands here */
int n; /* Amount to shift h by */
n = (handle->hash_sizelog - 3);
h = 0;
@ -792,6 +780,21 @@ register char * string;
h = (h << 3) + (h >> n) + c;
}
return (h & handle->hash_mask);
#else
unsigned long h = 0;
unsigned int len = 0;
unsigned int c;
while ((c = *string++) != 0)
{
h += c + (c << 17);
h ^= h >> 2;
++len;
}
h += len + (len << 17);
h ^= h >> 2;
return h & handle->hash_mask;
#endif
}
/*
@ -820,11 +823,8 @@ int number; /* number 0:TABLES-1 of current hashed */
main ()
{
char (*applicatee ());
char * hash_find();
char *destroy ();
char *what ();
struct hash_control * hash_new();
char * hash_replace();
int *ip;
number = 0;
@ -835,7 +835,8 @@ main()
printf ("hash_test command: ");
gets (answer);
command = answer[0];
if (isupper(command)) command = tolower(command); /* ecch! */
if (isupper (command))
command = tolower (command); /* ecch! */
switch (command)
{
case '#':
@ -877,14 +878,15 @@ main()
break;
case 'i':
p = hash_insert (h, name = what ("symbol"), value = what ("value"));
if (*p)
if (p)
{
printf("symbol=\"%s\" value=\"%s\" error=%s\n",name,value,p);
printf ("symbol=\"%s\" value=\"%s\" error=%s\n", name, value,
p);
}
break;
case 'j':
p = hash_jam (h, name = what ("symbol"), value = what ("value"));
if (*p)
if (p)
{
printf ("symbol=\"%s\" value=\"%s\" error=%s\n", name, value, p);
}
@ -893,7 +895,7 @@ main()
h = hashtable[number] = (char *) hash_new ();
break;
case 'q':
exit();
exit (EXIT_SUCCESS);
case 'r':
p = hash_replace (h, name = what ("symbol"), value = what ("value"));
printf ("old value was \"%s\"\n", p ? p : "{}");