| Message ID | 20120812201126.GA14643@google.com |
|---|---|
| State | New |
| Headers | show |
On Sun, Aug 12, 2012 at 10:11 PM, Diego Novillo <dnovillo@google.com> wrote: > This implements the VEC re-write. > > See http://gcc.gnu.org/ml/gcc-patches/2012-08/msg00711.html for > details. It's an odd thing that you need to touch code replacing -> with . (yes, it's due to the use of references) but not at the same time convert those places to the new VEC interface. Anyway, you'll do that as a quick followup anyway. I suppose this one is ok. Thanks, Richard. > > Diego. > > 2012-08-12 Diego Novillo <dnovillo@google.com> > > Re-implement VEC in C++. > > * vec.c (vec_heap_free): Convert into a template function. > (vec_gc_o_reserve_1): Make extern. > (vec_gc_p_reserve): Remove. > (vec_gc_p_reserve_exact): Remove. > (vec_gc_o_reserve): Remove. > (vec_gc_o_reserve_exact): Remove. > (vec_heap_o_reserve_1): Make extern. > (vec_heap_p_reserve): Remove. > (vec_heap_p_reserve_exact): Remove. > (vec_heap_o_reserve): Remove. > (vec_heap_o_reserve_exact): Remove. > (vec_stack_p_reserve): Remove. > (vec_stack_p_reserve_exact): Remove. > * vec.h (VEC_CHECK_INFO, VEC_CHECK_DECL, VEC_CHECK_PASS, > VEC_ASSERT, VEC_ASSERT_FAIL, vec_assert_fail): Move earlier > in the file. > (VEC): Define to vec_t<T>. > (vec_allocation_t): Define. > (struct vec_prefix): Move earlier in the file. > (vec_t<T>): New template. > (DEF_VEC_I, DEF_VECL_ALLOC_I, DEF_VEC_P, DEF_VEC_ALLOC_P, > DEF_VEC_O, DEF_VEC_ALLOC_P, DEF_VEC_O, DEF_VEC_ALLOC_O, > DEF_VEC_ALLOC_P_STACK, DEF_VEC_ALLOC_O_STACK, > DEF_VEC_ALLOC_I_STACK): Expand to 'struct vec_swallow_trailing_semi'. > (DEF_VEC_A): Provide template instantiations for > GC/PCH markers that do not traverse the vector. > (vec_stack_p_reserve): Remove. > (vec_stack_p_reserve_exact): Remove. > (vec_stack_p_reserve_exact_1): Remove. > (vec_stack_o_reserve): Remove. > (vec_stack_o_reserve_exact): Remove. > (vec_stack_free): Re-write as a template function. > (vec_reserve): New template function. > (vec_reserve_exact): New template function. > (vec_heap_free): New template function if GATHER_STATISTICS is > defined. Otherwise, macro that expands to free(). > (VEC_length_1): New template function. > (VEC_length): Call it. > (VEC_empty_1): New template function. > (VEC_empty): Call it. > (VEC_address_1): New template function. > (VEC_address): Call it. > (VEC_last_1): New template function. > (VEC_last): Call it. Change return type to T&. > Change all users that used VEC_Os. > (VEC_index_1): New template function. > (VEC_index): Call it. Return a T& instead of a T*. > Update all callers that were using VEC_O before. > (VEC_iterate_1): New template function. > (VEC_iterate): Call it. > (VEC_embedded_size_1): New template function. > (VEC_embedded_size): Call it. > (VEC_embedded_init_1): New template function. > (VEC_embedded_init): Call it. > (VEC_alloc_1): New template function. > (VEC_alloc): Call it. If A is 'stack', call XALLOCAVAR to > do the allocation. > (VEC_free_1): New template function. > (VEC_free): Call it. > (VEC_copy_1): New template function. > (VEC_copy): Call it. > (VEC_space_1): New template function > (VEC_space): Call it. > (VEC_reserve_1): New template function. > (VEC_reserve): Call it. > (VEC_reserve_exact_1): New template function. > (VEC_reserve_exact): Call it. > (VEC_splice_1): New template function. > (VEC_splice): Call it. > (VEC_safe_splice_1): New template function. > (VEC_safe_splice): Call it. > (VEC_quick_push_1): New template function. Create two overloads, one > accepting T, the other accepting T *. Update all callers > where T and T * are ambiguous. > (VEC_quick_push): Call it. > (VEC_safe_push_1): New template function. Create two overloads, one > accepting T, the other accepting T *. Update all callers > where T and T * are ambiguous. > (VEC_safe_push): Call it. > (VEC_pop_1): New template function. > (VEC_pop): Call it. > (VEC_truncate_1): New template function. > (VEC_truncate): Call it. > (VEC_safe_grow_1): New template function. > (VEC_safe_grow): Call it. > (VEC_safe_grow_cleared_1): New template function. > (VEC_safe_grow_cleared): Call it. > (VEC_replace_1): New template function. > (VEC_replace): Call it. Always accept T instead of T*. > Update all callers that used VEC_Os. > (VEC_quick_insert_1): New template function. > (VEC_quick_insert): Call it. > (VEC_safe_insert_1): New template function. > (VEC_safe_insert): Call it. > (VEC_ordered_remove_1): New template function. > (VEC_ordered_remove): Call it. > (VEC_unordered_remove_1): New template function. > (VEC_unordered_remove): Call it. > (VEC_block_remove_1): New template function. > (VEC_block_remove): Call it. > (VEC_lower_bound_1): New template function. > (VEC_lower_bound): Call it. > (VEC_OP): Remove. > (DEF_VEC_FUNC_P): Remove. > (DEF_VEC_ALLOC_FUNC_P): Remove. > (DEF_VEC_NONALLOC_FUNCS_P): Remove. > (DEF_VEC_FUNC_O): Remove. > (DEF_VEC_ALLOC_FUNC_O): Remove. > (DEF_VEC_NONALLOC_FUNCS_O): Remove. > (DEF_VEC_ALLOC_FUNC_I): Remove. > (DEF_VEC_NONALLOC_FUNCS_I): Remove. > (DEF_VEC_ALLOC_FUNC_P_STACK): Remove. > (DEF_VEC_ALLOC_FUNC_O_STACK): Remove. > (DEF_VEC_ALLOC_FUNC_I_STACK): Remove. > (vec_reserve_exact): New template function. > > * gengtype-lex.l (DEF_VEC_ALLOC_[IOP]/{EOID}): Remove. > * gengtype-parse.c (token_names): Remove DEF_VEC_ALLOC_[IOP]. > (typedef_name): Emit vec_t<C1> instead of VEC_C1_C2. > (def_vec_alloc): Remove. Update all callers. > * gengtype.c (filter_type_name): New. > (output_mangled_typename): Call it. > (write_func_for_structure): Likewise. > (write_types): Likewise. > (write_root): Likewise. > (write_typed_alloc_def): Likewise. > (note_def_vec): Emit vec_t<TYPE_NAME> instead of VEC_TYPE_NAME_base. > (note_def_vec_alloc): Remove. > * gengtype.h (note_def_vec_alloc): Remove. > (DEFVEC_ALLOC): Remove token code. > > * df-scan.c (df_bb_verify): Remove call to df_free_collection_rec > inside the insn traversal loop. > * gimplify.c (gimplify_compound_lval): Rename STACK to EXPR_STACK. > * ipa-inline.c (inline_small_functions): Rename HEAP to EDGE_HEAP. > * reg-stack.c (stack): Rename to STACK_PTR. Update all users. > * tree-vrp.c (stack): Rename to EQUIV_STACK. Update all users. > > * config/bfin/bfin.c (hwloop_optimize): Update some calls to > VEC_* for vectors of non-pointers. > * config/c6x/c6x.c (try_rename_operands): Likewise. > (reshuffle_units): Likewise. > * config/mips/mips.c (mips_multi_start): Likewise. > (mips_multi_add): Likewise. > (mips_multi_copy_insn): Likewise. > (mips_multi_set_operand): Likewise. > * hw-doloop.c (discover_loop): Likewise. > (discover_loops): Likewise. > (reorg_loops): Likewise. > > diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c > index 1b1bca8..cd35cd1 100644 > --- a/gcc/ada/gcc-interface/trans.c > +++ b/gcc/ada/gcc-interface/trans.c > @@ -2921,7 +2921,7 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) > = VEC_index (constructor_elt, > CONSTRUCTOR_ELTS > (TREE_OPERAND (TREE_OPERAND (ret_val, 0), 1)), > - 1)->value; > + 1).value; > else > ret_val = TREE_OPERAND (TREE_OPERAND (ret_val, 0), 1); > } > @@ -2980,7 +2980,7 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) > TREE_OPERAND (alloc, 0), > VEC_index (constructor_elt, > CONSTRUCTOR_ELTS (TREE_OPERAND (alloc, 1)), > - 0)->value); > + 0).value); > > /* Build a modified CONSTRUCTOR that references NEW_VAR. */ > p_array = TYPE_FIELDS (TREE_TYPE (alloc)); > @@ -2990,7 +2990,7 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) > VEC_index (constructor_elt, > CONSTRUCTOR_ELTS > (TREE_OPERAND (alloc, 1)), > - 1)->value); > + 1).value); > new_ret = build_constructor (TREE_TYPE (alloc), v); > } > else > diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c > index cd91873..c9b29ad 100644 > --- a/gcc/ada/gcc-interface/utils.c > +++ b/gcc/ada/gcc-interface/utils.c > @@ -4491,10 +4491,10 @@ convert (tree type, tree expr) > inner expression. */ > if (TREE_CODE (expr) == CONSTRUCTOR > && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (expr)) > - && VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0)->index > + && VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0).index > == TYPE_FIELDS (etype)) > unpadded > - = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0)->value; > + = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0).value; > > /* Otherwise, build an explicit component reference. */ > else > @@ -5047,7 +5047,7 @@ remove_conversions (tree exp, bool true_address) > && TYPE_JUSTIFIED_MODULAR_P (TREE_TYPE (exp))) > return > remove_conversions (VEC_index (constructor_elt, > - CONSTRUCTOR_ELTS (exp), 0)->value, > + CONSTRUCTOR_ELTS (exp), 0).value, > true); > break; > > diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c > index a8a21a6..4578114 100644 > --- a/gcc/ada/gcc-interface/utils2.c > +++ b/gcc/ada/gcc-interface/utils2.c > @@ -441,7 +441,7 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) > > /* The constant folder doesn't fold fat pointer types so we do it here. */ > if (TREE_CODE (p1) == CONSTRUCTOR) > - p1_array = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p1), 0)->value; > + p1_array = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p1), 0).value; > else > p1_array = build_component_ref (p1, NULL_TREE, > TYPE_FIELDS (TREE_TYPE (p1)), true); > @@ -452,7 +452,7 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) > null_pointer_node)); > > if (TREE_CODE (p2) == CONSTRUCTOR) > - p2_array = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p2), 0)->value; > + p2_array = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p2), 0).value; > else > p2_array = build_component_ref (p2, NULL_TREE, > TYPE_FIELDS (TREE_TYPE (p2)), true); > @@ -473,14 +473,14 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) > = fold_build2_loc (loc, EQ_EXPR, result_type, p1_array, p2_array); > > if (TREE_CODE (p1) == CONSTRUCTOR) > - p1_bounds = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p1), 1)->value; > + p1_bounds = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p1), 1).value; > else > p1_bounds > = build_component_ref (p1, NULL_TREE, > DECL_CHAIN (TYPE_FIELDS (TREE_TYPE (p1))), true); > > if (TREE_CODE (p2) == CONSTRUCTOR) > - p2_bounds = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p2), 1)->value; > + p2_bounds = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p2), 1).value; > else > p2_bounds > = build_component_ref (p2, NULL_TREE, > @@ -1336,7 +1336,7 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand) > { > result = VEC_index (constructor_elt, > CONSTRUCTOR_ELTS (operand), > - 0)->value; > + 0).value; > result = convert (build_pointer_type (TREE_TYPE (operand)), > build_unary_op (ADDR_EXPR, NULL_TREE, result)); > break; > @@ -2676,9 +2676,9 @@ gnat_stabilize_reference (tree ref, bool force, bool *success) > && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (ref)) == 1) > { > tree index > - = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ref), 0)->index; > + = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ref), 0).index; > tree value > - = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ref), 0)->value; > + = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ref), 0).value; > result > = build_constructor_single (type, index, > gnat_stabilize_reference_1 (value, > diff --git a/gcc/alias.c b/gcc/alias.c > index a105004..de7640f 100644 > --- a/gcc/alias.c > +++ b/gcc/alias.c > @@ -852,8 +852,8 @@ new_alias_set (void) > if (flag_strict_aliasing) > { > if (alias_sets == 0) > - VEC_safe_push (alias_set_entry, gc, alias_sets, 0); > - VEC_safe_push (alias_set_entry, gc, alias_sets, 0); > + VEC_safe_push (alias_set_entry, gc, alias_sets, (alias_set_entry) 0); > + VEC_safe_push (alias_set_entry, gc, alias_sets, (alias_set_entry) 0); > return VEC_length (alias_set_entry, alias_sets) - 1; > } > else > diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c > index a002541..ab3eb0a 100644 > --- a/gcc/c-family/c-common.c > +++ b/gcc/c-family/c-common.c > @@ -8392,7 +8392,7 @@ parse_optimize_options (tree args, bool attr_p) > /* Build up argv vector. Just in case the string is stored away, use garbage > collected strings. */ > VEC_truncate (const_char_p, optimize_args, 0); > - VEC_safe_push (const_char_p, gc, optimize_args, NULL); > + VEC_safe_push (const_char_p, gc, optimize_args, (const_char_p)NULL); > > for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap)) > { > @@ -9390,10 +9390,10 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default) > constructor_elt *ce; > bool fold_p = false; > > - if (VEC_index (constructor_elt, v, 0)->index) > + if (VEC_index (constructor_elt, v, 0).index) > maxindex = fold_convert_loc (input_location, sizetype, > VEC_index (constructor_elt, > - v, 0)->index); > + v, 0).index); > curindex = maxindex; > > for (cnt = 1; > diff --git a/gcc/c-family/c-pragma.c b/gcc/c-family/c-pragma.c > index 830ca81..77ed0f0 100644 > --- a/gcc/c-family/c-pragma.c > +++ b/gcc/c-family/c-pragma.c > @@ -1209,9 +1209,9 @@ c_pp_lookup_pragma (unsigned int id, const char **space, const char **name) > + VEC_length (pragma_ns_name, registered_pp_pragmas))) > { > *space = VEC_index (pragma_ns_name, registered_pp_pragmas, > - id - PRAGMA_FIRST_EXTERNAL)->space; > + id - PRAGMA_FIRST_EXTERNAL).space; > *name = VEC_index (pragma_ns_name, registered_pp_pragmas, > - id - PRAGMA_FIRST_EXTERNAL)->name; > + id - PRAGMA_FIRST_EXTERNAL).name; > return; > } > > @@ -1334,7 +1334,7 @@ c_invoke_pragma_handler (unsigned int id) > pragma_handler_2arg handler_2arg; > > id -= PRAGMA_FIRST_EXTERNAL; > - ihandler = VEC_index (internal_pragma_handler, registered_pragmas, id); > + ihandler = &VEC_index (internal_pragma_handler, registered_pragmas, id); > if (ihandler->extra_data) > { > handler_2arg = ihandler->handler.handler_2arg; > diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c > index 09df65d..e5d17b7 100644 > --- a/gcc/c/c-decl.c > +++ b/gcc/c/c-decl.c > @@ -3932,7 +3932,7 @@ add_flexible_array_elts_to_size (tree decl, tree init) > if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))) > return; > > - elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value; > + elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init)).value; > type = TREE_TYPE (elt); > if (TREE_CODE (type) == ARRAY_TYPE > && TYPE_SIZE (type) == NULL_TREE > diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c > index 2237749..34d5a34 100644 > --- a/gcc/c/c-parser.c > +++ b/gcc/c/c-parser.c > @@ -6529,9 +6529,9 @@ c_parser_postfix_expression (c_parser *parser) > break; > } > > - e1_p = VEC_index (c_expr_t, cexpr_list, 0); > - e2_p = VEC_index (c_expr_t, cexpr_list, 1); > - e3_p = VEC_index (c_expr_t, cexpr_list, 2); > + e1_p = &VEC_index (c_expr_t, cexpr_list, 0); > + e2_p = &VEC_index (c_expr_t, cexpr_list, 1); > + e3_p = &VEC_index (c_expr_t, cexpr_list, 2); > > c = e1_p->value; > mark_exp_read (e2_p->value); > @@ -6611,8 +6611,8 @@ c_parser_postfix_expression (c_parser *parser) > break; > } > > - e1_p = VEC_index (c_expr_t, cexpr_list, 0); > - e2_p = VEC_index (c_expr_t, cexpr_list, 1); > + e1_p = &VEC_index (c_expr_t, cexpr_list, 0); > + e2_p = &VEC_index (c_expr_t, cexpr_list, 1); > > mark_exp_read (e1_p->value); > if (TREE_CODE (e1_p->value) == EXCESS_PRECISION_EXPR) > @@ -6671,15 +6671,15 @@ c_parser_postfix_expression (c_parser *parser) > if (VEC_length (c_expr_t, cexpr_list) == 2) > expr.value = > c_build_vec_perm_expr > - (loc, VEC_index (c_expr_t, cexpr_list, 0)->value, > - NULL_TREE, VEC_index (c_expr_t, cexpr_list, 1)->value); > + (loc, VEC_index (c_expr_t, cexpr_list, 0).value, > + NULL_TREE, VEC_index (c_expr_t, cexpr_list, 1).value); > > else if (VEC_length (c_expr_t, cexpr_list) == 3) > expr.value = > c_build_vec_perm_expr > - (loc, VEC_index (c_expr_t, cexpr_list, 0)->value, > - VEC_index (c_expr_t, cexpr_list, 1)->value, > - VEC_index (c_expr_t, cexpr_list, 2)->value); > + (loc, VEC_index (c_expr_t, cexpr_list, 0).value, > + VEC_index (c_expr_t, cexpr_list, 1).value, > + VEC_index (c_expr_t, cexpr_list, 2).value); > else > { > error_at (loc, "wrong number of arguments to " > diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c > index c2f713e..5b710c3 100644 > --- a/gcc/c/c-typeck.c > +++ b/gcc/c/c-typeck.c > @@ -6950,7 +6950,7 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack) > bool constructor_zeroinit = > (VEC_length (constructor_elt, constructor_elements) == 1 > && integer_zerop > - (VEC_index (constructor_elt, constructor_elements, 0)->value)); > + (VEC_index (constructor_elt, constructor_elements, 0).value)); > > /* Do not warn for flexible array members or zero-length arrays. */ > while (constructor_unfilled_fields > @@ -6997,10 +6997,10 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack) > else if (VEC_length (constructor_elt,constructor_elements) != 1) > { > error_init ("extra elements in scalar initializer"); > - ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; > + ret.value = VEC_index (constructor_elt,constructor_elements,0).value; > } > else > - ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; > + ret.value = VEC_index (constructor_elt,constructor_elements,0).value; > } > else > { > @@ -7671,9 +7671,9 @@ find_init_member (tree field, struct obstack * braced_init_obstack) > else if (TREE_CODE (constructor_type) == UNION_TYPE) > { > if (!VEC_empty (constructor_elt, constructor_elements) > - && (VEC_last (constructor_elt, constructor_elements)->index > + && (VEC_last (constructor_elt, constructor_elements).index > == field)) > - return VEC_last (constructor_elt, constructor_elements)->value; > + return VEC_last (constructor_elt, constructor_elements).value; > } > return 0; > } > @@ -7856,7 +7856,7 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type, > if (!implicit) > { > if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt, > - constructor_elements)->value)) > + constructor_elements).value)) > warning_init (0, > "initialized field with side-effects overwritten"); > else if (warn_override_init) > diff --git a/gcc/combine.c b/gcc/combine.c > index 2b91eb9..3c4dee8 100644 > --- a/gcc/combine.c > +++ b/gcc/combine.c > @@ -1587,7 +1587,7 @@ set_nonzero_bits_and_sign_copies (rtx x, const_rtx set, void *data) > (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x)) > && HWI_COMPUTABLE_MODE_P (GET_MODE (x))) > { > - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x)); > + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, REGNO (x)); > > if (set == 0 || GET_CODE (set) == CLOBBER) > { > @@ -3635,21 +3635,21 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p, > && ! (temp = SET_DEST (XVECEXP (newpat, 0, 1)), > (REG_P (temp) > && VEC_index (reg_stat_type, reg_stat, > - REGNO (temp))->nonzero_bits != 0 > + REGNO (temp)).nonzero_bits != 0 > && GET_MODE_PRECISION (GET_MODE (temp)) < BITS_PER_WORD > && GET_MODE_PRECISION (GET_MODE (temp)) < HOST_BITS_PER_INT > && (VEC_index (reg_stat_type, reg_stat, > - REGNO (temp))->nonzero_bits > + REGNO (temp)).nonzero_bits > != GET_MODE_MASK (word_mode)))) > && ! (GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) == SUBREG > && (temp = SUBREG_REG (SET_DEST (XVECEXP (newpat, 0, 1))), > (REG_P (temp) > && VEC_index (reg_stat_type, reg_stat, > - REGNO (temp))->nonzero_bits != 0 > + REGNO (temp)).nonzero_bits != 0 > && GET_MODE_PRECISION (GET_MODE (temp)) < BITS_PER_WORD > && GET_MODE_PRECISION (GET_MODE (temp)) < HOST_BITS_PER_INT > && (VEC_index (reg_stat_type, reg_stat, > - REGNO (temp))->nonzero_bits > + REGNO (temp)).nonzero_bits > != GET_MODE_MASK (word_mode))))) > && ! reg_overlap_mentioned_p (SET_DEST (XVECEXP (newpat, 0, 1)), > SET_SRC (XVECEXP (newpat, 0, 1))) > @@ -9425,7 +9425,7 @@ reg_nonzero_bits_for_combine (const_rtx x, enum machine_mode mode, > value. Otherwise, use the previously-computed global nonzero bits > for this register. */ > > - rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x)); > + rsp = &VEC_index (reg_stat_type, reg_stat, REGNO (x)); > if (rsp->last_set_value != 0 > && (rsp->last_set_mode == mode > || (GET_MODE_CLASS (rsp->last_set_mode) == MODE_INT > @@ -9494,7 +9494,7 @@ reg_num_sign_bit_copies_for_combine (const_rtx x, enum machine_mode mode, > rtx tem; > reg_stat_type *rsp; > > - rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x)); > + rsp = &VEC_index (reg_stat_type, reg_stat, REGNO (x)); > if (rsp->last_set_value != 0 > && rsp->last_set_mode == mode > && ((rsp->last_set_label >= label_tick_ebb_start > @@ -12033,7 +12033,7 @@ update_table_tick (rtx x) > > for (r = regno; r < endregno; r++) > { > - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, r); > + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, r); > rsp->last_set_table_tick = label_tick; > } > > @@ -12135,7 +12135,7 @@ record_value_for_reg (rtx reg, rtx insn, rtx value) > register. */ > for (i = regno; i < endregno; i++) > { > - rsp = VEC_index (reg_stat_type, reg_stat, i); > + rsp = &VEC_index (reg_stat_type, reg_stat, i); > > if (insn) > rsp->last_set = insn; > @@ -12161,7 +12161,7 @@ record_value_for_reg (rtx reg, rtx insn, rtx value) > > for (i = regno; i < endregno; i++) > { > - rsp = VEC_index (reg_stat_type, reg_stat, i); > + rsp = &VEC_index (reg_stat_type, reg_stat, i); > rsp->last_set_label = label_tick; > if (!insn > || (value && rsp->last_set_table_tick >= label_tick_ebb_start)) > @@ -12173,7 +12173,7 @@ record_value_for_reg (rtx reg, rtx insn, rtx value) > /* The value being assigned might refer to X (like in "x++;"). In that > case, we must replace it with (clobber (const_int 0)) to prevent > infinite loops. */ > - rsp = VEC_index (reg_stat_type, reg_stat, regno); > + rsp = &VEC_index (reg_stat_type, reg_stat, regno); > if (value && !get_last_value_validate (&value, insn, label_tick, 0)) > { > value = copy_rtx (value); > @@ -12271,7 +12271,7 @@ record_dead_and_set_regs (rtx insn) > { > reg_stat_type *rsp; > > - rsp = VEC_index (reg_stat_type, reg_stat, i); > + rsp = &VEC_index (reg_stat_type, reg_stat, i); > rsp->last_death = insn; > } > } > @@ -12286,7 +12286,7 @@ record_dead_and_set_regs (rtx insn) > { > reg_stat_type *rsp; > > - rsp = VEC_index (reg_stat_type, reg_stat, i); > + rsp = &VEC_index (reg_stat_type, reg_stat, i); > rsp->last_set_invalid = 1; > rsp->last_set = insn; > rsp->last_set_value = 0; > @@ -12344,7 +12344,7 @@ record_promoted_value (rtx insn, rtx subreg) > continue; > } > > - rsp = VEC_index (reg_stat_type, reg_stat, regno); > + rsp = &VEC_index (reg_stat_type, reg_stat, regno); > if (rsp->last_set == insn) > { > if (SUBREG_PROMOTED_UNSIGNED_P (subreg) > 0) > @@ -12369,7 +12369,7 @@ record_promoted_value (rtx insn, rtx subreg) > static bool > reg_truncated_to_mode (enum machine_mode mode, const_rtx x) > { > - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x)); > + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, REGNO (x)); > enum machine_mode truncated = rsp->truncated_to_mode; > > if (truncated == 0 > @@ -12414,7 +12414,7 @@ record_truncated_value (rtx *p, void *data ATTRIBUTE_UNUSED) > else > return 0; > > - rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x)); > + rsp = &VEC_index (reg_stat_type, reg_stat, REGNO (x)); > if (rsp->truncated_to_mode == 0 > || rsp->truncation_label < label_tick_ebb_start > || (GET_MODE_SIZE (truncated_mode) > @@ -12493,7 +12493,7 @@ get_last_value_validate (rtx *loc, rtx insn, int tick, int replace) > > for (j = regno; j < endregno; j++) > { > - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, j); > + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, j); > if (rsp->last_set_invalid > /* If this is a pseudo-register that was only set once and not > live at the beginning of the function, it is always valid. */ > @@ -12597,7 +12597,7 @@ get_last_value (const_rtx x) > return 0; > > regno = REGNO (x); > - rsp = VEC_index (reg_stat_type, reg_stat, regno); > + rsp = &VEC_index (reg_stat_type, reg_stat, regno); > value = rsp->last_set_value; > > /* If we don't have a value, or if it isn't for this basic block and > @@ -12661,7 +12661,7 @@ use_crosses_set_p (const_rtx x, int from_luid) > #endif > for (; regno < endreg; regno++) > { > - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, regno); > + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, regno); > if (rsp->last_set > && rsp->last_set_label == label_tick > && DF_INSN_LUID (rsp->last_set) > from_luid) > @@ -12909,7 +12909,7 @@ move_deaths (rtx x, rtx maybe_kill_insn, int from_luid, rtx to_insn, > if (code == REG) > { > unsigned int regno = REGNO (x); > - rtx where_dead = VEC_index (reg_stat_type, reg_stat, regno)->last_death; > + rtx where_dead = VEC_index (reg_stat_type, reg_stat, regno).last_death; > > /* Don't move the register if it gets killed in between from and to. */ > if (maybe_kill_insn && reg_set_p (x, maybe_kill_insn) > @@ -13524,7 +13524,7 @@ distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2, rtx elim_i2, > if (place && REG_NOTE_KIND (note) == REG_DEAD) > { > unsigned int regno = REGNO (XEXP (note, 0)); > - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, regno); > + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, regno); > > if (dead_or_set_p (place, XEXP (note, 0)) > || reg_bitfield_target_p (XEXP (note, 0), PATTERN (place))) > diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c > index 3edb6e1..1702785 100644 > --- a/gcc/dwarf2cfi.c > +++ b/gcc/dwarf2cfi.c > @@ -2550,7 +2550,7 @@ create_cfi_notes (void) > gcc_checking_assert (trace_work_list == NULL); > > /* Always begin at the entry trace. */ > - ti = VEC_index (dw_trace_info, trace_info, 0); > + ti = &VEC_index (dw_trace_info, trace_info, 0); > scan_trace (ti); > > while (!VEC_empty (dw_trace_info_ref, trace_work_list)) > @@ -2597,7 +2597,7 @@ connect_traces (void) > /* Remove all unprocessed traces from the list. */ > for (i = n - 1; i > 0; --i) > { > - ti = VEC_index (dw_trace_info, trace_info, i); > + ti = &VEC_index (dw_trace_info, trace_info, i); > if (ti->beg_row == NULL) > { > VEC_ordered_remove (dw_trace_info, trace_info, i); > @@ -2609,13 +2609,13 @@ connect_traces (void) > > /* Work from the end back to the beginning. This lets us easily insert > remember/restore_state notes in the correct order wrt other notes. */ > - prev_ti = VEC_index (dw_trace_info, trace_info, n - 1); > + prev_ti = &VEC_index (dw_trace_info, trace_info, n - 1); > for (i = n - 1; i > 0; --i) > { > dw_cfi_row *old_row; > > ti = prev_ti; > - prev_ti = VEC_index (dw_trace_info, trace_info, i - 1); > + prev_ti = &VEC_index (dw_trace_info, trace_info, i - 1); > > add_cfi_insn = ti->head; > > @@ -2686,7 +2686,7 @@ connect_traces (void) > > for (i = 0; i < n; ++i) > { > - ti = VEC_index (dw_trace_info, trace_info, i); > + ti = &VEC_index (dw_trace_info, trace_info, i); > > if (ti->switch_sections) > prev_args_size = 0; > @@ -2884,8 +2884,8 @@ create_cie_data (void) > break; > case 1: > cie_return_save = ggc_alloc_reg_saved_in_data (); > - *cie_return_save = *VEC_index (reg_saved_in_data, > - cie_trace.regs_saved_in_regs, 0); > + *cie_return_save = VEC_index (reg_saved_in_data, > + cie_trace.regs_saved_in_regs, 0); > VEC_free (reg_saved_in_data, heap, cie_trace.regs_saved_in_regs); > break; > default: > diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c > index 4b67d82..4bc4cc3 100644 > --- a/gcc/dwarf2out.c > +++ b/gcc/dwarf2out.c > @@ -5821,7 +5821,7 @@ same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark) > return 0; > > FOR_EACH_VEC_ELT (dw_attr_node, die1->die_attr, ix, a1) > - if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark)) > + if (!same_attr_p (a1, &VEC_index (dw_attr_node, die2->die_attr, ix), mark)) > return 0; > > c1 = die1->die_child; > @@ -7072,7 +7072,7 @@ build_abbrev_table (dw_die_ref die, htab_t extern_map) > > FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, die_a) > { > - abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix); > + abbrev_a = &VEC_index (dw_attr_node, abbrev->die_attr, ix); > if ((abbrev_a->dw_attr != die_a->dw_attr) > || (value_format (abbrev_a) != value_format (die_a))) > { > @@ -20532,8 +20532,8 @@ optimize_macinfo_range (unsigned int idx, VEC (macinfo_entry, gc) *files, > unsigned int i, count, encoded_filename_len, linebuf_len; > void **slot; > > - first = VEC_index (macinfo_entry, macinfo_table, idx); > - second = VEC_index (macinfo_entry, macinfo_table, idx + 1); > + first = &VEC_index (macinfo_entry, macinfo_table, idx); > + second = &VEC_index (macinfo_entry, macinfo_table, idx + 1); > > /* Optimize only if there are at least two consecutive define/undef ops, > and either all of them are before first DW_MACINFO_start_file > @@ -20573,7 +20573,7 @@ optimize_macinfo_range (unsigned int idx, VEC (macinfo_entry, gc) *files, > if (VEC_empty (macinfo_entry, files)) > base = ""; > else > - base = lbasename (VEC_last (macinfo_entry, files)->info); > + base = lbasename (VEC_last (macinfo_entry, files).info); > for (encoded_filename_len = 0, i = 0; base[i]; i++) > if (ISIDNUM (base[i]) || base[i] == '.') > encoded_filename_len++; > @@ -20604,7 +20604,7 @@ optimize_macinfo_range (unsigned int idx, VEC (macinfo_entry, gc) *files, > > /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include > in the empty vector entry before the first define/undef. */ > - inc = VEC_index (macinfo_entry, macinfo_table, idx - 1); > + inc = &VEC_index (macinfo_entry, macinfo_table, idx - 1); > inc->code = DW_MACRO_GNU_transparent_include; > inc->lineno = 0; > inc->info = ggc_strdup (grp_name); > @@ -20697,7 +20697,7 @@ output_macinfo (void) > && VEC_length (macinfo_entry, files) != 1 > && i > 0 > && i + 1 < length > - && VEC_index (macinfo_entry, macinfo_table, i - 1)->code == 0) > + && VEC_index (macinfo_entry, macinfo_table, i - 1).code == 0) > { > unsigned count = optimize_macinfo_range (i, files, &macinfo_htab); > if (count) > @@ -21307,14 +21307,14 @@ static inline void > move_linkage_attr (dw_die_ref die) > { > unsigned ix = VEC_length (dw_attr_node, die->die_attr); > - dw_attr_node linkage = *VEC_index (dw_attr_node, die->die_attr, ix - 1); > + dw_attr_node linkage = VEC_index (dw_attr_node, die->die_attr, ix - 1); > > gcc_assert (linkage.dw_attr == DW_AT_linkage_name > || linkage.dw_attr == DW_AT_MIPS_linkage_name); > > while (--ix > 0) > { > - dw_attr_node *prev = VEC_index (dw_attr_node, die->die_attr, ix - 1); > + dw_attr_node *prev = &VEC_index (dw_attr_node, die->die_attr, ix - 1); > > if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name) > break; > @@ -22226,8 +22226,8 @@ dwarf2out_finish (const char *filename) > for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++) > { > add_location_or_const_value_attribute ( > - VEC_index (deferred_locations, deferred_locations_list, i)->die, > - VEC_index (deferred_locations, deferred_locations_list, i)->variable, > + VEC_index (deferred_locations, deferred_locations_list, i).die, > + VEC_index (deferred_locations, deferred_locations_list, i).variable, > false, > DW_AT_location); > } > diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c > index ebd49b3..210cc14 100644 > --- a/gcc/emit-rtl.c > +++ b/gcc/emit-rtl.c > @@ -6091,7 +6091,7 @@ locator_location (int loc) > break; > } > } > - return *VEC_index (location_t, locations_locators_vals, min); > + return VEC_index (location_t, locations_locators_vals, min); > } > > /* Return source line of the statement that produced this insn. */ > diff --git a/gcc/except.c b/gcc/except.c > index 605d8d7..0174512 100644 > --- a/gcc/except.c > +++ b/gcc/except.c > @@ -304,8 +304,8 @@ init_eh_for_function (void) > cfun->eh = ggc_alloc_cleared_eh_status (); > > /* Make sure zero'th entries are used. */ > - VEC_safe_push (eh_region, gc, cfun->eh->region_array, NULL); > - VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, NULL); > + VEC_safe_push (eh_region, gc, cfun->eh->region_array, (eh_region) NULL); > + VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, (eh_landing_pad) NULL); > } > > /* Routines to generate the exception tree somewhat directly. > @@ -806,7 +806,7 @@ add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list) > if (targetm.arm_eabi_unwinder) > VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi, NULL_TREE); > else > - VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, 0); > + VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, (uchar) 0); > } > > return n->filter; > @@ -2395,10 +2395,10 @@ add_call_site (rtx landing_pad, int action, int section) > record->action = action; > > VEC_safe_push (call_site_record, gc, > - crtl->eh.call_site_record[section], record); > + crtl->eh.call_site_record_v[section], record); > > return call_site_base + VEC_length (call_site_record, > - crtl->eh.call_site_record[section]) - 1; > + crtl->eh.call_site_record_v[section]) - 1; > } > > /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes. > @@ -2546,10 +2546,10 @@ convert_to_eh_region_ranges (void) > else if (last_action != -3) > last_landing_pad = pc_rtx; > call_site_base += VEC_length (call_site_record, > - crtl->eh.call_site_record[cur_sec]); > + crtl->eh.call_site_record_v[cur_sec]); > cur_sec++; > - gcc_assert (crtl->eh.call_site_record[cur_sec] == NULL); > - crtl->eh.call_site_record[cur_sec] > + gcc_assert (crtl->eh.call_site_record_v[cur_sec] == NULL); > + crtl->eh.call_site_record_v[cur_sec] > = VEC_alloc (call_site_record, gc, 10); > } > > @@ -2633,14 +2633,14 @@ push_sleb128 (VEC (uchar, gc) **data_area, int value) > static int > dw2_size_of_call_site_table (int section) > { > - int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]); > + int n = VEC_length (call_site_record, crtl->eh.call_site_record_v[section]); > int size = n * (4 + 4 + 4); > int i; > > for (i = 0; i < n; ++i) > { > struct call_site_record_d *cs = > - VEC_index (call_site_record, crtl->eh.call_site_record[section], i); > + VEC_index (call_site_record, crtl->eh.call_site_record_v[section], i); > size += size_of_uleb128 (cs->action); > } > > @@ -2650,14 +2650,14 @@ dw2_size_of_call_site_table (int section) > static int > sjlj_size_of_call_site_table (void) > { > - int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]); > + int n = VEC_length (call_site_record, crtl->eh.call_site_record_v[0]); > int size = 0; > int i; > > for (i = 0; i < n; ++i) > { > struct call_site_record_d *cs = > - VEC_index (call_site_record, crtl->eh.call_site_record[0], i); > + VEC_index (call_site_record, crtl->eh.call_site_record_v[0], i); > size += size_of_uleb128 (INTVAL (cs->landing_pad)); > size += size_of_uleb128 (cs->action); > } > @@ -2669,7 +2669,7 @@ sjlj_size_of_call_site_table (void) > static void > dw2_output_call_site_table (int cs_format, int section) > { > - int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]); > + int n = VEC_length (call_site_record, crtl->eh.call_site_record_v[section]); > int i; > const char *begin; > > @@ -2683,7 +2683,7 @@ dw2_output_call_site_table (int cs_format, int section) > for (i = 0; i < n; ++i) > { > struct call_site_record_d *cs = > - VEC_index (call_site_record, crtl->eh.call_site_record[section], i); > + VEC_index (call_site_record, crtl->eh.call_site_record_v[section], i); > char reg_start_lab[32]; > char reg_end_lab[32]; > char landing_pad_lab[32]; > @@ -2731,13 +2731,13 @@ dw2_output_call_site_table (int cs_format, int section) > static void > sjlj_output_call_site_table (void) > { > - int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]); > + int n = VEC_length (call_site_record, crtl->eh.call_site_record_v[0]); > int i; > > for (i = 0; i < n; ++i) > { > struct call_site_record_d *cs = > - VEC_index (call_site_record, crtl->eh.call_site_record[0], i); > + VEC_index (call_site_record, crtl->eh.call_site_record_v[0], i); > > dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad), > "region %d landing pad", i); > @@ -3051,7 +3051,7 @@ output_function_exception_table (const char *fnname) > targetm.asm_out.emit_except_table_label (asm_out_file); > > output_one_function_exception_table (0); > - if (crtl->eh.call_site_record[1] != NULL) > + if (crtl->eh.call_site_record_v[1] != NULL) > output_one_function_exception_table (1); > > switch_to_section (current_function_section ()); > diff --git a/gcc/fold-const.c b/gcc/fold-const.c > index 5e14125..3bfd203 100644 > --- a/gcc/fold-const.c > +++ b/gcc/fold-const.c > @@ -14285,7 +14285,7 @@ fold (tree expr) > while (begin != end) > { > unsigned HOST_WIDE_INT middle = (begin + end) / 2; > - tree index = VEC_index (constructor_elt, elts, middle)->index; > + tree index = VEC_index (constructor_elt, elts, middle).index; > > if (TREE_CODE (index) == INTEGER_CST > && tree_int_cst_lt (index, op1)) > @@ -14300,7 +14300,7 @@ fold (tree expr) > && tree_int_cst_lt (op1, TREE_OPERAND (index, 0))) > end = middle; > else > - return VEC_index (constructor_elt, elts, middle)->value; > + return VEC_index (constructor_elt, elts, middle).value; > } > } > > diff --git a/gcc/function.h b/gcc/function.h > index 3d3313f..684bbce 100644 > --- a/gcc/function.h > +++ b/gcc/function.h > @@ -157,7 +157,7 @@ struct GTY(()) rtl_eh { > > VEC(uchar,gc) *action_record_data; > > - VEC(call_site_record,gc) *call_site_record[2]; > + VEC(call_site_record,gc) *call_site_record_v[2]; > }; > > #define pending_stack_adjust (crtl->expr.x_pending_stack_adjust) > diff --git a/gcc/fwprop.c b/gcc/fwprop.c > index 65087ad..d1cba88 100644 > --- a/gcc/fwprop.c > +++ b/gcc/fwprop.c > @@ -223,7 +223,7 @@ single_def_use_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED, > bitmap_copy (local_lr, &lr_bb_info->in); > > /* Push a marker for the leave_block callback. */ > - VEC_safe_push (df_ref, heap, reg_defs_stack, NULL); > + VEC_safe_push (df_ref, heap, reg_defs_stack, (df_ref) NULL); > > process_uses (df_get_artificial_uses (bb_index), DF_REF_AT_TOP); > process_defs (df_get_artificial_defs (bb_index), DF_REF_AT_TOP); > diff --git a/gcc/gcc.c b/gcc/gcc.c > index bda354a..815747e 100644 > --- a/gcc/gcc.c > +++ b/gcc/gcc.c > @@ -2520,7 +2520,7 @@ execute (void) > and record info about each one. > Also search for the programs that are to be run. */ > > - VEC_safe_push (const_char_p, heap, argbuf, 0); > + VEC_safe_push (const_char_p, heap, argbuf, (const_char_p)0); > > commands[0].prog = VEC_index (const_char_p, argbuf, 0); /* first command. */ > commands[0].argv = VEC_address (const_char_p, argbuf); > diff --git a/gcc/genautomata.c b/gcc/genautomata.c > index 9f9e066..122a4a4 100644 > --- a/gcc/genautomata.c > +++ b/gcc/genautomata.c > @@ -5076,7 +5076,8 @@ store_alt_unit_usage (regexp_t regexp, regexp_t unit, int cycle, > > length = (cycle + 1) * REGEXP_ONEOF (regexp)->regexps_num; > while (VEC_length (unit_usage_t, cycle_alt_unit_usages) < length) > - VEC_safe_push (unit_usage_t, heap, cycle_alt_unit_usages, 0); > + VEC_safe_push (unit_usage_t, heap, cycle_alt_unit_usages, > + (unit_usage_t) NULL); > > index = cycle * REGEXP_ONEOF (regexp)->regexps_num + alt_num; > prev = NULL; > @@ -7673,7 +7674,8 @@ output_min_issue_delay_table (automaton_t automaton) > > if (VEC_index (vect_el_t, min_issue_delay_vect, asn)) > { > - VEC_replace (vect_el_t, min_issue_delay_vect, asn, 0); > + VEC_replace (vect_el_t, min_issue_delay_vect, asn, > + (vect_el_t) 0); > changed = 1; > } > > @@ -7723,7 +7725,8 @@ output_min_issue_delay_table (automaton_t automaton) > if (automaton->max_min_delay < x) > automaton->max_min_delay = x; > if (x == -1) > - VEC_replace (vect_el_t, min_issue_delay_vect, np, 0); > + VEC_replace (vect_el_t, min_issue_delay_vect, np, > + (vect_el_t) 0); > } > } > > @@ -7749,7 +7752,8 @@ output_min_issue_delay_table (automaton_t automaton) > = VEC_alloc (vect_el_t, heap, compressed_min_issue_delay_len); > > for (i = 0; i < compressed_min_issue_delay_len; i++) > - VEC_quick_push (vect_el_t, compressed_min_issue_delay_vect, 0); > + VEC_quick_push (vect_el_t, compressed_min_issue_delay_vect, > + (vect_el_t) 0); > > for (i = 0; i < min_issue_delay_len; i++) > { > @@ -7798,7 +7802,8 @@ output_dead_lock_vect (automaton_t automaton) > automaton->locked_states++; > } > else > - VEC_replace (vect_el_t, dead_lock_vect, s->order_state_num, 0); > + VEC_replace (vect_el_t, dead_lock_vect, s->order_state_num, > + (vect_el_t) 0); > } > if (automaton->locked_states == 0) > return; > @@ -7840,7 +7845,7 @@ output_reserved_units_table (automaton_t automaton) > reserved_units_table = VEC_alloc (vect_el_t, heap, reserved_units_size); > > for (i = 0; i < reserved_units_size; i++) > - VEC_quick_push (vect_el_t, reserved_units_table, 0); > + VEC_quick_push (vect_el_t, reserved_units_table, (vect_el_t) 0); > for (n = 0; n < VEC_length (state_t, output_states_vect); n++) > { > state_t s = VEC_index (state_t, output_states_vect, n); > diff --git a/gcc/genextract.c b/gcc/genextract.c > index 09e7cde..175febe 100644 > --- a/gcc/genextract.c > +++ b/gcc/genextract.c > @@ -201,7 +201,7 @@ VEC_safe_set_locstr (VEC(locstr,heap) **vp, unsigned int ix, char *str) > else > { > while (ix > VEC_length (locstr, *vp)) > - VEC_safe_push (locstr, heap, *vp, 0); > + VEC_safe_push (locstr, heap, *vp, (locstr) NULL); > VEC_safe_push (locstr, heap, *vp, str); > } > } > diff --git a/gcc/gimple-low.c b/gcc/gimple-low.c > index f17d8e7..7a51e8c 100644 > --- a/gcc/gimple-low.c > +++ b/gcc/gimple-low.c > @@ -121,7 +121,7 @@ lower_function_body (void) > if (gimple_seq_may_fallthru (lowered_body) > && (VEC_empty (return_statements_t, data.return_statements) > || gimple_return_retval (VEC_last (return_statements_t, > - data.return_statements)->stmt) != NULL)) > + data.return_statements).stmt) != NULL)) > { > x = gimple_build_return (NULL); > gimple_set_location (x, cfun->function_end_locus); > @@ -137,7 +137,7 @@ lower_function_body (void) > > /* Unfortunately, we can't use VEC_pop because it returns void for > objects. */ > - t = *VEC_last (return_statements_t, data.return_statements); > + t = VEC_last (return_statements_t, data.return_statements); > VEC_truncate (return_statements_t, > data.return_statements, > VEC_length (return_statements_t, > @@ -835,7 +835,7 @@ lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data) > for (i = VEC_length (return_statements_t, data->return_statements) - 1; > i >= 0; i--) > { > - tmp_rs = *VEC_index (return_statements_t, data->return_statements, i); > + tmp_rs = VEC_index (return_statements_t, data->return_statements, i); > > if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt)) > { > diff --git a/gcc/gimplify.c b/gcc/gimplify.c > index 03f7c9e..13cd535 100644 > --- a/gcc/gimplify.c > +++ b/gcc/gimplify.c > @@ -2119,7 +2119,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, > fallback_t fallback) > { > tree *p; > - VEC(tree,heap) *stack; > + VEC(tree,heap) *expr_stack; > enum gimplify_status ret = GS_ALL_DONE, tret; > int i; > location_t loc = EXPR_LOCATION (*expr_p); > @@ -2127,7 +2127,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, > > /* Create a stack of the subexpressions so later we can walk them in > order from inner to outer. */ > - stack = VEC_alloc (tree, heap, 10); > + expr_stack = VEC_alloc (tree, heap, 10); > > /* We can handle anything that get_inner_reference can deal with. */ > for (p = expr_p; ; p = &TREE_OPERAND (*p, 0)) > @@ -2147,13 +2147,13 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, > else > break; > > - VEC_safe_push (tree, heap, stack, *p); > + VEC_safe_push (tree, heap, expr_stack, *p); > } > > - gcc_assert (VEC_length (tree, stack)); > + gcc_assert (VEC_length (tree, expr_stack)); > > - /* Now STACK is a stack of pointers to all the refs we've walked through > - and P points to the innermost expression. > + /* Now EXPR_STACK is a stack of pointers to all the refs we've > + walked through and P points to the innermost expression. > > Java requires that we elaborated nodes in source order. That > means we must gimplify the inner expression followed by each of > @@ -2164,9 +2164,9 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, > So we do this in three steps. First we deal with the annotations > for any variables in the components, then we gimplify the base, > then we gimplify any indices, from left to right. */ > - for (i = VEC_length (tree, stack) - 1; i >= 0; i--) > + for (i = VEC_length (tree, expr_stack) - 1; i >= 0; i--) > { > - tree t = VEC_index (tree, stack, i); > + tree t = VEC_index (tree, expr_stack, i); > > if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) > { > @@ -2259,9 +2259,9 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, > > /* And finally, the indices and operands of ARRAY_REF. During this > loop we also remove any useless conversions. */ > - for (; VEC_length (tree, stack) > 0; ) > + for (; VEC_length (tree, expr_stack) > 0; ) > { > - tree t = VEC_pop (tree, stack); > + tree t = VEC_pop (tree, expr_stack); > > if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) > { > @@ -2289,7 +2289,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, > canonicalize_component_ref (expr_p); > } > > - VEC_free (tree, heap, stack); > + VEC_free (tree, heap, expr_stack); > > gcc_assert (*expr_p == expr || ret != GS_ALL_DONE); > > @@ -3848,7 +3848,7 @@ optimize_compound_literals_in_ctor (tree orig_ctor) > > for (idx = 0; idx < num; idx++) > { > - tree value = VEC_index (constructor_elt, elts, idx)->value; > + tree value = VEC_index (constructor_elt, elts, idx).value; > tree newval = value; > if (TREE_CODE (value) == CONSTRUCTOR) > newval = optimize_compound_literals_in_ctor (value); > @@ -3872,7 +3872,7 @@ optimize_compound_literals_in_ctor (tree orig_ctor) > CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts); > elts = CONSTRUCTOR_ELTS (ctor); > } > - VEC_index (constructor_elt, elts, idx)->value = newval; > + VEC_index (constructor_elt, elts, idx).value = newval; > } > return ctor; > } > @@ -4123,8 +4123,8 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, > > /* Extract the real and imaginary parts out of the ctor. */ > gcc_assert (VEC_length (constructor_elt, elts) == 2); > - r = VEC_index (constructor_elt, elts, 0)->value; > - i = VEC_index (constructor_elt, elts, 1)->value; > + r = VEC_index (constructor_elt, elts, 0).value; > + i = VEC_index (constructor_elt, elts, 1).value; > if (r == NULL || i == NULL) > { > tree zero = build_zero_cst (TREE_TYPE (type)); > diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c > index c168622..a92f92c 100644 > --- a/gcc/graphite-sese-to-poly.c > +++ b/gcc/graphite-sese-to-poly.c > @@ -1249,7 +1249,7 @@ build_sese_conditions_before (struct dom_walk_data *dw_data, > if (e->flags & EDGE_TRUE_VALUE) > VEC_safe_push (gimple, heap, *cases, stmt); > else > - VEC_safe_push (gimple, heap, *cases, NULL); > + VEC_safe_push (gimple, heap, *cases, (gimple) NULL); > } > > gbb = gbb_from_bb (bb); > diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c > index 41d556a..53fedd2 100644 > --- a/gcc/ipa-inline-analysis.c > +++ b/gcc/ipa-inline-analysis.c > @@ -295,9 +295,9 @@ add_clause (conditions conditions, struct predicate *p, clause_t clause) > condition *cc1; > if (!(clause & (1 << c1))) > continue; > - cc1 = VEC_index (condition, > - conditions, > - c1 - predicate_first_dynamic_condition); > + cc1 = &VEC_index (condition, > + conditions, > + c1 - predicate_first_dynamic_condition); > /* We have no way to represent !CHANGED and !IS_NOT_CONSTANT > and thus there is no point for looking for them. */ > if (cc1->code == CHANGED > @@ -306,12 +306,12 @@ add_clause (conditions conditions, struct predicate *p, clause_t clause) > for (c2 = c1 + 1; c2 <= NUM_CONDITIONS; c2++) > if (clause & (1 << c2)) > { > - condition *cc1 = VEC_index (condition, > - conditions, > - c1 - predicate_first_dynamic_condition); > - condition *cc2 = VEC_index (condition, > - conditions, > - c2 - predicate_first_dynamic_condition); > + condition *cc1 = &VEC_index (condition, > + conditions, > + c1 - predicate_first_dynamic_condition); > + condition *cc2 = &VEC_index (condition, > + conditions, > + c2 - predicate_first_dynamic_condition); > if (cc1->operand_num == cc2->operand_num > && cc1->val == cc2->val > && cc2->code != IS_NOT_CONSTANT > @@ -476,7 +476,7 @@ predicate_probability (conditions conds, > { > if (i2 >= predicate_first_dynamic_condition) > { > - condition *c = VEC_index > + condition *c = &VEC_index > (condition, conds, > i2 - predicate_first_dynamic_condition); > if (c->code == CHANGED > @@ -486,7 +486,7 @@ predicate_probability (conditions conds, > { > int iprob = VEC_index (inline_param_summary_t, > inline_param_summary, > - c->operand_num)->change_prob; > + c->operand_num).change_prob; > this_prob = MAX (this_prob, iprob); > } > else > @@ -516,8 +516,8 @@ dump_condition (FILE *f, conditions conditions, int cond) > fprintf (f, "not inlined"); > else > { > - c = VEC_index (condition, conditions, > - cond - predicate_first_dynamic_condition); > + c = &VEC_index (condition, conditions, > + cond - predicate_first_dynamic_condition); > fprintf (f, "op%i", c->operand_num); > if (c->code == IS_NOT_CONSTANT) > { > @@ -609,7 +609,7 @@ account_size_time (struct inline_summary *summary, int size, int time, > { > i = 0; > found = true; > - e = VEC_index (size_time_entry, summary->entry, 0); > + e = &VEC_index (size_time_entry, summary->entry, 0); > gcc_assert (!e->predicate.clause[0]); > } > if (dump_file && (dump_flags & TDF_DETAILS) && (time || size)) > @@ -759,7 +759,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p, > else if (inline_p > && !VEC_index (inline_param_summary_t, > es->param, > - i)->change_prob) > + i).change_prob) > VEC_replace (tree, known_vals, i, error_mark_node); > } > } > @@ -1134,7 +1134,7 @@ dump_inline_edge_summary (FILE * f, int indent, struct cgraph_node *node, > i++) > { > int prob = VEC_index (inline_param_summary_t, > - es->param, i)->change_prob; > + es->param, i).change_prob; > > if (!prob) > fprintf (f, "%*s op%i is compile time invariant\n", > @@ -1711,8 +1711,8 @@ will_be_nonconstant_predicate (struct ipa_node_params *info, > return p; > /* If we know when operand is constant, > we still can say something useful. */ > - if (!true_predicate_p (VEC_index (predicate_t, nonconstant_names, > - SSA_NAME_VERSION (use)))) > + if (!true_predicate_p (&VEC_index (predicate_t, nonconstant_names, > + SSA_NAME_VERSION (use)))) > continue; > return p; > } > @@ -1734,14 +1734,14 @@ will_be_nonconstant_predicate (struct ipa_node_params *info, > ipa_get_param_decl_index (info, parm), > CHANGED, NULL); > else > - p = *VEC_index (predicate_t, nonconstant_names, > - SSA_NAME_VERSION (use)); > + p = VEC_index (predicate_t, nonconstant_names, > + SSA_NAME_VERSION (use)); > op_non_const = or_predicates (summary->conds, &p, &op_non_const); > } > if (gimple_code (stmt) == GIMPLE_ASSIGN > && TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME) > VEC_replace (predicate_t, nonconstant_names, > - SSA_NAME_VERSION (gimple_assign_lhs (stmt)), &op_non_const); > + SSA_NAME_VERSION (gimple_assign_lhs (stmt)), op_non_const); > return op_non_const; > } > > @@ -1956,7 +1956,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early) > struct predicate false_p = false_predicate (); > VEC_replace (predicate_t, nonconstant_names, > SSA_NAME_VERSION (gimple_call_lhs (stmt)), > - &false_p); > + false_p); > } > if (ipa_node_params_vector) > { > @@ -1971,7 +1971,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early) > int prob = param_change_prob (stmt, i); > gcc_assert (prob >= 0 && prob <= REG_BR_PROB_BASE); > VEC_index (inline_param_summary_t, > - es->param, i)->change_prob = prob; > + es->param, i).change_prob = prob; > } > } > > @@ -2430,8 +2430,8 @@ remap_predicate (struct inline_summary *info, > { > struct condition *c; > > - c = VEC_index (condition, callee_info->conds, > - cond - predicate_first_dynamic_condition); > + c = &VEC_index (condition, callee_info->conds, > + cond - predicate_first_dynamic_condition); > /* See if we can remap condition operand to caller's operand. > Otherwise give up. */ > if (!operand_map > @@ -2519,10 +2519,10 @@ remap_edge_change_prob (struct cgraph_edge *inlined_edge, > { > int jf_formal_id = ipa_get_jf_pass_through_formal_id (jfunc); > int prob1 = VEC_index (inline_param_summary_t, > - es->param, i)->change_prob; > + es->param, i).change_prob; > int prob2 = VEC_index > (inline_param_summary_t, > - inlined_es->param, jf_formal_id)->change_prob; > + inlined_es->param, jf_formal_id).change_prob; > int prob = ((prob1 * prob2 + REG_BR_PROB_BASE / 2) > / REG_BR_PROB_BASE); > > @@ -2530,7 +2530,7 @@ remap_edge_change_prob (struct cgraph_edge *inlined_edge, > prob = 1; > > VEC_index (inline_param_summary_t, > - es->param, i)->change_prob = prob; > + es->param, i).change_prob = prob; > } > } > } > @@ -2753,12 +2753,12 @@ do_estimate_edge_time (struct cgraph_edge *edge) > <= edge->uid) > VEC_safe_grow_cleared (edge_growth_cache_entry, heap, edge_growth_cache, > cgraph_edge_max_uid); > - VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid)->time > + VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid).time > = ret + (ret >= 0); > > ret_size = size - es->call_stmt_size; > gcc_checking_assert (es->call_stmt_size); > - VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid)->size > + VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid).size > = ret_size + (ret_size >= 0); > } > return ret; > @@ -2784,7 +2784,7 @@ do_estimate_edge_growth (struct cgraph_edge *edge) > do_estimate_edge_time (edge); > size = VEC_index (edge_growth_cache_entry, > edge_growth_cache, > - edge->uid)->size; > + edge->uid).size; > gcc_checking_assert (size); > return size - (size > 0); > } > @@ -3019,7 +3019,7 @@ read_inline_edge_summary (struct lto_input_block *ib, struct cgraph_edge *e) > { > VEC_safe_grow_cleared (inline_param_summary_t, heap, es->param, length); > for (i = 0; i < length; i++) > - VEC_index (inline_param_summary_t, es->param, i)->change_prob > + VEC_index (inline_param_summary_t, es->param, i).change_prob > = streamer_read_uhwi (ib); > } > } > @@ -3173,7 +3173,7 @@ write_inline_edge_summary (struct output_block *ob, struct cgraph_edge *e) > streamer_write_uhwi (ob, VEC_length (inline_param_summary_t, es->param)); > for (i = 0; i < (int)VEC_length (inline_param_summary_t, es->param); i++) > streamer_write_uhwi (ob, VEC_index (inline_param_summary_t, > - es->param, i)->change_prob); > + es->param, i).change_prob); > } > > > diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c > index d8b66e6..c43ce25 100644 > --- a/gcc/ipa-inline.c > +++ b/gcc/ipa-inline.c > @@ -1287,7 +1287,7 @@ inline_small_functions (void) > { > struct cgraph_node *node; > struct cgraph_edge *edge; > - fibheap_t heap = fibheap_new (); > + fibheap_t edge_heap = fibheap_new (); > bitmap updated_nodes = BITMAP_ALLOC (NULL); > int min_size, max_size; > VEC (cgraph_edge_p, heap) *new_indirect_edges = NULL; > @@ -1344,7 +1344,7 @@ inline_small_functions (void) > && edge->inline_failed) > { > gcc_assert (!edge->aux); > - update_edge_key (heap, edge); > + update_edge_key (edge_heap, edge); > } > } > > @@ -1352,16 +1352,16 @@ inline_small_functions (void) > || !max_count > || (profile_info && flag_branch_probabilities)); > > - while (!fibheap_empty (heap)) > + while (!fibheap_empty (edge_heap)) > { > int old_size = overall_size; > struct cgraph_node *where, *callee; > - int badness = fibheap_min_key (heap); > + int badness = fibheap_min_key (edge_heap); > int current_badness; > int cached_badness; > int growth; > > - edge = (struct cgraph_edge *) fibheap_extract_min (heap); > + edge = (struct cgraph_edge *) fibheap_extract_min (edge_heap); > gcc_assert (edge->aux); > edge->aux = NULL; > if (!edge->inline_failed) > @@ -1382,7 +1382,7 @@ inline_small_functions (void) > gcc_assert (current_badness >= badness); > if (current_badness != badness) > { > - edge->aux = fibheap_insert (heap, current_badness, edge); > + edge->aux = fibheap_insert (edge_heap, current_badness, edge); > continue; > } > > @@ -1447,8 +1447,8 @@ inline_small_functions (void) > /* Recursive inliner inlines all recursive calls of the function > at once. Consequently we need to update all callee keys. */ > if (flag_indirect_inlining) > - add_new_edges_to_heap (heap, new_indirect_edges); > - update_callee_keys (heap, where, updated_nodes); > + add_new_edges_to_heap (edge_heap, new_indirect_edges); > + update_callee_keys (edge_heap, where, updated_nodes); > } > else > { > @@ -1482,12 +1482,12 @@ inline_small_functions (void) > gcc_checking_assert (!callee->global.inlined_to); > inline_call (edge, true, &new_indirect_edges, &overall_size, true); > if (flag_indirect_inlining) > - add_new_edges_to_heap (heap, new_indirect_edges); > + add_new_edges_to_heap (edge_heap, new_indirect_edges); > > reset_edge_caches (edge->callee); > reset_node_growth_cache (callee); > > - update_callee_keys (heap, edge->callee, updated_nodes); > + update_callee_keys (edge_heap, edge->callee, updated_nodes); > } > where = edge->caller; > if (where->global.inlined_to) > @@ -1499,7 +1499,7 @@ inline_small_functions (void) > inlined into (since it's body size changed) and for the functions > called by function we inlined (since number of it inlinable callers > might change). */ > - update_caller_keys (heap, where, updated_nodes, NULL); > + update_caller_keys (edge_heap, where, updated_nodes, NULL); > bitmap_clear (updated_nodes); > > if (dump_file) > @@ -1525,7 +1525,7 @@ inline_small_functions (void) > free_growth_caches (); > if (new_indirect_edges) > VEC_free (cgraph_edge_p, heap, new_indirect_edges); > - fibheap_delete (heap); > + fibheap_delete (edge_heap); > if (dump_file) > fprintf (dump_file, > "Unit growth for small function inlining: %i->%i (%i%%)\n", > diff --git a/gcc/ipa-inline.h b/gcc/ipa-inline.h > index fbd0b99..2d0004b 100644 > --- a/gcc/ipa-inline.h > +++ b/gcc/ipa-inline.h > @@ -191,13 +191,13 @@ extern int nfunctions_inlined; > static inline struct inline_summary * > inline_summary (struct cgraph_node *node) > { > - return VEC_index (inline_summary_t, inline_summary_vec, node->uid); > + return &VEC_index (inline_summary_t, inline_summary_vec, node->uid); > } > > static inline struct inline_edge_summary * > inline_edge_summary (struct cgraph_edge *edge) > { > - return VEC_index (inline_edge_summary_t, > + return &VEC_index (inline_edge_summary_t, > inline_edge_summary_vec, edge->uid); > } > > @@ -226,7 +226,7 @@ estimate_edge_growth (struct cgraph_edge *edge) > if ((int)VEC_length (edge_growth_cache_entry, edge_growth_cache) <= edge->uid > || !(ret = VEC_index (edge_growth_cache_entry, > edge_growth_cache, > - edge->uid)->size)) > + edge->uid).size)) > return do_estimate_edge_growth (edge); > return ret - (ret > 0); > } > @@ -242,7 +242,7 @@ estimate_edge_time (struct cgraph_edge *edge) > if ((int)VEC_length (edge_growth_cache_entry, edge_growth_cache) <= edge->uid > || !(ret = VEC_index (edge_growth_cache_entry, > edge_growth_cache, > - edge->uid)->time)) > + edge->uid).time)) > return do_estimate_edge_time (edge); > return ret - (ret > 0); > } > @@ -265,6 +265,6 @@ reset_edge_growth_cache (struct cgraph_edge *edge) > if ((int)VEC_length (edge_growth_cache_entry, edge_growth_cache) > edge->uid) > { > struct edge_growth_cache_entry zero = {0, 0}; > - VEC_replace (edge_growth_cache_entry, edge_growth_cache, edge->uid, &zero); > + VEC_replace (edge_growth_cache_entry, edge_growth_cache, edge->uid, zero); > } > } > diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c > index 7f90984..b964272 100644 > --- a/gcc/ipa-prop.c > +++ b/gcc/ipa-prop.c > @@ -94,7 +94,7 @@ ipa_populate_param_decls (struct cgraph_node *node, > for (parm = fnargs; parm; parm = DECL_CHAIN (parm)) > { > VEC_index (ipa_param_descriptor_t, > - info->descriptors, param_num)->decl = parm; > + info->descriptors, param_num).decl = parm; > param_num++; > } > } > @@ -2439,10 +2439,10 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst, > old_args->jump_functions); > > for (i = 0; i < VEC_length (ipa_jump_func_t, old_args->jump_functions); i++) > - VEC_index (ipa_jump_func_t, new_args->jump_functions, i)->agg.items > + VEC_index (ipa_jump_func_t, new_args->jump_functions, i).agg.items > = VEC_copy (ipa_agg_jf_item_t, gc, > VEC_index (ipa_jump_func_t, > - old_args->jump_functions, i)->agg.items); > + old_args->jump_functions, i).agg.items); > } > > /* Hook that is called by cgraph.c when a node is duplicated. */ > @@ -2672,7 +2672,7 @@ ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments, > struct ipa_parm_adjustment *adj; > gcc_assert (link); > > - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); > + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); > parm = VEC_index (tree, oparms, adj->base_index); > adj->base = parm; > > @@ -2738,8 +2738,8 @@ ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments, > When we are asked to remove it, we need to build new FUNCTION_TYPE > instead. */ > if (TREE_CODE (orig_type) != METHOD_TYPE > - || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param > - && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0)) > + || (VEC_index (ipa_parm_adjustment_t, adjustments, 0).copy_param > + && VEC_index (ipa_parm_adjustment_t, adjustments, 0).base_index == 0)) > { > new_type = build_distinct_type_copy (orig_type); > TYPE_ARG_TYPES (new_type) = new_reversed; > @@ -2806,7 +2806,7 @@ ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt, > { > struct ipa_parm_adjustment *adj; > > - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); > + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); > > if (adj->copy_param) > { > @@ -2989,7 +2989,7 @@ index_in_adjustments_multiple_times_p (int base_index, > for (i = 0; i < len; i++) > { > struct ipa_parm_adjustment *adj; > - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); > + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); > > if (adj->base_index == base_index) > { > @@ -3020,7 +3020,7 @@ ipa_combine_adjustments (ipa_parm_adjustment_vec inner, > for (i = 0; i < inlen; i++) > { > struct ipa_parm_adjustment *n; > - n = VEC_index (ipa_parm_adjustment_t, inner, i); > + n = &VEC_index (ipa_parm_adjustment_t, inner, i); > > if (n->remove_param) > removals++; > @@ -3032,10 +3032,10 @@ ipa_combine_adjustments (ipa_parm_adjustment_vec inner, > for (i = 0; i < outlen; i++) > { > struct ipa_parm_adjustment *r; > - struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t, > - outer, i); > - struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp, > - out->base_index); > + struct ipa_parm_adjustment *out = &VEC_index (ipa_parm_adjustment_t, > + outer, i); > + struct ipa_parm_adjustment *in = &VEC_index (ipa_parm_adjustment_t, tmp, > + out->base_index); > > gcc_assert (!in->remove_param); > if (out->remove_param) > @@ -3068,8 +3068,8 @@ ipa_combine_adjustments (ipa_parm_adjustment_vec inner, > > for (i = 0; i < inlen; i++) > { > - struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t, > - inner, i); > + struct ipa_parm_adjustment *n = &VEC_index (ipa_parm_adjustment_t, > + inner, i); > > if (n->remove_param) > VEC_quick_push (ipa_parm_adjustment_t, adjustments, n); > @@ -3094,7 +3094,7 @@ ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments, > for (i = 0; i < len; i++) > { > struct ipa_parm_adjustment *adj; > - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); > + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); > > if (!first) > fprintf (file, " "); > diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h > index 489e5d8..feb8ff7 100644 > --- a/gcc/ipa-prop.h > +++ b/gcc/ipa-prop.h > @@ -359,7 +359,7 @@ ipa_get_param_count (struct ipa_node_params *info) > static inline tree > ipa_get_param (struct ipa_node_params *info, int i) > { > - return VEC_index (ipa_param_descriptor_t, info->descriptors, i)->decl; > + return VEC_index (ipa_param_descriptor_t, info->descriptors, i).decl; > } > > /* Set the used flag corresponding to the Ith formal parameter of the function > @@ -368,7 +368,7 @@ ipa_get_param (struct ipa_node_params *info, int i) > static inline void > ipa_set_param_used (struct ipa_node_params *info, int i, bool val) > { > - VEC_index (ipa_param_descriptor_t, info->descriptors, i)->used = val; > + VEC_index (ipa_param_descriptor_t, info->descriptors, i).used = val; > } > > /* Return the used flag corresponding to the Ith formal parameter of the > @@ -377,7 +377,7 @@ ipa_set_param_used (struct ipa_node_params *info, int i, bool val) > static inline bool > ipa_is_param_used (struct ipa_node_params *info, int i) > { > - return VEC_index (ipa_param_descriptor_t, info->descriptors, i)->used; > + return VEC_index (ipa_param_descriptor_t, info->descriptors, i).used; > } > > /* ipa_edge_args stores information related to a callsite and particularly its > @@ -406,7 +406,7 @@ ipa_get_cs_argument_count (struct ipa_edge_args *args) > static inline struct ipa_jump_func * > ipa_get_ith_jump_func (struct ipa_edge_args *args, int i) > { > - return VEC_index (ipa_jump_func_t, args->jump_functions, i); > + return &VEC_index (ipa_jump_func_t, args->jump_functions, i); > } > > /* Vectors need to have typedefs of structures. */ > @@ -425,10 +425,10 @@ extern GTY(()) VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector; > > /* Return the associated parameter/argument info corresponding to the given > node/edge. */ > -#define IPA_NODE_REF(NODE) (VEC_index (ipa_node_params_t, \ > - ipa_node_params_vector, (NODE)->uid)) > -#define IPA_EDGE_REF(EDGE) (VEC_index (ipa_edge_args_t, \ > - ipa_edge_args_vector, (EDGE)->uid)) > +#define IPA_NODE_REF(NODE) (&VEC_index (ipa_node_params_t, \ > + ipa_node_params_vector, (NODE)->uid)) > +#define IPA_EDGE_REF(EDGE) (&VEC_index (ipa_edge_args_t, \ > + ipa_edge_args_vector, (EDGE)->uid)) > /* This macro checks validity of index returned by > ipa_get_param_decl_index function. */ > #define IS_VALID_JUMP_FUNC_INDEX(I) ((I) != -1) > diff --git a/gcc/ipa-ref-inline.h b/gcc/ipa-ref-inline.h > index 636af14..575bba9 100644 > --- a/gcc/ipa-ref-inline.h > +++ b/gcc/ipa-ref-inline.h > @@ -73,7 +73,7 @@ ipa_ref_list_first_reference (struct ipa_ref_list *list) > { > if (!VEC_length (ipa_ref_t, list->references)) > return NULL; > - return VEC_index (ipa_ref_t, list->references, 0); > + return &VEC_index (ipa_ref_t, list->references, 0); > } > > /* Return first referring ref in LIST or NULL if empty. */ > diff --git a/gcc/ipa-ref.c b/gcc/ipa-ref.c > index 7926eb6..21799ab 100644 > --- a/gcc/ipa-ref.c > +++ b/gcc/ipa-ref.c > @@ -49,7 +49,7 @@ ipa_record_reference (symtab_node referring_node, > old_references = list->references; > VEC_safe_grow (ipa_ref_t, gc, list->references, > VEC_length (ipa_ref_t, list->references) + 1); > - ref = VEC_last (ipa_ref_t, list->references); > + ref = &VEC_last (ipa_ref_t, list->references); > > list2 = &referred_node->symbol.ref_list; > VEC_safe_push (ipa_ref_ptr, heap, list2->referring, ref); > @@ -93,7 +93,7 @@ ipa_remove_reference (struct ipa_ref *ref) > } > VEC_pop (ipa_ref_ptr, list->referring); > > - last = VEC_last (ipa_ref_t, list2->references); > + last = &VEC_last (ipa_ref_t, list2->references); > if (ref != last) > { > *ref = *last; > @@ -111,7 +111,7 @@ void > ipa_remove_all_references (struct ipa_ref_list *list) > { > while (VEC_length (ipa_ref_t, list->references)) > - ipa_remove_reference (VEC_last (ipa_ref_t, list->references)); > + ipa_remove_reference (&VEC_last (ipa_ref_t, list->references)); > VEC_free (ipa_ref_t, gc, list->references); > list->references = NULL; > } > diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c > index 2b5bc22..ed12b5f 100644 > --- a/gcc/ipa-split.c > +++ b/gcc/ipa-split.c > @@ -921,7 +921,7 @@ find_split_points (int overall_time, int overall_size) > > while (!VEC_empty (stack_entry, stack)) > { > - stack_entry *entry = VEC_last (stack_entry, stack); > + stack_entry *entry = &VEC_last (stack_entry, stack); > > /* We are walking an acyclic graph, so edge_num counts > succ and pred edges together. However when considering > @@ -988,9 +988,9 @@ find_split_points (int overall_time, int overall_size) > new_entry.bb = dest; > new_entry.edge_num = 0; > new_entry.overall_time > - = VEC_index (bb_info, bb_info_vec, dest->index)->time; > + = VEC_index (bb_info, bb_info_vec, dest->index).time; > new_entry.overall_size > - = VEC_index (bb_info, bb_info_vec, dest->index)->size; > + = VEC_index (bb_info, bb_info_vec, dest->index).size; > new_entry.earliest = INT_MAX; > new_entry.set_ssa_names = BITMAP_ALLOC (NULL); > new_entry.used_ssa_names = BITMAP_ALLOC (NULL); > @@ -1010,8 +1010,8 @@ find_split_points (int overall_time, int overall_size) > and merge stuff we accumulate during the walk. */ > else if (entry->bb != ENTRY_BLOCK_PTR) > { > - stack_entry *prev = VEC_index (stack_entry, stack, > - VEC_length (stack_entry, stack) - 2); > + stack_entry *prev = &VEC_index (stack_entry, stack, > + VEC_length (stack_entry, stack) - 2); > > entry->bb->aux = (void *)(intptr_t)-1; > prev->can_split &= entry->can_split; > @@ -1493,8 +1493,8 @@ execute_split_functions (void) > } > overall_time += time; > overall_size += size; > - VEC_index (bb_info, bb_info_vec, bb->index)->time = time; > - VEC_index (bb_info, bb_info_vec, bb->index)->size = size; > + VEC_index (bb_info, bb_info_vec, bb->index).time = time; > + VEC_index (bb_info, bb_info_vec, bb->index).size = size; > } > find_split_points (overall_time, overall_size); > if (best_split_point.split_bbs) > diff --git a/gcc/java/boehm.c b/gcc/java/boehm.c > index f4a9af6..07dfb61 100644 > --- a/gcc/java/boehm.c > +++ b/gcc/java/boehm.c > @@ -233,6 +233,6 @@ uses_jv_markobj_p (tree dtable) > this function is only used with flag_reduced_reflection. No > point in asserting unless we hit the bad case. */ > gcc_assert (!flag_reduced_reflection || TARGET_VTABLE_USES_DESCRIPTORS == 0); > - v = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (dtable), 3)->value; > + v = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (dtable), 3).value; > return (PROCEDURE_OBJECT_DESCRIPTOR == TREE_INT_CST_LOW (v)); > } > diff --git a/gcc/java/class.c b/gcc/java/class.c > index 40ff26d..f806cea 100644 > --- a/gcc/java/class.c > +++ b/gcc/java/class.c > @@ -1533,7 +1533,7 @@ make_method_value (tree mdecl) > v = VEC_alloc (constructor_elt, gc, length); > VEC_safe_grow_cleared (constructor_elt, gc, v, length); > > - e = VEC_index (constructor_elt, v, idx--); > + e = &VEC_index (constructor_elt, v, idx--); > e->value = null_pointer_node; > > FOR_EACH_VEC_ELT (tree, DECL_FUNCTION_THROWS (mdecl), ix, t) > @@ -1542,7 +1542,7 @@ make_method_value (tree mdecl) > tree utf8 > = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig), > IDENTIFIER_LENGTH (sig))); > - e = VEC_index (constructor_elt, v, idx--); > + e = &VEC_index (constructor_elt, v, idx--); > e->value = utf8; > } > gcc_assert (idx == -1); > @@ -1621,7 +1621,7 @@ get_dispatch_table (tree type, tree this_class_addr) > arraysize += 2; > > VEC_safe_grow_cleared (constructor_elt, gc, v, arraysize); > - e = VEC_index (constructor_elt, v, arraysize - 1); > + e = &VEC_index (constructor_elt, v, arraysize - 1); > > #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E-- > for (i = nvirtuals; --i >= 0; ) > @@ -3007,7 +3007,7 @@ emit_catch_table (tree this_class) > int n_catch_classes; > constructor_elt *e; > /* Fill in the dummy entry that make_class created. */ > - e = VEC_index (constructor_elt, TYPE_CATCH_CLASSES (this_class), 0); > + e = &VEC_index (constructor_elt, TYPE_CATCH_CLASSES (this_class), 0); > e->value = make_catch_class_record (null_pointer_node, null_pointer_node); > CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class), NULL_TREE, > make_catch_class_record (null_pointer_node, > diff --git a/gcc/java/constants.c b/gcc/java/constants.c > index 2cc911f..c709fa4 100644 > --- a/gcc/java/constants.c > +++ b/gcc/java/constants.c > @@ -514,8 +514,8 @@ build_constants_constructor (void) > int c = outgoing_cpool->count; > VEC_safe_grow_cleared (constructor_elt, gc, tags, c); > VEC_safe_grow_cleared (constructor_elt, gc, data, c); > - t = VEC_index (constructor_elt, tags, c-1); > - d = VEC_index (constructor_elt, data, c-1); > + t = &VEC_index (constructor_elt, tags, c-1); > + d = &VEC_index (constructor_elt, data, c-1); > } > > #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E-- > diff --git a/gcc/java/java-tree.h b/gcc/java/java-tree.h > index 6169b6a..5167b9b 100644 > --- a/gcc/java/java-tree.h > +++ b/gcc/java/java-tree.h > @@ -1430,7 +1430,7 @@ extern tree *type_map; > #define PUSH_SUPER_VALUE(V, VALUE) \ > do \ > { \ > - constructor_elt *_elt___ = VEC_last (constructor_elt, V); \ > + constructor_elt *_elt___ = &VEC_last (constructor_elt, V); \ > tree _next___ = DECL_CHAIN (_elt___->index); \ > gcc_assert (!DECL_NAME (_elt___->index)); \ > _elt___->value = VALUE; \ > @@ -1444,7 +1444,7 @@ extern tree *type_map; > #define PUSH_FIELD_VALUE(V, NAME, VALUE) \ > do \ > { \ > - constructor_elt *_elt___ = VEC_last (constructor_elt, V); \ > + constructor_elt *_elt___ = &VEC_last (constructor_elt, V); \ > tree _next___ = DECL_CHAIN (_elt___->index); \ > gcc_assert (strcmp (IDENTIFIER_POINTER (DECL_NAME (_elt___->index)), \ > NAME) == 0); \ > diff --git a/gcc/modulo-sched.c b/gcc/modulo-sched.c > index af79fb6..673055e 100644 > --- a/gcc/modulo-sched.c > +++ b/gcc/modulo-sched.c > @@ -229,7 +229,7 @@ static void remove_node_from_ps (partial_schedule_ptr, ps_insn_ptr); > > #define NODE_ASAP(node) ((node)->aux.count) > > -#define SCHED_PARAMS(x) VEC_index (node_sched_params, node_sched_param_vec, x) > +#define SCHED_PARAMS(x) (&VEC_index (node_sched_params, node_sched_param_vec, x)) > #define SCHED_TIME(x) (SCHED_PARAMS (x)->time) > #define SCHED_ROW(x) (SCHED_PARAMS (x)->row) > #define SCHED_STAGE(x) (SCHED_PARAMS (x)->stage) > @@ -305,7 +305,7 @@ static struct ps_reg_move_info * > ps_reg_move (partial_schedule_ptr ps, int id) > { > gcc_checking_assert (id >= ps->g->num_nodes); > - return VEC_index (ps_reg_move_info, ps->reg_moves, id - ps->g->num_nodes); > + return &VEC_index (ps_reg_move_info, ps->reg_moves, id - ps->g->num_nodes); > } > > /* Return the rtl instruction that is being scheduled by partial schedule > diff --git a/gcc/ree.c b/gcc/ree.c > index 697e45f..1d0f194 100644 > --- a/gcc/ree.c > +++ b/gcc/ree.c > @@ -802,7 +802,7 @@ add_removable_extension (const_rtx expr, rtx insn, > different extension. FIXME: this obviously can be improved. */ > for (def = defs; def; def = def->next) > if ((idx = def_map[INSN_UID(DF_REF_INSN (def->ref))]) > - && (cand = VEC_index (ext_cand, *insn_list, idx - 1)) > + && (cand = &VEC_index (ext_cand, *insn_list, idx - 1)) > && (cand->code != code || cand->mode != mode)) > { > if (dump_file) > diff --git a/gcc/reg-stack.c b/gcc/reg-stack.c > index d1e195d..dc7550a 100644 > --- a/gcc/reg-stack.c > +++ b/gcc/reg-stack.c > @@ -201,7 +201,7 @@ typedef struct stack_def > int top; /* index to top stack element */ > HARD_REG_SET reg_set; /* set of live registers */ > unsigned char reg[REG_STACK_SIZE];/* register - stack mapping */ > -} *stack; > +} *stack_ptr; > > /* This is used to carry information about basic blocks. It is > attached to the AUX field of the standard CFG block. */ > @@ -246,7 +246,7 @@ static rtx not_a_num; > /* Forward declarations */ > > static int stack_regs_mentioned_p (const_rtx pat); > -static void pop_stack (stack, int); > +static void pop_stack (stack_ptr, int); > static rtx *get_true_reg (rtx *); > > static int check_asm_stack_operands (rtx); > @@ -254,19 +254,19 @@ static void get_asm_operands_in_out (rtx, int *, int *); > static rtx stack_result (tree); > static void replace_reg (rtx *, int); > static void remove_regno_note (rtx, enum reg_note, unsigned int); > -static int get_hard_regnum (stack, rtx); > -static rtx emit_pop_insn (rtx, stack, rtx, enum emit_where); > -static void swap_to_top(rtx, stack, rtx, rtx); > -static bool move_for_stack_reg (rtx, stack, rtx); > -static bool move_nan_for_stack_reg (rtx, stack, rtx); > +static int get_hard_regnum (stack_ptr, rtx); > +static rtx emit_pop_insn (rtx, stack_ptr, rtx, enum emit_where); > +static void swap_to_top(rtx, stack_ptr, rtx, rtx); > +static bool move_for_stack_reg (rtx, stack_ptr, rtx); > +static bool move_nan_for_stack_reg (rtx, stack_ptr, rtx); > static int swap_rtx_condition_1 (rtx); > static int swap_rtx_condition (rtx); > -static void compare_for_stack_reg (rtx, stack, rtx); > -static bool subst_stack_regs_pat (rtx, stack, rtx); > -static void subst_asm_stack_regs (rtx, stack); > -static bool subst_stack_regs (rtx, stack); > -static void change_stack (rtx, stack, stack, enum emit_where); > -static void print_stack (FILE *, stack); > +static void compare_for_stack_reg (rtx, stack_ptr, rtx); > +static bool subst_stack_regs_pat (rtx, stack_ptr, rtx); > +static void subst_asm_stack_regs (rtx, stack_ptr); > +static bool subst_stack_regs (rtx, stack_ptr); > +static void change_stack (rtx, stack_ptr, stack_ptr, enum emit_where); > +static void print_stack (FILE *, stack_ptr); > static rtx next_flags_user (rtx); > > /* Return nonzero if any stack register is mentioned somewhere within PAT. */ > @@ -354,7 +354,7 @@ next_flags_user (rtx insn) > /* Reorganize the stack into ascending numbers, before this insn. */ > > static void > -straighten_stack (rtx insn, stack regstack) > +straighten_stack (rtx insn, stack_ptr regstack) > { > struct stack_def temp_stack; > int top; > @@ -377,7 +377,7 @@ straighten_stack (rtx insn, stack regstack) > /* Pop a register from the stack. */ > > static void > -pop_stack (stack regstack, int regno) > +pop_stack (stack_ptr regstack, int regno) > { > int top = regstack->top; > > @@ -721,7 +721,7 @@ remove_regno_note (rtx insn, enum reg_note note, unsigned int regno) > returned if the register is not found. */ > > static int > -get_hard_regnum (stack regstack, rtx reg) > +get_hard_regnum (stack_ptr regstack, rtx reg) > { > int i; > > @@ -742,7 +742,7 @@ get_hard_regnum (stack regstack, rtx reg) > cases the movdf pattern to pop. */ > > static rtx > -emit_pop_insn (rtx insn, stack regstack, rtx reg, enum emit_where where) > +emit_pop_insn (rtx insn, stack_ptr regstack, rtx reg, enum emit_where where) > { > rtx pop_insn, pop_rtx; > int hard_regno; > @@ -793,7 +793,7 @@ emit_pop_insn (rtx insn, stack regstack, rtx reg, enum emit_where where) > If REG is already at the top of the stack, no insn is emitted. */ > > static void > -emit_swap_insn (rtx insn, stack regstack, rtx reg) > +emit_swap_insn (rtx insn, stack_ptr regstack, rtx reg) > { > int hard_regno; > rtx swap_rtx; > @@ -900,7 +900,7 @@ emit_swap_insn (rtx insn, stack regstack, rtx reg) > is emitted. */ > > static void > -swap_to_top (rtx insn, stack regstack, rtx src1, rtx src2) > +swap_to_top (rtx insn, stack_ptr regstack, rtx src1, rtx src2) > { > struct stack_def temp_stack; > int regno, j, k, temp; > @@ -941,7 +941,7 @@ swap_to_top (rtx insn, stack regstack, rtx src1, rtx src2) > was deleted in the process. */ > > static bool > -move_for_stack_reg (rtx insn, stack regstack, rtx pat) > +move_for_stack_reg (rtx insn, stack_ptr regstack, rtx pat) > { > rtx *psrc = get_true_reg (&SET_SRC (pat)); > rtx *pdest = get_true_reg (&SET_DEST (pat)); > @@ -1092,7 +1092,7 @@ move_for_stack_reg (rtx insn, stack regstack, rtx pat) > a NaN into DEST, then invokes move_for_stack_reg. */ > > static bool > -move_nan_for_stack_reg (rtx insn, stack regstack, rtx dest) > +move_nan_for_stack_reg (rtx insn, stack_ptr regstack, rtx dest) > { > rtx pat; > > @@ -1231,7 +1231,7 @@ swap_rtx_condition (rtx insn) > set up. */ > > static void > -compare_for_stack_reg (rtx insn, stack regstack, rtx pat_src) > +compare_for_stack_reg (rtx insn, stack_ptr regstack, rtx pat_src) > { > rtx *src1, *src2; > rtx src1_note, src2_note; > @@ -1320,7 +1320,7 @@ compare_for_stack_reg (rtx insn, stack regstack, rtx pat_src) > static int > subst_stack_regs_in_debug_insn (rtx *loc, void *data) > { > - stack regstack = (stack)data; > + stack_ptr regstack = (stack_ptr)data; > int hard_regno; > > if (!STACK_REG_P (*loc)) > @@ -1361,7 +1361,7 @@ subst_all_stack_regs_in_debug_insn (rtx insn, struct stack_def *regstack) > was deleted in the process. */ > > static bool > -subst_stack_regs_pat (rtx insn, stack regstack, rtx pat) > +subst_stack_regs_pat (rtx insn, stack_ptr regstack, rtx pat) > { > rtx *dest, *src; > bool control_flow_insn_deleted = false; > @@ -2009,7 +2009,7 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat) > requirements, since record_asm_stack_regs removes any problem asm. */ > > static void > -subst_asm_stack_regs (rtx insn, stack regstack) > +subst_asm_stack_regs (rtx insn, stack_ptr regstack) > { > rtx body = PATTERN (insn); > int alt; > @@ -2292,7 +2292,7 @@ subst_asm_stack_regs (rtx insn, stack regstack) > a control flow insn was deleted in the process. */ > > static bool > -subst_stack_regs (rtx insn, stack regstack) > +subst_stack_regs (rtx insn, stack_ptr regstack) > { > rtx *note_link, note; > bool control_flow_insn_deleted = false; > @@ -2404,7 +2404,7 @@ subst_stack_regs (rtx insn, stack regstack) > is no longer needed once this has executed. */ > > static void > -change_stack (rtx insn, stack old, stack new_stack, enum emit_where where) > +change_stack (rtx insn, stack_ptr old, stack_ptr new_stack, enum emit_where where) > { > int reg; > int update_end = 0; > @@ -2610,7 +2610,7 @@ change_stack (rtx insn, stack old, stack new_stack, enum emit_where where) > /* Print stack configuration. */ > > static void > -print_stack (FILE *file, stack s) > +print_stack (FILE *file, stack_ptr s) > { > if (! file) > return; > @@ -2686,7 +2686,7 @@ static void > convert_regs_exit (void) > { > int value_reg_low, value_reg_high; > - stack output_stack; > + stack_ptr output_stack; > rtx retvalue; > > retvalue = stack_result (current_function_decl); > @@ -2719,8 +2719,8 @@ convert_regs_exit (void) > static void > propagate_stack (edge e) > { > - stack src_stack = &BLOCK_INFO (e->src)->stack_out; > - stack dest_stack = &BLOCK_INFO (e->dest)->stack_in; > + stack_ptr src_stack = &BLOCK_INFO (e->src)->stack_out; > + stack_ptr dest_stack = &BLOCK_INFO (e->dest)->stack_in; > int reg; > > /* Preserve the order of the original stack, but check whether > @@ -2746,8 +2746,8 @@ static bool > compensate_edge (edge e) > { > basic_block source = e->src, target = e->dest; > - stack target_stack = &BLOCK_INFO (target)->stack_in; > - stack source_stack = &BLOCK_INFO (source)->stack_out; > + stack_ptr target_stack = &BLOCK_INFO (target)->stack_in; > + stack_ptr source_stack = &BLOCK_INFO (source)->stack_out; > struct stack_def regstack; > int reg; > > diff --git a/gcc/regrename.c b/gcc/regrename.c > index 2366fb5..d125242 100644 > --- a/gcc/regrename.c > +++ b/gcc/regrename.c > @@ -728,8 +728,8 @@ regrename_analyze (bitmap bb_mask) > rtx insn; > FOR_BB_INSNS (bb1, insn) > { > - insn_rr_info *p = VEC_index (insn_rr_info, insn_rr, > - INSN_UID (insn)); > + insn_rr_info *p = &VEC_index (insn_rr_info, insn_rr, > + INSN_UID (insn)); > p->op_info = NULL; > } > } > @@ -1583,7 +1583,7 @@ build_def_use (basic_block bb) > > if (insn_rr != NULL) > { > - insn_info = VEC_index (insn_rr_info, insn_rr, INSN_UID (insn)); > + insn_info = &VEC_index (insn_rr_info, insn_rr, INSN_UID (insn)); > insn_info->op_info = XOBNEWVEC (&rename_obstack, operand_rr_info, > recog_data.n_operands); > memset (insn_info->op_info, 0, > diff --git a/gcc/reload.h b/gcc/reload.h > index 29d15ea..a672ddc 100644 > --- a/gcc/reload.h > +++ b/gcc/reload.h > @@ -243,19 +243,19 @@ typedef struct reg_equivs > } reg_equivs_t; > > #define reg_equiv_constant(ELT) \ > - VEC_index (reg_equivs_t, reg_equivs, (ELT))->constant > + VEC_index (reg_equivs_t, reg_equivs, (ELT)).constant > #define reg_equiv_invariant(ELT) \ > - VEC_index (reg_equivs_t, reg_equivs, (ELT))->invariant > + VEC_index (reg_equivs_t, reg_equivs, (ELT)).invariant > #define reg_equiv_memory_loc(ELT) \ > - VEC_index (reg_equivs_t, reg_equivs, (ELT))->memory_loc > + VEC_index (reg_equivs_t, reg_equivs, (ELT)).memory_loc > #define reg_equiv_address(ELT) \ > - VEC_index (reg_equivs_t, reg_equivs, (ELT))->address > + VEC_index (reg_equivs_t, reg_equivs, (ELT)).address > #define reg_equiv_mem(ELT) \ > - VEC_index (reg_equivs_t, reg_equivs, (ELT))->mem > + VEC_index (reg_equivs_t, reg_equivs, (ELT)).mem > #define reg_equiv_alt_mem_list(ELT) \ > - VEC_index (reg_equivs_t, reg_equivs, (ELT))->alt_mem_list > + VEC_index (reg_equivs_t, reg_equivs, (ELT)).alt_mem_list > #define reg_equiv_init(ELT) \ > - VEC_index (reg_equivs_t, reg_equivs, (ELT))->init > + VEC_index (reg_equivs_t, reg_equivs, (ELT)).init > > DEF_VEC_O(reg_equivs_t); > DEF_VEC_ALLOC_O(reg_equivs_t, gc); > diff --git a/gcc/reload1.c b/gcc/reload1.c > index bf5d3d3..b866af5 100644 > --- a/gcc/reload1.c > +++ b/gcc/reload1.c > @@ -664,7 +664,8 @@ grow_reg_equivs (void) > for (i = old_size; i < max_regno; i++) > { > VEC_quick_insert (reg_equivs_t, reg_equivs, i, 0); > - memset (VEC_index (reg_equivs_t, reg_equivs, i), 0, sizeof (reg_equivs_t)); > + memset (&VEC_index (reg_equivs_t, reg_equivs, i), 0, > + sizeof (reg_equivs_t)); > } > > } > diff --git a/gcc/sched-int.h b/gcc/sched-int.h > index fa5fc66..2e46238 100644 > --- a/gcc/sched-int.h > +++ b/gcc/sched-int.h > @@ -873,7 +873,7 @@ DEF_VEC_ALLOC_O (haifa_insn_data_def, heap); > > extern VEC(haifa_insn_data_def, heap) *h_i_d; > > -#define HID(INSN) (VEC_index (haifa_insn_data_def, h_i_d, INSN_UID (INSN))) > +#define HID(INSN) (&VEC_index (haifa_insn_data_def, h_i_d, INSN_UID (INSN))) > > /* Accessor macros for h_i_d. There are more in haifa-sched.c and > sched-rgn.c. */ > @@ -895,7 +895,7 @@ DEF_VEC_ALLOC_O (haifa_deps_insn_data_def, heap); > > extern VEC(haifa_deps_insn_data_def, heap) *h_d_i_d; > > -#define HDID(INSN) (VEC_index (haifa_deps_insn_data_def, h_d_i_d, \ > +#define HDID(INSN) (&VEC_index (haifa_deps_insn_data_def, h_d_i_d, \ > INSN_LUID (INSN))) > #define INSN_DEP_COUNT(INSN) (HDID (INSN)->dep_count) > #define HAS_INTERNAL_DEP(INSN) (HDID (INSN)->has_internal_dep) > @@ -909,7 +909,7 @@ extern VEC(haifa_deps_insn_data_def, heap) *h_d_i_d; > #define INSN_COND_DEPS(INSN) (HDID (INSN)->cond_deps) > #define CANT_MOVE(INSN) (HDID (INSN)->cant_move) > #define CANT_MOVE_BY_LUID(LUID) (VEC_index (haifa_deps_insn_data_def, h_d_i_d, \ > - LUID)->cant_move) > + LUID).cant_move) > > > #define INSN_PRIORITY(INSN) (HID (INSN)->priority) > diff --git a/gcc/sel-sched-ir.c b/gcc/sel-sched-ir.c > index e7ca3f1..449efc9 100644 > --- a/gcc/sel-sched-ir.c > +++ b/gcc/sel-sched-ir.c > @@ -1524,7 +1524,7 @@ insert_in_history_vect (VEC (expr_history_def, heap) **pvect, > > if (res) > { > - expr_history_def *phist = VEC_index (expr_history_def, vect, ind); > + expr_history_def *phist = &VEC_index (expr_history_def, vect, ind); > > /* It is possible that speculation types of expressions that were > propagated through different paths will be different here. In this > @@ -4159,7 +4159,7 @@ finish_insns (void) > removed during the scheduling. */ > for (i = 0; i < VEC_length (sel_insn_data_def, s_i_d); i++) > { > - sel_insn_data_def *sid_entry = VEC_index (sel_insn_data_def, s_i_d, i); > + sel_insn_data_def *sid_entry = &VEC_index (sel_insn_data_def, s_i_d, i); > > if (sid_entry->live) > return_regset_to_pool (sid_entry->live); > diff --git a/gcc/sel-sched-ir.h b/gcc/sel-sched-ir.h > index 2003552..ef884a5 100644 > --- a/gcc/sel-sched-ir.h > +++ b/gcc/sel-sched-ir.h > @@ -765,8 +765,8 @@ DEF_VEC_ALLOC_O (sel_insn_data_def, heap); > extern VEC (sel_insn_data_def, heap) *s_i_d; > > /* Accessor macros for s_i_d. */ > -#define SID(INSN) (VEC_index (sel_insn_data_def, s_i_d, INSN_LUID (INSN))) > -#define SID_BY_UID(UID) (VEC_index (sel_insn_data_def, s_i_d, LUID_BY_UID (UID))) > +#define SID(INSN) (&VEC_index (sel_insn_data_def, s_i_d, INSN_LUID (INSN))) > +#define SID_BY_UID(UID) (&VEC_index (sel_insn_data_def, s_i_d, LUID_BY_UID (UID))) > > extern sel_insn_data_def insn_sid (insn_t); > > @@ -897,7 +897,7 @@ extern void sel_finish_global_bb_info (void); > > /* Get data for BB. */ > #define SEL_GLOBAL_BB_INFO(BB) \ > - (VEC_index (sel_global_bb_info_def, sel_global_bb_info, (BB)->index)) > + (&VEC_index (sel_global_bb_info_def, sel_global_bb_info, (BB)->index)) > > /* Access macros. */ > #define BB_LV_SET(BB) (SEL_GLOBAL_BB_INFO (BB)->lv_set) > @@ -927,8 +927,8 @@ DEF_VEC_ALLOC_O (sel_region_bb_info_def, heap); > extern VEC (sel_region_bb_info_def, heap) *sel_region_bb_info; > > /* Get data for BB. */ > -#define SEL_REGION_BB_INFO(BB) (VEC_index (sel_region_bb_info_def, \ > - sel_region_bb_info, (BB)->index)) > +#define SEL_REGION_BB_INFO(BB) (&VEC_index (sel_region_bb_info_def, \ > + sel_region_bb_info, (BB)->index)) > > /* Get BB's note_list. > A note_list is a list of various notes that was scattered across BB > diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c > index f0c6eaf..b5bffa1 100644 > --- a/gcc/sel-sched.c > +++ b/gcc/sel-sched.c > @@ -1938,9 +1938,9 @@ undo_transformations (av_set_t *av_ptr, rtx insn) > { > expr_history_def *phist; > > - phist = VEC_index (expr_history_def, > - EXPR_HISTORY_OF_CHANGES (expr), > - index); > + phist = &VEC_index (expr_history_def, > + EXPR_HISTORY_OF_CHANGES (expr), > + index); > > switch (phist->type) > { > @@ -3581,7 +3581,7 @@ vinsn_vec_has_expr_p (vinsn_vec_t vinsn_vec, expr_t expr) > EXPR_HISTORY_OF_CHANGES (expr)) > ? VEC_index (expr_history_def, > EXPR_HISTORY_OF_CHANGES (expr), > - i++)->old_expr_vinsn > + i++).old_expr_vinsn > : NULL)) > FOR_EACH_VEC_ELT (vinsn_t, vinsn_vec, n, vinsn) > if (VINSN_SEPARABLE_P (vinsn)) > diff --git a/gcc/tree-call-cdce.c b/gcc/tree-call-cdce.c > index c879548..be020da 100644 > --- a/gcc/tree-call-cdce.c > +++ b/gcc/tree-call-cdce.c > @@ -374,7 +374,7 @@ gen_conditions_for_domain (tree arg, inp_domain domain, > { > /* Now push a separator. */ > if (domain.has_lb) > - VEC_quick_push (gimple, conds, NULL); > + VEC_quick_push (gimple, conds, (gimple)NULL); > > gen_one_condition (arg, domain.ub, > (domain.is_ub_inclusive > @@ -496,7 +496,7 @@ gen_conditions_for_pow_int_base (tree base, tree expn, > type is integer. */ > > /* Push a separator. */ > - VEC_quick_push (gimple, conds, NULL); > + VEC_quick_push (gimple, conds, (gimple)NULL); > > temp = create_tmp_var (int_type, "DCE_COND1"); > cst0 = build_int_cst (int_type, 0); > diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c > index c44567f..7429003 100644 > --- a/gcc/tree-ssa-loop-ivopts.c > +++ b/gcc/tree-ssa-loop-ivopts.c > @@ -3120,7 +3120,7 @@ multiplier_allowed_in_address_p (HOST_WIDE_INT ratio, enum machine_mode mode, > > TODO -- there must be some better way. This all is quite crude. */ > > -typedef struct > +typedef struct address_cost_data_s > { > HOST_WIDE_INT min_offset, max_offset; > unsigned costs[2][2][2][2]; > > diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c > index 233ecce..30c4127 100644 > --- a/gcc/tree-ssa-reassoc.c > +++ b/gcc/tree-ssa-reassoc.c > @@ -962,7 +962,7 @@ static VEC (oecount, heap) *cvec; > static hashval_t > oecount_hash (const void *p) > { > - const oecount *c = VEC_index (oecount, cvec, (size_t)p - 42); > + const oecount *c = &VEC_index (oecount, cvec, (size_t)p - 42); > return htab_hash_pointer (c->op) ^ (hashval_t)c->oecode; > } > > @@ -971,8 +971,8 @@ oecount_hash (const void *p) > static int > oecount_eq (const void *p1, const void *p2) > { > - const oecount *c1 = VEC_index (oecount, cvec, (size_t)p1 - 42); > - const oecount *c2 = VEC_index (oecount, cvec, (size_t)p2 - 42); > + const oecount *c1 = &VEC_index (oecount, cvec, (size_t)p1 - 42); > + const oecount *c2 = &VEC_index (oecount, cvec, (size_t)p2 - 42); > return (c1->oecode == c2->oecode > && c1->op == c2->op); > } > @@ -1354,7 +1354,7 @@ undistribute_ops_list (enum tree_code opcode, > else > { > VEC_pop (oecount, cvec); > - VEC_index (oecount, cvec, (size_t)*slot - 42)->cnt++; > + VEC_index (oecount, cvec, (size_t)*slot - 42).cnt++; > } > } > } > @@ -1381,7 +1381,7 @@ undistribute_ops_list (enum tree_code opcode, > candidates2 = sbitmap_alloc (length); > while (!VEC_empty (oecount, cvec)) > { > - oecount *c = VEC_last (oecount, cvec); > + oecount *c = &VEC_last (oecount, cvec); > if (c->cnt < 2) > break; > > @@ -3190,7 +3190,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) > fputs ("Multiplying by cached product ", dump_file); > for (elt = j; elt < vec_len; elt++) > { > - rf = VEC_index (repeat_factor, repeat_factor_vec, elt); > + rf = &VEC_index (repeat_factor, repeat_factor_vec, elt); > print_generic_expr (dump_file, rf->factor, 0); > if (elt < vec_len - 1) > fputs (" * ", dump_file); > @@ -3216,7 +3216,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) > dump_file); > for (elt = j; elt < vec_len; elt++) > { > - rf = VEC_index (repeat_factor, repeat_factor_vec, elt); > + rf = &VEC_index (repeat_factor, repeat_factor_vec, elt); > print_generic_expr (dump_file, rf->factor, 0); > if (elt < vec_len - 1) > fputs (" * ", dump_file); > @@ -3250,7 +3250,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) > fputs ("Building __builtin_pow call for (", dump_file); > for (elt = j; elt < vec_len; elt++) > { > - rf = VEC_index (repeat_factor, repeat_factor_vec, elt); > + rf = &VEC_index (repeat_factor, repeat_factor_vec, elt); > print_generic_expr (dump_file, rf->factor, 0); > if (elt < vec_len - 1) > fputs (" * ", dump_file); > @@ -3275,8 +3275,8 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) > { > tree op1, op2; > > - rf1 = VEC_index (repeat_factor, repeat_factor_vec, ii); > - rf2 = VEC_index (repeat_factor, repeat_factor_vec, ii + 1); > + rf1 = &VEC_index (repeat_factor, repeat_factor_vec, ii); > + rf2 = &VEC_index (repeat_factor, repeat_factor_vec, ii + 1); > > /* Init the last factor's representative to be itself. */ > if (!rf2->repr) > @@ -3300,7 +3300,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) > > /* Form a call to __builtin_powi for the maximum product > just formed, raised to the power obtained earlier. */ > - rf1 = VEC_index (repeat_factor, repeat_factor_vec, j); > + rf1 = &VEC_index (repeat_factor, repeat_factor_vec, j); > iter_result = make_temp_ssa_name (type, NULL, "reassocpow"); > pow_stmt = gimple_build_call (powi_fndecl, 2, rf1->repr, > build_int_cst (integer_type_node, > @@ -3333,7 +3333,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) > unsigned k = power; > unsigned n; > > - rf1 = VEC_index (repeat_factor, repeat_factor_vec, i); > + rf1 = &VEC_index (repeat_factor, repeat_factor_vec, i); > rf1->count -= power; > > FOR_EACH_VEC_ELT_REVERSE (operand_entry_t, *ops, n, oe) > diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c > index 842c392..55798d1 100644 > --- a/gcc/tree-ssa-sccvn.c > +++ b/gcc/tree-ssa-sccvn.c > @@ -775,7 +775,7 @@ ao_ref_init_from_vn_reference (ao_ref *ref, > alias_set_type base_alias_set = -1; > > /* First get the final access size from just the outermost expression. */ > - op = VEC_index (vn_reference_op_s, ops, 0); > + op = &VEC_index (vn_reference_op_s, ops, 0); > if (op->opcode == COMPONENT_REF) > size_tree = DECL_SIZE (op->op0); > else if (op->opcode == BIT_FIELD_REF) > @@ -815,7 +815,7 @@ ao_ref_init_from_vn_reference (ao_ref *ref, > && op->op0 > && DECL_P (TREE_OPERAND (op->op0, 0))) > { > - vn_reference_op_t pop = VEC_index (vn_reference_op_s, ops, i-1); > + vn_reference_op_t pop = &VEC_index (vn_reference_op_s, ops, i-1); > base = TREE_OPERAND (op->op0, 0); > if (pop->off == -1) > { > @@ -1004,8 +1004,8 @@ vn_reference_fold_indirect (VEC (vn_reference_op_s, heap) **ops, > unsigned int *i_p) > { > unsigned int i = *i_p; > - vn_reference_op_t op = VEC_index (vn_reference_op_s, *ops, i); > - vn_reference_op_t mem_op = VEC_index (vn_reference_op_s, *ops, i - 1); > + vn_reference_op_t op = &VEC_index (vn_reference_op_s, *ops, i); > + vn_reference_op_t mem_op = &VEC_index (vn_reference_op_s, *ops, i - 1); > tree addr_base; > HOST_WIDE_INT addr_offset; > > @@ -1036,8 +1036,8 @@ vn_reference_maybe_forwprop_address (VEC (vn_reference_op_s, heap) **ops, > unsigned int *i_p) > { > unsigned int i = *i_p; > - vn_reference_op_t op = VEC_index (vn_reference_op_s, *ops, i); > - vn_reference_op_t mem_op = VEC_index (vn_reference_op_s, *ops, i - 1); > + vn_reference_op_t op = &VEC_index (vn_reference_op_s, *ops, i); > + vn_reference_op_t mem_op = &VEC_index (vn_reference_op_s, *ops, i - 1); > gimple def_stmt; > enum tree_code code; > double_int off; > @@ -1114,7 +1114,7 @@ fully_constant_vn_reference_p (vn_reference_t ref) > > /* Try to simplify the translated expression if it is > a call to a builtin function with at most two arguments. */ > - op = VEC_index (vn_reference_op_s, operands, 0); > + op = &VEC_index (vn_reference_op_s, operands, 0); > if (op->opcode == CALL_EXPR > && TREE_CODE (op->op0) == ADDR_EXPR > && TREE_CODE (TREE_OPERAND (op->op0, 0)) == FUNCTION_DECL > @@ -1124,9 +1124,9 @@ fully_constant_vn_reference_p (vn_reference_t ref) > { > vn_reference_op_t arg0, arg1 = NULL; > bool anyconst = false; > - arg0 = VEC_index (vn_reference_op_s, operands, 1); > + arg0 = &VEC_index (vn_reference_op_s, operands, 1); > if (VEC_length (vn_reference_op_s, operands) > 2) > - arg1 = VEC_index (vn_reference_op_s, operands, 2); > + arg1 = &VEC_index (vn_reference_op_s, operands, 2); > if (TREE_CODE_CLASS (arg0->opcode) == tcc_constant > || (arg0->opcode == ADDR_EXPR > && is_gimple_min_invariant (arg0->op0))) > @@ -1158,7 +1158,7 @@ fully_constant_vn_reference_p (vn_reference_t ref) > && VEC_length (vn_reference_op_s, operands) == 2) > { > vn_reference_op_t arg0; > - arg0 = VEC_index (vn_reference_op_s, operands, 1); > + arg0 = &VEC_index (vn_reference_op_s, operands, 1); > if (arg0->opcode == STRING_CST > && (TYPE_MODE (op->type) > == TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0->op0)))) > @@ -1226,12 +1226,12 @@ valueize_refs_1 (VEC (vn_reference_op_s, heap) *orig, bool *valueized_anything) > && vro->op0 > && TREE_CODE (vro->op0) == ADDR_EXPR > && VEC_index (vn_reference_op_s, > - orig, i - 1)->opcode == MEM_REF) > + orig, i - 1).opcode == MEM_REF) > vn_reference_fold_indirect (&orig, &i); > else if (i > 0 > && vro->opcode == SSA_NAME > && VEC_index (vn_reference_op_s, > - orig, i - 1)->opcode == MEM_REF) > + orig, i - 1).opcode == MEM_REF) > vn_reference_maybe_forwprop_address (&orig, &i); > /* If it transforms a non-constant ARRAY_REF into a constant > one, adjust the constant offset. */ > @@ -1624,9 +1624,9 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_) > i = VEC_length (vn_reference_op_s, vr->operands) - 1; > j = VEC_length (vn_reference_op_s, lhs_ops) - 1; > while (j >= 0 && i >= 0 > - && vn_reference_op_eq (VEC_index (vn_reference_op_s, > - vr->operands, i), > - VEC_index (vn_reference_op_s, lhs_ops, j))) > + && vn_reference_op_eq (&VEC_index (vn_reference_op_s, > + vr->operands, i), > + &VEC_index (vn_reference_op_s, lhs_ops, j))) > { > i--; > j--; > @@ -1639,10 +1639,10 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_) > don't care here - further lookups with the rewritten operands > will simply fail if we messed up types too badly. */ > if (j == 0 && i >= 0 > - && VEC_index (vn_reference_op_s, lhs_ops, 0)->opcode == MEM_REF > - && VEC_index (vn_reference_op_s, lhs_ops, 0)->off != -1 > - && (VEC_index (vn_reference_op_s, lhs_ops, 0)->off > - == VEC_index (vn_reference_op_s, vr->operands, i)->off)) > + && VEC_index (vn_reference_op_s, lhs_ops, 0).opcode == MEM_REF > + && VEC_index (vn_reference_op_s, lhs_ops, 0).off != -1 > + && (VEC_index (vn_reference_op_s, lhs_ops, 0).off > + == VEC_index (vn_reference_op_s, vr->operands, i).off)) > i--, j--; > > /* i now points to the first additional op. > @@ -1669,7 +1669,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_) > VEC_truncate (vn_reference_op_s, vr->operands, > i + 1 + VEC_length (vn_reference_op_s, rhs)); > FOR_EACH_VEC_ELT (vn_reference_op_s, rhs, j, vro) > - VEC_replace (vn_reference_op_s, vr->operands, i + 1 + j, vro); > + VEC_replace (vn_reference_op_s, vr->operands, i + 1 + j, *vro); > VEC_free (vn_reference_op_s, heap, rhs); > vr->operands = valueize_refs (vr->operands); > vr->hashcode = vn_reference_compute_hash (vr); > @@ -1807,12 +1807,12 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_) > op.opcode = MEM_REF; > op.op0 = build_int_cst (ptr_type_node, at - rhs_offset); > op.off = at - lhs_offset + rhs_offset; > - VEC_replace (vn_reference_op_s, vr->operands, 0, &op); > + VEC_replace (vn_reference_op_s, vr->operands, 0, op); > op.type = TREE_TYPE (rhs); > op.opcode = TREE_CODE (rhs); > op.op0 = rhs; > op.off = -1; > - VEC_replace (vn_reference_op_s, vr->operands, 1, &op); > + VEC_replace (vn_reference_op_s, vr->operands, 1, op); > vr->hashcode = vn_reference_compute_hash (vr); > > /* Adjust *ref from the new operands. */ > @@ -3746,7 +3746,7 @@ start_over: > /* Restore the last use walker and continue walking there. */ > use = name; > name = VEC_pop (tree, namevec); > - memcpy (&iter, VEC_last (ssa_op_iter, itervec), > + memcpy (&iter, &VEC_last (ssa_op_iter, itervec), > sizeof (ssa_op_iter)); > VEC_pop (ssa_op_iter, itervec); > goto continue_walking; > diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c > index 5b185b6..c108f76 100644 > --- a/gcc/tree-ssa-structalias.c > +++ b/gcc/tree-ssa-structalias.c > @@ -2927,7 +2927,7 @@ get_constraint_for_ptr_offset (tree ptr, tree offset, > for (j = 0; j < n; j++) > { > varinfo_t curr; > - c = *VEC_index (ce_s, *results, j); > + c = VEC_index (ce_s, *results, j); > curr = get_varinfo (c.var); > > if (c.type == ADDRESSOF > @@ -2989,7 +2989,7 @@ get_constraint_for_ptr_offset (tree ptr, tree offset, > else > c.offset = rhsoffset; > > - VEC_replace (ce_s, *results, j, &c); > + VEC_replace (ce_s, *results, j, c); > } > } > > @@ -3058,7 +3058,7 @@ get_constraint_for_component_ref (tree t, VEC(ce_s, heap) **results, > adding the required subset of sub-fields below. */ > get_constraint_for_1 (t, results, true, lhs_p); > gcc_assert (VEC_length (ce_s, *results) == 1); > - result = VEC_last (ce_s, *results); > + result = &VEC_last (ce_s, *results); > > if (result->type == SCALAR > && get_varinfo (result->var)->is_full_var) > @@ -3284,13 +3284,13 @@ get_constraint_for_1 (tree t, VEC (ce_s, heap) **results, bool address_p, > if (address_p) > return; > > - cs = *VEC_last (ce_s, *results); > + cs = VEC_last (ce_s, *results); > if (cs.type == DEREF > && type_can_have_subvars (TREE_TYPE (t))) > { > /* For dereferences this means we have to defer it > to solving time. */ > - VEC_last (ce_s, *results)->offset = UNKNOWN_OFFSET; > + VEC_last (ce_s, *results).offset = UNKNOWN_OFFSET; > return; > } > if (cs.type != SCALAR) > @@ -3451,8 +3451,8 @@ do_structure_copy (tree lhsop, tree rhsop) > > get_constraint_for (lhsop, &lhsc); > get_constraint_for_rhs (rhsop, &rhsc); > - lhsp = VEC_index (ce_s, lhsc, 0); > - rhsp = VEC_index (ce_s, rhsc, 0); > + lhsp = &VEC_index (ce_s, lhsc, 0); > + rhsp = &VEC_index (ce_s, rhsc, 0); > if (lhsp->type == DEREF > || (lhsp->type == ADDRESSOF && lhsp->var == anything_id) > || rhsp->type == DEREF) > @@ -3481,7 +3481,7 @@ do_structure_copy (tree lhsop, tree rhsop) > for (j = 0; VEC_iterate (ce_s, lhsc, j, lhsp);) > { > varinfo_t lhsv, rhsv; > - rhsp = VEC_index (ce_s, rhsc, k); > + rhsp = &VEC_index (ce_s, rhsc, k); > lhsv = get_varinfo (lhsp->var); > rhsv = get_varinfo (rhsp->var); > if (lhsv->may_have_pointers > @@ -4377,7 +4377,7 @@ find_func_aliases_for_call (gimple t) > lhs = get_function_part_constraint (fi, fi_parm_base + j); > while (VEC_length (ce_s, rhsc) != 0) > { > - rhsp = VEC_last (ce_s, rhsc); > + rhsp = &VEC_last (ce_s, rhsc); > process_constraint (new_constraint (lhs, *rhsp)); > VEC_pop (ce_s, rhsc); > } > @@ -4399,7 +4399,7 @@ find_func_aliases_for_call (gimple t) > VEC(ce_s, heap) *tem = NULL; > VEC_safe_push (ce_s, heap, tem, &rhs); > do_deref (&tem); > - rhs = *VEC_index (ce_s, tem, 0); > + rhs = VEC_index (ce_s, tem, 0); > VEC_free(ce_s, heap, tem); > } > FOR_EACH_VEC_ELT (ce_s, lhsc, j, lhsp) > @@ -4471,7 +4471,7 @@ find_func_aliases (gimple origt) > struct constraint_expr *c2; > while (VEC_length (ce_s, rhsc) > 0) > { > - c2 = VEC_last (ce_s, rhsc); > + c2 = &VEC_last (ce_s, rhsc); > process_constraint (new_constraint (*c, *c2)); > VEC_pop (ce_s, rhsc); > } > @@ -5158,7 +5158,7 @@ push_fields_onto_fieldstack (tree type, VEC(fieldoff_s,heap) **fieldstack, > bool must_have_pointers_p; > > if (!VEC_empty (fieldoff_s, *fieldstack)) > - pair = VEC_last (fieldoff_s, *fieldstack); > + pair = &VEC_last (fieldoff_s, *fieldstack); > > /* If there isn't anything at offset zero, create sth. */ > if (!pair > diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c > index e0b68c7..4e25159 100644 > --- a/gcc/tree-vect-loop-manip.c > +++ b/gcc/tree-vect-loop-manip.c > @@ -188,7 +188,7 @@ adjust_vec_debug_stmts (void) > > while (!VEC_empty (adjust_info, adjust_vec)) > { > - adjust_debug_stmts_now (VEC_last (adjust_info, adjust_vec)); > + adjust_debug_stmts_now (&VEC_last (adjust_info, adjust_vec)); > VEC_pop (adjust_info, adjust_vec); > } > > @@ -2550,4 +2550,3 @@ vect_loop_versioning (loop_vec_info loop_vinfo, > GSI_SAME_STMT); > } > } > - > diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c > index 782172f..a4c7483 100644 > --- a/gcc/tree-vect-slp.c > +++ b/gcc/tree-vect-slp.c > @@ -1098,7 +1098,7 @@ vect_slp_rearrange_stmts (slp_tree node, unsigned int group_size, > tmp_stmts = VEC_alloc (gimple, heap, group_size); > > for (i = 0; i < group_size; i++) > - VEC_safe_push (gimple, heap, tmp_stmts, NULL); > + VEC_safe_push (gimple, heap, tmp_stmts, (gimple)NULL); > > FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt) > { > @@ -2653,7 +2653,7 @@ vect_create_mask_and_perm (gimple stmt, gimple next_scalar_stmt, > stmts later. */ > for (i = VEC_length (gimple, SLP_TREE_VEC_STMTS (node)); > i < (int) SLP_TREE_NUMBER_OF_VEC_STMTS (node); i++) > - VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (node), NULL); > + VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (node), (gimple)NULL); > > perm_dest = vect_create_destination_var (gimple_assign_lhs (stmt), vectype); > for (i = 0; i < ncopies; i++) > diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c > index eb6402b..e3f46ec 100644 > --- a/gcc/tree-vrp.c > +++ b/gcc/tree-vrp.c > @@ -8862,7 +8862,7 @@ vrp_fold_stmt (gimple_stmt_iterator *si) > > A NULL entry is used to mark the end of pairs which need to be > restored. */ > -static VEC(tree,heap) *stack; > +static VEC(tree,heap) *equiv_stack; > > /* A trivial wrapper so that we can present the generic jump threading > code with a simple API for simplifying statements. STMT is the > @@ -8930,7 +8930,7 @@ identify_jump_threads (void) > > /* Allocate our unwinder stack to unwind any temporary equivalences > that might be recorded. */ > - stack = VEC_alloc (tree, heap, 20); > + equiv_stack = VEC_alloc (tree, heap, 20); > > /* To avoid lots of silly node creation, we create a single > conditional and just modify it in-place when attempting to > @@ -8984,7 +8984,7 @@ identify_jump_threads (void) > if (e->flags & (EDGE_DFS_BACK | EDGE_COMPLEX)) > continue; > > - thread_across_edge (dummy, e, true, &stack, > + thread_across_edge (dummy, e, true, &equiv_stack, > simplify_stmt_for_jump_threading); > } > } > @@ -9005,7 +9005,7 @@ static void > finalize_jump_threads (void) > { > thread_through_all_blocks (false); > - VEC_free (tree, heap, stack); > + VEC_free (tree, heap, equiv_stack); > } > > > diff --git a/gcc/tree.c b/gcc/tree.c > index 6e864c3..e0bd2b5 100644 > --- a/gcc/tree.c > +++ b/gcc/tree.c > @@ -6704,8 +6704,8 @@ simple_cst_equal (const_tree t1, const_tree t2) > > for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx) > /* ??? Should we handle also fields here? */ > - if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value, > - VEC_index (constructor_elt, v2, idx)->value)) > + if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx).value, > + VEC_index (constructor_elt, v2, idx).value)) > return false; > return true; > } > diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c > index a79872f..818fb24 100644 > --- a/gcc/var-tracking.c > +++ b/gcc/var-tracking.c > @@ -7821,7 +7821,7 @@ loc_exp_dep_clear (variable var) > { > while (!VEC_empty (loc_exp_dep, VAR_LOC_DEP_VEC (var))) > { > - loc_exp_dep *led = VEC_last (loc_exp_dep, VAR_LOC_DEP_VEC (var)); > + loc_exp_dep *led = &VEC_last (loc_exp_dep, VAR_LOC_DEP_VEC (var)); > if (led->next) > led->next->pprev = led->pprev; > if (led->pprev) > @@ -7865,7 +7865,7 @@ loc_exp_insert_dep (variable var, rtx x, htab_t vars) > else > { > VEC_quick_push (loc_exp_dep, VAR_LOC_DEP_VEC (var), NULL); > - led = VEC_last (loc_exp_dep, VAR_LOC_DEP_VEC (var)); > + led = &VEC_last (loc_exp_dep, VAR_LOC_DEP_VEC (var)); > } > led->dv = var->dv; > led->value = x; > diff --git a/gcc/varasm.c b/gcc/varasm.c > index a1f0a23..b380a47 100644 > --- a/gcc/varasm.c > +++ b/gcc/varasm.c > @@ -2871,8 +2871,8 @@ compare_constant (const tree t1, const tree t2) > > for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx) > { > - constructor_elt *c1 = VEC_index (constructor_elt, v1, idx); > - constructor_elt *c2 = VEC_index (constructor_elt, v2, idx); > + constructor_elt *c1 = &VEC_index (constructor_elt, v1, idx); > + constructor_elt *c2 = &VEC_index (constructor_elt, v2, idx); > > /* Check that each value is the same... */ > if (!compare_constant (c1->value, c2->value)) > diff --git a/gcc/vec.c b/gcc/vec.c > index 85274c4..51a55d9 100644 > --- a/gcc/vec.c > +++ b/gcc/vec.c > @@ -1,7 +1,8 @@ > /* Vector API for GNU compiler. > - Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 > + Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010, 2011, 2012 > Free Software Foundation, Inc. > Contributed by Nathan Sidwell <nathan@codesourcery.com> > + Re-implemented in C++ by Diego Novillo <dnovillo@google.com> > > This file is part of GCC. > > @@ -213,7 +214,7 @@ calculate_allocation (const struct vec_prefix *pfx, int reserve, bool exact) > trailing array is at VEC_OFFSET offset and consists of ELT_SIZE > sized elements. */ > > -static void * > +void * > vec_gc_o_reserve_1 (void *vec, int reserve, size_t vec_offset, size_t elt_size, > bool exact MEM_STAT_DECL) > { > @@ -246,61 +247,10 @@ vec_gc_o_reserve_1 (void *vec, int reserve, size_t vec_offset, size_t elt_size, > return vec; > } > > -/* Ensure there are at least RESERVE free slots in VEC, growing > - exponentially. If RESERVE < 0 grow exactly, else grow > - exponentially. As a special case, if VEC is NULL, and RESERVE is > - 0, no vector will be created. */ > - > -void * > -vec_gc_p_reserve (void *vec, int reserve MEM_STAT_DECL) > -{ > - return vec_gc_o_reserve_1 (vec, reserve, > - sizeof (struct vec_prefix), > - sizeof (void *), false > - PASS_MEM_STAT); > -} > - > -/* Ensure there are at least RESERVE free slots in VEC, growing > - exactly. If RESERVE < 0 grow exactly, else grow exponentially. As > - a special case, if VEC is NULL, and RESERVE is 0, no vector will be > - created. */ > - > -void * > -vec_gc_p_reserve_exact (void *vec, int reserve MEM_STAT_DECL) > -{ > - return vec_gc_o_reserve_1 (vec, reserve, > - sizeof (struct vec_prefix), > - sizeof (void *), true > - PASS_MEM_STAT); > -} > - > -/* As for vec_gc_p_reserve, but for object vectors. The vector's > - trailing array is at VEC_OFFSET offset and consists of ELT_SIZE > - sized elements. */ > - > -void * > -vec_gc_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size > - MEM_STAT_DECL) > -{ > - return vec_gc_o_reserve_1 (vec, reserve, vec_offset, elt_size, false > - PASS_MEM_STAT); > -} > - > -/* As for vec_gc_p_reserve_exact, but for object vectors. The > - vector's trailing array is at VEC_OFFSET offset and consists of > - ELT_SIZE sized elements. */ > - > -void * > -vec_gc_o_reserve_exact (void *vec, int reserve, size_t vec_offset, > - size_t elt_size MEM_STAT_DECL) > -{ > - return vec_gc_o_reserve_1 (vec, reserve, vec_offset, elt_size, true > - PASS_MEM_STAT); > -} > > /* As for vec_gc_o_reserve_1, but for heap allocated vectors. */ > > -static void * > +void * > vec_heap_o_reserve_1 (void *vec, int reserve, size_t vec_offset, > size_t elt_size, bool exact MEM_STAT_DECL) > { > @@ -328,47 +278,6 @@ vec_heap_o_reserve_1 (void *vec, int reserve, size_t vec_offset, > return vec; > } > > -/* As for vec_gc_p_reserve, but for heap allocated vectors. */ > - > -void * > -vec_heap_p_reserve (void *vec, int reserve MEM_STAT_DECL) > -{ > - return vec_heap_o_reserve_1 (vec, reserve, > - sizeof (struct vec_prefix), > - sizeof (void *), false > - PASS_MEM_STAT); > -} > - > -/* As for vec_gc_p_reserve_exact, but for heap allocated vectors. */ > - > -void * > -vec_heap_p_reserve_exact (void *vec, int reserve MEM_STAT_DECL) > -{ > - return vec_heap_o_reserve_1 (vec, reserve, > - sizeof (struct vec_prefix), > - sizeof (void *), true > - PASS_MEM_STAT); > -} > - > -/* As for vec_gc_o_reserve, but for heap allocated vectors. */ > - > -void * > -vec_heap_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size > - MEM_STAT_DECL) > -{ > - return vec_heap_o_reserve_1 (vec, reserve, vec_offset, elt_size, false > - PASS_MEM_STAT); > -} > - > -/* As for vec_gc_o_reserve_exact, but for heap allocated vectors. */ > - > -void * > -vec_heap_o_reserve_exact (void *vec, int reserve, size_t vec_offset, > - size_t elt_size MEM_STAT_DECL) > -{ > - return vec_heap_o_reserve_1 (vec, reserve, vec_offset, elt_size, true > - PASS_MEM_STAT); > -} > > /* Stack vectors are a little different. VEC_alloc turns into a call > to vec_stack_p_reserve_exact1 and passes in space allocated via a > @@ -450,28 +359,6 @@ vec_stack_o_reserve_1 (void *vec, int reserve, size_t vec_offset, > /* Grow a vector allocated on the stack. */ > > void * > -vec_stack_p_reserve (void *vec, int reserve MEM_STAT_DECL) > -{ > - return vec_stack_o_reserve_1 (vec, reserve, > - sizeof (struct vec_prefix), > - sizeof (void *), false > - PASS_MEM_STAT); > -} > - > -/* Exact version of vec_stack_p_reserve. */ > - > -void * > -vec_stack_p_reserve_exact (void *vec, int reserve MEM_STAT_DECL) > -{ > - return vec_stack_o_reserve_1 (vec, reserve, > - sizeof (struct vec_prefix), > - sizeof (void *), true > - PASS_MEM_STAT); > -} > - > -/* Like vec_stack_p_reserve, but for objects. */ > - > -void * > vec_stack_o_reserve (void *vec, int reserve, size_t vec_offset, > size_t elt_size MEM_STAT_DECL) > { > @@ -479,7 +366,7 @@ vec_stack_o_reserve (void *vec, int reserve, size_t vec_offset, > PASS_MEM_STAT); > } > > -/* Like vec_stack_p_reserve_exact, but for objects. */ > +/* Exact version of vec_stack_o_reserve. */ > > void * > vec_stack_o_reserve_exact (void *vec, int reserve, size_t vec_offset, > diff --git a/gcc/vec.h b/gcc/vec.h > index cb87112..5fdb859 100644 > --- a/gcc/vec.h > +++ b/gcc/vec.h > @@ -1,7 +1,8 @@ > /* Vector API for GNU compiler. > - Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010 > + Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012 > Free Software Foundation, Inc. > Contributed by Nathan Sidwell <nathan@codesourcery.com> > + Re-implemented in C++ by Diego Novillo <dnovillo@google.com> > > This file is part of GCC. > > @@ -134,6 +135,153 @@ along with GCC; see the file COPYING3. If not see > > */ > > +#if ENABLE_CHECKING > +#define VEC_CHECK_INFO ,__FILE__,__LINE__,__FUNCTION__ > +#define VEC_CHECK_DECL ,const char *file_,unsigned line_,const char *function_ > +#define VEC_CHECK_PASS ,file_,line_,function_ > + > +#define VEC_ASSERT(EXPR,OP,T,A) \ > + (void)((EXPR) ? 0 : (VEC_ASSERT_FAIL(OP,VEC(T,A)), 0)) > + > +extern void vec_assert_fail (const char *, const char * VEC_CHECK_DECL) > + ATTRIBUTE_NORETURN; > +#define VEC_ASSERT_FAIL(OP,VEC) vec_assert_fail (OP,#VEC VEC_CHECK_PASS) > +#else > +#define VEC_CHECK_INFO > +#define VEC_CHECK_DECL > +#define VEC_CHECK_PASS > +#define VEC_ASSERT(EXPR,OP,T,A) (void)(EXPR) > +#endif > + > +#define VEC(T,A) vec_t<T> > + > +enum vec_allocation_t { heap, gc, stack }; > + > +struct vec_prefix > +{ > + unsigned num; > + unsigned alloc; > +}; > + > +/* Vector type, user visible. */ > +template<typename T> > +struct GTY(()) vec_t > +{ > + vec_prefix prefix; > + T vec[1]; > +}; > + > +/* Garbage collection support for vec_t. */ > + > +template<typename T> > +void > +gt_ggc_mx (vec_t<T> *v) > +{ > + extern void gt_ggc_mx (T&); > + for (unsigned i = 0; i < v->prefix.num; i++) > + gt_ggc_mx (v->vec[i]); > +} > + > + > +/* PCH support for vec_t. */ > + > +template<typename T> > +void > +gt_pch_nx (vec_t<T> *v) > +{ > + extern void gt_pch_nx (T&); > + for (unsigned i = 0; i < v->prefix.num; i++) > + gt_pch_nx (v->vec[i]); > +} > + > +template<typename T> > +void > +gt_pch_nx (vec_t<T *> *v, gt_pointer_operator op, void *cookie) > +{ > + for (unsigned i = 0; i < v->prefix.num; i++) > + op (&(v->vec[i]), cookie); > +} > + > +template<typename T> > +void > +gt_pch_nx (vec_t<T> *v, gt_pointer_operator op, void *cookie) > +{ > + extern void gt_pch_nx (T *, gt_pointer_operator, void *); > + for (unsigned i = 0; i < v->prefix.num; i++) > + gt_pch_nx (&(v->vec[i]), op, cookie); > +} > + > + > +/* FIXME cxx-conversion. Remove these definitions and update all > + calling sites. */ > +/* Vector of integer-like object. */ > +#define DEF_VEC_I(T) struct vec_swallow_trailing_semi > +#define DEF_VEC_ALLOC_I(T,A) struct vec_swallow_trailing_semi > + > +/* Vector of pointer to object. */ > +#define DEF_VEC_P(T) struct vec_swallow_trailing_semi > +#define DEF_VEC_ALLOC_P(T,A) struct vec_swallow_trailing_semi > + > +/* Vector of object. */ > +#define DEF_VEC_O(T) struct vec_swallow_trailing_semi > +#define DEF_VEC_ALLOC_O(T,A) struct vec_swallow_trailing_semi > + > +/* Vectors on the stack. */ > +#define DEF_VEC_ALLOC_P_STACK(T) struct vec_swallow_trailing_semi > +#define DEF_VEC_ALLOC_O_STACK(T) struct vec_swallow_trailing_semi > +#define DEF_VEC_ALLOC_I_STACK(T) struct vec_swallow_trailing_semi > + > +/* Vectors of atomic types. Atomic types do not need to have its > + elements marked for GC and PCH. To avoid unnecessary traversals, > + we provide template instantiations for the GC/PCH functions that > + do not traverse the vector. > + > + FIXME cxx-conversion - Once vec_t users are converted this can > + be provided in some other way (e.g., adding an additional template > + parameter to the vec_t class). */ > +#define DEF_VEC_A(TYPE) \ > +template<typename T> \ > +void \ > +gt_ggc_mx (vec_t<TYPE> *v ATTRIBUTE_UNUSED) \ > +{ \ > +} \ > + \ > +template<typename T> \ > +void \ > +gt_pch_nx (vec_t<TYPE> *v ATTRIBUTE_UNUSED) \ > +{ \ > +} \ > + \ > +template<typename T> \ > +void \ > +gt_pch_nx (vec_t<TYPE> *v ATTRIBUTE_UNUSED, \ > + gt_pointer_operator op ATTRIBUTE_UNUSED, \ > + void *cookie ATTRIBUTE_UNUSED) \ > +{ \ > +} \ > +struct vec_swallow_trailing_semi > + > +#define DEF_VEC_ALLOC_A(T,A) struct vec_swallow_trailing_semi > + > +/* Support functions for stack vectors. */ > +extern void *vec_stack_p_reserve_exact_1 (int, void *); > +extern void *vec_stack_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); > +extern void *vec_stack_o_reserve_exact (void *, int, size_t, size_t > + MEM_STAT_DECL); > +extern void vec_stack_free (void *); > + > +/* Reallocate an array of elements with prefix. */ > +template<typename T, enum vec_allocation_t A> > +extern vec_t<T> *vec_reserve (vec_t<T> *, int MEM_STAT_DECL); > + > +template<typename T, enum vec_allocation_t A> > +extern vec_t<T> *vec_reserve_exact (vec_t<T> *, int MEM_STAT_DECL); > + > +extern void dump_vec_loc_statistics (void); > +extern void ggc_free (void *); > +extern void vec_heap_free (void *); > + > + > /* Macros to invoke API calls. A single macro works for both pointer > and object vectors, but the argument and return types might well be > different. In each macro, T is the typedef of the vector elements, > @@ -148,7 +296,14 @@ along with GCC; see the file COPYING3. If not see > Return the number of active elements in V. V can be NULL, in which > case zero is returned. */ > > -#define VEC_length(T,V) (VEC_OP(T,base,length)(VEC_BASE(V))) > +#define VEC_length(T,V) (VEC_length_1<T> (V)) > + > +template<typename T> > +static inline unsigned > +VEC_length_1 (const vec_t<T> *vec_) > +{ > + return vec_ ? vec_->prefix.num : 0; > +} > > > /* Check if vector is empty > @@ -156,7 +311,30 @@ along with GCC; see the file COPYING3. If not see > > Return nonzero if V is an empty vector (or V is NULL), zero otherwise. */ > > -#define VEC_empty(T,V) (VEC_length (T,V) == 0) > +#define VEC_empty(T,V) (VEC_empty_1<T> (V)) > + > +template<typename T> > +static inline bool > +VEC_empty_1 (const vec_t<T> *vec_) > +{ > + return VEC_length (T, vec_) == 0; > +} > + > + > +/* Get the address of the array of elements > + T *VEC_T_address (VEC(T) v) > + > + If you need to directly manipulate the array (for instance, you > + want to feed it to qsort), use this accessor. */ > + > +#define VEC_address(T,V) (VEC_address_1<T> (V)) > + > +template<typename T> > +static inline T * > +VEC_address_1 (vec_t<T> *vec_) > +{ > + return vec_ ? vec_->vec : 0; > +} > > > /* Get the final element of the vector. > @@ -166,16 +344,42 @@ along with GCC; see the file COPYING3. If not see > > Return the final element. V must not be empty. */ > > -#define VEC_last(T,V) (VEC_OP(T,base,last)(VEC_BASE(V) VEC_CHECK_INFO)) > +#define VEC_last(T,V) (VEC_last_1<T> (V VEC_CHECK_INFO)) > + > +template<typename T> > +static inline T& > +VEC_last_1 (vec_t<T> *vec_ VEC_CHECK_DECL) > +{ > + VEC_ASSERT (vec_ && vec_->prefix.num, "last", T, base); > + return vec_->vec[vec_->prefix.num - 1]; > +} > + > > /* Index into vector > T VEC_T_index(VEC(T) *v, unsigned ix); // Integer > T VEC_T_index(VEC(T) *v, unsigned ix); // Pointer > T *VEC_T_index(VEC(T) *v, unsigned ix); // Object > > - Return the IX'th element. If IX must be in the domain of V. */ > + Return the IX'th element. IX must be in the domain of V. */ > + > +#define VEC_index(T,V,I) (VEC_index_1<T> (V, I VEC_CHECK_INFO)) > + > +template<typename T> > +static inline T& > +VEC_index_1 (vec_t<T> *vec_, unsigned ix_ VEC_CHECK_DECL) > +{ > + VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); > + return vec_->vec[ix_]; > +} > + > +template<typename T> > +static inline const T& > +VEC_index_1 (const vec_t<T> *vec_, unsigned ix_ VEC_CHECK_DECL) > +{ > + VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); > + return vec_->vec[ix_]; > +} > > -#define VEC_index(T,V,I) (VEC_OP(T,base,index)(VEC_BASE(V),I VEC_CHECK_INFO)) > > /* Iterate over vector > int VEC_T_iterate(VEC(T) *v, unsigned ix, T &ptr); // Integer > @@ -189,7 +393,39 @@ along with GCC; see the file COPYING3. If not see > for (ix = 0; VEC_iterate(T,v,ix,ptr); ix++) > continue; */ > > -#define VEC_iterate(T,V,I,P) (VEC_OP(T,base,iterate)(VEC_BASE(V),I,&(P))) > +#define VEC_iterate(T,V,I,P) (VEC_iterate_1<T> (V, I, &(P))) > + > +template<typename T> > +static inline bool > +VEC_iterate_1 (const vec_t<T> *vec_, unsigned ix_, T *ptr) > +{ > + if (vec_ && ix_ < vec_->prefix.num) > + { > + *ptr = vec_->vec[ix_]; > + return true; > + } > + else > + { > + *ptr = 0; > + return false; > + } > +} > + > +template<typename T> > +static inline bool > +VEC_iterate_1 (vec_t<T> *vec_, unsigned ix_, T **ptr) > +{ > + if (vec_ && ix_ < vec_->prefix.num) > + { > + *ptr = &vec_->vec[ix_]; > + return true; > + } > + else > + { > + *ptr = 0; > + return false; > + } > +} > > /* Convenience macro for forward iteration. */ > > @@ -208,31 +444,99 @@ along with GCC; see the file COPYING3. If not see > VEC_iterate (T, (V), (I), (P)); \ > (I)--) > > + > +/* Use these to determine the required size and initialization of a > + vector embedded within another structure (as the final member). > + > + size_t VEC_T_embedded_size(int reserve); > + void VEC_T_embedded_init(VEC(T) *v, int reserve); > + > + These allow the caller to perform the memory allocation. */ > + > +#define VEC_embedded_size(T,N) (VEC_embedded_size_1<T> (N)) > + > +template<typename T> > +static inline size_t > +VEC_embedded_size_1 (int alloc_) > +{ > + return offsetof (vec_t<T>, vec) + alloc_ * sizeof (T); > +} > + > +#define VEC_embedded_init(T,O,N) (VEC_embedded_init_1<T> (O, N)) > + > +template<typename T> > +static inline void > +VEC_embedded_init_1 (vec_t<T> *vec_, int alloc_) > +{ > + vec_->prefix.num = 0; > + vec_->prefix.alloc = alloc_; > +} > + > + > /* Allocate new vector. > VEC(T,A) *VEC_T_A_alloc(int reserve); > > Allocate a new vector with space for RESERVE objects. If RESERVE > - is zero, NO vector is created. */ > + is zero, NO vector is created. > + > + We support a vector which starts out with space on the stack and > + switches to heap space when forced to reallocate. This works a > + little differently. In the case of stack vectors, VEC_alloc will > + expand to a call to VEC_alloc_1 that calls XALLOCAVAR to request the > + initial allocation. This uses alloca to get the initial space. > + Since alloca can not be usefully called in an inline function, > + VEC_alloc must always be a macro. > + > + Only the initial allocation will be made using alloca, so pass a > + reasonable estimate that doesn't use too much stack space; don't > + pass zero. Don't return a VEC(TYPE,stack) vector from the function > + which allocated it. */ > + > +#define VEC_alloc(T,A,N) \ > + ((A == stack) \ > + ? VEC_alloc_1 (N, \ > + XALLOCAVAR (vec_t<T>, \ > + VEC_embedded_size_1<T> (N))) \ > + : VEC_alloc_1<T, A> (N MEM_STAT_INFO)) > + > +template<typename T, enum vec_allocation_t A> > +static inline vec_t<T> * > +VEC_alloc_1 (int alloc_ MEM_STAT_DECL) > +{ > + return vec_reserve_exact<T, A> (NULL, alloc_ PASS_MEM_STAT); > +} > + > +template<typename T> > +static inline vec_t<T> * > +VEC_alloc_1 (int alloc_, vec_t<T> *space) > +{ > + return (vec_t<T> *) vec_stack_p_reserve_exact_1 (alloc_, space); > +} > > -#define VEC_alloc(T,A,N) (VEC_OP(T,A,alloc)(N MEM_STAT_INFO)) > > /* Free a vector. > void VEC_T_A_free(VEC(T,A) *&); > > Free a vector and set it to NULL. */ > > -#define VEC_free(T,A,V) (VEC_OP(T,A,free)(&V)) > +#define VEC_free(T,A,V) (VEC_free_1<T, A> (&V)) > > -/* Use these to determine the required size and initialization of a > - vector embedded within another structure (as the final member). > - > - size_t VEC_T_embedded_size(int reserve); > - void VEC_T_embedded_init(VEC(T) *v, int reserve); > - > - These allow the caller to perform the memory allocation. */ > +template<typename T, enum vec_allocation_t A> > +static inline void > +VEC_free_1 (vec_t<T> **vec_) > +{ > + if (*vec_) > + { > + if (A == heap) > + vec_heap_free (*vec_); > + else if (A == gc) > + ggc_free (*vec_); > + else if (A == stack) > + vec_stack_free (*vec_); > + } > + *vec_ = NULL; > +} > > -#define VEC_embedded_size(T,N) (VEC_OP(T,base,embedded_size)(N)) > -#define VEC_embedded_init(T,O,N) (VEC_OP(T,base,embedded_init)(VEC_BASE(O),N)) > > /* Copy a vector. > VEC(T,A) *VEC_T_A_copy(VEC(T) *); > @@ -240,7 +544,24 @@ along with GCC; see the file COPYING3. If not see > Copy the live elements of a vector into a new vector. The new and > old vectors need not be allocated by the same mechanism. */ > > -#define VEC_copy(T,A,V) (VEC_OP(T,A,copy)(VEC_BASE(V) MEM_STAT_INFO)) > +#define VEC_copy(T,A,V) (VEC_copy_1<T, A> (V MEM_STAT_INFO)) > + > +template<typename T, enum vec_allocation_t A> > +static inline vec_t<T> * > +VEC_copy_1 (vec_t<T> *vec_ MEM_STAT_DECL) > +{ > + size_t len_ = vec_ ? vec_->prefix.num : 0; > + vec_t<T> *new_vec_ = NULL; > + > + if (len_) > + { > + new_vec_ = vec_reserve_exact<T, A> (NULL, len_ PASS_MEM_STAT); > + new_vec_->prefix.num = len_; > + memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_); > + } > + return new_vec_; > +} > + > > /* Determine if a vector has additional capacity. > > @@ -252,8 +573,18 @@ along with GCC; see the file COPYING3. If not see > nonzero in exactly the same circumstances that VEC_T_reserve > will. */ > > -#define VEC_space(T,V,R) \ > - (VEC_OP(T,base,space)(VEC_BASE(V),R VEC_CHECK_INFO)) > +#define VEC_space(T,V,R) (VEC_space_1<T> (V, R VEC_CHECK_INFO)) > + > +template<typename T> > +static inline int > +VEC_space_1 (vec_t<T> *vec_, int alloc_ VEC_CHECK_DECL) > +{ > + VEC_ASSERT (alloc_ >= 0, "space", T, base); > + return vec_ > + ? vec_->prefix.alloc - vec_->prefix.num >= (unsigned)alloc_ > + : !alloc_; > +} > + > > /* Reserve space. > int VEC_T_A_reserve(VEC(T,A) *&v, int reserve); > @@ -264,7 +595,20 @@ along with GCC; see the file COPYING3. If not see > occurred. */ > > #define VEC_reserve(T,A,V,R) \ > - (VEC_OP(T,A,reserve)(&(V),R VEC_CHECK_INFO MEM_STAT_INFO)) > + (VEC_reserve_1<T, A> (&(V), (int)(R) VEC_CHECK_INFO MEM_STAT_INFO)) > + > +template<typename T, enum vec_allocation_t A> > +static inline int > +VEC_reserve_1 (vec_t<T> **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) > +{ > + int extend = !VEC_space_1 (*vec_, alloc_ VEC_CHECK_PASS); > + > + if (extend) > + *vec_ = vec_reserve<T, A> (*vec_, alloc_ PASS_MEM_STAT); > + > + return extend; > +} > + > > /* Reserve space exactly. > int VEC_T_A_reserve_exact(VEC(T,A) *&v, int reserve); > @@ -275,7 +619,20 @@ along with GCC; see the file COPYING3. If not see > occurred. */ > > #define VEC_reserve_exact(T,A,V,R) \ > - (VEC_OP(T,A,reserve_exact)(&(V),R VEC_CHECK_INFO MEM_STAT_INFO)) > + (VEC_reserve_exact_1<T, A> (&(V), R VEC_CHECK_INFO MEM_STAT_INFO)) > + > +template<typename T, enum vec_allocation_t A> > +static inline int > +VEC_reserve_exact_1 (vec_t<T> **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) > +{ > + int extend = !VEC_space_1 (*vec_, alloc_ VEC_CHECK_PASS); > + > + if (extend) > + *vec_ = vec_reserve_exact<T, A> (*vec_, alloc_ PASS_MEM_STAT); > + > + return extend; > +} > + > > /* Copy elements with no reallocation > void VEC_T_splice (VEC(T) *dst, VEC(T) *src); // Integer > @@ -287,8 +644,23 @@ along with GCC; see the file COPYING3. If not see > often will be. DST is assumed to have sufficient headroom > available. */ > > -#define VEC_splice(T,DST,SRC) \ > - (VEC_OP(T,base,splice)(VEC_BASE(DST), VEC_BASE(SRC) VEC_CHECK_INFO)) > +#define VEC_splice(T,DST,SRC) (VEC_splice_1<T> (DST, SRC VEC_CHECK_INFO)) > + > +template<typename T> > +static inline void > +VEC_splice_1 (vec_t<T> *dst_, vec_t<T> *src_ VEC_CHECK_DECL) > +{ > + if (src_) > + { > + unsigned len_ = src_->prefix.num; > + VEC_ASSERT (dst_->prefix.num + len_ <= dst_->prefix.alloc, "splice", > + T, base); > + > + memcpy (&dst_->vec[dst_->prefix.num], &src_->vec[0], len_ * sizeof (T)); > + dst_->prefix.num += len_; > + } > +} > + > > /* Copy elements with reallocation > void VEC_T_safe_splice (VEC(T,A) *&dst, VEC(T) *src); // Integer > @@ -301,7 +673,21 @@ along with GCC; see the file COPYING3. If not see > reallocated if needed. */ > > #define VEC_safe_splice(T,A,DST,SRC) \ > - (VEC_OP(T,A,safe_splice)(&(DST), VEC_BASE(SRC) VEC_CHECK_INFO MEM_STAT_INFO)) > + (VEC_safe_splice_1<T, A> (&(DST), SRC VEC_CHECK_INFO MEM_STAT_INFO)) > + > +template<typename T, enum vec_allocation_t A> > +static inline void > +VEC_safe_splice_1 (vec_t<T> **dst_, vec_t<T> *src_ VEC_CHECK_DECL MEM_STAT_DECL) > +{ > + if (src_) > + { > + VEC_reserve_exact_1<T, A> (dst_, src_->prefix.num > + VEC_CHECK_PASS MEM_STAT_INFO); > + > + VEC_splice_1 (*dst_, src_ VEC_CHECK_PASS); > + } > +} > + > > /* Push object with no reallocation > T *VEC_T_quick_push (VEC(T) *v, T obj); // Integer > @@ -313,8 +699,31 @@ along with GCC; see the file COPYING3. If not see > case NO initialization is performed. There must > be sufficient space in the vector. */ > > -#define VEC_quick_push(T,V,O) \ > - (VEC_OP(T,base,quick_push)(VEC_BASE(V),O VEC_CHECK_INFO)) > +#define VEC_quick_push(T,V,O) (VEC_quick_push_1<T> (V, O VEC_CHECK_INFO)) > + > +template<typename T> > +static inline T & > +VEC_quick_push_1 (vec_t<T> *vec_, T obj_ VEC_CHECK_DECL) > +{ > + VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "push", T, base); > + vec_->vec[vec_->prefix.num] = obj_; > + T &val_ = vec_->vec[vec_->prefix.num]; > + vec_->prefix.num++; > + return val_; > +} > + > +template<typename T> > +static inline T * > +VEC_quick_push_1 (vec_t<T> *vec_, const T *ptr_ VEC_CHECK_DECL) > +{ > + T *slot_; > + VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "push", T, base); > + slot_ = &vec_->vec[vec_->prefix.num++]; > + if (ptr_) > + *slot_ = *ptr_; > + return slot_; > +} > + > > /* Push object with reallocation > T *VEC_T_A_safe_push (VEC(T,A) *&v, T obj); // Integer > @@ -326,7 +735,24 @@ along with GCC; see the file COPYING3. If not see > case NO initialization is performed. Reallocates V, if needed. */ > > #define VEC_safe_push(T,A,V,O) \ > - (VEC_OP(T,A,safe_push)(&(V),O VEC_CHECK_INFO MEM_STAT_INFO)) > + (VEC_safe_push_1<T, A> (&(V), O VEC_CHECK_INFO MEM_STAT_INFO)) > + > +template<typename T, enum vec_allocation_t A> > +static inline T & > +VEC_safe_push_1 (vec_t<T> **vec_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) > +{ > + VEC_reserve_1<T, A> (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); > + return VEC_quick_push_1 (*vec_, obj_ VEC_CHECK_PASS); > +} > + > +template<typename T, enum vec_allocation_t A> > +static inline T * > +VEC_safe_push_1 (vec_t<T> **vec_, const T *ptr_ VEC_CHECK_DECL MEM_STAT_DECL) > +{ > + VEC_reserve_1<T, A> (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); > + return VEC_quick_push_1 (*vec_, ptr_ VEC_CHECK_PASS); > +} > + > > /* Pop element off end > T VEC_T_pop (VEC(T) *v); // Integer > @@ -336,7 +762,16 @@ along with GCC; see the file COPYING3. If not see > Pop the last element off the end. Returns the element popped, for > pointer vectors. */ > > -#define VEC_pop(T,V) (VEC_OP(T,base,pop)(VEC_BASE(V) VEC_CHECK_INFO)) > +#define VEC_pop(T,V) (VEC_pop_1<T> (V VEC_CHECK_INFO)) > + > +template<typename T> > +static inline T& > +VEC_pop_1 (vec_t<T> *vec_ VEC_CHECK_DECL) > +{ > + VEC_ASSERT (vec_->prefix.num, "pop", T, base); > + return vec_->vec[--vec_->prefix.num]; > +} > + > > /* Truncate to specific length > void VEC_T_truncate (VEC(T) *v, unsigned len); > @@ -344,8 +779,18 @@ along with GCC; see the file COPYING3. If not see > Set the length as specified. The new length must be less than or > equal to the current length. This is an O(1) operation. */ > > -#define VEC_truncate(T,V,I) \ > - (VEC_OP(T,base,truncate)(VEC_BASE(V),I VEC_CHECK_INFO)) > +#define VEC_truncate(T,V,I) \ > + (VEC_truncate_1<T> (V, (unsigned)(I) VEC_CHECK_INFO)) > + > +template<typename T> > +static inline void > +VEC_truncate_1 (vec_t<T> *vec_, unsigned size_ VEC_CHECK_DECL) > +{ > + VEC_ASSERT (vec_ ? vec_->prefix.num >= size_ : !size_, "truncate", T, base); > + if (vec_) > + vec_->prefix.num = size_; > +} > + > > /* Grow to a specific length. > void VEC_T_A_safe_grow (VEC(T,A) *&v, int len); > @@ -355,7 +800,20 @@ along with GCC; see the file COPYING3. If not see > uninitialized. */ > > #define VEC_safe_grow(T,A,V,I) \ > - (VEC_OP(T,A,safe_grow)(&(V),I VEC_CHECK_INFO MEM_STAT_INFO)) > + (VEC_safe_grow_1<T, A> (&(V), (int)(I) VEC_CHECK_INFO MEM_STAT_INFO)) > + > +template<typename T, enum vec_allocation_t A> > +static inline void > +VEC_safe_grow_1 (vec_t<T> **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) > +{ > + VEC_ASSERT (size_ >= 0 && VEC_length (T, *vec_) <= (unsigned)size_, > + "grow", T, A); > + VEC_reserve_exact_1<T, A> (vec_, > + size_ - (int)(*vec_ ? (*vec_)->prefix.num : 0) > + VEC_CHECK_PASS PASS_MEM_STAT); > + (*vec_)->prefix.num = size_; > +} > + > > /* Grow to a specific length. > void VEC_T_A_safe_grow_cleared (VEC(T,A) *&v, int len); > @@ -364,8 +822,21 @@ along with GCC; see the file COPYING3. If not see > long or longer than the current length. The new elements are > initialized to zero. */ > > -#define VEC_safe_grow_cleared(T,A,V,I) \ > - (VEC_OP(T,A,safe_grow_cleared)(&(V),I VEC_CHECK_INFO MEM_STAT_INFO)) > +#define VEC_safe_grow_cleared(T,A,V,I) \ > + (VEC_safe_grow_cleared_1<T,A> (&(V), (int)(I) \ > + VEC_CHECK_INFO MEM_STAT_INFO)) > + > +template<typename T, enum vec_allocation_t A> > +static inline void > +VEC_safe_grow_cleared_1 (vec_t<T> **vec_, int size_ VEC_CHECK_DECL > + MEM_STAT_DECL) > +{ > + int oldsize = VEC_length (T, *vec_); > + VEC_safe_grow_1<T, A> (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); > + memset (&(VEC_address (T, *vec_)[oldsize]), 0, > + sizeof (T) * (size_ - oldsize)); > +} > + > > /* Replace element > T VEC_T_replace (VEC(T) *v, unsigned ix, T val); // Integer > @@ -379,20 +850,57 @@ along with GCC; see the file COPYING3. If not see > performed. */ > > #define VEC_replace(T,V,I,O) \ > - (VEC_OP(T,base,replace)(VEC_BASE(V),I,O VEC_CHECK_INFO)) > + (VEC_replace_1<T> (V, (unsigned)(I), O VEC_CHECK_INFO)) > + > +template<typename T> > +static inline T& > +VEC_replace_1 (vec_t<T> *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) > +{ > + VEC_ASSERT (ix_ < vec_->prefix.num, "replace", T, base); > + vec_->vec[ix_] = obj_; > + return vec_->vec[ix_]; > +} > + > > /* Insert object with no reallocation > - T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Integer > - T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Pointer > - T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T *val); // Object > + void VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Integer > + void VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Pointer > + void VEC_T_quick_insert (VEC(T) *v, unsigned ix, T *val); // Object > > - Insert an element, VAL, at the IXth position of V. Return a pointer > - to the slot created. For vectors of object, the new value can be > - NULL, in which case no initialization of the inserted slot takes > - place. There must be sufficient space. */ > + Insert an element, VAL, at the IXth position of V. For vectors of > + object, the new value can be NULL, in which case no initialization > + of the inserted slot takes place. There must be sufficient space. */ > > #define VEC_quick_insert(T,V,I,O) \ > - (VEC_OP(T,base,quick_insert)(VEC_BASE(V),I,O VEC_CHECK_INFO)) > + (VEC_quick_insert_1<T> (V,I,O VEC_CHECK_INFO)) > + > +template<typename T> > +static inline void > +VEC_quick_insert_1 (vec_t<T> *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) > +{ > + T *slot_; > + > + VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "insert", T, base); > + VEC_ASSERT (ix_ <= vec_->prefix.num, "insert", T, base); > + slot_ = &vec_->vec[ix_]; > + memmove (slot_ + 1, slot_, (vec_->prefix.num++ - ix_) * sizeof (T)); > + *slot_ = obj_; > +} > + > +template<typename T> > +static inline void > +VEC_quick_insert_1 (vec_t<T> *vec_, unsigned ix_, const T *ptr_ VEC_CHECK_DECL) > +{ > + T *slot_; > + > + VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "insert", T, base); > + VEC_ASSERT (ix_ <= vec_->prefix.num, "insert", T, base); > + slot_ = &vec_->vec[ix_]; > + memmove (slot_ + 1, slot_, (vec_->prefix.num++ - ix_) * sizeof (T)); > + if (ptr_) > + *slot_ = *ptr_; > +} > + > > /* Insert object with reallocation > T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T val); // Integer > @@ -405,31 +913,70 @@ along with GCC; see the file COPYING3. If not see > place. Reallocate V, if necessary. */ > > #define VEC_safe_insert(T,A,V,I,O) \ > - (VEC_OP(T,A,safe_insert)(&(V),I,O VEC_CHECK_INFO MEM_STAT_INFO)) > + (VEC_safe_insert_1<T, A> (&(V),I,O VEC_CHECK_INFO MEM_STAT_INFO)) > + > +template<typename T, enum vec_allocation_t A> > +static inline void > +VEC_safe_insert_1 (vec_t<T> **vec_, unsigned ix_, T obj_ > + VEC_CHECK_DECL MEM_STAT_DECL) > +{ > + VEC_reserve_1<T, A> (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); > + VEC_quick_insert_1 (*vec_, ix_, obj_ VEC_CHECK_PASS); > +} > + > +template<typename T, enum vec_allocation_t A> > +static inline void > +VEC_safe_insert_1 (vec_t<T> **vec_, unsigned ix_, T *ptr_ > + VEC_CHECK_DECL MEM_STAT_DECL) > +{ > + VEC_reserve_1<T, A> (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); > + VEC_quick_insert_1 (*vec_, ix_, ptr_ VEC_CHECK_PASS); > +} > + > + > > /* Remove element retaining order > - T VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Integer > - T VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Pointer > + void VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Integer > + void VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Pointer > void VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Object > > Remove an element from the IXth position of V. Ordering of > - remaining elements is preserved. For pointer vectors returns the > - removed object. This is an O(N) operation due to a memmove. */ > + remaining elements is preserved. This is an O(N) operation due to > + a memmove. */ > > #define VEC_ordered_remove(T,V,I) \ > - (VEC_OP(T,base,ordered_remove)(VEC_BASE(V),I VEC_CHECK_INFO)) > + (VEC_ordered_remove_1<T> (V,I VEC_CHECK_INFO)) > + > +template<typename T> > +static inline void > +VEC_ordered_remove_1 (vec_t<T> *vec_, unsigned ix_ VEC_CHECK_DECL) > +{ > + T *slot_; > + VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); > + slot_ = &vec_->vec[ix_]; > + memmove (slot_, slot_ + 1, (--vec_->prefix.num - ix_) * sizeof (T)); > +} > + > > /* Remove element destroying order > - T VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Integer > - T VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Pointer > + void VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Integer > + void VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Pointer > void VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Object > > - Remove an element from the IXth position of V. Ordering of > - remaining elements is destroyed. For pointer vectors returns the > - removed object. This is an O(1) operation. */ > + Remove an element from the IXth position of V. Ordering of > + remaining elements is destroyed. This is an O(1) operation. */ > > #define VEC_unordered_remove(T,V,I) \ > - (VEC_OP(T,base,unordered_remove)(VEC_BASE(V),I VEC_CHECK_INFO)) > + (VEC_unordered_remove_1<T> (V,I VEC_CHECK_INFO)) > + > +template<typename T> > +static inline void > +VEC_unordered_remove_1 (vec_t<T> *vec_, unsigned ix_ VEC_CHECK_DECL) > +{ > + VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); > + vec_->vec[ix_] = vec_->vec[--vec_->prefix.num]; > +} > + > > /* Remove a block of elements > void VEC_T_block_remove (VEC(T) *v, unsigned ix, unsigned len); > @@ -438,22 +985,27 @@ along with GCC; see the file COPYING3. If not see > This is an O(N) operation due to memmove. */ > > #define VEC_block_remove(T,V,I,L) \ > - (VEC_OP(T,base,block_remove)(VEC_BASE(V),I,L VEC_CHECK_INFO)) > + (VEC_block_remove_1<T> (V, I, L VEC_CHECK_INFO)) > > -/* Get the address of the array of elements > - T *VEC_T_address (VEC(T) v) > - > - If you need to directly manipulate the array (for instance, you > - want to feed it to qsort), use this accessor. */ > +template<typename T> > +static inline void > +VEC_block_remove_1 (vec_t<T> *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) > +{ > + T *slot_; > + VEC_ASSERT (ix_ + len_ <= vec_->prefix.num, "block_remove", T, base); > + slot_ = &vec_->vec[ix_]; > + vec_->prefix.num -= len_; > + memmove (slot_, slot_ + len_, (vec_->prefix.num - ix_) * sizeof (T)); > +} > > -#define VEC_address(T,V) (VEC_OP(T,base,address)(VEC_BASE(V))) > > /* Conveniently sort the contents of the vector with qsort. > void VEC_qsort (VEC(T) *v, int (*cmp_func)(const void *, const void *)) */ > > -#define VEC_qsort(T,V,CMP) qsort(VEC_address (T,V), VEC_length(T,V), \ > +#define VEC_qsort(T,V,CMP) qsort(VEC_address (T, V), VEC_length (T, V), \ > sizeof (T), CMP) > > + > /* Find the first index in the vector not less than the object. > unsigned VEC_T_lower_bound (VEC(T) *v, const T val, > bool (*lessthan) (const T, const T)); // Integer > @@ -466,955 +1018,140 @@ along with GCC; see the file COPYING3. If not see > changing the ordering of V. LESSTHAN is a function that returns > true if the first argument is strictly less than the second. */ > > -#define VEC_lower_bound(T,V,O,LT) \ > - (VEC_OP(T,base,lower_bound)(VEC_BASE(V),O,LT VEC_CHECK_INFO)) > +#define VEC_lower_bound(T,V,O,LT) \ > + (VEC_lower_bound_1<T> (V, O, LT VEC_CHECK_INFO)) > > -/* Reallocate an array of elements with prefix. */ > -extern void *vec_gc_p_reserve (void *, int MEM_STAT_DECL); > -extern void *vec_gc_p_reserve_exact (void *, int MEM_STAT_DECL); > -extern void *vec_gc_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); > -extern void *vec_gc_o_reserve_exact (void *, int, size_t, size_t > - MEM_STAT_DECL); > -extern void ggc_free (void *); > -#define vec_gc_free(V) ggc_free (V) > -extern void *vec_heap_p_reserve (void *, int MEM_STAT_DECL); > -extern void *vec_heap_p_reserve_exact (void *, int MEM_STAT_DECL); > -extern void *vec_heap_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); > -extern void *vec_heap_o_reserve_exact (void *, int, size_t, size_t > - MEM_STAT_DECL); > -extern void dump_vec_loc_statistics (void); > -extern void vec_heap_free (void *); > - > -#if ENABLE_CHECKING > -#define VEC_CHECK_INFO ,__FILE__,__LINE__,__FUNCTION__ > -#define VEC_CHECK_DECL ,const char *file_,unsigned line_,const char *function_ > -#define VEC_CHECK_PASS ,file_,line_,function_ > - > -#define VEC_ASSERT(EXPR,OP,T,A) \ > - (void)((EXPR) ? 0 : (VEC_ASSERT_FAIL(OP,VEC(T,A)), 0)) > - > -extern void vec_assert_fail (const char *, const char * VEC_CHECK_DECL) > - ATTRIBUTE_NORETURN; > -#define VEC_ASSERT_FAIL(OP,VEC) vec_assert_fail (OP,#VEC VEC_CHECK_PASS) > -#else > -#define VEC_CHECK_INFO > -#define VEC_CHECK_DECL > -#define VEC_CHECK_PASS > -#define VEC_ASSERT(EXPR,OP,T,A) (void)(EXPR) > -#endif > - > -/* Note: gengtype has hardwired knowledge of the expansions of the > - VEC, DEF_VEC_*, and DEF_VEC_ALLOC_* macros. If you change the > - expansions of these macros you may need to change gengtype too. */ > - > -typedef struct GTY(()) vec_prefix > +template<typename T> > +static inline unsigned > +VEC_lower_bound_1 (vec_t<T> *vec_, T obj_, > + bool (*lessthan_)(T, T) VEC_CHECK_DECL) > { > - unsigned num; > - unsigned alloc; > -} vec_prefix; > - > -#define VEC(T,A) VEC_##T##_##A > -#define VEC_OP(T,A,OP) VEC_##T##_##A##_##OP > - > -/* Base of vector type, not user visible. */ > -#define VEC_T(T,B) \ > -typedef struct VEC(T,B) \ > -{ \ > - struct vec_prefix prefix; \ > - T vec[1]; \ > -} VEC(T,B) > - > -#define VEC_T_GTY(T,B) \ > -typedef struct GTY(()) VEC(T,B) \ > -{ \ > - struct vec_prefix prefix; \ > - T GTY ((length ("%h.prefix.num"))) vec[1]; \ > -} VEC(T,B) > - > -#define VEC_T_GTY_ATOMIC(T,B) \ > -typedef struct GTY(()) VEC(T,B) \ > -{ \ > - struct vec_prefix prefix; \ > - T GTY ((atomic)) vec[1]; \ > -} VEC(T,B) > - > -/* Derived vector type, user visible. */ > -#define VEC_TA_GTY(T,B,A,GTY) \ > -typedef struct GTY VEC(T,A) \ > -{ \ > - VEC(T,B) base; \ > -} VEC(T,A) > - > -#define VEC_TA(T,B,A) \ > -typedef struct VEC(T,A) \ > -{ \ > - VEC(T,B) base; \ > -} VEC(T,A) > - > -/* Convert to base type. */ > -#if GCC_VERSION >= 4000 > -#define VEC_BASE(P) \ > - ((offsetof (__typeof (*P), base) == 0 || (P)) ? &(P)->base : 0) > -#else > -#define VEC_BASE(P) ((P) ? &(P)->base : 0) > -#endif > - > -/* Vector of integer-like object. */ > -#define DEF_VEC_I(T) \ > -static inline void VEC_OP (T,must_be,integral_type) (void) \ > -{ \ > - (void)~(T)0; \ > -} \ > - \ > -VEC_T(T,base); \ > -VEC_TA(T,base,none); \ > -DEF_VEC_FUNC_P(T) \ > -struct vec_swallow_trailing_semi > -#define DEF_VEC_ALLOC_I(T,A) \ > -VEC_TA(T,base,A); \ > -DEF_VEC_ALLOC_FUNC_I(T,A) \ > -DEF_VEC_NONALLOC_FUNCS_I(T,A) \ > -struct vec_swallow_trailing_semi > - > -/* Vector of pointer to object. */ > -#define DEF_VEC_P(T) \ > -static inline void VEC_OP (T,must_be,pointer_type) (void) \ > -{ \ > - (void)((T)1 == (void *)1); \ > -} \ > - \ > -VEC_T_GTY(T,base); \ > -VEC_TA(T,base,none); \ > -DEF_VEC_FUNC_P(T) \ > -struct vec_swallow_trailing_semi > -#define DEF_VEC_ALLOC_P(T,A) \ > -VEC_TA(T,base,A); \ > -DEF_VEC_ALLOC_FUNC_P(T,A) \ > -DEF_VEC_NONALLOC_FUNCS_P(T,A) \ > -struct vec_swallow_trailing_semi > - > -#define DEF_VEC_FUNC_P(T) \ > -static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \ > -{ \ > - return vec_ ? vec_->prefix.num : 0; \ > -} \ > - \ > -static inline T VEC_OP (T,base,last) \ > - (const VEC(T,base) *vec_ VEC_CHECK_DECL) \ > -{ \ > - VEC_ASSERT (vec_ && vec_->prefix.num, "last", T, base); \ > - \ > - return vec_->vec[vec_->prefix.num - 1]; \ > -} \ > - \ > -static inline T VEC_OP (T,base,index) \ > - (const VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ > -{ \ > - VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); \ > - \ > - return vec_->vec[ix_]; \ > -} \ > - \ > -static inline int VEC_OP (T,base,iterate) \ > - (const VEC(T,base) *vec_, unsigned ix_, T *ptr) \ > -{ \ > - if (vec_ && ix_ < vec_->prefix.num) \ > - { \ > - *ptr = vec_->vec[ix_]; \ > - return 1; \ > - } \ > - else \ > - { \ > - *ptr = (T) 0; \ > - return 0; \ > - } \ > -} \ > - \ > -static inline size_t VEC_OP (T,base,embedded_size) \ > - (int alloc_) \ > -{ \ > - return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T); \ > -} \ > - \ > -static inline void VEC_OP (T,base,embedded_init) \ > - (VEC(T,base) *vec_, int alloc_) \ > -{ \ > - vec_->prefix.num = 0; \ > - vec_->prefix.alloc = alloc_; \ > -} \ > - \ > -static inline int VEC_OP (T,base,space) \ > - (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \ > -{ \ > - VEC_ASSERT (alloc_ >= 0, "space", T, base); \ > - return vec_ ? vec_->prefix.alloc - vec_->prefix.num >= (unsigned)alloc_ : !alloc_; \ > -} \ > - \ > -static inline void VEC_OP(T,base,splice) \ > - (VEC(T,base) *dst_, VEC(T,base) *src_ VEC_CHECK_DECL) \ > -{ \ > - if (src_) \ > - { \ > - unsigned len_ = src_->prefix.num; \ > - VEC_ASSERT (dst_->prefix.num + len_ <= dst_->prefix.alloc, "splice", T, base); \ > - \ > - memcpy (&dst_->vec[dst_->prefix.num], &src_->vec[0], len_ * sizeof (T)); \ > - dst_->prefix.num += len_; \ > - } \ > -} \ > - \ > -static inline T *VEC_OP (T,base,quick_push) \ > - (VEC(T,base) *vec_, T obj_ VEC_CHECK_DECL) \ > -{ \ > - T *slot_; \ > - \ > - VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "push", T, base); \ > - slot_ = &vec_->vec[vec_->prefix.num++]; \ > - *slot_ = obj_; \ > - \ > - return slot_; \ > -} \ > - \ > -static inline T VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \ > -{ \ > - T obj_; \ > - \ > - VEC_ASSERT (vec_->prefix.num, "pop", T, base); \ > - obj_ = vec_->vec[--vec_->prefix.num]; \ > - \ > - return obj_; \ > -} \ > - \ > -static inline void VEC_OP (T,base,truncate) \ > - (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \ > -{ \ > - VEC_ASSERT (vec_ ? vec_->prefix.num >= size_ : !size_, "truncate", T, base); \ > - if (vec_) \ > - vec_->prefix.num = size_; \ > -} \ > - \ > -static inline T VEC_OP (T,base,replace) \ > - (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) \ > -{ \ > - T old_obj_; \ > - \ > - VEC_ASSERT (ix_ < vec_->prefix.num, "replace", T, base); \ > - old_obj_ = vec_->vec[ix_]; \ > - vec_->vec[ix_] = obj_; \ > - \ > - return old_obj_; \ > -} \ > - \ > -static inline T *VEC_OP (T,base,quick_insert) \ > - (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) \ > -{ \ > - T *slot_; \ > - \ > - VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "insert", T, base); \ > - VEC_ASSERT (ix_ <= vec_->prefix.num, "insert", T, base); \ > - slot_ = &vec_->vec[ix_]; \ > - memmove (slot_ + 1, slot_, (vec_->prefix.num++ - ix_) * sizeof (T)); \ > - *slot_ = obj_; \ > - \ > - return slot_; \ > -} \ > - \ > -static inline T VEC_OP (T,base,ordered_remove) \ > - (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ > -{ \ > - T *slot_; \ > - T obj_; \ > - \ > - VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \ > - slot_ = &vec_->vec[ix_]; \ > - obj_ = *slot_; \ > - memmove (slot_, slot_ + 1, (--vec_->prefix.num - ix_) * sizeof (T)); \ > - \ > - return obj_; \ > -} \ > - \ > -static inline T VEC_OP (T,base,unordered_remove) \ > - (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ > -{ \ > - T *slot_; \ > - T obj_; \ > - \ > - VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \ > - slot_ = &vec_->vec[ix_]; \ > - obj_ = *slot_; \ > - *slot_ = vec_->vec[--vec_->prefix.num]; \ > - \ > - return obj_; \ > -} \ > - \ > -static inline void VEC_OP (T,base,block_remove) \ > - (VEC(T,base) *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) \ > -{ \ > - T *slot_; \ > - \ > - VEC_ASSERT (ix_ + len_ <= vec_->prefix.num, "block_remove", T, base); \ > - slot_ = &vec_->vec[ix_]; \ > - vec_->prefix.num -= len_; \ > - memmove (slot_, slot_ + len_, (vec_->prefix.num - ix_) * sizeof (T)); \ > -} \ > - \ > -static inline T *VEC_OP (T,base,address) \ > - (VEC(T,base) *vec_) \ > -{ \ > - return vec_ ? vec_->vec : 0; \ > -} \ > - \ > -static inline unsigned VEC_OP (T,base,lower_bound) \ > - (VEC(T,base) *vec_, const T obj_, \ > - bool (*lessthan_)(const T, const T) VEC_CHECK_DECL) \ > -{ \ > - unsigned int len_ = VEC_OP (T,base, length) (vec_); \ > - unsigned int half_, middle_; \ > - unsigned int first_ = 0; \ > - while (len_ > 0) \ > - { \ > - T middle_elem_; \ > - half_ = len_ >> 1; \ > - middle_ = first_; \ > - middle_ += half_; \ > - middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \ > - if (lessthan_ (middle_elem_, obj_)) \ > - { \ > - first_ = middle_; \ > - ++first_; \ > - len_ = len_ - half_ - 1; \ > - } \ > - else \ > - len_ = half_; \ > - } \ > - return first_; \ > + unsigned int len_ = VEC_length (T, vec_); > + unsigned int half_, middle_; > + unsigned int first_ = 0; > + while (len_ > 0) > + { > + T middle_elem_; > + half_ = len_ >> 1; > + middle_ = first_; > + middle_ += half_; > + middle_elem_ = VEC_index_1 (vec_, middle_ VEC_CHECK_PASS); > + if (lessthan_ (middle_elem_, obj_)) > + { > + first_ = middle_; > + ++first_; > + len_ = len_ - half_ - 1; > + } > + else > + len_ = half_; > + } > + return first_; > } > > -#define DEF_VEC_ALLOC_FUNC_P(T,A) \ > -static inline VEC(T,A) *VEC_OP (T,A,alloc) \ > - (int alloc_ MEM_STAT_DECL) \ > -{ \ > - return (VEC(T,A) *) vec_##A##_p_reserve_exact (NULL, alloc_ \ > - PASS_MEM_STAT); \ > -} > - > - > -#define DEF_VEC_NONALLOC_FUNCS_P(T,A) \ > -static inline void VEC_OP (T,A,free) \ > - (VEC(T,A) **vec_) \ > -{ \ > - if (*vec_) \ > - vec_##A##_free (*vec_); \ > - *vec_ = NULL; \ > -} \ > - \ > -static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \ > -{ \ > - size_t len_ = vec_ ? vec_->prefix.num : 0; \ > - VEC (T,A) *new_vec_ = NULL; \ > - \ > - if (len_) \ > - { \ > - new_vec_ = (VEC (T,A) *)(vec_##A##_p_reserve_exact \ > - (NULL, len_ PASS_MEM_STAT)); \ > - \ > - new_vec_->base.prefix.num = len_; \ > - memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \ > - } \ > - return new_vec_; \ > -} \ > - \ > -static inline int VEC_OP (T,A,reserve) \ > - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ > - VEC_CHECK_PASS); \ > - \ > - if (extend) \ > - *vec_ = (VEC(T,A) *) vec_##A##_p_reserve (*vec_, alloc_ PASS_MEM_STAT); \ > - \ > - return extend; \ > -} \ > - \ > -static inline int VEC_OP (T,A,reserve_exact) \ > - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ > - VEC_CHECK_PASS); \ > - \ > - if (extend) \ > - *vec_ = (VEC(T,A) *) vec_##A##_p_reserve_exact (*vec_, alloc_ \ > - PASS_MEM_STAT); \ > - \ > - return extend; \ > -} \ > - \ > -static inline void VEC_OP (T,A,safe_grow) \ > - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - VEC_ASSERT (size_ >= 0 \ > - && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \ > - "grow", T, A); \ > - VEC_OP (T,A,reserve_exact) (vec_, \ > - size_ - (int)(*vec_ ? VEC_BASE(*vec_)->prefix.num : 0) \ > - VEC_CHECK_PASS PASS_MEM_STAT); \ > - VEC_BASE (*vec_)->prefix.num = size_; \ > -} \ > - \ > -static inline void VEC_OP (T,A,safe_grow_cleared) \ > - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \ > - VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \ > - memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \ > - sizeof (T) * (size_ - oldsize)); \ > -} \ > - \ > -static inline void VEC_OP(T,A,safe_splice) \ > - (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - if (src_) \ > - { \ > - VEC_OP (T,A,reserve_exact) (dst_, src_->prefix.num \ > - VEC_CHECK_PASS MEM_STAT_INFO); \ > - \ > - VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \ > - VEC_CHECK_PASS); \ > - } \ > -} \ > - \ > -static inline T *VEC_OP (T,A,safe_push) \ > - (VEC(T,A) **vec_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ > - \ > - return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \ > -} \ > - \ > -static inline T *VEC_OP (T,A,safe_insert) \ > - (VEC(T,A) **vec_, unsigned ix_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ > - \ > - return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ > - VEC_CHECK_PASS); \ > -} > - > -/* Vector of object. */ > -#define DEF_VEC_O(T) \ > -VEC_T_GTY(T,base); \ > -VEC_TA(T,base,none); \ > -DEF_VEC_FUNC_O(T) \ > -struct vec_swallow_trailing_semi > -#define DEF_VEC_ALLOC_O(T,A) \ > -VEC_TA(T,base,A); \ > -DEF_VEC_ALLOC_FUNC_O(T,A) \ > -DEF_VEC_NONALLOC_FUNCS_O(T,A) \ > -struct vec_swallow_trailing_semi > - > -/* Vector of atomic object. */ > -#define DEF_VEC_A(T) \ > -VEC_T_GTY_ATOMIC(T,base); \ > -VEC_TA(T,base,none); \ > -DEF_VEC_FUNC_O(T) \ > -struct vec_swallow_trailing_semi > -#define DEF_VEC_ALLOC_A(T,A) DEF_VEC_ALLOC_O(T,A) > - > -#define DEF_VEC_FUNC_O(T) \ > -static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \ > -{ \ > - return vec_ ? vec_->prefix.num : 0; \ > -} \ > - \ > -static inline T *VEC_OP (T,base,last) (VEC(T,base) *vec_ VEC_CHECK_DECL) \ > -{ \ > - VEC_ASSERT (vec_ && vec_->prefix.num, "last", T, base); \ > - \ > - return &vec_->vec[vec_->prefix.num - 1]; \ > -} \ > - \ > -static inline T *VEC_OP (T,base,index) \ > - (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ > -{ \ > - VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); \ > - \ > - return &vec_->vec[ix_]; \ > -} \ > - \ > -static inline int VEC_OP (T,base,iterate) \ > - (VEC(T,base) *vec_, unsigned ix_, T **ptr) \ > -{ \ > - if (vec_ && ix_ < vec_->prefix.num) \ > - { \ > - *ptr = &vec_->vec[ix_]; \ > - return 1; \ > - } \ > - else \ > - { \ > - *ptr = 0; \ > - return 0; \ > - } \ > -} \ > - \ > -static inline size_t VEC_OP (T,base,embedded_size) \ > - (int alloc_) \ > -{ \ > - return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T); \ > -} \ > - \ > -static inline void VEC_OP (T,base,embedded_init) \ > - (VEC(T,base) *vec_, int alloc_) \ > -{ \ > - vec_->prefix.num = 0; \ > - vec_->prefix.alloc = alloc_; \ > -} \ > - \ > -static inline int VEC_OP (T,base,space) \ > - (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \ > -{ \ > - VEC_ASSERT (alloc_ >= 0, "space", T, base); \ > - return vec_ ? vec_->prefix.alloc - vec_->prefix.num >= (unsigned)alloc_ : !alloc_; \ > -} \ > - \ > -static inline void VEC_OP(T,base,splice) \ > - (VEC(T,base) *dst_, VEC(T,base) *src_ VEC_CHECK_DECL) \ > -{ \ > - if (src_) \ > - { \ > - unsigned len_ = src_->prefix.num; \ > - VEC_ASSERT (dst_->prefix.num + len_ <= dst_->prefix.alloc, "splice", T, base); \ > - \ > - memcpy (&dst_->vec[dst_->prefix.num], &src_->vec[0], len_ * sizeof (T)); \ > - dst_->prefix.num += len_; \ > - } \ > -} \ > - \ > -static inline T *VEC_OP (T,base,quick_push) \ > - (VEC(T,base) *vec_, const T *obj_ VEC_CHECK_DECL) \ > -{ \ > - T *slot_; \ > - \ > - VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "push", T, base); \ > - slot_ = &vec_->vec[vec_->prefix.num++]; \ > - if (obj_) \ > - *slot_ = *obj_; \ > - \ > - return slot_; \ > -} \ > - \ > -static inline void VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \ > -{ \ > - VEC_ASSERT (vec_->prefix.num, "pop", T, base); \ > - --vec_->prefix.num; \ > -} \ > - \ > -static inline void VEC_OP (T,base,truncate) \ > - (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \ > -{ \ > - VEC_ASSERT (vec_ ? vec_->prefix.num >= size_ : !size_, "truncate", T, base); \ > - if (vec_) \ > - vec_->prefix.num = size_; \ > -} \ > - \ > -static inline T *VEC_OP (T,base,replace) \ > - (VEC(T,base) *vec_, unsigned ix_, const T *obj_ VEC_CHECK_DECL) \ > -{ \ > - T *slot_; \ > - \ > - VEC_ASSERT (ix_ < vec_->prefix.num, "replace", T, base); \ > - slot_ = &vec_->vec[ix_]; \ > - if (obj_) \ > - *slot_ = *obj_; \ > - \ > - return slot_; \ > -} \ > - \ > -static inline T *VEC_OP (T,base,quick_insert) \ > - (VEC(T,base) *vec_, unsigned ix_, const T *obj_ VEC_CHECK_DECL) \ > -{ \ > - T *slot_; \ > - \ > - VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "insert", T, base); \ > - VEC_ASSERT (ix_ <= vec_->prefix.num, "insert", T, base); \ > - slot_ = &vec_->vec[ix_]; \ > - memmove (slot_ + 1, slot_, (vec_->prefix.num++ - ix_) * sizeof (T)); \ > - if (obj_) \ > - *slot_ = *obj_; \ > - \ > - return slot_; \ > -} \ > - \ > -static inline void VEC_OP (T,base,ordered_remove) \ > - (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ > -{ \ > - T *slot_; \ > - \ > - VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \ > - slot_ = &vec_->vec[ix_]; \ > - memmove (slot_, slot_ + 1, (--vec_->prefix.num - ix_) * sizeof (T)); \ > -} \ > - \ > -static inline void VEC_OP (T,base,unordered_remove) \ > - (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ > -{ \ > - VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \ > - vec_->vec[ix_] = vec_->vec[--vec_->prefix.num]; \ > -} \ > - \ > -static inline void VEC_OP (T,base,block_remove) \ > - (VEC(T,base) *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) \ > -{ \ > - T *slot_; \ > - \ > - VEC_ASSERT (ix_ + len_ <= vec_->prefix.num, "block_remove", T, base); \ > - slot_ = &vec_->vec[ix_]; \ > - vec_->prefix.num -= len_; \ > - memmove (slot_, slot_ + len_, (vec_->prefix.num - ix_) * sizeof (T)); \ > -} \ > - \ > -static inline T *VEC_OP (T,base,address) \ > - (VEC(T,base) *vec_) \ > -{ \ > - return vec_ ? vec_->vec : 0; \ > -} \ > - \ > -static inline unsigned VEC_OP (T,base,lower_bound) \ > - (VEC(T,base) *vec_, const T *obj_, \ > - bool (*lessthan_)(const T *, const T *) VEC_CHECK_DECL) \ > -{ \ > - unsigned int len_ = VEC_OP (T, base, length) (vec_); \ > - unsigned int half_, middle_; \ > - unsigned int first_ = 0; \ > - while (len_ > 0) \ > - { \ > - T *middle_elem_; \ > - half_ = len_ >> 1; \ > - middle_ = first_; \ > - middle_ += half_; \ > - middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \ > - if (lessthan_ (middle_elem_, obj_)) \ > - { \ > - first_ = middle_; \ > - ++first_; \ > - len_ = len_ - half_ - 1; \ > - } \ > - else \ > - len_ = half_; \ > - } \ > - return first_; \ > -} > - > -#define DEF_VEC_ALLOC_FUNC_O(T,A) \ > -static inline VEC(T,A) *VEC_OP (T,A,alloc) \ > - (int alloc_ MEM_STAT_DECL) \ > -{ \ > - return (VEC(T,A) *) vec_##A##_o_reserve_exact (NULL, alloc_, \ > - offsetof (VEC(T,A),base.vec), \ > - sizeof (T) \ > - PASS_MEM_STAT); \ > -} > - > -#define DEF_VEC_NONALLOC_FUNCS_O(T,A) \ > -static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \ > -{ \ > - size_t len_ = vec_ ? vec_->prefix.num : 0; \ > - VEC (T,A) *new_vec_ = NULL; \ > - \ > - if (len_) \ > - { \ > - new_vec_ = (VEC (T,A) *)(vec_##A##_o_reserve_exact \ > - (NULL, len_, \ > - offsetof (VEC(T,A),base.vec), sizeof (T) \ > - PASS_MEM_STAT)); \ > - \ > - new_vec_->base.prefix.num = len_; \ > - memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \ > - } \ > - return new_vec_; \ > -} \ > - \ > -static inline void VEC_OP (T,A,free) \ > - (VEC(T,A) **vec_) \ > -{ \ > - if (*vec_) \ > - vec_##A##_free (*vec_); \ > - *vec_ = NULL; \ > -} \ > - \ > -static inline int VEC_OP (T,A,reserve) \ > - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ > - VEC_CHECK_PASS); \ > - \ > - if (extend) \ > - *vec_ = (VEC(T,A) *) vec_##A##_o_reserve (*vec_, alloc_, \ > - offsetof (VEC(T,A),base.vec),\ > - sizeof (T) \ > - PASS_MEM_STAT); \ > - \ > - return extend; \ > -} \ > - \ > -static inline int VEC_OP (T,A,reserve_exact) \ > - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ > - VEC_CHECK_PASS); \ > - \ > - if (extend) \ > - *vec_ = (VEC(T,A) *) vec_##A##_o_reserve_exact \ > - (*vec_, alloc_, \ > - offsetof (VEC(T,A),base.vec), \ > - sizeof (T) PASS_MEM_STAT); \ > - \ > - return extend; \ > -} \ > - \ > -static inline void VEC_OP (T,A,safe_grow) \ > - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - VEC_ASSERT (size_ >= 0 \ > - && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \ > - "grow", T, A); \ > - VEC_OP (T,A,reserve_exact) (vec_, \ > - size_ - (int)(*vec_ ? VEC_BASE(*vec_)->prefix.num : 0) \ > - VEC_CHECK_PASS PASS_MEM_STAT); \ > - VEC_BASE (*vec_)->prefix.num = size_; \ > -} \ > - \ > -static inline void VEC_OP (T,A,safe_grow_cleared) \ > - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \ > - VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \ > - memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \ > - sizeof (T) * (size_ - oldsize)); \ > -} \ > - \ > -static inline void VEC_OP(T,A,safe_splice) \ > - (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - if (src_) \ > - { \ > - VEC_OP (T,A,reserve_exact) (dst_, src_->prefix.num \ > - VEC_CHECK_PASS MEM_STAT_INFO); \ > - \ > - VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \ > - VEC_CHECK_PASS); \ > - } \ > -} \ > - \ > -static inline T *VEC_OP (T,A,safe_push) \ > - (VEC(T,A) **vec_, const T *obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ > - \ > - return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \ > -} \ > - \ > -static inline T *VEC_OP (T,A,safe_insert) \ > - (VEC(T,A) **vec_, unsigned ix_, const T *obj_ \ > - VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ > - \ > - return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ > - VEC_CHECK_PASS); \ > -} > - > -#define DEF_VEC_ALLOC_FUNC_I(T,A) \ > -static inline VEC(T,A) *VEC_OP (T,A,alloc) \ > - (int alloc_ MEM_STAT_DECL) \ > -{ \ > - return (VEC(T,A) *) vec_##A##_o_reserve_exact \ > - (NULL, alloc_, offsetof (VEC(T,A),base.vec), \ > - sizeof (T) PASS_MEM_STAT); \ > -} > - > -#define DEF_VEC_NONALLOC_FUNCS_I(T,A) \ > -static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \ > -{ \ > - size_t len_ = vec_ ? vec_->prefix.num : 0; \ > - VEC (T,A) *new_vec_ = NULL; \ > - \ > - if (len_) \ > - { \ > - new_vec_ = (VEC (T,A) *)(vec_##A##_o_reserve_exact \ > - (NULL, len_, \ > - offsetof (VEC(T,A),base.vec), sizeof (T) \ > - PASS_MEM_STAT)); \ > - \ > - new_vec_->base.prefix.num = len_; \ > - memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \ > - } \ > - return new_vec_; \ > -} \ > - \ > -static inline void VEC_OP (T,A,free) \ > - (VEC(T,A) **vec_) \ > -{ \ > - if (*vec_) \ > - vec_##A##_free (*vec_); \ > - *vec_ = NULL; \ > -} \ > - \ > -static inline int VEC_OP (T,A,reserve) \ > - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ > - VEC_CHECK_PASS); \ > - \ > - if (extend) \ > - *vec_ = (VEC(T,A) *) vec_##A##_o_reserve (*vec_, alloc_, \ > - offsetof (VEC(T,A),base.vec),\ > - sizeof (T) \ > - PASS_MEM_STAT); \ > - \ > - return extend; \ > -} \ > - \ > -static inline int VEC_OP (T,A,reserve_exact) \ > - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ > - VEC_CHECK_PASS); \ > - \ > - if (extend) \ > - *vec_ = (VEC(T,A) *) vec_##A##_o_reserve_exact \ > - (*vec_, alloc_, offsetof (VEC(T,A),base.vec), \ > - sizeof (T) PASS_MEM_STAT); \ > - \ > - return extend; \ > -} \ > - \ > -static inline void VEC_OP (T,A,safe_grow) \ > - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - VEC_ASSERT (size_ >= 0 \ > - && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \ > - "grow", T, A); \ > - VEC_OP (T,A,reserve_exact) (vec_, \ > - size_ - (int)(*vec_ ? VEC_BASE(*vec_)->prefix.num : 0) \ > - VEC_CHECK_PASS PASS_MEM_STAT); \ > - VEC_BASE (*vec_)->prefix.num = size_; \ > -} \ > - \ > -static inline void VEC_OP (T,A,safe_grow_cleared) \ > - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \ > - VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \ > - memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \ > - sizeof (T) * (size_ - oldsize)); \ > -} \ > - \ > -static inline void VEC_OP(T,A,safe_splice) \ > - (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - if (src_) \ > - { \ > - VEC_OP (T,A,reserve_exact) (dst_, src_->prefix.num \ > - VEC_CHECK_PASS MEM_STAT_INFO); \ > - \ > - VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \ > - VEC_CHECK_PASS); \ > - } \ > -} \ > - \ > -static inline T *VEC_OP (T,A,safe_push) \ > - (VEC(T,A) **vec_, const T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ > - \ > - return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \ > -} \ > - \ > -static inline T *VEC_OP (T,A,safe_insert) \ > - (VEC(T,A) **vec_, unsigned ix_, const T obj_ \ > - VEC_CHECK_DECL MEM_STAT_DECL) \ > -{ \ > - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ > - \ > - return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ > - VEC_CHECK_PASS); \ > +template<typename T> > +static inline unsigned > +VEC_lower_bound_1 (vec_t<T> *vec_, const T *ptr_, > + bool (*lessthan_)(const T*, const T*) VEC_CHECK_DECL) > +{ > + unsigned int len_ = VEC_length (T, vec_); > + unsigned int half_, middle_; > + unsigned int first_ = 0; > + while (len_ > 0) > + { > + T *middle_elem_; > + half_ = len_ >> 1; > + middle_ = first_; > + middle_ += half_; > + middle_elem_ = &VEC_index_1 (vec_, middle_ VEC_CHECK_PASS); > + if (lessthan_ (middle_elem_, ptr_)) > + { > + first_ = middle_; > + ++first_; > + len_ = len_ - half_ - 1; > + } > + else > + len_ = half_; > + } > + return first_; > } > > -/* We support a vector which starts out with space on the stack and > - switches to heap space when forced to reallocate. This works a > - little differently. Instead of DEF_VEC_ALLOC_P(TYPE, heap|gc), use > - DEF_VEC_ALLOC_P_STACK(TYPE). This uses alloca to get the initial > - space; because alloca can not be usefully called in an inline > - function, and because a macro can not define a macro, you must then > - write a #define for each type: > > - #define VEC_{TYPE}_stack_alloc(alloc) \ > - VEC_stack_alloc({TYPE}, alloc) > +void *vec_heap_o_reserve_1 (void *, int, size_t, size_t, bool MEM_STAT_DECL); > +void *vec_gc_o_reserve_1 (void *, int, size_t, size_t, bool MEM_STAT_DECL); > > - This is really a hack and perhaps can be made better. Note that > - this macro will wind up evaluating the ALLOC parameter twice. > +/* Ensure there are at least RESERVE free slots in VEC_, growing > + exponentially. If RESERVE < 0 grow exactly, else grow > + exponentially. As a special case, if VEC_ is NULL, and RESERVE is > + 0, no vector will be created. */ > > - Only the initial allocation will be made using alloca, so pass a > - reasonable estimate that doesn't use too much stack space; don't > - pass zero. Don't return a VEC(TYPE,stack) vector from the function > - which allocated it. */ > - > -extern void *vec_stack_p_reserve (void *, int MEM_STAT_DECL); > -extern void *vec_stack_p_reserve_exact (void *, int MEM_STAT_DECL); > -extern void *vec_stack_p_reserve_exact_1 (int, void *); > -extern void *vec_stack_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); > -extern void *vec_stack_o_reserve_exact (void *, int, size_t, size_t > - MEM_STAT_DECL); > -extern void vec_stack_free (void *); > - > -/* Unfortunately, we cannot use MEM_STAT_DECL here. */ > -#if GATHER_STATISTICS > -#define VEC_stack_alloc(T,alloc,name,line,function) \ > - (VEC_OP (T,stack,alloc1) \ > - (alloc, XALLOCAVAR (VEC(T,stack), VEC_embedded_size (T, alloc)))) > -#else > -#define VEC_stack_alloc(T,alloc) \ > - (VEC_OP (T,stack,alloc1) \ > - (alloc, XALLOCAVAR (VEC(T,stack), VEC_embedded_size (T, alloc)))) > -#endif > - > -#define DEF_VEC_ALLOC_P_STACK(T) \ > -VEC_TA(T,base,stack); \ > -DEF_VEC_ALLOC_FUNC_P_STACK(T) \ > -DEF_VEC_NONALLOC_FUNCS_P(T,stack) \ > -struct vec_swallow_trailing_semi > - > -#define DEF_VEC_ALLOC_FUNC_P_STACK(T) \ > -static inline VEC(T,stack) *VEC_OP (T,stack,alloc1) \ > - (int alloc_, VEC(T,stack)* space) \ > -{ \ > - return (VEC(T,stack) *) vec_stack_p_reserve_exact_1 (alloc_, space); \ > +template<typename T, enum vec_allocation_t A> > +vec_t<T> * > +vec_reserve (vec_t<T> *vec_, int reserve MEM_STAT_DECL) > +{ > + if (A == gc) > + return (vec_t<T> *) vec_gc_o_reserve_1 (vec_, reserve, > + offsetof (vec_t<T>, vec), > + sizeof (T), false > + PASS_MEM_STAT); > + else if (A == heap) > + return (vec_t<T> *) vec_heap_o_reserve_1 (vec_, reserve, > + offsetof (vec_t<T>, vec), > + sizeof (T), false > + PASS_MEM_STAT); > + else > + { > + /* Only allow stack vectors when re-growing them. The initial > + allocation of stack vectors must be done with the > + VEC_stack_alloc macro, because it uses alloca() for the > + allocation. */ > + if (vec_ == NULL) > + { > + fprintf (stderr, "Stack vectors must be initially allocated " > + "with VEC_stack_alloc.\n"); > + gcc_unreachable (); > + } > + return (vec_t<T> *) vec_stack_o_reserve (vec_, reserve, > + offsetof (vec_t<T>, vec), > + sizeof (T) PASS_MEM_STAT); > + } > } > > -#define DEF_VEC_ALLOC_O_STACK(T) \ > -VEC_TA(T,base,stack); \ > -DEF_VEC_ALLOC_FUNC_O_STACK(T) \ > -DEF_VEC_NONALLOC_FUNCS_O(T,stack) \ > -struct vec_swallow_trailing_semi > > -#define DEF_VEC_ALLOC_FUNC_O_STACK(T) \ > -static inline VEC(T,stack) *VEC_OP (T,stack,alloc1) \ > - (int alloc_, VEC(T,stack)* space) \ > -{ \ > - return (VEC(T,stack) *) vec_stack_p_reserve_exact_1 (alloc_, space); \ > -} > - > -#define DEF_VEC_ALLOC_I_STACK(T) \ > -VEC_TA(T,base,stack); \ > -DEF_VEC_ALLOC_FUNC_I_STACK(T) \ > -DEF_VEC_NONALLOC_FUNCS_I(T,stack) \ > -struct vec_swallow_trailing_semi > +/* Ensure there are at least RESERVE free slots in VEC_, growing > + exactly. If RESERVE < 0 grow exactly, else grow exponentially. As > + a special case, if VEC_ is NULL, and RESERVE is 0, no vector will be > + created. */ > > -#define DEF_VEC_ALLOC_FUNC_I_STACK(T) \ > -static inline VEC(T,stack) *VEC_OP (T,stack,alloc1) \ > - (int alloc_, VEC(T,stack)* space) \ > -{ \ > - return (VEC(T,stack) *) vec_stack_p_reserve_exact_1 (alloc_, space); \ > +template<typename T, enum vec_allocation_t A> > +vec_t<T> * > +vec_reserve_exact (vec_t<T> *vec_, int reserve MEM_STAT_DECL) > +{ > + if (A == gc) > + return (vec_t<T> *) vec_gc_o_reserve_1 (vec_, reserve, > + sizeof (struct vec_prefix), > + sizeof (T), true > + PASS_MEM_STAT); > + else if (A == heap) > + return (vec_t<T> *) vec_heap_o_reserve_1 (vec_, reserve, > + sizeof (struct vec_prefix), > + sizeof (T), true > + PASS_MEM_STAT); > + else if (A == stack) > + { > + /* Only allow stack vectors when re-growing them. The initial > + allocation of stack vectors must be done with VEC_alloc, > + because it uses alloca() for the allocation. */ > + if (vec_ == NULL) > + { > + fprintf (stderr, "Stack vectors must be initially allocated " > + "with VEC_stack_alloc.\n"); > + gcc_unreachable (); > + } > + return (vec_t<T> *) vec_stack_o_reserve_exact (vec_, reserve, > + sizeof (struct vec_prefix), > + sizeof (T) > + PASS_MEM_STAT); > + } > } > > #endif /* GCC_VEC_H */ > diff --git a/gcc/cp/call.c b/gcc/cp/call.c > index 5345f2b..7a72666 100644 > --- a/gcc/cp/call.c > +++ b/gcc/cp/call.c > @@ -1924,7 +1924,8 @@ add_function_candidate (struct z_candidate **candidates, > > for (i = 0; i < len; ++i) > { > - tree arg, argtype, to_type; > + tree argtype, to_type; > + tree arg; > conversion *t; > int is_this; > > @@ -1934,8 +1935,9 @@ add_function_candidate (struct z_candidate **candidates, > if (i == 0 && first_arg != NULL_TREE) > arg = first_arg; > else > - arg = VEC_index (tree, args, > - i + skip - (first_arg != NULL_TREE ? 1 : 0)); > + arg = CONST_CAST_TREE ( > + VEC_index (tree, args, > + i + skip - (first_arg != NULL_TREE ? 1 : 0))); > argtype = lvalue_type (arg); > > is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) > diff --git a/gcc/cp/class.c b/gcc/cp/class.c > index 2f377c8..dfa2b52 100644 > --- a/gcc/cp/class.c > +++ b/gcc/cp/class.c > @@ -8403,12 +8403,12 @@ build_vtbl_initializer (tree binfo, > int new_position = (TARGET_VTABLE_DATA_ENTRY_DISTANCE * ix > + (TARGET_VTABLE_DATA_ENTRY_DISTANCE - 1)); > > - VEC_replace (constructor_elt, vid.inits, new_position, e); > + VEC_replace (constructor_elt, vid.inits, new_position, *e); > > for (j = 1; j < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++j) > { > - constructor_elt *f = VEC_index (constructor_elt, vid.inits, > - new_position - j); > + constructor_elt *f = &VEC_index (constructor_elt, vid.inits, > + new_position - j); > f->index = NULL_TREE; > f->value = build1 (NOP_EXPR, vtable_entry_type, > null_pointer_node); > @@ -8429,7 +8429,7 @@ build_vtbl_initializer (tree binfo, > for (ix = VEC_length (constructor_elt, vid.inits) - 1; > VEC_iterate (constructor_elt, vid.inits, ix, e); > ix--, jx++) > - VEC_replace (constructor_elt, *inits, jx, e); > + VEC_replace (constructor_elt, *inits, jx, *e); > > /* Go through all the ordinary virtual functions, building up > initializers. */ > diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c > index b637643..5908996 100644 > --- a/gcc/cp/decl.c > +++ b/gcc/cp/decl.c > @@ -5282,7 +5282,7 @@ reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p, > && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1) > { > str_init = VEC_index (constructor_elt, > - CONSTRUCTOR_ELTS (str_init), 0)->value; > + CONSTRUCTOR_ELTS (str_init), 0).value; > } > > /* If it's a string literal, then it's the initializer for the array > @@ -5372,7 +5372,7 @@ reshape_init (tree type, tree init, tsubst_flags_t complain) > return init; > > /* Recurse on this CONSTRUCTOR. */ > - d.cur = VEC_index (constructor_elt, v, 0); > + d.cur = &VEC_index (constructor_elt, v, 0); > d.end = d.cur + VEC_length (constructor_elt, v); > > new_init = reshape_init_r (type, &d, true, complain); > @@ -5917,7 +5917,7 @@ type_dependent_init_p (tree init) > nelts = VEC_length (constructor_elt, elts); > for (i = 0; i < nelts; ++i) > if (type_dependent_init_p (VEC_index (constructor_elt, > - elts, i)->value)) > + elts, i).value)) > return true; > } > else > @@ -5947,7 +5947,7 @@ value_dependent_init_p (tree init) > nelts = VEC_length (constructor_elt, elts); > for (i = 0; i < nelts; ++i) > if (value_dependent_init_p (VEC_index (constructor_elt, > - elts, i)->value)) > + elts, i).value)) > return true; > } > else > @@ -6896,7 +6896,7 @@ cp_complete_array_type (tree *ptype, tree initial_value, bool do_default) > && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value))) > { > VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value); > - tree value = VEC_index (constructor_elt, v, 0)->value; > + tree value = VEC_index (constructor_elt, v, 0).value; > > if (TREE_CODE (value) == STRING_CST > && VEC_length (constructor_elt, v) == 1) > diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c > index d8c3305..a7f12ba 100644 > --- a/gcc/cp/parser.c > +++ b/gcc/cp/parser.c > @@ -273,7 +273,7 @@ cp_lexer_dump_tokens (FILE *file, VEC(cp_token,gc) *buffer, > > if (start_token > VEC_address (cp_token, buffer)) > { > - cp_lexer_print_token (file, VEC_index (cp_token, buffer, 0)); > + cp_lexer_print_token (file, &VEC_index (cp_token, buffer, 0)); > fprintf (file, " ... "); > } > > @@ -313,8 +313,7 @@ cp_lexer_dump_tokens (FILE *file, VEC(cp_token,gc) *buffer, > if (i == num && i < VEC_length (cp_token, buffer)) > { > fprintf (file, " ... "); > - cp_lexer_print_token (file, VEC_index (cp_token, buffer, > - VEC_length (cp_token, buffer) - 1)); > + cp_lexer_print_token (file, &VEC_last (cp_token, buffer)); > } > > fprintf (file, "\n"); > @@ -1723,11 +1722,11 @@ cp_parser_context_new (cp_parser_context* next) > /* Managing the unparsed function queues. */ > > #define unparsed_funs_with_default_args \ > - VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_default_args > + VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues).funs_with_default_args > #define unparsed_funs_with_definitions \ > - VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_definitions > + VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues).funs_with_definitions > #define unparsed_nsdmis \ > - VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->nsdmis > + VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues).nsdmis > > static void > push_unparsed_function_queues (cp_parser *parser) > @@ -8048,7 +8047,7 @@ record_lambda_scope (tree lambda) > static void > finish_lambda_scope (void) > { > - tree_int *p = VEC_last (tree_int, lambda_scope_stack); > + tree_int *p = &VEC_last (tree_int, lambda_scope_stack); > if (lambda_scope != p->t) > { > lambda_scope = p->t; > diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c > index a19a893..51cb5ee 100644 > --- a/gcc/cp/rtti.c > +++ b/gcc/cp/rtti.c > @@ -295,7 +295,7 @@ typeid_ok_p (void) > } > > pseudo_type_info > - = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE)->type; > + = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE).type; > type_info_type = TYPE_MAIN_VARIANT (const_type_info_type_node); > > /* Make sure abi::__type_info_pseudo has the same alias set > @@ -422,7 +422,7 @@ get_tinfo_decl (tree type) > if (!d) > { > int ix = get_pseudo_ti_index (type); > - tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, ix); > + tinfo_s *ti = &VEC_index (tinfo_s, tinfo_descs, ix); > > d = build_lang_decl (VAR_DECL, name, ti->type); > SET_DECL_ASSEMBLER_NAME (d, name); > @@ -1079,7 +1079,7 @@ typeinfo_in_lib_p (tree type) > static tree > get_pseudo_ti_init (tree type, unsigned tk_index) > { > - tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, tk_index); > + tinfo_s *ti = &VEC_index (tinfo_s, tinfo_descs, tk_index); > > gcc_assert (at_eof); > switch (tk_index) > @@ -1105,7 +1105,7 @@ get_pseudo_ti_init (tree type, unsigned tk_index) > tree tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo)); > > /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */ > - ti = VEC_index (tinfo_s, tinfo_descs, tk_index); > + ti = &VEC_index (tinfo_s, tinfo_descs, tk_index); > return class_initializer (ti, type, 1, tinfo); > } > > @@ -1160,14 +1160,14 @@ get_pseudo_ti_init (tree type, unsigned tk_index) > CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, tinfo); > CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, offset); > base_init = build_constructor (init_list_type_node, v); > - e = VEC_index (constructor_elt, init_vec, ix); > + e = &VEC_index (constructor_elt, init_vec, ix); > e->index = NULL_TREE; > e->value = base_init; > } > base_inits = build_constructor (init_list_type_node, init_vec); > > /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */ > - ti = VEC_index (tinfo_s, tinfo_descs, tk_index); > + ti = &VEC_index (tinfo_s, tinfo_descs, tk_index); > return class_initializer (ti, type, 3, > build_int_cst (NULL_TREE, hint), > build_int_cst (NULL_TREE, nbases), > @@ -1214,7 +1214,7 @@ create_pseudo_type_info (int tk, const char *real_name, ...) > fields = build_decl (input_location, > FIELD_DECL, NULL_TREE, > VEC_index (tinfo_s, tinfo_descs, > - TK_TYPE_INFO_TYPE)->type); > + TK_TYPE_INFO_TYPE).type); > > /* Now add the derived fields. */ > while ((field_decl = va_arg (ap, tree))) > @@ -1228,7 +1228,7 @@ create_pseudo_type_info (int tk, const char *real_name, ...) > finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE); > CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type; > > - ti = VEC_index (tinfo_s, tinfo_descs, tk); > + ti = &VEC_index (tinfo_s, tinfo_descs, tk); > ti->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST); > ti->name = get_identifier (real_name); > ti->vtable = NULL_TREE; > @@ -1321,7 +1321,7 @@ get_pseudo_ti_index (tree type) > while (VEC_iterate (tinfo_s, tinfo_descs, len++, ti)) > ti->type = ti->vtable = ti->name = NULL_TREE; > } > - else if (VEC_index (tinfo_s, tinfo_descs, ix)->type) > + else if (VEC_index (tinfo_s, tinfo_descs, ix).type) > /* already created. */ > break; > > @@ -1335,7 +1335,7 @@ get_pseudo_ti_index (tree type) > array_domain = build_index_type (size_int (num_bases)); > base_array = > build_array_type (VEC_index (tinfo_s, tinfo_descs, > - TK_BASE_TYPE)->type, > + TK_BASE_TYPE).type, > array_domain); > > push_abi_namespace (); > @@ -1387,7 +1387,7 @@ create_tinfo_types (void) > DECL_CHAIN (field) = fields; > fields = field; > > - ti = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE); > + ti = &VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE); > ti->type = make_class_type (RECORD_TYPE); > ti->vtable = NULL_TREE; > ti->name = NULL_TREE; > @@ -1427,7 +1427,7 @@ create_tinfo_types (void) > DECL_CHAIN (field) = fields; > fields = field; > > - ti = VEC_index (tinfo_s, tinfo_descs, TK_BASE_TYPE); > + ti = &VEC_index (tinfo_s, tinfo_descs, TK_BASE_TYPE); > > ti->type = make_class_type (RECORD_TYPE); > ti->vtable = NULL_TREE; > diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c > index 230e967..ebac960 100644 > --- a/gcc/cp/semantics.c > +++ b/gcc/cp/semantics.c > @@ -161,7 +161,7 @@ resume_deferring_access_checks (void) > { > if (!deferred_access_no_check) > VEC_last (deferred_access, deferred_access_stack) > - ->deferring_access_checks_kind = dk_deferred; > + .deferring_access_checks_kind = dk_deferred; > } > > /* Stop deferring access checks. */ > @@ -171,7 +171,7 @@ stop_deferring_access_checks (void) > { > if (!deferred_access_no_check) > VEC_last (deferred_access, deferred_access_stack) > - ->deferring_access_checks_kind = dk_no_deferred; > + .deferring_access_checks_kind = dk_no_deferred; > } > > /* Discard the current deferred access checks and restore the > @@ -198,7 +198,7 @@ get_deferred_access_checks (void) > return NULL; > else > return (VEC_last (deferred_access, deferred_access_stack) > - ->deferred_access_checks); > + .deferred_access_checks); > } > > /* Take current deferred checks and combine with the > @@ -216,10 +216,10 @@ pop_to_parent_deferring_access_checks (void) > deferred_access *ptr; > > checks = (VEC_last (deferred_access, deferred_access_stack) > - ->deferred_access_checks); > + .deferred_access_checks); > > VEC_pop (deferred_access, deferred_access_stack); > - ptr = VEC_last (deferred_access, deferred_access_stack); > + ptr = &VEC_last (deferred_access, deferred_access_stack); > if (ptr->deferring_access_checks_kind == dk_no_deferred) > { > /* Check access. */ > @@ -321,7 +321,7 @@ perform_or_defer_access_check (tree binfo, tree decl, tree diag_decl, > > gcc_assert (TREE_CODE (binfo) == TREE_BINFO); > > - ptr = VEC_last (deferred_access, deferred_access_stack); > + ptr = &VEC_last (deferred_access, deferred_access_stack); > > /* If we are not supposed to defer access checks, just check now. */ > if (ptr->deferring_access_checks_kind == dk_no_deferred) > @@ -5948,7 +5948,7 @@ build_constexpr_constructor_member_initializers (tree type, tree body) > if (VEC_length (constructor_elt, vec) > 0) > { > /* In a delegating constructor, return the target. */ > - constructor_elt *ce = VEC_index (constructor_elt, vec, 0); > + constructor_elt *ce = &VEC_index (constructor_elt, vec, 0); > if (ce->index == current_class_ptr) > { > body = ce->value; > @@ -6820,7 +6820,7 @@ cxx_eval_array_reference (const constexpr_call *call, tree t, > } > i = tree_low_cst (index, 0); > if (TREE_CODE (ary) == CONSTRUCTOR) > - return VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ary), i)->value; > + return VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ary), i).value; > else if (elem_nchars == 1) > return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary))), > TREE_STRING_POINTER (ary)[i]); > diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c > index bfbde04..7cc2457 100644 > --- a/gcc/cp/tree.c > +++ b/gcc/cp/tree.c > @@ -1337,7 +1337,7 @@ strip_typedefs_expr (tree t) > type = strip_typedefs (TREE_TYPE (t)); > for (i = 0; i < n; ++i) > { > - constructor_elt *e = VEC_index (constructor_elt, vec, i); > + constructor_elt *e = &VEC_index (constructor_elt, vec, i); > tree op = strip_typedefs_expr (e->value); > if (op != e->value) > { > diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c > index 326f602..2180535 100644 > --- a/gcc/cp/typeck2.c > +++ b/gcc/cp/typeck2.c > @@ -1178,7 +1178,7 @@ process_init_constructor_record (tree type, tree init, > > if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init))) > { > - constructor_elt *ce = VEC_index (constructor_elt, > + constructor_elt *ce = &VEC_index (constructor_elt, > CONSTRUCTOR_ELTS (init), idx); > if (ce->index) > { > @@ -1305,7 +1305,7 @@ process_init_constructor_union (tree type, tree init, > VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1); > } > > - ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0); > + ce = &VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0); > > /* If this element specifies a field, initialize via that field. */ > if (ce->index) > diff --git a/gcc/df-scan.c b/gcc/df-scan.c > index df90365..55492fa 100644 > --- a/gcc/df-scan.c > +++ b/gcc/df-scan.c > @@ -4448,7 +4448,6 @@ df_bb_verify (basic_block bb) > if (!INSN_P (insn)) > continue; > df_insn_refs_verify (&collection_rec, bb, insn, true); > - df_free_collection_rec (&collection_rec); > } > > /* Do the artificial defs and uses. */ > diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c > index 3c94b79..504f9a8 100644 > --- a/gcc/tree-sra.c > +++ b/gcc/tree-sra.c > @@ -3999,7 +3999,7 @@ splice_all_param_accesses (VEC (access_p, heap) **representatives) > result = UNUSED_PARAMS; > } > else > - VEC_quick_push (access_p, *representatives, NULL); > + VEC_quick_push (access_p, *representatives, (access_p) NULL); > } > > if (result == NO_GOOD_ACCESS) > @@ -4208,7 +4208,7 @@ get_adjustment_for_base (ipa_parm_adjustment_vec adjustments, tree base) > { > struct ipa_parm_adjustment *adj; > > - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); > + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); > if (!adj->copy_param && adj->base == base) > return adj; > } > @@ -4315,7 +4315,7 @@ sra_ipa_modify_expr (tree *expr, bool convert, > > for (i = 0; i < len; i++) > { > - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); > + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); > > if (adj->base == base && > (adj->offset == offset || adj->remove_param)) > @@ -4522,7 +4522,7 @@ sra_ipa_reset_debug_stmts (ipa_parm_adjustment_vec adjustments) > tree name, vexpr, copy = NULL_TREE; > use_operand_p use_p; > > - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); > + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); > if (adj->copy_param || !is_gimple_reg (adj->base)) > continue; > name = ssa_default_def (cfun, adj->base); > diff --git a/gcc/tree-ssa-address.c b/gcc/tree-ssa-address.c > index ddab7d8..57a590d 100644 > --- a/gcc/tree-ssa-address.c > +++ b/gcc/tree-ssa-address.c > @@ -215,7 +215,8 @@ addr_for_mem_ref (struct mem_address *addr, addr_space_t as, > templ_index + 1); > > /* Reuse the templates for addresses, so that we do not waste memory. */ > - templ = VEC_index (mem_addr_template, mem_addr_template_list, templ_index); > + templ = &VEC_index (mem_addr_template, mem_addr_template_list, > + templ_index); > if (!templ->ref) > { > sym = (addr->symbol ? > diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c > index d2a4128..a7b644f 100644 > --- a/gcc/tree-ssa-dom.c > +++ b/gcc/tree-ssa-dom.c > @@ -1734,7 +1734,8 @@ dom_opt_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED, > > /* Push a marker on the stacks of local information so that we know how > far to unwind when we finalize this block. */ > - VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, NULL); > + VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, > + (expr_hash_elt_t)NULL); > VEC_safe_push (tree, heap, const_and_copies_stack, NULL_TREE); > > record_equivalences_from_incoming_edge (bb); > @@ -1745,7 +1746,8 @@ dom_opt_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED, > /* Create equivalences from redundant PHIs. PHIs are only truly > redundant when they exist in the same block, so push another > marker and unwind right afterwards. */ > - VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, NULL); > + VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, > + (expr_hash_elt_t)NULL); > for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) > eliminate_redundant_computations (&gsi); > remove_local_expressions_from_table (); > @@ -1800,7 +1802,8 @@ dom_opt_leave_block (struct dom_walk_data *walk_data, basic_block bb) > /* Push a marker onto the available expression stack so that we > unwind any expressions related to the TRUE arm before processing > the false arm below. */ > - VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, NULL); > + VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, > + (expr_hash_elt_t)NULL); > VEC_safe_push (tree, heap, const_and_copies_stack, NULL_TREE); > > edge_info = (struct edge_info *) true_edge->aux; > diff --git a/gcc/hw-doloop.c b/gcc/hw-doloop.c > index 925039f..cd9b3f2 100644 > --- a/gcc/hw-doloop.c > +++ b/gcc/hw-doloop.c > @@ -345,12 +345,12 @@ discover_loop (hwloop_info loop, basic_block tail_bb, rtx tail_insn, rtx reg) > } > > /* Analyze the structure of the loops in the current function. Use > - STACK for bitmap allocations. Returns all the valid candidates for > + LOOP_STACK for bitmap allocations. Returns all the valid candidates for > hardware loops found in this function. HOOKS is the argument > passed to reorg_loops, used here to find the iteration registers > from a loop_end pattern. */ > static hwloop_info > -discover_loops (bitmap_obstack *stack, struct hw_doloop_hooks *hooks) > +discover_loops (bitmap_obstack *loop_stack, struct hw_doloop_hooks *hooks) > { > hwloop_info loops = NULL; > hwloop_info loop; > @@ -406,7 +406,7 @@ discover_loops (bitmap_obstack *stack, struct hw_doloop_hooks *hooks) > loops = loop; > loop->loop_no = nloops++; > loop->blocks = VEC_alloc (basic_block, heap, 20); > - loop->block_bitmap = BITMAP_ALLOC (stack); > + loop->block_bitmap = BITMAP_ALLOC (loop_stack); > > if (dump_file) > { > @@ -626,18 +626,18 @@ reorg_loops (bool do_reorder, struct hw_doloop_hooks *hooks) > { > hwloop_info loops = NULL; > hwloop_info loop; > - bitmap_obstack stack; > + bitmap_obstack loop_stack; > > df_live_add_problem (); > df_live_set_all_dirty (); > df_analyze (); > > - bitmap_obstack_initialize (&stack); > + bitmap_obstack_initialize (&loop_stack); > > if (dump_file) > fprintf (dump_file, ";; Find loops, first pass\n\n"); > > - loops = discover_loops (&stack, hooks); > + loops = discover_loops (&loop_stack, hooks); > > if (do_reorder) > { > @@ -647,7 +647,7 @@ reorg_loops (bool do_reorder, struct hw_doloop_hooks *hooks) > if (dump_file) > fprintf (dump_file, ";; Find loops, second pass\n\n"); > > - loops = discover_loops (&stack, hooks); > + loops = discover_loops (&loop_stack, hooks); > } > > for (loop = loops; loop; loop = loop->next) > diff --git a/gcc/config/bfin/bfin.c b/gcc/config/bfin/bfin.c > index 3a4b8af..0a0d702 100644 > --- a/gcc/config/bfin/bfin.c > +++ b/gcc/config/bfin/bfin.c > @@ -3478,7 +3478,7 @@ hwloop_optimize (hwloop_info loop) > /* If we have to insert the LSETUP before a jump, count that jump in the > length. */ > if (VEC_length (edge, loop->incoming) > 1 > - || !(VEC_last (edge, loop->incoming)->flags & EDGE_FALLTHRU)) > + || !(VEC_last (edge, loop->incoming).flags & EDGE_FALLTHRU)) > { > gcc_assert (JUMP_P (insn)); > insn = PREV_INSN (insn); > @@ -3747,7 +3747,7 @@ hwloop_optimize (hwloop_info loop) > { > rtx prev = BB_END (loop->incoming_src); > if (VEC_length (edge, loop->incoming) > 1 > - || !(VEC_last (edge, loop->incoming)->flags & EDGE_FALLTHRU)) > + || !(VEC_last (edge, loop->incoming).flags & EDGE_FALLTHRU)) > { > gcc_assert (JUMP_P (prev)); > prev = PREV_INSN (prev); > diff --git a/gcc/config/c6x/c6x.c b/gcc/config/c6x/c6x.c > index a189a1d..1905504 100644 > --- a/gcc/config/c6x/c6x.c > +++ b/gcc/config/c6x/c6x.c > @@ -126,7 +126,7 @@ DEF_VEC_ALLOC_O(c6x_sched_insn_info, heap); > static VEC(c6x_sched_insn_info, heap) *insn_info; > > #define INSN_INFO_LENGTH (VEC_length (c6x_sched_insn_info, insn_info)) > -#define INSN_INFO_ENTRY(N) (*VEC_index (c6x_sched_insn_info, insn_info, (N))) > +#define INSN_INFO_ENTRY(N) (VEC_index (c6x_sched_insn_info, insn_info, (N))) > > static bool done_cfi_sections; > > @@ -3448,8 +3448,8 @@ try_rename_operands (rtx head, rtx tail, unit_req_table reqs, rtx insn, > { > unsigned int mask1, mask2, mask_changed; > int count, side1, side2, req1, req2; > - insn_rr_info *this_rr = VEC_index (insn_rr_info, insn_rr, > - INSN_UID (chain->insn)); > + insn_rr_info *this_rr = &VEC_index (insn_rr_info, insn_rr, > + INSN_UID (chain->insn)); > > count = get_unit_reqs (chain->insn, &req1, &side1, &req2, &side2); > > @@ -3555,7 +3555,7 @@ reshuffle_units (basic_block loop) > if (!get_unit_operand_masks (insn, &mask1, &mask2)) > continue; > > - info = VEC_index (insn_rr_info, insn_rr, INSN_UID (insn)); > + info = &VEC_index (insn_rr_info, insn_rr, INSN_UID (insn)); > if (info->op_info == NULL) > continue; > > diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c > index f36f65b..3688136 100644 > --- a/gcc/config/mips/mips.c > +++ b/gcc/config/mips/mips.c > @@ -3971,7 +3971,8 @@ mips_multi_start (void) > static struct mips_multi_member * > mips_multi_add (void) > { > - return VEC_safe_push (mips_multi_member, heap, mips_multi_members, 0); > + return VEC_safe_push (mips_multi_member, heap, mips_multi_members, > + (struct mips_multi_member *) 0); > } > > /* Add a normal insn with the given asm format to the current multi-insn > @@ -4026,7 +4027,7 @@ mips_multi_copy_insn (unsigned int i) > struct mips_multi_member *member; > > member = mips_multi_add (); > - memcpy (member, VEC_index (mips_multi_member, mips_multi_members, i), > + memcpy (member, &VEC_index (mips_multi_member, mips_multi_members, i), > sizeof (*member)); > gcc_assert (!member->is_label_p); > } > @@ -4038,7 +4039,7 @@ mips_multi_copy_insn (unsigned int i) > static void > mips_multi_set_operand (unsigned int i, unsigned int op, rtx x) > { > - VEC_index (mips_multi_member, mips_multi_members, i)->operands[op] = x; > + VEC_index (mips_multi_member, mips_multi_members, i).operands[op] = x; > } > > /* Write out the asm code for the current multi-insn sequence. */ >
On 12-08-13 05:39 , Richard Guenther wrote: > It's an odd thing that you need to touch code replacing -> with . (yes, it's > due to the use of references) but not at the same time convert those places > to the new VEC interface. Yes. I hated this aspect of the initial conversion. It caused many merge problems. Unfortunately, I could not escape it. Diego.
> This implements the VEC re-write. > > See http://gcc.gnu.org/ml/gcc-patches/2012-08/msg00711.html for > details. You didn't update the head comment in vec.h though, is that on purpose?
On 12-08-15 10:44 , Eric Botcazou wrote: >> This implements the VEC re-write. >> >> See http://gcc.gnu.org/ml/gcc-patches/2012-08/msg00711.html for >> details. > > You didn't update the head comment in vec.h though, is that on purpose? Yes. I am updating it now that I'm *really* changing the interface. Diego.
diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c index 1b1bca8..cd35cd1 100644 --- a/gcc/ada/gcc-interface/trans.c +++ b/gcc/ada/gcc-interface/trans.c @@ -2921,7 +2921,7 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (TREE_OPERAND (TREE_OPERAND (ret_val, 0), 1)), - 1)->value; + 1).value; else ret_val = TREE_OPERAND (TREE_OPERAND (ret_val, 0), 1); } @@ -2980,7 +2980,7 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) TREE_OPERAND (alloc, 0), VEC_index (constructor_elt, CONSTRUCTOR_ELTS (TREE_OPERAND (alloc, 1)), - 0)->value); + 0).value); /* Build a modified CONSTRUCTOR that references NEW_VAR. */ p_array = TYPE_FIELDS (TREE_TYPE (alloc)); @@ -2990,7 +2990,7 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) VEC_index (constructor_elt, CONSTRUCTOR_ELTS (TREE_OPERAND (alloc, 1)), - 1)->value); + 1).value); new_ret = build_constructor (TREE_TYPE (alloc), v); } else diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c index cd91873..c9b29ad 100644 --- a/gcc/ada/gcc-interface/utils.c +++ b/gcc/ada/gcc-interface/utils.c @@ -4491,10 +4491,10 @@ convert (tree type, tree expr) inner expression. */ if (TREE_CODE (expr) == CONSTRUCTOR && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (expr)) - && VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0)->index + && VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0).index == TYPE_FIELDS (etype)) unpadded - = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0)->value; + = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0).value; /* Otherwise, build an explicit component reference. */ else @@ -5047,7 +5047,7 @@ remove_conversions (tree exp, bool true_address) && TYPE_JUSTIFIED_MODULAR_P (TREE_TYPE (exp))) return remove_conversions (VEC_index (constructor_elt, - CONSTRUCTOR_ELTS (exp), 0)->value, + CONSTRUCTOR_ELTS (exp), 0).value, true); break; diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c index a8a21a6..4578114 100644 --- a/gcc/ada/gcc-interface/utils2.c +++ b/gcc/ada/gcc-interface/utils2.c @@ -441,7 +441,7 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) /* The constant folder doesn't fold fat pointer types so we do it here. */ if (TREE_CODE (p1) == CONSTRUCTOR) - p1_array = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p1), 0)->value; + p1_array = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p1), 0).value; else p1_array = build_component_ref (p1, NULL_TREE, TYPE_FIELDS (TREE_TYPE (p1)), true); @@ -452,7 +452,7 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) null_pointer_node)); if (TREE_CODE (p2) == CONSTRUCTOR) - p2_array = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p2), 0)->value; + p2_array = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p2), 0).value; else p2_array = build_component_ref (p2, NULL_TREE, TYPE_FIELDS (TREE_TYPE (p2)), true); @@ -473,14 +473,14 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) = fold_build2_loc (loc, EQ_EXPR, result_type, p1_array, p2_array); if (TREE_CODE (p1) == CONSTRUCTOR) - p1_bounds = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p1), 1)->value; + p1_bounds = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p1), 1).value; else p1_bounds = build_component_ref (p1, NULL_TREE, DECL_CHAIN (TYPE_FIELDS (TREE_TYPE (p1))), true); if (TREE_CODE (p2) == CONSTRUCTOR) - p2_bounds = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p2), 1)->value; + p2_bounds = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (p2), 1).value; else p2_bounds = build_component_ref (p2, NULL_TREE, @@ -1336,7 +1336,7 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand) { result = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (operand), - 0)->value; + 0).value; result = convert (build_pointer_type (TREE_TYPE (operand)), build_unary_op (ADDR_EXPR, NULL_TREE, result)); break; @@ -2676,9 +2676,9 @@ gnat_stabilize_reference (tree ref, bool force, bool *success) && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (ref)) == 1) { tree index - = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ref), 0)->index; + = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ref), 0).index; tree value - = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ref), 0)->value; + = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ref), 0).value; result = build_constructor_single (type, index, gnat_stabilize_reference_1 (value, diff --git a/gcc/alias.c b/gcc/alias.c index a105004..de7640f 100644 --- a/gcc/alias.c +++ b/gcc/alias.c @@ -852,8 +852,8 @@ new_alias_set (void) if (flag_strict_aliasing) { if (alias_sets == 0) - VEC_safe_push (alias_set_entry, gc, alias_sets, 0); - VEC_safe_push (alias_set_entry, gc, alias_sets, 0); + VEC_safe_push (alias_set_entry, gc, alias_sets, (alias_set_entry) 0); + VEC_safe_push (alias_set_entry, gc, alias_sets, (alias_set_entry) 0); return VEC_length (alias_set_entry, alias_sets) - 1; } else diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index a002541..ab3eb0a 100644 --- a/gcc/c-family/c-common.c +++ b/gcc/c-family/c-common.c @@ -8392,7 +8392,7 @@ parse_optimize_options (tree args, bool attr_p) /* Build up argv vector. Just in case the string is stored away, use garbage collected strings. */ VEC_truncate (const_char_p, optimize_args, 0); - VEC_safe_push (const_char_p, gc, optimize_args, NULL); + VEC_safe_push (const_char_p, gc, optimize_args, (const_char_p)NULL); for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap)) { @@ -9390,10 +9390,10 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default) constructor_elt *ce; bool fold_p = false; - if (VEC_index (constructor_elt, v, 0)->index) + if (VEC_index (constructor_elt, v, 0).index) maxindex = fold_convert_loc (input_location, sizetype, VEC_index (constructor_elt, - v, 0)->index); + v, 0).index); curindex = maxindex; for (cnt = 1; diff --git a/gcc/c-family/c-pragma.c b/gcc/c-family/c-pragma.c index 830ca81..77ed0f0 100644 --- a/gcc/c-family/c-pragma.c +++ b/gcc/c-family/c-pragma.c @@ -1209,9 +1209,9 @@ c_pp_lookup_pragma (unsigned int id, const char **space, const char **name) + VEC_length (pragma_ns_name, registered_pp_pragmas))) { *space = VEC_index (pragma_ns_name, registered_pp_pragmas, - id - PRAGMA_FIRST_EXTERNAL)->space; + id - PRAGMA_FIRST_EXTERNAL).space; *name = VEC_index (pragma_ns_name, registered_pp_pragmas, - id - PRAGMA_FIRST_EXTERNAL)->name; + id - PRAGMA_FIRST_EXTERNAL).name; return; } @@ -1334,7 +1334,7 @@ c_invoke_pragma_handler (unsigned int id) pragma_handler_2arg handler_2arg; id -= PRAGMA_FIRST_EXTERNAL; - ihandler = VEC_index (internal_pragma_handler, registered_pragmas, id); + ihandler = &VEC_index (internal_pragma_handler, registered_pragmas, id); if (ihandler->extra_data) { handler_2arg = ihandler->handler.handler_2arg; diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c index 09df65d..e5d17b7 100644 --- a/gcc/c/c-decl.c +++ b/gcc/c/c-decl.c @@ -3932,7 +3932,7 @@ add_flexible_array_elts_to_size (tree decl, tree init) if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))) return; - elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value; + elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init)).value; type = TREE_TYPE (elt); if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == NULL_TREE diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c index 2237749..34d5a34 100644 --- a/gcc/c/c-parser.c +++ b/gcc/c/c-parser.c @@ -6529,9 +6529,9 @@ c_parser_postfix_expression (c_parser *parser) break; } - e1_p = VEC_index (c_expr_t, cexpr_list, 0); - e2_p = VEC_index (c_expr_t, cexpr_list, 1); - e3_p = VEC_index (c_expr_t, cexpr_list, 2); + e1_p = &VEC_index (c_expr_t, cexpr_list, 0); + e2_p = &VEC_index (c_expr_t, cexpr_list, 1); + e3_p = &VEC_index (c_expr_t, cexpr_list, 2); c = e1_p->value; mark_exp_read (e2_p->value); @@ -6611,8 +6611,8 @@ c_parser_postfix_expression (c_parser *parser) break; } - e1_p = VEC_index (c_expr_t, cexpr_list, 0); - e2_p = VEC_index (c_expr_t, cexpr_list, 1); + e1_p = &VEC_index (c_expr_t, cexpr_list, 0); + e2_p = &VEC_index (c_expr_t, cexpr_list, 1); mark_exp_read (e1_p->value); if (TREE_CODE (e1_p->value) == EXCESS_PRECISION_EXPR) @@ -6671,15 +6671,15 @@ c_parser_postfix_expression (c_parser *parser) if (VEC_length (c_expr_t, cexpr_list) == 2) expr.value = c_build_vec_perm_expr - (loc, VEC_index (c_expr_t, cexpr_list, 0)->value, - NULL_TREE, VEC_index (c_expr_t, cexpr_list, 1)->value); + (loc, VEC_index (c_expr_t, cexpr_list, 0).value, + NULL_TREE, VEC_index (c_expr_t, cexpr_list, 1).value); else if (VEC_length (c_expr_t, cexpr_list) == 3) expr.value = c_build_vec_perm_expr - (loc, VEC_index (c_expr_t, cexpr_list, 0)->value, - VEC_index (c_expr_t, cexpr_list, 1)->value, - VEC_index (c_expr_t, cexpr_list, 2)->value); + (loc, VEC_index (c_expr_t, cexpr_list, 0).value, + VEC_index (c_expr_t, cexpr_list, 1).value, + VEC_index (c_expr_t, cexpr_list, 2).value); else { error_at (loc, "wrong number of arguments to " diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c index c2f713e..5b710c3 100644 --- a/gcc/c/c-typeck.c +++ b/gcc/c/c-typeck.c @@ -6950,7 +6950,7 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack) bool constructor_zeroinit = (VEC_length (constructor_elt, constructor_elements) == 1 && integer_zerop - (VEC_index (constructor_elt, constructor_elements, 0)->value)); + (VEC_index (constructor_elt, constructor_elements, 0).value)); /* Do not warn for flexible array members or zero-length arrays. */ while (constructor_unfilled_fields @@ -6997,10 +6997,10 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack) else if (VEC_length (constructor_elt,constructor_elements) != 1) { error_init ("extra elements in scalar initializer"); - ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; + ret.value = VEC_index (constructor_elt,constructor_elements,0).value; } else - ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; + ret.value = VEC_index (constructor_elt,constructor_elements,0).value; } else { @@ -7671,9 +7671,9 @@ find_init_member (tree field, struct obstack * braced_init_obstack) else if (TREE_CODE (constructor_type) == UNION_TYPE) { if (!VEC_empty (constructor_elt, constructor_elements) - && (VEC_last (constructor_elt, constructor_elements)->index + && (VEC_last (constructor_elt, constructor_elements).index == field)) - return VEC_last (constructor_elt, constructor_elements)->value; + return VEC_last (constructor_elt, constructor_elements).value; } return 0; } @@ -7856,7 +7856,7 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type, if (!implicit) { if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt, - constructor_elements)->value)) + constructor_elements).value)) warning_init (0, "initialized field with side-effects overwritten"); else if (warn_override_init) diff --git a/gcc/combine.c b/gcc/combine.c index 2b91eb9..3c4dee8 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -1587,7 +1587,7 @@ set_nonzero_bits_and_sign_copies (rtx x, const_rtx set, void *data) (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x)) && HWI_COMPUTABLE_MODE_P (GET_MODE (x))) { - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x)); + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, REGNO (x)); if (set == 0 || GET_CODE (set) == CLOBBER) { @@ -3635,21 +3635,21 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p, && ! (temp = SET_DEST (XVECEXP (newpat, 0, 1)), (REG_P (temp) && VEC_index (reg_stat_type, reg_stat, - REGNO (temp))->nonzero_bits != 0 + REGNO (temp)).nonzero_bits != 0 && GET_MODE_PRECISION (GET_MODE (temp)) < BITS_PER_WORD && GET_MODE_PRECISION (GET_MODE (temp)) < HOST_BITS_PER_INT && (VEC_index (reg_stat_type, reg_stat, - REGNO (temp))->nonzero_bits + REGNO (temp)).nonzero_bits != GET_MODE_MASK (word_mode)))) && ! (GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) == SUBREG && (temp = SUBREG_REG (SET_DEST (XVECEXP (newpat, 0, 1))), (REG_P (temp) && VEC_index (reg_stat_type, reg_stat, - REGNO (temp))->nonzero_bits != 0 + REGNO (temp)).nonzero_bits != 0 && GET_MODE_PRECISION (GET_MODE (temp)) < BITS_PER_WORD && GET_MODE_PRECISION (GET_MODE (temp)) < HOST_BITS_PER_INT && (VEC_index (reg_stat_type, reg_stat, - REGNO (temp))->nonzero_bits + REGNO (temp)).nonzero_bits != GET_MODE_MASK (word_mode))))) && ! reg_overlap_mentioned_p (SET_DEST (XVECEXP (newpat, 0, 1)), SET_SRC (XVECEXP (newpat, 0, 1))) @@ -9425,7 +9425,7 @@ reg_nonzero_bits_for_combine (const_rtx x, enum machine_mode mode, value. Otherwise, use the previously-computed global nonzero bits for this register. */ - rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x)); + rsp = &VEC_index (reg_stat_type, reg_stat, REGNO (x)); if (rsp->last_set_value != 0 && (rsp->last_set_mode == mode || (GET_MODE_CLASS (rsp->last_set_mode) == MODE_INT @@ -9494,7 +9494,7 @@ reg_num_sign_bit_copies_for_combine (const_rtx x, enum machine_mode mode, rtx tem; reg_stat_type *rsp; - rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x)); + rsp = &VEC_index (reg_stat_type, reg_stat, REGNO (x)); if (rsp->last_set_value != 0 && rsp->last_set_mode == mode && ((rsp->last_set_label >= label_tick_ebb_start @@ -12033,7 +12033,7 @@ update_table_tick (rtx x) for (r = regno; r < endregno; r++) { - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, r); + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, r); rsp->last_set_table_tick = label_tick; } @@ -12135,7 +12135,7 @@ record_value_for_reg (rtx reg, rtx insn, rtx value) register. */ for (i = regno; i < endregno; i++) { - rsp = VEC_index (reg_stat_type, reg_stat, i); + rsp = &VEC_index (reg_stat_type, reg_stat, i); if (insn) rsp->last_set = insn; @@ -12161,7 +12161,7 @@ record_value_for_reg (rtx reg, rtx insn, rtx value) for (i = regno; i < endregno; i++) { - rsp = VEC_index (reg_stat_type, reg_stat, i); + rsp = &VEC_index (reg_stat_type, reg_stat, i); rsp->last_set_label = label_tick; if (!insn || (value && rsp->last_set_table_tick >= label_tick_ebb_start)) @@ -12173,7 +12173,7 @@ record_value_for_reg (rtx reg, rtx insn, rtx value) /* The value being assigned might refer to X (like in "x++;"). In that case, we must replace it with (clobber (const_int 0)) to prevent infinite loops. */ - rsp = VEC_index (reg_stat_type, reg_stat, regno); + rsp = &VEC_index (reg_stat_type, reg_stat, regno); if (value && !get_last_value_validate (&value, insn, label_tick, 0)) { value = copy_rtx (value); @@ -12271,7 +12271,7 @@ record_dead_and_set_regs (rtx insn) { reg_stat_type *rsp; - rsp = VEC_index (reg_stat_type, reg_stat, i); + rsp = &VEC_index (reg_stat_type, reg_stat, i); rsp->last_death = insn; } } @@ -12286,7 +12286,7 @@ record_dead_and_set_regs (rtx insn) { reg_stat_type *rsp; - rsp = VEC_index (reg_stat_type, reg_stat, i); + rsp = &VEC_index (reg_stat_type, reg_stat, i); rsp->last_set_invalid = 1; rsp->last_set = insn; rsp->last_set_value = 0; @@ -12344,7 +12344,7 @@ record_promoted_value (rtx insn, rtx subreg) continue; } - rsp = VEC_index (reg_stat_type, reg_stat, regno); + rsp = &VEC_index (reg_stat_type, reg_stat, regno); if (rsp->last_set == insn) { if (SUBREG_PROMOTED_UNSIGNED_P (subreg) > 0) @@ -12369,7 +12369,7 @@ record_promoted_value (rtx insn, rtx subreg) static bool reg_truncated_to_mode (enum machine_mode mode, const_rtx x) { - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x)); + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, REGNO (x)); enum machine_mode truncated = rsp->truncated_to_mode; if (truncated == 0 @@ -12414,7 +12414,7 @@ record_truncated_value (rtx *p, void *data ATTRIBUTE_UNUSED) else return 0; - rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x)); + rsp = &VEC_index (reg_stat_type, reg_stat, REGNO (x)); if (rsp->truncated_to_mode == 0 || rsp->truncation_label < label_tick_ebb_start || (GET_MODE_SIZE (truncated_mode) @@ -12493,7 +12493,7 @@ get_last_value_validate (rtx *loc, rtx insn, int tick, int replace) for (j = regno; j < endregno; j++) { - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, j); + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, j); if (rsp->last_set_invalid /* If this is a pseudo-register that was only set once and not live at the beginning of the function, it is always valid. */ @@ -12597,7 +12597,7 @@ get_last_value (const_rtx x) return 0; regno = REGNO (x); - rsp = VEC_index (reg_stat_type, reg_stat, regno); + rsp = &VEC_index (reg_stat_type, reg_stat, regno); value = rsp->last_set_value; /* If we don't have a value, or if it isn't for this basic block and @@ -12661,7 +12661,7 @@ use_crosses_set_p (const_rtx x, int from_luid) #endif for (; regno < endreg; regno++) { - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, regno); + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, regno); if (rsp->last_set && rsp->last_set_label == label_tick && DF_INSN_LUID (rsp->last_set) > from_luid) @@ -12909,7 +12909,7 @@ move_deaths (rtx x, rtx maybe_kill_insn, int from_luid, rtx to_insn, if (code == REG) { unsigned int regno = REGNO (x); - rtx where_dead = VEC_index (reg_stat_type, reg_stat, regno)->last_death; + rtx where_dead = VEC_index (reg_stat_type, reg_stat, regno).last_death; /* Don't move the register if it gets killed in between from and to. */ if (maybe_kill_insn && reg_set_p (x, maybe_kill_insn) @@ -13524,7 +13524,7 @@ distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2, rtx elim_i2, if (place && REG_NOTE_KIND (note) == REG_DEAD) { unsigned int regno = REGNO (XEXP (note, 0)); - reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, regno); + reg_stat_type *rsp = &VEC_index (reg_stat_type, reg_stat, regno); if (dead_or_set_p (place, XEXP (note, 0)) || reg_bitfield_target_p (XEXP (note, 0), PATTERN (place))) diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c index 3edb6e1..1702785 100644 --- a/gcc/dwarf2cfi.c +++ b/gcc/dwarf2cfi.c @@ -2550,7 +2550,7 @@ create_cfi_notes (void) gcc_checking_assert (trace_work_list == NULL); /* Always begin at the entry trace. */ - ti = VEC_index (dw_trace_info, trace_info, 0); + ti = &VEC_index (dw_trace_info, trace_info, 0); scan_trace (ti); while (!VEC_empty (dw_trace_info_ref, trace_work_list)) @@ -2597,7 +2597,7 @@ connect_traces (void) /* Remove all unprocessed traces from the list. */ for (i = n - 1; i > 0; --i) { - ti = VEC_index (dw_trace_info, trace_info, i); + ti = &VEC_index (dw_trace_info, trace_info, i); if (ti->beg_row == NULL) { VEC_ordered_remove (dw_trace_info, trace_info, i); @@ -2609,13 +2609,13 @@ connect_traces (void) /* Work from the end back to the beginning. This lets us easily insert remember/restore_state notes in the correct order wrt other notes. */ - prev_ti = VEC_index (dw_trace_info, trace_info, n - 1); + prev_ti = &VEC_index (dw_trace_info, trace_info, n - 1); for (i = n - 1; i > 0; --i) { dw_cfi_row *old_row; ti = prev_ti; - prev_ti = VEC_index (dw_trace_info, trace_info, i - 1); + prev_ti = &VEC_index (dw_trace_info, trace_info, i - 1); add_cfi_insn = ti->head; @@ -2686,7 +2686,7 @@ connect_traces (void) for (i = 0; i < n; ++i) { - ti = VEC_index (dw_trace_info, trace_info, i); + ti = &VEC_index (dw_trace_info, trace_info, i); if (ti->switch_sections) prev_args_size = 0; @@ -2884,8 +2884,8 @@ create_cie_data (void) break; case 1: cie_return_save = ggc_alloc_reg_saved_in_data (); - *cie_return_save = *VEC_index (reg_saved_in_data, - cie_trace.regs_saved_in_regs, 0); + *cie_return_save = VEC_index (reg_saved_in_data, + cie_trace.regs_saved_in_regs, 0); VEC_free (reg_saved_in_data, heap, cie_trace.regs_saved_in_regs); break; default: diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index 4b67d82..4bc4cc3 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -5821,7 +5821,7 @@ same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark) return 0; FOR_EACH_VEC_ELT (dw_attr_node, die1->die_attr, ix, a1) - if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark)) + if (!same_attr_p (a1, &VEC_index (dw_attr_node, die2->die_attr, ix), mark)) return 0; c1 = die1->die_child; @@ -7072,7 +7072,7 @@ build_abbrev_table (dw_die_ref die, htab_t extern_map) FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, die_a) { - abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix); + abbrev_a = &VEC_index (dw_attr_node, abbrev->die_attr, ix); if ((abbrev_a->dw_attr != die_a->dw_attr) || (value_format (abbrev_a) != value_format (die_a))) { @@ -20532,8 +20532,8 @@ optimize_macinfo_range (unsigned int idx, VEC (macinfo_entry, gc) *files, unsigned int i, count, encoded_filename_len, linebuf_len; void **slot; - first = VEC_index (macinfo_entry, macinfo_table, idx); - second = VEC_index (macinfo_entry, macinfo_table, idx + 1); + first = &VEC_index (macinfo_entry, macinfo_table, idx); + second = &VEC_index (macinfo_entry, macinfo_table, idx + 1); /* Optimize only if there are at least two consecutive define/undef ops, and either all of them are before first DW_MACINFO_start_file @@ -20573,7 +20573,7 @@ optimize_macinfo_range (unsigned int idx, VEC (macinfo_entry, gc) *files, if (VEC_empty (macinfo_entry, files)) base = ""; else - base = lbasename (VEC_last (macinfo_entry, files)->info); + base = lbasename (VEC_last (macinfo_entry, files).info); for (encoded_filename_len = 0, i = 0; base[i]; i++) if (ISIDNUM (base[i]) || base[i] == '.') encoded_filename_len++; @@ -20604,7 +20604,7 @@ optimize_macinfo_range (unsigned int idx, VEC (macinfo_entry, gc) *files, /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include in the empty vector entry before the first define/undef. */ - inc = VEC_index (macinfo_entry, macinfo_table, idx - 1); + inc = &VEC_index (macinfo_entry, macinfo_table, idx - 1); inc->code = DW_MACRO_GNU_transparent_include; inc->lineno = 0; inc->info = ggc_strdup (grp_name); @@ -20697,7 +20697,7 @@ output_macinfo (void) && VEC_length (macinfo_entry, files) != 1 && i > 0 && i + 1 < length - && VEC_index (macinfo_entry, macinfo_table, i - 1)->code == 0) + && VEC_index (macinfo_entry, macinfo_table, i - 1).code == 0) { unsigned count = optimize_macinfo_range (i, files, &macinfo_htab); if (count) @@ -21307,14 +21307,14 @@ static inline void move_linkage_attr (dw_die_ref die) { unsigned ix = VEC_length (dw_attr_node, die->die_attr); - dw_attr_node linkage = *VEC_index (dw_attr_node, die->die_attr, ix - 1); + dw_attr_node linkage = VEC_index (dw_attr_node, die->die_attr, ix - 1); gcc_assert (linkage.dw_attr == DW_AT_linkage_name || linkage.dw_attr == DW_AT_MIPS_linkage_name); while (--ix > 0) { - dw_attr_node *prev = VEC_index (dw_attr_node, die->die_attr, ix - 1); + dw_attr_node *prev = &VEC_index (dw_attr_node, die->die_attr, ix - 1); if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name) break; @@ -22226,8 +22226,8 @@ dwarf2out_finish (const char *filename) for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++) { add_location_or_const_value_attribute ( - VEC_index (deferred_locations, deferred_locations_list, i)->die, - VEC_index (deferred_locations, deferred_locations_list, i)->variable, + VEC_index (deferred_locations, deferred_locations_list, i).die, + VEC_index (deferred_locations, deferred_locations_list, i).variable, false, DW_AT_location); } diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c index ebd49b3..210cc14 100644 --- a/gcc/emit-rtl.c +++ b/gcc/emit-rtl.c @@ -6091,7 +6091,7 @@ locator_location (int loc) break; } } - return *VEC_index (location_t, locations_locators_vals, min); + return VEC_index (location_t, locations_locators_vals, min); } /* Return source line of the statement that produced this insn. */ diff --git a/gcc/except.c b/gcc/except.c index 605d8d7..0174512 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -304,8 +304,8 @@ init_eh_for_function (void) cfun->eh = ggc_alloc_cleared_eh_status (); /* Make sure zero'th entries are used. */ - VEC_safe_push (eh_region, gc, cfun->eh->region_array, NULL); - VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, NULL); + VEC_safe_push (eh_region, gc, cfun->eh->region_array, (eh_region) NULL); + VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, (eh_landing_pad) NULL); } /* Routines to generate the exception tree somewhat directly. @@ -806,7 +806,7 @@ add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list) if (targetm.arm_eabi_unwinder) VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi, NULL_TREE); else - VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, 0); + VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, (uchar) 0); } return n->filter; @@ -2395,10 +2395,10 @@ add_call_site (rtx landing_pad, int action, int section) record->action = action; VEC_safe_push (call_site_record, gc, - crtl->eh.call_site_record[section], record); + crtl->eh.call_site_record_v[section], record); return call_site_base + VEC_length (call_site_record, - crtl->eh.call_site_record[section]) - 1; + crtl->eh.call_site_record_v[section]) - 1; } /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes. @@ -2546,10 +2546,10 @@ convert_to_eh_region_ranges (void) else if (last_action != -3) last_landing_pad = pc_rtx; call_site_base += VEC_length (call_site_record, - crtl->eh.call_site_record[cur_sec]); + crtl->eh.call_site_record_v[cur_sec]); cur_sec++; - gcc_assert (crtl->eh.call_site_record[cur_sec] == NULL); - crtl->eh.call_site_record[cur_sec] + gcc_assert (crtl->eh.call_site_record_v[cur_sec] == NULL); + crtl->eh.call_site_record_v[cur_sec] = VEC_alloc (call_site_record, gc, 10); } @@ -2633,14 +2633,14 @@ push_sleb128 (VEC (uchar, gc) **data_area, int value) static int dw2_size_of_call_site_table (int section) { - int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]); + int n = VEC_length (call_site_record, crtl->eh.call_site_record_v[section]); int size = n * (4 + 4 + 4); int i; for (i = 0; i < n; ++i) { struct call_site_record_d *cs = - VEC_index (call_site_record, crtl->eh.call_site_record[section], i); + VEC_index (call_site_record, crtl->eh.call_site_record_v[section], i); size += size_of_uleb128 (cs->action); } @@ -2650,14 +2650,14 @@ dw2_size_of_call_site_table (int section) static int sjlj_size_of_call_site_table (void) { - int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]); + int n = VEC_length (call_site_record, crtl->eh.call_site_record_v[0]); int size = 0; int i; for (i = 0; i < n; ++i) { struct call_site_record_d *cs = - VEC_index (call_site_record, crtl->eh.call_site_record[0], i); + VEC_index (call_site_record, crtl->eh.call_site_record_v[0], i); size += size_of_uleb128 (INTVAL (cs->landing_pad)); size += size_of_uleb128 (cs->action); } @@ -2669,7 +2669,7 @@ sjlj_size_of_call_site_table (void) static void dw2_output_call_site_table (int cs_format, int section) { - int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]); + int n = VEC_length (call_site_record, crtl->eh.call_site_record_v[section]); int i; const char *begin; @@ -2683,7 +2683,7 @@ dw2_output_call_site_table (int cs_format, int section) for (i = 0; i < n; ++i) { struct call_site_record_d *cs = - VEC_index (call_site_record, crtl->eh.call_site_record[section], i); + VEC_index (call_site_record, crtl->eh.call_site_record_v[section], i); char reg_start_lab[32]; char reg_end_lab[32]; char landing_pad_lab[32]; @@ -2731,13 +2731,13 @@ dw2_output_call_site_table (int cs_format, int section) static void sjlj_output_call_site_table (void) { - int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]); + int n = VEC_length (call_site_record, crtl->eh.call_site_record_v[0]); int i; for (i = 0; i < n; ++i) { struct call_site_record_d *cs = - VEC_index (call_site_record, crtl->eh.call_site_record[0], i); + VEC_index (call_site_record, crtl->eh.call_site_record_v[0], i); dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad), "region %d landing pad", i); @@ -3051,7 +3051,7 @@ output_function_exception_table (const char *fnname) targetm.asm_out.emit_except_table_label (asm_out_file); output_one_function_exception_table (0); - if (crtl->eh.call_site_record[1] != NULL) + if (crtl->eh.call_site_record_v[1] != NULL) output_one_function_exception_table (1); switch_to_section (current_function_section ()); diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 5e14125..3bfd203 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -14285,7 +14285,7 @@ fold (tree expr) while (begin != end) { unsigned HOST_WIDE_INT middle = (begin + end) / 2; - tree index = VEC_index (constructor_elt, elts, middle)->index; + tree index = VEC_index (constructor_elt, elts, middle).index; if (TREE_CODE (index) == INTEGER_CST && tree_int_cst_lt (index, op1)) @@ -14300,7 +14300,7 @@ fold (tree expr) && tree_int_cst_lt (op1, TREE_OPERAND (index, 0))) end = middle; else - return VEC_index (constructor_elt, elts, middle)->value; + return VEC_index (constructor_elt, elts, middle).value; } } diff --git a/gcc/function.h b/gcc/function.h index 3d3313f..684bbce 100644 --- a/gcc/function.h +++ b/gcc/function.h @@ -157,7 +157,7 @@ struct GTY(()) rtl_eh { VEC(uchar,gc) *action_record_data; - VEC(call_site_record,gc) *call_site_record[2]; + VEC(call_site_record,gc) *call_site_record_v[2]; }; #define pending_stack_adjust (crtl->expr.x_pending_stack_adjust) diff --git a/gcc/fwprop.c b/gcc/fwprop.c index 65087ad..d1cba88 100644 --- a/gcc/fwprop.c +++ b/gcc/fwprop.c @@ -223,7 +223,7 @@ single_def_use_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED, bitmap_copy (local_lr, &lr_bb_info->in); /* Push a marker for the leave_block callback. */ - VEC_safe_push (df_ref, heap, reg_defs_stack, NULL); + VEC_safe_push (df_ref, heap, reg_defs_stack, (df_ref) NULL); process_uses (df_get_artificial_uses (bb_index), DF_REF_AT_TOP); process_defs (df_get_artificial_defs (bb_index), DF_REF_AT_TOP); diff --git a/gcc/gcc.c b/gcc/gcc.c index bda354a..815747e 100644 --- a/gcc/gcc.c +++ b/gcc/gcc.c @@ -2520,7 +2520,7 @@ execute (void) and record info about each one. Also search for the programs that are to be run. */ - VEC_safe_push (const_char_p, heap, argbuf, 0); + VEC_safe_push (const_char_p, heap, argbuf, (const_char_p)0); commands[0].prog = VEC_index (const_char_p, argbuf, 0); /* first command. */ commands[0].argv = VEC_address (const_char_p, argbuf); diff --git a/gcc/genautomata.c b/gcc/genautomata.c index 9f9e066..122a4a4 100644 --- a/gcc/genautomata.c +++ b/gcc/genautomata.c @@ -5076,7 +5076,8 @@ store_alt_unit_usage (regexp_t regexp, regexp_t unit, int cycle, length = (cycle + 1) * REGEXP_ONEOF (regexp)->regexps_num; while (VEC_length (unit_usage_t, cycle_alt_unit_usages) < length) - VEC_safe_push (unit_usage_t, heap, cycle_alt_unit_usages, 0); + VEC_safe_push (unit_usage_t, heap, cycle_alt_unit_usages, + (unit_usage_t) NULL); index = cycle * REGEXP_ONEOF (regexp)->regexps_num + alt_num; prev = NULL; @@ -7673,7 +7674,8 @@ output_min_issue_delay_table (automaton_t automaton) if (VEC_index (vect_el_t, min_issue_delay_vect, asn)) { - VEC_replace (vect_el_t, min_issue_delay_vect, asn, 0); + VEC_replace (vect_el_t, min_issue_delay_vect, asn, + (vect_el_t) 0); changed = 1; } @@ -7723,7 +7725,8 @@ output_min_issue_delay_table (automaton_t automaton) if (automaton->max_min_delay < x) automaton->max_min_delay = x; if (x == -1) - VEC_replace (vect_el_t, min_issue_delay_vect, np, 0); + VEC_replace (vect_el_t, min_issue_delay_vect, np, + (vect_el_t) 0); } } @@ -7749,7 +7752,8 @@ output_min_issue_delay_table (automaton_t automaton) = VEC_alloc (vect_el_t, heap, compressed_min_issue_delay_len); for (i = 0; i < compressed_min_issue_delay_len; i++) - VEC_quick_push (vect_el_t, compressed_min_issue_delay_vect, 0); + VEC_quick_push (vect_el_t, compressed_min_issue_delay_vect, + (vect_el_t) 0); for (i = 0; i < min_issue_delay_len; i++) { @@ -7798,7 +7802,8 @@ output_dead_lock_vect (automaton_t automaton) automaton->locked_states++; } else - VEC_replace (vect_el_t, dead_lock_vect, s->order_state_num, 0); + VEC_replace (vect_el_t, dead_lock_vect, s->order_state_num, + (vect_el_t) 0); } if (automaton->locked_states == 0) return; @@ -7840,7 +7845,7 @@ output_reserved_units_table (automaton_t automaton) reserved_units_table = VEC_alloc (vect_el_t, heap, reserved_units_size); for (i = 0; i < reserved_units_size; i++) - VEC_quick_push (vect_el_t, reserved_units_table, 0); + VEC_quick_push (vect_el_t, reserved_units_table, (vect_el_t) 0); for (n = 0; n < VEC_length (state_t, output_states_vect); n++) { state_t s = VEC_index (state_t, output_states_vect, n); diff --git a/gcc/genextract.c b/gcc/genextract.c index 09e7cde..175febe 100644 --- a/gcc/genextract.c +++ b/gcc/genextract.c @@ -201,7 +201,7 @@ VEC_safe_set_locstr (VEC(locstr,heap) **vp, unsigned int ix, char *str) else { while (ix > VEC_length (locstr, *vp)) - VEC_safe_push (locstr, heap, *vp, 0); + VEC_safe_push (locstr, heap, *vp, (locstr) NULL); VEC_safe_push (locstr, heap, *vp, str); } } diff --git a/gcc/gimple-low.c b/gcc/gimple-low.c index f17d8e7..7a51e8c 100644 --- a/gcc/gimple-low.c +++ b/gcc/gimple-low.c @@ -121,7 +121,7 @@ lower_function_body (void) if (gimple_seq_may_fallthru (lowered_body) && (VEC_empty (return_statements_t, data.return_statements) || gimple_return_retval (VEC_last (return_statements_t, - data.return_statements)->stmt) != NULL)) + data.return_statements).stmt) != NULL)) { x = gimple_build_return (NULL); gimple_set_location (x, cfun->function_end_locus); @@ -137,7 +137,7 @@ lower_function_body (void) /* Unfortunately, we can't use VEC_pop because it returns void for objects. */ - t = *VEC_last (return_statements_t, data.return_statements); + t = VEC_last (return_statements_t, data.return_statements); VEC_truncate (return_statements_t, data.return_statements, VEC_length (return_statements_t, @@ -835,7 +835,7 @@ lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data) for (i = VEC_length (return_statements_t, data->return_statements) - 1; i >= 0; i--) { - tmp_rs = *VEC_index (return_statements_t, data->return_statements, i); + tmp_rs = VEC_index (return_statements_t, data->return_statements, i); if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt)) { diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 03f7c9e..13cd535 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -2119,7 +2119,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, fallback_t fallback) { tree *p; - VEC(tree,heap) *stack; + VEC(tree,heap) *expr_stack; enum gimplify_status ret = GS_ALL_DONE, tret; int i; location_t loc = EXPR_LOCATION (*expr_p); @@ -2127,7 +2127,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, /* Create a stack of the subexpressions so later we can walk them in order from inner to outer. */ - stack = VEC_alloc (tree, heap, 10); + expr_stack = VEC_alloc (tree, heap, 10); /* We can handle anything that get_inner_reference can deal with. */ for (p = expr_p; ; p = &TREE_OPERAND (*p, 0)) @@ -2147,13 +2147,13 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, else break; - VEC_safe_push (tree, heap, stack, *p); + VEC_safe_push (tree, heap, expr_stack, *p); } - gcc_assert (VEC_length (tree, stack)); + gcc_assert (VEC_length (tree, expr_stack)); - /* Now STACK is a stack of pointers to all the refs we've walked through - and P points to the innermost expression. + /* Now EXPR_STACK is a stack of pointers to all the refs we've + walked through and P points to the innermost expression. Java requires that we elaborated nodes in source order. That means we must gimplify the inner expression followed by each of @@ -2164,9 +2164,9 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, So we do this in three steps. First we deal with the annotations for any variables in the components, then we gimplify the base, then we gimplify any indices, from left to right. */ - for (i = VEC_length (tree, stack) - 1; i >= 0; i--) + for (i = VEC_length (tree, expr_stack) - 1; i >= 0; i--) { - tree t = VEC_index (tree, stack, i); + tree t = VEC_index (tree, expr_stack, i); if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) { @@ -2259,9 +2259,9 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, /* And finally, the indices and operands of ARRAY_REF. During this loop we also remove any useless conversions. */ - for (; VEC_length (tree, stack) > 0; ) + for (; VEC_length (tree, expr_stack) > 0; ) { - tree t = VEC_pop (tree, stack); + tree t = VEC_pop (tree, expr_stack); if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) { @@ -2289,7 +2289,7 @@ gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, canonicalize_component_ref (expr_p); } - VEC_free (tree, heap, stack); + VEC_free (tree, heap, expr_stack); gcc_assert (*expr_p == expr || ret != GS_ALL_DONE); @@ -3848,7 +3848,7 @@ optimize_compound_literals_in_ctor (tree orig_ctor) for (idx = 0; idx < num; idx++) { - tree value = VEC_index (constructor_elt, elts, idx)->value; + tree value = VEC_index (constructor_elt, elts, idx).value; tree newval = value; if (TREE_CODE (value) == CONSTRUCTOR) newval = optimize_compound_literals_in_ctor (value); @@ -3872,7 +3872,7 @@ optimize_compound_literals_in_ctor (tree orig_ctor) CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts); elts = CONSTRUCTOR_ELTS (ctor); } - VEC_index (constructor_elt, elts, idx)->value = newval; + VEC_index (constructor_elt, elts, idx).value = newval; } return ctor; } @@ -4123,8 +4123,8 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, /* Extract the real and imaginary parts out of the ctor. */ gcc_assert (VEC_length (constructor_elt, elts) == 2); - r = VEC_index (constructor_elt, elts, 0)->value; - i = VEC_index (constructor_elt, elts, 1)->value; + r = VEC_index (constructor_elt, elts, 0).value; + i = VEC_index (constructor_elt, elts, 1).value; if (r == NULL || i == NULL) { tree zero = build_zero_cst (TREE_TYPE (type)); diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c index c168622..a92f92c 100644 --- a/gcc/graphite-sese-to-poly.c +++ b/gcc/graphite-sese-to-poly.c @@ -1249,7 +1249,7 @@ build_sese_conditions_before (struct dom_walk_data *dw_data, if (e->flags & EDGE_TRUE_VALUE) VEC_safe_push (gimple, heap, *cases, stmt); else - VEC_safe_push (gimple, heap, *cases, NULL); + VEC_safe_push (gimple, heap, *cases, (gimple) NULL); } gbb = gbb_from_bb (bb); diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c index 41d556a..53fedd2 100644 --- a/gcc/ipa-inline-analysis.c +++ b/gcc/ipa-inline-analysis.c @@ -295,9 +295,9 @@ add_clause (conditions conditions, struct predicate *p, clause_t clause) condition *cc1; if (!(clause & (1 << c1))) continue; - cc1 = VEC_index (condition, - conditions, - c1 - predicate_first_dynamic_condition); + cc1 = &VEC_index (condition, + conditions, + c1 - predicate_first_dynamic_condition); /* We have no way to represent !CHANGED and !IS_NOT_CONSTANT and thus there is no point for looking for them. */ if (cc1->code == CHANGED @@ -306,12 +306,12 @@ add_clause (conditions conditions, struct predicate *p, clause_t clause) for (c2 = c1 + 1; c2 <= NUM_CONDITIONS; c2++) if (clause & (1 << c2)) { - condition *cc1 = VEC_index (condition, - conditions, - c1 - predicate_first_dynamic_condition); - condition *cc2 = VEC_index (condition, - conditions, - c2 - predicate_first_dynamic_condition); + condition *cc1 = &VEC_index (condition, + conditions, + c1 - predicate_first_dynamic_condition); + condition *cc2 = &VEC_index (condition, + conditions, + c2 - predicate_first_dynamic_condition); if (cc1->operand_num == cc2->operand_num && cc1->val == cc2->val && cc2->code != IS_NOT_CONSTANT @@ -476,7 +476,7 @@ predicate_probability (conditions conds, { if (i2 >= predicate_first_dynamic_condition) { - condition *c = VEC_index + condition *c = &VEC_index (condition, conds, i2 - predicate_first_dynamic_condition); if (c->code == CHANGED @@ -486,7 +486,7 @@ predicate_probability (conditions conds, { int iprob = VEC_index (inline_param_summary_t, inline_param_summary, - c->operand_num)->change_prob; + c->operand_num).change_prob; this_prob = MAX (this_prob, iprob); } else @@ -516,8 +516,8 @@ dump_condition (FILE *f, conditions conditions, int cond) fprintf (f, "not inlined"); else { - c = VEC_index (condition, conditions, - cond - predicate_first_dynamic_condition); + c = &VEC_index (condition, conditions, + cond - predicate_first_dynamic_condition); fprintf (f, "op%i", c->operand_num); if (c->code == IS_NOT_CONSTANT) { @@ -609,7 +609,7 @@ account_size_time (struct inline_summary *summary, int size, int time, { i = 0; found = true; - e = VEC_index (size_time_entry, summary->entry, 0); + e = &VEC_index (size_time_entry, summary->entry, 0); gcc_assert (!e->predicate.clause[0]); } if (dump_file && (dump_flags & TDF_DETAILS) && (time || size)) @@ -759,7 +759,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p, else if (inline_p && !VEC_index (inline_param_summary_t, es->param, - i)->change_prob) + i).change_prob) VEC_replace (tree, known_vals, i, error_mark_node); } } @@ -1134,7 +1134,7 @@ dump_inline_edge_summary (FILE * f, int indent, struct cgraph_node *node, i++) { int prob = VEC_index (inline_param_summary_t, - es->param, i)->change_prob; + es->param, i).change_prob; if (!prob) fprintf (f, "%*s op%i is compile time invariant\n", @@ -1711,8 +1711,8 @@ will_be_nonconstant_predicate (struct ipa_node_params *info, return p; /* If we know when operand is constant, we still can say something useful. */ - if (!true_predicate_p (VEC_index (predicate_t, nonconstant_names, - SSA_NAME_VERSION (use)))) + if (!true_predicate_p (&VEC_index (predicate_t, nonconstant_names, + SSA_NAME_VERSION (use)))) continue; return p; } @@ -1734,14 +1734,14 @@ will_be_nonconstant_predicate (struct ipa_node_params *info, ipa_get_param_decl_index (info, parm), CHANGED, NULL); else - p = *VEC_index (predicate_t, nonconstant_names, - SSA_NAME_VERSION (use)); + p = VEC_index (predicate_t, nonconstant_names, + SSA_NAME_VERSION (use)); op_non_const = or_predicates (summary->conds, &p, &op_non_const); } if (gimple_code (stmt) == GIMPLE_ASSIGN && TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME) VEC_replace (predicate_t, nonconstant_names, - SSA_NAME_VERSION (gimple_assign_lhs (stmt)), &op_non_const); + SSA_NAME_VERSION (gimple_assign_lhs (stmt)), op_non_const); return op_non_const; } @@ -1956,7 +1956,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early) struct predicate false_p = false_predicate (); VEC_replace (predicate_t, nonconstant_names, SSA_NAME_VERSION (gimple_call_lhs (stmt)), - &false_p); + false_p); } if (ipa_node_params_vector) { @@ -1971,7 +1971,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early) int prob = param_change_prob (stmt, i); gcc_assert (prob >= 0 && prob <= REG_BR_PROB_BASE); VEC_index (inline_param_summary_t, - es->param, i)->change_prob = prob; + es->param, i).change_prob = prob; } } @@ -2430,8 +2430,8 @@ remap_predicate (struct inline_summary *info, { struct condition *c; - c = VEC_index (condition, callee_info->conds, - cond - predicate_first_dynamic_condition); + c = &VEC_index (condition, callee_info->conds, + cond - predicate_first_dynamic_condition); /* See if we can remap condition operand to caller's operand. Otherwise give up. */ if (!operand_map @@ -2519,10 +2519,10 @@ remap_edge_change_prob (struct cgraph_edge *inlined_edge, { int jf_formal_id = ipa_get_jf_pass_through_formal_id (jfunc); int prob1 = VEC_index (inline_param_summary_t, - es->param, i)->change_prob; + es->param, i).change_prob; int prob2 = VEC_index (inline_param_summary_t, - inlined_es->param, jf_formal_id)->change_prob; + inlined_es->param, jf_formal_id).change_prob; int prob = ((prob1 * prob2 + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE); @@ -2530,7 +2530,7 @@ remap_edge_change_prob (struct cgraph_edge *inlined_edge, prob = 1; VEC_index (inline_param_summary_t, - es->param, i)->change_prob = prob; + es->param, i).change_prob = prob; } } } @@ -2753,12 +2753,12 @@ do_estimate_edge_time (struct cgraph_edge *edge) <= edge->uid) VEC_safe_grow_cleared (edge_growth_cache_entry, heap, edge_growth_cache, cgraph_edge_max_uid); - VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid)->time + VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid).time = ret + (ret >= 0); ret_size = size - es->call_stmt_size; gcc_checking_assert (es->call_stmt_size); - VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid)->size + VEC_index (edge_growth_cache_entry, edge_growth_cache, edge->uid).size = ret_size + (ret_size >= 0); } return ret; @@ -2784,7 +2784,7 @@ do_estimate_edge_growth (struct cgraph_edge *edge) do_estimate_edge_time (edge); size = VEC_index (edge_growth_cache_entry, edge_growth_cache, - edge->uid)->size; + edge->uid).size; gcc_checking_assert (size); return size - (size > 0); } @@ -3019,7 +3019,7 @@ read_inline_edge_summary (struct lto_input_block *ib, struct cgraph_edge *e) { VEC_safe_grow_cleared (inline_param_summary_t, heap, es->param, length); for (i = 0; i < length; i++) - VEC_index (inline_param_summary_t, es->param, i)->change_prob + VEC_index (inline_param_summary_t, es->param, i).change_prob = streamer_read_uhwi (ib); } } @@ -3173,7 +3173,7 @@ write_inline_edge_summary (struct output_block *ob, struct cgraph_edge *e) streamer_write_uhwi (ob, VEC_length (inline_param_summary_t, es->param)); for (i = 0; i < (int)VEC_length (inline_param_summary_t, es->param); i++) streamer_write_uhwi (ob, VEC_index (inline_param_summary_t, - es->param, i)->change_prob); + es->param, i).change_prob); } diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c index d8b66e6..c43ce25 100644 --- a/gcc/ipa-inline.c +++ b/gcc/ipa-inline.c @@ -1287,7 +1287,7 @@ inline_small_functions (void) { struct cgraph_node *node; struct cgraph_edge *edge; - fibheap_t heap = fibheap_new (); + fibheap_t edge_heap = fibheap_new (); bitmap updated_nodes = BITMAP_ALLOC (NULL); int min_size, max_size; VEC (cgraph_edge_p, heap) *new_indirect_edges = NULL; @@ -1344,7 +1344,7 @@ inline_small_functions (void) && edge->inline_failed) { gcc_assert (!edge->aux); - update_edge_key (heap, edge); + update_edge_key (edge_heap, edge); } } @@ -1352,16 +1352,16 @@ inline_small_functions (void) || !max_count || (profile_info && flag_branch_probabilities)); - while (!fibheap_empty (heap)) + while (!fibheap_empty (edge_heap)) { int old_size = overall_size; struct cgraph_node *where, *callee; - int badness = fibheap_min_key (heap); + int badness = fibheap_min_key (edge_heap); int current_badness; int cached_badness; int growth; - edge = (struct cgraph_edge *) fibheap_extract_min (heap); + edge = (struct cgraph_edge *) fibheap_extract_min (edge_heap); gcc_assert (edge->aux); edge->aux = NULL; if (!edge->inline_failed) @@ -1382,7 +1382,7 @@ inline_small_functions (void) gcc_assert (current_badness >= badness); if (current_badness != badness) { - edge->aux = fibheap_insert (heap, current_badness, edge); + edge->aux = fibheap_insert (edge_heap, current_badness, edge); continue; } @@ -1447,8 +1447,8 @@ inline_small_functions (void) /* Recursive inliner inlines all recursive calls of the function at once. Consequently we need to update all callee keys. */ if (flag_indirect_inlining) - add_new_edges_to_heap (heap, new_indirect_edges); - update_callee_keys (heap, where, updated_nodes); + add_new_edges_to_heap (edge_heap, new_indirect_edges); + update_callee_keys (edge_heap, where, updated_nodes); } else { @@ -1482,12 +1482,12 @@ inline_small_functions (void) gcc_checking_assert (!callee->global.inlined_to); inline_call (edge, true, &new_indirect_edges, &overall_size, true); if (flag_indirect_inlining) - add_new_edges_to_heap (heap, new_indirect_edges); + add_new_edges_to_heap (edge_heap, new_indirect_edges); reset_edge_caches (edge->callee); reset_node_growth_cache (callee); - update_callee_keys (heap, edge->callee, updated_nodes); + update_callee_keys (edge_heap, edge->callee, updated_nodes); } where = edge->caller; if (where->global.inlined_to) @@ -1499,7 +1499,7 @@ inline_small_functions (void) inlined into (since it's body size changed) and for the functions called by function we inlined (since number of it inlinable callers might change). */ - update_caller_keys (heap, where, updated_nodes, NULL); + update_caller_keys (edge_heap, where, updated_nodes, NULL); bitmap_clear (updated_nodes); if (dump_file) @@ -1525,7 +1525,7 @@ inline_small_functions (void) free_growth_caches (); if (new_indirect_edges) VEC_free (cgraph_edge_p, heap, new_indirect_edges); - fibheap_delete (heap); + fibheap_delete (edge_heap); if (dump_file) fprintf (dump_file, "Unit growth for small function inlining: %i->%i (%i%%)\n", diff --git a/gcc/ipa-inline.h b/gcc/ipa-inline.h index fbd0b99..2d0004b 100644 --- a/gcc/ipa-inline.h +++ b/gcc/ipa-inline.h @@ -191,13 +191,13 @@ extern int nfunctions_inlined; static inline struct inline_summary * inline_summary (struct cgraph_node *node) { - return VEC_index (inline_summary_t, inline_summary_vec, node->uid); + return &VEC_index (inline_summary_t, inline_summary_vec, node->uid); } static inline struct inline_edge_summary * inline_edge_summary (struct cgraph_edge *edge) { - return VEC_index (inline_edge_summary_t, + return &VEC_index (inline_edge_summary_t, inline_edge_summary_vec, edge->uid); } @@ -226,7 +226,7 @@ estimate_edge_growth (struct cgraph_edge *edge) if ((int)VEC_length (edge_growth_cache_entry, edge_growth_cache) <= edge->uid || !(ret = VEC_index (edge_growth_cache_entry, edge_growth_cache, - edge->uid)->size)) + edge->uid).size)) return do_estimate_edge_growth (edge); return ret - (ret > 0); } @@ -242,7 +242,7 @@ estimate_edge_time (struct cgraph_edge *edge) if ((int)VEC_length (edge_growth_cache_entry, edge_growth_cache) <= edge->uid || !(ret = VEC_index (edge_growth_cache_entry, edge_growth_cache, - edge->uid)->time)) + edge->uid).time)) return do_estimate_edge_time (edge); return ret - (ret > 0); } @@ -265,6 +265,6 @@ reset_edge_growth_cache (struct cgraph_edge *edge) if ((int)VEC_length (edge_growth_cache_entry, edge_growth_cache) > edge->uid) { struct edge_growth_cache_entry zero = {0, 0}; - VEC_replace (edge_growth_cache_entry, edge_growth_cache, edge->uid, &zero); + VEC_replace (edge_growth_cache_entry, edge_growth_cache, edge->uid, zero); } } diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c index 7f90984..b964272 100644 --- a/gcc/ipa-prop.c +++ b/gcc/ipa-prop.c @@ -94,7 +94,7 @@ ipa_populate_param_decls (struct cgraph_node *node, for (parm = fnargs; parm; parm = DECL_CHAIN (parm)) { VEC_index (ipa_param_descriptor_t, - info->descriptors, param_num)->decl = parm; + info->descriptors, param_num).decl = parm; param_num++; } } @@ -2439,10 +2439,10 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst, old_args->jump_functions); for (i = 0; i < VEC_length (ipa_jump_func_t, old_args->jump_functions); i++) - VEC_index (ipa_jump_func_t, new_args->jump_functions, i)->agg.items + VEC_index (ipa_jump_func_t, new_args->jump_functions, i).agg.items = VEC_copy (ipa_agg_jf_item_t, gc, VEC_index (ipa_jump_func_t, - old_args->jump_functions, i)->agg.items); + old_args->jump_functions, i).agg.items); } /* Hook that is called by cgraph.c when a node is duplicated. */ @@ -2672,7 +2672,7 @@ ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments, struct ipa_parm_adjustment *adj; gcc_assert (link); - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); parm = VEC_index (tree, oparms, adj->base_index); adj->base = parm; @@ -2738,8 +2738,8 @@ ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments, When we are asked to remove it, we need to build new FUNCTION_TYPE instead. */ if (TREE_CODE (orig_type) != METHOD_TYPE - || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param - && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0)) + || (VEC_index (ipa_parm_adjustment_t, adjustments, 0).copy_param + && VEC_index (ipa_parm_adjustment_t, adjustments, 0).base_index == 0)) { new_type = build_distinct_type_copy (orig_type); TYPE_ARG_TYPES (new_type) = new_reversed; @@ -2806,7 +2806,7 @@ ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt, { struct ipa_parm_adjustment *adj; - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); if (adj->copy_param) { @@ -2989,7 +2989,7 @@ index_in_adjustments_multiple_times_p (int base_index, for (i = 0; i < len; i++) { struct ipa_parm_adjustment *adj; - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); if (adj->base_index == base_index) { @@ -3020,7 +3020,7 @@ ipa_combine_adjustments (ipa_parm_adjustment_vec inner, for (i = 0; i < inlen; i++) { struct ipa_parm_adjustment *n; - n = VEC_index (ipa_parm_adjustment_t, inner, i); + n = &VEC_index (ipa_parm_adjustment_t, inner, i); if (n->remove_param) removals++; @@ -3032,10 +3032,10 @@ ipa_combine_adjustments (ipa_parm_adjustment_vec inner, for (i = 0; i < outlen; i++) { struct ipa_parm_adjustment *r; - struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t, - outer, i); - struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp, - out->base_index); + struct ipa_parm_adjustment *out = &VEC_index (ipa_parm_adjustment_t, + outer, i); + struct ipa_parm_adjustment *in = &VEC_index (ipa_parm_adjustment_t, tmp, + out->base_index); gcc_assert (!in->remove_param); if (out->remove_param) @@ -3068,8 +3068,8 @@ ipa_combine_adjustments (ipa_parm_adjustment_vec inner, for (i = 0; i < inlen; i++) { - struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t, - inner, i); + struct ipa_parm_adjustment *n = &VEC_index (ipa_parm_adjustment_t, + inner, i); if (n->remove_param) VEC_quick_push (ipa_parm_adjustment_t, adjustments, n); @@ -3094,7 +3094,7 @@ ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments, for (i = 0; i < len; i++) { struct ipa_parm_adjustment *adj; - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); if (!first) fprintf (file, " "); diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h index 489e5d8..feb8ff7 100644 --- a/gcc/ipa-prop.h +++ b/gcc/ipa-prop.h @@ -359,7 +359,7 @@ ipa_get_param_count (struct ipa_node_params *info) static inline tree ipa_get_param (struct ipa_node_params *info, int i) { - return VEC_index (ipa_param_descriptor_t, info->descriptors, i)->decl; + return VEC_index (ipa_param_descriptor_t, info->descriptors, i).decl; } /* Set the used flag corresponding to the Ith formal parameter of the function @@ -368,7 +368,7 @@ ipa_get_param (struct ipa_node_params *info, int i) static inline void ipa_set_param_used (struct ipa_node_params *info, int i, bool val) { - VEC_index (ipa_param_descriptor_t, info->descriptors, i)->used = val; + VEC_index (ipa_param_descriptor_t, info->descriptors, i).used = val; } /* Return the used flag corresponding to the Ith formal parameter of the @@ -377,7 +377,7 @@ ipa_set_param_used (struct ipa_node_params *info, int i, bool val) static inline bool ipa_is_param_used (struct ipa_node_params *info, int i) { - return VEC_index (ipa_param_descriptor_t, info->descriptors, i)->used; + return VEC_index (ipa_param_descriptor_t, info->descriptors, i).used; } /* ipa_edge_args stores information related to a callsite and particularly its @@ -406,7 +406,7 @@ ipa_get_cs_argument_count (struct ipa_edge_args *args) static inline struct ipa_jump_func * ipa_get_ith_jump_func (struct ipa_edge_args *args, int i) { - return VEC_index (ipa_jump_func_t, args->jump_functions, i); + return &VEC_index (ipa_jump_func_t, args->jump_functions, i); } /* Vectors need to have typedefs of structures. */ @@ -425,10 +425,10 @@ extern GTY(()) VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector; /* Return the associated parameter/argument info corresponding to the given node/edge. */ -#define IPA_NODE_REF(NODE) (VEC_index (ipa_node_params_t, \ - ipa_node_params_vector, (NODE)->uid)) -#define IPA_EDGE_REF(EDGE) (VEC_index (ipa_edge_args_t, \ - ipa_edge_args_vector, (EDGE)->uid)) +#define IPA_NODE_REF(NODE) (&VEC_index (ipa_node_params_t, \ + ipa_node_params_vector, (NODE)->uid)) +#define IPA_EDGE_REF(EDGE) (&VEC_index (ipa_edge_args_t, \ + ipa_edge_args_vector, (EDGE)->uid)) /* This macro checks validity of index returned by ipa_get_param_decl_index function. */ #define IS_VALID_JUMP_FUNC_INDEX(I) ((I) != -1) diff --git a/gcc/ipa-ref-inline.h b/gcc/ipa-ref-inline.h index 636af14..575bba9 100644 --- a/gcc/ipa-ref-inline.h +++ b/gcc/ipa-ref-inline.h @@ -73,7 +73,7 @@ ipa_ref_list_first_reference (struct ipa_ref_list *list) { if (!VEC_length (ipa_ref_t, list->references)) return NULL; - return VEC_index (ipa_ref_t, list->references, 0); + return &VEC_index (ipa_ref_t, list->references, 0); } /* Return first referring ref in LIST or NULL if empty. */ diff --git a/gcc/ipa-ref.c b/gcc/ipa-ref.c index 7926eb6..21799ab 100644 --- a/gcc/ipa-ref.c +++ b/gcc/ipa-ref.c @@ -49,7 +49,7 @@ ipa_record_reference (symtab_node referring_node, old_references = list->references; VEC_safe_grow (ipa_ref_t, gc, list->references, VEC_length (ipa_ref_t, list->references) + 1); - ref = VEC_last (ipa_ref_t, list->references); + ref = &VEC_last (ipa_ref_t, list->references); list2 = &referred_node->symbol.ref_list; VEC_safe_push (ipa_ref_ptr, heap, list2->referring, ref); @@ -93,7 +93,7 @@ ipa_remove_reference (struct ipa_ref *ref) } VEC_pop (ipa_ref_ptr, list->referring); - last = VEC_last (ipa_ref_t, list2->references); + last = &VEC_last (ipa_ref_t, list2->references); if (ref != last) { *ref = *last; @@ -111,7 +111,7 @@ void ipa_remove_all_references (struct ipa_ref_list *list) { while (VEC_length (ipa_ref_t, list->references)) - ipa_remove_reference (VEC_last (ipa_ref_t, list->references)); + ipa_remove_reference (&VEC_last (ipa_ref_t, list->references)); VEC_free (ipa_ref_t, gc, list->references); list->references = NULL; } diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c index 2b5bc22..ed12b5f 100644 --- a/gcc/ipa-split.c +++ b/gcc/ipa-split.c @@ -921,7 +921,7 @@ find_split_points (int overall_time, int overall_size) while (!VEC_empty (stack_entry, stack)) { - stack_entry *entry = VEC_last (stack_entry, stack); + stack_entry *entry = &VEC_last (stack_entry, stack); /* We are walking an acyclic graph, so edge_num counts succ and pred edges together. However when considering @@ -988,9 +988,9 @@ find_split_points (int overall_time, int overall_size) new_entry.bb = dest; new_entry.edge_num = 0; new_entry.overall_time - = VEC_index (bb_info, bb_info_vec, dest->index)->time; + = VEC_index (bb_info, bb_info_vec, dest->index).time; new_entry.overall_size - = VEC_index (bb_info, bb_info_vec, dest->index)->size; + = VEC_index (bb_info, bb_info_vec, dest->index).size; new_entry.earliest = INT_MAX; new_entry.set_ssa_names = BITMAP_ALLOC (NULL); new_entry.used_ssa_names = BITMAP_ALLOC (NULL); @@ -1010,8 +1010,8 @@ find_split_points (int overall_time, int overall_size) and merge stuff we accumulate during the walk. */ else if (entry->bb != ENTRY_BLOCK_PTR) { - stack_entry *prev = VEC_index (stack_entry, stack, - VEC_length (stack_entry, stack) - 2); + stack_entry *prev = &VEC_index (stack_entry, stack, + VEC_length (stack_entry, stack) - 2); entry->bb->aux = (void *)(intptr_t)-1; prev->can_split &= entry->can_split; @@ -1493,8 +1493,8 @@ execute_split_functions (void) } overall_time += time; overall_size += size; - VEC_index (bb_info, bb_info_vec, bb->index)->time = time; - VEC_index (bb_info, bb_info_vec, bb->index)->size = size; + VEC_index (bb_info, bb_info_vec, bb->index).time = time; + VEC_index (bb_info, bb_info_vec, bb->index).size = size; } find_split_points (overall_time, overall_size); if (best_split_point.split_bbs) diff --git a/gcc/java/boehm.c b/gcc/java/boehm.c index f4a9af6..07dfb61 100644 --- a/gcc/java/boehm.c +++ b/gcc/java/boehm.c @@ -233,6 +233,6 @@ uses_jv_markobj_p (tree dtable) this function is only used with flag_reduced_reflection. No point in asserting unless we hit the bad case. */ gcc_assert (!flag_reduced_reflection || TARGET_VTABLE_USES_DESCRIPTORS == 0); - v = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (dtable), 3)->value; + v = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (dtable), 3).value; return (PROCEDURE_OBJECT_DESCRIPTOR == TREE_INT_CST_LOW (v)); } diff --git a/gcc/java/class.c b/gcc/java/class.c index 40ff26d..f806cea 100644 --- a/gcc/java/class.c +++ b/gcc/java/class.c @@ -1533,7 +1533,7 @@ make_method_value (tree mdecl) v = VEC_alloc (constructor_elt, gc, length); VEC_safe_grow_cleared (constructor_elt, gc, v, length); - e = VEC_index (constructor_elt, v, idx--); + e = &VEC_index (constructor_elt, v, idx--); e->value = null_pointer_node; FOR_EACH_VEC_ELT (tree, DECL_FUNCTION_THROWS (mdecl), ix, t) @@ -1542,7 +1542,7 @@ make_method_value (tree mdecl) tree utf8 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig), IDENTIFIER_LENGTH (sig))); - e = VEC_index (constructor_elt, v, idx--); + e = &VEC_index (constructor_elt, v, idx--); e->value = utf8; } gcc_assert (idx == -1); @@ -1621,7 +1621,7 @@ get_dispatch_table (tree type, tree this_class_addr) arraysize += 2; VEC_safe_grow_cleared (constructor_elt, gc, v, arraysize); - e = VEC_index (constructor_elt, v, arraysize - 1); + e = &VEC_index (constructor_elt, v, arraysize - 1); #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E-- for (i = nvirtuals; --i >= 0; ) @@ -3007,7 +3007,7 @@ emit_catch_table (tree this_class) int n_catch_classes; constructor_elt *e; /* Fill in the dummy entry that make_class created. */ - e = VEC_index (constructor_elt, TYPE_CATCH_CLASSES (this_class), 0); + e = &VEC_index (constructor_elt, TYPE_CATCH_CLASSES (this_class), 0); e->value = make_catch_class_record (null_pointer_node, null_pointer_node); CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class), NULL_TREE, make_catch_class_record (null_pointer_node, diff --git a/gcc/java/constants.c b/gcc/java/constants.c index 2cc911f..c709fa4 100644 --- a/gcc/java/constants.c +++ b/gcc/java/constants.c @@ -514,8 +514,8 @@ build_constants_constructor (void) int c = outgoing_cpool->count; VEC_safe_grow_cleared (constructor_elt, gc, tags, c); VEC_safe_grow_cleared (constructor_elt, gc, data, c); - t = VEC_index (constructor_elt, tags, c-1); - d = VEC_index (constructor_elt, data, c-1); + t = &VEC_index (constructor_elt, tags, c-1); + d = &VEC_index (constructor_elt, data, c-1); } #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E-- diff --git a/gcc/java/java-tree.h b/gcc/java/java-tree.h index 6169b6a..5167b9b 100644 --- a/gcc/java/java-tree.h +++ b/gcc/java/java-tree.h @@ -1430,7 +1430,7 @@ extern tree *type_map; #define PUSH_SUPER_VALUE(V, VALUE) \ do \ { \ - constructor_elt *_elt___ = VEC_last (constructor_elt, V); \ + constructor_elt *_elt___ = &VEC_last (constructor_elt, V); \ tree _next___ = DECL_CHAIN (_elt___->index); \ gcc_assert (!DECL_NAME (_elt___->index)); \ _elt___->value = VALUE; \ @@ -1444,7 +1444,7 @@ extern tree *type_map; #define PUSH_FIELD_VALUE(V, NAME, VALUE) \ do \ { \ - constructor_elt *_elt___ = VEC_last (constructor_elt, V); \ + constructor_elt *_elt___ = &VEC_last (constructor_elt, V); \ tree _next___ = DECL_CHAIN (_elt___->index); \ gcc_assert (strcmp (IDENTIFIER_POINTER (DECL_NAME (_elt___->index)), \ NAME) == 0); \ diff --git a/gcc/modulo-sched.c b/gcc/modulo-sched.c index af79fb6..673055e 100644 --- a/gcc/modulo-sched.c +++ b/gcc/modulo-sched.c @@ -229,7 +229,7 @@ static void remove_node_from_ps (partial_schedule_ptr, ps_insn_ptr); #define NODE_ASAP(node) ((node)->aux.count) -#define SCHED_PARAMS(x) VEC_index (node_sched_params, node_sched_param_vec, x) +#define SCHED_PARAMS(x) (&VEC_index (node_sched_params, node_sched_param_vec, x)) #define SCHED_TIME(x) (SCHED_PARAMS (x)->time) #define SCHED_ROW(x) (SCHED_PARAMS (x)->row) #define SCHED_STAGE(x) (SCHED_PARAMS (x)->stage) @@ -305,7 +305,7 @@ static struct ps_reg_move_info * ps_reg_move (partial_schedule_ptr ps, int id) { gcc_checking_assert (id >= ps->g->num_nodes); - return VEC_index (ps_reg_move_info, ps->reg_moves, id - ps->g->num_nodes); + return &VEC_index (ps_reg_move_info, ps->reg_moves, id - ps->g->num_nodes); } /* Return the rtl instruction that is being scheduled by partial schedule diff --git a/gcc/ree.c b/gcc/ree.c index 697e45f..1d0f194 100644 --- a/gcc/ree.c +++ b/gcc/ree.c @@ -802,7 +802,7 @@ add_removable_extension (const_rtx expr, rtx insn, different extension. FIXME: this obviously can be improved. */ for (def = defs; def; def = def->next) if ((idx = def_map[INSN_UID(DF_REF_INSN (def->ref))]) - && (cand = VEC_index (ext_cand, *insn_list, idx - 1)) + && (cand = &VEC_index (ext_cand, *insn_list, idx - 1)) && (cand->code != code || cand->mode != mode)) { if (dump_file) diff --git a/gcc/reg-stack.c b/gcc/reg-stack.c index d1e195d..dc7550a 100644 --- a/gcc/reg-stack.c +++ b/gcc/reg-stack.c @@ -201,7 +201,7 @@ typedef struct stack_def int top; /* index to top stack element */ HARD_REG_SET reg_set; /* set of live registers */ unsigned char reg[REG_STACK_SIZE];/* register - stack mapping */ -} *stack; +} *stack_ptr; /* This is used to carry information about basic blocks. It is attached to the AUX field of the standard CFG block. */ @@ -246,7 +246,7 @@ static rtx not_a_num; /* Forward declarations */ static int stack_regs_mentioned_p (const_rtx pat); -static void pop_stack (stack, int); +static void pop_stack (stack_ptr, int); static rtx *get_true_reg (rtx *); static int check_asm_stack_operands (rtx); @@ -254,19 +254,19 @@ static void get_asm_operands_in_out (rtx, int *, int *); static rtx stack_result (tree); static void replace_reg (rtx *, int); static void remove_regno_note (rtx, enum reg_note, unsigned int); -static int get_hard_regnum (stack, rtx); -static rtx emit_pop_insn (rtx, stack, rtx, enum emit_where); -static void swap_to_top(rtx, stack, rtx, rtx); -static bool move_for_stack_reg (rtx, stack, rtx); -static bool move_nan_for_stack_reg (rtx, stack, rtx); +static int get_hard_regnum (stack_ptr, rtx); +static rtx emit_pop_insn (rtx, stack_ptr, rtx, enum emit_where); +static void swap_to_top(rtx, stack_ptr, rtx, rtx); +static bool move_for_stack_reg (rtx, stack_ptr, rtx); +static bool move_nan_for_stack_reg (rtx, stack_ptr, rtx); static int swap_rtx_condition_1 (rtx); static int swap_rtx_condition (rtx); -static void compare_for_stack_reg (rtx, stack, rtx); -static bool subst_stack_regs_pat (rtx, stack, rtx); -static void subst_asm_stack_regs (rtx, stack); -static bool subst_stack_regs (rtx, stack); -static void change_stack (rtx, stack, stack, enum emit_where); -static void print_stack (FILE *, stack); +static void compare_for_stack_reg (rtx, stack_ptr, rtx); +static bool subst_stack_regs_pat (rtx, stack_ptr, rtx); +static void subst_asm_stack_regs (rtx, stack_ptr); +static bool subst_stack_regs (rtx, stack_ptr); +static void change_stack (rtx, stack_ptr, stack_ptr, enum emit_where); +static void print_stack (FILE *, stack_ptr); static rtx next_flags_user (rtx); /* Return nonzero if any stack register is mentioned somewhere within PAT. */ @@ -354,7 +354,7 @@ next_flags_user (rtx insn) /* Reorganize the stack into ascending numbers, before this insn. */ static void -straighten_stack (rtx insn, stack regstack) +straighten_stack (rtx insn, stack_ptr regstack) { struct stack_def temp_stack; int top; @@ -377,7 +377,7 @@ straighten_stack (rtx insn, stack regstack) /* Pop a register from the stack. */ static void -pop_stack (stack regstack, int regno) +pop_stack (stack_ptr regstack, int regno) { int top = regstack->top; @@ -721,7 +721,7 @@ remove_regno_note (rtx insn, enum reg_note note, unsigned int regno) returned if the register is not found. */ static int -get_hard_regnum (stack regstack, rtx reg) +get_hard_regnum (stack_ptr regstack, rtx reg) { int i; @@ -742,7 +742,7 @@ get_hard_regnum (stack regstack, rtx reg) cases the movdf pattern to pop. */ static rtx -emit_pop_insn (rtx insn, stack regstack, rtx reg, enum emit_where where) +emit_pop_insn (rtx insn, stack_ptr regstack, rtx reg, enum emit_where where) { rtx pop_insn, pop_rtx; int hard_regno; @@ -793,7 +793,7 @@ emit_pop_insn (rtx insn, stack regstack, rtx reg, enum emit_where where) If REG is already at the top of the stack, no insn is emitted. */ static void -emit_swap_insn (rtx insn, stack regstack, rtx reg) +emit_swap_insn (rtx insn, stack_ptr regstack, rtx reg) { int hard_regno; rtx swap_rtx; @@ -900,7 +900,7 @@ emit_swap_insn (rtx insn, stack regstack, rtx reg) is emitted. */ static void -swap_to_top (rtx insn, stack regstack, rtx src1, rtx src2) +swap_to_top (rtx insn, stack_ptr regstack, rtx src1, rtx src2) { struct stack_def temp_stack; int regno, j, k, temp; @@ -941,7 +941,7 @@ swap_to_top (rtx insn, stack regstack, rtx src1, rtx src2) was deleted in the process. */ static bool -move_for_stack_reg (rtx insn, stack regstack, rtx pat) +move_for_stack_reg (rtx insn, stack_ptr regstack, rtx pat) { rtx *psrc = get_true_reg (&SET_SRC (pat)); rtx *pdest = get_true_reg (&SET_DEST (pat)); @@ -1092,7 +1092,7 @@ move_for_stack_reg (rtx insn, stack regstack, rtx pat) a NaN into DEST, then invokes move_for_stack_reg. */ static bool -move_nan_for_stack_reg (rtx insn, stack regstack, rtx dest) +move_nan_for_stack_reg (rtx insn, stack_ptr regstack, rtx dest) { rtx pat; @@ -1231,7 +1231,7 @@ swap_rtx_condition (rtx insn) set up. */ static void -compare_for_stack_reg (rtx insn, stack regstack, rtx pat_src) +compare_for_stack_reg (rtx insn, stack_ptr regstack, rtx pat_src) { rtx *src1, *src2; rtx src1_note, src2_note; @@ -1320,7 +1320,7 @@ compare_for_stack_reg (rtx insn, stack regstack, rtx pat_src) static int subst_stack_regs_in_debug_insn (rtx *loc, void *data) { - stack regstack = (stack)data; + stack_ptr regstack = (stack_ptr)data; int hard_regno; if (!STACK_REG_P (*loc)) @@ -1361,7 +1361,7 @@ subst_all_stack_regs_in_debug_insn (rtx insn, struct stack_def *regstack) was deleted in the process. */ static bool -subst_stack_regs_pat (rtx insn, stack regstack, rtx pat) +subst_stack_regs_pat (rtx insn, stack_ptr regstack, rtx pat) { rtx *dest, *src; bool control_flow_insn_deleted = false; @@ -2009,7 +2009,7 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat) requirements, since record_asm_stack_regs removes any problem asm. */ static void -subst_asm_stack_regs (rtx insn, stack regstack) +subst_asm_stack_regs (rtx insn, stack_ptr regstack) { rtx body = PATTERN (insn); int alt; @@ -2292,7 +2292,7 @@ subst_asm_stack_regs (rtx insn, stack regstack) a control flow insn was deleted in the process. */ static bool -subst_stack_regs (rtx insn, stack regstack) +subst_stack_regs (rtx insn, stack_ptr regstack) { rtx *note_link, note; bool control_flow_insn_deleted = false; @@ -2404,7 +2404,7 @@ subst_stack_regs (rtx insn, stack regstack) is no longer needed once this has executed. */ static void -change_stack (rtx insn, stack old, stack new_stack, enum emit_where where) +change_stack (rtx insn, stack_ptr old, stack_ptr new_stack, enum emit_where where) { int reg; int update_end = 0; @@ -2610,7 +2610,7 @@ change_stack (rtx insn, stack old, stack new_stack, enum emit_where where) /* Print stack configuration. */ static void -print_stack (FILE *file, stack s) +print_stack (FILE *file, stack_ptr s) { if (! file) return; @@ -2686,7 +2686,7 @@ static void convert_regs_exit (void) { int value_reg_low, value_reg_high; - stack output_stack; + stack_ptr output_stack; rtx retvalue; retvalue = stack_result (current_function_decl); @@ -2719,8 +2719,8 @@ convert_regs_exit (void) static void propagate_stack (edge e) { - stack src_stack = &BLOCK_INFO (e->src)->stack_out; - stack dest_stack = &BLOCK_INFO (e->dest)->stack_in; + stack_ptr src_stack = &BLOCK_INFO (e->src)->stack_out; + stack_ptr dest_stack = &BLOCK_INFO (e->dest)->stack_in; int reg; /* Preserve the order of the original stack, but check whether @@ -2746,8 +2746,8 @@ static bool compensate_edge (edge e) { basic_block source = e->src, target = e->dest; - stack target_stack = &BLOCK_INFO (target)->stack_in; - stack source_stack = &BLOCK_INFO (source)->stack_out; + stack_ptr target_stack = &BLOCK_INFO (target)->stack_in; + stack_ptr source_stack = &BLOCK_INFO (source)->stack_out; struct stack_def regstack; int reg; diff --git a/gcc/regrename.c b/gcc/regrename.c index 2366fb5..d125242 100644 --- a/gcc/regrename.c +++ b/gcc/regrename.c @@ -728,8 +728,8 @@ regrename_analyze (bitmap bb_mask) rtx insn; FOR_BB_INSNS (bb1, insn) { - insn_rr_info *p = VEC_index (insn_rr_info, insn_rr, - INSN_UID (insn)); + insn_rr_info *p = &VEC_index (insn_rr_info, insn_rr, + INSN_UID (insn)); p->op_info = NULL; } } @@ -1583,7 +1583,7 @@ build_def_use (basic_block bb) if (insn_rr != NULL) { - insn_info = VEC_index (insn_rr_info, insn_rr, INSN_UID (insn)); + insn_info = &VEC_index (insn_rr_info, insn_rr, INSN_UID (insn)); insn_info->op_info = XOBNEWVEC (&rename_obstack, operand_rr_info, recog_data.n_operands); memset (insn_info->op_info, 0, diff --git a/gcc/reload.h b/gcc/reload.h index 29d15ea..a672ddc 100644 --- a/gcc/reload.h +++ b/gcc/reload.h @@ -243,19 +243,19 @@ typedef struct reg_equivs } reg_equivs_t; #define reg_equiv_constant(ELT) \ - VEC_index (reg_equivs_t, reg_equivs, (ELT))->constant + VEC_index (reg_equivs_t, reg_equivs, (ELT)).constant #define reg_equiv_invariant(ELT) \ - VEC_index (reg_equivs_t, reg_equivs, (ELT))->invariant + VEC_index (reg_equivs_t, reg_equivs, (ELT)).invariant #define reg_equiv_memory_loc(ELT) \ - VEC_index (reg_equivs_t, reg_equivs, (ELT))->memory_loc + VEC_index (reg_equivs_t, reg_equivs, (ELT)).memory_loc #define reg_equiv_address(ELT) \ - VEC_index (reg_equivs_t, reg_equivs, (ELT))->address + VEC_index (reg_equivs_t, reg_equivs, (ELT)).address #define reg_equiv_mem(ELT) \ - VEC_index (reg_equivs_t, reg_equivs, (ELT))->mem + VEC_index (reg_equivs_t, reg_equivs, (ELT)).mem #define reg_equiv_alt_mem_list(ELT) \ - VEC_index (reg_equivs_t, reg_equivs, (ELT))->alt_mem_list + VEC_index (reg_equivs_t, reg_equivs, (ELT)).alt_mem_list #define reg_equiv_init(ELT) \ - VEC_index (reg_equivs_t, reg_equivs, (ELT))->init + VEC_index (reg_equivs_t, reg_equivs, (ELT)).init DEF_VEC_O(reg_equivs_t); DEF_VEC_ALLOC_O(reg_equivs_t, gc); diff --git a/gcc/reload1.c b/gcc/reload1.c index bf5d3d3..b866af5 100644 --- a/gcc/reload1.c +++ b/gcc/reload1.c @@ -664,7 +664,8 @@ grow_reg_equivs (void) for (i = old_size; i < max_regno; i++) { VEC_quick_insert (reg_equivs_t, reg_equivs, i, 0); - memset (VEC_index (reg_equivs_t, reg_equivs, i), 0, sizeof (reg_equivs_t)); + memset (&VEC_index (reg_equivs_t, reg_equivs, i), 0, + sizeof (reg_equivs_t)); } } diff --git a/gcc/sched-int.h b/gcc/sched-int.h index fa5fc66..2e46238 100644 --- a/gcc/sched-int.h +++ b/gcc/sched-int.h @@ -873,7 +873,7 @@ DEF_VEC_ALLOC_O (haifa_insn_data_def, heap); extern VEC(haifa_insn_data_def, heap) *h_i_d; -#define HID(INSN) (VEC_index (haifa_insn_data_def, h_i_d, INSN_UID (INSN))) +#define HID(INSN) (&VEC_index (haifa_insn_data_def, h_i_d, INSN_UID (INSN))) /* Accessor macros for h_i_d. There are more in haifa-sched.c and sched-rgn.c. */ @@ -895,7 +895,7 @@ DEF_VEC_ALLOC_O (haifa_deps_insn_data_def, heap); extern VEC(haifa_deps_insn_data_def, heap) *h_d_i_d; -#define HDID(INSN) (VEC_index (haifa_deps_insn_data_def, h_d_i_d, \ +#define HDID(INSN) (&VEC_index (haifa_deps_insn_data_def, h_d_i_d, \ INSN_LUID (INSN))) #define INSN_DEP_COUNT(INSN) (HDID (INSN)->dep_count) #define HAS_INTERNAL_DEP(INSN) (HDID (INSN)->has_internal_dep) @@ -909,7 +909,7 @@ extern VEC(haifa_deps_insn_data_def, heap) *h_d_i_d; #define INSN_COND_DEPS(INSN) (HDID (INSN)->cond_deps) #define CANT_MOVE(INSN) (HDID (INSN)->cant_move) #define CANT_MOVE_BY_LUID(LUID) (VEC_index (haifa_deps_insn_data_def, h_d_i_d, \ - LUID)->cant_move) + LUID).cant_move) #define INSN_PRIORITY(INSN) (HID (INSN)->priority) diff --git a/gcc/sel-sched-ir.c b/gcc/sel-sched-ir.c index e7ca3f1..449efc9 100644 --- a/gcc/sel-sched-ir.c +++ b/gcc/sel-sched-ir.c @@ -1524,7 +1524,7 @@ insert_in_history_vect (VEC (expr_history_def, heap) **pvect, if (res) { - expr_history_def *phist = VEC_index (expr_history_def, vect, ind); + expr_history_def *phist = &VEC_index (expr_history_def, vect, ind); /* It is possible that speculation types of expressions that were propagated through different paths will be different here. In this @@ -4159,7 +4159,7 @@ finish_insns (void) removed during the scheduling. */ for (i = 0; i < VEC_length (sel_insn_data_def, s_i_d); i++) { - sel_insn_data_def *sid_entry = VEC_index (sel_insn_data_def, s_i_d, i); + sel_insn_data_def *sid_entry = &VEC_index (sel_insn_data_def, s_i_d, i); if (sid_entry->live) return_regset_to_pool (sid_entry->live); diff --git a/gcc/sel-sched-ir.h b/gcc/sel-sched-ir.h index 2003552..ef884a5 100644 --- a/gcc/sel-sched-ir.h +++ b/gcc/sel-sched-ir.h @@ -765,8 +765,8 @@ DEF_VEC_ALLOC_O (sel_insn_data_def, heap); extern VEC (sel_insn_data_def, heap) *s_i_d; /* Accessor macros for s_i_d. */ -#define SID(INSN) (VEC_index (sel_insn_data_def, s_i_d, INSN_LUID (INSN))) -#define SID_BY_UID(UID) (VEC_index (sel_insn_data_def, s_i_d, LUID_BY_UID (UID))) +#define SID(INSN) (&VEC_index (sel_insn_data_def, s_i_d, INSN_LUID (INSN))) +#define SID_BY_UID(UID) (&VEC_index (sel_insn_data_def, s_i_d, LUID_BY_UID (UID))) extern sel_insn_data_def insn_sid (insn_t); @@ -897,7 +897,7 @@ extern void sel_finish_global_bb_info (void); /* Get data for BB. */ #define SEL_GLOBAL_BB_INFO(BB) \ - (VEC_index (sel_global_bb_info_def, sel_global_bb_info, (BB)->index)) + (&VEC_index (sel_global_bb_info_def, sel_global_bb_info, (BB)->index)) /* Access macros. */ #define BB_LV_SET(BB) (SEL_GLOBAL_BB_INFO (BB)->lv_set) @@ -927,8 +927,8 @@ DEF_VEC_ALLOC_O (sel_region_bb_info_def, heap); extern VEC (sel_region_bb_info_def, heap) *sel_region_bb_info; /* Get data for BB. */ -#define SEL_REGION_BB_INFO(BB) (VEC_index (sel_region_bb_info_def, \ - sel_region_bb_info, (BB)->index)) +#define SEL_REGION_BB_INFO(BB) (&VEC_index (sel_region_bb_info_def, \ + sel_region_bb_info, (BB)->index)) /* Get BB's note_list. A note_list is a list of various notes that was scattered across BB diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c index f0c6eaf..b5bffa1 100644 --- a/gcc/sel-sched.c +++ b/gcc/sel-sched.c @@ -1938,9 +1938,9 @@ undo_transformations (av_set_t *av_ptr, rtx insn) { expr_history_def *phist; - phist = VEC_index (expr_history_def, - EXPR_HISTORY_OF_CHANGES (expr), - index); + phist = &VEC_index (expr_history_def, + EXPR_HISTORY_OF_CHANGES (expr), + index); switch (phist->type) { @@ -3581,7 +3581,7 @@ vinsn_vec_has_expr_p (vinsn_vec_t vinsn_vec, expr_t expr) EXPR_HISTORY_OF_CHANGES (expr)) ? VEC_index (expr_history_def, EXPR_HISTORY_OF_CHANGES (expr), - i++)->old_expr_vinsn + i++).old_expr_vinsn : NULL)) FOR_EACH_VEC_ELT (vinsn_t, vinsn_vec, n, vinsn) if (VINSN_SEPARABLE_P (vinsn)) diff --git a/gcc/tree-call-cdce.c b/gcc/tree-call-cdce.c index c879548..be020da 100644 --- a/gcc/tree-call-cdce.c +++ b/gcc/tree-call-cdce.c @@ -374,7 +374,7 @@ gen_conditions_for_domain (tree arg, inp_domain domain, { /* Now push a separator. */ if (domain.has_lb) - VEC_quick_push (gimple, conds, NULL); + VEC_quick_push (gimple, conds, (gimple)NULL); gen_one_condition (arg, domain.ub, (domain.is_ub_inclusive @@ -496,7 +496,7 @@ gen_conditions_for_pow_int_base (tree base, tree expn, type is integer. */ /* Push a separator. */ - VEC_quick_push (gimple, conds, NULL); + VEC_quick_push (gimple, conds, (gimple)NULL); temp = create_tmp_var (int_type, "DCE_COND1"); cst0 = build_int_cst (int_type, 0); diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index c44567f..7429003 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -3120,7 +3120,7 @@ multiplier_allowed_in_address_p (HOST_WIDE_INT ratio, enum machine_mode mode, TODO -- there must be some better way. This all is quite crude. */ -typedef struct +typedef struct address_cost_data_s { HOST_WIDE_INT min_offset, max_offset; unsigned costs[2][2][2][2]; diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index 233ecce..30c4127 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -962,7 +962,7 @@ static VEC (oecount, heap) *cvec; static hashval_t oecount_hash (const void *p) { - const oecount *c = VEC_index (oecount, cvec, (size_t)p - 42); + const oecount *c = &VEC_index (oecount, cvec, (size_t)p - 42); return htab_hash_pointer (c->op) ^ (hashval_t)c->oecode; } @@ -971,8 +971,8 @@ oecount_hash (const void *p) static int oecount_eq (const void *p1, const void *p2) { - const oecount *c1 = VEC_index (oecount, cvec, (size_t)p1 - 42); - const oecount *c2 = VEC_index (oecount, cvec, (size_t)p2 - 42); + const oecount *c1 = &VEC_index (oecount, cvec, (size_t)p1 - 42); + const oecount *c2 = &VEC_index (oecount, cvec, (size_t)p2 - 42); return (c1->oecode == c2->oecode && c1->op == c2->op); } @@ -1354,7 +1354,7 @@ undistribute_ops_list (enum tree_code opcode, else { VEC_pop (oecount, cvec); - VEC_index (oecount, cvec, (size_t)*slot - 42)->cnt++; + VEC_index (oecount, cvec, (size_t)*slot - 42).cnt++; } } } @@ -1381,7 +1381,7 @@ undistribute_ops_list (enum tree_code opcode, candidates2 = sbitmap_alloc (length); while (!VEC_empty (oecount, cvec)) { - oecount *c = VEC_last (oecount, cvec); + oecount *c = &VEC_last (oecount, cvec); if (c->cnt < 2) break; @@ -3190,7 +3190,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) fputs ("Multiplying by cached product ", dump_file); for (elt = j; elt < vec_len; elt++) { - rf = VEC_index (repeat_factor, repeat_factor_vec, elt); + rf = &VEC_index (repeat_factor, repeat_factor_vec, elt); print_generic_expr (dump_file, rf->factor, 0); if (elt < vec_len - 1) fputs (" * ", dump_file); @@ -3216,7 +3216,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) dump_file); for (elt = j; elt < vec_len; elt++) { - rf = VEC_index (repeat_factor, repeat_factor_vec, elt); + rf = &VEC_index (repeat_factor, repeat_factor_vec, elt); print_generic_expr (dump_file, rf->factor, 0); if (elt < vec_len - 1) fputs (" * ", dump_file); @@ -3250,7 +3250,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) fputs ("Building __builtin_pow call for (", dump_file); for (elt = j; elt < vec_len; elt++) { - rf = VEC_index (repeat_factor, repeat_factor_vec, elt); + rf = &VEC_index (repeat_factor, repeat_factor_vec, elt); print_generic_expr (dump_file, rf->factor, 0); if (elt < vec_len - 1) fputs (" * ", dump_file); @@ -3275,8 +3275,8 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) { tree op1, op2; - rf1 = VEC_index (repeat_factor, repeat_factor_vec, ii); - rf2 = VEC_index (repeat_factor, repeat_factor_vec, ii + 1); + rf1 = &VEC_index (repeat_factor, repeat_factor_vec, ii); + rf2 = &VEC_index (repeat_factor, repeat_factor_vec, ii + 1); /* Init the last factor's representative to be itself. */ if (!rf2->repr) @@ -3300,7 +3300,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) /* Form a call to __builtin_powi for the maximum product just formed, raised to the power obtained earlier. */ - rf1 = VEC_index (repeat_factor, repeat_factor_vec, j); + rf1 = &VEC_index (repeat_factor, repeat_factor_vec, j); iter_result = make_temp_ssa_name (type, NULL, "reassocpow"); pow_stmt = gimple_build_call (powi_fndecl, 2, rf1->repr, build_int_cst (integer_type_node, @@ -3333,7 +3333,7 @@ attempt_builtin_powi (gimple stmt, VEC(operand_entry_t, heap) **ops) unsigned k = power; unsigned n; - rf1 = VEC_index (repeat_factor, repeat_factor_vec, i); + rf1 = &VEC_index (repeat_factor, repeat_factor_vec, i); rf1->count -= power; FOR_EACH_VEC_ELT_REVERSE (operand_entry_t, *ops, n, oe) diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index 842c392..55798d1 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -775,7 +775,7 @@ ao_ref_init_from_vn_reference (ao_ref *ref, alias_set_type base_alias_set = -1; /* First get the final access size from just the outermost expression. */ - op = VEC_index (vn_reference_op_s, ops, 0); + op = &VEC_index (vn_reference_op_s, ops, 0); if (op->opcode == COMPONENT_REF) size_tree = DECL_SIZE (op->op0); else if (op->opcode == BIT_FIELD_REF) @@ -815,7 +815,7 @@ ao_ref_init_from_vn_reference (ao_ref *ref, && op->op0 && DECL_P (TREE_OPERAND (op->op0, 0))) { - vn_reference_op_t pop = VEC_index (vn_reference_op_s, ops, i-1); + vn_reference_op_t pop = &VEC_index (vn_reference_op_s, ops, i-1); base = TREE_OPERAND (op->op0, 0); if (pop->off == -1) { @@ -1004,8 +1004,8 @@ vn_reference_fold_indirect (VEC (vn_reference_op_s, heap) **ops, unsigned int *i_p) { unsigned int i = *i_p; - vn_reference_op_t op = VEC_index (vn_reference_op_s, *ops, i); - vn_reference_op_t mem_op = VEC_index (vn_reference_op_s, *ops, i - 1); + vn_reference_op_t op = &VEC_index (vn_reference_op_s, *ops, i); + vn_reference_op_t mem_op = &VEC_index (vn_reference_op_s, *ops, i - 1); tree addr_base; HOST_WIDE_INT addr_offset; @@ -1036,8 +1036,8 @@ vn_reference_maybe_forwprop_address (VEC (vn_reference_op_s, heap) **ops, unsigned int *i_p) { unsigned int i = *i_p; - vn_reference_op_t op = VEC_index (vn_reference_op_s, *ops, i); - vn_reference_op_t mem_op = VEC_index (vn_reference_op_s, *ops, i - 1); + vn_reference_op_t op = &VEC_index (vn_reference_op_s, *ops, i); + vn_reference_op_t mem_op = &VEC_index (vn_reference_op_s, *ops, i - 1); gimple def_stmt; enum tree_code code; double_int off; @@ -1114,7 +1114,7 @@ fully_constant_vn_reference_p (vn_reference_t ref) /* Try to simplify the translated expression if it is a call to a builtin function with at most two arguments. */ - op = VEC_index (vn_reference_op_s, operands, 0); + op = &VEC_index (vn_reference_op_s, operands, 0); if (op->opcode == CALL_EXPR && TREE_CODE (op->op0) == ADDR_EXPR && TREE_CODE (TREE_OPERAND (op->op0, 0)) == FUNCTION_DECL @@ -1124,9 +1124,9 @@ fully_constant_vn_reference_p (vn_reference_t ref) { vn_reference_op_t arg0, arg1 = NULL; bool anyconst = false; - arg0 = VEC_index (vn_reference_op_s, operands, 1); + arg0 = &VEC_index (vn_reference_op_s, operands, 1); if (VEC_length (vn_reference_op_s, operands) > 2) - arg1 = VEC_index (vn_reference_op_s, operands, 2); + arg1 = &VEC_index (vn_reference_op_s, operands, 2); if (TREE_CODE_CLASS (arg0->opcode) == tcc_constant || (arg0->opcode == ADDR_EXPR && is_gimple_min_invariant (arg0->op0))) @@ -1158,7 +1158,7 @@ fully_constant_vn_reference_p (vn_reference_t ref) && VEC_length (vn_reference_op_s, operands) == 2) { vn_reference_op_t arg0; - arg0 = VEC_index (vn_reference_op_s, operands, 1); + arg0 = &VEC_index (vn_reference_op_s, operands, 1); if (arg0->opcode == STRING_CST && (TYPE_MODE (op->type) == TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0->op0)))) @@ -1226,12 +1226,12 @@ valueize_refs_1 (VEC (vn_reference_op_s, heap) *orig, bool *valueized_anything) && vro->op0 && TREE_CODE (vro->op0) == ADDR_EXPR && VEC_index (vn_reference_op_s, - orig, i - 1)->opcode == MEM_REF) + orig, i - 1).opcode == MEM_REF) vn_reference_fold_indirect (&orig, &i); else if (i > 0 && vro->opcode == SSA_NAME && VEC_index (vn_reference_op_s, - orig, i - 1)->opcode == MEM_REF) + orig, i - 1).opcode == MEM_REF) vn_reference_maybe_forwprop_address (&orig, &i); /* If it transforms a non-constant ARRAY_REF into a constant one, adjust the constant offset. */ @@ -1624,9 +1624,9 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_) i = VEC_length (vn_reference_op_s, vr->operands) - 1; j = VEC_length (vn_reference_op_s, lhs_ops) - 1; while (j >= 0 && i >= 0 - && vn_reference_op_eq (VEC_index (vn_reference_op_s, - vr->operands, i), - VEC_index (vn_reference_op_s, lhs_ops, j))) + && vn_reference_op_eq (&VEC_index (vn_reference_op_s, + vr->operands, i), + &VEC_index (vn_reference_op_s, lhs_ops, j))) { i--; j--; @@ -1639,10 +1639,10 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_) don't care here - further lookups with the rewritten operands will simply fail if we messed up types too badly. */ if (j == 0 && i >= 0 - && VEC_index (vn_reference_op_s, lhs_ops, 0)->opcode == MEM_REF - && VEC_index (vn_reference_op_s, lhs_ops, 0)->off != -1 - && (VEC_index (vn_reference_op_s, lhs_ops, 0)->off - == VEC_index (vn_reference_op_s, vr->operands, i)->off)) + && VEC_index (vn_reference_op_s, lhs_ops, 0).opcode == MEM_REF + && VEC_index (vn_reference_op_s, lhs_ops, 0).off != -1 + && (VEC_index (vn_reference_op_s, lhs_ops, 0).off + == VEC_index (vn_reference_op_s, vr->operands, i).off)) i--, j--; /* i now points to the first additional op. @@ -1669,7 +1669,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_) VEC_truncate (vn_reference_op_s, vr->operands, i + 1 + VEC_length (vn_reference_op_s, rhs)); FOR_EACH_VEC_ELT (vn_reference_op_s, rhs, j, vro) - VEC_replace (vn_reference_op_s, vr->operands, i + 1 + j, vro); + VEC_replace (vn_reference_op_s, vr->operands, i + 1 + j, *vro); VEC_free (vn_reference_op_s, heap, rhs); vr->operands = valueize_refs (vr->operands); vr->hashcode = vn_reference_compute_hash (vr); @@ -1807,12 +1807,12 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_) op.opcode = MEM_REF; op.op0 = build_int_cst (ptr_type_node, at - rhs_offset); op.off = at - lhs_offset + rhs_offset; - VEC_replace (vn_reference_op_s, vr->operands, 0, &op); + VEC_replace (vn_reference_op_s, vr->operands, 0, op); op.type = TREE_TYPE (rhs); op.opcode = TREE_CODE (rhs); op.op0 = rhs; op.off = -1; - VEC_replace (vn_reference_op_s, vr->operands, 1, &op); + VEC_replace (vn_reference_op_s, vr->operands, 1, op); vr->hashcode = vn_reference_compute_hash (vr); /* Adjust *ref from the new operands. */ @@ -3746,7 +3746,7 @@ start_over: /* Restore the last use walker and continue walking there. */ use = name; name = VEC_pop (tree, namevec); - memcpy (&iter, VEC_last (ssa_op_iter, itervec), + memcpy (&iter, &VEC_last (ssa_op_iter, itervec), sizeof (ssa_op_iter)); VEC_pop (ssa_op_iter, itervec); goto continue_walking; diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index 5b185b6..c108f76 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -2927,7 +2927,7 @@ get_constraint_for_ptr_offset (tree ptr, tree offset, for (j = 0; j < n; j++) { varinfo_t curr; - c = *VEC_index (ce_s, *results, j); + c = VEC_index (ce_s, *results, j); curr = get_varinfo (c.var); if (c.type == ADDRESSOF @@ -2989,7 +2989,7 @@ get_constraint_for_ptr_offset (tree ptr, tree offset, else c.offset = rhsoffset; - VEC_replace (ce_s, *results, j, &c); + VEC_replace (ce_s, *results, j, c); } } @@ -3058,7 +3058,7 @@ get_constraint_for_component_ref (tree t, VEC(ce_s, heap) **results, adding the required subset of sub-fields below. */ get_constraint_for_1 (t, results, true, lhs_p); gcc_assert (VEC_length (ce_s, *results) == 1); - result = VEC_last (ce_s, *results); + result = &VEC_last (ce_s, *results); if (result->type == SCALAR && get_varinfo (result->var)->is_full_var) @@ -3284,13 +3284,13 @@ get_constraint_for_1 (tree t, VEC (ce_s, heap) **results, bool address_p, if (address_p) return; - cs = *VEC_last (ce_s, *results); + cs = VEC_last (ce_s, *results); if (cs.type == DEREF && type_can_have_subvars (TREE_TYPE (t))) { /* For dereferences this means we have to defer it to solving time. */ - VEC_last (ce_s, *results)->offset = UNKNOWN_OFFSET; + VEC_last (ce_s, *results).offset = UNKNOWN_OFFSET; return; } if (cs.type != SCALAR) @@ -3451,8 +3451,8 @@ do_structure_copy (tree lhsop, tree rhsop) get_constraint_for (lhsop, &lhsc); get_constraint_for_rhs (rhsop, &rhsc); - lhsp = VEC_index (ce_s, lhsc, 0); - rhsp = VEC_index (ce_s, rhsc, 0); + lhsp = &VEC_index (ce_s, lhsc, 0); + rhsp = &VEC_index (ce_s, rhsc, 0); if (lhsp->type == DEREF || (lhsp->type == ADDRESSOF && lhsp->var == anything_id) || rhsp->type == DEREF) @@ -3481,7 +3481,7 @@ do_structure_copy (tree lhsop, tree rhsop) for (j = 0; VEC_iterate (ce_s, lhsc, j, lhsp);) { varinfo_t lhsv, rhsv; - rhsp = VEC_index (ce_s, rhsc, k); + rhsp = &VEC_index (ce_s, rhsc, k); lhsv = get_varinfo (lhsp->var); rhsv = get_varinfo (rhsp->var); if (lhsv->may_have_pointers @@ -4377,7 +4377,7 @@ find_func_aliases_for_call (gimple t) lhs = get_function_part_constraint (fi, fi_parm_base + j); while (VEC_length (ce_s, rhsc) != 0) { - rhsp = VEC_last (ce_s, rhsc); + rhsp = &VEC_last (ce_s, rhsc); process_constraint (new_constraint (lhs, *rhsp)); VEC_pop (ce_s, rhsc); } @@ -4399,7 +4399,7 @@ find_func_aliases_for_call (gimple t) VEC(ce_s, heap) *tem = NULL; VEC_safe_push (ce_s, heap, tem, &rhs); do_deref (&tem); - rhs = *VEC_index (ce_s, tem, 0); + rhs = VEC_index (ce_s, tem, 0); VEC_free(ce_s, heap, tem); } FOR_EACH_VEC_ELT (ce_s, lhsc, j, lhsp) @@ -4471,7 +4471,7 @@ find_func_aliases (gimple origt) struct constraint_expr *c2; while (VEC_length (ce_s, rhsc) > 0) { - c2 = VEC_last (ce_s, rhsc); + c2 = &VEC_last (ce_s, rhsc); process_constraint (new_constraint (*c, *c2)); VEC_pop (ce_s, rhsc); } @@ -5158,7 +5158,7 @@ push_fields_onto_fieldstack (tree type, VEC(fieldoff_s,heap) **fieldstack, bool must_have_pointers_p; if (!VEC_empty (fieldoff_s, *fieldstack)) - pair = VEC_last (fieldoff_s, *fieldstack); + pair = &VEC_last (fieldoff_s, *fieldstack); /* If there isn't anything at offset zero, create sth. */ if (!pair diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c index e0b68c7..4e25159 100644 --- a/gcc/tree-vect-loop-manip.c +++ b/gcc/tree-vect-loop-manip.c @@ -188,7 +188,7 @@ adjust_vec_debug_stmts (void) while (!VEC_empty (adjust_info, adjust_vec)) { - adjust_debug_stmts_now (VEC_last (adjust_info, adjust_vec)); + adjust_debug_stmts_now (&VEC_last (adjust_info, adjust_vec)); VEC_pop (adjust_info, adjust_vec); } @@ -2550,4 +2550,3 @@ vect_loop_versioning (loop_vec_info loop_vinfo, GSI_SAME_STMT); } } - diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c index 782172f..a4c7483 100644 --- a/gcc/tree-vect-slp.c +++ b/gcc/tree-vect-slp.c @@ -1098,7 +1098,7 @@ vect_slp_rearrange_stmts (slp_tree node, unsigned int group_size, tmp_stmts = VEC_alloc (gimple, heap, group_size); for (i = 0; i < group_size; i++) - VEC_safe_push (gimple, heap, tmp_stmts, NULL); + VEC_safe_push (gimple, heap, tmp_stmts, (gimple)NULL); FOR_EACH_VEC_ELT (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt) { @@ -2653,7 +2653,7 @@ vect_create_mask_and_perm (gimple stmt, gimple next_scalar_stmt, stmts later. */ for (i = VEC_length (gimple, SLP_TREE_VEC_STMTS (node)); i < (int) SLP_TREE_NUMBER_OF_VEC_STMTS (node); i++) - VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (node), NULL); + VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (node), (gimple)NULL); perm_dest = vect_create_destination_var (gimple_assign_lhs (stmt), vectype); for (i = 0; i < ncopies; i++) diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index eb6402b..e3f46ec 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -8862,7 +8862,7 @@ vrp_fold_stmt (gimple_stmt_iterator *si) A NULL entry is used to mark the end of pairs which need to be restored. */ -static VEC(tree,heap) *stack; +static VEC(tree,heap) *equiv_stack; /* A trivial wrapper so that we can present the generic jump threading code with a simple API for simplifying statements. STMT is the @@ -8930,7 +8930,7 @@ identify_jump_threads (void) /* Allocate our unwinder stack to unwind any temporary equivalences that might be recorded. */ - stack = VEC_alloc (tree, heap, 20); + equiv_stack = VEC_alloc (tree, heap, 20); /* To avoid lots of silly node creation, we create a single conditional and just modify it in-place when attempting to @@ -8984,7 +8984,7 @@ identify_jump_threads (void) if (e->flags & (EDGE_DFS_BACK | EDGE_COMPLEX)) continue; - thread_across_edge (dummy, e, true, &stack, + thread_across_edge (dummy, e, true, &equiv_stack, simplify_stmt_for_jump_threading); } } @@ -9005,7 +9005,7 @@ static void finalize_jump_threads (void) { thread_through_all_blocks (false); - VEC_free (tree, heap, stack); + VEC_free (tree, heap, equiv_stack); } diff --git a/gcc/tree.c b/gcc/tree.c index 6e864c3..e0bd2b5 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -6704,8 +6704,8 @@ simple_cst_equal (const_tree t1, const_tree t2) for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx) /* ??? Should we handle also fields here? */ - if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value, - VEC_index (constructor_elt, v2, idx)->value)) + if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx).value, + VEC_index (constructor_elt, v2, idx).value)) return false; return true; } diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c index a79872f..818fb24 100644 --- a/gcc/var-tracking.c +++ b/gcc/var-tracking.c @@ -7821,7 +7821,7 @@ loc_exp_dep_clear (variable var) { while (!VEC_empty (loc_exp_dep, VAR_LOC_DEP_VEC (var))) { - loc_exp_dep *led = VEC_last (loc_exp_dep, VAR_LOC_DEP_VEC (var)); + loc_exp_dep *led = &VEC_last (loc_exp_dep, VAR_LOC_DEP_VEC (var)); if (led->next) led->next->pprev = led->pprev; if (led->pprev) @@ -7865,7 +7865,7 @@ loc_exp_insert_dep (variable var, rtx x, htab_t vars) else { VEC_quick_push (loc_exp_dep, VAR_LOC_DEP_VEC (var), NULL); - led = VEC_last (loc_exp_dep, VAR_LOC_DEP_VEC (var)); + led = &VEC_last (loc_exp_dep, VAR_LOC_DEP_VEC (var)); } led->dv = var->dv; led->value = x; diff --git a/gcc/varasm.c b/gcc/varasm.c index a1f0a23..b380a47 100644 --- a/gcc/varasm.c +++ b/gcc/varasm.c @@ -2871,8 +2871,8 @@ compare_constant (const tree t1, const tree t2) for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx) { - constructor_elt *c1 = VEC_index (constructor_elt, v1, idx); - constructor_elt *c2 = VEC_index (constructor_elt, v2, idx); + constructor_elt *c1 = &VEC_index (constructor_elt, v1, idx); + constructor_elt *c2 = &VEC_index (constructor_elt, v2, idx); /* Check that each value is the same... */ if (!compare_constant (c1->value, c2->value)) diff --git a/gcc/vec.c b/gcc/vec.c index 85274c4..51a55d9 100644 --- a/gcc/vec.c +++ b/gcc/vec.c @@ -1,7 +1,8 @@ /* Vector API for GNU compiler. - Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 + Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010, 2011, 2012 Free Software Foundation, Inc. Contributed by Nathan Sidwell <nathan@codesourcery.com> + Re-implemented in C++ by Diego Novillo <dnovillo@google.com> This file is part of GCC. @@ -213,7 +214,7 @@ calculate_allocation (const struct vec_prefix *pfx, int reserve, bool exact) trailing array is at VEC_OFFSET offset and consists of ELT_SIZE sized elements. */ -static void * +void * vec_gc_o_reserve_1 (void *vec, int reserve, size_t vec_offset, size_t elt_size, bool exact MEM_STAT_DECL) { @@ -246,61 +247,10 @@ vec_gc_o_reserve_1 (void *vec, int reserve, size_t vec_offset, size_t elt_size, return vec; } -/* Ensure there are at least RESERVE free slots in VEC, growing - exponentially. If RESERVE < 0 grow exactly, else grow - exponentially. As a special case, if VEC is NULL, and RESERVE is - 0, no vector will be created. */ - -void * -vec_gc_p_reserve (void *vec, int reserve MEM_STAT_DECL) -{ - return vec_gc_o_reserve_1 (vec, reserve, - sizeof (struct vec_prefix), - sizeof (void *), false - PASS_MEM_STAT); -} - -/* Ensure there are at least RESERVE free slots in VEC, growing - exactly. If RESERVE < 0 grow exactly, else grow exponentially. As - a special case, if VEC is NULL, and RESERVE is 0, no vector will be - created. */ - -void * -vec_gc_p_reserve_exact (void *vec, int reserve MEM_STAT_DECL) -{ - return vec_gc_o_reserve_1 (vec, reserve, - sizeof (struct vec_prefix), - sizeof (void *), true - PASS_MEM_STAT); -} - -/* As for vec_gc_p_reserve, but for object vectors. The vector's - trailing array is at VEC_OFFSET offset and consists of ELT_SIZE - sized elements. */ - -void * -vec_gc_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size - MEM_STAT_DECL) -{ - return vec_gc_o_reserve_1 (vec, reserve, vec_offset, elt_size, false - PASS_MEM_STAT); -} - -/* As for vec_gc_p_reserve_exact, but for object vectors. The - vector's trailing array is at VEC_OFFSET offset and consists of - ELT_SIZE sized elements. */ - -void * -vec_gc_o_reserve_exact (void *vec, int reserve, size_t vec_offset, - size_t elt_size MEM_STAT_DECL) -{ - return vec_gc_o_reserve_1 (vec, reserve, vec_offset, elt_size, true - PASS_MEM_STAT); -} /* As for vec_gc_o_reserve_1, but for heap allocated vectors. */ -static void * +void * vec_heap_o_reserve_1 (void *vec, int reserve, size_t vec_offset, size_t elt_size, bool exact MEM_STAT_DECL) { @@ -328,47 +278,6 @@ vec_heap_o_reserve_1 (void *vec, int reserve, size_t vec_offset, return vec; } -/* As for vec_gc_p_reserve, but for heap allocated vectors. */ - -void * -vec_heap_p_reserve (void *vec, int reserve MEM_STAT_DECL) -{ - return vec_heap_o_reserve_1 (vec, reserve, - sizeof (struct vec_prefix), - sizeof (void *), false - PASS_MEM_STAT); -} - -/* As for vec_gc_p_reserve_exact, but for heap allocated vectors. */ - -void * -vec_heap_p_reserve_exact (void *vec, int reserve MEM_STAT_DECL) -{ - return vec_heap_o_reserve_1 (vec, reserve, - sizeof (struct vec_prefix), - sizeof (void *), true - PASS_MEM_STAT); -} - -/* As for vec_gc_o_reserve, but for heap allocated vectors. */ - -void * -vec_heap_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size - MEM_STAT_DECL) -{ - return vec_heap_o_reserve_1 (vec, reserve, vec_offset, elt_size, false - PASS_MEM_STAT); -} - -/* As for vec_gc_o_reserve_exact, but for heap allocated vectors. */ - -void * -vec_heap_o_reserve_exact (void *vec, int reserve, size_t vec_offset, - size_t elt_size MEM_STAT_DECL) -{ - return vec_heap_o_reserve_1 (vec, reserve, vec_offset, elt_size, true - PASS_MEM_STAT); -} /* Stack vectors are a little different. VEC_alloc turns into a call to vec_stack_p_reserve_exact1 and passes in space allocated via a @@ -450,28 +359,6 @@ vec_stack_o_reserve_1 (void *vec, int reserve, size_t vec_offset, /* Grow a vector allocated on the stack. */ void * -vec_stack_p_reserve (void *vec, int reserve MEM_STAT_DECL) -{ - return vec_stack_o_reserve_1 (vec, reserve, - sizeof (struct vec_prefix), - sizeof (void *), false - PASS_MEM_STAT); -} - -/* Exact version of vec_stack_p_reserve. */ - -void * -vec_stack_p_reserve_exact (void *vec, int reserve MEM_STAT_DECL) -{ - return vec_stack_o_reserve_1 (vec, reserve, - sizeof (struct vec_prefix), - sizeof (void *), true - PASS_MEM_STAT); -} - -/* Like vec_stack_p_reserve, but for objects. */ - -void * vec_stack_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size MEM_STAT_DECL) { @@ -479,7 +366,7 @@ vec_stack_o_reserve (void *vec, int reserve, size_t vec_offset, PASS_MEM_STAT); } -/* Like vec_stack_p_reserve_exact, but for objects. */ +/* Exact version of vec_stack_o_reserve. */ void * vec_stack_o_reserve_exact (void *vec, int reserve, size_t vec_offset, diff --git a/gcc/vec.h b/gcc/vec.h index cb87112..5fdb859 100644 --- a/gcc/vec.h +++ b/gcc/vec.h @@ -1,7 +1,8 @@ /* Vector API for GNU compiler. - Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010 + Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. Contributed by Nathan Sidwell <nathan@codesourcery.com> + Re-implemented in C++ by Diego Novillo <dnovillo@google.com> This file is part of GCC. @@ -134,6 +135,153 @@ along with GCC; see the file COPYING3. If not see */ +#if ENABLE_CHECKING +#define VEC_CHECK_INFO ,__FILE__,__LINE__,__FUNCTION__ +#define VEC_CHECK_DECL ,const char *file_,unsigned line_,const char *function_ +#define VEC_CHECK_PASS ,file_,line_,function_ + +#define VEC_ASSERT(EXPR,OP,T,A) \ + (void)((EXPR) ? 0 : (VEC_ASSERT_FAIL(OP,VEC(T,A)), 0)) + +extern void vec_assert_fail (const char *, const char * VEC_CHECK_DECL) + ATTRIBUTE_NORETURN; +#define VEC_ASSERT_FAIL(OP,VEC) vec_assert_fail (OP,#VEC VEC_CHECK_PASS) +#else +#define VEC_CHECK_INFO +#define VEC_CHECK_DECL +#define VEC_CHECK_PASS +#define VEC_ASSERT(EXPR,OP,T,A) (void)(EXPR) +#endif + +#define VEC(T,A) vec_t<T> + +enum vec_allocation_t { heap, gc, stack }; + +struct vec_prefix +{ + unsigned num; + unsigned alloc; +}; + +/* Vector type, user visible. */ +template<typename T> +struct GTY(()) vec_t +{ + vec_prefix prefix; + T vec[1]; +}; + +/* Garbage collection support for vec_t. */ + +template<typename T> +void +gt_ggc_mx (vec_t<T> *v) +{ + extern void gt_ggc_mx (T&); + for (unsigned i = 0; i < v->prefix.num; i++) + gt_ggc_mx (v->vec[i]); +} + + +/* PCH support for vec_t. */ + +template<typename T> +void +gt_pch_nx (vec_t<T> *v) +{ + extern void gt_pch_nx (T&); + for (unsigned i = 0; i < v->prefix.num; i++) + gt_pch_nx (v->vec[i]); +} + +template<typename T> +void +gt_pch_nx (vec_t<T *> *v, gt_pointer_operator op, void *cookie) +{ + for (unsigned i = 0; i < v->prefix.num; i++) + op (&(v->vec[i]), cookie); +} + +template<typename T> +void +gt_pch_nx (vec_t<T> *v, gt_pointer_operator op, void *cookie) +{ + extern void gt_pch_nx (T *, gt_pointer_operator, void *); + for (unsigned i = 0; i < v->prefix.num; i++) + gt_pch_nx (&(v->vec[i]), op, cookie); +} + + +/* FIXME cxx-conversion. Remove these definitions and update all + calling sites. */ +/* Vector of integer-like object. */ +#define DEF_VEC_I(T) struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_I(T,A) struct vec_swallow_trailing_semi + +/* Vector of pointer to object. */ +#define DEF_VEC_P(T) struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_P(T,A) struct vec_swallow_trailing_semi + +/* Vector of object. */ +#define DEF_VEC_O(T) struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_O(T,A) struct vec_swallow_trailing_semi + +/* Vectors on the stack. */ +#define DEF_VEC_ALLOC_P_STACK(T) struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_O_STACK(T) struct vec_swallow_trailing_semi +#define DEF_VEC_ALLOC_I_STACK(T) struct vec_swallow_trailing_semi + +/* Vectors of atomic types. Atomic types do not need to have its + elements marked for GC and PCH. To avoid unnecessary traversals, + we provide template instantiations for the GC/PCH functions that + do not traverse the vector. + + FIXME cxx-conversion - Once vec_t users are converted this can + be provided in some other way (e.g., adding an additional template + parameter to the vec_t class). */ +#define DEF_VEC_A(TYPE) \ +template<typename T> \ +void \ +gt_ggc_mx (vec_t<TYPE> *v ATTRIBUTE_UNUSED) \ +{ \ +} \ + \ +template<typename T> \ +void \ +gt_pch_nx (vec_t<TYPE> *v ATTRIBUTE_UNUSED) \ +{ \ +} \ + \ +template<typename T> \ +void \ +gt_pch_nx (vec_t<TYPE> *v ATTRIBUTE_UNUSED, \ + gt_pointer_operator op ATTRIBUTE_UNUSED, \ + void *cookie ATTRIBUTE_UNUSED) \ +{ \ +} \ +struct vec_swallow_trailing_semi + +#define DEF_VEC_ALLOC_A(T,A) struct vec_swallow_trailing_semi + +/* Support functions for stack vectors. */ +extern void *vec_stack_p_reserve_exact_1 (int, void *); +extern void *vec_stack_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); +extern void *vec_stack_o_reserve_exact (void *, int, size_t, size_t + MEM_STAT_DECL); +extern void vec_stack_free (void *); + +/* Reallocate an array of elements with prefix. */ +template<typename T, enum vec_allocation_t A> +extern vec_t<T> *vec_reserve (vec_t<T> *, int MEM_STAT_DECL); + +template<typename T, enum vec_allocation_t A> +extern vec_t<T> *vec_reserve_exact (vec_t<T> *, int MEM_STAT_DECL); + +extern void dump_vec_loc_statistics (void); +extern void ggc_free (void *); +extern void vec_heap_free (void *); + + /* Macros to invoke API calls. A single macro works for both pointer and object vectors, but the argument and return types might well be different. In each macro, T is the typedef of the vector elements, @@ -148,7 +296,14 @@ along with GCC; see the file COPYING3. If not see Return the number of active elements in V. V can be NULL, in which case zero is returned. */ -#define VEC_length(T,V) (VEC_OP(T,base,length)(VEC_BASE(V))) +#define VEC_length(T,V) (VEC_length_1<T> (V)) + +template<typename T> +static inline unsigned +VEC_length_1 (const vec_t<T> *vec_) +{ + return vec_ ? vec_->prefix.num : 0; +} /* Check if vector is empty @@ -156,7 +311,30 @@ along with GCC; see the file COPYING3. If not see Return nonzero if V is an empty vector (or V is NULL), zero otherwise. */ -#define VEC_empty(T,V) (VEC_length (T,V) == 0) +#define VEC_empty(T,V) (VEC_empty_1<T> (V)) + +template<typename T> +static inline bool +VEC_empty_1 (const vec_t<T> *vec_) +{ + return VEC_length (T, vec_) == 0; +} + + +/* Get the address of the array of elements + T *VEC_T_address (VEC(T) v) + + If you need to directly manipulate the array (for instance, you + want to feed it to qsort), use this accessor. */ + +#define VEC_address(T,V) (VEC_address_1<T> (V)) + +template<typename T> +static inline T * +VEC_address_1 (vec_t<T> *vec_) +{ + return vec_ ? vec_->vec : 0; +} /* Get the final element of the vector. @@ -166,16 +344,42 @@ along with GCC; see the file COPYING3. If not see Return the final element. V must not be empty. */ -#define VEC_last(T,V) (VEC_OP(T,base,last)(VEC_BASE(V) VEC_CHECK_INFO)) +#define VEC_last(T,V) (VEC_last_1<T> (V VEC_CHECK_INFO)) + +template<typename T> +static inline T& +VEC_last_1 (vec_t<T> *vec_ VEC_CHECK_DECL) +{ + VEC_ASSERT (vec_ && vec_->prefix.num, "last", T, base); + return vec_->vec[vec_->prefix.num - 1]; +} + /* Index into vector T VEC_T_index(VEC(T) *v, unsigned ix); // Integer T VEC_T_index(VEC(T) *v, unsigned ix); // Pointer T *VEC_T_index(VEC(T) *v, unsigned ix); // Object - Return the IX'th element. If IX must be in the domain of V. */ + Return the IX'th element. IX must be in the domain of V. */ + +#define VEC_index(T,V,I) (VEC_index_1<T> (V, I VEC_CHECK_INFO)) + +template<typename T> +static inline T& +VEC_index_1 (vec_t<T> *vec_, unsigned ix_ VEC_CHECK_DECL) +{ + VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); + return vec_->vec[ix_]; +} + +template<typename T> +static inline const T& +VEC_index_1 (const vec_t<T> *vec_, unsigned ix_ VEC_CHECK_DECL) +{ + VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); + return vec_->vec[ix_]; +} -#define VEC_index(T,V,I) (VEC_OP(T,base,index)(VEC_BASE(V),I VEC_CHECK_INFO)) /* Iterate over vector int VEC_T_iterate(VEC(T) *v, unsigned ix, T &ptr); // Integer @@ -189,7 +393,39 @@ along with GCC; see the file COPYING3. If not see for (ix = 0; VEC_iterate(T,v,ix,ptr); ix++) continue; */ -#define VEC_iterate(T,V,I,P) (VEC_OP(T,base,iterate)(VEC_BASE(V),I,&(P))) +#define VEC_iterate(T,V,I,P) (VEC_iterate_1<T> (V, I, &(P))) + +template<typename T> +static inline bool +VEC_iterate_1 (const vec_t<T> *vec_, unsigned ix_, T *ptr) +{ + if (vec_ && ix_ < vec_->prefix.num) + { + *ptr = vec_->vec[ix_]; + return true; + } + else + { + *ptr = 0; + return false; + } +} + +template<typename T> +static inline bool +VEC_iterate_1 (vec_t<T> *vec_, unsigned ix_, T **ptr) +{ + if (vec_ && ix_ < vec_->prefix.num) + { + *ptr = &vec_->vec[ix_]; + return true; + } + else + { + *ptr = 0; + return false; + } +} /* Convenience macro for forward iteration. */ @@ -208,31 +444,99 @@ along with GCC; see the file COPYING3. If not see VEC_iterate (T, (V), (I), (P)); \ (I)--) + +/* Use these to determine the required size and initialization of a + vector embedded within another structure (as the final member). + + size_t VEC_T_embedded_size(int reserve); + void VEC_T_embedded_init(VEC(T) *v, int reserve); + + These allow the caller to perform the memory allocation. */ + +#define VEC_embedded_size(T,N) (VEC_embedded_size_1<T> (N)) + +template<typename T> +static inline size_t +VEC_embedded_size_1 (int alloc_) +{ + return offsetof (vec_t<T>, vec) + alloc_ * sizeof (T); +} + +#define VEC_embedded_init(T,O,N) (VEC_embedded_init_1<T> (O, N)) + +template<typename T> +static inline void +VEC_embedded_init_1 (vec_t<T> *vec_, int alloc_) +{ + vec_->prefix.num = 0; + vec_->prefix.alloc = alloc_; +} + + /* Allocate new vector. VEC(T,A) *VEC_T_A_alloc(int reserve); Allocate a new vector with space for RESERVE objects. If RESERVE - is zero, NO vector is created. */ + is zero, NO vector is created. + + We support a vector which starts out with space on the stack and + switches to heap space when forced to reallocate. This works a + little differently. In the case of stack vectors, VEC_alloc will + expand to a call to VEC_alloc_1 that calls XALLOCAVAR to request the + initial allocation. This uses alloca to get the initial space. + Since alloca can not be usefully called in an inline function, + VEC_alloc must always be a macro. + + Only the initial allocation will be made using alloca, so pass a + reasonable estimate that doesn't use too much stack space; don't + pass zero. Don't return a VEC(TYPE,stack) vector from the function + which allocated it. */ + +#define VEC_alloc(T,A,N) \ + ((A == stack) \ + ? VEC_alloc_1 (N, \ + XALLOCAVAR (vec_t<T>, \ + VEC_embedded_size_1<T> (N))) \ + : VEC_alloc_1<T, A> (N MEM_STAT_INFO)) + +template<typename T, enum vec_allocation_t A> +static inline vec_t<T> * +VEC_alloc_1 (int alloc_ MEM_STAT_DECL) +{ + return vec_reserve_exact<T, A> (NULL, alloc_ PASS_MEM_STAT); +} + +template<typename T> +static inline vec_t<T> * +VEC_alloc_1 (int alloc_, vec_t<T> *space) +{ + return (vec_t<T> *) vec_stack_p_reserve_exact_1 (alloc_, space); +} -#define VEC_alloc(T,A,N) (VEC_OP(T,A,alloc)(N MEM_STAT_INFO)) /* Free a vector. void VEC_T_A_free(VEC(T,A) *&); Free a vector and set it to NULL. */ -#define VEC_free(T,A,V) (VEC_OP(T,A,free)(&V)) +#define VEC_free(T,A,V) (VEC_free_1<T, A> (&V)) -/* Use these to determine the required size and initialization of a - vector embedded within another structure (as the final member). - - size_t VEC_T_embedded_size(int reserve); - void VEC_T_embedded_init(VEC(T) *v, int reserve); - - These allow the caller to perform the memory allocation. */ +template<typename T, enum vec_allocation_t A> +static inline void +VEC_free_1 (vec_t<T> **vec_) +{ + if (*vec_) + { + if (A == heap) + vec_heap_free (*vec_); + else if (A == gc) + ggc_free (*vec_); + else if (A == stack) + vec_stack_free (*vec_); + } + *vec_ = NULL; +} -#define VEC_embedded_size(T,N) (VEC_OP(T,base,embedded_size)(N)) -#define VEC_embedded_init(T,O,N) (VEC_OP(T,base,embedded_init)(VEC_BASE(O),N)) /* Copy a vector. VEC(T,A) *VEC_T_A_copy(VEC(T) *); @@ -240,7 +544,24 @@ along with GCC; see the file COPYING3. If not see Copy the live elements of a vector into a new vector. The new and old vectors need not be allocated by the same mechanism. */ -#define VEC_copy(T,A,V) (VEC_OP(T,A,copy)(VEC_BASE(V) MEM_STAT_INFO)) +#define VEC_copy(T,A,V) (VEC_copy_1<T, A> (V MEM_STAT_INFO)) + +template<typename T, enum vec_allocation_t A> +static inline vec_t<T> * +VEC_copy_1 (vec_t<T> *vec_ MEM_STAT_DECL) +{ + size_t len_ = vec_ ? vec_->prefix.num : 0; + vec_t<T> *new_vec_ = NULL; + + if (len_) + { + new_vec_ = vec_reserve_exact<T, A> (NULL, len_ PASS_MEM_STAT); + new_vec_->prefix.num = len_; + memcpy (new_vec_->vec, vec_->vec, sizeof (T) * len_); + } + return new_vec_; +} + /* Determine if a vector has additional capacity. @@ -252,8 +573,18 @@ along with GCC; see the file COPYING3. If not see nonzero in exactly the same circumstances that VEC_T_reserve will. */ -#define VEC_space(T,V,R) \ - (VEC_OP(T,base,space)(VEC_BASE(V),R VEC_CHECK_INFO)) +#define VEC_space(T,V,R) (VEC_space_1<T> (V, R VEC_CHECK_INFO)) + +template<typename T> +static inline int +VEC_space_1 (vec_t<T> *vec_, int alloc_ VEC_CHECK_DECL) +{ + VEC_ASSERT (alloc_ >= 0, "space", T, base); + return vec_ + ? vec_->prefix.alloc - vec_->prefix.num >= (unsigned)alloc_ + : !alloc_; +} + /* Reserve space. int VEC_T_A_reserve(VEC(T,A) *&v, int reserve); @@ -264,7 +595,20 @@ along with GCC; see the file COPYING3. If not see occurred. */ #define VEC_reserve(T,A,V,R) \ - (VEC_OP(T,A,reserve)(&(V),R VEC_CHECK_INFO MEM_STAT_INFO)) + (VEC_reserve_1<T, A> (&(V), (int)(R) VEC_CHECK_INFO MEM_STAT_INFO)) + +template<typename T, enum vec_allocation_t A> +static inline int +VEC_reserve_1 (vec_t<T> **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) +{ + int extend = !VEC_space_1 (*vec_, alloc_ VEC_CHECK_PASS); + + if (extend) + *vec_ = vec_reserve<T, A> (*vec_, alloc_ PASS_MEM_STAT); + + return extend; +} + /* Reserve space exactly. int VEC_T_A_reserve_exact(VEC(T,A) *&v, int reserve); @@ -275,7 +619,20 @@ along with GCC; see the file COPYING3. If not see occurred. */ #define VEC_reserve_exact(T,A,V,R) \ - (VEC_OP(T,A,reserve_exact)(&(V),R VEC_CHECK_INFO MEM_STAT_INFO)) + (VEC_reserve_exact_1<T, A> (&(V), R VEC_CHECK_INFO MEM_STAT_INFO)) + +template<typename T, enum vec_allocation_t A> +static inline int +VEC_reserve_exact_1 (vec_t<T> **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) +{ + int extend = !VEC_space_1 (*vec_, alloc_ VEC_CHECK_PASS); + + if (extend) + *vec_ = vec_reserve_exact<T, A> (*vec_, alloc_ PASS_MEM_STAT); + + return extend; +} + /* Copy elements with no reallocation void VEC_T_splice (VEC(T) *dst, VEC(T) *src); // Integer @@ -287,8 +644,23 @@ along with GCC; see the file COPYING3. If not see often will be. DST is assumed to have sufficient headroom available. */ -#define VEC_splice(T,DST,SRC) \ - (VEC_OP(T,base,splice)(VEC_BASE(DST), VEC_BASE(SRC) VEC_CHECK_INFO)) +#define VEC_splice(T,DST,SRC) (VEC_splice_1<T> (DST, SRC VEC_CHECK_INFO)) + +template<typename T> +static inline void +VEC_splice_1 (vec_t<T> *dst_, vec_t<T> *src_ VEC_CHECK_DECL) +{ + if (src_) + { + unsigned len_ = src_->prefix.num; + VEC_ASSERT (dst_->prefix.num + len_ <= dst_->prefix.alloc, "splice", + T, base); + + memcpy (&dst_->vec[dst_->prefix.num], &src_->vec[0], len_ * sizeof (T)); + dst_->prefix.num += len_; + } +} + /* Copy elements with reallocation void VEC_T_safe_splice (VEC(T,A) *&dst, VEC(T) *src); // Integer @@ -301,7 +673,21 @@ along with GCC; see the file COPYING3. If not see reallocated if needed. */ #define VEC_safe_splice(T,A,DST,SRC) \ - (VEC_OP(T,A,safe_splice)(&(DST), VEC_BASE(SRC) VEC_CHECK_INFO MEM_STAT_INFO)) + (VEC_safe_splice_1<T, A> (&(DST), SRC VEC_CHECK_INFO MEM_STAT_INFO)) + +template<typename T, enum vec_allocation_t A> +static inline void +VEC_safe_splice_1 (vec_t<T> **dst_, vec_t<T> *src_ VEC_CHECK_DECL MEM_STAT_DECL) +{ + if (src_) + { + VEC_reserve_exact_1<T, A> (dst_, src_->prefix.num + VEC_CHECK_PASS MEM_STAT_INFO); + + VEC_splice_1 (*dst_, src_ VEC_CHECK_PASS); + } +} + /* Push object with no reallocation T *VEC_T_quick_push (VEC(T) *v, T obj); // Integer @@ -313,8 +699,31 @@ along with GCC; see the file COPYING3. If not see case NO initialization is performed. There must be sufficient space in the vector. */ -#define VEC_quick_push(T,V,O) \ - (VEC_OP(T,base,quick_push)(VEC_BASE(V),O VEC_CHECK_INFO)) +#define VEC_quick_push(T,V,O) (VEC_quick_push_1<T> (V, O VEC_CHECK_INFO)) + +template<typename T> +static inline T & +VEC_quick_push_1 (vec_t<T> *vec_, T obj_ VEC_CHECK_DECL) +{ + VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "push", T, base); + vec_->vec[vec_->prefix.num] = obj_; + T &val_ = vec_->vec[vec_->prefix.num]; + vec_->prefix.num++; + return val_; +} + +template<typename T> +static inline T * +VEC_quick_push_1 (vec_t<T> *vec_, const T *ptr_ VEC_CHECK_DECL) +{ + T *slot_; + VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "push", T, base); + slot_ = &vec_->vec[vec_->prefix.num++]; + if (ptr_) + *slot_ = *ptr_; + return slot_; +} + /* Push object with reallocation T *VEC_T_A_safe_push (VEC(T,A) *&v, T obj); // Integer @@ -326,7 +735,24 @@ along with GCC; see the file COPYING3. If not see case NO initialization is performed. Reallocates V, if needed. */ #define VEC_safe_push(T,A,V,O) \ - (VEC_OP(T,A,safe_push)(&(V),O VEC_CHECK_INFO MEM_STAT_INFO)) + (VEC_safe_push_1<T, A> (&(V), O VEC_CHECK_INFO MEM_STAT_INFO)) + +template<typename T, enum vec_allocation_t A> +static inline T & +VEC_safe_push_1 (vec_t<T> **vec_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) +{ + VEC_reserve_1<T, A> (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); + return VEC_quick_push_1 (*vec_, obj_ VEC_CHECK_PASS); +} + +template<typename T, enum vec_allocation_t A> +static inline T * +VEC_safe_push_1 (vec_t<T> **vec_, const T *ptr_ VEC_CHECK_DECL MEM_STAT_DECL) +{ + VEC_reserve_1<T, A> (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); + return VEC_quick_push_1 (*vec_, ptr_ VEC_CHECK_PASS); +} + /* Pop element off end T VEC_T_pop (VEC(T) *v); // Integer @@ -336,7 +762,16 @@ along with GCC; see the file COPYING3. If not see Pop the last element off the end. Returns the element popped, for pointer vectors. */ -#define VEC_pop(T,V) (VEC_OP(T,base,pop)(VEC_BASE(V) VEC_CHECK_INFO)) +#define VEC_pop(T,V) (VEC_pop_1<T> (V VEC_CHECK_INFO)) + +template<typename T> +static inline T& +VEC_pop_1 (vec_t<T> *vec_ VEC_CHECK_DECL) +{ + VEC_ASSERT (vec_->prefix.num, "pop", T, base); + return vec_->vec[--vec_->prefix.num]; +} + /* Truncate to specific length void VEC_T_truncate (VEC(T) *v, unsigned len); @@ -344,8 +779,18 @@ along with GCC; see the file COPYING3. If not see Set the length as specified. The new length must be less than or equal to the current length. This is an O(1) operation. */ -#define VEC_truncate(T,V,I) \ - (VEC_OP(T,base,truncate)(VEC_BASE(V),I VEC_CHECK_INFO)) +#define VEC_truncate(T,V,I) \ + (VEC_truncate_1<T> (V, (unsigned)(I) VEC_CHECK_INFO)) + +template<typename T> +static inline void +VEC_truncate_1 (vec_t<T> *vec_, unsigned size_ VEC_CHECK_DECL) +{ + VEC_ASSERT (vec_ ? vec_->prefix.num >= size_ : !size_, "truncate", T, base); + if (vec_) + vec_->prefix.num = size_; +} + /* Grow to a specific length. void VEC_T_A_safe_grow (VEC(T,A) *&v, int len); @@ -355,7 +800,20 @@ along with GCC; see the file COPYING3. If not see uninitialized. */ #define VEC_safe_grow(T,A,V,I) \ - (VEC_OP(T,A,safe_grow)(&(V),I VEC_CHECK_INFO MEM_STAT_INFO)) + (VEC_safe_grow_1<T, A> (&(V), (int)(I) VEC_CHECK_INFO MEM_STAT_INFO)) + +template<typename T, enum vec_allocation_t A> +static inline void +VEC_safe_grow_1 (vec_t<T> **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) +{ + VEC_ASSERT (size_ >= 0 && VEC_length (T, *vec_) <= (unsigned)size_, + "grow", T, A); + VEC_reserve_exact_1<T, A> (vec_, + size_ - (int)(*vec_ ? (*vec_)->prefix.num : 0) + VEC_CHECK_PASS PASS_MEM_STAT); + (*vec_)->prefix.num = size_; +} + /* Grow to a specific length. void VEC_T_A_safe_grow_cleared (VEC(T,A) *&v, int len); @@ -364,8 +822,21 @@ along with GCC; see the file COPYING3. If not see long or longer than the current length. The new elements are initialized to zero. */ -#define VEC_safe_grow_cleared(T,A,V,I) \ - (VEC_OP(T,A,safe_grow_cleared)(&(V),I VEC_CHECK_INFO MEM_STAT_INFO)) +#define VEC_safe_grow_cleared(T,A,V,I) \ + (VEC_safe_grow_cleared_1<T,A> (&(V), (int)(I) \ + VEC_CHECK_INFO MEM_STAT_INFO)) + +template<typename T, enum vec_allocation_t A> +static inline void +VEC_safe_grow_cleared_1 (vec_t<T> **vec_, int size_ VEC_CHECK_DECL + MEM_STAT_DECL) +{ + int oldsize = VEC_length (T, *vec_); + VEC_safe_grow_1<T, A> (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); + memset (&(VEC_address (T, *vec_)[oldsize]), 0, + sizeof (T) * (size_ - oldsize)); +} + /* Replace element T VEC_T_replace (VEC(T) *v, unsigned ix, T val); // Integer @@ -379,20 +850,57 @@ along with GCC; see the file COPYING3. If not see performed. */ #define VEC_replace(T,V,I,O) \ - (VEC_OP(T,base,replace)(VEC_BASE(V),I,O VEC_CHECK_INFO)) + (VEC_replace_1<T> (V, (unsigned)(I), O VEC_CHECK_INFO)) + +template<typename T> +static inline T& +VEC_replace_1 (vec_t<T> *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) +{ + VEC_ASSERT (ix_ < vec_->prefix.num, "replace", T, base); + vec_->vec[ix_] = obj_; + return vec_->vec[ix_]; +} + /* Insert object with no reallocation - T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Integer - T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Pointer - T *VEC_T_quick_insert (VEC(T) *v, unsigned ix, T *val); // Object + void VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Integer + void VEC_T_quick_insert (VEC(T) *v, unsigned ix, T val); // Pointer + void VEC_T_quick_insert (VEC(T) *v, unsigned ix, T *val); // Object - Insert an element, VAL, at the IXth position of V. Return a pointer - to the slot created. For vectors of object, the new value can be - NULL, in which case no initialization of the inserted slot takes - place. There must be sufficient space. */ + Insert an element, VAL, at the IXth position of V. For vectors of + object, the new value can be NULL, in which case no initialization + of the inserted slot takes place. There must be sufficient space. */ #define VEC_quick_insert(T,V,I,O) \ - (VEC_OP(T,base,quick_insert)(VEC_BASE(V),I,O VEC_CHECK_INFO)) + (VEC_quick_insert_1<T> (V,I,O VEC_CHECK_INFO)) + +template<typename T> +static inline void +VEC_quick_insert_1 (vec_t<T> *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) +{ + T *slot_; + + VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "insert", T, base); + VEC_ASSERT (ix_ <= vec_->prefix.num, "insert", T, base); + slot_ = &vec_->vec[ix_]; + memmove (slot_ + 1, slot_, (vec_->prefix.num++ - ix_) * sizeof (T)); + *slot_ = obj_; +} + +template<typename T> +static inline void +VEC_quick_insert_1 (vec_t<T> *vec_, unsigned ix_, const T *ptr_ VEC_CHECK_DECL) +{ + T *slot_; + + VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "insert", T, base); + VEC_ASSERT (ix_ <= vec_->prefix.num, "insert", T, base); + slot_ = &vec_->vec[ix_]; + memmove (slot_ + 1, slot_, (vec_->prefix.num++ - ix_) * sizeof (T)); + if (ptr_) + *slot_ = *ptr_; +} + /* Insert object with reallocation T *VEC_T_A_safe_insert (VEC(T,A) *&v, unsigned ix, T val); // Integer @@ -405,31 +913,70 @@ along with GCC; see the file COPYING3. If not see place. Reallocate V, if necessary. */ #define VEC_safe_insert(T,A,V,I,O) \ - (VEC_OP(T,A,safe_insert)(&(V),I,O VEC_CHECK_INFO MEM_STAT_INFO)) + (VEC_safe_insert_1<T, A> (&(V),I,O VEC_CHECK_INFO MEM_STAT_INFO)) + +template<typename T, enum vec_allocation_t A> +static inline void +VEC_safe_insert_1 (vec_t<T> **vec_, unsigned ix_, T obj_ + VEC_CHECK_DECL MEM_STAT_DECL) +{ + VEC_reserve_1<T, A> (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); + VEC_quick_insert_1 (*vec_, ix_, obj_ VEC_CHECK_PASS); +} + +template<typename T, enum vec_allocation_t A> +static inline void +VEC_safe_insert_1 (vec_t<T> **vec_, unsigned ix_, T *ptr_ + VEC_CHECK_DECL MEM_STAT_DECL) +{ + VEC_reserve_1<T, A> (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); + VEC_quick_insert_1 (*vec_, ix_, ptr_ VEC_CHECK_PASS); +} + + /* Remove element retaining order - T VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Integer - T VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Pointer + void VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Integer + void VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Pointer void VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Object Remove an element from the IXth position of V. Ordering of - remaining elements is preserved. For pointer vectors returns the - removed object. This is an O(N) operation due to a memmove. */ + remaining elements is preserved. This is an O(N) operation due to + a memmove. */ #define VEC_ordered_remove(T,V,I) \ - (VEC_OP(T,base,ordered_remove)(VEC_BASE(V),I VEC_CHECK_INFO)) + (VEC_ordered_remove_1<T> (V,I VEC_CHECK_INFO)) + +template<typename T> +static inline void +VEC_ordered_remove_1 (vec_t<T> *vec_, unsigned ix_ VEC_CHECK_DECL) +{ + T *slot_; + VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); + slot_ = &vec_->vec[ix_]; + memmove (slot_, slot_ + 1, (--vec_->prefix.num - ix_) * sizeof (T)); +} + /* Remove element destroying order - T VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Integer - T VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Pointer + void VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Integer + void VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Pointer void VEC_T_unordered_remove (VEC(T) *v, unsigned ix); // Object - Remove an element from the IXth position of V. Ordering of - remaining elements is destroyed. For pointer vectors returns the - removed object. This is an O(1) operation. */ + Remove an element from the IXth position of V. Ordering of + remaining elements is destroyed. This is an O(1) operation. */ #define VEC_unordered_remove(T,V,I) \ - (VEC_OP(T,base,unordered_remove)(VEC_BASE(V),I VEC_CHECK_INFO)) + (VEC_unordered_remove_1<T> (V,I VEC_CHECK_INFO)) + +template<typename T> +static inline void +VEC_unordered_remove_1 (vec_t<T> *vec_, unsigned ix_ VEC_CHECK_DECL) +{ + VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); + vec_->vec[ix_] = vec_->vec[--vec_->prefix.num]; +} + /* Remove a block of elements void VEC_T_block_remove (VEC(T) *v, unsigned ix, unsigned len); @@ -438,22 +985,27 @@ along with GCC; see the file COPYING3. If not see This is an O(N) operation due to memmove. */ #define VEC_block_remove(T,V,I,L) \ - (VEC_OP(T,base,block_remove)(VEC_BASE(V),I,L VEC_CHECK_INFO)) + (VEC_block_remove_1<T> (V, I, L VEC_CHECK_INFO)) -/* Get the address of the array of elements - T *VEC_T_address (VEC(T) v) - - If you need to directly manipulate the array (for instance, you - want to feed it to qsort), use this accessor. */ +template<typename T> +static inline void +VEC_block_remove_1 (vec_t<T> *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) +{ + T *slot_; + VEC_ASSERT (ix_ + len_ <= vec_->prefix.num, "block_remove", T, base); + slot_ = &vec_->vec[ix_]; + vec_->prefix.num -= len_; + memmove (slot_, slot_ + len_, (vec_->prefix.num - ix_) * sizeof (T)); +} -#define VEC_address(T,V) (VEC_OP(T,base,address)(VEC_BASE(V))) /* Conveniently sort the contents of the vector with qsort. void VEC_qsort (VEC(T) *v, int (*cmp_func)(const void *, const void *)) */ -#define VEC_qsort(T,V,CMP) qsort(VEC_address (T,V), VEC_length(T,V), \ +#define VEC_qsort(T,V,CMP) qsort(VEC_address (T, V), VEC_length (T, V), \ sizeof (T), CMP) + /* Find the first index in the vector not less than the object. unsigned VEC_T_lower_bound (VEC(T) *v, const T val, bool (*lessthan) (const T, const T)); // Integer @@ -466,955 +1018,140 @@ along with GCC; see the file COPYING3. If not see changing the ordering of V. LESSTHAN is a function that returns true if the first argument is strictly less than the second. */ -#define VEC_lower_bound(T,V,O,LT) \ - (VEC_OP(T,base,lower_bound)(VEC_BASE(V),O,LT VEC_CHECK_INFO)) +#define VEC_lower_bound(T,V,O,LT) \ + (VEC_lower_bound_1<T> (V, O, LT VEC_CHECK_INFO)) -/* Reallocate an array of elements with prefix. */ -extern void *vec_gc_p_reserve (void *, int MEM_STAT_DECL); -extern void *vec_gc_p_reserve_exact (void *, int MEM_STAT_DECL); -extern void *vec_gc_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); -extern void *vec_gc_o_reserve_exact (void *, int, size_t, size_t - MEM_STAT_DECL); -extern void ggc_free (void *); -#define vec_gc_free(V) ggc_free (V) -extern void *vec_heap_p_reserve (void *, int MEM_STAT_DECL); -extern void *vec_heap_p_reserve_exact (void *, int MEM_STAT_DECL); -extern void *vec_heap_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); -extern void *vec_heap_o_reserve_exact (void *, int, size_t, size_t - MEM_STAT_DECL); -extern void dump_vec_loc_statistics (void); -extern void vec_heap_free (void *); - -#if ENABLE_CHECKING -#define VEC_CHECK_INFO ,__FILE__,__LINE__,__FUNCTION__ -#define VEC_CHECK_DECL ,const char *file_,unsigned line_,const char *function_ -#define VEC_CHECK_PASS ,file_,line_,function_ - -#define VEC_ASSERT(EXPR,OP,T,A) \ - (void)((EXPR) ? 0 : (VEC_ASSERT_FAIL(OP,VEC(T,A)), 0)) - -extern void vec_assert_fail (const char *, const char * VEC_CHECK_DECL) - ATTRIBUTE_NORETURN; -#define VEC_ASSERT_FAIL(OP,VEC) vec_assert_fail (OP,#VEC VEC_CHECK_PASS) -#else -#define VEC_CHECK_INFO -#define VEC_CHECK_DECL -#define VEC_CHECK_PASS -#define VEC_ASSERT(EXPR,OP,T,A) (void)(EXPR) -#endif - -/* Note: gengtype has hardwired knowledge of the expansions of the - VEC, DEF_VEC_*, and DEF_VEC_ALLOC_* macros. If you change the - expansions of these macros you may need to change gengtype too. */ - -typedef struct GTY(()) vec_prefix +template<typename T> +static inline unsigned +VEC_lower_bound_1 (vec_t<T> *vec_, T obj_, + bool (*lessthan_)(T, T) VEC_CHECK_DECL) { - unsigned num; - unsigned alloc; -} vec_prefix; - -#define VEC(T,A) VEC_##T##_##A -#define VEC_OP(T,A,OP) VEC_##T##_##A##_##OP - -/* Base of vector type, not user visible. */ -#define VEC_T(T,B) \ -typedef struct VEC(T,B) \ -{ \ - struct vec_prefix prefix; \ - T vec[1]; \ -} VEC(T,B) - -#define VEC_T_GTY(T,B) \ -typedef struct GTY(()) VEC(T,B) \ -{ \ - struct vec_prefix prefix; \ - T GTY ((length ("%h.prefix.num"))) vec[1]; \ -} VEC(T,B) - -#define VEC_T_GTY_ATOMIC(T,B) \ -typedef struct GTY(()) VEC(T,B) \ -{ \ - struct vec_prefix prefix; \ - T GTY ((atomic)) vec[1]; \ -} VEC(T,B) - -/* Derived vector type, user visible. */ -#define VEC_TA_GTY(T,B,A,GTY) \ -typedef struct GTY VEC(T,A) \ -{ \ - VEC(T,B) base; \ -} VEC(T,A) - -#define VEC_TA(T,B,A) \ -typedef struct VEC(T,A) \ -{ \ - VEC(T,B) base; \ -} VEC(T,A) - -/* Convert to base type. */ -#if GCC_VERSION >= 4000 -#define VEC_BASE(P) \ - ((offsetof (__typeof (*P), base) == 0 || (P)) ? &(P)->base : 0) -#else -#define VEC_BASE(P) ((P) ? &(P)->base : 0) -#endif - -/* Vector of integer-like object. */ -#define DEF_VEC_I(T) \ -static inline void VEC_OP (T,must_be,integral_type) (void) \ -{ \ - (void)~(T)0; \ -} \ - \ -VEC_T(T,base); \ -VEC_TA(T,base,none); \ -DEF_VEC_FUNC_P(T) \ -struct vec_swallow_trailing_semi -#define DEF_VEC_ALLOC_I(T,A) \ -VEC_TA(T,base,A); \ -DEF_VEC_ALLOC_FUNC_I(T,A) \ -DEF_VEC_NONALLOC_FUNCS_I(T,A) \ -struct vec_swallow_trailing_semi - -/* Vector of pointer to object. */ -#define DEF_VEC_P(T) \ -static inline void VEC_OP (T,must_be,pointer_type) (void) \ -{ \ - (void)((T)1 == (void *)1); \ -} \ - \ -VEC_T_GTY(T,base); \ -VEC_TA(T,base,none); \ -DEF_VEC_FUNC_P(T) \ -struct vec_swallow_trailing_semi -#define DEF_VEC_ALLOC_P(T,A) \ -VEC_TA(T,base,A); \ -DEF_VEC_ALLOC_FUNC_P(T,A) \ -DEF_VEC_NONALLOC_FUNCS_P(T,A) \ -struct vec_swallow_trailing_semi - -#define DEF_VEC_FUNC_P(T) \ -static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \ -{ \ - return vec_ ? vec_->prefix.num : 0; \ -} \ - \ -static inline T VEC_OP (T,base,last) \ - (const VEC(T,base) *vec_ VEC_CHECK_DECL) \ -{ \ - VEC_ASSERT (vec_ && vec_->prefix.num, "last", T, base); \ - \ - return vec_->vec[vec_->prefix.num - 1]; \ -} \ - \ -static inline T VEC_OP (T,base,index) \ - (const VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ -{ \ - VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); \ - \ - return vec_->vec[ix_]; \ -} \ - \ -static inline int VEC_OP (T,base,iterate) \ - (const VEC(T,base) *vec_, unsigned ix_, T *ptr) \ -{ \ - if (vec_ && ix_ < vec_->prefix.num) \ - { \ - *ptr = vec_->vec[ix_]; \ - return 1; \ - } \ - else \ - { \ - *ptr = (T) 0; \ - return 0; \ - } \ -} \ - \ -static inline size_t VEC_OP (T,base,embedded_size) \ - (int alloc_) \ -{ \ - return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T); \ -} \ - \ -static inline void VEC_OP (T,base,embedded_init) \ - (VEC(T,base) *vec_, int alloc_) \ -{ \ - vec_->prefix.num = 0; \ - vec_->prefix.alloc = alloc_; \ -} \ - \ -static inline int VEC_OP (T,base,space) \ - (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \ -{ \ - VEC_ASSERT (alloc_ >= 0, "space", T, base); \ - return vec_ ? vec_->prefix.alloc - vec_->prefix.num >= (unsigned)alloc_ : !alloc_; \ -} \ - \ -static inline void VEC_OP(T,base,splice) \ - (VEC(T,base) *dst_, VEC(T,base) *src_ VEC_CHECK_DECL) \ -{ \ - if (src_) \ - { \ - unsigned len_ = src_->prefix.num; \ - VEC_ASSERT (dst_->prefix.num + len_ <= dst_->prefix.alloc, "splice", T, base); \ - \ - memcpy (&dst_->vec[dst_->prefix.num], &src_->vec[0], len_ * sizeof (T)); \ - dst_->prefix.num += len_; \ - } \ -} \ - \ -static inline T *VEC_OP (T,base,quick_push) \ - (VEC(T,base) *vec_, T obj_ VEC_CHECK_DECL) \ -{ \ - T *slot_; \ - \ - VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "push", T, base); \ - slot_ = &vec_->vec[vec_->prefix.num++]; \ - *slot_ = obj_; \ - \ - return slot_; \ -} \ - \ -static inline T VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \ -{ \ - T obj_; \ - \ - VEC_ASSERT (vec_->prefix.num, "pop", T, base); \ - obj_ = vec_->vec[--vec_->prefix.num]; \ - \ - return obj_; \ -} \ - \ -static inline void VEC_OP (T,base,truncate) \ - (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \ -{ \ - VEC_ASSERT (vec_ ? vec_->prefix.num >= size_ : !size_, "truncate", T, base); \ - if (vec_) \ - vec_->prefix.num = size_; \ -} \ - \ -static inline T VEC_OP (T,base,replace) \ - (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) \ -{ \ - T old_obj_; \ - \ - VEC_ASSERT (ix_ < vec_->prefix.num, "replace", T, base); \ - old_obj_ = vec_->vec[ix_]; \ - vec_->vec[ix_] = obj_; \ - \ - return old_obj_; \ -} \ - \ -static inline T *VEC_OP (T,base,quick_insert) \ - (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL) \ -{ \ - T *slot_; \ - \ - VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "insert", T, base); \ - VEC_ASSERT (ix_ <= vec_->prefix.num, "insert", T, base); \ - slot_ = &vec_->vec[ix_]; \ - memmove (slot_ + 1, slot_, (vec_->prefix.num++ - ix_) * sizeof (T)); \ - *slot_ = obj_; \ - \ - return slot_; \ -} \ - \ -static inline T VEC_OP (T,base,ordered_remove) \ - (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ -{ \ - T *slot_; \ - T obj_; \ - \ - VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \ - slot_ = &vec_->vec[ix_]; \ - obj_ = *slot_; \ - memmove (slot_, slot_ + 1, (--vec_->prefix.num - ix_) * sizeof (T)); \ - \ - return obj_; \ -} \ - \ -static inline T VEC_OP (T,base,unordered_remove) \ - (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ -{ \ - T *slot_; \ - T obj_; \ - \ - VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \ - slot_ = &vec_->vec[ix_]; \ - obj_ = *slot_; \ - *slot_ = vec_->vec[--vec_->prefix.num]; \ - \ - return obj_; \ -} \ - \ -static inline void VEC_OP (T,base,block_remove) \ - (VEC(T,base) *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) \ -{ \ - T *slot_; \ - \ - VEC_ASSERT (ix_ + len_ <= vec_->prefix.num, "block_remove", T, base); \ - slot_ = &vec_->vec[ix_]; \ - vec_->prefix.num -= len_; \ - memmove (slot_, slot_ + len_, (vec_->prefix.num - ix_) * sizeof (T)); \ -} \ - \ -static inline T *VEC_OP (T,base,address) \ - (VEC(T,base) *vec_) \ -{ \ - return vec_ ? vec_->vec : 0; \ -} \ - \ -static inline unsigned VEC_OP (T,base,lower_bound) \ - (VEC(T,base) *vec_, const T obj_, \ - bool (*lessthan_)(const T, const T) VEC_CHECK_DECL) \ -{ \ - unsigned int len_ = VEC_OP (T,base, length) (vec_); \ - unsigned int half_, middle_; \ - unsigned int first_ = 0; \ - while (len_ > 0) \ - { \ - T middle_elem_; \ - half_ = len_ >> 1; \ - middle_ = first_; \ - middle_ += half_; \ - middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \ - if (lessthan_ (middle_elem_, obj_)) \ - { \ - first_ = middle_; \ - ++first_; \ - len_ = len_ - half_ - 1; \ - } \ - else \ - len_ = half_; \ - } \ - return first_; \ + unsigned int len_ = VEC_length (T, vec_); + unsigned int half_, middle_; + unsigned int first_ = 0; + while (len_ > 0) + { + T middle_elem_; + half_ = len_ >> 1; + middle_ = first_; + middle_ += half_; + middle_elem_ = VEC_index_1 (vec_, middle_ VEC_CHECK_PASS); + if (lessthan_ (middle_elem_, obj_)) + { + first_ = middle_; + ++first_; + len_ = len_ - half_ - 1; + } + else + len_ = half_; + } + return first_; } -#define DEF_VEC_ALLOC_FUNC_P(T,A) \ -static inline VEC(T,A) *VEC_OP (T,A,alloc) \ - (int alloc_ MEM_STAT_DECL) \ -{ \ - return (VEC(T,A) *) vec_##A##_p_reserve_exact (NULL, alloc_ \ - PASS_MEM_STAT); \ -} - - -#define DEF_VEC_NONALLOC_FUNCS_P(T,A) \ -static inline void VEC_OP (T,A,free) \ - (VEC(T,A) **vec_) \ -{ \ - if (*vec_) \ - vec_##A##_free (*vec_); \ - *vec_ = NULL; \ -} \ - \ -static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \ -{ \ - size_t len_ = vec_ ? vec_->prefix.num : 0; \ - VEC (T,A) *new_vec_ = NULL; \ - \ - if (len_) \ - { \ - new_vec_ = (VEC (T,A) *)(vec_##A##_p_reserve_exact \ - (NULL, len_ PASS_MEM_STAT)); \ - \ - new_vec_->base.prefix.num = len_; \ - memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \ - } \ - return new_vec_; \ -} \ - \ -static inline int VEC_OP (T,A,reserve) \ - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ - VEC_CHECK_PASS); \ - \ - if (extend) \ - *vec_ = (VEC(T,A) *) vec_##A##_p_reserve (*vec_, alloc_ PASS_MEM_STAT); \ - \ - return extend; \ -} \ - \ -static inline int VEC_OP (T,A,reserve_exact) \ - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ - VEC_CHECK_PASS); \ - \ - if (extend) \ - *vec_ = (VEC(T,A) *) vec_##A##_p_reserve_exact (*vec_, alloc_ \ - PASS_MEM_STAT); \ - \ - return extend; \ -} \ - \ -static inline void VEC_OP (T,A,safe_grow) \ - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - VEC_ASSERT (size_ >= 0 \ - && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \ - "grow", T, A); \ - VEC_OP (T,A,reserve_exact) (vec_, \ - size_ - (int)(*vec_ ? VEC_BASE(*vec_)->prefix.num : 0) \ - VEC_CHECK_PASS PASS_MEM_STAT); \ - VEC_BASE (*vec_)->prefix.num = size_; \ -} \ - \ -static inline void VEC_OP (T,A,safe_grow_cleared) \ - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \ - VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \ - memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \ - sizeof (T) * (size_ - oldsize)); \ -} \ - \ -static inline void VEC_OP(T,A,safe_splice) \ - (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - if (src_) \ - { \ - VEC_OP (T,A,reserve_exact) (dst_, src_->prefix.num \ - VEC_CHECK_PASS MEM_STAT_INFO); \ - \ - VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \ - VEC_CHECK_PASS); \ - } \ -} \ - \ -static inline T *VEC_OP (T,A,safe_push) \ - (VEC(T,A) **vec_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ - \ - return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \ -} \ - \ -static inline T *VEC_OP (T,A,safe_insert) \ - (VEC(T,A) **vec_, unsigned ix_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ - \ - return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ - VEC_CHECK_PASS); \ -} - -/* Vector of object. */ -#define DEF_VEC_O(T) \ -VEC_T_GTY(T,base); \ -VEC_TA(T,base,none); \ -DEF_VEC_FUNC_O(T) \ -struct vec_swallow_trailing_semi -#define DEF_VEC_ALLOC_O(T,A) \ -VEC_TA(T,base,A); \ -DEF_VEC_ALLOC_FUNC_O(T,A) \ -DEF_VEC_NONALLOC_FUNCS_O(T,A) \ -struct vec_swallow_trailing_semi - -/* Vector of atomic object. */ -#define DEF_VEC_A(T) \ -VEC_T_GTY_ATOMIC(T,base); \ -VEC_TA(T,base,none); \ -DEF_VEC_FUNC_O(T) \ -struct vec_swallow_trailing_semi -#define DEF_VEC_ALLOC_A(T,A) DEF_VEC_ALLOC_O(T,A) - -#define DEF_VEC_FUNC_O(T) \ -static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \ -{ \ - return vec_ ? vec_->prefix.num : 0; \ -} \ - \ -static inline T *VEC_OP (T,base,last) (VEC(T,base) *vec_ VEC_CHECK_DECL) \ -{ \ - VEC_ASSERT (vec_ && vec_->prefix.num, "last", T, base); \ - \ - return &vec_->vec[vec_->prefix.num - 1]; \ -} \ - \ -static inline T *VEC_OP (T,base,index) \ - (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ -{ \ - VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); \ - \ - return &vec_->vec[ix_]; \ -} \ - \ -static inline int VEC_OP (T,base,iterate) \ - (VEC(T,base) *vec_, unsigned ix_, T **ptr) \ -{ \ - if (vec_ && ix_ < vec_->prefix.num) \ - { \ - *ptr = &vec_->vec[ix_]; \ - return 1; \ - } \ - else \ - { \ - *ptr = 0; \ - return 0; \ - } \ -} \ - \ -static inline size_t VEC_OP (T,base,embedded_size) \ - (int alloc_) \ -{ \ - return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T); \ -} \ - \ -static inline void VEC_OP (T,base,embedded_init) \ - (VEC(T,base) *vec_, int alloc_) \ -{ \ - vec_->prefix.num = 0; \ - vec_->prefix.alloc = alloc_; \ -} \ - \ -static inline int VEC_OP (T,base,space) \ - (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \ -{ \ - VEC_ASSERT (alloc_ >= 0, "space", T, base); \ - return vec_ ? vec_->prefix.alloc - vec_->prefix.num >= (unsigned)alloc_ : !alloc_; \ -} \ - \ -static inline void VEC_OP(T,base,splice) \ - (VEC(T,base) *dst_, VEC(T,base) *src_ VEC_CHECK_DECL) \ -{ \ - if (src_) \ - { \ - unsigned len_ = src_->prefix.num; \ - VEC_ASSERT (dst_->prefix.num + len_ <= dst_->prefix.alloc, "splice", T, base); \ - \ - memcpy (&dst_->vec[dst_->prefix.num], &src_->vec[0], len_ * sizeof (T)); \ - dst_->prefix.num += len_; \ - } \ -} \ - \ -static inline T *VEC_OP (T,base,quick_push) \ - (VEC(T,base) *vec_, const T *obj_ VEC_CHECK_DECL) \ -{ \ - T *slot_; \ - \ - VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "push", T, base); \ - slot_ = &vec_->vec[vec_->prefix.num++]; \ - if (obj_) \ - *slot_ = *obj_; \ - \ - return slot_; \ -} \ - \ -static inline void VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \ -{ \ - VEC_ASSERT (vec_->prefix.num, "pop", T, base); \ - --vec_->prefix.num; \ -} \ - \ -static inline void VEC_OP (T,base,truncate) \ - (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \ -{ \ - VEC_ASSERT (vec_ ? vec_->prefix.num >= size_ : !size_, "truncate", T, base); \ - if (vec_) \ - vec_->prefix.num = size_; \ -} \ - \ -static inline T *VEC_OP (T,base,replace) \ - (VEC(T,base) *vec_, unsigned ix_, const T *obj_ VEC_CHECK_DECL) \ -{ \ - T *slot_; \ - \ - VEC_ASSERT (ix_ < vec_->prefix.num, "replace", T, base); \ - slot_ = &vec_->vec[ix_]; \ - if (obj_) \ - *slot_ = *obj_; \ - \ - return slot_; \ -} \ - \ -static inline T *VEC_OP (T,base,quick_insert) \ - (VEC(T,base) *vec_, unsigned ix_, const T *obj_ VEC_CHECK_DECL) \ -{ \ - T *slot_; \ - \ - VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "insert", T, base); \ - VEC_ASSERT (ix_ <= vec_->prefix.num, "insert", T, base); \ - slot_ = &vec_->vec[ix_]; \ - memmove (slot_ + 1, slot_, (vec_->prefix.num++ - ix_) * sizeof (T)); \ - if (obj_) \ - *slot_ = *obj_; \ - \ - return slot_; \ -} \ - \ -static inline void VEC_OP (T,base,ordered_remove) \ - (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ -{ \ - T *slot_; \ - \ - VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \ - slot_ = &vec_->vec[ix_]; \ - memmove (slot_, slot_ + 1, (--vec_->prefix.num - ix_) * sizeof (T)); \ -} \ - \ -static inline void VEC_OP (T,base,unordered_remove) \ - (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \ -{ \ - VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \ - vec_->vec[ix_] = vec_->vec[--vec_->prefix.num]; \ -} \ - \ -static inline void VEC_OP (T,base,block_remove) \ - (VEC(T,base) *vec_, unsigned ix_, unsigned len_ VEC_CHECK_DECL) \ -{ \ - T *slot_; \ - \ - VEC_ASSERT (ix_ + len_ <= vec_->prefix.num, "block_remove", T, base); \ - slot_ = &vec_->vec[ix_]; \ - vec_->prefix.num -= len_; \ - memmove (slot_, slot_ + len_, (vec_->prefix.num - ix_) * sizeof (T)); \ -} \ - \ -static inline T *VEC_OP (T,base,address) \ - (VEC(T,base) *vec_) \ -{ \ - return vec_ ? vec_->vec : 0; \ -} \ - \ -static inline unsigned VEC_OP (T,base,lower_bound) \ - (VEC(T,base) *vec_, const T *obj_, \ - bool (*lessthan_)(const T *, const T *) VEC_CHECK_DECL) \ -{ \ - unsigned int len_ = VEC_OP (T, base, length) (vec_); \ - unsigned int half_, middle_; \ - unsigned int first_ = 0; \ - while (len_ > 0) \ - { \ - T *middle_elem_; \ - half_ = len_ >> 1; \ - middle_ = first_; \ - middle_ += half_; \ - middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \ - if (lessthan_ (middle_elem_, obj_)) \ - { \ - first_ = middle_; \ - ++first_; \ - len_ = len_ - half_ - 1; \ - } \ - else \ - len_ = half_; \ - } \ - return first_; \ -} - -#define DEF_VEC_ALLOC_FUNC_O(T,A) \ -static inline VEC(T,A) *VEC_OP (T,A,alloc) \ - (int alloc_ MEM_STAT_DECL) \ -{ \ - return (VEC(T,A) *) vec_##A##_o_reserve_exact (NULL, alloc_, \ - offsetof (VEC(T,A),base.vec), \ - sizeof (T) \ - PASS_MEM_STAT); \ -} - -#define DEF_VEC_NONALLOC_FUNCS_O(T,A) \ -static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \ -{ \ - size_t len_ = vec_ ? vec_->prefix.num : 0; \ - VEC (T,A) *new_vec_ = NULL; \ - \ - if (len_) \ - { \ - new_vec_ = (VEC (T,A) *)(vec_##A##_o_reserve_exact \ - (NULL, len_, \ - offsetof (VEC(T,A),base.vec), sizeof (T) \ - PASS_MEM_STAT)); \ - \ - new_vec_->base.prefix.num = len_; \ - memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \ - } \ - return new_vec_; \ -} \ - \ -static inline void VEC_OP (T,A,free) \ - (VEC(T,A) **vec_) \ -{ \ - if (*vec_) \ - vec_##A##_free (*vec_); \ - *vec_ = NULL; \ -} \ - \ -static inline int VEC_OP (T,A,reserve) \ - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ - VEC_CHECK_PASS); \ - \ - if (extend) \ - *vec_ = (VEC(T,A) *) vec_##A##_o_reserve (*vec_, alloc_, \ - offsetof (VEC(T,A),base.vec),\ - sizeof (T) \ - PASS_MEM_STAT); \ - \ - return extend; \ -} \ - \ -static inline int VEC_OP (T,A,reserve_exact) \ - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ - VEC_CHECK_PASS); \ - \ - if (extend) \ - *vec_ = (VEC(T,A) *) vec_##A##_o_reserve_exact \ - (*vec_, alloc_, \ - offsetof (VEC(T,A),base.vec), \ - sizeof (T) PASS_MEM_STAT); \ - \ - return extend; \ -} \ - \ -static inline void VEC_OP (T,A,safe_grow) \ - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - VEC_ASSERT (size_ >= 0 \ - && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \ - "grow", T, A); \ - VEC_OP (T,A,reserve_exact) (vec_, \ - size_ - (int)(*vec_ ? VEC_BASE(*vec_)->prefix.num : 0) \ - VEC_CHECK_PASS PASS_MEM_STAT); \ - VEC_BASE (*vec_)->prefix.num = size_; \ -} \ - \ -static inline void VEC_OP (T,A,safe_grow_cleared) \ - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \ - VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \ - memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \ - sizeof (T) * (size_ - oldsize)); \ -} \ - \ -static inline void VEC_OP(T,A,safe_splice) \ - (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - if (src_) \ - { \ - VEC_OP (T,A,reserve_exact) (dst_, src_->prefix.num \ - VEC_CHECK_PASS MEM_STAT_INFO); \ - \ - VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \ - VEC_CHECK_PASS); \ - } \ -} \ - \ -static inline T *VEC_OP (T,A,safe_push) \ - (VEC(T,A) **vec_, const T *obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ - \ - return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \ -} \ - \ -static inline T *VEC_OP (T,A,safe_insert) \ - (VEC(T,A) **vec_, unsigned ix_, const T *obj_ \ - VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ - \ - return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ - VEC_CHECK_PASS); \ -} - -#define DEF_VEC_ALLOC_FUNC_I(T,A) \ -static inline VEC(T,A) *VEC_OP (T,A,alloc) \ - (int alloc_ MEM_STAT_DECL) \ -{ \ - return (VEC(T,A) *) vec_##A##_o_reserve_exact \ - (NULL, alloc_, offsetof (VEC(T,A),base.vec), \ - sizeof (T) PASS_MEM_STAT); \ -} - -#define DEF_VEC_NONALLOC_FUNCS_I(T,A) \ -static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \ -{ \ - size_t len_ = vec_ ? vec_->prefix.num : 0; \ - VEC (T,A) *new_vec_ = NULL; \ - \ - if (len_) \ - { \ - new_vec_ = (VEC (T,A) *)(vec_##A##_o_reserve_exact \ - (NULL, len_, \ - offsetof (VEC(T,A),base.vec), sizeof (T) \ - PASS_MEM_STAT)); \ - \ - new_vec_->base.prefix.num = len_; \ - memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \ - } \ - return new_vec_; \ -} \ - \ -static inline void VEC_OP (T,A,free) \ - (VEC(T,A) **vec_) \ -{ \ - if (*vec_) \ - vec_##A##_free (*vec_); \ - *vec_ = NULL; \ -} \ - \ -static inline int VEC_OP (T,A,reserve) \ - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ - VEC_CHECK_PASS); \ - \ - if (extend) \ - *vec_ = (VEC(T,A) *) vec_##A##_o_reserve (*vec_, alloc_, \ - offsetof (VEC(T,A),base.vec),\ - sizeof (T) \ - PASS_MEM_STAT); \ - \ - return extend; \ -} \ - \ -static inline int VEC_OP (T,A,reserve_exact) \ - (VEC(T,A) **vec_, int alloc_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - int extend = !VEC_OP (T,base,space) (VEC_BASE(*vec_), alloc_ \ - VEC_CHECK_PASS); \ - \ - if (extend) \ - *vec_ = (VEC(T,A) *) vec_##A##_o_reserve_exact \ - (*vec_, alloc_, offsetof (VEC(T,A),base.vec), \ - sizeof (T) PASS_MEM_STAT); \ - \ - return extend; \ -} \ - \ -static inline void VEC_OP (T,A,safe_grow) \ - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - VEC_ASSERT (size_ >= 0 \ - && VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \ - "grow", T, A); \ - VEC_OP (T,A,reserve_exact) (vec_, \ - size_ - (int)(*vec_ ? VEC_BASE(*vec_)->prefix.num : 0) \ - VEC_CHECK_PASS PASS_MEM_STAT); \ - VEC_BASE (*vec_)->prefix.num = size_; \ -} \ - \ -static inline void VEC_OP (T,A,safe_grow_cleared) \ - (VEC(T,A) **vec_, int size_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - int oldsize = VEC_OP(T,base,length) VEC_BASE(*vec_); \ - VEC_OP (T,A,safe_grow) (vec_, size_ VEC_CHECK_PASS PASS_MEM_STAT); \ - memset (&(VEC_OP (T,base,address) VEC_BASE(*vec_))[oldsize], 0, \ - sizeof (T) * (size_ - oldsize)); \ -} \ - \ -static inline void VEC_OP(T,A,safe_splice) \ - (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - if (src_) \ - { \ - VEC_OP (T,A,reserve_exact) (dst_, src_->prefix.num \ - VEC_CHECK_PASS MEM_STAT_INFO); \ - \ - VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \ - VEC_CHECK_PASS); \ - } \ -} \ - \ -static inline T *VEC_OP (T,A,safe_push) \ - (VEC(T,A) **vec_, const T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ - \ - return VEC_OP (T,base,quick_push) (VEC_BASE(*vec_), obj_ VEC_CHECK_PASS); \ -} \ - \ -static inline T *VEC_OP (T,A,safe_insert) \ - (VEC(T,A) **vec_, unsigned ix_, const T obj_ \ - VEC_CHECK_DECL MEM_STAT_DECL) \ -{ \ - VEC_OP (T,A,reserve) (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); \ - \ - return VEC_OP (T,base,quick_insert) (VEC_BASE(*vec_), ix_, obj_ \ - VEC_CHECK_PASS); \ +template<typename T> +static inline unsigned +VEC_lower_bound_1 (vec_t<T> *vec_, const T *ptr_, + bool (*lessthan_)(const T*, const T*) VEC_CHECK_DECL) +{ + unsigned int len_ = VEC_length (T, vec_); + unsigned int half_, middle_; + unsigned int first_ = 0; + while (len_ > 0) + { + T *middle_elem_; + half_ = len_ >> 1; + middle_ = first_; + middle_ += half_; + middle_elem_ = &VEC_index_1 (vec_, middle_ VEC_CHECK_PASS); + if (lessthan_ (middle_elem_, ptr_)) + { + first_ = middle_; + ++first_; + len_ = len_ - half_ - 1; + } + else + len_ = half_; + } + return first_; } -/* We support a vector which starts out with space on the stack and - switches to heap space when forced to reallocate. This works a - little differently. Instead of DEF_VEC_ALLOC_P(TYPE, heap|gc), use - DEF_VEC_ALLOC_P_STACK(TYPE). This uses alloca to get the initial - space; because alloca can not be usefully called in an inline - function, and because a macro can not define a macro, you must then - write a #define for each type: - #define VEC_{TYPE}_stack_alloc(alloc) \ - VEC_stack_alloc({TYPE}, alloc) +void *vec_heap_o_reserve_1 (void *, int, size_t, size_t, bool MEM_STAT_DECL); +void *vec_gc_o_reserve_1 (void *, int, size_t, size_t, bool MEM_STAT_DECL); - This is really a hack and perhaps can be made better. Note that - this macro will wind up evaluating the ALLOC parameter twice. +/* Ensure there are at least RESERVE free slots in VEC_, growing + exponentially. If RESERVE < 0 grow exactly, else grow + exponentially. As a special case, if VEC_ is NULL, and RESERVE is + 0, no vector will be created. */ - Only the initial allocation will be made using alloca, so pass a - reasonable estimate that doesn't use too much stack space; don't - pass zero. Don't return a VEC(TYPE,stack) vector from the function - which allocated it. */ - -extern void *vec_stack_p_reserve (void *, int MEM_STAT_DECL); -extern void *vec_stack_p_reserve_exact (void *, int MEM_STAT_DECL); -extern void *vec_stack_p_reserve_exact_1 (int, void *); -extern void *vec_stack_o_reserve (void *, int, size_t, size_t MEM_STAT_DECL); -extern void *vec_stack_o_reserve_exact (void *, int, size_t, size_t - MEM_STAT_DECL); -extern void vec_stack_free (void *); - -/* Unfortunately, we cannot use MEM_STAT_DECL here. */ -#if GATHER_STATISTICS -#define VEC_stack_alloc(T,alloc,name,line,function) \ - (VEC_OP (T,stack,alloc1) \ - (alloc, XALLOCAVAR (VEC(T,stack), VEC_embedded_size (T, alloc)))) -#else -#define VEC_stack_alloc(T,alloc) \ - (VEC_OP (T,stack,alloc1) \ - (alloc, XALLOCAVAR (VEC(T,stack), VEC_embedded_size (T, alloc)))) -#endif - -#define DEF_VEC_ALLOC_P_STACK(T) \ -VEC_TA(T,base,stack); \ -DEF_VEC_ALLOC_FUNC_P_STACK(T) \ -DEF_VEC_NONALLOC_FUNCS_P(T,stack) \ -struct vec_swallow_trailing_semi - -#define DEF_VEC_ALLOC_FUNC_P_STACK(T) \ -static inline VEC(T,stack) *VEC_OP (T,stack,alloc1) \ - (int alloc_, VEC(T,stack)* space) \ -{ \ - return (VEC(T,stack) *) vec_stack_p_reserve_exact_1 (alloc_, space); \ +template<typename T, enum vec_allocation_t A> +vec_t<T> * +vec_reserve (vec_t<T> *vec_, int reserve MEM_STAT_DECL) +{ + if (A == gc) + return (vec_t<T> *) vec_gc_o_reserve_1 (vec_, reserve, + offsetof (vec_t<T>, vec), + sizeof (T), false + PASS_MEM_STAT); + else if (A == heap) + return (vec_t<T> *) vec_heap_o_reserve_1 (vec_, reserve, + offsetof (vec_t<T>, vec), + sizeof (T), false + PASS_MEM_STAT); + else + { + /* Only allow stack vectors when re-growing them. The initial + allocation of stack vectors must be done with the + VEC_stack_alloc macro, because it uses alloca() for the + allocation. */ + if (vec_ == NULL) + { + fprintf (stderr, "Stack vectors must be initially allocated " + "with VEC_stack_alloc.\n"); + gcc_unreachable (); + } + return (vec_t<T> *) vec_stack_o_reserve (vec_, reserve, + offsetof (vec_t<T>, vec), + sizeof (T) PASS_MEM_STAT); + } } -#define DEF_VEC_ALLOC_O_STACK(T) \ -VEC_TA(T,base,stack); \ -DEF_VEC_ALLOC_FUNC_O_STACK(T) \ -DEF_VEC_NONALLOC_FUNCS_O(T,stack) \ -struct vec_swallow_trailing_semi -#define DEF_VEC_ALLOC_FUNC_O_STACK(T) \ -static inline VEC(T,stack) *VEC_OP (T,stack,alloc1) \ - (int alloc_, VEC(T,stack)* space) \ -{ \ - return (VEC(T,stack) *) vec_stack_p_reserve_exact_1 (alloc_, space); \ -} - -#define DEF_VEC_ALLOC_I_STACK(T) \ -VEC_TA(T,base,stack); \ -DEF_VEC_ALLOC_FUNC_I_STACK(T) \ -DEF_VEC_NONALLOC_FUNCS_I(T,stack) \ -struct vec_swallow_trailing_semi +/* Ensure there are at least RESERVE free slots in VEC_, growing + exactly. If RESERVE < 0 grow exactly, else grow exponentially. As + a special case, if VEC_ is NULL, and RESERVE is 0, no vector will be + created. */ -#define DEF_VEC_ALLOC_FUNC_I_STACK(T) \ -static inline VEC(T,stack) *VEC_OP (T,stack,alloc1) \ - (int alloc_, VEC(T,stack)* space) \ -{ \ - return (VEC(T,stack) *) vec_stack_p_reserve_exact_1 (alloc_, space); \ +template<typename T, enum vec_allocation_t A> +vec_t<T> * +vec_reserve_exact (vec_t<T> *vec_, int reserve MEM_STAT_DECL) +{ + if (A == gc) + return (vec_t<T> *) vec_gc_o_reserve_1 (vec_, reserve, + sizeof (struct vec_prefix), + sizeof (T), true + PASS_MEM_STAT); + else if (A == heap) + return (vec_t<T> *) vec_heap_o_reserve_1 (vec_, reserve, + sizeof (struct vec_prefix), + sizeof (T), true + PASS_MEM_STAT); + else if (A == stack) + { + /* Only allow stack vectors when re-growing them. The initial + allocation of stack vectors must be done with VEC_alloc, + because it uses alloca() for the allocation. */ + if (vec_ == NULL) + { + fprintf (stderr, "Stack vectors must be initially allocated " + "with VEC_stack_alloc.\n"); + gcc_unreachable (); + } + return (vec_t<T> *) vec_stack_o_reserve_exact (vec_, reserve, + sizeof (struct vec_prefix), + sizeof (T) + PASS_MEM_STAT); + } } #endif /* GCC_VEC_H */ diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 5345f2b..7a72666 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -1924,7 +1924,8 @@ add_function_candidate (struct z_candidate **candidates, for (i = 0; i < len; ++i) { - tree arg, argtype, to_type; + tree argtype, to_type; + tree arg; conversion *t; int is_this; @@ -1934,8 +1935,9 @@ add_function_candidate (struct z_candidate **candidates, if (i == 0 && first_arg != NULL_TREE) arg = first_arg; else - arg = VEC_index (tree, args, - i + skip - (first_arg != NULL_TREE ? 1 : 0)); + arg = CONST_CAST_TREE ( + VEC_index (tree, args, + i + skip - (first_arg != NULL_TREE ? 1 : 0))); argtype = lvalue_type (arg); is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) diff --git a/gcc/cp/class.c b/gcc/cp/class.c index 2f377c8..dfa2b52 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -8403,12 +8403,12 @@ build_vtbl_initializer (tree binfo, int new_position = (TARGET_VTABLE_DATA_ENTRY_DISTANCE * ix + (TARGET_VTABLE_DATA_ENTRY_DISTANCE - 1)); - VEC_replace (constructor_elt, vid.inits, new_position, e); + VEC_replace (constructor_elt, vid.inits, new_position, *e); for (j = 1; j < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++j) { - constructor_elt *f = VEC_index (constructor_elt, vid.inits, - new_position - j); + constructor_elt *f = &VEC_index (constructor_elt, vid.inits, + new_position - j); f->index = NULL_TREE; f->value = build1 (NOP_EXPR, vtable_entry_type, null_pointer_node); @@ -8429,7 +8429,7 @@ build_vtbl_initializer (tree binfo, for (ix = VEC_length (constructor_elt, vid.inits) - 1; VEC_iterate (constructor_elt, vid.inits, ix, e); ix--, jx++) - VEC_replace (constructor_elt, *inits, jx, e); + VEC_replace (constructor_elt, *inits, jx, *e); /* Go through all the ordinary virtual functions, building up initializers. */ diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index b637643..5908996 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -5282,7 +5282,7 @@ reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p, && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1) { str_init = VEC_index (constructor_elt, - CONSTRUCTOR_ELTS (str_init), 0)->value; + CONSTRUCTOR_ELTS (str_init), 0).value; } /* If it's a string literal, then it's the initializer for the array @@ -5372,7 +5372,7 @@ reshape_init (tree type, tree init, tsubst_flags_t complain) return init; /* Recurse on this CONSTRUCTOR. */ - d.cur = VEC_index (constructor_elt, v, 0); + d.cur = &VEC_index (constructor_elt, v, 0); d.end = d.cur + VEC_length (constructor_elt, v); new_init = reshape_init_r (type, &d, true, complain); @@ -5917,7 +5917,7 @@ type_dependent_init_p (tree init) nelts = VEC_length (constructor_elt, elts); for (i = 0; i < nelts; ++i) if (type_dependent_init_p (VEC_index (constructor_elt, - elts, i)->value)) + elts, i).value)) return true; } else @@ -5947,7 +5947,7 @@ value_dependent_init_p (tree init) nelts = VEC_length (constructor_elt, elts); for (i = 0; i < nelts; ++i) if (value_dependent_init_p (VEC_index (constructor_elt, - elts, i)->value)) + elts, i).value)) return true; } else @@ -6896,7 +6896,7 @@ cp_complete_array_type (tree *ptype, tree initial_value, bool do_default) && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value))) { VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value); - tree value = VEC_index (constructor_elt, v, 0)->value; + tree value = VEC_index (constructor_elt, v, 0).value; if (TREE_CODE (value) == STRING_CST && VEC_length (constructor_elt, v) == 1) diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index d8c3305..a7f12ba 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -273,7 +273,7 @@ cp_lexer_dump_tokens (FILE *file, VEC(cp_token,gc) *buffer, if (start_token > VEC_address (cp_token, buffer)) { - cp_lexer_print_token (file, VEC_index (cp_token, buffer, 0)); + cp_lexer_print_token (file, &VEC_index (cp_token, buffer, 0)); fprintf (file, " ... "); } @@ -313,8 +313,7 @@ cp_lexer_dump_tokens (FILE *file, VEC(cp_token,gc) *buffer, if (i == num && i < VEC_length (cp_token, buffer)) { fprintf (file, " ... "); - cp_lexer_print_token (file, VEC_index (cp_token, buffer, - VEC_length (cp_token, buffer) - 1)); + cp_lexer_print_token (file, &VEC_last (cp_token, buffer)); } fprintf (file, "\n"); @@ -1723,11 +1722,11 @@ cp_parser_context_new (cp_parser_context* next) /* Managing the unparsed function queues. */ #define unparsed_funs_with_default_args \ - VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_default_args + VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues).funs_with_default_args #define unparsed_funs_with_definitions \ - VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_definitions + VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues).funs_with_definitions #define unparsed_nsdmis \ - VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->nsdmis + VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues).nsdmis static void push_unparsed_function_queues (cp_parser *parser) @@ -8048,7 +8047,7 @@ record_lambda_scope (tree lambda) static void finish_lambda_scope (void) { - tree_int *p = VEC_last (tree_int, lambda_scope_stack); + tree_int *p = &VEC_last (tree_int, lambda_scope_stack); if (lambda_scope != p->t) { lambda_scope = p->t; diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c index a19a893..51cb5ee 100644 --- a/gcc/cp/rtti.c +++ b/gcc/cp/rtti.c @@ -295,7 +295,7 @@ typeid_ok_p (void) } pseudo_type_info - = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE)->type; + = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE).type; type_info_type = TYPE_MAIN_VARIANT (const_type_info_type_node); /* Make sure abi::__type_info_pseudo has the same alias set @@ -422,7 +422,7 @@ get_tinfo_decl (tree type) if (!d) { int ix = get_pseudo_ti_index (type); - tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, ix); + tinfo_s *ti = &VEC_index (tinfo_s, tinfo_descs, ix); d = build_lang_decl (VAR_DECL, name, ti->type); SET_DECL_ASSEMBLER_NAME (d, name); @@ -1079,7 +1079,7 @@ typeinfo_in_lib_p (tree type) static tree get_pseudo_ti_init (tree type, unsigned tk_index) { - tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, tk_index); + tinfo_s *ti = &VEC_index (tinfo_s, tinfo_descs, tk_index); gcc_assert (at_eof); switch (tk_index) @@ -1105,7 +1105,7 @@ get_pseudo_ti_init (tree type, unsigned tk_index) tree tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo)); /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */ - ti = VEC_index (tinfo_s, tinfo_descs, tk_index); + ti = &VEC_index (tinfo_s, tinfo_descs, tk_index); return class_initializer (ti, type, 1, tinfo); } @@ -1160,14 +1160,14 @@ get_pseudo_ti_init (tree type, unsigned tk_index) CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, tinfo); CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, offset); base_init = build_constructor (init_list_type_node, v); - e = VEC_index (constructor_elt, init_vec, ix); + e = &VEC_index (constructor_elt, init_vec, ix); e->index = NULL_TREE; e->value = base_init; } base_inits = build_constructor (init_list_type_node, init_vec); /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */ - ti = VEC_index (tinfo_s, tinfo_descs, tk_index); + ti = &VEC_index (tinfo_s, tinfo_descs, tk_index); return class_initializer (ti, type, 3, build_int_cst (NULL_TREE, hint), build_int_cst (NULL_TREE, nbases), @@ -1214,7 +1214,7 @@ create_pseudo_type_info (int tk, const char *real_name, ...) fields = build_decl (input_location, FIELD_DECL, NULL_TREE, VEC_index (tinfo_s, tinfo_descs, - TK_TYPE_INFO_TYPE)->type); + TK_TYPE_INFO_TYPE).type); /* Now add the derived fields. */ while ((field_decl = va_arg (ap, tree))) @@ -1228,7 +1228,7 @@ create_pseudo_type_info (int tk, const char *real_name, ...) finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE); CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type; - ti = VEC_index (tinfo_s, tinfo_descs, tk); + ti = &VEC_index (tinfo_s, tinfo_descs, tk); ti->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST); ti->name = get_identifier (real_name); ti->vtable = NULL_TREE; @@ -1321,7 +1321,7 @@ get_pseudo_ti_index (tree type) while (VEC_iterate (tinfo_s, tinfo_descs, len++, ti)) ti->type = ti->vtable = ti->name = NULL_TREE; } - else if (VEC_index (tinfo_s, tinfo_descs, ix)->type) + else if (VEC_index (tinfo_s, tinfo_descs, ix).type) /* already created. */ break; @@ -1335,7 +1335,7 @@ get_pseudo_ti_index (tree type) array_domain = build_index_type (size_int (num_bases)); base_array = build_array_type (VEC_index (tinfo_s, tinfo_descs, - TK_BASE_TYPE)->type, + TK_BASE_TYPE).type, array_domain); push_abi_namespace (); @@ -1387,7 +1387,7 @@ create_tinfo_types (void) DECL_CHAIN (field) = fields; fields = field; - ti = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE); + ti = &VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE); ti->type = make_class_type (RECORD_TYPE); ti->vtable = NULL_TREE; ti->name = NULL_TREE; @@ -1427,7 +1427,7 @@ create_tinfo_types (void) DECL_CHAIN (field) = fields; fields = field; - ti = VEC_index (tinfo_s, tinfo_descs, TK_BASE_TYPE); + ti = &VEC_index (tinfo_s, tinfo_descs, TK_BASE_TYPE); ti->type = make_class_type (RECORD_TYPE); ti->vtable = NULL_TREE; diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index 230e967..ebac960 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -161,7 +161,7 @@ resume_deferring_access_checks (void) { if (!deferred_access_no_check) VEC_last (deferred_access, deferred_access_stack) - ->deferring_access_checks_kind = dk_deferred; + .deferring_access_checks_kind = dk_deferred; } /* Stop deferring access checks. */ @@ -171,7 +171,7 @@ stop_deferring_access_checks (void) { if (!deferred_access_no_check) VEC_last (deferred_access, deferred_access_stack) - ->deferring_access_checks_kind = dk_no_deferred; + .deferring_access_checks_kind = dk_no_deferred; } /* Discard the current deferred access checks and restore the @@ -198,7 +198,7 @@ get_deferred_access_checks (void) return NULL; else return (VEC_last (deferred_access, deferred_access_stack) - ->deferred_access_checks); + .deferred_access_checks); } /* Take current deferred checks and combine with the @@ -216,10 +216,10 @@ pop_to_parent_deferring_access_checks (void) deferred_access *ptr; checks = (VEC_last (deferred_access, deferred_access_stack) - ->deferred_access_checks); + .deferred_access_checks); VEC_pop (deferred_access, deferred_access_stack); - ptr = VEC_last (deferred_access, deferred_access_stack); + ptr = &VEC_last (deferred_access, deferred_access_stack); if (ptr->deferring_access_checks_kind == dk_no_deferred) { /* Check access. */ @@ -321,7 +321,7 @@ perform_or_defer_access_check (tree binfo, tree decl, tree diag_decl, gcc_assert (TREE_CODE (binfo) == TREE_BINFO); - ptr = VEC_last (deferred_access, deferred_access_stack); + ptr = &VEC_last (deferred_access, deferred_access_stack); /* If we are not supposed to defer access checks, just check now. */ if (ptr->deferring_access_checks_kind == dk_no_deferred) @@ -5948,7 +5948,7 @@ build_constexpr_constructor_member_initializers (tree type, tree body) if (VEC_length (constructor_elt, vec) > 0) { /* In a delegating constructor, return the target. */ - constructor_elt *ce = VEC_index (constructor_elt, vec, 0); + constructor_elt *ce = &VEC_index (constructor_elt, vec, 0); if (ce->index == current_class_ptr) { body = ce->value; @@ -6820,7 +6820,7 @@ cxx_eval_array_reference (const constexpr_call *call, tree t, } i = tree_low_cst (index, 0); if (TREE_CODE (ary) == CONSTRUCTOR) - return VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ary), i)->value; + return VEC_index (constructor_elt, CONSTRUCTOR_ELTS (ary), i).value; else if (elem_nchars == 1) return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary))), TREE_STRING_POINTER (ary)[i]); diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index bfbde04..7cc2457 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -1337,7 +1337,7 @@ strip_typedefs_expr (tree t) type = strip_typedefs (TREE_TYPE (t)); for (i = 0; i < n; ++i) { - constructor_elt *e = VEC_index (constructor_elt, vec, i); + constructor_elt *e = &VEC_index (constructor_elt, vec, i); tree op = strip_typedefs_expr (e->value); if (op != e->value) { diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c index 326f602..2180535 100644 --- a/gcc/cp/typeck2.c +++ b/gcc/cp/typeck2.c @@ -1178,7 +1178,7 @@ process_init_constructor_record (tree type, tree init, if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init))) { - constructor_elt *ce = VEC_index (constructor_elt, + constructor_elt *ce = &VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), idx); if (ce->index) { @@ -1305,7 +1305,7 @@ process_init_constructor_union (tree type, tree init, VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1); } - ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0); + ce = &VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0); /* If this element specifies a field, initialize via that field. */ if (ce->index) diff --git a/gcc/df-scan.c b/gcc/df-scan.c index df90365..55492fa 100644 --- a/gcc/df-scan.c +++ b/gcc/df-scan.c @@ -4448,7 +4448,6 @@ df_bb_verify (basic_block bb) if (!INSN_P (insn)) continue; df_insn_refs_verify (&collection_rec, bb, insn, true); - df_free_collection_rec (&collection_rec); } /* Do the artificial defs and uses. */ diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 3c94b79..504f9a8 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -3999,7 +3999,7 @@ splice_all_param_accesses (VEC (access_p, heap) **representatives) result = UNUSED_PARAMS; } else - VEC_quick_push (access_p, *representatives, NULL); + VEC_quick_push (access_p, *representatives, (access_p) NULL); } if (result == NO_GOOD_ACCESS) @@ -4208,7 +4208,7 @@ get_adjustment_for_base (ipa_parm_adjustment_vec adjustments, tree base) { struct ipa_parm_adjustment *adj; - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); if (!adj->copy_param && adj->base == base) return adj; } @@ -4315,7 +4315,7 @@ sra_ipa_modify_expr (tree *expr, bool convert, for (i = 0; i < len; i++) { - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); if (adj->base == base && (adj->offset == offset || adj->remove_param)) @@ -4522,7 +4522,7 @@ sra_ipa_reset_debug_stmts (ipa_parm_adjustment_vec adjustments) tree name, vexpr, copy = NULL_TREE; use_operand_p use_p; - adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); + adj = &VEC_index (ipa_parm_adjustment_t, adjustments, i); if (adj->copy_param || !is_gimple_reg (adj->base)) continue; name = ssa_default_def (cfun, adj->base); diff --git a/gcc/tree-ssa-address.c b/gcc/tree-ssa-address.c index ddab7d8..57a590d 100644 --- a/gcc/tree-ssa-address.c +++ b/gcc/tree-ssa-address.c @@ -215,7 +215,8 @@ addr_for_mem_ref (struct mem_address *addr, addr_space_t as, templ_index + 1); /* Reuse the templates for addresses, so that we do not waste memory. */ - templ = VEC_index (mem_addr_template, mem_addr_template_list, templ_index); + templ = &VEC_index (mem_addr_template, mem_addr_template_list, + templ_index); if (!templ->ref) { sym = (addr->symbol ? diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c index d2a4128..a7b644f 100644 --- a/gcc/tree-ssa-dom.c +++ b/gcc/tree-ssa-dom.c @@ -1734,7 +1734,8 @@ dom_opt_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED, /* Push a marker on the stacks of local information so that we know how far to unwind when we finalize this block. */ - VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, NULL); + VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, + (expr_hash_elt_t)NULL); VEC_safe_push (tree, heap, const_and_copies_stack, NULL_TREE); record_equivalences_from_incoming_edge (bb); @@ -1745,7 +1746,8 @@ dom_opt_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED, /* Create equivalences from redundant PHIs. PHIs are only truly redundant when they exist in the same block, so push another marker and unwind right afterwards. */ - VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, NULL); + VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, + (expr_hash_elt_t)NULL); for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) eliminate_redundant_computations (&gsi); remove_local_expressions_from_table (); @@ -1800,7 +1802,8 @@ dom_opt_leave_block (struct dom_walk_data *walk_data, basic_block bb) /* Push a marker onto the available expression stack so that we unwind any expressions related to the TRUE arm before processing the false arm below. */ - VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, NULL); + VEC_safe_push (expr_hash_elt_t, heap, avail_exprs_stack, + (expr_hash_elt_t)NULL); VEC_safe_push (tree, heap, const_and_copies_stack, NULL_TREE); edge_info = (struct edge_info *) true_edge->aux; diff --git a/gcc/hw-doloop.c b/gcc/hw-doloop.c index 925039f..cd9b3f2 100644 --- a/gcc/hw-doloop.c +++ b/gcc/hw-doloop.c @@ -345,12 +345,12 @@ discover_loop (hwloop_info loop, basic_block tail_bb, rtx tail_insn, rtx reg) } /* Analyze the structure of the loops in the current function. Use - STACK for bitmap allocations. Returns all the valid candidates for + LOOP_STACK for bitmap allocations. Returns all the valid candidates for hardware loops found in this function. HOOKS is the argument passed to reorg_loops, used here to find the iteration registers from a loop_end pattern. */ static hwloop_info -discover_loops (bitmap_obstack *stack, struct hw_doloop_hooks *hooks) +discover_loops (bitmap_obstack *loop_stack, struct hw_doloop_hooks *hooks) { hwloop_info loops = NULL; hwloop_info loop; @@ -406,7 +406,7 @@ discover_loops (bitmap_obstack *stack, struct hw_doloop_hooks *hooks) loops = loop; loop->loop_no = nloops++; loop->blocks = VEC_alloc (basic_block, heap, 20); - loop->block_bitmap = BITMAP_ALLOC (stack); + loop->block_bitmap = BITMAP_ALLOC (loop_stack); if (dump_file) { @@ -626,18 +626,18 @@ reorg_loops (bool do_reorder, struct hw_doloop_hooks *hooks) { hwloop_info loops = NULL; hwloop_info loop; - bitmap_obstack stack; + bitmap_obstack loop_stack; df_live_add_problem (); df_live_set_all_dirty (); df_analyze (); - bitmap_obstack_initialize (&stack); + bitmap_obstack_initialize (&loop_stack); if (dump_file) fprintf (dump_file, ";; Find loops, first pass\n\n"); - loops = discover_loops (&stack, hooks); + loops = discover_loops (&loop_stack, hooks); if (do_reorder) { @@ -647,7 +647,7 @@ reorg_loops (bool do_reorder, struct hw_doloop_hooks *hooks) if (dump_file) fprintf (dump_file, ";; Find loops, second pass\n\n"); - loops = discover_loops (&stack, hooks); + loops = discover_loops (&loop_stack, hooks); } for (loop = loops; loop; loop = loop->next) diff --git a/gcc/config/bfin/bfin.c b/gcc/config/bfin/bfin.c index 3a4b8af..0a0d702 100644 --- a/gcc/config/bfin/bfin.c +++ b/gcc/config/bfin/bfin.c @@ -3478,7 +3478,7 @@ hwloop_optimize (hwloop_info loop) /* If we have to insert the LSETUP before a jump, count that jump in the length. */ if (VEC_length (edge, loop->incoming) > 1 - || !(VEC_last (edge, loop->incoming)->flags & EDGE_FALLTHRU)) + || !(VEC_last (edge, loop->incoming).flags & EDGE_FALLTHRU)) { gcc_assert (JUMP_P (insn)); insn = PREV_INSN (insn); @@ -3747,7 +3747,7 @@ hwloop_optimize (hwloop_info loop) { rtx prev = BB_END (loop->incoming_src); if (VEC_length (edge, loop->incoming) > 1 - || !(VEC_last (edge, loop->incoming)->flags & EDGE_FALLTHRU)) + || !(VEC_last (edge, loop->incoming).flags & EDGE_FALLTHRU)) { gcc_assert (JUMP_P (prev)); prev = PREV_INSN (prev); diff --git a/gcc/config/c6x/c6x.c b/gcc/config/c6x/c6x.c index a189a1d..1905504 100644 --- a/gcc/config/c6x/c6x.c +++ b/gcc/config/c6x/c6x.c @@ -126,7 +126,7 @@ DEF_VEC_ALLOC_O(c6x_sched_insn_info, heap); static VEC(c6x_sched_insn_info, heap) *insn_info; #define INSN_INFO_LENGTH (VEC_length (c6x_sched_insn_info, insn_info)) -#define INSN_INFO_ENTRY(N) (*VEC_index (c6x_sched_insn_info, insn_info, (N))) +#define INSN_INFO_ENTRY(N) (VEC_index (c6x_sched_insn_info, insn_info, (N))) static bool done_cfi_sections; @@ -3448,8 +3448,8 @@ try_rename_operands (rtx head, rtx tail, unit_req_table reqs, rtx insn, { unsigned int mask1, mask2, mask_changed; int count, side1, side2, req1, req2; - insn_rr_info *this_rr = VEC_index (insn_rr_info, insn_rr, - INSN_UID (chain->insn)); + insn_rr_info *this_rr = &VEC_index (insn_rr_info, insn_rr, + INSN_UID (chain->insn)); count = get_unit_reqs (chain->insn, &req1, &side1, &req2, &side2); @@ -3555,7 +3555,7 @@ reshuffle_units (basic_block loop) if (!get_unit_operand_masks (insn, &mask1, &mask2)) continue; - info = VEC_index (insn_rr_info, insn_rr, INSN_UID (insn)); + info = &VEC_index (insn_rr_info, insn_rr, INSN_UID (insn)); if (info->op_info == NULL) continue; diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c index f36f65b..3688136 100644 --- a/gcc/config/mips/mips.c +++ b/gcc/config/mips/mips.c @@ -3971,7 +3971,8 @@ mips_multi_start (void) static struct mips_multi_member * mips_multi_add (void) { - return VEC_safe_push (mips_multi_member, heap, mips_multi_members, 0); + return VEC_safe_push (mips_multi_member, heap, mips_multi_members, + (struct mips_multi_member *) 0); } /* Add a normal insn with the given asm format to the current multi-insn @@ -4026,7 +4027,7 @@ mips_multi_copy_insn (unsigned int i) struct mips_multi_member *member; member = mips_multi_add (); - memcpy (member, VEC_index (mips_multi_member, mips_multi_members, i), + memcpy (member, &VEC_index (mips_multi_member, mips_multi_members, i), sizeof (*member)); gcc_assert (!member->is_label_p); } @@ -4038,7 +4039,7 @@ mips_multi_copy_insn (unsigned int i) static void mips_multi_set_operand (unsigned int i, unsigned int op, rtx x) { - VEC_index (mips_multi_member, mips_multi_members, i)->operands[op] = x; + VEC_index (mips_multi_member, mips_multi_members, i).operands[op] = x; } /* Write out the asm code for the current multi-insn sequence. */
This implements the VEC re-write. See http://gcc.gnu.org/ml/gcc-patches/2012-08/msg00711.html for details. Diego. 2012-08-12 Diego Novillo <dnovillo@google.com> Re-implement VEC in C++. * vec.c (vec_heap_free): Convert into a template function. (vec_gc_o_reserve_1): Make extern. (vec_gc_p_reserve): Remove. (vec_gc_p_reserve_exact): Remove. (vec_gc_o_reserve): Remove. (vec_gc_o_reserve_exact): Remove. (vec_heap_o_reserve_1): Make extern. (vec_heap_p_reserve): Remove. (vec_heap_p_reserve_exact): Remove. (vec_heap_o_reserve): Remove. (vec_heap_o_reserve_exact): Remove. (vec_stack_p_reserve): Remove. (vec_stack_p_reserve_exact): Remove. * vec.h (VEC_CHECK_INFO, VEC_CHECK_DECL, VEC_CHECK_PASS, VEC_ASSERT, VEC_ASSERT_FAIL, vec_assert_fail): Move earlier in the file. (VEC): Define to vec_t<T>. (vec_allocation_t): Define. (struct vec_prefix): Move earlier in the file. (vec_t<T>): New template. (DEF_VEC_I, DEF_VECL_ALLOC_I, DEF_VEC_P, DEF_VEC_ALLOC_P, DEF_VEC_O, DEF_VEC_ALLOC_P, DEF_VEC_O, DEF_VEC_ALLOC_O, DEF_VEC_ALLOC_P_STACK, DEF_VEC_ALLOC_O_STACK, DEF_VEC_ALLOC_I_STACK): Expand to 'struct vec_swallow_trailing_semi'. (DEF_VEC_A): Provide template instantiations for GC/PCH markers that do not traverse the vector. (vec_stack_p_reserve): Remove. (vec_stack_p_reserve_exact): Remove. (vec_stack_p_reserve_exact_1): Remove. (vec_stack_o_reserve): Remove. (vec_stack_o_reserve_exact): Remove. (vec_stack_free): Re-write as a template function. (vec_reserve): New template function. (vec_reserve_exact): New template function. (vec_heap_free): New template function if GATHER_STATISTICS is defined. Otherwise, macro that expands to free(). (VEC_length_1): New template function. (VEC_length): Call it. (VEC_empty_1): New template function. (VEC_empty): Call it. (VEC_address_1): New template function. (VEC_address): Call it. (VEC_last_1): New template function. (VEC_last): Call it. Change return type to T&. Change all users that used VEC_Os. (VEC_index_1): New template function. (VEC_index): Call it. Return a T& instead of a T*. Update all callers that were using VEC_O before. (VEC_iterate_1): New template function. (VEC_iterate): Call it. (VEC_embedded_size_1): New template function. (VEC_embedded_size): Call it. (VEC_embedded_init_1): New template function. (VEC_embedded_init): Call it. (VEC_alloc_1): New template function. (VEC_alloc): Call it. If A is 'stack', call XALLOCAVAR to do the allocation. (VEC_free_1): New template function. (VEC_free): Call it. (VEC_copy_1): New template function. (VEC_copy): Call it. (VEC_space_1): New template function (VEC_space): Call it. (VEC_reserve_1): New template function. (VEC_reserve): Call it. (VEC_reserve_exact_1): New template function. (VEC_reserve_exact): Call it. (VEC_splice_1): New template function. (VEC_splice): Call it. (VEC_safe_splice_1): New template function. (VEC_safe_splice): Call it. (VEC_quick_push_1): New template function. Create two overloads, one accepting T, the other accepting T *. Update all callers where T and T * are ambiguous. (VEC_quick_push): Call it. (VEC_safe_push_1): New template function. Create two overloads, one accepting T, the other accepting T *. Update all callers where T and T * are ambiguous. (VEC_safe_push): Call it. (VEC_pop_1): New template function. (VEC_pop): Call it. (VEC_truncate_1): New template function. (VEC_truncate): Call it. (VEC_safe_grow_1): New template function. (VEC_safe_grow): Call it. (VEC_safe_grow_cleared_1): New template function. (VEC_safe_grow_cleared): Call it. (VEC_replace_1): New template function. (VEC_replace): Call it. Always accept T instead of T*. Update all callers that used VEC_Os. (VEC_quick_insert_1): New template function. (VEC_quick_insert): Call it. (VEC_safe_insert_1): New template function. (VEC_safe_insert): Call it. (VEC_ordered_remove_1): New template function. (VEC_ordered_remove): Call it. (VEC_unordered_remove_1): New template function. (VEC_unordered_remove): Call it. (VEC_block_remove_1): New template function. (VEC_block_remove): Call it. (VEC_lower_bound_1): New template function. (VEC_lower_bound): Call it. (VEC_OP): Remove. (DEF_VEC_FUNC_P): Remove. (DEF_VEC_ALLOC_FUNC_P): Remove. (DEF_VEC_NONALLOC_FUNCS_P): Remove. (DEF_VEC_FUNC_O): Remove. (DEF_VEC_ALLOC_FUNC_O): Remove. (DEF_VEC_NONALLOC_FUNCS_O): Remove. (DEF_VEC_ALLOC_FUNC_I): Remove. (DEF_VEC_NONALLOC_FUNCS_I): Remove. (DEF_VEC_ALLOC_FUNC_P_STACK): Remove. (DEF_VEC_ALLOC_FUNC_O_STACK): Remove. (DEF_VEC_ALLOC_FUNC_I_STACK): Remove. (vec_reserve_exact): New template function. * gengtype-lex.l (DEF_VEC_ALLOC_[IOP]/{EOID}): Remove. * gengtype-parse.c (token_names): Remove DEF_VEC_ALLOC_[IOP]. (typedef_name): Emit vec_t<C1> instead of VEC_C1_C2. (def_vec_alloc): Remove. Update all callers. * gengtype.c (filter_type_name): New. (output_mangled_typename): Call it. (write_func_for_structure): Likewise. (write_types): Likewise. (write_root): Likewise. (write_typed_alloc_def): Likewise. (note_def_vec): Emit vec_t<TYPE_NAME> instead of VEC_TYPE_NAME_base. (note_def_vec_alloc): Remove. * gengtype.h (note_def_vec_alloc): Remove. (DEFVEC_ALLOC): Remove token code. * df-scan.c (df_bb_verify): Remove call to df_free_collection_rec inside the insn traversal loop. * gimplify.c (gimplify_compound_lval): Rename STACK to EXPR_STACK. * ipa-inline.c (inline_small_functions): Rename HEAP to EDGE_HEAP. * reg-stack.c (stack): Rename to STACK_PTR. Update all users. * tree-vrp.c (stack): Rename to EQUIV_STACK. Update all users. * config/bfin/bfin.c (hwloop_optimize): Update some calls to VEC_* for vectors of non-pointers. * config/c6x/c6x.c (try_rename_operands): Likewise. (reshuffle_units): Likewise. * config/mips/mips.c (mips_multi_start): Likewise. (mips_multi_add): Likewise. (mips_multi_copy_insn): Likewise. (mips_multi_set_operand): Likewise. * hw-doloop.c (discover_loop): Likewise. (discover_loops): Likewise. (reorg_loops): Likewise.