/* Convert a program in SSA form into Normal form.
- Copyright (C) 2004-2015 Free Software Foundation, Inc.
+ Copyright (C) 2004-2019 Free Software Foundation, Inc.
Contributed by Andrew Macleod <amacleod@redhat.com>
This file is part of GCC.
#include "system.h"
#include "coretypes.h"
#include "backend.h"
-#include "cfghooks.h"
+#include "rtl.h"
#include "tree.h"
#include "gimple.h"
-#include "rtl.h"
+#include "cfghooks.h"
#include "ssa.h"
-#include "alias.h"
-#include "fold-const.h"
+#include "tree-ssa.h"
+#include "memmodel.h"
+#include "emit-rtl.h"
+#include "gimple-pretty-print.h"
+#include "diagnostic-core.h"
+#include "tree-dfa.h"
#include "stor-layout.h"
#include "cfgrtl.h"
#include "cfganal.h"
-#include "gimple-pretty-print.h"
-#include "internal-fn.h"
#include "tree-eh.h"
#include "gimple-iterator.h"
#include "tree-cfg.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"
+#include "dojump.h"
/* FIXME: A lot of code here deals with expanding to RTL. All that code
should be in cfgexpand.c. */
-#include "flags.h"
-#include "insn-config.h"
-#include "expmed.h"
-#include "dojump.h"
#include "explow.h"
-#include "calls.h"
-#include "emit-rtl.h"
-#include "varasm.h"
-#include "stmt.h"
#include "expr.h"
/* Return TRUE if expression STMT is suitable for replacement. */
bool
-ssa_is_replaceable_p (gimple stmt)
+ssa_is_replaceable_p (gimple *stmt)
{
use_operand_p use_p;
tree def;
- gimple use_stmt;
+ 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))
+ if (stmt_could_throw_p (cfun, stmt))
return false;
/* Punt if there is more than 1 def. */
rarely more than 6, and in the bootstrap of gcc, the maximum number
of nodes encountered was 12. */
-typedef struct _elim_graph {
+struct elim_graph
+{
+ elim_graph (var_map map);
+
/* Size of the elimination vectors. */
int size;
/* List of nodes in the elimination graph. */
- vec<int> nodes;
+ auto_vec<int> nodes;
/* The predecessor and successor edge list. */
- vec<int> edge_list;
+ auto_vec<int> edge_list;
/* Source locus on each edge */
- vec<source_location> edge_locus;
+ auto_vec<location_t> edge_locus;
/* Visited vector. */
- sbitmap visited;
+ auto_sbitmap visited;
/* Stack for visited nodes. */
- vec<int> stack;
+ auto_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> const_dests;
- vec<tree> const_copies;
+ auto_vec<int> const_dests;
+ auto_vec<tree> const_copies;
/* Source locations for any constant copies. */
- vec<source_location> copy_locus;
-} *elim_graph;
+ auto_vec<location_t> copy_locus;
+};
/* For an edge E find out a good source location to associate with
{
for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ gimple *stmt = gsi_stmt (gsi);
if (is_gimple_debug (stmt))
continue;
if (gimple_has_location (stmt) || gimple_block (stmt))
}
else
emit_move_insn (dest, src);
+ do_pending_stack_adjust ();
rtx_insn *seq = get_insns ();
end_sequence ();
/* Insert a copy instruction from partition SRC to DEST onto edge E. */
static void
-insert_partition_copy_on_edge (edge e, int dest, int src, source_location locus)
+insert_partition_copy_on_edge (edge e, int dest, int src, location_t locus)
{
tree var;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file,
- "Inserting a partition copy on edge BB%d->BB%d :"
+ "Inserting a partition copy on edge BB%d->BB%d : "
"PART.%d = PART.%d",
e->src->index,
e->dest->index, dest, src);
onto edge E. */
static void
-insert_value_copy_on_edge (edge e, int dest, tree src, source_location locus)
+insert_value_copy_on_edge (edge e, int dest, tree src, location_t locus)
{
rtx dest_rtx, seq, x;
machine_mode dest_mode, src_mode;
else if (src_mode == BLKmode)
{
x = dest_rtx;
- store_expr (src, x, 0, false);
+ store_expr (src, x, 0, false, false);
}
else
x = expand_expr (src, dest_rtx, dest_mode, EXPAND_NORMAL);
if (x != dest_rtx)
emit_move_insn (dest_rtx, x);
+ do_pending_stack_adjust ();
+
seq = get_insns ();
end_sequence ();
static void
insert_rtx_to_part_on_edge (edge e, int dest, rtx src, int unsignedsrcp,
- source_location locus)
+ location_t locus)
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
onto edge E. */
static void
-insert_part_to_rtx_on_edge (edge e, rtx dest, int src, source_location locus)
+insert_part_to_rtx_on_edge (edge e, rtx dest, int src, location_t locus)
{
tree var;
if (dump_file && (dump_flags & TDF_DETAILS))
}
-/* Create an elimination graph with SIZE nodes and associated data
- structures. */
+/* Create an elimination graph for map. */
-static elim_graph
-new_elim_graph (int size)
+elim_graph::elim_graph (var_map map) :
+ nodes (30), edge_list (20), edge_locus (10), visited (map->num_partitions),
+ stack (30), map (map), const_dests (20), const_copies (20), copy_locus (10)
{
- elim_graph g = (elim_graph) xmalloc (sizeof (struct _elim_graph));
-
- 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;
}
/* Empty elimination graph G. */
static inline void
-clear_elim_graph (elim_graph g)
+clear_elim_graph (elim_graph *g)
{
g->nodes.truncate (0);
g->edge_list.truncate (0);
}
-/* Delete elimination graph G. */
-
-static inline void
-delete_elim_graph (elim_graph g)
-{
- sbitmap_free (g->visited);
- 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);
-}
-
-
/* Return the number of nodes in graph G. */
static inline int
-elim_graph_size (elim_graph g)
+elim_graph_size (elim_graph *g)
{
return g->nodes.length ();
}
/* Add NODE to graph G, if it doesn't exist already. */
static inline void
-elim_graph_add_node (elim_graph g, int node)
+elim_graph_add_node (elim_graph *g, int node)
{
int x;
int t;
/* Add the edge PRED->SUCC to graph G. */
static inline void
-elim_graph_add_edge (elim_graph g, int pred, int succ, source_location locus)
+elim_graph_add_edge (elim_graph *g, int pred, int succ, location_t locus)
{
g->edge_list.safe_push (pred);
g->edge_list.safe_push (succ);
return the successor node. -1 is returned if there is no such edge. */
static inline int
-elim_graph_remove_succ_edge (elim_graph g, int node, source_location *locus)
+elim_graph_remove_succ_edge (elim_graph *g, int node, location_t *locus)
{
int y;
unsigned x;
/* Add T to elimination graph G. */
static inline void
-eliminate_name (elim_graph g, int T)
+eliminate_name (elim_graph *g, int T)
{
elim_graph_add_node (g, T);
}
G->e. */
static void
-eliminate_build (elim_graph g)
+eliminate_build (elim_graph *g)
{
tree Ti;
int p0, pi;
for (gsi = gsi_start_phis (g->e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
{
gphi *phi = gsi.phi ();
- source_location locus;
+ location_t locus;
p0 = var_to_partition (g->map, gimple_phi_result (phi));
/* Ignore results which are not in partitions. */
/* Push successors of T onto the elimination stack for G. */
static void
-elim_forward (elim_graph g, int T)
+elim_forward (elim_graph *g, int T)
{
int S;
- source_location locus;
+ location_t locus;
bitmap_set_bit (g->visited, T);
FOR_EACH_ELIM_GRAPH_SUCC (g, T, S, locus,
/* Return 1 if there unvisited predecessors of T in graph G. */
static int
-elim_unvisited_predecessor (elim_graph g, int T)
+elim_unvisited_predecessor (elim_graph *g, int T)
{
int P;
- source_location locus;
+ location_t locus;
FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
{
/* Process predecessors first, and insert a copy. */
static void
-elim_backward (elim_graph g, int T)
+elim_backward (elim_graph *g, int T)
{
int P;
- source_location locus;
+ location_t locus;
bitmap_set_bit (g->visited, T);
FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
tree type = TREE_TYPE (name);
int unsignedp;
machine_mode reg_mode = promote_ssa_mode (name, &unsignedp);
+ if (reg_mode == BLKmode)
+ return assign_temp (type, 0, 0);
rtx x = gen_reg_rtx (reg_mode);
if (POINTER_TYPE_P (type))
mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (type)));
region, and create a temporary to break the cycle if one is found. */
static void
-elim_create (elim_graph g, int T)
+elim_create (elim_graph *g, int T)
{
int P, S;
- source_location locus;
+ location_t locus;
if (elim_unvisited_predecessor (g, T))
{
/* Eliminate all the phi nodes on edge E in graph G. */
static void
-eliminate_phi (edge e, elim_graph g)
+eliminate_phi (edge e, elim_graph *g)
{
int x;
{
int dest;
tree src;
- source_location locus;
+ location_t locus;
src = g->const_copies.pop ();
dest = g->const_dests.pop ();
SET_USE (arg_p, NULL_TREE);
if (has_zero_uses (arg))
{
- gimple stmt;
+ gimple *stmt;
gimple_stmt_iterator gsi;
stmt = SSA_NAME_DEF_STMT (arg);
gphi *phi = gsi.phi ();
result = gimple_phi_result (phi);
if (virtual_operand_p (result))
- {
-#ifdef ENABLE_CHECKING
- size_t i;
- /* There should be no arguments which are not virtual, or the
- results will be incorrect. */
- for (i = 0; i < gimple_phi_num_args (phi); i++)
- {
- tree arg = PHI_ARG_DEF (phi, i);
- 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);
- fprintf (stderr, "), but the result is :");
- print_gimple_stmt (stderr, phi, 0, TDF_SLIM);
- internal_error ("SSA corruption");
- }
- }
-#endif
- remove_phi_node (&gsi, true);
- }
+ remove_phi_node (&gsi, true);
else
{
/* Also remove real PHIs with no uses. */
variable. */
static void
-rewrite_trees (var_map map ATTRIBUTE_UNUSED)
+rewrite_trees (var_map map)
{
-#ifdef ENABLE_CHECKING
+ if (!flag_checking)
+ return;
+
basic_block bb;
/* Search for PHIs where the destination has no partition, but one
or more arguments has a partition. This should not happen and can
}
}
}
-#endif
+}
+
+/* Create a default def for VAR. */
+
+static void
+create_default_def (tree var, void *arg ATTRIBUTE_UNUSED)
+{
+ if (!is_gimple_reg (var))
+ return;
+
+ tree ssa = get_or_create_ssa_default_def (cfun, var);
+ gcc_assert (ssa);
+}
+
+/* Call CALLBACK for all PARM_DECLs and RESULT_DECLs for which
+ assign_parms may ask for a default partition. */
+
+static void
+for_all_parms (void (*callback)(tree var, void *arg), void *arg)
+{
+ for (tree var = DECL_ARGUMENTS (current_function_decl); var;
+ var = DECL_CHAIN (var))
+ callback (var, arg);
+ if (!VOID_TYPE_P (TREE_TYPE (DECL_RESULT (current_function_decl))))
+ callback (DECL_RESULT (current_function_decl), arg);
+ if (cfun->static_chain_decl)
+ callback (cfun->static_chain_decl, arg);
+}
+
+/* We need to pass two arguments to set_parm_default_def_partition,
+ but for_all_parms only supports one. Use a pair. */
+
+typedef std::pair<var_map, bitmap> parm_default_def_partition_arg;
+
+/* Set in ARG's PARTS bitmap the bit corresponding to the partition in
+ ARG's MAP containing VAR's default def. */
+
+static void
+set_parm_default_def_partition (tree var, void *arg_)
+{
+ parm_default_def_partition_arg *arg = (parm_default_def_partition_arg *)arg_;
+ var_map map = arg->first;
+ bitmap parts = arg->second;
+
+ if (!is_gimple_reg (var))
+ return;
+
+ tree ssa = ssa_default_def (cfun, var);
+ gcc_assert (ssa);
+
+ int version = var_to_partition (map, ssa);
+ gcc_assert (version != NO_PARTITION);
+
+ bool changed = bitmap_set_bit (parts, version);
+ gcc_assert (changed);
+}
+
+/* Allocate and return a bitmap that has a bit set for each partition
+ that contains a default def for a parameter. */
+
+static bitmap
+get_parm_default_def_partitions (var_map map)
+{
+ bitmap parm_default_def_parts = BITMAP_ALLOC (NULL);
+
+ parm_default_def_partition_arg
+ arg = std::make_pair (map, parm_default_def_parts);
+
+ for_all_parms (set_parm_default_def_partition, &arg);
+
+ return parm_default_def_parts;
+}
+
+/* Allocate and return a bitmap that has a bit set for each partition
+ that contains an undefined value. */
+
+static bitmap
+get_undefined_value_partitions (var_map map)
+{
+ bitmap undefined_value_parts = BITMAP_ALLOC (NULL);
+
+ for (unsigned int i = 1; i < num_ssa_names; i++)
+ {
+ tree var = ssa_name (i);
+ if (var
+ && !virtual_operand_p (var)
+ && !has_zero_uses (var)
+ && ssa_undefined_value_p (var))
+ {
+ const int p = var_to_partition (map, var);
+ if (p != NO_PARTITION)
+ bitmap_set_bit (undefined_value_parts, p);
+ }
+ }
+
+ return undefined_value_parts;
}
/* Given the out-of-ssa info object SA (with prepared partitions)
expand_phi_nodes (struct ssaexpand *sa)
{
basic_block bb;
- elim_graph g = new_elim_graph (sa->map->num_partitions);
- g->map = sa->map;
+ elim_graph g (sa->map);
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb,
EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
edge e;
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->preds)
- eliminate_phi (e, g);
+ eliminate_phi (e, &g);
set_phi_nodes (bb, NULL);
/* We can't redirect EH edges in RTL land, so we need to do this
here. Redirection happens only when splitting is necessary,
ei_next (&ei);
}
}
-
- delete_elim_graph (g);
}
{
bitmap values = NULL;
var_map map;
- unsigned i;
- map = coalesce_ssa_name ();
+ for_all_parms (create_default_def, NULL);
+ map = init_var_map (num_ssa_names);
+ coalesce_ssa_name (map);
/* Return to viewing the variable list as just all reference variables after
coalescing has been performed. */
sa->map = map;
sa->values = values;
- sa->partition_has_default_def = BITMAP_ALLOC (NULL);
- for (i = 1; i < num_ssa_names; i++)
- {
- tree t = ssa_name (i);
- if (t && SSA_NAME_IS_DEFAULT_DEF (t))
- {
- int p = var_to_partition (map, t);
- if (p != NO_PARTITION)
- bitmap_set_bit (sa->partition_has_default_def, p);
- }
- }
+ sa->partitions_for_parm_default_defs = get_parm_default_def_partitions (map);
+ sa->partitions_for_undefined_values = get_undefined_value_partitions (map);
}
bb->aux = NULL;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ gimple *stmt = gsi_stmt (gsi);
gimple_set_uid (stmt, i);
i++;
}
{
use_operand_p use;
imm_use_iterator imm_iter;
- gimple defa = SSA_NAME_DEF_STMT (arg);
+ gimple *defa = SSA_NAME_DEF_STMT (arg);
/* If ARG isn't defined in the same block it's too complicated for
our little mind. */
FOR_EACH_IMM_USE_FAST (use, imm_iter, result)
{
- gimple use_stmt = USE_STMT (use);
+ 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,
{
tree arg = gimple_phi_arg_def (phi, i);
edge e = gimple_phi_arg_edge (phi, i);
+ /* We are only interested in copies emitted on critical
+ backedges. */
+ if (!(e->flags & EDGE_DFS_BACK)
+ || !EDGE_CRITICAL_P (e))
+ continue;
/* 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
- needed. */
- if ((e->flags & EDGE_DFS_BACK)
- && (TREE_CODE (arg) != SSA_NAME
- || SSA_NAME_VAR (arg) != SSA_NAME_VAR (result)
- || trivially_conflicts_p (bb, result, arg)))
+ constant initialization. If the argument is an SSA_NAME then
+ a copy statement may be needed. First handle the case
+ where we cannot insert before the argument definition. */
+ if (TREE_CODE (arg) != SSA_NAME
+ || (gimple_code (SSA_NAME_DEF_STMT (arg)) == GIMPLE_PHI
+ && trivially_conflicts_p (bb, result, arg)))
{
tree name;
gassign *stmt;
- gimple last = NULL;
+ gimple *last = NULL;
gimple_stmt_iterator gsi2;
gsi2 = gsi_last_bb (gimple_phi_arg_edge (phi, i)->src);
gsi_insert_after (&gsi2, stmt, GSI_NEW_STMT);
SET_PHI_ARG_DEF (phi, i, name);
}
+ /* Insert a copy before the definition of the backedge value
+ and adjust all conflicting uses. */
+ else if (trivially_conflicts_p (bb, result, arg))
+ {
+ gimple *def = SSA_NAME_DEF_STMT (arg);
+ if (gimple_nop_p (def)
+ || gimple_code (def) == GIMPLE_PHI)
+ continue;
+ tree name = copy_ssa_name (result);
+ gimple *stmt = gimple_build_assign (name, result);
+ imm_use_iterator imm_iter;
+ gimple *use_stmt;
+ /* The following matches trivially_conflicts_p. */
+ FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, result)
+ {
+ if (gimple_bb (use_stmt) != bb
+ || (gimple_code (use_stmt) != GIMPLE_PHI
+ && (maybe_renumber_stmts_bb (bb), true)
+ && gimple_uid (use_stmt) > gimple_uid (def)))
+ {
+ use_operand_p use;
+ FOR_EACH_IMM_USE_ON_STMT (use, imm_iter)
+ SET_USE (use, name);
+ }
+ }
+ gimple_stmt_iterator gsi = gsi_for_stmt (def);
+ gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
+ }
}
}
if (sa->values)
BITMAP_FREE (sa->values);
delete_var_map (sa->map);
- BITMAP_FREE (sa->partition_has_default_def);
+ BITMAP_FREE (sa->partitions_for_parm_default_defs);
+ BITMAP_FREE (sa->partitions_for_undefined_values);
memset (sa, 0, sizeof *sa);
}
projects / thirdparty / gcc.git / blobdiff