1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008 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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>.
21 Java and all Java-based marks are trademarks or registered trademarks
22 of Sun Microsystems, Inc. in the United States and other countries.
23 The Free Software Foundation is independent of Sun Microsystems, Inc. */
25 /* Written by Per Bothner <bothner@cygnus.com> */
29 #include "coretypes.h"
34 #include "java-tree.h"
47 #include "tree-iterator.h"
51 /* DOS brain-damage */
53 #define O_BINARY 0 /* MS-DOS brain-damage */
56 static tree
make_method_value (tree
);
57 static tree
build_java_method_type (tree
, tree
, int);
58 static int32
hashUtf8String (const char *, int);
59 static tree
make_field_value (tree
);
60 static tree
get_dispatch_vector (tree
);
61 static tree
get_dispatch_table (tree
, tree
);
62 static int supers_all_compiled (tree type
);
63 static tree
maybe_layout_super_class (tree
, tree
);
64 static void add_miranda_methods (tree
, tree
);
65 static int assume_compiled (const char *);
66 static tree
build_symbol_entry (tree
, tree
);
67 static tree
emit_assertion_table (tree
);
68 static void register_class (void);
70 struct obstack temporary_obstack
;
72 static const char *cyclic_inheritance_report
;
74 /* The compiler generates different code depending on whether or not
75 it can assume certain classes have been compiled down to native
76 code or not. The compiler options -fassume-compiled= and
77 -fno-assume-compiled= are used to create a tree of
78 class_flag_node objects. This tree is queried to determine if
79 a class is assume to be compiled or not. Each node in the tree
80 represents either a package or a specific class. */
82 typedef struct class_flag_node_struct
84 /* The class or package name. */
87 /* Nonzero if this represents an exclusion. */
90 /* Pointers to other nodes in the tree. */
91 struct class_flag_node_struct
*parent
;
92 struct class_flag_node_struct
*sibling
;
93 struct class_flag_node_struct
*child
;
96 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
97 static void add_class_flag (class_flag_node
**, const char *, int);
99 /* This is the root of the include/exclude tree. */
101 static class_flag_node
*assume_compiled_tree
;
103 static class_flag_node
*enable_assert_tree
;
105 static GTY(()) tree class_roots
[4];
106 #define fields_ident class_roots[0] /* get_identifier ("fields") */
107 #define info_ident class_roots[1] /* get_identifier ("info") */
108 #define class_list class_roots[2]
109 #define class_dtable_decl class_roots[3]
111 static GTY(()) VEC(tree
,gc
) *registered_class
;
113 /* A tree that returns the address of the class$ of the class
114 currently being compiled. */
115 static GTY(()) tree this_classdollar
;
117 /* Return the node that most closely represents the class whose name
118 is IDENT. Start the search from NODE (followed by its siblings).
119 Return NULL if an appropriate node does not exist. */
121 static class_flag_node
*
122 find_class_flag_node (class_flag_node
*node
, const char *ident
)
126 size_t node_ident_length
= strlen (node
->ident
);
128 /* node_ident_length is zero at the root of the tree. If the
129 identifiers are the same length, then we have matching
130 classes. Otherwise check if we've matched an enclosing
133 if (node_ident_length
== 0
134 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
135 && (ident
[node_ident_length
] == '\0'
136 || ident
[node_ident_length
] == '.')))
138 /* We've found a match, however, there might be a more
141 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
148 /* No match yet. Continue through the sibling list. */
149 node
= node
->sibling
;
152 /* No match at all in this tree. */
157 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
159 class_flag_node
*root
= *rootp
;
160 class_flag_node
*parent
, *node
;
162 /* Create the root of the tree if it doesn't exist yet. */
166 root
= XNEW (class_flag_node
);
169 root
->sibling
= NULL
;
175 /* Calling the function with the empty string means we're setting
176 value for the root of the hierarchy. */
184 /* Find the parent node for this new node. PARENT will either be a
185 class or a package name. Adjust PARENT accordingly. */
187 parent
= find_class_flag_node (root
, ident
);
188 if (strcmp (ident
, parent
->ident
) == 0)
189 parent
->value
= value
;
192 /* Insert new node into the tree. */
193 node
= XNEW (class_flag_node
);
195 node
->ident
= xstrdup (ident
);
199 node
->parent
= parent
;
200 node
->sibling
= parent
->child
;
201 parent
->child
= node
;
205 /* Add a new IDENT to the include/exclude tree. It's an exclusion
206 if EXCLUDEP is nonzero. */
209 add_assume_compiled (const char *ident
, int excludep
)
211 add_class_flag (&assume_compiled_tree
, ident
, excludep
);
214 /* The default value returned by enable_assertions. */
216 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
218 /* Enter IDENT (a class or package name) into the enable-assertions table.
219 VALUE is true to enable and false to disable. */
222 add_enable_assert (const char *ident
, int value
)
224 if (enable_assert_tree
== NULL
)
225 add_class_flag (&enable_assert_tree
, "", DEFAULT_ENABLE_ASSERT
);
226 add_class_flag (&enable_assert_tree
, ident
, value
);
229 /* Returns nonzero if IDENT is the name of a class that the compiler
230 should assume has been compiled to object code. */
233 assume_compiled (const char *ident
)
238 if (NULL
== assume_compiled_tree
)
241 i
= find_class_flag_node (assume_compiled_tree
, ident
);
248 /* Return true if we should generate code to check assertions within KLASS. */
251 enable_assertions (tree klass
)
253 /* Check if command-line specifies whether we should check assertions. */
255 if (klass
!= NULL_TREE
&& DECL_NAME (klass
) && enable_assert_tree
!= NULL
)
257 const char *ident
= IDENTIFIER_POINTER (DECL_NAME (klass
));
258 class_flag_node
*node
259 = find_class_flag_node (enable_assert_tree
, ident
);
263 /* The default is to enable assertions if generating class files,
264 or not optimizing. */
265 return DEFAULT_ENABLE_ASSERT
;
268 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
269 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
270 Also, PREFIX is prepended, and SUFFIX is appended. */
273 ident_subst (const char* old_name
,
280 int prefix_len
= strlen (prefix
);
281 int suffix_len
= strlen (suffix
);
282 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
283 char *buffer
= (char *) alloca (i
);
285 strcpy (buffer
, prefix
);
286 for (i
= 0; i
< old_length
; i
++)
288 char ch
= old_name
[i
];
291 buffer
[prefix_len
+ i
] = ch
;
293 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
294 return get_identifier (buffer
);
297 /* Return an IDENTIFIER_NODE the same as OLD_ID,
298 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
299 Also, PREFIX is prepended, and SUFFIX is appended. */
302 identifier_subst (const tree old_id
,
308 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
309 prefix
, old_char
, new_char
, suffix
);
312 /* Generate a valid C identifier from the name of the class TYPE,
313 prefixed by PREFIX. */
316 mangled_classname (const char *prefix
, tree type
)
319 tree ident
= TYPE_NAME (type
);
320 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
321 ident
= DECL_NAME (ident
);
322 result
= identifier_subst (ident
, prefix
, '.', '_', "");
324 /* Replace any characters that aren't in the set [0-9a-zA-Z_$] with
325 "_0xXX". Class names containing such chracters are uncommon, but
326 they do sometimes occur in class files. Without this check,
327 these names cause assembly errors.
329 There is a possibility that a real class name could conflict with
330 the identifier we generate, but it is unlikely and will
331 immediately be detected as an assembler error. At some point we
332 should do something more elaborate (perhaps using the full
333 unicode mangling scheme) in order to prevent such a conflict. */
336 const int len
= IDENTIFIER_LENGTH (result
);
337 const char *p
= IDENTIFIER_POINTER (result
);
338 int illegal_chars
= 0;
340 /* Make two passes over the identifier. The first pass is merely
341 to count illegal characters; we need to do this in order to
342 allocate a buffer. */
343 for (i
= 0; i
< len
; i
++)
346 illegal_chars
+= (! ISALNUM (c
) && c
!= '_' && c
!= '$');
349 /* And the second pass, which is rarely executed, does the
351 if (illegal_chars
!= 0)
353 char *buffer
= (char *) alloca (illegal_chars
* 4 + len
+ 1);
356 for (i
= 0, j
= 0; i
< len
; i
++)
359 if (! ISALNUM (c
) && c
!= '_' && c
!= '$')
362 sprintf (&buffer
[j
], "0x%02x", c
);
370 result
= get_identifier (buffer
);
381 type
= make_node (RECORD_TYPE
);
382 /* Unfortunately we must create the binfo here, so that class
384 TYPE_BINFO (type
) = make_tree_binfo (0);
385 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
390 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
391 and where each of the constituents is separated by '/',
392 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
395 unmangle_classname (const char *name
, int name_length
)
397 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
398 /* It's not sufficient to compare to_return and get_identifier
399 (name) to determine whether to_return is qualified. There are
400 cases in signature analysis where name will be stripped of a
402 name
= IDENTIFIER_POINTER (to_return
);
406 QUALIFIED_P (to_return
) = 1;
413 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
416 const char *type_name = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
417 char *buf = (char *) alloca (strlen (type_name) \
418 + strlen (#NAME "_syms_") + 1); \
421 sprintf (buf, #NAME "_%s", type_name); \
422 TYPE_## TABLE ##_DECL (type) = decl = \
423 build_decl (input_location, VAR_DECL, get_identifier (buf), TABLE_TYPE); \
424 DECL_EXTERNAL (decl) = 1; \
425 TREE_STATIC (decl) = 1; \
426 TREE_READONLY (decl) = 1; \
427 TREE_CONSTANT (decl) = 1; \
428 DECL_IGNORED_P (decl) = 1; \
429 /* Mark the table as belonging to this class. */ \
431 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
432 DECL_OWNER (decl) = TYPE; \
433 sprintf (buf, #NAME "_syms_%s", type_name); \
434 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
435 build_decl (input_location, VAR_DECL, get_identifier (buf), symbols_array_type); \
436 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
437 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
438 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
442 /* Given a class, create the DECLs for all its associated indirect
445 gen_indirect_dispatch_tables (tree type
)
447 const char *type_name
= IDENTIFIER_POINTER (mangled_classname ("", type
));
450 char *buf
= (char *) alloca (strlen (type_name
)
451 + strlen ("_catch_classes_") + 1);
452 tree catch_class_type
= make_node (RECORD_TYPE
);
454 sprintf (buf
, "_catch_classes_%s", type_name
);
455 PUSH_FIELD (input_location
,
456 catch_class_type
, field
, "address", utf8const_ptr_type
);
457 PUSH_FIELD (input_location
,
458 catch_class_type
, field
, "classname", ptr_type_node
);
459 FINISH_RECORD (catch_class_type
);
461 TYPE_CTABLE_DECL (type
)
462 = build_decl (input_location
, VAR_DECL
, get_identifier (buf
),
463 build_array_type (catch_class_type
, 0));
464 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
465 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
466 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
467 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
468 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
469 pushdecl (TYPE_CTABLE_DECL (type
));
472 if (flag_indirect_dispatch
)
474 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
475 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
476 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
483 push_class (tree class_type
, tree class_name
)
485 tree decl
, signature
;
486 location_t saved_loc
= input_location
;
487 CLASS_P (class_type
) = 1;
488 decl
= build_decl (input_location
, TYPE_DECL
, class_name
, class_type
);
489 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
491 /* dbxout needs a DECL_SIZE if in gstabs mode */
492 DECL_SIZE (decl
) = integer_zero_node
;
494 input_location
= saved_loc
;
495 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
496 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
498 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
499 both a typedef and in the struct name-space. We may want to re-visit
500 this later, but for now it reduces the changes needed for gdb. */
501 DECL_ARTIFICIAL (decl
) = 1;
503 pushdecl_top_level (decl
);
508 /* Finds the (global) class named NAME. Creates the class if not found.
509 Also creates associated TYPE_DECL.
510 Does not check if the class actually exists, load the class,
511 fill in field or methods, or do layout_type. */
514 lookup_class (tree name
)
516 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
517 if (decl
== NULL_TREE
)
518 decl
= push_class (make_class (), name
);
519 return TREE_TYPE (decl
);
523 set_super_info (int access_flags
, tree this_class
,
524 tree super_class
, int interfaces_count
)
526 int total_supers
= interfaces_count
;
527 tree class_decl
= TYPE_NAME (this_class
);
533 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
534 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
537 tree super_binfo
= make_tree_binfo (0);
538 BINFO_TYPE (super_binfo
) = super_class
;
539 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
540 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
541 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
544 set_class_decl_access_flags (access_flags
, class_decl
);
548 set_class_decl_access_flags (int access_flags
, tree class_decl
)
550 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
551 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
552 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
553 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
554 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
555 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
556 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
557 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
558 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
559 if (access_flags
& ACC_ENUM
) CLASS_ENUM (class_decl
) = 1;
560 if (access_flags
& ACC_SYNTHETIC
) CLASS_SYNTHETIC (class_decl
) = 1;
561 if (access_flags
& ACC_ANNOTATION
) CLASS_ANNOTATION (class_decl
) = 1;
564 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
565 direct sub-classes of Object are 1, and so on. */
568 class_depth (tree clas
)
571 if (! CLASS_LOADED_P (clas
))
572 load_class (clas
, 1);
573 if (TYPE_SIZE (clas
) == error_mark_node
)
575 while (clas
!= object_type_node
)
578 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
583 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
586 interface_of_p (tree type1
, tree type2
)
589 tree binfo
, base_binfo
;
591 if (! TYPE_BINFO (type2
))
594 for (binfo
= TYPE_BINFO (type2
), i
= 0;
595 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
596 if (BINFO_TYPE (base_binfo
) == type1
)
599 for (binfo
= TYPE_BINFO (type2
), i
= 0;
600 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
601 if (BINFO_TYPE (base_binfo
)
602 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
608 /* Return true iff TYPE1 inherits from TYPE2. */
611 inherits_from_p (tree type1
, tree type2
)
613 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
618 if (! CLASS_LOADED_P (type1
))
619 load_class (type1
, 1);
621 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
626 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
629 enclosing_context_p (tree type1
, tree type2
)
631 if (!INNER_CLASS_TYPE_P (type2
))
634 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
636 type2
= (INNER_CLASS_TYPE_P (type2
) ?
637 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
647 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
651 common_enclosing_context_p (tree type1
, tree type2
)
656 for (current
= type2
; current
;
657 current
= (INNER_CLASS_TYPE_P (current
) ?
658 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
660 if (type1
== current
)
663 if (INNER_CLASS_TYPE_P (type1
))
664 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
671 /* Return 1 iff there exists a common enclosing "this" between TYPE1
672 and TYPE2, without crossing any static context. */
675 common_enclosing_instance_p (tree type1
, tree type2
)
677 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
680 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
681 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
682 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
685 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
686 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
687 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
689 if (type1
== current
)
695 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
696 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
697 if attempt is made to add it twice. */
700 maybe_add_interface (tree this_class
, tree interface_class
)
702 tree binfo
, base_binfo
;
705 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
706 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
707 if (BINFO_TYPE (base_binfo
) == interface_class
)
708 return interface_class
;
709 add_interface (this_class
, interface_class
);
713 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
716 add_interface (tree this_class
, tree interface_class
)
718 tree interface_binfo
= make_tree_binfo (0);
720 BINFO_TYPE (interface_binfo
) = interface_class
;
721 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
722 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
723 BINFO_VIRTUAL_P (interface_binfo
) = 1;
725 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
729 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
731 if (access_flags
& ACC_STATIC
)
733 fntype
= build_method_type (this_class
, fntype
);
735 /* We know that arg 1 of every nonstatic method is non-null; tell
737 TYPE_ATTRIBUTES (fntype
) = (tree_cons
738 (get_identifier ("nonnull"),
739 tree_cons (NULL_TREE
,
740 build_int_cst (NULL_TREE
, 1),
742 TYPE_ATTRIBUTES (fntype
)));
747 java_hide_decl (tree decl ATTRIBUTE_UNUSED
)
749 #ifdef HAVE_GAS_HIDDEN
750 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
751 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
756 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
758 tree method_type
, fndecl
;
760 method_type
= build_java_method_type (function_type
,
761 this_class
, access_flags
);
763 fndecl
= build_decl (input_location
, FUNCTION_DECL
, name
, method_type
);
764 DECL_CONTEXT (fndecl
) = this_class
;
766 DECL_LANG_SPECIFIC (fndecl
)
767 = GGC_CNEW (struct lang_decl
);
768 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
770 /* Initialize the static initializer test table. */
772 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
773 java_treetreehash_create (10, 1);
775 /* Initialize the initialized (static) class table. */
776 if (access_flags
& ACC_STATIC
)
777 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
778 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
780 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
781 TYPE_METHODS (this_class
) = fndecl
;
783 /* If pointers to member functions use the least significant bit to
784 indicate whether a function is virtual, ensure a pointer
785 to this function will have that bit clear. */
786 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
787 && !(access_flags
& ACC_STATIC
)
788 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
789 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
791 /* Notice that this is a finalizer and update the class type
792 accordingly. This is used to optimize instance allocation. */
793 if (name
== finalize_identifier_node
794 && TREE_TYPE (function_type
) == void_type_node
795 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
796 HAS_FINALIZER_P (this_class
) = 1;
798 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
799 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
800 if (access_flags
& ACC_PRIVATE
)
801 METHOD_PRIVATE (fndecl
) = 1;
802 if (access_flags
& ACC_NATIVE
)
804 METHOD_NATIVE (fndecl
) = 1;
805 DECL_EXTERNAL (fndecl
) = 1;
808 /* FNDECL is external unless we are compiling it into this object
810 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
811 if (access_flags
& ACC_STATIC
)
812 METHOD_STATIC (fndecl
) = 1;
813 if (access_flags
& ACC_FINAL
)
814 METHOD_FINAL (fndecl
) = 1;
815 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
816 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
817 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
818 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
819 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
820 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
824 /* Add a method to THIS_CLASS.
825 The method's name is NAME.
826 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
829 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
831 tree function_type
, fndecl
;
832 const unsigned char *sig
833 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
836 fatal_error ("bad method signature");
838 function_type
= get_type_from_signature (method_sig
);
839 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
840 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
845 add_field (tree klass
, tree name
, tree field_type
, int flags
)
847 int is_static
= (flags
& ACC_STATIC
) != 0;
849 field
= build_decl (input_location
,
850 is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
851 TREE_CHAIN (field
) = TYPE_FIELDS (klass
);
852 TYPE_FIELDS (klass
) = field
;
853 DECL_CONTEXT (field
) = klass
;
854 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
856 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
857 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
858 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
859 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
860 if (flags
& ACC_VOLATILE
)
862 FIELD_VOLATILE (field
) = 1;
863 TREE_THIS_VOLATILE (field
) = 1;
865 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
866 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
867 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
870 FIELD_STATIC (field
) = 1;
871 /* Always make field externally visible. This is required so
872 that native methods can always access the field. */
873 TREE_PUBLIC (field
) = 1;
874 /* Hide everything that shouldn't be visible outside a DSO. */
875 if (flag_indirect_classes
876 || (FIELD_PRIVATE (field
)))
877 java_hide_decl (field
);
878 /* Considered external unless we are compiling it into this
880 DECL_EXTERNAL (field
) = (is_compiled_class (klass
) != 2);
886 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
889 set_constant_value (tree field
, tree constant
)
891 if (field
== NULL_TREE
)
892 warning (OPT_Wattributes
,
893 "misplaced ConstantValue attribute (not in any field)");
894 else if (DECL_INITIAL (field
) != NULL_TREE
)
895 warning (OPT_Wattributes
,
896 "duplicate ConstantValue attribute for field '%s'",
897 IDENTIFIER_POINTER (DECL_NAME (field
)));
900 DECL_INITIAL (field
) = constant
;
901 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
902 && ! (TREE_TYPE (constant
) == int_type_node
903 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
904 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
905 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
906 && TREE_TYPE (field
) == string_ptr_type_node
))
907 error ("ConstantValue attribute of field '%s' has wrong type",
908 IDENTIFIER_POINTER (DECL_NAME (field
)));
912 /* Calculate a hash value for a string encoded in Utf8 format.
913 * This returns the same hash value as specified for java.lang.String.hashCode.
917 hashUtf8String (const char *str
, int len
)
919 const unsigned char* ptr
= (const unsigned char*) str
;
920 const unsigned char *limit
= ptr
+ len
;
924 int ch
= UTF8_GET (ptr
, limit
);
925 /* Updated specification from
926 http://www.javasoft.com/docs/books/jls/clarify.html. */
927 hash
= (31 * hash
) + ch
;
932 static GTY(()) tree utf8_decl_list
= NULL_TREE
;
935 build_utf8_ref (tree name
)
937 const char * name_ptr
= IDENTIFIER_POINTER (name
);
938 int name_len
= IDENTIFIER_LENGTH (name
), name_pad
;
940 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
941 static int utf8_count
= 0;
943 tree ref
= IDENTIFIER_UTF8_REF (name
);
945 if (ref
!= NULL_TREE
)
948 ctype
= make_node (RECORD_TYPE
);
949 /* '\0' byte plus padding to utf8const_type's alignment. */
950 name_pad
= TYPE_ALIGN_UNIT (utf8const_type
)
951 - (name_len
& (TYPE_ALIGN_UNIT (utf8const_type
) - 1));
952 str_type
= build_prim_array_type (unsigned_byte_type_node
,
953 name_len
+ name_pad
);
954 PUSH_FIELD (input_location
, ctype
, field
, "hash", unsigned_short_type_node
);
955 PUSH_FIELD (input_location
,
956 ctype
, field
, "length", unsigned_short_type_node
);
957 PUSH_FIELD (input_location
, ctype
, field
, "data", str_type
);
958 FINISH_RECORD (ctype
);
959 START_RECORD_CONSTRUCTOR (cinit
, ctype
);
960 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
961 PUSH_FIELD_VALUE (cinit
, "hash", build_int_cst (NULL_TREE
, name_hash
));
962 PUSH_FIELD_VALUE (cinit
, "length", build_int_cst (NULL_TREE
, name_len
));
963 string
= build_string (name_len
, name_ptr
);
964 TREE_TYPE (string
) = str_type
;
965 PUSH_FIELD_VALUE (cinit
, "data", string
);
966 FINISH_RECORD_CONSTRUCTOR (cinit
);
967 TREE_CONSTANT (cinit
) = 1;
969 /* Generate a unique-enough identifier. */
970 sprintf(buf
, "_Utf%d", ++utf8_count
);
972 decl
= build_decl (input_location
,
973 VAR_DECL
, get_identifier (buf
), utf8const_type
);
974 TREE_STATIC (decl
) = 1;
975 DECL_ARTIFICIAL (decl
) = 1;
976 DECL_IGNORED_P (decl
) = 1;
977 TREE_READONLY (decl
) = 1;
978 TREE_THIS_VOLATILE (decl
) = 0;
979 DECL_INITIAL (decl
) = cinit
;
981 if (HAVE_GAS_SHF_MERGE
)
984 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
985 decl_size
= name_len
+ 4 + name_pad
;
986 if (flag_merge_constants
&& decl_size
< 256)
989 int flags
= (SECTION_OVERRIDE
990 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
991 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
992 switch_to_section (get_section (buf
, flags
, NULL
));
993 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
997 TREE_CHAIN (decl
) = utf8_decl_list
;
998 layout_decl (decl
, 0);
999 DECL_SIZE (decl
) = TYPE_SIZE (ctype
);
1000 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (ctype
);
1002 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
1003 varpool_mark_needed_node (varpool_node (decl
));
1004 utf8_decl_list
= decl
;
1005 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
1006 IDENTIFIER_UTF8_REF (name
) = ref
;
1010 /* Like build_class_ref, but instead of a direct reference generate a
1011 pointer into the constant pool. */
1014 build_indirect_class_ref (tree type
)
1018 index
= alloc_class_constant (type
);
1019 cl
= build_ref_from_constant_pool (index
);
1020 return convert (promote_type (class_ptr_type
), cl
);
1024 build_static_class_ref (tree type
)
1026 tree decl_name
, decl
, ref
;
1028 if (TYPE_SIZE (type
) == error_mark_node
)
1029 return null_pointer_node
;
1030 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1031 "", '/', '/', ".class$$");
1032 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1033 if (decl
== NULL_TREE
)
1035 decl
= build_decl (input_location
, VAR_DECL
, decl_name
, class_type_node
);
1036 TREE_STATIC (decl
) = 1;
1037 if (! flag_indirect_classes
)
1039 TREE_PUBLIC (decl
) = 1;
1040 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1041 java_hide_decl (decl
);
1043 DECL_IGNORED_P (decl
) = 1;
1044 DECL_ARTIFICIAL (decl
) = 1;
1045 if (is_compiled_class (type
) == 1)
1046 DECL_EXTERNAL (decl
) = 1;
1047 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1048 DECL_CLASS_FIELD_P (decl
) = 1;
1049 DECL_CONTEXT (decl
) = type
;
1051 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1052 that that means not calling pushdecl_top_level. */
1053 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1056 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1061 build_classdollar_field (tree type
)
1063 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1064 "", '/', '/', ".class$");
1065 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1067 if (decl
== NULL_TREE
)
1070 = build_decl (input_location
,
1071 VAR_DECL
, decl_name
,
1074 (build_type_variant (class_type_node
,
1076 /* const */ 1, 0)));
1077 TREE_STATIC (decl
) = 1;
1078 TREE_CONSTANT (decl
) = 1;
1079 TREE_READONLY (decl
) = 1;
1080 TREE_PUBLIC (decl
) = 1;
1081 java_hide_decl (decl
);
1082 DECL_IGNORED_P (decl
) = 1;
1083 DECL_ARTIFICIAL (decl
) = 1;
1084 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1085 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1086 DECL_CLASS_FIELD_P (decl
) = 1;
1087 DECL_CONTEXT (decl
) = type
;
1093 /* Create a local variable that holds the current class$. */
1096 cache_this_class_ref (tree fndecl
)
1100 tree classdollar_field
;
1101 if (flag_indirect_classes
)
1102 classdollar_field
= build_classdollar_field (output_class
);
1104 classdollar_field
= build_static_class_ref (output_class
);
1106 this_classdollar
= build_decl (input_location
,
1107 VAR_DECL
, NULL_TREE
,
1108 TREE_TYPE (classdollar_field
));
1110 java_add_local_var (this_classdollar
);
1111 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1112 this_classdollar
, classdollar_field
));
1115 this_classdollar
= build_classdollar_field (output_class
);
1117 /* Prepend class initialization for static methods reachable from
1119 if (METHOD_STATIC (fndecl
)
1120 && (! METHOD_PRIVATE (fndecl
)
1121 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1122 && ! DECL_CLINIT_P (fndecl
)
1123 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1125 tree init
= build_call_expr (soft_initclass_node
, 1,
1127 java_add_stmt (init
);
1131 /* Remove the reference to the local variable that holds the current
1135 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1137 this_classdollar
= build_classdollar_field (output_class
);
1140 /* Build a reference to the class TYPE.
1141 Also handles primitive types and array types. */
1144 build_class_ref (tree type
)
1146 int is_compiled
= is_compiled_class (type
);
1150 if (TREE_CODE (type
) == POINTER_TYPE
)
1151 type
= TREE_TYPE (type
);
1153 if (flag_indirect_dispatch
1154 && type
!= output_class
1155 && TREE_CODE (type
) == RECORD_TYPE
)
1156 return build_indirect_class_ref (type
);
1158 if (type
== output_class
&& flag_indirect_classes
)
1160 /* This can be NULL if we see a JNI stub before we see any
1162 if (! this_classdollar
)
1163 this_classdollar
= build_classdollar_field (output_class
);
1164 return this_classdollar
;
1167 if (TREE_CODE (type
) == RECORD_TYPE
)
1168 return build_static_class_ref (type
);
1174 decl_name
= TYPE_NAME (type
);
1175 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1176 decl_name
= DECL_NAME (decl_name
);
1177 name
= IDENTIFIER_POINTER (decl_name
);
1178 if (strncmp (name
, "promoted_", 9) == 0)
1180 sprintf (buffer
, "_Jv_%sClass", name
);
1181 decl_name
= get_identifier (buffer
);
1182 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1183 if (decl
== NULL_TREE
)
1185 decl
= build_decl (input_location
,
1186 VAR_DECL
, decl_name
, class_type_node
);
1187 TREE_STATIC (decl
) = 1;
1188 TREE_PUBLIC (decl
) = 1;
1189 DECL_EXTERNAL (decl
) = 1;
1190 DECL_ARTIFICIAL (decl
) = 1;
1191 pushdecl_top_level (decl
);
1195 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1199 return build_indirect_class_ref (type
);
1202 /* Create a local statically allocated variable that will hold a
1203 pointer to a static field. */
1206 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1208 tree decl
, decl_name
;
1209 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1210 char *buf
= (char *) alloca (strlen (name
) + 20);
1211 sprintf (buf
, "%s_%d_ref", name
, index
);
1212 decl_name
= get_identifier (buf
);
1213 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1214 if (decl
== NULL_TREE
)
1216 decl
= build_decl (input_location
,
1217 VAR_DECL
, decl_name
, ptr_type_node
);
1218 TREE_STATIC (decl
) = 1;
1219 TREE_PUBLIC (decl
) = 0;
1220 DECL_EXTERNAL (decl
) = 0;
1221 DECL_ARTIFICIAL (decl
) = 1;
1222 DECL_IGNORED_P (decl
) = 1;
1223 pushdecl_top_level (decl
);
1229 build_static_field_ref (tree fdecl
)
1231 tree fclass
= DECL_CONTEXT (fdecl
);
1232 int is_compiled
= is_compiled_class (fclass
);
1234 /* Allow static final fields to fold to a constant. When using
1235 -findirect-dispatch, we simply never do this folding if compiling
1236 from .class; in the .class file constants will be referred to via
1237 the constant pool. */
1238 if (!flag_indirect_dispatch
1240 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1241 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1242 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1243 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1245 if (is_compiled
== 1)
1246 DECL_EXTERNAL (fdecl
) = 1;
1250 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1251 and a class local static variable CACHE_ENTRY, then
1253 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1254 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1257 This can mostly be optimized away, so that the usual path is a
1258 load followed by a test and branch. _Jv_ResolvePoolEntry is
1259 only called once for each constant pool entry.
1261 There is an optimization that we don't do: at the start of a
1262 method, create a local copy of CACHE_ENTRY and use that instead.
1266 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1267 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1269 = build_call_expr (built_in_decls
[BUILT_IN_EXPECT
], 2,
1270 build2 (EQ_EXPR
, boolean_type_node
,
1271 cache_entry
, null_pointer_node
),
1272 boolean_false_node
);
1273 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1275 = build_call_expr (soft_resolvepoolentry_node
, 2,
1276 build_class_ref (output_class
),
1278 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1279 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1280 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1281 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1287 get_access_flags_from_decl (tree decl
)
1289 int access_flags
= 0;
1290 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1292 if (FIELD_STATIC (decl
))
1293 access_flags
|= ACC_STATIC
;
1294 if (FIELD_PUBLIC (decl
))
1295 access_flags
|= ACC_PUBLIC
;
1296 if (FIELD_PROTECTED (decl
))
1297 access_flags
|= ACC_PROTECTED
;
1298 if (FIELD_PRIVATE (decl
))
1299 access_flags
|= ACC_PRIVATE
;
1300 if (FIELD_FINAL (decl
))
1301 access_flags
|= ACC_FINAL
;
1302 if (FIELD_VOLATILE (decl
))
1303 access_flags
|= ACC_VOLATILE
;
1304 if (FIELD_TRANSIENT (decl
))
1305 access_flags
|= ACC_TRANSIENT
;
1306 if (FIELD_ENUM (decl
))
1307 access_flags
|= ACC_ENUM
;
1308 if (FIELD_SYNTHETIC (decl
))
1309 access_flags
|= ACC_SYNTHETIC
;
1310 return access_flags
;
1312 if (TREE_CODE (decl
) == TYPE_DECL
)
1314 if (CLASS_PUBLIC (decl
))
1315 access_flags
|= ACC_PUBLIC
;
1316 if (CLASS_FINAL (decl
))
1317 access_flags
|= ACC_FINAL
;
1318 if (CLASS_SUPER (decl
))
1319 access_flags
|= ACC_SUPER
;
1320 if (CLASS_INTERFACE (decl
))
1321 access_flags
|= ACC_INTERFACE
;
1322 if (CLASS_ABSTRACT (decl
))
1323 access_flags
|= ACC_ABSTRACT
;
1324 if (CLASS_STATIC (decl
))
1325 access_flags
|= ACC_STATIC
;
1326 if (CLASS_PRIVATE (decl
))
1327 access_flags
|= ACC_PRIVATE
;
1328 if (CLASS_PROTECTED (decl
))
1329 access_flags
|= ACC_PROTECTED
;
1330 if (CLASS_STRICTFP (decl
))
1331 access_flags
|= ACC_STRICT
;
1332 if (CLASS_ENUM (decl
))
1333 access_flags
|= ACC_ENUM
;
1334 if (CLASS_SYNTHETIC (decl
))
1335 access_flags
|= ACC_SYNTHETIC
;
1336 if (CLASS_ANNOTATION (decl
))
1337 access_flags
|= ACC_ANNOTATION
;
1338 return access_flags
;
1340 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1342 if (METHOD_PUBLIC (decl
))
1343 access_flags
|= ACC_PUBLIC
;
1344 if (METHOD_PRIVATE (decl
))
1345 access_flags
|= ACC_PRIVATE
;
1346 if (METHOD_PROTECTED (decl
))
1347 access_flags
|= ACC_PROTECTED
;
1348 if (METHOD_STATIC (decl
))
1349 access_flags
|= ACC_STATIC
;
1350 if (METHOD_FINAL (decl
))
1351 access_flags
|= ACC_FINAL
;
1352 if (METHOD_SYNCHRONIZED (decl
))
1353 access_flags
|= ACC_SYNCHRONIZED
;
1354 if (METHOD_NATIVE (decl
))
1355 access_flags
|= ACC_NATIVE
;
1356 if (METHOD_ABSTRACT (decl
))
1357 access_flags
|= ACC_ABSTRACT
;
1358 if (METHOD_STRICTFP (decl
))
1359 access_flags
|= ACC_STRICT
;
1360 if (METHOD_INVISIBLE (decl
))
1361 access_flags
|= ACC_INVISIBLE
;
1362 if (DECL_ARTIFICIAL (decl
))
1363 access_flags
|= ACC_SYNTHETIC
;
1364 if (METHOD_BRIDGE (decl
))
1365 access_flags
|= ACC_BRIDGE
;
1366 if (METHOD_VARARGS (decl
))
1367 access_flags
|= ACC_VARARGS
;
1368 return access_flags
;
1373 static GTY (()) int alias_labelno
= 0;
1375 /* Create a private alias for METHOD. Using this alias instead of the method
1376 decl ensures that ncode entries in the method table point to the real function
1377 at runtime, not a PLT entry. */
1380 make_local_function_alias (tree method
)
1382 #ifdef ASM_OUTPUT_DEF
1385 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1386 char *name
= (char *) alloca (strlen (method_name
) + 2);
1387 char *buf
= (char *) alloca (strlen (method_name
) + 128);
1389 /* Only create aliases for local functions. */
1390 if (DECL_EXTERNAL (method
))
1393 /* Prefix method_name with 'L' for the alias label. */
1395 strcpy (name
+ 1, method_name
);
1397 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1398 alias
= build_decl (input_location
,
1399 FUNCTION_DECL
, get_identifier (buf
),
1400 TREE_TYPE (method
));
1401 DECL_CONTEXT (alias
) = NULL
;
1402 TREE_READONLY (alias
) = TREE_READONLY (method
);
1403 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1404 TREE_PUBLIC (alias
) = 0;
1405 DECL_EXTERNAL (alias
) = 0;
1406 DECL_ARTIFICIAL (alias
) = 1;
1407 DECL_INITIAL (alias
) = error_mark_node
;
1408 TREE_ADDRESSABLE (alias
) = 1;
1409 TREE_USED (alias
) = 1;
1410 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1411 if (!flag_syntax_only
)
1412 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1419 /** Make reflection data (_Jv_Field) for field FDECL. */
1422 make_field_value (tree fdecl
)
1426 tree type
= TREE_TYPE (fdecl
);
1427 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1429 START_RECORD_CONSTRUCTOR (finit
, field_type_node
);
1430 PUSH_FIELD_VALUE (finit
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1432 type
= build_class_ref (type
);
1435 tree signature
= build_java_signature (type
);
1437 type
= build_utf8_ref (unmangle_classname
1438 (IDENTIFIER_POINTER (signature
),
1439 IDENTIFIER_LENGTH (signature
)));
1441 PUSH_FIELD_VALUE (finit
, "type", type
);
1443 flags
= get_access_flags_from_decl (fdecl
);
1445 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1447 PUSH_FIELD_VALUE (finit
, "accflags", build_int_cst (NULL_TREE
, flags
));
1448 PUSH_FIELD_VALUE (finit
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1451 tree field_address
= integer_zero_node
;
1452 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1453 && FIELD_STATIC (fdecl
))
1454 field_address
= build_address_of (fdecl
);
1458 build_constructor_from_list (field_info_union_node
,
1460 ((FIELD_STATIC (fdecl
)
1461 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1462 : TYPE_FIELDS (field_info_union_node
)),
1463 (FIELD_STATIC (fdecl
)
1465 : byte_position (fdecl
)))));
1468 FINISH_RECORD_CONSTRUCTOR (finit
);
1472 /** Make reflection data (_Jv_Method) for method MDECL. */
1475 make_method_value (tree mdecl
)
1477 static int method_name_count
= 0;
1482 #define ACC_TRANSLATED 0x4000
1483 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1485 class_decl
= DECL_CONTEXT (mdecl
);
1486 /* For interfaces, the index field contains the dispatch index. */
1487 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1488 index
= build_int_cst (NULL_TREE
,
1489 get_interface_method_index (mdecl
, class_decl
));
1490 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1491 index
= get_method_index (mdecl
);
1493 index
= integer_minus_one_node
;
1495 code
= null_pointer_node
;
1496 if (METHOD_ABSTRACT (mdecl
))
1497 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1498 soft_abstractmethod_node
);
1500 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1501 make_local_function_alias (mdecl
));
1502 START_RECORD_CONSTRUCTOR (minit
, method_type_node
);
1503 PUSH_FIELD_VALUE (minit
, "name",
1504 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1505 init_identifier_node
1506 : DECL_NAME (mdecl
)));
1508 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1509 PUSH_FIELD_VALUE (minit
, "signature",
1512 (IDENTIFIER_POINTER(signature
),
1513 IDENTIFIER_LENGTH(signature
)))));
1515 PUSH_FIELD_VALUE (minit
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1516 PUSH_FIELD_VALUE (minit
, "index", index
);
1517 PUSH_FIELD_VALUE (minit
, "ncode", code
);
1520 /* Compute the `throws' information for the method. */
1521 tree table
= null_pointer_node
;
1522 if (DECL_FUNCTION_THROWS (mdecl
) != NULL_TREE
)
1524 int length
= 1 + list_length (DECL_FUNCTION_THROWS (mdecl
));
1525 tree iter
, type
, array
;
1528 table
= tree_cons (NULL_TREE
, table
, NULL_TREE
);
1529 for (iter
= DECL_FUNCTION_THROWS (mdecl
);
1531 iter
= TREE_CHAIN (iter
))
1533 tree sig
= DECL_NAME (TYPE_NAME (TREE_VALUE (iter
)));
1535 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1536 IDENTIFIER_LENGTH (sig
)));
1537 table
= tree_cons (NULL_TREE
, utf8
, table
);
1539 type
= build_prim_array_type (ptr_type_node
, length
);
1540 table
= build_constructor_from_list (type
, table
);
1541 /* Compute something unique enough. */
1542 sprintf (buf
, "_methods%d", method_name_count
++);
1543 array
= build_decl (input_location
,
1544 VAR_DECL
, get_identifier (buf
), type
);
1545 DECL_INITIAL (array
) = table
;
1546 TREE_STATIC (array
) = 1;
1547 DECL_ARTIFICIAL (array
) = 1;
1548 DECL_IGNORED_P (array
) = 1;
1549 rest_of_decl_compilation (array
, 1, 0);
1551 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1554 PUSH_FIELD_VALUE (minit
, "throws", table
);
1557 FINISH_RECORD_CONSTRUCTOR (minit
);
1562 get_dispatch_vector (tree type
)
1564 tree vtable
= TYPE_VTABLE (type
);
1566 if (vtable
== NULL_TREE
)
1570 tree super
= CLASSTYPE_SUPER (type
);
1571 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1572 vtable
= make_tree_vec (nvirtuals
);
1573 TYPE_VTABLE (type
) = vtable
;
1574 if (super
!= NULL_TREE
)
1576 tree super_vtable
= get_dispatch_vector (super
);
1578 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1579 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1582 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1583 method
= TREE_CHAIN (method
))
1585 tree method_index
= get_method_index (method
);
1586 if (method_index
!= NULL_TREE
1587 && host_integerp (method_index
, 0))
1588 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1596 get_dispatch_table (tree type
, tree this_class_addr
)
1598 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1599 tree vtable
= get_dispatch_vector (type
);
1601 tree list
= NULL_TREE
;
1602 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1606 for (i
= nvirtuals
; --i
>= 0; )
1608 tree method
= TREE_VEC_ELT (vtable
, i
);
1609 if (METHOD_ABSTRACT (method
))
1612 warning_at (DECL_SOURCE_LOCATION (method
), 0,
1613 "abstract method in non-abstract class");
1615 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1616 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1617 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1619 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1623 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1624 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1626 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1627 method
, build_int_cst (NULL_TREE
, j
));
1628 TREE_CONSTANT (fdesc
) = 1;
1629 list
= tree_cons (NULL_TREE
, fdesc
, list
);
1632 list
= tree_cons (NULL_TREE
,
1633 build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1639 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1640 using the Boehm GC we sometimes stash a GC type descriptor
1641 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1642 the emitted byte count during the output to the assembly file. */
1643 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1644 fake "function descriptor". It's first word is the is the class
1645 pointer, and subsequent words (usually one) contain the GC descriptor.
1646 In all other cases, we reserve two extra vtable slots. */
1647 gc_descr
= get_boehm_type_descriptor (type
);
1648 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1649 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1650 list
= tree_cons (NULL_TREE
, gc_descr
, list
);
1651 list
= tree_cons (NULL_TREE
, this_class_addr
, list
);
1653 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1654 list
= tree_cons (NULL_TREE
, null_pointer_node
, list
);
1655 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1656 list
= tree_cons (integer_zero_node
, null_pointer_node
, list
);
1658 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1659 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1660 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1662 return build_constructor_from_list
1663 (build_prim_array_type (nativecode_ptr_type_node
,
1668 /* Set the method_index for a method decl. */
1670 set_method_index (tree decl
, tree method_index
)
1672 if (method_index
!= NULL_TREE
)
1674 /* method_index is null if we're using indirect dispatch. */
1675 method_index
= fold (convert (sizetype
, method_index
));
1677 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1678 /* Add one to skip bogus descriptor for class and GC descriptor. */
1679 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1681 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1683 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1686 DECL_VINDEX (decl
) = method_index
;
1689 /* Get the method_index for a method decl. */
1691 get_method_index (tree decl
)
1693 tree method_index
= DECL_VINDEX (decl
);
1698 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1699 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1700 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1702 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1703 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1705 return method_index
;
1709 supers_all_compiled (tree type
)
1711 while (type
!= NULL_TREE
)
1713 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1715 type
= CLASSTYPE_SUPER (type
);
1721 make_class_data (tree type
)
1723 tree decl
, cons
, temp
;
1724 tree field
, fields_decl
;
1725 tree static_fields
= NULL_TREE
;
1726 tree instance_fields
= NULL_TREE
;
1727 HOST_WIDE_INT static_field_count
= 0;
1728 HOST_WIDE_INT instance_field_count
= 0;
1729 HOST_WIDE_INT field_count
;
1730 tree field_array_type
;
1732 tree methods
= NULL_TREE
;
1733 tree dtable_decl
= NULL_TREE
;
1734 HOST_WIDE_INT method_count
= 0;
1735 tree method_array_type
;
1738 tree this_class_addr
;
1739 tree constant_pool_constructor
;
1740 tree interfaces
= null_pointer_node
;
1741 int interface_len
= 0;
1742 int uses_jv_markobj
= 0;
1743 tree type_decl
= TYPE_NAME (type
);
1744 tree id_main
= get_identifier("main");
1745 tree id_class
= get_identifier("java.lang.Class");
1746 /** Offset from start of virtual function table declaration
1747 to where objects actually point at, following new g++ ABI. */
1748 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1749 VEC(int, heap
) *field_indexes
;
1750 tree first_real_field
;
1752 this_class_addr
= build_static_class_ref (type
);
1753 decl
= TREE_OPERAND (this_class_addr
, 0);
1755 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1756 && !flag_indirect_dispatch
)
1758 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1759 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1760 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1762 /* We've already created some other class, and consequently
1763 we made class_dtable_decl. Now we just want to fill it
1765 dtable_decl
= class_dtable_decl
;
1769 dtable_decl
= build_dtable_decl (type
);
1770 TREE_STATIC (dtable_decl
) = 1;
1771 DECL_ARTIFICIAL (dtable_decl
) = 1;
1772 DECL_IGNORED_P (dtable_decl
) = 1;
1775 TREE_PUBLIC (dtable_decl
) = 1;
1776 DECL_INITIAL (dtable_decl
) = dtable
;
1777 /* The only dispatch table exported from a DSO is the dispatch
1778 table for java.lang.Class. */
1779 if (DECL_NAME (type_decl
) != id_class
)
1780 java_hide_decl (dtable_decl
);
1781 if (! flag_indirect_classes
)
1782 rest_of_decl_compilation (dtable_decl
, 1, 0);
1783 /* Maybe we're compiling Class as the first class. If so, set
1784 class_dtable_decl to the decl we just made. */
1785 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1786 class_dtable_decl
= dtable_decl
;
1789 /* Build Field array. */
1790 field
= TYPE_FIELDS (type
);
1791 while (field
&& DECL_ARTIFICIAL (field
))
1792 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1793 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1794 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1795 first_real_field
= field
;
1797 /* First count static and instance fields. */
1798 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1800 if (! DECL_ARTIFICIAL (field
))
1802 if (FIELD_STATIC (field
))
1803 static_field_count
++;
1804 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1805 instance_field_count
++;
1808 field_count
= static_field_count
+ instance_field_count
;
1809 field_indexes
= VEC_alloc (int, heap
, field_count
);
1811 /* gcj sorts fields so that static fields come first, followed by
1812 instance fields. Unfortunately, by the time this takes place we
1813 have already generated the reflection_data for this class, and
1814 that data contains indexes into the fields. So, we generate a
1815 permutation that maps each original field index to its final
1816 position. Then we pass this permutation to
1817 rewrite_reflection_indexes(), which fixes up the reflection
1821 int static_count
= 0;
1822 int instance_count
= static_field_count
;
1825 for (i
= 0, field
= first_real_field
;
1827 field
= TREE_CHAIN (field
), i
++)
1829 if (! DECL_ARTIFICIAL (field
))
1832 if (FIELD_STATIC (field
))
1833 field_index
= static_count
++;
1834 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1835 field_index
= instance_count
++;
1838 VEC_quick_push (int, field_indexes
, field_index
);
1843 for (field
= first_real_field
; field
!= NULL_TREE
;
1844 field
= TREE_CHAIN (field
))
1846 if (! DECL_ARTIFICIAL (field
))
1848 if (FIELD_STATIC (field
))
1850 /* We must always create reflection data for static fields
1851 as it is used in the creation of the field itself. */
1852 tree init
= make_field_value (field
);
1853 tree initial
= DECL_INITIAL (field
);
1854 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1855 /* If the initial value is a string constant,
1856 prevent output_constant from trying to assemble the value. */
1857 if (initial
!= NULL_TREE
1858 && TREE_TYPE (initial
) == string_ptr_type_node
)
1859 DECL_INITIAL (field
) = NULL_TREE
;
1860 rest_of_decl_compilation (field
, 1, 1);
1861 DECL_INITIAL (field
) = initial
;
1863 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1865 tree init
= make_field_value (field
);
1866 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1871 if (field_count
> 0)
1873 static_fields
= nreverse (static_fields
);
1874 instance_fields
= nreverse (instance_fields
);
1875 static_fields
= chainon (static_fields
, instance_fields
);
1876 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1877 fields_decl
= build_decl (input_location
,
1878 VAR_DECL
, mangled_classname ("_FL_", type
),
1880 DECL_INITIAL (fields_decl
) = build_constructor_from_list
1881 (field_array_type
, static_fields
);
1882 TREE_STATIC (fields_decl
) = 1;
1883 DECL_ARTIFICIAL (fields_decl
) = 1;
1884 DECL_IGNORED_P (fields_decl
) = 1;
1885 rest_of_decl_compilation (fields_decl
, 1, 0);
1888 fields_decl
= NULL_TREE
;
1890 /* Build Method array. */
1891 for (method
= TYPE_METHODS (type
);
1892 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1895 if (METHOD_PRIVATE (method
)
1896 && ! flag_keep_inline_functions
1899 /* Even if we have a decl, we don't necessarily have the code.
1900 This can happen if we inherit a method from a superclass for
1901 which we don't have a .class file. */
1902 if (METHOD_DUMMY (method
))
1905 /* Generate method reflection data if:
1907 - !flag_reduced_reflection.
1909 - <clinit> -- The runtime uses reflection to initialize the
1912 - Any method in class java.lang.Class -- Class.forName() and
1913 perhaps other things require it.
1915 - class$ -- It does not work if reflection data missing.
1917 - main -- Reflection is used to find main(String[]) methods.
1919 - public not static -- It is potentially part of an
1920 interface. The runtime uses reflection data to build
1921 interface dispatch tables. */
1922 if (!flag_reduced_reflection
1923 || DECL_CLINIT_P (method
)
1924 || DECL_NAME (type_decl
) == id_class
1925 || DECL_NAME (method
) == id_main
1926 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1928 init
= make_method_value (method
);
1930 methods
= tree_cons (NULL_TREE
, init
, methods
);
1933 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1934 methods_decl
= build_decl (input_location
,
1935 VAR_DECL
, mangled_classname ("_MT_", type
),
1937 DECL_INITIAL (methods_decl
) = build_constructor_from_list
1938 (method_array_type
, nreverse (methods
));
1939 TREE_STATIC (methods_decl
) = 1;
1940 DECL_ARTIFICIAL (methods_decl
) = 1;
1941 DECL_IGNORED_P (methods_decl
) = 1;
1942 rest_of_decl_compilation (methods_decl
, 1, 0);
1944 if (class_dtable_decl
== NULL_TREE
)
1946 class_dtable_decl
= build_dtable_decl (class_type_node
);
1947 TREE_STATIC (class_dtable_decl
) = 1;
1948 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1949 DECL_IGNORED_P (class_dtable_decl
) = 1;
1950 if (is_compiled_class (class_type_node
) != 2)
1952 DECL_EXTERNAL (class_dtable_decl
) = 1;
1953 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1957 super
= CLASSTYPE_SUPER (type
);
1958 if (super
== NULL_TREE
)
1959 super
= null_pointer_node
;
1960 else if (! flag_indirect_dispatch
1961 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1962 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1963 super
= build_class_ref (super
);
1966 int super_index
= alloc_class_constant (super
);
1967 super
= build_int_cst (ptr_type_node
, super_index
);
1970 /* Build and emit the array of implemented interfaces. */
1971 if (type
!= object_type_node
)
1972 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1974 if (interface_len
> 0)
1976 tree init
= NULL_TREE
;
1978 tree interface_array_type
, idecl
;
1979 interface_array_type
1980 = build_prim_array_type (class_ptr_type
, interface_len
);
1981 idecl
= build_decl (input_location
,
1982 VAR_DECL
, mangled_classname ("_IF_", type
),
1983 interface_array_type
);
1985 for (i
= interface_len
; i
> 0; i
--)
1987 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1988 tree iclass
= BINFO_TYPE (child
);
1990 if (! flag_indirect_dispatch
1992 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
1993 index
= build_class_ref (iclass
);
1996 int int_index
= alloc_class_constant (iclass
);
1997 index
= build_int_cst (ptr_type_node
, int_index
);
1999 init
= tree_cons (NULL_TREE
, index
, init
);
2001 DECL_INITIAL (idecl
) = build_constructor_from_list (interface_array_type
,
2003 TREE_STATIC (idecl
) = 1;
2004 DECL_ARTIFICIAL (idecl
) = 1;
2005 DECL_IGNORED_P (idecl
) = 1;
2006 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
2007 rest_of_decl_compilation (idecl
, 1, 0);
2010 constant_pool_constructor
= build_constants_constructor ();
2012 if (flag_indirect_dispatch
)
2014 TYPE_OTABLE_DECL (type
)
2016 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
2017 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
2018 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
2020 TYPE_ATABLE_DECL (type
)
2022 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
2023 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
2024 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2026 TYPE_ITABLE_DECL (type
)
2028 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2029 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2030 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2033 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2035 START_RECORD_CONSTRUCTOR (temp
, object_type_node
);
2036 PUSH_FIELD_VALUE (temp
, "vtable",
2037 (flag_indirect_classes
2039 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2040 build1 (ADDR_EXPR
, dtable_ptr_type
,
2042 dtable_start_offset
)));
2043 if (! flag_hash_synchronization
)
2044 PUSH_FIELD_VALUE (temp
, "sync_info", null_pointer_node
);
2045 FINISH_RECORD_CONSTRUCTOR (temp
);
2046 START_RECORD_CONSTRUCTOR (cons
, class_type_node
);
2047 PUSH_SUPER_VALUE (cons
, temp
);
2048 PUSH_FIELD_VALUE (cons
, "next_or_version", gcj_abi_version
);
2049 PUSH_FIELD_VALUE (cons
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2050 PUSH_FIELD_VALUE (cons
, "accflags",
2051 build_int_cst (NULL_TREE
,
2052 get_access_flags_from_decl (type_decl
)));
2054 PUSH_FIELD_VALUE (cons
, "superclass",
2055 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2056 PUSH_FIELD_VALUE (cons
, "constants", constant_pool_constructor
);
2057 PUSH_FIELD_VALUE (cons
, "methods",
2058 methods_decl
== NULL_TREE
? null_pointer_node
2059 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2060 PUSH_FIELD_VALUE (cons
, "method_count",
2061 build_int_cst (NULL_TREE
, method_count
));
2063 if (flag_indirect_dispatch
)
2064 PUSH_FIELD_VALUE (cons
, "vtable_method_count", integer_minus_one_node
);
2066 PUSH_FIELD_VALUE (cons
, "vtable_method_count", TYPE_NVIRTUALS (type
));
2068 PUSH_FIELD_VALUE (cons
, "fields",
2069 fields_decl
== NULL_TREE
? null_pointer_node
2070 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2071 /* If we're using the binary compatibility ABI we don't know the
2072 size until load time. */
2073 PUSH_FIELD_VALUE (cons
, "size_in_bytes",
2074 (flag_indirect_dispatch
2075 ? integer_minus_one_node
2076 : size_in_bytes (type
)));
2077 PUSH_FIELD_VALUE (cons
, "field_count",
2078 build_int_cst (NULL_TREE
, field_count
));
2079 PUSH_FIELD_VALUE (cons
, "static_field_count",
2080 build_int_cst (NULL_TREE
, static_field_count
));
2082 if (flag_indirect_dispatch
)
2083 PUSH_FIELD_VALUE (cons
, "vtable", null_pointer_node
);
2085 PUSH_FIELD_VALUE (cons
, "vtable",
2086 dtable_decl
== NULL_TREE
? null_pointer_node
2087 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2088 build1 (ADDR_EXPR
, dtable_ptr_type
,
2090 dtable_start_offset
));
2091 if (TYPE_OTABLE_METHODS (type
) == NULL_TREE
)
2093 PUSH_FIELD_VALUE (cons
, "otable", null_pointer_node
);
2094 PUSH_FIELD_VALUE (cons
, "otable_syms", null_pointer_node
);
2098 pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type
));
2099 PUSH_FIELD_VALUE (cons
, "otable",
2100 build1 (ADDR_EXPR
, otable_ptr_type
, TYPE_OTABLE_DECL (type
)));
2101 PUSH_FIELD_VALUE (cons
, "otable_syms",
2102 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2103 TYPE_OTABLE_SYMS_DECL (type
)));
2104 TREE_CONSTANT (TYPE_OTABLE_DECL (type
)) = 1;
2106 if (TYPE_ATABLE_METHODS(type
) == NULL_TREE
)
2108 PUSH_FIELD_VALUE (cons
, "atable", null_pointer_node
);
2109 PUSH_FIELD_VALUE (cons
, "atable_syms", null_pointer_node
);
2113 pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type
));
2114 PUSH_FIELD_VALUE (cons
, "atable",
2115 build1 (ADDR_EXPR
, atable_ptr_type
, TYPE_ATABLE_DECL (type
)));
2116 PUSH_FIELD_VALUE (cons
, "atable_syms",
2117 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2118 TYPE_ATABLE_SYMS_DECL (type
)));
2119 TREE_CONSTANT (TYPE_ATABLE_DECL (type
)) = 1;
2121 if (TYPE_ITABLE_METHODS(type
) == NULL_TREE
)
2123 PUSH_FIELD_VALUE (cons
, "itable", null_pointer_node
);
2124 PUSH_FIELD_VALUE (cons
, "itable_syms", null_pointer_node
);
2128 pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type
));
2129 PUSH_FIELD_VALUE (cons
, "itable",
2130 build1 (ADDR_EXPR
, itable_ptr_type
, TYPE_ITABLE_DECL (type
)));
2131 PUSH_FIELD_VALUE (cons
, "itable_syms",
2132 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
2133 TYPE_ITABLE_SYMS_DECL (type
)));
2134 TREE_CONSTANT (TYPE_ITABLE_DECL (type
)) = 1;
2137 PUSH_FIELD_VALUE (cons
, "catch_classes",
2138 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2139 PUSH_FIELD_VALUE (cons
, "interfaces", interfaces
);
2140 PUSH_FIELD_VALUE (cons
, "loader", null_pointer_node
);
2141 PUSH_FIELD_VALUE (cons
, "interface_count",
2142 build_int_cst (NULL_TREE
, interface_len
));
2143 PUSH_FIELD_VALUE (cons
, "state",
2144 convert (byte_type_node
,
2145 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2147 PUSH_FIELD_VALUE (cons
, "thread", null_pointer_node
);
2148 PUSH_FIELD_VALUE (cons
, "depth", integer_zero_node
);
2149 PUSH_FIELD_VALUE (cons
, "ancestors", null_pointer_node
);
2150 PUSH_FIELD_VALUE (cons
, "idt", null_pointer_node
);
2151 PUSH_FIELD_VALUE (cons
, "arrayclass", null_pointer_node
);
2152 PUSH_FIELD_VALUE (cons
, "protectionDomain", null_pointer_node
);
2155 tree assertion_table_ref
;
2156 if (TYPE_ASSERTIONS (type
) == NULL
)
2157 assertion_table_ref
= null_pointer_node
;
2159 assertion_table_ref
= build1 (ADDR_EXPR
,
2160 build_pointer_type (assertion_table_type
),
2161 emit_assertion_table (type
));
2163 PUSH_FIELD_VALUE (cons
, "assertion_table", assertion_table_ref
);
2166 PUSH_FIELD_VALUE (cons
, "hack_signers", null_pointer_node
);
2167 PUSH_FIELD_VALUE (cons
, "chain", null_pointer_node
);
2168 PUSH_FIELD_VALUE (cons
, "aux_info", null_pointer_node
);
2169 PUSH_FIELD_VALUE (cons
, "engine", null_pointer_node
);
2171 if (TYPE_REFLECTION_DATA (current_class
))
2174 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2175 VEC (constructor_elt
, gc
) *v
2176 = VEC_alloc (constructor_elt
, gc
, count
);
2177 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2178 tree max_index
= build_int_cst (sizetype
, count
);
2179 tree index
= build_index_type (max_index
);
2180 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2183 static int reflection_data_count
;
2185 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2186 array
= build_decl (input_location
,
2187 VAR_DECL
, get_identifier (buf
), type
);
2189 rewrite_reflection_indexes (field_indexes
);
2191 for (i
= 0; i
< count
; i
++)
2193 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
2194 elt
->index
= build_int_cst (sizetype
, i
);
2195 elt
->value
= build_int_cstu (byte_type_node
, data
[i
]);
2198 DECL_INITIAL (array
) = build_constructor (type
, v
);
2199 TREE_STATIC (array
) = 1;
2200 DECL_ARTIFICIAL (array
) = 1;
2201 DECL_IGNORED_P (array
) = 1;
2202 TREE_READONLY (array
) = 1;
2203 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2204 rest_of_decl_compilation (array
, 1, 0);
2206 PUSH_FIELD_VALUE (cons
, "reflection_data", build_address_of (array
));
2209 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2212 PUSH_FIELD_VALUE (cons
, "reflection_data", null_pointer_node
);
2214 FINISH_RECORD_CONSTRUCTOR (cons
);
2216 DECL_INITIAL (decl
) = cons
;
2218 /* Hash synchronization requires at least 64-bit alignment. */
2219 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2220 DECL_ALIGN (decl
) = 64;
2222 if (flag_indirect_classes
)
2224 TREE_READONLY (decl
) = 1;
2225 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2228 rest_of_decl_compilation (decl
, 1, 0);
2231 tree classdollar_field
= build_classdollar_field (type
);
2232 if (!flag_indirect_classes
)
2233 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2234 rest_of_decl_compilation (classdollar_field
, 1, 0);
2237 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2238 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2239 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2245 java_expand_catch_classes (current_class
);
2247 current_function_decl
= NULL_TREE
;
2248 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2249 make_class_data (current_class
);
2251 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2254 /* Return 2 if KLASS is compiled by this compilation job;
2255 return 1 if KLASS can otherwise be assumed to be compiled;
2256 return 0 if we cannot assume that KLASS is compiled.
2257 Returns 1 for primitive and 0 for array types. */
2259 is_compiled_class (tree klass
)
2262 if (TREE_CODE (klass
) == POINTER_TYPE
)
2263 klass
= TREE_TYPE (klass
);
2264 if (TREE_CODE (klass
) != RECORD_TYPE
) /* Primitive types are static. */
2266 if (TYPE_ARRAY_P (klass
))
2269 seen_in_zip
= (TYPE_JCF (klass
) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass
)));
2270 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2272 /* The class was seen in the current ZIP file and will be
2273 available as a compiled class in the future but may not have
2274 been loaded already. Load it if necessary. This prevent
2275 build_class_ref () from crashing. */
2277 if (seen_in_zip
&& !CLASS_LOADED_P (klass
) && (klass
!= current_class
))
2278 load_class (klass
, 1);
2280 /* We return 2 for class seen in ZIP and class from files
2281 belonging to the same compilation unit */
2285 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass
)))))
2287 if (!CLASS_LOADED_P (klass
))
2289 if (klass
!= current_class
)
2290 load_class (klass
, 1);
2298 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2301 build_dtable_decl (tree type
)
2305 /* We need to build a new dtable type so that its size is uniquely
2306 computed when we're dealing with the class for real and not just
2307 faking it (like java.lang.Class during the initialization of the
2308 compiler.) We know we're not faking a class when CURRENT_CLASS is
2310 if (current_class
== type
)
2312 tree dummy
= NULL_TREE
;
2315 dtype
= make_node (RECORD_TYPE
);
2317 PUSH_FIELD (input_location
, dtype
, dummy
, "top_offset", ptr_type_node
);
2318 PUSH_FIELD (input_location
, dtype
, dummy
, "type_info", ptr_type_node
);
2320 PUSH_FIELD (input_location
, dtype
, dummy
, "class", class_ptr_type
);
2321 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2323 tree tmp_field
= build_decl (input_location
,
2324 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2325 TREE_CHAIN (dummy
) = tmp_field
;
2326 DECL_CONTEXT (tmp_field
) = dtype
;
2327 DECL_ARTIFICIAL (tmp_field
) = 1;
2331 PUSH_FIELD (input_location
, dtype
, dummy
, "gc_descr", ptr_type_node
);
2332 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2334 tree tmp_field
= build_decl (input_location
,
2335 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2336 TREE_CHAIN (dummy
) = tmp_field
;
2337 DECL_CONTEXT (tmp_field
) = dtype
;
2338 DECL_ARTIFICIAL (tmp_field
) = 1;
2342 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2343 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2344 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2346 PUSH_FIELD (input_location
, dtype
, dummy
, "methods",
2347 build_prim_array_type (nativecode_ptr_type_node
, n
));
2348 layout_type (dtype
);
2351 dtype
= dtable_type
;
2353 decl
= build_decl (input_location
,
2354 VAR_DECL
, get_identifier ("vt$"), dtype
);
2355 DECL_CONTEXT (decl
) = type
;
2356 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2357 DECL_VTABLE_P (decl
) = 1;
2362 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2363 fields inherited from SUPER_CLASS. */
2366 push_super_field (tree this_class
, tree super_class
)
2369 /* Don't insert the field if we're just re-laying the class out. */
2370 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2372 base_decl
= build_decl (input_location
,
2373 FIELD_DECL
, NULL_TREE
, super_class
);
2374 DECL_IGNORED_P (base_decl
) = 1;
2375 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2376 TYPE_FIELDS (this_class
) = base_decl
;
2377 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2378 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2381 /* Handle the different manners we may have to lay out a super class. */
2384 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2388 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2390 if (!CLASS_LOADED_P (super_class
))
2391 load_class (super_class
, 1);
2393 /* We might have to layout the class before its dependency on
2394 the super class gets resolved by java_complete_class */
2395 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2397 if (TREE_TYPE (super_class
) != NULL_TREE
)
2398 super_class
= TREE_TYPE (super_class
);
2402 if (!TYPE_SIZE (super_class
))
2403 safe_layout_class (super_class
);
2408 /* safe_layout_class just makes sure that we can load a class without
2409 disrupting the current_class, input_file, input_line, etc, information
2410 about the class processed currently. */
2413 safe_layout_class (tree klass
)
2415 tree save_current_class
= current_class
;
2416 location_t save_location
= input_location
;
2418 layout_class (klass
);
2420 current_class
= save_current_class
;
2421 input_location
= save_location
;
2425 layout_class (tree this_class
)
2428 tree super_class
= CLASSTYPE_SUPER (this_class
);
2430 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2431 if (CLASS_BEING_LAIDOUT (this_class
))
2437 sprintf (buffer
, " with '%s'",
2438 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2439 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2441 for (current
= TREE_CHAIN (class_list
); current
;
2442 current
= TREE_CHAIN (current
))
2444 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2445 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2446 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2447 DECL_SOURCE_FILE (decl
),
2448 DECL_SOURCE_LINE (decl
));
2449 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2451 obstack_1grow (&temporary_obstack
, '\0');
2452 report
= XOBFINISH (&temporary_obstack
, char *);
2453 cyclic_inheritance_report
= ggc_strdup (report
);
2454 obstack_free (&temporary_obstack
, report
);
2455 TYPE_SIZE (this_class
) = error_mark_node
;
2458 CLASS_BEING_LAIDOUT (this_class
) = 1;
2460 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2462 tree maybe_super_class
2463 = maybe_layout_super_class (super_class
, this_class
);
2464 if (maybe_super_class
== NULL
2465 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2467 TYPE_SIZE (this_class
) = error_mark_node
;
2468 CLASS_BEING_LAIDOUT (this_class
) = 0;
2469 class_list
= TREE_CHAIN (class_list
);
2472 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2473 push_super_field (this_class
, maybe_super_class
);
2476 layout_type (this_class
);
2478 /* Also recursively load/layout any superinterfaces. */
2479 if (TYPE_BINFO (this_class
))
2481 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2483 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2484 tree super_interface
= BINFO_TYPE (binfo
);
2485 tree maybe_super_interface
2486 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2487 if (maybe_super_interface
== NULL
2488 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2490 TYPE_SIZE (this_class
) = error_mark_node
;
2491 CLASS_BEING_LAIDOUT (this_class
) = 0;
2492 class_list
= TREE_CHAIN (class_list
);
2498 /* Convert the size back to an SI integer value. */
2499 TYPE_SIZE_UNIT (this_class
) =
2500 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2502 CLASS_BEING_LAIDOUT (this_class
) = 0;
2503 class_list
= TREE_CHAIN (class_list
);
2507 add_miranda_methods (tree base_class
, tree search_class
)
2510 tree binfo
, base_binfo
;
2512 if (!CLASS_PARSED_P (search_class
))
2513 load_class (search_class
, 1);
2515 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2516 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2519 tree elt
= BINFO_TYPE (base_binfo
);
2521 /* FIXME: This is totally bogus. We should not be handling
2522 Miranda methods at all if we're using the BC ABI. */
2523 if (TYPE_DUMMY (elt
))
2526 /* Ensure that interface methods are seen in declared order. */
2527 if (!CLASS_LOADED_P (elt
))
2528 load_class (elt
, 1);
2529 layout_class_methods (elt
);
2531 /* All base classes will have been laid out at this point, so the order
2532 will be correct. This code must match similar layout code in the
2534 for (method_decl
= TYPE_METHODS (elt
);
2535 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2539 /* An interface can have <clinit>. */
2540 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2543 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2544 override
= lookup_argument_method (base_class
,
2545 DECL_NAME (method_decl
), sig
);
2546 if (override
== NULL_TREE
)
2548 /* Found a Miranda method. Add it. */
2550 sig
= build_java_signature (TREE_TYPE (method_decl
));
2552 = add_method (base_class
,
2553 get_access_flags_from_decl (method_decl
),
2554 DECL_NAME (method_decl
), sig
);
2555 METHOD_INVISIBLE (new_method
) = 1;
2559 /* Try superinterfaces. */
2560 add_miranda_methods (base_class
, elt
);
2565 layout_class_methods (tree this_class
)
2567 tree method_decl
, dtable_count
;
2568 tree super_class
, type_name
;
2570 if (TYPE_NVIRTUALS (this_class
))
2573 super_class
= CLASSTYPE_SUPER (this_class
);
2577 super_class
= maybe_layout_super_class (super_class
, this_class
);
2578 if (!TYPE_NVIRTUALS (super_class
))
2579 layout_class_methods (super_class
);
2580 dtable_count
= TYPE_NVIRTUALS (super_class
);
2583 dtable_count
= integer_zero_node
;
2585 type_name
= TYPE_NAME (this_class
);
2586 if (!flag_indirect_dispatch
2587 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2589 /* An abstract class can have methods which are declared only in
2590 an implemented interface. These are called "Miranda
2591 methods". We make a dummy method entry for such methods
2593 add_miranda_methods (this_class
, this_class
);
2596 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2598 for (method_decl
= TYPE_METHODS (this_class
);
2599 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2600 dtable_count
= layout_class_method (this_class
, super_class
,
2601 method_decl
, dtable_count
);
2603 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2606 /* Return the index of METHOD in INTERFACE. This index begins at 1
2607 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2609 get_interface_method_index (tree method
, tree interface
)
2614 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
))
2618 /* We don't want to put <clinit> into the interface table. */
2619 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2621 gcc_assert (meth
!= NULL_TREE
);
2625 /* Lay METHOD_DECL out, returning a possibly new value of
2626 DTABLE_COUNT. Also mangle the method's name. */
2629 layout_class_method (tree this_class
, tree super_class
,
2630 tree method_decl
, tree dtable_count
)
2632 tree method_name
= DECL_NAME (method_decl
);
2634 TREE_PUBLIC (method_decl
) = 1;
2636 if (flag_indirect_classes
2637 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2638 && ! METHOD_NATIVE (method_decl
)
2639 && ! special_method_p (method_decl
)))
2640 java_hide_decl (method_decl
);
2642 /* Considered external unless it is being compiled into this object
2643 file, or it was already flagged as external. */
2644 if (!DECL_EXTERNAL (method_decl
))
2645 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2646 || METHOD_NATIVE (method_decl
));
2648 if (ID_INIT_P (method_name
))
2650 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2652 for (ptr
= p
; *ptr
; )
2657 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2658 build_java_signature (TREE_TYPE (method_decl
));
2660 else if (! METHOD_STATIC (method_decl
))
2663 build_java_signature (TREE_TYPE (method_decl
));
2664 bool method_override
= false;
2665 tree super_method
= lookup_java_method (super_class
, method_name
,
2667 if (super_method
!= NULL_TREE
2668 && ! METHOD_DUMMY (super_method
))
2670 method_override
= true;
2671 if (! METHOD_PUBLIC (super_method
) &&
2672 ! METHOD_PROTECTED (super_method
))
2674 /* Don't override private method, or default-access method in
2676 if (METHOD_PRIVATE (super_method
) ||
2677 ! in_same_package (TYPE_NAME (this_class
),
2678 TYPE_NAME (super_class
)))
2679 method_override
= false;
2682 if (method_override
)
2684 tree method_index
= get_method_index (super_method
);
2685 set_method_index (method_decl
, method_index
);
2686 if (method_index
== NULL_TREE
2687 && ! flag_indirect_dispatch
2688 && ! DECL_ARTIFICIAL (super_method
))
2689 error ("non-static method %q+D overrides static method",
2692 else if (this_class
== object_type_node
2693 && (METHOD_FINAL (method_decl
)
2694 || METHOD_PRIVATE (method_decl
)))
2696 /* We don't generate vtable entries for final Object
2697 methods. This is simply to save space, since every
2698 object would otherwise have to define them. */
2700 else if (! METHOD_PRIVATE (method_decl
)
2703 /* We generate vtable entries for final methods because they
2704 may one day be changed to non-final. */
2705 set_method_index (method_decl
, dtable_count
);
2706 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2707 dtable_count
, integer_one_node
);
2711 return dtable_count
;
2715 register_class (void)
2719 if (!registered_class
)
2720 registered_class
= VEC_alloc (tree
, gc
, 8);
2722 if (flag_indirect_classes
)
2723 node
= current_class
;
2725 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2726 VEC_safe_push (tree
, gc
, registered_class
, node
);
2729 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2730 all the classes we have emitted. */
2733 emit_indirect_register_classes (tree
*list_p
)
2735 tree klass
, t
, register_class_fn
;
2738 tree init
= NULL_TREE
;
2739 int size
= VEC_length (tree
, registered_class
) * 2 + 1;
2740 tree class_array_type
2741 = build_prim_array_type (ptr_type_node
, size
);
2742 tree
cdecl = build_decl (input_location
,
2743 VAR_DECL
, get_identifier ("_Jv_CLS"),
2745 tree reg_class_list
;
2746 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2748 init
= tree_cons (NULL_TREE
,
2749 fold_convert (ptr_type_node
,
2750 build_static_class_ref (klass
)), init
);
2753 fold_convert (ptr_type_node
,
2754 build_address_of (build_classdollar_field (klass
))),
2757 init
= tree_cons (NULL_TREE
, integer_zero_node
, init
);
2758 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type
,
2760 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2761 TREE_STATIC (cdecl) = 1;
2762 DECL_ARTIFICIAL (cdecl) = 1;
2763 DECL_IGNORED_P (cdecl) = 1;
2764 TREE_READONLY (cdecl) = 1;
2765 TREE_CONSTANT (cdecl) = 1;
2766 rest_of_decl_compilation (cdecl, 1, 0);
2767 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2769 t
= build_function_type_list (void_type_node
,
2770 build_pointer_type (ptr_type_node
), NULL
);
2771 t
= build_decl (input_location
,
2773 get_identifier ("_Jv_RegisterNewClasses"), t
);
2774 TREE_PUBLIC (t
) = 1;
2775 DECL_EXTERNAL (t
) = 1;
2776 register_class_fn
= t
;
2777 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2778 append_to_statement_list (t
, list_p
);
2782 /* Emit something to register classes at start-up time.
2784 The preferred mechanism is through the .jcr section, which contain
2785 a list of pointers to classes which get registered during constructor
2788 The fallback mechanism is to add statements to *LIST_P to call
2789 _Jv_RegisterClass for each class in this file. These statements will
2790 be added to a static constructor function for this translation unit. */
2793 emit_register_classes (tree
*list_p
)
2795 if (registered_class
== NULL
)
2798 if (flag_indirect_classes
)
2800 emit_indirect_register_classes (list_p
);
2804 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2805 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2806 but lack suitable crtbegin/end objects or linker support. These
2807 targets can override the default in tm.h to use the fallback mechanism. */
2808 if (TARGET_USE_JCR_SECTION
)
2813 #ifdef JCR_SECTION_NAME
2814 switch_to_section (get_section (JCR_SECTION_NAME
, SECTION_WRITE
, NULL
));
2816 /* A target has defined TARGET_USE_JCR_SECTION,
2817 but doesn't have a JCR_SECTION_NAME. */
2820 assemble_align (POINTER_SIZE
);
2822 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2824 t
= build_fold_addr_expr (klass
);
2825 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2830 tree klass
, t
, register_class_fn
;
2833 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2834 t
= build_decl (input_location
,
2835 FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2836 TREE_PUBLIC (t
) = 1;
2837 DECL_EXTERNAL (t
) = 1;
2838 register_class_fn
= t
;
2840 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2842 t
= build_fold_addr_expr (klass
);
2843 t
= build_call_expr (register_class_fn
, 1, t
);
2844 append_to_statement_list (t
, list_p
);
2849 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2852 build_symbol_entry (tree decl
, tree special
)
2854 tree clname
, name
, signature
, sym
;
2855 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2856 /* ??? Constructors are given the name foo.foo all the way through
2857 the compiler, but in the method table they're all renamed
2858 foo.<init>. So, we have to do the same here unless we want an
2859 unresolved reference at runtime. */
2860 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2861 && DECL_CONSTRUCTOR_P (decl
))
2862 ? init_identifier_node
2863 : DECL_NAME (decl
));
2864 signature
= build_java_signature (TREE_TYPE (decl
));
2865 signature
= build_utf8_ref (unmangle_classname
2866 (IDENTIFIER_POINTER (signature
),
2867 IDENTIFIER_LENGTH (signature
)));
2868 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2869 signature addr+1 if SPECIAL, and this indicates to the runtime
2870 system that this is a "special" symbol, i.e. one that should
2871 bypass access controls. */
2872 if (special
!= NULL_TREE
)
2873 signature
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (signature
), signature
,
2874 fold_convert (sizetype
, special
));
2876 START_RECORD_CONSTRUCTOR (sym
, symbol_type
);
2877 PUSH_FIELD_VALUE (sym
, "clname", clname
);
2878 PUSH_FIELD_VALUE (sym
, "name", name
);
2879 PUSH_FIELD_VALUE (sym
, "signature", signature
);
2880 FINISH_RECORD_CONSTRUCTOR (sym
);
2881 TREE_CONSTANT (sym
) = 1;
2886 /* Emit a symbol table: used by -findirect-dispatch. */
2889 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2890 tree the_syms_decl
, tree the_array_element_type
,
2893 tree method_list
, method
, table
, list
, null_symbol
;
2894 tree table_size
, the_array_type
;
2897 /* Only emit a table if this translation unit actually made any
2898 references via it. */
2899 if (decl_list
== NULL_TREE
)
2902 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2904 method_list
= decl_list
;
2906 while (method_list
!= NULL_TREE
)
2908 tree special
= TREE_PURPOSE (method_list
);
2909 method
= TREE_VALUE (method_list
);
2910 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
, special
), list
);
2911 method_list
= TREE_CHAIN (method_list
);
2915 /* Terminate the list with a "null" entry. */
2916 START_RECORD_CONSTRUCTOR (null_symbol
, symbol_type
);
2917 PUSH_FIELD_VALUE (null_symbol
, "clname", null_pointer_node
);
2918 PUSH_FIELD_VALUE (null_symbol
, "name", null_pointer_node
);
2919 PUSH_FIELD_VALUE (null_symbol
, "signature", null_pointer_node
);
2920 FINISH_RECORD_CONSTRUCTOR (null_symbol
);
2921 TREE_CONSTANT (null_symbol
) = 1;
2922 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2924 /* Put the list in the right order and make it a constructor. */
2925 list
= nreverse (list
);
2926 table
= build_constructor_from_list (symbols_array_type
, list
);
2928 /* Make it the initial value for otable_syms and emit the decl. */
2929 DECL_INITIAL (the_syms_decl
) = table
;
2930 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2931 DECL_IGNORED_P (the_syms_decl
) = 1;
2932 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2934 /* Now that its size is known, redefine the table as an
2935 uninitialized static array of INDEX + 1 elements. The extra entry
2936 is used by the runtime to track whether the table has been
2939 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2940 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2941 the_table
= build_decl (input_location
,
2942 VAR_DECL
, name
, the_array_type
);
2943 TREE_STATIC (the_table
) = 1;
2944 TREE_READONLY (the_table
) = 1;
2945 rest_of_decl_compilation (the_table
, 1, 0);
2950 /* Make an entry for the catch_classes list. */
2952 make_catch_class_record (tree catch_class
, tree classname
)
2955 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2956 START_RECORD_CONSTRUCTOR (entry
, type
);
2957 PUSH_FIELD_VALUE (entry
, "address", catch_class
);
2958 PUSH_FIELD_VALUE (entry
, "classname", classname
);
2959 FINISH_RECORD_CONSTRUCTOR (entry
);
2964 /* Generate the list of Throwable classes that are caught by exception
2965 handlers in this class. */
2967 emit_catch_table (tree this_class
)
2969 tree table
, table_size
, array_type
;
2970 TYPE_CATCH_CLASSES (this_class
) =
2972 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2973 TYPE_CATCH_CLASSES (this_class
));
2974 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2975 TYPE_CATCH_CLASSES (this_class
) =
2977 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2978 TYPE_CATCH_CLASSES (this_class
));
2979 table_size
= build_index_type
2980 (build_int_cst (NULL_TREE
,
2981 list_length (TYPE_CATCH_CLASSES (this_class
))));
2983 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2986 build_decl (input_location
,
2987 VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2988 DECL_INITIAL (table
) =
2989 build_constructor_from_list (array_type
, TYPE_CATCH_CLASSES (this_class
));
2990 TREE_STATIC (table
) = 1;
2991 TREE_READONLY (table
) = 1;
2992 DECL_IGNORED_P (table
) = 1;
2993 rest_of_decl_compilation (table
, 1, 0);
2997 /* Given a type, return the signature used by
2998 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2999 same as build_java_signature() because we want the canonical array
3003 build_signature_for_libgcj (tree type
)
3007 sig
= build_java_signature (type
);
3008 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
3009 IDENTIFIER_LENGTH (sig
)));
3013 /* Add an entry to the type assertion table. Callback used during hashtable
3017 add_assertion_table_entry (void **htab_entry
, void *ptr
)
3020 tree code_val
, op1_utf8
, op2_utf8
;
3021 tree
*list
= (tree
*) ptr
;
3022 type_assertion
*as
= (type_assertion
*) *htab_entry
;
3024 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
3026 if (as
->op1
== NULL_TREE
)
3027 op1_utf8
= null_pointer_node
;
3029 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3031 if (as
->op2
== NULL_TREE
)
3032 op2_utf8
= null_pointer_node
;
3034 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3036 START_RECORD_CONSTRUCTOR (entry
, assertion_entry_type
);
3037 PUSH_FIELD_VALUE (entry
, "assertion_code", code_val
);
3038 PUSH_FIELD_VALUE (entry
, "op1", op1_utf8
);
3039 PUSH_FIELD_VALUE (entry
, "op2", op2_utf8
);
3040 FINISH_RECORD_CONSTRUCTOR (entry
);
3042 *list
= tree_cons (NULL_TREE
, entry
, *list
);
3046 /* Generate the type assertion table for KLASS, and return its DECL. */
3049 emit_assertion_table (tree klass
)
3051 tree null_entry
, ctor
, table_decl
;
3052 tree list
= NULL_TREE
;
3053 htab_t assertions_htab
= TYPE_ASSERTIONS (klass
);
3055 /* Iterate through the hash table. */
3056 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
3058 /* Finish with a null entry. */
3059 START_RECORD_CONSTRUCTOR (null_entry
, assertion_entry_type
);
3060 PUSH_FIELD_VALUE (null_entry
, "assertion_code", integer_zero_node
);
3061 PUSH_FIELD_VALUE (null_entry
, "op1", null_pointer_node
);
3062 PUSH_FIELD_VALUE (null_entry
, "op2", null_pointer_node
);
3063 FINISH_RECORD_CONSTRUCTOR (null_entry
);
3065 list
= tree_cons (NULL_TREE
, null_entry
, list
);
3067 /* Put the list in the right order and make it a constructor. */
3068 list
= nreverse (list
);
3069 ctor
= build_constructor_from_list (assertion_table_type
, list
);
3071 table_decl
= build_decl (input_location
,
3072 VAR_DECL
, mangled_classname ("_type_assert_", klass
),
3073 assertion_table_type
);
3075 TREE_STATIC (table_decl
) = 1;
3076 TREE_READONLY (table_decl
) = 1;
3077 TREE_CONSTANT (table_decl
) = 1;
3078 DECL_IGNORED_P (table_decl
) = 1;
3080 DECL_INITIAL (table_decl
) = ctor
;
3081 DECL_ARTIFICIAL (table_decl
) = 1;
3082 rest_of_decl_compilation (table_decl
, 1, 0);
3088 init_class_processing (void)
3090 fields_ident
= get_identifier ("fields");
3091 info_ident
= get_identifier ("info");
3093 gcc_obstack_init (&temporary_obstack
);
3096 static hashval_t
java_treetreehash_hash (const void *);
3097 static int java_treetreehash_compare (const void *, const void *);
3099 /* A hash table mapping trees to trees. Used generally. */
3101 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3104 java_treetreehash_hash (const void *k_p
)
3106 const struct treetreehash_entry
*const k
3107 = (const struct treetreehash_entry
*) k_p
;
3108 return JAVA_TREEHASHHASH_H (k
->key
);
3112 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3114 const struct treetreehash_entry
*const k1
3115 = (const struct treetreehash_entry
*) k1_p
;
3116 const_tree
const k2
= (const_tree
) k2_p
;
3117 return (k1
->key
== k2
);
3121 java_treetreehash_find (htab_t ht
, tree t
)
3123 struct treetreehash_entry
*e
;
3124 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3125 e
= (struct treetreehash_entry
*) htab_find_with_hash (ht
, t
, hv
);
3133 java_treetreehash_new (htab_t ht
, tree t
)
3136 struct treetreehash_entry
*tthe
;
3137 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3139 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3142 tthe
= (struct treetreehash_entry
*) (*ht
->alloc_f
) (1, sizeof (*tthe
));
3147 tthe
= (struct treetreehash_entry
*) *e
;
3148 return &tthe
->value
;
3152 java_treetreehash_create (size_t size
, int gc
)
3155 return htab_create_ggc (size
, java_treetreehash_hash
,
3156 java_treetreehash_compare
, NULL
);
3158 return htab_create_alloc (size
, java_treetreehash_hash
,
3159 java_treetreehash_compare
, free
, xcalloc
, free
);
3162 /* Break down qualified IDENTIFIER into package and class-name components.
3163 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3164 "pkg.foo", and RIGHT to "Bar". */
3167 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3170 int l
= IDENTIFIER_LENGTH (source
);
3172 base
= (char *) alloca (l
+ 1);
3173 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3175 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3177 while (*p
!= '.' && p
!= base
)
3180 /* We didn't find a '.'. Return an error. */
3186 *right
= get_identifier (p
+1);
3187 *left
= get_identifier (base
);
3192 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3193 if the classes are from the same package. */
3196 in_same_package (tree name1
, tree name2
)
3202 if (TREE_CODE (name1
) == TYPE_DECL
)
3203 name1
= DECL_NAME (name1
);
3204 if (TREE_CODE (name2
) == TYPE_DECL
)
3205 name2
= DECL_NAME (name2
);
3207 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3208 /* One in empty package. */
3211 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3212 /* Both in empty package. */
3215 split_qualified_name (&pkg1
, &tmp
, name1
);
3216 split_qualified_name (&pkg2
, &tmp
, name2
);
3218 return (pkg1
== pkg2
);
3221 #include "gt-java-class.h"