From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- gcc/java/constants.c | 620 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 620 insertions(+) create mode 100644 gcc/java/constants.c (limited to 'gcc/java/constants.c') diff --git a/gcc/java/constants.c b/gcc/java/constants.c new file mode 100644 index 000000000..4425338f6 --- /dev/null +++ b/gcc/java/constants.c @@ -0,0 +1,620 @@ +/* Handle the constant pool of the Java(TM) Virtual Machine. + Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, + 2007, 2008, 2010 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 +. + +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. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "jcf.h" +#include "tree.h" +#include "java-tree.h" +#include "diagnostic-core.h" +#include "toplev.h" +#include "ggc.h" + +static void set_constant_entry (CPool *, int, int, jword); +static int find_tree_constant (CPool *, int, tree); +static int find_name_and_type_constant (CPool *, tree, tree); +static tree get_tag_node (int); + +/* Set the INDEX'th constant in CPOOL to have the given TAG and VALUE. */ + +static void +set_constant_entry (CPool *cpool, int index, int tag, jword value) +{ + if (cpool->data == NULL) + { + cpool->capacity = 100; + cpool->tags = (uint8 *) ggc_alloc_cleared_atomic (sizeof (uint8) + * cpool->capacity); + cpool->data = ggc_alloc_cleared_vec_cpool_entry (sizeof + (union cpool_entry), + cpool->capacity); + cpool->count = 1; + } + if (index >= cpool->capacity) + { + int old_cap = cpool->capacity; + cpool->capacity *= 2; + if (index >= cpool->capacity) + cpool->capacity = index + 10; + cpool->tags = GGC_RESIZEVEC (uint8, cpool->tags, cpool->capacity); + cpool->data = GGC_RESIZEVEC (union cpool_entry, cpool->data, + cpool->capacity); + + /* Make sure GC never sees uninitialized tag values. */ + memset (cpool->tags + old_cap, 0, cpool->capacity - old_cap); + memset (cpool->data + old_cap, 0, + (cpool->capacity - old_cap) * sizeof (union cpool_entry)); + } + if (index >= cpool->count) + cpool->count = index + 1; + cpool->tags[index] = tag; + cpool->data[index].w = value; +} + +/* Find (or create) a constant pool entry matching TAG and VALUE. */ + +int +find_constant1 (CPool *cpool, int tag, jword value) +{ + int i; + for (i = cpool->count; --i > 0; ) + { + if (cpool->tags[i] == tag && cpool->data[i].w == value) + return i; + } + i = cpool->count == 0 ? 1 : cpool->count; + set_constant_entry (cpool, i, tag, value); + return i; +} + +/* Find a double-word constant pool entry matching TAG and WORD1/WORD2. */ + +int +find_constant2 (CPool *cpool, int tag, jword word1, jword word2) +{ + int i; + for (i = cpool->count - 1; --i > 0; ) + { + if (cpool->tags[i] == tag + && cpool->data[i].w == word1 + && cpool->data[i+1].w == word2) + return i; + } + i = cpool->count == 0 ? 1 : cpool->count; + set_constant_entry (cpool, i, tag, word1); + set_constant_entry (cpool, i+1, 0, word2); + return i; +} + +static int +find_tree_constant (CPool *cpool, int tag, tree value) +{ + int i; + for (i = cpool->count; --i > 0; ) + { + if (cpool->tags[i] == tag && cpool->data[i].t == value) + return i; + } + i = cpool->count == 0 ? 1 : cpool->count; + set_constant_entry (cpool, i, tag, 0); + cpool->data[i].t = value; + return i; +} + + +int +find_utf8_constant (CPool *cpool, tree name) +{ + if (name == NULL_TREE) + return 0; + return find_tree_constant (cpool, CONSTANT_Utf8, name); +} + +int +find_class_or_string_constant (CPool *cpool, int tag, tree name) +{ + jword j = find_utf8_constant (cpool, name); + int i; + for (i = cpool->count; --i > 0; ) + { + if (cpool->tags[i] == tag && cpool->data[i].w == j) + return i; + } + i = cpool->count; + set_constant_entry (cpool, i, tag, j); + return i; +} + +int +find_class_constant (CPool *cpool, tree type) +{ + return find_class_or_string_constant (cpool, CONSTANT_Class, + build_internal_class_name (type)); +} + +/* Allocate a CONSTANT_string entry given a STRING_CST. */ + +int +find_string_constant (CPool *cpool, tree string) +{ + string = get_identifier (TREE_STRING_POINTER (string)); + return find_class_or_string_constant (cpool, CONSTANT_String, string); + +} + +/* Find (or create) a CONSTANT_NameAndType matching NAME and TYPE. + Return its index in the constant pool CPOOL. */ + +static int +find_name_and_type_constant (CPool *cpool, tree name, tree type) +{ + int name_index = find_utf8_constant (cpool, name); + int type_index = find_utf8_constant (cpool, build_java_signature (type)); + return find_constant1 (cpool, CONSTANT_NameAndType, + (name_index << 16) | type_index); +} + +/* Find (or create) a CONSTANT_Fieldref for DECL (a FIELD_DECL or VAR_DECL). + Return its index in the constant pool CPOOL. */ + +int +find_fieldref_index (CPool *cpool, tree decl) +{ + int class_index = find_class_constant (cpool, DECL_CONTEXT (decl)); + int name_type_index + = find_name_and_type_constant (cpool, DECL_NAME (decl), TREE_TYPE (decl)); + return find_constant1 (cpool, CONSTANT_Fieldref, + (class_index << 16) | name_type_index); +} + +/* Find (or create) a CONSTANT_Methodref for DECL (a FUNCTION_DECL). + Return its index in the constant pool CPOOL. */ + +int +find_methodref_index (CPool *cpool, tree decl) +{ + return find_methodref_with_class_index (cpool, decl, DECL_CONTEXT (decl)); +} + +int +find_methodref_with_class_index (CPool *cpool, tree decl, tree mclass) +{ + int class_index = find_class_constant (cpool, mclass); + tree name = DECL_CONSTRUCTOR_P (decl) ? init_identifier_node + : DECL_NAME (decl); + int name_type_index; + name_type_index = + find_name_and_type_constant (cpool, name, TREE_TYPE (decl)); + return find_constant1 (cpool, + CLASS_INTERFACE (TYPE_NAME (mclass)) + ? CONSTANT_InterfaceMethodref + : CONSTANT_Methodref, + (class_index << 16) | name_type_index); +} + +#define PUT1(X) (*ptr++ = (X)) +#define PUT2(X) (PUT1((X) >> 8), PUT1(X)) +#define PUT4(X) (PUT2((X) >> 16), PUT2(X)) +#define PUTN(P, N) (memcpy(ptr, (P), (N)), ptr += (N)) + +/* Give the number of bytes needed in a .class file for the CPOOL + constant pool. Includes the 2-byte constant_pool_count. */ + +int +count_constant_pool_bytes (CPool *cpool) +{ + int size = 2; + int i = 1; + for ( ; i < cpool->count; i++) + { + size++; + switch (cpool->tags[i]) + { + case CONSTANT_NameAndType: + case CONSTANT_Fieldref: + case CONSTANT_Methodref: + case CONSTANT_InterfaceMethodref: + case CONSTANT_Float: + case CONSTANT_Integer: + size += 4; + break; + case CONSTANT_Class: + case CONSTANT_String: + size += 2; + break; + case CONSTANT_Long: + case CONSTANT_Double: + size += 8; + i++; + break; + case CONSTANT_Utf8: + { + tree t = cpool->data[i].t; + int len = IDENTIFIER_LENGTH (t); + size += len + 2; + } + break; + default: + /* Second word of CONSTANT_Long and CONSTANT_Double. */ + size--; + } + } + return size; +} + +/* Write the constant pool CPOOL into BUFFER. + The length of BUFFER is LENGTH, which must match the needed length. */ + +void +write_constant_pool (CPool *cpool, unsigned char *buffer, int length) +{ + unsigned char *ptr = buffer; + int i = 1; + union cpool_entry *datap = &cpool->data[1]; + PUT2 (cpool->count); + for ( ; i < cpool->count; i++, datap++) + { + int tag = cpool->tags[i]; + PUT1 (tag); + switch (tag) + { + case CONSTANT_NameAndType: + case CONSTANT_Fieldref: + case CONSTANT_Methodref: + case CONSTANT_InterfaceMethodref: + case CONSTANT_Float: + case CONSTANT_Integer: + PUT4 (datap->w); + break; + case CONSTANT_Class: + case CONSTANT_String: + PUT2 (datap->w); + break; + break; + case CONSTANT_Long: + case CONSTANT_Double: + PUT4(datap->w); + i++; + datap++; + PUT4 (datap->w); + break; + case CONSTANT_Utf8: + { + tree t = datap->t; + int len = IDENTIFIER_LENGTH (t); + PUT2 (len); + PUTN (IDENTIFIER_POINTER (t), len); + } + break; + } + } + + gcc_assert (ptr == buffer + length); +} + +static GTY(()) tree tag_nodes[13]; +static tree +get_tag_node (int tag) +{ + /* A Cache for build_int_cst (CONSTANT_XXX, 0). */ + + if (tag >= 13) + return build_int_cst (NULL_TREE, tag); + + if (tag_nodes[tag] == NULL_TREE) + tag_nodes[tag] = build_int_cst (NULL_TREE, tag); + return tag_nodes[tag]; +} + +/* Given a class, return its constant pool, creating one if necessary. */ + +CPool * +cpool_for_class (tree klass) +{ + CPool *cpool = TYPE_CPOOL (klass); + + if (cpool == NULL) + { + cpool = ggc_alloc_cleared_CPool (); + TYPE_CPOOL (klass) = cpool; + } + return cpool; +} + +/* Look for a constant pool entry that matches TAG and NAME. + Creates a new entry if not found. + TAG is one of CONSTANT_Utf8, CONSTANT_String or CONSTANT_Class. + NAME is an IDENTIFIER_NODE naming the Utf8 constant, string, or class. + Returns the index of the entry. */ + +int +alloc_name_constant (int tag, tree name) +{ + CPool *outgoing_cpool = cpool_for_class (output_class); + return find_tree_constant (outgoing_cpool, tag, name); +} + +/* Create a constant pool entry for a name_and_type. This one has '.' + rather than '/' because it isn't going into a class file, it's + going into a compiled object. We don't use the '/' separator in + compiled objects. */ + +static int +find_name_and_type_constant_tree (CPool *cpool, tree name, tree type) +{ + int name_index = find_utf8_constant (cpool, name); + int type_index + = find_utf8_constant (cpool, + identifier_subst (build_java_signature (type), + "", '/', '.', "")); + return find_constant1 (cpool, CONSTANT_NameAndType, + (name_index << 16) | type_index); +} + +/* Look for a field ref that matches DECL in the constant pool of + KLASS. + Return the index of the entry. */ + +int +alloc_constant_fieldref (tree klass, tree decl) +{ + CPool *outgoing_cpool = cpool_for_class (klass); + int class_index + = find_tree_constant (outgoing_cpool, CONSTANT_Class, + DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))); + int name_type_index + = find_name_and_type_constant_tree (outgoing_cpool, DECL_NAME (decl), + TREE_TYPE (decl)); + return find_constant1 (outgoing_cpool, CONSTANT_Fieldref, + (class_index << 16) | name_type_index); +} + +/* Build an identifier for the internal name of reference type TYPE. */ + +tree +build_internal_class_name (tree type) +{ + tree name; + if (TYPE_ARRAY_P (type)) + name = build_java_signature (type); + else + { + name = TYPE_NAME (type); + if (TREE_CODE (name) != IDENTIFIER_NODE) + name = DECL_NAME (name); + name = identifier_subst (name, "", '.', '/', ""); + } + return name; +} + +/* Look for a CONSTANT_Class entry for CLAS, creating a new one if needed. */ + +int +alloc_class_constant (tree clas) +{ + tree class_name = build_internal_class_name (clas); + + return alloc_name_constant (CONSTANT_Class, + (unmangle_classname + (IDENTIFIER_POINTER(class_name), + IDENTIFIER_LENGTH(class_name)))); +} + +/* Return the decl of the data array of the current constant pool. */ + +tree +build_constant_data_ref (bool indirect) +{ + if (indirect) + { + tree d; + tree cpool_type = build_array_type (ptr_type_node, NULL_TREE); + tree decl = build_class_ref (output_class); + tree klass = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (decl)), + decl); + tree constants = build3 (COMPONENT_REF, + TREE_TYPE (constants_field_decl_node), klass, + constants_field_decl_node, + NULL_TREE); + tree data = build3 (COMPONENT_REF, + TREE_TYPE (constants_data_field_decl_node), + constants, + constants_data_field_decl_node, + NULL_TREE); + + TREE_THIS_NOTRAP (klass) = 1; + data = fold_convert (build_pointer_type (cpool_type), data); + d = build1 (INDIRECT_REF, cpool_type, data); + + return d; + } + else + { + tree decl_name = mangled_classname ("_CD_", output_class); + tree decl = IDENTIFIER_GLOBAL_VALUE (decl_name); + + if (! decl) + { + /* Build a type with unspecified bounds. The will make sure + that targets do the right thing with whatever size we end + up with at the end. Using bounds that are too small risks + assuming the data is in the small data section. */ + tree type = build_array_type (ptr_type_node, NULL_TREE); + + /* We need to lay out the type ourselves, since build_array_type + thinks the type is incomplete. */ + layout_type (type); + + decl = build_decl (input_location, VAR_DECL, decl_name, type); + TREE_STATIC (decl) = 1; + IDENTIFIER_GLOBAL_VALUE (decl_name) = decl; + } + + return decl; + } +} + +/* Get the pointer value at the INDEX'th element of the constant pool. */ + +tree +build_ref_from_constant_pool (int index) +{ + tree i; + tree d = TYPE_CPOOL_DATA_REF (output_class); + + if (d == NULL_TREE) + d = build_constant_data_ref (flag_indirect_classes); + + i = build_int_cst (NULL_TREE, index); + d = build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (d)), d, i, + NULL_TREE, NULL_TREE); + return d; +} + +/* Build an initializer for the constants field of the current constant pool. + Should only be called at top-level, since it may emit declarations. */ + +tree +build_constants_constructor (void) +{ + CPool *outgoing_cpool = cpool_for_class (current_class); + tree tags_value, data_value; + tree cons; + VEC(constructor_elt,gc) *v = NULL; + int i; + VEC(constructor_elt,gc) *tags = NULL; + VEC(constructor_elt,gc) *data = NULL; + constructor_elt *t = NULL; + constructor_elt *d = NULL; + + if (outgoing_cpool->count > 0) + { + int c = outgoing_cpool->count; + VEC_safe_grow_cleared (constructor_elt, gc, tags, c); + VEC_safe_grow_cleared (constructor_elt, gc, data, c); + t = VEC_index (constructor_elt, tags, c-1); + d = VEC_index (constructor_elt, data, c-1); + } + +#define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E-- + for (i = outgoing_cpool->count; --i > 0; ) + switch (outgoing_cpool->tags[i] & ~CONSTANT_LazyFlag) + { + case CONSTANT_None: /* The second half of a Double or Long on a + 32-bit target. */ + case CONSTANT_Fieldref: + case CONSTANT_NameAndType: + case CONSTANT_Float: + case CONSTANT_Integer: + case CONSTANT_Double: + case CONSTANT_Long: + case CONSTANT_Methodref: + case CONSTANT_InterfaceMethodref: + { + unsigned HOST_WIDE_INT temp = outgoing_cpool->data[i].w; + + /* Make sure that on a big-endian machine with 64-bit + pointers this 32-bit jint appears in the first word. + FIXME: This is a kludge. The field we're initializing is + not a scalar but a union, and that's how we should + represent it in the compiler. We should fix this. */ + if (BYTES_BIG_ENDIAN) + temp <<= ((POINTER_SIZE > 32) ? POINTER_SIZE - 32 : 0); + + CONSTRUCTOR_PREPEND_VALUE (t, get_tag_node (outgoing_cpool->tags[i])); + CONSTRUCTOR_PREPEND_VALUE (d, + fold_convert (ptr_type_node, + (build_int_cst (NULL_TREE, + temp)))); + } + break; + + case CONSTANT_Class: + case CONSTANT_String: + case CONSTANT_Unicode: + case CONSTANT_Utf8: + CONSTRUCTOR_PREPEND_VALUE (t, get_tag_node (outgoing_cpool->tags[i])); + CONSTRUCTOR_PREPEND_VALUE (d, build_utf8_ref (outgoing_cpool->data[i].t)); + break; + + default: + gcc_assert (false); + } +#undef CONSTRUCTOR_PREPEND_VALUE + + if (outgoing_cpool->count > 0) + { + tree data_decl, tags_decl, tags_type; + tree max_index = build_int_cst (sizetype, outgoing_cpool->count - 1); + tree index_type = build_index_type (max_index); + tree tem; + + /* Add dummy 0'th element of constant pool. */ + gcc_assert (t == VEC_address (constructor_elt, tags)); + gcc_assert (d == VEC_address (constructor_elt, data)); + t->value = get_tag_node (0); + d->value = null_pointer_node; + + /* Change the type of the decl to have the proper array size. + ??? Make sure to transition the old type-pointer-to list to this + new type to not invalidate all build address expressions. */ + data_decl = build_constant_data_ref (false); + tem = TYPE_POINTER_TO (TREE_TYPE (data_decl)); + if (!tem) + tem = build_pointer_type (TREE_TYPE (data_decl)); + TYPE_POINTER_TO (TREE_TYPE (data_decl)) = NULL_TREE; + TREE_TYPE (data_decl) = build_array_type (ptr_type_node, index_type); + TYPE_POINTER_TO (TREE_TYPE (data_decl)) = tem; + DECL_INITIAL (data_decl) = build_constructor (TREE_TYPE (data_decl), data); + DECL_SIZE (data_decl) = TYPE_SIZE (TREE_TYPE (data_decl)); + DECL_SIZE_UNIT (data_decl) = TYPE_SIZE_UNIT (TREE_TYPE (data_decl)); + rest_of_decl_compilation (data_decl, 1, 0); + data_value = build_address_of (data_decl); + + tags_type = build_array_type (unsigned_byte_type_node, index_type); + tags_decl = build_decl (input_location, + VAR_DECL, mangled_classname ("_CT_", + current_class), + tags_type); + TREE_STATIC (tags_decl) = 1; + DECL_INITIAL (tags_decl) = build_constructor (tags_type, tags); + rest_of_decl_compilation (tags_decl, 1, 0); + tags_value = build_address_of (tags_decl); + } + else + { + data_value = null_pointer_node; + tags_value = null_pointer_node; + } + START_RECORD_CONSTRUCTOR (v, constants_type_node); + PUSH_FIELD_VALUE (v, "size", + build_int_cst (NULL_TREE, outgoing_cpool->count)); + PUSH_FIELD_VALUE (v, "tags", tags_value); + PUSH_FIELD_VALUE (v, "data", data_value); + FINISH_RECORD_CONSTRUCTOR (cons, v, constants_type_node); + return cons; +} + +#include "gt-java-constants.h" -- cgit v1.2.3