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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>.
21 Java and all Java-based marks are trademarks or registered trademarks
22 of Sun Microsystems, Inc. in the United States and other countries.
23 The Free Software Foundation is independent of Sun Microsystems, Inc. */
25 /* Written by Per Bothner <bothner@cygnus.com> */
29 #include "coretypes.h"
34 #include "java-tree.h"
46 #include "tree-iterator.h"
50 /* DOS brain-damage */
52 #define O_BINARY 0 /* MS-DOS brain-damage */
55 static tree
make_method_value (tree
);
56 static tree
build_java_method_type (tree
, tree
, int);
57 static int32
hashUtf8String (const char *, int);
58 static tree
make_field_value (tree
);
59 static tree
get_dispatch_vector (tree
);
60 static tree
get_dispatch_table (tree
, tree
);
61 static int supers_all_compiled (tree type
);
62 static tree
maybe_layout_super_class (tree
, tree
);
63 static void add_miranda_methods (tree
, tree
);
64 static int assume_compiled (const char *);
65 static tree
build_symbol_entry (tree
, tree
);
66 static tree
emit_assertion_table (tree
);
67 static void register_class (void);
69 struct obstack temporary_obstack
;
71 static const char *cyclic_inheritance_report
;
73 /* The compiler generates different code depending on whether or not
74 it can assume certain classes have been compiled down to native
75 code or not. The compiler options -fassume-compiled= and
76 -fno-assume-compiled= are used to create a tree of
77 class_flag_node objects. This tree is queried to determine if
78 a class is assume to be compiled or not. Each node in the tree
79 represents either a package or a specific class. */
81 typedef struct class_flag_node_struct
83 /* The class or package name. */
86 /* Nonzero if this represents an exclusion. */
89 /* Pointers to other nodes in the tree. */
90 struct class_flag_node_struct
*parent
;
91 struct class_flag_node_struct
*sibling
;
92 struct class_flag_node_struct
*child
;
95 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
96 static void add_class_flag (class_flag_node
**, const char *, int);
98 /* This is the root of the include/exclude tree. */
100 static class_flag_node
*assume_compiled_tree
;
102 static class_flag_node
*enable_assert_tree
;
104 static GTY(()) tree class_roots
[4];
105 #define fields_ident class_roots[0] /* get_identifier ("fields") */
106 #define info_ident class_roots[1] /* get_identifier ("info") */
107 #define class_list class_roots[2]
108 #define class_dtable_decl class_roots[3]
110 static GTY(()) VEC(tree
,gc
) *registered_class
;
112 /* A tree that returns the address of the class$ of the class
113 currently being compiled. */
114 static GTY(()) tree this_classdollar
;
116 /* Return the node that most closely represents the class whose name
117 is IDENT. Start the search from NODE (followed by its siblings).
118 Return NULL if an appropriate node does not exist. */
120 static class_flag_node
*
121 find_class_flag_node (class_flag_node
*node
, const char *ident
)
125 size_t node_ident_length
= strlen (node
->ident
);
127 /* node_ident_length is zero at the root of the tree. If the
128 identifiers are the same length, then we have matching
129 classes. Otherwise check if we've matched an enclosing
132 if (node_ident_length
== 0
133 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
134 && (ident
[node_ident_length
] == '\0'
135 || ident
[node_ident_length
] == '.')))
137 /* We've found a match, however, there might be a more
140 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
147 /* No match yet. Continue through the sibling list. */
148 node
= node
->sibling
;
151 /* No match at all in this tree. */
156 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
158 class_flag_node
*root
= *rootp
;
159 class_flag_node
*parent
, *node
;
161 /* Create the root of the tree if it doesn't exist yet. */
165 root
= XNEW (class_flag_node
);
168 root
->sibling
= NULL
;
174 /* Calling the function with the empty string means we're setting
175 value for the root of the hierarchy. */
183 /* Find the parent node for this new node. PARENT will either be a
184 class or a package name. Adjust PARENT accordingly. */
186 parent
= find_class_flag_node (root
, ident
);
187 if (strcmp (ident
, parent
->ident
) == 0)
188 parent
->value
= value
;
191 /* Insert new node into the tree. */
192 node
= XNEW (class_flag_node
);
194 node
->ident
= xstrdup (ident
);
198 node
->parent
= parent
;
199 node
->sibling
= parent
->child
;
200 parent
->child
= node
;
204 /* Add a new IDENT to the include/exclude tree. It's an exclusion
205 if EXCLUDEP is nonzero. */
208 add_assume_compiled (const char *ident
, int excludep
)
210 add_class_flag (&assume_compiled_tree
, ident
, excludep
);
213 /* The default value returned by enable_assertions. */
215 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
217 /* Enter IDENT (a class or package name) into the enable-assertions table.
218 VALUE is true to enable and false to disable. */
221 add_enable_assert (const char *ident
, int value
)
223 if (enable_assert_tree
== NULL
)
224 add_class_flag (&enable_assert_tree
, "", DEFAULT_ENABLE_ASSERT
);
225 add_class_flag (&enable_assert_tree
, ident
, value
);
228 /* Returns nonzero if IDENT is the name of a class that the compiler
229 should assume has been compiled to object code. */
232 assume_compiled (const char *ident
)
237 if (NULL
== assume_compiled_tree
)
240 i
= find_class_flag_node (assume_compiled_tree
, ident
);
247 /* Return true if we should generate code to check assertions within KLASS. */
250 enable_assertions (tree klass
)
252 /* Check if command-line specifies whether we should check assertions. */
254 if (klass
!= NULL_TREE
&& DECL_NAME (klass
) && enable_assert_tree
!= NULL
)
256 const char *ident
= IDENTIFIER_POINTER (DECL_NAME (klass
));
257 class_flag_node
*node
258 = find_class_flag_node (enable_assert_tree
, ident
);
262 /* The default is to enable assertions if generating class files,
263 or not optimizing. */
264 return DEFAULT_ENABLE_ASSERT
;
267 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
268 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
269 Also, PREFIX is prepended, and SUFFIX is appended. */
272 ident_subst (const char* old_name
,
279 int prefix_len
= strlen (prefix
);
280 int suffix_len
= strlen (suffix
);
281 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
282 char *buffer
= alloca (i
);
284 strcpy (buffer
, prefix
);
285 for (i
= 0; i
< old_length
; i
++)
287 char ch
= old_name
[i
];
290 buffer
[prefix_len
+ i
] = ch
;
292 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
293 return get_identifier (buffer
);
296 /* Return an IDENTIFIER_NODE the same as OLD_ID,
297 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
298 Also, PREFIX is prepended, and SUFFIX is appended. */
301 identifier_subst (const tree old_id
,
307 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
308 prefix
, old_char
, new_char
, suffix
);
311 /* Generate a valid C identifier from the name of the class TYPE,
312 prefixed by PREFIX. */
315 mangled_classname (const char *prefix
, tree type
)
317 tree ident
= TYPE_NAME (type
);
318 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
319 ident
= DECL_NAME (ident
);
320 return identifier_subst (ident
, prefix
, '.', '_', "");
327 type
= make_node (RECORD_TYPE
);
328 /* Unfortunately we must create the binfo here, so that class
330 TYPE_BINFO (type
) = make_tree_binfo (0);
331 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
336 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
337 and where each of the constituents is separated by '/',
338 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
341 unmangle_classname (const char *name
, int name_length
)
343 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
344 /* It's not sufficient to compare to_return and get_identifier
345 (name) to determine whether to_return is qualified. There are
346 cases in signature analysis where name will be stripped of a
348 name
= IDENTIFIER_POINTER (to_return
);
352 QUALIFIED_P (to_return
) = 1;
359 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
362 const char *typename = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
363 char *buf = alloca (strlen (typename) + strlen (#NAME "_syms_") + 1); \
366 sprintf (buf, #NAME "_%s", typename); \
367 TYPE_## TABLE ##_DECL (type) = decl = \
368 build_decl (VAR_DECL, get_identifier (buf), TABLE_TYPE); \
369 DECL_EXTERNAL (decl) = 1; \
370 TREE_STATIC (decl) = 1; \
371 TREE_READONLY (decl) = 1; \
372 TREE_CONSTANT (decl) = 1; \
373 DECL_IGNORED_P (decl) = 1; \
374 /* Mark the table as belonging to this class. */ \
376 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
377 DECL_OWNER (decl) = TYPE; \
378 sprintf (buf, #NAME "_syms_%s", typename); \
379 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
380 build_decl (VAR_DECL, get_identifier (buf), symbols_array_type); \
381 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
382 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
383 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
387 /* Given a class, create the DECLs for all its associated indirect
390 gen_indirect_dispatch_tables (tree type
)
392 const char *typename
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
395 char *buf
= alloca (strlen (typename
) + strlen ("_catch_classes_") + 1);
396 tree catch_class_type
= make_node (RECORD_TYPE
);
398 sprintf (buf
, "_catch_classes_%s", typename
);
399 PUSH_FIELD (catch_class_type
, field
, "address", utf8const_ptr_type
);
400 PUSH_FIELD (catch_class_type
, field
, "classname", ptr_type_node
);
401 FINISH_RECORD (catch_class_type
);
403 TYPE_CTABLE_DECL (type
)
404 = build_decl (VAR_DECL
, get_identifier (buf
),
405 build_array_type (catch_class_type
, 0));
406 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
407 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
408 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
409 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
410 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
411 pushdecl (TYPE_CTABLE_DECL (type
));
414 if (flag_indirect_dispatch
)
416 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
417 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
418 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
425 push_class (tree class_type
, tree class_name
)
427 tree decl
, signature
;
428 location_t saved_loc
= input_location
;
429 #ifndef USE_MAPPED_LOCATION
430 input_filename
= "<unknown>";
433 CLASS_P (class_type
) = 1;
434 decl
= build_decl (TYPE_DECL
, class_name
, class_type
);
435 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
437 /* dbxout needs a DECL_SIZE if in gstabs mode */
438 DECL_SIZE (decl
) = integer_zero_node
;
440 input_location
= saved_loc
;
441 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
442 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
444 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
445 both a typedef and in the struct name-space. We may want to re-visit
446 this later, but for now it reduces the changes needed for gdb. */
447 DECL_ARTIFICIAL (decl
) = 1;
449 pushdecl_top_level (decl
);
454 /* Finds the (global) class named NAME. Creates the class if not found.
455 Also creates associated TYPE_DECL.
456 Does not check if the class actually exists, load the class,
457 fill in field or methods, or do layout_type. */
460 lookup_class (tree name
)
462 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
463 if (decl
== NULL_TREE
)
464 decl
= push_class (make_class (), name
);
465 return TREE_TYPE (decl
);
469 set_super_info (int access_flags
, tree this_class
,
470 tree super_class
, int interfaces_count
)
472 int total_supers
= interfaces_count
;
473 tree class_decl
= TYPE_NAME (this_class
);
479 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
480 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
483 tree super_binfo
= make_tree_binfo (0);
484 BINFO_TYPE (super_binfo
) = super_class
;
485 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
486 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
487 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
490 set_class_decl_access_flags (access_flags
, class_decl
);
494 set_class_decl_access_flags (int access_flags
, tree class_decl
)
496 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
497 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
498 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
499 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
500 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
501 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
502 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
503 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
504 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
505 if (access_flags
& ACC_ENUM
) CLASS_ENUM (class_decl
) = 1;
506 if (access_flags
& ACC_SYNTHETIC
) CLASS_SYNTHETIC (class_decl
) = 1;
507 if (access_flags
& ACC_ANNOTATION
) CLASS_ANNOTATION (class_decl
) = 1;
510 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
511 direct sub-classes of Object are 1, and so on. */
514 class_depth (tree clas
)
517 if (! CLASS_LOADED_P (clas
))
518 load_class (clas
, 1);
519 if (TYPE_SIZE (clas
) == error_mark_node
)
521 while (clas
!= object_type_node
)
524 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
529 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
532 interface_of_p (tree type1
, tree type2
)
535 tree binfo
, base_binfo
;
537 if (! TYPE_BINFO (type2
))
540 for (binfo
= TYPE_BINFO (type2
), i
= 0;
541 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
542 if (BINFO_TYPE (base_binfo
) == type1
)
545 for (binfo
= TYPE_BINFO (type2
), i
= 0;
546 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
547 if (BINFO_TYPE (base_binfo
)
548 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
554 /* Return true iff TYPE1 inherits from TYPE2. */
557 inherits_from_p (tree type1
, tree type2
)
559 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
564 if (! CLASS_LOADED_P (type1
))
565 load_class (type1
, 1);
567 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
572 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
575 enclosing_context_p (tree type1
, tree type2
)
577 if (!INNER_CLASS_TYPE_P (type2
))
580 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
582 type2
= (INNER_CLASS_TYPE_P (type2
) ?
583 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
593 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
597 common_enclosing_context_p (tree type1
, tree type2
)
602 for (current
= type2
; current
;
603 current
= (INNER_CLASS_TYPE_P (current
) ?
604 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
606 if (type1
== current
)
609 if (INNER_CLASS_TYPE_P (type1
))
610 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
617 /* Return 1 iff there exists a common enclosing "this" between TYPE1
618 and TYPE2, without crossing any static context. */
621 common_enclosing_instance_p (tree type1
, tree type2
)
623 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
626 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
627 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
628 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
631 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
632 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
633 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
635 if (type1
== current
)
641 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
642 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
643 if attempt is made to add it twice. */
646 maybe_add_interface (tree this_class
, tree interface_class
)
648 tree binfo
, base_binfo
;
651 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
652 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
653 if (BINFO_TYPE (base_binfo
) == interface_class
)
654 return interface_class
;
655 add_interface (this_class
, interface_class
);
659 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
662 add_interface (tree this_class
, tree interface_class
)
664 tree interface_binfo
= make_tree_binfo (0);
666 BINFO_TYPE (interface_binfo
) = interface_class
;
667 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
668 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
669 BINFO_VIRTUAL_P (interface_binfo
) = 1;
671 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
675 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
677 if (access_flags
& ACC_STATIC
)
679 fntype
= build_method_type (this_class
, fntype
);
681 /* We know that arg 1 of every nonstatic method is non-null; tell
683 TYPE_ATTRIBUTES (fntype
) = (tree_cons
684 (get_identifier ("nonnull"),
685 tree_cons (NULL_TREE
,
686 build_int_cst (NULL_TREE
, 1),
688 TYPE_ATTRIBUTES (fntype
)));
693 hide (tree decl ATTRIBUTE_UNUSED
)
695 #ifdef HAVE_GAS_HIDDEN
696 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
697 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
702 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
704 tree method_type
, fndecl
;
706 method_type
= build_java_method_type (function_type
,
707 this_class
, access_flags
);
709 fndecl
= build_decl (FUNCTION_DECL
, name
, method_type
);
710 DECL_CONTEXT (fndecl
) = this_class
;
712 DECL_LANG_SPECIFIC (fndecl
)
713 = ggc_alloc_cleared (sizeof (struct lang_decl
));
714 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
716 /* Initialize the static initializer test table. */
718 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
719 java_treetreehash_create (10, 1);
721 /* Initialize the initialized (static) class table. */
722 if (access_flags
& ACC_STATIC
)
723 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
724 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
726 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
727 TYPE_METHODS (this_class
) = fndecl
;
729 /* If pointers to member functions use the least significant bit to
730 indicate whether a function is virtual, ensure a pointer
731 to this function will have that bit clear. */
732 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
733 && !(access_flags
& ACC_STATIC
)
734 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
735 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
737 /* Notice that this is a finalizer and update the class type
738 accordingly. This is used to optimize instance allocation. */
739 if (name
== finalize_identifier_node
740 && TREE_TYPE (function_type
) == void_type_node
741 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
742 HAS_FINALIZER_P (this_class
) = 1;
744 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
745 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
746 if (access_flags
& ACC_PRIVATE
)
747 METHOD_PRIVATE (fndecl
) = DECL_INLINE (fndecl
) = 1;
748 if (access_flags
& ACC_NATIVE
)
750 METHOD_NATIVE (fndecl
) = 1;
751 DECL_EXTERNAL (fndecl
) = 1;
754 /* FNDECL is external unless we are compiling it into this object
756 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
757 if (access_flags
& ACC_STATIC
)
758 METHOD_STATIC (fndecl
) = DECL_INLINE (fndecl
) = 1;
759 if (access_flags
& ACC_FINAL
)
760 METHOD_FINAL (fndecl
) = DECL_INLINE (fndecl
) = 1;
761 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
762 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
763 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
764 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
765 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
766 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
770 /* Add a method to THIS_CLASS.
771 The method's name is NAME.
772 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
775 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
777 tree function_type
, fndecl
;
778 const unsigned char *sig
779 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
782 fatal_error ("bad method signature");
784 function_type
= get_type_from_signature (method_sig
);
785 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
786 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
791 add_field (tree
class, tree name
, tree field_type
, int flags
)
793 int is_static
= (flags
& ACC_STATIC
) != 0;
795 field
= build_decl (is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
796 TREE_CHAIN (field
) = TYPE_FIELDS (class);
797 TYPE_FIELDS (class) = field
;
798 DECL_CONTEXT (field
) = class;
799 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
801 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
802 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
803 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
804 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
805 if (flags
& ACC_VOLATILE
)
807 FIELD_VOLATILE (field
) = 1;
808 TREE_THIS_VOLATILE (field
) = 1;
810 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
811 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
812 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
815 FIELD_STATIC (field
) = 1;
816 /* Always make field externally visible. This is required so
817 that native methods can always access the field. */
818 TREE_PUBLIC (field
) = 1;
819 /* Hide everything that shouldn't be visible outside a DSO. */
820 if (flag_indirect_classes
821 || (FIELD_PRIVATE (field
)))
823 /* Considered external unless we are compiling it into this
825 DECL_EXTERNAL (field
) = (is_compiled_class (class) != 2);
831 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
834 set_constant_value (tree field
, tree constant
)
836 if (field
== NULL_TREE
)
837 warning (OPT_Wattributes
,
838 "misplaced ConstantValue attribute (not in any field)");
839 else if (DECL_INITIAL (field
) != NULL_TREE
)
840 warning (OPT_Wattributes
,
841 "duplicate ConstantValue attribute for field '%s'",
842 IDENTIFIER_POINTER (DECL_NAME (field
)));
845 DECL_INITIAL (field
) = constant
;
846 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
847 && ! (TREE_TYPE (constant
) == int_type_node
848 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
849 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
850 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
851 && TREE_TYPE (field
) == string_ptr_type_node
))
852 error ("ConstantValue attribute of field '%s' has wrong type",
853 IDENTIFIER_POINTER (DECL_NAME (field
)));
857 /* Calculate a hash value for a string encoded in Utf8 format.
858 * This returns the same hash value as specified for java.lang.String.hashCode.
862 hashUtf8String (const char *str
, int len
)
864 const unsigned char* ptr
= (const unsigned char*) str
;
865 const unsigned char *limit
= ptr
+ len
;
869 int ch
= UTF8_GET (ptr
, limit
);
870 /* Updated specification from
871 http://www.javasoft.com/docs/books/jls/clarify.html. */
872 hash
= (31 * hash
) + ch
;
877 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
880 build_utf8_ref (tree name
)
882 const char * name_ptr
= IDENTIFIER_POINTER(name
);
883 int name_len
= IDENTIFIER_LENGTH(name
);
885 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
886 static int utf8_count
= 0;
888 tree ref
= IDENTIFIER_UTF8_REF (name
);
890 if (ref
!= NULL_TREE
)
893 ctype
= make_node (RECORD_TYPE
);
894 str_type
= build_prim_array_type (unsigned_byte_type_node
,
895 name_len
+ 1); /* Allow for final '\0'. */
896 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
897 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
898 PUSH_FIELD (ctype
, field
, "data", str_type
);
899 FINISH_RECORD (ctype
);
900 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
901 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
902 PUSH_FIELD_VALUE (cinit
, "hash", build_int_cst (NULL_TREE
, name_hash
));
903 PUSH_FIELD_VALUE (cinit
, "length", build_int_cst (NULL_TREE
, name_len
));
904 string
= build_string (name_len
, name_ptr
);
905 TREE_TYPE (string
) = str_type
;
906 PUSH_FIELD_VALUE (cinit
, "data", string
);
907 FINISH_RECORD_CONSTRUCTOR (cinit
);
908 TREE_CONSTANT (cinit
) = 1;
909 TREE_INVARIANT (cinit
) = 1;
911 /* Generate a unique-enough identifier. */
912 sprintf(buf
, "_Utf%d", ++utf8_count
);
914 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
915 TREE_STATIC (decl
) = 1;
916 DECL_ARTIFICIAL (decl
) = 1;
917 DECL_IGNORED_P (decl
) = 1;
918 TREE_READONLY (decl
) = 1;
919 TREE_THIS_VOLATILE (decl
) = 0;
920 DECL_INITIAL (decl
) = cinit
;
922 if (HAVE_GAS_SHF_MERGE
)
925 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
926 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
927 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
928 if (flag_merge_constants
&& decl_size
< 256)
931 int flags
= (SECTION_OVERRIDE
932 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
933 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
934 switch_to_section (get_section (buf
, flags
, NULL
));
935 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
939 TREE_CHAIN (decl
) = utf8_decl_list
;
940 layout_decl (decl
, 0);
942 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
943 varpool_mark_needed_node (varpool_node (decl
));
944 utf8_decl_list
= decl
;
945 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
946 IDENTIFIER_UTF8_REF (name
) = ref
;
950 /* Like build_class_ref, but instead of a direct reference generate a
951 pointer into the constant pool. */
954 build_indirect_class_ref (tree type
)
958 index
= alloc_class_constant (type
);
959 cl
= build_ref_from_constant_pool (index
);
960 return convert (promote_type (class_ptr_type
), cl
);
964 build_static_class_ref (tree type
)
966 tree decl_name
, decl
, ref
;
968 if (TYPE_SIZE (type
) == error_mark_node
)
969 return null_pointer_node
;
970 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
971 "", '/', '/', ".class$$");
972 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
973 if (decl
== NULL_TREE
)
975 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
976 TREE_STATIC (decl
) = 1;
977 if (! flag_indirect_classes
)
979 TREE_PUBLIC (decl
) = 1;
980 if (CLASS_PRIVATE (TYPE_NAME (type
)))
983 DECL_IGNORED_P (decl
) = 1;
984 DECL_ARTIFICIAL (decl
) = 1;
985 if (is_compiled_class (type
) == 1)
986 DECL_EXTERNAL (decl
) = 1;
987 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
988 DECL_CLASS_FIELD_P (decl
) = 1;
989 DECL_CONTEXT (decl
) = type
;
991 /* ??? We want to preserve the DECL_CONTEXT we set just above,
992 that that means not calling pushdecl_top_level. */
993 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
996 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1001 build_classdollar_field (tree type
)
1003 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1004 "", '/', '/', ".class$");
1005 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1007 if (decl
== NULL_TREE
)
1010 = build_decl (VAR_DECL
, decl_name
,
1013 (build_type_variant (class_type_node
,
1015 /* const */ 1, 0)));
1016 TREE_STATIC (decl
) = 1;
1017 TREE_INVARIANT (decl
) = 1;
1018 TREE_CONSTANT (decl
) = 1;
1019 TREE_READONLY (decl
) = 1;
1020 TREE_PUBLIC (decl
) = 1;
1022 DECL_IGNORED_P (decl
) = 1;
1023 DECL_ARTIFICIAL (decl
) = 1;
1024 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1025 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1026 DECL_CLASS_FIELD_P (decl
) = 1;
1027 DECL_CONTEXT (decl
) = type
;
1033 /* Create a local variable that holds the current class$. */
1036 cache_this_class_ref (tree fndecl
)
1040 tree classdollar_field
;
1041 if (flag_indirect_classes
)
1042 classdollar_field
= build_classdollar_field (output_class
);
1044 classdollar_field
= build_static_class_ref (output_class
);
1046 this_classdollar
= build_decl (VAR_DECL
, NULL_TREE
,
1047 TREE_TYPE (classdollar_field
));
1049 java_add_local_var (this_classdollar
);
1050 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1051 this_classdollar
, classdollar_field
));
1054 this_classdollar
= build_classdollar_field (output_class
);
1056 /* Prepend class initialization for static methods reachable from
1058 if (METHOD_STATIC (fndecl
)
1059 && (! METHOD_PRIVATE (fndecl
)
1060 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1061 && ! DECL_CLINIT_P (fndecl
)
1062 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1064 tree init
= build_call_expr (soft_initclass_node
, 1,
1066 java_add_stmt (init
);
1070 /* Remove the reference to the local variable that holds the current
1074 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1076 this_classdollar
= build_classdollar_field (output_class
);
1079 /* Build a reference to the class TYPE.
1080 Also handles primitive types and array types. */
1083 build_class_ref (tree type
)
1085 int is_compiled
= is_compiled_class (type
);
1089 if (TREE_CODE (type
) == POINTER_TYPE
)
1090 type
= TREE_TYPE (type
);
1092 if (flag_indirect_dispatch
1093 && type
!= output_class
1094 && TREE_CODE (type
) == RECORD_TYPE
)
1095 return build_indirect_class_ref (type
);
1097 if (type
== output_class
&& flag_indirect_classes
)
1098 return this_classdollar
;
1100 if (TREE_CODE (type
) == RECORD_TYPE
)
1101 return build_static_class_ref (type
);
1107 decl_name
= TYPE_NAME (type
);
1108 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1109 decl_name
= DECL_NAME (decl_name
);
1110 name
= IDENTIFIER_POINTER (decl_name
);
1111 if (strncmp (name
, "promoted_", 9) == 0)
1113 sprintf (buffer
, "_Jv_%sClass", name
);
1114 decl_name
= get_identifier (buffer
);
1115 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1116 if (decl
== NULL_TREE
)
1118 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1119 TREE_STATIC (decl
) = 1;
1120 TREE_PUBLIC (decl
) = 1;
1121 DECL_EXTERNAL (decl
) = 1;
1122 DECL_ARTIFICIAL (decl
) = 1;
1123 pushdecl_top_level (decl
);
1127 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1131 return build_indirect_class_ref (type
);
1134 /* Create a local statically allocated variable that will hold a
1135 pointer to a static field. */
1138 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1140 tree decl
, decl_name
;
1141 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1142 char *buf
= alloca (strlen (name
) + 20);
1143 sprintf (buf
, "%s_%d_ref", name
, index
);
1144 decl_name
= get_identifier (buf
);
1145 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1146 if (decl
== NULL_TREE
)
1148 decl
= build_decl (VAR_DECL
, decl_name
, ptr_type_node
);
1149 TREE_STATIC (decl
) = 1;
1150 TREE_PUBLIC (decl
) = 0;
1151 DECL_EXTERNAL (decl
) = 0;
1152 DECL_ARTIFICIAL (decl
) = 1;
1153 DECL_IGNORED_P (decl
) = 1;
1154 pushdecl_top_level (decl
);
1160 build_static_field_ref (tree fdecl
)
1162 tree fclass
= DECL_CONTEXT (fdecl
);
1163 int is_compiled
= is_compiled_class (fclass
);
1165 /* Allow static final fields to fold to a constant. When using
1166 -findirect-dispatch, we simply never do this folding if compiling
1167 from .class; in the .class file constants will be referred to via
1168 the constant pool. */
1169 if (!flag_indirect_dispatch
1171 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1172 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1173 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1174 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1176 if (is_compiled
== 1)
1177 DECL_EXTERNAL (fdecl
) = 1;
1181 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1182 and a class local static variable CACHE_ENTRY, then
1184 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1185 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1188 This can mostly be optimized away, so that the usual path is a
1189 load followed by a test and branch. _Jv_ResolvePoolEntry is
1190 only called once for each constant pool entry.
1192 There is an optimization that we don't do: at the start of a
1193 method, create a local copy of CACHE_ENTRY and use that instead.
1197 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1198 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1200 = build_call_expr (built_in_decls
[BUILT_IN_EXPECT
], 2,
1201 build2 (EQ_EXPR
, boolean_type_node
,
1202 cache_entry
, null_pointer_node
),
1203 boolean_false_node
);
1204 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1206 = build_call_expr (soft_resolvepoolentry_node
, 2,
1207 build_class_ref (output_class
),
1209 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1210 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1211 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1212 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1218 get_access_flags_from_decl (tree decl
)
1220 int access_flags
= 0;
1221 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1223 if (FIELD_STATIC (decl
))
1224 access_flags
|= ACC_STATIC
;
1225 if (FIELD_PUBLIC (decl
))
1226 access_flags
|= ACC_PUBLIC
;
1227 if (FIELD_PROTECTED (decl
))
1228 access_flags
|= ACC_PROTECTED
;
1229 if (FIELD_PRIVATE (decl
))
1230 access_flags
|= ACC_PRIVATE
;
1231 if (FIELD_FINAL (decl
))
1232 access_flags
|= ACC_FINAL
;
1233 if (FIELD_VOLATILE (decl
))
1234 access_flags
|= ACC_VOLATILE
;
1235 if (FIELD_TRANSIENT (decl
))
1236 access_flags
|= ACC_TRANSIENT
;
1237 if (FIELD_ENUM (decl
))
1238 access_flags
|= ACC_ENUM
;
1239 if (FIELD_SYNTHETIC (decl
))
1240 access_flags
|= ACC_SYNTHETIC
;
1241 return access_flags
;
1243 if (TREE_CODE (decl
) == TYPE_DECL
)
1245 if (CLASS_PUBLIC (decl
))
1246 access_flags
|= ACC_PUBLIC
;
1247 if (CLASS_FINAL (decl
))
1248 access_flags
|= ACC_FINAL
;
1249 if (CLASS_SUPER (decl
))
1250 access_flags
|= ACC_SUPER
;
1251 if (CLASS_INTERFACE (decl
))
1252 access_flags
|= ACC_INTERFACE
;
1253 if (CLASS_ABSTRACT (decl
))
1254 access_flags
|= ACC_ABSTRACT
;
1255 if (CLASS_STATIC (decl
))
1256 access_flags
|= ACC_STATIC
;
1257 if (CLASS_PRIVATE (decl
))
1258 access_flags
|= ACC_PRIVATE
;
1259 if (CLASS_PROTECTED (decl
))
1260 access_flags
|= ACC_PROTECTED
;
1261 if (CLASS_STRICTFP (decl
))
1262 access_flags
|= ACC_STRICT
;
1263 if (CLASS_ENUM (decl
))
1264 access_flags
|= ACC_ENUM
;
1265 if (CLASS_SYNTHETIC (decl
))
1266 access_flags
|= ACC_SYNTHETIC
;
1267 if (CLASS_ANNOTATION (decl
))
1268 access_flags
|= ACC_ANNOTATION
;
1269 return access_flags
;
1271 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1273 if (METHOD_PUBLIC (decl
))
1274 access_flags
|= ACC_PUBLIC
;
1275 if (METHOD_PRIVATE (decl
))
1276 access_flags
|= ACC_PRIVATE
;
1277 if (METHOD_PROTECTED (decl
))
1278 access_flags
|= ACC_PROTECTED
;
1279 if (METHOD_STATIC (decl
))
1280 access_flags
|= ACC_STATIC
;
1281 if (METHOD_FINAL (decl
))
1282 access_flags
|= ACC_FINAL
;
1283 if (METHOD_SYNCHRONIZED (decl
))
1284 access_flags
|= ACC_SYNCHRONIZED
;
1285 if (METHOD_NATIVE (decl
))
1286 access_flags
|= ACC_NATIVE
;
1287 if (METHOD_ABSTRACT (decl
))
1288 access_flags
|= ACC_ABSTRACT
;
1289 if (METHOD_STRICTFP (decl
))
1290 access_flags
|= ACC_STRICT
;
1291 if (METHOD_INVISIBLE (decl
))
1292 access_flags
|= ACC_INVISIBLE
;
1293 if (DECL_ARTIFICIAL (decl
))
1294 access_flags
|= ACC_SYNTHETIC
;
1295 if (METHOD_BRIDGE (decl
))
1296 access_flags
|= ACC_BRIDGE
;
1297 if (METHOD_VARARGS (decl
))
1298 access_flags
|= ACC_VARARGS
;
1299 return access_flags
;
1304 static GTY (()) int alias_labelno
= 0;
1306 /* Create a private alias for METHOD. Using this alias instead of the method
1307 decl ensures that ncode entries in the method table point to the real function
1308 at runtime, not a PLT entry. */
1311 make_local_function_alias (tree method
)
1313 #ifdef ASM_OUTPUT_DEF
1316 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1317 char *name
= alloca (strlen (method_name
) + 2);
1318 char *buf
= alloca (strlen (method_name
) + 128);
1320 /* Only create aliases for local functions. */
1321 if (DECL_EXTERNAL (method
))
1324 /* Prefix method_name with 'L' for the alias label. */
1326 strcpy (name
+ 1, method_name
);
1328 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1329 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
1330 TREE_TYPE (method
));
1331 DECL_CONTEXT (alias
) = NULL
;
1332 TREE_READONLY (alias
) = TREE_READONLY (method
);
1333 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1334 TREE_PUBLIC (alias
) = 0;
1335 DECL_EXTERNAL (alias
) = 0;
1336 DECL_ARTIFICIAL (alias
) = 1;
1337 DECL_INLINE (alias
) = 0;
1338 DECL_INITIAL (alias
) = error_mark_node
;
1339 TREE_ADDRESSABLE (alias
) = 1;
1340 TREE_USED (alias
) = 1;
1341 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1342 if (!flag_syntax_only
)
1343 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1350 /** Make reflection data (_Jv_Field) for field FDECL. */
1353 make_field_value (tree fdecl
)
1357 tree type
= TREE_TYPE (fdecl
);
1358 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1360 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1361 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1363 type
= build_class_ref (type
);
1366 tree signature
= build_java_signature (type
);
1368 type
= build_utf8_ref (unmangle_classname
1369 (IDENTIFIER_POINTER (signature
),
1370 IDENTIFIER_LENGTH (signature
)));
1372 PUSH_FIELD_VALUE (finit
, "type", type
);
1374 flags
= get_access_flags_from_decl (fdecl
);
1376 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1378 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1379 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1382 tree field_address
= integer_zero_node
;
1383 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1384 && FIELD_STATIC (fdecl
))
1385 field_address
= build_address_of (fdecl
);
1389 build_constructor_from_list (field_info_union_node
,
1391 ((FIELD_STATIC (fdecl
)
1392 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1393 : TYPE_FIELDS (field_info_union_node
)),
1394 (FIELD_STATIC (fdecl
)
1396 : byte_position (fdecl
)))));
1399 FINISH_RECORD_CONSTRUCTOR (finit
);
1403 /** Make reflection data (_Jv_Method) for method MDECL. */
1406 make_method_value (tree mdecl
)
1408 static int method_name_count
= 0;
1413 #define ACC_TRANSLATED 0x4000
1414 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1416 class_decl
= DECL_CONTEXT (mdecl
);
1417 /* For interfaces, the index field contains the dispatch index. */
1418 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1419 index
= build_int_cst (NULL_TREE
,
1420 get_interface_method_index (mdecl
, class_decl
));
1421 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1422 index
= get_method_index (mdecl
);
1424 index
= integer_minus_one_node
;
1426 code
= null_pointer_node
;
1427 if (METHOD_ABSTRACT (mdecl
))
1428 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1429 soft_abstractmethod_node
);
1431 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1432 make_local_function_alias (mdecl
));
1433 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1434 PUSH_FIELD_VALUE (minit
, "name",
1435 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1436 init_identifier_node
1437 : DECL_NAME (mdecl
)));
1439 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1440 PUSH_FIELD_VALUE (minit
, "signature",
1443 (IDENTIFIER_POINTER(signature
),
1444 IDENTIFIER_LENGTH(signature
)))));
1446 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1447 PUSH_FIELD_VALUE (minit
, "index", index
);
1448 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1451 /* Compute the `throws' information for the method. */
1452 tree table
= null_pointer_node
;
1453 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1455 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1456 tree iter
, type
, array
;
1459 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1460 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1462 iter
= TREE_CHAIN (iter
))
1464 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1466 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1467 IDENTIFIER_LENGTH (sig
)));
1468 table
= tree_cons (NULL_TREE
, utf8
, table
);
1470 type
= build_prim_array_type (ptr_type_node
, length
);
1471 table
= build_constructor_from_list (type
, table
);
1472 /* Compute something unique enough. */
1473 sprintf (buf
, "_methods%d", method_name_count
++);
1474 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1475 DECL_INITIAL (array
) = table
;
1476 TREE_STATIC (array
) = 1;
1477 DECL_ARTIFICIAL (array
) = 1;
1478 DECL_IGNORED_P (array
) = 1;
1479 rest_of_decl_compilation (array
, 1, 0);
1481 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1484 PUSH_FIELD_VALUE (minit
, "throws", table
);
1487 FINISH_RECORD_CONSTRUCTOR (minit
);
1492 get_dispatch_vector (tree type
)
1494 tree vtable
= TYPE_VTABLE (type
);
1496 if (vtable
== NULL_TREE
)
1500 tree super
= CLASSTYPE_SUPER (type
);
1501 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1502 vtable
= make_tree_vec (nvirtuals
);
1503 TYPE_VTABLE (type
) = vtable
;
1504 if (super
!= NULL_TREE
)
1506 tree super_vtable
= get_dispatch_vector (super
);
1508 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1509 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1512 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1513 method
= TREE_CHAIN (method
))
1515 tree method_index
= get_method_index (method
);
1516 if (method_index
!= NULL_TREE
1517 && host_integerp (method_index
, 0))
1518 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1526 get_dispatch_table (tree type
, tree this_class_addr
)
1528 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1529 tree vtable
= get_dispatch_vector (type
);
1531 tree list
= NULL_TREE
;
1532 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1536 for (i
= nvirtuals
; --i
>= 0; )
1538 tree method
= TREE_VEC_ELT (vtable
, i
);
1539 if (METHOD_ABSTRACT (method
))
1542 warning (0, "%Jabstract method in non-abstract class", method
);
1544 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1545 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1546 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1548 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1552 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1553 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1555 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1556 method
, build_int_cst (NULL_TREE
, j
));
1557 TREE_CONSTANT (fdesc
) = 1;
1558 TREE_INVARIANT (fdesc
) = 1;
1559 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1562 list
= tree_cons (NULL_TREE
,
1563 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1569 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1570 using the Boehm GC we sometimes stash a GC type descriptor
1571 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1572 the emitted byte count during the output to the assembly file. */
1573 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1574 fake "function descriptor". It's first word is the is the class
1575 pointer, and subsequent words (usually one) contain the GC descriptor.
1576 In all other cases, we reserve two extra vtable slots. */
1577 gc_descr
= get_boehm_type_descriptor (type
);
1578 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1579 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1580 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1581 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1583 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1584 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1585 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1586 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1588 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1589 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1590 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1592 return build_constructor_from_list
1593 (build_prim_array_type (nativecode_ptr_type_node
,
1598 /* Set the method_index for a method decl. */
1600 set_method_index (tree decl
, tree method_index
)
1602 if (method_index
!= NULL_TREE
)
1604 /* method_index is null if we're using indirect dispatch. */
1605 method_index
= fold (convert (sizetype
, method_index
));
1607 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1608 /* Add one to skip bogus descriptor for class and GC descriptor. */
1609 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1611 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1613 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1616 DECL_VINDEX (decl
) = method_index
;
1619 /* Get the method_index for a method decl. */
1621 get_method_index (tree decl
)
1623 tree method_index
= DECL_VINDEX (decl
);
1628 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1629 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1630 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1632 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1633 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1635 return method_index
;
1639 supers_all_compiled (tree type
)
1641 while (type
!= NULL_TREE
)
1643 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1645 type
= CLASSTYPE_SUPER (type
);
1651 make_class_data (tree type
)
1653 tree decl
, cons
, temp
;
1654 tree field
, fields_decl
;
1655 tree static_fields
= NULL_TREE
;
1656 tree instance_fields
= NULL_TREE
;
1657 HOST_WIDE_INT static_field_count
= 0;
1658 HOST_WIDE_INT instance_field_count
= 0;
1659 HOST_WIDE_INT field_count
;
1660 tree field_array_type
;
1662 tree methods
= NULL_TREE
;
1663 tree dtable_decl
= NULL_TREE
;
1664 HOST_WIDE_INT method_count
= 0;
1665 tree method_array_type
;
1668 tree this_class_addr
;
1669 tree constant_pool_constructor
;
1670 tree interfaces
= null_pointer_node
;
1671 int interface_len
= 0;
1672 int uses_jv_markobj
= 0;
1673 tree type_decl
= TYPE_NAME (type
);
1674 tree id_main
= get_identifier("main");
1675 tree id_class
= get_identifier("java.lang.Class");
1676 /** Offset from start of virtual function table declaration
1677 to where objects actually point at, following new g++ ABI. */
1678 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1679 VEC(int, heap
) *field_indexes
;
1680 tree first_real_field
;
1682 this_class_addr
= build_static_class_ref (type
);
1683 decl
= TREE_OPERAND (this_class_addr
, 0);
1685 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1686 && !flag_indirect_dispatch
)
1688 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1689 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1690 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1692 /* We've already created some other class, and consequently
1693 we made class_dtable_decl. Now we just want to fill it
1695 dtable_decl
= class_dtable_decl
;
1699 dtable_decl
= build_dtable_decl (type
);
1700 TREE_STATIC (dtable_decl
) = 1;
1701 DECL_ARTIFICIAL (dtable_decl
) = 1;
1702 DECL_IGNORED_P (dtable_decl
) = 1;
1705 TREE_PUBLIC (dtable_decl
) = 1;
1706 DECL_INITIAL (dtable_decl
) = dtable
;
1707 /* The only dispatch table exported from a DSO is the dispatch
1708 table for java.lang.Class. */
1709 if (DECL_NAME (type_decl
) != id_class
)
1711 if (! flag_indirect_classes
)
1712 rest_of_decl_compilation (dtable_decl
, 1, 0);
1713 /* Maybe we're compiling Class as the first class. If so, set
1714 class_dtable_decl to the decl we just made. */
1715 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1716 class_dtable_decl
= dtable_decl
;
1719 /* Build Field array. */
1720 field
= TYPE_FIELDS (type
);
1721 while (field
&& DECL_ARTIFICIAL (field
))
1722 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1723 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1724 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1725 first_real_field
= field
;
1727 /* First count static and instance fields. */
1728 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1730 if (! DECL_ARTIFICIAL (field
))
1732 if (FIELD_STATIC (field
))
1733 static_field_count
++;
1734 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1735 instance_field_count
++;
1738 field_count
= static_field_count
+ instance_field_count
;
1739 field_indexes
= VEC_alloc (int, heap
, field_count
);
1741 /* gcj sorts fields so that static fields come first, followed by
1742 instance fields. Unfortunately, by the time this takes place we
1743 have already generated the reflection_data for this class, and
1744 that data contains indexes into the fields. So, we generate a
1745 permutation that maps each original field index to its final
1746 position. Then we pass this permutation to
1747 rewrite_reflection_indexes(), which fixes up the reflection
1751 int static_count
= 0;
1752 int instance_count
= static_field_count
;
1755 for (i
= 0, field
= first_real_field
;
1757 field
= TREE_CHAIN (field
), i
++)
1759 if (! DECL_ARTIFICIAL (field
))
1762 if (FIELD_STATIC (field
))
1763 field_index
= static_count
++;
1764 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1765 field_index
= instance_count
++;
1766 VEC_quick_push (int, field_indexes
, field_index
);
1771 for (field
= first_real_field
; field
!= NULL_TREE
;
1772 field
= TREE_CHAIN (field
))
1774 if (! DECL_ARTIFICIAL (field
))
1776 if (FIELD_STATIC (field
))
1778 /* We must always create reflection data for static fields
1779 as it is used in the creation of the field itself. */
1780 tree init
= make_field_value (field
);
1781 tree initial
= DECL_INITIAL (field
);
1782 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1783 /* If the initial value is a string constant,
1784 prevent output_constant from trying to assemble the value. */
1785 if (initial
!= NULL_TREE
1786 && TREE_TYPE (initial
) == string_ptr_type_node
)
1787 DECL_INITIAL (field
) = NULL_TREE
;
1788 rest_of_decl_compilation (field
, 1, 1);
1789 DECL_INITIAL (field
) = initial
;
1791 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1793 tree init
= make_field_value (field
);
1794 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1799 if (field_count
> 0)
1801 static_fields
= nreverse (static_fields
);
1802 instance_fields
= nreverse (instance_fields
);
1803 static_fields
= chainon (static_fields
, instance_fields
);
1804 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1805 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1807 DECL_INITIAL (fields_decl
) = build_constructor_from_list
1808 (field_array_type
, static_fields
);
1809 TREE_STATIC (fields_decl
) = 1;
1810 DECL_ARTIFICIAL (fields_decl
) = 1;
1811 DECL_IGNORED_P (fields_decl
) = 1;
1812 rest_of_decl_compilation (fields_decl
, 1, 0);
1815 fields_decl
= NULL_TREE
;
1817 /* Build Method array. */
1818 for (method
= TYPE_METHODS (type
);
1819 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1822 if (METHOD_PRIVATE (method
)
1823 && ! flag_keep_inline_functions
1826 /* Even if we have a decl, we don't necessarily have the code.
1827 This can happen if we inherit a method from a superclass for
1828 which we don't have a .class file. */
1829 if (METHOD_DUMMY (method
))
1832 /* Generate method reflection data if:
1834 - !flag_reduced_reflection.
1836 - <clinit> -- The runtime uses reflection to initialize the
1839 - Any method in class java.lang.Class -- Class.forName() and
1840 perhaps other things require it.
1842 - class$ -- It does not work if reflection data missing.
1844 - main -- Reflection is used to find main(String[]) methods.
1846 - public not static -- It is potentially part of an
1847 interface. The runtime uses reflection data to build
1848 interface dispatch tables. */
1849 if (!flag_reduced_reflection
1850 || DECL_CLINIT_P (method
)
1851 || DECL_NAME (type_decl
) == id_class
1852 || DECL_NAME (method
) == id_main
1853 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1855 init
= make_method_value (method
);
1857 methods
= tree_cons (NULL_TREE
, init
, methods
);
1860 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1861 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1863 DECL_INITIAL (methods_decl
) = build_constructor_from_list
1864 (method_array_type
, nreverse (methods
));
1865 TREE_STATIC (methods_decl
) = 1;
1866 DECL_ARTIFICIAL (methods_decl
) = 1;
1867 DECL_IGNORED_P (methods_decl
) = 1;
1868 rest_of_decl_compilation (methods_decl
, 1, 0);
1870 if (class_dtable_decl
== NULL_TREE
)
1872 class_dtable_decl
= build_dtable_decl (class_type_node
);
1873 TREE_STATIC (class_dtable_decl
) = 1;
1874 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1875 DECL_IGNORED_P (class_dtable_decl
) = 1;
1876 if (is_compiled_class (class_type_node
) != 2)
1878 DECL_EXTERNAL (class_dtable_decl
) = 1;
1879 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1883 super
= CLASSTYPE_SUPER (type
);
1884 if (super
== NULL_TREE
)
1885 super
= null_pointer_node
;
1886 else if (! flag_indirect_dispatch
1887 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1888 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1889 super
= build_class_ref (super
);
1892 int super_index
= alloc_class_constant (super
);
1893 super
= build_int_cst (ptr_type_node
, super_index
);
1896 /* Build and emit the array of implemented interfaces. */
1897 if (type
!= object_type_node
)
1898 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1900 if (interface_len
> 0)
1902 tree init
= NULL_TREE
;
1904 tree interface_array_type
, idecl
;
1905 interface_array_type
1906 = build_prim_array_type (class_ptr_type
, interface_len
);
1907 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1908 interface_array_type
);
1910 for (i
= interface_len
; i
> 0; i
--)
1912 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1913 tree iclass
= BINFO_TYPE (child
);
1915 if (! flag_indirect_dispatch
1917 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1918 index
= build_class_ref (iclass
);
1921 int int_index
= alloc_class_constant (iclass
);
1922 index
= build_int_cst (ptr_type_node
, int_index
);
1924 init
= tree_cons (NULL_TREE
, index
, init
);
1926 DECL_INITIAL (idecl
) = build_constructor_from_list (interface_array_type
,
1928 TREE_STATIC (idecl
) = 1;
1929 DECL_ARTIFICIAL (idecl
) = 1;
1930 DECL_IGNORED_P (idecl
) = 1;
1931 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1932 rest_of_decl_compilation (idecl
, 1, 0);
1935 constant_pool_constructor
= build_constants_constructor ();
1937 if (flag_indirect_dispatch
)
1939 TYPE_OTABLE_DECL (type
)
1941 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
1942 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
1943 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
1945 TYPE_ATABLE_DECL (type
)
1947 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
1948 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
1949 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
1951 TYPE_ITABLE_DECL (type
)
1953 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
1954 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
1955 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
1958 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
1960 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
1961 PUSH_FIELD_VALUE (temp
, "vtable",
1962 (flag_indirect_classes
1964 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
1965 build1 (ADDR_EXPR
, dtable_ptr_type
,
1967 dtable_start_offset
)));
1968 if (! flag_hash_synchronization
)
1969 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
1970 FINISH_RECORD_CONSTRUCTOR (temp
);
1971 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
1972 PUSH_SUPER_VALUE (cons
, temp
);
1973 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
1974 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
1975 PUSH_FIELD_VALUE (cons
, "accflags",
1976 build_int_cst (NULL_TREE
,
1977 get_access_flags_from_decl (type_decl
)));
1979 PUSH_FIELD_VALUE (cons
, "superclass",
1980 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
1981 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
1982 PUSH_FIELD_VALUE (cons
, "methods",
1983 methods_decl
== NULL_TREE
? null_pointer_node
1984 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
1985 PUSH_FIELD_VALUE (cons
, "method_count",
1986 build_int_cst (NULL_TREE
, method_count
));
1988 if (flag_indirect_dispatch
)
1989 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
1991 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
1993 PUSH_FIELD_VALUE (cons
, "fields",
1994 fields_decl
== NULL_TREE
? null_pointer_node
1995 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
1996 /* If we're using the binary compatibility ABI we don't know the
1997 size until load time. */
1998 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
1999 (flag_indirect_dispatch
2000 ? integer_minus_one_node
2001 : size_in_bytes (type
)));
2002 PUSH_FIELD_VALUE (cons
, "field_count",
2003 build_int_cst (NULL_TREE
, field_count
));
2004 PUSH_FIELD_VALUE (cons
, "static_field_count",
2005 build_int_cst (NULL_TREE
, static_field_count
));
2007 if (flag_indirect_dispatch
)
2008 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
2010 PUSH_FIELD_VALUE (cons
, "vtable",
2011 dtable_decl
== NULL_TREE
? null_pointer_node
2012 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2013 build1 (ADDR_EXPR
, dtable_ptr_type
,
2015 dtable_start_offset
));
2016 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
2018 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
2019 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
2023 pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type
));
2024 PUSH_FIELD_VALUE (cons
, "otable",
2025 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
2026 PUSH_FIELD_VALUE (cons
, "otable_syms",
2027 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2028 TYPE_OTABLE_SYMS_DECL (type
)));
2029 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
2030 TREE_INVARIANT (TYPE_OTABLE_DECL (type
)) = 1;
2032 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
2034 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
2035 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
2039 pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type
));
2040 PUSH_FIELD_VALUE (cons
, "atable",
2041 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
2042 PUSH_FIELD_VALUE (cons
, "atable_syms",
2043 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2044 TYPE_ATABLE_SYMS_DECL (type
)));
2045 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
2046 TREE_INVARIANT (TYPE_ATABLE_DECL (type
)) = 1;
2048 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
2050 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
2051 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
2055 pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type
));
2056 PUSH_FIELD_VALUE (cons
, "itable",
2057 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
2058 PUSH_FIELD_VALUE (cons
, "itable_syms",
2059 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2060 TYPE_ITABLE_SYMS_DECL (type
)));
2061 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
2062 TREE_INVARIANT (TYPE_ITABLE_DECL (type
)) = 1;
2065 PUSH_FIELD_VALUE (cons
, "catch_classes",
2066 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2067 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
2068 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
2069 PUSH_FIELD_VALUE (cons
, "interface_count",
2070 build_int_cst (NULL_TREE
, interface_len
));
2071 PUSH_FIELD_VALUE (cons
, "state",
2072 convert (byte_type_node
,
2073 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2075 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
2076 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
2077 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
2078 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
2079 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
2080 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
2083 tree assertion_table_ref
;
2084 if (TYPE_ASSERTIONS (type
) == NULL
)
2085 assertion_table_ref
= null_pointer_node
;
2087 assertion_table_ref
= build1 (ADDR_EXPR
,
2088 build_pointer_type (assertion_table_type
),
2089 emit_assertion_table (type
));
2091 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
2094 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
2095 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
2096 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
2097 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
2099 if (TYPE_REFLECTION_DATA (current_class
))
2102 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2103 VEC (constructor_elt
, gc
) *v
2104 = VEC_alloc (constructor_elt
, gc
, count
);
2105 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2106 tree max_index
= build_int_cst (sizetype
, count
);
2107 tree index
= build_index_type (max_index
);
2108 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2111 static int reflection_data_count
;
2113 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2114 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
2116 rewrite_reflection_indexes (field_indexes
);
2118 for (i
= 0; i
< count
; i
++)
2120 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
2121 elt
->index
= build_int_cst (sizetype
, i
);
2122 elt
->value
= build_int_cstu (byte_type_node
, data
[i
]);
2125 DECL_INITIAL (array
) = build_constructor (type
, v
);
2126 TREE_STATIC (array
) = 1;
2127 DECL_ARTIFICIAL (array
) = 1;
2128 DECL_IGNORED_P (array
) = 1;
2129 TREE_READONLY (array
) = 1;
2130 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2131 rest_of_decl_compilation (array
, 1, 0);
2133 PUSH_FIELD_VALUE (cons
, "reflection_data", build_address_of (array
));
2136 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2139 PUSH_FIELD_VALUE (cons
, "reflection_data", null_pointer_node
);
2141 FINISH_RECORD_CONSTRUCTOR (cons
);
2143 DECL_INITIAL (decl
) = cons
;
2145 /* Hash synchronization requires at least 64-bit alignment. */
2146 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2147 DECL_ALIGN (decl
) = 64;
2149 if (flag_indirect_classes
)
2151 TREE_READONLY (decl
) = 1;
2152 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2155 rest_of_decl_compilation (decl
, 1, 0);
2158 tree classdollar_field
= build_classdollar_field (type
);
2159 if (!flag_indirect_classes
)
2160 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2161 rest_of_decl_compilation (classdollar_field
, 1, 0);
2164 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2165 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2166 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2172 java_expand_catch_classes (current_class
);
2174 current_function_decl
= NULL_TREE
;
2175 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2176 make_class_data (current_class
);
2178 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2181 /* Return 2 if CLASS is compiled by this compilation job;
2182 return 1 if CLASS can otherwise be assumed to be compiled;
2183 return 0 if we cannot assume that CLASS is compiled.
2184 Returns 1 for primitive and 0 for array types. */
2186 is_compiled_class (tree
class)
2189 if (TREE_CODE (class) == POINTER_TYPE
)
2190 class = TREE_TYPE (class);
2191 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
2193 if (TYPE_ARRAY_P (class))
2196 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
2197 if (CLASS_FROM_CURRENTLY_COMPILED_P (class))
2199 /* The class was seen in the current ZIP file and will be
2200 available as a compiled class in the future but may not have
2201 been loaded already. Load it if necessary. This prevent
2202 build_class_ref () from crashing. */
2204 if (seen_in_zip
&& !CLASS_LOADED_P (class) && (class != current_class
))
2205 load_class (class, 1);
2207 /* We return 2 for class seen in ZIP and class from files
2208 belonging to the same compilation unit */
2212 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
2214 if (!CLASS_LOADED_P (class))
2216 if (class != current_class
)
2217 load_class (class, 1);
2225 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2228 build_dtable_decl (tree type
)
2232 /* We need to build a new dtable type so that its size is uniquely
2233 computed when we're dealing with the class for real and not just
2234 faking it (like java.lang.Class during the initialization of the
2235 compiler.) We know we're not faking a class when CURRENT_CLASS is
2237 if (current_class
== type
)
2239 tree dummy
= NULL_TREE
;
2242 dtype
= make_node (RECORD_TYPE
);
2244 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
2245 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
2247 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
2248 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2250 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2251 TREE_CHAIN (dummy
) = tmp_field
;
2252 DECL_CONTEXT (tmp_field
) = dtype
;
2253 DECL_ARTIFICIAL (tmp_field
) = 1;
2257 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
2258 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2260 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2261 TREE_CHAIN (dummy
) = tmp_field
;
2262 DECL_CONTEXT (tmp_field
) = dtype
;
2263 DECL_ARTIFICIAL (tmp_field
) = 1;
2267 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2268 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2269 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2271 PUSH_FIELD (dtype
, dummy
, "methods",
2272 build_prim_array_type (nativecode_ptr_type_node
, n
));
2273 layout_type (dtype
);
2276 dtype
= dtable_type
;
2278 decl
= build_decl (VAR_DECL
, get_identifier ("vt$"), dtype
);
2279 DECL_CONTEXT (decl
) = type
;
2280 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2281 DECL_VTABLE_P (decl
) = 1;
2286 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2287 fields inherited from SUPER_CLASS. */
2290 push_super_field (tree this_class
, tree super_class
)
2293 /* Don't insert the field if we're just re-laying the class out. */
2294 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2296 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
2297 DECL_IGNORED_P (base_decl
) = 1;
2298 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2299 TYPE_FIELDS (this_class
) = base_decl
;
2300 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2301 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2304 /* Handle the different manners we may have to lay out a super class. */
2307 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2311 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2313 if (!CLASS_LOADED_P (super_class
))
2314 load_class (super_class
, 1);
2316 /* We might have to layout the class before its dependency on
2317 the super class gets resolved by java_complete_class */
2318 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2320 if (TREE_TYPE (super_class
) != NULL_TREE
)
2321 super_class
= TREE_TYPE (super_class
);
2325 if (!TYPE_SIZE (super_class
))
2326 safe_layout_class (super_class
);
2331 /* safe_layout_class just makes sure that we can load a class without
2332 disrupting the current_class, input_file, input_line, etc, information
2333 about the class processed currently. */
2336 safe_layout_class (tree
class)
2338 tree save_current_class
= current_class
;
2339 location_t save_location
= input_location
;
2341 layout_class (class);
2343 current_class
= save_current_class
;
2344 input_location
= save_location
;
2348 layout_class (tree this_class
)
2351 tree super_class
= CLASSTYPE_SUPER (this_class
);
2353 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2354 if (CLASS_BEING_LAIDOUT (this_class
))
2360 sprintf (buffer
, " with '%s'",
2361 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2362 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2364 for (current
= TREE_CHAIN (class_list
); current
;
2365 current
= TREE_CHAIN (current
))
2367 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2368 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2369 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2370 DECL_SOURCE_FILE (decl
),
2371 DECL_SOURCE_LINE (decl
));
2372 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2374 obstack_1grow (&temporary_obstack
, '\0');
2375 report
= obstack_finish (&temporary_obstack
);
2376 cyclic_inheritance_report
= ggc_strdup (report
);
2377 obstack_free (&temporary_obstack
, report
);
2378 TYPE_SIZE (this_class
) = error_mark_node
;
2381 CLASS_BEING_LAIDOUT (this_class
) = 1;
2383 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2385 tree maybe_super_class
2386 = maybe_layout_super_class (super_class
, this_class
);
2387 if (maybe_super_class
== NULL
2388 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2390 TYPE_SIZE (this_class
) = error_mark_node
;
2391 CLASS_BEING_LAIDOUT (this_class
) = 0;
2392 class_list
= TREE_CHAIN (class_list
);
2395 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2396 push_super_field (this_class
, maybe_super_class
);
2399 layout_type (this_class
);
2401 /* Also recursively load/layout any superinterfaces. */
2402 if (TYPE_BINFO (this_class
))
2404 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2406 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2407 tree super_interface
= BINFO_TYPE (binfo
);
2408 tree maybe_super_interface
2409 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2410 if (maybe_super_interface
== NULL
2411 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2413 TYPE_SIZE (this_class
) = error_mark_node
;
2414 CLASS_BEING_LAIDOUT (this_class
) = 0;
2415 class_list
= TREE_CHAIN (class_list
);
2421 /* Convert the size back to an SI integer value. */
2422 TYPE_SIZE_UNIT (this_class
) =
2423 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2425 CLASS_BEING_LAIDOUT (this_class
) = 0;
2426 class_list
= TREE_CHAIN (class_list
);
2430 add_miranda_methods (tree base_class
, tree search_class
)
2433 tree binfo
, base_binfo
;
2435 if (!CLASS_PARSED_P (search_class
))
2436 load_class (search_class
, 1);
2438 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2439 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2442 tree elt
= BINFO_TYPE (base_binfo
);
2444 /* FIXME: This is totally bogus. We should not be handling
2445 Miranda methods at all if we're using the BC ABI. */
2446 if (TYPE_DUMMY (elt
))
2449 /* Ensure that interface methods are seen in declared order. */
2450 if (!CLASS_LOADED_P (elt
))
2451 load_class (elt
, 1);
2452 layout_class_methods (elt
);
2454 /* All base classes will have been laid out at this point, so the order
2455 will be correct. This code must match similar layout code in the
2457 for (method_decl
= TYPE_METHODS (elt
);
2458 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2462 /* An interface can have <clinit>. */
2463 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2466 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2467 override
= lookup_argument_method (base_class
,
2468 DECL_NAME (method_decl
), sig
);
2469 if (override
== NULL_TREE
)
2471 /* Found a Miranda method. Add it. */
2473 sig
= build_java_signature (TREE_TYPE (method_decl
));
2475 = add_method (base_class
,
2476 get_access_flags_from_decl (method_decl
),
2477 DECL_NAME (method_decl
), sig
);
2478 METHOD_INVISIBLE (new_method
) = 1;
2482 /* Try superinterfaces. */
2483 add_miranda_methods (base_class
, elt
);
2488 layout_class_methods (tree this_class
)
2490 tree method_decl
, dtable_count
;
2491 tree super_class
, type_name
;
2493 if (TYPE_NVIRTUALS (this_class
))
2496 super_class
= CLASSTYPE_SUPER (this_class
);
2500 super_class
= maybe_layout_super_class (super_class
, this_class
);
2501 if (!TYPE_NVIRTUALS (super_class
))
2502 layout_class_methods (super_class
);
2503 dtable_count
= TYPE_NVIRTUALS (super_class
);
2506 dtable_count
= integer_zero_node
;
2508 type_name
= TYPE_NAME (this_class
);
2509 if (!flag_indirect_dispatch
2510 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2512 /* An abstract class can have methods which are declared only in
2513 an implemented interface. These are called "Miranda
2514 methods". We make a dummy method entry for such methods
2516 add_miranda_methods (this_class
, this_class
);
2519 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2521 for (method_decl
= TYPE_METHODS (this_class
);
2522 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2523 dtable_count
= layout_class_method (this_class
, super_class
,
2524 method_decl
, dtable_count
);
2526 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2529 /* Return the index of METHOD in INTERFACE. This index begins at 1
2530 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2532 get_interface_method_index (tree method
, tree interface
)
2537 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
))
2541 /* We don't want to put <clinit> into the interface table. */
2542 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2544 gcc_assert (meth
!= NULL_TREE
);
2548 /* Lay METHOD_DECL out, returning a possibly new value of
2549 DTABLE_COUNT. Also mangle the method's name. */
2552 layout_class_method (tree this_class
, tree super_class
,
2553 tree method_decl
, tree dtable_count
)
2555 tree method_name
= DECL_NAME (method_decl
);
2557 TREE_PUBLIC (method_decl
) = 1;
2559 if (flag_indirect_classes
2560 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2561 && ! METHOD_NATIVE (method_decl
)
2562 && ! special_method_p (method_decl
)))
2565 /* Considered external unless it is being compiled into this object
2566 file, or it was already flagged as external. */
2567 if (!DECL_EXTERNAL (method_decl
))
2568 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2569 || METHOD_NATIVE (method_decl
));
2571 if (ID_INIT_P (method_name
))
2573 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2575 for (ptr
= p
; *ptr
; )
2580 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2581 build_java_signature (TREE_TYPE (method_decl
));
2583 else if (! METHOD_STATIC (method_decl
))
2586 build_java_signature (TREE_TYPE (method_decl
));
2587 bool method_override
= false;
2588 tree super_method
= lookup_java_method (super_class
, method_name
,
2590 if (super_method
!= NULL_TREE
2591 && ! METHOD_DUMMY (super_method
))
2593 method_override
= true;
2594 if (! METHOD_PUBLIC (super_method
) &&
2595 ! METHOD_PROTECTED (super_method
))
2597 /* Don't override private method, or default-access method in
2599 if (METHOD_PRIVATE (super_method
) ||
2600 ! in_same_package (TYPE_NAME (this_class
),
2601 TYPE_NAME (super_class
)))
2602 method_override
= false;
2605 if (method_override
)
2607 tree method_index
= get_method_index (super_method
);
2608 set_method_index (method_decl
, method_index
);
2609 if (method_index
== NULL_TREE
2610 && ! flag_indirect_dispatch
2611 && ! DECL_ARTIFICIAL (super_method
))
2612 error ("non-static method %q+D overrides static method",
2615 else if (this_class
== object_type_node
2616 && (METHOD_FINAL (method_decl
)
2617 || METHOD_PRIVATE (method_decl
)))
2619 /* We don't generate vtable entries for final Object
2620 methods. This is simply to save space, since every
2621 object would otherwise have to define them. */
2623 else if (! METHOD_PRIVATE (method_decl
)
2626 /* We generate vtable entries for final methods because they
2627 may one day be changed to non-final. */
2628 set_method_index (method_decl
, dtable_count
);
2629 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2630 dtable_count
, integer_one_node
);
2634 return dtable_count
;
2638 register_class (void)
2642 if (!registered_class
)
2643 registered_class
= VEC_alloc (tree
, gc
, 8);
2645 if (flag_indirect_classes
)
2646 node
= current_class
;
2648 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2649 VEC_safe_push (tree
, gc
, registered_class
, node
);
2652 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2653 all the classes we have emitted. */
2656 emit_indirect_register_classes (tree
*list_p
)
2658 tree klass
, t
, register_class_fn
;
2661 tree init
= NULL_TREE
;
2662 int size
= VEC_length (tree
, registered_class
) * 2 + 1;
2663 tree class_array_type
2664 = build_prim_array_type (ptr_type_node
, size
);
2665 tree
cdecl = build_decl (VAR_DECL
, get_identifier ("_Jv_CLS"),
2667 tree reg_class_list
;
2668 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2670 init
= tree_cons (NULL_TREE
,
2671 fold_convert (ptr_type_node
,
2672 build_static_class_ref (klass
)), init
);
2675 fold_convert (ptr_type_node
,
2676 build_address_of (build_classdollar_field (klass
))),
2679 init
= tree_cons (NULL_TREE
, integer_zero_node
, init
);
2680 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type
,
2682 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2683 TREE_STATIC (cdecl) = 1;
2684 DECL_ARTIFICIAL (cdecl) = 1;
2685 DECL_IGNORED_P (cdecl) = 1;
2686 TREE_READONLY (cdecl) = 1;
2687 TREE_CONSTANT (cdecl) = 1;
2688 rest_of_decl_compilation (cdecl, 1, 0);
2689 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2691 t
= build_function_type_list (void_type_node
,
2692 build_pointer_type (ptr_type_node
), NULL
);
2693 t
= build_decl (FUNCTION_DECL
,
2694 get_identifier ("_Jv_RegisterNewClasses"), t
);
2695 TREE_PUBLIC (t
) = 1;
2696 DECL_EXTERNAL (t
) = 1;
2697 register_class_fn
= t
;
2698 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2699 append_to_statement_list (t
, list_p
);
2703 /* Emit something to register classes at start-up time.
2705 The preferred mechanism is through the .jcr section, which contain
2706 a list of pointers to classes which get registered during constructor
2709 The fallback mechanism is to add statements to *LIST_P to call
2710 _Jv_RegisterClass for each class in this file. These statements will
2711 be added to a static constructor function for this translation unit. */
2714 emit_register_classes (tree
*list_p
)
2716 if (registered_class
== NULL
)
2719 if (flag_indirect_classes
)
2721 emit_indirect_register_classes (list_p
);
2725 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2726 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2727 but lack suitable crtbegin/end objects or linker support. These
2728 targets can override the default in tm.h to use the fallback mechanism. */
2729 if (TARGET_USE_JCR_SECTION
)
2734 #ifdef JCR_SECTION_NAME
2735 switch_to_section (get_section (JCR_SECTION_NAME
, SECTION_WRITE
, NULL
));
2737 /* A target has defined TARGET_USE_JCR_SECTION,
2738 but doesn't have a JCR_SECTION_NAME. */
2741 assemble_align (POINTER_SIZE
);
2743 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2745 t
= build_fold_addr_expr (klass
);
2746 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2751 tree klass
, t
, register_class_fn
;
2754 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2755 t
= build_decl (FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2756 TREE_PUBLIC (t
) = 1;
2757 DECL_EXTERNAL (t
) = 1;
2758 register_class_fn
= t
;
2760 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2762 t
= build_fold_addr_expr (klass
);
2763 t
= build_call_expr (register_class_fn
, 1, t
);
2764 append_to_statement_list (t
, list_p
);
2769 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2772 build_symbol_entry (tree decl
, tree special
)
2774 tree clname
, name
, signature
, sym
;
2775 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2776 /* ??? Constructors are given the name foo.foo all the way through
2777 the compiler, but in the method table they're all renamed
2778 foo.<init>. So, we have to do the same here unless we want an
2779 unresolved reference at runtime. */
2780 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2781 && DECL_CONSTRUCTOR_P (decl
))
2782 ? init_identifier_node
2783 : DECL_NAME (decl
));
2784 signature
= build_java_signature (TREE_TYPE (decl
));
2785 signature
= build_utf8_ref (unmangle_classname
2786 (IDENTIFIER_POINTER (signature
),
2787 IDENTIFIER_LENGTH (signature
)));
2788 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2789 signature addr+1 if SPECIAL, and this indicates to the runtime
2790 system that this is a "special" symbol, i.e. one that should
2791 bypass access controls. */
2792 if (special
!= NULL_TREE
)
2793 signature
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (signature
), signature
,
2794 fold_convert (sizetype
, special
));
2796 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2797 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2798 PUSH_FIELD_VALUE (sym
, "name", name
);
2799 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2800 FINISH_RECORD_CONSTRUCTOR (sym
);
2801 TREE_CONSTANT (sym
) = 1;
2802 TREE_INVARIANT (sym
) = 1;
2807 /* Emit a symbol table: used by -findirect-dispatch. */
2810 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2811 tree the_syms_decl
, tree the_array_element_type
,
2814 tree method_list
, method
, table
, list
, null_symbol
;
2815 tree table_size
, the_array_type
;
2818 /* Only emit a table if this translation unit actually made any
2819 references via it. */
2820 if (decl_list
== NULL_TREE
)
2823 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2825 method_list
= decl_list
;
2827 while (method_list
!= NULL_TREE
)
2829 tree special
= TREE_PURPOSE (method_list
);
2830 method
= TREE_VALUE (method_list
);
2831 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
, special
), list
);
2832 method_list
= TREE_CHAIN (method_list
);
2836 /* Terminate the list with a "null" entry. */
2837 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2838 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2839 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2840 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2841 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2842 TREE_CONSTANT (null_symbol
) = 1;
2843 TREE_INVARIANT (null_symbol
) = 1;
2844 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2846 /* Put the list in the right order and make it a constructor. */
2847 list
= nreverse (list
);
2848 table
= build_constructor_from_list (symbols_array_type
, list
);
2850 /* Make it the initial value for otable_syms and emit the decl. */
2851 DECL_INITIAL (the_syms_decl
) = table
;
2852 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2853 DECL_IGNORED_P (the_syms_decl
) = 1;
2854 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2856 /* Now that its size is known, redefine the table as an
2857 uninitialized static array of INDEX + 1 elements. The extra entry
2858 is used by the runtime to track whether the table has been
2861 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2862 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2863 the_table
= build_decl (VAR_DECL
, name
, the_array_type
);
2864 TREE_STATIC (the_table
) = 1;
2865 TREE_READONLY (the_table
) = 1;
2866 rest_of_decl_compilation (the_table
, 1, 0);
2871 /* Make an entry for the catch_classes list. */
2873 make_catch_class_record (tree catch_class
, tree classname
)
2876 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2877 START_RECORD_CONSTRUCTOR (entry
, type
);
2878 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2879 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2880 FINISH_RECORD_CONSTRUCTOR (entry
);
2885 /* Generate the list of Throwable classes that are caught by exception
2886 handlers in this class. */
2888 emit_catch_table (tree this_class
)
2890 tree table
, table_size
, array_type
;
2891 TYPE_CATCH_CLASSES (this_class
) =
2893 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2894 TYPE_CATCH_CLASSES (this_class
));
2895 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2896 TYPE_CATCH_CLASSES (this_class
) =
2898 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2899 TYPE_CATCH_CLASSES (this_class
));
2900 table_size
= build_index_type
2901 (build_int_cst (NULL_TREE
,
2902 list_length (TYPE_CATCH_CLASSES (this_class
))));
2904 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2907 build_decl (VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2908 DECL_INITIAL (table
) =
2909 build_constructor_from_list (array_type
, TYPE_CATCH_CLASSES (this_class
));
2910 TREE_STATIC (table
) = 1;
2911 TREE_READONLY (table
) = 1;
2912 DECL_IGNORED_P (table
) = 1;
2913 rest_of_decl_compilation (table
, 1, 0);
2917 /* Given a type, return the signature used by
2918 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2919 same as build_java_signature() because we want the canonical array
2923 build_signature_for_libgcj (tree type
)
2927 sig
= build_java_signature (type
);
2928 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
2929 IDENTIFIER_LENGTH (sig
)));
2933 /* Add an entry to the type assertion table. Callback used during hashtable
2937 add_assertion_table_entry (void **htab_entry
, void *ptr
)
2940 tree code_val
, op1_utf8
, op2_utf8
;
2941 tree
*list
= (tree
*) ptr
;
2942 type_assertion
*as
= (type_assertion
*) *htab_entry
;
2944 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
2946 if (as
->op1
== NULL_TREE
)
2947 op1_utf8
= null_pointer_node
;
2949 op1_utf8
= build_signature_for_libgcj (as
->op1
);
2951 if (as
->op2
== NULL_TREE
)
2952 op2_utf8
= null_pointer_node
;
2954 op2_utf8
= build_signature_for_libgcj (as
->op2
);
2956 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
2957 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
2958 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
2959 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
2960 FINISH_RECORD_CONSTRUCTOR (entry
);
2962 *list
= tree_cons (NULL_TREE
, entry
, *list
);
2966 /* Generate the type assertion table for CLASS, and return its DECL. */
2969 emit_assertion_table (tree
class)
2971 tree null_entry
, ctor
, table_decl
;
2972 tree list
= NULL_TREE
;
2973 htab_t assertions_htab
= TYPE_ASSERTIONS (class);
2975 /* Iterate through the hash table. */
2976 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
2978 /* Finish with a null entry. */
2979 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
2980 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
2981 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
2982 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
2983 FINISH_RECORD_CONSTRUCTOR (null_entry
);
2985 list
= tree_cons (NULL_TREE
, null_entry
, list
);
2987 /* Put the list in the right order and make it a constructor. */
2988 list
= nreverse (list
);
2989 ctor
= build_constructor_from_list (assertion_table_type
, list
);
2991 table_decl
= build_decl (VAR_DECL
, mangled_classname ("_type_assert_", class),
2992 assertion_table_type
);
2994 TREE_STATIC (table_decl
) = 1;
2995 TREE_READONLY (table_decl
) = 1;
2996 TREE_CONSTANT (table_decl
) = 1;
2997 DECL_IGNORED_P (table_decl
) = 1;
2999 DECL_INITIAL (table_decl
) = ctor
;
3000 DECL_ARTIFICIAL (table_decl
) = 1;
3001 rest_of_decl_compilation (table_decl
, 1, 0);
3007 init_class_processing (void)
3009 fields_ident
= get_identifier ("fields");
3010 info_ident
= get_identifier ("info");
3012 gcc_obstack_init (&temporary_obstack
);
3015 static hashval_t
java_treetreehash_hash (const void *);
3016 static int java_treetreehash_compare (const void *, const void *);
3018 /* A hash table mapping trees to trees. Used generally. */
3020 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
3023 java_treetreehash_hash (const void *k_p
)
3025 const struct treetreehash_entry
*const k
3026 = (const struct treetreehash_entry
*) k_p
;
3027 return JAVA_TREEHASHHASH_H (k
->key
);
3031 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3033 const struct treetreehash_entry
*const k1
3034 = (const struct treetreehash_entry
*) k1_p
;
3035 const_tree
const k2
= (const_tree
) k2_p
;
3036 return (k1
->key
== k2
);
3040 java_treetreehash_find (htab_t ht
, tree t
)
3042 struct treetreehash_entry
*e
;
3043 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3044 e
= htab_find_with_hash (ht
, t
, hv
);
3052 java_treetreehash_new (htab_t ht
, tree t
)
3055 struct treetreehash_entry
*tthe
;
3056 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3058 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3061 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
3066 tthe
= (struct treetreehash_entry
*) *e
;
3067 return &tthe
->value
;
3071 java_treetreehash_create (size_t size
, int gc
)
3074 return htab_create_ggc (size
, java_treetreehash_hash
,
3075 java_treetreehash_compare
, NULL
);
3077 return htab_create_alloc (size
, java_treetreehash_hash
,
3078 java_treetreehash_compare
, free
, xcalloc
, free
);
3081 /* Break down qualified IDENTIFIER into package and class-name components.
3082 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3083 "pkg.foo", and RIGHT to "Bar". */
3086 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3089 int l
= IDENTIFIER_LENGTH (source
);
3091 base
= alloca (l
+ 1);
3092 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3094 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3096 while (*p
!= '.' && p
!= base
)
3099 /* We didn't find a '.'. Return an error. */
3105 *right
= get_identifier (p
+1);
3106 *left
= get_identifier (base
);
3111 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3112 if the classes are from the same package. */
3115 in_same_package (tree name1
, tree name2
)
3121 if (TREE_CODE (name1
) == TYPE_DECL
)
3122 name1
= DECL_NAME (name1
);
3123 if (TREE_CODE (name2
) == TYPE_DECL
)
3124 name2
= DECL_NAME (name2
);
3126 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3127 /* One in empty package. */
3130 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3131 /* Both in empty package. */
3134 split_qualified_name (&pkg1
, &tmp
, name1
);
3135 split_qualified_name (&pkg2
, &tmp
, name2
);
3137 return (pkg1
== pkg2
);
3140 #include "gt-java-class.h"