diff options
Diffstat (limited to 'gcc/tree-ssa-pre.c')
| -rw-r--r-- | gcc/tree-ssa-pre.c | 307 |
1 files changed, 146 insertions, 161 deletions
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index 6876dd4..00b88bf 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -233,11 +233,9 @@ pre_expr_d::hash (const value_type *e) 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. */ @@ -248,18 +246,18 @@ alloc_expression_id (pre_expr 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 { @@ -286,9 +284,9 @@ lookup_expression_id (const pre_expr expr) 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 { @@ -316,7 +314,7 @@ get_or_alloc_expression_id (pre_expr expr) 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, @@ -325,7 +323,7 @@ expression_for_id (unsigned int id) static void clear_expression_ids (void) { - VEC_free (pre_expr, heap, expressions); + expressions.release (); } static alloc_pool pre_expr_pool; @@ -368,7 +366,7 @@ typedef struct bitmap_set 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 @@ -583,16 +581,16 @@ add_to_value (unsigned int v, pre_expr e) 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)); @@ -645,7 +643,7 @@ sccvn_valnum_from_value_id (unsigned int val) { 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); @@ -712,15 +710,15 @@ bitmap_set_free (bitmap_set_t set) /* 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) { @@ -734,11 +732,11 @@ sorted_array_from_bitmap_set (bitmap_set_t set) 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)); } } @@ -860,7 +858,7 @@ bitmap_set_replace_value (bitmap_set_t set, unsigned int lookfor, 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)) @@ -947,7 +945,7 @@ print_pre_expr (FILE *outfile, const pre_expr expr) 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; @@ -977,7 +975,7 @@ print_pre_expr (FILE *outfile, const pre_expr expr) } 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, "}"); @@ -1056,7 +1054,7 @@ debug_bitmap_sets_for (basic_block bb) 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; @@ -1111,7 +1109,7 @@ get_constant_for_value_id (unsigned int v) { 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) { @@ -1262,7 +1260,7 @@ fully_constant_expression (pre_expr e) 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) @@ -1393,7 +1391,7 @@ get_representative_for (const pre_expr e) 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); @@ -1512,9 +1510,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, 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, @@ -1535,17 +1531,18 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, 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; @@ -1593,12 +1590,11 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, } 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]); @@ -1620,18 +1616,16 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, 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; } @@ -1643,7 +1637,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, &same_valid); if (newvuse == NULL_TREE) { - VEC_free (vn_reference_op_s, heap, newoperands); + newoperands.release (); return NULL; } } @@ -1658,7 +1652,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, 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 @@ -1686,7 +1680,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, else if (!result && newref && !useless_type_conversion_p (ref->type, newref->type)) { - VEC_free (vn_reference_op_s, heap, newoperands); + newoperands.release (); return NULL; } @@ -1709,9 +1703,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, 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; @@ -1719,7 +1711,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, 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) @@ -1728,7 +1720,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, } add_to_value (new_val_id, expr); } - VEC_free (vn_reference_op_s, heap, newoperands); + newoperands.release (); return expr; } break; @@ -1807,7 +1799,7 @@ static void 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; @@ -1818,7 +1810,7 @@ phi_translate_set (bitmap_set_t dest, bitmap_set_t set, basic_block pred, } 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); @@ -1834,7 +1826,7 @@ phi_translate_set (bitmap_set_t dest, bitmap_set_t set, basic_block pred, 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 @@ -1849,7 +1841,7 @@ bitmap_find_leader (bitmap_set_t set, unsigned int val) { 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) { @@ -1873,7 +1865,7 @@ bitmap_find_leader (bitmap_set_t set, unsigned int val) 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); @@ -2007,7 +1999,7 @@ valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, pre_expr expr, 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) @@ -2030,16 +2022,16 @@ valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, pre_expr expr, 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 @@ -2049,16 +2041,16 @@ dependent_clean (bitmap_set_t set1, bitmap_set_t set2, basic_block block) 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 @@ -2198,18 +2190,18 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge) 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. */ @@ -2219,7 +2211,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge) BB_VISITED (block) = 0; BB_DEFERRED (block) = 1; changed = true; - VEC_free (basic_block, heap, worklist); + worklist.release (); goto maybe_dump_sets; } @@ -2228,7 +2220,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge) 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))) { @@ -2240,7 +2232,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge) 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 @@ -2362,20 +2354,20 @@ compute_partial_antic_aux (basic_block block, 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; @@ -2398,7 +2390,7 @@ compute_partial_antic_aux (basic_block block, expression_for_id (i)); } } - VEC_free (basic_block, heap, worklist); + worklist.release (); } /* Prune expressions that are clobbered in block and thus become @@ -2559,8 +2551,7 @@ static tree 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) @@ -2576,9 +2567,8 @@ create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref, 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); @@ -2618,8 +2608,7 @@ create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref, 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) @@ -2789,7 +2778,7 @@ find_or_generate_expression (basic_block block, tree op, gimple_seq *stmts) } /* 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) @@ -2874,7 +2863,7 @@ create_expression_by_pieces (basic_block block, pre_expr expr, } 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); @@ -2990,7 +2979,7 @@ static bool 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; @@ -3002,7 +2991,7 @@ inhibit_phi_insertion (basic_block bb, pre_expr expr) 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) { @@ -3048,7 +3037,7 @@ inhibit_phi_insertion (basic_block bb, pre_expr expr) 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; @@ -3089,7 +3078,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum, 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) { @@ -3097,8 +3086,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum, &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) @@ -3136,13 +3124,13 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum, } 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) @@ -3181,8 +3169,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum, } 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); } } } @@ -3207,7 +3194,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum, 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) @@ -3273,15 +3260,15 @@ static bool 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) { @@ -3329,7 +3316,7 @@ do_regular_insertion (basic_block block, basic_block dom) 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; } @@ -3340,12 +3327,12 @@ do_regular_insertion (basic_block block, basic_block dom) 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. */ @@ -3400,7 +3387,7 @@ do_regular_insertion (basic_block block, basic_block dom) { 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) @@ -3426,8 +3413,8 @@ do_regular_insertion (basic_block block, basic_block dom) } } - VEC_free (pre_expr, heap, exprs); - VEC_free (pre_expr, heap, avail); + exprs.release (); + avail.release (); return new_stuff; } @@ -3443,15 +3430,15 @@ static bool 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) { @@ -3493,7 +3480,7 @@ do_partial_partial_insertion (basic_block block, basic_block dom) 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; } @@ -3501,7 +3488,7 @@ do_partial_partial_insertion (basic_block block, basic_block dom) 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; @@ -3564,8 +3551,8 @@ do_partial_partial_insertion (basic_block block, basic_block dom) } } - VEC_free (pre_expr, heap, exprs); - VEC_free (pre_expr, heap, avail); + exprs.release (); + avail.release (); return new_stuff; } @@ -3800,7 +3787,8 @@ compute_avail (void) { 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)) @@ -3810,7 +3798,7 @@ compute_avail (void) 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; @@ -3938,11 +3926,11 @@ compute_avail (void) /* 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. */ @@ -3955,8 +3943,8 @@ eliminate_avail (tree op) { 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; @@ -3971,11 +3959,10 @@ eliminate_push_avail (tree op) 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); } } @@ -4024,7 +4011,7 @@ eliminate_bb (dom_walk_data *, basic_block b) 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);) { @@ -4082,7 +4069,7 @@ eliminate_bb (dom_walk_data *, basic_block b) 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))) @@ -4259,7 +4246,7 @@ eliminate_bb (dom_walk_data *, basic_block b) } /* 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 @@ -4318,7 +4305,7 @@ eliminate_bb (dom_walk_data *, basic_block b) } 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. */ @@ -4360,9 +4347,8 @@ static void 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. */ @@ -4378,11 +4364,11 @@ eliminate (void) 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; @@ -4394,13 +4380,13 @@ eliminate (void) 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); @@ -4437,14 +4423,14 @@ eliminate (void) 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; } @@ -4601,12 +4587,11 @@ init_pre (void) 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); @@ -4644,14 +4629,14 @@ static void 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 (); |