+2004-01-09 Andrew Haley <aph@redhat.com>
+
+ PR java/12755:
+ * parse.y (java_fix_constructors): Set output_class.
+ (java_reorder_fields): Likewise.
+ (java_layout_classes): Likewise.
+ (java_expand_classes): Generate indirect dispatch tables.
+ (java_expand_classes): Set output_class.
+ (java_finish_classes): Likewise.
+ * lang.c (java_init): Turn on always_initialize_class_p if we're
+ using indirect dis[atch.
+ (java_decl_ok_for_sibcall): Use output_class, not current_class.
+ (java_get_callee_fndecl): Use class local atable.
+ * jcf-parse.c
+ (always_initialize_class_p): Decl moved to java-tree.h.
+ (HANDLE_CLASS_INFO): Set output_class.
+ (read_class): Likewise.
+ (parse_class_file): Call gen_indirect_dispatch_tables.
+ (parse_zip_file_entries): Set output_class.
+ (java_parse_file): Set output_class. Don't emit symbol tables.
+ * java-tree.h (output_class): New.
+ Remove global declarations for otable, atable, and ctable.
+ (always_initialize_class_p): moved here from decl.c.
+ (DECL_OWNER): New.
+ (TYPE_ATABLE_METHODS, TYPE_ATABLE_SYMS_DECL, TYPE_ATABLE_DECL,
+ TYPE_OTABLE_METHODS, TYPE_OTABLE_SYMS_DECL, TYPE_OTABLE_DECL,
+ TYPE_CTABLE_DECL, TYPE_CATCH_CLASSES): New.
+ (struct lang_type): Add otable_methods, otable_decl,
+ otable_syms_decl, atable_methods, atable_decl, atable_syms_decl,
+ ctable_decl, catch_classes, type_to_runtime_map.
+ * expr.c (build_field_ref): Make otable, atable, and ctable class
+ local rather than global.
+ (build_known_method_ref): Likewise.
+ (build_invokeinterface): Likewise.
+ (java_expand_expr): Pass runtime type (rather than actual type) to
+ expand_start_catch.
+ * except.c (prepare_eh_table_type): Create TYPE_TO_RUNTIME_MAP for
+ this class. Look up each class in that map to delete duplicates.
+ (expand_end_java_handler): Pass runtime type (rather than actual
+ type) to expand_start_catch.
+ * decl.c: (always_initialize_class_p): Decl moved to java-tree.h.
+ (do_nothing): New.
+ (java_init_decl_processing): Rearrange things. Remove global
+ declarations of otable, atable, and ctable.
+ (java_init_decl_processing): Make lang_eh_runtime_type do_nothing.
+ (java_expand_body): Set output_class.
+ * constants.c (build_constant_data_ref): Use output_class, not
+ current_class.
+ (alloc_name_constant): Likewise.
+ * class.c (gen_indirect_dispatch_tables): New.
+ (build_class_ref): Generate hard reference to superclass, even if
+ using indirect dispatch.
+ (build_static_field_ref): Use class local atable.
+ (make_class_data): Generate hard reference to superclass, even if
+ using indirect dispatch.
+ Generate symbolic references to interfaces when using indirect
+ dispatch.
+ (make_class_data): Emit otable, atable, and ctable.
+ Make otable, atable, and ctable class local rather than global.
+ (emit_catch_table): Make otable, atable, and ctable class local
+ rather than global.
+
2003-12-25 Andrew Pinski <pinskia@physics.uc.edu>
* parse.y (catch_clause_parameter): Fix typo.
/* Functions related to building classes and their related objects.
- Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of GCC.
#include "ggc.h"
#include "stdio.h"
#include "target.h"
+#include "except.h"
/* DOS brain-damage */
#ifndef O_BINARY
return to_return;
}
+
+/* Given a class, create the DECLs for all its associated indirect dispatch tables. */
+void
+gen_indirect_dispatch_tables (tree type)
+{
+ const char *typename = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
+ {
+ tree field = NULL;
+ char *buf = alloca (strlen (typename) + strlen ("_catch_classes_"));
+ tree catch_class_type = make_node (RECORD_TYPE);
+
+ sprintf (buf, "_catch_classes_%s", typename);
+ PUSH_FIELD (catch_class_type, field, "address", utf8const_ptr_type);
+ PUSH_FIELD (catch_class_type, field, "classname", ptr_type_node);
+ FINISH_RECORD (catch_class_type);
+
+ TYPE_CTABLE_DECL (type)
+ = build_decl (VAR_DECL, get_identifier (buf),
+ build_array_type (catch_class_type, 0));
+ DECL_EXTERNAL (TYPE_CTABLE_DECL (type)) = 1;
+ TREE_STATIC (TYPE_CTABLE_DECL (type)) = 1;
+ TREE_READONLY (TYPE_CTABLE_DECL (type)) = 1;
+ TREE_CONSTANT (TYPE_CTABLE_DECL (type)) = 1;
+ DECL_IGNORED_P (TYPE_CTABLE_DECL (type)) = 1;
+ pushdecl (TYPE_CTABLE_DECL (type));
+ }
+
+ if (flag_indirect_dispatch)
+ {
+ {
+ char *buf = alloca (strlen (typename) + strlen ("_otable_syms_"));
+
+ sprintf (buf, "_otable_%s", typename);
+ TYPE_OTABLE_DECL (type) =
+ build_decl (VAR_DECL, get_identifier (buf), otable_type);
+ DECL_EXTERNAL (TYPE_OTABLE_DECL (type)) = 1;
+ TREE_STATIC (TYPE_OTABLE_DECL (type)) = 1;
+ TREE_READONLY (TYPE_OTABLE_DECL (type)) = 1;
+ TREE_CONSTANT (TYPE_OTABLE_DECL (type)) = 1;
+ DECL_IGNORED_P (TYPE_OTABLE_DECL (type)) = 1;
+ pushdecl (TYPE_OTABLE_DECL (type));
+ sprintf (buf, "_otable_syms_%s", typename);
+ TYPE_OTABLE_SYMS_DECL (type) =
+ build_decl (VAR_DECL, get_identifier (buf), symbols_array_type);
+ TREE_STATIC (TYPE_OTABLE_SYMS_DECL (type)) = 1;
+ TREE_CONSTANT (TYPE_OTABLE_SYMS_DECL (type)) = 1;
+ DECL_IGNORED_P(TYPE_OTABLE_SYMS_DECL (type)) = 1;
+ pushdecl (TYPE_OTABLE_SYMS_DECL (type));
+ }
+
+ {
+ char *buf = alloca (strlen (typename) + strlen ("_atable_syms_"));
+ tree decl;
+
+ sprintf (buf, "_atable_%s", typename);
+ TYPE_ATABLE_DECL (type) = decl =
+ build_decl (VAR_DECL, get_identifier (buf), atable_type);
+ DECL_EXTERNAL (decl) = 1;
+ TREE_STATIC (decl) = 1;
+ TREE_READONLY (decl) = 1;
+ TREE_CONSTANT (decl) = 1;
+ DECL_IGNORED_P (decl) = 1;
+ /* Mark the atable as belonging to this class. */
+ pushdecl (decl);
+ MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
+ DECL_OWNER (decl) = type;
+ sprintf (buf, "_atable_syms_%s", typename);
+ TYPE_ATABLE_SYMS_DECL (type) =
+ build_decl (VAR_DECL, get_identifier (buf), symbols_array_type);
+ TREE_STATIC (TYPE_ATABLE_SYMS_DECL (type)) = 1;
+ TREE_CONSTANT (TYPE_ATABLE_SYMS_DECL (type)) = 1;
+ DECL_IGNORED_P (TYPE_ATABLE_SYMS_DECL (type)) = 1;
+ pushdecl (TYPE_ATABLE_SYMS_DECL (type));
+ }
+ }
+}
+
tree
push_class (tree class_type, tree class_name)
{
if (TREE_CODE (type) == POINTER_TYPE)
type = TREE_TYPE (type);
- if (flag_indirect_dispatch
- && type != current_class
+ /* FIXME: we really want an indirect reference to our
+ superclass. However, libgcj assumes that a superclass
+ pointer always points directly to a class. As a workaround
+ we always emit this hard superclass reference. */
+ if (flag_indirect_dispatch
+ && type != output_class
+ && type != CLASSTYPE_SUPER (output_class)
&& TREE_CODE (type) == RECORD_TYPE)
return build_indirect_class_ref (type);
if (flag_indirect_dispatch)
{
tree table_index
- = build_int_2 (get_symbol_table_index (fdecl, &atable_methods), 0);
+ = build_int_2 (get_symbol_table_index
+ (fdecl, &TYPE_ATABLE_METHODS (output_class)), 0);
tree field_address
= build (ARRAY_REF, build_pointer_type (TREE_TYPE (fdecl)),
- atable_decl, table_index);
+ TYPE_ATABLE_DECL (output_class), table_index);
return fold (build1 (INDIRECT_REF, TREE_TYPE (fdecl),
field_address));
}
super = CLASSTYPE_SUPER (type);
if (super == NULL_TREE)
super = null_pointer_node;
- else if (! flag_indirect_dispatch
- && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
+ else if (/* FIXME: we should also test for (!
+ flag_indirect_dispatch) here, but libgcj can't cope with
+ a symbolic reference a superclass in the class data. */
+ assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
&& assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
super = build_class_ref (super);
else
tree child = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i);
tree iclass = BINFO_TYPE (child);
tree index;
- if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass)))))
+ if (! flag_indirect_dispatch
+ && (assume_compiled
+ (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))))
index = build_class_ref (iclass);
else
{
- int int_index = alloc_class_constant (iclass);
- index = build_int_2 (int_index, 0);
- TREE_TYPE (index) = ptr_type_node;
+ int int_index = alloc_class_constant (iclass);
+ index = build_int_2 (int_index, 0);
+ TREE_TYPE (index) = ptr_type_node;
}
init = tree_cons (NULL_TREE, index, init);
}
constant_pool_constructor = build_constants_constructor ();
+ if (flag_indirect_dispatch)
+ {
+ TYPE_OTABLE_DECL (type)
+ = emit_symbol_table
+ (DECL_NAME (TYPE_OTABLE_DECL (type)),
+ TYPE_OTABLE_DECL (type), TYPE_OTABLE_METHODS (type),
+ TYPE_OTABLE_SYMS_DECL (type), integer_type_node);
+
+ TYPE_ATABLE_DECL (type)
+ = emit_symbol_table
+ (DECL_NAME (TYPE_ATABLE_DECL (type)),
+ TYPE_ATABLE_DECL (type), TYPE_ATABLE_METHODS (type),
+ TYPE_ATABLE_SYMS_DECL (type), ptr_type_node);
+ }
+
+ TYPE_CTABLE_DECL (type) = emit_catch_table (type);
+
START_RECORD_CONSTRUCTOR (temp, object_type_node);
PUSH_FIELD_VALUE (temp, "vtable",
build (PLUS_EXPR, dtable_ptr_type,
: build (PLUS_EXPR, dtable_ptr_type,
build1 (ADDR_EXPR, dtable_ptr_type, dtable_decl),
dtable_start_offset));
- if (otable_methods == NULL_TREE)
+ if (TYPE_OTABLE_METHODS (type) == NULL_TREE)
{
PUSH_FIELD_VALUE (cons, "otable", null_pointer_node);
PUSH_FIELD_VALUE (cons, "otable_syms", null_pointer_node);
else
{
PUSH_FIELD_VALUE (cons, "otable",
- build1 (ADDR_EXPR, otable_ptr_type, otable_decl));
+ build1 (ADDR_EXPR, otable_ptr_type, TYPE_OTABLE_DECL (type)));
PUSH_FIELD_VALUE (cons, "otable_syms",
build1 (ADDR_EXPR, symbols_array_ptr_type,
- otable_syms_decl));
- TREE_CONSTANT (otable_decl) = 1;
- }
- if (atable_methods == NULL_TREE)
+ TYPE_OTABLE_SYMS_DECL (type)));
+ TREE_CONSTANT (TYPE_OTABLE_DECL (type)) = 1;
+ }
+ if (TYPE_ATABLE_METHODS(type) == NULL_TREE)
{
PUSH_FIELD_VALUE (cons, "atable", null_pointer_node);
PUSH_FIELD_VALUE (cons, "atable_syms", null_pointer_node);
else
{
PUSH_FIELD_VALUE (cons, "atable",
- build1 (ADDR_EXPR, atable_ptr_type, atable_decl));
+ build1 (ADDR_EXPR, atable_ptr_type, TYPE_ATABLE_DECL (type)));
PUSH_FIELD_VALUE (cons, "atable_syms",
build1 (ADDR_EXPR, symbols_array_ptr_type,
- atable_syms_decl));
- TREE_CONSTANT (atable_decl) = 1;
+ TYPE_ATABLE_SYMS_DECL (type)));
+ TREE_CONSTANT (TYPE_ATABLE_DECL (type)) = 1;
}
PUSH_FIELD_VALUE (cons, "catch_classes",
- build1 (ADDR_EXPR, ptr_type_node, ctable_decl));
+ build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
PUSH_FIELD_VALUE (cons, "interface_count", build_int_2 (interface_len, 0));
method = TREE_CHAIN (method);
}
+ java_expand_catch_classes (current_class);
+
current_function_decl = NULL_TREE;
make_class_data (current_class);
register_class ();
make_catch_class_record (tree catch_class, tree classname)
{
tree entry;
- tree type = TREE_TYPE (TREE_TYPE (ctable_decl));
+ tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
START_RECORD_CONSTRUCTOR (entry, type);
PUSH_FIELD_VALUE (entry, "address", catch_class);
PUSH_FIELD_VALUE (entry, "classname", classname);
/* Generate the list of Throwable classes that are caught by exception
- handlers in this compilation. */
-void
-emit_catch_table (void)
+ handlers in this class. */
+tree
+emit_catch_table (tree this_class)
{
tree table, table_size, array_type;
- catch_classes
- = tree_cons (NULL,
- make_catch_class_record (null_pointer_node, null_pointer_node),
- catch_classes);
- catch_classes = nreverse (catch_classes);
- catch_classes
- = tree_cons (NULL,
- make_catch_class_record (null_pointer_node, null_pointer_node),
- catch_classes);
- table_size = build_index_type (build_int_2 (list_length (catch_classes), 0));
+ TYPE_CATCH_CLASSES (this_class) =
+ tree_cons (NULL,
+ make_catch_class_record (null_pointer_node, null_pointer_node),
+ TYPE_CATCH_CLASSES (this_class));
+ TYPE_CATCH_CLASSES (this_class) = nreverse (TYPE_CATCH_CLASSES (this_class));
+ TYPE_CATCH_CLASSES (this_class) =
+ tree_cons (NULL,
+ make_catch_class_record (null_pointer_node, null_pointer_node),
+ TYPE_CATCH_CLASSES (this_class));
+ table_size =
+ build_index_type (build_int_2
+ (list_length (TYPE_CATCH_CLASSES (this_class)), 0));
array_type
- = build_array_type (TREE_TYPE (TREE_TYPE (ctable_decl)), table_size);
- table = build_decl (VAR_DECL, DECL_NAME (ctable_decl), array_type);
- DECL_INITIAL (table) = build_constructor (array_type, catch_classes);
+ = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
+ table_size);
+ 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));
TREE_STATIC (table) = 1;
TREE_READONLY (table) = 1;
+ DECL_IGNORED_P (table) = 1;
rest_of_decl_compilation (table, NULL, 1, 0);
- ctable_decl = table;
+ return table;
}
/* Handle the constant pool of the Java(TM) Virtual Machine.
- Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
int
alloc_name_constant (int tag, tree name)
{
- CPool *outgoing_cpool = cpool_for_class (current_class);
+ CPool *outgoing_cpool = cpool_for_class (output_class);
return find_tree_constant (outgoing_cpool, tag, name);
}
{
tree cpool_data_ref = NULL_TREE;
- if (TYPE_CPOOL_DATA_REF (current_class))
- cpool_data_ref = TYPE_CPOOL_DATA_REF (current_class);
+ if (TYPE_CPOOL_DATA_REF (output_class))
+ cpool_data_ref = TYPE_CPOOL_DATA_REF (output_class);
if (cpool_data_ref == NULL_TREE)
{
tree decl;
- tree decl_name = mangled_classname ("_CD_", current_class);
+ tree decl_name = mangled_classname ("_CD_", output_class);
decl = build_decl (VAR_DECL, decl_name,
build_array_type (ptr_type_node,
one_elt_array_domain_type));
TREE_STATIC (decl) = 1;
make_decl_rtl (decl, NULL);
- TYPE_CPOOL_DATA_REF (current_class) = cpool_data_ref
+ TYPE_CPOOL_DATA_REF (output_class) = cpool_data_ref
= build1 (ADDR_EXPR, ptr_type_node, decl);
}
return cpool_data_ref;
/* Process declarations and variables for the GNU compiler for the
Java(TM) language.
- Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of GCC.
/* Name of the Serializable class. */
tree java_io_serializable_identifier_node;
-/* Set to nonzero value in order to emit class initialization code
- before static field references. */
-extern int always_initialize_class_p;
-
/* The DECL_MAP is a mapping from (index, type) to a decl node.
If index < max_locals, it is the index of a local variable.
if index >= max_locals, then index-max_locals is a stack slot.
return r;
}
+static tree
+do_nothing (tree t)
+{
+ return t;
+}
+
+
void
java_init_decl_processing (void)
{
float_array_vtable = create_primitive_vtable ("float");
double_array_vtable = create_primitive_vtable ("double");
+ one_elt_array_domain_type = build_index_type (integer_one_node);
+ utf8const_type = make_node (RECORD_TYPE);
+ PUSH_FIELD (utf8const_type, field, "hash", unsigned_short_type_node);
+ PUSH_FIELD (utf8const_type, field, "length", unsigned_short_type_node);
+ FINISH_RECORD (utf8const_type);
+ utf8const_ptr_type = build_pointer_type (utf8const_type);
+
+ atable_type = build_array_type (ptr_type_node,
+ one_elt_array_domain_type);
+ TYPE_NONALIASED_COMPONENT (atable_type) = 1;
+ atable_ptr_type = build_pointer_type (atable_type);
+
+ symbol_type = make_node (RECORD_TYPE);
+ PUSH_FIELD (symbol_type, field, "clname", utf8const_ptr_type);
+ PUSH_FIELD (symbol_type, field, "name", utf8const_ptr_type);
+ PUSH_FIELD (symbol_type, field, "signature", utf8const_ptr_type);
+ FINISH_RECORD (symbol_type);
+
+ symbols_array_type = build_array_type (symbol_type,
+ one_elt_array_domain_type);
+ symbols_array_ptr_type = build_pointer_type (symbols_array_type);
+
/* As you're adding items here, please update the code right after
this section, so that the filename containing the source code of
the pre-defined class gets registered correctly. */
/* for lack of a better place to put this stub call */
init_expr_processing();
- utf8const_type = make_node (RECORD_TYPE);
- PUSH_FIELD (utf8const_type, field, "hash", unsigned_short_type_node);
- PUSH_FIELD (utf8const_type, field, "length", unsigned_short_type_node);
- FINISH_RECORD (utf8const_type);
- utf8const_ptr_type = build_pointer_type (utf8const_type);
-
constants_type_node = make_node (RECORD_TYPE);
PUSH_FIELD (constants_type_node, field, "size", unsigned_int_type_node);
PUSH_FIELD (constants_type_node, field, "tags", ptr_type_node);
dtable_type = make_node (RECORD_TYPE);
dtable_ptr_type = build_pointer_type (dtable_type);
- one_elt_array_domain_type = build_index_type (integer_one_node);
otable_type = build_array_type (integer_type_node,
one_elt_array_domain_type);
TYPE_NONALIASED_COMPONENT (otable_type) = 1;
otable_ptr_type = build_pointer_type (otable_type);
- atable_type = build_array_type (ptr_type_node,
- one_elt_array_domain_type);
- TYPE_NONALIASED_COMPONENT (atable_type) = 1;
- atable_ptr_type = build_pointer_type (atable_type);
-
- symbol_type = make_node (RECORD_TYPE);
- PUSH_FIELD (symbol_type, field, "clname", utf8const_ptr_type);
- PUSH_FIELD (symbol_type, field, "name", utf8const_ptr_type);
- PUSH_FIELD (symbol_type, field, "signature", utf8const_ptr_type);
- FINISH_RECORD (symbol_type);
-
- symbols_array_type = build_array_type (symbol_type,
- one_elt_array_domain_type);
- symbols_array_ptr_type = build_pointer_type (symbols_array_type);
-
- if (flag_indirect_dispatch)
- {
- otable_decl = build_decl (VAR_DECL, get_identifier ("otable"), otable_type);
- DECL_EXTERNAL (otable_decl) = 1;
- TREE_STATIC (otable_decl) = 1;
- TREE_READONLY (otable_decl) = 1;
- TREE_CONSTANT (otable_decl) = 1;
- pushdecl (otable_decl);
- otable_syms_decl = build_decl (VAR_DECL, get_identifier ("otable_syms"),
- symbols_array_type);
- TREE_STATIC (otable_syms_decl) = 1;
- TREE_CONSTANT (otable_syms_decl) = 1;
- pushdecl (otable_syms_decl);
-
- atable_decl = build_decl (VAR_DECL, get_identifier ("atable"), atable_type);
- DECL_EXTERNAL (atable_decl) = 1;
- TREE_STATIC (atable_decl) = 1;
- TREE_READONLY (atable_decl) = 1;
- TREE_CONSTANT (atable_decl) = 1;
- pushdecl (atable_decl);
- atable_syms_decl = build_decl (VAR_DECL, get_identifier ("atable_syms"),
- symbols_array_type);
- TREE_STATIC (atable_syms_decl) = 1;
- TREE_CONSTANT (atable_syms_decl) = 1;
- pushdecl (atable_syms_decl);
- }
-
- {
- tree catch_class_type = make_node (RECORD_TYPE);
- PUSH_FIELD (catch_class_type, field, "address", utf8const_ptr_type);
- PUSH_FIELD (catch_class_type, field, "classname", ptr_type_node);
- FINISH_RECORD (catch_class_type);
-
- ctable_decl
- = build_decl (VAR_DECL, get_identifier ("catch_classes"),
- build_array_type
- (catch_class_type, 0));
- DECL_EXTERNAL (ctable_decl) = 1;
- TREE_STATIC (ctable_decl) = 1;
- TREE_READONLY (ctable_decl) = 1;
- TREE_CONSTANT (ctable_decl) = 1;
- pushdecl (ctable_decl);
- }
PUSH_FIELD (object_type_node, field, "vtable", dtable_ptr_type);
/* This isn't exactly true, but it is what we have in the source.
eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS
? "__gcj_personality_sj0"
: "__gcj_personality_v0");
- lang_eh_runtime_type = prepare_eh_table_type;
+
+ lang_eh_runtime_type = do_nothing;
init_jcf_parse ();
initialize_builtins ();
-
soft_fmod_node = built_in_decls[BUILT_IN_FMOD];
#if 0
soft_fmodf_node = built_in_decls[BUILT_IN_FMODF];
current_function_decl = fndecl;
input_location = DECL_SOURCE_LOCATION (fndecl);
+ output_class = DECL_CONTEXT (current_function_decl);
current_class = DECL_CONTEXT (fndecl);
timevar_push (TV_EXPAND);
/* Handle exceptions for GNU compiler for the Java(TM) language.
- Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003
+ Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of GCC.
prepare_eh_table_type (tree type)
{
tree exp;
+ tree *slot;
const char *name;
char *buf;
tree decl;
* rewritten to point to the appropriate class. */
if (type == NULL_TREE)
- exp = NULL_TREE;
- else if (is_compiled_class (type) && !flag_indirect_dispatch)
+ return NULL_TREE;
+
+ if (TYPE_TO_RUNTIME_MAP (output_class) == NULL)
+ TYPE_TO_RUNTIME_MAP (output_class) = java_treetreehash_create (10, 1);
+
+ slot = java_treetreehash_new (TYPE_TO_RUNTIME_MAP (output_class), type);
+ if (*slot != NULL)
+ return TREE_VALUE (*slot);
+
+ if (is_compiled_class (type) && !flag_indirect_dispatch)
{
name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
buf = alloca (strlen (name) + 5);
DECL_INITIAL (decl) = build_class_ref (type);
layout_decl (decl, 0);
pushdecl (decl);
- rest_of_decl_compilation (decl, (char*) 0, global_bindings_p (), 0);
- make_decl_rtl (decl, (char*) 0);
exp = build1 (ADDR_EXPR, ptr_type_node, decl);
}
else
TREE_THIS_VOLATILE (decl) = 0;
layout_decl (decl, 0);
pushdecl (decl);
- rest_of_decl_compilation (decl, (char*) 0, global_bindings_p (), 0);
- make_decl_rtl (decl, (char*) 0);
exp = build1 (ADDR_EXPR, build_pointer_type (utf8const_ptr_type), decl);
- catch_classes = tree_cons (NULL, make_catch_class_record (exp, utf8_ref), catch_classes);
+ TYPE_CATCH_CLASSES (output_class) =
+ tree_cons (NULL, make_catch_class_record (exp, utf8_ref),
+ TYPE_CATCH_CLASSES (output_class));
}
+
+ *slot = tree_cons (type, exp, NULL_TREE);
+
return exp;
}
+static int
+expand_catch_class (void **entry, void *x ATTRIBUTE_UNUSED)
+{
+ struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
+ tree decl = TREE_OPERAND (TREE_VALUE ((tree)ite->value), 0);
+ rest_of_decl_compilation (decl, (char*) 0, global_bindings_p (), 0);
+ return true;
+}
+
+/* For every class in the TYPE_TO_RUNTIME_MAP, expand the
+ corresponding object that is used by the runtime type matcher. */
+
+void
+java_expand_catch_classes (tree this_class)
+{
+ if (TYPE_TO_RUNTIME_MAP (this_class))
+ htab_traverse
+ (TYPE_TO_RUNTIME_MAP (this_class),
+ expand_catch_class, NULL);
+}
/* Build a reference to the jthrowable object being carried in the
exception header. */
if (type == NULL)
type = throwable_type_node;
- expand_start_catch (type);
+ expand_start_catch (prepare_eh_table_type (type));
expand_goto (TREE_VALUE (handler));
expand_end_catch ();
}
/* Process expressions for the GNU compiler for the Java(TM) language.
- Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of GCC.
if (base_type != TREE_TYPE (self_value))
self_value = fold (build1 (NOP_EXPR, base_type, self_value));
if (flag_indirect_dispatch
- && current_class != self_class)
- /* FIXME: current_class != self_class is not exactly the right
+ && output_class != self_class)
+ /* FIXME: output_class != self_class is not exactly the right
test. What we really want to know is whether self_class is
- in the same translation unit as current_class. If it is,
+ in the same translation unit as output_class. If it is,
we can make a direct reference. */
{
- tree otable_index
- = build_int_2
- (get_symbol_table_index (field_decl, &otable_methods), 0);
- tree field_offset = build (ARRAY_REF, integer_type_node, otable_decl,
- otable_index);
+ tree otable_index =
+ build_int_2 (get_symbol_table_index
+ (field_decl, &TYPE_OTABLE_METHODS (output_class)), 0);
+ tree field_offset =
+ build (ARRAY_REF, integer_type_node, TYPE_OTABLE_DECL (output_class),
+ otable_index);
tree address
= fold (build (PLUS_EXPR,
build_pointer_type (TREE_TYPE (field_decl)),
}
else
{
- tree table_index = build_int_2 (get_symbol_table_index
- (method, &atable_methods), 0);
- func = build (ARRAY_REF, method_ptr_type_node, atable_decl,
- table_index);
+ tree table_index =
+ build_int_2 (get_symbol_table_index
+ (method, &TYPE_ATABLE_METHODS (output_class)), 0);
+ func =
+ build (ARRAY_REF, method_ptr_type_node,
+ TYPE_ATABLE_DECL (output_class), table_index);
}
}
else
if (flag_indirect_dispatch)
{
otable_index
- = build_int_2 (get_symbol_table_index (method, &otable_methods), 0);
- method_index = build (ARRAY_REF, integer_type_node, otable_decl,
+ = build_int_2 (get_symbol_table_index
+ (method, &TYPE_OTABLE_METHODS (output_class)), 0);
+ method_index = build (ARRAY_REF, integer_type_node,
+ TYPE_OTABLE_DECL (output_class),
otable_index);
}
else
if (flag_indirect_dispatch)
{
- otable_index
- = build_int_2 (get_symbol_table_index (method, &otable_methods), 0);
- idx = build (ARRAY_REF, integer_type_node, otable_decl, otable_index);
+ otable_index =
+ build_int_2 (get_symbol_table_index
+ (method, &TYPE_OTABLE_METHODS (output_class)), 0);
+ idx =
+ build (ARRAY_REF, integer_type_node, TYPE_OTABLE_DECL (output_class),
+ otable_index);
}
else
{
tree decl = BLOCK_EXPR_DECLS (catch);
tree type = (decl ? TREE_TYPE (TREE_TYPE (decl)) : NULL_TREE);
- expand_start_catch (type);
+ expand_start_catch (prepare_eh_table_type (type));
expand_expr_stmt (TREE_OPERAND (current, 0));
expand_end_catch ();
}
/* Definitions for parsing and type checking for the GNU compiler for
the Java(TM) language.
- Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of GCC.
#define main_class \
java_global_trees[JTI_MAIN_CLASS]
-/* The class we are currently processing. */
+/* The class we use as the base for name resolution. It's usually the
+ class we're generating code for but sometimes it points to an inner
+ class. If you really want to know the class we're currently
+ generating code for, use output_class instead. */
#define current_class \
java_global_trees[JTI_CURRENT_CLASS]
+/* The class we are currently generating. Really. */
+#define output_class \
+ java_global_trees[JTI_OUTPUT_CLASS]
+
/* List of all class DECLs seen so far. */
#define all_class_list \
java_global_trees[JTI_ALL_CLASS_LIST]
/* List of virtual decls referred to by this translation unit, used to
generate virtual method offset symbol table. */
-#define otable_methods java_global_trees [JTI_OTABLE_METHODS]
-/* List of static decls referred to by this translation unit, used to
- generate virtual method offset symbol table. */
-#define atable_methods java_global_trees [JTI_ATABLE_METHODS]
/* The virtual offset table. This is emitted as uninitialized data of
the required length, and filled out at run time during class
linking. */
-#define otable_decl java_global_trees [JTI_OTABLE_DECL]
-/* The static address table. */
-#define atable_decl java_global_trees [JTI_ATABLE_DECL]
/* The virtual offset symbol table. Used by the runtime to fill out
the otable. */
-#define otable_syms_decl java_global_trees [JTI_OTABLE_SYMS_DECL]
-/* The static symbol table. Used by the runtime to fill out the
- otable. */
-#define atable_syms_decl java_global_trees [JTI_ATABLE_SYMS_DECL]
-
-#define ctable_decl java_global_trees [JTI_CTABLE_DECL]
-#define catch_classes java_global_trees [JTI_CATCH_CLASSES]
extern int flag_emit_class_files;
/* The Java .class file that provides main_class; the main input file. */
extern GTY(()) struct JCF * current_jcf;
+/* Set to nonzero value in order to emit class initialization code
+ before static field references. */
+extern int always_initialize_class_p;
+
typedef struct CPool constant_pool;
#define CONSTANT_ResolvedFlag 16
JTI_MAIN_CLASS,
JTI_CURRENT_CLASS,
+ JTI_OUTPUT_CLASS,
JTI_ALL_CLASS_LIST,
JTI_ALL_CLASS_FILENAME,
- JTI_OTABLE_METHODS,
- JTI_OTABLE_DECL,
- JTI_OTABLE_SYMS_DECL,
-
- JTI_ATABLE_METHODS,
- JTI_ATABLE_DECL,
- JTI_ATABLE_SYMS_DECL,
-
- JTI_CTABLE_DECL,
- JTI_CATCH_CLASSES,
-
JTI_PREDEF_FILENAMES,
JTI_MAX
/* The original WFL of a final variable. */
#define DECL_FIELD_FINAL_WFL(NODE) \
(DECL_LANG_SPECIFIC(NODE)->u.v.wfl)
+/* The class that's the owner of a dynamic binding table. */
+#define DECL_OWNER(NODE) \
+ (DECL_LANG_SPECIFIC(NODE)->u.v.owner)
/* True if NODE is a local variable final. */
#define LOCAL_FINAL_P(NODE) (DECL_LANG_SPECIFIC (NODE) && DECL_FINAL (NODE))
/* True if NODE is a final field. */
tree slot_chain;
tree am; /* Access method for this field (1.1) */
tree wfl; /* Original wfl */
+ tree owner;
unsigned int final_iud : 1; /* Final initialized upon declaration */
unsigned int cif : 1; /* True: decl is a class initialization flag */
unsigned int freed; /* Decl is no longer in scope. */
#define TYPE_STRICTFP(T) (TYPE_LANG_SPECIFIC(T)->strictfp)
#define TYPE_USES_ASSERTIONS(T) (TYPE_LANG_SPECIFIC(T)->assertions)
+#define TYPE_ATABLE_METHODS(T) (TYPE_LANG_SPECIFIC(T)->atable_methods)
+#define TYPE_ATABLE_SYMS_DECL(T) (TYPE_LANG_SPECIFIC(T)->atable_syms_decl)
+#define TYPE_ATABLE_DECL(T) (TYPE_LANG_SPECIFIC(T)->atable_decl)
+
+#define TYPE_OTABLE_METHODS(T) (TYPE_LANG_SPECIFIC(T)->otable_methods)
+#define TYPE_OTABLE_SYMS_DECL(T) (TYPE_LANG_SPECIFIC(T)->otable_syms_decl)
+#define TYPE_OTABLE_DECL(T) (TYPE_LANG_SPECIFIC(T)->otable_decl)
+
+#define TYPE_CTABLE_DECL(T) (TYPE_LANG_SPECIFIC(T)->ctable_decl)
+#define TYPE_CATCH_CLASSES(T) (TYPE_LANG_SPECIFIC(T)->catch_classes)
+
+#define TYPE_TO_RUNTIME_MAP(T) (TYPE_LANG_SPECIFIC(T)->type_to_runtime_map)
+
struct lang_type GTY(())
{
tree signature;
tree package_list; /* List of package names, progressive */
tree import_list; /* Imported types, in the CU of this class */
tree import_demand_list; /* Imported types, in the CU of this class */
+
+ tree otable_methods; /* List of static decls referred to by this class. */
+ tree otable_decl; /* The static address table. */
+ tree otable_syms_decl;
+
+ tree atable_methods; /* List of static decls referred to by this class. */
+ tree atable_decl; /* The static address table. */
+ tree atable_syms_decl;
+
+ tree ctable_decl; /* The table of classes for the runtime type matcher. */
+ tree catch_classes;
+
+ htab_t GTY ((param_is (struct treetreehash_entry))) type_to_runtime_map;
+ /* The mapping of classes to exception region markers. */
+
unsigned pic:1; /* Private Inner Class. */
unsigned poic:1; /* Protected Inner Class. */
unsigned strictfp:1; /* `strictfp' class. */
extern tree create_label_decl (tree);
extern void push_labeled_block (tree);
extern tree prepare_eh_table_type (tree);
+extern void java_expand_catch_classes (tree);
extern tree build_exception_object_ref (tree);
extern tree generate_name (void);
extern void pop_labeled_block (void);
extern int get_symbol_table_index (tree, tree *);
extern tree make_catch_class_record (tree, tree);
-extern void emit_catch_table (void);
+extern tree emit_catch_table (tree);
+
+extern void gen_indirect_dispatch_tables (tree type);
#define DECL_FINAL(DECL) DECL_LANG_FLAG_3 (DECL)
/* Parser for Java(TM) .class files.
- Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003
+ Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of GCC.
extern struct obstack temporary_obstack;
-/* Set to nonzero value in order to emit class initialization code
- before static field references. */
-extern int always_initialize_class_p;
-
static GTY(()) tree parse_roots[3];
/* The FIELD_DECL for the current field. */
#define HANDLE_CLASS_INFO(ACCESS_FLAGS, THIS, SUPER, INTERFACES_COUNT) \
{ tree super_class = SUPER==0 ? NULL_TREE : get_class_constant (jcf, SUPER); \
- current_class = give_name_to_class (jcf, THIS); \
+ output_class = current_class = give_name_to_class (jcf, THIS); \
set_super_info (ACCESS_FLAGS, current_class, super_class, INTERFACES_COUNT);}
#define HANDLE_CLASS_INTERFACE(INDEX) \
wfl_operator = build_expr_wfl (NULL_TREE, NULL, 0, 0);
EXPR_WFL_FILENAME_NODE (wfl_operator) = file;
input_filename = ggc_strdup (filename);
- current_class = NULL_TREE;
+ output_class = current_class = NULL_TREE;
current_function_decl = NULL_TREE;
if (!HAS_BEEN_ALREADY_PARSED_P (file))
{
{
java_parser_context_save_global ();
java_push_parser_context ();
- current_class = class;
+ output_class = current_class = class;
input_filename = current_jcf->filename;
if (JCF_SEEN_IN_ZIP (current_jcf))
read_zip_member(current_jcf,
load_inner_classes (class);
}
- current_class = save_current_class;
+ output_class = current_class = save_current_class;
input_location = save_location;
current_jcf = save_current_jcf;
return 1;
compiling from class files. */
always_initialize_class_p = 1;
+ gen_indirect_dispatch_tables (current_class);
+
java_mark_class_local (current_class);
for (method = TYPE_METHODS (current_class);
input_filename = IDENTIFIER_POINTER (TREE_VALUE (node));
if (CLASS_FILE_P (node))
{
- current_class = TREE_PURPOSE (node);
+ output_class = current_class = TREE_PURPOSE (node);
current_jcf = TYPE_JCF (current_class);
layout_class (current_class);
load_inner_classes (current_class);
/* Emit the .jcf section. */
emit_register_classes ();
- if (flag_indirect_dispatch)
- {
- otable_decl
- = emit_symbol_table
- (get_identifier ("otable"),
- otable_decl, otable_methods, otable_syms_decl, integer_type_node);
- atable_decl
- = emit_symbol_table
- (get_identifier ("atable"),
- atable_decl, atable_methods, atable_syms_decl, ptr_type_node);
- }
- emit_catch_table ();
}
write_resource_constructor ();
class = lookup_class (get_identifier (class_name));
FREE (class_name);
current_jcf = TYPE_JCF (class);
- current_class = class;
+ output_class = current_class = class;
if (! CLASS_LOADED_P (class))
{
/* Java(TM) language-specific utility routines.
- Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of GCC.
if (flag_inline_functions)
flag_inline_trees = 1;
+ /* FIXME: Indirect dispatch isn't yet compatible with static class
+ init optimization. */
+ if (flag_indirect_dispatch)
+ always_initialize_class_p = true;
+
/* Force minimum function alignment if g++ uses the least significant
bit of function pointers to store the virtual bit. This is required
to keep vtables compatible. */
(DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), ite->key);
if (! h)
return true;
-
splay_tree_insert (decl_map,
(splay_tree_key) ite->value,
(splay_tree_value) h);
-
return true;
}
static bool
java_decl_ok_for_sibcall (tree decl)
{
- return decl != NULL && DECL_CONTEXT (decl) == current_class;
+ return decl != NULL && DECL_CONTEXT (decl) == output_class;
}
/* Used by estimate_num_insns. Estimate number of instructions seen
static tree
java_get_callee_fndecl (tree call_expr)
{
- tree method, table, element;
+ tree method, table, element, atable_methods;
HOST_WIDE_INT index;
if (TREE_CODE (method) != ARRAY_REF)
return NULL;
table = TREE_OPERAND (method, 0);
- if (table != atable_decl)
+ if (! DECL_LANG_SPECIFIC(table)
+ || !DECL_OWNER (table)
+ || TYPE_ATABLE_DECL (DECL_OWNER (table)) != table)
return NULL;
- index = TREE_INT_CST_LOW (TREE_OPERAND (method, 1));
+ atable_methods = TYPE_ATABLE_METHODS (DECL_OWNER (table));
+ index = TREE_INT_CST_LOW (TREE_OPERAND (method, 1));
+
/* FIXME: Replace this for loop with a hash table lookup. */
for (element = atable_methods; element; element = TREE_CHAIN (element))
{
}
--index;
}
-
+
return NULL;
}
/* Source code parsing and tree node generation for the GNU compiler
for the Java(TM) language.
- Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
if (CLASS_INTERFACE (TYPE_NAME (class_type)))
continue;
- current_class = class_type;
+ output_class = current_class = class_type;
for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
{
if (DECL_CONSTRUCTOR_P (decl))
for (current = gclass_list; current; current = TREE_CHAIN (current))
{
- current_class = TREE_TYPE (TREE_VALUE (current));
+ output_class = current_class = TREE_TYPE (TREE_VALUE (current));
if (current_class == stop_reordering)
break;
for (current = gclass_list; current; current = TREE_CHAIN (current))
{
- current_class = TREE_TYPE (TREE_VALUE (current));
+ output_class = current_class = TREE_TYPE (TREE_VALUE (current));
layout_class (current_class);
/* Error reported by the caller */
{
tree clinit, decl, first_decl;
- current_class = TREE_TYPE (class_decl);
+ output_class = current_class = TREE_TYPE (class_decl);
/* Pre-expand <clinit> to figure whether we really need it or
not. If we do need it, we pre-expand the static fields so they're
for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
{
+ tree current;
+ for (current = cur_ctxp->class_list;
+ current;
+ current = TREE_CHAIN (current))
+ gen_indirect_dispatch_tables (TREE_TYPE (current));
+ }
+
+ for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
+ {
ctxp = cur_ctxp;
input_filename = ctxp->filename;
lang_init_source (2); /* Error msgs have method prototypes */
}
input_filename = main_input_filename;
-
/* Find anonymous classes and expand their constructor. This extra pass is
necessary because the constructor itself is only generated when the
method in which it is defined is expanded. */
ctxp = cur_ctxp;
for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
{
- current_class = TREE_TYPE (current);
+ output_class = current_class = TREE_TYPE (current);
if (ANONYMOUS_CLASS_P (current_class))
{
tree d;
for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
{
tree d;
- current_class = TREE_TYPE (current);
+ output_class = current_class = TREE_TYPE (current);
for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
{
if (DECL_RESULT (d) == NULL_TREE)
for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
{
tree d;
- current_class = TREE_TYPE (current);
+ output_class = current_class = TREE_TYPE (current);
for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
{
if (DECL_RESULT (d) == NULL_TREE)
current;
current = TREE_CHAIN (current))
{
- current_class = TREE_TYPE (TREE_VALUE (current));
+ output_class = current_class = TREE_TYPE (TREE_VALUE (current));
if (flag_emit_class_files)
write_classfile (current_class);
if (flag_emit_xref)
ctxp = cur_ctxp;
for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
{
- current_class = TREE_TYPE (current);
+ output_class = current_class = TREE_TYPE (current);
finish_class ();
}
}
projects / platform / upstream / linaro-gcc.git / commitdiff