riscv-gnu-toolchain/gcc.git - Unnamed repository; edit this file 'description' to name the repository.

diff options

author	Richard Sandiford <richard.sandiford@arm.com>	2018-07-31 14:23:25 +0000
committer	Richard Sandiford <rsandifo@gcc.gnu.org>	2018-07-31 14:23:25 +0000
commit	78e02b3bbb00fc898c550b88161838eb5dd95806 (patch)
tree	b8c2aa33b7aef2b96b2f17210fec46a79c3dabc3 /gcc/tree-vectorizer.h
parent	b978758186fa187d52d2c4a02cdc8474d361a0dd (diff)
download	gcc-78e02b3bbb00fc898c550b88161838eb5dd95806.zip gcc-78e02b3bbb00fc898c550b88161838eb5dd95806.tar.gz gcc-78e02b3bbb00fc898c550b88161838eb5dd95806.tar.bz2

[19/46] Make vect_dr_stmt return a stmt_vec_info

This patch makes vect_dr_stmt return a stmt_vec_info instead of a gimple stmt. Rather than retain a separate gimple stmt variable in cases where both existed, the patch replaces uses of the gimple variable with the uses of the stmt_vec_info. Later patches do this more generally. Many things that are keyed off a data_reference would these days be better keyed off a stmt_vec_info, but it's more convenient to do that later in the series. The vect_dr_size calls that are left over do still benefit from this patch. 2018-07-31 Richard Sandiford <richard.sandiford@arm.com> gcc/ * tree-vectorizer.h (vect_dr_stmt): Return a stmt_vec_info rather than a gimple stmt. * tree-vect-data-refs.c (vect_analyze_data_ref_dependence) (vect_slp_analyze_data_ref_dependence, vect_record_base_alignments) (vect_calculate_target_alignmentm, vect_compute_data_ref_alignment) (vect_update_misalignment_for_peel, vect_verify_datarefs_alignment) (vector_alignment_reachable_p, vect_get_data_access_cost) (vect_get_peeling_costs_all_drs, vect_peeling_hash_get_lowest_cost) (vect_peeling_supportable, vect_enhance_data_refs_alignment) (vect_find_same_alignment_drs, vect_analyze_data_refs_alignment) (vect_analyze_group_access_1, vect_analyze_group_access) (vect_analyze_data_ref_access, vect_analyze_data_ref_accesses) (vect_vfa_access_size, vect_small_gap_p, vect_analyze_data_refs) (vect_supportable_dr_alignment): Remove vinfo_for_stmt from the result of vect_dr_stmt and use the stmt_vec_info instead of the associated gimple stmt. * tree-vect-loop-manip.c (get_misalign_in_elems): Likewise. (vect_gen_prolog_loop_niters): Likewise. * tree-vect-loop.c (vect_analyze_loop_2): Likewise. From-SVN: r263134

Diffstat (limited to 'gcc/tree-vectorizer.h')

-rw-r--r--

gcc/tree-vectorizer.h

1 files changed, 2 insertions, 2 deletions

/* Functions related to building classes and their related objects. Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 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 2, 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 COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 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 "tm.h" #include "tree.h" #include "rtl.h" #include "flags.h" #include "java-tree.h" #include "jcf.h" #include "obstack.h" #include "toplev.h" #include "output.h" #include "parse.h" #include "function.h" #include "ggc.h" #include "stdio.h" #include "target.h" /* DOS brain-damage */ #ifndef O_BINARY #define O_BINARY 0 /* MS-DOS brain-damage */ #endif 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 void add_interface_do (tree, tree, int); static tree maybe_layout_super_class (tree, tree); static int assume_compiled (const char *); static tree build_method_symbols_entry (tree); static GTY(()) rtx registerClass_libfunc; struct obstack temporary_obstack; /* 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 assume_compiled_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 assume_compiled_node_struct { /* The class or package name. */ const char *ident; /* Nonzero if this represents an exclusion. */ int excludep; /* Pointers to other nodes in the tree. */ struct assume_compiled_node_struct *parent; struct assume_compiled_node_struct *sibling; struct assume_compiled_node_struct *child; } assume_compiled_node; static assume_compiled_node *find_assume_compiled_node (assume_compiled_node *, const char *); /* This is the root of the include/exclude tree. */ static assume_compiled_node *assume_compiled_tree; static GTY(()) tree class_roots[5]; #define registered_class class_roots[0] #define fields_ident class_roots[1] /* get_identifier ("fields") */ #define info_ident class_roots[2] /* get_identifier ("info") */ #define class_list class_roots[3] #define class_dtable_decl class_roots[4] /* Return the node that most closely represents the class whose name is IDENT. Start the search from NODE. Return NULL if an appropriate node does not exist. */ static assume_compiled_node * find_assume_compiled_node (assume_compiled_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 && (strlen (ident) == node_ident_length || ident[node_ident_length] == '.'))) { /* We've found a match, however, there might be a more specific match. */ assume_compiled_node *found = find_assume_compiled_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; } /* 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) { int len; assume_compiled_node *parent; assume_compiled_node *node = xmalloc (sizeof (assume_compiled_node)); node->ident = xstrdup (ident); node->excludep = excludep; node->child = NULL; /* Create the root of the tree if it doesn't exist yet. */ if (NULL == assume_compiled_tree) { assume_compiled_tree = xmalloc (sizeof (assume_compiled_node)); assume_compiled_tree->ident = ""; assume_compiled_tree->excludep = 0; assume_compiled_tree->sibling = NULL; assume_compiled_tree->child = NULL; assume_compiled_tree->parent = NULL; } /* Calling the function with the empty string means we're setting excludep for the root of the hierarchy. */ if (0 == ident[0]) { assume_compiled_tree->excludep = excludep; return; } /* Find the parent node for this new node. PARENT will either be a class or a package name. Adjust PARENT accordingly. */ parent = find_assume_compiled_node (assume_compiled_tree, ident); len = strlen (parent->ident); if (parent->ident[len] && parent->ident[len] != '.') parent = parent->parent; /* Insert NODE into the tree. */ node->parent = parent; node->sibling = parent->child; parent->child = node; } /* 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) { assume_compiled_node *i; int result; if (NULL == assume_compiled_tree) return 1; i = find_assume_compiled_node (assume_compiled_tree, ident); result = ! i->excludep; return (result); } /* 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; #ifdef __GNUC__ char buffer[i]; #else char *buffer = alloca (i); #endif 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 ident = TYPE_NAME (type); if (TREE_CODE (ident) != IDENTIFIER_NODE) ident = DECL_NAME (ident); return identifier_subst (ident, prefix, '.', '_', ""); } tree make_class (void) { tree type; type = make_node (RECORD_TYPE); TYPE_BINFO (type) = make_tree_vec (BINFO_ELTS); MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type); 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; } tree push_class (tree class_type, tree class_name) { tree decl, signature; location_t saved_loc = input_location; tree source_name = identifier_subst (class_name, "", '.', '/', ".java"); CLASS_P (class_type) = 1; input_filename = IDENTIFIER_POINTER (source_name); input_line = 0; decl = build_decl (TYPE_DECL, class_name, class_type); /* 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++; TYPE_BINFO_BASETYPES (this_class) = make_tree_vec (total_supers); if (super_class) { tree super_binfo = make_tree_vec (BINFO_ELTS); BINFO_TYPE (super_binfo) = super_class; BINFO_OFFSET (super_binfo) = integer_zero_node; TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (this_class)), 0) = super_binfo; CLASS_HAS_SUPER (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; } /* 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 = TYPE_BINFO_BASETYPE (clas, 0); } return depth; } /* Return true iff TYPE2 is an interface that extends interface TYPE1 */ int interface_of_p (tree type1, tree type2) { int n, i; tree basetype_vec; if (!(basetype_vec = TYPE_BINFO_BASETYPES (type2))) return 0; n = TREE_VEC_LENGTH (basetype_vec); for (i = 0; i < n; i++) { tree vec_elt = TREE_VEC_ELT (basetype_vec, i); if (vec_elt && BINFO_TYPE (vec_elt) == type1) return 1; } for (i = 0; i < n; i++) { tree vec_elt = TREE_VEC_ELT (basetype_vec, i); if (vec_elt && BINFO_TYPE (vec_elt) && interface_of_p (type1, BINFO_TYPE (vec_elt))) 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; type1 = CLASSTYPE_SUPER (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 there exists a common enclosing context between TYPE1 and TYPE2. */ int common_enclosing_context_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; } static void add_interface_do (tree basetype_vec, tree interface_class, int i) { tree interface_binfo = make_tree_vec (BINFO_ELTS); BINFO_TYPE (interface_binfo) = interface_class; BINFO_OFFSET (interface_binfo) = integer_zero_node; BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node; TREE_VIA_VIRTUAL (interface_binfo) = 1; TREE_VEC_ELT (basetype_vec, i) = interface_binfo; } /* 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 basetype_vec = TYPE_BINFO_BASETYPES (this_class); int i; int n = TREE_VEC_LENGTH (basetype_vec); for (i = 0; ; i++) { if (i >= n) { error ("internal error - too many interface type"); return NULL_TREE; } else if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE) break; else if (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)) == interface_class) return interface_class; } add_interface_do (basetype_vec, interface_class, i); 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 basetype_vec = TYPE_BINFO_BASETYPES (this_class); int i; int n = TREE_VEC_LENGTH (basetype_vec); for (i = 0; ; i++) { if (i >= n) { error ("internal error - too many interface type"); return; } else if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE) break; } add_interface_do (basetype_vec, interface_class, i); } #if 0 /* Return the address of a pointer to the first FUNCTION_DECL in the list (*LIST) whose DECL_NAME is NAME. */ static tree * find_named_method (tree *list, tree name) { while (*list && DECL_NAME (*list) != name) list = &TREE_CHAIN (*list); return list; } #endif static tree build_java_method_type (tree fntype, tree this_class, int access_flags) { if (access_flags & ACC_STATIC) return fntype; return build_method_type (this_class, fntype); } 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 (FUNCTION_DECL, name, method_type); DECL_CONTEXT (fndecl) = this_class; DECL_LANG_SPECIFIC (fndecl) = ggc_alloc_cleared (sizeof (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, 1); /* Initialize the initialized (static) class table. */ if (access_flags & ACC_STATIC) DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) = htab_create_ggc (50, htab_hash_pointer, htab_eq_pointer, NULL); /* Initialize the static method invocation compound list */ DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = NULL_TREE; TREE_CHAIN (fndecl) = TYPE_METHODS (this_class); TYPE_METHODS (this_class) = fndecl; /* 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) = DECL_INLINE (fndecl) = 1; if (access_flags & ACC_NATIVE) { METHOD_NATIVE (fndecl) = 1; DECL_EXTERNAL (fndecl) = 1; } if (access_flags & ACC_STATIC) METHOD_STATIC (fndecl) = DECL_INLINE (fndecl) = 1; if (access_flags & ACC_FINAL) METHOD_FINAL (fndecl) = DECL_INLINE (fndecl) = 1; if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1; if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1; if (access_flags & ACC_TRANSIENT) METHOD_TRANSIENT (fndecl) = 1; if (access_flags & ACC_STRICT) METHOD_STRICTFP (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 ("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 class, tree name, tree field_type, int flags) { int is_static = (flags & ACC_STATIC) != 0; tree field; field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type); TREE_CHAIN (field) = TYPE_FIELDS (class); TYPE_FIELDS (class) = field; DECL_CONTEXT (field) = class; 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; if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (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; /* Considered external until we know what classes are being compiled into this object file. */ DECL_EXTERNAL (field) = 1; } return field; } /* Associate a constant value CONSTANT with VAR_DECL FIELD. */ void set_constant_value (tree field, tree constant) { if (field == NULL_TREE) warning ("misplaced ConstantValue attribute (not in any field)"); else if (DECL_INITIAL (field) != NULL_TREE) warning ("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))); if (FIELD_FINAL (field)) DECL_FIELD_FINAL_IUD (field) = 1; } } /* Count the number of Unicode chars encoded in a given Ut8 string. */ #if 0 int strLengthUtf8 (char *str, int len) { register unsigned char* ptr = (unsigned char*) str; register unsigned char *limit = ptr + len; int str_length = 0; for (; ptr < limit; str_length++) { if (UTF8_GET (ptr, limit) < 0) return -1; } return str_length; } #endif /* 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) { register const unsigned char* ptr = (const unsigned char*) str; register const unsigned char *limit = ptr + len; int32 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; } static GTY(()) tree utf8_decl_list = NULL_TREE; tree build_utf8_ref (tree name) { const char * name_ptr = IDENTIFIER_POINTER(name); int name_len = IDENTIFIER_LENGTH(name); 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; if (ref != NULL_TREE) return ref; ctype = make_node (RECORD_TYPE); str_type = build_prim_array_type (unsigned_byte_type_node, name_len + 1); /* Allow for final '\0'. */ PUSH_FIELD (ctype, field, "hash", unsigned_short_type_node); PUSH_FIELD (ctype, field, "length", unsigned_short_type_node); PUSH_FIELD (ctype, field, "data", str_type); FINISH_RECORD (ctype); START_RECORD_CONSTRUCTOR (cinit, ctype); name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF; PUSH_FIELD_VALUE (cinit, "hash", build_int_2 (name_hash, 0)); PUSH_FIELD_VALUE (cinit, "length", build_int_2 (name_len, 0)); string = build_string (name_len, name_ptr); TREE_TYPE (string) = str_type; PUSH_FIELD_VALUE (cinit, "data", string); FINISH_RECORD_CONSTRUCTOR (cinit); TREE_CONSTANT (cinit) = 1; /* Generate a unique-enough identifier. */ sprintf(buf, "_Utf%d", ++utf8_count); decl = build_decl (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; #ifdef HAVE_GAS_SHF_MERGE { int decl_size; /* Ensure decl_size is a multiple of utf8const_type's alignment. */ decl_size = (name_len + 5 + TYPE_ALIGN_UNIT (utf8const_type) - 1) & ~(TYPE_ALIGN_UNIT (utf8const_type) - 1); 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); named_section_flags (buf, flags); DECL_SECTION_NAME (decl) = build_string (strlen (buf), buf); } } #endif TREE_CHAIN (decl) = utf8_decl_list; layout_decl (decl, 0); pushdecl (decl); rest_of_decl_compilation (decl, (char*) 0, global_bindings_p (), 0); utf8_decl_list = decl; make_decl_rtl (decl, (char*) 0); ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl); IDENTIFIER_UTF8_REF (name) = ref; return ref; } /* 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_name, decl; if (TREE_CODE (type) == POINTER_TYPE) type = TREE_TYPE (type); if (TREE_CODE (type) == RECORD_TYPE) { 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 (VAR_DECL, decl_name, class_type_node); DECL_SIZE (decl) = TYPE_SIZE (class_type_node); DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (class_type_node); TREE_STATIC (decl) = 1; TREE_PUBLIC (decl) = 1; DECL_IGNORED_P (decl) = 1; DECL_ARTIFICIAL (decl) = 1; if (is_compiled == 1) DECL_EXTERNAL (decl) = 1; SET_DECL_ASSEMBLER_NAME (decl, java_mangle_class_field (&temporary_obstack, type)); make_decl_rtl (decl, NULL); pushdecl_top_level (decl); } } else { const char *name; char buffer[25]; if (flag_emit_class_files) { const char *prim_class_name; tree prim_class; if (type == char_type_node) prim_class_name = "java.lang.Character"; else if (type == boolean_type_node) prim_class_name = "java.lang.Boolean"; else if (type == byte_type_node) prim_class_name = "java.lang.Byte"; else if (type == short_type_node) prim_class_name = "java.lang.Short"; else if (type == int_type_node) prim_class_name = "java.lang.Integer"; else if (type == long_type_node) prim_class_name = "java.lang.Long"; else if (type == float_type_node) prim_class_name = "java.lang.Float"; else if (type == double_type_node) prim_class_name = "java.lang.Double"; else if (type == void_type_node) prim_class_name = "java.lang.Void"; else abort (); prim_class = lookup_class (get_identifier (prim_class_name)); return build (COMPONENT_REF, NULL_TREE, prim_class, TYPE_identifier_node); } 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 (VAR_DECL, decl_name, class_type_node); TREE_STATIC (decl) = 1; TREE_PUBLIC (decl) = 1; DECL_EXTERNAL (decl) = 1; make_decl_rtl (decl, NULL); pushdecl_top_level (decl); } } ref = build1 (ADDR_EXPR, class_ptr_type, decl); return ref; } else { int index; tree cl; index = alloc_class_constant (type); cl = build_ref_from_constant_pool (index); TREE_TYPE (cl) = promote_type (class_ptr_type); return cl; } } 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 -fno-assume-compiled, gcj will sometimes try to fold a field from an uncompiled class. This is required when the field in question meets the appropriate criteria for a compile-time constant. However, currently sometimes gcj is too eager and will end up returning the field itself, leading to an incorrect external reference being generated. */ if (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 (!DECL_RTL_SET_P (fdecl)) { if (is_compiled == 1) DECL_EXTERNAL (fdecl) = 1; make_decl_rtl (fdecl, NULL); } return fdecl; } else { /* Compile as: * *(FTYPE*)build_class_ref(FCLASS)->fields[INDEX].info.addr */ tree ref = build_class_ref (fclass); tree fld; int field_index = 0; ref = build1 (INDIRECT_REF, class_type_node, ref); ref = build (COMPONENT_REF, field_ptr_type_node, ref, lookup_field (&class_type_node, fields_ident)); for (fld = TYPE_FIELDS (fclass); ; fld = TREE_CHAIN (fld)) { if (fld == fdecl) break; if (fld == NULL_TREE) fatal_error ("field '%s' not found in class", IDENTIFIER_POINTER (DECL_NAME (fdecl))); if (FIELD_STATIC (fld)) field_index++; } field_index *= int_size_in_bytes (field_type_node); ref = fold (build (PLUS_EXPR, field_ptr_type_node, ref, build_int_2 (field_index, 0))); ref = build1 (INDIRECT_REF, field_type_node, ref); ref = build (COMPONENT_REF, field_info_union_node, ref, lookup_field (&field_type_node, info_ident)); ref = build (COMPONENT_REF, ptr_type_node, ref, TREE_CHAIN (TYPE_FIELDS (field_info_union_node))); return fold (build1 (INDIRECT_REF, TREE_TYPE(fdecl), ref)); } } 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; 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; 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_TRANSIENT (decl)) access_flags |= ACC_TRANSIENT; if (METHOD_STRICTFP (decl)) access_flags |= ACC_STRICT; return access_flags; } abort (); } static tree make_field_value (tree fdecl) { tree finit; int flags; tree type = TREE_TYPE (fdecl); int resolved = is_compiled_class (type); START_RECORD_CONSTRUCTOR (finit, field_type_node); PUSH_FIELD_VALUE (finit, "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 (finit, "type", type); flags = get_access_flags_from_decl (fdecl); if (! resolved) flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */; PUSH_FIELD_VALUE (finit, "accflags", build_int_2 (flags, 0)); PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl))); PUSH_FIELD_VALUE (finit, "info", build_constructor (field_info_union_node, build_tree_list ((FIELD_STATIC (fdecl) ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node)) : TYPE_FIELDS (field_info_union_node)), (FIELD_STATIC (fdecl) ? build_address_of (build_static_field_ref (fdecl)) : byte_position (fdecl))))); FINISH_RECORD_CONSTRUCTOR (finit); return finit; } static tree make_method_value (tree mdecl) { static int method_name_count = 0; tree minit; tree index; tree code; #define ACC_TRANSLATED 0x4000 int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED; if (!flag_indirect_dispatch && DECL_VINDEX (mdecl) != NULL_TREE) index = DECL_VINDEX (mdecl); else index = integer_minus_one_node; code = null_pointer_node; if (DECL_RTL_SET_P (mdecl)) code = build1 (ADDR_EXPR, nativecode_ptr_type_node, mdecl); START_RECORD_CONSTRUCTOR (minit, method_type_node); PUSH_FIELD_VALUE (minit, "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 (minit, "signature", (build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER(signature), IDENTIFIER_LENGTH(signature))))); } PUSH_FIELD_VALUE (minit, "accflags", build_int_2 (accflags, 0)); PUSH_FIELD_VALUE (minit, "index", index); PUSH_FIELD_VALUE (minit, "ncode", code); { /* Compute the `throws' information for the method. */ tree table = null_pointer_node; if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE) { int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl)); tree iter, type, array; char buf[60]; table = tree_cons (NULL_TREE, table, NULL_TREE); for (iter = DECL_FUNCTION_THROWS (mdecl); iter != NULL_TREE; iter = TREE_CHAIN (iter)) { tree sig = DECL_NAME (TYPE_NAME (TREE_VALUE (iter))); tree utf8 = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig), IDENTIFIER_LENGTH (sig))); table = tree_cons (NULL_TREE, utf8, table); } type = build_prim_array_type (ptr_type_node, length); table = build_constructor (type, table); /* Compute something unique enough. */ sprintf (buf, "_methods%d", method_name_count++); array = build_decl (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, (char*) 0, 1, 0); table = build1 (ADDR_EXPR, ptr_type_node, array); } PUSH_FIELD_VALUE (minit, "throws", table); } FINISH_RECORD_CONSTRUCTOR (minit); 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_low_cst (TYPE_NVIRTUALS (type), 0); vtable = make_tree_vec (nvirtuals); TYPE_VTABLE (type) = vtable; if (super != NULL_TREE) { tree super_vtable = get_dispatch_vector (super); for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; ) TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i); } for (method = TYPE_METHODS (type); method != NULL_TREE; method = TREE_CHAIN (method)) if (DECL_VINDEX (method) != NULL_TREE && host_integerp (DECL_VINDEX (method), 0)) TREE_VEC_ELT (vtable, tree_low_cst (DECL_VINDEX (method), 0)) = 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; tree list = NULL_TREE; int nvirtuals = TREE_VEC_LENGTH (vtable); int arraysize; tree gc_descr; for (i = nvirtuals; --i >= 0; ) { tree method = TREE_VEC_ELT (vtable, i); if (METHOD_ABSTRACT (method)) { if (! abstract_p) warning ("%Habstract method in non-abstract class", &DECL_SOURCE_FILE (method)); if (TARGET_VTABLE_USES_DESCRIPTORS) for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j) list = tree_cons (NULL_TREE, null_pointer_node, list); else list = tree_cons (NULL_TREE, null_pointer_node, list); } else { if (!DECL_RTL_SET_P (method)) make_decl_rtl (method, NULL); if (TARGET_VTABLE_USES_DESCRIPTORS) for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j) { tree fdesc = build (FDESC_EXPR, nativecode_ptr_type_node, method, build_int_2 (j, 0)); TREE_CONSTANT (fdesc) = 1; list = tree_cons (NULL_TREE, fdesc, list); } else list = tree_cons (NULL_TREE, build1 (ADDR_EXPR, nativecode_ptr_type_node, method), list); } } /* 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); list = tree_cons (NULL_TREE, gc_descr, list); for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j) list = tree_cons (NULL_TREE, gc_descr, list); list = tree_cons (NULL_TREE, this_class_addr, list); /** Pointer to type_info object (to be implemented), according to g++ ABI. */ list = tree_cons (NULL_TREE, null_pointer_node, list); /** Offset to start of whole object. Always (ptrdiff_t)0 for Java. */ list = tree_cons (integer_zero_node, null_pointer_node, list); arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2); if (TARGET_VTABLE_USES_DESCRIPTORS) arraysize *= TARGET_VTABLE_USES_DESCRIPTORS; arraysize += 2; return build_constructor (build_prim_array_type (nativecode_ptr_type_node, arraysize), list); } 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; } void make_class_data (tree type) { tree decl, cons, temp; tree field, fields_decl; tree static_fields = NULL_TREE; tree instance_fields = NULL_TREE; 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 methods = NULL_TREE; 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; tree type_decl = TYPE_NAME (type); /** Offset from start of virtual function table declaration to where objects actually point at, following new g++ ABI. */ tree dtable_start_offset = build_int_2 (2 * POINTER_SIZE / BITS_PER_UNIT, 0); this_class_addr = build_class_ref (type); decl = TREE_OPERAND (this_class_addr, 0); /* Build Field array. */ field = TYPE_FIELDS (type); if (DECL_NAME (field) == NULL_TREE) field = TREE_CHAIN (field); /* Skip dummy field for inherited data. */ for ( ; field != NULL_TREE; field = TREE_CHAIN (field)) { if (! DECL_ARTIFICIAL (field)) { tree init = make_field_value (field); if (FIELD_STATIC (field)) { tree initial = DECL_INITIAL (field); static_field_count++; static_fields = tree_cons (NULL_TREE, init, static_fields); /* 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, (char*) 0, 1, 1); DECL_INITIAL (field) = initial; } else { instance_field_count++; instance_fields = tree_cons (NULL_TREE, init, instance_fields); } } } field_count = static_field_count + instance_field_count; if (field_count > 0) { static_fields = nreverse (static_fields); instance_fields = nreverse (instance_fields); static_fields = chainon (static_fields, instance_fields); field_array_type = build_prim_array_type (field_type_node, field_count); fields_decl = build_decl (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, (char*) 0, 1, 0); } else fields_decl = NULL_TREE; /* Build Method array. */ for (method = TYPE_METHODS (type); method != NULL_TREE; method = TREE_CHAIN (method)) { tree init; if (METHOD_PRIVATE (method) && ! flag_keep_inline_functions && (flag_inline_functions || optimize)) continue; init = make_method_value (method); method_count++; methods = tree_cons (NULL_TREE, init, methods); } method_array_type = build_prim_array_type (method_type_node, method_count); methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type), method_array_type); DECL_INITIAL (methods_decl) = build_constructor (method_array_type, nreverse (methods)); TREE_STATIC (methods_decl) = 1; DECL_ARTIFICIAL (methods_decl) = 1; DECL_IGNORED_P (methods_decl) = 1; rest_of_decl_compilation (methods_decl, (char*) 0, 1, 0); if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl) && !flag_indirect_dispatch) { tree dtable = get_dispatch_table (type, this_class_addr); dtable_decl = build_dtable_decl (type); DECL_INITIAL (dtable_decl) = dtable; TREE_STATIC (dtable_decl) = 1; DECL_ARTIFICIAL (dtable_decl) = 1; DECL_IGNORED_P (dtable_decl) = 1; TREE_PUBLIC (dtable_decl) = 1; rest_of_decl_compilation (dtable_decl, (char*) 0, 1, 0); if (type == class_type_node) class_dtable_decl = dtable_decl; } 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, (char*) 0, 1, 0); } super = CLASSTYPE_SUPER (type); if (super == NULL_TREE) super = null_pointer_node; else if (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_2 (super_index, 0); TREE_TYPE (super) = ptr_type_node; } /* Build and emit the array of implemented interfaces. */ if (type != object_type_node) interface_len = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)) - 1; if (interface_len > 0) { tree init = NULL_TREE; int i; tree interface_array_type, idecl; interface_array_type = build_prim_array_type (class_ptr_type, interface_len); idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type), interface_array_type); for (i = interface_len; i > 0; i--) { tree child = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i); tree iclass = BINFO_TYPE (child); tree index; if (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_2 (int_index, 0); TREE_TYPE (index) = ptr_type_node; } init = tree_cons (NULL_TREE, index, init); } 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, (char*) 0, 1, 0); } constant_pool_constructor = build_constants_constructor (); START_RECORD_CONSTRUCTOR (temp, object_type_node); PUSH_FIELD_VALUE (temp, "vtable", build (PLUS_EXPR, dtable_ptr_type, build1 (ADDR_EXPR, dtable_ptr_type, class_dtable_decl), dtable_start_offset)); if (! flag_hash_synchronization) PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node); FINISH_RECORD_CONSTRUCTOR (temp); START_RECORD_CONSTRUCTOR (cons, class_type_node); PUSH_SUPER_VALUE (cons, temp); PUSH_FIELD_VALUE (cons, "next", null_pointer_node); PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl))); PUSH_FIELD_VALUE (cons, "accflags", build_int_2 (get_access_flags_from_decl (type_decl), 0)); PUSH_FIELD_VALUE (cons, "superclass", CLASS_INTERFACE (type_decl) ? null_pointer_node : super); PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor); PUSH_FIELD_VALUE (cons, "methods", build1 (ADDR_EXPR, method_ptr_type_node, methods_decl)); PUSH_FIELD_VALUE (cons, "method_count", build_int_2 (method_count, 0)); if (flag_indirect_dispatch) PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node) else PUSH_FIELD_VALUE (cons, "vtable_method_count", TYPE_NVIRTUALS (type)); PUSH_FIELD_VALUE (cons, "fields", fields_decl == NULL_TREE ? null_pointer_node : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl)); PUSH_FIELD_VALUE (cons, "size_in_bytes", size_in_bytes (type)); PUSH_FIELD_VALUE (cons, "field_count", build_int_2 (field_count, 0)); PUSH_FIELD_VALUE (cons, "static_field_count", build_int_2 (static_field_count, 0)); if (flag_indirect_dispatch) PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node) else PUSH_FIELD_VALUE (cons, "vtable", dtable_decl == NULL_TREE ? null_pointer_node : build (PLUS_EXPR, dtable_ptr_type, build1 (ADDR_EXPR, dtable_ptr_type, dtable_decl), dtable_start_offset)); if (otable_methods == NULL_TREE) { PUSH_FIELD_VALUE (cons, "otable", null_pointer_node); PUSH_FIELD_VALUE (cons, "otable_syms", null_pointer_node); } else { PUSH_FIELD_VALUE (cons, "otable", build1 (ADDR_EXPR, otable_ptr_type, otable_decl)); PUSH_FIELD_VALUE (cons, "otable_syms", build1 (ADDR_EXPR, method_symbols_array_ptr_type, otable_syms_decl)); } PUSH_FIELD_VALUE (cons, "interfaces", interfaces); PUSH_FIELD_VALUE (cons, "loader", null_pointer_node); PUSH_FIELD_VALUE (cons, "interface_count", build_int_2 (interface_len, 0)); PUSH_FIELD_VALUE (cons, "state", integer_zero_node); PUSH_FIELD_VALUE (cons, "thread", null_pointer_node); PUSH_FIELD_VALUE (cons, "depth", integer_zero_node); PUSH_FIELD_VALUE (cons, "ancestors", null_pointer_node); PUSH_FIELD_VALUE (cons, "idt", null_pointer_node); PUSH_FIELD_VALUE (cons, "arrayclass", null_pointer_node); PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node); PUSH_FIELD_VALUE (cons, "chain", null_pointer_node); FINISH_RECORD_CONSTRUCTOR (cons); DECL_INITIAL (decl) = cons; /* Hash synchronization requires at least 64-bit alignment. */ if (flag_hash_synchronization && POINTER_SIZE < 64) DECL_ALIGN (decl) = 64; rest_of_decl_compilation (decl, (char*) 0, 1, 0); } void finish_class (void) { tree method; tree type_methods = TYPE_METHODS (current_class); int saw_native_method = 0; /* Find out if we have any native methods. We use this information later. */ for (method = type_methods; method != NULL_TREE; method = TREE_CHAIN (method)) { if (METHOD_NATIVE (method)) { saw_native_method = 1; break; } } /* Emit deferred inline methods. */ for (method = type_methods; method != NULL_TREE; ) { if (! TREE_ASM_WRITTEN (method) && DECL_SAVED_INSNS (method) != 0) { output_inline_function (method); /* Scan the list again to see if there are any earlier methods to emit. */ method = type_methods; continue; } method = TREE_CHAIN (method); } current_function_decl = NULL_TREE; make_class_data (current_class); register_class (); rest_of_decl_compilation (TYPE_NAME (current_class), (char*) 0, 1, 0); } /* Return 2 if CLASS is compiled by this compilation job; return 1 if CLASS can otherwise be assumed to be compiled; return 0 if we cannot assume that CLASS is compiled. Returns 1 for primitive and 0 for array types. */ int is_compiled_class (tree class) { int seen_in_zip; if (TREE_CODE (class) == POINTER_TYPE) class = TREE_TYPE (class); if (TREE_CODE (class) != RECORD_TYPE) /* Primitive types are static. */ return 1; if (TYPE_ARRAY_P (class)) return 0; if (class == current_class) return 2; seen_in_zip = (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class))); if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip) { /* 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 (class)) load_class (class, 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 (class))))) { if (!CLASS_LOADED_P (class)) { if (CLASS_FROM_SOURCE_P (class)) safe_layout_class (class); else load_class (class, 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; /* 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 (dtype, dummy, "top_offset", ptr_type_node); PUSH_FIELD (dtype, dummy, "type_info", ptr_type_node); PUSH_FIELD (dtype, dummy, "class", class_ptr_type); for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n) { tree tmp_field = build_decl (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 (dtype, dummy, "gc_descr", ptr_type_node); for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n) { tree tmp_field = build_decl (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 (dtype, dummy, "methods", build_prim_array_type (nativecode_ptr_type_node, n)); layout_type (dtype); } else dtype = dtable_type; return build_decl (VAR_DECL, java_mangle_vtable (&temporary_obstack, type), dtype); } /* 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 (FIELD_DECL, NULL_TREE, super_class); DECL_IGNORED_P (base_decl) = 1; TREE_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) { if (TREE_CODE (super_class) == RECORD_TYPE) { if (!CLASS_LOADED_P (super_class) && CLASS_FROM_SOURCE_P (super_class)) safe_layout_class (super_class); 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 { /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so we give it one. */ tree this_wrap = NULL_TREE; if (this_class) { tree this_decl = TYPE_NAME (this_class); this_wrap = build_expr_wfl (this_class, DECL_SOURCE_FILE (this_decl), DECL_SOURCE_LINE (this_decl), 0); } super_class = do_resolve_class (NULL_TREE, /* FIXME? */ super_class, NULL_TREE, this_wrap); if (!super_class) return NULL_TREE; /* FIXME, NULL_TREE not checked by caller. */ super_class = TREE_TYPE (super_class); } } if (!TYPE_SIZE (super_class)) safe_layout_class (super_class); return super_class; } void layout_class (tree this_class) { tree super_class = CLASSTYPE_SUPER (this_class); tree field; 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 = obstack_finish (&temporary_obstack); 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); } for (field = TYPE_FIELDS (this_class); field != NULL_TREE; field = TREE_CHAIN (field)) { if (FIELD_STATIC (field)) { /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */ SET_DECL_ASSEMBLER_NAME (field, java_mangle_decl (&temporary_obstack, field)); } } layout_type (this_class); /* Also recursively load/layout any superinterfaces, but only if class was loaded from bytecode. The source parser will take care of this itself. */ if (!CLASS_FROM_SOURCE_P (this_class)) { tree basetype_vec = TYPE_BINFO_BASETYPES (this_class); if (basetype_vec) { int n = TREE_VEC_LENGTH (basetype_vec) - 1; int i; for (i = n; i > 0; i--) { tree vec_elt = TREE_VEC_ELT (basetype_vec, i); tree super_interface = BINFO_TYPE (vec_elt); 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); } void layout_class_methods (tree this_class) { tree method_decl, dtable_count; tree super_class; 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_METHODS (this_class) = nreverse (TYPE_METHODS (this_class)); for (method_decl = TYPE_METHODS (this_class); method_decl; method_decl = TREE_CHAIN (method_decl)) dtable_count = layout_class_method (this_class, super_class, method_decl, dtable_count); TYPE_NVIRTUALS (this_class) = dtable_count; } /* 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; /* Considered external until we know what classes are being compiled into this object file. */ DECL_EXTERNAL (method_decl) = 1; /* This is a good occasion to mangle the method's name */ SET_DECL_ASSEMBLER_NAME (method_decl, java_mangle_decl (&temporary_obstack, method_decl)); /* We don't generate a RTL for the method if it's abstract, or if it's an interface method that isn't clinit. */ if (! METHOD_ABSTRACT (method_decl) || (CLASS_INTERFACE (TYPE_NAME (this_class)) && (DECL_CLINIT_P (method_decl)))) make_decl_rtl (method_decl, NULL); 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_argument_signature (TREE_TYPE (method_decl)); } else if (! METHOD_STATIC (method_decl) && !DECL_ARTIFICIAL (method_decl)) { tree method_sig = build_java_argument_signature (TREE_TYPE (method_decl)); tree super_method = lookup_argument_method (super_class, method_name, method_sig); if (super_method != NULL_TREE && ! METHOD_PRIVATE (super_method)) { DECL_VINDEX (method_decl) = DECL_VINDEX (super_method); if (DECL_VINDEX (method_decl) == NULL_TREE && !CLASS_FROM_SOURCE_P (this_class)) error ("%Hnon-static method '%D' overrides static method", &DECL_SOURCE_LOCATION (method_decl), method_decl); } else if (! METHOD_FINAL (method_decl) && ! METHOD_PRIVATE (method_decl) && ! CLASS_FINAL (TYPE_NAME (this_class)) && dtable_count) { DECL_VINDEX (method_decl) = dtable_count; dtable_count = fold (build (PLUS_EXPR, integer_type_node, dtable_count, integer_one_node)); } } return dtable_count; } void register_class (void) { /* END does not need to be registered with the garbage collector because it always points into the list given by REGISTERED_CLASS, and that variable is registered with the collector. */ static tree end; tree node = TREE_OPERAND (build_class_ref (current_class), 0); tree current = copy_node (node); XEXP (DECL_RTL (current), 0) = copy_rtx (XEXP (DECL_RTL(node), 0)); if (!registered_class) registered_class = current; else TREE_CHAIN (end) = current; end = current; } /* Emit something to register classes at start-up time. The preferred 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 generate a `constructor' function which calls _Jv_RegisterClass for each class in this file. */ void emit_register_classes (void) { /* ??? This isn't quite the correct test. We also have to know that the target is using gcc's crtbegin/crtend objects rather than the ones that come with the operating system. */ if (SUPPORTS_WEAK && targetm.have_named_sections) { #ifdef JCR_SECTION_NAME tree t; named_section_flags (JCR_SECTION_NAME, SECTION_WRITE); assemble_align (POINTER_SIZE); for (t = registered_class; t; t = TREE_CHAIN (t)) assemble_integer (XEXP (DECL_RTL (t), 0), POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); #else abort (); #endif } else { extern tree get_file_function_name (int); tree init_name = get_file_function_name ('I'); tree init_type = build_function_type (void_type_node, end_params_node); tree init_decl; tree t; location_t saved_loc = input_location; init_decl = build_decl (FUNCTION_DECL, init_name, init_type); SET_DECL_ASSEMBLER_NAME (init_decl, init_name); DECL_SOURCE_LINE (init_decl) = 0; TREE_STATIC (init_decl) = 1; current_function_decl = init_decl; DECL_RESULT (init_decl) = build_decl (RESULT_DECL, NULL_TREE, void_type_node); /* It can be a static function as long as collect2 does not have to scan the object file to find its ctor/dtor routine. */ TREE_PUBLIC (init_decl) = ! targetm.have_ctors_dtors; /* Suppress spurious warnings. */ TREE_USED (init_decl) = 1; pushlevel (0); make_decl_rtl (init_decl, NULL); init_function_start (init_decl); expand_function_start (init_decl, 0); /* Do not allow the function to be deferred. */ current_function_cannot_inline = "static constructors and destructors cannot be inlined"; for ( t = registered_class; t; t = TREE_CHAIN (t)) emit_library_call (registerClass_libfunc, 0, VOIDmode, 1, XEXP (DECL_RTL (t), 0), Pmode); input_location = DECL_SOURCE_LOCATION (init_decl); expand_function_end (); poplevel (1, 0, 1); rest_of_compilation (init_decl); current_function_decl = NULL_TREE; if (targetm.have_ctors_dtors) (* targetm.asm_out.constructor) (XEXP (DECL_RTL (init_decl), 0), DEFAULT_INIT_PRIORITY); input_location = saved_loc; } } /* Make a method_symbol_type (_Jv_MethodSymbol) node for METHOD. */ static tree build_method_symbols_entry (tree method) { tree clname, name, signature, method_symbol; clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)))); name = build_utf8_ref (DECL_NAME (method)); signature = build_java_signature (TREE_TYPE (method)); signature = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (signature), IDENTIFIER_LENGTH (signature))); START_RECORD_CONSTRUCTOR (method_symbol, method_symbol_type); PUSH_FIELD_VALUE (method_symbol, "clname", clname); PUSH_FIELD_VALUE (method_symbol, "name", name); PUSH_FIELD_VALUE (method_symbol, "signature", signature); FINISH_RECORD_CONSTRUCTOR (method_symbol); TREE_CONSTANT (method_symbol) = 1; return method_symbol; } /* Emit the offset symbols table for indirect virtual dispatch. */ void emit_offset_symbol_table (void) { tree method_list, method, table, list, null_symbol; tree otable_bound, otable_array_type; int index; /* Only emit an offset table if this translation unit actually made virtual calls. */ if (otable_methods == NULL_TREE) return; /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */ index = 0; method_list = otable_methods; list = NULL_TREE; while (method_list != NULL_TREE) { method = TREE_VALUE (method_list); list = tree_cons (NULL_TREE, build_method_symbols_entry (method), list); method_list = TREE_CHAIN (method_list); index++; } /* Terminate the list with a "null" entry. */ START_RECORD_CONSTRUCTOR (null_symbol, method_symbol_type); PUSH_FIELD_VALUE (null_symbol, "clname", null_pointer_node); PUSH_FIELD_VALUE (null_symbol, "name", null_pointer_node); PUSH_FIELD_VALUE (null_symbol, "signature", null_pointer_node); FINISH_RECORD_CONSTRUCTOR (null_symbol); TREE_CONSTANT (null_symbol) = 1; list = tree_cons (NULL_TREE, null_symbol, list); /* Put the list in the right order and make it a constructor. */ list = nreverse (list); table = build_constructor (method_symbols_array_type, list); /* Make it the initial value for otable_syms and emit the decl. */ DECL_INITIAL (otable_syms_decl) = table; DECL_ARTIFICIAL (otable_syms_decl) = 1; DECL_IGNORED_P (otable_syms_decl) = 1; rest_of_decl_compilation (otable_syms_decl, NULL, 1, 0); /* Now that its size is known, redefine otable as an uninitialized static array of INDEX + 1 integers. The extra entry is used by the runtime to track whether the otable has been initialized. */ otable_bound = build_index_type (build_int_2 (index, 0)); otable_array_type = build_array_type (integer_type_node, otable_bound); otable_decl = build_decl (VAR_DECL, get_identifier ("otable"), otable_array_type); TREE_STATIC (otable_decl) = 1; TREE_READONLY (otable_decl) = 1; rest_of_decl_compilation (otable_decl, NULL, 1, 0); } void init_class_processing (void) { registerClass_libfunc = gen_rtx_SYMBOL_REF (Pmode, "_Jv_RegisterClass"); fields_ident = get_identifier ("fields"); info_ident = get_identifier ("info"); gcc_obstack_init (&temporary_obstack); } static hashval_t java_treetreehash_hash (const void *); static int java_treetreehash_compare (const void *, const void *); /* A hash table mapping trees to trees. Used generally. */ #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t)) static hashval_t java_treetreehash_hash (const void *k_p) { struct treetreehash_entry *k = (struct treetreehash_entry *) k_p; return JAVA_TREEHASHHASH_H (k->key); } static int java_treetreehash_compare (const void * k1_p, const void * k2_p) { struct treetreehash_entry * k1 = (struct treetreehash_entry *) k1_p; tree k2 = (tree) k2_p; return (k1->key == k2); } tree java_treetreehash_find (htab_t ht, tree t) { struct treetreehash_entry *e; hashval_t hv = JAVA_TREEHASHHASH_H (t); e = htab_find_with_hash (ht, t, hv); if (e == NULL) return NULL; else return e->value; } tree * java_treetreehash_new (htab_t ht, tree t) { void **e; struct treetreehash_entry *tthe; hashval_t hv = JAVA_TREEHASHHASH_H (t); e = htab_find_slot_with_hash (ht, t, hv, INSERT); if (*e == NULL) { tthe = (*ht->alloc_f) (1, sizeof (*tthe)); tthe->key = t; *e = tthe; } else tthe = (struct treetreehash_entry *) *e; return &tthe->value; } htab_t java_treetreehash_create (size_t size, int gc) { if (gc) return htab_create_ggc (size, java_treetreehash_hash, java_treetreehash_compare, NULL); else return htab_create_alloc (size, java_treetreehash_hash, java_treetreehash_compare, free, xcalloc, free); } #include "gt-java-class.h"


context:
space:
mode: