From patchwork Thu Nov 15 21:53:44 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Diego Novillo X-Patchwork-Id: 199444 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 831B22C0419 for ; Fri, 16 Nov 2012 08:58:25 +1100 (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=1353621505; h=Comment: DomainKey-Signature:Received:Received:Received:Received:Received: Received:Received:Received:Date:To:Subject:User-Agent: MIME-Version:Content-Type:Content-Transfer-Encoding:Message-Id: From:Mailing-List:Precedence:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:Sender:Delivered-To; bh=TP9Ixh4 v6E6LVwvSrl8KS2WsP/k=; b=sLuVzxX34sPSnYlq4g1m13l1Ly1cDqZUGIdPJ2L QYUrGgUNYEskjBNw66l05qfAGkZHDj3uF4xfRbM5sZO6CJu3eIKBU8H0pF7vtkER 2C7eKo7oI1KQ3wP/1xIee/7ic6+we9ACjpcmqDnyAMJFcC+EzREUExT79lZj03Vf 0qQ0= 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:Date:To:Subject:User-Agent:MIME-Version:Content-Type:Content-Transfer-Encoding:Message-Id:From:X-Gm-Message-State:X-IsSubscribed:Mailing-List:Precedence:List-Id:List-Unsubscribe:List-Archive:List-Post:List-Help:Sender:Delivered-To; b=GiduTzC2Fnmv/L/EqRunl1Et+wMsockmpFkEfTYpn0YXcOQRYGmUX9tnAlWYpT GMzIs8imBhAYlOZInMgcGOjKFoCGekSUwQmb8ndO7aQJdpp7+/znJEn94PegF7Hs IpZdzFzR1WRzxfWz6St9Y4W3f+qkzuUx75GODTMSP+Y34=; Received: (qmail 11825 invoked by alias); 15 Nov 2012 21:54:40 -0000 Received: (qmail 11761 invoked by uid 22791); 15 Nov 2012 21:54:38 -0000 X-SWARE-Spam-Status: No, hits=-3.9 required=5.0 tests=AWL, BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, KHOP_RCVD_TRUST, RCVD_IN_DNSWL_LOW, RCVD_IN_HOSTKARMA_YE, RP_MATCHES_RCVD, SARE_OBFU_PART_INA, TW_CX, TW_GC, TW_JC X-Spam-Check-By: sourceware.org Received: from mail-la0-f73.google.com (HELO mail-la0-f73.google.com) (209.85.215.73) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 15 Nov 2012 21:53:49 +0000 Received: by mail-la0-f73.google.com with SMTP id d3so136138lah.2 for ; Thu, 15 Nov 2012 13:53:46 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=date:to:subject:user-agent:mime-version:content-type :content-transfer-encoding:message-id:from:x-gm-message-state; bh=aZibPHQPBr5EPTe541Lqap2Ry2bqNUnMzsgu8x1ymkQ=; b=ZC1WuQRs8ak6+SMm5l7M2T3XMNf7B0G9WQwUPU3ERtGiN9jmAhFlz8a4eB4XdRbewz s05g61U7k17UFpfrkSCYFYeowcqjGAAQznXW9sTTv6DXHO/SL/VNdDfdjEz6wmZbdZ0w 6pHlyA0Rzdsn0da67QMAHYvt/nxuSWPhgs3LNE+lfc56ETdevL3+16l/NVoNC6VceVxM J+OHTbWdXpw086hoiQ8FWEniFkYiuO/UKcR4cY/84R57lrsFoh5htMmFgowuYbbPxfM7 SV9h7tMM5V/O9N4r7/2xH+vHngQAxJz0OKlXJJDAPnXPJYrqy36+ZXJpEJV2zcwipLwb VWHQ== Received: by 10.14.2.199 with SMTP id 47mr3299470eef.5.1353016425768; Thu, 15 Nov 2012 13:53:45 -0800 (PST) Received: from hpza10.eem.corp.google.com ([74.125.121.33]) by gmr-mx.google.com with ESMTPS id z47si4118325eel.0.2012.11.15.13.53.45 (version=TLSv1/SSLv3 cipher=AES128-SHA); Thu, 15 Nov 2012 13:53:45 -0800 (PST) Received: from torture.tor.corp.google.com (torture.tor.corp.google.com [172.30.222.16]) by hpza10.eem.corp.google.com (Postfix) with ESMTP id 39488200301; Thu, 15 Nov 2012 13:53:45 -0800 (PST) Received: by torture.tor.corp.google.com (Postfix, from userid 54752) id 77D95C0916; Thu, 15 Nov 2012 16:53:44 -0500 (EST) Date: Thu, 15 Nov 2012 16:53:44 -0500 To: aph@redhat.com, gcc-patches@gcc.gnu.org Subject: VEC re-write [patch 09/25] User-Agent: Heirloom mailx 12.5 6/20/10 MIME-Version: 1.0 Message-Id: <20121115215344.77D95C0916@torture.tor.corp.google.com> From: dnovillo@google.com (Diego Novillo) X-Gm-Message-State: ALoCoQmxW1ZD/r8yAN4eHwMVLqPo9RmA7N5XhlX9jGI2QIkNHGn3QfTNa1oX6Sq+41rMfOcXt3s2DkD6w9RuVCbvZb1Veg0EdOzN7eIdnygHefy7YTmfmR/gImklQDBcLtiDH+gC1FrPig9O7w/dKfbT6TZu0bSlanWCJ+j8EA+NB1PVXSbDy3x7a/JL4Dm8hHCd5jUuFP68NThAwZ2gLxsygI0jRj+0Pmxjuou5/SjGSq9uAUQ5FNQ= 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 2012-11-15 Diego Novillo Adjust for new vec API (http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec) * boehm.c: Use new vec API in vec.h. * class.c: Likewise. * constants.c: Likewise. * decl.c: Likewise. * expr.c: Likewise. * java-tree.h: Likewise. * jcf-parse.c: Likewise. * resource.c: Likewise. * verify-glue.c: Likewise. diff --git a/gcc/java/boehm.c b/gcc/java/boehm.c index 0fa8964..e125883 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 = (*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 a89b831..7465a9b 100644 --- a/gcc/java/class.c +++ b/gcc/java/class.c @@ -40,7 +40,6 @@ The Free Software Foundation is independent of Sun Microsystems, Inc. */ #include "ggc.h" #include "cgraph.h" #include "tree-iterator.h" -#include "vecprim.h" #include "target.h" static tree make_method_value (tree); @@ -98,7 +97,7 @@ static GTY(()) tree class_roots[4]; #define class_list class_roots[2] #define class_dtable_decl class_roots[3] -static GTY(()) VEC(tree,gc) *registered_class; +static GTY(()) vec *registered_class; /* A tree that returns the address of the class$ of the class currently being compiled. */ @@ -106,7 +105,7 @@ static GTY(()) tree this_classdollar; /* A list of static class fields. This is to emit proper debug info for them. */ -VEC(tree,gc) *pending_static_fields; +vec *pending_static_fields; /* Return the node that most closely represents the class whose name is IDENT. Start the search from NODE (followed by its siblings). @@ -878,7 +877,7 @@ add_field (tree klass, tree name, tree field_type, int flags) object file. */ DECL_EXTERNAL (field) = (is_compiled_class (klass) != 2); if (!DECL_EXTERNAL (field)) - VEC_safe_push (tree, gc, pending_static_fields, field); + vec_safe_push (pending_static_fields, field); } return field; @@ -941,7 +940,7 @@ build_utf8_ref (tree name) int name_hash; tree ref = IDENTIFIER_UTF8_REF (name); tree decl; - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; if (ref != NULL_TREE) return ref; @@ -1422,7 +1421,7 @@ make_field_value (tree fdecl) int flags; tree type = TREE_TYPE (fdecl); int resolved = is_compiled_class (type) && ! flag_indirect_dispatch; - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; START_RECORD_CONSTRUCTOR (v, field_type_node); PUSH_FIELD_VALUE (v, "name", build_utf8_ref (DECL_NAME (fdecl))); @@ -1480,7 +1479,7 @@ make_method_value (tree mdecl) tree class_decl; #define ACC_TRANSLATED 0x4000 int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED; - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; class_decl = DECL_CONTEXT (mdecl); /* For interfaces, the index field contains the dispatch index. */ @@ -1520,29 +1519,29 @@ make_method_value (tree mdecl) /* Compute the `throws' information for the method. */ tree table = null_pointer_node; - if (!VEC_empty (tree, DECL_FUNCTION_THROWS (mdecl))) + if (!vec_safe_is_empty (DECL_FUNCTION_THROWS (mdecl))) { - int length = 1 + VEC_length (tree, DECL_FUNCTION_THROWS (mdecl)); + int length = 1 + DECL_FUNCTION_THROWS (mdecl)->length (); tree t, type, array; char buf[60]; - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; int idx = length - 1; unsigned ix; constructor_elt *e; - v = VEC_alloc (constructor_elt, gc, length); - VEC_safe_grow_cleared (constructor_elt, gc, v, length); + vec_alloc (v, length); + v->quick_grow_cleared (length); - e = &VEC_index (constructor_elt, v, idx--); + e = &(*v)[idx--]; e->value = null_pointer_node; - FOR_EACH_VEC_ELT (tree, DECL_FUNCTION_THROWS (mdecl), ix, t) + FOR_EACH_VEC_SAFE_ELT (DECL_FUNCTION_THROWS (mdecl), ix, t) { tree sig = DECL_NAME (TYPE_NAME (t)); tree utf8 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig), - IDENTIFIER_LENGTH (sig))); - e = &VEC_index (constructor_elt, v, idx--); + IDENTIFIER_LENGTH (sig))); + e = &(*v)[idx--]; e->value = utf8; } gcc_assert (idx == -1); @@ -1611,7 +1610,7 @@ get_dispatch_table (tree type, tree this_class_addr) int nvirtuals = TREE_VEC_LENGTH (vtable); int arraysize; tree gc_descr; - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; constructor_elt *e; tree arraytype; @@ -1620,8 +1619,8 @@ get_dispatch_table (tree type, tree this_class_addr) arraysize *= TARGET_VTABLE_USES_DESCRIPTORS; arraysize += 2; - VEC_safe_grow_cleared (constructor_elt, gc, v, arraysize); - e = &VEC_index (constructor_elt, v, arraysize - 1); + vec_safe_grow_cleared (v, arraysize); + e = &(*v)[arraysize - 1]; #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E-- for (i = nvirtuals; --i >= 0; ) @@ -1674,7 +1673,7 @@ get_dispatch_table (tree type, tree this_class_addr) /** Pointer to type_info object (to be implemented), according to g++ ABI. */ CONSTRUCTOR_PREPEND_VALUE (e, null_pointer_node); /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */ - gcc_assert (e == VEC_address (constructor_elt, v)); + gcc_assert (e == v->address ()); e->index = integer_zero_node; e->value = null_pointer_node; #undef CONSTRUCTOR_PREPEND_VALUE @@ -1737,8 +1736,8 @@ supers_all_compiled (tree type) } static void -add_table_and_syms (VEC(constructor_elt,gc) **v, - VEC(method_entry,gc) *methods, +add_table_and_syms (vec **v, + vec *methods, const char *table_name, tree table_slot, tree table_type, const char *syms_name, tree syms_slot) { @@ -1785,13 +1784,13 @@ make_class_data (tree type) /** Offset from start of virtual function table declaration to where objects actually point at, following new g++ ABI. */ tree dtable_start_offset = size_int (2 * POINTER_SIZE / BITS_PER_UNIT); - VEC(int, heap) *field_indexes; + vec field_indexes; tree first_real_field; - VEC(constructor_elt,gc) *v1 = NULL, *v2 = NULL; + vec *v1 = NULL, *v2 = NULL; tree reflection_data; - VEC(constructor_elt,gc) *static_fields = NULL; - VEC(constructor_elt,gc) *instance_fields = NULL; - VEC(constructor_elt,gc) *methods = NULL; + vec *static_fields = NULL; + vec *instance_fields = NULL; + vec *methods = NULL; this_class_addr = build_static_class_ref (type); decl = TREE_OPERAND (this_class_addr, 0); @@ -1850,7 +1849,7 @@ make_class_data (tree type) } } field_count = static_field_count + instance_field_count; - field_indexes = VEC_alloc (int, heap, field_count); + field_indexes.create (field_count); /* gcj sorts fields so that static fields come first, followed by instance fields. Unfortunately, by the time this takes place we @@ -1879,7 +1878,7 @@ make_class_data (tree type) field_index = instance_count++; else continue; - VEC_quick_push (int, field_indexes, field_index); + field_indexes.quick_push (field_index); } } } @@ -1912,14 +1911,12 @@ make_class_data (tree type) } } - gcc_assert (static_field_count - == (int) VEC_length (constructor_elt, static_fields)); - gcc_assert (instance_field_count - == (int) VEC_length (constructor_elt, instance_fields)); + gcc_assert (static_field_count == (int) vec_safe_length (static_fields)); + gcc_assert (instance_field_count == (int) vec_safe_length (instance_fields)); if (field_count > 0) { - VEC_safe_splice (constructor_elt, gc, static_fields, instance_fields); + vec_safe_splice (static_fields, instance_fields); field_array_type = build_prim_array_type (field_type_node, field_count); fields_decl = build_decl (input_location, VAR_DECL, mangled_classname ("_FL_", type), @@ -2021,8 +2018,8 @@ make_class_data (tree type) { int i; tree interface_array_type, idecl; - VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc, - interface_len); + vec *init; + vec_alloc (init, interface_len); interface_array_type = build_prim_array_type (class_ptr_type, interface_len); idecl = build_decl (input_location, @@ -2143,7 +2140,7 @@ make_class_data (tree type) "itable_syms", TYPE_ITABLE_SYMS_DECL (type)); PUSH_FIELD_VALUE (v2, "catch_classes", - build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type))); + build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type))); PUSH_FIELD_VALUE (v2, "interfaces", interfaces); PUSH_FIELD_VALUE (v2, "loader", null_pointer_node); PUSH_FIELD_VALUE (v2, "interface_count", @@ -2180,8 +2177,8 @@ make_class_data (tree type) { int i; int count = TYPE_REFLECTION_DATASIZE (current_class); - VEC (constructor_elt, gc) *v - = VEC_alloc (constructor_elt, gc, count); + vec *v; + vec_alloc (v, count); unsigned char *data = TYPE_REFLECTION_DATA (current_class); tree max_index = build_int_cst (sizetype, count); tree index = build_index_type (max_index); @@ -2194,14 +2191,14 @@ make_class_data (tree type) array = build_decl (input_location, VAR_DECL, get_identifier (buf), type); - rewrite_reflection_indexes (field_indexes); + rewrite_reflection_indexes (&field_indexes); for (i = 0; i < count; i++) { constructor_elt elt; elt.index = build_int_cst (sizetype, i); elt.value = build_int_cstu (byte_type_node, data[i]); - VEC_quick_push (constructor_elt, v, elt); + v->quick_push (elt); } DECL_INITIAL (array) = build_constructor (type, v); @@ -2727,13 +2724,13 @@ register_class (void) tree node; if (!registered_class) - registered_class = VEC_alloc (tree, gc, 8); + vec_alloc (registered_class, 8); if (flag_indirect_classes) node = current_class; else node = TREE_OPERAND (build_class_ref (current_class), 0); - VEC_safe_push (tree, gc, registered_class, node); + vec_safe_push (registered_class, node); } /* Emit a function that calls _Jv_RegisterNewClasses with a list of @@ -2745,15 +2742,16 @@ emit_indirect_register_classes (tree *list_p) tree klass, t, register_class_fn; int i; - int size = VEC_length (tree, registered_class) * 2 + 1; - VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc, size); + int size = vec_safe_length (registered_class) * 2 + 1; + vec *init; + vec_alloc (init, size); tree class_array_type = build_prim_array_type (ptr_type_node, size); tree cdecl = build_decl (input_location, VAR_DECL, get_identifier ("_Jv_CLS"), class_array_type); tree reg_class_list; - FOR_EACH_VEC_ELT (tree, registered_class, i, klass) + FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass) { t = fold_convert (ptr_type_node, build_static_class_ref (klass)); CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, t); @@ -2792,10 +2790,11 @@ emit_register_classes_in_jcr_section (void) #ifdef JCR_SECTION_NAME tree klass, cdecl, class_array_type; int i; - int size = VEC_length (tree, registered_class); - VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc, size); + int size = vec_safe_length (registered_class); + vec *init; + vec_alloc (init, size); - FOR_EACH_VEC_ELT (tree, registered_class, i, klass) + FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass) CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, build_fold_addr_expr (klass)); /* ??? I would like to use tree_output_constant_def() but there is no way @@ -2844,7 +2843,7 @@ emit_Jv_RegisterClass_calls (tree *list_p) DECL_EXTERNAL (t) = 1; register_class_fn = t; - FOR_EACH_VEC_ELT (tree, registered_class, i, klass) + FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass) { t = build_fold_addr_expr (klass); t = build_call_expr (register_class_fn, 1, t); @@ -2890,7 +2889,7 @@ static tree build_symbol_table_entry (tree clname, tree name, tree signature) { tree symbol; - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; START_RECORD_CONSTRUCTOR (v, symbol_type); PUSH_FIELD_VALUE (v, "clname", clname); @@ -2935,22 +2934,22 @@ build_symbol_entry (tree decl, tree special) tree emit_symbol_table (tree name, tree the_table, - VEC(method_entry,gc) *decl_table, + vec *decl_table, tree the_syms_decl, tree the_array_element_type, int element_size) { tree table, null_symbol, table_size, the_array_type; unsigned index; method_entry *e; - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; /* Only emit a table if this translation unit actually made any references via it. */ - if (decl_table == NULL) + if (!decl_table) return the_table; /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */ - FOR_EACH_VEC_ELT (method_entry, decl_table, index, e) + FOR_EACH_VEC_ELT (*decl_table, index, e) CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_symbol_entry (e->method, e->special)); @@ -2990,7 +2989,7 @@ make_catch_class_record (tree catch_class, tree classname) { tree entry; tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class))); - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; START_RECORD_CONSTRUCTOR (v, type); PUSH_FIELD_VALUE (v, "address", catch_class); PUSH_FIELD_VALUE (v, "classname", classname); @@ -3008,13 +3007,12 @@ 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 = &(*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, null_pointer_node)); - n_catch_classes = VEC_length (constructor_elt, - TYPE_CATCH_CLASSES (this_class)); + n_catch_classes = TYPE_CATCH_CLASSES (this_class)->length (); table_size = build_index_type (build_int_cst (NULL_TREE, n_catch_classes)); array_type = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))), @@ -3052,7 +3050,7 @@ build_signature_for_libgcj (tree type) static tree build_assertion_table_entry (tree code, tree op1, tree op2) { - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; tree entry; START_RECORD_CONSTRUCTOR (v, assertion_entry_type); @@ -3072,7 +3070,8 @@ add_assertion_table_entry (void **htab_entry, void *ptr) { tree entry; tree code_val, op1_utf8, op2_utf8; - VEC(constructor_elt,gc) **v = (VEC(constructor_elt,gc) **) ptr; + vec **v + = ((vec **) ptr); type_assertion *as = (type_assertion *) *htab_entry; code_val = build_int_cst (NULL_TREE, as->assertion_code); @@ -3100,7 +3099,7 @@ emit_assertion_table (tree klass) { tree null_entry, ctor, table_decl; htab_t assertions_htab = TYPE_ASSERTIONS (klass); - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; /* Iterate through the hash table. */ htab_traverse (assertions_htab, add_assertion_table_entry, &v); @@ -3266,11 +3265,11 @@ in_same_package (tree name1, tree name2) void java_write_globals (void) { - tree *vec = VEC_address (tree, pending_static_fields); - int len = VEC_length (tree, pending_static_fields); + tree *vec = vec_safe_address (pending_static_fields); + int len = vec_safe_length (pending_static_fields); write_global_declarations (); emit_debug_global_declarations (vec, len); - VEC_free (tree, gc, pending_static_fields); + vec_free (pending_static_fields); } #include "gt-java-class.h" diff --git a/gcc/java/constants.c b/gcc/java/constants.c index c709fa4..653c3c2 100644 --- a/gcc/java/constants.c +++ b/gcc/java/constants.c @@ -502,20 +502,20 @@ build_constants_constructor (void) CPool *outgoing_cpool = cpool_for_class (current_class); tree tags_value, data_value; tree cons; - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; int i; - VEC(constructor_elt,gc) *tags = NULL; - VEC(constructor_elt,gc) *data = NULL; + vec *tags = NULL; + vec *data = NULL; constructor_elt *t = NULL; constructor_elt *d = NULL; if (outgoing_cpool->count > 0) { 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); + vec_safe_grow_cleared (tags, c); + vec_safe_grow_cleared (data, c); + t = &(*tags)[c-1]; + d = &(*data)[c-1]; } #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E-- @@ -569,8 +569,8 @@ build_constants_constructor (void) tree tem; /* Add dummy 0'th element of constant pool. */ - gcc_assert (t == VEC_address (constructor_elt, tags)); - gcc_assert (d == VEC_address (constructor_elt, data)); + gcc_assert (t == tags->address ()); + gcc_assert (d == data->address ()); t->value = get_tag_node (0); d->value = null_pointer_node; diff --git a/gcc/java/decl.c b/gcc/java/decl.c index 30048fd..c1ddd57 100644 --- a/gcc/java/decl.c +++ b/gcc/java/decl.c @@ -1953,7 +1953,7 @@ java_mark_class_local (tree klass) if (FIELD_STATIC (t)) { if (DECL_EXTERNAL (t)) - VEC_safe_push (tree, gc, pending_static_fields, t); + vec_safe_push (pending_static_fields, t); java_mark_decl_local (t); } diff --git a/gcc/java/expr.c b/gcc/java/expr.c index 8041cdd..0f6e465 100644 --- a/gcc/java/expr.c +++ b/gcc/java/expr.c @@ -74,7 +74,7 @@ static void expand_cond (enum tree_code, tree, int); static void expand_java_goto (int); static tree expand_java_switch (tree, int); static void expand_java_add_case (tree, int, int); -static VEC(tree,gc) *pop_arguments (tree); +static vec *pop_arguments (tree); static void expand_invoke (int, int, int); static void expand_java_field_op (int, int, int); static void java_push_constant_from_pool (struct JCF *, int); @@ -96,7 +96,7 @@ tree dtable_ident = NULL_TREE; int always_initialize_class_p = 0; /* We store the stack state in two places: - Within a basic block, we use the quick_stack, which is a VEC of expression + Within a basic block, we use the quick_stack, which is a vec of expression nodes. This is the top part of the stack; below that we use find_stack_slot. At the end of a basic block, the quick_stack must be flushed @@ -122,7 +122,7 @@ int always_initialize_class_p = 0; So dup cannot just add an extra element to the quick_stack, but iadd can. */ -static GTY(()) VEC(tree,gc) *quick_stack; +static GTY(()) vec *quick_stack; /* The physical memory page size used in this computer. See build_field_ref(). */ @@ -222,10 +222,10 @@ flush_quick_stack (void) tree t; /* Count the number of slots the quick stack is holding. */ - for (ix = 0; VEC_iterate(tree, quick_stack, ix, t); ix++) + for (ix = 0; vec_safe_iterate (quick_stack, ix, &t); ix++) stack_index -= 1 + TYPE_IS_WIDE (TREE_TYPE (t)); - for (ix = 0; VEC_iterate(tree, quick_stack, ix, t); ix++) + for (ix = 0; vec_safe_iterate (quick_stack, ix, &t); ix++) { tree decl, type = TREE_TYPE (t); @@ -235,7 +235,7 @@ flush_quick_stack (void) stack_index += 1 + TYPE_IS_WIDE (type); } - VEC_truncate (tree, quick_stack, 0); + vec_safe_truncate (quick_stack, 0); } /* Push TYPE on the type stack. @@ -276,7 +276,7 @@ push_value (tree value) value = convert (type, value); } push_type (type); - VEC_safe_push (tree, gc, quick_stack, value); + vec_safe_push (quick_stack, value); /* If the value has a side effect, then we need to evaluate it whether or not the result is used. If the value ends up on the @@ -590,8 +590,8 @@ static tree pop_value (tree type) { type = pop_type (type); - if (VEC_length (tree, quick_stack) != 0) - return VEC_pop (tree, quick_stack); + if (vec_safe_length (quick_stack) != 0) + return quick_stack->pop (); else return find_stack_slot (stack_pointer, promote_type (type)); } @@ -1100,17 +1100,17 @@ static void expand_java_multianewarray (tree class_type, int ndim) { int i; - VEC(tree,gc) *args = NULL; + vec *args = NULL; - VEC_safe_grow (tree, gc, args, 3 + ndim); + vec_safe_grow (args, 3 + ndim); - VEC_replace (tree, args, 0, build_class_ref (class_type)); - VEC_replace (tree, args, 1, build_int_cst (NULL_TREE, ndim)); + (*args)[0] = build_class_ref (class_type); + (*args)[1] = build_int_cst (NULL_TREE, ndim); for(i = ndim - 1; i >= 0; i-- ) - VEC_replace (tree, args, (unsigned)(2 + i), pop_value (int_type_node)); + (*args)[(unsigned)(2 + i)] = pop_value (int_type_node); - VEC_replace (tree, args, 2 + ndim, null_pointer_node); + (*args)[2 + ndim] = null_pointer_node; push_value (build_call_vec (promote_type (class_type), build_address_of (soft_multianewarray_node), @@ -1808,7 +1808,7 @@ char *instruction_bits; indexed by PC. Each element is a tree vector holding the type state at that PC. We only note type states at basic block boundaries. */ -VEC(tree, gc) *type_states; +vec *type_states; static void note_label (int current_pc ATTRIBUTE_UNUSED, int target_pc) @@ -1901,12 +1901,12 @@ expand_java_add_case (tree switch_expr, int match, int target_pc) append_to_statement_list (x, &SWITCH_BODY (switch_expr)); } -static VEC(tree,gc) * +static vec * pop_arguments (tree method_type) { function_args_iterator fnai; tree type; - VEC(tree,gc) *args = NULL; + vec *args = NULL; int arity; FOREACH_FUNCTION_ARGS (method_type, type, fnai) @@ -1915,14 +1915,14 @@ pop_arguments (tree method_type) if (type == void_type_node) break; - VEC_safe_push (tree, gc, args, type); + vec_safe_push (args, type); } - arity = VEC_length (tree, args); + arity = vec_safe_length (args); while (arity--) { - tree arg = pop_value (VEC_index (tree, args, arity)); + tree arg = pop_value ((*args)[arity]); /* We simply cast each argument to its proper type. This is needed since we lose type information coming out of the @@ -1935,7 +1935,7 @@ pop_arguments (tree method_type) && INTEGRAL_TYPE_P (type)) arg = convert (integer_type_node, arg); - VEC_replace (tree, args, arity, arg); + (*args)[arity] = arg; } return args; @@ -2063,14 +2063,14 @@ typedef struct const char *new_classname; const char *new_signature; int flags; - void (*rewrite_arglist) (VEC(tree,gc) **); + void (*rewrite_arglist) (vec **); } rewrite_rule; /* Add __builtin_return_address(0) to the end of an arglist. */ static void -rewrite_arglist_getcaller (VEC(tree,gc) **arglist) +rewrite_arglist_getcaller (vec **arglist) { tree retaddr = build_call_expr (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS), @@ -2078,15 +2078,15 @@ rewrite_arglist_getcaller (VEC(tree,gc) **arglist) DECL_UNINLINABLE (current_function_decl) = 1; - VEC_safe_push (tree, gc, *arglist, retaddr); + vec_safe_push (*arglist, retaddr); } /* Add this.class to the end of an arglist. */ static void -rewrite_arglist_getclass (VEC(tree,gc) **arglist) +rewrite_arglist_getclass (vec **arglist) { - VEC_safe_push (tree, gc, *arglist, build_class_ref (output_class)); + vec_safe_push (*arglist, build_class_ref (output_class)); } static rewrite_rule rules[] = @@ -2137,7 +2137,7 @@ special_method_p (tree candidate_method) method, update SPECIAL.*/ void -maybe_rewrite_invocation (tree *method_p, VEC(tree,gc) **arg_list_p, +maybe_rewrite_invocation (tree *method_p, vec **arg_list_p, tree *method_signature_p, tree *special) { tree context = DECL_NAME (TYPE_NAME (DECL_CONTEXT (*method_p))); @@ -2185,7 +2185,7 @@ maybe_rewrite_invocation (tree *method_p, VEC(tree,gc) **arg_list_p, tree build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED, tree self_type, tree method_signature ATTRIBUTE_UNUSED, - VEC(tree,gc) *arg_list ATTRIBUTE_UNUSED, tree special) + vec *arg_list ATTRIBUTE_UNUSED, tree special) { tree func; if (is_compiled_class (self_type)) @@ -2261,12 +2261,12 @@ build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED, } tree -invoke_build_dtable (int is_invoke_interface, VEC(tree,gc) *arg_list) +invoke_build_dtable (int is_invoke_interface, vec *arg_list) { tree dtable, objectref; - tree saved = save_expr (VEC_index (tree, arg_list, 0)); + tree saved = save_expr ((*arg_list)[0]); - VEC_replace (tree, arg_list, 0, saved); + (*arg_list)[0] = saved; /* If we're dealing with interfaces and if the objectref argument is an array then get the dispatch table of the class @@ -2292,17 +2292,17 @@ invoke_build_dtable (int is_invoke_interface, VEC(tree,gc) *arg_list) int get_symbol_table_index (tree t, tree special, - VEC(method_entry,gc) **symbol_table) + vec **symbol_table) { method_entry *e; unsigned i; method_entry elem = {t, special}; - FOR_EACH_VEC_ELT (method_entry, *symbol_table, i, e) + FOR_EACH_VEC_SAFE_ELT (*symbol_table, i, e) if (t == e->method && special == e->special) goto done; - VEC_safe_push (method_entry, gc, *symbol_table, elem); + vec_safe_push (*symbol_table, elem); done: return i + 1; @@ -2428,7 +2428,7 @@ expand_invoke (int opcode, int method_ref_index, int nargs ATTRIBUTE_UNUSED) const char *const self_name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type))); tree call, func, method, method_type; - VEC(tree,gc) *arg_list; + vec *arg_list; tree check = NULL_TREE; tree special = NULL_TREE; @@ -2569,8 +2569,8 @@ expand_invoke (int opcode, int method_ref_index, int nargs ATTRIBUTE_UNUSED) We do omit the check if we're calling . */ /* We use a SAVE_EXPR here to make sure we only evaluate the new `self' expression once. */ - tree save_arg = save_expr (VEC_index (tree, arg_list, 0)); - VEC_replace (tree, arg_list, 0, save_arg); + tree save_arg = save_expr ((*arg_list)[0]); + (*arg_list)[0] = save_arg; check = java_check_reference (save_arg, ! DECL_INIT_P (method)); func = build_known_method_ref (method, method_type, self_type, method_signature, arg_list, special); @@ -2622,7 +2622,7 @@ build_jni_stub (tree method) tree method_args; tree meth_var; tree bind; - VEC(tree,gc) *args = NULL; + vec *args = NULL; int args_size = 0; tree klass = DECL_CONTEXT (method); @@ -2657,7 +2657,7 @@ build_jni_stub (tree method) /* The JNIEnv structure is the first argument to the JNI function. */ args_size += int_size_in_bytes (TREE_TYPE (env_var)); - VEC_safe_push (tree, gc, args, env_var); + vec_safe_push (args, env_var); /* For a static method the second argument is the class. For a non-static method the second argument is `this'; that is already @@ -2665,7 +2665,7 @@ build_jni_stub (tree method) if (METHOD_STATIC (method)) { args_size += int_size_in_bytes (TREE_TYPE (klass)); - VEC_safe_push (tree, gc, args, klass); + vec_safe_push (args, klass); } /* All the arguments to this method become arguments to the @@ -2680,7 +2680,7 @@ build_jni_stub (tree method) #endif args_size += (arg_bits / BITS_PER_UNIT); - VEC_safe_push (tree, gc, args, tem); + vec_safe_push (args, tem); } arg_types = TYPE_ARG_TYPES (TREE_TYPE (method)); @@ -2967,7 +2967,7 @@ static void load_type_state (int pc) { int i; - tree vec = VEC_index (tree, type_states, pc); + tree vec = (*type_states)[pc]; int cur_length = TREE_VEC_LENGTH (vec); stack_pointer = cur_length - DECL_MAX_LOCALS(current_function_decl); for (i = 0; i < cur_length; i++) @@ -3010,8 +3010,8 @@ note_instructions (JCF *jcf, tree method) byte_ops = jcf->read_ptr; instruction_bits = XRESIZEVAR (char, instruction_bits, length + 1); memset (instruction_bits, 0, length + 1); - type_states = VEC_alloc (tree, gc, length + 1); - VEC_safe_grow_cleared (tree, gc, type_states, length + 1); + vec_alloc (type_states, length + 1); + type_states->quick_grow_cleared (length + 1); /* This pass figures out which PC can be the targets of jumps. */ for (PC = 0; PC < length;) diff --git a/gcc/java/java-tree.h b/gcc/java/java-tree.h index 5167b9b..11b780b 100644 --- a/gcc/java/java-tree.h +++ b/gcc/java/java-tree.h @@ -724,7 +724,7 @@ struct GTY(()) lang_decl_func { int max_stack; int arg_slot_count; source_location last_line; /* End line number for a function decl */ - VEC(tree,gc) *throws_list; /* Exception specified by `throws' */ + vec *throws_list; /* Exception specified by `throws' */ tree exc_obj; /* Decl holding the exception object. */ /* Class initialization test variables */ @@ -869,8 +869,6 @@ typedef struct GTY(()) method_entry_d { tree special; } method_entry; -DEF_VEC_O(method_entry); -DEF_VEC_ALLOC_O(method_entry,gc); /* FIXME: the variable_size annotation here is needed because these types are variable-sized in some other frontends. Due to gengtype deficiency the GTY @@ -882,24 +880,24 @@ struct GTY((variable_size)) lang_type { tree cpool_data_ref; /* Cached */ tree package_list; /* List of package names, progressive */ - VEC(method_entry,gc) *otable_methods; /* List of static decls referred + vec *otable_methods; /* List of static decls referred to by this class. */ tree otable_decl; /* The static address table. */ tree otable_syms_decl; - VEC(method_entry,gc) *atable_methods; /* List of abstract methods + vec *atable_methods; /* List of abstract methods referred to by this class. */ tree atable_decl; /* The static address table. */ tree atable_syms_decl; - VEC(method_entry,gc) *itable_methods; /* List of interface methods + vec *itable_methods; /* List of interface methods referred to by this class. */ tree itable_decl; /* The interfaces table. */ tree itable_syms_decl; tree ctable_decl; /* The table of classes for the runtime type matcher. */ - VEC(constructor_elt,gc) *catch_classes; + vec *catch_classes; htab_t GTY ((param_is (struct treetreehash_entry))) type_to_runtime_map; /* The mapping of classes to exception region @@ -1016,14 +1014,16 @@ extern void initialize_builtins (void); extern tree lookup_name (tree); extern bool special_method_p (tree); -extern void maybe_rewrite_invocation (tree *, VEC(tree,gc) **, tree *, tree *); -extern tree build_known_method_ref (tree, tree, tree, tree, VEC(tree,gc) *, tree); +extern void maybe_rewrite_invocation (tree *, vec **, tree *, + tree *); +extern tree build_known_method_ref (tree, tree, tree, tree, vec *, + tree); extern tree build_class_init (tree, tree); extern int attach_init_test_initialization_flags (void **, void *); extern tree build_invokevirtual (tree, tree, tree); extern tree build_invokeinterface (tree, tree); extern tree build_jni_stub (tree); -extern tree invoke_build_dtable (int, VEC(tree,gc) *); +extern tree invoke_build_dtable (int, vec *); extern tree build_field_ref (tree, tree, tree); extern tree java_modify_addr_for_volatile (tree); extern void pushdecl_force_head (tree); @@ -1062,7 +1062,7 @@ extern void make_class_data (tree); extern int alloc_name_constant (int, tree); extern int alloc_constant_fieldref (tree, tree); extern void emit_register_classes (tree *); -extern tree emit_symbol_table (tree, tree, VEC(method_entry,gc) *, +extern tree emit_symbol_table (tree, tree, vec *, tree, tree, int); extern void lang_init_source (int); extern void write_classfile (tree); @@ -1165,7 +1165,7 @@ extern void register_exception_range(struct eh_range *, int, int); extern void finish_method (tree); extern void java_expand_body (tree); -extern int get_symbol_table_index (tree, tree, VEC(method_entry,gc) **); +extern int get_symbol_table_index (tree, tree, vec **); extern tree make_catch_class_record (tree, tree); extern tree emit_catch_table (tree); @@ -1180,7 +1180,7 @@ extern void rewrite_reflection_indexes (void *); int cxx_keyword_p (const char *name, int length); -extern GTY(()) VEC(tree,gc) *pending_static_fields; +extern GTY(()) vec *pending_static_fields; extern void java_write_globals (void); @@ -1268,7 +1268,7 @@ extern void java_write_globals (void); #define CLASS_COMPLETE_P(DECL) DECL_LANG_FLAG_2 (DECL) /* A vector used to track type states for the current method. */ -extern VEC(tree, gc) *type_states; +extern vec *type_states; /* This maps a bytecode offset (PC) to various flags, listed below (starting with BCODE_). */ @@ -1419,7 +1419,7 @@ extern tree *type_map; #define START_RECORD_CONSTRUCTOR(V, CTYPE) \ do \ { \ - V = VEC_alloc (constructor_elt, gc, 0); \ + vec_alloc (V, 0); \ CONSTRUCTOR_APPEND_ELT (V, TYPE_FIELDS (CTYPE), NULL); \ } \ while (0) @@ -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___ = &(V)->last (); \ 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___ = &(V)->last (); \ tree _next___ = DECL_CHAIN (_elt___->index); \ gcc_assert (strcmp (IDENTIFIER_POINTER (DECL_NAME (_elt___->index)), \ NAME) == 0); \ @@ -1457,7 +1457,7 @@ extern tree *type_map; #define FINISH_RECORD_CONSTRUCTOR(CONS, V, CTYPE) \ do \ { \ - VEC_pop (constructor_elt, V); \ + V->pop (); \ CONS = build_constructor (CTYPE, V); \ TREE_CONSTANT (CONS) = 0; \ } \ diff --git a/gcc/java/jcf-parse.c b/gcc/java/jcf-parse.c index 92f032cb..c97b12f 100644 --- a/gcc/java/jcf-parse.c +++ b/gcc/java/jcf-parse.c @@ -39,7 +39,6 @@ The Free Software Foundation is independent of Sun Microsystems, Inc. */ #include "ggc.h" #include "debug.h" #include "cgraph.h" -#include "vecprim.h" #include "bitmap.h" #include "target.h" @@ -86,7 +85,7 @@ static location_t file_start_location; static GTY(()) struct JCF * main_jcf; /* A list of all the class DECLs seen so far. */ -static GTY(()) VEC(tree,gc) *all_class_list; +static GTY(()) vec *all_class_list; /* The number of source files passed to us by -fsource-filename and an array of pointers to each name. Used by find_sourcefile(). */ @@ -744,7 +743,7 @@ rewrite_reflection_indexes (void *arg) { bitmap_iterator bi; unsigned int offset; - VEC(int, heap) *map = (VEC(int, heap) *) arg; + vec *map = (vec *) arg; unsigned char *data = TYPE_REFLECTION_DATA (current_class); if (map) @@ -753,7 +752,7 @@ rewrite_reflection_indexes (void *arg) { uint16 index = annotation_read_short (data + offset); annotation_rewrite_short - (VEC_index (int, map, index), data + offset); + ((*map)[index], data + offset); } } } @@ -933,12 +932,13 @@ handle_signature_attribute (int member_index, JCF *jcf, #define HANDLE_EXCEPTIONS_ATTRIBUTE(COUNT) \ { \ int n = COUNT; \ - VEC (tree,gc) *v = VEC_alloc (tree, gc, n); \ - gcc_assert (DECL_FUNCTION_THROWS (current_method) == NULL); \ + vec *v; \ + vec_alloc (v, n); \ + gcc_assert (!DECL_FUNCTION_THROWS (current_method)); \ while (--n >= 0) \ { \ tree thrown_class = get_class_constant (jcf, JCF_readu2 (jcf)); \ - VEC_quick_push (tree, v, thrown_class); \ + v->quick_push (thrown_class); \ } \ DECL_FUNCTION_THROWS (current_method) = v; \ } @@ -1480,7 +1480,7 @@ jcf_parse (JCF* jcf) if (current_class == object_type_node) layout_class_methods (object_type_node); else - VEC_safe_push (tree, gc, all_class_list, TYPE_NAME (current_class)); + vec_safe_push (all_class_list, TYPE_NAME (current_class)); } /* If we came across inner classes, load them now. */ @@ -1512,7 +1512,7 @@ static void java_layout_seen_class_methods (void) { unsigned start = 0; - unsigned end = VEC_length (tree, all_class_list); + unsigned end = vec_safe_length (all_class_list); while (1) { @@ -1521,7 +1521,7 @@ java_layout_seen_class_methods (void) for (ix = start; ix != end; ix++) { - tree decl = VEC_index (tree, all_class_list, ix); + tree decl = (*all_class_list)[ix]; tree cls = TREE_TYPE (decl); input_location = DECL_SOURCE_LOCATION (decl); @@ -1534,7 +1534,7 @@ java_layout_seen_class_methods (void) /* Note that new classes might have been added while laying out methods, changing the value of all_class_list. */ - new_length = VEC_length (tree, all_class_list); + new_length = vec_safe_length (all_class_list); if (end != new_length) { start = end; @@ -1665,12 +1665,12 @@ parse_class_file (void) input_location = save_location; } -static VEC(tree,gc) *predefined_filenames; +static vec *predefined_filenames; void add_predefined_file (tree name) { - VEC_safe_push (tree, gc, predefined_filenames, name); + vec_safe_push (predefined_filenames, name); } int @@ -1679,7 +1679,7 @@ predefined_filename_p (tree node) unsigned ix; tree f; - FOR_EACH_VEC_ELT (tree, predefined_filenames, ix, f) + FOR_EACH_VEC_SAFE_ELT (predefined_filenames, ix, f) if (f == node) return 1; @@ -1853,18 +1853,17 @@ java_parse_file (void) const char *resource_filename; /* Only one resource file may be compiled at a time. */ - gcc_assert (VEC_length (tree, all_translation_units) == 1); + gcc_assert (all_translation_units->length () == 1); resource_filename - = IDENTIFIER_POINTER - (DECL_NAME (VEC_index (tree, all_translation_units, 0))); + = IDENTIFIER_POINTER (DECL_NAME ((*all_translation_units)[0])); compile_resource_file (resource_name, resource_filename); goto finish; } current_jcf = main_jcf; - FOR_EACH_VEC_ELT (tree, all_translation_units, ix, node) + FOR_EACH_VEC_ELT (*all_translation_units, ix, node) { unsigned char magic_string[4]; char *real_path; @@ -1951,7 +1950,7 @@ java_parse_file (void) } } - FOR_EACH_VEC_ELT (tree, all_translation_units, ix, node) + FOR_EACH_VEC_ELT (*all_translation_units, ix, node) { input_location = DECL_SOURCE_LOCATION (node); if (CLASS_FILE_P (node)) diff --git a/gcc/java/resource.c b/gcc/java/resource.c index 1558dcd..52e99c4 100644 --- a/gcc/java/resource.c +++ b/gcc/java/resource.c @@ -37,13 +37,13 @@ The Free Software Foundation is independent of Sun Microsystems, Inc. */ #include "cgraph.h" /* A list of all the resources files. */ -static GTY(()) VEC(tree,gc) *resources; +static GTY(()) vec *resources; void compile_resource_data (const char *name, const char *buffer, int length) { tree rtype, field = NULL_TREE, data_type, rinit, data, decl; - VEC(constructor_elt,gc) *v = NULL; + vec *v = NULL; data_type = build_prim_array_type (unsigned_byte_type_node, strlen (name) + length); @@ -80,7 +80,7 @@ compile_resource_data (const char *name, const char *buffer, int length) rest_of_decl_compilation (decl, global_bindings_p (), 0); varpool_finalize_decl (decl); - VEC_safe_push (tree, gc, resources, decl); + vec_safe_push (resources, decl); } void @@ -100,7 +100,7 @@ write_resource_constructor (tree *list_p) register_resource_fn = t; /* Write out entries in the same order in which they were defined. */ - FOR_EACH_VEC_ELT (tree, resources, ix, decl) + FOR_EACH_VEC_ELT (*resources, ix, decl) { t = build_fold_addr_expr (decl); t = build_call_expr (register_resource_fn, 1, t); diff --git a/gcc/java/verify-glue.c b/gcc/java/verify-glue.c index c9eee07..86cd289 100644 --- a/gcc/java/verify-glue.c +++ b/gcc/java/verify-glue.c @@ -394,7 +394,7 @@ void vfy_note_stack_depth (vfy_method *method, int pc, int depth) { tree val = make_tree_vec (method->max_locals + depth); - VEC_replace (tree, type_states, pc, val); + (*type_states)[pc] = val; /* Called for side effects. */ lookup_label (pc); } @@ -409,7 +409,7 @@ vfy_note_stack_type (vfy_method *method, int pc, int slot, vfy_jclass type) if (type == object_type_node) type = object_ptr_type_node; - vec = VEC_index (tree, type_states, pc); + vec = (*type_states)[pc]; TREE_VEC_ELT (vec, slot) = type; /* Called for side effects. */ lookup_label (pc); @@ -424,7 +424,7 @@ vfy_note_local_type (vfy_method *method ATTRIBUTE_UNUSED, int pc, int slot, if (type == object_type_node) type = object_ptr_type_node; - vec = VEC_index (tree, type_states, pc); + vec = (*type_states)[pc]; TREE_VEC_ELT (vec, slot) = type; /* Called for side effects. */ lookup_label (pc);