1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC 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 GNU CC 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 GNU CC; 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> */
33 #include "java-tree.h"
41 static tree make_method_value PARAMS ((tree));
42 static tree build_java_method_type PARAMS ((tree, tree, int));
43 static int32 hashUtf8String PARAMS ((const char *, int));
44 static tree make_field_value PARAMS ((tree));
45 static tree get_dispatch_vector PARAMS ((tree));
46 static tree get_dispatch_table PARAMS ((tree, tree));
47 static void add_interface_do PARAMS ((tree, tree, int));
48 static tree maybe_layout_super_class PARAMS ((tree, tree));
49 static int assume_compiled PARAMS ((const char *));
50 static struct hash_entry *init_test_hash_newfunc PARAMS ((struct hash_entry *,
53 static rtx registerClass_libfunc;
55 extern struct obstack permanent_obstack;
56 struct obstack temporary_obstack;
58 /* The compiler generates different code depending on whether or not
59 it can assume certain classes have been compiled down to native
60 code or not. The compiler options -fassume-compiled= and
61 -fno-assume-compiled= are used to create a tree of
62 assume_compiled_node objects. This tree is queried to determine if
63 a class is assume to be compiled or not. Each node in the tree
64 represents either a package or a specific class. */
66 typedef struct assume_compiled_node_struct
68 /* The class or package name. */
71 /* Non-zero if this represents an exclusion. */
74 /* Pointers to other nodes in the tree. */
75 struct assume_compiled_node_struct *parent;
76 struct assume_compiled_node_struct *sibling;
77 struct assume_compiled_node_struct *child;
78 } assume_compiled_node;
80 static assume_compiled_node *find_assume_compiled_node
81 PARAMS ((assume_compiled_node *, const char *));
83 /* This is the root of the include/exclude tree. */
85 static assume_compiled_node *assume_compiled_tree;
87 static tree class_roots[5]
88 = { NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE };
89 #define registered_class class_roots[0]
90 #define fields_ident class_roots[1] /* get_identifier ("fields") */
91 #define info_ident class_roots[2] /* get_identifier ("info") */
92 #define class_list class_roots[3]
93 #define class_dtable_decl class_roots[4]
95 /* Return the node that most closely represents the class whose name
96 is IDENT. Start the search from NODE. Return NULL if an
97 appropriate node does not exist. */
99 static assume_compiled_node *
100 find_assume_compiled_node (node, ident)
101 assume_compiled_node *node;
106 size_t node_ident_length = strlen (node->ident);
108 /* node_ident_length is zero at the root of the tree. If the
109 identifiers are the same length, then we have matching
110 classes. Otherwise check if we've matched an enclosing
113 if (node_ident_length == 0
114 || (strncmp (ident, node->ident, node_ident_length) == 0
115 && (strlen (ident) == node_ident_length
116 || ident[node_ident_length] == '.')))
118 /* We've found a match, however, there might be a more
121 assume_compiled_node *found = find_assume_compiled_node (node->child,
129 /* No match yet. Continue through the sibling list. */
130 node = node->sibling;
133 /* No match at all in this tree. */
137 /* Add a new IDENT to the include/exclude tree. It's an exclusion
138 if EXCLUDEP is non-zero. */
141 add_assume_compiled (ident, excludep)
145 assume_compiled_node *parent;
146 assume_compiled_node *node =
147 (assume_compiled_node *) xmalloc (sizeof (assume_compiled_node));
149 node->ident = xstrdup (ident);
150 node->excludep = excludep;
153 /* Create the root of the tree if it doesn't exist yet. */
155 if (NULL == assume_compiled_tree)
157 assume_compiled_tree =
158 (assume_compiled_node *) xmalloc (sizeof (assume_compiled_node));
159 assume_compiled_tree->ident = "";
160 assume_compiled_tree->excludep = 0;
161 assume_compiled_tree->sibling = NULL;
162 assume_compiled_tree->child = NULL;
163 assume_compiled_tree->parent = NULL;
166 /* Calling the function with the empty string means we're setting
167 excludep for the root of the hierarchy. */
171 assume_compiled_tree->excludep = excludep;
175 /* Find the parent node for this new node. PARENT will either be a
176 class or a package name. Adjust PARENT accordingly. */
178 parent = find_assume_compiled_node (assume_compiled_tree, ident);
179 if (ident[strlen (parent->ident)] != '.')
180 parent = parent->parent;
182 /* Insert NODE into the tree. */
184 node->parent = parent;
185 node->sibling = parent->child;
186 parent->child = node;
189 /* Returns non-zero if IDENT is the name of a class that the compiler
190 should assume has been compiled to FIXME */
193 assume_compiled (ident)
196 assume_compiled_node *i;
199 if (NULL == assume_compiled_tree)
202 i = find_assume_compiled_node (assume_compiled_tree,
205 result = ! i->excludep;
210 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
211 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
212 Also, PREFIX is prepended, and SUFFIX is appended. */
215 ident_subst (old_name, old_length, prefix, old_char, new_char, suffix)
216 const char* old_name;
223 int prefix_len = strlen (prefix);
224 int suffix_len = strlen (suffix);
225 int i = prefix_len + old_length + suffix_len + 1;
229 char *buffer = (char *)alloca (i);
231 strcpy (buffer, prefix);
232 for (i = 0; i < old_length; i++)
234 char ch = old_name[i];
237 buffer[prefix_len + i] = ch;
239 strcpy (buffer + prefix_len + old_length, suffix);
240 return get_identifier (buffer);
243 /* Return an IDENTIFIER_NODE the same as OLD_ID,
244 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
245 Also, PREFIX is prepended, and SUFFIX is appended. */
248 identifier_subst (old_id, prefix, old_char, new_char, suffix)
255 return ident_subst (IDENTIFIER_POINTER (old_id), IDENTIFIER_LENGTH (old_id),
256 prefix, old_char, new_char, suffix);
259 /* Generate a valid C identifier from the name of the class TYPE,
260 prefixed by PREFIX. */
263 mangled_classname (prefix, 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 #ifdef JAVA_USE_HANDLES
279 tree field1 = build_decl (FIELD_DECL, get_identifier ("obj"),
280 build_pointer_type (type));
281 tree field2 = build_decl (FIELD_DECL, get_identifier ("methods"),
282 methodtable_ptr_type);
283 tree handle_type = make_node (RECORD_TYPE);
284 TREE_CHAIN (field1) = field2;
285 TYPE_FIELDS (handle_type) = field1;
286 TYPE_BINFO (type) = make_tree_vec (7);
287 TYPE_BINFO (handle_type) = make_tree_vec (7);
288 BINFO_HANDLE (TYPE_BINFO (handle_type)) = type;
289 BINFO_HANDLE (TYPE_BINFO (type)) = handle_type;
291 TYPE_BINFO (type) = make_tree_vec (6);
293 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
298 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
299 and where each of the constituents is separated by '/',
300 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
303 unmangle_classname (name, name_length)
304 const char *name; int name_length;
306 tree to_return = ident_subst (name, name_length, "", '/', '.', "");
307 /* It's not sufficient to compare to_return and get_identifier
308 (name) to determine whether to_return is qualified. There are
309 cases in signature analysis where name will be stripped of a
311 name = IDENTIFIER_POINTER (to_return);
315 QUALIFIED_P (to_return) = 1;
323 push_class (class_type, class_name)
324 tree class_type, class_name;
326 tree decl, signature;
327 const char *save_input_filename = input_filename;
328 int save_lineno = lineno;
329 tree source_name = identifier_subst (class_name, "", '.', '/', ".java");
330 CLASS_P (class_type) = 1;
331 input_filename = IDENTIFIER_POINTER (source_name);
333 decl = build_decl (TYPE_DECL, class_name, class_type);
334 input_filename = save_input_filename;
335 lineno = save_lineno;
336 signature = identifier_subst (class_name, "L", '.', '/', ";");
337 IDENTIFIER_SIGNATURE_TYPE (signature) = build_pointer_type (class_type);
339 /* Setting DECL_ARTIFICAL forces dbxout.c to specific the type is
340 both a typedef and in the struct name-space. We may want to re-visit
341 this later, but for now it reduces the changes needed for gdb. */
342 DECL_ARTIFICIAL (decl) = 1;
344 pushdecl_top_level (decl);
345 #ifdef JAVA_USE_HANDLES
347 tree handle_name = identifier_subst (class_name,
348 "Handle$", '.', '.', "");
349 tree handle_decl = build_decl (TYPE_DECL, handle_name,
350 CLASS_TO_HANDLE_TYPE (class_type));
351 pushdecl (handle_decl);
358 /* Finds the (global) class named NAME. Creates the class if not found.
359 Also creates associated TYPE_DECL.
360 Does not check if the class actually exists, load the class,
361 fill in field or methods, or do layout_type. */
367 tree decl = IDENTIFIER_CLASS_VALUE (name);
368 if (decl == NULL_TREE)
369 decl = push_class (make_class (), name);
370 return TREE_TYPE (decl);
374 set_super_info (access_flags, this_class, super_class, interfaces_count)
378 int interfaces_count;
380 int total_supers = interfaces_count;
381 tree class_decl = TYPE_NAME (this_class);
385 TYPE_BINFO_BASETYPES (this_class) = make_tree_vec (total_supers);
388 tree super_binfo = make_tree_vec (6);
389 BINFO_TYPE (super_binfo) = super_class;
390 BINFO_OFFSET (super_binfo) = integer_zero_node;
391 TREE_VIA_PUBLIC (super_binfo) = 1;
392 TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (this_class)), 0)
394 CLASS_HAS_SUPER (this_class) = 1;
397 if (access_flags & ACC_PUBLIC) CLASS_PUBLIC (class_decl) = 1;
398 if (access_flags & ACC_FINAL) CLASS_FINAL (class_decl) = 1;
399 if (access_flags & ACC_SUPER) CLASS_SUPER (class_decl) = 1;
400 if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
401 if (access_flags & ACC_ABSTRACT) CLASS_ABSTRACT (class_decl) = 1;
402 if (access_flags & ACC_STATIC) CLASS_STATIC (class_decl) = 1;
403 if (access_flags & ACC_PRIVATE) CLASS_PRIVATE (class_decl) = 1;
404 if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
407 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
408 direct sub-classes of Object are 1, and so on. */
415 if (! CLASS_LOADED_P (clas))
416 load_class (clas, 1);
417 if (TYPE_SIZE (clas) == error_mark_node)
419 while (clas != object_type_node)
422 clas = TYPE_BINFO_BASETYPE (clas, 0);
427 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
430 interface_of_p (type1, type2)
436 if (!(basetype_vec = TYPE_BINFO_BASETYPES (type2)))
438 n = TREE_VEC_LENGTH (basetype_vec);
439 for (i = 0; i < n; i++)
441 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
442 if (vec_elt && BINFO_TYPE (vec_elt) == type1)
445 for (i = 0; i < n; i++)
447 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
448 if (vec_elt && BINFO_TYPE (vec_elt)
449 && interface_of_p (type1, BINFO_TYPE (vec_elt)))
455 /* Return true iff TYPE1 inherits from TYPE2. */
458 inherits_from_p (type1, type2)
461 while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
465 type1 = CLASSTYPE_SUPER (type1);
470 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
473 enclosing_context_p (type1, type2)
476 if (!INNER_CLASS_TYPE_P (type2))
479 for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
481 type2 = (INNER_CLASS_TYPE_P (type2) ?
482 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
491 /* Return 1 iff there exists a common enclosing context between TYPE1
494 int common_enclosing_context_p (type1, type2)
497 if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
500 for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1;
501 type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
502 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
505 for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
506 current = (PURE_INNER_CLASS_TYPE_P (current) ?
507 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
509 if (type1 == current)
516 add_interface_do (basetype_vec, interface_class, i)
517 tree basetype_vec, interface_class;
520 tree interface_binfo = make_tree_vec (6);
521 BINFO_TYPE (interface_binfo) = interface_class;
522 BINFO_OFFSET (interface_binfo) = integer_zero_node;
523 TREE_VIA_VIRTUAL (interface_binfo) = 1;
524 TREE_VIA_PUBLIC (interface_binfo) = 1;
525 TREE_VEC_ELT (basetype_vec, i) = interface_binfo;
528 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
529 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
530 if attempt is made to add it twice. */
533 maybe_add_interface (this_class, interface_class)
534 tree this_class, interface_class;
536 tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
538 int n = TREE_VEC_LENGTH (basetype_vec);
543 error ("internal error - too many interface type");
546 else if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
548 else if (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)) == interface_class)
549 return interface_class;
551 add_interface_do (basetype_vec, interface_class, i);
555 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
558 add_interface (this_class, interface_class)
559 tree this_class, interface_class;
561 tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
563 int n = TREE_VEC_LENGTH (basetype_vec);
568 error ("internal error - too many interface type");
571 else if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
574 add_interface_do (basetype_vec, interface_class, i);
578 /* Return the address of a pointer to the first FUNCTION_DECL
579 in the list (*LIST) whose DECL_NAME is NAME. */
582 find_named_method (list, name)
586 while (*list && DECL_NAME (*list) != name)
587 list = &TREE_CHAIN (*list);
593 build_java_method_type (fntype, this_class, access_flags)
598 if (access_flags & ACC_STATIC)
600 return build_method_type (CLASS_TO_HANDLE_TYPE (this_class), fntype);
603 static struct hash_entry *
604 init_test_hash_newfunc (entry, table, string)
605 struct hash_entry *entry;
606 struct hash_table *table;
607 hash_table_key string ATTRIBUTE_UNUSED;
609 struct init_test_hash_entry *ret = (struct init_test_hash_entry *) entry;
612 ret = ((struct init_test_hash_entry *)
613 hash_allocate (table, sizeof (struct init_test_hash_entry)));
617 ret->init_test_decl = 0;
618 return (struct hash_entry *) ret;
621 /* Hash table helpers. Also reused in find_applicable_accessible_methods_list
622 (parse.y). The hash of a tree node is it's pointer value,
623 comparison is direct. */
626 java_hash_hash_tree_node (k)
633 java_hash_compare_tree_node (k1, k2)
637 return ((char*) k1 == (char*) k2);
641 add_method_1 (handle_class, access_flags, name, function_type)
647 tree method_type, fndecl;
649 method_type = build_java_method_type (function_type,
650 handle_class, access_flags);
652 fndecl = build_decl (FUNCTION_DECL, name, method_type);
653 DECL_CONTEXT (fndecl) = handle_class;
655 DECL_LANG_SPECIFIC (fndecl)
656 = (struct lang_decl *) ggc_alloc_cleared (sizeof (struct lang_decl));
658 /* Initialize the static initializer test table. */
659 hash_table_init (&DECL_FUNCTION_INIT_TEST_TABLE (fndecl),
660 init_test_hash_newfunc, java_hash_hash_tree_node,
661 java_hash_compare_tree_node);
663 TREE_CHAIN (fndecl) = TYPE_METHODS (handle_class);
664 TYPE_METHODS (handle_class) = fndecl;
666 if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
667 if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
668 if (access_flags & ACC_PRIVATE)
669 METHOD_PRIVATE (fndecl) = DECL_INLINE (fndecl) = 1;
670 if (access_flags & ACC_NATIVE)
672 METHOD_NATIVE (fndecl) = 1;
673 DECL_EXTERNAL (fndecl) = 1;
675 if (access_flags & ACC_STATIC)
676 METHOD_STATIC (fndecl) = DECL_INLINE (fndecl) = 1;
677 if (access_flags & ACC_FINAL)
678 METHOD_FINAL (fndecl) = DECL_INLINE (fndecl) = 1;
679 if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
680 if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
681 if (access_flags & ACC_TRANSIENT) METHOD_TRANSIENT (fndecl) = 1;
685 /* Add a method to THIS_CLASS.
686 The method's name is NAME.
687 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
690 add_method (this_class, access_flags, name, method_sig)
696 tree handle_class = CLASS_TO_HANDLE_TYPE (this_class);
697 tree function_type, fndecl;
698 const unsigned char *sig
699 = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
702 fatal_error ("bad method signature");
704 function_type = get_type_from_signature (method_sig);
705 fndecl = add_method_1 (handle_class, access_flags, name, function_type);
706 set_java_signature (TREE_TYPE (fndecl), method_sig);
711 add_field (class, name, field_type, flags)
717 int is_static = (flags & ACC_STATIC) != 0;
719 field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type);
720 TREE_CHAIN (field) = TYPE_FIELDS (class);
721 TYPE_FIELDS (class) = field;
722 DECL_CONTEXT (field) = class;
724 if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
725 if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
726 if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
727 if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
728 if (flags & ACC_VOLATILE) FIELD_VOLATILE (field) = 1;
729 if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
732 FIELD_STATIC (field) = 1;
733 /* Always make field externally visible. This is required so
734 that native methods can always access the field. */
735 TREE_PUBLIC (field) = 1;
740 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
743 set_constant_value (field, constant)
744 tree field, constant;
746 if (field == NULL_TREE)
747 warning ("misplaced ConstantValue attribute (not in any field)");
748 else if (DECL_INITIAL (field) != NULL_TREE)
749 warning ("duplicate ConstanValue atribute for field '%s'",
750 IDENTIFIER_POINTER (DECL_NAME (field)));
753 DECL_INITIAL (field) = constant;
754 if (FIELD_FINAL (field))
755 DECL_FIELD_FINAL_IUD (field) = 1;
759 /* Count the number of Unicode chars encoded in a given Ut8 string. */
763 strLengthUtf8 (str, len)
767 register unsigned char* ptr = (unsigned char*) str;
768 register unsigned char *limit = ptr + len;
770 for (; ptr < limit; str_length++) {
771 if (UTF8_GET (ptr, limit) < 0)
779 /* Calculate a hash value for a string encoded in Utf8 format.
780 * This returns the same hash value as specified for java.lang.String.hashCode.
784 hashUtf8String (str, len)
788 register const unsigned char* ptr = (const unsigned char*) str;
789 register const unsigned char *limit = ptr + len;
793 int ch = UTF8_GET (ptr, limit);
794 /* Updated specification from
795 http://www.javasoft.com/docs/books/jls/clarify.html. */
796 hash = (31 * hash) + ch;
801 tree utf8_decl_list = NULL_TREE;
804 build_utf8_ref (name)
807 const char * name_ptr = IDENTIFIER_POINTER(name);
808 int name_len = IDENTIFIER_LENGTH(name);
810 tree ctype, field = NULL_TREE, str_type, cinit, string;
811 static int utf8_count = 0;
813 tree ref = IDENTIFIER_UTF8_REF (name);
815 if (ref != NULL_TREE)
818 ctype = make_node (RECORD_TYPE);
819 str_type = build_prim_array_type (unsigned_byte_type_node,
820 name_len + 1); /* Allow for final '\0'. */
821 PUSH_FIELD (ctype, field, "hash", unsigned_short_type_node);
822 PUSH_FIELD (ctype, field, "length", unsigned_short_type_node);
823 PUSH_FIELD (ctype, field, "data", str_type);
824 FINISH_RECORD (ctype);
825 START_RECORD_CONSTRUCTOR (cinit, ctype);
826 name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
827 PUSH_FIELD_VALUE (cinit, "hash", build_int_2 (name_hash, 0));
828 PUSH_FIELD_VALUE (cinit, "length", build_int_2 (name_len, 0));
829 string = build_string (name_len, name_ptr);
830 TREE_TYPE (string) = str_type;
831 PUSH_FIELD_VALUE (cinit, "data", string);
832 FINISH_RECORD_CONSTRUCTOR (cinit);
833 TREE_CONSTANT (cinit) = 1;
835 /* Generate a unique-enough identifier. */
836 sprintf(buf, "_Utf%d", ++utf8_count);
838 decl = build_decl (VAR_DECL, get_identifier (buf), utf8const_type);
839 /* FIXME get some way to force this into .text, not .data. */
840 TREE_STATIC (decl) = 1;
841 DECL_ARTIFICIAL (decl) = 1;
842 DECL_IGNORED_P (decl) = 1;
843 TREE_READONLY (decl) = 1;
844 TREE_THIS_VOLATILE (decl) = 0;
845 DECL_INITIAL (decl) = cinit;
846 TREE_CHAIN (decl) = utf8_decl_list;
847 layout_decl (decl, 0);
849 rest_of_decl_compilation (decl, (char*) 0, global_bindings_p (), 0);
850 utf8_decl_list = decl;
851 make_decl_rtl (decl, (char*) 0);
852 ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
853 IDENTIFIER_UTF8_REF (name) = ref;
857 /* Build a reference to the class TYPE.
858 Also handles primitive types and array types. */
861 build_class_ref (type)
864 int is_compiled = is_compiled_class (type);
867 tree ref, decl_name, decl;
868 if (TREE_CODE (type) == POINTER_TYPE)
869 type = TREE_TYPE (type);
870 if (TREE_CODE (type) == RECORD_TYPE)
872 if (TYPE_SIZE (type) == error_mark_node)
873 return null_pointer_node;
874 decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
875 "", '/', '/', ".class");
876 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
877 if (decl == NULL_TREE)
879 decl = build_decl (VAR_DECL, decl_name, class_type_node);
880 DECL_SIZE (decl) = TYPE_SIZE (class_type_node);
881 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (class_type_node);
882 TREE_STATIC (decl) = 1;
883 TREE_PUBLIC (decl) = 1;
884 DECL_IGNORED_P (decl) = 1;
885 DECL_ARTIFICIAL (decl) = 1;
886 SET_DECL_ASSEMBLER_NAME (decl,
887 java_mangle_class_field
888 (&temporary_obstack, type));
889 make_decl_rtl (decl, NULL);
890 pushdecl_top_level (decl);
891 if (is_compiled == 1)
892 DECL_EXTERNAL (decl) = 1;
899 if (flag_emit_class_files)
901 const char *prim_class_name;
903 if (type == char_type_node)
904 prim_class_name = "java.lang.Character";
905 else if (type == boolean_type_node)
906 prim_class_name = "java.lang.Boolean";
907 else if (type == byte_type_node)
908 prim_class_name = "java.lang.Byte";
909 else if (type == short_type_node)
910 prim_class_name = "java.lang.Short";
911 else if (type == int_type_node)
912 prim_class_name = "java.lang.Integer";
913 else if (type == long_type_node)
914 prim_class_name = "java.lang.Long";
915 else if (type == float_type_node)
916 prim_class_name = "java.lang.Float";
917 else if (type == double_type_node)
918 prim_class_name = "java.lang.Double";
919 else if (type == void_type_node)
920 prim_class_name = "java.lang.Void";
924 prim_class = lookup_class (get_identifier (prim_class_name));
925 return build (COMPONENT_REF, NULL_TREE,
926 prim_class, TYPE_identifier_node);
928 decl_name = TYPE_NAME (type);
929 if (TREE_CODE (decl_name) == TYPE_DECL)
930 decl_name = DECL_NAME (decl_name);
931 name = IDENTIFIER_POINTER (decl_name);
932 if (strncmp (name, "promoted_", 9) == 0)
934 sprintf (buffer, "_Jv_%sClass", name);
935 decl_name = get_identifier (buffer);
936 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
937 if (decl == NULL_TREE)
939 decl = build_decl (VAR_DECL, decl_name, class_type_node);
940 TREE_STATIC (decl) = 1;
941 TREE_PUBLIC (decl) = 1;
942 make_decl_rtl (decl, NULL);
943 pushdecl_top_level (decl);
944 if (is_compiled == 1)
945 DECL_EXTERNAL (decl) = 1;
949 ref = build1 (ADDR_EXPR, class_ptr_type, decl);
956 index = alloc_class_constant (type);
957 cl = build_ref_from_constant_pool (index);
958 TREE_TYPE (cl) = promote_type (class_ptr_type);
964 build_static_field_ref (fdecl)
967 tree fclass = DECL_CONTEXT (fdecl);
968 int is_compiled = is_compiled_class (fclass);
971 if (!DECL_RTL_SET_P (fdecl))
973 if (is_compiled == 1)
974 DECL_EXTERNAL (fdecl) = 1;
975 make_decl_rtl (fdecl, NULL);
982 * *(FTYPE*)build_class_ref(FCLASS)->fields[INDEX].info.addr */
983 tree ref = build_class_ref (fclass);
986 ref = build1 (INDIRECT_REF, class_type_node, ref);
987 ref = build (COMPONENT_REF, field_ptr_type_node, ref,
988 lookup_field (&class_type_node, fields_ident));
990 for (fld = TYPE_FIELDS (fclass); ; fld = TREE_CHAIN (fld))
994 if (fld == NULL_TREE)
995 fatal_error ("field '%s' not found in class",
996 IDENTIFIER_POINTER (DECL_NAME (fdecl)));
997 if (FIELD_STATIC (fld))
1000 field_index *= int_size_in_bytes (field_type_node);
1001 ref = fold (build (PLUS_EXPR, field_ptr_type_node,
1002 ref, build_int_2 (field_index, 0)));
1003 ref = build1 (INDIRECT_REF, field_type_node, ref);
1004 ref = build (COMPONENT_REF, field_info_union_node,
1005 ref, lookup_field (&field_type_node, info_ident));
1006 ref = build (COMPONENT_REF, ptr_type_node,
1007 ref, TREE_CHAIN (TYPE_FIELDS (field_info_union_node)));
1008 return fold (build1 (INDIRECT_REF, TREE_TYPE(fdecl), ref));
1013 get_access_flags_from_decl (decl)
1016 int access_flags = 0;
1017 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
1019 if (FIELD_STATIC (decl))
1020 access_flags |= ACC_STATIC;
1021 if (FIELD_PUBLIC (decl))
1022 access_flags |= ACC_PUBLIC;
1023 if (FIELD_PROTECTED (decl))
1024 access_flags |= ACC_PROTECTED;
1025 if (FIELD_PRIVATE (decl))
1026 access_flags |= ACC_PRIVATE;
1027 if (FIELD_FINAL (decl))
1028 access_flags |= ACC_FINAL;
1029 if (FIELD_VOLATILE (decl))
1030 access_flags |= ACC_VOLATILE;
1031 if (FIELD_TRANSIENT (decl))
1032 access_flags |= ACC_TRANSIENT;
1033 return access_flags;
1035 if (TREE_CODE (decl) == TYPE_DECL)
1037 if (CLASS_PUBLIC (decl))
1038 access_flags |= ACC_PUBLIC;
1039 if (CLASS_FINAL (decl))
1040 access_flags |= ACC_FINAL;
1041 if (CLASS_SUPER (decl))
1042 access_flags |= ACC_SUPER;
1043 if (CLASS_INTERFACE (decl))
1044 access_flags |= ACC_INTERFACE;
1045 if (CLASS_ABSTRACT (decl))
1046 access_flags |= ACC_ABSTRACT;
1047 if (CLASS_STATIC (decl))
1048 access_flags |= ACC_STATIC;
1049 if (CLASS_PRIVATE (decl))
1050 access_flags |= ACC_PRIVATE;
1051 if (CLASS_PROTECTED (decl))
1052 access_flags |= ACC_PROTECTED;
1053 return access_flags;
1055 if (TREE_CODE (decl) == FUNCTION_DECL)
1057 if (METHOD_PUBLIC (decl))
1058 access_flags |= ACC_PUBLIC;
1059 if (METHOD_PRIVATE (decl))
1060 access_flags |= ACC_PRIVATE;
1061 if (METHOD_PROTECTED (decl))
1062 access_flags |= ACC_PROTECTED;
1063 if (METHOD_STATIC (decl))
1064 access_flags |= ACC_STATIC;
1065 if (METHOD_FINAL (decl))
1066 access_flags |= ACC_FINAL;
1067 if (METHOD_SYNCHRONIZED (decl))
1068 access_flags |= ACC_SYNCHRONIZED;
1069 if (METHOD_NATIVE (decl))
1070 access_flags |= ACC_NATIVE;
1071 if (METHOD_ABSTRACT (decl))
1072 access_flags |= ACC_ABSTRACT;
1073 if (METHOD_TRANSIENT (decl))
1074 access_flags |= ACC_TRANSIENT;
1075 return access_flags;
1081 make_field_value (fdecl)
1086 tree type = TREE_TYPE (fdecl);
1087 int resolved = is_compiled_class (type);
1089 START_RECORD_CONSTRUCTOR (finit, field_type_node);
1090 PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl)));
1092 type = build_class_ref (type);
1095 tree signature = build_java_signature (type);
1097 type = build_utf8_ref (unmangle_classname
1098 (IDENTIFIER_POINTER (signature),
1099 IDENTIFIER_LENGTH (signature)));
1101 PUSH_FIELD_VALUE (finit, "type", type);
1103 flags = get_access_flags_from_decl (fdecl);
1105 flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1107 PUSH_FIELD_VALUE (finit, "accflags", build_int_2 (flags, 0));
1108 PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
1112 build (CONSTRUCTOR, field_info_union_node, NULL_TREE,
1114 ((FIELD_STATIC (fdecl)
1115 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
1116 : TYPE_FIELDS (field_info_union_node)),
1117 (FIELD_STATIC (fdecl)
1118 ? build_address_of (build_static_field_ref (fdecl))
1119 : byte_position (fdecl)))));
1121 FINISH_RECORD_CONSTRUCTOR (finit);
1126 make_method_value (mdecl)
1131 #define ACC_TRANSLATED 0x4000
1132 int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
1133 code = null_pointer_node;
1134 if (DECL_RTL_SET_P (mdecl))
1135 code = build1 (ADDR_EXPR, nativecode_ptr_type_node, mdecl);
1136 START_RECORD_CONSTRUCTOR (minit, method_type_node);
1137 PUSH_FIELD_VALUE (minit, "name",
1138 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
1139 init_identifier_node
1140 : DECL_NAME (mdecl)));
1142 tree signature = build_java_signature (TREE_TYPE (mdecl));
1143 PUSH_FIELD_VALUE (minit, "signature",
1146 (IDENTIFIER_POINTER(signature),
1147 IDENTIFIER_LENGTH(signature)))));
1149 PUSH_FIELD_VALUE (minit, "accflags", build_int_2 (accflags, 0));
1150 PUSH_FIELD_VALUE (minit, "ncode", code);
1151 FINISH_RECORD_CONSTRUCTOR (minit);
1156 get_dispatch_vector (type)
1159 tree vtable = TYPE_VTABLE (type);
1164 tree super = CLASSTYPE_SUPER (type);
1165 HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1166 vtable = make_tree_vec (nvirtuals);
1167 TYPE_VTABLE (type) = vtable;
1168 if (super != NULL_TREE)
1170 tree super_vtable = get_dispatch_vector (super);
1172 for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1173 TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1176 for (method = TYPE_METHODS (type); method != NULL_TREE;
1177 method = TREE_CHAIN (method))
1178 if (DECL_VINDEX (method) != NULL_TREE
1179 && host_integerp (DECL_VINDEX (method), 0))
1180 TREE_VEC_ELT (vtable, tree_low_cst (DECL_VINDEX (method), 0))
1188 get_dispatch_table (type, this_class_addr)
1189 tree type, this_class_addr;
1191 int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1192 tree vtable = get_dispatch_vector (type);
1194 tree list = NULL_TREE;
1195 int nvirtuals = TREE_VEC_LENGTH (vtable);
1196 for (i = nvirtuals; --i >= 0; )
1198 tree method = TREE_VEC_ELT (vtable, i);
1199 if (METHOD_ABSTRACT (method))
1202 warning_with_decl (method,
1203 "abstract method in non-abstract class");
1204 method = null_pointer_node;
1208 if (!DECL_RTL_SET_P (method))
1209 make_decl_rtl (method, NULL);
1210 method = build1 (ADDR_EXPR, nativecode_ptr_type_node, method);
1212 list = tree_cons (NULL_TREE /*DECL_VINDEX (method) + 2*/,
1215 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1216 using the Boehm GC we sometimes stash a GC type descriptor
1217 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1218 the emitted byte count during the output to the assembly file. */
1219 list = tree_cons (NULL_TREE, get_boehm_type_descriptor (type),
1221 list = tree_cons (integer_zero_node, this_class_addr, list);
1222 return build (CONSTRUCTOR, build_prim_array_type (nativecode_ptr_type_node,
1228 make_class_data (type)
1231 tree decl, cons, temp;
1232 tree field, fields_decl;
1233 tree static_fields = NULL_TREE;
1234 tree instance_fields = NULL_TREE;
1235 HOST_WIDE_INT static_field_count = 0;
1236 HOST_WIDE_INT instance_field_count = 0;
1237 HOST_WIDE_INT field_count;
1238 tree field_array_type;
1240 tree methods = NULL_TREE;
1241 tree dtable_decl = NULL_TREE;
1242 HOST_WIDE_INT method_count = 0;
1243 tree method_array_type;
1246 tree this_class_addr;
1247 tree constant_pool_constructor;
1248 tree interfaces = null_pointer_node;
1249 int interface_len = 0;
1250 tree type_decl = TYPE_NAME (type);
1252 this_class_addr = build_class_ref (type);
1253 decl = TREE_OPERAND (this_class_addr, 0);
1255 /* Build Field array. */
1256 field = TYPE_FIELDS (type);
1257 if (DECL_NAME (field) == NULL_TREE)
1258 field = TREE_CHAIN (field); /* Skip dummy field for inherited data. */
1259 for ( ; field != NULL_TREE; field = TREE_CHAIN (field))
1261 if (! DECL_ARTIFICIAL (field))
1263 tree init = make_field_value (field);
1264 if (FIELD_STATIC (field))
1266 tree initial = DECL_INITIAL (field);
1267 static_field_count++;
1268 static_fields = tree_cons (NULL_TREE, init, static_fields);
1269 /* If the initial value is a string constant,
1270 prevent output_constant from trying to assemble the value. */
1271 if (initial != NULL_TREE
1272 && TREE_TYPE (initial) == string_ptr_type_node)
1273 DECL_INITIAL (field) = NULL_TREE;
1274 rest_of_decl_compilation (field, (char*) 0, 1, 1);
1275 DECL_INITIAL (field) = initial;
1279 instance_field_count++;
1280 instance_fields = tree_cons (NULL_TREE, init, instance_fields);
1284 field_count = static_field_count + instance_field_count;
1285 if (field_count > 0)
1287 static_fields = nreverse (static_fields);
1288 instance_fields = nreverse (instance_fields);
1289 static_fields = chainon (static_fields, instance_fields);
1290 field_array_type = build_prim_array_type (field_type_node, field_count);
1291 fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
1293 DECL_INITIAL (fields_decl) = build (CONSTRUCTOR, field_array_type,
1294 NULL_TREE, static_fields);
1295 TREE_STATIC (fields_decl) = 1;
1296 DECL_ARTIFICIAL (fields_decl) = 1;
1297 DECL_IGNORED_P (fields_decl) = 1;
1298 rest_of_decl_compilation (fields_decl, (char*) 0, 1, 0);
1301 fields_decl = NULL_TREE;
1303 /* Build Method array. */
1304 for (method = TYPE_METHODS (CLASS_TO_HANDLE_TYPE (type));
1305 method != NULL_TREE; method = TREE_CHAIN (method))
1308 if (METHOD_PRIVATE (method)
1309 && ! flag_keep_inline_functions
1310 && (flag_inline_functions || optimize))
1312 init = make_method_value (method);
1314 methods = tree_cons (NULL_TREE, init, methods);
1316 method_array_type = build_prim_array_type (method_type_node, method_count);
1317 methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
1319 DECL_INITIAL (methods_decl) = build (CONSTRUCTOR, method_array_type,
1320 NULL_TREE, nreverse (methods));
1321 TREE_STATIC (methods_decl) = 1;
1322 DECL_ARTIFICIAL (methods_decl) = 1;
1323 DECL_IGNORED_P (methods_decl) = 1;
1324 rest_of_decl_compilation (methods_decl, (char*) 0, 1, 0);
1326 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
1327 && ! CLASS_INTERFACE (type_decl))
1329 tree dtable = get_dispatch_table (type, this_class_addr);
1330 dtable_decl = build_dtable_decl (type);
1331 DECL_INITIAL (dtable_decl) = dtable;
1332 TREE_STATIC (dtable_decl) = 1;
1333 DECL_ARTIFICIAL (dtable_decl) = 1;
1334 DECL_IGNORED_P (dtable_decl) = 1;
1335 TREE_PUBLIC (dtable_decl) = 1;
1336 rest_of_decl_compilation (dtable_decl, (char*) 0, 1, 0);
1337 if (type == class_type_node)
1338 class_dtable_decl = dtable_decl;
1341 if (class_dtable_decl == NULL_TREE)
1343 class_dtable_decl = build_dtable_decl (class_type_node);
1344 TREE_STATIC (class_dtable_decl) = 1;
1345 DECL_ARTIFICIAL (class_dtable_decl) = 1;
1346 DECL_IGNORED_P (class_dtable_decl) = 1;
1347 if (is_compiled_class (class_type_node) != 2)
1348 DECL_EXTERNAL (class_dtable_decl) = 1;
1349 rest_of_decl_compilation (class_dtable_decl, (char*) 0, 1, 0);
1352 super = CLASSTYPE_SUPER (type);
1353 if (super == NULL_TREE)
1354 super = null_pointer_node;
1355 else if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl))))
1356 super = build_class_ref (super);
1359 int super_index = alloc_class_constant (super);
1360 super = build_int_2 (super_index, 0);
1361 TREE_TYPE (super) = ptr_type_node;
1364 /* Build and emit the array of implemented interfaces. */
1365 if (type != object_type_node)
1366 interface_len = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)) - 1;
1367 if (interface_len > 0)
1369 tree init = NULL_TREE;
1371 tree interface_array_type, idecl;
1372 interface_array_type
1373 = build_prim_array_type (class_ptr_type, interface_len);
1374 idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type),
1375 interface_array_type);
1376 for (i = interface_len; i > 0; i--)
1378 tree child = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i);
1379 tree iclass = BINFO_TYPE (child);
1381 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass)))))
1382 index = build_class_ref (iclass);
1385 int int_index = alloc_class_constant (iclass);
1386 index = build_int_2 (int_index, 0);
1387 TREE_TYPE (index) = ptr_type_node;
1389 init = tree_cons (NULL_TREE, index, init);
1391 DECL_INITIAL (idecl) = build (CONSTRUCTOR, interface_array_type,
1393 TREE_STATIC (idecl) = 1;
1394 DECL_ARTIFICIAL (idecl) = 1;
1395 DECL_IGNORED_P (idecl) = 1;
1396 interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
1397 rest_of_decl_compilation (idecl, (char*) 0, 1, 0);
1400 constant_pool_constructor = build_constants_constructor ();
1402 START_RECORD_CONSTRUCTOR (temp, object_type_node);
1403 PUSH_FIELD_VALUE (temp, "vtable",
1404 build1 (ADDR_EXPR, dtable_ptr_type, class_dtable_decl));
1405 if (! flag_hash_synchronization)
1406 PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
1407 FINISH_RECORD_CONSTRUCTOR (temp);
1408 START_RECORD_CONSTRUCTOR (cons, class_type_node);
1409 PUSH_SUPER_VALUE (cons, temp);
1410 PUSH_FIELD_VALUE (cons, "next", null_pointer_node);
1411 PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
1412 PUSH_FIELD_VALUE (cons, "accflags",
1413 build_int_2 (get_access_flags_from_decl (type_decl), 0));
1415 PUSH_FIELD_VALUE (cons, "superclass",
1416 CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
1417 PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
1418 PUSH_FIELD_VALUE (cons, "methods",
1419 build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
1420 PUSH_FIELD_VALUE (cons, "method_count", build_int_2 (method_count, 0));
1421 PUSH_FIELD_VALUE (cons, "vtable_method_count", TYPE_NVIRTUALS (type));
1422 PUSH_FIELD_VALUE (cons, "fields",
1423 fields_decl == NULL_TREE ? null_pointer_node
1424 : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
1425 PUSH_FIELD_VALUE (cons, "size_in_bytes", size_in_bytes (type));
1426 PUSH_FIELD_VALUE (cons, "field_count", build_int_2 (field_count, 0));
1427 PUSH_FIELD_VALUE (cons, "static_field_count",
1428 build_int_2 (static_field_count, 0));
1429 PUSH_FIELD_VALUE (cons, "vtable",
1430 dtable_decl == NULL_TREE ? null_pointer_node
1431 : build1 (ADDR_EXPR, dtable_ptr_type, dtable_decl));
1432 PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
1433 PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
1434 PUSH_FIELD_VALUE (cons, "interface_count", build_int_2 (interface_len, 0));
1435 PUSH_FIELD_VALUE (cons, "state", integer_zero_node);
1437 PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
1438 PUSH_FIELD_VALUE (cons, "depth", integer_zero_node);
1439 PUSH_FIELD_VALUE (cons, "ancestors", null_pointer_node);
1440 PUSH_FIELD_VALUE (cons, "idt", null_pointer_node);
1441 PUSH_FIELD_VALUE (cons, "arrayclass", null_pointer_node);
1442 PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
1444 FINISH_RECORD_CONSTRUCTOR (cons);
1446 DECL_INITIAL (decl) = cons;
1447 rest_of_decl_compilation (decl, (char*) 0, 1, 0);
1454 tree type_methods = TYPE_METHODS (CLASS_TO_HANDLE_TYPE (current_class));
1455 int saw_native_method = 0;
1457 /* Find out if we have any native methods. We use this information
1459 for (method = type_methods;
1460 method != NULL_TREE;
1461 method = TREE_CHAIN (method))
1463 if (METHOD_NATIVE (method))
1465 saw_native_method = 1;
1470 /* Emit deferred inline methods. */
1471 for (method = type_methods; method != NULL_TREE; )
1473 if (! TREE_ASM_WRITTEN (method) && DECL_SAVED_INSNS (method) != 0)
1475 /* It's a deferred inline method. Decide if we need to emit it. */
1476 if (flag_keep_inline_functions
1477 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (method))
1478 || ! METHOD_PRIVATE (method)
1479 || saw_native_method)
1481 output_inline_function (method);
1482 /* Scan the list again to see if there are any earlier
1484 method = type_methods;
1488 method = TREE_CHAIN (method);
1491 current_function_decl = NULL_TREE;
1492 make_class_data (current_class);
1494 rest_of_decl_compilation (TYPE_NAME (current_class), (char*) 0, 1, 0);
1497 /* Return 2 if CLASS is compiled by this compilation job;
1498 return 1 if CLASS can otherwise be assumed to be compiled;
1499 return 0 if we cannot assume that CLASS is compiled.
1500 Returns 1 for primitive and 0 for array types. */
1502 is_compiled_class (class)
1506 if (TREE_CODE (class) == POINTER_TYPE)
1507 class = TREE_TYPE (class);
1508 if (TREE_CODE (class) != RECORD_TYPE) /* Primitive types are static. */
1510 if (TYPE_ARRAY_P (class))
1512 if (class == current_class)
1515 seen_in_zip = (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1516 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip)
1518 /* The class was seen in the current ZIP file and will be
1519 available as a compiled class in the future but may not have
1520 been loaded already. Load it if necessary. This prevent
1521 build_class_ref () from crashing. */
1523 if (seen_in_zip && !CLASS_LOADED_P (class))
1524 load_class (class, 1);
1526 /* We return 2 for class seen in ZIP and class from files
1527 belonging to the same compilation unit */
1531 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1533 if (!CLASS_LOADED_P (class))
1535 if (CLASS_FROM_SOURCE_P (class))
1536 safe_layout_class (class);
1538 load_class (class, 1);
1546 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1549 build_dtable_decl (type)
1554 /* We need to build a new dtable type so that its size is uniquely
1555 computed when we're dealing with the class for real and not just
1556 faking it (like java.lang.Class during the initialization of the
1557 compiler.) We now we're not faking a class when CURRENT_CLASS is
1559 if (current_class == type)
1561 tree dummy = NULL_TREE, aomt, n;
1563 dtype = make_node (RECORD_TYPE);
1564 PUSH_FIELD (dtype, dummy, "class", class_ptr_type);
1565 n = build_int_2 (TREE_VEC_LENGTH (get_dispatch_vector (type)), 0);
1566 aomt = build_array_type (ptr_type_node, build_index_type (n));
1567 PUSH_FIELD (dtype, dummy, "methods", aomt);
1568 layout_type (dtype);
1571 dtype = dtable_type;
1573 return build_decl (VAR_DECL,
1574 java_mangle_vtable (&temporary_obstack, type), dtype);
1577 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
1578 fields inherited from SUPER_CLASS. */
1581 push_super_field (this_class, super_class)
1582 tree this_class, super_class;
1585 /* Don't insert the field if we're just re-laying the class out. */
1586 if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
1588 base_decl = build_decl (FIELD_DECL, NULL_TREE, super_class);
1589 DECL_IGNORED_P (base_decl) = 1;
1590 TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
1591 TYPE_FIELDS (this_class) = base_decl;
1592 DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
1593 DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
1596 /* Handle the different manners we may have to lay out a super class. */
1599 maybe_layout_super_class (super_class, this_class)
1603 if (TREE_CODE (super_class) == RECORD_TYPE)
1605 if (!CLASS_LOADED_P (super_class) && CLASS_FROM_SOURCE_P (super_class))
1606 safe_layout_class (super_class);
1607 if (!CLASS_LOADED_P (super_class))
1608 load_class (super_class, 1);
1610 /* We might have to layout the class before its dependency on
1611 the super class gets resolved by java_complete_class */
1612 else if (TREE_CODE (super_class) == POINTER_TYPE)
1614 if (TREE_TYPE (super_class) != NULL_TREE)
1615 super_class = TREE_TYPE (super_class);
1618 super_class = do_resolve_class (NULL_TREE, /* FIXME? */
1619 super_class, NULL_TREE, this_class);
1621 return NULL_TREE; /* FIXME, NULL_TREE not checked by caller. */
1622 super_class = TREE_TYPE (super_class);
1625 if (!TYPE_SIZE (super_class))
1626 safe_layout_class (super_class);
1632 layout_class (this_class)
1635 tree super_class = CLASSTYPE_SUPER (this_class);
1638 class_list = tree_cons (this_class, NULL_TREE, class_list);
1639 if (CLASS_BEING_LAIDOUT (this_class))
1645 sprintf (buffer, " with `%s'",
1646 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
1647 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
1649 for (current = TREE_CHAIN (class_list); current;
1650 current = TREE_CHAIN (current))
1652 tree decl = TYPE_NAME (TREE_PURPOSE (current));
1653 sprintf (buffer, "\n which inherits from `%s' (%s:%d)",
1654 IDENTIFIER_POINTER (DECL_NAME (decl)),
1655 DECL_SOURCE_FILE (decl),
1656 DECL_SOURCE_LINE (decl));
1657 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
1659 obstack_1grow (&temporary_obstack, '\0');
1660 report = obstack_finish (&temporary_obstack);
1661 cyclic_inheritance_report = ggc_strdup (report);
1662 obstack_free (&temporary_obstack, report);
1663 TYPE_SIZE (this_class) = error_mark_node;
1666 CLASS_BEING_LAIDOUT (this_class) = 1;
1668 if (super_class && !CLASS_BEING_LAIDOUT (super_class))
1670 tree maybe_super_class
1671 = maybe_layout_super_class (super_class, this_class);
1672 if (maybe_super_class == NULL
1673 || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
1675 TYPE_SIZE (this_class) = error_mark_node;
1676 CLASS_BEING_LAIDOUT (this_class) = 0;
1677 class_list = TREE_CHAIN (class_list);
1680 if (TYPE_SIZE (this_class) == NULL_TREE)
1681 push_super_field (this_class, maybe_super_class);
1684 for (field = TYPE_FIELDS (this_class);
1685 field != NULL_TREE; field = TREE_CHAIN (field))
1687 if (FIELD_STATIC (field))
1689 /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
1690 SET_DECL_ASSEMBLER_NAME (field,
1692 (&temporary_obstack, field));
1696 layout_type (this_class);
1698 /* Also recursively load/layout any superinterfaces, but only if class was
1699 loaded from bytecode. The source parser will take care of this itself. */
1700 if (!CLASS_FROM_SOURCE_P (this_class))
1702 tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
1706 int n = TREE_VEC_LENGTH (basetype_vec) - 1;
1708 for (i = n; i > 0; i--)
1710 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
1711 tree super_interface = BINFO_TYPE (vec_elt);
1713 tree maybe_super_interface
1714 = maybe_layout_super_class (super_interface, NULL_TREE);
1715 if (maybe_super_interface == NULL
1716 || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
1718 TYPE_SIZE (this_class) = error_mark_node;
1719 CLASS_BEING_LAIDOUT (this_class) = 0;
1720 class_list = TREE_CHAIN (class_list);
1727 /* Convert the size back to an SI integer value */
1728 TYPE_SIZE_UNIT (this_class) =
1729 fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
1731 CLASS_BEING_LAIDOUT (this_class) = 0;
1732 class_list = TREE_CHAIN (class_list);
1736 layout_class_methods (this_class)
1739 tree method_decl, dtable_count;
1740 tree super_class, handle_type;
1742 if (TYPE_NVIRTUALS (this_class))
1745 super_class = CLASSTYPE_SUPER (this_class);
1746 handle_type = CLASS_TO_HANDLE_TYPE (this_class);
1750 super_class = maybe_layout_super_class (super_class, this_class);
1751 if (!TYPE_NVIRTUALS (super_class))
1752 layout_class_methods (super_class);
1753 dtable_count = TYPE_NVIRTUALS (super_class);
1756 dtable_count = integer_zero_node;
1758 TYPE_METHODS (handle_type) = nreverse (TYPE_METHODS (handle_type));
1760 for (method_decl = TYPE_METHODS (handle_type);
1761 method_decl; method_decl = TREE_CHAIN (method_decl))
1762 dtable_count = layout_class_method (this_class, super_class,
1763 method_decl, dtable_count);
1765 TYPE_NVIRTUALS (this_class) = dtable_count;
1767 #ifdef JAVA_USE_HANDLES
1768 layout_type (handle_type);
1772 /* Return 0 if NAME is equal to STR, -1 if STR is "less" than NAME,
1773 and 1 if STR is "greater" than NAME. */
1775 /* Lay METHOD_DECL out, returning a possibly new value of
1776 DTABLE_COUNT. Also mangle the method's name. */
1779 layout_class_method (this_class, super_class, method_decl, dtable_count)
1780 tree this_class, super_class, method_decl, dtable_count;
1782 tree method_name = DECL_NAME (method_decl);
1784 TREE_PUBLIC (method_decl) = 1;
1786 /* This is a good occasion to mangle the method's name */
1787 SET_DECL_ASSEMBLER_NAME (method_decl,
1788 java_mangle_decl (&temporary_obstack,
1790 /* We don't generate a RTL for the method if it's abstract, or if
1791 it's an interface method that isn't clinit. */
1792 if (! METHOD_ABSTRACT (method_decl)
1793 || (CLASS_INTERFACE (TYPE_NAME (this_class))
1794 && (DECL_CLINIT_P (method_decl))))
1795 make_decl_rtl (method_decl, NULL);
1797 if (ID_INIT_P (method_name))
1799 const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
1801 for (ptr = p; *ptr; )
1806 DECL_CONSTRUCTOR_P (method_decl) = 1;
1807 build_java_argument_signature (TREE_TYPE (method_decl));
1809 else if (! METHOD_STATIC (method_decl) && !DECL_ARTIFICIAL (method_decl))
1812 build_java_argument_signature (TREE_TYPE (method_decl));
1813 tree super_method = lookup_argument_method (super_class, method_name,
1815 if (super_method != NULL_TREE && ! METHOD_PRIVATE (super_method))
1817 DECL_VINDEX (method_decl) = DECL_VINDEX (super_method);
1818 if (DECL_VINDEX (method_decl) == NULL_TREE
1819 && !CLASS_FROM_SOURCE_P (this_class))
1820 error_with_decl (method_decl,
1821 "non-static method '%s' overrides static method");
1823 else if (! METHOD_FINAL (method_decl)
1824 && ! METHOD_PRIVATE (method_decl)
1825 && ! CLASS_FINAL (TYPE_NAME (this_class))
1828 DECL_VINDEX (method_decl) = dtable_count;
1829 dtable_count = fold (build (PLUS_EXPR, integer_type_node,
1830 dtable_count, integer_one_node));
1834 return dtable_count;
1840 /* END does not need to be registered with the garbage collector
1841 because it always points into the list given by REGISTERED_CLASS,
1842 and that variable is registered with the collector. */
1844 tree node = TREE_OPERAND (build_class_ref (current_class), 0);
1845 tree current = copy_node (node);
1847 XEXP (DECL_RTL (current), 0) = copy_rtx (XEXP (DECL_RTL(node), 0));
1848 if (!registered_class)
1849 registered_class = current;
1851 TREE_CHAIN (end) = current;
1856 /* Generate a function that gets called at start-up (static contructor) time,
1857 which calls registerClass for all the compiled classes. */
1860 emit_register_classes ()
1862 extern tree get_file_function_name PARAMS ((int));
1863 tree init_name = get_file_function_name ('I');
1864 tree init_type = build_function_type (void_type_node, end_params_node);
1868 init_decl = build_decl (FUNCTION_DECL, init_name, init_type);
1869 SET_DECL_ASSEMBLER_NAME (init_decl, init_name);
1870 TREE_STATIC (init_decl) = 1;
1871 current_function_decl = init_decl;
1872 DECL_RESULT (init_decl) = build_decl(RESULT_DECL, NULL_TREE, void_type_node);
1873 /* DECL_EXTERNAL (init_decl) = 1;*/
1874 TREE_PUBLIC (init_decl) = 1;
1876 make_decl_rtl (init_decl, NULL);
1877 init_function_start (init_decl, input_filename, 0);
1878 expand_function_start (init_decl, 0);
1880 for ( t = registered_class; t; t = TREE_CHAIN (t))
1881 emit_library_call (registerClass_libfunc, 0, VOIDmode, 1,
1882 XEXP (DECL_RTL (t), 0), Pmode);
1884 expand_function_end (input_filename, 0, 0);
1887 /* Force generation, even with -O3 or deeper. Gross hack. FIXME */
1888 int saved_flag = flag_inline_functions;
1889 flag_inline_functions = 0;
1890 rest_of_compilation (init_decl);
1891 flag_inline_functions = saved_flag;
1893 current_function_decl = NULL_TREE;
1894 assemble_constructor (IDENTIFIER_POINTER (init_name));
1898 init_class_processing ()
1900 registerClass_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_Jv_RegisterClass");
1901 ggc_add_tree_root (class_roots, sizeof (class_roots) / sizeof (tree));
1902 fields_ident = get_identifier ("fields");
1903 info_ident = get_identifier ("info");
1904 ggc_add_rtx_root (®isterClass_libfunc, 1);
1905 gcc_obstack_init (&temporary_obstack);