Subversion Repositories openrisc

/* Handle types for the GNU compiler for the Java(TM) language.

   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007,

   2008, 2009, 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

<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 "tree.h"

#include "obstack.h"

#include "flags.h"

#include "java-tree.h"

#include "jcf.h"

#include "convert.h"

#include "diagnostic-core.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 = DECL_CHAIN (DECL_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;

  DECL_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.  */

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 = DECL_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;