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 int assume_compiled (const char *);
61 static tree
build_method_symbols_entry (tree
);
63 static GTY(()) rtx registerClass_libfunc
;
65 struct obstack temporary_obstack
;
67 /* The compiler generates different code depending on whether or not
68 it can assume certain classes have been compiled down to native
69 code or not. The compiler options -fassume-compiled= and
70 -fno-assume-compiled= are used to create a tree of
71 assume_compiled_node objects. This tree is queried to determine if
72 a class is assume to be compiled or not. Each node in the tree
73 represents either a package or a specific class. */
75 typedef struct assume_compiled_node_struct
77 /* The class or package name. */
80 /* Nonzero if this represents an exclusion. */
83 /* Pointers to other nodes in the tree. */
84 struct assume_compiled_node_struct
*parent
;
85 struct assume_compiled_node_struct
*sibling
;
86 struct assume_compiled_node_struct
*child
;
87 } assume_compiled_node
;
89 static assume_compiled_node
*find_assume_compiled_node (assume_compiled_node
*,
92 /* This is the root of the include/exclude tree. */
94 static assume_compiled_node
*assume_compiled_tree
;
96 static GTY(()) tree class_roots
[5];
97 #define registered_class class_roots[0]
98 #define fields_ident class_roots[1] /* get_identifier ("fields") */
99 #define info_ident class_roots[2] /* get_identifier ("info") */
100 #define class_list class_roots[3]
101 #define class_dtable_decl class_roots[4]
103 /* Return the node that most closely represents the class whose name
104 is IDENT. Start the search from NODE. Return NULL if an
105 appropriate node does not exist. */
107 static assume_compiled_node
*
108 find_assume_compiled_node (assume_compiled_node
*node
, const char *ident
)
112 size_t node_ident_length
= strlen (node
->ident
);
114 /* node_ident_length is zero at the root of the tree. If the
115 identifiers are the same length, then we have matching
116 classes. Otherwise check if we've matched an enclosing
119 if (node_ident_length
== 0
120 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
121 && (strlen (ident
) == node_ident_length
122 || ident
[node_ident_length
] == '.')))
124 /* We've found a match, however, there might be a more
127 assume_compiled_node
*found
= find_assume_compiled_node (node
->child
,
135 /* No match yet. Continue through the sibling list. */
136 node
= node
->sibling
;
139 /* No match at all in this tree. */
143 /* Add a new IDENT to the include/exclude tree. It's an exclusion
144 if EXCLUDEP is nonzero. */
147 add_assume_compiled (const char *ident
, int excludep
)
150 assume_compiled_node
*parent
;
151 assume_compiled_node
*node
=
152 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 const char *save_input_filename
= input_filename
;
312 int save_lineno
= lineno
;
313 tree source_name
= identifier_subst (class_name
, "", '.', '/', ".java");
314 CLASS_P (class_type
) = 1;
315 input_filename
= IDENTIFIER_POINTER (source_name
);
317 decl
= build_decl (TYPE_DECL
, class_name
, class_type
);
319 /* dbxout needs a DECL_SIZE if in gstabs mode */
320 DECL_SIZE (decl
) = integer_zero_node
;
322 input_filename
= save_input_filename
;
323 lineno
= save_lineno
;
324 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
325 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
327 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
328 both a typedef and in the struct name-space. We may want to re-visit
329 this later, but for now it reduces the changes needed for gdb. */
330 DECL_ARTIFICIAL (decl
) = 1;
332 pushdecl_top_level (decl
);
337 /* Finds the (global) class named NAME. Creates the class if not found.
338 Also creates associated TYPE_DECL.
339 Does not check if the class actually exists, load the class,
340 fill in field or methods, or do layout_type. */
343 lookup_class (tree name
)
345 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
346 if (decl
== NULL_TREE
)
347 decl
= push_class (make_class (), name
);
348 return TREE_TYPE (decl
);
352 set_super_info (int access_flags
, tree this_class
,
353 tree super_class
, int interfaces_count
)
355 int total_supers
= interfaces_count
;
356 tree class_decl
= TYPE_NAME (this_class
);
360 TYPE_BINFO_BASETYPES (this_class
) = make_tree_vec (total_supers
);
363 tree super_binfo
= make_tree_vec (BINFO_ELTS
);
364 BINFO_TYPE (super_binfo
) = super_class
;
365 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
366 TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (this_class
)), 0)
368 CLASS_HAS_SUPER (this_class
) = 1;
371 set_class_decl_access_flags (access_flags
, class_decl
);
375 set_class_decl_access_flags (int access_flags
, tree class_decl
)
377 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
378 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
379 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
380 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
381 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
382 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
383 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
384 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
385 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
388 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
389 direct sub-classes of Object are 1, and so on. */
392 class_depth (tree clas
)
395 if (! CLASS_LOADED_P (clas
))
396 load_class (clas
, 1);
397 if (TYPE_SIZE (clas
) == error_mark_node
)
399 while (clas
!= object_type_node
)
402 clas
= TYPE_BINFO_BASETYPE (clas
, 0);
407 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
410 interface_of_p (tree type1
, tree type2
)
415 if (!(basetype_vec
= TYPE_BINFO_BASETYPES (type2
)))
417 n
= TREE_VEC_LENGTH (basetype_vec
);
418 for (i
= 0; i
< n
; i
++)
420 tree vec_elt
= TREE_VEC_ELT (basetype_vec
, i
);
421 if (vec_elt
&& BINFO_TYPE (vec_elt
) == type1
)
424 for (i
= 0; i
< n
; i
++)
426 tree vec_elt
= TREE_VEC_ELT (basetype_vec
, i
);
427 if (vec_elt
&& BINFO_TYPE (vec_elt
)
428 && interface_of_p (type1
, BINFO_TYPE (vec_elt
)))
434 /* Return true iff TYPE1 inherits from TYPE2. */
437 inherits_from_p (tree type1
, tree type2
)
439 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
443 type1
= CLASSTYPE_SUPER (type1
);
448 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
451 enclosing_context_p (tree type1
, tree type2
)
453 if (!INNER_CLASS_TYPE_P (type2
))
456 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
458 type2
= (INNER_CLASS_TYPE_P (type2
) ?
459 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
468 /* Return 1 iff there exists a common enclosing context between TYPE1
471 int common_enclosing_context_p (tree type1
, tree type2
)
473 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
476 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
477 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
478 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
481 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
482 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
483 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
485 if (type1
== current
)
492 add_interface_do (tree basetype_vec
, tree interface_class
, int i
)
494 tree interface_binfo
= make_tree_vec (BINFO_ELTS
);
495 BINFO_TYPE (interface_binfo
) = interface_class
;
496 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
497 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
498 TREE_VIA_VIRTUAL (interface_binfo
) = 1;
499 TREE_VEC_ELT (basetype_vec
, i
) = interface_binfo
;
502 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
503 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
504 if attempt is made to add it twice. */
507 maybe_add_interface (tree this_class
, tree interface_class
)
509 tree basetype_vec
= TYPE_BINFO_BASETYPES (this_class
);
511 int n
= TREE_VEC_LENGTH (basetype_vec
);
516 error ("internal error - too many interface type");
519 else if (TREE_VEC_ELT (basetype_vec
, i
) == NULL_TREE
)
521 else if (BINFO_TYPE (TREE_VEC_ELT (basetype_vec
, i
)) == interface_class
)
522 return interface_class
;
524 add_interface_do (basetype_vec
, interface_class
, i
);
528 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
531 add_interface (tree this_class
, tree interface_class
)
533 tree basetype_vec
= TYPE_BINFO_BASETYPES (this_class
);
535 int n
= TREE_VEC_LENGTH (basetype_vec
);
540 error ("internal error - too many interface type");
543 else if (TREE_VEC_ELT (basetype_vec
, i
) == NULL_TREE
)
546 add_interface_do (basetype_vec
, interface_class
, i
);
550 /* Return the address of a pointer to the first FUNCTION_DECL
551 in the list (*LIST) whose DECL_NAME is NAME. */
554 find_named_method (tree
*list
, tree name
)
556 while (*list
&& DECL_NAME (*list
) != name
)
557 list
= &TREE_CHAIN (*list
);
563 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
565 if (access_flags
& ACC_STATIC
)
567 return build_method_type (this_class
, fntype
);
571 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
573 tree method_type
, fndecl
;
575 method_type
= build_java_method_type (function_type
,
576 this_class
, access_flags
);
578 fndecl
= build_decl (FUNCTION_DECL
, name
, method_type
);
579 DECL_CONTEXT (fndecl
) = this_class
;
581 DECL_LANG_SPECIFIC (fndecl
)
582 = ggc_alloc_cleared (sizeof (struct lang_decl
));
583 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
585 /* Initialize the static initializer test table. */
587 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
588 java_treetreehash_create (10, 1);
590 /* Initialize the initialized (static) class table. */
591 if (access_flags
& ACC_STATIC
)
592 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
593 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
595 /* Initialize the static method invocation compound list */
596 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl
) = NULL_TREE
;
598 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
599 TYPE_METHODS (this_class
) = fndecl
;
601 /* Notice that this is a finalizer and update the class type
602 accordingly. This is used to optimize instance allocation. */
603 if (name
== finalize_identifier_node
604 && TREE_TYPE (function_type
) == void_type_node
605 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
606 HAS_FINALIZER_P (this_class
) = 1;
608 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
609 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
610 if (access_flags
& ACC_PRIVATE
)
611 METHOD_PRIVATE (fndecl
) = DECL_INLINE (fndecl
) = 1;
612 if (access_flags
& ACC_NATIVE
)
614 METHOD_NATIVE (fndecl
) = 1;
615 DECL_EXTERNAL (fndecl
) = 1;
617 if (access_flags
& ACC_STATIC
)
618 METHOD_STATIC (fndecl
) = DECL_INLINE (fndecl
) = 1;
619 if (access_flags
& ACC_FINAL
)
620 METHOD_FINAL (fndecl
) = DECL_INLINE (fndecl
) = 1;
621 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
622 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
623 if (access_flags
& ACC_TRANSIENT
) METHOD_TRANSIENT (fndecl
) = 1;
624 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
628 /* Add a method to THIS_CLASS.
629 The method's name is NAME.
630 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
633 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
635 tree function_type
, fndecl
;
636 const unsigned char *sig
637 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
640 fatal_error ("bad method signature");
642 function_type
= get_type_from_signature (method_sig
);
643 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
644 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
649 add_field (tree
class, tree name
, tree field_type
, int flags
)
651 int is_static
= (flags
& ACC_STATIC
) != 0;
653 field
= build_decl (is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
654 TREE_CHAIN (field
) = TYPE_FIELDS (class);
655 TYPE_FIELDS (class) = field
;
656 DECL_CONTEXT (field
) = class;
658 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
659 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
660 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
661 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
662 if (flags
& ACC_VOLATILE
) FIELD_VOLATILE (field
) = 1;
663 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
666 FIELD_STATIC (field
) = 1;
667 /* Always make field externally visible. This is required so
668 that native methods can always access the field. */
669 TREE_PUBLIC (field
) = 1;
670 /* Considered external until we know what classes are being
671 compiled into this object file. */
672 DECL_EXTERNAL (field
) = 1;
678 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
681 set_constant_value (tree field
, tree constant
)
683 if (field
== NULL_TREE
)
684 warning ("misplaced ConstantValue attribute (not in any field)");
685 else if (DECL_INITIAL (field
) != NULL_TREE
)
686 warning ("duplicate ConstantValue attribute for field '%s'",
687 IDENTIFIER_POINTER (DECL_NAME (field
)));
690 DECL_INITIAL (field
) = constant
;
691 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
692 && ! (TREE_TYPE (constant
) == int_type_node
693 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
694 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
695 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
696 && TREE_TYPE (field
) == string_ptr_type_node
))
697 error ("ConstantValue attribute of field '%s' has wrong type",
698 IDENTIFIER_POINTER (DECL_NAME (field
)));
699 if (FIELD_FINAL (field
))
700 DECL_FIELD_FINAL_IUD (field
) = 1;
704 /* Count the number of Unicode chars encoded in a given Ut8 string. */
708 strLengthUtf8 (char *str
, int len
)
710 register unsigned char* ptr
= (unsigned char*) str
;
711 register unsigned char *limit
= ptr
+ len
;
713 for (; ptr
< limit
; str_length
++) {
714 if (UTF8_GET (ptr
, limit
) < 0)
722 /* Calculate a hash value for a string encoded in Utf8 format.
723 * This returns the same hash value as specified for java.lang.String.hashCode.
727 hashUtf8String (const char *str
, int len
)
729 register const unsigned char* ptr
= (const unsigned char*) str
;
730 register const unsigned char *limit
= ptr
+ len
;
734 int ch
= UTF8_GET (ptr
, limit
);
735 /* Updated specification from
736 http://www.javasoft.com/docs/books/jls/clarify.html. */
737 hash
= (31 * hash
) + ch
;
742 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
745 build_utf8_ref (tree name
)
747 const char * name_ptr
= IDENTIFIER_POINTER(name
);
748 int name_len
= IDENTIFIER_LENGTH(name
);
750 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
751 static int utf8_count
= 0;
753 tree ref
= IDENTIFIER_UTF8_REF (name
);
755 if (ref
!= NULL_TREE
)
758 ctype
= make_node (RECORD_TYPE
);
759 str_type
= build_prim_array_type (unsigned_byte_type_node
,
760 name_len
+ 1); /* Allow for final '\0'. */
761 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
762 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
763 PUSH_FIELD (ctype
, field
, "data", str_type
);
764 FINISH_RECORD (ctype
);
765 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
766 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
767 PUSH_FIELD_VALUE (cinit
, "hash", build_int_2 (name_hash
, 0));
768 PUSH_FIELD_VALUE (cinit
, "length", build_int_2 (name_len
, 0));
769 string
= build_string (name_len
, name_ptr
);
770 TREE_TYPE (string
) = str_type
;
771 PUSH_FIELD_VALUE (cinit
, "data", string
);
772 FINISH_RECORD_CONSTRUCTOR (cinit
);
773 TREE_CONSTANT (cinit
) = 1;
775 /* Generate a unique-enough identifier. */
776 sprintf(buf
, "_Utf%d", ++utf8_count
);
778 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
779 TREE_STATIC (decl
) = 1;
780 DECL_ARTIFICIAL (decl
) = 1;
781 DECL_IGNORED_P (decl
) = 1;
782 TREE_READONLY (decl
) = 1;
783 TREE_THIS_VOLATILE (decl
) = 0;
784 DECL_INITIAL (decl
) = cinit
;
785 #ifdef HAVE_GAS_SHF_MERGE
788 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
789 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
790 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
791 if (flag_merge_constants
&& decl_size
< 256)
794 int flags
= (SECTION_OVERRIDE
795 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
796 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
797 named_section_flags (buf
, flags
);
798 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
802 TREE_CHAIN (decl
) = utf8_decl_list
;
803 layout_decl (decl
, 0);
805 rest_of_decl_compilation (decl
, (char*) 0, global_bindings_p (), 0);
806 utf8_decl_list
= decl
;
807 make_decl_rtl (decl
, (char*) 0);
808 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
809 IDENTIFIER_UTF8_REF (name
) = ref
;
813 /* Build a reference to the class TYPE.
814 Also handles primitive types and array types. */
817 build_class_ref (tree type
)
819 int is_compiled
= is_compiled_class (type
);
822 tree ref
, decl_name
, decl
;
823 if (TREE_CODE (type
) == POINTER_TYPE
)
824 type
= TREE_TYPE (type
);
825 if (TREE_CODE (type
) == RECORD_TYPE
)
827 if (TYPE_SIZE (type
) == error_mark_node
)
828 return null_pointer_node
;
829 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
830 "", '/', '/', ".class");
831 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
832 if (decl
== NULL_TREE
)
834 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
835 DECL_SIZE (decl
) = TYPE_SIZE (class_type_node
);
836 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (class_type_node
);
837 TREE_STATIC (decl
) = 1;
838 TREE_PUBLIC (decl
) = 1;
839 DECL_IGNORED_P (decl
) = 1;
840 DECL_ARTIFICIAL (decl
) = 1;
841 if (is_compiled
== 1)
842 DECL_EXTERNAL (decl
) = 1;
843 SET_DECL_ASSEMBLER_NAME (decl
,
844 java_mangle_class_field
845 (&temporary_obstack
, type
));
846 make_decl_rtl (decl
, NULL
);
847 pushdecl_top_level (decl
);
854 if (flag_emit_class_files
)
856 const char *prim_class_name
;
858 if (type
== char_type_node
)
859 prim_class_name
= "java.lang.Character";
860 else if (type
== boolean_type_node
)
861 prim_class_name
= "java.lang.Boolean";
862 else if (type
== byte_type_node
)
863 prim_class_name
= "java.lang.Byte";
864 else if (type
== short_type_node
)
865 prim_class_name
= "java.lang.Short";
866 else if (type
== int_type_node
)
867 prim_class_name
= "java.lang.Integer";
868 else if (type
== long_type_node
)
869 prim_class_name
= "java.lang.Long";
870 else if (type
== float_type_node
)
871 prim_class_name
= "java.lang.Float";
872 else if (type
== double_type_node
)
873 prim_class_name
= "java.lang.Double";
874 else if (type
== void_type_node
)
875 prim_class_name
= "java.lang.Void";
879 prim_class
= lookup_class (get_identifier (prim_class_name
));
880 return build (COMPONENT_REF
, NULL_TREE
,
881 prim_class
, TYPE_identifier_node
);
883 decl_name
= TYPE_NAME (type
);
884 if (TREE_CODE (decl_name
) == TYPE_DECL
)
885 decl_name
= DECL_NAME (decl_name
);
886 name
= IDENTIFIER_POINTER (decl_name
);
887 if (strncmp (name
, "promoted_", 9) == 0)
889 sprintf (buffer
, "_Jv_%sClass", name
);
890 decl_name
= get_identifier (buffer
);
891 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
892 if (decl
== NULL_TREE
)
894 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
895 TREE_STATIC (decl
) = 1;
896 TREE_PUBLIC (decl
) = 1;
897 DECL_EXTERNAL (decl
) = 1;
898 make_decl_rtl (decl
, NULL
);
899 pushdecl_top_level (decl
);
903 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
910 index
= alloc_class_constant (type
);
911 cl
= build_ref_from_constant_pool (index
);
912 TREE_TYPE (cl
) = promote_type (class_ptr_type
);
918 build_static_field_ref (tree fdecl
)
920 tree fclass
= DECL_CONTEXT (fdecl
);
921 int is_compiled
= is_compiled_class (fclass
);
923 /* Allow static final fields to fold to a constant. When using
924 -fno-assume-compiled, gcj will sometimes try to fold a field from
925 an uncompiled class. This is required when the field in question
926 meets the appropriate criteria for a compile-time constant.
927 However, currently sometimes gcj is too eager and will end up
928 returning the field itself, leading to an incorrect external
929 reference being generated. */
931 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
932 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
933 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
934 && TREE_CONSTANT (DECL_INITIAL (fdecl
))))
936 if (!DECL_RTL_SET_P (fdecl
))
938 if (is_compiled
== 1)
939 DECL_EXTERNAL (fdecl
) = 1;
940 make_decl_rtl (fdecl
, NULL
);
947 * *(FTYPE*)build_class_ref(FCLASS)->fields[INDEX].info.addr */
948 tree ref
= build_class_ref (fclass
);
951 ref
= build1 (INDIRECT_REF
, class_type_node
, ref
);
952 ref
= build (COMPONENT_REF
, field_ptr_type_node
, ref
,
953 lookup_field (&class_type_node
, fields_ident
));
955 for (fld
= TYPE_FIELDS (fclass
); ; fld
= TREE_CHAIN (fld
))
959 if (fld
== NULL_TREE
)
960 fatal_error ("field '%s' not found in class",
961 IDENTIFIER_POINTER (DECL_NAME (fdecl
)));
962 if (FIELD_STATIC (fld
))
965 field_index
*= int_size_in_bytes (field_type_node
);
966 ref
= fold (build (PLUS_EXPR
, field_ptr_type_node
,
967 ref
, build_int_2 (field_index
, 0)));
968 ref
= build1 (INDIRECT_REF
, field_type_node
, ref
);
969 ref
= build (COMPONENT_REF
, field_info_union_node
,
970 ref
, lookup_field (&field_type_node
, info_ident
));
971 ref
= build (COMPONENT_REF
, ptr_type_node
,
972 ref
, TREE_CHAIN (TYPE_FIELDS (field_info_union_node
)));
973 return fold (build1 (INDIRECT_REF
, TREE_TYPE(fdecl
), ref
));
978 get_access_flags_from_decl (tree decl
)
980 int access_flags
= 0;
981 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
983 if (FIELD_STATIC (decl
))
984 access_flags
|= ACC_STATIC
;
985 if (FIELD_PUBLIC (decl
))
986 access_flags
|= ACC_PUBLIC
;
987 if (FIELD_PROTECTED (decl
))
988 access_flags
|= ACC_PROTECTED
;
989 if (FIELD_PRIVATE (decl
))
990 access_flags
|= ACC_PRIVATE
;
991 if (FIELD_FINAL (decl
))
992 access_flags
|= ACC_FINAL
;
993 if (FIELD_VOLATILE (decl
))
994 access_flags
|= ACC_VOLATILE
;
995 if (FIELD_TRANSIENT (decl
))
996 access_flags
|= ACC_TRANSIENT
;
999 if (TREE_CODE (decl
) == TYPE_DECL
)
1001 if (CLASS_PUBLIC (decl
))
1002 access_flags
|= ACC_PUBLIC
;
1003 if (CLASS_FINAL (decl
))
1004 access_flags
|= ACC_FINAL
;
1005 if (CLASS_SUPER (decl
))
1006 access_flags
|= ACC_SUPER
;
1007 if (CLASS_INTERFACE (decl
))
1008 access_flags
|= ACC_INTERFACE
;
1009 if (CLASS_ABSTRACT (decl
))
1010 access_flags
|= ACC_ABSTRACT
;
1011 if (CLASS_STATIC (decl
))
1012 access_flags
|= ACC_STATIC
;
1013 if (CLASS_PRIVATE (decl
))
1014 access_flags
|= ACC_PRIVATE
;
1015 if (CLASS_PROTECTED (decl
))
1016 access_flags
|= ACC_PROTECTED
;
1017 if (CLASS_STRICTFP (decl
))
1018 access_flags
|= ACC_STRICT
;
1019 return access_flags
;
1021 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1023 if (METHOD_PUBLIC (decl
))
1024 access_flags
|= ACC_PUBLIC
;
1025 if (METHOD_PRIVATE (decl
))
1026 access_flags
|= ACC_PRIVATE
;
1027 if (METHOD_PROTECTED (decl
))
1028 access_flags
|= ACC_PROTECTED
;
1029 if (METHOD_STATIC (decl
))
1030 access_flags
|= ACC_STATIC
;
1031 if (METHOD_FINAL (decl
))
1032 access_flags
|= ACC_FINAL
;
1033 if (METHOD_SYNCHRONIZED (decl
))
1034 access_flags
|= ACC_SYNCHRONIZED
;
1035 if (METHOD_NATIVE (decl
))
1036 access_flags
|= ACC_NATIVE
;
1037 if (METHOD_ABSTRACT (decl
))
1038 access_flags
|= ACC_ABSTRACT
;
1039 if (METHOD_TRANSIENT (decl
))
1040 access_flags
|= ACC_TRANSIENT
;
1041 if (METHOD_STRICTFP (decl
))
1042 access_flags
|= ACC_STRICT
;
1043 return access_flags
;
1049 make_field_value (tree fdecl
)
1053 tree type
= TREE_TYPE (fdecl
);
1054 int resolved
= is_compiled_class (type
);
1056 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1057 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1059 type
= build_class_ref (type
);
1062 tree signature
= build_java_signature (type
);
1064 type
= build_utf8_ref (unmangle_classname
1065 (IDENTIFIER_POINTER (signature
),
1066 IDENTIFIER_LENGTH (signature
)));
1068 PUSH_FIELD_VALUE (finit
, "type", type
);
1070 flags
= get_access_flags_from_decl (fdecl
);
1072 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1074 PUSH_FIELD_VALUE (finit
, "accflags", build_int_2 (flags
, 0));
1075 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1079 build (CONSTRUCTOR
, field_info_union_node
, NULL_TREE
,
1081 ((FIELD_STATIC (fdecl
)
1082 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1083 : TYPE_FIELDS (field_info_union_node
)),
1084 (FIELD_STATIC (fdecl
)
1085 ? build_address_of (build_static_field_ref (fdecl
))
1086 : byte_position (fdecl
)))));
1088 FINISH_RECORD_CONSTRUCTOR (finit
);
1093 make_method_value (tree mdecl
)
1095 static int method_name_count
= 0;
1099 #define ACC_TRANSLATED 0x4000
1100 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1102 if (!flag_indirect_dispatch
&& DECL_VINDEX (mdecl
) != NULL_TREE
)
1103 index
= DECL_VINDEX (mdecl
);
1105 index
= integer_minus_one_node
;
1107 code
= null_pointer_node
;
1108 if (DECL_RTL_SET_P (mdecl
))
1109 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
, mdecl
);
1110 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1111 PUSH_FIELD_VALUE (minit
, "name",
1112 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1113 init_identifier_node
1114 : DECL_NAME (mdecl
)));
1116 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1117 PUSH_FIELD_VALUE (minit
, "signature",
1120 (IDENTIFIER_POINTER(signature
),
1121 IDENTIFIER_LENGTH(signature
)))));
1123 PUSH_FIELD_VALUE (minit
, "accflags", build_int_2 (accflags
, 0));
1124 PUSH_FIELD_VALUE (minit
, "index", index
);
1125 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1128 /* Compute the `throws' information for the method. */
1129 tree table
= null_pointer_node
;
1130 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1132 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1133 tree iter
, type
, array
;
1136 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1137 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1139 iter
= TREE_CHAIN (iter
))
1141 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1143 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1144 IDENTIFIER_LENGTH (sig
)));
1145 table
= tree_cons (NULL_TREE
, utf8
, table
);
1147 type
= build_prim_array_type (ptr_type_node
, length
);
1148 table
= build (CONSTRUCTOR
, type
, NULL_TREE
, table
);
1149 /* Compute something unique enough. */
1150 sprintf (buf
, "_methods%d", method_name_count
++);
1151 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1152 DECL_INITIAL (array
) = table
;
1153 TREE_STATIC (array
) = 1;
1154 DECL_ARTIFICIAL (array
) = 1;
1155 DECL_IGNORED_P (array
) = 1;
1156 rest_of_decl_compilation (array
, (char*) 0, 1, 0);
1158 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1161 PUSH_FIELD_VALUE (minit
, "throws", table
);
1164 FINISH_RECORD_CONSTRUCTOR (minit
);
1169 get_dispatch_vector (tree type
)
1171 tree vtable
= TYPE_VTABLE (type
);
1173 if (vtable
== NULL_TREE
)
1177 tree super
= CLASSTYPE_SUPER (type
);
1178 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1179 vtable
= make_tree_vec (nvirtuals
);
1180 TYPE_VTABLE (type
) = vtable
;
1181 if (super
!= NULL_TREE
)
1183 tree super_vtable
= get_dispatch_vector (super
);
1185 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1186 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1189 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1190 method
= TREE_CHAIN (method
))
1191 if (DECL_VINDEX (method
) != NULL_TREE
1192 && host_integerp (DECL_VINDEX (method
), 0))
1193 TREE_VEC_ELT (vtable
, tree_low_cst (DECL_VINDEX (method
), 0))
1201 get_dispatch_table (tree type
, tree this_class_addr
)
1203 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1204 tree vtable
= get_dispatch_vector (type
);
1206 tree list
= NULL_TREE
;
1207 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1211 for (i
= nvirtuals
; --i
>= 0; )
1213 tree method
= TREE_VEC_ELT (vtable
, i
);
1214 if (METHOD_ABSTRACT (method
))
1217 warning_with_decl (method
,
1218 "abstract method in non-abstract class");
1220 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1221 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1222 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1224 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1228 if (!DECL_RTL_SET_P (method
))
1229 make_decl_rtl (method
, NULL
);
1231 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1232 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1234 tree fdesc
= build (FDESC_EXPR
, nativecode_ptr_type_node
,
1235 method
, build_int_2 (j
, 0));
1236 TREE_CONSTANT (fdesc
) = 1;
1237 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1240 list
= tree_cons (NULL_TREE
,
1241 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1247 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1248 using the Boehm GC we sometimes stash a GC type descriptor
1249 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1250 the emitted byte count during the output to the assembly file. */
1251 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1252 fake "function descriptor". It's first word is the is the class
1253 pointer, and subsequent words (usually one) contain the GC descriptor.
1254 In all other cases, we reserve two extra vtable slots. */
1255 gc_descr
= get_boehm_type_descriptor (type
);
1256 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1257 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1258 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1259 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1261 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1262 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1263 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1264 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1266 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1267 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1268 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1270 return build (CONSTRUCTOR
,
1271 build_prim_array_type (nativecode_ptr_type_node
, arraysize
),
1276 supers_all_compiled (tree type
)
1278 while (type
!= NULL_TREE
)
1280 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1282 type
= CLASSTYPE_SUPER (type
);
1288 make_class_data (tree type
)
1290 tree decl
, cons
, temp
;
1291 tree field
, fields_decl
;
1292 tree static_fields
= NULL_TREE
;
1293 tree instance_fields
= NULL_TREE
;
1294 HOST_WIDE_INT static_field_count
= 0;
1295 HOST_WIDE_INT instance_field_count
= 0;
1296 HOST_WIDE_INT field_count
;
1297 tree field_array_type
;
1299 tree methods
= NULL_TREE
;
1300 tree dtable_decl
= NULL_TREE
;
1301 HOST_WIDE_INT method_count
= 0;
1302 tree method_array_type
;
1305 tree this_class_addr
;
1306 tree constant_pool_constructor
;
1307 tree interfaces
= null_pointer_node
;
1308 int interface_len
= 0;
1309 tree type_decl
= TYPE_NAME (type
);
1310 /** Offset from start of virtual function table declaration
1311 to where objects actually point at, following new g++ ABI. */
1312 tree dtable_start_offset
= build_int_2 (2 * POINTER_SIZE
/ BITS_PER_UNIT
, 0);
1314 this_class_addr
= build_class_ref (type
);
1315 decl
= TREE_OPERAND (this_class_addr
, 0);
1317 /* Build Field array. */
1318 field
= TYPE_FIELDS (type
);
1319 if (DECL_NAME (field
) == NULL_TREE
)
1320 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1321 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1323 if (! DECL_ARTIFICIAL (field
))
1325 tree init
= make_field_value (field
);
1326 if (FIELD_STATIC (field
))
1328 tree initial
= DECL_INITIAL (field
);
1329 static_field_count
++;
1330 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1331 /* If the initial value is a string constant,
1332 prevent output_constant from trying to assemble the value. */
1333 if (initial
!= NULL_TREE
1334 && TREE_TYPE (initial
) == string_ptr_type_node
)
1335 DECL_INITIAL (field
) = NULL_TREE
;
1336 rest_of_decl_compilation (field
, (char*) 0, 1, 1);
1337 DECL_INITIAL (field
) = initial
;
1341 instance_field_count
++;
1342 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1346 field_count
= static_field_count
+ instance_field_count
;
1347 if (field_count
> 0)
1349 static_fields
= nreverse (static_fields
);
1350 instance_fields
= nreverse (instance_fields
);
1351 static_fields
= chainon (static_fields
, instance_fields
);
1352 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1353 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1355 DECL_INITIAL (fields_decl
) = build (CONSTRUCTOR
, field_array_type
,
1356 NULL_TREE
, static_fields
);
1357 TREE_STATIC (fields_decl
) = 1;
1358 DECL_ARTIFICIAL (fields_decl
) = 1;
1359 DECL_IGNORED_P (fields_decl
) = 1;
1360 rest_of_decl_compilation (fields_decl
, (char*) 0, 1, 0);
1363 fields_decl
= NULL_TREE
;
1365 /* Build Method array. */
1366 for (method
= TYPE_METHODS (type
);
1367 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1370 if (METHOD_PRIVATE (method
)
1371 && ! flag_keep_inline_functions
1372 && (flag_inline_functions
|| optimize
))
1374 init
= make_method_value (method
);
1376 methods
= tree_cons (NULL_TREE
, init
, methods
);
1378 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1379 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1381 DECL_INITIAL (methods_decl
) = build (CONSTRUCTOR
, method_array_type
,
1382 NULL_TREE
, nreverse (methods
));
1383 TREE_STATIC (methods_decl
) = 1;
1384 DECL_ARTIFICIAL (methods_decl
) = 1;
1385 DECL_IGNORED_P (methods_decl
) = 1;
1386 rest_of_decl_compilation (methods_decl
, (char*) 0, 1, 0);
1388 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1389 && !flag_indirect_dispatch
)
1391 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1392 dtable_decl
= build_dtable_decl (type
);
1393 DECL_INITIAL (dtable_decl
) = dtable
;
1394 TREE_STATIC (dtable_decl
) = 1;
1395 DECL_ARTIFICIAL (dtable_decl
) = 1;
1396 DECL_IGNORED_P (dtable_decl
) = 1;
1397 TREE_PUBLIC (dtable_decl
) = 1;
1398 rest_of_decl_compilation (dtable_decl
, (char*) 0, 1, 0);
1399 if (type
== class_type_node
)
1400 class_dtable_decl
= dtable_decl
;
1403 if (class_dtable_decl
== NULL_TREE
)
1405 class_dtable_decl
= build_dtable_decl (class_type_node
);
1406 TREE_STATIC (class_dtable_decl
) = 1;
1407 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1408 DECL_IGNORED_P (class_dtable_decl
) = 1;
1409 if (is_compiled_class (class_type_node
) != 2)
1410 DECL_EXTERNAL (class_dtable_decl
) = 1;
1411 rest_of_decl_compilation (class_dtable_decl
, (char*) 0, 1, 0);
1414 super
= CLASSTYPE_SUPER (type
);
1415 if (super
== NULL_TREE
)
1416 super
= null_pointer_node
;
1417 else if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1418 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1419 super
= build_class_ref (super
);
1422 int super_index
= alloc_class_constant (super
);
1423 super
= build_int_2 (super_index
, 0);
1424 TREE_TYPE (super
) = ptr_type_node
;
1427 /* Build and emit the array of implemented interfaces. */
1428 if (type
!= object_type_node
)
1429 interface_len
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
)) - 1;
1430 if (interface_len
> 0)
1432 tree init
= NULL_TREE
;
1434 tree interface_array_type
, idecl
;
1435 interface_array_type
1436 = build_prim_array_type (class_ptr_type
, interface_len
);
1437 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1438 interface_array_type
);
1439 for (i
= interface_len
; i
> 0; i
--)
1441 tree child
= TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type
), i
);
1442 tree iclass
= BINFO_TYPE (child
);
1444 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
)))))
1445 index
= build_class_ref (iclass
);
1448 int int_index
= alloc_class_constant (iclass
);
1449 index
= build_int_2 (int_index
, 0);
1450 TREE_TYPE (index
) = ptr_type_node
;
1452 init
= tree_cons (NULL_TREE
, index
, init
);
1454 DECL_INITIAL (idecl
) = build (CONSTRUCTOR
, interface_array_type
,
1456 TREE_STATIC (idecl
) = 1;
1457 DECL_ARTIFICIAL (idecl
) = 1;
1458 DECL_IGNORED_P (idecl
) = 1;
1459 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1460 rest_of_decl_compilation (idecl
, (char*) 0, 1, 0);
1463 constant_pool_constructor
= build_constants_constructor ();
1465 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
1466 PUSH_FIELD_VALUE (temp
, "vtable",
1467 build (PLUS_EXPR
, dtable_ptr_type
,
1468 build1 (ADDR_EXPR
, dtable_ptr_type
, class_dtable_decl
),
1469 dtable_start_offset
));
1470 if (! flag_hash_synchronization
)
1471 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
1472 FINISH_RECORD_CONSTRUCTOR (temp
);
1473 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
1474 PUSH_SUPER_VALUE (cons
, temp
);
1475 PUSH_FIELD_VALUE (cons
, "next", null_pointer_node
);
1476 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
1477 PUSH_FIELD_VALUE (cons
, "accflags",
1478 build_int_2 (get_access_flags_from_decl (type_decl
), 0));
1480 PUSH_FIELD_VALUE (cons
, "superclass",
1481 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
1482 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
1483 PUSH_FIELD_VALUE (cons
, "methods",
1484 build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
1485 PUSH_FIELD_VALUE (cons
, "method_count", build_int_2 (method_count
, 0));
1487 if (flag_indirect_dispatch
)
1488 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
)
1490 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
1492 PUSH_FIELD_VALUE (cons
, "fields",
1493 fields_decl
== NULL_TREE
? null_pointer_node
1494 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
1495 PUSH_FIELD_VALUE (cons
, "size_in_bytes", size_in_bytes (type
));
1496 PUSH_FIELD_VALUE (cons
, "field_count", build_int_2 (field_count
, 0));
1497 PUSH_FIELD_VALUE (cons
, "static_field_count",
1498 build_int_2 (static_field_count
, 0));
1500 if (flag_indirect_dispatch
)
1501 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
)
1503 PUSH_FIELD_VALUE (cons
, "vtable",
1504 dtable_decl
== NULL_TREE
? null_pointer_node
1505 : build (PLUS_EXPR
, dtable_ptr_type
,
1506 build1 (ADDR_EXPR
, dtable_ptr_type
, dtable_decl
),
1507 dtable_start_offset
));
1509 if (otable_methods
== NULL_TREE
)
1511 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
1512 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
1516 PUSH_FIELD_VALUE (cons
, "otable",
1517 build1 (ADDR_EXPR
, otable_ptr_type
, otable_decl
));
1518 PUSH_FIELD_VALUE (cons
, "otable_syms",
1519 build1 (ADDR_EXPR
, method_symbols_array_ptr_type
,
1522 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
1523 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
1524 PUSH_FIELD_VALUE (cons
, "interface_count", build_int_2 (interface_len
, 0));
1525 PUSH_FIELD_VALUE (cons
, "state", integer_zero_node
);
1527 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
1528 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
1529 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
1530 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
1531 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
1532 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
1533 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
1535 FINISH_RECORD_CONSTRUCTOR (cons
);
1537 DECL_INITIAL (decl
) = cons
;
1539 /* Hash synchronization requires at least 64-bit alignment. */
1540 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
1541 DECL_ALIGN (decl
) = 64;
1543 rest_of_decl_compilation (decl
, (char*) 0, 1, 0);
1550 tree type_methods
= TYPE_METHODS (current_class
);
1551 int saw_native_method
= 0;
1553 /* Find out if we have any native methods. We use this information
1555 for (method
= type_methods
;
1556 method
!= NULL_TREE
;
1557 method
= TREE_CHAIN (method
))
1559 if (METHOD_NATIVE (method
))
1561 saw_native_method
= 1;
1566 /* Emit deferred inline methods. */
1567 for (method
= type_methods
; method
!= NULL_TREE
; )
1569 if (! TREE_ASM_WRITTEN (method
) && DECL_SAVED_INSNS (method
) != 0)
1571 output_inline_function (method
);
1572 /* Scan the list again to see if there are any earlier
1574 method
= type_methods
;
1577 method
= TREE_CHAIN (method
);
1580 current_function_decl
= NULL_TREE
;
1581 make_class_data (current_class
);
1583 rest_of_decl_compilation (TYPE_NAME (current_class
), (char*) 0, 1, 0);
1586 /* Return 2 if CLASS is compiled by this compilation job;
1587 return 1 if CLASS can otherwise be assumed to be compiled;
1588 return 0 if we cannot assume that CLASS is compiled.
1589 Returns 1 for primitive and 0 for array types. */
1591 is_compiled_class (tree
class)
1594 if (TREE_CODE (class) == POINTER_TYPE
)
1595 class = TREE_TYPE (class);
1596 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
1598 if (TYPE_ARRAY_P (class))
1600 if (class == current_class
)
1603 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1604 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip
)
1606 /* The class was seen in the current ZIP file and will be
1607 available as a compiled class in the future but may not have
1608 been loaded already. Load it if necessary. This prevent
1609 build_class_ref () from crashing. */
1611 if (seen_in_zip
&& !CLASS_LOADED_P (class))
1612 load_class (class, 1);
1614 /* We return 2 for class seen in ZIP and class from files
1615 belonging to the same compilation unit */
1619 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1621 if (!CLASS_LOADED_P (class))
1623 if (CLASS_FROM_SOURCE_P (class))
1624 safe_layout_class (class);
1626 load_class (class, 1);
1634 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1637 build_dtable_decl (tree type
)
1641 /* We need to build a new dtable type so that its size is uniquely
1642 computed when we're dealing with the class for real and not just
1643 faking it (like java.lang.Class during the initialization of the
1644 compiler.) We know we're not faking a class when CURRENT_CLASS is
1646 if (current_class
== type
)
1648 tree dummy
= NULL_TREE
;
1651 dtype
= make_node (RECORD_TYPE
);
1653 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
1654 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
1656 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
1657 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
1659 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
1660 TREE_CHAIN (dummy
) = tmp_field
;
1661 DECL_CONTEXT (tmp_field
) = dtype
;
1662 DECL_ARTIFICIAL (tmp_field
) = 1;
1666 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
1667 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
1669 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
1670 TREE_CHAIN (dummy
) = tmp_field
;
1671 DECL_CONTEXT (tmp_field
) = dtype
;
1672 DECL_ARTIFICIAL (tmp_field
) = 1;
1676 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
1677 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1678 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1680 PUSH_FIELD (dtype
, dummy
, "methods",
1681 build_prim_array_type (nativecode_ptr_type_node
, n
));
1682 layout_type (dtype
);
1685 dtype
= dtable_type
;
1687 return build_decl (VAR_DECL
,
1688 java_mangle_vtable (&temporary_obstack
, type
), dtype
);
1691 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
1692 fields inherited from SUPER_CLASS. */
1695 push_super_field (tree this_class
, tree super_class
)
1698 /* Don't insert the field if we're just re-laying the class out. */
1699 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
1701 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
1702 DECL_IGNORED_P (base_decl
) = 1;
1703 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
1704 TYPE_FIELDS (this_class
) = base_decl
;
1705 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
1706 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
1709 /* Handle the different manners we may have to lay out a super class. */
1712 maybe_layout_super_class (tree super_class
, tree this_class
)
1714 if (TREE_CODE (super_class
) == RECORD_TYPE
)
1716 if (!CLASS_LOADED_P (super_class
) && CLASS_FROM_SOURCE_P (super_class
))
1717 safe_layout_class (super_class
);
1718 if (!CLASS_LOADED_P (super_class
))
1719 load_class (super_class
, 1);
1721 /* We might have to layout the class before its dependency on
1722 the super class gets resolved by java_complete_class */
1723 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
1725 if (TREE_TYPE (super_class
) != NULL_TREE
)
1726 super_class
= TREE_TYPE (super_class
);
1729 /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
1731 tree this_wrap
= NULL_TREE
;
1735 tree this_decl
= TYPE_NAME (this_class
);
1736 this_wrap
= build_expr_wfl (this_class
,
1737 DECL_SOURCE_FILE (this_decl
),
1738 DECL_SOURCE_LINE (this_decl
), 0);
1740 super_class
= do_resolve_class (NULL_TREE
, /* FIXME? */
1741 super_class
, NULL_TREE
, this_wrap
);
1743 return NULL_TREE
; /* FIXME, NULL_TREE not checked by caller. */
1744 super_class
= TREE_TYPE (super_class
);
1747 if (!TYPE_SIZE (super_class
))
1748 safe_layout_class (super_class
);
1754 layout_class (tree this_class
)
1756 tree super_class
= CLASSTYPE_SUPER (this_class
);
1759 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
1760 if (CLASS_BEING_LAIDOUT (this_class
))
1766 sprintf (buffer
, " with `%s'",
1767 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
1768 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
1770 for (current
= TREE_CHAIN (class_list
); current
;
1771 current
= TREE_CHAIN (current
))
1773 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
1774 sprintf (buffer
, "\n which inherits from `%s' (%s:%d)",
1775 IDENTIFIER_POINTER (DECL_NAME (decl
)),
1776 DECL_SOURCE_FILE (decl
),
1777 DECL_SOURCE_LINE (decl
));
1778 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
1780 obstack_1grow (&temporary_obstack
, '\0');
1781 report
= obstack_finish (&temporary_obstack
);
1782 cyclic_inheritance_report
= ggc_strdup (report
);
1783 obstack_free (&temporary_obstack
, report
);
1784 TYPE_SIZE (this_class
) = error_mark_node
;
1787 CLASS_BEING_LAIDOUT (this_class
) = 1;
1789 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
1791 tree maybe_super_class
1792 = maybe_layout_super_class (super_class
, this_class
);
1793 if (maybe_super_class
== NULL
1794 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
1796 TYPE_SIZE (this_class
) = error_mark_node
;
1797 CLASS_BEING_LAIDOUT (this_class
) = 0;
1798 class_list
= TREE_CHAIN (class_list
);
1801 if (TYPE_SIZE (this_class
) == NULL_TREE
)
1802 push_super_field (this_class
, maybe_super_class
);
1805 for (field
= TYPE_FIELDS (this_class
);
1806 field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1808 if (FIELD_STATIC (field
))
1810 /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
1811 SET_DECL_ASSEMBLER_NAME (field
,
1813 (&temporary_obstack
, field
));
1817 layout_type (this_class
);
1819 /* Also recursively load/layout any superinterfaces, but only if class was
1820 loaded from bytecode. The source parser will take care of this itself. */
1821 if (!CLASS_FROM_SOURCE_P (this_class
))
1823 tree basetype_vec
= TYPE_BINFO_BASETYPES (this_class
);
1827 int n
= TREE_VEC_LENGTH (basetype_vec
) - 1;
1829 for (i
= n
; i
> 0; i
--)
1831 tree vec_elt
= TREE_VEC_ELT (basetype_vec
, i
);
1832 tree super_interface
= BINFO_TYPE (vec_elt
);
1834 tree maybe_super_interface
1835 = maybe_layout_super_class (super_interface
, NULL_TREE
);
1836 if (maybe_super_interface
== NULL
1837 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
1839 TYPE_SIZE (this_class
) = error_mark_node
;
1840 CLASS_BEING_LAIDOUT (this_class
) = 0;
1841 class_list
= TREE_CHAIN (class_list
);
1848 /* Convert the size back to an SI integer value */
1849 TYPE_SIZE_UNIT (this_class
) =
1850 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
1852 CLASS_BEING_LAIDOUT (this_class
) = 0;
1853 class_list
= TREE_CHAIN (class_list
);
1857 layout_class_methods (tree this_class
)
1859 tree method_decl
, dtable_count
;
1862 if (TYPE_NVIRTUALS (this_class
))
1865 super_class
= CLASSTYPE_SUPER (this_class
);
1869 super_class
= maybe_layout_super_class (super_class
, this_class
);
1870 if (!TYPE_NVIRTUALS (super_class
))
1871 layout_class_methods (super_class
);
1872 dtable_count
= TYPE_NVIRTUALS (super_class
);
1875 dtable_count
= integer_zero_node
;
1877 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
1879 for (method_decl
= TYPE_METHODS (this_class
);
1880 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
1881 dtable_count
= layout_class_method (this_class
, super_class
,
1882 method_decl
, dtable_count
);
1884 TYPE_NVIRTUALS (this_class
) = dtable_count
;
1887 /* Lay METHOD_DECL out, returning a possibly new value of
1888 DTABLE_COUNT. Also mangle the method's name. */
1891 layout_class_method (tree this_class
, tree super_class
,
1892 tree method_decl
, tree dtable_count
)
1894 tree method_name
= DECL_NAME (method_decl
);
1896 TREE_PUBLIC (method_decl
) = 1;
1898 /* This is a good occasion to mangle the method's name */
1899 SET_DECL_ASSEMBLER_NAME (method_decl
,
1900 java_mangle_decl (&temporary_obstack
,
1902 /* We don't generate a RTL for the method if it's abstract, or if
1903 it's an interface method that isn't clinit. */
1904 if (! METHOD_ABSTRACT (method_decl
)
1905 || (CLASS_INTERFACE (TYPE_NAME (this_class
))
1906 && (DECL_CLINIT_P (method_decl
))))
1907 make_decl_rtl (method_decl
, NULL
);
1909 if (ID_INIT_P (method_name
))
1911 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
1913 for (ptr
= p
; *ptr
; )
1918 DECL_CONSTRUCTOR_P (method_decl
) = 1;
1919 build_java_argument_signature (TREE_TYPE (method_decl
));
1921 else if (! METHOD_STATIC (method_decl
) && !DECL_ARTIFICIAL (method_decl
))
1924 build_java_argument_signature (TREE_TYPE (method_decl
));
1925 tree super_method
= lookup_argument_method (super_class
, method_name
,
1927 if (super_method
!= NULL_TREE
&& ! METHOD_PRIVATE (super_method
))
1929 DECL_VINDEX (method_decl
) = DECL_VINDEX (super_method
);
1930 if (DECL_VINDEX (method_decl
) == NULL_TREE
1931 && !CLASS_FROM_SOURCE_P (this_class
))
1932 error_with_decl (method_decl
,
1933 "non-static method '%s' overrides static method");
1935 else if (! METHOD_FINAL (method_decl
)
1936 && ! METHOD_PRIVATE (method_decl
)
1937 && ! CLASS_FINAL (TYPE_NAME (this_class
))
1940 DECL_VINDEX (method_decl
) = dtable_count
;
1941 dtable_count
= fold (build (PLUS_EXPR
, integer_type_node
,
1942 dtable_count
, integer_one_node
));
1946 return dtable_count
;
1950 register_class (void)
1952 /* END does not need to be registered with the garbage collector
1953 because it always points into the list given by REGISTERED_CLASS,
1954 and that variable is registered with the collector. */
1956 tree node
= TREE_OPERAND (build_class_ref (current_class
), 0);
1957 tree current
= copy_node (node
);
1959 XEXP (DECL_RTL (current
), 0) = copy_rtx (XEXP (DECL_RTL(node
), 0));
1960 if (!registered_class
)
1961 registered_class
= current
;
1963 TREE_CHAIN (end
) = current
;
1968 /* Emit something to register classes at start-up time.
1970 The preferred mechanism is through the .jcr section, which contain
1971 a list of pointers to classes which get registered during
1972 constructor invocation time. The fallback mechanism is to generate
1973 a `constructor' function which calls _Jv_RegisterClass for each
1974 class in this file. */
1977 emit_register_classes (void)
1979 /* ??? This isn't quite the correct test. We also have to know
1980 that the target is using gcc's crtbegin/crtend objects rather
1981 than the ones that come with the operating system. */
1982 if (SUPPORTS_WEAK
&& targetm
.have_named_sections
)
1984 #ifdef JCR_SECTION_NAME
1986 named_section_flags (JCR_SECTION_NAME
, SECTION_WRITE
);
1987 assemble_align (POINTER_SIZE
);
1988 for (t
= registered_class
; t
; t
= TREE_CHAIN (t
))
1989 assemble_integer (XEXP (DECL_RTL (t
), 0),
1990 POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1997 extern tree
get_file_function_name (int);
1998 tree init_name
= get_file_function_name ('I');
1999 tree init_type
= build_function_type (void_type_node
, end_params_node
);
2003 init_decl
= build_decl (FUNCTION_DECL
, init_name
, init_type
);
2004 SET_DECL_ASSEMBLER_NAME (init_decl
, init_name
);
2005 TREE_STATIC (init_decl
) = 1;
2006 current_function_decl
= init_decl
;
2007 DECL_RESULT (init_decl
) = build_decl (RESULT_DECL
, NULL_TREE
,
2010 /* It can be a static function as long as collect2 does not have
2011 to scan the object file to find its ctor/dtor routine. */
2012 TREE_PUBLIC (init_decl
) = ! targetm
.have_ctors_dtors
;
2014 /* Suppress spurious warnings. */
2015 TREE_USED (init_decl
) = 1;
2018 make_decl_rtl (init_decl
, NULL
);
2019 init_function_start (init_decl
, input_filename
, 0);
2020 expand_function_start (init_decl
, 0);
2022 /* Do not allow the function to be deferred. */
2023 current_function_cannot_inline
2024 = "static constructors and destructors cannot be inlined";
2026 for ( t
= registered_class
; t
; t
= TREE_CHAIN (t
))
2027 emit_library_call (registerClass_libfunc
, 0, VOIDmode
, 1,
2028 XEXP (DECL_RTL (t
), 0), Pmode
);
2030 expand_function_end (input_filename
, 0, 0);
2032 rest_of_compilation (init_decl
);
2033 current_function_decl
= NULL_TREE
;
2035 if (targetm
.have_ctors_dtors
)
2036 (* targetm
.asm_out
.constructor
) (XEXP (DECL_RTL (init_decl
), 0),
2037 DEFAULT_INIT_PRIORITY
);
2041 /* Make a method_symbol_type (_Jv_MethodSymbol) node for METHOD. */
2044 build_method_symbols_entry (tree method
)
2046 tree clname
, name
, signature
, method_symbol
;
2048 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (method
))));
2049 name
= build_utf8_ref (DECL_NAME (method
));
2050 signature
= build_java_signature (TREE_TYPE (method
));
2051 signature
= build_utf8_ref (unmangle_classname
2052 (IDENTIFIER_POINTER (signature
),
2053 IDENTIFIER_LENGTH (signature
)));
2055 START_RECORD_CONSTRUCTOR (method_symbol
, method_symbol_type
);
2056 PUSH_FIELD_VALUE (method_symbol
, "clname", clname
);
2057 PUSH_FIELD_VALUE (method_symbol
, "name", name
);
2058 PUSH_FIELD_VALUE (method_symbol
, "signature", signature
);
2059 FINISH_RECORD_CONSTRUCTOR (method_symbol
);
2060 TREE_CONSTANT (method_symbol
) = 1;
2062 return method_symbol
;
2065 /* Emit the offset symbols table for indirect virtual dispatch. */
2068 emit_offset_symbol_table (void)
2070 tree method_list
, method
, table
, list
, null_symbol
;
2071 tree otable_bound
, otable_array_type
;
2074 /* Only emit an offset table if this translation unit actually made virtual
2076 if (otable_methods
== NULL_TREE
)
2079 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2081 method_list
= otable_methods
;
2083 while (method_list
!= NULL_TREE
)
2085 method
= TREE_VALUE (method_list
);
2086 list
= tree_cons (NULL_TREE
, build_method_symbols_entry (method
), list
);
2087 method_list
= TREE_CHAIN (method_list
);
2091 /* Terminate the list with a "null" entry. */
2092 START_RECORD_CONSTRUCTOR (null_symbol
, method_symbol_type
);
2093 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2094 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2095 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2096 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2097 TREE_CONSTANT (null_symbol
) = 1;
2098 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2100 /* Put the list in the right order and make it a constructor. */
2101 list
= nreverse (list
);
2102 table
= build (CONSTRUCTOR
, method_symbols_array_type
, NULL_TREE
, list
);
2104 /* Make it the initial value for otable_syms and emit the decl. */
2105 DECL_INITIAL (otable_syms_decl
) = table
;
2106 DECL_ARTIFICIAL (otable_syms_decl
) = 1;
2107 DECL_IGNORED_P (otable_syms_decl
) = 1;
2108 rest_of_decl_compilation (otable_syms_decl
, NULL
, 1, 0);
2110 /* Now that its size is known, redefine otable as an uninitialized static
2111 array of INDEX + 1 integers. The extra entry is used by the runtime
2112 to track whether the otable has been initialized. */
2113 otable_bound
= build_index_type (build_int_2 (index
, 0));
2114 otable_array_type
= build_array_type (integer_type_node
, otable_bound
);
2115 otable_decl
= build_decl (VAR_DECL
, get_identifier ("otable"),
2117 TREE_STATIC (otable_decl
) = 1;
2118 TREE_READONLY (otable_decl
) = 1;
2119 rest_of_decl_compilation (otable_decl
, NULL
, 1, 0);
2123 init_class_processing (void)
2125 registerClass_libfunc
= gen_rtx_SYMBOL_REF (Pmode
, "_Jv_RegisterClass");
2126 fields_ident
= get_identifier ("fields");
2127 info_ident
= get_identifier ("info");
2128 gcc_obstack_init (&temporary_obstack
);
2131 static hashval_t
java_treetreehash_hash (const void *);
2132 static int java_treetreehash_compare (const void *, const void *);
2134 /* A hash table mapping trees to trees. Used generally. */
2136 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2139 java_treetreehash_hash (const void *k_p
)
2141 struct treetreehash_entry
*k
= (struct treetreehash_entry
*) k_p
;
2142 return JAVA_TREEHASHHASH_H (k
->key
);
2146 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
2148 struct treetreehash_entry
* k1
= (struct treetreehash_entry
*) k1_p
;
2149 tree k2
= (tree
) k2_p
;
2150 return (k1
->key
== k2
);
2154 java_treetreehash_find (htab_t ht
, tree t
)
2156 struct treetreehash_entry
*e
;
2157 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2158 e
= (struct treetreehash_entry
*) htab_find_with_hash (ht
, t
, hv
);
2166 java_treetreehash_new (htab_t ht
, tree t
)
2169 struct treetreehash_entry
*tthe
;
2170 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2172 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
2175 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
2180 tthe
= (struct treetreehash_entry
*) *e
;
2181 return &tthe
->value
;
2185 java_treetreehash_create (size_t size
, int gc
)
2188 return htab_create_ggc (size
, java_treetreehash_hash
,
2189 java_treetreehash_compare
, NULL
);
2191 return htab_create_alloc (size
, java_treetreehash_hash
,
2192 java_treetreehash_compare
, free
, xcalloc
, free
);
2195 #include "gt-java-class.h"