Delete old versions of GCC.

Change-Id: I710f125d905290e1024cbd67f48299861790c66c

1 files changed, 0 insertions, 828 deletions

diff --git a/gcc-4.6/gcc/java/typeck.c b/gcc-4.6/gcc/java/typeck.c
deleted file mode 100644
index 67552176b..000000000
--- a/gcc-4.6/gcc/java/typeck.c
+++ /dev/null
@@ -1,828 +0,0 @@
-/* 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;
-  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 = DECL_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;
-}