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
);
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 str_type
= build_prim_array_type (unsigned_byte_type_node
,
946 name_len
+ 1); /* Allow for final '\0'. */
947 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
948 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
949 PUSH_FIELD (ctype
, field
, "data", str_type
);
950 FINISH_RECORD (ctype
);
951 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
952 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
953 PUSH_FIELD_VALUE (cinit
, "hash", build_int_cst (NULL_TREE
, name_hash
));
954 PUSH_FIELD_VALUE (cinit
, "length", build_int_cst (NULL_TREE
, name_len
));
955 string
= build_string (name_len
, name_ptr
);
956 TREE_TYPE (string
) = str_type
;
957 PUSH_FIELD_VALUE (cinit
, "data", string
);
958 FINISH_RECORD_CONSTRUCTOR (cinit
);
959 TREE_CONSTANT (cinit
) = 1;
961 /* Generate a unique-enough identifier. */
962 sprintf(buf
, "_Utf%d", ++utf8_count
);
964 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
965 TREE_STATIC (decl
) = 1;
966 DECL_ARTIFICIAL (decl
) = 1;
967 DECL_IGNORED_P (decl
) = 1;
968 TREE_READONLY (decl
) = 1;
969 TREE_THIS_VOLATILE (decl
) = 0;
970 DECL_INITIAL (decl
) = cinit
;
972 if (HAVE_GAS_SHF_MERGE
)
975 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
976 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
977 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
978 if (flag_merge_constants
&& decl_size
< 256)
981 int flags
= (SECTION_OVERRIDE
982 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
983 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
984 switch_to_section (get_section (buf
, flags
, NULL
));
985 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
989 TREE_CHAIN (decl
) = utf8_decl_list
;
990 layout_decl (decl
, 0);
992 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
993 varpool_mark_needed_node (varpool_node (decl
));
994 utf8_decl_list
= decl
;
995 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
996 IDENTIFIER_UTF8_REF (name
) = ref
;
1000 /* Like build_class_ref, but instead of a direct reference generate a
1001 pointer into the constant pool. */
1004 build_indirect_class_ref (tree type
)
1008 index
= alloc_class_constant (type
);
1009 cl
= build_ref_from_constant_pool (index
);
1010 return convert (promote_type (class_ptr_type
), cl
);
1014 build_static_class_ref (tree type
)
1016 tree decl_name
, decl
, ref
;
1018 if (TYPE_SIZE (type
) == error_mark_node
)
1019 return null_pointer_node
;
1020 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1021 "", '/', '/', ".class$$");
1022 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1023 if (decl
== NULL_TREE
)
1025 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1026 TREE_STATIC (decl
) = 1;
1027 if (! flag_indirect_classes
)
1029 TREE_PUBLIC (decl
) = 1;
1030 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1031 java_hide_decl (decl
);
1033 DECL_IGNORED_P (decl
) = 1;
1034 DECL_ARTIFICIAL (decl
) = 1;
1035 if (is_compiled_class (type
) == 1)
1036 DECL_EXTERNAL (decl
) = 1;
1037 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1038 DECL_CLASS_FIELD_P (decl
) = 1;
1039 DECL_CONTEXT (decl
) = type
;
1041 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1042 that that means not calling pushdecl_top_level. */
1043 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1046 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1051 build_classdollar_field (tree type
)
1053 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1054 "", '/', '/', ".class$");
1055 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1057 if (decl
== NULL_TREE
)
1060 = build_decl (VAR_DECL
, decl_name
,
1063 (build_type_variant (class_type_node
,
1065 /* const */ 1, 0)));
1066 TREE_STATIC (decl
) = 1;
1067 TREE_CONSTANT (decl
) = 1;
1068 TREE_READONLY (decl
) = 1;
1069 TREE_PUBLIC (decl
) = 1;
1070 java_hide_decl (decl
);
1071 DECL_IGNORED_P (decl
) = 1;
1072 DECL_ARTIFICIAL (decl
) = 1;
1073 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1074 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1075 DECL_CLASS_FIELD_P (decl
) = 1;
1076 DECL_CONTEXT (decl
) = type
;
1082 /* Create a local variable that holds the current class$. */
1085 cache_this_class_ref (tree fndecl
)
1089 tree classdollar_field
;
1090 if (flag_indirect_classes
)
1091 classdollar_field
= build_classdollar_field (output_class
);
1093 classdollar_field
= build_static_class_ref (output_class
);
1095 this_classdollar
= build_decl (VAR_DECL
, NULL_TREE
,
1096 TREE_TYPE (classdollar_field
));
1098 java_add_local_var (this_classdollar
);
1099 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1100 this_classdollar
, classdollar_field
));
1103 this_classdollar
= build_classdollar_field (output_class
);
1105 /* Prepend class initialization for static methods reachable from
1107 if (METHOD_STATIC (fndecl
)
1108 && (! METHOD_PRIVATE (fndecl
)
1109 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1110 && ! DECL_CLINIT_P (fndecl
)
1111 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1113 tree init
= build_call_expr (soft_initclass_node
, 1,
1115 java_add_stmt (init
);
1119 /* Remove the reference to the local variable that holds the current
1123 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1125 this_classdollar
= build_classdollar_field (output_class
);
1128 /* Build a reference to the class TYPE.
1129 Also handles primitive types and array types. */
1132 build_class_ref (tree type
)
1134 int is_compiled
= is_compiled_class (type
);
1138 if (TREE_CODE (type
) == POINTER_TYPE
)
1139 type
= TREE_TYPE (type
);
1141 if (flag_indirect_dispatch
1142 && type
!= output_class
1143 && TREE_CODE (type
) == RECORD_TYPE
)
1144 return build_indirect_class_ref (type
);
1146 if (type
== output_class
&& flag_indirect_classes
)
1148 /* This can be NULL if we see a JNI stub before we see any
1150 if (! this_classdollar
)
1151 this_classdollar
= build_classdollar_field (output_class
);
1152 return this_classdollar
;
1155 if (TREE_CODE (type
) == RECORD_TYPE
)
1156 return build_static_class_ref (type
);
1162 decl_name
= TYPE_NAME (type
);
1163 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1164 decl_name
= DECL_NAME (decl_name
);
1165 name
= IDENTIFIER_POINTER (decl_name
);
1166 if (strncmp (name
, "promoted_", 9) == 0)
1168 sprintf (buffer
, "_Jv_%sClass", name
);
1169 decl_name
= get_identifier (buffer
);
1170 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1171 if (decl
== NULL_TREE
)
1173 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1174 TREE_STATIC (decl
) = 1;
1175 TREE_PUBLIC (decl
) = 1;
1176 DECL_EXTERNAL (decl
) = 1;
1177 DECL_ARTIFICIAL (decl
) = 1;
1178 pushdecl_top_level (decl
);
1182 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1186 return build_indirect_class_ref (type
);
1189 /* Create a local statically allocated variable that will hold a
1190 pointer to a static field. */
1193 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1195 tree decl
, decl_name
;
1196 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1197 char *buf
= (char *) alloca (strlen (name
) + 20);
1198 sprintf (buf
, "%s_%d_ref", name
, index
);
1199 decl_name
= get_identifier (buf
);
1200 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1201 if (decl
== NULL_TREE
)
1203 decl
= build_decl (VAR_DECL
, decl_name
, ptr_type_node
);
1204 TREE_STATIC (decl
) = 1;
1205 TREE_PUBLIC (decl
) = 0;
1206 DECL_EXTERNAL (decl
) = 0;
1207 DECL_ARTIFICIAL (decl
) = 1;
1208 DECL_IGNORED_P (decl
) = 1;
1209 pushdecl_top_level (decl
);
1215 build_static_field_ref (tree fdecl
)
1217 tree fclass
= DECL_CONTEXT (fdecl
);
1218 int is_compiled
= is_compiled_class (fclass
);
1220 /* Allow static final fields to fold to a constant. When using
1221 -findirect-dispatch, we simply never do this folding if compiling
1222 from .class; in the .class file constants will be referred to via
1223 the constant pool. */
1224 if (!flag_indirect_dispatch
1226 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1227 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1228 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1229 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1231 if (is_compiled
== 1)
1232 DECL_EXTERNAL (fdecl
) = 1;
1236 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1237 and a class local static variable CACHE_ENTRY, then
1239 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1240 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1243 This can mostly be optimized away, so that the usual path is a
1244 load followed by a test and branch. _Jv_ResolvePoolEntry is
1245 only called once for each constant pool entry.
1247 There is an optimization that we don't do: at the start of a
1248 method, create a local copy of CACHE_ENTRY and use that instead.
1252 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1253 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1255 = build_call_expr (built_in_decls
[BUILT_IN_EXPECT
], 2,
1256 build2 (EQ_EXPR
, boolean_type_node
,
1257 cache_entry
, null_pointer_node
),
1258 boolean_false_node
);
1259 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1261 = build_call_expr (soft_resolvepoolentry_node
, 2,
1262 build_class_ref (output_class
),
1264 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1265 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1266 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1267 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1273 get_access_flags_from_decl (tree decl
)
1275 int access_flags
= 0;
1276 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1278 if (FIELD_STATIC (decl
))
1279 access_flags
|= ACC_STATIC
;
1280 if (FIELD_PUBLIC (decl
))
1281 access_flags
|= ACC_PUBLIC
;
1282 if (FIELD_PROTECTED (decl
))
1283 access_flags
|= ACC_PROTECTED
;
1284 if (FIELD_PRIVATE (decl
))
1285 access_flags
|= ACC_PRIVATE
;
1286 if (FIELD_FINAL (decl
))
1287 access_flags
|= ACC_FINAL
;
1288 if (FIELD_VOLATILE (decl
))
1289 access_flags
|= ACC_VOLATILE
;
1290 if (FIELD_TRANSIENT (decl
))
1291 access_flags
|= ACC_TRANSIENT
;
1292 if (FIELD_ENUM (decl
))
1293 access_flags
|= ACC_ENUM
;
1294 if (FIELD_SYNTHETIC (decl
))
1295 access_flags
|= ACC_SYNTHETIC
;
1296 return access_flags
;
1298 if (TREE_CODE (decl
) == TYPE_DECL
)
1300 if (CLASS_PUBLIC (decl
))
1301 access_flags
|= ACC_PUBLIC
;
1302 if (CLASS_FINAL (decl
))
1303 access_flags
|= ACC_FINAL
;
1304 if (CLASS_SUPER (decl
))
1305 access_flags
|= ACC_SUPER
;
1306 if (CLASS_INTERFACE (decl
))
1307 access_flags
|= ACC_INTERFACE
;
1308 if (CLASS_ABSTRACT (decl
))
1309 access_flags
|= ACC_ABSTRACT
;
1310 if (CLASS_STATIC (decl
))
1311 access_flags
|= ACC_STATIC
;
1312 if (CLASS_PRIVATE (decl
))
1313 access_flags
|= ACC_PRIVATE
;
1314 if (CLASS_PROTECTED (decl
))
1315 access_flags
|= ACC_PROTECTED
;
1316 if (CLASS_STRICTFP (decl
))
1317 access_flags
|= ACC_STRICT
;
1318 if (CLASS_ENUM (decl
))
1319 access_flags
|= ACC_ENUM
;
1320 if (CLASS_SYNTHETIC (decl
))
1321 access_flags
|= ACC_SYNTHETIC
;
1322 if (CLASS_ANNOTATION (decl
))
1323 access_flags
|= ACC_ANNOTATION
;
1324 return access_flags
;
1326 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1328 if (METHOD_PUBLIC (decl
))
1329 access_flags
|= ACC_PUBLIC
;
1330 if (METHOD_PRIVATE (decl
))
1331 access_flags
|= ACC_PRIVATE
;
1332 if (METHOD_PROTECTED (decl
))
1333 access_flags
|= ACC_PROTECTED
;
1334 if (METHOD_STATIC (decl
))
1335 access_flags
|= ACC_STATIC
;
1336 if (METHOD_FINAL (decl
))
1337 access_flags
|= ACC_FINAL
;
1338 if (METHOD_SYNCHRONIZED (decl
))
1339 access_flags
|= ACC_SYNCHRONIZED
;
1340 if (METHOD_NATIVE (decl
))
1341 access_flags
|= ACC_NATIVE
;
1342 if (METHOD_ABSTRACT (decl
))
1343 access_flags
|= ACC_ABSTRACT
;
1344 if (METHOD_STRICTFP (decl
))
1345 access_flags
|= ACC_STRICT
;
1346 if (METHOD_INVISIBLE (decl
))
1347 access_flags
|= ACC_INVISIBLE
;
1348 if (DECL_ARTIFICIAL (decl
))
1349 access_flags
|= ACC_SYNTHETIC
;
1350 if (METHOD_BRIDGE (decl
))
1351 access_flags
|= ACC_BRIDGE
;
1352 if (METHOD_VARARGS (decl
))
1353 access_flags
|= ACC_VARARGS
;
1354 return access_flags
;
1359 static GTY (()) int alias_labelno
= 0;
1361 /* Create a private alias for METHOD. Using this alias instead of the method
1362 decl ensures that ncode entries in the method table point to the real function
1363 at runtime, not a PLT entry. */
1366 make_local_function_alias (tree method
)
1368 #ifdef ASM_OUTPUT_DEF
1371 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1372 char *name
= (char *) alloca (strlen (method_name
) + 2);
1373 char *buf
= (char *) alloca (strlen (method_name
) + 128);
1375 /* Only create aliases for local functions. */
1376 if (DECL_EXTERNAL (method
))
1379 /* Prefix method_name with 'L' for the alias label. */
1381 strcpy (name
+ 1, method_name
);
1383 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1384 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
1385 TREE_TYPE (method
));
1386 DECL_CONTEXT (alias
) = NULL
;
1387 TREE_READONLY (alias
) = TREE_READONLY (method
);
1388 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1389 TREE_PUBLIC (alias
) = 0;
1390 DECL_EXTERNAL (alias
) = 0;
1391 DECL_ARTIFICIAL (alias
) = 1;
1392 DECL_INLINE (alias
) = 0;
1393 DECL_INITIAL (alias
) = error_mark_node
;
1394 TREE_ADDRESSABLE (alias
) = 1;
1395 TREE_USED (alias
) = 1;
1396 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1397 if (!flag_syntax_only
)
1398 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1405 /** Make reflection data (_Jv_Field) for field FDECL. */
1408 make_field_value (tree fdecl
)
1412 tree type
= TREE_TYPE (fdecl
);
1413 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1415 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1416 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1418 type
= build_class_ref (type
);
1421 tree signature
= build_java_signature (type
);
1423 type
= build_utf8_ref (unmangle_classname
1424 (IDENTIFIER_POINTER (signature
),
1425 IDENTIFIER_LENGTH (signature
)));
1427 PUSH_FIELD_VALUE (finit
, "type", type
);
1429 flags
= get_access_flags_from_decl (fdecl
);
1431 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1433 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1434 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1437 tree field_address
= integer_zero_node
;
1438 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1439 && FIELD_STATIC (fdecl
))
1440 field_address
= build_address_of (fdecl
);
1444 build_constructor_from_list (field_info_union_node
,
1446 ((FIELD_STATIC (fdecl
)
1447 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1448 : TYPE_FIELDS (field_info_union_node
)),
1449 (FIELD_STATIC (fdecl
)
1451 : byte_position (fdecl
)))));
1454 FINISH_RECORD_CONSTRUCTOR (finit
);
1458 /** Make reflection data (_Jv_Method) for method MDECL. */
1461 make_method_value (tree mdecl
)
1463 static int method_name_count
= 0;
1468 #define ACC_TRANSLATED 0x4000
1469 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1471 class_decl
= DECL_CONTEXT (mdecl
);
1472 /* For interfaces, the index field contains the dispatch index. */
1473 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1474 index
= build_int_cst (NULL_TREE
,
1475 get_interface_method_index (mdecl
, class_decl
));
1476 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1477 index
= get_method_index (mdecl
);
1479 index
= integer_minus_one_node
;
1481 code
= null_pointer_node
;
1482 if (METHOD_ABSTRACT (mdecl
))
1483 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1484 soft_abstractmethod_node
);
1486 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1487 make_local_function_alias (mdecl
));
1488 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1489 PUSH_FIELD_VALUE (minit
, "name",
1490 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1491 init_identifier_node
1492 : DECL_NAME (mdecl
)));
1494 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1495 PUSH_FIELD_VALUE (minit
, "signature",
1498 (IDENTIFIER_POINTER(signature
),
1499 IDENTIFIER_LENGTH(signature
)))));
1501 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1502 PUSH_FIELD_VALUE (minit
, "index", index
);
1503 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1506 /* Compute the `throws' information for the method. */
1507 tree table
= null_pointer_node
;
1508 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1510 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1511 tree iter
, type
, array
;
1514 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1515 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1517 iter
= TREE_CHAIN (iter
))
1519 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1521 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1522 IDENTIFIER_LENGTH (sig
)));
1523 table
= tree_cons (NULL_TREE
, utf8
, table
);
1525 type
= build_prim_array_type (ptr_type_node
, length
);
1526 table
= build_constructor_from_list (type
, table
);
1527 /* Compute something unique enough. */
1528 sprintf (buf
, "_methods%d", method_name_count
++);
1529 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1530 DECL_INITIAL (array
) = table
;
1531 TREE_STATIC (array
) = 1;
1532 DECL_ARTIFICIAL (array
) = 1;
1533 DECL_IGNORED_P (array
) = 1;
1534 rest_of_decl_compilation (array
, 1, 0);
1536 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1539 PUSH_FIELD_VALUE (minit
, "throws", table
);
1542 FINISH_RECORD_CONSTRUCTOR (minit
);
1547 get_dispatch_vector (tree type
)
1549 tree vtable
= TYPE_VTABLE (type
);
1551 if (vtable
== NULL_TREE
)
1555 tree super
= CLASSTYPE_SUPER (type
);
1556 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1557 vtable
= make_tree_vec (nvirtuals
);
1558 TYPE_VTABLE (type
) = vtable
;
1559 if (super
!= NULL_TREE
)
1561 tree super_vtable
= get_dispatch_vector (super
);
1563 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1564 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1567 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1568 method
= TREE_CHAIN (method
))
1570 tree method_index
= get_method_index (method
);
1571 if (method_index
!= NULL_TREE
1572 && host_integerp (method_index
, 0))
1573 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1581 get_dispatch_table (tree type
, tree this_class_addr
)
1583 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1584 tree vtable
= get_dispatch_vector (type
);
1586 tree list
= NULL_TREE
;
1587 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1591 for (i
= nvirtuals
; --i
>= 0; )
1593 tree method
= TREE_VEC_ELT (vtable
, i
);
1594 if (METHOD_ABSTRACT (method
))
1597 warning (0, "%Jabstract method in non-abstract class", method
);
1599 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1600 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1601 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1603 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1607 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1608 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1610 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1611 method
, build_int_cst (NULL_TREE
, j
));
1612 TREE_CONSTANT (fdesc
) = 1;
1613 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1616 list
= tree_cons (NULL_TREE
,
1617 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1623 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1624 using the Boehm GC we sometimes stash a GC type descriptor
1625 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1626 the emitted byte count during the output to the assembly file. */
1627 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1628 fake "function descriptor". It's first word is the is the class
1629 pointer, and subsequent words (usually one) contain the GC descriptor.
1630 In all other cases, we reserve two extra vtable slots. */
1631 gc_descr
= get_boehm_type_descriptor (type
);
1632 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1633 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1634 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1635 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1637 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1638 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1639 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1640 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1642 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1643 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1644 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1646 return build_constructor_from_list
1647 (build_prim_array_type (nativecode_ptr_type_node
,
1652 /* Set the method_index for a method decl. */
1654 set_method_index (tree decl
, tree method_index
)
1656 if (method_index
!= NULL_TREE
)
1658 /* method_index is null if we're using indirect dispatch. */
1659 method_index
= fold (convert (sizetype
, method_index
));
1661 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1662 /* Add one to skip bogus descriptor for class and GC descriptor. */
1663 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1665 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1667 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1670 DECL_VINDEX (decl
) = method_index
;
1673 /* Get the method_index for a method decl. */
1675 get_method_index (tree decl
)
1677 tree method_index
= DECL_VINDEX (decl
);
1682 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1683 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1684 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1686 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1687 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1689 return method_index
;
1693 supers_all_compiled (tree type
)
1695 while (type
!= NULL_TREE
)
1697 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1699 type
= CLASSTYPE_SUPER (type
);
1705 make_class_data (tree type
)
1707 tree decl
, cons
, temp
;
1708 tree field
, fields_decl
;
1709 tree static_fields
= NULL_TREE
;
1710 tree instance_fields
= NULL_TREE
;
1711 HOST_WIDE_INT static_field_count
= 0;
1712 HOST_WIDE_INT instance_field_count
= 0;
1713 HOST_WIDE_INT field_count
;
1714 tree field_array_type
;
1716 tree methods
= NULL_TREE
;
1717 tree dtable_decl
= NULL_TREE
;
1718 HOST_WIDE_INT method_count
= 0;
1719 tree method_array_type
;
1722 tree this_class_addr
;
1723 tree constant_pool_constructor
;
1724 tree interfaces
= null_pointer_node
;
1725 int interface_len
= 0;
1726 int uses_jv_markobj
= 0;
1727 tree type_decl
= TYPE_NAME (type
);
1728 tree id_main
= get_identifier("main");
1729 tree id_class
= get_identifier("java.lang.Class");
1730 /** Offset from start of virtual function table declaration
1731 to where objects actually point at, following new g++ ABI. */
1732 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1733 VEC(int, heap
) *field_indexes
;
1734 tree first_real_field
;
1736 this_class_addr
= build_static_class_ref (type
);
1737 decl
= TREE_OPERAND (this_class_addr
, 0);
1739 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1740 && !flag_indirect_dispatch
)
1742 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1743 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1744 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1746 /* We've already created some other class, and consequently
1747 we made class_dtable_decl. Now we just want to fill it
1749 dtable_decl
= class_dtable_decl
;
1753 dtable_decl
= build_dtable_decl (type
);
1754 TREE_STATIC (dtable_decl
) = 1;
1755 DECL_ARTIFICIAL (dtable_decl
) = 1;
1756 DECL_IGNORED_P (dtable_decl
) = 1;
1759 TREE_PUBLIC (dtable_decl
) = 1;
1760 DECL_INITIAL (dtable_decl
) = dtable
;
1761 /* The only dispatch table exported from a DSO is the dispatch
1762 table for java.lang.Class. */
1763 if (DECL_NAME (type_decl
) != id_class
)
1764 java_hide_decl (dtable_decl
);
1765 if (! flag_indirect_classes
)
1766 rest_of_decl_compilation (dtable_decl
, 1, 0);
1767 /* Maybe we're compiling Class as the first class. If so, set
1768 class_dtable_decl to the decl we just made. */
1769 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1770 class_dtable_decl
= dtable_decl
;
1773 /* Build Field array. */
1774 field
= TYPE_FIELDS (type
);
1775 while (field
&& DECL_ARTIFICIAL (field
))
1776 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1777 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1778 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1779 first_real_field
= field
;
1781 /* First count static and instance fields. */
1782 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1784 if (! DECL_ARTIFICIAL (field
))
1786 if (FIELD_STATIC (field
))
1787 static_field_count
++;
1788 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1789 instance_field_count
++;
1792 field_count
= static_field_count
+ instance_field_count
;
1793 field_indexes
= VEC_alloc (int, heap
, field_count
);
1795 /* gcj sorts fields so that static fields come first, followed by
1796 instance fields. Unfortunately, by the time this takes place we
1797 have already generated the reflection_data for this class, and
1798 that data contains indexes into the fields. So, we generate a
1799 permutation that maps each original field index to its final
1800 position. Then we pass this permutation to
1801 rewrite_reflection_indexes(), which fixes up the reflection
1805 int static_count
= 0;
1806 int instance_count
= static_field_count
;
1809 for (i
= 0, field
= first_real_field
;
1811 field
= TREE_CHAIN (field
), i
++)
1813 if (! DECL_ARTIFICIAL (field
))
1816 if (FIELD_STATIC (field
))
1817 field_index
= static_count
++;
1818 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1819 field_index
= instance_count
++;
1820 VEC_quick_push (int, field_indexes
, field_index
);
1825 for (field
= first_real_field
; field
!= NULL_TREE
;
1826 field
= TREE_CHAIN (field
))
1828 if (! DECL_ARTIFICIAL (field
))
1830 if (FIELD_STATIC (field
))
1832 /* We must always create reflection data for static fields
1833 as it is used in the creation of the field itself. */
1834 tree init
= make_field_value (field
);
1835 tree initial
= DECL_INITIAL (field
);
1836 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1837 /* If the initial value is a string constant,
1838 prevent output_constant from trying to assemble the value. */
1839 if (initial
!= NULL_TREE
1840 && TREE_TYPE (initial
) == string_ptr_type_node
)
1841 DECL_INITIAL (field
) = NULL_TREE
;
1842 rest_of_decl_compilation (field
, 1, 1);
1843 DECL_INITIAL (field
) = initial
;
1845 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1847 tree init
= make_field_value (field
);
1848 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1853 if (field_count
> 0)
1855 static_fields
= nreverse (static_fields
);
1856 instance_fields
= nreverse (instance_fields
);
1857 static_fields
= chainon (static_fields
, instance_fields
);
1858 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1859 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1861 DECL_INITIAL (fields_decl
) = build_constructor_from_list
1862 (field_array_type
, static_fields
);
1863 TREE_STATIC (fields_decl
) = 1;
1864 DECL_ARTIFICIAL (fields_decl
) = 1;
1865 DECL_IGNORED_P (fields_decl
) = 1;
1866 rest_of_decl_compilation (fields_decl
, 1, 0);
1869 fields_decl
= NULL_TREE
;
1871 /* Build Method array. */
1872 for (method
= TYPE_METHODS (type
);
1873 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1876 if (METHOD_PRIVATE (method
)
1877 && ! flag_keep_inline_functions
1880 /* Even if we have a decl, we don't necessarily have the code.
1881 This can happen if we inherit a method from a superclass for
1882 which we don't have a .class file. */
1883 if (METHOD_DUMMY (method
))
1886 /* Generate method reflection data if:
1888 - !flag_reduced_reflection.
1890 - <clinit> -- The runtime uses reflection to initialize the
1893 - Any method in class java.lang.Class -- Class.forName() and
1894 perhaps other things require it.
1896 - class$ -- It does not work if reflection data missing.
1898 - main -- Reflection is used to find main(String[]) methods.
1900 - public not static -- It is potentially part of an
1901 interface. The runtime uses reflection data to build
1902 interface dispatch tables. */
1903 if (!flag_reduced_reflection
1904 || DECL_CLINIT_P (method
)
1905 || DECL_NAME (type_decl
) == id_class
1906 || DECL_NAME (method
) == id_main
1907 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1909 init
= make_method_value (method
);
1911 methods
= tree_cons (NULL_TREE
, init
, methods
);
1914 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1915 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1917 DECL_INITIAL (methods_decl
) = build_constructor_from_list
1918 (method_array_type
, nreverse (methods
));
1919 TREE_STATIC (methods_decl
) = 1;
1920 DECL_ARTIFICIAL (methods_decl
) = 1;
1921 DECL_IGNORED_P (methods_decl
) = 1;
1922 rest_of_decl_compilation (methods_decl
, 1, 0);
1924 if (class_dtable_decl
== NULL_TREE
)
1926 class_dtable_decl
= build_dtable_decl (class_type_node
);
1927 TREE_STATIC (class_dtable_decl
) = 1;
1928 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1929 DECL_IGNORED_P (class_dtable_decl
) = 1;
1930 if (is_compiled_class (class_type_node
) != 2)
1932 DECL_EXTERNAL (class_dtable_decl
) = 1;
1933 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1937 super
= CLASSTYPE_SUPER (type
);
1938 if (super
== NULL_TREE
)
1939 super
= null_pointer_node
;
1940 else if (! flag_indirect_dispatch
1941 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1942 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1943 super
= build_class_ref (super
);
1946 int super_index
= alloc_class_constant (super
);
1947 super
= build_int_cst (ptr_type_node
, super_index
);
1950 /* Build and emit the array of implemented interfaces. */
1951 if (type
!= object_type_node
)
1952 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1954 if (interface_len
> 0)
1956 tree init
= NULL_TREE
;
1958 tree interface_array_type
, idecl
;
1959 interface_array_type
1960 = build_prim_array_type (class_ptr_type
, interface_len
);
1961 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1962 interface_array_type
);
1964 for (i
= interface_len
; i
> 0; i
--)
1966 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1967 tree iclass
= BINFO_TYPE (child
);
1969 if (! flag_indirect_dispatch
1971 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1972 index
= build_class_ref (iclass
);
1975 int int_index
= alloc_class_constant (iclass
);
1976 index
= build_int_cst (ptr_type_node
, int_index
);
1978 init
= tree_cons (NULL_TREE
, index
, init
);
1980 DECL_INITIAL (idecl
) = build_constructor_from_list (interface_array_type
,
1982 TREE_STATIC (idecl
) = 1;
1983 DECL_ARTIFICIAL (idecl
) = 1;
1984 DECL_IGNORED_P (idecl
) = 1;
1985 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1986 rest_of_decl_compilation (idecl
, 1, 0);
1989 constant_pool_constructor
= build_constants_constructor ();
1991 if (flag_indirect_dispatch
)
1993 TYPE_OTABLE_DECL (type
)
1995 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
1996 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
1997 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
1999 TYPE_ATABLE_DECL (type
)
2001 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
2002 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
2003 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2005 TYPE_ITABLE_DECL (type
)
2007 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2008 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2009 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2012 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2014 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
2015 PUSH_FIELD_VALUE (temp
, "vtable",
2016 (flag_indirect_classes
2018 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2019 build1 (ADDR_EXPR
, dtable_ptr_type
,
2021 dtable_start_offset
)));
2022 if (! flag_hash_synchronization
)
2023 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
2024 FINISH_RECORD_CONSTRUCTOR (temp
);
2025 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
2026 PUSH_SUPER_VALUE (cons
, temp
);
2027 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
2028 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2029 PUSH_FIELD_VALUE (cons
, "accflags",
2030 build_int_cst (NULL_TREE
,
2031 get_access_flags_from_decl (type_decl
)));
2033 PUSH_FIELD_VALUE (cons
, "superclass",
2034 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2035 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
2036 PUSH_FIELD_VALUE (cons
, "methods",
2037 methods_decl
== NULL_TREE
? null_pointer_node
2038 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2039 PUSH_FIELD_VALUE (cons
, "method_count",
2040 build_int_cst (NULL_TREE
, method_count
));
2042 if (flag_indirect_dispatch
)
2043 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
2045 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
2047 PUSH_FIELD_VALUE (cons
, "fields",
2048 fields_decl
== NULL_TREE
? null_pointer_node
2049 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2050 /* If we're using the binary compatibility ABI we don't know the
2051 size until load time. */
2052 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
2053 (flag_indirect_dispatch
2054 ? integer_minus_one_node
2055 : size_in_bytes (type
)));
2056 PUSH_FIELD_VALUE (cons
, "field_count",
2057 build_int_cst (NULL_TREE
, field_count
));
2058 PUSH_FIELD_VALUE (cons
, "static_field_count",
2059 build_int_cst (NULL_TREE
, static_field_count
));
2061 if (flag_indirect_dispatch
)
2062 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
2064 PUSH_FIELD_VALUE (cons
, "vtable",
2065 dtable_decl
== NULL_TREE
? null_pointer_node
2066 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2067 build1 (ADDR_EXPR
, dtable_ptr_type
,
2069 dtable_start_offset
));
2070 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
2072 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
2073 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
2077 pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type
));
2078 PUSH_FIELD_VALUE (cons
, "otable",
2079 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
2080 PUSH_FIELD_VALUE (cons
, "otable_syms",
2081 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2082 TYPE_OTABLE_SYMS_DECL (type
)));
2083 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
2085 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
2087 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
2088 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
2092 pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type
));
2093 PUSH_FIELD_VALUE (cons
, "atable",
2094 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
2095 PUSH_FIELD_VALUE (cons
, "atable_syms",
2096 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2097 TYPE_ATABLE_SYMS_DECL (type
)));
2098 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
2100 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
2102 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
2103 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
2107 pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type
));
2108 PUSH_FIELD_VALUE (cons
, "itable",
2109 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
2110 PUSH_FIELD_VALUE (cons
, "itable_syms",
2111 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2112 TYPE_ITABLE_SYMS_DECL (type
)));
2113 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
2116 PUSH_FIELD_VALUE (cons
, "catch_classes",
2117 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2118 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
2119 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
2120 PUSH_FIELD_VALUE (cons
, "interface_count",
2121 build_int_cst (NULL_TREE
, interface_len
));
2122 PUSH_FIELD_VALUE (cons
, "state",
2123 convert (byte_type_node
,
2124 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2126 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
2127 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
2128 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
2129 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
2130 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
2131 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
2134 tree assertion_table_ref
;
2135 if (TYPE_ASSERTIONS (type
) == NULL
)
2136 assertion_table_ref
= null_pointer_node
;
2138 assertion_table_ref
= build1 (ADDR_EXPR
,
2139 build_pointer_type (assertion_table_type
),
2140 emit_assertion_table (type
));
2142 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
2145 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
2146 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
2147 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
2148 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
2150 if (TYPE_REFLECTION_DATA (current_class
))
2153 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2154 VEC (constructor_elt
, gc
) *v
2155 = VEC_alloc (constructor_elt
, gc
, count
);
2156 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2157 tree max_index
= build_int_cst (sizetype
, count
);
2158 tree index
= build_index_type (max_index
);
2159 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2162 static int reflection_data_count
;
2164 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2165 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
2167 rewrite_reflection_indexes (field_indexes
);
2169 for (i
= 0; i
< count
; i
++)
2171 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
2172 elt
->index
= build_int_cst (sizetype
, i
);
2173 elt
->value
= build_int_cstu (byte_type_node
, data
[i
]);
2176 DECL_INITIAL (array
) = build_constructor (type
, v
);
2177 TREE_STATIC (array
) = 1;
2178 DECL_ARTIFICIAL (array
) = 1;
2179 DECL_IGNORED_P (array
) = 1;
2180 TREE_READONLY (array
) = 1;
2181 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2182 rest_of_decl_compilation (array
, 1, 0);
2184 PUSH_FIELD_VALUE (cons
, "reflection_data", build_address_of (array
));
2187 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2190 PUSH_FIELD_VALUE (cons
, "reflection_data", null_pointer_node
);
2192 FINISH_RECORD_CONSTRUCTOR (cons
);
2194 DECL_INITIAL (decl
) = cons
;
2196 /* Hash synchronization requires at least 64-bit alignment. */
2197 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2198 DECL_ALIGN (decl
) = 64;
2200 if (flag_indirect_classes
)
2202 TREE_READONLY (decl
) = 1;
2203 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2206 rest_of_decl_compilation (decl
, 1, 0);
2209 tree classdollar_field
= build_classdollar_field (type
);
2210 if (!flag_indirect_classes
)
2211 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2212 rest_of_decl_compilation (classdollar_field
, 1, 0);
2215 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2216 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2217 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2223 java_expand_catch_classes (current_class
);
2225 current_function_decl
= NULL_TREE
;
2226 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2227 make_class_data (current_class
);
2229 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2232 /* Return 2 if KLASS is compiled by this compilation job;
2233 return 1 if KLASS can otherwise be assumed to be compiled;
2234 return 0 if we cannot assume that KLASS is compiled.
2235 Returns 1 for primitive and 0 for array types. */
2237 is_compiled_class (tree klass
)
2240 if (TREE_CODE (klass
) == POINTER_TYPE
)
2241 klass
= TREE_TYPE (klass
);
2242 if (TREE_CODE (klass
) != RECORD_TYPE
) /* Primitive types are static. */
2244 if (TYPE_ARRAY_P (klass
))
2247 seen_in_zip
= (TYPE_JCF (klass
) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass
)));
2248 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2250 /* The class was seen in the current ZIP file and will be
2251 available as a compiled class in the future but may not have
2252 been loaded already. Load it if necessary. This prevent
2253 build_class_ref () from crashing. */
2255 if (seen_in_zip
&& !CLASS_LOADED_P (klass
) && (klass
!= current_class
))
2256 load_class (klass
, 1);
2258 /* We return 2 for class seen in ZIP and class from files
2259 belonging to the same compilation unit */
2263 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass
)))))
2265 if (!CLASS_LOADED_P (klass
))
2267 if (klass
!= current_class
)
2268 load_class (klass
, 1);
2276 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2279 build_dtable_decl (tree type
)
2283 /* We need to build a new dtable type so that its size is uniquely
2284 computed when we're dealing with the class for real and not just
2285 faking it (like java.lang.Class during the initialization of the
2286 compiler.) We know we're not faking a class when CURRENT_CLASS is
2288 if (current_class
== type
)
2290 tree dummy
= NULL_TREE
;
2293 dtype
= make_node (RECORD_TYPE
);
2295 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
2296 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
2298 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
2299 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2301 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2302 TREE_CHAIN (dummy
) = tmp_field
;
2303 DECL_CONTEXT (tmp_field
) = dtype
;
2304 DECL_ARTIFICIAL (tmp_field
) = 1;
2308 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
2309 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2311 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2312 TREE_CHAIN (dummy
) = tmp_field
;
2313 DECL_CONTEXT (tmp_field
) = dtype
;
2314 DECL_ARTIFICIAL (tmp_field
) = 1;
2318 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2319 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2320 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2322 PUSH_FIELD (dtype
, dummy
, "methods",
2323 build_prim_array_type (nativecode_ptr_type_node
, n
));
2324 layout_type (dtype
);
2327 dtype
= dtable_type
;
2329 decl
= build_decl (VAR_DECL
, get_identifier ("vt$"), dtype
);
2330 DECL_CONTEXT (decl
) = type
;
2331 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2332 DECL_VTABLE_P (decl
) = 1;
2337 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2338 fields inherited from SUPER_CLASS. */
2341 push_super_field (tree this_class
, tree super_class
)
2344 /* Don't insert the field if we're just re-laying the class out. */
2345 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2347 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
2348 DECL_IGNORED_P (base_decl
) = 1;
2349 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2350 TYPE_FIELDS (this_class
) = base_decl
;
2351 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2352 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2355 /* Handle the different manners we may have to lay out a super class. */
2358 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2362 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2364 if (!CLASS_LOADED_P (super_class
))
2365 load_class (super_class
, 1);
2367 /* We might have to layout the class before its dependency on
2368 the super class gets resolved by java_complete_class */
2369 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2371 if (TREE_TYPE (super_class
) != NULL_TREE
)
2372 super_class
= TREE_TYPE (super_class
);
2376 if (!TYPE_SIZE (super_class
))
2377 safe_layout_class (super_class
);
2382 /* safe_layout_class just makes sure that we can load a class without
2383 disrupting the current_class, input_file, input_line, etc, information
2384 about the class processed currently. */
2387 safe_layout_class (tree klass
)
2389 tree save_current_class
= current_class
;
2390 location_t save_location
= input_location
;
2392 layout_class (klass
);
2394 current_class
= save_current_class
;
2395 input_location
= save_location
;
2399 layout_class (tree this_class
)
2402 tree super_class
= CLASSTYPE_SUPER (this_class
);
2404 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2405 if (CLASS_BEING_LAIDOUT (this_class
))
2411 sprintf (buffer
, " with '%s'",
2412 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2413 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2415 for (current
= TREE_CHAIN (class_list
); current
;
2416 current
= TREE_CHAIN (current
))
2418 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2419 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2420 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2421 DECL_SOURCE_FILE (decl
),
2422 DECL_SOURCE_LINE (decl
));
2423 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2425 obstack_1grow (&temporary_obstack
, '\0');
2426 report
= XOBFINISH (&temporary_obstack
, char *);
2427 cyclic_inheritance_report
= ggc_strdup (report
);
2428 obstack_free (&temporary_obstack
, report
);
2429 TYPE_SIZE (this_class
) = error_mark_node
;
2432 CLASS_BEING_LAIDOUT (this_class
) = 1;
2434 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2436 tree maybe_super_class
2437 = maybe_layout_super_class (super_class
, this_class
);
2438 if (maybe_super_class
== NULL
2439 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2441 TYPE_SIZE (this_class
) = error_mark_node
;
2442 CLASS_BEING_LAIDOUT (this_class
) = 0;
2443 class_list
= TREE_CHAIN (class_list
);
2446 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2447 push_super_field (this_class
, maybe_super_class
);
2450 layout_type (this_class
);
2452 /* Also recursively load/layout any superinterfaces. */
2453 if (TYPE_BINFO (this_class
))
2455 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2457 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2458 tree super_interface
= BINFO_TYPE (binfo
);
2459 tree maybe_super_interface
2460 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2461 if (maybe_super_interface
== NULL
2462 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2464 TYPE_SIZE (this_class
) = error_mark_node
;
2465 CLASS_BEING_LAIDOUT (this_class
) = 0;
2466 class_list
= TREE_CHAIN (class_list
);
2472 /* Convert the size back to an SI integer value. */
2473 TYPE_SIZE_UNIT (this_class
) =
2474 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2476 CLASS_BEING_LAIDOUT (this_class
) = 0;
2477 class_list
= TREE_CHAIN (class_list
);
2481 add_miranda_methods (tree base_class
, tree search_class
)
2484 tree binfo
, base_binfo
;
2486 if (!CLASS_PARSED_P (search_class
))
2487 load_class (search_class
, 1);
2489 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2490 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2493 tree elt
= BINFO_TYPE (base_binfo
);
2495 /* FIXME: This is totally bogus. We should not be handling
2496 Miranda methods at all if we're using the BC ABI. */
2497 if (TYPE_DUMMY (elt
))
2500 /* Ensure that interface methods are seen in declared order. */
2501 if (!CLASS_LOADED_P (elt
))
2502 load_class (elt
, 1);
2503 layout_class_methods (elt
);
2505 /* All base classes will have been laid out at this point, so the order
2506 will be correct. This code must match similar layout code in the
2508 for (method_decl
= TYPE_METHODS (elt
);
2509 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2513 /* An interface can have <clinit>. */
2514 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2517 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2518 override
= lookup_argument_method (base_class
,
2519 DECL_NAME (method_decl
), sig
);
2520 if (override
== NULL_TREE
)
2522 /* Found a Miranda method. Add it. */
2524 sig
= build_java_signature (TREE_TYPE (method_decl
));
2526 = add_method (base_class
,
2527 get_access_flags_from_decl (method_decl
),
2528 DECL_NAME (method_decl
), sig
);
2529 METHOD_INVISIBLE (new_method
) = 1;
2533 /* Try superinterfaces. */
2534 add_miranda_methods (base_class
, elt
);
2539 layout_class_methods (tree this_class
)
2541 tree method_decl
, dtable_count
;
2542 tree super_class
, type_name
;
2544 if (TYPE_NVIRTUALS (this_class
))
2547 super_class
= CLASSTYPE_SUPER (this_class
);
2551 super_class
= maybe_layout_super_class (super_class
, this_class
);
2552 if (!TYPE_NVIRTUALS (super_class
))
2553 layout_class_methods (super_class
);
2554 dtable_count
= TYPE_NVIRTUALS (super_class
);
2557 dtable_count
= integer_zero_node
;
2559 type_name
= TYPE_NAME (this_class
);
2560 if (!flag_indirect_dispatch
2561 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2563 /* An abstract class can have methods which are declared only in
2564 an implemented interface. These are called "Miranda
2565 methods". We make a dummy method entry for such methods
2567 add_miranda_methods (this_class
, this_class
);
2570 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2572 for (method_decl
= TYPE_METHODS (this_class
);
2573 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2574 dtable_count
= layout_class_method (this_class
, super_class
,
2575 method_decl
, dtable_count
);
2577 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2580 /* Return the index of METHOD in INTERFACE. This index begins at 1
2581 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2583 get_interface_method_index (tree method
, tree interface
)
2588 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
))
2592 /* We don't want to put <clinit> into the interface table. */
2593 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2595 gcc_assert (meth
!= NULL_TREE
);
2599 /* Lay METHOD_DECL out, returning a possibly new value of
2600 DTABLE_COUNT. Also mangle the method's name. */
2603 layout_class_method (tree this_class
, tree super_class
,
2604 tree method_decl
, tree dtable_count
)
2606 tree method_name
= DECL_NAME (method_decl
);
2608 TREE_PUBLIC (method_decl
) = 1;
2610 if (flag_indirect_classes
2611 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2612 && ! METHOD_NATIVE (method_decl
)
2613 && ! special_method_p (method_decl
)))
2614 java_hide_decl (method_decl
);
2616 /* Considered external unless it is being compiled into this object
2617 file, or it was already flagged as external. */
2618 if (!DECL_EXTERNAL (method_decl
))
2619 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2620 || METHOD_NATIVE (method_decl
));
2622 if (ID_INIT_P (method_name
))
2624 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2626 for (ptr
= p
; *ptr
; )
2631 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2632 build_java_signature (TREE_TYPE (method_decl
));
2634 else if (! METHOD_STATIC (method_decl
))
2637 build_java_signature (TREE_TYPE (method_decl
));
2638 bool method_override
= false;
2639 tree super_method
= lookup_java_method (super_class
, method_name
,
2641 if (super_method
!= NULL_TREE
2642 && ! METHOD_DUMMY (super_method
))
2644 method_override
= true;
2645 if (! METHOD_PUBLIC (super_method
) &&
2646 ! METHOD_PROTECTED (super_method
))
2648 /* Don't override private method, or default-access method in
2650 if (METHOD_PRIVATE (super_method
) ||
2651 ! in_same_package (TYPE_NAME (this_class
),
2652 TYPE_NAME (super_class
)))
2653 method_override
= false;
2656 if (method_override
)
2658 tree method_index
= get_method_index (super_method
);
2659 set_method_index (method_decl
, method_index
);
2660 if (method_index
== NULL_TREE
2661 && ! flag_indirect_dispatch
2662 && ! DECL_ARTIFICIAL (super_method
))
2663 error ("non-static method %q+D overrides static method",
2666 else if (this_class
== object_type_node
2667 && (METHOD_FINAL (method_decl
)
2668 || METHOD_PRIVATE (method_decl
)))
2670 /* We don't generate vtable entries for final Object
2671 methods. This is simply to save space, since every
2672 object would otherwise have to define them. */
2674 else if (! METHOD_PRIVATE (method_decl
)
2677 /* We generate vtable entries for final methods because they
2678 may one day be changed to non-final. */
2679 set_method_index (method_decl
, dtable_count
);
2680 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2681 dtable_count
, integer_one_node
);
2685 return dtable_count
;
2689 register_class (void)
2693 if (!registered_class
)
2694 registered_class
= VEC_alloc (tree
, gc
, 8);
2696 if (flag_indirect_classes
)
2697 node
= current_class
;
2699 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2700 VEC_safe_push (tree
, gc
, registered_class
, node
);
2703 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2704 all the classes we have emitted. */
2707 emit_indirect_register_classes (tree
*list_p
)
2709 tree klass
, t
, register_class_fn
;
2712 tree init
= NULL_TREE
;
2713 int size
= VEC_length (tree
, registered_class
) * 2 + 1;
2714 tree class_array_type
2715 = build_prim_array_type (ptr_type_node
, size
);
2716 tree
cdecl = build_decl (VAR_DECL
, get_identifier ("_Jv_CLS"),
2718 tree reg_class_list
;
2719 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2721 init
= tree_cons (NULL_TREE
,
2722 fold_convert (ptr_type_node
,
2723 build_static_class_ref (klass
)), init
);
2726 fold_convert (ptr_type_node
,
2727 build_address_of (build_classdollar_field (klass
))),
2730 init
= tree_cons (NULL_TREE
, integer_zero_node
, init
);
2731 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type
,
2733 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2734 TREE_STATIC (cdecl) = 1;
2735 DECL_ARTIFICIAL (cdecl) = 1;
2736 DECL_IGNORED_P (cdecl) = 1;
2737 TREE_READONLY (cdecl) = 1;
2738 TREE_CONSTANT (cdecl) = 1;
2739 rest_of_decl_compilation (cdecl, 1, 0);
2740 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2742 t
= build_function_type_list (void_type_node
,
2743 build_pointer_type (ptr_type_node
), NULL
);
2744 t
= build_decl (FUNCTION_DECL
,
2745 get_identifier ("_Jv_RegisterNewClasses"), t
);
2746 TREE_PUBLIC (t
) = 1;
2747 DECL_EXTERNAL (t
) = 1;
2748 register_class_fn
= t
;
2749 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2750 append_to_statement_list (t
, list_p
);
2754 /* Emit something to register classes at start-up time.
2756 The preferred mechanism is through the .jcr section, which contain
2757 a list of pointers to classes which get registered during constructor
2760 The fallback mechanism is to add statements to *LIST_P to call
2761 _Jv_RegisterClass for each class in this file. These statements will
2762 be added to a static constructor function for this translation unit. */
2765 emit_register_classes (tree
*list_p
)
2767 if (registered_class
== NULL
)
2770 if (flag_indirect_classes
)
2772 emit_indirect_register_classes (list_p
);
2776 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2777 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2778 but lack suitable crtbegin/end objects or linker support. These
2779 targets can override the default in tm.h to use the fallback mechanism. */
2780 if (TARGET_USE_JCR_SECTION
)
2785 #ifdef JCR_SECTION_NAME
2786 switch_to_section (get_section (JCR_SECTION_NAME
, SECTION_WRITE
, NULL
));
2788 /* A target has defined TARGET_USE_JCR_SECTION,
2789 but doesn't have a JCR_SECTION_NAME. */
2792 assemble_align (POINTER_SIZE
);
2794 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2796 t
= build_fold_addr_expr (klass
);
2797 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2802 tree klass
, t
, register_class_fn
;
2805 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2806 t
= build_decl (FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2807 TREE_PUBLIC (t
) = 1;
2808 DECL_EXTERNAL (t
) = 1;
2809 register_class_fn
= t
;
2811 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2813 t
= build_fold_addr_expr (klass
);
2814 t
= build_call_expr (register_class_fn
, 1, t
);
2815 append_to_statement_list (t
, list_p
);
2820 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2823 build_symbol_entry (tree decl
, tree special
)
2825 tree clname
, name
, signature
, sym
;
2826 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2827 /* ??? Constructors are given the name foo.foo all the way through
2828 the compiler, but in the method table they're all renamed
2829 foo.<init>. So, we have to do the same here unless we want an
2830 unresolved reference at runtime. */
2831 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2832 && DECL_CONSTRUCTOR_P (decl
))
2833 ? init_identifier_node
2834 : DECL_NAME (decl
));
2835 signature
= build_java_signature (TREE_TYPE (decl
));
2836 signature
= build_utf8_ref (unmangle_classname
2837 (IDENTIFIER_POINTER (signature
),
2838 IDENTIFIER_LENGTH (signature
)));
2839 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2840 signature addr+1 if SPECIAL, and this indicates to the runtime
2841 system that this is a "special" symbol, i.e. one that should
2842 bypass access controls. */
2843 if (special
!= NULL_TREE
)
2844 signature
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (signature
), signature
,
2845 fold_convert (sizetype
, special
));
2847 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2848 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2849 PUSH_FIELD_VALUE (sym
, "name", name
);
2850 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2851 FINISH_RECORD_CONSTRUCTOR (sym
);
2852 TREE_CONSTANT (sym
) = 1;
2857 /* Emit a symbol table: used by -findirect-dispatch. */
2860 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2861 tree the_syms_decl
, tree the_array_element_type
,
2864 tree method_list
, method
, table
, list
, null_symbol
;
2865 tree table_size
, the_array_type
;
2868 /* Only emit a table if this translation unit actually made any
2869 references via it. */
2870 if (decl_list
== NULL_TREE
)
2873 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2875 method_list
= decl_list
;
2877 while (method_list
!= NULL_TREE
)
2879 tree special
= TREE_PURPOSE (method_list
);
2880 method
= TREE_VALUE (method_list
);
2881 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
, special
), list
);
2882 method_list
= TREE_CHAIN (method_list
);
2886 /* Terminate the list with a "null" entry. */
2887 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2888 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2889 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2890 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2891 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2892 TREE_CONSTANT (null_symbol
) = 1;
2893 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2895 /* Put the list in the right order and make it a constructor. */
2896 list
= nreverse (list
);
2897 table
= build_constructor_from_list (symbols_array_type
, list
);
2899 /* Make it the initial value for otable_syms and emit the decl. */
2900 DECL_INITIAL (the_syms_decl
) = table
;
2901 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2902 DECL_IGNORED_P (the_syms_decl
) = 1;
2903 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2905 /* Now that its size is known, redefine the table as an
2906 uninitialized static array of INDEX + 1 elements. The extra entry
2907 is used by the runtime to track whether the table has been
2910 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2911 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2912 the_table
= build_decl (VAR_DECL
, name
, the_array_type
);
2913 TREE_STATIC (the_table
) = 1;
2914 TREE_READONLY (the_table
) = 1;
2915 rest_of_decl_compilation (the_table
, 1, 0);
2920 /* Make an entry for the catch_classes list. */
2922 make_catch_class_record (tree catch_class
, tree classname
)
2925 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2926 START_RECORD_CONSTRUCTOR (entry
, type
);
2927 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2928 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2929 FINISH_RECORD_CONSTRUCTOR (entry
);
2934 /* Generate the list of Throwable classes that are caught by exception
2935 handlers in this class. */
2937 emit_catch_table (tree this_class
)
2939 tree table
, table_size
, array_type
;
2940 TYPE_CATCH_CLASSES (this_class
) =
2942 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2943 TYPE_CATCH_CLASSES (this_class
));
2944 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2945 TYPE_CATCH_CLASSES (this_class
) =
2947 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2948 TYPE_CATCH_CLASSES (this_class
));
2949 table_size
= build_index_type
2950 (build_int_cst (NULL_TREE
,
2951 list_length (TYPE_CATCH_CLASSES (this_class
))));
2953 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2956 build_decl (VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2957 DECL_INITIAL (table
) =
2958 build_constructor_from_list (array_type
, TYPE_CATCH_CLASSES (this_class
));
2959 TREE_STATIC (table
) = 1;
2960 TREE_READONLY (table
) = 1;
2961 DECL_IGNORED_P (table
) = 1;
2962 rest_of_decl_compilation (table
, 1, 0);
2966 /* Given a type, return the signature used by
2967 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2968 same as build_java_signature() because we want the canonical array
2972 build_signature_for_libgcj (tree type
)
2976 sig
= build_java_signature (type
);
2977 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
2978 IDENTIFIER_LENGTH (sig
)));
2982 /* Add an entry to the type assertion table. Callback used during hashtable
2986 add_assertion_table_entry (void **htab_entry
, void *ptr
)
2989 tree code_val
, op1_utf8
, op2_utf8
;
2990 tree
*list
= (tree
*) ptr
;
2991 type_assertion
*as
= (type_assertion
*) *htab_entry
;
2993 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
2995 if (as
->op1
== NULL_TREE
)
2996 op1_utf8
= null_pointer_node
;
2998 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3000 if (as
->op2
== NULL_TREE
)
3001 op2_utf8
= null_pointer_node
;
3003 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3005 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
3006 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
3007 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
3008 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
3009 FINISH_RECORD_CONSTRUCTOR (entry
);
3011 *list
= tree_cons (NULL_TREE
, entry
, *list
);
3015 /* Generate the type assertion table for KLASS, and return its DECL. */
3018 emit_assertion_table (tree klass
)
3020 tree null_entry
, ctor
, table_decl
;
3021 tree list
= NULL_TREE
;
3022 htab_t assertions_htab
= TYPE_ASSERTIONS (klass
);
3024 /* Iterate through the hash table. */
3025 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
3027 /* Finish with a null entry. */
3028 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
3029 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
3030 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
3031 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
3032 FINISH_RECORD_CONSTRUCTOR (null_entry
);
3034 list
= tree_cons (NULL_TREE
, null_entry
, list
);
3036 /* Put the list in the right order and make it a constructor. */
3037 list
= nreverse (list
);
3038 ctor
= build_constructor_from_list (assertion_table_type
, list
);
3040 table_decl
= build_decl (VAR_DECL
, mangled_classname ("_type_assert_", klass
),
3041 assertion_table_type
);
3043 TREE_STATIC (table_decl
) = 1;
3044 TREE_READONLY (table_decl
) = 1;
3045 TREE_CONSTANT (table_decl
) = 1;
3046 DECL_IGNORED_P (table_decl
) = 1;
3048 DECL_INITIAL (table_decl
) = ctor
;
3049 DECL_ARTIFICIAL (table_decl
) = 1;
3050 rest_of_decl_compilation (table_decl
, 1, 0);
3056 init_class_processing (void)
3058 fields_ident
= get_identifier ("fields");
3059 info_ident
= get_identifier ("info");
3061 gcc_obstack_init (&temporary_obstack
);
3064 static hashval_t
java_treetreehash_hash (const void *);
3065 static int java_treetreehash_compare (const void *, const void *);
3067 /* A hash table mapping trees to trees. Used generally. */
3069 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3072 java_treetreehash_hash (const void *k_p
)
3074 const struct treetreehash_entry
*const k
3075 = (const struct treetreehash_entry
*) k_p
;
3076 return JAVA_TREEHASHHASH_H (k
->key
);
3080 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3082 const struct treetreehash_entry
*const k1
3083 = (const struct treetreehash_entry
*) k1_p
;
3084 const_tree
const k2
= (const_tree
) k2_p
;
3085 return (k1
->key
== k2
);
3089 java_treetreehash_find (htab_t ht
, tree t
)
3091 struct treetreehash_entry
*e
;
3092 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3093 e
= (struct treetreehash_entry
*) htab_find_with_hash (ht
, t
, hv
);
3101 java_treetreehash_new (htab_t ht
, tree t
)
3104 struct treetreehash_entry
*tthe
;
3105 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3107 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3110 tthe
= (struct treetreehash_entry
*) (*ht
->alloc_f
) (1, sizeof (*tthe
));
3115 tthe
= (struct treetreehash_entry
*) *e
;
3116 return &tthe
->value
;
3120 java_treetreehash_create (size_t size
, int gc
)
3123 return htab_create_ggc (size
, java_treetreehash_hash
,
3124 java_treetreehash_compare
, NULL
);
3126 return htab_create_alloc (size
, java_treetreehash_hash
,
3127 java_treetreehash_compare
, free
, xcalloc
, free
);
3130 /* Break down qualified IDENTIFIER into package and class-name components.
3131 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3132 "pkg.foo", and RIGHT to "Bar". */
3135 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3138 int l
= IDENTIFIER_LENGTH (source
);
3140 base
= (char *) alloca (l
+ 1);
3141 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3143 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3145 while (*p
!= '.' && p
!= base
)
3148 /* We didn't find a '.'. Return an error. */
3154 *right
= get_identifier (p
+1);
3155 *left
= get_identifier (base
);
3160 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3161 if the classes are from the same package. */
3164 in_same_package (tree name1
, tree name2
)
3170 if (TREE_CODE (name1
) == TYPE_DECL
)
3171 name1
= DECL_NAME (name1
);
3172 if (TREE_CODE (name2
) == TYPE_DECL
)
3173 name2
= DECL_NAME (name2
);
3175 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3176 /* One in empty package. */
3179 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3180 /* Both in empty package. */
3183 split_qualified_name (&pkg1
, &tmp
, name1
);
3184 split_qualified_name (&pkg2
, &tmp
, name2
);
3186 return (pkg1
== pkg2
);
3189 #include "gt-java-class.h"