static void
record_common_node (struct streamer_tree_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;
streamer_tree_cache_append (cache, node);
if (POINTER_TYPE_P (node)
|| TREE_CODE (node) == COMPLEX_TYPE
|| TREE_CODE (node) == ARRAY_TYPE)
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))
record_common_node (cache, f);
}
}
static void
record_common_node (struct streamer_tree_cache_d *cache, tree node)
{
/* If we recursively end up at nodes we do not want to preload simply don't.
??? We'd want to verify that this doesn't happen, or alternatively
do not recurse at all. */
if (node == char_type_node)
return;
gcc_checking_assert (node != boolean_type_node
&& node != boolean_true_node
&& node != boolean_false_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;
/* ??? FIXME, devise a better hash value. But the hash needs to be equal
for all frontend and lto1 invocations. So just use the position
in the cache as hash value. */
streamer_tree_cache_append (cache, node, cache->nodes.length ());
if (POINTER_TYPE_P (node)
|| TREE_CODE (node) == COMPLEX_TYPE
|| TREE_CODE (node) == ARRAY_TYPE)
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 component references (see
nonoverlapping_component_refs_p and
nonoverlapping_component_refs_of_decl_p). */
for (tree f = TYPE_FIELDS (node); f; f = TREE_CHAIN (f))
record_common_node (cache, f);
}
}
static void
preload_common_nodes (struct streamer_tree_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)
record_common_node (cache, integer_types[i]);
for (i = 0; i < stk_type_kind_last; i++)
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)
record_common_node (cache, global_trees[i]);
}
static void
preload_common_nodes (struct streamer_tree_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)
record_common_node (cache, integer_types[i]);
for (i = 0; i < stk_type_kind_last; i++)
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
/* MAIN_IDENTIFIER is not always initialized by Fortran FE. */
&& i != TI_MAIN_IDENTIFIER
/* PID_TYPE is initialized only by C family front-ends. */
&& i != TI_PID_TYPE
/* Skip optimization and target option nodes; they depend on flags. */
&& i != TI_OPTIMIZATION_DEFAULT
&& i != TI_OPTIMIZATION_CURRENT
&& i != TI_TARGET_OPTION_DEFAULT
&& i != TI_TARGET_OPTION_CURRENT
&& i != TI_CURRENT_TARGET_PRAGMA
&& i != TI_CURRENT_OPTIMIZE_PRAGMA
/* Skip va_list* related nodes if offloading. For native LTO
we want them to be merged for the stdarg pass, for offloading
they might not be identical between host and offloading target. */
&& (!lto_stream_offload_p
|| (i != TI_VA_LIST_TYPE
&& i != TI_VA_LIST_GPR_COUNTER_FIELD
&& i != TI_VA_LIST_FPR_COUNTER_FIELD)))
record_common_node (cache, global_trees[i]);
}
static void
record_common_node (struct streamer_tree_cache_d *cache, tree node)
{
/* If we recursively end up at nodes we do not want to preload simply don't.
??? We'd want to verify that this doesn't happen, or alternatively
do not recurse at all. */
if (node == char_type_node)
return;
gcc_checking_assert (node != boolean_type_node
&& node != boolean_true_node
&& node != boolean_false_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;
/* ??? FIXME, devise a better hash value. But the hash needs to be equal
for all frontend and lto1 invocations. So just use the position
in the cache as hash value. */
streamer_tree_cache_append (cache, node, cache->nodes.length ());
switch (TREE_CODE (node))
{
case ERROR_MARK:
case FIELD_DECL:
case FIXED_POINT_TYPE:
case IDENTIFIER_NODE:
case INTEGER_CST:
case INTEGER_TYPE:
case POINTER_BOUNDS_TYPE:
case REAL_TYPE:
case TREE_LIST:
case VOID_CST:
case VOID_TYPE:
/* No recursive trees. */
break;
case ARRAY_TYPE:
case POINTER_TYPE:
case REFERENCE_TYPE:
record_common_node (cache, TREE_TYPE (node));
break;
case COMPLEX_TYPE:
/* Verify that a complex type's component type (node_type) has been
handled already (and we thus don't need to recurse here). */
verify_common_node_recorded (cache, TREE_TYPE (node));
break;
case 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 component references (see
nonoverlapping_component_refs_p and
nonoverlapping_component_refs_of_decl_p). */
for (tree f = TYPE_FIELDS (node); f; f = TREE_CHAIN (f))
record_common_node (cache, f);
break;
default:
/* Unexpected tree code. */
gcc_unreachable ();
}
}