/* String pool for GCC.
- Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007
- Free Software Foundation, Inc.
+ Copyright (C) 2000-2015 Free Software Foundation, Inc.
This file is part of GCC.
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.
+ Identifiers are uniquely stored in a hash table.
We use cpplib's hash table implementation. libiberty's
hashtab.c is not used because it requires 100% average space
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tm.h"
-#include "ggc.h"
-#include "tree.h"
+#include "ggc-internal.h"
+#include "alias.h"
#include "symtab.h"
+#include "options.h"
+#include "tree.h"
#include "cpplib.h"
/* The "" allocated string. */
/* Character strings, each containing a single decimal digit.
Written this way to save space. */
-const char digit_vector[] = {
+static const char digit_vector[] = {
'0', 0, '1', 0, '2', 0, '3', 0, '4', 0,
'5', 0, '6', 0, '7', 0, '8', 0, '9', 0
};
+#define digit_string(d) (digit_vector + ((d) * 2))
+
struct ht *ident_hash;
-static struct obstack string_stack;
-static hashnode alloc_node (hash_table *);
+static hashnode alloc_node (cpp_hash_table *);
static int mark_ident (struct cpp_reader *, hashnode, const void *);
static void *
stringpool_ggc_alloc (size_t x)
{
- return ggc_alloc (x);
+ return ggc_alloc_atomic (x);
}
/* Initialize the string pool. */
void
init_stringpool (void)
{
+ /* Clean up if we're called more than once.
+ (We can't make this idempotent since identifiers contain state) */
+ if (ident_hash)
+ ht_destroy (ident_hash);
+
/* 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);
}
/* Allocate a hash node. */
static hashnode
-alloc_node (hash_table *table ATTRIBUTE_UNUSED)
+alloc_node (cpp_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 (const char *contents, int length)
+ggc_alloc_string (const char *contents, int length MEM_STAT_DECL)
{
+ char *result;
+
if (length == -1)
length = strlen (contents);
if (length == 1 && ISDIGIT (contents[0]))
return digit_string (contents[0] - '0');
- obstack_grow0 (&string_stack, contents, length);
- return XOBFINISH (&string_stack, const char *);
+ result = (char *) ggc_internal_cleared_alloc (length + 1 PASS_MEM_STAT);
+ memcpy (result, contents, length);
+ result[length] = '\0';
+ return (const char *) result;
}
/* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
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 (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 (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
void
gt_pch_n_S (const void *x)
{
- gt_pch_note_object ((void *)x, (void *)x, >_pch_p_S,
- gt_types_enum_last);
+ gt_pch_note_object (CONST_CAST (void *, x), CONST_CAST (void *, x),
+ >_pch_p_S);
+}
+
+
+/* User-callable entry point for marking string X. */
+
+void
+gt_pch_nx (const char *& x)
+{
+ gt_pch_n_S (x);
+}
+
+void
+gt_pch_nx (unsigned char *& x)
+{
+ gt_pch_n_S (x);
+}
+
+void
+gt_pch_nx (unsigned char& x ATTRIBUTE_UNUSED)
+{
+}
+
+void
+gt_pch_nx (unsigned char *x, gt_pointer_operator op, void *cookie)
+{
+ op (x, cookie);
}
\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 * *
+struct GTY(()) string_pool_data {
+ ht_identifier_ptr *
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")))
void
gt_pch_save_stringpool (void)
{
- spd = ggc_alloc (sizeof (*spd));
+ spd = ggc_alloc<string_pool_data> ();
spd->nslots = ident_hash->nslots;
spd->nelements = ident_hash->nelements;
- spd->entries = ggc_alloc (sizeof (spd->entries[0]) * spd->nslots);
+ spd->entries = ggc_vec_alloc<ht_identifier_ptr> (spd->nslots);
memcpy (spd->entries, ident_hash->entries,
spd->nslots * sizeof (spd->entries[0]));
}