diff options
Diffstat (limited to 'gcc/java')
| -rw-r--r-- | gcc/java/ChangeLog | 23 | ||||
| -rw-r--r-- | gcc/java/check-init.c | 8 | ||||
| -rw-r--r-- | gcc/java/class.c | 26 | ||||
| -rw-r--r-- | gcc/java/constants.c | 7 | ||||
| -rw-r--r-- | gcc/java/java-gimplify.c | 8 | ||||
| -rw-r--r-- | gcc/java/java-tree.h | 54 | ||||
| -rw-r--r-- | gcc/java/jcf-write.c | 13 | ||||
| -rw-r--r-- | gcc/java/parse.y | 38 |
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; } |