/* Convert a program in SSA form into Normal form.
- Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2004-2014 Free Software Foundation, Inc.
Contributed by Andrew Macleod <amacleod@redhat.com>
This file is part of GCC.
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
-#include "ggc.h"
+#include "stor-layout.h"
+#include "predict.h"
+#include "vec.h"
+#include "hashtab.h"
+#include "hash-set.h"
+#include "machmode.h"
+#include "hard-reg-set.h"
+#include "input.h"
+#include "function.h"
+#include "dominance.h"
+#include "cfg.h"
+#include "cfgrtl.h"
+#include "cfganal.h"
#include "basic-block.h"
-#include "diagnostic.h"
+#include "gimple-pretty-print.h"
#include "bitmap.h"
-#include "tree-flow.h"
-#include "timevar.h"
-#include "tree-dump.h"
-#include "tree-pass.h"
-#include "toplev.h"
+#include "sbitmap.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "tree-eh.h"
+#include "gimple-expr.h"
+#include "is-a.h"
+#include "gimple.h"
+#include "gimple-iterator.h"
+#include "gimple-ssa.h"
+#include "tree-cfg.h"
+#include "tree-phinodes.h"
+#include "ssa-iterators.h"
+#include "stringpool.h"
+#include "tree-ssanames.h"
+#include "dumpfile.h"
+#include "diagnostic-core.h"
+#include "tree-ssa-live.h"
+#include "tree-ssa-ter.h"
+#include "tree-ssa-coalesce.h"
+#include "tree-outof-ssa.h"
+
+/* FIXME: A lot of code here deals with expanding to RTL. All that code
+ should be in cfgexpand.c. */
#include "expr.h"
-#include "ssaexpand.h"
+/* Return TRUE if expression STMT is suitable for replacement. */
+
+bool
+ssa_is_replaceable_p (gimple stmt)
+{
+ use_operand_p use_p;
+ tree def;
+ gimple use_stmt;
+
+ /* Only consider modify stmts. */
+ if (!is_gimple_assign (stmt))
+ return false;
+
+ /* If the statement may throw an exception, it cannot be replaced. */
+ if (stmt_could_throw_p (stmt))
+ return false;
+
+ /* Punt if there is more than 1 def. */
+ def = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_DEF);
+ if (!def)
+ return false;
+
+ /* Only consider definitions which have a single use. */
+ if (!single_imm_use (def, &use_p, &use_stmt))
+ return false;
+
+ /* Used in this block, but at the TOP of the block, not the end. */
+ if (gimple_code (use_stmt) == GIMPLE_PHI)
+ return false;
+
+ /* There must be no VDEFs. */
+ if (gimple_vdef (stmt))
+ return false;
+
+ /* Float expressions must go through memory if float-store is on. */
+ if (flag_float_store
+ && FLOAT_TYPE_P (gimple_expr_type (stmt)))
+ return false;
+
+ /* An assignment with a register variable on the RHS is not
+ replaceable. */
+ if (gimple_assign_rhs_code (stmt) == VAR_DECL
+ && DECL_HARD_REGISTER (gimple_assign_rhs1 (stmt)))
+ return false;
+
+ /* No function calls can be replaced. */
+ if (is_gimple_call (stmt))
+ return false;
+
+ /* Leave any stmt with volatile operands alone as well. */
+ if (gimple_has_volatile_ops (stmt))
+ return false;
+
+ return true;
+}
-DEF_VEC_I(source_location);
-DEF_VEC_ALLOC_I(source_location,heap);
/* Used to hold all the components required to do SSA PHI elimination.
The node and pred/succ list is a simple linear list of nodes and
edges represented as pairs of nodes.
The predecessor and successor list: Nodes are entered in pairs, where
- [0] ->PRED, [1]->SUCC. All the even indexes in the array represent
- predecessors, all the odd elements are successors.
-
+ [0] ->PRED, [1]->SUCC. All the even indexes in the array represent
+ predecessors, all the odd elements are successors.
+
Rationale:
- When implemented as bitmaps, very large programs SSA->Normal times were
+ When implemented as bitmaps, very large programs SSA->Normal times were
being dominated by clearing the interference graph.
- Typically this list of edges is extremely small since it only includes
- PHI results and uses from a single edge which have not coalesced with
+ Typically this list of edges is extremely small since it only includes
+ PHI results and uses from a single edge which have not coalesced with
each other. This means that no virtual PHI nodes are included, and
empirical evidence suggests that the number of edges rarely exceed
3, and in a bootstrap of GCC, the maximum size encountered was 7.
This also limits the number of possible nodes that are involved to
rarely more than 6, and in the bootstrap of gcc, the maximum number
of nodes encountered was 12. */
-
+
typedef struct _elim_graph {
/* Size of the elimination vectors. */
int size;
/* List of nodes in the elimination graph. */
- VEC(int,heap) *nodes;
+ vec<int> nodes;
/* The predecessor and successor edge list. */
- VEC(int,heap) *edge_list;
+ vec<int> edge_list;
/* Source locus on each edge */
- VEC(source_location,heap) *edge_locus;
+ vec<source_location> edge_locus;
/* Visited vector. */
sbitmap visited;
/* Stack for visited nodes. */
- VEC(int,heap) *stack;
-
+ vec<int> stack;
+
/* The variable partition map. */
var_map map;
edge e;
/* List of constant copies to emit. These are pushed on in pairs. */
- VEC(int,heap) *const_dests;
- VEC(tree,heap) *const_copies;
+ vec<int> const_dests;
+ vec<tree> const_copies;
/* Source locations for any constant copies. */
- VEC(source_location,heap) *copy_locus;
+ vec<source_location> copy_locus;
} *elim_graph;
{
if (e->goto_locus)
{
- set_curr_insn_source_location (e->goto_locus);
- set_curr_insn_block (e->goto_block);
+ set_curr_insn_location (e->goto_locus);
}
else
{
for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
{
gimple stmt = gsi_stmt (gsi);
+ if (is_gimple_debug (stmt))
+ continue;
if (gimple_has_location (stmt) || gimple_block (stmt))
{
- set_curr_insn_source_location (gimple_location (stmt));
- set_curr_insn_block (gimple_block (stmt));
+ set_curr_insn_location (gimple_location (stmt));
return;
}
}
}
}
-/* Emit insns to copy SRC into DEST converting SRC if necessary. */
+/* Emit insns to copy SRC into DEST converting SRC if necessary. As
+ SRC/DEST might be BLKmode memory locations SIZEEXP is a tree from
+ which we deduce the size to copy in that case. */
static inline rtx
-emit_partition_copy (rtx dest, rtx src, int unsignedsrcp)
+emit_partition_copy (rtx dest, rtx src, int unsignedsrcp, tree sizeexp)
{
rtx seq;
if (GET_MODE (src) != VOIDmode && GET_MODE (src) != GET_MODE (dest))
src = convert_to_mode (GET_MODE (dest), src, unsignedsrcp);
- emit_move_insn (dest, src);
+ if (GET_MODE (src) == BLKmode)
+ {
+ gcc_assert (GET_MODE (dest) == BLKmode);
+ emit_block_move (dest, src, expr_size (sizeexp), BLOCK_OP_NORMAL);
+ }
+ else
+ emit_move_insn (dest, src);
seq = get_insns ();
end_sequence ();
static void
insert_partition_copy_on_edge (edge e, int dest, int src, source_location locus)
{
+ tree var;
rtx seq;
if (dump_file && (dump_flags & TDF_DETAILS))
{
set_location_for_edge (e);
/* If a locus is provided, override the default. */
if (locus)
- set_curr_insn_source_location (locus);
+ set_curr_insn_location (locus);
- seq = emit_partition_copy (SA.partition_to_pseudo[dest],
- SA.partition_to_pseudo[src],
- TYPE_UNSIGNED (TREE_TYPE (
- partition_to_var (SA.map, src))));
+ var = partition_to_var (SA.map, src);
+ seq = emit_partition_copy (copy_rtx (SA.partition_to_pseudo[dest]),
+ copy_rtx (SA.partition_to_pseudo[src]),
+ TYPE_UNSIGNED (TREE_TYPE (var)),
+ var);
insert_insn_on_edge (seq, e);
}
static void
insert_value_copy_on_edge (edge e, int dest, tree src, source_location locus)
{
- rtx seq, x;
- enum machine_mode mode;
+ rtx dest_rtx, seq, x;
+ machine_mode dest_mode, src_mode;
+ int unsignedp;
+ tree var;
+
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file,
fprintf (dump_file, "\n");
}
- gcc_assert (SA.partition_to_pseudo[dest]);
+ dest_rtx = copy_rtx (SA.partition_to_pseudo[dest]);
+ gcc_assert (dest_rtx);
set_location_for_edge (e);
/* If a locus is provided, override the default. */
if (locus)
- set_curr_insn_source_location (locus);
+ set_curr_insn_location (locus);
start_sequence ();
- mode = GET_MODE (SA.partition_to_pseudo[dest]);
- x = expand_expr (src, SA.partition_to_pseudo[dest], mode, EXPAND_NORMAL);
- if (GET_MODE (x) != VOIDmode && GET_MODE (x) != mode)
- x = convert_to_mode (mode, x, TYPE_UNSIGNED (TREE_TYPE (src)));
- if (CONSTANT_P (x) && GET_MODE (x) == VOIDmode
- && mode != TYPE_MODE (TREE_TYPE (src)))
- x = convert_modes (mode, TYPE_MODE (TREE_TYPE (src)),
- x, TYPE_UNSIGNED (TREE_TYPE (src)));
- if (x != SA.partition_to_pseudo[dest])
- emit_move_insn (SA.partition_to_pseudo[dest], x);
+
+ var = SSA_NAME_VAR (partition_to_var (SA.map, dest));
+ src_mode = TYPE_MODE (TREE_TYPE (src));
+ dest_mode = GET_MODE (dest_rtx);
+ gcc_assert (src_mode == TYPE_MODE (TREE_TYPE (var)));
+ gcc_assert (!REG_P (dest_rtx)
+ || dest_mode == promote_decl_mode (var, &unsignedp));
+
+ if (src_mode != dest_mode)
+ {
+ x = expand_expr (src, NULL, src_mode, EXPAND_NORMAL);
+ x = convert_modes (dest_mode, src_mode, x, unsignedp);
+ }
+ else if (src_mode == BLKmode)
+ {
+ x = dest_rtx;
+ store_expr (src, x, 0, false);
+ }
+ else
+ x = expand_expr (src, dest_rtx, dest_mode, EXPAND_NORMAL);
+
+ if (x != dest_rtx)
+ emit_move_insn (dest_rtx, x);
seq = get_insns ();
end_sequence ();
set_location_for_edge (e);
/* If a locus is provided, override the default. */
if (locus)
- set_curr_insn_source_location (locus);
+ set_curr_insn_location (locus);
- seq = emit_partition_copy (SA.partition_to_pseudo[dest],
- src,
- unsignedsrcp);
+ /* We give the destination as sizeexp in case src/dest are BLKmode
+ mems. Usually we give the source. As we result from SSA names
+ the left and right size should be the same (and no WITH_SIZE_EXPR
+ involved), so it doesn't matter. */
+ seq = emit_partition_copy (copy_rtx (SA.partition_to_pseudo[dest]),
+ src, unsignedsrcp,
+ partition_to_var (SA.map, dest));
insert_insn_on_edge (seq, e);
}
static void
insert_part_to_rtx_on_edge (edge e, rtx dest, int src, source_location locus)
{
+ tree var;
rtx seq;
if (dump_file && (dump_flags & TDF_DETAILS))
{
set_location_for_edge (e);
/* If a locus is provided, override the default. */
if (locus)
- set_curr_insn_source_location (locus);
+ set_curr_insn_location (locus);
+ var = partition_to_var (SA.map, src);
seq = emit_partition_copy (dest,
- SA.partition_to_pseudo[src],
- TYPE_UNSIGNED (TREE_TYPE (
- partition_to_var (SA.map, src))));
+ copy_rtx (SA.partition_to_pseudo[src]),
+ TYPE_UNSIGNED (TREE_TYPE (var)),
+ var);
insert_insn_on_edge (seq, e);
}
{
elim_graph g = (elim_graph) xmalloc (sizeof (struct _elim_graph));
- g->nodes = VEC_alloc (int, heap, 30);
- g->const_dests = VEC_alloc (int, heap, 20);
- g->const_copies = VEC_alloc (tree, heap, 20);
- g->copy_locus = VEC_alloc (source_location, heap, 10);
- g->edge_list = VEC_alloc (int, heap, 20);
- g->edge_locus = VEC_alloc (source_location, heap, 10);
- g->stack = VEC_alloc (int, heap, 30);
-
+ g->nodes.create (30);
+ g->const_dests.create (20);
+ g->const_copies.create (20);
+ g->copy_locus.create (10);
+ g->edge_list.create (20);
+ g->edge_locus.create (10);
+ g->stack.create (30);
+
g->visited = sbitmap_alloc (size);
return g;
static inline void
clear_elim_graph (elim_graph g)
{
- VEC_truncate (int, g->nodes, 0);
- VEC_truncate (int, g->edge_list, 0);
- VEC_truncate (source_location, g->edge_locus, 0);
+ g->nodes.truncate (0);
+ g->edge_list.truncate (0);
+ g->edge_locus.truncate (0);
}
delete_elim_graph (elim_graph g)
{
sbitmap_free (g->visited);
- VEC_free (int, heap, g->stack);
- VEC_free (int, heap, g->edge_list);
- VEC_free (tree, heap, g->const_copies);
- VEC_free (int, heap, g->const_dests);
- VEC_free (int, heap, g->nodes);
- VEC_free (source_location, heap, g->copy_locus);
- VEC_free (source_location, heap, g->edge_locus);
+ g->stack.release ();
+ g->edge_list.release ();
+ g->const_copies.release ();
+ g->const_dests.release ();
+ g->nodes.release ();
+ g->copy_locus.release ();
+ g->edge_locus.release ();
free (g);
}
static inline int
elim_graph_size (elim_graph g)
{
- return VEC_length (int, g->nodes);
+ return g->nodes.length ();
}
/* Add NODE to graph G, if it doesn't exist already. */
-static inline void
+static inline void
elim_graph_add_node (elim_graph g, int node)
{
int x;
int t;
- for (x = 0; VEC_iterate (int, g->nodes, x, t); x++)
+ FOR_EACH_VEC_ELT (g->nodes, x, t)
if (t == node)
return;
- VEC_safe_push (int, heap, g->nodes, node);
+ g->nodes.safe_push (node);
}
static inline void
elim_graph_add_edge (elim_graph g, int pred, int succ, source_location locus)
{
- VEC_safe_push (int, heap, g->edge_list, pred);
- VEC_safe_push (int, heap, g->edge_list, succ);
- VEC_safe_push (source_location, heap, g->edge_locus, locus);
+ g->edge_list.safe_push (pred);
+ g->edge_list.safe_push (succ);
+ g->edge_locus.safe_push (locus);
}
{
int y;
unsigned x;
- for (x = 0; x < VEC_length (int, g->edge_list); x += 2)
- if (VEC_index (int, g->edge_list, x) == node)
+ for (x = 0; x < g->edge_list.length (); x += 2)
+ if (g->edge_list[x] == node)
{
- VEC_replace (int, g->edge_list, x, -1);
- y = VEC_index (int, g->edge_list, x + 1);
- VEC_replace (int, g->edge_list, x + 1, -1);
- *locus = VEC_index (source_location, g->edge_locus, x / 2);
- VEC_replace (source_location, g->edge_locus, x / 2, UNKNOWN_LOCATION);
+ g->edge_list[x] = -1;
+ y = g->edge_list[x + 1];
+ g->edge_list[x + 1] = -1;
+ *locus = g->edge_locus[x / 2];
+ g->edge_locus[x / 2] = UNKNOWN_LOCATION;
return y;
}
*locus = UNKNOWN_LOCATION;
do { \
unsigned x_; \
int y_; \
- for (x_ = 0; x_ < VEC_length (int, (GRAPH)->edge_list); x_ += 2) \
+ for (x_ = 0; x_ < (GRAPH)->edge_list.length (); x_ += 2) \
{ \
- y_ = VEC_index (int, (GRAPH)->edge_list, x_); \
+ y_ = (GRAPH)->edge_list[x_]; \
if (y_ != (NODE)) \
continue; \
- (VAR) = VEC_index (int, (GRAPH)->edge_list, x_ + 1); \
- (LOCUS) = VEC_index (source_location, (GRAPH)->edge_locus, x_ / 2); \
+ (void) ((VAR) = (GRAPH)->edge_list[x_ + 1]); \
+ (void) ((LOCUS) = (GRAPH)->edge_locus[x_ / 2]); \
CODE; \
} \
} while (0)
do { \
unsigned x_; \
int y_; \
- for (x_ = 0; x_ < VEC_length (int, (GRAPH)->edge_list); x_ += 2) \
+ for (x_ = 0; x_ < (GRAPH)->edge_list.length (); x_ += 2) \
{ \
- y_ = VEC_index (int, (GRAPH)->edge_list, x_ + 1); \
+ y_ = (GRAPH)->edge_list[x_ + 1]; \
if (y_ != (NODE)) \
continue; \
- (VAR) = VEC_index (int, (GRAPH)->edge_list, x_); \
- (LOCUS) = VEC_index (source_location, (GRAPH)->edge_locus, x_ / 2); \
+ (void) ((VAR) = (GRAPH)->edge_list[x_]); \
+ (void) ((LOCUS) = (GRAPH)->edge_locus[x_ / 2]); \
CODE; \
} \
} while (0)
elim_graph_add_node (g, T);
}
+/* Return true if this phi argument T should have a copy queued when using
+ var_map MAP. PHI nodes should contain only ssa_names and invariants. A
+ test for ssa_name is definitely simpler, but don't let invalid contents
+ slip through in the meantime. */
+
+static inline bool
+queue_phi_copy_p (var_map map, tree t)
+{
+ if (TREE_CODE (t) == SSA_NAME)
+ {
+ if (var_to_partition (map, t) == NO_PARTITION)
+ return true;
+ return false;
+ }
+ gcc_checking_assert (is_gimple_min_invariant (t));
+ return true;
+}
/* Build elimination graph G for basic block BB on incoming PHI edge
G->e. */
gimple_stmt_iterator gsi;
clear_elim_graph (g);
-
+
for (gsi = gsi_start_phis (g->e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple phi = gsi_stmt (gsi);
/* If this argument is a constant, or a SSA_NAME which is being
left in SSA form, just queue a copy to be emitted on this
edge. */
- if (!phi_ssa_name_p (Ti)
- || (TREE_CODE (Ti) == SSA_NAME
- && var_to_partition (g->map, Ti) == NO_PARTITION))
+ if (queue_phi_copy_p (g->map, Ti))
{
/* Save constant copies until all other copies have been emitted
on this edge. */
- VEC_safe_push (int, heap, g->const_dests, p0);
- VEC_safe_push (tree, heap, g->const_copies, Ti);
- VEC_safe_push (source_location, heap, g->copy_locus, locus);
+ g->const_dests.safe_push (p0);
+ g->const_copies.safe_push (Ti);
+ g->copy_locus.safe_push (locus);
}
else
{
/* Push successors of T onto the elimination stack for G. */
-static void
+static void
elim_forward (elim_graph g, int T)
{
int S;
source_location locus;
- SET_BIT (g->visited, T);
+ bitmap_set_bit (g->visited, T);
FOR_EACH_ELIM_GRAPH_SUCC (g, T, S, locus,
{
- if (!TEST_BIT (g->visited, S))
+ if (!bitmap_bit_p (g->visited, S))
elim_forward (g, S);
});
- VEC_safe_push (int, heap, g->stack, T);
+ g->stack.safe_push (T);
}
FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
{
- if (!TEST_BIT (g->visited, P))
+ if (!bitmap_bit_p (g->visited, P))
return 1;
});
return 0;
int P;
source_location locus;
- SET_BIT (g->visited, T);
+ bitmap_set_bit (g->visited, T);
FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
{
- if (!TEST_BIT (g->visited, P))
+ if (!bitmap_bit_p (g->visited, P))
{
elim_backward (g, P);
insert_partition_copy_on_edge (g->e, P, T, locus);
{
tree var = TREE_CODE (name) == SSA_NAME ? SSA_NAME_VAR (name) : name;
tree type = TREE_TYPE (var);
- int unsignedp = TYPE_UNSIGNED (type);
- enum machine_mode reg_mode
- = promote_mode (type, DECL_MODE (var), &unsignedp, 0);
+ int unsignedp;
+ machine_mode reg_mode = promote_decl_mode (var, &unsignedp);
rtx x = gen_reg_rtx (reg_mode);
if (POINTER_TYPE_P (type))
mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
return x;
}
-/* Insert required copies for T in graph G. Check for a strongly connected
+/* Insert required copies for T in graph G. Check for a strongly connected
region, and create a temporary to break the cycle if one is found. */
-static void
+static void
elim_create (elim_graph g, int T)
{
int P, S;
insert_part_to_rtx_on_edge (g->e, U, T, UNKNOWN_LOCATION);
FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
{
- if (!TEST_BIT (g->visited, P))
+ if (!bitmap_bit_p (g->visited, P))
{
elim_backward (g, P);
insert_rtx_to_part_on_edge (g->e, P, U, unsignedsrcp, locus);
S = elim_graph_remove_succ_edge (g, T, &locus);
if (S != -1)
{
- SET_BIT (g->visited, T);
+ bitmap_set_bit (g->visited, T);
insert_partition_copy_on_edge (g->e, T, S, locus);
}
}
{
int x;
- gcc_assert (VEC_length (tree, g->const_copies) == 0);
- gcc_assert (VEC_length (source_location, g->copy_locus) == 0);
+ gcc_assert (g->const_copies.length () == 0);
+ gcc_assert (g->copy_locus.length () == 0);
/* Abnormal edges already have everything coalesced. */
if (e->flags & EDGE_ABNORMAL)
{
int part;
- sbitmap_zero (g->visited);
- VEC_truncate (int, g->stack, 0);
+ bitmap_clear (g->visited);
+ g->stack.truncate (0);
- for (x = 0; VEC_iterate (int, g->nodes, x, part); x++)
+ FOR_EACH_VEC_ELT (g->nodes, x, part)
{
- if (!TEST_BIT (g->visited, part))
+ if (!bitmap_bit_p (g->visited, part))
elim_forward (g, part);
}
-
- sbitmap_zero (g->visited);
- while (VEC_length (int, g->stack) > 0)
+
+ bitmap_clear (g->visited);
+ while (g->stack.length () > 0)
{
- x = VEC_pop (int, g->stack);
- if (!TEST_BIT (g->visited, x))
+ x = g->stack.pop ();
+ if (!bitmap_bit_p (g->visited, x))
elim_create (g, x);
}
}
/* If there are any pending constant copies, issue them now. */
- while (VEC_length (tree, g->const_copies) > 0)
+ while (g->const_copies.length () > 0)
{
int dest;
tree src;
source_location locus;
- src = VEC_pop (tree, g->const_copies);
- dest = VEC_pop (int, g->const_dests);
- locus = VEC_pop (source_location, g->copy_locus);
+ src = g->const_copies.pop ();
+ dest = g->const_dests.pop ();
+ locus = g->copy_locus.pop ();
insert_value_copy_on_edge (e, dest, src, locus);
}
}
-/* Remove each argument from PHI. If an arg was the last use of an SSA_NAME,
+/* Remove each argument from PHI. If an arg was the last use of an SSA_NAME,
check to see if this allows another PHI node to be removed. */
static void
gimple_stmt_iterator gsi;
tree result;
- FOR_EACH_BB (bb)
+ FOR_EACH_BB_FN (bb, cfun)
{
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
{
gimple phi = gsi_stmt (gsi);
result = gimple_phi_result (phi);
- if (!is_gimple_reg (SSA_NAME_VAR (result)))
+ if (virtual_operand_p (result))
{
#ifdef ENABLE_CHECKING
size_t i;
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
tree arg = PHI_ARG_DEF (phi, i);
- if (TREE_CODE (arg) == SSA_NAME
- && is_gimple_reg (SSA_NAME_VAR (arg)))
+ if (TREE_CODE (arg) == SSA_NAME
+ && !virtual_operand_p (arg))
{
fprintf (stderr, "Argument of PHI is not virtual (");
print_generic_expr (stderr, arg, TDF_SLIM);
/* This function will rewrite the current program using the variable mapping
- found in MAP. If the replacement vector VALUES is provided, any
- occurrences of partitions with non-null entries in the vector will be
- replaced with the expression in the vector instead of its mapped
+ found in MAP. If the replacement vector VALUES is provided, any
+ occurrences of partitions with non-null entries in the vector will be
+ replaced with the expression in the vector instead of its mapped
variable. */
static void
/* Search for PHIs where the destination has no partition, but one
or more arguments has a partition. This should not happen and can
create incorrect code. */
- FOR_EACH_BB (bb)
+ FOR_EACH_BB_FN (bb, cfun)
{
gimple_stmt_iterator gsi;
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
elim_graph g = new_elim_graph (sa->map->num_partitions);
g->map = sa->map;
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb, EXIT_BLOCK_PTR, next_bb)
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb,
+ EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
if (!gimple_seq_empty_p (phi_nodes (bb)))
{
edge e;
if (e->insns.r && (e->flags & EDGE_EH)
&& !single_pred_p (e->dest))
{
- rtx insns = e->insns.r;
+ rtx_insn *insns = e->insns.r;
basic_block bb;
- e->insns.r = NULL_RTX;
+ e->insns.r = NULL;
bb = split_edge (e);
single_pred_edge (bb)->insns.r = insns;
}
{
unsigned i = 0;
gimple_stmt_iterator gsi;
-
+
if (!bb->aux)
return;
bb->aux = NULL;
FOR_EACH_IMM_USE_FAST (use, imm_iter, result)
{
gimple use_stmt = USE_STMT (use);
+ if (is_gimple_debug (use_stmt))
+ continue;
/* Now, if there's a use of RESULT that lies outside this basic block,
then there surely is a conflict with ARG. */
if (gimple_bb (use_stmt) != bb)
if (gimple_uid (defa) < gimple_uid (use_stmt))
return true;
}
-
+
return false;
}
basic_block bb;
gimple_stmt_iterator gsi;
- FOR_EACH_BB (bb)
+ mark_dfs_back_edges ();
+
+ FOR_EACH_BB_FN (bb, cfun)
{
/* Mark block as possibly needing calculation of UIDs. */
bb->aux = &bb->aux;
{
gimple phi = gsi_stmt (gsi);
tree result = gimple_phi_result (phi);
- tree result_var;
size_t i;
- if (!is_gimple_reg (result))
+ if (virtual_operand_p (result))
continue;
- result_var = SSA_NAME_VAR (result);
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
tree arg = gimple_phi_arg_def (phi, i);
edge e = gimple_phi_arg_edge (phi, i);
- /* If the argument is not an SSA_NAME, then we will need a
+ /* If the argument is not an SSA_NAME, then we will need a
constant initialization. If the argument is an SSA_NAME with
- a different underlying variable then a copy statement will be
+ a different underlying variable then a copy statement will be
needed. */
if ((e->flags & EDGE_DFS_BACK)
&& (TREE_CODE (arg) != SSA_NAME
- || SSA_NAME_VAR (arg) != result_var
+ || SSA_NAME_VAR (arg) != SSA_NAME_VAR (result)
|| trivially_conflicts_p (bb, result, arg)))
{
tree name;
/* In theory the only way we ought to get back to the
start of a loop should be with a COND_EXPR or GOTO_EXPR.
- However, better safe than sorry.
+ However, better safe than sorry.
If the block ends with a control statement or
something that might throw, then we have to
insert this assignment before the last
continue;
}
- /* Create a new instance of the underlying variable of the
+ /* Create a new instance of the underlying variable of the
PHI result. */
- stmt = gimple_build_assign (result_var,
+ name = copy_ssa_name (result, NULL);
+ stmt = gimple_build_assign (name,
gimple_phi_arg_def (phi, i));
- name = make_ssa_name (result_var, stmt);
- gimple_assign_set_lhs (stmt, name);
/* copy location if present. */
if (gimple_phi_arg_has_location (phi, i))
- gimple_set_location (stmt,
+ gimple_set_location (stmt,
gimple_phi_arg_location (phi, i));
/* Insert the new statement into the block and update
projects / thirdparty / gcc.git / blobdiff