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, 2010 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"
32 #include "java-tree.h"
42 #include "tree-iterator.h"
44 #include "tm.h" /* FIXME: For gcc_obstack_init from defaults.h. */
46 /* DOS brain-damage */
48 #define O_BINARY 0 /* MS-DOS brain-damage */
51 static tree
make_method_value (tree
);
52 static tree
build_java_method_type (tree
, tree
, int);
53 static int32
hashUtf8String (const char *, int);
54 static tree
make_field_value (tree
);
55 static tree
get_dispatch_vector (tree
);
56 static tree
get_dispatch_table (tree
, tree
);
57 static int supers_all_compiled (tree type
);
58 static tree
maybe_layout_super_class (tree
, tree
);
59 static void add_miranda_methods (tree
, tree
);
60 static int assume_compiled (const char *);
61 static tree
build_symbol_entry (tree
, tree
);
62 static tree
emit_assertion_table (tree
);
63 static void register_class (void);
65 struct obstack temporary_obstack
;
67 static const char *cyclic_inheritance_report
;
69 /* The compiler generates different code depending on whether or not
70 it can assume certain classes have been compiled down to native
71 code or not. The compiler options -fassume-compiled= and
72 -fno-assume-compiled= are used to create a tree of
73 class_flag_node objects. This tree is queried to determine if
74 a class is assume to be compiled or not. Each node in the tree
75 represents either a package or a specific class. */
77 typedef struct class_flag_node_struct
79 /* The class or package name. */
82 /* Nonzero if this represents an exclusion. */
85 /* Pointers to other nodes in the tree. */
86 struct class_flag_node_struct
*parent
;
87 struct class_flag_node_struct
*sibling
;
88 struct class_flag_node_struct
*child
;
91 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
92 static void add_class_flag (class_flag_node
**, const char *, int);
94 /* This is the root of the include/exclude tree. */
96 static class_flag_node
*assume_compiled_tree
;
98 static class_flag_node
*enable_assert_tree
;
100 static GTY(()) tree class_roots
[4];
101 #define fields_ident class_roots[0] /* get_identifier ("fields") */
102 #define info_ident class_roots[1] /* get_identifier ("info") */
103 #define class_list class_roots[2]
104 #define class_dtable_decl class_roots[3]
106 static GTY(()) VEC(tree
,gc
) *registered_class
;
108 /* A tree that returns the address of the class$ of the class
109 currently being compiled. */
110 static GTY(()) tree this_classdollar
;
112 /* A list of static class fields. This is to emit proper debug
114 VEC(tree
,gc
) *pending_static_fields
;
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
);
385 TYPE_CATCH_CLASSES (type
) = NULL
;
386 /* Push a dummy entry; we can't call make_catch_class_record here
387 because other infrastructure may not be set up yet. We'll come
388 back and fill it in later once said infrastructure is
390 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (type
), NULL_TREE
, NULL_TREE
);
395 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
396 and where each of the constituents is separated by '/',
397 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
400 unmangle_classname (const char *name
, int name_length
)
402 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
403 /* It's not sufficient to compare to_return and get_identifier
404 (name) to determine whether to_return is qualified. There are
405 cases in signature analysis where name will be stripped of a
407 name
= IDENTIFIER_POINTER (to_return
);
411 QUALIFIED_P (to_return
) = 1;
418 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
421 const char *type_name = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
422 char *buf = (char *) alloca (strlen (type_name) \
423 + strlen (#NAME "_syms_") + 1); \
426 sprintf (buf, #NAME "_%s", type_name); \
427 TYPE_## TABLE ##_DECL (type) = decl = \
428 build_decl (input_location, VAR_DECL, get_identifier (buf), TABLE_TYPE); \
429 DECL_EXTERNAL (decl) = 1; \
430 TREE_STATIC (decl) = 1; \
431 TREE_READONLY (decl) = 1; \
432 TREE_CONSTANT (decl) = 1; \
433 DECL_IGNORED_P (decl) = 1; \
434 /* Mark the table as belonging to this class. */ \
436 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
437 DECL_OWNER (decl) = TYPE; \
438 sprintf (buf, #NAME "_syms_%s", type_name); \
439 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
440 build_decl (input_location, VAR_DECL, get_identifier (buf), symbols_array_type); \
441 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
442 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
443 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
447 /* Given a class, create the DECLs for all its associated indirect
450 gen_indirect_dispatch_tables (tree type
)
452 const char *type_name
= IDENTIFIER_POINTER (mangled_classname ("", type
));
455 char *buf
= (char *) alloca (strlen (type_name
)
456 + strlen ("_catch_classes_") + 1);
457 tree catch_class_type
= make_node (RECORD_TYPE
);
459 sprintf (buf
, "_catch_classes_%s", type_name
);
460 PUSH_FIELD (input_location
,
461 catch_class_type
, field
, "address", utf8const_ptr_type
);
462 PUSH_FIELD (input_location
,
463 catch_class_type
, field
, "classname", ptr_type_node
);
464 FINISH_RECORD (catch_class_type
);
466 TYPE_CTABLE_DECL (type
)
467 = build_decl (input_location
, VAR_DECL
, get_identifier (buf
),
468 build_array_type (catch_class_type
, 0));
469 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
470 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
471 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
472 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
473 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
474 pushdecl (TYPE_CTABLE_DECL (type
));
477 if (flag_indirect_dispatch
)
479 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
480 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
481 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
488 push_class (tree class_type
, tree class_name
)
490 tree decl
, signature
;
491 location_t saved_loc
= input_location
;
492 CLASS_P (class_type
) = 1;
493 decl
= build_decl (input_location
, TYPE_DECL
, class_name
, class_type
);
494 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
496 /* dbxout needs a DECL_SIZE if in gstabs mode */
497 DECL_SIZE (decl
) = integer_zero_node
;
499 input_location
= saved_loc
;
500 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
501 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
503 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
504 both a typedef and in the struct name-space. We may want to re-visit
505 this later, but for now it reduces the changes needed for gdb. */
506 DECL_ARTIFICIAL (decl
) = 1;
508 pushdecl_top_level (decl
);
513 /* Finds the (global) class named NAME. Creates the class if not found.
514 Also creates associated TYPE_DECL.
515 Does not check if the class actually exists, load the class,
516 fill in field or methods, or do layout_type. */
519 lookup_class (tree name
)
521 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
522 if (decl
== NULL_TREE
)
523 decl
= push_class (make_class (), name
);
524 return TREE_TYPE (decl
);
528 set_super_info (int access_flags
, tree this_class
,
529 tree super_class
, int interfaces_count
)
531 int total_supers
= interfaces_count
;
532 tree class_decl
= TYPE_NAME (this_class
);
538 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
539 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
542 tree super_binfo
= make_tree_binfo (0);
543 BINFO_TYPE (super_binfo
) = super_class
;
544 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
545 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
546 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
549 set_class_decl_access_flags (access_flags
, class_decl
);
553 set_class_decl_access_flags (int access_flags
, tree class_decl
)
555 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
556 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
557 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
558 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
559 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
560 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
561 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
562 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
563 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
564 if (access_flags
& ACC_ENUM
) CLASS_ENUM (class_decl
) = 1;
565 if (access_flags
& ACC_SYNTHETIC
) CLASS_SYNTHETIC (class_decl
) = 1;
566 if (access_flags
& ACC_ANNOTATION
) CLASS_ANNOTATION (class_decl
) = 1;
569 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
570 direct sub-classes of Object are 1, and so on. */
573 class_depth (tree clas
)
576 if (! CLASS_LOADED_P (clas
))
577 load_class (clas
, 1);
578 if (TYPE_SIZE (clas
) == error_mark_node
)
580 while (clas
!= object_type_node
)
583 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
588 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
591 interface_of_p (tree type1
, tree type2
)
594 tree binfo
, base_binfo
;
596 if (! TYPE_BINFO (type2
))
599 for (binfo
= TYPE_BINFO (type2
), i
= 0;
600 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
601 if (BINFO_TYPE (base_binfo
) == type1
)
604 for (binfo
= TYPE_BINFO (type2
), i
= 0;
605 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
606 if (BINFO_TYPE (base_binfo
)
607 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
613 /* Return true iff TYPE1 inherits from TYPE2. */
616 inherits_from_p (tree type1
, tree type2
)
618 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
623 if (! CLASS_LOADED_P (type1
))
624 load_class (type1
, 1);
626 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
631 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
634 enclosing_context_p (tree type1
, tree type2
)
636 if (!INNER_CLASS_TYPE_P (type2
))
639 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
641 type2
= (INNER_CLASS_TYPE_P (type2
) ?
642 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
652 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
656 common_enclosing_context_p (tree type1
, tree type2
)
661 for (current
= type2
; current
;
662 current
= (INNER_CLASS_TYPE_P (current
) ?
663 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
665 if (type1
== current
)
668 if (INNER_CLASS_TYPE_P (type1
))
669 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
676 /* Return 1 iff there exists a common enclosing "this" between TYPE1
677 and TYPE2, without crossing any static context. */
680 common_enclosing_instance_p (tree type1
, tree type2
)
682 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
685 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
686 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
687 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
690 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
691 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
692 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
694 if (type1
== current
)
700 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
701 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
702 if attempt is made to add it twice. */
705 maybe_add_interface (tree this_class
, tree interface_class
)
707 tree binfo
, base_binfo
;
710 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
711 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
712 if (BINFO_TYPE (base_binfo
) == interface_class
)
713 return interface_class
;
714 add_interface (this_class
, interface_class
);
718 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
721 add_interface (tree this_class
, tree interface_class
)
723 tree interface_binfo
= make_tree_binfo (0);
725 BINFO_TYPE (interface_binfo
) = interface_class
;
726 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
727 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
728 BINFO_VIRTUAL_P (interface_binfo
) = 1;
730 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
734 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
736 if (access_flags
& ACC_STATIC
)
738 fntype
= build_method_type (this_class
, fntype
);
740 /* We know that arg 1 of every nonstatic method is non-null; tell
742 TYPE_ATTRIBUTES (fntype
) = (tree_cons
743 (get_identifier ("nonnull"),
744 tree_cons (NULL_TREE
,
745 build_int_cst (NULL_TREE
, 1),
747 TYPE_ATTRIBUTES (fntype
)));
752 java_hide_decl (tree decl ATTRIBUTE_UNUSED
)
754 #ifdef HAVE_GAS_HIDDEN
755 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
756 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
761 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
763 tree method_type
, fndecl
;
765 method_type
= build_java_method_type (function_type
,
766 this_class
, access_flags
);
768 fndecl
= build_decl (input_location
, FUNCTION_DECL
, name
, method_type
);
769 DECL_CONTEXT (fndecl
) = this_class
;
771 DECL_LANG_SPECIFIC (fndecl
)
772 = ggc_alloc_cleared_lang_decl(sizeof (struct lang_decl
));
773 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
775 /* Initialize the static initializer test table. */
777 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) = java_treetreehash_create (10);
779 /* Initialize the initialized (static) class table. */
780 if (access_flags
& ACC_STATIC
)
781 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
782 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
784 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
785 TYPE_METHODS (this_class
) = fndecl
;
787 /* If pointers to member functions use the least significant bit to
788 indicate whether a function is virtual, ensure a pointer
789 to this function will have that bit clear. */
790 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
791 && !(access_flags
& ACC_STATIC
)
792 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
793 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
795 /* Notice that this is a finalizer and update the class type
796 accordingly. This is used to optimize instance allocation. */
797 if (name
== finalize_identifier_node
798 && TREE_TYPE (function_type
) == void_type_node
799 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
800 HAS_FINALIZER_P (this_class
) = 1;
802 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
803 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
804 if (access_flags
& ACC_PRIVATE
)
805 METHOD_PRIVATE (fndecl
) = 1;
806 if (access_flags
& ACC_NATIVE
)
808 METHOD_NATIVE (fndecl
) = 1;
809 DECL_EXTERNAL (fndecl
) = 1;
812 /* FNDECL is external unless we are compiling it into this object
814 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
815 if (access_flags
& ACC_STATIC
)
816 METHOD_STATIC (fndecl
) = 1;
817 if (access_flags
& ACC_FINAL
)
818 METHOD_FINAL (fndecl
) = 1;
819 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
820 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
821 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
822 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
823 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
824 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
828 /* Add a method to THIS_CLASS.
829 The method's name is NAME.
830 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
833 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
835 tree function_type
, fndecl
;
836 const unsigned char *sig
837 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
840 fatal_error ("bad method signature");
842 function_type
= get_type_from_signature (method_sig
);
843 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
844 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
849 add_field (tree klass
, tree name
, tree field_type
, int flags
)
851 int is_static
= (flags
& ACC_STATIC
) != 0;
853 field
= build_decl (input_location
,
854 is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
855 TREE_CHAIN (field
) = TYPE_FIELDS (klass
);
856 TYPE_FIELDS (klass
) = field
;
857 DECL_CONTEXT (field
) = klass
;
858 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
860 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
861 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
862 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
863 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
864 if (flags
& ACC_VOLATILE
)
866 FIELD_VOLATILE (field
) = 1;
867 TREE_THIS_VOLATILE (field
) = 1;
869 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
870 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
871 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
874 FIELD_STATIC (field
) = 1;
875 /* Always make field externally visible. This is required so
876 that native methods can always access the field. */
877 TREE_PUBLIC (field
) = 1;
878 /* Hide everything that shouldn't be visible outside a DSO. */
879 if (flag_indirect_classes
880 || (FIELD_PRIVATE (field
)))
881 java_hide_decl (field
);
882 /* Considered external unless we are compiling it into this
884 DECL_EXTERNAL (field
) = (is_compiled_class (klass
) != 2);
885 if (!DECL_EXTERNAL (field
))
886 VEC_safe_push (tree
, gc
, pending_static_fields
, field
);
892 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
895 set_constant_value (tree field
, tree constant
)
897 if (field
== NULL_TREE
)
898 warning (OPT_Wattributes
,
899 "misplaced ConstantValue attribute (not in any field)");
900 else if (DECL_INITIAL (field
) != NULL_TREE
)
901 warning (OPT_Wattributes
,
902 "duplicate ConstantValue attribute for field '%s'",
903 IDENTIFIER_POINTER (DECL_NAME (field
)));
906 DECL_INITIAL (field
) = constant
;
907 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
908 && ! (TREE_TYPE (constant
) == int_type_node
909 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
910 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
911 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
912 && TREE_TYPE (field
) == string_ptr_type_node
))
913 error ("ConstantValue attribute of field '%s' has wrong type",
914 IDENTIFIER_POINTER (DECL_NAME (field
)));
918 /* Calculate a hash value for a string encoded in Utf8 format.
919 * This returns the same hash value as specified for java.lang.String.hashCode.
923 hashUtf8String (const char *str
, int len
)
925 const unsigned char* ptr
= (const unsigned char*) str
;
926 const unsigned char *limit
= ptr
+ len
;
930 int ch
= UTF8_GET (ptr
, limit
);
931 /* Updated specification from
932 http://www.javasoft.com/docs/books/jls/clarify.html. */
933 hash
= (31 * hash
) + ch
;
939 build_utf8_ref (tree name
)
941 const char * name_ptr
= IDENTIFIER_POINTER (name
);
942 int name_len
= IDENTIFIER_LENGTH (name
), name_pad
;
944 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
945 static int utf8_count
= 0;
947 tree ref
= IDENTIFIER_UTF8_REF (name
);
949 VEC(constructor_elt
,gc
) *v
= NULL
;
950 if (ref
!= NULL_TREE
)
953 ctype
= make_node (RECORD_TYPE
);
954 /* '\0' byte plus padding to utf8const_type's alignment. */
955 name_pad
= TYPE_ALIGN_UNIT (utf8const_type
)
956 - (name_len
& (TYPE_ALIGN_UNIT (utf8const_type
) - 1));
957 str_type
= build_prim_array_type (unsigned_byte_type_node
,
958 name_len
+ name_pad
);
959 PUSH_FIELD (input_location
, ctype
, field
, "hash", unsigned_short_type_node
);
960 PUSH_FIELD (input_location
,
961 ctype
, field
, "length", unsigned_short_type_node
);
962 PUSH_FIELD (input_location
, ctype
, field
, "data", str_type
);
963 FINISH_RECORD (ctype
);
964 START_RECORD_CONSTRUCTOR (v
, ctype
);
965 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
966 PUSH_FIELD_VALUE (v
, "hash", build_int_cst (NULL_TREE
, name_hash
));
967 PUSH_FIELD_VALUE (v
, "length", build_int_cst (NULL_TREE
, name_len
));
968 string
= build_string (name_len
, name_ptr
);
969 TREE_TYPE (string
) = str_type
;
970 PUSH_FIELD_VALUE (v
, "data", string
);
971 FINISH_RECORD_CONSTRUCTOR (cinit
, v
, ctype
);
972 TREE_CONSTANT (cinit
) = 1;
974 /* Generate a unique-enough identifier. */
975 sprintf(buf
, "_Utf%d", ++utf8_count
);
977 decl
= build_decl (input_location
,
978 VAR_DECL
, get_identifier (buf
), utf8const_type
);
979 TREE_STATIC (decl
) = 1;
980 DECL_ARTIFICIAL (decl
) = 1;
981 DECL_IGNORED_P (decl
) = 1;
982 TREE_READONLY (decl
) = 1;
983 TREE_THIS_VOLATILE (decl
) = 0;
984 DECL_INITIAL (decl
) = cinit
;
986 if (HAVE_GAS_SHF_MERGE
)
989 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
990 decl_size
= name_len
+ 4 + name_pad
;
991 if (flag_merge_constants
&& decl_size
< 256)
994 int flags
= (SECTION_OVERRIDE
995 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
996 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
997 switch_to_section (get_section (buf
, flags
, NULL
));
998 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
1002 layout_decl (decl
, 0);
1003 DECL_SIZE (decl
) = TYPE_SIZE (ctype
);
1004 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (ctype
);
1006 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
1007 varpool_mark_needed_node (varpool_node (decl
));
1008 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
1009 IDENTIFIER_UTF8_REF (name
) = ref
;
1013 /* Like build_class_ref, but instead of a direct reference generate a
1014 pointer into the constant pool. */
1017 build_indirect_class_ref (tree type
)
1021 index
= alloc_class_constant (type
);
1022 cl
= build_ref_from_constant_pool (index
);
1023 return convert (promote_type (class_ptr_type
), cl
);
1027 build_static_class_ref (tree type
)
1029 tree decl_name
, decl
, ref
;
1031 if (TYPE_SIZE (type
) == error_mark_node
)
1032 return null_pointer_node
;
1033 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1034 "", '/', '/', ".class$$");
1035 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1036 if (decl
== NULL_TREE
)
1038 decl
= build_decl (input_location
, VAR_DECL
, decl_name
, class_type_node
);
1039 TREE_STATIC (decl
) = 1;
1040 if (! flag_indirect_classes
)
1042 TREE_PUBLIC (decl
) = 1;
1043 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1044 java_hide_decl (decl
);
1046 DECL_IGNORED_P (decl
) = 1;
1047 DECL_ARTIFICIAL (decl
) = 1;
1048 if (is_compiled_class (type
) == 1)
1049 DECL_EXTERNAL (decl
) = 1;
1050 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1051 DECL_CLASS_FIELD_P (decl
) = 1;
1052 DECL_CONTEXT (decl
) = type
;
1054 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1055 that that means not calling pushdecl_top_level. */
1056 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1059 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1064 build_classdollar_field (tree type
)
1066 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1067 "", '/', '/', ".class$");
1068 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1070 if (decl
== NULL_TREE
)
1073 = build_decl (input_location
,
1074 VAR_DECL
, decl_name
,
1077 (build_type_variant (class_type_node
,
1079 /* const */ 1, 0)));
1080 TREE_STATIC (decl
) = 1;
1081 TREE_CONSTANT (decl
) = 1;
1082 TREE_READONLY (decl
) = 1;
1083 TREE_PUBLIC (decl
) = 1;
1084 java_hide_decl (decl
);
1085 DECL_IGNORED_P (decl
) = 1;
1086 DECL_ARTIFICIAL (decl
) = 1;
1087 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1088 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1089 DECL_CLASS_FIELD_P (decl
) = 1;
1090 DECL_CONTEXT (decl
) = type
;
1096 /* Create a local variable that holds the current class$. */
1099 cache_this_class_ref (tree fndecl
)
1103 tree classdollar_field
;
1104 if (flag_indirect_classes
)
1105 classdollar_field
= build_classdollar_field (output_class
);
1107 classdollar_field
= build_static_class_ref (output_class
);
1109 this_classdollar
= build_decl (input_location
,
1110 VAR_DECL
, NULL_TREE
,
1111 TREE_TYPE (classdollar_field
));
1113 java_add_local_var (this_classdollar
);
1114 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1115 this_classdollar
, classdollar_field
));
1118 this_classdollar
= build_classdollar_field (output_class
);
1120 /* Prepend class initialization for static methods reachable from
1122 if (METHOD_STATIC (fndecl
)
1123 && (! METHOD_PRIVATE (fndecl
)
1124 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1125 && ! DECL_CLINIT_P (fndecl
)
1126 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1128 tree init
= build_call_expr (soft_initclass_node
, 1,
1130 java_add_stmt (init
);
1134 /* Remove the reference to the local variable that holds the current
1138 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1140 this_classdollar
= build_classdollar_field (output_class
);
1143 /* Build a reference to the class TYPE.
1144 Also handles primitive types and array types. */
1147 build_class_ref (tree type
)
1149 int is_compiled
= is_compiled_class (type
);
1153 if (TREE_CODE (type
) == POINTER_TYPE
)
1154 type
= TREE_TYPE (type
);
1156 if (flag_indirect_dispatch
1157 && type
!= output_class
1158 && TREE_CODE (type
) == RECORD_TYPE
)
1159 return build_indirect_class_ref (type
);
1161 if (type
== output_class
&& flag_indirect_classes
)
1163 /* This can be NULL if we see a JNI stub before we see any
1165 if (! this_classdollar
)
1166 this_classdollar
= build_classdollar_field (output_class
);
1167 return this_classdollar
;
1170 if (TREE_CODE (type
) == RECORD_TYPE
)
1171 return build_static_class_ref (type
);
1177 decl_name
= TYPE_NAME (type
);
1178 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1179 decl_name
= DECL_NAME (decl_name
);
1180 name
= IDENTIFIER_POINTER (decl_name
);
1181 if (strncmp (name
, "promoted_", 9) == 0)
1183 sprintf (buffer
, "_Jv_%sClass", name
);
1184 decl_name
= get_identifier (buffer
);
1185 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1186 if (decl
== NULL_TREE
)
1188 decl
= build_decl (input_location
,
1189 VAR_DECL
, decl_name
, class_type_node
);
1190 TREE_STATIC (decl
) = 1;
1191 TREE_PUBLIC (decl
) = 1;
1192 DECL_EXTERNAL (decl
) = 1;
1193 DECL_ARTIFICIAL (decl
) = 1;
1194 pushdecl_top_level (decl
);
1198 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1202 return build_indirect_class_ref (type
);
1205 /* Create a local statically allocated variable that will hold a
1206 pointer to a static field. */
1209 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1211 tree decl
, decl_name
;
1212 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1213 char *buf
= (char *) alloca (strlen (name
) + 20);
1214 sprintf (buf
, "%s_%d_ref", name
, index
);
1215 decl_name
= get_identifier (buf
);
1216 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1217 if (decl
== NULL_TREE
)
1219 decl
= build_decl (input_location
,
1220 VAR_DECL
, decl_name
, ptr_type_node
);
1221 TREE_STATIC (decl
) = 1;
1222 TREE_PUBLIC (decl
) = 0;
1223 DECL_EXTERNAL (decl
) = 0;
1224 DECL_ARTIFICIAL (decl
) = 1;
1225 DECL_IGNORED_P (decl
) = 1;
1226 pushdecl_top_level (decl
);
1232 build_static_field_ref (tree fdecl
)
1234 tree fclass
= DECL_CONTEXT (fdecl
);
1235 int is_compiled
= is_compiled_class (fclass
);
1237 /* Allow static final fields to fold to a constant. When using
1238 -findirect-dispatch, we simply never do this folding if compiling
1239 from .class; in the .class file constants will be referred to via
1240 the constant pool. */
1241 if (!flag_indirect_dispatch
1243 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1244 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1245 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1246 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1248 if (is_compiled
== 1)
1249 DECL_EXTERNAL (fdecl
) = 1;
1253 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1254 and a class local static variable CACHE_ENTRY, then
1256 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1257 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1260 This can mostly be optimized away, so that the usual path is a
1261 load followed by a test and branch. _Jv_ResolvePoolEntry is
1262 only called once for each constant pool entry.
1264 There is an optimization that we don't do: at the start of a
1265 method, create a local copy of CACHE_ENTRY and use that instead.
1269 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1270 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1272 = build_call_expr (built_in_decls
[BUILT_IN_EXPECT
], 2,
1273 build2 (EQ_EXPR
, boolean_type_node
,
1274 cache_entry
, null_pointer_node
),
1275 boolean_false_node
);
1276 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1278 = build_call_expr (soft_resolvepoolentry_node
, 2,
1279 build_class_ref (output_class
),
1281 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1282 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1283 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1284 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1290 get_access_flags_from_decl (tree decl
)
1292 int access_flags
= 0;
1293 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1295 if (FIELD_STATIC (decl
))
1296 access_flags
|= ACC_STATIC
;
1297 if (FIELD_PUBLIC (decl
))
1298 access_flags
|= ACC_PUBLIC
;
1299 if (FIELD_PROTECTED (decl
))
1300 access_flags
|= ACC_PROTECTED
;
1301 if (FIELD_PRIVATE (decl
))
1302 access_flags
|= ACC_PRIVATE
;
1303 if (FIELD_FINAL (decl
))
1304 access_flags
|= ACC_FINAL
;
1305 if (FIELD_VOLATILE (decl
))
1306 access_flags
|= ACC_VOLATILE
;
1307 if (FIELD_TRANSIENT (decl
))
1308 access_flags
|= ACC_TRANSIENT
;
1309 if (FIELD_ENUM (decl
))
1310 access_flags
|= ACC_ENUM
;
1311 if (FIELD_SYNTHETIC (decl
))
1312 access_flags
|= ACC_SYNTHETIC
;
1313 return access_flags
;
1315 if (TREE_CODE (decl
) == TYPE_DECL
)
1317 if (CLASS_PUBLIC (decl
))
1318 access_flags
|= ACC_PUBLIC
;
1319 if (CLASS_FINAL (decl
))
1320 access_flags
|= ACC_FINAL
;
1321 if (CLASS_SUPER (decl
))
1322 access_flags
|= ACC_SUPER
;
1323 if (CLASS_INTERFACE (decl
))
1324 access_flags
|= ACC_INTERFACE
;
1325 if (CLASS_ABSTRACT (decl
))
1326 access_flags
|= ACC_ABSTRACT
;
1327 if (CLASS_STATIC (decl
))
1328 access_flags
|= ACC_STATIC
;
1329 if (CLASS_PRIVATE (decl
))
1330 access_flags
|= ACC_PRIVATE
;
1331 if (CLASS_PROTECTED (decl
))
1332 access_flags
|= ACC_PROTECTED
;
1333 if (CLASS_STRICTFP (decl
))
1334 access_flags
|= ACC_STRICT
;
1335 if (CLASS_ENUM (decl
))
1336 access_flags
|= ACC_ENUM
;
1337 if (CLASS_SYNTHETIC (decl
))
1338 access_flags
|= ACC_SYNTHETIC
;
1339 if (CLASS_ANNOTATION (decl
))
1340 access_flags
|= ACC_ANNOTATION
;
1341 return access_flags
;
1343 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1345 if (METHOD_PUBLIC (decl
))
1346 access_flags
|= ACC_PUBLIC
;
1347 if (METHOD_PRIVATE (decl
))
1348 access_flags
|= ACC_PRIVATE
;
1349 if (METHOD_PROTECTED (decl
))
1350 access_flags
|= ACC_PROTECTED
;
1351 if (METHOD_STATIC (decl
))
1352 access_flags
|= ACC_STATIC
;
1353 if (METHOD_FINAL (decl
))
1354 access_flags
|= ACC_FINAL
;
1355 if (METHOD_SYNCHRONIZED (decl
))
1356 access_flags
|= ACC_SYNCHRONIZED
;
1357 if (METHOD_NATIVE (decl
))
1358 access_flags
|= ACC_NATIVE
;
1359 if (METHOD_ABSTRACT (decl
))
1360 access_flags
|= ACC_ABSTRACT
;
1361 if (METHOD_STRICTFP (decl
))
1362 access_flags
|= ACC_STRICT
;
1363 if (METHOD_INVISIBLE (decl
))
1364 access_flags
|= ACC_INVISIBLE
;
1365 if (DECL_ARTIFICIAL (decl
))
1366 access_flags
|= ACC_SYNTHETIC
;
1367 if (METHOD_BRIDGE (decl
))
1368 access_flags
|= ACC_BRIDGE
;
1369 if (METHOD_VARARGS (decl
))
1370 access_flags
|= ACC_VARARGS
;
1371 return access_flags
;
1376 static GTY (()) int alias_labelno
= 0;
1378 /* Create a private alias for METHOD. Using this alias instead of the method
1379 decl ensures that ncode entries in the method table point to the real function
1380 at runtime, not a PLT entry. */
1383 make_local_function_alias (tree method
)
1385 #ifdef ASM_OUTPUT_DEF
1388 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1389 char *name
= (char *) alloca (strlen (method_name
) + 2);
1390 char *buf
= (char *) alloca (strlen (method_name
) + 128);
1392 /* Only create aliases for local functions. */
1393 if (DECL_EXTERNAL (method
))
1396 /* Prefix method_name with 'L' for the alias label. */
1398 strcpy (name
+ 1, method_name
);
1400 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1401 alias
= build_decl (input_location
,
1402 FUNCTION_DECL
, get_identifier (buf
),
1403 TREE_TYPE (method
));
1404 DECL_CONTEXT (alias
) = NULL
;
1405 TREE_READONLY (alias
) = TREE_READONLY (method
);
1406 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1407 TREE_PUBLIC (alias
) = 0;
1408 DECL_EXTERNAL (alias
) = 0;
1409 DECL_ARTIFICIAL (alias
) = 1;
1410 DECL_INITIAL (alias
) = error_mark_node
;
1411 TREE_ADDRESSABLE (alias
) = 1;
1412 TREE_USED (alias
) = 1;
1413 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1414 if (!flag_syntax_only
)
1415 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1422 /** Make reflection data (_Jv_Field) for field FDECL. */
1425 make_field_value (tree fdecl
)
1429 tree type
= TREE_TYPE (fdecl
);
1430 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1431 VEC(constructor_elt
,gc
) *v
= NULL
;
1433 START_RECORD_CONSTRUCTOR (v
, field_type_node
);
1434 PUSH_FIELD_VALUE (v
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1436 type
= build_class_ref (type
);
1439 tree signature
= build_java_signature (type
);
1441 type
= build_utf8_ref (unmangle_classname
1442 (IDENTIFIER_POINTER (signature
),
1443 IDENTIFIER_LENGTH (signature
)));
1445 PUSH_FIELD_VALUE (v
, "type", type
);
1447 flags
= get_access_flags_from_decl (fdecl
);
1449 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1451 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, flags
));
1452 PUSH_FIELD_VALUE (v
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1455 tree field_address
= integer_zero_node
;
1456 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1457 && FIELD_STATIC (fdecl
))
1458 field_address
= build_address_of (fdecl
);
1462 build_constructor_from_list (field_info_union_node
,
1464 ((FIELD_STATIC (fdecl
)
1465 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1466 : TYPE_FIELDS (field_info_union_node
)),
1467 (FIELD_STATIC (fdecl
)
1469 : byte_position (fdecl
)))));
1472 FINISH_RECORD_CONSTRUCTOR (finit
, v
, field_type_node
);
1476 /** Make reflection data (_Jv_Method) for method MDECL. */
1479 make_method_value (tree mdecl
)
1481 static int method_name_count
= 0;
1486 #define ACC_TRANSLATED 0x4000
1487 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1488 VEC(constructor_elt
,gc
) *v
= NULL
;
1490 class_decl
= DECL_CONTEXT (mdecl
);
1491 /* For interfaces, the index field contains the dispatch index. */
1492 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1493 index
= build_int_cst (NULL_TREE
,
1494 get_interface_method_index (mdecl
, class_decl
));
1495 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1496 index
= get_method_index (mdecl
);
1498 index
= integer_minus_one_node
;
1500 code
= null_pointer_node
;
1501 if (METHOD_ABSTRACT (mdecl
))
1502 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1503 soft_abstractmethod_node
);
1505 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1506 make_local_function_alias (mdecl
));
1507 START_RECORD_CONSTRUCTOR (v
, method_type_node
);
1508 PUSH_FIELD_VALUE (v
, "name",
1509 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1510 init_identifier_node
1511 : DECL_NAME (mdecl
)));
1513 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1514 PUSH_FIELD_VALUE (v
, "signature",
1517 (IDENTIFIER_POINTER(signature
),
1518 IDENTIFIER_LENGTH(signature
)))));
1520 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1521 PUSH_FIELD_VALUE (v
, "index", index
);
1522 PUSH_FIELD_VALUE (v
, "ncode", code
);
1525 /* Compute the `throws' information for the method. */
1526 tree table
= null_pointer_node
;
1527 if (DECL_FUNCTION_THROWS (mdecl
) != NULL
)
1529 int length
= 1 + VEC_length (tree
, DECL_FUNCTION_THROWS (mdecl
));
1530 tree t
, type
, array
;
1534 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1536 VEC_iterate (tree
, DECL_FUNCTION_THROWS (mdecl
), ix
, t
);
1539 tree sig
= DECL_NAME (TYPE_NAME (t
));
1541 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1542 IDENTIFIER_LENGTH (sig
)));
1543 table
= tree_cons (NULL_TREE
, utf8
, table
);
1545 type
= build_prim_array_type (ptr_type_node
, length
);
1546 table
= build_constructor_from_list (type
, table
);
1547 /* Compute something unique enough. */
1548 sprintf (buf
, "_methods%d", method_name_count
++);
1549 array
= build_decl (input_location
,
1550 VAR_DECL
, get_identifier (buf
), type
);
1551 DECL_INITIAL (array
) = table
;
1552 TREE_STATIC (array
) = 1;
1553 DECL_ARTIFICIAL (array
) = 1;
1554 DECL_IGNORED_P (array
) = 1;
1555 rest_of_decl_compilation (array
, 1, 0);
1557 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1560 PUSH_FIELD_VALUE (v
, "throws", table
);
1563 FINISH_RECORD_CONSTRUCTOR (minit
, v
, method_type_node
);
1568 get_dispatch_vector (tree type
)
1570 tree vtable
= TYPE_VTABLE (type
);
1572 if (vtable
== NULL_TREE
)
1576 tree super
= CLASSTYPE_SUPER (type
);
1577 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1578 vtable
= make_tree_vec (nvirtuals
);
1579 TYPE_VTABLE (type
) = vtable
;
1580 if (super
!= NULL_TREE
)
1582 tree super_vtable
= get_dispatch_vector (super
);
1584 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1585 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1588 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1589 method
= TREE_CHAIN (method
))
1591 tree method_index
= get_method_index (method
);
1592 if (method_index
!= NULL_TREE
1593 && host_integerp (method_index
, 0))
1594 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1602 get_dispatch_table (tree type
, tree this_class_addr
)
1604 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1605 tree vtable
= get_dispatch_vector (type
);
1607 tree list
= NULL_TREE
;
1608 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1612 for (i
= nvirtuals
; --i
>= 0; )
1614 tree method
= TREE_VEC_ELT (vtable
, i
);
1615 if (METHOD_ABSTRACT (method
))
1618 warning_at (DECL_SOURCE_LOCATION (method
), 0,
1619 "abstract method in non-abstract class");
1621 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1622 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1623 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1625 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1629 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1630 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1632 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1633 method
, build_int_cst (NULL_TREE
, j
));
1634 TREE_CONSTANT (fdesc
) = 1;
1635 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1638 list
= tree_cons (NULL_TREE
,
1639 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1645 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1646 using the Boehm GC we sometimes stash a GC type descriptor
1647 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1648 the emitted byte count during the output to the assembly file. */
1649 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1650 fake "function descriptor". It's first word is the is the class
1651 pointer, and subsequent words (usually one) contain the GC descriptor.
1652 In all other cases, we reserve two extra vtable slots. */
1653 gc_descr
= get_boehm_type_descriptor (type
);
1654 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1655 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1656 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1657 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1659 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1660 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1661 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1662 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1664 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1665 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1666 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1668 return build_constructor_from_list
1669 (build_prim_array_type (nativecode_ptr_type_node
,
1674 /* Set the method_index for a method decl. */
1676 set_method_index (tree decl
, tree method_index
)
1678 if (method_index
!= NULL_TREE
)
1680 /* method_index is null if we're using indirect dispatch. */
1681 method_index
= fold (convert (sizetype
, method_index
));
1683 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1684 /* Add one to skip bogus descriptor for class and GC descriptor. */
1685 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1687 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1689 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1692 DECL_VINDEX (decl
) = method_index
;
1695 /* Get the method_index for a method decl. */
1697 get_method_index (tree decl
)
1699 tree method_index
= DECL_VINDEX (decl
);
1704 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1705 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1706 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1708 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1709 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1711 return method_index
;
1715 supers_all_compiled (tree type
)
1717 while (type
!= NULL_TREE
)
1719 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1721 type
= CLASSTYPE_SUPER (type
);
1727 add_table_and_syms (VEC(constructor_elt
,gc
) **v
,
1728 VEC(method_entry
,gc
) *methods
,
1729 const char *table_name
, tree table_slot
, tree table_type
,
1730 const char *syms_name
, tree syms_slot
)
1732 if (methods
== NULL
)
1734 PUSH_FIELD_VALUE (*v
, table_name
, null_pointer_node
);
1735 PUSH_FIELD_VALUE (*v
, syms_name
, null_pointer_node
);
1739 pushdecl_top_level (syms_slot
);
1740 PUSH_FIELD_VALUE (*v
, table_name
,
1741 build1 (ADDR_EXPR
, table_type
, table_slot
));
1742 PUSH_FIELD_VALUE (*v
, syms_name
,
1743 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1745 TREE_CONSTANT (table_slot
) = 1;
1750 make_class_data (tree type
)
1752 tree decl
, cons
, temp
;
1753 tree field
, fields_decl
;
1754 tree static_fields
= NULL_TREE
;
1755 tree instance_fields
= NULL_TREE
;
1756 HOST_WIDE_INT static_field_count
= 0;
1757 HOST_WIDE_INT instance_field_count
= 0;
1758 HOST_WIDE_INT field_count
;
1759 tree field_array_type
;
1761 tree methods
= NULL_TREE
;
1762 tree dtable_decl
= NULL_TREE
;
1763 HOST_WIDE_INT method_count
= 0;
1764 tree method_array_type
;
1767 tree this_class_addr
;
1768 tree constant_pool_constructor
;
1769 tree interfaces
= null_pointer_node
;
1770 int interface_len
= 0;
1771 int uses_jv_markobj
= 0;
1772 tree type_decl
= TYPE_NAME (type
);
1773 tree id_main
= get_identifier("main");
1774 tree id_class
= get_identifier("java.lang.Class");
1775 /** Offset from start of virtual function table declaration
1776 to where objects actually point at, following new g++ ABI. */
1777 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1778 VEC(int, heap
) *field_indexes
;
1779 tree first_real_field
;
1780 VEC(constructor_elt
,gc
) *v1
= NULL
, *v2
= NULL
;
1781 tree reflection_data
;
1783 this_class_addr
= build_static_class_ref (type
);
1784 decl
= TREE_OPERAND (this_class_addr
, 0);
1786 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1787 && !flag_indirect_dispatch
)
1789 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1790 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1791 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1793 /* We've already created some other class, and consequently
1794 we made class_dtable_decl. Now we just want to fill it
1796 dtable_decl
= class_dtable_decl
;
1800 dtable_decl
= build_dtable_decl (type
);
1801 TREE_STATIC (dtable_decl
) = 1;
1802 DECL_ARTIFICIAL (dtable_decl
) = 1;
1803 DECL_IGNORED_P (dtable_decl
) = 1;
1806 TREE_PUBLIC (dtable_decl
) = 1;
1807 DECL_INITIAL (dtable_decl
) = dtable
;
1808 /* The only dispatch table exported from a DSO is the dispatch
1809 table for java.lang.Class. */
1810 if (DECL_NAME (type_decl
) != id_class
)
1811 java_hide_decl (dtable_decl
);
1812 if (! flag_indirect_classes
)
1813 rest_of_decl_compilation (dtable_decl
, 1, 0);
1814 /* Maybe we're compiling Class as the first class. If so, set
1815 class_dtable_decl to the decl we just made. */
1816 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1817 class_dtable_decl
= dtable_decl
;
1820 /* Build Field array. */
1821 field
= TYPE_FIELDS (type
);
1822 while (field
&& DECL_ARTIFICIAL (field
))
1823 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1824 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1825 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1826 first_real_field
= field
;
1828 /* First count static and instance fields. */
1829 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1831 if (! DECL_ARTIFICIAL (field
))
1833 if (FIELD_STATIC (field
))
1834 static_field_count
++;
1835 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1836 instance_field_count
++;
1839 field_count
= static_field_count
+ instance_field_count
;
1840 field_indexes
= VEC_alloc (int, heap
, field_count
);
1842 /* gcj sorts fields so that static fields come first, followed by
1843 instance fields. Unfortunately, by the time this takes place we
1844 have already generated the reflection_data for this class, and
1845 that data contains indexes into the fields. So, we generate a
1846 permutation that maps each original field index to its final
1847 position. Then we pass this permutation to
1848 rewrite_reflection_indexes(), which fixes up the reflection
1852 int static_count
= 0;
1853 int instance_count
= static_field_count
;
1856 for (i
= 0, field
= first_real_field
;
1858 field
= TREE_CHAIN (field
), i
++)
1860 if (! DECL_ARTIFICIAL (field
))
1863 if (FIELD_STATIC (field
))
1864 field_index
= static_count
++;
1865 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1866 field_index
= instance_count
++;
1869 VEC_quick_push (int, field_indexes
, field_index
);
1874 for (field
= first_real_field
; field
!= NULL_TREE
;
1875 field
= TREE_CHAIN (field
))
1877 if (! DECL_ARTIFICIAL (field
))
1879 if (FIELD_STATIC (field
))
1881 /* We must always create reflection data for static fields
1882 as it is used in the creation of the field itself. */
1883 tree init
= make_field_value (field
);
1884 tree initial
= DECL_INITIAL (field
);
1885 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1886 /* If the initial value is a string constant,
1887 prevent output_constant from trying to assemble the value. */
1888 if (initial
!= NULL_TREE
1889 && TREE_TYPE (initial
) == string_ptr_type_node
)
1890 DECL_INITIAL (field
) = NULL_TREE
;
1891 rest_of_decl_compilation (field
, 1, 1);
1892 DECL_INITIAL (field
) = initial
;
1894 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1896 tree init
= make_field_value (field
);
1897 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1902 if (field_count
> 0)
1904 static_fields
= nreverse (static_fields
);
1905 instance_fields
= nreverse (instance_fields
);
1906 static_fields
= chainon (static_fields
, instance_fields
);
1907 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1908 fields_decl
= build_decl (input_location
,
1909 VAR_DECL
, mangled_classname ("_FL_", type
),
1911 DECL_INITIAL (fields_decl
) = build_constructor_from_list
1912 (field_array_type
, static_fields
);
1913 TREE_STATIC (fields_decl
) = 1;
1914 DECL_ARTIFICIAL (fields_decl
) = 1;
1915 DECL_IGNORED_P (fields_decl
) = 1;
1916 rest_of_decl_compilation (fields_decl
, 1, 0);
1919 fields_decl
= NULL_TREE
;
1921 /* Build Method array. */
1922 for (method
= TYPE_METHODS (type
);
1923 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1926 if (METHOD_PRIVATE (method
)
1927 && ! flag_keep_inline_functions
1930 /* Even if we have a decl, we don't necessarily have the code.
1931 This can happen if we inherit a method from a superclass for
1932 which we don't have a .class file. */
1933 if (METHOD_DUMMY (method
))
1936 /* Generate method reflection data if:
1938 - !flag_reduced_reflection.
1940 - <clinit> -- The runtime uses reflection to initialize the
1943 - Any method in class java.lang.Class -- Class.forName() and
1944 perhaps other things require it.
1946 - class$ -- It does not work if reflection data missing.
1948 - main -- Reflection is used to find main(String[]) methods.
1950 - public not static -- It is potentially part of an
1951 interface. The runtime uses reflection data to build
1952 interface dispatch tables. */
1953 if (!flag_reduced_reflection
1954 || DECL_CLINIT_P (method
)
1955 || DECL_NAME (type_decl
) == id_class
1956 || DECL_NAME (method
) == id_main
1957 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1959 init
= make_method_value (method
);
1961 methods
= tree_cons (NULL_TREE
, init
, methods
);
1964 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1965 methods_decl
= build_decl (input_location
,
1966 VAR_DECL
, mangled_classname ("_MT_", type
),
1968 DECL_INITIAL (methods_decl
) = build_constructor_from_list
1969 (method_array_type
, nreverse (methods
));
1970 TREE_STATIC (methods_decl
) = 1;
1971 DECL_ARTIFICIAL (methods_decl
) = 1;
1972 DECL_IGNORED_P (methods_decl
) = 1;
1973 rest_of_decl_compilation (methods_decl
, 1, 0);
1975 if (class_dtable_decl
== NULL_TREE
)
1977 class_dtable_decl
= build_dtable_decl (class_type_node
);
1978 TREE_STATIC (class_dtable_decl
) = 1;
1979 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1980 DECL_IGNORED_P (class_dtable_decl
) = 1;
1981 if (is_compiled_class (class_type_node
) != 2)
1983 DECL_EXTERNAL (class_dtable_decl
) = 1;
1984 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1988 super
= CLASSTYPE_SUPER (type
);
1989 if (super
== NULL_TREE
)
1990 super
= null_pointer_node
;
1991 else if (! flag_indirect_dispatch
1992 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1993 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1994 super
= build_class_ref (super
);
1997 int super_index
= alloc_class_constant (super
);
1998 super
= build_int_cst (ptr_type_node
, super_index
);
2001 /* Build and emit the array of implemented interfaces. */
2002 if (type
!= object_type_node
)
2003 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
2005 if (interface_len
> 0)
2007 tree init
= NULL_TREE
;
2009 tree interface_array_type
, idecl
;
2010 interface_array_type
2011 = build_prim_array_type (class_ptr_type
, interface_len
);
2012 idecl
= build_decl (input_location
,
2013 VAR_DECL
, mangled_classname ("_IF_", type
),
2014 interface_array_type
);
2016 for (i
= interface_len
; i
> 0; i
--)
2018 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
2019 tree iclass
= BINFO_TYPE (child
);
2021 if (! flag_indirect_dispatch
2023 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
2024 index
= build_class_ref (iclass
);
2027 int int_index
= alloc_class_constant (iclass
);
2028 index
= build_int_cst (ptr_type_node
, int_index
);
2030 init
= tree_cons (NULL_TREE
, index
, init
);
2032 DECL_INITIAL (idecl
) = build_constructor_from_list (interface_array_type
,
2034 TREE_STATIC (idecl
) = 1;
2035 DECL_ARTIFICIAL (idecl
) = 1;
2036 DECL_IGNORED_P (idecl
) = 1;
2037 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
2038 rest_of_decl_compilation (idecl
, 1, 0);
2041 constant_pool_constructor
= build_constants_constructor ();
2043 if (flag_indirect_dispatch
)
2045 TYPE_OTABLE_DECL (type
)
2047 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
2048 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
2049 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
2051 TYPE_ATABLE_DECL (type
)
2053 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
2054 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
2055 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2057 TYPE_ITABLE_DECL (type
)
2059 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2060 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2061 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2064 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2066 START_RECORD_CONSTRUCTOR (v1
, object_type_node
);
2067 PUSH_FIELD_VALUE (v1
, "vtable",
2068 (flag_indirect_classes
2070 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2071 build1 (ADDR_EXPR
, dtable_ptr_type
,
2073 dtable_start_offset
)));
2074 if (! flag_hash_synchronization
)
2075 PUSH_FIELD_VALUE (v1
, "sync_info", null_pointer_node
);
2076 FINISH_RECORD_CONSTRUCTOR (temp
, v1
, object_type_node
);
2077 START_RECORD_CONSTRUCTOR (v2
, class_type_node
);
2078 PUSH_SUPER_VALUE (v2
, temp
);
2079 PUSH_FIELD_VALUE (v2
, "next_or_version", gcj_abi_version
);
2080 PUSH_FIELD_VALUE (v2
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2081 PUSH_FIELD_VALUE (v2
, "accflags",
2082 build_int_cst (NULL_TREE
,
2083 get_access_flags_from_decl (type_decl
)));
2085 PUSH_FIELD_VALUE (v2
, "superclass",
2086 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2087 PUSH_FIELD_VALUE (v2
, "constants", constant_pool_constructor
);
2088 PUSH_FIELD_VALUE (v2
, "methods",
2089 methods_decl
== NULL_TREE
? null_pointer_node
2090 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2091 PUSH_FIELD_VALUE (v2
, "method_count",
2092 build_int_cst (NULL_TREE
, method_count
));
2094 PUSH_FIELD_VALUE (v2
, "vtable_method_count",
2095 (flag_indirect_dispatch
2096 ? integer_minus_one_node
2097 : TYPE_NVIRTUALS (type
)));
2099 PUSH_FIELD_VALUE (v2
, "fields",
2100 fields_decl
== NULL_TREE
? null_pointer_node
2101 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2102 /* If we're using the binary compatibility ABI we don't know the
2103 size until load time. */
2104 PUSH_FIELD_VALUE (v2
, "size_in_bytes",
2105 (flag_indirect_dispatch
2106 ? integer_minus_one_node
2107 : size_in_bytes (type
)));
2108 PUSH_FIELD_VALUE (v2
, "field_count",
2109 build_int_cst (NULL_TREE
, field_count
));
2110 PUSH_FIELD_VALUE (v2
, "static_field_count",
2111 build_int_cst (NULL_TREE
, static_field_count
));
2113 PUSH_FIELD_VALUE (v2
, "vtable",
2114 (flag_indirect_dispatch
|| dtable_decl
== NULL_TREE
2116 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2117 build1 (ADDR_EXPR
, dtable_ptr_type
,
2119 dtable_start_offset
)));
2120 add_table_and_syms (&v2
, TYPE_OTABLE_METHODS (type
),
2121 "otable", TYPE_OTABLE_DECL (type
), otable_ptr_type
,
2122 "otable_syms", TYPE_OTABLE_SYMS_DECL (type
));
2123 add_table_and_syms (&v2
, TYPE_ATABLE_METHODS (type
),
2124 "atable", TYPE_ATABLE_DECL (type
), atable_ptr_type
,
2125 "atable_syms", TYPE_ATABLE_SYMS_DECL (type
));
2126 add_table_and_syms (&v2
, TYPE_ITABLE_METHODS (type
),
2127 "itable", TYPE_ITABLE_DECL (type
), itable_ptr_type
,
2128 "itable_syms", TYPE_ITABLE_SYMS_DECL (type
));
2130 PUSH_FIELD_VALUE (v2
, "catch_classes",
2131 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2132 PUSH_FIELD_VALUE (v2
, "interfaces", interfaces
);
2133 PUSH_FIELD_VALUE (v2
, "loader", null_pointer_node
);
2134 PUSH_FIELD_VALUE (v2
, "interface_count",
2135 build_int_cst (NULL_TREE
, interface_len
));
2136 PUSH_FIELD_VALUE (v2
, "state",
2137 convert (byte_type_node
,
2138 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2140 PUSH_FIELD_VALUE (v2
, "thread", null_pointer_node
);
2141 PUSH_FIELD_VALUE (v2
, "depth", integer_zero_node
);
2142 PUSH_FIELD_VALUE (v2
, "ancestors", null_pointer_node
);
2143 PUSH_FIELD_VALUE (v2
, "idt", null_pointer_node
);
2144 PUSH_FIELD_VALUE (v2
, "arrayclass", null_pointer_node
);
2145 PUSH_FIELD_VALUE (v2
, "protectionDomain", null_pointer_node
);
2148 tree assertion_table_ref
;
2149 if (TYPE_ASSERTIONS (type
) == NULL
)
2150 assertion_table_ref
= null_pointer_node
;
2152 assertion_table_ref
= build1 (ADDR_EXPR
,
2153 build_pointer_type (assertion_table_type
),
2154 emit_assertion_table (type
));
2156 PUSH_FIELD_VALUE (v2
, "assertion_table", assertion_table_ref
);
2159 PUSH_FIELD_VALUE (v2
, "hack_signers", null_pointer_node
);
2160 PUSH_FIELD_VALUE (v2
, "chain", null_pointer_node
);
2161 PUSH_FIELD_VALUE (v2
, "aux_info", null_pointer_node
);
2162 PUSH_FIELD_VALUE (v2
, "engine", null_pointer_node
);
2164 if (TYPE_REFLECTION_DATA (current_class
))
2167 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2168 VEC (constructor_elt
, gc
) *v
2169 = VEC_alloc (constructor_elt
, gc
, count
);
2170 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2171 tree max_index
= build_int_cst (sizetype
, count
);
2172 tree index
= build_index_type (max_index
);
2173 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2176 static int reflection_data_count
;
2178 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2179 array
= build_decl (input_location
,
2180 VAR_DECL
, get_identifier (buf
), type
);
2182 rewrite_reflection_indexes (field_indexes
);
2184 for (i
= 0; i
< count
; i
++)
2186 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
2187 elt
->index
= build_int_cst (sizetype
, i
);
2188 elt
->value
= build_int_cstu (byte_type_node
, data
[i
]);
2191 DECL_INITIAL (array
) = build_constructor (type
, v
);
2192 TREE_STATIC (array
) = 1;
2193 DECL_ARTIFICIAL (array
) = 1;
2194 DECL_IGNORED_P (array
) = 1;
2195 TREE_READONLY (array
) = 1;
2196 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2197 rest_of_decl_compilation (array
, 1, 0);
2199 reflection_data
= build_address_of (array
);
2202 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2205 reflection_data
= null_pointer_node
;
2207 PUSH_FIELD_VALUE (v2
, "reflection_data", reflection_data
);
2208 FINISH_RECORD_CONSTRUCTOR (cons
, v2
, class_type_node
);
2210 DECL_INITIAL (decl
) = cons
;
2212 /* Hash synchronization requires at least 64-bit alignment. */
2213 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2214 DECL_ALIGN (decl
) = 64;
2216 if (flag_indirect_classes
)
2218 TREE_READONLY (decl
) = 1;
2219 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2222 rest_of_decl_compilation (decl
, 1, 0);
2225 tree classdollar_field
= build_classdollar_field (type
);
2226 if (!flag_indirect_classes
)
2227 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2228 rest_of_decl_compilation (classdollar_field
, 1, 0);
2231 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2232 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2233 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2239 java_expand_catch_classes (current_class
);
2241 current_function_decl
= NULL_TREE
;
2242 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2243 make_class_data (current_class
);
2245 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2248 /* Return 2 if KLASS is compiled by this compilation job;
2249 return 1 if KLASS can otherwise be assumed to be compiled;
2250 return 0 if we cannot assume that KLASS is compiled.
2251 Returns 1 for primitive and 0 for array types. */
2253 is_compiled_class (tree klass
)
2256 if (TREE_CODE (klass
) == POINTER_TYPE
)
2257 klass
= TREE_TYPE (klass
);
2258 if (TREE_CODE (klass
) != RECORD_TYPE
) /* Primitive types are static. */
2260 if (TYPE_ARRAY_P (klass
))
2263 seen_in_zip
= (TYPE_JCF (klass
) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass
)));
2264 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2266 /* The class was seen in the current ZIP file and will be
2267 available as a compiled class in the future but may not have
2268 been loaded already. Load it if necessary. This prevent
2269 build_class_ref () from crashing. */
2271 if (seen_in_zip
&& !CLASS_LOADED_P (klass
) && (klass
!= current_class
))
2272 load_class (klass
, 1);
2274 /* We return 2 for class seen in ZIP and class from files
2275 belonging to the same compilation unit */
2279 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass
)))))
2281 if (!CLASS_LOADED_P (klass
))
2283 if (klass
!= current_class
)
2284 load_class (klass
, 1);
2292 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2295 build_dtable_decl (tree type
)
2299 /* We need to build a new dtable type so that its size is uniquely
2300 computed when we're dealing with the class for real and not just
2301 faking it (like java.lang.Class during the initialization of the
2302 compiler.) We know we're not faking a class when CURRENT_CLASS is
2304 if (current_class
== type
)
2306 tree dummy
= NULL_TREE
;
2309 dtype
= make_node (RECORD_TYPE
);
2311 PUSH_FIELD (input_location
, dtype
, dummy
, "top_offset", ptr_type_node
);
2312 PUSH_FIELD (input_location
, dtype
, dummy
, "type_info", ptr_type_node
);
2314 PUSH_FIELD (input_location
, dtype
, dummy
, "class", class_ptr_type
);
2315 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2317 tree tmp_field
= build_decl (input_location
,
2318 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2319 TREE_CHAIN (dummy
) = tmp_field
;
2320 DECL_CONTEXT (tmp_field
) = dtype
;
2321 DECL_ARTIFICIAL (tmp_field
) = 1;
2325 PUSH_FIELD (input_location
, dtype
, dummy
, "gc_descr", ptr_type_node
);
2326 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2328 tree tmp_field
= build_decl (input_location
,
2329 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2330 TREE_CHAIN (dummy
) = tmp_field
;
2331 DECL_CONTEXT (tmp_field
) = dtype
;
2332 DECL_ARTIFICIAL (tmp_field
) = 1;
2336 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2337 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2338 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2340 PUSH_FIELD (input_location
, dtype
, dummy
, "methods",
2341 build_prim_array_type (nativecode_ptr_type_node
, n
));
2342 layout_type (dtype
);
2345 dtype
= dtable_type
;
2347 decl
= build_decl (input_location
,
2348 VAR_DECL
, get_identifier ("vt$"), dtype
);
2349 DECL_CONTEXT (decl
) = type
;
2350 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2351 DECL_VTABLE_P (decl
) = 1;
2356 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2357 fields inherited from SUPER_CLASS. */
2360 push_super_field (tree this_class
, tree super_class
)
2363 /* Don't insert the field if we're just re-laying the class out. */
2364 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2366 base_decl
= build_decl (input_location
,
2367 FIELD_DECL
, NULL_TREE
, super_class
);
2368 DECL_IGNORED_P (base_decl
) = 1;
2369 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2370 TYPE_FIELDS (this_class
) = base_decl
;
2371 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2372 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2375 /* Handle the different manners we may have to lay out a super class. */
2378 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2382 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2384 if (!CLASS_LOADED_P (super_class
))
2385 load_class (super_class
, 1);
2387 /* We might have to layout the class before its dependency on
2388 the super class gets resolved by java_complete_class */
2389 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2391 if (TREE_TYPE (super_class
) != NULL_TREE
)
2392 super_class
= TREE_TYPE (super_class
);
2396 if (!TYPE_SIZE (super_class
))
2397 safe_layout_class (super_class
);
2402 /* safe_layout_class just makes sure that we can load a class without
2403 disrupting the current_class, input_file, input_line, etc, information
2404 about the class processed currently. */
2407 safe_layout_class (tree klass
)
2409 tree save_current_class
= current_class
;
2410 location_t save_location
= input_location
;
2412 layout_class (klass
);
2414 current_class
= save_current_class
;
2415 input_location
= save_location
;
2419 layout_class (tree this_class
)
2422 tree super_class
= CLASSTYPE_SUPER (this_class
);
2424 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2425 if (CLASS_BEING_LAIDOUT (this_class
))
2431 sprintf (buffer
, " with '%s'",
2432 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2433 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2435 for (current
= TREE_CHAIN (class_list
); current
;
2436 current
= TREE_CHAIN (current
))
2438 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2439 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2440 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2441 DECL_SOURCE_FILE (decl
),
2442 DECL_SOURCE_LINE (decl
));
2443 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2445 obstack_1grow (&temporary_obstack
, '\0');
2446 report
= XOBFINISH (&temporary_obstack
, char *);
2447 cyclic_inheritance_report
= ggc_strdup (report
);
2448 obstack_free (&temporary_obstack
, report
);
2449 TYPE_SIZE (this_class
) = error_mark_node
;
2452 CLASS_BEING_LAIDOUT (this_class
) = 1;
2454 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2456 tree maybe_super_class
2457 = maybe_layout_super_class (super_class
, this_class
);
2458 if (maybe_super_class
== NULL
2459 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2461 TYPE_SIZE (this_class
) = error_mark_node
;
2462 CLASS_BEING_LAIDOUT (this_class
) = 0;
2463 class_list
= TREE_CHAIN (class_list
);
2466 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2467 push_super_field (this_class
, maybe_super_class
);
2470 layout_type (this_class
);
2472 /* Also recursively load/layout any superinterfaces. */
2473 if (TYPE_BINFO (this_class
))
2475 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2477 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2478 tree super_interface
= BINFO_TYPE (binfo
);
2479 tree maybe_super_interface
2480 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2481 if (maybe_super_interface
== NULL
2482 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2484 TYPE_SIZE (this_class
) = error_mark_node
;
2485 CLASS_BEING_LAIDOUT (this_class
) = 0;
2486 class_list
= TREE_CHAIN (class_list
);
2492 /* Convert the size back to an SI integer value. */
2493 TYPE_SIZE_UNIT (this_class
) =
2494 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2496 CLASS_BEING_LAIDOUT (this_class
) = 0;
2497 class_list
= TREE_CHAIN (class_list
);
2501 add_miranda_methods (tree base_class
, tree search_class
)
2504 tree binfo
, base_binfo
;
2506 if (!CLASS_PARSED_P (search_class
))
2507 load_class (search_class
, 1);
2509 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2510 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2513 tree elt
= BINFO_TYPE (base_binfo
);
2515 /* FIXME: This is totally bogus. We should not be handling
2516 Miranda methods at all if we're using the BC ABI. */
2517 if (TYPE_DUMMY (elt
))
2520 /* Ensure that interface methods are seen in declared order. */
2521 if (!CLASS_LOADED_P (elt
))
2522 load_class (elt
, 1);
2523 layout_class_methods (elt
);
2525 /* All base classes will have been laid out at this point, so the order
2526 will be correct. This code must match similar layout code in the
2528 for (method_decl
= TYPE_METHODS (elt
);
2529 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2533 /* An interface can have <clinit>. */
2534 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2537 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2538 override
= lookup_argument_method (base_class
,
2539 DECL_NAME (method_decl
), sig
);
2540 if (override
== NULL_TREE
)
2542 /* Found a Miranda method. Add it. */
2544 sig
= build_java_signature (TREE_TYPE (method_decl
));
2546 = add_method (base_class
,
2547 get_access_flags_from_decl (method_decl
),
2548 DECL_NAME (method_decl
), sig
);
2549 METHOD_INVISIBLE (new_method
) = 1;
2553 /* Try superinterfaces. */
2554 add_miranda_methods (base_class
, elt
);
2559 layout_class_methods (tree this_class
)
2561 tree method_decl
, dtable_count
;
2562 tree super_class
, type_name
;
2564 if (TYPE_NVIRTUALS (this_class
))
2567 super_class
= CLASSTYPE_SUPER (this_class
);
2571 super_class
= maybe_layout_super_class (super_class
, this_class
);
2572 if (!TYPE_NVIRTUALS (super_class
))
2573 layout_class_methods (super_class
);
2574 dtable_count
= TYPE_NVIRTUALS (super_class
);
2577 dtable_count
= integer_zero_node
;
2579 type_name
= TYPE_NAME (this_class
);
2580 if (!flag_indirect_dispatch
2581 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2583 /* An abstract class can have methods which are declared only in
2584 an implemented interface. These are called "Miranda
2585 methods". We make a dummy method entry for such methods
2587 add_miranda_methods (this_class
, this_class
);
2590 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2592 for (method_decl
= TYPE_METHODS (this_class
);
2593 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2594 dtable_count
= layout_class_method (this_class
, super_class
,
2595 method_decl
, dtable_count
);
2597 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2600 /* Return the index of METHOD in INTERFACE. This index begins at 1
2601 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2603 get_interface_method_index (tree method
, tree interface
)
2608 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
))
2612 /* We don't want to put <clinit> into the interface table. */
2613 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2615 gcc_assert (meth
!= NULL_TREE
);
2619 /* Lay METHOD_DECL out, returning a possibly new value of
2620 DTABLE_COUNT. Also mangle the method's name. */
2623 layout_class_method (tree this_class
, tree super_class
,
2624 tree method_decl
, tree dtable_count
)
2626 tree method_name
= DECL_NAME (method_decl
);
2628 TREE_PUBLIC (method_decl
) = 1;
2630 if (flag_indirect_classes
2631 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2632 && ! METHOD_NATIVE (method_decl
)
2633 && ! special_method_p (method_decl
)))
2634 java_hide_decl (method_decl
);
2636 /* Considered external unless it is being compiled into this object
2637 file, or it was already flagged as external. */
2638 if (!DECL_EXTERNAL (method_decl
))
2639 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2640 || METHOD_NATIVE (method_decl
));
2642 if (ID_INIT_P (method_name
))
2644 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2646 for (ptr
= p
; *ptr
; )
2651 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2652 build_java_signature (TREE_TYPE (method_decl
));
2654 else if (! METHOD_STATIC (method_decl
))
2657 build_java_signature (TREE_TYPE (method_decl
));
2658 bool method_override
= false;
2659 tree super_method
= lookup_java_method (super_class
, method_name
,
2661 if (super_method
!= NULL_TREE
2662 && ! METHOD_DUMMY (super_method
))
2664 method_override
= true;
2665 if (! METHOD_PUBLIC (super_method
) &&
2666 ! METHOD_PROTECTED (super_method
))
2668 /* Don't override private method, or default-access method in
2670 if (METHOD_PRIVATE (super_method
) ||
2671 ! in_same_package (TYPE_NAME (this_class
),
2672 TYPE_NAME (super_class
)))
2673 method_override
= false;
2676 if (method_override
)
2678 tree method_index
= get_method_index (super_method
);
2679 set_method_index (method_decl
, method_index
);
2680 if (method_index
== NULL_TREE
2681 && ! flag_indirect_dispatch
2682 && ! DECL_ARTIFICIAL (super_method
))
2683 error ("non-static method %q+D overrides static method",
2686 else if (this_class
== object_type_node
2687 && (METHOD_FINAL (method_decl
)
2688 || METHOD_PRIVATE (method_decl
)))
2690 /* We don't generate vtable entries for final Object
2691 methods. This is simply to save space, since every
2692 object would otherwise have to define them. */
2694 else if (! METHOD_PRIVATE (method_decl
)
2697 /* We generate vtable entries for final methods because they
2698 may one day be changed to non-final. */
2699 set_method_index (method_decl
, dtable_count
);
2700 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2701 dtable_count
, integer_one_node
);
2705 return dtable_count
;
2709 register_class (void)
2713 if (!registered_class
)
2714 registered_class
= VEC_alloc (tree
, gc
, 8);
2716 if (flag_indirect_classes
)
2717 node
= current_class
;
2719 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2720 VEC_safe_push (tree
, gc
, registered_class
, node
);
2723 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2724 all the classes we have emitted. */
2727 emit_indirect_register_classes (tree
*list_p
)
2729 tree klass
, t
, register_class_fn
;
2732 tree init
= NULL_TREE
;
2733 int size
= VEC_length (tree
, registered_class
) * 2 + 1;
2734 tree class_array_type
2735 = build_prim_array_type (ptr_type_node
, size
);
2736 tree
cdecl = build_decl (input_location
,
2737 VAR_DECL
, get_identifier ("_Jv_CLS"),
2739 tree reg_class_list
;
2740 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2742 init
= tree_cons (NULL_TREE
,
2743 fold_convert (ptr_type_node
,
2744 build_static_class_ref (klass
)), init
);
2747 fold_convert (ptr_type_node
,
2748 build_address_of (build_classdollar_field (klass
))),
2751 init
= tree_cons (NULL_TREE
, integer_zero_node
, init
);
2752 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type
,
2754 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2755 TREE_STATIC (cdecl) = 1;
2756 DECL_ARTIFICIAL (cdecl) = 1;
2757 DECL_IGNORED_P (cdecl) = 1;
2758 TREE_READONLY (cdecl) = 1;
2759 TREE_CONSTANT (cdecl) = 1;
2760 rest_of_decl_compilation (cdecl, 1, 0);
2761 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2763 t
= build_function_type_list (void_type_node
,
2764 build_pointer_type (ptr_type_node
), NULL
);
2765 t
= build_decl (input_location
,
2767 get_identifier ("_Jv_RegisterNewClasses"), t
);
2768 TREE_PUBLIC (t
) = 1;
2769 DECL_EXTERNAL (t
) = 1;
2770 register_class_fn
= t
;
2771 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2772 append_to_statement_list (t
, list_p
);
2776 /* Emit something to register classes at start-up time.
2778 The preferred mechanism is through the .jcr section, which contain
2779 a list of pointers to classes which get registered during constructor
2782 The fallback mechanism is to add statements to *LIST_P to call
2783 _Jv_RegisterClass for each class in this file. These statements will
2784 be added to a static constructor function for this translation unit. */
2787 emit_register_classes (tree
*list_p
)
2789 if (registered_class
== NULL
)
2792 if (flag_indirect_classes
)
2794 emit_indirect_register_classes (list_p
);
2798 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2799 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2800 but lack suitable crtbegin/end objects or linker support. These
2801 targets can override the default in tm.h to use the fallback mechanism. */
2802 if (TARGET_USE_JCR_SECTION
)
2807 #ifdef JCR_SECTION_NAME
2808 switch_to_section (get_section (JCR_SECTION_NAME
, SECTION_WRITE
, NULL
));
2810 /* A target has defined TARGET_USE_JCR_SECTION,
2811 but doesn't have a JCR_SECTION_NAME. */
2814 assemble_align (POINTER_SIZE
);
2816 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2818 t
= build_fold_addr_expr (klass
);
2819 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2824 tree klass
, t
, register_class_fn
;
2827 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2828 t
= build_decl (input_location
,
2829 FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2830 TREE_PUBLIC (t
) = 1;
2831 DECL_EXTERNAL (t
) = 1;
2832 register_class_fn
= t
;
2834 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2836 t
= build_fold_addr_expr (klass
);
2837 t
= build_call_expr (register_class_fn
, 1, t
);
2838 append_to_statement_list (t
, list_p
);
2843 /* Build a constructor for an entry in the symbol table. */
2846 build_symbol_table_entry (tree clname
, tree name
, tree signature
)
2849 VEC(constructor_elt
,gc
) *v
= NULL
;
2851 START_RECORD_CONSTRUCTOR (v
, symbol_type
);
2852 PUSH_FIELD_VALUE (v
, "clname", clname
);
2853 PUSH_FIELD_VALUE (v
, "name", name
);
2854 PUSH_FIELD_VALUE (v
, "signature", signature
);
2855 FINISH_RECORD_CONSTRUCTOR (symbol
, v
, symbol_type
);
2856 TREE_CONSTANT (symbol
) = 1;
2861 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2864 build_symbol_entry (tree decl
, tree special
)
2866 tree clname
, name
, signature
;
2867 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2868 /* ??? Constructors are given the name foo.foo all the way through
2869 the compiler, but in the method table they're all renamed
2870 foo.<init>. So, we have to do the same here unless we want an
2871 unresolved reference at runtime. */
2872 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2873 && DECL_CONSTRUCTOR_P (decl
))
2874 ? init_identifier_node
2875 : DECL_NAME (decl
));
2876 signature
= build_java_signature (TREE_TYPE (decl
));
2877 signature
= build_utf8_ref (unmangle_classname
2878 (IDENTIFIER_POINTER (signature
),
2879 IDENTIFIER_LENGTH (signature
)));
2880 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2881 signature addr+1 if SPECIAL, and this indicates to the runtime
2882 system that this is a "special" symbol, i.e. one that should
2883 bypass access controls. */
2884 if (special
!= NULL_TREE
)
2885 signature
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (signature
), signature
,
2886 fold_convert (sizetype
, special
));
2888 return build_symbol_table_entry (clname
, name
, signature
);
2891 /* Emit a symbol table: used by -findirect-dispatch. */
2894 emit_symbol_table (tree name
, tree the_table
,
2895 VEC(method_entry
,gc
) *decl_table
,
2896 tree the_syms_decl
, tree the_array_element_type
,
2899 tree table
, list
, null_symbol
;
2900 tree table_size
, the_array_type
;
2904 /* Only emit a table if this translation unit actually made any
2905 references via it. */
2906 if (decl_table
== NULL
)
2909 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2911 for (index
= 0; VEC_iterate (method_entry
, decl_table
, index
, e
); index
++)
2912 list
= tree_cons (NULL_TREE
,
2913 build_symbol_entry (e
->method
, e
->special
),
2916 /* Terminate the list with a "null" entry. */
2917 null_symbol
= build_symbol_table_entry (null_pointer_node
,
2920 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2922 /* Put the list in the right order and make it a constructor. */
2923 list
= nreverse (list
);
2924 table
= build_constructor_from_list (symbols_array_type
, list
);
2926 /* Make it the initial value for otable_syms and emit the decl. */
2927 DECL_INITIAL (the_syms_decl
) = table
;
2928 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2929 DECL_IGNORED_P (the_syms_decl
) = 1;
2930 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2932 /* Now that its size is known, redefine the table as an
2933 uninitialized static array of INDEX + 1 elements. The extra entry
2934 is used by the runtime to track whether the table has been
2937 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2938 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2939 the_table
= build_decl (input_location
,
2940 VAR_DECL
, name
, the_array_type
);
2941 TREE_STATIC (the_table
) = 1;
2942 TREE_READONLY (the_table
) = 1;
2943 rest_of_decl_compilation (the_table
, 1, 0);
2948 /* Make an entry for the catch_classes list. */
2950 make_catch_class_record (tree catch_class
, tree classname
)
2953 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2954 VEC(constructor_elt
,gc
) *v
= NULL
;
2955 START_RECORD_CONSTRUCTOR (v
, type
);
2956 PUSH_FIELD_VALUE (v
, "address", catch_class
);
2957 PUSH_FIELD_VALUE (v
, "classname", classname
);
2958 FINISH_RECORD_CONSTRUCTOR (entry
, v
, type
);
2963 /* Generate the list of Throwable classes that are caught by exception
2964 handlers in this class. */
2966 emit_catch_table (tree this_class
)
2968 tree table
, table_size
, array_type
;
2969 int n_catch_classes
;
2971 /* Fill in the dummy entry that make_class created. */
2972 e
= VEC_index (constructor_elt
, TYPE_CATCH_CLASSES (this_class
), 0);
2973 e
->value
= make_catch_class_record (null_pointer_node
, null_pointer_node
);
2974 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class
), NULL_TREE
,
2975 make_catch_class_record (null_pointer_node
,
2976 null_pointer_node
));
2977 n_catch_classes
= VEC_length (constructor_elt
,
2978 TYPE_CATCH_CLASSES (this_class
));
2979 table_size
= build_index_type (build_int_cst (NULL_TREE
, n_catch_classes
));
2981 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2984 build_decl (input_location
,
2985 VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2986 DECL_INITIAL (table
) =
2987 build_constructor (array_type
, TYPE_CATCH_CLASSES (this_class
));
2988 TREE_STATIC (table
) = 1;
2989 TREE_READONLY (table
) = 1;
2990 DECL_IGNORED_P (table
) = 1;
2991 rest_of_decl_compilation (table
, 1, 0);
2995 /* Given a type, return the signature used by
2996 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2997 same as build_java_signature() because we want the canonical array
3001 build_signature_for_libgcj (tree type
)
3005 sig
= build_java_signature (type
);
3006 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
3007 IDENTIFIER_LENGTH (sig
)));
3011 /* Build an entry in the type assertion table. */
3014 build_assertion_table_entry (tree code
, tree op1
, tree op2
)
3016 VEC(constructor_elt
,gc
) *v
= NULL
;
3019 START_RECORD_CONSTRUCTOR (v
, assertion_entry_type
);
3020 PUSH_FIELD_VALUE (v
, "assertion_code", code
);
3021 PUSH_FIELD_VALUE (v
, "op1", op1
);
3022 PUSH_FIELD_VALUE (v
, "op2", op2
);
3023 FINISH_RECORD_CONSTRUCTOR (entry
, v
, assertion_entry_type
);
3028 /* Add an entry to the type assertion table. Callback used during hashtable
3032 add_assertion_table_entry (void **htab_entry
, void *ptr
)
3035 tree code_val
, op1_utf8
, op2_utf8
;
3036 tree
*list
= (tree
*) ptr
;
3037 type_assertion
*as
= (type_assertion
*) *htab_entry
;
3039 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
3041 if (as
->op1
== NULL_TREE
)
3042 op1_utf8
= null_pointer_node
;
3044 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3046 if (as
->op2
== NULL_TREE
)
3047 op2_utf8
= null_pointer_node
;
3049 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3051 entry
= build_assertion_table_entry (code_val
, op1_utf8
, op2_utf8
);
3053 *list
= tree_cons (NULL_TREE
, entry
, *list
);
3057 /* Generate the type assertion table for KLASS, and return its DECL. */
3060 emit_assertion_table (tree klass
)
3062 tree null_entry
, ctor
, table_decl
;
3063 tree list
= NULL_TREE
;
3064 htab_t assertions_htab
= TYPE_ASSERTIONS (klass
);
3066 /* Iterate through the hash table. */
3067 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
3069 /* Finish with a null entry. */
3070 null_entry
= build_assertion_table_entry (integer_zero_node
,
3074 list
= tree_cons (NULL_TREE
, null_entry
, list
);
3076 /* Put the list in the right order and make it a constructor. */
3077 list
= nreverse (list
);
3078 ctor
= build_constructor_from_list (assertion_table_type
, list
);
3080 table_decl
= build_decl (input_location
,
3081 VAR_DECL
, mangled_classname ("_type_assert_", klass
),
3082 assertion_table_type
);
3084 TREE_STATIC (table_decl
) = 1;
3085 TREE_READONLY (table_decl
) = 1;
3086 TREE_CONSTANT (table_decl
) = 1;
3087 DECL_IGNORED_P (table_decl
) = 1;
3089 DECL_INITIAL (table_decl
) = ctor
;
3090 DECL_ARTIFICIAL (table_decl
) = 1;
3091 rest_of_decl_compilation (table_decl
, 1, 0);
3097 init_class_processing (void)
3099 fields_ident
= get_identifier ("fields");
3100 info_ident
= get_identifier ("info");
3102 gcc_obstack_init (&temporary_obstack
);
3105 static hashval_t
java_treetreehash_hash (const void *);
3106 static int java_treetreehash_compare (const void *, const void *);
3108 /* A hash table mapping trees to trees. Used generally. */
3110 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3113 java_treetreehash_hash (const void *k_p
)
3115 const struct treetreehash_entry
*const k
3116 = (const struct treetreehash_entry
*) k_p
;
3117 return JAVA_TREEHASHHASH_H (k
->key
);
3121 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3123 const struct treetreehash_entry
*const k1
3124 = (const struct treetreehash_entry
*) k1_p
;
3125 const_tree
const k2
= (const_tree
) k2_p
;
3126 return (k1
->key
== k2
);
3130 java_treetreehash_find (htab_t ht
, tree t
)
3132 struct treetreehash_entry
*e
;
3133 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3134 e
= (struct treetreehash_entry
*) htab_find_with_hash (ht
, t
, hv
);
3142 java_treetreehash_new (htab_t ht
, tree t
)
3145 struct treetreehash_entry
*tthe
;
3146 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3148 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3151 tthe
= ggc_alloc_cleared_treetreehash_entry ();
3156 tthe
= (struct treetreehash_entry
*) *e
;
3157 return &tthe
->value
;
3161 java_treetreehash_create (size_t size
)
3163 return htab_create_ggc (size
, java_treetreehash_hash
,
3164 java_treetreehash_compare
, NULL
);
3167 /* Break down qualified IDENTIFIER into package and class-name components.
3168 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3169 "pkg.foo", and RIGHT to "Bar". */
3172 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3175 int l
= IDENTIFIER_LENGTH (source
);
3177 base
= (char *) alloca (l
+ 1);
3178 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3180 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3182 while (*p
!= '.' && p
!= base
)
3185 /* We didn't find a '.'. Return an error. */
3191 *right
= get_identifier (p
+1);
3192 *left
= get_identifier (base
);
3197 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3198 if the classes are from the same package. */
3201 in_same_package (tree name1
, tree name2
)
3207 if (TREE_CODE (name1
) == TYPE_DECL
)
3208 name1
= DECL_NAME (name1
);
3209 if (TREE_CODE (name2
) == TYPE_DECL
)
3210 name2
= DECL_NAME (name2
);
3212 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3213 /* One in empty package. */
3216 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3217 /* Both in empty package. */
3220 split_qualified_name (&pkg1
, &tmp
, name1
);
3221 split_qualified_name (&pkg2
, &tmp
, name2
);
3223 return (pkg1
== pkg2
);
3226 /* lang_hooks.decls.final_write_globals: perform final processing on
3227 global variables. */
3230 java_write_globals (void)
3232 tree
*vec
= VEC_address (tree
, pending_static_fields
);
3233 int len
= VEC_length (tree
, pending_static_fields
);
3234 write_global_declarations ();
3235 emit_debug_global_declarations (vec
, len
);
3236 VEC_free (tree
, gc
, pending_static_fields
);
3239 #include "gt-java-class.h"