Serialize decl_lang_specific properly. Trickier than one would think.

git-svn-id: https://gcc.gnu.org/svn/gcc/branches/tree-serialize-branch@45660 138bc75d-0d04-0410-961f-82ee72b054a4

5 files changed, 65 insertions, 20 deletions

diff --git a/gcc/c-decl.c b/gcc/c-decl.c
index 6abeda84429..1fea7b93a51 100644
--- a/gcc/c-decl.c
+++ b/gcc/c-decl.c
@@ -6960,6 +6960,50 @@ copy_lang_decl (decl)
   DECL_LANG_SPECIFIC (decl) = ld;
 }
 void
+lang_unpickle_tree (t, oldt)
+	tree t;
+	tree oldt;
+{
+  if (TREE_CODE (t) == IDENTIFIER_NODE)
+    {
+      struct lang_identifier *i = (struct lang_identifier *) t;
+      i->global_value = (tree)write_tree (&i->global_value);
+      i->local_value = (tree) write_tree (&i->local_value);
+      i->label_value = (tree) write_tree (&i->label_value);
+      i->implicit_decl = (tree) write_tree (&i->implicit_decl);
+      i->error_locus = (tree) write_tree (&i->error_locus);
+      i->limbo_value = (tree) write_tree (&i->limbo_value);
+    }
+  else if (TYPE_P (t) && TYPE_LANG_SPECIFIC (t))
+    {
+     struct lang_type *lt;
+     int id;
+     if (ggc_set_mark (TYPE_LANG_SPECIFIC (t)))
+       {
+	 lt = (struct lang_type *) xmalloc (sizeof (struct lang_type));
+	 memcpy (lt, TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type));
+	 id = current_id++;
+	 store_to_db (&id, sizeof (int), lt, sizeof (struct lang_type));
+	 free (lt);
+	 TYPE_LANG_SPECIFIC (t) = (struct lang_type *)id;
+       }
+
+    }
+  else if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
+    {
+      struct lang_decl *ld;
+      int id;
+      ld = (struct lang_decl *) xmalloc (sizeof (struct lang_decl));
+      memcpy (ld, DECL_LANG_SPECIFIC (t), sizeof (struct lang_decl));
+      id = current_id++;
+      ld->base.saved_tree = (tree) write_tree (&ld->base.saved_tree); 
+      ld->pending_sizes = (tree) write_tree (&ld->pending_sizes);
+      store_to_db (&id, sizeof (int), ld, sizeof (struct lang_decl));
+      free (ld);
+      DECL_LANG_SPECIFIC (t) = (struct lang_decl *)id;
+    }
+}
+void
 lang_pickle_tree (t, oldt)
 	tree t;
 	tree oldt;
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 67fc9b3e9d3..c5a8a65946d 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -1963,14 +1963,14 @@ pickle_lang_function (t, p)
     return 0;
   if (ggc_set_mark (p))
     {
-      result = splay_tree_lookup (written_trees, (splay_tree_key)p);
+      result = splay_tree_lookup (written_pointers, (splay_tree_key)p);
       if (result)
 	return result->value;
     }
   id = current_id++;
   new = (struct cp_language_function *)xmalloc (sizeof (struct cp_language_function));
   memcpy (new, p, sizeof (struct cp_language_function));
-  splay_tree_insert (written_trees, (splay_tree_key) p, id);
+  splay_tree_insert (written_pointers, (splay_tree_key) p, id);
   pickle_c_language_function (&new->base);
   new->x_ctor_label = (tree) write_tree (&new->x_ctor_label);
   new->x_dtor_label = (tree) write_tree (&new->x_dtor_label);
@@ -1994,15 +1994,15 @@ pickle_decl_lang_specific (t, ld)
   splay_tree_node result;
   if (ggc_set_mark (ld))
     {
-      result = splay_tree_lookup (written_trees, (splay_tree_key)ld);
+      result = splay_tree_lookup (written_pointers, (splay_tree_key)ld);
       if (result)
 	return result->value;
     }
   id = current_id++;
   new = (struct lang_decl *)xmalloc (sizeof (struct lang_decl));
   memcpy (new, ld, sizeof (struct lang_decl));
-  splay_tree_insert (written_trees, (splay_tree_key)ld, id);
-  new->decl_flags.base.saved_tree = (tree) write_tree (&new->decl_flags.base.saved_tree);
+  splay_tree_insert (written_pointers, (splay_tree_key)ld, id);
+  new->decl_flags.base.saved_tree = (tree) write_tree (&((&new->decl_flags.base)->saved_tree));
   if (!DECL_GLOBAL_CTOR_P (t)
       && !DECL_GLOBAL_DTOR_P (t)
       && !DECL_THUNK_P (t)
@@ -2014,7 +2014,7 @@ pickle_decl_lang_specific (t, ld)
     new->decl_flags.u.template_info = (tree) write_tree (&new->decl_flags.u.template_info);
   else
     new->decl_flags.u.level = 
-(struct binding_level *)pickle_binding_level (&new->decl_flags.u.level);
+(struct binding_level *)pickle_binding_level (&NAMESPACE_LEVEL (t));
   if (CAN_HAVE_FULL_LANG_DECL_P (t))
     {
       new->befriending_classes = (tree) write_tree (&new->befriending_classes);
@@ -2023,6 +2023,7 @@ pickle_decl_lang_specific (t, ld)
       new->inlined_fns = (tree) write_tree (&new->inlined_fns);
       if (TREE_CODE (t) == TYPE_DECL)
 	new->u.sorted_fields = (tree) write_tree (&new->u.sorted_fields);
+
     }
   store_to_db (&id, sizeof (int), new, sizeof (struct lang_decl));
   free (new);
@@ -2076,14 +2077,14 @@ pickle_binding_level (arg)
     return 0;
 //  if (ggc_set_mark (lvl))
  //   {
-      result = splay_tree_lookup (written_trees, (splay_tree_key)lvl);
+      result = splay_tree_lookup (written_pointers, (splay_tree_key)lvl);
       if (result)
 	return result->value;
   //  }
   id = current_id++;
   new = xmalloc (sizeof (struct binding_level));
   memcpy (new, lvl, sizeof (struct binding_level));
-  splay_tree_insert (written_trees, (splay_tree_key)lvl, id);
+  splay_tree_insert (written_pointers, (splay_tree_key)lvl, id);
   new->names = (tree) write_tree (&new->names);
   new->tags = (tree) write_tree (&new->tags);
   new->usings = (tree) write_tree (&new->usings);
@@ -2148,7 +2149,6 @@ lang_pickle_tree  (t, oldt)
     TEMPLATE_PARM_DECL (t) = (tree) write_tree (&TEMPLATE_PARM_DECL (t));
   else if (TREE_CODE_CLASS (code) == 'd')
     {
-#if 0
       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
       if (ld)
 	{
@@ -2156,12 +2156,11 @@ lang_pickle_tree  (t, oldt)
 	    if (TREE_CODE (t) == FUNCTION_DECL
 		&& !DECL_PENDING_INLINE_P (oldt))
 	      { 
-//		DECL_SAVED_FUNCTION_DATA (t) = (struct cp_language_function *)pickle_lang_function (t, (struct cp_language_function *)DECL_SAVED_FUNCTION_DATA (t));
+		DECL_SAVED_FUNCTION_DATA (t) = (struct cp_language_function *)pickle_lang_function (t, (struct cp_language_function *)DECL_SAVED_FUNCTION_DATA (t));
 	      }
 	  DECL_LANG_SPECIFIC (t) = 
 	    (struct lang_decl *)pickle_decl_lang_specific (oldt, DECL_LANG_SPECIFIC (t));
 	}
-#endif
     }
     else if (TREE_CODE_CLASS (code) == 't')
       {
@@ -2174,7 +2173,7 @@ lang_pickle_tree  (t, oldt)
 	    splay_tree_node result;
 	    if (ggc_set_mark (lt))
 	      {
-		result = splay_tree_lookup (written_trees, (splay_tree_key) lt);
+		result = splay_tree_lookup (written_pointers, (splay_tree_key) lt);
 		if (result)
 		  TYPE_LANG_SPECIFIC (t) = (struct lang_type *)result->value;
 		return;
@@ -2182,7 +2181,7 @@ lang_pickle_tree  (t, oldt)
 	    id = current_id++;
 	    new = xmalloc (sizeof (struct lang_type));
 	    memcpy (new, lt, sizeof (struct lang_type));
-	    splay_tree_insert (written_trees, (splay_tree_key)lt, id);
+	    splay_tree_insert (written_pointers, (splay_tree_key)lt, id);
 	    new->primary_base = (tree) write_tree (&new->primary_base);
 	    new->vfields = (tree) write_tree (&new->vfields);
 	    new->vbases = (tree) write_tree (&new->vbases);
diff --git a/gcc/toplev.c b/gcc/toplev.c
index f9f02f3f937..dda03425f3c 100644
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -2157,7 +2157,6 @@ compile_file (name)
     }
 
   /* Initialize data in various passes.  */
-
   init_obstacks ();
   name = init_parse (name);
   init_emit_once (debug_info_level == DINFO_LEVEL_NORMAL
diff --git a/gcc/tree.c b/gcc/tree.c
index 2bbd71e6def..2278ddd81c0 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -744,7 +744,6 @@ build_complex (type, real, imag)
     = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
   return t;
 }
-
 /* Build a newly constructed TREE_VEC node of length LEN.  */
 
 tree
@@ -4985,6 +4984,7 @@ const char *datafilename = "testtree";
 size_t current_id = 1;
 splay_tree read_trees = NULL;
 splay_tree written_trees = NULL;
+splay_tree written_pointers = NULL;
 static int pickle_string PARAMS ((const char *));
 static char * pickle_tree PARAMS ((tree));
 static tree unpickle_tree PARAMS ((tree));
@@ -4996,11 +4996,11 @@ pickle_string (s)
 {
   int id;
   splay_tree_node result;
-  result = splay_tree_lookup (written_trees, (splay_tree_key)s);
+  result = splay_tree_lookup (written_pointers, (splay_tree_key)s);
   if (result)
     return result->value;
   id = current_id++;	
-  splay_tree_insert (written_trees, (splay_tree_key)s, id);
+  splay_tree_insert (written_pointers, (splay_tree_key)s, id);
   store_to_db (&id, sizeof (int), (void *)s, strlen (s) + 1);
   return id;
 } 
@@ -5357,12 +5357,12 @@ write_tree_varray (v)
     return 0;
   if (ggc_set_mark (v))
     {
-      result = splay_tree_lookup (written_trees, (splay_tree_key) v);
+      result = splay_tree_lookup (written_pointers, (splay_tree_key) v);
       if (result)
 	return result->value;
     }
   id = current_id++;
-  splay_tree_insert (written_trees, (splay_tree_key)v, id);
+  splay_tree_insert (written_pointers, (splay_tree_key)v, id);
   buffer = pickle_tree_varray (v);
   store_to_db (&id, sizeof (int), buffer, VARRAY_BYTES (v));
   free (buffer);
@@ -5376,6 +5376,8 @@ write_tree (tp)
   int id;
   splay_tree_node result;
   char *buffer;
+  if (written_pointers == NULL)
+    written_pointers = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
   if (written_trees == NULL)
     written_trees = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
   if (datafile == NULL)
@@ -5392,7 +5394,7 @@ write_tree (tp)
 	return result->value;
     }
   id = current_id++;	
-  splay_tree_insert (written_trees, (splay_tree_key)*tp, id);
+  splay_tree_insert (written_trees, (splay_tree_key)(*tp), id);
   buffer = pickle_tree (*tp);
   store_to_db (&id, sizeof (int), buffer, tree_size (*tp));
   free (buffer);
diff --git a/gcc/treepch.h b/gcc/treepch.h
index be031de7bc4..e2ddbaec2bf 100644
--- a/gcc/treepch.h
+++ b/gcc/treepch.h
@@ -13,6 +13,7 @@ extern void lang_pickle_tree PARAMS ((tree, tree));
 extern void lang_unpickle_tree PARAMS ((tree));
 extern splay_tree read_trees;
 extern splay_tree written_trees;
+extern splay_tree written_pointers;
 extern size_t current_id;
 extern const char *datafilename;
 extern DBM *datafile;