Make CONSTRUCTOR use VEC to store initializers.

	* c-common.c (complete_array_type): Update to cope with VEC in
	CONSTRUCTOR_ELTS.
	* c-pretty-print.c (pp_c_initializer_list): Use pp_c_constructor_elts.
	(pp_c_constructor_elts): New function.
	* c-pretty-print.h (pp_c_constructor_elts): Declare.
	* c-typeck.c (build_function_call, build_c_cast, digest_init,
	struct constructor_stack, struct initializer_stack,
	constructor_elements, push_init_level, pop_init_level,
	add_pending_init, find_init_member, output_init_element): Update to
	cope with VEC in CONSTRUCTOR_ELTS.
	* coverage.c (build_fn_info_value, build_ctr_info_value,
	build_gcov_info): Likewise.
	* expr.c (categorize_ctor_elements_1, store_constructor,
	expand_expr_real_1): Likewise.
	* fold-const.c (fold_ternary): Likewise.
	* gimplify.c (gimplify_init_ctor_preeval, zero_sized_field_decl,
	gimplify_init_constructor, gimplify_expr): Likewise.
	* tree-dump.c (dequeue_and_dump): Likewise.
	* tree-inline.c (copy_tree_r): Add code to duplicate a CONSTRUCTOR
	node.
	* tree-pretty-print.c (dump_generic_node): Update to cope with VEC in
	CONSTRUCTOR_ELTS.
	* tree-sra.c (generate_element_init_1): Likewise.
	* tree-ssa-ccp.c (fold_const_aggregate_ref): Likewise.
	* tree-ssa-operands.c (get_expr_operands): Likewise.
	* tree-vect-generic.c (expand_vector_piecewise): Likewise.
	* tree-vect-transform.c (vect_get_vec_def_for_operand):
	(get_initial_def_for_reduction): Likewise.
	* tree-vn.c (set_value_handle, get_value_handle): CONSTURCTOR uses
	value handle in annotations.
	* tree.c (tree_node_kind, tree_code_size, make_node_stat,
	tree_node_structure): Add support for constr_kind.
	(build_vector_from_ctor, build_constructor_single,
	build_constructor_from_list): New functions.
	(build_constructor): Update to take a VEC instead of a TREE_LIST.
	(simple_cst_equal, iterative_hash_expr, initializer_zerop, walk_tree):
	Update to cope with VEC in CONSTRUCTOR_ELTS.
	* tree.def (CONSTRUCTOR): Make it a tcc_exceptional node.
	* tree.h (FOR_EACH_CONSTRUCTOR_VALUE, FOR_EACH_CONSTRUCTOR_ELT,
	CONSTRUCTOR_APPEND_ELT): New macros.
	(struct constructor_elt, struct	tree_constructor): New data types.
	(union tree_node): Add tree_constructor field.
	* treestruct.def: Define TS_CONSTRUCTOR.
	* varasm.c (const_hash_1, compare_constant, copy_constant,
	compute_reloc_for_constant, output_addressed_constants,
	initializer_constant_valid_p, output_constant,
	array_size_for_constructor, output_constructor): Update to cope with
	VEC in CONSTRUCTOR_ELTS.
	* vec.h (VEC_empty, VEC_copy): New macros.

ada/
	Make CONSTRUCTOR use VEC to store initializers.
	* decl.c (gnat_to_gnu_entity): Update to cope with VEC in
	CONSTRUCTOR_ELTS.
	* trans.c (extract_values): Likewise.
	* utils.c (convert, remove_conversions): Likewise.
	* utils2.c (contains_save_expr_p, build_binary_op, build_unary_op,
	gnat_build_constructor): Likewise.

cp/
	Make CONSTRUCTOR use VEC to store initializers.
	* call.c (convert_default_arg): Update call to digest_init.
	* class.c (dump_class_hierarchy, dump_array): Update to cope with
	VEC in CONSTRUCTOR_ELTS.
	* cp-tree.h (EMPTY_CONSTRUCTOR_P): Likewise.
	(finish_compound_literal, digest_init): Update declaration.
	* decl.c (struct reshape_iter): New data type.
	(reshape_init_array): Rename to...
	(reshape_init_array_1): Update to cope with VEC in CONSTRUCTOR_ELTS.
	(reshape_init): Rewrite from scratch. Split parts into...
	(reshape_init_array, reshape_init_vector, reshape_init_class,
	reshape_init_r): New functions.
	(check_initializer): Update call to reshape_init. Remove obsolete
	code.
	(initialize_artificial_var, cp_complete_array_type): Update to cope
	with VEC in CONSTRUCTOR_ELTS.
	* decl2.c (grokfield): Update calls to digest_init.
	(mark_vtable_entries): Update to cope with VEC in CONSTRUCTOR_ELTS.
	* error.c (dump_expr_init_vec): New function.
	(dump_expr): Use dump_expr_init_vec.
	* init.c (build_zero_init, build_vec_init): Update to cope with VEC
	in CONSTRUCTOR_ELTS.
	(expand_default_init): Update call to digest_init.
	* parser.c  (cp_parser_postfix_expression): Use a VEC for the
	initializers.
	(cp_parser_initializer_list): Build a VEC of initializers.
	* pt.c (tsubst_copy, tsubst_copy_and_build): Update to cope with VEC
	in CONSTRUCTOR_ELTS.
	* rtti.c (tinfo_base_init, generic_initializer, ptr_initializer,
	ptm_initializer, class_initializer, get_pseudo_ti_init): Use
	build_constructor_from_list instead of build_constructor.
	* semantics.c (finish_compound_literal): Update call to digest_init.
	* tree.c (stabilize_init): Update to cope with VEC in
	CONSTRUCTOR_ELTS.
	* typeck.c (build_ptrmemfunc1): Likewise.
	* typeck2.c: (cxx_incomplete_type_error, split_nonconstant_init_1):
	Likewise.
	(store_init_value): Use build_constructor_from_list and update call
	to digest_init.
	(digest_init): Rewrite.
	(process_init_constructor): Rewrite from scratch. Split into...
	(process_init_constructor_array, picflag_from_initializer,
	process_init_constructor_record, process_init_constructor_union):
	New functions.
	(PICFLAG_ERRONEOUS, PICFLAG_NOT_ALL_CONSTANT, PICFLAG_NOT_ALL_SIMPLE):
	New macros.
	(build_functional_cast): Use build_constructor_from_list instead of
	build_constructor.

fortran/
	Make CONSTRUCTOR use VEC to store initializers.
	* trans-array.c (gfc_build_null_descriptor,
	gfc_trans_array_constructor_value, gfc_conv_array_initializer):
	Update to cope with VEC in CONSTRUCTOR_ELTS.
	* trans-common.c (create_common): Likewise.
	* trans-expr.c (gfc_conv_structure): Likewise.
	* trans-stmt.c (gfc_trans_character_select): Use
	build_constructor_from_list instead of build_constructor.

java/
	Make CONSTRUCTOR use VEC to store initializers.
	* check-init.c (check_init): Update to cope with VEC in
	CONSTRUCTOR_ELTS.
	* class.c (make_field_value, make_method_value, get_dispatch_table,
	make_class_data, emit_symbol_table, emit_catch_table,
	emit_assertion_table): Use build_constructor_from_list instead of
	build_constructor.
	* constants.c (build_constants_constructor): Likewise.
	* java-gimplify.c (java_gimplify_new_array_init): Update to cope with
	VEC in CONSTRUCTOR_ELTS.
	* java-tree.h (START_RECORD_CONSTRUCTOR, PUSH_SUPER_VALUE,
	PUSH_FIELD_VALUE, FINISH_RECORD_CONSTRUCTOR): Create a VEC instead
	of a TREE_LIST.
	* jcf-write.c (generate_bytecode_insns): Update to cope with VEC in
	CONSTRUCTOR_ELTS.
	* parse.y (build_new_array_init): Use build_constructor_from_list
	instead of build_constructor.
	(patch_new_array_init): Update to cope with VEC in
	CONSTRUCTOR_ELTS.
	(array_constructor_check_entry): Likewise.

objc/
	Make CONSTRUCTOR use VEC to store initializers.
	* objc-act.c (objc_build_constructor): Use build_constructor_from_list
	instead of build_constructor.

testsuite/
	Make CONSTRUCTOR use VEC to store initializers.
	* g++.dg/ext/complit3.C: Check for specific error messages.
	* g++.dg/init/brace2.C: Update error message.
	* g++.dg/warn/Wbraces2.C: Likewise.

From-SVN: r102182

8 files changed, 109 insertions, 68 deletions

diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 26459df..1b6eccf 100644
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,26 @@
+2005-07-20  Giovanni Bajo  <giovannibajo@libero.it>
+
+	Make CONSTRUCTOR use VEC to store initializers.
+	* check-init.c (check_init): Update to cope with VEC in
+	CONSTRUCTOR_ELTS.
+	* class.c (make_field_value, make_method_value, get_dispatch_table,
+	make_class_data, emit_symbol_table, emit_catch_table,
+	emit_assertion_table): Use build_constructor_from_list instead of
+	build_constructor.
+	* constants.c (build_constants_constructor): Likewise.
+	* java-gimplify.c (java_gimplify_new_array_init): Update to cope with
+	VEC in CONSTRUCTOR_ELTS.
+	* java-tree.h (START_RECORD_CONSTRUCTOR, PUSH_SUPER_VALUE,
+	PUSH_FIELD_VALUE, FINISH_RECORD_CONSTRUCTOR): Create a VEC instead
+	of a TREE_LIST.
+	* jcf-write.c (generate_bytecode_insns): Update to cope with VEC in
+	CONSTRUCTOR_ELTS.
+	* parse.y (build_new_array_init): Use build_constructor_from_list
+	instead of build_constructor.
+	(patch_new_array_init): Update to cope with VEC in
+	CONSTRUCTOR_ELTS.
+	(array_constructor_check_entry): Likewise.
+
 2005-07-12  Tom Tromey  <tromey@redhat.com>
 
 	* jvspec.c (lang_specific_driver): Put filelist_filename first on
diff --git a/gcc/java/check-init.c b/gcc/java/check-init.c
index f8b1736..377ac78 100644
--- a/gcc/java/check-init.c
+++ b/gcc/java/check-init.c
@@ -918,9 +918,11 @@ check_init (tree exp, words before)
 
     case NEW_ARRAY_INIT:
       {
-	tree x = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0));
-	for ( ;  x != NULL_TREE;  x = TREE_CHAIN (x))
-	  check_init (TREE_VALUE (x), before);
+	tree value;
+	unsigned HOST_WIDE_INT idx;
+	FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
+				    idx, value)
+	  check_init (value, before);
       }
       break;
 
diff --git a/gcc/java/class.c b/gcc/java/class.c
index eca8017..c2bd62f 100644
--- a/gcc/java/class.c
+++ b/gcc/java/class.c
@@ -1278,7 +1278,7 @@ make_field_value (tree fdecl)
 
   PUSH_FIELD_VALUE
     (finit, "info",
-     build_constructor (field_info_union_node,
+     build_constructor_from_list (field_info_union_node,
 	    build_tree_list
 	    ((FIELD_STATIC (fdecl)
 	      ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
@@ -1359,7 +1359,7 @@ make_method_value (tree mdecl)
 	    table = tree_cons (NULL_TREE, utf8, table);
 	  }
 	type = build_prim_array_type (ptr_type_node, length);
-	table = build_constructor (type, table);
+	table = build_constructor_from_list (type, table);
 	/* Compute something unique enough.  */
 	sprintf (buf, "_methods%d", method_name_count++);
 	array = build_decl (VAR_DECL, get_identifier (buf), type);
@@ -1480,8 +1480,9 @@ get_dispatch_table (tree type, tree this_class_addr)
   if (TARGET_VTABLE_USES_DESCRIPTORS)
     arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
   arraysize += 2;
-  return build_constructor (build_prim_array_type (nativecode_ptr_type_node,
-						   arraysize), list);
+  return build_constructor_from_list
+	  (build_prim_array_type (nativecode_ptr_type_node,
+				  arraysize), list);
 }
 
 
@@ -1608,8 +1609,8 @@ make_class_data (tree type)
       field_array_type = build_prim_array_type (field_type_node, field_count);
       fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
 				field_array_type);
-      DECL_INITIAL (fields_decl) = build_constructor (field_array_type,
-						      static_fields);
+      DECL_INITIAL (fields_decl) = build_constructor_from_list
+				    (field_array_type, static_fields);
       TREE_STATIC (fields_decl) = 1;
       DECL_ARTIFICIAL (fields_decl) = 1;
       DECL_IGNORED_P (fields_decl) = 1;
@@ -1639,8 +1640,8 @@ make_class_data (tree type)
   method_array_type = build_prim_array_type (method_type_node, method_count);
   methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
 			     method_array_type);
-  DECL_INITIAL (methods_decl) = build_constructor (method_array_type,
-						   nreverse (methods));
+  DECL_INITIAL (methods_decl) = build_constructor_from_list
+				 (method_array_type, nreverse (methods));
   TREE_STATIC (methods_decl) = 1;
   DECL_ARTIFICIAL (methods_decl) = 1;
   DECL_IGNORED_P (methods_decl) = 1;
@@ -1715,7 +1716,8 @@ make_class_data (tree type)
 	    }
 	  init = tree_cons (NULL_TREE, index, init); 
 	}
-      DECL_INITIAL (idecl) = build_constructor (interface_array_type, init);
+      DECL_INITIAL (idecl) = build_constructor_from_list (interface_array_type,
+							  init);
       TREE_STATIC (idecl) = 1;
       DECL_ARTIFICIAL (idecl) = 1;
       DECL_IGNORED_P (idecl) = 1;
@@ -2528,7 +2530,7 @@ emit_symbol_table (tree name, tree the_table, tree decl_list,
 
   /* Put the list in the right order and make it a constructor. */
   list = nreverse (list);
-  table = build_constructor (symbols_array_type, list);  
+  table = build_constructor_from_list (symbols_array_type, list);  
 
   /* Make it the initial value for otable_syms and emit the decl. */
   DECL_INITIAL (the_syms_decl) = table;
@@ -2589,7 +2591,7 @@ emit_catch_table (tree this_class)
   table = 
     build_decl (VAR_DECL, DECL_NAME (TYPE_CTABLE_DECL (this_class)), array_type);
   DECL_INITIAL (table) = 
-    build_constructor (array_type, TYPE_CATCH_CLASSES (this_class));
+    build_constructor_from_list (array_type, TYPE_CATCH_CLASSES (this_class));
   TREE_STATIC (table) = 1;
   TREE_READONLY (table) = 1;  
   DECL_IGNORED_P (table) = 1;
@@ -2669,7 +2671,7 @@ emit_assertion_table (tree class)
   
   /* Put the list in the right order and make it a constructor. */
   list = nreverse (list);
-  ctor = build_constructor (assertion_table_type, list);
+  ctor = build_constructor_from_list (assertion_table_type, list);
 
   table_decl = build_decl (VAR_DECL, mangled_classname ("_type_assert_", class),
 			   assertion_table_type);
diff --git a/gcc/java/constants.c b/gcc/java/constants.c
index 335f20c..bba67a7 100644
--- a/gcc/java/constants.c
+++ b/gcc/java/constants.c
@@ -515,8 +515,8 @@ build_constants_constructor (void)
   
       data_decl = build_constant_data_ref ();
       TREE_TYPE (data_decl) = build_array_type (ptr_type_node, index_type);
-      DECL_INITIAL (data_decl) = build_constructor (TREE_TYPE (data_decl),
-						    data_list);
+      DECL_INITIAL (data_decl) = build_constructor_from_list
+				  (TREE_TYPE (data_decl), data_list);
       DECL_SIZE (data_decl) = TYPE_SIZE (TREE_TYPE (data_decl));
       DECL_SIZE_UNIT (data_decl) = TYPE_SIZE_UNIT (TREE_TYPE (data_decl));
       rest_of_decl_compilation (data_decl, 1, 0);
@@ -527,7 +527,8 @@ build_constants_constructor (void)
 							   current_class),
 			      tags_type);
       TREE_STATIC (tags_decl) = 1;
-      DECL_INITIAL (tags_decl) = build_constructor (tags_type, tags_list);
+      DECL_INITIAL (tags_decl) = build_constructor_from_list
+				 (tags_type, tags_list);
       rest_of_decl_compilation (tags_decl, 1, 0);
       tags_value = build_address_of (tags_decl);
     }
diff --git a/gcc/java/java-gimplify.c b/gcc/java/java-gimplify.c
index 60713a4..cbc174d 100644
--- a/gcc/java/java-gimplify.c
+++ b/gcc/java/java-gimplify.c
@@ -296,7 +296,8 @@ java_gimplify_new_array_init (tree exp)
   HOST_WIDE_INT ilength = java_array_type_length (array_type);
   tree length = build_int_cst (NULL_TREE, ilength);
   tree init = TREE_OPERAND (exp, 0);
-  tree values = CONSTRUCTOR_ELTS (init);
+  tree value;
+  unsigned HOST_WIDE_INT cnt;
 
   tree array_ptr_type = build_pointer_type (array_type);
   tree tmp = create_tmp_var (array_ptr_type, "array");
@@ -306,7 +307,7 @@ java_gimplify_new_array_init (tree exp)
   int index = 0;
 
   /* FIXME: try to allocate array statically?  */
-  while (values != NULL_TREE)
+  FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), cnt, value)
     {
       /* FIXME: Should use build_java_arrayaccess here, but avoid
 	 bounds checking.  */
@@ -317,9 +318,8 @@ java_gimplify_new_array_init (tree exp)
 				build4 (ARRAY_REF, element_type, lhs,
 					build_int_cst (NULL_TREE, index++),
 					NULL_TREE, NULL_TREE),
-				TREE_VALUE (values));
+				value);
       body = build2 (COMPOUND_EXPR, element_type, body, assignment);
-      values = TREE_CHAIN (values);
     }
 
   return build2 (COMPOUND_EXPR, array_ptr_type, body, tmp);
diff --git a/gcc/java/java-tree.h b/gcc/java/java-tree.h
index 5b63435..ab6157b 100644
--- a/gcc/java/java-tree.h
+++ b/gcc/java/java-tree.h
@@ -1762,41 +1762,49 @@ extern tree *type_map;
 #define FINISH_RECORD(RTYPE) layout_type (RTYPE)
 
 /* Start building a RECORD_TYPE constructor with a given TYPE in CONS. */
-#define START_RECORD_CONSTRUCTOR(CONS, CTYPE)	\
-{ CONS = build_constructor ((CTYPE), NULL_TREE);	\
-  TREE_CHAIN (CONS) = TYPE_FIELDS (CTYPE); }
+#define START_RECORD_CONSTRUCTOR(CONS, CTYPE) \
+  do \
+    { \
+      CONS = build_constructor ((CTYPE), VEC_alloc (constructor_elt, gc, 0)); \
+      CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (CONS), TYPE_FIELDS (CTYPE), \
+			      NULL); \
+    } \
+  while (0)
 
 /* Append a field initializer to CONS for the dummy field for the inherited
    fields.  The dummy field has the given VALUE, and the same type as the
    super-class.   Must be specified before calls to PUSH_FIELD_VALUE. */
-#define PUSH_SUPER_VALUE(CONS, VALUE)			\
-{							\
-  tree _field = TREE_CHAIN (CONS);			\
-  if (DECL_NAME (_field) != NULL_TREE)			\
-    abort ();						\
-  CONSTRUCTOR_ELTS (CONS)				\
-    = tree_cons (_field, (VALUE), CONSTRUCTOR_ELTS (CONS)); \
-  TREE_CHAIN (CONS) = TREE_CHAIN (_field);		\
-}
+#define PUSH_SUPER_VALUE(CONS, VALUE) \
+  do \
+    { \
+      constructor_elt *_elt___ = VEC_last (constructor_elt, \
+					   CONSTRUCTOR_ELTS (CONS)); \
+      tree _next___ = TREE_CHAIN (_elt___->index); \
+      gcc_assert (!DECL_NAME (_elt___->index)); \
+      _elt___->value = VALUE; \
+      CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (CONS), _next___, NULL); \
+    } \
+  while (0)
 
 /* Append a field initializer to CONS for a field with the given VALUE.
    NAME is a char* string used for error checking;
    the initializer must be specified in order. */
 #define PUSH_FIELD_VALUE(CONS, NAME, VALUE) 				\
-do									\
-{									\
-  tree _field = TREE_CHAIN (CONS);					\
-  if (strcmp (IDENTIFIER_POINTER (DECL_NAME (_field)), NAME) != 0) 	\
-    abort ();								\
-  CONSTRUCTOR_ELTS (CONS)						\
-    = tree_cons (_field, (VALUE), CONSTRUCTOR_ELTS (CONS));		\
-  TREE_CHAIN (CONS) = TREE_CHAIN (_field); 				\
-}									\
-while (0)
+  do \
+    { \
+      constructor_elt *_elt___ = VEC_last (constructor_elt, \
+					   CONSTRUCTOR_ELTS (CONS)); \
+      tree _next___ = TREE_CHAIN (_elt___->index); \
+      gcc_assert (strcmp (IDENTIFIER_POINTER (DECL_NAME (_elt___->index)), \
+			  NAME) == 0); \
+      _elt___->value = VALUE; \
+      CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (CONS), _next___, NULL); \
+    } \
+  while (0)
 
 /* Finish creating a record CONSTRUCTOR CONS. */
 #define FINISH_RECORD_CONSTRUCTOR(CONS) \
-  CONSTRUCTOR_ELTS(CONS) = nreverse (CONSTRUCTOR_ELTS (CONS))
+  VEC_pop (constructor_elt, CONSTRUCTOR_ELTS (CONS))
 
 /* Macros on constructors invocations.  */
 #define CALL_CONSTRUCTOR_P(NODE)		\
diff --git a/gcc/java/jcf-write.c b/gcc/java/jcf-write.c
index c27b732..4576499 100644
--- a/gcc/java/jcf-write.c
+++ b/gcc/java/jcf-write.c
@@ -2461,14 +2461,16 @@ generate_bytecode_insns (tree exp, int target, struct jcf_partial *state)
       break;
     case NEW_ARRAY_INIT:
       {
-	tree values = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0));
+	VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0));
 	tree array_type = TREE_TYPE (TREE_TYPE (exp));
 	tree element_type = TYPE_ARRAY_ELEMENT (array_type);
+	unsigned HOST_WIDE_INT idx;
+	tree value;
 	HOST_WIDE_INT length = java_array_type_length (array_type);
 	if (target == IGNORE_TARGET)
 	  {
-	    for ( ;  values != NULL_TREE;  values = TREE_CHAIN (values))
-	      generate_bytecode_insns (TREE_VALUE (values), target, state);
+	    FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
+	      generate_bytecode_insns (value, target, state);
 	    break;
 	  }
 	push_int_const (length, state);
@@ -2489,16 +2491,17 @@ generate_bytecode_insns (tree exp, int target, struct jcf_partial *state)
 	  }
 	offset = 0;
 	jopcode = OPCODE_iastore + adjust_typed_op (element_type, 7);
-	for ( ;  values != NULL_TREE;  values = TREE_CHAIN (values), offset++)
+	FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
 	  {
 	    int save_SP = state->code_SP;
 	    emit_dup (1, 0, state);
 	    push_int_const (offset, state);
 	    NOTE_PUSH (1);
-	    generate_bytecode_insns (TREE_VALUE (values), STACK_TARGET, state);
+	    generate_bytecode_insns (value, STACK_TARGET, state);
 	    RESERVE (1);
 	    OP1 (jopcode);
 	    state->code_SP = save_SP;
+	    offset++;
 	  }
       }
       break;
diff --git a/gcc/java/parse.y b/gcc/java/parse.y
index 6007b18..10a37e0 100644
--- a/gcc/java/parse.y
+++ b/gcc/java/parse.y
@@ -274,7 +274,7 @@ static void missing_return_error (tree);
 static tree build_new_array_init (int, tree);
 static tree patch_new_array_init (tree, tree);
 static tree maybe_build_array_element_wfl (tree);
-static int array_constructor_check_entry (tree, tree);
+static int array_constructor_check_entry (tree, constructor_elt *);
 static const char *purify_type_name (const char *);
 static tree fold_constant_for_init (tree, tree);
 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
@@ -14793,7 +14793,8 @@ maybe_build_array_element_wfl (tree node)
 static tree
 build_new_array_init (int location, tree values)
 {
-  tree constructor = build_constructor (NULL_TREE, values);
+  tree constructor = build_constructor_from_list (NULL_TREE,
+						  nreverse (values));
   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
   EXPR_WFL_LINECOL (to_return) = location;
   return to_return;
@@ -14807,8 +14808,9 @@ static tree
 patch_new_array_init (tree type, tree node)
 {
   int error_seen = 0;
-  tree current, element_type;
-  HOST_WIDE_INT length;
+  tree element_type;
+  unsigned HOST_WIDE_INT length;
+  constructor_elt *current;
   int all_constant = 1;
   tree init = TREE_OPERAND (node, 0);
 
@@ -14822,16 +14824,16 @@ patch_new_array_init (tree type, tree node)
   type = TREE_TYPE (type);
   element_type = TYPE_ARRAY_ELEMENT (type);
 
-  CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
-
-  for (length = 0, current = CONSTRUCTOR_ELTS (init);
-       current;  length++, current = TREE_CHAIN (current))
+  for (length = 0;
+       VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init),
+		    length, current);
+       length++)
     {
-      tree elt = TREE_VALUE (current);
+      tree elt = current->value;
       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
 	{
 	  error_seen |= array_constructor_check_entry (element_type, current);
-	  elt = TREE_VALUE (current);
+	  elt = current->value;
 	  /* When compiling to native code, STRING_CST is converted to
 	     INDIRECT_REF, but still with a TREE_CONSTANT flag. */
 	  if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
@@ -14839,8 +14841,8 @@ patch_new_array_init (tree type, tree node)
 	}
       else
 	{
-	  TREE_VALUE (current) = patch_new_array_init (element_type, elt);
-	  TREE_PURPOSE (current) = NULL_TREE;
+	  current->value = patch_new_array_init (element_type, elt);
+	  current->index = NULL_TREE;
 	  all_constant = 0;
 	}
       if (elt && TREE_CODE (elt) == TREE_LIST
@@ -14869,16 +14871,16 @@ patch_new_array_init (tree type, tree node)
    otherwise.  */
 
 static int
-array_constructor_check_entry (tree type, tree entry)
+array_constructor_check_entry (tree type, constructor_elt *entry)
 {
   char *array_type_string = NULL;	/* For error reports */
   tree value, type_value, new_value, wfl_value, patched;
   int error_seen = 0;
 
   new_value = NULL_TREE;
-  wfl_value = TREE_VALUE (entry);
+  wfl_value = entry->value;
 
-  value = java_complete_tree (TREE_VALUE (entry));
+  value = java_complete_tree (entry->value);
   /* patch_string return error_mark_node if arg is error_mark_node */
   if ((patched = patch_string (value)))
     value = patched;
@@ -14889,7 +14891,7 @@ array_constructor_check_entry (tree type, tree entry)
 
   /* At anytime, try_builtin_assignconv can report a warning on
      constant overflow during narrowing. */
-  SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
+  SET_WFL_OPERATOR (wfl_operator, entry->index, wfl_value);
   new_value = try_builtin_assignconv (wfl_operator, type, value);
   if (!new_value && (new_value = try_reference_assignconv (type, value)))
     type_value = promote_type (type);
@@ -14908,12 +14910,12 @@ array_constructor_check_entry (tree type, tree entry)
     }
 
   if (new_value)
-    TREE_VALUE (entry) = new_value;
+    entry->value = new_value;
 
   if (array_type_string)
     free (array_type_string);
 
-  TREE_PURPOSE (entry) = NULL_TREE;
+  entry->index = NULL_TREE;
   return error_seen;
 }