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 (OPT_Wattributes
,
794 "misplaced ConstantValue attribute (not in any field)");
795 else if (DECL_INITIAL (field
) != NULL_TREE
)
796 warning (OPT_Wattributes
,
797 "duplicate ConstantValue attribute for field '%s'",
798 IDENTIFIER_POINTER (DECL_NAME (field
)));
801 DECL_INITIAL (field
) = constant
;
802 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
803 && ! (TREE_TYPE (constant
) == int_type_node
804 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
805 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
806 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
807 && TREE_TYPE (field
) == string_ptr_type_node
))
808 error ("ConstantValue attribute of field '%s' has wrong type",
809 IDENTIFIER_POINTER (DECL_NAME (field
)));
810 if (FIELD_FINAL (field
))
811 DECL_FIELD_FINAL_IUD (field
) = 1;
815 /* Count the number of Unicode chars encoded in a given Ut8 string. */
819 strLengthUtf8 (char *str
, int len
)
821 register unsigned char* ptr
= (unsigned char*) str
;
822 register unsigned char *limit
= ptr
+ len
;
824 for (; ptr
< limit
; str_length
++) {
825 if (UTF8_GET (ptr
, limit
) < 0)
833 /* Calculate a hash value for a string encoded in Utf8 format.
834 * This returns the same hash value as specified for java.lang.String.hashCode.
838 hashUtf8String (const char *str
, int len
)
840 const unsigned char* ptr
= (const unsigned char*) str
;
841 const unsigned char *limit
= ptr
+ len
;
845 int ch
= UTF8_GET (ptr
, limit
);
846 /* Updated specification from
847 http://www.javasoft.com/docs/books/jls/clarify.html. */
848 hash
= (31 * hash
) + ch
;
853 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
856 build_utf8_ref (tree name
)
858 const char * name_ptr
= IDENTIFIER_POINTER(name
);
859 int name_len
= IDENTIFIER_LENGTH(name
);
861 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
862 static int utf8_count
= 0;
864 tree ref
= IDENTIFIER_UTF8_REF (name
);
866 if (ref
!= NULL_TREE
)
869 ctype
= make_node (RECORD_TYPE
);
870 str_type
= build_prim_array_type (unsigned_byte_type_node
,
871 name_len
+ 1); /* Allow for final '\0'. */
872 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
873 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
874 PUSH_FIELD (ctype
, field
, "data", str_type
);
875 FINISH_RECORD (ctype
);
876 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
877 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
878 PUSH_FIELD_VALUE (cinit
, "hash", build_int_cst (NULL_TREE
, name_hash
));
879 PUSH_FIELD_VALUE (cinit
, "length", build_int_cst (NULL_TREE
, name_len
));
880 string
= build_string (name_len
, name_ptr
);
881 TREE_TYPE (string
) = str_type
;
882 PUSH_FIELD_VALUE (cinit
, "data", string
);
883 FINISH_RECORD_CONSTRUCTOR (cinit
);
884 TREE_CONSTANT (cinit
) = 1;
885 TREE_INVARIANT (cinit
) = 1;
887 /* Generate a unique-enough identifier. */
888 sprintf(buf
, "_Utf%d", ++utf8_count
);
890 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
891 TREE_STATIC (decl
) = 1;
892 DECL_ARTIFICIAL (decl
) = 1;
893 DECL_IGNORED_P (decl
) = 1;
894 TREE_READONLY (decl
) = 1;
895 TREE_THIS_VOLATILE (decl
) = 0;
896 DECL_INITIAL (decl
) = cinit
;
898 if (HAVE_GAS_SHF_MERGE
)
901 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
902 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
903 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
904 if (flag_merge_constants
&& decl_size
< 256)
907 int flags
= (SECTION_OVERRIDE
908 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
909 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
910 named_section_flags (buf
, flags
);
911 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
915 TREE_CHAIN (decl
) = utf8_decl_list
;
916 layout_decl (decl
, 0);
918 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
919 cgraph_varpool_mark_needed_node (cgraph_varpool_node (decl
));
920 utf8_decl_list
= decl
;
921 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
922 IDENTIFIER_UTF8_REF (name
) = ref
;
926 /* Like build_class_ref, but instead of a direct reference generate a
927 pointer into the constant pool. */
930 build_indirect_class_ref (tree type
)
934 index
= alloc_class_constant (type
);
935 cl
= build_ref_from_constant_pool (index
);
936 return convert (promote_type (class_ptr_type
), cl
);
939 /* Build a reference to the class TYPE.
940 Also handles primitive types and array types. */
943 build_class_ref (tree type
)
945 int is_compiled
= is_compiled_class (type
);
948 tree ref
, decl_name
, decl
;
949 if (TREE_CODE (type
) == POINTER_TYPE
)
950 type
= TREE_TYPE (type
);
952 if (flag_indirect_dispatch
953 && type
!= output_class
954 && TREE_CODE (type
) == RECORD_TYPE
)
955 return build_indirect_class_ref (type
);
957 if (TREE_CODE (type
) == RECORD_TYPE
)
959 if (TYPE_SIZE (type
) == error_mark_node
)
960 return null_pointer_node
;
961 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
962 "", '/', '/', ".class");
963 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
964 if (decl
== NULL_TREE
)
966 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
967 TREE_STATIC (decl
) = 1;
968 TREE_PUBLIC (decl
) = 1;
969 DECL_IGNORED_P (decl
) = 1;
970 DECL_ARTIFICIAL (decl
) = 1;
971 if (is_compiled
== 1)
972 DECL_EXTERNAL (decl
) = 1;
973 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
974 DECL_CLASS_FIELD_P (decl
) = 1;
975 DECL_CONTEXT (decl
) = type
;
977 /* ??? We want to preserve the DECL_CONTEXT we set just above,
978 that that means not calling pushdecl_top_level. */
979 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
986 if (flag_emit_class_files
)
988 const char *prim_class_name
;
990 if (type
== char_type_node
)
991 prim_class_name
= "java.lang.Character";
992 else if (type
== boolean_type_node
)
993 prim_class_name
= "java.lang.Boolean";
994 else if (type
== byte_type_node
)
995 prim_class_name
= "java.lang.Byte";
996 else if (type
== short_type_node
)
997 prim_class_name
= "java.lang.Short";
998 else if (type
== int_type_node
)
999 prim_class_name
= "java.lang.Integer";
1000 else if (type
== long_type_node
)
1001 prim_class_name
= "java.lang.Long";
1002 else if (type
== float_type_node
)
1003 prim_class_name
= "java.lang.Float";
1004 else if (type
== double_type_node
)
1005 prim_class_name
= "java.lang.Double";
1006 else if (type
== void_type_node
)
1007 prim_class_name
= "java.lang.Void";
1011 prim_class
= lookup_class (get_identifier (prim_class_name
));
1012 return build3 (COMPONENT_REF
, NULL_TREE
,
1013 prim_class
, TYPE_identifier_node
, NULL_TREE
);
1015 decl_name
= TYPE_NAME (type
);
1016 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1017 decl_name
= DECL_NAME (decl_name
);
1018 name
= IDENTIFIER_POINTER (decl_name
);
1019 if (strncmp (name
, "promoted_", 9) == 0)
1021 sprintf (buffer
, "_Jv_%sClass", name
);
1022 decl_name
= get_identifier (buffer
);
1023 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1024 if (decl
== NULL_TREE
)
1026 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1027 TREE_STATIC (decl
) = 1;
1028 TREE_PUBLIC (decl
) = 1;
1029 DECL_EXTERNAL (decl
) = 1;
1030 DECL_ARTIFICIAL (decl
) = 1;
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 pushdecl_top_level (decl
);
1067 build_static_field_ref (tree fdecl
)
1069 tree fclass
= DECL_CONTEXT (fdecl
);
1070 int is_compiled
= is_compiled_class (fclass
);
1072 /* Allow static final fields to fold to a constant. When using
1073 -fno-assume-compiled, gcj will sometimes try to fold a field from
1074 an uncompiled class. This is required when the field in question
1075 meets the appropriate criteria for a compile-time constant.
1076 However, currently sometimes gcj is too eager and will end up
1077 returning the field itself, leading to an incorrect external
1078 reference being generated. */
1079 if ((is_compiled
&& !flag_indirect_dispatch
)
1080 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1081 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1082 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1083 && TREE_CONSTANT (DECL_INITIAL (fdecl
))))
1085 if (is_compiled
== 1)
1086 DECL_EXTERNAL (fdecl
) = 1;
1090 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1091 and a class local static variable CACHE_ENTRY, then
1093 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1094 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1097 This can mostly be optimized away, so that the usual path is a
1098 load followed by a test and branch. _Jv_ResolvePoolEntry is
1099 only called once for each constant pool entry.
1101 There is an optimization that we don't do: at the start of a
1102 method, create a local copy of CACHE_ENTRY and use that instead.
1106 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1107 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1109 = build3 (CALL_EXPR
, boolean_type_node
,
1110 build_address_of (built_in_decls
[BUILT_IN_EXPECT
]),
1111 tree_cons (NULL_TREE
, build2 (EQ_EXPR
, boolean_type_node
,
1112 cache_entry
, null_pointer_node
),
1113 build_tree_list (NULL_TREE
, boolean_false_node
)),
1115 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1117 = build3 (CALL_EXPR
, ptr_type_node
,
1118 build_address_of (soft_resolvepoolentry_node
),
1119 tree_cons (NULL_TREE
, build_class_ref (output_class
),
1120 build_tree_list (NULL_TREE
, cpool_index_cst
)),
1122 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1123 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1124 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1125 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1131 get_access_flags_from_decl (tree decl
)
1133 int access_flags
= 0;
1134 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1136 if (FIELD_STATIC (decl
))
1137 access_flags
|= ACC_STATIC
;
1138 if (FIELD_PUBLIC (decl
))
1139 access_flags
|= ACC_PUBLIC
;
1140 if (FIELD_PROTECTED (decl
))
1141 access_flags
|= ACC_PROTECTED
;
1142 if (FIELD_PRIVATE (decl
))
1143 access_flags
|= ACC_PRIVATE
;
1144 if (FIELD_FINAL (decl
))
1145 access_flags
|= ACC_FINAL
;
1146 if (FIELD_VOLATILE (decl
))
1147 access_flags
|= ACC_VOLATILE
;
1148 if (FIELD_TRANSIENT (decl
))
1149 access_flags
|= ACC_TRANSIENT
;
1150 return access_flags
;
1152 if (TREE_CODE (decl
) == TYPE_DECL
)
1154 if (CLASS_PUBLIC (decl
))
1155 access_flags
|= ACC_PUBLIC
;
1156 if (CLASS_FINAL (decl
))
1157 access_flags
|= ACC_FINAL
;
1158 if (CLASS_SUPER (decl
))
1159 access_flags
|= ACC_SUPER
;
1160 if (CLASS_INTERFACE (decl
))
1161 access_flags
|= ACC_INTERFACE
;
1162 if (CLASS_ABSTRACT (decl
))
1163 access_flags
|= ACC_ABSTRACT
;
1164 if (CLASS_STATIC (decl
))
1165 access_flags
|= ACC_STATIC
;
1166 if (CLASS_PRIVATE (decl
))
1167 access_flags
|= ACC_PRIVATE
;
1168 if (CLASS_PROTECTED (decl
))
1169 access_flags
|= ACC_PROTECTED
;
1170 if (CLASS_STRICTFP (decl
))
1171 access_flags
|= ACC_STRICT
;
1172 return access_flags
;
1174 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1176 if (METHOD_PUBLIC (decl
))
1177 access_flags
|= ACC_PUBLIC
;
1178 if (METHOD_PRIVATE (decl
))
1179 access_flags
|= ACC_PRIVATE
;
1180 if (METHOD_PROTECTED (decl
))
1181 access_flags
|= ACC_PROTECTED
;
1182 if (METHOD_STATIC (decl
))
1183 access_flags
|= ACC_STATIC
;
1184 if (METHOD_FINAL (decl
))
1185 access_flags
|= ACC_FINAL
;
1186 if (METHOD_SYNCHRONIZED (decl
))
1187 access_flags
|= ACC_SYNCHRONIZED
;
1188 if (METHOD_NATIVE (decl
))
1189 access_flags
|= ACC_NATIVE
;
1190 if (METHOD_ABSTRACT (decl
))
1191 access_flags
|= ACC_ABSTRACT
;
1192 if (METHOD_STRICTFP (decl
))
1193 access_flags
|= ACC_STRICT
;
1194 if (METHOD_INVISIBLE (decl
))
1195 access_flags
|= ACC_INVISIBLE
;
1196 return access_flags
;
1201 static GTY (()) int alias_labelno
= 0;
1203 /* Create a private alias for METHOD. Using this alias instead of the method
1204 decl ensures that ncode entries in the method table point to the real function
1205 at runtime, not a PLT entry. */
1208 make_local_function_alias (tree method
)
1210 #ifdef ASM_OUTPUT_DEF
1213 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1214 char *name
= alloca (strlen (method_name
) + 2);
1215 char *buf
= alloca (strlen (method_name
) + 128);
1217 /* Only create aliases for local functions. */
1218 if (DECL_EXTERNAL (method
))
1221 /* Prefix method_name with 'L' for the alias label. */
1223 strcpy (name
+ 1, method_name
);
1225 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1226 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
1227 TREE_TYPE (method
));
1228 DECL_CONTEXT (alias
) = NULL
;
1229 TREE_READONLY (alias
) = TREE_READONLY (method
);
1230 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1231 TREE_PUBLIC (alias
) = 0;
1232 DECL_EXTERNAL (alias
) = 0;
1233 DECL_ARTIFICIAL (alias
) = 1;
1234 DECL_INLINE (alias
) = 0;
1235 DECL_INITIAL (alias
) = error_mark_node
;
1236 TREE_ADDRESSABLE (alias
) = 1;
1237 TREE_USED (alias
) = 1;
1238 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1239 if (!flag_syntax_only
)
1240 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1247 /** Make reflection data (_Jv_Field) for field FDECL. */
1250 make_field_value (tree fdecl
)
1254 tree type
= TREE_TYPE (fdecl
);
1255 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1257 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1258 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1260 type
= build_class_ref (type
);
1263 tree signature
= build_java_signature (type
);
1265 type
= build_utf8_ref (unmangle_classname
1266 (IDENTIFIER_POINTER (signature
),
1267 IDENTIFIER_LENGTH (signature
)));
1269 PUSH_FIELD_VALUE (finit
, "type", type
);
1271 flags
= get_access_flags_from_decl (fdecl
);
1273 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1275 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1276 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1280 build_constructor (field_info_union_node
,
1282 ((FIELD_STATIC (fdecl
)
1283 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1284 : TYPE_FIELDS (field_info_union_node
)),
1285 (FIELD_STATIC (fdecl
)
1286 ? build_address_of (fdecl
)
1287 : byte_position (fdecl
)))));
1289 FINISH_RECORD_CONSTRUCTOR (finit
);
1293 /** Make reflection data (_Jv_Method) for method MDECL. */
1296 make_method_value (tree mdecl
)
1298 static int method_name_count
= 0;
1303 #define ACC_TRANSLATED 0x4000
1304 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1306 class_decl
= DECL_CONTEXT (mdecl
);
1307 /* For interfaces, the index field contains the dispatch index. */
1308 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1309 index
= build_int_cst (NULL_TREE
,
1310 get_interface_method_index (mdecl
, class_decl
));
1311 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1312 index
= get_method_index (mdecl
);
1314 index
= integer_minus_one_node
;
1316 code
= null_pointer_node
;
1317 if (!METHOD_ABSTRACT (mdecl
))
1318 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1319 make_local_function_alias (mdecl
));
1320 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1321 PUSH_FIELD_VALUE (minit
, "name",
1322 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1323 init_identifier_node
1324 : DECL_NAME (mdecl
)));
1326 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1327 PUSH_FIELD_VALUE (minit
, "signature",
1330 (IDENTIFIER_POINTER(signature
),
1331 IDENTIFIER_LENGTH(signature
)))));
1333 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1334 PUSH_FIELD_VALUE (minit
, "index", index
);
1335 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1338 /* Compute the `throws' information for the method. */
1339 tree table
= null_pointer_node
;
1340 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1342 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1343 tree iter
, type
, array
;
1346 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1347 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1349 iter
= TREE_CHAIN (iter
))
1351 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1353 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1354 IDENTIFIER_LENGTH (sig
)));
1355 table
= tree_cons (NULL_TREE
, utf8
, table
);
1357 type
= build_prim_array_type (ptr_type_node
, length
);
1358 table
= build_constructor (type
, table
);
1359 /* Compute something unique enough. */
1360 sprintf (buf
, "_methods%d", method_name_count
++);
1361 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1362 DECL_INITIAL (array
) = table
;
1363 TREE_STATIC (array
) = 1;
1364 DECL_ARTIFICIAL (array
) = 1;
1365 DECL_IGNORED_P (array
) = 1;
1366 rest_of_decl_compilation (array
, 1, 0);
1368 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1371 PUSH_FIELD_VALUE (minit
, "throws", table
);
1374 FINISH_RECORD_CONSTRUCTOR (minit
);
1379 get_dispatch_vector (tree type
)
1381 tree vtable
= TYPE_VTABLE (type
);
1383 if (vtable
== NULL_TREE
)
1387 tree super
= CLASSTYPE_SUPER (type
);
1388 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1389 vtable
= make_tree_vec (nvirtuals
);
1390 TYPE_VTABLE (type
) = vtable
;
1391 if (super
!= NULL_TREE
)
1393 tree super_vtable
= get_dispatch_vector (super
);
1395 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1396 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1399 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1400 method
= TREE_CHAIN (method
))
1402 tree method_index
= get_method_index (method
);
1403 if (method_index
!= NULL_TREE
1404 && host_integerp (method_index
, 0))
1405 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1413 get_dispatch_table (tree type
, tree this_class_addr
)
1415 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1416 tree vtable
= get_dispatch_vector (type
);
1418 tree list
= NULL_TREE
;
1419 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1423 for (i
= nvirtuals
; --i
>= 0; )
1425 tree method
= TREE_VEC_ELT (vtable
, i
);
1426 if (METHOD_ABSTRACT (method
))
1429 warning (0, "%Jabstract method in non-abstract class", method
);
1431 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1432 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1433 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1435 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1439 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1440 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1442 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1443 method
, build_int_cst (NULL_TREE
, j
));
1444 TREE_CONSTANT (fdesc
) = 1;
1445 TREE_INVARIANT (fdesc
) = 1;
1446 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1449 list
= tree_cons (NULL_TREE
,
1450 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1456 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1457 using the Boehm GC we sometimes stash a GC type descriptor
1458 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1459 the emitted byte count during the output to the assembly file. */
1460 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1461 fake "function descriptor". It's first word is the is the class
1462 pointer, and subsequent words (usually one) contain the GC descriptor.
1463 In all other cases, we reserve two extra vtable slots. */
1464 gc_descr
= get_boehm_type_descriptor (type
);
1465 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1466 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1467 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1468 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1470 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1471 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1472 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1473 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1475 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1476 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1477 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1479 return build_constructor (build_prim_array_type (nativecode_ptr_type_node
,
1484 /* Set the method_index for a method decl. */
1486 set_method_index (tree decl
, tree method_index
)
1488 if (method_index
!= NULL_TREE
)
1490 /* method_index is null if we're using indirect dispatch. */
1491 method_index
= fold (convert (sizetype
, method_index
));
1493 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1494 /* Add one to skip bogus descriptor for class and GC descriptor. */
1495 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1497 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1499 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1502 DECL_VINDEX (decl
) = method_index
;
1505 /* Get the method_index for a method decl. */
1507 get_method_index (tree decl
)
1509 tree method_index
= DECL_VINDEX (decl
);
1514 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1515 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1516 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1518 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1519 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1521 return method_index
;
1525 supers_all_compiled (tree type
)
1527 while (type
!= NULL_TREE
)
1529 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1531 type
= CLASSTYPE_SUPER (type
);
1537 make_class_data (tree type
)
1539 tree decl
, cons
, temp
;
1540 tree field
, fields_decl
;
1541 tree static_fields
= NULL_TREE
;
1542 tree instance_fields
= NULL_TREE
;
1543 HOST_WIDE_INT static_field_count
= 0;
1544 HOST_WIDE_INT instance_field_count
= 0;
1545 HOST_WIDE_INT field_count
;
1546 tree field_array_type
;
1548 tree methods
= NULL_TREE
;
1549 tree dtable_decl
= NULL_TREE
;
1550 HOST_WIDE_INT method_count
= 0;
1551 tree method_array_type
;
1554 tree this_class_addr
;
1555 tree constant_pool_constructor
;
1556 tree interfaces
= null_pointer_node
;
1557 int interface_len
= 0;
1558 tree type_decl
= TYPE_NAME (type
);
1559 /** Offset from start of virtual function table declaration
1560 to where objects actually point at, following new g++ ABI. */
1561 tree dtable_start_offset
= build_int_cst (NULL_TREE
,
1562 2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1564 this_class_addr
= build_class_ref (type
);
1565 decl
= TREE_OPERAND (this_class_addr
, 0);
1567 /* Build Field array. */
1568 field
= TYPE_FIELDS (type
);
1569 while (field
&& DECL_ARTIFICIAL (field
))
1570 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1571 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1572 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1573 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1575 if (! DECL_ARTIFICIAL (field
))
1577 tree init
= make_field_value (field
);
1578 if (FIELD_STATIC (field
))
1580 tree initial
= DECL_INITIAL (field
);
1581 static_field_count
++;
1582 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1583 /* If the initial value is a string constant,
1584 prevent output_constant from trying to assemble the value. */
1585 if (initial
!= NULL_TREE
1586 && TREE_TYPE (initial
) == string_ptr_type_node
)
1587 DECL_INITIAL (field
) = NULL_TREE
;
1588 rest_of_decl_compilation (field
, 1, 1);
1589 DECL_INITIAL (field
) = initial
;
1593 instance_field_count
++;
1594 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1598 field_count
= static_field_count
+ instance_field_count
;
1599 if (field_count
> 0)
1601 static_fields
= nreverse (static_fields
);
1602 instance_fields
= nreverse (instance_fields
);
1603 static_fields
= chainon (static_fields
, instance_fields
);
1604 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1605 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1607 DECL_INITIAL (fields_decl
) = build_constructor (field_array_type
,
1609 TREE_STATIC (fields_decl
) = 1;
1610 DECL_ARTIFICIAL (fields_decl
) = 1;
1611 DECL_IGNORED_P (fields_decl
) = 1;
1612 rest_of_decl_compilation (fields_decl
, 1, 0);
1615 fields_decl
= NULL_TREE
;
1617 /* Build Method array. */
1618 for (method
= TYPE_METHODS (type
);
1619 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1622 if (METHOD_PRIVATE (method
)
1623 && ! flag_keep_inline_functions
1626 /* Even if we have a decl, we don't necessarily have the code.
1627 This can happen if we inherit a method from a superclass for
1628 which we don't have a .class file. */
1629 if (METHOD_DUMMY (method
))
1631 init
= make_method_value (method
);
1633 methods
= tree_cons (NULL_TREE
, init
, methods
);
1635 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1636 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1638 DECL_INITIAL (methods_decl
) = build_constructor (method_array_type
,
1639 nreverse (methods
));
1640 TREE_STATIC (methods_decl
) = 1;
1641 DECL_ARTIFICIAL (methods_decl
) = 1;
1642 DECL_IGNORED_P (methods_decl
) = 1;
1643 rest_of_decl_compilation (methods_decl
, 1, 0);
1645 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1646 && !flag_indirect_dispatch
)
1648 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1649 dtable_decl
= build_dtable_decl (type
);
1650 DECL_INITIAL (dtable_decl
) = dtable
;
1651 TREE_STATIC (dtable_decl
) = 1;
1652 DECL_ARTIFICIAL (dtable_decl
) = 1;
1653 DECL_IGNORED_P (dtable_decl
) = 1;
1654 TREE_PUBLIC (dtable_decl
) = 1;
1655 rest_of_decl_compilation (dtable_decl
, 1, 0);
1656 if (type
== class_type_node
)
1657 class_dtable_decl
= dtable_decl
;
1660 if (class_dtable_decl
== NULL_TREE
)
1662 class_dtable_decl
= build_dtable_decl (class_type_node
);
1663 TREE_STATIC (class_dtable_decl
) = 1;
1664 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1665 DECL_IGNORED_P (class_dtable_decl
) = 1;
1666 if (is_compiled_class (class_type_node
) != 2)
1667 DECL_EXTERNAL (class_dtable_decl
) = 1;
1668 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1671 super
= CLASSTYPE_SUPER (type
);
1672 if (super
== NULL_TREE
)
1673 super
= null_pointer_node
;
1674 else if (! flag_indirect_dispatch
1675 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1676 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1677 super
= build_class_ref (super
);
1680 int super_index
= alloc_class_constant (super
);
1681 super
= build_int_cst (ptr_type_node
, super_index
);
1684 /* Build and emit the array of implemented interfaces. */
1685 if (type
!= object_type_node
)
1686 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1688 if (interface_len
> 0)
1690 tree init
= NULL_TREE
;
1692 tree interface_array_type
, idecl
;
1693 interface_array_type
1694 = build_prim_array_type (class_ptr_type
, interface_len
);
1695 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1696 interface_array_type
);
1698 for (i
= interface_len
; i
> 0; i
--)
1700 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1701 tree iclass
= BINFO_TYPE (child
);
1703 if (! flag_indirect_dispatch
1705 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1706 index
= build_class_ref (iclass
);
1709 int int_index
= alloc_class_constant (iclass
);
1710 index
= build_int_cst (ptr_type_node
, int_index
);
1712 init
= tree_cons (NULL_TREE
, index
, init
);
1714 DECL_INITIAL (idecl
) = build_constructor (interface_array_type
, init
);
1715 TREE_STATIC (idecl
) = 1;
1716 DECL_ARTIFICIAL (idecl
) = 1;
1717 DECL_IGNORED_P (idecl
) = 1;
1718 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1719 rest_of_decl_compilation (idecl
, 1, 0);
1722 constant_pool_constructor
= build_constants_constructor ();
1724 if (flag_indirect_dispatch
)
1726 TYPE_OTABLE_DECL (type
)
1728 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
1729 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
1730 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
1732 TYPE_ATABLE_DECL (type
)
1734 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
1735 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
1736 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
1738 TYPE_ITABLE_DECL (type
)
1740 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
1741 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
1742 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
1745 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
1747 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
1748 PUSH_FIELD_VALUE (temp
, "vtable",
1749 build2 (PLUS_EXPR
, dtable_ptr_type
,
1750 build1 (ADDR_EXPR
, dtable_ptr_type
,
1752 dtable_start_offset
));
1753 if (! flag_hash_synchronization
)
1754 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
1755 FINISH_RECORD_CONSTRUCTOR (temp
);
1756 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
1757 PUSH_SUPER_VALUE (cons
, temp
);
1758 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
1759 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
1760 PUSH_FIELD_VALUE (cons
, "accflags",
1761 build_int_cst (NULL_TREE
,
1762 get_access_flags_from_decl (type_decl
)));
1764 PUSH_FIELD_VALUE (cons
, "superclass",
1765 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
1766 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
1767 PUSH_FIELD_VALUE (cons
, "methods",
1768 build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
1769 PUSH_FIELD_VALUE (cons
, "method_count",
1770 build_int_cst (NULL_TREE
, method_count
));
1772 if (flag_indirect_dispatch
)
1773 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
1775 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
1777 PUSH_FIELD_VALUE (cons
, "fields",
1778 fields_decl
== NULL_TREE
? null_pointer_node
1779 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
1780 /* If we're using the binary compatibility ABI we don't know the
1781 size until load time. */
1782 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
1783 (flag_indirect_dispatch
1784 ? integer_minus_one_node
1785 : size_in_bytes (type
)));
1786 PUSH_FIELD_VALUE (cons
, "field_count",
1787 build_int_cst (NULL_TREE
, field_count
));
1788 PUSH_FIELD_VALUE (cons
, "static_field_count",
1789 build_int_cst (NULL_TREE
, static_field_count
));
1791 if (flag_indirect_dispatch
)
1792 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
1794 PUSH_FIELD_VALUE (cons
, "vtable",
1795 dtable_decl
== NULL_TREE
? null_pointer_node
1796 : build2 (PLUS_EXPR
, dtable_ptr_type
,
1797 build1 (ADDR_EXPR
, dtable_ptr_type
,
1799 dtable_start_offset
));
1800 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
1802 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
1803 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
1807 PUSH_FIELD_VALUE (cons
, "otable",
1808 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
1809 PUSH_FIELD_VALUE (cons
, "otable_syms",
1810 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1811 TYPE_OTABLE_SYMS_DECL (type
)));
1812 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
1813 TREE_INVARIANT (TYPE_OTABLE_DECL (type
)) = 1;
1815 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
1817 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
1818 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
1822 PUSH_FIELD_VALUE (cons
, "atable",
1823 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
1824 PUSH_FIELD_VALUE (cons
, "atable_syms",
1825 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1826 TYPE_ATABLE_SYMS_DECL (type
)));
1827 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
1828 TREE_INVARIANT (TYPE_ATABLE_DECL (type
)) = 1;
1830 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
1832 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
1833 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
1837 PUSH_FIELD_VALUE (cons
, "itable",
1838 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
1839 PUSH_FIELD_VALUE (cons
, "itable_syms",
1840 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1841 TYPE_ITABLE_SYMS_DECL (type
)));
1842 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
1843 TREE_INVARIANT (TYPE_ITABLE_DECL (type
)) = 1;
1846 PUSH_FIELD_VALUE (cons
, "catch_classes",
1847 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
1848 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
1849 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
1850 PUSH_FIELD_VALUE (cons
, "interface_count",
1851 build_int_cst (NULL_TREE
, interface_len
));
1854 convert (byte_type_node
,
1855 build_int_cst (NULL_TREE
,
1856 flag_indirect_dispatch
1857 ? JV_STATE_PRELOADING
1858 : JV_STATE_COMPILED
)));
1860 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
1861 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
1862 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
1863 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
1864 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
1865 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
1868 tree assertion_table_ref
;
1869 if (TYPE_ASSERTIONS (type
) == NULL
)
1870 assertion_table_ref
= null_pointer_node
;
1872 assertion_table_ref
= build1 (ADDR_EXPR
,
1873 build_pointer_type (assertion_table_type
),
1874 emit_assertion_table (type
));
1876 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
1879 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
1880 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
1881 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
1882 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
1884 FINISH_RECORD_CONSTRUCTOR (cons
);
1886 DECL_INITIAL (decl
) = cons
;
1888 /* Hash synchronization requires at least 64-bit alignment. */
1889 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
1890 DECL_ALIGN (decl
) = 64;
1892 rest_of_decl_compilation (decl
, 1, 0);
1894 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
1895 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
1896 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
1902 if (TYPE_VERIFY_METHOD (output_class
))
1904 tree verify_method
= TYPE_VERIFY_METHOD (output_class
);
1905 DECL_SAVED_TREE (verify_method
)
1906 = add_stmt_to_compound (DECL_SAVED_TREE (verify_method
), void_type_node
,
1907 build (RETURN_EXPR
, void_type_node
, NULL
));
1908 java_genericize (verify_method
);
1909 cgraph_finalize_function (verify_method
, false);
1910 TYPE_ASSERTIONS (current_class
) = NULL
;
1913 java_expand_catch_classes (current_class
);
1915 current_function_decl
= NULL_TREE
;
1916 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
1917 make_class_data (current_class
);
1919 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
1922 /* Return 2 if CLASS is compiled by this compilation job;
1923 return 1 if CLASS can otherwise be assumed to be compiled;
1924 return 0 if we cannot assume that CLASS is compiled.
1925 Returns 1 for primitive and 0 for array types. */
1927 is_compiled_class (tree
class)
1930 if (TREE_CODE (class) == POINTER_TYPE
)
1931 class = TREE_TYPE (class);
1932 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
1934 if (TYPE_ARRAY_P (class))
1936 if (class == current_class
)
1939 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1940 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip
)
1942 /* The class was seen in the current ZIP file and will be
1943 available as a compiled class in the future but may not have
1944 been loaded already. Load it if necessary. This prevent
1945 build_class_ref () from crashing. */
1947 if (seen_in_zip
&& !CLASS_LOADED_P (class))
1948 load_class (class, 1);
1950 /* We return 2 for class seen in ZIP and class from files
1951 belonging to the same compilation unit */
1955 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1957 if (!CLASS_LOADED_P (class))
1959 if (CLASS_FROM_SOURCE_P (class))
1960 safe_layout_class (class);
1962 load_class (class, 1);
1970 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1973 build_dtable_decl (tree type
)
1977 /* We need to build a new dtable type so that its size is uniquely
1978 computed when we're dealing with the class for real and not just
1979 faking it (like java.lang.Class during the initialization of the
1980 compiler.) We know we're not faking a class when CURRENT_CLASS is
1982 if (current_class
== type
)
1984 tree dummy
= NULL_TREE
;
1987 dtype
= make_node (RECORD_TYPE
);
1989 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
1990 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
1992 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
1993 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
1995 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
1996 TREE_CHAIN (dummy
) = tmp_field
;
1997 DECL_CONTEXT (tmp_field
) = dtype
;
1998 DECL_ARTIFICIAL (tmp_field
) = 1;
2002 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
2003 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2005 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2006 TREE_CHAIN (dummy
) = tmp_field
;
2007 DECL_CONTEXT (tmp_field
) = dtype
;
2008 DECL_ARTIFICIAL (tmp_field
) = 1;
2012 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2013 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2014 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2016 PUSH_FIELD (dtype
, dummy
, "methods",
2017 build_prim_array_type (nativecode_ptr_type_node
, n
));
2018 layout_type (dtype
);
2021 dtype
= dtable_type
;
2023 decl
= build_decl (VAR_DECL
, get_identifier ("vt$"), dtype
);
2024 DECL_CONTEXT (decl
) = type
;
2025 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2026 DECL_VTABLE_P (decl
) = 1;
2031 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2032 fields inherited from SUPER_CLASS. */
2035 push_super_field (tree this_class
, tree super_class
)
2038 /* Don't insert the field if we're just re-laying the class out. */
2039 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2041 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
2042 DECL_IGNORED_P (base_decl
) = 1;
2043 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2044 TYPE_FIELDS (this_class
) = base_decl
;
2045 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2046 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2049 /* Handle the different manners we may have to lay out a super class. */
2052 maybe_layout_super_class (tree super_class
, tree this_class
)
2054 if (TREE_CODE (super_class
) == RECORD_TYPE
)
2056 if (!CLASS_LOADED_P (super_class
) && CLASS_FROM_SOURCE_P (super_class
))
2057 safe_layout_class (super_class
);
2058 if (!CLASS_LOADED_P (super_class
))
2059 load_class (super_class
, 1);
2061 /* We might have to layout the class before its dependency on
2062 the super class gets resolved by java_complete_class */
2063 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2065 if (TREE_TYPE (super_class
) != NULL_TREE
)
2066 super_class
= TREE_TYPE (super_class
);
2069 /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
2071 tree this_wrap
= NULL_TREE
;
2075 tree this_decl
= TYPE_NAME (this_class
);
2076 #ifdef USE_MAPPED_LOCATION
2077 this_wrap
= build_expr_wfl (this_class
,
2078 DECL_SOURCE_LOCATION (this_decl
));
2080 this_wrap
= build_expr_wfl (this_class
,
2081 DECL_SOURCE_FILE (this_decl
),
2082 DECL_SOURCE_LINE (this_decl
), 0);
2085 super_class
= do_resolve_class (NULL_TREE
, this_class
,
2086 super_class
, NULL_TREE
, this_wrap
);
2088 return NULL_TREE
; /* FIXME, NULL_TREE not checked by caller. */
2089 super_class
= TREE_TYPE (super_class
);
2092 if (!TYPE_SIZE (super_class
))
2093 safe_layout_class (super_class
);
2099 layout_class (tree this_class
)
2101 tree super_class
= CLASSTYPE_SUPER (this_class
);
2103 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2104 if (CLASS_BEING_LAIDOUT (this_class
))
2110 sprintf (buffer
, " with '%s'",
2111 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2112 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2114 for (current
= TREE_CHAIN (class_list
); current
;
2115 current
= TREE_CHAIN (current
))
2117 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2118 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2119 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2120 DECL_SOURCE_FILE (decl
),
2121 DECL_SOURCE_LINE (decl
));
2122 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2124 obstack_1grow (&temporary_obstack
, '\0');
2125 report
= obstack_finish (&temporary_obstack
);
2126 cyclic_inheritance_report
= ggc_strdup (report
);
2127 obstack_free (&temporary_obstack
, report
);
2128 TYPE_SIZE (this_class
) = error_mark_node
;
2131 CLASS_BEING_LAIDOUT (this_class
) = 1;
2133 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2135 tree maybe_super_class
2136 = maybe_layout_super_class (super_class
, this_class
);
2137 if (maybe_super_class
== NULL
2138 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2140 TYPE_SIZE (this_class
) = error_mark_node
;
2141 CLASS_BEING_LAIDOUT (this_class
) = 0;
2142 class_list
= TREE_CHAIN (class_list
);
2145 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2146 push_super_field (this_class
, maybe_super_class
);
2149 layout_type (this_class
);
2151 /* Also recursively load/layout any superinterfaces, but only if
2152 class was loaded from bytecode. The source parser will take care
2154 if (!CLASS_FROM_SOURCE_P (this_class
))
2157 if (TYPE_BINFO (this_class
))
2159 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2161 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2162 tree super_interface
= BINFO_TYPE (binfo
);
2163 tree maybe_super_interface
2164 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2165 if (maybe_super_interface
== NULL
2166 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2168 TYPE_SIZE (this_class
) = error_mark_node
;
2169 CLASS_BEING_LAIDOUT (this_class
) = 0;
2170 class_list
= TREE_CHAIN (class_list
);
2177 /* Convert the size back to an SI integer value. */
2178 TYPE_SIZE_UNIT (this_class
) =
2179 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2181 CLASS_BEING_LAIDOUT (this_class
) = 0;
2182 class_list
= TREE_CHAIN (class_list
);
2186 add_miranda_methods (tree base_class
, tree search_class
)
2189 tree binfo
, base_binfo
;
2191 if (!CLASS_PARSED_P (search_class
))
2192 load_class (search_class
, 1);
2194 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2195 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2198 tree elt
= BINFO_TYPE (base_binfo
);
2200 /* FIXME: This is totally bogus. We should not be handling
2201 Miranda methods at all if we're using the BC ABI. */
2202 if (TYPE_DUMMY (elt
))
2205 /* Ensure that interface methods are seen in declared order. */
2206 if (!CLASS_LOADED_P (elt
))
2207 load_class (elt
, 1);
2208 layout_class_methods (elt
);
2210 /* All base classes will have been laid out at this point, so the order
2211 will be correct. This code must match similar layout code in the
2213 for (method_decl
= TYPE_METHODS (elt
);
2214 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2218 /* An interface can have <clinit>. */
2219 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2222 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2223 override
= lookup_argument_method (base_class
,
2224 DECL_NAME (method_decl
), sig
);
2225 if (override
== NULL_TREE
)
2227 /* Found a Miranda method. Add it. */
2229 sig
= build_java_signature (TREE_TYPE (method_decl
));
2231 = add_method (base_class
,
2232 get_access_flags_from_decl (method_decl
),
2233 DECL_NAME (method_decl
), sig
);
2234 METHOD_INVISIBLE (new_method
) = 1;
2238 /* Try superinterfaces. */
2239 add_miranda_methods (base_class
, elt
);
2244 layout_class_methods (tree this_class
)
2246 tree method_decl
, dtable_count
;
2247 tree super_class
, type_name
;
2249 if (TYPE_NVIRTUALS (this_class
))
2252 super_class
= CLASSTYPE_SUPER (this_class
);
2256 super_class
= maybe_layout_super_class (super_class
, this_class
);
2257 if (!TYPE_NVIRTUALS (super_class
))
2258 layout_class_methods (super_class
);
2259 dtable_count
= TYPE_NVIRTUALS (super_class
);
2262 dtable_count
= integer_zero_node
;
2264 type_name
= TYPE_NAME (this_class
);
2265 if (!flag_indirect_dispatch
2266 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2268 /* An abstract class can have methods which are declared only in
2269 an implemented interface. These are called "Miranda
2270 methods". We make a dummy method entry for such methods
2272 add_miranda_methods (this_class
, this_class
);
2275 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2277 for (method_decl
= TYPE_METHODS (this_class
);
2278 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2279 dtable_count
= layout_class_method (this_class
, super_class
,
2280 method_decl
, dtable_count
);
2282 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2285 /* Return the index of METHOD in INTERFACE. This index begins at 1 and is used as an
2286 argument for _Jv_LookupInterfaceMethodIdx(). */
2288 get_interface_method_index (tree method
, tree interface
)
2293 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
), i
++)
2297 if (meth
== NULL_TREE
)
2302 /* Lay METHOD_DECL out, returning a possibly new value of
2303 DTABLE_COUNT. Also mangle the method's name. */
2306 layout_class_method (tree this_class
, tree super_class
,
2307 tree method_decl
, tree dtable_count
)
2309 tree method_name
= DECL_NAME (method_decl
);
2311 TREE_PUBLIC (method_decl
) = 1;
2312 /* Considered external until we know what classes are being
2313 compiled into this object file. */
2314 DECL_EXTERNAL (method_decl
) = 1;
2316 if (ID_INIT_P (method_name
))
2318 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2320 for (ptr
= p
; *ptr
; )
2325 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2326 build_java_argument_signature (TREE_TYPE (method_decl
));
2328 else if (! METHOD_STATIC (method_decl
))
2331 build_java_argument_signature (TREE_TYPE (method_decl
));
2332 bool method_override
= false;
2333 tree super_method
= lookup_argument_method (super_class
, method_name
,
2335 if (super_method
!= NULL_TREE
2336 && ! METHOD_DUMMY (super_method
))
2338 method_override
= true;
2339 if (! METHOD_PUBLIC (super_method
) &&
2340 ! METHOD_PROTECTED (super_method
))
2342 /* Don't override private method, or default-access method in
2344 if (METHOD_PRIVATE (super_method
) ||
2345 ! in_same_package (TYPE_NAME (this_class
),
2346 TYPE_NAME (super_class
)))
2347 method_override
= false;
2350 if (method_override
)
2352 tree method_index
= get_method_index (super_method
);
2353 set_method_index (method_decl
, method_index
);
2354 if (method_index
== NULL_TREE
2355 && ! flag_indirect_dispatch
2356 && !CLASS_FROM_SOURCE_P (this_class
)
2357 && ! DECL_ARTIFICIAL (super_method
))
2358 error ("%Jnon-static method '%D' overrides static method",
2359 method_decl
, method_decl
);
2361 else if (this_class
== object_type_node
2362 && (METHOD_FINAL (method_decl
)
2363 || METHOD_PRIVATE (method_decl
)))
2365 /* We don't generate vtable entries for final Object
2366 methods. This is simply to save space, since every
2367 object would otherwise have to define them. */
2369 else if (! METHOD_PRIVATE (method_decl
)
2372 /* We generate vtable entries for final methods because they
2373 may one day be changed to non-final. */
2374 set_method_index (method_decl
, dtable_count
);
2375 dtable_count
= fold (build2 (PLUS_EXPR
, integer_type_node
,
2376 dtable_count
, integer_one_node
));
2380 return dtable_count
;
2384 register_class (void)
2388 if (!registered_class
)
2389 registered_class
= VEC_alloc (tree
, gc
, 8);
2391 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2392 VEC_safe_push (tree
, gc
, registered_class
, node
);
2395 /* Emit something to register classes at start-up time.
2397 The preferred mechanism is through the .jcr section, which contain
2398 a list of pointers to classes which get registered during constructor
2401 The fallback mechanism is to add statements to *LIST_P to call
2402 _Jv_RegisterClass for each class in this file. These statements will
2403 be added to a static constructor function for this translation unit. */
2406 emit_register_classes (tree
*list_p
)
2408 if (registered_class
== NULL
)
2411 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2412 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2413 but lack suitable crtbegin/end objects or linker support. These
2414 targets can overide the default in tm.h to use the fallback mechanism. */
2415 if (TARGET_USE_JCR_SECTION
)
2420 #ifdef JCR_SECTION_NAME
2421 named_section_flags (JCR_SECTION_NAME
, SECTION_WRITE
);
2423 /* A target has defined TARGET_USE_JCR_SECTION,
2424 but doesn't have a JCR_SECTION_NAME. */
2427 assemble_align (POINTER_SIZE
);
2429 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2431 t
= build_fold_addr_expr (klass
);
2432 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2437 tree klass
, t
, register_class_fn
;
2440 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2441 t
= build_decl (FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2442 TREE_PUBLIC (t
) = 1;
2443 DECL_EXTERNAL (t
) = 1;
2444 register_class_fn
= t
;
2446 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2448 t
= build_fold_addr_expr (klass
);
2449 t
= tree_cons (NULL
, t
, NULL
);
2450 t
= build_function_call_expr (register_class_fn
, t
);
2451 append_to_statement_list (t
, list_p
);
2456 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2459 build_symbol_entry (tree decl
)
2461 tree clname
, name
, signature
, sym
;
2462 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2463 /* ??? Constructors are given the name foo.foo all the way through
2464 the compiler, but in the method table they're all renamed
2465 foo.<init>. So, we have to do the same here unless we want an
2466 unresolved reference at runtime. */
2467 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2468 && DECL_CONSTRUCTOR_P (decl
))
2469 ? init_identifier_node
2470 : DECL_NAME (decl
));
2471 signature
= build_java_signature (TREE_TYPE (decl
));
2472 signature
= build_utf8_ref (unmangle_classname
2473 (IDENTIFIER_POINTER (signature
),
2474 IDENTIFIER_LENGTH (signature
)));
2476 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2477 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2478 PUSH_FIELD_VALUE (sym
, "name", name
);
2479 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2480 FINISH_RECORD_CONSTRUCTOR (sym
);
2481 TREE_CONSTANT (sym
) = 1;
2482 TREE_INVARIANT (sym
) = 1;
2487 /* Emit a symbol table: used by -findirect-dispatch. */
2490 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2491 tree the_syms_decl
, tree the_array_element_type
,
2494 tree method_list
, method
, table
, list
, null_symbol
;
2495 tree table_size
, the_array_type
;
2498 /* Only emit a table if this translation unit actually made any
2499 references via it. */
2500 if (decl_list
== NULL_TREE
)
2503 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2505 method_list
= decl_list
;
2507 while (method_list
!= NULL_TREE
)
2509 method
= TREE_VALUE (method_list
);
2510 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
), list
);
2511 method_list
= TREE_CHAIN (method_list
);
2515 /* Terminate the list with a "null" entry. */
2516 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2517 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2518 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2519 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2520 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2521 TREE_CONSTANT (null_symbol
) = 1;
2522 TREE_INVARIANT (null_symbol
) = 1;
2523 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2525 /* Put the list in the right order and make it a constructor. */
2526 list
= nreverse (list
);
2527 table
= build_constructor (symbols_array_type
, list
);
2529 /* Make it the initial value for otable_syms and emit the decl. */
2530 DECL_INITIAL (the_syms_decl
) = table
;
2531 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2532 DECL_IGNORED_P (the_syms_decl
) = 1;
2533 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2535 /* Now that its size is known, redefine the table as an
2536 uninitialized static array of INDEX + 1 elements. The extra entry
2537 is used by the runtime to track whether the table has been
2540 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2541 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2542 the_table
= build_decl (VAR_DECL
, name
, the_array_type
);
2543 TREE_STATIC (the_table
) = 1;
2544 TREE_READONLY (the_table
) = 1;
2545 rest_of_decl_compilation (the_table
, 1, 0);
2550 /* Make an entry for the catch_classes list. */
2552 make_catch_class_record (tree catch_class
, tree classname
)
2555 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2556 START_RECORD_CONSTRUCTOR (entry
, type
);
2557 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2558 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2559 FINISH_RECORD_CONSTRUCTOR (entry
);
2564 /* Generate the list of Throwable classes that are caught by exception
2565 handlers in this class. */
2567 emit_catch_table (tree this_class
)
2569 tree table
, table_size
, array_type
;
2570 TYPE_CATCH_CLASSES (this_class
) =
2572 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2573 TYPE_CATCH_CLASSES (this_class
));
2574 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2575 TYPE_CATCH_CLASSES (this_class
) =
2577 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2578 TYPE_CATCH_CLASSES (this_class
));
2579 table_size
= build_index_type
2580 (build_int_cst (NULL_TREE
,
2581 list_length (TYPE_CATCH_CLASSES (this_class
))));
2583 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2586 build_decl (VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2587 DECL_INITIAL (table
) =
2588 build_constructor (array_type
, TYPE_CATCH_CLASSES (this_class
));
2589 TREE_STATIC (table
) = 1;
2590 TREE_READONLY (table
) = 1;
2591 DECL_IGNORED_P (table
) = 1;
2592 rest_of_decl_compilation (table
, 1, 0);
2596 /* Given a type, return the signature used by
2597 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2598 same as build_java_signature() because we want the canonical array
2602 build_signature_for_libgcj (tree type
)
2606 sig
= build_java_signature (type
);
2607 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
2608 IDENTIFIER_LENGTH (sig
)));
2612 /* Add an entry to the type assertion table. Callback used during hashtable
2616 add_assertion_table_entry (void **htab_entry
, void *ptr
)
2619 tree code_val
, op1_utf8
, op2_utf8
;
2620 tree
*list
= (tree
*) ptr
;
2621 type_assertion
*as
= (type_assertion
*) *htab_entry
;
2623 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
2625 if (as
->op1
== NULL_TREE
)
2626 op1_utf8
= null_pointer_node
;
2628 op1_utf8
= build_signature_for_libgcj (as
->op1
);
2630 if (as
->op2
== NULL_TREE
)
2631 op2_utf8
= null_pointer_node
;
2633 op2_utf8
= build_signature_for_libgcj (as
->op2
);
2635 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
2636 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
2637 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
2638 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
2639 FINISH_RECORD_CONSTRUCTOR (entry
);
2641 *list
= tree_cons (NULL_TREE
, entry
, *list
);
2645 /* Generate the type assertion table for CLASS, and return its DECL. */
2648 emit_assertion_table (tree
class)
2650 tree null_entry
, ctor
, table_decl
;
2651 tree list
= NULL_TREE
;
2652 htab_t assertions_htab
= TYPE_ASSERTIONS (class);
2654 /* Iterate through the hash table. */
2655 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
2657 /* Finish with a null entry. */
2658 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
2659 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
2660 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
2661 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
2662 FINISH_RECORD_CONSTRUCTOR (null_entry
);
2664 list
= tree_cons (NULL_TREE
, null_entry
, list
);
2666 /* Put the list in the right order and make it a constructor. */
2667 list
= nreverse (list
);
2668 ctor
= build_constructor (assertion_table_type
, list
);
2670 table_decl
= build_decl (VAR_DECL
, mangled_classname ("_type_assert_", class),
2671 assertion_table_type
);
2673 TREE_STATIC (table_decl
) = 1;
2674 TREE_READONLY (table_decl
) = 1;
2675 TREE_CONSTANT (table_decl
) = 1;
2676 DECL_IGNORED_P (table_decl
) = 1;
2678 DECL_INITIAL (table_decl
) = ctor
;
2679 DECL_ARTIFICIAL (table_decl
) = 1;
2680 rest_of_decl_compilation (table_decl
, 1, 0);
2686 init_class_processing (void)
2688 fields_ident
= get_identifier ("fields");
2689 info_ident
= get_identifier ("info");
2691 gcc_obstack_init (&temporary_obstack
);
2694 static hashval_t
java_treetreehash_hash (const void *);
2695 static int java_treetreehash_compare (const void *, const void *);
2697 /* A hash table mapping trees to trees. Used generally. */
2699 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2702 java_treetreehash_hash (const void *k_p
)
2704 struct treetreehash_entry
*k
= (struct treetreehash_entry
*) k_p
;
2705 return JAVA_TREEHASHHASH_H (k
->key
);
2709 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
2711 struct treetreehash_entry
* k1
= (struct treetreehash_entry
*) k1_p
;
2712 tree k2
= (tree
) k2_p
;
2713 return (k1
->key
== k2
);
2717 java_treetreehash_find (htab_t ht
, tree t
)
2719 struct treetreehash_entry
*e
;
2720 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2721 e
= htab_find_with_hash (ht
, t
, hv
);
2729 java_treetreehash_new (htab_t ht
, tree t
)
2732 struct treetreehash_entry
*tthe
;
2733 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2735 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
2738 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
2743 tthe
= (struct treetreehash_entry
*) *e
;
2744 return &tthe
->value
;
2748 java_treetreehash_create (size_t size
, int gc
)
2751 return htab_create_ggc (size
, java_treetreehash_hash
,
2752 java_treetreehash_compare
, NULL
);
2754 return htab_create_alloc (size
, java_treetreehash_hash
,
2755 java_treetreehash_compare
, free
, xcalloc
, free
);
2758 /* Break down qualified IDENTIFIER into package and class-name components.
2759 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
2760 "pkg.foo", and RIGHT to "Bar". */
2763 split_qualified_name (tree
*left
, tree
*right
, tree source
)
2766 int l
= IDENTIFIER_LENGTH (source
);
2768 base
= alloca (l
+ 1);
2769 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
2771 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
2773 while (*p
!= '.' && p
!= base
)
2776 /* We didn't find a '.'. Return an error. */
2782 *right
= get_identifier (p
+1);
2783 *left
= get_identifier (base
);
2788 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
2789 if the classes are from the same package. */
2792 in_same_package (tree name1
, tree name2
)
2798 if (TREE_CODE (name1
) == TYPE_DECL
)
2799 name1
= DECL_NAME (name1
);
2800 if (TREE_CODE (name2
) == TYPE_DECL
)
2801 name2
= DECL_NAME (name2
);
2803 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
2804 /* One in empty package. */
2807 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
2808 /* Both in empty package. */
2811 split_qualified_name (&pkg1
, &tmp
, name1
);
2812 split_qualified_name (&pkg2
, &tmp
, name2
);
2814 return (pkg1
== pkg2
);
2817 #include "gt-java-class.h"