1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007 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"
51 /* DOS brain-damage */
53 #define O_BINARY 0 /* MS-DOS brain-damage */
56 static tree make_method_value (tree);
57 static tree build_java_method_type (tree, tree, int);
58 static int32 hashUtf8String (const char *, int);
59 static tree make_field_value (tree);
60 static tree get_dispatch_vector (tree);
61 static tree get_dispatch_table (tree, tree);
62 static int supers_all_compiled (tree type);
63 static tree maybe_layout_super_class (tree, tree);
64 static void add_miranda_methods (tree, tree);
65 static int assume_compiled (const char *);
66 static tree build_symbol_entry (tree, tree);
67 static tree emit_assertion_table (tree);
68 static void register_class (void);
70 struct obstack temporary_obstack;
72 static const char *cyclic_inheritance_report;
74 /* The compiler generates different code depending on whether or not
75 it can assume certain classes have been compiled down to native
76 code or not. The compiler options -fassume-compiled= and
77 -fno-assume-compiled= are used to create a tree of
78 class_flag_node objects. This tree is queried to determine if
79 a class is assume to be compiled or not. Each node in the tree
80 represents either a package or a specific class. */
82 typedef struct class_flag_node_struct
84 /* The class or package name. */
87 /* Nonzero if this represents an exclusion. */
90 /* Pointers to other nodes in the tree. */
91 struct class_flag_node_struct *parent;
92 struct class_flag_node_struct *sibling;
93 struct class_flag_node_struct *child;
96 static class_flag_node *find_class_flag_node (class_flag_node *, const char *);
97 static void add_class_flag (class_flag_node **, const char *, int);
99 /* This is the root of the include/exclude tree. */
101 static class_flag_node *assume_compiled_tree;
103 static class_flag_node *enable_assert_tree;
105 static GTY(()) tree class_roots[4];
106 #define fields_ident class_roots[0] /* get_identifier ("fields") */
107 #define info_ident class_roots[1] /* get_identifier ("info") */
108 #define class_list class_roots[2]
109 #define class_dtable_decl class_roots[3]
111 static GTY(()) VEC(tree,gc) *registered_class;
113 /* A tree that returns the address of the class$ of the class
114 currently being compiled. */
115 static GTY(()) tree this_classdollar;
117 /* Return the node that most closely represents the class whose name
118 is IDENT. Start the search from NODE (followed by its siblings).
119 Return NULL if an appropriate node does not exist. */
121 static class_flag_node *
122 find_class_flag_node (class_flag_node *node, const char *ident)
126 size_t node_ident_length = strlen (node->ident);
128 /* node_ident_length is zero at the root of the tree. If the
129 identifiers are the same length, then we have matching
130 classes. Otherwise check if we've matched an enclosing
133 if (node_ident_length == 0
134 || (strncmp (ident, node->ident, node_ident_length) == 0
135 && (ident[node_ident_length] == '\0'
136 || ident[node_ident_length] == '.')))
138 /* We've found a match, however, there might be a more
141 class_flag_node *found = find_class_flag_node (node->child, ident);
148 /* No match yet. Continue through the sibling list. */
149 node = node->sibling;
152 /* No match at all in this tree. */
157 add_class_flag (class_flag_node **rootp, const char *ident, int value)
159 class_flag_node *root = *rootp;
160 class_flag_node *parent, *node;
162 /* Create the root of the tree if it doesn't exist yet. */
166 root = XNEW (class_flag_node);
169 root->sibling = NULL;
175 /* Calling the function with the empty string means we're setting
176 value for the root of the hierarchy. */
184 /* Find the parent node for this new node. PARENT will either be a
185 class or a package name. Adjust PARENT accordingly. */
187 parent = find_class_flag_node (root, ident);
188 if (strcmp (ident, parent->ident) == 0)
189 parent->value = value;
192 /* Insert new node into the tree. */
193 node = XNEW (class_flag_node);
195 node->ident = xstrdup (ident);
199 node->parent = parent;
200 node->sibling = parent->child;
201 parent->child = node;
205 /* Add a new IDENT to the include/exclude tree. It's an exclusion
206 if EXCLUDEP is nonzero. */
209 add_assume_compiled (const char *ident, int excludep)
211 add_class_flag (&assume_compiled_tree, ident, excludep);
214 /* The default value returned by enable_assertions. */
216 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
218 /* Enter IDENT (a class or package name) into the enable-assertions table.
219 VALUE is true to enable and false to disable. */
222 add_enable_assert (const char *ident, int value)
224 if (enable_assert_tree == NULL)
225 add_class_flag (&enable_assert_tree, "", DEFAULT_ENABLE_ASSERT);
226 add_class_flag (&enable_assert_tree, ident, value);
229 /* Returns nonzero if IDENT is the name of a class that the compiler
230 should assume has been compiled to object code. */
233 assume_compiled (const char *ident)
238 if (NULL == assume_compiled_tree)
241 i = find_class_flag_node (assume_compiled_tree, ident);
248 /* Return true if we should generate code to check assertions within KLASS. */
251 enable_assertions (tree klass)
253 /* Check if command-line specifies whether we should check assertions. */
255 if (klass != NULL_TREE && DECL_NAME (klass) && enable_assert_tree != NULL)
257 const char *ident = IDENTIFIER_POINTER (DECL_NAME (klass));
258 class_flag_node *node
259 = find_class_flag_node (enable_assert_tree, ident);
263 /* The default is to enable assertions if generating class files,
264 or not optimizing. */
265 return DEFAULT_ENABLE_ASSERT;
268 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
269 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
270 Also, PREFIX is prepended, and SUFFIX is appended. */
273 ident_subst (const char* old_name,
280 int prefix_len = strlen (prefix);
281 int suffix_len = strlen (suffix);
282 int i = prefix_len + old_length + suffix_len + 1;
283 char *buffer = alloca (i);
285 strcpy (buffer, prefix);
286 for (i = 0; i < old_length; i++)
288 char ch = old_name[i];
291 buffer[prefix_len + i] = ch;
293 strcpy (buffer + prefix_len + old_length, suffix);
294 return get_identifier (buffer);
297 /* Return an IDENTIFIER_NODE the same as OLD_ID,
298 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
299 Also, PREFIX is prepended, and SUFFIX is appended. */
302 identifier_subst (const tree old_id,
308 return ident_subst (IDENTIFIER_POINTER (old_id), IDENTIFIER_LENGTH (old_id),
309 prefix, old_char, new_char, suffix);
312 /* Generate a valid C identifier from the name of the class TYPE,
313 prefixed by PREFIX. */
316 mangled_classname (const char *prefix, tree type)
318 tree ident = TYPE_NAME (type);
319 if (TREE_CODE (ident) != IDENTIFIER_NODE)
320 ident = DECL_NAME (ident);
321 return identifier_subst (ident, prefix, '.', '_', "");
328 type = make_node (RECORD_TYPE);
329 /* Unfortunately we must create the binfo here, so that class
331 TYPE_BINFO (type) = make_tree_binfo (0);
332 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
337 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
338 and where each of the constituents is separated by '/',
339 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
342 unmangle_classname (const char *name, int name_length)
344 tree to_return = ident_subst (name, name_length, "", '/', '.', "");
345 /* It's not sufficient to compare to_return and get_identifier
346 (name) to determine whether to_return is qualified. There are
347 cases in signature analysis where name will be stripped of a
349 name = IDENTIFIER_POINTER (to_return);
353 QUALIFIED_P (to_return) = 1;
360 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
363 const char *typename = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
364 char *buf = alloca (strlen (typename) + strlen (#NAME "_syms_") + 1); \
367 sprintf (buf, #NAME "_%s", typename); \
368 TYPE_## TABLE ##_DECL (type) = decl = \
369 build_decl (VAR_DECL, get_identifier (buf), TABLE_TYPE); \
370 DECL_EXTERNAL (decl) = 1; \
371 TREE_STATIC (decl) = 1; \
372 TREE_READONLY (decl) = 1; \
373 TREE_CONSTANT (decl) = 1; \
374 DECL_IGNORED_P (decl) = 1; \
375 /* Mark the table as belonging to this class. */ \
377 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
378 DECL_OWNER (decl) = TYPE; \
379 sprintf (buf, #NAME "_syms_%s", typename); \
380 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
381 build_decl (VAR_DECL, get_identifier (buf), symbols_array_type); \
382 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
383 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
384 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
388 /* Given a class, create the DECLs for all its associated indirect
391 gen_indirect_dispatch_tables (tree type)
393 const char *typename = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
396 char *buf = alloca (strlen (typename) + strlen ("_catch_classes_") + 1);
397 tree catch_class_type = make_node (RECORD_TYPE);
399 sprintf (buf, "_catch_classes_%s", typename);
400 PUSH_FIELD (catch_class_type, field, "address", utf8const_ptr_type);
401 PUSH_FIELD (catch_class_type, field, "classname", ptr_type_node);
402 FINISH_RECORD (catch_class_type);
404 TYPE_CTABLE_DECL (type)
405 = build_decl (VAR_DECL, get_identifier (buf),
406 build_array_type (catch_class_type, 0));
407 DECL_EXTERNAL (TYPE_CTABLE_DECL (type)) = 1;
408 TREE_STATIC (TYPE_CTABLE_DECL (type)) = 1;
409 TREE_READONLY (TYPE_CTABLE_DECL (type)) = 1;
410 TREE_CONSTANT (TYPE_CTABLE_DECL (type)) = 1;
411 DECL_IGNORED_P (TYPE_CTABLE_DECL (type)) = 1;
412 pushdecl (TYPE_CTABLE_DECL (type));
415 if (flag_indirect_dispatch)
417 GEN_TABLE (ATABLE, _atable, atable_type, type);
418 GEN_TABLE (OTABLE, _otable, otable_type, type);
419 GEN_TABLE (ITABLE, _itable, itable_type, type);
426 push_class (tree class_type, tree class_name)
428 tree decl, signature;
429 location_t saved_loc = input_location;
430 #ifndef USE_MAPPED_LOCATION
431 tree source_name = identifier_subst (class_name, "", '.', '/', ".java");
432 input_filename = IDENTIFIER_POINTER (source_name);
435 CLASS_P (class_type) = 1;
436 decl = build_decl (TYPE_DECL, class_name, class_type);
437 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
439 /* dbxout needs a DECL_SIZE if in gstabs mode */
440 DECL_SIZE (decl) = integer_zero_node;
442 input_location = saved_loc;
443 signature = identifier_subst (class_name, "L", '.', '/', ";");
444 IDENTIFIER_SIGNATURE_TYPE (signature) = build_pointer_type (class_type);
446 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
447 both a typedef and in the struct name-space. We may want to re-visit
448 this later, but for now it reduces the changes needed for gdb. */
449 DECL_ARTIFICIAL (decl) = 1;
451 pushdecl_top_level (decl);
456 /* Finds the (global) class named NAME. Creates the class if not found.
457 Also creates associated TYPE_DECL.
458 Does not check if the class actually exists, load the class,
459 fill in field or methods, or do layout_type. */
462 lookup_class (tree name)
464 tree decl = IDENTIFIER_CLASS_VALUE (name);
465 if (decl == NULL_TREE)
466 decl = push_class (make_class (), name);
467 return TREE_TYPE (decl);
471 set_super_info (int access_flags, tree this_class,
472 tree super_class, int interfaces_count)
474 int total_supers = interfaces_count;
475 tree class_decl = TYPE_NAME (this_class);
481 TYPE_BINFO (this_class) = make_tree_binfo (total_supers);
482 TYPE_VFIELD (this_class) = TYPE_VFIELD (object_type_node);
485 tree super_binfo = make_tree_binfo (0);
486 BINFO_TYPE (super_binfo) = super_class;
487 BINFO_OFFSET (super_binfo) = integer_zero_node;
488 BINFO_BASE_APPEND (TYPE_BINFO (this_class), super_binfo);
489 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class)) = 1;
492 set_class_decl_access_flags (access_flags, class_decl);
496 set_class_decl_access_flags (int access_flags, tree class_decl)
498 if (access_flags & ACC_PUBLIC) CLASS_PUBLIC (class_decl) = 1;
499 if (access_flags & ACC_FINAL) CLASS_FINAL (class_decl) = 1;
500 if (access_flags & ACC_SUPER) CLASS_SUPER (class_decl) = 1;
501 if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
502 if (access_flags & ACC_ABSTRACT) CLASS_ABSTRACT (class_decl) = 1;
503 if (access_flags & ACC_STATIC) CLASS_STATIC (class_decl) = 1;
504 if (access_flags & ACC_PRIVATE) CLASS_PRIVATE (class_decl) = 1;
505 if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
506 if (access_flags & ACC_STRICT) CLASS_STRICTFP (class_decl) = 1;
507 if (access_flags & ACC_ENUM) CLASS_ENUM (class_decl) = 1;
508 if (access_flags & ACC_SYNTHETIC) CLASS_SYNTHETIC (class_decl) = 1;
509 if (access_flags & ACC_ANNOTATION) CLASS_ANNOTATION (class_decl) = 1;
512 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
513 direct sub-classes of Object are 1, and so on. */
516 class_depth (tree clas)
519 if (! CLASS_LOADED_P (clas))
520 load_class (clas, 1);
521 if (TYPE_SIZE (clas) == error_mark_node)
523 while (clas != object_type_node)
526 clas = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas), 0));
531 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
534 interface_of_p (tree type1, tree type2)
537 tree binfo, base_binfo;
539 if (! TYPE_BINFO (type2))
542 for (binfo = TYPE_BINFO (type2), i = 0;
543 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
544 if (BINFO_TYPE (base_binfo) == type1)
547 for (binfo = TYPE_BINFO (type2), i = 0;
548 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) /* */
549 if (BINFO_TYPE (base_binfo)
550 && interface_of_p (type1, BINFO_TYPE (base_binfo)))
556 /* Return true iff TYPE1 inherits from TYPE2. */
559 inherits_from_p (tree type1, tree type2)
561 while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
566 if (! CLASS_LOADED_P (type1))
567 load_class (type1, 1);
569 type1 = maybe_layout_super_class (CLASSTYPE_SUPER (type1), type1);
574 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
577 enclosing_context_p (tree type1, tree type2)
579 if (!INNER_CLASS_TYPE_P (type2))
582 for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
584 type2 = (INNER_CLASS_TYPE_P (type2) ?
585 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
595 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
599 common_enclosing_context_p (tree type1, tree type2)
604 for (current = type2; current;
605 current = (INNER_CLASS_TYPE_P (current) ?
606 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
608 if (type1 == current)
611 if (INNER_CLASS_TYPE_P (type1))
612 type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1)));
619 /* Return 1 iff there exists a common enclosing "this" between TYPE1
620 and TYPE2, without crossing any static context. */
623 common_enclosing_instance_p (tree type1, tree type2)
625 if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
628 for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1;
629 type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
630 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
633 for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
634 current = (PURE_INNER_CLASS_TYPE_P (current) ?
635 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
637 if (type1 == current)
643 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
644 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
645 if attempt is made to add it twice. */
648 maybe_add_interface (tree this_class, tree interface_class)
650 tree binfo, base_binfo;
653 for (binfo = TYPE_BINFO (this_class), i = 0;
654 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
655 if (BINFO_TYPE (base_binfo) == interface_class)
656 return interface_class;
657 add_interface (this_class, interface_class);
661 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
664 add_interface (tree this_class, tree interface_class)
666 tree interface_binfo = make_tree_binfo (0);
668 BINFO_TYPE (interface_binfo) = interface_class;
669 BINFO_OFFSET (interface_binfo) = integer_zero_node;
670 BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node;
671 BINFO_VIRTUAL_P (interface_binfo) = 1;
673 BINFO_BASE_APPEND (TYPE_BINFO (this_class), interface_binfo);
677 build_java_method_type (tree fntype, tree this_class, int access_flags)
679 if (access_flags & ACC_STATIC)
681 fntype = build_method_type (this_class, fntype);
683 /* We know that arg 1 of every nonstatic method is non-null; tell
685 TYPE_ATTRIBUTES (fntype) = (tree_cons
686 (get_identifier ("nonnull"),
687 tree_cons (NULL_TREE,
688 build_int_cst (NULL_TREE, 1),
690 TYPE_ATTRIBUTES (fntype)));
695 add_method_1 (tree this_class, int access_flags, tree name, tree function_type)
697 tree method_type, fndecl;
699 method_type = build_java_method_type (function_type,
700 this_class, access_flags);
702 fndecl = build_decl (FUNCTION_DECL, name, method_type);
703 DECL_CONTEXT (fndecl) = this_class;
705 DECL_LANG_SPECIFIC (fndecl)
706 = ggc_alloc_cleared (sizeof (struct lang_decl));
707 DECL_LANG_SPECIFIC (fndecl)->desc = LANG_DECL_FUNC;
709 /* Initialize the static initializer test table. */
711 DECL_FUNCTION_INIT_TEST_TABLE (fndecl) =
712 java_treetreehash_create (10, 1);
714 /* Initialize the initialized (static) class table. */
715 if (access_flags & ACC_STATIC)
716 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) =
717 htab_create_ggc (50, htab_hash_pointer, htab_eq_pointer, NULL);
719 TREE_CHAIN (fndecl) = TYPE_METHODS (this_class);
720 TYPE_METHODS (this_class) = fndecl;
722 /* Notice that this is a finalizer and update the class type
723 accordingly. This is used to optimize instance allocation. */
724 if (name == finalize_identifier_node
725 && TREE_TYPE (function_type) == void_type_node
726 && TREE_VALUE (TYPE_ARG_TYPES (function_type)) == void_type_node)
727 HAS_FINALIZER_P (this_class) = 1;
729 if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
730 if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
731 if (access_flags & ACC_PRIVATE)
732 METHOD_PRIVATE (fndecl) = DECL_INLINE (fndecl) = 1;
733 if (access_flags & ACC_NATIVE)
735 METHOD_NATIVE (fndecl) = 1;
736 DECL_EXTERNAL (fndecl) = 1;
739 /* FNDECL is external unless we are compiling it into this object
741 DECL_EXTERNAL (fndecl) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class) == 0;
742 if (access_flags & ACC_STATIC)
743 METHOD_STATIC (fndecl) = DECL_INLINE (fndecl) = 1;
744 if (access_flags & ACC_FINAL)
745 METHOD_FINAL (fndecl) = DECL_INLINE (fndecl) = 1;
746 if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
747 if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
748 if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
749 if (access_flags & ACC_SYNTHETIC) DECL_ARTIFICIAL (fndecl) = 1;
750 if (access_flags & ACC_BRIDGE) METHOD_BRIDGE (fndecl) = 1;
751 if (access_flags & ACC_VARARGS) METHOD_VARARGS (fndecl) = 1;
755 /* Add a method to THIS_CLASS.
756 The method's name is NAME.
757 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
760 add_method (tree this_class, int access_flags, tree name, tree method_sig)
762 tree function_type, fndecl;
763 const unsigned char *sig
764 = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
767 fatal_error ("bad method signature");
769 function_type = get_type_from_signature (method_sig);
770 fndecl = add_method_1 (this_class, access_flags, name, function_type);
771 set_java_signature (TREE_TYPE (fndecl), method_sig);
776 add_field (tree class, tree name, tree field_type, int flags)
778 int is_static = (flags & ACC_STATIC) != 0;
780 field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type);
781 TREE_CHAIN (field) = TYPE_FIELDS (class);
782 TYPE_FIELDS (class) = field;
783 DECL_CONTEXT (field) = class;
784 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
786 if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
787 if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
788 if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
789 if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
790 if (flags & ACC_VOLATILE)
792 FIELD_VOLATILE (field) = 1;
793 TREE_THIS_VOLATILE (field) = 1;
795 if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
796 if (flags & ACC_ENUM) FIELD_ENUM (field) = 1;
797 if (flags & ACC_SYNTHETIC) FIELD_SYNTHETIC (field) = 1;
800 FIELD_STATIC (field) = 1;
801 /* Always make field externally visible. This is required so
802 that native methods can always access the field. */
803 TREE_PUBLIC (field) = 1;
804 /* Considered external unless we are compiling it into this
806 DECL_EXTERNAL (field) = (is_compiled_class (class) != 2);
812 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
815 set_constant_value (tree field, tree constant)
817 if (field == NULL_TREE)
818 warning (OPT_Wattributes,
819 "misplaced ConstantValue attribute (not in any field)");
820 else if (DECL_INITIAL (field) != NULL_TREE)
821 warning (OPT_Wattributes,
822 "duplicate ConstantValue attribute for field '%s'",
823 IDENTIFIER_POINTER (DECL_NAME (field)));
826 DECL_INITIAL (field) = constant;
827 if (TREE_TYPE (constant) != TREE_TYPE (field)
828 && ! (TREE_TYPE (constant) == int_type_node
829 && INTEGRAL_TYPE_P (TREE_TYPE (field))
830 && TYPE_PRECISION (TREE_TYPE (field)) <= 32)
831 && ! (TREE_TYPE (constant) == utf8const_ptr_type
832 && TREE_TYPE (field) == string_ptr_type_node))
833 error ("ConstantValue attribute of field '%s' has wrong type",
834 IDENTIFIER_POINTER (DECL_NAME (field)));
835 if (FIELD_FINAL (field))
836 DECL_FIELD_FINAL_IUD (field) = 1;
840 /* Calculate a hash value for a string encoded in Utf8 format.
841 * This returns the same hash value as specified for java.lang.String.hashCode.
845 hashUtf8String (const char *str, int len)
847 const unsigned char* ptr = (const unsigned char*) str;
848 const unsigned char *limit = ptr + len;
852 int ch = UTF8_GET (ptr, limit);
853 /* Updated specification from
854 http://www.javasoft.com/docs/books/jls/clarify.html. */
855 hash = (31 * hash) + ch;
860 static GTY(()) tree utf8_decl_list = NULL_TREE;
863 build_utf8_ref (tree name)
865 const char * name_ptr = IDENTIFIER_POINTER(name);
866 int name_len = IDENTIFIER_LENGTH(name);
868 tree ctype, field = NULL_TREE, str_type, cinit, string;
869 static int utf8_count = 0;
871 tree ref = IDENTIFIER_UTF8_REF (name);
873 if (ref != NULL_TREE)
876 ctype = make_node (RECORD_TYPE);
877 str_type = build_prim_array_type (unsigned_byte_type_node,
878 name_len + 1); /* Allow for final '\0'. */
879 PUSH_FIELD (ctype, field, "hash", unsigned_short_type_node);
880 PUSH_FIELD (ctype, field, "length", unsigned_short_type_node);
881 PUSH_FIELD (ctype, field, "data", str_type);
882 FINISH_RECORD (ctype);
883 START_RECORD_CONSTRUCTOR (cinit, ctype);
884 name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
885 PUSH_FIELD_VALUE (cinit, "hash", build_int_cst (NULL_TREE, name_hash));
886 PUSH_FIELD_VALUE (cinit, "length", build_int_cst (NULL_TREE, name_len));
887 string = build_string (name_len, name_ptr);
888 TREE_TYPE (string) = str_type;
889 PUSH_FIELD_VALUE (cinit, "data", string);
890 FINISH_RECORD_CONSTRUCTOR (cinit);
891 TREE_CONSTANT (cinit) = 1;
892 TREE_INVARIANT (cinit) = 1;
894 /* Generate a unique-enough identifier. */
895 sprintf(buf, "_Utf%d", ++utf8_count);
897 decl = build_decl (VAR_DECL, get_identifier (buf), utf8const_type);
898 TREE_STATIC (decl) = 1;
899 DECL_ARTIFICIAL (decl) = 1;
900 DECL_IGNORED_P (decl) = 1;
901 TREE_READONLY (decl) = 1;
902 TREE_THIS_VOLATILE (decl) = 0;
903 DECL_INITIAL (decl) = cinit;
905 if (HAVE_GAS_SHF_MERGE)
908 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
909 decl_size = (name_len + 5 + TYPE_ALIGN_UNIT (utf8const_type) - 1)
910 & ~(TYPE_ALIGN_UNIT (utf8const_type) - 1);
911 if (flag_merge_constants && decl_size < 256)
914 int flags = (SECTION_OVERRIDE
915 | SECTION_MERGE | (SECTION_ENTSIZE & decl_size));
916 sprintf (buf, ".rodata.jutf8.%d", decl_size);
917 switch_to_section (get_section (buf, flags, NULL));
918 DECL_SECTION_NAME (decl) = build_string (strlen (buf), buf);
922 TREE_CHAIN (decl) = utf8_decl_list;
923 layout_decl (decl, 0);
925 rest_of_decl_compilation (decl, global_bindings_p (), 0);
926 varpool_mark_needed_node (varpool_node (decl));
927 utf8_decl_list = decl;
928 ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
929 IDENTIFIER_UTF8_REF (name) = ref;
933 /* Like build_class_ref, but instead of a direct reference generate a
934 pointer into the constant pool. */
937 build_indirect_class_ref (tree type)
941 index = alloc_class_constant (type);
942 cl = build_ref_from_constant_pool (index);
943 return convert (promote_type (class_ptr_type), cl);
947 build_static_class_ref (tree type)
949 tree decl_name, decl, ref;
951 if (TYPE_SIZE (type) == error_mark_node)
952 return null_pointer_node;
953 decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
954 "", '/', '/', ".class$$");
955 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
956 if (decl == NULL_TREE)
958 decl = build_decl (VAR_DECL, decl_name, class_type_node);
959 TREE_STATIC (decl) = 1;
960 if (! flag_indirect_classes)
961 TREE_PUBLIC (decl) = 1;
962 DECL_IGNORED_P (decl) = 1;
963 DECL_ARTIFICIAL (decl) = 1;
964 if (is_compiled_class (type) == 1)
965 DECL_EXTERNAL (decl) = 1;
966 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
967 DECL_CLASS_FIELD_P (decl) = 1;
968 DECL_CONTEXT (decl) = type;
970 /* ??? We want to preserve the DECL_CONTEXT we set just above,
971 that that means not calling pushdecl_top_level. */
972 IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
975 ref = build1 (ADDR_EXPR, class_ptr_type, decl);
980 build_classdollar_field (tree type)
982 tree decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
983 "", '/', '/', ".class$");
984 tree decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
986 if (decl == NULL_TREE)
989 = build_decl (VAR_DECL, decl_name,
992 (build_type_variant (class_type_node,
995 TREE_STATIC (decl) = 1;
996 TREE_INVARIANT (decl) = 1;
997 TREE_CONSTANT (decl) = 1;
998 TREE_READONLY (decl) = 1;
999 TREE_PUBLIC (decl) = 1;
1000 DECL_IGNORED_P (decl) = 1;
1001 DECL_ARTIFICIAL (decl) = 1;
1002 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1003 IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
1004 DECL_CLASS_FIELD_P (decl) = 1;
1005 DECL_CONTEXT (decl) = type;
1011 /* Create a local variable that holds the the current class$. */
1014 cache_this_class_ref (tree fndecl)
1018 tree classdollar_field;
1019 if (flag_indirect_classes)
1020 classdollar_field = build_classdollar_field (output_class);
1022 classdollar_field = build_static_class_ref (output_class);
1024 this_classdollar = build_decl (VAR_DECL, NULL_TREE,
1025 TREE_TYPE (classdollar_field));
1027 java_add_local_var (this_classdollar);
1028 java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (this_classdollar),
1029 this_classdollar, classdollar_field));
1032 this_classdollar = build_classdollar_field (output_class);
1034 /* Prepend class initialization for static methods reachable from
1036 if (METHOD_STATIC (fndecl)
1037 && (! METHOD_PRIVATE (fndecl)
1038 || INNER_CLASS_P (DECL_CONTEXT (fndecl)))
1039 && ! DECL_CLINIT_P (fndecl)
1040 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl))))
1042 tree init = build3 (CALL_EXPR, void_type_node,
1043 build_address_of (soft_initclass_node),
1044 build_tree_list (NULL_TREE, this_classdollar),
1046 java_add_stmt (init);
1050 /* Build a reference to the class TYPE.
1051 Also handles primitive types and array types. */
1054 build_class_ref (tree type)
1056 int is_compiled = is_compiled_class (type);
1060 if (TREE_CODE (type) == POINTER_TYPE)
1061 type = TREE_TYPE (type);
1063 if (flag_indirect_dispatch
1064 && type != output_class
1065 && TREE_CODE (type) == RECORD_TYPE)
1066 return build_indirect_class_ref (type);
1068 if (type == output_class && flag_indirect_classes)
1069 return this_classdollar;
1071 if (TREE_CODE (type) == RECORD_TYPE)
1072 return build_static_class_ref (type);
1078 decl_name = TYPE_NAME (type);
1079 if (TREE_CODE (decl_name) == TYPE_DECL)
1080 decl_name = DECL_NAME (decl_name);
1081 name = IDENTIFIER_POINTER (decl_name);
1082 if (strncmp (name, "promoted_", 9) == 0)
1084 sprintf (buffer, "_Jv_%sClass", name);
1085 decl_name = get_identifier (buffer);
1086 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1087 if (decl == NULL_TREE)
1089 decl = build_decl (VAR_DECL, decl_name, class_type_node);
1090 TREE_STATIC (decl) = 1;
1091 TREE_PUBLIC (decl) = 1;
1092 DECL_EXTERNAL (decl) = 1;
1093 DECL_ARTIFICIAL (decl) = 1;
1094 pushdecl_top_level (decl);
1098 ref = build1 (ADDR_EXPR, class_ptr_type, decl);
1102 return build_indirect_class_ref (type);
1105 /* Create a local statically allocated variable that will hold a
1106 pointer to a static field. */
1109 build_fieldref_cache_entry (int index, tree fdecl ATTRIBUTE_UNUSED)
1111 tree decl, decl_name;
1112 const char *name = IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class));
1113 char *buf = alloca (strlen (name) + 20);
1114 sprintf (buf, "%s_%d_ref", name, index);
1115 decl_name = get_identifier (buf);
1116 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1117 if (decl == NULL_TREE)
1119 decl = build_decl (VAR_DECL, decl_name, ptr_type_node);
1120 TREE_STATIC (decl) = 1;
1121 TREE_PUBLIC (decl) = 0;
1122 DECL_EXTERNAL (decl) = 0;
1123 DECL_ARTIFICIAL (decl) = 1;
1124 DECL_IGNORED_P (decl) = 1;
1125 pushdecl_top_level (decl);
1131 build_static_field_ref (tree fdecl)
1133 tree fclass = DECL_CONTEXT (fdecl);
1134 int is_compiled = is_compiled_class (fclass);
1135 int from_class = ! CLASS_FROM_SOURCE_P (current_class);
1137 /* Allow static final fields to fold to a constant. When using
1138 -findirect-dispatch, we simply never do this folding if compiling
1139 from .class; in the .class file constants will be referred to via
1140 the constant pool. */
1141 if ((!flag_indirect_dispatch || !from_class)
1143 || (FIELD_FINAL (fdecl) && DECL_INITIAL (fdecl) != NULL_TREE
1144 && (JSTRING_TYPE_P (TREE_TYPE (fdecl))
1145 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl)))
1146 && TREE_CONSTANT (DECL_INITIAL (fdecl)))))
1148 if (is_compiled == 1)
1149 DECL_EXTERNAL (fdecl) = 1;
1153 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1154 and a class local static variable CACHE_ENTRY, then
1156 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1157 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1160 This can mostly be optimized away, so that the usual path is a
1161 load followed by a test and branch. _Jv_ResolvePoolEntry is
1162 only called once for each constant pool entry.
1164 There is an optimization that we don't do: at the start of a
1165 method, create a local copy of CACHE_ENTRY and use that instead.
1169 int cpool_index = alloc_constant_fieldref (output_class, fdecl);
1170 tree cache_entry = build_fieldref_cache_entry (cpool_index, fdecl);
1172 = build3 (CALL_EXPR, boolean_type_node,
1173 build_address_of (built_in_decls[BUILT_IN_EXPECT]),
1174 tree_cons (NULL_TREE, build2 (EQ_EXPR, boolean_type_node,
1175 cache_entry, null_pointer_node),
1176 build_tree_list (NULL_TREE, boolean_false_node)),
1178 tree cpool_index_cst = build_int_cst (NULL_TREE, cpool_index);
1180 = build3 (CALL_EXPR, ptr_type_node,
1181 build_address_of (soft_resolvepoolentry_node),
1182 tree_cons (NULL_TREE, build_class_ref (output_class),
1183 build_tree_list (NULL_TREE, cpool_index_cst)),
1185 init = build2 (MODIFY_EXPR, ptr_type_node, cache_entry, init);
1186 init = build3 (COND_EXPR, ptr_type_node, test, init, cache_entry);
1187 init = fold_convert (build_pointer_type (TREE_TYPE (fdecl)), init);
1188 fdecl = build1 (INDIRECT_REF, TREE_TYPE (fdecl), init);
1194 get_access_flags_from_decl (tree decl)
1196 int access_flags = 0;
1197 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
1199 if (FIELD_STATIC (decl))
1200 access_flags |= ACC_STATIC;
1201 if (FIELD_PUBLIC (decl))
1202 access_flags |= ACC_PUBLIC;
1203 if (FIELD_PROTECTED (decl))
1204 access_flags |= ACC_PROTECTED;
1205 if (FIELD_PRIVATE (decl))
1206 access_flags |= ACC_PRIVATE;
1207 if (FIELD_FINAL (decl))
1208 access_flags |= ACC_FINAL;
1209 if (FIELD_VOLATILE (decl))
1210 access_flags |= ACC_VOLATILE;
1211 if (FIELD_TRANSIENT (decl))
1212 access_flags |= ACC_TRANSIENT;
1213 if (FIELD_ENUM (decl))
1214 access_flags |= ACC_ENUM;
1215 if (FIELD_SYNTHETIC (decl))
1216 access_flags |= ACC_SYNTHETIC;
1217 return access_flags;
1219 if (TREE_CODE (decl) == TYPE_DECL)
1221 if (CLASS_PUBLIC (decl))
1222 access_flags |= ACC_PUBLIC;
1223 if (CLASS_FINAL (decl))
1224 access_flags |= ACC_FINAL;
1225 if (CLASS_SUPER (decl))
1226 access_flags |= ACC_SUPER;
1227 if (CLASS_INTERFACE (decl))
1228 access_flags |= ACC_INTERFACE;
1229 if (CLASS_ABSTRACT (decl))
1230 access_flags |= ACC_ABSTRACT;
1231 if (CLASS_STATIC (decl))
1232 access_flags |= ACC_STATIC;
1233 if (CLASS_PRIVATE (decl))
1234 access_flags |= ACC_PRIVATE;
1235 if (CLASS_PROTECTED (decl))
1236 access_flags |= ACC_PROTECTED;
1237 if (CLASS_STRICTFP (decl))
1238 access_flags |= ACC_STRICT;
1239 if (CLASS_ENUM (decl))
1240 access_flags |= ACC_ENUM;
1241 if (CLASS_SYNTHETIC (decl))
1242 access_flags |= ACC_SYNTHETIC;
1243 if (CLASS_ANNOTATION (decl))
1244 access_flags |= ACC_ANNOTATION;
1245 return access_flags;
1247 if (TREE_CODE (decl) == FUNCTION_DECL)
1249 if (METHOD_PUBLIC (decl))
1250 access_flags |= ACC_PUBLIC;
1251 if (METHOD_PRIVATE (decl))
1252 access_flags |= ACC_PRIVATE;
1253 if (METHOD_PROTECTED (decl))
1254 access_flags |= ACC_PROTECTED;
1255 if (METHOD_STATIC (decl))
1256 access_flags |= ACC_STATIC;
1257 if (METHOD_FINAL (decl))
1258 access_flags |= ACC_FINAL;
1259 if (METHOD_SYNCHRONIZED (decl))
1260 access_flags |= ACC_SYNCHRONIZED;
1261 if (METHOD_NATIVE (decl))
1262 access_flags |= ACC_NATIVE;
1263 if (METHOD_ABSTRACT (decl))
1264 access_flags |= ACC_ABSTRACT;
1265 if (METHOD_STRICTFP (decl))
1266 access_flags |= ACC_STRICT;
1267 if (METHOD_INVISIBLE (decl))
1268 access_flags |= ACC_INVISIBLE;
1269 if (DECL_ARTIFICIAL (decl))
1270 access_flags |= ACC_SYNTHETIC;
1271 if (METHOD_BRIDGE (decl))
1272 access_flags |= ACC_BRIDGE;
1273 if (METHOD_VARARGS (decl))
1274 access_flags |= ACC_VARARGS;
1275 return access_flags;
1280 static GTY (()) int alias_labelno = 0;
1282 /* Create a private alias for METHOD. Using this alias instead of the method
1283 decl ensures that ncode entries in the method table point to the real function
1284 at runtime, not a PLT entry. */
1287 make_local_function_alias (tree method)
1289 #ifdef ASM_OUTPUT_DEF
1292 const char *method_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method));
1293 char *name = alloca (strlen (method_name) + 2);
1294 char *buf = alloca (strlen (method_name) + 128);
1296 /* Only create aliases for local functions. */
1297 if (DECL_EXTERNAL (method))
1300 /* Prefix method_name with 'L' for the alias label. */
1302 strcpy (name + 1, method_name);
1304 ASM_GENERATE_INTERNAL_LABEL (buf, name, alias_labelno++);
1305 alias = build_decl (FUNCTION_DECL, get_identifier (buf),
1306 TREE_TYPE (method));
1307 DECL_CONTEXT (alias) = NULL;
1308 TREE_READONLY (alias) = TREE_READONLY (method);
1309 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (method);
1310 TREE_PUBLIC (alias) = 0;
1311 DECL_EXTERNAL (alias) = 0;
1312 DECL_ARTIFICIAL (alias) = 1;
1313 DECL_INLINE (alias) = 0;
1314 DECL_INITIAL (alias) = error_mark_node;
1315 TREE_ADDRESSABLE (alias) = 1;
1316 TREE_USED (alias) = 1;
1317 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
1318 if (!flag_syntax_only)
1319 assemble_alias (alias, DECL_ASSEMBLER_NAME (method));
1326 /** Make reflection data (_Jv_Field) for field FDECL. */
1329 make_field_value (tree fdecl)
1333 tree type = TREE_TYPE (fdecl);
1334 int resolved = is_compiled_class (type) && ! flag_indirect_dispatch;
1336 START_RECORD_CONSTRUCTOR (finit, field_type_node);
1337 PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl)));
1339 type = build_class_ref (type);
1342 tree signature = build_java_signature (type);
1344 type = build_utf8_ref (unmangle_classname
1345 (IDENTIFIER_POINTER (signature),
1346 IDENTIFIER_LENGTH (signature)));
1348 PUSH_FIELD_VALUE (finit, "type", type);
1350 flags = get_access_flags_from_decl (fdecl);
1352 flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1354 PUSH_FIELD_VALUE (finit, "accflags", build_int_cst (NULL_TREE, flags));
1355 PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
1358 tree field_address = integer_zero_node;
1359 if ((DECL_INITIAL (fdecl) || ! flag_indirect_classes)
1360 && FIELD_STATIC (fdecl))
1361 field_address = build_address_of (fdecl);
1365 build_constructor_from_list (field_info_union_node,
1367 ((FIELD_STATIC (fdecl)
1368 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
1369 : TYPE_FIELDS (field_info_union_node)),
1370 (FIELD_STATIC (fdecl)
1372 : byte_position (fdecl)))));
1375 FINISH_RECORD_CONSTRUCTOR (finit);
1379 /** Make reflection data (_Jv_Method) for method MDECL. */
1382 make_method_value (tree mdecl)
1384 static int method_name_count = 0;
1389 #define ACC_TRANSLATED 0x4000
1390 int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
1392 class_decl = DECL_CONTEXT (mdecl);
1393 /* For interfaces, the index field contains the dispatch index. */
1394 if (CLASS_INTERFACE (TYPE_NAME (class_decl)))
1395 index = build_int_cst (NULL_TREE,
1396 get_interface_method_index (mdecl, class_decl));
1397 else if (!flag_indirect_dispatch && get_method_index (mdecl) != NULL_TREE)
1398 index = get_method_index (mdecl);
1400 index = integer_minus_one_node;
1402 code = null_pointer_node;
1403 if (METHOD_ABSTRACT (mdecl))
1404 code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1405 soft_abstractmethod_node);
1407 code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1408 make_local_function_alias (mdecl));
1409 START_RECORD_CONSTRUCTOR (minit, method_type_node);
1410 PUSH_FIELD_VALUE (minit, "name",
1411 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
1412 init_identifier_node
1413 : DECL_NAME (mdecl)));
1415 tree signature = build_java_signature (TREE_TYPE (mdecl));
1416 PUSH_FIELD_VALUE (minit, "signature",
1419 (IDENTIFIER_POINTER(signature),
1420 IDENTIFIER_LENGTH(signature)))));
1422 PUSH_FIELD_VALUE (minit, "accflags", build_int_cst (NULL_TREE, accflags));
1423 PUSH_FIELD_VALUE (minit, "index", index);
1424 PUSH_FIELD_VALUE (minit, "ncode", code);
1427 /* Compute the `throws' information for the method. */
1428 tree table = null_pointer_node;
1429 if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE)
1431 int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl));
1432 tree iter, type, array;
1435 table = tree_cons (NULL_TREE, table, NULL_TREE);
1436 for (iter = DECL_FUNCTION_THROWS (mdecl);
1438 iter = TREE_CHAIN (iter))
1440 tree sig = DECL_NAME (TYPE_NAME (TREE_VALUE (iter)));
1442 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
1443 IDENTIFIER_LENGTH (sig)));
1444 table = tree_cons (NULL_TREE, utf8, table);
1446 type = build_prim_array_type (ptr_type_node, length);
1447 table = build_constructor_from_list (type, table);
1448 /* Compute something unique enough. */
1449 sprintf (buf, "_methods%d", method_name_count++);
1450 array = build_decl (VAR_DECL, get_identifier (buf), type);
1451 DECL_INITIAL (array) = table;
1452 TREE_STATIC (array) = 1;
1453 DECL_ARTIFICIAL (array) = 1;
1454 DECL_IGNORED_P (array) = 1;
1455 rest_of_decl_compilation (array, 1, 0);
1457 table = build1 (ADDR_EXPR, ptr_type_node, array);
1460 PUSH_FIELD_VALUE (minit, "throws", table);
1463 FINISH_RECORD_CONSTRUCTOR (minit);
1468 get_dispatch_vector (tree type)
1470 tree vtable = TYPE_VTABLE (type);
1472 if (vtable == NULL_TREE)
1476 tree super = CLASSTYPE_SUPER (type);
1477 HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1478 vtable = make_tree_vec (nvirtuals);
1479 TYPE_VTABLE (type) = vtable;
1480 if (super != NULL_TREE)
1482 tree super_vtable = get_dispatch_vector (super);
1484 for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1485 TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1488 for (method = TYPE_METHODS (type); method != NULL_TREE;
1489 method = TREE_CHAIN (method))
1491 tree method_index = get_method_index (method);
1492 if (method_index != NULL_TREE
1493 && host_integerp (method_index, 0))
1494 TREE_VEC_ELT (vtable, tree_low_cst (method_index, 0)) = method;
1502 get_dispatch_table (tree type, tree this_class_addr)
1504 int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1505 tree vtable = get_dispatch_vector (type);
1507 tree list = NULL_TREE;
1508 int nvirtuals = TREE_VEC_LENGTH (vtable);
1512 for (i = nvirtuals; --i >= 0; )
1514 tree method = TREE_VEC_ELT (vtable, i);
1515 if (METHOD_ABSTRACT (method))
1518 warning (0, "%Jabstract method in non-abstract class", method);
1520 if (TARGET_VTABLE_USES_DESCRIPTORS)
1521 for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1522 list = tree_cons (NULL_TREE, null_pointer_node, list);
1524 list = tree_cons (NULL_TREE, null_pointer_node, list);
1528 if (TARGET_VTABLE_USES_DESCRIPTORS)
1529 for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1531 tree fdesc = build2 (FDESC_EXPR, nativecode_ptr_type_node,
1532 method, build_int_cst (NULL_TREE, j));
1533 TREE_CONSTANT (fdesc) = 1;
1534 TREE_INVARIANT (fdesc) = 1;
1535 list = tree_cons (NULL_TREE, fdesc, list);
1538 list = tree_cons (NULL_TREE,
1539 build1 (ADDR_EXPR, nativecode_ptr_type_node,
1545 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1546 using the Boehm GC we sometimes stash a GC type descriptor
1547 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1548 the emitted byte count during the output to the assembly file. */
1549 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1550 fake "function descriptor". It's first word is the is the class
1551 pointer, and subsequent words (usually one) contain the GC descriptor.
1552 In all other cases, we reserve two extra vtable slots. */
1553 gc_descr = get_boehm_type_descriptor (type);
1554 list = tree_cons (NULL_TREE, gc_descr, list);
1555 for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
1556 list = tree_cons (NULL_TREE, gc_descr, list);
1557 list = tree_cons (NULL_TREE, this_class_addr, list);
1559 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1560 list = tree_cons (NULL_TREE, null_pointer_node, list);
1561 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1562 list = tree_cons (integer_zero_node, null_pointer_node, list);
1564 arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
1565 if (TARGET_VTABLE_USES_DESCRIPTORS)
1566 arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
1568 return build_constructor_from_list
1569 (build_prim_array_type (nativecode_ptr_type_node,
1574 /* Set the method_index for a method decl. */
1576 set_method_index (tree decl, tree method_index)
1578 if (method_index != NULL_TREE)
1580 /* method_index is null if we're using indirect dispatch. */
1581 method_index = fold (convert (sizetype, method_index));
1583 if (TARGET_VTABLE_USES_DESCRIPTORS)
1584 /* Add one to skip bogus descriptor for class and GC descriptor. */
1585 method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
1587 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1589 method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1592 DECL_VINDEX (decl) = method_index;
1595 /* Get the method_index for a method decl. */
1597 get_method_index (tree decl)
1599 tree method_index = DECL_VINDEX (decl);
1604 if (TARGET_VTABLE_USES_DESCRIPTORS)
1605 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1606 method_index = size_binop (MINUS_EXPR, method_index, size_int (1));
1608 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1609 method_index = size_binop (MINUS_EXPR, method_index, size_int (2));
1611 return method_index;
1615 supers_all_compiled (tree type)
1617 while (type != NULL_TREE)
1619 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
1621 type = CLASSTYPE_SUPER (type);
1627 make_class_data (tree type)
1629 tree decl, cons, temp;
1630 tree field, fields_decl;
1631 tree static_fields = NULL_TREE;
1632 tree instance_fields = NULL_TREE;
1633 HOST_WIDE_INT static_field_count = 0;
1634 HOST_WIDE_INT instance_field_count = 0;
1635 HOST_WIDE_INT field_count;
1636 tree field_array_type;
1638 tree methods = NULL_TREE;
1639 tree dtable_decl = NULL_TREE;
1640 HOST_WIDE_INT method_count = 0;
1641 tree method_array_type;
1644 tree this_class_addr;
1645 tree constant_pool_constructor;
1646 tree interfaces = null_pointer_node;
1647 int interface_len = 0;
1648 int uses_jv_markobj = 0;
1649 tree type_decl = TYPE_NAME (type);
1650 tree id_main = get_identifier("main");
1651 tree id_class = get_identifier("java.lang.Class");
1652 /** Offset from start of virtual function table declaration
1653 to where objects actually point at, following new g++ ABI. */
1654 tree dtable_start_offset = build_int_cst (NULL_TREE,
1655 2 * POINTER_SIZE / BITS_PER_UNIT);
1656 VEC(int, heap) *field_indexes;
1657 tree first_real_field;
1659 this_class_addr = build_static_class_ref (type);
1660 decl = TREE_OPERAND (this_class_addr, 0);
1662 if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
1663 && !flag_indirect_dispatch)
1665 tree dtable = get_dispatch_table (type, this_class_addr);
1666 uses_jv_markobj = uses_jv_markobj_p (dtable);
1667 if (type == class_type_node && class_dtable_decl != NULL_TREE)
1669 /* We've already created some other class, and consequently
1670 we made class_dtable_decl. Now we just want to fill it
1672 dtable_decl = class_dtable_decl;
1676 dtable_decl = build_dtable_decl (type);
1677 TREE_STATIC (dtable_decl) = 1;
1678 DECL_ARTIFICIAL (dtable_decl) = 1;
1679 DECL_IGNORED_P (dtable_decl) = 1;
1682 TREE_PUBLIC (dtable_decl) = 1;
1683 DECL_INITIAL (dtable_decl) = dtable;
1684 if (! flag_indirect_classes)
1685 rest_of_decl_compilation (dtable_decl, 1, 0);
1686 /* Maybe we're compiling Class as the first class. If so, set
1687 class_dtable_decl to the decl we just made. */
1688 if (type == class_type_node && class_dtable_decl == NULL_TREE)
1689 class_dtable_decl = dtable_decl;
1692 /* Build Field array. */
1693 field = TYPE_FIELDS (type);
1694 while (field && DECL_ARTIFICIAL (field))
1695 field = TREE_CHAIN (field); /* Skip dummy fields. */
1696 if (field && DECL_NAME (field) == NULL_TREE)
1697 field = TREE_CHAIN (field); /* Skip dummy field for inherited data. */
1698 first_real_field = field;
1700 /* First count static and instance fields. */
1701 for ( ; field != NULL_TREE; field = TREE_CHAIN (field))
1703 if (! DECL_ARTIFICIAL (field))
1705 if (FIELD_STATIC (field))
1706 static_field_count++;
1707 else if (uses_jv_markobj || !flag_reduced_reflection)
1708 instance_field_count++;
1711 field_count = static_field_count + instance_field_count;
1712 field_indexes = VEC_alloc (int, heap, field_count);
1714 /* gcj sorts fields so that static fields come first, followed by
1715 instance fields. Unfortunately, by the time this takes place we
1716 have already generated the reflection_data for this class, and
1717 that data contains indexes into the fields. So, we generate a
1718 permutation that maps each original field index to its final
1719 position. Then we pass this permutation to
1720 rewrite_reflection_indexes(), which fixes up the reflection
1724 int static_count = 0;
1725 int instance_count = static_field_count;
1728 for (i = 0, field = first_real_field;
1730 field = TREE_CHAIN (field), i++)
1732 if (! DECL_ARTIFICIAL (field))
1735 if (FIELD_STATIC (field))
1736 field_index = static_count++;
1737 else if (uses_jv_markobj || !flag_reduced_reflection)
1738 field_index = instance_count++;
1739 VEC_quick_push (int, field_indexes, field_index);
1744 for (field = first_real_field; field != NULL_TREE;
1745 field = TREE_CHAIN (field))
1747 if (! DECL_ARTIFICIAL (field))
1749 if (FIELD_STATIC (field))
1751 /* We must always create reflection data for static fields
1752 as it is used in the creation of the field itself. */
1753 tree init = make_field_value (field);
1754 tree initial = DECL_INITIAL (field);
1755 static_fields = tree_cons (NULL_TREE, init, static_fields);
1756 /* If the initial value is a string constant,
1757 prevent output_constant from trying to assemble the value. */
1758 if (initial != NULL_TREE
1759 && TREE_TYPE (initial) == string_ptr_type_node)
1760 DECL_INITIAL (field) = NULL_TREE;
1761 rest_of_decl_compilation (field, 1, 1);
1762 DECL_INITIAL (field) = initial;
1764 else if (uses_jv_markobj || !flag_reduced_reflection)
1766 tree init = make_field_value (field);
1767 instance_fields = tree_cons (NULL_TREE, init, instance_fields);
1772 if (field_count > 0)
1774 static_fields = nreverse (static_fields);
1775 instance_fields = nreverse (instance_fields);
1776 static_fields = chainon (static_fields, instance_fields);
1777 field_array_type = build_prim_array_type (field_type_node, field_count);
1778 fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
1780 DECL_INITIAL (fields_decl) = build_constructor_from_list
1781 (field_array_type, static_fields);
1782 TREE_STATIC (fields_decl) = 1;
1783 DECL_ARTIFICIAL (fields_decl) = 1;
1784 DECL_IGNORED_P (fields_decl) = 1;
1785 rest_of_decl_compilation (fields_decl, 1, 0);
1788 fields_decl = NULL_TREE;
1790 /* Build Method array. */
1791 for (method = TYPE_METHODS (type);
1792 method != NULL_TREE; method = TREE_CHAIN (method))
1795 if (METHOD_PRIVATE (method)
1796 && ! flag_keep_inline_functions
1799 /* Even if we have a decl, we don't necessarily have the code.
1800 This can happen if we inherit a method from a superclass for
1801 which we don't have a .class file. */
1802 if (METHOD_DUMMY (method))
1805 /* Generate method reflection data if:
1807 - !flag_reduced_reflection.
1809 - <clinit> -- The runtime uses reflection to initialize the
1812 - Any method in class java.lang.Class -- Class.forName() and
1813 perhaps other things require it.
1815 - class$ -- It does not work if reflection data missing.
1817 - main -- Reflection is used to find main(String[]) methods.
1819 - public not static -- It is potentially part of an
1820 interface. The runtime uses reflection data to build
1821 interface dispatch tables. */
1822 if (!flag_reduced_reflection
1823 || DECL_CLINIT_P (method)
1824 || DECL_NAME (type_decl) == id_class
1825 || DECL_NAME (method) == id_main
1826 || (METHOD_PUBLIC (method) && !METHOD_STATIC (method))
1827 || TYPE_DOT_CLASS (type) == method)
1829 init = make_method_value (method);
1831 methods = tree_cons (NULL_TREE, init, methods);
1834 method_array_type = build_prim_array_type (method_type_node, method_count);
1835 methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
1837 DECL_INITIAL (methods_decl) = build_constructor_from_list
1838 (method_array_type, nreverse (methods));
1839 TREE_STATIC (methods_decl) = 1;
1840 DECL_ARTIFICIAL (methods_decl) = 1;
1841 DECL_IGNORED_P (methods_decl) = 1;
1842 rest_of_decl_compilation (methods_decl, 1, 0);
1844 if (class_dtable_decl == NULL_TREE)
1846 class_dtable_decl = build_dtable_decl (class_type_node);
1847 TREE_STATIC (class_dtable_decl) = 1;
1848 DECL_ARTIFICIAL (class_dtable_decl) = 1;
1849 DECL_IGNORED_P (class_dtable_decl) = 1;
1850 if (is_compiled_class (class_type_node) != 2)
1852 DECL_EXTERNAL (class_dtable_decl) = 1;
1853 rest_of_decl_compilation (class_dtable_decl, 1, 0);
1857 super = CLASSTYPE_SUPER (type);
1858 if (super == NULL_TREE)
1859 super = null_pointer_node;
1860 else if (! flag_indirect_dispatch
1861 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
1862 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
1863 super = build_class_ref (super);
1866 int super_index = alloc_class_constant (super);
1867 super = build_int_cst (ptr_type_node, super_index);
1870 /* Build and emit the array of implemented interfaces. */
1871 if (type != object_type_node)
1872 interface_len = BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) - 1;
1874 if (interface_len > 0)
1876 tree init = NULL_TREE;
1878 tree interface_array_type, idecl;
1879 interface_array_type
1880 = build_prim_array_type (class_ptr_type, interface_len);
1881 idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type),
1882 interface_array_type);
1884 for (i = interface_len; i > 0; i--)
1886 tree child = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
1887 tree iclass = BINFO_TYPE (child);
1889 if (! flag_indirect_dispatch
1891 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))))
1892 index = build_class_ref (iclass);
1895 int int_index = alloc_class_constant (iclass);
1896 index = build_int_cst (ptr_type_node, int_index);
1898 init = tree_cons (NULL_TREE, index, init);
1900 DECL_INITIAL (idecl) = build_constructor_from_list (interface_array_type,
1902 TREE_STATIC (idecl) = 1;
1903 DECL_ARTIFICIAL (idecl) = 1;
1904 DECL_IGNORED_P (idecl) = 1;
1905 interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
1906 rest_of_decl_compilation (idecl, 1, 0);
1909 constant_pool_constructor = build_constants_constructor ();
1911 if (flag_indirect_dispatch)
1913 TYPE_OTABLE_DECL (type)
1915 (DECL_NAME (TYPE_OTABLE_DECL (type)),
1916 TYPE_OTABLE_DECL (type), TYPE_OTABLE_METHODS (type),
1917 TYPE_OTABLE_SYMS_DECL (type), integer_type_node, 1);
1919 TYPE_ATABLE_DECL (type)
1921 (DECL_NAME (TYPE_ATABLE_DECL (type)),
1922 TYPE_ATABLE_DECL (type), TYPE_ATABLE_METHODS (type),
1923 TYPE_ATABLE_SYMS_DECL (type), ptr_type_node, 1);
1925 TYPE_ITABLE_DECL (type)
1927 (DECL_NAME (TYPE_ITABLE_DECL (type)),
1928 TYPE_ITABLE_DECL (type), TYPE_ITABLE_METHODS (type),
1929 TYPE_ITABLE_SYMS_DECL (type), ptr_type_node, 2);
1932 TYPE_CTABLE_DECL (type) = emit_catch_table (type);
1934 START_RECORD_CONSTRUCTOR (temp, object_type_node);
1935 PUSH_FIELD_VALUE (temp, "vtable",
1936 (flag_indirect_classes
1938 : build2 (PLUS_EXPR, dtable_ptr_type,
1939 build1 (ADDR_EXPR, dtable_ptr_type,
1941 dtable_start_offset)));
1942 if (! flag_hash_synchronization)
1943 PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
1944 FINISH_RECORD_CONSTRUCTOR (temp);
1945 START_RECORD_CONSTRUCTOR (cons, class_type_node);
1946 PUSH_SUPER_VALUE (cons, temp);
1947 PUSH_FIELD_VALUE (cons, "next_or_version", gcj_abi_version);
1948 PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
1949 PUSH_FIELD_VALUE (cons, "accflags",
1950 build_int_cst (NULL_TREE,
1951 get_access_flags_from_decl (type_decl)));
1953 PUSH_FIELD_VALUE (cons, "superclass",
1954 CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
1955 PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
1956 PUSH_FIELD_VALUE (cons, "methods",
1957 methods_decl == NULL_TREE ? null_pointer_node
1958 : build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
1959 PUSH_FIELD_VALUE (cons, "method_count",
1960 build_int_cst (NULL_TREE, method_count));
1962 if (flag_indirect_dispatch)
1963 PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node);
1965 PUSH_FIELD_VALUE (cons, "vtable_method_count", TYPE_NVIRTUALS (type));
1967 PUSH_FIELD_VALUE (cons, "fields",
1968 fields_decl == NULL_TREE ? null_pointer_node
1969 : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
1970 /* If we're using the binary compatibility ABI we don't know the
1971 size until load time. */
1972 PUSH_FIELD_VALUE (cons, "size_in_bytes",
1973 (flag_indirect_dispatch
1974 ? integer_minus_one_node
1975 : size_in_bytes (type)));
1976 PUSH_FIELD_VALUE (cons, "field_count",
1977 build_int_cst (NULL_TREE, field_count));
1978 PUSH_FIELD_VALUE (cons, "static_field_count",
1979 build_int_cst (NULL_TREE, static_field_count));
1981 if (flag_indirect_dispatch)
1982 PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node);
1984 PUSH_FIELD_VALUE (cons, "vtable",
1985 dtable_decl == NULL_TREE ? null_pointer_node
1986 : build2 (PLUS_EXPR, dtable_ptr_type,
1987 build1 (ADDR_EXPR, dtable_ptr_type,
1989 dtable_start_offset));
1990 if (TYPE_OTABLE_METHODS (type) == NULL_TREE)
1992 PUSH_FIELD_VALUE (cons, "otable", null_pointer_node);
1993 PUSH_FIELD_VALUE (cons, "otable_syms", null_pointer_node);
1997 pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type));
1998 PUSH_FIELD_VALUE (cons, "otable",
1999 build1 (ADDR_EXPR, otable_ptr_type, TYPE_OTABLE_DECL (type)));
2000 PUSH_FIELD_VALUE (cons, "otable_syms",
2001 build1 (ADDR_EXPR, symbols_array_ptr_type,
2002 TYPE_OTABLE_SYMS_DECL (type)));
2003 TREE_CONSTANT (TYPE_OTABLE_DECL (type)) = 1;
2004 TREE_INVARIANT (TYPE_OTABLE_DECL (type)) = 1;
2006 if (TYPE_ATABLE_METHODS(type) == NULL_TREE)
2008 PUSH_FIELD_VALUE (cons, "atable", null_pointer_node);
2009 PUSH_FIELD_VALUE (cons, "atable_syms", null_pointer_node);
2013 pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type));
2014 PUSH_FIELD_VALUE (cons, "atable",
2015 build1 (ADDR_EXPR, atable_ptr_type, TYPE_ATABLE_DECL (type)));
2016 PUSH_FIELD_VALUE (cons, "atable_syms",
2017 build1 (ADDR_EXPR, symbols_array_ptr_type,
2018 TYPE_ATABLE_SYMS_DECL (type)));
2019 TREE_CONSTANT (TYPE_ATABLE_DECL (type)) = 1;
2020 TREE_INVARIANT (TYPE_ATABLE_DECL (type)) = 1;
2022 if (TYPE_ITABLE_METHODS(type) == NULL_TREE)
2024 PUSH_FIELD_VALUE (cons, "itable", null_pointer_node);
2025 PUSH_FIELD_VALUE (cons, "itable_syms", null_pointer_node);
2029 pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type));
2030 PUSH_FIELD_VALUE (cons, "itable",
2031 build1 (ADDR_EXPR, itable_ptr_type, TYPE_ITABLE_DECL (type)));
2032 PUSH_FIELD_VALUE (cons, "itable_syms",
2033 build1 (ADDR_EXPR, symbols_array_ptr_type,
2034 TYPE_ITABLE_SYMS_DECL (type)));
2035 TREE_CONSTANT (TYPE_ITABLE_DECL (type)) = 1;
2036 TREE_INVARIANT (TYPE_ITABLE_DECL (type)) = 1;
2039 PUSH_FIELD_VALUE (cons, "catch_classes",
2040 build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
2041 PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
2042 PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
2043 PUSH_FIELD_VALUE (cons, "interface_count",
2044 build_int_cst (NULL_TREE, interface_len));
2045 PUSH_FIELD_VALUE (cons, "state",
2046 convert (byte_type_node,
2047 build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
2049 PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
2050 PUSH_FIELD_VALUE (cons, "depth", integer_zero_node);
2051 PUSH_FIELD_VALUE (cons, "ancestors", null_pointer_node);
2052 PUSH_FIELD_VALUE (cons, "idt", null_pointer_node);
2053 PUSH_FIELD_VALUE (cons, "arrayclass", null_pointer_node);
2054 PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
2057 tree assertion_table_ref;
2058 if (TYPE_ASSERTIONS (type) == NULL)
2059 assertion_table_ref = null_pointer_node;
2061 assertion_table_ref = build1 (ADDR_EXPR,
2062 build_pointer_type (assertion_table_type),
2063 emit_assertion_table (type));
2065 PUSH_FIELD_VALUE (cons, "assertion_table", assertion_table_ref);
2068 PUSH_FIELD_VALUE (cons, "hack_signers", null_pointer_node);
2069 PUSH_FIELD_VALUE (cons, "chain", null_pointer_node);
2070 PUSH_FIELD_VALUE (cons, "aux_info", null_pointer_node);
2071 PUSH_FIELD_VALUE (cons, "engine", null_pointer_node);
2073 if (TYPE_REFLECTION_DATA (current_class))
2076 int count = TYPE_REFLECTION_DATASIZE (current_class);
2077 VEC (constructor_elt, gc) *v
2078 = VEC_alloc (constructor_elt, gc, count);
2079 unsigned char *data = TYPE_REFLECTION_DATA (current_class);
2080 tree max_index = build_int_cst (sizetype, count);
2081 tree index = build_index_type (max_index);
2082 tree type = build_array_type (unsigned_byte_type_node, index);
2085 static int reflection_data_count;
2087 sprintf (buf, "_reflection_data_%d", reflection_data_count++);
2088 array = build_decl (VAR_DECL, get_identifier (buf), type);
2090 rewrite_reflection_indexes (field_indexes);
2092 for (i = 0; i < count; i++)
2094 constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
2095 elt->index = build_int_cst (sizetype, i);
2096 elt->value = build_int_cstu (byte_type_node, data[i]);
2099 DECL_INITIAL (array) = build_constructor (type, v);
2100 TREE_STATIC (array) = 1;
2101 DECL_ARTIFICIAL (array) = 1;
2102 DECL_IGNORED_P (array) = 1;
2103 TREE_READONLY (array) = 1;
2104 TREE_CONSTANT (DECL_INITIAL (array)) = 1;
2105 rest_of_decl_compilation (array, 1, 0);
2107 PUSH_FIELD_VALUE (cons, "reflection_data", build_address_of (array));
2110 TYPE_REFLECTION_DATA (current_class) = NULL;
2113 PUSH_FIELD_VALUE (cons, "reflection_data", null_pointer_node);
2115 FINISH_RECORD_CONSTRUCTOR (cons);
2117 DECL_INITIAL (decl) = cons;
2119 /* Hash synchronization requires at least 64-bit alignment. */
2120 if (flag_hash_synchronization && POINTER_SIZE < 64)
2121 DECL_ALIGN (decl) = 64;
2123 if (flag_indirect_classes)
2125 TREE_READONLY (decl) = 1;
2126 TREE_CONSTANT (DECL_INITIAL (decl)) = 1;
2129 rest_of_decl_compilation (decl, 1, 0);
2132 tree classdollar_field = build_classdollar_field (type);
2133 if (!flag_indirect_classes)
2134 DECL_INITIAL (classdollar_field) = build_static_class_ref (type);
2135 rest_of_decl_compilation (classdollar_field, 1, 0);
2138 TYPE_OTABLE_DECL (type) = NULL_TREE;
2139 TYPE_ATABLE_DECL (type) = NULL_TREE;
2140 TYPE_CTABLE_DECL (type) = NULL_TREE;
2146 if (TYPE_VERIFY_METHOD (output_class))
2148 tree verify_method = TYPE_VERIFY_METHOD (output_class);
2149 DECL_SAVED_TREE (verify_method)
2150 = add_stmt_to_compound (DECL_SAVED_TREE (verify_method), void_type_node,
2151 build1 (RETURN_EXPR, void_type_node, NULL));
2152 java_genericize (verify_method);
2153 cgraph_finalize_function (verify_method, false);
2154 TYPE_ASSERTIONS (current_class) = NULL;
2157 java_expand_catch_classes (current_class);
2159 current_function_decl = NULL_TREE;
2160 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class)) = 0;
2161 make_class_data (current_class);
2163 rest_of_decl_compilation (TYPE_NAME (current_class), 1, 0);
2166 /* Return 2 if CLASS is compiled by this compilation job;
2167 return 1 if CLASS can otherwise be assumed to be compiled;
2168 return 0 if we cannot assume that CLASS is compiled.
2169 Returns 1 for primitive and 0 for array types. */
2171 is_compiled_class (tree class)
2174 if (TREE_CODE (class) == POINTER_TYPE)
2175 class = TREE_TYPE (class);
2176 if (TREE_CODE (class) != RECORD_TYPE) /* Primitive types are static. */
2178 if (TYPE_ARRAY_P (class))
2181 seen_in_zip = (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
2182 if (CLASS_FROM_CURRENTLY_COMPILED_P (class))
2184 /* The class was seen in the current ZIP file and will be
2185 available as a compiled class in the future but may not have
2186 been loaded already. Load it if necessary. This prevent
2187 build_class_ref () from crashing. */
2189 if (seen_in_zip && !CLASS_LOADED_P (class) && (class != current_class))
2190 load_class (class, 1);
2192 /* We return 2 for class seen in ZIP and class from files
2193 belonging to the same compilation unit */
2197 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
2199 if (!CLASS_LOADED_P (class))
2201 if (CLASS_FROM_SOURCE_P (class))
2202 safe_layout_class (class);
2203 else if (class != current_class)
2204 load_class (class, 1);
2212 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2215 build_dtable_decl (tree type)
2219 /* We need to build a new dtable type so that its size is uniquely
2220 computed when we're dealing with the class for real and not just
2221 faking it (like java.lang.Class during the initialization of the
2222 compiler.) We know we're not faking a class when CURRENT_CLASS is
2224 if (current_class == type)
2226 tree dummy = NULL_TREE;
2229 dtype = make_node (RECORD_TYPE);
2231 PUSH_FIELD (dtype, dummy, "top_offset", ptr_type_node);
2232 PUSH_FIELD (dtype, dummy, "type_info", ptr_type_node);
2234 PUSH_FIELD (dtype, dummy, "class", class_ptr_type);
2235 for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2237 tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2238 TREE_CHAIN (dummy) = tmp_field;
2239 DECL_CONTEXT (tmp_field) = dtype;
2240 DECL_ARTIFICIAL (tmp_field) = 1;
2244 PUSH_FIELD (dtype, dummy, "gc_descr", ptr_type_node);
2245 for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2247 tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2248 TREE_CHAIN (dummy) = tmp_field;
2249 DECL_CONTEXT (tmp_field) = dtype;
2250 DECL_ARTIFICIAL (tmp_field) = 1;
2254 n = TREE_VEC_LENGTH (get_dispatch_vector (type));
2255 if (TARGET_VTABLE_USES_DESCRIPTORS)
2256 n *= TARGET_VTABLE_USES_DESCRIPTORS;
2258 PUSH_FIELD (dtype, dummy, "methods",
2259 build_prim_array_type (nativecode_ptr_type_node, n));
2260 layout_type (dtype);
2263 dtype = dtable_type;
2265 decl = build_decl (VAR_DECL, get_identifier ("vt$"), dtype);
2266 DECL_CONTEXT (decl) = type;
2267 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2268 DECL_VTABLE_P (decl) = 1;
2273 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2274 fields inherited from SUPER_CLASS. */
2277 push_super_field (tree this_class, tree super_class)
2280 /* Don't insert the field if we're just re-laying the class out. */
2281 if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
2283 base_decl = build_decl (FIELD_DECL, NULL_TREE, super_class);
2284 DECL_IGNORED_P (base_decl) = 1;
2285 TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
2286 TYPE_FIELDS (this_class) = base_decl;
2287 DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
2288 DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
2291 /* Handle the different manners we may have to lay out a super class. */
2294 maybe_layout_super_class (tree super_class, tree this_class ATTRIBUTE_UNUSED)
2298 else if (TREE_CODE (super_class) == RECORD_TYPE)
2300 if (!CLASS_LOADED_P (super_class) && CLASS_FROM_SOURCE_P (super_class))
2301 safe_layout_class (super_class);
2302 if (!CLASS_LOADED_P (super_class))
2303 load_class (super_class, 1);
2305 /* We might have to layout the class before its dependency on
2306 the super class gets resolved by java_complete_class */
2307 else if (TREE_CODE (super_class) == POINTER_TYPE)
2309 if (TREE_TYPE (super_class) != NULL_TREE)
2310 super_class = TREE_TYPE (super_class);
2314 if (!TYPE_SIZE (super_class))
2315 safe_layout_class (super_class);
2320 /* safe_layout_class just makes sure that we can load a class without
2321 disrupting the current_class, input_file, input_line, etc, information
2322 about the class processed currently. */
2325 safe_layout_class (tree class)
2327 tree save_current_class = current_class;
2328 location_t save_location = input_location;
2330 layout_class (class);
2332 current_class = save_current_class;
2333 input_location = save_location;
2337 layout_class (tree this_class)
2339 tree super_class = CLASSTYPE_SUPER (this_class);
2341 class_list = tree_cons (this_class, NULL_TREE, class_list);
2342 if (CLASS_BEING_LAIDOUT (this_class))
2348 sprintf (buffer, " with '%s'",
2349 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
2350 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2352 for (current = TREE_CHAIN (class_list); current;
2353 current = TREE_CHAIN (current))
2355 tree decl = TYPE_NAME (TREE_PURPOSE (current));
2356 sprintf (buffer, "\n which inherits from '%s' (%s:%d)",
2357 IDENTIFIER_POINTER (DECL_NAME (decl)),
2358 DECL_SOURCE_FILE (decl),
2359 DECL_SOURCE_LINE (decl));
2360 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2362 obstack_1grow (&temporary_obstack, '\0');
2363 report = obstack_finish (&temporary_obstack);
2364 cyclic_inheritance_report = ggc_strdup (report);
2365 obstack_free (&temporary_obstack, report);
2366 TYPE_SIZE (this_class) = error_mark_node;
2369 CLASS_BEING_LAIDOUT (this_class) = 1;
2371 if (super_class && !CLASS_BEING_LAIDOUT (super_class))
2373 tree maybe_super_class
2374 = maybe_layout_super_class (super_class, this_class);
2375 if (maybe_super_class == NULL
2376 || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
2378 TYPE_SIZE (this_class) = error_mark_node;
2379 CLASS_BEING_LAIDOUT (this_class) = 0;
2380 class_list = TREE_CHAIN (class_list);
2383 if (TYPE_SIZE (this_class) == NULL_TREE)
2384 push_super_field (this_class, maybe_super_class);
2387 layout_type (this_class);
2389 /* Also recursively load/layout any superinterfaces, but only if
2390 class was loaded from bytecode. The source parser will take care
2392 if (!CLASS_FROM_SOURCE_P (this_class))
2395 if (TYPE_BINFO (this_class))
2397 for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class)) - 1; i > 0; i--)
2399 tree binfo = BINFO_BASE_BINFO (TYPE_BINFO (this_class), i);
2400 tree super_interface = BINFO_TYPE (binfo);
2401 tree maybe_super_interface
2402 = maybe_layout_super_class (super_interface, NULL_TREE);
2403 if (maybe_super_interface == NULL
2404 || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
2406 TYPE_SIZE (this_class) = error_mark_node;
2407 CLASS_BEING_LAIDOUT (this_class) = 0;
2408 class_list = TREE_CHAIN (class_list);
2415 /* Convert the size back to an SI integer value. */
2416 TYPE_SIZE_UNIT (this_class) =
2417 fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
2419 CLASS_BEING_LAIDOUT (this_class) = 0;
2420 class_list = TREE_CHAIN (class_list);
2424 add_miranda_methods (tree base_class, tree search_class)
2427 tree binfo, base_binfo;
2429 if (!CLASS_PARSED_P (search_class))
2430 load_class (search_class, 1);
2432 for (binfo = TYPE_BINFO (search_class), i = 1;
2433 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2436 tree elt = BINFO_TYPE (base_binfo);
2438 /* FIXME: This is totally bogus. We should not be handling
2439 Miranda methods at all if we're using the BC ABI. */
2440 if (TYPE_DUMMY (elt))
2443 /* Ensure that interface methods are seen in declared order. */
2444 if (!CLASS_LOADED_P (elt))
2445 load_class (elt, 1);
2446 layout_class_methods (elt);
2448 /* All base classes will have been laid out at this point, so the order
2449 will be correct. This code must match similar layout code in the
2451 for (method_decl = TYPE_METHODS (elt);
2452 method_decl; method_decl = TREE_CHAIN (method_decl))
2456 /* An interface can have <clinit>. */
2457 if (ID_CLINIT_P (DECL_NAME (method_decl)))
2460 sig = build_java_argument_signature (TREE_TYPE (method_decl));
2461 override = lookup_argument_method (base_class,
2462 DECL_NAME (method_decl), sig);
2463 if (override == NULL_TREE)
2465 /* Found a Miranda method. Add it. */
2467 sig = build_java_signature (TREE_TYPE (method_decl));
2469 = add_method (base_class,
2470 get_access_flags_from_decl (method_decl),
2471 DECL_NAME (method_decl), sig);
2472 METHOD_INVISIBLE (new_method) = 1;
2476 /* Try superinterfaces. */
2477 add_miranda_methods (base_class, elt);
2482 layout_class_methods (tree this_class)
2484 tree method_decl, dtable_count;
2485 tree super_class, type_name;
2487 if (TYPE_NVIRTUALS (this_class))
2490 super_class = CLASSTYPE_SUPER (this_class);
2494 super_class = maybe_layout_super_class (super_class, this_class);
2495 if (!TYPE_NVIRTUALS (super_class))
2496 layout_class_methods (super_class);
2497 dtable_count = TYPE_NVIRTUALS (super_class);
2500 dtable_count = integer_zero_node;
2502 type_name = TYPE_NAME (this_class);
2503 if (!flag_indirect_dispatch
2504 && (CLASS_ABSTRACT (type_name) || CLASS_INTERFACE (type_name)))
2506 /* An abstract class can have methods which are declared only in
2507 an implemented interface. These are called "Miranda
2508 methods". We make a dummy method entry for such methods
2510 add_miranda_methods (this_class, this_class);
2513 TYPE_METHODS (this_class) = nreverse (TYPE_METHODS (this_class));
2515 for (method_decl = TYPE_METHODS (this_class);
2516 method_decl; method_decl = TREE_CHAIN (method_decl))
2517 dtable_count = layout_class_method (this_class, super_class,
2518 method_decl, dtable_count);
2520 TYPE_NVIRTUALS (this_class) = dtable_count;
2523 /* Return the index of METHOD in INTERFACE. This index begins at 1
2524 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2526 get_interface_method_index (tree method, tree interface)
2531 for (meth = TYPE_METHODS (interface); ; meth = TREE_CHAIN (meth))
2535 /* We don't want to put <clinit> into the interface table. */
2536 if (! ID_CLINIT_P (DECL_NAME (meth)))
2538 gcc_assert (meth != NULL_TREE);
2542 /* Lay METHOD_DECL out, returning a possibly new value of
2543 DTABLE_COUNT. Also mangle the method's name. */
2546 layout_class_method (tree this_class, tree super_class,
2547 tree method_decl, tree dtable_count)
2549 tree method_name = DECL_NAME (method_decl);
2551 TREE_PUBLIC (method_decl) = 1;
2553 /* Considered external unless it is being compiled into this object
2554 file, or it was already flagged as external. */
2555 if (!DECL_EXTERNAL (method_decl))
2556 DECL_EXTERNAL (method_decl) = ((is_compiled_class (this_class) != 2)
2557 || METHOD_NATIVE (method_decl));
2559 if (ID_INIT_P (method_name))
2561 const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
2563 for (ptr = p; *ptr; )
2568 DECL_CONSTRUCTOR_P (method_decl) = 1;
2569 build_java_signature (TREE_TYPE (method_decl));
2571 else if (! METHOD_STATIC (method_decl))
2574 build_java_signature (TREE_TYPE (method_decl));
2575 bool method_override = false;
2576 tree super_method = lookup_java_method (super_class, method_name,
2578 if (super_method != NULL_TREE
2579 && ! METHOD_DUMMY (super_method))
2581 method_override = true;
2582 if (! METHOD_PUBLIC (super_method) &&
2583 ! METHOD_PROTECTED (super_method))
2585 /* Don't override private method, or default-access method in
2587 if (METHOD_PRIVATE (super_method) ||
2588 ! in_same_package (TYPE_NAME (this_class),
2589 TYPE_NAME (super_class)))
2590 method_override = false;
2593 if (method_override)
2595 tree method_index = get_method_index (super_method);
2596 set_method_index (method_decl, method_index);
2597 if (method_index == NULL_TREE
2598 && ! flag_indirect_dispatch
2599 && !CLASS_FROM_SOURCE_P (this_class)
2600 && ! DECL_ARTIFICIAL (super_method))
2601 error ("non-static method %q+D overrides static method",
2604 else if (this_class == object_type_node
2605 && (METHOD_FINAL (method_decl)
2606 || METHOD_PRIVATE (method_decl)))
2608 /* We don't generate vtable entries for final Object
2609 methods. This is simply to save space, since every
2610 object would otherwise have to define them. */
2612 else if (! METHOD_PRIVATE (method_decl)
2615 /* We generate vtable entries for final methods because they
2616 may one day be changed to non-final. */
2617 set_method_index (method_decl, dtable_count);
2618 dtable_count = fold_build2 (PLUS_EXPR, integer_type_node,
2619 dtable_count, integer_one_node);
2623 return dtable_count;
2627 register_class (void)
2631 if (!registered_class)
2632 registered_class = VEC_alloc (tree, gc, 8);
2634 if (flag_indirect_classes)
2635 node = current_class;
2637 node = TREE_OPERAND (build_class_ref (current_class), 0);
2638 VEC_safe_push (tree, gc, registered_class, node);
2641 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2642 all the classes we have emitted. */
2645 emit_indirect_register_classes (tree *list_p)
2647 tree klass, t, register_class_fn;
2650 tree init = NULL_TREE;
2651 int size = VEC_length (tree, registered_class) * 2 + 1;
2652 tree class_array_type
2653 = build_prim_array_type (ptr_type_node, size);
2654 tree cdecl = build_decl (VAR_DECL, get_identifier ("_Jv_CLS"),
2656 tree reg_class_list;
2657 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2659 init = tree_cons (NULL_TREE,
2660 fold_convert (ptr_type_node,
2661 build_static_class_ref (klass)), init);
2664 fold_convert (ptr_type_node,
2665 build_address_of (build_classdollar_field (klass))),
2668 init = tree_cons (NULL_TREE, integer_zero_node, init);
2669 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type,
2671 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2672 TREE_STATIC (cdecl) = 1;
2673 DECL_ARTIFICIAL (cdecl) = 1;
2674 DECL_IGNORED_P (cdecl) = 1;
2675 TREE_READONLY (cdecl) = 1;
2676 TREE_CONSTANT (cdecl) = 1;
2677 rest_of_decl_compilation (cdecl, 1, 0);
2678 reg_class_list = fold_convert (ptr_type_node, build_address_of (cdecl));
2680 t = build_function_type_list (void_type_node,
2681 build_pointer_type (ptr_type_node), NULL);
2682 t = build_decl (FUNCTION_DECL,
2683 get_identifier ("_Jv_RegisterNewClasses"), t);
2684 TREE_PUBLIC (t) = 1;
2685 DECL_EXTERNAL (t) = 1;
2686 register_class_fn = t;
2687 t = tree_cons (NULL, reg_class_list, NULL);
2688 t = build_function_call_expr (register_class_fn, t);
2689 append_to_statement_list (t, list_p);
2693 /* Emit something to register classes at start-up time.
2695 The preferred mechanism is through the .jcr section, which contain
2696 a list of pointers to classes which get registered during constructor
2699 The fallback mechanism is to add statements to *LIST_P to call
2700 _Jv_RegisterClass for each class in this file. These statements will
2701 be added to a static constructor function for this translation unit. */
2704 emit_register_classes (tree *list_p)
2706 if (registered_class == NULL)
2709 if (flag_indirect_classes)
2711 emit_indirect_register_classes (list_p);
2715 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2716 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2717 but lack suitable crtbegin/end objects or linker support. These
2718 targets can override the default in tm.h to use the fallback mechanism. */
2719 if (TARGET_USE_JCR_SECTION)
2724 #ifdef JCR_SECTION_NAME
2725 switch_to_section (get_section (JCR_SECTION_NAME, SECTION_WRITE, NULL));
2727 /* A target has defined TARGET_USE_JCR_SECTION,
2728 but doesn't have a JCR_SECTION_NAME. */
2731 assemble_align (POINTER_SIZE);
2733 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2735 t = build_fold_addr_expr (klass);
2736 output_constant (t, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE);
2741 tree klass, t, register_class_fn;
2744 t = build_function_type_list (void_type_node, class_ptr_type, NULL);
2745 t = build_decl (FUNCTION_DECL, get_identifier ("_Jv_RegisterClass"), t);
2746 TREE_PUBLIC (t) = 1;
2747 DECL_EXTERNAL (t) = 1;
2748 register_class_fn = t;
2750 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2752 t = build_fold_addr_expr (klass);
2753 t = tree_cons (NULL, t, NULL);
2754 t = build_function_call_expr (register_class_fn, t);
2755 append_to_statement_list (t, list_p);
2760 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2763 build_symbol_entry (tree decl, tree special)
2765 tree clname, name, signature, sym;
2766 clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
2767 /* ??? Constructors are given the name foo.foo all the way through
2768 the compiler, but in the method table they're all renamed
2769 foo.<init>. So, we have to do the same here unless we want an
2770 unresolved reference at runtime. */
2771 name = build_utf8_ref ((TREE_CODE (decl) == FUNCTION_DECL
2772 && DECL_CONSTRUCTOR_P (decl))
2773 ? init_identifier_node
2774 : DECL_NAME (decl));
2775 signature = build_java_signature (TREE_TYPE (decl));
2776 signature = build_utf8_ref (unmangle_classname
2777 (IDENTIFIER_POINTER (signature),
2778 IDENTIFIER_LENGTH (signature)));
2779 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2780 signature addr+1 if SPECIAL, and this indicates to the runtime
2781 system that this is a "special" symbol, i.e. one that should
2782 bypass access controls. */
2783 if (special != NULL_TREE)
2784 signature = build2 (PLUS_EXPR, TREE_TYPE (signature), signature, special);
2786 START_RECORD_CONSTRUCTOR (sym, symbol_type);
2787 PUSH_FIELD_VALUE (sym, "clname", clname);
2788 PUSH_FIELD_VALUE (sym, "name", name);
2789 PUSH_FIELD_VALUE (sym, "signature", signature);
2790 FINISH_RECORD_CONSTRUCTOR (sym);
2791 TREE_CONSTANT (sym) = 1;
2792 TREE_INVARIANT (sym) = 1;
2797 /* Emit a symbol table: used by -findirect-dispatch. */
2800 emit_symbol_table (tree name, tree the_table, tree decl_list,
2801 tree the_syms_decl, tree the_array_element_type,
2804 tree method_list, method, table, list, null_symbol;
2805 tree table_size, the_array_type;
2808 /* Only emit a table if this translation unit actually made any
2809 references via it. */
2810 if (decl_list == NULL_TREE)
2813 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2815 method_list = decl_list;
2817 while (method_list != NULL_TREE)
2819 tree special = TREE_PURPOSE (method_list);
2820 method = TREE_VALUE (method_list);
2821 list = tree_cons (NULL_TREE, build_symbol_entry (method, special), list);
2822 method_list = TREE_CHAIN (method_list);
2826 /* Terminate the list with a "null" entry. */
2827 START_RECORD_CONSTRUCTOR (null_symbol, symbol_type);
2828 PUSH_FIELD_VALUE (null_symbol, "clname", null_pointer_node);
2829 PUSH_FIELD_VALUE (null_symbol, "name", null_pointer_node);
2830 PUSH_FIELD_VALUE (null_symbol, "signature", null_pointer_node);
2831 FINISH_RECORD_CONSTRUCTOR (null_symbol);
2832 TREE_CONSTANT (null_symbol) = 1;
2833 TREE_INVARIANT (null_symbol) = 1;
2834 list = tree_cons (NULL_TREE, null_symbol, list);
2836 /* Put the list in the right order and make it a constructor. */
2837 list = nreverse (list);
2838 table = build_constructor_from_list (symbols_array_type, list);
2840 /* Make it the initial value for otable_syms and emit the decl. */
2841 DECL_INITIAL (the_syms_decl) = table;
2842 DECL_ARTIFICIAL (the_syms_decl) = 1;
2843 DECL_IGNORED_P (the_syms_decl) = 1;
2844 rest_of_decl_compilation (the_syms_decl, 1, 0);
2846 /* Now that its size is known, redefine the table as an
2847 uninitialized static array of INDEX + 1 elements. The extra entry
2848 is used by the runtime to track whether the table has been
2851 = build_index_type (build_int_cst (NULL_TREE, index * element_size + 1));
2852 the_array_type = build_array_type (the_array_element_type, table_size);
2853 the_table = build_decl (VAR_DECL, name, the_array_type);
2854 TREE_STATIC (the_table) = 1;
2855 TREE_READONLY (the_table) = 1;
2856 rest_of_decl_compilation (the_table, 1, 0);
2861 /* Make an entry for the catch_classes list. */
2863 make_catch_class_record (tree catch_class, tree classname)
2866 tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
2867 START_RECORD_CONSTRUCTOR (entry, type);
2868 PUSH_FIELD_VALUE (entry, "address", catch_class);
2869 PUSH_FIELD_VALUE (entry, "classname", classname);
2870 FINISH_RECORD_CONSTRUCTOR (entry);
2875 /* Generate the list of Throwable classes that are caught by exception
2876 handlers in this class. */
2878 emit_catch_table (tree this_class)
2880 tree table, table_size, array_type;
2881 TYPE_CATCH_CLASSES (this_class) =
2883 make_catch_class_record (null_pointer_node, null_pointer_node),
2884 TYPE_CATCH_CLASSES (this_class));
2885 TYPE_CATCH_CLASSES (this_class) = nreverse (TYPE_CATCH_CLASSES (this_class));
2886 TYPE_CATCH_CLASSES (this_class) =
2888 make_catch_class_record (null_pointer_node, null_pointer_node),
2889 TYPE_CATCH_CLASSES (this_class));
2890 table_size = build_index_type
2891 (build_int_cst (NULL_TREE,
2892 list_length (TYPE_CATCH_CLASSES (this_class))));
2894 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
2897 build_decl (VAR_DECL, DECL_NAME (TYPE_CTABLE_DECL (this_class)), array_type);
2898 DECL_INITIAL (table) =
2899 build_constructor_from_list (array_type, TYPE_CATCH_CLASSES (this_class));
2900 TREE_STATIC (table) = 1;
2901 TREE_READONLY (table) = 1;
2902 DECL_IGNORED_P (table) = 1;
2903 rest_of_decl_compilation (table, 1, 0);
2907 /* Given a type, return the signature used by
2908 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2909 same as build_java_signature() because we want the canonical array
2913 build_signature_for_libgcj (tree type)
2917 sig = build_java_signature (type);
2918 ref = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
2919 IDENTIFIER_LENGTH (sig)));
2923 /* Add an entry to the type assertion table. Callback used during hashtable
2927 add_assertion_table_entry (void **htab_entry, void *ptr)
2930 tree code_val, op1_utf8, op2_utf8;
2931 tree *list = (tree *) ptr;
2932 type_assertion *as = (type_assertion *) *htab_entry;
2934 code_val = build_int_cst (NULL_TREE, as->assertion_code);
2936 if (as->op1 == NULL_TREE)
2937 op1_utf8 = null_pointer_node;
2939 op1_utf8 = build_signature_for_libgcj (as->op1);
2941 if (as->op2 == NULL_TREE)
2942 op2_utf8 = null_pointer_node;
2944 op2_utf8 = build_signature_for_libgcj (as->op2);
2946 START_RECORD_CONSTRUCTOR (entry, assertion_entry_type);
2947 PUSH_FIELD_VALUE (entry, "assertion_code", code_val);
2948 PUSH_FIELD_VALUE (entry, "op1", op1_utf8);
2949 PUSH_FIELD_VALUE (entry, "op2", op2_utf8);
2950 FINISH_RECORD_CONSTRUCTOR (entry);
2952 *list = tree_cons (NULL_TREE, entry, *list);
2956 /* Generate the type assertion table for CLASS, and return its DECL. */
2959 emit_assertion_table (tree class)
2961 tree null_entry, ctor, table_decl;
2962 tree list = NULL_TREE;
2963 htab_t assertions_htab = TYPE_ASSERTIONS (class);
2965 /* Iterate through the hash table. */
2966 htab_traverse (assertions_htab, add_assertion_table_entry, &list);
2968 /* Finish with a null entry. */
2969 START_RECORD_CONSTRUCTOR (null_entry, assertion_entry_type);
2970 PUSH_FIELD_VALUE (null_entry, "assertion_code", integer_zero_node);
2971 PUSH_FIELD_VALUE (null_entry, "op1", null_pointer_node);
2972 PUSH_FIELD_VALUE (null_entry, "op2", null_pointer_node);
2973 FINISH_RECORD_CONSTRUCTOR (null_entry);
2975 list = tree_cons (NULL_TREE, null_entry, list);
2977 /* Put the list in the right order and make it a constructor. */
2978 list = nreverse (list);
2979 ctor = build_constructor_from_list (assertion_table_type, list);
2981 table_decl = build_decl (VAR_DECL, mangled_classname ("_type_assert_", class),
2982 assertion_table_type);
2984 TREE_STATIC (table_decl) = 1;
2985 TREE_READONLY (table_decl) = 1;
2986 TREE_CONSTANT (table_decl) = 1;
2987 DECL_IGNORED_P (table_decl) = 1;
2989 DECL_INITIAL (table_decl) = ctor;
2990 DECL_ARTIFICIAL (table_decl) = 1;
2991 rest_of_decl_compilation (table_decl, 1, 0);
2997 init_class_processing (void)
2999 fields_ident = get_identifier ("fields");
3000 info_ident = get_identifier ("info");
3002 gcc_obstack_init (&temporary_obstack);
3005 static hashval_t java_treetreehash_hash (const void *);
3006 static int java_treetreehash_compare (const void *, const void *);
3008 /* A hash table mapping trees to trees. Used generally. */
3010 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
3013 java_treetreehash_hash (const void *k_p)
3015 struct treetreehash_entry *k = (struct treetreehash_entry *) k_p;
3016 return JAVA_TREEHASHHASH_H (k->key);
3020 java_treetreehash_compare (const void * k1_p, const void * k2_p)
3022 struct treetreehash_entry * k1 = (struct treetreehash_entry *) k1_p;
3023 tree k2 = (tree) k2_p;
3024 return (k1->key == k2);
3028 java_treetreehash_find (htab_t ht, tree t)
3030 struct treetreehash_entry *e;
3031 hashval_t hv = JAVA_TREEHASHHASH_H (t);
3032 e = htab_find_with_hash (ht, t, hv);
3040 java_treetreehash_new (htab_t ht, tree t)
3043 struct treetreehash_entry *tthe;
3044 hashval_t hv = JAVA_TREEHASHHASH_H (t);
3046 e = htab_find_slot_with_hash (ht, t, hv, INSERT);
3049 tthe = (*ht->alloc_f) (1, sizeof (*tthe));
3054 tthe = (struct treetreehash_entry *) *e;
3055 return &tthe->value;
3059 java_treetreehash_create (size_t size, int gc)
3062 return htab_create_ggc (size, java_treetreehash_hash,
3063 java_treetreehash_compare, NULL);
3065 return htab_create_alloc (size, java_treetreehash_hash,
3066 java_treetreehash_compare, free, xcalloc, free);
3069 /* Break down qualified IDENTIFIER into package and class-name components.
3070 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3071 "pkg.foo", and RIGHT to "Bar". */
3074 split_qualified_name (tree *left, tree *right, tree source)
3077 int l = IDENTIFIER_LENGTH (source);
3079 base = alloca (l + 1);
3080 memcpy (base, IDENTIFIER_POINTER (source), l + 1);
3082 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3084 while (*p != '.' && p != base)
3087 /* We didn't find a '.'. Return an error. */
3093 *right = get_identifier (p+1);
3094 *left = get_identifier (base);
3099 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3100 if the classes are from the same package. */
3103 in_same_package (tree name1, tree name2)
3109 if (TREE_CODE (name1) == TYPE_DECL)
3110 name1 = DECL_NAME (name1);
3111 if (TREE_CODE (name2) == TYPE_DECL)
3112 name2 = DECL_NAME (name2);
3114 if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
3115 /* One in empty package. */
3118 if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
3119 /* Both in empty package. */
3122 split_qualified_name (&pkg1, &tmp, name1);
3123 split_qualified_name (&pkg2, &tmp, name2);
3125 return (pkg1 == pkg2);
3128 #include "gt-java-class.h"