1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
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, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, 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
= xmalloc (sizeof (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
= xmalloc (sizeof (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 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
327 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
328 and where each of the constituents is separated by '/',
329 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
332 unmangle_classname (const char *name
, int name_length
)
334 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
335 /* It's not sufficient to compare to_return and get_identifier
336 (name) to determine whether to_return is qualified. There are
337 cases in signature analysis where name will be stripped of a
339 name
= IDENTIFIER_POINTER (to_return
);
343 QUALIFIED_P (to_return
) = 1;
350 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
353 const char *typename = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
354 char *buf = alloca (strlen (typename) + strlen (#NAME "_syms_") + 1); \
357 sprintf (buf, #NAME "_%s", typename); \
358 TYPE_## TABLE ##_DECL (type) = decl = \
359 build_decl (VAR_DECL, get_identifier (buf), TABLE_TYPE); \
360 DECL_EXTERNAL (decl) = 1; \
361 TREE_STATIC (decl) = 1; \
362 TREE_READONLY (decl) = 1; \
363 TREE_CONSTANT (decl) = 1; \
364 DECL_IGNORED_P (decl) = 1; \
365 /* Mark the table as belonging to this class. */ \
367 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
368 DECL_OWNER (decl) = TYPE; \
369 sprintf (buf, #NAME "_syms_%s", typename); \
370 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
371 build_decl (VAR_DECL, get_identifier (buf), symbols_array_type); \
372 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
373 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
374 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
375 pushdecl (TYPE_## TABLE ##_SYMS_DECL (TYPE)); \
379 /* Given a class, create the DECLs for all its associated indirect
382 gen_indirect_dispatch_tables (tree type
)
384 const char *typename
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
387 char *buf
= alloca (strlen (typename
) + strlen ("_catch_classes_") + 1);
388 tree catch_class_type
= make_node (RECORD_TYPE
);
390 sprintf (buf
, "_catch_classes_%s", typename
);
391 PUSH_FIELD (catch_class_type
, field
, "address", utf8const_ptr_type
);
392 PUSH_FIELD (catch_class_type
, field
, "classname", ptr_type_node
);
393 FINISH_RECORD (catch_class_type
);
395 TYPE_CTABLE_DECL (type
)
396 = build_decl (VAR_DECL
, get_identifier (buf
),
397 build_array_type (catch_class_type
, 0));
398 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
399 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
400 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
401 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
402 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
403 pushdecl (TYPE_CTABLE_DECL (type
));
406 if (flag_indirect_dispatch
)
408 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
409 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
410 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
417 push_class (tree class_type
, tree class_name
)
419 tree decl
, signature
;
420 location_t saved_loc
= input_location
;
421 #ifndef USE_MAPPED_LOCATION
422 tree source_name
= identifier_subst (class_name
, "", '.', '/', ".java");
423 input_filename
= IDENTIFIER_POINTER (source_name
);
426 CLASS_P (class_type
) = 1;
427 decl
= build_decl (TYPE_DECL
, class_name
, class_type
);
428 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
430 /* dbxout needs a DECL_SIZE if in gstabs mode */
431 DECL_SIZE (decl
) = integer_zero_node
;
433 input_location
= saved_loc
;
434 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
435 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
437 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
438 both a typedef and in the struct name-space. We may want to re-visit
439 this later, but for now it reduces the changes needed for gdb. */
440 DECL_ARTIFICIAL (decl
) = 1;
442 pushdecl_top_level (decl
);
447 /* Finds the (global) class named NAME. Creates the class if not found.
448 Also creates associated TYPE_DECL.
449 Does not check if the class actually exists, load the class,
450 fill in field or methods, or do layout_type. */
453 lookup_class (tree name
)
455 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
456 if (decl
== NULL_TREE
)
457 decl
= push_class (make_class (), name
);
458 return TREE_TYPE (decl
);
462 set_super_info (int access_flags
, tree this_class
,
463 tree super_class
, int interfaces_count
)
465 int total_supers
= interfaces_count
;
466 tree class_decl
= TYPE_NAME (this_class
);
471 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
472 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
475 tree super_binfo
= make_tree_binfo (0);
476 BINFO_TYPE (super_binfo
) = super_class
;
477 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
478 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
479 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
482 set_class_decl_access_flags (access_flags
, class_decl
);
486 set_class_decl_access_flags (int access_flags
, tree class_decl
)
488 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
489 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
490 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
491 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
492 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
493 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
494 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
495 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
496 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
499 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
500 direct sub-classes of Object are 1, and so on. */
503 class_depth (tree clas
)
506 if (! CLASS_LOADED_P (clas
))
507 load_class (clas
, 1);
508 if (TYPE_SIZE (clas
) == error_mark_node
)
510 while (clas
!= object_type_node
)
513 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
518 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
521 interface_of_p (tree type1
, tree type2
)
524 tree binfo
, base_binfo
;
526 if (! TYPE_BINFO (type2
))
529 for (binfo
= TYPE_BINFO (type2
), i
= 0;
530 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
531 if (BINFO_TYPE (base_binfo
) == type1
)
534 for (binfo
= TYPE_BINFO (type2
), i
= 0;
535 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
536 if (BINFO_TYPE (base_binfo
)
537 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
543 /* Return true iff TYPE1 inherits from TYPE2. */
546 inherits_from_p (tree type1
, tree type2
)
548 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
552 type1
= CLASSTYPE_SUPER (type1
);
557 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
560 enclosing_context_p (tree type1
, tree type2
)
562 if (!INNER_CLASS_TYPE_P (type2
))
565 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
567 type2
= (INNER_CLASS_TYPE_P (type2
) ?
568 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
578 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
582 common_enclosing_context_p (tree type1
, tree type2
)
587 for (current
= type2
; current
;
588 current
= (INNER_CLASS_TYPE_P (current
) ?
589 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
591 if (type1
== current
)
594 if (INNER_CLASS_TYPE_P (type1
))
595 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
602 /* Return 1 iff there exists a common enclosing "this" between TYPE1
603 and TYPE2, without crossing any static context. */
606 common_enclosing_instance_p (tree type1
, tree type2
)
608 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
611 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
612 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
613 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
616 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
617 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
618 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
620 if (type1
== current
)
626 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
627 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
628 if attempt is made to add it twice. */
631 maybe_add_interface (tree this_class
, tree interface_class
)
633 tree binfo
, base_binfo
;
636 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
637 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
638 if (BINFO_TYPE (base_binfo
) == interface_class
)
639 return interface_class
;
640 add_interface (this_class
, interface_class
);
644 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
647 add_interface (tree this_class
, tree interface_class
)
649 tree interface_binfo
= make_tree_binfo (0);
651 BINFO_TYPE (interface_binfo
) = interface_class
;
652 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
653 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
654 BINFO_VIRTUAL_P (interface_binfo
) = 1;
656 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
660 /* Return the address of a pointer to the first FUNCTION_DECL
661 in the list (*LIST) whose DECL_NAME is NAME. */
664 find_named_method (tree
*list
, tree name
)
666 while (*list
&& DECL_NAME (*list
) != name
)
667 list
= &TREE_CHAIN (*list
);
673 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
675 if (access_flags
& ACC_STATIC
)
677 return build_method_type (this_class
, fntype
);
681 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
683 tree method_type
, fndecl
;
685 method_type
= build_java_method_type (function_type
,
686 this_class
, access_flags
);
688 fndecl
= build_decl (FUNCTION_DECL
, name
, method_type
);
689 DECL_CONTEXT (fndecl
) = this_class
;
691 DECL_LANG_SPECIFIC (fndecl
)
692 = ggc_alloc_cleared (sizeof (struct lang_decl
));
693 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
695 /* Initialize the static initializer test table. */
697 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
698 java_treetreehash_create (10, 1);
700 /* Initialize the initialized (static) class table. */
701 if (access_flags
& ACC_STATIC
)
702 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
703 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
705 /* Initialize the static method invocation compound list */
706 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl
) = NULL_TREE
;
708 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
709 TYPE_METHODS (this_class
) = fndecl
;
711 /* Notice that this is a finalizer and update the class type
712 accordingly. This is used to optimize instance allocation. */
713 if (name
== finalize_identifier_node
714 && TREE_TYPE (function_type
) == void_type_node
715 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
716 HAS_FINALIZER_P (this_class
) = 1;
718 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
719 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
720 if (access_flags
& ACC_PRIVATE
)
721 METHOD_PRIVATE (fndecl
) = DECL_INLINE (fndecl
) = 1;
722 if (access_flags
& ACC_NATIVE
)
724 METHOD_NATIVE (fndecl
) = 1;
725 DECL_EXTERNAL (fndecl
) = 1;
727 if (access_flags
& ACC_STATIC
)
728 METHOD_STATIC (fndecl
) = DECL_INLINE (fndecl
) = 1;
729 if (access_flags
& ACC_FINAL
)
730 METHOD_FINAL (fndecl
) = DECL_INLINE (fndecl
) = 1;
731 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
732 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
733 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
737 /* Add a method to THIS_CLASS.
738 The method's name is NAME.
739 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
742 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
744 tree function_type
, fndecl
;
745 const unsigned char *sig
746 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
749 fatal_error ("bad method signature");
751 function_type
= get_type_from_signature (method_sig
);
752 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
753 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
758 add_field (tree
class, tree name
, tree field_type
, int flags
)
760 int is_static
= (flags
& ACC_STATIC
) != 0;
762 field
= build_decl (is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
763 TREE_CHAIN (field
) = TYPE_FIELDS (class);
764 TYPE_FIELDS (class) = field
;
765 DECL_CONTEXT (field
) = class;
767 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
768 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
769 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
770 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
771 if (flags
& ACC_VOLATILE
) FIELD_VOLATILE (field
) = 1;
772 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
775 FIELD_STATIC (field
) = 1;
776 /* Always make field externally visible. This is required so
777 that native methods can always access the field. */
778 TREE_PUBLIC (field
) = 1;
779 /* Considered external until we know what classes are being
780 compiled into this object file. */
781 DECL_EXTERNAL (field
) = 1;
787 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
790 set_constant_value (tree field
, tree constant
)
792 if (field
== NULL_TREE
)
793 warning (0, "misplaced ConstantValue attribute (not in any field)");
794 else if (DECL_INITIAL (field
) != NULL_TREE
)
795 warning (0, "duplicate ConstantValue attribute for field '%s'",
796 IDENTIFIER_POINTER (DECL_NAME (field
)));
799 DECL_INITIAL (field
) = constant
;
800 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
801 && ! (TREE_TYPE (constant
) == int_type_node
802 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
803 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
804 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
805 && TREE_TYPE (field
) == string_ptr_type_node
))
806 error ("ConstantValue attribute of field '%s' has wrong type",
807 IDENTIFIER_POINTER (DECL_NAME (field
)));
808 if (FIELD_FINAL (field
))
809 DECL_FIELD_FINAL_IUD (field
) = 1;
813 /* Count the number of Unicode chars encoded in a given Ut8 string. */
817 strLengthUtf8 (char *str
, int len
)
819 register unsigned char* ptr
= (unsigned char*) str
;
820 register unsigned char *limit
= ptr
+ len
;
822 for (; ptr
< limit
; str_length
++) {
823 if (UTF8_GET (ptr
, limit
) < 0)
831 /* Calculate a hash value for a string encoded in Utf8 format.
832 * This returns the same hash value as specified for java.lang.String.hashCode.
836 hashUtf8String (const char *str
, int len
)
838 const unsigned char* ptr
= (const unsigned char*) str
;
839 const unsigned char *limit
= ptr
+ len
;
843 int ch
= UTF8_GET (ptr
, limit
);
844 /* Updated specification from
845 http://www.javasoft.com/docs/books/jls/clarify.html. */
846 hash
= (31 * hash
) + ch
;
851 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
854 build_utf8_ref (tree name
)
856 const char * name_ptr
= IDENTIFIER_POINTER(name
);
857 int name_len
= IDENTIFIER_LENGTH(name
);
859 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
860 static int utf8_count
= 0;
862 tree ref
= IDENTIFIER_UTF8_REF (name
);
864 if (ref
!= NULL_TREE
)
867 ctype
= make_node (RECORD_TYPE
);
868 str_type
= build_prim_array_type (unsigned_byte_type_node
,
869 name_len
+ 1); /* Allow for final '\0'. */
870 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
871 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
872 PUSH_FIELD (ctype
, field
, "data", str_type
);
873 FINISH_RECORD (ctype
);
874 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
875 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
876 PUSH_FIELD_VALUE (cinit
, "hash", build_int_cst (NULL_TREE
, name_hash
));
877 PUSH_FIELD_VALUE (cinit
, "length", build_int_cst (NULL_TREE
, name_len
));
878 string
= build_string (name_len
, name_ptr
);
879 TREE_TYPE (string
) = str_type
;
880 PUSH_FIELD_VALUE (cinit
, "data", string
);
881 FINISH_RECORD_CONSTRUCTOR (cinit
);
882 TREE_CONSTANT (cinit
) = 1;
883 TREE_INVARIANT (cinit
) = 1;
885 /* Generate a unique-enough identifier. */
886 sprintf(buf
, "_Utf%d", ++utf8_count
);
888 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
889 TREE_STATIC (decl
) = 1;
890 DECL_ARTIFICIAL (decl
) = 1;
891 DECL_IGNORED_P (decl
) = 1;
892 TREE_READONLY (decl
) = 1;
893 TREE_THIS_VOLATILE (decl
) = 0;
894 DECL_INITIAL (decl
) = cinit
;
896 if (HAVE_GAS_SHF_MERGE
)
899 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
900 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
901 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
902 if (flag_merge_constants
&& decl_size
< 256)
905 int flags
= (SECTION_OVERRIDE
906 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
907 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
908 named_section_flags (buf
, flags
);
909 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
913 TREE_CHAIN (decl
) = utf8_decl_list
;
914 layout_decl (decl
, 0);
916 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
917 cgraph_varpool_mark_needed_node (cgraph_varpool_node (decl
));
918 utf8_decl_list
= decl
;
919 make_decl_rtl (decl
);
920 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
921 IDENTIFIER_UTF8_REF (name
) = ref
;
925 /* Like build_class_ref, but instead of a direct reference generate a
926 pointer into the constant pool. */
929 build_indirect_class_ref (tree type
)
933 index
= alloc_class_constant (type
);
934 cl
= build_ref_from_constant_pool (index
);
935 return convert (promote_type (class_ptr_type
), cl
);
938 /* Build a reference to the class TYPE.
939 Also handles primitive types and array types. */
942 build_class_ref (tree type
)
944 int is_compiled
= is_compiled_class (type
);
947 tree ref
, decl_name
, decl
;
948 if (TREE_CODE (type
) == POINTER_TYPE
)
949 type
= TREE_TYPE (type
);
951 if (flag_indirect_dispatch
952 && type
!= output_class
953 && TREE_CODE (type
) == RECORD_TYPE
)
954 return build_indirect_class_ref (type
);
956 if (TREE_CODE (type
) == RECORD_TYPE
)
958 if (TYPE_SIZE (type
) == error_mark_node
)
959 return null_pointer_node
;
960 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
961 "", '/', '/', ".class");
962 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
963 if (decl
== NULL_TREE
)
965 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
966 DECL_SIZE (decl
) = TYPE_SIZE (class_type_node
);
967 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (class_type_node
);
968 TREE_STATIC (decl
) = 1;
969 TREE_PUBLIC (decl
) = 1;
970 DECL_IGNORED_P (decl
) = 1;
971 DECL_ARTIFICIAL (decl
) = 1;
972 if (is_compiled
== 1)
973 DECL_EXTERNAL (decl
) = 1;
974 SET_DECL_ASSEMBLER_NAME (decl
,
975 java_mangle_class_field
976 (&temporary_obstack
, type
));
977 make_decl_rtl (decl
);
978 pushdecl_top_level (decl
);
985 if (flag_emit_class_files
)
987 const char *prim_class_name
;
989 if (type
== char_type_node
)
990 prim_class_name
= "java.lang.Character";
991 else if (type
== boolean_type_node
)
992 prim_class_name
= "java.lang.Boolean";
993 else if (type
== byte_type_node
)
994 prim_class_name
= "java.lang.Byte";
995 else if (type
== short_type_node
)
996 prim_class_name
= "java.lang.Short";
997 else if (type
== int_type_node
)
998 prim_class_name
= "java.lang.Integer";
999 else if (type
== long_type_node
)
1000 prim_class_name
= "java.lang.Long";
1001 else if (type
== float_type_node
)
1002 prim_class_name
= "java.lang.Float";
1003 else if (type
== double_type_node
)
1004 prim_class_name
= "java.lang.Double";
1005 else if (type
== void_type_node
)
1006 prim_class_name
= "java.lang.Void";
1010 prim_class
= lookup_class (get_identifier (prim_class_name
));
1011 return build3 (COMPONENT_REF
, NULL_TREE
,
1012 prim_class
, TYPE_identifier_node
, NULL_TREE
);
1014 decl_name
= TYPE_NAME (type
);
1015 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1016 decl_name
= DECL_NAME (decl_name
);
1017 name
= IDENTIFIER_POINTER (decl_name
);
1018 if (strncmp (name
, "promoted_", 9) == 0)
1020 sprintf (buffer
, "_Jv_%sClass", name
);
1021 decl_name
= get_identifier (buffer
);
1022 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1023 if (decl
== NULL_TREE
)
1025 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1026 TREE_STATIC (decl
) = 1;
1027 TREE_PUBLIC (decl
) = 1;
1028 DECL_EXTERNAL (decl
) = 1;
1029 DECL_ARTIFICIAL (decl
) = 1;
1030 make_decl_rtl (decl
);
1031 pushdecl_top_level (decl
);
1035 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1039 return build_indirect_class_ref (type
);
1042 /* Create a local statically allocated variable that will hold a
1043 pointer to a static field. */
1046 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1048 tree decl
, decl_name
;
1049 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1050 char *buf
= alloca (strlen (name
) + 20);
1051 sprintf (buf
, "%s_%d_ref", name
, index
);
1052 decl_name
= get_identifier (buf
);
1053 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1054 if (decl
== NULL_TREE
)
1056 decl
= build_decl (VAR_DECL
, decl_name
, ptr_type_node
);
1057 TREE_STATIC (decl
) = 1;
1058 TREE_PUBLIC (decl
) = 0;
1059 DECL_EXTERNAL (decl
) = 0;
1060 DECL_ARTIFICIAL (decl
) = 1;
1061 make_decl_rtl (decl
);
1062 pushdecl_top_level (decl
);
1068 build_static_field_ref (tree fdecl
)
1070 tree fclass
= DECL_CONTEXT (fdecl
);
1071 int is_compiled
= is_compiled_class (fclass
);
1073 /* Allow static final fields to fold to a constant. When using
1074 -fno-assume-compiled, gcj will sometimes try to fold a field from
1075 an uncompiled class. This is required when the field in question
1076 meets the appropriate criteria for a compile-time constant.
1077 However, currently sometimes gcj is too eager and will end up
1078 returning the field itself, leading to an incorrect external
1079 reference being generated. */
1080 if ((is_compiled
&& !flag_indirect_dispatch
)
1081 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1082 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1083 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1084 && TREE_CONSTANT (DECL_INITIAL (fdecl
))))
1086 if (!DECL_RTL_SET_P (fdecl
))
1088 if (is_compiled
== 1)
1089 DECL_EXTERNAL (fdecl
) = 1;
1090 make_decl_rtl (fdecl
);
1095 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1096 and a class local static variable CACHE_ENTRY, then
1098 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1099 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1102 This can mostly be optimized away, so that the usual path is a
1103 load followed by a test and branch. _Jv_ResolvePoolEntry is
1104 only called once for each constant pool entry.
1106 There is an optimization that we don't do: at the start of a
1107 method, create a local copy of CACHE_ENTRY and use that instead.
1111 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1112 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1114 = build3 (CALL_EXPR
, boolean_type_node
,
1115 build_address_of (built_in_decls
[BUILT_IN_EXPECT
]),
1116 tree_cons (NULL_TREE
, build2 (EQ_EXPR
, boolean_type_node
,
1117 cache_entry
, null_pointer_node
),
1118 build_tree_list (NULL_TREE
, boolean_false_node
)),
1120 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1122 = build3 (CALL_EXPR
, ptr_type_node
,
1123 build_address_of (soft_resolvepoolentry_node
),
1124 tree_cons (NULL_TREE
, build_class_ref (output_class
),
1125 build_tree_list (NULL_TREE
, cpool_index_cst
)),
1127 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1128 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1129 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1130 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1136 get_access_flags_from_decl (tree decl
)
1138 int access_flags
= 0;
1139 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1141 if (FIELD_STATIC (decl
))
1142 access_flags
|= ACC_STATIC
;
1143 if (FIELD_PUBLIC (decl
))
1144 access_flags
|= ACC_PUBLIC
;
1145 if (FIELD_PROTECTED (decl
))
1146 access_flags
|= ACC_PROTECTED
;
1147 if (FIELD_PRIVATE (decl
))
1148 access_flags
|= ACC_PRIVATE
;
1149 if (FIELD_FINAL (decl
))
1150 access_flags
|= ACC_FINAL
;
1151 if (FIELD_VOLATILE (decl
))
1152 access_flags
|= ACC_VOLATILE
;
1153 if (FIELD_TRANSIENT (decl
))
1154 access_flags
|= ACC_TRANSIENT
;
1155 return access_flags
;
1157 if (TREE_CODE (decl
) == TYPE_DECL
)
1159 if (CLASS_PUBLIC (decl
))
1160 access_flags
|= ACC_PUBLIC
;
1161 if (CLASS_FINAL (decl
))
1162 access_flags
|= ACC_FINAL
;
1163 if (CLASS_SUPER (decl
))
1164 access_flags
|= ACC_SUPER
;
1165 if (CLASS_INTERFACE (decl
))
1166 access_flags
|= ACC_INTERFACE
;
1167 if (CLASS_ABSTRACT (decl
))
1168 access_flags
|= ACC_ABSTRACT
;
1169 if (CLASS_STATIC (decl
))
1170 access_flags
|= ACC_STATIC
;
1171 if (CLASS_PRIVATE (decl
))
1172 access_flags
|= ACC_PRIVATE
;
1173 if (CLASS_PROTECTED (decl
))
1174 access_flags
|= ACC_PROTECTED
;
1175 if (CLASS_STRICTFP (decl
))
1176 access_flags
|= ACC_STRICT
;
1177 return access_flags
;
1179 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1181 if (METHOD_PUBLIC (decl
))
1182 access_flags
|= ACC_PUBLIC
;
1183 if (METHOD_PRIVATE (decl
))
1184 access_flags
|= ACC_PRIVATE
;
1185 if (METHOD_PROTECTED (decl
))
1186 access_flags
|= ACC_PROTECTED
;
1187 if (METHOD_STATIC (decl
))
1188 access_flags
|= ACC_STATIC
;
1189 if (METHOD_FINAL (decl
))
1190 access_flags
|= ACC_FINAL
;
1191 if (METHOD_SYNCHRONIZED (decl
))
1192 access_flags
|= ACC_SYNCHRONIZED
;
1193 if (METHOD_NATIVE (decl
))
1194 access_flags
|= ACC_NATIVE
;
1195 if (METHOD_ABSTRACT (decl
))
1196 access_flags
|= ACC_ABSTRACT
;
1197 if (METHOD_STRICTFP (decl
))
1198 access_flags
|= ACC_STRICT
;
1199 if (METHOD_INVISIBLE (decl
))
1200 access_flags
|= ACC_INVISIBLE
;
1201 return access_flags
;
1206 static GTY (()) int alias_labelno
= 0;
1208 /* Create a private alias for METHOD. Using this alias instead of the method
1209 decl ensures that ncode entries in the method table point to the real function
1210 at runtime, not a PLT entry. */
1213 make_local_function_alias (tree method
)
1215 #ifdef ASM_OUTPUT_DEF
1218 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1219 char *name
= alloca (strlen (method_name
) + 2);
1220 char *buf
= alloca (strlen (method_name
) + 128);
1222 /* Only create aliases for local functions. */
1223 if (DECL_EXTERNAL (method
))
1226 /* Prefix method_name with 'L' for the alias label. */
1228 strcpy (name
+ 1, method_name
);
1230 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1231 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
1232 TREE_TYPE (method
));
1233 DECL_CONTEXT (alias
) = NULL
;
1234 TREE_READONLY (alias
) = TREE_READONLY (method
);
1235 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1236 TREE_PUBLIC (alias
) = 0;
1237 DECL_EXTERNAL (alias
) = 0;
1238 DECL_ARTIFICIAL (alias
) = 1;
1239 DECL_INLINE (alias
) = 0;
1240 DECL_INITIAL (alias
) = error_mark_node
;
1241 TREE_ADDRESSABLE (alias
) = 1;
1242 TREE_USED (alias
) = 1;
1243 SET_DECL_ASSEMBLER_NAME (alias
, DECL_NAME (alias
));
1244 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1245 if (!flag_syntax_only
)
1246 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1253 /** Make reflection data (_Jv_Field) for field FDECL. */
1256 make_field_value (tree fdecl
)
1260 tree type
= TREE_TYPE (fdecl
);
1261 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1263 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1264 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1266 type
= build_class_ref (type
);
1269 tree signature
= build_java_signature (type
);
1271 type
= build_utf8_ref (unmangle_classname
1272 (IDENTIFIER_POINTER (signature
),
1273 IDENTIFIER_LENGTH (signature
)));
1275 PUSH_FIELD_VALUE (finit
, "type", type
);
1277 flags
= get_access_flags_from_decl (fdecl
);
1279 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1281 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1282 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1286 build_constructor (field_info_union_node
,
1288 ((FIELD_STATIC (fdecl
)
1289 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1290 : TYPE_FIELDS (field_info_union_node
)),
1291 (FIELD_STATIC (fdecl
)
1292 ? build_address_of (fdecl
)
1293 : byte_position (fdecl
)))));
1295 FINISH_RECORD_CONSTRUCTOR (finit
);
1299 /** Make reflection data (_Jv_Method) for method MDECL. */
1302 make_method_value (tree mdecl
)
1304 static int method_name_count
= 0;
1309 #define ACC_TRANSLATED 0x4000
1310 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1312 class_decl
= DECL_CONTEXT (mdecl
);
1313 /* For interfaces, the index field contains the dispatch index. */
1314 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1315 index
= build_int_cst (NULL_TREE
,
1316 get_interface_method_index (mdecl
, class_decl
));
1317 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1318 index
= get_method_index (mdecl
);
1320 index
= integer_minus_one_node
;
1322 code
= null_pointer_node
;
1323 if (DECL_RTL_SET_P (mdecl
))
1324 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1325 make_local_function_alias (mdecl
));
1326 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1327 PUSH_FIELD_VALUE (minit
, "name",
1328 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1329 init_identifier_node
1330 : DECL_NAME (mdecl
)));
1332 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1333 PUSH_FIELD_VALUE (minit
, "signature",
1336 (IDENTIFIER_POINTER(signature
),
1337 IDENTIFIER_LENGTH(signature
)))));
1339 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1340 PUSH_FIELD_VALUE (minit
, "index", index
);
1341 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1344 /* Compute the `throws' information for the method. */
1345 tree table
= null_pointer_node
;
1346 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1348 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1349 tree iter
, type
, array
;
1352 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1353 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1355 iter
= TREE_CHAIN (iter
))
1357 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1359 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1360 IDENTIFIER_LENGTH (sig
)));
1361 table
= tree_cons (NULL_TREE
, utf8
, table
);
1363 type
= build_prim_array_type (ptr_type_node
, length
);
1364 table
= build_constructor (type
, table
);
1365 /* Compute something unique enough. */
1366 sprintf (buf
, "_methods%d", method_name_count
++);
1367 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1368 DECL_INITIAL (array
) = table
;
1369 TREE_STATIC (array
) = 1;
1370 DECL_ARTIFICIAL (array
) = 1;
1371 DECL_IGNORED_P (array
) = 1;
1372 rest_of_decl_compilation (array
, 1, 0);
1374 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1377 PUSH_FIELD_VALUE (minit
, "throws", table
);
1380 FINISH_RECORD_CONSTRUCTOR (minit
);
1385 get_dispatch_vector (tree type
)
1387 tree vtable
= TYPE_VTABLE (type
);
1389 if (vtable
== NULL_TREE
)
1393 tree super
= CLASSTYPE_SUPER (type
);
1394 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1395 vtable
= make_tree_vec (nvirtuals
);
1396 TYPE_VTABLE (type
) = vtable
;
1397 if (super
!= NULL_TREE
)
1399 tree super_vtable
= get_dispatch_vector (super
);
1401 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1402 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1405 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1406 method
= TREE_CHAIN (method
))
1408 tree method_index
= get_method_index (method
);
1409 if (method_index
!= NULL_TREE
1410 && host_integerp (method_index
, 0))
1411 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1419 get_dispatch_table (tree type
, tree this_class_addr
)
1421 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1422 tree vtable
= get_dispatch_vector (type
);
1424 tree list
= NULL_TREE
;
1425 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1429 for (i
= nvirtuals
; --i
>= 0; )
1431 tree method
= TREE_VEC_ELT (vtable
, i
);
1432 if (METHOD_ABSTRACT (method
))
1435 warning (0, "%Jabstract method in non-abstract class", method
);
1437 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1438 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1439 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1441 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1445 if (!DECL_RTL_SET_P (method
))
1446 make_decl_rtl (method
);
1448 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1449 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1451 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1452 method
, build_int_cst (NULL_TREE
, j
));
1453 TREE_CONSTANT (fdesc
) = 1;
1454 TREE_INVARIANT (fdesc
) = 1;
1455 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1458 list
= tree_cons (NULL_TREE
,
1459 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1465 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1466 using the Boehm GC we sometimes stash a GC type descriptor
1467 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1468 the emitted byte count during the output to the assembly file. */
1469 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1470 fake "function descriptor". It's first word is the is the class
1471 pointer, and subsequent words (usually one) contain the GC descriptor.
1472 In all other cases, we reserve two extra vtable slots. */
1473 gc_descr
= get_boehm_type_descriptor (type
);
1474 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1475 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1476 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1477 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1479 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1480 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1481 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1482 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1484 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1485 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1486 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1488 return build_constructor (build_prim_array_type (nativecode_ptr_type_node
,
1493 /* Set the method_index for a method decl. */
1495 set_method_index (tree decl
, tree method_index
)
1497 if (method_index
!= NULL_TREE
)
1499 /* method_index is null if we're using indirect dispatch. */
1500 method_index
= fold (convert (sizetype
, method_index
));
1502 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1503 /* Add one to skip bogus descriptor for class and GC descriptor. */
1504 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1506 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1508 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1511 DECL_VINDEX (decl
) = method_index
;
1514 /* Get the method_index for a method decl. */
1516 get_method_index (tree decl
)
1518 tree method_index
= DECL_VINDEX (decl
);
1523 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1524 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1525 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1527 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1528 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1530 return method_index
;
1534 supers_all_compiled (tree type
)
1536 while (type
!= NULL_TREE
)
1538 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1540 type
= CLASSTYPE_SUPER (type
);
1546 make_class_data (tree type
)
1548 tree decl
, cons
, temp
;
1549 tree field
, fields_decl
;
1550 tree static_fields
= NULL_TREE
;
1551 tree instance_fields
= NULL_TREE
;
1552 HOST_WIDE_INT static_field_count
= 0;
1553 HOST_WIDE_INT instance_field_count
= 0;
1554 HOST_WIDE_INT field_count
;
1555 tree field_array_type
;
1557 tree methods
= NULL_TREE
;
1558 tree dtable_decl
= NULL_TREE
;
1559 HOST_WIDE_INT method_count
= 0;
1560 tree method_array_type
;
1563 tree this_class_addr
;
1564 tree constant_pool_constructor
;
1565 tree interfaces
= null_pointer_node
;
1566 int interface_len
= 0;
1567 tree type_decl
= TYPE_NAME (type
);
1568 /** Offset from start of virtual function table declaration
1569 to where objects actually point at, following new g++ ABI. */
1570 tree dtable_start_offset
= build_int_cst (NULL_TREE
,
1571 2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1573 this_class_addr
= build_class_ref (type
);
1574 decl
= TREE_OPERAND (this_class_addr
, 0);
1576 /* Build Field array. */
1577 field
= TYPE_FIELDS (type
);
1578 while (field
&& DECL_ARTIFICIAL (field
))
1579 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1580 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1581 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1582 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1584 if (! DECL_ARTIFICIAL (field
))
1586 tree init
= make_field_value (field
);
1587 if (FIELD_STATIC (field
))
1589 tree initial
= DECL_INITIAL (field
);
1590 static_field_count
++;
1591 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1592 /* If the initial value is a string constant,
1593 prevent output_constant from trying to assemble the value. */
1594 if (initial
!= NULL_TREE
1595 && TREE_TYPE (initial
) == string_ptr_type_node
)
1596 DECL_INITIAL (field
) = NULL_TREE
;
1597 rest_of_decl_compilation (field
, 1, 1);
1598 DECL_INITIAL (field
) = initial
;
1602 instance_field_count
++;
1603 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1607 field_count
= static_field_count
+ instance_field_count
;
1608 if (field_count
> 0)
1610 static_fields
= nreverse (static_fields
);
1611 instance_fields
= nreverse (instance_fields
);
1612 static_fields
= chainon (static_fields
, instance_fields
);
1613 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1614 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1616 DECL_INITIAL (fields_decl
) = build_constructor (field_array_type
,
1618 TREE_STATIC (fields_decl
) = 1;
1619 DECL_ARTIFICIAL (fields_decl
) = 1;
1620 DECL_IGNORED_P (fields_decl
) = 1;
1621 rest_of_decl_compilation (fields_decl
, 1, 0);
1624 fields_decl
= NULL_TREE
;
1626 /* Build Method array. */
1627 for (method
= TYPE_METHODS (type
);
1628 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1631 if (METHOD_PRIVATE (method
)
1632 && ! flag_keep_inline_functions
1635 /* Even if we have a decl, we don't necessarily have the code.
1636 This can happen if we inherit a method from a superclass for
1637 which we don't have a .class file. */
1638 if (METHOD_DUMMY (method
))
1640 init
= make_method_value (method
);
1642 methods
= tree_cons (NULL_TREE
, init
, methods
);
1644 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1645 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1647 DECL_INITIAL (methods_decl
) = build_constructor (method_array_type
,
1648 nreverse (methods
));
1649 TREE_STATIC (methods_decl
) = 1;
1650 DECL_ARTIFICIAL (methods_decl
) = 1;
1651 DECL_IGNORED_P (methods_decl
) = 1;
1652 rest_of_decl_compilation (methods_decl
, 1, 0);
1654 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1655 && !flag_indirect_dispatch
)
1657 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1658 dtable_decl
= build_dtable_decl (type
);
1659 DECL_INITIAL (dtable_decl
) = dtable
;
1660 TREE_STATIC (dtable_decl
) = 1;
1661 DECL_ARTIFICIAL (dtable_decl
) = 1;
1662 DECL_IGNORED_P (dtable_decl
) = 1;
1663 TREE_PUBLIC (dtable_decl
) = 1;
1664 rest_of_decl_compilation (dtable_decl
, 1, 0);
1665 if (type
== class_type_node
)
1666 class_dtable_decl
= dtable_decl
;
1669 if (class_dtable_decl
== NULL_TREE
)
1671 class_dtable_decl
= build_dtable_decl (class_type_node
);
1672 TREE_STATIC (class_dtable_decl
) = 1;
1673 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1674 DECL_IGNORED_P (class_dtable_decl
) = 1;
1675 if (is_compiled_class (class_type_node
) != 2)
1676 DECL_EXTERNAL (class_dtable_decl
) = 1;
1677 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1680 super
= CLASSTYPE_SUPER (type
);
1681 if (super
== NULL_TREE
)
1682 super
= null_pointer_node
;
1683 else if (! flag_indirect_dispatch
1684 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1685 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1686 super
= build_class_ref (super
);
1689 int super_index
= alloc_class_constant (super
);
1690 super
= build_int_cst (ptr_type_node
, super_index
);
1693 /* Build and emit the array of implemented interfaces. */
1694 if (type
!= object_type_node
)
1695 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1697 if (interface_len
> 0)
1699 tree init
= NULL_TREE
;
1701 tree interface_array_type
, idecl
;
1702 interface_array_type
1703 = build_prim_array_type (class_ptr_type
, interface_len
);
1704 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1705 interface_array_type
);
1707 for (i
= interface_len
; i
> 0; i
--)
1709 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1710 tree iclass
= BINFO_TYPE (child
);
1712 if (! flag_indirect_dispatch
1714 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1715 index
= build_class_ref (iclass
);
1718 int int_index
= alloc_class_constant (iclass
);
1719 index
= build_int_cst (ptr_type_node
, int_index
);
1721 init
= tree_cons (NULL_TREE
, index
, init
);
1723 DECL_INITIAL (idecl
) = build_constructor (interface_array_type
, init
);
1724 TREE_STATIC (idecl
) = 1;
1725 DECL_ARTIFICIAL (idecl
) = 1;
1726 DECL_IGNORED_P (idecl
) = 1;
1727 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1728 rest_of_decl_compilation (idecl
, 1, 0);
1731 constant_pool_constructor
= build_constants_constructor ();
1733 if (flag_indirect_dispatch
)
1735 TYPE_OTABLE_DECL (type
)
1737 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
1738 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
1739 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
1741 TYPE_ATABLE_DECL (type
)
1743 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
1744 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
1745 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
1747 TYPE_ITABLE_DECL (type
)
1749 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
1750 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
1751 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
1754 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
1756 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
1757 PUSH_FIELD_VALUE (temp
, "vtable",
1758 build2 (PLUS_EXPR
, dtable_ptr_type
,
1759 build1 (ADDR_EXPR
, dtable_ptr_type
,
1761 dtable_start_offset
));
1762 if (! flag_hash_synchronization
)
1763 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
1764 FINISH_RECORD_CONSTRUCTOR (temp
);
1765 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
1766 PUSH_SUPER_VALUE (cons
, temp
);
1767 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
1768 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
1769 PUSH_FIELD_VALUE (cons
, "accflags",
1770 build_int_cst (NULL_TREE
,
1771 get_access_flags_from_decl (type_decl
)));
1773 PUSH_FIELD_VALUE (cons
, "superclass",
1774 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
1775 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
1776 PUSH_FIELD_VALUE (cons
, "methods",
1777 build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
1778 PUSH_FIELD_VALUE (cons
, "method_count",
1779 build_int_cst (NULL_TREE
, method_count
));
1781 if (flag_indirect_dispatch
)
1782 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
1784 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
1786 PUSH_FIELD_VALUE (cons
, "fields",
1787 fields_decl
== NULL_TREE
? null_pointer_node
1788 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
1789 /* If we're using the binary compatibility ABI we don't know the
1790 size until load time. */
1791 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
1792 (flag_indirect_dispatch
1793 ? integer_minus_one_node
1794 : size_in_bytes (type
)));
1795 PUSH_FIELD_VALUE (cons
, "field_count",
1796 build_int_cst (NULL_TREE
, field_count
));
1797 PUSH_FIELD_VALUE (cons
, "static_field_count",
1798 build_int_cst (NULL_TREE
, static_field_count
));
1800 if (flag_indirect_dispatch
)
1801 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
1803 PUSH_FIELD_VALUE (cons
, "vtable",
1804 dtable_decl
== NULL_TREE
? null_pointer_node
1805 : build2 (PLUS_EXPR
, dtable_ptr_type
,
1806 build1 (ADDR_EXPR
, dtable_ptr_type
,
1808 dtable_start_offset
));
1809 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
1811 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
1812 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
1816 PUSH_FIELD_VALUE (cons
, "otable",
1817 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
1818 PUSH_FIELD_VALUE (cons
, "otable_syms",
1819 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1820 TYPE_OTABLE_SYMS_DECL (type
)));
1821 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
1822 TREE_INVARIANT (TYPE_OTABLE_DECL (type
)) = 1;
1824 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
1826 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
1827 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
1831 PUSH_FIELD_VALUE (cons
, "atable",
1832 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
1833 PUSH_FIELD_VALUE (cons
, "atable_syms",
1834 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1835 TYPE_ATABLE_SYMS_DECL (type
)));
1836 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
1837 TREE_INVARIANT (TYPE_ATABLE_DECL (type
)) = 1;
1839 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
1841 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
1842 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
1846 PUSH_FIELD_VALUE (cons
, "itable",
1847 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
1848 PUSH_FIELD_VALUE (cons
, "itable_syms",
1849 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1850 TYPE_ITABLE_SYMS_DECL (type
)));
1851 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
1852 TREE_INVARIANT (TYPE_ITABLE_DECL (type
)) = 1;
1855 PUSH_FIELD_VALUE (cons
, "catch_classes",
1856 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
1857 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
1858 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
1859 PUSH_FIELD_VALUE (cons
, "interface_count",
1860 build_int_cst (NULL_TREE
, interface_len
));
1863 convert (byte_type_node
,
1864 build_int_cst (NULL_TREE
,
1865 flag_indirect_dispatch
1866 ? JV_STATE_PRELOADING
1867 : JV_STATE_COMPILED
)));
1869 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
1870 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
1871 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
1872 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
1873 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
1874 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
1877 tree assertion_table_ref
;
1878 if (TYPE_ASSERTIONS (type
) == NULL
)
1879 assertion_table_ref
= null_pointer_node
;
1881 assertion_table_ref
= build1 (ADDR_EXPR
,
1882 build_pointer_type (assertion_table_type
),
1883 emit_assertion_table (type
));
1885 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
1888 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
1889 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
1890 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
1891 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
1893 FINISH_RECORD_CONSTRUCTOR (cons
);
1895 DECL_INITIAL (decl
) = cons
;
1897 /* Hash synchronization requires at least 64-bit alignment. */
1898 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
1899 DECL_ALIGN (decl
) = 64;
1901 rest_of_decl_compilation (decl
, 1, 0);
1903 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
1904 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
1905 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
1911 if (TYPE_VERIFY_METHOD (output_class
))
1913 tree verify_method
= TYPE_VERIFY_METHOD (output_class
);
1914 DECL_SAVED_TREE (verify_method
)
1915 = add_stmt_to_compound (DECL_SAVED_TREE (verify_method
), void_type_node
,
1916 build (RETURN_EXPR
, void_type_node
, NULL
));
1917 java_genericize (verify_method
);
1918 cgraph_finalize_function (verify_method
, false);
1919 TYPE_ASSERTIONS (current_class
) = NULL
;
1922 java_expand_catch_classes (current_class
);
1924 current_function_decl
= NULL_TREE
;
1925 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
1926 make_class_data (current_class
);
1928 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
1931 /* Return 2 if CLASS is compiled by this compilation job;
1932 return 1 if CLASS can otherwise be assumed to be compiled;
1933 return 0 if we cannot assume that CLASS is compiled.
1934 Returns 1 for primitive and 0 for array types. */
1936 is_compiled_class (tree
class)
1939 if (TREE_CODE (class) == POINTER_TYPE
)
1940 class = TREE_TYPE (class);
1941 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
1943 if (TYPE_ARRAY_P (class))
1945 if (class == current_class
)
1948 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1949 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip
)
1951 /* The class was seen in the current ZIP file and will be
1952 available as a compiled class in the future but may not have
1953 been loaded already. Load it if necessary. This prevent
1954 build_class_ref () from crashing. */
1956 if (seen_in_zip
&& !CLASS_LOADED_P (class))
1957 load_class (class, 1);
1959 /* We return 2 for class seen in ZIP and class from files
1960 belonging to the same compilation unit */
1964 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1966 if (!CLASS_LOADED_P (class))
1968 if (CLASS_FROM_SOURCE_P (class))
1969 safe_layout_class (class);
1971 load_class (class, 1);
1979 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1982 build_dtable_decl (tree type
)
1986 /* We need to build a new dtable type so that its size is uniquely
1987 computed when we're dealing with the class for real and not just
1988 faking it (like java.lang.Class during the initialization of the
1989 compiler.) We know we're not faking a class when CURRENT_CLASS is
1991 if (current_class
== type
)
1993 tree dummy
= NULL_TREE
;
1996 dtype
= make_node (RECORD_TYPE
);
1998 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
1999 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
2001 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
2002 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2004 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2005 TREE_CHAIN (dummy
) = tmp_field
;
2006 DECL_CONTEXT (tmp_field
) = dtype
;
2007 DECL_ARTIFICIAL (tmp_field
) = 1;
2011 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
2012 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2014 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2015 TREE_CHAIN (dummy
) = tmp_field
;
2016 DECL_CONTEXT (tmp_field
) = dtype
;
2017 DECL_ARTIFICIAL (tmp_field
) = 1;
2021 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2022 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2023 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2025 PUSH_FIELD (dtype
, dummy
, "methods",
2026 build_prim_array_type (nativecode_ptr_type_node
, n
));
2027 layout_type (dtype
);
2030 dtype
= dtable_type
;
2032 return build_decl (VAR_DECL
,
2033 java_mangle_vtable (&temporary_obstack
, type
), dtype
);
2036 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2037 fields inherited from SUPER_CLASS. */
2040 push_super_field (tree this_class
, tree super_class
)
2043 /* Don't insert the field if we're just re-laying the class out. */
2044 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2046 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
2047 DECL_IGNORED_P (base_decl
) = 1;
2048 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2049 TYPE_FIELDS (this_class
) = base_decl
;
2050 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2051 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2054 /* Handle the different manners we may have to lay out a super class. */
2057 maybe_layout_super_class (tree super_class
, tree this_class
)
2059 if (TREE_CODE (super_class
) == RECORD_TYPE
)
2061 if (!CLASS_LOADED_P (super_class
) && CLASS_FROM_SOURCE_P (super_class
))
2062 safe_layout_class (super_class
);
2063 if (!CLASS_LOADED_P (super_class
))
2064 load_class (super_class
, 1);
2066 /* We might have to layout the class before its dependency on
2067 the super class gets resolved by java_complete_class */
2068 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2070 if (TREE_TYPE (super_class
) != NULL_TREE
)
2071 super_class
= TREE_TYPE (super_class
);
2074 /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
2076 tree this_wrap
= NULL_TREE
;
2080 tree this_decl
= TYPE_NAME (this_class
);
2081 #ifdef USE_MAPPED_LOCATION
2082 this_wrap
= build_expr_wfl (this_class
,
2083 DECL_SOURCE_LOCATION (this_decl
));
2085 this_wrap
= build_expr_wfl (this_class
,
2086 DECL_SOURCE_FILE (this_decl
),
2087 DECL_SOURCE_LINE (this_decl
), 0);
2090 super_class
= do_resolve_class (NULL_TREE
, this_class
,
2091 super_class
, NULL_TREE
, this_wrap
);
2093 return NULL_TREE
; /* FIXME, NULL_TREE not checked by caller. */
2094 super_class
= TREE_TYPE (super_class
);
2097 if (!TYPE_SIZE (super_class
))
2098 safe_layout_class (super_class
);
2104 layout_class (tree this_class
)
2106 tree super_class
= CLASSTYPE_SUPER (this_class
);
2109 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2110 if (CLASS_BEING_LAIDOUT (this_class
))
2116 sprintf (buffer
, " with '%s'",
2117 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2118 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2120 for (current
= TREE_CHAIN (class_list
); current
;
2121 current
= TREE_CHAIN (current
))
2123 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2124 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2125 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2126 DECL_SOURCE_FILE (decl
),
2127 DECL_SOURCE_LINE (decl
));
2128 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2130 obstack_1grow (&temporary_obstack
, '\0');
2131 report
= obstack_finish (&temporary_obstack
);
2132 cyclic_inheritance_report
= ggc_strdup (report
);
2133 obstack_free (&temporary_obstack
, report
);
2134 TYPE_SIZE (this_class
) = error_mark_node
;
2137 CLASS_BEING_LAIDOUT (this_class
) = 1;
2139 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2141 tree maybe_super_class
2142 = maybe_layout_super_class (super_class
, this_class
);
2143 if (maybe_super_class
== NULL
2144 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2146 TYPE_SIZE (this_class
) = error_mark_node
;
2147 CLASS_BEING_LAIDOUT (this_class
) = 0;
2148 class_list
= TREE_CHAIN (class_list
);
2151 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2152 push_super_field (this_class
, maybe_super_class
);
2155 for (field
= TYPE_FIELDS (this_class
);
2156 field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
2158 if (FIELD_STATIC (field
))
2160 /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
2161 SET_DECL_ASSEMBLER_NAME (field
,
2163 (&temporary_obstack
, field
));
2167 layout_type (this_class
);
2169 /* Also recursively load/layout any superinterfaces, but only if
2170 class was loaded from bytecode. The source parser will take care
2172 if (!CLASS_FROM_SOURCE_P (this_class
))
2175 if (TYPE_BINFO (this_class
))
2177 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2179 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2180 tree super_interface
= BINFO_TYPE (binfo
);
2181 tree maybe_super_interface
2182 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2183 if (maybe_super_interface
== NULL
2184 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2186 TYPE_SIZE (this_class
) = error_mark_node
;
2187 CLASS_BEING_LAIDOUT (this_class
) = 0;
2188 class_list
= TREE_CHAIN (class_list
);
2195 /* Convert the size back to an SI integer value. */
2196 TYPE_SIZE_UNIT (this_class
) =
2197 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2199 CLASS_BEING_LAIDOUT (this_class
) = 0;
2200 class_list
= TREE_CHAIN (class_list
);
2204 add_miranda_methods (tree base_class
, tree search_class
)
2207 tree binfo
, base_binfo
;
2209 if (!CLASS_PARSED_P (search_class
))
2210 load_class (search_class
, 1);
2212 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2213 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2216 tree elt
= BINFO_TYPE (base_binfo
);
2218 /* FIXME: This is totally bogus. We should not be handling
2219 Miranda methods at all if we're using the BC ABI. */
2220 if (TYPE_DUMMY (elt
))
2223 /* Ensure that interface methods are seen in declared order. */
2224 if (!CLASS_LOADED_P (elt
))
2225 load_class (elt
, 1);
2226 layout_class_methods (elt
);
2228 /* All base classes will have been laid out at this point, so the order
2229 will be correct. This code must match similar layout code in the
2231 for (method_decl
= TYPE_METHODS (elt
);
2232 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2236 /* An interface can have <clinit>. */
2237 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2240 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2241 override
= lookup_argument_method (base_class
,
2242 DECL_NAME (method_decl
), sig
);
2243 if (override
== NULL_TREE
)
2245 /* Found a Miranda method. Add it. */
2247 sig
= build_java_signature (TREE_TYPE (method_decl
));
2249 = add_method (base_class
,
2250 get_access_flags_from_decl (method_decl
),
2251 DECL_NAME (method_decl
), sig
);
2252 METHOD_INVISIBLE (new_method
) = 1;
2256 /* Try superinterfaces. */
2257 add_miranda_methods (base_class
, elt
);
2262 layout_class_methods (tree this_class
)
2264 tree method_decl
, dtable_count
;
2265 tree super_class
, type_name
;
2267 if (TYPE_NVIRTUALS (this_class
))
2270 super_class
= CLASSTYPE_SUPER (this_class
);
2274 super_class
= maybe_layout_super_class (super_class
, this_class
);
2275 if (!TYPE_NVIRTUALS (super_class
))
2276 layout_class_methods (super_class
);
2277 dtable_count
= TYPE_NVIRTUALS (super_class
);
2280 dtable_count
= integer_zero_node
;
2282 type_name
= TYPE_NAME (this_class
);
2283 if (!flag_indirect_dispatch
2284 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2286 /* An abstract class can have methods which are declared only in
2287 an implemented interface. These are called "Miranda
2288 methods". We make a dummy method entry for such methods
2290 add_miranda_methods (this_class
, this_class
);
2293 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2295 for (method_decl
= TYPE_METHODS (this_class
);
2296 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2297 dtable_count
= layout_class_method (this_class
, super_class
,
2298 method_decl
, dtable_count
);
2300 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2303 /* Return the index of METHOD in INTERFACE. This index begins at 1 and is used as an
2304 argument for _Jv_LookupInterfaceMethodIdx(). */
2306 get_interface_method_index (tree method
, tree interface
)
2311 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
), i
++)
2315 if (meth
== NULL_TREE
)
2320 /* Lay METHOD_DECL out, returning a possibly new value of
2321 DTABLE_COUNT. Also mangle the method's name. */
2324 layout_class_method (tree this_class
, tree super_class
,
2325 tree method_decl
, tree dtable_count
)
2327 tree method_name
= DECL_NAME (method_decl
);
2329 TREE_PUBLIC (method_decl
) = 1;
2330 /* Considered external until we know what classes are being
2331 compiled into this object file. */
2332 DECL_EXTERNAL (method_decl
) = 1;
2334 /* This is a good occasion to mangle the method's name */
2335 SET_DECL_ASSEMBLER_NAME (method_decl
,
2336 java_mangle_decl (&temporary_obstack
,
2338 /* We don't generate a RTL for the method if it's abstract, or if
2339 it's an interface method that isn't clinit. */
2340 if (! METHOD_ABSTRACT (method_decl
)
2341 || (CLASS_INTERFACE (TYPE_NAME (this_class
))
2342 && (DECL_CLINIT_P (method_decl
))))
2343 make_decl_rtl (method_decl
);
2345 if (ID_INIT_P (method_name
))
2347 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2349 for (ptr
= p
; *ptr
; )
2354 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2355 build_java_argument_signature (TREE_TYPE (method_decl
));
2357 else if (! METHOD_STATIC (method_decl
))
2360 build_java_argument_signature (TREE_TYPE (method_decl
));
2361 bool method_override
= false;
2362 tree super_method
= lookup_argument_method (super_class
, method_name
,
2364 if (super_method
!= NULL_TREE
2365 && ! METHOD_DUMMY (super_method
))
2367 method_override
= true;
2368 if (! METHOD_PUBLIC (super_method
) &&
2369 ! METHOD_PROTECTED (super_method
))
2371 /* Don't override private method, or default-access method in
2373 if (METHOD_PRIVATE (super_method
) ||
2374 ! in_same_package (TYPE_NAME (this_class
),
2375 TYPE_NAME (super_class
)))
2376 method_override
= false;
2379 if (method_override
)
2381 tree method_index
= get_method_index (super_method
);
2382 set_method_index (method_decl
, method_index
);
2383 if (method_index
== NULL_TREE
2384 && ! flag_indirect_dispatch
2385 && !CLASS_FROM_SOURCE_P (this_class
)
2386 && ! DECL_ARTIFICIAL (super_method
))
2387 error ("%Jnon-static method '%D' overrides static method",
2388 method_decl
, method_decl
);
2390 else if (this_class
== object_type_node
2391 && (METHOD_FINAL (method_decl
)
2392 || METHOD_PRIVATE (method_decl
)))
2394 /* We don't generate vtable entries for final Object
2395 methods. This is simply to save space, since every
2396 object would otherwise have to define them. */
2398 else if (! METHOD_PRIVATE (method_decl
)
2401 /* We generate vtable entries for final methods because they
2402 may one day be changed to non-final. */
2403 set_method_index (method_decl
, dtable_count
);
2404 dtable_count
= fold (build2 (PLUS_EXPR
, integer_type_node
,
2405 dtable_count
, integer_one_node
));
2409 return dtable_count
;
2413 register_class (void)
2417 if (!registered_class
)
2418 registered_class
= VEC_alloc (tree
, gc
, 8);
2420 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2421 VEC_safe_push (tree
, gc
, registered_class
, node
);
2424 /* Emit something to register classes at start-up time.
2426 The preferred mechanism is through the .jcr section, which contain
2427 a list of pointers to classes which get registered during constructor
2430 The fallback mechanism is to add statements to *LIST_P to call
2431 _Jv_RegisterClass for each class in this file. These statements will
2432 be added to a static constructor function for this translation unit. */
2435 emit_register_classes (tree
*list_p
)
2437 if (registered_class
== NULL
)
2440 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2441 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2442 but lack suitable crtbegin/end objects or linker support. These
2443 targets can overide the default in tm.h to use the fallback mechanism. */
2444 if (TARGET_USE_JCR_SECTION
)
2449 #ifdef JCR_SECTION_NAME
2450 named_section_flags (JCR_SECTION_NAME
, SECTION_WRITE
);
2452 /* A target has defined TARGET_USE_JCR_SECTION,
2453 but doesn't have a JCR_SECTION_NAME. */
2456 assemble_align (POINTER_SIZE
);
2458 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2460 t
= build_fold_addr_expr (klass
);
2461 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2466 tree klass
, t
, register_class_fn
;
2469 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2470 t
= build_decl (FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2471 TREE_PUBLIC (t
) = 1;
2472 DECL_EXTERNAL (t
) = 1;
2473 register_class_fn
= t
;
2475 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2477 t
= build_fold_addr_expr (klass
);
2478 t
= tree_cons (NULL
, t
, NULL
);
2479 t
= build_function_call_expr (register_class_fn
, t
);
2480 append_to_statement_list (t
, list_p
);
2485 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2488 build_symbol_entry (tree decl
)
2490 tree clname
, name
, signature
, sym
;
2491 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2492 /* ??? Constructors are given the name foo.foo all the way through
2493 the compiler, but in the method table they're all renamed
2494 foo.<init>. So, we have to do the same here unless we want an
2495 unresolved reference at runtime. */
2496 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2497 && DECL_CONSTRUCTOR_P (decl
))
2498 ? init_identifier_node
2499 : DECL_NAME (decl
));
2500 signature
= build_java_signature (TREE_TYPE (decl
));
2501 signature
= build_utf8_ref (unmangle_classname
2502 (IDENTIFIER_POINTER (signature
),
2503 IDENTIFIER_LENGTH (signature
)));
2505 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2506 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2507 PUSH_FIELD_VALUE (sym
, "name", name
);
2508 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2509 FINISH_RECORD_CONSTRUCTOR (sym
);
2510 TREE_CONSTANT (sym
) = 1;
2511 TREE_INVARIANT (sym
) = 1;
2516 /* Emit a symbol table: used by -findirect-dispatch. */
2519 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2520 tree the_syms_decl
, tree the_array_element_type
,
2523 tree method_list
, method
, table
, list
, null_symbol
;
2524 tree table_size
, the_array_type
;
2527 /* Only emit a table if this translation unit actually made any
2528 references via it. */
2529 if (decl_list
== NULL_TREE
)
2532 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2534 method_list
= decl_list
;
2536 while (method_list
!= NULL_TREE
)
2538 method
= TREE_VALUE (method_list
);
2539 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
), list
);
2540 method_list
= TREE_CHAIN (method_list
);
2544 /* Terminate the list with a "null" entry. */
2545 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2546 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2547 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2548 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2549 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2550 TREE_CONSTANT (null_symbol
) = 1;
2551 TREE_INVARIANT (null_symbol
) = 1;
2552 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2554 /* Put the list in the right order and make it a constructor. */
2555 list
= nreverse (list
);
2556 table
= build_constructor (symbols_array_type
, list
);
2558 /* Make it the initial value for otable_syms and emit the decl. */
2559 DECL_INITIAL (the_syms_decl
) = table
;
2560 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2561 DECL_IGNORED_P (the_syms_decl
) = 1;
2562 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2564 /* Now that its size is known, redefine the table as an
2565 uninitialized static array of INDEX + 1 elements. The extra entry
2566 is used by the runtime to track whether the table has been
2569 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2570 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2571 the_table
= build_decl (VAR_DECL
, name
, the_array_type
);
2572 TREE_STATIC (the_table
) = 1;
2573 TREE_READONLY (the_table
) = 1;
2574 rest_of_decl_compilation (the_table
, 1, 0);
2579 /* Make an entry for the catch_classes list. */
2581 make_catch_class_record (tree catch_class
, tree classname
)
2584 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2585 START_RECORD_CONSTRUCTOR (entry
, type
);
2586 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2587 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2588 FINISH_RECORD_CONSTRUCTOR (entry
);
2593 /* Generate the list of Throwable classes that are caught by exception
2594 handlers in this class. */
2596 emit_catch_table (tree this_class
)
2598 tree table
, table_size
, array_type
;
2599 TYPE_CATCH_CLASSES (this_class
) =
2601 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2602 TYPE_CATCH_CLASSES (this_class
));
2603 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2604 TYPE_CATCH_CLASSES (this_class
) =
2606 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2607 TYPE_CATCH_CLASSES (this_class
));
2608 table_size
= build_index_type
2609 (build_int_cst (NULL_TREE
,
2610 list_length (TYPE_CATCH_CLASSES (this_class
))));
2612 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2615 build_decl (VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2616 DECL_INITIAL (table
) =
2617 build_constructor (array_type
, TYPE_CATCH_CLASSES (this_class
));
2618 TREE_STATIC (table
) = 1;
2619 TREE_READONLY (table
) = 1;
2620 DECL_IGNORED_P (table
) = 1;
2621 rest_of_decl_compilation (table
, 1, 0);
2625 /* Given a type, return the signature used by
2626 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2627 same as build_java_signature() because we want the canonical array
2631 build_signature_for_libgcj (tree type
)
2635 sig
= build_java_signature (type
);
2636 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
2637 IDENTIFIER_LENGTH (sig
)));
2641 /* Add an entry to the type assertion table. Callback used during hashtable
2645 add_assertion_table_entry (void **htab_entry
, void *ptr
)
2648 tree code_val
, op1_utf8
, op2_utf8
;
2649 tree
*list
= (tree
*) ptr
;
2650 type_assertion
*as
= (type_assertion
*) *htab_entry
;
2652 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
2654 if (as
->op1
== NULL_TREE
)
2655 op1_utf8
= null_pointer_node
;
2657 op1_utf8
= build_signature_for_libgcj (as
->op1
);
2659 if (as
->op2
== NULL_TREE
)
2660 op2_utf8
= null_pointer_node
;
2662 op2_utf8
= build_signature_for_libgcj (as
->op2
);
2664 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
2665 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
2666 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
2667 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
2668 FINISH_RECORD_CONSTRUCTOR (entry
);
2670 *list
= tree_cons (NULL_TREE
, entry
, *list
);
2674 /* Generate the type assertion table for CLASS, and return its DECL. */
2677 emit_assertion_table (tree
class)
2679 tree null_entry
, ctor
, table_decl
;
2680 tree list
= NULL_TREE
;
2681 htab_t assertions_htab
= TYPE_ASSERTIONS (class);
2683 /* Iterate through the hash table. */
2684 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
2686 /* Finish with a null entry. */
2687 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
2688 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
2689 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
2690 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
2691 FINISH_RECORD_CONSTRUCTOR (null_entry
);
2693 list
= tree_cons (NULL_TREE
, null_entry
, list
);
2695 /* Put the list in the right order and make it a constructor. */
2696 list
= nreverse (list
);
2697 ctor
= build_constructor (assertion_table_type
, list
);
2699 table_decl
= build_decl (VAR_DECL
, mangled_classname ("_type_assert_", class),
2700 assertion_table_type
);
2702 TREE_STATIC (table_decl
) = 1;
2703 TREE_READONLY (table_decl
) = 1;
2704 TREE_CONSTANT (table_decl
) = 1;
2705 DECL_IGNORED_P (table_decl
) = 1;
2707 DECL_INITIAL (table_decl
) = ctor
;
2708 DECL_ARTIFICIAL (table_decl
) = 1;
2709 rest_of_decl_compilation (table_decl
, 1, 0);
2715 init_class_processing (void)
2717 fields_ident
= get_identifier ("fields");
2718 info_ident
= get_identifier ("info");
2720 gcc_obstack_init (&temporary_obstack
);
2723 static hashval_t
java_treetreehash_hash (const void *);
2724 static int java_treetreehash_compare (const void *, const void *);
2726 /* A hash table mapping trees to trees. Used generally. */
2728 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2731 java_treetreehash_hash (const void *k_p
)
2733 struct treetreehash_entry
*k
= (struct treetreehash_entry
*) k_p
;
2734 return JAVA_TREEHASHHASH_H (k
->key
);
2738 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
2740 struct treetreehash_entry
* k1
= (struct treetreehash_entry
*) k1_p
;
2741 tree k2
= (tree
) k2_p
;
2742 return (k1
->key
== k2
);
2746 java_treetreehash_find (htab_t ht
, tree t
)
2748 struct treetreehash_entry
*e
;
2749 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2750 e
= htab_find_with_hash (ht
, t
, hv
);
2758 java_treetreehash_new (htab_t ht
, tree t
)
2761 struct treetreehash_entry
*tthe
;
2762 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2764 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
2767 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
2772 tthe
= (struct treetreehash_entry
*) *e
;
2773 return &tthe
->value
;
2777 java_treetreehash_create (size_t size
, int gc
)
2780 return htab_create_ggc (size
, java_treetreehash_hash
,
2781 java_treetreehash_compare
, NULL
);
2783 return htab_create_alloc (size
, java_treetreehash_hash
,
2784 java_treetreehash_compare
, free
, xcalloc
, free
);
2787 /* Break down qualified IDENTIFIER into package and class-name components.
2788 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
2789 "pkg.foo", and RIGHT to "Bar". */
2792 split_qualified_name (tree
*left
, tree
*right
, tree source
)
2795 int l
= IDENTIFIER_LENGTH (source
);
2797 base
= alloca (l
+ 1);
2798 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
2800 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
2802 while (*p
!= '.' && p
!= base
)
2805 /* We didn't find a '.'. Return an error. */
2811 *right
= get_identifier (p
+1);
2812 *left
= get_identifier (base
);
2817 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
2818 if the classes are from the same package. */
2821 in_same_package (tree name1
, tree name2
)
2827 if (TREE_CODE (name1
) == TYPE_DECL
)
2828 name1
= DECL_NAME (name1
);
2829 if (TREE_CODE (name2
) == TYPE_DECL
)
2830 name2
= DECL_NAME (name2
);
2832 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
2833 /* One in empty package. */
2836 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
2837 /* Both in empty package. */
2840 split_qualified_name (&pkg1
, &tmp
, name1
);
2841 split_qualified_name (&pkg2
, &tmp
, name2
);
2843 return (pkg1
== pkg2
);
2846 #include "gt-java-class.h"