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 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
920 IDENTIFIER_UTF8_REF (name
) = ref
;
924 /* Like build_class_ref, but instead of a direct reference generate a
925 pointer into the constant pool. */
928 build_indirect_class_ref (tree type
)
932 index
= alloc_class_constant (type
);
933 cl
= build_ref_from_constant_pool (index
);
934 return convert (promote_type (class_ptr_type
), cl
);
937 /* Build a reference to the class TYPE.
938 Also handles primitive types and array types. */
941 build_class_ref (tree type
)
943 int is_compiled
= is_compiled_class (type
);
946 tree ref
, decl_name
, decl
;
947 if (TREE_CODE (type
) == POINTER_TYPE
)
948 type
= TREE_TYPE (type
);
950 if (flag_indirect_dispatch
951 && type
!= output_class
952 && TREE_CODE (type
) == RECORD_TYPE
)
953 return build_indirect_class_ref (type
);
955 if (TREE_CODE (type
) == RECORD_TYPE
)
957 if (TYPE_SIZE (type
) == error_mark_node
)
958 return null_pointer_node
;
959 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
960 "", '/', '/', ".class");
961 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
962 if (decl
== NULL_TREE
)
964 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
965 TREE_STATIC (decl
) = 1;
966 TREE_PUBLIC (decl
) = 1;
967 DECL_IGNORED_P (decl
) = 1;
968 DECL_ARTIFICIAL (decl
) = 1;
969 if (is_compiled
== 1)
970 DECL_EXTERNAL (decl
) = 1;
971 SET_DECL_ASSEMBLER_NAME (decl
,
972 java_mangle_class_field
973 (&temporary_obstack
, type
));
974 pushdecl_top_level (decl
);
981 if (flag_emit_class_files
)
983 const char *prim_class_name
;
985 if (type
== char_type_node
)
986 prim_class_name
= "java.lang.Character";
987 else if (type
== boolean_type_node
)
988 prim_class_name
= "java.lang.Boolean";
989 else if (type
== byte_type_node
)
990 prim_class_name
= "java.lang.Byte";
991 else if (type
== short_type_node
)
992 prim_class_name
= "java.lang.Short";
993 else if (type
== int_type_node
)
994 prim_class_name
= "java.lang.Integer";
995 else if (type
== long_type_node
)
996 prim_class_name
= "java.lang.Long";
997 else if (type
== float_type_node
)
998 prim_class_name
= "java.lang.Float";
999 else if (type
== double_type_node
)
1000 prim_class_name
= "java.lang.Double";
1001 else if (type
== void_type_node
)
1002 prim_class_name
= "java.lang.Void";
1006 prim_class
= lookup_class (get_identifier (prim_class_name
));
1007 return build3 (COMPONENT_REF
, NULL_TREE
,
1008 prim_class
, TYPE_identifier_node
, NULL_TREE
);
1010 decl_name
= TYPE_NAME (type
);
1011 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1012 decl_name
= DECL_NAME (decl_name
);
1013 name
= IDENTIFIER_POINTER (decl_name
);
1014 if (strncmp (name
, "promoted_", 9) == 0)
1016 sprintf (buffer
, "_Jv_%sClass", name
);
1017 decl_name
= get_identifier (buffer
);
1018 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1019 if (decl
== NULL_TREE
)
1021 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1022 TREE_STATIC (decl
) = 1;
1023 TREE_PUBLIC (decl
) = 1;
1024 DECL_EXTERNAL (decl
) = 1;
1025 DECL_ARTIFICIAL (decl
) = 1;
1026 pushdecl_top_level (decl
);
1030 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1034 return build_indirect_class_ref (type
);
1037 /* Create a local statically allocated variable that will hold a
1038 pointer to a static field. */
1041 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1043 tree decl
, decl_name
;
1044 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1045 char *buf
= alloca (strlen (name
) + 20);
1046 sprintf (buf
, "%s_%d_ref", name
, index
);
1047 decl_name
= get_identifier (buf
);
1048 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1049 if (decl
== NULL_TREE
)
1051 decl
= build_decl (VAR_DECL
, decl_name
, ptr_type_node
);
1052 TREE_STATIC (decl
) = 1;
1053 TREE_PUBLIC (decl
) = 0;
1054 DECL_EXTERNAL (decl
) = 0;
1055 DECL_ARTIFICIAL (decl
) = 1;
1056 pushdecl_top_level (decl
);
1062 build_static_field_ref (tree fdecl
)
1064 tree fclass
= DECL_CONTEXT (fdecl
);
1065 int is_compiled
= is_compiled_class (fclass
);
1067 /* Allow static final fields to fold to a constant. When using
1068 -fno-assume-compiled, gcj will sometimes try to fold a field from
1069 an uncompiled class. This is required when the field in question
1070 meets the appropriate criteria for a compile-time constant.
1071 However, currently sometimes gcj is too eager and will end up
1072 returning the field itself, leading to an incorrect external
1073 reference being generated. */
1074 if ((is_compiled
&& !flag_indirect_dispatch
)
1075 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1076 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1077 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1078 && TREE_CONSTANT (DECL_INITIAL (fdecl
))))
1080 if (is_compiled
== 1)
1081 DECL_EXTERNAL (fdecl
) = 1;
1085 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1086 and a class local static variable CACHE_ENTRY, then
1088 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1089 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1092 This can mostly be optimized away, so that the usual path is a
1093 load followed by a test and branch. _Jv_ResolvePoolEntry is
1094 only called once for each constant pool entry.
1096 There is an optimization that we don't do: at the start of a
1097 method, create a local copy of CACHE_ENTRY and use that instead.
1101 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1102 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1104 = build3 (CALL_EXPR
, boolean_type_node
,
1105 build_address_of (built_in_decls
[BUILT_IN_EXPECT
]),
1106 tree_cons (NULL_TREE
, build2 (EQ_EXPR
, boolean_type_node
,
1107 cache_entry
, null_pointer_node
),
1108 build_tree_list (NULL_TREE
, boolean_false_node
)),
1110 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1112 = build3 (CALL_EXPR
, ptr_type_node
,
1113 build_address_of (soft_resolvepoolentry_node
),
1114 tree_cons (NULL_TREE
, build_class_ref (output_class
),
1115 build_tree_list (NULL_TREE
, cpool_index_cst
)),
1117 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1118 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1119 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1120 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1126 get_access_flags_from_decl (tree decl
)
1128 int access_flags
= 0;
1129 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1131 if (FIELD_STATIC (decl
))
1132 access_flags
|= ACC_STATIC
;
1133 if (FIELD_PUBLIC (decl
))
1134 access_flags
|= ACC_PUBLIC
;
1135 if (FIELD_PROTECTED (decl
))
1136 access_flags
|= ACC_PROTECTED
;
1137 if (FIELD_PRIVATE (decl
))
1138 access_flags
|= ACC_PRIVATE
;
1139 if (FIELD_FINAL (decl
))
1140 access_flags
|= ACC_FINAL
;
1141 if (FIELD_VOLATILE (decl
))
1142 access_flags
|= ACC_VOLATILE
;
1143 if (FIELD_TRANSIENT (decl
))
1144 access_flags
|= ACC_TRANSIENT
;
1145 return access_flags
;
1147 if (TREE_CODE (decl
) == TYPE_DECL
)
1149 if (CLASS_PUBLIC (decl
))
1150 access_flags
|= ACC_PUBLIC
;
1151 if (CLASS_FINAL (decl
))
1152 access_flags
|= ACC_FINAL
;
1153 if (CLASS_SUPER (decl
))
1154 access_flags
|= ACC_SUPER
;
1155 if (CLASS_INTERFACE (decl
))
1156 access_flags
|= ACC_INTERFACE
;
1157 if (CLASS_ABSTRACT (decl
))
1158 access_flags
|= ACC_ABSTRACT
;
1159 if (CLASS_STATIC (decl
))
1160 access_flags
|= ACC_STATIC
;
1161 if (CLASS_PRIVATE (decl
))
1162 access_flags
|= ACC_PRIVATE
;
1163 if (CLASS_PROTECTED (decl
))
1164 access_flags
|= ACC_PROTECTED
;
1165 if (CLASS_STRICTFP (decl
))
1166 access_flags
|= ACC_STRICT
;
1167 return access_flags
;
1169 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1171 if (METHOD_PUBLIC (decl
))
1172 access_flags
|= ACC_PUBLIC
;
1173 if (METHOD_PRIVATE (decl
))
1174 access_flags
|= ACC_PRIVATE
;
1175 if (METHOD_PROTECTED (decl
))
1176 access_flags
|= ACC_PROTECTED
;
1177 if (METHOD_STATIC (decl
))
1178 access_flags
|= ACC_STATIC
;
1179 if (METHOD_FINAL (decl
))
1180 access_flags
|= ACC_FINAL
;
1181 if (METHOD_SYNCHRONIZED (decl
))
1182 access_flags
|= ACC_SYNCHRONIZED
;
1183 if (METHOD_NATIVE (decl
))
1184 access_flags
|= ACC_NATIVE
;
1185 if (METHOD_ABSTRACT (decl
))
1186 access_flags
|= ACC_ABSTRACT
;
1187 if (METHOD_STRICTFP (decl
))
1188 access_flags
|= ACC_STRICT
;
1189 if (METHOD_INVISIBLE (decl
))
1190 access_flags
|= ACC_INVISIBLE
;
1191 return access_flags
;
1196 static GTY (()) int alias_labelno
= 0;
1198 /* Create a private alias for METHOD. Using this alias instead of the method
1199 decl ensures that ncode entries in the method table point to the real function
1200 at runtime, not a PLT entry. */
1203 make_local_function_alias (tree method
)
1205 #ifdef ASM_OUTPUT_DEF
1208 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1209 char *name
= alloca (strlen (method_name
) + 2);
1210 char *buf
= alloca (strlen (method_name
) + 128);
1212 /* Only create aliases for local functions. */
1213 if (DECL_EXTERNAL (method
))
1216 /* Prefix method_name with 'L' for the alias label. */
1218 strcpy (name
+ 1, method_name
);
1220 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1221 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
1222 TREE_TYPE (method
));
1223 DECL_CONTEXT (alias
) = NULL
;
1224 TREE_READONLY (alias
) = TREE_READONLY (method
);
1225 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1226 TREE_PUBLIC (alias
) = 0;
1227 DECL_EXTERNAL (alias
) = 0;
1228 DECL_ARTIFICIAL (alias
) = 1;
1229 DECL_INLINE (alias
) = 0;
1230 DECL_INITIAL (alias
) = error_mark_node
;
1231 TREE_ADDRESSABLE (alias
) = 1;
1232 TREE_USED (alias
) = 1;
1233 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1234 if (!flag_syntax_only
)
1235 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1242 /** Make reflection data (_Jv_Field) for field FDECL. */
1245 make_field_value (tree fdecl
)
1249 tree type
= TREE_TYPE (fdecl
);
1250 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1252 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1253 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1255 type
= build_class_ref (type
);
1258 tree signature
= build_java_signature (type
);
1260 type
= build_utf8_ref (unmangle_classname
1261 (IDENTIFIER_POINTER (signature
),
1262 IDENTIFIER_LENGTH (signature
)));
1264 PUSH_FIELD_VALUE (finit
, "type", type
);
1266 flags
= get_access_flags_from_decl (fdecl
);
1268 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1270 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1271 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1275 build_constructor (field_info_union_node
,
1277 ((FIELD_STATIC (fdecl
)
1278 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1279 : TYPE_FIELDS (field_info_union_node
)),
1280 (FIELD_STATIC (fdecl
)
1281 ? build_address_of (fdecl
)
1282 : byte_position (fdecl
)))));
1284 FINISH_RECORD_CONSTRUCTOR (finit
);
1288 /** Make reflection data (_Jv_Method) for method MDECL. */
1291 make_method_value (tree mdecl
)
1293 static int method_name_count
= 0;
1298 #define ACC_TRANSLATED 0x4000
1299 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1301 class_decl
= DECL_CONTEXT (mdecl
);
1302 /* For interfaces, the index field contains the dispatch index. */
1303 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1304 index
= build_int_cst (NULL_TREE
,
1305 get_interface_method_index (mdecl
, class_decl
));
1306 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1307 index
= get_method_index (mdecl
);
1309 index
= integer_minus_one_node
;
1311 code
= null_pointer_node
;
1312 if (!METHOD_ABSTRACT (mdecl
))
1313 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1314 make_local_function_alias (mdecl
));
1315 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1316 PUSH_FIELD_VALUE (minit
, "name",
1317 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1318 init_identifier_node
1319 : DECL_NAME (mdecl
)));
1321 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1322 PUSH_FIELD_VALUE (minit
, "signature",
1325 (IDENTIFIER_POINTER(signature
),
1326 IDENTIFIER_LENGTH(signature
)))));
1328 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1329 PUSH_FIELD_VALUE (minit
, "index", index
);
1330 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1333 /* Compute the `throws' information for the method. */
1334 tree table
= null_pointer_node
;
1335 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1337 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1338 tree iter
, type
, array
;
1341 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1342 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1344 iter
= TREE_CHAIN (iter
))
1346 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1348 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1349 IDENTIFIER_LENGTH (sig
)));
1350 table
= tree_cons (NULL_TREE
, utf8
, table
);
1352 type
= build_prim_array_type (ptr_type_node
, length
);
1353 table
= build_constructor (type
, table
);
1354 /* Compute something unique enough. */
1355 sprintf (buf
, "_methods%d", method_name_count
++);
1356 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1357 DECL_INITIAL (array
) = table
;
1358 TREE_STATIC (array
) = 1;
1359 DECL_ARTIFICIAL (array
) = 1;
1360 DECL_IGNORED_P (array
) = 1;
1361 rest_of_decl_compilation (array
, 1, 0);
1363 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1366 PUSH_FIELD_VALUE (minit
, "throws", table
);
1369 FINISH_RECORD_CONSTRUCTOR (minit
);
1374 get_dispatch_vector (tree type
)
1376 tree vtable
= TYPE_VTABLE (type
);
1378 if (vtable
== NULL_TREE
)
1382 tree super
= CLASSTYPE_SUPER (type
);
1383 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1384 vtable
= make_tree_vec (nvirtuals
);
1385 TYPE_VTABLE (type
) = vtable
;
1386 if (super
!= NULL_TREE
)
1388 tree super_vtable
= get_dispatch_vector (super
);
1390 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1391 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1394 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1395 method
= TREE_CHAIN (method
))
1397 tree method_index
= get_method_index (method
);
1398 if (method_index
!= NULL_TREE
1399 && host_integerp (method_index
, 0))
1400 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1408 get_dispatch_table (tree type
, tree this_class_addr
)
1410 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1411 tree vtable
= get_dispatch_vector (type
);
1413 tree list
= NULL_TREE
;
1414 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1418 for (i
= nvirtuals
; --i
>= 0; )
1420 tree method
= TREE_VEC_ELT (vtable
, i
);
1421 if (METHOD_ABSTRACT (method
))
1424 warning (0, "%Jabstract method in non-abstract class", method
);
1426 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1427 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1428 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1430 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1434 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1435 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1437 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1438 method
, build_int_cst (NULL_TREE
, j
));
1439 TREE_CONSTANT (fdesc
) = 1;
1440 TREE_INVARIANT (fdesc
) = 1;
1441 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1444 list
= tree_cons (NULL_TREE
,
1445 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1451 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1452 using the Boehm GC we sometimes stash a GC type descriptor
1453 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1454 the emitted byte count during the output to the assembly file. */
1455 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1456 fake "function descriptor". It's first word is the is the class
1457 pointer, and subsequent words (usually one) contain the GC descriptor.
1458 In all other cases, we reserve two extra vtable slots. */
1459 gc_descr
= get_boehm_type_descriptor (type
);
1460 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1461 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1462 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1463 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1465 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1466 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1467 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1468 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1470 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1471 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1472 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1474 return build_constructor (build_prim_array_type (nativecode_ptr_type_node
,
1479 /* Set the method_index for a method decl. */
1481 set_method_index (tree decl
, tree method_index
)
1483 if (method_index
!= NULL_TREE
)
1485 /* method_index is null if we're using indirect dispatch. */
1486 method_index
= fold (convert (sizetype
, method_index
));
1488 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1489 /* Add one to skip bogus descriptor for class and GC descriptor. */
1490 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1492 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1494 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1497 DECL_VINDEX (decl
) = method_index
;
1500 /* Get the method_index for a method decl. */
1502 get_method_index (tree decl
)
1504 tree method_index
= DECL_VINDEX (decl
);
1509 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1510 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1511 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1513 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1514 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1516 return method_index
;
1520 supers_all_compiled (tree type
)
1522 while (type
!= NULL_TREE
)
1524 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1526 type
= CLASSTYPE_SUPER (type
);
1532 make_class_data (tree type
)
1534 tree decl
, cons
, temp
;
1535 tree field
, fields_decl
;
1536 tree static_fields
= NULL_TREE
;
1537 tree instance_fields
= NULL_TREE
;
1538 HOST_WIDE_INT static_field_count
= 0;
1539 HOST_WIDE_INT instance_field_count
= 0;
1540 HOST_WIDE_INT field_count
;
1541 tree field_array_type
;
1543 tree methods
= NULL_TREE
;
1544 tree dtable_decl
= NULL_TREE
;
1545 HOST_WIDE_INT method_count
= 0;
1546 tree method_array_type
;
1549 tree this_class_addr
;
1550 tree constant_pool_constructor
;
1551 tree interfaces
= null_pointer_node
;
1552 int interface_len
= 0;
1553 tree type_decl
= TYPE_NAME (type
);
1554 /** Offset from start of virtual function table declaration
1555 to where objects actually point at, following new g++ ABI. */
1556 tree dtable_start_offset
= build_int_cst (NULL_TREE
,
1557 2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1559 this_class_addr
= build_class_ref (type
);
1560 decl
= TREE_OPERAND (this_class_addr
, 0);
1562 /* Build Field array. */
1563 field
= TYPE_FIELDS (type
);
1564 while (field
&& DECL_ARTIFICIAL (field
))
1565 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1566 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1567 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1568 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1570 if (! DECL_ARTIFICIAL (field
))
1572 tree init
= make_field_value (field
);
1573 if (FIELD_STATIC (field
))
1575 tree initial
= DECL_INITIAL (field
);
1576 static_field_count
++;
1577 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1578 /* If the initial value is a string constant,
1579 prevent output_constant from trying to assemble the value. */
1580 if (initial
!= NULL_TREE
1581 && TREE_TYPE (initial
) == string_ptr_type_node
)
1582 DECL_INITIAL (field
) = NULL_TREE
;
1583 rest_of_decl_compilation (field
, 1, 1);
1584 DECL_INITIAL (field
) = initial
;
1588 instance_field_count
++;
1589 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1593 field_count
= static_field_count
+ instance_field_count
;
1594 if (field_count
> 0)
1596 static_fields
= nreverse (static_fields
);
1597 instance_fields
= nreverse (instance_fields
);
1598 static_fields
= chainon (static_fields
, instance_fields
);
1599 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1600 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1602 DECL_INITIAL (fields_decl
) = build_constructor (field_array_type
,
1604 TREE_STATIC (fields_decl
) = 1;
1605 DECL_ARTIFICIAL (fields_decl
) = 1;
1606 DECL_IGNORED_P (fields_decl
) = 1;
1607 rest_of_decl_compilation (fields_decl
, 1, 0);
1610 fields_decl
= NULL_TREE
;
1612 /* Build Method array. */
1613 for (method
= TYPE_METHODS (type
);
1614 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1617 if (METHOD_PRIVATE (method
)
1618 && ! flag_keep_inline_functions
1621 /* Even if we have a decl, we don't necessarily have the code.
1622 This can happen if we inherit a method from a superclass for
1623 which we don't have a .class file. */
1624 if (METHOD_DUMMY (method
))
1626 init
= make_method_value (method
);
1628 methods
= tree_cons (NULL_TREE
, init
, methods
);
1630 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1631 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1633 DECL_INITIAL (methods_decl
) = build_constructor (method_array_type
,
1634 nreverse (methods
));
1635 TREE_STATIC (methods_decl
) = 1;
1636 DECL_ARTIFICIAL (methods_decl
) = 1;
1637 DECL_IGNORED_P (methods_decl
) = 1;
1638 rest_of_decl_compilation (methods_decl
, 1, 0);
1640 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1641 && !flag_indirect_dispatch
)
1643 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1644 dtable_decl
= build_dtable_decl (type
);
1645 DECL_INITIAL (dtable_decl
) = dtable
;
1646 TREE_STATIC (dtable_decl
) = 1;
1647 DECL_ARTIFICIAL (dtable_decl
) = 1;
1648 DECL_IGNORED_P (dtable_decl
) = 1;
1649 TREE_PUBLIC (dtable_decl
) = 1;
1650 rest_of_decl_compilation (dtable_decl
, 1, 0);
1651 if (type
== class_type_node
)
1652 class_dtable_decl
= dtable_decl
;
1655 if (class_dtable_decl
== NULL_TREE
)
1657 class_dtable_decl
= build_dtable_decl (class_type_node
);
1658 TREE_STATIC (class_dtable_decl
) = 1;
1659 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1660 DECL_IGNORED_P (class_dtable_decl
) = 1;
1661 if (is_compiled_class (class_type_node
) != 2)
1662 DECL_EXTERNAL (class_dtable_decl
) = 1;
1663 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1666 super
= CLASSTYPE_SUPER (type
);
1667 if (super
== NULL_TREE
)
1668 super
= null_pointer_node
;
1669 else if (! flag_indirect_dispatch
1670 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1671 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1672 super
= build_class_ref (super
);
1675 int super_index
= alloc_class_constant (super
);
1676 super
= build_int_cst (ptr_type_node
, super_index
);
1679 /* Build and emit the array of implemented interfaces. */
1680 if (type
!= object_type_node
)
1681 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1683 if (interface_len
> 0)
1685 tree init
= NULL_TREE
;
1687 tree interface_array_type
, idecl
;
1688 interface_array_type
1689 = build_prim_array_type (class_ptr_type
, interface_len
);
1690 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1691 interface_array_type
);
1693 for (i
= interface_len
; i
> 0; i
--)
1695 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1696 tree iclass
= BINFO_TYPE (child
);
1698 if (! flag_indirect_dispatch
1700 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1701 index
= build_class_ref (iclass
);
1704 int int_index
= alloc_class_constant (iclass
);
1705 index
= build_int_cst (ptr_type_node
, int_index
);
1707 init
= tree_cons (NULL_TREE
, index
, init
);
1709 DECL_INITIAL (idecl
) = build_constructor (interface_array_type
, init
);
1710 TREE_STATIC (idecl
) = 1;
1711 DECL_ARTIFICIAL (idecl
) = 1;
1712 DECL_IGNORED_P (idecl
) = 1;
1713 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1714 rest_of_decl_compilation (idecl
, 1, 0);
1717 constant_pool_constructor
= build_constants_constructor ();
1719 if (flag_indirect_dispatch
)
1721 TYPE_OTABLE_DECL (type
)
1723 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
1724 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
1725 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
1727 TYPE_ATABLE_DECL (type
)
1729 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
1730 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
1731 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
1733 TYPE_ITABLE_DECL (type
)
1735 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
1736 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
1737 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
1740 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
1742 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
1743 PUSH_FIELD_VALUE (temp
, "vtable",
1744 build2 (PLUS_EXPR
, dtable_ptr_type
,
1745 build1 (ADDR_EXPR
, dtable_ptr_type
,
1747 dtable_start_offset
));
1748 if (! flag_hash_synchronization
)
1749 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
1750 FINISH_RECORD_CONSTRUCTOR (temp
);
1751 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
1752 PUSH_SUPER_VALUE (cons
, temp
);
1753 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
1754 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
1755 PUSH_FIELD_VALUE (cons
, "accflags",
1756 build_int_cst (NULL_TREE
,
1757 get_access_flags_from_decl (type_decl
)));
1759 PUSH_FIELD_VALUE (cons
, "superclass",
1760 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
1761 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
1762 PUSH_FIELD_VALUE (cons
, "methods",
1763 build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
1764 PUSH_FIELD_VALUE (cons
, "method_count",
1765 build_int_cst (NULL_TREE
, method_count
));
1767 if (flag_indirect_dispatch
)
1768 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
1770 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
1772 PUSH_FIELD_VALUE (cons
, "fields",
1773 fields_decl
== NULL_TREE
? null_pointer_node
1774 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
1775 /* If we're using the binary compatibility ABI we don't know the
1776 size until load time. */
1777 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
1778 (flag_indirect_dispatch
1779 ? integer_minus_one_node
1780 : size_in_bytes (type
)));
1781 PUSH_FIELD_VALUE (cons
, "field_count",
1782 build_int_cst (NULL_TREE
, field_count
));
1783 PUSH_FIELD_VALUE (cons
, "static_field_count",
1784 build_int_cst (NULL_TREE
, static_field_count
));
1786 if (flag_indirect_dispatch
)
1787 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
1789 PUSH_FIELD_VALUE (cons
, "vtable",
1790 dtable_decl
== NULL_TREE
? null_pointer_node
1791 : build2 (PLUS_EXPR
, dtable_ptr_type
,
1792 build1 (ADDR_EXPR
, dtable_ptr_type
,
1794 dtable_start_offset
));
1795 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
1797 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
1798 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
1802 PUSH_FIELD_VALUE (cons
, "otable",
1803 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
1804 PUSH_FIELD_VALUE (cons
, "otable_syms",
1805 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1806 TYPE_OTABLE_SYMS_DECL (type
)));
1807 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
1808 TREE_INVARIANT (TYPE_OTABLE_DECL (type
)) = 1;
1810 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
1812 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
1813 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
1817 PUSH_FIELD_VALUE (cons
, "atable",
1818 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
1819 PUSH_FIELD_VALUE (cons
, "atable_syms",
1820 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1821 TYPE_ATABLE_SYMS_DECL (type
)));
1822 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
1823 TREE_INVARIANT (TYPE_ATABLE_DECL (type
)) = 1;
1825 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
1827 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
1828 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
1832 PUSH_FIELD_VALUE (cons
, "itable",
1833 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
1834 PUSH_FIELD_VALUE (cons
, "itable_syms",
1835 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1836 TYPE_ITABLE_SYMS_DECL (type
)));
1837 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
1838 TREE_INVARIANT (TYPE_ITABLE_DECL (type
)) = 1;
1841 PUSH_FIELD_VALUE (cons
, "catch_classes",
1842 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
1843 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
1844 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
1845 PUSH_FIELD_VALUE (cons
, "interface_count",
1846 build_int_cst (NULL_TREE
, interface_len
));
1849 convert (byte_type_node
,
1850 build_int_cst (NULL_TREE
,
1851 flag_indirect_dispatch
1852 ? JV_STATE_PRELOADING
1853 : JV_STATE_COMPILED
)));
1855 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
1856 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
1857 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
1858 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
1859 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
1860 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
1863 tree assertion_table_ref
;
1864 if (TYPE_ASSERTIONS (type
) == NULL
)
1865 assertion_table_ref
= null_pointer_node
;
1867 assertion_table_ref
= build1 (ADDR_EXPR
,
1868 build_pointer_type (assertion_table_type
),
1869 emit_assertion_table (type
));
1871 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
1874 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
1875 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
1876 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
1877 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
1879 FINISH_RECORD_CONSTRUCTOR (cons
);
1881 DECL_INITIAL (decl
) = cons
;
1883 /* Hash synchronization requires at least 64-bit alignment. */
1884 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
1885 DECL_ALIGN (decl
) = 64;
1887 rest_of_decl_compilation (decl
, 1, 0);
1889 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
1890 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
1891 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
1897 if (TYPE_VERIFY_METHOD (output_class
))
1899 tree verify_method
= TYPE_VERIFY_METHOD (output_class
);
1900 DECL_SAVED_TREE (verify_method
)
1901 = add_stmt_to_compound (DECL_SAVED_TREE (verify_method
), void_type_node
,
1902 build (RETURN_EXPR
, void_type_node
, NULL
));
1903 java_genericize (verify_method
);
1904 cgraph_finalize_function (verify_method
, false);
1905 TYPE_ASSERTIONS (current_class
) = NULL
;
1908 java_expand_catch_classes (current_class
);
1910 current_function_decl
= NULL_TREE
;
1911 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
1912 make_class_data (current_class
);
1914 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
1917 /* Return 2 if CLASS is compiled by this compilation job;
1918 return 1 if CLASS can otherwise be assumed to be compiled;
1919 return 0 if we cannot assume that CLASS is compiled.
1920 Returns 1 for primitive and 0 for array types. */
1922 is_compiled_class (tree
class)
1925 if (TREE_CODE (class) == POINTER_TYPE
)
1926 class = TREE_TYPE (class);
1927 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
1929 if (TYPE_ARRAY_P (class))
1931 if (class == current_class
)
1934 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1935 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip
)
1937 /* The class was seen in the current ZIP file and will be
1938 available as a compiled class in the future but may not have
1939 been loaded already. Load it if necessary. This prevent
1940 build_class_ref () from crashing. */
1942 if (seen_in_zip
&& !CLASS_LOADED_P (class))
1943 load_class (class, 1);
1945 /* We return 2 for class seen in ZIP and class from files
1946 belonging to the same compilation unit */
1950 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1952 if (!CLASS_LOADED_P (class))
1954 if (CLASS_FROM_SOURCE_P (class))
1955 safe_layout_class (class);
1957 load_class (class, 1);
1965 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1968 build_dtable_decl (tree type
)
1972 /* We need to build a new dtable type so that its size is uniquely
1973 computed when we're dealing with the class for real and not just
1974 faking it (like java.lang.Class during the initialization of the
1975 compiler.) We know we're not faking a class when CURRENT_CLASS is
1977 if (current_class
== type
)
1979 tree dummy
= NULL_TREE
;
1982 dtype
= make_node (RECORD_TYPE
);
1984 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
1985 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
1987 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
1988 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
1990 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
1991 TREE_CHAIN (dummy
) = tmp_field
;
1992 DECL_CONTEXT (tmp_field
) = dtype
;
1993 DECL_ARTIFICIAL (tmp_field
) = 1;
1997 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
1998 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2000 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2001 TREE_CHAIN (dummy
) = tmp_field
;
2002 DECL_CONTEXT (tmp_field
) = dtype
;
2003 DECL_ARTIFICIAL (tmp_field
) = 1;
2007 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2008 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2009 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2011 PUSH_FIELD (dtype
, dummy
, "methods",
2012 build_prim_array_type (nativecode_ptr_type_node
, n
));
2013 layout_type (dtype
);
2016 dtype
= dtable_type
;
2018 return build_decl (VAR_DECL
,
2019 java_mangle_vtable (&temporary_obstack
, type
), dtype
);
2022 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2023 fields inherited from SUPER_CLASS. */
2026 push_super_field (tree this_class
, tree super_class
)
2029 /* Don't insert the field if we're just re-laying the class out. */
2030 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2032 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
2033 DECL_IGNORED_P (base_decl
) = 1;
2034 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2035 TYPE_FIELDS (this_class
) = base_decl
;
2036 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2037 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2040 /* Handle the different manners we may have to lay out a super class. */
2043 maybe_layout_super_class (tree super_class
, tree this_class
)
2045 if (TREE_CODE (super_class
) == RECORD_TYPE
)
2047 if (!CLASS_LOADED_P (super_class
) && CLASS_FROM_SOURCE_P (super_class
))
2048 safe_layout_class (super_class
);
2049 if (!CLASS_LOADED_P (super_class
))
2050 load_class (super_class
, 1);
2052 /* We might have to layout the class before its dependency on
2053 the super class gets resolved by java_complete_class */
2054 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2056 if (TREE_TYPE (super_class
) != NULL_TREE
)
2057 super_class
= TREE_TYPE (super_class
);
2060 /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
2062 tree this_wrap
= NULL_TREE
;
2066 tree this_decl
= TYPE_NAME (this_class
);
2067 #ifdef USE_MAPPED_LOCATION
2068 this_wrap
= build_expr_wfl (this_class
,
2069 DECL_SOURCE_LOCATION (this_decl
));
2071 this_wrap
= build_expr_wfl (this_class
,
2072 DECL_SOURCE_FILE (this_decl
),
2073 DECL_SOURCE_LINE (this_decl
), 0);
2076 super_class
= do_resolve_class (NULL_TREE
, this_class
,
2077 super_class
, NULL_TREE
, this_wrap
);
2079 return NULL_TREE
; /* FIXME, NULL_TREE not checked by caller. */
2080 super_class
= TREE_TYPE (super_class
);
2083 if (!TYPE_SIZE (super_class
))
2084 safe_layout_class (super_class
);
2090 layout_class (tree this_class
)
2092 tree super_class
= CLASSTYPE_SUPER (this_class
);
2095 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2096 if (CLASS_BEING_LAIDOUT (this_class
))
2102 sprintf (buffer
, " with '%s'",
2103 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2104 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2106 for (current
= TREE_CHAIN (class_list
); current
;
2107 current
= TREE_CHAIN (current
))
2109 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2110 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2111 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2112 DECL_SOURCE_FILE (decl
),
2113 DECL_SOURCE_LINE (decl
));
2114 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2116 obstack_1grow (&temporary_obstack
, '\0');
2117 report
= obstack_finish (&temporary_obstack
);
2118 cyclic_inheritance_report
= ggc_strdup (report
);
2119 obstack_free (&temporary_obstack
, report
);
2120 TYPE_SIZE (this_class
) = error_mark_node
;
2123 CLASS_BEING_LAIDOUT (this_class
) = 1;
2125 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2127 tree maybe_super_class
2128 = maybe_layout_super_class (super_class
, this_class
);
2129 if (maybe_super_class
== NULL
2130 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2132 TYPE_SIZE (this_class
) = error_mark_node
;
2133 CLASS_BEING_LAIDOUT (this_class
) = 0;
2134 class_list
= TREE_CHAIN (class_list
);
2137 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2138 push_super_field (this_class
, maybe_super_class
);
2141 for (field
= TYPE_FIELDS (this_class
);
2142 field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
2144 if (FIELD_STATIC (field
))
2146 /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
2147 SET_DECL_ASSEMBLER_NAME (field
,
2149 (&temporary_obstack
, field
));
2153 layout_type (this_class
);
2155 /* Also recursively load/layout any superinterfaces, but only if
2156 class was loaded from bytecode. The source parser will take care
2158 if (!CLASS_FROM_SOURCE_P (this_class
))
2161 if (TYPE_BINFO (this_class
))
2163 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2165 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2166 tree super_interface
= BINFO_TYPE (binfo
);
2167 tree maybe_super_interface
2168 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2169 if (maybe_super_interface
== NULL
2170 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2172 TYPE_SIZE (this_class
) = error_mark_node
;
2173 CLASS_BEING_LAIDOUT (this_class
) = 0;
2174 class_list
= TREE_CHAIN (class_list
);
2181 /* Convert the size back to an SI integer value. */
2182 TYPE_SIZE_UNIT (this_class
) =
2183 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2185 CLASS_BEING_LAIDOUT (this_class
) = 0;
2186 class_list
= TREE_CHAIN (class_list
);
2190 add_miranda_methods (tree base_class
, tree search_class
)
2193 tree binfo
, base_binfo
;
2195 if (!CLASS_PARSED_P (search_class
))
2196 load_class (search_class
, 1);
2198 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2199 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2202 tree elt
= BINFO_TYPE (base_binfo
);
2204 /* FIXME: This is totally bogus. We should not be handling
2205 Miranda methods at all if we're using the BC ABI. */
2206 if (TYPE_DUMMY (elt
))
2209 /* Ensure that interface methods are seen in declared order. */
2210 if (!CLASS_LOADED_P (elt
))
2211 load_class (elt
, 1);
2212 layout_class_methods (elt
);
2214 /* All base classes will have been laid out at this point, so the order
2215 will be correct. This code must match similar layout code in the
2217 for (method_decl
= TYPE_METHODS (elt
);
2218 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2222 /* An interface can have <clinit>. */
2223 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2226 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2227 override
= lookup_argument_method (base_class
,
2228 DECL_NAME (method_decl
), sig
);
2229 if (override
== NULL_TREE
)
2231 /* Found a Miranda method. Add it. */
2233 sig
= build_java_signature (TREE_TYPE (method_decl
));
2235 = add_method (base_class
,
2236 get_access_flags_from_decl (method_decl
),
2237 DECL_NAME (method_decl
), sig
);
2238 METHOD_INVISIBLE (new_method
) = 1;
2242 /* Try superinterfaces. */
2243 add_miranda_methods (base_class
, elt
);
2248 layout_class_methods (tree this_class
)
2250 tree method_decl
, dtable_count
;
2251 tree super_class
, type_name
;
2253 if (TYPE_NVIRTUALS (this_class
))
2256 super_class
= CLASSTYPE_SUPER (this_class
);
2260 super_class
= maybe_layout_super_class (super_class
, this_class
);
2261 if (!TYPE_NVIRTUALS (super_class
))
2262 layout_class_methods (super_class
);
2263 dtable_count
= TYPE_NVIRTUALS (super_class
);
2266 dtable_count
= integer_zero_node
;
2268 type_name
= TYPE_NAME (this_class
);
2269 if (!flag_indirect_dispatch
2270 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2272 /* An abstract class can have methods which are declared only in
2273 an implemented interface. These are called "Miranda
2274 methods". We make a dummy method entry for such methods
2276 add_miranda_methods (this_class
, this_class
);
2279 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2281 for (method_decl
= TYPE_METHODS (this_class
);
2282 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2283 dtable_count
= layout_class_method (this_class
, super_class
,
2284 method_decl
, dtable_count
);
2286 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2289 /* Return the index of METHOD in INTERFACE. This index begins at 1 and is used as an
2290 argument for _Jv_LookupInterfaceMethodIdx(). */
2292 get_interface_method_index (tree method
, tree interface
)
2297 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
), i
++)
2301 if (meth
== NULL_TREE
)
2306 /* Lay METHOD_DECL out, returning a possibly new value of
2307 DTABLE_COUNT. Also mangle the method's name. */
2310 layout_class_method (tree this_class
, tree super_class
,
2311 tree method_decl
, tree dtable_count
)
2313 tree method_name
= DECL_NAME (method_decl
);
2315 TREE_PUBLIC (method_decl
) = 1;
2316 /* Considered external until we know what classes are being
2317 compiled into this object file. */
2318 DECL_EXTERNAL (method_decl
) = 1;
2320 /* This is a good occasion to mangle the method's name */
2321 SET_DECL_ASSEMBLER_NAME (method_decl
,
2322 java_mangle_decl (&temporary_obstack
,
2325 if (ID_INIT_P (method_name
))
2327 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2329 for (ptr
= p
; *ptr
; )
2334 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2335 build_java_argument_signature (TREE_TYPE (method_decl
));
2337 else if (! METHOD_STATIC (method_decl
))
2340 build_java_argument_signature (TREE_TYPE (method_decl
));
2341 bool method_override
= false;
2342 tree super_method
= lookup_argument_method (super_class
, method_name
,
2344 if (super_method
!= NULL_TREE
2345 && ! METHOD_DUMMY (super_method
))
2347 method_override
= true;
2348 if (! METHOD_PUBLIC (super_method
) &&
2349 ! METHOD_PROTECTED (super_method
))
2351 /* Don't override private method, or default-access method in
2353 if (METHOD_PRIVATE (super_method
) ||
2354 ! in_same_package (TYPE_NAME (this_class
),
2355 TYPE_NAME (super_class
)))
2356 method_override
= false;
2359 if (method_override
)
2361 tree method_index
= get_method_index (super_method
);
2362 set_method_index (method_decl
, method_index
);
2363 if (method_index
== NULL_TREE
2364 && ! flag_indirect_dispatch
2365 && !CLASS_FROM_SOURCE_P (this_class
)
2366 && ! DECL_ARTIFICIAL (super_method
))
2367 error ("%Jnon-static method '%D' overrides static method",
2368 method_decl
, method_decl
);
2370 else if (this_class
== object_type_node
2371 && (METHOD_FINAL (method_decl
)
2372 || METHOD_PRIVATE (method_decl
)))
2374 /* We don't generate vtable entries for final Object
2375 methods. This is simply to save space, since every
2376 object would otherwise have to define them. */
2378 else if (! METHOD_PRIVATE (method_decl
)
2381 /* We generate vtable entries for final methods because they
2382 may one day be changed to non-final. */
2383 set_method_index (method_decl
, dtable_count
);
2384 dtable_count
= fold (build2 (PLUS_EXPR
, integer_type_node
,
2385 dtable_count
, integer_one_node
));
2389 return dtable_count
;
2393 register_class (void)
2397 if (!registered_class
)
2398 registered_class
= VEC_alloc (tree
, gc
, 8);
2400 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2401 VEC_safe_push (tree
, gc
, registered_class
, node
);
2404 /* Emit something to register classes at start-up time.
2406 The preferred mechanism is through the .jcr section, which contain
2407 a list of pointers to classes which get registered during constructor
2410 The fallback mechanism is to add statements to *LIST_P to call
2411 _Jv_RegisterClass for each class in this file. These statements will
2412 be added to a static constructor function for this translation unit. */
2415 emit_register_classes (tree
*list_p
)
2417 if (registered_class
== NULL
)
2420 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2421 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2422 but lack suitable crtbegin/end objects or linker support. These
2423 targets can overide the default in tm.h to use the fallback mechanism. */
2424 if (TARGET_USE_JCR_SECTION
)
2429 #ifdef JCR_SECTION_NAME
2430 named_section_flags (JCR_SECTION_NAME
, SECTION_WRITE
);
2432 /* A target has defined TARGET_USE_JCR_SECTION,
2433 but doesn't have a JCR_SECTION_NAME. */
2436 assemble_align (POINTER_SIZE
);
2438 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2440 t
= build_fold_addr_expr (klass
);
2441 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2446 tree klass
, t
, register_class_fn
;
2449 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2450 t
= build_decl (FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2451 TREE_PUBLIC (t
) = 1;
2452 DECL_EXTERNAL (t
) = 1;
2453 register_class_fn
= t
;
2455 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2457 t
= build_fold_addr_expr (klass
);
2458 t
= tree_cons (NULL
, t
, NULL
);
2459 t
= build_function_call_expr (register_class_fn
, t
);
2460 append_to_statement_list (t
, list_p
);
2465 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2468 build_symbol_entry (tree decl
)
2470 tree clname
, name
, signature
, sym
;
2471 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2472 /* ??? Constructors are given the name foo.foo all the way through
2473 the compiler, but in the method table they're all renamed
2474 foo.<init>. So, we have to do the same here unless we want an
2475 unresolved reference at runtime. */
2476 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2477 && DECL_CONSTRUCTOR_P (decl
))
2478 ? init_identifier_node
2479 : DECL_NAME (decl
));
2480 signature
= build_java_signature (TREE_TYPE (decl
));
2481 signature
= build_utf8_ref (unmangle_classname
2482 (IDENTIFIER_POINTER (signature
),
2483 IDENTIFIER_LENGTH (signature
)));
2485 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2486 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2487 PUSH_FIELD_VALUE (sym
, "name", name
);
2488 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2489 FINISH_RECORD_CONSTRUCTOR (sym
);
2490 TREE_CONSTANT (sym
) = 1;
2491 TREE_INVARIANT (sym
) = 1;
2496 /* Emit a symbol table: used by -findirect-dispatch. */
2499 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2500 tree the_syms_decl
, tree the_array_element_type
,
2503 tree method_list
, method
, table
, list
, null_symbol
;
2504 tree table_size
, the_array_type
;
2507 /* Only emit a table if this translation unit actually made any
2508 references via it. */
2509 if (decl_list
== NULL_TREE
)
2512 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2514 method_list
= decl_list
;
2516 while (method_list
!= NULL_TREE
)
2518 method
= TREE_VALUE (method_list
);
2519 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
), list
);
2520 method_list
= TREE_CHAIN (method_list
);
2524 /* Terminate the list with a "null" entry. */
2525 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2526 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2527 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2528 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2529 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2530 TREE_CONSTANT (null_symbol
) = 1;
2531 TREE_INVARIANT (null_symbol
) = 1;
2532 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2534 /* Put the list in the right order and make it a constructor. */
2535 list
= nreverse (list
);
2536 table
= build_constructor (symbols_array_type
, list
);
2538 /* Make it the initial value for otable_syms and emit the decl. */
2539 DECL_INITIAL (the_syms_decl
) = table
;
2540 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2541 DECL_IGNORED_P (the_syms_decl
) = 1;
2542 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2544 /* Now that its size is known, redefine the table as an
2545 uninitialized static array of INDEX + 1 elements. The extra entry
2546 is used by the runtime to track whether the table has been
2549 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2550 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2551 the_table
= build_decl (VAR_DECL
, name
, the_array_type
);
2552 TREE_STATIC (the_table
) = 1;
2553 TREE_READONLY (the_table
) = 1;
2554 rest_of_decl_compilation (the_table
, 1, 0);
2559 /* Make an entry for the catch_classes list. */
2561 make_catch_class_record (tree catch_class
, tree classname
)
2564 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2565 START_RECORD_CONSTRUCTOR (entry
, type
);
2566 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2567 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2568 FINISH_RECORD_CONSTRUCTOR (entry
);
2573 /* Generate the list of Throwable classes that are caught by exception
2574 handlers in this class. */
2576 emit_catch_table (tree this_class
)
2578 tree table
, table_size
, array_type
;
2579 TYPE_CATCH_CLASSES (this_class
) =
2581 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2582 TYPE_CATCH_CLASSES (this_class
));
2583 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2584 TYPE_CATCH_CLASSES (this_class
) =
2586 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2587 TYPE_CATCH_CLASSES (this_class
));
2588 table_size
= build_index_type
2589 (build_int_cst (NULL_TREE
,
2590 list_length (TYPE_CATCH_CLASSES (this_class
))));
2592 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2595 build_decl (VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2596 DECL_INITIAL (table
) =
2597 build_constructor (array_type
, TYPE_CATCH_CLASSES (this_class
));
2598 TREE_STATIC (table
) = 1;
2599 TREE_READONLY (table
) = 1;
2600 DECL_IGNORED_P (table
) = 1;
2601 rest_of_decl_compilation (table
, 1, 0);
2605 /* Given a type, return the signature used by
2606 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2607 same as build_java_signature() because we want the canonical array
2611 build_signature_for_libgcj (tree type
)
2615 sig
= build_java_signature (type
);
2616 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
2617 IDENTIFIER_LENGTH (sig
)));
2621 /* Add an entry to the type assertion table. Callback used during hashtable
2625 add_assertion_table_entry (void **htab_entry
, void *ptr
)
2628 tree code_val
, op1_utf8
, op2_utf8
;
2629 tree
*list
= (tree
*) ptr
;
2630 type_assertion
*as
= (type_assertion
*) *htab_entry
;
2632 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
2634 if (as
->op1
== NULL_TREE
)
2635 op1_utf8
= null_pointer_node
;
2637 op1_utf8
= build_signature_for_libgcj (as
->op1
);
2639 if (as
->op2
== NULL_TREE
)
2640 op2_utf8
= null_pointer_node
;
2642 op2_utf8
= build_signature_for_libgcj (as
->op2
);
2644 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
2645 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
2646 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
2647 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
2648 FINISH_RECORD_CONSTRUCTOR (entry
);
2650 *list
= tree_cons (NULL_TREE
, entry
, *list
);
2654 /* Generate the type assertion table for CLASS, and return its DECL. */
2657 emit_assertion_table (tree
class)
2659 tree null_entry
, ctor
, table_decl
;
2660 tree list
= NULL_TREE
;
2661 htab_t assertions_htab
= TYPE_ASSERTIONS (class);
2663 /* Iterate through the hash table. */
2664 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
2666 /* Finish with a null entry. */
2667 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
2668 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
2669 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
2670 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
2671 FINISH_RECORD_CONSTRUCTOR (null_entry
);
2673 list
= tree_cons (NULL_TREE
, null_entry
, list
);
2675 /* Put the list in the right order and make it a constructor. */
2676 list
= nreverse (list
);
2677 ctor
= build_constructor (assertion_table_type
, list
);
2679 table_decl
= build_decl (VAR_DECL
, mangled_classname ("_type_assert_", class),
2680 assertion_table_type
);
2682 TREE_STATIC (table_decl
) = 1;
2683 TREE_READONLY (table_decl
) = 1;
2684 TREE_CONSTANT (table_decl
) = 1;
2685 DECL_IGNORED_P (table_decl
) = 1;
2687 DECL_INITIAL (table_decl
) = ctor
;
2688 DECL_ARTIFICIAL (table_decl
) = 1;
2689 rest_of_decl_compilation (table_decl
, 1, 0);
2695 init_class_processing (void)
2697 fields_ident
= get_identifier ("fields");
2698 info_ident
= get_identifier ("info");
2700 gcc_obstack_init (&temporary_obstack
);
2703 static hashval_t
java_treetreehash_hash (const void *);
2704 static int java_treetreehash_compare (const void *, const void *);
2706 /* A hash table mapping trees to trees. Used generally. */
2708 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2711 java_treetreehash_hash (const void *k_p
)
2713 struct treetreehash_entry
*k
= (struct treetreehash_entry
*) k_p
;
2714 return JAVA_TREEHASHHASH_H (k
->key
);
2718 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
2720 struct treetreehash_entry
* k1
= (struct treetreehash_entry
*) k1_p
;
2721 tree k2
= (tree
) k2_p
;
2722 return (k1
->key
== k2
);
2726 java_treetreehash_find (htab_t ht
, tree t
)
2728 struct treetreehash_entry
*e
;
2729 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2730 e
= htab_find_with_hash (ht
, t
, hv
);
2738 java_treetreehash_new (htab_t ht
, tree t
)
2741 struct treetreehash_entry
*tthe
;
2742 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2744 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
2747 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
2752 tthe
= (struct treetreehash_entry
*) *e
;
2753 return &tthe
->value
;
2757 java_treetreehash_create (size_t size
, int gc
)
2760 return htab_create_ggc (size
, java_treetreehash_hash
,
2761 java_treetreehash_compare
, NULL
);
2763 return htab_create_alloc (size
, java_treetreehash_hash
,
2764 java_treetreehash_compare
, free
, xcalloc
, free
);
2767 /* Break down qualified IDENTIFIER into package and class-name components.
2768 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
2769 "pkg.foo", and RIGHT to "Bar". */
2772 split_qualified_name (tree
*left
, tree
*right
, tree source
)
2775 int l
= IDENTIFIER_LENGTH (source
);
2777 base
= alloca (l
+ 1);
2778 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
2780 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
2782 while (*p
!= '.' && p
!= base
)
2785 /* We didn't find a '.'. Return an error. */
2791 *right
= get_identifier (p
+1);
2792 *left
= get_identifier (base
);
2797 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
2798 if the classes are from the same package. */
2801 in_same_package (tree name1
, tree name2
)
2807 if (TREE_CODE (name1
) == TYPE_DECL
)
2808 name1
= DECL_NAME (name1
);
2809 if (TREE_CODE (name2
) == TYPE_DECL
)
2810 name2
= DECL_NAME (name2
);
2812 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
2813 /* One in empty package. */
2816 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
2817 /* Both in empty package. */
2820 split_qualified_name (&pkg1
, &tmp
, name1
);
2821 split_qualified_name (&pkg2
, &tmp
, name2
);
2823 return (pkg1
== pkg2
);
2826 #include "gt-java-class.h"