Merge from pch-branch up to tag pch-commit-20020603.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@54232 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 82 insertions, 109 deletions

diff --git a/gcc/tlink.c b/gcc/tlink.c
index fe06eba0f9b..b2111dcf4d5 100644
--- a/gcc/tlink.c
+++ b/gcc/tlink.c
@@ -24,7 +24,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "config.h"
 #include "system.h"
 #include "intl.h"
-#include "hash.h"
+#include "obstack.h"
+#include "hashtab.h"
 #include "demangle.h"
 #include "collect2.h"
 
@@ -39,12 +40,12 @@ extern int prepends_underscore;
 
 static int tlink_verbose;
 
-/* Hash table boilerplate for working with hash.[ch].  We have hash tables
+/* Hash table boilerplate for working with htab_t.  We have hash tables
    for symbol names, file names, and demangled symbols.  */
 
 typedef struct symbol_hash_entry
 {
-  struct hash_entry root;
+  const char *key;
   struct file_hash_entry *file;
   int chosen;
   int tweaking;
@@ -53,7 +54,7 @@ typedef struct symbol_hash_entry
 
 typedef struct file_hash_entry
 {
-  struct hash_entry root;
+  const char *key;
   const char *args;
   const char *dir;
   const char *main;
@@ -62,24 +63,38 @@ typedef struct file_hash_entry
 
 typedef struct demangled_hash_entry
 {
-  struct hash_entry root;
+  const char *key;
   const char *mangled;
 } demangled;
 
-static struct hash_table symbol_table;
+/* Hash and comparison functions for these hash tables.  */
+
+static int hash_string_eq PARAMS ((const void *, const void *));
+static hashval_t hash_string_hash PARAMS ((const void *));
+
+static int
+hash_string_eq (s1_p, s2_p)
+     const void *s1_p;
+     const void *s2_p;
+{
+  const char *const *s1 = (const char *const *)s1_p;
+  const char *s2 = (const char *)s2_p;
+  return strcmp (*s1, s2) == 0;
+}
+
+static hashval_t
+hash_string_hash (s_p)
+     const void *s_p;
+{
+  const char *const *s = (const char *const *)s_p;
+  return (*htab_hash_string) (*s);
+}
+
+static htab_t symbol_table;
 
-static struct hash_entry * symbol_hash_newfunc PARAMS ((struct hash_entry *,
-							struct hash_table *,
-							hash_table_key));
 static struct symbol_hash_entry * symbol_hash_lookup PARAMS ((const char *,
 							      int));
-static struct hash_entry * file_hash_newfunc PARAMS ((struct hash_entry *,
-						      struct hash_table *,
-						      hash_table_key));
 static struct file_hash_entry * file_hash_lookup PARAMS ((const char *));
-static struct hash_entry * demangled_hash_newfunc PARAMS ((struct hash_entry *,
-							   struct hash_table *,
-							   hash_table_key));
 static struct demangled_hash_entry *
   demangled_hash_lookup PARAMS ((const char *, int));
 static void symbol_push PARAMS ((symbol *));
@@ -100,30 +115,6 @@ static int read_repo_files PARAMS ((char **));
 static void demangle_new_symbols PARAMS ((void));
 static int scan_linker_output PARAMS ((const char *));
 
-/* Create a new entry for the symbol hash table.
-   Passed to hash_table_init.  */
-
-static struct hash_entry *
-symbol_hash_newfunc (entry, table, string)
-     struct hash_entry *entry;
-     struct hash_table *table;
-     hash_table_key string ATTRIBUTE_UNUSED;
-{
-  struct symbol_hash_entry *ret = (struct symbol_hash_entry *) entry;
-  if (ret == NULL)
-    {
-      ret = ((struct symbol_hash_entry *)
-	     hash_allocate (table, sizeof (struct symbol_hash_entry)));
-      if (ret == NULL)
-	return NULL;
-    }
-  ret->file = NULL;
-  ret->chosen = 0;
-  ret->tweaking = 0;
-  ret->tweaked = 0;
-  return (struct hash_entry *) ret;
-}
-
 /* Look up an entry in the symbol hash table.  */
 
 static struct symbol_hash_entry *
@@ -131,71 +122,44 @@ symbol_hash_lookup (string, create)
      const char *string;
      int create;
 {
-  return ((struct symbol_hash_entry *)
-	  hash_lookup (&symbol_table, (const hash_table_key) string,
-		       create, string_copy));
-}
-
-static struct hash_table file_table;
-
-/* Create a new entry for the file hash table.
-   Passed to hash_table_init.  */
-
-static struct hash_entry *
-file_hash_newfunc (entry, table, string)
-     struct hash_entry *entry;
-     struct hash_table *table;
-     hash_table_key string ATTRIBUTE_UNUSED;
-{
-   struct file_hash_entry *ret = (struct file_hash_entry *) entry;
-  if (ret == NULL)
+  PTR *e;
+  e = htab_find_slot_with_hash (symbol_table, string,
+				(*htab_hash_string)(string),
+				create ? INSERT : NO_INSERT);
+  if (e == NULL)
+    return NULL;
+  if (*e == NULL)
     {
-      ret = ((struct file_hash_entry *)
-	     hash_allocate (table, sizeof (struct file_hash_entry)));
-      if (ret == NULL)
-	return NULL;
+      struct symbol_hash_entry *v;
+      *e = v = xcalloc (1, sizeof (*v));
+      v->key = xstrdup (string);
     }
-  ret->args = NULL;
-  ret->dir = NULL;
-  ret->main = NULL;
-  ret->tweaking = 0;
-  return (struct hash_entry *) ret;
+  return *e;
 }
 
+static htab_t file_table;
+
 /* Look up an entry in the file hash table.  */
 
 static struct file_hash_entry *
 file_hash_lookup (string)
      const char *string;
 {
-  return ((struct file_hash_entry *)
-	  hash_lookup (&file_table, (const hash_table_key) string, true,
-		       string_copy));
-}
-
-static struct hash_table demangled_table;
-
-/* Create a new entry for the demangled name hash table.
-   Passed to hash_table_init.  */
-
-static struct hash_entry *
-demangled_hash_newfunc (entry, table, string)
-     struct hash_entry *entry;
-     struct hash_table *table;
-     hash_table_key string ATTRIBUTE_UNUSED;
-{
-  struct demangled_hash_entry *ret = (struct demangled_hash_entry *) entry;
-  if (ret == NULL)
+  PTR *e;
+  e = htab_find_slot_with_hash (file_table, string,
+				(*htab_hash_string)(string),
+				INSERT);
+  if (*e == NULL)
     {
-      ret = ((struct demangled_hash_entry *)
-	     hash_allocate (table, sizeof (struct demangled_hash_entry)));
-      if (ret == NULL)
-	return NULL;
+      struct file_hash_entry *v;
+      *e = v = xcalloc (1, sizeof (*v));
+      v->key = xstrdup (string);
     }
-  ret->mangled = NULL;
-  return (struct hash_entry *) ret;
+  return *e;
 }
 
+static htab_t demangled_table;
+
 /* Look up an entry in the demangled name hash table.  */
 
 static struct demangled_hash_entry *
@@ -203,9 +167,19 @@ demangled_hash_lookup (string, create)
      const char *string;
      int create;
 {
-  return ((struct demangled_hash_entry *)
-	  hash_lookup (&demangled_table, (const hash_table_key) string,
-		       create, string_copy));
+  PTR *e;
+  e = htab_find_slot_with_hash (demangled_table, string,
+				(*htab_hash_string)(string),
+				create ? INSERT : NO_INSERT);
+  if (e == NULL)
+    return NULL;
+  if (*e == NULL)
+    {
+      struct demangled_hash_entry *v;
+      *e = v = xcalloc (1, sizeof (*v));
+      v->key = xstrdup (string);
+    }
+  return *e;
 }
 
 /* Stack code.  */
@@ -290,12 +264,13 @@ tlink_init ()
 {
   const char *p;
 
-  hash_table_init (&symbol_table, symbol_hash_newfunc, string_hash,
-		   string_compare);
-  hash_table_init (&file_table, file_hash_newfunc, string_hash,
-		   string_compare);
-  hash_table_init (&demangled_table, demangled_hash_newfunc,
-		   string_hash, string_compare);
+  symbol_table = htab_create (500, hash_string_hash, hash_string_eq,
+			      NULL);
+  file_table = htab_create (500, hash_string_hash, hash_string_eq,
+			    NULL);
+  demangled_table = htab_create (500, hash_string_hash, hash_string_eq,
+				 NULL);
+  
   obstack_begin (&symbol_stack_obstack, 0);
   obstack_begin (&file_stack_obstack, 0);
 
@@ -422,11 +397,10 @@ read_repo_file (f)
      file *f;
 {
   char c;
-  FILE *stream = fopen ((char*) f->root.key, "r");
+  FILE *stream = fopen (f->key, "r");
 
   if (tlink_verbose >= 2)
-    fprintf (stderr, _("collect: reading %s\n"),
-	     (char*) f->root.key);
+    fprintf (stderr, _("collect: reading %s\n"), f->key);
 
   while (fscanf (stream, "%c ", &c) == 1)
     {
@@ -501,8 +475,8 @@ recompile_files ()
   while ((f = file_pop ()) != NULL)
     {
       char *line, *command;
-      FILE *stream = fopen ((char*) f->root.key, "r");
-      const char *const outname = frob_extension ((char*) f->root.key, ".rnw");
+      FILE *stream = fopen (f->key, "r");
+      const char *const outname = frob_extension (f->key, ".rnw");
       FILE *output = fopen (outname, "w");
 
       while ((line = tfgets (stream)) != NULL)
@@ -517,7 +491,7 @@ recompile_files ()
 	}
       fclose (stream);
       fclose (output);
-      rename (outname, (char*) f->root.key);
+      rename (outname, f->key);
 
       obstack_grow (&temporary_obstack, "cd ", 3);
       obstack_grow (&temporary_obstack, f->dir, strlen (f->dir));
@@ -587,14 +561,13 @@ demangle_new_symbols ()
   while ((sym = symbol_pop ()) != NULL)
     {
       demangled *dem;
-      const char *p = cplus_demangle ((char*) sym->root.key,
-				      DMGL_PARAMS | DMGL_ANSI);
+      const char *p = cplus_demangle (sym->key, DMGL_PARAMS | DMGL_ANSI);
 
       if (! p)
 	continue;
 
       dem = demangled_hash_lookup (p, true);
-      dem->mangled = (char*) sym->root.key;
+      dem->mangled = sym->key;
     }
 }
 
@@ -696,7 +669,7 @@ scan_linker_output (fname)
 	{
 	  if (tlink_verbose >= 2)
 	    fprintf (stderr, _("collect: tweaking %s in %s\n"),
-		     (char*) sym->root.key, (char*) sym->file->root.key);
+		     sym->key, sym->file->key);
 	  sym->tweaking = 1;
 	  file_push (sym->file);
 	}