1 /* String pool for GCC.
2 Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 2, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 /* String text, identifier text and identifier node allocator. Strings
22 allocated by ggc_alloc_string are stored in an obstack which is
23 never shrunk. Identifiers are uniquely stored in a hash table.
25 We have our own private hash table implementation. libiberty's
26 hashtab.c is not used because it requires 100% average space
27 overhead per string, which is unacceptable. Also, this algorithm
32 #include "coretypes.h"
36 #include "hashtable.h"
39 /* The "" allocated string. */
40 const char empty_string[] = "";
42 /* Character strings, each containing a single decimal digit.
43 Written this way to save space. */
44 const char digit_vector[] = {
45 '0', 0, '1', 0, '2', 0, '3', 0, '4', 0,
46 '5', 0, '6', 0, '7', 0, '8', 0, '9', 0
49 struct ht *ident_hash;
50 static struct obstack string_stack;
52 static hashnode alloc_node PARAMS ((hash_table *));
53 static int mark_ident PARAMS ((struct cpp_reader *, hashnode, const PTR));
54 static int ht_copy_and_clear PARAMS ((struct cpp_reader *, hashnode, const void *));
56 /* Initialize the string pool. */
60 /* Create with 16K (2^14) entries. */
61 ident_hash = ht_create (14);
62 ident_hash->alloc_node = alloc_node;
63 gcc_obstack_init (&string_stack);
66 /* Allocate a hash node. */
69 hash_table *table ATTRIBUTE_UNUSED;
71 return GCC_IDENT_TO_HT_IDENT (make_node (IDENTIFIER_NODE));
74 /* Allocate and return a string constant of length LENGTH, containing
75 CONTENTS. If LENGTH is -1, CONTENTS is assumed to be a
76 nul-terminated string, and the length is calculated using strlen.
77 If the same string constant has been allocated before, that copy is
78 returned this time too. */
81 ggc_alloc_string (contents, length)
86 length = strlen (contents);
90 if (length == 1 && ISDIGIT (contents[0]))
91 return digit_string (contents[0] - '0');
93 obstack_grow0 (&string_stack, contents, length);
94 return obstack_finish (&string_stack);
97 /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
98 If an identifier with that name has previously been referred to,
99 the same node is returned this time. */
102 get_identifier (text)
105 hashnode ht_node = ht_lookup (ident_hash,
106 (const unsigned char *) text,
107 strlen (text), HT_ALLOC);
109 /* ht_node can't be NULL here. */
110 return HT_IDENT_TO_GCC_IDENT (ht_node);
113 /* Identical to get_identifier, except that the length is assumed
117 get_identifier_with_length (text, length)
121 hashnode ht_node = ht_lookup (ident_hash,
122 (const unsigned char *) text,
125 /* ht_node can't be NULL here. */
126 return HT_IDENT_TO_GCC_IDENT (ht_node);
129 /* If an identifier with the name TEXT (a null-terminated string) has
130 previously been referred to, return that node; otherwise return
134 maybe_get_identifier (text)
139 ht_node = ht_lookup (ident_hash, (const unsigned char *) text,
140 strlen (text), HT_NO_INSERT);
142 return HT_IDENT_TO_GCC_IDENT (ht_node);
147 /* Report some basic statistics about the string pool. */
150 stringpool_statistics ()
152 ht_dump_statistics (ident_hash);
155 /* Mark an identifier for GC. */
158 mark_ident (pfile, h, v)
159 struct cpp_reader *pfile ATTRIBUTE_UNUSED;
161 const PTR v ATTRIBUTE_UNUSED;
163 gt_ggc_m_9tree_node (HT_IDENT_TO_GCC_IDENT (h));
167 /* Mark the trees hanging off the identifier node for GGC. These are
168 handled specially (not using gengtype) because of the special
169 treatment for strings. */
172 ggc_mark_stringpool ()
174 ht_forall (ident_hash, mark_ident, NULL);
177 /* Strings are _not_ GCed, but this routine exists so that a separate
178 roots table isn't needed for the few global variables that refer
183 void *x ATTRIBUTE_UNUSED;
187 /* Pointer-walking routine for strings (not very interesting, since
188 strings don't contain pointers). */
191 gt_pch_p_S (obj, x, op, cookie)
192 void *obj ATTRIBUTE_UNUSED;
193 void *x ATTRIBUTE_UNUSED;
194 gt_pointer_operator op ATTRIBUTE_UNUSED;
195 void *cookie ATTRIBUTE_UNUSED;
199 /* PCH pointer-walking routine for strings. */
205 gt_pch_note_object ((void *)x, (void *)x, >_pch_p_S);
208 /* Handle saving and restoring the string pool for PCH. */
210 struct string_pool_data GTY(())
212 tree * GTY((length ("%h.nslots"))) entries;
214 unsigned int nelements;
217 static GTY(()) struct string_pool_data * spd;
220 ht_copy_and_clear (r, hp, ht2_p)
221 cpp_reader *r ATTRIBUTE_UNUSED;
225 cpp_hashnode *h = CPP_HASHNODE (hp);
226 struct ht *ht2 = (struct ht *) ht2_p;
228 if (h->type != NT_VOID
229 && (h->flags & NODE_BUILTIN) == 0)
231 cpp_hashnode *h2 = CPP_HASHNODE (ht_lookup (ht2,
236 memcpy (&h2->value, &h->value, sizeof (h->value));
239 memset (&h->value, 0, sizeof (h->value));
244 static struct ht *saved_ident_hash;
247 gt_pch_save_stringpool ()
251 spd = ggc_alloc (sizeof (*spd));
252 spd->nslots = ident_hash->nslots;
253 spd->nelements = ident_hash->nelements;
254 spd->entries = ggc_alloc (sizeof (tree *) * spd->nslots);
255 for (i = 0; i < spd->nslots; i++)
256 if (ident_hash->entries[i] != NULL)
257 spd->entries[i] = HT_IDENT_TO_GCC_IDENT (ident_hash->entries[i]);
259 spd->entries[i] = NULL;
261 saved_ident_hash = ht_create (14);
262 saved_ident_hash->alloc_node = alloc_node;
263 ht_forall (ident_hash, ht_copy_and_clear, saved_ident_hash);
267 gt_pch_fixup_stringpool ()
269 ht_forall (saved_ident_hash, ht_copy_and_clear, ident_hash);
270 ht_destroy (saved_ident_hash);
271 saved_ident_hash = 0;
275 gt_pch_restore_stringpool ()
279 ident_hash->nslots = spd->nslots;
280 ident_hash->nelements = spd->nelements;
281 ident_hash->entries = xrealloc (ident_hash->entries,
282 sizeof (hashnode) * spd->nslots);
283 for (i = 0; i < spd->nslots; i++)
284 if (spd->entries[i] != NULL)
285 ident_hash->entries[i] = GCC_IDENT_TO_HT_IDENT (spd->entries[i]);
287 ident_hash->entries[i] = NULL;
292 #include "gt-stringpool.h"