1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 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 2, 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 COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA.
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc. */
26 /* Written by Per Bothner <bothner@cygnus.com> */
30 #include "coretypes.h"
35 #include "java-tree.h"
47 #include "tree-iterator.h"
50 /* DOS brain-damage */
52 #define O_BINARY 0 /* MS-DOS brain-damage */
55 static tree
make_method_value (tree
);
56 static tree
build_java_method_type (tree
, tree
, int);
57 static int32
hashUtf8String (const char *, int);
58 static tree
make_field_value (tree
);
59 static tree
get_dispatch_vector (tree
);
60 static tree
get_dispatch_table (tree
, tree
);
61 static int supers_all_compiled (tree type
);
62 static tree
maybe_layout_super_class (tree
, tree
);
63 static void add_miranda_methods (tree
, tree
);
64 static int assume_compiled (const char *);
65 static tree
build_symbol_entry (tree
);
66 static tree
emit_assertion_table (tree
);
67 static void register_class (void);
69 struct obstack temporary_obstack
;
71 /* The compiler generates different code depending on whether or not
72 it can assume certain classes have been compiled down to native
73 code or not. The compiler options -fassume-compiled= and
74 -fno-assume-compiled= are used to create a tree of
75 class_flag_node objects. This tree is queried to determine if
76 a class is assume to be compiled or not. Each node in the tree
77 represents either a package or a specific class. */
79 typedef struct class_flag_node_struct
81 /* The class or package name. */
84 /* Nonzero if this represents an exclusion. */
87 /* Pointers to other nodes in the tree. */
88 struct class_flag_node_struct
*parent
;
89 struct class_flag_node_struct
*sibling
;
90 struct class_flag_node_struct
*child
;
93 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
94 static void add_class_flag (class_flag_node
**, const char *, int);
96 /* This is the root of the include/exclude tree. */
98 static class_flag_node
*assume_compiled_tree
;
100 static class_flag_node
*enable_assert_tree
;
102 static GTY(()) tree class_roots
[4];
103 #define fields_ident class_roots[0] /* get_identifier ("fields") */
104 #define info_ident class_roots[1] /* get_identifier ("info") */
105 #define class_list class_roots[2]
106 #define class_dtable_decl class_roots[3]
108 static GTY(()) VEC(tree
,gc
) *registered_class
;
110 /* Return the node that most closely represents the class whose name
111 is IDENT. Start the search from NODE (followed by its siblings).
112 Return NULL if an appropriate node does not exist. */
114 static class_flag_node
*
115 find_class_flag_node (class_flag_node
*node
, const char *ident
)
119 size_t node_ident_length
= strlen (node
->ident
);
121 /* node_ident_length is zero at the root of the tree. If the
122 identifiers are the same length, then we have matching
123 classes. Otherwise check if we've matched an enclosing
126 if (node_ident_length
== 0
127 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
128 && (ident
[node_ident_length
] == '\0'
129 || ident
[node_ident_length
] == '.')))
131 /* We've found a match, however, there might be a more
134 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
141 /* No match yet. Continue through the sibling list. */
142 node
= node
->sibling
;
145 /* No match at all in this tree. */
150 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
152 class_flag_node
*root
= *rootp
;
153 class_flag_node
*parent
, *node
;
155 /* Create the root of the tree if it doesn't exist yet. */
159 root
= XNEW (class_flag_node
);
162 root
->sibling
= NULL
;
168 /* Calling the function with the empty string means we're setting
169 value for the root of the hierarchy. */
177 /* Find the parent node for this new node. PARENT will either be a
178 class or a package name. Adjust PARENT accordingly. */
180 parent
= find_class_flag_node (root
, ident
);
181 if (strcmp (ident
, parent
->ident
) == 0)
182 parent
->value
= value
;
185 /* Insert new node into the tree. */
186 node
= XNEW (class_flag_node
);
188 node
->ident
= xstrdup (ident
);
192 node
->parent
= parent
;
193 node
->sibling
= parent
->child
;
194 parent
->child
= node
;
198 /* Add a new IDENT to the include/exclude tree. It's an exclusion
199 if EXCLUDEP is nonzero. */
202 add_assume_compiled (const char *ident
, int excludep
)
204 add_class_flag (&assume_compiled_tree
, ident
, excludep
);
207 /* The default value returned by enable_assertions. */
209 #define DEFAULT_ENABLE_ASSERT (flag_emit_class_files || optimize == 0)
211 /* Enter IDENT (a class or package name) into the enable-assertions table.
212 VALUE is true to enable and false to disable. */
215 add_enable_assert (const char *ident
, int value
)
217 if (enable_assert_tree
== NULL
)
218 add_class_flag (&enable_assert_tree
, "", DEFAULT_ENABLE_ASSERT
);
219 add_class_flag (&enable_assert_tree
, ident
, value
);
222 /* Returns nonzero if IDENT is the name of a class that the compiler
223 should assume has been compiled to object code. */
226 assume_compiled (const char *ident
)
231 if (NULL
== assume_compiled_tree
)
234 i
= find_class_flag_node (assume_compiled_tree
, ident
);
241 /* Return true if we should generate code to check assertions within KLASS. */
244 enable_assertions (tree klass
)
246 /* Check if command-line specifies whether we should check assertions. */
248 if (klass
!= NULL_TREE
&& DECL_NAME (klass
) && enable_assert_tree
!= NULL
)
250 const char *ident
= IDENTIFIER_POINTER (DECL_NAME (klass
));
251 class_flag_node
*node
252 = find_class_flag_node (enable_assert_tree
, ident
);
256 /* The default is to enable assertions if generating class files,
257 or not optimizing. */
258 return DEFAULT_ENABLE_ASSERT
;
261 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
262 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
263 Also, PREFIX is prepended, and SUFFIX is appended. */
266 ident_subst (const char* old_name
,
273 int prefix_len
= strlen (prefix
);
274 int suffix_len
= strlen (suffix
);
275 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
276 char *buffer
= alloca (i
);
278 strcpy (buffer
, prefix
);
279 for (i
= 0; i
< old_length
; i
++)
281 char ch
= old_name
[i
];
284 buffer
[prefix_len
+ i
] = ch
;
286 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
287 return get_identifier (buffer
);
290 /* Return an IDENTIFIER_NODE the same as OLD_ID,
291 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
292 Also, PREFIX is prepended, and SUFFIX is appended. */
295 identifier_subst (const tree old_id
,
301 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
302 prefix
, old_char
, new_char
, suffix
);
305 /* Generate a valid C identifier from the name of the class TYPE,
306 prefixed by PREFIX. */
309 mangled_classname (const char *prefix
, tree type
)
311 tree ident
= TYPE_NAME (type
);
312 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
313 ident
= DECL_NAME (ident
);
314 return identifier_subst (ident
, prefix
, '.', '_', "");
321 type
= make_node (RECORD_TYPE
);
322 /* Unfortunately we must create the binfo here, so that class
324 TYPE_BINFO (type
) = make_tree_binfo (0);
325 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
330 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
331 and where each of the constituents is separated by '/',
332 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
335 unmangle_classname (const char *name
, int name_length
)
337 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
338 /* It's not sufficient to compare to_return and get_identifier
339 (name) to determine whether to_return is qualified. There are
340 cases in signature analysis where name will be stripped of a
342 name
= IDENTIFIER_POINTER (to_return
);
346 QUALIFIED_P (to_return
) = 1;
353 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
356 const char *typename = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
357 char *buf = alloca (strlen (typename) + strlen (#NAME "_syms_") + 1); \
360 sprintf (buf, #NAME "_%s", typename); \
361 TYPE_## TABLE ##_DECL (type) = decl = \
362 build_decl (VAR_DECL, get_identifier (buf), TABLE_TYPE); \
363 DECL_EXTERNAL (decl) = 1; \
364 TREE_STATIC (decl) = 1; \
365 TREE_READONLY (decl) = 1; \
366 TREE_CONSTANT (decl) = 1; \
367 DECL_IGNORED_P (decl) = 1; \
368 /* Mark the table as belonging to this class. */ \
370 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
371 DECL_OWNER (decl) = TYPE; \
372 sprintf (buf, #NAME "_syms_%s", typename); \
373 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
374 build_decl (VAR_DECL, get_identifier (buf), symbols_array_type); \
375 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
376 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
377 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
381 /* Given a class, create the DECLs for all its associated indirect
384 gen_indirect_dispatch_tables (tree type
)
386 const char *typename
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
389 char *buf
= alloca (strlen (typename
) + strlen ("_catch_classes_") + 1);
390 tree catch_class_type
= make_node (RECORD_TYPE
);
392 sprintf (buf
, "_catch_classes_%s", typename
);
393 PUSH_FIELD (catch_class_type
, field
, "address", utf8const_ptr_type
);
394 PUSH_FIELD (catch_class_type
, field
, "classname", ptr_type_node
);
395 FINISH_RECORD (catch_class_type
);
397 TYPE_CTABLE_DECL (type
)
398 = build_decl (VAR_DECL
, get_identifier (buf
),
399 build_array_type (catch_class_type
, 0));
400 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
401 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
402 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
403 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
404 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
405 pushdecl (TYPE_CTABLE_DECL (type
));
408 if (flag_indirect_dispatch
)
410 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
411 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
412 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
419 push_class (tree class_type
, tree class_name
)
421 tree decl
, signature
;
422 location_t saved_loc
= input_location
;
423 #ifndef USE_MAPPED_LOCATION
424 tree source_name
= identifier_subst (class_name
, "", '.', '/', ".java");
425 input_filename
= IDENTIFIER_POINTER (source_name
);
428 CLASS_P (class_type
) = 1;
429 decl
= build_decl (TYPE_DECL
, class_name
, class_type
);
430 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
432 /* dbxout needs a DECL_SIZE if in gstabs mode */
433 DECL_SIZE (decl
) = integer_zero_node
;
435 input_location
= saved_loc
;
436 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
437 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
439 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
440 both a typedef and in the struct name-space. We may want to re-visit
441 this later, but for now it reduces the changes needed for gdb. */
442 DECL_ARTIFICIAL (decl
) = 1;
444 pushdecl_top_level (decl
);
449 /* Finds the (global) class named NAME. Creates the class if not found.
450 Also creates associated TYPE_DECL.
451 Does not check if the class actually exists, load the class,
452 fill in field or methods, or do layout_type. */
455 lookup_class (tree name
)
457 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
458 if (decl
== NULL_TREE
)
459 decl
= push_class (make_class (), name
);
460 return TREE_TYPE (decl
);
464 set_super_info (int access_flags
, tree this_class
,
465 tree super_class
, int interfaces_count
)
467 int total_supers
= interfaces_count
;
468 tree class_decl
= TYPE_NAME (this_class
);
474 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
475 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
478 tree super_binfo
= make_tree_binfo (0);
479 BINFO_TYPE (super_binfo
) = super_class
;
480 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
481 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
482 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
485 set_class_decl_access_flags (access_flags
, class_decl
);
489 set_class_decl_access_flags (int access_flags
, tree class_decl
)
491 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
492 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
493 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
494 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
495 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
496 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
497 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
498 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
499 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
502 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
503 direct sub-classes of Object are 1, and so on. */
506 class_depth (tree clas
)
509 if (! CLASS_LOADED_P (clas
))
510 load_class (clas
, 1);
511 if (TYPE_SIZE (clas
) == error_mark_node
)
513 while (clas
!= object_type_node
)
516 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
521 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
524 interface_of_p (tree type1
, tree type2
)
527 tree binfo
, base_binfo
;
529 if (! TYPE_BINFO (type2
))
532 for (binfo
= TYPE_BINFO (type2
), i
= 0;
533 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
534 if (BINFO_TYPE (base_binfo
) == type1
)
537 for (binfo
= TYPE_BINFO (type2
), i
= 0;
538 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
539 if (BINFO_TYPE (base_binfo
)
540 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
546 /* Return true iff TYPE1 inherits from TYPE2. */
549 inherits_from_p (tree type1
, tree type2
)
551 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
556 if (! CLASS_LOADED_P (type1
))
557 load_class (type1
, 1);
559 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
564 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
567 enclosing_context_p (tree type1
, tree type2
)
569 if (!INNER_CLASS_TYPE_P (type2
))
572 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
574 type2
= (INNER_CLASS_TYPE_P (type2
) ?
575 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
585 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
589 common_enclosing_context_p (tree type1
, tree type2
)
594 for (current
= type2
; current
;
595 current
= (INNER_CLASS_TYPE_P (current
) ?
596 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
598 if (type1
== current
)
601 if (INNER_CLASS_TYPE_P (type1
))
602 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
609 /* Return 1 iff there exists a common enclosing "this" between TYPE1
610 and TYPE2, without crossing any static context. */
613 common_enclosing_instance_p (tree type1
, tree type2
)
615 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
618 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
619 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
620 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
623 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
624 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
625 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
627 if (type1
== current
)
633 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
634 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
635 if attempt is made to add it twice. */
638 maybe_add_interface (tree this_class
, tree interface_class
)
640 tree binfo
, base_binfo
;
643 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
644 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
645 if (BINFO_TYPE (base_binfo
) == interface_class
)
646 return interface_class
;
647 add_interface (this_class
, interface_class
);
651 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
654 add_interface (tree this_class
, tree interface_class
)
656 tree interface_binfo
= make_tree_binfo (0);
658 BINFO_TYPE (interface_binfo
) = interface_class
;
659 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
660 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
661 BINFO_VIRTUAL_P (interface_binfo
) = 1;
663 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
667 /* Return the address of a pointer to the first FUNCTION_DECL
668 in the list (*LIST) whose DECL_NAME is NAME. */
671 find_named_method (tree
*list
, tree name
)
673 while (*list
&& DECL_NAME (*list
) != name
)
674 list
= &TREE_CHAIN (*list
);
680 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
682 if (access_flags
& ACC_STATIC
)
684 fntype
= build_method_type (this_class
, fntype
);
686 /* We know that arg 1 of every nonstatic method is non-null; tell
688 TYPE_ATTRIBUTES (fntype
) = (tree_cons
689 (get_identifier ("nonnull"),
690 tree_cons (NULL_TREE
,
691 build_int_cst (NULL_TREE
, 1),
693 TYPE_ATTRIBUTES (fntype
)));
698 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
700 tree method_type
, fndecl
;
702 method_type
= build_java_method_type (function_type
,
703 this_class
, access_flags
);
705 fndecl
= build_decl (FUNCTION_DECL
, name
, method_type
);
706 DECL_CONTEXT (fndecl
) = this_class
;
708 DECL_LANG_SPECIFIC (fndecl
)
709 = ggc_alloc_cleared (sizeof (struct lang_decl
));
710 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
712 /* Initialize the static initializer test table. */
714 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
715 java_treetreehash_create (10, 1);
717 /* Initialize the initialized (static) class table. */
718 if (access_flags
& ACC_STATIC
)
719 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
720 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
722 /* Initialize the static method invocation compound list */
723 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl
) = NULL_TREE
;
725 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
726 TYPE_METHODS (this_class
) = fndecl
;
728 /* Notice that this is a finalizer and update the class type
729 accordingly. This is used to optimize instance allocation. */
730 if (name
== finalize_identifier_node
731 && TREE_TYPE (function_type
) == void_type_node
732 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
733 HAS_FINALIZER_P (this_class
) = 1;
735 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
736 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
737 if (access_flags
& ACC_PRIVATE
)
738 METHOD_PRIVATE (fndecl
) = DECL_INLINE (fndecl
) = 1;
739 if (access_flags
& ACC_NATIVE
)
741 METHOD_NATIVE (fndecl
) = 1;
742 DECL_EXTERNAL (fndecl
) = 1;
744 if (access_flags
& ACC_STATIC
)
745 METHOD_STATIC (fndecl
) = DECL_INLINE (fndecl
) = 1;
746 if (access_flags
& ACC_FINAL
)
747 METHOD_FINAL (fndecl
) = DECL_INLINE (fndecl
) = 1;
748 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
749 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
750 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
754 /* Add a method to THIS_CLASS.
755 The method's name is NAME.
756 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
759 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
761 tree function_type
, fndecl
;
762 const unsigned char *sig
763 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
766 fatal_error ("bad method signature");
768 function_type
= get_type_from_signature (method_sig
);
769 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
770 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
775 add_field (tree
class, tree name
, tree field_type
, int flags
)
777 int is_static
= (flags
& ACC_STATIC
) != 0;
779 field
= build_decl (is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
780 TREE_CHAIN (field
) = TYPE_FIELDS (class);
781 TYPE_FIELDS (class) = field
;
782 DECL_CONTEXT (field
) = class;
784 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
785 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
786 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
787 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
788 if (flags
& ACC_VOLATILE
) FIELD_VOLATILE (field
) = 1;
789 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
792 FIELD_STATIC (field
) = 1;
793 /* Always make field externally visible. This is required so
794 that native methods can always access the field. */
795 TREE_PUBLIC (field
) = 1;
796 /* Considered external until we know what classes are being
797 compiled into this object file. */
798 DECL_EXTERNAL (field
) = 1;
804 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
807 set_constant_value (tree field
, tree constant
)
809 if (field
== NULL_TREE
)
810 warning (OPT_Wattributes
,
811 "misplaced ConstantValue attribute (not in any field)");
812 else if (DECL_INITIAL (field
) != NULL_TREE
)
813 warning (OPT_Wattributes
,
814 "duplicate ConstantValue attribute for field '%s'",
815 IDENTIFIER_POINTER (DECL_NAME (field
)));
818 DECL_INITIAL (field
) = constant
;
819 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
820 && ! (TREE_TYPE (constant
) == int_type_node
821 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
822 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
823 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
824 && TREE_TYPE (field
) == string_ptr_type_node
))
825 error ("ConstantValue attribute of field '%s' has wrong type",
826 IDENTIFIER_POINTER (DECL_NAME (field
)));
827 if (FIELD_FINAL (field
))
828 DECL_FIELD_FINAL_IUD (field
) = 1;
832 /* Count the number of Unicode chars encoded in a given Ut8 string. */
836 strLengthUtf8 (char *str
, int len
)
838 register unsigned char* ptr
= (unsigned char*) str
;
839 register unsigned char *limit
= ptr
+ len
;
841 for (; ptr
< limit
; str_length
++) {
842 if (UTF8_GET (ptr
, limit
) < 0)
850 /* Calculate a hash value for a string encoded in Utf8 format.
851 * This returns the same hash value as specified for java.lang.String.hashCode.
855 hashUtf8String (const char *str
, int len
)
857 const unsigned char* ptr
= (const unsigned char*) str
;
858 const unsigned char *limit
= ptr
+ len
;
862 int ch
= UTF8_GET (ptr
, limit
);
863 /* Updated specification from
864 http://www.javasoft.com/docs/books/jls/clarify.html. */
865 hash
= (31 * hash
) + ch
;
870 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
873 build_utf8_ref (tree name
)
875 const char * name_ptr
= IDENTIFIER_POINTER(name
);
876 int name_len
= IDENTIFIER_LENGTH(name
);
878 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
879 static int utf8_count
= 0;
881 tree ref
= IDENTIFIER_UTF8_REF (name
);
883 if (ref
!= NULL_TREE
)
886 ctype
= make_node (RECORD_TYPE
);
887 str_type
= build_prim_array_type (unsigned_byte_type_node
,
888 name_len
+ 1); /* Allow for final '\0'. */
889 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
890 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
891 PUSH_FIELD (ctype
, field
, "data", str_type
);
892 FINISH_RECORD (ctype
);
893 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
894 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
895 PUSH_FIELD_VALUE (cinit
, "hash", build_int_cst (NULL_TREE
, name_hash
));
896 PUSH_FIELD_VALUE (cinit
, "length", build_int_cst (NULL_TREE
, name_len
));
897 string
= build_string (name_len
, name_ptr
);
898 TREE_TYPE (string
) = str_type
;
899 PUSH_FIELD_VALUE (cinit
, "data", string
);
900 FINISH_RECORD_CONSTRUCTOR (cinit
);
901 TREE_CONSTANT (cinit
) = 1;
902 TREE_INVARIANT (cinit
) = 1;
904 /* Generate a unique-enough identifier. */
905 sprintf(buf
, "_Utf%d", ++utf8_count
);
907 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
908 TREE_STATIC (decl
) = 1;
909 DECL_ARTIFICIAL (decl
) = 1;
910 DECL_IGNORED_P (decl
) = 1;
911 TREE_READONLY (decl
) = 1;
912 TREE_THIS_VOLATILE (decl
) = 0;
913 DECL_INITIAL (decl
) = cinit
;
915 if (HAVE_GAS_SHF_MERGE
)
918 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
919 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
920 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
921 if (flag_merge_constants
&& decl_size
< 256)
924 int flags
= (SECTION_OVERRIDE
925 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
926 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
927 switch_to_section (get_section (buf
, flags
, NULL
));
928 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
932 TREE_CHAIN (decl
) = utf8_decl_list
;
933 layout_decl (decl
, 0);
935 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
936 cgraph_varpool_mark_needed_node (cgraph_varpool_node (decl
));
937 utf8_decl_list
= decl
;
938 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
939 IDENTIFIER_UTF8_REF (name
) = ref
;
943 /* Like build_class_ref, but instead of a direct reference generate a
944 pointer into the constant pool. */
947 build_indirect_class_ref (tree type
)
951 index
= alloc_class_constant (type
);
952 cl
= build_ref_from_constant_pool (index
);
953 return convert (promote_type (class_ptr_type
), cl
);
957 build_static_class_ref (tree type
)
959 tree decl_name
, decl
, ref
;
961 if (TYPE_SIZE (type
) == error_mark_node
)
962 return null_pointer_node
;
963 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
964 "", '/', '/', ".class$$");
965 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
966 if (decl
== NULL_TREE
)
968 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
969 TREE_STATIC (decl
) = 1;
970 if (! flag_indirect_classes
)
971 TREE_PUBLIC (decl
) = 1;
972 DECL_IGNORED_P (decl
) = 1;
973 DECL_ARTIFICIAL (decl
) = 1;
974 if (is_compiled_class (type
) == 1)
975 DECL_EXTERNAL (decl
) = 1;
976 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
977 DECL_CLASS_FIELD_P (decl
) = 1;
978 DECL_CONTEXT (decl
) = type
;
980 /* ??? We want to preserve the DECL_CONTEXT we set just above,
981 that that means not calling pushdecl_top_level. */
982 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
985 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
990 build_classdollar_field (tree type
)
992 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
993 "", '/', '/', ".class$");
994 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
996 if (decl
== NULL_TREE
)
999 = build_decl (VAR_DECL
, decl_name
,
1002 (build_type_variant (class_type_node
,
1004 /* const */ 1, 0)));
1005 TREE_STATIC (decl
) = 1;
1006 TREE_INVARIANT (decl
) = 1;
1007 TREE_CONSTANT (decl
) = 1;
1008 TREE_READONLY (decl
) = 1;
1009 TREE_PUBLIC (decl
) = 1;
1010 DECL_IGNORED_P (decl
) = 1;
1011 DECL_ARTIFICIAL (decl
) = 1;
1012 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1013 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1014 DECL_CLASS_FIELD_P (decl
) = 1;
1015 DECL_CONTEXT (decl
) = type
;
1021 /* Build a reference to the class TYPE.
1022 Also handles primitive types and array types. */
1025 build_class_ref (tree type
)
1027 int is_compiled
= is_compiled_class (type
);
1031 if (TREE_CODE (type
) == POINTER_TYPE
)
1032 type
= TREE_TYPE (type
);
1034 if (flag_indirect_dispatch
1035 && type
!= output_class
1036 && TREE_CODE (type
) == RECORD_TYPE
)
1037 return build_indirect_class_ref (type
);
1039 if (type
== output_class
&& flag_indirect_classes
)
1040 return build_classdollar_field (type
);
1042 if (TREE_CODE (type
) == RECORD_TYPE
)
1043 return build_static_class_ref (type
);
1049 if (flag_emit_class_files
)
1051 const char *prim_class_name
;
1053 if (type
== char_type_node
)
1054 prim_class_name
= "java.lang.Character";
1055 else if (type
== boolean_type_node
)
1056 prim_class_name
= "java.lang.Boolean";
1057 else if (type
== byte_type_node
)
1058 prim_class_name
= "java.lang.Byte";
1059 else if (type
== short_type_node
)
1060 prim_class_name
= "java.lang.Short";
1061 else if (type
== int_type_node
)
1062 prim_class_name
= "java.lang.Integer";
1063 else if (type
== long_type_node
)
1064 prim_class_name
= "java.lang.Long";
1065 else if (type
== float_type_node
)
1066 prim_class_name
= "java.lang.Float";
1067 else if (type
== double_type_node
)
1068 prim_class_name
= "java.lang.Double";
1069 else if (type
== void_type_node
)
1070 prim_class_name
= "java.lang.Void";
1074 prim_class
= lookup_class (get_identifier (prim_class_name
));
1075 /* We wrap the class in a NOP_EXPR, because it is a
1076 type. We can't hold it in the COMPONENT_REF itself,
1077 as that type must remain NULL. */
1078 prim_class
= build1 (NOP_EXPR
, prim_class
, NULL_TREE
);
1080 return build3 (COMPONENT_REF
, NULL_TREE
,
1081 prim_class
, TYPE_identifier_node
, NULL_TREE
);
1083 decl_name
= TYPE_NAME (type
);
1084 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1085 decl_name
= DECL_NAME (decl_name
);
1086 name
= IDENTIFIER_POINTER (decl_name
);
1087 if (strncmp (name
, "promoted_", 9) == 0)
1089 sprintf (buffer
, "_Jv_%sClass", name
);
1090 decl_name
= get_identifier (buffer
);
1091 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1092 if (decl
== NULL_TREE
)
1094 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1095 TREE_STATIC (decl
) = 1;
1096 TREE_PUBLIC (decl
) = 1;
1097 DECL_EXTERNAL (decl
) = 1;
1098 DECL_ARTIFICIAL (decl
) = 1;
1099 pushdecl_top_level (decl
);
1103 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1107 return build_indirect_class_ref (type
);
1110 /* Create a local statically allocated variable that will hold a
1111 pointer to a static field. */
1114 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1116 tree decl
, decl_name
;
1117 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1118 char *buf
= alloca (strlen (name
) + 20);
1119 sprintf (buf
, "%s_%d_ref", name
, index
);
1120 decl_name
= get_identifier (buf
);
1121 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1122 if (decl
== NULL_TREE
)
1124 decl
= build_decl (VAR_DECL
, decl_name
, ptr_type_node
);
1125 TREE_STATIC (decl
) = 1;
1126 TREE_PUBLIC (decl
) = 0;
1127 DECL_EXTERNAL (decl
) = 0;
1128 DECL_ARTIFICIAL (decl
) = 1;
1129 pushdecl_top_level (decl
);
1135 build_static_field_ref (tree fdecl
)
1137 tree fclass
= DECL_CONTEXT (fdecl
);
1138 int is_compiled
= is_compiled_class (fclass
);
1139 int from_class
= ! CLASS_FROM_SOURCE_P (current_class
);
1141 /* Allow static final fields to fold to a constant. When using
1142 -findirect-dispatch, we simply never do this folding if compiling
1143 from .class; in the .class file constants will be referred to via
1144 the constant pool. */
1145 if ((!flag_indirect_dispatch
|| !from_class
)
1147 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1148 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1149 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1150 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1152 if (is_compiled
== 1)
1153 DECL_EXTERNAL (fdecl
) = 1;
1157 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1158 and a class local static variable CACHE_ENTRY, then
1160 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1161 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1164 This can mostly be optimized away, so that the usual path is a
1165 load followed by a test and branch. _Jv_ResolvePoolEntry is
1166 only called once for each constant pool entry.
1168 There is an optimization that we don't do: at the start of a
1169 method, create a local copy of CACHE_ENTRY and use that instead.
1173 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1174 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1176 = build3 (CALL_EXPR
, boolean_type_node
,
1177 build_address_of (built_in_decls
[BUILT_IN_EXPECT
]),
1178 tree_cons (NULL_TREE
, build2 (EQ_EXPR
, boolean_type_node
,
1179 cache_entry
, null_pointer_node
),
1180 build_tree_list (NULL_TREE
, boolean_false_node
)),
1182 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1184 = build3 (CALL_EXPR
, ptr_type_node
,
1185 build_address_of (soft_resolvepoolentry_node
),
1186 tree_cons (NULL_TREE
, build_class_ref (output_class
),
1187 build_tree_list (NULL_TREE
, cpool_index_cst
)),
1189 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1190 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1191 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1192 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1198 get_access_flags_from_decl (tree decl
)
1200 int access_flags
= 0;
1201 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1203 if (FIELD_STATIC (decl
))
1204 access_flags
|= ACC_STATIC
;
1205 if (FIELD_PUBLIC (decl
))
1206 access_flags
|= ACC_PUBLIC
;
1207 if (FIELD_PROTECTED (decl
))
1208 access_flags
|= ACC_PROTECTED
;
1209 if (FIELD_PRIVATE (decl
))
1210 access_flags
|= ACC_PRIVATE
;
1211 if (FIELD_FINAL (decl
))
1212 access_flags
|= ACC_FINAL
;
1213 if (FIELD_VOLATILE (decl
))
1214 access_flags
|= ACC_VOLATILE
;
1215 if (FIELD_TRANSIENT (decl
))
1216 access_flags
|= ACC_TRANSIENT
;
1217 return access_flags
;
1219 if (TREE_CODE (decl
) == TYPE_DECL
)
1221 if (CLASS_PUBLIC (decl
))
1222 access_flags
|= ACC_PUBLIC
;
1223 if (CLASS_FINAL (decl
))
1224 access_flags
|= ACC_FINAL
;
1225 if (CLASS_SUPER (decl
))
1226 access_flags
|= ACC_SUPER
;
1227 if (CLASS_INTERFACE (decl
))
1228 access_flags
|= ACC_INTERFACE
;
1229 if (CLASS_ABSTRACT (decl
))
1230 access_flags
|= ACC_ABSTRACT
;
1231 if (CLASS_STATIC (decl
))
1232 access_flags
|= ACC_STATIC
;
1233 if (CLASS_PRIVATE (decl
))
1234 access_flags
|= ACC_PRIVATE
;
1235 if (CLASS_PROTECTED (decl
))
1236 access_flags
|= ACC_PROTECTED
;
1237 if (CLASS_STRICTFP (decl
))
1238 access_flags
|= ACC_STRICT
;
1239 return access_flags
;
1241 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1243 if (METHOD_PUBLIC (decl
))
1244 access_flags
|= ACC_PUBLIC
;
1245 if (METHOD_PRIVATE (decl
))
1246 access_flags
|= ACC_PRIVATE
;
1247 if (METHOD_PROTECTED (decl
))
1248 access_flags
|= ACC_PROTECTED
;
1249 if (METHOD_STATIC (decl
))
1250 access_flags
|= ACC_STATIC
;
1251 if (METHOD_FINAL (decl
))
1252 access_flags
|= ACC_FINAL
;
1253 if (METHOD_SYNCHRONIZED (decl
))
1254 access_flags
|= ACC_SYNCHRONIZED
;
1255 if (METHOD_NATIVE (decl
))
1256 access_flags
|= ACC_NATIVE
;
1257 if (METHOD_ABSTRACT (decl
))
1258 access_flags
|= ACC_ABSTRACT
;
1259 if (METHOD_STRICTFP (decl
))
1260 access_flags
|= ACC_STRICT
;
1261 if (METHOD_INVISIBLE (decl
))
1262 access_flags
|= ACC_INVISIBLE
;
1263 return access_flags
;
1268 static GTY (()) int alias_labelno
= 0;
1270 /* Create a private alias for METHOD. Using this alias instead of the method
1271 decl ensures that ncode entries in the method table point to the real function
1272 at runtime, not a PLT entry. */
1275 make_local_function_alias (tree method
)
1277 #ifdef ASM_OUTPUT_DEF
1280 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1281 char *name
= alloca (strlen (method_name
) + 2);
1282 char *buf
= alloca (strlen (method_name
) + 128);
1284 /* Only create aliases for local functions. */
1285 if (DECL_EXTERNAL (method
))
1288 /* Prefix method_name with 'L' for the alias label. */
1290 strcpy (name
+ 1, method_name
);
1292 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1293 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
1294 TREE_TYPE (method
));
1295 DECL_CONTEXT (alias
) = NULL
;
1296 TREE_READONLY (alias
) = TREE_READONLY (method
);
1297 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1298 TREE_PUBLIC (alias
) = 0;
1299 DECL_EXTERNAL (alias
) = 0;
1300 DECL_ARTIFICIAL (alias
) = 1;
1301 DECL_INLINE (alias
) = 0;
1302 DECL_INITIAL (alias
) = error_mark_node
;
1303 TREE_ADDRESSABLE (alias
) = 1;
1304 TREE_USED (alias
) = 1;
1305 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1306 if (!flag_syntax_only
)
1307 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1314 /** Make reflection data (_Jv_Field) for field FDECL. */
1317 make_field_value (tree fdecl
)
1321 tree type
= TREE_TYPE (fdecl
);
1322 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1324 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1325 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1327 type
= build_class_ref (type
);
1330 tree signature
= build_java_signature (type
);
1332 type
= build_utf8_ref (unmangle_classname
1333 (IDENTIFIER_POINTER (signature
),
1334 IDENTIFIER_LENGTH (signature
)));
1336 PUSH_FIELD_VALUE (finit
, "type", type
);
1338 flags
= get_access_flags_from_decl (fdecl
);
1340 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1342 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1343 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1346 tree field_address
= integer_zero_node
;
1347 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1348 && FIELD_STATIC (fdecl
))
1349 field_address
= build_address_of (fdecl
);
1353 build_constructor_from_list (field_info_union_node
,
1355 ((FIELD_STATIC (fdecl
)
1356 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1357 : TYPE_FIELDS (field_info_union_node
)),
1358 (FIELD_STATIC (fdecl
)
1360 : byte_position (fdecl
)))));
1363 FINISH_RECORD_CONSTRUCTOR (finit
);
1367 /** Make reflection data (_Jv_Method) for method MDECL. */
1370 make_method_value (tree mdecl
)
1372 static int method_name_count
= 0;
1377 #define ACC_TRANSLATED 0x4000
1378 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1380 class_decl
= DECL_CONTEXT (mdecl
);
1381 /* For interfaces, the index field contains the dispatch index. */
1382 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1383 index
= build_int_cst (NULL_TREE
,
1384 get_interface_method_index (mdecl
, class_decl
));
1385 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1386 index
= get_method_index (mdecl
);
1388 index
= integer_minus_one_node
;
1390 code
= null_pointer_node
;
1391 if (METHOD_ABSTRACT (mdecl
))
1392 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1393 soft_abstractmethod_node
);
1395 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1396 make_local_function_alias (mdecl
));
1397 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1398 PUSH_FIELD_VALUE (minit
, "name",
1399 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1400 init_identifier_node
1401 : DECL_NAME (mdecl
)));
1403 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1404 PUSH_FIELD_VALUE (minit
, "signature",
1407 (IDENTIFIER_POINTER(signature
),
1408 IDENTIFIER_LENGTH(signature
)))));
1410 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1411 PUSH_FIELD_VALUE (minit
, "index", index
);
1412 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1415 /* Compute the `throws' information for the method. */
1416 tree table
= null_pointer_node
;
1417 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1419 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1420 tree iter
, type
, array
;
1423 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1424 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1426 iter
= TREE_CHAIN (iter
))
1428 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1430 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1431 IDENTIFIER_LENGTH (sig
)));
1432 table
= tree_cons (NULL_TREE
, utf8
, table
);
1434 type
= build_prim_array_type (ptr_type_node
, length
);
1435 table
= build_constructor_from_list (type
, table
);
1436 /* Compute something unique enough. */
1437 sprintf (buf
, "_methods%d", method_name_count
++);
1438 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1439 DECL_INITIAL (array
) = table
;
1440 TREE_STATIC (array
) = 1;
1441 DECL_ARTIFICIAL (array
) = 1;
1442 DECL_IGNORED_P (array
) = 1;
1443 rest_of_decl_compilation (array
, 1, 0);
1445 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1448 PUSH_FIELD_VALUE (minit
, "throws", table
);
1451 FINISH_RECORD_CONSTRUCTOR (minit
);
1456 get_dispatch_vector (tree type
)
1458 tree vtable
= TYPE_VTABLE (type
);
1460 if (vtable
== NULL_TREE
)
1464 tree super
= CLASSTYPE_SUPER (type
);
1465 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1466 vtable
= make_tree_vec (nvirtuals
);
1467 TYPE_VTABLE (type
) = vtable
;
1468 if (super
!= NULL_TREE
)
1470 tree super_vtable
= get_dispatch_vector (super
);
1472 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1473 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1476 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1477 method
= TREE_CHAIN (method
))
1479 tree method_index
= get_method_index (method
);
1480 if (method_index
!= NULL_TREE
1481 && host_integerp (method_index
, 0))
1482 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1490 get_dispatch_table (tree type
, tree this_class_addr
)
1492 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1493 tree vtable
= get_dispatch_vector (type
);
1495 tree list
= NULL_TREE
;
1496 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1500 for (i
= nvirtuals
; --i
>= 0; )
1502 tree method
= TREE_VEC_ELT (vtable
, i
);
1503 if (METHOD_ABSTRACT (method
))
1506 warning (0, "%Jabstract method in non-abstract class", method
);
1508 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1509 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1510 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1512 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1516 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1517 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1519 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1520 method
, build_int_cst (NULL_TREE
, j
));
1521 TREE_CONSTANT (fdesc
) = 1;
1522 TREE_INVARIANT (fdesc
) = 1;
1523 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1526 list
= tree_cons (NULL_TREE
,
1527 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1533 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1534 using the Boehm GC we sometimes stash a GC type descriptor
1535 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1536 the emitted byte count during the output to the assembly file. */
1537 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1538 fake "function descriptor". It's first word is the is the class
1539 pointer, and subsequent words (usually one) contain the GC descriptor.
1540 In all other cases, we reserve two extra vtable slots. */
1541 gc_descr
= get_boehm_type_descriptor (type
);
1542 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1543 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1544 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1545 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1547 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1548 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1549 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1550 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1552 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1553 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1554 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1556 return build_constructor_from_list
1557 (build_prim_array_type (nativecode_ptr_type_node
,
1562 /* Set the method_index for a method decl. */
1564 set_method_index (tree decl
, tree method_index
)
1566 if (method_index
!= NULL_TREE
)
1568 /* method_index is null if we're using indirect dispatch. */
1569 method_index
= fold (convert (sizetype
, method_index
));
1571 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1572 /* Add one to skip bogus descriptor for class and GC descriptor. */
1573 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1575 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1577 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1580 DECL_VINDEX (decl
) = method_index
;
1583 /* Get the method_index for a method decl. */
1585 get_method_index (tree decl
)
1587 tree method_index
= DECL_VINDEX (decl
);
1592 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1593 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1594 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1596 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1597 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1599 return method_index
;
1603 supers_all_compiled (tree type
)
1605 while (type
!= NULL_TREE
)
1607 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1609 type
= CLASSTYPE_SUPER (type
);
1614 /* The forth (index of 3) element in the vtable is the GC descriptor.
1615 A value of 2 indicates that the class uses _Jv_MarkObj. */
1617 uses_jv_markobj_p(tree dtable
)
1620 v
= VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (dtable
), 3)->value
;
1621 return (2 == TREE_INT_CST_LOW (v
));
1625 make_class_data (tree type
)
1627 tree decl
, cons
, temp
;
1628 tree field
, fields_decl
;
1629 tree static_fields
= NULL_TREE
;
1630 tree instance_fields
= NULL_TREE
;
1631 HOST_WIDE_INT static_field_count
= 0;
1632 HOST_WIDE_INT instance_field_count
= 0;
1633 HOST_WIDE_INT field_count
;
1634 tree field_array_type
;
1636 tree methods
= NULL_TREE
;
1637 tree dtable_decl
= NULL_TREE
;
1638 HOST_WIDE_INT method_count
= 0;
1639 tree method_array_type
;
1642 tree this_class_addr
;
1643 tree constant_pool_constructor
;
1644 tree interfaces
= null_pointer_node
;
1645 int interface_len
= 0;
1646 int uses_jv_markobj
= 0;
1647 tree type_decl
= TYPE_NAME (type
);
1648 tree id_main
= get_identifier("main");
1649 tree id_class
= get_identifier("java.lang.Class");
1650 /** Offset from start of virtual function table declaration
1651 to where objects actually point at, following new g++ ABI. */
1652 tree dtable_start_offset
= build_int_cst (NULL_TREE
,
1653 2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1655 this_class_addr
= build_static_class_ref (type
);
1656 decl
= TREE_OPERAND (this_class_addr
, 0);
1658 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1659 && !flag_indirect_dispatch
)
1661 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1662 uses_jv_markobj
= uses_jv_markobj_p(dtable
);
1663 dtable_decl
= build_dtable_decl (type
);
1664 DECL_INITIAL (dtable_decl
) = dtable
;
1665 TREE_STATIC (dtable_decl
) = 1;
1666 DECL_ARTIFICIAL (dtable_decl
) = 1;
1667 DECL_IGNORED_P (dtable_decl
) = 1;
1668 TREE_PUBLIC (dtable_decl
) = 1;
1669 if (! flag_indirect_classes
)
1670 rest_of_decl_compilation (dtable_decl
, 1, 0);
1671 if (type
== class_type_node
)
1672 class_dtable_decl
= dtable_decl
;
1675 /* Build Field array. */
1676 field
= TYPE_FIELDS (type
);
1677 while (field
&& DECL_ARTIFICIAL (field
))
1678 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1679 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1680 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1681 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1683 if (! DECL_ARTIFICIAL (field
))
1685 if (FIELD_STATIC (field
))
1687 /* We must always create reflection data for static fields
1688 as it is used in the creation of the field itself. */
1689 tree init
= make_field_value (field
);
1690 tree initial
= DECL_INITIAL (field
);
1691 static_field_count
++;
1692 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1693 /* If the initial value is a string constant,
1694 prevent output_constant from trying to assemble the value. */
1695 if (initial
!= NULL_TREE
1696 && TREE_TYPE (initial
) == string_ptr_type_node
)
1697 DECL_INITIAL (field
) = NULL_TREE
;
1698 rest_of_decl_compilation (field
, 1, 1);
1699 DECL_INITIAL (field
) = initial
;
1701 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1703 tree init
= make_field_value (field
);
1704 instance_field_count
++;
1705 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1709 field_count
= static_field_count
+ instance_field_count
;
1710 if (field_count
> 0)
1712 static_fields
= nreverse (static_fields
);
1713 instance_fields
= nreverse (instance_fields
);
1714 static_fields
= chainon (static_fields
, instance_fields
);
1715 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1716 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1718 DECL_INITIAL (fields_decl
) = build_constructor_from_list
1719 (field_array_type
, static_fields
);
1720 TREE_STATIC (fields_decl
) = 1;
1721 DECL_ARTIFICIAL (fields_decl
) = 1;
1722 DECL_IGNORED_P (fields_decl
) = 1;
1723 rest_of_decl_compilation (fields_decl
, 1, 0);
1726 fields_decl
= NULL_TREE
;
1728 /* Build Method array. */
1729 for (method
= TYPE_METHODS (type
);
1730 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1733 if (METHOD_PRIVATE (method
)
1734 && ! flag_keep_inline_functions
1737 /* Even if we have a decl, we don't necessarily have the code.
1738 This can happen if we inherit a method from a superclass for
1739 which we don't have a .class file. */
1740 if (METHOD_DUMMY (method
))
1743 /* Generate method reflection data if:
1745 - !flag_reduced_reflection.
1747 - <clinit> -- The runtime uses reflection to initialize the
1750 - Any method in class java.lang.Class -- Class.forName() and
1751 perhaps other things require it.
1753 - class$ -- It does not work if reflection data missing.
1755 - main -- Reflection is used to find main(String[]) methods.
1757 - public not static -- It is potentially part of an
1758 interface. The runtime uses reflection data to build
1759 interface dispatch tables. */
1760 if (!flag_reduced_reflection
1761 || DECL_CLINIT_P (method
)
1762 || DECL_NAME (type_decl
) == id_class
1763 || DECL_NAME (method
) == id_main
1764 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
))
1765 || TYPE_DOT_CLASS (type
) == method
)
1767 init
= make_method_value (method
);
1769 methods
= tree_cons (NULL_TREE
, init
, methods
);
1772 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1773 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1775 DECL_INITIAL (methods_decl
) = build_constructor_from_list
1776 (method_array_type
, nreverse (methods
));
1777 TREE_STATIC (methods_decl
) = 1;
1778 DECL_ARTIFICIAL (methods_decl
) = 1;
1779 DECL_IGNORED_P (methods_decl
) = 1;
1780 rest_of_decl_compilation (methods_decl
, 1, 0);
1782 if (class_dtable_decl
== NULL_TREE
)
1784 class_dtable_decl
= build_dtable_decl (class_type_node
);
1785 TREE_STATIC (class_dtable_decl
) = 1;
1786 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1787 DECL_IGNORED_P (class_dtable_decl
) = 1;
1788 if (is_compiled_class (class_type_node
) != 2)
1789 DECL_EXTERNAL (class_dtable_decl
) = 1;
1790 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1793 super
= CLASSTYPE_SUPER (type
);
1794 if (super
== NULL_TREE
)
1795 super
= null_pointer_node
;
1796 else if (! flag_indirect_dispatch
1797 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1798 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1799 super
= build_class_ref (super
);
1802 int super_index
= alloc_class_constant (super
);
1803 super
= build_int_cst (ptr_type_node
, super_index
);
1806 /* Build and emit the array of implemented interfaces. */
1807 if (type
!= object_type_node
)
1808 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1810 if (interface_len
> 0)
1812 tree init
= NULL_TREE
;
1814 tree interface_array_type
, idecl
;
1815 interface_array_type
1816 = build_prim_array_type (class_ptr_type
, interface_len
);
1817 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1818 interface_array_type
);
1820 for (i
= interface_len
; i
> 0; i
--)
1822 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1823 tree iclass
= BINFO_TYPE (child
);
1825 if (! flag_indirect_dispatch
1827 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1828 index
= build_class_ref (iclass
);
1831 int int_index
= alloc_class_constant (iclass
);
1832 index
= build_int_cst (ptr_type_node
, int_index
);
1834 init
= tree_cons (NULL_TREE
, index
, init
);
1836 DECL_INITIAL (idecl
) = build_constructor_from_list (interface_array_type
,
1838 TREE_STATIC (idecl
) = 1;
1839 DECL_ARTIFICIAL (idecl
) = 1;
1840 DECL_IGNORED_P (idecl
) = 1;
1841 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1842 rest_of_decl_compilation (idecl
, 1, 0);
1845 constant_pool_constructor
= build_constants_constructor ();
1847 if (flag_indirect_dispatch
)
1849 TYPE_OTABLE_DECL (type
)
1851 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
1852 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
1853 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
1855 TYPE_ATABLE_DECL (type
)
1857 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
1858 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
1859 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
1861 TYPE_ITABLE_DECL (type
)
1863 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
1864 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
1865 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
1868 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
1870 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
1871 PUSH_FIELD_VALUE (temp
, "vtable",
1872 build2 (PLUS_EXPR
, dtable_ptr_type
,
1873 build1 (ADDR_EXPR
, dtable_ptr_type
,
1875 dtable_start_offset
));
1876 if (! flag_hash_synchronization
)
1877 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
1878 FINISH_RECORD_CONSTRUCTOR (temp
);
1879 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
1880 PUSH_SUPER_VALUE (cons
, temp
);
1881 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
1882 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
1883 PUSH_FIELD_VALUE (cons
, "accflags",
1884 build_int_cst (NULL_TREE
,
1885 get_access_flags_from_decl (type_decl
)));
1887 PUSH_FIELD_VALUE (cons
, "superclass",
1888 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
1889 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
1890 PUSH_FIELD_VALUE (cons
, "methods",
1891 methods_decl
== NULL_TREE
? null_pointer_node
1892 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
1893 PUSH_FIELD_VALUE (cons
, "method_count",
1894 build_int_cst (NULL_TREE
, method_count
));
1896 if (flag_indirect_dispatch
)
1897 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
1899 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
1901 PUSH_FIELD_VALUE (cons
, "fields",
1902 fields_decl
== NULL_TREE
? null_pointer_node
1903 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
1904 /* If we're using the binary compatibility ABI we don't know the
1905 size until load time. */
1906 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
1907 (flag_indirect_dispatch
1908 ? integer_minus_one_node
1909 : size_in_bytes (type
)));
1910 PUSH_FIELD_VALUE (cons
, "field_count",
1911 build_int_cst (NULL_TREE
, field_count
));
1912 PUSH_FIELD_VALUE (cons
, "static_field_count",
1913 build_int_cst (NULL_TREE
, static_field_count
));
1915 if (flag_indirect_dispatch
)
1916 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
1918 PUSH_FIELD_VALUE (cons
, "vtable",
1919 dtable_decl
== NULL_TREE
? null_pointer_node
1920 : build2 (PLUS_EXPR
, dtable_ptr_type
,
1921 build1 (ADDR_EXPR
, dtable_ptr_type
,
1923 dtable_start_offset
));
1924 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
1926 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
1927 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
1931 pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type
));
1932 PUSH_FIELD_VALUE (cons
, "otable",
1933 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
1934 PUSH_FIELD_VALUE (cons
, "otable_syms",
1935 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1936 TYPE_OTABLE_SYMS_DECL (type
)));
1937 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
1938 TREE_INVARIANT (TYPE_OTABLE_DECL (type
)) = 1;
1940 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
1942 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
1943 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
1947 pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type
));
1948 PUSH_FIELD_VALUE (cons
, "atable",
1949 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
1950 PUSH_FIELD_VALUE (cons
, "atable_syms",
1951 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1952 TYPE_ATABLE_SYMS_DECL (type
)));
1953 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
1954 TREE_INVARIANT (TYPE_ATABLE_DECL (type
)) = 1;
1956 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
1958 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
1959 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
1963 pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type
));
1964 PUSH_FIELD_VALUE (cons
, "itable",
1965 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
1966 PUSH_FIELD_VALUE (cons
, "itable_syms",
1967 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1968 TYPE_ITABLE_SYMS_DECL (type
)));
1969 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
1970 TREE_INVARIANT (TYPE_ITABLE_DECL (type
)) = 1;
1973 PUSH_FIELD_VALUE (cons
, "catch_classes",
1974 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
1975 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
1976 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
1977 PUSH_FIELD_VALUE (cons
, "interface_count",
1978 build_int_cst (NULL_TREE
, interface_len
));
1979 PUSH_FIELD_VALUE (cons
, "state",
1980 convert (byte_type_node
,
1981 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
1983 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
1984 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
1985 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
1986 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
1987 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
1988 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
1991 tree assertion_table_ref
;
1992 if (TYPE_ASSERTIONS (type
) == NULL
)
1993 assertion_table_ref
= null_pointer_node
;
1995 assertion_table_ref
= build1 (ADDR_EXPR
,
1996 build_pointer_type (assertion_table_type
),
1997 emit_assertion_table (type
));
1999 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
2002 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
2003 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
2004 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
2005 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
2007 FINISH_RECORD_CONSTRUCTOR (cons
);
2009 DECL_INITIAL (decl
) = cons
;
2011 /* Hash synchronization requires at least 64-bit alignment. */
2012 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2013 DECL_ALIGN (decl
) = 64;
2015 if (flag_indirect_classes
)
2017 TREE_READONLY (decl
) = 1;
2018 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2021 rest_of_decl_compilation (decl
, 1, 0);
2024 tree classdollar_field
= build_classdollar_field (type
);
2025 if (!flag_indirect_classes
)
2026 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2027 rest_of_decl_compilation (classdollar_field
, 1, 0);
2030 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2031 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2032 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2038 if (TYPE_VERIFY_METHOD (output_class
))
2040 tree verify_method
= TYPE_VERIFY_METHOD (output_class
);
2041 DECL_SAVED_TREE (verify_method
)
2042 = add_stmt_to_compound (DECL_SAVED_TREE (verify_method
), void_type_node
,
2043 build1 (RETURN_EXPR
, void_type_node
, NULL
));
2044 java_genericize (verify_method
);
2045 cgraph_finalize_function (verify_method
, false);
2046 TYPE_ASSERTIONS (current_class
) = NULL
;
2049 java_expand_catch_classes (current_class
);
2051 current_function_decl
= NULL_TREE
;
2052 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2053 make_class_data (current_class
);
2055 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2058 /* Return 2 if CLASS is compiled by this compilation job;
2059 return 1 if CLASS can otherwise be assumed to be compiled;
2060 return 0 if we cannot assume that CLASS is compiled.
2061 Returns 1 for primitive and 0 for array types. */
2063 is_compiled_class (tree
class)
2066 if (TREE_CODE (class) == POINTER_TYPE
)
2067 class = TREE_TYPE (class);
2068 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
2070 if (TYPE_ARRAY_P (class))
2072 if (class == current_class
)
2075 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
2076 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip
)
2078 /* The class was seen in the current ZIP file and will be
2079 available as a compiled class in the future but may not have
2080 been loaded already. Load it if necessary. This prevent
2081 build_class_ref () from crashing. */
2083 if (seen_in_zip
&& !CLASS_LOADED_P (class))
2084 load_class (class, 1);
2086 /* We return 2 for class seen in ZIP and class from files
2087 belonging to the same compilation unit */
2091 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
2093 if (!CLASS_LOADED_P (class))
2095 if (CLASS_FROM_SOURCE_P (class))
2096 safe_layout_class (class);
2098 load_class (class, 1);
2106 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2109 build_dtable_decl (tree type
)
2113 /* We need to build a new dtable type so that its size is uniquely
2114 computed when we're dealing with the class for real and not just
2115 faking it (like java.lang.Class during the initialization of the
2116 compiler.) We know we're not faking a class when CURRENT_CLASS is
2118 if (current_class
== type
)
2120 tree dummy
= NULL_TREE
;
2123 dtype
= make_node (RECORD_TYPE
);
2125 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
2126 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
2128 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
2129 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2131 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2132 TREE_CHAIN (dummy
) = tmp_field
;
2133 DECL_CONTEXT (tmp_field
) = dtype
;
2134 DECL_ARTIFICIAL (tmp_field
) = 1;
2138 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
2139 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2141 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2142 TREE_CHAIN (dummy
) = tmp_field
;
2143 DECL_CONTEXT (tmp_field
) = dtype
;
2144 DECL_ARTIFICIAL (tmp_field
) = 1;
2148 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2149 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2150 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2152 PUSH_FIELD (dtype
, dummy
, "methods",
2153 build_prim_array_type (nativecode_ptr_type_node
, n
));
2154 layout_type (dtype
);
2157 dtype
= dtable_type
;
2159 decl
= build_decl (VAR_DECL
, get_identifier ("vt$"), dtype
);
2160 DECL_CONTEXT (decl
) = type
;
2161 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2162 DECL_VTABLE_P (decl
) = 1;
2167 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2168 fields inherited from SUPER_CLASS. */
2171 push_super_field (tree this_class
, tree super_class
)
2174 /* Don't insert the field if we're just re-laying the class out. */
2175 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2177 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
2178 DECL_IGNORED_P (base_decl
) = 1;
2179 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2180 TYPE_FIELDS (this_class
) = base_decl
;
2181 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2182 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2185 /* Handle the different manners we may have to lay out a super class. */
2188 maybe_layout_super_class (tree super_class
, tree this_class
)
2192 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2194 if (!CLASS_LOADED_P (super_class
) && CLASS_FROM_SOURCE_P (super_class
))
2195 safe_layout_class (super_class
);
2196 if (!CLASS_LOADED_P (super_class
))
2197 load_class (super_class
, 1);
2199 /* We might have to layout the class before its dependency on
2200 the super class gets resolved by java_complete_class */
2201 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2203 if (TREE_TYPE (super_class
) != NULL_TREE
)
2204 super_class
= TREE_TYPE (super_class
);
2207 /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
2209 tree this_wrap
= NULL_TREE
;
2211 /* Set the correct context for class resolution. */
2212 current_class
= this_class
;
2216 tree this_decl
= TYPE_NAME (this_class
);
2217 #ifdef USE_MAPPED_LOCATION
2218 this_wrap
= build_expr_wfl (this_class
,
2219 DECL_SOURCE_LOCATION (this_decl
));
2221 this_wrap
= build_expr_wfl (this_class
,
2222 DECL_SOURCE_FILE (this_decl
),
2223 DECL_SOURCE_LINE (this_decl
), 0);
2227 = do_resolve_class (DECL_CONTEXT (TYPE_NAME (this_class
)),
2228 this_class
, super_class
, NULL_TREE
, this_wrap
);
2230 return NULL_TREE
; /* FIXME, NULL_TREE not checked by caller. */
2231 super_class
= TREE_TYPE (super_class
);
2234 if (!TYPE_SIZE (super_class
))
2235 safe_layout_class (super_class
);
2241 layout_class (tree this_class
)
2243 tree super_class
= CLASSTYPE_SUPER (this_class
);
2245 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2246 if (CLASS_BEING_LAIDOUT (this_class
))
2252 sprintf (buffer
, " with '%s'",
2253 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2254 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2256 for (current
= TREE_CHAIN (class_list
); current
;
2257 current
= TREE_CHAIN (current
))
2259 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2260 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2261 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2262 DECL_SOURCE_FILE (decl
),
2263 DECL_SOURCE_LINE (decl
));
2264 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2266 obstack_1grow (&temporary_obstack
, '\0');
2267 report
= obstack_finish (&temporary_obstack
);
2268 cyclic_inheritance_report
= ggc_strdup (report
);
2269 obstack_free (&temporary_obstack
, report
);
2270 TYPE_SIZE (this_class
) = error_mark_node
;
2273 CLASS_BEING_LAIDOUT (this_class
) = 1;
2275 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2277 tree maybe_super_class
2278 = maybe_layout_super_class (super_class
, this_class
);
2279 if (maybe_super_class
== NULL
2280 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2282 TYPE_SIZE (this_class
) = error_mark_node
;
2283 CLASS_BEING_LAIDOUT (this_class
) = 0;
2284 class_list
= TREE_CHAIN (class_list
);
2287 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2288 push_super_field (this_class
, maybe_super_class
);
2291 layout_type (this_class
);
2293 /* Also recursively load/layout any superinterfaces, but only if
2294 class was loaded from bytecode. The source parser will take care
2296 if (!CLASS_FROM_SOURCE_P (this_class
))
2299 if (TYPE_BINFO (this_class
))
2301 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2303 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2304 tree super_interface
= BINFO_TYPE (binfo
);
2305 tree maybe_super_interface
2306 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2307 if (maybe_super_interface
== NULL
2308 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2310 TYPE_SIZE (this_class
) = error_mark_node
;
2311 CLASS_BEING_LAIDOUT (this_class
) = 0;
2312 class_list
= TREE_CHAIN (class_list
);
2319 /* Convert the size back to an SI integer value. */
2320 TYPE_SIZE_UNIT (this_class
) =
2321 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2323 CLASS_BEING_LAIDOUT (this_class
) = 0;
2324 class_list
= TREE_CHAIN (class_list
);
2328 add_miranda_methods (tree base_class
, tree search_class
)
2331 tree binfo
, base_binfo
;
2333 if (!CLASS_PARSED_P (search_class
))
2334 load_class (search_class
, 1);
2336 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2337 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2340 tree elt
= BINFO_TYPE (base_binfo
);
2342 /* FIXME: This is totally bogus. We should not be handling
2343 Miranda methods at all if we're using the BC ABI. */
2344 if (TYPE_DUMMY (elt
))
2347 /* Ensure that interface methods are seen in declared order. */
2348 if (!CLASS_LOADED_P (elt
))
2349 load_class (elt
, 1);
2350 layout_class_methods (elt
);
2352 /* All base classes will have been laid out at this point, so the order
2353 will be correct. This code must match similar layout code in the
2355 for (method_decl
= TYPE_METHODS (elt
);
2356 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2360 /* An interface can have <clinit>. */
2361 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2364 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2365 override
= lookup_argument_method (base_class
,
2366 DECL_NAME (method_decl
), sig
);
2367 if (override
== NULL_TREE
)
2369 /* Found a Miranda method. Add it. */
2371 sig
= build_java_signature (TREE_TYPE (method_decl
));
2373 = add_method (base_class
,
2374 get_access_flags_from_decl (method_decl
),
2375 DECL_NAME (method_decl
), sig
);
2376 METHOD_INVISIBLE (new_method
) = 1;
2380 /* Try superinterfaces. */
2381 add_miranda_methods (base_class
, elt
);
2386 layout_class_methods (tree this_class
)
2388 tree method_decl
, dtable_count
;
2389 tree super_class
, type_name
;
2391 if (TYPE_NVIRTUALS (this_class
))
2394 super_class
= CLASSTYPE_SUPER (this_class
);
2398 super_class
= maybe_layout_super_class (super_class
, this_class
);
2399 if (!TYPE_NVIRTUALS (super_class
))
2400 layout_class_methods (super_class
);
2401 dtable_count
= TYPE_NVIRTUALS (super_class
);
2404 dtable_count
= integer_zero_node
;
2406 type_name
= TYPE_NAME (this_class
);
2407 if (!flag_indirect_dispatch
2408 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2410 /* An abstract class can have methods which are declared only in
2411 an implemented interface. These are called "Miranda
2412 methods". We make a dummy method entry for such methods
2414 add_miranda_methods (this_class
, this_class
);
2417 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2419 for (method_decl
= TYPE_METHODS (this_class
);
2420 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2421 dtable_count
= layout_class_method (this_class
, super_class
,
2422 method_decl
, dtable_count
);
2424 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2427 /* Return the index of METHOD in INTERFACE. This index begins at 1
2428 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2430 get_interface_method_index (tree method
, tree interface
)
2435 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
))
2439 /* We don't want to put <clinit> into the interface table. */
2440 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2442 gcc_assert (meth
!= NULL_TREE
);
2446 /* Lay METHOD_DECL out, returning a possibly new value of
2447 DTABLE_COUNT. Also mangle the method's name. */
2450 layout_class_method (tree this_class
, tree super_class
,
2451 tree method_decl
, tree dtable_count
)
2453 tree method_name
= DECL_NAME (method_decl
);
2455 TREE_PUBLIC (method_decl
) = 1;
2456 /* Considered external until we know what classes are being
2457 compiled into this object file. */
2458 DECL_EXTERNAL (method_decl
) = 1;
2460 if (ID_INIT_P (method_name
))
2462 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2464 for (ptr
= p
; *ptr
; )
2469 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2470 build_java_argument_signature (TREE_TYPE (method_decl
));
2472 else if (! METHOD_STATIC (method_decl
))
2475 build_java_argument_signature (TREE_TYPE (method_decl
));
2476 bool method_override
= false;
2477 tree super_method
= lookup_argument_method (super_class
, method_name
,
2479 if (super_method
!= NULL_TREE
2480 && ! METHOD_DUMMY (super_method
))
2482 method_override
= true;
2483 if (! METHOD_PUBLIC (super_method
) &&
2484 ! METHOD_PROTECTED (super_method
))
2486 /* Don't override private method, or default-access method in
2488 if (METHOD_PRIVATE (super_method
) ||
2489 ! in_same_package (TYPE_NAME (this_class
),
2490 TYPE_NAME (super_class
)))
2491 method_override
= false;
2494 if (method_override
)
2496 tree method_index
= get_method_index (super_method
);
2497 set_method_index (method_decl
, method_index
);
2498 if (method_index
== NULL_TREE
2499 && ! flag_indirect_dispatch
2500 && !CLASS_FROM_SOURCE_P (this_class
)
2501 && ! DECL_ARTIFICIAL (super_method
))
2502 error ("non-static method %q+D overrides static method",
2505 else if (this_class
== object_type_node
2506 && (METHOD_FINAL (method_decl
)
2507 || METHOD_PRIVATE (method_decl
)))
2509 /* We don't generate vtable entries for final Object
2510 methods. This is simply to save space, since every
2511 object would otherwise have to define them. */
2513 else if (! METHOD_PRIVATE (method_decl
)
2516 /* We generate vtable entries for final methods because they
2517 may one day be changed to non-final. */
2518 set_method_index (method_decl
, dtable_count
);
2519 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2520 dtable_count
, integer_one_node
);
2524 return dtable_count
;
2528 register_class (void)
2532 if (!registered_class
)
2533 registered_class
= VEC_alloc (tree
, gc
, 8);
2535 if (flag_indirect_classes
)
2536 node
= current_class
;
2538 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2539 VEC_safe_push (tree
, gc
, registered_class
, node
);
2542 /* Emit a function that calls _Jv_NewClassFromInitializer for every
2546 emit_indirect_register_classes (tree
*list_p
)
2548 tree klass
, t
, register_class_fn
;
2551 tree init
= NULL_TREE
;
2552 int size
= VEC_length (tree
, registered_class
) * 2 + 1;
2553 tree class_array_type
2554 = build_prim_array_type (ptr_type_node
, size
);
2555 tree
cdecl = build_decl (VAR_DECL
, get_identifier ("_Jv_CLS"),
2557 tree reg_class_list
;
2558 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2560 init
= tree_cons (NULL_TREE
,
2561 fold_convert (ptr_type_node
,
2562 build_static_class_ref (klass
)), init
);
2565 fold_convert (ptr_type_node
,
2566 build_address_of (build_classdollar_field (klass
))),
2569 init
= tree_cons (NULL_TREE
, integer_zero_node
, init
);
2570 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type
,
2572 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2573 TREE_STATIC (cdecl) = 1;
2574 DECL_ARTIFICIAL (cdecl) = 1;
2575 DECL_IGNORED_P (cdecl) = 1;
2576 TREE_READONLY (cdecl) = 1;
2577 TREE_CONSTANT (cdecl) = 1;
2578 rest_of_decl_compilation (cdecl, 1, 0);
2579 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2581 t
= build_function_type_list (void_type_node
,
2582 build_pointer_type (ptr_type_node
), NULL
);
2583 t
= build_decl (FUNCTION_DECL
,
2584 get_identifier ("_Jv_RegisterNewClasses"), t
);
2585 TREE_PUBLIC (t
) = 1;
2586 DECL_EXTERNAL (t
) = 1;
2587 register_class_fn
= t
;
2588 t
= tree_cons (NULL
, reg_class_list
, NULL
);
2589 t
= build_function_call_expr (register_class_fn
, t
);
2590 append_to_statement_list (t
, list_p
);
2594 /* Emit something to register classes at start-up time.
2596 The preferred mechanism is through the .jcr section, which contain
2597 a list of pointers to classes which get registered during constructor
2600 The fallback mechanism is to add statements to *LIST_P to call
2601 _Jv_RegisterClass for each class in this file. These statements will
2602 be added to a static constructor function for this translation unit. */
2605 emit_register_classes (tree
*list_p
)
2607 if (registered_class
== NULL
)
2610 if (flag_indirect_classes
)
2612 emit_indirect_register_classes (list_p
);
2616 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2617 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2618 but lack suitable crtbegin/end objects or linker support. These
2619 targets can overide the default in tm.h to use the fallback mechanism. */
2620 if (TARGET_USE_JCR_SECTION
)
2625 #ifdef JCR_SECTION_NAME
2626 switch_to_section (get_section (JCR_SECTION_NAME
, SECTION_WRITE
, NULL
));
2628 /* A target has defined TARGET_USE_JCR_SECTION,
2629 but doesn't have a JCR_SECTION_NAME. */
2632 assemble_align (POINTER_SIZE
);
2634 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2636 t
= build_fold_addr_expr (klass
);
2637 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2642 tree klass
, t
, register_class_fn
;
2645 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2646 t
= build_decl (FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2647 TREE_PUBLIC (t
) = 1;
2648 DECL_EXTERNAL (t
) = 1;
2649 register_class_fn
= t
;
2651 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2653 t
= build_fold_addr_expr (klass
);
2654 t
= tree_cons (NULL
, t
, NULL
);
2655 t
= build_function_call_expr (register_class_fn
, t
);
2656 append_to_statement_list (t
, list_p
);
2661 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2664 build_symbol_entry (tree decl
)
2666 tree clname
, name
, signature
, sym
;
2667 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2668 /* ??? Constructors are given the name foo.foo all the way through
2669 the compiler, but in the method table they're all renamed
2670 foo.<init>. So, we have to do the same here unless we want an
2671 unresolved reference at runtime. */
2672 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2673 && DECL_CONSTRUCTOR_P (decl
))
2674 ? init_identifier_node
2675 : DECL_NAME (decl
));
2676 signature
= build_java_signature (TREE_TYPE (decl
));
2677 signature
= build_utf8_ref (unmangle_classname
2678 (IDENTIFIER_POINTER (signature
),
2679 IDENTIFIER_LENGTH (signature
)));
2681 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2682 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2683 PUSH_FIELD_VALUE (sym
, "name", name
);
2684 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2685 FINISH_RECORD_CONSTRUCTOR (sym
);
2686 TREE_CONSTANT (sym
) = 1;
2687 TREE_INVARIANT (sym
) = 1;
2692 /* Emit a symbol table: used by -findirect-dispatch. */
2695 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2696 tree the_syms_decl
, tree the_array_element_type
,
2699 tree method_list
, method
, table
, list
, null_symbol
;
2700 tree table_size
, the_array_type
;
2703 /* Only emit a table if this translation unit actually made any
2704 references via it. */
2705 if (decl_list
== NULL_TREE
)
2708 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2710 method_list
= decl_list
;
2712 while (method_list
!= NULL_TREE
)
2714 method
= TREE_VALUE (method_list
);
2715 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
), list
);
2716 method_list
= TREE_CHAIN (method_list
);
2720 /* Terminate the list with a "null" entry. */
2721 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2722 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2723 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2724 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2725 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2726 TREE_CONSTANT (null_symbol
) = 1;
2727 TREE_INVARIANT (null_symbol
) = 1;
2728 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2730 /* Put the list in the right order and make it a constructor. */
2731 list
= nreverse (list
);
2732 table
= build_constructor_from_list (symbols_array_type
, list
);
2734 /* Make it the initial value for otable_syms and emit the decl. */
2735 DECL_INITIAL (the_syms_decl
) = table
;
2736 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2737 DECL_IGNORED_P (the_syms_decl
) = 1;
2738 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2740 /* Now that its size is known, redefine the table as an
2741 uninitialized static array of INDEX + 1 elements. The extra entry
2742 is used by the runtime to track whether the table has been
2745 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2746 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2747 the_table
= build_decl (VAR_DECL
, name
, the_array_type
);
2748 TREE_STATIC (the_table
) = 1;
2749 TREE_READONLY (the_table
) = 1;
2750 rest_of_decl_compilation (the_table
, 1, 0);
2755 /* Make an entry for the catch_classes list. */
2757 make_catch_class_record (tree catch_class
, tree classname
)
2760 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2761 START_RECORD_CONSTRUCTOR (entry
, type
);
2762 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2763 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2764 FINISH_RECORD_CONSTRUCTOR (entry
);
2769 /* Generate the list of Throwable classes that are caught by exception
2770 handlers in this class. */
2772 emit_catch_table (tree this_class
)
2774 tree table
, table_size
, array_type
;
2775 TYPE_CATCH_CLASSES (this_class
) =
2777 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2778 TYPE_CATCH_CLASSES (this_class
));
2779 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2780 TYPE_CATCH_CLASSES (this_class
) =
2782 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2783 TYPE_CATCH_CLASSES (this_class
));
2784 table_size
= build_index_type
2785 (build_int_cst (NULL_TREE
,
2786 list_length (TYPE_CATCH_CLASSES (this_class
))));
2788 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2791 build_decl (VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2792 DECL_INITIAL (table
) =
2793 build_constructor_from_list (array_type
, TYPE_CATCH_CLASSES (this_class
));
2794 TREE_STATIC (table
) = 1;
2795 TREE_READONLY (table
) = 1;
2796 DECL_IGNORED_P (table
) = 1;
2797 rest_of_decl_compilation (table
, 1, 0);
2801 /* Given a type, return the signature used by
2802 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2803 same as build_java_signature() because we want the canonical array
2807 build_signature_for_libgcj (tree type
)
2811 sig
= build_java_signature (type
);
2812 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
2813 IDENTIFIER_LENGTH (sig
)));
2817 /* Add an entry to the type assertion table. Callback used during hashtable
2821 add_assertion_table_entry (void **htab_entry
, void *ptr
)
2824 tree code_val
, op1_utf8
, op2_utf8
;
2825 tree
*list
= (tree
*) ptr
;
2826 type_assertion
*as
= (type_assertion
*) *htab_entry
;
2828 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
2830 if (as
->op1
== NULL_TREE
)
2831 op1_utf8
= null_pointer_node
;
2833 op1_utf8
= build_signature_for_libgcj (as
->op1
);
2835 if (as
->op2
== NULL_TREE
)
2836 op2_utf8
= null_pointer_node
;
2838 op2_utf8
= build_signature_for_libgcj (as
->op2
);
2840 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
2841 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
2842 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
2843 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
2844 FINISH_RECORD_CONSTRUCTOR (entry
);
2846 *list
= tree_cons (NULL_TREE
, entry
, *list
);
2850 /* Generate the type assertion table for CLASS, and return its DECL. */
2853 emit_assertion_table (tree
class)
2855 tree null_entry
, ctor
, table_decl
;
2856 tree list
= NULL_TREE
;
2857 htab_t assertions_htab
= TYPE_ASSERTIONS (class);
2859 /* Iterate through the hash table. */
2860 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
2862 /* Finish with a null entry. */
2863 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
2864 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
2865 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
2866 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
2867 FINISH_RECORD_CONSTRUCTOR (null_entry
);
2869 list
= tree_cons (NULL_TREE
, null_entry
, list
);
2871 /* Put the list in the right order and make it a constructor. */
2872 list
= nreverse (list
);
2873 ctor
= build_constructor_from_list (assertion_table_type
, list
);
2875 table_decl
= build_decl (VAR_DECL
, mangled_classname ("_type_assert_", class),
2876 assertion_table_type
);
2878 TREE_STATIC (table_decl
) = 1;
2879 TREE_READONLY (table_decl
) = 1;
2880 TREE_CONSTANT (table_decl
) = 1;
2881 DECL_IGNORED_P (table_decl
) = 1;
2883 DECL_INITIAL (table_decl
) = ctor
;
2884 DECL_ARTIFICIAL (table_decl
) = 1;
2885 rest_of_decl_compilation (table_decl
, 1, 0);
2891 init_class_processing (void)
2893 fields_ident
= get_identifier ("fields");
2894 info_ident
= get_identifier ("info");
2896 gcc_obstack_init (&temporary_obstack
);
2899 static hashval_t
java_treetreehash_hash (const void *);
2900 static int java_treetreehash_compare (const void *, const void *);
2902 /* A hash table mapping trees to trees. Used generally. */
2904 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2907 java_treetreehash_hash (const void *k_p
)
2909 struct treetreehash_entry
*k
= (struct treetreehash_entry
*) k_p
;
2910 return JAVA_TREEHASHHASH_H (k
->key
);
2914 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
2916 struct treetreehash_entry
* k1
= (struct treetreehash_entry
*) k1_p
;
2917 tree k2
= (tree
) k2_p
;
2918 return (k1
->key
== k2
);
2922 java_treetreehash_find (htab_t ht
, tree t
)
2924 struct treetreehash_entry
*e
;
2925 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2926 e
= htab_find_with_hash (ht
, t
, hv
);
2934 java_treetreehash_new (htab_t ht
, tree t
)
2937 struct treetreehash_entry
*tthe
;
2938 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2940 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
2943 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
2948 tthe
= (struct treetreehash_entry
*) *e
;
2949 return &tthe
->value
;
2953 java_treetreehash_create (size_t size
, int gc
)
2956 return htab_create_ggc (size
, java_treetreehash_hash
,
2957 java_treetreehash_compare
, NULL
);
2959 return htab_create_alloc (size
, java_treetreehash_hash
,
2960 java_treetreehash_compare
, free
, xcalloc
, free
);
2963 /* Break down qualified IDENTIFIER into package and class-name components.
2964 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
2965 "pkg.foo", and RIGHT to "Bar". */
2968 split_qualified_name (tree
*left
, tree
*right
, tree source
)
2971 int l
= IDENTIFIER_LENGTH (source
);
2973 base
= alloca (l
+ 1);
2974 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
2976 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
2978 while (*p
!= '.' && p
!= base
)
2981 /* We didn't find a '.'. Return an error. */
2987 *right
= get_identifier (p
+1);
2988 *left
= get_identifier (base
);
2993 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
2994 if the classes are from the same package. */
2997 in_same_package (tree name1
, tree name2
)
3003 if (TREE_CODE (name1
) == TYPE_DECL
)
3004 name1
= DECL_NAME (name1
);
3005 if (TREE_CODE (name2
) == TYPE_DECL
)
3006 name2
= DECL_NAME (name2
);
3008 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3009 /* One in empty package. */
3012 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3013 /* Both in empty package. */
3016 split_qualified_name (&pkg1
, &tmp
, name1
);
3017 split_qualified_name (&pkg2
, &tmp
, name2
);
3019 return (pkg1
== pkg2
);
3022 #include "gt-java-class.h"