call_string::call_string (const call_string &other)
: m_return_edges (other.m_return_edges.length ())
{
- const return_superedge *e;
- int i;
- FOR_EACH_VEC_ELT (other.m_return_edges, i, e)
+ for (const return_superedge *e : other.m_return_edges)
m_return_edges.quick_push (e);
}
{
json::array *arr = new json::array ();
- const return_superedge *e;
- int i;
- FOR_EACH_VEC_ELT (m_return_edges, i, e)
+ for (const return_superedge *e : m_return_edges)
{
json::object *e_obj = new json::object ();
e_obj->set ("src_snode_idx",
call_string::hash () const
{
inchash::hash hstate;
- int i;
- const return_superedge *e;
- FOR_EACH_VEC_ELT (m_return_edges, i, e)
+ for (const return_superedge *e : m_return_edges)
hstate.add_ptr (e);
return hstate.end ();
}
= m_return_edges[m_return_edges.length () - 1];
int result = 0;
- const return_superedge *e;
- int i;
- FOR_EACH_VEC_ELT (m_return_edges, i, e)
+ for (const return_superedge *e : m_return_edges)
if (e == top_return_sedge)
++result;
return result;
void
checker_path::fixup_locations (pending_diagnostic *pd)
{
- checker_event *e;
- int i;
- FOR_EACH_VEC_ELT (m_events, i, e)
+ for (checker_event *e : m_events)
e->set_location (pd->fixup_location (e->get_location ()));
}
: m_constant (other.m_constant), m_cst_sval (other.m_cst_sval),
m_vars (other.m_vars.length ())
{
- int i;
- const svalue *sval;
- FOR_EACH_VEC_ELT (other.m_vars, i, sval)
+ for (const svalue *sval : other.m_vars)
m_vars.quick_push (sval);
}
json::object *ec_obj = new json::object ();
json::array *sval_arr = new json::array ();
- int i;
- const svalue *sval;
- FOR_EACH_VEC_ELT (m_vars, i, sval)
+ for (const svalue *sval : m_vars)
sval_arr->append (sval->to_json ());
ec_obj->set ("svals", sval_arr);
inchash::hash hstate;
inchash::add_expr (m_constant, hstate);
- int i;
- const svalue *sval;
- FOR_EACH_VEC_ELT (m_vars, i, sval)
+ for (const svalue * sval : m_vars)
hstate.add_ptr (sval);
return hstate.end ();
}
/* Equivalence classes. */
{
json::array *ec_arr = new json::array ();
- int i;
- equiv_class *ec;
- FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
+ for (const equiv_class *ec : m_equiv_classes)
ec_arr->append (ec->to_json ());
cm_obj->set ("ecs", ec_arr);
}
/* Constraints. */
{
json::array *con_arr = new json::array ();
- int i;
- constraint *c;
- FOR_EACH_VEC_ELT (m_constraints, i, c)
- con_arr->append (c->to_json ());
+ for (const constraint &c : m_constraints)
+ con_arr->append (c.to_json ());
cm_obj->set ("constraints", con_arr);
}
impl_region_model_context::on_svalue_leak (const svalue *sval)
{
- int sm_idx;
- sm_state_map *smap;
- FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
+ for (sm_state_map *smap : m_new_state->m_checker_states)
smap->on_svalue_leak (sval, this);
}
on_liveness_change (const svalue_set &live_svalues,
const region_model *model)
{
- int sm_idx;
- sm_state_map *smap;
- FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
+ for (sm_state_map *smap : m_new_state->m_checker_states)
smap->on_liveness_change (live_svalues, model, this);
}
impl_region_model_context::on_unknown_change (const svalue *sval,
bool is_mutable)
{
- int sm_idx;
- sm_state_map *smap;
- FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
+ for (sm_state_map *smap : m_new_state->m_checker_states)
smap->on_unknown_change (sval, is_mutable, m_ext_state);
}
const svalue *origin,
const extrinsic_state &ext_state)
{
- int i;
- const svalue *sval;
bool any_changed = false;
- FOR_EACH_VEC_ELT (ec.m_vars, i, sval)
+ for (const svalue *sval : ec.m_vars)
any_changed |= impl_set_state (sval, state, origin, ext_state);
return any_changed;
}
region_model_manager mgr;
region_model model (&mgr);
- unsigned i;
- tree cst;
- FOR_EACH_VEC_ELT (csts, i, cst)
+ for (tree cst : csts)
model.get_rvalue (cst, NULL);
model.canonicalize ();
static scoped_attributes*
find_attribute_namespace (const char* ns)
{
- unsigned ix;
- scoped_attributes *iter;
-
- FOR_EACH_VEC_ELT (attributes_table, ix, iter)
- if (ns == iter->ns
- || (iter->ns != NULL
+ for (scoped_attributes &iter : attributes_table)
+ if (ns == iter.ns
+ || (iter.ns != NULL
&& ns != NULL
- && !strcmp (iter->ns, ns)))
- return iter;
+ && !strcmp (iter.ns, ns)))
+ return &iter;
return NULL;
}
FOR_ALL_BB_FN (bb, cfun)
{
vec<basic_block> dom_bbs;
- basic_block bb1;
- int i;
if (bb->aux != NULL)
continue;
bb->aux = bb;
dom_bbs = get_dominated_by (CDI_DOMINATORS, bb);
- FOR_EACH_VEC_ELT (dom_bbs, i, bb1)
+ for (basic_block bb1 : dom_bbs)
if (bb1->aux == NULL && dominated_by_p (CDI_POST_DOMINATORS, bb, bb1)
&& bb1->loop_father == bb->loop_father)
{
}
}
dom_bbs = get_dominated_by (CDI_POST_DOMINATORS, bb);
- FOR_EACH_VEC_ELT (dom_bbs, i, bb1)
+ for (basic_block bb1 : dom_bbs)
if (bb1->aux == NULL && dominated_by_p (CDI_DOMINATORS, bb, bb1)
&& bb1->loop_father == bb->loop_father)
{
/* Forget the saved values of the callee's SAVE_EXPRs and
TARGET_EXPRs. */
- unsigned int i;
- tree save_expr;
- FOR_EACH_VEC_ELT (save_exprs, i, save_expr)
+ for (tree save_expr : save_exprs)
ctx->global->values.remove (save_expr);
/* Remove the parms/result from the values map. Is it worth
semantics are not applied on an object under construction.
They come into effect when the constructor for the most
derived object ends." */
- tree elt;
- unsigned int i;
- FOR_EACH_VEC_ELT (*ctors, i, elt)
+ for (tree elt : *ctors)
if (same_type_ignoring_top_level_qualifiers_p
(TREE_TYPE (const_object_being_modified), TREE_TYPE (elt)))
{
/* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing
CONSTRUCTORs, if any. */
- tree elt;
- unsigned i;
bool c = TREE_CONSTANT (init);
bool s = TREE_SIDE_EFFECTS (init);
if (!c || s || activated_union_member_p)
- FOR_EACH_VEC_ELT (*ctors, i, elt)
+ for (tree elt : *ctors)
{
if (!c)
TREE_CONSTANT (elt) = false;
}
/* Forget saved values of SAVE_EXPRs and TARGET_EXPRs. */
- unsigned int i;
- tree save_expr;
- FOR_EACH_VEC_ELT (save_exprs, i, save_expr)
+ for (tree save_expr : save_exprs)
ctx->global->values.remove (save_expr);
save_exprs.truncate (0);
&& !*non_constant_p);
/* Forget saved values of SAVE_EXPRs and TARGET_EXPRs. */
- unsigned int i;
- tree save_expr;
- FOR_EACH_VEC_ELT (save_exprs, i, save_expr)
+ for (tree save_expr : save_exprs)
ctx->global->values.remove (save_expr);
return NULL_TREE;
{
if (vec<tree, va_gc> *statics = static_decls)
{
- tree decl;
- unsigned int i;
- FOR_EACH_VEC_ELT (*statics, i, decl)
+ for (tree decl : *statics)
{
if (warn_unused_function
&& TREE_CODE (decl) == FUNCTION_DECL
reference, insert it in the statement-tree now. */
if (cleanups)
{
- unsigned i; tree t;
- FOR_EACH_VEC_ELT (*cleanups, i, t)
+ for (tree t : *cleanups)
push_cleanup (decl, t, false);
release_tree_vector (cleanups);
}
SET_OPAQUE_ENUM_P (enumtype, false);
DECL_SOURCE_LOCATION (TYPE_NAME (enumtype)) = loc;
- string_int_pair *value;
- unsigned int i;
- FOR_EACH_VEC_ELT (values, i, value)
- build_enumerator (get_identifier (value->first),
- build_int_cst (integer_type_node, value->second),
+ for (const string_int_pair &value : values)
+ build_enumerator (get_identifier (value.first),
+ build_int_cst (integer_type_node, value.second),
enumtype, NULL_TREE, loc);
finish_enum_value_list (enumtype);
case RID_BUILTIN_LAUNDER:
{
vec<tree, va_gc> *vec;
- unsigned int i;
- tree p;
cp_lexer_consume_token (parser->lexer);
vec = cp_parser_parenthesized_expression_list (parser, non_attr,
break;
}
- FOR_EACH_VEC_ELT (*vec, i, p)
+ for (tree p : *vec)
mark_exp_read (p);
switch (keyword)
static void
do_specs_vec (vec<char_p> vec)
{
- unsigned ix;
- char *opt;
-
- FOR_EACH_VEC_ELT (vec, ix, opt)
+ for (char *opt : vec)
{
do_spec_1 (opt, 1, NULL);
/* Make each accumulated option a separate argument. */
{
const char *p1 = p;
char *string;
- char *opt;
- unsigned ix;
/* Skip past the option value and make a copy. */
if (*p != '{')
string = save_string (p1 + 1, p - p1 - 2);
/* See if we already recorded this option. */
- FOR_EACH_VEC_ELT (linker_options, ix, opt)
+ for (const char *opt : linker_options)
if (! strcmp (string, opt))
{
free (string);
&& do_spec_2 (startfile_prefix_spec, NULL) == 0
&& do_spec_1 (" ", 0, NULL) == 0)
{
- const char *arg;
- int ndx;
- FOR_EACH_VEC_ELT (argbuf, ndx, arg)
+ for (const char *arg : argbuf)
add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
PREFIX_PRIORITY_LAST, 0, 1);
}
any_access_function_variant_p (const struct data_reference *a,
const class loop *loop_nest)
{
- unsigned int i;
vec<tree> fns = DR_ACCESS_FNS (a);
- tree t;
- FOR_EACH_VEC_ELT (fns, i, t)
+ for (tree t : fns)
if (!evolution_function_is_invariant_p (t, loop_nest->num))
return true;
clobbers those loads. */
gimple *first = merged_store->first_stmt;
gimple *last = merged_store->last_stmt;
- unsigned int i;
- store_immediate_info *infoc;
/* The stores are sorted by increasing store bitpos, so if info->stmt store
comes before the so far first load, we'll be changing
merged_store->first_stmt. In that case we need to give up if
range. */
if (info->order < merged_store->first_order)
{
- FOR_EACH_VEC_ELT (merged_store->stores, i, infoc)
+ for (store_immediate_info *infoc : merged_store->stores)
if (stmts_may_clobber_ref_p (info->stmt, first, infoc->ops[idx].val))
return false;
first = info->stmt;
processed loads. */
else if (info->order > merged_store->last_order)
{
- FOR_EACH_VEC_ELT (merged_store->stores, i, infoc)
+ for (store_immediate_info *infoc : merged_store->stores)
if (stmts_may_clobber_ref_p (last, info->stmt, infoc->ops[idx].val))
return false;
last = info->stmt;
gather_bswap_load_refs (&refs,
gimple_assign_rhs1 (m_store_info[i]->stmt));
- unsigned int i;
- tree ref;
- FOR_EACH_VEC_ELT (refs, i, ref)
+ for (tree ref : refs)
if (stmts_may_clobber_ref_p (first_stmt, last_stmt, ref))
return false;
n.vuse = NULL_TREE;
}
else if (infof->rhs_code == MEM_REF && info->rhs_code != MEM_REF)
{
- store_immediate_info *infoj;
- unsigned int j;
- FOR_EACH_VEC_ELT (merged_store->stores, j, infoj)
+ for (store_immediate_info *infoj : merged_store->stores)
{
infoj->rhs_code = BIT_INSERT_EXPR;
infoj->ops[0].val = gimple_assign_rhs1 (infoj->stmt);
static location_t
get_location_for_stmts (vec<gimple *> &stmts)
{
- gimple *stmt;
- unsigned int i;
-
- FOR_EACH_VEC_ELT (stmts, i, stmt)
+ for (gimple *stmt : stmts)
if (gimple_has_location (stmt))
return gimple_location (stmt);
void
print_iteration_domains (FILE *file, scop_p scop)
{
- int i;
- poly_bb_p pbb;
-
- FOR_EACH_VEC_ELT (scop->pbbs, i, pbb)
+ for (poly_bb_p pbb : scop->pbbs)
print_iteration_domain (file, pbb);
}
static void
free_poly_bb (poly_bb_p pbb)
{
- int i;
- poly_dr_p pdr;
-
isl_set_free (pbb->domain);
pbb->domain = NULL;
isl_set_free (pbb->iterators);
pbb->iterators = NULL;
if (PBB_DRS (pbb).exists ())
- FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr)
+ for (poly_dr_p pdr : PBB_DRS (pbb))
free_poly_dr (pdr);
PBB_DRS (pbb).release ();
static void
remove_gbbs_in_scop (scop_p scop)
{
- int i;
- poly_bb_p pbb;
-
- FOR_EACH_VEC_ELT (scop->pbbs, i, pbb)
+ for (poly_bb_p pbb : scop->pbbs)
free_gimple_poly_bb (PBB_BLACK_BOX (pbb));
}
void
free_scop (scop_p scop)
{
- int i;
- poly_bb_p pbb;
-
remove_gbbs_in_scop (scop);
free_sese_info (scop->scop_info);
- FOR_EACH_VEC_ELT (scop->pbbs, i, pbb)
+ for (poly_bb_p pbb : scop->pbbs)
free_poly_bb (pbb);
scop->pbbs.release ();
static void
dump_gbb_cases (FILE *file, gimple_poly_bb_p gbb)
{
- int i;
- gimple *stmt;
vec<gimple *> cases;
if (!gbb)
fprintf (file, "cases bb_%d (\n", GBB_BB (gbb)->index);
- FOR_EACH_VEC_ELT (cases, i, stmt)
+ for (gimple *stmt : cases)
print_gimple_stmt (file, stmt, 0);
fprintf (file, ")\n");
static void
dump_gbb_conditions (FILE *file, gimple_poly_bb_p gbb)
{
- int i;
- gimple *stmt;
vec<gimple *> conditions;
if (!gbb)
fprintf (file, "conditions bb_%d (\n", GBB_BB (gbb)->index);
- FOR_EACH_VEC_ELT (conditions, i, stmt)
+ for (gimple *stmt : conditions)
print_gimple_stmt (file, stmt, 0);
fprintf (file, ")\n");
void
print_pdrs (FILE *file, poly_bb_p pbb)
{
- int i;
- poly_dr_p pdr;
int nb_reads = 0;
int nb_writes = 0;
fprintf (file, "Data references (\n");
- FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr)
+ for (poly_dr_p pdr : PBB_DRS (pbb))
if (PDR_TYPE (pdr) == PDR_READ)
nb_reads++;
else
fprintf (file, "Read data references (\n");
- FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr)
+ for (poly_dr_p pdr : PBB_DRS (pbb))
if (PDR_TYPE (pdr) == PDR_READ)
print_pdr (file, pdr);
fprintf (file, ")\n");
fprintf (file, "Write data references (\n");
- FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr)
+ for (poly_dr_p pdr : PBB_DRS (pbb))
if (PDR_TYPE (pdr) != PDR_READ)
print_pdr (file, pdr);
fprintf (file, ")\n");
void
print_scop (FILE *file, scop_p scop)
{
- int i;
- poly_bb_p pbb;
-
fprintf (file, "SCoP (\n");
print_scop_context (file, scop);
print_scop_params (file, scop);
fprintf (file, "Number of statements: ");
fprintf (file, "%d\n", scop->pbbs.length ());
- FOR_EACH_VEC_ELT (scop->pbbs, i, pbb)
+ for (poly_bb_p pbb : scop->pbbs)
print_pbb (file, pbb);
fprintf (file, ")\n");
rtx_insn *jump = if_info->jump;
rtx cond = if_info->cond;
rtx_insn *seq, *loc_insn;
- rtx reg;
int c;
vec<rtx> then_regs = vNULL;
vec<rtx> else_regs = vNULL;
- unsigned int i;
int success_p = FALSE;
int limit = param_max_rtl_if_conversion_insns;
source register does not change after the assignment. Also count
the number of registers set in only one of the blocks. */
c = 0;
- FOR_EACH_VEC_ELT (then_regs, i, reg)
+ for (rtx reg : then_regs)
{
rtx *then_slot = then_vals.get (reg);
rtx *else_slot = else_vals.get (reg);
}
/* Finish off c for MAX_CONDITIONAL_EXECUTE. */
- FOR_EACH_VEC_ELT (else_regs, i, reg)
+ for (rtx reg : else_regs)
{
gcc_checking_assert (else_vals.get (reg));
if (!then_vals.get (reg))
}
}
- {
- unsigned int i;
- bitmap b;
-
- FOR_EACH_VEC_ELT (reg_copy_graph, i, b)
- if (b)
- BITMAP_FREE (b);
- }
+ for (bitmap b : reg_copy_graph)
+ if (b)
+ BITMAP_FREE (b);
reg_copy_graph.release ();
changed anything though. */
if (!worklist.is_empty ())
{
- unsigned int i;
- int index;
-
any_debug_changes = false;
bitmap_clear (visited);
- FOR_EACH_VEC_ELT (worklist, i, index)
+ for (int index : worklist)
{
bb = BASIC_BLOCK_FOR_FN (fun, index);
cprop_hardreg_bb (bb, all_vd, visited);
/* Unset value expr for parameters for which we created debug bind
expressions. */
- unsigned i;
- tree arg;
- FOR_EACH_VEC_ELT (clear_value_expr_list, i, arg)
+ for (tree arg : clear_value_expr_list)
{
DECL_HAS_VALUE_EXPR_P (arg) = 0;
SET_DECL_VALUE_EXPR (arg, NULL_TREE);
void
dump_insn_vector (rtx_vec_t succs)
{
- int i;
- rtx_insn *succ;
-
- FOR_EACH_VEC_ELT (succs, i, succ)
+ for (rtx_insn *succ : succs)
if (succ)
dump_insn (succ);
else
static bool
store_ops_ok (const vec<rtx> &x, int *regs_set)
{
- unsigned int i;
- rtx temp;
- FOR_EACH_VEC_ELT (x, i, temp)
+ for (rtx temp : x)
if (regs_set[REGNO (temp)])
return false;
/* But even a const call reads its parameters. Check whether the
base of some of registers used in mem is stack pointer. */
- rtx temp;
- unsigned int i;
- FOR_EACH_VEC_ELT (x_regs, i, temp)
+ for (rtx temp : x_regs)
if (may_be_sp_based_p (temp))
return true;
void
timer::named_items::print (FILE *fp, const timevar_time_def *total)
{
- unsigned int i;
- const char *item_name;
fprintf (fp, "Client items:\n");
- FOR_EACH_VEC_ELT (m_names, i, item_name)
+ for (const char *item_name : m_names)
{
timer::timevar_def *def = m_hash_map.get (item_name);
gcc_assert (def);
/* If we've marked .ABNORMAL_DISPATCHER basic block(s) as visited
above, but haven't marked any of their successors as visited,
unmark them now, so that they can be removed as useless. */
- basic_block dispatcher_bb;
- unsigned int k;
- FOR_EACH_VEC_ELT (abnormal_dispatchers, k, dispatcher_bb)
+ for (basic_block dispatcher_bb : abnormal_dispatchers)
{
edge e;
edge_iterator ei;
if (!dom_info_available_p (CDI_DOMINATORS))
mark_dfs_back_edges ();
- loop_p loop;
- unsigned i;
- FOR_EACH_VEC_ELT (*get_loops (cfun), i, loop)
+ for (loop_p loop : *get_loops (cfun))
if (loop && loop->header)
{
basic_block bb = loop->header;
static void
dump_data_references (FILE *file, vec<data_reference_p> datarefs)
{
- unsigned int i;
- struct data_reference *dr;
-
- FOR_EACH_VEC_ELT (datarefs, i, dr)
+ for (data_reference *dr : datarefs)
dump_data_reference (file, dr);
}
print_dir_vectors (FILE *outf, vec<lambda_vector> dir_vects,
int length)
{
- unsigned j;
- lambda_vector v;
-
- FOR_EACH_VEC_ELT (dir_vects, j, v)
+ for (lambda_vector v : dir_vects)
print_direction_vector (outf, v, length);
}
print_dist_vectors (FILE *outf, vec<lambda_vector> dist_vects,
int length)
{
- unsigned j;
- lambda_vector v;
-
- FOR_EACH_VEC_ELT (dist_vects, j, v)
+ for (lambda_vector v : dist_vects)
print_lambda_vector (outf, v, length);
}
dump_data_dependence_relations (FILE *file,
vec<ddr_p> ddrs)
{
- unsigned int i;
- struct data_dependence_relation *ddr;
-
- FOR_EACH_VEC_ELT (ddrs, i, ddr)
+ for (data_dependence_relation *ddr : ddrs)
dump_data_dependence_relation (file, ddr);
}
DEBUG_FUNCTION void
dump_dist_dir_vectors (FILE *file, vec<ddr_p> ddrs)
{
- unsigned int i, j;
- struct data_dependence_relation *ddr;
- lambda_vector v;
-
- FOR_EACH_VEC_ELT (ddrs, i, ddr)
+ for (data_dependence_relation *ddr : ddrs)
if (DDR_ARE_DEPENDENT (ddr) == NULL_TREE && DDR_AFFINE_P (ddr))
{
- FOR_EACH_VEC_ELT (DDR_DIST_VECTS (ddr), j, v)
+ for (lambda_vector v : DDR_DIST_VECTS (ddr))
{
fprintf (file, "DISTANCE_V (");
print_lambda_vector (file, v, DDR_NB_LOOPS (ddr));
fprintf (file, ")\n");
}
- FOR_EACH_VEC_ELT (DDR_DIR_VECTS (ddr), j, v)
+ for (lambda_vector v : DDR_DIR_VECTS (ddr))
{
fprintf (file, "DIRECTION_V (");
print_direction_vector (file, v, DDR_NB_LOOPS (ddr));
DEBUG_FUNCTION void
dump_ddrs (FILE *file, vec<ddr_p> ddrs)
{
- unsigned int i;
- struct data_dependence_relation *ddr;
-
- FOR_EACH_VEC_ELT (ddrs, i, ddr)
+ for (data_dependence_relation *ddr : ddrs)
dump_data_dependence_relation (file, ddr);
fprintf (file, "\n\n");
tree part_cond_expr;
fold_defer_overflow_warnings ();
- dr_with_seg_len_pair_t *alias_pair;
- unsigned int i;
- FOR_EACH_VEC_ELT (*alias_pairs, i, alias_pair)
+ for (const dr_with_seg_len_pair_t &alias_pair : alias_pairs)
{
- gcc_assert (alias_pair->flags);
+ gcc_assert (alias_pair.flags);
if (dump_enabled_p ())
dump_printf (MSG_NOTE,
"create runtime check for data references %T and %T\n",
- DR_REF (alias_pair->first.dr),
- DR_REF (alias_pair->second.dr));
+ DR_REF (alias_pair.first.dr),
+ DR_REF (alias_pair.second.dr));
/* Create condition expression for each pair data references. */
- create_intersect_range_checks (loop, &part_cond_expr, *alias_pair);
+ create_intersect_range_checks (loop, &part_cond_expr, alias_pair);
if (*cond_expr)
*cond_expr = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
*cond_expr, part_cond_expr);
static void
free_subscripts (vec<subscript_p> subscripts)
{
- unsigned i;
- subscript_p s;
-
- FOR_EACH_VEC_ELT (subscripts, i, s)
+ for (subscript_p s : subscripts)
{
free_conflict_function (s->conflicting_iterations_in_a);
free_conflict_function (s->conflicting_iterations_in_b);
static void
save_dist_v (struct data_dependence_relation *ddr, lambda_vector dist_v)
{
- unsigned i;
- lambda_vector v;
-
- FOR_EACH_VEC_ELT (DDR_DIST_VECTS (ddr), i, v)
+ for (lambda_vector v : DDR_DIST_VECTS (ddr))
if (lambda_vector_equal (v, dist_v, DDR_NB_LOOPS (ddr)))
return;
static void
save_dir_v (struct data_dependence_relation *ddr, lambda_vector dir_v)
{
- unsigned i;
- lambda_vector v;
-
- FOR_EACH_VEC_ELT (DDR_DIR_VECTS (ddr), i, v)
+ for (lambda_vector v : DDR_DIR_VECTS (ddr))
if (lambda_vector_equal (v, dir_v, DDR_NB_LOOPS (ddr)))
return;
invariant_access_functions (const struct data_dependence_relation *ddr,
int lnum)
{
- unsigned i;
- subscript *sub;
-
- FOR_EACH_VEC_ELT (DDR_SUBSCRIPTS (ddr), i, sub)
+ for (subscript *sub : DDR_SUBSCRIPTS (ddr))
if (!evolution_function_is_invariant_p (SUB_ACCESS_FN (sub, 0), lnum)
|| !evolution_function_is_invariant_p (SUB_ACCESS_FN (sub, 1), lnum))
return false;
static inline bool
same_access_functions (const struct data_dependence_relation *ddr)
{
- unsigned i;
- subscript *sub;
-
- FOR_EACH_VEC_ELT (DDR_SUBSCRIPTS (ddr), i, sub)
+ for (subscript *sub : DDR_SUBSCRIPTS (ddr))
if (!eq_evolutions_p (SUB_ACCESS_FN (sub, 0),
SUB_ACCESS_FN (sub, 1)))
return false;
access_functions_are_affine_or_constant_p (const struct data_reference *a,
const class loop *loop_nest)
{
- unsigned int i;
vec<tree> fns = DR_ACCESS_FNS (a);
- tree t;
-
- FOR_EACH_VEC_ELT (fns, i, t)
+ for (tree t : fns)
if (!evolution_function_is_invariant_p (t, loop_nest->num)
&& !evolution_function_is_affine_multivariate_p (t, loop_nest->num))
return false;
find_data_references_in_stmt (class loop *nest, gimple *stmt,
vec<data_reference_p> *datarefs)
{
- unsigned i;
auto_vec<data_ref_loc, 2> references;
- data_ref_loc *ref;
data_reference_p dr;
if (get_references_in_stmt (stmt, &references))
return opt_result::failure_at (stmt, "statement clobbers memory: %G",
stmt);
- FOR_EACH_VEC_ELT (references, i, ref)
+ for (const data_ref_loc &ref : references)
{
dr = create_data_ref (nest ? loop_preheader_edge (nest) : NULL,
- loop_containing_stmt (stmt), ref->ref,
- stmt, ref->is_read, ref->is_conditional_in_stmt);
+ loop_containing_stmt (stmt), ref.ref,
+ stmt, ref.is_read, ref.is_conditional_in_stmt);
gcc_assert (dr != NULL);
datarefs->safe_push (dr);
}
graphite_find_data_references_in_stmt (edge nest, loop_p loop, gimple *stmt,
vec<data_reference_p> *datarefs)
{
- unsigned i;
auto_vec<data_ref_loc, 2> references;
- data_ref_loc *ref;
bool ret = true;
data_reference_p dr;
if (get_references_in_stmt (stmt, &references))
return false;
- FOR_EACH_VEC_ELT (references, i, ref)
+ for (const data_ref_loc &ref : references)
{
- dr = create_data_ref (nest, loop, ref->ref, stmt, ref->is_read,
- ref->is_conditional_in_stmt);
+ dr = create_data_ref (nest, loop, ref.ref, stmt, ref.is_read,
+ ref.is_conditional_in_stmt);
gcc_assert (dr != NULL);
datarefs->safe_push (dr);
}
void
free_dependence_relations (vec<ddr_p> dependence_relations)
{
- unsigned int i;
- struct data_dependence_relation *ddr;
-
- FOR_EACH_VEC_ELT (dependence_relations, i, ddr)
+ for (data_dependence_relation *ddr : dependence_relations)
if (ddr)
free_dependence_relation (ddr);
void
free_data_refs (vec<data_reference_p> datarefs)
{
- unsigned int i;
- struct data_reference *dr;
-
- FOR_EACH_VEC_ELT (datarefs, i, dr)
+ for (data_reference *dr : datarefs)
free_data_ref (dr);
datarefs.release ();
}
static void
copy_debug_stmts (copy_body_data *id)
{
- size_t i;
- gdebug *stmt;
-
if (!id->debug_stmts.exists ())
return;
- FOR_EACH_VEC_ELT (id->debug_stmts, i, stmt)
+ for (gdebug *stmt : id->debug_stmts)
copy_debug_stmt (stmt, id);
id->debug_stmts.release ();
void
dump_currdefs (FILE *file)
{
- unsigned i;
- tree var;
-
if (symbols_to_rename.is_empty ())
return;
fprintf (file, "\n\nCurrent reaching definitions\n\n");
- FOR_EACH_VEC_ELT (symbols_to_rename, i, var)
+ for (tree var : symbols_to_rename)
{
common_info *info = get_common_info (var);
fprintf (file, "CURRDEF (");
{
edge e;
edge_iterator ei;
- unsigned i;
FOR_EACH_EDGE (e, ei, bb->succs)
{
- gphi *phi;
vec<gphi *> phis;
if (!bitmap_bit_p (blocks_with_phis_to_rewrite, e->dest->index))
continue;
phis = phis_to_rewrite[e->dest->index];
- FOR_EACH_VEC_ELT (phis, i, phi)
+ for (gphi *phi : phis)
{
tree arg, lhs_sym, reaching_def = NULL;
use_operand_p arg_p;
unsigned
clean_up_loop_closed_phi (function *fun)
{
- unsigned i;
- edge e;
gphi *phi;
tree rhs;
tree lhs;
{
/* Check each exit edege of loop. */
auto_vec<edge> exits = get_loop_exit_edges (loop);
- FOR_EACH_VEC_ELT (exits, i, e)
+ for (edge e : exits)
if (single_pred_p (e->dest))
/* Walk over loop-closed PHIs. */
for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi);)
int loop_depth, unsigned int *max_vf)
{
class loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
- lambda_vector dist_v;
- unsigned int i;
- FOR_EACH_VEC_ELT (DDR_DIST_VECTS (ddr), i, dist_v)
+ for (lambda_vector &dist_v : DDR_DIST_VECTS (ddr))
{
int dist = dist_v[loop_depth];
if (dist != 0 && !(dist > 0 && DDR_REVERSED_P (ddr)))
{
if (stmt_info != last_store_info)
continue;
- unsigned i;
- stmt_vec_info store_info;
- FOR_EACH_VEC_ELT (stores, i, store_info)
+
+ for (stmt_vec_info &store_info : stores)
{
data_reference *store_dr
= STMT_VINFO_DATA_REF (store_info);
{
if (stmt_info != last_store_info)
continue;
- unsigned i;
- stmt_vec_info store_info;
- FOR_EACH_VEC_ELT (stores, i, store_info)
+
+ for (stmt_vec_info &store_info : stores)
{
data_reference *store_dr
= STMT_VINFO_DATA_REF (store_info);
/* Verify we can sink loads to the vectorized stmt insert location,
special-casing stores of this instance. */
- slp_tree load;
- unsigned int i;
- FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (instance), i, load)
+ for (slp_tree &load : SLP_INSTANCE_LOADS (instance))
if (! vect_slp_analyze_node_dependences (vinfo, load,
store
? SLP_TREE_SCALAR_STMTS (store)
{
loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
class loop *loop = loop_vinfo ? LOOP_VINFO_LOOP (loop_vinfo) : NULL;
- data_reference *dr;
- unsigned int i;
- FOR_EACH_VEC_ELT (vinfo->shared->datarefs, i, dr)
+ for (data_reference *dr : vinfo->shared->datarefs)
{
dr_vec_info *dr_info = vinfo->lookup_dr (dr);
stmt_vec_info stmt_info = dr_info->stmt;
bool unknown_misalignment)
{
vec<data_reference_p> datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
- unsigned i;
- data_reference *dr;
- FOR_EACH_VEC_ELT (datarefs, i, dr)
+ for (data_reference *dr : datarefs)
{
dr_vec_info *dr_info = loop_vinfo->lookup_dr (dr);
if (!vect_relevant_for_alignment_p (dr_info))
vect_peeling_supportable (loop_vec_info loop_vinfo, dr_vec_info *dr0_info,
unsigned npeel)
{
- unsigned i;
- struct data_reference *dr = NULL;
vec<data_reference_p> datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
enum dr_alignment_support supportable_dr_alignment;
/* Ensure that all data refs can be vectorized after the peel. */
- FOR_EACH_VEC_ELT (datarefs, i, dr)
+ for (data_reference *dr : datarefs)
{
int save_misalignment;
vec_info::~vec_info ()
{
- slp_instance instance;
- unsigned int i;
-
- FOR_EACH_VEC_ELT (slp_instances, i, instance)
+ for (slp_instance &instance : slp_instances)
vect_free_slp_instance (instance);
destroy_cost_data (target_cost_data);
void
vec_info::free_stmt_vec_infos (void)
{
- unsigned int i;
- stmt_vec_info info;
- FOR_EACH_VEC_ELT (stmt_vec_infos, i, info)
+ for (stmt_vec_info &info : stmt_vec_infos)
if (info != NULL)
free_stmt_vec_info (info);
stmt_vec_infos.release ();
projects / thirdparty / gcc.git / commitdiff
