1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA.
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc. */
26 /* Written by Per Bothner <bothner@cygnus.com> */
30 #include "coretypes.h"
35 #include "java-tree.h"
47 #include "tree-iterator.h"
50 /* DOS brain-damage */
52 #define O_BINARY 0 /* MS-DOS brain-damage */
55 static tree make_method_value (tree);
56 static tree build_java_method_type (tree, tree, int);
57 static int32 hashUtf8String (const char *, int);
58 static tree make_field_value (tree);
59 static tree get_dispatch_vector (tree);
60 static tree get_dispatch_table (tree, tree);
61 static int supers_all_compiled (tree type);
62 static tree maybe_layout_super_class (tree, tree);
63 static void add_miranda_methods (tree, tree);
64 static int assume_compiled (const char *);
65 static tree build_symbol_entry (tree);
66 static tree emit_assertion_table (tree);
67 static void register_class (void);
69 struct obstack temporary_obstack;
71 /* The compiler generates different code depending on whether or not
72 it can assume certain classes have been compiled down to native
73 code or not. The compiler options -fassume-compiled= and
74 -fno-assume-compiled= are used to create a tree of
75 class_flag_node objects. This tree is queried to determine if
76 a class is assume to be compiled or not. Each node in the tree
77 represents either a package or a specific class. */
79 typedef struct class_flag_node_struct
81 /* The class or package name. */
84 /* Nonzero if this represents an exclusion. */
87 /* Pointers to other nodes in the tree. */
88 struct class_flag_node_struct *parent;
89 struct class_flag_node_struct *sibling;
90 struct class_flag_node_struct *child;
93 static class_flag_node *find_class_flag_node (class_flag_node *, const char *);
94 static void add_class_flag (class_flag_node **, const char *, int);
96 /* This is the root of the include/exclude tree. */
98 static class_flag_node *assume_compiled_tree;
100 static class_flag_node *enable_assert_tree;
102 static GTY(()) tree class_roots[4];
103 #define fields_ident class_roots[0] /* get_identifier ("fields") */
104 #define info_ident class_roots[1] /* get_identifier ("info") */
105 #define class_list class_roots[2]
106 #define class_dtable_decl class_roots[3]
108 static GTY(()) VEC(tree,gc) *registered_class;
110 /* Return the node that most closely represents the class whose name
111 is IDENT. Start the search from NODE (followed by its siblings).
112 Return NULL if an appropriate node does not exist. */
114 static class_flag_node *
115 find_class_flag_node (class_flag_node *node, const char *ident)
119 size_t node_ident_length = strlen (node->ident);
121 /* node_ident_length is zero at the root of the tree. If the
122 identifiers are the same length, then we have matching
123 classes. Otherwise check if we've matched an enclosing
126 if (node_ident_length == 0
127 || (strncmp (ident, node->ident, node_ident_length) == 0
128 && (ident[node_ident_length] == '\0'
129 || ident[node_ident_length] == '.')))
131 /* We've found a match, however, there might be a more
134 class_flag_node *found = find_class_flag_node (node->child, ident);
141 /* No match yet. Continue through the sibling list. */
142 node = node->sibling;
145 /* No match at all in this tree. */
150 add_class_flag (class_flag_node **rootp, const char *ident, int value)
152 class_flag_node *root = *rootp;
153 class_flag_node *parent, *node;
155 /* Create the root of the tree if it doesn't exist yet. */
159 root = XNEW (class_flag_node);
162 root->sibling = NULL;
168 /* Calling the function with the empty string means we're setting
169 value for the root of the hierarchy. */
177 /* Find the parent node for this new node. PARENT will either be a
178 class or a package name. Adjust PARENT accordingly. */
180 parent = find_class_flag_node (root, ident);
181 if (strcmp (ident, parent->ident) == 0)
182 parent->value = value;
185 /* Insert new node into the tree. */
186 node = XNEW (class_flag_node);
188 node->ident = xstrdup (ident);
192 node->parent = parent;
193 node->sibling = parent->child;
194 parent->child = node;
198 /* Add a new IDENT to the include/exclude tree. It's an exclusion
199 if EXCLUDEP is nonzero. */
202 add_assume_compiled (const char *ident, int excludep)
204 add_class_flag (&assume_compiled_tree, ident, excludep);
207 /* The default value returned by enable_assertions. */
209 #define DEFAULT_ENABLE_ASSERT (flag_emit_class_files || optimize == 0)
211 /* Enter IDENT (a class or package name) into the enable-assertions table.
212 VALUE is true to enable and false to disable. */
215 add_enable_assert (const char *ident, int value)
217 if (enable_assert_tree == NULL)
218 add_class_flag (&enable_assert_tree, "", DEFAULT_ENABLE_ASSERT);
219 add_class_flag (&enable_assert_tree, ident, value);
222 /* Returns nonzero if IDENT is the name of a class that the compiler
223 should assume has been compiled to object code. */
226 assume_compiled (const char *ident)
231 if (NULL == assume_compiled_tree)
234 i = find_class_flag_node (assume_compiled_tree, ident);
241 /* Return true if we should generate code to check assertions within KLASS. */
244 enable_assertions (tree klass)
246 /* Check if command-line specifies whether we should check assertions. */
248 if (klass != NULL_TREE && DECL_NAME (klass) && enable_assert_tree != NULL)
250 const char *ident = IDENTIFIER_POINTER (DECL_NAME (klass));
251 class_flag_node *node
252 = find_class_flag_node (enable_assert_tree, ident);
256 /* The default is to enable assertions if generating class files,
257 or not optimizing. */
258 return DEFAULT_ENABLE_ASSERT;
261 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
262 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
263 Also, PREFIX is prepended, and SUFFIX is appended. */
266 ident_subst (const char* old_name,
273 int prefix_len = strlen (prefix);
274 int suffix_len = strlen (suffix);
275 int i = prefix_len + old_length + suffix_len + 1;
276 char *buffer = alloca (i);
278 strcpy (buffer, prefix);
279 for (i = 0; i < old_length; i++)
281 char ch = old_name[i];
284 buffer[prefix_len + i] = ch;
286 strcpy (buffer + prefix_len + old_length, suffix);
287 return get_identifier (buffer);
290 /* Return an IDENTIFIER_NODE the same as OLD_ID,
291 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
292 Also, PREFIX is prepended, and SUFFIX is appended. */
295 identifier_subst (const tree old_id,
301 return ident_subst (IDENTIFIER_POINTER (old_id), IDENTIFIER_LENGTH (old_id),
302 prefix, old_char, new_char, suffix);
305 /* Generate a valid C identifier from the name of the class TYPE,
306 prefixed by PREFIX. */
309 mangled_classname (const char *prefix, tree type)
311 tree ident = TYPE_NAME (type);
312 if (TREE_CODE (ident) != IDENTIFIER_NODE)
313 ident = DECL_NAME (ident);
314 return identifier_subst (ident, prefix, '.', '_', "");
321 type = make_node (RECORD_TYPE);
322 /* Unfortunately we must create the binfo here, so that class
324 TYPE_BINFO (type) = make_tree_binfo (0);
325 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
330 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
331 and where each of the constituents is separated by '/',
332 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
335 unmangle_classname (const char *name, int name_length)
337 tree to_return = ident_subst (name, name_length, "", '/', '.', "");
338 /* It's not sufficient to compare to_return and get_identifier
339 (name) to determine whether to_return is qualified. There are
340 cases in signature analysis where name will be stripped of a
342 name = IDENTIFIER_POINTER (to_return);
346 QUALIFIED_P (to_return) = 1;
353 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
356 const char *typename = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
357 char *buf = alloca (strlen (typename) + strlen (#NAME "_syms_") + 1); \
360 sprintf (buf, #NAME "_%s", typename); \
361 TYPE_## TABLE ##_DECL (type) = decl = \
362 build_decl (VAR_DECL, get_identifier (buf), TABLE_TYPE); \
363 DECL_EXTERNAL (decl) = 1; \
364 TREE_STATIC (decl) = 1; \
365 TREE_READONLY (decl) = 1; \
366 TREE_CONSTANT (decl) = 1; \
367 DECL_IGNORED_P (decl) = 1; \
368 /* Mark the table as belonging to this class. */ \
370 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
371 DECL_OWNER (decl) = TYPE; \
372 sprintf (buf, #NAME "_syms_%s", typename); \
373 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
374 build_decl (VAR_DECL, get_identifier (buf), symbols_array_type); \
375 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
376 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
377 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
381 /* Given a class, create the DECLs for all its associated indirect
384 gen_indirect_dispatch_tables (tree type)
386 const char *typename = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
389 char *buf = alloca (strlen (typename) + strlen ("_catch_classes_") + 1);
390 tree catch_class_type = make_node (RECORD_TYPE);
392 sprintf (buf, "_catch_classes_%s", typename);
393 PUSH_FIELD (catch_class_type, field, "address", utf8const_ptr_type);
394 PUSH_FIELD (catch_class_type, field, "classname", ptr_type_node);
395 FINISH_RECORD (catch_class_type);
397 TYPE_CTABLE_DECL (type)
398 = build_decl (VAR_DECL, get_identifier (buf),
399 build_array_type (catch_class_type, 0));
400 DECL_EXTERNAL (TYPE_CTABLE_DECL (type)) = 1;
401 TREE_STATIC (TYPE_CTABLE_DECL (type)) = 1;
402 TREE_READONLY (TYPE_CTABLE_DECL (type)) = 1;
403 TREE_CONSTANT (TYPE_CTABLE_DECL (type)) = 1;
404 DECL_IGNORED_P (TYPE_CTABLE_DECL (type)) = 1;
405 pushdecl (TYPE_CTABLE_DECL (type));
408 if (flag_indirect_dispatch)
410 GEN_TABLE (ATABLE, _atable, atable_type, type);
411 GEN_TABLE (OTABLE, _otable, otable_type, type);
412 GEN_TABLE (ITABLE, _itable, itable_type, type);
419 push_class (tree class_type, tree class_name)
421 tree decl, signature;
422 location_t saved_loc = input_location;
423 #ifndef USE_MAPPED_LOCATION
424 tree source_name = identifier_subst (class_name, "", '.', '/', ".java");
425 input_filename = IDENTIFIER_POINTER (source_name);
428 CLASS_P (class_type) = 1;
429 decl = build_decl (TYPE_DECL, class_name, class_type);
430 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
432 /* dbxout needs a DECL_SIZE if in gstabs mode */
433 DECL_SIZE (decl) = integer_zero_node;
435 input_location = saved_loc;
436 signature = identifier_subst (class_name, "L", '.', '/', ";");
437 IDENTIFIER_SIGNATURE_TYPE (signature) = build_pointer_type (class_type);
439 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
440 both a typedef and in the struct name-space. We may want to re-visit
441 this later, but for now it reduces the changes needed for gdb. */
442 DECL_ARTIFICIAL (decl) = 1;
444 pushdecl_top_level (decl);
449 /* Finds the (global) class named NAME. Creates the class if not found.
450 Also creates associated TYPE_DECL.
451 Does not check if the class actually exists, load the class,
452 fill in field or methods, or do layout_type. */
455 lookup_class (tree name)
457 tree decl = IDENTIFIER_CLASS_VALUE (name);
458 if (decl == NULL_TREE)
459 decl = push_class (make_class (), name);
460 return TREE_TYPE (decl);
464 set_super_info (int access_flags, tree this_class,
465 tree super_class, int interfaces_count)
467 int total_supers = interfaces_count;
468 tree class_decl = TYPE_NAME (this_class);
474 TYPE_BINFO (this_class) = make_tree_binfo (total_supers);
475 TYPE_VFIELD (this_class) = TYPE_VFIELD (object_type_node);
478 tree super_binfo = make_tree_binfo (0);
479 BINFO_TYPE (super_binfo) = super_class;
480 BINFO_OFFSET (super_binfo) = integer_zero_node;
481 BINFO_BASE_APPEND (TYPE_BINFO (this_class), super_binfo);
482 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class)) = 1;
485 set_class_decl_access_flags (access_flags, class_decl);
489 set_class_decl_access_flags (int access_flags, tree class_decl)
491 if (access_flags & ACC_PUBLIC) CLASS_PUBLIC (class_decl) = 1;
492 if (access_flags & ACC_FINAL) CLASS_FINAL (class_decl) = 1;
493 if (access_flags & ACC_SUPER) CLASS_SUPER (class_decl) = 1;
494 if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
495 if (access_flags & ACC_ABSTRACT) CLASS_ABSTRACT (class_decl) = 1;
496 if (access_flags & ACC_STATIC) CLASS_STATIC (class_decl) = 1;
497 if (access_flags & ACC_PRIVATE) CLASS_PRIVATE (class_decl) = 1;
498 if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
499 if (access_flags & ACC_STRICT) CLASS_STRICTFP (class_decl) = 1;
502 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
503 direct sub-classes of Object are 1, and so on. */
506 class_depth (tree clas)
509 if (! CLASS_LOADED_P (clas))
510 load_class (clas, 1);
511 if (TYPE_SIZE (clas) == error_mark_node)
513 while (clas != object_type_node)
516 clas = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas), 0));
521 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
524 interface_of_p (tree type1, tree type2)
527 tree binfo, base_binfo;
529 if (! TYPE_BINFO (type2))
532 for (binfo = TYPE_BINFO (type2), i = 0;
533 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
534 if (BINFO_TYPE (base_binfo) == type1)
537 for (binfo = TYPE_BINFO (type2), i = 0;
538 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) /* */
539 if (BINFO_TYPE (base_binfo)
540 && interface_of_p (type1, BINFO_TYPE (base_binfo)))
546 /* Return true iff TYPE1 inherits from TYPE2. */
549 inherits_from_p (tree type1, tree type2)
551 while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
556 if (! CLASS_LOADED_P (type1))
557 load_class (type1, 1);
559 type1 = maybe_layout_super_class (CLASSTYPE_SUPER (type1), type1);
564 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
567 enclosing_context_p (tree type1, tree type2)
569 if (!INNER_CLASS_TYPE_P (type2))
572 for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
574 type2 = (INNER_CLASS_TYPE_P (type2) ?
575 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
585 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
589 common_enclosing_context_p (tree type1, tree type2)
594 for (current = type2; current;
595 current = (INNER_CLASS_TYPE_P (current) ?
596 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
598 if (type1 == current)
601 if (INNER_CLASS_TYPE_P (type1))
602 type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1)));
609 /* Return 1 iff there exists a common enclosing "this" between TYPE1
610 and TYPE2, without crossing any static context. */
613 common_enclosing_instance_p (tree type1, tree type2)
615 if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
618 for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1;
619 type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
620 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
623 for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
624 current = (PURE_INNER_CLASS_TYPE_P (current) ?
625 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
627 if (type1 == current)
633 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
634 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
635 if attempt is made to add it twice. */
638 maybe_add_interface (tree this_class, tree interface_class)
640 tree binfo, base_binfo;
643 for (binfo = TYPE_BINFO (this_class), i = 0;
644 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
645 if (BINFO_TYPE (base_binfo) == interface_class)
646 return interface_class;
647 add_interface (this_class, interface_class);
651 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
654 add_interface (tree this_class, tree interface_class)
656 tree interface_binfo = make_tree_binfo (0);
658 BINFO_TYPE (interface_binfo) = interface_class;
659 BINFO_OFFSET (interface_binfo) = integer_zero_node;
660 BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node;
661 BINFO_VIRTUAL_P (interface_binfo) = 1;
663 BINFO_BASE_APPEND (TYPE_BINFO (this_class), interface_binfo);
667 /* Return the address of a pointer to the first FUNCTION_DECL
668 in the list (*LIST) whose DECL_NAME is NAME. */
671 find_named_method (tree *list, tree name)
673 while (*list && DECL_NAME (*list) != name)
674 list = &TREE_CHAIN (*list);
680 build_java_method_type (tree fntype, tree this_class, int access_flags)
682 if (access_flags & ACC_STATIC)
684 fntype = build_method_type (this_class, fntype);
686 /* We know that arg 1 of every nonstatic method is non-null; tell
688 TYPE_ATTRIBUTES (fntype) = (tree_cons
689 (get_identifier ("nonnull"),
690 tree_cons (NULL_TREE,
691 build_int_cst (NULL_TREE, 1),
693 TYPE_ATTRIBUTES (fntype)));
698 add_method_1 (tree this_class, int access_flags, tree name, tree function_type)
700 tree method_type, fndecl;
702 method_type = build_java_method_type (function_type,
703 this_class, access_flags);
705 fndecl = build_decl (FUNCTION_DECL, name, method_type);
706 DECL_CONTEXT (fndecl) = this_class;
708 DECL_LANG_SPECIFIC (fndecl)
709 = ggc_alloc_cleared (sizeof (struct lang_decl));
710 DECL_LANG_SPECIFIC (fndecl)->desc = LANG_DECL_FUNC;
712 /* Initialize the static initializer test table. */
714 DECL_FUNCTION_INIT_TEST_TABLE (fndecl) =
715 java_treetreehash_create (10, 1);
717 /* Initialize the initialized (static) class table. */
718 if (access_flags & ACC_STATIC)
719 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) =
720 htab_create_ggc (50, htab_hash_pointer, htab_eq_pointer, NULL);
722 /* Initialize the static method invocation compound list */
723 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = NULL_TREE;
725 TREE_CHAIN (fndecl) = TYPE_METHODS (this_class);
726 TYPE_METHODS (this_class) = fndecl;
728 /* Notice that this is a finalizer and update the class type
729 accordingly. This is used to optimize instance allocation. */
730 if (name == finalize_identifier_node
731 && TREE_TYPE (function_type) == void_type_node
732 && TREE_VALUE (TYPE_ARG_TYPES (function_type)) == void_type_node)
733 HAS_FINALIZER_P (this_class) = 1;
735 if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
736 if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
737 if (access_flags & ACC_PRIVATE)
738 METHOD_PRIVATE (fndecl) = DECL_INLINE (fndecl) = 1;
739 if (access_flags & ACC_NATIVE)
741 METHOD_NATIVE (fndecl) = 1;
742 DECL_EXTERNAL (fndecl) = 1;
744 if (access_flags & ACC_STATIC)
745 METHOD_STATIC (fndecl) = DECL_INLINE (fndecl) = 1;
746 if (access_flags & ACC_FINAL)
747 METHOD_FINAL (fndecl) = DECL_INLINE (fndecl) = 1;
748 if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
749 if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
750 if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
754 /* Add a method to THIS_CLASS.
755 The method's name is NAME.
756 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
759 add_method (tree this_class, int access_flags, tree name, tree method_sig)
761 tree function_type, fndecl;
762 const unsigned char *sig
763 = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
766 fatal_error ("bad method signature");
768 function_type = get_type_from_signature (method_sig);
769 fndecl = add_method_1 (this_class, access_flags, name, function_type);
770 set_java_signature (TREE_TYPE (fndecl), method_sig);
775 add_field (tree class, tree name, tree field_type, int flags)
777 int is_static = (flags & ACC_STATIC) != 0;
779 field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type);
780 TREE_CHAIN (field) = TYPE_FIELDS (class);
781 TYPE_FIELDS (class) = field;
782 DECL_CONTEXT (field) = class;
784 if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
785 if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
786 if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
787 if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
788 if (flags & ACC_VOLATILE) FIELD_VOLATILE (field) = 1;
789 if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
792 FIELD_STATIC (field) = 1;
793 /* Always make field externally visible. This is required so
794 that native methods can always access the field. */
795 TREE_PUBLIC (field) = 1;
796 /* Considered external until we know what classes are being
797 compiled into this object file. */
798 DECL_EXTERNAL (field) = 1;
804 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
807 set_constant_value (tree field, tree constant)
809 if (field == NULL_TREE)
810 warning (OPT_Wattributes,
811 "misplaced ConstantValue attribute (not in any field)");
812 else if (DECL_INITIAL (field) != NULL_TREE)
813 warning (OPT_Wattributes,
814 "duplicate ConstantValue attribute for field '%s'",
815 IDENTIFIER_POINTER (DECL_NAME (field)));
818 DECL_INITIAL (field) = constant;
819 if (TREE_TYPE (constant) != TREE_TYPE (field)
820 && ! (TREE_TYPE (constant) == int_type_node
821 && INTEGRAL_TYPE_P (TREE_TYPE (field))
822 && TYPE_PRECISION (TREE_TYPE (field)) <= 32)
823 && ! (TREE_TYPE (constant) == utf8const_ptr_type
824 && TREE_TYPE (field) == string_ptr_type_node))
825 error ("ConstantValue attribute of field '%s' has wrong type",
826 IDENTIFIER_POINTER (DECL_NAME (field)));
827 if (FIELD_FINAL (field))
828 DECL_FIELD_FINAL_IUD (field) = 1;
832 /* Count the number of Unicode chars encoded in a given Ut8 string. */
836 strLengthUtf8 (char *str, int len)
838 register unsigned char* ptr = (unsigned char*) str;
839 register unsigned char *limit = ptr + len;
841 for (; ptr < limit; str_length++) {
842 if (UTF8_GET (ptr, limit) < 0)
850 /* Calculate a hash value for a string encoded in Utf8 format.
851 * This returns the same hash value as specified for java.lang.String.hashCode.
855 hashUtf8String (const char *str, int len)
857 const unsigned char* ptr = (const unsigned char*) str;
858 const unsigned char *limit = ptr + len;
862 int ch = UTF8_GET (ptr, limit);
863 /* Updated specification from
864 http://www.javasoft.com/docs/books/jls/clarify.html. */
865 hash = (31 * hash) + ch;
870 static GTY(()) tree utf8_decl_list = NULL_TREE;
873 build_utf8_ref (tree name)
875 const char * name_ptr = IDENTIFIER_POINTER(name);
876 int name_len = IDENTIFIER_LENGTH(name);
878 tree ctype, field = NULL_TREE, str_type, cinit, string;
879 static int utf8_count = 0;
881 tree ref = IDENTIFIER_UTF8_REF (name);
883 if (ref != NULL_TREE)
886 ctype = make_node (RECORD_TYPE);
887 str_type = build_prim_array_type (unsigned_byte_type_node,
888 name_len + 1); /* Allow for final '\0'. */
889 PUSH_FIELD (ctype, field, "hash", unsigned_short_type_node);
890 PUSH_FIELD (ctype, field, "length", unsigned_short_type_node);
891 PUSH_FIELD (ctype, field, "data", str_type);
892 FINISH_RECORD (ctype);
893 START_RECORD_CONSTRUCTOR (cinit, ctype);
894 name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
895 PUSH_FIELD_VALUE (cinit, "hash", build_int_cst (NULL_TREE, name_hash));
896 PUSH_FIELD_VALUE (cinit, "length", build_int_cst (NULL_TREE, name_len));
897 string = build_string (name_len, name_ptr);
898 TREE_TYPE (string) = str_type;
899 PUSH_FIELD_VALUE (cinit, "data", string);
900 FINISH_RECORD_CONSTRUCTOR (cinit);
901 TREE_CONSTANT (cinit) = 1;
902 TREE_INVARIANT (cinit) = 1;
904 /* Generate a unique-enough identifier. */
905 sprintf(buf, "_Utf%d", ++utf8_count);
907 decl = build_decl (VAR_DECL, get_identifier (buf), utf8const_type);
908 TREE_STATIC (decl) = 1;
909 DECL_ARTIFICIAL (decl) = 1;
910 DECL_IGNORED_P (decl) = 1;
911 TREE_READONLY (decl) = 1;
912 TREE_THIS_VOLATILE (decl) = 0;
913 DECL_INITIAL (decl) = cinit;
915 if (HAVE_GAS_SHF_MERGE)
918 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
919 decl_size = (name_len + 5 + TYPE_ALIGN_UNIT (utf8const_type) - 1)
920 & ~(TYPE_ALIGN_UNIT (utf8const_type) - 1);
921 if (flag_merge_constants && decl_size < 256)
924 int flags = (SECTION_OVERRIDE
925 | SECTION_MERGE | (SECTION_ENTSIZE & decl_size));
926 sprintf (buf, ".rodata.jutf8.%d", decl_size);
927 switch_to_section (get_section (buf, flags, NULL));
928 DECL_SECTION_NAME (decl) = build_string (strlen (buf), buf);
932 TREE_CHAIN (decl) = utf8_decl_list;
933 layout_decl (decl, 0);
935 rest_of_decl_compilation (decl, global_bindings_p (), 0);
936 cgraph_varpool_mark_needed_node (cgraph_varpool_node (decl));
937 utf8_decl_list = decl;
938 ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
939 IDENTIFIER_UTF8_REF (name) = ref;
943 /* Like build_class_ref, but instead of a direct reference generate a
944 pointer into the constant pool. */
947 build_indirect_class_ref (tree type)
951 index = alloc_class_constant (type);
952 cl = build_ref_from_constant_pool (index);
953 return convert (promote_type (class_ptr_type), cl);
956 /* Build a reference to the class TYPE.
957 Also handles primitive types and array types. */
960 build_class_ref (tree type)
962 int is_compiled = is_compiled_class (type);
965 tree ref, decl_name, decl;
966 if (TREE_CODE (type) == POINTER_TYPE)
967 type = TREE_TYPE (type);
969 if (flag_indirect_dispatch
970 && type != output_class
971 && TREE_CODE (type) == RECORD_TYPE)
972 return build_indirect_class_ref (type);
974 if (TREE_CODE (type) == RECORD_TYPE)
976 if (TYPE_SIZE (type) == error_mark_node)
977 return null_pointer_node;
978 decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
979 "", '/', '/', ".class");
980 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
981 if (decl == NULL_TREE)
983 decl = build_decl (VAR_DECL, decl_name, class_type_node);
984 TREE_STATIC (decl) = 1;
985 TREE_PUBLIC (decl) = 1;
986 DECL_IGNORED_P (decl) = 1;
987 DECL_ARTIFICIAL (decl) = 1;
988 if (is_compiled == 1)
989 DECL_EXTERNAL (decl) = 1;
990 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
991 DECL_CLASS_FIELD_P (decl) = 1;
992 DECL_CONTEXT (decl) = type;
994 /* ??? We want to preserve the DECL_CONTEXT we set just above,
995 that that means not calling pushdecl_top_level. */
996 IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
1003 if (flag_emit_class_files)
1005 const char *prim_class_name;
1007 if (type == char_type_node)
1008 prim_class_name = "java.lang.Character";
1009 else if (type == boolean_type_node)
1010 prim_class_name = "java.lang.Boolean";
1011 else if (type == byte_type_node)
1012 prim_class_name = "java.lang.Byte";
1013 else if (type == short_type_node)
1014 prim_class_name = "java.lang.Short";
1015 else if (type == int_type_node)
1016 prim_class_name = "java.lang.Integer";
1017 else if (type == long_type_node)
1018 prim_class_name = "java.lang.Long";
1019 else if (type == float_type_node)
1020 prim_class_name = "java.lang.Float";
1021 else if (type == double_type_node)
1022 prim_class_name = "java.lang.Double";
1023 else if (type == void_type_node)
1024 prim_class_name = "java.lang.Void";
1028 prim_class = lookup_class (get_identifier (prim_class_name));
1029 /* We wrap the class in a NOP_EXPR, because it is a
1030 type. We can't hold it in the COMPONENT_REF itself,
1031 as that type must remain NULL. */
1032 prim_class = build1 (NOP_EXPR, prim_class, NULL_TREE);
1034 return build3 (COMPONENT_REF, NULL_TREE,
1035 prim_class, TYPE_identifier_node, NULL_TREE);
1037 decl_name = TYPE_NAME (type);
1038 if (TREE_CODE (decl_name) == TYPE_DECL)
1039 decl_name = DECL_NAME (decl_name);
1040 name = IDENTIFIER_POINTER (decl_name);
1041 if (strncmp (name, "promoted_", 9) == 0)
1043 sprintf (buffer, "_Jv_%sClass", name);
1044 decl_name = get_identifier (buffer);
1045 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1046 if (decl == NULL_TREE)
1048 decl = build_decl (VAR_DECL, decl_name, class_type_node);
1049 TREE_STATIC (decl) = 1;
1050 TREE_PUBLIC (decl) = 1;
1051 DECL_EXTERNAL (decl) = 1;
1052 DECL_ARTIFICIAL (decl) = 1;
1053 pushdecl_top_level (decl);
1057 ref = build1 (ADDR_EXPR, class_ptr_type, decl);
1061 return build_indirect_class_ref (type);
1064 /* Create a local statically allocated variable that will hold a
1065 pointer to a static field. */
1068 build_fieldref_cache_entry (int index, tree fdecl ATTRIBUTE_UNUSED)
1070 tree decl, decl_name;
1071 const char *name = IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class));
1072 char *buf = alloca (strlen (name) + 20);
1073 sprintf (buf, "%s_%d_ref", name, index);
1074 decl_name = get_identifier (buf);
1075 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1076 if (decl == NULL_TREE)
1078 decl = build_decl (VAR_DECL, decl_name, ptr_type_node);
1079 TREE_STATIC (decl) = 1;
1080 TREE_PUBLIC (decl) = 0;
1081 DECL_EXTERNAL (decl) = 0;
1082 DECL_ARTIFICIAL (decl) = 1;
1083 pushdecl_top_level (decl);
1089 build_static_field_ref (tree fdecl)
1091 tree fclass = DECL_CONTEXT (fdecl);
1092 int is_compiled = is_compiled_class (fclass);
1093 int from_class = ! CLASS_FROM_SOURCE_P (current_class);
1095 /* Allow static final fields to fold to a constant. When using
1096 -findirect-dispatch, we simply never do this folding if compiling
1097 from .class; in the .class file constants will be referred to via
1098 the constant pool. */
1099 if ((!flag_indirect_dispatch || !from_class)
1101 || (FIELD_FINAL (fdecl) && DECL_INITIAL (fdecl) != NULL_TREE
1102 && (JSTRING_TYPE_P (TREE_TYPE (fdecl))
1103 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl)))
1104 && TREE_CONSTANT (DECL_INITIAL (fdecl)))))
1106 if (is_compiled == 1)
1107 DECL_EXTERNAL (fdecl) = 1;
1111 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1112 and a class local static variable CACHE_ENTRY, then
1114 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1115 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1118 This can mostly be optimized away, so that the usual path is a
1119 load followed by a test and branch. _Jv_ResolvePoolEntry is
1120 only called once for each constant pool entry.
1122 There is an optimization that we don't do: at the start of a
1123 method, create a local copy of CACHE_ENTRY and use that instead.
1127 int cpool_index = alloc_constant_fieldref (output_class, fdecl);
1128 tree cache_entry = build_fieldref_cache_entry (cpool_index, fdecl);
1130 = build3 (CALL_EXPR, boolean_type_node,
1131 build_address_of (built_in_decls[BUILT_IN_EXPECT]),
1132 tree_cons (NULL_TREE, build2 (EQ_EXPR, boolean_type_node,
1133 cache_entry, null_pointer_node),
1134 build_tree_list (NULL_TREE, boolean_false_node)),
1136 tree cpool_index_cst = build_int_cst (NULL_TREE, cpool_index);
1138 = build3 (CALL_EXPR, ptr_type_node,
1139 build_address_of (soft_resolvepoolentry_node),
1140 tree_cons (NULL_TREE, build_class_ref (output_class),
1141 build_tree_list (NULL_TREE, cpool_index_cst)),
1143 init = build2 (MODIFY_EXPR, ptr_type_node, cache_entry, init);
1144 init = build3 (COND_EXPR, ptr_type_node, test, init, cache_entry);
1145 init = fold_convert (build_pointer_type (TREE_TYPE (fdecl)), init);
1146 fdecl = build1 (INDIRECT_REF, TREE_TYPE (fdecl), init);
1152 get_access_flags_from_decl (tree decl)
1154 int access_flags = 0;
1155 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
1157 if (FIELD_STATIC (decl))
1158 access_flags |= ACC_STATIC;
1159 if (FIELD_PUBLIC (decl))
1160 access_flags |= ACC_PUBLIC;
1161 if (FIELD_PROTECTED (decl))
1162 access_flags |= ACC_PROTECTED;
1163 if (FIELD_PRIVATE (decl))
1164 access_flags |= ACC_PRIVATE;
1165 if (FIELD_FINAL (decl))
1166 access_flags |= ACC_FINAL;
1167 if (FIELD_VOLATILE (decl))
1168 access_flags |= ACC_VOLATILE;
1169 if (FIELD_TRANSIENT (decl))
1170 access_flags |= ACC_TRANSIENT;
1171 return access_flags;
1173 if (TREE_CODE (decl) == TYPE_DECL)
1175 if (CLASS_PUBLIC (decl))
1176 access_flags |= ACC_PUBLIC;
1177 if (CLASS_FINAL (decl))
1178 access_flags |= ACC_FINAL;
1179 if (CLASS_SUPER (decl))
1180 access_flags |= ACC_SUPER;
1181 if (CLASS_INTERFACE (decl))
1182 access_flags |= ACC_INTERFACE;
1183 if (CLASS_ABSTRACT (decl))
1184 access_flags |= ACC_ABSTRACT;
1185 if (CLASS_STATIC (decl))
1186 access_flags |= ACC_STATIC;
1187 if (CLASS_PRIVATE (decl))
1188 access_flags |= ACC_PRIVATE;
1189 if (CLASS_PROTECTED (decl))
1190 access_flags |= ACC_PROTECTED;
1191 if (CLASS_STRICTFP (decl))
1192 access_flags |= ACC_STRICT;
1193 return access_flags;
1195 if (TREE_CODE (decl) == FUNCTION_DECL)
1197 if (METHOD_PUBLIC (decl))
1198 access_flags |= ACC_PUBLIC;
1199 if (METHOD_PRIVATE (decl))
1200 access_flags |= ACC_PRIVATE;
1201 if (METHOD_PROTECTED (decl))
1202 access_flags |= ACC_PROTECTED;
1203 if (METHOD_STATIC (decl))
1204 access_flags |= ACC_STATIC;
1205 if (METHOD_FINAL (decl))
1206 access_flags |= ACC_FINAL;
1207 if (METHOD_SYNCHRONIZED (decl))
1208 access_flags |= ACC_SYNCHRONIZED;
1209 if (METHOD_NATIVE (decl))
1210 access_flags |= ACC_NATIVE;
1211 if (METHOD_ABSTRACT (decl))
1212 access_flags |= ACC_ABSTRACT;
1213 if (METHOD_STRICTFP (decl))
1214 access_flags |= ACC_STRICT;
1215 if (METHOD_INVISIBLE (decl))
1216 access_flags |= ACC_INVISIBLE;
1217 return access_flags;
1222 static GTY (()) int alias_labelno = 0;
1224 /* Create a private alias for METHOD. Using this alias instead of the method
1225 decl ensures that ncode entries in the method table point to the real function
1226 at runtime, not a PLT entry. */
1229 make_local_function_alias (tree method)
1231 #ifdef ASM_OUTPUT_DEF
1234 const char *method_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method));
1235 char *name = alloca (strlen (method_name) + 2);
1236 char *buf = alloca (strlen (method_name) + 128);
1238 /* Only create aliases for local functions. */
1239 if (DECL_EXTERNAL (method))
1242 /* Prefix method_name with 'L' for the alias label. */
1244 strcpy (name + 1, method_name);
1246 ASM_GENERATE_INTERNAL_LABEL (buf, name, alias_labelno++);
1247 alias = build_decl (FUNCTION_DECL, get_identifier (buf),
1248 TREE_TYPE (method));
1249 DECL_CONTEXT (alias) = NULL;
1250 TREE_READONLY (alias) = TREE_READONLY (method);
1251 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (method);
1252 TREE_PUBLIC (alias) = 0;
1253 DECL_EXTERNAL (alias) = 0;
1254 DECL_ARTIFICIAL (alias) = 1;
1255 DECL_INLINE (alias) = 0;
1256 DECL_INITIAL (alias) = error_mark_node;
1257 TREE_ADDRESSABLE (alias) = 1;
1258 TREE_USED (alias) = 1;
1259 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
1260 if (!flag_syntax_only)
1261 assemble_alias (alias, DECL_ASSEMBLER_NAME (method));
1268 /** Make reflection data (_Jv_Field) for field FDECL. */
1271 make_field_value (tree fdecl)
1275 tree type = TREE_TYPE (fdecl);
1276 int resolved = is_compiled_class (type) && ! flag_indirect_dispatch;
1278 START_RECORD_CONSTRUCTOR (finit, field_type_node);
1279 PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl)));
1281 type = build_class_ref (type);
1284 tree signature = build_java_signature (type);
1286 type = build_utf8_ref (unmangle_classname
1287 (IDENTIFIER_POINTER (signature),
1288 IDENTIFIER_LENGTH (signature)));
1290 PUSH_FIELD_VALUE (finit, "type", type);
1292 flags = get_access_flags_from_decl (fdecl);
1294 flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1296 PUSH_FIELD_VALUE (finit, "accflags", build_int_cst (NULL_TREE, flags));
1297 PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
1301 build_constructor_from_list (field_info_union_node,
1303 ((FIELD_STATIC (fdecl)
1304 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
1305 : TYPE_FIELDS (field_info_union_node)),
1306 (FIELD_STATIC (fdecl)
1307 ? build_address_of (fdecl)
1308 : byte_position (fdecl)))));
1310 FINISH_RECORD_CONSTRUCTOR (finit);
1314 /** Make reflection data (_Jv_Method) for method MDECL. */
1317 make_method_value (tree mdecl)
1319 static int method_name_count = 0;
1324 #define ACC_TRANSLATED 0x4000
1325 int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
1327 class_decl = DECL_CONTEXT (mdecl);
1328 /* For interfaces, the index field contains the dispatch index. */
1329 if (CLASS_INTERFACE (TYPE_NAME (class_decl)))
1330 index = build_int_cst (NULL_TREE,
1331 get_interface_method_index (mdecl, class_decl));
1332 else if (!flag_indirect_dispatch && get_method_index (mdecl) != NULL_TREE)
1333 index = get_method_index (mdecl);
1335 index = integer_minus_one_node;
1337 code = null_pointer_node;
1338 if (METHOD_ABSTRACT (mdecl))
1339 code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1340 soft_abstractmethod_node);
1342 code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1343 make_local_function_alias (mdecl));
1344 START_RECORD_CONSTRUCTOR (minit, method_type_node);
1345 PUSH_FIELD_VALUE (minit, "name",
1346 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
1347 init_identifier_node
1348 : DECL_NAME (mdecl)));
1350 tree signature = build_java_signature (TREE_TYPE (mdecl));
1351 PUSH_FIELD_VALUE (minit, "signature",
1354 (IDENTIFIER_POINTER(signature),
1355 IDENTIFIER_LENGTH(signature)))));
1357 PUSH_FIELD_VALUE (minit, "accflags", build_int_cst (NULL_TREE, accflags));
1358 PUSH_FIELD_VALUE (minit, "index", index);
1359 PUSH_FIELD_VALUE (minit, "ncode", code);
1362 /* Compute the `throws' information for the method. */
1363 tree table = null_pointer_node;
1364 if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE)
1366 int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl));
1367 tree iter, type, array;
1370 table = tree_cons (NULL_TREE, table, NULL_TREE);
1371 for (iter = DECL_FUNCTION_THROWS (mdecl);
1373 iter = TREE_CHAIN (iter))
1375 tree sig = DECL_NAME (TYPE_NAME (TREE_VALUE (iter)));
1377 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
1378 IDENTIFIER_LENGTH (sig)));
1379 table = tree_cons (NULL_TREE, utf8, table);
1381 type = build_prim_array_type (ptr_type_node, length);
1382 table = build_constructor_from_list (type, table);
1383 /* Compute something unique enough. */
1384 sprintf (buf, "_methods%d", method_name_count++);
1385 array = build_decl (VAR_DECL, get_identifier (buf), type);
1386 DECL_INITIAL (array) = table;
1387 TREE_STATIC (array) = 1;
1388 DECL_ARTIFICIAL (array) = 1;
1389 DECL_IGNORED_P (array) = 1;
1390 rest_of_decl_compilation (array, 1, 0);
1392 table = build1 (ADDR_EXPR, ptr_type_node, array);
1395 PUSH_FIELD_VALUE (minit, "throws", table);
1398 FINISH_RECORD_CONSTRUCTOR (minit);
1403 get_dispatch_vector (tree type)
1405 tree vtable = TYPE_VTABLE (type);
1407 if (vtable == NULL_TREE)
1411 tree super = CLASSTYPE_SUPER (type);
1412 HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1413 vtable = make_tree_vec (nvirtuals);
1414 TYPE_VTABLE (type) = vtable;
1415 if (super != NULL_TREE)
1417 tree super_vtable = get_dispatch_vector (super);
1419 for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1420 TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1423 for (method = TYPE_METHODS (type); method != NULL_TREE;
1424 method = TREE_CHAIN (method))
1426 tree method_index = get_method_index (method);
1427 if (method_index != NULL_TREE
1428 && host_integerp (method_index, 0))
1429 TREE_VEC_ELT (vtable, tree_low_cst (method_index, 0)) = method;
1437 get_dispatch_table (tree type, tree this_class_addr)
1439 int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1440 tree vtable = get_dispatch_vector (type);
1442 tree list = NULL_TREE;
1443 int nvirtuals = TREE_VEC_LENGTH (vtable);
1447 for (i = nvirtuals; --i >= 0; )
1449 tree method = TREE_VEC_ELT (vtable, i);
1450 if (METHOD_ABSTRACT (method))
1453 warning (0, "%Jabstract method in non-abstract class", method);
1455 if (TARGET_VTABLE_USES_DESCRIPTORS)
1456 for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1457 list = tree_cons (NULL_TREE, null_pointer_node, list);
1459 list = tree_cons (NULL_TREE, null_pointer_node, list);
1463 if (TARGET_VTABLE_USES_DESCRIPTORS)
1464 for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1466 tree fdesc = build2 (FDESC_EXPR, nativecode_ptr_type_node,
1467 method, build_int_cst (NULL_TREE, j));
1468 TREE_CONSTANT (fdesc) = 1;
1469 TREE_INVARIANT (fdesc) = 1;
1470 list = tree_cons (NULL_TREE, fdesc, list);
1473 list = tree_cons (NULL_TREE,
1474 build1 (ADDR_EXPR, nativecode_ptr_type_node,
1480 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1481 using the Boehm GC we sometimes stash a GC type descriptor
1482 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1483 the emitted byte count during the output to the assembly file. */
1484 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1485 fake "function descriptor". It's first word is the is the class
1486 pointer, and subsequent words (usually one) contain the GC descriptor.
1487 In all other cases, we reserve two extra vtable slots. */
1488 gc_descr = get_boehm_type_descriptor (type);
1489 list = tree_cons (NULL_TREE, gc_descr, list);
1490 for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
1491 list = tree_cons (NULL_TREE, gc_descr, list);
1492 list = tree_cons (NULL_TREE, this_class_addr, list);
1494 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1495 list = tree_cons (NULL_TREE, null_pointer_node, list);
1496 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1497 list = tree_cons (integer_zero_node, null_pointer_node, list);
1499 arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
1500 if (TARGET_VTABLE_USES_DESCRIPTORS)
1501 arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
1503 return build_constructor_from_list
1504 (build_prim_array_type (nativecode_ptr_type_node,
1509 /* Set the method_index for a method decl. */
1511 set_method_index (tree decl, tree method_index)
1513 if (method_index != NULL_TREE)
1515 /* method_index is null if we're using indirect dispatch. */
1516 method_index = fold (convert (sizetype, method_index));
1518 if (TARGET_VTABLE_USES_DESCRIPTORS)
1519 /* Add one to skip bogus descriptor for class and GC descriptor. */
1520 method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
1522 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1524 method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1527 DECL_VINDEX (decl) = method_index;
1530 /* Get the method_index for a method decl. */
1532 get_method_index (tree decl)
1534 tree method_index = DECL_VINDEX (decl);
1539 if (TARGET_VTABLE_USES_DESCRIPTORS)
1540 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1541 method_index = size_binop (MINUS_EXPR, method_index, size_int (1));
1543 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1544 method_index = size_binop (MINUS_EXPR, method_index, size_int (2));
1546 return method_index;
1550 supers_all_compiled (tree type)
1552 while (type != NULL_TREE)
1554 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
1556 type = CLASSTYPE_SUPER (type);
1561 /* The forth (index of 3) element in the vtable is the GC descriptor.
1562 A value of 2 indicates that the class uses _Jv_MarkObj. */
1564 uses_jv_markobj_p(tree dtable)
1567 v = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (dtable), 3)->value;
1568 return (2 == TREE_INT_CST_LOW (v));
1572 make_class_data (tree type)
1574 tree decl, cons, temp;
1575 tree field, fields_decl;
1576 tree static_fields = NULL_TREE;
1577 tree instance_fields = NULL_TREE;
1578 HOST_WIDE_INT static_field_count = 0;
1579 HOST_WIDE_INT instance_field_count = 0;
1580 HOST_WIDE_INT field_count;
1581 tree field_array_type;
1583 tree methods = NULL_TREE;
1584 tree dtable_decl = NULL_TREE;
1585 HOST_WIDE_INT method_count = 0;
1586 tree method_array_type;
1589 tree this_class_addr;
1590 tree constant_pool_constructor;
1591 tree interfaces = null_pointer_node;
1592 int interface_len = 0;
1593 int uses_jv_markobj = 0;
1594 tree type_decl = TYPE_NAME (type);
1595 tree id_main = get_identifier("main");
1596 tree id_class = get_identifier("java.lang.Class");
1597 /** Offset from start of virtual function table declaration
1598 to where objects actually point at, following new g++ ABI. */
1599 tree dtable_start_offset = build_int_cst (NULL_TREE,
1600 2 * POINTER_SIZE / BITS_PER_UNIT);
1602 this_class_addr = build_class_ref (type);
1603 decl = TREE_OPERAND (this_class_addr, 0);
1605 if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
1606 && !flag_indirect_dispatch)
1608 tree dtable = get_dispatch_table (type, this_class_addr);
1609 uses_jv_markobj = uses_jv_markobj_p(dtable);
1610 dtable_decl = build_dtable_decl (type);
1611 DECL_INITIAL (dtable_decl) = dtable;
1612 TREE_STATIC (dtable_decl) = 1;
1613 DECL_ARTIFICIAL (dtable_decl) = 1;
1614 DECL_IGNORED_P (dtable_decl) = 1;
1615 TREE_PUBLIC (dtable_decl) = 1;
1616 rest_of_decl_compilation (dtable_decl, 1, 0);
1617 if (type == class_type_node)
1618 class_dtable_decl = dtable_decl;
1621 /* Build Field array. */
1622 field = TYPE_FIELDS (type);
1623 while (field && DECL_ARTIFICIAL (field))
1624 field = TREE_CHAIN (field); /* Skip dummy fields. */
1625 if (field && DECL_NAME (field) == NULL_TREE)
1626 field = TREE_CHAIN (field); /* Skip dummy field for inherited data. */
1627 for ( ; field != NULL_TREE; field = TREE_CHAIN (field))
1629 if (! DECL_ARTIFICIAL (field))
1631 if (FIELD_STATIC (field))
1633 /* We must always create reflection data for static fields
1634 as it is used in the creation of the field itself. */
1635 tree init = make_field_value (field);
1636 tree initial = DECL_INITIAL (field);
1637 static_field_count++;
1638 static_fields = tree_cons (NULL_TREE, init, static_fields);
1639 /* If the initial value is a string constant,
1640 prevent output_constant from trying to assemble the value. */
1641 if (initial != NULL_TREE
1642 && TREE_TYPE (initial) == string_ptr_type_node)
1643 DECL_INITIAL (field) = NULL_TREE;
1644 rest_of_decl_compilation (field, 1, 1);
1645 DECL_INITIAL (field) = initial;
1647 else if (uses_jv_markobj || !flag_reduced_reflection)
1649 tree init = make_field_value (field);
1650 instance_field_count++;
1651 instance_fields = tree_cons (NULL_TREE, init, instance_fields);
1655 field_count = static_field_count + instance_field_count;
1656 if (field_count > 0)
1658 static_fields = nreverse (static_fields);
1659 instance_fields = nreverse (instance_fields);
1660 static_fields = chainon (static_fields, instance_fields);
1661 field_array_type = build_prim_array_type (field_type_node, field_count);
1662 fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
1664 DECL_INITIAL (fields_decl) = build_constructor_from_list
1665 (field_array_type, static_fields);
1666 TREE_STATIC (fields_decl) = 1;
1667 DECL_ARTIFICIAL (fields_decl) = 1;
1668 DECL_IGNORED_P (fields_decl) = 1;
1669 rest_of_decl_compilation (fields_decl, 1, 0);
1672 fields_decl = NULL_TREE;
1674 /* Build Method array. */
1675 for (method = TYPE_METHODS (type);
1676 method != NULL_TREE; method = TREE_CHAIN (method))
1679 if (METHOD_PRIVATE (method)
1680 && ! flag_keep_inline_functions
1683 /* Even if we have a decl, we don't necessarily have the code.
1684 This can happen if we inherit a method from a superclass for
1685 which we don't have a .class file. */
1686 if (METHOD_DUMMY (method))
1689 /* Generate method reflection data if:
1691 - !flag_reduced_reflection.
1693 - <clinit> -- The runtime uses reflection to initialize the
1696 - Any method in class java.lang.Class -- Class.forName() and
1697 perhaps other things require it.
1699 - class$ -- It does not work if reflection data missing.
1701 - main -- Reflection is used to find main(String[]) methods.
1703 - public not static -- It is potentially part of an
1704 interface. The runtime uses reflection data to build
1705 interface dispatch tables. */
1706 if (!flag_reduced_reflection
1707 || DECL_CLINIT_P (method)
1708 || DECL_NAME (type_decl) == id_class
1709 || DECL_NAME (method) == id_main
1710 || (METHOD_PUBLIC (method) && !METHOD_STATIC (method))
1711 || TYPE_DOT_CLASS (type) == method)
1713 init = make_method_value (method);
1715 methods = tree_cons (NULL_TREE, init, methods);
1718 method_array_type = build_prim_array_type (method_type_node, method_count);
1719 methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
1721 DECL_INITIAL (methods_decl) = build_constructor_from_list
1722 (method_array_type, nreverse (methods));
1723 TREE_STATIC (methods_decl) = 1;
1724 DECL_ARTIFICIAL (methods_decl) = 1;
1725 DECL_IGNORED_P (methods_decl) = 1;
1726 rest_of_decl_compilation (methods_decl, 1, 0);
1728 if (class_dtable_decl == NULL_TREE)
1730 class_dtable_decl = build_dtable_decl (class_type_node);
1731 TREE_STATIC (class_dtable_decl) = 1;
1732 DECL_ARTIFICIAL (class_dtable_decl) = 1;
1733 DECL_IGNORED_P (class_dtable_decl) = 1;
1734 if (is_compiled_class (class_type_node) != 2)
1735 DECL_EXTERNAL (class_dtable_decl) = 1;
1736 rest_of_decl_compilation (class_dtable_decl, 1, 0);
1739 super = CLASSTYPE_SUPER (type);
1740 if (super == NULL_TREE)
1741 super = null_pointer_node;
1742 else if (! flag_indirect_dispatch
1743 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
1744 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
1745 super = build_class_ref (super);
1748 int super_index = alloc_class_constant (super);
1749 super = build_int_cst (ptr_type_node, super_index);
1752 /* Build and emit the array of implemented interfaces. */
1753 if (type != object_type_node)
1754 interface_len = BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) - 1;
1756 if (interface_len > 0)
1758 tree init = NULL_TREE;
1760 tree interface_array_type, idecl;
1761 interface_array_type
1762 = build_prim_array_type (class_ptr_type, interface_len);
1763 idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type),
1764 interface_array_type);
1766 for (i = interface_len; i > 0; i--)
1768 tree child = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
1769 tree iclass = BINFO_TYPE (child);
1771 if (! flag_indirect_dispatch
1773 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))))
1774 index = build_class_ref (iclass);
1777 int int_index = alloc_class_constant (iclass);
1778 index = build_int_cst (ptr_type_node, int_index);
1780 init = tree_cons (NULL_TREE, index, init);
1782 DECL_INITIAL (idecl) = build_constructor_from_list (interface_array_type,
1784 TREE_STATIC (idecl) = 1;
1785 DECL_ARTIFICIAL (idecl) = 1;
1786 DECL_IGNORED_P (idecl) = 1;
1787 interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
1788 rest_of_decl_compilation (idecl, 1, 0);
1791 constant_pool_constructor = build_constants_constructor ();
1793 if (flag_indirect_dispatch)
1795 TYPE_OTABLE_DECL (type)
1797 (DECL_NAME (TYPE_OTABLE_DECL (type)),
1798 TYPE_OTABLE_DECL (type), TYPE_OTABLE_METHODS (type),
1799 TYPE_OTABLE_SYMS_DECL (type), integer_type_node, 1);
1801 TYPE_ATABLE_DECL (type)
1803 (DECL_NAME (TYPE_ATABLE_DECL (type)),
1804 TYPE_ATABLE_DECL (type), TYPE_ATABLE_METHODS (type),
1805 TYPE_ATABLE_SYMS_DECL (type), ptr_type_node, 1);
1807 TYPE_ITABLE_DECL (type)
1809 (DECL_NAME (TYPE_ITABLE_DECL (type)),
1810 TYPE_ITABLE_DECL (type), TYPE_ITABLE_METHODS (type),
1811 TYPE_ITABLE_SYMS_DECL (type), ptr_type_node, 2);
1814 TYPE_CTABLE_DECL (type) = emit_catch_table (type);
1816 START_RECORD_CONSTRUCTOR (temp, object_type_node);
1817 PUSH_FIELD_VALUE (temp, "vtable",
1818 build2 (PLUS_EXPR, dtable_ptr_type,
1819 build1 (ADDR_EXPR, dtable_ptr_type,
1821 dtable_start_offset));
1822 if (! flag_hash_synchronization)
1823 PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
1824 FINISH_RECORD_CONSTRUCTOR (temp);
1825 START_RECORD_CONSTRUCTOR (cons, class_type_node);
1826 PUSH_SUPER_VALUE (cons, temp);
1827 PUSH_FIELD_VALUE (cons, "next_or_version", gcj_abi_version);
1828 PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
1829 PUSH_FIELD_VALUE (cons, "accflags",
1830 build_int_cst (NULL_TREE,
1831 get_access_flags_from_decl (type_decl)));
1833 PUSH_FIELD_VALUE (cons, "superclass",
1834 CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
1835 PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
1836 PUSH_FIELD_VALUE (cons, "methods",
1837 methods_decl == NULL_TREE ? null_pointer_node
1838 : build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
1839 PUSH_FIELD_VALUE (cons, "method_count",
1840 build_int_cst (NULL_TREE, method_count));
1842 if (flag_indirect_dispatch)
1843 PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node);
1845 PUSH_FIELD_VALUE (cons, "vtable_method_count", TYPE_NVIRTUALS (type));
1847 PUSH_FIELD_VALUE (cons, "fields",
1848 fields_decl == NULL_TREE ? null_pointer_node
1849 : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
1850 /* If we're using the binary compatibility ABI we don't know the
1851 size until load time. */
1852 PUSH_FIELD_VALUE (cons, "size_in_bytes",
1853 (flag_indirect_dispatch
1854 ? integer_minus_one_node
1855 : size_in_bytes (type)));
1856 PUSH_FIELD_VALUE (cons, "field_count",
1857 build_int_cst (NULL_TREE, field_count));
1858 PUSH_FIELD_VALUE (cons, "static_field_count",
1859 build_int_cst (NULL_TREE, static_field_count));
1861 if (flag_indirect_dispatch)
1862 PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node);
1864 PUSH_FIELD_VALUE (cons, "vtable",
1865 dtable_decl == NULL_TREE ? null_pointer_node
1866 : build2 (PLUS_EXPR, dtable_ptr_type,
1867 build1 (ADDR_EXPR, dtable_ptr_type,
1869 dtable_start_offset));
1870 if (TYPE_OTABLE_METHODS (type) == NULL_TREE)
1872 PUSH_FIELD_VALUE (cons, "otable", null_pointer_node);
1873 PUSH_FIELD_VALUE (cons, "otable_syms", null_pointer_node);
1877 pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type));
1878 PUSH_FIELD_VALUE (cons, "otable",
1879 build1 (ADDR_EXPR, otable_ptr_type, TYPE_OTABLE_DECL (type)));
1880 PUSH_FIELD_VALUE (cons, "otable_syms",
1881 build1 (ADDR_EXPR, symbols_array_ptr_type,
1882 TYPE_OTABLE_SYMS_DECL (type)));
1883 TREE_CONSTANT (TYPE_OTABLE_DECL (type)) = 1;
1884 TREE_INVARIANT (TYPE_OTABLE_DECL (type)) = 1;
1886 if (TYPE_ATABLE_METHODS(type) == NULL_TREE)
1888 PUSH_FIELD_VALUE (cons, "atable", null_pointer_node);
1889 PUSH_FIELD_VALUE (cons, "atable_syms", null_pointer_node);
1893 pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type));
1894 PUSH_FIELD_VALUE (cons, "atable",
1895 build1 (ADDR_EXPR, atable_ptr_type, TYPE_ATABLE_DECL (type)));
1896 PUSH_FIELD_VALUE (cons, "atable_syms",
1897 build1 (ADDR_EXPR, symbols_array_ptr_type,
1898 TYPE_ATABLE_SYMS_DECL (type)));
1899 TREE_CONSTANT (TYPE_ATABLE_DECL (type)) = 1;
1900 TREE_INVARIANT (TYPE_ATABLE_DECL (type)) = 1;
1902 if (TYPE_ITABLE_METHODS(type) == NULL_TREE)
1904 PUSH_FIELD_VALUE (cons, "itable", null_pointer_node);
1905 PUSH_FIELD_VALUE (cons, "itable_syms", null_pointer_node);
1909 pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type));
1910 PUSH_FIELD_VALUE (cons, "itable",
1911 build1 (ADDR_EXPR, itable_ptr_type, TYPE_ITABLE_DECL (type)));
1912 PUSH_FIELD_VALUE (cons, "itable_syms",
1913 build1 (ADDR_EXPR, symbols_array_ptr_type,
1914 TYPE_ITABLE_SYMS_DECL (type)));
1915 TREE_CONSTANT (TYPE_ITABLE_DECL (type)) = 1;
1916 TREE_INVARIANT (TYPE_ITABLE_DECL (type)) = 1;
1919 PUSH_FIELD_VALUE (cons, "catch_classes",
1920 build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
1921 PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
1922 PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
1923 PUSH_FIELD_VALUE (cons, "interface_count",
1924 build_int_cst (NULL_TREE, interface_len));
1925 PUSH_FIELD_VALUE (cons, "state",
1926 convert (byte_type_node,
1927 build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
1929 PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
1930 PUSH_FIELD_VALUE (cons, "depth", integer_zero_node);
1931 PUSH_FIELD_VALUE (cons, "ancestors", null_pointer_node);
1932 PUSH_FIELD_VALUE (cons, "idt", null_pointer_node);
1933 PUSH_FIELD_VALUE (cons, "arrayclass", null_pointer_node);
1934 PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
1937 tree assertion_table_ref;
1938 if (TYPE_ASSERTIONS (type) == NULL)
1939 assertion_table_ref = null_pointer_node;
1941 assertion_table_ref = build1 (ADDR_EXPR,
1942 build_pointer_type (assertion_table_type),
1943 emit_assertion_table (type));
1945 PUSH_FIELD_VALUE (cons, "assertion_table", assertion_table_ref);
1948 PUSH_FIELD_VALUE (cons, "hack_signers", null_pointer_node);
1949 PUSH_FIELD_VALUE (cons, "chain", null_pointer_node);
1950 PUSH_FIELD_VALUE (cons, "aux_info", null_pointer_node);
1951 PUSH_FIELD_VALUE (cons, "engine", null_pointer_node);
1953 FINISH_RECORD_CONSTRUCTOR (cons);
1955 DECL_INITIAL (decl) = cons;
1957 /* Hash synchronization requires at least 64-bit alignment. */
1958 if (flag_hash_synchronization && POINTER_SIZE < 64)
1959 DECL_ALIGN (decl) = 64;
1961 rest_of_decl_compilation (decl, 1, 0);
1963 TYPE_OTABLE_DECL (type) = NULL_TREE;
1964 TYPE_ATABLE_DECL (type) = NULL_TREE;
1965 TYPE_CTABLE_DECL (type) = NULL_TREE;
1971 if (TYPE_VERIFY_METHOD (output_class))
1973 tree verify_method = TYPE_VERIFY_METHOD (output_class);
1974 DECL_SAVED_TREE (verify_method)
1975 = add_stmt_to_compound (DECL_SAVED_TREE (verify_method), void_type_node,
1976 build1 (RETURN_EXPR, void_type_node, NULL));
1977 java_genericize (verify_method);
1978 cgraph_finalize_function (verify_method, false);
1979 TYPE_ASSERTIONS (current_class) = NULL;
1982 java_expand_catch_classes (current_class);
1984 current_function_decl = NULL_TREE;
1985 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class)) = 0;
1986 make_class_data (current_class);
1988 rest_of_decl_compilation (TYPE_NAME (current_class), 1, 0);
1991 /* Return 2 if CLASS is compiled by this compilation job;
1992 return 1 if CLASS can otherwise be assumed to be compiled;
1993 return 0 if we cannot assume that CLASS is compiled.
1994 Returns 1 for primitive and 0 for array types. */
1996 is_compiled_class (tree class)
1999 if (TREE_CODE (class) == POINTER_TYPE)
2000 class = TREE_TYPE (class);
2001 if (TREE_CODE (class) != RECORD_TYPE) /* Primitive types are static. */
2003 if (TYPE_ARRAY_P (class))
2005 if (class == current_class)
2008 seen_in_zip = (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
2009 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip)
2011 /* The class was seen in the current ZIP file and will be
2012 available as a compiled class in the future but may not have
2013 been loaded already. Load it if necessary. This prevent
2014 build_class_ref () from crashing. */
2016 if (seen_in_zip && !CLASS_LOADED_P (class))
2017 load_class (class, 1);
2019 /* We return 2 for class seen in ZIP and class from files
2020 belonging to the same compilation unit */
2024 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
2026 if (!CLASS_LOADED_P (class))
2028 if (CLASS_FROM_SOURCE_P (class))
2029 safe_layout_class (class);
2031 load_class (class, 1);
2039 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2042 build_dtable_decl (tree type)
2046 /* We need to build a new dtable type so that its size is uniquely
2047 computed when we're dealing with the class for real and not just
2048 faking it (like java.lang.Class during the initialization of the
2049 compiler.) We know we're not faking a class when CURRENT_CLASS is
2051 if (current_class == type)
2053 tree dummy = NULL_TREE;
2056 dtype = make_node (RECORD_TYPE);
2058 PUSH_FIELD (dtype, dummy, "top_offset", ptr_type_node);
2059 PUSH_FIELD (dtype, dummy, "type_info", ptr_type_node);
2061 PUSH_FIELD (dtype, dummy, "class", class_ptr_type);
2062 for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2064 tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2065 TREE_CHAIN (dummy) = tmp_field;
2066 DECL_CONTEXT (tmp_field) = dtype;
2067 DECL_ARTIFICIAL (tmp_field) = 1;
2071 PUSH_FIELD (dtype, dummy, "gc_descr", ptr_type_node);
2072 for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2074 tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2075 TREE_CHAIN (dummy) = tmp_field;
2076 DECL_CONTEXT (tmp_field) = dtype;
2077 DECL_ARTIFICIAL (tmp_field) = 1;
2081 n = TREE_VEC_LENGTH (get_dispatch_vector (type));
2082 if (TARGET_VTABLE_USES_DESCRIPTORS)
2083 n *= TARGET_VTABLE_USES_DESCRIPTORS;
2085 PUSH_FIELD (dtype, dummy, "methods",
2086 build_prim_array_type (nativecode_ptr_type_node, n));
2087 layout_type (dtype);
2090 dtype = dtable_type;
2092 decl = build_decl (VAR_DECL, get_identifier ("vt$"), dtype);
2093 DECL_CONTEXT (decl) = type;
2094 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2095 DECL_VTABLE_P (decl) = 1;
2100 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2101 fields inherited from SUPER_CLASS. */
2104 push_super_field (tree this_class, tree super_class)
2107 /* Don't insert the field if we're just re-laying the class out. */
2108 if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
2110 base_decl = build_decl (FIELD_DECL, NULL_TREE, super_class);
2111 DECL_IGNORED_P (base_decl) = 1;
2112 TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
2113 TYPE_FIELDS (this_class) = base_decl;
2114 DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
2115 DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
2118 /* Handle the different manners we may have to lay out a super class. */
2121 maybe_layout_super_class (tree super_class, tree this_class)
2125 else if (TREE_CODE (super_class) == RECORD_TYPE)
2127 if (!CLASS_LOADED_P (super_class) && CLASS_FROM_SOURCE_P (super_class))
2128 safe_layout_class (super_class);
2129 if (!CLASS_LOADED_P (super_class))
2130 load_class (super_class, 1);
2132 /* We might have to layout the class before its dependency on
2133 the super class gets resolved by java_complete_class */
2134 else if (TREE_CODE (super_class) == POINTER_TYPE)
2136 if (TREE_TYPE (super_class) != NULL_TREE)
2137 super_class = TREE_TYPE (super_class);
2140 /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
2142 tree this_wrap = NULL_TREE;
2144 /* Set the correct context for class resolution. */
2145 current_class = this_class;
2149 tree this_decl = TYPE_NAME (this_class);
2150 #ifdef USE_MAPPED_LOCATION
2151 this_wrap = build_expr_wfl (this_class,
2152 DECL_SOURCE_LOCATION (this_decl));
2154 this_wrap = build_expr_wfl (this_class,
2155 DECL_SOURCE_FILE (this_decl),
2156 DECL_SOURCE_LINE (this_decl), 0);
2160 = do_resolve_class (DECL_CONTEXT (TYPE_NAME (this_class)),
2161 this_class, super_class, NULL_TREE, this_wrap);
2163 return NULL_TREE; /* FIXME, NULL_TREE not checked by caller. */
2164 super_class = TREE_TYPE (super_class);
2167 if (!TYPE_SIZE (super_class))
2168 safe_layout_class (super_class);
2174 layout_class (tree this_class)
2176 tree super_class = CLASSTYPE_SUPER (this_class);
2178 class_list = tree_cons (this_class, NULL_TREE, class_list);
2179 if (CLASS_BEING_LAIDOUT (this_class))
2185 sprintf (buffer, " with '%s'",
2186 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
2187 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2189 for (current = TREE_CHAIN (class_list); current;
2190 current = TREE_CHAIN (current))
2192 tree decl = TYPE_NAME (TREE_PURPOSE (current));
2193 sprintf (buffer, "\n which inherits from '%s' (%s:%d)",
2194 IDENTIFIER_POINTER (DECL_NAME (decl)),
2195 DECL_SOURCE_FILE (decl),
2196 DECL_SOURCE_LINE (decl));
2197 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2199 obstack_1grow (&temporary_obstack, '\0');
2200 report = obstack_finish (&temporary_obstack);
2201 cyclic_inheritance_report = ggc_strdup (report);
2202 obstack_free (&temporary_obstack, report);
2203 TYPE_SIZE (this_class) = error_mark_node;
2206 CLASS_BEING_LAIDOUT (this_class) = 1;
2208 if (super_class && !CLASS_BEING_LAIDOUT (super_class))
2210 tree maybe_super_class
2211 = maybe_layout_super_class (super_class, this_class);
2212 if (maybe_super_class == NULL
2213 || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
2215 TYPE_SIZE (this_class) = error_mark_node;
2216 CLASS_BEING_LAIDOUT (this_class) = 0;
2217 class_list = TREE_CHAIN (class_list);
2220 if (TYPE_SIZE (this_class) == NULL_TREE)
2221 push_super_field (this_class, maybe_super_class);
2224 layout_type (this_class);
2226 /* Also recursively load/layout any superinterfaces, but only if
2227 class was loaded from bytecode. The source parser will take care
2229 if (!CLASS_FROM_SOURCE_P (this_class))
2232 if (TYPE_BINFO (this_class))
2234 for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class)) - 1; i > 0; i--)
2236 tree binfo = BINFO_BASE_BINFO (TYPE_BINFO (this_class), i);
2237 tree super_interface = BINFO_TYPE (binfo);
2238 tree maybe_super_interface
2239 = maybe_layout_super_class (super_interface, NULL_TREE);
2240 if (maybe_super_interface == NULL
2241 || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
2243 TYPE_SIZE (this_class) = error_mark_node;
2244 CLASS_BEING_LAIDOUT (this_class) = 0;
2245 class_list = TREE_CHAIN (class_list);
2252 /* Convert the size back to an SI integer value. */
2253 TYPE_SIZE_UNIT (this_class) =
2254 fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
2256 CLASS_BEING_LAIDOUT (this_class) = 0;
2257 class_list = TREE_CHAIN (class_list);
2261 add_miranda_methods (tree base_class, tree search_class)
2264 tree binfo, base_binfo;
2266 if (!CLASS_PARSED_P (search_class))
2267 load_class (search_class, 1);
2269 for (binfo = TYPE_BINFO (search_class), i = 1;
2270 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2273 tree elt = BINFO_TYPE (base_binfo);
2275 /* FIXME: This is totally bogus. We should not be handling
2276 Miranda methods at all if we're using the BC ABI. */
2277 if (TYPE_DUMMY (elt))
2280 /* Ensure that interface methods are seen in declared order. */
2281 if (!CLASS_LOADED_P (elt))
2282 load_class (elt, 1);
2283 layout_class_methods (elt);
2285 /* All base classes will have been laid out at this point, so the order
2286 will be correct. This code must match similar layout code in the
2288 for (method_decl = TYPE_METHODS (elt);
2289 method_decl; method_decl = TREE_CHAIN (method_decl))
2293 /* An interface can have <clinit>. */
2294 if (ID_CLINIT_P (DECL_NAME (method_decl)))
2297 sig = build_java_argument_signature (TREE_TYPE (method_decl));
2298 override = lookup_argument_method (base_class,
2299 DECL_NAME (method_decl), sig);
2300 if (override == NULL_TREE)
2302 /* Found a Miranda method. Add it. */
2304 sig = build_java_signature (TREE_TYPE (method_decl));
2306 = add_method (base_class,
2307 get_access_flags_from_decl (method_decl),
2308 DECL_NAME (method_decl), sig);
2309 METHOD_INVISIBLE (new_method) = 1;
2313 /* Try superinterfaces. */
2314 add_miranda_methods (base_class, elt);
2319 layout_class_methods (tree this_class)
2321 tree method_decl, dtable_count;
2322 tree super_class, type_name;
2324 if (TYPE_NVIRTUALS (this_class))
2327 super_class = CLASSTYPE_SUPER (this_class);
2331 super_class = maybe_layout_super_class (super_class, this_class);
2332 if (!TYPE_NVIRTUALS (super_class))
2333 layout_class_methods (super_class);
2334 dtable_count = TYPE_NVIRTUALS (super_class);
2337 dtable_count = integer_zero_node;
2339 type_name = TYPE_NAME (this_class);
2340 if (!flag_indirect_dispatch
2341 && (CLASS_ABSTRACT (type_name) || CLASS_INTERFACE (type_name)))
2343 /* An abstract class can have methods which are declared only in
2344 an implemented interface. These are called "Miranda
2345 methods". We make a dummy method entry for such methods
2347 add_miranda_methods (this_class, this_class);
2350 TYPE_METHODS (this_class) = nreverse (TYPE_METHODS (this_class));
2352 for (method_decl = TYPE_METHODS (this_class);
2353 method_decl; method_decl = TREE_CHAIN (method_decl))
2354 dtable_count = layout_class_method (this_class, super_class,
2355 method_decl, dtable_count);
2357 TYPE_NVIRTUALS (this_class) = dtable_count;
2360 /* Return the index of METHOD in INTERFACE. This index begins at 1
2361 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2363 get_interface_method_index (tree method, tree interface)
2368 for (meth = TYPE_METHODS (interface); ; meth = TREE_CHAIN (meth))
2372 /* We don't want to put <clinit> into the interface table. */
2373 if (! ID_CLINIT_P (DECL_NAME (meth)))
2375 gcc_assert (meth != NULL_TREE);
2379 /* Lay METHOD_DECL out, returning a possibly new value of
2380 DTABLE_COUNT. Also mangle the method's name. */
2383 layout_class_method (tree this_class, tree super_class,
2384 tree method_decl, tree dtable_count)
2386 tree method_name = DECL_NAME (method_decl);
2388 TREE_PUBLIC (method_decl) = 1;
2389 /* Considered external until we know what classes are being
2390 compiled into this object file. */
2391 DECL_EXTERNAL (method_decl) = 1;
2393 if (ID_INIT_P (method_name))
2395 const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
2397 for (ptr = p; *ptr; )
2402 DECL_CONSTRUCTOR_P (method_decl) = 1;
2403 build_java_argument_signature (TREE_TYPE (method_decl));
2405 else if (! METHOD_STATIC (method_decl))
2408 build_java_argument_signature (TREE_TYPE (method_decl));
2409 bool method_override = false;
2410 tree super_method = lookup_argument_method (super_class, method_name,
2412 if (super_method != NULL_TREE
2413 && ! METHOD_DUMMY (super_method))
2415 method_override = true;
2416 if (! METHOD_PUBLIC (super_method) &&
2417 ! METHOD_PROTECTED (super_method))
2419 /* Don't override private method, or default-access method in
2421 if (METHOD_PRIVATE (super_method) ||
2422 ! in_same_package (TYPE_NAME (this_class),
2423 TYPE_NAME (super_class)))
2424 method_override = false;
2427 if (method_override)
2429 tree method_index = get_method_index (super_method);
2430 set_method_index (method_decl, method_index);
2431 if (method_index == NULL_TREE
2432 && ! flag_indirect_dispatch
2433 && !CLASS_FROM_SOURCE_P (this_class)
2434 && ! DECL_ARTIFICIAL (super_method))
2435 error ("non-static method %q+D overrides static method",
2438 else if (this_class == object_type_node
2439 && (METHOD_FINAL (method_decl)
2440 || METHOD_PRIVATE (method_decl)))
2442 /* We don't generate vtable entries for final Object
2443 methods. This is simply to save space, since every
2444 object would otherwise have to define them. */
2446 else if (! METHOD_PRIVATE (method_decl)
2449 /* We generate vtable entries for final methods because they
2450 may one day be changed to non-final. */
2451 set_method_index (method_decl, dtable_count);
2452 dtable_count = fold_build2 (PLUS_EXPR, integer_type_node,
2453 dtable_count, integer_one_node);
2457 return dtable_count;
2461 register_class (void)
2465 if (!registered_class)
2466 registered_class = VEC_alloc (tree, gc, 8);
2468 node = TREE_OPERAND (build_class_ref (current_class), 0);
2469 VEC_safe_push (tree, gc, registered_class, node);
2472 /* Emit something to register classes at start-up time.
2474 The preferred mechanism is through the .jcr section, which contain
2475 a list of pointers to classes which get registered during constructor
2478 The fallback mechanism is to add statements to *LIST_P to call
2479 _Jv_RegisterClass for each class in this file. These statements will
2480 be added to a static constructor function for this translation unit. */
2483 emit_register_classes (tree *list_p)
2485 if (registered_class == NULL)
2488 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2489 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2490 but lack suitable crtbegin/end objects or linker support. These
2491 targets can overide the default in tm.h to use the fallback mechanism. */
2492 if (TARGET_USE_JCR_SECTION)
2497 #ifdef JCR_SECTION_NAME
2498 switch_to_section (get_section (JCR_SECTION_NAME, SECTION_WRITE, NULL));
2500 /* A target has defined TARGET_USE_JCR_SECTION,
2501 but doesn't have a JCR_SECTION_NAME. */
2504 assemble_align (POINTER_SIZE);
2506 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2508 t = build_fold_addr_expr (klass);
2509 output_constant (t, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE);
2514 tree klass, t, register_class_fn;
2517 t = build_function_type_list (void_type_node, class_ptr_type, NULL);
2518 t = build_decl (FUNCTION_DECL, get_identifier ("_Jv_RegisterClass"), t);
2519 TREE_PUBLIC (t) = 1;
2520 DECL_EXTERNAL (t) = 1;
2521 register_class_fn = t;
2523 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2525 t = build_fold_addr_expr (klass);
2526 t = tree_cons (NULL, t, NULL);
2527 t = build_function_call_expr (register_class_fn, t);
2528 append_to_statement_list (t, list_p);
2533 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2536 build_symbol_entry (tree decl)
2538 tree clname, name, signature, sym;
2539 clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
2540 /* ??? Constructors are given the name foo.foo all the way through
2541 the compiler, but in the method table they're all renamed
2542 foo.<init>. So, we have to do the same here unless we want an
2543 unresolved reference at runtime. */
2544 name = build_utf8_ref ((TREE_CODE (decl) == FUNCTION_DECL
2545 && DECL_CONSTRUCTOR_P (decl))
2546 ? init_identifier_node
2547 : DECL_NAME (decl));
2548 signature = build_java_signature (TREE_TYPE (decl));
2549 signature = build_utf8_ref (unmangle_classname
2550 (IDENTIFIER_POINTER (signature),
2551 IDENTIFIER_LENGTH (signature)));
2553 START_RECORD_CONSTRUCTOR (sym, symbol_type);
2554 PUSH_FIELD_VALUE (sym, "clname", clname);
2555 PUSH_FIELD_VALUE (sym, "name", name);
2556 PUSH_FIELD_VALUE (sym, "signature", signature);
2557 FINISH_RECORD_CONSTRUCTOR (sym);
2558 TREE_CONSTANT (sym) = 1;
2559 TREE_INVARIANT (sym) = 1;
2564 /* Emit a symbol table: used by -findirect-dispatch. */
2567 emit_symbol_table (tree name, tree the_table, tree decl_list,
2568 tree the_syms_decl, tree the_array_element_type,
2571 tree method_list, method, table, list, null_symbol;
2572 tree table_size, the_array_type;
2575 /* Only emit a table if this translation unit actually made any
2576 references via it. */
2577 if (decl_list == NULL_TREE)
2580 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2582 method_list = decl_list;
2584 while (method_list != NULL_TREE)
2586 method = TREE_VALUE (method_list);
2587 list = tree_cons (NULL_TREE, build_symbol_entry (method), list);
2588 method_list = TREE_CHAIN (method_list);
2592 /* Terminate the list with a "null" entry. */
2593 START_RECORD_CONSTRUCTOR (null_symbol, symbol_type);
2594 PUSH_FIELD_VALUE (null_symbol, "clname", null_pointer_node);
2595 PUSH_FIELD_VALUE (null_symbol, "name", null_pointer_node);
2596 PUSH_FIELD_VALUE (null_symbol, "signature", null_pointer_node);
2597 FINISH_RECORD_CONSTRUCTOR (null_symbol);
2598 TREE_CONSTANT (null_symbol) = 1;
2599 TREE_INVARIANT (null_symbol) = 1;
2600 list = tree_cons (NULL_TREE, null_symbol, list);
2602 /* Put the list in the right order and make it a constructor. */
2603 list = nreverse (list);
2604 table = build_constructor_from_list (symbols_array_type, list);
2606 /* Make it the initial value for otable_syms and emit the decl. */
2607 DECL_INITIAL (the_syms_decl) = table;
2608 DECL_ARTIFICIAL (the_syms_decl) = 1;
2609 DECL_IGNORED_P (the_syms_decl) = 1;
2610 rest_of_decl_compilation (the_syms_decl, 1, 0);
2612 /* Now that its size is known, redefine the table as an
2613 uninitialized static array of INDEX + 1 elements. The extra entry
2614 is used by the runtime to track whether the table has been
2617 = build_index_type (build_int_cst (NULL_TREE, index * element_size + 1));
2618 the_array_type = build_array_type (the_array_element_type, table_size);
2619 the_table = build_decl (VAR_DECL, name, the_array_type);
2620 TREE_STATIC (the_table) = 1;
2621 TREE_READONLY (the_table) = 1;
2622 rest_of_decl_compilation (the_table, 1, 0);
2627 /* Make an entry for the catch_classes list. */
2629 make_catch_class_record (tree catch_class, tree classname)
2632 tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
2633 START_RECORD_CONSTRUCTOR (entry, type);
2634 PUSH_FIELD_VALUE (entry, "address", catch_class);
2635 PUSH_FIELD_VALUE (entry, "classname", classname);
2636 FINISH_RECORD_CONSTRUCTOR (entry);
2641 /* Generate the list of Throwable classes that are caught by exception
2642 handlers in this class. */
2644 emit_catch_table (tree this_class)
2646 tree table, table_size, array_type;
2647 TYPE_CATCH_CLASSES (this_class) =
2649 make_catch_class_record (null_pointer_node, null_pointer_node),
2650 TYPE_CATCH_CLASSES (this_class));
2651 TYPE_CATCH_CLASSES (this_class) = nreverse (TYPE_CATCH_CLASSES (this_class));
2652 TYPE_CATCH_CLASSES (this_class) =
2654 make_catch_class_record (null_pointer_node, null_pointer_node),
2655 TYPE_CATCH_CLASSES (this_class));
2656 table_size = build_index_type
2657 (build_int_cst (NULL_TREE,
2658 list_length (TYPE_CATCH_CLASSES (this_class))));
2660 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
2663 build_decl (VAR_DECL, DECL_NAME (TYPE_CTABLE_DECL (this_class)), array_type);
2664 DECL_INITIAL (table) =
2665 build_constructor_from_list (array_type, TYPE_CATCH_CLASSES (this_class));
2666 TREE_STATIC (table) = 1;
2667 TREE_READONLY (table) = 1;
2668 DECL_IGNORED_P (table) = 1;
2669 rest_of_decl_compilation (table, 1, 0);
2673 /* Given a type, return the signature used by
2674 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2675 same as build_java_signature() because we want the canonical array
2679 build_signature_for_libgcj (tree type)
2683 sig = build_java_signature (type);
2684 ref = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
2685 IDENTIFIER_LENGTH (sig)));
2689 /* Add an entry to the type assertion table. Callback used during hashtable
2693 add_assertion_table_entry (void **htab_entry, void *ptr)
2696 tree code_val, op1_utf8, op2_utf8;
2697 tree *list = (tree *) ptr;
2698 type_assertion *as = (type_assertion *) *htab_entry;
2700 code_val = build_int_cst (NULL_TREE, as->assertion_code);
2702 if (as->op1 == NULL_TREE)
2703 op1_utf8 = null_pointer_node;
2705 op1_utf8 = build_signature_for_libgcj (as->op1);
2707 if (as->op2 == NULL_TREE)
2708 op2_utf8 = null_pointer_node;
2710 op2_utf8 = build_signature_for_libgcj (as->op2);
2712 START_RECORD_CONSTRUCTOR (entry, assertion_entry_type);
2713 PUSH_FIELD_VALUE (entry, "assertion_code", code_val);
2714 PUSH_FIELD_VALUE (entry, "op1", op1_utf8);
2715 PUSH_FIELD_VALUE (entry, "op2", op2_utf8);
2716 FINISH_RECORD_CONSTRUCTOR (entry);
2718 *list = tree_cons (NULL_TREE, entry, *list);
2722 /* Generate the type assertion table for CLASS, and return its DECL. */
2725 emit_assertion_table (tree class)
2727 tree null_entry, ctor, table_decl;
2728 tree list = NULL_TREE;
2729 htab_t assertions_htab = TYPE_ASSERTIONS (class);
2731 /* Iterate through the hash table. */
2732 htab_traverse (assertions_htab, add_assertion_table_entry, &list);
2734 /* Finish with a null entry. */
2735 START_RECORD_CONSTRUCTOR (null_entry, assertion_entry_type);
2736 PUSH_FIELD_VALUE (null_entry, "assertion_code", integer_zero_node);
2737 PUSH_FIELD_VALUE (null_entry, "op1", null_pointer_node);
2738 PUSH_FIELD_VALUE (null_entry, "op2", null_pointer_node);
2739 FINISH_RECORD_CONSTRUCTOR (null_entry);
2741 list = tree_cons (NULL_TREE, null_entry, list);
2743 /* Put the list in the right order and make it a constructor. */
2744 list = nreverse (list);
2745 ctor = build_constructor_from_list (assertion_table_type, list);
2747 table_decl = build_decl (VAR_DECL, mangled_classname ("_type_assert_", class),
2748 assertion_table_type);
2750 TREE_STATIC (table_decl) = 1;
2751 TREE_READONLY (table_decl) = 1;
2752 TREE_CONSTANT (table_decl) = 1;
2753 DECL_IGNORED_P (table_decl) = 1;
2755 DECL_INITIAL (table_decl) = ctor;
2756 DECL_ARTIFICIAL (table_decl) = 1;
2757 rest_of_decl_compilation (table_decl, 1, 0);
2763 init_class_processing (void)
2765 fields_ident = get_identifier ("fields");
2766 info_ident = get_identifier ("info");
2768 gcc_obstack_init (&temporary_obstack);
2771 static hashval_t java_treetreehash_hash (const void *);
2772 static int java_treetreehash_compare (const void *, const void *);
2774 /* A hash table mapping trees to trees. Used generally. */
2776 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2779 java_treetreehash_hash (const void *k_p)
2781 struct treetreehash_entry *k = (struct treetreehash_entry *) k_p;
2782 return JAVA_TREEHASHHASH_H (k->key);
2786 java_treetreehash_compare (const void * k1_p, const void * k2_p)
2788 struct treetreehash_entry * k1 = (struct treetreehash_entry *) k1_p;
2789 tree k2 = (tree) k2_p;
2790 return (k1->key == k2);
2794 java_treetreehash_find (htab_t ht, tree t)
2796 struct treetreehash_entry *e;
2797 hashval_t hv = JAVA_TREEHASHHASH_H (t);
2798 e = htab_find_with_hash (ht, t, hv);
2806 java_treetreehash_new (htab_t ht, tree t)
2809 struct treetreehash_entry *tthe;
2810 hashval_t hv = JAVA_TREEHASHHASH_H (t);
2812 e = htab_find_slot_with_hash (ht, t, hv, INSERT);
2815 tthe = (*ht->alloc_f) (1, sizeof (*tthe));
2820 tthe = (struct treetreehash_entry *) *e;
2821 return &tthe->value;
2825 java_treetreehash_create (size_t size, int gc)
2828 return htab_create_ggc (size, java_treetreehash_hash,
2829 java_treetreehash_compare, NULL);
2831 return htab_create_alloc (size, java_treetreehash_hash,
2832 java_treetreehash_compare, free, xcalloc, free);
2835 /* Break down qualified IDENTIFIER into package and class-name components.
2836 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
2837 "pkg.foo", and RIGHT to "Bar". */
2840 split_qualified_name (tree *left, tree *right, tree source)
2843 int l = IDENTIFIER_LENGTH (source);
2845 base = alloca (l + 1);
2846 memcpy (base, IDENTIFIER_POINTER (source), l + 1);
2848 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
2850 while (*p != '.' && p != base)
2853 /* We didn't find a '.'. Return an error. */
2859 *right = get_identifier (p+1);
2860 *left = get_identifier (base);
2865 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
2866 if the classes are from the same package. */
2869 in_same_package (tree name1, tree name2)
2875 if (TREE_CODE (name1) == TYPE_DECL)
2876 name1 = DECL_NAME (name1);
2877 if (TREE_CODE (name2) == TYPE_DECL)
2878 name2 = DECL_NAME (name2);
2880 if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
2881 /* One in empty package. */
2884 if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
2885 /* Both in empty package. */
2888 split_qualified_name (&pkg1, &tmp, name1);
2889 split_qualified_name (&pkg2, &tmp, name2);
2891 return (pkg1 == pkg2);
2894 #include "gt-java-class.h"