/* 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.
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)
+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,
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.
+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.
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 = fold (build3 (COND_EXPR, type,
- fold (build2 (NE_EXPR, boolean_type_node, expr, expr)),
+ 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)));
+ 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 (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));
+ 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;
}
return error_mark_node;
if (code == VOID_TYPE)
return build1 (CONVERT_EXPR, type, expr);
- if (code == BOOLEAN_TYPE || code == CHAR_TYPE)
+ if (code == BOOLEAN_TYPE)
return fold_convert (type, expr);
if (code == INTEGER_TYPE)
{
- if ((really_constant_p (expr)
- || (! 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;
}
}
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 an unsigned type the same as TYPE in other respects. */
-
-tree
-java_unsigned_type (tree type)
-{
- return java_signed_or_unsigned_type (1, type);
-}
-
/* Mark EXP saying that we need to be able to take the
address of it; it should not be allocated in a register.
Value is true if successful. */
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. */
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] = '[';
if (TREE_CODE (el_name) == TYPE_DECL)
el_name = DECL_NAME (el_name);
{
- char suffix[12];
+ 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);
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;
}
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;
}
tree method;
/* If the superinterface hasn't been loaded yet, do so now. */
- if (CLASS_FROM_SOURCE_P (iclass))
- safe_layout_class (iclass);
- else if (!CLASS_LOADED_P (iclass))
+ if (!CLASS_LOADED_P (iclass))
load_class (iclass, 1);
/* First, we look in ICLASS. If that doesn't work we'll
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;
OSDN Git Service
