static void
lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
DECL_NAME (expr) = stream_read_tree (ib, data_in);
DECL_CONTEXT (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
TREE_REALPART (expr) = stream_read_tree (ib, data_in);
TREE_IMAGPART (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
DECL_SIZE (expr) = stream_read_tree (ib, data_in);
DECL_SIZE_UNIT (expr) = stream_read_tree (ib, data_in);
DECL_ATTRIBUTES (expr) = stream_read_tree (ib, data_in);
/* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
for early inlining so drop it on the floor instead of ICEing in
dwarf2out.c. */
if (TREE_CODE (expr) == PARM_DECL)
TREE_CHAIN (expr) = streamer_read_chain (ib, data_in);
if ((TREE_CODE (expr) == VAR_DECL
|| TREE_CODE (expr) == PARM_DECL)
&& DECL_HAS_VALUE_EXPR_P (expr))
SET_DECL_VALUE_EXPR (expr, stream_read_tree (ib, data_in));
if (TREE_CODE (expr) == VAR_DECL)
{
tree dexpr = stream_read_tree (ib, data_in);
if (dexpr)
SET_DECL_DEBUG_EXPR (expr, dexpr);
}
}
static void
lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
unsigned i;
tree t;
/* Note that the number of slots in EXPR was read in
streamer_alloc_tree when instantiating EXPR. However, the
vector is empty so we cannot rely on vec::length to know how many
elements to read. So, this list is emitted as a 0-terminated
list on the writer side. */
do
{
t = stream_read_tree (ib, data_in);
if (t)
BINFO_BASE_BINFOS (expr)->quick_push (t);
}
while (t);
BINFO_OFFSET (expr) = stream_read_tree (ib, data_in);
BINFO_VTABLE (expr) = stream_read_tree (ib, data_in);
BINFO_VPTR_FIELD (expr) = stream_read_tree (ib, data_in);
/* The vector of BINFO_BASE_ACCESSES is pre-allocated during
unpacking the bitfield section. */
for (i = 0; i < vec_safe_length (BINFO_BASE_ACCESSES (expr)); i++)
{
tree a = stream_read_tree (ib, data_in);
(*BINFO_BASE_ACCESSES (expr))[i] = a;
}
/* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
and BINFO_VPTR_INDEX; these are used by C++ FE only. */
}
static void
lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
TREE_PURPOSE (expr) = stream_read_tree (ib, data_in);
TREE_VALUE (expr) = stream_read_tree (ib, data_in);
TREE_CHAIN (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
if (TREE_CODE (expr) == TYPE_DECL)
DECL_ORIGINAL_TYPE (expr) = stream_read_tree (ib, data_in);
DECL_VINDEX (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_omp_clause_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
int i;
for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
OMP_CLAUSE_OPERAND (expr, i) = stream_read_tree (ib, data_in);
OMP_CLAUSE_CHAIN (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
DECL_FIELD_OFFSET (expr) = stream_read_tree (ib, data_in);
DECL_BIT_FIELD_TYPE (expr) = stream_read_tree (ib, data_in);
/* Do not stream DECL_QUALIFIER, it is useless after gimplification. */
DECL_FIELD_BIT_OFFSET (expr) = stream_read_tree (ib, data_in);
DECL_FCONTEXT (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
DECL_FIELD_OFFSET (expr) = stream_read_tree (ib, data_in);
DECL_BIT_FIELD_TYPE (expr) = stream_read_tree (ib, data_in);
DECL_BIT_FIELD_REPRESENTATIVE (expr) = stream_read_tree (ib, data_in);
DECL_FIELD_BIT_OFFSET (expr) = stream_read_tree (ib, data_in);
DECL_FCONTEXT (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
int i;
for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
TREE_OPERAND (expr, i) = stream_read_tree (ib, data_in);
TREE_SET_BLOCK (expr, stream_read_tree (ib, data_in));
}
static void
lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
if (TREE_CODE (expr) == FUNCTION_DECL)
{
DECL_ARGUMENTS (expr) = streamer_read_chain (ib, data_in);
DECL_RESULT (expr) = stream_read_tree (ib, data_in);
}
else if (TREE_CODE (expr) == TYPE_DECL)
DECL_ORIGINAL_TYPE (expr) = stream_read_tree (ib, data_in);
DECL_VINDEX (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
unsigned i;
for (i = 0; i < CONSTRUCTOR_NELTS (expr); i++)
{
constructor_elt e;
e.index = stream_read_tree (ib, data_in);
e.value = stream_read_tree (ib, data_in);
(*CONSTRUCTOR_ELTS (expr))[i] = e;
}
}
static void
lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
/* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
maybe it should be handled here? */
DECL_FUNCTION_PERSONALITY (expr) = stream_read_tree (ib, data_in);
DECL_FUNCTION_SPECIFIC_TARGET (expr) = stream_read_tree (ib, data_in);
DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = stream_read_tree (ib, data_in);
/* If the file contains a function with an EH personality set,
then it was compiled with -fexceptions. In that case, initialize
the backend EH machinery. */
if (DECL_FUNCTION_PERSONALITY (expr))
lto_init_eh ();
}
static void
lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
tree id;
id = stream_read_tree (ib, data_in);
if (id)
{
gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
SET_DECL_ASSEMBLER_NAME (expr, id);
}
DECL_SECTION_NAME (expr) = stream_read_tree (ib, data_in);
DECL_COMDAT_GROUP (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
unsigned i, len;
len = streamer_read_uhwi (ib);
for (i = 0; i < len; i++)
{
tree index, value;
index = stream_read_tree (ib, data_in);
value = stream_read_tree (ib, data_in);
CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
}
}
static void
lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
if (TREE_CODE (expr) != IDENTIFIER_NODE)
TREE_TYPE (expr) = stream_read_tree (ib, data_in);
}
tree
streamer_read_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
{
tree type = stream_read_tree (ib, data_in);
unsigned HOST_WIDE_INT low = streamer_read_uhwi (ib);
HOST_WIDE_INT high = streamer_read_hwi (ib);
return build_int_cst_wide (type, low, high);
}
static void
lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
int i, length;
location_t loc;
length = streamer_read_hwi (ib);
gcc_assert (length == TREE_OPERAND_LENGTH (expr));
for (i = 0; i < length; i++)
TREE_OPERAND (expr, i) = stream_read_tree (ib, data_in);
loc = lto_input_location (ib, data_in);
SET_EXPR_LOCATION (expr, loc);
TREE_BLOCK (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
unsigned i;
for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
VECTOR_CST_ELT (expr, i) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
DECL_VINDEX (expr) = stream_read_tree (ib, data_in);
/* DECL_STRUCT_FUNCTION is loaded on demand by cgraph_get_body. */
DECL_FUNCTION_PERSONALITY (expr) = stream_read_tree (ib, data_in);
#ifndef ACCEL_COMPILER
DECL_FUNCTION_SPECIFIC_TARGET (expr) = stream_read_tree (ib, data_in);
#endif
DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = stream_read_tree (ib, data_in);
/* If the file contains a function with an EH personality set,
then it was compiled with -fexceptions. In that case, initialize
the backend EH machinery. */
if (DECL_FUNCTION_PERSONALITY (expr))
lto_init_eh ();
}
static void
lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
int i;
tree block;
for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
TREE_OPERAND (expr, i) = stream_read_tree (ib, data_in);
block = stream_read_tree (ib, data_in);
/* TODO: Block is stored in the locus information. It may make more sense to
to make it go via the location cache. */
if (block)
{
data_in->location_cache.apply_location_cache ();
TREE_SET_BLOCK (expr, block);
}
}
static void
lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
int i;
/* Note that TREE_VEC_LENGTH was read by streamer_alloc_tree to
instantiate EXPR. */
for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
TREE_VEC_ELT (expr, i) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
/* Do not stream BLOCK_SOURCE_LOCATION. We cannot handle debug information
for early inlining so drop it on the floor instead of ICEing in
dwarf2out.c. */
BLOCK_VARS (expr) = streamer_read_chain (ib, data_in);
/* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
for early inlining so drop it on the floor instead of ICEing in
dwarf2out.c. */
BLOCK_SUPERCONTEXT (expr) = stream_read_tree (ib, data_in);
/* Do not stream BLOCK_ABSTRACT_ORIGIN. We cannot handle debug information
for early inlining so drop it on the floor instead of ICEing in
dwarf2out.c. */
BLOCK_FRAGMENT_ORIGIN (expr) = stream_read_tree (ib, data_in);
BLOCK_FRAGMENT_CHAIN (expr) = stream_read_tree (ib, data_in);
/* We re-compute BLOCK_SUBBLOCKS of our parent here instead
of streaming it. For non-BLOCK BLOCK_SUPERCONTEXTs we still
stream the child relationship explicitly. */
if (BLOCK_SUPERCONTEXT (expr)
&& TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == BLOCK)
{
BLOCK_CHAIN (expr) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr));
BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr)) = expr;
}
/* The global block is rooted at the TU decl. Hook it here to
avoid the need to stream in this block during WPA time. */
else if (BLOCK_SUPERCONTEXT (expr)
&& TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == TRANSLATION_UNIT_DECL)
DECL_INITIAL (BLOCK_SUPERCONTEXT (expr)) = expr;
/* The function-level block is connected at the time we read in
function bodies for the same reason. */
}
static gphi *
input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
struct function *fn)
{
unsigned HOST_WIDE_INT ix;
tree phi_result;
int i, len;
gphi *result;
ix = streamer_read_uhwi (ib);
phi_result = (*SSANAMES (fn))[ix];
len = EDGE_COUNT (bb->preds);
result = create_phi_node (phi_result, bb);
/* We have to go through a lookup process here because the preds in the
reconstructed graph are generally in a different order than they
were in the original program. */
for (i = 0; i < len; i++)
{
tree def = stream_read_tree (ib, data_in);
int src_index = streamer_read_uhwi (ib);
bitpack_d bp = streamer_read_bitpack (ib);
/* Do not cache a location - we do not have API to get pointer to the
location in PHI statement and we may trigger reallocation. */
location_t arg_loc = stream_input_location_now (&bp, data_in);
basic_block sbb = BASIC_BLOCK_FOR_FN (fn, src_index);
edge e = NULL;
int j;
for (j = 0; j < len; j++)
if (EDGE_PRED (bb, j)->src == sbb)
{
e = EDGE_PRED (bb, j);
break;
}
add_phi_arg (result, def, e, arg_loc);
}
return result;
}
static void
lto_input_ts_type_common_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
TYPE_SIZE (expr) = stream_read_tree (ib, data_in);
TYPE_SIZE_UNIT (expr) = stream_read_tree (ib, data_in);
TYPE_ATTRIBUTES (expr) = stream_read_tree (ib, data_in);
TYPE_NAME (expr) = stream_read_tree (ib, data_in);
/* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
reconstructed during fixup. */
/* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
during fixup. */
TYPE_MAIN_VARIANT (expr) = stream_read_tree (ib, data_in);
TYPE_CONTEXT (expr) = stream_read_tree (ib, data_in);
/* TYPE_CANONICAL gets re-computed during type merging. */
TYPE_CANONICAL (expr) = NULL_TREE;
TYPE_STUB_DECL (expr) = stream_read_tree (ib, data_in);
}
static void
lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
unsigned i, len;
tree t;
/* Note that the number of slots in EXPR was read in
streamer_alloc_tree when instantiating EXPR. However, the
vector is empty so we cannot rely on VEC_length to know how many
elements to read. So, this list is emitted as a 0-terminated
list on the writer side. */
do
{
t = stream_read_tree (ib, data_in);
if (t)
VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
}
while (t);
BINFO_OFFSET (expr) = stream_read_tree (ib, data_in);
BINFO_VTABLE (expr) = stream_read_tree (ib, data_in);
BINFO_VPTR_FIELD (expr) = stream_read_tree (ib, data_in);
len = streamer_read_uhwi (ib);
if (len > 0)
{
VEC_reserve_exact (tree, gc, BINFO_BASE_ACCESSES (expr), len);
for (i = 0; i < len; i++)
{
tree a = stream_read_tree (ib, data_in);
VEC_quick_push (tree, BINFO_BASE_ACCESSES (expr), a);
}
}
BINFO_INHERITANCE_CHAIN (expr) = stream_read_tree (ib, data_in);
BINFO_SUBVTT_INDEX (expr) = stream_read_tree (ib, data_in);
BINFO_VPTR_INDEX (expr) = stream_read_tree (ib, data_in);
}
tree
streamer_read_chain (struct lto_input_block *ib, struct data_in *data_in)
{
tree first, prev, curr;
/* The chain is written as NULL terminated list of trees. */
first = prev = NULL_TREE;
do
{
curr = stream_read_tree (ib, data_in);
if (prev)
TREE_CHAIN (prev) = curr;
else
first = curr;
prev = curr;
}
while (curr);
return first;
}
static gimple
input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
struct function *fn)
{
unsigned HOST_WIDE_INT ix;
tree phi_result;
int i, len;
gimple result;
ix = streamer_read_uhwi (ib);
phi_result = VEC_index (tree, SSANAMES (fn), ix);
len = EDGE_COUNT (bb->preds);
result = create_phi_node (phi_result, bb);
SSA_NAME_DEF_STMT (phi_result) = result;
/* We have to go through a lookup process here because the preds in the
reconstructed graph are generally in a different order than they
were in the original program. */
for (i = 0; i < len; i++)
{
tree def = stream_read_tree (ib, data_in);
int src_index = streamer_read_uhwi (ib);
location_t arg_loc = lto_input_location (ib, data_in);
basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index);
edge e = NULL;
int j;
for (j = 0; j < len; j++)
if (EDGE_PRED (bb, j)->src == sbb)
{
e = EDGE_PRED (bb, j);
break;
}
add_phi_arg (result, def, e, arg_loc);
}
return result;
}
tree
streamer_read_chain (struct lto_input_block *ib, struct data_in *data_in)
{
int i, count;
tree first, prev, curr;
first = prev = NULL_TREE;
count = streamer_read_hwi (ib);
for (i = 0; i < count; i++)
{
curr = stream_read_tree (ib, data_in);
if (prev)
TREE_CHAIN (prev) = curr;
else
first = curr;
TREE_CHAIN (curr) = NULL_TREE;
prev = curr;
}
return first;
}
tree
streamer_read_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
{
tree result, type;
HOST_WIDE_INT low, high;
bool overflow_p;
type = stream_read_tree (ib, data_in);
overflow_p = (streamer_read_uchar (ib) != 0);
low = streamer_read_uhwi (ib);
high = streamer_read_uhwi (ib);
result = build_int_cst_wide (type, low, high);
/* If the original constant had overflown, build a replica of RESULT to
avoid modifying the shared constant returned by build_int_cst_wide. */
if (overflow_p)
{
result = copy_node (result);
TREE_OVERFLOW (result) = 1;
}
return result;
}