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 "hashtab.h"
#include "tree-dump.h"
#include "tree-pass.h"
+#include "toplev.h"
/* Remove the corresponding arguments from the PHI nodes in E's
destination block and redirect it to DEST. Return redirected edge.
{
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");
+ error ("found real variable when subvariables should have appeared");
return 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;
}
}
/* Make sure the use is in an appropriate list by checking the previous
- element to make sure its the same. */
+ element to make sure it's the same. */
if (use_p->prev == NULL)
{
- error ("No immediate_use list");
+ error ("no immediate_use list");
err = true;
}
else
listvar = USE_FROM_PTR (use_p->prev);
if (listvar != ssa_name)
{
- error ("Wrong immediate use list");
+ error ("wrong immediate use list");
err = true;
}
}
if (EDGE_COUNT (bb->preds) != phi_num_args)
{
- error ("Incoming edge count does not match number of PHI arguments\n");
+ error ("incoming edge count does not match number of PHI arguments");
err = true;
goto error;
}
if (op == NULL_TREE)
{
- error ("PHI argument is missing for edge %d->%d\n",
+ error ("PHI argument is missing for edge %d->%d",
e->src->index,
e->dest->index);
err = true;
if (e->dest != bb)
{
- error ("Wrong edge %d->%d for PHI argument\n",
- e->src->index, e->dest->index, bb->index);
+ error ("wrong edge %d->%d for PHI argument",
+ e->src->index, e->dest->index);
err = true;
}
static void
verify_flow_insensitive_alias_info (void)
{
- size_t i;
tree var;
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;
+ VEC(tree,gc) *may_aliases;
+ tree alias;
- var = referenced_var (i);
ann = var_ann (var);
may_aliases = ann->may_aliases;
- for (j = 0; may_aliases && j < VARRAY_ACTIVE_SIZE (may_aliases); j++)
+ for (j = 0; VEC_iterate (tree, may_aliases, j, alias); j++)
{
- 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;
}
}
err:
debug_variable (var);
- internal_error ("verify_flow_insensitive_alias_info failed.");
+ internal_error ("verify_flow_insensitive_alias_info failed");
}
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
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. */
if (pi->pt_vars == NULL)
continue;
- VEC_safe_push (tree, name_tag_reps, ptr);
- VEC_safe_push (bitmap, pt_vars_for_reps, pi->pt_vars);
+ 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. */
if (tmt)
{
size_t i;
- varray_type aliases = var_ann (tmt)->may_aliases;
+ VEC(tree,gc) *aliases = var_ann (tmt)->may_aliases;
+ tree alias;
+
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, var_ann (alias)->uid);
- }
+ for (i = 0; VEC_iterate (tree, aliases, i, alias); 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, var_ann (tmt)->uid);
+ bitmap_set_bit (type_aliases, DECL_UID (tmt));
if (bitmap_equal_p (type_aliases, pi->pt_vars))
continue;
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");
+ 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;
}
}
}
- 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;
{
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_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. */
{
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;
}
if (check_modified_stmt && stmt_modified_p (stmt))
{
- error ("Stmt (0x%x) marked modified after optimization pass : ",
- (unsigned long)stmt);
+ error ("stmt (%p) marked modified after optimization pass : ",
+ (void *)stmt);
print_generic_stmt (stderr, stmt, TDF_VOPS);
goto err;
}
+ if (TREE_CODE (stmt) == MODIFY_EXPR
+ && TREE_CODE (TREE_OPERAND (stmt, 0)) != SSA_NAME)
+ {
+ tree lhs, base_address;
+
+ lhs = TREE_OPERAND (stmt, 0);
+ base_address = get_base_address (lhs);
- if (stmt_ann (stmt)->makes_aliased_stores
- && NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) == 0)
+ if (base_address
+ && SSA_VAR_P (base_address)
+ && ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF|SSA_OP_VMUSTDEF))
{
- error ("Statement makes aliased stores, but has no V_MAY_DEFS");
+ 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;
}
+ }
- FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES | SSA_OP_ALL_KILLS)
+ FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,
+ SSA_OP_ALL_USES | SSA_OP_ALL_KILLS)
{
op = USE_FROM_PTR (use_p);
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
}
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
- {
- 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);
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)
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");
+ 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;
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 ();
global_var = NULL_TREE;
+
+ htab_delete (default_defs);
BITMAP_FREE (call_clobbered_vars);
call_clobbered_vars = NULL;
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)
&& 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_REF_CAN_ALIAS_ALL (inner_type)
else if (INTEGRAL_TYPE_P (inner_type)
&& INTEGRAL_TYPE_P (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);
bool
stmt_references_memory_p (tree stmt)
{
- stmt_ann_t ann;
-
- get_stmt_operands (stmt);
- ann = stmt_ann (stmt);
+ stmt_ann_t ann = stmt_ann (stmt);
if (ann->has_volatile_ops)
return true;
- return (NUM_VUSES (VUSE_OPS (ann)) > 0
- || NUM_V_MAY_DEFS (V_MAY_DEF_OPS (ann)) > 0
- || NUM_V_MUST_DEFS (V_MUST_DEF_OPS (ann)) > 0);
+ return (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS));
}
/* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
warning text is in MSGID and LOCUS may contain a location or be null. */
static void
-warn_uninit (tree t, const char *msgid, void *data)
+warn_uninit (tree t, const char *gmsgid, void *data)
{
tree var = SSA_NAME_VAR (t);
tree def = SSA_NAME_DEF_STMT (t);
locus = (context != NULL && EXPR_HAS_LOCATION (context)
? EXPR_LOCUS (context)
: &DECL_SOURCE_LOCATION (var));
- warning (msgid, locus, var);
+ warning (0, gmsgid, locus, var);
TREE_NO_WARNING (var) = 1;
}
{
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))
{
+ 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;
}