IA MCU psABI support: changes to libraries

[gcc.git] / gcc / stringpool.c

diff --git a/gcc/stringpool.c b/gcc/stringpool.c
index cc2dd35368db81cba8b9e68d434bdeb0a8405b84..393834afcd5b998bcf447546802426aadd59bc9c 100644 (file)
--- a/gcc/stringpool.c
+++ b/gcc/stringpool.c
@@ -1,6 +1,5 @@
 /* String pool for GCC.
-   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
-   Free Software Foundation, Inc.
+   Copyright (C) 2000-2015 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -18,9 +17,8 @@ You should have received a copy of the GNU General Public License
 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
@@ -30,10 +28,11 @@ along with GCC; see the file COPYING3.  If not see
 #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.  */
@@ -41,26 +40,33 @@ const char empty_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 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;
@@ -69,19 +75,17 @@ init_stringpool (void)
 
 /* 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;
 
@@ -93,8 +97,9 @@ ggc_alloc_string (const char *contents, int length)
   if (length == 1 && ISDIGIT (contents[0]))
     return digit_string (contents[0] - '0');
 
-  result = ggc_alloc (length + 1);
-  memcpy (result, contents, length + 1);
+  result = (char *) ggc_internal_cleared_alloc (length + 1 PASS_MEM_STAT);
+  memcpy (result, contents, length);
+  result[length] = '\0';
   return (const char *) result;
 }
 
@@ -207,8 +212,34 @@ gt_pch_p_S (void *obj ATTRIBUTE_UNUSED, void *x ATTRIBUTE_UNUSED,
 void
 gt_pch_n_S (const void *x)
 {
-  gt_pch_note_object ((void *)x, (void *)x, &gt_pch_p_S,
-                     gt_types_enum_last);
+  gt_pch_note_object (CONST_CAST (void *, x), CONST_CAST (void *, x),
+                     &gt_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.  */
@@ -216,9 +247,8 @@ gt_pch_n_S (const void *x)
 /* 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")))
@@ -234,10 +264,10 @@ static GTY(()) struct string_pool_data * spd;
 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]));
 }