return true;
}
+ if (TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
+ {
+ error ("Type mismatch between an SSA_NAME and its symbol.");
+ return true;
+ }
+
if (SSA_NAME_IN_FREE_LIST (ssa_name))
{
error ("Found an SSA_NAME that had been released into the free pool");
for (i = 0; i < num_referenced_vars; i++)
{
+ size_t j;
var_ann_t ann;
+ varray_type may_aliases;
var = referenced_var (i);
ann = var_ann (var);
+ may_aliases = ann->may_aliases;
- if (ann->mem_tag_kind == TYPE_TAG || ann->mem_tag_kind == NAME_TAG)
+ for (j = 0; may_aliases && j < VARRAY_ACTIVE_SIZE (may_aliases); j++)
{
- size_t j;
- varray_type may_aliases = ann->may_aliases;
+ tree alias = VARRAY_TREE (may_aliases, j);
- for (j = 0; may_aliases && j < VARRAY_ACTIVE_SIZE (may_aliases); j++)
- {
- tree alias = VARRAY_TREE (may_aliases, j);
-
- bitmap_set_bit (visited, var_ann (alias)->uid);
+ bitmap_set_bit (visited, var_ann (alias)->uid);
- if (!may_be_aliased (alias))
- {
- error ("Non-addressable variable inside an alias set.");
- debug_variable (alias);
- goto err;
- }
+ if (!may_be_aliased (alias))
+ {
+ error ("Non-addressable variable inside an alias set.");
+ debug_variable (alias);
+ goto err;
}
}
}
goto err;
}
- if (pi->pt_anything && (pi->pt_malloc || pi->pt_vars))
- {
- error ("Pointers that point to anything should not point to malloc or other vars");
- goto err;
- }
-
- if (pi->pt_malloc && pi->pt_vars)
- {
- error ("Pointers pointing to malloc get a unique tag and cannot point to other vars");
- goto err;
- }
-
if (pi->name_mem_tag
&& !pi->pt_malloc
&& (pi->pt_vars == NULL
tree ptr2 = ssa_name (j);
struct ptr_info_def *pi2 = SSA_NAME_PTR_INFO (ptr2);
- if (!POINTER_TYPE_P (TREE_TYPE (ptr2)))
+ if (!TREE_VISITED (ptr2) || !POINTER_TYPE_P (TREE_TYPE (ptr2)))
continue;
if (pi2
static void
verify_alias_info (void)
{
- if (aliases_computed_p)
- {
- verify_flow_sensitive_alias_info ();
- verify_flow_insensitive_alias_info ();
- }
+ verify_flow_sensitive_alias_info ();
+ verify_flow_insensitive_alias_info ();
}
size_t i;
basic_block bb;
basic_block *definition_block = xcalloc (num_ssa_names, sizeof (basic_block));
+ ssa_op_iter iter;
+ tree op;
timevar_push (TV_TREE_SSA_VERIFY);
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt;
- stmt_ann_t ann;
- unsigned int j;
- v_may_def_optype v_may_defs;
- v_must_def_optype v_must_defs;
- def_optype defs;
stmt = bsi_stmt (bsi);
- ann = stmt_ann (stmt);
get_stmt_operands (stmt);
- v_may_defs = V_MAY_DEF_OPS (ann);
- if (ann->makes_aliased_stores && NUM_V_MAY_DEFS (v_may_defs) == 0)
+ if (stmt_ann (stmt)->makes_aliased_stores
+ && NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) == 0)
{
error ("Statement makes aliased stores, but has no V_MAY_DEFS");
debug_generic_stmt (stmt);
goto err;
}
- for (j = 0; j < NUM_V_MAY_DEFS (v_may_defs); j++)
+ FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_DEFS)
{
- tree op = V_MAY_DEF_RESULT (v_may_defs, j);
if (verify_def (bb, definition_block, op, stmt, true))
goto err;
}
- v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
- for (j = 0; j < NUM_V_MUST_DEFS (v_must_defs); j++)
- {
- tree op = V_MUST_DEF_OP (v_must_defs, j);
- if (verify_def (bb, definition_block, op, stmt, true))
- goto err;
- }
-
- defs = DEF_OPS (ann);
- for (j = 0; j < NUM_DEFS (defs); j++)
+ FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
{
- tree op = DEF_OP (defs, j);
if (verify_def (bb, definition_block, op, stmt, false))
goto err;
}
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
- stmt_ann_t ann = stmt_ann (stmt);
- unsigned int j;
- vuse_optype vuses;
- v_may_def_optype v_may_defs;
- use_optype uses;
-
- vuses = VUSE_OPS (ann);
- for (j = 0; j < NUM_VUSES (vuses); j++)
- {
- tree op = VUSE_OP (vuses, j);
- if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
- op, stmt, false, true))
- goto err;
- }
- v_may_defs = V_MAY_DEF_OPS (ann);
- for (j = 0; j < NUM_V_MAY_DEFS (v_may_defs); j++)
+ FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_USES)
{
- tree op = V_MAY_DEF_OP (v_may_defs, j);
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
op, stmt, false, true))
goto err;
}
- uses = USE_OPS (ann);
- for (j = 0; j < NUM_USES (uses); j++)
+ FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
{
- tree op = USE_OP (uses, j);
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
op, stmt, false, false))
goto err;
init_ssanames ();
init_phinodes ();
global_var = NULL_TREE;
- aliases_computed_p = false;
}
/* Remove annotations from every tree in the function. */
FOR_EACH_BB (bb)
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
- bsi_stmt (bsi)->common.ann = NULL;
+ {
+ 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++)
- referenced_var (i)->common.ann = NULL;
+ {
+ tree var = referenced_var (i);
+ ggc_free (var->common.ann);
+ var->common.ann = NULL;
+ }
referenced_vars = NULL;
}
global_var = NULL_TREE;
BITMAP_XFREE (call_clobbered_vars);
call_clobbered_vars = NULL;
- aliases_computed_p = false;
BITMAP_XFREE (addressable_vars);
addressable_vars = NULL;
}
return;
addr_var = TREE_OPERAND (repl, 0);
- while (TREE_CODE (*x) == ARRAY_REF
- || TREE_CODE (*x) == COMPONENT_REF
- || TREE_CODE (*x) == BIT_FIELD_REF)
+ 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;
- modify_stmt (stmt);
if (TREE_TYPE (*x) == TREE_TYPE (addr_var))
{
*x = addr_var;
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);
static void
replace_immediate_uses (tree var, tree repl)
{
- use_optype uses;
- vuse_optype vuses;
- v_may_def_optype v_may_defs;
int i, j, n;
dataflow_t df;
tree stmt;
stmt_ann_t ann;
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);
propagate_into_addr (stmt, var, &TREE_OPERAND (stmt, 1), repl);
}
- uses = USE_OPS (ann);
- for (j = 0; j < (int) NUM_USES (uses); j++)
- if (USE_OP (uses, j) == var)
+ FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
+ if (USE_FROM_PTR (use_p) == var)
{
- propagate_value (USE_OP_PTR (uses, j), repl);
+ propagate_value (use_p, repl);
mark_new_vars = POINTER_TYPE_P (TREE_TYPE (repl));
}
}
else
{
- vuses = VUSE_OPS (ann);
- for (j = 0; j < (int) NUM_VUSES (vuses); j++)
- if (VUSE_OP (vuses, j) == var)
- propagate_value (VUSE_OP_PTR (vuses, j), repl);
-
- v_may_defs = V_MAY_DEF_OPS (ann);
- for (j = 0; j < (int) NUM_V_MAY_DEFS (v_may_defs); j++)
- if (V_MAY_DEF_OP (v_may_defs, j) == var)
- propagate_value (V_MAY_DEF_OP_PTR (v_may_defs, j), repl);
+ FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_VIRTUAL_USES)
+ if (USE_FROM_PTR (use_p) == var)
+ propagate_value (use_p, repl);
}
/* If REPL is a pointer, it may have different memory tags associated
NULL, /* next */
0, /* static_pass_number */
0, /* tv_id */
- PROP_cfg | PROP_ssa, /* properties_required */
+ PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
OSDN Git Service
