static unsigned int next_expression_id;
/* Mapping from expression to id number we can use in bitmap sets. */
-DEF_VEC_P (pre_expr);
-DEF_VEC_ALLOC_P (pre_expr, heap);
-static VEC(pre_expr, heap) *expressions;
+static vec<pre_expr> expressions;
static hash_table <pre_expr_d> expression_to_id;
-static VEC(unsigned, heap) *name_to_id;
+static vec<unsigned> name_to_id;
/* Allocate an expression id for EXPR. */
/* Make sure we won't overflow. */
gcc_assert (next_expression_id + 1 > next_expression_id);
expr->id = next_expression_id++;
- VEC_safe_push (pre_expr, heap, expressions, expr);
+ expressions.safe_push (expr);
if (expr->kind == NAME)
{
unsigned version = SSA_NAME_VERSION (PRE_EXPR_NAME (expr));
- /* VEC_safe_grow_cleared allocates no headroom. Avoid frequent
- re-allocations by using VEC_reserve upfront. There is no
- VEC_quick_grow_cleared unfortunately. */
- unsigned old_len = VEC_length (unsigned, name_to_id);
- VEC_reserve (unsigned, heap, name_to_id, num_ssa_names - old_len);
- VEC_safe_grow_cleared (unsigned, heap, name_to_id, num_ssa_names);
- gcc_assert (VEC_index (unsigned, name_to_id, version) == 0);
- VEC_replace (unsigned, name_to_id, version, expr->id);
+ /* vec::safe_grow_cleared allocates no headroom. Avoid frequent
+ re-allocations by using vec::reserve upfront. There is no
+ vec::quick_grow_cleared unfortunately. */
+ unsigned old_len = name_to_id.length ();
+ name_to_id.reserve (num_ssa_names - old_len);
+ name_to_id.safe_grow_cleared (num_ssa_names);
+ gcc_assert (name_to_id[version] == 0);
+ name_to_id[version] = expr->id;
}
else
{
if (expr->kind == NAME)
{
unsigned version = SSA_NAME_VERSION (PRE_EXPR_NAME (expr));
- if (VEC_length (unsigned, name_to_id) <= version)
+ if (name_to_id.length () <= version)
return 0;
- return VEC_index (unsigned, name_to_id, version);
+ return name_to_id[version];
}
else
{
static inline pre_expr
expression_for_id (unsigned int id)
{
- return VEC_index (pre_expr, expressions, id);
+ return expressions[id];
}
/* Free the expression id field in all of our expressions,
static void
clear_expression_ids (void)
{
- VEC_free (pre_expr, heap, expressions);
+ expressions.release ();
}
static alloc_pool pre_expr_pool;
EXECUTE_IF_SET_IN_BITMAP(&(set)->values, 0, (id), (bi))
/* Mapping from value id to expressions with that value_id. */
-static VEC(bitmap, heap) *value_expressions;
+static vec<bitmap> value_expressions;
/* Sets that we need to keep track of. */
typedef struct bb_bitmap_sets
gcc_checking_assert (get_expr_value_id (e) == v);
- if (v >= VEC_length (bitmap, value_expressions))
+ if (v >= value_expressions.length ())
{
- VEC_safe_grow_cleared (bitmap, heap, value_expressions, v + 1);
+ value_expressions.safe_grow_cleared (v + 1);
}
- set = VEC_index (bitmap, value_expressions, v);
+ set = value_expressions[v];
if (!set)
{
set = BITMAP_ALLOC (&grand_bitmap_obstack);
- VEC_replace (bitmap, value_expressions, v, set);
+ value_expressions[v] = set;
}
bitmap_set_bit (set, get_or_alloc_expression_id (e));
{
bitmap_iterator bi;
unsigned int i;
- bitmap exprset = VEC_index (bitmap, value_expressions, val);
+ bitmap exprset = value_expressions[val];
EXECUTE_IF_SET_IN_BITMAP (exprset, 0, i, bi)
{
pre_expr vexpr = expression_for_id (i);
/* Generate an topological-ordered array of bitmap set SET. */
-static VEC(pre_expr, heap) *
+static vec<pre_expr>
sorted_array_from_bitmap_set (bitmap_set_t set)
{
unsigned int i, j;
bitmap_iterator bi, bj;
- VEC(pre_expr, heap) *result;
+ vec<pre_expr> result;
/* Pre-allocate roughly enough space for the array. */
- result = VEC_alloc (pre_expr, heap, bitmap_count_bits (&set->values));
+ result.create (bitmap_count_bits (&set->values));
FOR_EACH_VALUE_ID_IN_SET (set, i, bi)
{
If this is somehow a significant lose for some cases, we can
choose which set to walk based on the set size. */
- bitmap exprset = VEC_index (bitmap, value_expressions, i);
+ bitmap exprset = value_expressions[i];
EXECUTE_IF_SET_IN_BITMAP (exprset, 0, j, bj)
{
if (bitmap_bit_p (&set->expressions, j))
- VEC_safe_push (pre_expr, heap, result, expression_for_id (j));
+ result.safe_push (expression_for_id (j));
}
}
5-10x faster than walking the bitmap. If this is somehow a
significant lose for some cases, we can choose which set to walk
based on the set size. */
- exprset = VEC_index (bitmap, value_expressions, lookfor);
+ exprset = value_expressions[lookfor];
EXECUTE_IF_SET_IN_BITMAP (exprset, 0, i, bi)
{
if (bitmap_clear_bit (&set->expressions, i))
vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
fprintf (outfile, "{");
for (i = 0;
- VEC_iterate (vn_reference_op_s, ref->operands, i, vro);
+ ref->operands.iterate (i, &vro);
i++)
{
bool closebrace = false;
}
if (closebrace)
fprintf (outfile, ">");
- if (i != VEC_length (vn_reference_op_s, ref->operands) - 1)
+ if (i != ref->operands.length () - 1)
fprintf (outfile, ",");
}
fprintf (outfile, "}");
static void
print_value_expressions (FILE *outfile, unsigned int val)
{
- bitmap set = VEC_index (bitmap, value_expressions, val);
+ bitmap set = value_expressions[val];
if (set)
{
bitmap_set x;
{
unsigned int i;
bitmap_iterator bi;
- bitmap exprset = VEC_index (bitmap, value_expressions, v);
+ bitmap exprset = value_expressions[v];
EXECUTE_IF_SET_IN_BITMAP (exprset, 0, i, bi)
{
in case the new vuse doesn't change the value id of the OPERANDS. */
static tree
-translate_vuse_through_block (VEC (vn_reference_op_s, heap) *operands,
+translate_vuse_through_block (vec<vn_reference_op_s> operands,
alias_set_type set, tree type, tree vuse,
basic_block phiblock,
basic_block block, bool *same_valid)
and pick out an SSA_NAME. */
unsigned int i;
bitmap_iterator bi;
- bitmap exprs = VEC_index (bitmap, value_expressions, value_id);
+ bitmap exprs = value_expressions[value_id];
EXECUTE_IF_SET_IN_BITMAP (exprs, 0, i, bi)
{
pre_expr rep = expression_for_id (i);
else
{
new_val_id = get_next_value_id ();
- VEC_safe_grow_cleared (bitmap, heap,
- value_expressions,
- get_max_value_id() + 1);
+ value_expressions.safe_grow_cleared (get_max_value_id() + 1);
nary = vn_nary_op_insert_pieces (newnary->length,
newnary->opcode,
newnary->type,
case REFERENCE:
{
vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
- VEC (vn_reference_op_s, heap) *operands = ref->operands;
+ vec<vn_reference_op_s> operands = ref->operands;
tree vuse = ref->vuse;
tree newvuse = vuse;
- VEC (vn_reference_op_s, heap) *newoperands = NULL;
+ vec<vn_reference_op_s> newoperands
+ = vec<vn_reference_op_s>();
bool changed = false, same_valid = true;
unsigned int i, j, n;
vn_reference_op_t operand;
vn_reference_t newref;
for (i = 0, j = 0;
- VEC_iterate (vn_reference_op_s, operands, i, operand); i++, j++)
+ operands.iterate (i, &operand); i++, j++)
{
pre_expr opresult;
pre_expr leader;
}
if (n != 3)
{
- if (newoperands)
- VEC_free (vn_reference_op_s, heap, newoperands);
+ newoperands.release ();
return NULL;
}
- if (!newoperands)
- newoperands = VEC_copy (vn_reference_op_s, heap, operands);
+ if (!newoperands.exists ())
+ newoperands = operands.copy ();
/* We may have changed from an SSA_NAME to a constant */
if (newop.opcode == SSA_NAME && TREE_CODE (op[0]) != SSA_NAME)
newop.opcode = TREE_CODE (op[0]);
if (off.fits_shwi ())
newop.off = off.low;
}
- VEC_replace (vn_reference_op_s, newoperands, j, newop);
+ newoperands[j] = newop;
/* If it transforms from an SSA_NAME to an address, fold with
a preceding indirect reference. */
if (j > 0 && op[0] && TREE_CODE (op[0]) == ADDR_EXPR
- && VEC_index (vn_reference_op_s,
- newoperands, j - 1).opcode == MEM_REF)
+ && newoperands[j - 1].opcode == MEM_REF)
vn_reference_fold_indirect (&newoperands, &j);
}
- if (i != VEC_length (vn_reference_op_s, operands))
+ if (i != operands.length ())
{
- if (newoperands)
- VEC_free (vn_reference_op_s, heap, newoperands);
+ newoperands.release ();
return NULL;
}
&same_valid);
if (newvuse == NULL_TREE)
{
- VEC_free (vn_reference_op_s, heap, newoperands);
+ newoperands.release ();
return NULL;
}
}
newoperands,
&newref, VN_WALK);
if (result)
- VEC_free (vn_reference_op_s, heap, newoperands);
+ newoperands.release ();
/* We can always insert constants, so if we have a partial
redundant constant load of another type try to translate it
else if (!result && newref
&& !useless_type_conversion_p (ref->type, newref->type))
{
- VEC_free (vn_reference_op_s, heap, newoperands);
+ newoperands.release ();
return NULL;
}
if (changed || !same_valid)
{
new_val_id = get_next_value_id ();
- VEC_safe_grow_cleared (bitmap, heap,
- value_expressions,
- get_max_value_id() + 1);
+ value_expressions.safe_grow_cleared(get_max_value_id() + 1);
}
else
new_val_id = ref->value_id;
ref->type,
newoperands,
result, new_val_id);
- newoperands = NULL;
+ newoperands.create (0);
PRE_EXPR_REFERENCE (expr) = newref;
constant = fully_constant_expression (expr);
if (constant != expr)
}
add_to_value (new_val_id, expr);
}
- VEC_free (vn_reference_op_s, heap, newoperands);
+ newoperands.release ();
return expr;
}
break;
phi_translate_set (bitmap_set_t dest, bitmap_set_t set, basic_block pred,
basic_block phiblock)
{
- VEC (pre_expr, heap) *exprs;
+ vec<pre_expr> exprs;
pre_expr expr;
int i;
}
exprs = sorted_array_from_bitmap_set (set);
- FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+ FOR_EACH_VEC_ELT (exprs, i, expr)
{
pre_expr translated;
translated = phi_translate (expr, set, NULL, pred, phiblock);
else
bitmap_value_insert_into_set (dest, translated);
}
- VEC_free (pre_expr, heap, exprs);
+ exprs.release ();
}
/* Find the leader for a value (i.e., the name representing that
{
unsigned int i;
bitmap_iterator bi;
- bitmap exprset = VEC_index (bitmap, value_expressions, val);
+ bitmap exprset = value_expressions[val];
EXECUTE_IF_SET_IN_BITMAP (exprset, 0, i, bi)
{
choose which set to walk based on which set is smaller. */
unsigned int i;
bitmap_iterator bi;
- bitmap exprset = VEC_index (bitmap, value_expressions, val);
+ bitmap exprset = value_expressions[val];
EXECUTE_IF_AND_IN_BITMAP (exprset, &set->expressions, 0, i, bi)
return expression_for_id (i);
vn_reference_op_t vro;
unsigned int i;
- FOR_EACH_VEC_ELT (vn_reference_op_s, ref->operands, i, vro)
+ FOR_EACH_VEC_ELT (ref->operands, i, vro)
{
if (!op_valid_in_sets (set1, set2, vro->op0)
|| !op_valid_in_sets (set1, set2, vro->op1)
static void
dependent_clean (bitmap_set_t set1, bitmap_set_t set2, basic_block block)
{
- VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set1);
+ vec<pre_expr> exprs = sorted_array_from_bitmap_set (set1);
pre_expr expr;
int i;
- FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+ FOR_EACH_VEC_ELT (exprs, i, expr)
{
if (!valid_in_sets (set1, set2, expr, block))
bitmap_remove_from_set (set1, expr);
}
- VEC_free (pre_expr, heap, exprs);
+ exprs.release ();
}
/* Clean the set of expressions that are no longer valid in SET. This
static void
clean (bitmap_set_t set, basic_block block)
{
- VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set);
+ vec<pre_expr> exprs = sorted_array_from_bitmap_set (set);
pre_expr expr;
int i;
- FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+ FOR_EACH_VEC_ELT (exprs, i, expr)
{
if (!valid_in_sets (set, NULL, expr, block))
bitmap_remove_from_set (set, expr);
}
- VEC_free (pre_expr, heap, exprs);
+ exprs.release ();
}
/* Clean the set of expressions that are no longer valid in SET because
phis to translate through. */
else
{
- VEC(basic_block, heap) * worklist;
+ vec<basic_block> worklist;
size_t i;
basic_block bprime, first = NULL;
- worklist = VEC_alloc (basic_block, heap, EDGE_COUNT (block->succs));
+ worklist.create (EDGE_COUNT (block->succs));
FOR_EACH_EDGE (e, ei, block->succs)
{
if (!first
&& BB_VISITED (e->dest))
first = e->dest;
else if (BB_VISITED (e->dest))
- VEC_quick_push (basic_block, worklist, e->dest);
+ worklist.quick_push (e->dest);
}
/* Of multiple successors we have to have visited one already. */
BB_VISITED (block) = 0;
BB_DEFERRED (block) = 1;
changed = true;
- VEC_free (basic_block, heap, worklist);
+ worklist.release ();
goto maybe_dump_sets;
}
else
bitmap_set_copy (ANTIC_OUT, ANTIC_IN (first));
- FOR_EACH_VEC_ELT (basic_block, worklist, i, bprime)
+ FOR_EACH_VEC_ELT (worklist, i, bprime)
{
if (!gimple_seq_empty_p (phi_nodes (bprime)))
{
else
bitmap_set_and (ANTIC_OUT, ANTIC_IN (bprime));
}
- VEC_free (basic_block, heap, worklist);
+ worklist.release ();
}
/* Prune expressions that are clobbered in block and thus become
them. */
else
{
- VEC(basic_block, heap) * worklist;
+ vec<basic_block> worklist;
size_t i;
basic_block bprime;
- worklist = VEC_alloc (basic_block, heap, EDGE_COUNT (block->succs));
+ worklist.create (EDGE_COUNT (block->succs));
FOR_EACH_EDGE (e, ei, block->succs)
{
if (e->flags & EDGE_DFS_BACK)
continue;
- VEC_quick_push (basic_block, worklist, e->dest);
+ worklist.quick_push (e->dest);
}
- if (VEC_length (basic_block, worklist) > 0)
+ if (worklist.length () > 0)
{
- FOR_EACH_VEC_ELT (basic_block, worklist, i, bprime)
+ FOR_EACH_VEC_ELT (worklist, i, bprime)
{
unsigned int i;
bitmap_iterator bi;
expression_for_id (i));
}
}
- VEC_free (basic_block, heap, worklist);
+ worklist.release ();
}
/* Prune expressions that are clobbered in block and thus become
create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref,
unsigned int *operand, gimple_seq *stmts)
{
- vn_reference_op_t currop = &VEC_index (vn_reference_op_s, ref->operands,
- *operand);
+ vn_reference_op_t currop = &ref->operands[*operand];
tree genop;
++*operand;
switch (currop->opcode)
fn = find_or_generate_expression (block, currop->op0, stmts);
if (currop->op1)
sc = find_or_generate_expression (block, currop->op1, stmts);
- args = XNEWVEC (tree, VEC_length (vn_reference_op_s,
- ref->operands) - 1);
- while (*operand < VEC_length (vn_reference_op_s, ref->operands))
+ args = XNEWVEC (tree, ref->operands.length () - 1);
+ while (*operand < ref->operands.length ())
{
args[nargs] = create_component_ref_by_pieces_1 (block, ref,
operand, stmts);
case TARGET_MEM_REF:
{
tree genop0 = NULL_TREE, genop1 = NULL_TREE;
- vn_reference_op_t nextop = &VEC_index (vn_reference_op_s, ref->operands,
- ++*operand);
+ vn_reference_op_t nextop = &ref->operands[++*operand];
tree baseop = create_component_ref_by_pieces_1 (block, ref, operand,
stmts);
if (currop->op0)
}
/* It must be a complex expression, so generate it recursively. */
- bitmap exprset = VEC_index (bitmap, value_expressions, lookfor);
+ bitmap exprset = value_expressions[lookfor];
bitmap_iterator bi;
unsigned int i;
EXECUTE_IF_SET_IN_BITMAP (exprset, 0, i, bi)
}
if (nary->opcode == CONSTRUCTOR)
{
- VEC(constructor_elt,gc) *elts = NULL;
+ vec<constructor_elt, va_gc> *elts = NULL;
for (i = 0; i < nary->length; ++i)
CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE, genop[i]);
folded = build_constructor (nary->type, elts);
inhibit_phi_insertion (basic_block bb, pre_expr expr)
{
vn_reference_t vr = PRE_EXPR_REFERENCE (expr);
- VEC (vn_reference_op_s, heap) *ops = vr->operands;
+ vec<vn_reference_op_s> ops = vr->operands;
vn_reference_op_t op;
unsigned i;
memory reference is a simple induction variable. In other
cases the vectorizer won't do anything anyway (either it's
loop invariant or a complicated expression). */
- FOR_EACH_VEC_ELT (vn_reference_op_s, ops, i, op)
+ FOR_EACH_VEC_ELT (ops, i, op)
{
switch (op->opcode)
{
static bool
insert_into_preds_of_block (basic_block block, unsigned int exprnum,
- VEC(pre_expr, heap) *avail)
+ vec<pre_expr> avail)
{
pre_expr expr = expression_for_id (exprnum);
pre_expr newphi;
gimple_seq stmts = NULL;
tree builtexpr;
bprime = pred->src;
- eprime = VEC_index (pre_expr, avail, pred->dest_idx);
+ eprime = avail[pred->dest_idx];
if (eprime->kind != NAME && eprime->kind != CONSTANT)
{
&stmts, type);
gcc_assert (!(pred->flags & EDGE_ABNORMAL));
gsi_insert_seq_on_edge (pred, stmts);
- VEC_replace (pre_expr, avail, pred->dest_idx,
- get_or_alloc_expr_for_name (builtexpr));
+ avail[pred->dest_idx] = get_or_alloc_expr_for_name (builtexpr);
insertions = true;
}
else if (eprime->kind == CONSTANT)
}
gsi_insert_seq_on_edge (pred, stmts);
}
- VEC_replace (pre_expr, avail, pred->dest_idx,
- get_or_alloc_expr_for_name (forcedexpr));
+ avail[pred->dest_idx]
+ = get_or_alloc_expr_for_name (forcedexpr);
}
}
else
- VEC_replace (pre_expr, avail, pred->dest_idx,
- get_or_alloc_expr_for_constant (builtexpr));
+ avail[pred->dest_idx]
+ = get_or_alloc_expr_for_constant (builtexpr);
}
}
else if (eprime->kind == NAME)
}
gsi_insert_seq_on_edge (pred, stmts);
}
- VEC_replace (pre_expr, avail, pred->dest_idx,
- get_or_alloc_expr_for_name (forcedexpr));
+ avail[pred->dest_idx] = get_or_alloc_expr_for_name (forcedexpr);
}
}
}
bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (temp));
FOR_EACH_EDGE (pred, ei, block->preds)
{
- pre_expr ae = VEC_index (pre_expr, avail, pred->dest_idx);
+ pre_expr ae = avail[pred->dest_idx];
gcc_assert (get_expr_type (ae) == type
|| useless_type_conversion_p (type, get_expr_type (ae)));
if (ae->kind == CONSTANT)
do_regular_insertion (basic_block block, basic_block dom)
{
bool new_stuff = false;
- VEC (pre_expr, heap) *exprs;
+ vec<pre_expr> exprs;
pre_expr expr;
- VEC (pre_expr, heap) *avail = NULL;
+ vec<pre_expr> avail = vec<pre_expr>();
int i;
exprs = sorted_array_from_bitmap_set (ANTIC_IN (block));
- VEC_safe_grow (pre_expr, heap, avail, EDGE_COUNT (block->preds));
+ avail.safe_grow (EDGE_COUNT (block->preds));
- FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+ FOR_EACH_VEC_ELT (exprs, i, expr)
{
if (expr->kind != NAME)
{
rest of the results are. */
if (eprime == NULL)
{
- VEC_replace (pre_expr, avail, pred->dest_idx, NULL);
+ avail[pred->dest_idx] = NULL;
cant_insert = true;
break;
}
vprime);
if (edoubleprime == NULL)
{
- VEC_replace (pre_expr, avail, pred->dest_idx, eprime);
+ avail[pred->dest_idx] = eprime;
all_same = false;
}
else
{
- VEC_replace (pre_expr, avail, pred->dest_idx, edoubleprime);
+ avail[pred->dest_idx] = edoubleprime;
by_some = true;
/* We want to perform insertions to remove a redundancy on
a path in the CFG we want to optimize for speed. */
{
unsigned int j;
bitmap_iterator bi;
- bitmap exprset = VEC_index (bitmap, value_expressions, val);
+ bitmap exprset = value_expressions[val];
unsigned int new_val = get_expr_value_id (edoubleprime);
EXECUTE_IF_SET_IN_BITMAP (exprset, 0, j, bi)
}
}
- VEC_free (pre_expr, heap, exprs);
- VEC_free (pre_expr, heap, avail);
+ exprs.release ();
+ avail.release ();
return new_stuff;
}
do_partial_partial_insertion (basic_block block, basic_block dom)
{
bool new_stuff = false;
- VEC (pre_expr, heap) *exprs;
+ vec<pre_expr> exprs;
pre_expr expr;
- VEC (pre_expr, heap) *avail = NULL;
+ vec<pre_expr> avail = vec<pre_expr>();
int i;
exprs = sorted_array_from_bitmap_set (PA_IN (block));
- VEC_safe_grow (pre_expr, heap, avail, EDGE_COUNT (block->preds));
+ avail.safe_grow (EDGE_COUNT (block->preds));
- FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
+ FOR_EACH_VEC_ELT (exprs, i, expr)
{
if (expr->kind != NAME)
{
rest of the results are. */
if (eprime == NULL)
{
- VEC_replace (pre_expr, avail, pred->dest_idx, NULL);
+ avail[pred->dest_idx] = NULL;
cant_insert = true;
break;
}
eprime = fully_constant_expression (eprime);
vprime = get_expr_value_id (eprime);
edoubleprime = bitmap_find_leader (AVAIL_OUT (bprime), vprime);
- VEC_replace (pre_expr, avail, pred->dest_idx, edoubleprime);
+ avail[pred->dest_idx] = edoubleprime;
if (edoubleprime == NULL)
{
by_all = false;
}
}
- VEC_free (pre_expr, heap, exprs);
- VEC_free (pre_expr, heap, avail);
+ exprs.release ();
+ avail.release ();
return new_stuff;
}
{
vn_reference_t ref;
pre_expr result = NULL;
- VEC(vn_reference_op_s, heap) *ops = NULL;
+ vec<vn_reference_op_s> ops
+ = vec<vn_reference_op_s>();
/* We can value number only calls to real functions. */
if (gimple_call_internal_p (stmt))
vn_reference_lookup_pieces (gimple_vuse (stmt), 0,
gimple_expr_type (stmt),
ops, &ref, VN_NOWALK);
- VEC_free (vn_reference_op_s, heap, ops);
+ ops.release ();
if (!ref)
continue;
/* Local state for the eliminate domwalk. */
-static VEC (gimple, heap) *el_to_remove;
-static VEC (gimple, heap) *el_to_update;
+static vec<gimple> el_to_remove;
+static vec<gimple> el_to_update;
static unsigned int el_todo;
-static VEC (tree, heap) *el_avail;
-static VEC (tree, heap) *el_avail_stack;
+static vec<tree> el_avail;
+static vec<tree> el_avail_stack;
/* Return a leader for OP that is available at the current point of the
eliminate domwalk. */
{
if (SSA_NAME_IS_DEFAULT_DEF (valnum))
return valnum;
- if (VEC_length (tree, el_avail) > SSA_NAME_VERSION (valnum))
- return VEC_index (tree, el_avail, SSA_NAME_VERSION (valnum));
+ if (el_avail.length () > SSA_NAME_VERSION (valnum))
+ return el_avail[SSA_NAME_VERSION (valnum)];
}
else if (is_gimple_min_invariant (valnum))
return valnum;
tree valnum = VN_INFO (op)->valnum;
if (TREE_CODE (valnum) == SSA_NAME)
{
- if (VEC_length (tree, el_avail) <= SSA_NAME_VERSION (valnum))
- VEC_safe_grow_cleared (tree, heap,
- el_avail, SSA_NAME_VERSION (valnum) + 1);
- VEC_replace (tree, el_avail, SSA_NAME_VERSION (valnum), op);
- VEC_safe_push (tree, heap, el_avail_stack, op);
+ if (el_avail.length () <= SSA_NAME_VERSION (valnum))
+ el_avail.safe_grow_cleared (SSA_NAME_VERSION (valnum) + 1);
+ el_avail[SSA_NAME_VERSION (valnum)] = op;
+ el_avail_stack.safe_push (op);
}
}
gimple stmt;
/* Mark new bb. */
- VEC_safe_push (tree, heap, el_avail_stack, NULL_TREE);
+ el_avail_stack.safe_push (NULL_TREE);
for (gsi = gsi_start_phis (b); !gsi_end_p (gsi);)
{
gsi2 = gsi_after_labels (b);
gsi_insert_before (&gsi2, stmt, GSI_NEW_STMT);
/* Queue the copy for eventual removal. */
- VEC_safe_push (gimple, heap, el_to_remove, stmt);
+ el_to_remove.safe_push (stmt);
/* If we inserted this PHI node ourself, it's not an elimination. */
if (inserted_exprs
&& bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res)))
}
/* Queue stmt for removal. */
- VEC_safe_push (gimple, heap, el_to_remove, stmt);
+ el_to_remove.safe_push (stmt);
}
}
/* Visit COND_EXPRs and fold the comparison with the
}
gimple_call_set_fn (stmt, fn);
- VEC_safe_push (gimple, heap, el_to_update, stmt);
+ el_to_update.safe_push (stmt);
/* When changing a call into a noreturn call, cfg cleanup
is needed to fix up the noreturn call. */
eliminate_leave_block (dom_walk_data *, basic_block)
{
tree entry;
- while ((entry = VEC_pop (tree, el_avail_stack)) != NULL_TREE)
- VEC_replace (tree, el_avail,
- SSA_NAME_VERSION (VN_INFO (entry)->valnum), NULL_TREE);
+ while ((entry = el_avail_stack.pop ()) != NULL_TREE)
+ el_avail[SSA_NAME_VERSION (VN_INFO (entry)->valnum)] = NULL_TREE;
}
/* Eliminate fully redundant computations. */
need_eh_cleanup = BITMAP_ALLOC (NULL);
need_ab_cleanup = BITMAP_ALLOC (NULL);
- el_to_remove = NULL;
- el_to_update = NULL;
+ el_to_remove.create (0);
+ el_to_update.create (0);
el_todo = 0;
- el_avail = NULL;
- el_avail_stack = NULL;
+ el_avail.create (0);
+ el_avail_stack.create (0);
walk_data.dom_direction = CDI_DOMINATORS;
walk_data.initialize_block_local_data = NULL;
walk_dominator_tree (&walk_data, ENTRY_BLOCK_PTR);
fini_walk_dominator_tree (&walk_data);
- VEC_free (tree, heap, el_avail);
- VEC_free (tree, heap, el_avail_stack);
+ el_avail.release ();
+ el_avail_stack.release ();
/* We cannot remove stmts during BB walk, especially not release SSA
names there as this confuses the VN machinery. The stmts ending
up in el_to_remove are either stores or simple copies. */
- FOR_EACH_VEC_ELT (gimple, el_to_remove, i, stmt)
+ FOR_EACH_VEC_ELT (el_to_remove, i, stmt)
{
tree lhs = gimple_assign_lhs (stmt);
tree rhs = gimple_assign_rhs1 (stmt);
release_defs (stmt);
}
}
- VEC_free (gimple, heap, el_to_remove);
+ el_to_remove.release ();
/* We cannot update call statements with virtual operands during
SSA walk. This might remove them which in turn makes our
VN lattice invalid. */
- FOR_EACH_VEC_ELT (gimple, el_to_update, i, stmt)
+ FOR_EACH_VEC_ELT (el_to_update, i, stmt)
update_stmt (stmt);
- VEC_free (gimple, heap, el_to_update);
+ el_to_update.release ();
return el_todo;
}
basic_block bb;
next_expression_id = 1;
- expressions = NULL;
- VEC_safe_push (pre_expr, heap, expressions, NULL);
- value_expressions = VEC_alloc (bitmap, heap, get_max_value_id () + 1);
- VEC_safe_grow_cleared (bitmap, heap, value_expressions,
- get_max_value_id() + 1);
- name_to_id = NULL;
+ expressions.create (0);
+ expressions.safe_push (NULL);
+ value_expressions.create (get_max_value_id () + 1);
+ value_expressions.safe_grow_cleared (get_max_value_id() + 1);
+ name_to_id.create (0);
inserted_exprs = BITMAP_ALLOC (NULL);
fini_pre ()
{
free (postorder);
- VEC_free (bitmap, heap, value_expressions);
+ value_expressions.release ();
BITMAP_FREE (inserted_exprs);
bitmap_obstack_release (&grand_bitmap_obstack);
free_alloc_pool (bitmap_set_pool);
free_alloc_pool (pre_expr_pool);
phi_translate_table.dispose ();
expression_to_id.dispose ();
- VEC_free (unsigned, heap, name_to_id);
+ name_to_id.release ();
free_aux_for_blocks ();
projects / thirdparty / gcc.git / blobdiff