static void
write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
{
int i;
streamer_write_hwi (ob, TREE_OPERAND_LENGTH (expr));
for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
lto_output_location (ob, EXPR_LOCATION (expr));
stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
}
static struct loop *
outermost_invariant_loop_expr (tree expr, struct loop *loop)
{
enum tree_code_class codeclass = TREE_CODE_CLASS (TREE_CODE (expr));
unsigned i, nops;
struct loop *max_loop = superloop_at_depth (loop, 1), *aloop;
if (TREE_CODE (expr) == SSA_NAME
|| TREE_CODE (expr) == INTEGER_CST
|| is_gimple_min_invariant (expr))
return outermost_invariant_loop (expr, loop);
if (codeclass != tcc_unary
&& codeclass != tcc_binary
&& codeclass != tcc_expression
&& codeclass != tcc_vl_exp
&& codeclass != tcc_comparison)
return NULL;
nops = TREE_OPERAND_LENGTH (expr);
for (i = 0; i < nops; i++)
{
aloop = outermost_invariant_loop_expr (TREE_OPERAND (expr, i), loop);
if (!aloop)
return NULL;
if (flow_loop_nested_p (max_loop, aloop))
max_loop = aloop;
}
return max_loop;
}
static tree get_string_cst(tree var)
{
if (var == NULL_TREE)
return NULL_TREE;
if (TREE_CODE(var) == STRING_CST)
return var;
switch (TREE_CODE_CLASS(TREE_CODE(var))) {
case tcc_expression:
case tcc_reference: {
int i;
for (i = 0; i < TREE_OPERAND_LENGTH(var); i++) {
tree ret = get_string_cst(TREE_OPERAND(var, i));
if (ret != NULL_TREE)
return ret;
}
break;
}
default:
break;
}
return NULL_TREE;
}
static tree
cp_ubsan_check_member_access_r (tree *stmt_p, int *walk_subtrees, void *data)
{
tree stmt = *stmt_p, t;
cp_ubsan_check_member_access_data *ucmd
= (cp_ubsan_check_member_access_data *) data;
switch (TREE_CODE (stmt))
{
case ADDR_EXPR:
t = TREE_OPERAND (stmt, 0);
while ((TREE_CODE (t) == MEM_REF || TREE_CODE (t) == INDIRECT_REF)
&& TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
if (handled_component_p (t))
{
*walk_subtrees = 0;
ucmd->is_addr = true;
cp_walk_tree (&t, cp_ubsan_check_member_access_r,
data, ucmd->pset);
ucmd->is_addr = false;
}
break;
case MEM_REF:
case INDIRECT_REF:
t = TREE_OPERAND (stmt, 0);
if (TREE_CODE (t) == ADDR_EXPR)
{
*walk_subtrees = 0;
t = TREE_OPERAND (stmt, 0);
cp_walk_tree (&t, cp_ubsan_check_member_access_r, data, ucmd->pset);
}
break;
case COMPONENT_REF:
if (!ucmd->is_addr && cp_ubsan_maybe_instrument_member_access (stmt, ucmd))
{
*walk_subtrees = 0;
break;
}
/* FALLTHRU */
default:
if (ucmd->is_addr && handled_component_p (stmt))
{
int i, len = TREE_OPERAND_LENGTH (stmt);
*walk_subtrees = 0;
if (!handled_component_p (TREE_OPERAND (stmt, 0)))
ucmd->is_addr = false;
for (i = 0; i < len; i++)
{
cp_walk_tree (&TREE_OPERAND (stmt, i),
cp_ubsan_check_member_access_r, data, ucmd->pset);
ucmd->is_addr = false;
}
ucmd->is_addr = true;
}
break;
}
return NULL_TREE;
}
static void
write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
{
int i;
for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
}
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));
}
inline bool
tree_upper_hasher::equal (const value_type &parent, const compare_type &node)
{
if (parent == NULL || node == NULL)
return 0;
if (EXPR_P (parent))
{
int n = TREE_OPERAND_LENGTH (parent);
int i;
for (i = 0; i < n; i++)
if (node == TREE_OPERAND (parent, i))
return true;
}
return false;
}
bool
chrec_contains_undetermined (const_tree chrec)
{
int i, n;
if (chrec == chrec_dont_know)
return true;
if (chrec == NULL_TREE)
return false;
n = TREE_OPERAND_LENGTH (chrec);
for (i = 0; i < n; i++)
if (chrec_contains_undetermined (TREE_OPERAND (chrec, i)))
return true;
return false;
}
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 bool
evolution_function_is_invariant_rec_p (tree chrec, int loopnum)
{
if (evolution_function_is_constant_p (chrec))
return true;
if (TREE_CODE (chrec) == SSA_NAME
&& (loopnum == 0
|| expr_invariant_in_loop_p (get_loop (cfun, loopnum), chrec)))
return true;
if (TREE_CODE (chrec) == POLYNOMIAL_CHREC)
{
if (CHREC_VARIABLE (chrec) == (unsigned) loopnum
|| flow_loop_nested_p (get_loop (cfun, loopnum),
get_chrec_loop (chrec))
|| !evolution_function_is_invariant_rec_p (CHREC_RIGHT (chrec),
loopnum)
|| !evolution_function_is_invariant_rec_p (CHREC_LEFT (chrec),
loopnum))
return false;
return true;
}
switch (TREE_OPERAND_LENGTH (chrec))
{
case 2:
if (!evolution_function_is_invariant_rec_p (TREE_OPERAND (chrec, 1),
loopnum))
return false;
case 1:
if (!evolution_function_is_invariant_rec_p (TREE_OPERAND (chrec, 0),
loopnum))
return false;
return true;
default:
return false;
}
return false;
}
bool
tree_contains_chrecs (const_tree expr, int *size)
{
int i, n;
if (expr == NULL_TREE)
return false;
if (size)
(*size)++;
if (tree_is_chrec (expr))
return true;
n = TREE_OPERAND_LENGTH (expr);
for (i = 0; i < n; i++)
if (tree_contains_chrecs (TREE_OPERAND (expr, i), size))
return true;
return false;
}
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);
}
}
bool
chrec_contains_symbols (const_tree chrec)
{
int i, n;
if (chrec == NULL_TREE)
return false;
if (TREE_CODE (chrec) == SSA_NAME
|| TREE_CODE (chrec) == VAR_DECL
|| TREE_CODE (chrec) == PARM_DECL
|| TREE_CODE (chrec) == FUNCTION_DECL
|| TREE_CODE (chrec) == LABEL_DECL
|| TREE_CODE (chrec) == RESULT_DECL
|| TREE_CODE (chrec) == FIELD_DECL)
return true;
n = TREE_OPERAND_LENGTH (chrec);
for (i = 0; i < n; i++)
if (chrec_contains_symbols (TREE_OPERAND (chrec, i)))
return true;
return false;
}
static void
show_tree (tree node)
{
if (!CAN_HAVE_RANGE_P (node))
return;
gcc_rich_location richloc (EXPR_LOCATION (node));
richloc.add_expr (node);
if (richloc.get_num_locations () < 2)
{
error_at (&richloc, "range not found");
return;
}
enum tree_code code = TREE_CODE (node);
location_range *range = richloc.get_range (1);
inform (&richloc, "%s", get_tree_code_name (code));
/* Recurse. */
int min_idx = 0;
int max_idx = TREE_OPERAND_LENGTH (node);
switch (code)
{
case CALL_EXPR:
min_idx = 3;
break;
default:
break;
}
for (int i = min_idx; i < max_idx; i++)
show_tree (TREE_OPERAND (node, i));
}
