1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>.
20 Java and all Java-based marks are trademarks or registered trademarks
21 of Sun Microsystems, Inc. in the United States and other countries.
22 The Free Software Foundation is independent of Sun Microsystems, Inc. */
24 /* Written by Per Bothner <bothner@cygnus.com> */
28 #include "coretypes.h"
30 #include "stringpool.h"
31 #include "stor-layout.h"
34 #include "java-tree.h"
37 #include "diagnostic-core.h"
39 #include "output.h" /* for switch_to_section and get_section */
46 #include "hard-reg-set.h"
52 #include "plugin-api.h"
55 #include "tree-iterator.h"
58 static tree
make_method_value (tree
);
59 static tree
build_java_method_type (tree
, tree
, int);
60 static int32
hashUtf8String (const char *, int);
61 static tree
make_field_value (tree
);
62 static tree
get_dispatch_vector (tree
);
63 static tree
get_dispatch_table (tree
, tree
);
64 static int supers_all_compiled (tree type
);
65 static tree
maybe_layout_super_class (tree
, tree
);
66 static void add_miranda_methods (tree
, tree
);
67 static int assume_compiled (const char *);
68 static tree
build_symbol_entry (tree
, tree
);
69 static tree
emit_assertion_table (tree
);
70 static void register_class (void);
72 struct obstack temporary_obstack
;
74 static const char *cyclic_inheritance_report
;
76 /* The compiler generates different code depending on whether or not
77 it can assume certain classes have been compiled down to native
78 code or not. The compiler options -fassume-compiled= and
79 -fno-assume-compiled= are used to create a tree of
80 class_flag_node objects. This tree is queried to determine if
81 a class is assume to be compiled or not. Each node in the tree
82 represents either a package or a specific class. */
84 typedef struct class_flag_node_struct
86 /* The class or package name. */
89 /* Nonzero if this represents an exclusion. */
92 /* Pointers to other nodes in the tree. */
93 struct class_flag_node_struct
*parent
;
94 struct class_flag_node_struct
*sibling
;
95 struct class_flag_node_struct
*child
;
98 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
99 static void add_class_flag (class_flag_node
**, const char *, int);
101 /* This is the root of the include/exclude tree. */
103 static class_flag_node
*assume_compiled_tree
;
105 static class_flag_node
*enable_assert_tree
;
107 static GTY(()) tree class_roots
[4];
108 #define fields_ident class_roots[0] /* get_identifier ("fields") */
109 #define info_ident class_roots[1] /* get_identifier ("info") */
110 #define class_list class_roots[2]
111 #define class_dtable_decl class_roots[3]
113 static GTY(()) vec
<tree
, va_gc
> *registered_class
;
115 /* A tree that returns the address of the class$ of the class
116 currently being compiled. */
117 static GTY(()) tree this_classdollar
;
119 /* A list of static class fields. This is to emit proper debug
121 vec
<tree
, va_gc
> *pending_static_fields
;
123 /* Return the node that most closely represents the class whose name
124 is IDENT. Start the search from NODE (followed by its siblings).
125 Return NULL if an appropriate node does not exist. */
127 static class_flag_node
*
128 find_class_flag_node (class_flag_node
*node
, const char *ident
)
132 size_t node_ident_length
= strlen (node
->ident
);
134 /* node_ident_length is zero at the root of the tree. If the
135 identifiers are the same length, then we have matching
136 classes. Otherwise check if we've matched an enclosing
139 if (node_ident_length
== 0
140 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
141 && (ident
[node_ident_length
] == '\0'
142 || ident
[node_ident_length
] == '.')))
144 /* We've found a match, however, there might be a more
147 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
154 /* No match yet. Continue through the sibling list. */
155 node
= node
->sibling
;
158 /* No match at all in this tree. */
163 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
165 class_flag_node
*root
= *rootp
;
166 class_flag_node
*parent
, *node
;
168 /* Create the root of the tree if it doesn't exist yet. */
172 root
= XNEW (class_flag_node
);
175 root
->sibling
= NULL
;
181 /* Calling the function with the empty string means we're setting
182 value for the root of the hierarchy. */
190 /* Find the parent node for this new node. PARENT will either be a
191 class or a package name. Adjust PARENT accordingly. */
193 parent
= find_class_flag_node (root
, ident
);
194 if (strcmp (ident
, parent
->ident
) == 0)
195 parent
->value
= value
;
198 /* Insert new node into the tree. */
199 node
= XNEW (class_flag_node
);
201 node
->ident
= xstrdup (ident
);
205 node
->parent
= parent
;
206 node
->sibling
= parent
->child
;
207 parent
->child
= node
;
211 /* Add a new IDENT to the include/exclude tree. It's an exclusion
212 if EXCLUDEP is nonzero. */
215 add_assume_compiled (const char *ident
, int excludep
)
217 add_class_flag (&assume_compiled_tree
, ident
, excludep
);
220 /* The default value returned by enable_assertions. */
222 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
224 /* Enter IDENT (a class or package name) into the enable-assertions table.
225 VALUE is true to enable and false to disable. */
228 add_enable_assert (const char *ident
, int value
)
230 if (enable_assert_tree
== NULL
)
231 add_class_flag (&enable_assert_tree
, "", DEFAULT_ENABLE_ASSERT
);
232 add_class_flag (&enable_assert_tree
, ident
, value
);
235 /* Returns nonzero if IDENT is the name of a class that the compiler
236 should assume has been compiled to object code. */
239 assume_compiled (const char *ident
)
244 if (NULL
== assume_compiled_tree
)
247 i
= find_class_flag_node (assume_compiled_tree
, ident
);
254 /* Return true if we should generate code to check assertions within KLASS. */
257 enable_assertions (tree klass
)
259 /* Check if command-line specifies whether we should check assertions. */
261 if (klass
!= NULL_TREE
&& DECL_NAME (klass
) && enable_assert_tree
!= NULL
)
263 const char *ident
= IDENTIFIER_POINTER (DECL_NAME (klass
));
264 class_flag_node
*node
265 = find_class_flag_node (enable_assert_tree
, ident
);
269 /* The default is to enable assertions if generating class files,
270 or not optimizing. */
271 return DEFAULT_ENABLE_ASSERT
;
274 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
275 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
276 Also, PREFIX is prepended, and SUFFIX is appended. */
279 ident_subst (const char* old_name
,
286 int prefix_len
= strlen (prefix
);
287 int suffix_len
= strlen (suffix
);
288 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
289 char *buffer
= (char *) alloca (i
);
291 strcpy (buffer
, prefix
);
292 for (i
= 0; i
< old_length
; i
++)
294 char ch
= old_name
[i
];
297 buffer
[prefix_len
+ i
] = ch
;
299 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
300 return get_identifier (buffer
);
303 /* Return an IDENTIFIER_NODE the same as OLD_ID,
304 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
305 Also, PREFIX is prepended, and SUFFIX is appended. */
308 identifier_subst (const tree old_id
,
314 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
315 prefix
, old_char
, new_char
, suffix
);
318 /* Generate a valid C identifier from the name of the class TYPE,
319 prefixed by PREFIX. */
322 mangled_classname (const char *prefix
, tree type
)
325 tree ident
= TYPE_NAME (type
);
326 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
327 ident
= DECL_NAME (ident
);
328 result
= identifier_subst (ident
, prefix
, '.', '_', "");
330 /* Replace any characters that aren't in the set [0-9a-zA-Z_$] with
331 "_0xXX". Class names containing such chracters are uncommon, but
332 they do sometimes occur in class files. Without this check,
333 these names cause assembly errors.
335 There is a possibility that a real class name could conflict with
336 the identifier we generate, but it is unlikely and will
337 immediately be detected as an assembler error. At some point we
338 should do something more elaborate (perhaps using the full
339 unicode mangling scheme) in order to prevent such a conflict. */
342 const int len
= IDENTIFIER_LENGTH (result
);
343 const char *p
= IDENTIFIER_POINTER (result
);
344 int illegal_chars
= 0;
346 /* Make two passes over the identifier. The first pass is merely
347 to count illegal characters; we need to do this in order to
348 allocate a buffer. */
349 for (i
= 0; i
< len
; i
++)
352 illegal_chars
+= (! ISALNUM (c
) && c
!= '_' && c
!= '$');
355 /* And the second pass, which is rarely executed, does the
357 if (illegal_chars
!= 0)
359 char *buffer
= (char *) alloca (illegal_chars
* 4 + len
+ 1);
362 for (i
= 0, j
= 0; i
< len
; i
++)
365 if (! ISALNUM (c
) && c
!= '_' && c
!= '$')
368 sprintf (&buffer
[j
], "0x%02x", c
);
376 result
= get_identifier (buffer
);
387 type
= make_node (RECORD_TYPE
);
388 /* Unfortunately we must create the binfo here, so that class
390 TYPE_BINFO (type
) = make_tree_binfo (0);
391 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
392 TYPE_CATCH_CLASSES (type
) = NULL
;
393 /* Push a dummy entry; we can't call make_catch_class_record here
394 because other infrastructure may not be set up yet. We'll come
395 back and fill it in later once said infrastructure is
397 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (type
), NULL_TREE
, NULL_TREE
);
402 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
403 and where each of the constituents is separated by '/',
404 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
407 unmangle_classname (const char *name
, int name_length
)
409 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
410 /* It's not sufficient to compare to_return and get_identifier
411 (name) to determine whether to_return is qualified. There are
412 cases in signature analysis where name will be stripped of a
414 name
= IDENTIFIER_POINTER (to_return
);
418 QUALIFIED_P (to_return
) = 1;
425 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
428 const char *type_name = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
429 char *buf = (char *) alloca (strlen (type_name) \
430 + strlen (#NAME "_syms_") + 1); \
433 sprintf (buf, #NAME "_%s", type_name); \
434 TYPE_## TABLE ##_DECL (type) = decl = \
435 build_decl (input_location, VAR_DECL, get_identifier (buf), TABLE_TYPE); \
436 DECL_EXTERNAL (decl) = 1; \
437 TREE_STATIC (decl) = 1; \
438 TREE_READONLY (decl) = 1; \
439 TREE_CONSTANT (decl) = 1; \
440 DECL_IGNORED_P (decl) = 1; \
441 /* Mark the table as belonging to this class. */ \
443 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
444 DECL_OWNER (decl) = TYPE; \
445 sprintf (buf, #NAME "_syms_%s", type_name); \
446 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
447 build_decl (input_location, VAR_DECL, get_identifier (buf), symbols_array_type); \
448 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
449 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
450 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
454 /* Given a class, create the DECLs for all its associated indirect
457 gen_indirect_dispatch_tables (tree type
)
459 const char *type_name
= IDENTIFIER_POINTER (mangled_classname ("", type
));
462 char *buf
= (char *) alloca (strlen (type_name
)
463 + strlen ("_catch_classes_") + 1);
464 tree catch_class_type
= make_node (RECORD_TYPE
);
466 sprintf (buf
, "_catch_classes_%s", type_name
);
467 PUSH_FIELD (input_location
,
468 catch_class_type
, field
, "address", utf8const_ptr_type
);
469 PUSH_FIELD (input_location
,
470 catch_class_type
, field
, "classname", ptr_type_node
);
471 FINISH_RECORD (catch_class_type
);
473 TYPE_CTABLE_DECL (type
)
474 = build_decl (input_location
, VAR_DECL
, get_identifier (buf
),
475 build_array_type (catch_class_type
, 0));
476 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
477 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
478 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
479 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
480 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
481 pushdecl (TYPE_CTABLE_DECL (type
));
484 if (flag_indirect_dispatch
)
486 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
487 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
488 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
495 push_class (tree class_type
, tree class_name
)
497 tree decl
, signature
;
498 location_t saved_loc
= input_location
;
499 CLASS_P (class_type
) = 1;
500 decl
= build_decl (input_location
, TYPE_DECL
, class_name
, class_type
);
501 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
503 /* dbxout needs a DECL_SIZE if in gstabs mode */
504 DECL_SIZE (decl
) = integer_zero_node
;
506 input_location
= saved_loc
;
507 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
508 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
510 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
511 both a typedef and in the struct name-space. We may want to re-visit
512 this later, but for now it reduces the changes needed for gdb. */
513 DECL_ARTIFICIAL (decl
) = 1;
515 pushdecl_top_level (decl
);
520 /* Finds the (global) class named NAME. Creates the class if not found.
521 Also creates associated TYPE_DECL.
522 Does not check if the class actually exists, load the class,
523 fill in field or methods, or do layout_type. */
526 lookup_class (tree name
)
528 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
529 if (decl
== NULL_TREE
)
530 decl
= push_class (make_class (), name
);
531 return TREE_TYPE (decl
);
535 set_super_info (int access_flags
, tree this_class
,
536 tree super_class
, int interfaces_count
)
538 int total_supers
= interfaces_count
;
539 tree class_decl
= TYPE_NAME (this_class
);
545 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
546 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
549 tree super_binfo
= make_tree_binfo (0);
550 BINFO_TYPE (super_binfo
) = super_class
;
551 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
552 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
553 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
556 set_class_decl_access_flags (access_flags
, class_decl
);
560 set_class_decl_access_flags (int access_flags
, tree class_decl
)
562 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
563 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
564 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
565 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
566 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
567 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
568 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
569 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
570 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
571 if (access_flags
& ACC_ENUM
) CLASS_ENUM (class_decl
) = 1;
572 if (access_flags
& ACC_SYNTHETIC
) CLASS_SYNTHETIC (class_decl
) = 1;
573 if (access_flags
& ACC_ANNOTATION
) CLASS_ANNOTATION (class_decl
) = 1;
576 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
577 direct sub-classes of Object are 1, and so on. */
580 class_depth (tree clas
)
583 if (! CLASS_LOADED_P (clas
))
584 load_class (clas
, 1);
585 if (TYPE_SIZE (clas
) == error_mark_node
)
587 while (clas
!= object_type_node
)
590 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
595 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
598 interface_of_p (tree type1
, tree type2
)
601 tree binfo
, base_binfo
;
603 if (! TYPE_BINFO (type2
))
606 for (binfo
= TYPE_BINFO (type2
), i
= 0;
607 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
608 if (BINFO_TYPE (base_binfo
) == type1
)
611 for (binfo
= TYPE_BINFO (type2
), i
= 0;
612 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
613 if (BINFO_TYPE (base_binfo
)
614 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
620 /* Return true iff TYPE1 inherits from TYPE2. */
623 inherits_from_p (tree type1
, tree type2
)
625 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
630 if (! CLASS_LOADED_P (type1
))
631 load_class (type1
, 1);
633 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
638 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
641 enclosing_context_p (tree type1
, tree type2
)
643 if (!INNER_CLASS_TYPE_P (type2
))
646 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
648 type2
= (INNER_CLASS_TYPE_P (type2
) ?
649 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
659 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
663 common_enclosing_context_p (tree type1
, tree type2
)
668 for (current
= type2
; current
;
669 current
= (INNER_CLASS_TYPE_P (current
) ?
670 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
672 if (type1
== current
)
675 if (INNER_CLASS_TYPE_P (type1
))
676 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
683 /* Return 1 iff there exists a common enclosing "this" between TYPE1
684 and TYPE2, without crossing any static context. */
687 common_enclosing_instance_p (tree type1
, tree type2
)
689 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
692 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
693 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
694 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
697 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
698 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
699 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
701 if (type1
== current
)
707 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
708 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
709 if attempt is made to add it twice. */
712 maybe_add_interface (tree this_class
, tree interface_class
)
714 tree binfo
, base_binfo
;
717 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
718 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
719 if (BINFO_TYPE (base_binfo
) == interface_class
)
720 return interface_class
;
721 add_interface (this_class
, interface_class
);
725 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
728 add_interface (tree this_class
, tree interface_class
)
730 tree interface_binfo
= make_tree_binfo (0);
732 BINFO_TYPE (interface_binfo
) = interface_class
;
733 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
734 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
735 BINFO_VIRTUAL_P (interface_binfo
) = 1;
737 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
741 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
743 if (access_flags
& ACC_STATIC
)
745 fntype
= build_method_type (this_class
, fntype
);
747 /* We know that arg 1 of every nonstatic method is non-null; tell
749 TYPE_ATTRIBUTES (fntype
) = (tree_cons
750 (get_identifier ("nonnull"),
751 tree_cons (NULL_TREE
,
752 build_int_cst (NULL_TREE
, 1),
754 TYPE_ATTRIBUTES (fntype
)));
759 java_hide_decl (tree decl ATTRIBUTE_UNUSED
)
761 #ifdef HAVE_GAS_HIDDEN
762 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
763 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
768 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
770 tree method_type
, fndecl
;
772 method_type
= build_java_method_type (function_type
,
773 this_class
, access_flags
);
775 fndecl
= build_decl (input_location
, FUNCTION_DECL
, name
, method_type
);
776 DECL_CONTEXT (fndecl
) = this_class
;
778 DECL_LANG_SPECIFIC (fndecl
) = ggc_cleared_alloc
<struct lang_decl
> ();
779 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
781 /* Initialize the static initializer test table. */
783 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) = java_treetreehash_create (10);
785 /* Initialize the initialized (static) class table. */
786 if (access_flags
& ACC_STATIC
)
787 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
788 hash_table
<ict_hasher
>::create_ggc (50);
790 DECL_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
791 TYPE_METHODS (this_class
) = fndecl
;
793 /* If pointers to member functions use the least significant bit to
794 indicate whether a function is virtual, ensure a pointer
795 to this function will have that bit clear. */
796 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
797 && !(access_flags
& ACC_STATIC
)
798 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
799 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
801 /* Notice that this is a finalizer and update the class type
802 accordingly. This is used to optimize instance allocation. */
803 if (name
== finalize_identifier_node
804 && TREE_TYPE (function_type
) == void_type_node
805 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
806 HAS_FINALIZER_P (this_class
) = 1;
808 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
809 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
810 if (access_flags
& ACC_PRIVATE
)
811 METHOD_PRIVATE (fndecl
) = 1;
812 if (access_flags
& ACC_NATIVE
)
814 METHOD_NATIVE (fndecl
) = 1;
815 DECL_EXTERNAL (fndecl
) = 1;
818 /* FNDECL is external unless we are compiling it into this object
820 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
821 if (access_flags
& ACC_STATIC
)
822 METHOD_STATIC (fndecl
) = 1;
823 if (access_flags
& ACC_FINAL
)
824 METHOD_FINAL (fndecl
) = 1;
825 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
826 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
827 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
828 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
829 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
830 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
834 /* Add a method to THIS_CLASS.
835 The method's name is NAME.
836 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
839 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
841 tree function_type
, fndecl
;
842 const unsigned char *sig
843 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
846 fatal_error ("bad method signature");
848 function_type
= get_type_from_signature (method_sig
);
849 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
850 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
855 add_field (tree klass
, tree name
, tree field_type
, int flags
)
857 int is_static
= (flags
& ACC_STATIC
) != 0;
859 field
= build_decl (input_location
,
860 is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
861 DECL_CHAIN (field
) = TYPE_FIELDS (klass
);
862 TYPE_FIELDS (klass
) = field
;
863 DECL_CONTEXT (field
) = klass
;
864 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
866 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
867 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
868 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
869 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
870 if (flags
& ACC_VOLATILE
)
872 FIELD_VOLATILE (field
) = 1;
873 TREE_THIS_VOLATILE (field
) = 1;
875 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
876 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
877 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
880 FIELD_STATIC (field
) = 1;
881 /* Always make field externally visible. This is required so
882 that native methods can always access the field. */
883 TREE_PUBLIC (field
) = 1;
884 /* Hide everything that shouldn't be visible outside a DSO. */
885 if (flag_indirect_classes
886 || (FIELD_PRIVATE (field
)))
887 java_hide_decl (field
);
888 /* Considered external unless we are compiling it into this
890 DECL_EXTERNAL (field
) = (is_compiled_class (klass
) != 2);
891 if (!DECL_EXTERNAL (field
))
892 vec_safe_push (pending_static_fields
, field
);
898 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
901 set_constant_value (tree field
, tree constant
)
903 if (field
== NULL_TREE
)
904 warning (OPT_Wattributes
,
905 "misplaced ConstantValue attribute (not in any field)");
906 else if (DECL_INITIAL (field
) != NULL_TREE
)
907 warning (OPT_Wattributes
,
908 "duplicate ConstantValue attribute for field '%s'",
909 IDENTIFIER_POINTER (DECL_NAME (field
)));
912 DECL_INITIAL (field
) = constant
;
913 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
914 && ! (TREE_TYPE (constant
) == int_type_node
915 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
916 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
917 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
918 && TREE_TYPE (field
) == string_ptr_type_node
))
919 error ("ConstantValue attribute of field '%s' has wrong type",
920 IDENTIFIER_POINTER (DECL_NAME (field
)));
924 /* Calculate a hash value for a string encoded in Utf8 format.
925 * This returns the same hash value as specified for java.lang.String.hashCode.
929 hashUtf8String (const char *str
, int len
)
931 const unsigned char* ptr
= (const unsigned char*) str
;
932 const unsigned char *limit
= ptr
+ len
;
936 int ch
= UTF8_GET (ptr
, limit
);
937 /* Updated specification from
938 http://www.javasoft.com/docs/books/jls/clarify.html. */
939 hash
= (31 * hash
) + ch
;
945 build_utf8_ref (tree name
)
947 const char * name_ptr
= IDENTIFIER_POINTER (name
);
948 int name_len
= IDENTIFIER_LENGTH (name
), name_pad
;
950 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
951 static int utf8_count
= 0;
953 tree ref
= IDENTIFIER_UTF8_REF (name
);
955 vec
<constructor_elt
, va_gc
> *v
= NULL
;
956 if (ref
!= NULL_TREE
)
959 ctype
= make_node (RECORD_TYPE
);
960 /* '\0' byte plus padding to utf8const_type's alignment. */
961 name_pad
= TYPE_ALIGN_UNIT (utf8const_type
)
962 - (name_len
& (TYPE_ALIGN_UNIT (utf8const_type
) - 1));
963 str_type
= build_prim_array_type (unsigned_byte_type_node
,
964 name_len
+ name_pad
);
965 PUSH_FIELD (input_location
, ctype
, field
, "hash", unsigned_short_type_node
);
966 PUSH_FIELD (input_location
,
967 ctype
, field
, "length", unsigned_short_type_node
);
968 PUSH_FIELD (input_location
, ctype
, field
, "data", str_type
);
969 FINISH_RECORD (ctype
);
970 START_RECORD_CONSTRUCTOR (v
, ctype
);
971 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
972 PUSH_FIELD_VALUE (v
, "hash", build_int_cst (NULL_TREE
, name_hash
));
973 PUSH_FIELD_VALUE (v
, "length", build_int_cst (NULL_TREE
, name_len
));
974 string
= build_string (name_len
, name_ptr
);
975 TREE_TYPE (string
) = str_type
;
976 PUSH_FIELD_VALUE (v
, "data", string
);
977 FINISH_RECORD_CONSTRUCTOR (cinit
, v
, ctype
);
978 TREE_CONSTANT (cinit
) = 1;
980 /* Generate a unique-enough identifier. */
981 sprintf(buf
, "_Utf%d", ++utf8_count
);
983 decl
= build_decl (input_location
,
984 VAR_DECL
, get_identifier (buf
), utf8const_type
);
985 TREE_STATIC (decl
) = 1;
986 DECL_ARTIFICIAL (decl
) = 1;
987 DECL_IGNORED_P (decl
) = 1;
988 TREE_READONLY (decl
) = 1;
989 TREE_THIS_VOLATILE (decl
) = 0;
990 DECL_INITIAL (decl
) = cinit
;
991 DECL_USER_ALIGN (decl
) = 1;
993 if (HAVE_GAS_SHF_MERGE
)
996 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
997 decl_size
= name_len
+ 4 + name_pad
;
998 if (flag_merge_constants
&& decl_size
< 256)
1001 int flags
= (SECTION_OVERRIDE
1002 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
1003 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
1004 switch_to_section (get_section (buf
, flags
, NULL
));
1005 set_decl_section_name (decl
, buf
);
1009 layout_decl (decl
, 0);
1010 DECL_SIZE (decl
) = TYPE_SIZE (ctype
);
1011 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (ctype
);
1013 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
1014 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
1015 IDENTIFIER_UTF8_REF (name
) = ref
;
1019 /* Like build_class_ref, but instead of a direct reference generate a
1020 pointer into the constant pool. */
1023 build_indirect_class_ref (tree type
)
1027 index
= alloc_class_constant (type
);
1028 cl
= build_ref_from_constant_pool (index
);
1029 return convert (promote_type (class_ptr_type
), cl
);
1033 build_static_class_ref (tree type
)
1035 tree decl_name
, decl
, ref
;
1037 if (TYPE_SIZE (type
) == error_mark_node
)
1038 return null_pointer_node
;
1039 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1040 "", '/', '/', ".class$$");
1041 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1042 if (decl
== NULL_TREE
)
1044 decl
= build_decl (input_location
, VAR_DECL
, decl_name
, class_type_node
);
1045 TREE_STATIC (decl
) = 1;
1046 if (! flag_indirect_classes
)
1048 TREE_PUBLIC (decl
) = 1;
1049 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1050 java_hide_decl (decl
);
1052 DECL_IGNORED_P (decl
) = 1;
1053 DECL_ARTIFICIAL (decl
) = 1;
1054 if (is_compiled_class (type
) == 1)
1055 DECL_EXTERNAL (decl
) = 1;
1056 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1057 DECL_CLASS_FIELD_P (decl
) = 1;
1058 DECL_CONTEXT (decl
) = type
;
1060 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1061 that that means not calling pushdecl_top_level. */
1062 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1065 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1070 build_classdollar_field (tree type
)
1072 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1073 "", '/', '/', ".class$");
1074 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1076 if (decl
== NULL_TREE
)
1079 = build_decl (input_location
,
1080 VAR_DECL
, decl_name
,
1081 (build_qualified_type
1083 (build_qualified_type (class_type_node
,
1086 TREE_STATIC (decl
) = 1;
1087 TREE_CONSTANT (decl
) = 1;
1088 TREE_PUBLIC (decl
) = 1;
1089 java_hide_decl (decl
);
1090 DECL_IGNORED_P (decl
) = 1;
1091 DECL_ARTIFICIAL (decl
) = 1;
1092 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1093 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1094 DECL_CLASS_FIELD_P (decl
) = 1;
1095 DECL_CONTEXT (decl
) = type
;
1101 /* Create a local variable that holds the current class$. */
1104 cache_this_class_ref (tree fndecl
)
1108 tree classdollar_field
;
1109 if (flag_indirect_classes
)
1110 classdollar_field
= build_classdollar_field (output_class
);
1112 classdollar_field
= build_static_class_ref (output_class
);
1114 this_classdollar
= build_decl (input_location
,
1115 VAR_DECL
, NULL_TREE
,
1116 TREE_TYPE (classdollar_field
));
1118 java_add_local_var (this_classdollar
);
1119 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1120 this_classdollar
, classdollar_field
));
1123 this_classdollar
= build_classdollar_field (output_class
);
1125 /* Prepend class initialization for static methods reachable from
1127 if (METHOD_STATIC (fndecl
)
1128 && (! METHOD_PRIVATE (fndecl
)
1129 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1130 && ! DECL_CLINIT_P (fndecl
)
1131 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1133 tree init
= build_call_expr (soft_initclass_node
, 1,
1135 java_add_stmt (init
);
1139 /* Remove the reference to the local variable that holds the current
1143 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1145 this_classdollar
= build_classdollar_field (output_class
);
1148 /* Build a reference to the class TYPE.
1149 Also handles primitive types and array types. */
1152 build_class_ref (tree type
)
1154 int is_compiled
= is_compiled_class (type
);
1158 if (TREE_CODE (type
) == POINTER_TYPE
)
1159 type
= TREE_TYPE (type
);
1161 if (flag_indirect_dispatch
1162 && type
!= output_class
1163 && TREE_CODE (type
) == RECORD_TYPE
)
1164 return build_indirect_class_ref (type
);
1166 if (type
== output_class
&& flag_indirect_classes
)
1168 /* This can be NULL if we see a JNI stub before we see any
1170 if (! this_classdollar
)
1171 this_classdollar
= build_classdollar_field (output_class
);
1172 return this_classdollar
;
1175 if (TREE_CODE (type
) == RECORD_TYPE
)
1176 return build_static_class_ref (type
);
1182 decl_name
= TYPE_NAME (type
);
1183 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1184 decl_name
= DECL_NAME (decl_name
);
1185 name
= IDENTIFIER_POINTER (decl_name
);
1186 if (strncmp (name
, "promoted_", 9) == 0)
1188 sprintf (buffer
, "_Jv_%sClass", name
);
1189 decl_name
= get_identifier (buffer
);
1190 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1191 if (decl
== NULL_TREE
)
1193 decl
= build_decl (input_location
,
1194 VAR_DECL
, decl_name
, class_type_node
);
1195 TREE_STATIC (decl
) = 1;
1196 TREE_PUBLIC (decl
) = 1;
1197 DECL_EXTERNAL (decl
) = 1;
1198 DECL_ARTIFICIAL (decl
) = 1;
1199 pushdecl_top_level (decl
);
1203 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1207 return build_indirect_class_ref (type
);
1210 /* Create a local statically allocated variable that will hold a
1211 pointer to a static field. */
1214 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1216 tree decl
, decl_name
;
1217 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1218 char *buf
= (char *) alloca (strlen (name
) + 20);
1219 sprintf (buf
, "%s_%d_ref", name
, index
);
1220 decl_name
= get_identifier (buf
);
1221 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1222 if (decl
== NULL_TREE
)
1224 decl
= build_decl (input_location
,
1225 VAR_DECL
, decl_name
, ptr_type_node
);
1226 TREE_STATIC (decl
) = 1;
1227 TREE_PUBLIC (decl
) = 0;
1228 DECL_EXTERNAL (decl
) = 0;
1229 DECL_ARTIFICIAL (decl
) = 1;
1230 DECL_IGNORED_P (decl
) = 1;
1231 pushdecl_top_level (decl
);
1237 build_static_field_ref (tree fdecl
)
1239 tree fclass
= DECL_CONTEXT (fdecl
);
1240 int is_compiled
= is_compiled_class (fclass
);
1242 /* Allow static final fields to fold to a constant. When using
1243 -findirect-dispatch, we simply never do this folding if compiling
1244 from .class; in the .class file constants will be referred to via
1245 the constant pool. */
1246 if (!flag_indirect_dispatch
1248 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1249 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1250 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1251 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1253 if (is_compiled
== 1)
1254 DECL_EXTERNAL (fdecl
) = 1;
1258 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1259 and a class local static variable CACHE_ENTRY, then
1261 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1262 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1265 This can mostly be optimized away, so that the usual path is a
1266 load followed by a test and branch. _Jv_ResolvePoolEntry is
1267 only called once for each constant pool entry.
1269 There is an optimization that we don't do: at the start of a
1270 method, create a local copy of CACHE_ENTRY and use that instead.
1274 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1275 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1277 = build_call_expr (builtin_decl_implicit (BUILT_IN_EXPECT
), 2,
1278 build2 (EQ_EXPR
, boolean_type_node
,
1279 cache_entry
, null_pointer_node
),
1280 boolean_false_node
);
1281 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1283 = build_call_expr (soft_resolvepoolentry_node
, 2,
1284 build_class_ref (output_class
),
1286 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1287 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1288 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1289 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1295 get_access_flags_from_decl (tree decl
)
1297 int access_flags
= 0;
1298 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1300 if (FIELD_STATIC (decl
))
1301 access_flags
|= ACC_STATIC
;
1302 if (FIELD_PUBLIC (decl
))
1303 access_flags
|= ACC_PUBLIC
;
1304 if (FIELD_PROTECTED (decl
))
1305 access_flags
|= ACC_PROTECTED
;
1306 if (FIELD_PRIVATE (decl
))
1307 access_flags
|= ACC_PRIVATE
;
1308 if (FIELD_FINAL (decl
))
1309 access_flags
|= ACC_FINAL
;
1310 if (FIELD_VOLATILE (decl
))
1311 access_flags
|= ACC_VOLATILE
;
1312 if (FIELD_TRANSIENT (decl
))
1313 access_flags
|= ACC_TRANSIENT
;
1314 if (FIELD_ENUM (decl
))
1315 access_flags
|= ACC_ENUM
;
1316 if (FIELD_SYNTHETIC (decl
))
1317 access_flags
|= ACC_SYNTHETIC
;
1318 return access_flags
;
1320 if (TREE_CODE (decl
) == TYPE_DECL
)
1322 if (CLASS_PUBLIC (decl
))
1323 access_flags
|= ACC_PUBLIC
;
1324 if (CLASS_FINAL (decl
))
1325 access_flags
|= ACC_FINAL
;
1326 if (CLASS_SUPER (decl
))
1327 access_flags
|= ACC_SUPER
;
1328 if (CLASS_INTERFACE (decl
))
1329 access_flags
|= ACC_INTERFACE
;
1330 if (CLASS_ABSTRACT (decl
))
1331 access_flags
|= ACC_ABSTRACT
;
1332 if (CLASS_STATIC (decl
))
1333 access_flags
|= ACC_STATIC
;
1334 if (CLASS_PRIVATE (decl
))
1335 access_flags
|= ACC_PRIVATE
;
1336 if (CLASS_PROTECTED (decl
))
1337 access_flags
|= ACC_PROTECTED
;
1338 if (CLASS_STRICTFP (decl
))
1339 access_flags
|= ACC_STRICT
;
1340 if (CLASS_ENUM (decl
))
1341 access_flags
|= ACC_ENUM
;
1342 if (CLASS_SYNTHETIC (decl
))
1343 access_flags
|= ACC_SYNTHETIC
;
1344 if (CLASS_ANNOTATION (decl
))
1345 access_flags
|= ACC_ANNOTATION
;
1346 return access_flags
;
1348 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1350 if (METHOD_PUBLIC (decl
))
1351 access_flags
|= ACC_PUBLIC
;
1352 if (METHOD_PRIVATE (decl
))
1353 access_flags
|= ACC_PRIVATE
;
1354 if (METHOD_PROTECTED (decl
))
1355 access_flags
|= ACC_PROTECTED
;
1356 if (METHOD_STATIC (decl
))
1357 access_flags
|= ACC_STATIC
;
1358 if (METHOD_FINAL (decl
))
1359 access_flags
|= ACC_FINAL
;
1360 if (METHOD_SYNCHRONIZED (decl
))
1361 access_flags
|= ACC_SYNCHRONIZED
;
1362 if (METHOD_NATIVE (decl
))
1363 access_flags
|= ACC_NATIVE
;
1364 if (METHOD_ABSTRACT (decl
))
1365 access_flags
|= ACC_ABSTRACT
;
1366 if (METHOD_STRICTFP (decl
))
1367 access_flags
|= ACC_STRICT
;
1368 if (METHOD_INVISIBLE (decl
))
1369 access_flags
|= ACC_INVISIBLE
;
1370 if (DECL_ARTIFICIAL (decl
))
1371 access_flags
|= ACC_SYNTHETIC
;
1372 if (METHOD_BRIDGE (decl
))
1373 access_flags
|= ACC_BRIDGE
;
1374 if (METHOD_VARARGS (decl
))
1375 access_flags
|= ACC_VARARGS
;
1376 return access_flags
;
1381 static GTY (()) int alias_labelno
= 0;
1383 /* Create a private alias for METHOD. Using this alias instead of the method
1384 decl ensures that ncode entries in the method table point to the real function
1385 at runtime, not a PLT entry. */
1388 make_local_function_alias (tree method
)
1390 #ifdef ASM_OUTPUT_DEF
1393 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1394 char *name
= (char *) alloca (strlen (method_name
) + 2);
1395 char *buf
= (char *) alloca (strlen (method_name
) + 128);
1397 /* Only create aliases for local functions. */
1398 if (DECL_EXTERNAL (method
))
1401 /* Prefix method_name with 'L' for the alias label. */
1403 strcpy (name
+ 1, method_name
);
1405 targetm
.asm_out
.generate_internal_label (buf
, name
, alias_labelno
++);
1406 alias
= build_decl (input_location
,
1407 FUNCTION_DECL
, get_identifier (buf
),
1408 TREE_TYPE (method
));
1409 DECL_CONTEXT (alias
) = NULL
;
1410 TREE_READONLY (alias
) = TREE_READONLY (method
);
1411 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1412 TREE_PUBLIC (alias
) = 0;
1413 DECL_EXTERNAL (alias
) = 0;
1414 DECL_ARTIFICIAL (alias
) = 1;
1415 DECL_INITIAL (alias
) = error_mark_node
;
1416 TREE_ADDRESSABLE (alias
) = 1;
1417 TREE_USED (alias
) = 1;
1418 if (!flag_syntax_only
)
1419 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1426 /** Make reflection data (_Jv_Field) for field FDECL. */
1429 make_field_value (tree fdecl
)
1433 tree type
= TREE_TYPE (fdecl
);
1434 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1435 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1437 START_RECORD_CONSTRUCTOR (v
, field_type_node
);
1438 PUSH_FIELD_VALUE (v
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1440 type
= build_class_ref (type
);
1443 tree signature
= build_java_signature (type
);
1445 type
= build_utf8_ref (unmangle_classname
1446 (IDENTIFIER_POINTER (signature
),
1447 IDENTIFIER_LENGTH (signature
)));
1449 PUSH_FIELD_VALUE (v
, "type", type
);
1451 flags
= get_access_flags_from_decl (fdecl
);
1453 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1455 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, flags
));
1456 PUSH_FIELD_VALUE (v
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1459 tree field_address
= integer_zero_node
;
1461 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1462 && FIELD_STATIC (fdecl
))
1463 field_address
= build_address_of (fdecl
);
1465 index
= (FIELD_STATIC (fdecl
)
1466 ? DECL_CHAIN (TYPE_FIELDS (field_info_union_node
))
1467 : TYPE_FIELDS (field_info_union_node
));
1468 value
= (FIELD_STATIC (fdecl
)
1470 : byte_position (fdecl
));
1474 build_constructor_single (field_info_union_node
, index
, value
));
1477 FINISH_RECORD_CONSTRUCTOR (finit
, v
, field_type_node
);
1481 /** Make reflection data (_Jv_Method) for method MDECL. */
1484 make_method_value (tree mdecl
)
1486 static int method_name_count
= 0;
1491 #define ACC_TRANSLATED 0x4000
1492 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1493 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1495 class_decl
= DECL_CONTEXT (mdecl
);
1496 /* For interfaces, the index field contains the dispatch index. */
1497 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1498 index
= build_int_cst (NULL_TREE
,
1499 get_interface_method_index (mdecl
, class_decl
));
1500 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1501 index
= get_method_index (mdecl
);
1503 index
= integer_minus_one_node
;
1505 code
= null_pointer_node
;
1506 if (METHOD_ABSTRACT (mdecl
))
1507 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1508 soft_abstractmethod_node
);
1510 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1511 make_local_function_alias (mdecl
));
1512 START_RECORD_CONSTRUCTOR (v
, method_type_node
);
1513 PUSH_FIELD_VALUE (v
, "name",
1514 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1515 init_identifier_node
1516 : DECL_NAME (mdecl
)));
1518 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1519 PUSH_FIELD_VALUE (v
, "signature",
1522 (IDENTIFIER_POINTER(signature
),
1523 IDENTIFIER_LENGTH(signature
)))));
1525 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1526 PUSH_FIELD_VALUE (v
, "index", index
);
1527 PUSH_FIELD_VALUE (v
, "ncode", code
);
1530 /* Compute the `throws' information for the method. */
1531 tree table
= null_pointer_node
;
1533 if (!vec_safe_is_empty (DECL_FUNCTION_THROWS (mdecl
)))
1535 int length
= 1 + DECL_FUNCTION_THROWS (mdecl
)->length ();
1536 tree t
, type
, array
;
1538 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1539 int idx
= length
- 1;
1543 vec_alloc (v
, length
);
1544 v
->quick_grow_cleared (length
);
1547 e
->value
= null_pointer_node
;
1549 FOR_EACH_VEC_SAFE_ELT (DECL_FUNCTION_THROWS (mdecl
), ix
, t
)
1551 tree sig
= DECL_NAME (TYPE_NAME (t
));
1553 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1554 IDENTIFIER_LENGTH (sig
)));
1558 gcc_assert (idx
== -1);
1559 type
= build_prim_array_type (ptr_type_node
, length
);
1560 table
= build_constructor (type
, v
);
1561 /* Compute something unique enough. */
1562 sprintf (buf
, "_methods%d", method_name_count
++);
1563 array
= build_decl (input_location
,
1564 VAR_DECL
, get_identifier (buf
), type
);
1565 DECL_INITIAL (array
) = table
;
1566 TREE_STATIC (array
) = 1;
1567 DECL_ARTIFICIAL (array
) = 1;
1568 DECL_IGNORED_P (array
) = 1;
1569 rest_of_decl_compilation (array
, 1, 0);
1571 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1574 PUSH_FIELD_VALUE (v
, "throws", table
);
1577 FINISH_RECORD_CONSTRUCTOR (minit
, v
, method_type_node
);
1582 get_dispatch_vector (tree type
)
1584 tree vtable
= TYPE_VTABLE (type
);
1586 if (vtable
== NULL_TREE
)
1590 tree super
= CLASSTYPE_SUPER (type
);
1591 HOST_WIDE_INT nvirtuals
= tree_to_shwi (TYPE_NVIRTUALS (type
));
1592 vtable
= make_tree_vec (nvirtuals
);
1593 TYPE_VTABLE (type
) = vtable
;
1594 if (super
!= NULL_TREE
)
1596 tree super_vtable
= get_dispatch_vector (super
);
1598 for (i
= tree_to_shwi (TYPE_NVIRTUALS (super
)); --i
>= 0; )
1599 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1602 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1603 method
= DECL_CHAIN (method
))
1605 tree method_index
= get_method_index (method
);
1606 if (method_index
!= NULL_TREE
1607 && tree_fits_shwi_p (method_index
))
1608 TREE_VEC_ELT (vtable
, tree_to_shwi (method_index
)) = method
;
1616 get_dispatch_table (tree type
, tree this_class_addr
)
1618 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1619 tree vtable
= get_dispatch_vector (type
);
1621 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1624 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1628 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1629 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1630 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1633 vec_safe_grow_cleared (v
, arraysize
);
1634 e
= &(*v
)[arraysize
- 1];
1636 #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
1637 for (i
= nvirtuals
; --i
>= 0; )
1639 tree method
= TREE_VEC_ELT (vtable
, i
);
1640 if (METHOD_ABSTRACT (method
))
1643 warning_at (DECL_SOURCE_LOCATION (method
), 0,
1644 "abstract method in non-abstract class");
1646 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1647 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1648 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1650 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1654 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1655 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1657 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1658 method
, build_int_cst (NULL_TREE
, j
));
1659 TREE_CONSTANT (fdesc
) = 1;
1660 CONSTRUCTOR_PREPEND_VALUE (e
, fdesc
);
1663 CONSTRUCTOR_PREPEND_VALUE (e
,
1665 nativecode_ptr_type_node
,
1670 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1671 using the Boehm GC we sometimes stash a GC type descriptor
1672 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1673 the emitted byte count during the output to the assembly file. */
1674 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1675 fake "function descriptor". It's first word is the is the class
1676 pointer, and subsequent words (usually one) contain the GC descriptor.
1677 In all other cases, we reserve two extra vtable slots. */
1678 gc_descr
= get_boehm_type_descriptor (type
);
1679 CONSTRUCTOR_PREPEND_VALUE (e
, gc_descr
);
1680 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1681 CONSTRUCTOR_PREPEND_VALUE (e
, gc_descr
);
1682 CONSTRUCTOR_PREPEND_VALUE (e
, this_class_addr
);
1684 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1685 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1686 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1687 gcc_assert (e
== v
->address ());
1688 e
->index
= integer_zero_node
;
1689 e
->value
= null_pointer_node
;
1690 #undef CONSTRUCTOR_PREPEND_VALUE
1692 arraytype
= build_prim_array_type (nativecode_ptr_type_node
, arraysize
);
1693 return build_constructor (arraytype
, v
);
1697 /* Set the method_index for a method decl. */
1699 set_method_index (tree decl
, tree method_index
)
1701 if (method_index
!= NULL_TREE
)
1703 /* method_index is null if we're using indirect dispatch. */
1704 method_index
= fold (convert (sizetype
, method_index
));
1706 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1707 /* Add one to skip bogus descriptor for class and GC descriptor. */
1708 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1710 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1712 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1715 DECL_VINDEX (decl
) = method_index
;
1718 /* Get the method_index for a method decl. */
1720 get_method_index (tree decl
)
1722 tree method_index
= DECL_VINDEX (decl
);
1727 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1728 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1729 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1731 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1732 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1734 return method_index
;
1738 supers_all_compiled (tree type
)
1740 while (type
!= NULL_TREE
)
1742 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1744 type
= CLASSTYPE_SUPER (type
);
1750 add_table_and_syms (vec
<constructor_elt
, va_gc
> **v
,
1751 vec
<method_entry
, va_gc
> *methods
,
1752 const char *table_name
, tree table_slot
, tree table_type
,
1753 const char *syms_name
, tree syms_slot
)
1755 if (methods
== NULL
)
1757 PUSH_FIELD_VALUE (*v
, table_name
, null_pointer_node
);
1758 PUSH_FIELD_VALUE (*v
, syms_name
, null_pointer_node
);
1762 pushdecl_top_level (syms_slot
);
1763 PUSH_FIELD_VALUE (*v
, table_name
,
1764 build1 (ADDR_EXPR
, table_type
, table_slot
));
1765 PUSH_FIELD_VALUE (*v
, syms_name
,
1766 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1768 TREE_CONSTANT (table_slot
) = 1;
1773 make_class_data (tree type
)
1775 tree decl
, cons
, temp
;
1776 tree field
, fields_decl
;
1777 HOST_WIDE_INT static_field_count
= 0;
1778 HOST_WIDE_INT instance_field_count
= 0;
1779 HOST_WIDE_INT field_count
;
1780 tree field_array_type
;
1782 tree dtable_decl
= NULL_TREE
;
1783 HOST_WIDE_INT method_count
= 0;
1784 tree method_array_type
;
1787 tree this_class_addr
;
1788 tree constant_pool_constructor
;
1789 tree interfaces
= null_pointer_node
;
1790 int interface_len
= 0;
1791 int uses_jv_markobj
= 0;
1792 tree type_decl
= TYPE_NAME (type
);
1793 tree id_main
= get_identifier("main");
1794 tree id_class
= get_identifier("java.lang.Class");
1795 /** Offset from start of virtual function table declaration
1796 to where objects actually point at, following new g++ ABI. */
1797 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1798 vec
<int> field_indexes
;
1799 tree first_real_field
;
1800 vec
<constructor_elt
, va_gc
> *v1
= NULL
, *v2
= NULL
;
1801 tree reflection_data
;
1802 vec
<constructor_elt
, va_gc
> *static_fields
= NULL
;
1803 vec
<constructor_elt
, va_gc
> *instance_fields
= NULL
;
1804 vec
<constructor_elt
, va_gc
> *methods
= NULL
;
1806 this_class_addr
= build_static_class_ref (type
);
1807 decl
= TREE_OPERAND (this_class_addr
, 0);
1809 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1810 && !flag_indirect_dispatch
)
1812 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1813 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1814 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1816 /* We've already created some other class, and consequently
1817 we made class_dtable_decl. Now we just want to fill it
1819 dtable_decl
= class_dtable_decl
;
1823 dtable_decl
= build_dtable_decl (type
);
1824 TREE_STATIC (dtable_decl
) = 1;
1825 DECL_ARTIFICIAL (dtable_decl
) = 1;
1826 DECL_IGNORED_P (dtable_decl
) = 1;
1829 TREE_PUBLIC (dtable_decl
) = 1;
1830 DECL_INITIAL (dtable_decl
) = dtable
;
1831 /* The only dispatch table exported from a DSO is the dispatch
1832 table for java.lang.Class. */
1833 if (DECL_NAME (type_decl
) != id_class
)
1834 java_hide_decl (dtable_decl
);
1835 if (! flag_indirect_classes
)
1836 rest_of_decl_compilation (dtable_decl
, 1, 0);
1837 /* Maybe we're compiling Class as the first class. If so, set
1838 class_dtable_decl to the decl we just made. */
1839 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1840 class_dtable_decl
= dtable_decl
;
1843 /* Build Field array. */
1844 field
= TYPE_FIELDS (type
);
1845 while (field
&& DECL_ARTIFICIAL (field
))
1846 field
= DECL_CHAIN (field
); /* Skip dummy fields. */
1847 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1848 field
= DECL_CHAIN (field
); /* Skip dummy field for inherited data. */
1849 first_real_field
= field
;
1851 /* First count static and instance fields. */
1852 for ( ; field
!= NULL_TREE
; field
= DECL_CHAIN (field
))
1854 if (! DECL_ARTIFICIAL (field
))
1856 if (FIELD_STATIC (field
))
1857 static_field_count
++;
1858 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1859 instance_field_count
++;
1862 field_count
= static_field_count
+ instance_field_count
;
1863 field_indexes
.create (field_count
);
1865 /* gcj sorts fields so that static fields come first, followed by
1866 instance fields. Unfortunately, by the time this takes place we
1867 have already generated the reflection_data for this class, and
1868 that data contains indexes into the fields. So, we generate a
1869 permutation that maps each original field index to its final
1870 position. Then we pass this permutation to
1871 rewrite_reflection_indexes(), which fixes up the reflection
1875 int static_count
= 0;
1876 int instance_count
= static_field_count
;
1879 for (i
= 0, field
= first_real_field
;
1881 field
= DECL_CHAIN (field
), i
++)
1883 if (! DECL_ARTIFICIAL (field
))
1886 if (FIELD_STATIC (field
))
1887 field_index
= static_count
++;
1888 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1889 field_index
= instance_count
++;
1892 field_indexes
.quick_push (field_index
);
1897 for (field
= first_real_field
; field
!= NULL_TREE
;
1898 field
= DECL_CHAIN (field
))
1900 if (! DECL_ARTIFICIAL (field
))
1902 if (FIELD_STATIC (field
))
1904 /* We must always create reflection data for static fields
1905 as it is used in the creation of the field itself. */
1906 tree init
= make_field_value (field
);
1907 tree initial
= DECL_INITIAL (field
);
1908 CONSTRUCTOR_APPEND_ELT (static_fields
, NULL_TREE
, init
);
1909 /* If the initial value is a string constant,
1910 prevent output_constant from trying to assemble the value. */
1911 if (initial
!= NULL_TREE
1912 && TREE_TYPE (initial
) == string_ptr_type_node
)
1913 DECL_INITIAL (field
) = NULL_TREE
;
1914 rest_of_decl_compilation (field
, 1, 1);
1915 DECL_INITIAL (field
) = initial
;
1917 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1919 tree init
= make_field_value (field
);
1920 CONSTRUCTOR_APPEND_ELT (instance_fields
, NULL_TREE
, init
);
1925 gcc_assert (static_field_count
== (int) vec_safe_length (static_fields
));
1926 gcc_assert (instance_field_count
== (int) vec_safe_length (instance_fields
));
1928 if (field_count
> 0)
1930 vec_safe_splice (static_fields
, instance_fields
);
1931 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1932 fields_decl
= build_decl (input_location
,
1933 VAR_DECL
, mangled_classname ("_FL_", type
),
1935 DECL_INITIAL (fields_decl
)
1936 = build_constructor (field_array_type
, static_fields
);
1937 TREE_STATIC (fields_decl
) = 1;
1938 DECL_ARTIFICIAL (fields_decl
) = 1;
1939 DECL_IGNORED_P (fields_decl
) = 1;
1940 rest_of_decl_compilation (fields_decl
, 1, 0);
1943 fields_decl
= NULL_TREE
;
1945 /* Build Method array. */
1946 for (method
= TYPE_METHODS (type
);
1947 method
!= NULL_TREE
; method
= DECL_CHAIN (method
))
1950 if (METHOD_PRIVATE (method
)
1951 && ! flag_keep_inline_functions
1954 /* Even if we have a decl, we don't necessarily have the code.
1955 This can happen if we inherit a method from a superclass for
1956 which we don't have a .class file. */
1957 if (METHOD_DUMMY (method
))
1960 /* Generate method reflection data if:
1962 - !flag_reduced_reflection.
1964 - <clinit> -- The runtime uses reflection to initialize the
1967 - Any method in class java.lang.Class -- Class.forName() and
1968 perhaps other things require it.
1970 - class$ -- It does not work if reflection data missing.
1972 - main -- Reflection is used to find main(String[]) methods.
1974 - public not static -- It is potentially part of an
1975 interface. The runtime uses reflection data to build
1976 interface dispatch tables. */
1977 if (!flag_reduced_reflection
1978 || DECL_CLINIT_P (method
)
1979 || DECL_NAME (type_decl
) == id_class
1980 || DECL_NAME (method
) == id_main
1981 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1983 init
= make_method_value (method
);
1985 CONSTRUCTOR_APPEND_ELT (methods
, NULL_TREE
, init
);
1988 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1989 methods_decl
= build_decl (input_location
,
1990 VAR_DECL
, mangled_classname ("_MT_", type
),
1992 DECL_INITIAL (methods_decl
) = build_constructor (method_array_type
, methods
);
1993 TREE_STATIC (methods_decl
) = 1;
1994 DECL_ARTIFICIAL (methods_decl
) = 1;
1995 DECL_IGNORED_P (methods_decl
) = 1;
1996 rest_of_decl_compilation (methods_decl
, 1, 0);
1998 if (class_dtable_decl
== NULL_TREE
)
2000 class_dtable_decl
= build_dtable_decl (class_type_node
);
2001 TREE_STATIC (class_dtable_decl
) = 1;
2002 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
2003 DECL_IGNORED_P (class_dtable_decl
) = 1;
2004 if (is_compiled_class (class_type_node
) != 2)
2006 DECL_EXTERNAL (class_dtable_decl
) = 1;
2007 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
2011 super
= CLASSTYPE_SUPER (type
);
2012 if (super
== NULL_TREE
)
2013 super
= null_pointer_node
;
2014 else if (! flag_indirect_dispatch
2015 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
2016 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
2017 super
= build_class_ref (super
);
2020 int super_index
= alloc_class_constant (super
);
2021 super
= build_int_cst (ptr_type_node
, super_index
);
2024 /* Build and emit the array of implemented interfaces. */
2025 if (type
!= object_type_node
)
2026 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
2028 if (interface_len
> 0)
2031 tree interface_array_type
, idecl
;
2032 vec
<constructor_elt
, va_gc
> *init
;
2033 vec_alloc (init
, interface_len
);
2034 interface_array_type
2035 = build_prim_array_type (class_ptr_type
, interface_len
);
2036 idecl
= build_decl (input_location
,
2037 VAR_DECL
, mangled_classname ("_IF_", type
),
2038 interface_array_type
);
2040 for (i
= 1; i
<= interface_len
; i
++)
2042 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
2043 tree iclass
= BINFO_TYPE (child
);
2045 if (! flag_indirect_dispatch
2047 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
2048 index
= build_class_ref (iclass
);
2051 int int_index
= alloc_class_constant (iclass
);
2052 index
= build_int_cst (ptr_type_node
, int_index
);
2054 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, index
);
2056 DECL_INITIAL (idecl
) = build_constructor (interface_array_type
, init
);
2057 TREE_STATIC (idecl
) = 1;
2058 DECL_ARTIFICIAL (idecl
) = 1;
2059 DECL_IGNORED_P (idecl
) = 1;
2060 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
2061 rest_of_decl_compilation (idecl
, 1, 0);
2064 constant_pool_constructor
= build_constants_constructor ();
2066 if (flag_indirect_dispatch
)
2068 TYPE_OTABLE_DECL (type
)
2070 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
2071 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
2072 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
2074 TYPE_ATABLE_DECL (type
)
2076 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
2077 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
2078 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2080 TYPE_ITABLE_DECL (type
)
2082 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2083 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2084 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2087 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2089 START_RECORD_CONSTRUCTOR (v1
, object_type_node
);
2090 PUSH_FIELD_VALUE (v1
, "vtable",
2091 (flag_indirect_classes
2093 : fold_build_pointer_plus
2094 (build1 (ADDR_EXPR
, dtable_ptr_type
,
2096 dtable_start_offset
)));
2097 if (! flag_hash_synchronization
)
2098 PUSH_FIELD_VALUE (v1
, "sync_info", null_pointer_node
);
2099 FINISH_RECORD_CONSTRUCTOR (temp
, v1
, object_type_node
);
2100 START_RECORD_CONSTRUCTOR (v2
, class_type_node
);
2101 PUSH_SUPER_VALUE (v2
, temp
);
2102 PUSH_FIELD_VALUE (v2
, "next_or_version", gcj_abi_version
);
2103 PUSH_FIELD_VALUE (v2
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2104 PUSH_FIELD_VALUE (v2
, "accflags",
2105 build_int_cst (NULL_TREE
,
2106 get_access_flags_from_decl (type_decl
)));
2108 PUSH_FIELD_VALUE (v2
, "superclass",
2109 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2110 PUSH_FIELD_VALUE (v2
, "constants", constant_pool_constructor
);
2111 PUSH_FIELD_VALUE (v2
, "methods",
2112 methods_decl
== NULL_TREE
? null_pointer_node
2113 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2114 PUSH_FIELD_VALUE (v2
, "method_count",
2115 build_int_cst (NULL_TREE
, method_count
));
2117 PUSH_FIELD_VALUE (v2
, "vtable_method_count",
2118 (flag_indirect_dispatch
2119 ? integer_minus_one_node
2120 : TYPE_NVIRTUALS (type
)));
2122 PUSH_FIELD_VALUE (v2
, "fields",
2123 fields_decl
== NULL_TREE
? null_pointer_node
2124 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2125 /* If we're using the binary compatibility ABI we don't know the
2126 size until load time. */
2127 PUSH_FIELD_VALUE (v2
, "size_in_bytes",
2128 (flag_indirect_dispatch
2129 ? integer_minus_one_node
2130 : size_in_bytes (type
)));
2131 PUSH_FIELD_VALUE (v2
, "field_count",
2132 build_int_cst (NULL_TREE
, field_count
));
2133 PUSH_FIELD_VALUE (v2
, "static_field_count",
2134 build_int_cst (NULL_TREE
, static_field_count
));
2136 PUSH_FIELD_VALUE (v2
, "vtable",
2137 (flag_indirect_dispatch
|| dtable_decl
== NULL_TREE
2139 : fold_build_pointer_plus
2140 (build1 (ADDR_EXPR
, dtable_ptr_type
,
2142 dtable_start_offset
)));
2143 add_table_and_syms (&v2
, TYPE_OTABLE_METHODS (type
),
2144 "otable", TYPE_OTABLE_DECL (type
), otable_ptr_type
,
2145 "otable_syms", TYPE_OTABLE_SYMS_DECL (type
));
2146 add_table_and_syms (&v2
, TYPE_ATABLE_METHODS (type
),
2147 "atable", TYPE_ATABLE_DECL (type
), atable_ptr_type
,
2148 "atable_syms", TYPE_ATABLE_SYMS_DECL (type
));
2149 add_table_and_syms (&v2
, TYPE_ITABLE_METHODS (type
),
2150 "itable", TYPE_ITABLE_DECL (type
), itable_ptr_type
,
2151 "itable_syms", TYPE_ITABLE_SYMS_DECL (type
));
2153 PUSH_FIELD_VALUE (v2
, "catch_classes",
2154 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2155 PUSH_FIELD_VALUE (v2
, "interfaces", interfaces
);
2156 PUSH_FIELD_VALUE (v2
, "loader", null_pointer_node
);
2157 PUSH_FIELD_VALUE (v2
, "interface_count",
2158 build_int_cst (NULL_TREE
, interface_len
));
2159 PUSH_FIELD_VALUE (v2
, "state",
2160 convert (byte_type_node
,
2161 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2163 PUSH_FIELD_VALUE (v2
, "thread", null_pointer_node
);
2164 PUSH_FIELD_VALUE (v2
, "depth", integer_zero_node
);
2165 PUSH_FIELD_VALUE (v2
, "ancestors", null_pointer_node
);
2166 PUSH_FIELD_VALUE (v2
, "idt", null_pointer_node
);
2167 PUSH_FIELD_VALUE (v2
, "arrayclass", null_pointer_node
);
2168 PUSH_FIELD_VALUE (v2
, "protectionDomain", null_pointer_node
);
2171 tree assertion_table_ref
;
2172 if (TYPE_ASSERTIONS (type
) == NULL
)
2173 assertion_table_ref
= null_pointer_node
;
2175 assertion_table_ref
= build1 (ADDR_EXPR
,
2176 build_pointer_type (assertion_table_type
),
2177 emit_assertion_table (type
));
2179 PUSH_FIELD_VALUE (v2
, "assertion_table", assertion_table_ref
);
2182 PUSH_FIELD_VALUE (v2
, "hack_signers", null_pointer_node
);
2183 PUSH_FIELD_VALUE (v2
, "chain", null_pointer_node
);
2184 PUSH_FIELD_VALUE (v2
, "aux_info", null_pointer_node
);
2185 PUSH_FIELD_VALUE (v2
, "engine", null_pointer_node
);
2187 if (TYPE_REFLECTION_DATA (current_class
))
2190 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2191 vec
<constructor_elt
, va_gc
> *v
;
2192 vec_alloc (v
, count
);
2193 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2194 tree max_index
= build_int_cst (sizetype
, count
);
2195 tree index
= build_index_type (max_index
);
2196 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2199 static int reflection_data_count
;
2201 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2202 array
= build_decl (input_location
,
2203 VAR_DECL
, get_identifier (buf
), type
);
2205 rewrite_reflection_indexes (&field_indexes
);
2207 for (i
= 0; i
< count
; i
++)
2209 constructor_elt elt
;
2210 elt
.index
= build_int_cst (sizetype
, i
);
2211 elt
.value
= build_int_cstu (byte_type_node
, data
[i
]);
2212 v
->quick_push (elt
);
2215 DECL_INITIAL (array
) = build_constructor (type
, v
);
2216 TREE_STATIC (array
) = 1;
2217 DECL_ARTIFICIAL (array
) = 1;
2218 DECL_IGNORED_P (array
) = 1;
2219 TREE_READONLY (array
) = 1;
2220 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2221 rest_of_decl_compilation (array
, 1, 0);
2223 reflection_data
= build_address_of (array
);
2226 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2229 reflection_data
= null_pointer_node
;
2231 PUSH_FIELD_VALUE (v2
, "reflection_data", reflection_data
);
2232 FINISH_RECORD_CONSTRUCTOR (cons
, v2
, class_type_node
);
2234 DECL_INITIAL (decl
) = cons
;
2236 /* Hash synchronization requires at least 64-bit alignment. */
2237 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2238 DECL_ALIGN (decl
) = 64;
2240 if (flag_indirect_classes
)
2242 TREE_READONLY (decl
) = 1;
2243 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2246 rest_of_decl_compilation (decl
, 1, 0);
2249 tree classdollar_field
= build_classdollar_field (type
);
2250 if (!flag_indirect_classes
)
2251 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2252 rest_of_decl_compilation (classdollar_field
, 1, 0);
2255 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2256 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2257 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2263 java_expand_catch_classes (current_class
);
2265 current_function_decl
= NULL_TREE
;
2266 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2267 make_class_data (current_class
);
2269 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2272 /* Return 2 if KLASS is compiled by this compilation job;
2273 return 1 if KLASS can otherwise be assumed to be compiled;
2274 return 0 if we cannot assume that KLASS is compiled.
2275 Returns 1 for primitive and 0 for array types. */
2277 is_compiled_class (tree klass
)
2280 if (TREE_CODE (klass
) == POINTER_TYPE
)
2281 klass
= TREE_TYPE (klass
);
2282 if (TREE_CODE (klass
) != RECORD_TYPE
) /* Primitive types are static. */
2284 if (TYPE_ARRAY_P (klass
))
2287 seen_in_zip
= (TYPE_JCF (klass
) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass
)));
2288 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2290 /* The class was seen in the current ZIP file and will be
2291 available as a compiled class in the future but may not have
2292 been loaded already. Load it if necessary. This prevent
2293 build_class_ref () from crashing. */
2295 if (seen_in_zip
&& !CLASS_LOADED_P (klass
) && (klass
!= current_class
))
2296 load_class (klass
, 1);
2298 /* We return 2 for class seen in ZIP and class from files
2299 belonging to the same compilation unit */
2303 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass
)))))
2305 if (!CLASS_LOADED_P (klass
))
2307 if (klass
!= current_class
)
2308 load_class (klass
, 1);
2316 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2319 build_dtable_decl (tree type
)
2323 /* We need to build a new dtable type so that its size is uniquely
2324 computed when we're dealing with the class for real and not just
2325 faking it (like java.lang.Class during the initialization of the
2326 compiler.) We know we're not faking a class when CURRENT_CLASS is
2328 if (current_class
== type
)
2330 tree dummy
= NULL_TREE
;
2333 dtype
= make_node (RECORD_TYPE
);
2335 PUSH_FIELD (input_location
, dtype
, dummy
, "top_offset", ptr_type_node
);
2336 PUSH_FIELD (input_location
, dtype
, dummy
, "type_info", ptr_type_node
);
2338 PUSH_FIELD (input_location
, dtype
, dummy
, "class", class_ptr_type
);
2339 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2341 tree tmp_field
= build_decl (input_location
,
2342 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2343 TREE_CHAIN (dummy
) = tmp_field
;
2344 DECL_CONTEXT (tmp_field
) = dtype
;
2345 DECL_ARTIFICIAL (tmp_field
) = 1;
2349 PUSH_FIELD (input_location
, dtype
, dummy
, "gc_descr", ptr_type_node
);
2350 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2352 tree tmp_field
= build_decl (input_location
,
2353 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2354 TREE_CHAIN (dummy
) = tmp_field
;
2355 DECL_CONTEXT (tmp_field
) = dtype
;
2356 DECL_ARTIFICIAL (tmp_field
) = 1;
2360 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2361 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2362 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2364 PUSH_FIELD (input_location
, dtype
, dummy
, "methods",
2365 build_prim_array_type (nativecode_ptr_type_node
, n
));
2366 layout_type (dtype
);
2369 dtype
= dtable_type
;
2371 decl
= build_decl (input_location
,
2372 VAR_DECL
, get_identifier ("vt$"), dtype
);
2373 DECL_CONTEXT (decl
) = type
;
2374 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2375 DECL_VTABLE_P (decl
) = 1;
2380 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2381 fields inherited from SUPER_CLASS. */
2384 push_super_field (tree this_class
, tree super_class
)
2387 /* Don't insert the field if we're just re-laying the class out. */
2388 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2390 base_decl
= build_decl (input_location
,
2391 FIELD_DECL
, NULL_TREE
, super_class
);
2392 DECL_IGNORED_P (base_decl
) = 1;
2393 DECL_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2394 TYPE_FIELDS (this_class
) = base_decl
;
2395 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2396 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2399 /* Handle the different manners we may have to lay out a super class. */
2402 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2406 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2408 if (!CLASS_LOADED_P (super_class
))
2409 load_class (super_class
, 1);
2411 /* We might have to layout the class before its dependency on
2412 the super class gets resolved by java_complete_class */
2413 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2415 if (TREE_TYPE (super_class
) != NULL_TREE
)
2416 super_class
= TREE_TYPE (super_class
);
2420 if (!TYPE_SIZE (super_class
))
2421 safe_layout_class (super_class
);
2426 /* safe_layout_class just makes sure that we can load a class without
2427 disrupting the current_class, input_location, etc, information
2428 about the class processed currently. */
2431 safe_layout_class (tree klass
)
2433 tree save_current_class
= current_class
;
2434 location_t save_location
= input_location
;
2436 layout_class (klass
);
2438 current_class
= save_current_class
;
2439 input_location
= save_location
;
2443 layout_class (tree this_class
)
2446 tree super_class
= CLASSTYPE_SUPER (this_class
);
2448 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2449 if (CLASS_BEING_LAIDOUT (this_class
))
2455 sprintf (buffer
, " with '%s'",
2456 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2457 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2459 for (current
= TREE_CHAIN (class_list
); current
;
2460 current
= TREE_CHAIN (current
))
2462 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2463 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2464 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2465 DECL_SOURCE_FILE (decl
),
2466 DECL_SOURCE_LINE (decl
));
2467 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2469 obstack_1grow (&temporary_obstack
, '\0');
2470 report
= XOBFINISH (&temporary_obstack
, char *);
2471 cyclic_inheritance_report
= ggc_strdup (report
);
2472 obstack_free (&temporary_obstack
, report
);
2473 TYPE_SIZE (this_class
) = error_mark_node
;
2476 CLASS_BEING_LAIDOUT (this_class
) = 1;
2478 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2480 tree maybe_super_class
2481 = maybe_layout_super_class (super_class
, this_class
);
2482 if (maybe_super_class
== NULL
2483 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2485 TYPE_SIZE (this_class
) = error_mark_node
;
2486 CLASS_BEING_LAIDOUT (this_class
) = 0;
2487 class_list
= TREE_CHAIN (class_list
);
2490 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2491 push_super_field (this_class
, maybe_super_class
);
2494 layout_type (this_class
);
2496 /* Also recursively load/layout any superinterfaces. */
2497 if (TYPE_BINFO (this_class
))
2499 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2501 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2502 tree super_interface
= BINFO_TYPE (binfo
);
2503 tree maybe_super_interface
2504 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2505 if (maybe_super_interface
== NULL
2506 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2508 TYPE_SIZE (this_class
) = error_mark_node
;
2509 CLASS_BEING_LAIDOUT (this_class
) = 0;
2510 class_list
= TREE_CHAIN (class_list
);
2516 /* Convert the size back to an SI integer value. */
2517 TYPE_SIZE_UNIT (this_class
) =
2518 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2520 CLASS_BEING_LAIDOUT (this_class
) = 0;
2521 class_list
= TREE_CHAIN (class_list
);
2525 add_miranda_methods (tree base_class
, tree search_class
)
2528 tree binfo
, base_binfo
;
2530 if (!CLASS_PARSED_P (search_class
))
2531 load_class (search_class
, 1);
2533 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2534 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2537 tree elt
= BINFO_TYPE (base_binfo
);
2539 /* FIXME: This is totally bogus. We should not be handling
2540 Miranda methods at all if we're using the BC ABI. */
2541 if (TYPE_DUMMY (elt
))
2544 /* Ensure that interface methods are seen in declared order. */
2545 if (!CLASS_LOADED_P (elt
))
2546 load_class (elt
, 1);
2547 layout_class_methods (elt
);
2549 /* All base classes will have been laid out at this point, so the order
2550 will be correct. This code must match similar layout code in the
2552 for (method_decl
= TYPE_METHODS (elt
);
2553 method_decl
; method_decl
= DECL_CHAIN (method_decl
))
2557 /* An interface can have <clinit>. */
2558 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2561 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2562 override
= lookup_argument_method (base_class
,
2563 DECL_NAME (method_decl
), sig
);
2564 if (override
== NULL_TREE
)
2566 /* Found a Miranda method. Add it. */
2568 sig
= build_java_signature (TREE_TYPE (method_decl
));
2570 = add_method (base_class
,
2571 get_access_flags_from_decl (method_decl
),
2572 DECL_NAME (method_decl
), sig
);
2573 METHOD_INVISIBLE (new_method
) = 1;
2577 /* Try superinterfaces. */
2578 add_miranda_methods (base_class
, elt
);
2583 layout_class_methods (tree this_class
)
2585 tree method_decl
, dtable_count
;
2586 tree super_class
, type_name
;
2588 if (TYPE_NVIRTUALS (this_class
))
2591 super_class
= CLASSTYPE_SUPER (this_class
);
2595 super_class
= maybe_layout_super_class (super_class
, this_class
);
2596 if (!TYPE_NVIRTUALS (super_class
))
2597 layout_class_methods (super_class
);
2598 dtable_count
= TYPE_NVIRTUALS (super_class
);
2601 dtable_count
= integer_zero_node
;
2603 type_name
= TYPE_NAME (this_class
);
2604 if (!flag_indirect_dispatch
2605 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2607 /* An abstract class can have methods which are declared only in
2608 an implemented interface. These are called "Miranda
2609 methods". We make a dummy method entry for such methods
2611 add_miranda_methods (this_class
, this_class
);
2614 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2616 for (method_decl
= TYPE_METHODS (this_class
);
2617 method_decl
; method_decl
= DECL_CHAIN (method_decl
))
2618 dtable_count
= layout_class_method (this_class
, super_class
,
2619 method_decl
, dtable_count
);
2621 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2624 /* Return the index of METHOD in INTERFACE. This index begins at 1
2625 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2627 get_interface_method_index (tree method
, tree interface
)
2632 for (meth
= TYPE_METHODS (interface
); ; meth
= DECL_CHAIN (meth
))
2636 /* We don't want to put <clinit> into the interface table. */
2637 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2639 gcc_assert (meth
!= NULL_TREE
);
2643 /* Lay METHOD_DECL out, returning a possibly new value of
2644 DTABLE_COUNT. Also mangle the method's name. */
2647 layout_class_method (tree this_class
, tree super_class
,
2648 tree method_decl
, tree dtable_count
)
2650 tree method_name
= DECL_NAME (method_decl
);
2652 TREE_PUBLIC (method_decl
) = 1;
2654 if (flag_indirect_classes
2655 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2656 && ! METHOD_NATIVE (method_decl
)
2657 && ! special_method_p (method_decl
)))
2658 java_hide_decl (method_decl
);
2660 /* Considered external unless it is being compiled into this object
2661 file, or it was already flagged as external. */
2662 if (!DECL_EXTERNAL (method_decl
))
2663 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2664 || METHOD_NATIVE (method_decl
));
2666 if (ID_INIT_P (method_name
))
2668 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2670 for (ptr
= p
; *ptr
; )
2675 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2676 build_java_signature (TREE_TYPE (method_decl
));
2678 else if (! METHOD_STATIC (method_decl
))
2681 build_java_signature (TREE_TYPE (method_decl
));
2682 bool method_override
= false;
2683 tree super_method
= lookup_java_method (super_class
, method_name
,
2685 if (super_method
!= NULL_TREE
2686 && ! METHOD_DUMMY (super_method
))
2688 method_override
= true;
2689 if (! METHOD_PUBLIC (super_method
) &&
2690 ! METHOD_PROTECTED (super_method
))
2692 /* Don't override private method, or default-access method in
2694 if (METHOD_PRIVATE (super_method
) ||
2695 ! in_same_package (TYPE_NAME (this_class
),
2696 TYPE_NAME (super_class
)))
2697 method_override
= false;
2700 if (method_override
)
2702 tree method_index
= get_method_index (super_method
);
2703 set_method_index (method_decl
, method_index
);
2704 if (method_index
== NULL_TREE
2705 && ! flag_indirect_dispatch
2706 && ! DECL_ARTIFICIAL (super_method
))
2707 error ("non-static method %q+D overrides static method",
2710 else if (this_class
== object_type_node
2711 && (METHOD_FINAL (method_decl
)
2712 || METHOD_PRIVATE (method_decl
)))
2714 /* We don't generate vtable entries for final Object
2715 methods. This is simply to save space, since every
2716 object would otherwise have to define them. */
2718 else if (! METHOD_PRIVATE (method_decl
)
2721 /* We generate vtable entries for final methods because they
2722 may one day be changed to non-final. */
2723 set_method_index (method_decl
, dtable_count
);
2724 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2725 dtable_count
, integer_one_node
);
2729 return dtable_count
;
2733 register_class (void)
2737 if (!registered_class
)
2738 vec_alloc (registered_class
, 8);
2740 if (flag_indirect_classes
)
2741 node
= current_class
;
2743 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2744 vec_safe_push (registered_class
, node
);
2747 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2748 all the classes we have emitted. */
2751 emit_indirect_register_classes (tree
*list_p
)
2753 tree klass
, t
, register_class_fn
;
2756 int size
= vec_safe_length (registered_class
) * 2 + 1;
2757 vec
<constructor_elt
, va_gc
> *init
;
2758 vec_alloc (init
, size
);
2759 tree class_array_type
2760 = build_prim_array_type (ptr_type_node
, size
);
2761 tree
cdecl = build_decl (input_location
,
2762 VAR_DECL
, get_identifier ("_Jv_CLS"),
2764 tree reg_class_list
;
2765 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2767 t
= fold_convert (ptr_type_node
, build_static_class_ref (klass
));
2768 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, t
);
2769 t
= fold_convert (ptr_type_node
,
2770 build_address_of (build_classdollar_field (klass
)));
2771 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, t
);
2773 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, integer_zero_node
);
2774 DECL_INITIAL (cdecl) = build_constructor (class_array_type
, init
);
2775 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2776 TREE_STATIC (cdecl) = 1;
2777 DECL_ARTIFICIAL (cdecl) = 1;
2778 DECL_IGNORED_P (cdecl) = 1;
2779 TREE_READONLY (cdecl) = 1;
2780 TREE_CONSTANT (cdecl) = 1;
2781 rest_of_decl_compilation (cdecl, 1, 0);
2782 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2784 t
= build_function_type_list (void_type_node
,
2785 build_pointer_type (ptr_type_node
), NULL
);
2786 t
= build_decl (input_location
,
2788 get_identifier ("_Jv_RegisterNewClasses"), t
);
2789 TREE_PUBLIC (t
) = 1;
2790 DECL_EXTERNAL (t
) = 1;
2791 register_class_fn
= t
;
2792 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2793 append_to_statement_list (t
, list_p
);
2796 /* Emit a list of pointers to all classes we have emitted to JCR_SECTION. */
2799 emit_register_classes_in_jcr_section (void)
2801 #ifdef JCR_SECTION_NAME
2802 tree klass
, cdecl, class_array_type
;
2804 int size
= vec_safe_length (registered_class
);
2805 vec
<constructor_elt
, va_gc
> *init
;
2806 vec_alloc (init
, size
);
2808 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2809 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, build_fold_addr_expr (klass
));
2811 /* ??? I would like to use tree_output_constant_def() but there is no way
2812 to put the data in a named section name, or to set the alignment,
2813 via that function. So do everything manually here. */
2814 class_array_type
= build_prim_array_type (ptr_type_node
, size
);
2815 cdecl = build_decl (UNKNOWN_LOCATION
,
2816 VAR_DECL
, get_identifier ("_Jv_JCR_SECTION_data"),
2818 DECL_ALIGN (cdecl) = POINTER_SIZE
;
2819 DECL_USER_ALIGN (cdecl) = 1;
2820 DECL_INITIAL (cdecl) = build_constructor (class_array_type
, init
);
2821 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2822 TREE_STATIC (cdecl) = 1;
2823 TREE_READONLY (cdecl) = 0;
2824 TREE_CONSTANT (cdecl) = 1;
2825 DECL_ARTIFICIAL (cdecl) = 1;
2826 DECL_IGNORED_P (cdecl) = 1;
2827 DECL_PRESERVE_P (cdecl) = 1;
2828 set_decl_section_name (cdecl, JCR_SECTION_NAME
);
2829 pushdecl_top_level (cdecl);
2830 relayout_decl (cdecl);
2831 rest_of_decl_compilation (cdecl, 1, 0);
2833 /* A target has defined TARGET_USE_JCR_SECTION,
2834 but doesn't have a JCR_SECTION_NAME. */
2840 /* Emit a series of calls to _Jv_RegisterClass for every class we emitted.
2841 A series of calls is added to LIST_P. */
2844 emit_Jv_RegisterClass_calls (tree
*list_p
)
2846 tree klass
, t
, register_class_fn
;
2849 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2850 t
= build_decl (input_location
,
2851 FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2852 TREE_PUBLIC (t
) = 1;
2853 DECL_EXTERNAL (t
) = 1;
2854 register_class_fn
= t
;
2856 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2858 t
= build_fold_addr_expr (klass
);
2859 t
= build_call_expr (register_class_fn
, 1, t
);
2860 append_to_statement_list (t
, list_p
);
2864 /* Emit something to register classes at start-up time.
2866 The default mechanism is to generate instances at run-time.
2868 An alternative mechanism is through the .jcr section, which contain
2869 a list of pointers to classes which get registered during constructor
2872 The fallback mechanism is to add statements to *LIST_P to call
2873 _Jv_RegisterClass for each class in this file. These statements will
2874 be added to a static constructor function for this translation unit. */
2877 emit_register_classes (tree
*list_p
)
2879 if (registered_class
== NULL
)
2882 /* By default, generate instances of Class at runtime. */
2883 if (flag_indirect_classes
)
2884 emit_indirect_register_classes (list_p
);
2885 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2886 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2887 but lack suitable crtbegin/end objects or linker support. These
2888 targets can override the default in tm.h to use the fallback mechanism. */
2889 else if (TARGET_USE_JCR_SECTION
)
2890 emit_register_classes_in_jcr_section ();
2891 /* Use the fallback mechanism. */
2893 emit_Jv_RegisterClass_calls (list_p
);
2896 /* Build a constructor for an entry in the symbol table. */
2899 build_symbol_table_entry (tree clname
, tree name
, tree signature
)
2902 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2904 START_RECORD_CONSTRUCTOR (v
, symbol_type
);
2905 PUSH_FIELD_VALUE (v
, "clname", clname
);
2906 PUSH_FIELD_VALUE (v
, "name", name
);
2907 PUSH_FIELD_VALUE (v
, "signature", signature
);
2908 FINISH_RECORD_CONSTRUCTOR (symbol
, v
, symbol_type
);
2909 TREE_CONSTANT (symbol
) = 1;
2914 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2917 build_symbol_entry (tree decl
, tree special
)
2919 tree clname
, name
, signature
;
2920 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2921 /* ??? Constructors are given the name foo.foo all the way through
2922 the compiler, but in the method table they're all renamed
2923 foo.<init>. So, we have to do the same here unless we want an
2924 unresolved reference at runtime. */
2925 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2926 && DECL_CONSTRUCTOR_P (decl
))
2927 ? init_identifier_node
2928 : DECL_NAME (decl
));
2929 signature
= build_java_signature (TREE_TYPE (decl
));
2930 signature
= build_utf8_ref (unmangle_classname
2931 (IDENTIFIER_POINTER (signature
),
2932 IDENTIFIER_LENGTH (signature
)));
2933 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2934 signature addr+1 if SPECIAL, and this indicates to the runtime
2935 system that this is a "special" symbol, i.e. one that should
2936 bypass access controls. */
2937 if (special
!= NULL_TREE
)
2938 signature
= fold_build_pointer_plus (signature
, special
);
2940 return build_symbol_table_entry (clname
, name
, signature
);
2943 /* Emit a symbol table: used by -findirect-dispatch. */
2946 emit_symbol_table (tree name
, tree the_table
,
2947 vec
<method_entry
, va_gc
> *decl_table
,
2948 tree the_syms_decl
, tree the_array_element_type
,
2951 tree table
, null_symbol
, table_size
, the_array_type
;
2954 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2956 /* Only emit a table if this translation unit actually made any
2957 references via it. */
2961 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2962 FOR_EACH_VEC_ELT (*decl_table
, index
, e
)
2963 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
2964 build_symbol_entry (e
->method
, e
->special
));
2966 /* Terminate the list with a "null" entry. */
2967 null_symbol
= build_symbol_table_entry (null_pointer_node
,
2970 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, null_symbol
);
2972 tree symbols_arr_type
2973 = build_prim_array_type (symbol_type
, vec_safe_length (v
));
2975 table
= build_constructor (symbols_arr_type
, v
);
2977 /* Make it the initial value for otable_syms and emit the decl. */
2978 TREE_TYPE (the_syms_decl
) = symbols_arr_type
;
2979 relayout_decl (the_syms_decl
);
2980 DECL_INITIAL (the_syms_decl
) = table
;
2981 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2982 DECL_IGNORED_P (the_syms_decl
) = 1;
2983 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2985 /* Now that its size is known, redefine the table as an
2986 uninitialized static array of INDEX + 1 elements. The extra entry
2987 is used by the runtime to track whether the table has been
2990 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2991 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2992 the_table
= build_decl (input_location
,
2993 VAR_DECL
, name
, the_array_type
);
2994 TREE_STATIC (the_table
) = 1;
2995 TREE_READONLY (the_table
) = 1;
2996 rest_of_decl_compilation (the_table
, 1, 0);
3001 /* Make an entry for the catch_classes list. */
3003 make_catch_class_record (tree catch_class
, tree classname
)
3006 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
3007 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3008 START_RECORD_CONSTRUCTOR (v
, type
);
3009 PUSH_FIELD_VALUE (v
, "address", catch_class
);
3010 PUSH_FIELD_VALUE (v
, "classname", classname
);
3011 FINISH_RECORD_CONSTRUCTOR (entry
, v
, type
);
3016 /* Generate the list of Throwable classes that are caught by exception
3017 handlers in this class. */
3019 emit_catch_table (tree this_class
)
3021 tree table
, table_size
, array_type
;
3022 int n_catch_classes
;
3024 /* Fill in the dummy entry that make_class created. */
3025 e
= &(*TYPE_CATCH_CLASSES (this_class
))[0];
3026 e
->value
= make_catch_class_record (null_pointer_node
, null_pointer_node
);
3027 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class
), NULL_TREE
,
3028 make_catch_class_record (null_pointer_node
,
3029 null_pointer_node
));
3030 n_catch_classes
= TYPE_CATCH_CLASSES (this_class
)->length ();
3031 table_size
= build_index_type (build_int_cst (NULL_TREE
, n_catch_classes
));
3033 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
3036 build_decl (input_location
,
3037 VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
3038 DECL_INITIAL (table
) =
3039 build_constructor (array_type
, TYPE_CATCH_CLASSES (this_class
));
3040 TREE_STATIC (table
) = 1;
3041 TREE_READONLY (table
) = 1;
3042 DECL_IGNORED_P (table
) = 1;
3043 rest_of_decl_compilation (table
, 1, 0);
3047 /* Given a type, return the signature used by
3048 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
3049 same as build_java_signature() because we want the canonical array
3053 build_signature_for_libgcj (tree type
)
3057 sig
= build_java_signature (type
);
3058 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
3059 IDENTIFIER_LENGTH (sig
)));
3063 /* Build an entry in the type assertion table. */
3066 build_assertion_table_entry (tree code
, tree op1
, tree op2
)
3068 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3071 START_RECORD_CONSTRUCTOR (v
, assertion_entry_type
);
3072 PUSH_FIELD_VALUE (v
, "assertion_code", code
);
3073 PUSH_FIELD_VALUE (v
, "op1", op1
);
3074 PUSH_FIELD_VALUE (v
, "op2", op2
);
3075 FINISH_RECORD_CONSTRUCTOR (entry
, v
, assertion_entry_type
);
3080 /* Add an entry to the type assertion table. Callback used during hashtable
3084 add_assertion_table_entry (type_assertion
**slot
, vec
<constructor_elt
, va_gc
> **v
)
3087 tree code_val
, op1_utf8
, op2_utf8
;
3088 type_assertion
*as
= *slot
;
3090 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
3092 if (as
->op1
== NULL_TREE
)
3093 op1_utf8
= null_pointer_node
;
3095 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3097 if (as
->op2
== NULL_TREE
)
3098 op2_utf8
= null_pointer_node
;
3100 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3102 entry
= build_assertion_table_entry (code_val
, op1_utf8
, op2_utf8
);
3104 CONSTRUCTOR_APPEND_ELT (*v
, NULL_TREE
, entry
);
3108 /* Generate the type assertion table for KLASS, and return its DECL. */
3111 emit_assertion_table (tree klass
)
3113 tree null_entry
, ctor
, table_decl
;
3114 hash_table
<type_assertion_hasher
> *assertions_htab
= TYPE_ASSERTIONS (klass
);
3115 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3117 /* Iterate through the hash table. */
3119 ->traverse
<vec
<constructor_elt
, va_gc
> **, add_assertion_table_entry
> (&v
);
3121 /* Finish with a null entry. */
3122 null_entry
= build_assertion_table_entry (integer_zero_node
,
3126 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, null_entry
);
3129 = build_prim_array_type (assertion_entry_type
, vec_safe_length (v
));
3131 ctor
= build_constructor (type
, v
);
3133 table_decl
= build_decl (input_location
,
3134 VAR_DECL
, mangled_classname ("_type_assert_", klass
),
3137 TREE_STATIC (table_decl
) = 1;
3138 TREE_READONLY (table_decl
) = 1;
3139 TREE_CONSTANT (table_decl
) = 1;
3140 DECL_IGNORED_P (table_decl
) = 1;
3142 DECL_INITIAL (table_decl
) = ctor
;
3143 DECL_ARTIFICIAL (table_decl
) = 1;
3144 rest_of_decl_compilation (table_decl
, 1, 0);
3150 init_class_processing (void)
3152 fields_ident
= get_identifier ("fields");
3153 info_ident
= get_identifier ("info");
3155 gcc_obstack_init (&temporary_obstack
);
3158 /* A hash table mapping trees to trees. Used generally. */
3160 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3163 treetreehasher::hash (treetreehash_entry
*k
)
3165 return JAVA_TREEHASHHASH_H (k
->key
);
3169 treetreehasher::equal (treetreehash_entry
*k1
, tree k2
)
3171 return (k1
->key
== k2
);
3175 java_treetreehash_find (hash_table
<treetreehasher
> *ht
, tree t
)
3177 struct treetreehash_entry
*e
;
3178 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3179 e
= ht
->find_with_hash (t
, hv
);
3187 java_treetreehash_new (hash_table
<treetreehasher
> *ht
, tree t
)
3189 struct treetreehash_entry
*tthe
;
3190 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3192 treetreehash_entry
**e
= ht
->find_slot_with_hash (t
, hv
, INSERT
);
3195 tthe
= ggc_cleared_alloc
<treetreehash_entry
> ();
3201 return &tthe
->value
;
3204 hash_table
<treetreehasher
> *
3205 java_treetreehash_create (size_t size
)
3207 return hash_table
<treetreehasher
>::create_ggc (size
);
3210 /* Break down qualified IDENTIFIER into package and class-name components.
3211 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3212 "pkg.foo", and RIGHT to "Bar". */
3215 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3218 int l
= IDENTIFIER_LENGTH (source
);
3220 base
= (char *) alloca (l
+ 1);
3221 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3223 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3225 while (*p
!= '.' && p
!= base
)
3228 /* We didn't find a '.'. Return an error. */
3234 *right
= get_identifier (p
+1);
3235 *left
= get_identifier (base
);
3240 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3241 if the classes are from the same package. */
3244 in_same_package (tree name1
, tree name2
)
3250 if (TREE_CODE (name1
) == TYPE_DECL
)
3251 name1
= DECL_NAME (name1
);
3252 if (TREE_CODE (name2
) == TYPE_DECL
)
3253 name2
= DECL_NAME (name2
);
3255 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3256 /* One in empty package. */
3259 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3260 /* Both in empty package. */
3263 split_qualified_name (&pkg1
, &tmp
, name1
);
3264 split_qualified_name (&pkg2
, &tmp
, name2
);
3266 return (pkg1
== pkg2
);
3269 /* lang_hooks.decls.final_write_globals: perform final processing on
3270 global variables. */
3273 java_write_globals (void)
3275 tree
*vec
= vec_safe_address (pending_static_fields
);
3276 int len
= vec_safe_length (pending_static_fields
);
3277 write_global_declarations ();
3278 emit_debug_global_declarations (vec
, len
);
3279 vec_free (pending_static_fields
);
3282 #include "gt-java-class.h"