#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "flags.h"
#include "rtl.h"
#include "tm_p.h"
#include "ggc.h"
#include "langhooks.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "output.h"
#include "errors.h"
#include "expr.h"
#include "function.h"
#include "diagnostic.h"
#include "bitmap.h"
#include "tree-flow.h"
#include "tree-gimple.h"
#include "tree-inline.h"
#include "varray.h"
#include "timevar.h"
#include "hashtab.h"
#include "tree-dump.h"
#include "tree-pass.h"
void
ssa_remove_edge (edge e)
{
tree phi, next;
for (phi = phi_nodes (e->dest); phi; phi = next)
{
next = PHI_CHAIN (phi);
remove_phi_arg (phi, e->src);
}
remove_edge (e);
}
edge
ssa_redirect_edge (edge e, basic_block dest)
{
tree phi, next;
tree list = NULL, *last = &list;
tree src, dst, node;
int i;
for (phi = phi_nodes (e->dest); phi; phi = next)
{
next = PHI_CHAIN (phi);
i = phi_arg_from_edge (phi, e);
if (i < 0)
continue;
src = PHI_ARG_DEF (phi, i);
dst = PHI_RESULT (phi);
node = build_tree_list (dst, src);
*last = node;
last = &TREE_CHAIN (node);
remove_phi_arg_num (phi, i);
}
e = redirect_edge_succ_nodup (e, dest);
PENDING_STMT (e) = list;
return e;
}
void
flush_pending_stmts (edge e)
{
tree phi, arg;
if (!PENDING_STMT (e))
return;
for (phi = phi_nodes (e->dest), arg = PENDING_STMT (e);
phi;
phi = PHI_CHAIN (phi), arg = TREE_CHAIN (arg))
{
tree def = TREE_VALUE (arg);
add_phi_arg (&phi, def, e);
}
PENDING_STMT (e) = NULL;
}
static bool
verify_ssa_name (tree ssa_name, bool is_virtual)
{
TREE_VISITED (ssa_name) = 1;
if (TREE_CODE (ssa_name) != SSA_NAME)
{
error ("Expected an SSA_NAME object");
return true;
}
if (TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
{
error ("Type mismatch between an SSA_NAME and its symbol.");
return true;
}
if (SSA_NAME_IN_FREE_LIST (ssa_name))
{
error ("Found an SSA_NAME that had been released into the free pool");
return true;
}
if (is_virtual && is_gimple_reg (ssa_name))
{
error ("Found a virtual definition for a GIMPLE register");
return true;
}
if (!is_virtual && !is_gimple_reg (ssa_name))
{
error ("Found a real definition for a non-register");
return true;
}
return false;
}
static bool
verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
tree stmt, bool is_virtual)
{
if (verify_ssa_name (ssa_name, is_virtual))
goto err;
if (definition_block[SSA_NAME_VERSION (ssa_name)])
{
error ("SSA_NAME created in two different blocks %i and %i",
definition_block[SSA_NAME_VERSION (ssa_name)]->index, bb->index);
goto err;
}
definition_block[SSA_NAME_VERSION (ssa_name)] = bb;
if (SSA_NAME_DEF_STMT (ssa_name) != stmt)
{
error ("SSA_NAME_DEF_STMT is wrong");
fprintf (stderr, "Expected definition statement:\n");
print_generic_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), TDF_VOPS);
fprintf (stderr, "\nActual definition statement:\n");
print_generic_stmt (stderr, stmt, TDF_VOPS);
goto err;
}
return false;
err:
fprintf (stderr, "while verifying SSA_NAME ");
print_generic_expr (stderr, ssa_name, 0);
fprintf (stderr, " in statement\n");
print_generic_stmt (stderr, stmt, TDF_VOPS);
return true;
}
static bool
verify_use (basic_block bb, basic_block def_bb, tree ssa_name,
tree stmt, bool check_abnormal, bool is_virtual,
bitmap names_defined_in_bb)
{
bool err = false;
err = verify_ssa_name (ssa_name, is_virtual);
if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name))
&& var_ann (SSA_NAME_VAR (ssa_name))->default_def == ssa_name)
;
else if (!def_bb)
{
error ("Missing definition");
err = true;
}
else if (bb != def_bb
&& !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
{
error ("Definition in block %i does not dominate use in block %i",
def_bb->index, bb->index);
err = true;
}
else if (bb == def_bb
&& names_defined_in_bb != NULL
&& !bitmap_bit_p (names_defined_in_bb, SSA_NAME_VERSION (ssa_name)))
{
error ("Definition in block %i follows the use", def_bb->index);
err = true;
}
if (check_abnormal
&& !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
{
error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
err = true;
}
if (err)
{
fprintf (stderr, "for SSA_NAME: ");
print_generic_expr (stderr, ssa_name, TDF_VOPS);
fprintf (stderr, "in statement:\n");
print_generic_stmt (stderr, stmt, TDF_VOPS);
}
return err;
}
static bool
verify_phi_args (tree phi, basic_block bb, basic_block *definition_block)
{
edge e;
bool err = false;
int i, phi_num_args = PHI_NUM_ARGS (phi);
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->preds)
e->aux = (void *) 1;
for (i = 0; i < phi_num_args; i++)
{
tree op = PHI_ARG_DEF (phi, i);
e = PHI_ARG_EDGE (phi, i);
if (TREE_CODE (op) == SSA_NAME)
err = verify_use (e->src, definition_block[SSA_NAME_VERSION (op)], op,
phi, e->flags & EDGE_ABNORMAL,
!is_gimple_reg (PHI_RESULT (phi)),
NULL);
if (e->dest != bb)
{
error ("Wrong edge %d->%d for PHI argument\n",
e->src->index, e->dest->index, bb->index);
err = true;
}
if (e->aux == (void *) 0)
{
error ("PHI argument flowing through dead edge %d->%d\n",
e->src->index, e->dest->index);
err = true;
}
if (e->aux == (void *) 2)
{
error ("PHI argument duplicated for edge %d->%d\n", e->src->index,
e->dest->index);
err = true;
}
if (err)
{
fprintf (stderr, "PHI argument\n");
print_generic_stmt (stderr, op, TDF_VOPS);
goto error;
}
e->aux = (void *) 2;
}
FOR_EACH_EDGE (e, ei, bb->preds)
{
if (e->aux != (void *) 2)
{
error ("No argument flowing through edge %d->%d\n", e->src->index,
e->dest->index);
err = true;
goto error;
}
e->aux = (void *) 0;
}
error:
if (err)
{
fprintf (stderr, "for PHI node\n");
print_generic_stmt (stderr, phi, TDF_VOPS);
}
return err;
}
static void
verify_flow_insensitive_alias_info (void)
{
size_t i;
tree var;
bitmap visited = BITMAP_XMALLOC ();
for (i = 0; i < num_referenced_vars; i++)
{
size_t j;
var_ann_t ann;
varray_type may_aliases;
var = referenced_var (i);
ann = var_ann (var);
may_aliases = ann->may_aliases;
for (j = 0; may_aliases && j < VARRAY_ACTIVE_SIZE (may_aliases); j++)
{
tree alias = VARRAY_TREE (may_aliases, j);
bitmap_set_bit (visited, var_ann (alias)->uid);
if (!may_be_aliased (alias))
{
error ("Non-addressable variable inside an alias set.");
debug_variable (alias);
goto err;
}
}
}
for (i = 0; i < num_referenced_vars; i++)
{
var_ann_t ann;
var = referenced_var (i);
ann = var_ann (var);
if (ann->mem_tag_kind == NOT_A_TAG
&& ann->is_alias_tag
&& !bitmap_bit_p (visited, ann->uid))
{
error ("Addressable variable that is an alias tag but is not in any alias set.");
goto err;
}
}
BITMAP_XFREE (visited);
return;
err:
debug_variable (var);
internal_error ("verify_flow_insensitive_alias_info failed.");
}
static void
verify_flow_sensitive_alias_info (void)
{
size_t i;
tree ptr;
for (i = 1; i < num_ssa_names; i++)
{
var_ann_t ann;
struct ptr_info_def *pi;
ptr = ssa_name (i);
if (!ptr)
continue;
ann = var_ann (SSA_NAME_VAR (ptr));
pi = SSA_NAME_PTR_INFO (ptr);
if (!TREE_VISITED (ptr) || !POINTER_TYPE_P (TREE_TYPE (ptr)))
continue;
if (TREE_CODE (SSA_NAME_VAR (ptr)) == RESULT_DECL
&& is_gimple_reg (ptr))
continue;
if (pi == NULL)
continue;
if (pi->is_dereferenced && !pi->name_mem_tag && !ann->type_mem_tag)
{
error ("Dereferenced pointers should have a name or a type tag");
goto err;
}
if (pi->name_mem_tag
&& !pi->pt_malloc
&& (pi->pt_vars == NULL
|| bitmap_first_set_bit (pi->pt_vars) < 0))
{
error ("Pointers with a memory tag, should have points-to sets or point to malloc");
goto err;
}
if (pi->value_escapes_p
&& pi->name_mem_tag
&& !is_call_clobbered (pi->name_mem_tag))
{
error ("Pointer escapes but its name tag is not call-clobbered.");
goto err;
}
}
return;
err:
debug_variable (ptr);
internal_error ("verify_flow_sensitive_alias_info failed.");
}
DEF_VEC_MALLOC_P (bitmap);
static void
verify_name_tags (void)
{
size_t i;
size_t j;
bitmap first, second;
VEC (tree) *name_tag_reps = NULL;
VEC (bitmap) *pt_vars_for_reps = NULL;
for (i = 0; i < num_ssa_names; i++)
{
if (ssa_name (i))
{
tree ptr = ssa_name (i);
struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr);
if (!TREE_VISITED (ptr)
|| !POINTER_TYPE_P (TREE_TYPE (ptr))
|| !pi
|| !pi->name_mem_tag
|| TREE_VISITED (pi->name_mem_tag))
continue;
TREE_VISITED (pi->name_mem_tag) = 1;
if (pi->pt_vars != NULL)
{
VEC_safe_push (tree, name_tag_reps, ptr);
VEC_safe_push (bitmap, pt_vars_for_reps, pi->pt_vars);
}
}
}
for (i = 0; VEC_iterate (bitmap, pt_vars_for_reps, i, first); i++)
{
for (j = i + 1; VEC_iterate (bitmap, pt_vars_for_reps, j, second); j++)
{
if (bitmap_equal_p (first, second))
{
error ("Two different pointers with identical points-to sets but different name tags");
debug_variable (VEC_index (tree, name_tag_reps, j));
goto err;
}
}
}
for (i = 0; i < num_ssa_names; i++)
{
if (ssa_name (i))
{
tree ptr = ssa_name (i);
struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr);
if (!TREE_VISITED (ptr)
|| !POINTER_TYPE_P (TREE_TYPE (ptr))
|| !pi
|| !pi->name_mem_tag)
continue;
TREE_VISITED (pi->name_mem_tag) = 0;
}
}
VEC_free (bitmap, pt_vars_for_reps);
return;
err:
debug_variable (VEC_index (tree, name_tag_reps, i));
internal_error ("verify_name_tags failed");
}
static void
verify_alias_info (void)
{
verify_flow_sensitive_alias_info ();
verify_name_tags ();
verify_flow_insensitive_alias_info ();
}
void
verify_ssa (void)
{
size_t i;
basic_block bb;
basic_block *definition_block = xcalloc (num_ssa_names, sizeof (basic_block));
ssa_op_iter iter;
tree op;
enum dom_state orig_dom_state = dom_computed[CDI_DOMINATORS];
bitmap names_defined_in_bb = BITMAP_XMALLOC ();
timevar_push (TV_TREE_SSA_VERIFY);
for (i = 1; i < num_ssa_names; i++)
if (ssa_name (i))
TREE_VISITED (ssa_name (i)) = 0;
calculate_dominance_info (CDI_DOMINATORS);
FOR_EACH_BB (bb)
{
tree phi;
block_stmt_iterator bsi;
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
{
int i;
if (verify_def (bb, definition_block, PHI_RESULT (phi), phi,
!is_gimple_reg (PHI_RESULT (phi))))
goto err;
for (i = 0; i < PHI_NUM_ARGS (phi); i++)
{
tree def = PHI_ARG_DEF (phi, i);
if (TREE_CODE (def) != SSA_NAME && !is_gimple_min_invariant (def))
{
error ("PHI argument is not SSA_NAME, or invariant");
print_generic_stmt (stderr, phi, TDF_VOPS);
goto err;
}
}
}
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt;
stmt = bsi_stmt (bsi);
get_stmt_operands (stmt);
if (stmt_ann (stmt)->makes_aliased_stores
&& NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) == 0)
{
error ("Statement makes aliased stores, but has no V_MAY_DEFS");
print_generic_stmt (stderr, stmt, TDF_VOPS);
goto err;
}
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_DEFS)
{
if (verify_def (bb, definition_block, op, stmt, true))
goto err;
}
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
{
if (verify_def (bb, definition_block, op, stmt, false))
goto err;
}
}
}
FOR_EACH_BB (bb)
{
edge e;
tree phi;
edge_iterator ei;
block_stmt_iterator bsi;
FOR_EACH_EDGE (e, ei, bb->preds)
{
if (e->aux)
{
error ("AUX pointer initialized for edge %d->%d\n", e->src->index,
e->dest->index);
goto err;
}
}
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
{
if (verify_phi_args (phi, bb, definition_block))
goto err;
bitmap_set_bit (names_defined_in_bb,
SSA_NAME_VERSION (PHI_RESULT (phi)));
}
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_KILLS)
{
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
op, stmt, false, true,
names_defined_in_bb))
goto err;
}
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
{
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
op, stmt, false, false,
names_defined_in_bb))
goto err;
}
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
{
bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op));
}
}
FOR_EACH_EDGE (e, ei, bb->succs)
{
for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi))
{
bool virtual = !is_gimple_reg (PHI_RESULT (phi));
op = PHI_ARG_DEF_FROM_EDGE (phi, e);
if (TREE_CODE (op) != SSA_NAME)
continue;
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
op, phi, false, virtual,
names_defined_in_bb))
goto err;
}
}
bitmap_clear (names_defined_in_bb);
}
verify_alias_info ();
free (definition_block);
if (orig_dom_state == DOM_NONE)
free_dominance_info (CDI_DOMINATORS);
else
dom_computed[CDI_DOMINATORS] = orig_dom_state;
BITMAP_XFREE (names_defined_in_bb);
timevar_pop (TV_TREE_SSA_VERIFY);
return;
err:
internal_error ("verify_ssa failed.");
}
void
init_tree_ssa (void)
{
VARRAY_TREE_INIT (referenced_vars, 20, "referenced_vars");
call_clobbered_vars = BITMAP_XMALLOC ();
addressable_vars = BITMAP_XMALLOC ();
init_ssa_operands ();
init_ssanames ();
init_phinodes ();
global_var = NULL_TREE;
}
void
delete_tree_ssa (void)
{
size_t i;
basic_block bb;
block_stmt_iterator bsi;
FOR_EACH_BB (bb)
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
release_defs (stmt);
ggc_free (stmt->common.ann);
stmt->common.ann = NULL;
}
if (referenced_vars)
{
for (i = 0; i < num_referenced_vars; i++)
{
tree var = referenced_var (i);
ggc_free (var->common.ann);
var->common.ann = NULL;
}
referenced_vars = NULL;
}
fini_ssanames ();
fini_phinodes ();
fini_ssa_operands ();
global_var = NULL_TREE;
BITMAP_XFREE (call_clobbered_vars);
call_clobbered_vars = NULL;
BITMAP_XFREE (addressable_vars);
addressable_vars = NULL;
}
bool
tree_ssa_useless_type_conversion_1 (tree outer_type, tree inner_type)
{
if (inner_type == outer_type
|| (lang_hooks.types_compatible_p (inner_type, outer_type)))
return true;
else if (POINTER_TYPE_P (inner_type)
&& POINTER_TYPE_P (outer_type)
&& TREE_CODE (TREE_TYPE (outer_type)) == VOID_TYPE)
return true;
else if (POINTER_TYPE_P (inner_type)
&& POINTER_TYPE_P (outer_type)
&& lang_hooks.types_compatible_p (TREE_TYPE (inner_type),
TREE_TYPE (outer_type)))
return true;
else if (INTEGRAL_TYPE_P (inner_type)
&& INTEGRAL_TYPE_P (outer_type)
&& TYPE_MODE (inner_type) == TYPE_MODE (outer_type)
&& TYPE_UNSIGNED (inner_type) == TYPE_UNSIGNED (outer_type)
&& TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type))
{
bool first_boolean = (TREE_CODE (inner_type) == BOOLEAN_TYPE);
bool second_boolean = (TREE_CODE (outer_type) == BOOLEAN_TYPE);
if (first_boolean == second_boolean)
return true;
}
else if (TREE_CODE (inner_type) == COMPLEX_TYPE
&& TREE_CODE (outer_type) == COMPLEX_TYPE
&& tree_ssa_useless_type_conversion_1 (TREE_TYPE (outer_type),
TREE_TYPE (inner_type)))
return true;
return false;
}
bool
tree_ssa_useless_type_conversion (tree expr)
{
if (TREE_CODE (expr) == NOP_EXPR || TREE_CODE (expr) == CONVERT_EXPR
|| TREE_CODE (expr) == VIEW_CONVERT_EXPR
|| TREE_CODE (expr) == NON_LVALUE_EXPR)
return tree_ssa_useless_type_conversion_1 (TREE_TYPE (expr),
TREE_TYPE (TREE_OPERAND (expr,
0)));
return false;
}
static bool
walk_use_def_chains_1 (tree var, walk_use_def_chains_fn fn, void *data,
bitmap visited, bool is_dfs)
{
tree def_stmt;
if (bitmap_bit_p (visited, SSA_NAME_VERSION (var)))
return false;
bitmap_set_bit (visited, SSA_NAME_VERSION (var));
def_stmt = SSA_NAME_DEF_STMT (var);
if (TREE_CODE (def_stmt) != PHI_NODE)
{
return fn (var, def_stmt, data);
}
else
{
int i;
if (!is_dfs)
for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
if (fn (PHI_ARG_DEF (def_stmt, i), def_stmt, data))
return true;
for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
{
tree arg = PHI_ARG_DEF (def_stmt, i);
if (TREE_CODE (arg) == SSA_NAME
&& walk_use_def_chains_1 (arg, fn, data, visited, is_dfs))
return true;
}
if (is_dfs)
for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
if (fn (PHI_ARG_DEF (def_stmt, i), def_stmt, data))
return true;
}
return false;
}
void
walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
bool is_dfs)
{
tree def_stmt;
gcc_assert (TREE_CODE (var) == SSA_NAME);
def_stmt = SSA_NAME_DEF_STMT (var);
if (TREE_CODE (def_stmt) != PHI_NODE)
(*fn) (var, def_stmt, data);
else
{
bitmap visited = BITMAP_XMALLOC ();
walk_use_def_chains_1 (var, fn, data, visited, is_dfs);
BITMAP_XFREE (visited);
}
}
static void
propagate_into_addr (tree stmt, tree var, tree *x, tree repl)
{
tree new_var, ass_stmt, addr_var;
basic_block bb;
block_stmt_iterator bsi;
if (TREE_CODE (repl) != ADDR_EXPR)
return;
addr_var = TREE_OPERAND (repl, 0);
while (handled_component_p (*x)
|| TREE_CODE (*x) == REALPART_EXPR
|| TREE_CODE (*x) == IMAGPART_EXPR)
x = &TREE_OPERAND (*x, 0);
if (TREE_CODE (*x) != INDIRECT_REF
|| TREE_OPERAND (*x, 0) != var)
return;
if (TREE_TYPE (*x) == TREE_TYPE (addr_var))
{
*x = addr_var;
mark_new_vars_to_rename (stmt, vars_to_rename);
return;
}
ass_stmt = build2 (MODIFY_EXPR, void_type_node, NULL_TREE, repl);
new_var = duplicate_ssa_name (var, ass_stmt);
TREE_OPERAND (*x, 0) = new_var;
TREE_OPERAND (ass_stmt, 0) = new_var;
bb = bb_for_stmt (stmt);
tree_block_label (bb);
bsi = bsi_after_labels (bb);
bsi_insert_after (&bsi, ass_stmt, BSI_NEW_STMT);
mark_new_vars_to_rename (stmt, vars_to_rename);
}
static void
replace_immediate_uses (tree var, tree repl)
{
int i, j, n;
dataflow_t df;
tree stmt;
bool mark_new_vars;
ssa_op_iter iter;
use_operand_p use_p;
df = get_immediate_uses (SSA_NAME_DEF_STMT (var));
n = num_immediate_uses (df);
for (i = 0; i < n; i++)
{
stmt = immediate_use (df, i);
if (TREE_CODE (stmt) == PHI_NODE)
{
for (j = 0; j < PHI_NUM_ARGS (stmt); j++)
if (PHI_ARG_DEF (stmt, j) == var)
{
SET_PHI_ARG_DEF (stmt, j, repl);
if (TREE_CODE (repl) == SSA_NAME
&& PHI_ARG_EDGE (stmt, j)->flags & EDGE_ABNORMAL)
SSA_NAME_OCCURS_IN_ABNORMAL_PHI (repl) = 1;
}
continue;
}
get_stmt_operands (stmt);
mark_new_vars = false;
if (is_gimple_reg (SSA_NAME_VAR (var)))
{
if (TREE_CODE (stmt) == MODIFY_EXPR)
{
propagate_into_addr (stmt, var, &TREE_OPERAND (stmt, 0), repl);
propagate_into_addr (stmt, var, &TREE_OPERAND (stmt, 1), repl);
}
FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
if (USE_FROM_PTR (use_p) == var)
{
propagate_value (use_p, repl);
mark_new_vars = POINTER_TYPE_P (TREE_TYPE (repl));
}
}
else
{
FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,
SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_KILLS)
if (USE_FROM_PTR (use_p) == var)
propagate_value (use_p, repl);
}
if (TREE_CODE (repl) != SSA_NAME)
{
tree tmp = stmt;
fold_stmt (&tmp);
if (tmp != stmt)
{
block_stmt_iterator si = bsi_for_stmt (stmt);
bsi_replace (&si, tmp, true);
stmt = bsi_stmt (si);
}
}
if (mark_new_vars)
mark_new_vars_to_rename (stmt, vars_to_rename);
else
modify_stmt (stmt);
}
}
static tree
get_eq_name (tree *eq_to, tree var)
{
unsigned ver;
tree val = var;
while (TREE_CODE (val) == SSA_NAME)
{
ver = SSA_NAME_VERSION (val);
if (!eq_to[ver])
break;
val = eq_to[ver];
}
while (TREE_CODE (var) == SSA_NAME)
{
ver = SSA_NAME_VERSION (var);
if (!eq_to[ver])
break;
var = eq_to[ver];
eq_to[ver] = val;
}
return val;
}
static void
check_phi_redundancy (tree phi, tree *eq_to)
{
tree val = NULL_TREE, def, res = PHI_RESULT (phi), stmt;
unsigned i, ver = SSA_NAME_VERSION (res), n;
dataflow_t df;
if (PHI_NUM_ARGS (phi) > 16)
return;
for (i = 0; i < (unsigned) PHI_NUM_ARGS (phi); i++)
{
def = PHI_ARG_DEF (phi, i);
if (TREE_CODE (def) == SSA_NAME)
{
def = get_eq_name (eq_to, def);
if (def == res)
continue;
}
if (val
&& !operand_equal_p (val, def, 0))
return;
val = def;
}
gcc_assert (val);
if (get_eq_name (eq_to, res) == val)
return;
if (!may_propagate_copy (res, val))
return;
eq_to[ver] = val;
df = get_immediate_uses (SSA_NAME_DEF_STMT (res));
n = num_immediate_uses (df);
for (i = 0; i < n; i++)
{
stmt = immediate_use (df, i);
if (TREE_CODE (stmt) == PHI_NODE)
check_phi_redundancy (stmt, eq_to);
}
}
void
kill_redundant_phi_nodes (void)
{
tree *eq_to;
unsigned i, old_num_ssa_names;
basic_block bb;
tree phi, var, repl, stmt;
eq_to = xcalloc (num_ssa_names, sizeof (tree));
compute_immediate_uses (TDFA_USE_OPS | TDFA_USE_VOPS, NULL);
old_num_ssa_names = num_ssa_names;
FOR_EACH_BB (bb)
{
for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi))
{
var = PHI_RESULT (phi);
check_phi_redundancy (phi, eq_to);
}
}
for (i = 0; i < old_num_ssa_names; i++)
{
if (!ssa_name (i))
continue;
repl = get_eq_name (eq_to, ssa_name (i));
if (repl != ssa_name (i))
replace_immediate_uses (ssa_name (i), repl);
}
for (i = 0; i < old_num_ssa_names; i++)
{
if (!ssa_name (i))
continue;
repl = get_eq_name (eq_to, ssa_name (i));
if (repl != ssa_name (i))
{
stmt = SSA_NAME_DEF_STMT (ssa_name (i));
remove_phi_node (stmt, NULL_TREE, bb_for_stmt (stmt));
}
}
free_df ();
free (eq_to);
}
struct tree_opt_pass pass_redundant_phi =
{
"redphi",
NULL,
kill_redundant_phi_nodes,
NULL,
NULL,
0,
0,
PROP_cfg | PROP_ssa | PROP_alias,
0,
0,
0,
TODO_dump_func | TODO_rename_vars
| TODO_ggc_collect | TODO_verify_ssa,
0
};
static void
warn_uninit (tree t, const char *msgid, location_t *locus)
{
tree var = SSA_NAME_VAR (t);
tree def = SSA_NAME_DEF_STMT (t);
if (!IS_EMPTY_STMT (def))
return;
if (TREE_CODE (var) == PARM_DECL)
return;
if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
return;
if (TREE_NO_WARNING (var))
return;
if (!locus)
locus = &DECL_SOURCE_LOCATION (var);
warning (msgid, locus, var);
TREE_NO_WARNING (var) = 1;
}
static tree
warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data)
{
location_t *locus = data;
tree t = *tp;
if (TREE_CODE (t) == SSA_NAME)
{
warn_uninit (t, "%H'%D' is used uninitialized in this function", locus);
*walk_subtrees = 0;
}
else if (IS_TYPE_OR_DECL_P (t))
*walk_subtrees = 0;
return NULL_TREE;
}
static void
warn_uninitialized_phi (tree phi)
{
int i, n = PHI_NUM_ARGS (phi);
if (!is_gimple_reg (PHI_RESULT (phi)))
return;
for (i = 0; i < n; ++i)
{
tree op = PHI_ARG_DEF (phi, i);
if (TREE_CODE (op) == SSA_NAME)
warn_uninit (op, "%H'%D' may be used uninitialized in this function",
NULL);
}
}
static void
execute_early_warn_uninitialized (void)
{
block_stmt_iterator bsi;
basic_block bb;
FOR_EACH_BB (bb)
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
walk_tree (bsi_stmt_ptr (bsi), warn_uninitialized_var,
EXPR_LOCUS (bsi_stmt (bsi)), NULL);
}
static void
execute_late_warn_uninitialized (void)
{
basic_block bb;
tree phi;
execute_early_warn_uninitialized ();
FOR_EACH_BB (bb)
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
warn_uninitialized_phi (phi);
}
static bool
gate_warn_uninitialized (void)
{
return warn_uninitialized != 0;
}
struct tree_opt_pass pass_early_warn_uninitialized =
{
NULL,
gate_warn_uninitialized,
execute_early_warn_uninitialized,
NULL,
NULL,
0,
0,
PROP_ssa,
0,
0,
0,
0,
0
};
struct tree_opt_pass pass_late_warn_uninitialized =
{
NULL,
gate_warn_uninitialized,
execute_late_warn_uninitialized,
NULL,
NULL,
0,
0,
PROP_ssa,
0,
0,
0,
0,
0
};