2011-08-08 18:49:34 +02:00
|
|
|
/* Miscellaneous utilities for tree streaming. Things that are used
|
|
|
|
in both input and output are here.
|
|
|
|
|
|
|
|
Copyright 2011 Free Software Foundation, Inc.
|
|
|
|
Contributed by Diego Novillo <dnovillo@google.com>
|
|
|
|
|
|
|
|
This file is part of GCC.
|
|
|
|
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
|
|
the terms of the GNU General Public License as published by the Free
|
|
|
|
Software Foundation; either version 3, or (at your option) any later
|
|
|
|
version.
|
|
|
|
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
for more details.
|
|
|
|
|
|
|
|
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/>. */
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "system.h"
|
|
|
|
#include "coretypes.h"
|
|
|
|
#include "streamer-hooks.h"
|
|
|
|
#include "tree-streamer.h"
|
|
|
|
|
|
|
|
/* Check that all the TS_* structures handled by the lto_output_* and
|
|
|
|
lto_input_* routines are exactly ALL the structures defined in
|
|
|
|
treestruct.def. */
|
|
|
|
|
|
|
|
void
|
|
|
|
check_handled_ts_structures (void)
|
|
|
|
{
|
|
|
|
bool handled_p[LAST_TS_ENUM];
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
memset (&handled_p, 0, sizeof (handled_p));
|
|
|
|
|
|
|
|
/* These are the TS_* structures that are either handled or
|
|
|
|
explicitly ignored by the streamer routines. */
|
|
|
|
handled_p[TS_BASE] = true;
|
|
|
|
handled_p[TS_TYPED] = true;
|
|
|
|
handled_p[TS_COMMON] = true;
|
|
|
|
handled_p[TS_INT_CST] = true;
|
|
|
|
handled_p[TS_REAL_CST] = true;
|
|
|
|
handled_p[TS_FIXED_CST] = true;
|
|
|
|
handled_p[TS_VECTOR] = true;
|
|
|
|
handled_p[TS_STRING] = true;
|
|
|
|
handled_p[TS_COMPLEX] = true;
|
|
|
|
handled_p[TS_IDENTIFIER] = true;
|
|
|
|
handled_p[TS_DECL_MINIMAL] = true;
|
|
|
|
handled_p[TS_DECL_COMMON] = true;
|
|
|
|
handled_p[TS_DECL_WRTL] = true;
|
|
|
|
handled_p[TS_DECL_NON_COMMON] = true;
|
|
|
|
handled_p[TS_DECL_WITH_VIS] = true;
|
|
|
|
handled_p[TS_FIELD_DECL] = true;
|
|
|
|
handled_p[TS_VAR_DECL] = true;
|
|
|
|
handled_p[TS_PARM_DECL] = true;
|
|
|
|
handled_p[TS_LABEL_DECL] = true;
|
|
|
|
handled_p[TS_RESULT_DECL] = true;
|
|
|
|
handled_p[TS_CONST_DECL] = true;
|
|
|
|
handled_p[TS_TYPE_DECL] = true;
|
|
|
|
handled_p[TS_FUNCTION_DECL] = true;
|
|
|
|
handled_p[TS_TYPE_COMMON] = true;
|
|
|
|
handled_p[TS_TYPE_WITH_LANG_SPECIFIC] = true;
|
|
|
|
handled_p[TS_TYPE_NON_COMMON] = true;
|
|
|
|
handled_p[TS_LIST] = true;
|
|
|
|
handled_p[TS_VEC] = true;
|
|
|
|
handled_p[TS_EXP] = true;
|
|
|
|
handled_p[TS_SSA_NAME] = true;
|
|
|
|
handled_p[TS_BLOCK] = true;
|
|
|
|
handled_p[TS_BINFO] = true;
|
|
|
|
handled_p[TS_STATEMENT_LIST] = true;
|
|
|
|
handled_p[TS_CONSTRUCTOR] = true;
|
|
|
|
handled_p[TS_OMP_CLAUSE] = true;
|
|
|
|
handled_p[TS_OPTIMIZATION] = true;
|
|
|
|
handled_p[TS_TARGET_OPTION] = true;
|
|
|
|
handled_p[TS_TRANSLATION_UNIT_DECL] = true;
|
|
|
|
|
|
|
|
/* Anything not marked above will trigger the following assertion.
|
|
|
|
If this assertion triggers, it means that there is a new TS_*
|
|
|
|
structure that should be handled by the streamer. */
|
|
|
|
for (i = 0; i < LAST_TS_ENUM; i++)
|
|
|
|
gcc_assert (handled_p[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Helper for lto_streamer_cache_insert_1. Add T to CACHE->NODES at
|
|
|
|
slot IX. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
lto_streamer_cache_add_to_node_array (struct lto_streamer_cache_d *cache,
|
|
|
|
unsigned ix, tree t)
|
|
|
|
{
|
|
|
|
/* Make sure we're either replacing an old element or
|
|
|
|
appending consecutively. */
|
|
|
|
gcc_assert (ix <= VEC_length (tree, cache->nodes));
|
|
|
|
|
|
|
|
if (ix == VEC_length (tree, cache->nodes))
|
|
|
|
VEC_safe_push (tree, heap, cache->nodes, t);
|
|
|
|
else
|
|
|
|
VEC_replace (tree, cache->nodes, ix, t);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Helper for lto_streamer_cache_insert and lto_streamer_cache_insert_at.
|
|
|
|
CACHE, T, and IX_P are as in lto_streamer_cache_insert.
|
|
|
|
|
|
|
|
If INSERT_AT_NEXT_SLOT_P is true, T is inserted at the next available
|
|
|
|
slot in the cache. Otherwise, T is inserted at the position indicated
|
|
|
|
in *IX_P.
|
|
|
|
|
|
|
|
If T already existed in CACHE, return true. Otherwise,
|
|
|
|
return false. */
|
|
|
|
|
|
|
|
static bool
|
|
|
|
lto_streamer_cache_insert_1 (struct lto_streamer_cache_d *cache,
|
|
|
|
tree t, unsigned *ix_p,
|
|
|
|
bool insert_at_next_slot_p)
|
|
|
|
{
|
|
|
|
void **slot;
|
|
|
|
unsigned ix;
|
|
|
|
bool existed_p;
|
|
|
|
|
|
|
|
gcc_assert (t);
|
|
|
|
|
|
|
|
slot = pointer_map_insert (cache->node_map, t);
|
|
|
|
if (!*slot)
|
|
|
|
{
|
|
|
|
/* Determine the next slot to use in the cache. */
|
|
|
|
if (insert_at_next_slot_p)
|
|
|
|
ix = VEC_length (tree, cache->nodes);
|
|
|
|
else
|
|
|
|
ix = *ix_p;
|
|
|
|
*slot = (void *)(size_t) (ix + 1);
|
|
|
|
|
|
|
|
lto_streamer_cache_add_to_node_array (cache, ix, t);
|
|
|
|
|
|
|
|
/* Indicate that the item was not present in the cache. */
|
|
|
|
existed_p = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ix = (size_t) *slot - 1;
|
|
|
|
|
|
|
|
if (!insert_at_next_slot_p && ix != *ix_p)
|
|
|
|
{
|
|
|
|
/* If the caller wants to insert T at a specific slot
|
|
|
|
location, and ENTRY->TO does not match *IX_P, add T to
|
|
|
|
the requested location slot. */
|
|
|
|
ix = *ix_p;
|
|
|
|
lto_streamer_cache_add_to_node_array (cache, ix, t);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Indicate that T was already in the cache. */
|
|
|
|
existed_p = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ix_p)
|
|
|
|
*ix_p = ix;
|
|
|
|
|
|
|
|
return existed_p;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Insert tree node T in CACHE. If T already existed in the cache
|
|
|
|
return true. Otherwise, return false.
|
|
|
|
|
|
|
|
If IX_P is non-null, update it with the index into the cache where
|
|
|
|
T has been stored. */
|
|
|
|
|
|
|
|
bool
|
|
|
|
lto_streamer_cache_insert (struct lto_streamer_cache_d *cache, tree t,
|
|
|
|
unsigned *ix_p)
|
|
|
|
{
|
|
|
|
return lto_streamer_cache_insert_1 (cache, t, ix_p, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Insert tree node T in CACHE at slot IX. If T already
|
|
|
|
existed in the cache return true. Otherwise, return false. */
|
|
|
|
|
|
|
|
bool
|
|
|
|
lto_streamer_cache_insert_at (struct lto_streamer_cache_d *cache,
|
|
|
|
tree t, unsigned ix)
|
|
|
|
{
|
|
|
|
return lto_streamer_cache_insert_1 (cache, t, &ix, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Appends tree node T to CACHE, even if T already existed in it. */
|
|
|
|
|
|
|
|
void
|
|
|
|
lto_streamer_cache_append (struct lto_streamer_cache_d *cache, tree t)
|
|
|
|
{
|
|
|
|
unsigned ix = VEC_length (tree, cache->nodes);
|
|
|
|
lto_streamer_cache_insert_1 (cache, t, &ix, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return true if tree node T exists in CACHE, otherwise false. If IX_P is
|
|
|
|
not NULL, write to *IX_P the index into the cache where T is stored
|
|
|
|
((unsigned)-1 if T is not found). */
|
|
|
|
|
|
|
|
bool
|
|
|
|
lto_streamer_cache_lookup (struct lto_streamer_cache_d *cache, tree t,
|
|
|
|
unsigned *ix_p)
|
|
|
|
{
|
|
|
|
void **slot;
|
|
|
|
bool retval;
|
|
|
|
unsigned ix;
|
|
|
|
|
|
|
|
gcc_assert (t);
|
|
|
|
|
|
|
|
slot = pointer_map_contains (cache->node_map, t);
|
|
|
|
if (slot == NULL)
|
|
|
|
{
|
|
|
|
retval = false;
|
|
|
|
ix = -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
retval = true;
|
|
|
|
ix = (size_t) *slot - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ix_p)
|
|
|
|
*ix_p = ix;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Return the tree node at slot IX in CACHE. */
|
|
|
|
|
|
|
|
tree
|
|
|
|
lto_streamer_cache_get (struct lto_streamer_cache_d *cache, unsigned ix)
|
|
|
|
{
|
|
|
|
gcc_assert (cache);
|
|
|
|
|
|
|
|
/* Make sure we're not requesting something we don't have. */
|
|
|
|
gcc_assert (ix < VEC_length (tree, cache->nodes));
|
|
|
|
|
|
|
|
return VEC_index (tree, cache->nodes, ix);
|
|
|
|
}
|
|
|
|
|
2011-08-11 14:02:34 +02:00
|
|
|
|
|
|
|
/* Record NODE in CACHE. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
lto_record_common_node (struct lto_streamer_cache_d *cache, tree node)
|
|
|
|
{
|
|
|
|
/* We have to make sure to fill exactly the same number of
|
|
|
|
elements for all frontends. That can include NULL trees.
|
|
|
|
As our hash table can't deal with zero entries we'll simply stream
|
|
|
|
a random other tree. A NULL tree never will be looked up so it
|
|
|
|
doesn't matter which tree we replace it with, just to be sure
|
|
|
|
use error_mark_node. */
|
|
|
|
if (!node)
|
|
|
|
node = error_mark_node;
|
|
|
|
|
|
|
|
lto_streamer_cache_append (cache, node);
|
|
|
|
|
|
|
|
if (POINTER_TYPE_P (node)
|
|
|
|
|| TREE_CODE (node) == COMPLEX_TYPE
|
|
|
|
|| TREE_CODE (node) == ARRAY_TYPE)
|
|
|
|
lto_record_common_node (cache, TREE_TYPE (node));
|
|
|
|
else if (TREE_CODE (node) == RECORD_TYPE)
|
|
|
|
{
|
|
|
|
/* The FIELD_DECLs of structures should be shared, so that every
|
|
|
|
COMPONENT_REF uses the same tree node when referencing a field.
|
|
|
|
Pointer equality between FIELD_DECLs is used by the alias
|
|
|
|
machinery to compute overlapping memory references (See
|
|
|
|
nonoverlapping_component_refs_p). */
|
|
|
|
tree f;
|
|
|
|
for (f = TYPE_FIELDS (node); f; f = TREE_CHAIN (f))
|
|
|
|
lto_record_common_node (cache, f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Preload common nodes into CACHE and make sure they are merged
|
|
|
|
properly according to the gimple type table. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
preload_common_nodes (struct lto_streamer_cache_d *cache)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for (i = 0; i < itk_none; i++)
|
|
|
|
/* Skip itk_char. char_type_node is dependent on -f[un]signed-char. */
|
|
|
|
if (i != itk_char)
|
|
|
|
lto_record_common_node (cache, integer_types[i]);
|
|
|
|
|
|
|
|
for (i = 0; i < TYPE_KIND_LAST; i++)
|
|
|
|
lto_record_common_node (cache, sizetype_tab[i]);
|
|
|
|
|
|
|
|
for (i = 0; i < TI_MAX; i++)
|
|
|
|
/* Skip boolean type and constants, they are frontend dependent. */
|
|
|
|
if (i != TI_BOOLEAN_TYPE
|
|
|
|
&& i != TI_BOOLEAN_FALSE
|
|
|
|
&& i != TI_BOOLEAN_TRUE)
|
|
|
|
lto_record_common_node (cache, global_trees[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-08-08 18:49:34 +02:00
|
|
|
/* Create a cache of pickled nodes. */
|
|
|
|
|
|
|
|
struct lto_streamer_cache_d *
|
|
|
|
lto_streamer_cache_create (void)
|
|
|
|
{
|
|
|
|
struct lto_streamer_cache_d *cache;
|
|
|
|
|
|
|
|
cache = XCNEW (struct lto_streamer_cache_d);
|
|
|
|
|
|
|
|
cache->node_map = pointer_map_create ();
|
|
|
|
|
|
|
|
/* Load all the well-known tree nodes that are always created by
|
|
|
|
the compiler on startup. This prevents writing them out
|
|
|
|
unnecessarily. */
|
2011-08-11 14:02:34 +02:00
|
|
|
preload_common_nodes (cache);
|
2011-08-08 18:49:34 +02:00
|
|
|
|
|
|
|
return cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Delete the streamer cache C. */
|
|
|
|
|
|
|
|
void
|
|
|
|
lto_streamer_cache_delete (struct lto_streamer_cache_d *c)
|
|
|
|
{
|
|
|
|
if (c == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
pointer_map_destroy (c->node_map);
|
|
|
|
VEC_free (tree, heap, c->nodes);
|
|
|
|
free (c);
|
|
|
|
}
|