1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>.
21 Java and all Java-based marks are trademarks or registered trademarks
22 of Sun Microsystems, Inc. in the United States and other countries.
23 The Free Software Foundation is independent of Sun Microsystems, Inc. */
25 /* Written by Per Bothner <bothner@cygnus.com> */
29 #include "coretypes.h"
34 #include "java-tree.h"
46 #include "tree-iterator.h"
50 /* DOS brain-damage */
52 #define O_BINARY 0 /* MS-DOS brain-damage */
55 static tree
make_method_value (tree
);
56 static tree
build_java_method_type (tree
, tree
, int);
57 static int32
hashUtf8String (const char *, int);
58 static tree
make_field_value (tree
);
59 static tree
get_dispatch_vector (tree
);
60 static tree
get_dispatch_table (tree
, tree
);
61 static int supers_all_compiled (tree type
);
62 static tree
maybe_layout_super_class (tree
, tree
);
63 static void add_miranda_methods (tree
, tree
);
64 static int assume_compiled (const char *);
65 static tree
build_symbol_entry (tree
, tree
);
66 static tree
emit_assertion_table (tree
);
67 static void register_class (void);
69 struct obstack temporary_obstack
;
71 static const char *cyclic_inheritance_report
;
73 /* The compiler generates different code depending on whether or not
74 it can assume certain classes have been compiled down to native
75 code or not. The compiler options -fassume-compiled= and
76 -fno-assume-compiled= are used to create a tree of
77 class_flag_node objects. This tree is queried to determine if
78 a class is assume to be compiled or not. Each node in the tree
79 represents either a package or a specific class. */
81 typedef struct class_flag_node_struct
83 /* The class or package name. */
86 /* Nonzero if this represents an exclusion. */
89 /* Pointers to other nodes in the tree. */
90 struct class_flag_node_struct
*parent
;
91 struct class_flag_node_struct
*sibling
;
92 struct class_flag_node_struct
*child
;
95 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
96 static void add_class_flag (class_flag_node
**, const char *, int);
98 /* This is the root of the include/exclude tree. */
100 static class_flag_node
*assume_compiled_tree
;
102 static class_flag_node
*enable_assert_tree
;
104 static GTY(()) tree class_roots
[4];
105 #define fields_ident class_roots[0] /* get_identifier ("fields") */
106 #define info_ident class_roots[1] /* get_identifier ("info") */
107 #define class_list class_roots[2]
108 #define class_dtable_decl class_roots[3]
110 static GTY(()) VEC(tree
,gc
) *registered_class
;
112 /* A tree that returns the address of the class$ of the class
113 currently being compiled. */
114 static GTY(()) tree this_classdollar
;
116 /* Return the node that most closely represents the class whose name
117 is IDENT. Start the search from NODE (followed by its siblings).
118 Return NULL if an appropriate node does not exist. */
120 static class_flag_node
*
121 find_class_flag_node (class_flag_node
*node
, const char *ident
)
125 size_t node_ident_length
= strlen (node
->ident
);
127 /* node_ident_length is zero at the root of the tree. If the
128 identifiers are the same length, then we have matching
129 classes. Otherwise check if we've matched an enclosing
132 if (node_ident_length
== 0
133 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
134 && (ident
[node_ident_length
] == '\0'
135 || ident
[node_ident_length
] == '.')))
137 /* We've found a match, however, there might be a more
140 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
147 /* No match yet. Continue through the sibling list. */
148 node
= node
->sibling
;
151 /* No match at all in this tree. */
156 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
158 class_flag_node
*root
= *rootp
;
159 class_flag_node
*parent
, *node
;
161 /* Create the root of the tree if it doesn't exist yet. */
165 root
= XNEW (class_flag_node
);
168 root
->sibling
= NULL
;
174 /* Calling the function with the empty string means we're setting
175 value for the root of the hierarchy. */
183 /* Find the parent node for this new node. PARENT will either be a
184 class or a package name. Adjust PARENT accordingly. */
186 parent
= find_class_flag_node (root
, ident
);
187 if (strcmp (ident
, parent
->ident
) == 0)
188 parent
->value
= value
;
191 /* Insert new node into the tree. */
192 node
= XNEW (class_flag_node
);
194 node
->ident
= xstrdup (ident
);
198 node
->parent
= parent
;
199 node
->sibling
= parent
->child
;
200 parent
->child
= node
;
204 /* Add a new IDENT to the include/exclude tree. It's an exclusion
205 if EXCLUDEP is nonzero. */
208 add_assume_compiled (const char *ident
, int excludep
)
210 add_class_flag (&assume_compiled_tree
, ident
, excludep
);
213 /* The default value returned by enable_assertions. */
215 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
217 /* Enter IDENT (a class or package name) into the enable-assertions table.
218 VALUE is true to enable and false to disable. */
221 add_enable_assert (const char *ident
, int value
)
223 if (enable_assert_tree
== NULL
)
224 add_class_flag (&enable_assert_tree
, "", DEFAULT_ENABLE_ASSERT
);
225 add_class_flag (&enable_assert_tree
, ident
, value
);
228 /* Returns nonzero if IDENT is the name of a class that the compiler
229 should assume has been compiled to object code. */
232 assume_compiled (const char *ident
)
237 if (NULL
== assume_compiled_tree
)
240 i
= find_class_flag_node (assume_compiled_tree
, ident
);
247 /* Return true if we should generate code to check assertions within KLASS. */
250 enable_assertions (tree klass
)
252 /* Check if command-line specifies whether we should check assertions. */
254 if (klass
!= NULL_TREE
&& DECL_NAME (klass
) && enable_assert_tree
!= NULL
)
256 const char *ident
= IDENTIFIER_POINTER (DECL_NAME (klass
));
257 class_flag_node
*node
258 = find_class_flag_node (enable_assert_tree
, ident
);
262 /* The default is to enable assertions if generating class files,
263 or not optimizing. */
264 return DEFAULT_ENABLE_ASSERT
;
267 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
268 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
269 Also, PREFIX is prepended, and SUFFIX is appended. */
272 ident_subst (const char* old_name
,
279 int prefix_len
= strlen (prefix
);
280 int suffix_len
= strlen (suffix
);
281 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
282 char *buffer
= alloca (i
);
284 strcpy (buffer
, prefix
);
285 for (i
= 0; i
< old_length
; i
++)
287 char ch
= old_name
[i
];
290 buffer
[prefix_len
+ i
] = ch
;
292 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
293 return get_identifier (buffer
);
296 /* Return an IDENTIFIER_NODE the same as OLD_ID,
297 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
298 Also, PREFIX is prepended, and SUFFIX is appended. */
301 identifier_subst (const tree old_id
,
307 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
308 prefix
, old_char
, new_char
, suffix
);
311 /* Generate a valid C identifier from the name of the class TYPE,
312 prefixed by PREFIX. */
315 mangled_classname (const char *prefix
, tree type
)
318 tree ident
= TYPE_NAME (type
);
319 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
320 ident
= DECL_NAME (ident
);
321 result
= identifier_subst (ident
, prefix
, '.', '_', "");
323 /* Replace any characters that aren't in the set [0-9a-zA-Z_$] with
324 "_0xXX". Class names containing such chracters are uncommon, but
325 they do sometimes occur in class files. Without this check,
326 these names cause assembly errors.
328 There is a possibility that a real class name could conflict with
329 the identifier we generate, but it is unlikely and will
330 immediately be detected as an assembler error. At some point we
331 should do something more elaborate (perhaps using the full
332 unicode mangling scheme) in order to prevent such a conflict. */
335 const int len
= IDENTIFIER_LENGTH (result
);
336 const char *p
= IDENTIFIER_POINTER (result
);
337 int illegal_chars
= 0;
339 /* Make two passes over the identifier. The first pass is merely
340 to count illegal characters; we need to do this in order to
341 allocate a buffer. */
342 for (i
= 0; i
< len
; i
++)
345 illegal_chars
+= (! ISALNUM (c
) && c
!= '_' && c
!= '$');
348 /* And the second pass, which is rarely executed, does the
350 if (illegal_chars
!= 0)
352 char *buffer
= alloca (illegal_chars
* 4 + len
+ 1);
355 for (i
= 0, j
= 0; i
< len
; i
++)
358 if (! ISALNUM (c
) && c
!= '_' && c
!= '$')
361 sprintf (&buffer
[j
], "0x%02x", c
);
369 result
= get_identifier (buffer
);
380 type
= make_node (RECORD_TYPE
);
381 /* Unfortunately we must create the binfo here, so that class
383 TYPE_BINFO (type
) = make_tree_binfo (0);
384 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
389 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
390 and where each of the constituents is separated by '/',
391 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
394 unmangle_classname (const char *name
, int name_length
)
396 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
397 /* It's not sufficient to compare to_return and get_identifier
398 (name) to determine whether to_return is qualified. There are
399 cases in signature analysis where name will be stripped of a
401 name
= IDENTIFIER_POINTER (to_return
);
405 QUALIFIED_P (to_return
) = 1;
412 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
415 const char *typename = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
416 char *buf = alloca (strlen (typename) + strlen (#NAME "_syms_") + 1); \
419 sprintf (buf, #NAME "_%s", typename); \
420 TYPE_## TABLE ##_DECL (type) = decl = \
421 build_decl (VAR_DECL, get_identifier (buf), TABLE_TYPE); \
422 DECL_EXTERNAL (decl) = 1; \
423 TREE_STATIC (decl) = 1; \
424 TREE_READONLY (decl) = 1; \
425 TREE_CONSTANT (decl) = 1; \
426 DECL_IGNORED_P (decl) = 1; \
427 /* Mark the table as belonging to this class. */ \
429 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
430 DECL_OWNER (decl) = TYPE; \
431 sprintf (buf, #NAME "_syms_%s", typename); \
432 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
433 build_decl (VAR_DECL, get_identifier (buf), symbols_array_type); \
434 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
435 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
436 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
440 /* Given a class, create the DECLs for all its associated indirect
443 gen_indirect_dispatch_tables (tree type
)
445 const char *typename
= IDENTIFIER_POINTER (mangled_classname ("", type
));
448 char *buf
= alloca (strlen (typename
) + strlen ("_catch_classes_") + 1);
449 tree catch_class_type
= make_node (RECORD_TYPE
);
451 sprintf (buf
, "_catch_classes_%s", typename
);
452 PUSH_FIELD (catch_class_type
, field
, "address", utf8const_ptr_type
);
453 PUSH_FIELD (catch_class_type
, field
, "classname", ptr_type_node
);
454 FINISH_RECORD (catch_class_type
);
456 TYPE_CTABLE_DECL (type
)
457 = build_decl (VAR_DECL
, get_identifier (buf
),
458 build_array_type (catch_class_type
, 0));
459 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
460 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
461 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
462 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
463 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
464 pushdecl (TYPE_CTABLE_DECL (type
));
467 if (flag_indirect_dispatch
)
469 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
470 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
471 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
478 push_class (tree class_type
, tree class_name
)
480 tree decl
, signature
;
481 location_t saved_loc
= input_location
;
482 CLASS_P (class_type
) = 1;
483 decl
= build_decl (TYPE_DECL
, class_name
, class_type
);
484 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
486 /* dbxout needs a DECL_SIZE if in gstabs mode */
487 DECL_SIZE (decl
) = integer_zero_node
;
489 input_location
= saved_loc
;
490 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
491 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
493 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
494 both a typedef and in the struct name-space. We may want to re-visit
495 this later, but for now it reduces the changes needed for gdb. */
496 DECL_ARTIFICIAL (decl
) = 1;
498 pushdecl_top_level (decl
);
503 /* Finds the (global) class named NAME. Creates the class if not found.
504 Also creates associated TYPE_DECL.
505 Does not check if the class actually exists, load the class,
506 fill in field or methods, or do layout_type. */
509 lookup_class (tree name
)
511 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
512 if (decl
== NULL_TREE
)
513 decl
= push_class (make_class (), name
);
514 return TREE_TYPE (decl
);
518 set_super_info (int access_flags
, tree this_class
,
519 tree super_class
, int interfaces_count
)
521 int total_supers
= interfaces_count
;
522 tree class_decl
= TYPE_NAME (this_class
);
528 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
529 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
532 tree super_binfo
= make_tree_binfo (0);
533 BINFO_TYPE (super_binfo
) = super_class
;
534 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
535 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
536 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
539 set_class_decl_access_flags (access_flags
, class_decl
);
543 set_class_decl_access_flags (int access_flags
, tree class_decl
)
545 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
546 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
547 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
548 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
549 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
550 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
551 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
552 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
553 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
554 if (access_flags
& ACC_ENUM
) CLASS_ENUM (class_decl
) = 1;
555 if (access_flags
& ACC_SYNTHETIC
) CLASS_SYNTHETIC (class_decl
) = 1;
556 if (access_flags
& ACC_ANNOTATION
) CLASS_ANNOTATION (class_decl
) = 1;
559 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
560 direct sub-classes of Object are 1, and so on. */
563 class_depth (tree clas
)
566 if (! CLASS_LOADED_P (clas
))
567 load_class (clas
, 1);
568 if (TYPE_SIZE (clas
) == error_mark_node
)
570 while (clas
!= object_type_node
)
573 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
578 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
581 interface_of_p (tree type1
, tree type2
)
584 tree binfo
, base_binfo
;
586 if (! TYPE_BINFO (type2
))
589 for (binfo
= TYPE_BINFO (type2
), i
= 0;
590 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
591 if (BINFO_TYPE (base_binfo
) == type1
)
594 for (binfo
= TYPE_BINFO (type2
), i
= 0;
595 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
596 if (BINFO_TYPE (base_binfo
)
597 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
603 /* Return true iff TYPE1 inherits from TYPE2. */
606 inherits_from_p (tree type1
, tree type2
)
608 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
613 if (! CLASS_LOADED_P (type1
))
614 load_class (type1
, 1);
616 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
621 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
624 enclosing_context_p (tree type1
, tree type2
)
626 if (!INNER_CLASS_TYPE_P (type2
))
629 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
631 type2
= (INNER_CLASS_TYPE_P (type2
) ?
632 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
642 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
646 common_enclosing_context_p (tree type1
, tree type2
)
651 for (current
= type2
; current
;
652 current
= (INNER_CLASS_TYPE_P (current
) ?
653 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
655 if (type1
== current
)
658 if (INNER_CLASS_TYPE_P (type1
))
659 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
666 /* Return 1 iff there exists a common enclosing "this" between TYPE1
667 and TYPE2, without crossing any static context. */
670 common_enclosing_instance_p (tree type1
, tree type2
)
672 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
675 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
676 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
677 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
680 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
681 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
682 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
684 if (type1
== current
)
690 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
691 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
692 if attempt is made to add it twice. */
695 maybe_add_interface (tree this_class
, tree interface_class
)
697 tree binfo
, base_binfo
;
700 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
701 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
702 if (BINFO_TYPE (base_binfo
) == interface_class
)
703 return interface_class
;
704 add_interface (this_class
, interface_class
);
708 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
711 add_interface (tree this_class
, tree interface_class
)
713 tree interface_binfo
= make_tree_binfo (0);
715 BINFO_TYPE (interface_binfo
) = interface_class
;
716 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
717 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
718 BINFO_VIRTUAL_P (interface_binfo
) = 1;
720 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
724 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
726 if (access_flags
& ACC_STATIC
)
728 fntype
= build_method_type (this_class
, fntype
);
730 /* We know that arg 1 of every nonstatic method is non-null; tell
732 TYPE_ATTRIBUTES (fntype
) = (tree_cons
733 (get_identifier ("nonnull"),
734 tree_cons (NULL_TREE
,
735 build_int_cst (NULL_TREE
, 1),
737 TYPE_ATTRIBUTES (fntype
)));
742 java_hide_decl (tree decl ATTRIBUTE_UNUSED
)
744 #ifdef HAVE_GAS_HIDDEN
745 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
746 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
751 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
753 tree method_type
, fndecl
;
755 method_type
= build_java_method_type (function_type
,
756 this_class
, access_flags
);
758 fndecl
= build_decl (FUNCTION_DECL
, name
, method_type
);
759 DECL_CONTEXT (fndecl
) = this_class
;
761 DECL_LANG_SPECIFIC (fndecl
)
762 = ggc_alloc_cleared (sizeof (struct lang_decl
));
763 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
765 /* Initialize the static initializer test table. */
767 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
768 java_treetreehash_create (10, 1);
770 /* Initialize the initialized (static) class table. */
771 if (access_flags
& ACC_STATIC
)
772 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
773 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
775 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
776 TYPE_METHODS (this_class
) = fndecl
;
778 /* If pointers to member functions use the least significant bit to
779 indicate whether a function is virtual, ensure a pointer
780 to this function will have that bit clear. */
781 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
782 && !(access_flags
& ACC_STATIC
)
783 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
784 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
786 /* Notice that this is a finalizer and update the class type
787 accordingly. This is used to optimize instance allocation. */
788 if (name
== finalize_identifier_node
789 && TREE_TYPE (function_type
) == void_type_node
790 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
791 HAS_FINALIZER_P (this_class
) = 1;
793 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
794 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
795 if (access_flags
& ACC_PRIVATE
)
796 METHOD_PRIVATE (fndecl
) = DECL_INLINE (fndecl
) = 1;
797 if (access_flags
& ACC_NATIVE
)
799 METHOD_NATIVE (fndecl
) = 1;
800 DECL_EXTERNAL (fndecl
) = 1;
803 /* FNDECL is external unless we are compiling it into this object
805 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
806 if (access_flags
& ACC_STATIC
)
807 METHOD_STATIC (fndecl
) = DECL_INLINE (fndecl
) = 1;
808 if (access_flags
& ACC_FINAL
)
809 METHOD_FINAL (fndecl
) = DECL_INLINE (fndecl
) = 1;
810 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
811 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
812 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
813 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
814 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
815 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
819 /* Add a method to THIS_CLASS.
820 The method's name is NAME.
821 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
824 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
826 tree function_type
, fndecl
;
827 const unsigned char *sig
828 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
831 fatal_error ("bad method signature");
833 function_type
= get_type_from_signature (method_sig
);
834 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
835 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
840 add_field (tree
class, tree name
, tree field_type
, int flags
)
842 int is_static
= (flags
& ACC_STATIC
) != 0;
844 field
= build_decl (is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
845 TREE_CHAIN (field
) = TYPE_FIELDS (class);
846 TYPE_FIELDS (class) = field
;
847 DECL_CONTEXT (field
) = class;
848 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
850 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
851 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
852 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
853 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
854 if (flags
& ACC_VOLATILE
)
856 FIELD_VOLATILE (field
) = 1;
857 TREE_THIS_VOLATILE (field
) = 1;
859 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
860 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
861 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
864 FIELD_STATIC (field
) = 1;
865 /* Always make field externally visible. This is required so
866 that native methods can always access the field. */
867 TREE_PUBLIC (field
) = 1;
868 /* Hide everything that shouldn't be visible outside a DSO. */
869 if (flag_indirect_classes
870 || (FIELD_PRIVATE (field
)))
871 java_hide_decl (field
);
872 /* Considered external unless we are compiling it into this
874 DECL_EXTERNAL (field
) = (is_compiled_class (class) != 2);
880 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
883 set_constant_value (tree field
, tree constant
)
885 if (field
== NULL_TREE
)
886 warning (OPT_Wattributes
,
887 "misplaced ConstantValue attribute (not in any field)");
888 else if (DECL_INITIAL (field
) != NULL_TREE
)
889 warning (OPT_Wattributes
,
890 "duplicate ConstantValue attribute for field '%s'",
891 IDENTIFIER_POINTER (DECL_NAME (field
)));
894 DECL_INITIAL (field
) = constant
;
895 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
896 && ! (TREE_TYPE (constant
) == int_type_node
897 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
898 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
899 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
900 && TREE_TYPE (field
) == string_ptr_type_node
))
901 error ("ConstantValue attribute of field '%s' has wrong type",
902 IDENTIFIER_POINTER (DECL_NAME (field
)));
906 /* Calculate a hash value for a string encoded in Utf8 format.
907 * This returns the same hash value as specified for java.lang.String.hashCode.
911 hashUtf8String (const char *str
, int len
)
913 const unsigned char* ptr
= (const unsigned char*) str
;
914 const unsigned char *limit
= ptr
+ len
;
918 int ch
= UTF8_GET (ptr
, limit
);
919 /* Updated specification from
920 http://www.javasoft.com/docs/books/jls/clarify.html. */
921 hash
= (31 * hash
) + ch
;
926 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
929 build_utf8_ref (tree name
)
931 const char * name_ptr
= IDENTIFIER_POINTER(name
);
932 int name_len
= IDENTIFIER_LENGTH(name
);
934 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
935 static int utf8_count
= 0;
937 tree ref
= IDENTIFIER_UTF8_REF (name
);
939 if (ref
!= NULL_TREE
)
942 ctype
= make_node (RECORD_TYPE
);
943 str_type
= build_prim_array_type (unsigned_byte_type_node
,
944 name_len
+ 1); /* Allow for final '\0'. */
945 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
946 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
947 PUSH_FIELD (ctype
, field
, "data", str_type
);
948 FINISH_RECORD (ctype
);
949 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
950 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
951 PUSH_FIELD_VALUE (cinit
, "hash", build_int_cst (NULL_TREE
, name_hash
));
952 PUSH_FIELD_VALUE (cinit
, "length", build_int_cst (NULL_TREE
, name_len
));
953 string
= build_string (name_len
, name_ptr
);
954 TREE_TYPE (string
) = str_type
;
955 PUSH_FIELD_VALUE (cinit
, "data", string
);
956 FINISH_RECORD_CONSTRUCTOR (cinit
);
957 TREE_CONSTANT (cinit
) = 1;
958 TREE_INVARIANT (cinit
) = 1;
960 /* Generate a unique-enough identifier. */
961 sprintf(buf
, "_Utf%d", ++utf8_count
);
963 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
964 TREE_STATIC (decl
) = 1;
965 DECL_ARTIFICIAL (decl
) = 1;
966 DECL_IGNORED_P (decl
) = 1;
967 TREE_READONLY (decl
) = 1;
968 TREE_THIS_VOLATILE (decl
) = 0;
969 DECL_INITIAL (decl
) = cinit
;
971 if (HAVE_GAS_SHF_MERGE
)
974 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
975 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
976 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
977 if (flag_merge_constants
&& decl_size
< 256)
980 int flags
= (SECTION_OVERRIDE
981 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
982 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
983 switch_to_section (get_section (buf
, flags
, NULL
));
984 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
988 TREE_CHAIN (decl
) = utf8_decl_list
;
989 layout_decl (decl
, 0);
991 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
992 varpool_mark_needed_node (varpool_node (decl
));
993 utf8_decl_list
= decl
;
994 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
995 IDENTIFIER_UTF8_REF (name
) = ref
;
999 /* Like build_class_ref, but instead of a direct reference generate a
1000 pointer into the constant pool. */
1003 build_indirect_class_ref (tree type
)
1007 index
= alloc_class_constant (type
);
1008 cl
= build_ref_from_constant_pool (index
);
1009 return convert (promote_type (class_ptr_type
), cl
);
1013 build_static_class_ref (tree type
)
1015 tree decl_name
, decl
, ref
;
1017 if (TYPE_SIZE (type
) == error_mark_node
)
1018 return null_pointer_node
;
1019 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1020 "", '/', '/', ".class$$");
1021 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1022 if (decl
== NULL_TREE
)
1024 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1025 TREE_STATIC (decl
) = 1;
1026 if (! flag_indirect_classes
)
1028 TREE_PUBLIC (decl
) = 1;
1029 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1030 java_hide_decl (decl
);
1032 DECL_IGNORED_P (decl
) = 1;
1033 DECL_ARTIFICIAL (decl
) = 1;
1034 if (is_compiled_class (type
) == 1)
1035 DECL_EXTERNAL (decl
) = 1;
1036 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1037 DECL_CLASS_FIELD_P (decl
) = 1;
1038 DECL_CONTEXT (decl
) = type
;
1040 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1041 that that means not calling pushdecl_top_level. */
1042 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1045 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1050 build_classdollar_field (tree type
)
1052 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1053 "", '/', '/', ".class$");
1054 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1056 if (decl
== NULL_TREE
)
1059 = build_decl (VAR_DECL
, decl_name
,
1062 (build_type_variant (class_type_node
,
1064 /* const */ 1, 0)));
1065 TREE_STATIC (decl
) = 1;
1066 TREE_INVARIANT (decl
) = 1;
1067 TREE_CONSTANT (decl
) = 1;
1068 TREE_READONLY (decl
) = 1;
1069 TREE_PUBLIC (decl
) = 1;
1070 java_hide_decl (decl
);
1071 DECL_IGNORED_P (decl
) = 1;
1072 DECL_ARTIFICIAL (decl
) = 1;
1073 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1074 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1075 DECL_CLASS_FIELD_P (decl
) = 1;
1076 DECL_CONTEXT (decl
) = type
;
1082 /* Create a local variable that holds the current class$. */
1085 cache_this_class_ref (tree fndecl
)
1089 tree classdollar_field
;
1090 if (flag_indirect_classes
)
1091 classdollar_field
= build_classdollar_field (output_class
);
1093 classdollar_field
= build_static_class_ref (output_class
);
1095 this_classdollar
= build_decl (VAR_DECL
, NULL_TREE
,
1096 TREE_TYPE (classdollar_field
));
1098 java_add_local_var (this_classdollar
);
1099 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1100 this_classdollar
, classdollar_field
));
1103 this_classdollar
= build_classdollar_field (output_class
);
1105 /* Prepend class initialization for static methods reachable from
1107 if (METHOD_STATIC (fndecl
)
1108 && (! METHOD_PRIVATE (fndecl
)
1109 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1110 && ! DECL_CLINIT_P (fndecl
)
1111 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1113 tree init
= build_call_expr (soft_initclass_node
, 1,
1115 java_add_stmt (init
);
1119 /* Remove the reference to the local variable that holds the current
1123 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1125 this_classdollar
= build_classdollar_field (output_class
);
1128 /* Build a reference to the class TYPE.
1129 Also handles primitive types and array types. */
1132 build_class_ref (tree type
)
1134 int is_compiled
= is_compiled_class (type
);
1138 if (TREE_CODE (type
) == POINTER_TYPE
)
1139 type
= TREE_TYPE (type
);
1141 if (flag_indirect_dispatch
1142 && type
!= output_class
1143 && TREE_CODE (type
) == RECORD_TYPE
)
1144 return build_indirect_class_ref (type
);
1146 if (type
== output_class
&& flag_indirect_classes
)
1147 return this_classdollar
;
1149 if (TREE_CODE (type
) == RECORD_TYPE
)
1150 return build_static_class_ref (type
);
1156 decl_name
= TYPE_NAME (type
);
1157 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1158 decl_name
= DECL_NAME (decl_name
);
1159 name
= IDENTIFIER_POINTER (decl_name
);
1160 if (strncmp (name
, "promoted_", 9) == 0)
1162 sprintf (buffer
, "_Jv_%sClass", name
);
1163 decl_name
= get_identifier (buffer
);
1164 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1165 if (decl
== NULL_TREE
)
1167 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1168 TREE_STATIC (decl
) = 1;
1169 TREE_PUBLIC (decl
) = 1;
1170 DECL_EXTERNAL (decl
) = 1;
1171 DECL_ARTIFICIAL (decl
) = 1;
1172 pushdecl_top_level (decl
);
1176 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1180 return build_indirect_class_ref (type
);
1183 /* Create a local statically allocated variable that will hold a
1184 pointer to a static field. */
1187 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1189 tree decl
, decl_name
;
1190 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1191 char *buf
= alloca (strlen (name
) + 20);
1192 sprintf (buf
, "%s_%d_ref", name
, index
);
1193 decl_name
= get_identifier (buf
);
1194 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1195 if (decl
== NULL_TREE
)
1197 decl
= build_decl (VAR_DECL
, decl_name
, ptr_type_node
);
1198 TREE_STATIC (decl
) = 1;
1199 TREE_PUBLIC (decl
) = 0;
1200 DECL_EXTERNAL (decl
) = 0;
1201 DECL_ARTIFICIAL (decl
) = 1;
1202 DECL_IGNORED_P (decl
) = 1;
1203 pushdecl_top_level (decl
);
1209 build_static_field_ref (tree fdecl
)
1211 tree fclass
= DECL_CONTEXT (fdecl
);
1212 int is_compiled
= is_compiled_class (fclass
);
1214 /* Allow static final fields to fold to a constant. When using
1215 -findirect-dispatch, we simply never do this folding if compiling
1216 from .class; in the .class file constants will be referred to via
1217 the constant pool. */
1218 if (!flag_indirect_dispatch
1220 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1221 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1222 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1223 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1225 if (is_compiled
== 1)
1226 DECL_EXTERNAL (fdecl
) = 1;
1230 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1231 and a class local static variable CACHE_ENTRY, then
1233 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1234 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1237 This can mostly be optimized away, so that the usual path is a
1238 load followed by a test and branch. _Jv_ResolvePoolEntry is
1239 only called once for each constant pool entry.
1241 There is an optimization that we don't do: at the start of a
1242 method, create a local copy of CACHE_ENTRY and use that instead.
1246 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1247 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1249 = build_call_expr (built_in_decls
[BUILT_IN_EXPECT
], 2,
1250 build2 (EQ_EXPR
, boolean_type_node
,
1251 cache_entry
, null_pointer_node
),
1252 boolean_false_node
);
1253 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1255 = build_call_expr (soft_resolvepoolentry_node
, 2,
1256 build_class_ref (output_class
),
1258 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1259 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1260 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1261 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1267 get_access_flags_from_decl (tree decl
)
1269 int access_flags
= 0;
1270 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1272 if (FIELD_STATIC (decl
))
1273 access_flags
|= ACC_STATIC
;
1274 if (FIELD_PUBLIC (decl
))
1275 access_flags
|= ACC_PUBLIC
;
1276 if (FIELD_PROTECTED (decl
))
1277 access_flags
|= ACC_PROTECTED
;
1278 if (FIELD_PRIVATE (decl
))
1279 access_flags
|= ACC_PRIVATE
;
1280 if (FIELD_FINAL (decl
))
1281 access_flags
|= ACC_FINAL
;
1282 if (FIELD_VOLATILE (decl
))
1283 access_flags
|= ACC_VOLATILE
;
1284 if (FIELD_TRANSIENT (decl
))
1285 access_flags
|= ACC_TRANSIENT
;
1286 if (FIELD_ENUM (decl
))
1287 access_flags
|= ACC_ENUM
;
1288 if (FIELD_SYNTHETIC (decl
))
1289 access_flags
|= ACC_SYNTHETIC
;
1290 return access_flags
;
1292 if (TREE_CODE (decl
) == TYPE_DECL
)
1294 if (CLASS_PUBLIC (decl
))
1295 access_flags
|= ACC_PUBLIC
;
1296 if (CLASS_FINAL (decl
))
1297 access_flags
|= ACC_FINAL
;
1298 if (CLASS_SUPER (decl
))
1299 access_flags
|= ACC_SUPER
;
1300 if (CLASS_INTERFACE (decl
))
1301 access_flags
|= ACC_INTERFACE
;
1302 if (CLASS_ABSTRACT (decl
))
1303 access_flags
|= ACC_ABSTRACT
;
1304 if (CLASS_STATIC (decl
))
1305 access_flags
|= ACC_STATIC
;
1306 if (CLASS_PRIVATE (decl
))
1307 access_flags
|= ACC_PRIVATE
;
1308 if (CLASS_PROTECTED (decl
))
1309 access_flags
|= ACC_PROTECTED
;
1310 if (CLASS_STRICTFP (decl
))
1311 access_flags
|= ACC_STRICT
;
1312 if (CLASS_ENUM (decl
))
1313 access_flags
|= ACC_ENUM
;
1314 if (CLASS_SYNTHETIC (decl
))
1315 access_flags
|= ACC_SYNTHETIC
;
1316 if (CLASS_ANNOTATION (decl
))
1317 access_flags
|= ACC_ANNOTATION
;
1318 return access_flags
;
1320 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1322 if (METHOD_PUBLIC (decl
))
1323 access_flags
|= ACC_PUBLIC
;
1324 if (METHOD_PRIVATE (decl
))
1325 access_flags
|= ACC_PRIVATE
;
1326 if (METHOD_PROTECTED (decl
))
1327 access_flags
|= ACC_PROTECTED
;
1328 if (METHOD_STATIC (decl
))
1329 access_flags
|= ACC_STATIC
;
1330 if (METHOD_FINAL (decl
))
1331 access_flags
|= ACC_FINAL
;
1332 if (METHOD_SYNCHRONIZED (decl
))
1333 access_flags
|= ACC_SYNCHRONIZED
;
1334 if (METHOD_NATIVE (decl
))
1335 access_flags
|= ACC_NATIVE
;
1336 if (METHOD_ABSTRACT (decl
))
1337 access_flags
|= ACC_ABSTRACT
;
1338 if (METHOD_STRICTFP (decl
))
1339 access_flags
|= ACC_STRICT
;
1340 if (METHOD_INVISIBLE (decl
))
1341 access_flags
|= ACC_INVISIBLE
;
1342 if (DECL_ARTIFICIAL (decl
))
1343 access_flags
|= ACC_SYNTHETIC
;
1344 if (METHOD_BRIDGE (decl
))
1345 access_flags
|= ACC_BRIDGE
;
1346 if (METHOD_VARARGS (decl
))
1347 access_flags
|= ACC_VARARGS
;
1348 return access_flags
;
1353 static GTY (()) int alias_labelno
= 0;
1355 /* Create a private alias for METHOD. Using this alias instead of the method
1356 decl ensures that ncode entries in the method table point to the real function
1357 at runtime, not a PLT entry. */
1360 make_local_function_alias (tree method
)
1362 #ifdef ASM_OUTPUT_DEF
1365 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1366 char *name
= alloca (strlen (method_name
) + 2);
1367 char *buf
= alloca (strlen (method_name
) + 128);
1369 /* Only create aliases for local functions. */
1370 if (DECL_EXTERNAL (method
))
1373 /* Prefix method_name with 'L' for the alias label. */
1375 strcpy (name
+ 1, method_name
);
1377 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1378 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
1379 TREE_TYPE (method
));
1380 DECL_CONTEXT (alias
) = NULL
;
1381 TREE_READONLY (alias
) = TREE_READONLY (method
);
1382 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1383 TREE_PUBLIC (alias
) = 0;
1384 DECL_EXTERNAL (alias
) = 0;
1385 DECL_ARTIFICIAL (alias
) = 1;
1386 DECL_INLINE (alias
) = 0;
1387 DECL_INITIAL (alias
) = error_mark_node
;
1388 TREE_ADDRESSABLE (alias
) = 1;
1389 TREE_USED (alias
) = 1;
1390 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1391 if (!flag_syntax_only
)
1392 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1399 /** Make reflection data (_Jv_Field) for field FDECL. */
1402 make_field_value (tree fdecl
)
1406 tree type
= TREE_TYPE (fdecl
);
1407 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1409 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1410 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1412 type
= build_class_ref (type
);
1415 tree signature
= build_java_signature (type
);
1417 type
= build_utf8_ref (unmangle_classname
1418 (IDENTIFIER_POINTER (signature
),
1419 IDENTIFIER_LENGTH (signature
)));
1421 PUSH_FIELD_VALUE (finit
, "type", type
);
1423 flags
= get_access_flags_from_decl (fdecl
);
1425 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1427 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1428 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1431 tree field_address
= integer_zero_node
;
1432 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1433 && FIELD_STATIC (fdecl
))
1434 field_address
= build_address_of (fdecl
);
1438 build_constructor_from_list (field_info_union_node
,
1440 ((FIELD_STATIC (fdecl
)
1441 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1442 : TYPE_FIELDS (field_info_union_node
)),
1443 (FIELD_STATIC (fdecl
)
1445 : byte_position (fdecl
)))));
1448 FINISH_RECORD_CONSTRUCTOR (finit
);
1452 /** Make reflection data (_Jv_Method) for method MDECL. */
1455 make_method_value (tree mdecl
)
1457 static int method_name_count
= 0;
1462 #define ACC_TRANSLATED 0x4000
1463 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1465 class_decl
= DECL_CONTEXT (mdecl
);
1466 /* For interfaces, the index field contains the dispatch index. */
1467 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1468 index
= build_int_cst (NULL_TREE
,
1469 get_interface_method_index (mdecl
, class_decl
));
1470 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1471 index
= get_method_index (mdecl
);
1473 index
= integer_minus_one_node
;
1475 code
= null_pointer_node
;
1476 if (METHOD_ABSTRACT (mdecl
))
1477 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1478 soft_abstractmethod_node
);
1480 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1481 make_local_function_alias (mdecl
));
1482 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1483 PUSH_FIELD_VALUE (minit
, "name",
1484 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1485 init_identifier_node
1486 : DECL_NAME (mdecl
)));
1488 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1489 PUSH_FIELD_VALUE (minit
, "signature",
1492 (IDENTIFIER_POINTER(signature
),
1493 IDENTIFIER_LENGTH(signature
)))));
1495 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1496 PUSH_FIELD_VALUE (minit
, "index", index
);
1497 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1500 /* Compute the `throws' information for the method. */
1501 tree table
= null_pointer_node
;
1502 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1504 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1505 tree iter
, type
, array
;
1508 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1509 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1511 iter
= TREE_CHAIN (iter
))
1513 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1515 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1516 IDENTIFIER_LENGTH (sig
)));
1517 table
= tree_cons (NULL_TREE
, utf8
, table
);
1519 type
= build_prim_array_type (ptr_type_node
, length
);
1520 table
= build_constructor_from_list (type
, table
);
1521 /* Compute something unique enough. */
1522 sprintf (buf
, "_methods%d", method_name_count
++);
1523 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1524 DECL_INITIAL (array
) = table
;
1525 TREE_STATIC (array
) = 1;
1526 DECL_ARTIFICIAL (array
) = 1;
1527 DECL_IGNORED_P (array
) = 1;
1528 rest_of_decl_compilation (array
, 1, 0);
1530 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1533 PUSH_FIELD_VALUE (minit
, "throws", table
);
1536 FINISH_RECORD_CONSTRUCTOR (minit
);
1541 get_dispatch_vector (tree type
)
1543 tree vtable
= TYPE_VTABLE (type
);
1545 if (vtable
== NULL_TREE
)
1549 tree super
= CLASSTYPE_SUPER (type
);
1550 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1551 vtable
= make_tree_vec (nvirtuals
);
1552 TYPE_VTABLE (type
) = vtable
;
1553 if (super
!= NULL_TREE
)
1555 tree super_vtable
= get_dispatch_vector (super
);
1557 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1558 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1561 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1562 method
= TREE_CHAIN (method
))
1564 tree method_index
= get_method_index (method
);
1565 if (method_index
!= NULL_TREE
1566 && host_integerp (method_index
, 0))
1567 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1575 get_dispatch_table (tree type
, tree this_class_addr
)
1577 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1578 tree vtable
= get_dispatch_vector (type
);
1580 tree list
= NULL_TREE
;
1581 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1585 for (i
= nvirtuals
; --i
>= 0; )
1587 tree method
= TREE_VEC_ELT (vtable
, i
);
1588 if (METHOD_ABSTRACT (method
))
1591 warning (0, "%Jabstract method in non-abstract class", method
);
1593 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1594 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1595 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1597 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1601 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1602 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1604 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1605 method
, build_int_cst (NULL_TREE
, j
));
1606 TREE_CONSTANT (fdesc
) = 1;
1607 TREE_INVARIANT (fdesc
) = 1;
1608 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1611 list
= tree_cons (NULL_TREE
,
1612 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1618 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1619 using the Boehm GC we sometimes stash a GC type descriptor
1620 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1621 the emitted byte count during the output to the assembly file. */
1622 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1623 fake "function descriptor". It's first word is the is the class
1624 pointer, and subsequent words (usually one) contain the GC descriptor.
1625 In all other cases, we reserve two extra vtable slots. */
1626 gc_descr
= get_boehm_type_descriptor (type
);
1627 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1628 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1629 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1630 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1632 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1633 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1634 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1635 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1637 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1638 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1639 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1641 return build_constructor_from_list
1642 (build_prim_array_type (nativecode_ptr_type_node
,
1647 /* Set the method_index for a method decl. */
1649 set_method_index (tree decl
, tree method_index
)
1651 if (method_index
!= NULL_TREE
)
1653 /* method_index is null if we're using indirect dispatch. */
1654 method_index
= fold (convert (sizetype
, method_index
));
1656 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1657 /* Add one to skip bogus descriptor for class and GC descriptor. */
1658 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1660 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1662 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1665 DECL_VINDEX (decl
) = method_index
;
1668 /* Get the method_index for a method decl. */
1670 get_method_index (tree decl
)
1672 tree method_index
= DECL_VINDEX (decl
);
1677 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1678 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1679 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1681 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1682 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1684 return method_index
;
1688 supers_all_compiled (tree type
)
1690 while (type
!= NULL_TREE
)
1692 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1694 type
= CLASSTYPE_SUPER (type
);
1700 make_class_data (tree type
)
1702 tree decl
, cons
, temp
;
1703 tree field
, fields_decl
;
1704 tree static_fields
= NULL_TREE
;
1705 tree instance_fields
= NULL_TREE
;
1706 HOST_WIDE_INT static_field_count
= 0;
1707 HOST_WIDE_INT instance_field_count
= 0;
1708 HOST_WIDE_INT field_count
;
1709 tree field_array_type
;
1711 tree methods
= NULL_TREE
;
1712 tree dtable_decl
= NULL_TREE
;
1713 HOST_WIDE_INT method_count
= 0;
1714 tree method_array_type
;
1717 tree this_class_addr
;
1718 tree constant_pool_constructor
;
1719 tree interfaces
= null_pointer_node
;
1720 int interface_len
= 0;
1721 int uses_jv_markobj
= 0;
1722 tree type_decl
= TYPE_NAME (type
);
1723 tree id_main
= get_identifier("main");
1724 tree id_class
= get_identifier("java.lang.Class");
1725 /** Offset from start of virtual function table declaration
1726 to where objects actually point at, following new g++ ABI. */
1727 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1728 VEC(int, heap
) *field_indexes
;
1729 tree first_real_field
;
1731 this_class_addr
= build_static_class_ref (type
);
1732 decl
= TREE_OPERAND (this_class_addr
, 0);
1734 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1735 && !flag_indirect_dispatch
)
1737 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1738 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1739 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1741 /* We've already created some other class, and consequently
1742 we made class_dtable_decl. Now we just want to fill it
1744 dtable_decl
= class_dtable_decl
;
1748 dtable_decl
= build_dtable_decl (type
);
1749 TREE_STATIC (dtable_decl
) = 1;
1750 DECL_ARTIFICIAL (dtable_decl
) = 1;
1751 DECL_IGNORED_P (dtable_decl
) = 1;
1754 TREE_PUBLIC (dtable_decl
) = 1;
1755 DECL_INITIAL (dtable_decl
) = dtable
;
1756 /* The only dispatch table exported from a DSO is the dispatch
1757 table for java.lang.Class. */
1758 if (DECL_NAME (type_decl
) != id_class
)
1759 java_hide_decl (dtable_decl
);
1760 if (! flag_indirect_classes
)
1761 rest_of_decl_compilation (dtable_decl
, 1, 0);
1762 /* Maybe we're compiling Class as the first class. If so, set
1763 class_dtable_decl to the decl we just made. */
1764 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1765 class_dtable_decl
= dtable_decl
;
1768 /* Build Field array. */
1769 field
= TYPE_FIELDS (type
);
1770 while (field
&& DECL_ARTIFICIAL (field
))
1771 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1772 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1773 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1774 first_real_field
= field
;
1776 /* First count static and instance fields. */
1777 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1779 if (! DECL_ARTIFICIAL (field
))
1781 if (FIELD_STATIC (field
))
1782 static_field_count
++;
1783 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1784 instance_field_count
++;
1787 field_count
= static_field_count
+ instance_field_count
;
1788 field_indexes
= VEC_alloc (int, heap
, field_count
);
1790 /* gcj sorts fields so that static fields come first, followed by
1791 instance fields. Unfortunately, by the time this takes place we
1792 have already generated the reflection_data for this class, and
1793 that data contains indexes into the fields. So, we generate a
1794 permutation that maps each original field index to its final
1795 position. Then we pass this permutation to
1796 rewrite_reflection_indexes(), which fixes up the reflection
1800 int static_count
= 0;
1801 int instance_count
= static_field_count
;
1804 for (i
= 0, field
= first_real_field
;
1806 field
= TREE_CHAIN (field
), i
++)
1808 if (! DECL_ARTIFICIAL (field
))
1811 if (FIELD_STATIC (field
))
1812 field_index
= static_count
++;
1813 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1814 field_index
= instance_count
++;
1815 VEC_quick_push (int, field_indexes
, field_index
);
1820 for (field
= first_real_field
; field
!= NULL_TREE
;
1821 field
= TREE_CHAIN (field
))
1823 if (! DECL_ARTIFICIAL (field
))
1825 if (FIELD_STATIC (field
))
1827 /* We must always create reflection data for static fields
1828 as it is used in the creation of the field itself. */
1829 tree init
= make_field_value (field
);
1830 tree initial
= DECL_INITIAL (field
);
1831 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1832 /* If the initial value is a string constant,
1833 prevent output_constant from trying to assemble the value. */
1834 if (initial
!= NULL_TREE
1835 && TREE_TYPE (initial
) == string_ptr_type_node
)
1836 DECL_INITIAL (field
) = NULL_TREE
;
1837 rest_of_decl_compilation (field
, 1, 1);
1838 DECL_INITIAL (field
) = initial
;
1840 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1842 tree init
= make_field_value (field
);
1843 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1848 if (field_count
> 0)
1850 static_fields
= nreverse (static_fields
);
1851 instance_fields
= nreverse (instance_fields
);
1852 static_fields
= chainon (static_fields
, instance_fields
);
1853 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1854 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1856 DECL_INITIAL (fields_decl
) = build_constructor_from_list
1857 (field_array_type
, static_fields
);
1858 TREE_STATIC (fields_decl
) = 1;
1859 DECL_ARTIFICIAL (fields_decl
) = 1;
1860 DECL_IGNORED_P (fields_decl
) = 1;
1861 rest_of_decl_compilation (fields_decl
, 1, 0);
1864 fields_decl
= NULL_TREE
;
1866 /* Build Method array. */
1867 for (method
= TYPE_METHODS (type
);
1868 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1871 if (METHOD_PRIVATE (method
)
1872 && ! flag_keep_inline_functions
1875 /* Even if we have a decl, we don't necessarily have the code.
1876 This can happen if we inherit a method from a superclass for
1877 which we don't have a .class file. */
1878 if (METHOD_DUMMY (method
))
1881 /* Generate method reflection data if:
1883 - !flag_reduced_reflection.
1885 - <clinit> -- The runtime uses reflection to initialize the
1888 - Any method in class java.lang.Class -- Class.forName() and
1889 perhaps other things require it.
1891 - class$ -- It does not work if reflection data missing.
1893 - main -- Reflection is used to find main(String[]) methods.
1895 - public not static -- It is potentially part of an
1896 interface. The runtime uses reflection data to build
1897 interface dispatch tables. */
1898 if (!flag_reduced_reflection
1899 || DECL_CLINIT_P (method
)
1900 || DECL_NAME (type_decl
) == id_class
1901 || DECL_NAME (method
) == id_main
1902 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1904 init
= make_method_value (method
);
1906 methods
= tree_cons (NULL_TREE
, init
, methods
);
1909 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1910 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1912 DECL_INITIAL (methods_decl
) = build_constructor_from_list
1913 (method_array_type
, nreverse (methods
));
1914 TREE_STATIC (methods_decl
) = 1;
1915 DECL_ARTIFICIAL (methods_decl
) = 1;
1916 DECL_IGNORED_P (methods_decl
) = 1;
1917 rest_of_decl_compilation (methods_decl
, 1, 0);
1919 if (class_dtable_decl
== NULL_TREE
)
1921 class_dtable_decl
= build_dtable_decl (class_type_node
);
1922 TREE_STATIC (class_dtable_decl
) = 1;
1923 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1924 DECL_IGNORED_P (class_dtable_decl
) = 1;
1925 if (is_compiled_class (class_type_node
) != 2)
1927 DECL_EXTERNAL (class_dtable_decl
) = 1;
1928 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1932 super
= CLASSTYPE_SUPER (type
);
1933 if (super
== NULL_TREE
)
1934 super
= null_pointer_node
;
1935 else if (! flag_indirect_dispatch
1936 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1937 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1938 super
= build_class_ref (super
);
1941 int super_index
= alloc_class_constant (super
);
1942 super
= build_int_cst (ptr_type_node
, super_index
);
1945 /* Build and emit the array of implemented interfaces. */
1946 if (type
!= object_type_node
)
1947 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1949 if (interface_len
> 0)
1951 tree init
= NULL_TREE
;
1953 tree interface_array_type
, idecl
;
1954 interface_array_type
1955 = build_prim_array_type (class_ptr_type
, interface_len
);
1956 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1957 interface_array_type
);
1959 for (i
= interface_len
; i
> 0; i
--)
1961 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1962 tree iclass
= BINFO_TYPE (child
);
1964 if (! flag_indirect_dispatch
1966 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1967 index
= build_class_ref (iclass
);
1970 int int_index
= alloc_class_constant (iclass
);
1971 index
= build_int_cst (ptr_type_node
, int_index
);
1973 init
= tree_cons (NULL_TREE
, index
, init
);
1975 DECL_INITIAL (idecl
) = build_constructor_from_list (interface_array_type
,
1977 TREE_STATIC (idecl
) = 1;
1978 DECL_ARTIFICIAL (idecl
) = 1;
1979 DECL_IGNORED_P (idecl
) = 1;
1980 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1981 rest_of_decl_compilation (idecl
, 1, 0);
1984 constant_pool_constructor
= build_constants_constructor ();
1986 if (flag_indirect_dispatch
)
1988 TYPE_OTABLE_DECL (type
)
1990 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
1991 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
1992 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
1994 TYPE_ATABLE_DECL (type
)
1996 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
1997 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
1998 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2000 TYPE_ITABLE_DECL (type
)
2002 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2003 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2004 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2007 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2009 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
2010 PUSH_FIELD_VALUE (temp
, "vtable",
2011 (flag_indirect_classes
2013 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2014 build1 (ADDR_EXPR
, dtable_ptr_type
,
2016 dtable_start_offset
)));
2017 if (! flag_hash_synchronization
)
2018 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
2019 FINISH_RECORD_CONSTRUCTOR (temp
);
2020 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
2021 PUSH_SUPER_VALUE (cons
, temp
);
2022 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
2023 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2024 PUSH_FIELD_VALUE (cons
, "accflags",
2025 build_int_cst (NULL_TREE
,
2026 get_access_flags_from_decl (type_decl
)));
2028 PUSH_FIELD_VALUE (cons
, "superclass",
2029 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2030 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
2031 PUSH_FIELD_VALUE (cons
, "methods",
2032 methods_decl
== NULL_TREE
? null_pointer_node
2033 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2034 PUSH_FIELD_VALUE (cons
, "method_count",
2035 build_int_cst (NULL_TREE
, method_count
));
2037 if (flag_indirect_dispatch
)
2038 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
2040 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
2042 PUSH_FIELD_VALUE (cons
, "fields",
2043 fields_decl
== NULL_TREE
? null_pointer_node
2044 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2045 /* If we're using the binary compatibility ABI we don't know the
2046 size until load time. */
2047 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
2048 (flag_indirect_dispatch
2049 ? integer_minus_one_node
2050 : size_in_bytes (type
)));
2051 PUSH_FIELD_VALUE (cons
, "field_count",
2052 build_int_cst (NULL_TREE
, field_count
));
2053 PUSH_FIELD_VALUE (cons
, "static_field_count",
2054 build_int_cst (NULL_TREE
, static_field_count
));
2056 if (flag_indirect_dispatch
)
2057 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
2059 PUSH_FIELD_VALUE (cons
, "vtable",
2060 dtable_decl
== NULL_TREE
? null_pointer_node
2061 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2062 build1 (ADDR_EXPR
, dtable_ptr_type
,
2064 dtable_start_offset
));
2065 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
2067 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
2068 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
2072 pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type
));
2073 PUSH_FIELD_VALUE (cons
, "otable",
2074 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
2075 PUSH_FIELD_VALUE (cons
, "otable_syms",
2076 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2077 TYPE_OTABLE_SYMS_DECL (type
)));
2078 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
2079 TREE_INVARIANT (TYPE_OTABLE_DECL (type
)) = 1;
2081 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
2083 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
2084 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
2088 pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type
));
2089 PUSH_FIELD_VALUE (cons
, "atable",
2090 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
2091 PUSH_FIELD_VALUE (cons
, "atable_syms",
2092 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2093 TYPE_ATABLE_SYMS_DECL (type
)));
2094 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
2095 TREE_INVARIANT (TYPE_ATABLE_DECL (type
)) = 1;
2097 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
2099 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
2100 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
2104 pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type
));
2105 PUSH_FIELD_VALUE (cons
, "itable",
2106 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
2107 PUSH_FIELD_VALUE (cons
, "itable_syms",
2108 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2109 TYPE_ITABLE_SYMS_DECL (type
)));
2110 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
2111 TREE_INVARIANT (TYPE_ITABLE_DECL (type
)) = 1;
2114 PUSH_FIELD_VALUE (cons
, "catch_classes",
2115 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2116 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
2117 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
2118 PUSH_FIELD_VALUE (cons
, "interface_count",
2119 build_int_cst (NULL_TREE
, interface_len
));
2120 PUSH_FIELD_VALUE (cons
, "state",
2121 convert (byte_type_node
,
2122 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2124 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
2125 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
2126 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
2127 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
2128 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
2129 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
2132 tree assertion_table_ref
;
2133 if (TYPE_ASSERTIONS (type
) == NULL
)
2134 assertion_table_ref
= null_pointer_node
;
2136 assertion_table_ref
= build1 (ADDR_EXPR
,
2137 build_pointer_type (assertion_table_type
),
2138 emit_assertion_table (type
));
2140 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
2143 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
2144 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
2145 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
2146 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
2148 if (TYPE_REFLECTION_DATA (current_class
))
2151 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2152 VEC (constructor_elt
, gc
) *v
2153 = VEC_alloc (constructor_elt
, gc
, count
);
2154 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2155 tree max_index
= build_int_cst (sizetype
, count
);
2156 tree index
= build_index_type (max_index
);
2157 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2160 static int reflection_data_count
;
2162 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2163 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
2165 rewrite_reflection_indexes (field_indexes
);
2167 for (i
= 0; i
< count
; i
++)
2169 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
2170 elt
->index
= build_int_cst (sizetype
, i
);
2171 elt
->value
= build_int_cstu (byte_type_node
, data
[i
]);
2174 DECL_INITIAL (array
) = build_constructor (type
, v
);
2175 TREE_STATIC (array
) = 1;
2176 DECL_ARTIFICIAL (array
) = 1;
2177 DECL_IGNORED_P (array
) = 1;
2178 TREE_READONLY (array
) = 1;
2179 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2180 rest_of_decl_compilation (array
, 1, 0);
2182 PUSH_FIELD_VALUE (cons
, "reflection_data", build_address_of (array
));
2185 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2188 PUSH_FIELD_VALUE (cons
, "reflection_data", null_pointer_node
);
2190 FINISH_RECORD_CONSTRUCTOR (cons
);
2192 DECL_INITIAL (decl
) = cons
;
2194 /* Hash synchronization requires at least 64-bit alignment. */
2195 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2196 DECL_ALIGN (decl
) = 64;
2198 if (flag_indirect_classes
)
2200 TREE_READONLY (decl
) = 1;
2201 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2204 rest_of_decl_compilation (decl
, 1, 0);
2207 tree classdollar_field
= build_classdollar_field (type
);
2208 if (!flag_indirect_classes
)
2209 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2210 rest_of_decl_compilation (classdollar_field
, 1, 0);
2213 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2214 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2215 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2221 java_expand_catch_classes (current_class
);
2223 current_function_decl
= NULL_TREE
;
2224 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2225 make_class_data (current_class
);
2227 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2230 /* Return 2 if CLASS is compiled by this compilation job;
2231 return 1 if CLASS can otherwise be assumed to be compiled;
2232 return 0 if we cannot assume that CLASS is compiled.
2233 Returns 1 for primitive and 0 for array types. */
2235 is_compiled_class (tree
class)
2238 if (TREE_CODE (class) == POINTER_TYPE
)
2239 class = TREE_TYPE (class);
2240 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
2242 if (TYPE_ARRAY_P (class))
2245 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
2246 if (CLASS_FROM_CURRENTLY_COMPILED_P (class))
2248 /* The class was seen in the current ZIP file and will be
2249 available as a compiled class in the future but may not have
2250 been loaded already. Load it if necessary. This prevent
2251 build_class_ref () from crashing. */
2253 if (seen_in_zip
&& !CLASS_LOADED_P (class) && (class != current_class
))
2254 load_class (class, 1);
2256 /* We return 2 for class seen in ZIP and class from files
2257 belonging to the same compilation unit */
2261 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
2263 if (!CLASS_LOADED_P (class))
2265 if (class != current_class
)
2266 load_class (class, 1);
2274 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2277 build_dtable_decl (tree type
)
2281 /* We need to build a new dtable type so that its size is uniquely
2282 computed when we're dealing with the class for real and not just
2283 faking it (like java.lang.Class during the initialization of the
2284 compiler.) We know we're not faking a class when CURRENT_CLASS is
2286 if (current_class
== type
)
2288 tree dummy
= NULL_TREE
;
2291 dtype
= make_node (RECORD_TYPE
);
2293 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
2294 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
2296 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
2297 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2299 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2300 TREE_CHAIN (dummy
) = tmp_field
;
2301 DECL_CONTEXT (tmp_field
) = dtype
;
2302 DECL_ARTIFICIAL (tmp_field
) = 1;
2306 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
2307 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2309 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2310 TREE_CHAIN (dummy
) = tmp_field
;
2311 DECL_CONTEXT (tmp_field
) = dtype
;
2312 DECL_ARTIFICIAL (tmp_field
) = 1;
2316 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2317 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2318 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2320 PUSH_FIELD (dtype
, dummy
, "methods",
2321 build_prim_array_type (nativecode_ptr_type_node
, n
));
2322 layout_type (dtype
);
2325 dtype
= dtable_type
;
2327 decl
= build_decl (VAR_DECL
, get_identifier ("vt$"), dtype
);
2328 DECL_CONTEXT (decl
) = type
;
2329 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2330 DECL_VTABLE_P (decl
) = 1;
2335 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2336 fields inherited from SUPER_CLASS. */
2339 push_super_field (tree this_class
, tree super_class
)
2342 /* Don't insert the field if we're just re-laying the class out. */
2343 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2345 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
2346 DECL_IGNORED_P (base_decl
) = 1;
2347 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2348 TYPE_FIELDS (this_class
) = base_decl
;
2349 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2350 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2353 /* Handle the different manners we may have to lay out a super class. */
2356 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2360 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2362 if (!CLASS_LOADED_P (super_class
))
2363 load_class (super_class
, 1);
2365 /* We might have to layout the class before its dependency on
2366 the super class gets resolved by java_complete_class */
2367 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2369 if (TREE_TYPE (super_class
) != NULL_TREE
)
2370 super_class
= TREE_TYPE (super_class
);
2374 if (!TYPE_SIZE (super_class
))
2375 safe_layout_class (super_class
);
2380 /* safe_layout_class just makes sure that we can load a class without
2381 disrupting the current_class, input_file, input_line, etc, information
2382 about the class processed currently. */
2385 safe_layout_class (tree
class)
2387 tree save_current_class
= current_class
;
2388 location_t save_location
= input_location
;
2390 layout_class (class);
2392 current_class
= save_current_class
;
2393 input_location
= save_location
;
2397 layout_class (tree this_class
)
2400 tree super_class
= CLASSTYPE_SUPER (this_class
);
2402 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2403 if (CLASS_BEING_LAIDOUT (this_class
))
2409 sprintf (buffer
, " with '%s'",
2410 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2411 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2413 for (current
= TREE_CHAIN (class_list
); current
;
2414 current
= TREE_CHAIN (current
))
2416 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2417 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2418 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2419 DECL_SOURCE_FILE (decl
),
2420 DECL_SOURCE_LINE (decl
));
2421 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2423 obstack_1grow (&temporary_obstack
, '\0');
2424 report
= obstack_finish (&temporary_obstack
);
2425 cyclic_inheritance_report
= ggc_strdup (report
);
2426 obstack_free (&temporary_obstack
, report
);
2427 TYPE_SIZE (this_class
) = error_mark_node
;
2430 CLASS_BEING_LAIDOUT (this_class
) = 1;
2432 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2434 tree maybe_super_class
2435 = maybe_layout_super_class (super_class
, this_class
);
2436 if (maybe_super_class
== NULL
2437 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2439 TYPE_SIZE (this_class
) = error_mark_node
;
2440 CLASS_BEING_LAIDOUT (this_class
) = 0;
2441 class_list
= TREE_CHAIN (class_list
);
2444 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2445 push_super_field (this_class
, maybe_super_class
);
2448 layout_type (this_class
);
2450 /* Also recursively load/layout any superinterfaces. */
2451 if (TYPE_BINFO (this_class
))
2453 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2455 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2456 tree super_interface
= BINFO_TYPE (binfo
);
2457 tree maybe_super_interface
2458 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2459 if (maybe_super_interface
== NULL
2460 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2462 TYPE_SIZE (this_class
) = error_mark_node
;
2463 CLASS_BEING_LAIDOUT (this_class
) = 0;
2464 class_list
= TREE_CHAIN (class_list
);
2470 /* Convert the size back to an SI integer value. */
2471 TYPE_SIZE_UNIT (this_class
) =
2472 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2474 CLASS_BEING_LAIDOUT (this_class
) = 0;
2475 class_list
= TREE_CHAIN (class_list
);
2479 add_miranda_methods (tree base_class
, tree search_class
)
2482 tree binfo
, base_binfo
;
2484 if (!CLASS_PARSED_P (search_class
))
2485 load_class (search_class
, 1);
2487 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2488 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2491 tree elt
= BINFO_TYPE (base_binfo
);
2493 /* FIXME: This is totally bogus. We should not be handling
2494 Miranda methods at all if we're using the BC ABI. */
2495 if (TYPE_DUMMY (elt
))
2498 /* Ensure that interface methods are seen in declared order. */
2499 if (!CLASS_LOADED_P (elt
))
2500 load_class (elt
, 1);
2501 layout_class_methods (elt
);
2503 /* All base classes will have been laid out at this point, so the order
2504 will be correct. This code must match similar layout code in the
2506 for (method_decl
= TYPE_METHODS (elt
);
2507 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2511 /* An interface can have <clinit>. */
2512 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2515 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2516 override
= lookup_argument_method (base_class
,
2517 DECL_NAME (method_decl
), sig
);
2518 if (override
== NULL_TREE
)
2520 /* Found a Miranda method. Add it. */
2522 sig
= build_java_signature (TREE_TYPE (method_decl
));
2524 = add_method (base_class
,
2525 get_access_flags_from_decl (method_decl
),
2526 DECL_NAME (method_decl
), sig
);
2527 METHOD_INVISIBLE (new_method
) = 1;
2531 /* Try superinterfaces. */
2532 add_miranda_methods (base_class
, elt
);
2537 layout_class_methods (tree this_class
)
2539 tree method_decl
, dtable_count
;
2540 tree super_class
, type_name
;
2542 if (TYPE_NVIRTUALS (this_class
))
2545 super_class
= CLASSTYPE_SUPER (this_class
);
2549 super_class
= maybe_layout_super_class (super_class
, this_class
);
2550 if (!TYPE_NVIRTUALS (super_class
))
2551 layout_class_methods (super_class
);
2552 dtable_count
= TYPE_NVIRTUALS (super_class
);
2555 dtable_count
= integer_zero_node
;
2557 type_name
= TYPE_NAME (this_class
);
2558 if (!flag_indirect_dispatch
2559 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2561 /* An abstract class can have methods which are declared only in
2562 an implemented interface. These are called "Miranda
2563 methods". We make a dummy method entry for such methods
2565 add_miranda_methods (this_class
, this_class
);
2568 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2570 for (method_decl
= TYPE_METHODS (this_class
);
2571 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2572 dtable_count
= layout_class_method (this_class
, super_class
,
2573 method_decl
, dtable_count
);
2575 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2578 /* Return the index of METHOD in INTERFACE. This index begins at 1
2579 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2581 get_interface_method_index (tree method
, tree interface
)
2586 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
))
2590 /* We don't want to put <clinit> into the interface table. */
2591 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2593 gcc_assert (meth
!= NULL_TREE
);
2597 /* Lay METHOD_DECL out, returning a possibly new value of
2598 DTABLE_COUNT. Also mangle the method's name. */
2601 layout_class_method (tree this_class
, tree super_class
,
2602 tree method_decl
, tree dtable_count
)
2604 tree method_name
= DECL_NAME (method_decl
);
2606 TREE_PUBLIC (method_decl
) = 1;
2608 if (flag_indirect_classes
2609 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2610 && ! METHOD_NATIVE (method_decl
)
2611 && ! special_method_p (method_decl
)))
2612 java_hide_decl (method_decl
);
2614 /* Considered external unless it is being compiled into this object
2615 file, or it was already flagged as external. */
2616 if (!DECL_EXTERNAL (method_decl
))
2617 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2618 || METHOD_NATIVE (method_decl
));
2620 if (ID_INIT_P (method_name
))
2622 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2624 for (ptr
= p
; *ptr
; )
2629 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2630 build_java_signature (TREE_TYPE (method_decl
));
2632 else if (! METHOD_STATIC (method_decl
))
2635 build_java_signature (TREE_TYPE (method_decl
));
2636 bool method_override
= false;
2637 tree super_method
= lookup_java_method (super_class
, method_name
,
2639 if (super_method
!= NULL_TREE
2640 && ! METHOD_DUMMY (super_method
))
2642 method_override
= true;
2643 if (! METHOD_PUBLIC (super_method
) &&
2644 ! METHOD_PROTECTED (super_method
))
2646 /* Don't override private method, or default-access method in
2648 if (METHOD_PRIVATE (super_method
) ||
2649 ! in_same_package (TYPE_NAME (this_class
),
2650 TYPE_NAME (super_class
)))
2651 method_override
= false;
2654 if (method_override
)
2656 tree method_index
= get_method_index (super_method
);
2657 set_method_index (method_decl
, method_index
);
2658 if (method_index
== NULL_TREE
2659 && ! flag_indirect_dispatch
2660 && ! DECL_ARTIFICIAL (super_method
))
2661 error ("non-static method %q+D overrides static method",
2664 else if (this_class
== object_type_node
2665 && (METHOD_FINAL (method_decl
)
2666 || METHOD_PRIVATE (method_decl
)))
2668 /* We don't generate vtable entries for final Object
2669 methods. This is simply to save space, since every
2670 object would otherwise have to define them. */
2672 else if (! METHOD_PRIVATE (method_decl
)
2675 /* We generate vtable entries for final methods because they
2676 may one day be changed to non-final. */
2677 set_method_index (method_decl
, dtable_count
);
2678 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2679 dtable_count
, integer_one_node
);
2683 return dtable_count
;
2687 register_class (void)
2691 if (!registered_class
)
2692 registered_class
= VEC_alloc (tree
, gc
, 8);
2694 if (flag_indirect_classes
)
2695 node
= current_class
;
2697 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2698 VEC_safe_push (tree
, gc
, registered_class
, node
);
2701 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2702 all the classes we have emitted. */
2705 emit_indirect_register_classes (tree
*list_p
)
2707 tree klass
, t
, register_class_fn
;
2710 tree init
= NULL_TREE
;
2711 int size
= VEC_length (tree
, registered_class
) * 2 + 1;
2712 tree class_array_type
2713 = build_prim_array_type (ptr_type_node
, size
);
2714 tree
cdecl = build_decl (VAR_DECL
, get_identifier ("_Jv_CLS"),
2716 tree reg_class_list
;
2717 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2719 init
= tree_cons (NULL_TREE
,
2720 fold_convert (ptr_type_node
,
2721 build_static_class_ref (klass
)), init
);
2724 fold_convert (ptr_type_node
,
2725 build_address_of (build_classdollar_field (klass
))),
2728 init
= tree_cons (NULL_TREE
, integer_zero_node
, init
);
2729 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type
,
2731 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2732 TREE_STATIC (cdecl) = 1;
2733 DECL_ARTIFICIAL (cdecl) = 1;
2734 DECL_IGNORED_P (cdecl) = 1;
2735 TREE_READONLY (cdecl) = 1;
2736 TREE_CONSTANT (cdecl) = 1;
2737 rest_of_decl_compilation (cdecl, 1, 0);
2738 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2740 t
= build_function_type_list (void_type_node
,
2741 build_pointer_type (ptr_type_node
), NULL
);
2742 t
= build_decl (FUNCTION_DECL
,
2743 get_identifier ("_Jv_RegisterNewClasses"), t
);
2744 TREE_PUBLIC (t
) = 1;
2745 DECL_EXTERNAL (t
) = 1;
2746 register_class_fn
= t
;
2747 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2748 append_to_statement_list (t
, list_p
);
2752 /* Emit something to register classes at start-up time.
2754 The preferred mechanism is through the .jcr section, which contain
2755 a list of pointers to classes which get registered during constructor
2758 The fallback mechanism is to add statements to *LIST_P to call
2759 _Jv_RegisterClass for each class in this file. These statements will
2760 be added to a static constructor function for this translation unit. */
2763 emit_register_classes (tree
*list_p
)
2765 if (registered_class
== NULL
)
2768 if (flag_indirect_classes
)
2770 emit_indirect_register_classes (list_p
);
2774 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2775 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2776 but lack suitable crtbegin/end objects or linker support. These
2777 targets can override the default in tm.h to use the fallback mechanism. */
2778 if (TARGET_USE_JCR_SECTION
)
2783 #ifdef JCR_SECTION_NAME
2784 switch_to_section (get_section (JCR_SECTION_NAME
, SECTION_WRITE
, NULL
));
2786 /* A target has defined TARGET_USE_JCR_SECTION,
2787 but doesn't have a JCR_SECTION_NAME. */
2790 assemble_align (POINTER_SIZE
);
2792 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2794 t
= build_fold_addr_expr (klass
);
2795 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2800 tree klass
, t
, register_class_fn
;
2803 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2804 t
= build_decl (FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2805 TREE_PUBLIC (t
) = 1;
2806 DECL_EXTERNAL (t
) = 1;
2807 register_class_fn
= t
;
2809 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2811 t
= build_fold_addr_expr (klass
);
2812 t
= build_call_expr (register_class_fn
, 1, t
);
2813 append_to_statement_list (t
, list_p
);
2818 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2821 build_symbol_entry (tree decl
, tree special
)
2823 tree clname
, name
, signature
, sym
;
2824 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2825 /* ??? Constructors are given the name foo.foo all the way through
2826 the compiler, but in the method table they're all renamed
2827 foo.<init>. So, we have to do the same here unless we want an
2828 unresolved reference at runtime. */
2829 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2830 && DECL_CONSTRUCTOR_P (decl
))
2831 ? init_identifier_node
2832 : DECL_NAME (decl
));
2833 signature
= build_java_signature (TREE_TYPE (decl
));
2834 signature
= build_utf8_ref (unmangle_classname
2835 (IDENTIFIER_POINTER (signature
),
2836 IDENTIFIER_LENGTH (signature
)));
2837 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2838 signature addr+1 if SPECIAL, and this indicates to the runtime
2839 system that this is a "special" symbol, i.e. one that should
2840 bypass access controls. */
2841 if (special
!= NULL_TREE
)
2842 signature
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (signature
), signature
,
2843 fold_convert (sizetype
, special
));
2845 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2846 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2847 PUSH_FIELD_VALUE (sym
, "name", name
);
2848 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2849 FINISH_RECORD_CONSTRUCTOR (sym
);
2850 TREE_CONSTANT (sym
) = 1;
2851 TREE_INVARIANT (sym
) = 1;
2856 /* Emit a symbol table: used by -findirect-dispatch. */
2859 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2860 tree the_syms_decl
, tree the_array_element_type
,
2863 tree method_list
, method
, table
, list
, null_symbol
;
2864 tree table_size
, the_array_type
;
2867 /* Only emit a table if this translation unit actually made any
2868 references via it. */
2869 if (decl_list
== NULL_TREE
)
2872 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2874 method_list
= decl_list
;
2876 while (method_list
!= NULL_TREE
)
2878 tree special
= TREE_PURPOSE (method_list
);
2879 method
= TREE_VALUE (method_list
);
2880 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
, special
), list
);
2881 method_list
= TREE_CHAIN (method_list
);
2885 /* Terminate the list with a "null" entry. */
2886 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2887 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2888 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2889 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2890 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2891 TREE_CONSTANT (null_symbol
) = 1;
2892 TREE_INVARIANT (null_symbol
) = 1;
2893 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2895 /* Put the list in the right order and make it a constructor. */
2896 list
= nreverse (list
);
2897 table
= build_constructor_from_list (symbols_array_type
, list
);
2899 /* Make it the initial value for otable_syms and emit the decl. */
2900 DECL_INITIAL (the_syms_decl
) = table
;
2901 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2902 DECL_IGNORED_P (the_syms_decl
) = 1;
2903 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2905 /* Now that its size is known, redefine the table as an
2906 uninitialized static array of INDEX + 1 elements. The extra entry
2907 is used by the runtime to track whether the table has been
2910 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2911 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2912 the_table
= build_decl (VAR_DECL
, name
, the_array_type
);
2913 TREE_STATIC (the_table
) = 1;
2914 TREE_READONLY (the_table
) = 1;
2915 rest_of_decl_compilation (the_table
, 1, 0);
2920 /* Make an entry for the catch_classes list. */
2922 make_catch_class_record (tree catch_class
, tree classname
)
2925 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2926 START_RECORD_CONSTRUCTOR (entry
, type
);
2927 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2928 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2929 FINISH_RECORD_CONSTRUCTOR (entry
);
2934 /* Generate the list of Throwable classes that are caught by exception
2935 handlers in this class. */
2937 emit_catch_table (tree this_class
)
2939 tree table
, table_size
, array_type
;
2940 TYPE_CATCH_CLASSES (this_class
) =
2942 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2943 TYPE_CATCH_CLASSES (this_class
));
2944 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2945 TYPE_CATCH_CLASSES (this_class
) =
2947 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2948 TYPE_CATCH_CLASSES (this_class
));
2949 table_size
= build_index_type
2950 (build_int_cst (NULL_TREE
,
2951 list_length (TYPE_CATCH_CLASSES (this_class
))));
2953 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2956 build_decl (VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2957 DECL_INITIAL (table
) =
2958 build_constructor_from_list (array_type
, TYPE_CATCH_CLASSES (this_class
));
2959 TREE_STATIC (table
) = 1;
2960 TREE_READONLY (table
) = 1;
2961 DECL_IGNORED_P (table
) = 1;
2962 rest_of_decl_compilation (table
, 1, 0);
2966 /* Given a type, return the signature used by
2967 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2968 same as build_java_signature() because we want the canonical array
2972 build_signature_for_libgcj (tree type
)
2976 sig
= build_java_signature (type
);
2977 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
2978 IDENTIFIER_LENGTH (sig
)));
2982 /* Add an entry to the type assertion table. Callback used during hashtable
2986 add_assertion_table_entry (void **htab_entry
, void *ptr
)
2989 tree code_val
, op1_utf8
, op2_utf8
;
2990 tree
*list
= (tree
*) ptr
;
2991 type_assertion
*as
= (type_assertion
*) *htab_entry
;
2993 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
2995 if (as
->op1
== NULL_TREE
)
2996 op1_utf8
= null_pointer_node
;
2998 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3000 if (as
->op2
== NULL_TREE
)
3001 op2_utf8
= null_pointer_node
;
3003 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3005 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
3006 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
3007 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
3008 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
3009 FINISH_RECORD_CONSTRUCTOR (entry
);
3011 *list
= tree_cons (NULL_TREE
, entry
, *list
);
3015 /* Generate the type assertion table for CLASS, and return its DECL. */
3018 emit_assertion_table (tree
class)
3020 tree null_entry
, ctor
, table_decl
;
3021 tree list
= NULL_TREE
;
3022 htab_t assertions_htab
= TYPE_ASSERTIONS (class);
3024 /* Iterate through the hash table. */
3025 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
3027 /* Finish with a null entry. */
3028 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
3029 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
3030 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
3031 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
3032 FINISH_RECORD_CONSTRUCTOR (null_entry
);
3034 list
= tree_cons (NULL_TREE
, null_entry
, list
);
3036 /* Put the list in the right order and make it a constructor. */
3037 list
= nreverse (list
);
3038 ctor
= build_constructor_from_list (assertion_table_type
, list
);
3040 table_decl
= build_decl (VAR_DECL
, mangled_classname ("_type_assert_", class),
3041 assertion_table_type
);
3043 TREE_STATIC (table_decl
) = 1;
3044 TREE_READONLY (table_decl
) = 1;
3045 TREE_CONSTANT (table_decl
) = 1;
3046 DECL_IGNORED_P (table_decl
) = 1;
3048 DECL_INITIAL (table_decl
) = ctor
;
3049 DECL_ARTIFICIAL (table_decl
) = 1;
3050 rest_of_decl_compilation (table_decl
, 1, 0);
3056 init_class_processing (void)
3058 fields_ident
= get_identifier ("fields");
3059 info_ident
= get_identifier ("info");
3061 gcc_obstack_init (&temporary_obstack
);
3064 static hashval_t
java_treetreehash_hash (const void *);
3065 static int java_treetreehash_compare (const void *, const void *);
3067 /* A hash table mapping trees to trees. Used generally. */
3069 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3072 java_treetreehash_hash (const void *k_p
)
3074 const struct treetreehash_entry
*const k
3075 = (const struct treetreehash_entry
*) k_p
;
3076 return JAVA_TREEHASHHASH_H (k
->key
);
3080 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3082 const struct treetreehash_entry
*const k1
3083 = (const struct treetreehash_entry
*) k1_p
;
3084 const_tree
const k2
= (const_tree
) k2_p
;
3085 return (k1
->key
== k2
);
3089 java_treetreehash_find (htab_t ht
, tree t
)
3091 struct treetreehash_entry
*e
;
3092 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3093 e
= htab_find_with_hash (ht
, t
, hv
);
3101 java_treetreehash_new (htab_t ht
, tree t
)
3104 struct treetreehash_entry
*tthe
;
3105 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3107 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3110 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
3115 tthe
= (struct treetreehash_entry
*) *e
;
3116 return &tthe
->value
;
3120 java_treetreehash_create (size_t size
, int gc
)
3123 return htab_create_ggc (size
, java_treetreehash_hash
,
3124 java_treetreehash_compare
, NULL
);
3126 return htab_create_alloc (size
, java_treetreehash_hash
,
3127 java_treetreehash_compare
, free
, xcalloc
, free
);
3130 /* Break down qualified IDENTIFIER into package and class-name components.
3131 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3132 "pkg.foo", and RIGHT to "Bar". */
3135 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3138 int l
= IDENTIFIER_LENGTH (source
);
3140 base
= alloca (l
+ 1);
3141 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3143 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3145 while (*p
!= '.' && p
!= base
)
3148 /* We didn't find a '.'. Return an error. */
3154 *right
= get_identifier (p
+1);
3155 *left
= get_identifier (base
);
3160 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3161 if the classes are from the same package. */
3164 in_same_package (tree name1
, tree name2
)
3170 if (TREE_CODE (name1
) == TYPE_DECL
)
3171 name1
= DECL_NAME (name1
);
3172 if (TREE_CODE (name2
) == TYPE_DECL
)
3173 name2
= DECL_NAME (name2
);
3175 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3176 /* One in empty package. */
3179 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3180 /* Both in empty package. */
3183 split_qualified_name (&pkg1
, &tmp
, name1
);
3184 split_qualified_name (&pkg2
, &tmp
, name2
);
3186 return (pkg1
== pkg2
);
3189 #include "gt-java-class.h"