aboutsummaryrefslogtreecommitdiff
path: root/gcc/java/class.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/java/class.c')
-rw-r--r--gcc/java/class.c3245
1 files changed, 0 insertions, 3245 deletions
diff --git a/gcc/java/class.c b/gcc/java/class.c
deleted file mode 100644
index b4708bc..0000000
--- a/gcc/java/class.c
+++ /dev/null
@@ -1,3245 +0,0 @@
-/* Functions related to building classes and their related objects.
- Copyright (C) 1996-2016 Free Software Foundation, Inc.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3, or (at your option)
-any later version.
-
-GCC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3. If not see
-<http://www.gnu.org/licenses/>.
-
-Java and all Java-based marks are trademarks or registered trademarks
-of Sun Microsystems, Inc. in the United States and other countries.
-The Free Software Foundation is independent of Sun Microsystems, Inc. */
-
-/* Written by Per Bothner <bothner@cygnus.com> */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "target.h"
-#include "function.h"
-#include "tree.h"
-#include "stringpool.h"
-#include "diagnostic-core.h"
-#include "fold-const.h"
-#include "stor-layout.h"
-#include "varasm.h"
-#include "java-tree.h"
-#include "jcf.h"
-#include "toplev.h"
-#include "output.h" /* for switch_to_section and get_section */
-#include "parse.h"
-#include "tree-iterator.h"
-
-static tree make_method_value (tree);
-static tree build_java_method_type (tree, tree, int);
-static int32 hashUtf8String (const char *, int);
-static tree make_field_value (tree);
-static tree get_dispatch_vector (tree);
-static tree get_dispatch_table (tree, tree);
-static int supers_all_compiled (tree type);
-static tree maybe_layout_super_class (tree, tree);
-static void add_miranda_methods (tree, tree);
-static int assume_compiled (const char *);
-static tree build_symbol_entry (tree, tree);
-static tree emit_assertion_table (tree);
-static void register_class (void);
-
-struct obstack temporary_obstack;
-
-static const char *cyclic_inheritance_report;
-
-/* The compiler generates different code depending on whether or not
- it can assume certain classes have been compiled down to native
- code or not. The compiler options -fassume-compiled= and
- -fno-assume-compiled= are used to create a tree of
- class_flag_node objects. This tree is queried to determine if
- a class is assume to be compiled or not. Each node in the tree
- represents either a package or a specific class. */
-
-typedef struct class_flag_node_struct
-{
- /* The class or package name. */
- const char *ident;
-
- /* Nonzero if this represents an exclusion. */
- int value;
-
- /* Pointers to other nodes in the tree. */
- struct class_flag_node_struct *parent;
- struct class_flag_node_struct *sibling;
- struct class_flag_node_struct *child;
-} class_flag_node;
-
-static class_flag_node *find_class_flag_node (class_flag_node *, const char *);
-static void add_class_flag (class_flag_node **, const char *, int);
-
-/* This is the root of the include/exclude tree. */
-
-static class_flag_node *assume_compiled_tree;
-
-static class_flag_node *enable_assert_tree;
-
-static GTY(()) tree class_roots[4];
-#define fields_ident class_roots[0] /* get_identifier ("fields") */
-#define info_ident class_roots[1] /* get_identifier ("info") */
-#define class_list class_roots[2]
-#define class_dtable_decl class_roots[3]
-
-static GTY(()) vec<tree, va_gc> *registered_class;
-
-/* A tree that returns the address of the class$ of the class
- currently being compiled. */
-static GTY(()) tree this_classdollar;
-
-/* Return the node that most closely represents the class whose name
- is IDENT. Start the search from NODE (followed by its siblings).
- Return NULL if an appropriate node does not exist. */
-
-static class_flag_node *
-find_class_flag_node (class_flag_node *node, const char *ident)
-{
- while (node)
- {
- size_t node_ident_length = strlen (node->ident);
-
- /* node_ident_length is zero at the root of the tree. If the
- identifiers are the same length, then we have matching
- classes. Otherwise check if we've matched an enclosing
- package name. */
-
- if (node_ident_length == 0
- || (strncmp (ident, node->ident, node_ident_length) == 0
- && (ident[node_ident_length] == '\0'
- || ident[node_ident_length] == '.')))
- {
- /* We've found a match, however, there might be a more
- specific match. */
-
- class_flag_node *found = find_class_flag_node (node->child, ident);
- if (found)
- return found;
- else
- return node;
- }
-
- /* No match yet. Continue through the sibling list. */
- node = node->sibling;
- }
-
- /* No match at all in this tree. */
- return NULL;
-}
-
-void
-add_class_flag (class_flag_node **rootp, const char *ident, int value)
-{
- class_flag_node *root = *rootp;
- class_flag_node *parent, *node;
-
- /* Create the root of the tree if it doesn't exist yet. */
-
- if (NULL == root)
- {
- root = XNEW (class_flag_node);
- root->ident = "";
- root->value = 0;
- root->sibling = NULL;
- root->child = NULL;
- root->parent = NULL;
- *rootp = root;
- }
-
- /* Calling the function with the empty string means we're setting
- value for the root of the hierarchy. */
-
- if (0 == ident[0])
- {
- root->value = value;
- return;
- }
-
- /* Find the parent node for this new node. PARENT will either be a
- class or a package name. Adjust PARENT accordingly. */
-
- parent = find_class_flag_node (root, ident);
- if (strcmp (ident, parent->ident) == 0)
- parent->value = value;
- else
- {
- /* Insert new node into the tree. */
- node = XNEW (class_flag_node);
-
- node->ident = xstrdup (ident);
- node->value = value;
- node->child = NULL;
-
- node->parent = parent;
- node->sibling = parent->child;
- parent->child = node;
- }
-}
-
-/* Add a new IDENT to the include/exclude tree. It's an exclusion
- if EXCLUDEP is nonzero. */
-
-void
-add_assume_compiled (const char *ident, int excludep)
-{
- add_class_flag (&assume_compiled_tree, ident, excludep);
-}
-
-/* The default value returned by enable_assertions. */
-
-#define DEFAULT_ENABLE_ASSERT (optimize == 0)
-
-/* Enter IDENT (a class or package name) into the enable-assertions table.
- VALUE is true to enable and false to disable. */
-
-void
-add_enable_assert (const char *ident, int value)
-{
- if (enable_assert_tree == NULL)
- add_class_flag (&enable_assert_tree, "", DEFAULT_ENABLE_ASSERT);
- add_class_flag (&enable_assert_tree, ident, value);
-}
-
-/* Returns nonzero if IDENT is the name of a class that the compiler
- should assume has been compiled to object code. */
-
-static int
-assume_compiled (const char *ident)
-{
- class_flag_node *i;
- int result;
-
- if (NULL == assume_compiled_tree)
- return 1;
-
- i = find_class_flag_node (assume_compiled_tree, ident);
-
- result = ! i->value;
-
- return (result);
-}
-
-/* Return true if we should generate code to check assertions within KLASS. */
-
-bool
-enable_assertions (tree klass)
-{
- /* Check if command-line specifies whether we should check assertions. */
-
- if (klass != NULL_TREE && DECL_NAME (klass) && enable_assert_tree != NULL)
- {
- const char *ident = IDENTIFIER_POINTER (DECL_NAME (klass));
- class_flag_node *node
- = find_class_flag_node (enable_assert_tree, ident);
- return node->value;
- }
-
- /* The default is to enable assertions if generating class files,
- or not optimizing. */
- return DEFAULT_ENABLE_ASSERT;
-}
-
-/* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
- except that characters matching OLD_CHAR are substituted by NEW_CHAR.
- Also, PREFIX is prepended, and SUFFIX is appended. */
-
-tree
-ident_subst (const char* old_name,
- int old_length,
- const char *prefix,
- int old_char,
- int new_char,
- const char *suffix)
-{
- int prefix_len = strlen (prefix);
- int suffix_len = strlen (suffix);
- int i = prefix_len + old_length + suffix_len + 1;
- char *buffer = (char *) alloca (i);
-
- strcpy (buffer, prefix);
- for (i = 0; i < old_length; i++)
- {
- char ch = old_name[i];
- if (ch == old_char)
- ch = new_char;
- buffer[prefix_len + i] = ch;
- }
- strcpy (buffer + prefix_len + old_length, suffix);
- return get_identifier (buffer);
-}
-
-/* Return an IDENTIFIER_NODE the same as OLD_ID,
- except that characters matching OLD_CHAR are substituted by NEW_CHAR.
- Also, PREFIX is prepended, and SUFFIX is appended. */
-
-tree
-identifier_subst (const tree old_id,
- const char *prefix,
- int old_char,
- int new_char,
- const char *suffix)
-{
- return ident_subst (IDENTIFIER_POINTER (old_id), IDENTIFIER_LENGTH (old_id),
- prefix, old_char, new_char, suffix);
-}
-
-/* Generate a valid C identifier from the name of the class TYPE,
- prefixed by PREFIX. */
-
-tree
-mangled_classname (const char *prefix, tree type)
-{
- tree result;
- tree ident = TYPE_NAME (type);
- if (TREE_CODE (ident) != IDENTIFIER_NODE)
- ident = DECL_NAME (ident);
- result = identifier_subst (ident, prefix, '.', '_', "");
-
- /* Replace any characters that aren't in the set [0-9a-zA-Z_$] with
- "_0xXX". Class names containing such chracters are uncommon, but
- they do sometimes occur in class files. Without this check,
- these names cause assembly errors.
-
- There is a possibility that a real class name could conflict with
- the identifier we generate, but it is unlikely and will
- immediately be detected as an assembler error. At some point we
- should do something more elaborate (perhaps using the full
- unicode mangling scheme) in order to prevent such a conflict. */
- {
- int i;
- const int len = IDENTIFIER_LENGTH (result);
- const char *p = IDENTIFIER_POINTER (result);
- int illegal_chars = 0;
-
- /* Make two passes over the identifier. The first pass is merely
- to count illegal characters; we need to do this in order to
- allocate a buffer. */
- for (i = 0; i < len; i++)
- {
- char c = p[i];
- illegal_chars += (! ISALNUM (c) && c != '_' && c != '$');
- }
-
- /* And the second pass, which is rarely executed, does the
- rewriting. */
- if (illegal_chars != 0)
- {
- char *buffer = (char *) alloca (illegal_chars * 4 + len + 1);
- int j;
-
- for (i = 0, j = 0; i < len; i++)
- {
- char c = p[i];
- if (! ISALNUM (c) && c != '_' && c != '$')
- {
- buffer[j++] = '_';
- sprintf (&buffer[j], "0x%02x", c);
- j += 4;
- }
- else
- buffer[j++] = c;
- }
-
- buffer[j] = 0;
- result = get_identifier (buffer);
- }
- }
-
- return result;
-}
-
-tree
-make_class (void)
-{
- tree type;
- type = make_node (RECORD_TYPE);
- /* Unfortunately we must create the binfo here, so that class
- loading works. */
- TYPE_BINFO (type) = make_tree_binfo (0);
- MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
- TYPE_CATCH_CLASSES (type) = NULL;
- /* Push a dummy entry; we can't call make_catch_class_record here
- because other infrastructure may not be set up yet. We'll come
- back and fill it in later once said infrastructure is
- initialized. */
- CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (type), NULL_TREE, NULL_TREE);
-
- return type;
-}
-
-/* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
- and where each of the constituents is separated by '/',
- return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
-
-tree
-unmangle_classname (const char *name, int name_length)
-{
- tree to_return = ident_subst (name, name_length, "", '/', '.', "");
- /* It's not sufficient to compare to_return and get_identifier
- (name) to determine whether to_return is qualified. There are
- cases in signature analysis where name will be stripped of a
- trailing ';'. */
- name = IDENTIFIER_POINTER (to_return);
- while (*name)
- if (*name++ == '.')
- {
- QUALIFIED_P (to_return) = 1;
- break;
- }
-
- return to_return;
-}
-
-#define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE) \
-do \
-{ \
- const char *type_name = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
- char *buf = (char *) alloca (strlen (type_name) \
- + strlen (#NAME "_syms_") + 1); \
- tree decl; \
- \
- sprintf (buf, #NAME "_%s", type_name); \
- TYPE_## TABLE ##_DECL (type) = decl = \
- build_decl (input_location, VAR_DECL, get_identifier (buf), TABLE_TYPE); \
- DECL_EXTERNAL (decl) = 1; \
- TREE_STATIC (decl) = 1; \
- TREE_READONLY (decl) = 1; \
- TREE_CONSTANT (decl) = 1; \
- DECL_IGNORED_P (decl) = 1; \
- /* Mark the table as belonging to this class. */ \
- pushdecl (decl); \
- MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl); \
- DECL_OWNER (decl) = TYPE; \
- sprintf (buf, #NAME "_syms_%s", type_name); \
- TYPE_## TABLE ##_SYMS_DECL (TYPE) = \
- build_decl (input_location, VAR_DECL, get_identifier (buf), symbols_array_type); \
- TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
- TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
- DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1; \
-} \
-while (0)
-
-/* Given a class, create the DECLs for all its associated indirect
- dispatch tables. */
-void
-gen_indirect_dispatch_tables (tree type)
-{
- const char *type_name = IDENTIFIER_POINTER (mangled_classname ("", type));
- {
- tree field = NULL;
- char *buf = (char *) alloca (strlen (type_name)
- + strlen ("_catch_classes_") + 1);
- tree catch_class_type = make_node (RECORD_TYPE);
-
- sprintf (buf, "_catch_classes_%s", type_name);
- PUSH_FIELD (input_location,
- catch_class_type, field, "address", utf8const_ptr_type);
- PUSH_FIELD (input_location,
- catch_class_type, field, "classname", ptr_type_node);
- FINISH_RECORD (catch_class_type);
-
- TYPE_CTABLE_DECL (type)
- = build_decl (input_location, VAR_DECL, get_identifier (buf),
- build_array_type (catch_class_type, 0));
- DECL_EXTERNAL (TYPE_CTABLE_DECL (type)) = 1;
- TREE_STATIC (TYPE_CTABLE_DECL (type)) = 1;
- TREE_READONLY (TYPE_CTABLE_DECL (type)) = 1;
- TREE_CONSTANT (TYPE_CTABLE_DECL (type)) = 1;
- DECL_IGNORED_P (TYPE_CTABLE_DECL (type)) = 1;
- pushdecl (TYPE_CTABLE_DECL (type));
- }
-
- if (flag_indirect_dispatch)
- {
- GEN_TABLE (ATABLE, _atable, atable_type, type);
- GEN_TABLE (OTABLE, _otable, otable_type, type);
- GEN_TABLE (ITABLE, _itable, itable_type, type);
- }
-}
-
-#undef GEN_TABLE
-
-tree
-push_class (tree class_type, tree class_name)
-{
- tree decl, signature;
- location_t saved_loc = input_location;
- CLASS_P (class_type) = 1;
- decl = build_decl (input_location, TYPE_DECL, class_name, class_type);
- TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
-
- /* dbxout needs a DECL_SIZE if in gstabs mode */
- DECL_SIZE (decl) = integer_zero_node;
-
- input_location = saved_loc;
- signature = identifier_subst (class_name, "L", '.', '/', ";");
- IDENTIFIER_SIGNATURE_TYPE (signature) = build_pointer_type (class_type);
-
- /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
- both a typedef and in the struct name-space. We may want to re-visit
- this later, but for now it reduces the changes needed for gdb. */
- DECL_ARTIFICIAL (decl) = 1;
-
- pushdecl_top_level (decl);
-
- return decl;
-}
-
-/* Finds the (global) class named NAME. Creates the class if not found.
- Also creates associated TYPE_DECL.
- Does not check if the class actually exists, load the class,
- fill in field or methods, or do layout_type. */
-
-tree
-lookup_class (tree name)
-{
- tree decl = IDENTIFIER_CLASS_VALUE (name);
- if (decl == NULL_TREE)
- decl = push_class (make_class (), name);
- return TREE_TYPE (decl);
-}
-
-void
-set_super_info (int access_flags, tree this_class,
- tree super_class, int interfaces_count)
-{
- int total_supers = interfaces_count;
- tree class_decl = TYPE_NAME (this_class);
-
- if (super_class)
- total_supers++;
-
- if (total_supers)
- TYPE_BINFO (this_class) = make_tree_binfo (total_supers);
- TYPE_VFIELD (this_class) = TYPE_VFIELD (object_type_node);
- if (super_class)
- {
- tree super_binfo = make_tree_binfo (0);
- BINFO_TYPE (super_binfo) = super_class;
- BINFO_OFFSET (super_binfo) = integer_zero_node;
- BINFO_BASE_APPEND (TYPE_BINFO (this_class), super_binfo);
- CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class)) = 1;
- }
-
- set_class_decl_access_flags (access_flags, class_decl);
-}
-
-void
-set_class_decl_access_flags (int access_flags, tree class_decl)
-{
- if (access_flags & ACC_PUBLIC) CLASS_PUBLIC (class_decl) = 1;
- if (access_flags & ACC_FINAL) CLASS_FINAL (class_decl) = 1;
- if (access_flags & ACC_SUPER) CLASS_SUPER (class_decl) = 1;
- if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
- if (access_flags & ACC_ABSTRACT) CLASS_ABSTRACT (class_decl) = 1;
- if (access_flags & ACC_STATIC) CLASS_STATIC (class_decl) = 1;
- if (access_flags & ACC_PRIVATE) CLASS_PRIVATE (class_decl) = 1;
- if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
- if (access_flags & ACC_STRICT) CLASS_STRICTFP (class_decl) = 1;
- if (access_flags & ACC_ENUM) CLASS_ENUM (class_decl) = 1;
- if (access_flags & ACC_SYNTHETIC) CLASS_SYNTHETIC (class_decl) = 1;
- if (access_flags & ACC_ANNOTATION) CLASS_ANNOTATION (class_decl) = 1;
-}
-
-/* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
- direct sub-classes of Object are 1, and so on. */
-
-int
-class_depth (tree clas)
-{
- int depth = 0;
- if (! CLASS_LOADED_P (clas))
- load_class (clas, 1);
- if (TYPE_SIZE (clas) == error_mark_node)
- return -1;
- while (clas != object_type_node)
- {
- depth++;
- clas = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas), 0));
- }
- return depth;
-}
-
-/* Return true iff TYPE2 is an interface that extends interface TYPE1 */
-
-int
-interface_of_p (tree type1, tree type2)
-{
- int i;
- tree binfo, base_binfo;
-
- if (! TYPE_BINFO (type2))
- return 0;
-
- for (binfo = TYPE_BINFO (type2), i = 0;
- BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
- if (BINFO_TYPE (base_binfo) == type1)
- return 1;
-
- for (binfo = TYPE_BINFO (type2), i = 0;
- BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) /* */
- if (BINFO_TYPE (base_binfo)
- && interface_of_p (type1, BINFO_TYPE (base_binfo)))
- return 1;
-
- return 0;
-}
-
-/* Return true iff TYPE1 inherits from TYPE2. */
-
-int
-inherits_from_p (tree type1, tree type2)
-{
- while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
- {
- if (type1 == type2)
- return 1;
-
- if (! CLASS_LOADED_P (type1))
- load_class (type1, 1);
-
- type1 = maybe_layout_super_class (CLASSTYPE_SUPER (type1), type1);
- }
- return 0;
-}
-
-/* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
-
-int
-enclosing_context_p (tree type1, tree type2)
-{
- if (!INNER_CLASS_TYPE_P (type2))
- return 0;
-
- for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
- type2;
- type2 = (INNER_CLASS_TYPE_P (type2) ?
- TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
- {
- if (type2 == type1)
- return 1;
- }
-
- return 0;
-}
-
-
-/* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
- nesting level. */
-
-int
-common_enclosing_context_p (tree type1, tree type2)
-{
- while (type1)
- {
- tree current;
- for (current = type2; current;
- current = (INNER_CLASS_TYPE_P (current) ?
- TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
- NULL_TREE))
- if (type1 == current)
- return 1;
-
- if (INNER_CLASS_TYPE_P (type1))
- type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1)));
- else
- break;
- }
- return 0;
-}
-
-/* Return 1 iff there exists a common enclosing "this" between TYPE1
- and TYPE2, without crossing any static context. */
-
-int
-common_enclosing_instance_p (tree type1, tree type2)
-{
- if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
- return 0;
-
- for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1;
- type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
- TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
- {
- tree current;
- for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
- current = (PURE_INNER_CLASS_TYPE_P (current) ?
- TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
- NULL_TREE))
- if (type1 == current)
- return 1;
- }
- return 0;
-}
-
-/* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
- found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
- if attempt is made to add it twice. */
-
-tree
-maybe_add_interface (tree this_class, tree interface_class)
-{
- tree binfo, base_binfo;
- int i;
-
- for (binfo = TYPE_BINFO (this_class), i = 0;
- BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
- if (BINFO_TYPE (base_binfo) == interface_class)
- return interface_class;
- add_interface (this_class, interface_class);
- return NULL_TREE;
-}
-
-/* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
-
-void
-add_interface (tree this_class, tree interface_class)
-{
- tree interface_binfo = make_tree_binfo (0);
-
- BINFO_TYPE (interface_binfo) = interface_class;
- BINFO_OFFSET (interface_binfo) = integer_zero_node;
- BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node;
- BINFO_VIRTUAL_P (interface_binfo) = 1;
-
- BINFO_BASE_APPEND (TYPE_BINFO (this_class), interface_binfo);
-}
-
-static tree
-build_java_method_type (tree fntype, tree this_class, int access_flags)
-{
- if (access_flags & ACC_STATIC)
- return fntype;
- fntype = build_method_type (this_class, fntype);
-
- /* We know that arg 1 of every nonstatic method is non-null; tell
- the back-end so. */
- TYPE_ATTRIBUTES (fntype) = (tree_cons
- (get_identifier ("nonnull"),
- tree_cons (NULL_TREE,
- build_int_cst (NULL_TREE, 1),
- NULL_TREE),
- TYPE_ATTRIBUTES (fntype)));
- return fntype;
-}
-
-void
-java_hide_decl (tree decl ATTRIBUTE_UNUSED)
-{
-#ifdef HAVE_GAS_HIDDEN
- DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
- DECL_VISIBILITY_SPECIFIED (decl) = 1;
-#endif
-}
-
-tree
-add_method_1 (tree this_class, int access_flags, tree name, tree function_type)
-{
- tree method_type, fndecl;
-
- method_type = build_java_method_type (function_type,
- this_class, access_flags);
-
- fndecl = build_decl (input_location, FUNCTION_DECL, name, method_type);
- DECL_CONTEXT (fndecl) = this_class;
-
- DECL_LANG_SPECIFIC (fndecl) = ggc_cleared_alloc<struct lang_decl> ();
- DECL_LANG_SPECIFIC (fndecl)->desc = LANG_DECL_FUNC;
-
- /* Initialize the static initializer test table. */
-
- DECL_FUNCTION_INIT_TEST_TABLE (fndecl) = java_treetreehash_create (10);
-
- /* Initialize the initialized (static) class table. */
- if (access_flags & ACC_STATIC)
- DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) =
- hash_table<ict_hasher>::create_ggc (50);
-
- DECL_CHAIN (fndecl) = TYPE_METHODS (this_class);
- TYPE_METHODS (this_class) = fndecl;
-
- if (!(access_flags & ACC_STATIC))
- SET_DECL_ALIGN (fndecl, MINIMUM_METHOD_BOUNDARY);
-
- /* Notice that this is a finalizer and update the class type
- accordingly. This is used to optimize instance allocation. */
- if (name == finalize_identifier_node
- && TREE_TYPE (function_type) == void_type_node
- && TREE_VALUE (TYPE_ARG_TYPES (function_type)) == void_type_node)
- HAS_FINALIZER_P (this_class) = 1;
-
- if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
- if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
- if (access_flags & ACC_PRIVATE)
- METHOD_PRIVATE (fndecl) = 1;
- if (access_flags & ACC_NATIVE)
- {
- METHOD_NATIVE (fndecl) = 1;
- DECL_EXTERNAL (fndecl) = 1;
- }
- else
- /* FNDECL is external unless we are compiling it into this object
- file. */
- DECL_EXTERNAL (fndecl) = CLASS_FROM_CURRENTLY_COMPILED_P (this_class) == 0;
- if (access_flags & ACC_STATIC)
- METHOD_STATIC (fndecl) = 1;
- if (access_flags & ACC_FINAL)
- METHOD_FINAL (fndecl) = 1;
- if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
- if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
- if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
- if (access_flags & ACC_SYNTHETIC) DECL_ARTIFICIAL (fndecl) = 1;
- if (access_flags & ACC_BRIDGE) METHOD_BRIDGE (fndecl) = 1;
- if (access_flags & ACC_VARARGS) METHOD_VARARGS (fndecl) = 1;
- return fndecl;
-}
-
-/* Add a method to THIS_CLASS.
- The method's name is NAME.
- Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
-
-tree
-add_method (tree this_class, int access_flags, tree name, tree method_sig)
-{
- tree function_type, fndecl;
- const unsigned char *sig
- = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
-
- if (sig[0] != '(')
- fatal_error (input_location, "bad method signature");
-
- function_type = get_type_from_signature (method_sig);
- fndecl = add_method_1 (this_class, access_flags, name, function_type);
- set_java_signature (TREE_TYPE (fndecl), method_sig);
- return fndecl;
-}
-
-tree
-add_field (tree klass, tree name, tree field_type, int flags)
-{
- int is_static = (flags & ACC_STATIC) != 0;
- tree field;
- field = build_decl (input_location,
- is_static ? VAR_DECL : FIELD_DECL, name, field_type);
- DECL_CHAIN (field) = TYPE_FIELDS (klass);
- TYPE_FIELDS (klass) = field;
- DECL_CONTEXT (field) = klass;
- MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
-
- if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
- if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
- if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
- if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
- if (flags & ACC_VOLATILE)
- {
- FIELD_VOLATILE (field) = 1;
- TREE_THIS_VOLATILE (field) = 1;
- }
- if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
- if (flags & ACC_ENUM) FIELD_ENUM (field) = 1;
- if (flags & ACC_SYNTHETIC) FIELD_SYNTHETIC (field) = 1;
- if (is_static)
- {
- FIELD_STATIC (field) = 1;
- /* Always make field externally visible. This is required so
- that native methods can always access the field. */
- TREE_PUBLIC (field) = 1;
- /* Hide everything that shouldn't be visible outside a DSO. */
- if (flag_indirect_classes
- || (FIELD_PRIVATE (field)))
- java_hide_decl (field);
- /* Considered external unless we are compiling it into this
- object file. */
- DECL_EXTERNAL (field) = (is_compiled_class (klass) != 2);
- }
-
- return field;
-}
-
-/* Associate a constant value CONSTANT with VAR_DECL FIELD. */
-
-void
-set_constant_value (tree field, tree constant)
-{
- if (field == NULL_TREE)
- warning (OPT_Wattributes,
- "misplaced ConstantValue attribute (not in any field)");
- else if (DECL_INITIAL (field) != NULL_TREE)
- warning (OPT_Wattributes,
- "duplicate ConstantValue attribute for field '%s'",
- IDENTIFIER_POINTER (DECL_NAME (field)));
- else
- {
- DECL_INITIAL (field) = constant;
- if (TREE_TYPE (constant) != TREE_TYPE (field)
- && ! (TREE_TYPE (constant) == int_type_node
- && INTEGRAL_TYPE_P (TREE_TYPE (field))
- && TYPE_PRECISION (TREE_TYPE (field)) <= 32)
- && ! (TREE_TYPE (constant) == utf8const_ptr_type
- && TREE_TYPE (field) == string_ptr_type_node))
- error ("ConstantValue attribute of field '%s' has wrong type",
- IDENTIFIER_POINTER (DECL_NAME (field)));
- }
-}
-
-/* Calculate a hash value for a string encoded in Utf8 format.
- * This returns the same hash value as specified for java.lang.String.hashCode.
- */
-
-static int32
-hashUtf8String (const char *str, int len)
-{
- const unsigned char* ptr = (const unsigned char*) str;
- const unsigned char *limit = ptr + len;
- uint32 hash = 0;
- for (; ptr < limit;)
- {
- int ch = UTF8_GET (ptr, limit);
- /* Updated specification from
- http://www.javasoft.com/docs/books/jls/clarify.html. */
- hash = (31 * hash) + ch;
- }
- return hash;
-}
-
-tree
-build_utf8_ref (tree name)
-{
- const char * name_ptr = IDENTIFIER_POINTER (name);
- int name_len = IDENTIFIER_LENGTH (name), name_pad;
- char buf[60];
- tree ctype, field = NULL_TREE, str_type, cinit, string;
- static int utf8_count = 0;
- int name_hash;
- tree ref = IDENTIFIER_UTF8_REF (name);
- tree decl;
- vec<constructor_elt, va_gc> *v = NULL;
- if (ref != NULL_TREE)
- return ref;
-
- ctype = make_node (RECORD_TYPE);
- /* '\0' byte plus padding to utf8const_type's alignment. */
- name_pad = TYPE_ALIGN_UNIT (utf8const_type)
- - (name_len & (TYPE_ALIGN_UNIT (utf8const_type) - 1));
- str_type = build_prim_array_type (unsigned_byte_type_node,
- name_len + name_pad);
- PUSH_FIELD (input_location, ctype, field, "hash", unsigned_short_type_node);
- PUSH_FIELD (input_location,
- ctype, field, "length", unsigned_short_type_node);
- PUSH_FIELD (input_location, ctype, field, "data", str_type);
- FINISH_RECORD (ctype);
- START_RECORD_CONSTRUCTOR (v, ctype);
- name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
- PUSH_FIELD_VALUE (v, "hash", build_int_cst (NULL_TREE, name_hash));
- PUSH_FIELD_VALUE (v, "length", build_int_cst (NULL_TREE, name_len));
- string = build_string (name_len, name_ptr);
- TREE_TYPE (string) = str_type;
- PUSH_FIELD_VALUE (v, "data", string);
- FINISH_RECORD_CONSTRUCTOR (cinit, v, ctype);
- TREE_CONSTANT (cinit) = 1;
-
- /* Generate a unique-enough identifier. */
- sprintf(buf, "_Utf%d", ++utf8_count);
-
- decl = build_decl (input_location,
- VAR_DECL, get_identifier (buf), utf8const_type);
- TREE_STATIC (decl) = 1;
- DECL_ARTIFICIAL (decl) = 1;
- DECL_IGNORED_P (decl) = 1;
- TREE_READONLY (decl) = 1;
- TREE_THIS_VOLATILE (decl) = 0;
- DECL_INITIAL (decl) = cinit;
- DECL_USER_ALIGN (decl) = 1;
-
- if (HAVE_GAS_SHF_MERGE)
- {
- int decl_size;
- /* Ensure decl_size is a multiple of utf8const_type's alignment. */
- decl_size = name_len + 4 + name_pad;
- if (flag_merge_constants && decl_size < 256)
- {
- char buf[32];
- int flags = (SECTION_OVERRIDE
- | SECTION_MERGE | (SECTION_ENTSIZE & decl_size));
- sprintf (buf, ".rodata.jutf8.%d", decl_size);
- switch_to_section (get_section (buf, flags, NULL));
- set_decl_section_name (decl, buf);
- }
- }
-
- layout_decl (decl, 0);
- DECL_SIZE (decl) = TYPE_SIZE (ctype);
- DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (ctype);
- pushdecl (decl);
- rest_of_decl_compilation (decl, global_bindings_p (), 0);
- ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
- IDENTIFIER_UTF8_REF (name) = ref;
- return ref;
-}
-
-/* Like build_class_ref, but instead of a direct reference generate a
- pointer into the constant pool. */
-
-static tree
-build_indirect_class_ref (tree type)
-{
- int index;
- tree cl;
- index = alloc_class_constant (type);
- cl = build_ref_from_constant_pool (index);
- return convert (promote_type (class_ptr_type), cl);
-}
-
-static tree
-build_static_class_ref (tree type)
-{
- tree decl_name, decl, ref;
-
- if (TYPE_SIZE (type) == error_mark_node)
- return null_pointer_node;
- decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
- "", '/', '/', ".class$$");
- decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
- if (decl == NULL_TREE)
- {
- decl = build_decl (input_location, VAR_DECL, decl_name, class_type_node);
- TREE_STATIC (decl) = 1;
- if (! flag_indirect_classes)
- {
- TREE_PUBLIC (decl) = 1;
- if (CLASS_PRIVATE (TYPE_NAME (type)))
- java_hide_decl (decl);
- }
- DECL_IGNORED_P (decl) = 1;
- DECL_ARTIFICIAL (decl) = 1;
- if (is_compiled_class (type) == 1)
- DECL_EXTERNAL (decl) = 1;
- MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
- DECL_CLASS_FIELD_P (decl) = 1;
- DECL_CONTEXT (decl) = type;
-
- /* ??? We want to preserve the DECL_CONTEXT we set just above,
- that means not calling pushdecl_top_level. */
- IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
- }
-
- ref = build1 (ADDR_EXPR, class_ptr_type, decl);
- return ref;
-}
-
-static tree
-build_classdollar_field (tree type)
-{
- tree decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
- "", '/', '/', ".class$");
- tree decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
-
- if (decl == NULL_TREE)
- {
- decl
- = build_decl (input_location,
- VAR_DECL, decl_name,
- (build_qualified_type
- (build_pointer_type
- (build_qualified_type (class_type_node,
- TYPE_QUAL_CONST)),
- TYPE_QUAL_CONST)));
- TREE_STATIC (decl) = 1;
- TREE_CONSTANT (decl) = 1;
- TREE_PUBLIC (decl) = 1;
- java_hide_decl (decl);
- DECL_IGNORED_P (decl) = 1;
- DECL_ARTIFICIAL (decl) = 1;
- MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
- IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
- DECL_CLASS_FIELD_P (decl) = 1;
- DECL_CONTEXT (decl) = type;
- }
-
- return decl;
-}
-
-/* Create a local variable that holds the current class$. */
-
-void
-cache_this_class_ref (tree fndecl)
-{
- if (optimize)
- {
- tree classdollar_field;
- if (flag_indirect_classes)
- classdollar_field = build_classdollar_field (output_class);
- else
- classdollar_field = build_static_class_ref (output_class);
-
- this_classdollar = build_decl (input_location,
- VAR_DECL, NULL_TREE,
- TREE_TYPE (classdollar_field));
-
- java_add_local_var (this_classdollar);
- java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (this_classdollar),
- this_classdollar, classdollar_field));
- }
- else
- this_classdollar = build_classdollar_field (output_class);
-
- /* Prepend class initialization for static methods reachable from
- other classes. */
- if (METHOD_STATIC (fndecl)
- && (! METHOD_PRIVATE (fndecl)
- || INNER_CLASS_P (DECL_CONTEXT (fndecl)))
- && ! DECL_CLINIT_P (fndecl)
- && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (fndecl))))
- {
- tree init = build_call_expr (soft_initclass_node, 1,
- this_classdollar);
- java_add_stmt (init);
- }
-}
-
-/* Remove the reference to the local variable that holds the current
- class$. */
-
-void
-uncache_this_class_ref (tree fndecl ATTRIBUTE_UNUSED)
-{
- this_classdollar = build_classdollar_field (output_class);
-}
-
-/* Build a reference to the class TYPE.
- Also handles primitive types and array types. */
-
-tree
-build_class_ref (tree type)
-{
- int is_compiled = is_compiled_class (type);
- if (is_compiled)
- {
- tree ref, decl;
- if (TREE_CODE (type) == POINTER_TYPE)
- type = TREE_TYPE (type);
-
- if (flag_indirect_dispatch
- && type != output_class
- && TREE_CODE (type) == RECORD_TYPE)
- return build_indirect_class_ref (type);
-
- if (type == output_class && flag_indirect_classes)
- {
- /* This can be NULL if we see a JNI stub before we see any
- other method. */
- if (! this_classdollar)
- this_classdollar = build_classdollar_field (output_class);
- return this_classdollar;
- }
-
- if (TREE_CODE (type) == RECORD_TYPE)
- return build_static_class_ref (type);
- else
- {
- const char *name;
- tree decl_name;
- char buffer[25];
- decl_name = TYPE_NAME (type);
- if (TREE_CODE (decl_name) == TYPE_DECL)
- decl_name = DECL_NAME (decl_name);
- name = IDENTIFIER_POINTER (decl_name);
- if (strncmp (name, "promoted_", 9) == 0)
- name += 9;
- sprintf (buffer, "_Jv_%sClass", name);
- decl_name = get_identifier (buffer);
- decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
- if (decl == NULL_TREE)
- {
- decl = build_decl (input_location,
- VAR_DECL, decl_name, class_type_node);
- TREE_STATIC (decl) = 1;
- TREE_PUBLIC (decl) = 1;
- DECL_EXTERNAL (decl) = 1;
- DECL_ARTIFICIAL (decl) = 1;
- pushdecl_top_level (decl);
- }
- }
-
- ref = build1 (ADDR_EXPR, class_ptr_type, decl);
- return ref;
- }
- else
- return build_indirect_class_ref (type);
-}
-
-/* Create a local statically allocated variable that will hold a
- pointer to a static field. */
-
-static tree
-build_fieldref_cache_entry (int index, tree fdecl ATTRIBUTE_UNUSED)
-{
- tree decl, decl_name;
- const char *name = IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class));
- char *buf = (char *) alloca (strlen (name) + 20);
- sprintf (buf, "%s_%d_ref", name, index);
- decl_name = get_identifier (buf);
- decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
- if (decl == NULL_TREE)
- {
- decl = build_decl (input_location,
- VAR_DECL, decl_name, ptr_type_node);
- TREE_STATIC (decl) = 1;
- TREE_PUBLIC (decl) = 0;
- DECL_EXTERNAL (decl) = 0;
- DECL_ARTIFICIAL (decl) = 1;
- DECL_IGNORED_P (decl) = 1;
- pushdecl_top_level (decl);
- }
- return decl;
-}
-
-tree
-build_static_field_ref (tree fdecl)
-{
- tree fclass = DECL_CONTEXT (fdecl);
- int is_compiled = is_compiled_class (fclass);
-
- /* Allow static final fields to fold to a constant. When using
- -findirect-dispatch, we simply never do this folding if compiling
- from .class; in the .class file constants will be referred to via
- the constant pool. */
- if (!flag_indirect_dispatch
- && (is_compiled
- || (FIELD_FINAL (fdecl) && DECL_INITIAL (fdecl) != NULL_TREE
- && (JSTRING_TYPE_P (TREE_TYPE (fdecl))
- || JNUMERIC_TYPE_P (TREE_TYPE (fdecl)))
- && TREE_CONSTANT (DECL_INITIAL (fdecl)))))
- {
- if (is_compiled == 1)
- DECL_EXTERNAL (fdecl) = 1;
- }
- else
- {
- /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
- and a class local static variable CACHE_ENTRY, then
-
- *(fdecl **)((__builtin_expect (cache_entry == null, false))
- ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
- : cache_entry)
-
- This can mostly be optimized away, so that the usual path is a
- load followed by a test and branch. _Jv_ResolvePoolEntry is
- only called once for each constant pool entry.
-
- There is an optimization that we don't do: at the start of a
- method, create a local copy of CACHE_ENTRY and use that instead.
-
- */
-
- int cpool_index = alloc_constant_fieldref (output_class, fdecl);
- tree cache_entry = build_fieldref_cache_entry (cpool_index, fdecl);
- tree test
- = build_call_expr (builtin_decl_implicit (BUILT_IN_EXPECT), 2,
- build2 (EQ_EXPR, boolean_type_node,
- cache_entry, null_pointer_node),
- boolean_false_node);
- tree cpool_index_cst = build_int_cst (NULL_TREE, cpool_index);
- tree init
- = build_call_expr (soft_resolvepoolentry_node, 2,
- build_class_ref (output_class),
- cpool_index_cst);
- init = build2 (MODIFY_EXPR, ptr_type_node, cache_entry, init);
- init = build3 (COND_EXPR, ptr_type_node, test, init, cache_entry);
- init = fold_convert (build_pointer_type (TREE_TYPE (fdecl)), init);
- fdecl = build1 (INDIRECT_REF, TREE_TYPE (fdecl), init);
- }
- return fdecl;
-}
-
-int
-get_access_flags_from_decl (tree decl)
-{
- int access_flags = 0;
- if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
- {
- if (FIELD_STATIC (decl))
- access_flags |= ACC_STATIC;
- if (FIELD_PUBLIC (decl))
- access_flags |= ACC_PUBLIC;
- if (FIELD_PROTECTED (decl))
- access_flags |= ACC_PROTECTED;
- if (FIELD_PRIVATE (decl))
- access_flags |= ACC_PRIVATE;
- if (FIELD_FINAL (decl))
- access_flags |= ACC_FINAL;
- if (FIELD_VOLATILE (decl))
- access_flags |= ACC_VOLATILE;
- if (FIELD_TRANSIENT (decl))
- access_flags |= ACC_TRANSIENT;
- if (FIELD_ENUM (decl))
- access_flags |= ACC_ENUM;
- if (FIELD_SYNTHETIC (decl))
- access_flags |= ACC_SYNTHETIC;
- return access_flags;
- }
- if (TREE_CODE (decl) == TYPE_DECL)
- {
- if (CLASS_PUBLIC (decl))
- access_flags |= ACC_PUBLIC;
- if (CLASS_FINAL (decl))
- access_flags |= ACC_FINAL;
- if (CLASS_SUPER (decl))
- access_flags |= ACC_SUPER;
- if (CLASS_INTERFACE (decl))
- access_flags |= ACC_INTERFACE;
- if (CLASS_ABSTRACT (decl))
- access_flags |= ACC_ABSTRACT;
- if (CLASS_STATIC (decl))
- access_flags |= ACC_STATIC;
- if (CLASS_PRIVATE (decl))
- access_flags |= ACC_PRIVATE;
- if (CLASS_PROTECTED (decl))
- access_flags |= ACC_PROTECTED;
- if (CLASS_STRICTFP (decl))
- access_flags |= ACC_STRICT;
- if (CLASS_ENUM (decl))
- access_flags |= ACC_ENUM;
- if (CLASS_SYNTHETIC (decl))
- access_flags |= ACC_SYNTHETIC;
- if (CLASS_ANNOTATION (decl))
- access_flags |= ACC_ANNOTATION;
- return access_flags;
- }
- if (TREE_CODE (decl) == FUNCTION_DECL)
- {
- if (METHOD_PUBLIC (decl))
- access_flags |= ACC_PUBLIC;
- if (METHOD_PRIVATE (decl))
- access_flags |= ACC_PRIVATE;
- if (METHOD_PROTECTED (decl))
- access_flags |= ACC_PROTECTED;
- if (METHOD_STATIC (decl))
- access_flags |= ACC_STATIC;
- if (METHOD_FINAL (decl))
- access_flags |= ACC_FINAL;
- if (METHOD_SYNCHRONIZED (decl))
- access_flags |= ACC_SYNCHRONIZED;
- if (METHOD_NATIVE (decl))
- access_flags |= ACC_NATIVE;
- if (METHOD_ABSTRACT (decl))
- access_flags |= ACC_ABSTRACT;
- if (METHOD_STRICTFP (decl))
- access_flags |= ACC_STRICT;
- if (METHOD_INVISIBLE (decl))
- access_flags |= ACC_INVISIBLE;
- if (DECL_ARTIFICIAL (decl))
- access_flags |= ACC_SYNTHETIC;
- if (METHOD_BRIDGE (decl))
- access_flags |= ACC_BRIDGE;
- if (METHOD_VARARGS (decl))
- access_flags |= ACC_VARARGS;
- return access_flags;
- }
- gcc_unreachable ();
-}
-
-static GTY (()) int alias_labelno = 0;
-
-/* Create a private alias for METHOD. Using this alias instead of the method
- decl ensures that ncode entries in the method table point to the real function
- at runtime, not a PLT entry. */
-
-static tree
-make_local_function_alias (tree method)
-{
-#ifdef ASM_OUTPUT_DEF
- tree alias;
-
- const char *method_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method));
- char *name = (char *) alloca (strlen (method_name) + 2);
- char *buf = (char *) alloca (strlen (method_name) + 128);
-
- /* Only create aliases for local functions. */
- if (DECL_EXTERNAL (method))
- return method;
-
- /* Prefix method_name with 'L' for the alias label. */
- *name = 'L';
- strcpy (name + 1, method_name);
-
- targetm.asm_out.generate_internal_label (buf, name, alias_labelno++);
- alias = build_decl (input_location,
- FUNCTION_DECL, get_identifier (buf),
- TREE_TYPE (method));
- DECL_CONTEXT (alias) = NULL;
- TREE_READONLY (alias) = TREE_READONLY (method);
- TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (method);
- TREE_PUBLIC (alias) = 0;
- DECL_EXTERNAL (alias) = 0;
- DECL_ARTIFICIAL (alias) = 1;
- DECL_INITIAL (alias) = error_mark_node;
- TREE_ADDRESSABLE (alias) = 1;
- TREE_USED (alias) = 1;
- if (!flag_syntax_only)
- assemble_alias (alias, DECL_ASSEMBLER_NAME (method));
- return alias;
-#else
- return method;
-#endif
-}
-
-/** Make reflection data (_Jv_Field) for field FDECL. */
-
-static tree
-make_field_value (tree fdecl)
-{
- tree finit;
- int flags;
- tree type = TREE_TYPE (fdecl);
- int resolved = is_compiled_class (type) && ! flag_indirect_dispatch;
- vec<constructor_elt, va_gc> *v = NULL;
-
- START_RECORD_CONSTRUCTOR (v, field_type_node);
- PUSH_FIELD_VALUE (v, "name", build_utf8_ref (DECL_NAME (fdecl)));
- if (resolved)
- type = build_class_ref (type);
- else
- {
- tree signature = build_java_signature (type);
-
- type = build_utf8_ref (unmangle_classname
- (IDENTIFIER_POINTER (signature),
- IDENTIFIER_LENGTH (signature)));
- }
- PUSH_FIELD_VALUE (v, "type", type);
-
- flags = get_access_flags_from_decl (fdecl);
- if (! resolved)
- flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
-
- PUSH_FIELD_VALUE (v, "accflags", build_int_cst (NULL_TREE, flags));
- PUSH_FIELD_VALUE (v, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
-
- {
- tree field_address = integer_zero_node;
- tree index, value;
- if ((DECL_INITIAL (fdecl) || ! flag_indirect_classes)
- && FIELD_STATIC (fdecl))
- field_address = build_address_of (fdecl);
-
- index = (FIELD_STATIC (fdecl)
- ? DECL_CHAIN (TYPE_FIELDS (field_info_union_node))
- : TYPE_FIELDS (field_info_union_node));
- value = (FIELD_STATIC (fdecl)
- ? field_address
- : byte_position (fdecl));
-
- PUSH_FIELD_VALUE
- (v, "info",
- build_constructor_single (field_info_union_node, index, value));
- }
-
- FINISH_RECORD_CONSTRUCTOR (finit, v, field_type_node);
- return finit;
-}
-
-/** Make reflection data (_Jv_Method) for method MDECL. */
-
-static tree
-make_method_value (tree mdecl)
-{
- static int method_name_count = 0;
- tree minit;
- tree index;
- tree code;
- tree class_decl;
-#define ACC_TRANSLATED 0x4000
- int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
- vec<constructor_elt, va_gc> *v = NULL;
-
- class_decl = DECL_CONTEXT (mdecl);
- /* For interfaces, the index field contains the dispatch index. */
- if (CLASS_INTERFACE (TYPE_NAME (class_decl)))
- index = build_int_cst (NULL_TREE,
- get_interface_method_index (mdecl, class_decl));
- else if (!flag_indirect_dispatch && get_method_index (mdecl) != NULL_TREE)
- index = get_method_index (mdecl);
- else
- index = integer_minus_one_node;
-
- code = null_pointer_node;
- if (METHOD_ABSTRACT (mdecl))
- code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
- soft_abstractmethod_node);
- else
- code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
- make_local_function_alias (mdecl));
- START_RECORD_CONSTRUCTOR (v, method_type_node);
- PUSH_FIELD_VALUE (v, "name",
- build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
- init_identifier_node
- : DECL_NAME (mdecl)));
- {
- tree signature = build_java_signature (TREE_TYPE (mdecl));
- PUSH_FIELD_VALUE (v, "signature",
- (build_utf8_ref
- (unmangle_classname
- (IDENTIFIER_POINTER(signature),
- IDENTIFIER_LENGTH(signature)))));
- }
- PUSH_FIELD_VALUE (v, "accflags", build_int_cst (NULL_TREE, accflags));
- PUSH_FIELD_VALUE (v, "index", index);
- PUSH_FIELD_VALUE (v, "ncode", code);
-
- {
- /* Compute the `throws' information for the method. */
- tree table = null_pointer_node;
-
- if (!vec_safe_is_empty (DECL_FUNCTION_THROWS (mdecl)))
- {
- int length = 1 + DECL_FUNCTION_THROWS (mdecl)->length ();
- tree t, type, array;
- char buf[60];
- vec<constructor_elt, va_gc> *v = NULL;
- int idx = length - 1;
- unsigned ix;
- constructor_elt *e;
-
- vec_alloc (v, length);
- v->quick_grow_cleared (length);
-
- e = &(*v)[idx--];
- e->value = null_pointer_node;
-
- FOR_EACH_VEC_SAFE_ELT (DECL_FUNCTION_THROWS (mdecl), ix, t)
- {
- tree sig = DECL_NAME (TYPE_NAME (t));
- tree utf8
- = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
- IDENTIFIER_LENGTH (sig)));
- e = &(*v)[idx--];
- e->value = utf8;
- }
- gcc_assert (idx == -1);
- type = build_prim_array_type (ptr_type_node, length);
- table = build_constructor (type, v);
- /* Compute something unique enough. */
- sprintf (buf, "_methods%d", method_name_count++);
- array = build_decl (input_location,
- VAR_DECL, get_identifier (buf), type);
- DECL_INITIAL (array) = table;
- TREE_STATIC (array) = 1;
- DECL_ARTIFICIAL (array) = 1;
- DECL_IGNORED_P (array) = 1;
- rest_of_decl_compilation (array, 1, 0);
-
- table = build1 (ADDR_EXPR, ptr_type_node, array);
- }
-
- PUSH_FIELD_VALUE (v, "throws", table);
- }
-
- FINISH_RECORD_CONSTRUCTOR (minit, v, method_type_node);
- return minit;
-}
-
-static tree
-get_dispatch_vector (tree type)
-{
- tree vtable = TYPE_VTABLE (type);
-
- if (vtable == NULL_TREE)
- {
- HOST_WIDE_INT i;
- tree method;
- tree super = CLASSTYPE_SUPER (type);
- HOST_WIDE_INT nvirtuals = tree_to_shwi (TYPE_NVIRTUALS (type));
- vtable = make_tree_vec (nvirtuals);
- TYPE_VTABLE (type) = vtable;
- if (super != NULL_TREE)
- {
- tree super_vtable = get_dispatch_vector (super);
-
- for (i = tree_to_shwi (TYPE_NVIRTUALS (super)); --i >= 0; )
- TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
- }
-
- for (method = TYPE_METHODS (type); method != NULL_TREE;
- method = DECL_CHAIN (method))
- {
- tree method_index = get_method_index (method);
- if (method_index != NULL_TREE
- && tree_fits_shwi_p (method_index))
- TREE_VEC_ELT (vtable, tree_to_shwi (method_index)) = method;
- }
- }
-
- return vtable;
-}
-
-static tree
-get_dispatch_table (tree type, tree this_class_addr)
-{
- int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
- tree vtable = get_dispatch_vector (type);
- int i, j;
- int nvirtuals = TREE_VEC_LENGTH (vtable);
- int arraysize;
- tree gc_descr;
- vec<constructor_elt, va_gc> *v = NULL;
- constructor_elt *e;
- tree arraytype;
-
- arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
- if (TARGET_VTABLE_USES_DESCRIPTORS)
- arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
- arraysize += 2;
-
- vec_safe_grow_cleared (v, arraysize);
- e = &(*v)[arraysize - 1];
-
-#define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
- for (i = nvirtuals; --i >= 0; )
- {
- tree method = TREE_VEC_ELT (vtable, i);
- if (METHOD_ABSTRACT (method))
- {
- if (! abstract_p)
- warning_at (DECL_SOURCE_LOCATION (method), 0,
- "abstract method in non-abstract class");
-
- if (TARGET_VTABLE_USES_DESCRIPTORS)
- for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
- CONSTRUCTOR_PREPEND_VALUE (e, null_pointer_node);
- else
- CONSTRUCTOR_PREPEND_VALUE (e, null_pointer_node);
- }
- else
- {
- if (TARGET_VTABLE_USES_DESCRIPTORS)
- for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
- {
- tree fdesc = build2 (FDESC_EXPR, nativecode_ptr_type_node,
- method, build_int_cst (NULL_TREE, j));
- TREE_CONSTANT (fdesc) = 1;
- CONSTRUCTOR_PREPEND_VALUE (e, fdesc);
- }
- else
- CONSTRUCTOR_PREPEND_VALUE (e,
- build1 (ADDR_EXPR,
- nativecode_ptr_type_node,
- method));
- }
- }
-
- /* Dummy entry for compatibility with G++ -fvtable-thunks. When
- using the Boehm GC we sometimes stash a GC type descriptor
- there. We set the PURPOSE to NULL_TREE not to interfere (reset)
- the emitted byte count during the output to the assembly file. */
- /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
- fake "function descriptor". It's first word is the is the class
- pointer, and subsequent words (usually one) contain the GC descriptor.
- In all other cases, we reserve two extra vtable slots. */
- gc_descr = get_boehm_type_descriptor (type);
- CONSTRUCTOR_PREPEND_VALUE (e, gc_descr);
- for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
- CONSTRUCTOR_PREPEND_VALUE (e, gc_descr);
- CONSTRUCTOR_PREPEND_VALUE (e, this_class_addr);
-
- /** Pointer to type_info object (to be implemented), according to g++ ABI. */
- CONSTRUCTOR_PREPEND_VALUE (e, null_pointer_node);
- /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */
- gcc_assert (e == v->address ());
- e->index = integer_zero_node;
- e->value = null_pointer_node;
-#undef CONSTRUCTOR_PREPEND_VALUE
-
- arraytype = build_prim_array_type (nativecode_ptr_type_node, arraysize);
- return build_constructor (arraytype, v);
-}
-
-
-/* Set the method_index for a method decl. */
-void
-set_method_index (tree decl, tree method_index)
-{
- if (method_index != NULL_TREE)
- {
- /* method_index is null if we're using indirect dispatch. */
- method_index = fold (convert (sizetype, method_index));
-
- if (TARGET_VTABLE_USES_DESCRIPTORS)
- /* Add one to skip bogus descriptor for class and GC descriptor. */
- method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
- else
- /* Add 1 to skip "class" field of dtable, and 1 to skip GC
- descriptor. */
- method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
- }
-
- DECL_VINDEX (decl) = method_index;
-}
-
-/* Get the method_index for a method decl. */
-tree
-get_method_index (tree decl)
-{
- tree method_index = DECL_VINDEX (decl);
-
- if (! method_index)
- return NULL;
-
- if (TARGET_VTABLE_USES_DESCRIPTORS)
- /* Sub one to skip bogus descriptor for class and GC descriptor. */
- method_index = size_binop (MINUS_EXPR, method_index, size_int (1));
- else
- /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
- method_index = size_binop (MINUS_EXPR, method_index, size_int (2));
-
- return method_index;
-}
-
-static int
-supers_all_compiled (tree type)
-{
- while (type != NULL_TREE)
- {
- if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
- return 0;
- type = CLASSTYPE_SUPER (type);
- }
- return 1;
-}
-
-static void
-add_table_and_syms (vec<constructor_elt, va_gc> **v,
- vec<method_entry, va_gc> *methods,
- const char *table_name, tree table_slot, tree table_type,
- const char *syms_name, tree syms_slot)
-{
- if (methods == NULL)
- {
- PUSH_FIELD_VALUE (*v, table_name, null_pointer_node);
- PUSH_FIELD_VALUE (*v, syms_name, null_pointer_node);
- }
- else
- {
- pushdecl_top_level (syms_slot);
- PUSH_FIELD_VALUE (*v, table_name,
- build1 (ADDR_EXPR, table_type, table_slot));
- PUSH_FIELD_VALUE (*v, syms_name,
- build1 (ADDR_EXPR, symbols_array_ptr_type,
- syms_slot));
- TREE_CONSTANT (table_slot) = 1;
- }
-}
-
-void
-make_class_data (tree type)
-{
- tree decl, cons, temp;
- tree field, fields_decl;
- HOST_WIDE_INT static_field_count = 0;
- HOST_WIDE_INT instance_field_count = 0;
- HOST_WIDE_INT field_count;
- tree field_array_type;
- tree method;
- tree dtable_decl = NULL_TREE;
- HOST_WIDE_INT method_count = 0;
- tree method_array_type;
- tree methods_decl;
- tree super;
- tree this_class_addr;
- tree constant_pool_constructor;
- tree interfaces = null_pointer_node;
- int interface_len = 0;
- int uses_jv_markobj = 0;
- tree type_decl = TYPE_NAME (type);
- tree id_main = get_identifier("main");
- tree id_class = get_identifier("java.lang.Class");
- /** Offset from start of virtual function table declaration
- to where objects actually point at, following new g++ ABI. */
- tree dtable_start_offset = size_int (2 * POINTER_SIZE / BITS_PER_UNIT);
- vec<int> field_indexes;
- tree first_real_field;
- vec<constructor_elt, va_gc> *v1 = NULL, *v2 = NULL;
- tree reflection_data;
- vec<constructor_elt, va_gc> *static_fields = NULL;
- vec<constructor_elt, va_gc> *instance_fields = NULL;
- vec<constructor_elt, va_gc> *methods = NULL;
-
- this_class_addr = build_static_class_ref (type);
- decl = TREE_OPERAND (this_class_addr, 0);
-
- if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
- && !flag_indirect_dispatch)
- {
- tree dtable = get_dispatch_table (type, this_class_addr);
- uses_jv_markobj = uses_jv_markobj_p (dtable);
- if (type == class_type_node && class_dtable_decl != NULL_TREE)
- {
- /* We've already created some other class, and consequently
- we made class_dtable_decl. Now we just want to fill it
- in. */
- dtable_decl = class_dtable_decl;
- }
- else
- {
- dtable_decl = build_dtable_decl (type);
- TREE_STATIC (dtable_decl) = 1;
- DECL_ARTIFICIAL (dtable_decl) = 1;
- DECL_IGNORED_P (dtable_decl) = 1;
- }
-
- TREE_PUBLIC (dtable_decl) = 1;
- DECL_INITIAL (dtable_decl) = dtable;
- /* The only dispatch table exported from a DSO is the dispatch
- table for java.lang.Class. */
- if (DECL_NAME (type_decl) != id_class)
- java_hide_decl (dtable_decl);
- if (! flag_indirect_classes)
- rest_of_decl_compilation (dtable_decl, 1, 0);
- /* Maybe we're compiling Class as the first class. If so, set
- class_dtable_decl to the decl we just made. */
- if (type == class_type_node && class_dtable_decl == NULL_TREE)
- class_dtable_decl = dtable_decl;
- }
-
- /* Build Field array. */
- field = TYPE_FIELDS (type);
- while (field && DECL_ARTIFICIAL (field))
- field = DECL_CHAIN (field); /* Skip dummy fields. */
- if (field && DECL_NAME (field) == NULL_TREE)
- field = DECL_CHAIN (field); /* Skip dummy field for inherited data. */
- first_real_field = field;
-
- /* First count static and instance fields. */
- for ( ; field != NULL_TREE; field = DECL_CHAIN (field))
- {
- if (! DECL_ARTIFICIAL (field))
- {
- if (FIELD_STATIC (field))
- static_field_count++;
- else if (uses_jv_markobj || !flag_reduced_reflection)
- instance_field_count++;
- }
- }
- field_count = static_field_count + instance_field_count;
- field_indexes.create (field_count);
-
- /* gcj sorts fields so that static fields come first, followed by
- instance fields. Unfortunately, by the time this takes place we
- have already generated the reflection_data for this class, and
- that data contains indexes into the fields. So, we generate a
- permutation that maps each original field index to its final
- position. Then we pass this permutation to
- rewrite_reflection_indexes(), which fixes up the reflection
- data. */
- {
- int i;
- int static_count = 0;
- int instance_count = static_field_count;
- int field_index;
-
- for (i = 0, field = first_real_field;
- field != NULL_TREE;
- field = DECL_CHAIN (field), i++)
- {
- if (! DECL_ARTIFICIAL (field))
- {
- field_index = 0;
- if (FIELD_STATIC (field))
- field_index = static_count++;
- else if (uses_jv_markobj || !flag_reduced_reflection)
- field_index = instance_count++;
- else
- continue;
- field_indexes.quick_push (field_index);
- }
- }
- }
-
- for (field = first_real_field; field != NULL_TREE;
- field = DECL_CHAIN (field))
- {
- if (! DECL_ARTIFICIAL (field))
- {
- if (FIELD_STATIC (field))
- {
- /* We must always create reflection data for static fields
- as it is used in the creation of the field itself. */
- tree init = make_field_value (field);
- tree initial = DECL_INITIAL (field);
- CONSTRUCTOR_APPEND_ELT (static_fields, NULL_TREE, init);
- /* If the initial value is a string constant,
- prevent output_constant from trying to assemble the value. */
- if (initial != NULL_TREE
- && TREE_TYPE (initial) == string_ptr_type_node)
- DECL_INITIAL (field) = NULL_TREE;
- rest_of_decl_compilation (field, 1, 1);
- DECL_INITIAL (field) = initial;
- }
- else if (uses_jv_markobj || !flag_reduced_reflection)
- {
- tree init = make_field_value (field);
- CONSTRUCTOR_APPEND_ELT (instance_fields, NULL_TREE, init);
- }
- }
- }
-
- gcc_assert (static_field_count == (int) vec_safe_length (static_fields));
- gcc_assert (instance_field_count == (int) vec_safe_length (instance_fields));
-
- if (field_count > 0)
- {
- vec_safe_splice (static_fields, instance_fields);
- field_array_type = build_prim_array_type (field_type_node, field_count);
- fields_decl = build_decl (input_location,
- VAR_DECL, mangled_classname ("_FL_", type),
- field_array_type);
- DECL_INITIAL (fields_decl)
- = build_constructor (field_array_type, static_fields);
- TREE_STATIC (fields_decl) = 1;
- DECL_ARTIFICIAL (fields_decl) = 1;
- DECL_IGNORED_P (fields_decl) = 1;
- rest_of_decl_compilation (fields_decl, 1, 0);
- }
- else
- fields_decl = NULL_TREE;
-
- /* Build Method array. */
- for (method = TYPE_METHODS (type);
- method != NULL_TREE; method = DECL_CHAIN (method))
- {
- tree init;
- if (METHOD_PRIVATE (method)
- && ! flag_keep_inline_functions
- && optimize)
- continue;
- /* Even if we have a decl, we don't necessarily have the code.
- This can happen if we inherit a method from a superclass for
- which we don't have a .class file. */
- if (METHOD_DUMMY (method))
- continue;
-
- /* Generate method reflection data if:
-
- - !flag_reduced_reflection.
-
- - <clinit> -- The runtime uses reflection to initialize the
- class.
-
- - Any method in class java.lang.Class -- Class.forName() and
- perhaps other things require it.
-
- - class$ -- It does not work if reflection data missing.
-
- - main -- Reflection is used to find main(String[]) methods.
-
- - public not static -- It is potentially part of an
- interface. The runtime uses reflection data to build
- interface dispatch tables. */
- if (!flag_reduced_reflection
- || DECL_CLINIT_P (method)
- || DECL_NAME (type_decl) == id_class
- || DECL_NAME (method) == id_main
- || (METHOD_PUBLIC (method) && !METHOD_STATIC (method)))
- {
- init = make_method_value (method);
- method_count++;
- CONSTRUCTOR_APPEND_ELT (methods, NULL_TREE, init);
- }
- }
- method_array_type = build_prim_array_type (method_type_node, method_count);
- methods_decl = build_decl (input_location,
- VAR_DECL, mangled_classname ("_MT_", type),
- method_array_type);
- DECL_INITIAL (methods_decl) = build_constructor (method_array_type, methods);
- TREE_STATIC (methods_decl) = 1;
- DECL_ARTIFICIAL (methods_decl) = 1;
- DECL_IGNORED_P (methods_decl) = 1;
- rest_of_decl_compilation (methods_decl, 1, 0);
-
- if (class_dtable_decl == NULL_TREE)
- {
- class_dtable_decl = build_dtable_decl (class_type_node);
- TREE_STATIC (class_dtable_decl) = 1;
- DECL_ARTIFICIAL (class_dtable_decl) = 1;
- DECL_IGNORED_P (class_dtable_decl) = 1;
- if (is_compiled_class (class_type_node) != 2)
- {
- DECL_EXTERNAL (class_dtable_decl) = 1;
- rest_of_decl_compilation (class_dtable_decl, 1, 0);
- }
- }
-
- super = CLASSTYPE_SUPER (type);
- if (super == NULL_TREE)
- super = null_pointer_node;
- else if (! flag_indirect_dispatch
- && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
- && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
- super = build_class_ref (super);
- else
- {
- int super_index = alloc_class_constant (super);
- super = build_int_cst (ptr_type_node, super_index);
- }
-
- /* Build and emit the array of implemented interfaces. */
- if (type != object_type_node)
- interface_len = BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) - 1;
-
- if (interface_len > 0)
- {
- int i;
- tree interface_array_type, idecl;
- vec<constructor_elt, va_gc> *init;
- vec_alloc (init, interface_len);
- interface_array_type
- = build_prim_array_type (class_ptr_type, interface_len);
- idecl = build_decl (input_location,
- VAR_DECL, mangled_classname ("_IF_", type),
- interface_array_type);
-
- for (i = 1; i <= interface_len; i++)
- {
- tree child = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
- tree iclass = BINFO_TYPE (child);
- tree index;
- if (! flag_indirect_dispatch
- && (assume_compiled
- (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))))
- index = build_class_ref (iclass);
- else
- {
- int int_index = alloc_class_constant (iclass);
- index = build_int_cst (ptr_type_node, int_index);
- }
- CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, index);
- }
- DECL_INITIAL (idecl) = build_constructor (interface_array_type, init);
- TREE_STATIC (idecl) = 1;
- DECL_ARTIFICIAL (idecl) = 1;
- DECL_IGNORED_P (idecl) = 1;
- interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
- rest_of_decl_compilation (idecl, 1, 0);
- }
-
- constant_pool_constructor = build_constants_constructor ();
-
- if (flag_indirect_dispatch)
- {
- TYPE_OTABLE_DECL (type)
- = emit_symbol_table
- (DECL_NAME (TYPE_OTABLE_DECL (type)),
- TYPE_OTABLE_DECL (type), TYPE_OTABLE_METHODS (type),
- TYPE_OTABLE_SYMS_DECL (type), integer_type_node, 1);
-
- TYPE_ATABLE_DECL (type)
- = emit_symbol_table
- (DECL_NAME (TYPE_ATABLE_DECL (type)),
- TYPE_ATABLE_DECL (type), TYPE_ATABLE_METHODS (type),
- TYPE_ATABLE_SYMS_DECL (type), ptr_type_node, 1);
-
- TYPE_ITABLE_DECL (type)
- = emit_symbol_table
- (DECL_NAME (TYPE_ITABLE_DECL (type)),
- TYPE_ITABLE_DECL (type), TYPE_ITABLE_METHODS (type),
- TYPE_ITABLE_SYMS_DECL (type), ptr_type_node, 2);
- }
-
- TYPE_CTABLE_DECL (type) = emit_catch_table (type);
-
- START_RECORD_CONSTRUCTOR (v1, object_type_node);
- PUSH_FIELD_VALUE (v1, "vtable",
- (flag_indirect_classes
- ? null_pointer_node
- : fold_build_pointer_plus
- (build1 (ADDR_EXPR, dtable_ptr_type,
- class_dtable_decl),
- dtable_start_offset)));
- if (! flag_hash_synchronization)
- PUSH_FIELD_VALUE (v1, "sync_info", null_pointer_node);
- FINISH_RECORD_CONSTRUCTOR (temp, v1, object_type_node);
- START_RECORD_CONSTRUCTOR (v2, class_type_node);
- PUSH_SUPER_VALUE (v2, temp);
- PUSH_FIELD_VALUE (v2, "next_or_version", gcj_abi_version);
- PUSH_FIELD_VALUE (v2, "name", build_utf8_ref (DECL_NAME (type_decl)));
- PUSH_FIELD_VALUE (v2, "accflags",
- build_int_cst (NULL_TREE,
- get_access_flags_from_decl (type_decl)));
-
- PUSH_FIELD_VALUE (v2, "superclass",
- CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
- PUSH_FIELD_VALUE (v2, "constants", constant_pool_constructor);
- PUSH_FIELD_VALUE (v2, "methods",
- methods_decl == NULL_TREE ? null_pointer_node
- : build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
- PUSH_FIELD_VALUE (v2, "method_count",
- build_int_cst (NULL_TREE, method_count));
-
- PUSH_FIELD_VALUE (v2, "vtable_method_count",
- (flag_indirect_dispatch
- ? integer_minus_one_node
- : TYPE_NVIRTUALS (type)));
-
- PUSH_FIELD_VALUE (v2, "fields",
- fields_decl == NULL_TREE ? null_pointer_node
- : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
- /* If we're using the binary compatibility ABI we don't know the
- size until load time. */
- PUSH_FIELD_VALUE (v2, "size_in_bytes",
- (flag_indirect_dispatch
- ? integer_minus_one_node
- : size_in_bytes (type)));
- PUSH_FIELD_VALUE (v2, "field_count",
- build_int_cst (NULL_TREE, field_count));
- PUSH_FIELD_VALUE (v2, "static_field_count",
- build_int_cst (NULL_TREE, static_field_count));
-
- PUSH_FIELD_VALUE (v2, "vtable",
- (flag_indirect_dispatch || dtable_decl == NULL_TREE
- ? null_pointer_node
- : fold_build_pointer_plus
- (build1 (ADDR_EXPR, dtable_ptr_type,
- dtable_decl),
- dtable_start_offset)));
- add_table_and_syms (&v2, TYPE_OTABLE_METHODS (type),
- "otable", TYPE_OTABLE_DECL (type), otable_ptr_type,
- "otable_syms", TYPE_OTABLE_SYMS_DECL (type));
- add_table_and_syms (&v2, TYPE_ATABLE_METHODS (type),
- "atable", TYPE_ATABLE_DECL (type), atable_ptr_type,
- "atable_syms", TYPE_ATABLE_SYMS_DECL (type));
- add_table_and_syms (&v2, TYPE_ITABLE_METHODS (type),
- "itable", TYPE_ITABLE_DECL (type), itable_ptr_type,
- "itable_syms", TYPE_ITABLE_SYMS_DECL (type));
-
- PUSH_FIELD_VALUE (v2, "catch_classes",
- build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
- PUSH_FIELD_VALUE (v2, "interfaces", interfaces);
- PUSH_FIELD_VALUE (v2, "loader", null_pointer_node);
- PUSH_FIELD_VALUE (v2, "interface_count",
- build_int_cst (NULL_TREE, interface_len));
- PUSH_FIELD_VALUE (v2, "state",
- convert (byte_type_node,
- build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
-
- PUSH_FIELD_VALUE (v2, "thread", null_pointer_node);
- PUSH_FIELD_VALUE (v2, "depth", integer_zero_node);
- PUSH_FIELD_VALUE (v2, "ancestors", null_pointer_node);
- PUSH_FIELD_VALUE (v2, "idt", null_pointer_node);
- PUSH_FIELD_VALUE (v2, "arrayclass", null_pointer_node);
- PUSH_FIELD_VALUE (v2, "protectionDomain", null_pointer_node);
-
- {
- tree assertion_table_ref;
- if (TYPE_ASSERTIONS (type) == NULL)
- assertion_table_ref = null_pointer_node;
- else
- assertion_table_ref = build1 (ADDR_EXPR,
- build_pointer_type (assertion_table_type),
- emit_assertion_table (type));
-
- PUSH_FIELD_VALUE (v2, "assertion_table", assertion_table_ref);
- }
-
- PUSH_FIELD_VALUE (v2, "hack_signers", null_pointer_node);
- PUSH_FIELD_VALUE (v2, "chain", null_pointer_node);
- PUSH_FIELD_VALUE (v2, "aux_info", null_pointer_node);
- PUSH_FIELD_VALUE (v2, "engine", null_pointer_node);
-
- if (TYPE_REFLECTION_DATA (current_class))
- {
- int i;
- int count = TYPE_REFLECTION_DATASIZE (current_class);
- vec<constructor_elt, va_gc> *v;
- vec_alloc (v, count);
- unsigned char *data = TYPE_REFLECTION_DATA (current_class);
- tree max_index = build_int_cst (sizetype, count);
- tree index = build_index_type (max_index);
- tree type = build_array_type (unsigned_byte_type_node, index);
- char buf[64];
- tree array;
- static int reflection_data_count;
-
- sprintf (buf, "_reflection_data_%d", reflection_data_count++);
- array = build_decl (input_location,
- VAR_DECL, get_identifier (buf), type);
-
- rewrite_reflection_indexes (&field_indexes);
-
- for (i = 0; i < count; i++)
- {
- constructor_elt elt;
- elt.index = build_int_cst (sizetype, i);
- elt.value = build_int_cstu (byte_type_node, data[i]);
- v->quick_push (elt);
- }
-
- DECL_INITIAL (array) = build_constructor (type, v);
- TREE_STATIC (array) = 1;
- DECL_ARTIFICIAL (array) = 1;
- DECL_IGNORED_P (array) = 1;
- TREE_READONLY (array) = 1;
- TREE_CONSTANT (DECL_INITIAL (array)) = 1;
- rest_of_decl_compilation (array, 1, 0);
-
- reflection_data = build_address_of (array);
-
- free (data);
- TYPE_REFLECTION_DATA (current_class) = NULL;
- }
- else
- reflection_data = null_pointer_node;
-
- PUSH_FIELD_VALUE (v2, "reflection_data", reflection_data);
- FINISH_RECORD_CONSTRUCTOR (cons, v2, class_type_node);
-
- DECL_INITIAL (decl) = cons;
-
- /* Hash synchronization requires at least 64-bit alignment. */
- if (flag_hash_synchronization && POINTER_SIZE < 64)
- SET_DECL_ALIGN (decl, 64);
-
- if (flag_indirect_classes)
- {
- TREE_READONLY (decl) = 1;
- TREE_CONSTANT (DECL_INITIAL (decl)) = 1;
- }
-
- rest_of_decl_compilation (decl, 1, 0);
-
- {
- tree classdollar_field = build_classdollar_field (type);
- if (!flag_indirect_classes)
- DECL_INITIAL (classdollar_field) = build_static_class_ref (type);
- rest_of_decl_compilation (classdollar_field, 1, 0);
- }
-
- TYPE_OTABLE_DECL (type) = NULL_TREE;
- TYPE_ATABLE_DECL (type) = NULL_TREE;
- TYPE_CTABLE_DECL (type) = NULL_TREE;
-}
-
-void
-finish_class (void)
-{
- java_expand_catch_classes (current_class);
-
- current_function_decl = NULL_TREE;
- TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class)) = 0;
- make_class_data (current_class);
- register_class ();
- rest_of_decl_compilation (TYPE_NAME (current_class), 1, 0);
-}
-
-/* Return 2 if KLASS is compiled by this compilation job;
- return 1 if KLASS can otherwise be assumed to be compiled;
- return 0 if we cannot assume that KLASS is compiled.
- Returns 1 for primitive and 0 for array types. */
-int
-is_compiled_class (tree klass)
-{
- int seen_in_zip;
- if (TREE_CODE (klass) == POINTER_TYPE)
- klass = TREE_TYPE (klass);
- if (TREE_CODE (klass) != RECORD_TYPE) /* Primitive types are static. */
- return 1;
- if (TYPE_ARRAY_P (klass))
- return 0;
-
- seen_in_zip = (TYPE_JCF (klass) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass)));
- if (CLASS_FROM_CURRENTLY_COMPILED_P (klass))
- {
- /* The class was seen in the current ZIP file and will be
- available as a compiled class in the future but may not have
- been loaded already. Load it if necessary. This prevent
- build_class_ref () from crashing. */
-
- if (seen_in_zip && !CLASS_LOADED_P (klass) && (klass != current_class))
- load_class (klass, 1);
-
- /* We return 2 for class seen in ZIP and class from files
- belonging to the same compilation unit */
- return 2;
- }
-
- if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass)))))
- {
- if (!CLASS_LOADED_P (klass))
- {
- if (klass != current_class)
- load_class (klass, 1);
- }
- return 1;
- }
-
- return 0;
-}
-
-/* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
-
-tree
-build_dtable_decl (tree type)
-{
- tree dtype, decl;
-
- /* We need to build a new dtable type so that its size is uniquely
- computed when we're dealing with the class for real and not just
- faking it (like java.lang.Class during the initialization of the
- compiler.) We know we're not faking a class when CURRENT_CLASS is
- TYPE. */
- if (current_class == type)
- {
- tree dummy = NULL_TREE;
- int n;
-
- dtype = make_node (RECORD_TYPE);
-
- PUSH_FIELD (input_location, dtype, dummy, "top_offset", ptr_type_node);
- PUSH_FIELD (input_location, dtype, dummy, "type_info", ptr_type_node);
-
- PUSH_FIELD (input_location, dtype, dummy, "class", class_ptr_type);
- for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
- {
- tree tmp_field = build_decl (input_location,
- FIELD_DECL, NULL_TREE, ptr_type_node);
- TREE_CHAIN (dummy) = tmp_field;
- DECL_CONTEXT (tmp_field) = dtype;
- DECL_ARTIFICIAL (tmp_field) = 1;
- dummy = tmp_field;
- }
-
- PUSH_FIELD (input_location, dtype, dummy, "gc_descr", ptr_type_node);
- for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
- {
- tree tmp_field = build_decl (input_location,
- FIELD_DECL, NULL_TREE, ptr_type_node);
- TREE_CHAIN (dummy) = tmp_field;
- DECL_CONTEXT (tmp_field) = dtype;
- DECL_ARTIFICIAL (tmp_field) = 1;
- dummy = tmp_field;
- }
-
- n = TREE_VEC_LENGTH (get_dispatch_vector (type));
- if (TARGET_VTABLE_USES_DESCRIPTORS)
- n *= TARGET_VTABLE_USES_DESCRIPTORS;
-
- PUSH_FIELD (input_location, dtype, dummy, "methods",
- build_prim_array_type (nativecode_ptr_type_node, n));
- layout_type (dtype);
- }
- else
- dtype = dtable_type;
-
- decl = build_decl (input_location,
- VAR_DECL, get_identifier ("vt$"), dtype);
- DECL_CONTEXT (decl) = type;
- MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
- DECL_VTABLE_P (decl) = 1;
-
- return decl;
-}
-
-/* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
- fields inherited from SUPER_CLASS. */
-
-void
-push_super_field (tree this_class, tree super_class)
-{
- tree base_decl;
- /* Don't insert the field if we're just re-laying the class out. */
- if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
- return;
- base_decl = build_decl (input_location,
- FIELD_DECL, NULL_TREE, super_class);
- DECL_IGNORED_P (base_decl) = 1;
- DECL_CONTEXT (base_decl) = this_class;
- DECL_CHAIN (base_decl) = TYPE_FIELDS (this_class);
- TYPE_FIELDS (this_class) = base_decl;
- DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
- DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
-}
-
-/* Handle the different manners we may have to lay out a super class. */
-
-static tree
-maybe_layout_super_class (tree super_class, tree this_class ATTRIBUTE_UNUSED)
-{
- if (!super_class)
- return NULL_TREE;
- else if (TREE_CODE (super_class) == RECORD_TYPE)
- {
- if (!CLASS_LOADED_P (super_class))
- load_class (super_class, 1);
- }
- /* We might have to layout the class before its dependency on
- the super class gets resolved by java_complete_class */
- else if (TREE_CODE (super_class) == POINTER_TYPE)
- {
- if (TREE_TYPE (super_class) != NULL_TREE)
- super_class = TREE_TYPE (super_class);
- else
- gcc_unreachable ();
- }
- if (!TYPE_SIZE (super_class))
- safe_layout_class (super_class);
-
- return super_class;
-}
-
-/* safe_layout_class just makes sure that we can load a class without
- disrupting the current_class, input_location, etc, information
- about the class processed currently. */
-
-void
-safe_layout_class (tree klass)
-{
- tree save_current_class = current_class;
- location_t save_location = input_location;
-
- layout_class (klass);
-
- current_class = save_current_class;
- input_location = save_location;
-}
-
-void
-layout_class (tree this_class)
-{
- int i;
- tree super_class = CLASSTYPE_SUPER (this_class);
-
- class_list = tree_cons (this_class, NULL_TREE, class_list);
- if (CLASS_BEING_LAIDOUT (this_class))
- {
- char buffer [1024];
- char *report;
- tree current;
-
- sprintf (buffer, " with '%s'",
- IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
- obstack_grow (&temporary_obstack, buffer, strlen (buffer));
-
- for (current = TREE_CHAIN (class_list); current;
- current = TREE_CHAIN (current))
- {
- tree decl = TYPE_NAME (TREE_PURPOSE (current));
- sprintf (buffer, "\n which inherits from '%s' (%s:%d)",
- IDENTIFIER_POINTER (DECL_NAME (decl)),
- DECL_SOURCE_FILE (decl),
- DECL_SOURCE_LINE (decl));
- obstack_grow (&temporary_obstack, buffer, strlen (buffer));
- }
- obstack_1grow (&temporary_obstack, '\0');
- report = XOBFINISH (&temporary_obstack, char *);
- cyclic_inheritance_report = ggc_strdup (report);
- obstack_free (&temporary_obstack, report);
- TYPE_SIZE (this_class) = error_mark_node;
- return;
- }
- CLASS_BEING_LAIDOUT (this_class) = 1;
-
- if (super_class && !CLASS_BEING_LAIDOUT (super_class))
- {
- tree maybe_super_class
- = maybe_layout_super_class (super_class, this_class);
- if (maybe_super_class == NULL
- || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
- {
- TYPE_SIZE (this_class) = error_mark_node;
- CLASS_BEING_LAIDOUT (this_class) = 0;
- class_list = TREE_CHAIN (class_list);
- return;
- }
- if (TYPE_SIZE (this_class) == NULL_TREE)
- push_super_field (this_class, maybe_super_class);
- }
-
- layout_type (this_class);
-
- /* Also recursively load/layout any superinterfaces. */
- if (TYPE_BINFO (this_class))
- {
- for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class)) - 1; i > 0; i--)
- {
- tree binfo = BINFO_BASE_BINFO (TYPE_BINFO (this_class), i);
- tree super_interface = BINFO_TYPE (binfo);
- tree maybe_super_interface
- = maybe_layout_super_class (super_interface, NULL_TREE);
- if (maybe_super_interface == NULL
- || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
- {
- TYPE_SIZE (this_class) = error_mark_node;
- CLASS_BEING_LAIDOUT (this_class) = 0;
- class_list = TREE_CHAIN (class_list);
- return;
- }
- }
- }
-
- /* Convert the size back to an SI integer value. */
- TYPE_SIZE_UNIT (this_class) =
- fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
-
- CLASS_BEING_LAIDOUT (this_class) = 0;
- class_list = TREE_CHAIN (class_list);
-}
-
-static void
-add_miranda_methods (tree base_class, tree search_class)
-{
- int i;
- tree binfo, base_binfo;
-
- if (!CLASS_PARSED_P (search_class))
- load_class (search_class, 1);
-
- for (binfo = TYPE_BINFO (search_class), i = 1;
- BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
- {
- tree method_decl;
- tree elt = BINFO_TYPE (base_binfo);
-
- /* FIXME: This is totally bogus. We should not be handling
- Miranda methods at all if we're using the BC ABI. */
- if (TYPE_DUMMY (elt))
- continue;
-
- /* Ensure that interface methods are seen in declared order. */
- if (!CLASS_LOADED_P (elt))
- load_class (elt, 1);
- layout_class_methods (elt);
-
- /* All base classes will have been laid out at this point, so the order
- will be correct. This code must match similar layout code in the
- runtime. */
- for (method_decl = TYPE_METHODS (elt);
- method_decl; method_decl = DECL_CHAIN (method_decl))
- {
- tree sig, override;
-
- /* An interface can have <clinit>. */
- if (ID_CLINIT_P (DECL_NAME (method_decl)))
- continue;
-
- sig = build_java_argument_signature (TREE_TYPE (method_decl));
- override = lookup_argument_method (base_class,
- DECL_NAME (method_decl), sig);
- if (override == NULL_TREE)
- {
- /* Found a Miranda method. Add it. */
- tree new_method;
- sig = build_java_signature (TREE_TYPE (method_decl));
- new_method
- = add_method (base_class,
- get_access_flags_from_decl (method_decl),
- DECL_NAME (method_decl), sig);
- METHOD_INVISIBLE (new_method) = 1;
- }
- }
-
- /* Try superinterfaces. */
- add_miranda_methods (base_class, elt);
- }
-}
-
-void
-layout_class_methods (tree this_class)
-{
- tree method_decl, dtable_count;
- tree super_class, type_name;
-
- if (TYPE_NVIRTUALS (this_class))
- return;
-
- super_class = CLASSTYPE_SUPER (this_class);
-
- if (super_class)
- {
- super_class = maybe_layout_super_class (super_class, this_class);
- if (!TYPE_NVIRTUALS (super_class))
- layout_class_methods (super_class);
- dtable_count = TYPE_NVIRTUALS (super_class);
- }
- else
- dtable_count = integer_zero_node;
-
- type_name = TYPE_NAME (this_class);
- if (!flag_indirect_dispatch
- && (CLASS_ABSTRACT (type_name) || CLASS_INTERFACE (type_name)))
- {
- /* An abstract class can have methods which are declared only in
- an implemented interface. These are called "Miranda
- methods". We make a dummy method entry for such methods
- here. */
- add_miranda_methods (this_class, this_class);
- }
-
- TYPE_METHODS (this_class) = nreverse (TYPE_METHODS (this_class));
-
- for (method_decl = TYPE_METHODS (this_class);
- method_decl; method_decl = DECL_CHAIN (method_decl))
- dtable_count = layout_class_method (this_class, super_class,
- method_decl, dtable_count);
-
- TYPE_NVIRTUALS (this_class) = dtable_count;
-}
-
-/* Return the index of METHOD in INTERFACE. This index begins at 1
- and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
-int
-get_interface_method_index (tree method, tree interface)
-{
- tree meth;
- int i = 1;
-
- for (meth = TYPE_METHODS (interface); ; meth = DECL_CHAIN (meth))
- {
- if (meth == method)
- return i;
- /* We don't want to put <clinit> into the interface table. */
- if (! ID_CLINIT_P (DECL_NAME (meth)))
- ++i;
- gcc_assert (meth != NULL_TREE);
- }
-}
-
-/* Lay METHOD_DECL out, returning a possibly new value of
- DTABLE_COUNT. Also mangle the method's name. */
-
-tree
-layout_class_method (tree this_class, tree super_class,
- tree method_decl, tree dtable_count)
-{
- tree method_name = DECL_NAME (method_decl);
-
- TREE_PUBLIC (method_decl) = 1;
-
- if (flag_indirect_classes
- || (METHOD_PRIVATE (method_decl) && METHOD_STATIC (method_decl)
- && ! METHOD_NATIVE (method_decl)
- && ! special_method_p (method_decl)))
- java_hide_decl (method_decl);
-
- /* Considered external unless it is being compiled into this object
- file, or it was already flagged as external. */
- if (!DECL_EXTERNAL (method_decl))
- DECL_EXTERNAL (method_decl) = ((is_compiled_class (this_class) != 2)
- || METHOD_NATIVE (method_decl));
-
- if (ID_INIT_P (method_name))
- {
- const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
- const char *ptr;
- for (ptr = p; *ptr; )
- {
- if (*ptr++ == '.')
- p = ptr;
- }
- DECL_CONSTRUCTOR_P (method_decl) = 1;
- build_java_signature (TREE_TYPE (method_decl));
- }
- else if (! METHOD_STATIC (method_decl))
- {
- tree method_sig =
- build_java_signature (TREE_TYPE (method_decl));
- bool method_override = false;
- tree super_method = lookup_java_method (super_class, method_name,
- method_sig);
- if (super_method != NULL_TREE
- && ! METHOD_DUMMY (super_method))
- {
- method_override = true;
- if (! METHOD_PUBLIC (super_method) &&
- ! METHOD_PROTECTED (super_method))
- {
- /* Don't override private method, or default-access method in
- another package. */
- if (METHOD_PRIVATE (super_method) ||
- ! in_same_package (TYPE_NAME (this_class),
- TYPE_NAME (super_class)))
- method_override = false;
- }
- }
- if (method_override)
- {
- tree method_index = get_method_index (super_method);
- set_method_index (method_decl, method_index);
- if (method_index == NULL_TREE
- && ! flag_indirect_dispatch
- && ! DECL_ARTIFICIAL (super_method))
- error ("non-static method %q+D overrides static method",
- method_decl);
- }
- else if (this_class == object_type_node
- && (METHOD_FINAL (method_decl)
- || METHOD_PRIVATE (method_decl)))
- {
- /* We don't generate vtable entries for final Object
- methods. This is simply to save space, since every
- object would otherwise have to define them. */
- }
- else if (! METHOD_PRIVATE (method_decl)
- && dtable_count)
- {
- /* We generate vtable entries for final methods because they
- may one day be changed to non-final. */
- set_method_index (method_decl, dtable_count);
- dtable_count = fold_build2 (PLUS_EXPR, integer_type_node,
- dtable_count, integer_one_node);
- }
- }
-
- return dtable_count;
-}
-
-static void
-register_class (void)
-{
- tree node;
-
- if (!registered_class)
- vec_alloc (registered_class, 8);
-
- if (flag_indirect_classes)
- node = current_class;
- else
- node = TREE_OPERAND (build_class_ref (current_class), 0);
- vec_safe_push (registered_class, node);
-}
-
-/* Emit a function that calls _Jv_RegisterNewClasses with a list of
- all the classes we have emitted. */
-
-static void
-emit_indirect_register_classes (tree *list_p)
-{
- tree klass, t, register_class_fn;
- int i;
-
- int size = vec_safe_length (registered_class) * 2 + 1;
- vec<constructor_elt, va_gc> *init;
- vec_alloc (init, size);
- tree class_array_type
- = build_prim_array_type (ptr_type_node, size);
- tree cdecl = build_decl (input_location,
- VAR_DECL, get_identifier ("_Jv_CLS"),
- class_array_type);
- tree reg_class_list;
- FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass)
- {
- t = fold_convert (ptr_type_node, build_static_class_ref (klass));
- CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, t);
- t = fold_convert (ptr_type_node,
- build_address_of (build_classdollar_field (klass)));
- CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, t);
- }
- CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, integer_zero_node);
- DECL_INITIAL (cdecl) = build_constructor (class_array_type, init);
- TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
- TREE_STATIC (cdecl) = 1;
- DECL_ARTIFICIAL (cdecl) = 1;
- DECL_IGNORED_P (cdecl) = 1;
- TREE_READONLY (cdecl) = 1;
- TREE_CONSTANT (cdecl) = 1;
- rest_of_decl_compilation (cdecl, 1, 0);
- reg_class_list = fold_convert (ptr_type_node, build_address_of (cdecl));
-
- t = build_function_type_list (void_type_node,
- build_pointer_type (ptr_type_node), NULL);
- t = build_decl (input_location,
- FUNCTION_DECL,
- get_identifier ("_Jv_RegisterNewClasses"), t);
- TREE_PUBLIC (t) = 1;
- DECL_EXTERNAL (t) = 1;
- register_class_fn = t;
- t = build_call_expr (register_class_fn, 1, reg_class_list);
- append_to_statement_list (t, list_p);
-}
-
-/* Emit a list of pointers to all classes we have emitted to JCR_SECTION. */
-
-static void
-emit_register_classes_in_jcr_section (void)
-{
-#ifdef JCR_SECTION_NAME
- tree klass, cdecl, class_array_type;
- int i;
- int size = vec_safe_length (registered_class);
- vec<constructor_elt, va_gc> *init;
- vec_alloc (init, size);
-
- FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass)
- CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, build_fold_addr_expr (klass));
-
- /* ??? I would like to use tree_output_constant_def() but there is no way
- to put the data in a named section name, or to set the alignment,
- via that function. So do everything manually here. */
- class_array_type = build_prim_array_type (ptr_type_node, size);
- cdecl = build_decl (UNKNOWN_LOCATION,
- VAR_DECL, get_identifier ("_Jv_JCR_SECTION_data"),
- class_array_type);
- SET_DECL_ALIGN (cdecl, POINTER_SIZE);
- DECL_USER_ALIGN (cdecl) = 1;
- DECL_INITIAL (cdecl) = build_constructor (class_array_type, init);
- TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
- TREE_STATIC (cdecl) = 1;
- TREE_READONLY (cdecl) = 0;
- TREE_CONSTANT (cdecl) = 1;
- DECL_ARTIFICIAL (cdecl) = 1;
- DECL_IGNORED_P (cdecl) = 1;
- DECL_PRESERVE_P (cdecl) = 1;
- set_decl_section_name (cdecl, JCR_SECTION_NAME);
- pushdecl_top_level (cdecl);
- relayout_decl (cdecl);
- rest_of_decl_compilation (cdecl, 1, 0);
-#else
- /* A target has defined TARGET_USE_JCR_SECTION,
- but doesn't have a JCR_SECTION_NAME. */
- gcc_unreachable ();
-#endif
-}
-
-
-/* Emit a series of calls to _Jv_RegisterClass for every class we emitted.
- A series of calls is added to LIST_P. */
-
-static void
-emit_Jv_RegisterClass_calls (tree *list_p)
-{
- tree klass, t, register_class_fn;
- int i;
-
- t = build_function_type_list (void_type_node, class_ptr_type, NULL);
- t = build_decl (input_location,
- FUNCTION_DECL, get_identifier ("_Jv_RegisterClass"), t);
- TREE_PUBLIC (t) = 1;
- DECL_EXTERNAL (t) = 1;
- register_class_fn = t;
-
- FOR_EACH_VEC_SAFE_ELT (registered_class, i, klass)
- {
- t = build_fold_addr_expr (klass);
- t = build_call_expr (register_class_fn, 1, t);
- append_to_statement_list (t, list_p);
- }
-}
-
-/* Emit something to register classes at start-up time.
-
- The default mechanism is to generate instances at run-time.
-
- An alternative mechanism is through the .jcr section, which contain
- a list of pointers to classes which get registered during constructor
- invocation time.
-
- The fallback mechanism is to add statements to *LIST_P to call
- _Jv_RegisterClass for each class in this file. These statements will
- be added to a static constructor function for this translation unit. */
-
-void
-emit_register_classes (tree *list_p)
-{
- if (registered_class == NULL)
- return;
-
- /* By default, generate instances of Class at runtime. */
- if (flag_indirect_classes)
- emit_indirect_register_classes (list_p);
- /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
- TARGET_ASM_NAMED_SECTION, else 0. Some targets meet those conditions
- but lack suitable crtbegin/end objects or linker support. These
- targets can override the default in tm.h to use the fallback mechanism. */
- else if (TARGET_USE_JCR_SECTION)
- emit_register_classes_in_jcr_section ();
- /* Use the fallback mechanism. */
- else
- emit_Jv_RegisterClass_calls (list_p);
-}
-
-/* Build a constructor for an entry in the symbol table. */
-
-static tree
-build_symbol_table_entry (tree clname, tree name, tree signature)
-{
- tree symbol;
- vec<constructor_elt, va_gc> *v = NULL;
-
- START_RECORD_CONSTRUCTOR (v, symbol_type);
- PUSH_FIELD_VALUE (v, "clname", clname);
- PUSH_FIELD_VALUE (v, "name", name);
- PUSH_FIELD_VALUE (v, "signature", signature);
- FINISH_RECORD_CONSTRUCTOR (symbol, v, symbol_type);
- TREE_CONSTANT (symbol) = 1;
-
- return symbol;
-}
-
-/* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
-
-static tree
-build_symbol_entry (tree decl, tree special)
-{
- tree clname, name, signature;
- clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
- /* ??? Constructors are given the name foo.foo all the way through
- the compiler, but in the method table they're all renamed
- foo.<init>. So, we have to do the same here unless we want an
- unresolved reference at runtime. */
- name = build_utf8_ref ((TREE_CODE (decl) == FUNCTION_DECL
- && DECL_CONSTRUCTOR_P (decl))
- ? init_identifier_node
- : DECL_NAME (decl));
- signature = build_java_signature (TREE_TYPE (decl));
- signature = build_utf8_ref (unmangle_classname
- (IDENTIFIER_POINTER (signature),
- IDENTIFIER_LENGTH (signature)));
- /* SPECIAL is either NULL_TREE or integer_one_node. We emit
- signature addr+1 if SPECIAL, and this indicates to the runtime
- system that this is a "special" symbol, i.e. one that should
- bypass access controls. */
- if (special != NULL_TREE)
- signature = fold_build_pointer_plus (signature, special);
-
- return build_symbol_table_entry (clname, name, signature);
-}
-
-/* Emit a symbol table: used by -findirect-dispatch. */
-
-tree
-emit_symbol_table (tree name, tree the_table,
- vec<method_entry, va_gc> *decl_table,
- tree the_syms_decl, tree the_array_element_type,
- int element_size)
-{
- tree table, null_symbol, table_size, the_array_type;
- unsigned index;
- method_entry *e;
- vec<constructor_elt, va_gc> *v = NULL;
-
- /* Only emit a table if this translation unit actually made any
- references via it. */
- if (!decl_table)
- return the_table;
-
- /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
- FOR_EACH_VEC_ELT (*decl_table, index, e)
- CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
- build_symbol_entry (e->method, e->special));
-
- /* Terminate the list with a "null" entry. */
- null_symbol = build_symbol_table_entry (null_pointer_node,
- null_pointer_node,
- null_pointer_node);
- CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, null_symbol);
-
- tree symbols_arr_type
- = build_prim_array_type (symbol_type, vec_safe_length (v));
-
- table = build_constructor (symbols_arr_type, v);
-
- /* Make it the initial value for otable_syms and emit the decl. */
- TREE_TYPE (the_syms_decl) = symbols_arr_type;
- relayout_decl (the_syms_decl);
- DECL_INITIAL (the_syms_decl) = table;
- DECL_ARTIFICIAL (the_syms_decl) = 1;
- DECL_IGNORED_P (the_syms_decl) = 1;
- rest_of_decl_compilation (the_syms_decl, 1, 0);
-
- /* Now that its size is known, redefine the table as an
- uninitialized static array of INDEX + 1 elements. The extra entry
- is used by the runtime to track whether the table has been
- initialized. */
- table_size
- = build_index_type (build_int_cst (NULL_TREE, index * element_size + 1));
- the_array_type = build_array_type (the_array_element_type, table_size);
- the_table = build_decl (input_location,
- VAR_DECL, name, the_array_type);
- TREE_STATIC (the_table) = 1;
- TREE_READONLY (the_table) = 1;
- rest_of_decl_compilation (the_table, 1, 0);
-
- return the_table;
-}
-
-/* Make an entry for the catch_classes list. */
-tree
-make_catch_class_record (tree catch_class, tree classname)
-{
- tree entry;
- tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
- vec<constructor_elt, va_gc> *v = NULL;
- START_RECORD_CONSTRUCTOR (v, type);
- PUSH_FIELD_VALUE (v, "address", catch_class);
- PUSH_FIELD_VALUE (v, "classname", classname);
- FINISH_RECORD_CONSTRUCTOR (entry, v, type);
- return entry;
-}
-
-
-/* Generate the list of Throwable classes that are caught by exception
- handlers in this class. */
-tree
-emit_catch_table (tree this_class)
-{
- tree table, table_size, array_type;
- int n_catch_classes;
- constructor_elt *e;
- /* Fill in the dummy entry that make_class created. */
- e = &(*TYPE_CATCH_CLASSES (this_class))[0];
- e->value = make_catch_class_record (null_pointer_node, null_pointer_node);
- CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class), NULL_TREE,
- make_catch_class_record (null_pointer_node,
- null_pointer_node));
- n_catch_classes = TYPE_CATCH_CLASSES (this_class)->length ();
- table_size = build_index_type (build_int_cst (NULL_TREE, n_catch_classes));
- array_type
- = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
- table_size);
- table =
- build_decl (input_location,
- VAR_DECL, DECL_NAME (TYPE_CTABLE_DECL (this_class)), array_type);
- DECL_INITIAL (table) =
- build_constructor (array_type, TYPE_CATCH_CLASSES (this_class));
- TREE_STATIC (table) = 1;
- TREE_READONLY (table) = 1;
- DECL_IGNORED_P (table) = 1;
- rest_of_decl_compilation (table, 1, 0);
- return table;
-}
-
-/* Given a type, return the signature used by
- _Jv_FindClassFromSignature() in libgcj. This isn't exactly the
- same as build_java_signature() because we want the canonical array
- type. */
-
-static tree
-build_signature_for_libgcj (tree type)
-{
- tree sig, ref;
-
- sig = build_java_signature (type);
- ref = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
- IDENTIFIER_LENGTH (sig)));
- return ref;
-}
-
-/* Build an entry in the type assertion table. */
-
-static tree
-build_assertion_table_entry (tree code, tree op1, tree op2)
-{
- vec<constructor_elt, va_gc> *v = NULL;
- tree entry;
-
- START_RECORD_CONSTRUCTOR (v, assertion_entry_type);
- PUSH_FIELD_VALUE (v, "assertion_code", code);
- PUSH_FIELD_VALUE (v, "op1", op1);
- PUSH_FIELD_VALUE (v, "op2", op2);
- FINISH_RECORD_CONSTRUCTOR (entry, v, assertion_entry_type);
-
- return entry;
-}
-
-/* Add an entry to the type assertion table. Callback used during hashtable
- traversal. */
-
-int
-add_assertion_table_entry (type_assertion **slot, vec<constructor_elt, va_gc> **v)
-{
- tree entry;
- tree code_val, op1_utf8, op2_utf8;
- type_assertion *as = *slot;
-
- code_val = build_int_cst (NULL_TREE, as->assertion_code);
-
- if (as->op1 == NULL_TREE)
- op1_utf8 = null_pointer_node;
- else
- op1_utf8 = build_signature_for_libgcj (as->op1);
-
- if (as->op2 == NULL_TREE)
- op2_utf8 = null_pointer_node;
- else
- op2_utf8 = build_signature_for_libgcj (as->op2);
-
- entry = build_assertion_table_entry (code_val, op1_utf8, op2_utf8);
-
- CONSTRUCTOR_APPEND_ELT (*v, NULL_TREE, entry);
- return true;
-}
-
-/* Generate the type assertion table for KLASS, and return its DECL. */
-
-static tree
-emit_assertion_table (tree klass)
-{
- tree null_entry, ctor, table_decl;
- hash_table<type_assertion_hasher> *assertions_htab = TYPE_ASSERTIONS (klass);
- vec<constructor_elt, va_gc> *v = NULL;
-
- /* Iterate through the hash table. */
- assertions_htab
- ->traverse<vec<constructor_elt, va_gc> **, add_assertion_table_entry> (&v);
-
- /* Finish with a null entry. */
- null_entry = build_assertion_table_entry (integer_zero_node,
- null_pointer_node,
- null_pointer_node);
-
- CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, null_entry);
-
- tree type
- = build_prim_array_type (assertion_entry_type, vec_safe_length (v));
-
- ctor = build_constructor (type, v);
-
- table_decl = build_decl (input_location,
- VAR_DECL, mangled_classname ("_type_assert_", klass),
- type);
-
- TREE_STATIC (table_decl) = 1;
- TREE_READONLY (table_decl) = 1;
- TREE_CONSTANT (table_decl) = 1;
- DECL_IGNORED_P (table_decl) = 1;
-
- DECL_INITIAL (table_decl) = ctor;
- DECL_ARTIFICIAL (table_decl) = 1;
- rest_of_decl_compilation (table_decl, 1, 0);
-
- return table_decl;
-}
-
-void
-init_class_processing (void)
-{
- fields_ident = get_identifier ("fields");
- info_ident = get_identifier ("info");
-
- gcc_obstack_init (&temporary_obstack);
-}
-
-/* A hash table mapping trees to trees. Used generally. */
-
-#define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
-
-hashval_t
-treetreehasher::hash (treetreehash_entry *k)
-{
- return JAVA_TREEHASHHASH_H (k->key);
-}
-
-bool
-treetreehasher::equal (treetreehash_entry *k1, tree k2)
-{
- return (k1->key == k2);
-}
-
-tree
-java_treetreehash_find (hash_table<treetreehasher> *ht, tree t)
-{
- struct treetreehash_entry *e;
- hashval_t hv = JAVA_TREEHASHHASH_H (t);
- e = ht->find_with_hash (t, hv);
- if (e == NULL)
- return NULL;
- else
- return e->value;
-}
-
-tree *
-java_treetreehash_new (hash_table<treetreehasher> *ht, tree t)
-{
- struct treetreehash_entry *tthe;
- hashval_t hv = JAVA_TREEHASHHASH_H (t);
-
- treetreehash_entry **e = ht->find_slot_with_hash (t, hv, INSERT);
- if (*e == NULL)
- {
- tthe = ggc_cleared_alloc<treetreehash_entry> ();
- tthe->key = t;
- *e = tthe;
- }
- else
- tthe = *e;
- return &tthe->value;
-}
-
-hash_table<treetreehasher> *
-java_treetreehash_create (size_t size)
-{
- return hash_table<treetreehasher>::create_ggc (size);
-}
-
-/* Break down qualified IDENTIFIER into package and class-name components.
- For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
- "pkg.foo", and RIGHT to "Bar". */
-
-int
-split_qualified_name (tree *left, tree *right, tree source)
-{
- char *p, *base;
- int l = IDENTIFIER_LENGTH (source);
-
- base = (char *) alloca (l + 1);
- memcpy (base, IDENTIFIER_POINTER (source), l + 1);
-
- /* Breakdown NAME into REMAINDER . IDENTIFIER. */
- p = base + l - 1;
- while (*p != '.' && p != base)
- p--;
-
- /* We didn't find a '.'. Return an error. */
- if (p == base)
- return 1;
-
- *p = '\0';
- if (right)
- *right = get_identifier (p+1);
- *left = get_identifier (base);
-
- return 0;
-}
-
-/* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
- if the classes are from the same package. */
-
-int
-in_same_package (tree name1, tree name2)
-{
- tree tmp;
- tree pkg1;
- tree pkg2;
-
- if (TREE_CODE (name1) == TYPE_DECL)
- name1 = DECL_NAME (name1);
- if (TREE_CODE (name2) == TYPE_DECL)
- name2 = DECL_NAME (name2);
-
- if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
- /* One in empty package. */
- return 0;
-
- if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
- /* Both in empty package. */
- return 1;
-
- split_qualified_name (&pkg1, &tmp, name1);
- split_qualified_name (&pkg2, &tmp, name2);
-
- return (pkg1 == pkg2);
-}
-
-#include "gt-java-class.h"
generated by cgit v1.1 at 2025-05-22 12:19:38 +0000