* config/i386/i386.md (fix_trunc<mode>_i387_fisttp_with_temp): Use 'X'

[pf3gnuchains/gcc-fork.git] / gcc / stringpool.c

diff --git a/gcc/stringpool.c b/gcc/stringpool.c
index 6390486..d2e1ad3 100644 (file)
--- a/gcc/stringpool.c
+++ b/gcc/stringpool.c
@@ -1,11 +1,12 @@
 /* String pool for GCC.
 /* String pool for GCC.

-   Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007
+   Free Software Foundation, Inc.

 
 This file is part of GCC.
 
 GCC 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
 
 This file is part of GCC.
 
 GCC 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, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later

 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY


@@ -14,24 +15,26 @@ 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
 for more details.
 
 You should have received a copy of the GNU General Public License

-along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */

 
 /* String text, identifier text and identifier node allocator.  Strings
    allocated by ggc_alloc_string are stored in an obstack which is
    never shrunk.  Identifiers are uniquely stored in a hash table.
 
 
 /* String text, identifier text and identifier node allocator.  Strings
    allocated by ggc_alloc_string are stored in an obstack which is
    never shrunk.  Identifiers are uniquely stored in a hash table.
 

-   We have our own private hash table implementation.  libiberty's
+   We use cpplib's hash table implementation.  libiberty's

    hashtab.c is not used because it requires 100% average space
    overhead per string, which is unacceptable.  Also, this algorithm
    is faster.  */
 
 #include "config.h"
 #include "system.h"
    hashtab.c is not used because it requires 100% average space
    overhead per string, which is unacceptable.  Also, this algorithm
    is faster.  */
 
 #include "config.h"
 #include "system.h"

+#include "coretypes.h"
+#include "tm.h"

 #include "ggc.h"
 #include "tree.h"
 #include "ggc.h"
 #include "tree.h"

-#include "hashtable.h"
+#include "symtab.h"
+#include "cpplib.h"

 
 /* The "" allocated string.  */
 const char empty_string[] = "";
 
 /* The "" allocated string.  */
 const char empty_string[] = "";


@@ -46,25 +49,29 @@ const char digit_vector[] = {
 struct ht *ident_hash;
 static struct obstack string_stack;
 
 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 void *
+stringpool_ggc_alloc (size_t x)
+{
+  return ggc_alloc (x);
+}

 
 /* Initialize the string pool.  */
 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;
 {
   /* Create with 16K (2^14) entries.  */
   ident_hash = ht_create (14);
   ident_hash->alloc_node = alloc_node;

+  ident_hash->alloc_subobject = stringpool_ggc_alloc;

   gcc_obstack_init (&string_stack);
   gcc_obstack_init (&string_stack);

-  ggc_add_root (&ident_hash, 1, sizeof ident_hash, mark_ident_hash);

 }
 
 /* Allocate a hash node.  */
 static hashnode
 }
 
 /* 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));
 }
 {
   return GCC_IDENT_TO_HT_IDENT (make_node (IDENTIFIER_NODE));
 }


@@ -76,9 +83,7 @@ alloc_node (table)
    returned this time too.  */
 
 const char *
    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);
 {
   if (length == -1)
     length = strlen (contents);


@@ -89,16 +94,17 @@ ggc_alloc_string (contents, length)
     return digit_string (contents[0] - '0');
 
   obstack_grow0 (&string_stack, contents, length);
     return digit_string (contents[0] - '0');
 
   obstack_grow0 (&string_stack, contents, length);

-  return obstack_finish (&string_stack);
+  return XOBFINISH (&string_stack, const char *);

 }
 
 /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
    If an identifier with that name has previously been referred to,
    the same node is returned this time.  */
 
 }
 
 /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
    If an identifier with that name has previously been referred to,
    the same node is returned this time.  */
 

+#undef get_identifier
+

 tree
 tree

-get_identifier (text)
-     const char *text;
+get_identifier (const char *text)

 {
   hashnode ht_node = ht_lookup (ident_hash,
                                (const unsigned char *) text,
 {
   hashnode ht_node = ht_lookup (ident_hash,
                                (const unsigned char *) text,


@@ -112,9 +118,7 @@ get_identifier (text)
    known.  */
 
 tree
    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,
 {
   hashnode ht_node = ht_lookup (ident_hash,
                                (const unsigned char *) text,


@@ -129,8 +133,7 @@ get_identifier_with_length (text, length)
    NULL_TREE.  */
 
 tree
    NULL_TREE.  */
 
 tree

-maybe_get_identifier (text)
-     const char *text;
+maybe_get_identifier (const char *text)

 {
   hashnode ht_node;
 
 {
   hashnode ht_node;
 


@@ -145,28 +148,106 @@ maybe_get_identifier (text)
 /* Report some basic statistics about the string pool.  */
 
 void
 /* Report some basic statistics about the string pool.  */
 
 void

-stringpool_statistics ()
+stringpool_statistics (void)

 {
   ht_dump_statistics (ident_hash);
 }
 {
   ht_dump_statistics (ident_hash);
 }

-
+\f

 /* Mark an identifier for GC.  */
 
 static int
 /* 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;
 }
 
   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);
 }
 {
   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,
+                     gt_types_enum_last);
+}
+\f
+/* Handle saving and restoring the string pool for PCH.  */
+
+/* SPD is saved in the PCH file and holds the information needed
+   to restore the string pool.  */
+
+struct string_pool_data GTY(())
+{
+  struct ht_identifier * * 
+    GTY((length ("%h.nslots"),
+        nested_ptr (union tree_node, "%h ? GCC_IDENT_TO_HT_IDENT (%h) : NULL",
+                    "%h ? HT_IDENT_TO_GCC_IDENT (%h) : NULL")))
+    entries;
+  unsigned int nslots;
+  unsigned int nelements;
+};
+
+static GTY(()) struct string_pool_data * spd;
+
+/* Save the stringpool data in SPD.  */
+
+void
+gt_pch_save_stringpool (void)
+{
+  spd = ggc_alloc (sizeof (*spd));
+  spd->nslots = ident_hash->nslots;
+  spd->nelements = ident_hash->nelements;
+  spd->entries = ggc_alloc (sizeof (spd->entries[0]) * spd->nslots);
+  memcpy (spd->entries, ident_hash->entries,
+         spd->nslots * sizeof (spd->entries[0]));
+}
+
+/* Return the stringpool to its state before gt_pch_save_stringpool
+   was called.  */
+
+void
+gt_pch_fixup_stringpool (void)
+{
+}
+
+/* A PCH file has been restored, which loaded SPD; fill the real hash table
+   from SPD.  */
+
+void
+gt_pch_restore_stringpool (void)
+{
+  ht_load (ident_hash, spd->entries, spd->nslots, spd->nelements, false);
+  spd = NULL;
+}
+
+#include "gt-stringpool.h"