1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996-2013 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 */
44 #include "tree-iterator.h"
47 static tree
make_method_value (tree
);
48 static tree
build_java_method_type (tree
, tree
, int);
49 static int32
hashUtf8String (const char *, int);
50 static tree
make_field_value (tree
);
51 static tree
get_dispatch_vector (tree
);
52 static tree
get_dispatch_table (tree
, tree
);
53 static int supers_all_compiled (tree type
);
54 static tree
maybe_layout_super_class (tree
, tree
);
55 static void add_miranda_methods (tree
, tree
);
56 static int assume_compiled (const char *);
57 static tree
build_symbol_entry (tree
, tree
);
58 static tree
emit_assertion_table (tree
);
59 static void register_class (void);
61 struct obstack temporary_obstack
;
63 static const char *cyclic_inheritance_report
;
65 /* The compiler generates different code depending on whether or not
66 it can assume certain classes have been compiled down to native
67 code or not. The compiler options -fassume-compiled= and
68 -fno-assume-compiled= are used to create a tree of
69 class_flag_node objects. This tree is queried to determine if
70 a class is assume to be compiled or not. Each node in the tree
71 represents either a package or a specific class. */
73 typedef struct class_flag_node_struct
75 /* The class or package name. */
78 /* Nonzero if this represents an exclusion. */
81 /* Pointers to other nodes in the tree. */
82 struct class_flag_node_struct
*parent
;
83 struct class_flag_node_struct
*sibling
;
84 struct class_flag_node_struct
*child
;
87 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
88 static void add_class_flag (class_flag_node
**, const char *, int);
90 /* This is the root of the include/exclude tree. */
92 static class_flag_node
*assume_compiled_tree
;
94 static class_flag_node
*enable_assert_tree
;
96 static GTY(()) tree class_roots
[4];
97 #define fields_ident class_roots[0] /* get_identifier ("fields") */
98 #define info_ident class_roots[1] /* get_identifier ("info") */
99 #define class_list class_roots[2]
100 #define class_dtable_decl class_roots[3]
102 static GTY(()) vec
<tree
, va_gc
> *registered_class
;
104 /* A tree that returns the address of the class$ of the class
105 currently being compiled. */
106 static GTY(()) tree this_classdollar
;
108 /* A list of static class fields. This is to emit proper debug
110 vec
<tree
, va_gc
> *pending_static_fields
;
112 /* Return the node that most closely represents the class whose name
113 is IDENT. Start the search from NODE (followed by its siblings).
114 Return NULL if an appropriate node does not exist. */
116 static class_flag_node
*
117 find_class_flag_node (class_flag_node
*node
, const char *ident
)
121 size_t node_ident_length
= strlen (node
->ident
);
123 /* node_ident_length is zero at the root of the tree. If the
124 identifiers are the same length, then we have matching
125 classes. Otherwise check if we've matched an enclosing
128 if (node_ident_length
== 0
129 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
130 && (ident
[node_ident_length
] == '\0'
131 || ident
[node_ident_length
] == '.')))
133 /* We've found a match, however, there might be a more
136 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
143 /* No match yet. Continue through the sibling list. */
144 node
= node
->sibling
;
147 /* No match at all in this tree. */
152 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
154 class_flag_node
*root
= *rootp
;
155 class_flag_node
*parent
, *node
;
157 /* Create the root of the tree if it doesn't exist yet. */
161 root
= XNEW (class_flag_node
);
164 root
->sibling
= NULL
;
170 /* Calling the function with the empty string means we're setting
171 value for the root of the hierarchy. */
179 /* Find the parent node for this new node. PARENT will either be a
180 class or a package name. Adjust PARENT accordingly. */
182 parent
= find_class_flag_node (root
, ident
);
183 if (strcmp (ident
, parent
->ident
) == 0)
184 parent
->value
= value
;
187 /* Insert new node into the tree. */
188 node
= XNEW (class_flag_node
);
190 node
->ident
= xstrdup (ident
);
194 node
->parent
= parent
;
195 node
->sibling
= parent
->child
;
196 parent
->child
= node
;
200 /* Add a new IDENT to the include/exclude tree. It's an exclusion
201 if EXCLUDEP is nonzero. */
204 add_assume_compiled (const char *ident
, int excludep
)
206 add_class_flag (&assume_compiled_tree
, ident
, excludep
);
209 /* The default value returned by enable_assertions. */
211 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
213 /* Enter IDENT (a class or package name) into the enable-assertions table.
214 VALUE is true to enable and false to disable. */
217 add_enable_assert (const char *ident
, int value
)
219 if (enable_assert_tree
== NULL
)
220 add_class_flag (&enable_assert_tree
, "", DEFAULT_ENABLE_ASSERT
);
221 add_class_flag (&enable_assert_tree
, ident
, value
);
224 /* Returns nonzero if IDENT is the name of a class that the compiler
225 should assume has been compiled to object code. */
228 assume_compiled (const char *ident
)
233 if (NULL
== assume_compiled_tree
)
236 i
= find_class_flag_node (assume_compiled_tree
, ident
);
243 /* Return true if we should generate code to check assertions within KLASS. */
246 enable_assertions (tree klass
)
248 /* Check if command-line specifies whether we should check assertions. */
250 if (klass
!= NULL_TREE
&& DECL_NAME (klass
) && enable_assert_tree
!= NULL
)
252 const char *ident
= IDENTIFIER_POINTER (DECL_NAME (klass
));
253 class_flag_node
*node
254 = find_class_flag_node (enable_assert_tree
, ident
);
258 /* The default is to enable assertions if generating class files,
259 or not optimizing. */
260 return DEFAULT_ENABLE_ASSERT
;
263 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
264 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
265 Also, PREFIX is prepended, and SUFFIX is appended. */
268 ident_subst (const char* old_name
,
275 int prefix_len
= strlen (prefix
);
276 int suffix_len
= strlen (suffix
);
277 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
278 char *buffer
= (char *) alloca (i
);
280 strcpy (buffer
, prefix
);
281 for (i
= 0; i
< old_length
; i
++)
283 char ch
= old_name
[i
];
286 buffer
[prefix_len
+ i
] = ch
;
288 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
289 return get_identifier (buffer
);
292 /* Return an IDENTIFIER_NODE the same as OLD_ID,
293 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
294 Also, PREFIX is prepended, and SUFFIX is appended. */
297 identifier_subst (const tree old_id
,
303 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
304 prefix
, old_char
, new_char
, suffix
);
307 /* Generate a valid C identifier from the name of the class TYPE,
308 prefixed by PREFIX. */
311 mangled_classname (const char *prefix
, tree type
)
314 tree ident
= TYPE_NAME (type
);
315 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
316 ident
= DECL_NAME (ident
);
317 result
= identifier_subst (ident
, prefix
, '.', '_', "");
319 /* Replace any characters that aren't in the set [0-9a-zA-Z_$] with
320 "_0xXX". Class names containing such chracters are uncommon, but
321 they do sometimes occur in class files. Without this check,
322 these names cause assembly errors.
324 There is a possibility that a real class name could conflict with
325 the identifier we generate, but it is unlikely and will
326 immediately be detected as an assembler error. At some point we
327 should do something more elaborate (perhaps using the full
328 unicode mangling scheme) in order to prevent such a conflict. */
331 const int len
= IDENTIFIER_LENGTH (result
);
332 const char *p
= IDENTIFIER_POINTER (result
);
333 int illegal_chars
= 0;
335 /* Make two passes over the identifier. The first pass is merely
336 to count illegal characters; we need to do this in order to
337 allocate a buffer. */
338 for (i
= 0; i
< len
; i
++)
341 illegal_chars
+= (! ISALNUM (c
) && c
!= '_' && c
!= '$');
344 /* And the second pass, which is rarely executed, does the
346 if (illegal_chars
!= 0)
348 char *buffer
= (char *) alloca (illegal_chars
* 4 + len
+ 1);
351 for (i
= 0, j
= 0; i
< len
; i
++)
354 if (! ISALNUM (c
) && c
!= '_' && c
!= '$')
357 sprintf (&buffer
[j
], "0x%02x", c
);
365 result
= get_identifier (buffer
);
376 type
= make_node (RECORD_TYPE
);
377 /* Unfortunately we must create the binfo here, so that class
379 TYPE_BINFO (type
) = make_tree_binfo (0);
380 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
381 TYPE_CATCH_CLASSES (type
) = NULL
;
382 /* Push a dummy entry; we can't call make_catch_class_record here
383 because other infrastructure may not be set up yet. We'll come
384 back and fill it in later once said infrastructure is
386 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (type
), NULL_TREE
, NULL_TREE
);
391 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
392 and where each of the constituents is separated by '/',
393 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
396 unmangle_classname (const char *name
, int name_length
)
398 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
399 /* It's not sufficient to compare to_return and get_identifier
400 (name) to determine whether to_return is qualified. There are
401 cases in signature analysis where name will be stripped of a
403 name
= IDENTIFIER_POINTER (to_return
);
407 QUALIFIED_P (to_return
) = 1;
414 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
417 const char *type_name = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
418 char *buf = (char *) alloca (strlen (type_name) \
419 + strlen (#NAME "_syms_") + 1); \
422 sprintf (buf, #NAME "_%s", type_name); \
423 TYPE_## TABLE ##_DECL (type) = decl = \
424 build_decl (input_location, VAR_DECL, get_identifier (buf), TABLE_TYPE); \
425 DECL_EXTERNAL (decl) = 1; \
426 TREE_STATIC (decl) = 1; \
427 TREE_READONLY (decl) = 1; \
428 TREE_CONSTANT (decl) = 1; \
429 DECL_IGNORED_P (decl) = 1; \
430 /* Mark the table as belonging to this class. */ \
432 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
433 DECL_OWNER (decl) = TYPE; \
434 sprintf (buf, #NAME "_syms_%s", type_name); \
435 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
436 build_decl (input_location, VAR_DECL, get_identifier (buf), symbols_array_type); \
437 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
438 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
439 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
443 /* Given a class, create the DECLs for all its associated indirect
446 gen_indirect_dispatch_tables (tree type
)
448 const char *type_name
= IDENTIFIER_POINTER (mangled_classname ("", type
));
451 char *buf
= (char *) alloca (strlen (type_name
)
452 + strlen ("_catch_classes_") + 1);
453 tree catch_class_type
= make_node (RECORD_TYPE
);
455 sprintf (buf
, "_catch_classes_%s", type_name
);
456 PUSH_FIELD (input_location
,
457 catch_class_type
, field
, "address", utf8const_ptr_type
);
458 PUSH_FIELD (input_location
,
459 catch_class_type
, field
, "classname", ptr_type_node
);
460 FINISH_RECORD (catch_class_type
);
462 TYPE_CTABLE_DECL (type
)
463 = build_decl (input_location
, VAR_DECL
, get_identifier (buf
),
464 build_array_type (catch_class_type
, 0));
465 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
466 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
467 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
468 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
469 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
470 pushdecl (TYPE_CTABLE_DECL (type
));
473 if (flag_indirect_dispatch
)
475 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
476 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
477 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
484 push_class (tree class_type
, tree class_name
)
486 tree decl
, signature
;
487 location_t saved_loc
= input_location
;
488 CLASS_P (class_type
) = 1;
489 decl
= build_decl (input_location
, TYPE_DECL
, class_name
, class_type
);
490 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
492 /* dbxout needs a DECL_SIZE if in gstabs mode */
493 DECL_SIZE (decl
) = integer_zero_node
;
495 input_location
= saved_loc
;
496 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
497 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
499 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
500 both a typedef and in the struct name-space. We may want to re-visit
501 this later, but for now it reduces the changes needed for gdb. */
502 DECL_ARTIFICIAL (decl
) = 1;
504 pushdecl_top_level (decl
);
509 /* Finds the (global) class named NAME. Creates the class if not found.
510 Also creates associated TYPE_DECL.
511 Does not check if the class actually exists, load the class,
512 fill in field or methods, or do layout_type. */
515 lookup_class (tree name
)
517 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
518 if (decl
== NULL_TREE
)
519 decl
= push_class (make_class (), name
);
520 return TREE_TYPE (decl
);
524 set_super_info (int access_flags
, tree this_class
,
525 tree super_class
, int interfaces_count
)
527 int total_supers
= interfaces_count
;
528 tree class_decl
= TYPE_NAME (this_class
);
534 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
535 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
538 tree super_binfo
= make_tree_binfo (0);
539 BINFO_TYPE (super_binfo
) = super_class
;
540 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
541 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
542 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
545 set_class_decl_access_flags (access_flags
, class_decl
);
549 set_class_decl_access_flags (int access_flags
, tree class_decl
)
551 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
552 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
553 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
554 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
555 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
556 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
557 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
558 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
559 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
560 if (access_flags
& ACC_ENUM
) CLASS_ENUM (class_decl
) = 1;
561 if (access_flags
& ACC_SYNTHETIC
) CLASS_SYNTHETIC (class_decl
) = 1;
562 if (access_flags
& ACC_ANNOTATION
) CLASS_ANNOTATION (class_decl
) = 1;
565 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
566 direct sub-classes of Object are 1, and so on. */
569 class_depth (tree clas
)
572 if (! CLASS_LOADED_P (clas
))
573 load_class (clas
, 1);
574 if (TYPE_SIZE (clas
) == error_mark_node
)
576 while (clas
!= object_type_node
)
579 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
584 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
587 interface_of_p (tree type1
, tree type2
)
590 tree binfo
, base_binfo
;
592 if (! TYPE_BINFO (type2
))
595 for (binfo
= TYPE_BINFO (type2
), i
= 0;
596 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
597 if (BINFO_TYPE (base_binfo
) == type1
)
600 for (binfo
= TYPE_BINFO (type2
), i
= 0;
601 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
602 if (BINFO_TYPE (base_binfo
)
603 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
609 /* Return true iff TYPE1 inherits from TYPE2. */
612 inherits_from_p (tree type1
, tree type2
)
614 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
619 if (! CLASS_LOADED_P (type1
))
620 load_class (type1
, 1);
622 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
627 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
630 enclosing_context_p (tree type1
, tree type2
)
632 if (!INNER_CLASS_TYPE_P (type2
))
635 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
637 type2
= (INNER_CLASS_TYPE_P (type2
) ?
638 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
648 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
652 common_enclosing_context_p (tree type1
, tree type2
)
657 for (current
= type2
; current
;
658 current
= (INNER_CLASS_TYPE_P (current
) ?
659 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
661 if (type1
== current
)
664 if (INNER_CLASS_TYPE_P (type1
))
665 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
672 /* Return 1 iff there exists a common enclosing "this" between TYPE1
673 and TYPE2, without crossing any static context. */
676 common_enclosing_instance_p (tree type1
, tree type2
)
678 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
681 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
682 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
683 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
686 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
687 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
688 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
690 if (type1
== current
)
696 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
697 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
698 if attempt is made to add it twice. */
701 maybe_add_interface (tree this_class
, tree interface_class
)
703 tree binfo
, base_binfo
;
706 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
707 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
708 if (BINFO_TYPE (base_binfo
) == interface_class
)
709 return interface_class
;
710 add_interface (this_class
, interface_class
);
714 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
717 add_interface (tree this_class
, tree interface_class
)
719 tree interface_binfo
= make_tree_binfo (0);
721 BINFO_TYPE (interface_binfo
) = interface_class
;
722 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
723 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
724 BINFO_VIRTUAL_P (interface_binfo
) = 1;
726 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
730 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
732 if (access_flags
& ACC_STATIC
)
734 fntype
= build_method_type (this_class
, fntype
);
736 /* We know that arg 1 of every nonstatic method is non-null; tell
738 TYPE_ATTRIBUTES (fntype
) = (tree_cons
739 (get_identifier ("nonnull"),
740 tree_cons (NULL_TREE
,
741 build_int_cst (NULL_TREE
, 1),
743 TYPE_ATTRIBUTES (fntype
)));
748 java_hide_decl (tree decl ATTRIBUTE_UNUSED
)
750 #ifdef HAVE_GAS_HIDDEN
751 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
752 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
757 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
759 tree method_type
, fndecl
;
761 method_type
= build_java_method_type (function_type
,
762 this_class
, access_flags
);
764 fndecl
= build_decl (input_location
, FUNCTION_DECL
, name
, method_type
);
765 DECL_CONTEXT (fndecl
) = this_class
;
767 DECL_LANG_SPECIFIC (fndecl
)
768 = ggc_alloc_cleared_lang_decl(sizeof (struct lang_decl
));
769 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
771 /* Initialize the static initializer test table. */
773 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) = java_treetreehash_create (10);
775 /* Initialize the initialized (static) class table. */
776 if (access_flags
& ACC_STATIC
)
777 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
778 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
780 DECL_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
781 TYPE_METHODS (this_class
) = fndecl
;
783 /* If pointers to member functions use the least significant bit to
784 indicate whether a function is virtual, ensure a pointer
785 to this function will have that bit clear. */
786 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
787 && !(access_flags
& ACC_STATIC
)
788 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
789 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
791 /* Notice that this is a finalizer and update the class type
792 accordingly. This is used to optimize instance allocation. */
793 if (name
== finalize_identifier_node
794 && TREE_TYPE (function_type
) == void_type_node
795 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
796 HAS_FINALIZER_P (this_class
) = 1;
798 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
799 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
800 if (access_flags
& ACC_PRIVATE
)
801 METHOD_PRIVATE (fndecl
) = 1;
802 if (access_flags
& ACC_NATIVE
)
804 METHOD_NATIVE (fndecl
) = 1;
805 DECL_EXTERNAL (fndecl
) = 1;
808 /* FNDECL is external unless we are compiling it into this object
810 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
811 if (access_flags
& ACC_STATIC
)
812 METHOD_STATIC (fndecl
) = 1;
813 if (access_flags
& ACC_FINAL
)
814 METHOD_FINAL (fndecl
) = 1;
815 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
816 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
817 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
818 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
819 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
820 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
824 /* Add a method to THIS_CLASS.
825 The method's name is NAME.
826 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
829 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
831 tree function_type
, fndecl
;
832 const unsigned char *sig
833 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
836 fatal_error ("bad method signature");
838 function_type
= get_type_from_signature (method_sig
);
839 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
840 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
845 add_field (tree klass
, tree name
, tree field_type
, int flags
)
847 int is_static
= (flags
& ACC_STATIC
) != 0;
849 field
= build_decl (input_location
,
850 is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
851 DECL_CHAIN (field
) = TYPE_FIELDS (klass
);
852 TYPE_FIELDS (klass
) = field
;
853 DECL_CONTEXT (field
) = klass
;
854 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
856 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
857 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
858 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
859 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
860 if (flags
& ACC_VOLATILE
)
862 FIELD_VOLATILE (field
) = 1;
863 TREE_THIS_VOLATILE (field
) = 1;
865 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
866 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
867 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
870 FIELD_STATIC (field
) = 1;
871 /* Always make field externally visible. This is required so
872 that native methods can always access the field. */
873 TREE_PUBLIC (field
) = 1;
874 /* Hide everything that shouldn't be visible outside a DSO. */
875 if (flag_indirect_classes
876 || (FIELD_PRIVATE (field
)))
877 java_hide_decl (field
);
878 /* Considered external unless we are compiling it into this
880 DECL_EXTERNAL (field
) = (is_compiled_class (klass
) != 2);
881 if (!DECL_EXTERNAL (field
))
882 vec_safe_push (pending_static_fields
, field
);
888 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
891 set_constant_value (tree field
, tree constant
)
893 if (field
== NULL_TREE
)
894 warning (OPT_Wattributes
,
895 "misplaced ConstantValue attribute (not in any field)");
896 else if (DECL_INITIAL (field
) != NULL_TREE
)
897 warning (OPT_Wattributes
,
898 "duplicate ConstantValue attribute for field '%s'",
899 IDENTIFIER_POINTER (DECL_NAME (field
)));
902 DECL_INITIAL (field
) = constant
;
903 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
904 && ! (TREE_TYPE (constant
) == int_type_node
905 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
906 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
907 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
908 && TREE_TYPE (field
) == string_ptr_type_node
))
909 error ("ConstantValue attribute of field '%s' has wrong type",
910 IDENTIFIER_POINTER (DECL_NAME (field
)));
914 /* Calculate a hash value for a string encoded in Utf8 format.
915 * This returns the same hash value as specified for java.lang.String.hashCode.
919 hashUtf8String (const char *str
, int len
)
921 const unsigned char* ptr
= (const unsigned char*) str
;
922 const unsigned char *limit
= ptr
+ len
;
926 int ch
= UTF8_GET (ptr
, limit
);
927 /* Updated specification from
928 http://www.javasoft.com/docs/books/jls/clarify.html. */
929 hash
= (31 * hash
) + ch
;
935 build_utf8_ref (tree name
)
937 const char * name_ptr
= IDENTIFIER_POINTER (name
);
938 int name_len
= IDENTIFIER_LENGTH (name
), name_pad
;
940 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
941 static int utf8_count
= 0;
943 tree ref
= IDENTIFIER_UTF8_REF (name
);
945 vec
<constructor_elt
, va_gc
> *v
= NULL
;
946 if (ref
!= NULL_TREE
)
949 ctype
= make_node (RECORD_TYPE
);
950 /* '\0' byte plus padding to utf8const_type's alignment. */
951 name_pad
= TYPE_ALIGN_UNIT (utf8const_type
)
952 - (name_len
& (TYPE_ALIGN_UNIT (utf8const_type
) - 1));
953 str_type
= build_prim_array_type (unsigned_byte_type_node
,
954 name_len
+ name_pad
);
955 PUSH_FIELD (input_location
, ctype
, field
, "hash", unsigned_short_type_node
);
956 PUSH_FIELD (input_location
,
957 ctype
, field
, "length", unsigned_short_type_node
);
958 PUSH_FIELD (input_location
, ctype
, field
, "data", str_type
);
959 FINISH_RECORD (ctype
);
960 START_RECORD_CONSTRUCTOR (v
, ctype
);
961 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
962 PUSH_FIELD_VALUE (v
, "hash", build_int_cst (NULL_TREE
, name_hash
));
963 PUSH_FIELD_VALUE (v
, "length", build_int_cst (NULL_TREE
, name_len
));
964 string
= build_string (name_len
, name_ptr
);
965 TREE_TYPE (string
) = str_type
;
966 PUSH_FIELD_VALUE (v
, "data", string
);
967 FINISH_RECORD_CONSTRUCTOR (cinit
, v
, ctype
);
968 TREE_CONSTANT (cinit
) = 1;
970 /* Generate a unique-enough identifier. */
971 sprintf(buf
, "_Utf%d", ++utf8_count
);
973 decl
= build_decl (input_location
,
974 VAR_DECL
, get_identifier (buf
), utf8const_type
);
975 TREE_STATIC (decl
) = 1;
976 DECL_ARTIFICIAL (decl
) = 1;
977 DECL_IGNORED_P (decl
) = 1;
978 TREE_READONLY (decl
) = 1;
979 TREE_THIS_VOLATILE (decl
) = 0;
980 DECL_INITIAL (decl
) = cinit
;
981 DECL_USER_ALIGN (decl
) = 1;
983 if (HAVE_GAS_SHF_MERGE
)
986 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
987 decl_size
= name_len
+ 4 + name_pad
;
988 if (flag_merge_constants
&& decl_size
< 256)
991 int flags
= (SECTION_OVERRIDE
992 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
993 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
994 switch_to_section (get_section (buf
, flags
, NULL
));
995 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
999 layout_decl (decl
, 0);
1000 DECL_SIZE (decl
) = TYPE_SIZE (ctype
);
1001 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (ctype
);
1003 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
1004 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
1005 IDENTIFIER_UTF8_REF (name
) = ref
;
1009 /* Like build_class_ref, but instead of a direct reference generate a
1010 pointer into the constant pool. */
1013 build_indirect_class_ref (tree type
)
1017 index
= alloc_class_constant (type
);
1018 cl
= build_ref_from_constant_pool (index
);
1019 return convert (promote_type (class_ptr_type
), cl
);
1023 build_static_class_ref (tree type
)
1025 tree decl_name
, decl
, ref
;
1027 if (TYPE_SIZE (type
) == error_mark_node
)
1028 return null_pointer_node
;
1029 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1030 "", '/', '/', ".class$$");
1031 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1032 if (decl
== NULL_TREE
)
1034 decl
= build_decl (input_location
, VAR_DECL
, decl_name
, class_type_node
);
1035 TREE_STATIC (decl
) = 1;
1036 if (! flag_indirect_classes
)
1038 TREE_PUBLIC (decl
) = 1;
1039 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1040 java_hide_decl (decl
);
1042 DECL_IGNORED_P (decl
) = 1;
1043 DECL_ARTIFICIAL (decl
) = 1;
1044 if (is_compiled_class (type
) == 1)
1045 DECL_EXTERNAL (decl
) = 1;
1046 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1047 DECL_CLASS_FIELD_P (decl
) = 1;
1048 DECL_CONTEXT (decl
) = type
;
1050 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1051 that that means not calling pushdecl_top_level. */
1052 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1055 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1060 build_classdollar_field (tree type
)
1062 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1063 "", '/', '/', ".class$");
1064 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1066 if (decl
== NULL_TREE
)
1069 = build_decl (input_location
,
1070 VAR_DECL
, decl_name
,
1073 (build_type_variant (class_type_node
,
1075 /* const */ 1, 0)));
1076 TREE_STATIC (decl
) = 1;
1077 TREE_CONSTANT (decl
) = 1;
1078 TREE_READONLY (decl
) = 1;
1079 TREE_PUBLIC (decl
) = 1;
1080 java_hide_decl (decl
);
1081 DECL_IGNORED_P (decl
) = 1;
1082 DECL_ARTIFICIAL (decl
) = 1;
1083 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1084 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1085 DECL_CLASS_FIELD_P (decl
) = 1;
1086 DECL_CONTEXT (decl
) = type
;
1092 /* Create a local variable that holds the current class$. */
1095 cache_this_class_ref (tree fndecl
)
1099 tree classdollar_field
;
1100 if (flag_indirect_classes
)
1101 classdollar_field
= build_classdollar_field (output_class
);
1103 classdollar_field
= build_static_class_ref (output_class
);
1105 this_classdollar
= build_decl (input_location
,
1106 VAR_DECL
, NULL_TREE
,
1107 TREE_TYPE (classdollar_field
));
1109 java_add_local_var (this_classdollar
);
1110 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1111 this_classdollar
, classdollar_field
));
1114 this_classdollar
= build_classdollar_field (output_class
);
1116 /* Prepend class initialization for static methods reachable from
1118 if (METHOD_STATIC (fndecl
)
1119 && (! METHOD_PRIVATE (fndecl
)
1120 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1121 && ! DECL_CLINIT_P (fndecl
)
1122 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1124 tree init
= build_call_expr (soft_initclass_node
, 1,
1126 java_add_stmt (init
);
1130 /* Remove the reference to the local variable that holds the current
1134 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1136 this_classdollar
= build_classdollar_field (output_class
);
1139 /* Build a reference to the class TYPE.
1140 Also handles primitive types and array types. */
1143 build_class_ref (tree type
)
1145 int is_compiled
= is_compiled_class (type
);
1149 if (TREE_CODE (type
) == POINTER_TYPE
)
1150 type
= TREE_TYPE (type
);
1152 if (flag_indirect_dispatch
1153 && type
!= output_class
1154 && TREE_CODE (type
) == RECORD_TYPE
)
1155 return build_indirect_class_ref (type
);
1157 if (type
== output_class
&& flag_indirect_classes
)
1159 /* This can be NULL if we see a JNI stub before we see any
1161 if (! this_classdollar
)
1162 this_classdollar
= build_classdollar_field (output_class
);
1163 return this_classdollar
;
1166 if (TREE_CODE (type
) == RECORD_TYPE
)
1167 return build_static_class_ref (type
);
1173 decl_name
= TYPE_NAME (type
);
1174 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1175 decl_name
= DECL_NAME (decl_name
);
1176 name
= IDENTIFIER_POINTER (decl_name
);
1177 if (strncmp (name
, "promoted_", 9) == 0)
1179 sprintf (buffer
, "_Jv_%sClass", name
);
1180 decl_name
= get_identifier (buffer
);
1181 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1182 if (decl
== NULL_TREE
)
1184 decl
= build_decl (input_location
,
1185 VAR_DECL
, decl_name
, class_type_node
);
1186 TREE_STATIC (decl
) = 1;
1187 TREE_PUBLIC (decl
) = 1;
1188 DECL_EXTERNAL (decl
) = 1;
1189 DECL_ARTIFICIAL (decl
) = 1;
1190 pushdecl_top_level (decl
);
1194 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1198 return build_indirect_class_ref (type
);
1201 /* Create a local statically allocated variable that will hold a
1202 pointer to a static field. */
1205 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1207 tree decl
, decl_name
;
1208 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1209 char *buf
= (char *) alloca (strlen (name
) + 20);
1210 sprintf (buf
, "%s_%d_ref", name
, index
);
1211 decl_name
= get_identifier (buf
);
1212 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1213 if (decl
== NULL_TREE
)
1215 decl
= build_decl (input_location
,
1216 VAR_DECL
, decl_name
, ptr_type_node
);
1217 TREE_STATIC (decl
) = 1;
1218 TREE_PUBLIC (decl
) = 0;
1219 DECL_EXTERNAL (decl
) = 0;
1220 DECL_ARTIFICIAL (decl
) = 1;
1221 DECL_IGNORED_P (decl
) = 1;
1222 pushdecl_top_level (decl
);
1228 build_static_field_ref (tree fdecl
)
1230 tree fclass
= DECL_CONTEXT (fdecl
);
1231 int is_compiled
= is_compiled_class (fclass
);
1233 /* Allow static final fields to fold to a constant. When using
1234 -findirect-dispatch, we simply never do this folding if compiling
1235 from .class; in the .class file constants will be referred to via
1236 the constant pool. */
1237 if (!flag_indirect_dispatch
1239 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1240 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1241 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1242 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1244 if (is_compiled
== 1)
1245 DECL_EXTERNAL (fdecl
) = 1;
1249 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1250 and a class local static variable CACHE_ENTRY, then
1252 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1253 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1256 This can mostly be optimized away, so that the usual path is a
1257 load followed by a test and branch. _Jv_ResolvePoolEntry is
1258 only called once for each constant pool entry.
1260 There is an optimization that we don't do: at the start of a
1261 method, create a local copy of CACHE_ENTRY and use that instead.
1265 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1266 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1268 = build_call_expr (builtin_decl_implicit (BUILT_IN_EXPECT
), 2,
1269 build2 (EQ_EXPR
, boolean_type_node
,
1270 cache_entry
, null_pointer_node
),
1271 boolean_false_node
);
1272 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1274 = build_call_expr (soft_resolvepoolentry_node
, 2,
1275 build_class_ref (output_class
),
1277 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1278 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1279 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1280 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1286 get_access_flags_from_decl (tree decl
)
1288 int access_flags
= 0;
1289 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1291 if (FIELD_STATIC (decl
))
1292 access_flags
|= ACC_STATIC
;
1293 if (FIELD_PUBLIC (decl
))
1294 access_flags
|= ACC_PUBLIC
;
1295 if (FIELD_PROTECTED (decl
))
1296 access_flags
|= ACC_PROTECTED
;
1297 if (FIELD_PRIVATE (decl
))
1298 access_flags
|= ACC_PRIVATE
;
1299 if (FIELD_FINAL (decl
))
1300 access_flags
|= ACC_FINAL
;
1301 if (FIELD_VOLATILE (decl
))
1302 access_flags
|= ACC_VOLATILE
;
1303 if (FIELD_TRANSIENT (decl
))
1304 access_flags
|= ACC_TRANSIENT
;
1305 if (FIELD_ENUM (decl
))
1306 access_flags
|= ACC_ENUM
;
1307 if (FIELD_SYNTHETIC (decl
))
1308 access_flags
|= ACC_SYNTHETIC
;
1309 return access_flags
;
1311 if (TREE_CODE (decl
) == TYPE_DECL
)
1313 if (CLASS_PUBLIC (decl
))
1314 access_flags
|= ACC_PUBLIC
;
1315 if (CLASS_FINAL (decl
))
1316 access_flags
|= ACC_FINAL
;
1317 if (CLASS_SUPER (decl
))
1318 access_flags
|= ACC_SUPER
;
1319 if (CLASS_INTERFACE (decl
))
1320 access_flags
|= ACC_INTERFACE
;
1321 if (CLASS_ABSTRACT (decl
))
1322 access_flags
|= ACC_ABSTRACT
;
1323 if (CLASS_STATIC (decl
))
1324 access_flags
|= ACC_STATIC
;
1325 if (CLASS_PRIVATE (decl
))
1326 access_flags
|= ACC_PRIVATE
;
1327 if (CLASS_PROTECTED (decl
))
1328 access_flags
|= ACC_PROTECTED
;
1329 if (CLASS_STRICTFP (decl
))
1330 access_flags
|= ACC_STRICT
;
1331 if (CLASS_ENUM (decl
))
1332 access_flags
|= ACC_ENUM
;
1333 if (CLASS_SYNTHETIC (decl
))
1334 access_flags
|= ACC_SYNTHETIC
;
1335 if (CLASS_ANNOTATION (decl
))
1336 access_flags
|= ACC_ANNOTATION
;
1337 return access_flags
;
1339 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1341 if (METHOD_PUBLIC (decl
))
1342 access_flags
|= ACC_PUBLIC
;
1343 if (METHOD_PRIVATE (decl
))
1344 access_flags
|= ACC_PRIVATE
;
1345 if (METHOD_PROTECTED (decl
))
1346 access_flags
|= ACC_PROTECTED
;
1347 if (METHOD_STATIC (decl
))
1348 access_flags
|= ACC_STATIC
;
1349 if (METHOD_FINAL (decl
))
1350 access_flags
|= ACC_FINAL
;
1351 if (METHOD_SYNCHRONIZED (decl
))
1352 access_flags
|= ACC_SYNCHRONIZED
;
1353 if (METHOD_NATIVE (decl
))
1354 access_flags
|= ACC_NATIVE
;
1355 if (METHOD_ABSTRACT (decl
))
1356 access_flags
|= ACC_ABSTRACT
;
1357 if (METHOD_STRICTFP (decl
))
1358 access_flags
|= ACC_STRICT
;
1359 if (METHOD_INVISIBLE (decl
))
1360 access_flags
|= ACC_INVISIBLE
;
1361 if (DECL_ARTIFICIAL (decl
))
1362 access_flags
|= ACC_SYNTHETIC
;
1363 if (METHOD_BRIDGE (decl
))
1364 access_flags
|= ACC_BRIDGE
;
1365 if (METHOD_VARARGS (decl
))
1366 access_flags
|= ACC_VARARGS
;
1367 return access_flags
;
1372 static GTY (()) int alias_labelno
= 0;
1374 /* Create a private alias for METHOD. Using this alias instead of the method
1375 decl ensures that ncode entries in the method table point to the real function
1376 at runtime, not a PLT entry. */
1379 make_local_function_alias (tree method
)
1381 #ifdef ASM_OUTPUT_DEF
1384 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1385 char *name
= (char *) alloca (strlen (method_name
) + 2);
1386 char *buf
= (char *) alloca (strlen (method_name
) + 128);
1388 /* Only create aliases for local functions. */
1389 if (DECL_EXTERNAL (method
))
1392 /* Prefix method_name with 'L' for the alias label. */
1394 strcpy (name
+ 1, method_name
);
1396 targetm
.asm_out
.generate_internal_label (buf
, name
, alias_labelno
++);
1397 alias
= build_decl (input_location
,
1398 FUNCTION_DECL
, get_identifier (buf
),
1399 TREE_TYPE (method
));
1400 DECL_CONTEXT (alias
) = NULL
;
1401 TREE_READONLY (alias
) = TREE_READONLY (method
);
1402 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1403 TREE_PUBLIC (alias
) = 0;
1404 DECL_EXTERNAL (alias
) = 0;
1405 DECL_ARTIFICIAL (alias
) = 1;
1406 DECL_INITIAL (alias
) = error_mark_node
;
1407 TREE_ADDRESSABLE (alias
) = 1;
1408 TREE_USED (alias
) = 1;
1409 if (!flag_syntax_only
)
1410 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1417 /** Make reflection data (_Jv_Field) for field FDECL. */
1420 make_field_value (tree fdecl
)
1424 tree type
= TREE_TYPE (fdecl
);
1425 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1426 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1428 START_RECORD_CONSTRUCTOR (v
, field_type_node
);
1429 PUSH_FIELD_VALUE (v
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1431 type
= build_class_ref (type
);
1434 tree signature
= build_java_signature (type
);
1436 type
= build_utf8_ref (unmangle_classname
1437 (IDENTIFIER_POINTER (signature
),
1438 IDENTIFIER_LENGTH (signature
)));
1440 PUSH_FIELD_VALUE (v
, "type", type
);
1442 flags
= get_access_flags_from_decl (fdecl
);
1444 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1446 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, flags
));
1447 PUSH_FIELD_VALUE (v
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1450 tree field_address
= integer_zero_node
;
1452 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1453 && FIELD_STATIC (fdecl
))
1454 field_address
= build_address_of (fdecl
);
1456 index
= (FIELD_STATIC (fdecl
)
1457 ? DECL_CHAIN (TYPE_FIELDS (field_info_union_node
))
1458 : TYPE_FIELDS (field_info_union_node
));
1459 value
= (FIELD_STATIC (fdecl
)
1461 : byte_position (fdecl
));
1465 build_constructor_single (field_info_union_node
, index
, value
));
1468 FINISH_RECORD_CONSTRUCTOR (finit
, v
, field_type_node
);
1472 /** Make reflection data (_Jv_Method) for method MDECL. */
1475 make_method_value (tree mdecl
)
1477 static int method_name_count
= 0;
1482 #define ACC_TRANSLATED 0x4000
1483 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1484 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1486 class_decl
= DECL_CONTEXT (mdecl
);
1487 /* For interfaces, the index field contains the dispatch index. */
1488 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1489 index
= build_int_cst (NULL_TREE
,
1490 get_interface_method_index (mdecl
, class_decl
));
1491 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1492 index
= get_method_index (mdecl
);
1494 index
= integer_minus_one_node
;
1496 code
= null_pointer_node
;
1497 if (METHOD_ABSTRACT (mdecl
))
1498 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1499 soft_abstractmethod_node
);
1501 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1502 make_local_function_alias (mdecl
));
1503 START_RECORD_CONSTRUCTOR (v
, method_type_node
);
1504 PUSH_FIELD_VALUE (v
, "name",
1505 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1506 init_identifier_node
1507 : DECL_NAME (mdecl
)));
1509 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1510 PUSH_FIELD_VALUE (v
, "signature",
1513 (IDENTIFIER_POINTER(signature
),
1514 IDENTIFIER_LENGTH(signature
)))));
1516 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1517 PUSH_FIELD_VALUE (v
, "index", index
);
1518 PUSH_FIELD_VALUE (v
, "ncode", code
);
1521 /* Compute the `throws' information for the method. */
1522 tree table
= null_pointer_node
;
1524 if (!vec_safe_is_empty (DECL_FUNCTION_THROWS (mdecl
)))
1526 int length
= 1 + DECL_FUNCTION_THROWS (mdecl
)->length ();
1527 tree t
, type
, array
;
1529 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1530 int idx
= length
- 1;
1534 vec_alloc (v
, length
);
1535 v
->quick_grow_cleared (length
);
1538 e
->value
= null_pointer_node
;
1540 FOR_EACH_VEC_SAFE_ELT (DECL_FUNCTION_THROWS (mdecl
), ix
, t
)
1542 tree sig
= DECL_NAME (TYPE_NAME (t
));
1544 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1545 IDENTIFIER_LENGTH (sig
)));
1549 gcc_assert (idx
== -1);
1550 type
= build_prim_array_type (ptr_type_node
, length
);
1551 table
= build_constructor (type
, v
);
1552 /* Compute something unique enough. */
1553 sprintf (buf
, "_methods%d", method_name_count
++);
1554 array
= build_decl (input_location
,
1555 VAR_DECL
, get_identifier (buf
), type
);
1556 DECL_INITIAL (array
) = table
;
1557 TREE_STATIC (array
) = 1;
1558 DECL_ARTIFICIAL (array
) = 1;
1559 DECL_IGNORED_P (array
) = 1;
1560 rest_of_decl_compilation (array
, 1, 0);
1562 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1565 PUSH_FIELD_VALUE (v
, "throws", table
);
1568 FINISH_RECORD_CONSTRUCTOR (minit
, v
, method_type_node
);
1573 get_dispatch_vector (tree type
)
1575 tree vtable
= TYPE_VTABLE (type
);
1577 if (vtable
== NULL_TREE
)
1581 tree super
= CLASSTYPE_SUPER (type
);
1582 HOST_WIDE_INT nvirtuals
= tree_to_shwi (TYPE_NVIRTUALS (type
));
1583 vtable
= make_tree_vec (nvirtuals
);
1584 TYPE_VTABLE (type
) = vtable
;
1585 if (super
!= NULL_TREE
)
1587 tree super_vtable
= get_dispatch_vector (super
);
1589 for (i
= tree_to_shwi (TYPE_NVIRTUALS (super
)); --i
>= 0; )
1590 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1593 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1594 method
= DECL_CHAIN (method
))
1596 tree method_index
= get_method_index (method
);
1597 if (method_index
!= NULL_TREE
1598 && tree_fits_shwi_p (method_index
))
1599 TREE_VEC_ELT (vtable
, tree_to_shwi (method_index
)) = method
;
1607 get_dispatch_table (tree type
, tree this_class_addr
)
1609 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1610 tree vtable
= get_dispatch_vector (type
);
1612 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1615 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1619 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1620 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1621 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1624 vec_safe_grow_cleared (v
, arraysize
);
1625 e
= &(*v
)[arraysize
- 1];
1627 #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
1628 for (i
= nvirtuals
; --i
>= 0; )
1630 tree method
= TREE_VEC_ELT (vtable
, i
);
1631 if (METHOD_ABSTRACT (method
))
1634 warning_at (DECL_SOURCE_LOCATION (method
), 0,
1635 "abstract method in non-abstract class");
1637 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1638 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1639 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1641 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1645 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1646 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1648 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1649 method
, build_int_cst (NULL_TREE
, j
));
1650 TREE_CONSTANT (fdesc
) = 1;
1651 CONSTRUCTOR_PREPEND_VALUE (e
, fdesc
);
1654 CONSTRUCTOR_PREPEND_VALUE (e
,
1656 nativecode_ptr_type_node
,
1661 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1662 using the Boehm GC we sometimes stash a GC type descriptor
1663 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1664 the emitted byte count during the output to the assembly file. */
1665 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1666 fake "function descriptor". It's first word is the is the class
1667 pointer, and subsequent words (usually one) contain the GC descriptor.
1668 In all other cases, we reserve two extra vtable slots. */
1669 gc_descr
= get_boehm_type_descriptor (type
);
1670 CONSTRUCTOR_PREPEND_VALUE (e
, gc_descr
);
1671 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1672 CONSTRUCTOR_PREPEND_VALUE (e
, gc_descr
);
1673 CONSTRUCTOR_PREPEND_VALUE (e
, this_class_addr
);
1675 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1676 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1677 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1678 gcc_assert (e
== v
->address ());
1679 e
->index
= integer_zero_node
;
1680 e
->value
= null_pointer_node
;
1681 #undef CONSTRUCTOR_PREPEND_VALUE
1683 arraytype
= build_prim_array_type (nativecode_ptr_type_node
, arraysize
);
1684 return build_constructor (arraytype
, v
);
1688 /* Set the method_index for a method decl. */
1690 set_method_index (tree decl
, tree method_index
)
1692 if (method_index
!= NULL_TREE
)
1694 /* method_index is null if we're using indirect dispatch. */
1695 method_index
= fold (convert (sizetype
, method_index
));
1697 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1698 /* Add one to skip bogus descriptor for class and GC descriptor. */
1699 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1701 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1703 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1706 DECL_VINDEX (decl
) = method_index
;
1709 /* Get the method_index for a method decl. */
1711 get_method_index (tree decl
)
1713 tree method_index
= DECL_VINDEX (decl
);
1718 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1719 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1720 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1722 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1723 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1725 return method_index
;
1729 supers_all_compiled (tree type
)
1731 while (type
!= NULL_TREE
)
1733 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1735 type
= CLASSTYPE_SUPER (type
);
1741 add_table_and_syms (vec
<constructor_elt
, va_gc
> **v
,
1742 vec
<method_entry
, va_gc
> *methods
,
1743 const char *table_name
, tree table_slot
, tree table_type
,
1744 const char *syms_name
, tree syms_slot
)
1746 if (methods
== NULL
)
1748 PUSH_FIELD_VALUE (*v
, table_name
, null_pointer_node
);
1749 PUSH_FIELD_VALUE (*v
, syms_name
, null_pointer_node
);
1753 pushdecl_top_level (syms_slot
);
1754 PUSH_FIELD_VALUE (*v
, table_name
,
1755 build1 (ADDR_EXPR
, table_type
, table_slot
));
1756 PUSH_FIELD_VALUE (*v
, syms_name
,
1757 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1759 TREE_CONSTANT (table_slot
) = 1;
1764 make_class_data (tree type
)
1766 tree decl
, cons
, temp
;
1767 tree field
, fields_decl
;
1768 HOST_WIDE_INT static_field_count
= 0;
1769 HOST_WIDE_INT instance_field_count
= 0;
1770 HOST_WIDE_INT field_count
;
1771 tree field_array_type
;
1773 tree dtable_decl
= NULL_TREE
;
1774 HOST_WIDE_INT method_count
= 0;
1775 tree method_array_type
;
1778 tree this_class_addr
;
1779 tree constant_pool_constructor
;
1780 tree interfaces
= null_pointer_node
;
1781 int interface_len
= 0;
1782 int uses_jv_markobj
= 0;
1783 tree type_decl
= TYPE_NAME (type
);
1784 tree id_main
= get_identifier("main");
1785 tree id_class
= get_identifier("java.lang.Class");
1786 /** Offset from start of virtual function table declaration
1787 to where objects actually point at, following new g++ ABI. */
1788 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1789 vec
<int> field_indexes
;
1790 tree first_real_field
;
1791 vec
<constructor_elt
, va_gc
> *v1
= NULL
, *v2
= NULL
;
1792 tree reflection_data
;
1793 vec
<constructor_elt
, va_gc
> *static_fields
= NULL
;
1794 vec
<constructor_elt
, va_gc
> *instance_fields
= NULL
;
1795 vec
<constructor_elt
, va_gc
> *methods
= NULL
;
1797 this_class_addr
= build_static_class_ref (type
);
1798 decl
= TREE_OPERAND (this_class_addr
, 0);
1800 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1801 && !flag_indirect_dispatch
)
1803 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1804 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1805 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1807 /* We've already created some other class, and consequently
1808 we made class_dtable_decl. Now we just want to fill it
1810 dtable_decl
= class_dtable_decl
;
1814 dtable_decl
= build_dtable_decl (type
);
1815 TREE_STATIC (dtable_decl
) = 1;
1816 DECL_ARTIFICIAL (dtable_decl
) = 1;
1817 DECL_IGNORED_P (dtable_decl
) = 1;
1820 TREE_PUBLIC (dtable_decl
) = 1;
1821 DECL_INITIAL (dtable_decl
) = dtable
;
1822 /* The only dispatch table exported from a DSO is the dispatch
1823 table for java.lang.Class. */
1824 if (DECL_NAME (type_decl
) != id_class
)
1825 java_hide_decl (dtable_decl
);
1826 if (! flag_indirect_classes
)
1827 rest_of_decl_compilation (dtable_decl
, 1, 0);
1828 /* Maybe we're compiling Class as the first class. If so, set
1829 class_dtable_decl to the decl we just made. */
1830 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1831 class_dtable_decl
= dtable_decl
;
1834 /* Build Field array. */
1835 field
= TYPE_FIELDS (type
);
1836 while (field
&& DECL_ARTIFICIAL (field
))
1837 field
= DECL_CHAIN (field
); /* Skip dummy fields. */
1838 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1839 field
= DECL_CHAIN (field
); /* Skip dummy field for inherited data. */
1840 first_real_field
= field
;
1842 /* First count static and instance fields. */
1843 for ( ; field
!= NULL_TREE
; field
= DECL_CHAIN (field
))
1845 if (! DECL_ARTIFICIAL (field
))
1847 if (FIELD_STATIC (field
))
1848 static_field_count
++;
1849 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1850 instance_field_count
++;
1853 field_count
= static_field_count
+ instance_field_count
;
1854 field_indexes
.create (field_count
);
1856 /* gcj sorts fields so that static fields come first, followed by
1857 instance fields. Unfortunately, by the time this takes place we
1858 have already generated the reflection_data for this class, and
1859 that data contains indexes into the fields. So, we generate a
1860 permutation that maps each original field index to its final
1861 position. Then we pass this permutation to
1862 rewrite_reflection_indexes(), which fixes up the reflection
1866 int static_count
= 0;
1867 int instance_count
= static_field_count
;
1870 for (i
= 0, field
= first_real_field
;
1872 field
= DECL_CHAIN (field
), i
++)
1874 if (! DECL_ARTIFICIAL (field
))
1877 if (FIELD_STATIC (field
))
1878 field_index
= static_count
++;
1879 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1880 field_index
= instance_count
++;
1883 field_indexes
.quick_push (field_index
);
1888 for (field
= first_real_field
; field
!= NULL_TREE
;
1889 field
= DECL_CHAIN (field
))
1891 if (! DECL_ARTIFICIAL (field
))
1893 if (FIELD_STATIC (field
))
1895 /* We must always create reflection data for static fields
1896 as it is used in the creation of the field itself. */
1897 tree init
= make_field_value (field
);
1898 tree initial
= DECL_INITIAL (field
);
1899 CONSTRUCTOR_APPEND_ELT (static_fields
, NULL_TREE
, init
);
1900 /* If the initial value is a string constant,
1901 prevent output_constant from trying to assemble the value. */
1902 if (initial
!= NULL_TREE
1903 && TREE_TYPE (initial
) == string_ptr_type_node
)
1904 DECL_INITIAL (field
) = NULL_TREE
;
1905 rest_of_decl_compilation (field
, 1, 1);
1906 DECL_INITIAL (field
) = initial
;
1908 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1910 tree init
= make_field_value (field
);
1911 CONSTRUCTOR_APPEND_ELT (instance_fields
, NULL_TREE
, init
);
1916 gcc_assert (static_field_count
== (int) vec_safe_length (static_fields
));
1917 gcc_assert (instance_field_count
== (int) vec_safe_length (instance_fields
));
1919 if (field_count
> 0)
1921 vec_safe_splice (static_fields
, instance_fields
);
1922 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1923 fields_decl
= build_decl (input_location
,
1924 VAR_DECL
, mangled_classname ("_FL_", type
),
1926 DECL_INITIAL (fields_decl
)
1927 = build_constructor (field_array_type
, static_fields
);
1928 TREE_STATIC (fields_decl
) = 1;
1929 DECL_ARTIFICIAL (fields_decl
) = 1;
1930 DECL_IGNORED_P (fields_decl
) = 1;
1931 rest_of_decl_compilation (fields_decl
, 1, 0);
1934 fields_decl
= NULL_TREE
;
1936 /* Build Method array. */
1937 for (method
= TYPE_METHODS (type
);
1938 method
!= NULL_TREE
; method
= DECL_CHAIN (method
))
1941 if (METHOD_PRIVATE (method
)
1942 && ! flag_keep_inline_functions
1945 /* Even if we have a decl, we don't necessarily have the code.
1946 This can happen if we inherit a method from a superclass for
1947 which we don't have a .class file. */
1948 if (METHOD_DUMMY (method
))
1951 /* Generate method reflection data if:
1953 - !flag_reduced_reflection.
1955 - <clinit> -- The runtime uses reflection to initialize the
1958 - Any method in class java.lang.Class -- Class.forName() and
1959 perhaps other things require it.
1961 - class$ -- It does not work if reflection data missing.
1963 - main -- Reflection is used to find main(String[]) methods.
1965 - public not static -- It is potentially part of an
1966 interface. The runtime uses reflection data to build
1967 interface dispatch tables. */
1968 if (!flag_reduced_reflection
1969 || DECL_CLINIT_P (method
)
1970 || DECL_NAME (type_decl
) == id_class
1971 || DECL_NAME (method
) == id_main
1972 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1974 init
= make_method_value (method
);
1976 CONSTRUCTOR_APPEND_ELT (methods
, NULL_TREE
, init
);
1979 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1980 methods_decl
= build_decl (input_location
,
1981 VAR_DECL
, mangled_classname ("_MT_", type
),
1983 DECL_INITIAL (methods_decl
) = build_constructor (method_array_type
, methods
);
1984 TREE_STATIC (methods_decl
) = 1;
1985 DECL_ARTIFICIAL (methods_decl
) = 1;
1986 DECL_IGNORED_P (methods_decl
) = 1;
1987 rest_of_decl_compilation (methods_decl
, 1, 0);
1989 if (class_dtable_decl
== NULL_TREE
)
1991 class_dtable_decl
= build_dtable_decl (class_type_node
);
1992 TREE_STATIC (class_dtable_decl
) = 1;
1993 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1994 DECL_IGNORED_P (class_dtable_decl
) = 1;
1995 if (is_compiled_class (class_type_node
) != 2)
1997 DECL_EXTERNAL (class_dtable_decl
) = 1;
1998 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
2002 super
= CLASSTYPE_SUPER (type
);
2003 if (super
== NULL_TREE
)
2004 super
= null_pointer_node
;
2005 else if (! flag_indirect_dispatch
2006 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
2007 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
2008 super
= build_class_ref (super
);
2011 int super_index
= alloc_class_constant (super
);
2012 super
= build_int_cst (ptr_type_node
, super_index
);
2015 /* Build and emit the array of implemented interfaces. */
2016 if (type
!= object_type_node
)
2017 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
2019 if (interface_len
> 0)
2022 tree interface_array_type
, idecl
;
2023 vec
<constructor_elt
, va_gc
> *init
;
2024 vec_alloc (init
, interface_len
);
2025 interface_array_type
2026 = build_prim_array_type (class_ptr_type
, interface_len
);
2027 idecl
= build_decl (input_location
,
2028 VAR_DECL
, mangled_classname ("_IF_", type
),
2029 interface_array_type
);
2031 for (i
= 1; i
<= interface_len
; i
++)
2033 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
2034 tree iclass
= BINFO_TYPE (child
);
2036 if (! flag_indirect_dispatch
2038 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
2039 index
= build_class_ref (iclass
);
2042 int int_index
= alloc_class_constant (iclass
);
2043 index
= build_int_cst (ptr_type_node
, int_index
);
2045 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, index
);
2047 DECL_INITIAL (idecl
) = build_constructor (interface_array_type
, init
);
2048 TREE_STATIC (idecl
) = 1;
2049 DECL_ARTIFICIAL (idecl
) = 1;
2050 DECL_IGNORED_P (idecl
) = 1;
2051 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
2052 rest_of_decl_compilation (idecl
, 1, 0);
2055 constant_pool_constructor
= build_constants_constructor ();
2057 if (flag_indirect_dispatch
)
2059 TYPE_OTABLE_DECL (type
)
2061 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
2062 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
2063 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
2065 TYPE_ATABLE_DECL (type
)
2067 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
2068 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
2069 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2071 TYPE_ITABLE_DECL (type
)
2073 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2074 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2075 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2078 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2080 START_RECORD_CONSTRUCTOR (v1
, object_type_node
);
2081 PUSH_FIELD_VALUE (v1
, "vtable",
2082 (flag_indirect_classes
2084 : fold_build_pointer_plus
2085 (build1 (ADDR_EXPR
, dtable_ptr_type
,
2087 dtable_start_offset
)));
2088 if (! flag_hash_synchronization
)
2089 PUSH_FIELD_VALUE (v1
, "sync_info", null_pointer_node
);
2090 FINISH_RECORD_CONSTRUCTOR (temp
, v1
, object_type_node
);
2091 START_RECORD_CONSTRUCTOR (v2
, class_type_node
);
2092 PUSH_SUPER_VALUE (v2
, temp
);
2093 PUSH_FIELD_VALUE (v2
, "next_or_version", gcj_abi_version
);
2094 PUSH_FIELD_VALUE (v2
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2095 PUSH_FIELD_VALUE (v2
, "accflags",
2096 build_int_cst (NULL_TREE
,
2097 get_access_flags_from_decl (type_decl
)));
2099 PUSH_FIELD_VALUE (v2
, "superclass",
2100 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2101 PUSH_FIELD_VALUE (v2
, "constants", constant_pool_constructor
);
2102 PUSH_FIELD_VALUE (v2
, "methods",
2103 methods_decl
== NULL_TREE
? null_pointer_node
2104 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2105 PUSH_FIELD_VALUE (v2
, "method_count",
2106 build_int_cst (NULL_TREE
, method_count
));
2108 PUSH_FIELD_VALUE (v2
, "vtable_method_count",
2109 (flag_indirect_dispatch
2110 ? integer_minus_one_node
2111 : TYPE_NVIRTUALS (type
)));
2113 PUSH_FIELD_VALUE (v2
, "fields",
2114 fields_decl
== NULL_TREE
? null_pointer_node
2115 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2116 /* If we're using the binary compatibility ABI we don't know the
2117 size until load time. */
2118 PUSH_FIELD_VALUE (v2
, "size_in_bytes",
2119 (flag_indirect_dispatch
2120 ? integer_minus_one_node
2121 : size_in_bytes (type
)));
2122 PUSH_FIELD_VALUE (v2
, "field_count",
2123 build_int_cst (NULL_TREE
, field_count
));
2124 PUSH_FIELD_VALUE (v2
, "static_field_count",
2125 build_int_cst (NULL_TREE
, static_field_count
));
2127 PUSH_FIELD_VALUE (v2
, "vtable",
2128 (flag_indirect_dispatch
|| dtable_decl
== NULL_TREE
2130 : fold_build_pointer_plus
2131 (build1 (ADDR_EXPR
, dtable_ptr_type
,
2133 dtable_start_offset
)));
2134 add_table_and_syms (&v2
, TYPE_OTABLE_METHODS (type
),
2135 "otable", TYPE_OTABLE_DECL (type
), otable_ptr_type
,
2136 "otable_syms", TYPE_OTABLE_SYMS_DECL (type
));
2137 add_table_and_syms (&v2
, TYPE_ATABLE_METHODS (type
),
2138 "atable", TYPE_ATABLE_DECL (type
), atable_ptr_type
,
2139 "atable_syms", TYPE_ATABLE_SYMS_DECL (type
));
2140 add_table_and_syms (&v2
, TYPE_ITABLE_METHODS (type
),
2141 "itable", TYPE_ITABLE_DECL (type
), itable_ptr_type
,
2142 "itable_syms", TYPE_ITABLE_SYMS_DECL (type
));
2144 PUSH_FIELD_VALUE (v2
, "catch_classes",
2145 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2146 PUSH_FIELD_VALUE (v2
, "interfaces", interfaces
);
2147 PUSH_FIELD_VALUE (v2
, "loader", null_pointer_node
);
2148 PUSH_FIELD_VALUE (v2
, "interface_count",
2149 build_int_cst (NULL_TREE
, interface_len
));
2150 PUSH_FIELD_VALUE (v2
, "state",
2151 convert (byte_type_node
,
2152 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2154 PUSH_FIELD_VALUE (v2
, "thread", null_pointer_node
);
2155 PUSH_FIELD_VALUE (v2
, "depth", integer_zero_node
);
2156 PUSH_FIELD_VALUE (v2
, "ancestors", null_pointer_node
);
2157 PUSH_FIELD_VALUE (v2
, "idt", null_pointer_node
);
2158 PUSH_FIELD_VALUE (v2
, "arrayclass", null_pointer_node
);
2159 PUSH_FIELD_VALUE (v2
, "protectionDomain", null_pointer_node
);
2162 tree assertion_table_ref
;
2163 if (TYPE_ASSERTIONS (type
) == NULL
)
2164 assertion_table_ref
= null_pointer_node
;
2166 assertion_table_ref
= build1 (ADDR_EXPR
,
2167 build_pointer_type (assertion_table_type
),
2168 emit_assertion_table (type
));
2170 PUSH_FIELD_VALUE (v2
, "assertion_table", assertion_table_ref
);
2173 PUSH_FIELD_VALUE (v2
, "hack_signers", null_pointer_node
);
2174 PUSH_FIELD_VALUE (v2
, "chain", null_pointer_node
);
2175 PUSH_FIELD_VALUE (v2
, "aux_info", null_pointer_node
);
2176 PUSH_FIELD_VALUE (v2
, "engine", null_pointer_node
);
2178 if (TYPE_REFLECTION_DATA (current_class
))
2181 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2182 vec
<constructor_elt
, va_gc
> *v
;
2183 vec_alloc (v
, count
);
2184 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2185 tree max_index
= build_int_cst (sizetype
, count
);
2186 tree index
= build_index_type (max_index
);
2187 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2190 static int reflection_data_count
;
2192 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2193 array
= build_decl (input_location
,
2194 VAR_DECL
, get_identifier (buf
), type
);
2196 rewrite_reflection_indexes (&field_indexes
);
2198 for (i
= 0; i
< count
; i
++)
2200 constructor_elt elt
;
2201 elt
.index
= build_int_cst (sizetype
, i
);
2202 elt
.value
= build_int_cstu (byte_type_node
, data
[i
]);
2203 v
->quick_push (elt
);
2206 DECL_INITIAL (array
) = build_constructor (type
, v
);
2207 TREE_STATIC (array
) = 1;
2208 DECL_ARTIFICIAL (array
) = 1;
2209 DECL_IGNORED_P (array
) = 1;
2210 TREE_READONLY (array
) = 1;
2211 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2212 rest_of_decl_compilation (array
, 1, 0);
2214 reflection_data
= build_address_of (array
);
2217 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2220 reflection_data
= null_pointer_node
;
2222 PUSH_FIELD_VALUE (v2
, "reflection_data", reflection_data
);
2223 FINISH_RECORD_CONSTRUCTOR (cons
, v2
, class_type_node
);
2225 DECL_INITIAL (decl
) = cons
;
2227 /* Hash synchronization requires at least 64-bit alignment. */
2228 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2229 DECL_ALIGN (decl
) = 64;
2231 if (flag_indirect_classes
)
2233 TREE_READONLY (decl
) = 1;
2234 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2237 rest_of_decl_compilation (decl
, 1, 0);
2240 tree classdollar_field
= build_classdollar_field (type
);
2241 if (!flag_indirect_classes
)
2242 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2243 rest_of_decl_compilation (classdollar_field
, 1, 0);
2246 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2247 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2248 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2254 java_expand_catch_classes (current_class
);
2256 current_function_decl
= NULL_TREE
;
2257 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2258 make_class_data (current_class
);
2260 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2263 /* Return 2 if KLASS is compiled by this compilation job;
2264 return 1 if KLASS can otherwise be assumed to be compiled;
2265 return 0 if we cannot assume that KLASS is compiled.
2266 Returns 1 for primitive and 0 for array types. */
2268 is_compiled_class (tree klass
)
2271 if (TREE_CODE (klass
) == POINTER_TYPE
)
2272 klass
= TREE_TYPE (klass
);
2273 if (TREE_CODE (klass
) != RECORD_TYPE
) /* Primitive types are static. */
2275 if (TYPE_ARRAY_P (klass
))
2278 seen_in_zip
= (TYPE_JCF (klass
) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass
)));
2279 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2281 /* The class was seen in the current ZIP file and will be
2282 available as a compiled class in the future but may not have
2283 been loaded already. Load it if necessary. This prevent
2284 build_class_ref () from crashing. */
2286 if (seen_in_zip
&& !CLASS_LOADED_P (klass
) && (klass
!= current_class
))
2287 load_class (klass
, 1);
2289 /* We return 2 for class seen in ZIP and class from files
2290 belonging to the same compilation unit */
2294 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass
)))))
2296 if (!CLASS_LOADED_P (klass
))
2298 if (klass
!= current_class
)
2299 load_class (klass
, 1);
2307 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2310 build_dtable_decl (tree type
)
2314 /* We need to build a new dtable type so that its size is uniquely
2315 computed when we're dealing with the class for real and not just
2316 faking it (like java.lang.Class during the initialization of the
2317 compiler.) We know we're not faking a class when CURRENT_CLASS is
2319 if (current_class
== type
)
2321 tree dummy
= NULL_TREE
;
2324 dtype
= make_node (RECORD_TYPE
);
2326 PUSH_FIELD (input_location
, dtype
, dummy
, "top_offset", ptr_type_node
);
2327 PUSH_FIELD (input_location
, dtype
, dummy
, "type_info", ptr_type_node
);
2329 PUSH_FIELD (input_location
, dtype
, dummy
, "class", class_ptr_type
);
2330 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2332 tree tmp_field
= build_decl (input_location
,
2333 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2334 TREE_CHAIN (dummy
) = tmp_field
;
2335 DECL_CONTEXT (tmp_field
) = dtype
;
2336 DECL_ARTIFICIAL (tmp_field
) = 1;
2340 PUSH_FIELD (input_location
, dtype
, dummy
, "gc_descr", ptr_type_node
);
2341 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2343 tree tmp_field
= build_decl (input_location
,
2344 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2345 TREE_CHAIN (dummy
) = tmp_field
;
2346 DECL_CONTEXT (tmp_field
) = dtype
;
2347 DECL_ARTIFICIAL (tmp_field
) = 1;
2351 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2352 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2353 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2355 PUSH_FIELD (input_location
, dtype
, dummy
, "methods",
2356 build_prim_array_type (nativecode_ptr_type_node
, n
));
2357 layout_type (dtype
);
2360 dtype
= dtable_type
;
2362 decl
= build_decl (input_location
,
2363 VAR_DECL
, get_identifier ("vt$"), dtype
);
2364 DECL_CONTEXT (decl
) = type
;
2365 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2366 DECL_VTABLE_P (decl
) = 1;
2371 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2372 fields inherited from SUPER_CLASS. */
2375 push_super_field (tree this_class
, tree super_class
)
2378 /* Don't insert the field if we're just re-laying the class out. */
2379 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2381 base_decl
= build_decl (input_location
,
2382 FIELD_DECL
, NULL_TREE
, super_class
);
2383 DECL_IGNORED_P (base_decl
) = 1;
2384 DECL_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2385 TYPE_FIELDS (this_class
) = base_decl
;
2386 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2387 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2390 /* Handle the different manners we may have to lay out a super class. */
2393 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2397 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2399 if (!CLASS_LOADED_P (super_class
))
2400 load_class (super_class
, 1);
2402 /* We might have to layout the class before its dependency on
2403 the super class gets resolved by java_complete_class */
2404 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2406 if (TREE_TYPE (super_class
) != NULL_TREE
)
2407 super_class
= TREE_TYPE (super_class
);
2411 if (!TYPE_SIZE (super_class
))
2412 safe_layout_class (super_class
);
2417 /* safe_layout_class just makes sure that we can load a class without
2418 disrupting the current_class, input_location, etc, information
2419 about the class processed currently. */
2422 safe_layout_class (tree klass
)
2424 tree save_current_class
= current_class
;
2425 location_t save_location
= input_location
;
2427 layout_class (klass
);
2429 current_class
= save_current_class
;
2430 input_location
= save_location
;
2434 layout_class (tree this_class
)
2437 tree super_class
= CLASSTYPE_SUPER (this_class
);
2439 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2440 if (CLASS_BEING_LAIDOUT (this_class
))
2446 sprintf (buffer
, " with '%s'",
2447 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2448 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2450 for (current
= TREE_CHAIN (class_list
); current
;
2451 current
= TREE_CHAIN (current
))
2453 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2454 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2455 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2456 DECL_SOURCE_FILE (decl
),
2457 DECL_SOURCE_LINE (decl
));
2458 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2460 obstack_1grow (&temporary_obstack
, '\0');
2461 report
= XOBFINISH (&temporary_obstack
, char *);
2462 cyclic_inheritance_report
= ggc_strdup (report
);
2463 obstack_free (&temporary_obstack
, report
);
2464 TYPE_SIZE (this_class
) = error_mark_node
;
2467 CLASS_BEING_LAIDOUT (this_class
) = 1;
2469 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2471 tree maybe_super_class
2472 = maybe_layout_super_class (super_class
, this_class
);
2473 if (maybe_super_class
== NULL
2474 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2476 TYPE_SIZE (this_class
) = error_mark_node
;
2477 CLASS_BEING_LAIDOUT (this_class
) = 0;
2478 class_list
= TREE_CHAIN (class_list
);
2481 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2482 push_super_field (this_class
, maybe_super_class
);
2485 layout_type (this_class
);
2487 /* Also recursively load/layout any superinterfaces. */
2488 if (TYPE_BINFO (this_class
))
2490 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2492 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2493 tree super_interface
= BINFO_TYPE (binfo
);
2494 tree maybe_super_interface
2495 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2496 if (maybe_super_interface
== NULL
2497 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2499 TYPE_SIZE (this_class
) = error_mark_node
;
2500 CLASS_BEING_LAIDOUT (this_class
) = 0;
2501 class_list
= TREE_CHAIN (class_list
);
2507 /* Convert the size back to an SI integer value. */
2508 TYPE_SIZE_UNIT (this_class
) =
2509 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2511 CLASS_BEING_LAIDOUT (this_class
) = 0;
2512 class_list
= TREE_CHAIN (class_list
);
2516 add_miranda_methods (tree base_class
, tree search_class
)
2519 tree binfo
, base_binfo
;
2521 if (!CLASS_PARSED_P (search_class
))
2522 load_class (search_class
, 1);
2524 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2525 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2528 tree elt
= BINFO_TYPE (base_binfo
);
2530 /* FIXME: This is totally bogus. We should not be handling
2531 Miranda methods at all if we're using the BC ABI. */
2532 if (TYPE_DUMMY (elt
))
2535 /* Ensure that interface methods are seen in declared order. */
2536 if (!CLASS_LOADED_P (elt
))
2537 load_class (elt
, 1);
2538 layout_class_methods (elt
);
2540 /* All base classes will have been laid out at this point, so the order
2541 will be correct. This code must match similar layout code in the
2543 for (method_decl
= TYPE_METHODS (elt
);
2544 method_decl
; method_decl
= DECL_CHAIN (method_decl
))
2548 /* An interface can have <clinit>. */
2549 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2552 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2553 override
= lookup_argument_method (base_class
,
2554 DECL_NAME (method_decl
), sig
);
2555 if (override
== NULL_TREE
)
2557 /* Found a Miranda method. Add it. */
2559 sig
= build_java_signature (TREE_TYPE (method_decl
));
2561 = add_method (base_class
,
2562 get_access_flags_from_decl (method_decl
),
2563 DECL_NAME (method_decl
), sig
);
2564 METHOD_INVISIBLE (new_method
) = 1;
2568 /* Try superinterfaces. */
2569 add_miranda_methods (base_class
, elt
);
2574 layout_class_methods (tree this_class
)
2576 tree method_decl
, dtable_count
;
2577 tree super_class
, type_name
;
2579 if (TYPE_NVIRTUALS (this_class
))
2582 super_class
= CLASSTYPE_SUPER (this_class
);
2586 super_class
= maybe_layout_super_class (super_class
, this_class
);
2587 if (!TYPE_NVIRTUALS (super_class
))
2588 layout_class_methods (super_class
);
2589 dtable_count
= TYPE_NVIRTUALS (super_class
);
2592 dtable_count
= integer_zero_node
;
2594 type_name
= TYPE_NAME (this_class
);
2595 if (!flag_indirect_dispatch
2596 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2598 /* An abstract class can have methods which are declared only in
2599 an implemented interface. These are called "Miranda
2600 methods". We make a dummy method entry for such methods
2602 add_miranda_methods (this_class
, this_class
);
2605 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2607 for (method_decl
= TYPE_METHODS (this_class
);
2608 method_decl
; method_decl
= DECL_CHAIN (method_decl
))
2609 dtable_count
= layout_class_method (this_class
, super_class
,
2610 method_decl
, dtable_count
);
2612 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2615 /* Return the index of METHOD in INTERFACE. This index begins at 1
2616 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2618 get_interface_method_index (tree method
, tree interface
)
2623 for (meth
= TYPE_METHODS (interface
); ; meth
= DECL_CHAIN (meth
))
2627 /* We don't want to put <clinit> into the interface table. */
2628 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2630 gcc_assert (meth
!= NULL_TREE
);
2634 /* Lay METHOD_DECL out, returning a possibly new value of
2635 DTABLE_COUNT. Also mangle the method's name. */
2638 layout_class_method (tree this_class
, tree super_class
,
2639 tree method_decl
, tree dtable_count
)
2641 tree method_name
= DECL_NAME (method_decl
);
2643 TREE_PUBLIC (method_decl
) = 1;
2645 if (flag_indirect_classes
2646 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2647 && ! METHOD_NATIVE (method_decl
)
2648 && ! special_method_p (method_decl
)))
2649 java_hide_decl (method_decl
);
2651 /* Considered external unless it is being compiled into this object
2652 file, or it was already flagged as external. */
2653 if (!DECL_EXTERNAL (method_decl
))
2654 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2655 || METHOD_NATIVE (method_decl
));
2657 if (ID_INIT_P (method_name
))
2659 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2661 for (ptr
= p
; *ptr
; )
2666 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2667 build_java_signature (TREE_TYPE (method_decl
));
2669 else if (! METHOD_STATIC (method_decl
))
2672 build_java_signature (TREE_TYPE (method_decl
));
2673 bool method_override
= false;
2674 tree super_method
= lookup_java_method (super_class
, method_name
,
2676 if (super_method
!= NULL_TREE
2677 && ! METHOD_DUMMY (super_method
))
2679 method_override
= true;
2680 if (! METHOD_PUBLIC (super_method
) &&
2681 ! METHOD_PROTECTED (super_method
))
2683 /* Don't override private method, or default-access method in
2685 if (METHOD_PRIVATE (super_method
) ||
2686 ! in_same_package (TYPE_NAME (this_class
),
2687 TYPE_NAME (super_class
)))
2688 method_override
= false;
2691 if (method_override
)
2693 tree method_index
= get_method_index (super_method
);
2694 set_method_index (method_decl
, method_index
);
2695 if (method_index
== NULL_TREE
2696 && ! flag_indirect_dispatch
2697 && ! DECL_ARTIFICIAL (super_method
))
2698 error ("non-static method %q+D overrides static method",
2701 else if (this_class
== object_type_node
2702 && (METHOD_FINAL (method_decl
)
2703 || METHOD_PRIVATE (method_decl
)))
2705 /* We don't generate vtable entries for final Object
2706 methods. This is simply to save space, since every
2707 object would otherwise have to define them. */
2709 else if (! METHOD_PRIVATE (method_decl
)
2712 /* We generate vtable entries for final methods because they
2713 may one day be changed to non-final. */
2714 set_method_index (method_decl
, dtable_count
);
2715 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2716 dtable_count
, integer_one_node
);
2720 return dtable_count
;
2724 register_class (void)
2728 if (!registered_class
)
2729 vec_alloc (registered_class
, 8);
2731 if (flag_indirect_classes
)
2732 node
= current_class
;
2734 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2735 vec_safe_push (registered_class
, node
);
2738 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2739 all the classes we have emitted. */
2742 emit_indirect_register_classes (tree
*list_p
)
2744 tree klass
, t
, register_class_fn
;
2747 int size
= vec_safe_length (registered_class
) * 2 + 1;
2748 vec
<constructor_elt
, va_gc
> *init
;
2749 vec_alloc (init
, size
);
2750 tree class_array_type
2751 = build_prim_array_type (ptr_type_node
, size
);
2752 tree
cdecl = build_decl (input_location
,
2753 VAR_DECL
, get_identifier ("_Jv_CLS"),
2755 tree reg_class_list
;
2756 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2758 t
= fold_convert (ptr_type_node
, build_static_class_ref (klass
));
2759 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, t
);
2760 t
= fold_convert (ptr_type_node
,
2761 build_address_of (build_classdollar_field (klass
)));
2762 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, t
);
2764 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, integer_zero_node
);
2765 DECL_INITIAL (cdecl) = build_constructor (class_array_type
, init
);
2766 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2767 TREE_STATIC (cdecl) = 1;
2768 DECL_ARTIFICIAL (cdecl) = 1;
2769 DECL_IGNORED_P (cdecl) = 1;
2770 TREE_READONLY (cdecl) = 1;
2771 TREE_CONSTANT (cdecl) = 1;
2772 rest_of_decl_compilation (cdecl, 1, 0);
2773 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2775 t
= build_function_type_list (void_type_node
,
2776 build_pointer_type (ptr_type_node
), NULL
);
2777 t
= build_decl (input_location
,
2779 get_identifier ("_Jv_RegisterNewClasses"), t
);
2780 TREE_PUBLIC (t
) = 1;
2781 DECL_EXTERNAL (t
) = 1;
2782 register_class_fn
= t
;
2783 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2784 append_to_statement_list (t
, list_p
);
2787 /* Emit a list of pointers to all classes we have emitted to JCR_SECTION. */
2790 emit_register_classes_in_jcr_section (void)
2792 #ifdef JCR_SECTION_NAME
2793 tree klass
, cdecl, class_array_type
;
2795 int size
= vec_safe_length (registered_class
);
2796 vec
<constructor_elt
, va_gc
> *init
;
2797 vec_alloc (init
, size
);
2799 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2800 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, build_fold_addr_expr (klass
));
2802 /* ??? I would like to use tree_output_constant_def() but there is no way
2803 to put the data in a named section name, or to set the alignment,
2804 via that function. So do everything manually here. */
2805 class_array_type
= build_prim_array_type (ptr_type_node
, size
);
2806 cdecl = build_decl (UNKNOWN_LOCATION
,
2807 VAR_DECL
, get_identifier ("_Jv_JCR_SECTION_data"),
2809 DECL_SECTION_NAME (cdecl) = build_string (strlen (JCR_SECTION_NAME
),
2811 DECL_ALIGN (cdecl) = POINTER_SIZE
;
2812 DECL_USER_ALIGN (cdecl) = 1;
2813 DECL_INITIAL (cdecl) = build_constructor (class_array_type
, init
);
2814 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2815 TREE_STATIC (cdecl) = 1;
2816 TREE_READONLY (cdecl) = 0;
2817 TREE_CONSTANT (cdecl) = 1;
2818 DECL_ARTIFICIAL (cdecl) = 1;
2819 DECL_IGNORED_P (cdecl) = 1;
2820 DECL_PRESERVE_P (cdecl) = 1;
2821 pushdecl_top_level (cdecl);
2822 relayout_decl (cdecl);
2823 rest_of_decl_compilation (cdecl, 1, 0);
2825 /* A target has defined TARGET_USE_JCR_SECTION,
2826 but doesn't have a JCR_SECTION_NAME. */
2832 /* Emit a series of calls to _Jv_RegisterClass for every class we emitted.
2833 A series of calls is added to LIST_P. */
2836 emit_Jv_RegisterClass_calls (tree
*list_p
)
2838 tree klass
, t
, register_class_fn
;
2841 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2842 t
= build_decl (input_location
,
2843 FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2844 TREE_PUBLIC (t
) = 1;
2845 DECL_EXTERNAL (t
) = 1;
2846 register_class_fn
= t
;
2848 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2850 t
= build_fold_addr_expr (klass
);
2851 t
= build_call_expr (register_class_fn
, 1, t
);
2852 append_to_statement_list (t
, list_p
);
2856 /* Emit something to register classes at start-up time.
2858 The default mechanism is to generate instances at run-time.
2860 An alternative mechanism is through the .jcr section, which contain
2861 a list of pointers to classes which get registered during constructor
2864 The fallback mechanism is to add statements to *LIST_P to call
2865 _Jv_RegisterClass for each class in this file. These statements will
2866 be added to a static constructor function for this translation unit. */
2869 emit_register_classes (tree
*list_p
)
2871 if (registered_class
== NULL
)
2874 /* By default, generate instances of Class at runtime. */
2875 if (flag_indirect_classes
)
2876 emit_indirect_register_classes (list_p
);
2877 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2878 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2879 but lack suitable crtbegin/end objects or linker support. These
2880 targets can override the default in tm.h to use the fallback mechanism. */
2881 else if (TARGET_USE_JCR_SECTION
)
2882 emit_register_classes_in_jcr_section ();
2883 /* Use the fallback mechanism. */
2885 emit_Jv_RegisterClass_calls (list_p
);
2888 /* Build a constructor for an entry in the symbol table. */
2891 build_symbol_table_entry (tree clname
, tree name
, tree signature
)
2894 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2896 START_RECORD_CONSTRUCTOR (v
, symbol_type
);
2897 PUSH_FIELD_VALUE (v
, "clname", clname
);
2898 PUSH_FIELD_VALUE (v
, "name", name
);
2899 PUSH_FIELD_VALUE (v
, "signature", signature
);
2900 FINISH_RECORD_CONSTRUCTOR (symbol
, v
, symbol_type
);
2901 TREE_CONSTANT (symbol
) = 1;
2906 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2909 build_symbol_entry (tree decl
, tree special
)
2911 tree clname
, name
, signature
;
2912 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2913 /* ??? Constructors are given the name foo.foo all the way through
2914 the compiler, but in the method table they're all renamed
2915 foo.<init>. So, we have to do the same here unless we want an
2916 unresolved reference at runtime. */
2917 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2918 && DECL_CONSTRUCTOR_P (decl
))
2919 ? init_identifier_node
2920 : DECL_NAME (decl
));
2921 signature
= build_java_signature (TREE_TYPE (decl
));
2922 signature
= build_utf8_ref (unmangle_classname
2923 (IDENTIFIER_POINTER (signature
),
2924 IDENTIFIER_LENGTH (signature
)));
2925 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2926 signature addr+1 if SPECIAL, and this indicates to the runtime
2927 system that this is a "special" symbol, i.e. one that should
2928 bypass access controls. */
2929 if (special
!= NULL_TREE
)
2930 signature
= fold_build_pointer_plus (signature
, special
);
2932 return build_symbol_table_entry (clname
, name
, signature
);
2935 /* Emit a symbol table: used by -findirect-dispatch. */
2938 emit_symbol_table (tree name
, tree the_table
,
2939 vec
<method_entry
, va_gc
> *decl_table
,
2940 tree the_syms_decl
, tree the_array_element_type
,
2943 tree table
, null_symbol
, table_size
, the_array_type
;
2946 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2948 /* Only emit a table if this translation unit actually made any
2949 references via it. */
2953 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2954 FOR_EACH_VEC_ELT (*decl_table
, index
, e
)
2955 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
2956 build_symbol_entry (e
->method
, e
->special
));
2958 /* Terminate the list with a "null" entry. */
2959 null_symbol
= build_symbol_table_entry (null_pointer_node
,
2962 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, null_symbol
);
2964 tree symbols_arr_type
2965 = build_prim_array_type (symbol_type
, vec_safe_length (v
));
2967 table
= build_constructor (symbols_arr_type
, v
);
2969 /* Make it the initial value for otable_syms and emit the decl. */
2970 TREE_TYPE (the_syms_decl
) = symbols_arr_type
;
2971 relayout_decl (the_syms_decl
);
2972 DECL_INITIAL (the_syms_decl
) = table
;
2973 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2974 DECL_IGNORED_P (the_syms_decl
) = 1;
2975 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2977 /* Now that its size is known, redefine the table as an
2978 uninitialized static array of INDEX + 1 elements. The extra entry
2979 is used by the runtime to track whether the table has been
2982 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2983 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2984 the_table
= build_decl (input_location
,
2985 VAR_DECL
, name
, the_array_type
);
2986 TREE_STATIC (the_table
) = 1;
2987 TREE_READONLY (the_table
) = 1;
2988 rest_of_decl_compilation (the_table
, 1, 0);
2993 /* Make an entry for the catch_classes list. */
2995 make_catch_class_record (tree catch_class
, tree classname
)
2998 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2999 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3000 START_RECORD_CONSTRUCTOR (v
, type
);
3001 PUSH_FIELD_VALUE (v
, "address", catch_class
);
3002 PUSH_FIELD_VALUE (v
, "classname", classname
);
3003 FINISH_RECORD_CONSTRUCTOR (entry
, v
, type
);
3008 /* Generate the list of Throwable classes that are caught by exception
3009 handlers in this class. */
3011 emit_catch_table (tree this_class
)
3013 tree table
, table_size
, array_type
;
3014 int n_catch_classes
;
3016 /* Fill in the dummy entry that make_class created. */
3017 e
= &(*TYPE_CATCH_CLASSES (this_class
))[0];
3018 e
->value
= make_catch_class_record (null_pointer_node
, null_pointer_node
);
3019 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class
), NULL_TREE
,
3020 make_catch_class_record (null_pointer_node
,
3021 null_pointer_node
));
3022 n_catch_classes
= TYPE_CATCH_CLASSES (this_class
)->length ();
3023 table_size
= build_index_type (build_int_cst (NULL_TREE
, n_catch_classes
));
3025 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
3028 build_decl (input_location
,
3029 VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
3030 DECL_INITIAL (table
) =
3031 build_constructor (array_type
, TYPE_CATCH_CLASSES (this_class
));
3032 TREE_STATIC (table
) = 1;
3033 TREE_READONLY (table
) = 1;
3034 DECL_IGNORED_P (table
) = 1;
3035 rest_of_decl_compilation (table
, 1, 0);
3039 /* Given a type, return the signature used by
3040 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
3041 same as build_java_signature() because we want the canonical array
3045 build_signature_for_libgcj (tree type
)
3049 sig
= build_java_signature (type
);
3050 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
3051 IDENTIFIER_LENGTH (sig
)));
3055 /* Build an entry in the type assertion table. */
3058 build_assertion_table_entry (tree code
, tree op1
, tree op2
)
3060 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3063 START_RECORD_CONSTRUCTOR (v
, assertion_entry_type
);
3064 PUSH_FIELD_VALUE (v
, "assertion_code", code
);
3065 PUSH_FIELD_VALUE (v
, "op1", op1
);
3066 PUSH_FIELD_VALUE (v
, "op2", op2
);
3067 FINISH_RECORD_CONSTRUCTOR (entry
, v
, assertion_entry_type
);
3072 /* Add an entry to the type assertion table. Callback used during hashtable
3076 add_assertion_table_entry (void **htab_entry
, void *ptr
)
3079 tree code_val
, op1_utf8
, op2_utf8
;
3080 vec
<constructor_elt
, va_gc
> **v
3081 = ((vec
<constructor_elt
, va_gc
> **) ptr
);
3082 type_assertion
*as
= (type_assertion
*) *htab_entry
;
3084 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
3086 if (as
->op1
== NULL_TREE
)
3087 op1_utf8
= null_pointer_node
;
3089 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3091 if (as
->op2
== NULL_TREE
)
3092 op2_utf8
= null_pointer_node
;
3094 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3096 entry
= build_assertion_table_entry (code_val
, op1_utf8
, op2_utf8
);
3098 CONSTRUCTOR_APPEND_ELT (*v
, NULL_TREE
, entry
);
3102 /* Generate the type assertion table for KLASS, and return its DECL. */
3105 emit_assertion_table (tree klass
)
3107 tree null_entry
, ctor
, table_decl
;
3108 htab_t assertions_htab
= TYPE_ASSERTIONS (klass
);
3109 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3111 /* Iterate through the hash table. */
3112 htab_traverse (assertions_htab
, add_assertion_table_entry
, &v
);
3114 /* Finish with a null entry. */
3115 null_entry
= build_assertion_table_entry (integer_zero_node
,
3119 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, null_entry
);
3122 = build_prim_array_type (assertion_entry_type
, vec_safe_length (v
));
3124 ctor
= build_constructor (type
, v
);
3126 table_decl
= build_decl (input_location
,
3127 VAR_DECL
, mangled_classname ("_type_assert_", klass
),
3130 TREE_STATIC (table_decl
) = 1;
3131 TREE_READONLY (table_decl
) = 1;
3132 TREE_CONSTANT (table_decl
) = 1;
3133 DECL_IGNORED_P (table_decl
) = 1;
3135 DECL_INITIAL (table_decl
) = ctor
;
3136 DECL_ARTIFICIAL (table_decl
) = 1;
3137 rest_of_decl_compilation (table_decl
, 1, 0);
3143 init_class_processing (void)
3145 fields_ident
= get_identifier ("fields");
3146 info_ident
= get_identifier ("info");
3148 gcc_obstack_init (&temporary_obstack
);
3151 static hashval_t
java_treetreehash_hash (const void *);
3152 static int java_treetreehash_compare (const void *, const void *);
3154 /* A hash table mapping trees to trees. Used generally. */
3156 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3159 java_treetreehash_hash (const void *k_p
)
3161 const struct treetreehash_entry
*const k
3162 = (const struct treetreehash_entry
*) k_p
;
3163 return JAVA_TREEHASHHASH_H (k
->key
);
3167 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3169 const struct treetreehash_entry
*const k1
3170 = (const struct treetreehash_entry
*) k1_p
;
3171 const_tree
const k2
= (const_tree
) k2_p
;
3172 return (k1
->key
== k2
);
3176 java_treetreehash_find (htab_t ht
, tree t
)
3178 struct treetreehash_entry
*e
;
3179 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3180 e
= (struct treetreehash_entry
*) htab_find_with_hash (ht
, t
, hv
);
3188 java_treetreehash_new (htab_t ht
, tree t
)
3191 struct treetreehash_entry
*tthe
;
3192 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3194 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3197 tthe
= ggc_alloc_cleared_treetreehash_entry ();
3202 tthe
= (struct treetreehash_entry
*) *e
;
3203 return &tthe
->value
;
3207 java_treetreehash_create (size_t size
)
3209 return htab_create_ggc (size
, java_treetreehash_hash
,
3210 java_treetreehash_compare
, NULL
);
3213 /* Break down qualified IDENTIFIER into package and class-name components.
3214 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3215 "pkg.foo", and RIGHT to "Bar". */
3218 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3221 int l
= IDENTIFIER_LENGTH (source
);
3223 base
= (char *) alloca (l
+ 1);
3224 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3226 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3228 while (*p
!= '.' && p
!= base
)
3231 /* We didn't find a '.'. Return an error. */
3237 *right
= get_identifier (p
+1);
3238 *left
= get_identifier (base
);
3243 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3244 if the classes are from the same package. */
3247 in_same_package (tree name1
, tree name2
)
3253 if (TREE_CODE (name1
) == TYPE_DECL
)
3254 name1
= DECL_NAME (name1
);
3255 if (TREE_CODE (name2
) == TYPE_DECL
)
3256 name2
= DECL_NAME (name2
);
3258 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3259 /* One in empty package. */
3262 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3263 /* Both in empty package. */
3266 split_qualified_name (&pkg1
, &tmp
, name1
);
3267 split_qualified_name (&pkg2
, &tmp
, name2
);
3269 return (pkg1
== pkg2
);
3272 /* lang_hooks.decls.final_write_globals: perform final processing on
3273 global variables. */
3276 java_write_globals (void)
3278 tree
*vec
= vec_safe_address (pending_static_fields
);
3279 int len
= vec_safe_length (pending_static_fields
);
3280 write_global_declarations ();
3281 emit_debug_global_declarations (vec
, len
);
3282 vec_free (pending_static_fields
);
3285 #include "gt-java-class.h"