return e;
}
-/* Add PHI arguments queued in PENDINT_STMT list on edge E to edge
+/* Add PHI arguments queued in PENDING_STMT list on edge E to edge
E->dest. */
void
return true;
}
+ if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
+ && !IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name)))
+ {
+ error ("found a default name with a non-empty defining statement");
+ return true;
+ }
+
return false;
}
it means that the block in that array slot contains the
definition of SSA_NAME.
- IS_VIRTUAL is true if SSA_NAME is created by a V_MAY_DEF or a
- V_MUST_DEF. */
+ IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
static bool
verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
is flowing through an abnormal edge (only used when checking PHI
arguments).
- IS_VIRTUAL is true if SSA_NAME is created by a V_MAY_DEF or a
- V_MUST_DEF.
-
If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
that are defined before STMT in basic block BB. */
static bool
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)
+ tree stmt, bool check_abnormal, 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))
- && default_def (SSA_NAME_VAR (ssa_name)) == ssa_name)
+ && SSA_NAME_IS_DEFAULT_DEF (ssa_name))
; /* Default definitions have empty statements. Nothing to do. */
else if (!def_bb)
{
/* Return true if any of the arguments for PHI node PHI at block BB is
malformed.
- 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. */
+ 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. */
static bool
verify_phi_args (tree phi, basic_block bb, basic_block *definition_block)
use_operand_p op_p = PHI_ARG_DEF_PTR (phi, i);
tree op = USE_FROM_PTR (op_p);
-
e = EDGE_PRED (bb, i);
if (op == NULL_TREE)
}
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);
+ {
+ err = verify_ssa_name (op, !is_gimple_reg (PHI_RESULT (phi)));
+ err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)],
+ op_p, phi, e->flags & EDGE_ABNORMAL, NULL);
+ }
if (e->dest != bb)
{
if (err)
{
fprintf (stderr, "for PHI node\n");
- print_generic_stmt (stderr, phi, TDF_VOPS);
+ print_generic_stmt (stderr, phi, TDF_VOPS|TDF_MEMSYMS);
}
verify_flow_insensitive_alias_info (void)
{
tree var;
- bitmap visited = BITMAP_ALLOC (NULL);
referenced_var_iterator rvi;
FOR_EACH_REFERENCED_VAR (var, rvi)
{
- size_t j;
- var_ann_t ann;
- varray_type may_aliases;
+ unsigned int j;
+ bitmap aliases;
+ tree alias;
+ bitmap_iterator bi;
- ann = var_ann (var);
- may_aliases = ann->may_aliases;
+ if (!MTAG_P (var) || !MTAG_ALIASES (var))
+ continue;
+
+ aliases = MTAG_ALIASES (var);
- for (j = 0; may_aliases && j < VARRAY_ACTIVE_SIZE (may_aliases); j++)
+ EXECUTE_IF_SET_IN_BITMAP (aliases, 0, j, bi)
{
- tree alias = VARRAY_TREE (may_aliases, j);
-
- bitmap_set_bit (visited, DECL_UID (alias));
+ alias = referenced_var (j);
- if (!may_be_aliased (alias))
+ if (TREE_CODE (alias) != MEMORY_PARTITION_TAG
+ && !may_be_aliased (alias))
{
error ("non-addressable variable inside an alias set");
debug_variable (alias);
}
}
- FOR_EACH_REFERENCED_VAR (var, rvi)
- {
- var_ann_t ann;
- ann = var_ann (var);
-
- if (ann->mem_tag_kind == NOT_A_TAG
- && ann->is_alias_tag
- && !bitmap_bit_p (visited, DECL_UID (var)))
- {
- error ("addressable variable that is an alias tag but is not in any alias set");
- goto err;
- }
- }
-
- BITMAP_FREE (visited);
return;
err:
continue;
ann = var_ann (var);
- if (pi->is_dereferenced && !pi->name_mem_tag && !ann->type_mem_tag)
+ if (pi->is_dereferenced && !pi->name_mem_tag && !ann->symbol_mem_tag)
{
- error ("dereferenced pointers should have a name or a type tag");
+ error ("dereferenced pointers should have a name or a symbol tag");
goto err;
}
goto err;
}
- if (pi->value_escapes_p
- && pi->name_mem_tag
- && !is_call_clobbered (pi->name_mem_tag))
+ if (pi->value_escapes_p && pi->name_mem_tag)
{
- error ("pointer escapes but its name tag is not call-clobbered");
- goto err;
+ tree t = memory_partition (pi->name_mem_tag);
+ if (t == NULL_TREE)
+ t = pi->name_mem_tag;
+
+ if (!is_call_clobbered (t))
+ {
+ error ("pointer escapes but its name tag is not call-clobbered");
+ goto err;
+ }
}
}
internal_error ("verify_flow_sensitive_alias_info failed");
}
-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.
- 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. */
+/* Verify the consistency of call clobbering information. */
static void
-verify_name_tags (void)
+verify_call_clobbering (void)
{
- size_t i;
- size_t j;
- bitmap first, second;
- 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++)
- {
- 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;
+ unsigned int i;
+ bitmap_iterator bi;
+ tree var;
+ referenced_var_iterator rvi;
- if (pi->pt_vars == NULL)
- continue;
+ /* At all times, the result of the call_clobbered flag should
+ match the result of the call_clobbered_vars bitmap. Verify both
+ that everything in call_clobbered_vars is marked
+ call_clobbered, and that everything marked
+ call_clobbered is in call_clobbered_vars. */
+ EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun), 0, i, bi)
+ {
+ var = referenced_var (i);
- VEC_safe_push (tree, heap, name_tag_reps, ptr);
- VEC_safe_push (bitmap, heap, pt_vars_for_reps, pi->pt_vars);
+ if (memory_partition (var))
+ var = memory_partition (var);
- /* 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)
+ if (!MTAG_P (var) && !var_ann (var)->call_clobbered)
{
- 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;
-
- 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;
- }
+ error ("variable in call_clobbered_vars but not marked "
+ "call_clobbered");
+ debug_variable (var);
+ goto err;
}
}
-
- /* Now compare all the representative bitmaps with all other representative
- bitmaps, to verify that they are all different. */
- for (i = 0; VEC_iterate (bitmap, pt_vars_for_reps, i, first); i++)
- {
- for (j = i + 1; VEC_iterate (bitmap, pt_vars_for_reps, j, second); j++)
- {
- if (bitmap_equal_p (first, second))
- {
- error ("two different pointers with identical points-to sets but different name tags");
- debug_variable (VEC_index (tree, name_tag_reps, j));
- goto err;
- }
- }
- }
- /* Lastly, clear out the visited flags. */
- for (i = 0; i < num_ssa_names; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- if (ssa_name (i))
+ if (is_gimple_reg (var))
+ continue;
+
+ if (memory_partition (var))
+ var = memory_partition (var);
+
+ if (!MTAG_P (var)
+ && var_ann (var)->call_clobbered
+ && !bitmap_bit_p (gimple_call_clobbered_vars (cfun), DECL_UID (var)))
{
- tree ptr = ssa_name (i);
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr);
- if (!TREE_VISITED (ptr)
- || !POINTER_TYPE_P (TREE_TYPE (ptr))
- || !pi
- || !pi->name_mem_tag)
- continue;
- TREE_VISITED (pi->name_mem_tag) = 0;
+ error ("variable marked call_clobbered but not in "
+ "call_clobbered_vars bitmap.");
+ debug_variable (var);
+ goto err;
}
- }
+ }
- /* 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");
-}
+ err:
+ internal_error ("verify_call_clobbering failed");
+}
/* Verify the consistency of aliasing information. */
verify_alias_info (void)
{
verify_flow_sensitive_alias_info ();
- verify_name_tags ();
+ verify_call_clobbering ();
verify_flow_insensitive_alias_info ();
}
{
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];
{
if (verify_phi_args (phi, bb, definition_block))
goto err;
+
bitmap_set_bit (names_defined_in_bb,
SSA_NAME_VERSION (PHI_RESULT (phi)));
}
if (check_modified_stmt && stmt_modified_p (stmt))
{
- error ("stmt (%p) marked modified after optimization pass : ",
+ 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)
+ if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+ && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) != SSA_NAME)
{
tree lhs, base_address;
- lhs = TREE_OPERAND (stmt, 0);
+ lhs = GIMPLE_STMT_OPERAND (stmt, 0);
base_address = get_base_address (lhs);
if (base_address
+ && gimple_aliases_computed_p (cfun)
&& SSA_VAR_P (base_address)
- && ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF|SSA_OP_VMUSTDEF))
+ && !stmt_ann (stmt)->has_volatile_ops
+ && ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF))
{
- error ("statement makes a memory store, but has no "
- "V_MAY_DEFS nor V_MUST_DEFS");
+ error ("statement makes a memory store, but has no VDEFS");
print_generic_stmt (stderr, stmt, TDF_VOPS);
goto err;
}
}
+ FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_VIRTUALS)
+ {
+ if (verify_ssa_name (op, true))
+ {
+ error ("in statement");
+ print_generic_stmt (stderr, stmt, TDF_VOPS|TDF_MEMSYMS);
+ goto err;
+ }
+ }
- if (stmt_ann (stmt)->makes_aliased_stores
- && ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF))
+ FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE|SSA_OP_DEF)
{
- error ("statement makes aliased stores, but has no V_MAY_DEFS");
- print_generic_stmt (stderr, stmt, TDF_VOPS);
- goto err;
+ if (verify_ssa_name (op, false))
+ {
+ error ("in statement");
+ print_generic_stmt (stderr, stmt, TDF_VOPS|TDF_MEMSYMS);
+ 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_USE|SSA_OP_VUSE)
{
op = USE_FROM_PTR (use_p);
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
- use_p, stmt, false, !is_gimple_reg (op),
- names_defined_in_bb))
+ use_p, stmt, false, names_defined_in_bb))
goto err;
}
}
/* Finally, verify alias information. */
- verify_alias_info ();
+ if (gimple_aliases_computed_p (cfun))
+ verify_alias_info ();
free (definition_block);
int
int_tree_map_eq (const void *va, const void *vb)
{
- const struct int_tree_map *a = va, *b = 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);
}
return ((const struct int_tree_map *)item)->uid;
}
+/* Return true if the uid in both int tree maps are equal. */
+
+static int
+var_ann_eq (const void *va, const void *vb)
+{
+ const struct static_var_ann_d *a = (const struct static_var_ann_d *) va;
+ tree b = (tree) vb;
+ return (a->uid == DECL_UID (b));
+}
+
+/* Hash a UID in a int_tree_map. */
+
+static unsigned int
+var_ann_hash (const void *item)
+{
+ return ((const struct static_var_ann_d *)item)->uid;
+}
+
/* Initialize global DFA and SSA structures. */
void
init_tree_ssa (void)
{
- referenced_vars = htab_create_ggc (20, int_tree_map_hash,
- int_tree_map_eq, NULL);
- call_clobbered_vars = BITMAP_ALLOC (NULL);
- addressable_vars = BITMAP_ALLOC (NULL);
+ cfun->gimple_df = ggc_alloc_cleared (sizeof (struct gimple_df));
+ cfun->gimple_df->referenced_vars = htab_create_ggc (20, int_tree_map_hash,
+ int_tree_map_eq, NULL);
+ cfun->gimple_df->default_defs = htab_create_ggc (20, int_tree_map_hash,
+ int_tree_map_eq, NULL);
+ cfun->gimple_df->var_anns = htab_create_ggc (20, var_ann_hash,
+ var_ann_eq, NULL);
+ cfun->gimple_df->call_clobbered_vars = BITMAP_GGC_ALLOC ();
+ cfun->gimple_df->addressable_vars = BITMAP_GGC_ALLOC ();
init_ssanames ();
init_phinodes ();
- global_var = NULL_TREE;
- aliases_computed_p = false;
}
/* Remove annotations from every referenced variable. */
FOR_EACH_REFERENCED_VAR (var, rvi)
{
- ggc_free (var->common.ann);
- var->common.ann = NULL;
+ if (var->base.ann)
+ ggc_free (var->base.ann);
+ var->base.ann = NULL;
}
- htab_delete (referenced_vars);
- referenced_vars = NULL;
+ htab_delete (gimple_referenced_vars (cfun));
+ cfun->gimple_df->referenced_vars = NULL;
fini_ssanames ();
fini_phinodes ();
+ /* we no longer maintain the SSA operand cache at this point. */
+ fini_ssa_operands ();
- global_var = NULL_TREE;
- BITMAP_FREE (call_clobbered_vars);
- call_clobbered_vars = NULL;
- BITMAP_FREE (addressable_vars);
- addressable_vars = NULL;
- modified_noreturn_calls = NULL;
- aliases_computed_p = false;
- gcc_assert (!need_ssa_update_p ());
+ cfun->gimple_df->global_var = NULL_TREE;
+
+ htab_delete (cfun->gimple_df->default_defs);
+ cfun->gimple_df->default_defs = NULL;
+ htab_delete (cfun->gimple_df->var_anns);
+ cfun->gimple_df->var_anns = NULL;
+ cfun->gimple_df->call_clobbered_vars = NULL;
+ cfun->gimple_df->addressable_vars = NULL;
+ cfun->gimple_df->modified_noreturn_calls = NULL;
+ if (gimple_aliases_computed_p (cfun))
+ {
+ delete_alias_heapvars ();
+ gcc_assert (!need_ssa_update_p ());
+ }
+ cfun->gimple_df->aliases_computed_p = false;
+
+ cfun->gimple_df = NULL;
}
&& TREE_CODE (TREE_TYPE (outer_type)) == VOID_TYPE)
return true;
+ /* 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. */
if (TREE_CODE (expr) == NOP_EXPR || TREE_CODE (expr) == CONVERT_EXPR
|| TREE_CODE (expr) == VIEW_CONVERT_EXPR
|| TREE_CODE (expr) == NON_LVALUE_EXPR)
- return tree_ssa_useless_type_conversion_1 (TREE_TYPE (expr),
- TREE_TYPE (TREE_OPERAND (expr,
- 0)));
-
+ /* FIXME: Use of GENERIC_TREE_TYPE here is a temporary measure to work
+ around known bugs with GIMPLE_MODIFY_STMTs appearing in places
+ they shouldn't. See PR 30391. */
+ return tree_ssa_useless_type_conversion_1
+ (TREE_TYPE (expr),
+ GENERIC_TREE_TYPE (TREE_OPERAND (expr, 0)));
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.
for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
{
tree arg = PHI_ARG_DEF (def_stmt, i);
- if (TREE_CODE (arg) == SSA_NAME
+
+ /* ARG may be NULL for newly introduced PHI nodes. */
+ if (arg
+ && TREE_CODE (arg) == SSA_NAME
&& walk_use_def_chains_1 (arg, fn, data, visited, is_dfs))
return true;
}
If IS_DFS is false, the two steps above are done in reverse order
(i.e., a breadth-first search). */
-
void
walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
bool is_dfs)
tree var = SSA_NAME_VAR (t);
tree def = SSA_NAME_DEF_STMT (t);
tree context = (tree) data;
- location_t * locus;
+ location_t *locus;
+ expanded_location xloc, floc;
/* Default uses (indicated by an empty definition statement),
are uninitialized. */
? EXPR_LOCUS (context)
: &DECL_SOURCE_LOCATION (var));
warning (0, gmsgid, locus, var);
+ xloc = expand_location (*locus);
+ floc = expand_location (DECL_SOURCE_LOCATION (cfun->decl));
+ if (xloc.file != floc.file
+ || xloc.line < floc.line
+ || xloc.line > LOCATION_LINE (cfun->function_end_locus))
+ inform ("%J%qD was declared here", var, 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;
}
}
}
-static void
+static unsigned int
execute_early_warn_uninitialized (void)
{
block_stmt_iterator bsi;
walk_tree (bsi_stmt_ptr (bsi), warn_uninitialized_var,
context, NULL);
}
+ return 0;
}
-static void
+static unsigned int
execute_late_warn_uninitialized (void)
{
basic_block bb;
FOR_EACH_BB (bb)
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
warn_uninitialized_phi (phi);
+ return 0;
}
static bool
0, /* todo_flags_finish */
0 /* letter */
};
-
OSDN Git Service
