+2013-11-01 Trevor Saunders <tsaunders@mozilla.com>
+
+ * function.c (reorder_blocks): Convert block_stack to a stack_vec.
+ * gimplify.c (gimplify_compound_lval): Likewise.
+ * graphite-clast-to-gimple.c (gloog): Likewise.
+ * graphite-dependences.c (loop_is_parallel_p): Likewise.
+ * graphite-scop-detection.c (scopdet_basic_block_info): Likewise.
+ (limit_scop); Likewise.
+ (build_scops): Likewise.
+ (dot_scop): Likewise.
+ * graphite-sese-to-poly.c (sese_dom_walker): Likewise.
+ (build_scop_drs): Likewise.
+ (insert_stmts): Likewise.
+ (insert_out_of_ssa_copy): Likewise.
+ (remove_phi): Likewise.
+ (rewrite_commutative_reductions_out_of_ssa_close_phi): Likewise.
+ * hw-doloop.c (discover_loop): Likewise.
+ * tree-call-cdce.c (shrink_wrap_one_built_in_call): Likewise.
+ * tree-dfa.c (dump_enumerated_decls): Likewise.
+ * tree-if-conv.c (if_convertable_loop_p): Likewise.
+ * tree-inline.c (tree_function_versioning): Likewise.
+ * tree-loop-distribution.c (build_rdg): Likewise.
+ (rdg_flag_vertex_and_dependent): Likewise.
+ (distribute_loop): Likewise.
+ * tree-parloops.c (loop_parallel_p): Likewise.
+ (eliminate_local_variables): Likewise.
+ (separate_decls_in_region): Likewise.
+ * tree-predcom.c (tree_predictive_commoning_loop): Likewise.
+ * tree-ssa-phiopt.c (cond_if_else_store_replacement): Likewise.
+ * tree-ssa-uncprop.c (uncprop_dom_walker): Likewise.
+ * tree-vect-loop.c (vect_analyze_scaler_cycles_1): Likewise.
+ * tree-vect-patterns.c (vect_pattern_recog): Likewise.
+ * tree-vect-stmts.c (vect_mark_stmts_to_be_vectorized): Likewise.
+ (vectorizable_condition): Likewise.
+
2013-11-01 Uros Bizjak <ubizjak@gmail.com>
* configure.ac (HAVE_AS_IX86_INTERUNIT_MOVQ): Always define as 0/1.
+2013-11-01 Trevor Saunders <tsaunders@mozilla.com>
+
+ * semantics.c (build_anon_member_initialization): Convert fields to be
+ a stack_vec.
+
2013-11-01 Marc Glisse <marc.glisse@inria.fr>
PR c++/58834
to build up the initializer from the outside in so that we can reuse
previously built CONSTRUCTORs if this is, say, the second field in an
anonymous struct. So we use a vec as a stack. */
- vec<tree> fields;
- fields.create (2);
+ stack_vec<tree, 2> fields;
do
{
fields.safe_push (TREE_OPERAND (member, 1));
/* Now we're at the innermost field, the one that isn't an anonymous
aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
gcc_assert (fields.is_empty());
- fields.release ();
CONSTRUCTOR_APPEND_ELT (*vec, field, init);
return true;
reorder_blocks (void)
{
tree block = DECL_INITIAL (current_function_decl);
- vec<tree> block_stack;
if (block == NULL_TREE)
return;
- block_stack.create (10);
+ stack_vec<tree, 10> block_stack;
/* Reset the TREE_ASM_WRITTEN bit for all blocks. */
clear_block_marks (block);
/* Recreate the block tree from the note nesting. */
reorder_blocks_1 (get_insns (), block, &block_stack);
BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block));
-
- block_stack.release ();
}
/* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
fallback_t fallback)
{
tree *p;
- vec<tree> expr_stack;
enum gimplify_status ret = GS_ALL_DONE, tret;
int i;
location_t loc = EXPR_LOCATION (*expr_p);
/* Create a stack of the subexpressions so later we can walk them in
order from inner to outer. */
- expr_stack.create (10);
+ stack_vec<tree, 10> expr_stack;
/* We can handle anything that get_inner_reference can deal with. */
for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
bool
gloog (scop_p scop, bb_pbb_htab_type bb_pbb_mapping)
{
- vec<tree> newivs;
- newivs.create (10);
+ stack_vec<tree, 10> newivs;
loop_p context_loop;
sese region = SCOP_REGION (scop);
ifsese if_region = NULL;
newivs_index.dispose ();
params_index.dispose ();
- newivs.release ();
cloog_clast_free (clast);
timevar_pop (TV_GRAPHITE_CODE_GEN);
{
bool dependences;
scop_p scop;
- vec<poly_bb_p> body;
- body.create (3);
timevar_push (TV_GRAPHITE_DATA_DEPS);
+ stack_vec<poly_bb_p, 3> body;
scop = get_loop_body_pbbs (loop, bb_pbb_mapping, &body);
dependences = loop_level_carries_dependences (scop, body, depth);
- body.release ();
timevar_pop (TV_GRAPHITE_DATA_DEPS);
return !dependences;
case GBB_LOOP_SING_EXIT_HEADER:
{
- vec<sd_region> regions;
- regions.create (3);
+ stack_vec<sd_region, 3> regions;
struct scopdet_info sinfo;
edge exit_e = single_exit (loop);
{
/* XXX: For now we just do not join loops with multiple exits. If the
exits lead to the same bb it may be possible to join the loop. */
- vec<sd_region> regions;
- regions.create (3);
+ stack_vec<sd_region, 3> regions;
vec<edge> exits = get_loop_exit_edges (loop);
edge e;
int i;
}
case GBB_COND_HEADER:
{
- vec<sd_region> regions;
- regions.create (3);
+ stack_vec<sd_region, 3> regions;
struct scopdet_info sinfo;
vec<basic_block> dominated;
int i;
static void
limit_scops (vec<scop_p> *scops)
{
- vec<sd_region> regions;
- regions.create (3);
+ stack_vec<sd_region, 3> regions;
int i;
scop_p scop;
create_sese_edges (regions);
build_graphite_scops (regions, scops);
- regions.release ();
}
/* Returns true when P1 and P2 are close phis with the same
build_scops (vec<scop_p> *scops)
{
struct loop *loop = current_loops->tree_root;
- vec<sd_region> regions;
- regions.create (3);
+ stack_vec<sd_region, 3> regions;
canonicalize_loop_closed_ssa_form ();
build_scops_1 (single_succ (ENTRY_BLOCK_PTR), ENTRY_BLOCK_PTR->loop_father,
DEBUG_FUNCTION void
dot_scop (scop_p scop)
{
- vec<scop_p> scops = vNULL;
+ stack_vec<scop_p, 1> scops;
if (scop)
scops.safe_push (scop);
#else
dot_all_scops_1 (stderr, scops);
#endif
-
- scops.release ();
}
#endif
{
public:
sese_dom_walker (cdi_direction, sese);
- ~sese_dom_walker ();
virtual void before_dom_children (basic_block);
virtual void after_dom_children (basic_block);
private:
- vec<gimple> m_conditions, m_cases;
+ stack_vec<gimple, 3> m_conditions, m_cases;
sese m_region;
};
sese_dom_walker::sese_dom_walker (cdi_direction direction, sese region)
: dom_walker (direction), m_region (region)
{
- m_conditions.create (3);
- m_cases.create (3);
-}
-
-sese_dom_walker::~sese_dom_walker ()
-{
- m_conditions.release ();
- m_cases.release ();
}
/* Call-back for dom_walk executed before visiting the dominated
int i, j;
poly_bb_p pbb;
data_reference_p dr;
- vec<data_reference_p> drs;
- drs.create (3);
+ stack_vec<data_reference_p, 3> drs;
/* Remove all the PBBs that do not have data references: these basic
blocks are not handled in the polyhedral representation. */
gimple_stmt_iterator insert_gsi)
{
gimple_stmt_iterator gsi;
- vec<gimple> x;
- x.create (3);
+ stack_vec<gimple, 3> x;
gimple_seq_add_stmt (&stmts, stmt);
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
gsi_insert_seq_before (&insert_gsi, stmts, GSI_SAME_STMT);
analyze_drs_in_stmts (scop, gsi_bb (insert_gsi), x);
- x.release ();
}
/* Insert the assignment "RES := EXPR" just after AFTER_STMT. */
gimple_stmt_iterator gsi;
tree var = force_gimple_operand (expr, &stmts, true, NULL_TREE);
gimple stmt = gimple_build_assign (unshare_expr (res), var);
- vec<gimple> x;
- x.create (3);
+ stack_vec<gimple, 3> x;
gimple_seq_add_stmt (&stmts, stmt);
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
}
analyze_drs_in_stmts (scop, gimple_bb (after_stmt), x);
- x.release ();
}
/* Creates a poly_bb_p for basic_block BB from the existing PBB. */
tree var = force_gimple_operand (expr, &stmts, true, NULL_TREE);
gimple stmt = gimple_build_assign (unshare_expr (res), var);
basic_block bb;
- vec<gimple> x;
- x.create (3);
+ stack_vec<gimple, 3> x;
gimple_seq_add_stmt (&stmts, stmt);
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
new_pbb_from_pbb (scop, pbb_from_bb (e->src), bb);
analyze_drs_in_stmts (scop, bb, x);
- x.release ();
}
/* Creates a zero dimension array of the same type as VAR. */
tree def;
use_operand_p use_p;
gimple_stmt_iterator gsi;
- vec<gimple> update;
- update.create (3);
+ stack_vec<gimple, 3> update;
unsigned int i;
gimple stmt;
FOR_EACH_VEC_ELT (update, i, stmt)
update_stmt (stmt);
- update.release ();
-
gsi = gsi_for_phi_node (phi);
remove_phi_node (&gsi, false);
}
gimple close_phi)
{
bool res;
- vec<gimple> in;
- in.create (10);
- vec<gimple> out;
- out.create (10);
+ stack_vec<gimple, 10> in;
+ stack_vec<gimple, 10> out;
detect_commutative_reduction (scop, close_phi, &in, &out);
res = in.length () > 1;
if (res)
translate_scalar_reduction_to_array (scop, in, out);
- in.release ();
- out.release ();
return res;
}
bool found_tail;
unsigned dwork = 0;
basic_block bb;
- vec<basic_block> works;
loop->tail = tail_bb;
loop->loop_end = tail_insn;
loop->head = BRANCH_EDGE (tail_bb)->dest;
loop->successor = FALLTHRU_EDGE (tail_bb)->dest;
- works.create (20);
+ stack_vec<basic_block, 20> works;
works.safe_push (loop->head);
found_tail = false;
}
}
}
-
- works.release ();
}
/* Analyze the structure of the loops in the current function. Use
basic_block bi_call_bb, join_tgt_bb, guard_bb, guard_bb0;
edge join_tgt_in_edge_from_call, join_tgt_in_edge_fall_thru;
edge bi_call_in_edge0, guard_bb_in_edge;
- vec<gimple> conds;
unsigned tn_cond_stmts, nconds;
unsigned ci;
gimple cond_expr = NULL;
tree bi_call_label_decl;
gimple bi_call_label;
- conds.create (12);
+ stack_vec<gimple, 12> conds;
gen_shrink_wrap_conditions (bi_call, conds, &nconds);
/* This can happen if the condition generator decides
return false and do not do any transformation for
the call. */
if (nconds == 0)
- {
- conds.release ();
- return false;
- }
+ return false;
bi_call_bb = gimple_bb (bi_call);
it could e.g. have EH edges. */
join_tgt_in_edge_from_call = find_fallthru_edge (bi_call_bb->succs);
if (join_tgt_in_edge_from_call == NULL)
- {
- conds.release ();
- return false;
- }
+ return false;
}
else
join_tgt_in_edge_from_call = split_block (bi_call_bb, bi_call);
guard_bb_in_edge->count = guard_bb->count - bi_call_in_edge->count;
}
- conds.release ();
if (dump_file && (dump_flags & TDF_DETAILS))
{
location_t loc;
{
basic_block bb;
struct walk_stmt_info wi;
- vec<numbered_tree> decl_list;
- decl_list.create (40);
+ stack_vec<numbered_tree, 40> decl_list;
memset (&wi, '\0', sizeof (wi));
wi.info = (void *) &decl_list;
last = ntp->t;
}
}
- decl_list.release ();
}
bool res = false;
vec<data_reference_p> refs;
vec<ddr_p> ddrs;
- vec<loop_p> loop_nest;
/* Handle only innermost loop. */
if (!loop || loop->inner)
refs.create (5);
ddrs.create (25);
- loop_nest.create (3);
+ stack_vec<loop_p, 3> loop_nest;
res = if_convertible_loop_p_1 (loop, &loop_nest, &refs, &ddrs);
if (flag_tree_loop_if_convert_stores)
unsigned i;
struct ipa_replace_map *replace_info;
basic_block old_entry_block, bb;
- vec<gimple> init_stmts;
- init_stmts.create (10);
+ stack_vec<gimple, 10> init_stmts;
tree vars = NULL_TREE;
gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
free_dominance_info (CDI_POST_DOMINATORS);
gcc_assert (!id.debug_stmts.exists ());
- init_stmts.release ();
pop_cfun ();
return;
}
build_rdg (vec<loop_p> loop_nest, control_dependences *cd)
{
struct graph *rdg;
- vec<gimple> stmts;
vec<data_reference_p> datarefs;
/* Create the RDG vertices from the stmts of the loop nest. */
- stmts.create (10);
+ stack_vec<gimple, 10> stmts;
stmts_from_loop (loop_nest[0], &stmts);
rdg = new_graph (stmts.length ());
datarefs.create (10);
if (!create_rdg_vertices (rdg, stmts, loop_nest[0], &datarefs))
{
- stmts.release ();
datarefs.release ();
free_rdg (rdg);
return NULL;
build_rdg_partition_for_vertex (struct graph *rdg, int v)
{
partition_t partition = partition_alloc (NULL, NULL);
- vec<int> nodes;
+ stack_vec<int, 3> nodes;
unsigned i;
int x;
- nodes.create (3);
graphds_dfs (rdg, &v, 1, &nodes, false, NULL);
FOR_EACH_VEC_ELT (nodes, i, x)
loop_containing_stmt (RDG_STMT (rdg, x))->num);
}
- nodes.release ();
return partition;
}
control_dependences *cd, int *nb_calls)
{
struct graph *rdg;
- vec<loop_p> loop_nest;
vec<partition_t> partitions;
partition_t partition;
bool any_builtin;
int num_sccs = 1;
*nb_calls = 0;
- loop_nest.create (3);
+ stack_vec<loop_p, 3> loop_nest;
if (!find_loop_nest (loop, &loop_nest))
- {
- loop_nest.release ();
- return 0;
- }
+ return 0;
rdg = build_rdg (loop_nest, cd);
if (!rdg)
"Loop %d not distributed: failed to build the RDG.\n",
loop->num);
- loop_nest.release ();
return 0;
}
partitions.release ();
free_rdg (rdg);
- loop_nest.release ();
return nbp - *nb_calls;
}
static bool
loop_parallel_p (struct loop *loop, struct obstack * parloop_obstack)
{
- vec<loop_p> loop_nest;
vec<ddr_p> dependence_relations;
vec<data_reference_p> datarefs;
lambda_trans_matrix trans;
/* Check for problems with dependences. If the loop can be reversed,
the iterations are independent. */
+ stack_vec<loop_p, 3> loop_nest;
datarefs.create (10);
- dependence_relations.create (10 * 10);
- loop_nest.create (3);
+ dependence_relations.create (100);
if (! compute_data_dependences_for_loop (loop, true, &loop_nest, &datarefs,
&dependence_relations))
{
" FAILED: data dependencies exist across iterations\n");
end:
- loop_nest.release ();
free_dependence_relations (dependence_relations);
free_data_refs (datarefs);
eliminate_local_variables (edge entry, edge exit)
{
basic_block bb;
- vec<basic_block> body;
- body.create (3);
+ stack_vec<basic_block, 3> body;
unsigned i;
gimple_stmt_iterator gsi;
bool has_debug_stmt = false;
eliminate_local_variables_stmt (entry, &gsi, decl_address);
decl_address.dispose ();
- body.release ();
}
/* Returns true if expression EXPR is not defined between ENTRY and
tree type, type_name, nvar;
gimple_stmt_iterator gsi;
struct clsn_data clsn_data;
- vec<basic_block> body;
- body.create (3);
+ stack_vec<basic_block, 3> body;
basic_block bb;
basic_block entry_bb = bb1;
basic_block exit_bb = exit->dest;
}
}
- body.release ();
-
if (name_copies.elements () == 0 && reduction_list.elements () == 0)
{
/* It may happen that there is nothing to copy (if there are only
static bool
tree_predictive_commoning_loop (struct loop *loop)
{
- vec<loop_p> loop_nest;
vec<data_reference_p> datarefs;
vec<ddr_p> dependences;
struct component *components;
/* Find the data references and split them into components according to their
dependence relations. */
- datarefs.create (10);
+ stack_vec<loop_p, 3> loop_nest;
dependences.create (10);
- loop_nest.create (3);
+ datarefs.create (10);
if (! compute_data_dependences_for_loop (loop, true, &loop_nest, &datarefs,
&dependences))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Cannot analyze data dependencies\n");
- loop_nest.release ();
free_data_refs (datarefs);
free_dependence_relations (dependences);
return false;
data_reference_p then_dr, else_dr;
int i, j;
tree then_lhs, else_lhs;
- vec<gimple> then_stores, else_stores;
basic_block blocks[3];
if (MAX_STORES_TO_SINK == 0)
}
/* Find pairs of stores with equal LHS. */
- then_stores.create (1);
- else_stores.create (1);
+ stack_vec<gimple, 1> then_stores, else_stores;
FOR_EACH_VEC_ELT (then_datarefs, i, then_dr)
{
if (DR_IS_READ (then_dr))
{
free_data_refs (then_datarefs);
free_data_refs (else_datarefs);
- then_stores.release ();
- else_stores.release ();
return false;
}
free_dependence_relations (else_ddrs);
free_data_refs (then_datarefs);
free_data_refs (else_datarefs);
- then_stores.release ();
- else_stores.release ();
return false;
}
blocks[0] = then_bb;
free_dependence_relations (else_ddrs);
free_data_refs (then_datarefs);
free_data_refs (else_datarefs);
- then_stores.release ();
- else_stores.release ();
return false;
}
}
free_dependence_relations (else_ddrs);
free_data_refs (then_datarefs);
free_data_refs (else_datarefs);
- then_stores.release ();
- else_stores.release ();
return false;
}
}
free_dependence_relations (else_ddrs);
free_data_refs (then_datarefs);
free_data_refs (else_datarefs);
- then_stores.release ();
- else_stores.release ();
return ok;
}
class uncprop_dom_walker : public dom_walker
{
public:
- uncprop_dom_walker (cdi_direction direction)
- : dom_walker (direction)
- {
- m_equiv_stack.create (2);
- }
- ~uncprop_dom_walker ()
- {
- m_equiv_stack.release ();
- }
+ uncprop_dom_walker (cdi_direction direction) : dom_walker (direction) {}
virtual void before_dom_children (basic_block);
virtual void after_dom_children (basic_block);
leading to this block. If no such edge equivalency exists, then we
record NULL. These equivalences are live until we leave the dominator
subtree rooted at the block where we record the equivalency. */
- vec<tree> m_equiv_stack;
+ stack_vec<tree, 2> m_equiv_stack;
};
/* Main driver for un-cprop. */
{
basic_block bb = loop->header;
tree init, step;
- vec<gimple> worklist;
- worklist.create (64);
+ stack_vec<gimple, 64> worklist;
gimple_stmt_iterator gsi;
bool double_reduc;
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
"Unknown def-use cycle pattern.\n");
}
-
- worklist.release ();
}
gimple_stmt_iterator si;
unsigned int i, j;
vect_recog_func_ptr vect_recog_func;
- vec<gimple> stmts_to_replace;
- stmts_to_replace.create (1);
+ stack_vec<gimple, 1> stmts_to_replace;
gimple stmt;
if (dump_enabled_p ())
}
}
}
-
- stmts_to_replace.release ();
}
bool
vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo)
{
- vec<gimple> worklist;
struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
unsigned int nbbs = loop->num_nodes;
dump_printf_loc (MSG_NOTE, vect_location,
"=== vect_mark_stmts_to_be_vectorized ===\n");
- worklist.create (64);
+ stack_vec<gimple, 64> worklist;
/* 1. Init worklist. */
for (i = 0; i < nbbs; i++)
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
"unsupported use of reduction.\n");
- worklist.release ();
return false;
}
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
"unsupported use of nested cycle.\n");
- worklist.release ();
return false;
}
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
"unsupported use of double reduction.\n");
- worklist.release ();
return false;
}
live_p, relevant, &worklist, false)
|| !process_use (stmt, TREE_OPERAND (op, 1), loop_vinfo,
live_p, relevant, &worklist, false))
- {
- worklist.release ();
- return false;
- }
+ return false;
i = 2;
}
for (; i < gimple_num_ops (stmt); i++)
op = gimple_op (stmt, i);
if (!process_use (stmt, op, loop_vinfo, live_p, relevant,
&worklist, false))
- {
- worklist.release ();
- return false;
- }
+ return false;
}
}
else if (is_gimple_call (stmt))
tree arg = gimple_call_arg (stmt, i);
if (!process_use (stmt, arg, loop_vinfo, live_p, relevant,
&worklist, false))
- {
- worklist.release ();
- return false;
- }
+ return false;
}
}
}
tree op = USE_FROM_PTR (use_p);
if (!process_use (stmt, op, loop_vinfo, live_p, relevant,
&worklist, false))
- {
- worklist.release ();
- return false;
- }
+ return false;
}
if (STMT_VINFO_GATHER_P (stmt_vinfo))
gcc_assert (decl);
if (!process_use (stmt, off, loop_vinfo, live_p, relevant,
&worklist, true))
- {
- worklist.release ();
- return false;
- }
+ return false;
}
} /* while worklist */
- worklist.release ();
return true;
}
{
if (slp_node)
{
- vec<tree> ops;
- ops.create (4);
- vec<vec<tree> > vec_defs;
+ stack_vec<tree, 4> ops;
+ stack_vec<vec<tree>, 4> vec_defs;
- vec_defs.create (4);
ops.safe_push (TREE_OPERAND (cond_expr, 0));
ops.safe_push (TREE_OPERAND (cond_expr, 1));
ops.safe_push (then_clause);