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, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA.
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc. */
26 /* Written by Per Bothner <bothner@cygnus.com> */
30 #include "coretypes.h"
35 #include "java-tree.h"
47 #include "tree-iterator.h"
50 /* DOS brain-damage */
52 #define O_BINARY 0 /* MS-DOS brain-damage */
55 static tree
make_method_value (tree
);
56 static tree
build_java_method_type (tree
, tree
, int);
57 static int32
hashUtf8String (const char *, int);
58 static tree
make_field_value (tree
);
59 static tree
get_dispatch_vector (tree
);
60 static tree
get_dispatch_table (tree
, tree
);
61 static int supers_all_compiled (tree type
);
62 static tree
maybe_layout_super_class (tree
, tree
);
63 static void add_miranda_methods (tree
, tree
);
64 static int assume_compiled (const char *);
65 static tree
build_symbol_entry (tree
);
66 static tree
emit_assertion_table (tree
);
67 static void register_class (void);
69 struct obstack temporary_obstack
;
71 /* The compiler generates different code depending on whether or not
72 it can assume certain classes have been compiled down to native
73 code or not. The compiler options -fassume-compiled= and
74 -fno-assume-compiled= are used to create a tree of
75 class_flag_node objects. This tree is queried to determine if
76 a class is assume to be compiled or not. Each node in the tree
77 represents either a package or a specific class. */
79 typedef struct class_flag_node_struct
81 /* The class or package name. */
84 /* Nonzero if this represents an exclusion. */
87 /* Pointers to other nodes in the tree. */
88 struct class_flag_node_struct
*parent
;
89 struct class_flag_node_struct
*sibling
;
90 struct class_flag_node_struct
*child
;
93 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
94 static void add_class_flag (class_flag_node
**, const char *, int);
96 /* This is the root of the include/exclude tree. */
98 static class_flag_node
*assume_compiled_tree
;
100 static class_flag_node
*enable_assert_tree
;
102 static GTY(()) tree class_roots
[4];
103 #define fields_ident class_roots[0] /* get_identifier ("fields") */
104 #define info_ident class_roots[1] /* get_identifier ("info") */
105 #define class_list class_roots[2]
106 #define class_dtable_decl class_roots[3]
108 static GTY(()) VEC(tree
,gc
) *registered_class
;
110 /* Return the node that most closely represents the class whose name
111 is IDENT. Start the search from NODE (followed by its siblings).
112 Return NULL if an appropriate node does not exist. */
114 static class_flag_node
*
115 find_class_flag_node (class_flag_node
*node
, const char *ident
)
119 size_t node_ident_length
= strlen (node
->ident
);
121 /* node_ident_length is zero at the root of the tree. If the
122 identifiers are the same length, then we have matching
123 classes. Otherwise check if we've matched an enclosing
126 if (node_ident_length
== 0
127 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
128 && (ident
[node_ident_length
] == '\0'
129 || ident
[node_ident_length
] == '.')))
131 /* We've found a match, however, there might be a more
134 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
141 /* No match yet. Continue through the sibling list. */
142 node
= node
->sibling
;
145 /* No match at all in this tree. */
150 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
152 class_flag_node
*root
= *rootp
;
153 class_flag_node
*parent
, *node
;
155 /* Create the root of the tree if it doesn't exist yet. */
159 root
= 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
)
553 if (! CLASS_LOADED_P (type1
))
554 load_class (type1
, 1);
556 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
561 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
564 enclosing_context_p (tree type1
, tree type2
)
566 if (!INNER_CLASS_TYPE_P (type2
))
569 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
571 type2
= (INNER_CLASS_TYPE_P (type2
) ?
572 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
582 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
586 common_enclosing_context_p (tree type1
, tree type2
)
591 for (current
= type2
; current
;
592 current
= (INNER_CLASS_TYPE_P (current
) ?
593 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
595 if (type1
== current
)
598 if (INNER_CLASS_TYPE_P (type1
))
599 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
606 /* Return 1 iff there exists a common enclosing "this" between TYPE1
607 and TYPE2, without crossing any static context. */
610 common_enclosing_instance_p (tree type1
, tree type2
)
612 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
615 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
616 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
617 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
620 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
621 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
622 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
624 if (type1
== current
)
630 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
631 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
632 if attempt is made to add it twice. */
635 maybe_add_interface (tree this_class
, tree interface_class
)
637 tree binfo
, base_binfo
;
640 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
641 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
642 if (BINFO_TYPE (base_binfo
) == interface_class
)
643 return interface_class
;
644 add_interface (this_class
, interface_class
);
648 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
651 add_interface (tree this_class
, tree interface_class
)
653 tree interface_binfo
= make_tree_binfo (0);
655 BINFO_TYPE (interface_binfo
) = interface_class
;
656 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
657 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
658 BINFO_VIRTUAL_P (interface_binfo
) = 1;
660 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
664 /* Return the address of a pointer to the first FUNCTION_DECL
665 in the list (*LIST) whose DECL_NAME is NAME. */
668 find_named_method (tree
*list
, tree name
)
670 while (*list
&& DECL_NAME (*list
) != name
)
671 list
= &TREE_CHAIN (*list
);
677 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
679 if (access_flags
& ACC_STATIC
)
681 return build_method_type (this_class
, fntype
);
685 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
687 tree method_type
, fndecl
;
689 method_type
= build_java_method_type (function_type
,
690 this_class
, access_flags
);
692 fndecl
= build_decl (FUNCTION_DECL
, name
, method_type
);
693 DECL_CONTEXT (fndecl
) = this_class
;
695 DECL_LANG_SPECIFIC (fndecl
)
696 = ggc_alloc_cleared (sizeof (struct lang_decl
));
697 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
699 /* Initialize the static initializer test table. */
701 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
702 java_treetreehash_create (10, 1);
704 /* Initialize the initialized (static) class table. */
705 if (access_flags
& ACC_STATIC
)
706 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
707 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
709 /* Initialize the static method invocation compound list */
710 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl
) = NULL_TREE
;
712 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
713 TYPE_METHODS (this_class
) = fndecl
;
715 /* Notice that this is a finalizer and update the class type
716 accordingly. This is used to optimize instance allocation. */
717 if (name
== finalize_identifier_node
718 && TREE_TYPE (function_type
) == void_type_node
719 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
720 HAS_FINALIZER_P (this_class
) = 1;
722 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
723 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
724 if (access_flags
& ACC_PRIVATE
)
725 METHOD_PRIVATE (fndecl
) = DECL_INLINE (fndecl
) = 1;
726 if (access_flags
& ACC_NATIVE
)
728 METHOD_NATIVE (fndecl
) = 1;
729 DECL_EXTERNAL (fndecl
) = 1;
731 if (access_flags
& ACC_STATIC
)
732 METHOD_STATIC (fndecl
) = DECL_INLINE (fndecl
) = 1;
733 if (access_flags
& ACC_FINAL
)
734 METHOD_FINAL (fndecl
) = DECL_INLINE (fndecl
) = 1;
735 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
736 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
737 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
741 /* Add a method to THIS_CLASS.
742 The method's name is NAME.
743 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
746 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
748 tree function_type
, fndecl
;
749 const unsigned char *sig
750 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
753 fatal_error ("bad method signature");
755 function_type
= get_type_from_signature (method_sig
);
756 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
757 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
762 add_field (tree
class, tree name
, tree field_type
, int flags
)
764 int is_static
= (flags
& ACC_STATIC
) != 0;
766 field
= build_decl (is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
767 TREE_CHAIN (field
) = TYPE_FIELDS (class);
768 TYPE_FIELDS (class) = field
;
769 DECL_CONTEXT (field
) = class;
771 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
772 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
773 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
774 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
775 if (flags
& ACC_VOLATILE
) FIELD_VOLATILE (field
) = 1;
776 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
779 FIELD_STATIC (field
) = 1;
780 /* Always make field externally visible. This is required so
781 that native methods can always access the field. */
782 TREE_PUBLIC (field
) = 1;
783 /* Considered external until we know what classes are being
784 compiled into this object file. */
785 DECL_EXTERNAL (field
) = 1;
791 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
794 set_constant_value (tree field
, tree constant
)
796 if (field
== NULL_TREE
)
797 warning (OPT_Wattributes
,
798 "misplaced ConstantValue attribute (not in any field)");
799 else if (DECL_INITIAL (field
) != NULL_TREE
)
800 warning (OPT_Wattributes
,
801 "duplicate ConstantValue attribute for field '%s'",
802 IDENTIFIER_POINTER (DECL_NAME (field
)));
805 DECL_INITIAL (field
) = constant
;
806 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
807 && ! (TREE_TYPE (constant
) == int_type_node
808 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
809 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
810 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
811 && TREE_TYPE (field
) == string_ptr_type_node
))
812 error ("ConstantValue attribute of field '%s' has wrong type",
813 IDENTIFIER_POINTER (DECL_NAME (field
)));
814 if (FIELD_FINAL (field
))
815 DECL_FIELD_FINAL_IUD (field
) = 1;
819 /* Count the number of Unicode chars encoded in a given Ut8 string. */
823 strLengthUtf8 (char *str
, int len
)
825 register unsigned char* ptr
= (unsigned char*) str
;
826 register unsigned char *limit
= ptr
+ len
;
828 for (; ptr
< limit
; str_length
++) {
829 if (UTF8_GET (ptr
, limit
) < 0)
837 /* Calculate a hash value for a string encoded in Utf8 format.
838 * This returns the same hash value as specified for java.lang.String.hashCode.
842 hashUtf8String (const char *str
, int len
)
844 const unsigned char* ptr
= (const unsigned char*) str
;
845 const unsigned char *limit
= ptr
+ len
;
849 int ch
= UTF8_GET (ptr
, limit
);
850 /* Updated specification from
851 http://www.javasoft.com/docs/books/jls/clarify.html. */
852 hash
= (31 * hash
) + ch
;
857 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
860 build_utf8_ref (tree name
)
862 const char * name_ptr
= IDENTIFIER_POINTER(name
);
863 int name_len
= IDENTIFIER_LENGTH(name
);
865 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
866 static int utf8_count
= 0;
868 tree ref
= IDENTIFIER_UTF8_REF (name
);
870 if (ref
!= NULL_TREE
)
873 ctype
= make_node (RECORD_TYPE
);
874 str_type
= build_prim_array_type (unsigned_byte_type_node
,
875 name_len
+ 1); /* Allow for final '\0'. */
876 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
877 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
878 PUSH_FIELD (ctype
, field
, "data", str_type
);
879 FINISH_RECORD (ctype
);
880 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
881 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
882 PUSH_FIELD_VALUE (cinit
, "hash", build_int_cst (NULL_TREE
, name_hash
));
883 PUSH_FIELD_VALUE (cinit
, "length", build_int_cst (NULL_TREE
, name_len
));
884 string
= build_string (name_len
, name_ptr
);
885 TREE_TYPE (string
) = str_type
;
886 PUSH_FIELD_VALUE (cinit
, "data", string
);
887 FINISH_RECORD_CONSTRUCTOR (cinit
);
888 TREE_CONSTANT (cinit
) = 1;
889 TREE_INVARIANT (cinit
) = 1;
891 /* Generate a unique-enough identifier. */
892 sprintf(buf
, "_Utf%d", ++utf8_count
);
894 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
895 TREE_STATIC (decl
) = 1;
896 DECL_ARTIFICIAL (decl
) = 1;
897 DECL_IGNORED_P (decl
) = 1;
898 TREE_READONLY (decl
) = 1;
899 TREE_THIS_VOLATILE (decl
) = 0;
900 DECL_INITIAL (decl
) = cinit
;
902 if (HAVE_GAS_SHF_MERGE
)
905 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
906 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
907 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
908 if (flag_merge_constants
&& decl_size
< 256)
911 int flags
= (SECTION_OVERRIDE
912 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
913 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
914 named_section_flags (buf
, flags
);
915 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
919 TREE_CHAIN (decl
) = utf8_decl_list
;
920 layout_decl (decl
, 0);
922 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
923 cgraph_varpool_mark_needed_node (cgraph_varpool_node (decl
));
924 utf8_decl_list
= decl
;
925 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
926 IDENTIFIER_UTF8_REF (name
) = ref
;
930 /* Like build_class_ref, but instead of a direct reference generate a
931 pointer into the constant pool. */
934 build_indirect_class_ref (tree type
)
938 index
= alloc_class_constant (type
);
939 cl
= build_ref_from_constant_pool (index
);
940 return convert (promote_type (class_ptr_type
), cl
);
943 /* Build a reference to the class TYPE.
944 Also handles primitive types and array types. */
947 build_class_ref (tree type
)
949 int is_compiled
= is_compiled_class (type
);
952 tree ref
, decl_name
, decl
;
953 if (TREE_CODE (type
) == POINTER_TYPE
)
954 type
= TREE_TYPE (type
);
956 if (flag_indirect_dispatch
957 && type
!= output_class
958 && TREE_CODE (type
) == RECORD_TYPE
)
959 return build_indirect_class_ref (type
);
961 if (TREE_CODE (type
) == RECORD_TYPE
)
963 if (TYPE_SIZE (type
) == error_mark_node
)
964 return null_pointer_node
;
965 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
966 "", '/', '/', ".class");
967 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
968 if (decl
== NULL_TREE
)
970 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
971 TREE_STATIC (decl
) = 1;
972 TREE_PUBLIC (decl
) = 1;
973 DECL_IGNORED_P (decl
) = 1;
974 DECL_ARTIFICIAL (decl
) = 1;
975 if (is_compiled
== 1)
976 DECL_EXTERNAL (decl
) = 1;
977 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
978 DECL_CLASS_FIELD_P (decl
) = 1;
979 DECL_CONTEXT (decl
) = type
;
981 /* ??? We want to preserve the DECL_CONTEXT we set just above,
982 that that means not calling pushdecl_top_level. */
983 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
990 if (flag_emit_class_files
)
992 const char *prim_class_name
;
994 if (type
== char_type_node
)
995 prim_class_name
= "java.lang.Character";
996 else if (type
== boolean_type_node
)
997 prim_class_name
= "java.lang.Boolean";
998 else if (type
== byte_type_node
)
999 prim_class_name
= "java.lang.Byte";
1000 else if (type
== short_type_node
)
1001 prim_class_name
= "java.lang.Short";
1002 else if (type
== int_type_node
)
1003 prim_class_name
= "java.lang.Integer";
1004 else if (type
== long_type_node
)
1005 prim_class_name
= "java.lang.Long";
1006 else if (type
== float_type_node
)
1007 prim_class_name
= "java.lang.Float";
1008 else if (type
== double_type_node
)
1009 prim_class_name
= "java.lang.Double";
1010 else if (type
== void_type_node
)
1011 prim_class_name
= "java.lang.Void";
1015 prim_class
= lookup_class (get_identifier (prim_class_name
));
1016 /* We wrap the class in a NOP_EXPR, because it is a
1017 type. We can't hold it in the COMPONENT_REF itself,
1018 as that type must remain NULL. */
1019 prim_class
= build1 (NOP_EXPR
, prim_class
, NULL_TREE
);
1021 return build3 (COMPONENT_REF
, NULL_TREE
,
1022 prim_class
, TYPE_identifier_node
, NULL_TREE
);
1024 decl_name
= TYPE_NAME (type
);
1025 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1026 decl_name
= DECL_NAME (decl_name
);
1027 name
= IDENTIFIER_POINTER (decl_name
);
1028 if (strncmp (name
, "promoted_", 9) == 0)
1030 sprintf (buffer
, "_Jv_%sClass", name
);
1031 decl_name
= get_identifier (buffer
);
1032 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1033 if (decl
== NULL_TREE
)
1035 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1036 TREE_STATIC (decl
) = 1;
1037 TREE_PUBLIC (decl
) = 1;
1038 DECL_EXTERNAL (decl
) = 1;
1039 DECL_ARTIFICIAL (decl
) = 1;
1040 pushdecl_top_level (decl
);
1044 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1048 return build_indirect_class_ref (type
);
1051 /* Create a local statically allocated variable that will hold a
1052 pointer to a static field. */
1055 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1057 tree decl
, decl_name
;
1058 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1059 char *buf
= alloca (strlen (name
) + 20);
1060 sprintf (buf
, "%s_%d_ref", name
, index
);
1061 decl_name
= get_identifier (buf
);
1062 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1063 if (decl
== NULL_TREE
)
1065 decl
= build_decl (VAR_DECL
, decl_name
, ptr_type_node
);
1066 TREE_STATIC (decl
) = 1;
1067 TREE_PUBLIC (decl
) = 0;
1068 DECL_EXTERNAL (decl
) = 0;
1069 DECL_ARTIFICIAL (decl
) = 1;
1070 pushdecl_top_level (decl
);
1076 build_static_field_ref (tree fdecl
)
1078 tree fclass
= DECL_CONTEXT (fdecl
);
1079 int is_compiled
= is_compiled_class (fclass
);
1080 int from_class
= ! CLASS_FROM_SOURCE_P (current_class
);
1082 /* Allow static final fields to fold to a constant. When using
1083 -findirect-dispatch, we simply never do this folding if compiling
1084 from .class; in the .class file constants will be referred to via
1085 the constant pool. */
1086 if ((!flag_indirect_dispatch
|| !from_class
)
1088 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1089 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1090 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1091 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1093 if (is_compiled
== 1)
1094 DECL_EXTERNAL (fdecl
) = 1;
1098 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1099 and a class local static variable CACHE_ENTRY, then
1101 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1102 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1105 This can mostly be optimized away, so that the usual path is a
1106 load followed by a test and branch. _Jv_ResolvePoolEntry is
1107 only called once for each constant pool entry.
1109 There is an optimization that we don't do: at the start of a
1110 method, create a local copy of CACHE_ENTRY and use that instead.
1114 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1115 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1117 = build3 (CALL_EXPR
, boolean_type_node
,
1118 build_address_of (built_in_decls
[BUILT_IN_EXPECT
]),
1119 tree_cons (NULL_TREE
, build2 (EQ_EXPR
, boolean_type_node
,
1120 cache_entry
, null_pointer_node
),
1121 build_tree_list (NULL_TREE
, boolean_false_node
)),
1123 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1125 = build3 (CALL_EXPR
, ptr_type_node
,
1126 build_address_of (soft_resolvepoolentry_node
),
1127 tree_cons (NULL_TREE
, build_class_ref (output_class
),
1128 build_tree_list (NULL_TREE
, cpool_index_cst
)),
1130 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1131 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1132 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1133 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1139 get_access_flags_from_decl (tree decl
)
1141 int access_flags
= 0;
1142 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1144 if (FIELD_STATIC (decl
))
1145 access_flags
|= ACC_STATIC
;
1146 if (FIELD_PUBLIC (decl
))
1147 access_flags
|= ACC_PUBLIC
;
1148 if (FIELD_PROTECTED (decl
))
1149 access_flags
|= ACC_PROTECTED
;
1150 if (FIELD_PRIVATE (decl
))
1151 access_flags
|= ACC_PRIVATE
;
1152 if (FIELD_FINAL (decl
))
1153 access_flags
|= ACC_FINAL
;
1154 if (FIELD_VOLATILE (decl
))
1155 access_flags
|= ACC_VOLATILE
;
1156 if (FIELD_TRANSIENT (decl
))
1157 access_flags
|= ACC_TRANSIENT
;
1158 return access_flags
;
1160 if (TREE_CODE (decl
) == TYPE_DECL
)
1162 if (CLASS_PUBLIC (decl
))
1163 access_flags
|= ACC_PUBLIC
;
1164 if (CLASS_FINAL (decl
))
1165 access_flags
|= ACC_FINAL
;
1166 if (CLASS_SUPER (decl
))
1167 access_flags
|= ACC_SUPER
;
1168 if (CLASS_INTERFACE (decl
))
1169 access_flags
|= ACC_INTERFACE
;
1170 if (CLASS_ABSTRACT (decl
))
1171 access_flags
|= ACC_ABSTRACT
;
1172 if (CLASS_STATIC (decl
))
1173 access_flags
|= ACC_STATIC
;
1174 if (CLASS_PRIVATE (decl
))
1175 access_flags
|= ACC_PRIVATE
;
1176 if (CLASS_PROTECTED (decl
))
1177 access_flags
|= ACC_PROTECTED
;
1178 if (CLASS_STRICTFP (decl
))
1179 access_flags
|= ACC_STRICT
;
1180 return access_flags
;
1182 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1184 if (METHOD_PUBLIC (decl
))
1185 access_flags
|= ACC_PUBLIC
;
1186 if (METHOD_PRIVATE (decl
))
1187 access_flags
|= ACC_PRIVATE
;
1188 if (METHOD_PROTECTED (decl
))
1189 access_flags
|= ACC_PROTECTED
;
1190 if (METHOD_STATIC (decl
))
1191 access_flags
|= ACC_STATIC
;
1192 if (METHOD_FINAL (decl
))
1193 access_flags
|= ACC_FINAL
;
1194 if (METHOD_SYNCHRONIZED (decl
))
1195 access_flags
|= ACC_SYNCHRONIZED
;
1196 if (METHOD_NATIVE (decl
))
1197 access_flags
|= ACC_NATIVE
;
1198 if (METHOD_ABSTRACT (decl
))
1199 access_flags
|= ACC_ABSTRACT
;
1200 if (METHOD_STRICTFP (decl
))
1201 access_flags
|= ACC_STRICT
;
1202 if (METHOD_INVISIBLE (decl
))
1203 access_flags
|= ACC_INVISIBLE
;
1204 return access_flags
;
1209 static GTY (()) int alias_labelno
= 0;
1211 /* Create a private alias for METHOD. Using this alias instead of the method
1212 decl ensures that ncode entries in the method table point to the real function
1213 at runtime, not a PLT entry. */
1216 make_local_function_alias (tree method
)
1218 #ifdef ASM_OUTPUT_DEF
1221 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1222 char *name
= alloca (strlen (method_name
) + 2);
1223 char *buf
= alloca (strlen (method_name
) + 128);
1225 /* Only create aliases for local functions. */
1226 if (DECL_EXTERNAL (method
))
1229 /* Prefix method_name with 'L' for the alias label. */
1231 strcpy (name
+ 1, method_name
);
1233 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1234 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
1235 TREE_TYPE (method
));
1236 DECL_CONTEXT (alias
) = NULL
;
1237 TREE_READONLY (alias
) = TREE_READONLY (method
);
1238 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1239 TREE_PUBLIC (alias
) = 0;
1240 DECL_EXTERNAL (alias
) = 0;
1241 DECL_ARTIFICIAL (alias
) = 1;
1242 DECL_INLINE (alias
) = 0;
1243 DECL_INITIAL (alias
) = error_mark_node
;
1244 TREE_ADDRESSABLE (alias
) = 1;
1245 TREE_USED (alias
) = 1;
1246 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1247 if (!flag_syntax_only
)
1248 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1255 /** Make reflection data (_Jv_Field) for field FDECL. */
1258 make_field_value (tree fdecl
)
1262 tree type
= TREE_TYPE (fdecl
);
1263 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1265 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1266 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1268 type
= build_class_ref (type
);
1271 tree signature
= build_java_signature (type
);
1273 type
= build_utf8_ref (unmangle_classname
1274 (IDENTIFIER_POINTER (signature
),
1275 IDENTIFIER_LENGTH (signature
)));
1277 PUSH_FIELD_VALUE (finit
, "type", type
);
1279 flags
= get_access_flags_from_decl (fdecl
);
1281 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1283 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1284 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1288 build_constructor_from_list (field_info_union_node
,
1290 ((FIELD_STATIC (fdecl
)
1291 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1292 : TYPE_FIELDS (field_info_union_node
)),
1293 (FIELD_STATIC (fdecl
)
1294 ? build_address_of (fdecl
)
1295 : byte_position (fdecl
)))));
1297 FINISH_RECORD_CONSTRUCTOR (finit
);
1301 /** Make reflection data (_Jv_Method) for method MDECL. */
1304 make_method_value (tree mdecl
)
1306 static int method_name_count
= 0;
1311 #define ACC_TRANSLATED 0x4000
1312 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1314 class_decl
= DECL_CONTEXT (mdecl
);
1315 /* For interfaces, the index field contains the dispatch index. */
1316 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1317 index
= build_int_cst (NULL_TREE
,
1318 get_interface_method_index (mdecl
, class_decl
));
1319 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1320 index
= get_method_index (mdecl
);
1322 index
= integer_minus_one_node
;
1324 code
= null_pointer_node
;
1325 if (METHOD_ABSTRACT (mdecl
))
1326 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1327 soft_abstractmethod_node
);
1329 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1330 make_local_function_alias (mdecl
));
1331 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1332 PUSH_FIELD_VALUE (minit
, "name",
1333 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1334 init_identifier_node
1335 : DECL_NAME (mdecl
)));
1337 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1338 PUSH_FIELD_VALUE (minit
, "signature",
1341 (IDENTIFIER_POINTER(signature
),
1342 IDENTIFIER_LENGTH(signature
)))));
1344 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1345 PUSH_FIELD_VALUE (minit
, "index", index
);
1346 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1349 /* Compute the `throws' information for the method. */
1350 tree table
= null_pointer_node
;
1351 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1353 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1354 tree iter
, type
, array
;
1357 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1358 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1360 iter
= TREE_CHAIN (iter
))
1362 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1364 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1365 IDENTIFIER_LENGTH (sig
)));
1366 table
= tree_cons (NULL_TREE
, utf8
, table
);
1368 type
= build_prim_array_type (ptr_type_node
, length
);
1369 table
= build_constructor_from_list (type
, table
);
1370 /* Compute something unique enough. */
1371 sprintf (buf
, "_methods%d", method_name_count
++);
1372 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1373 DECL_INITIAL (array
) = table
;
1374 TREE_STATIC (array
) = 1;
1375 DECL_ARTIFICIAL (array
) = 1;
1376 DECL_IGNORED_P (array
) = 1;
1377 rest_of_decl_compilation (array
, 1, 0);
1379 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1382 PUSH_FIELD_VALUE (minit
, "throws", table
);
1385 FINISH_RECORD_CONSTRUCTOR (minit
);
1390 get_dispatch_vector (tree type
)
1392 tree vtable
= TYPE_VTABLE (type
);
1394 if (vtable
== NULL_TREE
)
1398 tree super
= CLASSTYPE_SUPER (type
);
1399 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1400 vtable
= make_tree_vec (nvirtuals
);
1401 TYPE_VTABLE (type
) = vtable
;
1402 if (super
!= NULL_TREE
)
1404 tree super_vtable
= get_dispatch_vector (super
);
1406 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1407 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1410 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1411 method
= TREE_CHAIN (method
))
1413 tree method_index
= get_method_index (method
);
1414 if (method_index
!= NULL_TREE
1415 && host_integerp (method_index
, 0))
1416 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1424 get_dispatch_table (tree type
, tree this_class_addr
)
1426 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1427 tree vtable
= get_dispatch_vector (type
);
1429 tree list
= NULL_TREE
;
1430 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1434 for (i
= nvirtuals
; --i
>= 0; )
1436 tree method
= TREE_VEC_ELT (vtable
, i
);
1437 if (METHOD_ABSTRACT (method
))
1440 warning (0, "%Jabstract method in non-abstract class", method
);
1442 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1443 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1444 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1446 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1450 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1451 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1453 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1454 method
, build_int_cst (NULL_TREE
, j
));
1455 TREE_CONSTANT (fdesc
) = 1;
1456 TREE_INVARIANT (fdesc
) = 1;
1457 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1460 list
= tree_cons (NULL_TREE
,
1461 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1467 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1468 using the Boehm GC we sometimes stash a GC type descriptor
1469 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1470 the emitted byte count during the output to the assembly file. */
1471 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1472 fake "function descriptor". It's first word is the is the class
1473 pointer, and subsequent words (usually one) contain the GC descriptor.
1474 In all other cases, we reserve two extra vtable slots. */
1475 gc_descr
= get_boehm_type_descriptor (type
);
1476 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1477 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1478 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1479 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1481 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1482 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1483 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1484 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1486 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1487 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1488 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1490 return build_constructor_from_list
1491 (build_prim_array_type (nativecode_ptr_type_node
,
1496 /* Set the method_index for a method decl. */
1498 set_method_index (tree decl
, tree method_index
)
1500 if (method_index
!= NULL_TREE
)
1502 /* method_index is null if we're using indirect dispatch. */
1503 method_index
= fold (convert (sizetype
, method_index
));
1505 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1506 /* Add one to skip bogus descriptor for class and GC descriptor. */
1507 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1509 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1511 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1514 DECL_VINDEX (decl
) = method_index
;
1517 /* Get the method_index for a method decl. */
1519 get_method_index (tree decl
)
1521 tree method_index
= DECL_VINDEX (decl
);
1526 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1527 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1528 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1530 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1531 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1533 return method_index
;
1537 supers_all_compiled (tree type
)
1539 while (type
!= NULL_TREE
)
1541 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1543 type
= CLASSTYPE_SUPER (type
);
1549 make_class_data (tree type
)
1551 tree decl
, cons
, temp
;
1552 tree field
, fields_decl
;
1553 tree static_fields
= NULL_TREE
;
1554 tree instance_fields
= NULL_TREE
;
1555 HOST_WIDE_INT static_field_count
= 0;
1556 HOST_WIDE_INT instance_field_count
= 0;
1557 HOST_WIDE_INT field_count
;
1558 tree field_array_type
;
1560 tree methods
= NULL_TREE
;
1561 tree dtable_decl
= NULL_TREE
;
1562 HOST_WIDE_INT method_count
= 0;
1563 tree method_array_type
;
1566 tree this_class_addr
;
1567 tree constant_pool_constructor
;
1568 tree interfaces
= null_pointer_node
;
1569 int interface_len
= 0;
1570 tree type_decl
= TYPE_NAME (type
);
1571 /** Offset from start of virtual function table declaration
1572 to where objects actually point at, following new g++ ABI. */
1573 tree dtable_start_offset
= build_int_cst (NULL_TREE
,
1574 2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1576 this_class_addr
= build_class_ref (type
);
1577 decl
= TREE_OPERAND (this_class_addr
, 0);
1579 /* Build Field array. */
1580 field
= TYPE_FIELDS (type
);
1581 while (field
&& DECL_ARTIFICIAL (field
))
1582 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1583 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1584 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1585 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1587 if (! DECL_ARTIFICIAL (field
))
1589 tree init
= make_field_value (field
);
1590 if (FIELD_STATIC (field
))
1592 tree initial
= DECL_INITIAL (field
);
1593 static_field_count
++;
1594 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1595 /* If the initial value is a string constant,
1596 prevent output_constant from trying to assemble the value. */
1597 if (initial
!= NULL_TREE
1598 && TREE_TYPE (initial
) == string_ptr_type_node
)
1599 DECL_INITIAL (field
) = NULL_TREE
;
1600 rest_of_decl_compilation (field
, 1, 1);
1601 DECL_INITIAL (field
) = initial
;
1605 instance_field_count
++;
1606 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1610 field_count
= static_field_count
+ instance_field_count
;
1611 if (field_count
> 0)
1613 static_fields
= nreverse (static_fields
);
1614 instance_fields
= nreverse (instance_fields
);
1615 static_fields
= chainon (static_fields
, instance_fields
);
1616 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1617 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1619 DECL_INITIAL (fields_decl
) = build_constructor_from_list
1620 (field_array_type
, static_fields
);
1621 TREE_STATIC (fields_decl
) = 1;
1622 DECL_ARTIFICIAL (fields_decl
) = 1;
1623 DECL_IGNORED_P (fields_decl
) = 1;
1624 rest_of_decl_compilation (fields_decl
, 1, 0);
1627 fields_decl
= NULL_TREE
;
1629 /* Build Method array. */
1630 for (method
= TYPE_METHODS (type
);
1631 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1634 if (METHOD_PRIVATE (method
)
1635 && ! flag_keep_inline_functions
1638 /* Even if we have a decl, we don't necessarily have the code.
1639 This can happen if we inherit a method from a superclass for
1640 which we don't have a .class file. */
1641 if (METHOD_DUMMY (method
))
1643 init
= make_method_value (method
);
1645 methods
= tree_cons (NULL_TREE
, init
, methods
);
1647 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1648 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1650 DECL_INITIAL (methods_decl
) = build_constructor_from_list
1651 (method_array_type
, nreverse (methods
));
1652 TREE_STATIC (methods_decl
) = 1;
1653 DECL_ARTIFICIAL (methods_decl
) = 1;
1654 DECL_IGNORED_P (methods_decl
) = 1;
1655 rest_of_decl_compilation (methods_decl
, 1, 0);
1657 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1658 && !flag_indirect_dispatch
)
1660 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1661 dtable_decl
= build_dtable_decl (type
);
1662 DECL_INITIAL (dtable_decl
) = dtable
;
1663 TREE_STATIC (dtable_decl
) = 1;
1664 DECL_ARTIFICIAL (dtable_decl
) = 1;
1665 DECL_IGNORED_P (dtable_decl
) = 1;
1666 TREE_PUBLIC (dtable_decl
) = 1;
1667 rest_of_decl_compilation (dtable_decl
, 1, 0);
1668 if (type
== class_type_node
)
1669 class_dtable_decl
= dtable_decl
;
1672 if (class_dtable_decl
== NULL_TREE
)
1674 class_dtable_decl
= build_dtable_decl (class_type_node
);
1675 TREE_STATIC (class_dtable_decl
) = 1;
1676 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1677 DECL_IGNORED_P (class_dtable_decl
) = 1;
1678 if (is_compiled_class (class_type_node
) != 2)
1679 DECL_EXTERNAL (class_dtable_decl
) = 1;
1680 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1683 super
= CLASSTYPE_SUPER (type
);
1684 if (super
== NULL_TREE
)
1685 super
= null_pointer_node
;
1686 else if (! flag_indirect_dispatch
1687 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1688 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1689 super
= build_class_ref (super
);
1692 int super_index
= alloc_class_constant (super
);
1693 super
= build_int_cst (ptr_type_node
, super_index
);
1696 /* Build and emit the array of implemented interfaces. */
1697 if (type
!= object_type_node
)
1698 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1700 if (interface_len
> 0)
1702 tree init
= NULL_TREE
;
1704 tree interface_array_type
, idecl
;
1705 interface_array_type
1706 = build_prim_array_type (class_ptr_type
, interface_len
);
1707 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1708 interface_array_type
);
1710 for (i
= interface_len
; i
> 0; i
--)
1712 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1713 tree iclass
= BINFO_TYPE (child
);
1715 if (! flag_indirect_dispatch
1717 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1718 index
= build_class_ref (iclass
);
1721 int int_index
= alloc_class_constant (iclass
);
1722 index
= build_int_cst (ptr_type_node
, int_index
);
1724 init
= tree_cons (NULL_TREE
, index
, init
);
1726 DECL_INITIAL (idecl
) = build_constructor_from_list (interface_array_type
,
1728 TREE_STATIC (idecl
) = 1;
1729 DECL_ARTIFICIAL (idecl
) = 1;
1730 DECL_IGNORED_P (idecl
) = 1;
1731 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1732 rest_of_decl_compilation (idecl
, 1, 0);
1735 constant_pool_constructor
= build_constants_constructor ();
1737 if (flag_indirect_dispatch
)
1739 TYPE_OTABLE_DECL (type
)
1741 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
1742 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
1743 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
1745 TYPE_ATABLE_DECL (type
)
1747 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
1748 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
1749 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
1751 TYPE_ITABLE_DECL (type
)
1753 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
1754 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
1755 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
1758 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
1760 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
1761 PUSH_FIELD_VALUE (temp
, "vtable",
1762 build2 (PLUS_EXPR
, dtable_ptr_type
,
1763 build1 (ADDR_EXPR
, dtable_ptr_type
,
1765 dtable_start_offset
));
1766 if (! flag_hash_synchronization
)
1767 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
1768 FINISH_RECORD_CONSTRUCTOR (temp
);
1769 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
1770 PUSH_SUPER_VALUE (cons
, temp
);
1771 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
1772 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
1773 PUSH_FIELD_VALUE (cons
, "accflags",
1774 build_int_cst (NULL_TREE
,
1775 get_access_flags_from_decl (type_decl
)));
1777 PUSH_FIELD_VALUE (cons
, "superclass",
1778 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
1779 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
1780 PUSH_FIELD_VALUE (cons
, "methods",
1781 build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
1782 PUSH_FIELD_VALUE (cons
, "method_count",
1783 build_int_cst (NULL_TREE
, method_count
));
1785 if (flag_indirect_dispatch
)
1786 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
1788 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
1790 PUSH_FIELD_VALUE (cons
, "fields",
1791 fields_decl
== NULL_TREE
? null_pointer_node
1792 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
1793 /* If we're using the binary compatibility ABI we don't know the
1794 size until load time. */
1795 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
1796 (flag_indirect_dispatch
1797 ? integer_minus_one_node
1798 : size_in_bytes (type
)));
1799 PUSH_FIELD_VALUE (cons
, "field_count",
1800 build_int_cst (NULL_TREE
, field_count
));
1801 PUSH_FIELD_VALUE (cons
, "static_field_count",
1802 build_int_cst (NULL_TREE
, static_field_count
));
1804 if (flag_indirect_dispatch
)
1805 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
1807 PUSH_FIELD_VALUE (cons
, "vtable",
1808 dtable_decl
== NULL_TREE
? null_pointer_node
1809 : build2 (PLUS_EXPR
, dtable_ptr_type
,
1810 build1 (ADDR_EXPR
, dtable_ptr_type
,
1812 dtable_start_offset
));
1813 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
1815 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
1816 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
1820 PUSH_FIELD_VALUE (cons
, "otable",
1821 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
1822 PUSH_FIELD_VALUE (cons
, "otable_syms",
1823 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1824 TYPE_OTABLE_SYMS_DECL (type
)));
1825 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
1826 TREE_INVARIANT (TYPE_OTABLE_DECL (type
)) = 1;
1828 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
1830 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
1831 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
1835 PUSH_FIELD_VALUE (cons
, "atable",
1836 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
1837 PUSH_FIELD_VALUE (cons
, "atable_syms",
1838 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1839 TYPE_ATABLE_SYMS_DECL (type
)));
1840 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
1841 TREE_INVARIANT (TYPE_ATABLE_DECL (type
)) = 1;
1843 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
1845 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
1846 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
1850 PUSH_FIELD_VALUE (cons
, "itable",
1851 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
1852 PUSH_FIELD_VALUE (cons
, "itable_syms",
1853 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1854 TYPE_ITABLE_SYMS_DECL (type
)));
1855 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
1856 TREE_INVARIANT (TYPE_ITABLE_DECL (type
)) = 1;
1859 PUSH_FIELD_VALUE (cons
, "catch_classes",
1860 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
1861 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
1862 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
1863 PUSH_FIELD_VALUE (cons
, "interface_count",
1864 build_int_cst (NULL_TREE
, interface_len
));
1865 PUSH_FIELD_VALUE (cons
, "state",
1866 convert (byte_type_node
,
1867 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
1869 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
1870 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
1871 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
1872 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
1873 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
1874 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
1877 tree assertion_table_ref
;
1878 if (TYPE_ASSERTIONS (type
) == NULL
)
1879 assertion_table_ref
= null_pointer_node
;
1881 assertion_table_ref
= build1 (ADDR_EXPR
,
1882 build_pointer_type (assertion_table_type
),
1883 emit_assertion_table (type
));
1885 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
1888 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
1889 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
1890 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
1891 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
1893 FINISH_RECORD_CONSTRUCTOR (cons
);
1895 DECL_INITIAL (decl
) = cons
;
1897 /* Hash synchronization requires at least 64-bit alignment. */
1898 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
1899 DECL_ALIGN (decl
) = 64;
1901 rest_of_decl_compilation (decl
, 1, 0);
1903 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
1904 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
1905 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
1911 if (TYPE_VERIFY_METHOD (output_class
))
1913 tree verify_method
= TYPE_VERIFY_METHOD (output_class
);
1914 DECL_SAVED_TREE (verify_method
)
1915 = add_stmt_to_compound (DECL_SAVED_TREE (verify_method
), void_type_node
,
1916 build (RETURN_EXPR
, void_type_node
, NULL
));
1917 java_genericize (verify_method
);
1918 cgraph_finalize_function (verify_method
, false);
1919 TYPE_ASSERTIONS (current_class
) = NULL
;
1922 java_expand_catch_classes (current_class
);
1924 current_function_decl
= NULL_TREE
;
1925 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
1926 make_class_data (current_class
);
1928 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
1931 /* Return 2 if CLASS is compiled by this compilation job;
1932 return 1 if CLASS can otherwise be assumed to be compiled;
1933 return 0 if we cannot assume that CLASS is compiled.
1934 Returns 1 for primitive and 0 for array types. */
1936 is_compiled_class (tree
class)
1939 if (TREE_CODE (class) == POINTER_TYPE
)
1940 class = TREE_TYPE (class);
1941 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
1943 if (TYPE_ARRAY_P (class))
1945 if (class == current_class
)
1948 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1949 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip
)
1951 /* The class was seen in the current ZIP file and will be
1952 available as a compiled class in the future but may not have
1953 been loaded already. Load it if necessary. This prevent
1954 build_class_ref () from crashing. */
1956 if (seen_in_zip
&& !CLASS_LOADED_P (class))
1957 load_class (class, 1);
1959 /* We return 2 for class seen in ZIP and class from files
1960 belonging to the same compilation unit */
1964 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1966 if (!CLASS_LOADED_P (class))
1968 if (CLASS_FROM_SOURCE_P (class))
1969 safe_layout_class (class);
1971 load_class (class, 1);
1979 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1982 build_dtable_decl (tree type
)
1986 /* We need to build a new dtable type so that its size is uniquely
1987 computed when we're dealing with the class for real and not just
1988 faking it (like java.lang.Class during the initialization of the
1989 compiler.) We know we're not faking a class when CURRENT_CLASS is
1991 if (current_class
== type
)
1993 tree dummy
= NULL_TREE
;
1996 dtype
= make_node (RECORD_TYPE
);
1998 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
1999 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
2001 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
2002 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2004 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2005 TREE_CHAIN (dummy
) = tmp_field
;
2006 DECL_CONTEXT (tmp_field
) = dtype
;
2007 DECL_ARTIFICIAL (tmp_field
) = 1;
2011 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
2012 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2014 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2015 TREE_CHAIN (dummy
) = tmp_field
;
2016 DECL_CONTEXT (tmp_field
) = dtype
;
2017 DECL_ARTIFICIAL (tmp_field
) = 1;
2021 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2022 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2023 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2025 PUSH_FIELD (dtype
, dummy
, "methods",
2026 build_prim_array_type (nativecode_ptr_type_node
, n
));
2027 layout_type (dtype
);
2030 dtype
= dtable_type
;
2032 decl
= build_decl (VAR_DECL
, get_identifier ("vt$"), dtype
);
2033 DECL_CONTEXT (decl
) = type
;
2034 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2035 DECL_VTABLE_P (decl
) = 1;
2040 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2041 fields inherited from SUPER_CLASS. */
2044 push_super_field (tree this_class
, tree super_class
)
2047 /* Don't insert the field if we're just re-laying the class out. */
2048 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2050 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
2051 DECL_IGNORED_P (base_decl
) = 1;
2052 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2053 TYPE_FIELDS (this_class
) = base_decl
;
2054 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2055 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2058 /* Handle the different manners we may have to lay out a super class. */
2061 maybe_layout_super_class (tree super_class
, tree this_class
)
2065 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2067 if (!CLASS_LOADED_P (super_class
) && CLASS_FROM_SOURCE_P (super_class
))
2068 safe_layout_class (super_class
);
2069 if (!CLASS_LOADED_P (super_class
))
2070 load_class (super_class
, 1);
2072 /* We might have to layout the class before its dependency on
2073 the super class gets resolved by java_complete_class */
2074 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2076 if (TREE_TYPE (super_class
) != NULL_TREE
)
2077 super_class
= TREE_TYPE (super_class
);
2080 /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
2082 tree this_wrap
= NULL_TREE
;
2086 tree this_decl
= TYPE_NAME (this_class
);
2087 #ifdef USE_MAPPED_LOCATION
2088 this_wrap
= build_expr_wfl (this_class
,
2089 DECL_SOURCE_LOCATION (this_decl
));
2091 this_wrap
= build_expr_wfl (this_class
,
2092 DECL_SOURCE_FILE (this_decl
),
2093 DECL_SOURCE_LINE (this_decl
), 0);
2097 = do_resolve_class (DECL_CONTEXT (TYPE_NAME (this_class
)),
2098 this_class
, super_class
, NULL_TREE
, this_wrap
);
2100 return NULL_TREE
; /* FIXME, NULL_TREE not checked by caller. */
2101 super_class
= TREE_TYPE (super_class
);
2104 if (!TYPE_SIZE (super_class
))
2105 safe_layout_class (super_class
);
2111 layout_class (tree this_class
)
2113 tree super_class
= CLASSTYPE_SUPER (this_class
);
2115 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2116 if (CLASS_BEING_LAIDOUT (this_class
))
2122 sprintf (buffer
, " with '%s'",
2123 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2124 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2126 for (current
= TREE_CHAIN (class_list
); current
;
2127 current
= TREE_CHAIN (current
))
2129 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2130 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2131 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2132 DECL_SOURCE_FILE (decl
),
2133 DECL_SOURCE_LINE (decl
));
2134 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2136 obstack_1grow (&temporary_obstack
, '\0');
2137 report
= obstack_finish (&temporary_obstack
);
2138 cyclic_inheritance_report
= ggc_strdup (report
);
2139 obstack_free (&temporary_obstack
, report
);
2140 TYPE_SIZE (this_class
) = error_mark_node
;
2143 CLASS_BEING_LAIDOUT (this_class
) = 1;
2145 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2147 tree maybe_super_class
2148 = maybe_layout_super_class (super_class
, this_class
);
2149 if (maybe_super_class
== NULL
2150 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2152 TYPE_SIZE (this_class
) = error_mark_node
;
2153 CLASS_BEING_LAIDOUT (this_class
) = 0;
2154 class_list
= TREE_CHAIN (class_list
);
2157 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2158 push_super_field (this_class
, maybe_super_class
);
2161 layout_type (this_class
);
2163 /* Also recursively load/layout any superinterfaces, but only if
2164 class was loaded from bytecode. The source parser will take care
2166 if (!CLASS_FROM_SOURCE_P (this_class
))
2169 if (TYPE_BINFO (this_class
))
2171 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2173 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2174 tree super_interface
= BINFO_TYPE (binfo
);
2175 tree maybe_super_interface
2176 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2177 if (maybe_super_interface
== NULL
2178 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2180 TYPE_SIZE (this_class
) = error_mark_node
;
2181 CLASS_BEING_LAIDOUT (this_class
) = 0;
2182 class_list
= TREE_CHAIN (class_list
);
2189 /* Convert the size back to an SI integer value. */
2190 TYPE_SIZE_UNIT (this_class
) =
2191 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2193 CLASS_BEING_LAIDOUT (this_class
) = 0;
2194 class_list
= TREE_CHAIN (class_list
);
2198 add_miranda_methods (tree base_class
, tree search_class
)
2201 tree binfo
, base_binfo
;
2203 if (!CLASS_PARSED_P (search_class
))
2204 load_class (search_class
, 1);
2206 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2207 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2210 tree elt
= BINFO_TYPE (base_binfo
);
2212 /* FIXME: This is totally bogus. We should not be handling
2213 Miranda methods at all if we're using the BC ABI. */
2214 if (TYPE_DUMMY (elt
))
2217 /* Ensure that interface methods are seen in declared order. */
2218 if (!CLASS_LOADED_P (elt
))
2219 load_class (elt
, 1);
2220 layout_class_methods (elt
);
2222 /* All base classes will have been laid out at this point, so the order
2223 will be correct. This code must match similar layout code in the
2225 for (method_decl
= TYPE_METHODS (elt
);
2226 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2230 /* An interface can have <clinit>. */
2231 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2234 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2235 override
= lookup_argument_method (base_class
,
2236 DECL_NAME (method_decl
), sig
);
2237 if (override
== NULL_TREE
)
2239 /* Found a Miranda method. Add it. */
2241 sig
= build_java_signature (TREE_TYPE (method_decl
));
2243 = add_method (base_class
,
2244 get_access_flags_from_decl (method_decl
),
2245 DECL_NAME (method_decl
), sig
);
2246 METHOD_INVISIBLE (new_method
) = 1;
2250 /* Try superinterfaces. */
2251 add_miranda_methods (base_class
, elt
);
2256 layout_class_methods (tree this_class
)
2258 tree method_decl
, dtable_count
;
2259 tree super_class
, type_name
;
2261 if (TYPE_NVIRTUALS (this_class
))
2264 super_class
= CLASSTYPE_SUPER (this_class
);
2268 super_class
= maybe_layout_super_class (super_class
, this_class
);
2269 if (!TYPE_NVIRTUALS (super_class
))
2270 layout_class_methods (super_class
);
2271 dtable_count
= TYPE_NVIRTUALS (super_class
);
2274 dtable_count
= integer_zero_node
;
2276 type_name
= TYPE_NAME (this_class
);
2277 if (!flag_indirect_dispatch
2278 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2280 /* An abstract class can have methods which are declared only in
2281 an implemented interface. These are called "Miranda
2282 methods". We make a dummy method entry for such methods
2284 add_miranda_methods (this_class
, this_class
);
2287 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2289 for (method_decl
= TYPE_METHODS (this_class
);
2290 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2291 dtable_count
= layout_class_method (this_class
, super_class
,
2292 method_decl
, dtable_count
);
2294 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2297 /* Return the index of METHOD in INTERFACE. This index begins at 1 and is used as an
2298 argument for _Jv_LookupInterfaceMethodIdx(). */
2300 get_interface_method_index (tree method
, tree interface
)
2305 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
), i
++)
2309 if (meth
== NULL_TREE
)
2314 /* Lay METHOD_DECL out, returning a possibly new value of
2315 DTABLE_COUNT. Also mangle the method's name. */
2318 layout_class_method (tree this_class
, tree super_class
,
2319 tree method_decl
, tree dtable_count
)
2321 tree method_name
= DECL_NAME (method_decl
);
2323 TREE_PUBLIC (method_decl
) = 1;
2324 /* Considered external until we know what classes are being
2325 compiled into this object file. */
2326 DECL_EXTERNAL (method_decl
) = 1;
2328 if (ID_INIT_P (method_name
))
2330 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2332 for (ptr
= p
; *ptr
; )
2337 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2338 build_java_argument_signature (TREE_TYPE (method_decl
));
2340 else if (! METHOD_STATIC (method_decl
))
2343 build_java_argument_signature (TREE_TYPE (method_decl
));
2344 bool method_override
= false;
2345 tree super_method
= lookup_argument_method (super_class
, method_name
,
2347 if (super_method
!= NULL_TREE
2348 && ! METHOD_DUMMY (super_method
))
2350 method_override
= true;
2351 if (! METHOD_PUBLIC (super_method
) &&
2352 ! METHOD_PROTECTED (super_method
))
2354 /* Don't override private method, or default-access method in
2356 if (METHOD_PRIVATE (super_method
) ||
2357 ! in_same_package (TYPE_NAME (this_class
),
2358 TYPE_NAME (super_class
)))
2359 method_override
= false;
2362 if (method_override
)
2364 tree method_index
= get_method_index (super_method
);
2365 set_method_index (method_decl
, method_index
);
2366 if (method_index
== NULL_TREE
2367 && ! flag_indirect_dispatch
2368 && !CLASS_FROM_SOURCE_P (this_class
)
2369 && ! DECL_ARTIFICIAL (super_method
))
2370 error ("non-static method %q+D overrides static method",
2373 else if (this_class
== object_type_node
2374 && (METHOD_FINAL (method_decl
)
2375 || METHOD_PRIVATE (method_decl
)))
2377 /* We don't generate vtable entries for final Object
2378 methods. This is simply to save space, since every
2379 object would otherwise have to define them. */
2381 else if (! METHOD_PRIVATE (method_decl
)
2384 /* We generate vtable entries for final methods because they
2385 may one day be changed to non-final. */
2386 set_method_index (method_decl
, dtable_count
);
2387 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2388 dtable_count
, integer_one_node
);
2392 return dtable_count
;
2396 register_class (void)
2400 if (!registered_class
)
2401 registered_class
= VEC_alloc (tree
, gc
, 8);
2403 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2404 VEC_safe_push (tree
, gc
, registered_class
, node
);
2407 /* Emit something to register classes at start-up time.
2409 The preferred mechanism is through the .jcr section, which contain
2410 a list of pointers to classes which get registered during constructor
2413 The fallback mechanism is to add statements to *LIST_P to call
2414 _Jv_RegisterClass for each class in this file. These statements will
2415 be added to a static constructor function for this translation unit. */
2418 emit_register_classes (tree
*list_p
)
2420 if (registered_class
== NULL
)
2423 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2424 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2425 but lack suitable crtbegin/end objects or linker support. These
2426 targets can overide the default in tm.h to use the fallback mechanism. */
2427 if (TARGET_USE_JCR_SECTION
)
2432 #ifdef JCR_SECTION_NAME
2433 named_section_flags (JCR_SECTION_NAME
, SECTION_WRITE
);
2435 /* A target has defined TARGET_USE_JCR_SECTION,
2436 but doesn't have a JCR_SECTION_NAME. */
2439 assemble_align (POINTER_SIZE
);
2441 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2443 t
= build_fold_addr_expr (klass
);
2444 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2449 tree klass
, t
, register_class_fn
;
2452 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2453 t
= build_decl (FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2454 TREE_PUBLIC (t
) = 1;
2455 DECL_EXTERNAL (t
) = 1;
2456 register_class_fn
= t
;
2458 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2460 t
= build_fold_addr_expr (klass
);
2461 t
= tree_cons (NULL
, t
, NULL
);
2462 t
= build_function_call_expr (register_class_fn
, t
);
2463 append_to_statement_list (t
, list_p
);
2468 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2471 build_symbol_entry (tree decl
)
2473 tree clname
, name
, signature
, sym
;
2474 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2475 /* ??? Constructors are given the name foo.foo all the way through
2476 the compiler, but in the method table they're all renamed
2477 foo.<init>. So, we have to do the same here unless we want an
2478 unresolved reference at runtime. */
2479 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2480 && DECL_CONSTRUCTOR_P (decl
))
2481 ? init_identifier_node
2482 : DECL_NAME (decl
));
2483 signature
= build_java_signature (TREE_TYPE (decl
));
2484 signature
= build_utf8_ref (unmangle_classname
2485 (IDENTIFIER_POINTER (signature
),
2486 IDENTIFIER_LENGTH (signature
)));
2488 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2489 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2490 PUSH_FIELD_VALUE (sym
, "name", name
);
2491 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2492 FINISH_RECORD_CONSTRUCTOR (sym
);
2493 TREE_CONSTANT (sym
) = 1;
2494 TREE_INVARIANT (sym
) = 1;
2499 /* Emit a symbol table: used by -findirect-dispatch. */
2502 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2503 tree the_syms_decl
, tree the_array_element_type
,
2506 tree method_list
, method
, table
, list
, null_symbol
;
2507 tree table_size
, the_array_type
;
2510 /* Only emit a table if this translation unit actually made any
2511 references via it. */
2512 if (decl_list
== NULL_TREE
)
2515 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2517 method_list
= decl_list
;
2519 while (method_list
!= NULL_TREE
)
2521 method
= TREE_VALUE (method_list
);
2522 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
), list
);
2523 method_list
= TREE_CHAIN (method_list
);
2527 /* Terminate the list with a "null" entry. */
2528 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2529 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2530 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2531 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2532 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2533 TREE_CONSTANT (null_symbol
) = 1;
2534 TREE_INVARIANT (null_symbol
) = 1;
2535 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2537 /* Put the list in the right order and make it a constructor. */
2538 list
= nreverse (list
);
2539 table
= build_constructor_from_list (symbols_array_type
, list
);
2541 /* Make it the initial value for otable_syms and emit the decl. */
2542 DECL_INITIAL (the_syms_decl
) = table
;
2543 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2544 DECL_IGNORED_P (the_syms_decl
) = 1;
2545 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2547 /* Now that its size is known, redefine the table as an
2548 uninitialized static array of INDEX + 1 elements. The extra entry
2549 is used by the runtime to track whether the table has been
2552 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2553 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2554 the_table
= build_decl (VAR_DECL
, name
, the_array_type
);
2555 TREE_STATIC (the_table
) = 1;
2556 TREE_READONLY (the_table
) = 1;
2557 rest_of_decl_compilation (the_table
, 1, 0);
2562 /* Make an entry for the catch_classes list. */
2564 make_catch_class_record (tree catch_class
, tree classname
)
2567 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2568 START_RECORD_CONSTRUCTOR (entry
, type
);
2569 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2570 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2571 FINISH_RECORD_CONSTRUCTOR (entry
);
2576 /* Generate the list of Throwable classes that are caught by exception
2577 handlers in this class. */
2579 emit_catch_table (tree this_class
)
2581 tree table
, table_size
, array_type
;
2582 TYPE_CATCH_CLASSES (this_class
) =
2584 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2585 TYPE_CATCH_CLASSES (this_class
));
2586 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2587 TYPE_CATCH_CLASSES (this_class
) =
2589 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2590 TYPE_CATCH_CLASSES (this_class
));
2591 table_size
= build_index_type
2592 (build_int_cst (NULL_TREE
,
2593 list_length (TYPE_CATCH_CLASSES (this_class
))));
2595 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2598 build_decl (VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2599 DECL_INITIAL (table
) =
2600 build_constructor_from_list (array_type
, TYPE_CATCH_CLASSES (this_class
));
2601 TREE_STATIC (table
) = 1;
2602 TREE_READONLY (table
) = 1;
2603 DECL_IGNORED_P (table
) = 1;
2604 rest_of_decl_compilation (table
, 1, 0);
2608 /* Given a type, return the signature used by
2609 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2610 same as build_java_signature() because we want the canonical array
2614 build_signature_for_libgcj (tree type
)
2618 sig
= build_java_signature (type
);
2619 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
2620 IDENTIFIER_LENGTH (sig
)));
2624 /* Add an entry to the type assertion table. Callback used during hashtable
2628 add_assertion_table_entry (void **htab_entry
, void *ptr
)
2631 tree code_val
, op1_utf8
, op2_utf8
;
2632 tree
*list
= (tree
*) ptr
;
2633 type_assertion
*as
= (type_assertion
*) *htab_entry
;
2635 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
2637 if (as
->op1
== NULL_TREE
)
2638 op1_utf8
= null_pointer_node
;
2640 op1_utf8
= build_signature_for_libgcj (as
->op1
);
2642 if (as
->op2
== NULL_TREE
)
2643 op2_utf8
= null_pointer_node
;
2645 op2_utf8
= build_signature_for_libgcj (as
->op2
);
2647 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
2648 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
2649 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
2650 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
2651 FINISH_RECORD_CONSTRUCTOR (entry
);
2653 *list
= tree_cons (NULL_TREE
, entry
, *list
);
2657 /* Generate the type assertion table for CLASS, and return its DECL. */
2660 emit_assertion_table (tree
class)
2662 tree null_entry
, ctor
, table_decl
;
2663 tree list
= NULL_TREE
;
2664 htab_t assertions_htab
= TYPE_ASSERTIONS (class);
2666 /* Iterate through the hash table. */
2667 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
2669 /* Finish with a null entry. */
2670 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
2671 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
2672 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
2673 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
2674 FINISH_RECORD_CONSTRUCTOR (null_entry
);
2676 list
= tree_cons (NULL_TREE
, null_entry
, list
);
2678 /* Put the list in the right order and make it a constructor. */
2679 list
= nreverse (list
);
2680 ctor
= build_constructor_from_list (assertion_table_type
, list
);
2682 table_decl
= build_decl (VAR_DECL
, mangled_classname ("_type_assert_", class),
2683 assertion_table_type
);
2685 TREE_STATIC (table_decl
) = 1;
2686 TREE_READONLY (table_decl
) = 1;
2687 TREE_CONSTANT (table_decl
) = 1;
2688 DECL_IGNORED_P (table_decl
) = 1;
2690 DECL_INITIAL (table_decl
) = ctor
;
2691 DECL_ARTIFICIAL (table_decl
) = 1;
2692 rest_of_decl_compilation (table_decl
, 1, 0);
2698 init_class_processing (void)
2700 fields_ident
= get_identifier ("fields");
2701 info_ident
= get_identifier ("info");
2703 gcc_obstack_init (&temporary_obstack
);
2706 static hashval_t
java_treetreehash_hash (const void *);
2707 static int java_treetreehash_compare (const void *, const void *);
2709 /* A hash table mapping trees to trees. Used generally. */
2711 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2714 java_treetreehash_hash (const void *k_p
)
2716 struct treetreehash_entry
*k
= (struct treetreehash_entry
*) k_p
;
2717 return JAVA_TREEHASHHASH_H (k
->key
);
2721 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
2723 struct treetreehash_entry
* k1
= (struct treetreehash_entry
*) k1_p
;
2724 tree k2
= (tree
) k2_p
;
2725 return (k1
->key
== k2
);
2729 java_treetreehash_find (htab_t ht
, tree t
)
2731 struct treetreehash_entry
*e
;
2732 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2733 e
= htab_find_with_hash (ht
, t
, hv
);
2741 java_treetreehash_new (htab_t ht
, tree t
)
2744 struct treetreehash_entry
*tthe
;
2745 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2747 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
2750 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
2755 tthe
= (struct treetreehash_entry
*) *e
;
2756 return &tthe
->value
;
2760 java_treetreehash_create (size_t size
, int gc
)
2763 return htab_create_ggc (size
, java_treetreehash_hash
,
2764 java_treetreehash_compare
, NULL
);
2766 return htab_create_alloc (size
, java_treetreehash_hash
,
2767 java_treetreehash_compare
, free
, xcalloc
, free
);
2770 /* Break down qualified IDENTIFIER into package and class-name components.
2771 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
2772 "pkg.foo", and RIGHT to "Bar". */
2775 split_qualified_name (tree
*left
, tree
*right
, tree source
)
2778 int l
= IDENTIFIER_LENGTH (source
);
2780 base
= alloca (l
+ 1);
2781 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
2783 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
2785 while (*p
!= '.' && p
!= base
)
2788 /* We didn't find a '.'. Return an error. */
2794 *right
= get_identifier (p
+1);
2795 *left
= get_identifier (base
);
2800 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
2801 if the classes are from the same package. */
2804 in_same_package (tree name1
, tree name2
)
2810 if (TREE_CODE (name1
) == TYPE_DECL
)
2811 name1
= DECL_NAME (name1
);
2812 if (TREE_CODE (name2
) == TYPE_DECL
)
2813 name2
= DECL_NAME (name2
);
2815 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
2816 /* One in empty package. */
2819 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
2820 /* Both in empty package. */
2823 split_qualified_name (&pkg1
, &tmp
, name1
);
2824 split_qualified_name (&pkg2
, &tmp
, name2
);
2826 return (pkg1
== pkg2
);
2829 #include "gt-java-class.h"