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 (6);
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 (6);
364 BINFO_TYPE (super_binfo
) = super_class
;
365 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
366 TREE_VIA_PUBLIC (super_binfo
) = 1;
367 TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (this_class
)), 0)
369 CLASS_HAS_SUPER (this_class
) = 1;
372 set_class_decl_access_flags (access_flags
, class_decl
);
376 set_class_decl_access_flags (int access_flags
, tree class_decl
)
378 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
379 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
380 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
381 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
382 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
383 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
384 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
385 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
386 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
389 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
390 direct sub-classes of Object are 1, and so on. */
393 class_depth (tree clas
)
396 if (! CLASS_LOADED_P (clas
))
397 load_class (clas
, 1);
398 if (TYPE_SIZE (clas
) == error_mark_node
)
400 while (clas
!= object_type_node
)
403 clas
= TYPE_BINFO_BASETYPE (clas
, 0);
408 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
411 interface_of_p (tree type1
, tree type2
)
416 if (!(basetype_vec
= TYPE_BINFO_BASETYPES (type2
)))
418 n
= TREE_VEC_LENGTH (basetype_vec
);
419 for (i
= 0; i
< n
; i
++)
421 tree vec_elt
= TREE_VEC_ELT (basetype_vec
, i
);
422 if (vec_elt
&& BINFO_TYPE (vec_elt
) == type1
)
425 for (i
= 0; i
< n
; i
++)
427 tree vec_elt
= TREE_VEC_ELT (basetype_vec
, i
);
428 if (vec_elt
&& BINFO_TYPE (vec_elt
)
429 && interface_of_p (type1
, BINFO_TYPE (vec_elt
)))
435 /* Return true iff TYPE1 inherits from TYPE2. */
438 inherits_from_p (tree type1
, tree type2
)
440 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
444 type1
= CLASSTYPE_SUPER (type1
);
449 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
452 enclosing_context_p (tree type1
, tree type2
)
454 if (!INNER_CLASS_TYPE_P (type2
))
457 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
459 type2
= (INNER_CLASS_TYPE_P (type2
) ?
460 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
469 /* Return 1 iff there exists a common enclosing context between TYPE1
472 int common_enclosing_context_p (tree type1
, tree type2
)
474 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
477 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
478 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
479 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
482 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
483 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
484 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
486 if (type1
== current
)
493 add_interface_do (tree basetype_vec
, tree interface_class
, int i
)
495 tree interface_binfo
= make_tree_vec (6);
496 BINFO_TYPE (interface_binfo
) = interface_class
;
497 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
498 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
499 TREE_VIA_VIRTUAL (interface_binfo
) = 1;
500 TREE_VIA_PUBLIC (interface_binfo
) = 1;
501 TREE_VEC_ELT (basetype_vec
, i
) = interface_binfo
;
504 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
505 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
506 if attempt is made to add it twice. */
509 maybe_add_interface (tree this_class
, tree interface_class
)
511 tree basetype_vec
= TYPE_BINFO_BASETYPES (this_class
);
513 int n
= TREE_VEC_LENGTH (basetype_vec
);
518 error ("internal error - too many interface type");
521 else if (TREE_VEC_ELT (basetype_vec
, i
) == NULL_TREE
)
523 else if (BINFO_TYPE (TREE_VEC_ELT (basetype_vec
, i
)) == interface_class
)
524 return interface_class
;
526 add_interface_do (basetype_vec
, interface_class
, i
);
530 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
533 add_interface (tree this_class
, tree interface_class
)
535 tree basetype_vec
= TYPE_BINFO_BASETYPES (this_class
);
537 int n
= TREE_VEC_LENGTH (basetype_vec
);
542 error ("internal error - too many interface type");
545 else if (TREE_VEC_ELT (basetype_vec
, i
) == NULL_TREE
)
548 add_interface_do (basetype_vec
, interface_class
, i
);
552 /* Return the address of a pointer to the first FUNCTION_DECL
553 in the list (*LIST) whose DECL_NAME is NAME. */
556 find_named_method (tree
*list
, tree name
)
558 while (*list
&& DECL_NAME (*list
) != name
)
559 list
= &TREE_CHAIN (*list
);
565 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
567 if (access_flags
& ACC_STATIC
)
569 return build_method_type (this_class
, fntype
);
573 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
575 tree method_type
, fndecl
;
577 method_type
= build_java_method_type (function_type
,
578 this_class
, access_flags
);
580 fndecl
= build_decl (FUNCTION_DECL
, name
, method_type
);
581 DECL_CONTEXT (fndecl
) = this_class
;
583 DECL_LANG_SPECIFIC (fndecl
)
584 = ggc_alloc_cleared (sizeof (struct lang_decl
));
585 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
587 /* Initialize the static initializer test table. */
589 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
590 java_treetreehash_create (10, 1);
592 /* Initialize the initialized (static) class table. */
593 if (access_flags
& ACC_STATIC
)
594 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
595 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
597 /* Initialize the static method invocation compound list */
598 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl
) = NULL_TREE
;
600 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
601 TYPE_METHODS (this_class
) = fndecl
;
603 /* Notice that this is a finalizer and update the class type
604 accordingly. This is used to optimize instance allocation. */
605 if (name
== finalize_identifier_node
606 && TREE_TYPE (function_type
) == void_type_node
607 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
608 HAS_FINALIZER_P (this_class
) = 1;
610 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
611 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
612 if (access_flags
& ACC_PRIVATE
)
613 METHOD_PRIVATE (fndecl
) = DECL_INLINE (fndecl
) = 1;
614 if (access_flags
& ACC_NATIVE
)
616 METHOD_NATIVE (fndecl
) = 1;
617 DECL_EXTERNAL (fndecl
) = 1;
619 if (access_flags
& ACC_STATIC
)
620 METHOD_STATIC (fndecl
) = DECL_INLINE (fndecl
) = 1;
621 if (access_flags
& ACC_FINAL
)
622 METHOD_FINAL (fndecl
) = DECL_INLINE (fndecl
) = 1;
623 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
624 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
625 if (access_flags
& ACC_TRANSIENT
) METHOD_TRANSIENT (fndecl
) = 1;
626 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
630 /* Add a method to THIS_CLASS.
631 The method's name is NAME.
632 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
635 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
637 tree function_type
, fndecl
;
638 const unsigned char *sig
639 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
642 fatal_error ("bad method signature");
644 function_type
= get_type_from_signature (method_sig
);
645 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
646 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
651 add_field (tree
class, tree name
, tree field_type
, int flags
)
653 int is_static
= (flags
& ACC_STATIC
) != 0;
655 field
= build_decl (is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
656 TREE_CHAIN (field
) = TYPE_FIELDS (class);
657 TYPE_FIELDS (class) = field
;
658 DECL_CONTEXT (field
) = class;
660 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
661 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
662 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
663 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
664 if (flags
& ACC_VOLATILE
) FIELD_VOLATILE (field
) = 1;
665 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
668 FIELD_STATIC (field
) = 1;
669 /* Always make field externally visible. This is required so
670 that native methods can always access the field. */
671 TREE_PUBLIC (field
) = 1;
672 /* Considered external until we know what classes are being
673 compiled into this object file. */
674 DECL_EXTERNAL (field
) = 1;
680 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
683 set_constant_value (tree field
, tree constant
)
685 if (field
== NULL_TREE
)
686 warning ("misplaced ConstantValue attribute (not in any field)");
687 else if (DECL_INITIAL (field
) != NULL_TREE
)
688 warning ("duplicate ConstantValue attribute for field '%s'",
689 IDENTIFIER_POINTER (DECL_NAME (field
)));
692 DECL_INITIAL (field
) = constant
;
693 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
694 && ! (TREE_TYPE (constant
) == int_type_node
695 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
696 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
697 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
698 && TREE_TYPE (field
) == string_ptr_type_node
))
699 error ("ConstantValue attribute of field '%s' has wrong type",
700 IDENTIFIER_POINTER (DECL_NAME (field
)));
701 if (FIELD_FINAL (field
))
702 DECL_FIELD_FINAL_IUD (field
) = 1;
706 /* Count the number of Unicode chars encoded in a given Ut8 string. */
710 strLengthUtf8 (char *str
, int len
)
712 register unsigned char* ptr
= (unsigned char*) str
;
713 register unsigned char *limit
= ptr
+ len
;
715 for (; ptr
< limit
; str_length
++) {
716 if (UTF8_GET (ptr
, limit
) < 0)
724 /* Calculate a hash value for a string encoded in Utf8 format.
725 * This returns the same hash value as specified for java.lang.String.hashCode.
729 hashUtf8String (const char *str
, int len
)
731 register const unsigned char* ptr
= (const unsigned char*) str
;
732 register const unsigned char *limit
= ptr
+ len
;
736 int ch
= UTF8_GET (ptr
, limit
);
737 /* Updated specification from
738 http://www.javasoft.com/docs/books/jls/clarify.html. */
739 hash
= (31 * hash
) + ch
;
744 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
747 build_utf8_ref (tree name
)
749 const char * name_ptr
= IDENTIFIER_POINTER(name
);
750 int name_len
= IDENTIFIER_LENGTH(name
);
752 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
753 static int utf8_count
= 0;
755 tree ref
= IDENTIFIER_UTF8_REF (name
);
757 if (ref
!= NULL_TREE
)
760 ctype
= make_node (RECORD_TYPE
);
761 str_type
= build_prim_array_type (unsigned_byte_type_node
,
762 name_len
+ 1); /* Allow for final '\0'. */
763 PUSH_FIELD (ctype
, field
, "hash", unsigned_short_type_node
);
764 PUSH_FIELD (ctype
, field
, "length", unsigned_short_type_node
);
765 PUSH_FIELD (ctype
, field
, "data", str_type
);
766 FINISH_RECORD (ctype
);
767 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
768 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
769 PUSH_FIELD_VALUE (cinit
, "hash", build_int_2 (name_hash
, 0));
770 PUSH_FIELD_VALUE (cinit
, "length", build_int_2 (name_len
, 0));
771 string
= build_string (name_len
, name_ptr
);
772 TREE_TYPE (string
) = str_type
;
773 PUSH_FIELD_VALUE (cinit
, "data", string
);
774 FINISH_RECORD_CONSTRUCTOR (cinit
);
775 TREE_CONSTANT (cinit
) = 1;
777 /* Generate a unique-enough identifier. */
778 sprintf(buf
, "_Utf%d", ++utf8_count
);
780 decl
= build_decl (VAR_DECL
, get_identifier (buf
), utf8const_type
);
781 TREE_STATIC (decl
) = 1;
782 DECL_ARTIFICIAL (decl
) = 1;
783 DECL_IGNORED_P (decl
) = 1;
784 TREE_READONLY (decl
) = 1;
785 TREE_THIS_VOLATILE (decl
) = 0;
786 DECL_INITIAL (decl
) = cinit
;
787 #ifdef HAVE_GAS_SHF_MERGE
790 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
791 decl_size
= (name_len
+ 5 + TYPE_ALIGN_UNIT (utf8const_type
) - 1)
792 & ~(TYPE_ALIGN_UNIT (utf8const_type
) - 1);
793 if (flag_merge_constants
&& decl_size
< 256)
796 int flags
= (SECTION_OVERRIDE
797 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
798 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
799 named_section_flags (buf
, flags
);
800 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
804 TREE_CHAIN (decl
) = utf8_decl_list
;
805 layout_decl (decl
, 0);
807 rest_of_decl_compilation (decl
, (char*) 0, global_bindings_p (), 0);
808 utf8_decl_list
= decl
;
809 make_decl_rtl (decl
, (char*) 0);
810 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
811 IDENTIFIER_UTF8_REF (name
) = ref
;
815 /* Build a reference to the class TYPE.
816 Also handles primitive types and array types. */
819 build_class_ref (tree type
)
821 int is_compiled
= is_compiled_class (type
);
824 tree ref
, decl_name
, decl
;
825 if (TREE_CODE (type
) == POINTER_TYPE
)
826 type
= TREE_TYPE (type
);
827 if (TREE_CODE (type
) == RECORD_TYPE
)
829 if (TYPE_SIZE (type
) == error_mark_node
)
830 return null_pointer_node
;
831 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
832 "", '/', '/', ".class");
833 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
834 if (decl
== NULL_TREE
)
836 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
837 DECL_SIZE (decl
) = TYPE_SIZE (class_type_node
);
838 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (class_type_node
);
839 TREE_STATIC (decl
) = 1;
840 TREE_PUBLIC (decl
) = 1;
841 DECL_IGNORED_P (decl
) = 1;
842 DECL_ARTIFICIAL (decl
) = 1;
843 if (is_compiled
== 1)
844 DECL_EXTERNAL (decl
) = 1;
845 SET_DECL_ASSEMBLER_NAME (decl
,
846 java_mangle_class_field
847 (&temporary_obstack
, type
));
848 make_decl_rtl (decl
, NULL
);
849 pushdecl_top_level (decl
);
856 if (flag_emit_class_files
)
858 const char *prim_class_name
;
860 if (type
== char_type_node
)
861 prim_class_name
= "java.lang.Character";
862 else if (type
== boolean_type_node
)
863 prim_class_name
= "java.lang.Boolean";
864 else if (type
== byte_type_node
)
865 prim_class_name
= "java.lang.Byte";
866 else if (type
== short_type_node
)
867 prim_class_name
= "java.lang.Short";
868 else if (type
== int_type_node
)
869 prim_class_name
= "java.lang.Integer";
870 else if (type
== long_type_node
)
871 prim_class_name
= "java.lang.Long";
872 else if (type
== float_type_node
)
873 prim_class_name
= "java.lang.Float";
874 else if (type
== double_type_node
)
875 prim_class_name
= "java.lang.Double";
876 else if (type
== void_type_node
)
877 prim_class_name
= "java.lang.Void";
881 prim_class
= lookup_class (get_identifier (prim_class_name
));
882 return build (COMPONENT_REF
, NULL_TREE
,
883 prim_class
, TYPE_identifier_node
);
885 decl_name
= TYPE_NAME (type
);
886 if (TREE_CODE (decl_name
) == TYPE_DECL
)
887 decl_name
= DECL_NAME (decl_name
);
888 name
= IDENTIFIER_POINTER (decl_name
);
889 if (strncmp (name
, "promoted_", 9) == 0)
891 sprintf (buffer
, "_Jv_%sClass", name
);
892 decl_name
= get_identifier (buffer
);
893 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
894 if (decl
== NULL_TREE
)
896 decl
= build_decl (VAR_DECL
, decl_name
, class_type_node
);
897 TREE_STATIC (decl
) = 1;
898 TREE_PUBLIC (decl
) = 1;
899 DECL_EXTERNAL (decl
) = 1;
900 make_decl_rtl (decl
, NULL
);
901 pushdecl_top_level (decl
);
905 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
912 index
= alloc_class_constant (type
);
913 cl
= build_ref_from_constant_pool (index
);
914 TREE_TYPE (cl
) = promote_type (class_ptr_type
);
920 build_static_field_ref (tree fdecl
)
922 tree fclass
= DECL_CONTEXT (fdecl
);
923 int is_compiled
= is_compiled_class (fclass
);
925 /* Allow static final fields to fold to a constant. */
926 if (is_compiled
|| FIELD_FINAL (fdecl
))
928 if (!DECL_RTL_SET_P (fdecl
))
930 if (is_compiled
== 1)
931 DECL_EXTERNAL (fdecl
) = 1;
932 make_decl_rtl (fdecl
, NULL
);
939 * *(FTYPE*)build_class_ref(FCLASS)->fields[INDEX].info.addr */
940 tree ref
= build_class_ref (fclass
);
943 ref
= build1 (INDIRECT_REF
, class_type_node
, ref
);
944 ref
= build (COMPONENT_REF
, field_ptr_type_node
, ref
,
945 lookup_field (&class_type_node
, fields_ident
));
947 for (fld
= TYPE_FIELDS (fclass
); ; fld
= TREE_CHAIN (fld
))
951 if (fld
== NULL_TREE
)
952 fatal_error ("field '%s' not found in class",
953 IDENTIFIER_POINTER (DECL_NAME (fdecl
)));
954 if (FIELD_STATIC (fld
))
957 field_index
*= int_size_in_bytes (field_type_node
);
958 ref
= fold (build (PLUS_EXPR
, field_ptr_type_node
,
959 ref
, build_int_2 (field_index
, 0)));
960 ref
= build1 (INDIRECT_REF
, field_type_node
, ref
);
961 ref
= build (COMPONENT_REF
, field_info_union_node
,
962 ref
, lookup_field (&field_type_node
, info_ident
));
963 ref
= build (COMPONENT_REF
, ptr_type_node
,
964 ref
, TREE_CHAIN (TYPE_FIELDS (field_info_union_node
)));
965 return fold (build1 (INDIRECT_REF
, TREE_TYPE(fdecl
), ref
));
970 get_access_flags_from_decl (tree decl
)
972 int access_flags
= 0;
973 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
975 if (FIELD_STATIC (decl
))
976 access_flags
|= ACC_STATIC
;
977 if (FIELD_PUBLIC (decl
))
978 access_flags
|= ACC_PUBLIC
;
979 if (FIELD_PROTECTED (decl
))
980 access_flags
|= ACC_PROTECTED
;
981 if (FIELD_PRIVATE (decl
))
982 access_flags
|= ACC_PRIVATE
;
983 if (FIELD_FINAL (decl
))
984 access_flags
|= ACC_FINAL
;
985 if (FIELD_VOLATILE (decl
))
986 access_flags
|= ACC_VOLATILE
;
987 if (FIELD_TRANSIENT (decl
))
988 access_flags
|= ACC_TRANSIENT
;
991 if (TREE_CODE (decl
) == TYPE_DECL
)
993 if (CLASS_PUBLIC (decl
))
994 access_flags
|= ACC_PUBLIC
;
995 if (CLASS_FINAL (decl
))
996 access_flags
|= ACC_FINAL
;
997 if (CLASS_SUPER (decl
))
998 access_flags
|= ACC_SUPER
;
999 if (CLASS_INTERFACE (decl
))
1000 access_flags
|= ACC_INTERFACE
;
1001 if (CLASS_ABSTRACT (decl
))
1002 access_flags
|= ACC_ABSTRACT
;
1003 if (CLASS_STATIC (decl
))
1004 access_flags
|= ACC_STATIC
;
1005 if (CLASS_PRIVATE (decl
))
1006 access_flags
|= ACC_PRIVATE
;
1007 if (CLASS_PROTECTED (decl
))
1008 access_flags
|= ACC_PROTECTED
;
1009 if (CLASS_STRICTFP (decl
))
1010 access_flags
|= ACC_STRICT
;
1011 return access_flags
;
1013 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1015 if (METHOD_PUBLIC (decl
))
1016 access_flags
|= ACC_PUBLIC
;
1017 if (METHOD_PRIVATE (decl
))
1018 access_flags
|= ACC_PRIVATE
;
1019 if (METHOD_PROTECTED (decl
))
1020 access_flags
|= ACC_PROTECTED
;
1021 if (METHOD_STATIC (decl
))
1022 access_flags
|= ACC_STATIC
;
1023 if (METHOD_FINAL (decl
))
1024 access_flags
|= ACC_FINAL
;
1025 if (METHOD_SYNCHRONIZED (decl
))
1026 access_flags
|= ACC_SYNCHRONIZED
;
1027 if (METHOD_NATIVE (decl
))
1028 access_flags
|= ACC_NATIVE
;
1029 if (METHOD_ABSTRACT (decl
))
1030 access_flags
|= ACC_ABSTRACT
;
1031 if (METHOD_TRANSIENT (decl
))
1032 access_flags
|= ACC_TRANSIENT
;
1033 if (METHOD_STRICTFP (decl
))
1034 access_flags
|= ACC_STRICT
;
1035 return access_flags
;
1041 make_field_value (tree fdecl
)
1045 tree type
= TREE_TYPE (fdecl
);
1046 int resolved
= is_compiled_class (type
);
1048 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1049 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1051 type
= build_class_ref (type
);
1054 tree signature
= build_java_signature (type
);
1056 type
= build_utf8_ref (unmangle_classname
1057 (IDENTIFIER_POINTER (signature
),
1058 IDENTIFIER_LENGTH (signature
)));
1060 PUSH_FIELD_VALUE (finit
, "type", type
);
1062 flags
= get_access_flags_from_decl (fdecl
);
1064 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1066 PUSH_FIELD_VALUE (finit
, "accflags", build_int_2 (flags
, 0));
1067 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1071 build (CONSTRUCTOR
, field_info_union_node
, NULL_TREE
,
1073 ((FIELD_STATIC (fdecl
)
1074 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1075 : TYPE_FIELDS (field_info_union_node
)),
1076 (FIELD_STATIC (fdecl
)
1077 ? build_address_of (build_static_field_ref (fdecl
))
1078 : byte_position (fdecl
)))));
1080 FINISH_RECORD_CONSTRUCTOR (finit
);
1085 make_method_value (tree mdecl
)
1087 static int method_name_count
= 0;
1091 #define ACC_TRANSLATED 0x4000
1092 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1094 if (!flag_indirect_dispatch
&& DECL_VINDEX (mdecl
) != NULL_TREE
)
1095 index
= DECL_VINDEX (mdecl
);
1097 index
= integer_minus_one_node
;
1099 code
= null_pointer_node
;
1100 if (DECL_RTL_SET_P (mdecl
))
1101 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
, mdecl
);
1102 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1103 PUSH_FIELD_VALUE (minit
, "name",
1104 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1105 init_identifier_node
1106 : DECL_NAME (mdecl
)));
1108 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1109 PUSH_FIELD_VALUE (minit
, "signature",
1112 (IDENTIFIER_POINTER(signature
),
1113 IDENTIFIER_LENGTH(signature
)))));
1115 PUSH_FIELD_VALUE (minit
, "accflags", build_int_2 (accflags
, 0));
1116 PUSH_FIELD_VALUE (minit
, "index", index
);
1117 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1120 /* Compute the `throws' information for the method. */
1121 tree table
= null_pointer_node
;
1122 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1124 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1125 tree iter
, type
, array
;
1128 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1129 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1131 iter
= TREE_CHAIN (iter
))
1133 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1135 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1136 IDENTIFIER_LENGTH (sig
)));
1137 table
= tree_cons (NULL_TREE
, utf8
, table
);
1139 type
= build_prim_array_type (ptr_type_node
, length
);
1140 table
= build (CONSTRUCTOR
, type
, NULL_TREE
, table
);
1141 /* Compute something unique enough. */
1142 sprintf (buf
, "_methods%d", method_name_count
++);
1143 array
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
1144 DECL_INITIAL (array
) = table
;
1145 TREE_STATIC (array
) = 1;
1146 DECL_ARTIFICIAL (array
) = 1;
1147 DECL_IGNORED_P (array
) = 1;
1148 rest_of_decl_compilation (array
, (char*) 0, 1, 0);
1150 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1153 PUSH_FIELD_VALUE (minit
, "throws", table
);
1156 FINISH_RECORD_CONSTRUCTOR (minit
);
1161 get_dispatch_vector (tree type
)
1163 tree vtable
= TYPE_VTABLE (type
);
1165 if (vtable
== NULL_TREE
)
1169 tree super
= CLASSTYPE_SUPER (type
);
1170 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1171 vtable
= make_tree_vec (nvirtuals
);
1172 TYPE_VTABLE (type
) = vtable
;
1173 if (super
!= NULL_TREE
)
1175 tree super_vtable
= get_dispatch_vector (super
);
1177 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1178 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1181 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1182 method
= TREE_CHAIN (method
))
1183 if (DECL_VINDEX (method
) != NULL_TREE
1184 && host_integerp (DECL_VINDEX (method
), 0))
1185 TREE_VEC_ELT (vtable
, tree_low_cst (DECL_VINDEX (method
), 0))
1193 get_dispatch_table (tree type
, tree this_class_addr
)
1195 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1196 tree vtable
= get_dispatch_vector (type
);
1198 tree list
= NULL_TREE
;
1199 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1203 for (i
= nvirtuals
; --i
>= 0; )
1205 tree method
= TREE_VEC_ELT (vtable
, i
);
1206 if (METHOD_ABSTRACT (method
))
1209 warning_with_decl (method
,
1210 "abstract method in non-abstract class");
1212 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1213 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1214 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1216 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1220 if (!DECL_RTL_SET_P (method
))
1221 make_decl_rtl (method
, NULL
);
1223 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1224 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1226 tree fdesc
= build (FDESC_EXPR
, nativecode_ptr_type_node
,
1227 method
, build_int_2 (j
, 0));
1228 TREE_CONSTANT (fdesc
) = 1;
1229 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1232 list
= tree_cons (NULL_TREE
,
1233 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1239 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1240 using the Boehm GC we sometimes stash a GC type descriptor
1241 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1242 the emitted byte count during the output to the assembly file. */
1243 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1244 fake "function descriptor". It's first word is the is the class
1245 pointer, and subsequent words (usually one) contain the GC descriptor.
1246 In all other cases, we reserve two extra vtable slots. */
1247 gc_descr
= get_boehm_type_descriptor (type
);
1248 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1249 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1250 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1251 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1253 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1254 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1255 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1256 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1258 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1259 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1260 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1262 return build (CONSTRUCTOR
,
1263 build_prim_array_type (nativecode_ptr_type_node
, arraysize
),
1268 supers_all_compiled (tree type
)
1270 while (type
!= NULL_TREE
)
1272 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1274 type
= CLASSTYPE_SUPER (type
);
1280 make_class_data (tree type
)
1282 tree decl
, cons
, temp
;
1283 tree field
, fields_decl
;
1284 tree static_fields
= NULL_TREE
;
1285 tree instance_fields
= NULL_TREE
;
1286 HOST_WIDE_INT static_field_count
= 0;
1287 HOST_WIDE_INT instance_field_count
= 0;
1288 HOST_WIDE_INT field_count
;
1289 tree field_array_type
;
1291 tree methods
= NULL_TREE
;
1292 tree dtable_decl
= NULL_TREE
;
1293 HOST_WIDE_INT method_count
= 0;
1294 tree method_array_type
;
1297 tree this_class_addr
;
1298 tree constant_pool_constructor
;
1299 tree interfaces
= null_pointer_node
;
1300 int interface_len
= 0;
1301 tree type_decl
= TYPE_NAME (type
);
1302 /** Offset from start of virtual function table declaration
1303 to where objects actually point at, following new g++ ABI. */
1304 tree dtable_start_offset
= build_int_2 (2 * POINTER_SIZE
/ BITS_PER_UNIT
, 0);
1306 this_class_addr
= build_class_ref (type
);
1307 decl
= TREE_OPERAND (this_class_addr
, 0);
1309 /* Build Field array. */
1310 field
= TYPE_FIELDS (type
);
1311 if (DECL_NAME (field
) == NULL_TREE
)
1312 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1313 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1315 if (! DECL_ARTIFICIAL (field
))
1317 tree init
= make_field_value (field
);
1318 if (FIELD_STATIC (field
))
1320 tree initial
= DECL_INITIAL (field
);
1321 static_field_count
++;
1322 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1323 /* If the initial value is a string constant,
1324 prevent output_constant from trying to assemble the value. */
1325 if (initial
!= NULL_TREE
1326 && TREE_TYPE (initial
) == string_ptr_type_node
)
1327 DECL_INITIAL (field
) = NULL_TREE
;
1328 rest_of_decl_compilation (field
, (char*) 0, 1, 1);
1329 DECL_INITIAL (field
) = initial
;
1333 instance_field_count
++;
1334 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1338 field_count
= static_field_count
+ instance_field_count
;
1339 if (field_count
> 0)
1341 static_fields
= nreverse (static_fields
);
1342 instance_fields
= nreverse (instance_fields
);
1343 static_fields
= chainon (static_fields
, instance_fields
);
1344 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1345 fields_decl
= build_decl (VAR_DECL
, mangled_classname ("_FL_", type
),
1347 DECL_INITIAL (fields_decl
) = build (CONSTRUCTOR
, field_array_type
,
1348 NULL_TREE
, static_fields
);
1349 TREE_STATIC (fields_decl
) = 1;
1350 DECL_ARTIFICIAL (fields_decl
) = 1;
1351 DECL_IGNORED_P (fields_decl
) = 1;
1352 rest_of_decl_compilation (fields_decl
, (char*) 0, 1, 0);
1355 fields_decl
= NULL_TREE
;
1357 /* Build Method array. */
1358 for (method
= TYPE_METHODS (type
);
1359 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1362 if (METHOD_PRIVATE (method
)
1363 && ! flag_keep_inline_functions
1364 && (flag_inline_functions
|| optimize
))
1366 init
= make_method_value (method
);
1368 methods
= tree_cons (NULL_TREE
, init
, methods
);
1370 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1371 methods_decl
= build_decl (VAR_DECL
, mangled_classname ("_MT_", type
),
1373 DECL_INITIAL (methods_decl
) = build (CONSTRUCTOR
, method_array_type
,
1374 NULL_TREE
, nreverse (methods
));
1375 TREE_STATIC (methods_decl
) = 1;
1376 DECL_ARTIFICIAL (methods_decl
) = 1;
1377 DECL_IGNORED_P (methods_decl
) = 1;
1378 rest_of_decl_compilation (methods_decl
, (char*) 0, 1, 0);
1380 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1381 && !flag_indirect_dispatch
)
1383 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1384 dtable_decl
= build_dtable_decl (type
);
1385 DECL_INITIAL (dtable_decl
) = dtable
;
1386 TREE_STATIC (dtable_decl
) = 1;
1387 DECL_ARTIFICIAL (dtable_decl
) = 1;
1388 DECL_IGNORED_P (dtable_decl
) = 1;
1389 TREE_PUBLIC (dtable_decl
) = 1;
1390 rest_of_decl_compilation (dtable_decl
, (char*) 0, 1, 0);
1391 if (type
== class_type_node
)
1392 class_dtable_decl
= dtable_decl
;
1395 if (class_dtable_decl
== NULL_TREE
)
1397 class_dtable_decl
= build_dtable_decl (class_type_node
);
1398 TREE_STATIC (class_dtable_decl
) = 1;
1399 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1400 DECL_IGNORED_P (class_dtable_decl
) = 1;
1401 if (is_compiled_class (class_type_node
) != 2)
1402 DECL_EXTERNAL (class_dtable_decl
) = 1;
1403 rest_of_decl_compilation (class_dtable_decl
, (char*) 0, 1, 0);
1406 super
= CLASSTYPE_SUPER (type
);
1407 if (super
== NULL_TREE
)
1408 super
= null_pointer_node
;
1409 else if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1410 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1411 super
= build_class_ref (super
);
1414 int super_index
= alloc_class_constant (super
);
1415 super
= build_int_2 (super_index
, 0);
1416 TREE_TYPE (super
) = ptr_type_node
;
1419 /* Build and emit the array of implemented interfaces. */
1420 if (type
!= object_type_node
)
1421 interface_len
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
)) - 1;
1422 if (interface_len
> 0)
1424 tree init
= NULL_TREE
;
1426 tree interface_array_type
, idecl
;
1427 interface_array_type
1428 = build_prim_array_type (class_ptr_type
, interface_len
);
1429 idecl
= build_decl (VAR_DECL
, mangled_classname ("_IF_", type
),
1430 interface_array_type
);
1431 for (i
= interface_len
; i
> 0; i
--)
1433 tree child
= TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type
), i
);
1434 tree iclass
= BINFO_TYPE (child
);
1436 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
)))))
1437 index
= build_class_ref (iclass
);
1440 int int_index
= alloc_class_constant (iclass
);
1441 index
= build_int_2 (int_index
, 0);
1442 TREE_TYPE (index
) = ptr_type_node
;
1444 init
= tree_cons (NULL_TREE
, index
, init
);
1446 DECL_INITIAL (idecl
) = build (CONSTRUCTOR
, interface_array_type
,
1448 TREE_STATIC (idecl
) = 1;
1449 DECL_ARTIFICIAL (idecl
) = 1;
1450 DECL_IGNORED_P (idecl
) = 1;
1451 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
1452 rest_of_decl_compilation (idecl
, (char*) 0, 1, 0);
1455 constant_pool_constructor
= build_constants_constructor ();
1457 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
1458 PUSH_FIELD_VALUE (temp
, "vtable",
1459 build (PLUS_EXPR
, dtable_ptr_type
,
1460 build1 (ADDR_EXPR
, dtable_ptr_type
, class_dtable_decl
),
1461 dtable_start_offset
));
1462 if (! flag_hash_synchronization
)
1463 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
1464 FINISH_RECORD_CONSTRUCTOR (temp
);
1465 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
1466 PUSH_SUPER_VALUE (cons
, temp
);
1467 PUSH_FIELD_VALUE (cons
, "next", null_pointer_node
);
1468 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
1469 PUSH_FIELD_VALUE (cons
, "accflags",
1470 build_int_2 (get_access_flags_from_decl (type_decl
), 0));
1472 PUSH_FIELD_VALUE (cons
, "superclass",
1473 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
1474 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
1475 PUSH_FIELD_VALUE (cons
, "methods",
1476 build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
1477 PUSH_FIELD_VALUE (cons
, "method_count", build_int_2 (method_count
, 0));
1479 if (flag_indirect_dispatch
)
1480 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
)
1482 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
1484 PUSH_FIELD_VALUE (cons
, "fields",
1485 fields_decl
== NULL_TREE
? null_pointer_node
1486 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
1487 PUSH_FIELD_VALUE (cons
, "size_in_bytes", size_in_bytes (type
));
1488 PUSH_FIELD_VALUE (cons
, "field_count", build_int_2 (field_count
, 0));
1489 PUSH_FIELD_VALUE (cons
, "static_field_count",
1490 build_int_2 (static_field_count
, 0));
1492 if (flag_indirect_dispatch
)
1493 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
)
1495 PUSH_FIELD_VALUE (cons
, "vtable",
1496 dtable_decl
== NULL_TREE
? null_pointer_node
1497 : build (PLUS_EXPR
, dtable_ptr_type
,
1498 build1 (ADDR_EXPR
, dtable_ptr_type
, dtable_decl
),
1499 dtable_start_offset
));
1501 if (otable_methods
== NULL_TREE
)
1503 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
1504 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
1508 PUSH_FIELD_VALUE (cons
, "otable",
1509 build1 (ADDR_EXPR
, otable_ptr_type
, otable_decl
));
1510 PUSH_FIELD_VALUE (cons
, "otable_syms",
1511 build1 (ADDR_EXPR
, method_symbols_array_ptr_type
,
1514 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
1515 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
1516 PUSH_FIELD_VALUE (cons
, "interface_count", build_int_2 (interface_len
, 0));
1517 PUSH_FIELD_VALUE (cons
, "state", integer_zero_node
);
1519 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
1520 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
1521 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
1522 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
1523 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
1524 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
1525 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
1527 FINISH_RECORD_CONSTRUCTOR (cons
);
1529 DECL_INITIAL (decl
) = cons
;
1531 /* Hash synchronization requires at least 64-bit alignment. */
1532 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
1533 DECL_ALIGN (decl
) = 64;
1535 rest_of_decl_compilation (decl
, (char*) 0, 1, 0);
1542 tree type_methods
= TYPE_METHODS (current_class
);
1543 int saw_native_method
= 0;
1545 /* Find out if we have any native methods. We use this information
1547 for (method
= type_methods
;
1548 method
!= NULL_TREE
;
1549 method
= TREE_CHAIN (method
))
1551 if (METHOD_NATIVE (method
))
1553 saw_native_method
= 1;
1558 /* Emit deferred inline methods. */
1559 for (method
= type_methods
; method
!= NULL_TREE
; )
1561 if (! TREE_ASM_WRITTEN (method
) && DECL_SAVED_INSNS (method
) != 0)
1563 output_inline_function (method
);
1564 /* Scan the list again to see if there are any earlier
1566 method
= type_methods
;
1569 method
= TREE_CHAIN (method
);
1572 current_function_decl
= NULL_TREE
;
1573 make_class_data (current_class
);
1575 rest_of_decl_compilation (TYPE_NAME (current_class
), (char*) 0, 1, 0);
1578 /* Return 2 if CLASS is compiled by this compilation job;
1579 return 1 if CLASS can otherwise be assumed to be compiled;
1580 return 0 if we cannot assume that CLASS is compiled.
1581 Returns 1 for primitive and 0 for array types. */
1583 is_compiled_class (tree
class)
1586 if (TREE_CODE (class) == POINTER_TYPE
)
1587 class = TREE_TYPE (class);
1588 if (TREE_CODE (class) != RECORD_TYPE
) /* Primitive types are static. */
1590 if (TYPE_ARRAY_P (class))
1592 if (class == current_class
)
1595 seen_in_zip
= (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1596 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip
)
1598 /* The class was seen in the current ZIP file and will be
1599 available as a compiled class in the future but may not have
1600 been loaded already. Load it if necessary. This prevent
1601 build_class_ref () from crashing. */
1603 if (seen_in_zip
&& !CLASS_LOADED_P (class))
1604 load_class (class, 1);
1606 /* We return 2 for class seen in ZIP and class from files
1607 belonging to the same compilation unit */
1611 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1613 if (!CLASS_LOADED_P (class))
1615 if (CLASS_FROM_SOURCE_P (class))
1616 safe_layout_class (class);
1618 load_class (class, 1);
1626 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1629 build_dtable_decl (tree type
)
1633 /* We need to build a new dtable type so that its size is uniquely
1634 computed when we're dealing with the class for real and not just
1635 faking it (like java.lang.Class during the initialization of the
1636 compiler.) We know we're not faking a class when CURRENT_CLASS is
1638 if (current_class
== type
)
1640 tree dummy
= NULL_TREE
;
1643 dtype
= make_node (RECORD_TYPE
);
1645 PUSH_FIELD (dtype
, dummy
, "top_offset", ptr_type_node
);
1646 PUSH_FIELD (dtype
, dummy
, "type_info", ptr_type_node
);
1648 PUSH_FIELD (dtype
, dummy
, "class", class_ptr_type
);
1649 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
1651 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
1652 TREE_CHAIN (dummy
) = tmp_field
;
1653 DECL_CONTEXT (tmp_field
) = dtype
;
1654 DECL_ARTIFICIAL (tmp_field
) = 1;
1658 PUSH_FIELD (dtype
, dummy
, "gc_descr", ptr_type_node
);
1659 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
1661 tree tmp_field
= build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_node
);
1662 TREE_CHAIN (dummy
) = tmp_field
;
1663 DECL_CONTEXT (tmp_field
) = dtype
;
1664 DECL_ARTIFICIAL (tmp_field
) = 1;
1668 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
1669 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1670 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1672 PUSH_FIELD (dtype
, dummy
, "methods",
1673 build_prim_array_type (nativecode_ptr_type_node
, n
));
1674 layout_type (dtype
);
1677 dtype
= dtable_type
;
1679 return build_decl (VAR_DECL
,
1680 java_mangle_vtable (&temporary_obstack
, type
), dtype
);
1683 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
1684 fields inherited from SUPER_CLASS. */
1687 push_super_field (tree this_class
, tree super_class
)
1690 /* Don't insert the field if we're just re-laying the class out. */
1691 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
1693 base_decl
= build_decl (FIELD_DECL
, NULL_TREE
, super_class
);
1694 DECL_IGNORED_P (base_decl
) = 1;
1695 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
1696 TYPE_FIELDS (this_class
) = base_decl
;
1697 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
1698 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
1701 /* Handle the different manners we may have to lay out a super class. */
1704 maybe_layout_super_class (tree super_class
, tree this_class
)
1706 if (TREE_CODE (super_class
) == RECORD_TYPE
)
1708 if (!CLASS_LOADED_P (super_class
) && CLASS_FROM_SOURCE_P (super_class
))
1709 safe_layout_class (super_class
);
1710 if (!CLASS_LOADED_P (super_class
))
1711 load_class (super_class
, 1);
1713 /* We might have to layout the class before its dependency on
1714 the super class gets resolved by java_complete_class */
1715 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
1717 if (TREE_TYPE (super_class
) != NULL_TREE
)
1718 super_class
= TREE_TYPE (super_class
);
1721 super_class
= do_resolve_class (NULL_TREE
, /* FIXME? */
1722 super_class
, NULL_TREE
, this_class
);
1724 return NULL_TREE
; /* FIXME, NULL_TREE not checked by caller. */
1725 super_class
= TREE_TYPE (super_class
);
1728 if (!TYPE_SIZE (super_class
))
1729 safe_layout_class (super_class
);
1735 layout_class (tree this_class
)
1737 tree super_class
= CLASSTYPE_SUPER (this_class
);
1740 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
1741 if (CLASS_BEING_LAIDOUT (this_class
))
1747 sprintf (buffer
, " with `%s'",
1748 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
1749 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
1751 for (current
= TREE_CHAIN (class_list
); current
;
1752 current
= TREE_CHAIN (current
))
1754 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
1755 sprintf (buffer
, "\n which inherits from `%s' (%s:%d)",
1756 IDENTIFIER_POINTER (DECL_NAME (decl
)),
1757 DECL_SOURCE_FILE (decl
),
1758 DECL_SOURCE_LINE (decl
));
1759 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
1761 obstack_1grow (&temporary_obstack
, '\0');
1762 report
= obstack_finish (&temporary_obstack
);
1763 cyclic_inheritance_report
= ggc_strdup (report
);
1764 obstack_free (&temporary_obstack
, report
);
1765 TYPE_SIZE (this_class
) = error_mark_node
;
1768 CLASS_BEING_LAIDOUT (this_class
) = 1;
1770 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
1772 tree maybe_super_class
1773 = maybe_layout_super_class (super_class
, this_class
);
1774 if (maybe_super_class
== NULL
1775 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
1777 TYPE_SIZE (this_class
) = error_mark_node
;
1778 CLASS_BEING_LAIDOUT (this_class
) = 0;
1779 class_list
= TREE_CHAIN (class_list
);
1782 if (TYPE_SIZE (this_class
) == NULL_TREE
)
1783 push_super_field (this_class
, maybe_super_class
);
1786 for (field
= TYPE_FIELDS (this_class
);
1787 field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1789 if (FIELD_STATIC (field
))
1791 /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
1792 SET_DECL_ASSEMBLER_NAME (field
,
1794 (&temporary_obstack
, field
));
1798 layout_type (this_class
);
1800 /* Also recursively load/layout any superinterfaces, but only if class was
1801 loaded from bytecode. The source parser will take care of this itself. */
1802 if (!CLASS_FROM_SOURCE_P (this_class
))
1804 tree basetype_vec
= TYPE_BINFO_BASETYPES (this_class
);
1808 int n
= TREE_VEC_LENGTH (basetype_vec
) - 1;
1810 for (i
= n
; i
> 0; i
--)
1812 tree vec_elt
= TREE_VEC_ELT (basetype_vec
, i
);
1813 tree super_interface
= BINFO_TYPE (vec_elt
);
1815 tree maybe_super_interface
1816 = maybe_layout_super_class (super_interface
, NULL_TREE
);
1817 if (maybe_super_interface
== NULL
1818 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
1820 TYPE_SIZE (this_class
) = error_mark_node
;
1821 CLASS_BEING_LAIDOUT (this_class
) = 0;
1822 class_list
= TREE_CHAIN (class_list
);
1829 /* Convert the size back to an SI integer value */
1830 TYPE_SIZE_UNIT (this_class
) =
1831 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
1833 CLASS_BEING_LAIDOUT (this_class
) = 0;
1834 class_list
= TREE_CHAIN (class_list
);
1838 layout_class_methods (tree this_class
)
1840 tree method_decl
, dtable_count
;
1843 if (TYPE_NVIRTUALS (this_class
))
1846 super_class
= CLASSTYPE_SUPER (this_class
);
1850 super_class
= maybe_layout_super_class (super_class
, this_class
);
1851 if (!TYPE_NVIRTUALS (super_class
))
1852 layout_class_methods (super_class
);
1853 dtable_count
= TYPE_NVIRTUALS (super_class
);
1856 dtable_count
= integer_zero_node
;
1858 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
1860 for (method_decl
= TYPE_METHODS (this_class
);
1861 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
1862 dtable_count
= layout_class_method (this_class
, super_class
,
1863 method_decl
, dtable_count
);
1865 TYPE_NVIRTUALS (this_class
) = dtable_count
;
1868 /* Lay METHOD_DECL out, returning a possibly new value of
1869 DTABLE_COUNT. Also mangle the method's name. */
1872 layout_class_method (tree this_class
, tree super_class
,
1873 tree method_decl
, tree dtable_count
)
1875 tree method_name
= DECL_NAME (method_decl
);
1877 TREE_PUBLIC (method_decl
) = 1;
1879 /* This is a good occasion to mangle the method's name */
1880 SET_DECL_ASSEMBLER_NAME (method_decl
,
1881 java_mangle_decl (&temporary_obstack
,
1883 /* We don't generate a RTL for the method if it's abstract, or if
1884 it's an interface method that isn't clinit. */
1885 if (! METHOD_ABSTRACT (method_decl
)
1886 || (CLASS_INTERFACE (TYPE_NAME (this_class
))
1887 && (DECL_CLINIT_P (method_decl
))))
1888 make_decl_rtl (method_decl
, NULL
);
1890 if (ID_INIT_P (method_name
))
1892 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
1894 for (ptr
= p
; *ptr
; )
1899 DECL_CONSTRUCTOR_P (method_decl
) = 1;
1900 build_java_argument_signature (TREE_TYPE (method_decl
));
1902 else if (! METHOD_STATIC (method_decl
) && !DECL_ARTIFICIAL (method_decl
))
1905 build_java_argument_signature (TREE_TYPE (method_decl
));
1906 tree super_method
= lookup_argument_method (super_class
, method_name
,
1908 if (super_method
!= NULL_TREE
&& ! METHOD_PRIVATE (super_method
))
1910 DECL_VINDEX (method_decl
) = DECL_VINDEX (super_method
);
1911 if (DECL_VINDEX (method_decl
) == NULL_TREE
1912 && !CLASS_FROM_SOURCE_P (this_class
))
1913 error_with_decl (method_decl
,
1914 "non-static method '%s' overrides static method");
1916 else if (! METHOD_FINAL (method_decl
)
1917 && ! METHOD_PRIVATE (method_decl
)
1918 && ! CLASS_FINAL (TYPE_NAME (this_class
))
1921 DECL_VINDEX (method_decl
) = dtable_count
;
1922 dtable_count
= fold (build (PLUS_EXPR
, integer_type_node
,
1923 dtable_count
, integer_one_node
));
1927 return dtable_count
;
1931 register_class (void)
1933 /* END does not need to be registered with the garbage collector
1934 because it always points into the list given by REGISTERED_CLASS,
1935 and that variable is registered with the collector. */
1937 tree node
= TREE_OPERAND (build_class_ref (current_class
), 0);
1938 tree current
= copy_node (node
);
1940 XEXP (DECL_RTL (current
), 0) = copy_rtx (XEXP (DECL_RTL(node
), 0));
1941 if (!registered_class
)
1942 registered_class
= current
;
1944 TREE_CHAIN (end
) = current
;
1949 /* Emit something to register classes at start-up time.
1951 The preferred mechanism is through the .jcr section, which contain
1952 a list of pointers to classes which get registered during
1953 constructor invocation time. The fallback mechanism is to generate
1954 a `constructor' function which calls _Jv_RegisterClass for each
1955 class in this file. */
1958 emit_register_classes (void)
1960 /* ??? This isn't quite the correct test. We also have to know
1961 that the target is using gcc's crtbegin/crtend objects rather
1962 than the ones that come with the operating system. */
1963 if (SUPPORTS_WEAK
&& targetm
.have_named_sections
)
1965 #ifdef JCR_SECTION_NAME
1967 named_section_flags (JCR_SECTION_NAME
, SECTION_WRITE
);
1968 assemble_align (POINTER_SIZE
);
1969 for (t
= registered_class
; t
; t
= TREE_CHAIN (t
))
1970 assemble_integer (XEXP (DECL_RTL (t
), 0),
1971 POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1978 extern tree
get_file_function_name (int);
1979 tree init_name
= get_file_function_name ('I');
1980 tree init_type
= build_function_type (void_type_node
, end_params_node
);
1984 init_decl
= build_decl (FUNCTION_DECL
, init_name
, init_type
);
1985 SET_DECL_ASSEMBLER_NAME (init_decl
, init_name
);
1986 TREE_STATIC (init_decl
) = 1;
1987 current_function_decl
= init_decl
;
1988 DECL_RESULT (init_decl
) = build_decl (RESULT_DECL
, NULL_TREE
,
1991 /* It can be a static function as long as collect2 does not have
1992 to scan the object file to find its ctor/dtor routine. */
1993 TREE_PUBLIC (init_decl
) = ! targetm
.have_ctors_dtors
;
1995 /* Suppress spurious warnings. */
1996 TREE_USED (init_decl
) = 1;
1999 make_decl_rtl (init_decl
, NULL
);
2000 init_function_start (init_decl
, input_filename
, 0);
2001 expand_function_start (init_decl
, 0);
2003 /* Do not allow the function to be deferred. */
2004 current_function_cannot_inline
2005 = "static constructors and destructors cannot be inlined";
2007 for ( t
= registered_class
; t
; t
= TREE_CHAIN (t
))
2008 emit_library_call (registerClass_libfunc
, 0, VOIDmode
, 1,
2009 XEXP (DECL_RTL (t
), 0), Pmode
);
2011 expand_function_end (input_filename
, 0, 0);
2013 rest_of_compilation (init_decl
);
2014 current_function_decl
= NULL_TREE
;
2016 if (targetm
.have_ctors_dtors
)
2017 (* targetm
.asm_out
.constructor
) (XEXP (DECL_RTL (init_decl
), 0),
2018 DEFAULT_INIT_PRIORITY
);
2022 /* Make a method_symbol_type (_Jv_MethodSymbol) node for METHOD. */
2025 build_method_symbols_entry (tree method
)
2027 tree clname
, name
, signature
, method_symbol
;
2029 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (method
))));
2030 name
= build_utf8_ref (DECL_NAME (method
));
2031 signature
= build_java_signature (TREE_TYPE (method
));
2032 signature
= build_utf8_ref (unmangle_classname
2033 (IDENTIFIER_POINTER (signature
),
2034 IDENTIFIER_LENGTH (signature
)));
2036 START_RECORD_CONSTRUCTOR (method_symbol
, method_symbol_type
);
2037 PUSH_FIELD_VALUE (method_symbol
, "clname", clname
);
2038 PUSH_FIELD_VALUE (method_symbol
, "name", name
);
2039 PUSH_FIELD_VALUE (method_symbol
, "signature", signature
);
2040 FINISH_RECORD_CONSTRUCTOR (method_symbol
);
2041 TREE_CONSTANT (method_symbol
) = 1;
2043 return method_symbol
;
2046 /* Emit the offset symbols table for indirect virtual dispatch. */
2049 emit_offset_symbol_table (void)
2051 tree method_list
, method
, table
, list
, null_symbol
;
2052 tree otable_bound
, otable_array_type
;
2055 /* Only emit an offset table if this translation unit actually made virtual
2057 if (otable_methods
== NULL_TREE
)
2060 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2062 method_list
= otable_methods
;
2064 while (method_list
!= NULL_TREE
)
2066 method
= TREE_VALUE (method_list
);
2067 list
= tree_cons (NULL_TREE
, build_method_symbols_entry (method
), list
);
2068 method_list
= TREE_CHAIN (method_list
);
2072 /* Terminate the list with a "null" entry. */
2073 START_RECORD_CONSTRUCTOR (null_symbol
, method_symbol_type
);
2074 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2075 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2076 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2077 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2078 TREE_CONSTANT (null_symbol
) = 1;
2079 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2081 /* Put the list in the right order and make it a constructor. */
2082 list
= nreverse (list
);
2083 table
= build (CONSTRUCTOR
, method_symbols_array_type
, NULL_TREE
, list
);
2085 /* Make it the initial value for otable_syms and emit the decl. */
2086 DECL_INITIAL (otable_syms_decl
) = table
;
2087 DECL_ARTIFICIAL (otable_syms_decl
) = 1;
2088 DECL_IGNORED_P (otable_syms_decl
) = 1;
2089 rest_of_decl_compilation (otable_syms_decl
, NULL
, 1, 0);
2091 /* Now that its size is known, redefine otable as an uninitialized static
2092 array of INDEX + 1 integers. The extra entry is used by the runtime
2093 to track whether the otable has been initialized. */
2094 otable_bound
= build_index_type (build_int_2 (index
, 0));
2095 otable_array_type
= build_array_type (integer_type_node
, otable_bound
);
2096 otable_decl
= build_decl (VAR_DECL
, get_identifier ("otable"),
2098 TREE_STATIC (otable_decl
) = 1;
2099 TREE_READONLY (otable_decl
) = 1;
2100 rest_of_decl_compilation (otable_decl
, NULL
, 1, 0);
2104 init_class_processing (void)
2106 registerClass_libfunc
= gen_rtx_SYMBOL_REF (Pmode
, "_Jv_RegisterClass");
2107 fields_ident
= get_identifier ("fields");
2108 info_ident
= get_identifier ("info");
2109 gcc_obstack_init (&temporary_obstack
);
2112 static hashval_t
java_treetreehash_hash (const void *);
2113 static int java_treetreehash_compare (const void *, const void *);
2115 /* A hash table mapping trees to trees. Used generally. */
2117 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2120 java_treetreehash_hash (const void *k_p
)
2122 struct treetreehash_entry
*k
= (struct treetreehash_entry
*) k_p
;
2123 return JAVA_TREEHASHHASH_H (k
->key
);
2127 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
2129 struct treetreehash_entry
* k1
= (struct treetreehash_entry
*) k1_p
;
2130 tree k2
= (tree
) k2_p
;
2131 return (k1
->key
== k2
);
2135 java_treetreehash_find (htab_t ht
, tree t
)
2137 struct treetreehash_entry
*e
;
2138 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2139 e
= (struct treetreehash_entry
*) htab_find_with_hash (ht
, t
, hv
);
2147 java_treetreehash_new (htab_t ht
, tree t
)
2150 struct treetreehash_entry
*tthe
;
2151 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
2153 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
2156 tthe
= (*ht
->alloc_f
) (1, sizeof (*tthe
));
2161 tthe
= (struct treetreehash_entry
*) *e
;
2162 return &tthe
->value
;
2166 java_treetreehash_create (size_t size
, int gc
)
2169 return htab_create_ggc (size
, java_treetreehash_hash
,
2170 java_treetreehash_compare
, NULL
);
2172 return htab_create_alloc (size
, java_treetreehash_hash
,
2173 java_treetreehash_compare
, free
, xcalloc
, free
);
2176 #include "gt-java-class.h"