Gcc 3.4.2 20040728.

1 files changed, 134 insertions, 28 deletions

diff --git a/contrib/gcc/stringpool.c b/contrib/gcc/stringpool.c
index 639048625d96..0cf3be14f880 100644
--- a/contrib/gcc/stringpool.c
+++ b/contrib/gcc/stringpool.c
@@ -1,5 +1,5 @@
 /* String pool for GCC.
-   Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -29,9 +29,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 #include "config.h"
 #include "system.h"
+#include "coretypes.h"
+#include "tm.h"
 #include "ggc.h"
 #include "tree.h"
 #include "hashtable.h"
+#include "cpplib.h"
 
 /* The "" allocated string.  */
 const char empty_string[] = "";
@@ -46,25 +49,23 @@ const char digit_vector[] = {
 struct ht *ident_hash;
 static struct obstack string_stack;
 
-static hashnode alloc_node PARAMS ((hash_table *));
-static int mark_ident PARAMS ((struct cpp_reader *, hashnode, const PTR));
-static void mark_ident_hash PARAMS ((void *));
+static hashnode alloc_node (hash_table *);
+static int mark_ident (struct cpp_reader *, hashnode, const void *);
+static int ht_copy_and_clear (struct cpp_reader *, hashnode, const void *);
 
 /* Initialize the string pool.  */
 void
-init_stringpool ()
+init_stringpool (void)
 {
   /* Create with 16K (2^14) entries.  */
   ident_hash = ht_create (14);
   ident_hash->alloc_node = alloc_node;
   gcc_obstack_init (&string_stack);
-  ggc_add_root (&ident_hash, 1, sizeof ident_hash, mark_ident_hash);
 }
 
 /* Allocate a hash node.  */
 static hashnode
-alloc_node (table)
-     hash_table *table ATTRIBUTE_UNUSED;
+alloc_node (hash_table *table ATTRIBUTE_UNUSED)
 {
   return GCC_IDENT_TO_HT_IDENT (make_node (IDENTIFIER_NODE));
 }
@@ -76,9 +77,7 @@ alloc_node (table)
    returned this time too.  */
 
 const char *
-ggc_alloc_string (contents, length)
-     const char *contents;
-     int length;
+ggc_alloc_string (const char *contents, int length)
 {
   if (length == -1)
     length = strlen (contents);
@@ -96,9 +95,10 @@ ggc_alloc_string (contents, length)
    If an identifier with that name has previously been referred to,
    the same node is returned this time.  */
 
+#undef get_identifier
+
 tree
-get_identifier (text)
-     const char *text;
+get_identifier (const char *text)
 {
   hashnode ht_node = ht_lookup (ident_hash,
 				(const unsigned char *) text,
@@ -112,9 +112,7 @@ get_identifier (text)
    known.  */
 
 tree
-get_identifier_with_length (text, length)
-     const char *text;
-     unsigned int length;
+get_identifier_with_length (const char *text, size_t length)
 {
   hashnode ht_node = ht_lookup (ident_hash,
 				(const unsigned char *) text,
@@ -129,8 +127,7 @@ get_identifier_with_length (text, length)
    NULL_TREE.  */
 
 tree
-maybe_get_identifier (text)
-     const char *text;
+maybe_get_identifier (const char *text)
 {
   hashnode ht_node;
 
@@ -145,7 +142,7 @@ maybe_get_identifier (text)
 /* Report some basic statistics about the string pool.  */
 
 void
-stringpool_statistics ()
+stringpool_statistics (void)
 {
   ht_dump_statistics (ident_hash);
 }
@@ -153,20 +150,129 @@ stringpool_statistics ()
 /* Mark an identifier for GC.  */
 
 static int
-mark_ident (pfile, h, v)
-     struct cpp_reader *pfile ATTRIBUTE_UNUSED;
-     hashnode h;
-     const PTR v ATTRIBUTE_UNUSED;
+mark_ident (struct cpp_reader *pfile ATTRIBUTE_UNUSED, hashnode h,
+	    const void *v ATTRIBUTE_UNUSED)
 {
-  ggc_mark_tree (HT_IDENT_TO_GCC_IDENT (h));
+  gt_ggc_m_9tree_node (HT_IDENT_TO_GCC_IDENT (h));
   return 1;
 }
 
-/* Mark all identifiers for GC.  */
+/* Mark the trees hanging off the identifier node for GGC.  These are
+   handled specially (not using gengtype) because of the special
+   treatment for strings.  */
 
-static void
-mark_ident_hash (arg)
-     PTR arg ATTRIBUTE_UNUSED;
+void
+ggc_mark_stringpool (void)
 {
   ht_forall (ident_hash, mark_ident, NULL);
 }
+
+/* Strings are _not_ GCed, but this routine exists so that a separate
+   roots table isn't needed for the few global variables that refer
+   to strings.  */
+
+void
+gt_ggc_m_S (void *x ATTRIBUTE_UNUSED)
+{
+}
+
+/* Pointer-walking routine for strings (not very interesting, since
+   strings don't contain pointers).  */
+
+void
+gt_pch_p_S (void *obj ATTRIBUTE_UNUSED, void *x ATTRIBUTE_UNUSED,
+	    gt_pointer_operator op ATTRIBUTE_UNUSED,
+	    void *cookie ATTRIBUTE_UNUSED)
+{
+}
+
+/* PCH pointer-walking routine for strings.  */
+
+void
+gt_pch_n_S (const void *x)
+{
+  gt_pch_note_object ((void *)x, (void *)x, &gt_pch_p_S);
+}
+
+/* Handle saving and restoring the string pool for PCH.  */
+
+struct string_pool_data GTY(())
+{
+  tree * GTY((length ("%h.nslots"))) entries;
+  unsigned int nslots;
+  unsigned int nelements;
+};
+
+static GTY(()) struct string_pool_data * spd;
+
+static int
+ht_copy_and_clear (cpp_reader *r ATTRIBUTE_UNUSED, hashnode hp, const void *ht2_p)
+{
+  cpp_hashnode *h = CPP_HASHNODE (hp);
+  struct ht *ht2 = (struct ht *) ht2_p;
+
+  if (h->type != NT_VOID
+      && (h->flags & NODE_BUILTIN) == 0)
+    {
+      cpp_hashnode *h2 = CPP_HASHNODE (ht_lookup (ht2,
+						  NODE_NAME (h),
+						  NODE_LEN (h),
+						  HT_ALLOC));
+      h2->type = h->type;
+      memcpy (&h2->value, &h->value, sizeof (h->value));
+
+      h->type = NT_VOID;
+      memset (&h->value, 0, sizeof (h->value));
+    }
+  return 1;
+}
+
+static struct ht *saved_ident_hash;
+
+void
+gt_pch_save_stringpool (void)
+{
+  unsigned int i;
+
+  spd = ggc_alloc (sizeof (*spd));
+  spd->nslots = ident_hash->nslots;
+  spd->nelements = ident_hash->nelements;
+  spd->entries = ggc_alloc (sizeof (tree *) * spd->nslots);
+  for (i = 0; i < spd->nslots; i++)
+    if (ident_hash->entries[i] != NULL)
+      spd->entries[i] = HT_IDENT_TO_GCC_IDENT (ident_hash->entries[i]);
+    else
+      spd->entries[i] = NULL;
+
+  saved_ident_hash = ht_create (14);
+  saved_ident_hash->alloc_node = alloc_node;
+  ht_forall (ident_hash, ht_copy_and_clear, saved_ident_hash);
+}
+
+void
+gt_pch_fixup_stringpool (void)
+{
+  ht_forall (saved_ident_hash, ht_copy_and_clear, ident_hash);
+  ht_destroy (saved_ident_hash);
+  saved_ident_hash = 0;
+}
+
+void
+gt_pch_restore_stringpool (void)
+{
+  unsigned int i;
+
+  ident_hash->nslots = spd->nslots;
+  ident_hash->nelements = spd->nelements;
+  ident_hash->entries = xrealloc (ident_hash->entries,
+				  sizeof (hashnode) * spd->nslots);
+  for (i = 0; i < spd->nslots; i++)
+    if (spd->entries[i] != NULL)
+      ident_hash->entries[i] = GCC_IDENT_TO_HT_IDENT (spd->entries[i]);
+    else
+      ident_hash->entries[i] = NULL;
+
+  spd = NULL;
+}
+
+#include "gt-stringpool.h"