/* 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, 2008
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 = build3 (COND_EXPR, type,
- build2 (NE_EXPR, boolean_type_node, expr, expr),
- convert (type, integer_zero_node),
- convert_to_integer (type, expr));
-
- result = build3 (COND_EXPR, type,
- build2 (LE_EXPR, boolean_type_node, expr,
- convert (TREE_TYPE (expr), TYPE_MIN_VALUE (type))),
- TYPE_MIN_VALUE (type),
- result);
-
- result = build3 (COND_EXPR, type,
- 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 (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
- && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
- && TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
- return fold (convert_ieee_real_to_integer (type, expr));
+ 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)
+ 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 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. */
-
-bool
-java_mark_addressable (tree exp)
-{
- tree x = exp;
- while (1)
- switch (TREE_CODE (x))
- {
- case ADDR_EXPR:
- case COMPONENT_REF:
- case ARRAY_REF:
- case REALPART_EXPR:
- case IMAGPART_EXPR:
- x = TREE_OPERAND (x, 0);
- break;
-
- case TRUTH_ANDIF_EXPR:
- case TRUTH_ORIF_EXPR:
- case COMPOUND_EXPR:
- x = TREE_OPERAND (x, 1);
- break;
-
- case COND_EXPR:
- return java_mark_addressable (TREE_OPERAND (x, 1))
- && java_mark_addressable (TREE_OPERAND (x, 2));
-
- case CONSTRUCTOR:
- TREE_ADDRESSABLE (x) = 1;
- return true;
-
- case INDIRECT_REF:
- /* We sometimes add a cast *(TYPE*)&FOO to handle type and mode
- incompatibility problems. Handle this case by marking FOO. */
- if (TREE_CODE (TREE_OPERAND (x, 0)) == NOP_EXPR
- && TREE_CODE (TREE_OPERAND (TREE_OPERAND (x, 0), 0)) == ADDR_EXPR)
- {
- x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
- break;
- }
- if (TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
- {
- x = TREE_OPERAND (x, 0);
- break;
- }
- return true;
-
- case VAR_DECL:
- case CONST_DECL:
- case PARM_DECL:
- case RESULT_DECL:
- case FUNCTION_DECL:
- TREE_ADDRESSABLE (x) = 1;
-#if 0 /* poplevel deals with this now. */
- if (DECL_CONTEXT (x) == 0)
- TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
-#endif
- /* drops through */
- default:
- return true;
- }
-}
-
/* Thorough checking of the arrayness of TYPE. */
int
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 (input_location, 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);
TYPE_ARRAY_ELEMENT (t) = element_type;
/* Add length pseudo-field. */
- fld = build_decl (FIELD_DECL, get_identifier ("length"), int_type_node);
+ fld = build_decl (input_location,
+ FIELD_DECL, get_identifier ("length"), int_type_node);
TYPE_FIELDS (t) = fld;
DECL_CONTEXT (fld) = t;
FIELD_PUBLIC (fld) = 1;
TREE_READONLY (fld) = 1;
atype = build_prim_array_type (element_type, length);
- arfld = build_decl (FIELD_DECL, get_identifier ("data"), atype);
+ arfld = build_decl (input_location,
+ FIELD_DECL, get_identifier ("data"), atype);
DECL_CONTEXT (arfld) = t;
TREE_CHAIN (fld) = arfld;
DECL_ALIGN (arfld) = TYPE_ALIGN (element_type);
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 KLASS (or its ancestors) has a method METHOD_NAME. */
int
-has_method (tree class, tree method_name)
+has_method (tree klass, tree method_name)
{
- return lookup_do (class, SEARCH_INTERFACE,
+ return lookup_do (klass, SEARCH_INTERFACE,
method_name, NULL_TREE,
build_null_signature) != NULL_TREE;
}
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;