/* Process declarations and variables for the GNU compiler for the
Java(TM) language.
-
- Copyright (C) 1996, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU CC.
#include "config.h"
#include "system.h"
#include "tree.h"
+#include "toplev.h"
+#include "flags.h"
#include "java-tree.h"
#include "jcf.h"
#include "toplev.h"
-
-#ifndef INT_TYPE_SIZE
-#define INT_TYPE_SIZE BITS_PER_WORD
+#include "function.h"
+#include "except.h"
+#include "defaults.h"
+#include "java-except.h"
+#include "ggc.h"
+
+#if defined (DEBUG_JAVA_BINDING_LEVELS)
+extern void indent PROTO((void));
#endif
+static tree push_jvm_slot PARAMS ((int, tree));
+static tree lookup_name_current_level PARAMS ((tree));
+static tree push_promoted_type PARAMS ((const char *, tree));
+static struct binding_level *make_binding_level PARAMS ((void));
+static boolean emit_init_test_initialization PARAMS ((struct hash_entry *,
+ hash_table_key));
+static tree create_primitive_vtable PARAMS ((const char *));
+
+/* Set to non-zero value in order to emit class initilization code
+ before static field references. */
+extern int always_initialize_class_p;
+
+/* Use garbage collection. */
+
+int ggc_p = 1;
+
/* 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.
/* A list of local variables VAR_DECLs for this method that we have seen
debug information, but we have not reached their starting (byte) PC yet. */
-tree pending_local_decls = NULL_TREE;
+static tree pending_local_decls = NULL_TREE;
+
+tree throw_node [2];
/* Push a local variable or stack slot into the decl_map,
and assign it an rtl. */
-tree
+#if defined(DEBUG_JAVA_BINDING_LEVELS)
+int binding_depth = 0;
+int is_class_level = 0;
+int current_pc;
+
+void
+indent ()
+{
+ register unsigned i;
+
+ for (i = 0; i < binding_depth*2; i++)
+ putc (' ', stderr);
+}
+#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
+
+static tree
push_jvm_slot (index, decl)
int index;
tree decl;
if (DECL_LANG_SPECIFIC (decl) == NULL)
{
DECL_LANG_SPECIFIC (decl)
- = (struct lang_decl *) permalloc (sizeof (struct lang_decl_var));
+ = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl_var));
DECL_LOCAL_START_PC (decl) = 0;
DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
DECL_LOCAL_SLOT_NUMBER (decl) = index;
/* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
that is valid at PC (or -1 if any pc).
- If there is no existing matching decl, allocate one.
- If we find a decl with matching modes but different types,
- we re-use the rtl, but create a new decl. */
+ If there is no existing matching decl, allocate one. */
tree
find_local_variable (index, type, pc)
tree type;
int pc;
{
- struct rtx_def *rtl = NULL;
tree decl = TREE_VEC_ELT (decl_map, index);
tree best = NULL_TREE;
+
while (decl != NULL_TREE)
{
int in_range;
&& pc < DECL_LOCAL_END_PC (decl));
if ((TREE_TYPE (decl) == type
+ || (TREE_CODE (TREE_TYPE (decl)) == TREE_CODE (type)
+ && TYPE_PRECISION (TREE_TYPE (decl)) <= 32
+ && TYPE_PRECISION (type) <= 32
+ && TREE_CODE (type) != POINTER_TYPE)
|| (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
&& type == ptr_type_node))
&& in_range)
/* The bytecode PC that marks the end of this level. */
int end_pc;
+ /* The bytecode PC that marks the start of this level. */
+ int start_pc;
+
+#if defined(DEBUG_JAVA_BINDING_LEVELS)
+ /* Binding depth at which this level began. */
+ unsigned binding_depth;
+#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
};
#define NULL_BINDING_LEVEL (struct binding_level *) NULL
static struct binding_level *global_binding_level;
+/* A PC value bigger than any PC value we may ever may encounter. */
+
+#define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
+
/* Binding level structures are initialized by copying this one. */
static struct binding_level clear_binding_level
= {NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
- NULL_BINDING_LEVEL, 0, 0, 0, 0, 1000000000};
+ NULL_BINDING_LEVEL, 0, 0, 0, 0, LARGEST_PC, 0};
#if 0
/* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
if it has subblocks. */
static int keep_next_if_subblocks;
+
+tree java_global_trees[JTI_MAX];
-/* The FUNCTION_DECL for the function currently being compiled,
- or 0 if between functions. */
-tree current_function_decl;
-
-/* The type node for the ordinary character type. */
-tree char_type_node;
-
-tree object_type_node;
-tree object_ptr_type_node;
-tree string_type_node;
-tree throwable_type_node;
-tree runtime_exception_type_node;
-tree error_exception_type_node;
-
-tree boolean_type_node;
-
-tree float_type_node;
-tree double_type_node;
-
-/* a VOID_TYPE node. */
-
-tree void_type_node;
-tree ptr_type_node;
-tree return_address_type_node;
-
-tree integer_type_node;
-
-tree byte_type_node;
-tree short_type_node;
-tree int_type_node;
-tree long_type_node;
-
-tree promoted_byte_type_node;
-tree promoted_short_type_node;
-tree promoted_char_type_node;
-tree promoted_boolean_type_node;
-
-tree unsigned_byte_type_node;
-tree unsigned_short_type_node;
-tree unsigned_int_type_node;
-tree unsigned_long_type_node;
-
-/* The type for struct methodtable. */
-tree methodtable_type;
-tree methodtable_ptr_type;
-
-tree utf8const_type;
-tree utf8const_ptr_type;
-tree class_type_node;
-tree class_ptr_type;
-tree field_type_node;
-tree field_ptr_type_node;
-tree field_info_union_node;
-tree jexception_type;
-tree jexception_ptr_type;
-tree lineNumberEntry_type;
-tree lineNumbers_type;
-tree constants_type_node;
-tree dtable_type;
-tree dtable_ptr_type;
-tree method_type_node;
-tree method_ptr_type_node;
-tree nativecode_ptr_array_type_node;
-tree one_elt_array_domain_type;
-tree access_flags_type_node;
-tree class_dtable_decl;
-
-/* a node which has tree code ERROR_MARK, and whose type is itself.
- All erroneous expressions are replaced with this node. All functions
- that accept nodes as arguments should avoid generating error messages
- if this node is one of the arguments, since it is undesirable to get
- multiple error messages from one error in the input. */
-
-tree error_mark_node;
-
-/* Two expressions that are constants with value zero.
- The first is of type `int', the second of type `void *'. */
-tree integer_zero_node;
-tree null_pointer_node;
-
-/* Nodes for boolean constants TRUE and FALSE. */
-tree boolean_true_node, boolean_false_node;
-
-tree TYPE_identifier_node;
-tree init_identifier_node;
-tree clinit_identifier_node;
-tree void_signature_node;
-tree length_identifier_node;
-tree this_identifier_node;
-tree super_identifier_node;
-
-/* References to internal libjava functions we use. */
-tree alloc_object_node;
-tree soft_instanceof_node;
-tree soft_checkcast_node;
-tree soft_initclass_node;
-tree soft_newarray_node;
-tree soft_anewarray_node;
-tree soft_multianewarray_node;
-tree soft_badarrayindex_node;
-tree throw_node;
-tree soft_checkarraystore_node;
-tree soft_monitorenter_node;
-tree soft_monitorexit_node;
-tree soft_lookupinterfacemethod_node;
-tree soft_fmod_node;
-tree soft_exceptioninfo_call_node;
+tree predef_filenames[PREDEF_FILENAMES_SIZE];
/* Build (and pushdecl) a "promoted type" for all standard
types shorter than int. */
static tree
push_promoted_type (name, actual_type)
- char *name;
+ const char *name;
tree actual_type;
{
tree type = make_node (TREE_CODE (actual_type));
tree in_min = TYPE_MIN_VALUE (actual_type);
tree in_max = TYPE_MAX_VALUE (actual_type);
#endif
- TYPE_MIN_VALUE (type) = build_int_2 (TREE_INT_CST_LOW (in_min),
- TREE_INT_CST_HIGH (in_min));
+ TYPE_MIN_VALUE (type) = copy_node (in_min);
TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
- TYPE_MAX_VALUE (type) = build_int_2 (TREE_INT_CST_LOW (in_max),
- TREE_INT_CST_HIGH (in_max));
+ TYPE_MAX_VALUE (type) = copy_node (in_max);
TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node);
layout_type (type);
return type;
}
-/* Nodes for integer constants. */
-tree integer_one_node, integer_two_node, integer_four_node;
-tree integer_negative_one_node;
-
/* Return a definition for a builtin function named NAME and whose data type
is TYPE. TYPE should be a function type with argument types.
FUNCTION_CODE tells later passes how to compile calls to this function.
the name to be called if we can't opencode the function. */
tree
-builtin_function (name, type, function_code, library_name)
- char *name;
+builtin_function (name, type, function_code, class, library_name)
+ const char *name;
tree type;
- enum built_in_function function_code;
- char *library_name;
+ int function_code;
+ enum built_in_class class;
+ const char *library_name;
{
tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
DECL_EXTERNAL (decl) = 1;
DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
make_decl_rtl (decl, NULL_PTR, 1);
pushdecl (decl);
- if (function_code != NOT_BUILT_IN)
- {
- DECL_BUILT_IN (decl) = 1;
- DECL_FUNCTION_CODE (decl) = function_code;
- }
+ DECL_BUILT_IN_CLASS (decl) = class;
+ DECL_FUNCTION_CODE (decl) = function_code;
return decl;
}
+/* Return tree that represents a vtable for a primitive array. */
+static tree
+create_primitive_vtable (name)
+ const char *name;
+{
+ tree r;
+ char buf[50];
+
+ sprintf (buf, "_Jv_%sVTable", name);
+ r = build_decl (VAR_DECL, get_identifier (buf), ptr_type_node);
+ DECL_EXTERNAL (r) = 1;
+ make_decl_rtl (r, buf, 1);
+ return r;
+}
+
void
init_decl_processing ()
{
- tree field;
+ register tree endlink;
+ tree field = NULL_TREE;
tree t;
current_function_decl = NULL;
pushlevel (0); /* make the binding_level structure for global names */
global_binding_level = current_binding_level;
+ /* The code here must be similar to build_common_tree_nodes{,_2} in
+ tree.c, especially as to the order of initializing common nodes. */
error_mark_node = make_node (ERROR_MARK);
TREE_TYPE (error_mark_node) = error_mark_node;
/* Create sizetype first - needed for other types. */
- sizetype = make_unsigned_type (POINTER_SIZE);
- size_zero_node = build_int_2 (0, 0);
- TREE_TYPE (size_zero_node) = sizetype;
- size_one_node = build_int_2 (1, 0);
- TREE_TYPE (size_one_node) = sizetype;
+ initialize_sizetypes ();
byte_type_node = make_signed_type (8);
pushdecl (build_decl (TYPE_DECL, get_identifier ("byte"), byte_type_node));
pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned long"),
unsigned_long_type_node));
- integer_type_node = type_for_size (INT_TYPE_SIZE, 0);
+ set_sizetype (make_unsigned_type (POINTER_SIZE));
+ /* Define these next since types below may used them. */
+ integer_type_node = type_for_size (INT_TYPE_SIZE, 0);
integer_zero_node = build_int_2 (0, 0);
integer_one_node = build_int_2 (1, 0);
integer_two_node = build_int_2 (2, 0);
integer_four_node = build_int_2 (4, 0);
integer_negative_one_node = build_int_2 (-1, 0);
+ size_zero_node = size_int (0);
+ size_one_node = size_int (1);
+ bitsize_zero_node = bitsize_int (0);
+ bitsize_one_node = bitsize_int (1);
+ bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
+
+ long_zero_node = build_int_2 (0, 0);
+ TREE_TYPE (long_zero_node) = long_type_node;
+
void_type_node = make_node (VOID_TYPE);
pushdecl (build_decl (TYPE_DECL, get_identifier ("void"), void_type_node));
layout_type (void_type_node); /* Uses size_zero_node */
null_pointer_node = build_int_2 (0, 0);
TREE_TYPE (null_pointer_node) = ptr_type_node;
+ /* Used by the parser to represent empty statements and blocks. */
+ empty_stmt_node = build1 (NOP_EXPR, void_type_node, size_zero_node);
+ CAN_COMPLETE_NORMALLY (empty_stmt_node) = 1;
+
#if 0
/* Make a type to be the domain of a few array types
whose domains don't really matter.
double_type_node));
layout_type (double_type_node);
+ float_zero_node = build_real (float_type_node, dconst0);
+ double_zero_node = build_real (double_type_node, dconst0);
+
+ /* These are the vtables for arrays of primitives. */
+ boolean_array_vtable = create_primitive_vtable ("boolean");
+ byte_array_vtable = create_primitive_vtable ("byte");
+ char_array_vtable = create_primitive_vtable ("char");
+ short_array_vtable = create_primitive_vtable ("short");
+ int_array_vtable = create_primitive_vtable ("int");
+ long_array_vtable = create_primitive_vtable ("long");
+ float_array_vtable = create_primitive_vtable ("float");
+ double_array_vtable = create_primitive_vtable ("double");
+
+ /* 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. */
+ unqualified_object_id_node = get_identifier ("Object");
object_type_node = lookup_class (get_identifier ("java.lang.Object"));
object_ptr_type_node = promote_type (object_type_node);
string_type_node = lookup_class (get_identifier ("java.lang.String"));
+ string_ptr_type_node = promote_type (string_type_node);
class_type_node = lookup_class (get_identifier ("java.lang.Class"));
throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable"));
runtime_exception_type_node =
lookup_class (get_identifier ("java.lang.RuntimeException"));
error_exception_type_node =
lookup_class (get_identifier ("java.lang.Error"));
+ rawdata_ptr_type_node
+ = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
+
+ /* If you add to this section, don't forget to increase
+ PREDEF_FILENAMES_SIZE. */
+ predef_filenames [0] = get_identifier ("java/lang/Class.java");
+ predef_filenames [1] = get_identifier ("java/lang/Error.java");
+ predef_filenames [2] = get_identifier ("java/lang/Object.java");
+ predef_filenames [3] = get_identifier ("java/lang/RuntimeException.java");
+ predef_filenames [4] = get_identifier ("java/lang/String.java");
+ predef_filenames [5] = get_identifier ("java/lang/Throwable.java");
+ predef_filenames [6] = get_identifier ("gnu/gcj/RawData.java");
methodtable_type = make_node (RECORD_TYPE);
layout_type (methodtable_type);
- pushdecl (build_decl (TYPE_DECL, get_identifier ("methodtable"),
- methodtable_type));
+ build_decl (TYPE_DECL, get_identifier ("methodtable"), methodtable_type);
methodtable_ptr_type = build_pointer_type (methodtable_type);
TYPE_identifier_node = get_identifier ("TYPE");
init_identifier_node = get_identifier ("<init>");
clinit_identifier_node = get_identifier ("<clinit>");
+ /* Legacy `$finit$' special method identifier. This needs to be
+ recognized as equivalent to `finit$' but isn't generated anymore. */
+ finit_leg_identifier_node = get_identifier ("$finit$");
+ /* The new `finit$' special method identifier. This one is now
+ generated in place of `$finit$'. */
+ finit_identifier_node = get_identifier ("finit$");
void_signature_node = get_identifier ("()V");
length_identifier_node = get_identifier ("length");
this_identifier_node = get_identifier ("this");
super_identifier_node = get_identifier ("super");
+ continue_identifier_node = get_identifier ("continue");
+ access0_identifier_node = get_identifier ("access$0");
/* for lack of a better place to put this stub call */
init_expr_processing();
PUSH_FIELD (constants_type_node, field, "tags", ptr_type_node);
PUSH_FIELD (constants_type_node, field, "data", ptr_type_node);
FINISH_RECORD (constants_type_node);
- pushdecl (build_decl (TYPE_DECL, get_identifier ("constants"),
- constants_type_node));
+ build_decl (TYPE_DECL, get_identifier ("constants"), constants_type_node);
access_flags_type_node = unsigned_short_type_node;
dtable_type = make_node (RECORD_TYPE);
dtable_ptr_type = build_pointer_type (dtable_type);
- PUSH_FIELD (object_type_node, field, "dtable", dtable_ptr_type);
- PUSH_FIELD (object_type_node, field, "sync_info", ptr_type_node);
+ PUSH_FIELD (object_type_node, field, "vtable", dtable_ptr_type);
+ /* This isn't exactly true, but it is what we have in the source.
+ There is an unresolved issue here, which is whether the vtable
+ should be marked by the GC. */
+ if (! flag_hash_synchronization)
+ PUSH_FIELD (object_type_node, field, "sync_info",
+ build_pointer_type (object_type_node));
for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
FIELD_PRIVATE (t) = 1;
FINISH_RECORD (object_type_node);
PUSH_FIELD (class_type_node, field, "name", utf8const_ptr_type);
PUSH_FIELD (class_type_node, field, "accflags", access_flags_type_node);
PUSH_FIELD (class_type_node, field, "superclass", class_ptr_type);
- PUSH_FIELD (class_type_node, field, "subclass_head", class_ptr_type);
- PUSH_FIELD (class_type_node, field, "subclass_next", class_ptr_type);
PUSH_FIELD (class_type_node, field, "constants", constants_type_node);
PUSH_FIELD (class_type_node, field, "methods", method_ptr_type_node);
- PUSH_FIELD (class_type_node, field, "nmethods", short_type_node);
- PUSH_FIELD (class_type_node, field, "msize", short_type_node);
+ PUSH_FIELD (class_type_node, field, "method_count", short_type_node);
+ PUSH_FIELD (class_type_node, field, "vtable_method_count", short_type_node);
PUSH_FIELD (class_type_node, field, "fields", field_ptr_type_node);
- PUSH_FIELD (class_type_node, field, "bfsize", int_type_node);
- PUSH_FIELD (class_type_node, field, "nfields", short_type_node);
- PUSH_FIELD (class_type_node, field, "nsfields", short_type_node);
- PUSH_FIELD (class_type_node, field, "dtable", dtable_ptr_type);
+ PUSH_FIELD (class_type_node, field, "size_in_bytes", int_type_node);
+ PUSH_FIELD (class_type_node, field, "field_count", short_type_node);
+ PUSH_FIELD (class_type_node, field, "static_field_count", short_type_node);
+ PUSH_FIELD (class_type_node, field, "vtable", dtable_ptr_type);
PUSH_FIELD (class_type_node, field, "interfaces",
build_pointer_type (class_ptr_type));
PUSH_FIELD (class_type_node, field, "loader", ptr_type_node);
- PUSH_FIELD (class_type_node, field, "interface_len", short_type_node);
+ PUSH_FIELD (class_type_node, field, "interface_count", short_type_node);
PUSH_FIELD (class_type_node, field, "state", byte_type_node);
PUSH_FIELD (class_type_node, field, "thread", ptr_type_node);
+ PUSH_FIELD (class_type_node, field, "depth", short_type_node);
+ PUSH_FIELD (class_type_node, field, "ancestors", ptr_type_node);
+ PUSH_FIELD (class_type_node, field, "idt", ptr_type_node);
for (t = TYPE_FIELDS (class_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
FIELD_PRIVATE (t) = 1;
push_super_field (class_type_node, object_type_node);
FINISH_RECORD (class_type_node);
- pushdecl (build_decl (TYPE_DECL, get_identifier ("Class"), class_type_node));
+ build_decl (TYPE_DECL, get_identifier ("Class"), class_type_node);
field_info_union_node = make_node (UNION_TYPE);
PUSH_FIELD (field_info_union_node, field, "boffset", int_type_node);
PUSH_FIELD (field_type_node, field, "info", field_info_union_node);
FINISH_RECORD (field_type_node);
CLASS_LOADED_P (field_type_node) = 1;
- pushdecl (build_decl (TYPE_DECL, get_identifier ("Field"), field_type_node));
+ build_decl (TYPE_DECL, get_identifier ("Field"), field_type_node);
one_elt_array_domain_type = build_index_type (integer_one_node);
nativecode_ptr_array_type_node
PUSH_FIELD (dtable_type, field, "class", class_ptr_type);
PUSH_FIELD (dtable_type, field, "methods", nativecode_ptr_array_type_node);
FINISH_RECORD (dtable_type);
- pushdecl (build_decl (TYPE_DECL, get_identifier ("dispatchTable"), dtable_type));
+ build_decl (TYPE_DECL, get_identifier ("dispatchTable"), dtable_type);
#define jint_type int_type_node
#define jint_ptr_type ptr_type_node
PUSH_FIELD (jexception_type, field, "handler_pc", ptr_type_node);
PUSH_FIELD (jexception_type, field, "catch_type", class_ptr_type);
FINISH_RECORD (jexception_type);
- pushdecl (build_decl (TYPE_DECL, get_identifier ("jexception"), field_type_node));
+ build_decl (TYPE_DECL, get_identifier ("jexception"), field_type_node);
jexception_ptr_type = build_pointer_type (jexception_type);
lineNumberEntry_type = make_node (RECORD_TYPE);
PUSH_FIELD (method_type_node, field, "ncode", nativecode_ptr_type_node);
FINISH_RECORD (method_type_node);
CLASS_LOADED_P (method_type_node) = 1;
- pushdecl (build_decl (TYPE_DECL, get_identifier ("Method"), method_type_node));
+ build_decl (TYPE_DECL, get_identifier ("Method"), method_type_node);
+
+ endlink = end_params_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
t = tree_cons (NULL_TREE, class_ptr_type,
- build_tree_list (NULL_TREE, int_type_node));
+ tree_cons (NULL_TREE, int_type_node, endlink));
alloc_object_node = builtin_function ("_Jv_AllocObject",
build_function_type (ptr_type_node, t),
- NOT_BUILT_IN, NULL_PTR);
+ 0, NOT_BUILT_IN, NULL_PTR);
+ DECL_IS_MALLOC (alloc_object_node) = 1;
+
+ t = tree_cons (NULL_TREE, ptr_type_node, endlink);
soft_initclass_node = builtin_function ("_Jv_InitClass",
build_function_type (void_type_node,
t),
- NOT_BUILT_IN, NULL_PTR);
- t = build_tree_list (NULL_TREE, void_type_node);
- throw_node = builtin_function ("_Jv_Throw",
- build_function_type (ptr_type_node, t),
- NOT_BUILT_IN, NULL_PTR);
+ 0, NOT_BUILT_IN,
+ NULL_PTR);
+ throw_node[0] = builtin_function ("_Jv_Throw",
+ build_function_type (ptr_type_node, t),
+ 0, NOT_BUILT_IN, NULL_PTR);
+ /* Mark throw_nodes as `noreturn' functions with side effects. */
+ TREE_THIS_VOLATILE (throw_node[0]) = 1;
+ TREE_SIDE_EFFECTS (throw_node[0]) = 1;
+ t = tree_cons (NULL_TREE, ptr_type_node, endlink);
+ throw_node[1] = builtin_function ("_Jv_Sjlj_Throw",
+ build_function_type (ptr_type_node, t),
+ 0, NOT_BUILT_IN, NULL_PTR);
+ TREE_THIS_VOLATILE (throw_node[1]) = 1;
+ TREE_SIDE_EFFECTS (throw_node[1]) = 1;
+ t = build_function_type (int_type_node, endlink);
soft_monitorenter_node
- = builtin_function ("_Jv_MonitorEnter",
- build_function_type (int_type_node, t),
- NOT_BUILT_IN, NULL_PTR);
+ = builtin_function ("_Jv_MonitorEnter", t, 0, NOT_BUILT_IN,
+ NULL_PTR);
soft_monitorexit_node
- = builtin_function ("_Jv_MonitorExit",
- build_function_type (int_type_node, t),
- NOT_BUILT_IN, NULL_PTR);
+ = builtin_function ("_Jv_MonitorExit", t, 0, NOT_BUILT_IN,
+ NULL_PTR);
t = tree_cons (NULL_TREE, int_type_node,
- build_tree_list (NULL_TREE, int_type_node));
+ tree_cons (NULL_TREE, int_type_node, endlink));
soft_newarray_node
= builtin_function ("_Jv_NewArray",
build_function_type(ptr_type_node, t),
- NOT_BUILT_IN, NULL_PTR );
+ 0, NOT_BUILT_IN, NULL_PTR);
+ DECL_IS_MALLOC (soft_newarray_node) = 1;
t = tree_cons (NULL_TREE, int_type_node,
tree_cons (NULL_TREE, class_ptr_type,
- build_tree_list (NULL_TREE,
- object_ptr_type_node)));
+ tree_cons (NULL_TREE, object_ptr_type_node, endlink)));
soft_anewarray_node
= builtin_function ("_Jv_NewObjectArray",
build_function_type (ptr_type_node, t),
- NOT_BUILT_IN, NULL_PTR );
+ 0, NOT_BUILT_IN, NULL_PTR);
+ DECL_IS_MALLOC (soft_anewarray_node) = 1;
t = tree_cons (NULL_TREE, ptr_type_node,
- build_tree_list (NULL_TREE, int_type_node));
+ tree_cons (NULL_TREE, int_type_node, endlink));
soft_multianewarray_node
= builtin_function ("_Jv_NewMultiArray",
build_function_type (ptr_type_node, t),
- NOT_BUILT_IN, NULL_PTR );
+ 0, NOT_BUILT_IN, NULL_PTR);
+ DECL_IS_MALLOC (soft_multianewarray_node) = 1;
t = build_function_type (void_type_node,
- build_tree_list (NULL_TREE, int_type_node));
+ tree_cons (NULL_TREE, int_type_node, endlink));
soft_badarrayindex_node
= builtin_function ("_Jv_ThrowBadArrayIndex", t,
- NOT_BUILT_IN, NULL_PTR);
+ 0, NOT_BUILT_IN, NULL_PTR);
+ /* Mark soft_badarrayindex_node as a `noreturn' function with side
+ effects. */
TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
+ soft_nullpointer_node
+ = builtin_function ("_Jv_ThrowNullPointerException",
+ build_function_type (void_type_node, endlink),
+ 0, NOT_BUILT_IN, NULL_PTR);
+ /* Mark soft_nullpointer_node as a `noreturn' function with side
+ effects. */
+ TREE_THIS_VOLATILE (soft_nullpointer_node) = 1;
+ TREE_SIDE_EFFECTS (soft_nullpointer_node) = 1;
+
t = tree_cons (NULL_TREE, class_ptr_type,
- build_tree_list (NULL_TREE, object_ptr_type_node));
+ tree_cons (NULL_TREE, object_ptr_type_node, endlink));
soft_checkcast_node
= builtin_function ("_Jv_CheckCast",
build_function_type (ptr_type_node, t),
- NOT_BUILT_IN, NULL_PTR);
+ 0, NOT_BUILT_IN, NULL_PTR);
t = tree_cons (NULL_TREE, object_ptr_type_node,
- build_tree_list (NULL_TREE, class_ptr_type));
+ tree_cons (NULL_TREE, class_ptr_type, endlink));
soft_instanceof_node
= builtin_function ("_Jv_IsInstanceOf",
- build_function_type (promoted_boolean_type_node, t),
- NOT_BUILT_IN, NULL_PTR);
+ build_function_type (boolean_type_node, t),
+ 0, NOT_BUILT_IN, NULL_PTR);
t = tree_cons (NULL_TREE, object_ptr_type_node,
- build_tree_list (NULL_TREE, object_ptr_type_node));
+ tree_cons (NULL_TREE, object_ptr_type_node, endlink));
soft_checkarraystore_node
= builtin_function ("_Jv_CheckArrayStore",
build_function_type (void_type_node, t),
- NOT_BUILT_IN, NULL_PTR);
+ 0, NOT_BUILT_IN, NULL_PTR);
t = tree_cons (NULL_TREE, ptr_type_node,
tree_cons (NULL_TREE, ptr_type_node,
- build_tree_list (NULL_TREE, ptr_type_node)));
+ tree_cons (NULL_TREE, int_type_node, endlink)));
soft_lookupinterfacemethod_node
- = builtin_function ("_Jv_LookupInterfaceMethod",
+ = builtin_function ("_Jv_LookupInterfaceMethodIdx",
+ build_function_type (ptr_type_node, t),
+ 0, NOT_BUILT_IN, NULL_PTR);
+
+ t = tree_cons (NULL_TREE, object_ptr_type_node,
+ tree_cons (NULL_TREE, ptr_type_node,
+ tree_cons (NULL_TREE, ptr_type_node, endlink)));
+ soft_lookupjnimethod_node
+ = builtin_function ("_Jv_LookupJNIMethod",
+ build_function_type (ptr_type_node, t),
+ 0, NOT_BUILT_IN, NULL_PTR);
+ t = tree_cons (NULL_TREE, ptr_type_node, endlink);
+ soft_getjnienvnewframe_node
+ = builtin_function ("_Jv_GetJNIEnvNewFrame",
+ build_function_type (ptr_type_node, t),
+ 0, NOT_BUILT_IN, NULL_PTR);
+ soft_jnipopsystemframe_node
+ = builtin_function ("_Jv_JNI_PopSystemFrame",
build_function_type (ptr_type_node, t),
- NOT_BUILT_IN, NULL_PTR);
+ 0, NOT_BUILT_IN, NULL_PTR);
+
t = tree_cons (NULL_TREE, double_type_node,
- build_tree_list (NULL_TREE, double_type_node));
+ tree_cons (NULL_TREE, double_type_node, endlink));
soft_fmod_node
= builtin_function ("__builtin_fmod",
build_function_type (double_type_node, t),
- BUILT_IN_FMOD, "fmod");
+ BUILT_IN_FMOD, BUILT_IN_NORMAL, "fmod");
- t = build_tree_list (NULL_TREE, void_type_node);
soft_exceptioninfo_call_node
= build (CALL_EXPR,
ptr_type_node,
build_address_of
(builtin_function ("_Jv_exception_info",
- build_function_type (ptr_type_node, t),
- NOT_BUILT_IN, NULL_PTR)),
+ build_function_type (ptr_type_node, endlink),
+ 0, NOT_BUILT_IN, NULL_PTR)),
NULL_TREE, NULL_TREE);
TREE_SIDE_EFFECTS (soft_exceptioninfo_call_node) = 1;
#if 0
t = tree_cons (NULL_TREE, float_type_node,
- build_tree_list (NULL_TREE, float_type_node));
+ tree_cons (NULL_TREE, float_type_node, endlink));
soft_fmodf_node
= builtin_function ("__builtin_fmodf",
build_function_type (float_type_node, t),
- BUILT_IN_FMOD, "fmodf");
+ BUILT_IN_FMOD, BUILT_IN_NORMAL, "fmodf");
#endif
+ soft_idiv_node
+ = builtin_function ("_Jv_divI",
+ build_function_type (int_type_node, t),
+ 0, NOT_BUILT_IN, NULL_PTR);
+
+ soft_irem_node
+ = builtin_function ("_Jv_remI",
+ build_function_type (int_type_node, t),
+ 0, NOT_BUILT_IN, NULL_PTR);
+
+ soft_ldiv_node
+ = builtin_function ("_Jv_divJ",
+ build_function_type (long_type_node, t),
+ 0, NOT_BUILT_IN, NULL_PTR);
+
+ soft_lrem_node
+ = builtin_function ("_Jv_remJ",
+ build_function_type (long_type_node, t),
+ 0, NOT_BUILT_IN, NULL_PTR);
+
init_class_processing ();
+ init_jcf_parse ();
+
+ /* Register nodes with the garbage collector. */
+ ggc_add_tree_root (java_global_trees,
+ sizeof (java_global_trees) / sizeof (tree));
+ ggc_add_tree_root (throw_node,
+ sizeof (throw_node) / sizeof (tree));
+ ggc_add_tree_root (predef_filenames,
+ sizeof (predef_filenames) / sizeof (tree));
+ ggc_add_tree_root (&decl_map, 1);
+ ggc_add_tree_root (&pending_local_decls, 1);
}
/* Similar to `lookup_name' but look only at current binding level and
the previous one if its the parameter level. */
-tree
+static tree
lookup_name_current_level (name)
tree name;
{
register tree t;
register tree name = DECL_NAME (x);
register struct binding_level *b = current_binding_level;
-
- DECL_CONTEXT (x) = current_function_decl;
+
+ if (TREE_CODE (x) != TYPE_DECL)
+ DECL_CONTEXT (x) = current_function_decl;
if (name)
{
- char *file;
+ const char *file;
int line;
- int different_binding_level = 0;
t = lookup_name_current_level (name);
if (t != 0 && t == error_mark_node)
{
/* Here to install a non-global value. */
tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
- tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
IDENTIFIER_LOCAL_VALUE (name) = x;
#if 0
/* No shadow warnings for vars made for inlining. */
&& ! DECL_FROM_INLINE (x))
{
- char *warnstring = 0;
+ const char *warnstring = 0;
if (TREE_CODE (x) == PARM_DECL
&& current_binding_level->level_chain->parm_flag)
return x;
}
+
void
pushdecl_force_head (x)
tree x;
/* Create a new `struct binding_level'. */
-static
-struct binding_level *
+static struct binding_level *
make_binding_level ()
{
/* NOSTRICT */
void
pushlevel (unused)
- int unused;
+ int unused ATTRIBUTE_UNUSED;
{
register struct binding_level *newlevel = NULL_BINDING_LEVEL;
keep_next_level_flag = 0;
newlevel->keep_if_subblocks = keep_next_if_subblocks;
keep_next_if_subblocks = 0;
+#if defined(DEBUG_JAVA_BINDING_LEVELS)
+ newlevel->binding_depth = binding_depth;
+ indent ();
+ fprintf (stderr, "push %s level 0x%08x pc %d\n",
+ (is_class_level) ? "class" : "block", newlevel, current_pc);
+ is_class_level = 0;
+ binding_depth++;
+#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
}
/* Exit a binding level.
tree decl;
int block_previously_created;
+#if defined(DEBUG_JAVA_BINDING_LEVELS)
+ binding_depth--;
+ indent ();
+ if (current_binding_level->end_pc != LARGEST_PC)
+ fprintf (stderr, "pop %s level 0x%08x pc %d (end pc %d)\n",
+ (is_class_level) ? "class" : "block", current_binding_level, current_pc,
+ current_binding_level->end_pc);
+ else
+ fprintf (stderr, "pop %s level 0x%08x pc %d\n",
+ (is_class_level) ? "class" : "block", current_binding_level, current_pc);
+#if 0
+ if (is_class_level != (current_binding_level == class_binding_level))
+ {
+ indent ();
+ fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
+ }
+ is_class_level = 0;
+#endif
+#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
+
keep |= current_binding_level->keep;
/* Get the decls in the order they were written.
if (block != 0)
{
BLOCK_VARS (block) = decls;
- BLOCK_TYPE_TAGS (block) = NULL_TREE;
BLOCK_SUBBLOCKS (block) = subblocks;
- remember_end_note (block);
}
/* In each subblock, record that this is its superior. */
define_label (input_filename, lineno,
DECL_NAME (label));
}
- else if (warn_unused && !TREE_USED (label))
+ else if (warn_unused[UNUSED_LABEL] && !TREE_USED (label))
warning_with_decl (label, "label `%s' defined but not used");
IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
maybe_pushlevels (pc)
int pc;
{
+#if defined(DEBUG_JAVA_BINDING_LEVELS)
+ current_pc = pc;
+#endif
+
while (pending_local_decls != NULL_TREE &&
DECL_LOCAL_START_PC (pending_local_decls) <= pc)
{
if (end_pc > current_binding_level->end_pc)
end_pc = current_binding_level->end_pc;
+ maybe_start_try (pc, end_pc);
+
pushlevel (1);
expand_start_bindings (0);
+
current_binding_level->end_pc = end_pc;
-
+ current_binding_level->start_pc = pc;
current_binding_level->names = decl;
for ( ; decl != NULL_TREE; decl = TREE_CHAIN (decl))
{
push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl), decl);
}
- }
+ }
+
+ maybe_start_try (pc, 0);
}
void
maybe_poplevels (pc)
int pc;
{
+#if defined(DEBUG_JAVA_BINDING_LEVELS)
+ current_pc = pc;
+#endif
+
while (current_binding_level->end_pc <= pc)
{
expand_end_bindings (getdecls (), 1, 0);
+ maybe_end_try (current_binding_level->start_pc, pc);
+ poplevel (1, 0, 0);
+ }
+ maybe_end_try (0, pc);
+}
+
+/* Terminate any binding which began during the range beginning at
+ start_pc. This tidies up improperly nested local variable ranges
+ and exception handlers; a variable declared within an exception
+ range is forcibly terminated when that exception ends. */
+
+void
+force_poplevels (start_pc)
+ int start_pc;
+{
+ while (current_binding_level->start_pc > start_pc)
+ {
+ if (pedantic && current_binding_level->start_pc > start_pc)
+ warning_with_decl (current_function_decl,
+ "In %s: overlapped variable and exception ranges at %d",
+ current_binding_level->start_pc);
+ expand_end_bindings (getdecls (), 1, 0);
poplevel (1, 0, 0);
}
}
tree block;
{
TREE_USED (block) = 1;
- abort ();
current_binding_level->blocks
= chainon (current_binding_level->blocks, block);
}
= TREE_CODE (node) == VAR_DECL ? sizeof (struct lang_decl_var)
: sizeof (struct lang_decl);
struct lang_decl *x = (struct lang_decl *) oballoc (lang_decl_size);
- bcopy (DECL_LANG_SPECIFIC (node), x, lang_decl_size);
+ bcopy ((PTR) DECL_LANG_SPECIFIC (node), (PTR) x, lang_decl_size);
DECL_LANG_SPECIFIC (node) = x;
}
tree
maybe_build_cleanup (decl)
- tree decl;
+ tree decl ATTRIBUTE_UNUSED;
{
/* There are no cleanups in Java (I think). */
return NULL_TREE;
end_pc = DECL_CODE_LENGTH (current_function_decl);
}
DECL_LANG_SPECIFIC (decl)
- = (struct lang_decl *) permalloc (sizeof (struct lang_decl_var));
+ = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl_var));
DECL_LOCAL_SLOT_NUMBER (decl) = slot;
DECL_LOCAL_START_PC (decl) = start_pc;
+#if 0
+ /* FIXME: The range used internally for exceptions and local
+ variable ranges, is a half-open interval:
+ start_pc <= pc < end_pc. However, the range used in the
+ Java VM spec is inclusive at both ends:
+ start_pc <= pc <= end_pc. */
+ end_pc++;
+#endif
DECL_LOCAL_END_PC (decl) = end_pc;
/* Now insert the new decl in the proper place in
}
}
-void
-complete_start_java_method (fndecl)
+tree
+build_result_decl (fndecl)
tree fndecl;
{
tree restype = TREE_TYPE (TREE_TYPE (fndecl));
if (INTEGRAL_TYPE_P (restype)
&& TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
restype = integer_type_node;
- DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, restype);
+ return (DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, restype));
+}
+
+/* Called for every element in DECL_FUNCTION_INIT_TEST_TABLE in order
+ to emit initialization code for each test flag. */
+static boolean
+emit_init_test_initialization (entry, key)
+ struct hash_entry *entry;
+ hash_table_key key ATTRIBUTE_UNUSED;
+{
+ struct init_test_hash_entry *ite = (struct init_test_hash_entry *) entry;
+ tree klass = build_class_ref ((tree) entry->key);
+ expand_decl (ite->init_test_decl);
+
+ /* We initialize the class init check variable by looking at the
+ `state' field of the class to see if it is already initialized.
+ This makes things a bit faster if the class is already
+ initialized, which should be the common case. */
+ expand_expr_stmt
+ (build (MODIFY_EXPR, boolean_type_node,
+ ite->init_test_decl,
+ build (GE_EXPR, boolean_type_node,
+ build (COMPONENT_REF, byte_type_node,
+ build1 (INDIRECT_REF, class_type_node, klass),
+ lookup_field (&class_type_node,
+ get_identifier ("state"))),
+ build_int_2 (JV_STATE_DONE, 0))));
+
+ return true;
+}
+
+void
+complete_start_java_method (fndecl)
+ tree fndecl;
+{
if (! flag_emit_class_files)
{
/* Initialize the RTL code for the function. */
/* Set up parameters and prepare for return, for the function. */
expand_function_start (fndecl, 0);
+
+ /* Emit initialization code for test flags. */
+ if (! always_initialize_class_p)
+ hash_traverse (&DECL_FUNCTION_INIT_TEST_TABLE (fndecl),
+ emit_init_test_initialization, 0);
}
/* Allocate further tree nodes temporarily during compilation
#endif
- if (METHOD_STATIC (fndecl) && ! METHOD_PRIVATE (fndecl))
+ if (METHOD_STATIC (fndecl) && ! METHOD_PRIVATE (fndecl)
+ && ! flag_emit_class_files
+ && ! DECL_CLINIT_P (fndecl)
+ && ! CLASS_INTERFACE (TYPE_NAME (current_class)))
{
tree clas = DECL_CONTEXT (fndecl);
tree init = build (CALL_EXPR, void_type_node,
expand_expr_stmt (init);
}
- if (METHOD_SYNCHRONIZED (fndecl))
- {
- /* FIXME: surround the function body by a try/finally set. */
- }
-
/* Push local variables. Function compiled from source code are
using a different local variables management, and for them,
pushlevel shouldn't be called from here. */
if (! flag_emit_class_files)
expand_start_bindings (1);
}
+
+ if (METHOD_SYNCHRONIZED (fndecl) && ! flag_emit_class_files)
+ {
+ /* Wrap function body with a monitorenter plus monitorexit cleanup. */
+ tree enter, exit, lock;
+ if (METHOD_STATIC (fndecl))
+ lock = build_class_ref (DECL_CONTEXT (fndecl));
+ else
+ lock = DECL_ARGUMENTS (fndecl);
+ BUILD_MONITOR_ENTER (enter, lock);
+ BUILD_MONITOR_EXIT (exit, lock);
+ if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
+ {
+ expand_expr_stmt (enter);
+ expand_decl_cleanup (NULL_TREE, exit);
+ }
+ else
+ {
+ tree function_body = DECL_FUNCTION_BODY (fndecl);
+ tree body = BLOCK_EXPR_BODY (function_body);
+ lock = build (WITH_CLEANUP_EXPR, void_type_node,
+ enter, NULL_TREE, exit);
+ TREE_SIDE_EFFECTS (lock) = 1;
+ lock = build (COMPOUND_EXPR, TREE_TYPE (body), lock, body);
+ TREE_SIDE_EFFECTS (lock) = 1;
+ lock = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (body), lock);
+ TREE_SIDE_EFFECTS (lock) = 1;
+ BLOCK_EXPR_BODY (function_body) = lock;
+ }
+ }
}
void
decl_map = make_tree_vec (i);
type_map = (tree *) oballoc (i * sizeof (tree));
+#if defined(DEBUG_JAVA_BINDING_LEVELS)
+ fprintf (stderr, "%s:\n", (*decl_printable_name) (fndecl, 2));
+ current_pc = 0;
+#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
pushlevel (1); /* Push parameters. */
ptr = &DECL_ARGUMENTS (fndecl);
for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
- tem != NULL_TREE; tem = TREE_CHAIN (tem), i++)
+ tem != end_params_node; tem = TREE_CHAIN (tem), i++)
{
tree parm_name = NULL_TREE, parm_decl;
tree parm_type = TREE_VALUE (tem);
parm_decl = build_decl (PARM_DECL, parm_name, parm_type);
DECL_CONTEXT (parm_decl) = fndecl;
-#ifdef PROMOTE_PROTOTYPES
- if (TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
+ if (PROMOTE_PROTOTYPES
+ && TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
&& INTEGRAL_TYPE_P (parm_type))
parm_type = integer_type_node;
-#endif
DECL_ARG_TYPE (parm_decl) = parm_type;
*ptr = parm_decl;
while (i < DECL_MAX_LOCALS(fndecl))
type_map[i++] = NULL_TREE;
+ build_result_decl (fndecl);
complete_start_java_method (fndecl);
}
end_java_method ()
{
tree fndecl = current_function_decl;
+ int flag_asynchronous_exceptions = asynchronous_exceptions;
expand_end_bindings (getdecls (), 1, 0);
/* pop out of function */
/* Generate rtl for function exit. */
expand_function_end (input_filename, lineno, 0);
+ /* FIXME: If the current method contains any exception handlers,
+ force asynchronous_exceptions: this is necessary because signal
+ handlers in libjava may throw exceptions. This is far from being
+ a perfect solution, but it's better than doing nothing at all.*/
+ if (catch_clauses)
+ asynchronous_exceptions = 1;
+
/* Run the optimizers and output assembler code for this function. */
rest_of_compilation (fndecl);
current_function_decl = NULL_TREE;
permanent_allocation (1);
+ asynchronous_exceptions = flag_asynchronous_exceptions;
}
-tree
-build_decl_no_layout (code, name, type)
- enum tree_code code;
- tree name, type;
+/* Mark language-specific parts of T for garbage-collection. */
+
+void
+lang_mark_tree (t)
+ tree t;
{
- tree decl = build_decl (TYPE_DECL, name, type);
- TREE_SET_CODE (decl, code);
- return decl;
+ if (TREE_CODE (t) == IDENTIFIER_NODE)
+ {
+ struct lang_identifier *li = (struct lang_identifier *) t;
+ ggc_mark_tree (li->global_value);
+ ggc_mark_tree (li->local_value);
+ ggc_mark_tree (li->utf8_ref);
+ }
+ else if (TREE_CODE (t) == VAR_DECL
+ || TREE_CODE (t) == PARM_DECL)
+ {
+ struct lang_decl_var *ldv =
+ ((struct lang_decl_var *) DECL_LANG_SPECIFIC (t));
+ if (ldv)
+ {
+ ggc_mark (ldv);
+ ggc_mark_tree (ldv->slot_chain);
+ }
+ }
+ else if (TREE_CODE (t) == FUNCTION_DECL)
+ {
+ struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
+
+ if (ld)
+ {
+ ggc_mark (ld);
+ ggc_mark_tree (ld->throws_list);
+ ggc_mark_tree (ld->function_decl_body);
+ ggc_mark_tree (ld->called_constructor);
+ ggc_mark_tree (ld->inner_access);
+ }
+ }
+ else if (TYPE_P (t))
+ {
+ struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
+
+ if (lt)
+ {
+ ggc_mark (lt);
+ ggc_mark_tree (lt->signature);
+ ggc_mark_tree (lt->cpool_data_ref);
+ ggc_mark_tree (lt->finit_stmt_list);
+ ggc_mark_tree (lt->clinit_stmt_list);
+ ggc_mark_tree (lt->ii_block);
+ ggc_mark_tree (lt->dot_class);
+ }
+ }
}