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;
}
bool
cpp_validate_cilk_plus_loop (tree body)
{
bool valid = true;
cp_walk_tree (&body, cpp_validate_cilk_plus_loop_aux,
(void *) &valid, NULL);
return valid;
}
void
cp_ubsan_instrument_member_accesses (tree *t_p)
{
if (cp_ubsan_instrument_vptr_p (NULL_TREE))
{
hash_set<tree> pset;
cp_ubsan_check_member_access_data ucmd;
ucmd.pset = &pset;
ucmd.is_addr = false;
cp_walk_tree (t_p, cp_ubsan_check_member_access_r, &ucmd, &pset);
}
}
static void
cp_genericize_tree (tree* t_p)
{
struct cp_genericize_data wtd;
wtd.p_set = pointer_set_create ();
wtd.bind_expr_stack.create (0);
wtd.omp_ctx = NULL;
cp_walk_tree (t_p, cp_genericize_r, &wtd, NULL);
pointer_set_destroy (wtd.p_set);
wtd.bind_expr_stack.release ();
}
static void
genericize_switch_stmt (tree *stmt_p, int *walk_subtrees, void *data)
{
tree stmt = *stmt_p;
tree break_block, body, cond, type;
location_t stmt_locus = EXPR_LOCATION (stmt);
break_block = begin_bc_block (bc_break, stmt_locus);
body = SWITCH_STMT_BODY (stmt);
if (!body)
body = build_empty_stmt (stmt_locus);
cond = SWITCH_STMT_COND (stmt);
type = SWITCH_STMT_TYPE (stmt);
cp_walk_tree (&body, cp_genericize_r, data, NULL);
cp_walk_tree (&cond, cp_genericize_r, data, NULL);
cp_walk_tree (&type, cp_genericize_r, data, NULL);
*walk_subtrees = 0;
*stmt_p = build3_loc (stmt_locus, SWITCH_EXPR, type, cond, body, NULL_TREE);
finish_bc_block (stmt_p, bc_break, break_block);
}
static tree
replace_invariant_exprs (tree *node)
{
size_t ix = 0;
tree node_list = NULL_TREE;
tree t = NULL_TREE, new_var = NULL_TREE;
struct inv_list data;
data.list_values = NULL;
data.replacement = NULL;
data.additional_tcodes = NULL;
cp_walk_tree (node, find_inv_trees, (void *) &data, NULL);
if (vec_safe_length (data.list_values))
{
node_list = push_stmt_list ();
for (ix = 0; vec_safe_iterate (data.list_values, ix, &t); ix++)
{
/* Sometimes, when comma_expr has a function call in it, it will
typecast it to void. Find_inv_trees finds those nodes and so
if it void type, then don't bother creating a new var to hold
the return value. */
if (VOID_TYPE_P (TREE_TYPE (t)))
{
finish_expr_stmt (t);
new_var = void_node;
}
else
new_var = get_temp_regvar (TREE_TYPE (t), t);
vec_safe_push (data.replacement, new_var);
}
cp_walk_tree (node, replace_inv_trees, (void *) &data, NULL);
node_list = pop_stmt_list (node_list);
}
return node_list;
}
void
cp_genericize (tree fndecl)
{
tree t;
struct pointer_set_t *p_set;
/* Fix up the types of parms passed by invisible reference. */
for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
if (TREE_ADDRESSABLE (TREE_TYPE (t)))
{
/* If a function's arguments are copied to create a thunk,
then DECL_BY_REFERENCE will be set -- but the type of the
argument will be a pointer type, so we will never get
here. */
gcc_assert (!DECL_BY_REFERENCE (t));
gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
TREE_TYPE (t) = DECL_ARG_TYPE (t);
DECL_BY_REFERENCE (t) = 1;
TREE_ADDRESSABLE (t) = 0;
relayout_decl (t);
}
/* Do the same for the return value. */
if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl))))
{
t = DECL_RESULT (fndecl);
TREE_TYPE (t) = build_reference_type (TREE_TYPE (t));
DECL_BY_REFERENCE (t) = 1;
TREE_ADDRESSABLE (t) = 0;
relayout_decl (t);
}
/* If we're a clone, the body is already GIMPLE. */
if (DECL_CLONED_FUNCTION_P (fndecl))
return;
/* We do want to see every occurrence of the parms, so we can't just use
walk_tree's hash functionality. */
p_set = pointer_set_create ();
cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, p_set, NULL);
pointer_set_destroy (p_set);
/* Do everything else. */
c_genericize (fndecl);
gcc_assert (bc_label[bc_break] == NULL);
gcc_assert (bc_label[bc_continue] == NULL);
}
static void
genericize_for_stmt (tree *stmt_p, int *walk_subtrees, void *data)
{
tree stmt = *stmt_p;
tree expr = NULL;
tree loop;
tree init = FOR_INIT_STMT (stmt);
if (init)
{
cp_walk_tree (&init, cp_genericize_r, data, NULL);
append_to_statement_list (init, &expr);
}
genericize_cp_loop (&loop, EXPR_LOCATION (stmt), FOR_COND (stmt),
FOR_BODY (stmt), FOR_EXPR (stmt), 1, walk_subtrees, data);
append_to_statement_list (loop, &expr);
*stmt_p = expr;
}
static bool
cp_ubsan_maybe_instrument_member_access
(tree stmt, cp_ubsan_check_member_access_data *ucmd)
{
if (DECL_ARTIFICIAL (TREE_OPERAND (stmt, 1)))
return false;
tree base = TREE_OPERAND (stmt, 0);
if (!cp_ubsan_instrument_vptr_p (TREE_TYPE (base)))
return false;
cp_walk_tree (&base, cp_ubsan_check_member_access_r, ucmd, ucmd->pset);
base = cp_ubsan_instrument_vptr (EXPR_LOCATION (stmt), base,
TREE_TYPE (base), false,
UBSAN_MEMBER_ACCESS);
TREE_OPERAND (stmt, 0)
= build_fold_indirect_ref_loc (EXPR_LOCATION (stmt), base);
return true;
}
static void
genericize_omp_for_stmt (tree *stmt_p, int *walk_subtrees, void *data)
{
tree stmt = *stmt_p;
location_t locus = EXPR_LOCATION (stmt);
tree clab = begin_bc_block (bc_continue, locus);
cp_walk_tree (&OMP_FOR_BODY (stmt), cp_genericize_r, data, NULL);
cp_walk_tree (&OMP_FOR_CLAUSES (stmt), cp_genericize_r, data, NULL);
cp_walk_tree (&OMP_FOR_INIT (stmt), cp_genericize_r, data, NULL);
cp_walk_tree (&OMP_FOR_COND (stmt), cp_genericize_r, data, NULL);
cp_walk_tree (&OMP_FOR_INCR (stmt), cp_genericize_r, data, NULL);
cp_walk_tree (&OMP_FOR_PRE_BODY (stmt), cp_genericize_r, data, NULL);
*walk_subtrees = 0;
finish_bc_block (&OMP_FOR_BODY (stmt), bc_continue, clab);
}
static tree
cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
{
tree stmt = *stmt_p;
struct pointer_set_t *p_set = (struct pointer_set_t*) data;
if (is_invisiref_parm (stmt)
/* Don't dereference parms in a thunk, pass the references through. */
&& !(DECL_THUNK_P (current_function_decl)
&& TREE_CODE (stmt) == PARM_DECL))
{
*stmt_p = convert_from_reference (stmt);
*walk_subtrees = 0;
return NULL;
}
/* Map block scope extern declarations to visible declarations with the
same name and type in outer scopes if any. */
if (cp_function_chain->extern_decl_map
&& (TREE_CODE (stmt) == FUNCTION_DECL || TREE_CODE (stmt) == VAR_DECL)
&& DECL_EXTERNAL (stmt))
{
struct cxx_int_tree_map *h, in;
in.uid = DECL_UID (stmt);
h = (struct cxx_int_tree_map *)
htab_find_with_hash (cp_function_chain->extern_decl_map,
&in, in.uid);
if (h)
{
*stmt_p = h->to;
*walk_subtrees = 0;
return NULL;
}
}
/* Other than invisiref parms, don't walk the same tree twice. */
if (pointer_set_contains (p_set, stmt))
{
*walk_subtrees = 0;
return NULL_TREE;
}
if (TREE_CODE (stmt) == ADDR_EXPR
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
{
*stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
/* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR. */
*walk_subtrees = 0;
else if (TREE_CODE (stmt) == OMP_CLAUSE)
switch (OMP_CLAUSE_CODE (stmt))
{
case OMP_CLAUSE_LASTPRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
{
*walk_subtrees = 0;
if (OMP_CLAUSE_LASTPRIVATE_STMT (stmt))
cp_walk_tree (&OMP_CLAUSE_LASTPRIVATE_STMT (stmt),
cp_genericize_r, p_set, NULL);
}
break;
case OMP_CLAUSE_PRIVATE:
case OMP_CLAUSE_SHARED:
case OMP_CLAUSE_FIRSTPRIVATE:
case OMP_CLAUSE_COPYIN:
case OMP_CLAUSE_COPYPRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
*walk_subtrees = 0;
break;
case OMP_CLAUSE_REDUCTION:
gcc_assert (!is_invisiref_parm (OMP_CLAUSE_DECL (stmt)));
break;
default:
break;
}
else if (IS_TYPE_OR_DECL_P (stmt))
*walk_subtrees = 0;
/* Due to the way voidify_wrapper_expr is written, we don't get a chance
to lower this construct before scanning it, so we need to lower these
before doing anything else. */
else if (TREE_CODE (stmt) == CLEANUP_STMT)
*stmt_p = build2 (CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR,
void_type_node,
CLEANUP_BODY (stmt),
CLEANUP_EXPR (stmt));
else if (TREE_CODE (stmt) == IF_STMT)
{
genericize_if_stmt (stmt_p);
/* *stmt_p has changed, tail recurse to handle it again. */
return cp_genericize_r (stmt_p, walk_subtrees, data);
}
/* COND_EXPR might have incompatible types in branches if one or both
arms are bitfields. Fix it up now. */
else if (TREE_CODE (stmt) == COND_EXPR)
{
tree type_left
= (TREE_OPERAND (stmt, 1)
? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 1))
: NULL_TREE);
tree type_right
= (TREE_OPERAND (stmt, 2)
? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 2))
: NULL_TREE);
if (type_left
&& !useless_type_conversion_p (TREE_TYPE (stmt),
TREE_TYPE (TREE_OPERAND (stmt, 1))))
{
TREE_OPERAND (stmt, 1)
= fold_convert (type_left, TREE_OPERAND (stmt, 1));
gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
type_left));
}
if (type_right
&& !useless_type_conversion_p (TREE_TYPE (stmt),
TREE_TYPE (TREE_OPERAND (stmt, 2))))
{
TREE_OPERAND (stmt, 2)
= fold_convert (type_right, TREE_OPERAND (stmt, 2));
gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
type_right));
}
}
pointer_set_insert (p_set, *stmt_p);
return NULL;
}
void
gcc_cp_genericize (tree fndecl)
{
register_src_file(fndecl);
tree t;
struct cp_genericize_data wtd;
/* Fix up the types of parms passed by invisible reference. */
for (t = DECL_ARGUMENTS (fndecl); t; t = DECL_CHAIN (t))
if (TREE_ADDRESSABLE (TREE_TYPE (t)))
{
/* If a function's arguments are copied to create a thunk,
then DECL_BY_REFERENCE will be set -- but the type of the
argument will be a pointer type, so we will never get
here. */
gcc_assert (!DECL_BY_REFERENCE (t));
gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
TREE_TYPE (t) = DECL_ARG_TYPE (t);
DECL_BY_REFERENCE (t) = 1;
TREE_ADDRESSABLE (t) = 0;
relayout_decl (t);
}
/* Do the same for the return value. */
if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl))))
{
t = DECL_RESULT (fndecl);
TREE_TYPE (t) = build_reference_type (TREE_TYPE (t));
DECL_BY_REFERENCE (t) = 1;
TREE_ADDRESSABLE (t) = 0;
relayout_decl (t);
if (DECL_NAME (t))
{
/* Adjust DECL_VALUE_EXPR of the original var. */
tree outer = outer_curly_brace_block (current_function_decl);
tree var;
if (outer)
for (var = BLOCK_VARS (outer); var; var = DECL_CHAIN (var))
if (DECL_NAME (t) == DECL_NAME (var)
&& DECL_HAS_VALUE_EXPR_P (var)
&& DECL_VALUE_EXPR (var) == t)
{
tree val = convert_from_reference (t);
SET_DECL_VALUE_EXPR (var, val);
break;
}
}
}
/* If we're a clone, the body is already GIMPLE. */
if (DECL_CLONED_FUNCTION_P (fndecl))
return;
/* We do want to see every occurrence of the parms, so we can't just use
walk_tree's hash functionality. */
wtd.p_set = pointer_set_create ();
wtd.bind_expr_stack = NULL;
cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, &wtd, NULL);
pointer_set_destroy (wtd.p_set);
VEC_free (tree, heap, wtd.bind_expr_stack);
/* Do everything else. */
gcc_genericize (fndecl);
gcc_assert (bc_label[bc_break] == NULL);
gcc_assert (bc_label[bc_continue] == NULL);
}
static tree
cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
{
tree stmt = *stmt_p;
struct cp_genericize_data *wtd = (struct cp_genericize_data *) data;
struct pointer_set_t *p_set = wtd->p_set;
if (is_invisiref_parm (stmt)
/* Don't dereference parms in a thunk, pass the references through. */
&& !(DECL_THUNK_P (current_function_decl)
&& TREE_CODE (stmt) == PARM_DECL))
{
*stmt_p = convert_from_reference (stmt);
*walk_subtrees = 0;
return NULL;
}
/* Map block scope extern declarations to visible declarations with the
same name and type in outer scopes if any. */
if (cp_function_chain->extern_decl_map
&& (TREE_CODE (stmt) == FUNCTION_DECL || TREE_CODE (stmt) == VAR_DECL)
&& DECL_EXTERNAL (stmt))
{
struct cxx_int_tree_map *h, in;
in.uid = DECL_UID (stmt);
h = (struct cxx_int_tree_map *)
htab_find_with_hash (cp_function_chain->extern_decl_map,
&in, in.uid);
if (h)
{
*stmt_p = h->to;
*walk_subtrees = 0;
return NULL;
}
}
/* Other than invisiref parms, don't walk the same tree twice. */
if (pointer_set_contains (p_set, stmt))
{
*walk_subtrees = 0;
return NULL_TREE;
}
if (TREE_CODE (stmt) == ADDR_EXPR
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
{
*stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
/* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR. */
*walk_subtrees = 0;
else if (TREE_CODE (stmt) == OMP_CLAUSE)
switch (OMP_CLAUSE_CODE (stmt))
{
case OMP_CLAUSE_LASTPRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
{
*walk_subtrees = 0;
if (OMP_CLAUSE_LASTPRIVATE_STMT (stmt))
cp_walk_tree (&OMP_CLAUSE_LASTPRIVATE_STMT (stmt),
cp_genericize_r, data, NULL);
}
break;
case OMP_CLAUSE_PRIVATE:
case OMP_CLAUSE_SHARED:
case OMP_CLAUSE_FIRSTPRIVATE:
case OMP_CLAUSE_COPYIN:
case OMP_CLAUSE_COPYPRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
*walk_subtrees = 0;
break;
case OMP_CLAUSE_REDUCTION:
gcc_assert (!is_invisiref_parm (OMP_CLAUSE_DECL (stmt)));
break;
default:
break;
}
else if (IS_TYPE_OR_DECL_P (stmt))
*walk_subtrees = 0;
/* Due to the way voidify_wrapper_expr is written, we don't get a chance
to lower this construct before scanning it, so we need to lower these
before doing anything else. */
else if (TREE_CODE (stmt) == CLEANUP_STMT)
*stmt_p = build2 (CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR,
void_type_node,
CLEANUP_BODY (stmt),
CLEANUP_EXPR (stmt));
else if (TREE_CODE (stmt) == IF_STMT)
{
genericize_if_stmt (stmt_p);
/* *stmt_p has changed, tail recurse to handle it again. */
return cp_genericize_r (stmt_p, walk_subtrees, data);
}
/* COND_EXPR might have incompatible types in branches if one or both
arms are bitfields.FILE *
my_dump_begin (int phase, int *flag_ptr) Fix it up now. */
else if (TREE_CODE (stmt) == COND_EXPR)
{
tree type_left
= (TREE_OPERAND (stmt, 1)
? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 1))
: NULL_TREE);
tree type_right
= (TREE_OPERAND (stmt, 2)
? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 2))
: NULL_TREE);
if (type_left
&& !useless_type_conversion_p (TREE_TYPE (stmt),
TREE_TYPE (TREE_OPERAND (stmt, 1))))
{
TREE_OPERAND (stmt, 1)
= fold_convert (type_left, TREE_OPERAND (stmt, 1));
gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
type_left));
}
if (type_right
&& !useless_type_conversion_p (TREE_TYPE (stmt),
TREE_TYPE (TREE_OPERAND (stmt, 2))))
{
TREE_OPERAND (stmt, 2)
= fold_convert (type_right, TREE_OPERAND (stmt, 2));
gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
type_right));
}
}
else if (TREE_CODE (stmt) == BIND_EXPR)
{
VEC_safe_push (tree, heap, wtd->bind_expr_stack, stmt);
cp_walk_tree (&BIND_EXPR_BODY (stmt),
cp_genericize_r, data, NULL);
VEC_pop (tree, wtd->bind_expr_stack);
}
else if (TREE_CODE (stmt) == USING_STMT)
{
tree block = NULL_TREE;
/* Get the innermost inclosing GIMPLE_BIND that has a non NULL
BLOCK, and append an IMPORTED_DECL to its
BLOCK_VARS chained list. */
if (wtd->bind_expr_stack)
{
int i;
for (i = VEC_length (tree, wtd->bind_expr_stack) - 1; i >= 0; i--)
if ((block = BIND_EXPR_BLOCK (VEC_index (tree,
wtd->bind_expr_stack, i))))
break;
}
if (block)
{
tree using_directive;
gcc_assert (TREE_OPERAND (stmt, 0));
using_directive = make_node (IMPORTED_DECL);
TREE_TYPE (using_directive) = void_type_node;
IMPORTED_DECL_ASSOCIATED_DECL (using_directive)
= TREE_OPERAND (stmt, 0);
DECL_CHAIN (using_directive) = BLOCK_VARS (block);
BLOCK_VARS (block) = using_directive;
}
/* The USING_STMT won't appear in GENERIC. */
*stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == DECL_EXPR
&& TREE_CODE (DECL_EXPR_DECL (stmt)) == USING_DECL)
{
/* Using decls inside DECL_EXPRs are just dropped on the floor. */
*stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
*walk_subtrees = 0;
}
pointer_set_insert (p_set, *stmt_p);
return NULL;
}
static tree
cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
{
tree stmt = *stmt_p;
struct cp_genericize_data *wtd = (struct cp_genericize_data *) data;
struct pointer_set_t *p_set = wtd->p_set;
/* If in an OpenMP context, note var uses. */
if (__builtin_expect (wtd->omp_ctx != NULL, 0)
&& (VAR_P (stmt)
|| TREE_CODE (stmt) == PARM_DECL
|| TREE_CODE (stmt) == RESULT_DECL)
&& omp_var_to_track (stmt))
omp_cxx_notice_variable (wtd->omp_ctx, stmt);
if (is_invisiref_parm (stmt)
/* Don't dereference parms in a thunk, pass the references through. */
&& !(DECL_THUNK_P (current_function_decl)
&& TREE_CODE (stmt) == PARM_DECL))
{
*stmt_p = convert_from_reference (stmt);
*walk_subtrees = 0;
return NULL;
}
/* Map block scope extern declarations to visible declarations with the
same name and type in outer scopes if any. */
if (cp_function_chain->extern_decl_map
&& VAR_OR_FUNCTION_DECL_P (stmt)
&& DECL_EXTERNAL (stmt))
{
struct cxx_int_tree_map *h, in;
in.uid = DECL_UID (stmt);
h = (struct cxx_int_tree_map *)
htab_find_with_hash (cp_function_chain->extern_decl_map,
&in, in.uid);
if (h)
{
*stmt_p = h->to;
*walk_subtrees = 0;
return NULL;
}
}
/* Other than invisiref parms, don't walk the same tree twice. */
if (pointer_set_contains (p_set, stmt))
{
*walk_subtrees = 0;
return NULL_TREE;
}
if (TREE_CODE (stmt) == ADDR_EXPR
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
{
/* If in an OpenMP context, note var uses. */
if (__builtin_expect (wtd->omp_ctx != NULL, 0)
&& omp_var_to_track (TREE_OPERAND (stmt, 0)))
omp_cxx_notice_variable (wtd->omp_ctx, TREE_OPERAND (stmt, 0));
*stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
/* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR. */
*walk_subtrees = 0;
else if (TREE_CODE (stmt) == OMP_CLAUSE)
switch (OMP_CLAUSE_CODE (stmt))
{
case OMP_CLAUSE_LASTPRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
{
*walk_subtrees = 0;
if (OMP_CLAUSE_LASTPRIVATE_STMT (stmt))
cp_walk_tree (&OMP_CLAUSE_LASTPRIVATE_STMT (stmt),
cp_genericize_r, data, NULL);
}
break;
case OMP_CLAUSE_PRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
*walk_subtrees = 0;
else if (wtd->omp_ctx != NULL)
{
/* Private clause doesn't cause any references to the
var in outer contexts, avoid calling
omp_cxx_notice_variable for it. */
struct cp_genericize_omp_taskreg *old = wtd->omp_ctx;
wtd->omp_ctx = NULL;
cp_walk_tree (&OMP_CLAUSE_DECL (stmt), cp_genericize_r,
data, NULL);
wtd->omp_ctx = old;
*walk_subtrees = 0;
}
break;
case OMP_CLAUSE_SHARED:
case OMP_CLAUSE_FIRSTPRIVATE:
case OMP_CLAUSE_COPYIN:
case OMP_CLAUSE_COPYPRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
*walk_subtrees = 0;
break;
case OMP_CLAUSE_REDUCTION:
/* Don't dereference an invisiref in reduction clause's
OMP_CLAUSE_DECL either. OMP_CLAUSE_REDUCTION_{INIT,MERGE}
still needs to be genericized. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
{
*walk_subtrees = 0;
if (OMP_CLAUSE_REDUCTION_INIT (stmt))
cp_walk_tree (&OMP_CLAUSE_REDUCTION_INIT (stmt),
cp_genericize_r, data, NULL);
if (OMP_CLAUSE_REDUCTION_MERGE (stmt))
cp_walk_tree (&OMP_CLAUSE_REDUCTION_MERGE (stmt),
cp_genericize_r, data, NULL);
}
break;
default:
break;
}
else if (IS_TYPE_OR_DECL_P (stmt))
*walk_subtrees = 0;
/* Due to the way voidify_wrapper_expr is written, we don't get a chance
to lower this construct before scanning it, so we need to lower these
before doing anything else. */
else if (TREE_CODE (stmt) == CLEANUP_STMT)
*stmt_p = build2_loc (EXPR_LOCATION (stmt),
CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR,
void_type_node,
CLEANUP_BODY (stmt),
CLEANUP_EXPR (stmt));
else if (TREE_CODE (stmt) == IF_STMT)
{
genericize_if_stmt (stmt_p);
/* *stmt_p has changed, tail recurse to handle it again. */
return cp_genericize_r (stmt_p, walk_subtrees, data);
}
/* COND_EXPR might have incompatible types in branches if one or both
arms are bitfields. Fix it up now. */
else if (TREE_CODE (stmt) == COND_EXPR)
{
tree type_left
= (TREE_OPERAND (stmt, 1)
? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 1))
: NULL_TREE);
tree type_right
= (TREE_OPERAND (stmt, 2)
? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 2))
: NULL_TREE);
if (type_left
&& !useless_type_conversion_p (TREE_TYPE (stmt),
TREE_TYPE (TREE_OPERAND (stmt, 1))))
{
TREE_OPERAND (stmt, 1)
= fold_convert (type_left, TREE_OPERAND (stmt, 1));
gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
type_left));
}
if (type_right
&& !useless_type_conversion_p (TREE_TYPE (stmt),
TREE_TYPE (TREE_OPERAND (stmt, 2))))
{
TREE_OPERAND (stmt, 2)
= fold_convert (type_right, TREE_OPERAND (stmt, 2));
gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
type_right));
}
}
else if (TREE_CODE (stmt) == BIND_EXPR)
{
if (__builtin_expect (wtd->omp_ctx != NULL, 0))
{
tree decl;
for (decl = BIND_EXPR_VARS (stmt); decl; decl = DECL_CHAIN (decl))
if (VAR_P (decl)
&& !DECL_EXTERNAL (decl)
&& omp_var_to_track (decl))
{
splay_tree_node n
= splay_tree_lookup (wtd->omp_ctx->variables,
(splay_tree_key) decl);
if (n == NULL)
splay_tree_insert (wtd->omp_ctx->variables,
(splay_tree_key) decl,
TREE_STATIC (decl)
? OMP_CLAUSE_DEFAULT_SHARED
: OMP_CLAUSE_DEFAULT_PRIVATE);
}
}
wtd->bind_expr_stack.safe_push (stmt);
cp_walk_tree (&BIND_EXPR_BODY (stmt),
cp_genericize_r, data, NULL);
wtd->bind_expr_stack.pop ();
}
else if (TREE_CODE (stmt) == USING_STMT)
{
tree block = NULL_TREE;
/* Get the innermost inclosing GIMPLE_BIND that has a non NULL
BLOCK, and append an IMPORTED_DECL to its
BLOCK_VARS chained list. */
if (wtd->bind_expr_stack.exists ())
{
int i;
for (i = wtd->bind_expr_stack.length () - 1; i >= 0; i--)
if ((block = BIND_EXPR_BLOCK (wtd->bind_expr_stack[i])))
break;
}
if (block)
{
tree using_directive;
gcc_assert (TREE_OPERAND (stmt, 0));
using_directive = make_node (IMPORTED_DECL);
TREE_TYPE (using_directive) = void_type_node;
IMPORTED_DECL_ASSOCIATED_DECL (using_directive)
= TREE_OPERAND (stmt, 0);
DECL_CHAIN (using_directive) = BLOCK_VARS (block);
BLOCK_VARS (block) = using_directive;
}
/* The USING_STMT won't appear in GENERIC. */
*stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == DECL_EXPR
&& TREE_CODE (DECL_EXPR_DECL (stmt)) == USING_DECL)
{
/* Using decls inside DECL_EXPRs are just dropped on the floor. */
*stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == OMP_PARALLEL || TREE_CODE (stmt) == OMP_TASK)
{
struct cp_genericize_omp_taskreg omp_ctx;
tree c, decl;
splay_tree_node n;
*walk_subtrees = 0;
cp_walk_tree (&OMP_CLAUSES (stmt), cp_genericize_r, data, NULL);
omp_ctx.is_parallel = TREE_CODE (stmt) == OMP_PARALLEL;
omp_ctx.default_shared = omp_ctx.is_parallel;
omp_ctx.outer = wtd->omp_ctx;
omp_ctx.variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
wtd->omp_ctx = &omp_ctx;
for (c = OMP_CLAUSES (stmt); c; c = OMP_CLAUSE_CHAIN (c))
switch (OMP_CLAUSE_CODE (c))
{
case OMP_CLAUSE_SHARED:
case OMP_CLAUSE_PRIVATE:
case OMP_CLAUSE_FIRSTPRIVATE:
case OMP_CLAUSE_LASTPRIVATE:
decl = OMP_CLAUSE_DECL (c);
if (decl == error_mark_node || !omp_var_to_track (decl))
break;
n = splay_tree_lookup (omp_ctx.variables, (splay_tree_key) decl);
if (n != NULL)
break;
splay_tree_insert (omp_ctx.variables, (splay_tree_key) decl,
OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
? OMP_CLAUSE_DEFAULT_SHARED
: OMP_CLAUSE_DEFAULT_PRIVATE);
if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_PRIVATE
&& omp_ctx.outer)
omp_cxx_notice_variable (omp_ctx.outer, decl);
break;
case OMP_CLAUSE_DEFAULT:
if (OMP_CLAUSE_DEFAULT_KIND (c) == OMP_CLAUSE_DEFAULT_SHARED)
omp_ctx.default_shared = true;
default:
break;
}
cp_walk_tree (&OMP_BODY (stmt), cp_genericize_r, data, NULL);
wtd->omp_ctx = omp_ctx.outer;
splay_tree_delete (omp_ctx.variables);
}
else if (TREE_CODE (stmt) == CONVERT_EXPR)
gcc_assert (!CONVERT_EXPR_VBASE_PATH (stmt));
else if (TREE_CODE (stmt) == FOR_STMT)
genericize_for_stmt (stmt_p, walk_subtrees, data);
else if (TREE_CODE (stmt) == WHILE_STMT)
genericize_while_stmt (stmt_p, walk_subtrees, data);
else if (TREE_CODE (stmt) == DO_STMT)
genericize_do_stmt (stmt_p, walk_subtrees, data);
else if (TREE_CODE (stmt) == SWITCH_STMT)
genericize_switch_stmt (stmt_p, walk_subtrees, data);
else if (TREE_CODE (stmt) == CONTINUE_STMT)
genericize_continue_stmt (stmt_p);
else if (TREE_CODE (stmt) == BREAK_STMT)
genericize_break_stmt (stmt_p);
else if (TREE_CODE (stmt) == OMP_FOR
|| TREE_CODE (stmt) == OMP_SIMD
|| TREE_CODE (stmt) == OMP_DISTRIBUTE)
genericize_omp_for_stmt (stmt_p, walk_subtrees, data);
else if (TREE_CODE (stmt) == SIZEOF_EXPR)
{
if (SIZEOF_EXPR_TYPE_P (stmt))
*stmt_p
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (stmt, 0)),
SIZEOF_EXPR, false);
else if (TYPE_P (TREE_OPERAND (stmt, 0)))
*stmt_p = cxx_sizeof_or_alignof_type (TREE_OPERAND (stmt, 0),
SIZEOF_EXPR, false);
else
*stmt_p = cxx_sizeof_or_alignof_expr (TREE_OPERAND (stmt, 0),
SIZEOF_EXPR, false);
if (*stmt_p == error_mark_node)
*stmt_p = size_one_node;
return NULL;
}
pointer_set_insert (p_set, *stmt_p);
return NULL;
}
static void
genericize_cp_loop (tree *stmt_p, location_t start_locus, tree cond, tree body,
tree incr, bool cond_is_first, int *walk_subtrees,
void *data)
{
tree blab, clab;
tree entry = NULL, exit = NULL, t;
tree stmt_list = NULL;
blab = begin_bc_block (bc_break, start_locus);
clab = begin_bc_block (bc_continue, start_locus);
if (incr && EXPR_P (incr))
SET_EXPR_LOCATION (incr, start_locus);
cp_walk_tree (&cond, cp_genericize_r, data, NULL);
cp_walk_tree (&body, cp_genericize_r, data, NULL);
cp_walk_tree (&incr, cp_genericize_r, data, NULL);
*walk_subtrees = 0;
/* If condition is zero don't generate a loop construct. */
if (cond && integer_zerop (cond))
{
if (cond_is_first)
{
t = build1_loc (start_locus, GOTO_EXPR, void_type_node,
get_bc_label (bc_break));
append_to_statement_list (t, &stmt_list);
}
}
else
{
/* Expand to gotos, just like c_finish_loop. TODO: Use LOOP_EXPR. */
tree top = build1 (LABEL_EXPR, void_type_node,
create_artificial_label (start_locus));
/* If we have an exit condition, then we build an IF with gotos either
out of the loop, or to the top of it. If there's no exit condition,
then we just build a jump back to the top. */
exit = build1 (GOTO_EXPR, void_type_node, LABEL_EXPR_LABEL (top));
if (cond && !integer_nonzerop (cond))
{
/* Canonicalize the loop condition to the end. This means
generating a branch to the loop condition. Reuse the
continue label, if possible. */
if (cond_is_first)
{
if (incr)
{
entry = build1 (LABEL_EXPR, void_type_node,
create_artificial_label (start_locus));
t = build1_loc (start_locus, GOTO_EXPR, void_type_node,
LABEL_EXPR_LABEL (entry));
}
else
t = build1_loc (start_locus, GOTO_EXPR, void_type_node,
get_bc_label (bc_continue));
append_to_statement_list (t, &stmt_list);
}
t = build1 (GOTO_EXPR, void_type_node, get_bc_label (bc_break));
exit = fold_build3_loc (start_locus,
COND_EXPR, void_type_node, cond, exit, t);
}
append_to_statement_list (top, &stmt_list);
}
append_to_statement_list (body, &stmt_list);
finish_bc_block (&stmt_list, bc_continue, clab);
append_to_statement_list (incr, &stmt_list);
append_to_statement_list (entry, &stmt_list);
append_to_statement_list (exit, &stmt_list);
finish_bc_block (&stmt_list, bc_break, blab);
if (stmt_list == NULL_TREE)
stmt_list = build1 (NOP_EXPR, void_type_node, integer_zero_node);
*stmt_p = stmt_list;
}
