1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc. */
26 /* Written by Per Bothner <bothner@cygnus.com> */
30 #include "coretypes.h"
35 #include "java-tree.h"
46 /* DOS brain-damage */
48 #define O_BINARY 0 /* MS-DOS brain-damage */
51 static tree
make_method_value (tree
);
52 static tree
build_java_method_type (tree
, tree
, int);
53 static int32
hashUtf8String (const char *, int);
54 static tree
make_field_value (tree
);
55 static tree
get_dispatch_vector (tree
);
56 static tree
get_dispatch_table (tree
, tree
);
57 static int supers_all_compiled (tree type
);
58 static void add_interface_do (tree
, tree
, int);
59 static tree
maybe_layout_super_class (tree
, tree
);
60 static void add_miranda_methods (tree
, tree
);
61 static int assume_compiled (const char *);
62 static tree
build_method_symbols_entry (tree
);
64 static GTY(()) rtx registerClass_libfunc
;
66 struct obstack temporary_obstack
;
68 /* The compiler generates different code depending on whether or not
69 it can assume certain classes have been compiled down to native
70 code or not. The compiler options -fassume-compiled= and
71 -fno-assume-compiled= are used to create a tree of
72 assume_compiled_node objects. This tree is queried to determine if
73 a class is assume to be compiled or not. Each node in the tree
74 represents either a package or a specific class. */
76 typedef struct assume_compiled_node_struct
78 /* The class or package name. */
81 /* Nonzero if this represents an exclusion. */
84 /* Pointers to other nodes in the tree. */
85 struct assume_compiled_node_struct
*parent
;
86 struct assume_compiled_node_struct
*sibling
;
87 struct assume_compiled_node_struct
*child
;
88 } assume_compiled_node
;
90 static assume_compiled_node
*find_assume_compiled_node (assume_compiled_node
*,
93 /* This is the root of the include/exclude tree. */
95 static assume_compiled_node
*assume_compiled_tree
;
97 static GTY(()) tree class_roots
[5];
98 #define registered_class class_roots[0]
99 #define fields_ident class_roots[1] /* get_identifier ("fields") */
100 #define info_ident class_roots[2] /* get_identifier ("info") */
101 #define class_list class_roots[3]
102 #define class_dtable_decl class_roots[4]
104 /* Return the node that most closely represents the class whose name
105 is IDENT. Start the search from NODE. Return NULL if an
106 appropriate node does not exist. */
108 static assume_compiled_node
*
109 find_assume_compiled_node (assume_compiled_node
*node
, const char *ident
)
113 size_t node_ident_length
= strlen (node
->ident
);
115 /* node_ident_length is zero at the root of the tree. If the
116 identifiers are the same length, then we have matching
117 classes. Otherwise check if we've matched an enclosing
120 if (node_ident_length
== 0
121 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
122 && (strlen (ident
) == node_ident_length
123 || ident
[node_ident_length
] == '.')))
125 /* We've found a match, however, there might be a more
128 assume_compiled_node
*found
= find_assume_compiled_node (node
->child
,
136 /* No match yet. Continue through the sibling list. */
137 node
= node
->sibling
;
140 /* No match at all in this tree. */
144 /* Add a new IDENT to the include/exclude tree. It's an exclusion
145 if EXCLUDEP is nonzero. */
148 add_assume_compiled (const char *ident
, int excludep
)
151 assume_compiled_node
*parent
;
152 assume_compiled_node
*node
= xmalloc (sizeof (assume_compiled_node
));
154 node
->ident
= xstrdup (ident
);
155 node
->excludep
= excludep
;
158 /* Create the root of the tree if it doesn't exist yet. */
160 if (NULL
== assume_compiled_tree
)
162 assume_compiled_tree
= xmalloc (sizeof (assume_compiled_node
));
163 assume_compiled_tree
->ident
= "";
164 assume_compiled_tree
->excludep
= 0;
165 assume_compiled_tree
->sibling
= NULL
;
166 assume_compiled_tree
->child
= NULL
;
167 assume_compiled_tree
->parent
= NULL
;
170 /* Calling the function with the empty string means we're setting
171 excludep for the root of the hierarchy. */
175 assume_compiled_tree
->excludep
= excludep
;
179 /* Find the parent node for this new node. PARENT will either be a
180 class or a package name. Adjust PARENT accordingly. */
182 parent
= find_assume_compiled_node (assume_compiled_tree
, ident
);
183 len
= strlen (parent
->ident
);
184 if (parent
->ident
[len
] && parent
->ident
[len
] != '.')
185 parent
= parent
->parent
;
187 /* Insert NODE into the tree. */
189 node
->parent
= parent
;
190 node
->sibling
= parent
->child
;
191 parent
->child
= node
;
194 /* Returns nonzero if IDENT is the name of a class that the compiler
195 should assume has been compiled to object code. */
198 assume_compiled (const char *ident
)
200 assume_compiled_node
*i
;
203 if (NULL
== assume_compiled_tree
)
206 i
= find_assume_compiled_node (assume_compiled_tree
,
209 result
= ! i
->excludep
;
214 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
215 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
216 Also, PREFIX is prepended, and SUFFIX is appended. */
219 ident_subst (const char* old_name
,
226 int prefix_len
= strlen (prefix
);
227 int suffix_len
= strlen (suffix
);
228 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
232 char *buffer
= alloca (i
);
234 strcpy (buffer
, prefix
);
235 for (i
= 0; i
< old_length
; i
++)
237 char ch
= old_name
[i
];
240 buffer
[prefix_len
+ i
] = ch
;
242 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
243 return get_identifier (buffer
);
246 /* Return an IDENTIFIER_NODE the same as OLD_ID,
247 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
248 Also, PREFIX is prepended, and SUFFIX is appended. */
251 identifier_subst (const tree old_id
,
257 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
258 prefix
, old_char
, new_char
, suffix
);
261 /* Generate a valid C identifier from the name of the class TYPE,
262 prefixed by PREFIX. */
265 mangled_classname (const char *prefix
, tree type
)
267 tree ident
= TYPE_NAME (type
);
268 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
269 ident
= DECL_NAME (ident
);
270 return identifier_subst (ident
, prefix
, '.', '_', "");
277 type
= make_node (RECORD_TYPE
);
278 TYPE_BINFO (type
) = make_tree_vec (BINFO_ELTS
);
279 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
284 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
285 and where each of the constituents is separated by '/',
286 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
289 unmangle_classname (const char *name
, int name_length
)
291 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
292 /* It's not sufficient to compare to_return and get_identifier
293 (name) to determine whether to_return is qualified. There are
294 cases in signature analysis where name will be stripped of a
296 name
= IDENTIFIER_POINTER (to_return
);
300 QUALIFIED_P (to_return
) = 1;
308 push_class (tree class_type
, tree class_name
)
310 tree decl
, signature
;
311 location_t saved_loc
= input_location
;
312 tree source_name
= identifier_subst (class_name
, "", '.', '/', ".java");
313 CLASS_P (class_type
) = 1;
314 input_filename
= IDENTIFIER_POINTER (source_name
);
316 decl
= build_decl (TYPE_DECL
, class_name
, class_type
);
318 /* dbxout needs a DECL_SIZE if in gstabs mode */
319 DECL_SIZE (decl
) = integer_zero_node
;
321 input_location
= saved_loc
;
322 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
323 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
325 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
326 both a typedef and in the struct name-space. We may want to re-visit
327 this later, but for now it reduces the changes needed for gdb. */
328 DECL_ARTIFICIAL (decl
) = 1;
330 pushdecl_top_level (decl
);
335 /* Finds the (global) class named NAME. Creates the class if not found.
336 Also creates associated TYPE_DECL.
337 Does not check if the class actually exists, load the class,
338 fill in field or methods, or do layout_type. */
341 lookup_class (tree name
)
343 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
344 if (decl
== NULL_TREE
)
345 decl
= push_class (make_class (), name
);
346 return TREE_TYPE (decl
);
350 set_super_info (int access_flags
, tree this_class
,
351 tree super_class
, int interfaces_count
)
353 int total_supers
= interfaces_count
;
354 tree class_decl
= TYPE_NAME (this_class
);
358 TYPE_BINFO_BASETYPES (this_class
) = make_tree_vec (total_supers
);
361 tree super_binfo
= make_tree_vec (BINFO_ELTS
);
362 BINFO_TYPE (super_binfo
) = super_class
;
363 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
364 TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (this_class
)), 0)
366 CLASS_HAS_SUPER (this_class
) = 1;
369 set_class_decl_access_flags (access_flags
, class_decl
);
373 set_class_decl_access_flags (int access_flags
, tree class_decl
)
375 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
376 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
377 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
378 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
379 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
380 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
381 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
382 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
383 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
386 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
387 direct sub-classes of Object are 1, and so on. */
390 class_depth (tree clas
)
393 if (! CLASS_LOADED_P (clas
))
394 load_class (clas
, 1);
395 if (TYPE_SIZE (clas
) == error_mark_node
)
397 while (clas
!= object_type_node
)
400 clas
= TYPE_BINFO_BASETYPE (clas
, 0);
405 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
408 interface_of_p (tree type1
, tree type2
)
413 if (!(basetype_vec
= TYPE_BINFO_BASETYPES (type2
)))
415 n
= TREE_VEC_LENGTH (basetype_vec
);
416 for (i
= 0; i
< n
; i
++)
418 tree vec_elt
= TREE_VEC_ELT (basetype_vec
, i
);
419 if (vec_elt
&& BINFO_TYPE (vec_elt
) == type1
)
422 for (i
= 0; i
< n
; i
++)
424 tree vec_elt
= TREE_VEC_ELT (basetype_vec
, i
);
425 if (vec_elt
&& BINFO_TYPE (vec_elt
)
426 && interface_of_p (type1
, BINFO_TYPE (vec_elt
)))
432 /* Return true iff TYPE1 inherits from TYPE2. */
435 inherits_from_p (tree type1
, tree type2
)
437 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
441 type1
= CLASSTYPE_SUPER (type1
);
446 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
449 enclosing_context_p (tree type1
, tree type2
)
451 if (!INNER_CLASS_TYPE_P (type2
))
454 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
456 type2
= (INNER_CLASS_TYPE_P (type2
) ?
457 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
466 /* Return 1 iff there exists a common enclosing context between TYPE1
469 int common_enclosing_context_p (tree type1
, tree type2
)
471 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
474 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
475 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
476 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
479 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
480 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
481 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
483 if (type1
== current
)
490 add_interface_do (tree basetype_vec
, tree interface_class
, int i
)
492 tree interface_binfo
= make_tree_vec (BINFO_ELTS
);
493 BINFO_TYPE (interface_binfo
) = interface_class
;
494 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
495 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
496 TREE_VIA_VIRTUAL (interface_binfo
) = 1;
497 TREE_VEC_ELT (basetype_vec
, i
) = interface_binfo
;
500 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
501 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
502 if attempt is made to add it twice. */
505 maybe_add_interface (tree this_class
, tree interface_class
)
507 tree basetype_vec
= TYPE_BINFO_BASETYPES (this_class
);
509 int n
= TREE_VEC_LENGTH (basetype_vec
);
514 error ("internal error - too many interface type");
517 else if (TREE_VEC_ELT (basetype_vec
, i
) == NULL_TREE
)
519 else if (BINFO_TYPE (TREE_VEC_ELT (basetype_vec
, i
)) == interface_class
)
520 return interface_class
;
522 add_interface_do (basetype_vec
, interface_class
, i
);
526 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
529 add_interface (tree this_class
, tree interface_class
)
531 tree basetype_vec
= TYPE_BINFO_BASETYPES (this_class
);
533 int n
= TREE_VEC_LENGTH (basetype_vec
);
538 error ("internal error - too many interface type");
541 else if (TREE_VEC_ELT (basetype_vec
, i
) == NULL_TREE
)
544 add_interface_do (basetype_vec
, interface_class
, i
);
548 /* Return the address of a pointer to the first FUNCTION_DECL
549 in the list (*LIST) whose DECL_NAME is NAME. */
552 find_named_method (tree
*list
, tree name
)
554 while (*list
&& DECL_NAME (*list
) != name
)
555 list
= &TREE_CHAIN (*list
);
561 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
563 if (access_flags
& ACC_STATIC
)
565 return build_method_type (this_class
, fntype
);
569 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
571 tree method_type
, fndecl
;
573 method_type
= build_java_method_type (function_type
,
574 this_class
, access_flags
);
576 fndecl
= build_decl (FUNCTION_DECL
, name
, method_type
);
577 DECL_CONTEXT (fndecl
) = this_class
;
579 DECL_LANG_SPECIFIC (fndecl
)
580 = ggc_alloc_cleared (sizeof (struct lang_decl
));
581 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
583 /* Initialize the static initializer test table. */
585 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
586 java_treetreehash_create (10, 1);
588 /* Initialize the initialized (static) class table. */
589 if (access_flags
& ACC_STATIC
)
590 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
591 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
593 /* Initialize the static method invocation compound list */
594 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl
) = NULL_TREE
;
596 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
597 TYPE_METHODS (this_class
) = fndecl
;
599 /* Notice that this is a finalizer and update the class type
600 accordingly. This is used to optimize instance allocation. */
601 if (name
== finalize_identifier_node
602 && TREE_TYPE (function_type
) == void_type_node
603 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
604 HAS_FINALIZER_P (this_class
) = 1;
606 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
607 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
608 if (access_flags
& ACC_PRIVATE
)
609 METHOD_PRIVATE (fndecl
) = DECL_INLINE (fndecl
) = 1;
610 if (access_flags
& ACC_NATIVE
)
612 METHOD_NATIVE (fndecl
) = 1;
613 DECL_EXTERNAL (fndecl
) = 1;
615 if (access_flags
& ACC_STATIC
)
616 METHOD_STATIC (fndecl
) = DECL_INLINE (fndecl
) = 1;
617 if (access_flags
& ACC_FINAL
)
618 METHOD_FINAL (fndecl
) = DECL_INLINE (fndecl
) = 1;
619 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
620 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
621 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
625 /* Add a method to THIS_CLASS.
626 The method's name is NAME.
627 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
630 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
632 tree function_type
, fndecl
;
633 const unsigned char *sig
634 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
637 fatal_error ("bad method signature");
639 function_type
= get_type_from_signature (method_sig
);
640 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
641 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
646 add_field (tree
class, tree name
, tree field_type
, int flags
)
648 int is_static
= (flags
& ACC_STATIC
) != 0;
650 field
= build_decl (is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
651 TREE_CHAIN (field
) = TYPE_FIELDS (class);
652 TYPE_FIELDS (class) = field
;
653 DECL_CONTEXT (field
) = class;
655 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
656 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
657 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
658 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
659 if (flags
& ACC_VOLATILE
) FIELD_VOLATILE (field
) = 1;
660 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
663 FIELD_STATIC (field
) = 1;
664 /* Always make field externally visible. This is required so
665 that native methods can always access the field. */
666 TREE_PUBLIC (field
) = 1;
667 /* Considered external until we know what classes are being
668 compiled into this object file. */
669 DECL_EXTERNAL (field
) = 1;
675 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
678 set_constant_value (tree field
, tree constant
)
680 if (field
== NULL_TREE
)
681 warning ("misplaced ConstantValue attribute (not in any field)");
682 else if (DECL_INITIAL (field
) != NULL_TREE
)
683 warning ("duplicate ConstantValue attribute for field '%s'",
684 IDENTIFIER_POINTER (DECL_NAME (field
)));
687 DECL_INITIAL (field
) = constant
;
688 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
689 && ! (TREE_TYPE (constant
) == int_type_node
690 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
691 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
692 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
693 && TREE_TYPE (field
) == string_ptr_type_node
))
694 error ("ConstantValue attribute of field '%s' has wrong type",
695 IDENTIFIER_POINTER (DECL_NAME (field
)));
696 if (FIELD_FINAL (field
))
697 DECL_FIELD_FINAL_IUD (field
) = 1;
701 /* Count the number of Unicode chars encoded in a given Ut8 string. */
705 strLengthUtf8 (char *str
, int len
)
707 register unsigned char* ptr
= (unsigned char*) str
;
708 register unsigned char *limit
= ptr
+ len
;
710 for (; ptr
< limit
; str_length
++) {
711 if (UTF8_GET (ptr
, limit
) < 0)
719 /* Calculate a hash value for a string encoded in Utf8 format.
720 * This returns the same hash value as specified for java.lang.String.hashCode.
724 hashUtf8String (const char *str
, int len
)
726 register const unsigned char* ptr
= (const unsigned char*) str
;
727 register const unsigned char *limit
= ptr
+ len
;
731 int ch
= UTF8_GET (ptr
, limit
);
732 /* Updated specification from
733 http://www.javasoft.com/docs/books/jls/clarify.html. */
734 hash
= (31 * hash
) + ch
;
739 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
742 build_utf8_ref (tree name
)
744 const char * name_ptr
= IDENTIFIER_POINTER(name
);
745 int name_len
= IDENTIFIER_LENGTH(name
);
747 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
748 static int utf8_count
= 0;
750 tree ref
= IDENTIFIER_UTF8_REF (name
);
752 if (ref
!= NULL_TREE
)
755 ctype
= make_node (RECORD_TYPE
);
756 str_type
= build_prim_array_type (unsigned_byte_type_node
,
757 name_len
+ 1); /* Allow for final '\0'. */
758 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
759 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
760 PUSH_FIELD (ctype
, field
, "data", str_type
);
761 FINISH_RECORD (ctype
);
762 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
763 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
764 PUSH_FIELD_VALUE (cinit
, "hash", build_int_2 (name_hash
, 0));
765 PUSH_FIELD_VALUE (cinit
, "length", build_int_2 (name_len
, 0));
766 string
= build_string (name_len
, name_ptr
);
767 TREE_TYPE (string
) = str_type
;
768 PUSH_FIELD_VALUE (cinit
, "data", string
);
769 FINISH_RECORD_CONSTRUCTOR (cinit
);
770 TREE_CONSTANT (cinit
) = 1;
772 /* Generate a unique-enough identifier. */
773 sprintf(buf
, "_Utf%d", ++utf8_count
);
775 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
776 TREE_STATIC (decl
) = 1;
777 DECL_ARTIFICIAL (decl
) = 1;
778 DECL_IGNORED_P (decl
) = 1;
779 TREE_READONLY (decl
) = 1;
780 TREE_THIS_VOLATILE (decl
) = 0;
781 DECL_INITIAL (decl
) = cinit
;
782 #ifdef HAVE_GAS_SHF_MERGE
785 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
786 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
787 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
788 if (flag_merge_constants
&& decl_size
< 256)
791 int flags
= (SECTION_OVERRIDE
792 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
793 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
794 named_section_flags (buf
, flags
);
795 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
799 TREE_CHAIN (decl
) = utf8_decl_list
;
800 layout_decl (decl
, 0);
802 rest_of_decl_compilation (decl
, (char*) 0, global_bindings_p (), 0);
803 utf8_decl_list
= decl
;
804 make_decl_rtl (decl
, (char*) 0);
805 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
806 IDENTIFIER_UTF8_REF (name
) = ref
;
810 /* Build a reference to the class TYPE.
811 Also handles primitive types and array types. */
814 build_class_ref (tree type
)
816 int is_compiled
= is_compiled_class (type
);
819 tree ref
, decl_name
, decl
;
820 if (TREE_CODE (type
) == POINTER_TYPE
)
821 type
= TREE_TYPE (type
);
822 if (TREE_CODE (type
) == RECORD_TYPE
)
824 if (TYPE_SIZE (type
) == error_mark_node
)
825 return null_pointer_node
;
826 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
827 "", '/', '/', ".class");
828 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
829 if (decl
== NULL_TREE
)
831 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
832 DECL_SIZE (decl
) = TYPE_SIZE (class_type_node
);
833 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (class_type_node
);
834 TREE_STATIC (decl
) = 1;
835 TREE_PUBLIC (decl
) = 1;
836 DECL_IGNORED_P (decl
) = 1;
837 DECL_ARTIFICIAL (decl
) = 1;
838 if (is_compiled
== 1)
839 DECL_EXTERNAL (decl
) = 1;
840 SET_DECL_ASSEMBLER_NAME (decl
,
841 java_mangle_class_field
842 (&temporary_obstack
, type
));
843 make_decl_rtl (decl
, NULL
);
844 pushdecl_top_level (decl
);
851 if (flag_emit_class_files
)
853 const char *prim_class_name
;
855 if (type
== char_type_node
)
856 prim_class_name
= "java.lang.Character";
857 else if (type
== boolean_type_node
)
858 prim_class_name
= "java.lang.Boolean";
859 else if (type
== byte_type_node
)
860 prim_class_name
= "java.lang.Byte";
861 else if (type
== short_type_node
)
862 prim_class_name
= "java.lang.Short";
863 else if (type
== int_type_node
)
864 prim_class_name
= "java.lang.Integer";
865 else if (type
== long_type_node
)
866 prim_class_name
= "java.lang.Long";
867 else if (type
== float_type_node
)
868 prim_class_name
= "java.lang.Float";
869 else if (type
== double_type_node
)
870 prim_class_name
= "java.lang.Double";
871 else if (type
== void_type_node
)
872 prim_class_name
= "java.lang.Void";
876 prim_class
= lookup_class (get_identifier (prim_class_name
));
877 return build (COMPONENT_REF
, NULL_TREE
,
878 prim_class
, TYPE_identifier_node
);
880 decl_name
= TYPE_NAME (type
);
881 if (TREE_CODE (decl_name
) == TYPE_DECL
)
882 decl_name
= DECL_NAME (decl_name
);
883 name
= IDENTIFIER_POINTER (decl_name
);
884 if (strncmp (name
, "promoted_", 9) == 0)
886 sprintf (buffer
, "_Jv_%sClass", name
);
887 decl_name
= get_identifier (buffer
);
888 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
889 if (decl
== NULL_TREE
)
891 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
892 TREE_STATIC (decl
) = 1;
893 TREE_PUBLIC (decl
) = 1;
894 DECL_EXTERNAL (decl
) = 1;
895 make_decl_rtl (decl
, NULL
);
896 pushdecl_top_level (decl
);
900 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
907 index
= alloc_class_constant (type
);
908 cl
= build_ref_from_constant_pool (index
);
909 TREE_TYPE (cl
) = promote_type (class_ptr_type
);
915 build_static_field_ref (tree fdecl
)
917 tree fclass
= DECL_CONTEXT (fdecl
);
918 int is_compiled
= is_compiled_class (fclass
);
920 /* Allow static final fields to fold to a constant. When using
921 -fno-assume-compiled, gcj will sometimes try to fold a field from
922 an uncompiled class. This is required when the field in question
923 meets the appropriate criteria for a compile-time constant.
924 However, currently sometimes gcj is too eager and will end up
925 returning the field itself, leading to an incorrect external
926 reference being generated. */
928 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
929 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
930 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
931 && TREE_CONSTANT (DECL_INITIAL (fdecl
))))
933 if (!DECL_RTL_SET_P (fdecl
))
935 if (is_compiled
== 1)
936 DECL_EXTERNAL (fdecl
) = 1;
937 make_decl_rtl (fdecl
, NULL
);
944 * *(FTYPE*)build_class_ref(FCLASS)->fields[INDEX].info.addr */
945 tree ref
= build_class_ref (fclass
);
948 ref
= build1 (INDIRECT_REF
, class_type_node
, ref
);
949 ref
= build (COMPONENT_REF
, field_ptr_type_node
, ref
,
950 lookup_field (&class_type_node
, fields_ident
));
952 for (fld
= TYPE_FIELDS (fclass
); ; fld
= TREE_CHAIN (fld
))
956 if (fld
== NULL_TREE
)
957 fatal_error ("field '%s' not found in class",
958 IDENTIFIER_POINTER (DECL_NAME (fdecl
)));
959 if (FIELD_STATIC (fld
))
962 field_index
*= int_size_in_bytes (field_type_node
);
963 ref
= fold (build (PLUS_EXPR
, field_ptr_type_node
,
964 ref
, build_int_2 (field_index
, 0)));
965 ref
= build1 (INDIRECT_REF
, field_type_node
, ref
);
966 ref
= build (COMPONENT_REF
, field_info_union_node
,
967 ref
, lookup_field (&field_type_node
, info_ident
));
968 ref
= build (COMPONENT_REF
, ptr_type_node
,
969 ref
, TREE_CHAIN (TYPE_FIELDS (field_info_union_node
)));
970 return fold (build1 (INDIRECT_REF
, TREE_TYPE(fdecl
), ref
));
975 get_access_flags_from_decl (tree decl
)
977 int access_flags
= 0;
978 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
980 if (FIELD_STATIC (decl
))
981 access_flags
|= ACC_STATIC
;
982 if (FIELD_PUBLIC (decl
))
983 access_flags
|= ACC_PUBLIC
;
984 if (FIELD_PROTECTED (decl
))
985 access_flags
|= ACC_PROTECTED
;
986 if (FIELD_PRIVATE (decl
))
987 access_flags
|= ACC_PRIVATE
;
988 if (FIELD_FINAL (decl
))
989 access_flags
|= ACC_FINAL
;
990 if (FIELD_VOLATILE (decl
))
991 access_flags
|= ACC_VOLATILE
;
992 if (FIELD_TRANSIENT (decl
))
993 access_flags
|= ACC_TRANSIENT
;
996 if (TREE_CODE (decl
) == TYPE_DECL
)
998 if (CLASS_PUBLIC (decl
))
999 access_flags
|= ACC_PUBLIC
;
1000 if (CLASS_FINAL (decl
))
1001 access_flags
|= ACC_FINAL
;
1002 if (CLASS_SUPER (decl
))
1003 access_flags
|= ACC_SUPER
;
1004 if (CLASS_INTERFACE (decl
))
1005 access_flags
|= ACC_INTERFACE
;
1006 if (CLASS_ABSTRACT (decl
))
1007 access_flags
|= ACC_ABSTRACT
;
1008 if (CLASS_STATIC (decl
))
1009 access_flags
|= ACC_STATIC
;
1010 if (CLASS_PRIVATE (decl
))
1011 access_flags
|= ACC_PRIVATE
;
1012 if (CLASS_PROTECTED (decl
))
1013 access_flags
|= ACC_PROTECTED
;
1014 if (CLASS_STRICTFP (decl
))
1015 access_flags
|= ACC_STRICT
;
1016 return access_flags
;
1018 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1020 if (METHOD_PUBLIC (decl
))
1021 access_flags
|= ACC_PUBLIC
;
1022 if (METHOD_PRIVATE (decl
))
1023 access_flags
|= ACC_PRIVATE
;
1024 if (METHOD_PROTECTED (decl
))
1025 access_flags
|= ACC_PROTECTED
;
1026 if (METHOD_STATIC (decl
))
1027 access_flags
|= ACC_STATIC
;
1028 if (METHOD_FINAL (decl
))
1029 access_flags
|= ACC_FINAL
;
1030 if (METHOD_SYNCHRONIZED (decl
))
1031 access_flags
|= ACC_SYNCHRONIZED
;
1032 if (METHOD_NATIVE (decl
))
1033 access_flags
|= ACC_NATIVE
;
1034 if (METHOD_ABSTRACT (decl
))
1035 access_flags
|= ACC_ABSTRACT
;
1036 if (METHOD_STRICTFP (decl
))
1037 access_flags
|= ACC_STRICT
;
1038 if (METHOD_INVISIBLE (decl
))
1039 access_flags
|= ACC_INVISIBLE
;
1040 return access_flags
;
1046 make_field_value (tree fdecl
)
1050 tree type
= TREE_TYPE (fdecl
);
1051 int resolved
= is_compiled_class (type
);
1053 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1054 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1056 type
= build_class_ref (type
);
1059 tree signature
= build_java_signature (type
);
1061 type
= build_utf8_ref (unmangle_classname
1062 (IDENTIFIER_POINTER (signature
),
1063 IDENTIFIER_LENGTH (signature
)));
1065 PUSH_FIELD_VALUE (finit
, "type", type
);
1067 flags
= get_access_flags_from_decl (fdecl
);
1069 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1071 PUSH_FIELD_VALUE (finit
, "accflags", build_int_2 (flags
, 0));
1072 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1076 build_constructor (field_info_union_node
,
1078 ((FIELD_STATIC (fdecl
)
1079 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1080 : TYPE_FIELDS (field_info_union_node
)),
1081 (FIELD_STATIC (fdecl
)
1082 ? build_address_of (build_static_field_ref (fdecl
))
1083 : byte_position (fdecl
)))));
1085 FINISH_RECORD_CONSTRUCTOR (finit
);
1090 make_method_value (tree mdecl
)
1092 static int method_name_count
= 0;
1096 #define ACC_TRANSLATED 0x4000
1097 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1099 if (!flag_indirect_dispatch
&& DECL_VINDEX (mdecl
) != NULL_TREE
)
1100 index
= DECL_VINDEX (mdecl
);
1102 index
= integer_minus_one_node
;
1104 code
= null_pointer_node
;
1105 if (DECL_RTL_SET_P (mdecl
))
1106 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
, mdecl
);
1107 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1108 PUSH_FIELD_VALUE (minit
, "name",
1109 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1110 init_identifier_node
1111 : DECL_NAME (mdecl
)));
1113 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1114 PUSH_FIELD_VALUE (minit
, "signature",
1117 (IDENTIFIER_POINTER(signature
),
1118 IDENTIFIER_LENGTH(signature
)))));
1120 PUSH_FIELD_VALUE (minit
, "accflags", build_int_2 (accflags
, 0));
1121 PUSH_FIELD_VALUE (minit
, "index", index
);
1122 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1125 /* Compute the `throws' information for the method. */
1126 tree table
= null_pointer_node
;
1127 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1129 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1130 tree iter
, type
, array
;
1133 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1134 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1136 iter
= TREE_CHAIN (iter
))
1138 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1140 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1141 IDENTIFIER_LENGTH (sig
)));
1142 table
= tree_cons (NULL_TREE
, utf8
, table
);
1144 type
= build_prim_array_type (ptr_type_node
, length
);
1145 table
= build_constructor (type
, table
);
1146 /* Compute something unique enough. */
1147 sprintf (buf
, "_methods%d", method_name_count
++);
1148 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1149 DECL_INITIAL (array
) = table
;
1150 TREE_STATIC (array
) = 1;
1151 DECL_ARTIFICIAL (array
) = 1;
1152 DECL_IGNORED_P (array
) = 1;
1153 rest_of_decl_compilation (array
, (char*) 0, 1, 0);
1155 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1158 PUSH_FIELD_VALUE (minit
, "throws", table
);
1161 FINISH_RECORD_CONSTRUCTOR (minit
);
1166 get_dispatch_vector (tree type
)
1168 tree vtable
= TYPE_VTABLE (type
);
1170 if (vtable
== NULL_TREE
)
1174 tree super
= CLASSTYPE_SUPER (type
);
1175 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1176 vtable
= make_tree_vec (nvirtuals
);
1177 TYPE_VTABLE (type
) = vtable
;
1178 if (super
!= NULL_TREE
)
1180 tree super_vtable
= get_dispatch_vector (super
);
1182 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1183 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1186 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1187 method
= TREE_CHAIN (method
))
1188 if (DECL_VINDEX (method
) != NULL_TREE
1189 && host_integerp (DECL_VINDEX (method
), 0))
1190 TREE_VEC_ELT (vtable
, tree_low_cst (DECL_VINDEX (method
), 0))
1198 get_dispatch_table (tree type
, tree this_class_addr
)
1200 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1201 tree vtable
= get_dispatch_vector (type
);
1203 tree list
= NULL_TREE
;
1204 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1208 for (i
= nvirtuals
; --i
>= 0; )
1210 tree method
= TREE_VEC_ELT (vtable
, i
);
1211 if (METHOD_ABSTRACT (method
))
1214 warning ("%Habstract method in non-abstract class",
1215 &DECL_SOURCE_FILE (method
));
1217 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1218 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1219 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1221 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1225 if (!DECL_RTL_SET_P (method
))
1226 make_decl_rtl (method
, NULL
);
1228 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1229 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1231 tree fdesc
= build (FDESC_EXPR
, nativecode_ptr_type_node
,
1232 method
, build_int_2 (j
, 0));
1233 TREE_CONSTANT (fdesc
) = 1;
1234 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1237 list
= tree_cons (NULL_TREE
,
1238 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1244 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1245 using the Boehm GC we sometimes stash a GC type descriptor
1246 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1247 the emitted byte count during the output to the assembly file. */
1248 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1249 fake "function descriptor". It's first word is the is the class
1250 pointer, and subsequent words (usually one) contain the GC descriptor.
1251 In all other cases, we reserve two extra vtable slots. */
1252 gc_descr
= get_boehm_type_descriptor (type
);
1253 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1254 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1255 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1256 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1258 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1259 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1260 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1261 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1263 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1264 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1265 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1267 return build_constructor (build_prim_array_type (nativecode_ptr_type_node
,
1272 supers_all_compiled (tree type
)
1274 while (type
!= NULL_TREE
)
1276 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1278 type
= CLASSTYPE_SUPER (type
);
1284 make_class_data (tree type
)
1286 tree decl
, cons
, temp
;
1287 tree field
, fields_decl
;
1288 tree static_fields
= NULL_TREE
;
1289 tree instance_fields
= NULL_TREE
;
1290 HOST_WIDE_INT static_field_count
= 0;
1291 HOST_WIDE_INT instance_field_count
= 0;
1292 HOST_WIDE_INT field_count
;
1293 tree field_array_type
;
1295 tree methods
= NULL_TREE
;
1296 tree dtable_decl
= NULL_TREE
;
1297 HOST_WIDE_INT method_count
= 0;
1298 tree method_array_type
;
1301 tree this_class_addr
;
1302 tree constant_pool_constructor
;
1303 tree interfaces
= null_pointer_node
;
1304 int interface_len
= 0;
1305 tree type_decl
= TYPE_NAME (type
);
1306 /** Offset from start of virtual function table declaration
1307 to where objects actually point at, following new g++ ABI. */
1308 tree dtable_start_offset
= build_int_2 (2 * POINTER_SIZE
/ BITS_PER_UNIT
, 0);
1310 this_class_addr
= build_class_ref (type
);
1311 decl
= TREE_OPERAND (this_class_addr
, 0);
1313 /* Build Field array. */
1314 field
= TYPE_FIELDS (type
);
1315 if (DECL_NAME (field
) == NULL_TREE
)
1316 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1317 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1319 if (! DECL_ARTIFICIAL (field
))
1321 tree init
= make_field_value (field
);
1322 if (FIELD_STATIC (field
))
1324 tree initial
= DECL_INITIAL (field
);
1325 static_field_count
++;
1326 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1327 /* If the initial value is a string constant,
1328 prevent output_constant from trying to assemble the value. */
1329 if (initial
!= NULL_TREE
1330 && TREE_TYPE (initial
) == string_ptr_type_node
)
1331 DECL_INITIAL (field
) = NULL_TREE
;
1332 rest_of_decl_compilation (field
, (char*) 0, 1, 1);
1333 DECL_INITIAL (field
) = initial
;
1337 instance_field_count
++;
1338 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1342 field_count
= static_field_count
+ instance_field_count
;
1343 if (field_count
> 0)
1345 static_fields
= nreverse (static_fields
);
1346 instance_fields
= nreverse (instance_fields
);
1347 static_fields
= chainon (static_fields
, instance_fields
);
1348 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1349 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1351 DECL_INITIAL (fields_decl
) = build_constructor (field_array_type
,
1353 TREE_STATIC (fields_decl
) = 1;
1354 DECL_ARTIFICIAL (fields_decl
) = 1;
1355 DECL_IGNORED_P (fields_decl
) = 1;
1356 rest_of_decl_compilation (fields_decl
, (char*) 0, 1, 0);
1359 fields_decl
= NULL_TREE
;
1361 /* Build Method array. */
1362 for (method
= TYPE_METHODS (type
);
1363 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1366 if (METHOD_PRIVATE (method
)
1367 && ! flag_keep_inline_functions
1368 && (flag_inline_functions
|| optimize
))
1370 init
= make_method_value (method
);
1372 methods
= tree_cons (NULL_TREE
, init
, methods
);
1374 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1375 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1377 DECL_INITIAL (methods_decl
) = build_constructor (method_array_type
,
1378 nreverse (methods
));
1379 TREE_STATIC (methods_decl
) = 1;
1380 DECL_ARTIFICIAL (methods_decl
) = 1;
1381 DECL_IGNORED_P (methods_decl
) = 1;
1382 rest_of_decl_compilation (methods_decl
, (char*) 0, 1, 0);
1384 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1385 && !flag_indirect_dispatch
)
1387 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1388 dtable_decl
= build_dtable_decl (type
);
1389 DECL_INITIAL (dtable_decl
) = dtable
;
1390 TREE_STATIC (dtable_decl
) = 1;
1391 DECL_ARTIFICIAL (dtable_decl
) = 1;
1392 DECL_IGNORED_P (dtable_decl
) = 1;
1393 TREE_PUBLIC (dtable_decl
) = 1;
1394 rest_of_decl_compilation (dtable_decl
, (char*) 0, 1, 0);
1395 if (type
== class_type_node
)
1396 class_dtable_decl
= dtable_decl
;
1399 if (class_dtable_decl
== NULL_TREE
)
1401 class_dtable_decl
= build_dtable_decl (class_type_node
);
1402 TREE_STATIC (class_dtable_decl
) = 1;
1403 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1404 DECL_IGNORED_P (class_dtable_decl
) = 1;
1405 if (is_compiled_class (class_type_node
) != 2)
1406 DECL_EXTERNAL (class_dtable_decl
) = 1;
1407 rest_of_decl_compilation (class_dtable_decl
, (char*) 0, 1, 0);
1410 super
= CLASSTYPE_SUPER (type
);
1411 if (super
== NULL_TREE
)
1412 super
= null_pointer_node
;
1413 else if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1414 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1415 super
= build_class_ref (super
);
1418 int super_index
= alloc_class_constant (super
);
1419 super
= build_int_2 (super_index
, 0);
1420 TREE_TYPE (super
) = ptr_type_node
;
1423 /* Build and emit the array of implemented interfaces. */
1424 if (type
!= object_type_node
)
1425 interface_len
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
)) - 1;
1426 if (interface_len
> 0)
1428 tree init
= NULL_TREE
;
1430 tree interface_array_type
, idecl
;
1431 interface_array_type
1432 = build_prim_array_type (class_ptr_type
, interface_len
);
1433 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1434 interface_array_type
);
1435 for (i
= interface_len
; i
> 0; i
--)
1437 tree child
= TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type
), i
);
1438 tree iclass
= BINFO_TYPE (child
);
1440 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
)))))
1441 index
= build_class_ref (iclass
);
1444 int int_index
= alloc_class_constant (iclass
);
1445 index
= build_int_2 (int_index
, 0);
1446 TREE_TYPE (index
) = ptr_type_node
;
1448 init
= tree_cons (NULL_TREE
, index
, init
);
1450 DECL_INITIAL (idecl
) = build_constructor (interface_array_type
, init
);
1451 TREE_STATIC (idecl
) = 1;
1452 DECL_ARTIFICIAL (idecl
) = 1;
1453 DECL_IGNORED_P (idecl
) = 1;
1454 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1455 rest_of_decl_compilation (idecl
, (char*) 0, 1, 0);
1458 constant_pool_constructor
= build_constants_constructor ();
1460 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
1461 PUSH_FIELD_VALUE (temp
, "vtable",
1462 build (PLUS_EXPR
, dtable_ptr_type
,
1463 build1 (ADDR_EXPR
, dtable_ptr_type
, class_dtable_decl
),
1464 dtable_start_offset
));
1465 if (! flag_hash_synchronization
)
1466 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
1467 FINISH_RECORD_CONSTRUCTOR (temp
);
1468 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
1469 PUSH_SUPER_VALUE (cons
, temp
);
1470 PUSH_FIELD_VALUE (cons
, "next", null_pointer_node
);
1471 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
1472 PUSH_FIELD_VALUE (cons
, "accflags",
1473 build_int_2 (get_access_flags_from_decl (type_decl
), 0));
1475 PUSH_FIELD_VALUE (cons
, "superclass",
1476 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
1477 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
1478 PUSH_FIELD_VALUE (cons
, "methods",
1479 build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
1480 PUSH_FIELD_VALUE (cons
, "method_count", build_int_2 (method_count
, 0));
1482 if (flag_indirect_dispatch
)
1483 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
)
1485 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
1487 PUSH_FIELD_VALUE (cons
, "fields",
1488 fields_decl
== NULL_TREE
? null_pointer_node
1489 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
1490 PUSH_FIELD_VALUE (cons
, "size_in_bytes", size_in_bytes (type
));
1491 PUSH_FIELD_VALUE (cons
, "field_count", build_int_2 (field_count
, 0));
1492 PUSH_FIELD_VALUE (cons
, "static_field_count",
1493 build_int_2 (static_field_count
, 0));
1495 if (flag_indirect_dispatch
)
1496 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
)
1498 PUSH_FIELD_VALUE (cons
, "vtable",
1499 dtable_decl
== NULL_TREE
? null_pointer_node
1500 : build (PLUS_EXPR
, dtable_ptr_type
,
1501 build1 (ADDR_EXPR
, dtable_ptr_type
, dtable_decl
),
1502 dtable_start_offset
));
1504 if (otable_methods
== NULL_TREE
)
1506 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
1507 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
1511 PUSH_FIELD_VALUE (cons
, "otable",
1512 build1 (ADDR_EXPR
, otable_ptr_type
, otable_decl
));
1513 PUSH_FIELD_VALUE (cons
, "otable_syms",
1514 build1 (ADDR_EXPR
, method_symbols_array_ptr_type
,
1517 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
1518 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
1519 PUSH_FIELD_VALUE (cons
, "interface_count", build_int_2 (interface_len
, 0));
1520 PUSH_FIELD_VALUE (cons
, "state", integer_zero_node
);
1522 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
1523 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
1524 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
1525 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
1526 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
1527 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
1528 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
1530 FINISH_RECORD_CONSTRUCTOR (cons
);
1532 DECL_INITIAL (decl
) = cons
;
1534 /* Hash synchronization requires at least 64-bit alignment. */
1535 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
1536 DECL_ALIGN (decl
) = 64;
1538 rest_of_decl_compilation (decl
, (char*) 0, 1, 0);
1545 tree type_methods
= TYPE_METHODS (current_class
);
1546 int saw_native_method
= 0;
1548 /* Find out if we have any native methods. We use this information
1550 for (method
= type_methods
;
1551 method
!= NULL_TREE
;
1552 method
= TREE_CHAIN (method
))
1554 if (METHOD_NATIVE (method
))
1556 saw_native_method
= 1;
1561 /* Emit deferred inline methods. */
1562 for (method
= type_methods
; method
!= NULL_TREE
; )
1564 if (! TREE_ASM_WRITTEN (method
) && DECL_SAVED_INSNS (method
) != 0)
1566 output_inline_function (method
);
1567 /* Scan the list again to see if there are any earlier
1569 method
= type_methods
;
1572 method
= TREE_CHAIN (method
);
1575 current_function_decl
= NULL_TREE
;
1576 make_class_data (current_class
);
1578 rest_of_decl_compilation (TYPE_NAME (current_class
), (char*) 0, 1, 0);
1581 /* Return 2 if CLASS is compiled by this compilation job;
1582 return 1 if CLASS can otherwise be assumed to be compiled;
1583 return 0 if we cannot assume that CLASS is compiled.
1584 Returns 1 for primitive and 0 for array types. */
1586 is_compiled_class (tree
class)
1589 if (TREE_CODE (class) == POINTER_TYPE
)
1590 class = TREE_TYPE (class);
1591 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
1593 if (TYPE_ARRAY_P (class))
1595 if (class == current_class
)
1598 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1599 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip
)
1601 /* The class was seen in the current ZIP file and will be
1602 available as a compiled class in the future but may not have
1603 been loaded already. Load it if necessary. This prevent
1604 build_class_ref () from crashing. */
1606 if (seen_in_zip
&& !CLASS_LOADED_P (class))
1607 load_class (class, 1);
1609 /* We return 2 for class seen in ZIP and class from files
1610 belonging to the same compilation unit */
1614 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1616 if (!CLASS_LOADED_P (class))
1618 if (CLASS_FROM_SOURCE_P (class))
1619 safe_layout_class (class);
1621 load_class (class, 1);
1629 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1632 build_dtable_decl (tree type
)
1636 /* We need to build a new dtable type so that its size is uniquely
1637 computed when we're dealing with the class for real and not just
1638 faking it (like java.lang.Class during the initialization of the
1639 compiler.) We know we're not faking a class when CURRENT_CLASS is
1641 if (current_class
== type
)
1643 tree dummy
= NULL_TREE
;
1646 dtype
= make_node (RECORD_TYPE
);
1648 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
1649 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
1651 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
1652 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
1654 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
1655 TREE_CHAIN (dummy
) = tmp_field
;
1656 DECL_CONTEXT (tmp_field
) = dtype
;
1657 DECL_ARTIFICIAL (tmp_field
) = 1;
1661 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
1662 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
1664 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
1665 TREE_CHAIN (dummy
) = tmp_field
;
1666 DECL_CONTEXT (tmp_field
) = dtype
;
1667 DECL_ARTIFICIAL (tmp_field
) = 1;
1671 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
1672 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1673 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1675 PUSH_FIELD (dtype
, dummy
, "methods",
1676 build_prim_array_type (nativecode_ptr_type_node
, n
));
1677 layout_type (dtype
);
1680 dtype
= dtable_type
;
1682 return build_decl (VAR_DECL
,
1683 java_mangle_vtable (&temporary_obstack
, type
), dtype
);
1686 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
1687 fields inherited from SUPER_CLASS. */
1690 push_super_field (tree this_class
, tree super_class
)
1693 /* Don't insert the field if we're just re-laying the class out. */
1694 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
1696 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
1697 DECL_IGNORED_P (base_decl
) = 1;
1698 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
1699 TYPE_FIELDS (this_class
) = base_decl
;
1700 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
1701 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
1704 /* Handle the different manners we may have to lay out a super class. */
1707 maybe_layout_super_class (tree super_class
, tree this_class
)
1709 if (TREE_CODE (super_class
) == RECORD_TYPE
)
1711 if (!CLASS_LOADED_P (super_class
) && CLASS_FROM_SOURCE_P (super_class
))
1712 safe_layout_class (super_class
);
1713 if (!CLASS_LOADED_P (super_class
))
1714 load_class (super_class
, 1);
1716 /* We might have to layout the class before its dependency on
1717 the super class gets resolved by java_complete_class */
1718 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
1720 if (TREE_TYPE (super_class
) != NULL_TREE
)
1721 super_class
= TREE_TYPE (super_class
);
1724 /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
1726 tree this_wrap
= NULL_TREE
;
1730 tree this_decl
= TYPE_NAME (this_class
);
1731 this_wrap
= build_expr_wfl (this_class
,
1732 DECL_SOURCE_FILE (this_decl
),
1733 DECL_SOURCE_LINE (this_decl
), 0);
1735 super_class
= do_resolve_class (NULL_TREE
, /* FIXME? */
1736 super_class
, NULL_TREE
, this_wrap
);
1738 return NULL_TREE
; /* FIXME, NULL_TREE not checked by caller. */
1739 super_class
= TREE_TYPE (super_class
);
1742 if (!TYPE_SIZE (super_class
))
1743 safe_layout_class (super_class
);
1749 layout_class (tree this_class
)
1751 tree super_class
= CLASSTYPE_SUPER (this_class
);
1754 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
1755 if (CLASS_BEING_LAIDOUT (this_class
))
1761 sprintf (buffer
, " with `%s'",
1762 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
1763 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
1765 for (current
= TREE_CHAIN (class_list
); current
;
1766 current
= TREE_CHAIN (current
))
1768 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
1769 sprintf (buffer
, "\n which inherits from `%s' (%s:%d)",
1770 IDENTIFIER_POINTER (DECL_NAME (decl
)),
1771 DECL_SOURCE_FILE (decl
),
1772 DECL_SOURCE_LINE (decl
));
1773 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
1775 obstack_1grow (&temporary_obstack
, '\0');
1776 report
= obstack_finish (&temporary_obstack
);
1777 cyclic_inheritance_report
= ggc_strdup (report
);
1778 obstack_free (&temporary_obstack
, report
);
1779 TYPE_SIZE (this_class
) = error_mark_node
;
1782 CLASS_BEING_LAIDOUT (this_class
) = 1;
1784 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
1786 tree maybe_super_class
1787 = maybe_layout_super_class (super_class
, this_class
);
1788 if (maybe_super_class
== NULL
1789 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
1791 TYPE_SIZE (this_class
) = error_mark_node
;
1792 CLASS_BEING_LAIDOUT (this_class
) = 0;
1793 class_list
= TREE_CHAIN (class_list
);
1796 if (TYPE_SIZE (this_class
) == NULL_TREE
)
1797 push_super_field (this_class
, maybe_super_class
);
1800 for (field
= TYPE_FIELDS (this_class
);
1801 field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1803 if (FIELD_STATIC (field
))
1805 /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
1806 SET_DECL_ASSEMBLER_NAME (field
,
1808 (&temporary_obstack
, field
));
1812 layout_type (this_class
);
1814 /* Also recursively load/layout any superinterfaces, but only if
1815 class was loaded from bytecode. The source parser will take care
1817 if (!CLASS_FROM_SOURCE_P (this_class
))
1819 tree basetype_vec
= TYPE_BINFO_BASETYPES (this_class
);
1823 int n
= TREE_VEC_LENGTH (basetype_vec
) - 1;
1825 for (i
= n
; i
> 0; i
--)
1827 tree vec_elt
= TREE_VEC_ELT (basetype_vec
, i
);
1828 tree super_interface
= BINFO_TYPE (vec_elt
);
1830 tree maybe_super_interface
1831 = maybe_layout_super_class (super_interface
, NULL_TREE
);
1832 if (maybe_super_interface
== NULL
1833 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
1835 TYPE_SIZE (this_class
) = error_mark_node
;
1836 CLASS_BEING_LAIDOUT (this_class
) = 0;
1837 class_list
= TREE_CHAIN (class_list
);
1844 /* Convert the size back to an SI integer value. */
1845 TYPE_SIZE_UNIT (this_class
) =
1846 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
1848 CLASS_BEING_LAIDOUT (this_class
) = 0;
1849 class_list
= TREE_CHAIN (class_list
);
1853 add_miranda_methods (tree base_class
, tree search_class
)
1855 tree basetype_vec
= TYPE_BINFO_BASETYPES (search_class
);
1856 int i
, n
= TREE_VEC_LENGTH (basetype_vec
);
1857 for (i
= 1; i
< n
; ++i
)
1860 tree elt
= TREE_VEC_ELT (basetype_vec
, i
);
1861 if (elt
== NULL_TREE
)
1863 elt
= BINFO_TYPE (elt
);
1865 /* Ensure that interface methods are seen in declared order. */
1866 layout_class_methods (elt
);
1868 /* All base classes will have been laid out at this point, so the order
1869 will be correct. This code must match similar layout code in the
1871 for (method_decl
= TYPE_METHODS (elt
);
1872 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
1876 /* An interface can have <clinit>. */
1877 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
1880 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
1881 override
= lookup_argument_method (base_class
,
1882 DECL_NAME (method_decl
), sig
);
1883 if (override
== NULL_TREE
)
1885 /* Found a Miranda method. Add it. */
1887 sig
= build_java_signature (TREE_TYPE (method_decl
));
1889 = add_method (base_class
,
1890 get_access_flags_from_decl (method_decl
),
1891 DECL_NAME (method_decl
), sig
);
1892 METHOD_INVISIBLE (new_method
) = 1;
1896 /* Try superinterfaces. */
1897 add_miranda_methods (base_class
, elt
);
1902 layout_class_methods (tree this_class
)
1904 tree method_decl
, dtable_count
;
1907 if (TYPE_NVIRTUALS (this_class
))
1910 super_class
= CLASSTYPE_SUPER (this_class
);
1914 super_class
= maybe_layout_super_class (super_class
, this_class
);
1915 if (!TYPE_NVIRTUALS (super_class
))
1916 layout_class_methods (super_class
);
1917 dtable_count
= TYPE_NVIRTUALS (super_class
);
1920 dtable_count
= integer_zero_node
;
1922 if (CLASS_ABSTRACT (TYPE_NAME (this_class
)))
1924 /* An abstract class can have methods which are declared only in
1925 an implemented interface. These are called "Miranda
1926 methods". We make a dummy method entry for such methods
1928 add_miranda_methods (this_class
, this_class
);
1931 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
1933 for (method_decl
= TYPE_METHODS (this_class
);
1934 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
1935 dtable_count
= layout_class_method (this_class
, super_class
,
1936 method_decl
, dtable_count
);
1938 TYPE_NVIRTUALS (this_class
) = dtable_count
;
1941 /* Lay METHOD_DECL out, returning a possibly new value of
1942 DTABLE_COUNT. Also mangle the method's name. */
1945 layout_class_method (tree this_class
, tree super_class
,
1946 tree method_decl
, tree dtable_count
)
1948 tree method_name
= DECL_NAME (method_decl
);
1950 TREE_PUBLIC (method_decl
) = 1;
1951 /* Considered external until we know what classes are being
1952 compiled into this object file. */
1953 DECL_EXTERNAL (method_decl
) = 1;
1955 /* This is a good occasion to mangle the method's name */
1956 SET_DECL_ASSEMBLER_NAME (method_decl
,
1957 java_mangle_decl (&temporary_obstack
,
1959 /* We don't generate a RTL for the method if it's abstract, or if
1960 it's an interface method that isn't clinit. */
1961 if (! METHOD_ABSTRACT (method_decl
)
1962 || (CLASS_INTERFACE (TYPE_NAME (this_class
))
1963 && (DECL_CLINIT_P (method_decl
))))
1964 make_decl_rtl (method_decl
, NULL
);
1966 if (ID_INIT_P (method_name
))
1968 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
1970 for (ptr
= p
; *ptr
; )
1975 DECL_CONSTRUCTOR_P (method_decl
) = 1;
1976 build_java_argument_signature (TREE_TYPE (method_decl
));
1978 else if (! METHOD_STATIC (method_decl
) && !DECL_ARTIFICIAL (method_decl
))
1981 build_java_argument_signature (TREE_TYPE (method_decl
));
1982 tree super_method
= lookup_argument_method (super_class
, method_name
,
1984 if (super_method
!= NULL_TREE
&& ! METHOD_PRIVATE (super_method
))
1986 DECL_VINDEX (method_decl
) = DECL_VINDEX (super_method
);
1987 if (DECL_VINDEX (method_decl
) == NULL_TREE
1988 && !CLASS_FROM_SOURCE_P (this_class
))
1989 error ("%Hnon-static method '%D' overrides static method",
1990 &DECL_SOURCE_LOCATION (method_decl
), method_decl
);
1992 else if (! METHOD_FINAL (method_decl
)
1993 && ! METHOD_PRIVATE (method_decl
)
1994 && ! CLASS_FINAL (TYPE_NAME (this_class
))
1997 DECL_VINDEX (method_decl
) = dtable_count
;
1998 dtable_count
= fold (build (PLUS_EXPR
, integer_type_node
,
1999 dtable_count
, integer_one_node
));
2003 return dtable_count
;
2007 register_class (void)
2009 /* END does not need to be registered with the garbage collector
2010 because it always points into the list given by REGISTERED_CLASS,
2011 and that variable is registered with the collector. */
2013 tree node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2014 tree current
= copy_node (node
);
2016 XEXP (DECL_RTL (current
), 0) = copy_rtx (XEXP (DECL_RTL(node
), 0));
2017 if (!registered_class
)
2018 registered_class
= current
;
2020 TREE_CHAIN (end
) = current
;
2025 /* Emit something to register classes at start-up time.
2027 The preferred mechanism is through the .jcr section, which contain
2028 a list of pointers to classes which get registered during
2029 constructor invocation time. The fallback mechanism is to generate
2030 a `constructor' function which calls _Jv_RegisterClass for each
2031 class in this file. */
2034 emit_register_classes (void)
2036 /* ??? This isn't quite the correct test. We also have to know
2037 that the target is using gcc's crtbegin/crtend objects rather
2038 than the ones that come with the operating system. */
2039 if (SUPPORTS_WEAK
&& targetm
.have_named_sections
)
2041 #ifdef JCR_SECTION_NAME
2043 named_section_flags (JCR_SECTION_NAME
, SECTION_WRITE
);
2044 assemble_align (POINTER_SIZE
);
2045 for (t
= registered_class
; t
; t
= TREE_CHAIN (t
))
2046 assemble_integer (XEXP (DECL_RTL (t
), 0),
2047 POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
2054 extern tree
get_file_function_name (int);
2055 tree init_name
= get_file_function_name ('I');
2056 tree init_type
= build_function_type (void_type_node
, end_params_node
);
2059 location_t saved_loc
= input_location
;
2061 init_decl
= build_decl (FUNCTION_DECL
, init_name
, init_type
);
2062 SET_DECL_ASSEMBLER_NAME (init_decl
, init_name
);
2063 DECL_SOURCE_LINE (init_decl
) = 0;
2064 TREE_STATIC (init_decl
) = 1;
2065 current_function_decl
= init_decl
;
2066 DECL_RESULT (init_decl
) = build_decl (RESULT_DECL
, NULL_TREE
,
2069 /* It can be a static function as long as collect2 does not have
2070 to scan the object file to find its ctor/dtor routine. */
2071 TREE_PUBLIC (init_decl
) = ! targetm
.have_ctors_dtors
;
2073 /* Suppress spurious warnings. */
2074 TREE_USED (init_decl
) = 1;
2077 make_decl_rtl (init_decl
, NULL
);
2078 init_function_start (init_decl
);
2079 expand_function_start (init_decl
, 0);
2081 /* Do not allow the function to be deferred. */
2082 current_function_cannot_inline
2083 = "static constructors and destructors cannot be inlined";
2085 for ( t
= registered_class
; t
; t
= TREE_CHAIN (t
))
2086 emit_library_call (registerClass_libfunc
, 0, VOIDmode
, 1,
2087 XEXP (DECL_RTL (t
), 0), Pmode
);
2088 input_location
= DECL_SOURCE_LOCATION (init_decl
);
2089 expand_function_end ();
2091 rest_of_compilation (init_decl
);
2092 current_function_decl
= NULL_TREE
;
2094 if (targetm
.have_ctors_dtors
)
2095 (* targetm
.asm_out
.constructor
) (XEXP (DECL_RTL (init_decl
), 0),
2096 DEFAULT_INIT_PRIORITY
);
2097 input_location
= saved_loc
;
2101 /* Make a method_symbol_type (_Jv_MethodSymbol) node for METHOD. */
2104 build_method_symbols_entry (tree method
)
2106 tree clname
, name
, signature
, method_symbol
;
2108 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (method
))));
2109 name
= build_utf8_ref (DECL_NAME (method
));
2110 signature
= build_java_signature (TREE_TYPE (method
));
2111 signature
= build_utf8_ref (unmangle_classname
2112 (IDENTIFIER_POINTER (signature
),
2113 IDENTIFIER_LENGTH (signature
)));
2115 START_RECORD_CONSTRUCTOR (method_symbol
, method_symbol_type
);
2116 PUSH_FIELD_VALUE (method_symbol
, "clname", clname
);
2117 PUSH_FIELD_VALUE (method_symbol
, "name", name
);
2118 PUSH_FIELD_VALUE (method_symbol
, "signature", signature
);
2119 FINISH_RECORD_CONSTRUCTOR (method_symbol
);
2120 TREE_CONSTANT (method_symbol
) = 1;
2122 return method_symbol
;
2125 /* Emit the offset symbols table for indirect virtual dispatch. */
2128 emit_offset_symbol_table (void)
2130 tree method_list
, method
, table
, list
, null_symbol
;
2131 tree otable_bound
, otable_array_type
;
2134 /* Only emit an offset table if this translation unit actually made virtual
2136 if (otable_methods
== NULL_TREE
)
2139 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2141 method_list
= otable_methods
;
2143 while (method_list
!= NULL_TREE
)
2145 method
= TREE_VALUE (method_list
);
2146 list
= tree_cons (NULL_TREE
, build_method_symbols_entry (method
), list
);
2147 method_list
= TREE_CHAIN (method_list
);
2151 /* Terminate the list with a "null" entry. */
2152 START_RECORD_CONSTRUCTOR (null_symbol
, method_symbol_type
);
2153 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2154 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2155 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2156 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2157 TREE_CONSTANT (null_symbol
) = 1;
2158 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2160 /* Put the list in the right order and make it a constructor. */
2161 list
= nreverse (list
);
2162 table
= build_constructor (method_symbols_array_type
, list
);
2164 /* Make it the initial value for otable_syms and emit the decl. */
2165 DECL_INITIAL (otable_syms_decl
) = table
;
2166 DECL_ARTIFICIAL (otable_syms_decl
) = 1;
2167 DECL_IGNORED_P (otable_syms_decl
) = 1;
2168 rest_of_decl_compilation (otable_syms_decl
, NULL
, 1, 0);
2170 /* Now that its size is known, redefine otable as an uninitialized static
2171 array of INDEX + 1 integers. The extra entry is used by the runtime
2172 to track whether the otable has been initialized. */
2173 otable_bound
= build_index_type (build_int_2 (index
, 0));
2174 otable_array_type
= build_array_type (integer_type_node
, otable_bound
);
2175 otable_decl
= build_decl (VAR_DECL
, get_identifier ("otable"),
2177 TREE_STATIC (otable_decl
) = 1;
2178 TREE_READONLY (otable_decl
) = 1;
2179 rest_of_decl_compilation (otable_decl
, NULL
, 1, 0);
2183 init_class_processing (void)
2185 registerClass_libfunc
= gen_rtx_SYMBOL_REF (Pmode
, "_Jv_RegisterClass");
2186 fields_ident
= get_identifier ("fields");
2187 info_ident
= get_identifier ("info");
2188 gcc_obstack_init (&temporary_obstack
);
2191 static hashval_t
java_treetreehash_hash (const void *);
2192 static int java_treetreehash_compare (const void *, const void *);
2194 /* A hash table mapping trees to trees. Used generally. */
2196 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2199 java_treetreehash_hash (const void *k_p
)
2201 struct treetreehash_entry
*k
= (struct treetreehash_entry
*) k_p
;
2202 return JAVA_TREEHASHHASH_H (k
->key
);
2206 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
2208 struct treetreehash_entry
* k1
= (struct treetreehash_entry
*) k1_p
;
2209 tree k2
= (tree
) k2_p
;
2210 return (k1
->key
== k2
);
2214 java_treetreehash_find (htab_t ht
, tree t
)
2216 struct treetreehash_entry
*e
;
2217 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2218 e
= htab_find_with_hash (ht
, t
, hv
);
2226 java_treetreehash_new (htab_t ht
, tree t
)
2229 struct treetreehash_entry
*tthe
;
2230 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2232 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
2235 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
2240 tthe
= (struct treetreehash_entry
*) *e
;
2241 return &tthe
->value
;
2245 java_treetreehash_create (size_t size
, int gc
)
2248 return htab_create_ggc (size
, java_treetreehash_hash
,
2249 java_treetreehash_compare
, NULL
);
2251 return htab_create_alloc (size
, java_treetreehash_hash
,
2252 java_treetreehash_compare
, free
, xcalloc
, free
);
2255 #include "gt-java-class.h"