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, 2008 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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>.
21 Java and all Java-based marks are trademarks or registered trademarks
22 of Sun Microsystems, Inc. in the United States and other countries.
23 The Free Software Foundation is independent of Sun Microsystems, Inc. */
25 /* Written by Per Bothner <bothner@cygnus.com> */
29 #include "coretypes.h"
34 #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 = (char *) 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)
319 tree ident = TYPE_NAME (type);
320 if (TREE_CODE (ident) != IDENTIFIER_NODE)
321 ident = DECL_NAME (ident);
322 result = identifier_subst (ident, prefix, '.', '_', "");
324 /* Replace any characters that aren't in the set [0-9a-zA-Z_$] with
325 "_0xXX". Class names containing such chracters are uncommon, but
326 they do sometimes occur in class files. Without this check,
327 these names cause assembly errors.
329 There is a possibility that a real class name could conflict with
330 the identifier we generate, but it is unlikely and will
331 immediately be detected as an assembler error. At some point we
332 should do something more elaborate (perhaps using the full
333 unicode mangling scheme) in order to prevent such a conflict. */
336 const int len = IDENTIFIER_LENGTH (result);
337 const char *p = IDENTIFIER_POINTER (result);
338 int illegal_chars = 0;
340 /* Make two passes over the identifier. The first pass is merely
341 to count illegal characters; we need to do this in order to
342 allocate a buffer. */
343 for (i = 0; i < len; i++)
346 illegal_chars += (! ISALNUM (c) && c != '_' && c != '$');
349 /* And the second pass, which is rarely executed, does the
351 if (illegal_chars != 0)
353 char *buffer = (char *) alloca (illegal_chars * 4 + len + 1);
356 for (i = 0, j = 0; i < len; i++)
359 if (! ISALNUM (c) && c != '_' && c != '$')
362 sprintf (&buffer[j], "0x%02x", c);
370 result = get_identifier (buffer);
381 type = make_node (RECORD_TYPE);
382 /* Unfortunately we must create the binfo here, so that class
384 TYPE_BINFO (type) = make_tree_binfo (0);
385 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
390 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
391 and where each of the constituents is separated by '/',
392 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
395 unmangle_classname (const char *name, int name_length)
397 tree to_return = ident_subst (name, name_length, "", '/', '.', "");
398 /* It's not sufficient to compare to_return and get_identifier
399 (name) to determine whether to_return is qualified. There are
400 cases in signature analysis where name will be stripped of a
402 name = IDENTIFIER_POINTER (to_return);
406 QUALIFIED_P (to_return) = 1;
413 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
416 const char *type_name = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
417 char *buf = (char *) alloca (strlen (type_name) \
418 + strlen (#NAME "_syms_") + 1); \
421 sprintf (buf, #NAME "_%s", type_name); \
422 TYPE_## TABLE ##_DECL (type) = decl = \
423 build_decl (input_location, VAR_DECL, get_identifier (buf), TABLE_TYPE); \
424 DECL_EXTERNAL (decl) = 1; \
425 TREE_STATIC (decl) = 1; \
426 TREE_READONLY (decl) = 1; \
427 TREE_CONSTANT (decl) = 1; \
428 DECL_IGNORED_P (decl) = 1; \
429 /* Mark the table as belonging to this class. */ \
431 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
432 DECL_OWNER (decl) = TYPE; \
433 sprintf (buf, #NAME "_syms_%s", type_name); \
434 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
435 build_decl (input_location, VAR_DECL, get_identifier (buf), symbols_array_type); \
436 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
437 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
438 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
442 /* Given a class, create the DECLs for all its associated indirect
445 gen_indirect_dispatch_tables (tree type)
447 const char *type_name = IDENTIFIER_POINTER (mangled_classname ("", type));
450 char *buf = (char *) alloca (strlen (type_name)
451 + strlen ("_catch_classes_") + 1);
452 tree catch_class_type = make_node (RECORD_TYPE);
454 sprintf (buf, "_catch_classes_%s", type_name);
455 PUSH_FIELD (input_location,
456 catch_class_type, field, "address", utf8const_ptr_type);
457 PUSH_FIELD (input_location,
458 catch_class_type, field, "classname", ptr_type_node);
459 FINISH_RECORD (catch_class_type);
461 TYPE_CTABLE_DECL (type)
462 = build_decl (input_location, VAR_DECL, get_identifier (buf),
463 build_array_type (catch_class_type, 0));
464 DECL_EXTERNAL (TYPE_CTABLE_DECL (type)) = 1;
465 TREE_STATIC (TYPE_CTABLE_DECL (type)) = 1;
466 TREE_READONLY (TYPE_CTABLE_DECL (type)) = 1;
467 TREE_CONSTANT (TYPE_CTABLE_DECL (type)) = 1;
468 DECL_IGNORED_P (TYPE_CTABLE_DECL (type)) = 1;
469 pushdecl (TYPE_CTABLE_DECL (type));
472 if (flag_indirect_dispatch)
474 GEN_TABLE (ATABLE, _atable, atable_type, type);
475 GEN_TABLE (OTABLE, _otable, otable_type, type);
476 GEN_TABLE (ITABLE, _itable, itable_type, type);
483 push_class (tree class_type, tree class_name)
485 tree decl, signature;
486 location_t saved_loc = input_location;
487 CLASS_P (class_type) = 1;
488 decl = build_decl (input_location, TYPE_DECL, class_name, class_type);
489 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
491 /* dbxout needs a DECL_SIZE if in gstabs mode */
492 DECL_SIZE (decl) = integer_zero_node;
494 input_location = saved_loc;
495 signature = identifier_subst (class_name, "L", '.', '/', ";");
496 IDENTIFIER_SIGNATURE_TYPE (signature) = build_pointer_type (class_type);
498 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
499 both a typedef and in the struct name-space. We may want to re-visit
500 this later, but for now it reduces the changes needed for gdb. */
501 DECL_ARTIFICIAL (decl) = 1;
503 pushdecl_top_level (decl);
508 /* Finds the (global) class named NAME. Creates the class if not found.
509 Also creates associated TYPE_DECL.
510 Does not check if the class actually exists, load the class,
511 fill in field or methods, or do layout_type. */
514 lookup_class (tree name)
516 tree decl = IDENTIFIER_CLASS_VALUE (name);
517 if (decl == NULL_TREE)
518 decl = push_class (make_class (), name);
519 return TREE_TYPE (decl);
523 set_super_info (int access_flags, tree this_class,
524 tree super_class, int interfaces_count)
526 int total_supers = interfaces_count;
527 tree class_decl = TYPE_NAME (this_class);
533 TYPE_BINFO (this_class) = make_tree_binfo (total_supers);
534 TYPE_VFIELD (this_class) = TYPE_VFIELD (object_type_node);
537 tree super_binfo = make_tree_binfo (0);
538 BINFO_TYPE (super_binfo) = super_class;
539 BINFO_OFFSET (super_binfo) = integer_zero_node;
540 BINFO_BASE_APPEND (TYPE_BINFO (this_class), super_binfo);
541 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class)) = 1;
544 set_class_decl_access_flags (access_flags, class_decl);
548 set_class_decl_access_flags (int access_flags, tree class_decl)
550 if (access_flags & ACC_PUBLIC) CLASS_PUBLIC (class_decl) = 1;
551 if (access_flags & ACC_FINAL) CLASS_FINAL (class_decl) = 1;
552 if (access_flags & ACC_SUPER) CLASS_SUPER (class_decl) = 1;
553 if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
554 if (access_flags & ACC_ABSTRACT) CLASS_ABSTRACT (class_decl) = 1;
555 if (access_flags & ACC_STATIC) CLASS_STATIC (class_decl) = 1;
556 if (access_flags & ACC_PRIVATE) CLASS_PRIVATE (class_decl) = 1;
557 if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
558 if (access_flags & ACC_STRICT) CLASS_STRICTFP (class_decl) = 1;
559 if (access_flags & ACC_ENUM) CLASS_ENUM (class_decl) = 1;
560 if (access_flags & ACC_SYNTHETIC) CLASS_SYNTHETIC (class_decl) = 1;
561 if (access_flags & ACC_ANNOTATION) CLASS_ANNOTATION (class_decl) = 1;
564 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
565 direct sub-classes of Object are 1, and so on. */
568 class_depth (tree clas)
571 if (! CLASS_LOADED_P (clas))
572 load_class (clas, 1);
573 if (TYPE_SIZE (clas) == error_mark_node)
575 while (clas != object_type_node)
578 clas = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas), 0));
583 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
586 interface_of_p (tree type1, tree type2)
589 tree binfo, base_binfo;
591 if (! TYPE_BINFO (type2))
594 for (binfo = TYPE_BINFO (type2), i = 0;
595 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
596 if (BINFO_TYPE (base_binfo) == type1)
599 for (binfo = TYPE_BINFO (type2), i = 0;
600 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) /* */
601 if (BINFO_TYPE (base_binfo)
602 && interface_of_p (type1, BINFO_TYPE (base_binfo)))
608 /* Return true iff TYPE1 inherits from TYPE2. */
611 inherits_from_p (tree type1, tree type2)
613 while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
618 if (! CLASS_LOADED_P (type1))
619 load_class (type1, 1);
621 type1 = maybe_layout_super_class (CLASSTYPE_SUPER (type1), type1);
626 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
629 enclosing_context_p (tree type1, tree type2)
631 if (!INNER_CLASS_TYPE_P (type2))
634 for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
636 type2 = (INNER_CLASS_TYPE_P (type2) ?
637 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
647 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
651 common_enclosing_context_p (tree type1, tree type2)
656 for (current = type2; current;
657 current = (INNER_CLASS_TYPE_P (current) ?
658 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
660 if (type1 == current)
663 if (INNER_CLASS_TYPE_P (type1))
664 type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1)));
671 /* Return 1 iff there exists a common enclosing "this" between TYPE1
672 and TYPE2, without crossing any static context. */
675 common_enclosing_instance_p (tree type1, tree type2)
677 if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
680 for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1;
681 type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
682 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
685 for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
686 current = (PURE_INNER_CLASS_TYPE_P (current) ?
687 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
689 if (type1 == current)
695 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
696 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
697 if attempt is made to add it twice. */
700 maybe_add_interface (tree this_class, tree interface_class)
702 tree binfo, base_binfo;
705 for (binfo = TYPE_BINFO (this_class), i = 0;
706 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
707 if (BINFO_TYPE (base_binfo) == interface_class)
708 return interface_class;
709 add_interface (this_class, interface_class);
713 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
716 add_interface (tree this_class, tree interface_class)
718 tree interface_binfo = make_tree_binfo (0);
720 BINFO_TYPE (interface_binfo) = interface_class;
721 BINFO_OFFSET (interface_binfo) = integer_zero_node;
722 BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node;
723 BINFO_VIRTUAL_P (interface_binfo) = 1;
725 BINFO_BASE_APPEND (TYPE_BINFO (this_class), interface_binfo);
729 build_java_method_type (tree fntype, tree this_class, int access_flags)
731 if (access_flags & ACC_STATIC)
733 fntype = build_method_type (this_class, fntype);
735 /* We know that arg 1 of every nonstatic method is non-null; tell
737 TYPE_ATTRIBUTES (fntype) = (tree_cons
738 (get_identifier ("nonnull"),
739 tree_cons (NULL_TREE,
740 build_int_cst (NULL_TREE, 1),
742 TYPE_ATTRIBUTES (fntype)));
747 java_hide_decl (tree decl ATTRIBUTE_UNUSED)
749 #ifdef HAVE_GAS_HIDDEN
750 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
751 DECL_VISIBILITY_SPECIFIED (decl) = 1;
756 add_method_1 (tree this_class, int access_flags, tree name, tree function_type)
758 tree method_type, fndecl;
760 method_type = build_java_method_type (function_type,
761 this_class, access_flags);
763 fndecl = build_decl (input_location, FUNCTION_DECL, name, method_type);
764 DECL_CONTEXT (fndecl) = this_class;
766 DECL_LANG_SPECIFIC (fndecl)
767 = GGC_CNEW (struct lang_decl);
768 DECL_LANG_SPECIFIC (fndecl)->desc = LANG_DECL_FUNC;
770 /* Initialize the static initializer test table. */
772 DECL_FUNCTION_INIT_TEST_TABLE (fndecl) =
773 java_treetreehash_create (10, 1);
775 /* Initialize the initialized (static) class table. */
776 if (access_flags & ACC_STATIC)
777 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) =
778 htab_create_ggc (50, htab_hash_pointer, htab_eq_pointer, NULL);
780 TREE_CHAIN (fndecl) = TYPE_METHODS (this_class);
781 TYPE_METHODS (this_class) = fndecl;
783 /* If pointers to member functions use the least significant bit to
784 indicate whether a function is virtual, ensure a pointer
785 to this function will have that bit clear. */
786 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
787 && !(access_flags & ACC_STATIC)
788 && DECL_ALIGN (fndecl) < 2 * BITS_PER_UNIT)
789 DECL_ALIGN (fndecl) = 2 * BITS_PER_UNIT;
791 /* Notice that this is a finalizer and update the class type
792 accordingly. This is used to optimize instance allocation. */
793 if (name == finalize_identifier_node
794 && TREE_TYPE (function_type) == void_type_node
795 && TREE_VALUE (TYPE_ARG_TYPES (function_type)) == void_type_node)
796 HAS_FINALIZER_P (this_class) = 1;
798 if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
799 if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
800 if (access_flags & ACC_PRIVATE)
801 METHOD_PRIVATE (fndecl) = 1;
802 if (access_flags & ACC_NATIVE)
804 METHOD_NATIVE (fndecl) = 1;
805 DECL_EXTERNAL (fndecl) = 1;
808 /* FNDECL is external unless we are compiling it into this object
810 DECL_EXTERNAL (fndecl) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class) == 0;
811 if (access_flags & ACC_STATIC)
812 METHOD_STATIC (fndecl) = 1;
813 if (access_flags & ACC_FINAL)
814 METHOD_FINAL (fndecl) = 1;
815 if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
816 if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
817 if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
818 if (access_flags & ACC_SYNTHETIC) DECL_ARTIFICIAL (fndecl) = 1;
819 if (access_flags & ACC_BRIDGE) METHOD_BRIDGE (fndecl) = 1;
820 if (access_flags & ACC_VARARGS) METHOD_VARARGS (fndecl) = 1;
824 /* Add a method to THIS_CLASS.
825 The method's name is NAME.
826 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
829 add_method (tree this_class, int access_flags, tree name, tree method_sig)
831 tree function_type, fndecl;
832 const unsigned char *sig
833 = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
836 fatal_error ("bad method signature");
838 function_type = get_type_from_signature (method_sig);
839 fndecl = add_method_1 (this_class, access_flags, name, function_type);
840 set_java_signature (TREE_TYPE (fndecl), method_sig);
845 add_field (tree klass, tree name, tree field_type, int flags)
847 int is_static = (flags & ACC_STATIC) != 0;
849 field = build_decl (input_location,
850 is_static ? VAR_DECL : FIELD_DECL, name, field_type);
851 TREE_CHAIN (field) = TYPE_FIELDS (klass);
852 TYPE_FIELDS (klass) = field;
853 DECL_CONTEXT (field) = klass;
854 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
856 if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
857 if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
858 if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
859 if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
860 if (flags & ACC_VOLATILE)
862 FIELD_VOLATILE (field) = 1;
863 TREE_THIS_VOLATILE (field) = 1;
865 if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
866 if (flags & ACC_ENUM) FIELD_ENUM (field) = 1;
867 if (flags & ACC_SYNTHETIC) FIELD_SYNTHETIC (field) = 1;
870 FIELD_STATIC (field) = 1;
871 /* Always make field externally visible. This is required so
872 that native methods can always access the field. */
873 TREE_PUBLIC (field) = 1;
874 /* Hide everything that shouldn't be visible outside a DSO. */
875 if (flag_indirect_classes
876 || (FIELD_PRIVATE (field)))
877 java_hide_decl (field);
878 /* Considered external unless we are compiling it into this
880 DECL_EXTERNAL (field) = (is_compiled_class (klass) != 2);
886 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
889 set_constant_value (tree field, tree constant)
891 if (field == NULL_TREE)
892 warning (OPT_Wattributes,
893 "misplaced ConstantValue attribute (not in any field)");
894 else if (DECL_INITIAL (field) != NULL_TREE)
895 warning (OPT_Wattributes,
896 "duplicate ConstantValue attribute for field '%s'",
897 IDENTIFIER_POINTER (DECL_NAME (field)));
900 DECL_INITIAL (field) = constant;
901 if (TREE_TYPE (constant) != TREE_TYPE (field)
902 && ! (TREE_TYPE (constant) == int_type_node
903 && INTEGRAL_TYPE_P (TREE_TYPE (field))
904 && TYPE_PRECISION (TREE_TYPE (field)) <= 32)
905 && ! (TREE_TYPE (constant) == utf8const_ptr_type
906 && TREE_TYPE (field) == string_ptr_type_node))
907 error ("ConstantValue attribute of field '%s' has wrong type",
908 IDENTIFIER_POINTER (DECL_NAME (field)));
912 /* Calculate a hash value for a string encoded in Utf8 format.
913 * This returns the same hash value as specified for java.lang.String.hashCode.
917 hashUtf8String (const char *str, int len)
919 const unsigned char* ptr = (const unsigned char*) str;
920 const unsigned char *limit = ptr + len;
924 int ch = UTF8_GET (ptr, limit);
925 /* Updated specification from
926 http://www.javasoft.com/docs/books/jls/clarify.html. */
927 hash = (31 * hash) + ch;
932 static GTY(()) tree utf8_decl_list = NULL_TREE;
935 build_utf8_ref (tree name)
937 const char * name_ptr = IDENTIFIER_POINTER (name);
938 int name_len = IDENTIFIER_LENGTH (name), name_pad;
940 tree ctype, field = NULL_TREE, str_type, cinit, string;
941 static int utf8_count = 0;
943 tree ref = IDENTIFIER_UTF8_REF (name);
945 VEC(constructor_elt,gc) *v = NULL;
946 if (ref != NULL_TREE)
949 ctype = make_node (RECORD_TYPE);
950 /* '\0' byte plus padding to utf8const_type's alignment. */
951 name_pad = TYPE_ALIGN_UNIT (utf8const_type)
952 - (name_len & (TYPE_ALIGN_UNIT (utf8const_type) - 1));
953 str_type = build_prim_array_type (unsigned_byte_type_node,
954 name_len + name_pad);
955 PUSH_FIELD (input_location, ctype, field, "hash", unsigned_short_type_node);
956 PUSH_FIELD (input_location,
957 ctype, field, "length", unsigned_short_type_node);
958 PUSH_FIELD (input_location, ctype, field, "data", str_type);
959 FINISH_RECORD (ctype);
960 START_RECORD_CONSTRUCTOR (v, ctype);
961 name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
962 PUSH_FIELD_VALUE (v, "hash", build_int_cst (NULL_TREE, name_hash));
963 PUSH_FIELD_VALUE (v, "length", build_int_cst (NULL_TREE, name_len));
964 string = build_string (name_len, name_ptr);
965 TREE_TYPE (string) = str_type;
966 PUSH_FIELD_VALUE (v, "data", string);
967 FINISH_RECORD_CONSTRUCTOR (cinit, v, ctype);
968 TREE_CONSTANT (cinit) = 1;
970 /* Generate a unique-enough identifier. */
971 sprintf(buf, "_Utf%d", ++utf8_count);
973 decl = build_decl (input_location,
974 VAR_DECL, get_identifier (buf), utf8const_type);
975 TREE_STATIC (decl) = 1;
976 DECL_ARTIFICIAL (decl) = 1;
977 DECL_IGNORED_P (decl) = 1;
978 TREE_READONLY (decl) = 1;
979 TREE_THIS_VOLATILE (decl) = 0;
980 DECL_INITIAL (decl) = cinit;
982 if (HAVE_GAS_SHF_MERGE)
985 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
986 decl_size = name_len + 4 + name_pad;
987 if (flag_merge_constants && decl_size < 256)
990 int flags = (SECTION_OVERRIDE
991 | SECTION_MERGE | (SECTION_ENTSIZE & decl_size));
992 sprintf (buf, ".rodata.jutf8.%d", decl_size);
993 switch_to_section (get_section (buf, flags, NULL));
994 DECL_SECTION_NAME (decl) = build_string (strlen (buf), buf);
998 TREE_CHAIN (decl) = utf8_decl_list;
999 layout_decl (decl, 0);
1000 DECL_SIZE (decl) = TYPE_SIZE (ctype);
1001 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (ctype);
1003 rest_of_decl_compilation (decl, global_bindings_p (), 0);
1004 varpool_mark_needed_node (varpool_node (decl));
1005 utf8_decl_list = decl;
1006 ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
1007 IDENTIFIER_UTF8_REF (name) = ref;
1011 /* Like build_class_ref, but instead of a direct reference generate a
1012 pointer into the constant pool. */
1015 build_indirect_class_ref (tree type)
1019 index = alloc_class_constant (type);
1020 cl = build_ref_from_constant_pool (index);
1021 return convert (promote_type (class_ptr_type), cl);
1025 build_static_class_ref (tree type)
1027 tree decl_name, decl, ref;
1029 if (TYPE_SIZE (type) == error_mark_node)
1030 return null_pointer_node;
1031 decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
1032 "", '/', '/', ".class$$");
1033 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1034 if (decl == NULL_TREE)
1036 decl = build_decl (input_location, VAR_DECL, decl_name, class_type_node);
1037 TREE_STATIC (decl) = 1;
1038 if (! flag_indirect_classes)
1040 TREE_PUBLIC (decl) = 1;
1041 if (CLASS_PRIVATE (TYPE_NAME (type)))
1042 java_hide_decl (decl);
1044 DECL_IGNORED_P (decl) = 1;
1045 DECL_ARTIFICIAL (decl) = 1;
1046 if (is_compiled_class (type) == 1)
1047 DECL_EXTERNAL (decl) = 1;
1048 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1049 DECL_CLASS_FIELD_P (decl) = 1;
1050 DECL_CONTEXT (decl) = type;
1052 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1053 that that means not calling pushdecl_top_level. */
1054 IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
1057 ref = build1 (ADDR_EXPR, class_ptr_type, decl);
1062 build_classdollar_field (tree type)
1064 tree decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
1065 "", '/', '/', ".class$");
1066 tree decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1068 if (decl == NULL_TREE)
1071 = build_decl (input_location,
1072 VAR_DECL, decl_name,
1075 (build_type_variant (class_type_node,
1077 /* const */ 1, 0)));
1078 TREE_STATIC (decl) = 1;
1079 TREE_CONSTANT (decl) = 1;
1080 TREE_READONLY (decl) = 1;
1081 TREE_PUBLIC (decl) = 1;
1082 java_hide_decl (decl);
1083 DECL_IGNORED_P (decl) = 1;
1084 DECL_ARTIFICIAL (decl) = 1;
1085 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1086 IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
1087 DECL_CLASS_FIELD_P (decl) = 1;
1088 DECL_CONTEXT (decl) = type;
1094 /* Create a local variable that holds the current class$. */
1097 cache_this_class_ref (tree fndecl)
1101 tree classdollar_field;
1102 if (flag_indirect_classes)
1103 classdollar_field = build_classdollar_field (output_class);
1105 classdollar_field = build_static_class_ref (output_class);
1107 this_classdollar = build_decl (input_location,
1108 VAR_DECL, NULL_TREE,
1109 TREE_TYPE (classdollar_field));
1111 java_add_local_var (this_classdollar);
1112 java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (this_classdollar),
1113 this_classdollar, classdollar_field));
1116 this_classdollar = build_classdollar_field (output_class);
1118 /* Prepend class initialization for static methods reachable from
1120 if (METHOD_STATIC (fndecl)
1121 && (! METHOD_PRIVATE (fndecl)
1122 || INNER_CLASS_P (DECL_CONTEXT (fndecl)))
1123 && ! DECL_CLINIT_P (fndecl)
1124 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl))))
1126 tree init = build_call_expr (soft_initclass_node, 1,
1128 java_add_stmt (init);
1132 /* Remove the reference to the local variable that holds the current
1136 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED)
1138 this_classdollar = build_classdollar_field (output_class);
1141 /* Build a reference to the class TYPE.
1142 Also handles primitive types and array types. */
1145 build_class_ref (tree type)
1147 int is_compiled = is_compiled_class (type);
1151 if (TREE_CODE (type) == POINTER_TYPE)
1152 type = TREE_TYPE (type);
1154 if (flag_indirect_dispatch
1155 && type != output_class
1156 && TREE_CODE (type) == RECORD_TYPE)
1157 return build_indirect_class_ref (type);
1159 if (type == output_class && flag_indirect_classes)
1161 /* This can be NULL if we see a JNI stub before we see any
1163 if (! this_classdollar)
1164 this_classdollar = build_classdollar_field (output_class);
1165 return this_classdollar;
1168 if (TREE_CODE (type) == RECORD_TYPE)
1169 return build_static_class_ref (type);
1175 decl_name = TYPE_NAME (type);
1176 if (TREE_CODE (decl_name) == TYPE_DECL)
1177 decl_name = DECL_NAME (decl_name);
1178 name = IDENTIFIER_POINTER (decl_name);
1179 if (strncmp (name, "promoted_", 9) == 0)
1181 sprintf (buffer, "_Jv_%sClass", name);
1182 decl_name = get_identifier (buffer);
1183 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1184 if (decl == NULL_TREE)
1186 decl = build_decl (input_location,
1187 VAR_DECL, decl_name, class_type_node);
1188 TREE_STATIC (decl) = 1;
1189 TREE_PUBLIC (decl) = 1;
1190 DECL_EXTERNAL (decl) = 1;
1191 DECL_ARTIFICIAL (decl) = 1;
1192 pushdecl_top_level (decl);
1196 ref = build1 (ADDR_EXPR, class_ptr_type, decl);
1200 return build_indirect_class_ref (type);
1203 /* Create a local statically allocated variable that will hold a
1204 pointer to a static field. */
1207 build_fieldref_cache_entry (int index, tree fdecl ATTRIBUTE_UNUSED)
1209 tree decl, decl_name;
1210 const char *name = IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class));
1211 char *buf = (char *) alloca (strlen (name) + 20);
1212 sprintf (buf, "%s_%d_ref", name, index);
1213 decl_name = get_identifier (buf);
1214 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1215 if (decl == NULL_TREE)
1217 decl = build_decl (input_location,
1218 VAR_DECL, decl_name, ptr_type_node);
1219 TREE_STATIC (decl) = 1;
1220 TREE_PUBLIC (decl) = 0;
1221 DECL_EXTERNAL (decl) = 0;
1222 DECL_ARTIFICIAL (decl) = 1;
1223 DECL_IGNORED_P (decl) = 1;
1224 pushdecl_top_level (decl);
1230 build_static_field_ref (tree fdecl)
1232 tree fclass = DECL_CONTEXT (fdecl);
1233 int is_compiled = is_compiled_class (fclass);
1235 /* Allow static final fields to fold to a constant. When using
1236 -findirect-dispatch, we simply never do this folding if compiling
1237 from .class; in the .class file constants will be referred to via
1238 the constant pool. */
1239 if (!flag_indirect_dispatch
1241 || (FIELD_FINAL (fdecl) && DECL_INITIAL (fdecl) != NULL_TREE
1242 && (JSTRING_TYPE_P (TREE_TYPE (fdecl))
1243 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl)))
1244 && TREE_CONSTANT (DECL_INITIAL (fdecl)))))
1246 if (is_compiled == 1)
1247 DECL_EXTERNAL (fdecl) = 1;
1251 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1252 and a class local static variable CACHE_ENTRY, then
1254 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1255 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1258 This can mostly be optimized away, so that the usual path is a
1259 load followed by a test and branch. _Jv_ResolvePoolEntry is
1260 only called once for each constant pool entry.
1262 There is an optimization that we don't do: at the start of a
1263 method, create a local copy of CACHE_ENTRY and use that instead.
1267 int cpool_index = alloc_constant_fieldref (output_class, fdecl);
1268 tree cache_entry = build_fieldref_cache_entry (cpool_index, fdecl);
1270 = build_call_expr (built_in_decls[BUILT_IN_EXPECT], 2,
1271 build2 (EQ_EXPR, boolean_type_node,
1272 cache_entry, null_pointer_node),
1273 boolean_false_node);
1274 tree cpool_index_cst = build_int_cst (NULL_TREE, cpool_index);
1276 = build_call_expr (soft_resolvepoolentry_node, 2,
1277 build_class_ref (output_class),
1279 init = build2 (MODIFY_EXPR, ptr_type_node, cache_entry, init);
1280 init = build3 (COND_EXPR, ptr_type_node, test, init, cache_entry);
1281 init = fold_convert (build_pointer_type (TREE_TYPE (fdecl)), init);
1282 fdecl = build1 (INDIRECT_REF, TREE_TYPE (fdecl), init);
1288 get_access_flags_from_decl (tree decl)
1290 int access_flags = 0;
1291 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
1293 if (FIELD_STATIC (decl))
1294 access_flags |= ACC_STATIC;
1295 if (FIELD_PUBLIC (decl))
1296 access_flags |= ACC_PUBLIC;
1297 if (FIELD_PROTECTED (decl))
1298 access_flags |= ACC_PROTECTED;
1299 if (FIELD_PRIVATE (decl))
1300 access_flags |= ACC_PRIVATE;
1301 if (FIELD_FINAL (decl))
1302 access_flags |= ACC_FINAL;
1303 if (FIELD_VOLATILE (decl))
1304 access_flags |= ACC_VOLATILE;
1305 if (FIELD_TRANSIENT (decl))
1306 access_flags |= ACC_TRANSIENT;
1307 if (FIELD_ENUM (decl))
1308 access_flags |= ACC_ENUM;
1309 if (FIELD_SYNTHETIC (decl))
1310 access_flags |= ACC_SYNTHETIC;
1311 return access_flags;
1313 if (TREE_CODE (decl) == TYPE_DECL)
1315 if (CLASS_PUBLIC (decl))
1316 access_flags |= ACC_PUBLIC;
1317 if (CLASS_FINAL (decl))
1318 access_flags |= ACC_FINAL;
1319 if (CLASS_SUPER (decl))
1320 access_flags |= ACC_SUPER;
1321 if (CLASS_INTERFACE (decl))
1322 access_flags |= ACC_INTERFACE;
1323 if (CLASS_ABSTRACT (decl))
1324 access_flags |= ACC_ABSTRACT;
1325 if (CLASS_STATIC (decl))
1326 access_flags |= ACC_STATIC;
1327 if (CLASS_PRIVATE (decl))
1328 access_flags |= ACC_PRIVATE;
1329 if (CLASS_PROTECTED (decl))
1330 access_flags |= ACC_PROTECTED;
1331 if (CLASS_STRICTFP (decl))
1332 access_flags |= ACC_STRICT;
1333 if (CLASS_ENUM (decl))
1334 access_flags |= ACC_ENUM;
1335 if (CLASS_SYNTHETIC (decl))
1336 access_flags |= ACC_SYNTHETIC;
1337 if (CLASS_ANNOTATION (decl))
1338 access_flags |= ACC_ANNOTATION;
1339 return access_flags;
1341 if (TREE_CODE (decl) == FUNCTION_DECL)
1343 if (METHOD_PUBLIC (decl))
1344 access_flags |= ACC_PUBLIC;
1345 if (METHOD_PRIVATE (decl))
1346 access_flags |= ACC_PRIVATE;
1347 if (METHOD_PROTECTED (decl))
1348 access_flags |= ACC_PROTECTED;
1349 if (METHOD_STATIC (decl))
1350 access_flags |= ACC_STATIC;
1351 if (METHOD_FINAL (decl))
1352 access_flags |= ACC_FINAL;
1353 if (METHOD_SYNCHRONIZED (decl))
1354 access_flags |= ACC_SYNCHRONIZED;
1355 if (METHOD_NATIVE (decl))
1356 access_flags |= ACC_NATIVE;
1357 if (METHOD_ABSTRACT (decl))
1358 access_flags |= ACC_ABSTRACT;
1359 if (METHOD_STRICTFP (decl))
1360 access_flags |= ACC_STRICT;
1361 if (METHOD_INVISIBLE (decl))
1362 access_flags |= ACC_INVISIBLE;
1363 if (DECL_ARTIFICIAL (decl))
1364 access_flags |= ACC_SYNTHETIC;
1365 if (METHOD_BRIDGE (decl))
1366 access_flags |= ACC_BRIDGE;
1367 if (METHOD_VARARGS (decl))
1368 access_flags |= ACC_VARARGS;
1369 return access_flags;
1374 static GTY (()) int alias_labelno = 0;
1376 /* Create a private alias for METHOD. Using this alias instead of the method
1377 decl ensures that ncode entries in the method table point to the real function
1378 at runtime, not a PLT entry. */
1381 make_local_function_alias (tree method)
1383 #ifdef ASM_OUTPUT_DEF
1386 const char *method_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method));
1387 char *name = (char *) alloca (strlen (method_name) + 2);
1388 char *buf = (char *) alloca (strlen (method_name) + 128);
1390 /* Only create aliases for local functions. */
1391 if (DECL_EXTERNAL (method))
1394 /* Prefix method_name with 'L' for the alias label. */
1396 strcpy (name + 1, method_name);
1398 ASM_GENERATE_INTERNAL_LABEL (buf, name, alias_labelno++);
1399 alias = build_decl (input_location,
1400 FUNCTION_DECL, get_identifier (buf),
1401 TREE_TYPE (method));
1402 DECL_CONTEXT (alias) = NULL;
1403 TREE_READONLY (alias) = TREE_READONLY (method);
1404 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (method);
1405 TREE_PUBLIC (alias) = 0;
1406 DECL_EXTERNAL (alias) = 0;
1407 DECL_ARTIFICIAL (alias) = 1;
1408 DECL_INITIAL (alias) = error_mark_node;
1409 TREE_ADDRESSABLE (alias) = 1;
1410 TREE_USED (alias) = 1;
1411 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
1412 if (!flag_syntax_only)
1413 assemble_alias (alias, DECL_ASSEMBLER_NAME (method));
1420 /** Make reflection data (_Jv_Field) for field FDECL. */
1423 make_field_value (tree fdecl)
1427 tree type = TREE_TYPE (fdecl);
1428 int resolved = is_compiled_class (type) && ! flag_indirect_dispatch;
1429 VEC(constructor_elt,gc) *v = NULL;
1431 START_RECORD_CONSTRUCTOR (v, field_type_node);
1432 PUSH_FIELD_VALUE (v, "name", build_utf8_ref (DECL_NAME (fdecl)));
1434 type = build_class_ref (type);
1437 tree signature = build_java_signature (type);
1439 type = build_utf8_ref (unmangle_classname
1440 (IDENTIFIER_POINTER (signature),
1441 IDENTIFIER_LENGTH (signature)));
1443 PUSH_FIELD_VALUE (v, "type", type);
1445 flags = get_access_flags_from_decl (fdecl);
1447 flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1449 PUSH_FIELD_VALUE (v, "accflags", build_int_cst (NULL_TREE, flags));
1450 PUSH_FIELD_VALUE (v, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
1453 tree field_address = integer_zero_node;
1454 if ((DECL_INITIAL (fdecl) || ! flag_indirect_classes)
1455 && FIELD_STATIC (fdecl))
1456 field_address = build_address_of (fdecl);
1460 build_constructor_from_list (field_info_union_node,
1462 ((FIELD_STATIC (fdecl)
1463 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
1464 : TYPE_FIELDS (field_info_union_node)),
1465 (FIELD_STATIC (fdecl)
1467 : byte_position (fdecl)))));
1470 FINISH_RECORD_CONSTRUCTOR (finit, v, field_type_node);
1474 /** Make reflection data (_Jv_Method) for method MDECL. */
1477 make_method_value (tree mdecl)
1479 static int method_name_count = 0;
1484 #define ACC_TRANSLATED 0x4000
1485 int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
1486 VEC(constructor_elt,gc) *v = NULL;
1488 class_decl = DECL_CONTEXT (mdecl);
1489 /* For interfaces, the index field contains the dispatch index. */
1490 if (CLASS_INTERFACE (TYPE_NAME (class_decl)))
1491 index = build_int_cst (NULL_TREE,
1492 get_interface_method_index (mdecl, class_decl));
1493 else if (!flag_indirect_dispatch && get_method_index (mdecl) != NULL_TREE)
1494 index = get_method_index (mdecl);
1496 index = integer_minus_one_node;
1498 code = null_pointer_node;
1499 if (METHOD_ABSTRACT (mdecl))
1500 code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1501 soft_abstractmethod_node);
1503 code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1504 make_local_function_alias (mdecl));
1505 START_RECORD_CONSTRUCTOR (v, method_type_node);
1506 PUSH_FIELD_VALUE (v, "name",
1507 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
1508 init_identifier_node
1509 : DECL_NAME (mdecl)));
1511 tree signature = build_java_signature (TREE_TYPE (mdecl));
1512 PUSH_FIELD_VALUE (v, "signature",
1515 (IDENTIFIER_POINTER(signature),
1516 IDENTIFIER_LENGTH(signature)))));
1518 PUSH_FIELD_VALUE (v, "accflags", build_int_cst (NULL_TREE, accflags));
1519 PUSH_FIELD_VALUE (v, "index", index);
1520 PUSH_FIELD_VALUE (v, "ncode", code);
1523 /* Compute the `throws' information for the method. */
1524 tree table = null_pointer_node;
1525 if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE)
1527 int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl));
1528 tree iter, type, array;
1531 table = tree_cons (NULL_TREE, table, NULL_TREE);
1532 for (iter = DECL_FUNCTION_THROWS (mdecl);
1534 iter = TREE_CHAIN (iter))
1536 tree sig = DECL_NAME (TYPE_NAME (TREE_VALUE (iter)));
1538 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
1539 IDENTIFIER_LENGTH (sig)));
1540 table = tree_cons (NULL_TREE, utf8, table);
1542 type = build_prim_array_type (ptr_type_node, length);
1543 table = build_constructor_from_list (type, table);
1544 /* Compute something unique enough. */
1545 sprintf (buf, "_methods%d", method_name_count++);
1546 array = build_decl (input_location,
1547 VAR_DECL, get_identifier (buf), type);
1548 DECL_INITIAL (array) = table;
1549 TREE_STATIC (array) = 1;
1550 DECL_ARTIFICIAL (array) = 1;
1551 DECL_IGNORED_P (array) = 1;
1552 rest_of_decl_compilation (array, 1, 0);
1554 table = build1 (ADDR_EXPR, ptr_type_node, array);
1557 PUSH_FIELD_VALUE (v, "throws", table);
1560 FINISH_RECORD_CONSTRUCTOR (minit, v, method_type_node);
1565 get_dispatch_vector (tree type)
1567 tree vtable = TYPE_VTABLE (type);
1569 if (vtable == NULL_TREE)
1573 tree super = CLASSTYPE_SUPER (type);
1574 HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1575 vtable = make_tree_vec (nvirtuals);
1576 TYPE_VTABLE (type) = vtable;
1577 if (super != NULL_TREE)
1579 tree super_vtable = get_dispatch_vector (super);
1581 for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1582 TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1585 for (method = TYPE_METHODS (type); method != NULL_TREE;
1586 method = TREE_CHAIN (method))
1588 tree method_index = get_method_index (method);
1589 if (method_index != NULL_TREE
1590 && host_integerp (method_index, 0))
1591 TREE_VEC_ELT (vtable, tree_low_cst (method_index, 0)) = method;
1599 get_dispatch_table (tree type, tree this_class_addr)
1601 int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1602 tree vtable = get_dispatch_vector (type);
1604 tree list = NULL_TREE;
1605 int nvirtuals = TREE_VEC_LENGTH (vtable);
1609 for (i = nvirtuals; --i >= 0; )
1611 tree method = TREE_VEC_ELT (vtable, i);
1612 if (METHOD_ABSTRACT (method))
1615 warning_at (DECL_SOURCE_LOCATION (method), 0,
1616 "abstract method in non-abstract class");
1618 if (TARGET_VTABLE_USES_DESCRIPTORS)
1619 for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1620 list = tree_cons (NULL_TREE, null_pointer_node, list);
1622 list = tree_cons (NULL_TREE, null_pointer_node, list);
1626 if (TARGET_VTABLE_USES_DESCRIPTORS)
1627 for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1629 tree fdesc = build2 (FDESC_EXPR, nativecode_ptr_type_node,
1630 method, build_int_cst (NULL_TREE, j));
1631 TREE_CONSTANT (fdesc) = 1;
1632 list = tree_cons (NULL_TREE, fdesc, list);
1635 list = tree_cons (NULL_TREE,
1636 build1 (ADDR_EXPR, nativecode_ptr_type_node,
1642 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1643 using the Boehm GC we sometimes stash a GC type descriptor
1644 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1645 the emitted byte count during the output to the assembly file. */
1646 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1647 fake "function descriptor". It's first word is the is the class
1648 pointer, and subsequent words (usually one) contain the GC descriptor.
1649 In all other cases, we reserve two extra vtable slots. */
1650 gc_descr = get_boehm_type_descriptor (type);
1651 list = tree_cons (NULL_TREE, gc_descr, list);
1652 for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
1653 list = tree_cons (NULL_TREE, gc_descr, list);
1654 list = tree_cons (NULL_TREE, this_class_addr, list);
1656 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1657 list = tree_cons (NULL_TREE, null_pointer_node, list);
1658 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1659 list = tree_cons (integer_zero_node, null_pointer_node, list);
1661 arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
1662 if (TARGET_VTABLE_USES_DESCRIPTORS)
1663 arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
1665 return build_constructor_from_list
1666 (build_prim_array_type (nativecode_ptr_type_node,
1671 /* Set the method_index for a method decl. */
1673 set_method_index (tree decl, tree method_index)
1675 if (method_index != NULL_TREE)
1677 /* method_index is null if we're using indirect dispatch. */
1678 method_index = fold (convert (sizetype, method_index));
1680 if (TARGET_VTABLE_USES_DESCRIPTORS)
1681 /* Add one to skip bogus descriptor for class and GC descriptor. */
1682 method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
1684 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1686 method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1689 DECL_VINDEX (decl) = method_index;
1692 /* Get the method_index for a method decl. */
1694 get_method_index (tree decl)
1696 tree method_index = DECL_VINDEX (decl);
1701 if (TARGET_VTABLE_USES_DESCRIPTORS)
1702 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1703 method_index = size_binop (MINUS_EXPR, method_index, size_int (1));
1705 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1706 method_index = size_binop (MINUS_EXPR, method_index, size_int (2));
1708 return method_index;
1712 supers_all_compiled (tree type)
1714 while (type != NULL_TREE)
1716 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
1718 type = CLASSTYPE_SUPER (type);
1724 add_table_and_syms (VEC(constructor_elt,gc) **v,
1726 const char *table_name, tree table_slot, tree table_type,
1727 const char *syms_name, tree syms_slot)
1729 if (method_slot == NULL_TREE)
1731 PUSH_FIELD_VALUE (*v, table_name, null_pointer_node);
1732 PUSH_FIELD_VALUE (*v, syms_name, null_pointer_node);
1736 pushdecl_top_level (syms_slot);
1737 PUSH_FIELD_VALUE (*v, table_name,
1738 build1 (ADDR_EXPR, table_type, table_slot));
1739 PUSH_FIELD_VALUE (*v, syms_name,
1740 build1 (ADDR_EXPR, symbols_array_ptr_type,
1742 TREE_CONSTANT (table_slot) = 1;
1747 make_class_data (tree type)
1749 tree decl, cons, temp;
1750 tree field, fields_decl;
1751 tree static_fields = NULL_TREE;
1752 tree instance_fields = NULL_TREE;
1753 HOST_WIDE_INT static_field_count = 0;
1754 HOST_WIDE_INT instance_field_count = 0;
1755 HOST_WIDE_INT field_count;
1756 tree field_array_type;
1758 tree methods = NULL_TREE;
1759 tree dtable_decl = NULL_TREE;
1760 HOST_WIDE_INT method_count = 0;
1761 tree method_array_type;
1764 tree this_class_addr;
1765 tree constant_pool_constructor;
1766 tree interfaces = null_pointer_node;
1767 int interface_len = 0;
1768 int uses_jv_markobj = 0;
1769 tree type_decl = TYPE_NAME (type);
1770 tree id_main = get_identifier("main");
1771 tree id_class = get_identifier("java.lang.Class");
1772 /** Offset from start of virtual function table declaration
1773 to where objects actually point at, following new g++ ABI. */
1774 tree dtable_start_offset = size_int (2 * POINTER_SIZE / BITS_PER_UNIT);
1775 VEC(int, heap) *field_indexes;
1776 tree first_real_field;
1777 VEC(constructor_elt,gc) *v1 = NULL, *v2 = NULL;
1778 tree reflection_data;
1780 this_class_addr = build_static_class_ref (type);
1781 decl = TREE_OPERAND (this_class_addr, 0);
1783 if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
1784 && !flag_indirect_dispatch)
1786 tree dtable = get_dispatch_table (type, this_class_addr);
1787 uses_jv_markobj = uses_jv_markobj_p (dtable);
1788 if (type == class_type_node && class_dtable_decl != NULL_TREE)
1790 /* We've already created some other class, and consequently
1791 we made class_dtable_decl. Now we just want to fill it
1793 dtable_decl = class_dtable_decl;
1797 dtable_decl = build_dtable_decl (type);
1798 TREE_STATIC (dtable_decl) = 1;
1799 DECL_ARTIFICIAL (dtable_decl) = 1;
1800 DECL_IGNORED_P (dtable_decl) = 1;
1803 TREE_PUBLIC (dtable_decl) = 1;
1804 DECL_INITIAL (dtable_decl) = dtable;
1805 /* The only dispatch table exported from a DSO is the dispatch
1806 table for java.lang.Class. */
1807 if (DECL_NAME (type_decl) != id_class)
1808 java_hide_decl (dtable_decl);
1809 if (! flag_indirect_classes)
1810 rest_of_decl_compilation (dtable_decl, 1, 0);
1811 /* Maybe we're compiling Class as the first class. If so, set
1812 class_dtable_decl to the decl we just made. */
1813 if (type == class_type_node && class_dtable_decl == NULL_TREE)
1814 class_dtable_decl = dtable_decl;
1817 /* Build Field array. */
1818 field = TYPE_FIELDS (type);
1819 while (field && DECL_ARTIFICIAL (field))
1820 field = TREE_CHAIN (field); /* Skip dummy fields. */
1821 if (field && DECL_NAME (field) == NULL_TREE)
1822 field = TREE_CHAIN (field); /* Skip dummy field for inherited data. */
1823 first_real_field = field;
1825 /* First count static and instance fields. */
1826 for ( ; field != NULL_TREE; field = TREE_CHAIN (field))
1828 if (! DECL_ARTIFICIAL (field))
1830 if (FIELD_STATIC (field))
1831 static_field_count++;
1832 else if (uses_jv_markobj || !flag_reduced_reflection)
1833 instance_field_count++;
1836 field_count = static_field_count + instance_field_count;
1837 field_indexes = VEC_alloc (int, heap, field_count);
1839 /* gcj sorts fields so that static fields come first, followed by
1840 instance fields. Unfortunately, by the time this takes place we
1841 have already generated the reflection_data for this class, and
1842 that data contains indexes into the fields. So, we generate a
1843 permutation that maps each original field index to its final
1844 position. Then we pass this permutation to
1845 rewrite_reflection_indexes(), which fixes up the reflection
1849 int static_count = 0;
1850 int instance_count = static_field_count;
1853 for (i = 0, field = first_real_field;
1855 field = TREE_CHAIN (field), i++)
1857 if (! DECL_ARTIFICIAL (field))
1860 if (FIELD_STATIC (field))
1861 field_index = static_count++;
1862 else if (uses_jv_markobj || !flag_reduced_reflection)
1863 field_index = instance_count++;
1866 VEC_quick_push (int, field_indexes, field_index);
1871 for (field = first_real_field; field != NULL_TREE;
1872 field = TREE_CHAIN (field))
1874 if (! DECL_ARTIFICIAL (field))
1876 if (FIELD_STATIC (field))
1878 /* We must always create reflection data for static fields
1879 as it is used in the creation of the field itself. */
1880 tree init = make_field_value (field);
1881 tree initial = DECL_INITIAL (field);
1882 static_fields = tree_cons (NULL_TREE, init, static_fields);
1883 /* If the initial value is a string constant,
1884 prevent output_constant from trying to assemble the value. */
1885 if (initial != NULL_TREE
1886 && TREE_TYPE (initial) == string_ptr_type_node)
1887 DECL_INITIAL (field) = NULL_TREE;
1888 rest_of_decl_compilation (field, 1, 1);
1889 DECL_INITIAL (field) = initial;
1891 else if (uses_jv_markobj || !flag_reduced_reflection)
1893 tree init = make_field_value (field);
1894 instance_fields = tree_cons (NULL_TREE, init, instance_fields);
1899 if (field_count > 0)
1901 static_fields = nreverse (static_fields);
1902 instance_fields = nreverse (instance_fields);
1903 static_fields = chainon (static_fields, instance_fields);
1904 field_array_type = build_prim_array_type (field_type_node, field_count);
1905 fields_decl = build_decl (input_location,
1906 VAR_DECL, mangled_classname ("_FL_", type),
1908 DECL_INITIAL (fields_decl) = build_constructor_from_list
1909 (field_array_type, static_fields);
1910 TREE_STATIC (fields_decl) = 1;
1911 DECL_ARTIFICIAL (fields_decl) = 1;
1912 DECL_IGNORED_P (fields_decl) = 1;
1913 rest_of_decl_compilation (fields_decl, 1, 0);
1916 fields_decl = NULL_TREE;
1918 /* Build Method array. */
1919 for (method = TYPE_METHODS (type);
1920 method != NULL_TREE; method = TREE_CHAIN (method))
1923 if (METHOD_PRIVATE (method)
1924 && ! flag_keep_inline_functions
1927 /* Even if we have a decl, we don't necessarily have the code.
1928 This can happen if we inherit a method from a superclass for
1929 which we don't have a .class file. */
1930 if (METHOD_DUMMY (method))
1933 /* Generate method reflection data if:
1935 - !flag_reduced_reflection.
1937 - <clinit> -- The runtime uses reflection to initialize the
1940 - Any method in class java.lang.Class -- Class.forName() and
1941 perhaps other things require it.
1943 - class$ -- It does not work if reflection data missing.
1945 - main -- Reflection is used to find main(String[]) methods.
1947 - public not static -- It is potentially part of an
1948 interface. The runtime uses reflection data to build
1949 interface dispatch tables. */
1950 if (!flag_reduced_reflection
1951 || DECL_CLINIT_P (method)
1952 || DECL_NAME (type_decl) == id_class
1953 || DECL_NAME (method) == id_main
1954 || (METHOD_PUBLIC (method) && !METHOD_STATIC (method)))
1956 init = make_method_value (method);
1958 methods = tree_cons (NULL_TREE, init, methods);
1961 method_array_type = build_prim_array_type (method_type_node, method_count);
1962 methods_decl = build_decl (input_location,
1963 VAR_DECL, mangled_classname ("_MT_", type),
1965 DECL_INITIAL (methods_decl) = build_constructor_from_list
1966 (method_array_type, nreverse (methods));
1967 TREE_STATIC (methods_decl) = 1;
1968 DECL_ARTIFICIAL (methods_decl) = 1;
1969 DECL_IGNORED_P (methods_decl) = 1;
1970 rest_of_decl_compilation (methods_decl, 1, 0);
1972 if (class_dtable_decl == NULL_TREE)
1974 class_dtable_decl = build_dtable_decl (class_type_node);
1975 TREE_STATIC (class_dtable_decl) = 1;
1976 DECL_ARTIFICIAL (class_dtable_decl) = 1;
1977 DECL_IGNORED_P (class_dtable_decl) = 1;
1978 if (is_compiled_class (class_type_node) != 2)
1980 DECL_EXTERNAL (class_dtable_decl) = 1;
1981 rest_of_decl_compilation (class_dtable_decl, 1, 0);
1985 super = CLASSTYPE_SUPER (type);
1986 if (super == NULL_TREE)
1987 super = null_pointer_node;
1988 else if (! flag_indirect_dispatch
1989 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
1990 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
1991 super = build_class_ref (super);
1994 int super_index = alloc_class_constant (super);
1995 super = build_int_cst (ptr_type_node, super_index);
1998 /* Build and emit the array of implemented interfaces. */
1999 if (type != object_type_node)
2000 interface_len = BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) - 1;
2002 if (interface_len > 0)
2004 tree init = NULL_TREE;
2006 tree interface_array_type, idecl;
2007 interface_array_type
2008 = build_prim_array_type (class_ptr_type, interface_len);
2009 idecl = build_decl (input_location,
2010 VAR_DECL, mangled_classname ("_IF_", type),
2011 interface_array_type);
2013 for (i = interface_len; i > 0; i--)
2015 tree child = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
2016 tree iclass = BINFO_TYPE (child);
2018 if (! flag_indirect_dispatch
2020 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))))
2021 index = build_class_ref (iclass);
2024 int int_index = alloc_class_constant (iclass);
2025 index = build_int_cst (ptr_type_node, int_index);
2027 init = tree_cons (NULL_TREE, index, init);
2029 DECL_INITIAL (idecl) = build_constructor_from_list (interface_array_type,
2031 TREE_STATIC (idecl) = 1;
2032 DECL_ARTIFICIAL (idecl) = 1;
2033 DECL_IGNORED_P (idecl) = 1;
2034 interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
2035 rest_of_decl_compilation (idecl, 1, 0);
2038 constant_pool_constructor = build_constants_constructor ();
2040 if (flag_indirect_dispatch)
2042 TYPE_OTABLE_DECL (type)
2044 (DECL_NAME (TYPE_OTABLE_DECL (type)),
2045 TYPE_OTABLE_DECL (type), TYPE_OTABLE_METHODS (type),
2046 TYPE_OTABLE_SYMS_DECL (type), integer_type_node, 1);
2048 TYPE_ATABLE_DECL (type)
2050 (DECL_NAME (TYPE_ATABLE_DECL (type)),
2051 TYPE_ATABLE_DECL (type), TYPE_ATABLE_METHODS (type),
2052 TYPE_ATABLE_SYMS_DECL (type), ptr_type_node, 1);
2054 TYPE_ITABLE_DECL (type)
2056 (DECL_NAME (TYPE_ITABLE_DECL (type)),
2057 TYPE_ITABLE_DECL (type), TYPE_ITABLE_METHODS (type),
2058 TYPE_ITABLE_SYMS_DECL (type), ptr_type_node, 2);
2061 TYPE_CTABLE_DECL (type) = emit_catch_table (type);
2063 START_RECORD_CONSTRUCTOR (v1, object_type_node);
2064 PUSH_FIELD_VALUE (v1, "vtable",
2065 (flag_indirect_classes
2067 : build2 (POINTER_PLUS_EXPR, dtable_ptr_type,
2068 build1 (ADDR_EXPR, dtable_ptr_type,
2070 dtable_start_offset)));
2071 if (! flag_hash_synchronization)
2072 PUSH_FIELD_VALUE (v1, "sync_info", null_pointer_node);
2073 FINISH_RECORD_CONSTRUCTOR (temp, v1, object_type_node);
2074 START_RECORD_CONSTRUCTOR (v2, class_type_node);
2075 PUSH_SUPER_VALUE (v2, temp);
2076 PUSH_FIELD_VALUE (v2, "next_or_version", gcj_abi_version);
2077 PUSH_FIELD_VALUE (v2, "name", build_utf8_ref (DECL_NAME (type_decl)));
2078 PUSH_FIELD_VALUE (v2, "accflags",
2079 build_int_cst (NULL_TREE,
2080 get_access_flags_from_decl (type_decl)));
2082 PUSH_FIELD_VALUE (v2, "superclass",
2083 CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
2084 PUSH_FIELD_VALUE (v2, "constants", constant_pool_constructor);
2085 PUSH_FIELD_VALUE (v2, "methods",
2086 methods_decl == NULL_TREE ? null_pointer_node
2087 : build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
2088 PUSH_FIELD_VALUE (v2, "method_count",
2089 build_int_cst (NULL_TREE, method_count));
2091 PUSH_FIELD_VALUE (v2, "vtable_method_count",
2092 (flag_indirect_dispatch
2093 ? integer_minus_one_node
2094 : TYPE_NVIRTUALS (type)));
2096 PUSH_FIELD_VALUE (v2, "fields",
2097 fields_decl == NULL_TREE ? null_pointer_node
2098 : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
2099 /* If we're using the binary compatibility ABI we don't know the
2100 size until load time. */
2101 PUSH_FIELD_VALUE (v2, "size_in_bytes",
2102 (flag_indirect_dispatch
2103 ? integer_minus_one_node
2104 : size_in_bytes (type)));
2105 PUSH_FIELD_VALUE (v2, "field_count",
2106 build_int_cst (NULL_TREE, field_count));
2107 PUSH_FIELD_VALUE (v2, "static_field_count",
2108 build_int_cst (NULL_TREE, static_field_count));
2110 PUSH_FIELD_VALUE (v2, "vtable",
2111 (flag_indirect_dispatch || dtable_decl == NULL_TREE
2113 : build2 (POINTER_PLUS_EXPR, dtable_ptr_type,
2114 build1 (ADDR_EXPR, dtable_ptr_type,
2116 dtable_start_offset)));
2117 add_table_and_syms (&v2, TYPE_OTABLE_METHODS (type),
2118 "otable", TYPE_OTABLE_DECL (type), otable_ptr_type,
2119 "otable_syms", TYPE_OTABLE_SYMS_DECL (type));
2120 add_table_and_syms (&v2, TYPE_ATABLE_METHODS (type),
2121 "atable", TYPE_ATABLE_DECL (type), atable_ptr_type,
2122 "atable_syms", TYPE_ATABLE_SYMS_DECL (type));
2123 add_table_and_syms (&v2, TYPE_ITABLE_METHODS (type),
2124 "itable", TYPE_ITABLE_DECL (type), itable_ptr_type,
2125 "itable_syms", TYPE_ITABLE_SYMS_DECL (type));
2127 PUSH_FIELD_VALUE (v2, "catch_classes",
2128 build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
2129 PUSH_FIELD_VALUE (v2, "interfaces", interfaces);
2130 PUSH_FIELD_VALUE (v2, "loader", null_pointer_node);
2131 PUSH_FIELD_VALUE (v2, "interface_count",
2132 build_int_cst (NULL_TREE, interface_len));
2133 PUSH_FIELD_VALUE (v2, "state",
2134 convert (byte_type_node,
2135 build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
2137 PUSH_FIELD_VALUE (v2, "thread", null_pointer_node);
2138 PUSH_FIELD_VALUE (v2, "depth", integer_zero_node);
2139 PUSH_FIELD_VALUE (v2, "ancestors", null_pointer_node);
2140 PUSH_FIELD_VALUE (v2, "idt", null_pointer_node);
2141 PUSH_FIELD_VALUE (v2, "arrayclass", null_pointer_node);
2142 PUSH_FIELD_VALUE (v2, "protectionDomain", null_pointer_node);
2145 tree assertion_table_ref;
2146 if (TYPE_ASSERTIONS (type) == NULL)
2147 assertion_table_ref = null_pointer_node;
2149 assertion_table_ref = build1 (ADDR_EXPR,
2150 build_pointer_type (assertion_table_type),
2151 emit_assertion_table (type));
2153 PUSH_FIELD_VALUE (v2, "assertion_table", assertion_table_ref);
2156 PUSH_FIELD_VALUE (v2, "hack_signers", null_pointer_node);
2157 PUSH_FIELD_VALUE (v2, "chain", null_pointer_node);
2158 PUSH_FIELD_VALUE (v2, "aux_info", null_pointer_node);
2159 PUSH_FIELD_VALUE (v2, "engine", null_pointer_node);
2161 if (TYPE_REFLECTION_DATA (current_class))
2164 int count = TYPE_REFLECTION_DATASIZE (current_class);
2165 VEC (constructor_elt, gc) *v
2166 = VEC_alloc (constructor_elt, gc, count);
2167 unsigned char *data = TYPE_REFLECTION_DATA (current_class);
2168 tree max_index = build_int_cst (sizetype, count);
2169 tree index = build_index_type (max_index);
2170 tree type = build_array_type (unsigned_byte_type_node, index);
2173 static int reflection_data_count;
2175 sprintf (buf, "_reflection_data_%d", reflection_data_count++);
2176 array = build_decl (input_location,
2177 VAR_DECL, get_identifier (buf), type);
2179 rewrite_reflection_indexes (field_indexes);
2181 for (i = 0; i < count; i++)
2183 constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
2184 elt->index = build_int_cst (sizetype, i);
2185 elt->value = build_int_cstu (byte_type_node, data[i]);
2188 DECL_INITIAL (array) = build_constructor (type, v);
2189 TREE_STATIC (array) = 1;
2190 DECL_ARTIFICIAL (array) = 1;
2191 DECL_IGNORED_P (array) = 1;
2192 TREE_READONLY (array) = 1;
2193 TREE_CONSTANT (DECL_INITIAL (array)) = 1;
2194 rest_of_decl_compilation (array, 1, 0);
2196 reflection_data = build_address_of (array);
2199 TYPE_REFLECTION_DATA (current_class) = NULL;
2202 reflection_data = null_pointer_node;
2204 PUSH_FIELD_VALUE (v2, "reflection_data", reflection_data);
2205 FINISH_RECORD_CONSTRUCTOR (cons, v2, class_type_node);
2207 DECL_INITIAL (decl) = cons;
2209 /* Hash synchronization requires at least 64-bit alignment. */
2210 if (flag_hash_synchronization && POINTER_SIZE < 64)
2211 DECL_ALIGN (decl) = 64;
2213 if (flag_indirect_classes)
2215 TREE_READONLY (decl) = 1;
2216 TREE_CONSTANT (DECL_INITIAL (decl)) = 1;
2219 rest_of_decl_compilation (decl, 1, 0);
2222 tree classdollar_field = build_classdollar_field (type);
2223 if (!flag_indirect_classes)
2224 DECL_INITIAL (classdollar_field) = build_static_class_ref (type);
2225 rest_of_decl_compilation (classdollar_field, 1, 0);
2228 TYPE_OTABLE_DECL (type) = NULL_TREE;
2229 TYPE_ATABLE_DECL (type) = NULL_TREE;
2230 TYPE_CTABLE_DECL (type) = NULL_TREE;
2236 java_expand_catch_classes (current_class);
2238 current_function_decl = NULL_TREE;
2239 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class)) = 0;
2240 make_class_data (current_class);
2242 rest_of_decl_compilation (TYPE_NAME (current_class), 1, 0);
2245 /* Return 2 if KLASS is compiled by this compilation job;
2246 return 1 if KLASS can otherwise be assumed to be compiled;
2247 return 0 if we cannot assume that KLASS is compiled.
2248 Returns 1 for primitive and 0 for array types. */
2250 is_compiled_class (tree klass)
2253 if (TREE_CODE (klass) == POINTER_TYPE)
2254 klass = TREE_TYPE (klass);
2255 if (TREE_CODE (klass) != RECORD_TYPE) /* Primitive types are static. */
2257 if (TYPE_ARRAY_P (klass))
2260 seen_in_zip = (TYPE_JCF (klass) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass)));
2261 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass))
2263 /* The class was seen in the current ZIP file and will be
2264 available as a compiled class in the future but may not have
2265 been loaded already. Load it if necessary. This prevent
2266 build_class_ref () from crashing. */
2268 if (seen_in_zip && !CLASS_LOADED_P (klass) && (klass != current_class))
2269 load_class (klass, 1);
2271 /* We return 2 for class seen in ZIP and class from files
2272 belonging to the same compilation unit */
2276 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass)))))
2278 if (!CLASS_LOADED_P (klass))
2280 if (klass != current_class)
2281 load_class (klass, 1);
2289 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2292 build_dtable_decl (tree type)
2296 /* We need to build a new dtable type so that its size is uniquely
2297 computed when we're dealing with the class for real and not just
2298 faking it (like java.lang.Class during the initialization of the
2299 compiler.) We know we're not faking a class when CURRENT_CLASS is
2301 if (current_class == type)
2303 tree dummy = NULL_TREE;
2306 dtype = make_node (RECORD_TYPE);
2308 PUSH_FIELD (input_location, dtype, dummy, "top_offset", ptr_type_node);
2309 PUSH_FIELD (input_location, dtype, dummy, "type_info", ptr_type_node);
2311 PUSH_FIELD (input_location, dtype, dummy, "class", class_ptr_type);
2312 for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2314 tree tmp_field = build_decl (input_location,
2315 FIELD_DECL, NULL_TREE, ptr_type_node);
2316 TREE_CHAIN (dummy) = tmp_field;
2317 DECL_CONTEXT (tmp_field) = dtype;
2318 DECL_ARTIFICIAL (tmp_field) = 1;
2322 PUSH_FIELD (input_location, dtype, dummy, "gc_descr", ptr_type_node);
2323 for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2325 tree tmp_field = build_decl (input_location,
2326 FIELD_DECL, NULL_TREE, ptr_type_node);
2327 TREE_CHAIN (dummy) = tmp_field;
2328 DECL_CONTEXT (tmp_field) = dtype;
2329 DECL_ARTIFICIAL (tmp_field) = 1;
2333 n = TREE_VEC_LENGTH (get_dispatch_vector (type));
2334 if (TARGET_VTABLE_USES_DESCRIPTORS)
2335 n *= TARGET_VTABLE_USES_DESCRIPTORS;
2337 PUSH_FIELD (input_location, dtype, dummy, "methods",
2338 build_prim_array_type (nativecode_ptr_type_node, n));
2339 layout_type (dtype);
2342 dtype = dtable_type;
2344 decl = build_decl (input_location,
2345 VAR_DECL, get_identifier ("vt$"), dtype);
2346 DECL_CONTEXT (decl) = type;
2347 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2348 DECL_VTABLE_P (decl) = 1;
2353 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2354 fields inherited from SUPER_CLASS. */
2357 push_super_field (tree this_class, tree super_class)
2360 /* Don't insert the field if we're just re-laying the class out. */
2361 if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
2363 base_decl = build_decl (input_location,
2364 FIELD_DECL, NULL_TREE, super_class);
2365 DECL_IGNORED_P (base_decl) = 1;
2366 TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
2367 TYPE_FIELDS (this_class) = base_decl;
2368 DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
2369 DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
2372 /* Handle the different manners we may have to lay out a super class. */
2375 maybe_layout_super_class (tree super_class, tree this_class ATTRIBUTE_UNUSED)
2379 else if (TREE_CODE (super_class) == RECORD_TYPE)
2381 if (!CLASS_LOADED_P (super_class))
2382 load_class (super_class, 1);
2384 /* We might have to layout the class before its dependency on
2385 the super class gets resolved by java_complete_class */
2386 else if (TREE_CODE (super_class) == POINTER_TYPE)
2388 if (TREE_TYPE (super_class) != NULL_TREE)
2389 super_class = TREE_TYPE (super_class);
2393 if (!TYPE_SIZE (super_class))
2394 safe_layout_class (super_class);
2399 /* safe_layout_class just makes sure that we can load a class without
2400 disrupting the current_class, input_file, input_line, etc, information
2401 about the class processed currently. */
2404 safe_layout_class (tree klass)
2406 tree save_current_class = current_class;
2407 location_t save_location = input_location;
2409 layout_class (klass);
2411 current_class = save_current_class;
2412 input_location = save_location;
2416 layout_class (tree this_class)
2419 tree super_class = CLASSTYPE_SUPER (this_class);
2421 class_list = tree_cons (this_class, NULL_TREE, class_list);
2422 if (CLASS_BEING_LAIDOUT (this_class))
2428 sprintf (buffer, " with '%s'",
2429 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
2430 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2432 for (current = TREE_CHAIN (class_list); current;
2433 current = TREE_CHAIN (current))
2435 tree decl = TYPE_NAME (TREE_PURPOSE (current));
2436 sprintf (buffer, "\n which inherits from '%s' (%s:%d)",
2437 IDENTIFIER_POINTER (DECL_NAME (decl)),
2438 DECL_SOURCE_FILE (decl),
2439 DECL_SOURCE_LINE (decl));
2440 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2442 obstack_1grow (&temporary_obstack, '\0');
2443 report = XOBFINISH (&temporary_obstack, char *);
2444 cyclic_inheritance_report = ggc_strdup (report);
2445 obstack_free (&temporary_obstack, report);
2446 TYPE_SIZE (this_class) = error_mark_node;
2449 CLASS_BEING_LAIDOUT (this_class) = 1;
2451 if (super_class && !CLASS_BEING_LAIDOUT (super_class))
2453 tree maybe_super_class
2454 = maybe_layout_super_class (super_class, this_class);
2455 if (maybe_super_class == NULL
2456 || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
2458 TYPE_SIZE (this_class) = error_mark_node;
2459 CLASS_BEING_LAIDOUT (this_class) = 0;
2460 class_list = TREE_CHAIN (class_list);
2463 if (TYPE_SIZE (this_class) == NULL_TREE)
2464 push_super_field (this_class, maybe_super_class);
2467 layout_type (this_class);
2469 /* Also recursively load/layout any superinterfaces. */
2470 if (TYPE_BINFO (this_class))
2472 for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class)) - 1; i > 0; i--)
2474 tree binfo = BINFO_BASE_BINFO (TYPE_BINFO (this_class), i);
2475 tree super_interface = BINFO_TYPE (binfo);
2476 tree maybe_super_interface
2477 = maybe_layout_super_class (super_interface, NULL_TREE);
2478 if (maybe_super_interface == NULL
2479 || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
2481 TYPE_SIZE (this_class) = error_mark_node;
2482 CLASS_BEING_LAIDOUT (this_class) = 0;
2483 class_list = TREE_CHAIN (class_list);
2489 /* Convert the size back to an SI integer value. */
2490 TYPE_SIZE_UNIT (this_class) =
2491 fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
2493 CLASS_BEING_LAIDOUT (this_class) = 0;
2494 class_list = TREE_CHAIN (class_list);
2498 add_miranda_methods (tree base_class, tree search_class)
2501 tree binfo, base_binfo;
2503 if (!CLASS_PARSED_P (search_class))
2504 load_class (search_class, 1);
2506 for (binfo = TYPE_BINFO (search_class), i = 1;
2507 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2510 tree elt = BINFO_TYPE (base_binfo);
2512 /* FIXME: This is totally bogus. We should not be handling
2513 Miranda methods at all if we're using the BC ABI. */
2514 if (TYPE_DUMMY (elt))
2517 /* Ensure that interface methods are seen in declared order. */
2518 if (!CLASS_LOADED_P (elt))
2519 load_class (elt, 1);
2520 layout_class_methods (elt);
2522 /* All base classes will have been laid out at this point, so the order
2523 will be correct. This code must match similar layout code in the
2525 for (method_decl = TYPE_METHODS (elt);
2526 method_decl; method_decl = TREE_CHAIN (method_decl))
2530 /* An interface can have <clinit>. */
2531 if (ID_CLINIT_P (DECL_NAME (method_decl)))
2534 sig = build_java_argument_signature (TREE_TYPE (method_decl));
2535 override = lookup_argument_method (base_class,
2536 DECL_NAME (method_decl), sig);
2537 if (override == NULL_TREE)
2539 /* Found a Miranda method. Add it. */
2541 sig = build_java_signature (TREE_TYPE (method_decl));
2543 = add_method (base_class,
2544 get_access_flags_from_decl (method_decl),
2545 DECL_NAME (method_decl), sig);
2546 METHOD_INVISIBLE (new_method) = 1;
2550 /* Try superinterfaces. */
2551 add_miranda_methods (base_class, elt);
2556 layout_class_methods (tree this_class)
2558 tree method_decl, dtable_count;
2559 tree super_class, type_name;
2561 if (TYPE_NVIRTUALS (this_class))
2564 super_class = CLASSTYPE_SUPER (this_class);
2568 super_class = maybe_layout_super_class (super_class, this_class);
2569 if (!TYPE_NVIRTUALS (super_class))
2570 layout_class_methods (super_class);
2571 dtable_count = TYPE_NVIRTUALS (super_class);
2574 dtable_count = integer_zero_node;
2576 type_name = TYPE_NAME (this_class);
2577 if (!flag_indirect_dispatch
2578 && (CLASS_ABSTRACT (type_name) || CLASS_INTERFACE (type_name)))
2580 /* An abstract class can have methods which are declared only in
2581 an implemented interface. These are called "Miranda
2582 methods". We make a dummy method entry for such methods
2584 add_miranda_methods (this_class, this_class);
2587 TYPE_METHODS (this_class) = nreverse (TYPE_METHODS (this_class));
2589 for (method_decl = TYPE_METHODS (this_class);
2590 method_decl; method_decl = TREE_CHAIN (method_decl))
2591 dtable_count = layout_class_method (this_class, super_class,
2592 method_decl, dtable_count);
2594 TYPE_NVIRTUALS (this_class) = dtable_count;
2597 /* Return the index of METHOD in INTERFACE. This index begins at 1
2598 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2600 get_interface_method_index (tree method, tree interface)
2605 for (meth = TYPE_METHODS (interface); ; meth = TREE_CHAIN (meth))
2609 /* We don't want to put <clinit> into the interface table. */
2610 if (! ID_CLINIT_P (DECL_NAME (meth)))
2612 gcc_assert (meth != NULL_TREE);
2616 /* Lay METHOD_DECL out, returning a possibly new value of
2617 DTABLE_COUNT. Also mangle the method's name. */
2620 layout_class_method (tree this_class, tree super_class,
2621 tree method_decl, tree dtable_count)
2623 tree method_name = DECL_NAME (method_decl);
2625 TREE_PUBLIC (method_decl) = 1;
2627 if (flag_indirect_classes
2628 || (METHOD_PRIVATE (method_decl) && METHOD_STATIC (method_decl)
2629 && ! METHOD_NATIVE (method_decl)
2630 && ! special_method_p (method_decl)))
2631 java_hide_decl (method_decl);
2633 /* Considered external unless it is being compiled into this object
2634 file, or it was already flagged as external. */
2635 if (!DECL_EXTERNAL (method_decl))
2636 DECL_EXTERNAL (method_decl) = ((is_compiled_class (this_class) != 2)
2637 || METHOD_NATIVE (method_decl));
2639 if (ID_INIT_P (method_name))
2641 const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
2643 for (ptr = p; *ptr; )
2648 DECL_CONSTRUCTOR_P (method_decl) = 1;
2649 build_java_signature (TREE_TYPE (method_decl));
2651 else if (! METHOD_STATIC (method_decl))
2654 build_java_signature (TREE_TYPE (method_decl));
2655 bool method_override = false;
2656 tree super_method = lookup_java_method (super_class, method_name,
2658 if (super_method != NULL_TREE
2659 && ! METHOD_DUMMY (super_method))
2661 method_override = true;
2662 if (! METHOD_PUBLIC (super_method) &&
2663 ! METHOD_PROTECTED (super_method))
2665 /* Don't override private method, or default-access method in
2667 if (METHOD_PRIVATE (super_method) ||
2668 ! in_same_package (TYPE_NAME (this_class),
2669 TYPE_NAME (super_class)))
2670 method_override = false;
2673 if (method_override)
2675 tree method_index = get_method_index (super_method);
2676 set_method_index (method_decl, method_index);
2677 if (method_index == NULL_TREE
2678 && ! flag_indirect_dispatch
2679 && ! DECL_ARTIFICIAL (super_method))
2680 error ("non-static method %q+D overrides static method",
2683 else if (this_class == object_type_node
2684 && (METHOD_FINAL (method_decl)
2685 || METHOD_PRIVATE (method_decl)))
2687 /* We don't generate vtable entries for final Object
2688 methods. This is simply to save space, since every
2689 object would otherwise have to define them. */
2691 else if (! METHOD_PRIVATE (method_decl)
2694 /* We generate vtable entries for final methods because they
2695 may one day be changed to non-final. */
2696 set_method_index (method_decl, dtable_count);
2697 dtable_count = fold_build2 (PLUS_EXPR, integer_type_node,
2698 dtable_count, integer_one_node);
2702 return dtable_count;
2706 register_class (void)
2710 if (!registered_class)
2711 registered_class = VEC_alloc (tree, gc, 8);
2713 if (flag_indirect_classes)
2714 node = current_class;
2716 node = TREE_OPERAND (build_class_ref (current_class), 0);
2717 VEC_safe_push (tree, gc, registered_class, node);
2720 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2721 all the classes we have emitted. */
2724 emit_indirect_register_classes (tree *list_p)
2726 tree klass, t, register_class_fn;
2729 tree init = NULL_TREE;
2730 int size = VEC_length (tree, registered_class) * 2 + 1;
2731 tree class_array_type
2732 = build_prim_array_type (ptr_type_node, size);
2733 tree cdecl = build_decl (input_location,
2734 VAR_DECL, get_identifier ("_Jv_CLS"),
2736 tree reg_class_list;
2737 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2739 init = tree_cons (NULL_TREE,
2740 fold_convert (ptr_type_node,
2741 build_static_class_ref (klass)), init);
2744 fold_convert (ptr_type_node,
2745 build_address_of (build_classdollar_field (klass))),
2748 init = tree_cons (NULL_TREE, integer_zero_node, init);
2749 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type,
2751 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2752 TREE_STATIC (cdecl) = 1;
2753 DECL_ARTIFICIAL (cdecl) = 1;
2754 DECL_IGNORED_P (cdecl) = 1;
2755 TREE_READONLY (cdecl) = 1;
2756 TREE_CONSTANT (cdecl) = 1;
2757 rest_of_decl_compilation (cdecl, 1, 0);
2758 reg_class_list = fold_convert (ptr_type_node, build_address_of (cdecl));
2760 t = build_function_type_list (void_type_node,
2761 build_pointer_type (ptr_type_node), NULL);
2762 t = build_decl (input_location,
2764 get_identifier ("_Jv_RegisterNewClasses"), t);
2765 TREE_PUBLIC (t) = 1;
2766 DECL_EXTERNAL (t) = 1;
2767 register_class_fn = t;
2768 t = build_call_expr (register_class_fn, 1, reg_class_list);
2769 append_to_statement_list (t, list_p);
2773 /* Emit something to register classes at start-up time.
2775 The preferred mechanism is through the .jcr section, which contain
2776 a list of pointers to classes which get registered during constructor
2779 The fallback mechanism is to add statements to *LIST_P to call
2780 _Jv_RegisterClass for each class in this file. These statements will
2781 be added to a static constructor function for this translation unit. */
2784 emit_register_classes (tree *list_p)
2786 if (registered_class == NULL)
2789 if (flag_indirect_classes)
2791 emit_indirect_register_classes (list_p);
2795 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2796 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2797 but lack suitable crtbegin/end objects or linker support. These
2798 targets can override the default in tm.h to use the fallback mechanism. */
2799 if (TARGET_USE_JCR_SECTION)
2804 #ifdef JCR_SECTION_NAME
2805 switch_to_section (get_section (JCR_SECTION_NAME, SECTION_WRITE, NULL));
2807 /* A target has defined TARGET_USE_JCR_SECTION,
2808 but doesn't have a JCR_SECTION_NAME. */
2811 assemble_align (POINTER_SIZE);
2813 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2815 t = build_fold_addr_expr (klass);
2816 output_constant (t, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE);
2821 tree klass, t, register_class_fn;
2824 t = build_function_type_list (void_type_node, class_ptr_type, NULL);
2825 t = build_decl (input_location,
2826 FUNCTION_DECL, get_identifier ("_Jv_RegisterClass"), t);
2827 TREE_PUBLIC (t) = 1;
2828 DECL_EXTERNAL (t) = 1;
2829 register_class_fn = t;
2831 for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2833 t = build_fold_addr_expr (klass);
2834 t = build_call_expr (register_class_fn, 1, t);
2835 append_to_statement_list (t, list_p);
2840 /* Build a constructor for an entry in the symbol table. */
2843 build_symbol_table_entry (tree clname, tree name, tree signature)
2846 VEC(constructor_elt,gc) *v = NULL;
2848 START_RECORD_CONSTRUCTOR (v, symbol_type);
2849 PUSH_FIELD_VALUE (v, "clname", clname);
2850 PUSH_FIELD_VALUE (v, "name", name);
2851 PUSH_FIELD_VALUE (v, "signature", signature);
2852 FINISH_RECORD_CONSTRUCTOR (symbol, v, symbol_type);
2853 TREE_CONSTANT (symbol) = 1;
2858 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2861 build_symbol_entry (tree decl, tree special)
2863 tree clname, name, signature;
2864 clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
2865 /* ??? Constructors are given the name foo.foo all the way through
2866 the compiler, but in the method table they're all renamed
2867 foo.<init>. So, we have to do the same here unless we want an
2868 unresolved reference at runtime. */
2869 name = build_utf8_ref ((TREE_CODE (decl) == FUNCTION_DECL
2870 && DECL_CONSTRUCTOR_P (decl))
2871 ? init_identifier_node
2872 : DECL_NAME (decl));
2873 signature = build_java_signature (TREE_TYPE (decl));
2874 signature = build_utf8_ref (unmangle_classname
2875 (IDENTIFIER_POINTER (signature),
2876 IDENTIFIER_LENGTH (signature)));
2877 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2878 signature addr+1 if SPECIAL, and this indicates to the runtime
2879 system that this is a "special" symbol, i.e. one that should
2880 bypass access controls. */
2881 if (special != NULL_TREE)
2882 signature = build2 (POINTER_PLUS_EXPR, TREE_TYPE (signature), signature,
2883 fold_convert (sizetype, special));
2885 return build_symbol_table_entry (clname, name, signature);
2888 /* Emit a symbol table: used by -findirect-dispatch. */
2891 emit_symbol_table (tree name, tree the_table, tree decl_list,
2892 tree the_syms_decl, tree the_array_element_type,
2895 tree method_list, method, table, list, null_symbol;
2896 tree table_size, the_array_type;
2899 /* Only emit a table if this translation unit actually made any
2900 references via it. */
2901 if (decl_list == NULL_TREE)
2904 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2906 method_list = decl_list;
2908 while (method_list != NULL_TREE)
2910 tree special = TREE_PURPOSE (method_list);
2911 method = TREE_VALUE (method_list);
2912 list = tree_cons (NULL_TREE, build_symbol_entry (method, special), list);
2913 method_list = TREE_CHAIN (method_list);
2917 /* Terminate the list with a "null" entry. */
2918 null_symbol = build_symbol_table_entry (null_pointer_node,
2921 list = tree_cons (NULL_TREE, null_symbol, list);
2923 /* Put the list in the right order and make it a constructor. */
2924 list = nreverse (list);
2925 table = build_constructor_from_list (symbols_array_type, list);
2927 /* Make it the initial value for otable_syms and emit the decl. */
2928 DECL_INITIAL (the_syms_decl) = table;
2929 DECL_ARTIFICIAL (the_syms_decl) = 1;
2930 DECL_IGNORED_P (the_syms_decl) = 1;
2931 rest_of_decl_compilation (the_syms_decl, 1, 0);
2933 /* Now that its size is known, redefine the table as an
2934 uninitialized static array of INDEX + 1 elements. The extra entry
2935 is used by the runtime to track whether the table has been
2938 = build_index_type (build_int_cst (NULL_TREE, index * element_size + 1));
2939 the_array_type = build_array_type (the_array_element_type, table_size);
2940 the_table = build_decl (input_location,
2941 VAR_DECL, name, the_array_type);
2942 TREE_STATIC (the_table) = 1;
2943 TREE_READONLY (the_table) = 1;
2944 rest_of_decl_compilation (the_table, 1, 0);
2949 /* Make an entry for the catch_classes list. */
2951 make_catch_class_record (tree catch_class, tree classname)
2954 tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
2955 VEC(constructor_elt,gc) *v = NULL;
2956 START_RECORD_CONSTRUCTOR (v, type);
2957 PUSH_FIELD_VALUE (v, "address", catch_class);
2958 PUSH_FIELD_VALUE (v, "classname", classname);
2959 FINISH_RECORD_CONSTRUCTOR (entry, v, type);
2964 /* Generate the list of Throwable classes that are caught by exception
2965 handlers in this class. */
2967 emit_catch_table (tree this_class)
2969 tree table, table_size, array_type;
2970 TYPE_CATCH_CLASSES (this_class) =
2972 make_catch_class_record (null_pointer_node, null_pointer_node),
2973 TYPE_CATCH_CLASSES (this_class));
2974 TYPE_CATCH_CLASSES (this_class) = nreverse (TYPE_CATCH_CLASSES (this_class));
2975 TYPE_CATCH_CLASSES (this_class) =
2977 make_catch_class_record (null_pointer_node, null_pointer_node),
2978 TYPE_CATCH_CLASSES (this_class));
2979 table_size = build_index_type
2980 (build_int_cst (NULL_TREE,
2981 list_length (TYPE_CATCH_CLASSES (this_class))));
2983 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
2986 build_decl (input_location,
2987 VAR_DECL, DECL_NAME (TYPE_CTABLE_DECL (this_class)), array_type);
2988 DECL_INITIAL (table) =
2989 build_constructor_from_list (array_type, TYPE_CATCH_CLASSES (this_class));
2990 TREE_STATIC (table) = 1;
2991 TREE_READONLY (table) = 1;
2992 DECL_IGNORED_P (table) = 1;
2993 rest_of_decl_compilation (table, 1, 0);
2997 /* Given a type, return the signature used by
2998 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2999 same as build_java_signature() because we want the canonical array
3003 build_signature_for_libgcj (tree type)
3007 sig = build_java_signature (type);
3008 ref = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
3009 IDENTIFIER_LENGTH (sig)));
3013 /* Build an entry in the type assertion table. */
3016 build_assertion_table_entry (tree code, tree op1, tree op2)
3018 VEC(constructor_elt,gc) *v = NULL;
3021 START_RECORD_CONSTRUCTOR (v, assertion_entry_type);
3022 PUSH_FIELD_VALUE (v, "assertion_code", code);
3023 PUSH_FIELD_VALUE (v, "op1", op1);
3024 PUSH_FIELD_VALUE (v, "op2", op2);
3025 FINISH_RECORD_CONSTRUCTOR (entry, v, assertion_entry_type);
3030 /* Add an entry to the type assertion table. Callback used during hashtable
3034 add_assertion_table_entry (void **htab_entry, void *ptr)
3037 tree code_val, op1_utf8, op2_utf8;
3038 tree *list = (tree *) ptr;
3039 type_assertion *as = (type_assertion *) *htab_entry;
3041 code_val = build_int_cst (NULL_TREE, as->assertion_code);
3043 if (as->op1 == NULL_TREE)
3044 op1_utf8 = null_pointer_node;
3046 op1_utf8 = build_signature_for_libgcj (as->op1);
3048 if (as->op2 == NULL_TREE)
3049 op2_utf8 = null_pointer_node;
3051 op2_utf8 = build_signature_for_libgcj (as->op2);
3053 entry = build_assertion_table_entry (code_val, op1_utf8, op2_utf8);
3055 *list = tree_cons (NULL_TREE, entry, *list);
3059 /* Generate the type assertion table for KLASS, and return its DECL. */
3062 emit_assertion_table (tree klass)
3064 tree null_entry, ctor, table_decl;
3065 tree list = NULL_TREE;
3066 htab_t assertions_htab = TYPE_ASSERTIONS (klass);
3068 /* Iterate through the hash table. */
3069 htab_traverse (assertions_htab, add_assertion_table_entry, &list);
3071 /* Finish with a null entry. */
3072 null_entry = build_assertion_table_entry (integer_zero_node,
3076 list = tree_cons (NULL_TREE, null_entry, list);
3078 /* Put the list in the right order and make it a constructor. */
3079 list = nreverse (list);
3080 ctor = build_constructor_from_list (assertion_table_type, list);
3082 table_decl = build_decl (input_location,
3083 VAR_DECL, mangled_classname ("_type_assert_", klass),
3084 assertion_table_type);
3086 TREE_STATIC (table_decl) = 1;
3087 TREE_READONLY (table_decl) = 1;
3088 TREE_CONSTANT (table_decl) = 1;
3089 DECL_IGNORED_P (table_decl) = 1;
3091 DECL_INITIAL (table_decl) = ctor;
3092 DECL_ARTIFICIAL (table_decl) = 1;
3093 rest_of_decl_compilation (table_decl, 1, 0);
3099 init_class_processing (void)
3101 fields_ident = get_identifier ("fields");
3102 info_ident = get_identifier ("info");
3104 gcc_obstack_init (&temporary_obstack);
3107 static hashval_t java_treetreehash_hash (const void *);
3108 static int java_treetreehash_compare (const void *, const void *);
3110 /* A hash table mapping trees to trees. Used generally. */
3112 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3115 java_treetreehash_hash (const void *k_p)
3117 const struct treetreehash_entry *const k
3118 = (const struct treetreehash_entry *) k_p;
3119 return JAVA_TREEHASHHASH_H (k->key);
3123 java_treetreehash_compare (const void * k1_p, const void * k2_p)
3125 const struct treetreehash_entry *const k1
3126 = (const struct treetreehash_entry *) k1_p;
3127 const_tree const k2 = (const_tree) k2_p;
3128 return (k1->key == k2);
3132 java_treetreehash_find (htab_t ht, tree t)
3134 struct treetreehash_entry *e;
3135 hashval_t hv = JAVA_TREEHASHHASH_H (t);
3136 e = (struct treetreehash_entry *) htab_find_with_hash (ht, t, hv);
3144 java_treetreehash_new (htab_t ht, tree t)
3147 struct treetreehash_entry *tthe;
3148 hashval_t hv = JAVA_TREEHASHHASH_H (t);
3150 e = htab_find_slot_with_hash (ht, t, hv, INSERT);
3153 tthe = (struct treetreehash_entry *) (*ht->alloc_f) (1, sizeof (*tthe));
3158 tthe = (struct treetreehash_entry *) *e;
3159 return &tthe->value;
3163 java_treetreehash_create (size_t size, int gc)
3166 return htab_create_ggc (size, java_treetreehash_hash,
3167 java_treetreehash_compare, NULL);
3169 return htab_create_alloc (size, java_treetreehash_hash,
3170 java_treetreehash_compare, free, xcalloc, free);
3173 /* Break down qualified IDENTIFIER into package and class-name components.
3174 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3175 "pkg.foo", and RIGHT to "Bar". */
3178 split_qualified_name (tree *left, tree *right, tree source)
3181 int l = IDENTIFIER_LENGTH (source);
3183 base = (char *) alloca (l + 1);
3184 memcpy (base, IDENTIFIER_POINTER (source), l + 1);
3186 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3188 while (*p != '.' && p != base)
3191 /* We didn't find a '.'. Return an error. */
3197 *right = get_identifier (p+1);
3198 *left = get_identifier (base);
3203 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3204 if the classes are from the same package. */
3207 in_same_package (tree name1, tree name2)
3213 if (TREE_CODE (name1) == TYPE_DECL)
3214 name1 = DECL_NAME (name1);
3215 if (TREE_CODE (name2) == TYPE_DECL)
3216 name2 = DECL_NAME (name2);
3218 if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
3219 /* One in empty package. */
3222 if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
3223 /* Both in empty package. */
3226 split_qualified_name (&pkg1, &tmp, name1);
3227 split_qualified_name (&pkg2, &tmp, name2);
3229 return (pkg1 == pkg2);
3232 #include "gt-java-class.h"