/* Handle types for the GNU compiler for the Java(TM) language.
- Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007
Free Software Foundation, Inc.
This file is part of GCC.
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.
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.
Java and all Java-based marks are trademarks or registered trademarks
of Sun Microsystems, Inc. in the United States and other countries.
int max_locals = DECL_MAX_LOCALS(current_function_decl);
int nslots = TYPE_IS_WIDE (type) ? 2 : 1;
- if (slot < 0 || slot + nslots - 1 >= max_locals)
- abort ();
+ gcc_assert (slot >= 0 && (slot + nslots - 1 < max_locals));
type_map[slot] = type;
while (--nslots > 0)
tree result;
expr = save_expr (expr);
- result = build (COND_EXPR, type,
- build (NE_EXPR, boolean_type_node, expr, expr),
- convert (type, integer_zero_node),
- convert_to_integer (type, expr));
-
- result = build (COND_EXPR, type,
- build (LE_EXPR, boolean_type_node, expr,
- convert (TREE_TYPE (expr), TYPE_MIN_VALUE (type))),
- TYPE_MIN_VALUE (type),
- result);
-
- result = build (COND_EXPR, type,
- build (GE_EXPR, boolean_type_node, expr,
- convert (TREE_TYPE (expr), TYPE_MAX_VALUE (type))),
- TYPE_MAX_VALUE (type),
- result);
+ result = fold_build3 (COND_EXPR, type,
+ fold_build2 (NE_EXPR, boolean_type_node, expr, expr),
+ convert (type, integer_zero_node),
+ convert_to_integer (type, expr));
+
+ result = fold_build3 (COND_EXPR, type,
+ fold_build2 (LE_EXPR, boolean_type_node, expr,
+ convert (TREE_TYPE (expr),
+ TYPE_MIN_VALUE (type))),
+ TYPE_MIN_VALUE (type),
+ result);
+
+ result = fold_build3 (COND_EXPR, type,
+ fold_build2 (GE_EXPR, boolean_type_node, expr,
+ convert (TREE_TYPE (expr),
+ TYPE_MAX_VALUE (type))),
+ TYPE_MAX_VALUE (type),
+ result);
return result;
}
if (!expr)
return error_mark_node;
- if (do_not_fold)
- return build1 (NOP_EXPR, type, expr);
-
if (type == TREE_TYPE (expr)
|| TREE_CODE (expr) == ERROR_MARK)
return expr;
if (code == VOID_TYPE)
return build1 (CONVERT_EXPR, type, expr);
if (code == BOOLEAN_TYPE)
- return fold (convert_to_boolean (type, expr));
+ return fold_convert (type, expr);
if (code == INTEGER_TYPE)
{
- if (! flag_unsafe_math_optimizations
- && ! flag_emit_class_files
+ if (type == char_type_node || type == promoted_char_type_node)
+ return fold_convert (type, expr);
+ if ((really_constant_p (expr) || ! flag_unsafe_math_optimizations)
&& TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
&& TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
- return fold (convert_ieee_real_to_integer (type, expr));
+ return convert_ieee_real_to_integer (type, expr);
else
{
/* fold very helpfully sets the overflow status if a type
overflows in a narrowing integer conversion, but Java
doesn't care. */
tree tmp = fold (convert_to_integer (type, expr));
- TREE_OVERFLOW (tmp) = 0;
+ if (TREE_CODE (tmp) == INTEGER_CST)
+ TREE_OVERFLOW (tmp) = 0;
return tmp;
}
}
if (code == REAL_TYPE)
return fold (convert_to_real (type, expr));
- if (code == CHAR_TYPE)
- return fold (convert_to_char (type, expr));
if (code == POINTER_TYPE)
return fold (convert_to_pointer (type, expr));
error ("conversion to non-scalar type requested");
}
-tree
-convert_to_char (tree type, tree expr)
-{
- return build1 (NOP_EXPR, type, expr);
-}
-
-tree
-convert_to_boolean (tree type, tree expr)
-{
- return build1 (NOP_EXPR, type, expr);
-}
-
/* Return a data type that has machine mode MODE.
If the mode is an integer,
then UNSIGNEDP selects between signed and unsigned types. */
return 0;
}
-/* Return a type the same as TYPE except unsigned or
- signed according to UNSIGNEDP. */
-
-tree
-java_signed_or_unsigned_type (int unsignedp, tree type)
-{
- if (! INTEGRAL_TYPE_P (type))
- return type;
- if (TYPE_PRECISION (type) == TYPE_PRECISION (int_type_node))
- return unsignedp ? unsigned_int_type_node : int_type_node;
- if (TYPE_PRECISION (type) == TYPE_PRECISION (byte_type_node))
- return unsignedp ? unsigned_byte_type_node : byte_type_node;
- if (TYPE_PRECISION (type) == TYPE_PRECISION (short_type_node))
- return unsignedp ? unsigned_short_type_node : short_type_node;
- if (TYPE_PRECISION (type) == TYPE_PRECISION (long_type_node))
- return unsignedp ? unsigned_long_type_node : long_type_node;
- return type;
-}
-
/* Return a signed type the same as TYPE in other respects. */
tree
java_signed_type (tree type)
{
- return java_signed_or_unsigned_type (0, type);
+ return get_signed_or_unsigned_type (0, type);
}
/* Return an unsigned type the same as TYPE in other respects. */
tree
java_unsigned_type (tree type)
{
- return java_signed_or_unsigned_type (1, type);
+ return get_signed_or_unsigned_type (1, type);
}
/* Mark EXP saying that we need to be able to take the
return -1;
}
-/* An array of unknown length will be ultimately given an length of
+/* An array of unknown length will be ultimately given a length of
-2, so that we can still have `length' producing a negative value
even if found. This was part of an optimization aiming at removing
`length' from static arrays. We could restore it, FIXME. */
if (length != -1)
{
- tree max_index = build_int_2 (length - 1, (0 == length ? -1 : 0));
- TREE_TYPE (max_index) = sizetype;
+ tree max_index = build_int_cst (sizetype, length - 1);
index = build_index_type (max_index);
}
return build_array_type (element_type, index);
build_java_array_type (tree element_type, HOST_WIDE_INT length)
{
tree sig, t, fld, atype, arfld;
- char buf[12];
+ char buf[23];
tree elsig = build_java_signature (element_type);
tree el_name = element_type;
buf[0] = '[';
el_name = TYPE_NAME (el_name);
if (TREE_CODE (el_name) == TYPE_DECL)
el_name = DECL_NAME (el_name);
- TYPE_NAME (t) = build_decl (TYPE_DECL,
- identifier_subst (el_name, "", '.', '.', "[]"),
+ {
+ char suffix[23];
+ if (length >= 0)
+ sprintf (suffix, "[%d]", (int)length);
+ else
+ strcpy (suffix, "[]");
+ TYPE_NAME (t)
+ = TYPE_STUB_DECL (t)
+ = build_decl (TYPE_DECL,
+ identifier_subst (el_name, "", '.', '.', suffix),
t);
+ TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (t)) = true;
+ }
set_java_signature (t, sig);
set_super_info (0, t, object_type_node, 0);
if (type == boolean_type_node)
return promoted_boolean_type_node;
goto handle_int;
- case CHAR_TYPE:
+ case INTEGER_TYPE:
if (type == char_type_node)
return promoted_char_type_node;
- goto handle_int;
- case INTEGER_TYPE:
handle_int:
if (TYPE_PRECISION (type) < TYPE_PRECISION (int_type_node))
{
parse_signature_type (const unsigned char **ptr, const unsigned char *limit)
{
tree type;
-
- if (*ptr >= limit)
- abort ();
+ gcc_assert (*ptr < limit);
switch (**ptr)
{
const unsigned char *str = start;
for ( ; ; str++)
{
- if (str >= limit)
- abort ();
+ gcc_assert (str < limit);
if (*str == ';')
break;
}
*ptr = str+1;
- type = lookup_class (unmangle_classname (start, str - start));
+ type = lookup_class (unmangle_classname ((const char *) start, str - start));
break;
}
default:
- abort ();
+ gcc_unreachable ();
}
return promote_type (type);
}
switch (TREE_CODE (type))
{
case BOOLEAN_TYPE: sg[0] = 'Z'; goto native;
- case CHAR_TYPE: sg[0] = 'C'; goto native;
case VOID_TYPE: sg[0] = 'V'; goto native;
case INTEGER_TYPE:
+ if (type == char_type_node || type == promoted_char_type_node)
+ {
+ sg[0] = 'C';
+ goto native;
+ }
switch (TYPE_PRECISION (type))
{
case 8: sg[0] = 'B'; goto native;
break;
bad_type:
default:
- abort ();
+ gcc_unreachable ();
}
TYPE_SIGNATURE (type) = sig;
}
method_signature, build_java_signature);
}
-/* Return true iff CLASS (or its ancestors) has a method METHOD_NAME. */
+/* Return true iff CLASS (or its ancestors) has a method METHOD_NAME. */
int
has_method (tree class, tree method_name)
{
tree signature, tree (*signature_builder) (tree))
{
int i;
- int interface_len =
- TREE_VEC_LENGTH (BINFO_BASE_BINFOS (TYPE_BINFO (searched_class))) - 1;
+ tree binfo, base_binfo;
- for (i = interface_len; i > 0; i--)
+ for (binfo = TYPE_BINFO (searched_class), i = 1;
+ BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
{
- tree child = BINFO_BASE_BINFO (TYPE_BINFO (searched_class), i);
- tree iclass = BINFO_TYPE (child);
+ tree iclass = BINFO_TYPE (base_binfo);
tree method;
/* If the superinterface hasn't been loaded yet, do so now. */
/* First, we look in ICLASS. If that doesn't work we'll
recursively look through all its superinterfaces. */
method = shallow_find_method (iclass, flags, method_name,
- signature, signature_builder);
+ signature, signature_builder);
if (method != NULL_TREE)
return method;
tree signature, tree (*signature_builder) (tree))
{
tree method;
+ tree orig_class = searched_class;
if (searched_class == NULL_TREE)
return NULL_TREE;
/* If that doesn't work, look in our interfaces. */
if (flags & SEARCH_INTERFACE)
- method = find_method_in_interfaces (searched_class, flags, method_name,
+ method = find_method_in_interfaces (orig_class, flags, method_name,
signature, signature_builder);
return method;