X-Git-Url: http://drtracing.org/?a=blobdiff_plain;ds=sidebyside;f=gas%2Fhash.c;h=655ddfcc5264d6dfad5dd34b98319fafdbc7976a;hb=a6684f0dddb292873f962dc36b20e6db00ef6b09;hp=3ef582ddf623a44d7dfd8d51effca6f6ebd7911f;hpb=ec2655a6a75bc61d21e6f8ddc1e9f9027a8914dd;p=deliverable%2Fbinutils-gdb.git

diff --git a/gas/hash.c b/gas/hash.c
index 3ef582ddf6..655ddfcc52 100644
--- a/gas/hash.c
+++ b/gas/hash.c
@@ -1,7 +1,5 @@
 /* hash.c -- gas hash table code
-   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
-   2000, 2001, 2002, 2003, 2005, 2007
-   Free Software Foundation, Inc.
+   Copyright (C) 1987-2016 Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
 
@@ -44,7 +42,7 @@ struct hash_entry {
      table.  */
   unsigned long hash;
   /* Pointer being stored in the hash table.  */
-  PTR data;
+  void *data;
 };
 
 /* A hash table.  */
@@ -78,45 +76,21 @@ static unsigned long gas_hash_table_size = 65537;
 void
 set_gas_hash_table_size (unsigned long size)
 {
-  gas_hash_table_size = size;
-}
-
-/* FIXME: This function should be amalgmated with bfd/hash.c:bfd_hash_set_default_size().  */
-static unsigned long
-get_gas_hash_table_size (void)
-{
-  /* Extend this prime list if you want more granularity of hash table size.  */
-  static const unsigned long hash_size_primes[] =
-    {
-      1021, 4051, 8599, 16699, 65537
-    };
-  unsigned int index;
-
-  /* Work out the best prime number near the hash_size.
-     FIXME: This could be a more sophisticated algorithm,
-     but is it really worth implementing it ?   */
-  for (index = 0; index < ARRAY_SIZE (hash_size_primes) - 1; ++index)
-    if (gas_hash_table_size <= hash_size_primes[index])
-      break;
-
-  return hash_size_primes[index];
+  gas_hash_table_size = bfd_hash_set_default_size (size);
 }
 
 /* Create a hash table.  This return a control block.  */
 
 struct hash_control *
-hash_new (void)
+hash_new_sized (unsigned long size)
 {
-  unsigned long size;
   unsigned long alloc;
   struct hash_control *ret;
 
-  size = get_gas_hash_table_size ();
-
-  ret = xmalloc (sizeof *ret);
+  ret = XNEW (struct hash_control);
   obstack_begin (&ret->memory, chunksize);
   alloc = size * sizeof (struct hash_entry *);
-  ret->table = obstack_alloc (&ret->memory, alloc);
+  ret->table = (struct hash_entry **) obstack_alloc (&ret->memory, alloc);
   memset (ret->table, 0, alloc);
   ret->size = size;
 
@@ -132,6 +106,12 @@ hash_new (void)
   return ret;
 }
 
+struct hash_control *
+hash_new (void)
+{
+  return hash_new_sized (gas_hash_table_size);
+}
+
 /* Delete a hash table, freeing all allocated memory.  */
 
 void
@@ -157,7 +137,7 @@ hash_lookup (struct hash_control *table, const char *key, size_t len,
   unsigned long hash;
   size_t n;
   unsigned int c;
-  unsigned int index;
+  unsigned int hindex;
   struct hash_entry **list;
   struct hash_entry *p;
   struct hash_entry *prev;
@@ -179,8 +159,8 @@ hash_lookup (struct hash_control *table, const char *key, size_t len,
   if (phash != NULL)
     *phash = hash;
 
-  index = hash % table->size;
-  list = table->table + index;
+  hindex = hash % table->size;
+  list = table->table + hindex;
 
   if (plist != NULL)
     *plist = list;
@@ -223,7 +203,7 @@ hash_lookup (struct hash_control *table, const char *key, size_t len,
    hash table.  */
 
 const char *
-hash_insert (struct hash_control *table, const char *key, PTR value)
+hash_insert (struct hash_control *table, const char *key, void *val)
 {
   struct hash_entry *p;
   struct hash_entry **list;
@@ -240,7 +220,7 @@ hash_insert (struct hash_control *table, const char *key, PTR value)
   p = (struct hash_entry *) obstack_alloc (&table->memory, sizeof (*p));
   p->string = key;
   p->hash = hash;
-  p->data = value;
+  p->data = val;
 
   p->next = *list;
   *list = p;
@@ -253,7 +233,7 @@ hash_insert (struct hash_control *table, const char *key, PTR value)
    error.  If an entry already exists, its value is replaced.  */
 
 const char *
-hash_jam (struct hash_control *table, const char *key, PTR value)
+hash_jam (struct hash_control *table, const char *key, void *val)
 {
   struct hash_entry *p;
   struct hash_entry **list;
@@ -266,7 +246,7 @@ hash_jam (struct hash_control *table, const char *key, PTR value)
       ++table->replacements;
 #endif
 
-      p->data = value;
+      p->data = val;
     }
   else
     {
@@ -277,7 +257,7 @@ hash_jam (struct hash_control *table, const char *key, PTR value)
       p = (struct hash_entry *) obstack_alloc (&table->memory, sizeof (*p));
       p->string = key;
       p->hash = hash;
-      p->data = value;
+      p->data = val;
 
       p->next = *list;
       *list = p;
@@ -290,11 +270,11 @@ hash_jam (struct hash_control *table, const char *key, PTR value)
    value stored for the entry.  If the entry is not found in the hash
    table, this does nothing and returns NULL.  */
 
-PTR
-hash_replace (struct hash_control *table, const char *key, PTR value)
+void *
+hash_replace (struct hash_control *table, const char *key, void *value)
 {
   struct hash_entry *p;
-  PTR ret;
+  void *ret;
 
   p = hash_lookup (table, key, strlen (key), NULL, NULL);
   if (p == NULL)
@@ -314,7 +294,7 @@ hash_replace (struct hash_control *table, const char *key, PTR value)
 /* Find an entry in a hash table, returning its value.  Returns NULL
    if the entry is not found.  */
 
-PTR
+void *
 hash_find (struct hash_control *table, const char *key)
 {
   struct hash_entry *p;
@@ -329,7 +309,7 @@ hash_find (struct hash_control *table, const char *key)
 /* As hash_find, but KEY is of length LEN and is not guaranteed to be
    NUL-terminated.  */
 
-PTR
+void *
 hash_find_n (struct hash_control *table, const char *key, size_t len)
 {
   struct hash_entry *p;
@@ -344,8 +324,8 @@ hash_find_n (struct hash_control *table, const char *key, size_t len)
 /* Delete an entry from a hash table.  This returns the value stored
    for that entry, or NULL if there is no such entry.  */
 
-PTR
-hash_delete (struct hash_control *table, const char *key)
+void *
+hash_delete (struct hash_control *table, const char *key, int freeme)
 {
   struct hash_entry *p;
   struct hash_entry **list;
@@ -363,9 +343,8 @@ hash_delete (struct hash_control *table, const char *key)
 
   *list = p->next;
 
-  /* Note that we never reclaim the memory for this entry.  If gas
-     ever starts deleting hash table entries in a big way, this will
-     have to change.  */
+  if (freeme)
+    obstack_free (&table->memory, p);
 
   return p->data;
 }
@@ -375,7 +354,7 @@ hash_delete (struct hash_control *table, const char *key)
 
 void
 hash_traverse (struct hash_control *table,
-	       void (*pfn) (const char *key, PTR value))
+	       void (*pfn) (const char *key, void *value))
 {
   unsigned int i;