1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007 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"
51 /* DOS brain-damage */
53 #define O_BINARY 0 /* MS-DOS brain-damage */
56 static tree
make_method_value (tree
);
57 static tree
build_java_method_type (tree
, tree
, int);
58 static int32
hashUtf8String (const char *, int);
59 static tree
make_field_value (tree
);
60 static tree
get_dispatch_vector (tree
);
61 static tree
get_dispatch_table (tree
, tree
);
62 static int supers_all_compiled (tree type
);
63 static tree
maybe_layout_super_class (tree
, tree
);
64 static void add_miranda_methods (tree
, tree
);
65 static int assume_compiled (const char *);
66 static tree
build_symbol_entry (tree
, tree
);
67 static tree
emit_assertion_table (tree
);
68 static void register_class (void);
70 struct obstack temporary_obstack
;
72 static const char *cyclic_inheritance_report
;
74 /* The compiler generates different code depending on whether or not
75 it can assume certain classes have been compiled down to native
76 code or not. The compiler options -fassume-compiled= and
77 -fno-assume-compiled= are used to create a tree of
78 class_flag_node objects. This tree is queried to determine if
79 a class is assume to be compiled or not. Each node in the tree
80 represents either a package or a specific class. */
82 typedef struct class_flag_node_struct
84 /* The class or package name. */
87 /* Nonzero if this represents an exclusion. */
90 /* Pointers to other nodes in the tree. */
91 struct class_flag_node_struct
*parent
;
92 struct class_flag_node_struct
*sibling
;
93 struct class_flag_node_struct
*child
;
96 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
97 static void add_class_flag (class_flag_node
**, const char *, int);
99 /* This is the root of the include/exclude tree. */
101 static class_flag_node
*assume_compiled_tree
;
103 static class_flag_node
*enable_assert_tree
;
105 static GTY(()) tree class_roots
[4];
106 #define fields_ident class_roots[0] /* get_identifier ("fields") */
107 #define info_ident class_roots[1] /* get_identifier ("info") */
108 #define class_list class_roots[2]
109 #define class_dtable_decl class_roots[3]
111 static GTY(()) VEC(tree
,gc
) *registered_class
;
113 /* A tree that returns the address of the class$ of the class
114 currently being compiled. */
115 static GTY(()) tree this_classdollar
;
117 /* Return the node that most closely represents the class whose name
118 is IDENT. Start the search from NODE (followed by its siblings).
119 Return NULL if an appropriate node does not exist. */
121 static class_flag_node
*
122 find_class_flag_node (class_flag_node
*node
, const char *ident
)
126 size_t node_ident_length
= strlen (node
->ident
);
128 /* node_ident_length is zero at the root of the tree. If the
129 identifiers are the same length, then we have matching
130 classes. Otherwise check if we've matched an enclosing
133 if (node_ident_length
== 0
134 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
135 && (ident
[node_ident_length
] == '\0'
136 || ident
[node_ident_length
] == '.')))
138 /* We've found a match, however, there might be a more
141 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
148 /* No match yet. Continue through the sibling list. */
149 node
= node
->sibling
;
152 /* No match at all in this tree. */
157 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
159 class_flag_node
*root
= *rootp
;
160 class_flag_node
*parent
, *node
;
162 /* Create the root of the tree if it doesn't exist yet. */
166 root
= XNEW (class_flag_node
);
169 root
->sibling
= NULL
;
175 /* Calling the function with the empty string means we're setting
176 value for the root of the hierarchy. */
184 /* Find the parent node for this new node. PARENT will either be a
185 class or a package name. Adjust PARENT accordingly. */
187 parent
= find_class_flag_node (root
, ident
);
188 if (strcmp (ident
, parent
->ident
) == 0)
189 parent
->value
= value
;
192 /* Insert new node into the tree. */
193 node
= XNEW (class_flag_node
);
195 node
->ident
= xstrdup (ident
);
199 node
->parent
= parent
;
200 node
->sibling
= parent
->child
;
201 parent
->child
= node
;
205 /* Add a new IDENT to the include/exclude tree. It's an exclusion
206 if EXCLUDEP is nonzero. */
209 add_assume_compiled (const char *ident
, int excludep
)
211 add_class_flag (&assume_compiled_tree
, ident
, excludep
);
214 /* The default value returned by enable_assertions. */
216 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
218 /* Enter IDENT (a class or package name) into the enable-assertions table.
219 VALUE is true to enable and false to disable. */
222 add_enable_assert (const char *ident
, int value
)
224 if (enable_assert_tree
== NULL
)
225 add_class_flag (&enable_assert_tree
, "", DEFAULT_ENABLE_ASSERT
);
226 add_class_flag (&enable_assert_tree
, ident
, value
);
229 /* Returns nonzero if IDENT is the name of a class that the compiler
230 should assume has been compiled to object code. */
233 assume_compiled (const char *ident
)
238 if (NULL
== assume_compiled_tree
)
241 i
= find_class_flag_node (assume_compiled_tree
, ident
);
248 /* Return true if we should generate code to check assertions within KLASS. */
251 enable_assertions (tree klass
)
253 /* Check if command-line specifies whether we should check assertions. */
255 if (klass
!= NULL_TREE
&& DECL_NAME (klass
) && enable_assert_tree
!= NULL
)
257 const char *ident
= IDENTIFIER_POINTER (DECL_NAME (klass
));
258 class_flag_node
*node
259 = find_class_flag_node (enable_assert_tree
, ident
);
263 /* The default is to enable assertions if generating class files,
264 or not optimizing. */
265 return DEFAULT_ENABLE_ASSERT
;
268 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
269 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
270 Also, PREFIX is prepended, and SUFFIX is appended. */
273 ident_subst (const char* old_name
,
280 int prefix_len
= strlen (prefix
);
281 int suffix_len
= strlen (suffix
);
282 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
283 char *buffer
= alloca (i
);
285 strcpy (buffer
, prefix
);
286 for (i
= 0; i
< old_length
; i
++)
288 char ch
= old_name
[i
];
291 buffer
[prefix_len
+ i
] = ch
;
293 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
294 return get_identifier (buffer
);
297 /* Return an IDENTIFIER_NODE the same as OLD_ID,
298 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
299 Also, PREFIX is prepended, and SUFFIX is appended. */
302 identifier_subst (const tree old_id
,
308 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
309 prefix
, old_char
, new_char
, suffix
);
312 /* Generate a valid C identifier from the name of the class TYPE,
313 prefixed by PREFIX. */
316 mangled_classname (const char *prefix
, tree type
)
318 tree ident
= TYPE_NAME (type
);
319 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
320 ident
= DECL_NAME (ident
);
321 return identifier_subst (ident
, prefix
, '.', '_', "");
328 type
= make_node (RECORD_TYPE
);
329 /* Unfortunately we must create the binfo here, so that class
331 TYPE_BINFO (type
) = make_tree_binfo (0);
332 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
337 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
338 and where each of the constituents is separated by '/',
339 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
342 unmangle_classname (const char *name
, int name_length
)
344 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
345 /* It's not sufficient to compare to_return and get_identifier
346 (name) to determine whether to_return is qualified. There are
347 cases in signature analysis where name will be stripped of a
349 name
= IDENTIFIER_POINTER (to_return
);
353 QUALIFIED_P (to_return
) = 1;
360 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
363 const char *typename = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
364 char *buf = alloca (strlen (typename) + strlen (#NAME "_syms_") + 1); \
367 sprintf (buf, #NAME "_%s", typename); \
368 TYPE_## TABLE ##_DECL (type) = decl = \
369 build_decl (VAR_DECL, get_identifier (buf), TABLE_TYPE); \
370 DECL_EXTERNAL (decl) = 1; \
371 TREE_STATIC (decl) = 1; \
372 TREE_READONLY (decl) = 1; \
373 TREE_CONSTANT (decl) = 1; \
374 DECL_IGNORED_P (decl) = 1; \
375 /* Mark the table as belonging to this class. */ \
377 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
378 DECL_OWNER (decl) = TYPE; \
379 sprintf (buf, #NAME "_syms_%s", typename); \
380 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
381 build_decl (VAR_DECL, get_identifier (buf), symbols_array_type); \
382 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
383 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
384 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
388 /* Given a class, create the DECLs for all its associated indirect
391 gen_indirect_dispatch_tables (tree type
)
393 const char *typename
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
396 char *buf
= alloca (strlen (typename
) + strlen ("_catch_classes_") + 1);
397 tree catch_class_type
= make_node (RECORD_TYPE
);
399 sprintf (buf
, "_catch_classes_%s", typename
);
400 PUSH_FIELD (catch_class_type
, field
, "address", utf8const_ptr_type
);
401 PUSH_FIELD (catch_class_type
, field
, "classname", ptr_type_node
);
402 FINISH_RECORD (catch_class_type
);
404 TYPE_CTABLE_DECL (type
)
405 = build_decl (VAR_DECL
, get_identifier (buf
),
406 build_array_type (catch_class_type
, 0));
407 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
408 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
409 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
410 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
411 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
412 pushdecl (TYPE_CTABLE_DECL (type
));
415 if (flag_indirect_dispatch
)
417 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
418 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
419 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
426 push_class (tree class_type
, tree class_name
)
428 tree decl
, signature
;
429 location_t saved_loc
= input_location
;
430 #ifndef USE_MAPPED_LOCATION
431 input_filename
= "<unknown>";
434 CLASS_P (class_type
) = 1;
435 decl
= build_decl (TYPE_DECL
, class_name
, class_type
);
436 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
438 /* dbxout needs a DECL_SIZE if in gstabs mode */
439 DECL_SIZE (decl
) = integer_zero_node
;
441 input_location
= saved_loc
;
442 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
443 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
445 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
446 both a typedef and in the struct name-space. We may want to re-visit
447 this later, but for now it reduces the changes needed for gdb. */
448 DECL_ARTIFICIAL (decl
) = 1;
450 pushdecl_top_level (decl
);
455 /* Finds the (global) class named NAME. Creates the class if not found.
456 Also creates associated TYPE_DECL.
457 Does not check if the class actually exists, load the class,
458 fill in field or methods, or do layout_type. */
461 lookup_class (tree name
)
463 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
464 if (decl
== NULL_TREE
)
465 decl
= push_class (make_class (), name
);
466 return TREE_TYPE (decl
);
470 set_super_info (int access_flags
, tree this_class
,
471 tree super_class
, int interfaces_count
)
473 int total_supers
= interfaces_count
;
474 tree class_decl
= TYPE_NAME (this_class
);
480 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
481 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
484 tree super_binfo
= make_tree_binfo (0);
485 BINFO_TYPE (super_binfo
) = super_class
;
486 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
487 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
488 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
491 set_class_decl_access_flags (access_flags
, class_decl
);
495 set_class_decl_access_flags (int access_flags
, tree class_decl
)
497 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
498 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
499 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
500 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
501 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
502 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
503 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
504 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
505 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
506 if (access_flags
& ACC_ENUM
) CLASS_ENUM (class_decl
) = 1;
507 if (access_flags
& ACC_SYNTHETIC
) CLASS_SYNTHETIC (class_decl
) = 1;
508 if (access_flags
& ACC_ANNOTATION
) CLASS_ANNOTATION (class_decl
) = 1;
511 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
512 direct sub-classes of Object are 1, and so on. */
515 class_depth (tree clas
)
518 if (! CLASS_LOADED_P (clas
))
519 load_class (clas
, 1);
520 if (TYPE_SIZE (clas
) == error_mark_node
)
522 while (clas
!= object_type_node
)
525 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
530 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
533 interface_of_p (tree type1
, tree type2
)
536 tree binfo
, base_binfo
;
538 if (! TYPE_BINFO (type2
))
541 for (binfo
= TYPE_BINFO (type2
), i
= 0;
542 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
543 if (BINFO_TYPE (base_binfo
) == type1
)
546 for (binfo
= TYPE_BINFO (type2
), i
= 0;
547 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
548 if (BINFO_TYPE (base_binfo
)
549 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
555 /* Return true iff TYPE1 inherits from TYPE2. */
558 inherits_from_p (tree type1
, tree type2
)
560 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
565 if (! CLASS_LOADED_P (type1
))
566 load_class (type1
, 1);
568 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
573 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
576 enclosing_context_p (tree type1
, tree type2
)
578 if (!INNER_CLASS_TYPE_P (type2
))
581 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
583 type2
= (INNER_CLASS_TYPE_P (type2
) ?
584 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
594 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
598 common_enclosing_context_p (tree type1
, tree type2
)
603 for (current
= type2
; current
;
604 current
= (INNER_CLASS_TYPE_P (current
) ?
605 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
607 if (type1
== current
)
610 if (INNER_CLASS_TYPE_P (type1
))
611 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
618 /* Return 1 iff there exists a common enclosing "this" between TYPE1
619 and TYPE2, without crossing any static context. */
622 common_enclosing_instance_p (tree type1
, tree type2
)
624 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
627 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
628 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
629 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
632 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
633 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
634 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
636 if (type1
== current
)
642 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
643 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
644 if attempt is made to add it twice. */
647 maybe_add_interface (tree this_class
, tree interface_class
)
649 tree binfo
, base_binfo
;
652 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
653 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
654 if (BINFO_TYPE (base_binfo
) == interface_class
)
655 return interface_class
;
656 add_interface (this_class
, interface_class
);
660 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
663 add_interface (tree this_class
, tree interface_class
)
665 tree interface_binfo
= make_tree_binfo (0);
667 BINFO_TYPE (interface_binfo
) = interface_class
;
668 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
669 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
670 BINFO_VIRTUAL_P (interface_binfo
) = 1;
672 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
676 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
678 if (access_flags
& ACC_STATIC
)
680 fntype
= build_method_type (this_class
, fntype
);
682 /* We know that arg 1 of every nonstatic method is non-null; tell
684 TYPE_ATTRIBUTES (fntype
) = (tree_cons
685 (get_identifier ("nonnull"),
686 tree_cons (NULL_TREE
,
687 build_int_cst (NULL_TREE
, 1),
689 TYPE_ATTRIBUTES (fntype
)));
694 hide (tree decl ATTRIBUTE_UNUSED
)
696 #ifdef HAVE_GAS_HIDDEN
697 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
698 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
703 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
705 tree method_type
, fndecl
;
707 method_type
= build_java_method_type (function_type
,
708 this_class
, access_flags
);
710 fndecl
= build_decl (FUNCTION_DECL
, name
, method_type
);
711 DECL_CONTEXT (fndecl
) = this_class
;
713 DECL_LANG_SPECIFIC (fndecl
)
714 = ggc_alloc_cleared (sizeof (struct lang_decl
));
715 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
717 /* Initialize the static initializer test table. */
719 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
720 java_treetreehash_create (10, 1);
722 /* Initialize the initialized (static) class table. */
723 if (access_flags
& ACC_STATIC
)
724 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
725 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
727 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
728 TYPE_METHODS (this_class
) = fndecl
;
730 /* If pointers to member functions use the least significant bit to
731 indicate whether a function is virtual, ensure a pointer
732 to this function will have that bit clear. */
733 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
734 && !(access_flags
& ACC_STATIC
)
735 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
736 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
738 /* Notice that this is a finalizer and update the class type
739 accordingly. This is used to optimize instance allocation. */
740 if (name
== finalize_identifier_node
741 && TREE_TYPE (function_type
) == void_type_node
742 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
743 HAS_FINALIZER_P (this_class
) = 1;
745 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
746 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
747 if (access_flags
& ACC_PRIVATE
)
748 METHOD_PRIVATE (fndecl
) = DECL_INLINE (fndecl
) = 1;
749 if (access_flags
& ACC_NATIVE
)
751 METHOD_NATIVE (fndecl
) = 1;
752 DECL_EXTERNAL (fndecl
) = 1;
755 /* FNDECL is external unless we are compiling it into this object
757 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
758 if (access_flags
& ACC_STATIC
)
759 METHOD_STATIC (fndecl
) = DECL_INLINE (fndecl
) = 1;
760 if (access_flags
& ACC_FINAL
)
761 METHOD_FINAL (fndecl
) = DECL_INLINE (fndecl
) = 1;
762 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
763 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
764 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
765 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
766 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
767 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
771 /* Add a method to THIS_CLASS.
772 The method's name is NAME.
773 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
776 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
778 tree function_type
, fndecl
;
779 const unsigned char *sig
780 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
783 fatal_error ("bad method signature");
785 function_type
= get_type_from_signature (method_sig
);
786 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
787 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
792 add_field (tree
class, tree name
, tree field_type
, int flags
)
794 int is_static
= (flags
& ACC_STATIC
) != 0;
796 field
= build_decl (is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
797 TREE_CHAIN (field
) = TYPE_FIELDS (class);
798 TYPE_FIELDS (class) = field
;
799 DECL_CONTEXT (field
) = class;
800 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
802 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
803 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
804 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
805 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
806 if (flags
& ACC_VOLATILE
)
808 FIELD_VOLATILE (field
) = 1;
809 TREE_THIS_VOLATILE (field
) = 1;
811 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
812 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
813 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
816 FIELD_STATIC (field
) = 1;
817 /* Always make field externally visible. This is required so
818 that native methods can always access the field. */
819 TREE_PUBLIC (field
) = 1;
820 /* Hide everything that shouldn't be visible outside a DSO. */
821 if (flag_indirect_classes
822 || (FIELD_PRIVATE (field
)))
824 /* Considered external unless we are compiling it into this
826 DECL_EXTERNAL (field
) = (is_compiled_class (class) != 2);
832 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
835 set_constant_value (tree field
, tree constant
)
837 if (field
== NULL_TREE
)
838 warning (OPT_Wattributes
,
839 "misplaced ConstantValue attribute (not in any field)");
840 else if (DECL_INITIAL (field
) != NULL_TREE
)
841 warning (OPT_Wattributes
,
842 "duplicate ConstantValue attribute for field '%s'",
843 IDENTIFIER_POINTER (DECL_NAME (field
)));
846 DECL_INITIAL (field
) = constant
;
847 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
848 && ! (TREE_TYPE (constant
) == int_type_node
849 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
850 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
851 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
852 && TREE_TYPE (field
) == string_ptr_type_node
))
853 error ("ConstantValue attribute of field '%s' has wrong type",
854 IDENTIFIER_POINTER (DECL_NAME (field
)));
855 if (FIELD_FINAL (field
))
856 DECL_FIELD_FINAL_IUD (field
) = 1;
860 /* Calculate a hash value for a string encoded in Utf8 format.
861 * This returns the same hash value as specified for java.lang.String.hashCode.
865 hashUtf8String (const char *str
, int len
)
867 const unsigned char* ptr
= (const unsigned char*) str
;
868 const unsigned char *limit
= ptr
+ len
;
872 int ch
= UTF8_GET (ptr
, limit
);
873 /* Updated specification from
874 http://www.javasoft.com/docs/books/jls/clarify.html. */
875 hash
= (31 * hash
) + ch
;
880 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
883 build_utf8_ref (tree name
)
885 const char * name_ptr
= IDENTIFIER_POINTER(name
);
886 int name_len
= IDENTIFIER_LENGTH(name
);
888 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
889 static int utf8_count
= 0;
891 tree ref
= IDENTIFIER_UTF8_REF (name
);
893 if (ref
!= NULL_TREE
)
896 ctype
= make_node (RECORD_TYPE
);
897 str_type
= build_prim_array_type (unsigned_byte_type_node
,
898 name_len
+ 1); /* Allow for final '\0'. */
899 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
900 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
901 PUSH_FIELD (ctype
, field
, "data", str_type
);
902 FINISH_RECORD (ctype
);
903 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
904 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
905 PUSH_FIELD_VALUE (cinit
, "hash", build_int_cst (NULL_TREE
, name_hash
));
906 PUSH_FIELD_VALUE (cinit
, "length", build_int_cst (NULL_TREE
, name_len
));
907 string
= build_string (name_len
, name_ptr
);
908 TREE_TYPE (string
) = str_type
;
909 PUSH_FIELD_VALUE (cinit
, "data", string
);
910 FINISH_RECORD_CONSTRUCTOR (cinit
);
911 TREE_CONSTANT (cinit
) = 1;
912 TREE_INVARIANT (cinit
) = 1;
914 /* Generate a unique-enough identifier. */
915 sprintf(buf
, "_Utf%d", ++utf8_count
);
917 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
918 TREE_STATIC (decl
) = 1;
919 DECL_ARTIFICIAL (decl
) = 1;
920 DECL_IGNORED_P (decl
) = 1;
921 TREE_READONLY (decl
) = 1;
922 TREE_THIS_VOLATILE (decl
) = 0;
923 DECL_INITIAL (decl
) = cinit
;
925 if (HAVE_GAS_SHF_MERGE
)
928 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
929 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
930 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
931 if (flag_merge_constants
&& decl_size
< 256)
934 int flags
= (SECTION_OVERRIDE
935 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
936 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
937 switch_to_section (get_section (buf
, flags
, NULL
));
938 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
942 TREE_CHAIN (decl
) = utf8_decl_list
;
943 layout_decl (decl
, 0);
945 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
946 varpool_mark_needed_node (varpool_node (decl
));
947 utf8_decl_list
= decl
;
948 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
949 IDENTIFIER_UTF8_REF (name
) = ref
;
953 /* Like build_class_ref, but instead of a direct reference generate a
954 pointer into the constant pool. */
957 build_indirect_class_ref (tree type
)
961 index
= alloc_class_constant (type
);
962 cl
= build_ref_from_constant_pool (index
);
963 return convert (promote_type (class_ptr_type
), cl
);
967 build_static_class_ref (tree type
)
969 tree decl_name
, decl
, ref
;
971 if (TYPE_SIZE (type
) == error_mark_node
)
972 return null_pointer_node
;
973 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
974 "", '/', '/', ".class$$");
975 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
976 if (decl
== NULL_TREE
)
978 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
979 TREE_STATIC (decl
) = 1;
980 if (! flag_indirect_classes
)
982 TREE_PUBLIC (decl
) = 1;
983 if (CLASS_PRIVATE (TYPE_NAME (type
)))
986 DECL_IGNORED_P (decl
) = 1;
987 DECL_ARTIFICIAL (decl
) = 1;
988 if (is_compiled_class (type
) == 1)
989 DECL_EXTERNAL (decl
) = 1;
990 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
991 DECL_CLASS_FIELD_P (decl
) = 1;
992 DECL_CONTEXT (decl
) = type
;
994 /* ??? We want to preserve the DECL_CONTEXT we set just above,
995 that that means not calling pushdecl_top_level. */
996 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
999 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1004 build_classdollar_field (tree type
)
1006 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1007 "", '/', '/', ".class$");
1008 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1010 if (decl
== NULL_TREE
)
1013 = build_decl (VAR_DECL
, decl_name
,
1016 (build_type_variant (class_type_node
,
1018 /* const */ 1, 0)));
1019 TREE_STATIC (decl
) = 1;
1020 TREE_INVARIANT (decl
) = 1;
1021 TREE_CONSTANT (decl
) = 1;
1022 TREE_READONLY (decl
) = 1;
1023 TREE_PUBLIC (decl
) = 1;
1025 DECL_IGNORED_P (decl
) = 1;
1026 DECL_ARTIFICIAL (decl
) = 1;
1027 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1028 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1029 DECL_CLASS_FIELD_P (decl
) = 1;
1030 DECL_CONTEXT (decl
) = type
;
1036 /* Create a local variable that holds the current class$. */
1039 cache_this_class_ref (tree fndecl
)
1043 tree classdollar_field
;
1044 if (flag_indirect_classes
)
1045 classdollar_field
= build_classdollar_field (output_class
);
1047 classdollar_field
= build_static_class_ref (output_class
);
1049 this_classdollar
= build_decl (VAR_DECL
, NULL_TREE
,
1050 TREE_TYPE (classdollar_field
));
1052 java_add_local_var (this_classdollar
);
1053 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1054 this_classdollar
, classdollar_field
));
1057 this_classdollar
= build_classdollar_field (output_class
);
1059 /* Prepend class initialization for static methods reachable from
1061 if (METHOD_STATIC (fndecl
)
1062 && (! METHOD_PRIVATE (fndecl
)
1063 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1064 && ! DECL_CLINIT_P (fndecl
)
1065 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1067 tree init
= build_call_expr (soft_initclass_node
, 1,
1069 java_add_stmt (init
);
1073 /* Remove the reference to the local variable that holds the current
1077 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1079 this_classdollar
= build_classdollar_field (output_class
);
1082 /* Build a reference to the class TYPE.
1083 Also handles primitive types and array types. */
1086 build_class_ref (tree type
)
1088 int is_compiled
= is_compiled_class (type
);
1092 if (TREE_CODE (type
) == POINTER_TYPE
)
1093 type
= TREE_TYPE (type
);
1095 if (flag_indirect_dispatch
1096 && type
!= output_class
1097 && TREE_CODE (type
) == RECORD_TYPE
)
1098 return build_indirect_class_ref (type
);
1100 if (type
== output_class
&& flag_indirect_classes
)
1101 return this_classdollar
;
1103 if (TREE_CODE (type
) == RECORD_TYPE
)
1104 return build_static_class_ref (type
);
1110 decl_name
= TYPE_NAME (type
);
1111 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1112 decl_name
= DECL_NAME (decl_name
);
1113 name
= IDENTIFIER_POINTER (decl_name
);
1114 if (strncmp (name
, "promoted_", 9) == 0)
1116 sprintf (buffer
, "_Jv_%sClass", name
);
1117 decl_name
= get_identifier (buffer
);
1118 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1119 if (decl
== NULL_TREE
)
1121 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
1122 TREE_STATIC (decl
) = 1;
1123 TREE_PUBLIC (decl
) = 1;
1124 DECL_EXTERNAL (decl
) = 1;
1125 DECL_ARTIFICIAL (decl
) = 1;
1126 pushdecl_top_level (decl
);
1130 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1134 return build_indirect_class_ref (type
);
1137 /* Create a local statically allocated variable that will hold a
1138 pointer to a static field. */
1141 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1143 tree decl
, decl_name
;
1144 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1145 char *buf
= alloca (strlen (name
) + 20);
1146 sprintf (buf
, "%s_%d_ref", name
, index
);
1147 decl_name
= get_identifier (buf
);
1148 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1149 if (decl
== NULL_TREE
)
1151 decl
= build_decl (VAR_DECL
, decl_name
, ptr_type_node
);
1152 TREE_STATIC (decl
) = 1;
1153 TREE_PUBLIC (decl
) = 0;
1154 DECL_EXTERNAL (decl
) = 0;
1155 DECL_ARTIFICIAL (decl
) = 1;
1156 DECL_IGNORED_P (decl
) = 1;
1157 pushdecl_top_level (decl
);
1163 build_static_field_ref (tree fdecl
)
1165 tree fclass
= DECL_CONTEXT (fdecl
);
1166 int is_compiled
= is_compiled_class (fclass
);
1167 int from_class
= ! CLASS_FROM_SOURCE_P (current_class
);
1169 /* Allow static final fields to fold to a constant. When using
1170 -findirect-dispatch, we simply never do this folding if compiling
1171 from .class; in the .class file constants will be referred to via
1172 the constant pool. */
1173 if ((!flag_indirect_dispatch
|| !from_class
)
1175 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1176 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1177 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1178 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1180 if (is_compiled
== 1)
1181 DECL_EXTERNAL (fdecl
) = 1;
1185 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1186 and a class local static variable CACHE_ENTRY, then
1188 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1189 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1192 This can mostly be optimized away, so that the usual path is a
1193 load followed by a test and branch. _Jv_ResolvePoolEntry is
1194 only called once for each constant pool entry.
1196 There is an optimization that we don't do: at the start of a
1197 method, create a local copy of CACHE_ENTRY and use that instead.
1201 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1202 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1204 = build_call_expr (built_in_decls
[BUILT_IN_EXPECT
], 2,
1205 build2 (EQ_EXPR
, boolean_type_node
,
1206 cache_entry
, null_pointer_node
),
1207 boolean_false_node
);
1208 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1210 = build_call_expr (soft_resolvepoolentry_node
, 2,
1211 build_class_ref (output_class
),
1213 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1214 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1215 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1216 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1222 get_access_flags_from_decl (tree decl
)
1224 int access_flags
= 0;
1225 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1227 if (FIELD_STATIC (decl
))
1228 access_flags
|= ACC_STATIC
;
1229 if (FIELD_PUBLIC (decl
))
1230 access_flags
|= ACC_PUBLIC
;
1231 if (FIELD_PROTECTED (decl
))
1232 access_flags
|= ACC_PROTECTED
;
1233 if (FIELD_PRIVATE (decl
))
1234 access_flags
|= ACC_PRIVATE
;
1235 if (FIELD_FINAL (decl
))
1236 access_flags
|= ACC_FINAL
;
1237 if (FIELD_VOLATILE (decl
))
1238 access_flags
|= ACC_VOLATILE
;
1239 if (FIELD_TRANSIENT (decl
))
1240 access_flags
|= ACC_TRANSIENT
;
1241 if (FIELD_ENUM (decl
))
1242 access_flags
|= ACC_ENUM
;
1243 if (FIELD_SYNTHETIC (decl
))
1244 access_flags
|= ACC_SYNTHETIC
;
1245 return access_flags
;
1247 if (TREE_CODE (decl
) == TYPE_DECL
)
1249 if (CLASS_PUBLIC (decl
))
1250 access_flags
|= ACC_PUBLIC
;
1251 if (CLASS_FINAL (decl
))
1252 access_flags
|= ACC_FINAL
;
1253 if (CLASS_SUPER (decl
))
1254 access_flags
|= ACC_SUPER
;
1255 if (CLASS_INTERFACE (decl
))
1256 access_flags
|= ACC_INTERFACE
;
1257 if (CLASS_ABSTRACT (decl
))
1258 access_flags
|= ACC_ABSTRACT
;
1259 if (CLASS_STATIC (decl
))
1260 access_flags
|= ACC_STATIC
;
1261 if (CLASS_PRIVATE (decl
))
1262 access_flags
|= ACC_PRIVATE
;
1263 if (CLASS_PROTECTED (decl
))
1264 access_flags
|= ACC_PROTECTED
;
1265 if (CLASS_STRICTFP (decl
))
1266 access_flags
|= ACC_STRICT
;
1267 if (CLASS_ENUM (decl
))
1268 access_flags
|= ACC_ENUM
;
1269 if (CLASS_SYNTHETIC (decl
))
1270 access_flags
|= ACC_SYNTHETIC
;
1271 if (CLASS_ANNOTATION (decl
))
1272 access_flags
|= ACC_ANNOTATION
;
1273 return access_flags
;
1275 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1277 if (METHOD_PUBLIC (decl
))
1278 access_flags
|= ACC_PUBLIC
;
1279 if (METHOD_PRIVATE (decl
))
1280 access_flags
|= ACC_PRIVATE
;
1281 if (METHOD_PROTECTED (decl
))
1282 access_flags
|= ACC_PROTECTED
;
1283 if (METHOD_STATIC (decl
))
1284 access_flags
|= ACC_STATIC
;
1285 if (METHOD_FINAL (decl
))
1286 access_flags
|= ACC_FINAL
;
1287 if (METHOD_SYNCHRONIZED (decl
))
1288 access_flags
|= ACC_SYNCHRONIZED
;
1289 if (METHOD_NATIVE (decl
))
1290 access_flags
|= ACC_NATIVE
;
1291 if (METHOD_ABSTRACT (decl
))
1292 access_flags
|= ACC_ABSTRACT
;
1293 if (METHOD_STRICTFP (decl
))
1294 access_flags
|= ACC_STRICT
;
1295 if (METHOD_INVISIBLE (decl
))
1296 access_flags
|= ACC_INVISIBLE
;
1297 if (DECL_ARTIFICIAL (decl
))
1298 access_flags
|= ACC_SYNTHETIC
;
1299 if (METHOD_BRIDGE (decl
))
1300 access_flags
|= ACC_BRIDGE
;
1301 if (METHOD_VARARGS (decl
))
1302 access_flags
|= ACC_VARARGS
;
1303 return access_flags
;
1308 static GTY (()) int alias_labelno
= 0;
1310 /* Create a private alias for METHOD. Using this alias instead of the method
1311 decl ensures that ncode entries in the method table point to the real function
1312 at runtime, not a PLT entry. */
1315 make_local_function_alias (tree method
)
1317 #ifdef ASM_OUTPUT_DEF
1320 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1321 char *name
= alloca (strlen (method_name
) + 2);
1322 char *buf
= alloca (strlen (method_name
) + 128);
1324 /* Only create aliases for local functions. */
1325 if (DECL_EXTERNAL (method
))
1328 /* Prefix method_name with 'L' for the alias label. */
1330 strcpy (name
+ 1, method_name
);
1332 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1333 alias
= build_decl (FUNCTION_DECL
, get_identifier (buf
),
1334 TREE_TYPE (method
));
1335 DECL_CONTEXT (alias
) = NULL
;
1336 TREE_READONLY (alias
) = TREE_READONLY (method
);
1337 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1338 TREE_PUBLIC (alias
) = 0;
1339 DECL_EXTERNAL (alias
) = 0;
1340 DECL_ARTIFICIAL (alias
) = 1;
1341 DECL_INLINE (alias
) = 0;
1342 DECL_INITIAL (alias
) = error_mark_node
;
1343 TREE_ADDRESSABLE (alias
) = 1;
1344 TREE_USED (alias
) = 1;
1345 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1346 if (!flag_syntax_only
)
1347 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1354 /** Make reflection data (_Jv_Field) for field FDECL. */
1357 make_field_value (tree fdecl
)
1361 tree type
= TREE_TYPE (fdecl
);
1362 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1364 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1365 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1367 type
= build_class_ref (type
);
1370 tree signature
= build_java_signature (type
);
1372 type
= build_utf8_ref (unmangle_classname
1373 (IDENTIFIER_POINTER (signature
),
1374 IDENTIFIER_LENGTH (signature
)));
1376 PUSH_FIELD_VALUE (finit
, "type", type
);
1378 flags
= get_access_flags_from_decl (fdecl
);
1380 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1382 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1383 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1386 tree field_address
= integer_zero_node
;
1387 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1388 && FIELD_STATIC (fdecl
))
1389 field_address
= build_address_of (fdecl
);
1393 build_constructor_from_list (field_info_union_node
,
1395 ((FIELD_STATIC (fdecl
)
1396 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1397 : TYPE_FIELDS (field_info_union_node
)),
1398 (FIELD_STATIC (fdecl
)
1400 : byte_position (fdecl
)))));
1403 FINISH_RECORD_CONSTRUCTOR (finit
);
1407 /** Make reflection data (_Jv_Method) for method MDECL. */
1410 make_method_value (tree mdecl
)
1412 static int method_name_count
= 0;
1417 #define ACC_TRANSLATED 0x4000
1418 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1420 class_decl
= DECL_CONTEXT (mdecl
);
1421 /* For interfaces, the index field contains the dispatch index. */
1422 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1423 index
= build_int_cst (NULL_TREE
,
1424 get_interface_method_index (mdecl
, class_decl
));
1425 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1426 index
= get_method_index (mdecl
);
1428 index
= integer_minus_one_node
;
1430 code
= null_pointer_node
;
1431 if (METHOD_ABSTRACT (mdecl
))
1432 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1433 soft_abstractmethod_node
);
1435 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1436 make_local_function_alias (mdecl
));
1437 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1438 PUSH_FIELD_VALUE (minit
, "name",
1439 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1440 init_identifier_node
1441 : DECL_NAME (mdecl
)));
1443 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1444 PUSH_FIELD_VALUE (minit
, "signature",
1447 (IDENTIFIER_POINTER(signature
),
1448 IDENTIFIER_LENGTH(signature
)))));
1450 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1451 PUSH_FIELD_VALUE (minit
, "index", index
);
1452 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1455 /* Compute the `throws' information for the method. */
1456 tree table
= null_pointer_node
;
1457 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1459 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1460 tree iter
, type
, array
;
1463 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1464 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1466 iter
= TREE_CHAIN (iter
))
1468 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1470 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1471 IDENTIFIER_LENGTH (sig
)));
1472 table
= tree_cons (NULL_TREE
, utf8
, table
);
1474 type
= build_prim_array_type (ptr_type_node
, length
);
1475 table
= build_constructor_from_list (type
, table
);
1476 /* Compute something unique enough. */
1477 sprintf (buf
, "_methods%d", method_name_count
++);
1478 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1479 DECL_INITIAL (array
) = table
;
1480 TREE_STATIC (array
) = 1;
1481 DECL_ARTIFICIAL (array
) = 1;
1482 DECL_IGNORED_P (array
) = 1;
1483 rest_of_decl_compilation (array
, 1, 0);
1485 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1488 PUSH_FIELD_VALUE (minit
, "throws", table
);
1491 FINISH_RECORD_CONSTRUCTOR (minit
);
1496 get_dispatch_vector (tree type
)
1498 tree vtable
= TYPE_VTABLE (type
);
1500 if (vtable
== NULL_TREE
)
1504 tree super
= CLASSTYPE_SUPER (type
);
1505 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1506 vtable
= make_tree_vec (nvirtuals
);
1507 TYPE_VTABLE (type
) = vtable
;
1508 if (super
!= NULL_TREE
)
1510 tree super_vtable
= get_dispatch_vector (super
);
1512 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1513 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1516 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1517 method
= TREE_CHAIN (method
))
1519 tree method_index
= get_method_index (method
);
1520 if (method_index
!= NULL_TREE
1521 && host_integerp (method_index
, 0))
1522 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1530 get_dispatch_table (tree type
, tree this_class_addr
)
1532 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1533 tree vtable
= get_dispatch_vector (type
);
1535 tree list
= NULL_TREE
;
1536 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1540 for (i
= nvirtuals
; --i
>= 0; )
1542 tree method
= TREE_VEC_ELT (vtable
, i
);
1543 if (METHOD_ABSTRACT (method
))
1546 warning (0, "%Jabstract method in non-abstract class", method
);
1548 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1549 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1550 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1552 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1556 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1557 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1559 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1560 method
, build_int_cst (NULL_TREE
, j
));
1561 TREE_CONSTANT (fdesc
) = 1;
1562 TREE_INVARIANT (fdesc
) = 1;
1563 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1566 list
= tree_cons (NULL_TREE
,
1567 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1573 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1574 using the Boehm GC we sometimes stash a GC type descriptor
1575 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1576 the emitted byte count during the output to the assembly file. */
1577 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1578 fake "function descriptor". It's first word is the is the class
1579 pointer, and subsequent words (usually one) contain the GC descriptor.
1580 In all other cases, we reserve two extra vtable slots. */
1581 gc_descr
= get_boehm_type_descriptor (type
);
1582 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1583 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1584 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1585 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1587 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1588 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1589 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1590 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1592 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1593 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1594 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1596 return build_constructor_from_list
1597 (build_prim_array_type (nativecode_ptr_type_node
,
1602 /* Set the method_index for a method decl. */
1604 set_method_index (tree decl
, tree method_index
)
1606 if (method_index
!= NULL_TREE
)
1608 /* method_index is null if we're using indirect dispatch. */
1609 method_index
= fold (convert (sizetype
, method_index
));
1611 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1612 /* Add one to skip bogus descriptor for class and GC descriptor. */
1613 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1615 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1617 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1620 DECL_VINDEX (decl
) = method_index
;
1623 /* Get the method_index for a method decl. */
1625 get_method_index (tree decl
)
1627 tree method_index
= DECL_VINDEX (decl
);
1632 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1633 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1634 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1636 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1637 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1639 return method_index
;
1643 supers_all_compiled (tree type
)
1645 while (type
!= NULL_TREE
)
1647 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1649 type
= CLASSTYPE_SUPER (type
);
1655 make_class_data (tree type
)
1657 tree decl
, cons
, temp
;
1658 tree field
, fields_decl
;
1659 tree static_fields
= NULL_TREE
;
1660 tree instance_fields
= NULL_TREE
;
1661 HOST_WIDE_INT static_field_count
= 0;
1662 HOST_WIDE_INT instance_field_count
= 0;
1663 HOST_WIDE_INT field_count
;
1664 tree field_array_type
;
1666 tree methods
= NULL_TREE
;
1667 tree dtable_decl
= NULL_TREE
;
1668 HOST_WIDE_INT method_count
= 0;
1669 tree method_array_type
;
1672 tree this_class_addr
;
1673 tree constant_pool_constructor
;
1674 tree interfaces
= null_pointer_node
;
1675 int interface_len
= 0;
1676 int uses_jv_markobj
= 0;
1677 tree type_decl
= TYPE_NAME (type
);
1678 tree id_main
= get_identifier("main");
1679 tree id_class
= get_identifier("java.lang.Class");
1680 /** Offset from start of virtual function table declaration
1681 to where objects actually point at, following new g++ ABI. */
1682 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1683 VEC(int, heap
) *field_indexes
;
1684 tree first_real_field
;
1686 this_class_addr
= build_static_class_ref (type
);
1687 decl
= TREE_OPERAND (this_class_addr
, 0);
1689 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1690 && !flag_indirect_dispatch
)
1692 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1693 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1694 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1696 /* We've already created some other class, and consequently
1697 we made class_dtable_decl. Now we just want to fill it
1699 dtable_decl
= class_dtable_decl
;
1703 dtable_decl
= build_dtable_decl (type
);
1704 TREE_STATIC (dtable_decl
) = 1;
1705 DECL_ARTIFICIAL (dtable_decl
) = 1;
1706 DECL_IGNORED_P (dtable_decl
) = 1;
1709 TREE_PUBLIC (dtable_decl
) = 1;
1710 DECL_INITIAL (dtable_decl
) = dtable
;
1711 /* The only dispatch table exported from a DSO is the dispatch
1712 table for java.lang.Class. */
1713 if (DECL_NAME (type_decl
) != id_class
)
1715 if (! flag_indirect_classes
)
1716 rest_of_decl_compilation (dtable_decl
, 1, 0);
1717 /* Maybe we're compiling Class as the first class. If so, set
1718 class_dtable_decl to the decl we just made. */
1719 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1720 class_dtable_decl
= dtable_decl
;
1723 /* Build Field array. */
1724 field
= TYPE_FIELDS (type
);
1725 while (field
&& DECL_ARTIFICIAL (field
))
1726 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1727 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1728 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1729 first_real_field
= field
;
1731 /* First count static and instance fields. */
1732 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1734 if (! DECL_ARTIFICIAL (field
))
1736 if (FIELD_STATIC (field
))
1737 static_field_count
++;
1738 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1739 instance_field_count
++;
1742 field_count
= static_field_count
+ instance_field_count
;
1743 field_indexes
= VEC_alloc (int, heap
, field_count
);
1745 /* gcj sorts fields so that static fields come first, followed by
1746 instance fields. Unfortunately, by the time this takes place we
1747 have already generated the reflection_data for this class, and
1748 that data contains indexes into the fields. So, we generate a
1749 permutation that maps each original field index to its final
1750 position. Then we pass this permutation to
1751 rewrite_reflection_indexes(), which fixes up the reflection
1755 int static_count
= 0;
1756 int instance_count
= static_field_count
;
1759 for (i
= 0, field
= first_real_field
;
1761 field
= TREE_CHAIN (field
), i
++)
1763 if (! DECL_ARTIFICIAL (field
))
1766 if (FIELD_STATIC (field
))
1767 field_index
= static_count
++;
1768 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1769 field_index
= instance_count
++;
1770 VEC_quick_push (int, field_indexes
, field_index
);
1775 for (field
= first_real_field
; field
!= NULL_TREE
;
1776 field
= TREE_CHAIN (field
))
1778 if (! DECL_ARTIFICIAL (field
))
1780 if (FIELD_STATIC (field
))
1782 /* We must always create reflection data for static fields
1783 as it is used in the creation of the field itself. */
1784 tree init
= make_field_value (field
);
1785 tree initial
= DECL_INITIAL (field
);
1786 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1787 /* If the initial value is a string constant,
1788 prevent output_constant from trying to assemble the value. */
1789 if (initial
!= NULL_TREE
1790 && TREE_TYPE (initial
) == string_ptr_type_node
)
1791 DECL_INITIAL (field
) = NULL_TREE
;
1792 rest_of_decl_compilation (field
, 1, 1);
1793 DECL_INITIAL (field
) = initial
;
1795 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1797 tree init
= make_field_value (field
);
1798 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1803 if (field_count
> 0)
1805 static_fields
= nreverse (static_fields
);
1806 instance_fields
= nreverse (instance_fields
);
1807 static_fields
= chainon (static_fields
, instance_fields
);
1808 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1809 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1811 DECL_INITIAL (fields_decl
) = build_constructor_from_list
1812 (field_array_type
, static_fields
);
1813 TREE_STATIC (fields_decl
) = 1;
1814 DECL_ARTIFICIAL (fields_decl
) = 1;
1815 DECL_IGNORED_P (fields_decl
) = 1;
1816 rest_of_decl_compilation (fields_decl
, 1, 0);
1819 fields_decl
= NULL_TREE
;
1821 /* Build Method array. */
1822 for (method
= TYPE_METHODS (type
);
1823 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1826 if (METHOD_PRIVATE (method
)
1827 && ! flag_keep_inline_functions
1830 /* Even if we have a decl, we don't necessarily have the code.
1831 This can happen if we inherit a method from a superclass for
1832 which we don't have a .class file. */
1833 if (METHOD_DUMMY (method
))
1836 /* Generate method reflection data if:
1838 - !flag_reduced_reflection.
1840 - <clinit> -- The runtime uses reflection to initialize the
1843 - Any method in class java.lang.Class -- Class.forName() and
1844 perhaps other things require it.
1846 - class$ -- It does not work if reflection data missing.
1848 - main -- Reflection is used to find main(String[]) methods.
1850 - public not static -- It is potentially part of an
1851 interface. The runtime uses reflection data to build
1852 interface dispatch tables. */
1853 if (!flag_reduced_reflection
1854 || DECL_CLINIT_P (method
)
1855 || DECL_NAME (type_decl
) == id_class
1856 || DECL_NAME (method
) == id_main
1857 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
))
1858 || TYPE_DOT_CLASS (type
) == method
)
1860 init
= make_method_value (method
);
1862 methods
= tree_cons (NULL_TREE
, init
, methods
);
1865 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1866 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1868 DECL_INITIAL (methods_decl
) = build_constructor_from_list
1869 (method_array_type
, nreverse (methods
));
1870 TREE_STATIC (methods_decl
) = 1;
1871 DECL_ARTIFICIAL (methods_decl
) = 1;
1872 DECL_IGNORED_P (methods_decl
) = 1;
1873 rest_of_decl_compilation (methods_decl
, 1, 0);
1875 if (class_dtable_decl
== NULL_TREE
)
1877 class_dtable_decl
= build_dtable_decl (class_type_node
);
1878 TREE_STATIC (class_dtable_decl
) = 1;
1879 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1880 DECL_IGNORED_P (class_dtable_decl
) = 1;
1881 if (is_compiled_class (class_type_node
) != 2)
1883 DECL_EXTERNAL (class_dtable_decl
) = 1;
1884 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1888 super
= CLASSTYPE_SUPER (type
);
1889 if (super
== NULL_TREE
)
1890 super
= null_pointer_node
;
1891 else if (! flag_indirect_dispatch
1892 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1893 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1894 super
= build_class_ref (super
);
1897 int super_index
= alloc_class_constant (super
);
1898 super
= build_int_cst (ptr_type_node
, super_index
);
1901 /* Build and emit the array of implemented interfaces. */
1902 if (type
!= object_type_node
)
1903 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1905 if (interface_len
> 0)
1907 tree init
= NULL_TREE
;
1909 tree interface_array_type
, idecl
;
1910 interface_array_type
1911 = build_prim_array_type (class_ptr_type
, interface_len
);
1912 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1913 interface_array_type
);
1915 for (i
= interface_len
; i
> 0; i
--)
1917 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1918 tree iclass
= BINFO_TYPE (child
);
1920 if (! flag_indirect_dispatch
1922 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1923 index
= build_class_ref (iclass
);
1926 int int_index
= alloc_class_constant (iclass
);
1927 index
= build_int_cst (ptr_type_node
, int_index
);
1929 init
= tree_cons (NULL_TREE
, index
, init
);
1931 DECL_INITIAL (idecl
) = build_constructor_from_list (interface_array_type
,
1933 TREE_STATIC (idecl
) = 1;
1934 DECL_ARTIFICIAL (idecl
) = 1;
1935 DECL_IGNORED_P (idecl
) = 1;
1936 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1937 rest_of_decl_compilation (idecl
, 1, 0);
1940 constant_pool_constructor
= build_constants_constructor ();
1942 if (flag_indirect_dispatch
)
1944 TYPE_OTABLE_DECL (type
)
1946 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
1947 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
1948 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
1950 TYPE_ATABLE_DECL (type
)
1952 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
1953 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
1954 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
1956 TYPE_ITABLE_DECL (type
)
1958 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
1959 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
1960 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
1963 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
1965 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
1966 PUSH_FIELD_VALUE (temp
, "vtable",
1967 (flag_indirect_classes
1969 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
1970 build1 (ADDR_EXPR
, dtable_ptr_type
,
1972 dtable_start_offset
)));
1973 if (! flag_hash_synchronization
)
1974 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
1975 FINISH_RECORD_CONSTRUCTOR (temp
);
1976 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
1977 PUSH_SUPER_VALUE (cons
, temp
);
1978 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
1979 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
1980 PUSH_FIELD_VALUE (cons
, "accflags",
1981 build_int_cst (NULL_TREE
,
1982 get_access_flags_from_decl (type_decl
)));
1984 PUSH_FIELD_VALUE (cons
, "superclass",
1985 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
1986 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
1987 PUSH_FIELD_VALUE (cons
, "methods",
1988 methods_decl
== NULL_TREE
? null_pointer_node
1989 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
1990 PUSH_FIELD_VALUE (cons
, "method_count",
1991 build_int_cst (NULL_TREE
, method_count
));
1993 if (flag_indirect_dispatch
)
1994 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
1996 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
1998 PUSH_FIELD_VALUE (cons
, "fields",
1999 fields_decl
== NULL_TREE
? null_pointer_node
2000 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2001 /* If we're using the binary compatibility ABI we don't know the
2002 size until load time. */
2003 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
2004 (flag_indirect_dispatch
2005 ? integer_minus_one_node
2006 : size_in_bytes (type
)));
2007 PUSH_FIELD_VALUE (cons
, "field_count",
2008 build_int_cst (NULL_TREE
, field_count
));
2009 PUSH_FIELD_VALUE (cons
, "static_field_count",
2010 build_int_cst (NULL_TREE
, static_field_count
));
2012 if (flag_indirect_dispatch
)
2013 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
2015 PUSH_FIELD_VALUE (cons
, "vtable",
2016 dtable_decl
== NULL_TREE
? null_pointer_node
2017 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2018 build1 (ADDR_EXPR
, dtable_ptr_type
,
2020 dtable_start_offset
));
2021 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
2023 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
2024 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
2028 pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type
));
2029 PUSH_FIELD_VALUE (cons
, "otable",
2030 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
2031 PUSH_FIELD_VALUE (cons
, "otable_syms",
2032 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2033 TYPE_OTABLE_SYMS_DECL (type
)));
2034 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
2035 TREE_INVARIANT (TYPE_OTABLE_DECL (type
)) = 1;
2037 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
2039 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
2040 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
2044 pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type
));
2045 PUSH_FIELD_VALUE (cons
, "atable",
2046 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
2047 PUSH_FIELD_VALUE (cons
, "atable_syms",
2048 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2049 TYPE_ATABLE_SYMS_DECL (type
)));
2050 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
2051 TREE_INVARIANT (TYPE_ATABLE_DECL (type
)) = 1;
2053 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
2055 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
2056 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
2060 pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type
));
2061 PUSH_FIELD_VALUE (cons
, "itable",
2062 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
2063 PUSH_FIELD_VALUE (cons
, "itable_syms",
2064 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2065 TYPE_ITABLE_SYMS_DECL (type
)));
2066 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
2067 TREE_INVARIANT (TYPE_ITABLE_DECL (type
)) = 1;
2070 PUSH_FIELD_VALUE (cons
, "catch_classes",
2071 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2072 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
2073 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
2074 PUSH_FIELD_VALUE (cons
, "interface_count",
2075 build_int_cst (NULL_TREE
, interface_len
));
2076 PUSH_FIELD_VALUE (cons
, "state",
2077 convert (byte_type_node
,
2078 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2080 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
2081 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
2082 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
2083 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
2084 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
2085 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
2088 tree assertion_table_ref
;
2089 if (TYPE_ASSERTIONS (type
) == NULL
)
2090 assertion_table_ref
= null_pointer_node
;
2092 assertion_table_ref
= build1 (ADDR_EXPR
,
2093 build_pointer_type (assertion_table_type
),
2094 emit_assertion_table (type
));
2096 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
2099 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
2100 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
2101 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
2102 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
2104 if (TYPE_REFLECTION_DATA (current_class
))
2107 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2108 VEC (constructor_elt
, gc
) *v
2109 = VEC_alloc (constructor_elt
, gc
, count
);
2110 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2111 tree max_index
= build_int_cst (sizetype
, count
);
2112 tree index
= build_index_type (max_index
);
2113 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2116 static int reflection_data_count
;
2118 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2119 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
2121 rewrite_reflection_indexes (field_indexes
);
2123 for (i
= 0; i
< count
; i
++)
2125 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
2126 elt
->index
= build_int_cst (sizetype
, i
);
2127 elt
->value
= build_int_cstu (byte_type_node
, data
[i
]);
2130 DECL_INITIAL (array
) = build_constructor (type
, v
);
2131 TREE_STATIC (array
) = 1;
2132 DECL_ARTIFICIAL (array
) = 1;
2133 DECL_IGNORED_P (array
) = 1;
2134 TREE_READONLY (array
) = 1;
2135 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2136 rest_of_decl_compilation (array
, 1, 0);
2138 PUSH_FIELD_VALUE (cons
, "reflection_data", build_address_of (array
));
2141 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2144 PUSH_FIELD_VALUE (cons
, "reflection_data", null_pointer_node
);
2146 FINISH_RECORD_CONSTRUCTOR (cons
);
2148 DECL_INITIAL (decl
) = cons
;
2150 /* Hash synchronization requires at least 64-bit alignment. */
2151 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2152 DECL_ALIGN (decl
) = 64;
2154 if (flag_indirect_classes
)
2156 TREE_READONLY (decl
) = 1;
2157 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2160 rest_of_decl_compilation (decl
, 1, 0);
2163 tree classdollar_field
= build_classdollar_field (type
);
2164 if (!flag_indirect_classes
)
2165 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2166 rest_of_decl_compilation (classdollar_field
, 1, 0);
2169 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2170 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2171 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2177 if (TYPE_VERIFY_METHOD (output_class
))
2179 tree verify_method
= TYPE_VERIFY_METHOD (output_class
);
2180 DECL_SAVED_TREE (verify_method
)
2181 = add_stmt_to_compound (DECL_SAVED_TREE (verify_method
), void_type_node
,
2182 build1 (RETURN_EXPR
, void_type_node
, NULL
));
2183 java_genericize (verify_method
);
2184 cgraph_finalize_function (verify_method
, false);
2185 TYPE_ASSERTIONS (current_class
) = NULL
;
2188 java_expand_catch_classes (current_class
);
2190 current_function_decl
= NULL_TREE
;
2191 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2192 make_class_data (current_class
);
2194 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2197 /* Return 2 if CLASS is compiled by this compilation job;
2198 return 1 if CLASS can otherwise be assumed to be compiled;
2199 return 0 if we cannot assume that CLASS is compiled.
2200 Returns 1 for primitive and 0 for array types. */
2202 is_compiled_class (tree
class)
2205 if (TREE_CODE (class) == POINTER_TYPE
)
2206 class = TREE_TYPE (class);
2207 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
2209 if (TYPE_ARRAY_P (class))
2212 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
2213 if (CLASS_FROM_CURRENTLY_COMPILED_P (class))
2215 /* The class was seen in the current ZIP file and will be
2216 available as a compiled class in the future but may not have
2217 been loaded already. Load it if necessary. This prevent
2218 build_class_ref () from crashing. */
2220 if (seen_in_zip
&& !CLASS_LOADED_P (class) && (class != current_class
))
2221 load_class (class, 1);
2223 /* We return 2 for class seen in ZIP and class from files
2224 belonging to the same compilation unit */
2228 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
2230 if (!CLASS_LOADED_P (class))
2232 if (CLASS_FROM_SOURCE_P (class))
2233 safe_layout_class (class);
2234 else if (class != current_class
)
2235 load_class (class, 1);
2243 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2246 build_dtable_decl (tree type
)
2250 /* We need to build a new dtable type so that its size is uniquely
2251 computed when we're dealing with the class for real and not just
2252 faking it (like java.lang.Class during the initialization of the
2253 compiler.) We know we're not faking a class when CURRENT_CLASS is
2255 if (current_class
== type
)
2257 tree dummy
= NULL_TREE
;
2260 dtype
= make_node (RECORD_TYPE
);
2262 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
2263 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
2265 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
2266 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2268 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2269 TREE_CHAIN (dummy
) = tmp_field
;
2270 DECL_CONTEXT (tmp_field
) = dtype
;
2271 DECL_ARTIFICIAL (tmp_field
) = 1;
2275 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
2276 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2278 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2279 TREE_CHAIN (dummy
) = tmp_field
;
2280 DECL_CONTEXT (tmp_field
) = dtype
;
2281 DECL_ARTIFICIAL (tmp_field
) = 1;
2285 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2286 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2287 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2289 PUSH_FIELD (dtype
, dummy
, "methods",
2290 build_prim_array_type (nativecode_ptr_type_node
, n
));
2291 layout_type (dtype
);
2294 dtype
= dtable_type
;
2296 decl
= build_decl (VAR_DECL
, get_identifier ("vt$"), dtype
);
2297 DECL_CONTEXT (decl
) = type
;
2298 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2299 DECL_VTABLE_P (decl
) = 1;
2304 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2305 fields inherited from SUPER_CLASS. */
2308 push_super_field (tree this_class
, tree super_class
)
2311 /* Don't insert the field if we're just re-laying the class out. */
2312 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2314 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
2315 DECL_IGNORED_P (base_decl
) = 1;
2316 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2317 TYPE_FIELDS (this_class
) = base_decl
;
2318 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2319 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2322 /* Handle the different manners we may have to lay out a super class. */
2325 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2329 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2331 if (!CLASS_LOADED_P (super_class
) && CLASS_FROM_SOURCE_P (super_class
))
2332 safe_layout_class (super_class
);
2333 if (!CLASS_LOADED_P (super_class
))
2334 load_class (super_class
, 1);
2336 /* We might have to layout the class before its dependency on
2337 the super class gets resolved by java_complete_class */
2338 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2340 if (TREE_TYPE (super_class
) != NULL_TREE
)
2341 super_class
= TREE_TYPE (super_class
);
2345 if (!TYPE_SIZE (super_class
))
2346 safe_layout_class (super_class
);
2351 /* safe_layout_class just makes sure that we can load a class without
2352 disrupting the current_class, input_file, input_line, etc, information
2353 about the class processed currently. */
2356 safe_layout_class (tree
class)
2358 tree save_current_class
= current_class
;
2359 location_t save_location
= input_location
;
2361 layout_class (class);
2363 current_class
= save_current_class
;
2364 input_location
= save_location
;
2368 layout_class (tree this_class
)
2370 tree super_class
= CLASSTYPE_SUPER (this_class
);
2372 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2373 if (CLASS_BEING_LAIDOUT (this_class
))
2379 sprintf (buffer
, " with '%s'",
2380 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2381 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2383 for (current
= TREE_CHAIN (class_list
); current
;
2384 current
= TREE_CHAIN (current
))
2386 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2387 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2388 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2389 DECL_SOURCE_FILE (decl
),
2390 DECL_SOURCE_LINE (decl
));
2391 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2393 obstack_1grow (&temporary_obstack
, '\0');
2394 report
= obstack_finish (&temporary_obstack
);
2395 cyclic_inheritance_report
= ggc_strdup (report
);
2396 obstack_free (&temporary_obstack
, report
);
2397 TYPE_SIZE (this_class
) = error_mark_node
;
2400 CLASS_BEING_LAIDOUT (this_class
) = 1;
2402 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2404 tree maybe_super_class
2405 = maybe_layout_super_class (super_class
, this_class
);
2406 if (maybe_super_class
== NULL
2407 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2409 TYPE_SIZE (this_class
) = error_mark_node
;
2410 CLASS_BEING_LAIDOUT (this_class
) = 0;
2411 class_list
= TREE_CHAIN (class_list
);
2414 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2415 push_super_field (this_class
, maybe_super_class
);
2418 layout_type (this_class
);
2420 /* Also recursively load/layout any superinterfaces, but only if
2421 class was loaded from bytecode. The source parser will take care
2423 if (!CLASS_FROM_SOURCE_P (this_class
))
2426 if (TYPE_BINFO (this_class
))
2428 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2430 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2431 tree super_interface
= BINFO_TYPE (binfo
);
2432 tree maybe_super_interface
2433 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2434 if (maybe_super_interface
== NULL
2435 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2437 TYPE_SIZE (this_class
) = error_mark_node
;
2438 CLASS_BEING_LAIDOUT (this_class
) = 0;
2439 class_list
= TREE_CHAIN (class_list
);
2446 /* Convert the size back to an SI integer value. */
2447 TYPE_SIZE_UNIT (this_class
) =
2448 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2450 CLASS_BEING_LAIDOUT (this_class
) = 0;
2451 class_list
= TREE_CHAIN (class_list
);
2455 add_miranda_methods (tree base_class
, tree search_class
)
2458 tree binfo
, base_binfo
;
2460 if (!CLASS_PARSED_P (search_class
))
2461 load_class (search_class
, 1);
2463 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2464 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2467 tree elt
= BINFO_TYPE (base_binfo
);
2469 /* FIXME: This is totally bogus. We should not be handling
2470 Miranda methods at all if we're using the BC ABI. */
2471 if (TYPE_DUMMY (elt
))
2474 /* Ensure that interface methods are seen in declared order. */
2475 if (!CLASS_LOADED_P (elt
))
2476 load_class (elt
, 1);
2477 layout_class_methods (elt
);
2479 /* All base classes will have been laid out at this point, so the order
2480 will be correct. This code must match similar layout code in the
2482 for (method_decl
= TYPE_METHODS (elt
);
2483 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2487 /* An interface can have <clinit>. */
2488 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2491 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2492 override
= lookup_argument_method (base_class
,
2493 DECL_NAME (method_decl
), sig
);
2494 if (override
== NULL_TREE
)
2496 /* Found a Miranda method. Add it. */
2498 sig
= build_java_signature (TREE_TYPE (method_decl
));
2500 = add_method (base_class
,
2501 get_access_flags_from_decl (method_decl
),
2502 DECL_NAME (method_decl
), sig
);
2503 METHOD_INVISIBLE (new_method
) = 1;
2507 /* Try superinterfaces. */
2508 add_miranda_methods (base_class
, elt
);
2513 layout_class_methods (tree this_class
)
2515 tree method_decl
, dtable_count
;
2516 tree super_class
, type_name
;
2518 if (TYPE_NVIRTUALS (this_class
))
2521 super_class
= CLASSTYPE_SUPER (this_class
);
2525 super_class
= maybe_layout_super_class (super_class
, this_class
);
2526 if (!TYPE_NVIRTUALS (super_class
))
2527 layout_class_methods (super_class
);
2528 dtable_count
= TYPE_NVIRTUALS (super_class
);
2531 dtable_count
= integer_zero_node
;
2533 type_name
= TYPE_NAME (this_class
);
2534 if (!flag_indirect_dispatch
2535 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2537 /* An abstract class can have methods which are declared only in
2538 an implemented interface. These are called "Miranda
2539 methods". We make a dummy method entry for such methods
2541 add_miranda_methods (this_class
, this_class
);
2544 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2546 for (method_decl
= TYPE_METHODS (this_class
);
2547 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2548 dtable_count
= layout_class_method (this_class
, super_class
,
2549 method_decl
, dtable_count
);
2551 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2554 /* Return the index of METHOD in INTERFACE. This index begins at 1
2555 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2557 get_interface_method_index (tree method
, tree interface
)
2562 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
))
2566 /* We don't want to put <clinit> into the interface table. */
2567 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2569 gcc_assert (meth
!= NULL_TREE
);
2573 /* Lay METHOD_DECL out, returning a possibly new value of
2574 DTABLE_COUNT. Also mangle the method's name. */
2577 layout_class_method (tree this_class
, tree super_class
,
2578 tree method_decl
, tree dtable_count
)
2580 tree method_name
= DECL_NAME (method_decl
);
2582 TREE_PUBLIC (method_decl
) = 1;
2584 if (flag_indirect_classes
2585 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2586 && ! METHOD_NATIVE (method_decl
)
2587 && ! special_method_p (method_decl
)))
2590 /* Considered external unless it is being compiled into this object
2591 file, or it was already flagged as external. */
2592 if (!DECL_EXTERNAL (method_decl
))
2593 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2594 || METHOD_NATIVE (method_decl
));
2596 if (ID_INIT_P (method_name
))
2598 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2600 for (ptr
= p
; *ptr
; )
2605 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2606 build_java_signature (TREE_TYPE (method_decl
));
2608 else if (! METHOD_STATIC (method_decl
))
2611 build_java_signature (TREE_TYPE (method_decl
));
2612 bool method_override
= false;
2613 tree super_method
= lookup_java_method (super_class
, method_name
,
2615 if (super_method
!= NULL_TREE
2616 && ! METHOD_DUMMY (super_method
))
2618 method_override
= true;
2619 if (! METHOD_PUBLIC (super_method
) &&
2620 ! METHOD_PROTECTED (super_method
))
2622 /* Don't override private method, or default-access method in
2624 if (METHOD_PRIVATE (super_method
) ||
2625 ! in_same_package (TYPE_NAME (this_class
),
2626 TYPE_NAME (super_class
)))
2627 method_override
= false;
2630 if (method_override
)
2632 tree method_index
= get_method_index (super_method
);
2633 set_method_index (method_decl
, method_index
);
2634 if (method_index
== NULL_TREE
2635 && ! flag_indirect_dispatch
2636 && !CLASS_FROM_SOURCE_P (this_class
)
2637 && ! DECL_ARTIFICIAL (super_method
))
2638 error ("non-static method %q+D overrides static method",
2641 else if (this_class
== object_type_node
2642 && (METHOD_FINAL (method_decl
)
2643 || METHOD_PRIVATE (method_decl
)))
2645 /* We don't generate vtable entries for final Object
2646 methods. This is simply to save space, since every
2647 object would otherwise have to define them. */
2649 else if (! METHOD_PRIVATE (method_decl
)
2652 /* We generate vtable entries for final methods because they
2653 may one day be changed to non-final. */
2654 set_method_index (method_decl
, dtable_count
);
2655 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2656 dtable_count
, integer_one_node
);
2660 return dtable_count
;
2664 register_class (void)
2668 if (!registered_class
)
2669 registered_class
= VEC_alloc (tree
, gc
, 8);
2671 if (flag_indirect_classes
)
2672 node
= current_class
;
2674 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2675 VEC_safe_push (tree
, gc
, registered_class
, node
);
2678 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2679 all the classes we have emitted. */
2682 emit_indirect_register_classes (tree
*list_p
)
2684 tree klass
, t
, register_class_fn
;
2687 tree init
= NULL_TREE
;
2688 int size
= VEC_length (tree
, registered_class
) * 2 + 1;
2689 tree class_array_type
2690 = build_prim_array_type (ptr_type_node
, size
);
2691 tree
cdecl = build_decl (VAR_DECL
, get_identifier ("_Jv_CLS"),
2693 tree reg_class_list
;
2694 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2696 init
= tree_cons (NULL_TREE
,
2697 fold_convert (ptr_type_node
,
2698 build_static_class_ref (klass
)), init
);
2701 fold_convert (ptr_type_node
,
2702 build_address_of (build_classdollar_field (klass
))),
2705 init
= tree_cons (NULL_TREE
, integer_zero_node
, init
);
2706 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type
,
2708 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2709 TREE_STATIC (cdecl) = 1;
2710 DECL_ARTIFICIAL (cdecl) = 1;
2711 DECL_IGNORED_P (cdecl) = 1;
2712 TREE_READONLY (cdecl) = 1;
2713 TREE_CONSTANT (cdecl) = 1;
2714 rest_of_decl_compilation (cdecl, 1, 0);
2715 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2717 t
= build_function_type_list (void_type_node
,
2718 build_pointer_type (ptr_type_node
), NULL
);
2719 t
= build_decl (FUNCTION_DECL
,
2720 get_identifier ("_Jv_RegisterNewClasses"), t
);
2721 TREE_PUBLIC (t
) = 1;
2722 DECL_EXTERNAL (t
) = 1;
2723 register_class_fn
= t
;
2724 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2725 append_to_statement_list (t
, list_p
);
2729 /* Emit something to register classes at start-up time.
2731 The preferred mechanism is through the .jcr section, which contain
2732 a list of pointers to classes which get registered during constructor
2735 The fallback mechanism is to add statements to *LIST_P to call
2736 _Jv_RegisterClass for each class in this file. These statements will
2737 be added to a static constructor function for this translation unit. */
2740 emit_register_classes (tree
*list_p
)
2742 if (registered_class
== NULL
)
2745 if (flag_indirect_classes
)
2747 emit_indirect_register_classes (list_p
);
2751 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2752 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2753 but lack suitable crtbegin/end objects or linker support. These
2754 targets can override the default in tm.h to use the fallback mechanism. */
2755 if (TARGET_USE_JCR_SECTION
)
2760 #ifdef JCR_SECTION_NAME
2761 switch_to_section (get_section (JCR_SECTION_NAME
, SECTION_WRITE
, NULL
));
2763 /* A target has defined TARGET_USE_JCR_SECTION,
2764 but doesn't have a JCR_SECTION_NAME. */
2767 assemble_align (POINTER_SIZE
);
2769 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2771 t
= build_fold_addr_expr (klass
);
2772 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2777 tree klass
, t
, register_class_fn
;
2780 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2781 t
= build_decl (FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2782 TREE_PUBLIC (t
) = 1;
2783 DECL_EXTERNAL (t
) = 1;
2784 register_class_fn
= t
;
2786 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2788 t
= build_fold_addr_expr (klass
);
2789 t
= build_call_expr (register_class_fn
, 1, t
);
2790 append_to_statement_list (t
, list_p
);
2795 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2798 build_symbol_entry (tree decl
, tree special
)
2800 tree clname
, name
, signature
, sym
;
2801 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2802 /* ??? Constructors are given the name foo.foo all the way through
2803 the compiler, but in the method table they're all renamed
2804 foo.<init>. So, we have to do the same here unless we want an
2805 unresolved reference at runtime. */
2806 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2807 && DECL_CONSTRUCTOR_P (decl
))
2808 ? init_identifier_node
2809 : DECL_NAME (decl
));
2810 signature
= build_java_signature (TREE_TYPE (decl
));
2811 signature
= build_utf8_ref (unmangle_classname
2812 (IDENTIFIER_POINTER (signature
),
2813 IDENTIFIER_LENGTH (signature
)));
2814 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2815 signature addr+1 if SPECIAL, and this indicates to the runtime
2816 system that this is a "special" symbol, i.e. one that should
2817 bypass access controls. */
2818 if (special
!= NULL_TREE
)
2819 signature
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (signature
), signature
,
2820 fold_convert (sizetype
, special
));
2822 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2823 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2824 PUSH_FIELD_VALUE (sym
, "name", name
);
2825 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2826 FINISH_RECORD_CONSTRUCTOR (sym
);
2827 TREE_CONSTANT (sym
) = 1;
2828 TREE_INVARIANT (sym
) = 1;
2833 /* Emit a symbol table: used by -findirect-dispatch. */
2836 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2837 tree the_syms_decl
, tree the_array_element_type
,
2840 tree method_list
, method
, table
, list
, null_symbol
;
2841 tree table_size
, the_array_type
;
2844 /* Only emit a table if this translation unit actually made any
2845 references via it. */
2846 if (decl_list
== NULL_TREE
)
2849 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2851 method_list
= decl_list
;
2853 while (method_list
!= NULL_TREE
)
2855 tree special
= TREE_PURPOSE (method_list
);
2856 method
= TREE_VALUE (method_list
);
2857 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
, special
), list
);
2858 method_list
= TREE_CHAIN (method_list
);
2862 /* Terminate the list with a "null" entry. */
2863 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2864 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2865 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2866 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2867 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2868 TREE_CONSTANT (null_symbol
) = 1;
2869 TREE_INVARIANT (null_symbol
) = 1;
2870 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2872 /* Put the list in the right order and make it a constructor. */
2873 list
= nreverse (list
);
2874 table
= build_constructor_from_list (symbols_array_type
, list
);
2876 /* Make it the initial value for otable_syms and emit the decl. */
2877 DECL_INITIAL (the_syms_decl
) = table
;
2878 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2879 DECL_IGNORED_P (the_syms_decl
) = 1;
2880 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2882 /* Now that its size is known, redefine the table as an
2883 uninitialized static array of INDEX + 1 elements. The extra entry
2884 is used by the runtime to track whether the table has been
2887 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2888 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2889 the_table
= build_decl (VAR_DECL
, name
, the_array_type
);
2890 TREE_STATIC (the_table
) = 1;
2891 TREE_READONLY (the_table
) = 1;
2892 rest_of_decl_compilation (the_table
, 1, 0);
2897 /* Make an entry for the catch_classes list. */
2899 make_catch_class_record (tree catch_class
, tree classname
)
2902 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2903 START_RECORD_CONSTRUCTOR (entry
, type
);
2904 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2905 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2906 FINISH_RECORD_CONSTRUCTOR (entry
);
2911 /* Generate the list of Throwable classes that are caught by exception
2912 handlers in this class. */
2914 emit_catch_table (tree this_class
)
2916 tree table
, table_size
, array_type
;
2917 TYPE_CATCH_CLASSES (this_class
) =
2919 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2920 TYPE_CATCH_CLASSES (this_class
));
2921 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2922 TYPE_CATCH_CLASSES (this_class
) =
2924 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2925 TYPE_CATCH_CLASSES (this_class
));
2926 table_size
= build_index_type
2927 (build_int_cst (NULL_TREE
,
2928 list_length (TYPE_CATCH_CLASSES (this_class
))));
2930 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2933 build_decl (VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2934 DECL_INITIAL (table
) =
2935 build_constructor_from_list (array_type
, TYPE_CATCH_CLASSES (this_class
));
2936 TREE_STATIC (table
) = 1;
2937 TREE_READONLY (table
) = 1;
2938 DECL_IGNORED_P (table
) = 1;
2939 rest_of_decl_compilation (table
, 1, 0);
2943 /* Given a type, return the signature used by
2944 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2945 same as build_java_signature() because we want the canonical array
2949 build_signature_for_libgcj (tree type
)
2953 sig
= build_java_signature (type
);
2954 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
2955 IDENTIFIER_LENGTH (sig
)));
2959 /* Add an entry to the type assertion table. Callback used during hashtable
2963 add_assertion_table_entry (void **htab_entry
, void *ptr
)
2966 tree code_val
, op1_utf8
, op2_utf8
;
2967 tree
*list
= (tree
*) ptr
;
2968 type_assertion
*as
= (type_assertion
*) *htab_entry
;
2970 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
2972 if (as
->op1
== NULL_TREE
)
2973 op1_utf8
= null_pointer_node
;
2975 op1_utf8
= build_signature_for_libgcj (as
->op1
);
2977 if (as
->op2
== NULL_TREE
)
2978 op2_utf8
= null_pointer_node
;
2980 op2_utf8
= build_signature_for_libgcj (as
->op2
);
2982 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
2983 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
2984 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
2985 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
2986 FINISH_RECORD_CONSTRUCTOR (entry
);
2988 *list
= tree_cons (NULL_TREE
, entry
, *list
);
2992 /* Generate the type assertion table for CLASS, and return its DECL. */
2995 emit_assertion_table (tree
class)
2997 tree null_entry
, ctor
, table_decl
;
2998 tree list
= NULL_TREE
;
2999 htab_t assertions_htab
= TYPE_ASSERTIONS (class);
3001 /* Iterate through the hash table. */
3002 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
3004 /* Finish with a null entry. */
3005 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
3006 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
3007 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
3008 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
3009 FINISH_RECORD_CONSTRUCTOR (null_entry
);
3011 list
= tree_cons (NULL_TREE
, null_entry
, list
);
3013 /* Put the list in the right order and make it a constructor. */
3014 list
= nreverse (list
);
3015 ctor
= build_constructor_from_list (assertion_table_type
, list
);
3017 table_decl
= build_decl (VAR_DECL
, mangled_classname ("_type_assert_", class),
3018 assertion_table_type
);
3020 TREE_STATIC (table_decl
) = 1;
3021 TREE_READONLY (table_decl
) = 1;
3022 TREE_CONSTANT (table_decl
) = 1;
3023 DECL_IGNORED_P (table_decl
) = 1;
3025 DECL_INITIAL (table_decl
) = ctor
;
3026 DECL_ARTIFICIAL (table_decl
) = 1;
3027 rest_of_decl_compilation (table_decl
, 1, 0);
3033 init_class_processing (void)
3035 fields_ident
= get_identifier ("fields");
3036 info_ident
= get_identifier ("info");
3038 gcc_obstack_init (&temporary_obstack
);
3041 static hashval_t
java_treetreehash_hash (const void *);
3042 static int java_treetreehash_compare (const void *, const void *);
3044 /* A hash table mapping trees to trees. Used generally. */
3046 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
3049 java_treetreehash_hash (const void *k_p
)
3051 struct treetreehash_entry
*k
= (struct treetreehash_entry
*) k_p
;
3052 return JAVA_TREEHASHHASH_H (k
->key
);
3056 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3058 struct treetreehash_entry
* k1
= (struct treetreehash_entry
*) k1_p
;
3059 tree k2
= (tree
) k2_p
;
3060 return (k1
->key
== k2
);
3064 java_treetreehash_find (htab_t ht
, tree t
)
3066 struct treetreehash_entry
*e
;
3067 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3068 e
= htab_find_with_hash (ht
, t
, hv
);
3076 java_treetreehash_new (htab_t ht
, tree t
)
3079 struct treetreehash_entry
*tthe
;
3080 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3082 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3085 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
3090 tthe
= (struct treetreehash_entry
*) *e
;
3091 return &tthe
->value
;
3095 java_treetreehash_create (size_t size
, int gc
)
3098 return htab_create_ggc (size
, java_treetreehash_hash
,
3099 java_treetreehash_compare
, NULL
);
3101 return htab_create_alloc (size
, java_treetreehash_hash
,
3102 java_treetreehash_compare
, free
, xcalloc
, free
);
3105 /* Break down qualified IDENTIFIER into package and class-name components.
3106 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3107 "pkg.foo", and RIGHT to "Bar". */
3110 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3113 int l
= IDENTIFIER_LENGTH (source
);
3115 base
= alloca (l
+ 1);
3116 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3118 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3120 while (*p
!= '.' && p
!= base
)
3123 /* We didn't find a '.'. Return an error. */
3129 *right
= get_identifier (p
+1);
3130 *left
= get_identifier (base
);
3135 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3136 if the classes are from the same package. */
3139 in_same_package (tree name1
, tree name2
)
3145 if (TREE_CODE (name1
) == TYPE_DECL
)
3146 name1
= DECL_NAME (name1
);
3147 if (TREE_CODE (name2
) == TYPE_DECL
)
3148 name2
= DECL_NAME (name2
);
3150 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3151 /* One in empty package. */
3154 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3155 /* Both in empty package. */
3158 split_qualified_name (&pkg1
, &tmp
, name1
);
3159 split_qualified_name (&pkg2
, &tmp
, name2
);
3161 return (pkg1
== pkg2
);
3164 #include "gt-java-class.h"