/* Miscellaneous SSA utility functions.
- Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "output.h"
-#include "errors.h"
#include "expr.h"
#include "function.h"
#include "diagnostic.h"
#include "bitmap.h"
+#include "pointer-set.h"
#include "tree-flow.h"
#include "tree-gimple.h"
#include "tree-inline.h"
#include "hashtab.h"
#include "tree-dump.h"
#include "tree-pass.h"
-
-
-/* Remove edge E and remove the corresponding arguments from the PHI nodes
- in E's destination block. */
-
-void
-ssa_remove_edge (edge e)
-{
- tree phi, next;
-
- /* Remove the appropriate PHI arguments in E's destination block. */
- for (phi = phi_nodes (e->dest); phi; phi = next)
- {
- next = PHI_CHAIN (phi);
- remove_phi_arg (phi, e->src);
- }
-
- remove_edge (e);
-}
+#include "toplev.h"
/* Remove the corresponding arguments from the PHI nodes in E's
destination block and redirect it to DEST. Return redirected edge.
edge
ssa_redirect_edge (edge e, basic_block dest)
{
- tree phi, next;
+ tree phi;
tree list = NULL, *last = &list;
tree src, dst, node;
- int i;
/* Remove the appropriate PHI arguments in E's destination block. */
- for (phi = phi_nodes (e->dest); phi; phi = next)
+ for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi))
{
- next = PHI_CHAIN (phi);
-
- i = phi_arg_from_edge (phi, e);
- if (i < 0)
+ if (PHI_ARG_DEF (phi, e->dest_idx) == NULL_TREE)
continue;
- src = PHI_ARG_DEF (phi, i);
+ src = PHI_ARG_DEF (phi, e->dest_idx);
dst = PHI_RESULT (phi);
node = build_tree_list (dst, src);
*last = node;
last = &TREE_CHAIN (node);
-
- remove_phi_arg_num (phi, i);
}
e = redirect_edge_succ_nodup (e, dest);
phi = PHI_CHAIN (phi), arg = TREE_CHAIN (arg))
{
tree def = TREE_VALUE (arg);
- add_phi_arg (&phi, def, e);
+ add_phi_arg (phi, def, e);
}
PENDING_STMT (e) = NULL;
static bool
verify_ssa_name (tree ssa_name, bool is_virtual)
{
- TREE_VISITED (ssa_name) = 1;
-
if (TREE_CODE (ssa_name) != SSA_NAME)
{
- error ("Expected an SSA_NAME object");
+ error ("expected an SSA_NAME object");
return true;
}
if (TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
{
- error ("Type mismatch between an SSA_NAME and its symbol.");
+ error ("type mismatch between an SSA_NAME and its symbol");
return true;
}
if (SSA_NAME_IN_FREE_LIST (ssa_name))
{
- error ("Found an SSA_NAME that had been released into the free pool");
+ error ("found an SSA_NAME that had been released into the free pool");
return true;
}
if (is_virtual && is_gimple_reg (ssa_name))
{
- error ("Found a virtual definition for a GIMPLE register");
+ error ("found a virtual definition for a GIMPLE register");
return true;
}
if (!is_virtual && !is_gimple_reg (ssa_name))
{
- error ("Found a real definition for a non-register");
+ error ("found a real definition for a non-register");
+ return true;
+ }
+
+ if (is_virtual && var_ann (SSA_NAME_VAR (ssa_name))
+ && get_subvars_for_var (SSA_NAME_VAR (ssa_name)) != NULL)
+ {
+ error ("found real variable when subvariables should have appeared");
return true;
}
that are defined before STMT in basic block BB. */
static bool
-verify_use (basic_block bb, basic_block def_bb, tree ssa_name,
+verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
tree stmt, bool check_abnormal, bool is_virtual,
bitmap names_defined_in_bb)
{
bool err = false;
+ tree ssa_name = USE_FROM_PTR (use_p);
err = verify_ssa_name (ssa_name, is_virtual);
+ if (!TREE_VISITED (ssa_name))
+ if (verify_imm_links (stderr, ssa_name))
+ err = true;
+
+ TREE_VISITED (ssa_name) = 1;
+
if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name))
- && var_ann (SSA_NAME_VAR (ssa_name))->default_def == ssa_name)
+ && default_def (SSA_NAME_VAR (ssa_name)) == ssa_name)
; /* Default definitions have empty statements. Nothing to do. */
else if (!def_bb)
{
- error ("Missing definition");
+ error ("missing definition");
err = true;
}
else if (bb != def_bb
&& !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
{
- error ("Definition in block %i does not dominate use in block %i",
+ error ("definition in block %i does not dominate use in block %i",
def_bb->index, bb->index);
err = true;
}
&& names_defined_in_bb != NULL
&& !bitmap_bit_p (names_defined_in_bb, SSA_NAME_VERSION (ssa_name)))
{
- error ("Definition in block %i follows the use", def_bb->index);
+ error ("definition in block %i follows the use", def_bb->index);
err = true;
}
err = true;
}
+ /* Make sure the use is in an appropriate list by checking the previous
+ element to make sure it's the same. */
+ if (use_p->prev == NULL)
+ {
+ error ("no immediate_use list");
+ err = true;
+ }
+ else
+ {
+ tree listvar ;
+ if (use_p->prev->use == NULL)
+ listvar = use_p->prev->stmt;
+ else
+ listvar = USE_FROM_PTR (use_p->prev);
+ if (listvar != ssa_name)
+ {
+ error ("wrong immediate use list");
+ err = true;
+ }
+ }
+
if (err)
{
fprintf (stderr, "for SSA_NAME: ");
print_generic_expr (stderr, ssa_name, TDF_VOPS);
- fprintf (stderr, "in statement:\n");
+ fprintf (stderr, " in statement:\n");
print_generic_stmt (stderr, stmt, TDF_VOPS);
}
/* Return true if any of the arguments for PHI node PHI at block BB is
malformed.
- IDOM contains immediate dominator information for the flowgraph.
-
DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME version
numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set, it means that the
block in that array slot contains the definition of SSA_NAME. */
{
edge e;
bool err = false;
- int i, phi_num_args = PHI_NUM_ARGS (phi);
- edge_iterator ei;
+ unsigned i, phi_num_args = PHI_NUM_ARGS (phi);
- /* Mark all the incoming edges. */
- FOR_EACH_EDGE (e, ei, bb->preds)
- e->aux = (void *) 1;
+ if (EDGE_COUNT (bb->preds) != phi_num_args)
+ {
+ error ("incoming edge count does not match number of PHI arguments");
+ err = true;
+ goto error;
+ }
for (i = 0; i < phi_num_args; i++)
{
- tree op = PHI_ARG_DEF (phi, i);
+ use_operand_p op_p = PHI_ARG_DEF_PTR (phi, i);
+ tree op = USE_FROM_PTR (op_p);
- e = PHI_ARG_EDGE (phi, i);
- if (TREE_CODE (op) == SSA_NAME)
- err = verify_use (e->src, definition_block[SSA_NAME_VERSION (op)], op,
- phi, e->flags & EDGE_ABNORMAL,
- !is_gimple_reg (PHI_RESULT (phi)),
- NULL);
+ e = EDGE_PRED (bb, i);
- if (e->dest != bb)
+ if (op == NULL_TREE)
{
- error ("Wrong edge %d->%d for PHI argument\n",
- e->src->index, e->dest->index, bb->index);
+ error ("PHI argument is missing for edge %d->%d",
+ e->src->index,
+ e->dest->index);
err = true;
+ goto error;
}
- if (e->aux == (void *) 0)
+ if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op))
{
- error ("PHI argument flowing through dead edge %d->%d\n",
- e->src->index, e->dest->index);
+ error ("PHI argument is not SSA_NAME, or invariant");
err = true;
}
- if (e->aux == (void *) 2)
+ if (TREE_CODE (op) == SSA_NAME)
+ err = verify_use (e->src, definition_block[SSA_NAME_VERSION (op)], op_p,
+ phi, e->flags & EDGE_ABNORMAL,
+ !is_gimple_reg (PHI_RESULT (phi)),
+ NULL);
+
+ if (e->dest != bb)
{
- error ("PHI argument duplicated for edge %d->%d\n", e->src->index,
- e->dest->index);
+ error ("wrong edge %d->%d for PHI argument",
+ e->src->index, e->dest->index);
err = true;
}
print_generic_stmt (stderr, op, TDF_VOPS);
goto error;
}
-
- e->aux = (void *) 2;
- }
-
- FOR_EACH_EDGE (e, ei, bb->preds)
- {
- if (e->aux != (void *) 2)
- {
- error ("No argument flowing through edge %d->%d\n", e->src->index,
- e->dest->index);
- err = true;
- goto error;
- }
- e->aux = (void *) 0;
}
error:
static void
verify_flow_insensitive_alias_info (void)
{
- size_t i;
tree var;
- bitmap visited = BITMAP_XMALLOC ();
+ bitmap visited = BITMAP_ALLOC (NULL);
+ referenced_var_iterator rvi;
- for (i = 0; i < num_referenced_vars; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
size_t j;
var_ann_t ann;
varray_type may_aliases;
- var = referenced_var (i);
ann = var_ann (var);
may_aliases = ann->may_aliases;
{
tree alias = VARRAY_TREE (may_aliases, j);
- bitmap_set_bit (visited, var_ann (alias)->uid);
+ bitmap_set_bit (visited, DECL_UID (alias));
if (!may_be_aliased (alias))
{
- error ("Non-addressable variable inside an alias set.");
+ error ("non-addressable variable inside an alias set");
debug_variable (alias);
goto err;
}
}
}
- for (i = 0; i < num_referenced_vars; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
var_ann_t ann;
-
- var = referenced_var (i);
ann = var_ann (var);
- if (ann->mem_tag_kind == NOT_A_TAG
+ if (!MTAG_P (var)
&& ann->is_alias_tag
- && !bitmap_bit_p (visited, ann->uid))
+ && !bitmap_bit_p (visited, DECL_UID (var)))
{
- error ("Addressable variable that is an alias tag but is not in any alias set.");
+ error ("addressable variable that is an alias tag but is not in any alias set");
goto err;
}
}
- BITMAP_XFREE (visited);
+ BITMAP_FREE (visited);
return;
err:
debug_variable (var);
- internal_error ("verify_flow_insensitive_alias_info failed.");
+ internal_error ("verify_flow_insensitive_alias_info failed");
}
for (i = 1; i < num_ssa_names; i++)
{
+ tree var;
var_ann_t ann;
struct ptr_info_def *pi;
+
ptr = ssa_name (i);
if (!ptr)
continue;
- ann = var_ann (SSA_NAME_VAR (ptr));
- pi = SSA_NAME_PTR_INFO (ptr);
/* We only care for pointers that are actually referenced in the
program. */
- if (!TREE_VISITED (ptr) || !POINTER_TYPE_P (TREE_TYPE (ptr)))
+ if (!POINTER_TYPE_P (TREE_TYPE (ptr)) || !TREE_VISITED (ptr))
continue;
/* RESULT_DECL is special. If it's a GIMPLE register, then it
is only written-to only once in the return statement.
Otherwise, aggregate RESULT_DECLs may be written-to more than
once in virtual operands. */
- if (TREE_CODE (SSA_NAME_VAR (ptr)) == RESULT_DECL
+ var = SSA_NAME_VAR (ptr);
+ if (TREE_CODE (var) == RESULT_DECL
&& is_gimple_reg (ptr))
continue;
+ pi = SSA_NAME_PTR_INFO (ptr);
if (pi == NULL)
continue;
+ ann = var_ann (var);
if (pi->is_dereferenced && !pi->name_mem_tag && !ann->type_mem_tag)
{
- error ("Dereferenced pointers should have a name or a type tag");
+ error ("dereferenced pointers should have a name or a type tag");
goto err;
}
if (pi->name_mem_tag
- && !pi->pt_malloc
&& (pi->pt_vars == NULL || bitmap_empty_p (pi->pt_vars)))
{
- error ("Pointers with a memory tag, should have points-to sets or point to malloc");
+ error ("pointers with a memory tag, should have points-to sets");
goto err;
}
&& pi->name_mem_tag
&& !is_call_clobbered (pi->name_mem_tag))
{
- error ("Pointer escapes but its name tag is not call-clobbered.");
+ error ("pointer escapes but its name tag is not call-clobbered");
goto err;
}
}
err:
debug_variable (ptr);
- internal_error ("verify_flow_sensitive_alias_info failed.");
+ internal_error ("verify_flow_sensitive_alias_info failed");
}
-DEF_VEC_MALLOC_P (bitmap);
+DEF_VEC_P (bitmap);
+DEF_VEC_ALLOC_P (bitmap,heap);
/* Verify that all name tags have different points to sets.
This algorithm takes advantage of the fact that every variable with the
same name tag must have the same points-to set.
So we check a single variable for each name tag, and verify that its
points-to set is different from every other points-to set for other name
- tags. */
+ tags.
+
+ Additionally, given a pointer P_i with name tag NMT and type tag
+ TMT, this function verified the alias set of TMT is a superset of
+ the alias set of NMT. */
static void
verify_name_tags (void)
size_t i;
size_t j;
bitmap first, second;
- VEC (tree) *name_tag_reps = NULL;
- VEC (bitmap) *pt_vars_for_reps = NULL;
+ VEC(tree,heap) *name_tag_reps = NULL;
+ VEC(bitmap,heap) *pt_vars_for_reps = NULL;
+ bitmap type_aliases = BITMAP_ALLOC (NULL);
/* First we compute the name tag representatives and their points-to sets. */
for (i = 0; i < num_ssa_names; i++)
{
- if (ssa_name (i))
+ struct ptr_info_def *pi;
+ tree tmt, ptr = ssa_name (i);
+
+ if (ptr == NULL_TREE)
+ continue;
+
+ pi = SSA_NAME_PTR_INFO (ptr);
+
+ if (!TREE_VISITED (ptr)
+ || !POINTER_TYPE_P (TREE_TYPE (ptr))
+ || !pi
+ || !pi->name_mem_tag
+ || TREE_VISITED (pi->name_mem_tag))
+ continue;
+
+ TREE_VISITED (pi->name_mem_tag) = 1;
+
+ if (pi->pt_vars == NULL)
+ continue;
+
+ VEC_safe_push (tree, heap, name_tag_reps, ptr);
+ VEC_safe_push (bitmap, heap, pt_vars_for_reps, pi->pt_vars);
+
+ /* Verify that alias set of PTR's type tag is a superset of the
+ alias set of PTR's name tag. */
+ tmt = var_ann (SSA_NAME_VAR (ptr))->type_mem_tag;
+ if (tmt)
{
- tree ptr = ssa_name (i);
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr);
- if (!TREE_VISITED (ptr)
- || !POINTER_TYPE_P (TREE_TYPE (ptr))
- || !pi
- || !pi->name_mem_tag
- || TREE_VISITED (pi->name_mem_tag))
+ size_t i;
+ varray_type aliases = var_ann (tmt)->may_aliases;
+ bitmap_clear (type_aliases);
+ for (i = 0; aliases && i < VARRAY_ACTIVE_SIZE (aliases); i++)
+ {
+ tree alias = VARRAY_TREE (aliases, i);
+ bitmap_set_bit (type_aliases, DECL_UID (alias));
+ }
+
+ /* When grouping, we may have added PTR's type tag into the
+ alias set of PTR's name tag. To prevent a false
+ positive, pretend that TMT is in its own alias set. */
+ bitmap_set_bit (type_aliases, DECL_UID (tmt));
+
+ if (bitmap_equal_p (type_aliases, pi->pt_vars))
continue;
- TREE_VISITED (pi->name_mem_tag) = 1;
- if (pi->pt_vars != NULL)
- {
- VEC_safe_push (tree, name_tag_reps, ptr);
- VEC_safe_push (bitmap, pt_vars_for_reps, pi->pt_vars);
+
+ if (!bitmap_intersect_compl_p (type_aliases, pi->pt_vars))
+ {
+ error ("alias set of a pointer's type tag should be a superset of the corresponding name tag");
+ debug_variable (tmt);
+ debug_variable (pi->name_mem_tag);
+ goto err;
}
}
}
{
if (bitmap_equal_p (first, second))
{
- error ("Two different pointers with identical points-to sets but different name tags");
+ error ("two different pointers with identical points-to sets but different name tags");
debug_variable (VEC_index (tree, name_tag_reps, j));
goto err;
}
TREE_VISITED (pi->name_mem_tag) = 0;
}
}
- VEC_free (bitmap, pt_vars_for_reps);
+
+ /* We do not have to free the bitmaps or trees in the vectors, as
+ they are not owned by us. */
+ VEC_free (bitmap, heap, pt_vars_for_reps);
+ VEC_free (tree, heap, name_tag_reps);
+ BITMAP_FREE (type_aliases);
return;
err:
debug_variable (VEC_index (tree, name_tag_reps, i));
internal_error ("verify_name_tags failed");
}
+
+
/* Verify the consistency of aliasing information. */
static void
TODO: verify the variable annotations. */
void
-verify_ssa (void)
+verify_ssa (bool check_modified_stmt)
{
size_t i;
basic_block bb;
- basic_block *definition_block = xcalloc (num_ssa_names, sizeof (basic_block));
+ basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names);
ssa_op_iter iter;
tree op;
enum dom_state orig_dom_state = dom_computed[CDI_DOMINATORS];
- bitmap names_defined_in_bb = BITMAP_XMALLOC ();
+ bitmap names_defined_in_bb = BITMAP_ALLOC (NULL);
+
+ gcc_assert (!need_ssa_update_p ());
+
+ verify_stmts ();
timevar_push (TV_TREE_SSA_VERIFY);
/* Keep track of SSA names present in the IL. */
for (i = 1; i < num_ssa_names; i++)
- if (ssa_name (i))
- TREE_VISITED (ssa_name (i)) = 0;
-
- calculate_dominance_info (CDI_DOMINATORS);
-
- /* Verify and register all the SSA_NAME definitions found in the
- function. */
- FOR_EACH_BB (bb)
{
- tree phi;
- block_stmt_iterator bsi;
-
- for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
- {
- int i;
- if (verify_def (bb, definition_block, PHI_RESULT (phi), phi,
- !is_gimple_reg (PHI_RESULT (phi))))
- goto err;
- for (i = 0; i < PHI_NUM_ARGS (phi); i++)
- {
- tree def = PHI_ARG_DEF (phi, i);
- if (TREE_CODE (def) != SSA_NAME && !is_gimple_min_invariant (def))
- {
- error ("PHI argument is not SSA_NAME, or invariant");
- print_generic_stmt (stderr, phi, TDF_VOPS);
- goto err;
- }
- }
- }
-
- for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+ tree name = ssa_name (i);
+ if (name)
{
tree stmt;
+ TREE_VISITED (name) = 0;
- stmt = bsi_stmt (bsi);
- get_stmt_operands (stmt);
-
- if (stmt_ann (stmt)->makes_aliased_stores
- && NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) == 0)
+ stmt = SSA_NAME_DEF_STMT (name);
+ if (!IS_EMPTY_STMT (stmt))
{
- error ("Statement makes aliased stores, but has no V_MAY_DEFS");
- print_generic_stmt (stderr, stmt, TDF_VOPS);
- goto err;
- }
-
- FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_DEFS)
- {
- if (verify_def (bb, definition_block, op, stmt, true))
- goto err;
- }
-
- FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
- {
- if (verify_def (bb, definition_block, op, stmt, false))
- goto err;
+ basic_block bb = bb_for_stmt (stmt);
+ verify_def (bb, definition_block,
+ name, stmt, !is_gimple_reg (name));
+
}
}
}
+ calculate_dominance_info (CDI_DOMINATORS);
/* Now verify all the uses and make sure they agree with the definitions
found in the previous pass. */
{
if (e->aux)
{
- error ("AUX pointer initialized for edge %d->%d\n", e->src->index,
+ error ("AUX pointer initialized for edge %d->%d", e->src->index,
e->dest->index);
goto err;
}
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
+ use_operand_p use_p;
- FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_KILLS)
+ if (check_modified_stmt && stmt_modified_p (stmt))
{
- if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
- op, stmt, false, true,
- names_defined_in_bb))
- goto err;
+ error ("stmt (%p) marked modified after optimization pass : ",
+ (void *)stmt);
+ print_generic_stmt (stderr, stmt, TDF_VOPS);
+ goto err;
}
- FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
+ if (TREE_CODE (stmt) == MODIFY_EXPR
+ && TREE_CODE (TREE_OPERAND (stmt, 0)) != SSA_NAME)
{
- if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
- op, stmt, false, false,
- names_defined_in_bb))
- goto err;
- }
+ tree lhs, base_address;
- FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
- {
- bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op));
+ lhs = TREE_OPERAND (stmt, 0);
+ base_address = get_base_address (lhs);
+
+ if (base_address
+ && SSA_VAR_P (base_address)
+ && ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF|SSA_OP_VMUSTDEF))
+ {
+ error ("statement makes a memory store, but has no "
+ "V_MAY_DEFS nor V_MUST_DEFS");
+ print_generic_stmt (stderr, stmt, TDF_VOPS);
+ goto err;
+ }
}
- }
- /* Verify the uses in arguments of PHI nodes at the exits from the
- block. */
- FOR_EACH_EDGE (e, ei, bb->succs)
- {
- for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi))
+ FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,
+ SSA_OP_ALL_USES | SSA_OP_ALL_KILLS)
{
- bool virtual = !is_gimple_reg (PHI_RESULT (phi));
- op = PHI_ARG_DEF_FROM_EDGE (phi, e);
- if (TREE_CODE (op) != SSA_NAME)
- continue;
-
+ op = USE_FROM_PTR (use_p);
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
- op, phi, false, virtual,
+ use_p, stmt, false, !is_gimple_reg (op),
names_defined_in_bb))
goto err;
}
+
+ FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
+ bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op));
}
bitmap_clear (names_defined_in_bb);
verify_alias_info ();
free (definition_block);
+
/* Restore the dominance information to its prior known state, so
that we do not perturb the compiler's subsequent behavior. */
if (orig_dom_state == DOM_NONE)
else
dom_computed[CDI_DOMINATORS] = orig_dom_state;
- BITMAP_XFREE (names_defined_in_bb);
+ BITMAP_FREE (names_defined_in_bb);
timevar_pop (TV_TREE_SSA_VERIFY);
return;
err:
- internal_error ("verify_ssa failed.");
+ internal_error ("verify_ssa failed");
+}
+
+/* Return true if the uid in both int tree maps are equal. */
+
+int
+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 *b = (const struct int_tree_map *) vb;
+ return (a->uid == b->uid);
+}
+
+/* Hash a UID in a int_tree_map. */
+
+unsigned int
+int_tree_map_hash (const void *item)
+{
+ return ((const struct int_tree_map *)item)->uid;
}
void
init_tree_ssa (void)
{
- VARRAY_TREE_INIT (referenced_vars, 20, "referenced_vars");
- call_clobbered_vars = BITMAP_XMALLOC ();
- addressable_vars = BITMAP_XMALLOC ();
- init_ssa_operands ();
+ referenced_vars = htab_create_ggc (20, int_tree_map_hash,
+ int_tree_map_eq, NULL);
+ default_defs = htab_create_ggc (20, int_tree_map_hash, int_tree_map_eq, NULL);
+ call_clobbered_vars = BITMAP_ALLOC (NULL);
+ addressable_vars = BITMAP_ALLOC (NULL);
+ init_alias_heapvars ();
init_ssanames ();
init_phinodes ();
global_var = NULL_TREE;
+ aliases_computed_p = false;
}
size_t i;
basic_block bb;
block_stmt_iterator bsi;
+ referenced_var_iterator rvi;
+ tree var;
+
+ /* Release any ssa_names still in use. */
+ for (i = 0; i < num_ssa_names; i++)
+ {
+ tree var = ssa_name (i);
+ if (var && TREE_CODE (var) == SSA_NAME)
+ {
+ SSA_NAME_IMM_USE_NODE (var).prev = &(SSA_NAME_IMM_USE_NODE (var));
+ SSA_NAME_IMM_USE_NODE (var).next = &(SSA_NAME_IMM_USE_NODE (var));
+ }
+ release_ssa_name (var);
+ }
/* Remove annotations from every tree in the function. */
FOR_EACH_BB (bb)
- for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
- {
- tree stmt = bsi_stmt (bsi);
- release_defs (stmt);
- ggc_free (stmt->common.ann);
- stmt->common.ann = NULL;
- }
-
- /* Remove annotations from every referenced variable. */
- if (referenced_vars)
{
- for (i = 0; i < num_referenced_vars; i++)
+ for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
- tree var = referenced_var (i);
- ggc_free (var->common.ann);
- var->common.ann = NULL;
+ tree stmt = bsi_stmt (bsi);
+ stmt_ann_t ann = get_stmt_ann (stmt);
+
+ free_ssa_operands (&ann->operands);
+ ann->addresses_taken = 0;
+ mark_stmt_modified (stmt);
}
- referenced_vars = NULL;
+ set_phi_nodes (bb, NULL);
}
+ /* Remove annotations from every referenced variable. */
+ FOR_EACH_REFERENCED_VAR (var, rvi)
+ {
+ ggc_free (var->common.ann);
+ var->common.ann = NULL;
+ }
+ htab_delete (referenced_vars);
+ referenced_vars = NULL;
+
fini_ssanames ();
fini_phinodes ();
- fini_ssa_operands ();
global_var = NULL_TREE;
- BITMAP_XFREE (call_clobbered_vars);
+
+ htab_delete (default_defs);
+ BITMAP_FREE (call_clobbered_vars);
call_clobbered_vars = NULL;
- BITMAP_XFREE (addressable_vars);
+ BITMAP_FREE (addressable_vars);
addressable_vars = NULL;
+ modified_noreturn_calls = NULL;
+ aliases_computed_p = false;
+ delete_alias_heapvars ();
+ gcc_assert (!need_ssa_update_p ());
}
-/* Return true if EXPR is a useless type conversion, otherwise return
- false. */
+/* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
+ useless type conversion, otherwise return false. */
bool
tree_ssa_useless_type_conversion_1 (tree outer_type, tree inner_type)
{
+ if (inner_type == outer_type)
+ return true;
+
+ /* Changes in machine mode are never useless conversions. */
+ if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type))
+ return false;
+
/* If the inner and outer types are effectively the same, then
strip the type conversion and enter the equivalence into
the table. */
- if (inner_type == outer_type
- || (lang_hooks.types_compatible_p (inner_type, outer_type)))
+ if (lang_hooks.types_compatible_p (inner_type, outer_type))
return true;
/* If both types are pointers and the outer type is a (void *), then
implement the ABI. */
else if (POINTER_TYPE_P (inner_type)
&& POINTER_TYPE_P (outer_type)
- && TYPE_MODE (inner_type) == TYPE_MODE (outer_type)
&& TYPE_REF_CAN_ALIAS_ALL (inner_type)
== TYPE_REF_CAN_ALIAS_ALL (outer_type)
&& TREE_CODE (TREE_TYPE (outer_type)) == VOID_TYPE)
return true;
- /* Pointers and references are equivalent once we get to GENERIC,
- so strip conversions that just switch between them. */
+ /* Don't lose casts between pointers to volatile and non-volatile
+ qualified types. Doing so would result in changing the semantics
+ of later accesses. */
+ else if (POINTER_TYPE_P (inner_type)
+ && POINTER_TYPE_P (outer_type)
+ && TYPE_VOLATILE (TREE_TYPE (outer_type))
+ != TYPE_VOLATILE (TREE_TYPE (inner_type)))
+ return false;
+
+ /* Pointers/references are equivalent if their pointed to types
+ are effectively the same. This allows to strip conversions between
+ pointer types with different type qualifiers. */
else if (POINTER_TYPE_P (inner_type)
&& POINTER_TYPE_P (outer_type)
- && TYPE_MODE (inner_type) == TYPE_MODE (outer_type)
&& TYPE_REF_CAN_ALIAS_ALL (inner_type)
== TYPE_REF_CAN_ALIAS_ALL (outer_type)
&& lang_hooks.types_compatible_p (TREE_TYPE (inner_type),
mean that testing of precision is necessary. */
else if (INTEGRAL_TYPE_P (inner_type)
&& INTEGRAL_TYPE_P (outer_type)
- && TYPE_MODE (inner_type) == TYPE_MODE (outer_type)
&& TYPE_UNSIGNED (inner_type) == TYPE_UNSIGNED (outer_type)
- && TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type))
+ && TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type)
+ && simple_cst_equal (TYPE_MAX_VALUE (inner_type), TYPE_MAX_VALUE (outer_type))
+ && simple_cst_equal (TYPE_MIN_VALUE (inner_type), TYPE_MIN_VALUE (outer_type)))
{
bool first_boolean = (TREE_CODE (inner_type) == BOOLEAN_TYPE);
bool second_boolean = (TREE_CODE (outer_type) == BOOLEAN_TYPE);
return false;
}
+/* Returns true if statement STMT may read memory. */
+
+bool
+stmt_references_memory_p (tree stmt)
+{
+ stmt_ann_t ann = stmt_ann (stmt);
+
+ if (ann->has_volatile_ops)
+ return true;
+
+ return (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS));
+}
/* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
described in walk_use_def_chains.
- VISITED is a bitmap used to mark visited SSA_NAMEs to avoid
- infinite loops.
+ 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
+ SSA versions we had visited. But non-sparse bitmaps are way too
+ expensive, while sparse bitmaps may cause quadratic behavior.
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
static bool
walk_use_def_chains_1 (tree var, walk_use_def_chains_fn fn, void *data,
- bitmap visited, bool is_dfs)
+ struct pointer_set_t *visited, bool is_dfs)
{
tree def_stmt;
- if (bitmap_bit_p (visited, SSA_NAME_VERSION (var)))
+ if (pointer_set_insert (visited, var))
return false;
- bitmap_set_bit (visited, SSA_NAME_VERSION (var));
-
def_stmt = SSA_NAME_DEF_STMT (var);
if (TREE_CODE (def_stmt) != PHI_NODE)
(*fn) (var, def_stmt, data);
else
{
- bitmap visited = BITMAP_XMALLOC ();
+ struct pointer_set_t *visited = pointer_set_create ();
walk_use_def_chains_1 (var, fn, data, visited, is_dfs);
- BITMAP_XFREE (visited);
- }
-}
-
-
-/* Replaces VAR with REPL in memory reference expression *X in
- statement STMT. */
-
-static void
-propagate_into_addr (tree stmt, tree var, tree *x, tree repl)
-{
- tree new_var, ass_stmt, addr_var;
- basic_block bb;
- block_stmt_iterator bsi;
-
- /* There is nothing special to handle in the other cases. */
- if (TREE_CODE (repl) != ADDR_EXPR)
- return;
- addr_var = TREE_OPERAND (repl, 0);
-
- while (handled_component_p (*x)
- || TREE_CODE (*x) == REALPART_EXPR
- || TREE_CODE (*x) == IMAGPART_EXPR)
- x = &TREE_OPERAND (*x, 0);
-
- if (TREE_CODE (*x) != INDIRECT_REF
- || TREE_OPERAND (*x, 0) != var)
- return;
-
- if (TREE_TYPE (*x) == TREE_TYPE (addr_var))
- {
- *x = addr_var;
- mark_new_vars_to_rename (stmt, vars_to_rename);
- return;
- }
-
-
- /* Frontends sometimes produce expressions like *&a instead of a[0].
- Create a temporary variable to handle this case. */
- ass_stmt = build2 (MODIFY_EXPR, void_type_node, NULL_TREE, repl);
- new_var = duplicate_ssa_name (var, ass_stmt);
- TREE_OPERAND (*x, 0) = new_var;
- TREE_OPERAND (ass_stmt, 0) = new_var;
-
- bb = bb_for_stmt (stmt);
- tree_block_label (bb);
- bsi = bsi_after_labels (bb);
- bsi_insert_after (&bsi, ass_stmt, BSI_NEW_STMT);
-
- mark_new_vars_to_rename (stmt, vars_to_rename);
-}
-
-/* Replaces immediate uses of VAR by REPL. */
-
-static void
-replace_immediate_uses (tree var, tree repl)
-{
- int i, j, n;
- dataflow_t df;
- tree stmt;
- bool mark_new_vars;
- ssa_op_iter iter;
- use_operand_p use_p;
-
- df = get_immediate_uses (SSA_NAME_DEF_STMT (var));
- n = num_immediate_uses (df);
-
- for (i = 0; i < n; i++)
- {
- stmt = immediate_use (df, i);
-
- if (TREE_CODE (stmt) == PHI_NODE)
- {
- for (j = 0; j < PHI_NUM_ARGS (stmt); j++)
- if (PHI_ARG_DEF (stmt, j) == var)
- {
- SET_PHI_ARG_DEF (stmt, j, repl);
- if (TREE_CODE (repl) == SSA_NAME
- && PHI_ARG_EDGE (stmt, j)->flags & EDGE_ABNORMAL)
- SSA_NAME_OCCURS_IN_ABNORMAL_PHI (repl) = 1;
- }
-
- continue;
- }
-
- get_stmt_operands (stmt);
- mark_new_vars = false;
- if (is_gimple_reg (SSA_NAME_VAR (var)))
- {
- if (TREE_CODE (stmt) == MODIFY_EXPR)
- {
- propagate_into_addr (stmt, var, &TREE_OPERAND (stmt, 0), repl);
- propagate_into_addr (stmt, var, &TREE_OPERAND (stmt, 1), repl);
- }
-
- FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
- if (USE_FROM_PTR (use_p) == var)
- {
- propagate_value (use_p, repl);
- mark_new_vars = POINTER_TYPE_P (TREE_TYPE (repl));
- }
- }
- else
- {
- FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,
- SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_KILLS)
- if (USE_FROM_PTR (use_p) == var)
- propagate_value (use_p, repl);
- }
-
- /* FIXME. If REPL is a constant, we need to fold STMT.
- However, fold_stmt wants a pointer to the statement, because
- it may happen that it needs to replace the whole statement
- with a new expression. Since the current def-use machinery
- does not return pointers to statements, we call fold_stmt
- with the address of a local temporary, if that call changes
- the temporary then we fallback on looking for a proper
- pointer to STMT by scanning STMT's basic block.
-
- Note that all this will become unnecessary soon. This
- pass is being replaced with a proper copy propagation pass
- for 4.1 (dnovillo, 2004-09-17). */
- if (TREE_CODE (repl) != SSA_NAME)
- {
- tree tmp = stmt;
- fold_stmt (&tmp);
- mark_new_vars = true;
- if (tmp != stmt)
- {
- block_stmt_iterator si = bsi_for_stmt (stmt);
- bsi_replace (&si, tmp, true);
- stmt = bsi_stmt (si);
- }
- }
-
- /* If REPL is a pointer, it may have different memory tags associated
- with it. For instance, VAR may have had a name tag while REPL
- only had a type tag. In these cases, the virtual operands (if
- any) in the statement will refer to different symbols which need
- to be renamed. */
- if (mark_new_vars)
- mark_new_vars_to_rename (stmt, vars_to_rename);
- else
- modify_stmt (stmt);
- }
-}
-
-/* Gets the value VAR is equivalent to according to EQ_TO. */
-
-static tree
-get_eq_name (tree *eq_to, tree var)
-{
- unsigned ver;
- tree val = var;
-
- while (TREE_CODE (val) == SSA_NAME)
- {
- ver = SSA_NAME_VERSION (val);
- if (!eq_to[ver])
- break;
-
- val = eq_to[ver];
+ pointer_set_destroy (visited);
}
-
- while (TREE_CODE (var) == SSA_NAME)
- {
- ver = SSA_NAME_VERSION (var);
- if (!eq_to[ver])
- break;
-
- var = eq_to[ver];
- eq_to[ver] = val;
- }
-
- return val;
}
-/* Checks whether phi node PHI is redundant and if it is, records the ssa name
- its result is redundant to to EQ_TO array. */
-
-static void
-check_phi_redundancy (tree phi, tree *eq_to)
-{
- tree val = NULL_TREE, def, res = PHI_RESULT (phi), stmt;
- unsigned i, ver = SSA_NAME_VERSION (res), n;
- dataflow_t df;
-
- /* It is unlikely that such large phi node would be redundant. */
- if (PHI_NUM_ARGS (phi) > 16)
- return;
-
- for (i = 0; i < (unsigned) PHI_NUM_ARGS (phi); i++)
- {
- def = PHI_ARG_DEF (phi, i);
-
- if (TREE_CODE (def) == SSA_NAME)
- {
- def = get_eq_name (eq_to, def);
- if (def == res)
- continue;
- }
-
- if (val
- && !operand_equal_p (val, def, 0))
- return;
-
- val = def;
- }
-
- /* At least one of the arguments should not be equal to the result, or
- something strange is happening. */
- gcc_assert (val);
-
- if (get_eq_name (eq_to, res) == val)
- return;
-
- if (!may_propagate_copy (res, val))
- return;
-
- eq_to[ver] = val;
-
- df = get_immediate_uses (SSA_NAME_DEF_STMT (res));
- n = num_immediate_uses (df);
-
- for (i = 0; i < n; i++)
- {
- stmt = immediate_use (df, i);
-
- if (TREE_CODE (stmt) == PHI_NODE)
- check_phi_redundancy (stmt, eq_to);
- }
-}
-
-/* Removes redundant phi nodes.
-
- A redundant PHI node is a PHI node where all of its PHI arguments
- are the same value, excluding any PHI arguments which are the same
- as the PHI result.
-
- A redundant PHI node is effectively a copy, so we forward copy propagate
- which removes all uses of the destination of the PHI node then
- finally we delete the redundant PHI node.
-
- Note that if we can not copy propagate the PHI node, then the PHI
- will not be removed. Thus we do not have to worry about dependencies
- between PHIs and the problems serializing PHIs into copies creates.
-
- The most important effect of this pass is to remove degenerate PHI
- nodes created by removing unreachable code. */
-
-void
-kill_redundant_phi_nodes (void)
-{
- tree *eq_to;
- unsigned i, old_num_ssa_names;
- basic_block bb;
- tree phi, var, repl, stmt;
-
- /* The EQ_TO[VER] holds the value by that the ssa name VER should be
- replaced. If EQ_TO[VER] is ssa name and it is decided to replace it by
- other value, it may be necessary to follow the chain till the final value.
- We perform path shortening (replacing the entries of the EQ_TO array with
- heads of these chains) whenever we access the field to prevent quadratic
- complexity (probably would not occur in practice anyway, but let us play
- it safe). */
- eq_to = xcalloc (num_ssa_names, sizeof (tree));
-
- /* We have had cases where computing immediate uses takes a
- significant amount of compile time. If we run into such
- problems here, we may want to only compute immediate uses for
- a subset of all the SSA_NAMEs instead of computing it for
- all of the SSA_NAMEs. */
- compute_immediate_uses (TDFA_USE_OPS | TDFA_USE_VOPS, NULL);
- old_num_ssa_names = num_ssa_names;
-
- FOR_EACH_BB (bb)
- {
- for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
- {
- var = PHI_RESULT (phi);
- check_phi_redundancy (phi, eq_to);
- }
- }
-
- /* Now propagate the values. */
- for (i = 0; i < old_num_ssa_names; i++)
- {
- if (!ssa_name (i))
- continue;
-
- repl = get_eq_name (eq_to, ssa_name (i));
- if (repl != ssa_name (i))
- replace_immediate_uses (ssa_name (i), repl);
- }
-
- /* And remove the dead phis. */
- for (i = 0; i < old_num_ssa_names; i++)
- {
- if (!ssa_name (i))
- continue;
-
- repl = get_eq_name (eq_to, ssa_name (i));
- if (repl != ssa_name (i))
- {
- stmt = SSA_NAME_DEF_STMT (ssa_name (i));
- remove_phi_node (stmt, NULL_TREE, bb_for_stmt (stmt));
- }
- }
-
- free_df ();
- free (eq_to);
-}
-
-struct tree_opt_pass pass_redundant_phi =
-{
- "redphi", /* name */
- NULL, /* gate */
- kill_redundant_phi_nodes, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- 0, /* tv_id */
- PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_dump_func | TODO_rename_vars
- | TODO_ggc_collect | TODO_verify_ssa, /* todo_flags_finish */
- 0 /* letter */
-};
\f
/* Emit warnings for uninitialized variables. This is done in two passes.
warning text is in MSGID and LOCUS may contain a location or be null. */
static void
-warn_uninit (tree t, const char *msgid, location_t *locus)
+warn_uninit (tree t, const char *gmsgid, void *data)
{
tree var = SSA_NAME_VAR (t);
tree def = SSA_NAME_DEF_STMT (t);
+ tree context = (tree) data;
+ location_t * locus;
/* Default uses (indicated by an empty definition statement),
are uninitialized. */
if (TREE_NO_WARNING (var))
return;
- if (!locus)
- locus = &DECL_SOURCE_LOCATION (var);
- warning (msgid, locus, var);
+ locus = (context != NULL && EXPR_HAS_LOCATION (context)
+ ? EXPR_LOCUS (context)
+ : &DECL_SOURCE_LOCATION (var));
+ warning (0, gmsgid, locus, var);
TREE_NO_WARNING (var) = 1;
}
static tree
warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data)
{
- location_t *locus = data;
tree t = *tp;
- /* We only do data flow with SSA_NAMEs, so that's all we can warn about. */
- if (TREE_CODE (t) == SSA_NAME)
+ switch (TREE_CODE (t))
{
- warn_uninit (t, "%H%qD is used uninitialized in this function", locus);
+ case SSA_NAME:
+ /* We only do data flow with SSA_NAMEs, so that's all we
+ can warn about. */
+ warn_uninit (t, "%H%qD is used uninitialized in this function", data);
*walk_subtrees = 0;
+ break;
+
+ case REALPART_EXPR:
+ case IMAGPART_EXPR:
+ /* The total store transformation performed during gimplification
+ creates uninitialized variable uses. If all is well, these will
+ be optimized away, so don't warn now. */
+ if (TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME)
+ *walk_subtrees = 0;
+ break;
+
+ default:
+ if (IS_TYPE_OR_DECL_P (t))
+ *walk_subtrees = 0;
+ break;
}
- else if (IS_TYPE_OR_DECL_P (t))
- *walk_subtrees = 0;
return NULL_TREE;
}
FOR_EACH_BB (bb)
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
- walk_tree (bsi_stmt_ptr (bsi), warn_uninitialized_var,
- EXPR_LOCUS (bsi_stmt (bsi)), NULL);
+ {
+ tree context = bsi_stmt (bsi);
+ walk_tree (bsi_stmt_ptr (bsi), warn_uninitialized_var,
+ context, NULL);
+ }
}
static void