#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 "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);
-}
-
/* Remove the corresponding arguments from the PHI nodes in E's
destination block and redirect it to DEST. Return redirected edge.
The list of removed arguments is stored in PENDING_STMT (e). */
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);
for (phi = phi_nodes (e->dest), arg = PENDING_STMT (e);
phi;
- phi = TREE_CHAIN (phi), arg = TREE_CHAIN (arg))
+ phi = PHI_CHAIN (phi), arg = TREE_CHAIN (arg))
{
tree def = TREE_VALUE (arg);
add_phi_arg (&phi, def, e);
/* 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);
+ unsigned i, phi_num_args = PHI_NUM_ARGS (phi);
edge_iterator ei;
+ if (EDGE_COUNT (bb->preds) != phi_num_args)
+ {
+ error ("Incoming edge count does not match number of PHI arguments\n");
+ err = true;
+ goto error;
+ }
+
/* Mark all the incoming edges. */
FOR_EACH_EDGE (e, ei, bb->preds)
e->aux = (void *) 1;
{
tree op = PHI_ARG_DEF (phi, i);
+ if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op))
+ {
+ error ("PHI argument is not SSA_NAME, or invariant");
+ err = true;
+ }
+
e = PHI_ARG_EDGE (phi, i);
if (TREE_CODE (op) == SSA_NAME)
if (e->aux == (void *) 0)
{
- error ("PHI argument flowing through dead edge %d->%d\n",
+ error ("PHI argument flowing through dead or duplicated edge %d->%d\n",
e->src->index, e->dest->index);
err = true;
}
- if (e->aux == (void *) 2)
- {
- error ("PHI argument duplicated for edge %d->%d\n", e->src->index,
- e->dest->index);
- err = true;
- }
-
if (err)
{
fprintf (stderr, "PHI argument\n");
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;
}
/* 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)
- {
- 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)
+ stmt = SSA_NAME_DEF_STMT (name);
+ if (!IS_EMPTY_STMT (stmt))
{
- 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. */
{
tree stmt = bsi_stmt (bsi);
- FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_KILLS)
- {
- if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
- op, stmt, false, true,
- names_defined_in_bb))
- goto err;
- }
+ get_stmt_operands (stmt);
- FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
+ 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");
+ print_generic_stmt (stderr, stmt, TDF_VOPS);
+ goto err;
+ }
+
+ FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_USES | SSA_OP_ALL_KILLS)
{
if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
- op, stmt, false, false,
+ op, stmt, false, !is_gimple_reg (op),
names_defined_in_bb))
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))
- {
- bool virtual = !is_gimple_reg (PHI_RESULT (phi));
- op = PHI_ARG_DEF_FROM_EDGE (phi, e);
- if (TREE_CODE (op) != SSA_NAME)
- continue;
-
- if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
- op, phi, false, virtual,
- names_defined_in_bb))
- goto err;
- }
- }
-
bitmap_clear (names_defined_in_bb);
}
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;
so strip conversions that just switch between them. */
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),
TREE_TYPE (outer_type)))
return true;
return false;
}
+/* Returns true if statement STMT may read memory. */
+
+bool
+stmt_references_memory_p (tree stmt)
+{
+ stmt_ann_t ann;
+
+ get_stmt_operands (stmt);
+ 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);
+}
/* 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);
+ pointer_set_destroy (visited);
}
}
FOR_EACH_BB (bb)
{
- for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi))
+ for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
{
var = PHI_RESULT (phi);
check_phi_redundancy (phi, eq_to);