1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996-2015 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"
32 #include "fold-const.h"
33 #include "stringpool.h"
34 #include "stor-layout.h"
37 #include "java-tree.h"
40 #include "diagnostic-core.h"
42 #include "output.h" /* for switch_to_section and get_section */
45 #include "hard-reg-set.h"
48 #include "tree-iterator.h"
51 static tree
make_method_value (tree
);
52 static tree
build_java_method_type (tree
, tree
, int);
53 static int32
hashUtf8String (const char *, int);
54 static tree
make_field_value (tree
);
55 static tree
get_dispatch_vector (tree
);
56 static tree
get_dispatch_table (tree
, tree
);
57 static int supers_all_compiled (tree type
);
58 static tree
maybe_layout_super_class (tree
, tree
);
59 static void add_miranda_methods (tree
, tree
);
60 static int assume_compiled (const char *);
61 static tree
build_symbol_entry (tree
, tree
);
62 static tree
emit_assertion_table (tree
);
63 static void register_class (void);
65 struct obstack temporary_obstack
;
67 static const char *cyclic_inheritance_report
;
69 /* The compiler generates different code depending on whether or not
70 it can assume certain classes have been compiled down to native
71 code or not. The compiler options -fassume-compiled= and
72 -fno-assume-compiled= are used to create a tree of
73 class_flag_node objects. This tree is queried to determine if
74 a class is assume to be compiled or not. Each node in the tree
75 represents either a package or a specific class. */
77 typedef struct class_flag_node_struct
79 /* The class or package name. */
82 /* Nonzero if this represents an exclusion. */
85 /* Pointers to other nodes in the tree. */
86 struct class_flag_node_struct
*parent
;
87 struct class_flag_node_struct
*sibling
;
88 struct class_flag_node_struct
*child
;
91 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
92 static void add_class_flag (class_flag_node
**, const char *, int);
94 /* This is the root of the include/exclude tree. */
96 static class_flag_node
*assume_compiled_tree
;
98 static class_flag_node
*enable_assert_tree
;
100 static GTY(()) tree class_roots
[4];
101 #define fields_ident class_roots[0] /* get_identifier ("fields") */
102 #define info_ident class_roots[1] /* get_identifier ("info") */
103 #define class_list class_roots[2]
104 #define class_dtable_decl class_roots[3]
106 static GTY(()) vec
<tree
, va_gc
> *registered_class
;
108 /* A tree that returns the address of the class$ of the class
109 currently being compiled. */
110 static GTY(()) tree this_classdollar
;
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
) = ggc_cleared_alloc
<struct lang_decl
> ();
768 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
770 /* Initialize the static initializer test table. */
772 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) = java_treetreehash_create (10);
774 /* Initialize the initialized (static) class table. */
775 if (access_flags
& ACC_STATIC
)
776 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
777 hash_table
<ict_hasher
>::create_ggc (50);
779 DECL_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
780 TYPE_METHODS (this_class
) = fndecl
;
782 /* If pointers to member functions use the least significant bit to
783 indicate whether a function is virtual, ensure a pointer
784 to this function will have that bit clear. */
785 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
786 && !(access_flags
& ACC_STATIC
)
787 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
788 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
790 /* Notice that this is a finalizer and update the class type
791 accordingly. This is used to optimize instance allocation. */
792 if (name
== finalize_identifier_node
793 && TREE_TYPE (function_type
) == void_type_node
794 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
795 HAS_FINALIZER_P (this_class
) = 1;
797 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
798 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
799 if (access_flags
& ACC_PRIVATE
)
800 METHOD_PRIVATE (fndecl
) = 1;
801 if (access_flags
& ACC_NATIVE
)
803 METHOD_NATIVE (fndecl
) = 1;
804 DECL_EXTERNAL (fndecl
) = 1;
807 /* FNDECL is external unless we are compiling it into this object
809 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
810 if (access_flags
& ACC_STATIC
)
811 METHOD_STATIC (fndecl
) = 1;
812 if (access_flags
& ACC_FINAL
)
813 METHOD_FINAL (fndecl
) = 1;
814 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
815 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
816 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
817 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
818 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
819 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
823 /* Add a method to THIS_CLASS.
824 The method's name is NAME.
825 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
828 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
830 tree function_type
, fndecl
;
831 const unsigned char *sig
832 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
835 fatal_error (input_location
, "bad method signature");
837 function_type
= get_type_from_signature (method_sig
);
838 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
839 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
844 add_field (tree klass
, tree name
, tree field_type
, int flags
)
846 int is_static
= (flags
& ACC_STATIC
) != 0;
848 field
= build_decl (input_location
,
849 is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
850 DECL_CHAIN (field
) = TYPE_FIELDS (klass
);
851 TYPE_FIELDS (klass
) = field
;
852 DECL_CONTEXT (field
) = klass
;
853 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
855 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
856 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
857 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
858 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
859 if (flags
& ACC_VOLATILE
)
861 FIELD_VOLATILE (field
) = 1;
862 TREE_THIS_VOLATILE (field
) = 1;
864 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
865 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
866 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
869 FIELD_STATIC (field
) = 1;
870 /* Always make field externally visible. This is required so
871 that native methods can always access the field. */
872 TREE_PUBLIC (field
) = 1;
873 /* Hide everything that shouldn't be visible outside a DSO. */
874 if (flag_indirect_classes
875 || (FIELD_PRIVATE (field
)))
876 java_hide_decl (field
);
877 /* Considered external unless we are compiling it into this
879 DECL_EXTERNAL (field
) = (is_compiled_class (klass
) != 2);
885 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
888 set_constant_value (tree field
, tree constant
)
890 if (field
== NULL_TREE
)
891 warning (OPT_Wattributes
,
892 "misplaced ConstantValue attribute (not in any field)");
893 else if (DECL_INITIAL (field
) != NULL_TREE
)
894 warning (OPT_Wattributes
,
895 "duplicate ConstantValue attribute for field '%s'",
896 IDENTIFIER_POINTER (DECL_NAME (field
)));
899 DECL_INITIAL (field
) = constant
;
900 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
901 && ! (TREE_TYPE (constant
) == int_type_node
902 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
903 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
904 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
905 && TREE_TYPE (field
) == string_ptr_type_node
))
906 error ("ConstantValue attribute of field '%s' has wrong type",
907 IDENTIFIER_POINTER (DECL_NAME (field
)));
911 /* Calculate a hash value for a string encoded in Utf8 format.
912 * This returns the same hash value as specified for java.lang.String.hashCode.
916 hashUtf8String (const char *str
, int len
)
918 const unsigned char* ptr
= (const unsigned char*) str
;
919 const unsigned char *limit
= ptr
+ len
;
923 int ch
= UTF8_GET (ptr
, limit
);
924 /* Updated specification from
925 http://www.javasoft.com/docs/books/jls/clarify.html. */
926 hash
= (31 * hash
) + ch
;
932 build_utf8_ref (tree name
)
934 const char * name_ptr
= IDENTIFIER_POINTER (name
);
935 int name_len
= IDENTIFIER_LENGTH (name
), name_pad
;
937 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
938 static int utf8_count
= 0;
940 tree ref
= IDENTIFIER_UTF8_REF (name
);
942 vec
<constructor_elt
, va_gc
> *v
= NULL
;
943 if (ref
!= NULL_TREE
)
946 ctype
= make_node (RECORD_TYPE
);
947 /* '\0' byte plus padding to utf8const_type's alignment. */
948 name_pad
= TYPE_ALIGN_UNIT (utf8const_type
)
949 - (name_len
& (TYPE_ALIGN_UNIT (utf8const_type
) - 1));
950 str_type
= build_prim_array_type (unsigned_byte_type_node
,
951 name_len
+ name_pad
);
952 PUSH_FIELD (input_location
, ctype
, field
, "hash", unsigned_short_type_node
);
953 PUSH_FIELD (input_location
,
954 ctype
, field
, "length", unsigned_short_type_node
);
955 PUSH_FIELD (input_location
, ctype
, field
, "data", str_type
);
956 FINISH_RECORD (ctype
);
957 START_RECORD_CONSTRUCTOR (v
, ctype
);
958 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
959 PUSH_FIELD_VALUE (v
, "hash", build_int_cst (NULL_TREE
, name_hash
));
960 PUSH_FIELD_VALUE (v
, "length", build_int_cst (NULL_TREE
, name_len
));
961 string
= build_string (name_len
, name_ptr
);
962 TREE_TYPE (string
) = str_type
;
963 PUSH_FIELD_VALUE (v
, "data", string
);
964 FINISH_RECORD_CONSTRUCTOR (cinit
, v
, ctype
);
965 TREE_CONSTANT (cinit
) = 1;
967 /* Generate a unique-enough identifier. */
968 sprintf(buf
, "_Utf%d", ++utf8_count
);
970 decl
= build_decl (input_location
,
971 VAR_DECL
, get_identifier (buf
), utf8const_type
);
972 TREE_STATIC (decl
) = 1;
973 DECL_ARTIFICIAL (decl
) = 1;
974 DECL_IGNORED_P (decl
) = 1;
975 TREE_READONLY (decl
) = 1;
976 TREE_THIS_VOLATILE (decl
) = 0;
977 DECL_INITIAL (decl
) = cinit
;
978 DECL_USER_ALIGN (decl
) = 1;
980 if (HAVE_GAS_SHF_MERGE
)
983 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
984 decl_size
= name_len
+ 4 + name_pad
;
985 if (flag_merge_constants
&& decl_size
< 256)
988 int flags
= (SECTION_OVERRIDE
989 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
990 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
991 switch_to_section (get_section (buf
, flags
, NULL
));
992 set_decl_section_name (decl
, buf
);
996 layout_decl (decl
, 0);
997 DECL_SIZE (decl
) = TYPE_SIZE (ctype
);
998 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (ctype
);
1000 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
1001 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
1002 IDENTIFIER_UTF8_REF (name
) = ref
;
1006 /* Like build_class_ref, but instead of a direct reference generate a
1007 pointer into the constant pool. */
1010 build_indirect_class_ref (tree type
)
1014 index
= alloc_class_constant (type
);
1015 cl
= build_ref_from_constant_pool (index
);
1016 return convert (promote_type (class_ptr_type
), cl
);
1020 build_static_class_ref (tree type
)
1022 tree decl_name
, decl
, ref
;
1024 if (TYPE_SIZE (type
) == error_mark_node
)
1025 return null_pointer_node
;
1026 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1027 "", '/', '/', ".class$$");
1028 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1029 if (decl
== NULL_TREE
)
1031 decl
= build_decl (input_location
, VAR_DECL
, decl_name
, class_type_node
);
1032 TREE_STATIC (decl
) = 1;
1033 if (! flag_indirect_classes
)
1035 TREE_PUBLIC (decl
) = 1;
1036 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1037 java_hide_decl (decl
);
1039 DECL_IGNORED_P (decl
) = 1;
1040 DECL_ARTIFICIAL (decl
) = 1;
1041 if (is_compiled_class (type
) == 1)
1042 DECL_EXTERNAL (decl
) = 1;
1043 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1044 DECL_CLASS_FIELD_P (decl
) = 1;
1045 DECL_CONTEXT (decl
) = type
;
1047 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1048 that means not calling pushdecl_top_level. */
1049 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1052 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1057 build_classdollar_field (tree type
)
1059 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1060 "", '/', '/', ".class$");
1061 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1063 if (decl
== NULL_TREE
)
1066 = build_decl (input_location
,
1067 VAR_DECL
, decl_name
,
1068 (build_qualified_type
1070 (build_qualified_type (class_type_node
,
1073 TREE_STATIC (decl
) = 1;
1074 TREE_CONSTANT (decl
) = 1;
1075 TREE_PUBLIC (decl
) = 1;
1076 java_hide_decl (decl
);
1077 DECL_IGNORED_P (decl
) = 1;
1078 DECL_ARTIFICIAL (decl
) = 1;
1079 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1080 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1081 DECL_CLASS_FIELD_P (decl
) = 1;
1082 DECL_CONTEXT (decl
) = type
;
1088 /* Create a local variable that holds the current class$. */
1091 cache_this_class_ref (tree fndecl
)
1095 tree classdollar_field
;
1096 if (flag_indirect_classes
)
1097 classdollar_field
= build_classdollar_field (output_class
);
1099 classdollar_field
= build_static_class_ref (output_class
);
1101 this_classdollar
= build_decl (input_location
,
1102 VAR_DECL
, NULL_TREE
,
1103 TREE_TYPE (classdollar_field
));
1105 java_add_local_var (this_classdollar
);
1106 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1107 this_classdollar
, classdollar_field
));
1110 this_classdollar
= build_classdollar_field (output_class
);
1112 /* Prepend class initialization for static methods reachable from
1114 if (METHOD_STATIC (fndecl
)
1115 && (! METHOD_PRIVATE (fndecl
)
1116 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1117 && ! DECL_CLINIT_P (fndecl
)
1118 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1120 tree init
= build_call_expr (soft_initclass_node
, 1,
1122 java_add_stmt (init
);
1126 /* Remove the reference to the local variable that holds the current
1130 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1132 this_classdollar
= build_classdollar_field (output_class
);
1135 /* Build a reference to the class TYPE.
1136 Also handles primitive types and array types. */
1139 build_class_ref (tree type
)
1141 int is_compiled
= is_compiled_class (type
);
1145 if (TREE_CODE (type
) == POINTER_TYPE
)
1146 type
= TREE_TYPE (type
);
1148 if (flag_indirect_dispatch
1149 && type
!= output_class
1150 && TREE_CODE (type
) == RECORD_TYPE
)
1151 return build_indirect_class_ref (type
);
1153 if (type
== output_class
&& flag_indirect_classes
)
1155 /* This can be NULL if we see a JNI stub before we see any
1157 if (! this_classdollar
)
1158 this_classdollar
= build_classdollar_field (output_class
);
1159 return this_classdollar
;
1162 if (TREE_CODE (type
) == RECORD_TYPE
)
1163 return build_static_class_ref (type
);
1169 decl_name
= TYPE_NAME (type
);
1170 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1171 decl_name
= DECL_NAME (decl_name
);
1172 name
= IDENTIFIER_POINTER (decl_name
);
1173 if (strncmp (name
, "promoted_", 9) == 0)
1175 sprintf (buffer
, "_Jv_%sClass", name
);
1176 decl_name
= get_identifier (buffer
);
1177 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1178 if (decl
== NULL_TREE
)
1180 decl
= build_decl (input_location
,
1181 VAR_DECL
, decl_name
, class_type_node
);
1182 TREE_STATIC (decl
) = 1;
1183 TREE_PUBLIC (decl
) = 1;
1184 DECL_EXTERNAL (decl
) = 1;
1185 DECL_ARTIFICIAL (decl
) = 1;
1186 pushdecl_top_level (decl
);
1190 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1194 return build_indirect_class_ref (type
);
1197 /* Create a local statically allocated variable that will hold a
1198 pointer to a static field. */
1201 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1203 tree decl
, decl_name
;
1204 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1205 char *buf
= (char *) alloca (strlen (name
) + 20);
1206 sprintf (buf
, "%s_%d_ref", name
, index
);
1207 decl_name
= get_identifier (buf
);
1208 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1209 if (decl
== NULL_TREE
)
1211 decl
= build_decl (input_location
,
1212 VAR_DECL
, decl_name
, ptr_type_node
);
1213 TREE_STATIC (decl
) = 1;
1214 TREE_PUBLIC (decl
) = 0;
1215 DECL_EXTERNAL (decl
) = 0;
1216 DECL_ARTIFICIAL (decl
) = 1;
1217 DECL_IGNORED_P (decl
) = 1;
1218 pushdecl_top_level (decl
);
1224 build_static_field_ref (tree fdecl
)
1226 tree fclass
= DECL_CONTEXT (fdecl
);
1227 int is_compiled
= is_compiled_class (fclass
);
1229 /* Allow static final fields to fold to a constant. When using
1230 -findirect-dispatch, we simply never do this folding if compiling
1231 from .class; in the .class file constants will be referred to via
1232 the constant pool. */
1233 if (!flag_indirect_dispatch
1235 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1236 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1237 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1238 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1240 if (is_compiled
== 1)
1241 DECL_EXTERNAL (fdecl
) = 1;
1245 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1246 and a class local static variable CACHE_ENTRY, then
1248 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1249 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1252 This can mostly be optimized away, so that the usual path is a
1253 load followed by a test and branch. _Jv_ResolvePoolEntry is
1254 only called once for each constant pool entry.
1256 There is an optimization that we don't do: at the start of a
1257 method, create a local copy of CACHE_ENTRY and use that instead.
1261 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1262 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1264 = build_call_expr (builtin_decl_implicit (BUILT_IN_EXPECT
), 2,
1265 build2 (EQ_EXPR
, boolean_type_node
,
1266 cache_entry
, null_pointer_node
),
1267 boolean_false_node
);
1268 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1270 = build_call_expr (soft_resolvepoolentry_node
, 2,
1271 build_class_ref (output_class
),
1273 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1274 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1275 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1276 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1282 get_access_flags_from_decl (tree decl
)
1284 int access_flags
= 0;
1285 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1287 if (FIELD_STATIC (decl
))
1288 access_flags
|= ACC_STATIC
;
1289 if (FIELD_PUBLIC (decl
))
1290 access_flags
|= ACC_PUBLIC
;
1291 if (FIELD_PROTECTED (decl
))
1292 access_flags
|= ACC_PROTECTED
;
1293 if (FIELD_PRIVATE (decl
))
1294 access_flags
|= ACC_PRIVATE
;
1295 if (FIELD_FINAL (decl
))
1296 access_flags
|= ACC_FINAL
;
1297 if (FIELD_VOLATILE (decl
))
1298 access_flags
|= ACC_VOLATILE
;
1299 if (FIELD_TRANSIENT (decl
))
1300 access_flags
|= ACC_TRANSIENT
;
1301 if (FIELD_ENUM (decl
))
1302 access_flags
|= ACC_ENUM
;
1303 if (FIELD_SYNTHETIC (decl
))
1304 access_flags
|= ACC_SYNTHETIC
;
1305 return access_flags
;
1307 if (TREE_CODE (decl
) == TYPE_DECL
)
1309 if (CLASS_PUBLIC (decl
))
1310 access_flags
|= ACC_PUBLIC
;
1311 if (CLASS_FINAL (decl
))
1312 access_flags
|= ACC_FINAL
;
1313 if (CLASS_SUPER (decl
))
1314 access_flags
|= ACC_SUPER
;
1315 if (CLASS_INTERFACE (decl
))
1316 access_flags
|= ACC_INTERFACE
;
1317 if (CLASS_ABSTRACT (decl
))
1318 access_flags
|= ACC_ABSTRACT
;
1319 if (CLASS_STATIC (decl
))
1320 access_flags
|= ACC_STATIC
;
1321 if (CLASS_PRIVATE (decl
))
1322 access_flags
|= ACC_PRIVATE
;
1323 if (CLASS_PROTECTED (decl
))
1324 access_flags
|= ACC_PROTECTED
;
1325 if (CLASS_STRICTFP (decl
))
1326 access_flags
|= ACC_STRICT
;
1327 if (CLASS_ENUM (decl
))
1328 access_flags
|= ACC_ENUM
;
1329 if (CLASS_SYNTHETIC (decl
))
1330 access_flags
|= ACC_SYNTHETIC
;
1331 if (CLASS_ANNOTATION (decl
))
1332 access_flags
|= ACC_ANNOTATION
;
1333 return access_flags
;
1335 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1337 if (METHOD_PUBLIC (decl
))
1338 access_flags
|= ACC_PUBLIC
;
1339 if (METHOD_PRIVATE (decl
))
1340 access_flags
|= ACC_PRIVATE
;
1341 if (METHOD_PROTECTED (decl
))
1342 access_flags
|= ACC_PROTECTED
;
1343 if (METHOD_STATIC (decl
))
1344 access_flags
|= ACC_STATIC
;
1345 if (METHOD_FINAL (decl
))
1346 access_flags
|= ACC_FINAL
;
1347 if (METHOD_SYNCHRONIZED (decl
))
1348 access_flags
|= ACC_SYNCHRONIZED
;
1349 if (METHOD_NATIVE (decl
))
1350 access_flags
|= ACC_NATIVE
;
1351 if (METHOD_ABSTRACT (decl
))
1352 access_flags
|= ACC_ABSTRACT
;
1353 if (METHOD_STRICTFP (decl
))
1354 access_flags
|= ACC_STRICT
;
1355 if (METHOD_INVISIBLE (decl
))
1356 access_flags
|= ACC_INVISIBLE
;
1357 if (DECL_ARTIFICIAL (decl
))
1358 access_flags
|= ACC_SYNTHETIC
;
1359 if (METHOD_BRIDGE (decl
))
1360 access_flags
|= ACC_BRIDGE
;
1361 if (METHOD_VARARGS (decl
))
1362 access_flags
|= ACC_VARARGS
;
1363 return access_flags
;
1368 static GTY (()) int alias_labelno
= 0;
1370 /* Create a private alias for METHOD. Using this alias instead of the method
1371 decl ensures that ncode entries in the method table point to the real function
1372 at runtime, not a PLT entry. */
1375 make_local_function_alias (tree method
)
1377 #ifdef ASM_OUTPUT_DEF
1380 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1381 char *name
= (char *) alloca (strlen (method_name
) + 2);
1382 char *buf
= (char *) alloca (strlen (method_name
) + 128);
1384 /* Only create aliases for local functions. */
1385 if (DECL_EXTERNAL (method
))
1388 /* Prefix method_name with 'L' for the alias label. */
1390 strcpy (name
+ 1, method_name
);
1392 targetm
.asm_out
.generate_internal_label (buf
, name
, alias_labelno
++);
1393 alias
= build_decl (input_location
,
1394 FUNCTION_DECL
, get_identifier (buf
),
1395 TREE_TYPE (method
));
1396 DECL_CONTEXT (alias
) = NULL
;
1397 TREE_READONLY (alias
) = TREE_READONLY (method
);
1398 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1399 TREE_PUBLIC (alias
) = 0;
1400 DECL_EXTERNAL (alias
) = 0;
1401 DECL_ARTIFICIAL (alias
) = 1;
1402 DECL_INITIAL (alias
) = error_mark_node
;
1403 TREE_ADDRESSABLE (alias
) = 1;
1404 TREE_USED (alias
) = 1;
1405 if (!flag_syntax_only
)
1406 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1413 /** Make reflection data (_Jv_Field) for field FDECL. */
1416 make_field_value (tree fdecl
)
1420 tree type
= TREE_TYPE (fdecl
);
1421 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1422 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1424 START_RECORD_CONSTRUCTOR (v
, field_type_node
);
1425 PUSH_FIELD_VALUE (v
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1427 type
= build_class_ref (type
);
1430 tree signature
= build_java_signature (type
);
1432 type
= build_utf8_ref (unmangle_classname
1433 (IDENTIFIER_POINTER (signature
),
1434 IDENTIFIER_LENGTH (signature
)));
1436 PUSH_FIELD_VALUE (v
, "type", type
);
1438 flags
= get_access_flags_from_decl (fdecl
);
1440 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1442 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, flags
));
1443 PUSH_FIELD_VALUE (v
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1446 tree field_address
= integer_zero_node
;
1448 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1449 && FIELD_STATIC (fdecl
))
1450 field_address
= build_address_of (fdecl
);
1452 index
= (FIELD_STATIC (fdecl
)
1453 ? DECL_CHAIN (TYPE_FIELDS (field_info_union_node
))
1454 : TYPE_FIELDS (field_info_union_node
));
1455 value
= (FIELD_STATIC (fdecl
)
1457 : byte_position (fdecl
));
1461 build_constructor_single (field_info_union_node
, index
, value
));
1464 FINISH_RECORD_CONSTRUCTOR (finit
, v
, field_type_node
);
1468 /** Make reflection data (_Jv_Method) for method MDECL. */
1471 make_method_value (tree mdecl
)
1473 static int method_name_count
= 0;
1478 #define ACC_TRANSLATED 0x4000
1479 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1480 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1482 class_decl
= DECL_CONTEXT (mdecl
);
1483 /* For interfaces, the index field contains the dispatch index. */
1484 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1485 index
= build_int_cst (NULL_TREE
,
1486 get_interface_method_index (mdecl
, class_decl
));
1487 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1488 index
= get_method_index (mdecl
);
1490 index
= integer_minus_one_node
;
1492 code
= null_pointer_node
;
1493 if (METHOD_ABSTRACT (mdecl
))
1494 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1495 soft_abstractmethod_node
);
1497 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1498 make_local_function_alias (mdecl
));
1499 START_RECORD_CONSTRUCTOR (v
, method_type_node
);
1500 PUSH_FIELD_VALUE (v
, "name",
1501 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1502 init_identifier_node
1503 : DECL_NAME (mdecl
)));
1505 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1506 PUSH_FIELD_VALUE (v
, "signature",
1509 (IDENTIFIER_POINTER(signature
),
1510 IDENTIFIER_LENGTH(signature
)))));
1512 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1513 PUSH_FIELD_VALUE (v
, "index", index
);
1514 PUSH_FIELD_VALUE (v
, "ncode", code
);
1517 /* Compute the `throws' information for the method. */
1518 tree table
= null_pointer_node
;
1520 if (!vec_safe_is_empty (DECL_FUNCTION_THROWS (mdecl
)))
1522 int length
= 1 + DECL_FUNCTION_THROWS (mdecl
)->length ();
1523 tree t
, type
, array
;
1525 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1526 int idx
= length
- 1;
1530 vec_alloc (v
, length
);
1531 v
->quick_grow_cleared (length
);
1534 e
->value
= null_pointer_node
;
1536 FOR_EACH_VEC_SAFE_ELT (DECL_FUNCTION_THROWS (mdecl
), ix
, t
)
1538 tree sig
= DECL_NAME (TYPE_NAME (t
));
1540 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1541 IDENTIFIER_LENGTH (sig
)));
1545 gcc_assert (idx
== -1);
1546 type
= build_prim_array_type (ptr_type_node
, length
);
1547 table
= build_constructor (type
, v
);
1548 /* Compute something unique enough. */
1549 sprintf (buf
, "_methods%d", method_name_count
++);
1550 array
= build_decl (input_location
,
1551 VAR_DECL
, get_identifier (buf
), type
);
1552 DECL_INITIAL (array
) = table
;
1553 TREE_STATIC (array
) = 1;
1554 DECL_ARTIFICIAL (array
) = 1;
1555 DECL_IGNORED_P (array
) = 1;
1556 rest_of_decl_compilation (array
, 1, 0);
1558 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1561 PUSH_FIELD_VALUE (v
, "throws", table
);
1564 FINISH_RECORD_CONSTRUCTOR (minit
, v
, method_type_node
);
1569 get_dispatch_vector (tree type
)
1571 tree vtable
= TYPE_VTABLE (type
);
1573 if (vtable
== NULL_TREE
)
1577 tree super
= CLASSTYPE_SUPER (type
);
1578 HOST_WIDE_INT nvirtuals
= tree_to_shwi (TYPE_NVIRTUALS (type
));
1579 vtable
= make_tree_vec (nvirtuals
);
1580 TYPE_VTABLE (type
) = vtable
;
1581 if (super
!= NULL_TREE
)
1583 tree super_vtable
= get_dispatch_vector (super
);
1585 for (i
= tree_to_shwi (TYPE_NVIRTUALS (super
)); --i
>= 0; )
1586 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1589 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1590 method
= DECL_CHAIN (method
))
1592 tree method_index
= get_method_index (method
);
1593 if (method_index
!= NULL_TREE
1594 && tree_fits_shwi_p (method_index
))
1595 TREE_VEC_ELT (vtable
, tree_to_shwi (method_index
)) = method
;
1603 get_dispatch_table (tree type
, tree this_class_addr
)
1605 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1606 tree vtable
= get_dispatch_vector (type
);
1608 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1611 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1615 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1616 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1617 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1620 vec_safe_grow_cleared (v
, arraysize
);
1621 e
= &(*v
)[arraysize
- 1];
1623 #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
1624 for (i
= nvirtuals
; --i
>= 0; )
1626 tree method
= TREE_VEC_ELT (vtable
, i
);
1627 if (METHOD_ABSTRACT (method
))
1630 warning_at (DECL_SOURCE_LOCATION (method
), 0,
1631 "abstract method in non-abstract class");
1633 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1634 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1635 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1637 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1641 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1642 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1644 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1645 method
, build_int_cst (NULL_TREE
, j
));
1646 TREE_CONSTANT (fdesc
) = 1;
1647 CONSTRUCTOR_PREPEND_VALUE (e
, fdesc
);
1650 CONSTRUCTOR_PREPEND_VALUE (e
,
1652 nativecode_ptr_type_node
,
1657 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1658 using the Boehm GC we sometimes stash a GC type descriptor
1659 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1660 the emitted byte count during the output to the assembly file. */
1661 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1662 fake "function descriptor". It's first word is the is the class
1663 pointer, and subsequent words (usually one) contain the GC descriptor.
1664 In all other cases, we reserve two extra vtable slots. */
1665 gc_descr
= get_boehm_type_descriptor (type
);
1666 CONSTRUCTOR_PREPEND_VALUE (e
, gc_descr
);
1667 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1668 CONSTRUCTOR_PREPEND_VALUE (e
, gc_descr
);
1669 CONSTRUCTOR_PREPEND_VALUE (e
, this_class_addr
);
1671 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1672 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1673 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1674 gcc_assert (e
== v
->address ());
1675 e
->index
= integer_zero_node
;
1676 e
->value
= null_pointer_node
;
1677 #undef CONSTRUCTOR_PREPEND_VALUE
1679 arraytype
= build_prim_array_type (nativecode_ptr_type_node
, arraysize
);
1680 return build_constructor (arraytype
, v
);
1684 /* Set the method_index for a method decl. */
1686 set_method_index (tree decl
, tree method_index
)
1688 if (method_index
!= NULL_TREE
)
1690 /* method_index is null if we're using indirect dispatch. */
1691 method_index
= fold (convert (sizetype
, method_index
));
1693 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1694 /* Add one to skip bogus descriptor for class and GC descriptor. */
1695 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1697 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1699 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1702 DECL_VINDEX (decl
) = method_index
;
1705 /* Get the method_index for a method decl. */
1707 get_method_index (tree decl
)
1709 tree method_index
= DECL_VINDEX (decl
);
1714 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1715 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1716 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1718 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1719 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1721 return method_index
;
1725 supers_all_compiled (tree type
)
1727 while (type
!= NULL_TREE
)
1729 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1731 type
= CLASSTYPE_SUPER (type
);
1737 add_table_and_syms (vec
<constructor_elt
, va_gc
> **v
,
1738 vec
<method_entry
, va_gc
> *methods
,
1739 const char *table_name
, tree table_slot
, tree table_type
,
1740 const char *syms_name
, tree syms_slot
)
1742 if (methods
== NULL
)
1744 PUSH_FIELD_VALUE (*v
, table_name
, null_pointer_node
);
1745 PUSH_FIELD_VALUE (*v
, syms_name
, null_pointer_node
);
1749 pushdecl_top_level (syms_slot
);
1750 PUSH_FIELD_VALUE (*v
, table_name
,
1751 build1 (ADDR_EXPR
, table_type
, table_slot
));
1752 PUSH_FIELD_VALUE (*v
, syms_name
,
1753 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1755 TREE_CONSTANT (table_slot
) = 1;
1760 make_class_data (tree type
)
1762 tree decl
, cons
, temp
;
1763 tree field
, fields_decl
;
1764 HOST_WIDE_INT static_field_count
= 0;
1765 HOST_WIDE_INT instance_field_count
= 0;
1766 HOST_WIDE_INT field_count
;
1767 tree field_array_type
;
1769 tree dtable_decl
= NULL_TREE
;
1770 HOST_WIDE_INT method_count
= 0;
1771 tree method_array_type
;
1774 tree this_class_addr
;
1775 tree constant_pool_constructor
;
1776 tree interfaces
= null_pointer_node
;
1777 int interface_len
= 0;
1778 int uses_jv_markobj
= 0;
1779 tree type_decl
= TYPE_NAME (type
);
1780 tree id_main
= get_identifier("main");
1781 tree id_class
= get_identifier("java.lang.Class");
1782 /** Offset from start of virtual function table declaration
1783 to where objects actually point at, following new g++ ABI. */
1784 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1785 vec
<int> field_indexes
;
1786 tree first_real_field
;
1787 vec
<constructor_elt
, va_gc
> *v1
= NULL
, *v2
= NULL
;
1788 tree reflection_data
;
1789 vec
<constructor_elt
, va_gc
> *static_fields
= NULL
;
1790 vec
<constructor_elt
, va_gc
> *instance_fields
= NULL
;
1791 vec
<constructor_elt
, va_gc
> *methods
= NULL
;
1793 this_class_addr
= build_static_class_ref (type
);
1794 decl
= TREE_OPERAND (this_class_addr
, 0);
1796 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1797 && !flag_indirect_dispatch
)
1799 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1800 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1801 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1803 /* We've already created some other class, and consequently
1804 we made class_dtable_decl. Now we just want to fill it
1806 dtable_decl
= class_dtable_decl
;
1810 dtable_decl
= build_dtable_decl (type
);
1811 TREE_STATIC (dtable_decl
) = 1;
1812 DECL_ARTIFICIAL (dtable_decl
) = 1;
1813 DECL_IGNORED_P (dtable_decl
) = 1;
1816 TREE_PUBLIC (dtable_decl
) = 1;
1817 DECL_INITIAL (dtable_decl
) = dtable
;
1818 /* The only dispatch table exported from a DSO is the dispatch
1819 table for java.lang.Class. */
1820 if (DECL_NAME (type_decl
) != id_class
)
1821 java_hide_decl (dtable_decl
);
1822 if (! flag_indirect_classes
)
1823 rest_of_decl_compilation (dtable_decl
, 1, 0);
1824 /* Maybe we're compiling Class as the first class. If so, set
1825 class_dtable_decl to the decl we just made. */
1826 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1827 class_dtable_decl
= dtable_decl
;
1830 /* Build Field array. */
1831 field
= TYPE_FIELDS (type
);
1832 while (field
&& DECL_ARTIFICIAL (field
))
1833 field
= DECL_CHAIN (field
); /* Skip dummy fields. */
1834 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1835 field
= DECL_CHAIN (field
); /* Skip dummy field for inherited data. */
1836 first_real_field
= field
;
1838 /* First count static and instance fields. */
1839 for ( ; field
!= NULL_TREE
; field
= DECL_CHAIN (field
))
1841 if (! DECL_ARTIFICIAL (field
))
1843 if (FIELD_STATIC (field
))
1844 static_field_count
++;
1845 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1846 instance_field_count
++;
1849 field_count
= static_field_count
+ instance_field_count
;
1850 field_indexes
.create (field_count
);
1852 /* gcj sorts fields so that static fields come first, followed by
1853 instance fields. Unfortunately, by the time this takes place we
1854 have already generated the reflection_data for this class, and
1855 that data contains indexes into the fields. So, we generate a
1856 permutation that maps each original field index to its final
1857 position. Then we pass this permutation to
1858 rewrite_reflection_indexes(), which fixes up the reflection
1862 int static_count
= 0;
1863 int instance_count
= static_field_count
;
1866 for (i
= 0, field
= first_real_field
;
1868 field
= DECL_CHAIN (field
), i
++)
1870 if (! DECL_ARTIFICIAL (field
))
1873 if (FIELD_STATIC (field
))
1874 field_index
= static_count
++;
1875 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1876 field_index
= instance_count
++;
1879 field_indexes
.quick_push (field_index
);
1884 for (field
= first_real_field
; field
!= NULL_TREE
;
1885 field
= DECL_CHAIN (field
))
1887 if (! DECL_ARTIFICIAL (field
))
1889 if (FIELD_STATIC (field
))
1891 /* We must always create reflection data for static fields
1892 as it is used in the creation of the field itself. */
1893 tree init
= make_field_value (field
);
1894 tree initial
= DECL_INITIAL (field
);
1895 CONSTRUCTOR_APPEND_ELT (static_fields
, NULL_TREE
, init
);
1896 /* If the initial value is a string constant,
1897 prevent output_constant from trying to assemble the value. */
1898 if (initial
!= NULL_TREE
1899 && TREE_TYPE (initial
) == string_ptr_type_node
)
1900 DECL_INITIAL (field
) = NULL_TREE
;
1901 rest_of_decl_compilation (field
, 1, 1);
1902 DECL_INITIAL (field
) = initial
;
1904 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1906 tree init
= make_field_value (field
);
1907 CONSTRUCTOR_APPEND_ELT (instance_fields
, NULL_TREE
, init
);
1912 gcc_assert (static_field_count
== (int) vec_safe_length (static_fields
));
1913 gcc_assert (instance_field_count
== (int) vec_safe_length (instance_fields
));
1915 if (field_count
> 0)
1917 vec_safe_splice (static_fields
, instance_fields
);
1918 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1919 fields_decl
= build_decl (input_location
,
1920 VAR_DECL
, mangled_classname ("_FL_", type
),
1922 DECL_INITIAL (fields_decl
)
1923 = build_constructor (field_array_type
, static_fields
);
1924 TREE_STATIC (fields_decl
) = 1;
1925 DECL_ARTIFICIAL (fields_decl
) = 1;
1926 DECL_IGNORED_P (fields_decl
) = 1;
1927 rest_of_decl_compilation (fields_decl
, 1, 0);
1930 fields_decl
= NULL_TREE
;
1932 /* Build Method array. */
1933 for (method
= TYPE_METHODS (type
);
1934 method
!= NULL_TREE
; method
= DECL_CHAIN (method
))
1937 if (METHOD_PRIVATE (method
)
1938 && ! flag_keep_inline_functions
1941 /* Even if we have a decl, we don't necessarily have the code.
1942 This can happen if we inherit a method from a superclass for
1943 which we don't have a .class file. */
1944 if (METHOD_DUMMY (method
))
1947 /* Generate method reflection data if:
1949 - !flag_reduced_reflection.
1951 - <clinit> -- The runtime uses reflection to initialize the
1954 - Any method in class java.lang.Class -- Class.forName() and
1955 perhaps other things require it.
1957 - class$ -- It does not work if reflection data missing.
1959 - main -- Reflection is used to find main(String[]) methods.
1961 - public not static -- It is potentially part of an
1962 interface. The runtime uses reflection data to build
1963 interface dispatch tables. */
1964 if (!flag_reduced_reflection
1965 || DECL_CLINIT_P (method
)
1966 || DECL_NAME (type_decl
) == id_class
1967 || DECL_NAME (method
) == id_main
1968 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1970 init
= make_method_value (method
);
1972 CONSTRUCTOR_APPEND_ELT (methods
, NULL_TREE
, init
);
1975 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1976 methods_decl
= build_decl (input_location
,
1977 VAR_DECL
, mangled_classname ("_MT_", type
),
1979 DECL_INITIAL (methods_decl
) = build_constructor (method_array_type
, methods
);
1980 TREE_STATIC (methods_decl
) = 1;
1981 DECL_ARTIFICIAL (methods_decl
) = 1;
1982 DECL_IGNORED_P (methods_decl
) = 1;
1983 rest_of_decl_compilation (methods_decl
, 1, 0);
1985 if (class_dtable_decl
== NULL_TREE
)
1987 class_dtable_decl
= build_dtable_decl (class_type_node
);
1988 TREE_STATIC (class_dtable_decl
) = 1;
1989 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1990 DECL_IGNORED_P (class_dtable_decl
) = 1;
1991 if (is_compiled_class (class_type_node
) != 2)
1993 DECL_EXTERNAL (class_dtable_decl
) = 1;
1994 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1998 super
= CLASSTYPE_SUPER (type
);
1999 if (super
== NULL_TREE
)
2000 super
= null_pointer_node
;
2001 else if (! flag_indirect_dispatch
2002 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
2003 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
2004 super
= build_class_ref (super
);
2007 int super_index
= alloc_class_constant (super
);
2008 super
= build_int_cst (ptr_type_node
, super_index
);
2011 /* Build and emit the array of implemented interfaces. */
2012 if (type
!= object_type_node
)
2013 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
2015 if (interface_len
> 0)
2018 tree interface_array_type
, idecl
;
2019 vec
<constructor_elt
, va_gc
> *init
;
2020 vec_alloc (init
, interface_len
);
2021 interface_array_type
2022 = build_prim_array_type (class_ptr_type
, interface_len
);
2023 idecl
= build_decl (input_location
,
2024 VAR_DECL
, mangled_classname ("_IF_", type
),
2025 interface_array_type
);
2027 for (i
= 1; i
<= interface_len
; i
++)
2029 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
2030 tree iclass
= BINFO_TYPE (child
);
2032 if (! flag_indirect_dispatch
2034 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
2035 index
= build_class_ref (iclass
);
2038 int int_index
= alloc_class_constant (iclass
);
2039 index
= build_int_cst (ptr_type_node
, int_index
);
2041 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, index
);
2043 DECL_INITIAL (idecl
) = build_constructor (interface_array_type
, init
);
2044 TREE_STATIC (idecl
) = 1;
2045 DECL_ARTIFICIAL (idecl
) = 1;
2046 DECL_IGNORED_P (idecl
) = 1;
2047 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
2048 rest_of_decl_compilation (idecl
, 1, 0);
2051 constant_pool_constructor
= build_constants_constructor ();
2053 if (flag_indirect_dispatch
)
2055 TYPE_OTABLE_DECL (type
)
2057 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
2058 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
2059 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
2061 TYPE_ATABLE_DECL (type
)
2063 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
2064 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
2065 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2067 TYPE_ITABLE_DECL (type
)
2069 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2070 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2071 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2074 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2076 START_RECORD_CONSTRUCTOR (v1
, object_type_node
);
2077 PUSH_FIELD_VALUE (v1
, "vtable",
2078 (flag_indirect_classes
2080 : fold_build_pointer_plus
2081 (build1 (ADDR_EXPR
, dtable_ptr_type
,
2083 dtable_start_offset
)));
2084 if (! flag_hash_synchronization
)
2085 PUSH_FIELD_VALUE (v1
, "sync_info", null_pointer_node
);
2086 FINISH_RECORD_CONSTRUCTOR (temp
, v1
, object_type_node
);
2087 START_RECORD_CONSTRUCTOR (v2
, class_type_node
);
2088 PUSH_SUPER_VALUE (v2
, temp
);
2089 PUSH_FIELD_VALUE (v2
, "next_or_version", gcj_abi_version
);
2090 PUSH_FIELD_VALUE (v2
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2091 PUSH_FIELD_VALUE (v2
, "accflags",
2092 build_int_cst (NULL_TREE
,
2093 get_access_flags_from_decl (type_decl
)));
2095 PUSH_FIELD_VALUE (v2
, "superclass",
2096 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2097 PUSH_FIELD_VALUE (v2
, "constants", constant_pool_constructor
);
2098 PUSH_FIELD_VALUE (v2
, "methods",
2099 methods_decl
== NULL_TREE
? null_pointer_node
2100 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2101 PUSH_FIELD_VALUE (v2
, "method_count",
2102 build_int_cst (NULL_TREE
, method_count
));
2104 PUSH_FIELD_VALUE (v2
, "vtable_method_count",
2105 (flag_indirect_dispatch
2106 ? integer_minus_one_node
2107 : TYPE_NVIRTUALS (type
)));
2109 PUSH_FIELD_VALUE (v2
, "fields",
2110 fields_decl
== NULL_TREE
? null_pointer_node
2111 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2112 /* If we're using the binary compatibility ABI we don't know the
2113 size until load time. */
2114 PUSH_FIELD_VALUE (v2
, "size_in_bytes",
2115 (flag_indirect_dispatch
2116 ? integer_minus_one_node
2117 : size_in_bytes (type
)));
2118 PUSH_FIELD_VALUE (v2
, "field_count",
2119 build_int_cst (NULL_TREE
, field_count
));
2120 PUSH_FIELD_VALUE (v2
, "static_field_count",
2121 build_int_cst (NULL_TREE
, static_field_count
));
2123 PUSH_FIELD_VALUE (v2
, "vtable",
2124 (flag_indirect_dispatch
|| dtable_decl
== NULL_TREE
2126 : fold_build_pointer_plus
2127 (build1 (ADDR_EXPR
, dtable_ptr_type
,
2129 dtable_start_offset
)));
2130 add_table_and_syms (&v2
, TYPE_OTABLE_METHODS (type
),
2131 "otable", TYPE_OTABLE_DECL (type
), otable_ptr_type
,
2132 "otable_syms", TYPE_OTABLE_SYMS_DECL (type
));
2133 add_table_and_syms (&v2
, TYPE_ATABLE_METHODS (type
),
2134 "atable", TYPE_ATABLE_DECL (type
), atable_ptr_type
,
2135 "atable_syms", TYPE_ATABLE_SYMS_DECL (type
));
2136 add_table_and_syms (&v2
, TYPE_ITABLE_METHODS (type
),
2137 "itable", TYPE_ITABLE_DECL (type
), itable_ptr_type
,
2138 "itable_syms", TYPE_ITABLE_SYMS_DECL (type
));
2140 PUSH_FIELD_VALUE (v2
, "catch_classes",
2141 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2142 PUSH_FIELD_VALUE (v2
, "interfaces", interfaces
);
2143 PUSH_FIELD_VALUE (v2
, "loader", null_pointer_node
);
2144 PUSH_FIELD_VALUE (v2
, "interface_count",
2145 build_int_cst (NULL_TREE
, interface_len
));
2146 PUSH_FIELD_VALUE (v2
, "state",
2147 convert (byte_type_node
,
2148 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2150 PUSH_FIELD_VALUE (v2
, "thread", null_pointer_node
);
2151 PUSH_FIELD_VALUE (v2
, "depth", integer_zero_node
);
2152 PUSH_FIELD_VALUE (v2
, "ancestors", null_pointer_node
);
2153 PUSH_FIELD_VALUE (v2
, "idt", null_pointer_node
);
2154 PUSH_FIELD_VALUE (v2
, "arrayclass", null_pointer_node
);
2155 PUSH_FIELD_VALUE (v2
, "protectionDomain", null_pointer_node
);
2158 tree assertion_table_ref
;
2159 if (TYPE_ASSERTIONS (type
) == NULL
)
2160 assertion_table_ref
= null_pointer_node
;
2162 assertion_table_ref
= build1 (ADDR_EXPR
,
2163 build_pointer_type (assertion_table_type
),
2164 emit_assertion_table (type
));
2166 PUSH_FIELD_VALUE (v2
, "assertion_table", assertion_table_ref
);
2169 PUSH_FIELD_VALUE (v2
, "hack_signers", null_pointer_node
);
2170 PUSH_FIELD_VALUE (v2
, "chain", null_pointer_node
);
2171 PUSH_FIELD_VALUE (v2
, "aux_info", null_pointer_node
);
2172 PUSH_FIELD_VALUE (v2
, "engine", null_pointer_node
);
2174 if (TYPE_REFLECTION_DATA (current_class
))
2177 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2178 vec
<constructor_elt
, va_gc
> *v
;
2179 vec_alloc (v
, count
);
2180 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2181 tree max_index
= build_int_cst (sizetype
, count
);
2182 tree index
= build_index_type (max_index
);
2183 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2186 static int reflection_data_count
;
2188 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2189 array
= build_decl (input_location
,
2190 VAR_DECL
, get_identifier (buf
), type
);
2192 rewrite_reflection_indexes (&field_indexes
);
2194 for (i
= 0; i
< count
; i
++)
2196 constructor_elt elt
;
2197 elt
.index
= build_int_cst (sizetype
, i
);
2198 elt
.value
= build_int_cstu (byte_type_node
, data
[i
]);
2199 v
->quick_push (elt
);
2202 DECL_INITIAL (array
) = build_constructor (type
, v
);
2203 TREE_STATIC (array
) = 1;
2204 DECL_ARTIFICIAL (array
) = 1;
2205 DECL_IGNORED_P (array
) = 1;
2206 TREE_READONLY (array
) = 1;
2207 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2208 rest_of_decl_compilation (array
, 1, 0);
2210 reflection_data
= build_address_of (array
);
2213 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2216 reflection_data
= null_pointer_node
;
2218 PUSH_FIELD_VALUE (v2
, "reflection_data", reflection_data
);
2219 FINISH_RECORD_CONSTRUCTOR (cons
, v2
, class_type_node
);
2221 DECL_INITIAL (decl
) = cons
;
2223 /* Hash synchronization requires at least 64-bit alignment. */
2224 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2225 DECL_ALIGN (decl
) = 64;
2227 if (flag_indirect_classes
)
2229 TREE_READONLY (decl
) = 1;
2230 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2233 rest_of_decl_compilation (decl
, 1, 0);
2236 tree classdollar_field
= build_classdollar_field (type
);
2237 if (!flag_indirect_classes
)
2238 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2239 rest_of_decl_compilation (classdollar_field
, 1, 0);
2242 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2243 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2244 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2250 java_expand_catch_classes (current_class
);
2252 current_function_decl
= NULL_TREE
;
2253 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2254 make_class_data (current_class
);
2256 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2259 /* Return 2 if KLASS is compiled by this compilation job;
2260 return 1 if KLASS can otherwise be assumed to be compiled;
2261 return 0 if we cannot assume that KLASS is compiled.
2262 Returns 1 for primitive and 0 for array types. */
2264 is_compiled_class (tree klass
)
2267 if (TREE_CODE (klass
) == POINTER_TYPE
)
2268 klass
= TREE_TYPE (klass
);
2269 if (TREE_CODE (klass
) != RECORD_TYPE
) /* Primitive types are static. */
2271 if (TYPE_ARRAY_P (klass
))
2274 seen_in_zip
= (TYPE_JCF (klass
) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass
)));
2275 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2277 /* The class was seen in the current ZIP file and will be
2278 available as a compiled class in the future but may not have
2279 been loaded already. Load it if necessary. This prevent
2280 build_class_ref () from crashing. */
2282 if (seen_in_zip
&& !CLASS_LOADED_P (klass
) && (klass
!= current_class
))
2283 load_class (klass
, 1);
2285 /* We return 2 for class seen in ZIP and class from files
2286 belonging to the same compilation unit */
2290 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass
)))))
2292 if (!CLASS_LOADED_P (klass
))
2294 if (klass
!= current_class
)
2295 load_class (klass
, 1);
2303 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2306 build_dtable_decl (tree type
)
2310 /* We need to build a new dtable type so that its size is uniquely
2311 computed when we're dealing with the class for real and not just
2312 faking it (like java.lang.Class during the initialization of the
2313 compiler.) We know we're not faking a class when CURRENT_CLASS is
2315 if (current_class
== type
)
2317 tree dummy
= NULL_TREE
;
2320 dtype
= make_node (RECORD_TYPE
);
2322 PUSH_FIELD (input_location
, dtype
, dummy
, "top_offset", ptr_type_node
);
2323 PUSH_FIELD (input_location
, dtype
, dummy
, "type_info", ptr_type_node
);
2325 PUSH_FIELD (input_location
, dtype
, dummy
, "class", class_ptr_type
);
2326 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2328 tree tmp_field
= build_decl (input_location
,
2329 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2330 TREE_CHAIN (dummy
) = tmp_field
;
2331 DECL_CONTEXT (tmp_field
) = dtype
;
2332 DECL_ARTIFICIAL (tmp_field
) = 1;
2336 PUSH_FIELD (input_location
, dtype
, dummy
, "gc_descr", ptr_type_node
);
2337 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2339 tree tmp_field
= build_decl (input_location
,
2340 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2341 TREE_CHAIN (dummy
) = tmp_field
;
2342 DECL_CONTEXT (tmp_field
) = dtype
;
2343 DECL_ARTIFICIAL (tmp_field
) = 1;
2347 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2348 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2349 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2351 PUSH_FIELD (input_location
, dtype
, dummy
, "methods",
2352 build_prim_array_type (nativecode_ptr_type_node
, n
));
2353 layout_type (dtype
);
2356 dtype
= dtable_type
;
2358 decl
= build_decl (input_location
,
2359 VAR_DECL
, get_identifier ("vt$"), dtype
);
2360 DECL_CONTEXT (decl
) = type
;
2361 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2362 DECL_VTABLE_P (decl
) = 1;
2367 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2368 fields inherited from SUPER_CLASS. */
2371 push_super_field (tree this_class
, tree super_class
)
2374 /* Don't insert the field if we're just re-laying the class out. */
2375 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2377 base_decl
= build_decl (input_location
,
2378 FIELD_DECL
, NULL_TREE
, super_class
);
2379 DECL_IGNORED_P (base_decl
) = 1;
2380 DECL_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2381 TYPE_FIELDS (this_class
) = base_decl
;
2382 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2383 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2386 /* Handle the different manners we may have to lay out a super class. */
2389 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2393 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2395 if (!CLASS_LOADED_P (super_class
))
2396 load_class (super_class
, 1);
2398 /* We might have to layout the class before its dependency on
2399 the super class gets resolved by java_complete_class */
2400 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2402 if (TREE_TYPE (super_class
) != NULL_TREE
)
2403 super_class
= TREE_TYPE (super_class
);
2407 if (!TYPE_SIZE (super_class
))
2408 safe_layout_class (super_class
);
2413 /* safe_layout_class just makes sure that we can load a class without
2414 disrupting the current_class, input_location, etc, information
2415 about the class processed currently. */
2418 safe_layout_class (tree klass
)
2420 tree save_current_class
= current_class
;
2421 location_t save_location
= input_location
;
2423 layout_class (klass
);
2425 current_class
= save_current_class
;
2426 input_location
= save_location
;
2430 layout_class (tree this_class
)
2433 tree super_class
= CLASSTYPE_SUPER (this_class
);
2435 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2436 if (CLASS_BEING_LAIDOUT (this_class
))
2442 sprintf (buffer
, " with '%s'",
2443 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2444 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2446 for (current
= TREE_CHAIN (class_list
); current
;
2447 current
= TREE_CHAIN (current
))
2449 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2450 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2451 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2452 DECL_SOURCE_FILE (decl
),
2453 DECL_SOURCE_LINE (decl
));
2454 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2456 obstack_1grow (&temporary_obstack
, '\0');
2457 report
= XOBFINISH (&temporary_obstack
, char *);
2458 cyclic_inheritance_report
= ggc_strdup (report
);
2459 obstack_free (&temporary_obstack
, report
);
2460 TYPE_SIZE (this_class
) = error_mark_node
;
2463 CLASS_BEING_LAIDOUT (this_class
) = 1;
2465 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2467 tree maybe_super_class
2468 = maybe_layout_super_class (super_class
, this_class
);
2469 if (maybe_super_class
== NULL
2470 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2472 TYPE_SIZE (this_class
) = error_mark_node
;
2473 CLASS_BEING_LAIDOUT (this_class
) = 0;
2474 class_list
= TREE_CHAIN (class_list
);
2477 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2478 push_super_field (this_class
, maybe_super_class
);
2481 layout_type (this_class
);
2483 /* Also recursively load/layout any superinterfaces. */
2484 if (TYPE_BINFO (this_class
))
2486 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2488 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2489 tree super_interface
= BINFO_TYPE (binfo
);
2490 tree maybe_super_interface
2491 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2492 if (maybe_super_interface
== NULL
2493 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2495 TYPE_SIZE (this_class
) = error_mark_node
;
2496 CLASS_BEING_LAIDOUT (this_class
) = 0;
2497 class_list
= TREE_CHAIN (class_list
);
2503 /* Convert the size back to an SI integer value. */
2504 TYPE_SIZE_UNIT (this_class
) =
2505 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2507 CLASS_BEING_LAIDOUT (this_class
) = 0;
2508 class_list
= TREE_CHAIN (class_list
);
2512 add_miranda_methods (tree base_class
, tree search_class
)
2515 tree binfo
, base_binfo
;
2517 if (!CLASS_PARSED_P (search_class
))
2518 load_class (search_class
, 1);
2520 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2521 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2524 tree elt
= BINFO_TYPE (base_binfo
);
2526 /* FIXME: This is totally bogus. We should not be handling
2527 Miranda methods at all if we're using the BC ABI. */
2528 if (TYPE_DUMMY (elt
))
2531 /* Ensure that interface methods are seen in declared order. */
2532 if (!CLASS_LOADED_P (elt
))
2533 load_class (elt
, 1);
2534 layout_class_methods (elt
);
2536 /* All base classes will have been laid out at this point, so the order
2537 will be correct. This code must match similar layout code in the
2539 for (method_decl
= TYPE_METHODS (elt
);
2540 method_decl
; method_decl
= DECL_CHAIN (method_decl
))
2544 /* An interface can have <clinit>. */
2545 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2548 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2549 override
= lookup_argument_method (base_class
,
2550 DECL_NAME (method_decl
), sig
);
2551 if (override
== NULL_TREE
)
2553 /* Found a Miranda method. Add it. */
2555 sig
= build_java_signature (TREE_TYPE (method_decl
));
2557 = add_method (base_class
,
2558 get_access_flags_from_decl (method_decl
),
2559 DECL_NAME (method_decl
), sig
);
2560 METHOD_INVISIBLE (new_method
) = 1;
2564 /* Try superinterfaces. */
2565 add_miranda_methods (base_class
, elt
);
2570 layout_class_methods (tree this_class
)
2572 tree method_decl
, dtable_count
;
2573 tree super_class
, type_name
;
2575 if (TYPE_NVIRTUALS (this_class
))
2578 super_class
= CLASSTYPE_SUPER (this_class
);
2582 super_class
= maybe_layout_super_class (super_class
, this_class
);
2583 if (!TYPE_NVIRTUALS (super_class
))
2584 layout_class_methods (super_class
);
2585 dtable_count
= TYPE_NVIRTUALS (super_class
);
2588 dtable_count
= integer_zero_node
;
2590 type_name
= TYPE_NAME (this_class
);
2591 if (!flag_indirect_dispatch
2592 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2594 /* An abstract class can have methods which are declared only in
2595 an implemented interface. These are called "Miranda
2596 methods". We make a dummy method entry for such methods
2598 add_miranda_methods (this_class
, this_class
);
2601 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2603 for (method_decl
= TYPE_METHODS (this_class
);
2604 method_decl
; method_decl
= DECL_CHAIN (method_decl
))
2605 dtable_count
= layout_class_method (this_class
, super_class
,
2606 method_decl
, dtable_count
);
2608 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2611 /* Return the index of METHOD in INTERFACE. This index begins at 1
2612 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2614 get_interface_method_index (tree method
, tree interface
)
2619 for (meth
= TYPE_METHODS (interface
); ; meth
= DECL_CHAIN (meth
))
2623 /* We don't want to put <clinit> into the interface table. */
2624 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2626 gcc_assert (meth
!= NULL_TREE
);
2630 /* Lay METHOD_DECL out, returning a possibly new value of
2631 DTABLE_COUNT. Also mangle the method's name. */
2634 layout_class_method (tree this_class
, tree super_class
,
2635 tree method_decl
, tree dtable_count
)
2637 tree method_name
= DECL_NAME (method_decl
);
2639 TREE_PUBLIC (method_decl
) = 1;
2641 if (flag_indirect_classes
2642 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2643 && ! METHOD_NATIVE (method_decl
)
2644 && ! special_method_p (method_decl
)))
2645 java_hide_decl (method_decl
);
2647 /* Considered external unless it is being compiled into this object
2648 file, or it was already flagged as external. */
2649 if (!DECL_EXTERNAL (method_decl
))
2650 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2651 || METHOD_NATIVE (method_decl
));
2653 if (ID_INIT_P (method_name
))
2655 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2657 for (ptr
= p
; *ptr
; )
2662 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2663 build_java_signature (TREE_TYPE (method_decl
));
2665 else if (! METHOD_STATIC (method_decl
))
2668 build_java_signature (TREE_TYPE (method_decl
));
2669 bool method_override
= false;
2670 tree super_method
= lookup_java_method (super_class
, method_name
,
2672 if (super_method
!= NULL_TREE
2673 && ! METHOD_DUMMY (super_method
))
2675 method_override
= true;
2676 if (! METHOD_PUBLIC (super_method
) &&
2677 ! METHOD_PROTECTED (super_method
))
2679 /* Don't override private method, or default-access method in
2681 if (METHOD_PRIVATE (super_method
) ||
2682 ! in_same_package (TYPE_NAME (this_class
),
2683 TYPE_NAME (super_class
)))
2684 method_override
= false;
2687 if (method_override
)
2689 tree method_index
= get_method_index (super_method
);
2690 set_method_index (method_decl
, method_index
);
2691 if (method_index
== NULL_TREE
2692 && ! flag_indirect_dispatch
2693 && ! DECL_ARTIFICIAL (super_method
))
2694 error ("non-static method %q+D overrides static method",
2697 else if (this_class
== object_type_node
2698 && (METHOD_FINAL (method_decl
)
2699 || METHOD_PRIVATE (method_decl
)))
2701 /* We don't generate vtable entries for final Object
2702 methods. This is simply to save space, since every
2703 object would otherwise have to define them. */
2705 else if (! METHOD_PRIVATE (method_decl
)
2708 /* We generate vtable entries for final methods because they
2709 may one day be changed to non-final. */
2710 set_method_index (method_decl
, dtable_count
);
2711 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2712 dtable_count
, integer_one_node
);
2716 return dtable_count
;
2720 register_class (void)
2724 if (!registered_class
)
2725 vec_alloc (registered_class
, 8);
2727 if (flag_indirect_classes
)
2728 node
= current_class
;
2730 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2731 vec_safe_push (registered_class
, node
);
2734 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2735 all the classes we have emitted. */
2738 emit_indirect_register_classes (tree
*list_p
)
2740 tree klass
, t
, register_class_fn
;
2743 int size
= vec_safe_length (registered_class
) * 2 + 1;
2744 vec
<constructor_elt
, va_gc
> *init
;
2745 vec_alloc (init
, size
);
2746 tree class_array_type
2747 = build_prim_array_type (ptr_type_node
, size
);
2748 tree
cdecl = build_decl (input_location
,
2749 VAR_DECL
, get_identifier ("_Jv_CLS"),
2751 tree reg_class_list
;
2752 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2754 t
= fold_convert (ptr_type_node
, build_static_class_ref (klass
));
2755 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, t
);
2756 t
= fold_convert (ptr_type_node
,
2757 build_address_of (build_classdollar_field (klass
)));
2758 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, t
);
2760 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, integer_zero_node
);
2761 DECL_INITIAL (cdecl) = build_constructor (class_array_type
, init
);
2762 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2763 TREE_STATIC (cdecl) = 1;
2764 DECL_ARTIFICIAL (cdecl) = 1;
2765 DECL_IGNORED_P (cdecl) = 1;
2766 TREE_READONLY (cdecl) = 1;
2767 TREE_CONSTANT (cdecl) = 1;
2768 rest_of_decl_compilation (cdecl, 1, 0);
2769 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2771 t
= build_function_type_list (void_type_node
,
2772 build_pointer_type (ptr_type_node
), NULL
);
2773 t
= build_decl (input_location
,
2775 get_identifier ("_Jv_RegisterNewClasses"), t
);
2776 TREE_PUBLIC (t
) = 1;
2777 DECL_EXTERNAL (t
) = 1;
2778 register_class_fn
= t
;
2779 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2780 append_to_statement_list (t
, list_p
);
2783 /* Emit a list of pointers to all classes we have emitted to JCR_SECTION. */
2786 emit_register_classes_in_jcr_section (void)
2788 #ifdef JCR_SECTION_NAME
2789 tree klass
, cdecl, class_array_type
;
2791 int size
= vec_safe_length (registered_class
);
2792 vec
<constructor_elt
, va_gc
> *init
;
2793 vec_alloc (init
, size
);
2795 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2796 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, build_fold_addr_expr (klass
));
2798 /* ??? I would like to use tree_output_constant_def() but there is no way
2799 to put the data in a named section name, or to set the alignment,
2800 via that function. So do everything manually here. */
2801 class_array_type
= build_prim_array_type (ptr_type_node
, size
);
2802 cdecl = build_decl (UNKNOWN_LOCATION
,
2803 VAR_DECL
, get_identifier ("_Jv_JCR_SECTION_data"),
2805 DECL_ALIGN (cdecl) = POINTER_SIZE
;
2806 DECL_USER_ALIGN (cdecl) = 1;
2807 DECL_INITIAL (cdecl) = build_constructor (class_array_type
, init
);
2808 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2809 TREE_STATIC (cdecl) = 1;
2810 TREE_READONLY (cdecl) = 0;
2811 TREE_CONSTANT (cdecl) = 1;
2812 DECL_ARTIFICIAL (cdecl) = 1;
2813 DECL_IGNORED_P (cdecl) = 1;
2814 DECL_PRESERVE_P (cdecl) = 1;
2815 set_decl_section_name (cdecl, JCR_SECTION_NAME
);
2816 pushdecl_top_level (cdecl);
2817 relayout_decl (cdecl);
2818 rest_of_decl_compilation (cdecl, 1, 0);
2820 /* A target has defined TARGET_USE_JCR_SECTION,
2821 but doesn't have a JCR_SECTION_NAME. */
2827 /* Emit a series of calls to _Jv_RegisterClass for every class we emitted.
2828 A series of calls is added to LIST_P. */
2831 emit_Jv_RegisterClass_calls (tree
*list_p
)
2833 tree klass
, t
, register_class_fn
;
2836 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2837 t
= build_decl (input_location
,
2838 FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2839 TREE_PUBLIC (t
) = 1;
2840 DECL_EXTERNAL (t
) = 1;
2841 register_class_fn
= t
;
2843 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2845 t
= build_fold_addr_expr (klass
);
2846 t
= build_call_expr (register_class_fn
, 1, t
);
2847 append_to_statement_list (t
, list_p
);
2851 /* Emit something to register classes at start-up time.
2853 The default mechanism is to generate instances at run-time.
2855 An alternative mechanism is through the .jcr section, which contain
2856 a list of pointers to classes which get registered during constructor
2859 The fallback mechanism is to add statements to *LIST_P to call
2860 _Jv_RegisterClass for each class in this file. These statements will
2861 be added to a static constructor function for this translation unit. */
2864 emit_register_classes (tree
*list_p
)
2866 if (registered_class
== NULL
)
2869 /* By default, generate instances of Class at runtime. */
2870 if (flag_indirect_classes
)
2871 emit_indirect_register_classes (list_p
);
2872 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2873 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2874 but lack suitable crtbegin/end objects or linker support. These
2875 targets can override the default in tm.h to use the fallback mechanism. */
2876 else if (TARGET_USE_JCR_SECTION
)
2877 emit_register_classes_in_jcr_section ();
2878 /* Use the fallback mechanism. */
2880 emit_Jv_RegisterClass_calls (list_p
);
2883 /* Build a constructor for an entry in the symbol table. */
2886 build_symbol_table_entry (tree clname
, tree name
, tree signature
)
2889 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2891 START_RECORD_CONSTRUCTOR (v
, symbol_type
);
2892 PUSH_FIELD_VALUE (v
, "clname", clname
);
2893 PUSH_FIELD_VALUE (v
, "name", name
);
2894 PUSH_FIELD_VALUE (v
, "signature", signature
);
2895 FINISH_RECORD_CONSTRUCTOR (symbol
, v
, symbol_type
);
2896 TREE_CONSTANT (symbol
) = 1;
2901 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2904 build_symbol_entry (tree decl
, tree special
)
2906 tree clname
, name
, signature
;
2907 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2908 /* ??? Constructors are given the name foo.foo all the way through
2909 the compiler, but in the method table they're all renamed
2910 foo.<init>. So, we have to do the same here unless we want an
2911 unresolved reference at runtime. */
2912 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2913 && DECL_CONSTRUCTOR_P (decl
))
2914 ? init_identifier_node
2915 : DECL_NAME (decl
));
2916 signature
= build_java_signature (TREE_TYPE (decl
));
2917 signature
= build_utf8_ref (unmangle_classname
2918 (IDENTIFIER_POINTER (signature
),
2919 IDENTIFIER_LENGTH (signature
)));
2920 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2921 signature addr+1 if SPECIAL, and this indicates to the runtime
2922 system that this is a "special" symbol, i.e. one that should
2923 bypass access controls. */
2924 if (special
!= NULL_TREE
)
2925 signature
= fold_build_pointer_plus (signature
, special
);
2927 return build_symbol_table_entry (clname
, name
, signature
);
2930 /* Emit a symbol table: used by -findirect-dispatch. */
2933 emit_symbol_table (tree name
, tree the_table
,
2934 vec
<method_entry
, va_gc
> *decl_table
,
2935 tree the_syms_decl
, tree the_array_element_type
,
2938 tree table
, null_symbol
, table_size
, the_array_type
;
2941 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2943 /* Only emit a table if this translation unit actually made any
2944 references via it. */
2948 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2949 FOR_EACH_VEC_ELT (*decl_table
, index
, e
)
2950 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
2951 build_symbol_entry (e
->method
, e
->special
));
2953 /* Terminate the list with a "null" entry. */
2954 null_symbol
= build_symbol_table_entry (null_pointer_node
,
2957 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, null_symbol
);
2959 tree symbols_arr_type
2960 = build_prim_array_type (symbol_type
, vec_safe_length (v
));
2962 table
= build_constructor (symbols_arr_type
, v
);
2964 /* Make it the initial value for otable_syms and emit the decl. */
2965 TREE_TYPE (the_syms_decl
) = symbols_arr_type
;
2966 relayout_decl (the_syms_decl
);
2967 DECL_INITIAL (the_syms_decl
) = table
;
2968 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2969 DECL_IGNORED_P (the_syms_decl
) = 1;
2970 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2972 /* Now that its size is known, redefine the table as an
2973 uninitialized static array of INDEX + 1 elements. The extra entry
2974 is used by the runtime to track whether the table has been
2977 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2978 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2979 the_table
= build_decl (input_location
,
2980 VAR_DECL
, name
, the_array_type
);
2981 TREE_STATIC (the_table
) = 1;
2982 TREE_READONLY (the_table
) = 1;
2983 rest_of_decl_compilation (the_table
, 1, 0);
2988 /* Make an entry for the catch_classes list. */
2990 make_catch_class_record (tree catch_class
, tree classname
)
2993 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2994 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2995 START_RECORD_CONSTRUCTOR (v
, type
);
2996 PUSH_FIELD_VALUE (v
, "address", catch_class
);
2997 PUSH_FIELD_VALUE (v
, "classname", classname
);
2998 FINISH_RECORD_CONSTRUCTOR (entry
, v
, type
);
3003 /* Generate the list of Throwable classes that are caught by exception
3004 handlers in this class. */
3006 emit_catch_table (tree this_class
)
3008 tree table
, table_size
, array_type
;
3009 int n_catch_classes
;
3011 /* Fill in the dummy entry that make_class created. */
3012 e
= &(*TYPE_CATCH_CLASSES (this_class
))[0];
3013 e
->value
= make_catch_class_record (null_pointer_node
, null_pointer_node
);
3014 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class
), NULL_TREE
,
3015 make_catch_class_record (null_pointer_node
,
3016 null_pointer_node
));
3017 n_catch_classes
= TYPE_CATCH_CLASSES (this_class
)->length ();
3018 table_size
= build_index_type (build_int_cst (NULL_TREE
, n_catch_classes
));
3020 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
3023 build_decl (input_location
,
3024 VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
3025 DECL_INITIAL (table
) =
3026 build_constructor (array_type
, TYPE_CATCH_CLASSES (this_class
));
3027 TREE_STATIC (table
) = 1;
3028 TREE_READONLY (table
) = 1;
3029 DECL_IGNORED_P (table
) = 1;
3030 rest_of_decl_compilation (table
, 1, 0);
3034 /* Given a type, return the signature used by
3035 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
3036 same as build_java_signature() because we want the canonical array
3040 build_signature_for_libgcj (tree type
)
3044 sig
= build_java_signature (type
);
3045 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
3046 IDENTIFIER_LENGTH (sig
)));
3050 /* Build an entry in the type assertion table. */
3053 build_assertion_table_entry (tree code
, tree op1
, tree op2
)
3055 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3058 START_RECORD_CONSTRUCTOR (v
, assertion_entry_type
);
3059 PUSH_FIELD_VALUE (v
, "assertion_code", code
);
3060 PUSH_FIELD_VALUE (v
, "op1", op1
);
3061 PUSH_FIELD_VALUE (v
, "op2", op2
);
3062 FINISH_RECORD_CONSTRUCTOR (entry
, v
, assertion_entry_type
);
3067 /* Add an entry to the type assertion table. Callback used during hashtable
3071 add_assertion_table_entry (type_assertion
**slot
, vec
<constructor_elt
, va_gc
> **v
)
3074 tree code_val
, op1_utf8
, op2_utf8
;
3075 type_assertion
*as
= *slot
;
3077 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
3079 if (as
->op1
== NULL_TREE
)
3080 op1_utf8
= null_pointer_node
;
3082 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3084 if (as
->op2
== NULL_TREE
)
3085 op2_utf8
= null_pointer_node
;
3087 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3089 entry
= build_assertion_table_entry (code_val
, op1_utf8
, op2_utf8
);
3091 CONSTRUCTOR_APPEND_ELT (*v
, NULL_TREE
, entry
);
3095 /* Generate the type assertion table for KLASS, and return its DECL. */
3098 emit_assertion_table (tree klass
)
3100 tree null_entry
, ctor
, table_decl
;
3101 hash_table
<type_assertion_hasher
> *assertions_htab
= TYPE_ASSERTIONS (klass
);
3102 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3104 /* Iterate through the hash table. */
3106 ->traverse
<vec
<constructor_elt
, va_gc
> **, add_assertion_table_entry
> (&v
);
3108 /* Finish with a null entry. */
3109 null_entry
= build_assertion_table_entry (integer_zero_node
,
3113 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, null_entry
);
3116 = build_prim_array_type (assertion_entry_type
, vec_safe_length (v
));
3118 ctor
= build_constructor (type
, v
);
3120 table_decl
= build_decl (input_location
,
3121 VAR_DECL
, mangled_classname ("_type_assert_", klass
),
3124 TREE_STATIC (table_decl
) = 1;
3125 TREE_READONLY (table_decl
) = 1;
3126 TREE_CONSTANT (table_decl
) = 1;
3127 DECL_IGNORED_P (table_decl
) = 1;
3129 DECL_INITIAL (table_decl
) = ctor
;
3130 DECL_ARTIFICIAL (table_decl
) = 1;
3131 rest_of_decl_compilation (table_decl
, 1, 0);
3137 init_class_processing (void)
3139 fields_ident
= get_identifier ("fields");
3140 info_ident
= get_identifier ("info");
3142 gcc_obstack_init (&temporary_obstack
);
3145 /* A hash table mapping trees to trees. Used generally. */
3147 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3150 treetreehasher::hash (treetreehash_entry
*k
)
3152 return JAVA_TREEHASHHASH_H (k
->key
);
3156 treetreehasher::equal (treetreehash_entry
*k1
, tree k2
)
3158 return (k1
->key
== k2
);
3162 java_treetreehash_find (hash_table
<treetreehasher
> *ht
, tree t
)
3164 struct treetreehash_entry
*e
;
3165 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3166 e
= ht
->find_with_hash (t
, hv
);
3174 java_treetreehash_new (hash_table
<treetreehasher
> *ht
, tree t
)
3176 struct treetreehash_entry
*tthe
;
3177 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3179 treetreehash_entry
**e
= ht
->find_slot_with_hash (t
, hv
, INSERT
);
3182 tthe
= ggc_cleared_alloc
<treetreehash_entry
> ();
3188 return &tthe
->value
;
3191 hash_table
<treetreehasher
> *
3192 java_treetreehash_create (size_t size
)
3194 return hash_table
<treetreehasher
>::create_ggc (size
);
3197 /* Break down qualified IDENTIFIER into package and class-name components.
3198 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3199 "pkg.foo", and RIGHT to "Bar". */
3202 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3205 int l
= IDENTIFIER_LENGTH (source
);
3207 base
= (char *) alloca (l
+ 1);
3208 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3210 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3212 while (*p
!= '.' && p
!= base
)
3215 /* We didn't find a '.'. Return an error. */
3221 *right
= get_identifier (p
+1);
3222 *left
= get_identifier (base
);
3227 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3228 if the classes are from the same package. */
3231 in_same_package (tree name1
, tree name2
)
3237 if (TREE_CODE (name1
) == TYPE_DECL
)
3238 name1
= DECL_NAME (name1
);
3239 if (TREE_CODE (name2
) == TYPE_DECL
)
3240 name2
= DECL_NAME (name2
);
3242 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3243 /* One in empty package. */
3246 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3247 /* Both in empty package. */
3250 split_qualified_name (&pkg1
, &tmp
, name1
);
3251 split_qualified_name (&pkg2
, &tmp
, name2
);
3253 return (pkg1
== pkg2
);
3256 #include "gt-java-class.h"