830 lines
24 KiB
C
830 lines
24 KiB
C
|
/* Handle types for the GNU compiler for the Java(TM) language.
|
|||
|
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 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
|
|||
|
<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.
|
|||
|
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 "real.h"
|
|||
|
#include "obstack.h"
|
|||
|
#include "flags.h"
|
|||
|
#include "java-tree.h"
|
|||
|
#include "jcf.h"
|
|||
|
#include "convert.h"
|
|||
|
#include "toplev.h"
|
|||
|
#include "ggc.h"
|
|||
|
|
|||
|
static tree convert_ieee_real_to_integer (tree, tree);
|
|||
|
static tree parse_signature_type (const unsigned char **,
|
|||
|
const unsigned char *);
|
|||
|
static tree lookup_do (tree, int, tree, tree, tree (*)(tree));
|
|||
|
static tree build_null_signature (tree);
|
|||
|
|
|||
|
tree * type_map;
|
|||
|
|
|||
|
/* Set the type of the local variable with index SLOT to TYPE. */
|
|||
|
|
|||
|
void
|
|||
|
set_local_type (int slot, tree type)
|
|||
|
{
|
|||
|
int max_locals = DECL_MAX_LOCALS(current_function_decl);
|
|||
|
int nslots = TYPE_IS_WIDE (type) ? 2 : 1;
|
|||
|
|
|||
|
gcc_assert (slot >= 0 && (slot + nslots - 1 < max_locals));
|
|||
|
|
|||
|
type_map[slot] = type;
|
|||
|
while (--nslots > 0)
|
|||
|
type_map[++slot] = void_type_node;
|
|||
|
}
|
|||
|
|
|||
|
/* Convert an IEEE real to an integer type. The result of such a
|
|||
|
conversion when the source operand is a NaN isn't defined by
|
|||
|
IEEE754, but by the Java language standard: it must be zero. Also,
|
|||
|
overflows must be clipped to within range. This conversion
|
|||
|
produces something like:
|
|||
|
|
|||
|
((expr >= (float)MAX_INT)
|
|||
|
? MAX_INT
|
|||
|
: ((expr <= (float)MIN_INT)
|
|||
|
? MIN_INT
|
|||
|
: ((expr != expr)
|
|||
|
? 0
|
|||
|
: (int)expr))) */
|
|||
|
|
|||
|
static tree
|
|||
|
convert_ieee_real_to_integer (tree type, tree expr)
|
|||
|
{
|
|||
|
tree result;
|
|||
|
expr = save_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));
|
|||
|
|
|||
|
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;
|
|||
|
}
|
|||
|
|
|||
|
/* Create an expression whose value is that of EXPR,
|
|||
|
converted to type TYPE. The TREE_TYPE of the value
|
|||
|
is always TYPE. This function implements all reasonable
|
|||
|
conversions; callers should filter out those that are
|
|||
|
not permitted by the language being compiled. */
|
|||
|
|
|||
|
tree
|
|||
|
convert (tree type, tree expr)
|
|||
|
{
|
|||
|
enum tree_code code = TREE_CODE (type);
|
|||
|
|
|||
|
if (!expr)
|
|||
|
return error_mark_node;
|
|||
|
|
|||
|
if (type == TREE_TYPE (expr)
|
|||
|
|| TREE_CODE (expr) == ERROR_MARK)
|
|||
|
return expr;
|
|||
|
if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
|
|||
|
return error_mark_node;
|
|||
|
if (code == VOID_TYPE)
|
|||
|
return build1 (CONVERT_EXPR, type, expr);
|
|||
|
if (code == BOOLEAN_TYPE)
|
|||
|
return fold_convert (type, expr);
|
|||
|
if (code == INTEGER_TYPE)
|
|||
|
{
|
|||
|
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));
|
|||
|
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 == POINTER_TYPE)
|
|||
|
return fold (convert_to_pointer (type, expr));
|
|||
|
error ("conversion to non-scalar type requested");
|
|||
|
return error_mark_node;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* Return a data type that has machine mode MODE.
|
|||
|
If the mode is an integer,
|
|||
|
then UNSIGNEDP selects between signed and unsigned types. */
|
|||
|
|
|||
|
tree
|
|||
|
java_type_for_mode (enum machine_mode mode, int unsignedp)
|
|||
|
{
|
|||
|
if (mode == TYPE_MODE (int_type_node))
|
|||
|
return unsignedp ? unsigned_int_type_node : int_type_node;
|
|||
|
if (mode == TYPE_MODE (long_type_node))
|
|||
|
return unsignedp ? unsigned_long_type_node : long_type_node;
|
|||
|
if (mode == TYPE_MODE (short_type_node))
|
|||
|
return unsignedp ? unsigned_short_type_node : short_type_node;
|
|||
|
if (mode == TYPE_MODE (byte_type_node))
|
|||
|
return unsignedp ? unsigned_byte_type_node : byte_type_node;
|
|||
|
if (mode == TYPE_MODE (float_type_node))
|
|||
|
return float_type_node;
|
|||
|
if (mode == TYPE_MODE (double_type_node))
|
|||
|
return double_type_node;
|
|||
|
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
/* Return an integer type with BITS bits of precision,
|
|||
|
that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
|
|||
|
|
|||
|
tree
|
|||
|
java_type_for_size (unsigned bits, int unsignedp)
|
|||
|
{
|
|||
|
if (bits <= TYPE_PRECISION (byte_type_node))
|
|||
|
return unsignedp ? unsigned_byte_type_node : byte_type_node;
|
|||
|
if (bits <= TYPE_PRECISION (short_type_node))
|
|||
|
return unsignedp ? unsigned_short_type_node : short_type_node;
|
|||
|
if (bits <= TYPE_PRECISION (int_type_node))
|
|||
|
return unsignedp ? unsigned_int_type_node : int_type_node;
|
|||
|
if (bits <= TYPE_PRECISION (long_type_node))
|
|||
|
return unsignedp ? unsigned_long_type_node : long_type_node;
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
/* Thorough checking of the arrayness of TYPE. */
|
|||
|
|
|||
|
int
|
|||
|
is_array_type_p (tree type)
|
|||
|
{
|
|||
|
return TREE_CODE (type) == POINTER_TYPE
|
|||
|
&& TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
|
|||
|
&& TYPE_ARRAY_P (TREE_TYPE (type));
|
|||
|
}
|
|||
|
|
|||
|
/* Return the length of a Java array type.
|
|||
|
Return -1 if the length is unknown or non-constant. */
|
|||
|
|
|||
|
HOST_WIDE_INT
|
|||
|
java_array_type_length (tree array_type)
|
|||
|
{
|
|||
|
tree arfld;
|
|||
|
if (TREE_CODE (array_type) == POINTER_TYPE)
|
|||
|
array_type = TREE_TYPE (array_type);
|
|||
|
arfld = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type)));
|
|||
|
if (arfld != NULL_TREE)
|
|||
|
{
|
|||
|
tree index_type = TYPE_DOMAIN (TREE_TYPE (arfld));
|
|||
|
if (index_type != NULL_TREE)
|
|||
|
{
|
|||
|
tree high = TYPE_MAX_VALUE (index_type);
|
|||
|
if (TREE_CODE (high) == INTEGER_CST)
|
|||
|
return TREE_INT_CST_LOW (high) + 1;
|
|||
|
}
|
|||
|
}
|
|||
|
return -1;
|
|||
|
}
|
|||
|
|
|||
|
/* 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. */
|
|||
|
|
|||
|
tree
|
|||
|
build_prim_array_type (tree element_type, HOST_WIDE_INT length)
|
|||
|
{
|
|||
|
tree index = NULL;
|
|||
|
|
|||
|
if (length != -1)
|
|||
|
{
|
|||
|
tree max_index = build_int_cst (sizetype, length - 1);
|
|||
|
index = build_index_type (max_index);
|
|||
|
}
|
|||
|
return build_array_type (element_type, index);
|
|||
|
}
|
|||
|
|
|||
|
/* Return a Java array type with a given ELEMENT_TYPE and LENGTH.
|
|||
|
These are hashed (shared) using IDENTIFIER_SIGNATURE_TYPE.
|
|||
|
The LENGTH is -1 if the length is unknown. */
|
|||
|
|
|||
|
tree
|
|||
|
build_java_array_type (tree element_type, HOST_WIDE_INT length)
|
|||
|
{
|
|||
|
tree sig, t, fld, atype, arfld;
|
|||
|
char buf[23];
|
|||
|
tree elsig = build_java_signature (element_type);
|
|||
|
tree el_name = element_type;
|
|||
|
buf[0] = '[';
|
|||
|
if (length >= 0)
|
|||
|
sprintf (buf+1, HOST_WIDE_INT_PRINT_DEC, length);
|
|||
|
else
|
|||
|
buf[1] = '\0';
|
|||
|
sig = ident_subst (IDENTIFIER_POINTER (elsig), IDENTIFIER_LENGTH (elsig),
|
|||
|
buf, 0, 0, "");
|
|||
|
t = IDENTIFIER_SIGNATURE_TYPE (sig);
|
|||
|
if (t != NULL_TREE)
|
|||
|
return TREE_TYPE (t);
|
|||
|
t = make_class ();
|
|||
|
IDENTIFIER_SIGNATURE_TYPE (sig) = build_pointer_type (t);
|
|||
|
TYPE_ARRAY_P (t) = 1;
|
|||
|
|
|||
|
if (TREE_CODE (el_name) == POINTER_TYPE)
|
|||
|
el_name = TREE_TYPE (el_name);
|
|||
|
el_name = TYPE_NAME (el_name);
|
|||
|
if (TREE_CODE (el_name) == TYPE_DECL)
|
|||
|
el_name = DECL_NAME (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);
|
|||
|
if (TREE_CODE (element_type) == RECORD_TYPE)
|
|||
|
element_type = promote_type (element_type);
|
|||
|
TYPE_ARRAY_ELEMENT (t) = element_type;
|
|||
|
|
|||
|
/* Add length pseudo-field. */
|
|||
|
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;
|
|||
|
FIELD_FINAL (fld) = 1;
|
|||
|
TREE_READONLY (fld) = 1;
|
|||
|
|
|||
|
atype = build_prim_array_type (element_type, length);
|
|||
|
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);
|
|||
|
|
|||
|
/* We could layout_class, but that loads java.lang.Object prematurely.
|
|||
|
* This is called by the parser, and it is a bad idea to do load_class
|
|||
|
* in the middle of parsing, because of possible circularity problems. */
|
|||
|
push_super_field (t, object_type_node);
|
|||
|
layout_type (t);
|
|||
|
|
|||
|
return t;
|
|||
|
}
|
|||
|
|
|||
|
/* Promote TYPE to the type actually used for fields and parameters. */
|
|||
|
|
|||
|
tree
|
|||
|
promote_type (tree type)
|
|||
|
{
|
|||
|
switch (TREE_CODE (type))
|
|||
|
{
|
|||
|
case RECORD_TYPE:
|
|||
|
return build_pointer_type (type);
|
|||
|
case BOOLEAN_TYPE:
|
|||
|
if (type == boolean_type_node)
|
|||
|
return promoted_boolean_type_node;
|
|||
|
goto handle_int;
|
|||
|
case INTEGER_TYPE:
|
|||
|
if (type == char_type_node)
|
|||
|
return promoted_char_type_node;
|
|||
|
handle_int:
|
|||
|
if (TYPE_PRECISION (type) < TYPE_PRECISION (int_type_node))
|
|||
|
{
|
|||
|
if (type == short_type_node)
|
|||
|
return promoted_short_type_node;
|
|||
|
if (type == byte_type_node)
|
|||
|
return promoted_byte_type_node;
|
|||
|
return int_type_node;
|
|||
|
}
|
|||
|
/* ... else fall through ... */
|
|||
|
default:
|
|||
|
return type;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/* Parse a signature string, starting at *PTR and ending at LIMIT.
|
|||
|
Return the seen TREE_TYPE, updating *PTR. */
|
|||
|
|
|||
|
static tree
|
|||
|
parse_signature_type (const unsigned char **ptr, const unsigned char *limit)
|
|||
|
{
|
|||
|
tree type;
|
|||
|
gcc_assert (*ptr < limit);
|
|||
|
|
|||
|
switch (**ptr)
|
|||
|
{
|
|||
|
case 'B': (*ptr)++; return byte_type_node;
|
|||
|
case 'C': (*ptr)++; return char_type_node;
|
|||
|
case 'D': (*ptr)++; return double_type_node;
|
|||
|
case 'F': (*ptr)++; return float_type_node;
|
|||
|
case 'S': (*ptr)++; return short_type_node;
|
|||
|
case 'I': (*ptr)++; return int_type_node;
|
|||
|
case 'J': (*ptr)++; return long_type_node;
|
|||
|
case 'Z': (*ptr)++; return boolean_type_node;
|
|||
|
case 'V': (*ptr)++; return void_type_node;
|
|||
|
case '[':
|
|||
|
for ((*ptr)++; (*ptr) < limit && ISDIGIT (**ptr); ) (*ptr)++;
|
|||
|
type = parse_signature_type (ptr, limit);
|
|||
|
type = build_java_array_type (type, -1);
|
|||
|
break;
|
|||
|
case 'L':
|
|||
|
{
|
|||
|
const unsigned char *start = ++(*ptr);
|
|||
|
const unsigned char *str = start;
|
|||
|
for ( ; ; str++)
|
|||
|
{
|
|||
|
gcc_assert (str < limit);
|
|||
|
if (*str == ';')
|
|||
|
break;
|
|||
|
}
|
|||
|
*ptr = str+1;
|
|||
|
type = lookup_class (unmangle_classname ((const char *) start, str - start));
|
|||
|
break;
|
|||
|
}
|
|||
|
default:
|
|||
|
gcc_unreachable ();
|
|||
|
}
|
|||
|
return promote_type (type);
|
|||
|
}
|
|||
|
|
|||
|
/* Parse a Java "mangled" signature string, starting at SIG_STRING,
|
|||
|
and SIG_LENGTH bytes long.
|
|||
|
Return a gcc type node. */
|
|||
|
|
|||
|
tree
|
|||
|
parse_signature_string (const unsigned char *sig_string, int sig_length)
|
|||
|
{
|
|||
|
tree result_type;
|
|||
|
const unsigned char *str = sig_string;
|
|||
|
const unsigned char *limit = str + sig_length;
|
|||
|
|
|||
|
if (str < limit && str[0] == '(')
|
|||
|
{
|
|||
|
tree argtype_list = NULL_TREE;
|
|||
|
str++;
|
|||
|
while (str < limit && str[0] != ')')
|
|||
|
{
|
|||
|
tree argtype = parse_signature_type (&str, limit);
|
|||
|
argtype_list = tree_cons (NULL_TREE, argtype, argtype_list);
|
|||
|
}
|
|||
|
if (str++, str >= limit)
|
|||
|
abort ();
|
|||
|
result_type = parse_signature_type (&str, limit);
|
|||
|
argtype_list = chainon (nreverse (argtype_list), end_params_node);
|
|||
|
result_type = build_function_type (result_type, argtype_list);
|
|||
|
}
|
|||
|
else
|
|||
|
result_type = parse_signature_type (&str, limit);
|
|||
|
if (str != limit)
|
|||
|
error ("junk at end of signature string");
|
|||
|
return result_type;
|
|||
|
}
|
|||
|
|
|||
|
/* Convert a signature to its type.
|
|||
|
* Uses IDENTIFIER_SIGNATURE_TYPE as a cache (except for primitive types).
|
|||
|
*/
|
|||
|
|
|||
|
tree
|
|||
|
get_type_from_signature (tree signature)
|
|||
|
{
|
|||
|
const unsigned char *sig = (const unsigned char *) IDENTIFIER_POINTER (signature);
|
|||
|
int len = IDENTIFIER_LENGTH (signature);
|
|||
|
tree type;
|
|||
|
/* Primitive types aren't cached. */
|
|||
|
if (len <= 1)
|
|||
|
return parse_signature_string (sig, len);
|
|||
|
type = IDENTIFIER_SIGNATURE_TYPE (signature);
|
|||
|
if (type == NULL_TREE)
|
|||
|
{
|
|||
|
type = parse_signature_string (sig, len);
|
|||
|
IDENTIFIER_SIGNATURE_TYPE (signature) = type;
|
|||
|
}
|
|||
|
return type;
|
|||
|
}
|
|||
|
|
|||
|
/* Ignore signature and always return null. Used by has_method. */
|
|||
|
|
|||
|
static tree
|
|||
|
build_null_signature (tree type ATTRIBUTE_UNUSED)
|
|||
|
{
|
|||
|
return NULL_TREE;
|
|||
|
}
|
|||
|
|
|||
|
/* Return the signature string for the arguments of method type TYPE. */
|
|||
|
|
|||
|
tree
|
|||
|
build_java_argument_signature (tree type)
|
|||
|
{
|
|||
|
extern struct obstack temporary_obstack;
|
|||
|
tree sig = TYPE_ARGUMENT_SIGNATURE (type);
|
|||
|
if (sig == NULL_TREE)
|
|||
|
{
|
|||
|
tree args = TYPE_ARG_TYPES (type);
|
|||
|
if (TREE_CODE (type) == METHOD_TYPE)
|
|||
|
args = TREE_CHAIN (args); /* Skip "this" argument. */
|
|||
|
for (; args != end_params_node; args = TREE_CHAIN (args))
|
|||
|
{
|
|||
|
tree t = build_java_signature (TREE_VALUE (args));
|
|||
|
obstack_grow (&temporary_obstack,
|
|||
|
IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
|
|||
|
}
|
|||
|
obstack_1grow (&temporary_obstack, '\0');
|
|||
|
|
|||
|
sig = get_identifier (obstack_base (&temporary_obstack));
|
|||
|
TYPE_ARGUMENT_SIGNATURE (type) = sig;
|
|||
|
obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
|
|||
|
}
|
|||
|
return sig;
|
|||
|
}
|
|||
|
|
|||
|
/* Return the signature of the given TYPE. */
|
|||
|
|
|||
|
tree
|
|||
|
build_java_signature (tree type)
|
|||
|
{
|
|||
|
tree sig, t;
|
|||
|
while (TREE_CODE (type) == POINTER_TYPE)
|
|||
|
type = TREE_TYPE (type);
|
|||
|
MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
|
|||
|
sig = TYPE_SIGNATURE (type);
|
|||
|
if (sig == NULL_TREE)
|
|||
|
{
|
|||
|
char sg[2];
|
|||
|
switch (TREE_CODE (type))
|
|||
|
{
|
|||
|
case BOOLEAN_TYPE: sg[0] = 'Z'; 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;
|
|||
|
case 16: sg[0] = 'S'; goto native;
|
|||
|
case 32: sg[0] = 'I'; goto native;
|
|||
|
case 64: sg[0] = 'J'; goto native;
|
|||
|
default: goto bad_type;
|
|||
|
}
|
|||
|
case REAL_TYPE:
|
|||
|
switch (TYPE_PRECISION (type))
|
|||
|
{
|
|||
|
case 32: sg[0] = 'F'; goto native;
|
|||
|
case 64: sg[0] = 'D'; goto native;
|
|||
|
default: goto bad_type;
|
|||
|
}
|
|||
|
native:
|
|||
|
sg[1] = 0;
|
|||
|
sig = get_identifier (sg);
|
|||
|
break;
|
|||
|
case RECORD_TYPE:
|
|||
|
if (TYPE_ARRAY_P (type))
|
|||
|
{
|
|||
|
t = build_java_signature (TYPE_ARRAY_ELEMENT (type));
|
|||
|
sig = ident_subst (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t),
|
|||
|
"[", 0, 0, "");
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
t = DECL_NAME (TYPE_NAME (type));
|
|||
|
sig = ident_subst (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t),
|
|||
|
"L", '.', '/', ";");
|
|||
|
}
|
|||
|
break;
|
|||
|
case METHOD_TYPE:
|
|||
|
case FUNCTION_TYPE:
|
|||
|
{
|
|||
|
extern struct obstack temporary_obstack;
|
|||
|
sig = build_java_argument_signature (type);
|
|||
|
obstack_1grow (&temporary_obstack, '(');
|
|||
|
obstack_grow (&temporary_obstack,
|
|||
|
IDENTIFIER_POINTER (sig), IDENTIFIER_LENGTH (sig));
|
|||
|
obstack_1grow (&temporary_obstack, ')');
|
|||
|
|
|||
|
t = build_java_signature (TREE_TYPE (type));
|
|||
|
obstack_grow0 (&temporary_obstack,
|
|||
|
IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
|
|||
|
|
|||
|
sig = get_identifier (obstack_base (&temporary_obstack));
|
|||
|
obstack_free (&temporary_obstack,
|
|||
|
obstack_base (&temporary_obstack));
|
|||
|
}
|
|||
|
break;
|
|||
|
bad_type:
|
|||
|
default:
|
|||
|
gcc_unreachable ();
|
|||
|
}
|
|||
|
TYPE_SIGNATURE (type) = sig;
|
|||
|
}
|
|||
|
return sig;
|
|||
|
}
|
|||
|
|
|||
|
/* Save signature string SIG (an IDENTIFIER_NODE) in TYPE for future use. */
|
|||
|
|
|||
|
void
|
|||
|
set_java_signature (tree type, tree sig)
|
|||
|
{
|
|||
|
tree old_sig;
|
|||
|
while (TREE_CODE (type) == POINTER_TYPE)
|
|||
|
type = TREE_TYPE (type);
|
|||
|
MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
|
|||
|
old_sig = TYPE_SIGNATURE (type);
|
|||
|
if (old_sig != NULL_TREE && old_sig != sig)
|
|||
|
abort ();
|
|||
|
TYPE_SIGNATURE (type) = sig;
|
|||
|
#if 0 /* careful about METHOD_TYPE */
|
|||
|
if (IDENTIFIER_SIGNATURE_TYPE (sig) == NULL_TREE && TREE_PERMANENT (type))
|
|||
|
IDENTIFIER_SIGNATURE_TYPE (sig) = type;
|
|||
|
#endif
|
|||
|
}
|
|||
|
|
|||
|
/* Search in SEARCHED_CLASS and its superclasses for a method matching
|
|||
|
METHOD_NAME and signature METHOD_SIGNATURE. This function will
|
|||
|
only search for methods declared in the class hierarchy; interfaces
|
|||
|
will not be considered. Returns NULL_TREE if the method is not
|
|||
|
found. */
|
|||
|
tree
|
|||
|
lookup_argument_method (tree searched_class, tree method_name,
|
|||
|
tree method_signature)
|
|||
|
{
|
|||
|
return lookup_do (searched_class, 0,
|
|||
|
method_name, method_signature,
|
|||
|
build_java_argument_signature);
|
|||
|
}
|
|||
|
|
|||
|
/* Like lookup_argument_method, but lets the caller set any flags
|
|||
|
desired. */
|
|||
|
tree
|
|||
|
lookup_argument_method_generic (tree searched_class, tree method_name,
|
|||
|
tree method_signature, int flags)
|
|||
|
{
|
|||
|
return lookup_do (searched_class, flags,
|
|||
|
method_name, method_signature,
|
|||
|
build_java_argument_signature);
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* Search in class SEARCHED_CLASS (and its superclasses) for a method
|
|||
|
matching METHOD_NAME and signature METHOD_SIGNATURE. Return a
|
|||
|
FUNCTION_DECL on success, or NULL_TREE if none found. (Contrast
|
|||
|
lookup_argument_method, which ignores return type.) If
|
|||
|
SEARCHED_CLASS is an interface, search it too. */
|
|||
|
tree
|
|||
|
lookup_java_method (tree searched_class, tree method_name,
|
|||
|
tree method_signature)
|
|||
|
{
|
|||
|
return lookup_do (searched_class, SEARCH_INTERFACE, method_name,
|
|||
|
method_signature, build_java_signature);
|
|||
|
}
|
|||
|
|
|||
|
/* Return true iff KLASS (or its ancestors) has a method METHOD_NAME. <20>*/
|
|||
|
int
|
|||
|
has_method (tree klass, tree method_name)
|
|||
|
{
|
|||
|
return lookup_do (klass, SEARCH_INTERFACE,
|
|||
|
method_name, NULL_TREE,
|
|||
|
build_null_signature) != NULL_TREE;
|
|||
|
}
|
|||
|
|
|||
|
/* Search in class SEARCHED_CLASS, but not its superclasses, for a
|
|||
|
method matching METHOD_NAME and signature SIGNATURE. A private
|
|||
|
helper for lookup_do. */
|
|||
|
static tree
|
|||
|
shallow_find_method (tree searched_class, int flags, tree method_name,
|
|||
|
tree signature, tree (*signature_builder) (tree))
|
|||
|
{
|
|||
|
tree method;
|
|||
|
for (method = TYPE_METHODS (searched_class);
|
|||
|
method != NULL_TREE; method = TREE_CHAIN (method))
|
|||
|
{
|
|||
|
tree method_sig = (*signature_builder) (TREE_TYPE (method));
|
|||
|
if (DECL_NAME (method) == method_name && method_sig == signature)
|
|||
|
{
|
|||
|
/* If the caller requires a visible method, then we
|
|||
|
skip invisible methods here. */
|
|||
|
if (! (flags & SEARCH_VISIBLE)
|
|||
|
|| ! METHOD_INVISIBLE (method))
|
|||
|
return method;
|
|||
|
}
|
|||
|
}
|
|||
|
return NULL_TREE;
|
|||
|
}
|
|||
|
|
|||
|
/* Search in the superclasses of SEARCHED_CLASS for a method matching
|
|||
|
METHOD_NAME and signature SIGNATURE. A private helper for
|
|||
|
lookup_do. */
|
|||
|
static tree
|
|||
|
find_method_in_superclasses (tree searched_class, int flags,
|
|||
|
tree method_name, tree signature,
|
|||
|
tree (*signature_builder) (tree))
|
|||
|
{
|
|||
|
tree klass;
|
|||
|
for (klass = CLASSTYPE_SUPER (searched_class); klass != NULL_TREE;
|
|||
|
klass = CLASSTYPE_SUPER (klass))
|
|||
|
{
|
|||
|
tree method;
|
|||
|
method = shallow_find_method (klass, flags, method_name,
|
|||
|
signature, signature_builder);
|
|||
|
if (method != NULL_TREE)
|
|||
|
return method;
|
|||
|
}
|
|||
|
|
|||
|
return NULL_TREE;
|
|||
|
}
|
|||
|
|
|||
|
/* Search in the interfaces of SEARCHED_CLASS and its superinterfaces
|
|||
|
for a method matching METHOD_NAME and signature SIGNATURE. A
|
|||
|
private helper for lookup_do. */
|
|||
|
static tree
|
|||
|
find_method_in_interfaces (tree searched_class, int flags, tree method_name,
|
|||
|
tree signature, tree (*signature_builder) (tree))
|
|||
|
{
|
|||
|
int i;
|
|||
|
tree binfo, base_binfo;
|
|||
|
|
|||
|
for (binfo = TYPE_BINFO (searched_class), i = 1;
|
|||
|
BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
|
|||
|
{
|
|||
|
tree iclass = BINFO_TYPE (base_binfo);
|
|||
|
tree method;
|
|||
|
|
|||
|
/* If the superinterface hasn't been loaded yet, do so now. */
|
|||
|
if (!CLASS_LOADED_P (iclass))
|
|||
|
load_class (iclass, 1);
|
|||
|
|
|||
|
/* 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);
|
|||
|
if (method != NULL_TREE)
|
|||
|
return method;
|
|||
|
|
|||
|
method = find_method_in_interfaces
|
|||
|
(iclass, flags, method_name, signature, signature_builder);
|
|||
|
if (method != NULL_TREE)
|
|||
|
return method;
|
|||
|
}
|
|||
|
|
|||
|
return NULL_TREE;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/* Search in class SEARCHED_CLASS (and its superclasses) for a method
|
|||
|
matching METHOD_NAME and signature SIGNATURE. FLAGS control some
|
|||
|
parameters of the search.
|
|||
|
|
|||
|
SEARCH_INTERFACE means also search interfaces and superinterfaces
|
|||
|
of SEARCHED_CLASS.
|
|||
|
|
|||
|
SEARCH_SUPER means skip SEARCHED_CLASS and start with its
|
|||
|
superclass.
|
|||
|
|
|||
|
SEARCH_VISIBLE means skip methods for which METHOD_INVISIBLE is
|
|||
|
set.
|
|||
|
|
|||
|
Return the matched method DECL or NULL_TREE. SIGNATURE_BUILDER is
|
|||
|
used on method candidates to build their (sometimes partial)
|
|||
|
signature. */
|
|||
|
static tree
|
|||
|
lookup_do (tree searched_class, int flags, tree method_name,
|
|||
|
tree signature, tree (*signature_builder) (tree))
|
|||
|
{
|
|||
|
tree method;
|
|||
|
tree orig_class = searched_class;
|
|||
|
|
|||
|
if (searched_class == NULL_TREE)
|
|||
|
return NULL_TREE;
|
|||
|
|
|||
|
if (flags & SEARCH_SUPER)
|
|||
|
{
|
|||
|
searched_class = CLASSTYPE_SUPER (searched_class);
|
|||
|
if (searched_class == NULL_TREE)
|
|||
|
return NULL_TREE;
|
|||
|
}
|
|||
|
|
|||
|
/* First look in our own methods. */
|
|||
|
method = shallow_find_method (searched_class, flags, method_name,
|
|||
|
signature, signature_builder);
|
|||
|
if (method)
|
|||
|
return method;
|
|||
|
|
|||
|
/* Then look in our superclasses. */
|
|||
|
if (! CLASS_INTERFACE (TYPE_NAME (searched_class)))
|
|||
|
method = find_method_in_superclasses (searched_class, flags, method_name,
|
|||
|
signature, signature_builder);
|
|||
|
if (method)
|
|||
|
return method;
|
|||
|
|
|||
|
/* If that doesn't work, look in our interfaces. */
|
|||
|
if (flags & SEARCH_INTERFACE)
|
|||
|
method = find_method_in_interfaces (orig_class, flags, method_name,
|
|||
|
signature, signature_builder);
|
|||
|
|
|||
|
return method;
|
|||
|
}
|
|||
|
|
|||
|
/* Search in class CLAS for a constructor matching METHOD_SIGNATURE.
|
|||
|
Return a FUNCTION_DECL on success, or NULL_TREE if none found. */
|
|||
|
|
|||
|
tree
|
|||
|
lookup_java_constructor (tree clas, tree method_signature)
|
|||
|
{
|
|||
|
tree method = TYPE_METHODS (clas);
|
|||
|
for ( ; method != NULL_TREE; method = TREE_CHAIN (method))
|
|||
|
{
|
|||
|
tree method_sig = build_java_signature (TREE_TYPE (method));
|
|||
|
if (DECL_CONSTRUCTOR_P (method) && method_sig == method_signature)
|
|||
|
return method;
|
|||
|
}
|
|||
|
return NULL_TREE;
|
|||
|
}
|
|||
|
|
|||
|
/* Return a type which is the Binary Numeric Promotion of the pair T1,
|
|||
|
T2 and convert EXP1 and/or EXP2. See 5.6.2 Binary Numeric
|
|||
|
Promotion. It assumes that both T1 and T2 are eligible to BNP. */
|
|||
|
|
|||
|
tree
|
|||
|
binary_numeric_promotion (tree t1, tree t2, tree *exp1, tree *exp2)
|
|||
|
{
|
|||
|
if (t1 == double_type_node || t2 == double_type_node)
|
|||
|
{
|
|||
|
if (t1 != double_type_node)
|
|||
|
*exp1 = convert (double_type_node, *exp1);
|
|||
|
if (t2 != double_type_node)
|
|||
|
*exp2 = convert (double_type_node, *exp2);
|
|||
|
return double_type_node;
|
|||
|
}
|
|||
|
if (t1 == float_type_node || t2 == float_type_node)
|
|||
|
{
|
|||
|
if (t1 != float_type_node)
|
|||
|
*exp1 = convert (float_type_node, *exp1);
|
|||
|
if (t2 != float_type_node)
|
|||
|
*exp2 = convert (float_type_node, *exp2);
|
|||
|
return float_type_node;
|
|||
|
}
|
|||
|
if (t1 == long_type_node || t2 == long_type_node)
|
|||
|
{
|
|||
|
if (t1 != long_type_node)
|
|||
|
*exp1 = convert (long_type_node, *exp1);
|
|||
|
if (t2 != long_type_node)
|
|||
|
*exp2 = convert (long_type_node, *exp2);
|
|||
|
return long_type_node;
|
|||
|
}
|
|||
|
|
|||
|
if (t1 != int_type_node)
|
|||
|
*exp1 = convert (int_type_node, *exp1);
|
|||
|
if (t2 != int_type_node)
|
|||
|
*exp2 = convert (int_type_node, *exp2);
|
|||
|
return int_type_node;
|
|||
|
}
|