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 input_filename = "<unknown>";
434 CLASS_P (class_type) = 1;
435 decl = build_decl (TYPE_DECL, class_name, class_type);
436 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
438 /* dbxout needs a DECL_SIZE if in gstabs mode */
439 DECL_SIZE (decl) = integer_zero_node;
441 input_location = saved_loc;
442 signature = identifier_subst (class_name, "L", '.', '/', ";");
443 IDENTIFIER_SIGNATURE_TYPE (signature) = build_pointer_type (class_type);
445 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
446 both a typedef and in the struct name-space. We may want to re-visit
447 this later, but for now it reduces the changes needed for gdb. */
448 DECL_ARTIFICIAL (decl) = 1;
450 pushdecl_top_level (decl);
455 /* Finds the (global) class named NAME. Creates the class if not found.
456 Also creates associated TYPE_DECL.
457 Does not check if the class actually exists, load the class,
458 fill in field or methods, or do layout_type. */
461 lookup_class (tree name)
463 tree decl = IDENTIFIER_CLASS_VALUE (name);
464 if (decl == NULL_TREE)
465 decl = push_class (make_class (), name);
466 return TREE_TYPE (decl);
470 set_super_info (int access_flags, tree this_class,
471 tree super_class, int interfaces_count)
473 int total_supers = interfaces_count;
474 tree class_decl = TYPE_NAME (this_class);
480 TYPE_BINFO (this_class) = make_tree_binfo (total_supers);
481 TYPE_VFIELD (this_class) = TYPE_VFIELD (object_type_node);
484 tree super_binfo = make_tree_binfo (0);
485 BINFO_TYPE (super_binfo) = super_class;
486 BINFO_OFFSET (super_binfo) = integer_zero_node;
487 BINFO_BASE_APPEND (TYPE_BINFO (this_class), super_binfo);
488 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class)) = 1;
491 set_class_decl_access_flags (access_flags, class_decl);
495 set_class_decl_access_flags (int access_flags, tree class_decl)
497 if (access_flags & ACC_PUBLIC) CLASS_PUBLIC (class_decl) = 1;
498 if (access_flags & ACC_FINAL) CLASS_FINAL (class_decl) = 1;
499 if (access_flags & ACC_SUPER) CLASS_SUPER (class_decl) = 1;
500 if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
501 if (access_flags & ACC_ABSTRACT) CLASS_ABSTRACT (class_decl) = 1;
502 if (access_flags & ACC_STATIC) CLASS_STATIC (class_decl) = 1;
503 if (access_flags & ACC_PRIVATE) CLASS_PRIVATE (class_decl) = 1;
504 if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
505 if (access_flags & ACC_STRICT) CLASS_STRICTFP (class_decl) = 1;
506 if (access_flags & ACC_ENUM) CLASS_ENUM (class_decl) = 1;
507 if (access_flags & ACC_SYNTHETIC) CLASS_SYNTHETIC (class_decl) = 1;
508 if (access_flags & ACC_ANNOTATION) CLASS_ANNOTATION (class_decl) = 1;
511 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
512 direct sub-classes of Object are 1, and so on. */
515 class_depth (tree clas)
518 if (! CLASS_LOADED_P (clas))
519 load_class (clas, 1);
520 if (TYPE_SIZE (clas) == error_mark_node)
522 while (clas != object_type_node)
525 clas = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas), 0));
530 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
533 interface_of_p (tree type1, tree type2)
536 tree binfo, base_binfo;
538 if (! TYPE_BINFO (type2))
541 for (binfo = TYPE_BINFO (type2), i = 0;
542 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
543 if (BINFO_TYPE (base_binfo) == type1)
546 for (binfo = TYPE_BINFO (type2), i = 0;
547 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) /* */
548 if (BINFO_TYPE (base_binfo)
549 && interface_of_p (type1, BINFO_TYPE (base_binfo)))
555 /* Return true iff TYPE1 inherits from TYPE2. */
558 inherits_from_p (tree type1, tree type2)
560 while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
565 if (! CLASS_LOADED_P (type1))
566 load_class (type1, 1);
568 type1 = maybe_layout_super_class (CLASSTYPE_SUPER (type1), type1);
573 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
576 enclosing_context_p (tree type1, tree type2)
578 if (!INNER_CLASS_TYPE_P (type2))
581 for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
583 type2 = (INNER_CLASS_TYPE_P (type2) ?
584 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
594 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
598 common_enclosing_context_p (tree type1, tree type2)
603 for (current = type2; current;
604 current = (INNER_CLASS_TYPE_P (current) ?
605 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
607 if (type1 == current)
610 if (INNER_CLASS_TYPE_P (type1))
611 type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1)));
618 /* Return 1 iff there exists a common enclosing "this" between TYPE1
619 and TYPE2, without crossing any static context. */
622 common_enclosing_instance_p (tree type1, tree type2)
624 if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
627 for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1;
628 type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
629 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
632 for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
633 current = (PURE_INNER_CLASS_TYPE_P (current) ?
634 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
636 if (type1 == current)
642 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
643 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
644 if attempt is made to add it twice. */
647 maybe_add_interface (tree this_class, tree interface_class)
649 tree binfo, base_binfo;
652 for (binfo = TYPE_BINFO (this_class), i = 0;
653 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
654 if (BINFO_TYPE (base_binfo) == interface_class)
655 return interface_class;
656 add_interface (this_class, interface_class);
660 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
663 add_interface (tree this_class, tree interface_class)
665 tree interface_binfo = make_tree_binfo (0);
667 BINFO_TYPE (interface_binfo) = interface_class;
668 BINFO_OFFSET (interface_binfo) = integer_zero_node;
669 BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node;
670 BINFO_VIRTUAL_P (interface_binfo) = 1;
672 BINFO_BASE_APPEND (TYPE_BINFO (this_class), interface_binfo);
676 build_java_method_type (tree fntype, tree this_class, int access_flags)
678 if (access_flags & ACC_STATIC)
680 fntype = build_method_type (this_class, fntype);
682 /* We know that arg 1 of every nonstatic method is non-null; tell
684 TYPE_ATTRIBUTES (fntype) = (tree_cons
685 (get_identifier ("nonnull"),
686 tree_cons (NULL_TREE,
687 build_int_cst (NULL_TREE, 1),
689 TYPE_ATTRIBUTES (fntype)));
696 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
697 DECL_VISIBILITY_SPECIFIED (decl) = 1;
701 add_method_1 (tree this_class, int access_flags, tree name, tree function_type)
703 tree method_type, fndecl;
705 method_type = build_java_method_type (function_type,
706 this_class, access_flags);
708 fndecl = build_decl (FUNCTION_DECL, name, method_type);
709 DECL_CONTEXT (fndecl) = this_class;
711 DECL_LANG_SPECIFIC (fndecl)
712 = ggc_alloc_cleared (sizeof (struct lang_decl));
713 DECL_LANG_SPECIFIC (fndecl)->desc = LANG_DECL_FUNC;
715 /* Initialize the static initializer test table. */
717 DECL_FUNCTION_INIT_TEST_TABLE (fndecl) =
718 java_treetreehash_create (10, 1);
720 /* Initialize the initialized (static) class table. */
721 if (access_flags & ACC_STATIC)
722 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) =
723 htab_create_ggc (50, htab_hash_pointer, htab_eq_pointer, NULL);
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;
745 /* FNDECL is external unless we are compiling it into this object
747 DECL_EXTERNAL (fndecl) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class) == 0;
748 if (access_flags & ACC_STATIC)
749 METHOD_STATIC (fndecl) = DECL_INLINE (fndecl) = 1;
750 if (access_flags & ACC_FINAL)
751 METHOD_FINAL (fndecl) = DECL_INLINE (fndecl) = 1;
752 if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
753 if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
754 if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
755 if (access_flags & ACC_SYNTHETIC) DECL_ARTIFICIAL (fndecl) = 1;
756 if (access_flags & ACC_BRIDGE) METHOD_BRIDGE (fndecl) = 1;
757 if (access_flags & ACC_VARARGS) METHOD_VARARGS (fndecl) = 1;
761 /* Add a method to THIS_CLASS.
762 The method's name is NAME.
763 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
766 add_method (tree this_class, int access_flags, tree name, tree method_sig)
768 tree function_type, fndecl;
769 const unsigned char *sig
770 = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
773 fatal_error ("bad method signature");
775 function_type = get_type_from_signature (method_sig);
776 fndecl = add_method_1 (this_class, access_flags, name, function_type);
777 set_java_signature (TREE_TYPE (fndecl), method_sig);
782 add_field (tree class, tree name, tree field_type, int flags)
784 int is_static = (flags & ACC_STATIC) != 0;
786 field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type);
787 TREE_CHAIN (field) = TYPE_FIELDS (class);
788 TYPE_FIELDS (class) = field;
789 DECL_CONTEXT (field) = class;
790 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
792 if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
793 if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
794 if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
795 if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
796 if (flags & ACC_VOLATILE)
798 FIELD_VOLATILE (field) = 1;
799 TREE_THIS_VOLATILE (field) = 1;
801 if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
802 if (flags & ACC_ENUM) FIELD_ENUM (field) = 1;
803 if (flags & ACC_SYNTHETIC) FIELD_SYNTHETIC (field) = 1;
806 FIELD_STATIC (field) = 1;
807 /* Always make field externally visible. This is required so
808 that native methods can always access the field. */
809 TREE_PUBLIC (field) = 1;
810 /* Hide everything that shouldn't be visible outside a DSO. */
811 if (flag_indirect_classes
812 || (FIELD_PRIVATE (field)))
814 /* Considered external unless we are compiling it into this
816 DECL_EXTERNAL (field) = (is_compiled_class (class) != 2);
822 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
825 set_constant_value (tree field, tree constant)
827 if (field == NULL_TREE)
828 warning (OPT_Wattributes,
829 "misplaced ConstantValue attribute (not in any field)");
830 else if (DECL_INITIAL (field) != NULL_TREE)
831 warning (OPT_Wattributes,
832 "duplicate ConstantValue attribute for field '%s'",
833 IDENTIFIER_POINTER (DECL_NAME (field)));
836 DECL_INITIAL (field) = constant;
837 if (TREE_TYPE (constant) != TREE_TYPE (field)
838 && ! (TREE_TYPE (constant) == int_type_node
839 && INTEGRAL_TYPE_P (TREE_TYPE (field))
840 && TYPE_PRECISION (TREE_TYPE (field)) <= 32)
841 && ! (TREE_TYPE (constant) == utf8const_ptr_type
842 && TREE_TYPE (field) == string_ptr_type_node))
843 error ("ConstantValue attribute of field '%s' has wrong type",
844 IDENTIFIER_POINTER (DECL_NAME (field)));
845 if (FIELD_FINAL (field))
846 DECL_FIELD_FINAL_IUD (field) = 1;
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 varpool_mark_needed_node (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);
957 build_static_class_ref (tree type)
959 tree decl_name, decl, ref;
961 if (TYPE_SIZE (type) == error_mark_node)
962 return null_pointer_node;
963 decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
964 "", '/', '/', ".class$$");
965 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
966 if (decl == NULL_TREE)
968 decl = build_decl (VAR_DECL, decl_name, class_type_node);
969 TREE_STATIC (decl) = 1;
970 if (! flag_indirect_classes)
972 TREE_PUBLIC (decl) = 1;
973 if (CLASS_PRIVATE (TYPE_NAME (type)))
976 DECL_IGNORED_P (decl) = 1;
977 DECL_ARTIFICIAL (decl) = 1;
978 if (is_compiled_class (type) == 1)
979 DECL_EXTERNAL (decl) = 1;
980 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
981 DECL_CLASS_FIELD_P (decl) = 1;
982 DECL_CONTEXT (decl) = type;
984 /* ??? We want to preserve the DECL_CONTEXT we set just above,
985 that that means not calling pushdecl_top_level. */
986 IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
989 ref = build1 (ADDR_EXPR, class_ptr_type, decl);
994 build_classdollar_field (tree type)
996 tree decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
997 "", '/', '/', ".class$");
998 tree decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1000 if (decl == NULL_TREE)
1003 = build_decl (VAR_DECL, decl_name,
1006 (build_type_variant (class_type_node,
1008 /* const */ 1, 0)));
1009 TREE_STATIC (decl) = 1;
1010 TREE_INVARIANT (decl) = 1;
1011 TREE_CONSTANT (decl) = 1;
1012 TREE_READONLY (decl) = 1;
1013 TREE_PUBLIC (decl) = 1;
1015 DECL_IGNORED_P (decl) = 1;
1016 DECL_ARTIFICIAL (decl) = 1;
1017 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1018 IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
1019 DECL_CLASS_FIELD_P (decl) = 1;
1020 DECL_CONTEXT (decl) = type;
1026 /* Create a local variable that holds the current class$. */
1029 cache_this_class_ref (tree fndecl)
1033 tree classdollar_field;
1034 if (flag_indirect_classes)
1035 classdollar_field = build_classdollar_field (output_class);
1037 classdollar_field = build_static_class_ref (output_class);
1039 this_classdollar = build_decl (VAR_DECL, NULL_TREE,
1040 TREE_TYPE (classdollar_field));
1042 java_add_local_var (this_classdollar);
1043 java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (this_classdollar),
1044 this_classdollar, classdollar_field));
1047 this_classdollar = build_classdollar_field (output_class);
1049 /* Prepend class initialization for static methods reachable from
1051 if (METHOD_STATIC (fndecl)
1052 && (! METHOD_PRIVATE (fndecl)
1053 || INNER_CLASS_P (DECL_CONTEXT (fndecl)))
1054 && ! DECL_CLINIT_P (fndecl)
1055 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl))))
1057 tree init = build_call_expr (soft_initclass_node, 1,
1059 java_add_stmt (init);
1063 /* Remove the reference to the local variable that holds the current
1067 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED)
1069 this_classdollar = build_classdollar_field (output_class);
1072 /* Build a reference to the class TYPE.
1073 Also handles primitive types and array types. */
1076 build_class_ref (tree type)
1078 int is_compiled = is_compiled_class (type);
1082 if (TREE_CODE (type) == POINTER_TYPE)
1083 type = TREE_TYPE (type);
1085 if (flag_indirect_dispatch
1086 && type != output_class
1087 && TREE_CODE (type) == RECORD_TYPE)
1088 return build_indirect_class_ref (type);
1090 if (type == output_class && flag_indirect_classes)
1091 return this_classdollar;
1093 if (TREE_CODE (type) == RECORD_TYPE)
1094 return build_static_class_ref (type);
1100 decl_name = TYPE_NAME (type);
1101 if (TREE_CODE (decl_name) == TYPE_DECL)
1102 decl_name = DECL_NAME (decl_name);
1103 name = IDENTIFIER_POINTER (decl_name);
1104 if (strncmp (name, "promoted_", 9) == 0)
1106 sprintf (buffer, "_Jv_%sClass", name);
1107 decl_name = get_identifier (buffer);
1108 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1109 if (decl == NULL_TREE)
1111 decl = build_decl (VAR_DECL, decl_name, class_type_node);
1112 TREE_STATIC (decl) = 1;
1113 TREE_PUBLIC (decl) = 1;
1114 DECL_EXTERNAL (decl) = 1;
1115 DECL_ARTIFICIAL (decl) = 1;
1116 pushdecl_top_level (decl);
1120 ref = build1 (ADDR_EXPR, class_ptr_type, decl);
1124 return build_indirect_class_ref (type);
1127 /* Create a local statically allocated variable that will hold a
1128 pointer to a static field. */
1131 build_fieldref_cache_entry (int index, tree fdecl ATTRIBUTE_UNUSED)
1133 tree decl, decl_name;
1134 const char *name = IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class));
1135 char *buf = alloca (strlen (name) + 20);
1136 sprintf (buf, "%s_%d_ref", name, index);
1137 decl_name = get_identifier (buf);
1138 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1139 if (decl == NULL_TREE)
1141 decl = build_decl (VAR_DECL, decl_name, ptr_type_node);
1142 TREE_STATIC (decl) = 1;
1143 TREE_PUBLIC (decl) = 0;
1144 DECL_EXTERNAL (decl) = 0;
1145 DECL_ARTIFICIAL (decl) = 1;
1146 DECL_IGNORED_P (decl) = 1;
1147 pushdecl_top_level (decl);
1153 build_static_field_ref (tree fdecl)
1155 tree fclass = DECL_CONTEXT (fdecl);
1156 int is_compiled = is_compiled_class (fclass);
1157 int from_class = ! CLASS_FROM_SOURCE_P (current_class);
1159 /* Allow static final fields to fold to a constant. When using
1160 -findirect-dispatch, we simply never do this folding if compiling
1161 from .class; in the .class file constants will be referred to via
1162 the constant pool. */
1163 if ((!flag_indirect_dispatch || !from_class)
1165 || (FIELD_FINAL (fdecl) && DECL_INITIAL (fdecl) != NULL_TREE
1166 && (JSTRING_TYPE_P (TREE_TYPE (fdecl))
1167 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl)))
1168 && TREE_CONSTANT (DECL_INITIAL (fdecl)))))
1170 if (is_compiled == 1)
1171 DECL_EXTERNAL (fdecl) = 1;
1175 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1176 and a class local static variable CACHE_ENTRY, then
1178 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1179 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1182 This can mostly be optimized away, so that the usual path is a
1183 load followed by a test and branch. _Jv_ResolvePoolEntry is
1184 only called once for each constant pool entry.
1186 There is an optimization that we don't do: at the start of a
1187 method, create a local copy of CACHE_ENTRY and use that instead.
1191 int cpool_index = alloc_constant_fieldref (output_class, fdecl);
1192 tree cache_entry = build_fieldref_cache_entry (cpool_index, fdecl);
1194 = build_call_expr (built_in_decls[BUILT_IN_EXPECT], 2,
1195 build2 (EQ_EXPR, boolean_type_node,
1196 cache_entry, null_pointer_node),
1197 boolean_false_node);
1198 tree cpool_index_cst = build_int_cst (NULL_TREE, cpool_index);
1200 = build_call_expr (soft_resolvepoolentry_node, 2,
1201 build_class_ref (output_class),
1203 init = build2 (MODIFY_EXPR, ptr_type_node, cache_entry, init);
1204 init = build3 (COND_EXPR, ptr_type_node, test, init, cache_entry);
1205 init = fold_convert (build_pointer_type (TREE_TYPE (fdecl)), init);
1206 fdecl = build1 (INDIRECT_REF, TREE_TYPE (fdecl), init);
1212 get_access_flags_from_decl (tree decl)
1214 int access_flags = 0;
1215 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
1217 if (FIELD_STATIC (decl))
1218 access_flags |= ACC_STATIC;
1219 if (FIELD_PUBLIC (decl))
1220 access_flags |= ACC_PUBLIC;
1221 if (FIELD_PROTECTED (decl))
1222 access_flags |= ACC_PROTECTED;
1223 if (FIELD_PRIVATE (decl))
1224 access_flags |= ACC_PRIVATE;
1225 if (FIELD_FINAL (decl))
1226 access_flags |= ACC_FINAL;
1227 if (FIELD_VOLATILE (decl))
1228 access_flags |= ACC_VOLATILE;
1229 if (FIELD_TRANSIENT (decl))
1230 access_flags |= ACC_TRANSIENT;
1231 if (FIELD_ENUM (decl))
1232 access_flags |= ACC_ENUM;
1233 if (FIELD_SYNTHETIC (decl))
1234 access_flags |= ACC_SYNTHETIC;
1235 return access_flags;
1237 if (TREE_CODE (decl) == TYPE_DECL)
1239 if (CLASS_PUBLIC (decl))
1240 access_flags |= ACC_PUBLIC;
1241 if (CLASS_FINAL (decl))
1242 access_flags |= ACC_FINAL;
1243 if (CLASS_SUPER (decl))
1244 access_flags |= ACC_SUPER;
1245 if (CLASS_INTERFACE (decl))
1246 access_flags |= ACC_INTERFACE;
1247 if (CLASS_ABSTRACT (decl))
1248 access_flags |= ACC_ABSTRACT;
1249 if (CLASS_STATIC (decl))
1250 access_flags |= ACC_STATIC;
1251 if (CLASS_PRIVATE (decl))
1252 access_flags |= ACC_PRIVATE;
1253 if (CLASS_PROTECTED (decl))
1254 access_flags |= ACC_PROTECTED;
1255 if (CLASS_STRICTFP (decl))
1256 access_flags |= ACC_STRICT;
1257 if (CLASS_ENUM (decl))
1258 access_flags |= ACC_ENUM;
1259 if (CLASS_SYNTHETIC (decl))
1260 access_flags |= ACC_SYNTHETIC;
1261 if (CLASS_ANNOTATION (decl))
1262 access_flags |= ACC_ANNOTATION;
1263 return access_flags;
1265 if (TREE_CODE (decl) == FUNCTION_DECL)
1267 if (METHOD_PUBLIC (decl))
1268 access_flags |= ACC_PUBLIC;
1269 if (METHOD_PRIVATE (decl))
1270 access_flags |= ACC_PRIVATE;
1271 if (METHOD_PROTECTED (decl))
1272 access_flags |= ACC_PROTECTED;
1273 if (METHOD_STATIC (decl))
1274 access_flags |= ACC_STATIC;
1275 if (METHOD_FINAL (decl))
1276 access_flags |= ACC_FINAL;
1277 if (METHOD_SYNCHRONIZED (decl))
1278 access_flags |= ACC_SYNCHRONIZED;
1279 if (METHOD_NATIVE (decl))
1280 access_flags |= ACC_NATIVE;
1281 if (METHOD_ABSTRACT (decl))
1282 access_flags |= ACC_ABSTRACT;
1283 if (METHOD_STRICTFP (decl))
1284 access_flags |= ACC_STRICT;
1285 if (METHOD_INVISIBLE (decl))
1286 access_flags |= ACC_INVISIBLE;
1287 if (DECL_ARTIFICIAL (decl))
1288 access_flags |= ACC_SYNTHETIC;
1289 if (METHOD_BRIDGE (decl))
1290 access_flags |= ACC_BRIDGE;
1291 if (METHOD_VARARGS (decl))
1292 access_flags |= ACC_VARARGS;
1293 return access_flags;
1298 static GTY (()) int alias_labelno = 0;
1300 /* Create a private alias for METHOD. Using this alias instead of the method
1301 decl ensures that ncode entries in the method table point to the real function
1302 at runtime, not a PLT entry. */
1305 make_local_function_alias (tree method)
1307 #ifdef ASM_OUTPUT_DEF
1310 const char *method_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method));
1311 char *name = alloca (strlen (method_name) + 2);
1312 char *buf = alloca (strlen (method_name) + 128);
1314 /* Only create aliases for local functions. */
1315 if (DECL_EXTERNAL (method))
1318 /* Prefix method_name with 'L' for the alias label. */
1320 strcpy (name + 1, method_name);
1322 ASM_GENERATE_INTERNAL_LABEL (buf, name, alias_labelno++);
1323 alias = build_decl (FUNCTION_DECL, get_identifier (buf),
1324 TREE_TYPE (method));
1325 DECL_CONTEXT (alias) = NULL;
1326 TREE_READONLY (alias) = TREE_READONLY (method);
1327 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (method);
1328 TREE_PUBLIC (alias) = 0;
1329 DECL_EXTERNAL (alias) = 0;
1330 DECL_ARTIFICIAL (alias) = 1;
1331 DECL_INLINE (alias) = 0;
1332 DECL_INITIAL (alias) = error_mark_node;
1333 TREE_ADDRESSABLE (alias) = 1;
1334 TREE_USED (alias) = 1;
1335 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
1336 if (!flag_syntax_only)
1337 assemble_alias (alias, DECL_ASSEMBLER_NAME (method));
1344 /** Make reflection data (_Jv_Field) for field FDECL. */
1347 make_field_value (tree fdecl)
1351 tree type = TREE_TYPE (fdecl);
1352 int resolved = is_compiled_class (type) && ! flag_indirect_dispatch;
1354 START_RECORD_CONSTRUCTOR (finit, field_type_node);
1355 PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl)));
1357 type = build_class_ref (type);
1360 tree signature = build_java_signature (type);
1362 type = build_utf8_ref (unmangle_classname
1363 (IDENTIFIER_POINTER (signature),
1364 IDENTIFIER_LENGTH (signature)));
1366 PUSH_FIELD_VALUE (finit, "type", type);
1368 flags = get_access_flags_from_decl (fdecl);
1370 flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1372 PUSH_FIELD_VALUE (finit, "accflags", build_int_cst (NULL_TREE, flags));
1373 PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
1376 tree field_address = integer_zero_node;
1377 if ((DECL_INITIAL (fdecl) || ! flag_indirect_classes)
1378 && FIELD_STATIC (fdecl))
1379 field_address = build_address_of (fdecl);
1383 build_constructor_from_list (field_info_union_node,
1385 ((FIELD_STATIC (fdecl)
1386 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
1387 : TYPE_FIELDS (field_info_union_node)),
1388 (FIELD_STATIC (fdecl)
1390 : byte_position (fdecl)))));
1393 FINISH_RECORD_CONSTRUCTOR (finit);
1397 /** Make reflection data (_Jv_Method) for method MDECL. */
1400 make_method_value (tree mdecl)
1402 static int method_name_count = 0;
1407 #define ACC_TRANSLATED 0x4000
1408 int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
1410 class_decl = DECL_CONTEXT (mdecl);
1411 /* For interfaces, the index field contains the dispatch index. */
1412 if (CLASS_INTERFACE (TYPE_NAME (class_decl)))
1413 index = build_int_cst (NULL_TREE,
1414 get_interface_method_index (mdecl, class_decl));
1415 else if (!flag_indirect_dispatch && get_method_index (mdecl) != NULL_TREE)
1416 index = get_method_index (mdecl);
1418 index = integer_minus_one_node;
1420 code = null_pointer_node;
1421 if (METHOD_ABSTRACT (mdecl))
1422 code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1423 soft_abstractmethod_node);
1425 code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1426 make_local_function_alias (mdecl));
1427 START_RECORD_CONSTRUCTOR (minit, method_type_node);
1428 PUSH_FIELD_VALUE (minit, "name",
1429 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
1430 init_identifier_node
1431 : DECL_NAME (mdecl)));
1433 tree signature = build_java_signature (TREE_TYPE (mdecl));
1434 PUSH_FIELD_VALUE (minit, "signature",
1437 (IDENTIFIER_POINTER(signature),
1438 IDENTIFIER_LENGTH(signature)))));
1440 PUSH_FIELD_VALUE (minit, "accflags", build_int_cst (NULL_TREE, accflags));
1441 PUSH_FIELD_VALUE (minit, "index", index);
1442 PUSH_FIELD_VALUE (minit, "ncode", code);
1445 /* Compute the `throws' information for the method. */
1446 tree table = null_pointer_node;
1447 if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE)
1449 int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl));
1450 tree iter, type, array;
1453 table = tree_cons (NULL_TREE, table, NULL_TREE);
1454 for (iter = DECL_FUNCTION_THROWS (mdecl);
1456 iter = TREE_CHAIN (iter))
1458 tree sig = DECL_NAME (TYPE_NAME (TREE_VALUE (iter)));
1460 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
1461 IDENTIFIER_LENGTH (sig)));
1462 table = tree_cons (NULL_TREE, utf8, table);
1464 type = build_prim_array_type (ptr_type_node, length);
1465 table = build_constructor_from_list (type, table);
1466 /* Compute something unique enough. */
1467 sprintf (buf, "_methods%d", method_name_count++);
1468 array = build_decl (VAR_DECL, get_identifier (buf), type);
1469 DECL_INITIAL (array) = table;
1470 TREE_STATIC (array) = 1;
1471 DECL_ARTIFICIAL (array) = 1;
1472 DECL_IGNORED_P (array) = 1;
1473 rest_of_decl_compilation (array, 1, 0);
1475 table = build1 (ADDR_EXPR, ptr_type_node, array);
1478 PUSH_FIELD_VALUE (minit, "throws", table);
1481 FINISH_RECORD_CONSTRUCTOR (minit);
1486 get_dispatch_vector (tree type)
1488 tree vtable = TYPE_VTABLE (type);
1490 if (vtable == NULL_TREE)
1494 tree super = CLASSTYPE_SUPER (type);
1495 HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1496 vtable = make_tree_vec (nvirtuals);
1497 TYPE_VTABLE (type) = vtable;
1498 if (super != NULL_TREE)
1500 tree super_vtable = get_dispatch_vector (super);
1502 for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1503 TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1506 for (method = TYPE_METHODS (type); method != NULL_TREE;
1507 method = TREE_CHAIN (method))
1509 tree method_index = get_method_index (method);
1510 if (method_index != NULL_TREE
1511 && host_integerp (method_index, 0))
1512 TREE_VEC_ELT (vtable, tree_low_cst (method_index, 0)) = method;
1520 get_dispatch_table (tree type, tree this_class_addr)
1522 int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1523 tree vtable = get_dispatch_vector (type);
1525 tree list = NULL_TREE;
1526 int nvirtuals = TREE_VEC_LENGTH (vtable);
1530 for (i = nvirtuals; --i >= 0; )
1532 tree method = TREE_VEC_ELT (vtable, i);
1533 if (METHOD_ABSTRACT (method))
1536 warning (0, "%Jabstract method in non-abstract class", method);
1538 if (TARGET_VTABLE_USES_DESCRIPTORS)
1539 for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1540 list = tree_cons (NULL_TREE, null_pointer_node, list);
1542 list = tree_cons (NULL_TREE, null_pointer_node, list);
1546 if (TARGET_VTABLE_USES_DESCRIPTORS)
1547 for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1549 tree fdesc = build2 (FDESC_EXPR, nativecode_ptr_type_node,
1550 method, build_int_cst (NULL_TREE, j));
1551 TREE_CONSTANT (fdesc) = 1;
1552 TREE_INVARIANT (fdesc) = 1;
1553 list = tree_cons (NULL_TREE, fdesc, list);
1556 list = tree_cons (NULL_TREE,
1557 build1 (ADDR_EXPR, nativecode_ptr_type_node,
1563 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1564 using the Boehm GC we sometimes stash a GC type descriptor
1565 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1566 the emitted byte count during the output to the assembly file. */
1567 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1568 fake "function descriptor". It's first word is the is the class
1569 pointer, and subsequent words (usually one) contain the GC descriptor.
1570 In all other cases, we reserve two extra vtable slots. */
1571 gc_descr = get_boehm_type_descriptor (type);
1572 list = tree_cons (NULL_TREE, gc_descr, list);
1573 for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
1574 list = tree_cons (NULL_TREE, gc_descr, list);
1575 list = tree_cons (NULL_TREE, this_class_addr, list);
1577 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1578 list = tree_cons (NULL_TREE, null_pointer_node, list);
1579 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1580 list = tree_cons (integer_zero_node, null_pointer_node, list);
1582 arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
1583 if (TARGET_VTABLE_USES_DESCRIPTORS)
1584 arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
1586 return build_constructor_from_list
1587 (build_prim_array_type (nativecode_ptr_type_node,
1592 /* Set the method_index for a method decl. */
1594 set_method_index (tree decl, tree method_index)
1596 if (method_index != NULL_TREE)
1598 /* method_index is null if we're using indirect dispatch. */
1599 method_index = fold (convert (sizetype, method_index));
1601 if (TARGET_VTABLE_USES_DESCRIPTORS)
1602 /* Add one to skip bogus descriptor for class and GC descriptor. */
1603 method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
1605 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1607 method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1610 DECL_VINDEX (decl) = method_index;
1613 /* Get the method_index for a method decl. */
1615 get_method_index (tree decl)
1617 tree method_index = DECL_VINDEX (decl);
1622 if (TARGET_VTABLE_USES_DESCRIPTORS)
1623 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1624 method_index = size_binop (MINUS_EXPR, method_index, size_int (1));
1626 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1627 method_index = size_binop (MINUS_EXPR, method_index, size_int (2));
1629 return method_index;
1633 supers_all_compiled (tree type)
1635 while (type != NULL_TREE)
1637 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
1639 type = CLASSTYPE_SUPER (type);
1645 make_class_data (tree type)
1647 tree decl, cons, temp;
1648 tree field, fields_decl;
1649 tree static_fields = NULL_TREE;
1650 tree instance_fields = NULL_TREE;
1651 HOST_WIDE_INT static_field_count = 0;
1652 HOST_WIDE_INT instance_field_count = 0;
1653 HOST_WIDE_INT field_count;
1654 tree field_array_type;
1656 tree methods = NULL_TREE;
1657 tree dtable_decl = NULL_TREE;
1658 HOST_WIDE_INT method_count = 0;
1659 tree method_array_type;
1662 tree this_class_addr;
1663 tree constant_pool_constructor;
1664 tree interfaces = null_pointer_node;
1665 int interface_len = 0;
1666 int uses_jv_markobj = 0;
1667 tree type_decl = TYPE_NAME (type);
1668 tree id_main = get_identifier("main");
1669 tree id_class = get_identifier("java.lang.Class");
1670 /** Offset from start of virtual function table declaration
1671 to where objects actually point at, following new g++ ABI. */
1672 tree dtable_start_offset = size_int (2 * POINTER_SIZE / BITS_PER_UNIT);
1673 VEC(int, heap) *field_indexes;
1674 tree first_real_field;
1676 this_class_addr = build_static_class_ref (type);
1677 decl = TREE_OPERAND (this_class_addr, 0);
1679 if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
1680 && !flag_indirect_dispatch)
1682 tree dtable = get_dispatch_table (type, this_class_addr);
1683 uses_jv_markobj = uses_jv_markobj_p (dtable);
1684 if (type == class_type_node && class_dtable_decl != NULL_TREE)
1686 /* We've already created some other class, and consequently
1687 we made class_dtable_decl. Now we just want to fill it
1689 dtable_decl = class_dtable_decl;
1693 dtable_decl = build_dtable_decl (type);
1694 TREE_STATIC (dtable_decl) = 1;
1695 DECL_ARTIFICIAL (dtable_decl) = 1;
1696 DECL_IGNORED_P (dtable_decl) = 1;
1699 TREE_PUBLIC (dtable_decl) = 1;
1700 DECL_INITIAL (dtable_decl) = dtable;
1701 /* The only dispatch table exported from a DSO is the dispatch
1702 table for java.lang.Class. */
1703 if (DECL_NAME (type_decl) != id_class)
1705 if (! flag_indirect_classes)
1706 rest_of_decl_compilation (dtable_decl, 1, 0);
1707 /* Maybe we're compiling Class as the first class. If so, set
1708 class_dtable_decl to the decl we just made. */
1709 if (type == class_type_node && class_dtable_decl == NULL_TREE)
1710 class_dtable_decl = dtable_decl;
1713 /* Build Field array. */
1714 field = TYPE_FIELDS (type);
1715 while (field && DECL_ARTIFICIAL (field))
1716 field = TREE_CHAIN (field); /* Skip dummy fields. */
1717 if (field && DECL_NAME (field) == NULL_TREE)
1718 field = TREE_CHAIN (field); /* Skip dummy field for inherited data. */
1719 first_real_field = field;
1721 /* First count static and instance fields. */
1722 for ( ; field != NULL_TREE; field = TREE_CHAIN (field))
1724 if (! DECL_ARTIFICIAL (field))
1726 if (FIELD_STATIC (field))
1727 static_field_count++;
1728 else if (uses_jv_markobj || !flag_reduced_reflection)
1729 instance_field_count++;
1732 field_count = static_field_count + instance_field_count;
1733 field_indexes = VEC_alloc (int, heap, field_count);
1735 /* gcj sorts fields so that static fields come first, followed by
1736 instance fields. Unfortunately, by the time this takes place we
1737 have already generated the reflection_data for this class, and
1738 that data contains indexes into the fields. So, we generate a
1739 permutation that maps each original field index to its final
1740 position. Then we pass this permutation to
1741 rewrite_reflection_indexes(), which fixes up the reflection
1745 int static_count = 0;
1746 int instance_count = static_field_count;
1749 for (i = 0, field = first_real_field;
1751 field = TREE_CHAIN (field), i++)
1753 if (! DECL_ARTIFICIAL (field))
1756 if (FIELD_STATIC (field))
1757 field_index = static_count++;
1758 else if (uses_jv_markobj || !flag_reduced_reflection)
1759 field_index = instance_count++;
1760 VEC_quick_push (int, field_indexes, field_index);
1765 for (field = first_real_field; field != NULL_TREE;
1766 field = TREE_CHAIN (field))
1768 if (! DECL_ARTIFICIAL (field))
1770 if (FIELD_STATIC (field))
1772 /* We must always create reflection data for static fields
1773 as it is used in the creation of the field itself. */
1774 tree init = make_field_value (field);
1775 tree initial = DECL_INITIAL (field);
1776 static_fields = tree_cons (NULL_TREE, init, static_fields);
1777 /* If the initial value is a string constant,
1778 prevent output_constant from trying to assemble the value. */
1779 if (initial != NULL_TREE
1780 && TREE_TYPE (initial) == string_ptr_type_node)
1781 DECL_INITIAL (field) = NULL_TREE;
1782 rest_of_decl_compilation (field, 1, 1);
1783 DECL_INITIAL (field) = initial;
1785 else if (uses_jv_markobj || !flag_reduced_reflection)
1787 tree init = make_field_value (field);
1788 instance_fields = tree_cons (NULL_TREE, init, instance_fields);
1793 if (field_count > 0)
1795 static_fields = nreverse (static_fields);
1796 instance_fields = nreverse (instance_fields);
1797 static_fields = chainon (static_fields, instance_fields);
1798 field_array_type = build_prim_array_type (field_type_node, field_count);
1799 fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
1801 DECL_INITIAL (fields_decl) = build_constructor_from_list
1802 (field_array_type, static_fields);
1803 TREE_STATIC (fields_decl) = 1;
1804 DECL_ARTIFICIAL (fields_decl) = 1;
1805 DECL_IGNORED_P (fields_decl) = 1;
1806 rest_of_decl_compilation (fields_decl, 1, 0);
1809 fields_decl = NULL_TREE;
1811 /* Build Method array. */
1812 for (method = TYPE_METHODS (type);
1813 method != NULL_TREE; method = TREE_CHAIN (method))
1816 if (METHOD_PRIVATE (method)
1817 && ! flag_keep_inline_functions
1820 /* Even if we have a decl, we don't necessarily have the code.
1821 This can happen if we inherit a method from a superclass for
1822 which we don't have a .class file. */
1823 if (METHOD_DUMMY (method))
1826 /* Generate method reflection data if:
1828 - !flag_reduced_reflection.
1830 - <clinit> -- The runtime uses reflection to initialize the
1833 - Any method in class java.lang.Class -- Class.forName() and
1834 perhaps other things require it.
1836 - class$ -- It does not work if reflection data missing.
1838 - main -- Reflection is used to find main(String[]) methods.
1840 - public not static -- It is potentially part of an
1841 interface. The runtime uses reflection data to build
1842 interface dispatch tables. */
1843 if (!flag_reduced_reflection
1844 || DECL_CLINIT_P (method)
1845 || DECL_NAME (type_decl) == id_class
1846 || DECL_NAME (method) == id_main
1847 || (METHOD_PUBLIC (method) && !METHOD_STATIC (method))
1848 || TYPE_DOT_CLASS (type) == method)
1850 init = make_method_value (method);
1852 methods = tree_cons (NULL_TREE, init, methods);
1855 method_array_type = build_prim_array_type (method_type_node, method_count);
1856 methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
1858 DECL_INITIAL (methods_decl) = build_constructor_from_list
1859 (method_array_type, nreverse (methods));
1860 TREE_STATIC (methods_decl) = 1;
1861 DECL_ARTIFICIAL (methods_decl) = 1;
1862 DECL_IGNORED_P (methods_decl) = 1;
1863 rest_of_decl_compilation (methods_decl, 1, 0);
1865 if (class_dtable_decl == NULL_TREE)
1867 class_dtable_decl = build_dtable_decl (class_type_node);
1868 TREE_STATIC (class_dtable_decl) = 1;
1869 DECL_ARTIFICIAL (class_dtable_decl) = 1;
1870 DECL_IGNORED_P (class_dtable_decl) = 1;
1871 if (is_compiled_class (class_type_node) != 2)
1873 DECL_EXTERNAL (class_dtable_decl) = 1;
1874 rest_of_decl_compilation (class_dtable_decl, 1, 0);
1878 super = CLASSTYPE_SUPER (type);
1879 if (super == NULL_TREE)
1880 super = null_pointer_node;
1881 else if (! flag_indirect_dispatch
1882 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
1883 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
1884 super = build_class_ref (super);
1887 int super_index = alloc_class_constant (super);
1888 super = build_int_cst (ptr_type_node, super_index);
1891 /* Build and emit the array of implemented interfaces. */
1892 if (type != object_type_node)
1893 interface_len = BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) - 1;
1895 if (interface_len > 0)
1897 tree init = NULL_TREE;
1899 tree interface_array_type, idecl;
1900 interface_array_type
1901 = build_prim_array_type (class_ptr_type, interface_len);
1902 idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type),
1903 interface_array_type);
1905 for (i = interface_len; i > 0; i--)
1907 tree child = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
1908 tree iclass = BINFO_TYPE (child);
1910 if (! flag_indirect_dispatch
1912 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))))
1913 index = build_class_ref (iclass);
1916 int int_index = alloc_class_constant (iclass);
1917 index = build_int_cst (ptr_type_node, int_index);
1919 init = tree_cons (NULL_TREE, index, init);
1921 DECL_INITIAL (idecl) = build_constructor_from_list (interface_array_type,
1923 TREE_STATIC (idecl) = 1;
1924 DECL_ARTIFICIAL (idecl) = 1;
1925 DECL_IGNORED_P (idecl) = 1;
1926 interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
1927 rest_of_decl_compilation (idecl, 1, 0);
1930 constant_pool_constructor = build_constants_constructor ();
1932 if (flag_indirect_dispatch)
1934 TYPE_OTABLE_DECL (type)
1936 (DECL_NAME (TYPE_OTABLE_DECL (type)),
1937 TYPE_OTABLE_DECL (type), TYPE_OTABLE_METHODS (type),
1938 TYPE_OTABLE_SYMS_DECL (type), integer_type_node, 1);
1940 TYPE_ATABLE_DECL (type)
1942 (DECL_NAME (TYPE_ATABLE_DECL (type)),
1943 TYPE_ATABLE_DECL (type), TYPE_ATABLE_METHODS (type),
1944 TYPE_ATABLE_SYMS_DECL (type), ptr_type_node, 1);
1946 TYPE_ITABLE_DECL (type)
1948 (DECL_NAME (TYPE_ITABLE_DECL (type)),
1949 TYPE_ITABLE_DECL (type), TYPE_ITABLE_METHODS (type),
1950 TYPE_ITABLE_SYMS_DECL (type), ptr_type_node, 2);
1953 TYPE_CTABLE_DECL (type) = emit_catch_table (type);
1955 START_RECORD_CONSTRUCTOR (temp, object_type_node);
1956 PUSH_FIELD_VALUE (temp, "vtable",
1957 (flag_indirect_classes
1959 : build2 (POINTER_PLUS_EXPR, dtable_ptr_type,
1960 build1 (ADDR_EXPR, dtable_ptr_type,
1962 dtable_start_offset)));
1963 if (! flag_hash_synchronization)
1964 PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
1965 FINISH_RECORD_CONSTRUCTOR (temp);
1966 START_RECORD_CONSTRUCTOR (cons, class_type_node);
1967 PUSH_SUPER_VALUE (cons, temp);
1968 PUSH_FIELD_VALUE (cons, "next_or_version", gcj_abi_version);
1969 PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
1970 PUSH_FIELD_VALUE (cons, "accflags",
1971 build_int_cst (NULL_TREE,
1972 get_access_flags_from_decl (type_decl)));
1974 PUSH_FIELD_VALUE (cons, "superclass",
1975 CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
1976 PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
1977 PUSH_FIELD_VALUE (cons, "methods",
1978 methods_decl == NULL_TREE ? null_pointer_node
1979 : build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
1980 PUSH_FIELD_VALUE (cons, "method_count",
1981 build_int_cst (NULL_TREE, method_count));
1983 if (flag_indirect_dispatch)
1984 PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node);
1986 PUSH_FIELD_VALUE (cons, "vtable_method_count", TYPE_NVIRTUALS (type));
1988 PUSH_FIELD_VALUE (cons, "fields",
1989 fields_decl == NULL_TREE ? null_pointer_node
1990 : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
1991 /* If we're using the binary compatibility ABI we don't know the
1992 size until load time. */
1993 PUSH_FIELD_VALUE (cons, "size_in_bytes",
1994 (flag_indirect_dispatch
1995 ? integer_minus_one_node
1996 : size_in_bytes (type)));
1997 PUSH_FIELD_VALUE (cons, "field_count",
1998 build_int_cst (NULL_TREE, field_count));
1999 PUSH_FIELD_VALUE (cons, "static_field_count",
2000 build_int_cst (NULL_TREE, static_field_count));
2002 if (flag_indirect_dispatch)
2003 PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node);
2005 PUSH_FIELD_VALUE (cons, "vtable",
2006 dtable_decl == NULL_TREE ? null_pointer_node
2007 : build2 (POINTER_PLUS_EXPR, dtable_ptr_type,
2008 build1 (ADDR_EXPR, dtable_ptr_type,
2010 dtable_start_offset));
2011 if (TYPE_OTABLE_METHODS (type) == NULL_TREE)
2013 PUSH_FIELD_VALUE (cons, "otable", null_pointer_node);
2014 PUSH_FIELD_VALUE (cons, "otable_syms", null_pointer_node);
2018 pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type));
2019 PUSH_FIELD_VALUE (cons, "otable",
2020 build1 (ADDR_EXPR, otable_ptr_type, TYPE_OTABLE_DECL (type)));
2021 PUSH_FIELD_VALUE (cons, "otable_syms",
2022 build1 (ADDR_EXPR, symbols_array_ptr_type,
2023 TYPE_OTABLE_SYMS_DECL (type)));
2024 TREE_CONSTANT (TYPE_OTABLE_DECL (type)) = 1;
2025 TREE_INVARIANT (TYPE_OTABLE_DECL (type)) = 1;
2027 if (TYPE_ATABLE_METHODS(type) == NULL_TREE)
2029 PUSH_FIELD_VALUE (cons, "atable", null_pointer_node);
2030 PUSH_FIELD_VALUE (cons, "atable_syms", null_pointer_node);
2034 pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type));
2035 PUSH_FIELD_VALUE (cons, "atable",
2036 build1 (ADDR_EXPR, atable_ptr_type, TYPE_ATABLE_DECL (type)));
2037 PUSH_FIELD_VALUE (cons, "atable_syms",
2038 build1 (ADDR_EXPR, symbols_array_ptr_type,
2039 TYPE_ATABLE_SYMS_DECL (type)));
2040 TREE_CONSTANT (TYPE_ATABLE_DECL (type)) = 1;
2041 TREE_INVARIANT (TYPE_ATABLE_DECL (type)) = 1;
2043 if (TYPE_ITABLE_METHODS(type) == NULL_TREE)
2045 PUSH_FIELD_VALUE (cons, "itable", null_pointer_node);
2046 PUSH_FIELD_VALUE (cons, "itable_syms", null_pointer_node);
2050 pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type));
2051 PUSH_FIELD_VALUE (cons, "itable",
2052 build1 (ADDR_EXPR, itable_ptr_type, TYPE_ITABLE_DECL (type)));
2053 PUSH_FIELD_VALUE (cons, "itable_syms",
2054 build1 (ADDR_EXPR, symbols_array_ptr_type,
2055 TYPE_ITABLE_SYMS_DECL (type)));
2056 TREE_CONSTANT (TYPE_ITABLE_DECL (type)) = 1;
2057 TREE_INVARIANT (TYPE_ITABLE_DECL (type)) = 1;
2060 PUSH_FIELD_VALUE (cons, "catch_classes",
2061 build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
2062 PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
2063 PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
2064 PUSH_FIELD_VALUE (cons, "interface_count",
2065 build_int_cst (NULL_TREE, interface_len));
2066 PUSH_FIELD_VALUE (cons, "state",
2067 convert (byte_type_node,
2068 build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
2070 PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
2071 PUSH_FIELD_VALUE (cons, "depth", integer_zero_node);
2072 PUSH_FIELD_VALUE (cons, "ancestors", null_pointer_node);
2073 PUSH_FIELD_VALUE (cons, "idt", null_pointer_node);
2074 PUSH_FIELD_VALUE (cons, "arrayclass", null_pointer_node);
2075 PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
2078 tree assertion_table_ref;
2079 if (TYPE_ASSERTIONS (type) == NULL)
2080 assertion_table_ref = null_pointer_node;
2082 assertion_table_ref = build1 (ADDR_EXPR,
2083 build_pointer_type (assertion_table_type),
2084 emit_assertion_table (type));
2086 PUSH_FIELD_VALUE (cons, "assertion_table", assertion_table_ref);
2089 PUSH_FIELD_VALUE (cons, "hack_signers", null_pointer_node);
2090 PUSH_FIELD_VALUE (cons, "chain", null_pointer_node);
2091 PUSH_FIELD_VALUE (cons, "aux_info", null_pointer_node);
2092 PUSH_FIELD_VALUE (cons, "engine", null_pointer_node);
2094 if (TYPE_REFLECTION_DATA (current_class))
2097 int count = TYPE_REFLECTION_DATASIZE (current_class);
2098 VEC (constructor_elt, gc) *v
2099 = VEC_alloc (constructor_elt, gc, count);
2100 unsigned char *data = TYPE_REFLECTION_DATA (current_class);
2101 tree max_index = build_int_cst (sizetype, count);
2102 tree index = build_index_type (max_index);
2103 tree type = build_array_type (unsigned_byte_type_node, index);
2106 static int reflection_data_count;
2108 sprintf (buf, "_reflection_data_%d", reflection_data_count++);
2109 array = build_decl (VAR_DECL, get_identifier (buf), type);
2111 rewrite_reflection_indexes (field_indexes);
2113 for (i = 0; i < count; i++)
2115 constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
2116 elt->index = build_int_cst (sizetype, i);
2117 elt->value = build_int_cstu (byte_type_node, data[i]);
2120 DECL_INITIAL (array) = build_constructor (type, v);
2121 TREE_STATIC (array) = 1;
2122 DECL_ARTIFICIAL (array) = 1;
2123 DECL_IGNORED_P (array) = 1;
2124 TREE_READONLY (array) = 1;
2125 TREE_CONSTANT (DECL_INITIAL (array)) = 1;
2126 rest_of_decl_compilation (array, 1, 0);
2128 PUSH_FIELD_VALUE (cons, "reflection_data", build_address_of (array));
2131 TYPE_REFLECTION_DATA (current_class) = NULL;
2134 PUSH_FIELD_VALUE (cons, "reflection_data", null_pointer_node);
2136 FINISH_RECORD_CONSTRUCTOR (cons);
2138 DECL_INITIAL (decl) = cons;
2140 /* Hash synchronization requires at least 64-bit alignment. */
2141 if (flag_hash_synchronization && POINTER_SIZE < 64)
2142 DECL_ALIGN (decl) = 64;
2144 if (flag_indirect_classes)
2146 TREE_READONLY (decl) = 1;
2147 TREE_CONSTANT (DECL_INITIAL (decl)) = 1;
2150 rest_of_decl_compilation (decl, 1, 0);
2153 tree classdollar_field = build_classdollar_field (type);
2154 if (!flag_indirect_classes)
2155 DECL_INITIAL (classdollar_field) = build_static_class_ref (type);
2156 rest_of_decl_compilation (classdollar_field, 1, 0);
2159 TYPE_OTABLE_DECL (type) = NULL_TREE;
2160 TYPE_ATABLE_DECL (type) = NULL_TREE;
2161 TYPE_CTABLE_DECL (type) = NULL_TREE;
2167 if (TYPE_VERIFY_METHOD (output_class))
2169 tree verify_method = TYPE_VERIFY_METHOD (output_class);
2170 DECL_SAVED_TREE (verify_method)
2171 = add_stmt_to_compound (DECL_SAVED_TREE (verify_method), void_type_node,
2172 build1 (RETURN_EXPR, void_type_node, NULL));
2173 java_genericize (verify_method);
2174 cgraph_finalize_function (verify_method, false);
2175 TYPE_ASSERTIONS (current_class) = NULL;
2178 java_expand_catch_classes (current_class);
2180 current_function_decl = NULL_TREE;
2181 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class)) = 0;
2182 make_class_data (current_class);
2184 rest_of_decl_compilation (TYPE_NAME (current_class), 1, 0);
2187 /* Return 2 if CLASS is compiled by this compilation job;
2188 return 1 if CLASS can otherwise be assumed to be compiled;
2189 return 0 if we cannot assume that CLASS is compiled.
2190 Returns 1 for primitive and 0 for array types. */
2192 is_compiled_class (tree class)
2195 if (TREE_CODE (class) == POINTER_TYPE)
2196 class = TREE_TYPE (class);
2197 if (TREE_CODE (class) != RECORD_TYPE) /* Primitive types are static. */
2199 if (TYPE_ARRAY_P (class))
2202 seen_in_zip = (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
2203 if (CLASS_FROM_CURRENTLY_COMPILED_P (class))
2205 /* The class was seen in the current ZIP file and will be
2206 available as a compiled class in the future but may not have
2207 been loaded already. Load it if necessary. This prevent
2208 build_class_ref () from crashing. */
2210 if (seen_in_zip && !CLASS_LOADED_P (class) && (class != current_class))
2211 load_class (class, 1);
2213 /* We return 2 for class seen in ZIP and class from files
2214 belonging to the same compilation unit */
2218 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
2220 if (!CLASS_LOADED_P (class))
2222 if (CLASS_FROM_SOURCE_P (class))
2223 safe_layout_class (class);
2224 else if (class != current_class)
2225 load_class (class, 1);
2233 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2236 build_dtable_decl (tree type)
2240 /* We need to build a new dtable type so that its size is uniquely
2241 computed when we're dealing with the class for real and not just
2242 faking it (like java.lang.Class during the initialization of the
2243 compiler.) We know we're not faking a class when CURRENT_CLASS is
2245 if (current_class == type)
2247 tree dummy = NULL_TREE;
2250 dtype = make_node (RECORD_TYPE);
2252 PUSH_FIELD (dtype, dummy, "top_offset", ptr_type_node);
2253 PUSH_FIELD (dtype, dummy, "type_info", ptr_type_node);
2255 PUSH_FIELD (dtype, dummy, "class", class_ptr_type);
2256 for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2258 tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2259 TREE_CHAIN (dummy) = tmp_field;
2260 DECL_CONTEXT (tmp_field) = dtype;
2261 DECL_ARTIFICIAL (tmp_field) = 1;
2265 PUSH_FIELD (dtype, dummy, "gc_descr", ptr_type_node);
2266 for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2268 tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2269 TREE_CHAIN (dummy) = tmp_field;
2270 DECL_CONTEXT (tmp_field) = dtype;
2271 DECL_ARTIFICIAL (tmp_field) = 1;
2275 n = TREE_VEC_LENGTH (get_dispatch_vector (type));
2276 if (TARGET_VTABLE_USES_DESCRIPTORS)
2277 n *= TARGET_VTABLE_USES_DESCRIPTORS;
2279 PUSH_FIELD (dtype, dummy, "methods",
2280 build_prim_array_type (nativecode_ptr_type_node, n));
2281 layout_type (dtype);
2284 dtype = dtable_type;
2286 decl = build_decl (VAR_DECL, get_identifier ("vt$"), dtype);
2287 DECL_CONTEXT (decl) = type;
2288 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2289 DECL_VTABLE_P (decl) = 1;
2294 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2295 fields inherited from SUPER_CLASS. */
2298 push_super_field (tree this_class, tree super_class)
2301 /* Don't insert the field if we're just re-laying the class out. */
2302 if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
2304 base_decl = build_decl (FIELD_DECL, NULL_TREE, super_class);
2305 DECL_IGNORED_P (base_decl) = 1;
2306 TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
2307 TYPE_FIELDS (this_class) = base_decl;
2308 DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
2309 DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
2312 /* Handle the different manners we may have to lay out a super class. */
2315 maybe_layout_super_class (tree super_class, tree this_class ATTRIBUTE_UNUSED)
2319 else if (TREE_CODE (super_class) == RECORD_TYPE)
2321 if (!CLASS_LOADED_P (super_class) && CLASS_FROM_SOURCE_P (super_class))
2322 safe_layout_class (super_class);
2323 if (!CLASS_LOADED_P (super_class))
2324 load_class (super_class, 1);
2326 /* We might have to layout the class before its dependency on
2327 the super class gets resolved by java_complete_class */
2328 else if (TREE_CODE (super_class) == POINTER_TYPE)
2330 if (TREE_TYPE (super_class) != NULL_TREE)
2331 super_class = TREE_TYPE (super_class);
2335 if (!TYPE_SIZE (super_class))
2336 safe_layout_class (super_class);
2341 /* safe_layout_class just makes sure that we can load a class without
2342 disrupting the current_class, input_file, input_line, etc, information
2343 about the class processed currently. */
2346 safe_layout_class (tree class)
2348 tree save_current_class = current_class;
2349 location_t save_location = input_location;
2351 layout_class (class);
2353 current_class = save_current_class;
2354 input_location = save_location;
2358 layout_class (tree this_class)
2360 tree super_class = CLASSTYPE_SUPER (this_class);
2362 class_list = tree_cons (this_class, NULL_TREE, class_list);
2363 if (CLASS_BEING_LAIDOUT (this_class))
2369 sprintf (buffer, " with '%s'",
2370 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
2371 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2373 for (current = TREE_CHAIN (class_list); current;
2374 current = TREE_CHAIN (current))
2376 tree decl = TYPE_NAME (TREE_PURPOSE (current));
2377 sprintf (buffer, "\n which inherits from '%s' (%s:%d)",
2378 IDENTIFIER_POINTER (DECL_NAME (decl)),
2379 DECL_SOURCE_FILE (decl),
2380 DECL_SOURCE_LINE (decl));
2381 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2383 obstack_1grow (&temporary_obstack, '\0');
2384 report = obstack_finish (&temporary_obstack);
2385 cyclic_inheritance_report = ggc_strdup (report);
2386 obstack_free (&temporary_obstack, report);
2387 TYPE_SIZE (this_class) = error_mark_node;
2390 CLASS_BEING_LAIDOUT (this_class) = 1;
2392 if (super_class && !CLASS_BEING_LAIDOUT (super_class))
2394 tree maybe_super_class
2395 = maybe_layout_super_class (super_class, this_class);
2396 if (maybe_super_class == NULL
2397 || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
2399 TYPE_SIZE (this_class) = error_mark_node;
2400 CLASS_BEING_LAIDOUT (this_class) = 0;
2401 class_list = TREE_CHAIN (class_list);
2404 if (TYPE_SIZE (this_class) == NULL_TREE)
2405 push_super_field (this_class, maybe_super_class);
2408 layout_type (this_class);
2410 /* Also recursively load/layout any superinterfaces, but only if
2411 class was loaded from bytecode. The source parser will take care
2413 if (!CLASS_FROM_SOURCE_P (this_class))
2416 if (TYPE_BINFO (this_class))
2418 for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class)) - 1; i > 0; i--)
2420 tree binfo = BINFO_BASE_BINFO (TYPE_BINFO (this_class), i);
2421 tree super_interface = BINFO_TYPE (binfo);
2422 tree maybe_super_interface
2423 = maybe_layout_super_class (super_interface, NULL_TREE);
2424 if (maybe_super_interface == NULL
2425 || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
2427 TYPE_SIZE (this_class) = error_mark_node;
2428 CLASS_BEING_LAIDOUT (this_class) = 0;
2429 class_list = TREE_CHAIN (class_list);
2436 /* Convert the size back to an SI integer value. */
2437 TYPE_SIZE_UNIT (this_class) =
2438 fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
2440 CLASS_BEING_LAIDOUT (this_class) = 0;
2441 class_list = TREE_CHAIN (class_list);
2445 add_miranda_methods (tree base_class, tree search_class)
2448 tree binfo, base_binfo;
2450 if (!CLASS_PARSED_P (search_class))
2451 load_class (search_class, 1);
2453 for (binfo = TYPE_BINFO (search_class), i = 1;
2454 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2457 tree elt = BINFO_TYPE (base_binfo);
2459 /* FIXME: This is totally bogus. We should not be handling
2460 Miranda methods at all if we're using the BC ABI. */
2461 if (TYPE_DUMMY (elt))
2464 /* Ensure that interface methods are seen in declared order. */
2465 if (!CLASS_LOADED_P (elt))
2466 load_class (elt, 1);
2467 layout_class_methods (elt);
2469 /* All base classes will have been laid out at this point, so the order
2470 will be correct. This code must match similar layout code in the
2472 for (method_decl = TYPE_METHODS (elt);
2473 method_decl; method_decl = TREE_CHAIN (method_decl))
2477 /* An interface can have <clinit>. */
2478 if (ID_CLINIT_P (DECL_NAME (method_decl)))
2481 sig = build_java_argument_signature (TREE_TYPE (method_decl));
2482 override = lookup_argument_method (base_class,
2483 DECL_NAME (method_decl), sig);
2484 if (override == NULL_TREE)
2486 /* Found a Miranda method. Add it. */
2488 sig = build_java_signature (TREE_TYPE (method_decl));
2490 = add_method (base_class,
2491 get_access_flags_from_decl (method_decl),
2492 DECL_NAME (method_decl), sig);
2493 METHOD_INVISIBLE (new_method) = 1;
2497 /* Try superinterfaces. */
2498 add_miranda_methods (base_class, elt);
2503 layout_class_methods (tree this_class)
2505 tree method_decl, dtable_count;
2506 tree super_class, type_name;
2508 if (TYPE_NVIRTUALS (this_class))
2511 super_class = CLASSTYPE_SUPER (this_class);
2515 super_class = maybe_layout_super_class (super_class, this_class);
2516 if (!TYPE_NVIRTUALS (super_class))
2517 layout_class_methods (super_class);
2518 dtable_count = TYPE_NVIRTUALS (super_class);
2521 dtable_count = integer_zero_node;
2523 type_name = TYPE_NAME (this_class);
2524 if (!flag_indirect_dispatch
2525 && (CLASS_ABSTRACT (type_name) || CLASS_INTERFACE (type_name)))
2527 /* An abstract class can have methods which are declared only in
2528 an implemented interface. These are called "Miranda
2529 methods". We make a dummy method entry for such methods
2531 add_miranda_methods (this_class, this_class);
2534 TYPE_METHODS (this_class) = nreverse (TYPE_METHODS (this_class));
2536 for (method_decl = TYPE_METHODS (this_class);
2537 method_decl; method_decl = TREE_CHAIN (method_decl))
2538 dtable_count = layout_class_method (this_class, super_class,
2539 method_decl, dtable_count);
2541 TYPE_NVIRTUALS (this_class) = dtable_count;
2544 /* Return the index of METHOD in INTERFACE. This index begins at 1
2545 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2547 get_interface_method_index (tree method, tree interface)
2552 for (meth = TYPE_METHODS (interface); ; meth = TREE_CHAIN (meth))
2556 /* We don't want to put <clinit> into the interface table. */
2557 if (! ID_CLINIT_P (DECL_NAME (meth)))
2559 gcc_assert (meth != NULL_TREE);
2563 /* Lay METHOD_DECL out, returning a possibly new value of
2564 DTABLE_COUNT. Also mangle the method's name. */
2567 layout_class_method (tree this_class, tree super_class,
2568 tree method_decl, tree dtable_count)
2570 tree method_name = DECL_NAME (method_decl);
2572 TREE_PUBLIC (method_decl) = 1;
2574 if (flag_indirect_classes
2575 || (METHOD_PRIVATE (method_decl) && METHOD_STATIC (method_decl)
2576 && ! METHOD_NATIVE (method_decl)
2577 && ! special_method_p (method_decl)))
2580 /* Considered external unless it is being compiled into this object
2581 file, or it was already flagged as external. */
2582 if (!DECL_EXTERNAL (method_decl))
2583 DECL_EXTERNAL (method_decl) = ((is_compiled_class (this_class) != 2)
2584 || METHOD_NATIVE (method_decl));
2586 if (ID_INIT_P (method_name))
2588 const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
2590 for (ptr = p; *ptr; )
2595 DECL_CONSTRUCTOR_P (method_decl) = 1;
2596 build_java_signature (TREE_TYPE (method_decl));
2598 else if (! METHOD_STATIC (method_decl))
2601 build_java_signature (TREE_TYPE (method_decl));
2602 bool method_override = false;
2603 tree super_method = lookup_java_method (super_class, method_name,
2605 if (super_method != NULL_TREE
2606 && ! METHOD_DUMMY (super_method))
2608 method_override = true;
2609 if (! METHOD_PUBLIC (super_method) &&
2610 ! METHOD_PROTECTED (super_method))
2612 /* Don't override private method, or default-access method in
2614 if (METHOD_PRIVATE (super_method) ||
2615 ! in_same_package (TYPE_NAME (this_class),
2616 TYPE_NAME (super_class)))
2617 method_override = false;
2620 if (method_override)
2622 tree method_index = get_method_index (super_method);
2623 set_method_index (method_decl, method_index);
2624 if (method_index == NULL_TREE
2625 && ! flag_indirect_dispatch
2626 && !CLASS_FROM_SOURCE_P (this_class)
2627 && ! DECL_ARTIFICIAL (super_method))
2628 error ("non-static method %q+D overrides static method",
2631 else if (this_class == object_type_node
2632 && (METHOD_FINAL (method_decl)
2633 || METHOD_PRIVATE (method_decl)))
2635 /* We don't generate vtable entries for final Object
2636 methods. This is simply to save space, since every
2637 object would otherwise have to define them. */
2639 else if (! METHOD_PRIVATE (method_decl)
2642 /* We generate vtable entries for final methods because they
2643 may one day be changed to non-final. */
2644 set_method_index (method_decl, dtable_count);
2645 dtable_count = fold_build2 (PLUS_EXPR, integer_type_node,
2646 dtable_count, integer_one_node);
2650 return dtable_count;
2654 register_class (void)
2658 if (!registered_class)
2659 registered_class = VEC_alloc (tree, gc, 8);
2661 if (flag_indirect_classes)
2662 node = current_class;
2664 node = TREE_OPERAND (build_class_ref (current_class), 0);
2665 VEC_safe_push (tree, gc, registered_class, node);
2668 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2669 all the classes we have emitted. */
2672 emit_indirect_register_classes (tree *list_p)
2674 tree klass, t, register_class_fn;
2677 tree init = NULL_TREE;
2678 int size = VEC_length (tree, registered_class) * 2 + 1;
2679 tree class_array_type
2680 = build_prim_array_type (ptr_type_node, size);
2681 tree cdecl = build_decl (VAR_DECL, get_identifier ("_Jv_CLS"),
2683 tree reg_class_list;
2684 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2686 init = tree_cons (NULL_TREE,
2687 fold_convert (ptr_type_node,
2688 build_static_class_ref (klass)), init);
2691 fold_convert (ptr_type_node,
2692 build_address_of (build_classdollar_field (klass))),
2695 init = tree_cons (NULL_TREE, integer_zero_node, init);
2696 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type,
2698 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2699 TREE_STATIC (cdecl) = 1;
2700 DECL_ARTIFICIAL (cdecl) = 1;
2701 DECL_IGNORED_P (cdecl) = 1;
2702 TREE_READONLY (cdecl) = 1;
2703 TREE_CONSTANT (cdecl) = 1;
2704 rest_of_decl_compilation (cdecl, 1, 0);
2705 reg_class_list = fold_convert (ptr_type_node, build_address_of (cdecl));
2707 t = build_function_type_list (void_type_node,
2708 build_pointer_type (ptr_type_node), NULL);
2709 t = build_decl (FUNCTION_DECL,
2710 get_identifier ("_Jv_RegisterNewClasses"), t);
2711 TREE_PUBLIC (t) = 1;
2712 DECL_EXTERNAL (t) = 1;
2713 register_class_fn = t;
2714 t = build_call_expr (register_class_fn, 1, reg_class_list);
2715 append_to_statement_list (t, list_p);
2719 /* Emit something to register classes at start-up time.
2721 The preferred mechanism is through the .jcr section, which contain
2722 a list of pointers to classes which get registered during constructor
2725 The fallback mechanism is to add statements to *LIST_P to call
2726 _Jv_RegisterClass for each class in this file. These statements will
2727 be added to a static constructor function for this translation unit. */
2730 emit_register_classes (tree *list_p)
2732 if (registered_class == NULL)
2735 if (flag_indirect_classes)
2737 emit_indirect_register_classes (list_p);
2741 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2742 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2743 but lack suitable crtbegin/end objects or linker support. These
2744 targets can override the default in tm.h to use the fallback mechanism. */
2745 if (TARGET_USE_JCR_SECTION)
2750 #ifdef JCR_SECTION_NAME
2751 switch_to_section (get_section (JCR_SECTION_NAME, SECTION_WRITE, NULL));
2753 /* A target has defined TARGET_USE_JCR_SECTION,
2754 but doesn't have a JCR_SECTION_NAME. */
2757 assemble_align (POINTER_SIZE);
2759 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2761 t = build_fold_addr_expr (klass);
2762 output_constant (t, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE);
2767 tree klass, t, register_class_fn;
2770 t = build_function_type_list (void_type_node, class_ptr_type, NULL);
2771 t = build_decl (FUNCTION_DECL, get_identifier ("_Jv_RegisterClass"), t);
2772 TREE_PUBLIC (t) = 1;
2773 DECL_EXTERNAL (t) = 1;
2774 register_class_fn = t;
2776 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2778 t = build_fold_addr_expr (klass);
2779 t = build_call_expr (register_class_fn, 1, t);
2780 append_to_statement_list (t, list_p);
2785 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2788 build_symbol_entry (tree decl, tree special)
2790 tree clname, name, signature, sym;
2791 clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
2792 /* ??? Constructors are given the name foo.foo all the way through
2793 the compiler, but in the method table they're all renamed
2794 foo.<init>. So, we have to do the same here unless we want an
2795 unresolved reference at runtime. */
2796 name = build_utf8_ref ((TREE_CODE (decl) == FUNCTION_DECL
2797 && DECL_CONSTRUCTOR_P (decl))
2798 ? init_identifier_node
2799 : DECL_NAME (decl));
2800 signature = build_java_signature (TREE_TYPE (decl));
2801 signature = build_utf8_ref (unmangle_classname
2802 (IDENTIFIER_POINTER (signature),
2803 IDENTIFIER_LENGTH (signature)));
2804 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2805 signature addr+1 if SPECIAL, and this indicates to the runtime
2806 system that this is a "special" symbol, i.e. one that should
2807 bypass access controls. */
2808 if (special != NULL_TREE)
2809 signature = build2 (POINTER_PLUS_EXPR, TREE_TYPE (signature), signature,
2810 fold_convert (sizetype, special));
2812 START_RECORD_CONSTRUCTOR (sym, symbol_type);
2813 PUSH_FIELD_VALUE (sym, "clname", clname);
2814 PUSH_FIELD_VALUE (sym, "name", name);
2815 PUSH_FIELD_VALUE (sym, "signature", signature);
2816 FINISH_RECORD_CONSTRUCTOR (sym);
2817 TREE_CONSTANT (sym) = 1;
2818 TREE_INVARIANT (sym) = 1;
2823 /* Emit a symbol table: used by -findirect-dispatch. */
2826 emit_symbol_table (tree name, tree the_table, tree decl_list,
2827 tree the_syms_decl, tree the_array_element_type,
2830 tree method_list, method, table, list, null_symbol;
2831 tree table_size, the_array_type;
2834 /* Only emit a table if this translation unit actually made any
2835 references via it. */
2836 if (decl_list == NULL_TREE)
2839 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2841 method_list = decl_list;
2843 while (method_list != NULL_TREE)
2845 tree special = TREE_PURPOSE (method_list);
2846 method = TREE_VALUE (method_list);
2847 list = tree_cons (NULL_TREE, build_symbol_entry (method, special), list);
2848 method_list = TREE_CHAIN (method_list);
2852 /* Terminate the list with a "null" entry. */
2853 START_RECORD_CONSTRUCTOR (null_symbol, symbol_type);
2854 PUSH_FIELD_VALUE (null_symbol, "clname", null_pointer_node);
2855 PUSH_FIELD_VALUE (null_symbol, "name", null_pointer_node);
2856 PUSH_FIELD_VALUE (null_symbol, "signature", null_pointer_node);
2857 FINISH_RECORD_CONSTRUCTOR (null_symbol);
2858 TREE_CONSTANT (null_symbol) = 1;
2859 TREE_INVARIANT (null_symbol) = 1;
2860 list = tree_cons (NULL_TREE, null_symbol, list);
2862 /* Put the list in the right order and make it a constructor. */
2863 list = nreverse (list);
2864 table = build_constructor_from_list (symbols_array_type, list);
2866 /* Make it the initial value for otable_syms and emit the decl. */
2867 DECL_INITIAL (the_syms_decl) = table;
2868 DECL_ARTIFICIAL (the_syms_decl) = 1;
2869 DECL_IGNORED_P (the_syms_decl) = 1;
2870 rest_of_decl_compilation (the_syms_decl, 1, 0);
2872 /* Now that its size is known, redefine the table as an
2873 uninitialized static array of INDEX + 1 elements. The extra entry
2874 is used by the runtime to track whether the table has been
2877 = build_index_type (build_int_cst (NULL_TREE, index * element_size + 1));
2878 the_array_type = build_array_type (the_array_element_type, table_size);
2879 the_table = build_decl (VAR_DECL, name, the_array_type);
2880 TREE_STATIC (the_table) = 1;
2881 TREE_READONLY (the_table) = 1;
2882 rest_of_decl_compilation (the_table, 1, 0);
2887 /* Make an entry for the catch_classes list. */
2889 make_catch_class_record (tree catch_class, tree classname)
2892 tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
2893 START_RECORD_CONSTRUCTOR (entry, type);
2894 PUSH_FIELD_VALUE (entry, "address", catch_class);
2895 PUSH_FIELD_VALUE (entry, "classname", classname);
2896 FINISH_RECORD_CONSTRUCTOR (entry);
2901 /* Generate the list of Throwable classes that are caught by exception
2902 handlers in this class. */
2904 emit_catch_table (tree this_class)
2906 tree table, table_size, array_type;
2907 TYPE_CATCH_CLASSES (this_class) =
2909 make_catch_class_record (null_pointer_node, null_pointer_node),
2910 TYPE_CATCH_CLASSES (this_class));
2911 TYPE_CATCH_CLASSES (this_class) = nreverse (TYPE_CATCH_CLASSES (this_class));
2912 TYPE_CATCH_CLASSES (this_class) =
2914 make_catch_class_record (null_pointer_node, null_pointer_node),
2915 TYPE_CATCH_CLASSES (this_class));
2916 table_size = build_index_type
2917 (build_int_cst (NULL_TREE,
2918 list_length (TYPE_CATCH_CLASSES (this_class))));
2920 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
2923 build_decl (VAR_DECL, DECL_NAME (TYPE_CTABLE_DECL (this_class)), array_type);
2924 DECL_INITIAL (table) =
2925 build_constructor_from_list (array_type, TYPE_CATCH_CLASSES (this_class));
2926 TREE_STATIC (table) = 1;
2927 TREE_READONLY (table) = 1;
2928 DECL_IGNORED_P (table) = 1;
2929 rest_of_decl_compilation (table, 1, 0);
2933 /* Given a type, return the signature used by
2934 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2935 same as build_java_signature() because we want the canonical array
2939 build_signature_for_libgcj (tree type)
2943 sig = build_java_signature (type);
2944 ref = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
2945 IDENTIFIER_LENGTH (sig)));
2949 /* Add an entry to the type assertion table. Callback used during hashtable
2953 add_assertion_table_entry (void **htab_entry, void *ptr)
2956 tree code_val, op1_utf8, op2_utf8;
2957 tree *list = (tree *) ptr;
2958 type_assertion *as = (type_assertion *) *htab_entry;
2960 code_val = build_int_cst (NULL_TREE, as->assertion_code);
2962 if (as->op1 == NULL_TREE)
2963 op1_utf8 = null_pointer_node;
2965 op1_utf8 = build_signature_for_libgcj (as->op1);
2967 if (as->op2 == NULL_TREE)
2968 op2_utf8 = null_pointer_node;
2970 op2_utf8 = build_signature_for_libgcj (as->op2);
2972 START_RECORD_CONSTRUCTOR (entry, assertion_entry_type);
2973 PUSH_FIELD_VALUE (entry, "assertion_code", code_val);
2974 PUSH_FIELD_VALUE (entry, "op1", op1_utf8);
2975 PUSH_FIELD_VALUE (entry, "op2", op2_utf8);
2976 FINISH_RECORD_CONSTRUCTOR (entry);
2978 *list = tree_cons (NULL_TREE, entry, *list);
2982 /* Generate the type assertion table for CLASS, and return its DECL. */
2985 emit_assertion_table (tree class)
2987 tree null_entry, ctor, table_decl;
2988 tree list = NULL_TREE;
2989 htab_t assertions_htab = TYPE_ASSERTIONS (class);
2991 /* Iterate through the hash table. */
2992 htab_traverse (assertions_htab, add_assertion_table_entry, &list);
2994 /* Finish with a null entry. */
2995 START_RECORD_CONSTRUCTOR (null_entry, assertion_entry_type);
2996 PUSH_FIELD_VALUE (null_entry, "assertion_code", integer_zero_node);
2997 PUSH_FIELD_VALUE (null_entry, "op1", null_pointer_node);
2998 PUSH_FIELD_VALUE (null_entry, "op2", null_pointer_node);
2999 FINISH_RECORD_CONSTRUCTOR (null_entry);
3001 list = tree_cons (NULL_TREE, null_entry, list);
3003 /* Put the list in the right order and make it a constructor. */
3004 list = nreverse (list);
3005 ctor = build_constructor_from_list (assertion_table_type, list);
3007 table_decl = build_decl (VAR_DECL, mangled_classname ("_type_assert_", class),
3008 assertion_table_type);
3010 TREE_STATIC (table_decl) = 1;
3011 TREE_READONLY (table_decl) = 1;
3012 TREE_CONSTANT (table_decl) = 1;
3013 DECL_IGNORED_P (table_decl) = 1;
3015 DECL_INITIAL (table_decl) = ctor;
3016 DECL_ARTIFICIAL (table_decl) = 1;
3017 rest_of_decl_compilation (table_decl, 1, 0);
3023 init_class_processing (void)
3025 fields_ident = get_identifier ("fields");
3026 info_ident = get_identifier ("info");
3028 gcc_obstack_init (&temporary_obstack);
3031 static hashval_t java_treetreehash_hash (const void *);
3032 static int java_treetreehash_compare (const void *, const void *);
3034 /* A hash table mapping trees to trees. Used generally. */
3036 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
3039 java_treetreehash_hash (const void *k_p)
3041 struct treetreehash_entry *k = (struct treetreehash_entry *) k_p;
3042 return JAVA_TREEHASHHASH_H (k->key);
3046 java_treetreehash_compare (const void * k1_p, const void * k2_p)
3048 struct treetreehash_entry * k1 = (struct treetreehash_entry *) k1_p;
3049 tree k2 = (tree) k2_p;
3050 return (k1->key == k2);
3054 java_treetreehash_find (htab_t ht, tree t)
3056 struct treetreehash_entry *e;
3057 hashval_t hv = JAVA_TREEHASHHASH_H (t);
3058 e = htab_find_with_hash (ht, t, hv);
3066 java_treetreehash_new (htab_t ht, tree t)
3069 struct treetreehash_entry *tthe;
3070 hashval_t hv = JAVA_TREEHASHHASH_H (t);
3072 e = htab_find_slot_with_hash (ht, t, hv, INSERT);
3075 tthe = (*ht->alloc_f) (1, sizeof (*tthe));
3080 tthe = (struct treetreehash_entry *) *e;
3081 return &tthe->value;
3085 java_treetreehash_create (size_t size, int gc)
3088 return htab_create_ggc (size, java_treetreehash_hash,
3089 java_treetreehash_compare, NULL);
3091 return htab_create_alloc (size, java_treetreehash_hash,
3092 java_treetreehash_compare, free, xcalloc, free);
3095 /* Break down qualified IDENTIFIER into package and class-name components.
3096 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3097 "pkg.foo", and RIGHT to "Bar". */
3100 split_qualified_name (tree *left, tree *right, tree source)
3103 int l = IDENTIFIER_LENGTH (source);
3105 base = alloca (l + 1);
3106 memcpy (base, IDENTIFIER_POINTER (source), l + 1);
3108 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3110 while (*p != '.' && p != base)
3113 /* We didn't find a '.'. Return an error. */
3119 *right = get_identifier (p+1);
3120 *left = get_identifier (base);
3125 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3126 if the classes are from the same package. */
3129 in_same_package (tree name1, tree name2)
3135 if (TREE_CODE (name1) == TYPE_DECL)
3136 name1 = DECL_NAME (name1);
3137 if (TREE_CODE (name2) == TYPE_DECL)
3138 name2 = DECL_NAME (name2);
3140 if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
3141 /* One in empty package. */
3144 if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
3145 /* Both in empty package. */
3148 split_qualified_name (&pkg1, &tmp, name1);
3149 split_qualified_name (&pkg2, &tmp, name2);
3151 return (pkg1 == pkg2);
3154 #include "gt-java-class.h"