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, 2011, 2012 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"
35 #include "diagnostic-core.h"
37 #include "output.h" /* for switch_to_section and get_section */
42 #include "tree-iterator.h"
45 static tree
make_method_value (tree
);
46 static tree
build_java_method_type (tree
, tree
, int);
47 static int32
hashUtf8String (const char *, int);
48 static tree
make_field_value (tree
);
49 static tree
get_dispatch_vector (tree
);
50 static tree
get_dispatch_table (tree
, tree
);
51 static int supers_all_compiled (tree type
);
52 static tree
maybe_layout_super_class (tree
, tree
);
53 static void add_miranda_methods (tree
, tree
);
54 static int assume_compiled (const char *);
55 static tree
build_symbol_entry (tree
, tree
);
56 static tree
emit_assertion_table (tree
);
57 static void register_class (void);
59 struct obstack temporary_obstack
;
61 static const char *cyclic_inheritance_report
;
63 /* The compiler generates different code depending on whether or not
64 it can assume certain classes have been compiled down to native
65 code or not. The compiler options -fassume-compiled= and
66 -fno-assume-compiled= are used to create a tree of
67 class_flag_node objects. This tree is queried to determine if
68 a class is assume to be compiled or not. Each node in the tree
69 represents either a package or a specific class. */
71 typedef struct class_flag_node_struct
73 /* The class or package name. */
76 /* Nonzero if this represents an exclusion. */
79 /* Pointers to other nodes in the tree. */
80 struct class_flag_node_struct
*parent
;
81 struct class_flag_node_struct
*sibling
;
82 struct class_flag_node_struct
*child
;
85 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
86 static void add_class_flag (class_flag_node
**, const char *, int);
88 /* This is the root of the include/exclude tree. */
90 static class_flag_node
*assume_compiled_tree
;
92 static class_flag_node
*enable_assert_tree
;
94 static GTY(()) tree class_roots
[4];
95 #define fields_ident class_roots[0] /* get_identifier ("fields") */
96 #define info_ident class_roots[1] /* get_identifier ("info") */
97 #define class_list class_roots[2]
98 #define class_dtable_decl class_roots[3]
100 static GTY(()) vec
<tree
, va_gc
> *registered_class
;
102 /* A tree that returns the address of the class$ of the class
103 currently being compiled. */
104 static GTY(()) tree this_classdollar
;
106 /* A list of static class fields. This is to emit proper debug
108 vec
<tree
, va_gc
> *pending_static_fields
;
110 /* Return the node that most closely represents the class whose name
111 is IDENT. Start the search from NODE (followed by its siblings).
112 Return NULL if an appropriate node does not exist. */
114 static class_flag_node
*
115 find_class_flag_node (class_flag_node
*node
, const char *ident
)
119 size_t node_ident_length
= strlen (node
->ident
);
121 /* node_ident_length is zero at the root of the tree. If the
122 identifiers are the same length, then we have matching
123 classes. Otherwise check if we've matched an enclosing
126 if (node_ident_length
== 0
127 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
128 && (ident
[node_ident_length
] == '\0'
129 || ident
[node_ident_length
] == '.')))
131 /* We've found a match, however, there might be a more
134 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
141 /* No match yet. Continue through the sibling list. */
142 node
= node
->sibling
;
145 /* No match at all in this tree. */
150 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
152 class_flag_node
*root
= *rootp
;
153 class_flag_node
*parent
, *node
;
155 /* Create the root of the tree if it doesn't exist yet. */
159 root
= XNEW (class_flag_node
);
162 root
->sibling
= NULL
;
168 /* Calling the function with the empty string means we're setting
169 value for the root of the hierarchy. */
177 /* Find the parent node for this new node. PARENT will either be a
178 class or a package name. Adjust PARENT accordingly. */
180 parent
= find_class_flag_node (root
, ident
);
181 if (strcmp (ident
, parent
->ident
) == 0)
182 parent
->value
= value
;
185 /* Insert new node into the tree. */
186 node
= XNEW (class_flag_node
);
188 node
->ident
= xstrdup (ident
);
192 node
->parent
= parent
;
193 node
->sibling
= parent
->child
;
194 parent
->child
= node
;
198 /* Add a new IDENT to the include/exclude tree. It's an exclusion
199 if EXCLUDEP is nonzero. */
202 add_assume_compiled (const char *ident
, int excludep
)
204 add_class_flag (&assume_compiled_tree
, ident
, excludep
);
207 /* The default value returned by enable_assertions. */
209 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
211 /* Enter IDENT (a class or package name) into the enable-assertions table.
212 VALUE is true to enable and false to disable. */
215 add_enable_assert (const char *ident
, int value
)
217 if (enable_assert_tree
== NULL
)
218 add_class_flag (&enable_assert_tree
, "", DEFAULT_ENABLE_ASSERT
);
219 add_class_flag (&enable_assert_tree
, ident
, value
);
222 /* Returns nonzero if IDENT is the name of a class that the compiler
223 should assume has been compiled to object code. */
226 assume_compiled (const char *ident
)
231 if (NULL
== assume_compiled_tree
)
234 i
= find_class_flag_node (assume_compiled_tree
, ident
);
241 /* Return true if we should generate code to check assertions within KLASS. */
244 enable_assertions (tree klass
)
246 /* Check if command-line specifies whether we should check assertions. */
248 if (klass
!= NULL_TREE
&& DECL_NAME (klass
) && enable_assert_tree
!= NULL
)
250 const char *ident
= IDENTIFIER_POINTER (DECL_NAME (klass
));
251 class_flag_node
*node
252 = find_class_flag_node (enable_assert_tree
, ident
);
256 /* The default is to enable assertions if generating class files,
257 or not optimizing. */
258 return DEFAULT_ENABLE_ASSERT
;
261 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
262 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
263 Also, PREFIX is prepended, and SUFFIX is appended. */
266 ident_subst (const char* old_name
,
273 int prefix_len
= strlen (prefix
);
274 int suffix_len
= strlen (suffix
);
275 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
276 char *buffer
= (char *) alloca (i
);
278 strcpy (buffer
, prefix
);
279 for (i
= 0; i
< old_length
; i
++)
281 char ch
= old_name
[i
];
284 buffer
[prefix_len
+ i
] = ch
;
286 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
287 return get_identifier (buffer
);
290 /* Return an IDENTIFIER_NODE the same as OLD_ID,
291 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
292 Also, PREFIX is prepended, and SUFFIX is appended. */
295 identifier_subst (const tree old_id
,
301 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
302 prefix
, old_char
, new_char
, suffix
);
305 /* Generate a valid C identifier from the name of the class TYPE,
306 prefixed by PREFIX. */
309 mangled_classname (const char *prefix
, tree type
)
312 tree ident
= TYPE_NAME (type
);
313 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
314 ident
= DECL_NAME (ident
);
315 result
= identifier_subst (ident
, prefix
, '.', '_', "");
317 /* Replace any characters that aren't in the set [0-9a-zA-Z_$] with
318 "_0xXX". Class names containing such chracters are uncommon, but
319 they do sometimes occur in class files. Without this check,
320 these names cause assembly errors.
322 There is a possibility that a real class name could conflict with
323 the identifier we generate, but it is unlikely and will
324 immediately be detected as an assembler error. At some point we
325 should do something more elaborate (perhaps using the full
326 unicode mangling scheme) in order to prevent such a conflict. */
329 const int len
= IDENTIFIER_LENGTH (result
);
330 const char *p
= IDENTIFIER_POINTER (result
);
331 int illegal_chars
= 0;
333 /* Make two passes over the identifier. The first pass is merely
334 to count illegal characters; we need to do this in order to
335 allocate a buffer. */
336 for (i
= 0; i
< len
; i
++)
339 illegal_chars
+= (! ISALNUM (c
) && c
!= '_' && c
!= '$');
342 /* And the second pass, which is rarely executed, does the
344 if (illegal_chars
!= 0)
346 char *buffer
= (char *) alloca (illegal_chars
* 4 + len
+ 1);
349 for (i
= 0, j
= 0; i
< len
; i
++)
352 if (! ISALNUM (c
) && c
!= '_' && c
!= '$')
355 sprintf (&buffer
[j
], "0x%02x", c
);
363 result
= get_identifier (buffer
);
374 type
= make_node (RECORD_TYPE
);
375 /* Unfortunately we must create the binfo here, so that class
377 TYPE_BINFO (type
) = make_tree_binfo (0);
378 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
379 TYPE_CATCH_CLASSES (type
) = NULL
;
380 /* Push a dummy entry; we can't call make_catch_class_record here
381 because other infrastructure may not be set up yet. We'll come
382 back and fill it in later once said infrastructure is
384 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (type
), NULL_TREE
, NULL_TREE
);
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_alloc_cleared_lang_decl(sizeof (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
) = java_treetreehash_create (10);
773 /* Initialize the initialized (static) class table. */
774 if (access_flags
& ACC_STATIC
)
775 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
776 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
778 DECL_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
779 TYPE_METHODS (this_class
) = fndecl
;
781 /* If pointers to member functions use the least significant bit to
782 indicate whether a function is virtual, ensure a pointer
783 to this function will have that bit clear. */
784 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
785 && !(access_flags
& ACC_STATIC
)
786 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
787 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
789 /* Notice that this is a finalizer and update the class type
790 accordingly. This is used to optimize instance allocation. */
791 if (name
== finalize_identifier_node
792 && TREE_TYPE (function_type
) == void_type_node
793 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
794 HAS_FINALIZER_P (this_class
) = 1;
796 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
797 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
798 if (access_flags
& ACC_PRIVATE
)
799 METHOD_PRIVATE (fndecl
) = 1;
800 if (access_flags
& ACC_NATIVE
)
802 METHOD_NATIVE (fndecl
) = 1;
803 DECL_EXTERNAL (fndecl
) = 1;
806 /* FNDECL is external unless we are compiling it into this object
808 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
809 if (access_flags
& ACC_STATIC
)
810 METHOD_STATIC (fndecl
) = 1;
811 if (access_flags
& ACC_FINAL
)
812 METHOD_FINAL (fndecl
) = 1;
813 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
814 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
815 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
816 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
817 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
818 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
822 /* Add a method to THIS_CLASS.
823 The method's name is NAME.
824 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
827 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
829 tree function_type
, fndecl
;
830 const unsigned char *sig
831 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
834 fatal_error ("bad method signature");
836 function_type
= get_type_from_signature (method_sig
);
837 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
838 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
843 add_field (tree klass
, tree name
, tree field_type
, int flags
)
845 int is_static
= (flags
& ACC_STATIC
) != 0;
847 field
= build_decl (input_location
,
848 is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
849 DECL_CHAIN (field
) = TYPE_FIELDS (klass
);
850 TYPE_FIELDS (klass
) = field
;
851 DECL_CONTEXT (field
) = klass
;
852 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
854 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
855 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
856 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
857 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
858 if (flags
& ACC_VOLATILE
)
860 FIELD_VOLATILE (field
) = 1;
861 TREE_THIS_VOLATILE (field
) = 1;
863 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
864 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
865 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
868 FIELD_STATIC (field
) = 1;
869 /* Always make field externally visible. This is required so
870 that native methods can always access the field. */
871 TREE_PUBLIC (field
) = 1;
872 /* Hide everything that shouldn't be visible outside a DSO. */
873 if (flag_indirect_classes
874 || (FIELD_PRIVATE (field
)))
875 java_hide_decl (field
);
876 /* Considered external unless we are compiling it into this
878 DECL_EXTERNAL (field
) = (is_compiled_class (klass
) != 2);
879 if (!DECL_EXTERNAL (field
))
880 vec_safe_push (pending_static_fields
, field
);
886 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
889 set_constant_value (tree field
, tree constant
)
891 if (field
== NULL_TREE
)
892 warning (OPT_Wattributes
,
893 "misplaced ConstantValue attribute (not in any field)");
894 else if (DECL_INITIAL (field
) != NULL_TREE
)
895 warning (OPT_Wattributes
,
896 "duplicate ConstantValue attribute for field '%s'",
897 IDENTIFIER_POINTER (DECL_NAME (field
)));
900 DECL_INITIAL (field
) = constant
;
901 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
902 && ! (TREE_TYPE (constant
) == int_type_node
903 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
904 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
905 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
906 && TREE_TYPE (field
) == string_ptr_type_node
))
907 error ("ConstantValue attribute of field '%s' has wrong type",
908 IDENTIFIER_POINTER (DECL_NAME (field
)));
912 /* Calculate a hash value for a string encoded in Utf8 format.
913 * This returns the same hash value as specified for java.lang.String.hashCode.
917 hashUtf8String (const char *str
, int len
)
919 const unsigned char* ptr
= (const unsigned char*) str
;
920 const unsigned char *limit
= ptr
+ len
;
924 int ch
= UTF8_GET (ptr
, limit
);
925 /* Updated specification from
926 http://www.javasoft.com/docs/books/jls/clarify.html. */
927 hash
= (31 * hash
) + ch
;
933 build_utf8_ref (tree name
)
935 const char * name_ptr
= IDENTIFIER_POINTER (name
);
936 int name_len
= IDENTIFIER_LENGTH (name
), name_pad
;
938 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
939 static int utf8_count
= 0;
941 tree ref
= IDENTIFIER_UTF8_REF (name
);
943 vec
<constructor_elt
, va_gc
> *v
= NULL
;
944 if (ref
!= NULL_TREE
)
947 ctype
= make_node (RECORD_TYPE
);
948 /* '\0' byte plus padding to utf8const_type's alignment. */
949 name_pad
= TYPE_ALIGN_UNIT (utf8const_type
)
950 - (name_len
& (TYPE_ALIGN_UNIT (utf8const_type
) - 1));
951 str_type
= build_prim_array_type (unsigned_byte_type_node
,
952 name_len
+ name_pad
);
953 PUSH_FIELD (input_location
, ctype
, field
, "hash", unsigned_short_type_node
);
954 PUSH_FIELD (input_location
,
955 ctype
, field
, "length", unsigned_short_type_node
);
956 PUSH_FIELD (input_location
, ctype
, field
, "data", str_type
);
957 FINISH_RECORD (ctype
);
958 START_RECORD_CONSTRUCTOR (v
, ctype
);
959 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
960 PUSH_FIELD_VALUE (v
, "hash", build_int_cst (NULL_TREE
, name_hash
));
961 PUSH_FIELD_VALUE (v
, "length", build_int_cst (NULL_TREE
, name_len
));
962 string
= build_string (name_len
, name_ptr
);
963 TREE_TYPE (string
) = str_type
;
964 PUSH_FIELD_VALUE (v
, "data", string
);
965 FINISH_RECORD_CONSTRUCTOR (cinit
, v
, ctype
);
966 TREE_CONSTANT (cinit
) = 1;
968 /* Generate a unique-enough identifier. */
969 sprintf(buf
, "_Utf%d", ++utf8_count
);
971 decl
= build_decl (input_location
,
972 VAR_DECL
, get_identifier (buf
), utf8const_type
);
973 TREE_STATIC (decl
) = 1;
974 DECL_ARTIFICIAL (decl
) = 1;
975 DECL_IGNORED_P (decl
) = 1;
976 TREE_READONLY (decl
) = 1;
977 TREE_THIS_VOLATILE (decl
) = 0;
978 DECL_INITIAL (decl
) = cinit
;
979 DECL_USER_ALIGN (decl
) = 1;
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 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
1003 IDENTIFIER_UTF8_REF (name
) = ref
;
1007 /* Like build_class_ref, but instead of a direct reference generate a
1008 pointer into the constant pool. */
1011 build_indirect_class_ref (tree type
)
1015 index
= alloc_class_constant (type
);
1016 cl
= build_ref_from_constant_pool (index
);
1017 return convert (promote_type (class_ptr_type
), cl
);
1021 build_static_class_ref (tree type
)
1023 tree decl_name
, decl
, ref
;
1025 if (TYPE_SIZE (type
) == error_mark_node
)
1026 return null_pointer_node
;
1027 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1028 "", '/', '/', ".class$$");
1029 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1030 if (decl
== NULL_TREE
)
1032 decl
= build_decl (input_location
, VAR_DECL
, decl_name
, class_type_node
);
1033 TREE_STATIC (decl
) = 1;
1034 if (! flag_indirect_classes
)
1036 TREE_PUBLIC (decl
) = 1;
1037 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1038 java_hide_decl (decl
);
1040 DECL_IGNORED_P (decl
) = 1;
1041 DECL_ARTIFICIAL (decl
) = 1;
1042 if (is_compiled_class (type
) == 1)
1043 DECL_EXTERNAL (decl
) = 1;
1044 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1045 DECL_CLASS_FIELD_P (decl
) = 1;
1046 DECL_CONTEXT (decl
) = type
;
1048 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1049 that that means not calling pushdecl_top_level. */
1050 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1053 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1058 build_classdollar_field (tree type
)
1060 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1061 "", '/', '/', ".class$");
1062 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1064 if (decl
== NULL_TREE
)
1067 = build_decl (input_location
,
1068 VAR_DECL
, decl_name
,
1071 (build_type_variant (class_type_node
,
1073 /* const */ 1, 0)));
1074 TREE_STATIC (decl
) = 1;
1075 TREE_CONSTANT (decl
) = 1;
1076 TREE_READONLY (decl
) = 1;
1077 TREE_PUBLIC (decl
) = 1;
1078 java_hide_decl (decl
);
1079 DECL_IGNORED_P (decl
) = 1;
1080 DECL_ARTIFICIAL (decl
) = 1;
1081 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1082 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1083 DECL_CLASS_FIELD_P (decl
) = 1;
1084 DECL_CONTEXT (decl
) = type
;
1090 /* Create a local variable that holds the current class$. */
1093 cache_this_class_ref (tree fndecl
)
1097 tree classdollar_field
;
1098 if (flag_indirect_classes
)
1099 classdollar_field
= build_classdollar_field (output_class
);
1101 classdollar_field
= build_static_class_ref (output_class
);
1103 this_classdollar
= build_decl (input_location
,
1104 VAR_DECL
, NULL_TREE
,
1105 TREE_TYPE (classdollar_field
));
1107 java_add_local_var (this_classdollar
);
1108 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1109 this_classdollar
, classdollar_field
));
1112 this_classdollar
= build_classdollar_field (output_class
);
1114 /* Prepend class initialization for static methods reachable from
1116 if (METHOD_STATIC (fndecl
)
1117 && (! METHOD_PRIVATE (fndecl
)
1118 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1119 && ! DECL_CLINIT_P (fndecl
)
1120 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1122 tree init
= build_call_expr (soft_initclass_node
, 1,
1124 java_add_stmt (init
);
1128 /* Remove the reference to the local variable that holds the current
1132 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1134 this_classdollar
= build_classdollar_field (output_class
);
1137 /* Build a reference to the class TYPE.
1138 Also handles primitive types and array types. */
1141 build_class_ref (tree type
)
1143 int is_compiled
= is_compiled_class (type
);
1147 if (TREE_CODE (type
) == POINTER_TYPE
)
1148 type
= TREE_TYPE (type
);
1150 if (flag_indirect_dispatch
1151 && type
!= output_class
1152 && TREE_CODE (type
) == RECORD_TYPE
)
1153 return build_indirect_class_ref (type
);
1155 if (type
== output_class
&& flag_indirect_classes
)
1157 /* This can be NULL if we see a JNI stub before we see any
1159 if (! this_classdollar
)
1160 this_classdollar
= build_classdollar_field (output_class
);
1161 return this_classdollar
;
1164 if (TREE_CODE (type
) == RECORD_TYPE
)
1165 return build_static_class_ref (type
);
1171 decl_name
= TYPE_NAME (type
);
1172 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1173 decl_name
= DECL_NAME (decl_name
);
1174 name
= IDENTIFIER_POINTER (decl_name
);
1175 if (strncmp (name
, "promoted_", 9) == 0)
1177 sprintf (buffer
, "_Jv_%sClass", name
);
1178 decl_name
= get_identifier (buffer
);
1179 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1180 if (decl
== NULL_TREE
)
1182 decl
= build_decl (input_location
,
1183 VAR_DECL
, decl_name
, class_type_node
);
1184 TREE_STATIC (decl
) = 1;
1185 TREE_PUBLIC (decl
) = 1;
1186 DECL_EXTERNAL (decl
) = 1;
1187 DECL_ARTIFICIAL (decl
) = 1;
1188 pushdecl_top_level (decl
);
1192 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1196 return build_indirect_class_ref (type
);
1199 /* Create a local statically allocated variable that will hold a
1200 pointer to a static field. */
1203 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1205 tree decl
, decl_name
;
1206 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1207 char *buf
= (char *) alloca (strlen (name
) + 20);
1208 sprintf (buf
, "%s_%d_ref", name
, index
);
1209 decl_name
= get_identifier (buf
);
1210 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1211 if (decl
== NULL_TREE
)
1213 decl
= build_decl (input_location
,
1214 VAR_DECL
, decl_name
, ptr_type_node
);
1215 TREE_STATIC (decl
) = 1;
1216 TREE_PUBLIC (decl
) = 0;
1217 DECL_EXTERNAL (decl
) = 0;
1218 DECL_ARTIFICIAL (decl
) = 1;
1219 DECL_IGNORED_P (decl
) = 1;
1220 pushdecl_top_level (decl
);
1226 build_static_field_ref (tree fdecl
)
1228 tree fclass
= DECL_CONTEXT (fdecl
);
1229 int is_compiled
= is_compiled_class (fclass
);
1231 /* Allow static final fields to fold to a constant. When using
1232 -findirect-dispatch, we simply never do this folding if compiling
1233 from .class; in the .class file constants will be referred to via
1234 the constant pool. */
1235 if (!flag_indirect_dispatch
1237 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1238 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1239 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1240 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1242 if (is_compiled
== 1)
1243 DECL_EXTERNAL (fdecl
) = 1;
1247 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1248 and a class local static variable CACHE_ENTRY, then
1250 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1251 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1254 This can mostly be optimized away, so that the usual path is a
1255 load followed by a test and branch. _Jv_ResolvePoolEntry is
1256 only called once for each constant pool entry.
1258 There is an optimization that we don't do: at the start of a
1259 method, create a local copy of CACHE_ENTRY and use that instead.
1263 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1264 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1266 = build_call_expr (builtin_decl_implicit (BUILT_IN_EXPECT
), 2,
1267 build2 (EQ_EXPR
, boolean_type_node
,
1268 cache_entry
, null_pointer_node
),
1269 boolean_false_node
);
1270 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1272 = build_call_expr (soft_resolvepoolentry_node
, 2,
1273 build_class_ref (output_class
),
1275 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1276 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1277 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1278 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1284 get_access_flags_from_decl (tree decl
)
1286 int access_flags
= 0;
1287 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1289 if (FIELD_STATIC (decl
))
1290 access_flags
|= ACC_STATIC
;
1291 if (FIELD_PUBLIC (decl
))
1292 access_flags
|= ACC_PUBLIC
;
1293 if (FIELD_PROTECTED (decl
))
1294 access_flags
|= ACC_PROTECTED
;
1295 if (FIELD_PRIVATE (decl
))
1296 access_flags
|= ACC_PRIVATE
;
1297 if (FIELD_FINAL (decl
))
1298 access_flags
|= ACC_FINAL
;
1299 if (FIELD_VOLATILE (decl
))
1300 access_flags
|= ACC_VOLATILE
;
1301 if (FIELD_TRANSIENT (decl
))
1302 access_flags
|= ACC_TRANSIENT
;
1303 if (FIELD_ENUM (decl
))
1304 access_flags
|= ACC_ENUM
;
1305 if (FIELD_SYNTHETIC (decl
))
1306 access_flags
|= ACC_SYNTHETIC
;
1307 return access_flags
;
1309 if (TREE_CODE (decl
) == TYPE_DECL
)
1311 if (CLASS_PUBLIC (decl
))
1312 access_flags
|= ACC_PUBLIC
;
1313 if (CLASS_FINAL (decl
))
1314 access_flags
|= ACC_FINAL
;
1315 if (CLASS_SUPER (decl
))
1316 access_flags
|= ACC_SUPER
;
1317 if (CLASS_INTERFACE (decl
))
1318 access_flags
|= ACC_INTERFACE
;
1319 if (CLASS_ABSTRACT (decl
))
1320 access_flags
|= ACC_ABSTRACT
;
1321 if (CLASS_STATIC (decl
))
1322 access_flags
|= ACC_STATIC
;
1323 if (CLASS_PRIVATE (decl
))
1324 access_flags
|= ACC_PRIVATE
;
1325 if (CLASS_PROTECTED (decl
))
1326 access_flags
|= ACC_PROTECTED
;
1327 if (CLASS_STRICTFP (decl
))
1328 access_flags
|= ACC_STRICT
;
1329 if (CLASS_ENUM (decl
))
1330 access_flags
|= ACC_ENUM
;
1331 if (CLASS_SYNTHETIC (decl
))
1332 access_flags
|= ACC_SYNTHETIC
;
1333 if (CLASS_ANNOTATION (decl
))
1334 access_flags
|= ACC_ANNOTATION
;
1335 return access_flags
;
1337 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1339 if (METHOD_PUBLIC (decl
))
1340 access_flags
|= ACC_PUBLIC
;
1341 if (METHOD_PRIVATE (decl
))
1342 access_flags
|= ACC_PRIVATE
;
1343 if (METHOD_PROTECTED (decl
))
1344 access_flags
|= ACC_PROTECTED
;
1345 if (METHOD_STATIC (decl
))
1346 access_flags
|= ACC_STATIC
;
1347 if (METHOD_FINAL (decl
))
1348 access_flags
|= ACC_FINAL
;
1349 if (METHOD_SYNCHRONIZED (decl
))
1350 access_flags
|= ACC_SYNCHRONIZED
;
1351 if (METHOD_NATIVE (decl
))
1352 access_flags
|= ACC_NATIVE
;
1353 if (METHOD_ABSTRACT (decl
))
1354 access_flags
|= ACC_ABSTRACT
;
1355 if (METHOD_STRICTFP (decl
))
1356 access_flags
|= ACC_STRICT
;
1357 if (METHOD_INVISIBLE (decl
))
1358 access_flags
|= ACC_INVISIBLE
;
1359 if (DECL_ARTIFICIAL (decl
))
1360 access_flags
|= ACC_SYNTHETIC
;
1361 if (METHOD_BRIDGE (decl
))
1362 access_flags
|= ACC_BRIDGE
;
1363 if (METHOD_VARARGS (decl
))
1364 access_flags
|= ACC_VARARGS
;
1365 return access_flags
;
1370 static GTY (()) int alias_labelno
= 0;
1372 /* Create a private alias for METHOD. Using this alias instead of the method
1373 decl ensures that ncode entries in the method table point to the real function
1374 at runtime, not a PLT entry. */
1377 make_local_function_alias (tree method
)
1379 #ifdef ASM_OUTPUT_DEF
1382 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1383 char *name
= (char *) alloca (strlen (method_name
) + 2);
1384 char *buf
= (char *) alloca (strlen (method_name
) + 128);
1386 /* Only create aliases for local functions. */
1387 if (DECL_EXTERNAL (method
))
1390 /* Prefix method_name with 'L' for the alias label. */
1392 strcpy (name
+ 1, method_name
);
1394 targetm
.asm_out
.generate_internal_label (buf
, name
, alias_labelno
++);
1395 alias
= build_decl (input_location
,
1396 FUNCTION_DECL
, get_identifier (buf
),
1397 TREE_TYPE (method
));
1398 DECL_CONTEXT (alias
) = NULL
;
1399 TREE_READONLY (alias
) = TREE_READONLY (method
);
1400 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1401 TREE_PUBLIC (alias
) = 0;
1402 DECL_EXTERNAL (alias
) = 0;
1403 DECL_ARTIFICIAL (alias
) = 1;
1404 DECL_INITIAL (alias
) = error_mark_node
;
1405 TREE_ADDRESSABLE (alias
) = 1;
1406 TREE_USED (alias
) = 1;
1407 if (!flag_syntax_only
)
1408 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1415 /** Make reflection data (_Jv_Field) for field FDECL. */
1418 make_field_value (tree fdecl
)
1422 tree type
= TREE_TYPE (fdecl
);
1423 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1424 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1426 START_RECORD_CONSTRUCTOR (v
, field_type_node
);
1427 PUSH_FIELD_VALUE (v
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1429 type
= build_class_ref (type
);
1432 tree signature
= build_java_signature (type
);
1434 type
= build_utf8_ref (unmangle_classname
1435 (IDENTIFIER_POINTER (signature
),
1436 IDENTIFIER_LENGTH (signature
)));
1438 PUSH_FIELD_VALUE (v
, "type", type
);
1440 flags
= get_access_flags_from_decl (fdecl
);
1442 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1444 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, flags
));
1445 PUSH_FIELD_VALUE (v
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1448 tree field_address
= integer_zero_node
;
1450 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1451 && FIELD_STATIC (fdecl
))
1452 field_address
= build_address_of (fdecl
);
1454 index
= (FIELD_STATIC (fdecl
)
1455 ? DECL_CHAIN (TYPE_FIELDS (field_info_union_node
))
1456 : TYPE_FIELDS (field_info_union_node
));
1457 value
= (FIELD_STATIC (fdecl
)
1459 : byte_position (fdecl
));
1463 build_constructor_single (field_info_union_node
, index
, value
));
1466 FINISH_RECORD_CONSTRUCTOR (finit
, v
, field_type_node
);
1470 /** Make reflection data (_Jv_Method) for method MDECL. */
1473 make_method_value (tree mdecl
)
1475 static int method_name_count
= 0;
1480 #define ACC_TRANSLATED 0x4000
1481 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1482 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1484 class_decl
= DECL_CONTEXT (mdecl
);
1485 /* For interfaces, the index field contains the dispatch index. */
1486 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1487 index
= build_int_cst (NULL_TREE
,
1488 get_interface_method_index (mdecl
, class_decl
));
1489 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1490 index
= get_method_index (mdecl
);
1492 index
= integer_minus_one_node
;
1494 code
= null_pointer_node
;
1495 if (METHOD_ABSTRACT (mdecl
))
1496 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1497 soft_abstractmethod_node
);
1499 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1500 make_local_function_alias (mdecl
));
1501 START_RECORD_CONSTRUCTOR (v
, method_type_node
);
1502 PUSH_FIELD_VALUE (v
, "name",
1503 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1504 init_identifier_node
1505 : DECL_NAME (mdecl
)));
1507 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1508 PUSH_FIELD_VALUE (v
, "signature",
1511 (IDENTIFIER_POINTER(signature
),
1512 IDENTIFIER_LENGTH(signature
)))));
1514 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1515 PUSH_FIELD_VALUE (v
, "index", index
);
1516 PUSH_FIELD_VALUE (v
, "ncode", code
);
1519 /* Compute the `throws' information for the method. */
1520 tree table
= null_pointer_node
;
1522 if (!vec_safe_is_empty (DECL_FUNCTION_THROWS (mdecl
)))
1524 int length
= 1 + DECL_FUNCTION_THROWS (mdecl
)->length ();
1525 tree t
, type
, array
;
1527 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1528 int idx
= length
- 1;
1532 vec_alloc (v
, length
);
1533 v
->quick_grow_cleared (length
);
1536 e
->value
= null_pointer_node
;
1538 FOR_EACH_VEC_SAFE_ELT (DECL_FUNCTION_THROWS (mdecl
), ix
, t
)
1540 tree sig
= DECL_NAME (TYPE_NAME (t
));
1542 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1543 IDENTIFIER_LENGTH (sig
)));
1547 gcc_assert (idx
== -1);
1548 type
= build_prim_array_type (ptr_type_node
, length
);
1549 table
= build_constructor (type
, v
);
1550 /* Compute something unique enough. */
1551 sprintf (buf
, "_methods%d", method_name_count
++);
1552 array
= build_decl (input_location
,
1553 VAR_DECL
, get_identifier (buf
), type
);
1554 DECL_INITIAL (array
) = table
;
1555 TREE_STATIC (array
) = 1;
1556 DECL_ARTIFICIAL (array
) = 1;
1557 DECL_IGNORED_P (array
) = 1;
1558 rest_of_decl_compilation (array
, 1, 0);
1560 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1563 PUSH_FIELD_VALUE (v
, "throws", table
);
1566 FINISH_RECORD_CONSTRUCTOR (minit
, v
, method_type_node
);
1571 get_dispatch_vector (tree type
)
1573 tree vtable
= TYPE_VTABLE (type
);
1575 if (vtable
== NULL_TREE
)
1579 tree super
= CLASSTYPE_SUPER (type
);
1580 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1581 vtable
= make_tree_vec (nvirtuals
);
1582 TYPE_VTABLE (type
) = vtable
;
1583 if (super
!= NULL_TREE
)
1585 tree super_vtable
= get_dispatch_vector (super
);
1587 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1588 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1591 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1592 method
= DECL_CHAIN (method
))
1594 tree method_index
= get_method_index (method
);
1595 if (method_index
!= NULL_TREE
1596 && host_integerp (method_index
, 0))
1597 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1605 get_dispatch_table (tree type
, tree this_class_addr
)
1607 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1608 tree vtable
= get_dispatch_vector (type
);
1610 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1613 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1617 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1618 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1619 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1622 vec_safe_grow_cleared (v
, arraysize
);
1623 e
= &(*v
)[arraysize
- 1];
1625 #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
1626 for (i
= nvirtuals
; --i
>= 0; )
1628 tree method
= TREE_VEC_ELT (vtable
, i
);
1629 if (METHOD_ABSTRACT (method
))
1632 warning_at (DECL_SOURCE_LOCATION (method
), 0,
1633 "abstract method in non-abstract class");
1635 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1636 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1637 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1639 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1643 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1644 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1646 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1647 method
, build_int_cst (NULL_TREE
, j
));
1648 TREE_CONSTANT (fdesc
) = 1;
1649 CONSTRUCTOR_PREPEND_VALUE (e
, fdesc
);
1652 CONSTRUCTOR_PREPEND_VALUE (e
,
1654 nativecode_ptr_type_node
,
1659 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1660 using the Boehm GC we sometimes stash a GC type descriptor
1661 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1662 the emitted byte count during the output to the assembly file. */
1663 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1664 fake "function descriptor". It's first word is the is the class
1665 pointer, and subsequent words (usually one) contain the GC descriptor.
1666 In all other cases, we reserve two extra vtable slots. */
1667 gc_descr
= get_boehm_type_descriptor (type
);
1668 CONSTRUCTOR_PREPEND_VALUE (e
, gc_descr
);
1669 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1670 CONSTRUCTOR_PREPEND_VALUE (e
, gc_descr
);
1671 CONSTRUCTOR_PREPEND_VALUE (e
, this_class_addr
);
1673 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1674 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1675 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1676 gcc_assert (e
== v
->address ());
1677 e
->index
= integer_zero_node
;
1678 e
->value
= null_pointer_node
;
1679 #undef CONSTRUCTOR_PREPEND_VALUE
1681 arraytype
= build_prim_array_type (nativecode_ptr_type_node
, arraysize
);
1682 return build_constructor (arraytype
, v
);
1686 /* Set the method_index for a method decl. */
1688 set_method_index (tree decl
, tree method_index
)
1690 if (method_index
!= NULL_TREE
)
1692 /* method_index is null if we're using indirect dispatch. */
1693 method_index
= fold (convert (sizetype
, method_index
));
1695 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1696 /* Add one to skip bogus descriptor for class and GC descriptor. */
1697 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1699 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1701 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1704 DECL_VINDEX (decl
) = method_index
;
1707 /* Get the method_index for a method decl. */
1709 get_method_index (tree decl
)
1711 tree method_index
= DECL_VINDEX (decl
);
1716 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1717 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1718 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1720 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1721 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1723 return method_index
;
1727 supers_all_compiled (tree type
)
1729 while (type
!= NULL_TREE
)
1731 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1733 type
= CLASSTYPE_SUPER (type
);
1739 add_table_and_syms (vec
<constructor_elt
, va_gc
> **v
,
1740 vec
<method_entry
, va_gc
> *methods
,
1741 const char *table_name
, tree table_slot
, tree table_type
,
1742 const char *syms_name
, tree syms_slot
)
1744 if (methods
== NULL
)
1746 PUSH_FIELD_VALUE (*v
, table_name
, null_pointer_node
);
1747 PUSH_FIELD_VALUE (*v
, syms_name
, null_pointer_node
);
1751 pushdecl_top_level (syms_slot
);
1752 PUSH_FIELD_VALUE (*v
, table_name
,
1753 build1 (ADDR_EXPR
, table_type
, table_slot
));
1754 PUSH_FIELD_VALUE (*v
, syms_name
,
1755 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1757 TREE_CONSTANT (table_slot
) = 1;
1762 make_class_data (tree type
)
1764 tree decl
, cons
, temp
;
1765 tree field
, fields_decl
;
1766 HOST_WIDE_INT static_field_count
= 0;
1767 HOST_WIDE_INT instance_field_count
= 0;
1768 HOST_WIDE_INT field_count
;
1769 tree field_array_type
;
1771 tree dtable_decl
= NULL_TREE
;
1772 HOST_WIDE_INT method_count
= 0;
1773 tree method_array_type
;
1776 tree this_class_addr
;
1777 tree constant_pool_constructor
;
1778 tree interfaces
= null_pointer_node
;
1779 int interface_len
= 0;
1780 int uses_jv_markobj
= 0;
1781 tree type_decl
= TYPE_NAME (type
);
1782 tree id_main
= get_identifier("main");
1783 tree id_class
= get_identifier("java.lang.Class");
1784 /** Offset from start of virtual function table declaration
1785 to where objects actually point at, following new g++ ABI. */
1786 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1787 vec
<int> field_indexes
;
1788 tree first_real_field
;
1789 vec
<constructor_elt
, va_gc
> *v1
= NULL
, *v2
= NULL
;
1790 tree reflection_data
;
1791 vec
<constructor_elt
, va_gc
> *static_fields
= NULL
;
1792 vec
<constructor_elt
, va_gc
> *instance_fields
= NULL
;
1793 vec
<constructor_elt
, va_gc
> *methods
= NULL
;
1795 this_class_addr
= build_static_class_ref (type
);
1796 decl
= TREE_OPERAND (this_class_addr
, 0);
1798 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1799 && !flag_indirect_dispatch
)
1801 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1802 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1803 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1805 /* We've already created some other class, and consequently
1806 we made class_dtable_decl. Now we just want to fill it
1808 dtable_decl
= class_dtable_decl
;
1812 dtable_decl
= build_dtable_decl (type
);
1813 TREE_STATIC (dtable_decl
) = 1;
1814 DECL_ARTIFICIAL (dtable_decl
) = 1;
1815 DECL_IGNORED_P (dtable_decl
) = 1;
1818 TREE_PUBLIC (dtable_decl
) = 1;
1819 DECL_INITIAL (dtable_decl
) = dtable
;
1820 /* The only dispatch table exported from a DSO is the dispatch
1821 table for java.lang.Class. */
1822 if (DECL_NAME (type_decl
) != id_class
)
1823 java_hide_decl (dtable_decl
);
1824 if (! flag_indirect_classes
)
1825 rest_of_decl_compilation (dtable_decl
, 1, 0);
1826 /* Maybe we're compiling Class as the first class. If so, set
1827 class_dtable_decl to the decl we just made. */
1828 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1829 class_dtable_decl
= dtable_decl
;
1832 /* Build Field array. */
1833 field
= TYPE_FIELDS (type
);
1834 while (field
&& DECL_ARTIFICIAL (field
))
1835 field
= DECL_CHAIN (field
); /* Skip dummy fields. */
1836 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1837 field
= DECL_CHAIN (field
); /* Skip dummy field for inherited data. */
1838 first_real_field
= field
;
1840 /* First count static and instance fields. */
1841 for ( ; field
!= NULL_TREE
; field
= DECL_CHAIN (field
))
1843 if (! DECL_ARTIFICIAL (field
))
1845 if (FIELD_STATIC (field
))
1846 static_field_count
++;
1847 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1848 instance_field_count
++;
1851 field_count
= static_field_count
+ instance_field_count
;
1852 field_indexes
.create (field_count
);
1854 /* gcj sorts fields so that static fields come first, followed by
1855 instance fields. Unfortunately, by the time this takes place we
1856 have already generated the reflection_data for this class, and
1857 that data contains indexes into the fields. So, we generate a
1858 permutation that maps each original field index to its final
1859 position. Then we pass this permutation to
1860 rewrite_reflection_indexes(), which fixes up the reflection
1864 int static_count
= 0;
1865 int instance_count
= static_field_count
;
1868 for (i
= 0, field
= first_real_field
;
1870 field
= DECL_CHAIN (field
), i
++)
1872 if (! DECL_ARTIFICIAL (field
))
1875 if (FIELD_STATIC (field
))
1876 field_index
= static_count
++;
1877 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1878 field_index
= instance_count
++;
1881 field_indexes
.quick_push (field_index
);
1886 for (field
= first_real_field
; field
!= NULL_TREE
;
1887 field
= DECL_CHAIN (field
))
1889 if (! DECL_ARTIFICIAL (field
))
1891 if (FIELD_STATIC (field
))
1893 /* We must always create reflection data for static fields
1894 as it is used in the creation of the field itself. */
1895 tree init
= make_field_value (field
);
1896 tree initial
= DECL_INITIAL (field
);
1897 CONSTRUCTOR_APPEND_ELT (static_fields
, NULL_TREE
, init
);
1898 /* If the initial value is a string constant,
1899 prevent output_constant from trying to assemble the value. */
1900 if (initial
!= NULL_TREE
1901 && TREE_TYPE (initial
) == string_ptr_type_node
)
1902 DECL_INITIAL (field
) = NULL_TREE
;
1903 rest_of_decl_compilation (field
, 1, 1);
1904 DECL_INITIAL (field
) = initial
;
1906 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1908 tree init
= make_field_value (field
);
1909 CONSTRUCTOR_APPEND_ELT (instance_fields
, NULL_TREE
, init
);
1914 gcc_assert (static_field_count
== (int) vec_safe_length (static_fields
));
1915 gcc_assert (instance_field_count
== (int) vec_safe_length (instance_fields
));
1917 if (field_count
> 0)
1919 vec_safe_splice (static_fields
, instance_fields
);
1920 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1921 fields_decl
= build_decl (input_location
,
1922 VAR_DECL
, mangled_classname ("_FL_", type
),
1924 DECL_INITIAL (fields_decl
)
1925 = build_constructor (field_array_type
, static_fields
);
1926 TREE_STATIC (fields_decl
) = 1;
1927 DECL_ARTIFICIAL (fields_decl
) = 1;
1928 DECL_IGNORED_P (fields_decl
) = 1;
1929 rest_of_decl_compilation (fields_decl
, 1, 0);
1932 fields_decl
= NULL_TREE
;
1934 /* Build Method array. */
1935 for (method
= TYPE_METHODS (type
);
1936 method
!= NULL_TREE
; method
= DECL_CHAIN (method
))
1939 if (METHOD_PRIVATE (method
)
1940 && ! flag_keep_inline_functions
1943 /* Even if we have a decl, we don't necessarily have the code.
1944 This can happen if we inherit a method from a superclass for
1945 which we don't have a .class file. */
1946 if (METHOD_DUMMY (method
))
1949 /* Generate method reflection data if:
1951 - !flag_reduced_reflection.
1953 - <clinit> -- The runtime uses reflection to initialize the
1956 - Any method in class java.lang.Class -- Class.forName() and
1957 perhaps other things require it.
1959 - class$ -- It does not work if reflection data missing.
1961 - main -- Reflection is used to find main(String[]) methods.
1963 - public not static -- It is potentially part of an
1964 interface. The runtime uses reflection data to build
1965 interface dispatch tables. */
1966 if (!flag_reduced_reflection
1967 || DECL_CLINIT_P (method
)
1968 || DECL_NAME (type_decl
) == id_class
1969 || DECL_NAME (method
) == id_main
1970 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1972 init
= make_method_value (method
);
1974 CONSTRUCTOR_APPEND_ELT (methods
, NULL_TREE
, init
);
1977 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1978 methods_decl
= build_decl (input_location
,
1979 VAR_DECL
, mangled_classname ("_MT_", type
),
1981 DECL_INITIAL (methods_decl
) = build_constructor (method_array_type
, methods
);
1982 TREE_STATIC (methods_decl
) = 1;
1983 DECL_ARTIFICIAL (methods_decl
) = 1;
1984 DECL_IGNORED_P (methods_decl
) = 1;
1985 rest_of_decl_compilation (methods_decl
, 1, 0);
1987 if (class_dtable_decl
== NULL_TREE
)
1989 class_dtable_decl
= build_dtable_decl (class_type_node
);
1990 TREE_STATIC (class_dtable_decl
) = 1;
1991 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
1992 DECL_IGNORED_P (class_dtable_decl
) = 1;
1993 if (is_compiled_class (class_type_node
) != 2)
1995 DECL_EXTERNAL (class_dtable_decl
) = 1;
1996 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
2000 super
= CLASSTYPE_SUPER (type
);
2001 if (super
== NULL_TREE
)
2002 super
= null_pointer_node
;
2003 else if (! flag_indirect_dispatch
2004 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
2005 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
2006 super
= build_class_ref (super
);
2009 int super_index
= alloc_class_constant (super
);
2010 super
= build_int_cst (ptr_type_node
, super_index
);
2013 /* Build and emit the array of implemented interfaces. */
2014 if (type
!= object_type_node
)
2015 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
2017 if (interface_len
> 0)
2020 tree interface_array_type
, idecl
;
2021 vec
<constructor_elt
, va_gc
> *init
;
2022 vec_alloc (init
, interface_len
);
2023 interface_array_type
2024 = build_prim_array_type (class_ptr_type
, interface_len
);
2025 idecl
= build_decl (input_location
,
2026 VAR_DECL
, mangled_classname ("_IF_", type
),
2027 interface_array_type
);
2029 for (i
= 1; i
<= interface_len
; i
++)
2031 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
2032 tree iclass
= BINFO_TYPE (child
);
2034 if (! flag_indirect_dispatch
2036 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
2037 index
= build_class_ref (iclass
);
2040 int int_index
= alloc_class_constant (iclass
);
2041 index
= build_int_cst (ptr_type_node
, int_index
);
2043 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, index
);
2045 DECL_INITIAL (idecl
) = build_constructor (interface_array_type
, init
);
2046 TREE_STATIC (idecl
) = 1;
2047 DECL_ARTIFICIAL (idecl
) = 1;
2048 DECL_IGNORED_P (idecl
) = 1;
2049 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
2050 rest_of_decl_compilation (idecl
, 1, 0);
2053 constant_pool_constructor
= build_constants_constructor ();
2055 if (flag_indirect_dispatch
)
2057 TYPE_OTABLE_DECL (type
)
2059 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
2060 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
2061 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
2063 TYPE_ATABLE_DECL (type
)
2065 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
2066 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
2067 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2069 TYPE_ITABLE_DECL (type
)
2071 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2072 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2073 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2076 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2078 START_RECORD_CONSTRUCTOR (v1
, object_type_node
);
2079 PUSH_FIELD_VALUE (v1
, "vtable",
2080 (flag_indirect_classes
2082 : fold_build_pointer_plus
2083 (build1 (ADDR_EXPR
, dtable_ptr_type
,
2085 dtable_start_offset
)));
2086 if (! flag_hash_synchronization
)
2087 PUSH_FIELD_VALUE (v1
, "sync_info", null_pointer_node
);
2088 FINISH_RECORD_CONSTRUCTOR (temp
, v1
, object_type_node
);
2089 START_RECORD_CONSTRUCTOR (v2
, class_type_node
);
2090 PUSH_SUPER_VALUE (v2
, temp
);
2091 PUSH_FIELD_VALUE (v2
, "next_or_version", gcj_abi_version
);
2092 PUSH_FIELD_VALUE (v2
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2093 PUSH_FIELD_VALUE (v2
, "accflags",
2094 build_int_cst (NULL_TREE
,
2095 get_access_flags_from_decl (type_decl
)));
2097 PUSH_FIELD_VALUE (v2
, "superclass",
2098 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2099 PUSH_FIELD_VALUE (v2
, "constants", constant_pool_constructor
);
2100 PUSH_FIELD_VALUE (v2
, "methods",
2101 methods_decl
== NULL_TREE
? null_pointer_node
2102 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2103 PUSH_FIELD_VALUE (v2
, "method_count",
2104 build_int_cst (NULL_TREE
, method_count
));
2106 PUSH_FIELD_VALUE (v2
, "vtable_method_count",
2107 (flag_indirect_dispatch
2108 ? integer_minus_one_node
2109 : TYPE_NVIRTUALS (type
)));
2111 PUSH_FIELD_VALUE (v2
, "fields",
2112 fields_decl
== NULL_TREE
? null_pointer_node
2113 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2114 /* If we're using the binary compatibility ABI we don't know the
2115 size until load time. */
2116 PUSH_FIELD_VALUE (v2
, "size_in_bytes",
2117 (flag_indirect_dispatch
2118 ? integer_minus_one_node
2119 : size_in_bytes (type
)));
2120 PUSH_FIELD_VALUE (v2
, "field_count",
2121 build_int_cst (NULL_TREE
, field_count
));
2122 PUSH_FIELD_VALUE (v2
, "static_field_count",
2123 build_int_cst (NULL_TREE
, static_field_count
));
2125 PUSH_FIELD_VALUE (v2
, "vtable",
2126 (flag_indirect_dispatch
|| dtable_decl
== NULL_TREE
2128 : fold_build_pointer_plus
2129 (build1 (ADDR_EXPR
, dtable_ptr_type
,
2131 dtable_start_offset
)));
2132 add_table_and_syms (&v2
, TYPE_OTABLE_METHODS (type
),
2133 "otable", TYPE_OTABLE_DECL (type
), otable_ptr_type
,
2134 "otable_syms", TYPE_OTABLE_SYMS_DECL (type
));
2135 add_table_and_syms (&v2
, TYPE_ATABLE_METHODS (type
),
2136 "atable", TYPE_ATABLE_DECL (type
), atable_ptr_type
,
2137 "atable_syms", TYPE_ATABLE_SYMS_DECL (type
));
2138 add_table_and_syms (&v2
, TYPE_ITABLE_METHODS (type
),
2139 "itable", TYPE_ITABLE_DECL (type
), itable_ptr_type
,
2140 "itable_syms", TYPE_ITABLE_SYMS_DECL (type
));
2142 PUSH_FIELD_VALUE (v2
, "catch_classes",
2143 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2144 PUSH_FIELD_VALUE (v2
, "interfaces", interfaces
);
2145 PUSH_FIELD_VALUE (v2
, "loader", null_pointer_node
);
2146 PUSH_FIELD_VALUE (v2
, "interface_count",
2147 build_int_cst (NULL_TREE
, interface_len
));
2148 PUSH_FIELD_VALUE (v2
, "state",
2149 convert (byte_type_node
,
2150 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2152 PUSH_FIELD_VALUE (v2
, "thread", null_pointer_node
);
2153 PUSH_FIELD_VALUE (v2
, "depth", integer_zero_node
);
2154 PUSH_FIELD_VALUE (v2
, "ancestors", null_pointer_node
);
2155 PUSH_FIELD_VALUE (v2
, "idt", null_pointer_node
);
2156 PUSH_FIELD_VALUE (v2
, "arrayclass", null_pointer_node
);
2157 PUSH_FIELD_VALUE (v2
, "protectionDomain", null_pointer_node
);
2160 tree assertion_table_ref
;
2161 if (TYPE_ASSERTIONS (type
) == NULL
)
2162 assertion_table_ref
= null_pointer_node
;
2164 assertion_table_ref
= build1 (ADDR_EXPR
,
2165 build_pointer_type (assertion_table_type
),
2166 emit_assertion_table (type
));
2168 PUSH_FIELD_VALUE (v2
, "assertion_table", assertion_table_ref
);
2171 PUSH_FIELD_VALUE (v2
, "hack_signers", null_pointer_node
);
2172 PUSH_FIELD_VALUE (v2
, "chain", null_pointer_node
);
2173 PUSH_FIELD_VALUE (v2
, "aux_info", null_pointer_node
);
2174 PUSH_FIELD_VALUE (v2
, "engine", null_pointer_node
);
2176 if (TYPE_REFLECTION_DATA (current_class
))
2179 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2180 vec
<constructor_elt
, va_gc
> *v
;
2181 vec_alloc (v
, count
);
2182 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2183 tree max_index
= build_int_cst (sizetype
, count
);
2184 tree index
= build_index_type (max_index
);
2185 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2188 static int reflection_data_count
;
2190 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2191 array
= build_decl (input_location
,
2192 VAR_DECL
, get_identifier (buf
), type
);
2194 rewrite_reflection_indexes (&field_indexes
);
2196 for (i
= 0; i
< count
; i
++)
2198 constructor_elt elt
;
2199 elt
.index
= build_int_cst (sizetype
, i
);
2200 elt
.value
= build_int_cstu (byte_type_node
, data
[i
]);
2201 v
->quick_push (elt
);
2204 DECL_INITIAL (array
) = build_constructor (type
, v
);
2205 TREE_STATIC (array
) = 1;
2206 DECL_ARTIFICIAL (array
) = 1;
2207 DECL_IGNORED_P (array
) = 1;
2208 TREE_READONLY (array
) = 1;
2209 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2210 rest_of_decl_compilation (array
, 1, 0);
2212 reflection_data
= build_address_of (array
);
2215 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2218 reflection_data
= null_pointer_node
;
2220 PUSH_FIELD_VALUE (v2
, "reflection_data", reflection_data
);
2221 FINISH_RECORD_CONSTRUCTOR (cons
, v2
, class_type_node
);
2223 DECL_INITIAL (decl
) = cons
;
2225 /* Hash synchronization requires at least 64-bit alignment. */
2226 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2227 DECL_ALIGN (decl
) = 64;
2229 if (flag_indirect_classes
)
2231 TREE_READONLY (decl
) = 1;
2232 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2235 rest_of_decl_compilation (decl
, 1, 0);
2238 tree classdollar_field
= build_classdollar_field (type
);
2239 if (!flag_indirect_classes
)
2240 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2241 rest_of_decl_compilation (classdollar_field
, 1, 0);
2244 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2245 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2246 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2252 java_expand_catch_classes (current_class
);
2254 current_function_decl
= NULL_TREE
;
2255 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2256 make_class_data (current_class
);
2258 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2261 /* Return 2 if KLASS is compiled by this compilation job;
2262 return 1 if KLASS can otherwise be assumed to be compiled;
2263 return 0 if we cannot assume that KLASS is compiled.
2264 Returns 1 for primitive and 0 for array types. */
2266 is_compiled_class (tree klass
)
2269 if (TREE_CODE (klass
) == POINTER_TYPE
)
2270 klass
= TREE_TYPE (klass
);
2271 if (TREE_CODE (klass
) != RECORD_TYPE
) /* Primitive types are static. */
2273 if (TYPE_ARRAY_P (klass
))
2276 seen_in_zip
= (TYPE_JCF (klass
) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass
)));
2277 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2279 /* The class was seen in the current ZIP file and will be
2280 available as a compiled class in the future but may not have
2281 been loaded already. Load it if necessary. This prevent
2282 build_class_ref () from crashing. */
2284 if (seen_in_zip
&& !CLASS_LOADED_P (klass
) && (klass
!= current_class
))
2285 load_class (klass
, 1);
2287 /* We return 2 for class seen in ZIP and class from files
2288 belonging to the same compilation unit */
2292 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass
)))))
2294 if (!CLASS_LOADED_P (klass
))
2296 if (klass
!= current_class
)
2297 load_class (klass
, 1);
2305 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2308 build_dtable_decl (tree type
)
2312 /* We need to build a new dtable type so that its size is uniquely
2313 computed when we're dealing with the class for real and not just
2314 faking it (like java.lang.Class during the initialization of the
2315 compiler.) We know we're not faking a class when CURRENT_CLASS is
2317 if (current_class
== type
)
2319 tree dummy
= NULL_TREE
;
2322 dtype
= make_node (RECORD_TYPE
);
2324 PUSH_FIELD (input_location
, dtype
, dummy
, "top_offset", ptr_type_node
);
2325 PUSH_FIELD (input_location
, dtype
, dummy
, "type_info", ptr_type_node
);
2327 PUSH_FIELD (input_location
, dtype
, dummy
, "class", class_ptr_type
);
2328 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2330 tree tmp_field
= build_decl (input_location
,
2331 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2332 TREE_CHAIN (dummy
) = tmp_field
;
2333 DECL_CONTEXT (tmp_field
) = dtype
;
2334 DECL_ARTIFICIAL (tmp_field
) = 1;
2338 PUSH_FIELD (input_location
, dtype
, dummy
, "gc_descr", ptr_type_node
);
2339 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2341 tree tmp_field
= build_decl (input_location
,
2342 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2343 TREE_CHAIN (dummy
) = tmp_field
;
2344 DECL_CONTEXT (tmp_field
) = dtype
;
2345 DECL_ARTIFICIAL (tmp_field
) = 1;
2349 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2350 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2351 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2353 PUSH_FIELD (input_location
, dtype
, dummy
, "methods",
2354 build_prim_array_type (nativecode_ptr_type_node
, n
));
2355 layout_type (dtype
);
2358 dtype
= dtable_type
;
2360 decl
= build_decl (input_location
,
2361 VAR_DECL
, get_identifier ("vt$"), dtype
);
2362 DECL_CONTEXT (decl
) = type
;
2363 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2364 DECL_VTABLE_P (decl
) = 1;
2369 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2370 fields inherited from SUPER_CLASS. */
2373 push_super_field (tree this_class
, tree super_class
)
2376 /* Don't insert the field if we're just re-laying the class out. */
2377 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2379 base_decl
= build_decl (input_location
,
2380 FIELD_DECL
, NULL_TREE
, super_class
);
2381 DECL_IGNORED_P (base_decl
) = 1;
2382 DECL_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2383 TYPE_FIELDS (this_class
) = base_decl
;
2384 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2385 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2388 /* Handle the different manners we may have to lay out a super class. */
2391 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2395 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2397 if (!CLASS_LOADED_P (super_class
))
2398 load_class (super_class
, 1);
2400 /* We might have to layout the class before its dependency on
2401 the super class gets resolved by java_complete_class */
2402 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2404 if (TREE_TYPE (super_class
) != NULL_TREE
)
2405 super_class
= TREE_TYPE (super_class
);
2409 if (!TYPE_SIZE (super_class
))
2410 safe_layout_class (super_class
);
2415 /* safe_layout_class just makes sure that we can load a class without
2416 disrupting the current_class, input_file, input_line, etc, information
2417 about the class processed currently. */
2420 safe_layout_class (tree klass
)
2422 tree save_current_class
= current_class
;
2423 location_t save_location
= input_location
;
2425 layout_class (klass
);
2427 current_class
= save_current_class
;
2428 input_location
= save_location
;
2432 layout_class (tree this_class
)
2435 tree super_class
= CLASSTYPE_SUPER (this_class
);
2437 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2438 if (CLASS_BEING_LAIDOUT (this_class
))
2444 sprintf (buffer
, " with '%s'",
2445 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2446 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2448 for (current
= TREE_CHAIN (class_list
); current
;
2449 current
= TREE_CHAIN (current
))
2451 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2452 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2453 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2454 DECL_SOURCE_FILE (decl
),
2455 DECL_SOURCE_LINE (decl
));
2456 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2458 obstack_1grow (&temporary_obstack
, '\0');
2459 report
= XOBFINISH (&temporary_obstack
, char *);
2460 cyclic_inheritance_report
= ggc_strdup (report
);
2461 obstack_free (&temporary_obstack
, report
);
2462 TYPE_SIZE (this_class
) = error_mark_node
;
2465 CLASS_BEING_LAIDOUT (this_class
) = 1;
2467 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2469 tree maybe_super_class
2470 = maybe_layout_super_class (super_class
, this_class
);
2471 if (maybe_super_class
== NULL
2472 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2474 TYPE_SIZE (this_class
) = error_mark_node
;
2475 CLASS_BEING_LAIDOUT (this_class
) = 0;
2476 class_list
= TREE_CHAIN (class_list
);
2479 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2480 push_super_field (this_class
, maybe_super_class
);
2483 layout_type (this_class
);
2485 /* Also recursively load/layout any superinterfaces. */
2486 if (TYPE_BINFO (this_class
))
2488 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2490 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2491 tree super_interface
= BINFO_TYPE (binfo
);
2492 tree maybe_super_interface
2493 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2494 if (maybe_super_interface
== NULL
2495 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2497 TYPE_SIZE (this_class
) = error_mark_node
;
2498 CLASS_BEING_LAIDOUT (this_class
) = 0;
2499 class_list
= TREE_CHAIN (class_list
);
2505 /* Convert the size back to an SI integer value. */
2506 TYPE_SIZE_UNIT (this_class
) =
2507 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2509 CLASS_BEING_LAIDOUT (this_class
) = 0;
2510 class_list
= TREE_CHAIN (class_list
);
2514 add_miranda_methods (tree base_class
, tree search_class
)
2517 tree binfo
, base_binfo
;
2519 if (!CLASS_PARSED_P (search_class
))
2520 load_class (search_class
, 1);
2522 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2523 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2526 tree elt
= BINFO_TYPE (base_binfo
);
2528 /* FIXME: This is totally bogus. We should not be handling
2529 Miranda methods at all if we're using the BC ABI. */
2530 if (TYPE_DUMMY (elt
))
2533 /* Ensure that interface methods are seen in declared order. */
2534 if (!CLASS_LOADED_P (elt
))
2535 load_class (elt
, 1);
2536 layout_class_methods (elt
);
2538 /* All base classes will have been laid out at this point, so the order
2539 will be correct. This code must match similar layout code in the
2541 for (method_decl
= TYPE_METHODS (elt
);
2542 method_decl
; method_decl
= DECL_CHAIN (method_decl
))
2546 /* An interface can have <clinit>. */
2547 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2550 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2551 override
= lookup_argument_method (base_class
,
2552 DECL_NAME (method_decl
), sig
);
2553 if (override
== NULL_TREE
)
2555 /* Found a Miranda method. Add it. */
2557 sig
= build_java_signature (TREE_TYPE (method_decl
));
2559 = add_method (base_class
,
2560 get_access_flags_from_decl (method_decl
),
2561 DECL_NAME (method_decl
), sig
);
2562 METHOD_INVISIBLE (new_method
) = 1;
2566 /* Try superinterfaces. */
2567 add_miranda_methods (base_class
, elt
);
2572 layout_class_methods (tree this_class
)
2574 tree method_decl
, dtable_count
;
2575 tree super_class
, type_name
;
2577 if (TYPE_NVIRTUALS (this_class
))
2580 super_class
= CLASSTYPE_SUPER (this_class
);
2584 super_class
= maybe_layout_super_class (super_class
, this_class
);
2585 if (!TYPE_NVIRTUALS (super_class
))
2586 layout_class_methods (super_class
);
2587 dtable_count
= TYPE_NVIRTUALS (super_class
);
2590 dtable_count
= integer_zero_node
;
2592 type_name
= TYPE_NAME (this_class
);
2593 if (!flag_indirect_dispatch
2594 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2596 /* An abstract class can have methods which are declared only in
2597 an implemented interface. These are called "Miranda
2598 methods". We make a dummy method entry for such methods
2600 add_miranda_methods (this_class
, this_class
);
2603 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2605 for (method_decl
= TYPE_METHODS (this_class
);
2606 method_decl
; method_decl
= DECL_CHAIN (method_decl
))
2607 dtable_count
= layout_class_method (this_class
, super_class
,
2608 method_decl
, dtable_count
);
2610 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2613 /* Return the index of METHOD in INTERFACE. This index begins at 1
2614 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2616 get_interface_method_index (tree method
, tree interface
)
2621 for (meth
= TYPE_METHODS (interface
); ; meth
= DECL_CHAIN (meth
))
2625 /* We don't want to put <clinit> into the interface table. */
2626 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2628 gcc_assert (meth
!= NULL_TREE
);
2632 /* Lay METHOD_DECL out, returning a possibly new value of
2633 DTABLE_COUNT. Also mangle the method's name. */
2636 layout_class_method (tree this_class
, tree super_class
,
2637 tree method_decl
, tree dtable_count
)
2639 tree method_name
= DECL_NAME (method_decl
);
2641 TREE_PUBLIC (method_decl
) = 1;
2643 if (flag_indirect_classes
2644 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2645 && ! METHOD_NATIVE (method_decl
)
2646 && ! special_method_p (method_decl
)))
2647 java_hide_decl (method_decl
);
2649 /* Considered external unless it is being compiled into this object
2650 file, or it was already flagged as external. */
2651 if (!DECL_EXTERNAL (method_decl
))
2652 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2653 || METHOD_NATIVE (method_decl
));
2655 if (ID_INIT_P (method_name
))
2657 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2659 for (ptr
= p
; *ptr
; )
2664 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2665 build_java_signature (TREE_TYPE (method_decl
));
2667 else if (! METHOD_STATIC (method_decl
))
2670 build_java_signature (TREE_TYPE (method_decl
));
2671 bool method_override
= false;
2672 tree super_method
= lookup_java_method (super_class
, method_name
,
2674 if (super_method
!= NULL_TREE
2675 && ! METHOD_DUMMY (super_method
))
2677 method_override
= true;
2678 if (! METHOD_PUBLIC (super_method
) &&
2679 ! METHOD_PROTECTED (super_method
))
2681 /* Don't override private method, or default-access method in
2683 if (METHOD_PRIVATE (super_method
) ||
2684 ! in_same_package (TYPE_NAME (this_class
),
2685 TYPE_NAME (super_class
)))
2686 method_override
= false;
2689 if (method_override
)
2691 tree method_index
= get_method_index (super_method
);
2692 set_method_index (method_decl
, method_index
);
2693 if (method_index
== NULL_TREE
2694 && ! flag_indirect_dispatch
2695 && ! DECL_ARTIFICIAL (super_method
))
2696 error ("non-static method %q+D overrides static method",
2699 else if (this_class
== object_type_node
2700 && (METHOD_FINAL (method_decl
)
2701 || METHOD_PRIVATE (method_decl
)))
2703 /* We don't generate vtable entries for final Object
2704 methods. This is simply to save space, since every
2705 object would otherwise have to define them. */
2707 else if (! METHOD_PRIVATE (method_decl
)
2710 /* We generate vtable entries for final methods because they
2711 may one day be changed to non-final. */
2712 set_method_index (method_decl
, dtable_count
);
2713 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2714 dtable_count
, integer_one_node
);
2718 return dtable_count
;
2722 register_class (void)
2726 if (!registered_class
)
2727 vec_alloc (registered_class
, 8);
2729 if (flag_indirect_classes
)
2730 node
= current_class
;
2732 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2733 vec_safe_push (registered_class
, node
);
2736 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2737 all the classes we have emitted. */
2740 emit_indirect_register_classes (tree
*list_p
)
2742 tree klass
, t
, register_class_fn
;
2745 int size
= vec_safe_length (registered_class
) * 2 + 1;
2746 vec
<constructor_elt
, va_gc
> *init
;
2747 vec_alloc (init
, size
);
2748 tree class_array_type
2749 = build_prim_array_type (ptr_type_node
, size
);
2750 tree
cdecl = build_decl (input_location
,
2751 VAR_DECL
, get_identifier ("_Jv_CLS"),
2753 tree reg_class_list
;
2754 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2756 t
= fold_convert (ptr_type_node
, build_static_class_ref (klass
));
2757 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, t
);
2758 t
= fold_convert (ptr_type_node
,
2759 build_address_of (build_classdollar_field (klass
)));
2760 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, t
);
2762 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, integer_zero_node
);
2763 DECL_INITIAL (cdecl) = build_constructor (class_array_type
, init
);
2764 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2765 TREE_STATIC (cdecl) = 1;
2766 DECL_ARTIFICIAL (cdecl) = 1;
2767 DECL_IGNORED_P (cdecl) = 1;
2768 TREE_READONLY (cdecl) = 1;
2769 TREE_CONSTANT (cdecl) = 1;
2770 rest_of_decl_compilation (cdecl, 1, 0);
2771 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2773 t
= build_function_type_list (void_type_node
,
2774 build_pointer_type (ptr_type_node
), NULL
);
2775 t
= build_decl (input_location
,
2777 get_identifier ("_Jv_RegisterNewClasses"), t
);
2778 TREE_PUBLIC (t
) = 1;
2779 DECL_EXTERNAL (t
) = 1;
2780 register_class_fn
= t
;
2781 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2782 append_to_statement_list (t
, list_p
);
2785 /* Emit a list of pointers to all classes we have emitted to JCR_SECTION. */
2788 emit_register_classes_in_jcr_section (void)
2790 #ifdef JCR_SECTION_NAME
2791 tree klass
, cdecl, class_array_type
;
2793 int size
= vec_safe_length (registered_class
);
2794 vec
<constructor_elt
, va_gc
> *init
;
2795 vec_alloc (init
, size
);
2797 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2798 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, build_fold_addr_expr (klass
));
2800 /* ??? I would like to use tree_output_constant_def() but there is no way
2801 to put the data in a named section name, or to set the alignment,
2802 via that function. So do everything manually here. */
2803 class_array_type
= build_prim_array_type (ptr_type_node
, size
);
2804 cdecl = build_decl (UNKNOWN_LOCATION
,
2805 VAR_DECL
, get_identifier ("_Jv_JCR_SECTION_data"),
2807 DECL_SECTION_NAME (cdecl) = build_string (strlen (JCR_SECTION_NAME
),
2809 DECL_ALIGN (cdecl) = POINTER_SIZE
;
2810 DECL_USER_ALIGN (cdecl) = 1;
2811 DECL_INITIAL (cdecl) = build_constructor (class_array_type
, init
);
2812 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2813 TREE_STATIC (cdecl) = 1;
2814 TREE_READONLY (cdecl) = 0;
2815 TREE_CONSTANT (cdecl) = 1;
2816 DECL_ARTIFICIAL (cdecl) = 1;
2817 DECL_IGNORED_P (cdecl) = 1;
2818 pushdecl_top_level (cdecl);
2819 relayout_decl (cdecl);
2820 rest_of_decl_compilation (cdecl, 1, 0);
2821 mark_decl_referenced (cdecl);
2823 /* A target has defined TARGET_USE_JCR_SECTION,
2824 but doesn't have a JCR_SECTION_NAME. */
2830 /* Emit a series of calls to _Jv_RegisterClass for every class we emitted.
2831 A series of calls is added to LIST_P. */
2834 emit_Jv_RegisterClass_calls (tree
*list_p
)
2836 tree klass
, t
, register_class_fn
;
2839 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2840 t
= build_decl (input_location
,
2841 FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2842 TREE_PUBLIC (t
) = 1;
2843 DECL_EXTERNAL (t
) = 1;
2844 register_class_fn
= t
;
2846 FOR_EACH_VEC_SAFE_ELT (registered_class
, i
, klass
)
2848 t
= build_fold_addr_expr (klass
);
2849 t
= build_call_expr (register_class_fn
, 1, t
);
2850 append_to_statement_list (t
, list_p
);
2854 /* Emit something to register classes at start-up time.
2856 The default mechanism is to generate instances at run-time.
2858 An alternative mechanism is through the .jcr section, which contain
2859 a list of pointers to classes which get registered during constructor
2862 The fallback mechanism is to add statements to *LIST_P to call
2863 _Jv_RegisterClass for each class in this file. These statements will
2864 be added to a static constructor function for this translation unit. */
2867 emit_register_classes (tree
*list_p
)
2869 if (registered_class
== NULL
)
2872 /* By default, generate instances of Class at runtime. */
2873 if (flag_indirect_classes
)
2874 emit_indirect_register_classes (list_p
);
2875 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2876 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2877 but lack suitable crtbegin/end objects or linker support. These
2878 targets can override the default in tm.h to use the fallback mechanism. */
2879 else if (TARGET_USE_JCR_SECTION
)
2880 emit_register_classes_in_jcr_section ();
2881 /* Use the fallback mechanism. */
2883 emit_Jv_RegisterClass_calls (list_p
);
2886 /* Build a constructor for an entry in the symbol table. */
2889 build_symbol_table_entry (tree clname
, tree name
, tree signature
)
2892 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2894 START_RECORD_CONSTRUCTOR (v
, symbol_type
);
2895 PUSH_FIELD_VALUE (v
, "clname", clname
);
2896 PUSH_FIELD_VALUE (v
, "name", name
);
2897 PUSH_FIELD_VALUE (v
, "signature", signature
);
2898 FINISH_RECORD_CONSTRUCTOR (symbol
, v
, symbol_type
);
2899 TREE_CONSTANT (symbol
) = 1;
2904 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2907 build_symbol_entry (tree decl
, tree special
)
2909 tree clname
, name
, signature
;
2910 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2911 /* ??? Constructors are given the name foo.foo all the way through
2912 the compiler, but in the method table they're all renamed
2913 foo.<init>. So, we have to do the same here unless we want an
2914 unresolved reference at runtime. */
2915 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2916 && DECL_CONSTRUCTOR_P (decl
))
2917 ? init_identifier_node
2918 : DECL_NAME (decl
));
2919 signature
= build_java_signature (TREE_TYPE (decl
));
2920 signature
= build_utf8_ref (unmangle_classname
2921 (IDENTIFIER_POINTER (signature
),
2922 IDENTIFIER_LENGTH (signature
)));
2923 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2924 signature addr+1 if SPECIAL, and this indicates to the runtime
2925 system that this is a "special" symbol, i.e. one that should
2926 bypass access controls. */
2927 if (special
!= NULL_TREE
)
2928 signature
= fold_build_pointer_plus (signature
, special
);
2930 return build_symbol_table_entry (clname
, name
, signature
);
2933 /* Emit a symbol table: used by -findirect-dispatch. */
2936 emit_symbol_table (tree name
, tree the_table
,
2937 vec
<method_entry
, va_gc
> *decl_table
,
2938 tree the_syms_decl
, tree the_array_element_type
,
2941 tree table
, null_symbol
, table_size
, the_array_type
;
2944 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2946 /* Only emit a table if this translation unit actually made any
2947 references via it. */
2951 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2952 FOR_EACH_VEC_ELT (*decl_table
, index
, e
)
2953 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
2954 build_symbol_entry (e
->method
, e
->special
));
2956 /* Terminate the list with a "null" entry. */
2957 null_symbol
= build_symbol_table_entry (null_pointer_node
,
2960 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, null_symbol
);
2962 table
= build_constructor (symbols_array_type
, v
);
2964 /* Make it the initial value for otable_syms and emit the decl. */
2965 DECL_INITIAL (the_syms_decl
) = table
;
2966 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2967 DECL_IGNORED_P (the_syms_decl
) = 1;
2968 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2970 /* Now that its size is known, redefine the table as an
2971 uninitialized static array of INDEX + 1 elements. The extra entry
2972 is used by the runtime to track whether the table has been
2975 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2976 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2977 the_table
= build_decl (input_location
,
2978 VAR_DECL
, name
, the_array_type
);
2979 TREE_STATIC (the_table
) = 1;
2980 TREE_READONLY (the_table
) = 1;
2981 rest_of_decl_compilation (the_table
, 1, 0);
2986 /* Make an entry for the catch_classes list. */
2988 make_catch_class_record (tree catch_class
, tree classname
)
2991 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2992 vec
<constructor_elt
, va_gc
> *v
= NULL
;
2993 START_RECORD_CONSTRUCTOR (v
, type
);
2994 PUSH_FIELD_VALUE (v
, "address", catch_class
);
2995 PUSH_FIELD_VALUE (v
, "classname", classname
);
2996 FINISH_RECORD_CONSTRUCTOR (entry
, v
, type
);
3001 /* Generate the list of Throwable classes that are caught by exception
3002 handlers in this class. */
3004 emit_catch_table (tree this_class
)
3006 tree table
, table_size
, array_type
;
3007 int n_catch_classes
;
3009 /* Fill in the dummy entry that make_class created. */
3010 e
= &(*TYPE_CATCH_CLASSES (this_class
))[0];
3011 e
->value
= make_catch_class_record (null_pointer_node
, null_pointer_node
);
3012 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class
), NULL_TREE
,
3013 make_catch_class_record (null_pointer_node
,
3014 null_pointer_node
));
3015 n_catch_classes
= TYPE_CATCH_CLASSES (this_class
)->length ();
3016 table_size
= build_index_type (build_int_cst (NULL_TREE
, n_catch_classes
));
3018 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
3021 build_decl (input_location
,
3022 VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
3023 DECL_INITIAL (table
) =
3024 build_constructor (array_type
, TYPE_CATCH_CLASSES (this_class
));
3025 TREE_STATIC (table
) = 1;
3026 TREE_READONLY (table
) = 1;
3027 DECL_IGNORED_P (table
) = 1;
3028 rest_of_decl_compilation (table
, 1, 0);
3032 /* Given a type, return the signature used by
3033 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
3034 same as build_java_signature() because we want the canonical array
3038 build_signature_for_libgcj (tree type
)
3042 sig
= build_java_signature (type
);
3043 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
3044 IDENTIFIER_LENGTH (sig
)));
3048 /* Build an entry in the type assertion table. */
3051 build_assertion_table_entry (tree code
, tree op1
, tree op2
)
3053 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3056 START_RECORD_CONSTRUCTOR (v
, assertion_entry_type
);
3057 PUSH_FIELD_VALUE (v
, "assertion_code", code
);
3058 PUSH_FIELD_VALUE (v
, "op1", op1
);
3059 PUSH_FIELD_VALUE (v
, "op2", op2
);
3060 FINISH_RECORD_CONSTRUCTOR (entry
, v
, assertion_entry_type
);
3065 /* Add an entry to the type assertion table. Callback used during hashtable
3069 add_assertion_table_entry (void **htab_entry
, void *ptr
)
3072 tree code_val
, op1_utf8
, op2_utf8
;
3073 vec
<constructor_elt
, va_gc
> **v
3074 = ((vec
<constructor_elt
, va_gc
> **) ptr
);
3075 type_assertion
*as
= (type_assertion
*) *htab_entry
;
3077 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
3079 if (as
->op1
== NULL_TREE
)
3080 op1_utf8
= null_pointer_node
;
3082 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3084 if (as
->op2
== NULL_TREE
)
3085 op2_utf8
= null_pointer_node
;
3087 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3089 entry
= build_assertion_table_entry (code_val
, op1_utf8
, op2_utf8
);
3091 CONSTRUCTOR_APPEND_ELT (*v
, NULL_TREE
, entry
);
3095 /* Generate the type assertion table for KLASS, and return its DECL. */
3098 emit_assertion_table (tree klass
)
3100 tree null_entry
, ctor
, table_decl
;
3101 htab_t assertions_htab
= TYPE_ASSERTIONS (klass
);
3102 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3104 /* Iterate through the hash table. */
3105 htab_traverse (assertions_htab
, add_assertion_table_entry
, &v
);
3107 /* Finish with a null entry. */
3108 null_entry
= build_assertion_table_entry (integer_zero_node
,
3112 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, null_entry
);
3114 ctor
= build_constructor (assertion_table_type
, v
);
3116 table_decl
= build_decl (input_location
,
3117 VAR_DECL
, mangled_classname ("_type_assert_", klass
),
3118 assertion_table_type
);
3120 TREE_STATIC (table_decl
) = 1;
3121 TREE_READONLY (table_decl
) = 1;
3122 TREE_CONSTANT (table_decl
) = 1;
3123 DECL_IGNORED_P (table_decl
) = 1;
3125 DECL_INITIAL (table_decl
) = ctor
;
3126 DECL_ARTIFICIAL (table_decl
) = 1;
3127 rest_of_decl_compilation (table_decl
, 1, 0);
3133 init_class_processing (void)
3135 fields_ident
= get_identifier ("fields");
3136 info_ident
= get_identifier ("info");
3138 gcc_obstack_init (&temporary_obstack
);
3141 static hashval_t
java_treetreehash_hash (const void *);
3142 static int java_treetreehash_compare (const void *, const void *);
3144 /* A hash table mapping trees to trees. Used generally. */
3146 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3149 java_treetreehash_hash (const void *k_p
)
3151 const struct treetreehash_entry
*const k
3152 = (const struct treetreehash_entry
*) k_p
;
3153 return JAVA_TREEHASHHASH_H (k
->key
);
3157 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3159 const struct treetreehash_entry
*const k1
3160 = (const struct treetreehash_entry
*) k1_p
;
3161 const_tree
const k2
= (const_tree
) k2_p
;
3162 return (k1
->key
== k2
);
3166 java_treetreehash_find (htab_t ht
, tree t
)
3168 struct treetreehash_entry
*e
;
3169 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3170 e
= (struct treetreehash_entry
*) htab_find_with_hash (ht
, t
, hv
);
3178 java_treetreehash_new (htab_t ht
, tree t
)
3181 struct treetreehash_entry
*tthe
;
3182 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3184 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3187 tthe
= ggc_alloc_cleared_treetreehash_entry ();
3192 tthe
= (struct treetreehash_entry
*) *e
;
3193 return &tthe
->value
;
3197 java_treetreehash_create (size_t size
)
3199 return htab_create_ggc (size
, java_treetreehash_hash
,
3200 java_treetreehash_compare
, NULL
);
3203 /* Break down qualified IDENTIFIER into package and class-name components.
3204 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3205 "pkg.foo", and RIGHT to "Bar". */
3208 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3211 int l
= IDENTIFIER_LENGTH (source
);
3213 base
= (char *) alloca (l
+ 1);
3214 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3216 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3218 while (*p
!= '.' && p
!= base
)
3221 /* We didn't find a '.'. Return an error. */
3227 *right
= get_identifier (p
+1);
3228 *left
= get_identifier (base
);
3233 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3234 if the classes are from the same package. */
3237 in_same_package (tree name1
, tree name2
)
3243 if (TREE_CODE (name1
) == TYPE_DECL
)
3244 name1
= DECL_NAME (name1
);
3245 if (TREE_CODE (name2
) == TYPE_DECL
)
3246 name2
= DECL_NAME (name2
);
3248 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3249 /* One in empty package. */
3252 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3253 /* Both in empty package. */
3256 split_qualified_name (&pkg1
, &tmp
, name1
);
3257 split_qualified_name (&pkg2
, &tmp
, name2
);
3259 return (pkg1
== pkg2
);
3262 /* lang_hooks.decls.final_write_globals: perform final processing on
3263 global variables. */
3266 java_write_globals (void)
3268 tree
*vec
= vec_safe_address (pending_static_fields
);
3269 int len
= vec_safe_length (pending_static_fields
);
3270 write_global_declarations ();
3271 emit_debug_global_declarations (vec
, len
);
3272 vec_free (pending_static_fields
);
3275 #include "gt-java-class.h"