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
= (char *) 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
= (char *) 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 *type_name = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
416 char *buf = (char *) alloca (strlen (type_name) \
417 + strlen (#NAME "_syms_") + 1); \
420 sprintf (buf, #NAME "_%s", type_name); \
421 TYPE_## TABLE ##_DECL (type) = decl = \
422 build_decl (VAR_DECL, get_identifier (buf), TABLE_TYPE); \
423 DECL_EXTERNAL (decl) = 1; \
424 TREE_STATIC (decl) = 1; \
425 TREE_READONLY (decl) = 1; \
426 TREE_CONSTANT (decl) = 1; \
427 DECL_IGNORED_P (decl) = 1; \
428 /* Mark the table as belonging to this class. */ \
430 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
431 DECL_OWNER (decl) = TYPE; \
432 sprintf (buf, #NAME "_syms_%s", type_name); \
433 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
434 build_decl (VAR_DECL, get_identifier (buf), symbols_array_type); \
435 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
436 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
437 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
441 /* Given a class, create the DECLs for all its associated indirect
444 gen_indirect_dispatch_tables (tree type
)
446 const char *type_name
= IDENTIFIER_POINTER (mangled_classname ("", type
));
449 char *buf
= (char *) alloca (strlen (type_name
)
450 + strlen ("_catch_classes_") + 1);
451 tree catch_class_type
= make_node (RECORD_TYPE
);
453 sprintf (buf
, "_catch_classes_%s", type_name
);
454 PUSH_FIELD (catch_class_type
, field
, "address", utf8const_ptr_type
);
455 PUSH_FIELD (catch_class_type
, field
, "classname", ptr_type_node
);
456 FINISH_RECORD (catch_class_type
);
458 TYPE_CTABLE_DECL (type
)
459 = build_decl (VAR_DECL
, get_identifier (buf
),
460 build_array_type (catch_class_type
, 0));
461 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
462 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
463 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
464 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
465 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
466 pushdecl (TYPE_CTABLE_DECL (type
));
469 if (flag_indirect_dispatch
)
471 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
472 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
473 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
480 push_class (tree class_type
, tree class_name
)
482 tree decl
, signature
;
483 location_t saved_loc
= input_location
;
484 CLASS_P (class_type
) = 1;
485 decl
= build_decl (TYPE_DECL
, class_name
, class_type
);
486 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
488 /* dbxout needs a DECL_SIZE if in gstabs mode */
489 DECL_SIZE (decl
) = integer_zero_node
;
491 input_location
= saved_loc
;
492 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
493 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
495 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
496 both a typedef and in the struct name-space. We may want to re-visit
497 this later, but for now it reduces the changes needed for gdb. */
498 DECL_ARTIFICIAL (decl
) = 1;
500 pushdecl_top_level (decl
);
505 /* Finds the (global) class named NAME. Creates the class if not found.
506 Also creates associated TYPE_DECL.
507 Does not check if the class actually exists, load the class,
508 fill in field or methods, or do layout_type. */
511 lookup_class (tree name
)
513 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
514 if (decl
== NULL_TREE
)
515 decl
= push_class (make_class (), name
);
516 return TREE_TYPE (decl
);
520 set_super_info (int access_flags
, tree this_class
,
521 tree super_class
, int interfaces_count
)
523 int total_supers
= interfaces_count
;
524 tree class_decl
= TYPE_NAME (this_class
);
530 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
531 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
534 tree super_binfo
= make_tree_binfo (0);
535 BINFO_TYPE (super_binfo
) = super_class
;
536 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
537 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
538 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
541 set_class_decl_access_flags (access_flags
, class_decl
);
545 set_class_decl_access_flags (int access_flags
, tree class_decl
)
547 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
548 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
549 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
550 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
551 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
552 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
553 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
554 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
555 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
556 if (access_flags
& ACC_ENUM
) CLASS_ENUM (class_decl
) = 1;
557 if (access_flags
& ACC_SYNTHETIC
) CLASS_SYNTHETIC (class_decl
) = 1;
558 if (access_flags
& ACC_ANNOTATION
) CLASS_ANNOTATION (class_decl
) = 1;
561 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
562 direct sub-classes of Object are 1, and so on. */
565 class_depth (tree clas
)
568 if (! CLASS_LOADED_P (clas
))
569 load_class (clas
, 1);
570 if (TYPE_SIZE (clas
) == error_mark_node
)
572 while (clas
!= object_type_node
)
575 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
580 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
583 interface_of_p (tree type1
, tree type2
)
586 tree binfo
, base_binfo
;
588 if (! TYPE_BINFO (type2
))
591 for (binfo
= TYPE_BINFO (type2
), i
= 0;
592 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
593 if (BINFO_TYPE (base_binfo
) == type1
)
596 for (binfo
= TYPE_BINFO (type2
), i
= 0;
597 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
598 if (BINFO_TYPE (base_binfo
)
599 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
605 /* Return true iff TYPE1 inherits from TYPE2. */
608 inherits_from_p (tree type1
, tree type2
)
610 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
615 if (! CLASS_LOADED_P (type1
))
616 load_class (type1
, 1);
618 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
623 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
626 enclosing_context_p (tree type1
, tree type2
)
628 if (!INNER_CLASS_TYPE_P (type2
))
631 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
633 type2
= (INNER_CLASS_TYPE_P (type2
) ?
634 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
644 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
648 common_enclosing_context_p (tree type1
, tree type2
)
653 for (current
= type2
; current
;
654 current
= (INNER_CLASS_TYPE_P (current
) ?
655 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
657 if (type1
== current
)
660 if (INNER_CLASS_TYPE_P (type1
))
661 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
668 /* Return 1 iff there exists a common enclosing "this" between TYPE1
669 and TYPE2, without crossing any static context. */
672 common_enclosing_instance_p (tree type1
, tree type2
)
674 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
677 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
678 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
679 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
682 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
683 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
684 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
686 if (type1
== current
)
692 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
693 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
694 if attempt is made to add it twice. */
697 maybe_add_interface (tree this_class
, tree interface_class
)
699 tree binfo
, base_binfo
;
702 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
703 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
704 if (BINFO_TYPE (base_binfo
) == interface_class
)
705 return interface_class
;
706 add_interface (this_class
, interface_class
);
710 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
713 add_interface (tree this_class
, tree interface_class
)
715 tree interface_binfo
= make_tree_binfo (0);
717 BINFO_TYPE (interface_binfo
) = interface_class
;
718 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
719 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
720 BINFO_VIRTUAL_P (interface_binfo
) = 1;
722 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
726 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
728 if (access_flags
& ACC_STATIC
)
730 fntype
= build_method_type (this_class
, fntype
);
732 /* We know that arg 1 of every nonstatic method is non-null; tell
734 TYPE_ATTRIBUTES (fntype
) = (tree_cons
735 (get_identifier ("nonnull"),
736 tree_cons (NULL_TREE
,
737 build_int_cst (NULL_TREE
, 1),
739 TYPE_ATTRIBUTES (fntype
)));
744 java_hide_decl (tree decl ATTRIBUTE_UNUSED
)
746 #ifdef HAVE_GAS_HIDDEN
747 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
748 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
753 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
755 tree method_type
, fndecl
;
757 method_type
= build_java_method_type (function_type
,
758 this_class
, access_flags
);
760 fndecl
= build_decl (FUNCTION_DECL
, name
, method_type
);
761 DECL_CONTEXT (fndecl
) = this_class
;
763 DECL_LANG_SPECIFIC (fndecl
)
764 = GGC_CNEW (struct lang_decl
);
765 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
767 /* Initialize the static initializer test table. */
769 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
770 java_treetreehash_create (10, 1);
772 /* Initialize the initialized (static) class table. */
773 if (access_flags
& ACC_STATIC
)
774 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
775 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
777 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
778 TYPE_METHODS (this_class
) = fndecl
;
780 /* If pointers to member functions use the least significant bit to
781 indicate whether a function is virtual, ensure a pointer
782 to this function will have that bit clear. */
783 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
784 && !(access_flags
& ACC_STATIC
)
785 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
786 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
788 /* Notice that this is a finalizer and update the class type
789 accordingly. This is used to optimize instance allocation. */
790 if (name
== finalize_identifier_node
791 && TREE_TYPE (function_type
) == void_type_node
792 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
793 HAS_FINALIZER_P (this_class
) = 1;
795 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
796 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
797 if (access_flags
& ACC_PRIVATE
)
798 METHOD_PRIVATE (fndecl
) = DECL_INLINE (fndecl
) = 1;
799 if (access_flags
& ACC_NATIVE
)
801 METHOD_NATIVE (fndecl
) = 1;
802 DECL_EXTERNAL (fndecl
) = 1;
805 /* FNDECL is external unless we are compiling it into this object
807 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
808 if (access_flags
& ACC_STATIC
)
809 METHOD_STATIC (fndecl
) = DECL_INLINE (fndecl
) = 1;
810 if (access_flags
& ACC_FINAL
)
811 METHOD_FINAL (fndecl
) = DECL_INLINE (fndecl
) = 1;
812 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
813 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
814 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
815 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
816 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
817 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
821 /* Add a method to THIS_CLASS.
822 The method's name is NAME.
823 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
826 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
828 tree function_type
, fndecl
;
829 const unsigned char *sig
830 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
833 fatal_error ("bad method signature");
835 function_type
= get_type_from_signature (method_sig
);
836 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
837 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
842 add_field (tree klass
, tree name
, tree field_type
, int flags
)
844 int is_static
= (flags
& ACC_STATIC
) != 0;
846 field
= build_decl (is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
847 TREE_CHAIN (field
) = TYPE_FIELDS (klass
);
848 TYPE_FIELDS (klass
) = field
;
849 DECL_CONTEXT (field
) = klass
;
850 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
852 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
853 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
854 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
855 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
856 if (flags
& ACC_VOLATILE
)
858 FIELD_VOLATILE (field
) = 1;
859 TREE_THIS_VOLATILE (field
) = 1;
861 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
862 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
863 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
866 FIELD_STATIC (field
) = 1;
867 /* Always make field externally visible. This is required so
868 that native methods can always access the field. */
869 TREE_PUBLIC (field
) = 1;
870 /* Hide everything that shouldn't be visible outside a DSO. */
871 if (flag_indirect_classes
872 || (FIELD_PRIVATE (field
)))
873 java_hide_decl (field
);
874 /* Considered external unless we are compiling it into this
876 DECL_EXTERNAL (field
) = (is_compiled_class (klass
) != 2);
882 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
885 set_constant_value (tree field
, tree constant
)
887 if (field
== NULL_TREE
)
888 warning (OPT_Wattributes
,
889 "misplaced ConstantValue attribute (not in any field)");
890 else if (DECL_INITIAL (field
) != NULL_TREE
)
891 warning (OPT_Wattributes
,
892 "duplicate ConstantValue attribute for field '%s'",
893 IDENTIFIER_POINTER (DECL_NAME (field
)));
896 DECL_INITIAL (field
) = constant
;
897 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
898 && ! (TREE_TYPE (constant
) == int_type_node
899 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
900 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
901 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
902 && TREE_TYPE (field
) == string_ptr_type_node
))
903 error ("ConstantValue attribute of field '%s' has wrong type",
904 IDENTIFIER_POINTER (DECL_NAME (field
)));
908 /* Calculate a hash value for a string encoded in Utf8 format.
909 * This returns the same hash value as specified for java.lang.String.hashCode.
913 hashUtf8String (const char *str
, int len
)
915 const unsigned char* ptr
= (const unsigned char*) str
;
916 const unsigned char *limit
= ptr
+ len
;
920 int ch
= UTF8_GET (ptr
, limit
);
921 /* Updated specification from
922 http://www.javasoft.com/docs/books/jls/clarify.html. */
923 hash
= (31 * hash
) + ch
;
928 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
931 build_utf8_ref (tree name
)
933 const char * name_ptr
= IDENTIFIER_POINTER (name
);
934 int name_len
= IDENTIFIER_LENGTH (name
), name_pad
;
936 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
937 static int utf8_count
= 0;
939 tree ref
= IDENTIFIER_UTF8_REF (name
);
941 if (ref
!= NULL_TREE
)
944 ctype
= make_node (RECORD_TYPE
);
945 /* '\0' byte plus padding to utf8const_type's alignment. */
946 name_pad
= TYPE_ALIGN_UNIT (utf8const_type
)
947 - (name_len
& (TYPE_ALIGN_UNIT (utf8const_type
) - 1));
948 str_type
= build_prim_array_type (unsigned_byte_type_node
,
949 name_len
+ name_pad
);
950 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
951 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
952 PUSH_FIELD (ctype
, field
, "data", str_type
);
953 FINISH_RECORD (ctype
);
954 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
955 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
956 PUSH_FIELD_VALUE (cinit
, "hash", build_int_cst (NULL_TREE
, name_hash
));
957 PUSH_FIELD_VALUE (cinit
, "length", build_int_cst (NULL_TREE
, name_len
));
958 string
= build_string (name_len
, name_ptr
);
959 TREE_TYPE (string
) = str_type
;
960 PUSH_FIELD_VALUE (cinit
, "data", string
);
961 FINISH_RECORD_CONSTRUCTOR (cinit
);
962 TREE_CONSTANT (cinit
) = 1;
964 /* Generate a unique-enough identifier. */
965 sprintf(buf
, "_Utf%d", ++utf8_count
);
967 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
968 TREE_STATIC (decl
) = 1;
969 DECL_ARTIFICIAL (decl
) = 1;
970 DECL_IGNORED_P (decl
) = 1;
971 TREE_READONLY (decl
) = 1;
972 TREE_THIS_VOLATILE (decl
) = 0;
973 DECL_INITIAL (decl
) = cinit
;
975 if (HAVE_GAS_SHF_MERGE
)
978 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
979 decl_size
= name_len
+ 4 + name_pad
;
980 if (flag_merge_constants
&& decl_size
< 256)
983 int flags
= (SECTION_OVERRIDE
984 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
985 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
986 switch_to_section (get_section (buf
, flags
, NULL
));
987 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
991 TREE_CHAIN (decl
) = utf8_decl_list
;
992 layout_decl (decl
, 0);
994 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
995 varpool_mark_needed_node (varpool_node (decl
));
996 utf8_decl_list
= decl
;
997 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
998 IDENTIFIER_UTF8_REF (name
) = ref
;
1002 /* Like build_class_ref, but instead of a direct reference generate a
1003 pointer into the constant pool. */
1006 build_indirect_class_ref (tree type
)
1010 index
= alloc_class_constant (type
);
1011 cl
= build_ref_from_constant_pool (index
);
1012 return convert (promote_type (class_ptr_type
), cl
);
1016 build_static_class_ref (tree type
)
1018 tree decl_name
, decl
, ref
;
1020 if (TYPE_SIZE (type
) == error_mark_node
)
1021 return null_pointer_node
;
1022 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1023 "", '/', '/', ".class$$");
1024 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1025 if (decl
== NULL_TREE
)
1027 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1028 TREE_STATIC (decl
) = 1;
1029 if (! flag_indirect_classes
)
1031 TREE_PUBLIC (decl
) = 1;
1032 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1033 java_hide_decl (decl
);
1035 DECL_IGNORED_P (decl
) = 1;
1036 DECL_ARTIFICIAL (decl
) = 1;
1037 if (is_compiled_class (type
) == 1)
1038 DECL_EXTERNAL (decl
) = 1;
1039 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1040 DECL_CLASS_FIELD_P (decl
) = 1;
1041 DECL_CONTEXT (decl
) = type
;
1043 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1044 that that means not calling pushdecl_top_level. */
1045 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1048 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1053 build_classdollar_field (tree type
)
1055 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1056 "", '/', '/', ".class$");
1057 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1059 if (decl
== NULL_TREE
)
1062 = build_decl (VAR_DECL
, decl_name
,
1065 (build_type_variant (class_type_node
,
1067 /* const */ 1, 0)));
1068 TREE_STATIC (decl
) = 1;
1069 TREE_CONSTANT (decl
) = 1;
1070 TREE_READONLY (decl
) = 1;
1071 TREE_PUBLIC (decl
) = 1;
1072 java_hide_decl (decl
);
1073 DECL_IGNORED_P (decl
) = 1;
1074 DECL_ARTIFICIAL (decl
) = 1;
1075 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1076 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1077 DECL_CLASS_FIELD_P (decl
) = 1;
1078 DECL_CONTEXT (decl
) = type
;
1084 /* Create a local variable that holds the current class$. */
1087 cache_this_class_ref (tree fndecl
)
1091 tree classdollar_field
;
1092 if (flag_indirect_classes
)
1093 classdollar_field
= build_classdollar_field (output_class
);
1095 classdollar_field
= build_static_class_ref (output_class
);
1097 this_classdollar
= build_decl (VAR_DECL
, NULL_TREE
,
1098 TREE_TYPE (classdollar_field
));
1100 java_add_local_var (this_classdollar
);
1101 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1102 this_classdollar
, classdollar_field
));
1105 this_classdollar
= build_classdollar_field (output_class
);
1107 /* Prepend class initialization for static methods reachable from
1109 if (METHOD_STATIC (fndecl
)
1110 && (! METHOD_PRIVATE (fndecl
)
1111 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1112 && ! DECL_CLINIT_P (fndecl
)
1113 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1115 tree init
= build_call_expr (soft_initclass_node
, 1,
1117 java_add_stmt (init
);
1121 /* Remove the reference to the local variable that holds the current
1125 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1127 this_classdollar
= build_classdollar_field (output_class
);
1130 /* Build a reference to the class TYPE.
1131 Also handles primitive types and array types. */
1134 build_class_ref (tree type
)
1136 int is_compiled
= is_compiled_class (type
);
1140 if (TREE_CODE (type
) == POINTER_TYPE
)
1141 type
= TREE_TYPE (type
);
1143 if (flag_indirect_dispatch
1144 && type
!= output_class
1145 && TREE_CODE (type
) == RECORD_TYPE
)
1146 return build_indirect_class_ref (type
);
1148 if (type
== output_class
&& flag_indirect_classes
)
1150 /* This can be NULL if we see a JNI stub before we see any
1152 if (! this_classdollar
)
1153 this_classdollar
= build_classdollar_field (output_class
);
1154 return this_classdollar
;
1157 if (TREE_CODE (type
) == RECORD_TYPE
)
1158 return build_static_class_ref (type
);
1164 decl_name
= TYPE_NAME (type
);
1165 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1166 decl_name
= DECL_NAME (decl_name
);
1167 name
= IDENTIFIER_POINTER (decl_name
);
1168 if (strncmp (name
, "promoted_", 9) == 0)
1170 sprintf (buffer
, "_Jv_%sClass", name
);
1171 decl_name
= get_identifier (buffer
);
1172 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1173 if (decl
== NULL_TREE
)
1175 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1176 TREE_STATIC (decl
) = 1;
1177 TREE_PUBLIC (decl
) = 1;
1178 DECL_EXTERNAL (decl
) = 1;
1179 DECL_ARTIFICIAL (decl
) = 1;
1180 pushdecl_top_level (decl
);
1184 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1188 return build_indirect_class_ref (type
);
1191 /* Create a local statically allocated variable that will hold a
1192 pointer to a static field. */
1195 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1197 tree decl
, decl_name
;
1198 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1199 char *buf
= (char *) alloca (strlen (name
) + 20);
1200 sprintf (buf
, "%s_%d_ref", name
, index
);
1201 decl_name
= get_identifier (buf
);
1202 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1203 if (decl
== NULL_TREE
)
1205 decl
= build_decl (VAR_DECL
, decl_name
, ptr_type_node
);
1206 TREE_STATIC (decl
) = 1;
1207 TREE_PUBLIC (decl
) = 0;
1208 DECL_EXTERNAL (decl
) = 0;
1209 DECL_ARTIFICIAL (decl
) = 1;
1210 DECL_IGNORED_P (decl
) = 1;
1211 pushdecl_top_level (decl
);
1217 build_static_field_ref (tree fdecl
)
1219 tree fclass
= DECL_CONTEXT (fdecl
);
1220 int is_compiled
= is_compiled_class (fclass
);
1222 /* Allow static final fields to fold to a constant. When using
1223 -findirect-dispatch, we simply never do this folding if compiling
1224 from .class; in the .class file constants will be referred to via
1225 the constant pool. */
1226 if (!flag_indirect_dispatch
1228 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1229 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1230 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1231 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1233 if (is_compiled
== 1)
1234 DECL_EXTERNAL (fdecl
) = 1;
1238 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1239 and a class local static variable CACHE_ENTRY, then
1241 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1242 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1245 This can mostly be optimized away, so that the usual path is a
1246 load followed by a test and branch. _Jv_ResolvePoolEntry is
1247 only called once for each constant pool entry.
1249 There is an optimization that we don't do: at the start of a
1250 method, create a local copy of CACHE_ENTRY and use that instead.
1254 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1255 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1257 = build_call_expr (built_in_decls
[BUILT_IN_EXPECT
], 2,
1258 build2 (EQ_EXPR
, boolean_type_node
,
1259 cache_entry
, null_pointer_node
),
1260 boolean_false_node
);
1261 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1263 = build_call_expr (soft_resolvepoolentry_node
, 2,
1264 build_class_ref (output_class
),
1266 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1267 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1268 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1269 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1275 get_access_flags_from_decl (tree decl
)
1277 int access_flags
= 0;
1278 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1280 if (FIELD_STATIC (decl
))
1281 access_flags
|= ACC_STATIC
;
1282 if (FIELD_PUBLIC (decl
))
1283 access_flags
|= ACC_PUBLIC
;
1284 if (FIELD_PROTECTED (decl
))
1285 access_flags
|= ACC_PROTECTED
;
1286 if (FIELD_PRIVATE (decl
))
1287 access_flags
|= ACC_PRIVATE
;
1288 if (FIELD_FINAL (decl
))
1289 access_flags
|= ACC_FINAL
;
1290 if (FIELD_VOLATILE (decl
))
1291 access_flags
|= ACC_VOLATILE
;
1292 if (FIELD_TRANSIENT (decl
))
1293 access_flags
|= ACC_TRANSIENT
;
1294 if (FIELD_ENUM (decl
))
1295 access_flags
|= ACC_ENUM
;
1296 if (FIELD_SYNTHETIC (decl
))
1297 access_flags
|= ACC_SYNTHETIC
;
1298 return access_flags
;
1300 if (TREE_CODE (decl
) == TYPE_DECL
)
1302 if (CLASS_PUBLIC (decl
))
1303 access_flags
|= ACC_PUBLIC
;
1304 if (CLASS_FINAL (decl
))
1305 access_flags
|= ACC_FINAL
;
1306 if (CLASS_SUPER (decl
))
1307 access_flags
|= ACC_SUPER
;
1308 if (CLASS_INTERFACE (decl
))
1309 access_flags
|= ACC_INTERFACE
;
1310 if (CLASS_ABSTRACT (decl
))
1311 access_flags
|= ACC_ABSTRACT
;
1312 if (CLASS_STATIC (decl
))
1313 access_flags
|= ACC_STATIC
;
1314 if (CLASS_PRIVATE (decl
))
1315 access_flags
|= ACC_PRIVATE
;
1316 if (CLASS_PROTECTED (decl
))
1317 access_flags
|= ACC_PROTECTED
;
1318 if (CLASS_STRICTFP (decl
))
1319 access_flags
|= ACC_STRICT
;
1320 if (CLASS_ENUM (decl
))
1321 access_flags
|= ACC_ENUM
;
1322 if (CLASS_SYNTHETIC (decl
))
1323 access_flags
|= ACC_SYNTHETIC
;
1324 if (CLASS_ANNOTATION (decl
))
1325 access_flags
|= ACC_ANNOTATION
;
1326 return access_flags
;
1328 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1330 if (METHOD_PUBLIC (decl
))
1331 access_flags
|= ACC_PUBLIC
;
1332 if (METHOD_PRIVATE (decl
))
1333 access_flags
|= ACC_PRIVATE
;
1334 if (METHOD_PROTECTED (decl
))
1335 access_flags
|= ACC_PROTECTED
;
1336 if (METHOD_STATIC (decl
))
1337 access_flags
|= ACC_STATIC
;
1338 if (METHOD_FINAL (decl
))
1339 access_flags
|= ACC_FINAL
;
1340 if (METHOD_SYNCHRONIZED (decl
))
1341 access_flags
|= ACC_SYNCHRONIZED
;
1342 if (METHOD_NATIVE (decl
))
1343 access_flags
|= ACC_NATIVE
;
1344 if (METHOD_ABSTRACT (decl
))
1345 access_flags
|= ACC_ABSTRACT
;
1346 if (METHOD_STRICTFP (decl
))
1347 access_flags
|= ACC_STRICT
;
1348 if (METHOD_INVISIBLE (decl
))
1349 access_flags
|= ACC_INVISIBLE
;
1350 if (DECL_ARTIFICIAL (decl
))
1351 access_flags
|= ACC_SYNTHETIC
;
1352 if (METHOD_BRIDGE (decl
))
1353 access_flags
|= ACC_BRIDGE
;
1354 if (METHOD_VARARGS (decl
))
1355 access_flags
|= ACC_VARARGS
;
1356 return access_flags
;
1361 static GTY (()) int alias_labelno
= 0;
1363 /* Create a private alias for METHOD. Using this alias instead of the method
1364 decl ensures that ncode entries in the method table point to the real function
1365 at runtime, not a PLT entry. */
1368 make_local_function_alias (tree method
)
1370 #ifdef ASM_OUTPUT_DEF
1373 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1374 char *name
= (char *) alloca (strlen (method_name
) + 2);
1375 char *buf
= (char *) alloca (strlen (method_name
) + 128);
1377 /* Only create aliases for local functions. */
1378 if (DECL_EXTERNAL (method
))
1381 /* Prefix method_name with 'L' for the alias label. */
1383 strcpy (name
+ 1, method_name
);
1385 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1386 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
1387 TREE_TYPE (method
));
1388 DECL_CONTEXT (alias
) = NULL
;
1389 TREE_READONLY (alias
) = TREE_READONLY (method
);
1390 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1391 TREE_PUBLIC (alias
) = 0;
1392 DECL_EXTERNAL (alias
) = 0;
1393 DECL_ARTIFICIAL (alias
) = 1;
1394 DECL_INLINE (alias
) = 0;
1395 DECL_INITIAL (alias
) = error_mark_node
;
1396 TREE_ADDRESSABLE (alias
) = 1;
1397 TREE_USED (alias
) = 1;
1398 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1399 if (!flag_syntax_only
)
1400 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1407 /** Make reflection data (_Jv_Field) for field FDECL. */
1410 make_field_value (tree fdecl
)
1414 tree type
= TREE_TYPE (fdecl
);
1415 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1417 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1418 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1420 type
= build_class_ref (type
);
1423 tree signature
= build_java_signature (type
);
1425 type
= build_utf8_ref (unmangle_classname
1426 (IDENTIFIER_POINTER (signature
),
1427 IDENTIFIER_LENGTH (signature
)));
1429 PUSH_FIELD_VALUE (finit
, "type", type
);
1431 flags
= get_access_flags_from_decl (fdecl
);
1433 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1435 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1436 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1439 tree field_address
= integer_zero_node
;
1440 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1441 && FIELD_STATIC (fdecl
))
1442 field_address
= build_address_of (fdecl
);
1446 build_constructor_from_list (field_info_union_node
,
1448 ((FIELD_STATIC (fdecl
)
1449 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1450 : TYPE_FIELDS (field_info_union_node
)),
1451 (FIELD_STATIC (fdecl
)
1453 : byte_position (fdecl
)))));
1456 FINISH_RECORD_CONSTRUCTOR (finit
);
1460 /** Make reflection data (_Jv_Method) for method MDECL. */
1463 make_method_value (tree mdecl
)
1465 static int method_name_count
= 0;
1470 #define ACC_TRANSLATED 0x4000
1471 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1473 class_decl
= DECL_CONTEXT (mdecl
);
1474 /* For interfaces, the index field contains the dispatch index. */
1475 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1476 index
= build_int_cst (NULL_TREE
,
1477 get_interface_method_index (mdecl
, class_decl
));
1478 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1479 index
= get_method_index (mdecl
);
1481 index
= integer_minus_one_node
;
1483 code
= null_pointer_node
;
1484 if (METHOD_ABSTRACT (mdecl
))
1485 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1486 soft_abstractmethod_node
);
1488 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1489 make_local_function_alias (mdecl
));
1490 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1491 PUSH_FIELD_VALUE (minit
, "name",
1492 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1493 init_identifier_node
1494 : DECL_NAME (mdecl
)));
1496 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1497 PUSH_FIELD_VALUE (minit
, "signature",
1500 (IDENTIFIER_POINTER(signature
),
1501 IDENTIFIER_LENGTH(signature
)))));
1503 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1504 PUSH_FIELD_VALUE (minit
, "index", index
);
1505 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1508 /* Compute the `throws' information for the method. */
1509 tree table
= null_pointer_node
;
1510 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1512 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1513 tree iter
, type
, array
;
1516 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1517 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1519 iter
= TREE_CHAIN (iter
))
1521 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1523 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1524 IDENTIFIER_LENGTH (sig
)));
1525 table
= tree_cons (NULL_TREE
, utf8
, table
);
1527 type
= build_prim_array_type (ptr_type_node
, length
);
1528 table
= build_constructor_from_list (type
, table
);
1529 /* Compute something unique enough. */
1530 sprintf (buf
, "_methods%d", method_name_count
++);
1531 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1532 DECL_INITIAL (array
) = table
;
1533 TREE_STATIC (array
) = 1;
1534 DECL_ARTIFICIAL (array
) = 1;
1535 DECL_IGNORED_P (array
) = 1;
1536 rest_of_decl_compilation (array
, 1, 0);
1538 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1541 PUSH_FIELD_VALUE (minit
, "throws", table
);
1544 FINISH_RECORD_CONSTRUCTOR (minit
);
1549 get_dispatch_vector (tree type
)
1551 tree vtable
= TYPE_VTABLE (type
);
1553 if (vtable
== NULL_TREE
)
1557 tree super
= CLASSTYPE_SUPER (type
);
1558 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1559 vtable
= make_tree_vec (nvirtuals
);
1560 TYPE_VTABLE (type
) = vtable
;
1561 if (super
!= NULL_TREE
)
1563 tree super_vtable
= get_dispatch_vector (super
);
1565 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1566 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1569 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1570 method
= TREE_CHAIN (method
))
1572 tree method_index
= get_method_index (method
);
1573 if (method_index
!= NULL_TREE
1574 && host_integerp (method_index
, 0))
1575 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1583 get_dispatch_table (tree type
, tree this_class_addr
)
1585 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1586 tree vtable
= get_dispatch_vector (type
);
1588 tree list
= NULL_TREE
;
1589 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1593 for (i
= nvirtuals
; --i
>= 0; )
1595 tree method
= TREE_VEC_ELT (vtable
, i
);
1596 if (METHOD_ABSTRACT (method
))
1599 warning (0, "%Jabstract method in non-abstract class", method
);
1601 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1602 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1603 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1605 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1609 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1610 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1612 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1613 method
, build_int_cst (NULL_TREE
, j
));
1614 TREE_CONSTANT (fdesc
) = 1;
1615 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1618 list
= tree_cons (NULL_TREE
,
1619 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1625 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1626 using the Boehm GC we sometimes stash a GC type descriptor
1627 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1628 the emitted byte count during the output to the assembly file. */
1629 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1630 fake "function descriptor". It's first word is the is the class
1631 pointer, and subsequent words (usually one) contain the GC descriptor.
1632 In all other cases, we reserve two extra vtable slots. */
1633 gc_descr
= get_boehm_type_descriptor (type
);
1634 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1635 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1636 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1637 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1639 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1640 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1641 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1642 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1644 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1645 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1646 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1648 return build_constructor_from_list
1649 (build_prim_array_type (nativecode_ptr_type_node
,
1654 /* Set the method_index for a method decl. */
1656 set_method_index (tree decl
, tree method_index
)
1658 if (method_index
!= NULL_TREE
)
1660 /* method_index is null if we're using indirect dispatch. */
1661 method_index
= fold (convert (sizetype
, method_index
));
1663 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1664 /* Add one to skip bogus descriptor for class and GC descriptor. */
1665 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1667 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1669 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1672 DECL_VINDEX (decl
) = method_index
;
1675 /* Get the method_index for a method decl. */
1677 get_method_index (tree decl
)
1679 tree method_index
= DECL_VINDEX (decl
);
1684 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1685 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1686 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1688 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1689 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1691 return method_index
;
1695 supers_all_compiled (tree type
)
1697 while (type
!= NULL_TREE
)
1699 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1701 type
= CLASSTYPE_SUPER (type
);
1707 make_class_data (tree type
)
1709 tree decl
, cons
, temp
;
1710 tree field
, fields_decl
;
1711 tree static_fields
= NULL_TREE
;
1712 tree instance_fields
= NULL_TREE
;
1713 HOST_WIDE_INT static_field_count
= 0;
1714 HOST_WIDE_INT instance_field_count
= 0;
1715 HOST_WIDE_INT field_count
;
1716 tree field_array_type
;
1718 tree methods
= NULL_TREE
;
1719 tree dtable_decl
= NULL_TREE
;
1720 HOST_WIDE_INT method_count
= 0;
1721 tree method_array_type
;
1724 tree this_class_addr
;
1725 tree constant_pool_constructor
;
1726 tree interfaces
= null_pointer_node
;
1727 int interface_len
= 0;
1728 int uses_jv_markobj
= 0;
1729 tree type_decl
= TYPE_NAME (type
);
1730 tree id_main
= get_identifier("main");
1731 tree id_class
= get_identifier("java.lang.Class");
1732 /** Offset from start of virtual function table declaration
1733 to where objects actually point at, following new g++ ABI. */
1734 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1735 VEC(int, heap
) *field_indexes
;
1736 tree first_real_field
;
1738 this_class_addr
= build_static_class_ref (type
);
1739 decl
= TREE_OPERAND (this_class_addr
, 0);
1741 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1742 && !flag_indirect_dispatch
)
1744 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1745 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1746 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1748 /* We've already created some other class, and consequently
1749 we made class_dtable_decl. Now we just want to fill it
1751 dtable_decl
= class_dtable_decl
;
1755 dtable_decl
= build_dtable_decl (type
);
1756 TREE_STATIC (dtable_decl
) = 1;
1757 DECL_ARTIFICIAL (dtable_decl
) = 1;
1758 DECL_IGNORED_P (dtable_decl
) = 1;
1761 TREE_PUBLIC (dtable_decl
) = 1;
1762 DECL_INITIAL (dtable_decl
) = dtable
;
1763 /* The only dispatch table exported from a DSO is the dispatch
1764 table for java.lang.Class. */
1765 if (DECL_NAME (type_decl
) != id_class
)
1766 java_hide_decl (dtable_decl
);
1767 if (! flag_indirect_classes
)
1768 rest_of_decl_compilation (dtable_decl
, 1, 0);
1769 /* Maybe we're compiling Class as the first class. If so, set
1770 class_dtable_decl to the decl we just made. */
1771 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1772 class_dtable_decl
= dtable_decl
;
1775 /* Build Field array. */
1776 field
= TYPE_FIELDS (type
);
1777 while (field
&& DECL_ARTIFICIAL (field
))
1778 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1779 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1780 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1781 first_real_field
= field
;
1783 /* First count static and instance fields. */
1784 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1786 if (! DECL_ARTIFICIAL (field
))
1788 if (FIELD_STATIC (field
))
1789 static_field_count
++;
1790 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1791 instance_field_count
++;
1794 field_count
= static_field_count
+ instance_field_count
;
1795 field_indexes
= VEC_alloc (int, heap
, field_count
);
1797 /* gcj sorts fields so that static fields come first, followed by
1798 instance fields. Unfortunately, by the time this takes place we
1799 have already generated the reflection_data for this class, and
1800 that data contains indexes into the fields. So, we generate a
1801 permutation that maps each original field index to its final
1802 position. Then we pass this permutation to
1803 rewrite_reflection_indexes(), which fixes up the reflection
1807 int static_count
= 0;
1808 int instance_count
= static_field_count
;
1811 for (i
= 0, field
= first_real_field
;
1813 field
= TREE_CHAIN (field
), i
++)
1815 if (! DECL_ARTIFICIAL (field
))
1818 if (FIELD_STATIC (field
))
1819 field_index
= static_count
++;
1820 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1821 field_index
= instance_count
++;
1822 VEC_quick_push (int, field_indexes
, field_index
);
1827 for (field
= first_real_field
; field
!= NULL_TREE
;
1828 field
= TREE_CHAIN (field
))
1830 if (! DECL_ARTIFICIAL (field
))
1832 if (FIELD_STATIC (field
))
1834 /* We must always create reflection data for static fields
1835 as it is used in the creation of the field itself. */
1836 tree init
= make_field_value (field
);
1837 tree initial
= DECL_INITIAL (field
);
1838 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1839 /* If the initial value is a string constant,
1840 prevent output_constant from trying to assemble the value. */
1841 if (initial
!= NULL_TREE
1842 && TREE_TYPE (initial
) == string_ptr_type_node
)
1843 DECL_INITIAL (field
) = NULL_TREE
;
1844 rest_of_decl_compilation (field
, 1, 1);
1845 DECL_INITIAL (field
) = initial
;
1847 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1849 tree init
= make_field_value (field
);
1850 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1855 if (field_count
> 0)
1857 static_fields
= nreverse (static_fields
);
1858 instance_fields
= nreverse (instance_fields
);
1859 static_fields
= chainon (static_fields
, instance_fields
);
1860 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1861 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1863 DECL_INITIAL (fields_decl
) = build_constructor_from_list
1864 (field_array_type
, static_fields
);
1865 TREE_STATIC (fields_decl
) = 1;
1866 DECL_ARTIFICIAL (fields_decl
) = 1;
1867 DECL_IGNORED_P (fields_decl
) = 1;
1868 rest_of_decl_compilation (fields_decl
, 1, 0);
1871 fields_decl
= NULL_TREE
;
1873 /* Build Method array. */
1874 for (method
= TYPE_METHODS (type
);
1875 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1878 if (METHOD_PRIVATE (method
)
1879 && ! flag_keep_inline_functions
1882 /* Even if we have a decl, we don't necessarily have the code.
1883 This can happen if we inherit a method from a superclass for
1884 which we don't have a .class file. */
1885 if (METHOD_DUMMY (method
))
1888 /* Generate method reflection data if:
1890 - !flag_reduced_reflection.
1892 - <clinit> -- The runtime uses reflection to initialize the
1895 - Any method in class java.lang.Class -- Class.forName() and
1896 perhaps other things require it.
1898 - class$ -- It does not work if reflection data missing.
1900 - main -- Reflection is used to find main(String[]) methods.
1902 - public not static -- It is potentially part of an
1903 interface. The runtime uses reflection data to build
1904 interface dispatch tables. */
1905 if (!flag_reduced_reflection
1906 || DECL_CLINIT_P (method
)
1907 || DECL_NAME (type_decl
) == id_class
1908 || DECL_NAME (method
) == id_main
1909 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1911 init
= make_method_value (method
);
1913 methods
= tree_cons (NULL_TREE
, init
, methods
);
1916 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1917 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1919 DECL_INITIAL (methods_decl
) = build_constructor_from_list
1920 (method_array_type
, nreverse (methods
));
1921 TREE_STATIC (methods_decl
) = 1;
1922 DECL_ARTIFICIAL (methods_decl
) = 1;
1923 DECL_IGNORED_P (methods_decl
) = 1;
1924 rest_of_decl_compilation (methods_decl
, 1, 0);
1926 if (class_dtable_decl
== NULL_TREE
)
1928 class_dtable_decl
= build_dtable_decl (class_type_node
);
1929 TREE_STATIC (class_dtable_decl
) = 1;
1930 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1931 DECL_IGNORED_P (class_dtable_decl
) = 1;
1932 if (is_compiled_class (class_type_node
) != 2)
1934 DECL_EXTERNAL (class_dtable_decl
) = 1;
1935 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1939 super
= CLASSTYPE_SUPER (type
);
1940 if (super
== NULL_TREE
)
1941 super
= null_pointer_node
;
1942 else if (! flag_indirect_dispatch
1943 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1944 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1945 super
= build_class_ref (super
);
1948 int super_index
= alloc_class_constant (super
);
1949 super
= build_int_cst (ptr_type_node
, super_index
);
1952 /* Build and emit the array of implemented interfaces. */
1953 if (type
!= object_type_node
)
1954 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1956 if (interface_len
> 0)
1958 tree init
= NULL_TREE
;
1960 tree interface_array_type
, idecl
;
1961 interface_array_type
1962 = build_prim_array_type (class_ptr_type
, interface_len
);
1963 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1964 interface_array_type
);
1966 for (i
= interface_len
; i
> 0; i
--)
1968 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1969 tree iclass
= BINFO_TYPE (child
);
1971 if (! flag_indirect_dispatch
1973 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1974 index
= build_class_ref (iclass
);
1977 int int_index
= alloc_class_constant (iclass
);
1978 index
= build_int_cst (ptr_type_node
, int_index
);
1980 init
= tree_cons (NULL_TREE
, index
, init
);
1982 DECL_INITIAL (idecl
) = build_constructor_from_list (interface_array_type
,
1984 TREE_STATIC (idecl
) = 1;
1985 DECL_ARTIFICIAL (idecl
) = 1;
1986 DECL_IGNORED_P (idecl
) = 1;
1987 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1988 rest_of_decl_compilation (idecl
, 1, 0);
1991 constant_pool_constructor
= build_constants_constructor ();
1993 if (flag_indirect_dispatch
)
1995 TYPE_OTABLE_DECL (type
)
1997 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
1998 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
1999 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
2001 TYPE_ATABLE_DECL (type
)
2003 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
2004 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
2005 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2007 TYPE_ITABLE_DECL (type
)
2009 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2010 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2011 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2014 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2016 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
2017 PUSH_FIELD_VALUE (temp
, "vtable",
2018 (flag_indirect_classes
2020 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2021 build1 (ADDR_EXPR
, dtable_ptr_type
,
2023 dtable_start_offset
)));
2024 if (! flag_hash_synchronization
)
2025 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
2026 FINISH_RECORD_CONSTRUCTOR (temp
);
2027 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
2028 PUSH_SUPER_VALUE (cons
, temp
);
2029 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
2030 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2031 PUSH_FIELD_VALUE (cons
, "accflags",
2032 build_int_cst (NULL_TREE
,
2033 get_access_flags_from_decl (type_decl
)));
2035 PUSH_FIELD_VALUE (cons
, "superclass",
2036 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2037 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
2038 PUSH_FIELD_VALUE (cons
, "methods",
2039 methods_decl
== NULL_TREE
? null_pointer_node
2040 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2041 PUSH_FIELD_VALUE (cons
, "method_count",
2042 build_int_cst (NULL_TREE
, method_count
));
2044 if (flag_indirect_dispatch
)
2045 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
2047 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
2049 PUSH_FIELD_VALUE (cons
, "fields",
2050 fields_decl
== NULL_TREE
? null_pointer_node
2051 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2052 /* If we're using the binary compatibility ABI we don't know the
2053 size until load time. */
2054 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
2055 (flag_indirect_dispatch
2056 ? integer_minus_one_node
2057 : size_in_bytes (type
)));
2058 PUSH_FIELD_VALUE (cons
, "field_count",
2059 build_int_cst (NULL_TREE
, field_count
));
2060 PUSH_FIELD_VALUE (cons
, "static_field_count",
2061 build_int_cst (NULL_TREE
, static_field_count
));
2063 if (flag_indirect_dispatch
)
2064 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
2066 PUSH_FIELD_VALUE (cons
, "vtable",
2067 dtable_decl
== NULL_TREE
? null_pointer_node
2068 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2069 build1 (ADDR_EXPR
, dtable_ptr_type
,
2071 dtable_start_offset
));
2072 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
2074 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
2075 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
2079 pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type
));
2080 PUSH_FIELD_VALUE (cons
, "otable",
2081 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
2082 PUSH_FIELD_VALUE (cons
, "otable_syms",
2083 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2084 TYPE_OTABLE_SYMS_DECL (type
)));
2085 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
2087 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
2089 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
2090 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
2094 pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type
));
2095 PUSH_FIELD_VALUE (cons
, "atable",
2096 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
2097 PUSH_FIELD_VALUE (cons
, "atable_syms",
2098 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2099 TYPE_ATABLE_SYMS_DECL (type
)));
2100 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
2102 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
2104 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
2105 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
2109 pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type
));
2110 PUSH_FIELD_VALUE (cons
, "itable",
2111 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
2112 PUSH_FIELD_VALUE (cons
, "itable_syms",
2113 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2114 TYPE_ITABLE_SYMS_DECL (type
)));
2115 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
2118 PUSH_FIELD_VALUE (cons
, "catch_classes",
2119 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2120 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
2121 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
2122 PUSH_FIELD_VALUE (cons
, "interface_count",
2123 build_int_cst (NULL_TREE
, interface_len
));
2124 PUSH_FIELD_VALUE (cons
, "state",
2125 convert (byte_type_node
,
2126 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2128 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
2129 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
2130 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
2131 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
2132 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
2133 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
2136 tree assertion_table_ref
;
2137 if (TYPE_ASSERTIONS (type
) == NULL
)
2138 assertion_table_ref
= null_pointer_node
;
2140 assertion_table_ref
= build1 (ADDR_EXPR
,
2141 build_pointer_type (assertion_table_type
),
2142 emit_assertion_table (type
));
2144 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
2147 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
2148 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
2149 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
2150 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
2152 if (TYPE_REFLECTION_DATA (current_class
))
2155 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2156 VEC (constructor_elt
, gc
) *v
2157 = VEC_alloc (constructor_elt
, gc
, count
);
2158 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2159 tree max_index
= build_int_cst (sizetype
, count
);
2160 tree index
= build_index_type (max_index
);
2161 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2164 static int reflection_data_count
;
2166 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2167 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
2169 rewrite_reflection_indexes (field_indexes
);
2171 for (i
= 0; i
< count
; i
++)
2173 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
2174 elt
->index
= build_int_cst (sizetype
, i
);
2175 elt
->value
= build_int_cstu (byte_type_node
, data
[i
]);
2178 DECL_INITIAL (array
) = build_constructor (type
, v
);
2179 TREE_STATIC (array
) = 1;
2180 DECL_ARTIFICIAL (array
) = 1;
2181 DECL_IGNORED_P (array
) = 1;
2182 TREE_READONLY (array
) = 1;
2183 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2184 rest_of_decl_compilation (array
, 1, 0);
2186 PUSH_FIELD_VALUE (cons
, "reflection_data", build_address_of (array
));
2189 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2192 PUSH_FIELD_VALUE (cons
, "reflection_data", null_pointer_node
);
2194 FINISH_RECORD_CONSTRUCTOR (cons
);
2196 DECL_INITIAL (decl
) = cons
;
2198 /* Hash synchronization requires at least 64-bit alignment. */
2199 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2200 DECL_ALIGN (decl
) = 64;
2202 if (flag_indirect_classes
)
2204 TREE_READONLY (decl
) = 1;
2205 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2208 rest_of_decl_compilation (decl
, 1, 0);
2211 tree classdollar_field
= build_classdollar_field (type
);
2212 if (!flag_indirect_classes
)
2213 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2214 rest_of_decl_compilation (classdollar_field
, 1, 0);
2217 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2218 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2219 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2225 java_expand_catch_classes (current_class
);
2227 current_function_decl
= NULL_TREE
;
2228 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2229 make_class_data (current_class
);
2231 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2234 /* Return 2 if KLASS is compiled by this compilation job;
2235 return 1 if KLASS can otherwise be assumed to be compiled;
2236 return 0 if we cannot assume that KLASS is compiled.
2237 Returns 1 for primitive and 0 for array types. */
2239 is_compiled_class (tree klass
)
2242 if (TREE_CODE (klass
) == POINTER_TYPE
)
2243 klass
= TREE_TYPE (klass
);
2244 if (TREE_CODE (klass
) != RECORD_TYPE
) /* Primitive types are static. */
2246 if (TYPE_ARRAY_P (klass
))
2249 seen_in_zip
= (TYPE_JCF (klass
) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass
)));
2250 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2252 /* The class was seen in the current ZIP file and will be
2253 available as a compiled class in the future but may not have
2254 been loaded already. Load it if necessary. This prevent
2255 build_class_ref () from crashing. */
2257 if (seen_in_zip
&& !CLASS_LOADED_P (klass
) && (klass
!= current_class
))
2258 load_class (klass
, 1);
2260 /* We return 2 for class seen in ZIP and class from files
2261 belonging to the same compilation unit */
2265 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass
)))))
2267 if (!CLASS_LOADED_P (klass
))
2269 if (klass
!= current_class
)
2270 load_class (klass
, 1);
2278 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2281 build_dtable_decl (tree type
)
2285 /* We need to build a new dtable type so that its size is uniquely
2286 computed when we're dealing with the class for real and not just
2287 faking it (like java.lang.Class during the initialization of the
2288 compiler.) We know we're not faking a class when CURRENT_CLASS is
2290 if (current_class
== type
)
2292 tree dummy
= NULL_TREE
;
2295 dtype
= make_node (RECORD_TYPE
);
2297 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
2298 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
2300 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
2301 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2303 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2304 TREE_CHAIN (dummy
) = tmp_field
;
2305 DECL_CONTEXT (tmp_field
) = dtype
;
2306 DECL_ARTIFICIAL (tmp_field
) = 1;
2310 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
2311 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2313 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2314 TREE_CHAIN (dummy
) = tmp_field
;
2315 DECL_CONTEXT (tmp_field
) = dtype
;
2316 DECL_ARTIFICIAL (tmp_field
) = 1;
2320 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2321 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2322 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2324 PUSH_FIELD (dtype
, dummy
, "methods",
2325 build_prim_array_type (nativecode_ptr_type_node
, n
));
2326 layout_type (dtype
);
2329 dtype
= dtable_type
;
2331 decl
= build_decl (VAR_DECL
, get_identifier ("vt$"), dtype
);
2332 DECL_CONTEXT (decl
) = type
;
2333 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2334 DECL_VTABLE_P (decl
) = 1;
2339 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2340 fields inherited from SUPER_CLASS. */
2343 push_super_field (tree this_class
, tree super_class
)
2346 /* Don't insert the field if we're just re-laying the class out. */
2347 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2349 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
2350 DECL_IGNORED_P (base_decl
) = 1;
2351 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2352 TYPE_FIELDS (this_class
) = base_decl
;
2353 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2354 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2357 /* Handle the different manners we may have to lay out a super class. */
2360 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2364 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2366 if (!CLASS_LOADED_P (super_class
))
2367 load_class (super_class
, 1);
2369 /* We might have to layout the class before its dependency on
2370 the super class gets resolved by java_complete_class */
2371 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2373 if (TREE_TYPE (super_class
) != NULL_TREE
)
2374 super_class
= TREE_TYPE (super_class
);
2378 if (!TYPE_SIZE (super_class
))
2379 safe_layout_class (super_class
);
2384 /* safe_layout_class just makes sure that we can load a class without
2385 disrupting the current_class, input_file, input_line, etc, information
2386 about the class processed currently. */
2389 safe_layout_class (tree klass
)
2391 tree save_current_class
= current_class
;
2392 location_t save_location
= input_location
;
2394 layout_class (klass
);
2396 current_class
= save_current_class
;
2397 input_location
= save_location
;
2401 layout_class (tree this_class
)
2404 tree super_class
= CLASSTYPE_SUPER (this_class
);
2406 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2407 if (CLASS_BEING_LAIDOUT (this_class
))
2413 sprintf (buffer
, " with '%s'",
2414 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2415 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2417 for (current
= TREE_CHAIN (class_list
); current
;
2418 current
= TREE_CHAIN (current
))
2420 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2421 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2422 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2423 DECL_SOURCE_FILE (decl
),
2424 DECL_SOURCE_LINE (decl
));
2425 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2427 obstack_1grow (&temporary_obstack
, '\0');
2428 report
= XOBFINISH (&temporary_obstack
, char *);
2429 cyclic_inheritance_report
= ggc_strdup (report
);
2430 obstack_free (&temporary_obstack
, report
);
2431 TYPE_SIZE (this_class
) = error_mark_node
;
2434 CLASS_BEING_LAIDOUT (this_class
) = 1;
2436 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2438 tree maybe_super_class
2439 = maybe_layout_super_class (super_class
, this_class
);
2440 if (maybe_super_class
== NULL
2441 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2443 TYPE_SIZE (this_class
) = error_mark_node
;
2444 CLASS_BEING_LAIDOUT (this_class
) = 0;
2445 class_list
= TREE_CHAIN (class_list
);
2448 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2449 push_super_field (this_class
, maybe_super_class
);
2452 layout_type (this_class
);
2454 /* Also recursively load/layout any superinterfaces. */
2455 if (TYPE_BINFO (this_class
))
2457 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2459 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2460 tree super_interface
= BINFO_TYPE (binfo
);
2461 tree maybe_super_interface
2462 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2463 if (maybe_super_interface
== NULL
2464 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2466 TYPE_SIZE (this_class
) = error_mark_node
;
2467 CLASS_BEING_LAIDOUT (this_class
) = 0;
2468 class_list
= TREE_CHAIN (class_list
);
2474 /* Convert the size back to an SI integer value. */
2475 TYPE_SIZE_UNIT (this_class
) =
2476 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2478 CLASS_BEING_LAIDOUT (this_class
) = 0;
2479 class_list
= TREE_CHAIN (class_list
);
2483 add_miranda_methods (tree base_class
, tree search_class
)
2486 tree binfo
, base_binfo
;
2488 if (!CLASS_PARSED_P (search_class
))
2489 load_class (search_class
, 1);
2491 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2492 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2495 tree elt
= BINFO_TYPE (base_binfo
);
2497 /* FIXME: This is totally bogus. We should not be handling
2498 Miranda methods at all if we're using the BC ABI. */
2499 if (TYPE_DUMMY (elt
))
2502 /* Ensure that interface methods are seen in declared order. */
2503 if (!CLASS_LOADED_P (elt
))
2504 load_class (elt
, 1);
2505 layout_class_methods (elt
);
2507 /* All base classes will have been laid out at this point, so the order
2508 will be correct. This code must match similar layout code in the
2510 for (method_decl
= TYPE_METHODS (elt
);
2511 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2515 /* An interface can have <clinit>. */
2516 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2519 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2520 override
= lookup_argument_method (base_class
,
2521 DECL_NAME (method_decl
), sig
);
2522 if (override
== NULL_TREE
)
2524 /* Found a Miranda method. Add it. */
2526 sig
= build_java_signature (TREE_TYPE (method_decl
));
2528 = add_method (base_class
,
2529 get_access_flags_from_decl (method_decl
),
2530 DECL_NAME (method_decl
), sig
);
2531 METHOD_INVISIBLE (new_method
) = 1;
2535 /* Try superinterfaces. */
2536 add_miranda_methods (base_class
, elt
);
2541 layout_class_methods (tree this_class
)
2543 tree method_decl
, dtable_count
;
2544 tree super_class
, type_name
;
2546 if (TYPE_NVIRTUALS (this_class
))
2549 super_class
= CLASSTYPE_SUPER (this_class
);
2553 super_class
= maybe_layout_super_class (super_class
, this_class
);
2554 if (!TYPE_NVIRTUALS (super_class
))
2555 layout_class_methods (super_class
);
2556 dtable_count
= TYPE_NVIRTUALS (super_class
);
2559 dtable_count
= integer_zero_node
;
2561 type_name
= TYPE_NAME (this_class
);
2562 if (!flag_indirect_dispatch
2563 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2565 /* An abstract class can have methods which are declared only in
2566 an implemented interface. These are called "Miranda
2567 methods". We make a dummy method entry for such methods
2569 add_miranda_methods (this_class
, this_class
);
2572 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2574 for (method_decl
= TYPE_METHODS (this_class
);
2575 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2576 dtable_count
= layout_class_method (this_class
, super_class
,
2577 method_decl
, dtable_count
);
2579 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2582 /* Return the index of METHOD in INTERFACE. This index begins at 1
2583 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2585 get_interface_method_index (tree method
, tree interface
)
2590 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
))
2594 /* We don't want to put <clinit> into the interface table. */
2595 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2597 gcc_assert (meth
!= NULL_TREE
);
2601 /* Lay METHOD_DECL out, returning a possibly new value of
2602 DTABLE_COUNT. Also mangle the method's name. */
2605 layout_class_method (tree this_class
, tree super_class
,
2606 tree method_decl
, tree dtable_count
)
2608 tree method_name
= DECL_NAME (method_decl
);
2610 TREE_PUBLIC (method_decl
) = 1;
2612 if (flag_indirect_classes
2613 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2614 && ! METHOD_NATIVE (method_decl
)
2615 && ! special_method_p (method_decl
)))
2616 java_hide_decl (method_decl
);
2618 /* Considered external unless it is being compiled into this object
2619 file, or it was already flagged as external. */
2620 if (!DECL_EXTERNAL (method_decl
))
2621 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2622 || METHOD_NATIVE (method_decl
));
2624 if (ID_INIT_P (method_name
))
2626 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2628 for (ptr
= p
; *ptr
; )
2633 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2634 build_java_signature (TREE_TYPE (method_decl
));
2636 else if (! METHOD_STATIC (method_decl
))
2639 build_java_signature (TREE_TYPE (method_decl
));
2640 bool method_override
= false;
2641 tree super_method
= lookup_java_method (super_class
, method_name
,
2643 if (super_method
!= NULL_TREE
2644 && ! METHOD_DUMMY (super_method
))
2646 method_override
= true;
2647 if (! METHOD_PUBLIC (super_method
) &&
2648 ! METHOD_PROTECTED (super_method
))
2650 /* Don't override private method, or default-access method in
2652 if (METHOD_PRIVATE (super_method
) ||
2653 ! in_same_package (TYPE_NAME (this_class
),
2654 TYPE_NAME (super_class
)))
2655 method_override
= false;
2658 if (method_override
)
2660 tree method_index
= get_method_index (super_method
);
2661 set_method_index (method_decl
, method_index
);
2662 if (method_index
== NULL_TREE
2663 && ! flag_indirect_dispatch
2664 && ! DECL_ARTIFICIAL (super_method
))
2665 error ("non-static method %q+D overrides static method",
2668 else if (this_class
== object_type_node
2669 && (METHOD_FINAL (method_decl
)
2670 || METHOD_PRIVATE (method_decl
)))
2672 /* We don't generate vtable entries for final Object
2673 methods. This is simply to save space, since every
2674 object would otherwise have to define them. */
2676 else if (! METHOD_PRIVATE (method_decl
)
2679 /* We generate vtable entries for final methods because they
2680 may one day be changed to non-final. */
2681 set_method_index (method_decl
, dtable_count
);
2682 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2683 dtable_count
, integer_one_node
);
2687 return dtable_count
;
2691 register_class (void)
2695 if (!registered_class
)
2696 registered_class
= VEC_alloc (tree
, gc
, 8);
2698 if (flag_indirect_classes
)
2699 node
= current_class
;
2701 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2702 VEC_safe_push (tree
, gc
, registered_class
, node
);
2705 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2706 all the classes we have emitted. */
2709 emit_indirect_register_classes (tree
*list_p
)
2711 tree klass
, t
, register_class_fn
;
2714 tree init
= NULL_TREE
;
2715 int size
= VEC_length (tree
, registered_class
) * 2 + 1;
2716 tree class_array_type
2717 = build_prim_array_type (ptr_type_node
, size
);
2718 tree
cdecl = build_decl (VAR_DECL
, get_identifier ("_Jv_CLS"),
2720 tree reg_class_list
;
2721 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2723 init
= tree_cons (NULL_TREE
,
2724 fold_convert (ptr_type_node
,
2725 build_static_class_ref (klass
)), init
);
2728 fold_convert (ptr_type_node
,
2729 build_address_of (build_classdollar_field (klass
))),
2732 init
= tree_cons (NULL_TREE
, integer_zero_node
, init
);
2733 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type
,
2735 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2736 TREE_STATIC (cdecl) = 1;
2737 DECL_ARTIFICIAL (cdecl) = 1;
2738 DECL_IGNORED_P (cdecl) = 1;
2739 TREE_READONLY (cdecl) = 1;
2740 TREE_CONSTANT (cdecl) = 1;
2741 rest_of_decl_compilation (cdecl, 1, 0);
2742 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2744 t
= build_function_type_list (void_type_node
,
2745 build_pointer_type (ptr_type_node
), NULL
);
2746 t
= build_decl (FUNCTION_DECL
,
2747 get_identifier ("_Jv_RegisterNewClasses"), t
);
2748 TREE_PUBLIC (t
) = 1;
2749 DECL_EXTERNAL (t
) = 1;
2750 register_class_fn
= t
;
2751 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2752 append_to_statement_list (t
, list_p
);
2756 /* Emit something to register classes at start-up time.
2758 The preferred mechanism is through the .jcr section, which contain
2759 a list of pointers to classes which get registered during constructor
2762 The fallback mechanism is to add statements to *LIST_P to call
2763 _Jv_RegisterClass for each class in this file. These statements will
2764 be added to a static constructor function for this translation unit. */
2767 emit_register_classes (tree
*list_p
)
2769 if (registered_class
== NULL
)
2772 if (flag_indirect_classes
)
2774 emit_indirect_register_classes (list_p
);
2778 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2779 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2780 but lack suitable crtbegin/end objects or linker support. These
2781 targets can override the default in tm.h to use the fallback mechanism. */
2782 if (TARGET_USE_JCR_SECTION
)
2787 #ifdef JCR_SECTION_NAME
2788 switch_to_section (get_section (JCR_SECTION_NAME
, SECTION_WRITE
, NULL
));
2790 /* A target has defined TARGET_USE_JCR_SECTION,
2791 but doesn't have a JCR_SECTION_NAME. */
2794 assemble_align (POINTER_SIZE
);
2796 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2798 t
= build_fold_addr_expr (klass
);
2799 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2804 tree klass
, t
, register_class_fn
;
2807 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2808 t
= build_decl (FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2809 TREE_PUBLIC (t
) = 1;
2810 DECL_EXTERNAL (t
) = 1;
2811 register_class_fn
= t
;
2813 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2815 t
= build_fold_addr_expr (klass
);
2816 t
= build_call_expr (register_class_fn
, 1, t
);
2817 append_to_statement_list (t
, list_p
);
2822 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2825 build_symbol_entry (tree decl
, tree special
)
2827 tree clname
, name
, signature
, sym
;
2828 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2829 /* ??? Constructors are given the name foo.foo all the way through
2830 the compiler, but in the method table they're all renamed
2831 foo.<init>. So, we have to do the same here unless we want an
2832 unresolved reference at runtime. */
2833 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2834 && DECL_CONSTRUCTOR_P (decl
))
2835 ? init_identifier_node
2836 : DECL_NAME (decl
));
2837 signature
= build_java_signature (TREE_TYPE (decl
));
2838 signature
= build_utf8_ref (unmangle_classname
2839 (IDENTIFIER_POINTER (signature
),
2840 IDENTIFIER_LENGTH (signature
)));
2841 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2842 signature addr+1 if SPECIAL, and this indicates to the runtime
2843 system that this is a "special" symbol, i.e. one that should
2844 bypass access controls. */
2845 if (special
!= NULL_TREE
)
2846 signature
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (signature
), signature
,
2847 fold_convert (sizetype
, special
));
2849 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2850 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2851 PUSH_FIELD_VALUE (sym
, "name", name
);
2852 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2853 FINISH_RECORD_CONSTRUCTOR (sym
);
2854 TREE_CONSTANT (sym
) = 1;
2859 /* Emit a symbol table: used by -findirect-dispatch. */
2862 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2863 tree the_syms_decl
, tree the_array_element_type
,
2866 tree method_list
, method
, table
, list
, null_symbol
;
2867 tree table_size
, the_array_type
;
2870 /* Only emit a table if this translation unit actually made any
2871 references via it. */
2872 if (decl_list
== NULL_TREE
)
2875 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2877 method_list
= decl_list
;
2879 while (method_list
!= NULL_TREE
)
2881 tree special
= TREE_PURPOSE (method_list
);
2882 method
= TREE_VALUE (method_list
);
2883 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
, special
), list
);
2884 method_list
= TREE_CHAIN (method_list
);
2888 /* Terminate the list with a "null" entry. */
2889 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2890 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2891 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2892 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2893 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2894 TREE_CONSTANT (null_symbol
) = 1;
2895 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2897 /* Put the list in the right order and make it a constructor. */
2898 list
= nreverse (list
);
2899 table
= build_constructor_from_list (symbols_array_type
, list
);
2901 /* Make it the initial value for otable_syms and emit the decl. */
2902 DECL_INITIAL (the_syms_decl
) = table
;
2903 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2904 DECL_IGNORED_P (the_syms_decl
) = 1;
2905 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2907 /* Now that its size is known, redefine the table as an
2908 uninitialized static array of INDEX + 1 elements. The extra entry
2909 is used by the runtime to track whether the table has been
2912 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2913 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2914 the_table
= build_decl (VAR_DECL
, name
, the_array_type
);
2915 TREE_STATIC (the_table
) = 1;
2916 TREE_READONLY (the_table
) = 1;
2917 rest_of_decl_compilation (the_table
, 1, 0);
2922 /* Make an entry for the catch_classes list. */
2924 make_catch_class_record (tree catch_class
, tree classname
)
2927 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2928 START_RECORD_CONSTRUCTOR (entry
, type
);
2929 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2930 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2931 FINISH_RECORD_CONSTRUCTOR (entry
);
2936 /* Generate the list of Throwable classes that are caught by exception
2937 handlers in this class. */
2939 emit_catch_table (tree this_class
)
2941 tree table
, table_size
, array_type
;
2942 TYPE_CATCH_CLASSES (this_class
) =
2944 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2945 TYPE_CATCH_CLASSES (this_class
));
2946 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2947 TYPE_CATCH_CLASSES (this_class
) =
2949 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2950 TYPE_CATCH_CLASSES (this_class
));
2951 table_size
= build_index_type
2952 (build_int_cst (NULL_TREE
,
2953 list_length (TYPE_CATCH_CLASSES (this_class
))));
2955 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2958 build_decl (VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2959 DECL_INITIAL (table
) =
2960 build_constructor_from_list (array_type
, TYPE_CATCH_CLASSES (this_class
));
2961 TREE_STATIC (table
) = 1;
2962 TREE_READONLY (table
) = 1;
2963 DECL_IGNORED_P (table
) = 1;
2964 rest_of_decl_compilation (table
, 1, 0);
2968 /* Given a type, return the signature used by
2969 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2970 same as build_java_signature() because we want the canonical array
2974 build_signature_for_libgcj (tree type
)
2978 sig
= build_java_signature (type
);
2979 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
2980 IDENTIFIER_LENGTH (sig
)));
2984 /* Add an entry to the type assertion table. Callback used during hashtable
2988 add_assertion_table_entry (void **htab_entry
, void *ptr
)
2991 tree code_val
, op1_utf8
, op2_utf8
;
2992 tree
*list
= (tree
*) ptr
;
2993 type_assertion
*as
= (type_assertion
*) *htab_entry
;
2995 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
2997 if (as
->op1
== NULL_TREE
)
2998 op1_utf8
= null_pointer_node
;
3000 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3002 if (as
->op2
== NULL_TREE
)
3003 op2_utf8
= null_pointer_node
;
3005 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3007 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
3008 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
3009 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
3010 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
3011 FINISH_RECORD_CONSTRUCTOR (entry
);
3013 *list
= tree_cons (NULL_TREE
, entry
, *list
);
3017 /* Generate the type assertion table for KLASS, and return its DECL. */
3020 emit_assertion_table (tree klass
)
3022 tree null_entry
, ctor
, table_decl
;
3023 tree list
= NULL_TREE
;
3024 htab_t assertions_htab
= TYPE_ASSERTIONS (klass
);
3026 /* Iterate through the hash table. */
3027 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
3029 /* Finish with a null entry. */
3030 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
3031 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
3032 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
3033 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
3034 FINISH_RECORD_CONSTRUCTOR (null_entry
);
3036 list
= tree_cons (NULL_TREE
, null_entry
, list
);
3038 /* Put the list in the right order and make it a constructor. */
3039 list
= nreverse (list
);
3040 ctor
= build_constructor_from_list (assertion_table_type
, list
);
3042 table_decl
= build_decl (VAR_DECL
, mangled_classname ("_type_assert_", klass
),
3043 assertion_table_type
);
3045 TREE_STATIC (table_decl
) = 1;
3046 TREE_READONLY (table_decl
) = 1;
3047 TREE_CONSTANT (table_decl
) = 1;
3048 DECL_IGNORED_P (table_decl
) = 1;
3050 DECL_INITIAL (table_decl
) = ctor
;
3051 DECL_ARTIFICIAL (table_decl
) = 1;
3052 rest_of_decl_compilation (table_decl
, 1, 0);
3058 init_class_processing (void)
3060 fields_ident
= get_identifier ("fields");
3061 info_ident
= get_identifier ("info");
3063 gcc_obstack_init (&temporary_obstack
);
3066 static hashval_t
java_treetreehash_hash (const void *);
3067 static int java_treetreehash_compare (const void *, const void *);
3069 /* A hash table mapping trees to trees. Used generally. */
3071 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3074 java_treetreehash_hash (const void *k_p
)
3076 const struct treetreehash_entry
*const k
3077 = (const struct treetreehash_entry
*) k_p
;
3078 return JAVA_TREEHASHHASH_H (k
->key
);
3082 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3084 const struct treetreehash_entry
*const k1
3085 = (const struct treetreehash_entry
*) k1_p
;
3086 const_tree
const k2
= (const_tree
) k2_p
;
3087 return (k1
->key
== k2
);
3091 java_treetreehash_find (htab_t ht
, tree t
)
3093 struct treetreehash_entry
*e
;
3094 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3095 e
= (struct treetreehash_entry
*) htab_find_with_hash (ht
, t
, hv
);
3103 java_treetreehash_new (htab_t ht
, tree t
)
3106 struct treetreehash_entry
*tthe
;
3107 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3109 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3112 tthe
= (struct treetreehash_entry
*) (*ht
->alloc_f
) (1, sizeof (*tthe
));
3117 tthe
= (struct treetreehash_entry
*) *e
;
3118 return &tthe
->value
;
3122 java_treetreehash_create (size_t size
, int gc
)
3125 return htab_create_ggc (size
, java_treetreehash_hash
,
3126 java_treetreehash_compare
, NULL
);
3128 return htab_create_alloc (size
, java_treetreehash_hash
,
3129 java_treetreehash_compare
, free
, xcalloc
, free
);
3132 /* Break down qualified IDENTIFIER into package and class-name components.
3133 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3134 "pkg.foo", and RIGHT to "Bar". */
3137 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3140 int l
= IDENTIFIER_LENGTH (source
);
3142 base
= (char *) alloca (l
+ 1);
3143 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3145 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3147 while (*p
!= '.' && p
!= base
)
3150 /* We didn't find a '.'. Return an error. */
3156 *right
= get_identifier (p
+1);
3157 *left
= get_identifier (base
);
3162 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3163 if the classes are from the same package. */
3166 in_same_package (tree name1
, tree name2
)
3172 if (TREE_CODE (name1
) == TYPE_DECL
)
3173 name1
= DECL_NAME (name1
);
3174 if (TREE_CODE (name2
) == TYPE_DECL
)
3175 name2
= DECL_NAME (name2
);
3177 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3178 /* One in empty package. */
3181 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3182 /* Both in empty package. */
3185 split_qualified_name (&pkg1
, &tmp
, name1
);
3186 split_qualified_name (&pkg2
, &tmp
, name2
);
3188 return (pkg1
== pkg2
);
3191 #include "gt-java-class.h"