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, 2010 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"
32 #include "java-tree.h"
42 #include "tree-iterator.h"
44 #include "tm.h" /* FIXME: For gcc_obstack_init from defaults.h. */
46 /* DOS brain-damage */
48 #define O_BINARY 0 /* MS-DOS brain-damage */
51 static tree
make_method_value (tree
);
52 static tree
build_java_method_type (tree
, tree
, int);
53 static int32
hashUtf8String (const char *, int);
54 static tree
make_field_value (tree
);
55 static tree
get_dispatch_vector (tree
);
56 static tree
get_dispatch_table (tree
, tree
);
57 static int supers_all_compiled (tree type
);
58 static tree
maybe_layout_super_class (tree
, tree
);
59 static void add_miranda_methods (tree
, tree
);
60 static int assume_compiled (const char *);
61 static tree
build_symbol_entry (tree
, tree
);
62 static tree
emit_assertion_table (tree
);
63 static void register_class (void);
65 struct obstack temporary_obstack
;
67 static const char *cyclic_inheritance_report
;
69 /* The compiler generates different code depending on whether or not
70 it can assume certain classes have been compiled down to native
71 code or not. The compiler options -fassume-compiled= and
72 -fno-assume-compiled= are used to create a tree of
73 class_flag_node objects. This tree is queried to determine if
74 a class is assume to be compiled or not. Each node in the tree
75 represents either a package or a specific class. */
77 typedef struct class_flag_node_struct
79 /* The class or package name. */
82 /* Nonzero if this represents an exclusion. */
85 /* Pointers to other nodes in the tree. */
86 struct class_flag_node_struct
*parent
;
87 struct class_flag_node_struct
*sibling
;
88 struct class_flag_node_struct
*child
;
91 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
92 static void add_class_flag (class_flag_node
**, const char *, int);
94 /* This is the root of the include/exclude tree. */
96 static class_flag_node
*assume_compiled_tree
;
98 static class_flag_node
*enable_assert_tree
;
100 static GTY(()) tree class_roots
[4];
101 #define fields_ident class_roots[0] /* get_identifier ("fields") */
102 #define info_ident class_roots[1] /* get_identifier ("info") */
103 #define class_list class_roots[2]
104 #define class_dtable_decl class_roots[3]
106 static GTY(()) VEC(tree
,gc
) *registered_class
;
108 /* A tree that returns the address of the class$ of the class
109 currently being compiled. */
110 static GTY(()) tree this_classdollar
;
112 /* A list of static class fields. This is to emit proper debug
114 VEC(tree
,gc
) *pending_static_fields
;
116 /* Return the node that most closely represents the class whose name
117 is IDENT. Start the search from NODE (followed by its siblings).
118 Return NULL if an appropriate node does not exist. */
120 static class_flag_node
*
121 find_class_flag_node (class_flag_node
*node
, const char *ident
)
125 size_t node_ident_length
= strlen (node
->ident
);
127 /* node_ident_length is zero at the root of the tree. If the
128 identifiers are the same length, then we have matching
129 classes. Otherwise check if we've matched an enclosing
132 if (node_ident_length
== 0
133 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
134 && (ident
[node_ident_length
] == '\0'
135 || ident
[node_ident_length
] == '.')))
137 /* We've found a match, however, there might be a more
140 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
147 /* No match yet. Continue through the sibling list. */
148 node
= node
->sibling
;
151 /* No match at all in this tree. */
156 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
158 class_flag_node
*root
= *rootp
;
159 class_flag_node
*parent
, *node
;
161 /* Create the root of the tree if it doesn't exist yet. */
165 root
= XNEW (class_flag_node
);
168 root
->sibling
= NULL
;
174 /* Calling the function with the empty string means we're setting
175 value for the root of the hierarchy. */
183 /* Find the parent node for this new node. PARENT will either be a
184 class or a package name. Adjust PARENT accordingly. */
186 parent
= find_class_flag_node (root
, ident
);
187 if (strcmp (ident
, parent
->ident
) == 0)
188 parent
->value
= value
;
191 /* Insert new node into the tree. */
192 node
= XNEW (class_flag_node
);
194 node
->ident
= xstrdup (ident
);
198 node
->parent
= parent
;
199 node
->sibling
= parent
->child
;
200 parent
->child
= node
;
204 /* Add a new IDENT to the include/exclude tree. It's an exclusion
205 if EXCLUDEP is nonzero. */
208 add_assume_compiled (const char *ident
, int excludep
)
210 add_class_flag (&assume_compiled_tree
, ident
, excludep
);
213 /* The default value returned by enable_assertions. */
215 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
217 /* Enter IDENT (a class or package name) into the enable-assertions table.
218 VALUE is true to enable and false to disable. */
221 add_enable_assert (const char *ident
, int value
)
223 if (enable_assert_tree
== NULL
)
224 add_class_flag (&enable_assert_tree
, "", DEFAULT_ENABLE_ASSERT
);
225 add_class_flag (&enable_assert_tree
, ident
, value
);
228 /* Returns nonzero if IDENT is the name of a class that the compiler
229 should assume has been compiled to object code. */
232 assume_compiled (const char *ident
)
237 if (NULL
== assume_compiled_tree
)
240 i
= find_class_flag_node (assume_compiled_tree
, ident
);
247 /* Return true if we should generate code to check assertions within KLASS. */
250 enable_assertions (tree klass
)
252 /* Check if command-line specifies whether we should check assertions. */
254 if (klass
!= NULL_TREE
&& DECL_NAME (klass
) && enable_assert_tree
!= NULL
)
256 const char *ident
= IDENTIFIER_POINTER (DECL_NAME (klass
));
257 class_flag_node
*node
258 = find_class_flag_node (enable_assert_tree
, ident
);
262 /* The default is to enable assertions if generating class files,
263 or not optimizing. */
264 return DEFAULT_ENABLE_ASSERT
;
267 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
268 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
269 Also, PREFIX is prepended, and SUFFIX is appended. */
272 ident_subst (const char* old_name
,
279 int prefix_len
= strlen (prefix
);
280 int suffix_len
= strlen (suffix
);
281 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
282 char *buffer
= (char *) alloca (i
);
284 strcpy (buffer
, prefix
);
285 for (i
= 0; i
< old_length
; i
++)
287 char ch
= old_name
[i
];
290 buffer
[prefix_len
+ i
] = ch
;
292 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
293 return get_identifier (buffer
);
296 /* Return an IDENTIFIER_NODE the same as OLD_ID,
297 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
298 Also, PREFIX is prepended, and SUFFIX is appended. */
301 identifier_subst (const tree old_id
,
307 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
308 prefix
, old_char
, new_char
, suffix
);
311 /* Generate a valid C identifier from the name of the class TYPE,
312 prefixed by PREFIX. */
315 mangled_classname (const char *prefix
, tree type
)
318 tree ident
= TYPE_NAME (type
);
319 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
320 ident
= DECL_NAME (ident
);
321 result
= identifier_subst (ident
, prefix
, '.', '_', "");
323 /* Replace any characters that aren't in the set [0-9a-zA-Z_$] with
324 "_0xXX". Class names containing such chracters are uncommon, but
325 they do sometimes occur in class files. Without this check,
326 these names cause assembly errors.
328 There is a possibility that a real class name could conflict with
329 the identifier we generate, but it is unlikely and will
330 immediately be detected as an assembler error. At some point we
331 should do something more elaborate (perhaps using the full
332 unicode mangling scheme) in order to prevent such a conflict. */
335 const int len
= IDENTIFIER_LENGTH (result
);
336 const char *p
= IDENTIFIER_POINTER (result
);
337 int illegal_chars
= 0;
339 /* Make two passes over the identifier. The first pass is merely
340 to count illegal characters; we need to do this in order to
341 allocate a buffer. */
342 for (i
= 0; i
< len
; i
++)
345 illegal_chars
+= (! ISALNUM (c
) && c
!= '_' && c
!= '$');
348 /* And the second pass, which is rarely executed, does the
350 if (illegal_chars
!= 0)
352 char *buffer
= (char *) alloca (illegal_chars
* 4 + len
+ 1);
355 for (i
= 0, j
= 0; i
< len
; i
++)
358 if (! ISALNUM (c
) && c
!= '_' && c
!= '$')
361 sprintf (&buffer
[j
], "0x%02x", c
);
369 result
= get_identifier (buffer
);
380 type
= make_node (RECORD_TYPE
);
381 /* Unfortunately we must create the binfo here, so that class
383 TYPE_BINFO (type
) = make_tree_binfo (0);
384 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
389 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
390 and where each of the constituents is separated by '/',
391 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
394 unmangle_classname (const char *name
, int name_length
)
396 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
397 /* It's not sufficient to compare to_return and get_identifier
398 (name) to determine whether to_return is qualified. There are
399 cases in signature analysis where name will be stripped of a
401 name
= IDENTIFIER_POINTER (to_return
);
405 QUALIFIED_P (to_return
) = 1;
412 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
415 const char *type_name = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
416 char *buf = (char *) alloca (strlen (type_name) \
417 + strlen (#NAME "_syms_") + 1); \
420 sprintf (buf, #NAME "_%s", type_name); \
421 TYPE_## TABLE ##_DECL (type) = decl = \
422 build_decl (input_location, VAR_DECL, get_identifier (buf), TABLE_TYPE); \
423 DECL_EXTERNAL (decl) = 1; \
424 TREE_STATIC (decl) = 1; \
425 TREE_READONLY (decl) = 1; \
426 TREE_CONSTANT (decl) = 1; \
427 DECL_IGNORED_P (decl) = 1; \
428 /* Mark the table as belonging to this class. */ \
430 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
431 DECL_OWNER (decl) = TYPE; \
432 sprintf (buf, #NAME "_syms_%s", type_name); \
433 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
434 build_decl (input_location, VAR_DECL, get_identifier (buf), symbols_array_type); \
435 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
436 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
437 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
441 /* Given a class, create the DECLs for all its associated indirect
444 gen_indirect_dispatch_tables (tree type
)
446 const char *type_name
= IDENTIFIER_POINTER (mangled_classname ("", type
));
449 char *buf
= (char *) alloca (strlen (type_name
)
450 + strlen ("_catch_classes_") + 1);
451 tree catch_class_type
= make_node (RECORD_TYPE
);
453 sprintf (buf
, "_catch_classes_%s", type_name
);
454 PUSH_FIELD (input_location
,
455 catch_class_type
, field
, "address", utf8const_ptr_type
);
456 PUSH_FIELD (input_location
,
457 catch_class_type
, field
, "classname", ptr_type_node
);
458 FINISH_RECORD (catch_class_type
);
460 TYPE_CTABLE_DECL (type
)
461 = build_decl (input_location
, VAR_DECL
, get_identifier (buf
),
462 build_array_type (catch_class_type
, 0));
463 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
464 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
465 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
466 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
467 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
468 pushdecl (TYPE_CTABLE_DECL (type
));
471 if (flag_indirect_dispatch
)
473 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
474 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
475 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
482 push_class (tree class_type
, tree class_name
)
484 tree decl
, signature
;
485 location_t saved_loc
= input_location
;
486 CLASS_P (class_type
) = 1;
487 decl
= build_decl (input_location
, TYPE_DECL
, class_name
, class_type
);
488 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
490 /* dbxout needs a DECL_SIZE if in gstabs mode */
491 DECL_SIZE (decl
) = integer_zero_node
;
493 input_location
= saved_loc
;
494 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
495 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
497 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
498 both a typedef and in the struct name-space. We may want to re-visit
499 this later, but for now it reduces the changes needed for gdb. */
500 DECL_ARTIFICIAL (decl
) = 1;
502 pushdecl_top_level (decl
);
507 /* Finds the (global) class named NAME. Creates the class if not found.
508 Also creates associated TYPE_DECL.
509 Does not check if the class actually exists, load the class,
510 fill in field or methods, or do layout_type. */
513 lookup_class (tree name
)
515 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
516 if (decl
== NULL_TREE
)
517 decl
= push_class (make_class (), name
);
518 return TREE_TYPE (decl
);
522 set_super_info (int access_flags
, tree this_class
,
523 tree super_class
, int interfaces_count
)
525 int total_supers
= interfaces_count
;
526 tree class_decl
= TYPE_NAME (this_class
);
532 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
533 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
536 tree super_binfo
= make_tree_binfo (0);
537 BINFO_TYPE (super_binfo
) = super_class
;
538 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
539 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
540 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
543 set_class_decl_access_flags (access_flags
, class_decl
);
547 set_class_decl_access_flags (int access_flags
, tree class_decl
)
549 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
550 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
551 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
552 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
553 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
554 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
555 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
556 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
557 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
558 if (access_flags
& ACC_ENUM
) CLASS_ENUM (class_decl
) = 1;
559 if (access_flags
& ACC_SYNTHETIC
) CLASS_SYNTHETIC (class_decl
) = 1;
560 if (access_flags
& ACC_ANNOTATION
) CLASS_ANNOTATION (class_decl
) = 1;
563 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
564 direct sub-classes of Object are 1, and so on. */
567 class_depth (tree clas
)
570 if (! CLASS_LOADED_P (clas
))
571 load_class (clas
, 1);
572 if (TYPE_SIZE (clas
) == error_mark_node
)
574 while (clas
!= object_type_node
)
577 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
582 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
585 interface_of_p (tree type1
, tree type2
)
588 tree binfo
, base_binfo
;
590 if (! TYPE_BINFO (type2
))
593 for (binfo
= TYPE_BINFO (type2
), i
= 0;
594 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
595 if (BINFO_TYPE (base_binfo
) == type1
)
598 for (binfo
= TYPE_BINFO (type2
), i
= 0;
599 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
600 if (BINFO_TYPE (base_binfo
)
601 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
607 /* Return true iff TYPE1 inherits from TYPE2. */
610 inherits_from_p (tree type1
, tree type2
)
612 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
617 if (! CLASS_LOADED_P (type1
))
618 load_class (type1
, 1);
620 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
625 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
628 enclosing_context_p (tree type1
, tree type2
)
630 if (!INNER_CLASS_TYPE_P (type2
))
633 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
635 type2
= (INNER_CLASS_TYPE_P (type2
) ?
636 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
646 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
650 common_enclosing_context_p (tree type1
, tree type2
)
655 for (current
= type2
; current
;
656 current
= (INNER_CLASS_TYPE_P (current
) ?
657 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
659 if (type1
== current
)
662 if (INNER_CLASS_TYPE_P (type1
))
663 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
670 /* Return 1 iff there exists a common enclosing "this" between TYPE1
671 and TYPE2, without crossing any static context. */
674 common_enclosing_instance_p (tree type1
, tree type2
)
676 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
679 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
680 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
681 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
684 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
685 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
686 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
688 if (type1
== current
)
694 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
695 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
696 if attempt is made to add it twice. */
699 maybe_add_interface (tree this_class
, tree interface_class
)
701 tree binfo
, base_binfo
;
704 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
705 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
706 if (BINFO_TYPE (base_binfo
) == interface_class
)
707 return interface_class
;
708 add_interface (this_class
, interface_class
);
712 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
715 add_interface (tree this_class
, tree interface_class
)
717 tree interface_binfo
= make_tree_binfo (0);
719 BINFO_TYPE (interface_binfo
) = interface_class
;
720 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
721 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
722 BINFO_VIRTUAL_P (interface_binfo
) = 1;
724 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
728 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
730 if (access_flags
& ACC_STATIC
)
732 fntype
= build_method_type (this_class
, fntype
);
734 /* We know that arg 1 of every nonstatic method is non-null; tell
736 TYPE_ATTRIBUTES (fntype
) = (tree_cons
737 (get_identifier ("nonnull"),
738 tree_cons (NULL_TREE
,
739 build_int_cst (NULL_TREE
, 1),
741 TYPE_ATTRIBUTES (fntype
)));
746 java_hide_decl (tree decl ATTRIBUTE_UNUSED
)
748 #ifdef HAVE_GAS_HIDDEN
749 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
750 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
755 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
757 tree method_type
, fndecl
;
759 method_type
= build_java_method_type (function_type
,
760 this_class
, access_flags
);
762 fndecl
= build_decl (input_location
, FUNCTION_DECL
, name
, method_type
);
763 DECL_CONTEXT (fndecl
) = this_class
;
765 DECL_LANG_SPECIFIC (fndecl
)
766 = GGC_CNEW (struct lang_decl
);
767 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
769 /* Initialize the static initializer test table. */
771 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) =
772 java_treetreehash_create (10, 1);
774 /* Initialize the initialized (static) class table. */
775 if (access_flags
& ACC_STATIC
)
776 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
777 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
779 TREE_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
780 TYPE_METHODS (this_class
) = fndecl
;
782 /* If pointers to member functions use the least significant bit to
783 indicate whether a function is virtual, ensure a pointer
784 to this function will have that bit clear. */
785 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
786 && !(access_flags
& ACC_STATIC
)
787 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
788 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
790 /* Notice that this is a finalizer and update the class type
791 accordingly. This is used to optimize instance allocation. */
792 if (name
== finalize_identifier_node
793 && TREE_TYPE (function_type
) == void_type_node
794 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
795 HAS_FINALIZER_P (this_class
) = 1;
797 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
798 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
799 if (access_flags
& ACC_PRIVATE
)
800 METHOD_PRIVATE (fndecl
) = 1;
801 if (access_flags
& ACC_NATIVE
)
803 METHOD_NATIVE (fndecl
) = 1;
804 DECL_EXTERNAL (fndecl
) = 1;
807 /* FNDECL is external unless we are compiling it into this object
809 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
810 if (access_flags
& ACC_STATIC
)
811 METHOD_STATIC (fndecl
) = 1;
812 if (access_flags
& ACC_FINAL
)
813 METHOD_FINAL (fndecl
) = 1;
814 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
815 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
816 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
817 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
818 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
819 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
823 /* Add a method to THIS_CLASS.
824 The method's name is NAME.
825 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
828 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
830 tree function_type
, fndecl
;
831 const unsigned char *sig
832 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
835 fatal_error ("bad method signature");
837 function_type
= get_type_from_signature (method_sig
);
838 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
839 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
844 add_field (tree klass
, tree name
, tree field_type
, int flags
)
846 int is_static
= (flags
& ACC_STATIC
) != 0;
848 field
= build_decl (input_location
,
849 is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
850 TREE_CHAIN (field
) = TYPE_FIELDS (klass
);
851 TYPE_FIELDS (klass
) = field
;
852 DECL_CONTEXT (field
) = klass
;
853 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
855 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
856 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
857 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
858 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
859 if (flags
& ACC_VOLATILE
)
861 FIELD_VOLATILE (field
) = 1;
862 TREE_THIS_VOLATILE (field
) = 1;
864 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
865 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
866 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
869 FIELD_STATIC (field
) = 1;
870 /* Always make field externally visible. This is required so
871 that native methods can always access the field. */
872 TREE_PUBLIC (field
) = 1;
873 /* Hide everything that shouldn't be visible outside a DSO. */
874 if (flag_indirect_classes
875 || (FIELD_PRIVATE (field
)))
876 java_hide_decl (field
);
877 /* Considered external unless we are compiling it into this
879 DECL_EXTERNAL (field
) = (is_compiled_class (klass
) != 2);
880 if (!DECL_EXTERNAL (field
))
881 VEC_safe_push (tree
, gc
, pending_static_fields
, field
);
887 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
890 set_constant_value (tree field
, tree constant
)
892 if (field
== NULL_TREE
)
893 warning (OPT_Wattributes
,
894 "misplaced ConstantValue attribute (not in any field)");
895 else if (DECL_INITIAL (field
) != NULL_TREE
)
896 warning (OPT_Wattributes
,
897 "duplicate ConstantValue attribute for field '%s'",
898 IDENTIFIER_POINTER (DECL_NAME (field
)));
901 DECL_INITIAL (field
) = constant
;
902 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
903 && ! (TREE_TYPE (constant
) == int_type_node
904 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
905 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
906 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
907 && TREE_TYPE (field
) == string_ptr_type_node
))
908 error ("ConstantValue attribute of field '%s' has wrong type",
909 IDENTIFIER_POINTER (DECL_NAME (field
)));
913 /* Calculate a hash value for a string encoded in Utf8 format.
914 * This returns the same hash value as specified for java.lang.String.hashCode.
918 hashUtf8String (const char *str
, int len
)
920 const unsigned char* ptr
= (const unsigned char*) str
;
921 const unsigned char *limit
= ptr
+ len
;
925 int ch
= UTF8_GET (ptr
, limit
);
926 /* Updated specification from
927 http://www.javasoft.com/docs/books/jls/clarify.html. */
928 hash
= (31 * hash
) + ch
;
934 build_utf8_ref (tree name
)
936 const char * name_ptr
= IDENTIFIER_POINTER (name
);
937 int name_len
= IDENTIFIER_LENGTH (name
), name_pad
;
939 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
940 static int utf8_count
= 0;
942 tree ref
= IDENTIFIER_UTF8_REF (name
);
944 VEC(constructor_elt
,gc
) *v
= NULL
;
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 (v
, ctype
);
960 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
961 PUSH_FIELD_VALUE (v
, "hash", build_int_cst (NULL_TREE
, name_hash
));
962 PUSH_FIELD_VALUE (v
, "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 (v
, "data", string
);
966 FINISH_RECORD_CONSTRUCTOR (cinit
, v
, ctype
);
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 layout_decl (decl
, 0);
998 DECL_SIZE (decl
) = TYPE_SIZE (ctype
);
999 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (ctype
);
1001 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
1002 varpool_mark_needed_node (varpool_node (decl
));
1003 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
1004 IDENTIFIER_UTF8_REF (name
) = ref
;
1008 /* Like build_class_ref, but instead of a direct reference generate a
1009 pointer into the constant pool. */
1012 build_indirect_class_ref (tree type
)
1016 index
= alloc_class_constant (type
);
1017 cl
= build_ref_from_constant_pool (index
);
1018 return convert (promote_type (class_ptr_type
), cl
);
1022 build_static_class_ref (tree type
)
1024 tree decl_name
, decl
, ref
;
1026 if (TYPE_SIZE (type
) == error_mark_node
)
1027 return null_pointer_node
;
1028 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1029 "", '/', '/', ".class$$");
1030 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1031 if (decl
== NULL_TREE
)
1033 decl
= build_decl (input_location
, VAR_DECL
, decl_name
, class_type_node
);
1034 TREE_STATIC (decl
) = 1;
1035 if (! flag_indirect_classes
)
1037 TREE_PUBLIC (decl
) = 1;
1038 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1039 java_hide_decl (decl
);
1041 DECL_IGNORED_P (decl
) = 1;
1042 DECL_ARTIFICIAL (decl
) = 1;
1043 if (is_compiled_class (type
) == 1)
1044 DECL_EXTERNAL (decl
) = 1;
1045 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1046 DECL_CLASS_FIELD_P (decl
) = 1;
1047 DECL_CONTEXT (decl
) = type
;
1049 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1050 that that means not calling pushdecl_top_level. */
1051 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1054 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1059 build_classdollar_field (tree type
)
1061 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1062 "", '/', '/', ".class$");
1063 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1065 if (decl
== NULL_TREE
)
1068 = build_decl (input_location
,
1069 VAR_DECL
, decl_name
,
1072 (build_type_variant (class_type_node
,
1074 /* const */ 1, 0)));
1075 TREE_STATIC (decl
) = 1;
1076 TREE_CONSTANT (decl
) = 1;
1077 TREE_READONLY (decl
) = 1;
1078 TREE_PUBLIC (decl
) = 1;
1079 java_hide_decl (decl
);
1080 DECL_IGNORED_P (decl
) = 1;
1081 DECL_ARTIFICIAL (decl
) = 1;
1082 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1083 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1084 DECL_CLASS_FIELD_P (decl
) = 1;
1085 DECL_CONTEXT (decl
) = type
;
1091 /* Create a local variable that holds the current class$. */
1094 cache_this_class_ref (tree fndecl
)
1098 tree classdollar_field
;
1099 if (flag_indirect_classes
)
1100 classdollar_field
= build_classdollar_field (output_class
);
1102 classdollar_field
= build_static_class_ref (output_class
);
1104 this_classdollar
= build_decl (input_location
,
1105 VAR_DECL
, NULL_TREE
,
1106 TREE_TYPE (classdollar_field
));
1108 java_add_local_var (this_classdollar
);
1109 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1110 this_classdollar
, classdollar_field
));
1113 this_classdollar
= build_classdollar_field (output_class
);
1115 /* Prepend class initialization for static methods reachable from
1117 if (METHOD_STATIC (fndecl
)
1118 && (! METHOD_PRIVATE (fndecl
)
1119 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1120 && ! DECL_CLINIT_P (fndecl
)
1121 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1123 tree init
= build_call_expr (soft_initclass_node
, 1,
1125 java_add_stmt (init
);
1129 /* Remove the reference to the local variable that holds the current
1133 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1135 this_classdollar
= build_classdollar_field (output_class
);
1138 /* Build a reference to the class TYPE.
1139 Also handles primitive types and array types. */
1142 build_class_ref (tree type
)
1144 int is_compiled
= is_compiled_class (type
);
1148 if (TREE_CODE (type
) == POINTER_TYPE
)
1149 type
= TREE_TYPE (type
);
1151 if (flag_indirect_dispatch
1152 && type
!= output_class
1153 && TREE_CODE (type
) == RECORD_TYPE
)
1154 return build_indirect_class_ref (type
);
1156 if (type
== output_class
&& flag_indirect_classes
)
1158 /* This can be NULL if we see a JNI stub before we see any
1160 if (! this_classdollar
)
1161 this_classdollar
= build_classdollar_field (output_class
);
1162 return this_classdollar
;
1165 if (TREE_CODE (type
) == RECORD_TYPE
)
1166 return build_static_class_ref (type
);
1172 decl_name
= TYPE_NAME (type
);
1173 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1174 decl_name
= DECL_NAME (decl_name
);
1175 name
= IDENTIFIER_POINTER (decl_name
);
1176 if (strncmp (name
, "promoted_", 9) == 0)
1178 sprintf (buffer
, "_Jv_%sClass", name
);
1179 decl_name
= get_identifier (buffer
);
1180 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1181 if (decl
== NULL_TREE
)
1183 decl
= build_decl (input_location
,
1184 VAR_DECL
, decl_name
, class_type_node
);
1185 TREE_STATIC (decl
) = 1;
1186 TREE_PUBLIC (decl
) = 1;
1187 DECL_EXTERNAL (decl
) = 1;
1188 DECL_ARTIFICIAL (decl
) = 1;
1189 pushdecl_top_level (decl
);
1193 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1197 return build_indirect_class_ref (type
);
1200 /* Create a local statically allocated variable that will hold a
1201 pointer to a static field. */
1204 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1206 tree decl
, decl_name
;
1207 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1208 char *buf
= (char *) alloca (strlen (name
) + 20);
1209 sprintf (buf
, "%s_%d_ref", name
, index
);
1210 decl_name
= get_identifier (buf
);
1211 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1212 if (decl
== NULL_TREE
)
1214 decl
= build_decl (input_location
,
1215 VAR_DECL
, decl_name
, ptr_type_node
);
1216 TREE_STATIC (decl
) = 1;
1217 TREE_PUBLIC (decl
) = 0;
1218 DECL_EXTERNAL (decl
) = 0;
1219 DECL_ARTIFICIAL (decl
) = 1;
1220 DECL_IGNORED_P (decl
) = 1;
1221 pushdecl_top_level (decl
);
1227 build_static_field_ref (tree fdecl
)
1229 tree fclass
= DECL_CONTEXT (fdecl
);
1230 int is_compiled
= is_compiled_class (fclass
);
1232 /* Allow static final fields to fold to a constant. When using
1233 -findirect-dispatch, we simply never do this folding if compiling
1234 from .class; in the .class file constants will be referred to via
1235 the constant pool. */
1236 if (!flag_indirect_dispatch
1238 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1239 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1240 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1241 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1243 if (is_compiled
== 1)
1244 DECL_EXTERNAL (fdecl
) = 1;
1248 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1249 and a class local static variable CACHE_ENTRY, then
1251 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1252 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1255 This can mostly be optimized away, so that the usual path is a
1256 load followed by a test and branch. _Jv_ResolvePoolEntry is
1257 only called once for each constant pool entry.
1259 There is an optimization that we don't do: at the start of a
1260 method, create a local copy of CACHE_ENTRY and use that instead.
1264 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1265 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1267 = build_call_expr (built_in_decls
[BUILT_IN_EXPECT
], 2,
1268 build2 (EQ_EXPR
, boolean_type_node
,
1269 cache_entry
, null_pointer_node
),
1270 boolean_false_node
);
1271 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1273 = build_call_expr (soft_resolvepoolentry_node
, 2,
1274 build_class_ref (output_class
),
1276 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1277 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1278 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1279 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1285 get_access_flags_from_decl (tree decl
)
1287 int access_flags
= 0;
1288 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1290 if (FIELD_STATIC (decl
))
1291 access_flags
|= ACC_STATIC
;
1292 if (FIELD_PUBLIC (decl
))
1293 access_flags
|= ACC_PUBLIC
;
1294 if (FIELD_PROTECTED (decl
))
1295 access_flags
|= ACC_PROTECTED
;
1296 if (FIELD_PRIVATE (decl
))
1297 access_flags
|= ACC_PRIVATE
;
1298 if (FIELD_FINAL (decl
))
1299 access_flags
|= ACC_FINAL
;
1300 if (FIELD_VOLATILE (decl
))
1301 access_flags
|= ACC_VOLATILE
;
1302 if (FIELD_TRANSIENT (decl
))
1303 access_flags
|= ACC_TRANSIENT
;
1304 if (FIELD_ENUM (decl
))
1305 access_flags
|= ACC_ENUM
;
1306 if (FIELD_SYNTHETIC (decl
))
1307 access_flags
|= ACC_SYNTHETIC
;
1308 return access_flags
;
1310 if (TREE_CODE (decl
) == TYPE_DECL
)
1312 if (CLASS_PUBLIC (decl
))
1313 access_flags
|= ACC_PUBLIC
;
1314 if (CLASS_FINAL (decl
))
1315 access_flags
|= ACC_FINAL
;
1316 if (CLASS_SUPER (decl
))
1317 access_flags
|= ACC_SUPER
;
1318 if (CLASS_INTERFACE (decl
))
1319 access_flags
|= ACC_INTERFACE
;
1320 if (CLASS_ABSTRACT (decl
))
1321 access_flags
|= ACC_ABSTRACT
;
1322 if (CLASS_STATIC (decl
))
1323 access_flags
|= ACC_STATIC
;
1324 if (CLASS_PRIVATE (decl
))
1325 access_flags
|= ACC_PRIVATE
;
1326 if (CLASS_PROTECTED (decl
))
1327 access_flags
|= ACC_PROTECTED
;
1328 if (CLASS_STRICTFP (decl
))
1329 access_flags
|= ACC_STRICT
;
1330 if (CLASS_ENUM (decl
))
1331 access_flags
|= ACC_ENUM
;
1332 if (CLASS_SYNTHETIC (decl
))
1333 access_flags
|= ACC_SYNTHETIC
;
1334 if (CLASS_ANNOTATION (decl
))
1335 access_flags
|= ACC_ANNOTATION
;
1336 return access_flags
;
1338 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1340 if (METHOD_PUBLIC (decl
))
1341 access_flags
|= ACC_PUBLIC
;
1342 if (METHOD_PRIVATE (decl
))
1343 access_flags
|= ACC_PRIVATE
;
1344 if (METHOD_PROTECTED (decl
))
1345 access_flags
|= ACC_PROTECTED
;
1346 if (METHOD_STATIC (decl
))
1347 access_flags
|= ACC_STATIC
;
1348 if (METHOD_FINAL (decl
))
1349 access_flags
|= ACC_FINAL
;
1350 if (METHOD_SYNCHRONIZED (decl
))
1351 access_flags
|= ACC_SYNCHRONIZED
;
1352 if (METHOD_NATIVE (decl
))
1353 access_flags
|= ACC_NATIVE
;
1354 if (METHOD_ABSTRACT (decl
))
1355 access_flags
|= ACC_ABSTRACT
;
1356 if (METHOD_STRICTFP (decl
))
1357 access_flags
|= ACC_STRICT
;
1358 if (METHOD_INVISIBLE (decl
))
1359 access_flags
|= ACC_INVISIBLE
;
1360 if (DECL_ARTIFICIAL (decl
))
1361 access_flags
|= ACC_SYNTHETIC
;
1362 if (METHOD_BRIDGE (decl
))
1363 access_flags
|= ACC_BRIDGE
;
1364 if (METHOD_VARARGS (decl
))
1365 access_flags
|= ACC_VARARGS
;
1366 return access_flags
;
1371 static GTY (()) int alias_labelno
= 0;
1373 /* Create a private alias for METHOD. Using this alias instead of the method
1374 decl ensures that ncode entries in the method table point to the real function
1375 at runtime, not a PLT entry. */
1378 make_local_function_alias (tree method
)
1380 #ifdef ASM_OUTPUT_DEF
1383 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1384 char *name
= (char *) alloca (strlen (method_name
) + 2);
1385 char *buf
= (char *) alloca (strlen (method_name
) + 128);
1387 /* Only create aliases for local functions. */
1388 if (DECL_EXTERNAL (method
))
1391 /* Prefix method_name with 'L' for the alias label. */
1393 strcpy (name
+ 1, method_name
);
1395 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1396 alias
= build_decl (input_location
,
1397 FUNCTION_DECL
, get_identifier (buf
),
1398 TREE_TYPE (method
));
1399 DECL_CONTEXT (alias
) = NULL
;
1400 TREE_READONLY (alias
) = TREE_READONLY (method
);
1401 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1402 TREE_PUBLIC (alias
) = 0;
1403 DECL_EXTERNAL (alias
) = 0;
1404 DECL_ARTIFICIAL (alias
) = 1;
1405 DECL_INITIAL (alias
) = error_mark_node
;
1406 TREE_ADDRESSABLE (alias
) = 1;
1407 TREE_USED (alias
) = 1;
1408 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1409 if (!flag_syntax_only
)
1410 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1417 /** Make reflection data (_Jv_Field) for field FDECL. */
1420 make_field_value (tree fdecl
)
1424 tree type
= TREE_TYPE (fdecl
);
1425 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1426 VEC(constructor_elt
,gc
) *v
= NULL
;
1428 START_RECORD_CONSTRUCTOR (v
, field_type_node
);
1429 PUSH_FIELD_VALUE (v
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1431 type
= build_class_ref (type
);
1434 tree signature
= build_java_signature (type
);
1436 type
= build_utf8_ref (unmangle_classname
1437 (IDENTIFIER_POINTER (signature
),
1438 IDENTIFIER_LENGTH (signature
)));
1440 PUSH_FIELD_VALUE (v
, "type", type
);
1442 flags
= get_access_flags_from_decl (fdecl
);
1444 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1446 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, flags
));
1447 PUSH_FIELD_VALUE (v
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1450 tree field_address
= integer_zero_node
;
1451 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1452 && FIELD_STATIC (fdecl
))
1453 field_address
= build_address_of (fdecl
);
1457 build_constructor_from_list (field_info_union_node
,
1459 ((FIELD_STATIC (fdecl
)
1460 ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node
))
1461 : TYPE_FIELDS (field_info_union_node
)),
1462 (FIELD_STATIC (fdecl
)
1464 : byte_position (fdecl
)))));
1467 FINISH_RECORD_CONSTRUCTOR (finit
, v
, field_type_node
);
1471 /** Make reflection data (_Jv_Method) for method MDECL. */
1474 make_method_value (tree mdecl
)
1476 static int method_name_count
= 0;
1481 #define ACC_TRANSLATED 0x4000
1482 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1483 VEC(constructor_elt
,gc
) *v
= NULL
;
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 (v
, method_type_node
);
1503 PUSH_FIELD_VALUE (v
, "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 (v
, "signature",
1512 (IDENTIFIER_POINTER(signature
),
1513 IDENTIFIER_LENGTH(signature
)))));
1515 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1516 PUSH_FIELD_VALUE (v
, "index", index
);
1517 PUSH_FIELD_VALUE (v
, "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 (v
, "throws", table
);
1557 FINISH_RECORD_CONSTRUCTOR (minit
, v
, method_type_node
);
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 add_table_and_syms (VEC(constructor_elt
,gc
) **v
,
1723 const char *table_name
, tree table_slot
, tree table_type
,
1724 const char *syms_name
, tree syms_slot
)
1726 if (method_slot
== NULL_TREE
)
1728 PUSH_FIELD_VALUE (*v
, table_name
, null_pointer_node
);
1729 PUSH_FIELD_VALUE (*v
, syms_name
, null_pointer_node
);
1733 pushdecl_top_level (syms_slot
);
1734 PUSH_FIELD_VALUE (*v
, table_name
,
1735 build1 (ADDR_EXPR
, table_type
, table_slot
));
1736 PUSH_FIELD_VALUE (*v
, syms_name
,
1737 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1739 TREE_CONSTANT (table_slot
) = 1;
1744 make_class_data (tree type
)
1746 tree decl
, cons
, temp
;
1747 tree field
, fields_decl
;
1748 tree static_fields
= NULL_TREE
;
1749 tree instance_fields
= NULL_TREE
;
1750 HOST_WIDE_INT static_field_count
= 0;
1751 HOST_WIDE_INT instance_field_count
= 0;
1752 HOST_WIDE_INT field_count
;
1753 tree field_array_type
;
1755 tree methods
= NULL_TREE
;
1756 tree dtable_decl
= NULL_TREE
;
1757 HOST_WIDE_INT method_count
= 0;
1758 tree method_array_type
;
1761 tree this_class_addr
;
1762 tree constant_pool_constructor
;
1763 tree interfaces
= null_pointer_node
;
1764 int interface_len
= 0;
1765 int uses_jv_markobj
= 0;
1766 tree type_decl
= TYPE_NAME (type
);
1767 tree id_main
= get_identifier("main");
1768 tree id_class
= get_identifier("java.lang.Class");
1769 /** Offset from start of virtual function table declaration
1770 to where objects actually point at, following new g++ ABI. */
1771 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1772 VEC(int, heap
) *field_indexes
;
1773 tree first_real_field
;
1774 VEC(constructor_elt
,gc
) *v1
= NULL
, *v2
= NULL
;
1775 tree reflection_data
;
1777 this_class_addr
= build_static_class_ref (type
);
1778 decl
= TREE_OPERAND (this_class_addr
, 0);
1780 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1781 && !flag_indirect_dispatch
)
1783 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1784 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1785 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1787 /* We've already created some other class, and consequently
1788 we made class_dtable_decl. Now we just want to fill it
1790 dtable_decl
= class_dtable_decl
;
1794 dtable_decl
= build_dtable_decl (type
);
1795 TREE_STATIC (dtable_decl
) = 1;
1796 DECL_ARTIFICIAL (dtable_decl
) = 1;
1797 DECL_IGNORED_P (dtable_decl
) = 1;
1800 TREE_PUBLIC (dtable_decl
) = 1;
1801 DECL_INITIAL (dtable_decl
) = dtable
;
1802 /* The only dispatch table exported from a DSO is the dispatch
1803 table for java.lang.Class. */
1804 if (DECL_NAME (type_decl
) != id_class
)
1805 java_hide_decl (dtable_decl
);
1806 if (! flag_indirect_classes
)
1807 rest_of_decl_compilation (dtable_decl
, 1, 0);
1808 /* Maybe we're compiling Class as the first class. If so, set
1809 class_dtable_decl to the decl we just made. */
1810 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1811 class_dtable_decl
= dtable_decl
;
1814 /* Build Field array. */
1815 field
= TYPE_FIELDS (type
);
1816 while (field
&& DECL_ARTIFICIAL (field
))
1817 field
= TREE_CHAIN (field
); /* Skip dummy fields. */
1818 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1819 field
= TREE_CHAIN (field
); /* Skip dummy field for inherited data. */
1820 first_real_field
= field
;
1822 /* First count static and instance fields. */
1823 for ( ; field
!= NULL_TREE
; field
= TREE_CHAIN (field
))
1825 if (! DECL_ARTIFICIAL (field
))
1827 if (FIELD_STATIC (field
))
1828 static_field_count
++;
1829 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1830 instance_field_count
++;
1833 field_count
= static_field_count
+ instance_field_count
;
1834 field_indexes
= VEC_alloc (int, heap
, field_count
);
1836 /* gcj sorts fields so that static fields come first, followed by
1837 instance fields. Unfortunately, by the time this takes place we
1838 have already generated the reflection_data for this class, and
1839 that data contains indexes into the fields. So, we generate a
1840 permutation that maps each original field index to its final
1841 position. Then we pass this permutation to
1842 rewrite_reflection_indexes(), which fixes up the reflection
1846 int static_count
= 0;
1847 int instance_count
= static_field_count
;
1850 for (i
= 0, field
= first_real_field
;
1852 field
= TREE_CHAIN (field
), i
++)
1854 if (! DECL_ARTIFICIAL (field
))
1857 if (FIELD_STATIC (field
))
1858 field_index
= static_count
++;
1859 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1860 field_index
= instance_count
++;
1863 VEC_quick_push (int, field_indexes
, field_index
);
1868 for (field
= first_real_field
; field
!= NULL_TREE
;
1869 field
= TREE_CHAIN (field
))
1871 if (! DECL_ARTIFICIAL (field
))
1873 if (FIELD_STATIC (field
))
1875 /* We must always create reflection data for static fields
1876 as it is used in the creation of the field itself. */
1877 tree init
= make_field_value (field
);
1878 tree initial
= DECL_INITIAL (field
);
1879 static_fields
= tree_cons (NULL_TREE
, init
, static_fields
);
1880 /* If the initial value is a string constant,
1881 prevent output_constant from trying to assemble the value. */
1882 if (initial
!= NULL_TREE
1883 && TREE_TYPE (initial
) == string_ptr_type_node
)
1884 DECL_INITIAL (field
) = NULL_TREE
;
1885 rest_of_decl_compilation (field
, 1, 1);
1886 DECL_INITIAL (field
) = initial
;
1888 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1890 tree init
= make_field_value (field
);
1891 instance_fields
= tree_cons (NULL_TREE
, init
, instance_fields
);
1896 if (field_count
> 0)
1898 static_fields
= nreverse (static_fields
);
1899 instance_fields
= nreverse (instance_fields
);
1900 static_fields
= chainon (static_fields
, instance_fields
);
1901 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1902 fields_decl
= build_decl (input_location
,
1903 VAR_DECL
, mangled_classname ("_FL_", type
),
1905 DECL_INITIAL (fields_decl
) = build_constructor_from_list
1906 (field_array_type
, static_fields
);
1907 TREE_STATIC (fields_decl
) = 1;
1908 DECL_ARTIFICIAL (fields_decl
) = 1;
1909 DECL_IGNORED_P (fields_decl
) = 1;
1910 rest_of_decl_compilation (fields_decl
, 1, 0);
1913 fields_decl
= NULL_TREE
;
1915 /* Build Method array. */
1916 for (method
= TYPE_METHODS (type
);
1917 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1920 if (METHOD_PRIVATE (method
)
1921 && ! flag_keep_inline_functions
1924 /* Even if we have a decl, we don't necessarily have the code.
1925 This can happen if we inherit a method from a superclass for
1926 which we don't have a .class file. */
1927 if (METHOD_DUMMY (method
))
1930 /* Generate method reflection data if:
1932 - !flag_reduced_reflection.
1934 - <clinit> -- The runtime uses reflection to initialize the
1937 - Any method in class java.lang.Class -- Class.forName() and
1938 perhaps other things require it.
1940 - class$ -- It does not work if reflection data missing.
1942 - main -- Reflection is used to find main(String[]) methods.
1944 - public not static -- It is potentially part of an
1945 interface. The runtime uses reflection data to build
1946 interface dispatch tables. */
1947 if (!flag_reduced_reflection
1948 || DECL_CLINIT_P (method
)
1949 || DECL_NAME (type_decl
) == id_class
1950 || DECL_NAME (method
) == id_main
1951 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1953 init
= make_method_value (method
);
1955 methods
= tree_cons (NULL_TREE
, init
, methods
);
1958 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1959 methods_decl
= build_decl (input_location
,
1960 VAR_DECL
, mangled_classname ("_MT_", type
),
1962 DECL_INITIAL (methods_decl
) = build_constructor_from_list
1963 (method_array_type
, nreverse (methods
));
1964 TREE_STATIC (methods_decl
) = 1;
1965 DECL_ARTIFICIAL (methods_decl
) = 1;
1966 DECL_IGNORED_P (methods_decl
) = 1;
1967 rest_of_decl_compilation (methods_decl
, 1, 0);
1969 if (class_dtable_decl
== NULL_TREE
)
1971 class_dtable_decl
= build_dtable_decl (class_type_node
);
1972 TREE_STATIC (class_dtable_decl
) = 1;
1973 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1974 DECL_IGNORED_P (class_dtable_decl
) = 1;
1975 if (is_compiled_class (class_type_node
) != 2)
1977 DECL_EXTERNAL (class_dtable_decl
) = 1;
1978 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
1982 super
= CLASSTYPE_SUPER (type
);
1983 if (super
== NULL_TREE
)
1984 super
= null_pointer_node
;
1985 else if (! flag_indirect_dispatch
1986 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
1987 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
1988 super
= build_class_ref (super
);
1991 int super_index
= alloc_class_constant (super
);
1992 super
= build_int_cst (ptr_type_node
, super_index
);
1995 /* Build and emit the array of implemented interfaces. */
1996 if (type
!= object_type_node
)
1997 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
1999 if (interface_len
> 0)
2001 tree init
= NULL_TREE
;
2003 tree interface_array_type
, idecl
;
2004 interface_array_type
2005 = build_prim_array_type (class_ptr_type
, interface_len
);
2006 idecl
= build_decl (input_location
,
2007 VAR_DECL
, mangled_classname ("_IF_", type
),
2008 interface_array_type
);
2010 for (i
= interface_len
; i
> 0; i
--)
2012 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
2013 tree iclass
= BINFO_TYPE (child
);
2015 if (! flag_indirect_dispatch
2017 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
2018 index
= build_class_ref (iclass
);
2021 int int_index
= alloc_class_constant (iclass
);
2022 index
= build_int_cst (ptr_type_node
, int_index
);
2024 init
= tree_cons (NULL_TREE
, index
, init
);
2026 DECL_INITIAL (idecl
) = build_constructor_from_list (interface_array_type
,
2028 TREE_STATIC (idecl
) = 1;
2029 DECL_ARTIFICIAL (idecl
) = 1;
2030 DECL_IGNORED_P (idecl
) = 1;
2031 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
2032 rest_of_decl_compilation (idecl
, 1, 0);
2035 constant_pool_constructor
= build_constants_constructor ();
2037 if (flag_indirect_dispatch
)
2039 TYPE_OTABLE_DECL (type
)
2041 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
2042 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
2043 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
2045 TYPE_ATABLE_DECL (type
)
2047 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
2048 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
2049 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2051 TYPE_ITABLE_DECL (type
)
2053 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2054 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2055 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2058 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2060 START_RECORD_CONSTRUCTOR (v1
, object_type_node
);
2061 PUSH_FIELD_VALUE (v1
, "vtable",
2062 (flag_indirect_classes
2064 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2065 build1 (ADDR_EXPR
, dtable_ptr_type
,
2067 dtable_start_offset
)));
2068 if (! flag_hash_synchronization
)
2069 PUSH_FIELD_VALUE (v1
, "sync_info", null_pointer_node
);
2070 FINISH_RECORD_CONSTRUCTOR (temp
, v1
, object_type_node
);
2071 START_RECORD_CONSTRUCTOR (v2
, class_type_node
);
2072 PUSH_SUPER_VALUE (v2
, temp
);
2073 PUSH_FIELD_VALUE (v2
, "next_or_version", gcj_abi_version
);
2074 PUSH_FIELD_VALUE (v2
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2075 PUSH_FIELD_VALUE (v2
, "accflags",
2076 build_int_cst (NULL_TREE
,
2077 get_access_flags_from_decl (type_decl
)));
2079 PUSH_FIELD_VALUE (v2
, "superclass",
2080 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2081 PUSH_FIELD_VALUE (v2
, "constants", constant_pool_constructor
);
2082 PUSH_FIELD_VALUE (v2
, "methods",
2083 methods_decl
== NULL_TREE
? null_pointer_node
2084 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2085 PUSH_FIELD_VALUE (v2
, "method_count",
2086 build_int_cst (NULL_TREE
, method_count
));
2088 PUSH_FIELD_VALUE (v2
, "vtable_method_count",
2089 (flag_indirect_dispatch
2090 ? integer_minus_one_node
2091 : TYPE_NVIRTUALS (type
)));
2093 PUSH_FIELD_VALUE (v2
, "fields",
2094 fields_decl
== NULL_TREE
? null_pointer_node
2095 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2096 /* If we're using the binary compatibility ABI we don't know the
2097 size until load time. */
2098 PUSH_FIELD_VALUE (v2
, "size_in_bytes",
2099 (flag_indirect_dispatch
2100 ? integer_minus_one_node
2101 : size_in_bytes (type
)));
2102 PUSH_FIELD_VALUE (v2
, "field_count",
2103 build_int_cst (NULL_TREE
, field_count
));
2104 PUSH_FIELD_VALUE (v2
, "static_field_count",
2105 build_int_cst (NULL_TREE
, static_field_count
));
2107 PUSH_FIELD_VALUE (v2
, "vtable",
2108 (flag_indirect_dispatch
|| dtable_decl
== NULL_TREE
2110 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2111 build1 (ADDR_EXPR
, dtable_ptr_type
,
2113 dtable_start_offset
)));
2114 add_table_and_syms (&v2
, TYPE_OTABLE_METHODS (type
),
2115 "otable", TYPE_OTABLE_DECL (type
), otable_ptr_type
,
2116 "otable_syms", TYPE_OTABLE_SYMS_DECL (type
));
2117 add_table_and_syms (&v2
, TYPE_ATABLE_METHODS (type
),
2118 "atable", TYPE_ATABLE_DECL (type
), atable_ptr_type
,
2119 "atable_syms", TYPE_ATABLE_SYMS_DECL (type
));
2120 add_table_and_syms (&v2
, TYPE_ITABLE_METHODS (type
),
2121 "itable", TYPE_ITABLE_DECL (type
), itable_ptr_type
,
2122 "itable_syms", TYPE_ITABLE_SYMS_DECL (type
));
2124 PUSH_FIELD_VALUE (v2
, "catch_classes",
2125 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2126 PUSH_FIELD_VALUE (v2
, "interfaces", interfaces
);
2127 PUSH_FIELD_VALUE (v2
, "loader", null_pointer_node
);
2128 PUSH_FIELD_VALUE (v2
, "interface_count",
2129 build_int_cst (NULL_TREE
, interface_len
));
2130 PUSH_FIELD_VALUE (v2
, "state",
2131 convert (byte_type_node
,
2132 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2134 PUSH_FIELD_VALUE (v2
, "thread", null_pointer_node
);
2135 PUSH_FIELD_VALUE (v2
, "depth", integer_zero_node
);
2136 PUSH_FIELD_VALUE (v2
, "ancestors", null_pointer_node
);
2137 PUSH_FIELD_VALUE (v2
, "idt", null_pointer_node
);
2138 PUSH_FIELD_VALUE (v2
, "arrayclass", null_pointer_node
);
2139 PUSH_FIELD_VALUE (v2
, "protectionDomain", null_pointer_node
);
2142 tree assertion_table_ref
;
2143 if (TYPE_ASSERTIONS (type
) == NULL
)
2144 assertion_table_ref
= null_pointer_node
;
2146 assertion_table_ref
= build1 (ADDR_EXPR
,
2147 build_pointer_type (assertion_table_type
),
2148 emit_assertion_table (type
));
2150 PUSH_FIELD_VALUE (v2
, "assertion_table", assertion_table_ref
);
2153 PUSH_FIELD_VALUE (v2
, "hack_signers", null_pointer_node
);
2154 PUSH_FIELD_VALUE (v2
, "chain", null_pointer_node
);
2155 PUSH_FIELD_VALUE (v2
, "aux_info", null_pointer_node
);
2156 PUSH_FIELD_VALUE (v2
, "engine", null_pointer_node
);
2158 if (TYPE_REFLECTION_DATA (current_class
))
2161 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2162 VEC (constructor_elt
, gc
) *v
2163 = VEC_alloc (constructor_elt
, gc
, count
);
2164 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2165 tree max_index
= build_int_cst (sizetype
, count
);
2166 tree index
= build_index_type (max_index
);
2167 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2170 static int reflection_data_count
;
2172 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2173 array
= build_decl (input_location
,
2174 VAR_DECL
, get_identifier (buf
), type
);
2176 rewrite_reflection_indexes (field_indexes
);
2178 for (i
= 0; i
< count
; i
++)
2180 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
2181 elt
->index
= build_int_cst (sizetype
, i
);
2182 elt
->value
= build_int_cstu (byte_type_node
, data
[i
]);
2185 DECL_INITIAL (array
) = build_constructor (type
, v
);
2186 TREE_STATIC (array
) = 1;
2187 DECL_ARTIFICIAL (array
) = 1;
2188 DECL_IGNORED_P (array
) = 1;
2189 TREE_READONLY (array
) = 1;
2190 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2191 rest_of_decl_compilation (array
, 1, 0);
2193 reflection_data
= build_address_of (array
);
2196 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2199 reflection_data
= null_pointer_node
;
2201 PUSH_FIELD_VALUE (v2
, "reflection_data", reflection_data
);
2202 FINISH_RECORD_CONSTRUCTOR (cons
, v2
, class_type_node
);
2204 DECL_INITIAL (decl
) = cons
;
2206 /* Hash synchronization requires at least 64-bit alignment. */
2207 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2208 DECL_ALIGN (decl
) = 64;
2210 if (flag_indirect_classes
)
2212 TREE_READONLY (decl
) = 1;
2213 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2216 rest_of_decl_compilation (decl
, 1, 0);
2219 tree classdollar_field
= build_classdollar_field (type
);
2220 if (!flag_indirect_classes
)
2221 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2222 rest_of_decl_compilation (classdollar_field
, 1, 0);
2225 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2226 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2227 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2233 java_expand_catch_classes (current_class
);
2235 current_function_decl
= NULL_TREE
;
2236 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2237 make_class_data (current_class
);
2239 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2242 /* Return 2 if KLASS is compiled by this compilation job;
2243 return 1 if KLASS can otherwise be assumed to be compiled;
2244 return 0 if we cannot assume that KLASS is compiled.
2245 Returns 1 for primitive and 0 for array types. */
2247 is_compiled_class (tree klass
)
2250 if (TREE_CODE (klass
) == POINTER_TYPE
)
2251 klass
= TREE_TYPE (klass
);
2252 if (TREE_CODE (klass
) != RECORD_TYPE
) /* Primitive types are static. */
2254 if (TYPE_ARRAY_P (klass
))
2257 seen_in_zip
= (TYPE_JCF (klass
) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass
)));
2258 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2260 /* The class was seen in the current ZIP file and will be
2261 available as a compiled class in the future but may not have
2262 been loaded already. Load it if necessary. This prevent
2263 build_class_ref () from crashing. */
2265 if (seen_in_zip
&& !CLASS_LOADED_P (klass
) && (klass
!= current_class
))
2266 load_class (klass
, 1);
2268 /* We return 2 for class seen in ZIP and class from files
2269 belonging to the same compilation unit */
2273 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass
)))))
2275 if (!CLASS_LOADED_P (klass
))
2277 if (klass
!= current_class
)
2278 load_class (klass
, 1);
2286 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2289 build_dtable_decl (tree type
)
2293 /* We need to build a new dtable type so that its size is uniquely
2294 computed when we're dealing with the class for real and not just
2295 faking it (like java.lang.Class during the initialization of the
2296 compiler.) We know we're not faking a class when CURRENT_CLASS is
2298 if (current_class
== type
)
2300 tree dummy
= NULL_TREE
;
2303 dtype
= make_node (RECORD_TYPE
);
2305 PUSH_FIELD (input_location
, dtype
, dummy
, "top_offset", ptr_type_node
);
2306 PUSH_FIELD (input_location
, dtype
, dummy
, "type_info", ptr_type_node
);
2308 PUSH_FIELD (input_location
, dtype
, dummy
, "class", class_ptr_type
);
2309 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2311 tree tmp_field
= build_decl (input_location
,
2312 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2313 TREE_CHAIN (dummy
) = tmp_field
;
2314 DECL_CONTEXT (tmp_field
) = dtype
;
2315 DECL_ARTIFICIAL (tmp_field
) = 1;
2319 PUSH_FIELD (input_location
, dtype
, dummy
, "gc_descr", ptr_type_node
);
2320 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2322 tree tmp_field
= build_decl (input_location
,
2323 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2324 TREE_CHAIN (dummy
) = tmp_field
;
2325 DECL_CONTEXT (tmp_field
) = dtype
;
2326 DECL_ARTIFICIAL (tmp_field
) = 1;
2330 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2331 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2332 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2334 PUSH_FIELD (input_location
, dtype
, dummy
, "methods",
2335 build_prim_array_type (nativecode_ptr_type_node
, n
));
2336 layout_type (dtype
);
2339 dtype
= dtable_type
;
2341 decl
= build_decl (input_location
,
2342 VAR_DECL
, get_identifier ("vt$"), dtype
);
2343 DECL_CONTEXT (decl
) = type
;
2344 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2345 DECL_VTABLE_P (decl
) = 1;
2350 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2351 fields inherited from SUPER_CLASS. */
2354 push_super_field (tree this_class
, tree super_class
)
2357 /* Don't insert the field if we're just re-laying the class out. */
2358 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2360 base_decl
= build_decl (input_location
,
2361 FIELD_DECL
, NULL_TREE
, super_class
);
2362 DECL_IGNORED_P (base_decl
) = 1;
2363 TREE_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2364 TYPE_FIELDS (this_class
) = base_decl
;
2365 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2366 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2369 /* Handle the different manners we may have to lay out a super class. */
2372 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2376 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2378 if (!CLASS_LOADED_P (super_class
))
2379 load_class (super_class
, 1);
2381 /* We might have to layout the class before its dependency on
2382 the super class gets resolved by java_complete_class */
2383 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2385 if (TREE_TYPE (super_class
) != NULL_TREE
)
2386 super_class
= TREE_TYPE (super_class
);
2390 if (!TYPE_SIZE (super_class
))
2391 safe_layout_class (super_class
);
2396 /* safe_layout_class just makes sure that we can load a class without
2397 disrupting the current_class, input_file, input_line, etc, information
2398 about the class processed currently. */
2401 safe_layout_class (tree klass
)
2403 tree save_current_class
= current_class
;
2404 location_t save_location
= input_location
;
2406 layout_class (klass
);
2408 current_class
= save_current_class
;
2409 input_location
= save_location
;
2413 layout_class (tree this_class
)
2416 tree super_class
= CLASSTYPE_SUPER (this_class
);
2418 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2419 if (CLASS_BEING_LAIDOUT (this_class
))
2425 sprintf (buffer
, " with '%s'",
2426 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2427 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2429 for (current
= TREE_CHAIN (class_list
); current
;
2430 current
= TREE_CHAIN (current
))
2432 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2433 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2434 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2435 DECL_SOURCE_FILE (decl
),
2436 DECL_SOURCE_LINE (decl
));
2437 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2439 obstack_1grow (&temporary_obstack
, '\0');
2440 report
= XOBFINISH (&temporary_obstack
, char *);
2441 cyclic_inheritance_report
= ggc_strdup (report
);
2442 obstack_free (&temporary_obstack
, report
);
2443 TYPE_SIZE (this_class
) = error_mark_node
;
2446 CLASS_BEING_LAIDOUT (this_class
) = 1;
2448 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2450 tree maybe_super_class
2451 = maybe_layout_super_class (super_class
, this_class
);
2452 if (maybe_super_class
== NULL
2453 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2455 TYPE_SIZE (this_class
) = error_mark_node
;
2456 CLASS_BEING_LAIDOUT (this_class
) = 0;
2457 class_list
= TREE_CHAIN (class_list
);
2460 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2461 push_super_field (this_class
, maybe_super_class
);
2464 layout_type (this_class
);
2466 /* Also recursively load/layout any superinterfaces. */
2467 if (TYPE_BINFO (this_class
))
2469 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2471 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2472 tree super_interface
= BINFO_TYPE (binfo
);
2473 tree maybe_super_interface
2474 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2475 if (maybe_super_interface
== NULL
2476 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2478 TYPE_SIZE (this_class
) = error_mark_node
;
2479 CLASS_BEING_LAIDOUT (this_class
) = 0;
2480 class_list
= TREE_CHAIN (class_list
);
2486 /* Convert the size back to an SI integer value. */
2487 TYPE_SIZE_UNIT (this_class
) =
2488 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2490 CLASS_BEING_LAIDOUT (this_class
) = 0;
2491 class_list
= TREE_CHAIN (class_list
);
2495 add_miranda_methods (tree base_class
, tree search_class
)
2498 tree binfo
, base_binfo
;
2500 if (!CLASS_PARSED_P (search_class
))
2501 load_class (search_class
, 1);
2503 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2504 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2507 tree elt
= BINFO_TYPE (base_binfo
);
2509 /* FIXME: This is totally bogus. We should not be handling
2510 Miranda methods at all if we're using the BC ABI. */
2511 if (TYPE_DUMMY (elt
))
2514 /* Ensure that interface methods are seen in declared order. */
2515 if (!CLASS_LOADED_P (elt
))
2516 load_class (elt
, 1);
2517 layout_class_methods (elt
);
2519 /* All base classes will have been laid out at this point, so the order
2520 will be correct. This code must match similar layout code in the
2522 for (method_decl
= TYPE_METHODS (elt
);
2523 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2527 /* An interface can have <clinit>. */
2528 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2531 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2532 override
= lookup_argument_method (base_class
,
2533 DECL_NAME (method_decl
), sig
);
2534 if (override
== NULL_TREE
)
2536 /* Found a Miranda method. Add it. */
2538 sig
= build_java_signature (TREE_TYPE (method_decl
));
2540 = add_method (base_class
,
2541 get_access_flags_from_decl (method_decl
),
2542 DECL_NAME (method_decl
), sig
);
2543 METHOD_INVISIBLE (new_method
) = 1;
2547 /* Try superinterfaces. */
2548 add_miranda_methods (base_class
, elt
);
2553 layout_class_methods (tree this_class
)
2555 tree method_decl
, dtable_count
;
2556 tree super_class
, type_name
;
2558 if (TYPE_NVIRTUALS (this_class
))
2561 super_class
= CLASSTYPE_SUPER (this_class
);
2565 super_class
= maybe_layout_super_class (super_class
, this_class
);
2566 if (!TYPE_NVIRTUALS (super_class
))
2567 layout_class_methods (super_class
);
2568 dtable_count
= TYPE_NVIRTUALS (super_class
);
2571 dtable_count
= integer_zero_node
;
2573 type_name
= TYPE_NAME (this_class
);
2574 if (!flag_indirect_dispatch
2575 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2577 /* An abstract class can have methods which are declared only in
2578 an implemented interface. These are called "Miranda
2579 methods". We make a dummy method entry for such methods
2581 add_miranda_methods (this_class
, this_class
);
2584 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2586 for (method_decl
= TYPE_METHODS (this_class
);
2587 method_decl
; method_decl
= TREE_CHAIN (method_decl
))
2588 dtable_count
= layout_class_method (this_class
, super_class
,
2589 method_decl
, dtable_count
);
2591 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2594 /* Return the index of METHOD in INTERFACE. This index begins at 1
2595 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2597 get_interface_method_index (tree method
, tree interface
)
2602 for (meth
= TYPE_METHODS (interface
); ; meth
= TREE_CHAIN (meth
))
2606 /* We don't want to put <clinit> into the interface table. */
2607 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2609 gcc_assert (meth
!= NULL_TREE
);
2613 /* Lay METHOD_DECL out, returning a possibly new value of
2614 DTABLE_COUNT. Also mangle the method's name. */
2617 layout_class_method (tree this_class
, tree super_class
,
2618 tree method_decl
, tree dtable_count
)
2620 tree method_name
= DECL_NAME (method_decl
);
2622 TREE_PUBLIC (method_decl
) = 1;
2624 if (flag_indirect_classes
2625 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2626 && ! METHOD_NATIVE (method_decl
)
2627 && ! special_method_p (method_decl
)))
2628 java_hide_decl (method_decl
);
2630 /* Considered external unless it is being compiled into this object
2631 file, or it was already flagged as external. */
2632 if (!DECL_EXTERNAL (method_decl
))
2633 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2634 || METHOD_NATIVE (method_decl
));
2636 if (ID_INIT_P (method_name
))
2638 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2640 for (ptr
= p
; *ptr
; )
2645 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2646 build_java_signature (TREE_TYPE (method_decl
));
2648 else if (! METHOD_STATIC (method_decl
))
2651 build_java_signature (TREE_TYPE (method_decl
));
2652 bool method_override
= false;
2653 tree super_method
= lookup_java_method (super_class
, method_name
,
2655 if (super_method
!= NULL_TREE
2656 && ! METHOD_DUMMY (super_method
))
2658 method_override
= true;
2659 if (! METHOD_PUBLIC (super_method
) &&
2660 ! METHOD_PROTECTED (super_method
))
2662 /* Don't override private method, or default-access method in
2664 if (METHOD_PRIVATE (super_method
) ||
2665 ! in_same_package (TYPE_NAME (this_class
),
2666 TYPE_NAME (super_class
)))
2667 method_override
= false;
2670 if (method_override
)
2672 tree method_index
= get_method_index (super_method
);
2673 set_method_index (method_decl
, method_index
);
2674 if (method_index
== NULL_TREE
2675 && ! flag_indirect_dispatch
2676 && ! DECL_ARTIFICIAL (super_method
))
2677 error ("non-static method %q+D overrides static method",
2680 else if (this_class
== object_type_node
2681 && (METHOD_FINAL (method_decl
)
2682 || METHOD_PRIVATE (method_decl
)))
2684 /* We don't generate vtable entries for final Object
2685 methods. This is simply to save space, since every
2686 object would otherwise have to define them. */
2688 else if (! METHOD_PRIVATE (method_decl
)
2691 /* We generate vtable entries for final methods because they
2692 may one day be changed to non-final. */
2693 set_method_index (method_decl
, dtable_count
);
2694 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2695 dtable_count
, integer_one_node
);
2699 return dtable_count
;
2703 register_class (void)
2707 if (!registered_class
)
2708 registered_class
= VEC_alloc (tree
, gc
, 8);
2710 if (flag_indirect_classes
)
2711 node
= current_class
;
2713 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2714 VEC_safe_push (tree
, gc
, registered_class
, node
);
2717 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2718 all the classes we have emitted. */
2721 emit_indirect_register_classes (tree
*list_p
)
2723 tree klass
, t
, register_class_fn
;
2726 tree init
= NULL_TREE
;
2727 int size
= VEC_length (tree
, registered_class
) * 2 + 1;
2728 tree class_array_type
2729 = build_prim_array_type (ptr_type_node
, size
);
2730 tree
cdecl = build_decl (input_location
,
2731 VAR_DECL
, get_identifier ("_Jv_CLS"),
2733 tree reg_class_list
;
2734 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2736 init
= tree_cons (NULL_TREE
,
2737 fold_convert (ptr_type_node
,
2738 build_static_class_ref (klass
)), init
);
2741 fold_convert (ptr_type_node
,
2742 build_address_of (build_classdollar_field (klass
))),
2745 init
= tree_cons (NULL_TREE
, integer_zero_node
, init
);
2746 DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type
,
2748 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2749 TREE_STATIC (cdecl) = 1;
2750 DECL_ARTIFICIAL (cdecl) = 1;
2751 DECL_IGNORED_P (cdecl) = 1;
2752 TREE_READONLY (cdecl) = 1;
2753 TREE_CONSTANT (cdecl) = 1;
2754 rest_of_decl_compilation (cdecl, 1, 0);
2755 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2757 t
= build_function_type_list (void_type_node
,
2758 build_pointer_type (ptr_type_node
), NULL
);
2759 t
= build_decl (input_location
,
2761 get_identifier ("_Jv_RegisterNewClasses"), t
);
2762 TREE_PUBLIC (t
) = 1;
2763 DECL_EXTERNAL (t
) = 1;
2764 register_class_fn
= t
;
2765 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2766 append_to_statement_list (t
, list_p
);
2770 /* Emit something to register classes at start-up time.
2772 The preferred mechanism is through the .jcr section, which contain
2773 a list of pointers to classes which get registered during constructor
2776 The fallback mechanism is to add statements to *LIST_P to call
2777 _Jv_RegisterClass for each class in this file. These statements will
2778 be added to a static constructor function for this translation unit. */
2781 emit_register_classes (tree
*list_p
)
2783 if (registered_class
== NULL
)
2786 if (flag_indirect_classes
)
2788 emit_indirect_register_classes (list_p
);
2792 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2793 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2794 but lack suitable crtbegin/end objects or linker support. These
2795 targets can override the default in tm.h to use the fallback mechanism. */
2796 if (TARGET_USE_JCR_SECTION
)
2801 #ifdef JCR_SECTION_NAME
2802 switch_to_section (get_section (JCR_SECTION_NAME
, SECTION_WRITE
, NULL
));
2804 /* A target has defined TARGET_USE_JCR_SECTION,
2805 but doesn't have a JCR_SECTION_NAME. */
2808 assemble_align (POINTER_SIZE
);
2810 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2812 t
= build_fold_addr_expr (klass
);
2813 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2818 tree klass
, t
, register_class_fn
;
2821 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2822 t
= build_decl (input_location
,
2823 FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2824 TREE_PUBLIC (t
) = 1;
2825 DECL_EXTERNAL (t
) = 1;
2826 register_class_fn
= t
;
2828 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2830 t
= build_fold_addr_expr (klass
);
2831 t
= build_call_expr (register_class_fn
, 1, t
);
2832 append_to_statement_list (t
, list_p
);
2837 /* Build a constructor for an entry in the symbol table. */
2840 build_symbol_table_entry (tree clname
, tree name
, tree signature
)
2843 VEC(constructor_elt
,gc
) *v
= NULL
;
2845 START_RECORD_CONSTRUCTOR (v
, symbol_type
);
2846 PUSH_FIELD_VALUE (v
, "clname", clname
);
2847 PUSH_FIELD_VALUE (v
, "name", name
);
2848 PUSH_FIELD_VALUE (v
, "signature", signature
);
2849 FINISH_RECORD_CONSTRUCTOR (symbol
, v
, symbol_type
);
2850 TREE_CONSTANT (symbol
) = 1;
2855 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2858 build_symbol_entry (tree decl
, tree special
)
2860 tree clname
, name
, signature
;
2861 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2862 /* ??? Constructors are given the name foo.foo all the way through
2863 the compiler, but in the method table they're all renamed
2864 foo.<init>. So, we have to do the same here unless we want an
2865 unresolved reference at runtime. */
2866 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2867 && DECL_CONSTRUCTOR_P (decl
))
2868 ? init_identifier_node
2869 : DECL_NAME (decl
));
2870 signature
= build_java_signature (TREE_TYPE (decl
));
2871 signature
= build_utf8_ref (unmangle_classname
2872 (IDENTIFIER_POINTER (signature
),
2873 IDENTIFIER_LENGTH (signature
)));
2874 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2875 signature addr+1 if SPECIAL, and this indicates to the runtime
2876 system that this is a "special" symbol, i.e. one that should
2877 bypass access controls. */
2878 if (special
!= NULL_TREE
)
2879 signature
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (signature
), signature
,
2880 fold_convert (sizetype
, special
));
2882 return build_symbol_table_entry (clname
, name
, signature
);
2885 /* Emit a symbol table: used by -findirect-dispatch. */
2888 emit_symbol_table (tree name
, tree the_table
, tree decl_list
,
2889 tree the_syms_decl
, tree the_array_element_type
,
2892 tree method_list
, method
, table
, list
, null_symbol
;
2893 tree table_size
, the_array_type
;
2896 /* Only emit a table if this translation unit actually made any
2897 references via it. */
2898 if (decl_list
== NULL_TREE
)
2901 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2903 method_list
= decl_list
;
2905 while (method_list
!= NULL_TREE
)
2907 tree special
= TREE_PURPOSE (method_list
);
2908 method
= TREE_VALUE (method_list
);
2909 list
= tree_cons (NULL_TREE
, build_symbol_entry (method
, special
), list
);
2910 method_list
= TREE_CHAIN (method_list
);
2914 /* Terminate the list with a "null" entry. */
2915 null_symbol
= build_symbol_table_entry (null_pointer_node
,
2918 list
= tree_cons (NULL_TREE
, null_symbol
, list
);
2920 /* Put the list in the right order and make it a constructor. */
2921 list
= nreverse (list
);
2922 table
= build_constructor_from_list (symbols_array_type
, list
);
2924 /* Make it the initial value for otable_syms and emit the decl. */
2925 DECL_INITIAL (the_syms_decl
) = table
;
2926 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2927 DECL_IGNORED_P (the_syms_decl
) = 1;
2928 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2930 /* Now that its size is known, redefine the table as an
2931 uninitialized static array of INDEX + 1 elements. The extra entry
2932 is used by the runtime to track whether the table has been
2935 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2936 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2937 the_table
= build_decl (input_location
,
2938 VAR_DECL
, name
, the_array_type
);
2939 TREE_STATIC (the_table
) = 1;
2940 TREE_READONLY (the_table
) = 1;
2941 rest_of_decl_compilation (the_table
, 1, 0);
2946 /* Make an entry for the catch_classes list. */
2948 make_catch_class_record (tree catch_class
, tree classname
)
2951 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2952 VEC(constructor_elt
,gc
) *v
= NULL
;
2953 START_RECORD_CONSTRUCTOR (v
, type
);
2954 PUSH_FIELD_VALUE (v
, "address", catch_class
);
2955 PUSH_FIELD_VALUE (v
, "classname", classname
);
2956 FINISH_RECORD_CONSTRUCTOR (entry
, v
, type
);
2961 /* Generate the list of Throwable classes that are caught by exception
2962 handlers in this class. */
2964 emit_catch_table (tree this_class
)
2966 tree table
, table_size
, array_type
;
2967 TYPE_CATCH_CLASSES (this_class
) =
2969 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2970 TYPE_CATCH_CLASSES (this_class
));
2971 TYPE_CATCH_CLASSES (this_class
) = nreverse (TYPE_CATCH_CLASSES (this_class
));
2972 TYPE_CATCH_CLASSES (this_class
) =
2974 make_catch_class_record (null_pointer_node
, null_pointer_node
),
2975 TYPE_CATCH_CLASSES (this_class
));
2976 table_size
= build_index_type
2977 (build_int_cst (NULL_TREE
,
2978 list_length (TYPE_CATCH_CLASSES (this_class
))));
2980 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
2983 build_decl (input_location
,
2984 VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
2985 DECL_INITIAL (table
) =
2986 build_constructor_from_list (array_type
, TYPE_CATCH_CLASSES (this_class
));
2987 TREE_STATIC (table
) = 1;
2988 TREE_READONLY (table
) = 1;
2989 DECL_IGNORED_P (table
) = 1;
2990 rest_of_decl_compilation (table
, 1, 0);
2994 /* Given a type, return the signature used by
2995 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
2996 same as build_java_signature() because we want the canonical array
3000 build_signature_for_libgcj (tree type
)
3004 sig
= build_java_signature (type
);
3005 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
3006 IDENTIFIER_LENGTH (sig
)));
3010 /* Build an entry in the type assertion table. */
3013 build_assertion_table_entry (tree code
, tree op1
, tree op2
)
3015 VEC(constructor_elt
,gc
) *v
= NULL
;
3018 START_RECORD_CONSTRUCTOR (v
, assertion_entry_type
);
3019 PUSH_FIELD_VALUE (v
, "assertion_code", code
);
3020 PUSH_FIELD_VALUE (v
, "op1", op1
);
3021 PUSH_FIELD_VALUE (v
, "op2", op2
);
3022 FINISH_RECORD_CONSTRUCTOR (entry
, v
, assertion_entry_type
);
3027 /* Add an entry to the type assertion table. Callback used during hashtable
3031 add_assertion_table_entry (void **htab_entry
, void *ptr
)
3034 tree code_val
, op1_utf8
, op2_utf8
;
3035 tree
*list
= (tree
*) ptr
;
3036 type_assertion
*as
= (type_assertion
*) *htab_entry
;
3038 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
3040 if (as
->op1
== NULL_TREE
)
3041 op1_utf8
= null_pointer_node
;
3043 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3045 if (as
->op2
== NULL_TREE
)
3046 op2_utf8
= null_pointer_node
;
3048 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3050 entry
= build_assertion_table_entry (code_val
, op1_utf8
, op2_utf8
);
3052 *list
= tree_cons (NULL_TREE
, entry
, *list
);
3056 /* Generate the type assertion table for KLASS, and return its DECL. */
3059 emit_assertion_table (tree klass
)
3061 tree null_entry
, ctor
, table_decl
;
3062 tree list
= NULL_TREE
;
3063 htab_t assertions_htab
= TYPE_ASSERTIONS (klass
);
3065 /* Iterate through the hash table. */
3066 htab_traverse (assertions_htab
, add_assertion_table_entry
, &list
);
3068 /* Finish with a null entry. */
3069 null_entry
= build_assertion_table_entry (integer_zero_node
,
3073 list
= tree_cons (NULL_TREE
, null_entry
, list
);
3075 /* Put the list in the right order and make it a constructor. */
3076 list
= nreverse (list
);
3077 ctor
= build_constructor_from_list (assertion_table_type
, list
);
3079 table_decl
= build_decl (input_location
,
3080 VAR_DECL
, mangled_classname ("_type_assert_", klass
),
3081 assertion_table_type
);
3083 TREE_STATIC (table_decl
) = 1;
3084 TREE_READONLY (table_decl
) = 1;
3085 TREE_CONSTANT (table_decl
) = 1;
3086 DECL_IGNORED_P (table_decl
) = 1;
3088 DECL_INITIAL (table_decl
) = ctor
;
3089 DECL_ARTIFICIAL (table_decl
) = 1;
3090 rest_of_decl_compilation (table_decl
, 1, 0);
3096 init_class_processing (void)
3098 fields_ident
= get_identifier ("fields");
3099 info_ident
= get_identifier ("info");
3101 gcc_obstack_init (&temporary_obstack
);
3104 static hashval_t
java_treetreehash_hash (const void *);
3105 static int java_treetreehash_compare (const void *, const void *);
3107 /* A hash table mapping trees to trees. Used generally. */
3109 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3112 java_treetreehash_hash (const void *k_p
)
3114 const struct treetreehash_entry
*const k
3115 = (const struct treetreehash_entry
*) k_p
;
3116 return JAVA_TREEHASHHASH_H (k
->key
);
3120 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3122 const struct treetreehash_entry
*const k1
3123 = (const struct treetreehash_entry
*) k1_p
;
3124 const_tree
const k2
= (const_tree
) k2_p
;
3125 return (k1
->key
== k2
);
3129 java_treetreehash_find (htab_t ht
, tree t
)
3131 struct treetreehash_entry
*e
;
3132 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3133 e
= (struct treetreehash_entry
*) htab_find_with_hash (ht
, t
, hv
);
3141 java_treetreehash_new (htab_t ht
, tree t
)
3144 struct treetreehash_entry
*tthe
;
3145 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3147 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3150 tthe
= (struct treetreehash_entry
*) (*ht
->alloc_f
) (1, sizeof (*tthe
));
3155 tthe
= (struct treetreehash_entry
*) *e
;
3156 return &tthe
->value
;
3160 java_treetreehash_create (size_t size
, int gc
)
3163 return htab_create_ggc (size
, java_treetreehash_hash
,
3164 java_treetreehash_compare
, NULL
);
3166 return htab_create_alloc (size
, java_treetreehash_hash
,
3167 java_treetreehash_compare
, free
, xcalloc
, free
);
3170 /* Break down qualified IDENTIFIER into package and class-name components.
3171 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3172 "pkg.foo", and RIGHT to "Bar". */
3175 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3178 int l
= IDENTIFIER_LENGTH (source
);
3180 base
= (char *) alloca (l
+ 1);
3181 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3183 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3185 while (*p
!= '.' && p
!= base
)
3188 /* We didn't find a '.'. Return an error. */
3194 *right
= get_identifier (p
+1);
3195 *left
= get_identifier (base
);
3200 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3201 if the classes are from the same package. */
3204 in_same_package (tree name1
, tree name2
)
3210 if (TREE_CODE (name1
) == TYPE_DECL
)
3211 name1
= DECL_NAME (name1
);
3212 if (TREE_CODE (name2
) == TYPE_DECL
)
3213 name2
= DECL_NAME (name2
);
3215 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3216 /* One in empty package. */
3219 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3220 /* Both in empty package. */
3223 split_qualified_name (&pkg1
, &tmp
, name1
);
3224 split_qualified_name (&pkg2
, &tmp
, name2
);
3226 return (pkg1
== pkg2
);
3229 /* lang_hooks.decls.final_write_globals: perform final processing on
3230 global variables. */
3233 java_write_globals (void)
3235 tree
*vec
= VEC_address (tree
, pending_static_fields
);
3236 int len
= VEC_length (tree
, pending_static_fields
);
3237 write_global_declarations ();
3238 emit_debug_global_declarations (vec
, len
);
3239 VEC_free (tree
, gc
, pending_static_fields
);
3242 #include "gt-java-class.h"