1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc. */
26 /* Written by Per Bothner <bothner@cygnus.com> */
30 #include "coretypes.h"
35 #include "java-tree.h"
46 /* DOS brain-damage */
48 #define O_BINARY 0 /* MS-DOS brain-damage */
51 static tree make_method_value (tree);
52 static tree build_java_method_type (tree, tree, int);
53 static int32 hashUtf8String (const char *, int);
54 static tree make_field_value (tree);
55 static tree get_dispatch_vector (tree);
56 static tree get_dispatch_table (tree, tree);
57 static int supers_all_compiled (tree type);
58 static void add_interface_do (tree, tree, int);
59 static tree maybe_layout_super_class (tree, tree);
60 static int assume_compiled (const char *);
61 static tree build_method_symbols_entry (tree);
63 static GTY(()) rtx registerClass_libfunc;
65 struct obstack temporary_obstack;
67 /* The compiler generates different code depending on whether or not
68 it can assume certain classes have been compiled down to native
69 code or not. The compiler options -fassume-compiled= and
70 -fno-assume-compiled= are used to create a tree of
71 assume_compiled_node objects. This tree is queried to determine if
72 a class is assume to be compiled or not. Each node in the tree
73 represents either a package or a specific class. */
75 typedef struct assume_compiled_node_struct
77 /* The class or package name. */
80 /* Nonzero if this represents an exclusion. */
83 /* Pointers to other nodes in the tree. */
84 struct assume_compiled_node_struct *parent;
85 struct assume_compiled_node_struct *sibling;
86 struct assume_compiled_node_struct *child;
87 } assume_compiled_node;
89 static assume_compiled_node *find_assume_compiled_node (assume_compiled_node *,
92 /* This is the root of the include/exclude tree. */
94 static assume_compiled_node *assume_compiled_tree;
96 static GTY(()) tree class_roots[5];
97 #define registered_class class_roots[0]
98 #define fields_ident class_roots[1] /* get_identifier ("fields") */
99 #define info_ident class_roots[2] /* get_identifier ("info") */
100 #define class_list class_roots[3]
101 #define class_dtable_decl class_roots[4]
103 /* Return the node that most closely represents the class whose name
104 is IDENT. Start the search from NODE. Return NULL if an
105 appropriate node does not exist. */
107 static assume_compiled_node *
108 find_assume_compiled_node (assume_compiled_node *node, const char *ident)
112 size_t node_ident_length = strlen (node->ident);
114 /* node_ident_length is zero at the root of the tree. If the
115 identifiers are the same length, then we have matching
116 classes. Otherwise check if we've matched an enclosing
119 if (node_ident_length == 0
120 || (strncmp (ident, node->ident, node_ident_length) == 0
121 && (strlen (ident) == node_ident_length
122 || ident[node_ident_length] == '.')))
124 /* We've found a match, however, there might be a more
127 assume_compiled_node *found = find_assume_compiled_node (node->child,
135 /* No match yet. Continue through the sibling list. */
136 node = node->sibling;
139 /* No match at all in this tree. */
143 /* Add a new IDENT to the include/exclude tree. It's an exclusion
144 if EXCLUDEP is nonzero. */
147 add_assume_compiled (const char *ident, int excludep)
150 assume_compiled_node *parent;
151 assume_compiled_node *node =
152 xmalloc (sizeof (assume_compiled_node));
154 node->ident = xstrdup (ident);
155 node->excludep = excludep;
158 /* Create the root of the tree if it doesn't exist yet. */
160 if (NULL == assume_compiled_tree)
162 assume_compiled_tree = xmalloc (sizeof (assume_compiled_node));
163 assume_compiled_tree->ident = "";
164 assume_compiled_tree->excludep = 0;
165 assume_compiled_tree->sibling = NULL;
166 assume_compiled_tree->child = NULL;
167 assume_compiled_tree->parent = NULL;
170 /* Calling the function with the empty string means we're setting
171 excludep for the root of the hierarchy. */
175 assume_compiled_tree->excludep = excludep;
179 /* Find the parent node for this new node. PARENT will either be a
180 class or a package name. Adjust PARENT accordingly. */
182 parent = find_assume_compiled_node (assume_compiled_tree, ident);
183 len = strlen (parent->ident);
184 if (parent->ident[len] && parent->ident[len] != '.')
185 parent = parent->parent;
187 /* Insert NODE into the tree. */
189 node->parent = parent;
190 node->sibling = parent->child;
191 parent->child = node;
194 /* Returns nonzero if IDENT is the name of a class that the compiler
195 should assume has been compiled to object code. */
198 assume_compiled (const char *ident)
200 assume_compiled_node *i;
203 if (NULL == assume_compiled_tree)
206 i = find_assume_compiled_node (assume_compiled_tree,
209 result = ! i->excludep;
214 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
215 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
216 Also, PREFIX is prepended, and SUFFIX is appended. */
219 ident_subst (const char* old_name,
226 int prefix_len = strlen (prefix);
227 int suffix_len = strlen (suffix);
228 int i = prefix_len + old_length + suffix_len + 1;
232 char *buffer = alloca (i);
234 strcpy (buffer, prefix);
235 for (i = 0; i < old_length; i++)
237 char ch = old_name[i];
240 buffer[prefix_len + i] = ch;
242 strcpy (buffer + prefix_len + old_length, suffix);
243 return get_identifier (buffer);
246 /* Return an IDENTIFIER_NODE the same as OLD_ID,
247 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
248 Also, PREFIX is prepended, and SUFFIX is appended. */
251 identifier_subst (const tree old_id,
257 return ident_subst (IDENTIFIER_POINTER (old_id), IDENTIFIER_LENGTH (old_id),
258 prefix, old_char, new_char, suffix);
261 /* Generate a valid C identifier from the name of the class TYPE,
262 prefixed by PREFIX. */
265 mangled_classname (const char *prefix, tree type)
267 tree ident = TYPE_NAME (type);
268 if (TREE_CODE (ident) != IDENTIFIER_NODE)
269 ident = DECL_NAME (ident);
270 return identifier_subst (ident, prefix, '.', '_', "");
277 type = make_node (RECORD_TYPE);
278 TYPE_BINFO (type) = make_tree_vec (BINFO_ELTS);
279 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
284 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
285 and where each of the constituents is separated by '/',
286 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
289 unmangle_classname (const char *name, int name_length)
291 tree to_return = ident_subst (name, name_length, "", '/', '.', "");
292 /* It's not sufficient to compare to_return and get_identifier
293 (name) to determine whether to_return is qualified. There are
294 cases in signature analysis where name will be stripped of a
296 name = IDENTIFIER_POINTER (to_return);
300 QUALIFIED_P (to_return) = 1;
308 push_class (tree class_type, tree class_name)
310 tree decl, signature;
311 const char *save_input_filename = input_filename;
312 int save_lineno = lineno;
313 tree source_name = identifier_subst (class_name, "", '.', '/', ".java");
314 CLASS_P (class_type) = 1;
315 input_filename = IDENTIFIER_POINTER (source_name);
317 decl = build_decl (TYPE_DECL, class_name, class_type);
319 /* dbxout needs a DECL_SIZE if in gstabs mode */
320 DECL_SIZE (decl) = integer_zero_node;
322 input_filename = save_input_filename;
323 lineno = save_lineno;
324 signature = identifier_subst (class_name, "L", '.', '/', ";");
325 IDENTIFIER_SIGNATURE_TYPE (signature) = build_pointer_type (class_type);
327 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
328 both a typedef and in the struct name-space. We may want to re-visit
329 this later, but for now it reduces the changes needed for gdb. */
330 DECL_ARTIFICIAL (decl) = 1;
332 pushdecl_top_level (decl);
337 /* Finds the (global) class named NAME. Creates the class if not found.
338 Also creates associated TYPE_DECL.
339 Does not check if the class actually exists, load the class,
340 fill in field or methods, or do layout_type. */
343 lookup_class (tree name)
345 tree decl = IDENTIFIER_CLASS_VALUE (name);
346 if (decl == NULL_TREE)
347 decl = push_class (make_class (), name);
348 return TREE_TYPE (decl);
352 set_super_info (int access_flags, tree this_class,
353 tree super_class, int interfaces_count)
355 int total_supers = interfaces_count;
356 tree class_decl = TYPE_NAME (this_class);
360 TYPE_BINFO_BASETYPES (this_class) = make_tree_vec (total_supers);
363 tree super_binfo = make_tree_vec (BINFO_ELTS);
364 BINFO_TYPE (super_binfo) = super_class;
365 BINFO_OFFSET (super_binfo) = integer_zero_node;
366 TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (this_class)), 0)
368 CLASS_HAS_SUPER (this_class) = 1;
371 set_class_decl_access_flags (access_flags, class_decl);
375 set_class_decl_access_flags (int access_flags, tree class_decl)
377 if (access_flags & ACC_PUBLIC) CLASS_PUBLIC (class_decl) = 1;
378 if (access_flags & ACC_FINAL) CLASS_FINAL (class_decl) = 1;
379 if (access_flags & ACC_SUPER) CLASS_SUPER (class_decl) = 1;
380 if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
381 if (access_flags & ACC_ABSTRACT) CLASS_ABSTRACT (class_decl) = 1;
382 if (access_flags & ACC_STATIC) CLASS_STATIC (class_decl) = 1;
383 if (access_flags & ACC_PRIVATE) CLASS_PRIVATE (class_decl) = 1;
384 if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
385 if (access_flags & ACC_STRICT) CLASS_STRICTFP (class_decl) = 1;
388 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
389 direct sub-classes of Object are 1, and so on. */
392 class_depth (tree clas)
395 if (! CLASS_LOADED_P (clas))
396 load_class (clas, 1);
397 if (TYPE_SIZE (clas) == error_mark_node)
399 while (clas != object_type_node)
402 clas = TYPE_BINFO_BASETYPE (clas, 0);
407 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
410 interface_of_p (tree type1, tree type2)
415 if (!(basetype_vec = TYPE_BINFO_BASETYPES (type2)))
417 n = TREE_VEC_LENGTH (basetype_vec);
418 for (i = 0; i < n; i++)
420 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
421 if (vec_elt && BINFO_TYPE (vec_elt) == type1)
424 for (i = 0; i < n; i++)
426 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
427 if (vec_elt && BINFO_TYPE (vec_elt)
428 && interface_of_p (type1, BINFO_TYPE (vec_elt)))
434 /* Return true iff TYPE1 inherits from TYPE2. */
437 inherits_from_p (tree type1, tree type2)
439 while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
443 type1 = CLASSTYPE_SUPER (type1);
448 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
451 enclosing_context_p (tree type1, tree type2)
453 if (!INNER_CLASS_TYPE_P (type2))
456 for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
458 type2 = (INNER_CLASS_TYPE_P (type2) ?
459 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
468 /* Return 1 iff there exists a common enclosing context between TYPE1
471 int common_enclosing_context_p (tree type1, tree type2)
473 if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
476 for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1;
477 type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
478 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
481 for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
482 current = (PURE_INNER_CLASS_TYPE_P (current) ?
483 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
485 if (type1 == current)
492 add_interface_do (tree basetype_vec, tree interface_class, int i)
494 tree interface_binfo = make_tree_vec (BINFO_ELTS);
495 BINFO_TYPE (interface_binfo) = interface_class;
496 BINFO_OFFSET (interface_binfo) = integer_zero_node;
497 BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node;
498 TREE_VIA_VIRTUAL (interface_binfo) = 1;
499 TREE_VEC_ELT (basetype_vec, i) = interface_binfo;
502 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
503 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
504 if attempt is made to add it twice. */
507 maybe_add_interface (tree this_class, tree interface_class)
509 tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
511 int n = TREE_VEC_LENGTH (basetype_vec);
516 error ("internal error - too many interface type");
519 else if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
521 else if (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)) == interface_class)
522 return interface_class;
524 add_interface_do (basetype_vec, interface_class, i);
528 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
531 add_interface (tree this_class, tree interface_class)
533 tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
535 int n = TREE_VEC_LENGTH (basetype_vec);
540 error ("internal error - too many interface type");
543 else if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
546 add_interface_do (basetype_vec, interface_class, i);
550 /* Return the address of a pointer to the first FUNCTION_DECL
551 in the list (*LIST) whose DECL_NAME is NAME. */
554 find_named_method (tree *list, tree name)
556 while (*list && DECL_NAME (*list) != name)
557 list = &TREE_CHAIN (*list);
563 build_java_method_type (tree fntype, tree this_class, int access_flags)
565 if (access_flags & ACC_STATIC)
567 return build_method_type (this_class, fntype);
571 add_method_1 (tree this_class, int access_flags, tree name, tree function_type)
573 tree method_type, fndecl;
575 method_type = build_java_method_type (function_type,
576 this_class, access_flags);
578 fndecl = build_decl (FUNCTION_DECL, name, method_type);
579 DECL_CONTEXT (fndecl) = this_class;
581 DECL_LANG_SPECIFIC (fndecl)
582 = ggc_alloc_cleared (sizeof (struct lang_decl));
583 DECL_LANG_SPECIFIC (fndecl)->desc = LANG_DECL_FUNC;
585 /* Initialize the static initializer test table. */
587 DECL_FUNCTION_INIT_TEST_TABLE (fndecl) =
588 java_treetreehash_create (10, 1);
590 /* Initialize the initialized (static) class table. */
591 if (access_flags & ACC_STATIC)
592 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) =
593 htab_create_ggc (50, htab_hash_pointer, htab_eq_pointer, NULL);
595 /* Initialize the static method invocation compound list */
596 DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = NULL_TREE;
598 TREE_CHAIN (fndecl) = TYPE_METHODS (this_class);
599 TYPE_METHODS (this_class) = fndecl;
601 /* Notice that this is a finalizer and update the class type
602 accordingly. This is used to optimize instance allocation. */
603 if (name == finalize_identifier_node
604 && TREE_TYPE (function_type) == void_type_node
605 && TREE_VALUE (TYPE_ARG_TYPES (function_type)) == void_type_node)
606 HAS_FINALIZER_P (this_class) = 1;
608 if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
609 if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
610 if (access_flags & ACC_PRIVATE)
611 METHOD_PRIVATE (fndecl) = DECL_INLINE (fndecl) = 1;
612 if (access_flags & ACC_NATIVE)
614 METHOD_NATIVE (fndecl) = 1;
615 DECL_EXTERNAL (fndecl) = 1;
617 if (access_flags & ACC_STATIC)
618 METHOD_STATIC (fndecl) = DECL_INLINE (fndecl) = 1;
619 if (access_flags & ACC_FINAL)
620 METHOD_FINAL (fndecl) = DECL_INLINE (fndecl) = 1;
621 if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
622 if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
623 if (access_flags & ACC_TRANSIENT) METHOD_TRANSIENT (fndecl) = 1;
624 if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
628 /* Add a method to THIS_CLASS.
629 The method's name is NAME.
630 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
633 add_method (tree this_class, int access_flags, tree name, tree method_sig)
635 tree function_type, fndecl;
636 const unsigned char *sig
637 = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
640 fatal_error ("bad method signature");
642 function_type = get_type_from_signature (method_sig);
643 fndecl = add_method_1 (this_class, access_flags, name, function_type);
644 set_java_signature (TREE_TYPE (fndecl), method_sig);
649 add_field (tree class, tree name, tree field_type, int flags)
651 int is_static = (flags & ACC_STATIC) != 0;
653 field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type);
654 TREE_CHAIN (field) = TYPE_FIELDS (class);
655 TYPE_FIELDS (class) = field;
656 DECL_CONTEXT (field) = class;
658 if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
659 if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
660 if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
661 if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
662 if (flags & ACC_VOLATILE) FIELD_VOLATILE (field) = 1;
663 if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
666 FIELD_STATIC (field) = 1;
667 /* Always make field externally visible. This is required so
668 that native methods can always access the field. */
669 TREE_PUBLIC (field) = 1;
670 /* Considered external until we know what classes are being
671 compiled into this object file. */
672 DECL_EXTERNAL (field) = 1;
678 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
681 set_constant_value (tree field, tree constant)
683 if (field == NULL_TREE)
684 warning ("misplaced ConstantValue attribute (not in any field)");
685 else if (DECL_INITIAL (field) != NULL_TREE)
686 warning ("duplicate ConstantValue attribute for field '%s'",
687 IDENTIFIER_POINTER (DECL_NAME (field)));
690 DECL_INITIAL (field) = constant;
691 if (TREE_TYPE (constant) != TREE_TYPE (field)
692 && ! (TREE_TYPE (constant) == int_type_node
693 && INTEGRAL_TYPE_P (TREE_TYPE (field))
694 && TYPE_PRECISION (TREE_TYPE (field)) <= 32)
695 && ! (TREE_TYPE (constant) == utf8const_ptr_type
696 && TREE_TYPE (field) == string_ptr_type_node))
697 error ("ConstantValue attribute of field '%s' has wrong type",
698 IDENTIFIER_POINTER (DECL_NAME (field)));
699 if (FIELD_FINAL (field))
700 DECL_FIELD_FINAL_IUD (field) = 1;
704 /* Count the number of Unicode chars encoded in a given Ut8 string. */
708 strLengthUtf8 (char *str, int len)
710 register unsigned char* ptr = (unsigned char*) str;
711 register unsigned char *limit = ptr + len;
713 for (; ptr < limit; str_length++) {
714 if (UTF8_GET (ptr, limit) < 0)
722 /* Calculate a hash value for a string encoded in Utf8 format.
723 * This returns the same hash value as specified for java.lang.String.hashCode.
727 hashUtf8String (const char *str, int len)
729 register const unsigned char* ptr = (const unsigned char*) str;
730 register const unsigned char *limit = ptr + len;
734 int ch = UTF8_GET (ptr, limit);
735 /* Updated specification from
736 http://www.javasoft.com/docs/books/jls/clarify.html. */
737 hash = (31 * hash) + ch;
742 static GTY(()) tree utf8_decl_list = NULL_TREE;
745 build_utf8_ref (tree name)
747 const char * name_ptr = IDENTIFIER_POINTER(name);
748 int name_len = IDENTIFIER_LENGTH(name);
750 tree ctype, field = NULL_TREE, str_type, cinit, string;
751 static int utf8_count = 0;
753 tree ref = IDENTIFIER_UTF8_REF (name);
755 if (ref != NULL_TREE)
758 ctype = make_node (RECORD_TYPE);
759 str_type = build_prim_array_type (unsigned_byte_type_node,
760 name_len + 1); /* Allow for final '\0'. */
761 PUSH_FIELD (ctype, field, "hash", unsigned_short_type_node);
762 PUSH_FIELD (ctype, field, "length", unsigned_short_type_node);
763 PUSH_FIELD (ctype, field, "data", str_type);
764 FINISH_RECORD (ctype);
765 START_RECORD_CONSTRUCTOR (cinit, ctype);
766 name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
767 PUSH_FIELD_VALUE (cinit, "hash", build_int_2 (name_hash, 0));
768 PUSH_FIELD_VALUE (cinit, "length", build_int_2 (name_len, 0));
769 string = build_string (name_len, name_ptr);
770 TREE_TYPE (string) = str_type;
771 PUSH_FIELD_VALUE (cinit, "data", string);
772 FINISH_RECORD_CONSTRUCTOR (cinit);
773 TREE_CONSTANT (cinit) = 1;
775 /* Generate a unique-enough identifier. */
776 sprintf(buf, "_Utf%d", ++utf8_count);
778 decl = build_decl (VAR_DECL, get_identifier (buf), utf8const_type);
779 TREE_STATIC (decl) = 1;
780 DECL_ARTIFICIAL (decl) = 1;
781 DECL_IGNORED_P (decl) = 1;
782 TREE_READONLY (decl) = 1;
783 TREE_THIS_VOLATILE (decl) = 0;
784 DECL_INITIAL (decl) = cinit;
785 #ifdef HAVE_GAS_SHF_MERGE
788 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
789 decl_size = (name_len + 5 + TYPE_ALIGN_UNIT (utf8const_type) - 1)
790 & ~(TYPE_ALIGN_UNIT (utf8const_type) - 1);
791 if (flag_merge_constants && decl_size < 256)
794 int flags = (SECTION_OVERRIDE
795 | SECTION_MERGE | (SECTION_ENTSIZE & decl_size));
796 sprintf (buf, ".rodata.jutf8.%d", decl_size);
797 named_section_flags (buf, flags);
798 DECL_SECTION_NAME (decl) = build_string (strlen (buf), buf);
802 TREE_CHAIN (decl) = utf8_decl_list;
803 layout_decl (decl, 0);
805 rest_of_decl_compilation (decl, (char*) 0, global_bindings_p (), 0);
806 utf8_decl_list = decl;
807 make_decl_rtl (decl, (char*) 0);
808 ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
809 IDENTIFIER_UTF8_REF (name) = ref;
813 /* Build a reference to the class TYPE.
814 Also handles primitive types and array types. */
817 build_class_ref (tree type)
819 int is_compiled = is_compiled_class (type);
822 tree ref, decl_name, decl;
823 if (TREE_CODE (type) == POINTER_TYPE)
824 type = TREE_TYPE (type);
825 if (TREE_CODE (type) == RECORD_TYPE)
827 if (TYPE_SIZE (type) == error_mark_node)
828 return null_pointer_node;
829 decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
830 "", '/', '/', ".class");
831 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
832 if (decl == NULL_TREE)
834 decl = build_decl (VAR_DECL, decl_name, class_type_node);
835 DECL_SIZE (decl) = TYPE_SIZE (class_type_node);
836 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (class_type_node);
837 TREE_STATIC (decl) = 1;
838 TREE_PUBLIC (decl) = 1;
839 DECL_IGNORED_P (decl) = 1;
840 DECL_ARTIFICIAL (decl) = 1;
841 if (is_compiled == 1)
842 DECL_EXTERNAL (decl) = 1;
843 SET_DECL_ASSEMBLER_NAME (decl,
844 java_mangle_class_field
845 (&temporary_obstack, type));
846 make_decl_rtl (decl, NULL);
847 pushdecl_top_level (decl);
854 if (flag_emit_class_files)
856 const char *prim_class_name;
858 if (type == char_type_node)
859 prim_class_name = "java.lang.Character";
860 else if (type == boolean_type_node)
861 prim_class_name = "java.lang.Boolean";
862 else if (type == byte_type_node)
863 prim_class_name = "java.lang.Byte";
864 else if (type == short_type_node)
865 prim_class_name = "java.lang.Short";
866 else if (type == int_type_node)
867 prim_class_name = "java.lang.Integer";
868 else if (type == long_type_node)
869 prim_class_name = "java.lang.Long";
870 else if (type == float_type_node)
871 prim_class_name = "java.lang.Float";
872 else if (type == double_type_node)
873 prim_class_name = "java.lang.Double";
874 else if (type == void_type_node)
875 prim_class_name = "java.lang.Void";
879 prim_class = lookup_class (get_identifier (prim_class_name));
880 return build (COMPONENT_REF, NULL_TREE,
881 prim_class, TYPE_identifier_node);
883 decl_name = TYPE_NAME (type);
884 if (TREE_CODE (decl_name) == TYPE_DECL)
885 decl_name = DECL_NAME (decl_name);
886 name = IDENTIFIER_POINTER (decl_name);
887 if (strncmp (name, "promoted_", 9) == 0)
889 sprintf (buffer, "_Jv_%sClass", name);
890 decl_name = get_identifier (buffer);
891 decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
892 if (decl == NULL_TREE)
894 decl = build_decl (VAR_DECL, decl_name, class_type_node);
895 TREE_STATIC (decl) = 1;
896 TREE_PUBLIC (decl) = 1;
897 DECL_EXTERNAL (decl) = 1;
898 make_decl_rtl (decl, NULL);
899 pushdecl_top_level (decl);
903 ref = build1 (ADDR_EXPR, class_ptr_type, decl);
910 index = alloc_class_constant (type);
911 cl = build_ref_from_constant_pool (index);
912 TREE_TYPE (cl) = promote_type (class_ptr_type);
918 build_static_field_ref (tree fdecl)
920 tree fclass = DECL_CONTEXT (fdecl);
921 int is_compiled = is_compiled_class (fclass);
923 /* Allow static final fields to fold to a constant. When using
924 -fno-assume-compiled, gcj will sometimes try to fold a field from
925 an uncompiled class. This is required when the field in question
926 meets the appropriate criteria for a compile-time constant.
927 However, currently sometimes gcj is too eager and will end up
928 returning the field itself, leading to an incorrect external
929 reference being generated. */
931 || (FIELD_FINAL (fdecl) && DECL_INITIAL (fdecl) != NULL_TREE
932 && (JSTRING_TYPE_P (TREE_TYPE (fdecl))
933 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl)))
934 && TREE_CONSTANT (DECL_INITIAL (fdecl))))
936 if (!DECL_RTL_SET_P (fdecl))
938 if (is_compiled == 1)
939 DECL_EXTERNAL (fdecl) = 1;
940 make_decl_rtl (fdecl, NULL);
947 * *(FTYPE*)build_class_ref(FCLASS)->fields[INDEX].info.addr */
948 tree ref = build_class_ref (fclass);
951 ref = build1 (INDIRECT_REF, class_type_node, ref);
952 ref = build (COMPONENT_REF, field_ptr_type_node, ref,
953 lookup_field (&class_type_node, fields_ident));
955 for (fld = TYPE_FIELDS (fclass); ; fld = TREE_CHAIN (fld))
959 if (fld == NULL_TREE)
960 fatal_error ("field '%s' not found in class",
961 IDENTIFIER_POINTER (DECL_NAME (fdecl)));
962 if (FIELD_STATIC (fld))
965 field_index *= int_size_in_bytes (field_type_node);
966 ref = fold (build (PLUS_EXPR, field_ptr_type_node,
967 ref, build_int_2 (field_index, 0)));
968 ref = build1 (INDIRECT_REF, field_type_node, ref);
969 ref = build (COMPONENT_REF, field_info_union_node,
970 ref, lookup_field (&field_type_node, info_ident));
971 ref = build (COMPONENT_REF, ptr_type_node,
972 ref, TREE_CHAIN (TYPE_FIELDS (field_info_union_node)));
973 return fold (build1 (INDIRECT_REF, TREE_TYPE(fdecl), ref));
978 get_access_flags_from_decl (tree decl)
980 int access_flags = 0;
981 if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
983 if (FIELD_STATIC (decl))
984 access_flags |= ACC_STATIC;
985 if (FIELD_PUBLIC (decl))
986 access_flags |= ACC_PUBLIC;
987 if (FIELD_PROTECTED (decl))
988 access_flags |= ACC_PROTECTED;
989 if (FIELD_PRIVATE (decl))
990 access_flags |= ACC_PRIVATE;
991 if (FIELD_FINAL (decl))
992 access_flags |= ACC_FINAL;
993 if (FIELD_VOLATILE (decl))
994 access_flags |= ACC_VOLATILE;
995 if (FIELD_TRANSIENT (decl))
996 access_flags |= ACC_TRANSIENT;
999 if (TREE_CODE (decl) == TYPE_DECL)
1001 if (CLASS_PUBLIC (decl))
1002 access_flags |= ACC_PUBLIC;
1003 if (CLASS_FINAL (decl))
1004 access_flags |= ACC_FINAL;
1005 if (CLASS_SUPER (decl))
1006 access_flags |= ACC_SUPER;
1007 if (CLASS_INTERFACE (decl))
1008 access_flags |= ACC_INTERFACE;
1009 if (CLASS_ABSTRACT (decl))
1010 access_flags |= ACC_ABSTRACT;
1011 if (CLASS_STATIC (decl))
1012 access_flags |= ACC_STATIC;
1013 if (CLASS_PRIVATE (decl))
1014 access_flags |= ACC_PRIVATE;
1015 if (CLASS_PROTECTED (decl))
1016 access_flags |= ACC_PROTECTED;
1017 if (CLASS_STRICTFP (decl))
1018 access_flags |= ACC_STRICT;
1019 return access_flags;
1021 if (TREE_CODE (decl) == FUNCTION_DECL)
1023 if (METHOD_PUBLIC (decl))
1024 access_flags |= ACC_PUBLIC;
1025 if (METHOD_PRIVATE (decl))
1026 access_flags |= ACC_PRIVATE;
1027 if (METHOD_PROTECTED (decl))
1028 access_flags |= ACC_PROTECTED;
1029 if (METHOD_STATIC (decl))
1030 access_flags |= ACC_STATIC;
1031 if (METHOD_FINAL (decl))
1032 access_flags |= ACC_FINAL;
1033 if (METHOD_SYNCHRONIZED (decl))
1034 access_flags |= ACC_SYNCHRONIZED;
1035 if (METHOD_NATIVE (decl))
1036 access_flags |= ACC_NATIVE;
1037 if (METHOD_ABSTRACT (decl))
1038 access_flags |= ACC_ABSTRACT;
1039 if (METHOD_TRANSIENT (decl))
1040 access_flags |= ACC_TRANSIENT;
1041 if (METHOD_STRICTFP (decl))
1042 access_flags |= ACC_STRICT;
1043 return access_flags;
1049 make_field_value (tree fdecl)
1053 tree type = TREE_TYPE (fdecl);
1054 int resolved = is_compiled_class (type);
1056 START_RECORD_CONSTRUCTOR (finit, field_type_node);
1057 PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl)));
1059 type = build_class_ref (type);
1062 tree signature = build_java_signature (type);
1064 type = build_utf8_ref (unmangle_classname
1065 (IDENTIFIER_POINTER (signature),
1066 IDENTIFIER_LENGTH (signature)));
1068 PUSH_FIELD_VALUE (finit, "type", type);
1070 flags = get_access_flags_from_decl (fdecl);
1072 flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1074 PUSH_FIELD_VALUE (finit, "accflags", build_int_2 (flags, 0));
1075 PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
1079 build_constructor (field_info_union_node,
1081 ((FIELD_STATIC (fdecl)
1082 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
1083 : TYPE_FIELDS (field_info_union_node)),
1084 (FIELD_STATIC (fdecl)
1085 ? build_address_of (build_static_field_ref (fdecl))
1086 : byte_position (fdecl)))));
1088 FINISH_RECORD_CONSTRUCTOR (finit);
1093 make_method_value (tree mdecl)
1095 static int method_name_count = 0;
1099 #define ACC_TRANSLATED 0x4000
1100 int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
1102 if (!flag_indirect_dispatch && DECL_VINDEX (mdecl) != NULL_TREE)
1103 index = DECL_VINDEX (mdecl);
1105 index = integer_minus_one_node;
1107 code = null_pointer_node;
1108 if (DECL_RTL_SET_P (mdecl))
1109 code = build1 (ADDR_EXPR, nativecode_ptr_type_node, mdecl);
1110 START_RECORD_CONSTRUCTOR (minit, method_type_node);
1111 PUSH_FIELD_VALUE (minit, "name",
1112 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
1113 init_identifier_node
1114 : DECL_NAME (mdecl)));
1116 tree signature = build_java_signature (TREE_TYPE (mdecl));
1117 PUSH_FIELD_VALUE (minit, "signature",
1120 (IDENTIFIER_POINTER(signature),
1121 IDENTIFIER_LENGTH(signature)))));
1123 PUSH_FIELD_VALUE (minit, "accflags", build_int_2 (accflags, 0));
1124 PUSH_FIELD_VALUE (minit, "index", index);
1125 PUSH_FIELD_VALUE (minit, "ncode", code);
1128 /* Compute the `throws' information for the method. */
1129 tree table = null_pointer_node;
1130 if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE)
1132 int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl));
1133 tree iter, type, array;
1136 table = tree_cons (NULL_TREE, table, NULL_TREE);
1137 for (iter = DECL_FUNCTION_THROWS (mdecl);
1139 iter = TREE_CHAIN (iter))
1141 tree sig = DECL_NAME (TYPE_NAME (TREE_VALUE (iter)));
1143 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
1144 IDENTIFIER_LENGTH (sig)));
1145 table = tree_cons (NULL_TREE, utf8, table);
1147 type = build_prim_array_type (ptr_type_node, length);
1148 table = build_constructor (type, table);
1149 /* Compute something unique enough. */
1150 sprintf (buf, "_methods%d", method_name_count++);
1151 array = build_decl (VAR_DECL, get_identifier (buf), type);
1152 DECL_INITIAL (array) = table;
1153 TREE_STATIC (array) = 1;
1154 DECL_ARTIFICIAL (array) = 1;
1155 DECL_IGNORED_P (array) = 1;
1156 rest_of_decl_compilation (array, (char*) 0, 1, 0);
1158 table = build1 (ADDR_EXPR, ptr_type_node, array);
1161 PUSH_FIELD_VALUE (minit, "throws", table);
1164 FINISH_RECORD_CONSTRUCTOR (minit);
1169 get_dispatch_vector (tree type)
1171 tree vtable = TYPE_VTABLE (type);
1173 if (vtable == NULL_TREE)
1177 tree super = CLASSTYPE_SUPER (type);
1178 HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1179 vtable = make_tree_vec (nvirtuals);
1180 TYPE_VTABLE (type) = vtable;
1181 if (super != NULL_TREE)
1183 tree super_vtable = get_dispatch_vector (super);
1185 for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1186 TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1189 for (method = TYPE_METHODS (type); method != NULL_TREE;
1190 method = TREE_CHAIN (method))
1191 if (DECL_VINDEX (method) != NULL_TREE
1192 && host_integerp (DECL_VINDEX (method), 0))
1193 TREE_VEC_ELT (vtable, tree_low_cst (DECL_VINDEX (method), 0))
1201 get_dispatch_table (tree type, tree this_class_addr)
1203 int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1204 tree vtable = get_dispatch_vector (type);
1206 tree list = NULL_TREE;
1207 int nvirtuals = TREE_VEC_LENGTH (vtable);
1211 for (i = nvirtuals; --i >= 0; )
1213 tree method = TREE_VEC_ELT (vtable, i);
1214 if (METHOD_ABSTRACT (method))
1217 warning_with_decl (method,
1218 "abstract method in non-abstract class");
1220 if (TARGET_VTABLE_USES_DESCRIPTORS)
1221 for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1222 list = tree_cons (NULL_TREE, null_pointer_node, list);
1224 list = tree_cons (NULL_TREE, null_pointer_node, list);
1228 if (!DECL_RTL_SET_P (method))
1229 make_decl_rtl (method, NULL);
1231 if (TARGET_VTABLE_USES_DESCRIPTORS)
1232 for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1234 tree fdesc = build (FDESC_EXPR, nativecode_ptr_type_node,
1235 method, build_int_2 (j, 0));
1236 TREE_CONSTANT (fdesc) = 1;
1237 list = tree_cons (NULL_TREE, fdesc, list);
1240 list = tree_cons (NULL_TREE,
1241 build1 (ADDR_EXPR, nativecode_ptr_type_node,
1247 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1248 using the Boehm GC we sometimes stash a GC type descriptor
1249 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1250 the emitted byte count during the output to the assembly file. */
1251 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1252 fake "function descriptor". It's first word is the is the class
1253 pointer, and subsequent words (usually one) contain the GC descriptor.
1254 In all other cases, we reserve two extra vtable slots. */
1255 gc_descr = get_boehm_type_descriptor (type);
1256 list = tree_cons (NULL_TREE, gc_descr, list);
1257 for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
1258 list = tree_cons (NULL_TREE, gc_descr, list);
1259 list = tree_cons (NULL_TREE, this_class_addr, list);
1261 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1262 list = tree_cons (NULL_TREE, null_pointer_node, list);
1263 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1264 list = tree_cons (integer_zero_node, null_pointer_node, list);
1266 arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
1267 if (TARGET_VTABLE_USES_DESCRIPTORS)
1268 arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
1270 return build_constructor (build_prim_array_type (nativecode_ptr_type_node,
1275 supers_all_compiled (tree type)
1277 while (type != NULL_TREE)
1279 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
1281 type = CLASSTYPE_SUPER (type);
1287 make_class_data (tree type)
1289 tree decl, cons, temp;
1290 tree field, fields_decl;
1291 tree static_fields = NULL_TREE;
1292 tree instance_fields = NULL_TREE;
1293 HOST_WIDE_INT static_field_count = 0;
1294 HOST_WIDE_INT instance_field_count = 0;
1295 HOST_WIDE_INT field_count;
1296 tree field_array_type;
1298 tree methods = NULL_TREE;
1299 tree dtable_decl = NULL_TREE;
1300 HOST_WIDE_INT method_count = 0;
1301 tree method_array_type;
1304 tree this_class_addr;
1305 tree constant_pool_constructor;
1306 tree interfaces = null_pointer_node;
1307 int interface_len = 0;
1308 tree type_decl = TYPE_NAME (type);
1309 /** Offset from start of virtual function table declaration
1310 to where objects actually point at, following new g++ ABI. */
1311 tree dtable_start_offset = build_int_2 (2 * POINTER_SIZE / BITS_PER_UNIT, 0);
1313 this_class_addr = build_class_ref (type);
1314 decl = TREE_OPERAND (this_class_addr, 0);
1316 /* Build Field array. */
1317 field = TYPE_FIELDS (type);
1318 if (DECL_NAME (field) == NULL_TREE)
1319 field = TREE_CHAIN (field); /* Skip dummy field for inherited data. */
1320 for ( ; field != NULL_TREE; field = TREE_CHAIN (field))
1322 if (! DECL_ARTIFICIAL (field))
1324 tree init = make_field_value (field);
1325 if (FIELD_STATIC (field))
1327 tree initial = DECL_INITIAL (field);
1328 static_field_count++;
1329 static_fields = tree_cons (NULL_TREE, init, static_fields);
1330 /* If the initial value is a string constant,
1331 prevent output_constant from trying to assemble the value. */
1332 if (initial != NULL_TREE
1333 && TREE_TYPE (initial) == string_ptr_type_node)
1334 DECL_INITIAL (field) = NULL_TREE;
1335 rest_of_decl_compilation (field, (char*) 0, 1, 1);
1336 DECL_INITIAL (field) = initial;
1340 instance_field_count++;
1341 instance_fields = tree_cons (NULL_TREE, init, instance_fields);
1345 field_count = static_field_count + instance_field_count;
1346 if (field_count > 0)
1348 static_fields = nreverse (static_fields);
1349 instance_fields = nreverse (instance_fields);
1350 static_fields = chainon (static_fields, instance_fields);
1351 field_array_type = build_prim_array_type (field_type_node, field_count);
1352 fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
1354 DECL_INITIAL (fields_decl) = build_constructor (field_array_type,
1356 TREE_STATIC (fields_decl) = 1;
1357 DECL_ARTIFICIAL (fields_decl) = 1;
1358 DECL_IGNORED_P (fields_decl) = 1;
1359 rest_of_decl_compilation (fields_decl, (char*) 0, 1, 0);
1362 fields_decl = NULL_TREE;
1364 /* Build Method array. */
1365 for (method = TYPE_METHODS (type);
1366 method != NULL_TREE; method = TREE_CHAIN (method))
1369 if (METHOD_PRIVATE (method)
1370 && ! flag_keep_inline_functions
1371 && (flag_inline_functions || optimize))
1373 init = make_method_value (method);
1375 methods = tree_cons (NULL_TREE, init, methods);
1377 method_array_type = build_prim_array_type (method_type_node, method_count);
1378 methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
1380 DECL_INITIAL (methods_decl) = build_constructor (method_array_type,
1381 nreverse (methods));
1382 TREE_STATIC (methods_decl) = 1;
1383 DECL_ARTIFICIAL (methods_decl) = 1;
1384 DECL_IGNORED_P (methods_decl) = 1;
1385 rest_of_decl_compilation (methods_decl, (char*) 0, 1, 0);
1387 if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
1388 && !flag_indirect_dispatch)
1390 tree dtable = get_dispatch_table (type, this_class_addr);
1391 dtable_decl = build_dtable_decl (type);
1392 DECL_INITIAL (dtable_decl) = dtable;
1393 TREE_STATIC (dtable_decl) = 1;
1394 DECL_ARTIFICIAL (dtable_decl) = 1;
1395 DECL_IGNORED_P (dtable_decl) = 1;
1396 TREE_PUBLIC (dtable_decl) = 1;
1397 rest_of_decl_compilation (dtable_decl, (char*) 0, 1, 0);
1398 if (type == class_type_node)
1399 class_dtable_decl = dtable_decl;
1402 if (class_dtable_decl == NULL_TREE)
1404 class_dtable_decl = build_dtable_decl (class_type_node);
1405 TREE_STATIC (class_dtable_decl) = 1;
1406 DECL_ARTIFICIAL (class_dtable_decl) = 1;
1407 DECL_IGNORED_P (class_dtable_decl) = 1;
1408 if (is_compiled_class (class_type_node) != 2)
1409 DECL_EXTERNAL (class_dtable_decl) = 1;
1410 rest_of_decl_compilation (class_dtable_decl, (char*) 0, 1, 0);
1413 super = CLASSTYPE_SUPER (type);
1414 if (super == NULL_TREE)
1415 super = null_pointer_node;
1416 else if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
1417 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
1418 super = build_class_ref (super);
1421 int super_index = alloc_class_constant (super);
1422 super = build_int_2 (super_index, 0);
1423 TREE_TYPE (super) = ptr_type_node;
1426 /* Build and emit the array of implemented interfaces. */
1427 if (type != object_type_node)
1428 interface_len = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)) - 1;
1429 if (interface_len > 0)
1431 tree init = NULL_TREE;
1433 tree interface_array_type, idecl;
1434 interface_array_type
1435 = build_prim_array_type (class_ptr_type, interface_len);
1436 idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type),
1437 interface_array_type);
1438 for (i = interface_len; i > 0; i--)
1440 tree child = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i);
1441 tree iclass = BINFO_TYPE (child);
1443 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass)))))
1444 index = build_class_ref (iclass);
1447 int int_index = alloc_class_constant (iclass);
1448 index = build_int_2 (int_index, 0);
1449 TREE_TYPE (index) = ptr_type_node;
1451 init = tree_cons (NULL_TREE, index, init);
1453 DECL_INITIAL (idecl) = build_constructor (interface_array_type, init);
1454 TREE_STATIC (idecl) = 1;
1455 DECL_ARTIFICIAL (idecl) = 1;
1456 DECL_IGNORED_P (idecl) = 1;
1457 interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
1458 rest_of_decl_compilation (idecl, (char*) 0, 1, 0);
1461 constant_pool_constructor = build_constants_constructor ();
1463 START_RECORD_CONSTRUCTOR (temp, object_type_node);
1464 PUSH_FIELD_VALUE (temp, "vtable",
1465 build (PLUS_EXPR, dtable_ptr_type,
1466 build1 (ADDR_EXPR, dtable_ptr_type, class_dtable_decl),
1467 dtable_start_offset));
1468 if (! flag_hash_synchronization)
1469 PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
1470 FINISH_RECORD_CONSTRUCTOR (temp);
1471 START_RECORD_CONSTRUCTOR (cons, class_type_node);
1472 PUSH_SUPER_VALUE (cons, temp);
1473 PUSH_FIELD_VALUE (cons, "next", null_pointer_node);
1474 PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
1475 PUSH_FIELD_VALUE (cons, "accflags",
1476 build_int_2 (get_access_flags_from_decl (type_decl), 0));
1478 PUSH_FIELD_VALUE (cons, "superclass",
1479 CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
1480 PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
1481 PUSH_FIELD_VALUE (cons, "methods",
1482 build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
1483 PUSH_FIELD_VALUE (cons, "method_count", build_int_2 (method_count, 0));
1485 if (flag_indirect_dispatch)
1486 PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node)
1488 PUSH_FIELD_VALUE (cons, "vtable_method_count", TYPE_NVIRTUALS (type));
1490 PUSH_FIELD_VALUE (cons, "fields",
1491 fields_decl == NULL_TREE ? null_pointer_node
1492 : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
1493 PUSH_FIELD_VALUE (cons, "size_in_bytes", size_in_bytes (type));
1494 PUSH_FIELD_VALUE (cons, "field_count", build_int_2 (field_count, 0));
1495 PUSH_FIELD_VALUE (cons, "static_field_count",
1496 build_int_2 (static_field_count, 0));
1498 if (flag_indirect_dispatch)
1499 PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node)
1501 PUSH_FIELD_VALUE (cons, "vtable",
1502 dtable_decl == NULL_TREE ? null_pointer_node
1503 : build (PLUS_EXPR, dtable_ptr_type,
1504 build1 (ADDR_EXPR, dtable_ptr_type, dtable_decl),
1505 dtable_start_offset));
1507 if (otable_methods == NULL_TREE)
1509 PUSH_FIELD_VALUE (cons, "otable", null_pointer_node);
1510 PUSH_FIELD_VALUE (cons, "otable_syms", null_pointer_node);
1514 PUSH_FIELD_VALUE (cons, "otable",
1515 build1 (ADDR_EXPR, otable_ptr_type, otable_decl));
1516 PUSH_FIELD_VALUE (cons, "otable_syms",
1517 build1 (ADDR_EXPR, method_symbols_array_ptr_type,
1520 PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
1521 PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
1522 PUSH_FIELD_VALUE (cons, "interface_count", build_int_2 (interface_len, 0));
1523 PUSH_FIELD_VALUE (cons, "state", integer_zero_node);
1525 PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
1526 PUSH_FIELD_VALUE (cons, "depth", integer_zero_node);
1527 PUSH_FIELD_VALUE (cons, "ancestors", null_pointer_node);
1528 PUSH_FIELD_VALUE (cons, "idt", null_pointer_node);
1529 PUSH_FIELD_VALUE (cons, "arrayclass", null_pointer_node);
1530 PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
1531 PUSH_FIELD_VALUE (cons, "chain", null_pointer_node);
1533 FINISH_RECORD_CONSTRUCTOR (cons);
1535 DECL_INITIAL (decl) = cons;
1537 /* Hash synchronization requires at least 64-bit alignment. */
1538 if (flag_hash_synchronization && POINTER_SIZE < 64)
1539 DECL_ALIGN (decl) = 64;
1541 rest_of_decl_compilation (decl, (char*) 0, 1, 0);
1548 tree type_methods = TYPE_METHODS (current_class);
1549 int saw_native_method = 0;
1551 /* Find out if we have any native methods. We use this information
1553 for (method = type_methods;
1554 method != NULL_TREE;
1555 method = TREE_CHAIN (method))
1557 if (METHOD_NATIVE (method))
1559 saw_native_method = 1;
1564 /* Emit deferred inline methods. */
1565 for (method = type_methods; method != NULL_TREE; )
1567 if (! TREE_ASM_WRITTEN (method) && DECL_SAVED_INSNS (method) != 0)
1569 output_inline_function (method);
1570 /* Scan the list again to see if there are any earlier
1572 method = type_methods;
1575 method = TREE_CHAIN (method);
1578 current_function_decl = NULL_TREE;
1579 make_class_data (current_class);
1581 rest_of_decl_compilation (TYPE_NAME (current_class), (char*) 0, 1, 0);
1584 /* Return 2 if CLASS is compiled by this compilation job;
1585 return 1 if CLASS can otherwise be assumed to be compiled;
1586 return 0 if we cannot assume that CLASS is compiled.
1587 Returns 1 for primitive and 0 for array types. */
1589 is_compiled_class (tree class)
1592 if (TREE_CODE (class) == POINTER_TYPE)
1593 class = TREE_TYPE (class);
1594 if (TREE_CODE (class) != RECORD_TYPE) /* Primitive types are static. */
1596 if (TYPE_ARRAY_P (class))
1598 if (class == current_class)
1601 seen_in_zip = (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1602 if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip)
1604 /* The class was seen in the current ZIP file and will be
1605 available as a compiled class in the future but may not have
1606 been loaded already. Load it if necessary. This prevent
1607 build_class_ref () from crashing. */
1609 if (seen_in_zip && !CLASS_LOADED_P (class))
1610 load_class (class, 1);
1612 /* We return 2 for class seen in ZIP and class from files
1613 belonging to the same compilation unit */
1617 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1619 if (!CLASS_LOADED_P (class))
1621 if (CLASS_FROM_SOURCE_P (class))
1622 safe_layout_class (class);
1624 load_class (class, 1);
1632 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1635 build_dtable_decl (tree type)
1639 /* We need to build a new dtable type so that its size is uniquely
1640 computed when we're dealing with the class for real and not just
1641 faking it (like java.lang.Class during the initialization of the
1642 compiler.) We know we're not faking a class when CURRENT_CLASS is
1644 if (current_class == type)
1646 tree dummy = NULL_TREE;
1649 dtype = make_node (RECORD_TYPE);
1651 PUSH_FIELD (dtype, dummy, "top_offset", ptr_type_node);
1652 PUSH_FIELD (dtype, dummy, "type_info", ptr_type_node);
1654 PUSH_FIELD (dtype, dummy, "class", class_ptr_type);
1655 for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
1657 tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
1658 TREE_CHAIN (dummy) = tmp_field;
1659 DECL_CONTEXT (tmp_field) = dtype;
1660 DECL_ARTIFICIAL (tmp_field) = 1;
1664 PUSH_FIELD (dtype, dummy, "gc_descr", ptr_type_node);
1665 for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
1667 tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
1668 TREE_CHAIN (dummy) = tmp_field;
1669 DECL_CONTEXT (tmp_field) = dtype;
1670 DECL_ARTIFICIAL (tmp_field) = 1;
1674 n = TREE_VEC_LENGTH (get_dispatch_vector (type));
1675 if (TARGET_VTABLE_USES_DESCRIPTORS)
1676 n *= TARGET_VTABLE_USES_DESCRIPTORS;
1678 PUSH_FIELD (dtype, dummy, "methods",
1679 build_prim_array_type (nativecode_ptr_type_node, n));
1680 layout_type (dtype);
1683 dtype = dtable_type;
1685 return build_decl (VAR_DECL,
1686 java_mangle_vtable (&temporary_obstack, type), dtype);
1689 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
1690 fields inherited from SUPER_CLASS. */
1693 push_super_field (tree this_class, tree super_class)
1696 /* Don't insert the field if we're just re-laying the class out. */
1697 if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
1699 base_decl = build_decl (FIELD_DECL, NULL_TREE, super_class);
1700 DECL_IGNORED_P (base_decl) = 1;
1701 TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
1702 TYPE_FIELDS (this_class) = base_decl;
1703 DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
1704 DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
1707 /* Handle the different manners we may have to lay out a super class. */
1710 maybe_layout_super_class (tree super_class, tree this_class)
1712 if (TREE_CODE (super_class) == RECORD_TYPE)
1714 if (!CLASS_LOADED_P (super_class) && CLASS_FROM_SOURCE_P (super_class))
1715 safe_layout_class (super_class);
1716 if (!CLASS_LOADED_P (super_class))
1717 load_class (super_class, 1);
1719 /* We might have to layout the class before its dependency on
1720 the super class gets resolved by java_complete_class */
1721 else if (TREE_CODE (super_class) == POINTER_TYPE)
1723 if (TREE_TYPE (super_class) != NULL_TREE)
1724 super_class = TREE_TYPE (super_class);
1727 /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
1729 tree this_wrap = NULL_TREE;
1733 tree this_decl = TYPE_NAME (this_class);
1734 this_wrap = build_expr_wfl (this_class,
1735 DECL_SOURCE_FILE (this_decl),
1736 DECL_SOURCE_LINE (this_decl), 0);
1738 super_class = do_resolve_class (NULL_TREE, /* FIXME? */
1739 super_class, NULL_TREE, this_wrap);
1741 return NULL_TREE; /* FIXME, NULL_TREE not checked by caller. */
1742 super_class = TREE_TYPE (super_class);
1745 if (!TYPE_SIZE (super_class))
1746 safe_layout_class (super_class);
1752 layout_class (tree this_class)
1754 tree super_class = CLASSTYPE_SUPER (this_class);
1757 class_list = tree_cons (this_class, NULL_TREE, class_list);
1758 if (CLASS_BEING_LAIDOUT (this_class))
1764 sprintf (buffer, " with `%s'",
1765 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
1766 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
1768 for (current = TREE_CHAIN (class_list); current;
1769 current = TREE_CHAIN (current))
1771 tree decl = TYPE_NAME (TREE_PURPOSE (current));
1772 sprintf (buffer, "\n which inherits from `%s' (%s:%d)",
1773 IDENTIFIER_POINTER (DECL_NAME (decl)),
1774 DECL_SOURCE_FILE (decl),
1775 DECL_SOURCE_LINE (decl));
1776 obstack_grow (&temporary_obstack, buffer, strlen (buffer));
1778 obstack_1grow (&temporary_obstack, '\0');
1779 report = obstack_finish (&temporary_obstack);
1780 cyclic_inheritance_report = ggc_strdup (report);
1781 obstack_free (&temporary_obstack, report);
1782 TYPE_SIZE (this_class) = error_mark_node;
1785 CLASS_BEING_LAIDOUT (this_class) = 1;
1787 if (super_class && !CLASS_BEING_LAIDOUT (super_class))
1789 tree maybe_super_class
1790 = maybe_layout_super_class (super_class, this_class);
1791 if (maybe_super_class == NULL
1792 || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
1794 TYPE_SIZE (this_class) = error_mark_node;
1795 CLASS_BEING_LAIDOUT (this_class) = 0;
1796 class_list = TREE_CHAIN (class_list);
1799 if (TYPE_SIZE (this_class) == NULL_TREE)
1800 push_super_field (this_class, maybe_super_class);
1803 for (field = TYPE_FIELDS (this_class);
1804 field != NULL_TREE; field = TREE_CHAIN (field))
1806 if (FIELD_STATIC (field))
1808 /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
1809 SET_DECL_ASSEMBLER_NAME (field,
1811 (&temporary_obstack, field));
1815 layout_type (this_class);
1817 /* Also recursively load/layout any superinterfaces, but only if class was
1818 loaded from bytecode. The source parser will take care of this itself. */
1819 if (!CLASS_FROM_SOURCE_P (this_class))
1821 tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
1825 int n = TREE_VEC_LENGTH (basetype_vec) - 1;
1827 for (i = n; i > 0; i--)
1829 tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
1830 tree super_interface = BINFO_TYPE (vec_elt);
1832 tree maybe_super_interface
1833 = maybe_layout_super_class (super_interface, NULL_TREE);
1834 if (maybe_super_interface == NULL
1835 || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
1837 TYPE_SIZE (this_class) = error_mark_node;
1838 CLASS_BEING_LAIDOUT (this_class) = 0;
1839 class_list = TREE_CHAIN (class_list);
1846 /* Convert the size back to an SI integer value */
1847 TYPE_SIZE_UNIT (this_class) =
1848 fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
1850 CLASS_BEING_LAIDOUT (this_class) = 0;
1851 class_list = TREE_CHAIN (class_list);
1855 layout_class_methods (tree this_class)
1857 tree method_decl, dtable_count;
1860 if (TYPE_NVIRTUALS (this_class))
1863 super_class = CLASSTYPE_SUPER (this_class);
1867 super_class = maybe_layout_super_class (super_class, this_class);
1868 if (!TYPE_NVIRTUALS (super_class))
1869 layout_class_methods (super_class);
1870 dtable_count = TYPE_NVIRTUALS (super_class);
1873 dtable_count = integer_zero_node;
1875 TYPE_METHODS (this_class) = nreverse (TYPE_METHODS (this_class));
1877 for (method_decl = TYPE_METHODS (this_class);
1878 method_decl; method_decl = TREE_CHAIN (method_decl))
1879 dtable_count = layout_class_method (this_class, super_class,
1880 method_decl, dtable_count);
1882 TYPE_NVIRTUALS (this_class) = dtable_count;
1885 /* Lay METHOD_DECL out, returning a possibly new value of
1886 DTABLE_COUNT. Also mangle the method's name. */
1889 layout_class_method (tree this_class, tree super_class,
1890 tree method_decl, tree dtable_count)
1892 tree method_name = DECL_NAME (method_decl);
1894 TREE_PUBLIC (method_decl) = 1;
1896 /* This is a good occasion to mangle the method's name */
1897 SET_DECL_ASSEMBLER_NAME (method_decl,
1898 java_mangle_decl (&temporary_obstack,
1900 /* We don't generate a RTL for the method if it's abstract, or if
1901 it's an interface method that isn't clinit. */
1902 if (! METHOD_ABSTRACT (method_decl)
1903 || (CLASS_INTERFACE (TYPE_NAME (this_class))
1904 && (DECL_CLINIT_P (method_decl))))
1905 make_decl_rtl (method_decl, NULL);
1907 if (ID_INIT_P (method_name))
1909 const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
1911 for (ptr = p; *ptr; )
1916 DECL_CONSTRUCTOR_P (method_decl) = 1;
1917 build_java_argument_signature (TREE_TYPE (method_decl));
1919 else if (! METHOD_STATIC (method_decl) && !DECL_ARTIFICIAL (method_decl))
1922 build_java_argument_signature (TREE_TYPE (method_decl));
1923 tree super_method = lookup_argument_method (super_class, method_name,
1925 if (super_method != NULL_TREE && ! METHOD_PRIVATE (super_method))
1927 DECL_VINDEX (method_decl) = DECL_VINDEX (super_method);
1928 if (DECL_VINDEX (method_decl) == NULL_TREE
1929 && !CLASS_FROM_SOURCE_P (this_class))
1930 error_with_decl (method_decl,
1931 "non-static method '%s' overrides static method");
1933 else if (! METHOD_FINAL (method_decl)
1934 && ! METHOD_PRIVATE (method_decl)
1935 && ! CLASS_FINAL (TYPE_NAME (this_class))
1938 DECL_VINDEX (method_decl) = dtable_count;
1939 dtable_count = fold (build (PLUS_EXPR, integer_type_node,
1940 dtable_count, integer_one_node));
1944 return dtable_count;
1948 register_class (void)
1950 /* END does not need to be registered with the garbage collector
1951 because it always points into the list given by REGISTERED_CLASS,
1952 and that variable is registered with the collector. */
1954 tree node = TREE_OPERAND (build_class_ref (current_class), 0);
1955 tree current = copy_node (node);
1957 XEXP (DECL_RTL (current), 0) = copy_rtx (XEXP (DECL_RTL(node), 0));
1958 if (!registered_class)
1959 registered_class = current;
1961 TREE_CHAIN (end) = current;
1966 /* Emit something to register classes at start-up time.
1968 The preferred mechanism is through the .jcr section, which contain
1969 a list of pointers to classes which get registered during
1970 constructor invocation time. The fallback mechanism is to generate
1971 a `constructor' function which calls _Jv_RegisterClass for each
1972 class in this file. */
1975 emit_register_classes (void)
1977 /* ??? This isn't quite the correct test. We also have to know
1978 that the target is using gcc's crtbegin/crtend objects rather
1979 than the ones that come with the operating system. */
1980 if (SUPPORTS_WEAK && targetm.have_named_sections)
1982 #ifdef JCR_SECTION_NAME
1984 named_section_flags (JCR_SECTION_NAME, SECTION_WRITE);
1985 assemble_align (POINTER_SIZE);
1986 for (t = registered_class; t; t = TREE_CHAIN (t))
1987 assemble_integer (XEXP (DECL_RTL (t), 0),
1988 POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1995 extern tree get_file_function_name (int);
1996 tree init_name = get_file_function_name ('I');
1997 tree init_type = build_function_type (void_type_node, end_params_node);
2001 init_decl = build_decl (FUNCTION_DECL, init_name, init_type);
2002 SET_DECL_ASSEMBLER_NAME (init_decl, init_name);
2003 TREE_STATIC (init_decl) = 1;
2004 current_function_decl = init_decl;
2005 DECL_RESULT (init_decl) = build_decl (RESULT_DECL, NULL_TREE,
2008 /* It can be a static function as long as collect2 does not have
2009 to scan the object file to find its ctor/dtor routine. */
2010 TREE_PUBLIC (init_decl) = ! targetm.have_ctors_dtors;
2012 /* Suppress spurious warnings. */
2013 TREE_USED (init_decl) = 1;
2016 make_decl_rtl (init_decl, NULL);
2017 init_function_start (init_decl, input_filename, 0);
2018 expand_function_start (init_decl, 0);
2020 /* Do not allow the function to be deferred. */
2021 current_function_cannot_inline
2022 = "static constructors and destructors cannot be inlined";
2024 for ( t = registered_class; t; t = TREE_CHAIN (t))
2025 emit_library_call (registerClass_libfunc, 0, VOIDmode, 1,
2026 XEXP (DECL_RTL (t), 0), Pmode);
2028 expand_function_end (input_filename, 0, 0);
2030 rest_of_compilation (init_decl);
2031 current_function_decl = NULL_TREE;
2033 if (targetm.have_ctors_dtors)
2034 (* targetm.asm_out.constructor) (XEXP (DECL_RTL (init_decl), 0),
2035 DEFAULT_INIT_PRIORITY);
2039 /* Make a method_symbol_type (_Jv_MethodSymbol) node for METHOD. */
2042 build_method_symbols_entry (tree method)
2044 tree clname, name, signature, method_symbol;
2046 clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (method))));
2047 name = build_utf8_ref (DECL_NAME (method));
2048 signature = build_java_signature (TREE_TYPE (method));
2049 signature = build_utf8_ref (unmangle_classname
2050 (IDENTIFIER_POINTER (signature),
2051 IDENTIFIER_LENGTH (signature)));
2053 START_RECORD_CONSTRUCTOR (method_symbol, method_symbol_type);
2054 PUSH_FIELD_VALUE (method_symbol, "clname", clname);
2055 PUSH_FIELD_VALUE (method_symbol, "name", name);
2056 PUSH_FIELD_VALUE (method_symbol, "signature", signature);
2057 FINISH_RECORD_CONSTRUCTOR (method_symbol);
2058 TREE_CONSTANT (method_symbol) = 1;
2060 return method_symbol;
2063 /* Emit the offset symbols table for indirect virtual dispatch. */
2066 emit_offset_symbol_table (void)
2068 tree method_list, method, table, list, null_symbol;
2069 tree otable_bound, otable_array_type;
2072 /* Only emit an offset table if this translation unit actually made virtual
2074 if (otable_methods == NULL_TREE)
2077 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2079 method_list = otable_methods;
2081 while (method_list != NULL_TREE)
2083 method = TREE_VALUE (method_list);
2084 list = tree_cons (NULL_TREE, build_method_symbols_entry (method), list);
2085 method_list = TREE_CHAIN (method_list);
2089 /* Terminate the list with a "null" entry. */
2090 START_RECORD_CONSTRUCTOR (null_symbol, method_symbol_type);
2091 PUSH_FIELD_VALUE (null_symbol, "clname", null_pointer_node);
2092 PUSH_FIELD_VALUE (null_symbol, "name", null_pointer_node);
2093 PUSH_FIELD_VALUE (null_symbol, "signature", null_pointer_node);
2094 FINISH_RECORD_CONSTRUCTOR (null_symbol);
2095 TREE_CONSTANT (null_symbol) = 1;
2096 list = tree_cons (NULL_TREE, null_symbol, list);
2098 /* Put the list in the right order and make it a constructor. */
2099 list = nreverse (list);
2100 table = build_constructor (method_symbols_array_type, list);
2102 /* Make it the initial value for otable_syms and emit the decl. */
2103 DECL_INITIAL (otable_syms_decl) = table;
2104 DECL_ARTIFICIAL (otable_syms_decl) = 1;
2105 DECL_IGNORED_P (otable_syms_decl) = 1;
2106 rest_of_decl_compilation (otable_syms_decl, NULL, 1, 0);
2108 /* Now that its size is known, redefine otable as an uninitialized static
2109 array of INDEX + 1 integers. The extra entry is used by the runtime
2110 to track whether the otable has been initialized. */
2111 otable_bound = build_index_type (build_int_2 (index, 0));
2112 otable_array_type = build_array_type (integer_type_node, otable_bound);
2113 otable_decl = build_decl (VAR_DECL, get_identifier ("otable"),
2115 TREE_STATIC (otable_decl) = 1;
2116 TREE_READONLY (otable_decl) = 1;
2117 rest_of_decl_compilation (otable_decl, NULL, 1, 0);
2121 init_class_processing (void)
2123 registerClass_libfunc = gen_rtx_SYMBOL_REF (Pmode, "_Jv_RegisterClass");
2124 fields_ident = get_identifier ("fields");
2125 info_ident = get_identifier ("info");
2126 gcc_obstack_init (&temporary_obstack);
2129 static hashval_t java_treetreehash_hash (const void *);
2130 static int java_treetreehash_compare (const void *, const void *);
2132 /* A hash table mapping trees to trees. Used generally. */
2134 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2137 java_treetreehash_hash (const void *k_p)
2139 struct treetreehash_entry *k = (struct treetreehash_entry *) k_p;
2140 return JAVA_TREEHASHHASH_H (k->key);
2144 java_treetreehash_compare (const void * k1_p, const void * k2_p)
2146 struct treetreehash_entry * k1 = (struct treetreehash_entry *) k1_p;
2147 tree k2 = (tree) k2_p;
2148 return (k1->key == k2);
2152 java_treetreehash_find (htab_t ht, tree t)
2154 struct treetreehash_entry *e;
2155 hashval_t hv = JAVA_TREEHASHHASH_H (t);
2156 e = (struct treetreehash_entry *) htab_find_with_hash (ht, t, hv);
2164 java_treetreehash_new (htab_t ht, tree t)
2167 struct treetreehash_entry *tthe;
2168 hashval_t hv = JAVA_TREEHASHHASH_H (t);
2170 e = htab_find_slot_with_hash (ht, t, hv, INSERT);
2173 tthe = (*ht->alloc_f) (1, sizeof (*tthe));
2178 tthe = (struct treetreehash_entry *) *e;
2179 return &tthe->value;
2183 java_treetreehash_create (size_t size, int gc)
2186 return htab_create_ggc (size, java_treetreehash_hash,
2187 java_treetreehash_compare, NULL);
2189 return htab_create_alloc (size, java_treetreehash_hash,
2190 java_treetreehash_compare, free, xcalloc, free);
2193 #include "gt-java-class.h"