X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fstringpool.c;h=79f8cb2c8d1a748e76b852e5f8031dec4ba63bc8;hb=e3cce89adacbdf7b200895b04d7a733fbb7e79e9;hp=1edb46f66a6086bfd44858f96ea10b5f58b9ccaa;hpb=573aba856d39e5b11d72261a6ccb6004dcb923cd;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/stringpool.c b/gcc/stringpool.c index 1edb46f66a6..79f8cb2c8d1 100644 --- a/gcc/stringpool.c +++ b/gcc/stringpool.c @@ -1,11 +1,12 @@ /* String pool for GCC. - Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc. + Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008 + 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 -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 @@ -14,15 +15,13 @@ 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 -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 +. */ -/* 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. + 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. */ @@ -33,7 +32,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "tm.h" #include "ggc.h" #include "tree.h" -#include "hashtable.h" +#include "symtab.h" +#include "cpplib.h" /* The "" allocated string. */ const char empty_string[] = ""; @@ -46,40 +46,42 @@ 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 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 -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); + ident_hash->alloc_subobject = stringpool_ggc_alloc; } /* 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)); } /* Allocate and return a string constant of length LENGTH, containing CONTENTS. If LENGTH is -1, CONTENTS is assumed to be a - nul-terminated string, and the length is calculated using strlen. - If the same string constant has been allocated before, that copy is - returned this time too. */ + nul-terminated string, and the length is calculated using strlen. */ const char * -ggc_alloc_string (contents, length) - const char *contents; - int length; +ggc_alloc_string (const char *contents, int length) { + char *result; + if (length == -1) length = strlen (contents); @@ -88,17 +90,20 @@ ggc_alloc_string (contents, length) if (length == 1 && ISDIGIT (contents[0])) return digit_string (contents[0] - '0'); - obstack_grow0 (&string_stack, contents, length); - return obstack_finish (&string_stack); + result = GGC_NEWVAR (char, length + 1); + memcpy (result, contents, length); + result[length] = '\0'; + return (const char *) result; } /* 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 -get_identifier (text) - const char *text; +get_identifier (const char *text) { hashnode ht_node = ht_lookup (ident_hash, (const unsigned char *) text, @@ -112,9 +117,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 +132,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,106 +147,113 @@ maybe_get_identifier (text) /* Report some basic statistics about the string pool. */ void -stringpool_statistics () +stringpool_statistics (void) { ht_dump_statistics (ident_hash); } - + /* 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) { gt_ggc_m_9tree_node (HT_IDENT_TO_GCC_IDENT (h)); return 1; } +/* Return true if an identifier should be removed from the table. */ + +static int +maybe_delete_ident (struct cpp_reader *pfile ATTRIBUTE_UNUSED, hashnode h, + const void *v ATTRIBUTE_UNUSED) +{ + return !ggc_marked_p (HT_IDENT_TO_GCC_IDENT (h)); +} + /* Mark the trees hanging off the identifier node for GGC. These are - handled specially (not using gengtype) because of the special - treatment for strings. */ + handled specially (not using gengtype) because identifiers are only + roots during one part of compilation. */ void -ggc_mark_stringpool () +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. */ +/* Purge the identifier hash of identifiers which are no longer + referenced. */ void -gt_ggc_m_S (x) - void *x ATTRIBUTE_UNUSED; +ggc_purge_stringpool (void) { + ht_purge (ident_hash, maybe_delete_ident, NULL); } /* Pointer-walking routine for strings (not very interesting, since strings don't contain pointers). */ void -gt_pch_p_S (obj, x, op, cookie) - void *obj ATTRIBUTE_UNUSED; - void *x ATTRIBUTE_UNUSED; - gt_pointer_operator op ATTRIBUTE_UNUSED; - void *cookie ATTRIBUTE_UNUSED; +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 (x) - const void *x; +gt_pch_n_S (const void *x) { - gt_pch_note_object ((void *)x, (void *)x, >_pch_p_S); + gt_pch_note_object (CONST_CAST (void *, x), CONST_CAST (void *, x), + >_pch_p_S, gt_types_enum_last); } - + /* Handle saving and restoring the string pool for PCH. */ -struct string_pool_data GTY(()) -{ - tree * GTY((length ("%h.nslots"))) entries; +/* SPD is saved in the PCH file and holds the information needed + to restore the string pool. */ + +struct GTY(()) string_pool_data { + 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 () +gt_pch_save_stringpool (void) { - unsigned int i; - - spd = ggc_alloc (sizeof (*spd)); + spd = GGC_NEW (struct string_pool_data); 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; + spd->entries = GGC_NEWVEC (struct ht_identifier *, 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_restore_stringpool () -{ - 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; +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; }