From 40ce13289f7f1382be8870e8b727c81b46b64131 Mon Sep 17 00:00:00 2001 From: Daniel Berlin Date: Mon, 17 Sep 2001 20:29:18 +0000 Subject: 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 --- gcc/c-decl.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ gcc/cp/decl.c | 25 ++++++++++++------------- gcc/toplev.c | 1 - gcc/tree.c | 14 ++++++++------ gcc/treepch.h | 1 + 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; -- cgit v1.2.3