1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2010 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>.
21 Java and all Java-based marks are trademarks or registered trademarks
22 of Sun Microsystems, Inc. in the United States and other countries.
23 The Free Software Foundation is independent of Sun Microsystems, Inc. */
25 /* Written by Per Bothner <bothner@cygnus.com> */
29 #include "coretypes.h"
32 #include "java-tree.h"
35 #include "diagnostic-core.h"
43 #include "tree-iterator.h"
45 #include "tm.h" /* FIXME: For gcc_obstack_init from defaults.h. */
47 /* DOS brain-damage */
49 #define O_BINARY 0 /* MS-DOS brain-damage */
52 static tree
make_method_value (tree
);
53 static tree
build_java_method_type (tree
, tree
, int);
54 static int32
hashUtf8String (const char *, int);
55 static tree
make_field_value (tree
);
56 static tree
get_dispatch_vector (tree
);
57 static tree
get_dispatch_table (tree
, tree
);
58 static int supers_all_compiled (tree type
);
59 static tree
maybe_layout_super_class (tree
, tree
);
60 static void add_miranda_methods (tree
, tree
);
61 static int assume_compiled (const char *);
62 static tree
build_symbol_entry (tree
, tree
);
63 static tree
emit_assertion_table (tree
);
64 static void register_class (void);
66 struct obstack temporary_obstack
;
68 static const char *cyclic_inheritance_report
;
70 /* The compiler generates different code depending on whether or not
71 it can assume certain classes have been compiled down to native
72 code or not. The compiler options -fassume-compiled= and
73 -fno-assume-compiled= are used to create a tree of
74 class_flag_node objects. This tree is queried to determine if
75 a class is assume to be compiled or not. Each node in the tree
76 represents either a package or a specific class. */
78 typedef struct class_flag_node_struct
80 /* The class or package name. */
83 /* Nonzero if this represents an exclusion. */
86 /* Pointers to other nodes in the tree. */
87 struct class_flag_node_struct
*parent
;
88 struct class_flag_node_struct
*sibling
;
89 struct class_flag_node_struct
*child
;
92 static class_flag_node
*find_class_flag_node (class_flag_node
*, const char *);
93 static void add_class_flag (class_flag_node
**, const char *, int);
95 /* This is the root of the include/exclude tree. */
97 static class_flag_node
*assume_compiled_tree
;
99 static class_flag_node
*enable_assert_tree
;
101 static GTY(()) tree class_roots
[4];
102 #define fields_ident class_roots[0] /* get_identifier ("fields") */
103 #define info_ident class_roots[1] /* get_identifier ("info") */
104 #define class_list class_roots[2]
105 #define class_dtable_decl class_roots[3]
107 static GTY(()) VEC(tree
,gc
) *registered_class
;
109 /* A tree that returns the address of the class$ of the class
110 currently being compiled. */
111 static GTY(()) tree this_classdollar
;
113 /* A list of static class fields. This is to emit proper debug
115 VEC(tree
,gc
) *pending_static_fields
;
117 /* Return the node that most closely represents the class whose name
118 is IDENT. Start the search from NODE (followed by its siblings).
119 Return NULL if an appropriate node does not exist. */
121 static class_flag_node
*
122 find_class_flag_node (class_flag_node
*node
, const char *ident
)
126 size_t node_ident_length
= strlen (node
->ident
);
128 /* node_ident_length is zero at the root of the tree. If the
129 identifiers are the same length, then we have matching
130 classes. Otherwise check if we've matched an enclosing
133 if (node_ident_length
== 0
134 || (strncmp (ident
, node
->ident
, node_ident_length
) == 0
135 && (ident
[node_ident_length
] == '\0'
136 || ident
[node_ident_length
] == '.')))
138 /* We've found a match, however, there might be a more
141 class_flag_node
*found
= find_class_flag_node (node
->child
, ident
);
148 /* No match yet. Continue through the sibling list. */
149 node
= node
->sibling
;
152 /* No match at all in this tree. */
157 add_class_flag (class_flag_node
**rootp
, const char *ident
, int value
)
159 class_flag_node
*root
= *rootp
;
160 class_flag_node
*parent
, *node
;
162 /* Create the root of the tree if it doesn't exist yet. */
166 root
= XNEW (class_flag_node
);
169 root
->sibling
= NULL
;
175 /* Calling the function with the empty string means we're setting
176 value for the root of the hierarchy. */
184 /* Find the parent node for this new node. PARENT will either be a
185 class or a package name. Adjust PARENT accordingly. */
187 parent
= find_class_flag_node (root
, ident
);
188 if (strcmp (ident
, parent
->ident
) == 0)
189 parent
->value
= value
;
192 /* Insert new node into the tree. */
193 node
= XNEW (class_flag_node
);
195 node
->ident
= xstrdup (ident
);
199 node
->parent
= parent
;
200 node
->sibling
= parent
->child
;
201 parent
->child
= node
;
205 /* Add a new IDENT to the include/exclude tree. It's an exclusion
206 if EXCLUDEP is nonzero. */
209 add_assume_compiled (const char *ident
, int excludep
)
211 add_class_flag (&assume_compiled_tree
, ident
, excludep
);
214 /* The default value returned by enable_assertions. */
216 #define DEFAULT_ENABLE_ASSERT (optimize == 0)
218 /* Enter IDENT (a class or package name) into the enable-assertions table.
219 VALUE is true to enable and false to disable. */
222 add_enable_assert (const char *ident
, int value
)
224 if (enable_assert_tree
== NULL
)
225 add_class_flag (&enable_assert_tree
, "", DEFAULT_ENABLE_ASSERT
);
226 add_class_flag (&enable_assert_tree
, ident
, value
);
229 /* Returns nonzero if IDENT is the name of a class that the compiler
230 should assume has been compiled to object code. */
233 assume_compiled (const char *ident
)
238 if (NULL
== assume_compiled_tree
)
241 i
= find_class_flag_node (assume_compiled_tree
, ident
);
248 /* Return true if we should generate code to check assertions within KLASS. */
251 enable_assertions (tree klass
)
253 /* Check if command-line specifies whether we should check assertions. */
255 if (klass
!= NULL_TREE
&& DECL_NAME (klass
) && enable_assert_tree
!= NULL
)
257 const char *ident
= IDENTIFIER_POINTER (DECL_NAME (klass
));
258 class_flag_node
*node
259 = find_class_flag_node (enable_assert_tree
, ident
);
263 /* The default is to enable assertions if generating class files,
264 or not optimizing. */
265 return DEFAULT_ENABLE_ASSERT
;
268 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
269 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
270 Also, PREFIX is prepended, and SUFFIX is appended. */
273 ident_subst (const char* old_name
,
280 int prefix_len
= strlen (prefix
);
281 int suffix_len
= strlen (suffix
);
282 int i
= prefix_len
+ old_length
+ suffix_len
+ 1;
283 char *buffer
= (char *) alloca (i
);
285 strcpy (buffer
, prefix
);
286 for (i
= 0; i
< old_length
; i
++)
288 char ch
= old_name
[i
];
291 buffer
[prefix_len
+ i
] = ch
;
293 strcpy (buffer
+ prefix_len
+ old_length
, suffix
);
294 return get_identifier (buffer
);
297 /* Return an IDENTIFIER_NODE the same as OLD_ID,
298 except that characters matching OLD_CHAR are substituted by NEW_CHAR.
299 Also, PREFIX is prepended, and SUFFIX is appended. */
302 identifier_subst (const tree old_id
,
308 return ident_subst (IDENTIFIER_POINTER (old_id
), IDENTIFIER_LENGTH (old_id
),
309 prefix
, old_char
, new_char
, suffix
);
312 /* Generate a valid C identifier from the name of the class TYPE,
313 prefixed by PREFIX. */
316 mangled_classname (const char *prefix
, tree type
)
319 tree ident
= TYPE_NAME (type
);
320 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
321 ident
= DECL_NAME (ident
);
322 result
= identifier_subst (ident
, prefix
, '.', '_', "");
324 /* Replace any characters that aren't in the set [0-9a-zA-Z_$] with
325 "_0xXX". Class names containing such chracters are uncommon, but
326 they do sometimes occur in class files. Without this check,
327 these names cause assembly errors.
329 There is a possibility that a real class name could conflict with
330 the identifier we generate, but it is unlikely and will
331 immediately be detected as an assembler error. At some point we
332 should do something more elaborate (perhaps using the full
333 unicode mangling scheme) in order to prevent such a conflict. */
336 const int len
= IDENTIFIER_LENGTH (result
);
337 const char *p
= IDENTIFIER_POINTER (result
);
338 int illegal_chars
= 0;
340 /* Make two passes over the identifier. The first pass is merely
341 to count illegal characters; we need to do this in order to
342 allocate a buffer. */
343 for (i
= 0; i
< len
; i
++)
346 illegal_chars
+= (! ISALNUM (c
) && c
!= '_' && c
!= '$');
349 /* And the second pass, which is rarely executed, does the
351 if (illegal_chars
!= 0)
353 char *buffer
= (char *) alloca (illegal_chars
* 4 + len
+ 1);
356 for (i
= 0, j
= 0; i
< len
; i
++)
359 if (! ISALNUM (c
) && c
!= '_' && c
!= '$')
362 sprintf (&buffer
[j
], "0x%02x", c
);
370 result
= get_identifier (buffer
);
381 type
= make_node (RECORD_TYPE
);
382 /* Unfortunately we must create the binfo here, so that class
384 TYPE_BINFO (type
) = make_tree_binfo (0);
385 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
386 TYPE_CATCH_CLASSES (type
) = NULL
;
387 /* Push a dummy entry; we can't call make_catch_class_record here
388 because other infrastructure may not be set up yet. We'll come
389 back and fill it in later once said infrastructure is
391 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (type
), NULL_TREE
, NULL_TREE
);
396 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
397 and where each of the constituents is separated by '/',
398 return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
401 unmangle_classname (const char *name
, int name_length
)
403 tree to_return
= ident_subst (name
, name_length
, "", '/', '.', "");
404 /* It's not sufficient to compare to_return and get_identifier
405 (name) to determine whether to_return is qualified. There are
406 cases in signature analysis where name will be stripped of a
408 name
= IDENTIFIER_POINTER (to_return
);
412 QUALIFIED_P (to_return
) = 1;
419 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
422 const char *type_name = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
423 char *buf = (char *) alloca (strlen (type_name) \
424 + strlen (#NAME "_syms_") + 1); \
427 sprintf (buf, #NAME "_%s", type_name); \
428 TYPE_## TABLE ##_DECL (type) = decl = \
429 build_decl (input_location, VAR_DECL, get_identifier (buf), TABLE_TYPE); \
430 DECL_EXTERNAL (decl) = 1; \
431 TREE_STATIC (decl) = 1; \
432 TREE_READONLY (decl) = 1; \
433 TREE_CONSTANT (decl) = 1; \
434 DECL_IGNORED_P (decl) = 1; \
435 /* Mark the table as belonging to this class. */ \
437 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
438 DECL_OWNER (decl) = TYPE; \
439 sprintf (buf, #NAME "_syms_%s", type_name); \
440 TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
441 build_decl (input_location, VAR_DECL, get_identifier (buf), symbols_array_type); \
442 TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
443 TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
444 DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
448 /* Given a class, create the DECLs for all its associated indirect
451 gen_indirect_dispatch_tables (tree type
)
453 const char *type_name
= IDENTIFIER_POINTER (mangled_classname ("", type
));
456 char *buf
= (char *) alloca (strlen (type_name
)
457 + strlen ("_catch_classes_") + 1);
458 tree catch_class_type
= make_node (RECORD_TYPE
);
460 sprintf (buf
, "_catch_classes_%s", type_name
);
461 PUSH_FIELD (input_location
,
462 catch_class_type
, field
, "address", utf8const_ptr_type
);
463 PUSH_FIELD (input_location
,
464 catch_class_type
, field
, "classname", ptr_type_node
);
465 FINISH_RECORD (catch_class_type
);
467 TYPE_CTABLE_DECL (type
)
468 = build_decl (input_location
, VAR_DECL
, get_identifier (buf
),
469 build_array_type (catch_class_type
, 0));
470 DECL_EXTERNAL (TYPE_CTABLE_DECL (type
)) = 1;
471 TREE_STATIC (TYPE_CTABLE_DECL (type
)) = 1;
472 TREE_READONLY (TYPE_CTABLE_DECL (type
)) = 1;
473 TREE_CONSTANT (TYPE_CTABLE_DECL (type
)) = 1;
474 DECL_IGNORED_P (TYPE_CTABLE_DECL (type
)) = 1;
475 pushdecl (TYPE_CTABLE_DECL (type
));
478 if (flag_indirect_dispatch
)
480 GEN_TABLE (ATABLE
, _atable
, atable_type
, type
);
481 GEN_TABLE (OTABLE
, _otable
, otable_type
, type
);
482 GEN_TABLE (ITABLE
, _itable
, itable_type
, type
);
489 push_class (tree class_type
, tree class_name
)
491 tree decl
, signature
;
492 location_t saved_loc
= input_location
;
493 CLASS_P (class_type
) = 1;
494 decl
= build_decl (input_location
, TYPE_DECL
, class_name
, class_type
);
495 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
497 /* dbxout needs a DECL_SIZE if in gstabs mode */
498 DECL_SIZE (decl
) = integer_zero_node
;
500 input_location
= saved_loc
;
501 signature
= identifier_subst (class_name
, "L", '.', '/', ";");
502 IDENTIFIER_SIGNATURE_TYPE (signature
) = build_pointer_type (class_type
);
504 /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
505 both a typedef and in the struct name-space. We may want to re-visit
506 this later, but for now it reduces the changes needed for gdb. */
507 DECL_ARTIFICIAL (decl
) = 1;
509 pushdecl_top_level (decl
);
514 /* Finds the (global) class named NAME. Creates the class if not found.
515 Also creates associated TYPE_DECL.
516 Does not check if the class actually exists, load the class,
517 fill in field or methods, or do layout_type. */
520 lookup_class (tree name
)
522 tree decl
= IDENTIFIER_CLASS_VALUE (name
);
523 if (decl
== NULL_TREE
)
524 decl
= push_class (make_class (), name
);
525 return TREE_TYPE (decl
);
529 set_super_info (int access_flags
, tree this_class
,
530 tree super_class
, int interfaces_count
)
532 int total_supers
= interfaces_count
;
533 tree class_decl
= TYPE_NAME (this_class
);
539 TYPE_BINFO (this_class
) = make_tree_binfo (total_supers
);
540 TYPE_VFIELD (this_class
) = TYPE_VFIELD (object_type_node
);
543 tree super_binfo
= make_tree_binfo (0);
544 BINFO_TYPE (super_binfo
) = super_class
;
545 BINFO_OFFSET (super_binfo
) = integer_zero_node
;
546 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), super_binfo
);
547 CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class
)) = 1;
550 set_class_decl_access_flags (access_flags
, class_decl
);
554 set_class_decl_access_flags (int access_flags
, tree class_decl
)
556 if (access_flags
& ACC_PUBLIC
) CLASS_PUBLIC (class_decl
) = 1;
557 if (access_flags
& ACC_FINAL
) CLASS_FINAL (class_decl
) = 1;
558 if (access_flags
& ACC_SUPER
) CLASS_SUPER (class_decl
) = 1;
559 if (access_flags
& ACC_INTERFACE
) CLASS_INTERFACE (class_decl
) = 1;
560 if (access_flags
& ACC_ABSTRACT
) CLASS_ABSTRACT (class_decl
) = 1;
561 if (access_flags
& ACC_STATIC
) CLASS_STATIC (class_decl
) = 1;
562 if (access_flags
& ACC_PRIVATE
) CLASS_PRIVATE (class_decl
) = 1;
563 if (access_flags
& ACC_PROTECTED
) CLASS_PROTECTED (class_decl
) = 1;
564 if (access_flags
& ACC_STRICT
) CLASS_STRICTFP (class_decl
) = 1;
565 if (access_flags
& ACC_ENUM
) CLASS_ENUM (class_decl
) = 1;
566 if (access_flags
& ACC_SYNTHETIC
) CLASS_SYNTHETIC (class_decl
) = 1;
567 if (access_flags
& ACC_ANNOTATION
) CLASS_ANNOTATION (class_decl
) = 1;
570 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
571 direct sub-classes of Object are 1, and so on. */
574 class_depth (tree clas
)
577 if (! CLASS_LOADED_P (clas
))
578 load_class (clas
, 1);
579 if (TYPE_SIZE (clas
) == error_mark_node
)
581 while (clas
!= object_type_node
)
584 clas
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas
), 0));
589 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
592 interface_of_p (tree type1
, tree type2
)
595 tree binfo
, base_binfo
;
597 if (! TYPE_BINFO (type2
))
600 for (binfo
= TYPE_BINFO (type2
), i
= 0;
601 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
602 if (BINFO_TYPE (base_binfo
) == type1
)
605 for (binfo
= TYPE_BINFO (type2
), i
= 0;
606 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++) /* */
607 if (BINFO_TYPE (base_binfo
)
608 && interface_of_p (type1
, BINFO_TYPE (base_binfo
)))
614 /* Return true iff TYPE1 inherits from TYPE2. */
617 inherits_from_p (tree type1
, tree type2
)
619 while (type1
!= NULL_TREE
&& TREE_CODE (type1
) == RECORD_TYPE
)
624 if (! CLASS_LOADED_P (type1
))
625 load_class (type1
, 1);
627 type1
= maybe_layout_super_class (CLASSTYPE_SUPER (type1
), type1
);
632 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
635 enclosing_context_p (tree type1
, tree type2
)
637 if (!INNER_CLASS_TYPE_P (type2
))
640 for (type2
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
)));
642 type2
= (INNER_CLASS_TYPE_P (type2
) ?
643 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))) : NULL_TREE
))
653 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
657 common_enclosing_context_p (tree type1
, tree type2
)
662 for (current
= type2
; current
;
663 current
= (INNER_CLASS_TYPE_P (current
) ?
664 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
666 if (type1
== current
)
669 if (INNER_CLASS_TYPE_P (type1
))
670 type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
)));
677 /* Return 1 iff there exists a common enclosing "this" between TYPE1
678 and TYPE2, without crossing any static context. */
681 common_enclosing_instance_p (tree type1
, tree type2
)
683 if (!PURE_INNER_CLASS_TYPE_P (type1
) || !PURE_INNER_CLASS_TYPE_P (type2
))
686 for (type1
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))); type1
;
687 type1
= (PURE_INNER_CLASS_TYPE_P (type1
) ?
688 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1
))) : NULL_TREE
))
691 for (current
= TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2
))); current
;
692 current
= (PURE_INNER_CLASS_TYPE_P (current
) ?
693 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current
))) :
695 if (type1
== current
)
701 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
702 found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
703 if attempt is made to add it twice. */
706 maybe_add_interface (tree this_class
, tree interface_class
)
708 tree binfo
, base_binfo
;
711 for (binfo
= TYPE_BINFO (this_class
), i
= 0;
712 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
713 if (BINFO_TYPE (base_binfo
) == interface_class
)
714 return interface_class
;
715 add_interface (this_class
, interface_class
);
719 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
722 add_interface (tree this_class
, tree interface_class
)
724 tree interface_binfo
= make_tree_binfo (0);
726 BINFO_TYPE (interface_binfo
) = interface_class
;
727 BINFO_OFFSET (interface_binfo
) = integer_zero_node
;
728 BINFO_VPTR_FIELD (interface_binfo
) = integer_zero_node
;
729 BINFO_VIRTUAL_P (interface_binfo
) = 1;
731 BINFO_BASE_APPEND (TYPE_BINFO (this_class
), interface_binfo
);
735 build_java_method_type (tree fntype
, tree this_class
, int access_flags
)
737 if (access_flags
& ACC_STATIC
)
739 fntype
= build_method_type (this_class
, fntype
);
741 /* We know that arg 1 of every nonstatic method is non-null; tell
743 TYPE_ATTRIBUTES (fntype
) = (tree_cons
744 (get_identifier ("nonnull"),
745 tree_cons (NULL_TREE
,
746 build_int_cst (NULL_TREE
, 1),
748 TYPE_ATTRIBUTES (fntype
)));
753 java_hide_decl (tree decl ATTRIBUTE_UNUSED
)
755 #ifdef HAVE_GAS_HIDDEN
756 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
757 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
762 add_method_1 (tree this_class
, int access_flags
, tree name
, tree function_type
)
764 tree method_type
, fndecl
;
766 method_type
= build_java_method_type (function_type
,
767 this_class
, access_flags
);
769 fndecl
= build_decl (input_location
, FUNCTION_DECL
, name
, method_type
);
770 DECL_CONTEXT (fndecl
) = this_class
;
772 DECL_LANG_SPECIFIC (fndecl
)
773 = ggc_alloc_cleared_lang_decl(sizeof (struct lang_decl
));
774 DECL_LANG_SPECIFIC (fndecl
)->desc
= LANG_DECL_FUNC
;
776 /* Initialize the static initializer test table. */
778 DECL_FUNCTION_INIT_TEST_TABLE (fndecl
) = java_treetreehash_create (10);
780 /* Initialize the initialized (static) class table. */
781 if (access_flags
& ACC_STATIC
)
782 DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl
) =
783 htab_create_ggc (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
785 DECL_CHAIN (fndecl
) = TYPE_METHODS (this_class
);
786 TYPE_METHODS (this_class
) = fndecl
;
788 /* If pointers to member functions use the least significant bit to
789 indicate whether a function is virtual, ensure a pointer
790 to this function will have that bit clear. */
791 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
792 && !(access_flags
& ACC_STATIC
)
793 && DECL_ALIGN (fndecl
) < 2 * BITS_PER_UNIT
)
794 DECL_ALIGN (fndecl
) = 2 * BITS_PER_UNIT
;
796 /* Notice that this is a finalizer and update the class type
797 accordingly. This is used to optimize instance allocation. */
798 if (name
== finalize_identifier_node
799 && TREE_TYPE (function_type
) == void_type_node
800 && TREE_VALUE (TYPE_ARG_TYPES (function_type
)) == void_type_node
)
801 HAS_FINALIZER_P (this_class
) = 1;
803 if (access_flags
& ACC_PUBLIC
) METHOD_PUBLIC (fndecl
) = 1;
804 if (access_flags
& ACC_PROTECTED
) METHOD_PROTECTED (fndecl
) = 1;
805 if (access_flags
& ACC_PRIVATE
)
806 METHOD_PRIVATE (fndecl
) = 1;
807 if (access_flags
& ACC_NATIVE
)
809 METHOD_NATIVE (fndecl
) = 1;
810 DECL_EXTERNAL (fndecl
) = 1;
813 /* FNDECL is external unless we are compiling it into this object
815 DECL_EXTERNAL (fndecl
) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class
) == 0;
816 if (access_flags
& ACC_STATIC
)
817 METHOD_STATIC (fndecl
) = 1;
818 if (access_flags
& ACC_FINAL
)
819 METHOD_FINAL (fndecl
) = 1;
820 if (access_flags
& ACC_SYNCHRONIZED
) METHOD_SYNCHRONIZED (fndecl
) = 1;
821 if (access_flags
& ACC_ABSTRACT
) METHOD_ABSTRACT (fndecl
) = 1;
822 if (access_flags
& ACC_STRICT
) METHOD_STRICTFP (fndecl
) = 1;
823 if (access_flags
& ACC_SYNTHETIC
) DECL_ARTIFICIAL (fndecl
) = 1;
824 if (access_flags
& ACC_BRIDGE
) METHOD_BRIDGE (fndecl
) = 1;
825 if (access_flags
& ACC_VARARGS
) METHOD_VARARGS (fndecl
) = 1;
829 /* Add a method to THIS_CLASS.
830 The method's name is NAME.
831 Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
834 add_method (tree this_class
, int access_flags
, tree name
, tree method_sig
)
836 tree function_type
, fndecl
;
837 const unsigned char *sig
838 = (const unsigned char *) IDENTIFIER_POINTER (method_sig
);
841 fatal_error ("bad method signature");
843 function_type
= get_type_from_signature (method_sig
);
844 fndecl
= add_method_1 (this_class
, access_flags
, name
, function_type
);
845 set_java_signature (TREE_TYPE (fndecl
), method_sig
);
850 add_field (tree klass
, tree name
, tree field_type
, int flags
)
852 int is_static
= (flags
& ACC_STATIC
) != 0;
854 field
= build_decl (input_location
,
855 is_static
? VAR_DECL
: FIELD_DECL
, name
, field_type
);
856 DECL_CHAIN (field
) = TYPE_FIELDS (klass
);
857 TYPE_FIELDS (klass
) = field
;
858 DECL_CONTEXT (field
) = klass
;
859 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field
);
861 if (flags
& ACC_PUBLIC
) FIELD_PUBLIC (field
) = 1;
862 if (flags
& ACC_PROTECTED
) FIELD_PROTECTED (field
) = 1;
863 if (flags
& ACC_PRIVATE
) FIELD_PRIVATE (field
) = 1;
864 if (flags
& ACC_FINAL
) FIELD_FINAL (field
) = 1;
865 if (flags
& ACC_VOLATILE
)
867 FIELD_VOLATILE (field
) = 1;
868 TREE_THIS_VOLATILE (field
) = 1;
870 if (flags
& ACC_TRANSIENT
) FIELD_TRANSIENT (field
) = 1;
871 if (flags
& ACC_ENUM
) FIELD_ENUM (field
) = 1;
872 if (flags
& ACC_SYNTHETIC
) FIELD_SYNTHETIC (field
) = 1;
875 FIELD_STATIC (field
) = 1;
876 /* Always make field externally visible. This is required so
877 that native methods can always access the field. */
878 TREE_PUBLIC (field
) = 1;
879 /* Hide everything that shouldn't be visible outside a DSO. */
880 if (flag_indirect_classes
881 || (FIELD_PRIVATE (field
)))
882 java_hide_decl (field
);
883 /* Considered external unless we are compiling it into this
885 DECL_EXTERNAL (field
) = (is_compiled_class (klass
) != 2);
886 if (!DECL_EXTERNAL (field
))
887 VEC_safe_push (tree
, gc
, pending_static_fields
, field
);
893 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
896 set_constant_value (tree field
, tree constant
)
898 if (field
== NULL_TREE
)
899 warning (OPT_Wattributes
,
900 "misplaced ConstantValue attribute (not in any field)");
901 else if (DECL_INITIAL (field
) != NULL_TREE
)
902 warning (OPT_Wattributes
,
903 "duplicate ConstantValue attribute for field '%s'",
904 IDENTIFIER_POINTER (DECL_NAME (field
)));
907 DECL_INITIAL (field
) = constant
;
908 if (TREE_TYPE (constant
) != TREE_TYPE (field
)
909 && ! (TREE_TYPE (constant
) == int_type_node
910 && INTEGRAL_TYPE_P (TREE_TYPE (field
))
911 && TYPE_PRECISION (TREE_TYPE (field
)) <= 32)
912 && ! (TREE_TYPE (constant
) == utf8const_ptr_type
913 && TREE_TYPE (field
) == string_ptr_type_node
))
914 error ("ConstantValue attribute of field '%s' has wrong type",
915 IDENTIFIER_POINTER (DECL_NAME (field
)));
919 /* Calculate a hash value for a string encoded in Utf8 format.
920 * This returns the same hash value as specified for java.lang.String.hashCode.
924 hashUtf8String (const char *str
, int len
)
926 const unsigned char* ptr
= (const unsigned char*) str
;
927 const unsigned char *limit
= ptr
+ len
;
931 int ch
= UTF8_GET (ptr
, limit
);
932 /* Updated specification from
933 http://www.javasoft.com/docs/books/jls/clarify.html. */
934 hash
= (31 * hash
) + ch
;
940 build_utf8_ref (tree name
)
942 const char * name_ptr
= IDENTIFIER_POINTER (name
);
943 int name_len
= IDENTIFIER_LENGTH (name
), name_pad
;
945 tree ctype
, field
= NULL_TREE
, str_type
, cinit
, string
;
946 static int utf8_count
= 0;
948 tree ref
= IDENTIFIER_UTF8_REF (name
);
950 VEC(constructor_elt
,gc
) *v
= NULL
;
951 if (ref
!= NULL_TREE
)
954 ctype
= make_node (RECORD_TYPE
);
955 /* '\0' byte plus padding to utf8const_type's alignment. */
956 name_pad
= TYPE_ALIGN_UNIT (utf8const_type
)
957 - (name_len
& (TYPE_ALIGN_UNIT (utf8const_type
) - 1));
958 str_type
= build_prim_array_type (unsigned_byte_type_node
,
959 name_len
+ name_pad
);
960 PUSH_FIELD (input_location
, ctype
, field
, "hash", unsigned_short_type_node
);
961 PUSH_FIELD (input_location
,
962 ctype
, field
, "length", unsigned_short_type_node
);
963 PUSH_FIELD (input_location
, ctype
, field
, "data", str_type
);
964 FINISH_RECORD (ctype
);
965 START_RECORD_CONSTRUCTOR (v
, ctype
);
966 name_hash
= hashUtf8String (name_ptr
, name_len
) & 0xFFFF;
967 PUSH_FIELD_VALUE (v
, "hash", build_int_cst (NULL_TREE
, name_hash
));
968 PUSH_FIELD_VALUE (v
, "length", build_int_cst (NULL_TREE
, name_len
));
969 string
= build_string (name_len
, name_ptr
);
970 TREE_TYPE (string
) = str_type
;
971 PUSH_FIELD_VALUE (v
, "data", string
);
972 FINISH_RECORD_CONSTRUCTOR (cinit
, v
, ctype
);
973 TREE_CONSTANT (cinit
) = 1;
975 /* Generate a unique-enough identifier. */
976 sprintf(buf
, "_Utf%d", ++utf8_count
);
978 decl
= build_decl (input_location
,
979 VAR_DECL
, get_identifier (buf
), utf8const_type
);
980 TREE_STATIC (decl
) = 1;
981 DECL_ARTIFICIAL (decl
) = 1;
982 DECL_IGNORED_P (decl
) = 1;
983 TREE_READONLY (decl
) = 1;
984 TREE_THIS_VOLATILE (decl
) = 0;
985 DECL_INITIAL (decl
) = cinit
;
987 if (HAVE_GAS_SHF_MERGE
)
990 /* Ensure decl_size is a multiple of utf8const_type's alignment. */
991 decl_size
= name_len
+ 4 + name_pad
;
992 if (flag_merge_constants
&& decl_size
< 256)
995 int flags
= (SECTION_OVERRIDE
996 | SECTION_MERGE
| (SECTION_ENTSIZE
& decl_size
));
997 sprintf (buf
, ".rodata.jutf8.%d", decl_size
);
998 switch_to_section (get_section (buf
, flags
, NULL
));
999 DECL_SECTION_NAME (decl
) = build_string (strlen (buf
), buf
);
1003 layout_decl (decl
, 0);
1004 DECL_SIZE (decl
) = TYPE_SIZE (ctype
);
1005 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (ctype
);
1007 rest_of_decl_compilation (decl
, global_bindings_p (), 0);
1008 varpool_mark_needed_node (varpool_node (decl
));
1009 ref
= build1 (ADDR_EXPR
, utf8const_ptr_type
, decl
);
1010 IDENTIFIER_UTF8_REF (name
) = ref
;
1014 /* Like build_class_ref, but instead of a direct reference generate a
1015 pointer into the constant pool. */
1018 build_indirect_class_ref (tree type
)
1022 index
= alloc_class_constant (type
);
1023 cl
= build_ref_from_constant_pool (index
);
1024 return convert (promote_type (class_ptr_type
), cl
);
1028 build_static_class_ref (tree type
)
1030 tree decl_name
, decl
, ref
;
1032 if (TYPE_SIZE (type
) == error_mark_node
)
1033 return null_pointer_node
;
1034 decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1035 "", '/', '/', ".class$$");
1036 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1037 if (decl
== NULL_TREE
)
1039 decl
= build_decl (input_location
, VAR_DECL
, decl_name
, class_type_node
);
1040 TREE_STATIC (decl
) = 1;
1041 if (! flag_indirect_classes
)
1043 TREE_PUBLIC (decl
) = 1;
1044 if (CLASS_PRIVATE (TYPE_NAME (type
)))
1045 java_hide_decl (decl
);
1047 DECL_IGNORED_P (decl
) = 1;
1048 DECL_ARTIFICIAL (decl
) = 1;
1049 if (is_compiled_class (type
) == 1)
1050 DECL_EXTERNAL (decl
) = 1;
1051 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1052 DECL_CLASS_FIELD_P (decl
) = 1;
1053 DECL_CONTEXT (decl
) = type
;
1055 /* ??? We want to preserve the DECL_CONTEXT we set just above,
1056 that that means not calling pushdecl_top_level. */
1057 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1060 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1065 build_classdollar_field (tree type
)
1067 tree decl_name
= identifier_subst (DECL_NAME (TYPE_NAME (type
)),
1068 "", '/', '/', ".class$");
1069 tree decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1071 if (decl
== NULL_TREE
)
1074 = build_decl (input_location
,
1075 VAR_DECL
, decl_name
,
1078 (build_type_variant (class_type_node
,
1080 /* const */ 1, 0)));
1081 TREE_STATIC (decl
) = 1;
1082 TREE_CONSTANT (decl
) = 1;
1083 TREE_READONLY (decl
) = 1;
1084 TREE_PUBLIC (decl
) = 1;
1085 java_hide_decl (decl
);
1086 DECL_IGNORED_P (decl
) = 1;
1087 DECL_ARTIFICIAL (decl
) = 1;
1088 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
1089 IDENTIFIER_GLOBAL_VALUE (decl_name
) = decl
;
1090 DECL_CLASS_FIELD_P (decl
) = 1;
1091 DECL_CONTEXT (decl
) = type
;
1097 /* Create a local variable that holds the current class$. */
1100 cache_this_class_ref (tree fndecl
)
1104 tree classdollar_field
;
1105 if (flag_indirect_classes
)
1106 classdollar_field
= build_classdollar_field (output_class
);
1108 classdollar_field
= build_static_class_ref (output_class
);
1110 this_classdollar
= build_decl (input_location
,
1111 VAR_DECL
, NULL_TREE
,
1112 TREE_TYPE (classdollar_field
));
1114 java_add_local_var (this_classdollar
);
1115 java_add_stmt (build2 (MODIFY_EXPR
, TREE_TYPE (this_classdollar
),
1116 this_classdollar
, classdollar_field
));
1119 this_classdollar
= build_classdollar_field (output_class
);
1121 /* Prepend class initialization for static methods reachable from
1123 if (METHOD_STATIC (fndecl
)
1124 && (! METHOD_PRIVATE (fndecl
)
1125 || INNER_CLASS_P (DECL_CONTEXT (fndecl
)))
1126 && ! DECL_CLINIT_P (fndecl
)
1127 && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl
))))
1129 tree init
= build_call_expr (soft_initclass_node
, 1,
1131 java_add_stmt (init
);
1135 /* Remove the reference to the local variable that holds the current
1139 uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED
)
1141 this_classdollar
= build_classdollar_field (output_class
);
1144 /* Build a reference to the class TYPE.
1145 Also handles primitive types and array types. */
1148 build_class_ref (tree type
)
1150 int is_compiled
= is_compiled_class (type
);
1154 if (TREE_CODE (type
) == POINTER_TYPE
)
1155 type
= TREE_TYPE (type
);
1157 if (flag_indirect_dispatch
1158 && type
!= output_class
1159 && TREE_CODE (type
) == RECORD_TYPE
)
1160 return build_indirect_class_ref (type
);
1162 if (type
== output_class
&& flag_indirect_classes
)
1164 /* This can be NULL if we see a JNI stub before we see any
1166 if (! this_classdollar
)
1167 this_classdollar
= build_classdollar_field (output_class
);
1168 return this_classdollar
;
1171 if (TREE_CODE (type
) == RECORD_TYPE
)
1172 return build_static_class_ref (type
);
1178 decl_name
= TYPE_NAME (type
);
1179 if (TREE_CODE (decl_name
) == TYPE_DECL
)
1180 decl_name
= DECL_NAME (decl_name
);
1181 name
= IDENTIFIER_POINTER (decl_name
);
1182 if (strncmp (name
, "promoted_", 9) == 0)
1184 sprintf (buffer
, "_Jv_%sClass", name
);
1185 decl_name
= get_identifier (buffer
);
1186 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1187 if (decl
== NULL_TREE
)
1189 decl
= build_decl (input_location
,
1190 VAR_DECL
, decl_name
, class_type_node
);
1191 TREE_STATIC (decl
) = 1;
1192 TREE_PUBLIC (decl
) = 1;
1193 DECL_EXTERNAL (decl
) = 1;
1194 DECL_ARTIFICIAL (decl
) = 1;
1195 pushdecl_top_level (decl
);
1199 ref
= build1 (ADDR_EXPR
, class_ptr_type
, decl
);
1203 return build_indirect_class_ref (type
);
1206 /* Create a local statically allocated variable that will hold a
1207 pointer to a static field. */
1210 build_fieldref_cache_entry (int index
, tree fdecl ATTRIBUTE_UNUSED
)
1212 tree decl
, decl_name
;
1213 const char *name
= IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class
));
1214 char *buf
= (char *) alloca (strlen (name
) + 20);
1215 sprintf (buf
, "%s_%d_ref", name
, index
);
1216 decl_name
= get_identifier (buf
);
1217 decl
= IDENTIFIER_GLOBAL_VALUE (decl_name
);
1218 if (decl
== NULL_TREE
)
1220 decl
= build_decl (input_location
,
1221 VAR_DECL
, decl_name
, ptr_type_node
);
1222 TREE_STATIC (decl
) = 1;
1223 TREE_PUBLIC (decl
) = 0;
1224 DECL_EXTERNAL (decl
) = 0;
1225 DECL_ARTIFICIAL (decl
) = 1;
1226 DECL_IGNORED_P (decl
) = 1;
1227 pushdecl_top_level (decl
);
1233 build_static_field_ref (tree fdecl
)
1235 tree fclass
= DECL_CONTEXT (fdecl
);
1236 int is_compiled
= is_compiled_class (fclass
);
1238 /* Allow static final fields to fold to a constant. When using
1239 -findirect-dispatch, we simply never do this folding if compiling
1240 from .class; in the .class file constants will be referred to via
1241 the constant pool. */
1242 if (!flag_indirect_dispatch
1244 || (FIELD_FINAL (fdecl
) && DECL_INITIAL (fdecl
) != NULL_TREE
1245 && (JSTRING_TYPE_P (TREE_TYPE (fdecl
))
1246 || JNUMERIC_TYPE_P (TREE_TYPE (fdecl
)))
1247 && TREE_CONSTANT (DECL_INITIAL (fdecl
)))))
1249 if (is_compiled
== 1)
1250 DECL_EXTERNAL (fdecl
) = 1;
1254 /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1255 and a class local static variable CACHE_ENTRY, then
1257 *(fdecl **)((__builtin_expect (cache_entry == null, false))
1258 ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1261 This can mostly be optimized away, so that the usual path is a
1262 load followed by a test and branch. _Jv_ResolvePoolEntry is
1263 only called once for each constant pool entry.
1265 There is an optimization that we don't do: at the start of a
1266 method, create a local copy of CACHE_ENTRY and use that instead.
1270 int cpool_index
= alloc_constant_fieldref (output_class
, fdecl
);
1271 tree cache_entry
= build_fieldref_cache_entry (cpool_index
, fdecl
);
1273 = build_call_expr (built_in_decls
[BUILT_IN_EXPECT
], 2,
1274 build2 (EQ_EXPR
, boolean_type_node
,
1275 cache_entry
, null_pointer_node
),
1276 boolean_false_node
);
1277 tree cpool_index_cst
= build_int_cst (NULL_TREE
, cpool_index
);
1279 = build_call_expr (soft_resolvepoolentry_node
, 2,
1280 build_class_ref (output_class
),
1282 init
= build2 (MODIFY_EXPR
, ptr_type_node
, cache_entry
, init
);
1283 init
= build3 (COND_EXPR
, ptr_type_node
, test
, init
, cache_entry
);
1284 init
= fold_convert (build_pointer_type (TREE_TYPE (fdecl
)), init
);
1285 fdecl
= build1 (INDIRECT_REF
, TREE_TYPE (fdecl
), init
);
1291 get_access_flags_from_decl (tree decl
)
1293 int access_flags
= 0;
1294 if (TREE_CODE (decl
) == FIELD_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
1296 if (FIELD_STATIC (decl
))
1297 access_flags
|= ACC_STATIC
;
1298 if (FIELD_PUBLIC (decl
))
1299 access_flags
|= ACC_PUBLIC
;
1300 if (FIELD_PROTECTED (decl
))
1301 access_flags
|= ACC_PROTECTED
;
1302 if (FIELD_PRIVATE (decl
))
1303 access_flags
|= ACC_PRIVATE
;
1304 if (FIELD_FINAL (decl
))
1305 access_flags
|= ACC_FINAL
;
1306 if (FIELD_VOLATILE (decl
))
1307 access_flags
|= ACC_VOLATILE
;
1308 if (FIELD_TRANSIENT (decl
))
1309 access_flags
|= ACC_TRANSIENT
;
1310 if (FIELD_ENUM (decl
))
1311 access_flags
|= ACC_ENUM
;
1312 if (FIELD_SYNTHETIC (decl
))
1313 access_flags
|= ACC_SYNTHETIC
;
1314 return access_flags
;
1316 if (TREE_CODE (decl
) == TYPE_DECL
)
1318 if (CLASS_PUBLIC (decl
))
1319 access_flags
|= ACC_PUBLIC
;
1320 if (CLASS_FINAL (decl
))
1321 access_flags
|= ACC_FINAL
;
1322 if (CLASS_SUPER (decl
))
1323 access_flags
|= ACC_SUPER
;
1324 if (CLASS_INTERFACE (decl
))
1325 access_flags
|= ACC_INTERFACE
;
1326 if (CLASS_ABSTRACT (decl
))
1327 access_flags
|= ACC_ABSTRACT
;
1328 if (CLASS_STATIC (decl
))
1329 access_flags
|= ACC_STATIC
;
1330 if (CLASS_PRIVATE (decl
))
1331 access_flags
|= ACC_PRIVATE
;
1332 if (CLASS_PROTECTED (decl
))
1333 access_flags
|= ACC_PROTECTED
;
1334 if (CLASS_STRICTFP (decl
))
1335 access_flags
|= ACC_STRICT
;
1336 if (CLASS_ENUM (decl
))
1337 access_flags
|= ACC_ENUM
;
1338 if (CLASS_SYNTHETIC (decl
))
1339 access_flags
|= ACC_SYNTHETIC
;
1340 if (CLASS_ANNOTATION (decl
))
1341 access_flags
|= ACC_ANNOTATION
;
1342 return access_flags
;
1344 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1346 if (METHOD_PUBLIC (decl
))
1347 access_flags
|= ACC_PUBLIC
;
1348 if (METHOD_PRIVATE (decl
))
1349 access_flags
|= ACC_PRIVATE
;
1350 if (METHOD_PROTECTED (decl
))
1351 access_flags
|= ACC_PROTECTED
;
1352 if (METHOD_STATIC (decl
))
1353 access_flags
|= ACC_STATIC
;
1354 if (METHOD_FINAL (decl
))
1355 access_flags
|= ACC_FINAL
;
1356 if (METHOD_SYNCHRONIZED (decl
))
1357 access_flags
|= ACC_SYNCHRONIZED
;
1358 if (METHOD_NATIVE (decl
))
1359 access_flags
|= ACC_NATIVE
;
1360 if (METHOD_ABSTRACT (decl
))
1361 access_flags
|= ACC_ABSTRACT
;
1362 if (METHOD_STRICTFP (decl
))
1363 access_flags
|= ACC_STRICT
;
1364 if (METHOD_INVISIBLE (decl
))
1365 access_flags
|= ACC_INVISIBLE
;
1366 if (DECL_ARTIFICIAL (decl
))
1367 access_flags
|= ACC_SYNTHETIC
;
1368 if (METHOD_BRIDGE (decl
))
1369 access_flags
|= ACC_BRIDGE
;
1370 if (METHOD_VARARGS (decl
))
1371 access_flags
|= ACC_VARARGS
;
1372 return access_flags
;
1377 static GTY (()) int alias_labelno
= 0;
1379 /* Create a private alias for METHOD. Using this alias instead of the method
1380 decl ensures that ncode entries in the method table point to the real function
1381 at runtime, not a PLT entry. */
1384 make_local_function_alias (tree method
)
1386 #ifdef ASM_OUTPUT_DEF
1389 const char *method_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
));
1390 char *name
= (char *) alloca (strlen (method_name
) + 2);
1391 char *buf
= (char *) alloca (strlen (method_name
) + 128);
1393 /* Only create aliases for local functions. */
1394 if (DECL_EXTERNAL (method
))
1397 /* Prefix method_name with 'L' for the alias label. */
1399 strcpy (name
+ 1, method_name
);
1401 ASM_GENERATE_INTERNAL_LABEL (buf
, name
, alias_labelno
++);
1402 alias
= build_decl (input_location
,
1403 FUNCTION_DECL
, get_identifier (buf
),
1404 TREE_TYPE (method
));
1405 DECL_CONTEXT (alias
) = NULL
;
1406 TREE_READONLY (alias
) = TREE_READONLY (method
);
1407 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (method
);
1408 TREE_PUBLIC (alias
) = 0;
1409 DECL_EXTERNAL (alias
) = 0;
1410 DECL_ARTIFICIAL (alias
) = 1;
1411 DECL_INITIAL (alias
) = error_mark_node
;
1412 TREE_ADDRESSABLE (alias
) = 1;
1413 TREE_USED (alias
) = 1;
1414 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias
)) = 1;
1415 if (!flag_syntax_only
)
1416 assemble_alias (alias
, DECL_ASSEMBLER_NAME (method
));
1423 /** Make reflection data (_Jv_Field) for field FDECL. */
1426 make_field_value (tree fdecl
)
1430 tree type
= TREE_TYPE (fdecl
);
1431 int resolved
= is_compiled_class (type
) && ! flag_indirect_dispatch
;
1432 VEC(constructor_elt
,gc
) *v
= NULL
;
1434 START_RECORD_CONSTRUCTOR (v
, field_type_node
);
1435 PUSH_FIELD_VALUE (v
, "name", build_utf8_ref (DECL_NAME (fdecl
)));
1437 type
= build_class_ref (type
);
1440 tree signature
= build_java_signature (type
);
1442 type
= build_utf8_ref (unmangle_classname
1443 (IDENTIFIER_POINTER (signature
),
1444 IDENTIFIER_LENGTH (signature
)));
1446 PUSH_FIELD_VALUE (v
, "type", type
);
1448 flags
= get_access_flags_from_decl (fdecl
);
1450 flags
|= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1452 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, flags
));
1453 PUSH_FIELD_VALUE (v
, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl
)));
1456 tree field_address
= integer_zero_node
;
1458 if ((DECL_INITIAL (fdecl
) || ! flag_indirect_classes
)
1459 && FIELD_STATIC (fdecl
))
1460 field_address
= build_address_of (fdecl
);
1462 index
= (FIELD_STATIC (fdecl
)
1463 ? DECL_CHAIN (TYPE_FIELDS (field_info_union_node
))
1464 : TYPE_FIELDS (field_info_union_node
));
1465 value
= (FIELD_STATIC (fdecl
)
1467 : byte_position (fdecl
));
1471 build_constructor_single (field_info_union_node
, index
, value
));
1474 FINISH_RECORD_CONSTRUCTOR (finit
, v
, field_type_node
);
1478 /** Make reflection data (_Jv_Method) for method MDECL. */
1481 make_method_value (tree mdecl
)
1483 static int method_name_count
= 0;
1488 #define ACC_TRANSLATED 0x4000
1489 int accflags
= get_access_flags_from_decl (mdecl
) | ACC_TRANSLATED
;
1490 VEC(constructor_elt
,gc
) *v
= NULL
;
1492 class_decl
= DECL_CONTEXT (mdecl
);
1493 /* For interfaces, the index field contains the dispatch index. */
1494 if (CLASS_INTERFACE (TYPE_NAME (class_decl
)))
1495 index
= build_int_cst (NULL_TREE
,
1496 get_interface_method_index (mdecl
, class_decl
));
1497 else if (!flag_indirect_dispatch
&& get_method_index (mdecl
) != NULL_TREE
)
1498 index
= get_method_index (mdecl
);
1500 index
= integer_minus_one_node
;
1502 code
= null_pointer_node
;
1503 if (METHOD_ABSTRACT (mdecl
))
1504 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1505 soft_abstractmethod_node
);
1507 code
= build1 (ADDR_EXPR
, nativecode_ptr_type_node
,
1508 make_local_function_alias (mdecl
));
1509 START_RECORD_CONSTRUCTOR (v
, method_type_node
);
1510 PUSH_FIELD_VALUE (v
, "name",
1511 build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl
) ?
1512 init_identifier_node
1513 : DECL_NAME (mdecl
)));
1515 tree signature
= build_java_signature (TREE_TYPE (mdecl
));
1516 PUSH_FIELD_VALUE (v
, "signature",
1519 (IDENTIFIER_POINTER(signature
),
1520 IDENTIFIER_LENGTH(signature
)))));
1522 PUSH_FIELD_VALUE (v
, "accflags", build_int_cst (NULL_TREE
, accflags
));
1523 PUSH_FIELD_VALUE (v
, "index", index
);
1524 PUSH_FIELD_VALUE (v
, "ncode", code
);
1527 /* Compute the `throws' information for the method. */
1528 tree table
= null_pointer_node
;
1530 if (!VEC_empty (tree
, DECL_FUNCTION_THROWS (mdecl
)))
1532 int length
= 1 + VEC_length (tree
, DECL_FUNCTION_THROWS (mdecl
));
1533 tree t
, type
, array
;
1535 VEC(constructor_elt
,gc
) *v
= NULL
;
1536 int idx
= length
- 1;
1540 v
= VEC_alloc (constructor_elt
, gc
, length
);
1541 VEC_safe_grow_cleared (constructor_elt
, gc
, v
, length
);
1543 e
= VEC_index (constructor_elt
, v
, idx
--);
1544 e
->value
= null_pointer_node
;
1547 VEC_iterate (tree
, DECL_FUNCTION_THROWS (mdecl
), ix
, t
);
1550 tree sig
= DECL_NAME (TYPE_NAME (t
));
1552 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
1553 IDENTIFIER_LENGTH (sig
)));
1554 e
= VEC_index (constructor_elt
, v
, idx
--);
1557 gcc_assert (idx
== -1);
1558 type
= build_prim_array_type (ptr_type_node
, length
);
1559 table
= build_constructor (type
, v
);
1560 /* Compute something unique enough. */
1561 sprintf (buf
, "_methods%d", method_name_count
++);
1562 array
= build_decl (input_location
,
1563 VAR_DECL
, get_identifier (buf
), type
);
1564 DECL_INITIAL (array
) = table
;
1565 TREE_STATIC (array
) = 1;
1566 DECL_ARTIFICIAL (array
) = 1;
1567 DECL_IGNORED_P (array
) = 1;
1568 rest_of_decl_compilation (array
, 1, 0);
1570 table
= build1 (ADDR_EXPR
, ptr_type_node
, array
);
1573 PUSH_FIELD_VALUE (v
, "throws", table
);
1576 FINISH_RECORD_CONSTRUCTOR (minit
, v
, method_type_node
);
1581 get_dispatch_vector (tree type
)
1583 tree vtable
= TYPE_VTABLE (type
);
1585 if (vtable
== NULL_TREE
)
1589 tree super
= CLASSTYPE_SUPER (type
);
1590 HOST_WIDE_INT nvirtuals
= tree_low_cst (TYPE_NVIRTUALS (type
), 0);
1591 vtable
= make_tree_vec (nvirtuals
);
1592 TYPE_VTABLE (type
) = vtable
;
1593 if (super
!= NULL_TREE
)
1595 tree super_vtable
= get_dispatch_vector (super
);
1597 for (i
= tree_low_cst (TYPE_NVIRTUALS (super
), 0); --i
>= 0; )
1598 TREE_VEC_ELT (vtable
, i
) = TREE_VEC_ELT (super_vtable
, i
);
1601 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
1602 method
= DECL_CHAIN (method
))
1604 tree method_index
= get_method_index (method
);
1605 if (method_index
!= NULL_TREE
1606 && host_integerp (method_index
, 0))
1607 TREE_VEC_ELT (vtable
, tree_low_cst (method_index
, 0)) = method
;
1615 get_dispatch_table (tree type
, tree this_class_addr
)
1617 int abstract_p
= CLASS_ABSTRACT (TYPE_NAME (type
));
1618 tree vtable
= get_dispatch_vector (type
);
1620 int nvirtuals
= TREE_VEC_LENGTH (vtable
);
1623 VEC(constructor_elt
,gc
) *v
= NULL
;
1627 arraysize
= (TARGET_VTABLE_USES_DESCRIPTORS
? nvirtuals
+ 1 : nvirtuals
+ 2);
1628 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1629 arraysize
*= TARGET_VTABLE_USES_DESCRIPTORS
;
1632 VEC_safe_grow_cleared (constructor_elt
, gc
, v
, arraysize
);
1633 e
= VEC_index (constructor_elt
, v
, arraysize
- 1);
1635 #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
1636 for (i
= nvirtuals
; --i
>= 0; )
1638 tree method
= TREE_VEC_ELT (vtable
, i
);
1639 if (METHOD_ABSTRACT (method
))
1642 warning_at (DECL_SOURCE_LOCATION (method
), 0,
1643 "abstract method in non-abstract class");
1645 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1646 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1647 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1649 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1653 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1654 for (j
= 0; j
< TARGET_VTABLE_USES_DESCRIPTORS
; ++j
)
1656 tree fdesc
= build2 (FDESC_EXPR
, nativecode_ptr_type_node
,
1657 method
, build_int_cst (NULL_TREE
, j
));
1658 TREE_CONSTANT (fdesc
) = 1;
1659 CONSTRUCTOR_PREPEND_VALUE (e
, fdesc
);
1662 CONSTRUCTOR_PREPEND_VALUE (e
,
1664 nativecode_ptr_type_node
,
1669 /* Dummy entry for compatibility with G++ -fvtable-thunks. When
1670 using the Boehm GC we sometimes stash a GC type descriptor
1671 there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1672 the emitted byte count during the output to the assembly file. */
1673 /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1674 fake "function descriptor". It's first word is the is the class
1675 pointer, and subsequent words (usually one) contain the GC descriptor.
1676 In all other cases, we reserve two extra vtable slots. */
1677 gc_descr
= get_boehm_type_descriptor (type
);
1678 CONSTRUCTOR_PREPEND_VALUE (e
, gc_descr
);
1679 for (j
= 1; j
< TARGET_VTABLE_USES_DESCRIPTORS
-1; ++j
)
1680 CONSTRUCTOR_PREPEND_VALUE (e
, gc_descr
);
1681 CONSTRUCTOR_PREPEND_VALUE (e
, this_class_addr
);
1683 /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1684 CONSTRUCTOR_PREPEND_VALUE (e
, null_pointer_node
);
1685 /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
1686 gcc_assert (e
== VEC_address (constructor_elt
, v
));
1687 e
->index
= integer_zero_node
;
1688 e
->value
= null_pointer_node
;
1689 #undef CONSTRUCTOR_PREPEND_VALUE
1691 arraytype
= build_prim_array_type (nativecode_ptr_type_node
, arraysize
);
1692 return build_constructor (arraytype
, v
);
1696 /* Set the method_index for a method decl. */
1698 set_method_index (tree decl
, tree method_index
)
1700 if (method_index
!= NULL_TREE
)
1702 /* method_index is null if we're using indirect dispatch. */
1703 method_index
= fold (convert (sizetype
, method_index
));
1705 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1706 /* Add one to skip bogus descriptor for class and GC descriptor. */
1707 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (1));
1709 /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1711 method_index
= size_binop (PLUS_EXPR
, method_index
, size_int (2));
1714 DECL_VINDEX (decl
) = method_index
;
1717 /* Get the method_index for a method decl. */
1719 get_method_index (tree decl
)
1721 tree method_index
= DECL_VINDEX (decl
);
1726 if (TARGET_VTABLE_USES_DESCRIPTORS
)
1727 /* Sub one to skip bogus descriptor for class and GC descriptor. */
1728 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (1));
1730 /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1731 method_index
= size_binop (MINUS_EXPR
, method_index
, size_int (2));
1733 return method_index
;
1737 supers_all_compiled (tree type
)
1739 while (type
!= NULL_TREE
)
1741 if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)))))
1743 type
= CLASSTYPE_SUPER (type
);
1749 add_table_and_syms (VEC(constructor_elt
,gc
) **v
,
1750 VEC(method_entry
,gc
) *methods
,
1751 const char *table_name
, tree table_slot
, tree table_type
,
1752 const char *syms_name
, tree syms_slot
)
1754 if (methods
== NULL
)
1756 PUSH_FIELD_VALUE (*v
, table_name
, null_pointer_node
);
1757 PUSH_FIELD_VALUE (*v
, syms_name
, null_pointer_node
);
1761 pushdecl_top_level (syms_slot
);
1762 PUSH_FIELD_VALUE (*v
, table_name
,
1763 build1 (ADDR_EXPR
, table_type
, table_slot
));
1764 PUSH_FIELD_VALUE (*v
, syms_name
,
1765 build1 (ADDR_EXPR
, symbols_array_ptr_type
,
1767 TREE_CONSTANT (table_slot
) = 1;
1772 make_class_data (tree type
)
1774 tree decl
, cons
, temp
;
1775 tree field
, fields_decl
;
1776 HOST_WIDE_INT static_field_count
= 0;
1777 HOST_WIDE_INT instance_field_count
= 0;
1778 HOST_WIDE_INT field_count
;
1779 tree field_array_type
;
1781 tree dtable_decl
= NULL_TREE
;
1782 HOST_WIDE_INT method_count
= 0;
1783 tree method_array_type
;
1786 tree this_class_addr
;
1787 tree constant_pool_constructor
;
1788 tree interfaces
= null_pointer_node
;
1789 int interface_len
= 0;
1790 int uses_jv_markobj
= 0;
1791 tree type_decl
= TYPE_NAME (type
);
1792 tree id_main
= get_identifier("main");
1793 tree id_class
= get_identifier("java.lang.Class");
1794 /** Offset from start of virtual function table declaration
1795 to where objects actually point at, following new g++ ABI. */
1796 tree dtable_start_offset
= size_int (2 * POINTER_SIZE
/ BITS_PER_UNIT
);
1797 VEC(int, heap
) *field_indexes
;
1798 tree first_real_field
;
1799 VEC(constructor_elt
,gc
) *v1
= NULL
, *v2
= NULL
;
1800 tree reflection_data
;
1801 VEC(constructor_elt
,gc
) *static_fields
= NULL
;
1802 VEC(constructor_elt
,gc
) *instance_fields
= NULL
;
1803 VEC(constructor_elt
,gc
) *methods
= NULL
;
1805 this_class_addr
= build_static_class_ref (type
);
1806 decl
= TREE_OPERAND (this_class_addr
, 0);
1808 if (supers_all_compiled (type
) && ! CLASS_INTERFACE (type_decl
)
1809 && !flag_indirect_dispatch
)
1811 tree dtable
= get_dispatch_table (type
, this_class_addr
);
1812 uses_jv_markobj
= uses_jv_markobj_p (dtable
);
1813 if (type
== class_type_node
&& class_dtable_decl
!= NULL_TREE
)
1815 /* We've already created some other class, and consequently
1816 we made class_dtable_decl. Now we just want to fill it
1818 dtable_decl
= class_dtable_decl
;
1822 dtable_decl
= build_dtable_decl (type
);
1823 TREE_STATIC (dtable_decl
) = 1;
1824 DECL_ARTIFICIAL (dtable_decl
) = 1;
1825 DECL_IGNORED_P (dtable_decl
) = 1;
1828 TREE_PUBLIC (dtable_decl
) = 1;
1829 DECL_INITIAL (dtable_decl
) = dtable
;
1830 /* The only dispatch table exported from a DSO is the dispatch
1831 table for java.lang.Class. */
1832 if (DECL_NAME (type_decl
) != id_class
)
1833 java_hide_decl (dtable_decl
);
1834 if (! flag_indirect_classes
)
1835 rest_of_decl_compilation (dtable_decl
, 1, 0);
1836 /* Maybe we're compiling Class as the first class. If so, set
1837 class_dtable_decl to the decl we just made. */
1838 if (type
== class_type_node
&& class_dtable_decl
== NULL_TREE
)
1839 class_dtable_decl
= dtable_decl
;
1842 /* Build Field array. */
1843 field
= TYPE_FIELDS (type
);
1844 while (field
&& DECL_ARTIFICIAL (field
))
1845 field
= DECL_CHAIN (field
); /* Skip dummy fields. */
1846 if (field
&& DECL_NAME (field
) == NULL_TREE
)
1847 field
= DECL_CHAIN (field
); /* Skip dummy field for inherited data. */
1848 first_real_field
= field
;
1850 /* First count static and instance fields. */
1851 for ( ; field
!= NULL_TREE
; field
= DECL_CHAIN (field
))
1853 if (! DECL_ARTIFICIAL (field
))
1855 if (FIELD_STATIC (field
))
1856 static_field_count
++;
1857 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1858 instance_field_count
++;
1861 field_count
= static_field_count
+ instance_field_count
;
1862 field_indexes
= VEC_alloc (int, heap
, field_count
);
1864 /* gcj sorts fields so that static fields come first, followed by
1865 instance fields. Unfortunately, by the time this takes place we
1866 have already generated the reflection_data for this class, and
1867 that data contains indexes into the fields. So, we generate a
1868 permutation that maps each original field index to its final
1869 position. Then we pass this permutation to
1870 rewrite_reflection_indexes(), which fixes up the reflection
1874 int static_count
= 0;
1875 int instance_count
= static_field_count
;
1878 for (i
= 0, field
= first_real_field
;
1880 field
= DECL_CHAIN (field
), i
++)
1882 if (! DECL_ARTIFICIAL (field
))
1885 if (FIELD_STATIC (field
))
1886 field_index
= static_count
++;
1887 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1888 field_index
= instance_count
++;
1891 VEC_quick_push (int, field_indexes
, field_index
);
1896 for (field
= first_real_field
; field
!= NULL_TREE
;
1897 field
= DECL_CHAIN (field
))
1899 if (! DECL_ARTIFICIAL (field
))
1901 if (FIELD_STATIC (field
))
1903 /* We must always create reflection data for static fields
1904 as it is used in the creation of the field itself. */
1905 tree init
= make_field_value (field
);
1906 tree initial
= DECL_INITIAL (field
);
1907 CONSTRUCTOR_APPEND_ELT (static_fields
, NULL_TREE
, init
);
1908 /* If the initial value is a string constant,
1909 prevent output_constant from trying to assemble the value. */
1910 if (initial
!= NULL_TREE
1911 && TREE_TYPE (initial
) == string_ptr_type_node
)
1912 DECL_INITIAL (field
) = NULL_TREE
;
1913 rest_of_decl_compilation (field
, 1, 1);
1914 DECL_INITIAL (field
) = initial
;
1916 else if (uses_jv_markobj
|| !flag_reduced_reflection
)
1918 tree init
= make_field_value (field
);
1919 CONSTRUCTOR_APPEND_ELT (instance_fields
, NULL_TREE
, init
);
1924 gcc_assert (static_field_count
1925 == (int) VEC_length (constructor_elt
, static_fields
));
1926 gcc_assert (instance_field_count
1927 == (int) VEC_length (constructor_elt
, instance_fields
));
1929 if (field_count
> 0)
1931 VEC_safe_splice (constructor_elt
, gc
, static_fields
, instance_fields
);
1932 field_array_type
= build_prim_array_type (field_type_node
, field_count
);
1933 fields_decl
= build_decl (input_location
,
1934 VAR_DECL
, mangled_classname ("_FL_", type
),
1936 DECL_INITIAL (fields_decl
)
1937 = build_constructor (field_array_type
, static_fields
);
1938 TREE_STATIC (fields_decl
) = 1;
1939 DECL_ARTIFICIAL (fields_decl
) = 1;
1940 DECL_IGNORED_P (fields_decl
) = 1;
1941 rest_of_decl_compilation (fields_decl
, 1, 0);
1944 fields_decl
= NULL_TREE
;
1946 /* Build Method array. */
1947 for (method
= TYPE_METHODS (type
);
1948 method
!= NULL_TREE
; method
= DECL_CHAIN (method
))
1951 if (METHOD_PRIVATE (method
)
1952 && ! flag_keep_inline_functions
1955 /* Even if we have a decl, we don't necessarily have the code.
1956 This can happen if we inherit a method from a superclass for
1957 which we don't have a .class file. */
1958 if (METHOD_DUMMY (method
))
1961 /* Generate method reflection data if:
1963 - !flag_reduced_reflection.
1965 - <clinit> -- The runtime uses reflection to initialize the
1968 - Any method in class java.lang.Class -- Class.forName() and
1969 perhaps other things require it.
1971 - class$ -- It does not work if reflection data missing.
1973 - main -- Reflection is used to find main(String[]) methods.
1975 - public not static -- It is potentially part of an
1976 interface. The runtime uses reflection data to build
1977 interface dispatch tables. */
1978 if (!flag_reduced_reflection
1979 || DECL_CLINIT_P (method
)
1980 || DECL_NAME (type_decl
) == id_class
1981 || DECL_NAME (method
) == id_main
1982 || (METHOD_PUBLIC (method
) && !METHOD_STATIC (method
)))
1984 init
= make_method_value (method
);
1986 CONSTRUCTOR_APPEND_ELT (methods
, NULL_TREE
, init
);
1989 method_array_type
= build_prim_array_type (method_type_node
, method_count
);
1990 methods_decl
= build_decl (input_location
,
1991 VAR_DECL
, mangled_classname ("_MT_", type
),
1993 DECL_INITIAL (methods_decl
) = build_constructor (method_array_type
, methods
);
1994 TREE_STATIC (methods_decl
) = 1;
1995 DECL_ARTIFICIAL (methods_decl
) = 1;
1996 DECL_IGNORED_P (methods_decl
) = 1;
1997 rest_of_decl_compilation (methods_decl
, 1, 0);
1999 if (class_dtable_decl
== NULL_TREE
)
2001 class_dtable_decl
= build_dtable_decl (class_type_node
);
2002 TREE_STATIC (class_dtable_decl
) = 1;
2003 DECL_ARTIFICIAL (class_dtable_decl
) = 1;
2004 DECL_IGNORED_P (class_dtable_decl
) = 1;
2005 if (is_compiled_class (class_type_node
) != 2)
2007 DECL_EXTERNAL (class_dtable_decl
) = 1;
2008 rest_of_decl_compilation (class_dtable_decl
, 1, 0);
2012 super
= CLASSTYPE_SUPER (type
);
2013 if (super
== NULL_TREE
)
2014 super
= null_pointer_node
;
2015 else if (! flag_indirect_dispatch
2016 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl
)))
2017 && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super
)))))
2018 super
= build_class_ref (super
);
2021 int super_index
= alloc_class_constant (super
);
2022 super
= build_int_cst (ptr_type_node
, super_index
);
2025 /* Build and emit the array of implemented interfaces. */
2026 if (type
!= object_type_node
)
2027 interface_len
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)) - 1;
2029 if (interface_len
> 0)
2032 tree interface_array_type
, idecl
;
2033 VEC(constructor_elt
,gc
) *init
= VEC_alloc (constructor_elt
, gc
,
2035 interface_array_type
2036 = build_prim_array_type (class_ptr_type
, interface_len
);
2037 idecl
= build_decl (input_location
,
2038 VAR_DECL
, mangled_classname ("_IF_", type
),
2039 interface_array_type
);
2041 for (i
= 1; i
<= interface_len
; i
++)
2043 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
2044 tree iclass
= BINFO_TYPE (child
);
2046 if (! flag_indirect_dispatch
2048 (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass
))))))
2049 index
= build_class_ref (iclass
);
2052 int int_index
= alloc_class_constant (iclass
);
2053 index
= build_int_cst (ptr_type_node
, int_index
);
2055 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, index
);
2057 DECL_INITIAL (idecl
) = build_constructor (interface_array_type
, init
);
2058 TREE_STATIC (idecl
) = 1;
2059 DECL_ARTIFICIAL (idecl
) = 1;
2060 DECL_IGNORED_P (idecl
) = 1;
2061 interfaces
= build1 (ADDR_EXPR
, ptr_type_node
, idecl
);
2062 rest_of_decl_compilation (idecl
, 1, 0);
2065 constant_pool_constructor
= build_constants_constructor ();
2067 if (flag_indirect_dispatch
)
2069 TYPE_OTABLE_DECL (type
)
2071 (DECL_NAME (TYPE_OTABLE_DECL (type
)),
2072 TYPE_OTABLE_DECL (type
), TYPE_OTABLE_METHODS (type
),
2073 TYPE_OTABLE_SYMS_DECL (type
), integer_type_node
, 1);
2075 TYPE_ATABLE_DECL (type
)
2077 (DECL_NAME (TYPE_ATABLE_DECL (type
)),
2078 TYPE_ATABLE_DECL (type
), TYPE_ATABLE_METHODS (type
),
2079 TYPE_ATABLE_SYMS_DECL (type
), ptr_type_node
, 1);
2081 TYPE_ITABLE_DECL (type
)
2083 (DECL_NAME (TYPE_ITABLE_DECL (type
)),
2084 TYPE_ITABLE_DECL (type
), TYPE_ITABLE_METHODS (type
),
2085 TYPE_ITABLE_SYMS_DECL (type
), ptr_type_node
, 2);
2088 TYPE_CTABLE_DECL (type
) = emit_catch_table (type
);
2090 START_RECORD_CONSTRUCTOR (v1
, object_type_node
);
2091 PUSH_FIELD_VALUE (v1
, "vtable",
2092 (flag_indirect_classes
2094 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2095 build1 (ADDR_EXPR
, dtable_ptr_type
,
2097 dtable_start_offset
)));
2098 if (! flag_hash_synchronization
)
2099 PUSH_FIELD_VALUE (v1
, "sync_info", null_pointer_node
);
2100 FINISH_RECORD_CONSTRUCTOR (temp
, v1
, object_type_node
);
2101 START_RECORD_CONSTRUCTOR (v2
, class_type_node
);
2102 PUSH_SUPER_VALUE (v2
, temp
);
2103 PUSH_FIELD_VALUE (v2
, "next_or_version", gcj_abi_version
);
2104 PUSH_FIELD_VALUE (v2
, "name", build_utf8_ref (DECL_NAME (type_decl
)));
2105 PUSH_FIELD_VALUE (v2
, "accflags",
2106 build_int_cst (NULL_TREE
,
2107 get_access_flags_from_decl (type_decl
)));
2109 PUSH_FIELD_VALUE (v2
, "superclass",
2110 CLASS_INTERFACE (type_decl
) ? null_pointer_node
: super
);
2111 PUSH_FIELD_VALUE (v2
, "constants", constant_pool_constructor
);
2112 PUSH_FIELD_VALUE (v2
, "methods",
2113 methods_decl
== NULL_TREE
? null_pointer_node
2114 : build1 (ADDR_EXPR
, method_ptr_type_node
, methods_decl
));
2115 PUSH_FIELD_VALUE (v2
, "method_count",
2116 build_int_cst (NULL_TREE
, method_count
));
2118 PUSH_FIELD_VALUE (v2
, "vtable_method_count",
2119 (flag_indirect_dispatch
2120 ? integer_minus_one_node
2121 : TYPE_NVIRTUALS (type
)));
2123 PUSH_FIELD_VALUE (v2
, "fields",
2124 fields_decl
== NULL_TREE
? null_pointer_node
2125 : build1 (ADDR_EXPR
, field_ptr_type_node
, fields_decl
));
2126 /* If we're using the binary compatibility ABI we don't know the
2127 size until load time. */
2128 PUSH_FIELD_VALUE (v2
, "size_in_bytes",
2129 (flag_indirect_dispatch
2130 ? integer_minus_one_node
2131 : size_in_bytes (type
)));
2132 PUSH_FIELD_VALUE (v2
, "field_count",
2133 build_int_cst (NULL_TREE
, field_count
));
2134 PUSH_FIELD_VALUE (v2
, "static_field_count",
2135 build_int_cst (NULL_TREE
, static_field_count
));
2137 PUSH_FIELD_VALUE (v2
, "vtable",
2138 (flag_indirect_dispatch
|| dtable_decl
== NULL_TREE
2140 : build2 (POINTER_PLUS_EXPR
, dtable_ptr_type
,
2141 build1 (ADDR_EXPR
, dtable_ptr_type
,
2143 dtable_start_offset
)));
2144 add_table_and_syms (&v2
, TYPE_OTABLE_METHODS (type
),
2145 "otable", TYPE_OTABLE_DECL (type
), otable_ptr_type
,
2146 "otable_syms", TYPE_OTABLE_SYMS_DECL (type
));
2147 add_table_and_syms (&v2
, TYPE_ATABLE_METHODS (type
),
2148 "atable", TYPE_ATABLE_DECL (type
), atable_ptr_type
,
2149 "atable_syms", TYPE_ATABLE_SYMS_DECL (type
));
2150 add_table_and_syms (&v2
, TYPE_ITABLE_METHODS (type
),
2151 "itable", TYPE_ITABLE_DECL (type
), itable_ptr_type
,
2152 "itable_syms", TYPE_ITABLE_SYMS_DECL (type
));
2154 PUSH_FIELD_VALUE (v2
, "catch_classes",
2155 build1 (ADDR_EXPR
, ptr_type_node
, TYPE_CTABLE_DECL (type
)));
2156 PUSH_FIELD_VALUE (v2
, "interfaces", interfaces
);
2157 PUSH_FIELD_VALUE (v2
, "loader", null_pointer_node
);
2158 PUSH_FIELD_VALUE (v2
, "interface_count",
2159 build_int_cst (NULL_TREE
, interface_len
));
2160 PUSH_FIELD_VALUE (v2
, "state",
2161 convert (byte_type_node
,
2162 build_int_cst (NULL_TREE
, JV_STATE_PRELOADING
)));
2164 PUSH_FIELD_VALUE (v2
, "thread", null_pointer_node
);
2165 PUSH_FIELD_VALUE (v2
, "depth", integer_zero_node
);
2166 PUSH_FIELD_VALUE (v2
, "ancestors", null_pointer_node
);
2167 PUSH_FIELD_VALUE (v2
, "idt", null_pointer_node
);
2168 PUSH_FIELD_VALUE (v2
, "arrayclass", null_pointer_node
);
2169 PUSH_FIELD_VALUE (v2
, "protectionDomain", null_pointer_node
);
2172 tree assertion_table_ref
;
2173 if (TYPE_ASSERTIONS (type
) == NULL
)
2174 assertion_table_ref
= null_pointer_node
;
2176 assertion_table_ref
= build1 (ADDR_EXPR
,
2177 build_pointer_type (assertion_table_type
),
2178 emit_assertion_table (type
));
2180 PUSH_FIELD_VALUE (v2
, "assertion_table", assertion_table_ref
);
2183 PUSH_FIELD_VALUE (v2
, "hack_signers", null_pointer_node
);
2184 PUSH_FIELD_VALUE (v2
, "chain", null_pointer_node
);
2185 PUSH_FIELD_VALUE (v2
, "aux_info", null_pointer_node
);
2186 PUSH_FIELD_VALUE (v2
, "engine", null_pointer_node
);
2188 if (TYPE_REFLECTION_DATA (current_class
))
2191 int count
= TYPE_REFLECTION_DATASIZE (current_class
);
2192 VEC (constructor_elt
, gc
) *v
2193 = VEC_alloc (constructor_elt
, gc
, count
);
2194 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
2195 tree max_index
= build_int_cst (sizetype
, count
);
2196 tree index
= build_index_type (max_index
);
2197 tree type
= build_array_type (unsigned_byte_type_node
, index
);
2200 static int reflection_data_count
;
2202 sprintf (buf
, "_reflection_data_%d", reflection_data_count
++);
2203 array
= build_decl (input_location
,
2204 VAR_DECL
, get_identifier (buf
), type
);
2206 rewrite_reflection_indexes (field_indexes
);
2208 for (i
= 0; i
< count
; i
++)
2210 constructor_elt
*elt
= VEC_quick_push (constructor_elt
, v
, NULL
);
2211 elt
->index
= build_int_cst (sizetype
, i
);
2212 elt
->value
= build_int_cstu (byte_type_node
, data
[i
]);
2215 DECL_INITIAL (array
) = build_constructor (type
, v
);
2216 TREE_STATIC (array
) = 1;
2217 DECL_ARTIFICIAL (array
) = 1;
2218 DECL_IGNORED_P (array
) = 1;
2219 TREE_READONLY (array
) = 1;
2220 TREE_CONSTANT (DECL_INITIAL (array
)) = 1;
2221 rest_of_decl_compilation (array
, 1, 0);
2223 reflection_data
= build_address_of (array
);
2226 TYPE_REFLECTION_DATA (current_class
) = NULL
;
2229 reflection_data
= null_pointer_node
;
2231 PUSH_FIELD_VALUE (v2
, "reflection_data", reflection_data
);
2232 FINISH_RECORD_CONSTRUCTOR (cons
, v2
, class_type_node
);
2234 DECL_INITIAL (decl
) = cons
;
2236 /* Hash synchronization requires at least 64-bit alignment. */
2237 if (flag_hash_synchronization
&& POINTER_SIZE
< 64)
2238 DECL_ALIGN (decl
) = 64;
2240 if (flag_indirect_classes
)
2242 TREE_READONLY (decl
) = 1;
2243 TREE_CONSTANT (DECL_INITIAL (decl
)) = 1;
2246 rest_of_decl_compilation (decl
, 1, 0);
2249 tree classdollar_field
= build_classdollar_field (type
);
2250 if (!flag_indirect_classes
)
2251 DECL_INITIAL (classdollar_field
) = build_static_class_ref (type
);
2252 rest_of_decl_compilation (classdollar_field
, 1, 0);
2255 TYPE_OTABLE_DECL (type
) = NULL_TREE
;
2256 TYPE_ATABLE_DECL (type
) = NULL_TREE
;
2257 TYPE_CTABLE_DECL (type
) = NULL_TREE
;
2263 java_expand_catch_classes (current_class
);
2265 current_function_decl
= NULL_TREE
;
2266 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class
)) = 0;
2267 make_class_data (current_class
);
2269 rest_of_decl_compilation (TYPE_NAME (current_class
), 1, 0);
2272 /* Return 2 if KLASS is compiled by this compilation job;
2273 return 1 if KLASS can otherwise be assumed to be compiled;
2274 return 0 if we cannot assume that KLASS is compiled.
2275 Returns 1 for primitive and 0 for array types. */
2277 is_compiled_class (tree klass
)
2280 if (TREE_CODE (klass
) == POINTER_TYPE
)
2281 klass
= TREE_TYPE (klass
);
2282 if (TREE_CODE (klass
) != RECORD_TYPE
) /* Primitive types are static. */
2284 if (TYPE_ARRAY_P (klass
))
2287 seen_in_zip
= (TYPE_JCF (klass
) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass
)));
2288 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2290 /* The class was seen in the current ZIP file and will be
2291 available as a compiled class in the future but may not have
2292 been loaded already. Load it if necessary. This prevent
2293 build_class_ref () from crashing. */
2295 if (seen_in_zip
&& !CLASS_LOADED_P (klass
) && (klass
!= current_class
))
2296 load_class (klass
, 1);
2298 /* We return 2 for class seen in ZIP and class from files
2299 belonging to the same compilation unit */
2303 if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass
)))))
2305 if (!CLASS_LOADED_P (klass
))
2307 if (klass
!= current_class
)
2308 load_class (klass
, 1);
2316 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2319 build_dtable_decl (tree type
)
2323 /* We need to build a new dtable type so that its size is uniquely
2324 computed when we're dealing with the class for real and not just
2325 faking it (like java.lang.Class during the initialization of the
2326 compiler.) We know we're not faking a class when CURRENT_CLASS is
2328 if (current_class
== type
)
2330 tree dummy
= NULL_TREE
;
2333 dtype
= make_node (RECORD_TYPE
);
2335 PUSH_FIELD (input_location
, dtype
, dummy
, "top_offset", ptr_type_node
);
2336 PUSH_FIELD (input_location
, dtype
, dummy
, "type_info", ptr_type_node
);
2338 PUSH_FIELD (input_location
, dtype
, dummy
, "class", class_ptr_type
);
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 PUSH_FIELD (input_location
, dtype
, dummy
, "gc_descr", ptr_type_node
);
2350 for (n
= 1; n
< TARGET_VTABLE_USES_DESCRIPTORS
; ++n
)
2352 tree tmp_field
= build_decl (input_location
,
2353 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
2354 TREE_CHAIN (dummy
) = tmp_field
;
2355 DECL_CONTEXT (tmp_field
) = dtype
;
2356 DECL_ARTIFICIAL (tmp_field
) = 1;
2360 n
= TREE_VEC_LENGTH (get_dispatch_vector (type
));
2361 if (TARGET_VTABLE_USES_DESCRIPTORS
)
2362 n
*= TARGET_VTABLE_USES_DESCRIPTORS
;
2364 PUSH_FIELD (input_location
, dtype
, dummy
, "methods",
2365 build_prim_array_type (nativecode_ptr_type_node
, n
));
2366 layout_type (dtype
);
2369 dtype
= dtable_type
;
2371 decl
= build_decl (input_location
,
2372 VAR_DECL
, get_identifier ("vt$"), dtype
);
2373 DECL_CONTEXT (decl
) = type
;
2374 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl
);
2375 DECL_VTABLE_P (decl
) = 1;
2380 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2381 fields inherited from SUPER_CLASS. */
2384 push_super_field (tree this_class
, tree super_class
)
2387 /* Don't insert the field if we're just re-laying the class out. */
2388 if (TYPE_FIELDS (this_class
) && !DECL_NAME (TYPE_FIELDS (this_class
)))
2390 base_decl
= build_decl (input_location
,
2391 FIELD_DECL
, NULL_TREE
, super_class
);
2392 DECL_IGNORED_P (base_decl
) = 1;
2393 DECL_CHAIN (base_decl
) = TYPE_FIELDS (this_class
);
2394 TYPE_FIELDS (this_class
) = base_decl
;
2395 DECL_SIZE (base_decl
) = TYPE_SIZE (super_class
);
2396 DECL_SIZE_UNIT (base_decl
) = TYPE_SIZE_UNIT (super_class
);
2399 /* Handle the different manners we may have to lay out a super class. */
2402 maybe_layout_super_class (tree super_class
, tree this_class ATTRIBUTE_UNUSED
)
2406 else if (TREE_CODE (super_class
) == RECORD_TYPE
)
2408 if (!CLASS_LOADED_P (super_class
))
2409 load_class (super_class
, 1);
2411 /* We might have to layout the class before its dependency on
2412 the super class gets resolved by java_complete_class */
2413 else if (TREE_CODE (super_class
) == POINTER_TYPE
)
2415 if (TREE_TYPE (super_class
) != NULL_TREE
)
2416 super_class
= TREE_TYPE (super_class
);
2420 if (!TYPE_SIZE (super_class
))
2421 safe_layout_class (super_class
);
2426 /* safe_layout_class just makes sure that we can load a class without
2427 disrupting the current_class, input_file, input_line, etc, information
2428 about the class processed currently. */
2431 safe_layout_class (tree klass
)
2433 tree save_current_class
= current_class
;
2434 location_t save_location
= input_location
;
2436 layout_class (klass
);
2438 current_class
= save_current_class
;
2439 input_location
= save_location
;
2443 layout_class (tree this_class
)
2446 tree super_class
= CLASSTYPE_SUPER (this_class
);
2448 class_list
= tree_cons (this_class
, NULL_TREE
, class_list
);
2449 if (CLASS_BEING_LAIDOUT (this_class
))
2455 sprintf (buffer
, " with '%s'",
2456 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
))));
2457 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2459 for (current
= TREE_CHAIN (class_list
); current
;
2460 current
= TREE_CHAIN (current
))
2462 tree decl
= TYPE_NAME (TREE_PURPOSE (current
));
2463 sprintf (buffer
, "\n which inherits from '%s' (%s:%d)",
2464 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2465 DECL_SOURCE_FILE (decl
),
2466 DECL_SOURCE_LINE (decl
));
2467 obstack_grow (&temporary_obstack
, buffer
, strlen (buffer
));
2469 obstack_1grow (&temporary_obstack
, '\0');
2470 report
= XOBFINISH (&temporary_obstack
, char *);
2471 cyclic_inheritance_report
= ggc_strdup (report
);
2472 obstack_free (&temporary_obstack
, report
);
2473 TYPE_SIZE (this_class
) = error_mark_node
;
2476 CLASS_BEING_LAIDOUT (this_class
) = 1;
2478 if (super_class
&& !CLASS_BEING_LAIDOUT (super_class
))
2480 tree maybe_super_class
2481 = maybe_layout_super_class (super_class
, this_class
);
2482 if (maybe_super_class
== NULL
2483 || TREE_CODE (TYPE_SIZE (maybe_super_class
)) == ERROR_MARK
)
2485 TYPE_SIZE (this_class
) = error_mark_node
;
2486 CLASS_BEING_LAIDOUT (this_class
) = 0;
2487 class_list
= TREE_CHAIN (class_list
);
2490 if (TYPE_SIZE (this_class
) == NULL_TREE
)
2491 push_super_field (this_class
, maybe_super_class
);
2494 layout_type (this_class
);
2496 /* Also recursively load/layout any superinterfaces. */
2497 if (TYPE_BINFO (this_class
))
2499 for (i
= BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class
)) - 1; i
> 0; i
--)
2501 tree binfo
= BINFO_BASE_BINFO (TYPE_BINFO (this_class
), i
);
2502 tree super_interface
= BINFO_TYPE (binfo
);
2503 tree maybe_super_interface
2504 = maybe_layout_super_class (super_interface
, NULL_TREE
);
2505 if (maybe_super_interface
== NULL
2506 || TREE_CODE (TYPE_SIZE (maybe_super_interface
)) == ERROR_MARK
)
2508 TYPE_SIZE (this_class
) = error_mark_node
;
2509 CLASS_BEING_LAIDOUT (this_class
) = 0;
2510 class_list
= TREE_CHAIN (class_list
);
2516 /* Convert the size back to an SI integer value. */
2517 TYPE_SIZE_UNIT (this_class
) =
2518 fold (convert (int_type_node
, TYPE_SIZE_UNIT (this_class
)));
2520 CLASS_BEING_LAIDOUT (this_class
) = 0;
2521 class_list
= TREE_CHAIN (class_list
);
2525 add_miranda_methods (tree base_class
, tree search_class
)
2528 tree binfo
, base_binfo
;
2530 if (!CLASS_PARSED_P (search_class
))
2531 load_class (search_class
, 1);
2533 for (binfo
= TYPE_BINFO (search_class
), i
= 1;
2534 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2537 tree elt
= BINFO_TYPE (base_binfo
);
2539 /* FIXME: This is totally bogus. We should not be handling
2540 Miranda methods at all if we're using the BC ABI. */
2541 if (TYPE_DUMMY (elt
))
2544 /* Ensure that interface methods are seen in declared order. */
2545 if (!CLASS_LOADED_P (elt
))
2546 load_class (elt
, 1);
2547 layout_class_methods (elt
);
2549 /* All base classes will have been laid out at this point, so the order
2550 will be correct. This code must match similar layout code in the
2552 for (method_decl
= TYPE_METHODS (elt
);
2553 method_decl
; method_decl
= DECL_CHAIN (method_decl
))
2557 /* An interface can have <clinit>. */
2558 if (ID_CLINIT_P (DECL_NAME (method_decl
)))
2561 sig
= build_java_argument_signature (TREE_TYPE (method_decl
));
2562 override
= lookup_argument_method (base_class
,
2563 DECL_NAME (method_decl
), sig
);
2564 if (override
== NULL_TREE
)
2566 /* Found a Miranda method. Add it. */
2568 sig
= build_java_signature (TREE_TYPE (method_decl
));
2570 = add_method (base_class
,
2571 get_access_flags_from_decl (method_decl
),
2572 DECL_NAME (method_decl
), sig
);
2573 METHOD_INVISIBLE (new_method
) = 1;
2577 /* Try superinterfaces. */
2578 add_miranda_methods (base_class
, elt
);
2583 layout_class_methods (tree this_class
)
2585 tree method_decl
, dtable_count
;
2586 tree super_class
, type_name
;
2588 if (TYPE_NVIRTUALS (this_class
))
2591 super_class
= CLASSTYPE_SUPER (this_class
);
2595 super_class
= maybe_layout_super_class (super_class
, this_class
);
2596 if (!TYPE_NVIRTUALS (super_class
))
2597 layout_class_methods (super_class
);
2598 dtable_count
= TYPE_NVIRTUALS (super_class
);
2601 dtable_count
= integer_zero_node
;
2603 type_name
= TYPE_NAME (this_class
);
2604 if (!flag_indirect_dispatch
2605 && (CLASS_ABSTRACT (type_name
) || CLASS_INTERFACE (type_name
)))
2607 /* An abstract class can have methods which are declared only in
2608 an implemented interface. These are called "Miranda
2609 methods". We make a dummy method entry for such methods
2611 add_miranda_methods (this_class
, this_class
);
2614 TYPE_METHODS (this_class
) = nreverse (TYPE_METHODS (this_class
));
2616 for (method_decl
= TYPE_METHODS (this_class
);
2617 method_decl
; method_decl
= DECL_CHAIN (method_decl
))
2618 dtable_count
= layout_class_method (this_class
, super_class
,
2619 method_decl
, dtable_count
);
2621 TYPE_NVIRTUALS (this_class
) = dtable_count
;
2624 /* Return the index of METHOD in INTERFACE. This index begins at 1
2625 and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2627 get_interface_method_index (tree method
, tree interface
)
2632 for (meth
= TYPE_METHODS (interface
); ; meth
= DECL_CHAIN (meth
))
2636 /* We don't want to put <clinit> into the interface table. */
2637 if (! ID_CLINIT_P (DECL_NAME (meth
)))
2639 gcc_assert (meth
!= NULL_TREE
);
2643 /* Lay METHOD_DECL out, returning a possibly new value of
2644 DTABLE_COUNT. Also mangle the method's name. */
2647 layout_class_method (tree this_class
, tree super_class
,
2648 tree method_decl
, tree dtable_count
)
2650 tree method_name
= DECL_NAME (method_decl
);
2652 TREE_PUBLIC (method_decl
) = 1;
2654 if (flag_indirect_classes
2655 || (METHOD_PRIVATE (method_decl
) && METHOD_STATIC (method_decl
)
2656 && ! METHOD_NATIVE (method_decl
)
2657 && ! special_method_p (method_decl
)))
2658 java_hide_decl (method_decl
);
2660 /* Considered external unless it is being compiled into this object
2661 file, or it was already flagged as external. */
2662 if (!DECL_EXTERNAL (method_decl
))
2663 DECL_EXTERNAL (method_decl
) = ((is_compiled_class (this_class
) != 2)
2664 || METHOD_NATIVE (method_decl
));
2666 if (ID_INIT_P (method_name
))
2668 const char *p
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class
)));
2670 for (ptr
= p
; *ptr
; )
2675 DECL_CONSTRUCTOR_P (method_decl
) = 1;
2676 build_java_signature (TREE_TYPE (method_decl
));
2678 else if (! METHOD_STATIC (method_decl
))
2681 build_java_signature (TREE_TYPE (method_decl
));
2682 bool method_override
= false;
2683 tree super_method
= lookup_java_method (super_class
, method_name
,
2685 if (super_method
!= NULL_TREE
2686 && ! METHOD_DUMMY (super_method
))
2688 method_override
= true;
2689 if (! METHOD_PUBLIC (super_method
) &&
2690 ! METHOD_PROTECTED (super_method
))
2692 /* Don't override private method, or default-access method in
2694 if (METHOD_PRIVATE (super_method
) ||
2695 ! in_same_package (TYPE_NAME (this_class
),
2696 TYPE_NAME (super_class
)))
2697 method_override
= false;
2700 if (method_override
)
2702 tree method_index
= get_method_index (super_method
);
2703 set_method_index (method_decl
, method_index
);
2704 if (method_index
== NULL_TREE
2705 && ! flag_indirect_dispatch
2706 && ! DECL_ARTIFICIAL (super_method
))
2707 error ("non-static method %q+D overrides static method",
2710 else if (this_class
== object_type_node
2711 && (METHOD_FINAL (method_decl
)
2712 || METHOD_PRIVATE (method_decl
)))
2714 /* We don't generate vtable entries for final Object
2715 methods. This is simply to save space, since every
2716 object would otherwise have to define them. */
2718 else if (! METHOD_PRIVATE (method_decl
)
2721 /* We generate vtable entries for final methods because they
2722 may one day be changed to non-final. */
2723 set_method_index (method_decl
, dtable_count
);
2724 dtable_count
= fold_build2 (PLUS_EXPR
, integer_type_node
,
2725 dtable_count
, integer_one_node
);
2729 return dtable_count
;
2733 register_class (void)
2737 if (!registered_class
)
2738 registered_class
= VEC_alloc (tree
, gc
, 8);
2740 if (flag_indirect_classes
)
2741 node
= current_class
;
2743 node
= TREE_OPERAND (build_class_ref (current_class
), 0);
2744 VEC_safe_push (tree
, gc
, registered_class
, node
);
2747 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2748 all the classes we have emitted. */
2751 emit_indirect_register_classes (tree
*list_p
)
2753 tree klass
, t
, register_class_fn
;
2756 int size
= VEC_length (tree
, registered_class
) * 2 + 1;
2757 VEC(constructor_elt
,gc
) *init
= VEC_alloc (constructor_elt
, gc
, size
);
2758 tree class_array_type
2759 = build_prim_array_type (ptr_type_node
, size
);
2760 tree
cdecl = build_decl (input_location
,
2761 VAR_DECL
, get_identifier ("_Jv_CLS"),
2763 tree reg_class_list
;
2764 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2766 t
= fold_convert (ptr_type_node
, build_static_class_ref (klass
));
2767 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, t
);
2768 t
= fold_convert (ptr_type_node
,
2769 build_address_of (build_classdollar_field (klass
)));
2770 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, t
);
2772 CONSTRUCTOR_APPEND_ELT (init
, NULL_TREE
, integer_zero_node
);
2773 DECL_INITIAL (cdecl) = build_constructor (class_array_type
, init
);
2774 TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2775 TREE_STATIC (cdecl) = 1;
2776 DECL_ARTIFICIAL (cdecl) = 1;
2777 DECL_IGNORED_P (cdecl) = 1;
2778 TREE_READONLY (cdecl) = 1;
2779 TREE_CONSTANT (cdecl) = 1;
2780 rest_of_decl_compilation (cdecl, 1, 0);
2781 reg_class_list
= fold_convert (ptr_type_node
, build_address_of (cdecl));
2783 t
= build_function_type_list (void_type_node
,
2784 build_pointer_type (ptr_type_node
), NULL
);
2785 t
= build_decl (input_location
,
2787 get_identifier ("_Jv_RegisterNewClasses"), t
);
2788 TREE_PUBLIC (t
) = 1;
2789 DECL_EXTERNAL (t
) = 1;
2790 register_class_fn
= t
;
2791 t
= build_call_expr (register_class_fn
, 1, reg_class_list
);
2792 append_to_statement_list (t
, list_p
);
2796 /* Emit something to register classes at start-up time.
2798 The preferred mechanism is through the .jcr section, which contain
2799 a list of pointers to classes which get registered during constructor
2802 The fallback mechanism is to add statements to *LIST_P to call
2803 _Jv_RegisterClass for each class in this file. These statements will
2804 be added to a static constructor function for this translation unit. */
2807 emit_register_classes (tree
*list_p
)
2809 if (registered_class
== NULL
)
2812 if (flag_indirect_classes
)
2814 emit_indirect_register_classes (list_p
);
2818 /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2819 TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
2820 but lack suitable crtbegin/end objects or linker support. These
2821 targets can override the default in tm.h to use the fallback mechanism. */
2822 if (TARGET_USE_JCR_SECTION
)
2827 #ifdef JCR_SECTION_NAME
2828 switch_to_section (get_section (JCR_SECTION_NAME
, SECTION_WRITE
, NULL
));
2830 /* A target has defined TARGET_USE_JCR_SECTION,
2831 but doesn't have a JCR_SECTION_NAME. */
2834 assemble_align (POINTER_SIZE
);
2836 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2838 t
= build_fold_addr_expr (klass
);
2839 output_constant (t
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
);
2844 tree klass
, t
, register_class_fn
;
2847 t
= build_function_type_list (void_type_node
, class_ptr_type
, NULL
);
2848 t
= build_decl (input_location
,
2849 FUNCTION_DECL
, get_identifier ("_Jv_RegisterClass"), t
);
2850 TREE_PUBLIC (t
) = 1;
2851 DECL_EXTERNAL (t
) = 1;
2852 register_class_fn
= t
;
2854 for (i
= 0; VEC_iterate (tree
, registered_class
, i
, klass
); ++i
)
2856 t
= build_fold_addr_expr (klass
);
2857 t
= build_call_expr (register_class_fn
, 1, t
);
2858 append_to_statement_list (t
, list_p
);
2863 /* Build a constructor for an entry in the symbol table. */
2866 build_symbol_table_entry (tree clname
, tree name
, tree signature
)
2869 VEC(constructor_elt
,gc
) *v
= NULL
;
2871 START_RECORD_CONSTRUCTOR (v
, symbol_type
);
2872 PUSH_FIELD_VALUE (v
, "clname", clname
);
2873 PUSH_FIELD_VALUE (v
, "name", name
);
2874 PUSH_FIELD_VALUE (v
, "signature", signature
);
2875 FINISH_RECORD_CONSTRUCTOR (symbol
, v
, symbol_type
);
2876 TREE_CONSTANT (symbol
) = 1;
2881 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2884 build_symbol_entry (tree decl
, tree special
)
2886 tree clname
, name
, signature
;
2887 clname
= build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))));
2888 /* ??? Constructors are given the name foo.foo all the way through
2889 the compiler, but in the method table they're all renamed
2890 foo.<init>. So, we have to do the same here unless we want an
2891 unresolved reference at runtime. */
2892 name
= build_utf8_ref ((TREE_CODE (decl
) == FUNCTION_DECL
2893 && DECL_CONSTRUCTOR_P (decl
))
2894 ? init_identifier_node
2895 : DECL_NAME (decl
));
2896 signature
= build_java_signature (TREE_TYPE (decl
));
2897 signature
= build_utf8_ref (unmangle_classname
2898 (IDENTIFIER_POINTER (signature
),
2899 IDENTIFIER_LENGTH (signature
)));
2900 /* SPECIAL is either NULL_TREE or integer_one_node. We emit
2901 signature addr+1 if SPECIAL, and this indicates to the runtime
2902 system that this is a "special" symbol, i.e. one that should
2903 bypass access controls. */
2904 if (special
!= NULL_TREE
)
2905 signature
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (signature
), signature
,
2906 fold_convert (sizetype
, special
));
2908 return build_symbol_table_entry (clname
, name
, signature
);
2911 /* Emit a symbol table: used by -findirect-dispatch. */
2914 emit_symbol_table (tree name
, tree the_table
,
2915 VEC(method_entry
,gc
) *decl_table
,
2916 tree the_syms_decl
, tree the_array_element_type
,
2919 tree table
, null_symbol
, table_size
, the_array_type
;
2922 VEC(constructor_elt
,gc
) *v
= NULL
;
2924 /* Only emit a table if this translation unit actually made any
2925 references via it. */
2926 if (decl_table
== NULL
)
2929 /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2930 for (index
= 0; VEC_iterate (method_entry
, decl_table
, index
, e
); index
++)
2931 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
2932 build_symbol_entry (e
->method
, e
->special
));
2934 /* Terminate the list with a "null" entry. */
2935 null_symbol
= build_symbol_table_entry (null_pointer_node
,
2938 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, null_symbol
);
2940 table
= build_constructor (symbols_array_type
, v
);
2942 /* Make it the initial value for otable_syms and emit the decl. */
2943 DECL_INITIAL (the_syms_decl
) = table
;
2944 DECL_ARTIFICIAL (the_syms_decl
) = 1;
2945 DECL_IGNORED_P (the_syms_decl
) = 1;
2946 rest_of_decl_compilation (the_syms_decl
, 1, 0);
2948 /* Now that its size is known, redefine the table as an
2949 uninitialized static array of INDEX + 1 elements. The extra entry
2950 is used by the runtime to track whether the table has been
2953 = build_index_type (build_int_cst (NULL_TREE
, index
* element_size
+ 1));
2954 the_array_type
= build_array_type (the_array_element_type
, table_size
);
2955 the_table
= build_decl (input_location
,
2956 VAR_DECL
, name
, the_array_type
);
2957 TREE_STATIC (the_table
) = 1;
2958 TREE_READONLY (the_table
) = 1;
2959 rest_of_decl_compilation (the_table
, 1, 0);
2964 /* Make an entry for the catch_classes list. */
2966 make_catch_class_record (tree catch_class
, tree classname
)
2969 tree type
= TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class
)));
2970 VEC(constructor_elt
,gc
) *v
= NULL
;
2971 START_RECORD_CONSTRUCTOR (v
, type
);
2972 PUSH_FIELD_VALUE (v
, "address", catch_class
);
2973 PUSH_FIELD_VALUE (v
, "classname", classname
);
2974 FINISH_RECORD_CONSTRUCTOR (entry
, v
, type
);
2979 /* Generate the list of Throwable classes that are caught by exception
2980 handlers in this class. */
2982 emit_catch_table (tree this_class
)
2984 tree table
, table_size
, array_type
;
2985 int n_catch_classes
;
2987 /* Fill in the dummy entry that make_class created. */
2988 e
= VEC_index (constructor_elt
, TYPE_CATCH_CLASSES (this_class
), 0);
2989 e
->value
= make_catch_class_record (null_pointer_node
, null_pointer_node
);
2990 CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class
), NULL_TREE
,
2991 make_catch_class_record (null_pointer_node
,
2992 null_pointer_node
));
2993 n_catch_classes
= VEC_length (constructor_elt
,
2994 TYPE_CATCH_CLASSES (this_class
));
2995 table_size
= build_index_type (build_int_cst (NULL_TREE
, n_catch_classes
));
2997 = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class
))),
3000 build_decl (input_location
,
3001 VAR_DECL
, DECL_NAME (TYPE_CTABLE_DECL (this_class
)), array_type
);
3002 DECL_INITIAL (table
) =
3003 build_constructor (array_type
, TYPE_CATCH_CLASSES (this_class
));
3004 TREE_STATIC (table
) = 1;
3005 TREE_READONLY (table
) = 1;
3006 DECL_IGNORED_P (table
) = 1;
3007 rest_of_decl_compilation (table
, 1, 0);
3011 /* Given a type, return the signature used by
3012 _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
3013 same as build_java_signature() because we want the canonical array
3017 build_signature_for_libgcj (tree type
)
3021 sig
= build_java_signature (type
);
3022 ref
= build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig
),
3023 IDENTIFIER_LENGTH (sig
)));
3027 /* Build an entry in the type assertion table. */
3030 build_assertion_table_entry (tree code
, tree op1
, tree op2
)
3032 VEC(constructor_elt
,gc
) *v
= NULL
;
3035 START_RECORD_CONSTRUCTOR (v
, assertion_entry_type
);
3036 PUSH_FIELD_VALUE (v
, "assertion_code", code
);
3037 PUSH_FIELD_VALUE (v
, "op1", op1
);
3038 PUSH_FIELD_VALUE (v
, "op2", op2
);
3039 FINISH_RECORD_CONSTRUCTOR (entry
, v
, assertion_entry_type
);
3044 /* Add an entry to the type assertion table. Callback used during hashtable
3048 add_assertion_table_entry (void **htab_entry
, void *ptr
)
3051 tree code_val
, op1_utf8
, op2_utf8
;
3052 VEC(constructor_elt
,gc
) **v
= (VEC(constructor_elt
,gc
) **) ptr
;
3053 type_assertion
*as
= (type_assertion
*) *htab_entry
;
3055 code_val
= build_int_cst (NULL_TREE
, as
->assertion_code
);
3057 if (as
->op1
== NULL_TREE
)
3058 op1_utf8
= null_pointer_node
;
3060 op1_utf8
= build_signature_for_libgcj (as
->op1
);
3062 if (as
->op2
== NULL_TREE
)
3063 op2_utf8
= null_pointer_node
;
3065 op2_utf8
= build_signature_for_libgcj (as
->op2
);
3067 entry
= build_assertion_table_entry (code_val
, op1_utf8
, op2_utf8
);
3069 CONSTRUCTOR_APPEND_ELT (*v
, NULL_TREE
, entry
);
3073 /* Generate the type assertion table for KLASS, and return its DECL. */
3076 emit_assertion_table (tree klass
)
3078 tree null_entry
, ctor
, table_decl
;
3079 htab_t assertions_htab
= TYPE_ASSERTIONS (klass
);
3080 VEC(constructor_elt
,gc
) *v
= NULL
;
3082 /* Iterate through the hash table. */
3083 htab_traverse (assertions_htab
, add_assertion_table_entry
, &v
);
3085 /* Finish with a null entry. */
3086 null_entry
= build_assertion_table_entry (integer_zero_node
,
3090 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, null_entry
);
3092 ctor
= build_constructor (assertion_table_type
, v
);
3094 table_decl
= build_decl (input_location
,
3095 VAR_DECL
, mangled_classname ("_type_assert_", klass
),
3096 assertion_table_type
);
3098 TREE_STATIC (table_decl
) = 1;
3099 TREE_READONLY (table_decl
) = 1;
3100 TREE_CONSTANT (table_decl
) = 1;
3101 DECL_IGNORED_P (table_decl
) = 1;
3103 DECL_INITIAL (table_decl
) = ctor
;
3104 DECL_ARTIFICIAL (table_decl
) = 1;
3105 rest_of_decl_compilation (table_decl
, 1, 0);
3111 init_class_processing (void)
3113 fields_ident
= get_identifier ("fields");
3114 info_ident
= get_identifier ("info");
3116 gcc_obstack_init (&temporary_obstack
);
3119 static hashval_t
java_treetreehash_hash (const void *);
3120 static int java_treetreehash_compare (const void *, const void *);
3122 /* A hash table mapping trees to trees. Used generally. */
3124 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3127 java_treetreehash_hash (const void *k_p
)
3129 const struct treetreehash_entry
*const k
3130 = (const struct treetreehash_entry
*) k_p
;
3131 return JAVA_TREEHASHHASH_H (k
->key
);
3135 java_treetreehash_compare (const void * k1_p
, const void * k2_p
)
3137 const struct treetreehash_entry
*const k1
3138 = (const struct treetreehash_entry
*) k1_p
;
3139 const_tree
const k2
= (const_tree
) k2_p
;
3140 return (k1
->key
== k2
);
3144 java_treetreehash_find (htab_t ht
, tree t
)
3146 struct treetreehash_entry
*e
;
3147 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3148 e
= (struct treetreehash_entry
*) htab_find_with_hash (ht
, t
, hv
);
3156 java_treetreehash_new (htab_t ht
, tree t
)
3159 struct treetreehash_entry
*tthe
;
3160 hashval_t hv
= JAVA_TREEHASHHASH_H (t
);
3162 e
= htab_find_slot_with_hash (ht
, t
, hv
, INSERT
);
3165 tthe
= ggc_alloc_cleared_treetreehash_entry ();
3170 tthe
= (struct treetreehash_entry
*) *e
;
3171 return &tthe
->value
;
3175 java_treetreehash_create (size_t size
)
3177 return htab_create_ggc (size
, java_treetreehash_hash
,
3178 java_treetreehash_compare
, NULL
);
3181 /* Break down qualified IDENTIFIER into package and class-name components.
3182 For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3183 "pkg.foo", and RIGHT to "Bar". */
3186 split_qualified_name (tree
*left
, tree
*right
, tree source
)
3189 int l
= IDENTIFIER_LENGTH (source
);
3191 base
= (char *) alloca (l
+ 1);
3192 memcpy (base
, IDENTIFIER_POINTER (source
), l
+ 1);
3194 /* Breakdown NAME into REMAINDER . IDENTIFIER. */
3196 while (*p
!= '.' && p
!= base
)
3199 /* We didn't find a '.'. Return an error. */
3205 *right
= get_identifier (p
+1);
3206 *left
= get_identifier (base
);
3211 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3212 if the classes are from the same package. */
3215 in_same_package (tree name1
, tree name2
)
3221 if (TREE_CODE (name1
) == TYPE_DECL
)
3222 name1
= DECL_NAME (name1
);
3223 if (TREE_CODE (name2
) == TYPE_DECL
)
3224 name2
= DECL_NAME (name2
);
3226 if (QUALIFIED_P (name1
) != QUALIFIED_P (name2
))
3227 /* One in empty package. */
3230 if (QUALIFIED_P (name1
) == 0 && QUALIFIED_P (name2
) == 0)
3231 /* Both in empty package. */
3234 split_qualified_name (&pkg1
, &tmp
, name1
);
3235 split_qualified_name (&pkg2
, &tmp
, name2
);
3237 return (pkg1
== pkg2
);
3240 /* lang_hooks.decls.final_write_globals: perform final processing on
3241 global variables. */
3244 java_write_globals (void)
3246 tree
*vec
= VEC_address (tree
, pending_static_fields
);
3247 int len
= VEC_length (tree
, pending_static_fields
);
3248 write_global_declarations ();
3249 emit_debug_global_declarations (vec
, len
);
3250 VEC_free (tree
, gc
, pending_static_fields
);
3253 #include "gt-java-class.h"