From patchwork Sun Aug 12 20:11:26 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Diego Novillo X-Patchwork-Id: 176798 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id 8C1852C008A for ; Mon, 13 Aug 2012 06:12:35 +1000 (EST) Comment: DKIM? See http://www.dkim.org DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; d=gcc.gnu.org; s=default; x=1345407155; h=Comment: DomainKey-Signature:Received:Received:Received:Received:Received: Received:Received:Received:Received:Date:From:To:Cc:Subject: Message-ID:MIME-Version:Content-Type:Content-Disposition: User-Agent:Mailing-List:Precedence:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:Sender:Delivered-To; bh=5yjaGo+ p3/62yrwFnDNA273wRlM=; b=b5KRxiVEikcvwC4QVglVNou1KZSERq9SCVl5evx gLizwO1vnMy1woSLQCMSqCQq0PNc37YFSz4tlZ/AESiuu7BjTiMF/UD3jIUhNED9 4xTEvuHlwherszSI8+fs7O90cdhZ3X9Vaz4gXqzkhQbiF3Yr/VvdbtzLX63R1eWP BUCg= Comment: DomainKeys? See http://antispam.yahoo.com/domainkeys DomainKey-Signature: a=rsa-sha1; q=dns; c=nofws; s=default; d=gcc.gnu.org; h=Received:Received:X-SWARE-Spam-Status:X-Spam-Check-By:Received:Received:X-Google-DKIM-Signature:Received:Received:Received:Received:Received:Date:From:To:Cc:Subject:Message-ID:MIME-Version:Content-Type:Content-Disposition:User-Agent:X-Gm-Message-State:X-IsSubscribed:Mailing-List:Precedence:List-Id:List-Unsubscribe:List-Archive:List-Post:List-Help:Sender:Delivered-To; b=JN0a8N9T+KVeY4dpBXjrTvr1e5XN3djNmD5tALbsei3NY8nhYOMfXV0FTgECVQ slhWaUksM02Qv48Srnwh3FKJqp/NGiWgkHn1J36aQ9d9OInB6X+WoctSwkrK7xDg nYqGDniB3uu3kXAbpSkqk6D5Xe52hcE2V6fWiMmGP0vOw=; Received: (qmail 24980 invoked by alias); 12 Aug 2012 20:12:25 -0000 Received: (qmail 24944 invoked by uid 22791); 12 Aug 2012 20:12:04 -0000 X-SWARE-Spam-Status: No, hits=-1.9 required=5.0 tests=AWL, BAYES_50, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, FILL_THIS_FORM_SHORT, KHOP_RCVD_TRUST, RCVD_IN_DNSWL_LOW, RCVD_IN_HOSTKARMA_YE, TW_CP, TW_CX, TW_GB, TW_HW, TW_NR, TW_RG, TW_TM, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mail-bk0-f73.google.com (HELO mail-bk0-f73.google.com) (209.85.214.73) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sun, 12 Aug 2012 20:11:30 +0000 Received: by bkwj4 with SMTP id j4so137798bkw.2 for ; Sun, 12 Aug 2012 13:11:28 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=date:from:to:cc:subject:message-id:mime-version:content-type :content-disposition:organization:user-agent:x-gm-message-state; bh=0H/D0uDljQacQ+6BOaZLbCaK1cJix26//5wR8OPMwGE=; b=H9V/sRdYMeZm1KItJRntmesOS80VfH0EamFrF0Eg0QC09MluFkegQGSQb6O6enB1lt 2EUejr3lVYhamQzmXKSpVTvfgPQGiSkgFZlW9T6s3Muz7TOxC+waBKLHQYzYN6x5mH4G jYzXW8Lpjk87WuNnzd8reiooMXJ/NDJe/I5cYkLxAhEfeMQuX9axzzCyu1Dm19C7SnzO 2zKH9H87RSoO+FZRFK/6mtzCeGFJ2QB+fu+GjPQ7CIGstZ5sTMjSvABM0XoTeZc7Atjz o77UnC3gEtAHqTxa+6RXmRwkVokH1GGn7X5TcwmZmRm6CPGJVunxTcNlJaZMsAiXeoLO 9mJA== Received: by 10.14.179.72 with SMTP id g48mr5324003eem.2.1344802288258; Sun, 12 Aug 2012 13:11:28 -0700 (PDT) Received: by 10.14.179.72 with SMTP id g48mr5323996eem.2.1344802288176; Sun, 12 Aug 2012 13:11:28 -0700 (PDT) Received: from hpza9.eem.corp.google.com ([74.125.121.33]) by gmr-mx.google.com with ESMTPS id d5si7640442eep.0.2012.08.12.13.11.28 (version=TLSv1/SSLv3 cipher=AES128-SHA); Sun, 12 Aug 2012 13:11:28 -0700 (PDT) Received: from torture.tor.corp.google.com (torture.tor.corp.google.com [172.29.41.4]) by hpza9.eem.corp.google.com (Postfix) with ESMTP id 5686B5C0050; Sun, 12 Aug 2012 13:11:27 -0700 (PDT) Received: by torture.tor.corp.google.com (Postfix, from userid 54752) id C934AC0D36; Sun, 12 Aug 2012 16:11:26 -0400 (EDT) Date: Sun, 12 Aug 2012 16:11:26 -0400 From: Diego Novillo To: gcc-patches@gcc.gnu.org, Lawrence Crowl Cc: Richard Guenther Subject: Merge C++ conversion into trunk (2/6 - VEC rewrite) Message-ID: <20120812201126.GA14643@google.com> MIME-Version: 1.0 Content-Disposition: inline User-Agent: Mutt/1.5.21 (2010-09-15) X-Gm-Message-State: ALoCoQn+cn8G+922+PtIm4YLPn/9t06v6hwMK7AlWwSOEBjWP1GqPK/ZVfEAWgm23+jvDMpumwJYIOR6uXYPE473xEuMksRWXpSy2nhYFaQg6JE35vuOw4nIv4IRPHcUiqtzKjFkyROOOiACJPZDX0l+tZMoQ2Xer7U5DSmkcGLiIEHMavQwo95BdssqjtrjGZ5Sr+Gt1IkIAW224hkPCFtQvgclCKHkdfbeAdP3hLxS+ej8BTAMFdk= X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org 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 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. (vec_allocation_t): Define. (struct vec_prefix): Move earlier in the file. (vec_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 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 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 + Re-implemented in C++ by Diego Novillo 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 + Re-implemented in C++ by Diego Novillo 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 + +enum vec_allocation_t { heap, gc, stack }; + +struct vec_prefix +{ + unsigned num; + unsigned alloc; +}; + +/* Vector type, user visible. */ +template +struct GTY(()) vec_t +{ + vec_prefix prefix; + T vec[1]; +}; + +/* Garbage collection support for vec_t. */ + +template +void +gt_ggc_mx (vec_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 +void +gt_pch_nx (vec_t *v) +{ + extern void gt_pch_nx (T&); + for (unsigned i = 0; i < v->prefix.num; i++) + gt_pch_nx (v->vec[i]); +} + +template +void +gt_pch_nx (vec_t *v, gt_pointer_operator op, void *cookie) +{ + for (unsigned i = 0; i < v->prefix.num; i++) + op (&(v->vec[i]), cookie); +} + +template +void +gt_pch_nx (vec_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 \ +void \ +gt_ggc_mx (vec_t *v ATTRIBUTE_UNUSED) \ +{ \ +} \ + \ +template \ +void \ +gt_pch_nx (vec_t *v ATTRIBUTE_UNUSED) \ +{ \ +} \ + \ +template \ +void \ +gt_pch_nx (vec_t *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 +extern vec_t *vec_reserve (vec_t *, int MEM_STAT_DECL); + +template +extern vec_t *vec_reserve_exact (vec_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 (V)) + +template +static inline unsigned +VEC_length_1 (const vec_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 (V)) + +template +static inline bool +VEC_empty_1 (const vec_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 (V)) + +template +static inline T * +VEC_address_1 (vec_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 (V VEC_CHECK_INFO)) + +template +static inline T& +VEC_last_1 (vec_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 (V, I VEC_CHECK_INFO)) + +template +static inline T& +VEC_index_1 (vec_t *vec_, unsigned ix_ VEC_CHECK_DECL) +{ + VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); + return vec_->vec[ix_]; +} + +template +static inline const T& +VEC_index_1 (const vec_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 (V, I, &(P))) + +template +static inline bool +VEC_iterate_1 (const vec_t *vec_, unsigned ix_, T *ptr) +{ + if (vec_ && ix_ < vec_->prefix.num) + { + *ptr = vec_->vec[ix_]; + return true; + } + else + { + *ptr = 0; + return false; + } +} + +template +static inline bool +VEC_iterate_1 (vec_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 (N)) + +template +static inline size_t +VEC_embedded_size_1 (int alloc_) +{ + return offsetof (vec_t, vec) + alloc_ * sizeof (T); +} + +#define VEC_embedded_init(T,O,N) (VEC_embedded_init_1 (O, N)) + +template +static inline void +VEC_embedded_init_1 (vec_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, \ + VEC_embedded_size_1 (N))) \ + : VEC_alloc_1 (N MEM_STAT_INFO)) + +template +static inline vec_t * +VEC_alloc_1 (int alloc_ MEM_STAT_DECL) +{ + return vec_reserve_exact (NULL, alloc_ PASS_MEM_STAT); +} + +template +static inline vec_t * +VEC_alloc_1 (int alloc_, vec_t *space) +{ + return (vec_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 (&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 +static inline void +VEC_free_1 (vec_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 (V MEM_STAT_INFO)) + +template +static inline vec_t * +VEC_copy_1 (vec_t *vec_ MEM_STAT_DECL) +{ + size_t len_ = vec_ ? vec_->prefix.num : 0; + vec_t *new_vec_ = NULL; + + if (len_) + { + new_vec_ = vec_reserve_exact (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 (V, R VEC_CHECK_INFO)) + +template +static inline int +VEC_space_1 (vec_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 (&(V), (int)(R) VEC_CHECK_INFO MEM_STAT_INFO)) + +template +static inline int +VEC_reserve_1 (vec_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 (*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 (&(V), R VEC_CHECK_INFO MEM_STAT_INFO)) + +template +static inline int +VEC_reserve_exact_1 (vec_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 (*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 (DST, SRC VEC_CHECK_INFO)) + +template +static inline void +VEC_splice_1 (vec_t *dst_, vec_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 (&(DST), SRC VEC_CHECK_INFO MEM_STAT_INFO)) + +template +static inline void +VEC_safe_splice_1 (vec_t **dst_, vec_t *src_ VEC_CHECK_DECL MEM_STAT_DECL) +{ + if (src_) + { + VEC_reserve_exact_1 (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 (V, O VEC_CHECK_INFO)) + +template +static inline T & +VEC_quick_push_1 (vec_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 +static inline T * +VEC_quick_push_1 (vec_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 (&(V), O VEC_CHECK_INFO MEM_STAT_INFO)) + +template +static inline T & +VEC_safe_push_1 (vec_t **vec_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) +{ + VEC_reserve_1 (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); + return VEC_quick_push_1 (*vec_, obj_ VEC_CHECK_PASS); +} + +template +static inline T * +VEC_safe_push_1 (vec_t **vec_, const T *ptr_ VEC_CHECK_DECL MEM_STAT_DECL) +{ + VEC_reserve_1 (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 (V VEC_CHECK_INFO)) + +template +static inline T& +VEC_pop_1 (vec_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 (V, (unsigned)(I) VEC_CHECK_INFO)) + +template +static inline void +VEC_truncate_1 (vec_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 (&(V), (int)(I) VEC_CHECK_INFO MEM_STAT_INFO)) + +template +static inline void +VEC_safe_grow_1 (vec_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 (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 (&(V), (int)(I) \ + VEC_CHECK_INFO MEM_STAT_INFO)) + +template +static inline void +VEC_safe_grow_cleared_1 (vec_t **vec_, int size_ VEC_CHECK_DECL + MEM_STAT_DECL) +{ + int oldsize = VEC_length (T, *vec_); + VEC_safe_grow_1 (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 (V, (unsigned)(I), O VEC_CHECK_INFO)) + +template +static inline T& +VEC_replace_1 (vec_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 (V,I,O VEC_CHECK_INFO)) + +template +static inline void +VEC_quick_insert_1 (vec_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 +static inline void +VEC_quick_insert_1 (vec_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 (&(V),I,O VEC_CHECK_INFO MEM_STAT_INFO)) + +template +static inline void +VEC_safe_insert_1 (vec_t **vec_, unsigned ix_, T obj_ + VEC_CHECK_DECL MEM_STAT_DECL) +{ + VEC_reserve_1 (vec_, 1 VEC_CHECK_PASS PASS_MEM_STAT); + VEC_quick_insert_1 (*vec_, ix_, obj_ VEC_CHECK_PASS); +} + +template +static inline void +VEC_safe_insert_1 (vec_t **vec_, unsigned ix_, T *ptr_ + VEC_CHECK_DECL MEM_STAT_DECL) +{ + VEC_reserve_1 (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 (V,I VEC_CHECK_INFO)) + +template +static inline void +VEC_ordered_remove_1 (vec_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 (V,I VEC_CHECK_INFO)) + +template +static inline void +VEC_unordered_remove_1 (vec_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 (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 +static inline void +VEC_block_remove_1 (vec_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 (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 +static inline unsigned +VEC_lower_bound_1 (vec_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 +static inline unsigned +VEC_lower_bound_1 (vec_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 +vec_t * +vec_reserve (vec_t *vec_, int reserve MEM_STAT_DECL) +{ + if (A == gc) + return (vec_t *) vec_gc_o_reserve_1 (vec_, reserve, + offsetof (vec_t, vec), + sizeof (T), false + PASS_MEM_STAT); + else if (A == heap) + return (vec_t *) vec_heap_o_reserve_1 (vec_, reserve, + offsetof (vec_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 *) vec_stack_o_reserve (vec_, reserve, + offsetof (vec_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 +vec_t * +vec_reserve_exact (vec_t *vec_, int reserve MEM_STAT_DECL) +{ + if (A == gc) + return (vec_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 *) 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 *) 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. */