/* Miscellaneous SSA utility functions.
|
/* Miscellaneous SSA utility functions.
|
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
|
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify
|
GCC is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3, or (at your option)
|
the Free Software Foundation; either version 3, or (at your option)
|
any later version.
|
any later version.
|
|
|
GCC is distributed in the hope that it will be useful,
|
GCC is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "target.h"
|
#include "target.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "output.h"
|
#include "output.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "function.h"
|
#include "function.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "bitmap.h"
|
#include "bitmap.h"
|
#include "pointer-set.h"
|
#include "pointer-set.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "gimple.h"
|
#include "gimple.h"
|
#include "tree-inline.h"
|
#include "tree-inline.h"
|
#include "varray.h"
|
#include "varray.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "tree-dump.h"
|
#include "tree-dump.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
|
|
/* Pointer map of variable mappings, keyed by edge. */
|
/* Pointer map of variable mappings, keyed by edge. */
|
static struct pointer_map_t *edge_var_maps;
|
static struct pointer_map_t *edge_var_maps;
|
|
|
|
|
/* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
|
/* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
|
|
|
void
|
void
|
redirect_edge_var_map_add (edge e, tree result, tree def, source_location locus)
|
redirect_edge_var_map_add (edge e, tree result, tree def, source_location locus)
|
{
|
{
|
void **slot;
|
void **slot;
|
edge_var_map_vector old_head, head;
|
edge_var_map_vector old_head, head;
|
edge_var_map new_node;
|
edge_var_map new_node;
|
|
|
if (edge_var_maps == NULL)
|
if (edge_var_maps == NULL)
|
edge_var_maps = pointer_map_create ();
|
edge_var_maps = pointer_map_create ();
|
|
|
slot = pointer_map_insert (edge_var_maps, e);
|
slot = pointer_map_insert (edge_var_maps, e);
|
old_head = head = (edge_var_map_vector) *slot;
|
old_head = head = (edge_var_map_vector) *slot;
|
if (!head)
|
if (!head)
|
{
|
{
|
head = VEC_alloc (edge_var_map, heap, 5);
|
head = VEC_alloc (edge_var_map, heap, 5);
|
*slot = head;
|
*slot = head;
|
}
|
}
|
new_node.def = def;
|
new_node.def = def;
|
new_node.result = result;
|
new_node.result = result;
|
new_node.locus = locus;
|
new_node.locus = locus;
|
|
|
VEC_safe_push (edge_var_map, heap, head, &new_node);
|
VEC_safe_push (edge_var_map, heap, head, &new_node);
|
if (old_head != head)
|
if (old_head != head)
|
{
|
{
|
/* The push did some reallocation. Update the pointer map. */
|
/* The push did some reallocation. Update the pointer map. */
|
*slot = head;
|
*slot = head;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Clear the var mappings in edge E. */
|
/* Clear the var mappings in edge E. */
|
|
|
void
|
void
|
redirect_edge_var_map_clear (edge e)
|
redirect_edge_var_map_clear (edge e)
|
{
|
{
|
void **slot;
|
void **slot;
|
edge_var_map_vector head;
|
edge_var_map_vector head;
|
|
|
if (!edge_var_maps)
|
if (!edge_var_maps)
|
return;
|
return;
|
|
|
slot = pointer_map_contains (edge_var_maps, e);
|
slot = pointer_map_contains (edge_var_maps, e);
|
|
|
if (slot)
|
if (slot)
|
{
|
{
|
head = (edge_var_map_vector) *slot;
|
head = (edge_var_map_vector) *slot;
|
VEC_free (edge_var_map, heap, head);
|
VEC_free (edge_var_map, heap, head);
|
*slot = NULL;
|
*slot = NULL;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Duplicate the redirected var mappings in OLDE in NEWE.
|
/* Duplicate the redirected var mappings in OLDE in NEWE.
|
|
|
Since we can't remove a mapping, let's just duplicate it. This assumes a
|
Since we can't remove a mapping, let's just duplicate it. This assumes a
|
pointer_map can have multiple edges mapping to the same var_map (many to
|
pointer_map can have multiple edges mapping to the same var_map (many to
|
one mapping), since we don't remove the previous mappings. */
|
one mapping), since we don't remove the previous mappings. */
|
|
|
void
|
void
|
redirect_edge_var_map_dup (edge newe, edge olde)
|
redirect_edge_var_map_dup (edge newe, edge olde)
|
{
|
{
|
void **new_slot, **old_slot;
|
void **new_slot, **old_slot;
|
edge_var_map_vector head;
|
edge_var_map_vector head;
|
|
|
if (!edge_var_maps)
|
if (!edge_var_maps)
|
return;
|
return;
|
|
|
new_slot = pointer_map_insert (edge_var_maps, newe);
|
new_slot = pointer_map_insert (edge_var_maps, newe);
|
old_slot = pointer_map_contains (edge_var_maps, olde);
|
old_slot = pointer_map_contains (edge_var_maps, olde);
|
if (!old_slot)
|
if (!old_slot)
|
return;
|
return;
|
head = (edge_var_map_vector) *old_slot;
|
head = (edge_var_map_vector) *old_slot;
|
|
|
if (head)
|
if (head)
|
*new_slot = VEC_copy (edge_var_map, heap, head);
|
*new_slot = VEC_copy (edge_var_map, heap, head);
|
else
|
else
|
*new_slot = VEC_alloc (edge_var_map, heap, 5);
|
*new_slot = VEC_alloc (edge_var_map, heap, 5);
|
}
|
}
|
|
|
|
|
/* Return the variable mappings for a given edge. If there is none, return
|
/* Return the variable mappings for a given edge. If there is none, return
|
NULL. */
|
NULL. */
|
|
|
edge_var_map_vector
|
edge_var_map_vector
|
redirect_edge_var_map_vector (edge e)
|
redirect_edge_var_map_vector (edge e)
|
{
|
{
|
void **slot;
|
void **slot;
|
|
|
/* Hey, what kind of idiot would... you'd be surprised. */
|
/* Hey, what kind of idiot would... you'd be surprised. */
|
if (!edge_var_maps)
|
if (!edge_var_maps)
|
return NULL;
|
return NULL;
|
|
|
slot = pointer_map_contains (edge_var_maps, e);
|
slot = pointer_map_contains (edge_var_maps, e);
|
if (!slot)
|
if (!slot)
|
return NULL;
|
return NULL;
|
|
|
return (edge_var_map_vector) *slot;
|
return (edge_var_map_vector) *slot;
|
}
|
}
|
|
|
/* Used by redirect_edge_var_map_destroy to free all memory. */
|
/* Used by redirect_edge_var_map_destroy to free all memory. */
|
|
|
static bool
|
static bool
|
free_var_map_entry (const void *key ATTRIBUTE_UNUSED,
|
free_var_map_entry (const void *key ATTRIBUTE_UNUSED,
|
void **value,
|
void **value,
|
void *data ATTRIBUTE_UNUSED)
|
void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
edge_var_map_vector head = (edge_var_map_vector) *value;
|
edge_var_map_vector head = (edge_var_map_vector) *value;
|
VEC_free (edge_var_map, heap, head);
|
VEC_free (edge_var_map, heap, head);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Clear the edge variable mappings. */
|
/* Clear the edge variable mappings. */
|
|
|
void
|
void
|
redirect_edge_var_map_destroy (void)
|
redirect_edge_var_map_destroy (void)
|
{
|
{
|
if (edge_var_maps)
|
if (edge_var_maps)
|
{
|
{
|
pointer_map_traverse (edge_var_maps, free_var_map_entry, NULL);
|
pointer_map_traverse (edge_var_maps, free_var_map_entry, NULL);
|
pointer_map_destroy (edge_var_maps);
|
pointer_map_destroy (edge_var_maps);
|
edge_var_maps = NULL;
|
edge_var_maps = NULL;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Remove the corresponding arguments from the PHI nodes in E's
|
/* Remove the corresponding arguments from the PHI nodes in E's
|
destination block and redirect it to DEST. Return redirected edge.
|
destination block and redirect it to DEST. Return redirected edge.
|
The list of removed arguments is stored in a vector accessed
|
The list of removed arguments is stored in a vector accessed
|
through edge_var_maps. */
|
through edge_var_maps. */
|
|
|
edge
|
edge
|
ssa_redirect_edge (edge e, basic_block dest)
|
ssa_redirect_edge (edge e, basic_block dest)
|
{
|
{
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
gimple phi;
|
gimple phi;
|
|
|
redirect_edge_var_map_clear (e);
|
redirect_edge_var_map_clear (e);
|
|
|
/* Remove the appropriate PHI arguments in E's destination block. */
|
/* Remove the appropriate PHI arguments in E's destination block. */
|
for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
tree def;
|
tree def;
|
source_location locus ;
|
source_location locus ;
|
|
|
phi = gsi_stmt (gsi);
|
phi = gsi_stmt (gsi);
|
def = gimple_phi_arg_def (phi, e->dest_idx);
|
def = gimple_phi_arg_def (phi, e->dest_idx);
|
locus = gimple_phi_arg_location (phi, e->dest_idx);
|
locus = gimple_phi_arg_location (phi, e->dest_idx);
|
|
|
if (def == NULL_TREE)
|
if (def == NULL_TREE)
|
continue;
|
continue;
|
|
|
redirect_edge_var_map_add (e, gimple_phi_result (phi), def, locus);
|
redirect_edge_var_map_add (e, gimple_phi_result (phi), def, locus);
|
}
|
}
|
|
|
e = redirect_edge_succ_nodup (e, dest);
|
e = redirect_edge_succ_nodup (e, dest);
|
|
|
return e;
|
return e;
|
}
|
}
|
|
|
|
|
/* Add PHI arguments queued in PENDING_STMT list on edge E to edge
|
/* Add PHI arguments queued in PENDING_STMT list on edge E to edge
|
E->dest. */
|
E->dest. */
|
|
|
void
|
void
|
flush_pending_stmts (edge e)
|
flush_pending_stmts (edge e)
|
{
|
{
|
gimple phi;
|
gimple phi;
|
edge_var_map_vector v;
|
edge_var_map_vector v;
|
edge_var_map *vm;
|
edge_var_map *vm;
|
int i;
|
int i;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
|
|
v = redirect_edge_var_map_vector (e);
|
v = redirect_edge_var_map_vector (e);
|
if (!v)
|
if (!v)
|
return;
|
return;
|
|
|
for (gsi = gsi_start_phis (e->dest), i = 0;
|
for (gsi = gsi_start_phis (e->dest), i = 0;
|
!gsi_end_p (gsi) && VEC_iterate (edge_var_map, v, i, vm);
|
!gsi_end_p (gsi) && VEC_iterate (edge_var_map, v, i, vm);
|
gsi_next (&gsi), i++)
|
gsi_next (&gsi), i++)
|
{
|
{
|
tree def;
|
tree def;
|
|
|
phi = gsi_stmt (gsi);
|
phi = gsi_stmt (gsi);
|
def = redirect_edge_var_map_def (vm);
|
def = redirect_edge_var_map_def (vm);
|
add_phi_arg (phi, def, e, redirect_edge_var_map_location (vm));
|
add_phi_arg (phi, def, e, redirect_edge_var_map_location (vm));
|
}
|
}
|
|
|
redirect_edge_var_map_clear (e);
|
redirect_edge_var_map_clear (e);
|
}
|
}
|
|
|
/* Given a tree for an expression for which we might want to emit
|
/* Given a tree for an expression for which we might want to emit
|
locations or values in debug information (generally a variable, but
|
locations or values in debug information (generally a variable, but
|
we might deal with other kinds of trees in the future), return the
|
we might deal with other kinds of trees in the future), return the
|
tree that should be used as the variable of a DEBUG_BIND STMT or
|
tree that should be used as the variable of a DEBUG_BIND STMT or
|
VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
|
VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
|
|
|
tree
|
tree
|
target_for_debug_bind (tree var)
|
target_for_debug_bind (tree var)
|
{
|
{
|
if (!MAY_HAVE_DEBUG_STMTS)
|
if (!MAY_HAVE_DEBUG_STMTS)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
if (TREE_CODE (var) != VAR_DECL
|
if (TREE_CODE (var) != VAR_DECL
|
&& TREE_CODE (var) != PARM_DECL)
|
&& TREE_CODE (var) != PARM_DECL)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
if (DECL_HAS_VALUE_EXPR_P (var))
|
if (DECL_HAS_VALUE_EXPR_P (var))
|
return target_for_debug_bind (DECL_VALUE_EXPR (var));
|
return target_for_debug_bind (DECL_VALUE_EXPR (var));
|
|
|
if (DECL_IGNORED_P (var))
|
if (DECL_IGNORED_P (var))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
if (!is_gimple_reg (var))
|
if (!is_gimple_reg (var))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
return var;
|
return var;
|
}
|
}
|
|
|
/* Called via walk_tree, look for SSA_NAMEs that have already been
|
/* Called via walk_tree, look for SSA_NAMEs that have already been
|
released. */
|
released. */
|
|
|
static tree
|
static tree
|
find_released_ssa_name (tree *tp, int *walk_subtrees, void *data_)
|
find_released_ssa_name (tree *tp, int *walk_subtrees, void *data_)
|
{
|
{
|
struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
|
struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
|
|
|
if (wi && wi->is_lhs)
|
if (wi && wi->is_lhs)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
if (TREE_CODE (*tp) == SSA_NAME)
|
if (TREE_CODE (*tp) == SSA_NAME)
|
{
|
{
|
if (SSA_NAME_IN_FREE_LIST (*tp))
|
if (SSA_NAME_IN_FREE_LIST (*tp))
|
return *tp;
|
return *tp;
|
|
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
}
|
}
|
else if (IS_TYPE_OR_DECL_P (*tp))
|
else if (IS_TYPE_OR_DECL_P (*tp))
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
|
/* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
|
by other DEBUG stmts, and replace uses of the DEF with the
|
by other DEBUG stmts, and replace uses of the DEF with the
|
newly-created debug temp. */
|
newly-created debug temp. */
|
|
|
void
|
void
|
insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
|
insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
|
{
|
{
|
imm_use_iterator imm_iter;
|
imm_use_iterator imm_iter;
|
use_operand_p use_p;
|
use_operand_p use_p;
|
gimple stmt;
|
gimple stmt;
|
gimple def_stmt = NULL;
|
gimple def_stmt = NULL;
|
int usecount = 0;
|
int usecount = 0;
|
tree value = NULL;
|
tree value = NULL;
|
|
|
if (!MAY_HAVE_DEBUG_STMTS)
|
if (!MAY_HAVE_DEBUG_STMTS)
|
return;
|
return;
|
|
|
/* If this name has already been registered for replacement, do nothing
|
/* If this name has already been registered for replacement, do nothing
|
as anything that uses this name isn't in SSA form. */
|
as anything that uses this name isn't in SSA form. */
|
if (name_registered_for_update_p (var))
|
if (name_registered_for_update_p (var))
|
return;
|
return;
|
|
|
/* Check whether there are debug stmts that reference this variable and,
|
/* Check whether there are debug stmts that reference this variable and,
|
if there are, decide whether we should use a debug temp. */
|
if there are, decide whether we should use a debug temp. */
|
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, var)
|
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, var)
|
{
|
{
|
stmt = USE_STMT (use_p);
|
stmt = USE_STMT (use_p);
|
|
|
if (!gimple_debug_bind_p (stmt))
|
if (!gimple_debug_bind_p (stmt))
|
continue;
|
continue;
|
|
|
if (usecount++)
|
if (usecount++)
|
break;
|
break;
|
|
|
if (gimple_debug_bind_get_value (stmt) != var)
|
if (gimple_debug_bind_get_value (stmt) != var)
|
{
|
{
|
/* Count this as an additional use, so as to make sure we
|
/* Count this as an additional use, so as to make sure we
|
use a temp unless VAR's definition has a SINGLE_RHS that
|
use a temp unless VAR's definition has a SINGLE_RHS that
|
can be shared. */
|
can be shared. */
|
usecount++;
|
usecount++;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (!usecount)
|
if (!usecount)
|
return;
|
return;
|
|
|
if (gsi)
|
if (gsi)
|
def_stmt = gsi_stmt (*gsi);
|
def_stmt = gsi_stmt (*gsi);
|
else
|
else
|
def_stmt = SSA_NAME_DEF_STMT (var);
|
def_stmt = SSA_NAME_DEF_STMT (var);
|
|
|
/* If we didn't get an insertion point, and the stmt has already
|
/* If we didn't get an insertion point, and the stmt has already
|
been removed, we won't be able to insert the debug bind stmt, so
|
been removed, we won't be able to insert the debug bind stmt, so
|
we'll have to drop debug information. */
|
we'll have to drop debug information. */
|
if (gimple_code (def_stmt) == GIMPLE_PHI)
|
if (gimple_code (def_stmt) == GIMPLE_PHI)
|
{
|
{
|
value = degenerate_phi_result (def_stmt);
|
value = degenerate_phi_result (def_stmt);
|
if (value && walk_tree (&value, find_released_ssa_name, NULL, NULL))
|
if (value && walk_tree (&value, find_released_ssa_name, NULL, NULL))
|
value = NULL;
|
value = NULL;
|
}
|
}
|
else if (is_gimple_assign (def_stmt))
|
else if (is_gimple_assign (def_stmt))
|
{
|
{
|
bool no_value = false;
|
bool no_value = false;
|
|
|
if (!dom_info_available_p (CDI_DOMINATORS))
|
if (!dom_info_available_p (CDI_DOMINATORS))
|
{
|
{
|
struct walk_stmt_info wi;
|
struct walk_stmt_info wi;
|
|
|
memset (&wi, 0, sizeof (wi));
|
memset (&wi, 0, sizeof (wi));
|
|
|
/* When removing blocks without following reverse dominance
|
/* When removing blocks without following reverse dominance
|
order, we may sometimes encounter SSA_NAMEs that have
|
order, we may sometimes encounter SSA_NAMEs that have
|
already been released, referenced in other SSA_DEFs that
|
already been released, referenced in other SSA_DEFs that
|
we're about to release. Consider:
|
we're about to release. Consider:
|
|
|
<bb X>:
|
<bb X>:
|
v_1 = foo;
|
v_1 = foo;
|
|
|
<bb Y>:
|
<bb Y>:
|
w_2 = v_1 + bar;
|
w_2 = v_1 + bar;
|
# DEBUG w => w_2
|
# DEBUG w => w_2
|
|
|
If we deleted BB X first, propagating the value of w_2
|
If we deleted BB X first, propagating the value of w_2
|
won't do us any good. It's too late to recover their
|
won't do us any good. It's too late to recover their
|
original definition of v_1: when it was deleted, it was
|
original definition of v_1: when it was deleted, it was
|
only referenced in other DEFs, it couldn't possibly know
|
only referenced in other DEFs, it couldn't possibly know
|
it should have been retained, and propagating every
|
it should have been retained, and propagating every
|
single DEF just in case it might have to be propagated
|
single DEF just in case it might have to be propagated
|
into a DEBUG STMT would probably be too wasteful.
|
into a DEBUG STMT would probably be too wasteful.
|
|
|
When dominator information is not readily available, we
|
When dominator information is not readily available, we
|
check for and accept some loss of debug information. But
|
check for and accept some loss of debug information. But
|
if it is available, there's no excuse for us to remove
|
if it is available, there's no excuse for us to remove
|
blocks in the wrong order, so we don't even check for
|
blocks in the wrong order, so we don't even check for
|
dead SSA NAMEs. SSA verification shall catch any
|
dead SSA NAMEs. SSA verification shall catch any
|
errors. */
|
errors. */
|
if ((!gsi && !gimple_bb (def_stmt))
|
if ((!gsi && !gimple_bb (def_stmt))
|
|| walk_gimple_op (def_stmt, find_released_ssa_name, &wi))
|
|| walk_gimple_op (def_stmt, find_released_ssa_name, &wi))
|
no_value = true;
|
no_value = true;
|
}
|
}
|
|
|
if (!no_value)
|
if (!no_value)
|
value = gimple_assign_rhs_to_tree (def_stmt);
|
value = gimple_assign_rhs_to_tree (def_stmt);
|
}
|
}
|
|
|
if (value)
|
if (value)
|
{
|
{
|
/* If there's a single use of VAR, and VAR is the entire debug
|
/* If there's a single use of VAR, and VAR is the entire debug
|
expression (usecount would have been incremented again
|
expression (usecount would have been incremented again
|
otherwise), and the definition involves only constants and
|
otherwise), and the definition involves only constants and
|
SSA names, then we can propagate VALUE into this single use,
|
SSA names, then we can propagate VALUE into this single use,
|
avoiding the temp.
|
avoiding the temp.
|
|
|
We can also avoid using a temp if VALUE can be shared and
|
We can also avoid using a temp if VALUE can be shared and
|
propagated into all uses, without generating expressions that
|
propagated into all uses, without generating expressions that
|
wouldn't be valid gimple RHSs.
|
wouldn't be valid gimple RHSs.
|
|
|
Other cases that would require unsharing or non-gimple RHSs
|
Other cases that would require unsharing or non-gimple RHSs
|
are deferred to a debug temp, although we could avoid temps
|
are deferred to a debug temp, although we could avoid temps
|
at the expense of duplication of expressions. */
|
at the expense of duplication of expressions. */
|
|
|
if (CONSTANT_CLASS_P (value)
|
if (CONSTANT_CLASS_P (value)
|
|| gimple_code (def_stmt) == GIMPLE_PHI
|
|| gimple_code (def_stmt) == GIMPLE_PHI
|
|| (usecount == 1
|
|| (usecount == 1
|
&& (!gimple_assign_single_p (def_stmt)
|
&& (!gimple_assign_single_p (def_stmt)
|
|| is_gimple_min_invariant (value)))
|
|| is_gimple_min_invariant (value)))
|
|| is_gimple_reg (value))
|
|| is_gimple_reg (value))
|
value = unshare_expr (value);
|
value = unshare_expr (value);
|
else
|
else
|
{
|
{
|
gimple def_temp;
|
gimple def_temp;
|
tree vexpr = make_node (DEBUG_EXPR_DECL);
|
tree vexpr = make_node (DEBUG_EXPR_DECL);
|
|
|
def_temp = gimple_build_debug_bind (vexpr,
|
def_temp = gimple_build_debug_bind (vexpr,
|
unshare_expr (value),
|
unshare_expr (value),
|
def_stmt);
|
def_stmt);
|
|
|
DECL_ARTIFICIAL (vexpr) = 1;
|
DECL_ARTIFICIAL (vexpr) = 1;
|
TREE_TYPE (vexpr) = TREE_TYPE (value);
|
TREE_TYPE (vexpr) = TREE_TYPE (value);
|
if (DECL_P (value))
|
if (DECL_P (value))
|
DECL_MODE (vexpr) = DECL_MODE (value);
|
DECL_MODE (vexpr) = DECL_MODE (value);
|
else
|
else
|
DECL_MODE (vexpr) = TYPE_MODE (TREE_TYPE (value));
|
DECL_MODE (vexpr) = TYPE_MODE (TREE_TYPE (value));
|
|
|
if (gsi)
|
if (gsi)
|
gsi_insert_before (gsi, def_temp, GSI_SAME_STMT);
|
gsi_insert_before (gsi, def_temp, GSI_SAME_STMT);
|
else
|
else
|
{
|
{
|
gimple_stmt_iterator ngsi = gsi_for_stmt (def_stmt);
|
gimple_stmt_iterator ngsi = gsi_for_stmt (def_stmt);
|
gsi_insert_before (&ngsi, def_temp, GSI_SAME_STMT);
|
gsi_insert_before (&ngsi, def_temp, GSI_SAME_STMT);
|
}
|
}
|
|
|
value = vexpr;
|
value = vexpr;
|
}
|
}
|
}
|
}
|
|
|
FOR_EACH_IMM_USE_STMT (stmt, imm_iter, var)
|
FOR_EACH_IMM_USE_STMT (stmt, imm_iter, var)
|
{
|
{
|
if (!gimple_debug_bind_p (stmt))
|
if (!gimple_debug_bind_p (stmt))
|
continue;
|
continue;
|
|
|
if (value)
|
if (value)
|
FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
|
FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
|
/* unshare_expr is not needed here. vexpr is either a
|
/* unshare_expr is not needed here. vexpr is either a
|
SINGLE_RHS, that can be safely shared, some other RHS
|
SINGLE_RHS, that can be safely shared, some other RHS
|
that was unshared when we found it had a single debug
|
that was unshared when we found it had a single debug
|
use, or a DEBUG_EXPR_DECL, that can be safely
|
use, or a DEBUG_EXPR_DECL, that can be safely
|
shared. */
|
shared. */
|
SET_USE (use_p, value);
|
SET_USE (use_p, value);
|
else
|
else
|
gimple_debug_bind_reset_value (stmt);
|
gimple_debug_bind_reset_value (stmt);
|
|
|
update_stmt (stmt);
|
update_stmt (stmt);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
|
/* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
|
other DEBUG stmts, and replace uses of the DEF with the
|
other DEBUG stmts, and replace uses of the DEF with the
|
newly-created debug temp. */
|
newly-created debug temp. */
|
|
|
void
|
void
|
insert_debug_temps_for_defs (gimple_stmt_iterator *gsi)
|
insert_debug_temps_for_defs (gimple_stmt_iterator *gsi)
|
{
|
{
|
gimple stmt;
|
gimple stmt;
|
ssa_op_iter op_iter;
|
ssa_op_iter op_iter;
|
def_operand_p def_p;
|
def_operand_p def_p;
|
|
|
if (!MAY_HAVE_DEBUG_STMTS)
|
if (!MAY_HAVE_DEBUG_STMTS)
|
return;
|
return;
|
|
|
stmt = gsi_stmt (*gsi);
|
stmt = gsi_stmt (*gsi);
|
|
|
FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
|
FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
|
{
|
{
|
tree var = DEF_FROM_PTR (def_p);
|
tree var = DEF_FROM_PTR (def_p);
|
|
|
if (TREE_CODE (var) != SSA_NAME)
|
if (TREE_CODE (var) != SSA_NAME)
|
continue;
|
continue;
|
|
|
insert_debug_temp_for_var_def (gsi, var);
|
insert_debug_temp_for_var_def (gsi, var);
|
}
|
}
|
}
|
}
|
|
|
/* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
|
/* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
|
dominated stmts before their dominators, so that release_ssa_defs
|
dominated stmts before their dominators, so that release_ssa_defs
|
stands a chance of propagating DEFs into debug bind stmts. */
|
stands a chance of propagating DEFs into debug bind stmts. */
|
|
|
void
|
void
|
release_defs_bitset (bitmap toremove)
|
release_defs_bitset (bitmap toremove)
|
{
|
{
|
unsigned j;
|
unsigned j;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
/* Performing a topological sort is probably overkill, this will
|
/* Performing a topological sort is probably overkill, this will
|
most likely run in slightly superlinear time, rather than the
|
most likely run in slightly superlinear time, rather than the
|
pathological quadratic worst case. */
|
pathological quadratic worst case. */
|
while (!bitmap_empty_p (toremove))
|
while (!bitmap_empty_p (toremove))
|
EXECUTE_IF_SET_IN_BITMAP (toremove, 0, j, bi)
|
EXECUTE_IF_SET_IN_BITMAP (toremove, 0, j, bi)
|
{
|
{
|
bool remove_now = true;
|
bool remove_now = true;
|
tree var = ssa_name (j);
|
tree var = ssa_name (j);
|
gimple stmt;
|
gimple stmt;
|
imm_use_iterator uit;
|
imm_use_iterator uit;
|
|
|
FOR_EACH_IMM_USE_STMT (stmt, uit, var)
|
FOR_EACH_IMM_USE_STMT (stmt, uit, var)
|
{
|
{
|
ssa_op_iter dit;
|
ssa_op_iter dit;
|
def_operand_p def_p;
|
def_operand_p def_p;
|
|
|
/* We can't propagate PHI nodes into debug stmts. */
|
/* We can't propagate PHI nodes into debug stmts. */
|
if (gimple_code (stmt) == GIMPLE_PHI
|
if (gimple_code (stmt) == GIMPLE_PHI
|
|| is_gimple_debug (stmt))
|
|| is_gimple_debug (stmt))
|
continue;
|
continue;
|
|
|
/* If we find another definition to remove that uses
|
/* If we find another definition to remove that uses
|
the one we're looking at, defer the removal of this
|
the one we're looking at, defer the removal of this
|
one, so that it can be propagated into debug stmts
|
one, so that it can be propagated into debug stmts
|
after the other is. */
|
after the other is. */
|
FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, dit, SSA_OP_DEF)
|
FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, dit, SSA_OP_DEF)
|
{
|
{
|
tree odef = DEF_FROM_PTR (def_p);
|
tree odef = DEF_FROM_PTR (def_p);
|
|
|
if (bitmap_bit_p (toremove, SSA_NAME_VERSION (odef)))
|
if (bitmap_bit_p (toremove, SSA_NAME_VERSION (odef)))
|
{
|
{
|
remove_now = false;
|
remove_now = false;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (!remove_now)
|
if (!remove_now)
|
BREAK_FROM_IMM_USE_STMT (uit);
|
BREAK_FROM_IMM_USE_STMT (uit);
|
}
|
}
|
|
|
if (remove_now)
|
if (remove_now)
|
{
|
{
|
gimple def = SSA_NAME_DEF_STMT (var);
|
gimple def = SSA_NAME_DEF_STMT (var);
|
gimple_stmt_iterator gsi = gsi_for_stmt (def);
|
gimple_stmt_iterator gsi = gsi_for_stmt (def);
|
|
|
if (gimple_code (def) == GIMPLE_PHI)
|
if (gimple_code (def) == GIMPLE_PHI)
|
remove_phi_node (&gsi, true);
|
remove_phi_node (&gsi, true);
|
else
|
else
|
{
|
{
|
gsi_remove (&gsi, true);
|
gsi_remove (&gsi, true);
|
release_defs (def);
|
release_defs (def);
|
}
|
}
|
|
|
bitmap_clear_bit (toremove, j);
|
bitmap_clear_bit (toremove, j);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Return true if SSA_NAME is malformed and mark it visited.
|
/* Return true if SSA_NAME is malformed and mark it visited.
|
|
|
IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
|
IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
|
operand. */
|
operand. */
|
|
|
static bool
|
static bool
|
verify_ssa_name (tree ssa_name, bool is_virtual)
|
verify_ssa_name (tree ssa_name, bool is_virtual)
|
{
|
{
|
if (TREE_CODE (ssa_name) != SSA_NAME)
|
if (TREE_CODE (ssa_name) != SSA_NAME)
|
{
|
{
|
error ("expected an SSA_NAME object");
|
error ("expected an SSA_NAME object");
|
return true;
|
return true;
|
}
|
}
|
|
|
if (TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
|
if (TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
|
{
|
{
|
error ("type mismatch between an SSA_NAME and its symbol");
|
error ("type mismatch between an SSA_NAME and its symbol");
|
return true;
|
return true;
|
}
|
}
|
|
|
if (SSA_NAME_IN_FREE_LIST (ssa_name))
|
if (SSA_NAME_IN_FREE_LIST (ssa_name))
|
{
|
{
|
error ("found an SSA_NAME that had been released into the free pool");
|
error ("found an SSA_NAME that had been released into the free pool");
|
return true;
|
return true;
|
}
|
}
|
|
|
if (is_virtual && is_gimple_reg (ssa_name))
|
if (is_virtual && is_gimple_reg (ssa_name))
|
{
|
{
|
error ("found a virtual definition for a GIMPLE register");
|
error ("found a virtual definition for a GIMPLE register");
|
return true;
|
return true;
|
}
|
}
|
|
|
if (is_virtual && SSA_NAME_VAR (ssa_name) != gimple_vop (cfun))
|
if (is_virtual && SSA_NAME_VAR (ssa_name) != gimple_vop (cfun))
|
{
|
{
|
error ("virtual SSA name for non-VOP decl");
|
error ("virtual SSA name for non-VOP decl");
|
return true;
|
return true;
|
}
|
}
|
|
|
if (!is_virtual && !is_gimple_reg (ssa_name))
|
if (!is_virtual && !is_gimple_reg (ssa_name))
|
{
|
{
|
error ("found a real definition for a non-register");
|
error ("found a real definition for a non-register");
|
return true;
|
return true;
|
}
|
}
|
|
|
if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
|
if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
|
&& !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name)))
|
&& !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name)))
|
{
|
{
|
error ("found a default name with a non-empty defining statement");
|
error ("found a default name with a non-empty defining statement");
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Return true if the definition of SSA_NAME at block BB is malformed.
|
/* Return true if the definition of SSA_NAME at block BB is malformed.
|
|
|
STMT is the statement where SSA_NAME is created.
|
STMT is the statement where SSA_NAME is created.
|
|
|
DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
|
DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
|
version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
|
version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
|
it means that the block in that array slot contains the
|
it means that the block in that array slot contains the
|
definition of SSA_NAME.
|
definition of SSA_NAME.
|
|
|
IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
|
IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
|
|
|
static bool
|
static bool
|
verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
|
verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
|
gimple stmt, bool is_virtual)
|
gimple stmt, bool is_virtual)
|
{
|
{
|
if (verify_ssa_name (ssa_name, is_virtual))
|
if (verify_ssa_name (ssa_name, is_virtual))
|
goto err;
|
goto err;
|
|
|
if (definition_block[SSA_NAME_VERSION (ssa_name)])
|
if (definition_block[SSA_NAME_VERSION (ssa_name)])
|
{
|
{
|
error ("SSA_NAME created in two different blocks %i and %i",
|
error ("SSA_NAME created in two different blocks %i and %i",
|
definition_block[SSA_NAME_VERSION (ssa_name)]->index, bb->index);
|
definition_block[SSA_NAME_VERSION (ssa_name)]->index, bb->index);
|
goto err;
|
goto err;
|
}
|
}
|
|
|
definition_block[SSA_NAME_VERSION (ssa_name)] = bb;
|
definition_block[SSA_NAME_VERSION (ssa_name)] = bb;
|
|
|
if (SSA_NAME_DEF_STMT (ssa_name) != stmt)
|
if (SSA_NAME_DEF_STMT (ssa_name) != stmt)
|
{
|
{
|
error ("SSA_NAME_DEF_STMT is wrong");
|
error ("SSA_NAME_DEF_STMT is wrong");
|
fprintf (stderr, "Expected definition statement:\n");
|
fprintf (stderr, "Expected definition statement:\n");
|
print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), 4, TDF_VOPS);
|
print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), 4, TDF_VOPS);
|
fprintf (stderr, "\nActual definition statement:\n");
|
fprintf (stderr, "\nActual definition statement:\n");
|
print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
|
print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
|
goto err;
|
goto err;
|
}
|
}
|
|
|
return false;
|
return false;
|
|
|
err:
|
err:
|
fprintf (stderr, "while verifying SSA_NAME ");
|
fprintf (stderr, "while verifying SSA_NAME ");
|
print_generic_expr (stderr, ssa_name, 0);
|
print_generic_expr (stderr, ssa_name, 0);
|
fprintf (stderr, " in statement\n");
|
fprintf (stderr, " in statement\n");
|
print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
|
print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* Return true if the use of SSA_NAME at statement STMT in block BB is
|
/* Return true if the use of SSA_NAME at statement STMT in block BB is
|
malformed.
|
malformed.
|
|
|
DEF_BB is the block where SSA_NAME was found to be created.
|
DEF_BB is the block where SSA_NAME was found to be created.
|
|
|
IDOM contains immediate dominator information for the flowgraph.
|
IDOM contains immediate dominator information for the flowgraph.
|
|
|
CHECK_ABNORMAL is true if the caller wants to check whether this use
|
CHECK_ABNORMAL is true if the caller wants to check whether this use
|
is flowing through an abnormal edge (only used when checking PHI
|
is flowing through an abnormal edge (only used when checking PHI
|
arguments).
|
arguments).
|
|
|
If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
|
If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
|
that are defined before STMT in basic block BB. */
|
that are defined before STMT in basic block BB. */
|
|
|
static bool
|
static bool
|
verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
|
verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
|
gimple stmt, bool check_abnormal, bitmap names_defined_in_bb)
|
gimple stmt, bool check_abnormal, bitmap names_defined_in_bb)
|
{
|
{
|
bool err = false;
|
bool err = false;
|
tree ssa_name = USE_FROM_PTR (use_p);
|
tree ssa_name = USE_FROM_PTR (use_p);
|
|
|
if (!TREE_VISITED (ssa_name))
|
if (!TREE_VISITED (ssa_name))
|
if (verify_imm_links (stderr, ssa_name))
|
if (verify_imm_links (stderr, ssa_name))
|
err = true;
|
err = true;
|
|
|
TREE_VISITED (ssa_name) = 1;
|
TREE_VISITED (ssa_name) = 1;
|
|
|
if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name))
|
if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name))
|
&& SSA_NAME_IS_DEFAULT_DEF (ssa_name))
|
&& SSA_NAME_IS_DEFAULT_DEF (ssa_name))
|
; /* Default definitions have empty statements. Nothing to do. */
|
; /* Default definitions have empty statements. Nothing to do. */
|
else if (!def_bb)
|
else if (!def_bb)
|
{
|
{
|
error ("missing definition");
|
error ("missing definition");
|
err = true;
|
err = true;
|
}
|
}
|
else if (bb != def_bb
|
else if (bb != def_bb
|
&& !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
|
&& !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
|
{
|
{
|
error ("definition in block %i does not dominate use in block %i",
|
error ("definition in block %i does not dominate use in block %i",
|
def_bb->index, bb->index);
|
def_bb->index, bb->index);
|
err = true;
|
err = true;
|
}
|
}
|
else if (bb == def_bb
|
else if (bb == def_bb
|
&& names_defined_in_bb != NULL
|
&& names_defined_in_bb != NULL
|
&& !bitmap_bit_p (names_defined_in_bb, SSA_NAME_VERSION (ssa_name)))
|
&& !bitmap_bit_p (names_defined_in_bb, SSA_NAME_VERSION (ssa_name)))
|
{
|
{
|
error ("definition in block %i follows the use", def_bb->index);
|
error ("definition in block %i follows the use", def_bb->index);
|
err = true;
|
err = true;
|
}
|
}
|
|
|
if (check_abnormal
|
if (check_abnormal
|
&& !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
|
&& !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
|
{
|
{
|
error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
|
error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
|
err = true;
|
err = true;
|
}
|
}
|
|
|
/* Make sure the use is in an appropriate list by checking the previous
|
/* Make sure the use is in an appropriate list by checking the previous
|
element to make sure it's the same. */
|
element to make sure it's the same. */
|
if (use_p->prev == NULL)
|
if (use_p->prev == NULL)
|
{
|
{
|
error ("no immediate_use list");
|
error ("no immediate_use list");
|
err = true;
|
err = true;
|
}
|
}
|
else
|
else
|
{
|
{
|
tree listvar;
|
tree listvar;
|
if (use_p->prev->use == NULL)
|
if (use_p->prev->use == NULL)
|
listvar = use_p->prev->loc.ssa_name;
|
listvar = use_p->prev->loc.ssa_name;
|
else
|
else
|
listvar = USE_FROM_PTR (use_p->prev);
|
listvar = USE_FROM_PTR (use_p->prev);
|
if (listvar != ssa_name)
|
if (listvar != ssa_name)
|
{
|
{
|
error ("wrong immediate use list");
|
error ("wrong immediate use list");
|
err = true;
|
err = true;
|
}
|
}
|
}
|
}
|
|
|
if (err)
|
if (err)
|
{
|
{
|
fprintf (stderr, "for SSA_NAME: ");
|
fprintf (stderr, "for SSA_NAME: ");
|
print_generic_expr (stderr, ssa_name, TDF_VOPS);
|
print_generic_expr (stderr, ssa_name, TDF_VOPS);
|
fprintf (stderr, " in statement:\n");
|
fprintf (stderr, " in statement:\n");
|
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
|
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
|
}
|
}
|
|
|
return err;
|
return err;
|
}
|
}
|
|
|
|
|
/* Return true if any of the arguments for PHI node PHI at block BB is
|
/* Return true if any of the arguments for PHI node PHI at block BB is
|
malformed.
|
malformed.
|
|
|
DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
|
DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
|
version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
|
version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
|
it means that the block in that array slot contains the
|
it means that the block in that array slot contains the
|
definition of SSA_NAME. */
|
definition of SSA_NAME. */
|
|
|
static bool
|
static bool
|
verify_phi_args (gimple phi, basic_block bb, basic_block *definition_block)
|
verify_phi_args (gimple phi, basic_block bb, basic_block *definition_block)
|
{
|
{
|
edge e;
|
edge e;
|
bool err = false;
|
bool err = false;
|
size_t i, phi_num_args = gimple_phi_num_args (phi);
|
size_t i, phi_num_args = gimple_phi_num_args (phi);
|
|
|
if (EDGE_COUNT (bb->preds) != phi_num_args)
|
if (EDGE_COUNT (bb->preds) != phi_num_args)
|
{
|
{
|
error ("incoming edge count does not match number of PHI arguments");
|
error ("incoming edge count does not match number of PHI arguments");
|
err = true;
|
err = true;
|
goto error;
|
goto error;
|
}
|
}
|
|
|
for (i = 0; i < phi_num_args; i++)
|
for (i = 0; i < phi_num_args; i++)
|
{
|
{
|
use_operand_p op_p = gimple_phi_arg_imm_use_ptr (phi, i);
|
use_operand_p op_p = gimple_phi_arg_imm_use_ptr (phi, i);
|
tree op = USE_FROM_PTR (op_p);
|
tree op = USE_FROM_PTR (op_p);
|
|
|
e = EDGE_PRED (bb, i);
|
e = EDGE_PRED (bb, i);
|
|
|
if (op == NULL_TREE)
|
if (op == NULL_TREE)
|
{
|
{
|
error ("PHI argument is missing for edge %d->%d",
|
error ("PHI argument is missing for edge %d->%d",
|
e->src->index,
|
e->src->index,
|
e->dest->index);
|
e->dest->index);
|
err = true;
|
err = true;
|
goto error;
|
goto error;
|
}
|
}
|
|
|
if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op))
|
if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op))
|
{
|
{
|
error ("PHI argument is not SSA_NAME, or invariant");
|
error ("PHI argument is not SSA_NAME, or invariant");
|
err = true;
|
err = true;
|
}
|
}
|
|
|
if (TREE_CODE (op) == SSA_NAME)
|
if (TREE_CODE (op) == SSA_NAME)
|
{
|
{
|
err = verify_ssa_name (op, !is_gimple_reg (gimple_phi_result (phi)));
|
err = verify_ssa_name (op, !is_gimple_reg (gimple_phi_result (phi)));
|
err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)],
|
err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)],
|
op_p, phi, e->flags & EDGE_ABNORMAL, NULL);
|
op_p, phi, e->flags & EDGE_ABNORMAL, NULL);
|
}
|
}
|
|
|
if (TREE_CODE (op) == ADDR_EXPR)
|
if (TREE_CODE (op) == ADDR_EXPR)
|
{
|
{
|
tree base = TREE_OPERAND (op, 0);
|
tree base = TREE_OPERAND (op, 0);
|
while (handled_component_p (base))
|
while (handled_component_p (base))
|
base = TREE_OPERAND (base, 0);
|
base = TREE_OPERAND (base, 0);
|
if ((TREE_CODE (base) == VAR_DECL
|
if ((TREE_CODE (base) == VAR_DECL
|
|| TREE_CODE (base) == PARM_DECL
|
|| TREE_CODE (base) == PARM_DECL
|
|| TREE_CODE (base) == RESULT_DECL)
|
|| TREE_CODE (base) == RESULT_DECL)
|
&& !TREE_ADDRESSABLE (base))
|
&& !TREE_ADDRESSABLE (base))
|
{
|
{
|
error ("address taken, but ADDRESSABLE bit not set");
|
error ("address taken, but ADDRESSABLE bit not set");
|
err = true;
|
err = true;
|
}
|
}
|
}
|
}
|
|
|
if (e->dest != bb)
|
if (e->dest != bb)
|
{
|
{
|
error ("wrong edge %d->%d for PHI argument",
|
error ("wrong edge %d->%d for PHI argument",
|
e->src->index, e->dest->index);
|
e->src->index, e->dest->index);
|
err = true;
|
err = true;
|
}
|
}
|
|
|
if (err)
|
if (err)
|
{
|
{
|
fprintf (stderr, "PHI argument\n");
|
fprintf (stderr, "PHI argument\n");
|
print_generic_stmt (stderr, op, TDF_VOPS);
|
print_generic_stmt (stderr, op, TDF_VOPS);
|
goto error;
|
goto error;
|
}
|
}
|
}
|
}
|
|
|
error:
|
error:
|
if (err)
|
if (err)
|
{
|
{
|
fprintf (stderr, "for PHI node\n");
|
fprintf (stderr, "for PHI node\n");
|
print_gimple_stmt (stderr, phi, 0, TDF_VOPS|TDF_MEMSYMS);
|
print_gimple_stmt (stderr, phi, 0, TDF_VOPS|TDF_MEMSYMS);
|
}
|
}
|
|
|
|
|
return err;
|
return err;
|
}
|
}
|
|
|
|
|
/* Verify common invariants in the SSA web.
|
/* Verify common invariants in the SSA web.
|
TODO: verify the variable annotations. */
|
TODO: verify the variable annotations. */
|
|
|
void
|
void
|
verify_ssa (bool check_modified_stmt)
|
verify_ssa (bool check_modified_stmt)
|
{
|
{
|
size_t i;
|
size_t i;
|
basic_block bb;
|
basic_block bb;
|
basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names);
|
basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names);
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
tree op;
|
tree op;
|
enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS);
|
enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS);
|
bitmap names_defined_in_bb = BITMAP_ALLOC (NULL);
|
bitmap names_defined_in_bb = BITMAP_ALLOC (NULL);
|
|
|
gcc_assert (!need_ssa_update_p (cfun));
|
gcc_assert (!need_ssa_update_p (cfun));
|
|
|
verify_stmts ();
|
verify_stmts ();
|
|
|
timevar_push (TV_TREE_SSA_VERIFY);
|
timevar_push (TV_TREE_SSA_VERIFY);
|
|
|
/* Keep track of SSA names present in the IL. */
|
/* Keep track of SSA names present in the IL. */
|
for (i = 1; i < num_ssa_names; i++)
|
for (i = 1; i < num_ssa_names; i++)
|
{
|
{
|
tree name = ssa_name (i);
|
tree name = ssa_name (i);
|
if (name)
|
if (name)
|
{
|
{
|
gimple stmt;
|
gimple stmt;
|
TREE_VISITED (name) = 0;
|
TREE_VISITED (name) = 0;
|
|
|
stmt = SSA_NAME_DEF_STMT (name);
|
stmt = SSA_NAME_DEF_STMT (name);
|
if (!gimple_nop_p (stmt))
|
if (!gimple_nop_p (stmt))
|
{
|
{
|
basic_block bb = gimple_bb (stmt);
|
basic_block bb = gimple_bb (stmt);
|
verify_def (bb, definition_block,
|
verify_def (bb, definition_block,
|
name, stmt, !is_gimple_reg (name));
|
name, stmt, !is_gimple_reg (name));
|
|
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
calculate_dominance_info (CDI_DOMINATORS);
|
calculate_dominance_info (CDI_DOMINATORS);
|
|
|
/* Now verify all the uses and make sure they agree with the definitions
|
/* Now verify all the uses and make sure they agree with the definitions
|
found in the previous pass. */
|
found in the previous pass. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
edge e;
|
edge e;
|
gimple phi;
|
gimple phi;
|
edge_iterator ei;
|
edge_iterator ei;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
|
|
/* Make sure that all edges have a clear 'aux' field. */
|
/* Make sure that all edges have a clear 'aux' field. */
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
{
|
{
|
if (e->aux)
|
if (e->aux)
|
{
|
{
|
error ("AUX pointer initialized for edge %d->%d", e->src->index,
|
error ("AUX pointer initialized for edge %d->%d", e->src->index,
|
e->dest->index);
|
e->dest->index);
|
goto err;
|
goto err;
|
}
|
}
|
}
|
}
|
|
|
/* Verify the arguments for every PHI node in the block. */
|
/* Verify the arguments for every PHI node in the block. */
|
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
phi = gsi_stmt (gsi);
|
phi = gsi_stmt (gsi);
|
if (verify_phi_args (phi, bb, definition_block))
|
if (verify_phi_args (phi, bb, definition_block))
|
goto err;
|
goto err;
|
|
|
bitmap_set_bit (names_defined_in_bb,
|
bitmap_set_bit (names_defined_in_bb,
|
SSA_NAME_VERSION (gimple_phi_result (phi)));
|
SSA_NAME_VERSION (gimple_phi_result (phi)));
|
}
|
}
|
|
|
/* Now verify all the uses and vuses in every statement of the block. */
|
/* Now verify all the uses and vuses in every statement of the block. */
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
gimple stmt = gsi_stmt (gsi);
|
gimple stmt = gsi_stmt (gsi);
|
use_operand_p use_p;
|
use_operand_p use_p;
|
bool has_err;
|
bool has_err;
|
|
|
if (check_modified_stmt && gimple_modified_p (stmt))
|
if (check_modified_stmt && gimple_modified_p (stmt))
|
{
|
{
|
error ("stmt (%p) marked modified after optimization pass: ",
|
error ("stmt (%p) marked modified after optimization pass: ",
|
(void *)stmt);
|
(void *)stmt);
|
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
|
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
|
goto err;
|
goto err;
|
}
|
}
|
|
|
if (is_gimple_assign (stmt)
|
if (is_gimple_assign (stmt)
|
&& TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME)
|
&& TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME)
|
{
|
{
|
tree lhs, base_address;
|
tree lhs, base_address;
|
|
|
lhs = gimple_assign_lhs (stmt);
|
lhs = gimple_assign_lhs (stmt);
|
base_address = get_base_address (lhs);
|
base_address = get_base_address (lhs);
|
|
|
if (base_address
|
if (base_address
|
&& SSA_VAR_P (base_address)
|
&& SSA_VAR_P (base_address)
|
&& !gimple_vdef (stmt)
|
&& !gimple_vdef (stmt)
|
&& optimize > 0)
|
&& optimize > 0)
|
{
|
{
|
error ("statement makes a memory store, but has no VDEFS");
|
error ("statement makes a memory store, but has no VDEFS");
|
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
|
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
|
goto err;
|
goto err;
|
}
|
}
|
}
|
}
|
else if (gimple_debug_bind_p (stmt)
|
else if (gimple_debug_bind_p (stmt)
|
&& !gimple_debug_bind_has_value_p (stmt))
|
&& !gimple_debug_bind_has_value_p (stmt))
|
continue;
|
continue;
|
|
|
/* Verify the single virtual operand and its constraints. */
|
/* Verify the single virtual operand and its constraints. */
|
has_err = false;
|
has_err = false;
|
if (gimple_vdef (stmt))
|
if (gimple_vdef (stmt))
|
{
|
{
|
if (gimple_vdef_op (stmt) == NULL_DEF_OPERAND_P)
|
if (gimple_vdef_op (stmt) == NULL_DEF_OPERAND_P)
|
{
|
{
|
error ("statement has VDEF operand not in defs list");
|
error ("statement has VDEF operand not in defs list");
|
has_err = true;
|
has_err = true;
|
}
|
}
|
if (!gimple_vuse (stmt))
|
if (!gimple_vuse (stmt))
|
{
|
{
|
error ("statement has VDEF but no VUSE operand");
|
error ("statement has VDEF but no VUSE operand");
|
has_err = true;
|
has_err = true;
|
}
|
}
|
else if (SSA_NAME_VAR (gimple_vdef (stmt))
|
else if (SSA_NAME_VAR (gimple_vdef (stmt))
|
!= SSA_NAME_VAR (gimple_vuse (stmt)))
|
!= SSA_NAME_VAR (gimple_vuse (stmt)))
|
{
|
{
|
error ("VDEF and VUSE do not use the same symbol");
|
error ("VDEF and VUSE do not use the same symbol");
|
has_err = true;
|
has_err = true;
|
}
|
}
|
has_err |= verify_ssa_name (gimple_vdef (stmt), true);
|
has_err |= verify_ssa_name (gimple_vdef (stmt), true);
|
}
|
}
|
if (gimple_vuse (stmt))
|
if (gimple_vuse (stmt))
|
{
|
{
|
if (gimple_vuse_op (stmt) == NULL_USE_OPERAND_P)
|
if (gimple_vuse_op (stmt) == NULL_USE_OPERAND_P)
|
{
|
{
|
error ("statement has VUSE operand not in uses list");
|
error ("statement has VUSE operand not in uses list");
|
has_err = true;
|
has_err = true;
|
}
|
}
|
has_err |= verify_ssa_name (gimple_vuse (stmt), true);
|
has_err |= verify_ssa_name (gimple_vuse (stmt), true);
|
}
|
}
|
if (has_err)
|
if (has_err)
|
{
|
{
|
error ("in statement");
|
error ("in statement");
|
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
|
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
|
goto err;
|
goto err;
|
}
|
}
|
|
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE|SSA_OP_DEF)
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE|SSA_OP_DEF)
|
{
|
{
|
if (verify_ssa_name (op, false))
|
if (verify_ssa_name (op, false))
|
{
|
{
|
error ("in statement");
|
error ("in statement");
|
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
|
print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
|
goto err;
|
goto err;
|
}
|
}
|
}
|
}
|
|
|
FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
|
FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
|
{
|
{
|
op = USE_FROM_PTR (use_p);
|
op = USE_FROM_PTR (use_p);
|
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
|
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
|
use_p, stmt, false, names_defined_in_bb))
|
use_p, stmt, false, names_defined_in_bb))
|
goto err;
|
goto err;
|
}
|
}
|
|
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
|
{
|
{
|
if (SSA_NAME_DEF_STMT (op) != stmt)
|
if (SSA_NAME_DEF_STMT (op) != stmt)
|
{
|
{
|
error ("SSA_NAME_DEF_STMT is wrong");
|
error ("SSA_NAME_DEF_STMT is wrong");
|
fprintf (stderr, "Expected definition statement:\n");
|
fprintf (stderr, "Expected definition statement:\n");
|
print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
|
print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
|
fprintf (stderr, "\nActual definition statement:\n");
|
fprintf (stderr, "\nActual definition statement:\n");
|
print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (op),
|
print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (op),
|
4, TDF_VOPS);
|
4, TDF_VOPS);
|
goto err;
|
goto err;
|
}
|
}
|
bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op));
|
bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op));
|
}
|
}
|
}
|
}
|
|
|
bitmap_clear (names_defined_in_bb);
|
bitmap_clear (names_defined_in_bb);
|
}
|
}
|
|
|
free (definition_block);
|
free (definition_block);
|
|
|
/* Restore the dominance information to its prior known state, so
|
/* Restore the dominance information to its prior known state, so
|
that we do not perturb the compiler's subsequent behavior. */
|
that we do not perturb the compiler's subsequent behavior. */
|
if (orig_dom_state == DOM_NONE)
|
if (orig_dom_state == DOM_NONE)
|
free_dominance_info (CDI_DOMINATORS);
|
free_dominance_info (CDI_DOMINATORS);
|
else
|
else
|
set_dom_info_availability (CDI_DOMINATORS, orig_dom_state);
|
set_dom_info_availability (CDI_DOMINATORS, orig_dom_state);
|
|
|
BITMAP_FREE (names_defined_in_bb);
|
BITMAP_FREE (names_defined_in_bb);
|
timevar_pop (TV_TREE_SSA_VERIFY);
|
timevar_pop (TV_TREE_SSA_VERIFY);
|
return;
|
return;
|
|
|
err:
|
err:
|
internal_error ("verify_ssa failed");
|
internal_error ("verify_ssa failed");
|
}
|
}
|
|
|
/* Return true if the uid in both int tree maps are equal. */
|
/* Return true if the uid in both int tree maps are equal. */
|
|
|
int
|
int
|
int_tree_map_eq (const void *va, const void *vb)
|
int_tree_map_eq (const void *va, const void *vb)
|
{
|
{
|
const struct int_tree_map *a = (const struct int_tree_map *) va;
|
const struct int_tree_map *a = (const struct int_tree_map *) va;
|
const struct int_tree_map *b = (const struct int_tree_map *) vb;
|
const struct int_tree_map *b = (const struct int_tree_map *) vb;
|
return (a->uid == b->uid);
|
return (a->uid == b->uid);
|
}
|
}
|
|
|
/* Hash a UID in a int_tree_map. */
|
/* Hash a UID in a int_tree_map. */
|
|
|
unsigned int
|
unsigned int
|
int_tree_map_hash (const void *item)
|
int_tree_map_hash (const void *item)
|
{
|
{
|
return ((const struct int_tree_map *)item)->uid;
|
return ((const struct int_tree_map *)item)->uid;
|
}
|
}
|
|
|
/* Return true if the DECL_UID in both trees are equal. */
|
/* Return true if the DECL_UID in both trees are equal. */
|
|
|
int
|
int
|
uid_decl_map_eq (const void *va, const void *vb)
|
uid_decl_map_eq (const void *va, const void *vb)
|
{
|
{
|
const_tree a = (const_tree) va;
|
const_tree a = (const_tree) va;
|
const_tree b = (const_tree) vb;
|
const_tree b = (const_tree) vb;
|
return (a->decl_minimal.uid == b->decl_minimal.uid);
|
return (a->decl_minimal.uid == b->decl_minimal.uid);
|
}
|
}
|
|
|
/* Hash a tree in a uid_decl_map. */
|
/* Hash a tree in a uid_decl_map. */
|
|
|
unsigned int
|
unsigned int
|
uid_decl_map_hash (const void *item)
|
uid_decl_map_hash (const void *item)
|
{
|
{
|
return ((const_tree)item)->decl_minimal.uid;
|
return ((const_tree)item)->decl_minimal.uid;
|
}
|
}
|
|
|
/* Return true if the DECL_UID in both trees are equal. */
|
/* Return true if the DECL_UID in both trees are equal. */
|
|
|
static int
|
static int
|
uid_ssaname_map_eq (const void *va, const void *vb)
|
uid_ssaname_map_eq (const void *va, const void *vb)
|
{
|
{
|
const_tree a = (const_tree) va;
|
const_tree a = (const_tree) va;
|
const_tree b = (const_tree) vb;
|
const_tree b = (const_tree) vb;
|
return (a->ssa_name.var->decl_minimal.uid == b->ssa_name.var->decl_minimal.uid);
|
return (a->ssa_name.var->decl_minimal.uid == b->ssa_name.var->decl_minimal.uid);
|
}
|
}
|
|
|
/* Hash a tree in a uid_decl_map. */
|
/* Hash a tree in a uid_decl_map. */
|
|
|
static unsigned int
|
static unsigned int
|
uid_ssaname_map_hash (const void *item)
|
uid_ssaname_map_hash (const void *item)
|
{
|
{
|
return ((const_tree)item)->ssa_name.var->decl_minimal.uid;
|
return ((const_tree)item)->ssa_name.var->decl_minimal.uid;
|
}
|
}
|
|
|
|
|
/* Initialize global DFA and SSA structures. */
|
/* Initialize global DFA and SSA structures. */
|
|
|
void
|
void
|
init_tree_ssa (struct function *fn)
|
init_tree_ssa (struct function *fn)
|
{
|
{
|
fn->gimple_df = GGC_CNEW (struct gimple_df);
|
fn->gimple_df = GGC_CNEW (struct gimple_df);
|
fn->gimple_df->referenced_vars = htab_create_ggc (20, uid_decl_map_hash,
|
fn->gimple_df->referenced_vars = htab_create_ggc (20, uid_decl_map_hash,
|
uid_decl_map_eq, NULL);
|
uid_decl_map_eq, NULL);
|
fn->gimple_df->default_defs = htab_create_ggc (20, uid_ssaname_map_hash,
|
fn->gimple_df->default_defs = htab_create_ggc (20, uid_ssaname_map_hash,
|
uid_ssaname_map_eq, NULL);
|
uid_ssaname_map_eq, NULL);
|
pt_solution_reset (&fn->gimple_df->escaped);
|
pt_solution_reset (&fn->gimple_df->escaped);
|
pt_solution_reset (&fn->gimple_df->callused);
|
pt_solution_reset (&fn->gimple_df->callused);
|
init_ssanames (fn, 0);
|
init_ssanames (fn, 0);
|
init_phinodes ();
|
init_phinodes ();
|
}
|
}
|
|
|
|
|
/* Deallocate memory associated with SSA data structures for FNDECL. */
|
/* Deallocate memory associated with SSA data structures for FNDECL. */
|
|
|
void
|
void
|
delete_tree_ssa (void)
|
delete_tree_ssa (void)
|
{
|
{
|
referenced_var_iterator rvi;
|
referenced_var_iterator rvi;
|
tree var;
|
tree var;
|
|
|
/* Remove annotations from every referenced local variable. */
|
/* Remove annotations from every referenced local variable. */
|
FOR_EACH_REFERENCED_VAR (var, rvi)
|
FOR_EACH_REFERENCED_VAR (var, rvi)
|
{
|
{
|
if (is_global_var (var))
|
if (is_global_var (var))
|
continue;
|
continue;
|
if (var_ann (var))
|
if (var_ann (var))
|
{
|
{
|
ggc_free (var_ann (var));
|
ggc_free (var_ann (var));
|
*DECL_VAR_ANN_PTR (var) = NULL;
|
*DECL_VAR_ANN_PTR (var) = NULL;
|
}
|
}
|
}
|
}
|
htab_delete (gimple_referenced_vars (cfun));
|
htab_delete (gimple_referenced_vars (cfun));
|
cfun->gimple_df->referenced_vars = NULL;
|
cfun->gimple_df->referenced_vars = NULL;
|
|
|
fini_ssanames ();
|
fini_ssanames ();
|
fini_phinodes ();
|
fini_phinodes ();
|
|
|
/* We no longer maintain the SSA operand cache at this point. */
|
/* We no longer maintain the SSA operand cache at this point. */
|
if (ssa_operands_active ())
|
if (ssa_operands_active ())
|
fini_ssa_operands ();
|
fini_ssa_operands ();
|
|
|
delete_alias_heapvars ();
|
delete_alias_heapvars ();
|
|
|
htab_delete (cfun->gimple_df->default_defs);
|
htab_delete (cfun->gimple_df->default_defs);
|
cfun->gimple_df->default_defs = NULL;
|
cfun->gimple_df->default_defs = NULL;
|
pt_solution_reset (&cfun->gimple_df->escaped);
|
pt_solution_reset (&cfun->gimple_df->escaped);
|
pt_solution_reset (&cfun->gimple_df->callused);
|
pt_solution_reset (&cfun->gimple_df->callused);
|
if (cfun->gimple_df->decls_to_pointers != NULL)
|
if (cfun->gimple_df->decls_to_pointers != NULL)
|
pointer_map_destroy (cfun->gimple_df->decls_to_pointers);
|
pointer_map_destroy (cfun->gimple_df->decls_to_pointers);
|
cfun->gimple_df->decls_to_pointers = NULL;
|
cfun->gimple_df->decls_to_pointers = NULL;
|
cfun->gimple_df->modified_noreturn_calls = NULL;
|
cfun->gimple_df->modified_noreturn_calls = NULL;
|
cfun->gimple_df = NULL;
|
cfun->gimple_df = NULL;
|
|
|
/* We no longer need the edge variable maps. */
|
/* We no longer need the edge variable maps. */
|
redirect_edge_var_map_destroy ();
|
redirect_edge_var_map_destroy ();
|
}
|
}
|
|
|
/* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
|
/* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
|
useless type conversion, otherwise return false.
|
useless type conversion, otherwise return false.
|
|
|
This function implicitly defines the middle-end type system. With
|
This function implicitly defines the middle-end type system. With
|
the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
|
the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
|
holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
|
holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
|
the following invariants shall be fulfilled:
|
the following invariants shall be fulfilled:
|
|
|
1) useless_type_conversion_p is transitive.
|
1) useless_type_conversion_p is transitive.
|
If a < b and b < c then a < c.
|
If a < b and b < c then a < c.
|
|
|
2) useless_type_conversion_p is not symmetric.
|
2) useless_type_conversion_p is not symmetric.
|
From a < b does not follow a > b.
|
From a < b does not follow a > b.
|
|
|
3) Types define the available set of operations applicable to values.
|
3) Types define the available set of operations applicable to values.
|
A type conversion is useless if the operations for the target type
|
A type conversion is useless if the operations for the target type
|
is a subset of the operations for the source type. For example
|
is a subset of the operations for the source type. For example
|
casts to void* are useless, casts from void* are not (void* can't
|
casts to void* are useless, casts from void* are not (void* can't
|
be dereferenced or offsetted, but copied, hence its set of operations
|
be dereferenced or offsetted, but copied, hence its set of operations
|
is a strict subset of that of all other data pointer types). Casts
|
is a strict subset of that of all other data pointer types). Casts
|
to const T* are useless (can't be written to), casts from const T*
|
to const T* are useless (can't be written to), casts from const T*
|
to T* are not. */
|
to T* are not. */
|
|
|
bool
|
bool
|
useless_type_conversion_p (tree outer_type, tree inner_type)
|
useless_type_conversion_p (tree outer_type, tree inner_type)
|
{
|
{
|
/* Do the following before stripping toplevel qualifiers. */
|
/* Do the following before stripping toplevel qualifiers. */
|
if (POINTER_TYPE_P (inner_type)
|
if (POINTER_TYPE_P (inner_type)
|
&& POINTER_TYPE_P (outer_type))
|
&& POINTER_TYPE_P (outer_type))
|
{
|
{
|
/* Do not lose casts between pointers to different address spaces. */
|
/* Do not lose casts between pointers to different address spaces. */
|
if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type))
|
if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type))
|
!= TYPE_ADDR_SPACE (TREE_TYPE (inner_type)))
|
!= TYPE_ADDR_SPACE (TREE_TYPE (inner_type)))
|
return false;
|
return false;
|
|
|
/* If the outer type is (void *) or a pointer to an incomplete
|
/* If the outer type is (void *) or a pointer to an incomplete
|
record type or a pointer to an unprototyped function,
|
record type or a pointer to an unprototyped function,
|
then the conversion is not necessary. */
|
then the conversion is not necessary. */
|
if (VOID_TYPE_P (TREE_TYPE (outer_type))
|
if (VOID_TYPE_P (TREE_TYPE (outer_type))
|
|| ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE
|
|| ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE
|
|| TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE)
|
|| TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE)
|
&& (TREE_CODE (TREE_TYPE (outer_type))
|
&& (TREE_CODE (TREE_TYPE (outer_type))
|
== TREE_CODE (TREE_TYPE (inner_type)))
|
== TREE_CODE (TREE_TYPE (inner_type)))
|
&& !TYPE_ARG_TYPES (TREE_TYPE (outer_type))
|
&& !TYPE_ARG_TYPES (TREE_TYPE (outer_type))
|
&& useless_type_conversion_p (TREE_TYPE (TREE_TYPE (outer_type)),
|
&& useless_type_conversion_p (TREE_TYPE (TREE_TYPE (outer_type)),
|
TREE_TYPE (TREE_TYPE (inner_type)))))
|
TREE_TYPE (TREE_TYPE (inner_type)))))
|
return true;
|
return true;
|
|
|
/* Do not lose casts to restrict qualified pointers. */
|
/* Do not lose casts to restrict qualified pointers. */
|
if ((TYPE_RESTRICT (outer_type)
|
if ((TYPE_RESTRICT (outer_type)
|
!= TYPE_RESTRICT (inner_type))
|
!= TYPE_RESTRICT (inner_type))
|
&& TYPE_RESTRICT (outer_type))
|
&& TYPE_RESTRICT (outer_type))
|
return false;
|
return false;
|
}
|
}
|
|
|
/* From now on qualifiers on value types do not matter. */
|
/* From now on qualifiers on value types do not matter. */
|
inner_type = TYPE_MAIN_VARIANT (inner_type);
|
inner_type = TYPE_MAIN_VARIANT (inner_type);
|
outer_type = TYPE_MAIN_VARIANT (outer_type);
|
outer_type = TYPE_MAIN_VARIANT (outer_type);
|
|
|
if (inner_type == outer_type)
|
if (inner_type == outer_type)
|
return true;
|
return true;
|
|
|
/* If we know the canonical types, compare them. */
|
/* If we know the canonical types, compare them. */
|
if (TYPE_CANONICAL (inner_type)
|
if (TYPE_CANONICAL (inner_type)
|
&& TYPE_CANONICAL (inner_type) == TYPE_CANONICAL (outer_type))
|
&& TYPE_CANONICAL (inner_type) == TYPE_CANONICAL (outer_type))
|
return true;
|
return true;
|
|
|
/* Changes in machine mode are never useless conversions unless we
|
/* Changes in machine mode are never useless conversions unless we
|
deal with aggregate types in which case we defer to later checks. */
|
deal with aggregate types in which case we defer to later checks. */
|
if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type)
|
if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type)
|
&& !AGGREGATE_TYPE_P (inner_type))
|
&& !AGGREGATE_TYPE_P (inner_type))
|
return false;
|
return false;
|
|
|
/* If both the inner and outer types are integral types, then the
|
/* If both the inner and outer types are integral types, then the
|
conversion is not necessary if they have the same mode and
|
conversion is not necessary if they have the same mode and
|
signedness and precision, and both or neither are boolean. */
|
signedness and precision, and both or neither are boolean. */
|
if (INTEGRAL_TYPE_P (inner_type)
|
if (INTEGRAL_TYPE_P (inner_type)
|
&& INTEGRAL_TYPE_P (outer_type))
|
&& INTEGRAL_TYPE_P (outer_type))
|
{
|
{
|
/* Preserve changes in signedness or precision. */
|
/* Preserve changes in signedness or precision. */
|
if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
|
if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
|
|| TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
|
|| TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
|
return false;
|
return false;
|
|
|
/* We don't need to preserve changes in the types minimum or
|
/* We don't need to preserve changes in the types minimum or
|
maximum value in general as these do not generate code
|
maximum value in general as these do not generate code
|
unless the types precisions are different. */
|
unless the types precisions are different. */
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Scalar floating point types with the same mode are compatible. */
|
/* Scalar floating point types with the same mode are compatible. */
|
else if (SCALAR_FLOAT_TYPE_P (inner_type)
|
else if (SCALAR_FLOAT_TYPE_P (inner_type)
|
&& SCALAR_FLOAT_TYPE_P (outer_type))
|
&& SCALAR_FLOAT_TYPE_P (outer_type))
|
return true;
|
return true;
|
|
|
/* Fixed point types with the same mode are compatible. */
|
/* Fixed point types with the same mode are compatible. */
|
else if (FIXED_POINT_TYPE_P (inner_type)
|
else if (FIXED_POINT_TYPE_P (inner_type)
|
&& FIXED_POINT_TYPE_P (outer_type))
|
&& FIXED_POINT_TYPE_P (outer_type))
|
return true;
|
return true;
|
|
|
/* We need to take special care recursing to pointed-to types. */
|
/* We need to take special care recursing to pointed-to types. */
|
else if (POINTER_TYPE_P (inner_type)
|
else if (POINTER_TYPE_P (inner_type)
|
&& POINTER_TYPE_P (outer_type))
|
&& POINTER_TYPE_P (outer_type))
|
{
|
{
|
/* Don't lose casts between pointers to volatile and non-volatile
|
/* Don't lose casts between pointers to volatile and non-volatile
|
qualified types. Doing so would result in changing the semantics
|
qualified types. Doing so would result in changing the semantics
|
of later accesses. For function types the volatile qualifier
|
of later accesses. For function types the volatile qualifier
|
is used to indicate noreturn functions. */
|
is used to indicate noreturn functions. */
|
if (TREE_CODE (TREE_TYPE (outer_type)) != FUNCTION_TYPE
|
if (TREE_CODE (TREE_TYPE (outer_type)) != FUNCTION_TYPE
|
&& TREE_CODE (TREE_TYPE (outer_type)) != METHOD_TYPE
|
&& TREE_CODE (TREE_TYPE (outer_type)) != METHOD_TYPE
|
&& TREE_CODE (TREE_TYPE (inner_type)) != FUNCTION_TYPE
|
&& TREE_CODE (TREE_TYPE (inner_type)) != FUNCTION_TYPE
|
&& TREE_CODE (TREE_TYPE (inner_type)) != METHOD_TYPE
|
&& TREE_CODE (TREE_TYPE (inner_type)) != METHOD_TYPE
|
&& (TYPE_VOLATILE (TREE_TYPE (outer_type))
|
&& (TYPE_VOLATILE (TREE_TYPE (outer_type))
|
!= TYPE_VOLATILE (TREE_TYPE (inner_type)))
|
!= TYPE_VOLATILE (TREE_TYPE (inner_type)))
|
&& TYPE_VOLATILE (TREE_TYPE (outer_type)))
|
&& TYPE_VOLATILE (TREE_TYPE (outer_type)))
|
return false;
|
return false;
|
|
|
/* We require explicit conversions from incomplete target types. */
|
/* We require explicit conversions from incomplete target types. */
|
if (!COMPLETE_TYPE_P (TREE_TYPE (inner_type))
|
if (!COMPLETE_TYPE_P (TREE_TYPE (inner_type))
|
&& COMPLETE_TYPE_P (TREE_TYPE (outer_type)))
|
&& COMPLETE_TYPE_P (TREE_TYPE (outer_type)))
|
return false;
|
return false;
|
|
|
/* Do not lose casts between pointers that when dereferenced access
|
/* Do not lose casts between pointers that when dereferenced access
|
memory with different alias sets. */
|
memory with different alias sets. */
|
if (get_deref_alias_set (inner_type) != get_deref_alias_set (outer_type))
|
if (get_deref_alias_set (inner_type) != get_deref_alias_set (outer_type))
|
return false;
|
return false;
|
|
|
/* We do not care for const qualification of the pointed-to types
|
/* We do not care for const qualification of the pointed-to types
|
as const qualification has no semantic value to the middle-end. */
|
as const qualification has no semantic value to the middle-end. */
|
|
|
/* Otherwise pointers/references are equivalent if their pointed
|
/* Otherwise pointers/references are equivalent if their pointed
|
to types are effectively the same. We can strip qualifiers
|
to types are effectively the same. We can strip qualifiers
|
on pointed-to types for further comparison, which is done in
|
on pointed-to types for further comparison, which is done in
|
the callee. Note we have to use true compatibility here
|
the callee. Note we have to use true compatibility here
|
because addresses are subject to propagation into dereferences
|
because addresses are subject to propagation into dereferences
|
and thus might get the original type exposed which is equivalent
|
and thus might get the original type exposed which is equivalent
|
to a reverse conversion. */
|
to a reverse conversion. */
|
return types_compatible_p (TREE_TYPE (outer_type),
|
return types_compatible_p (TREE_TYPE (outer_type),
|
TREE_TYPE (inner_type));
|
TREE_TYPE (inner_type));
|
}
|
}
|
|
|
/* Recurse for complex types. */
|
/* Recurse for complex types. */
|
else if (TREE_CODE (inner_type) == COMPLEX_TYPE
|
else if (TREE_CODE (inner_type) == COMPLEX_TYPE
|
&& TREE_CODE (outer_type) == COMPLEX_TYPE)
|
&& TREE_CODE (outer_type) == COMPLEX_TYPE)
|
return useless_type_conversion_p (TREE_TYPE (outer_type),
|
return useless_type_conversion_p (TREE_TYPE (outer_type),
|
TREE_TYPE (inner_type));
|
TREE_TYPE (inner_type));
|
|
|
/* Recurse for vector types with the same number of subparts. */
|
/* Recurse for vector types with the same number of subparts. */
|
else if (TREE_CODE (inner_type) == VECTOR_TYPE
|
else if (TREE_CODE (inner_type) == VECTOR_TYPE
|
&& TREE_CODE (outer_type) == VECTOR_TYPE
|
&& TREE_CODE (outer_type) == VECTOR_TYPE
|
&& TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type))
|
&& TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type))
|
return useless_type_conversion_p (TREE_TYPE (outer_type),
|
return useless_type_conversion_p (TREE_TYPE (outer_type),
|
TREE_TYPE (inner_type));
|
TREE_TYPE (inner_type));
|
|
|
else if (TREE_CODE (inner_type) == ARRAY_TYPE
|
else if (TREE_CODE (inner_type) == ARRAY_TYPE
|
&& TREE_CODE (outer_type) == ARRAY_TYPE)
|
&& TREE_CODE (outer_type) == ARRAY_TYPE)
|
{
|
{
|
/* Preserve string attributes. */
|
/* Preserve string attributes. */
|
if (TYPE_STRING_FLAG (inner_type) != TYPE_STRING_FLAG (outer_type))
|
if (TYPE_STRING_FLAG (inner_type) != TYPE_STRING_FLAG (outer_type))
|
return false;
|
return false;
|
|
|
/* Conversions from array types with unknown extent to
|
/* Conversions from array types with unknown extent to
|
array types with known extent are not useless. */
|
array types with known extent are not useless. */
|
if (!TYPE_DOMAIN (inner_type)
|
if (!TYPE_DOMAIN (inner_type)
|
&& TYPE_DOMAIN (outer_type))
|
&& TYPE_DOMAIN (outer_type))
|
return false;
|
return false;
|
|
|
/* Nor are conversions from array types with non-constant size to
|
/* Nor are conversions from array types with non-constant size to
|
array types with constant size or to different size. */
|
array types with constant size or to different size. */
|
if (TYPE_SIZE (outer_type)
|
if (TYPE_SIZE (outer_type)
|
&& TREE_CODE (TYPE_SIZE (outer_type)) == INTEGER_CST
|
&& TREE_CODE (TYPE_SIZE (outer_type)) == INTEGER_CST
|
&& (!TYPE_SIZE (inner_type)
|
&& (!TYPE_SIZE (inner_type)
|
|| TREE_CODE (TYPE_SIZE (inner_type)) != INTEGER_CST
|
|| TREE_CODE (TYPE_SIZE (inner_type)) != INTEGER_CST
|
|| !tree_int_cst_equal (TYPE_SIZE (outer_type),
|
|| !tree_int_cst_equal (TYPE_SIZE (outer_type),
|
TYPE_SIZE (inner_type))))
|
TYPE_SIZE (inner_type))))
|
return false;
|
return false;
|
|
|
/* Check conversions between arrays with partially known extents.
|
/* Check conversions between arrays with partially known extents.
|
If the array min/max values are constant they have to match.
|
If the array min/max values are constant they have to match.
|
Otherwise allow conversions to unknown and variable extents.
|
Otherwise allow conversions to unknown and variable extents.
|
In particular this declares conversions that may change the
|
In particular this declares conversions that may change the
|
mode to BLKmode as useless. */
|
mode to BLKmode as useless. */
|
if (TYPE_DOMAIN (inner_type)
|
if (TYPE_DOMAIN (inner_type)
|
&& TYPE_DOMAIN (outer_type)
|
&& TYPE_DOMAIN (outer_type)
|
&& TYPE_DOMAIN (inner_type) != TYPE_DOMAIN (outer_type))
|
&& TYPE_DOMAIN (inner_type) != TYPE_DOMAIN (outer_type))
|
{
|
{
|
tree inner_min = TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type));
|
tree inner_min = TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type));
|
tree outer_min = TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type));
|
tree outer_min = TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type));
|
tree inner_max = TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type));
|
tree inner_max = TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type));
|
tree outer_max = TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type));
|
tree outer_max = TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type));
|
|
|
/* After gimplification a variable min/max value carries no
|
/* After gimplification a variable min/max value carries no
|
additional information compared to a NULL value. All that
|
additional information compared to a NULL value. All that
|
matters has been lowered to be part of the IL. */
|
matters has been lowered to be part of the IL. */
|
if (inner_min && TREE_CODE (inner_min) != INTEGER_CST)
|
if (inner_min && TREE_CODE (inner_min) != INTEGER_CST)
|
inner_min = NULL_TREE;
|
inner_min = NULL_TREE;
|
if (outer_min && TREE_CODE (outer_min) != INTEGER_CST)
|
if (outer_min && TREE_CODE (outer_min) != INTEGER_CST)
|
outer_min = NULL_TREE;
|
outer_min = NULL_TREE;
|
if (inner_max && TREE_CODE (inner_max) != INTEGER_CST)
|
if (inner_max && TREE_CODE (inner_max) != INTEGER_CST)
|
inner_max = NULL_TREE;
|
inner_max = NULL_TREE;
|
if (outer_max && TREE_CODE (outer_max) != INTEGER_CST)
|
if (outer_max && TREE_CODE (outer_max) != INTEGER_CST)
|
outer_max = NULL_TREE;
|
outer_max = NULL_TREE;
|
|
|
/* Conversions NULL / variable <- cst are useless, but not
|
/* Conversions NULL / variable <- cst are useless, but not
|
the other way around. */
|
the other way around. */
|
if (outer_min
|
if (outer_min
|
&& (!inner_min
|
&& (!inner_min
|
|| !tree_int_cst_equal (inner_min, outer_min)))
|
|| !tree_int_cst_equal (inner_min, outer_min)))
|
return false;
|
return false;
|
if (outer_max
|
if (outer_max
|
&& (!inner_max
|
&& (!inner_max
|
|| !tree_int_cst_equal (inner_max, outer_max)))
|
|| !tree_int_cst_equal (inner_max, outer_max)))
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Recurse on the element check. */
|
/* Recurse on the element check. */
|
return useless_type_conversion_p (TREE_TYPE (outer_type),
|
return useless_type_conversion_p (TREE_TYPE (outer_type),
|
TREE_TYPE (inner_type));
|
TREE_TYPE (inner_type));
|
}
|
}
|
|
|
else if ((TREE_CODE (inner_type) == FUNCTION_TYPE
|
else if ((TREE_CODE (inner_type) == FUNCTION_TYPE
|
|| TREE_CODE (inner_type) == METHOD_TYPE)
|
|| TREE_CODE (inner_type) == METHOD_TYPE)
|
&& TREE_CODE (inner_type) == TREE_CODE (outer_type))
|
&& TREE_CODE (inner_type) == TREE_CODE (outer_type))
|
{
|
{
|
tree outer_parm, inner_parm;
|
tree outer_parm, inner_parm;
|
|
|
/* If the return types are not compatible bail out. */
|
/* If the return types are not compatible bail out. */
|
if (!useless_type_conversion_p (TREE_TYPE (outer_type),
|
if (!useless_type_conversion_p (TREE_TYPE (outer_type),
|
TREE_TYPE (inner_type)))
|
TREE_TYPE (inner_type)))
|
return false;
|
return false;
|
|
|
/* Method types should belong to a compatible base class. */
|
/* Method types should belong to a compatible base class. */
|
if (TREE_CODE (inner_type) == METHOD_TYPE
|
if (TREE_CODE (inner_type) == METHOD_TYPE
|
&& !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type),
|
&& !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type),
|
TYPE_METHOD_BASETYPE (inner_type)))
|
TYPE_METHOD_BASETYPE (inner_type)))
|
return false;
|
return false;
|
|
|
/* A conversion to an unprototyped argument list is ok. */
|
/* A conversion to an unprototyped argument list is ok. */
|
if (!TYPE_ARG_TYPES (outer_type))
|
if (!TYPE_ARG_TYPES (outer_type))
|
return true;
|
return true;
|
|
|
/* If the unqualified argument types are compatible the conversion
|
/* If the unqualified argument types are compatible the conversion
|
is useless. */
|
is useless. */
|
if (TYPE_ARG_TYPES (outer_type) == TYPE_ARG_TYPES (inner_type))
|
if (TYPE_ARG_TYPES (outer_type) == TYPE_ARG_TYPES (inner_type))
|
return true;
|
return true;
|
|
|
for (outer_parm = TYPE_ARG_TYPES (outer_type),
|
for (outer_parm = TYPE_ARG_TYPES (outer_type),
|
inner_parm = TYPE_ARG_TYPES (inner_type);
|
inner_parm = TYPE_ARG_TYPES (inner_type);
|
outer_parm && inner_parm;
|
outer_parm && inner_parm;
|
outer_parm = TREE_CHAIN (outer_parm),
|
outer_parm = TREE_CHAIN (outer_parm),
|
inner_parm = TREE_CHAIN (inner_parm))
|
inner_parm = TREE_CHAIN (inner_parm))
|
if (!useless_type_conversion_p
|
if (!useless_type_conversion_p
|
(TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm)),
|
(TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm)),
|
TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm))))
|
TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm))))
|
return false;
|
return false;
|
|
|
/* If there is a mismatch in the number of arguments the functions
|
/* If there is a mismatch in the number of arguments the functions
|
are not compatible. */
|
are not compatible. */
|
if (outer_parm || inner_parm)
|
if (outer_parm || inner_parm)
|
return false;
|
return false;
|
|
|
/* Defer to the target if necessary. */
|
/* Defer to the target if necessary. */
|
if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type))
|
if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type))
|
return targetm.comp_type_attributes (outer_type, inner_type) != 0;
|
return targetm.comp_type_attributes (outer_type, inner_type) != 0;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* For aggregates we rely on TYPE_CANONICAL exclusively and require
|
/* For aggregates we rely on TYPE_CANONICAL exclusively and require
|
explicit conversions for types involving to be structurally
|
explicit conversions for types involving to be structurally
|
compared types. */
|
compared types. */
|
else if (AGGREGATE_TYPE_P (inner_type)
|
else if (AGGREGATE_TYPE_P (inner_type)
|
&& TREE_CODE (inner_type) == TREE_CODE (outer_type))
|
&& TREE_CODE (inner_type) == TREE_CODE (outer_type))
|
return false;
|
return false;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return true if a conversion from either type of TYPE1 and TYPE2
|
/* Return true if a conversion from either type of TYPE1 and TYPE2
|
to the other is not required. Otherwise return false. */
|
to the other is not required. Otherwise return false. */
|
|
|
bool
|
bool
|
types_compatible_p (tree type1, tree type2)
|
types_compatible_p (tree type1, tree type2)
|
{
|
{
|
return (type1 == type2
|
return (type1 == type2
|
|| (useless_type_conversion_p (type1, type2)
|
|| (useless_type_conversion_p (type1, type2)
|
&& useless_type_conversion_p (type2, type1)));
|
&& useless_type_conversion_p (type2, type1)));
|
}
|
}
|
|
|
/* Return true if EXPR is a useless type conversion, otherwise return
|
/* Return true if EXPR is a useless type conversion, otherwise return
|
false. */
|
false. */
|
|
|
bool
|
bool
|
tree_ssa_useless_type_conversion (tree expr)
|
tree_ssa_useless_type_conversion (tree expr)
|
{
|
{
|
/* If we have an assignment that merely uses a NOP_EXPR to change
|
/* If we have an assignment that merely uses a NOP_EXPR to change
|
the top of the RHS to the type of the LHS and the type conversion
|
the top of the RHS to the type of the LHS and the type conversion
|
is "safe", then strip away the type conversion so that we can
|
is "safe", then strip away the type conversion so that we can
|
enter LHS = RHS into the const_and_copies table. */
|
enter LHS = RHS into the const_and_copies table. */
|
if (CONVERT_EXPR_P (expr)
|
if (CONVERT_EXPR_P (expr)
|
|| TREE_CODE (expr) == VIEW_CONVERT_EXPR
|
|| TREE_CODE (expr) == VIEW_CONVERT_EXPR
|
|| TREE_CODE (expr) == NON_LVALUE_EXPR)
|
|| TREE_CODE (expr) == NON_LVALUE_EXPR)
|
return useless_type_conversion_p
|
return useless_type_conversion_p
|
(TREE_TYPE (expr),
|
(TREE_TYPE (expr),
|
TREE_TYPE (TREE_OPERAND (expr, 0)));
|
TREE_TYPE (TREE_OPERAND (expr, 0)));
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Strip conversions from EXP according to
|
/* Strip conversions from EXP according to
|
tree_ssa_useless_type_conversion and return the resulting
|
tree_ssa_useless_type_conversion and return the resulting
|
expression. */
|
expression. */
|
|
|
tree
|
tree
|
tree_ssa_strip_useless_type_conversions (tree exp)
|
tree_ssa_strip_useless_type_conversions (tree exp)
|
{
|
{
|
while (tree_ssa_useless_type_conversion (exp))
|
while (tree_ssa_useless_type_conversion (exp))
|
exp = TREE_OPERAND (exp, 0);
|
exp = TREE_OPERAND (exp, 0);
|
return exp;
|
return exp;
|
}
|
}
|
|
|
|
|
/* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
|
/* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
|
described in walk_use_def_chains.
|
described in walk_use_def_chains.
|
|
|
VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
|
VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
|
infinite loops. We used to have a bitmap for this to just mark
|
infinite loops. We used to have a bitmap for this to just mark
|
SSA versions we had visited. But non-sparse bitmaps are way too
|
SSA versions we had visited. But non-sparse bitmaps are way too
|
expensive, while sparse bitmaps may cause quadratic behavior.
|
expensive, while sparse bitmaps may cause quadratic behavior.
|
|
|
IS_DFS is true if the caller wants to perform a depth-first search
|
IS_DFS is true if the caller wants to perform a depth-first search
|
when visiting PHI nodes. A DFS will visit each PHI argument and
|
when visiting PHI nodes. A DFS will visit each PHI argument and
|
call FN after each one. Otherwise, all the arguments are
|
call FN after each one. Otherwise, all the arguments are
|
visited first and then FN is called with each of the visited
|
visited first and then FN is called with each of the visited
|
arguments in a separate pass. */
|
arguments in a separate pass. */
|
|
|
static bool
|
static bool
|
walk_use_def_chains_1 (tree var, walk_use_def_chains_fn fn, void *data,
|
walk_use_def_chains_1 (tree var, walk_use_def_chains_fn fn, void *data,
|
struct pointer_set_t *visited, bool is_dfs)
|
struct pointer_set_t *visited, bool is_dfs)
|
{
|
{
|
gimple def_stmt;
|
gimple def_stmt;
|
|
|
if (pointer_set_insert (visited, var))
|
if (pointer_set_insert (visited, var))
|
return false;
|
return false;
|
|
|
def_stmt = SSA_NAME_DEF_STMT (var);
|
def_stmt = SSA_NAME_DEF_STMT (var);
|
|
|
if (gimple_code (def_stmt) != GIMPLE_PHI)
|
if (gimple_code (def_stmt) != GIMPLE_PHI)
|
{
|
{
|
/* If we reached the end of the use-def chain, call FN. */
|
/* If we reached the end of the use-def chain, call FN. */
|
return fn (var, def_stmt, data);
|
return fn (var, def_stmt, data);
|
}
|
}
|
else
|
else
|
{
|
{
|
size_t i;
|
size_t i;
|
|
|
/* When doing a breadth-first search, call FN before following the
|
/* When doing a breadth-first search, call FN before following the
|
use-def links for each argument. */
|
use-def links for each argument. */
|
if (!is_dfs)
|
if (!is_dfs)
|
for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
|
for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
|
if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data))
|
if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data))
|
return true;
|
return true;
|
|
|
/* Follow use-def links out of each PHI argument. */
|
/* Follow use-def links out of each PHI argument. */
|
for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
|
for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
|
{
|
{
|
tree arg = gimple_phi_arg_def (def_stmt, i);
|
tree arg = gimple_phi_arg_def (def_stmt, i);
|
|
|
/* ARG may be NULL for newly introduced PHI nodes. */
|
/* ARG may be NULL for newly introduced PHI nodes. */
|
if (arg
|
if (arg
|
&& TREE_CODE (arg) == SSA_NAME
|
&& TREE_CODE (arg) == SSA_NAME
|
&& walk_use_def_chains_1 (arg, fn, data, visited, is_dfs))
|
&& walk_use_def_chains_1 (arg, fn, data, visited, is_dfs))
|
return true;
|
return true;
|
}
|
}
|
|
|
/* When doing a depth-first search, call FN after following the
|
/* When doing a depth-first search, call FN after following the
|
use-def links for each argument. */
|
use-def links for each argument. */
|
if (is_dfs)
|
if (is_dfs)
|
for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
|
for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
|
if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data))
|
if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data))
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
|
|
/* Walk use-def chains starting at the SSA variable VAR. Call
|
/* Walk use-def chains starting at the SSA variable VAR. Call
|
function FN at each reaching definition found. FN takes three
|
function FN at each reaching definition found. FN takes three
|
arguments: VAR, its defining statement (DEF_STMT) and a generic
|
arguments: VAR, its defining statement (DEF_STMT) and a generic
|
pointer to whatever state information that FN may want to maintain
|
pointer to whatever state information that FN may want to maintain
|
(DATA). FN is able to stop the walk by returning true, otherwise
|
(DATA). FN is able to stop the walk by returning true, otherwise
|
in order to continue the walk, FN should return false.
|
in order to continue the walk, FN should return false.
|
|
|
Note, that if DEF_STMT is a PHI node, the semantics are slightly
|
Note, that if DEF_STMT is a PHI node, the semantics are slightly
|
different. The first argument to FN is no longer the original
|
different. The first argument to FN is no longer the original
|
variable VAR, but the PHI argument currently being examined. If FN
|
variable VAR, but the PHI argument currently being examined. If FN
|
wants to get at VAR, it should call PHI_RESULT (PHI).
|
wants to get at VAR, it should call PHI_RESULT (PHI).
|
|
|
If IS_DFS is true, this function will:
|
If IS_DFS is true, this function will:
|
|
|
1- walk the use-def chains for all the PHI arguments, and,
|
1- walk the use-def chains for all the PHI arguments, and,
|
2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
|
2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
|
|
|
If IS_DFS is false, the two steps above are done in reverse order
|
If IS_DFS is false, the two steps above are done in reverse order
|
(i.e., a breadth-first search). */
|
(i.e., a breadth-first search). */
|
|
|
void
|
void
|
walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
|
walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
|
bool is_dfs)
|
bool is_dfs)
|
{
|
{
|
gimple def_stmt;
|
gimple def_stmt;
|
|
|
gcc_assert (TREE_CODE (var) == SSA_NAME);
|
gcc_assert (TREE_CODE (var) == SSA_NAME);
|
|
|
def_stmt = SSA_NAME_DEF_STMT (var);
|
def_stmt = SSA_NAME_DEF_STMT (var);
|
|
|
/* We only need to recurse if the reaching definition comes from a PHI
|
/* We only need to recurse if the reaching definition comes from a PHI
|
node. */
|
node. */
|
if (gimple_code (def_stmt) != GIMPLE_PHI)
|
if (gimple_code (def_stmt) != GIMPLE_PHI)
|
(*fn) (var, def_stmt, data);
|
(*fn) (var, def_stmt, data);
|
else
|
else
|
{
|
{
|
struct pointer_set_t *visited = pointer_set_create ();
|
struct pointer_set_t *visited = pointer_set_create ();
|
walk_use_def_chains_1 (var, fn, data, visited, is_dfs);
|
walk_use_def_chains_1 (var, fn, data, visited, is_dfs);
|
pointer_set_destroy (visited);
|
pointer_set_destroy (visited);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Return true if T, an SSA_NAME, has an undefined value. */
|
/* Return true if T, an SSA_NAME, has an undefined value. */
|
|
|
bool
|
bool
|
ssa_undefined_value_p (tree t)
|
ssa_undefined_value_p (tree t)
|
{
|
{
|
tree var = SSA_NAME_VAR (t);
|
tree var = SSA_NAME_VAR (t);
|
|
|
/* Parameters get their initial value from the function entry. */
|
/* Parameters get their initial value from the function entry. */
|
if (TREE_CODE (var) == PARM_DECL)
|
if (TREE_CODE (var) == PARM_DECL)
|
return false;
|
return false;
|
|
|
/* Hard register variables get their initial value from the ether. */
|
/* Hard register variables get their initial value from the ether. */
|
if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
|
if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
|
return false;
|
return false;
|
|
|
/* The value is undefined iff its definition statement is empty. */
|
/* The value is undefined iff its definition statement is empty. */
|
return gimple_nop_p (SSA_NAME_DEF_STMT (t));
|
return gimple_nop_p (SSA_NAME_DEF_STMT (t));
|
}
|
}
|
|
|
/* Emit warnings for uninitialized variables. This is done in two passes.
|
/* Emit warnings for uninitialized variables. This is done in two passes.
|
|
|
The first pass notices real uses of SSA names with undefined values.
|
The first pass notices real uses of SSA names with undefined values.
|
Such uses are unconditionally uninitialized, and we can be certain that
|
Such uses are unconditionally uninitialized, and we can be certain that
|
such a use is a mistake. This pass is run before most optimizations,
|
such a use is a mistake. This pass is run before most optimizations,
|
so that we catch as many as we can.
|
so that we catch as many as we can.
|
|
|
The second pass follows PHI nodes to find uses that are potentially
|
The second pass follows PHI nodes to find uses that are potentially
|
uninitialized. In this case we can't necessarily prove that the use
|
uninitialized. In this case we can't necessarily prove that the use
|
is really uninitialized. This pass is run after most optimizations,
|
is really uninitialized. This pass is run after most optimizations,
|
so that we thread as many jumps and possible, and delete as much dead
|
so that we thread as many jumps and possible, and delete as much dead
|
code as possible, in order to reduce false positives. We also look
|
code as possible, in order to reduce false positives. We also look
|
again for plain uninitialized variables, since optimization may have
|
again for plain uninitialized variables, since optimization may have
|
changed conditionally uninitialized to unconditionally uninitialized. */
|
changed conditionally uninitialized to unconditionally uninitialized. */
|
|
|
/* Emit a warning for T, an SSA_NAME, being uninitialized. The exact
|
/* Emit a warning for T, an SSA_NAME, being uninitialized. The exact
|
warning text is in MSGID and LOCUS may contain a location or be null. */
|
warning text is in MSGID and LOCUS may contain a location or be null. */
|
|
|
static void
|
static void
|
warn_uninit (tree t, const char *gmsgid, void *data)
|
warn_uninit (tree t, const char *gmsgid, void *data)
|
{
|
{
|
tree var = SSA_NAME_VAR (t);
|
tree var = SSA_NAME_VAR (t);
|
gimple context = (gimple) data;
|
gimple context = (gimple) data;
|
location_t location;
|
location_t location;
|
expanded_location xloc, floc;
|
expanded_location xloc, floc;
|
|
|
if (!ssa_undefined_value_p (t))
|
if (!ssa_undefined_value_p (t))
|
return;
|
return;
|
|
|
/* TREE_NO_WARNING either means we already warned, or the front end
|
/* TREE_NO_WARNING either means we already warned, or the front end
|
wishes to suppress the warning. */
|
wishes to suppress the warning. */
|
if (TREE_NO_WARNING (var))
|
if (TREE_NO_WARNING (var))
|
return;
|
return;
|
|
|
/* Do not warn if it can be initialized outside this module. */
|
/* Do not warn if it can be initialized outside this module. */
|
if (is_global_var (var))
|
if (is_global_var (var))
|
return;
|
return;
|
|
|
location = (context != NULL && gimple_has_location (context))
|
location = (context != NULL && gimple_has_location (context))
|
? gimple_location (context)
|
? gimple_location (context)
|
: DECL_SOURCE_LOCATION (var);
|
: DECL_SOURCE_LOCATION (var);
|
xloc = expand_location (location);
|
xloc = expand_location (location);
|
floc = expand_location (DECL_SOURCE_LOCATION (cfun->decl));
|
floc = expand_location (DECL_SOURCE_LOCATION (cfun->decl));
|
if (warning_at (location, OPT_Wuninitialized, gmsgid, var))
|
if (warning_at (location, OPT_Wuninitialized, gmsgid, var))
|
{
|
{
|
TREE_NO_WARNING (var) = 1;
|
TREE_NO_WARNING (var) = 1;
|
|
|
if (xloc.file != floc.file
|
if (xloc.file != floc.file
|
|| xloc.line < floc.line
|
|| xloc.line < floc.line
|
|| xloc.line > LOCATION_LINE (cfun->function_end_locus))
|
|| xloc.line > LOCATION_LINE (cfun->function_end_locus))
|
inform (DECL_SOURCE_LOCATION (var), "%qD was declared here", var);
|
inform (DECL_SOURCE_LOCATION (var), "%qD was declared here", var);
|
}
|
}
|
}
|
}
|
|
|
struct walk_data {
|
struct walk_data {
|
gimple stmt;
|
gimple stmt;
|
bool always_executed;
|
bool always_executed;
|
bool warn_possibly_uninitialized;
|
bool warn_possibly_uninitialized;
|
};
|
};
|
|
|
/* Called via walk_tree, look for SSA_NAMEs that have empty definitions
|
/* Called via walk_tree, look for SSA_NAMEs that have empty definitions
|
and warn about them. */
|
and warn about them. */
|
|
|
static tree
|
static tree
|
warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data_)
|
warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data_)
|
{
|
{
|
struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
|
struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
|
struct walk_data *data = (struct walk_data *) wi->info;
|
struct walk_data *data = (struct walk_data *) wi->info;
|
tree t = *tp;
|
tree t = *tp;
|
|
|
/* We do not care about LHS. */
|
/* We do not care about LHS. */
|
if (wi->is_lhs)
|
if (wi->is_lhs)
|
{
|
{
|
/* Except for operands of INDIRECT_REF. */
|
/* Except for operands of INDIRECT_REF. */
|
if (!INDIRECT_REF_P (t))
|
if (!INDIRECT_REF_P (t))
|
return NULL_TREE;
|
return NULL_TREE;
|
t = TREE_OPERAND (t, 0);
|
t = TREE_OPERAND (t, 0);
|
}
|
}
|
|
|
switch (TREE_CODE (t))
|
switch (TREE_CODE (t))
|
{
|
{
|
case ADDR_EXPR:
|
case ADDR_EXPR:
|
/* Taking the address of an uninitialized variable does not
|
/* Taking the address of an uninitialized variable does not
|
count as using it. */
|
count as using it. */
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
break;
|
break;
|
|
|
case VAR_DECL:
|
case VAR_DECL:
|
{
|
{
|
/* A VAR_DECL in the RHS of a gimple statement may mean that
|
/* A VAR_DECL in the RHS of a gimple statement may mean that
|
this variable is loaded from memory. */
|
this variable is loaded from memory. */
|
use_operand_p vuse;
|
use_operand_p vuse;
|
tree op;
|
tree op;
|
|
|
/* If there is not gimple stmt,
|
/* If there is not gimple stmt,
|
or alias information has not been computed,
|
or alias information has not been computed,
|
then we cannot check VUSE ops. */
|
then we cannot check VUSE ops. */
|
if (data->stmt == NULL)
|
if (data->stmt == NULL)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* If the load happens as part of a call do not warn about it. */
|
/* If the load happens as part of a call do not warn about it. */
|
if (is_gimple_call (data->stmt))
|
if (is_gimple_call (data->stmt))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
vuse = gimple_vuse_op (data->stmt);
|
vuse = gimple_vuse_op (data->stmt);
|
if (vuse == NULL_USE_OPERAND_P)
|
if (vuse == NULL_USE_OPERAND_P)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
op = USE_FROM_PTR (vuse);
|
op = USE_FROM_PTR (vuse);
|
if (t != SSA_NAME_VAR (op)
|
if (t != SSA_NAME_VAR (op)
|
|| !SSA_NAME_IS_DEFAULT_DEF (op))
|
|| !SSA_NAME_IS_DEFAULT_DEF (op))
|
return NULL_TREE;
|
return NULL_TREE;
|
/* If this is a VUSE of t and it is the default definition,
|
/* If this is a VUSE of t and it is the default definition,
|
then warn about op. */
|
then warn about op. */
|
t = op;
|
t = op;
|
/* Fall through into SSA_NAME. */
|
/* Fall through into SSA_NAME. */
|
}
|
}
|
|
|
case SSA_NAME:
|
case SSA_NAME:
|
/* We only do data flow with SSA_NAMEs, so that's all we
|
/* We only do data flow with SSA_NAMEs, so that's all we
|
can warn about. */
|
can warn about. */
|
if (data->always_executed)
|
if (data->always_executed)
|
warn_uninit (t, "%qD is used uninitialized in this function",
|
warn_uninit (t, "%qD is used uninitialized in this function",
|
data->stmt);
|
data->stmt);
|
else if (data->warn_possibly_uninitialized)
|
else if (data->warn_possibly_uninitialized)
|
warn_uninit (t, "%qD may be used uninitialized in this function",
|
warn_uninit (t, "%qD may be used uninitialized in this function",
|
data->stmt);
|
data->stmt);
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
break;
|
break;
|
|
|
case REALPART_EXPR:
|
case REALPART_EXPR:
|
case IMAGPART_EXPR:
|
case IMAGPART_EXPR:
|
/* The total store transformation performed during gimplification
|
/* The total store transformation performed during gimplification
|
creates uninitialized variable uses. If all is well, these will
|
creates uninitialized variable uses. If all is well, these will
|
be optimized away, so don't warn now. */
|
be optimized away, so don't warn now. */
|
if (TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME)
|
if (TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME)
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
break;
|
break;
|
|
|
default:
|
default:
|
if (IS_TYPE_OR_DECL_P (t))
|
if (IS_TYPE_OR_DECL_P (t))
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
break;
|
break;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Look for inputs to PHI that are SSA_NAMEs that have empty definitions
|
/* Look for inputs to PHI that are SSA_NAMEs that have empty definitions
|
and warn about them. */
|
and warn about them. */
|
|
|
static void
|
static void
|
warn_uninitialized_phi (gimple phi)
|
warn_uninitialized_phi (gimple phi)
|
{
|
{
|
size_t i, n = gimple_phi_num_args (phi);
|
size_t i, n = gimple_phi_num_args (phi);
|
|
|
/* Don't look at memory tags. */
|
/* Don't look at memory tags. */
|
if (!is_gimple_reg (gimple_phi_result (phi)))
|
if (!is_gimple_reg (gimple_phi_result (phi)))
|
return;
|
return;
|
|
|
for (i = 0; i < n; ++i)
|
for (i = 0; i < n; ++i)
|
{
|
{
|
tree op = gimple_phi_arg_def (phi, i);
|
tree op = gimple_phi_arg_def (phi, i);
|
if (TREE_CODE (op) == SSA_NAME)
|
if (TREE_CODE (op) == SSA_NAME)
|
warn_uninit (op, "%qD may be used uninitialized in this function",
|
warn_uninit (op, "%qD may be used uninitialized in this function",
|
NULL);
|
NULL);
|
}
|
}
|
}
|
}
|
|
|
static unsigned int
|
static unsigned int
|
warn_uninitialized_vars (bool warn_possibly_uninitialized)
|
warn_uninitialized_vars (bool warn_possibly_uninitialized)
|
{
|
{
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
basic_block bb;
|
basic_block bb;
|
struct walk_data data;
|
struct walk_data data;
|
|
|
data.warn_possibly_uninitialized = warn_possibly_uninitialized;
|
data.warn_possibly_uninitialized = warn_possibly_uninitialized;
|
|
|
calculate_dominance_info (CDI_POST_DOMINATORS);
|
calculate_dominance_info (CDI_POST_DOMINATORS);
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
data.always_executed = dominated_by_p (CDI_POST_DOMINATORS,
|
data.always_executed = dominated_by_p (CDI_POST_DOMINATORS,
|
single_succ (ENTRY_BLOCK_PTR), bb);
|
single_succ (ENTRY_BLOCK_PTR), bb);
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
struct walk_stmt_info wi;
|
struct walk_stmt_info wi;
|
data.stmt = gsi_stmt (gsi);
|
data.stmt = gsi_stmt (gsi);
|
if (is_gimple_debug (data.stmt))
|
if (is_gimple_debug (data.stmt))
|
continue;
|
continue;
|
memset (&wi, 0, sizeof (wi));
|
memset (&wi, 0, sizeof (wi));
|
wi.info = &data;
|
wi.info = &data;
|
walk_gimple_op (gsi_stmt (gsi), warn_uninitialized_var, &wi);
|
walk_gimple_op (gsi_stmt (gsi), warn_uninitialized_var, &wi);
|
}
|
}
|
}
|
}
|
|
|
/* Post-dominator information can not be reliably updated. Free it
|
/* Post-dominator information can not be reliably updated. Free it
|
after the use. */
|
after the use. */
|
|
|
free_dominance_info (CDI_POST_DOMINATORS);
|
free_dominance_info (CDI_POST_DOMINATORS);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static unsigned int
|
static unsigned int
|
execute_early_warn_uninitialized (void)
|
execute_early_warn_uninitialized (void)
|
{
|
{
|
/* Currently, this pass runs always but
|
/* Currently, this pass runs always but
|
execute_late_warn_uninitialized only runs with optimization. With
|
execute_late_warn_uninitialized only runs with optimization. With
|
optimization we want to warn about possible uninitialized as late
|
optimization we want to warn about possible uninitialized as late
|
as possible, thus don't do it here. However, without
|
as possible, thus don't do it here. However, without
|
optimization we need to warn here about "may be uninitialized".
|
optimization we need to warn here about "may be uninitialized".
|
*/
|
*/
|
warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize);
|
warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static unsigned int
|
static unsigned int
|
execute_late_warn_uninitialized (void)
|
execute_late_warn_uninitialized (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
|
|
/* Re-do the plain uninitialized variable check, as optimization may have
|
/* Re-do the plain uninitialized variable check, as optimization may have
|
straightened control flow. Do this first so that we don't accidentally
|
straightened control flow. Do this first so that we don't accidentally
|
get a "may be" warning when we'd have seen an "is" warning later. */
|
get a "may be" warning when we'd have seen an "is" warning later. */
|
warn_uninitialized_vars (/*warn_possibly_uninitialized=*/1);
|
warn_uninitialized_vars (/*warn_possibly_uninitialized=*/1);
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
warn_uninitialized_phi (gsi_stmt (gsi));
|
warn_uninitialized_phi (gsi_stmt (gsi));
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static bool
|
static bool
|
gate_warn_uninitialized (void)
|
gate_warn_uninitialized (void)
|
{
|
{
|
return warn_uninitialized != 0;
|
return warn_uninitialized != 0;
|
}
|
}
|
|
|
struct gimple_opt_pass pass_early_warn_uninitialized =
|
struct gimple_opt_pass pass_early_warn_uninitialized =
|
{
|
{
|
{
|
{
|
GIMPLE_PASS,
|
GIMPLE_PASS,
|
"*early_warn_uninitialized", /* name */
|
"*early_warn_uninitialized", /* name */
|
gate_warn_uninitialized, /* gate */
|
gate_warn_uninitialized, /* gate */
|
execute_early_warn_uninitialized, /* execute */
|
execute_early_warn_uninitialized, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_NONE, /* tv_id */
|
TV_NONE, /* tv_id */
|
PROP_ssa, /* properties_required */
|
PROP_ssa, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
0 /* todo_flags_finish */
|
0 /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
struct gimple_opt_pass pass_late_warn_uninitialized =
|
struct gimple_opt_pass pass_late_warn_uninitialized =
|
{
|
{
|
{
|
{
|
GIMPLE_PASS,
|
GIMPLE_PASS,
|
"*late_warn_uninitialized", /* name */
|
"*late_warn_uninitialized", /* name */
|
gate_warn_uninitialized, /* gate */
|
gate_warn_uninitialized, /* gate */
|
execute_late_warn_uninitialized, /* execute */
|
execute_late_warn_uninitialized, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_NONE, /* tv_id */
|
TV_NONE, /* tv_id */
|
PROP_ssa, /* properties_required */
|
PROP_ssa, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
0 /* todo_flags_finish */
|
0 /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
/* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
|
/* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
|
|
|
void
|
void
|
execute_update_addresses_taken (bool do_optimize)
|
execute_update_addresses_taken (bool do_optimize)
|
{
|
{
|
tree var;
|
tree var;
|
referenced_var_iterator rvi;
|
referenced_var_iterator rvi;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
basic_block bb;
|
basic_block bb;
|
bitmap addresses_taken = BITMAP_ALLOC (NULL);
|
bitmap addresses_taken = BITMAP_ALLOC (NULL);
|
bitmap not_reg_needs = BITMAP_ALLOC (NULL);
|
bitmap not_reg_needs = BITMAP_ALLOC (NULL);
|
bool update_vops = false;
|
bool update_vops = false;
|
|
|
/* Collect into ADDRESSES_TAKEN all variables whose address is taken within
|
/* Collect into ADDRESSES_TAKEN all variables whose address is taken within
|
the function body. */
|
the function body. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
gimple stmt = gsi_stmt (gsi);
|
gimple stmt = gsi_stmt (gsi);
|
enum gimple_code code = gimple_code (stmt);
|
enum gimple_code code = gimple_code (stmt);
|
|
|
/* Note all addresses taken by the stmt. */
|
/* Note all addresses taken by the stmt. */
|
gimple_ior_addresses_taken (addresses_taken, stmt);
|
gimple_ior_addresses_taken (addresses_taken, stmt);
|
|
|
/* If we have a call or an assignment, see if the lhs contains
|
/* If we have a call or an assignment, see if the lhs contains
|
a local decl that requires not to be a gimple register. */
|
a local decl that requires not to be a gimple register. */
|
if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
|
if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
|
{
|
{
|
tree lhs = gimple_get_lhs (stmt);
|
tree lhs = gimple_get_lhs (stmt);
|
|
|
/* We may not rewrite TMR_SYMBOL to SSA. */
|
/* We may not rewrite TMR_SYMBOL to SSA. */
|
if (lhs && TREE_CODE (lhs) == TARGET_MEM_REF
|
if (lhs && TREE_CODE (lhs) == TARGET_MEM_REF
|
&& TMR_SYMBOL (lhs))
|
&& TMR_SYMBOL (lhs))
|
bitmap_set_bit (not_reg_needs, DECL_UID (TMR_SYMBOL (lhs)));
|
bitmap_set_bit (not_reg_needs, DECL_UID (TMR_SYMBOL (lhs)));
|
|
|
/* A plain decl does not need it set. */
|
/* A plain decl does not need it set. */
|
else if (lhs && handled_component_p (lhs))
|
else if (lhs && handled_component_p (lhs))
|
{
|
{
|
var = get_base_address (lhs);
|
var = get_base_address (lhs);
|
if (DECL_P (var))
|
if (DECL_P (var))
|
bitmap_set_bit (not_reg_needs, DECL_UID (var));
|
bitmap_set_bit (not_reg_needs, DECL_UID (var));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
size_t i;
|
size_t i;
|
gimple phi = gsi_stmt (gsi);
|
gimple phi = gsi_stmt (gsi);
|
|
|
for (i = 0; i < gimple_phi_num_args (phi); i++)
|
for (i = 0; i < gimple_phi_num_args (phi); i++)
|
{
|
{
|
tree op = PHI_ARG_DEF (phi, i), var;
|
tree op = PHI_ARG_DEF (phi, i), var;
|
if (TREE_CODE (op) == ADDR_EXPR
|
if (TREE_CODE (op) == ADDR_EXPR
|
&& (var = get_base_address (TREE_OPERAND (op, 0))) != NULL
|
&& (var = get_base_address (TREE_OPERAND (op, 0))) != NULL
|
&& DECL_P (var))
|
&& DECL_P (var))
|
bitmap_set_bit (addresses_taken, DECL_UID (var));
|
bitmap_set_bit (addresses_taken, DECL_UID (var));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* When possible, clear ADDRESSABLE bit or set the REGISTER bit
|
/* When possible, clear ADDRESSABLE bit or set the REGISTER bit
|
and mark variable for conversion into SSA. */
|
and mark variable for conversion into SSA. */
|
if (optimize && do_optimize)
|
if (optimize && do_optimize)
|
FOR_EACH_REFERENCED_VAR (var, rvi)
|
FOR_EACH_REFERENCED_VAR (var, rvi)
|
{
|
{
|
/* Global Variables, result decls cannot be changed. */
|
/* Global Variables, result decls cannot be changed. */
|
if (is_global_var (var)
|
if (is_global_var (var)
|
|| TREE_CODE (var) == RESULT_DECL
|
|| TREE_CODE (var) == RESULT_DECL
|
|| bitmap_bit_p (addresses_taken, DECL_UID (var)))
|
|| bitmap_bit_p (addresses_taken, DECL_UID (var)))
|
continue;
|
continue;
|
|
|
if (TREE_ADDRESSABLE (var)
|
if (TREE_ADDRESSABLE (var)
|
/* Do not change TREE_ADDRESSABLE if we need to preserve var as
|
/* Do not change TREE_ADDRESSABLE if we need to preserve var as
|
a non-register. Otherwise we are confused and forget to
|
a non-register. Otherwise we are confused and forget to
|
add virtual operands for it. */
|
add virtual operands for it. */
|
&& (!is_gimple_reg_type (TREE_TYPE (var))
|
&& (!is_gimple_reg_type (TREE_TYPE (var))
|
|| !bitmap_bit_p (not_reg_needs, DECL_UID (var))))
|
|| !bitmap_bit_p (not_reg_needs, DECL_UID (var))))
|
{
|
{
|
TREE_ADDRESSABLE (var) = 0;
|
TREE_ADDRESSABLE (var) = 0;
|
if (is_gimple_reg (var))
|
if (is_gimple_reg (var))
|
mark_sym_for_renaming (var);
|
mark_sym_for_renaming (var);
|
update_vops = true;
|
update_vops = true;
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "No longer having address taken ");
|
fprintf (dump_file, "No longer having address taken ");
|
print_generic_expr (dump_file, var, 0);
|
print_generic_expr (dump_file, var, 0);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
}
|
}
|
if (!DECL_GIMPLE_REG_P (var)
|
if (!DECL_GIMPLE_REG_P (var)
|
&& !bitmap_bit_p (not_reg_needs, DECL_UID (var))
|
&& !bitmap_bit_p (not_reg_needs, DECL_UID (var))
|
&& (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
|
&& (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
|
|| TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
|
|| TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
|
&& !TREE_THIS_VOLATILE (var)
|
&& !TREE_THIS_VOLATILE (var)
|
&& (TREE_CODE (var) != VAR_DECL || !DECL_HARD_REGISTER (var)))
|
&& (TREE_CODE (var) != VAR_DECL || !DECL_HARD_REGISTER (var)))
|
{
|
{
|
DECL_GIMPLE_REG_P (var) = 1;
|
DECL_GIMPLE_REG_P (var) = 1;
|
mark_sym_for_renaming (var);
|
mark_sym_for_renaming (var);
|
update_vops = true;
|
update_vops = true;
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Decl is now a gimple register ");
|
fprintf (dump_file, "Decl is now a gimple register ");
|
print_generic_expr (dump_file, var, 0);
|
print_generic_expr (dump_file, var, 0);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Operand caches needs to be recomputed for operands referencing the updated
|
/* Operand caches needs to be recomputed for operands referencing the updated
|
variables. */
|
variables. */
|
if (update_vops)
|
if (update_vops)
|
{
|
{
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
gimple stmt = gsi_stmt (gsi);
|
gimple stmt = gsi_stmt (gsi);
|
|
|
if (gimple_references_memory_p (stmt)
|
if (gimple_references_memory_p (stmt)
|
|| is_gimple_debug (stmt))
|
|| is_gimple_debug (stmt))
|
update_stmt (stmt);
|
update_stmt (stmt);
|
}
|
}
|
|
|
/* Update SSA form here, we are called as non-pass as well. */
|
/* Update SSA form here, we are called as non-pass as well. */
|
update_ssa (TODO_update_ssa);
|
update_ssa (TODO_update_ssa);
|
}
|
}
|
|
|
BITMAP_FREE (not_reg_needs);
|
BITMAP_FREE (not_reg_needs);
|
BITMAP_FREE (addresses_taken);
|
BITMAP_FREE (addresses_taken);
|
}
|
}
|
|
|
struct gimple_opt_pass pass_update_address_taken =
|
struct gimple_opt_pass pass_update_address_taken =
|
{
|
{
|
{
|
{
|
GIMPLE_PASS,
|
GIMPLE_PASS,
|
"addressables", /* name */
|
"addressables", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
NULL, /* execute */
|
NULL, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_NONE, /* tv_id */
|
TV_NONE, /* tv_id */
|
PROP_ssa, /* properties_required */
|
PROP_ssa, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_update_address_taken
|
TODO_update_address_taken
|
| TODO_dump_func /* todo_flags_finish */
|
| TODO_dump_func /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
