gcc/java/typeck.c

   1 /* Handle types for the GNU compiler for the Java(TM) language.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.
  20
  21 Java and all Java-based marks are trademarks or registered trademarks
  22 of Sun Microsystems, Inc. in the United States and other countries.
  23 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  24
  25 /* Written by Per Bothner <bothner@cygnus.com> */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "coretypes.h"
  30 #include "tree.h"
  31 #include "obstack.h"
  32 #include "flags.h"
  33 #include "java-tree.h"
  34 #include "jcf.h"
  35 #include "convert.h"
  36 #include "toplev.h"
  37 #include "ggc.h"
  38
  39 static tree convert_ieee_real_to_integer (tree, tree);
  40 static tree parse_signature_type (const unsigned char **,
  41                                   const unsigned char *);
  42 static tree lookup_do (tree, int, tree, tree, tree (*)(tree));
  43 static tree build_null_signature (tree);
  44
  45 tree * type_map;
  46
  47 /* Set the type of the local variable with index SLOT to TYPE. */
  48
  49 void
  50 set_local_type (int slot, tree type)
  51 {
  52   int max_locals = DECL_MAX_LOCALS(current_function_decl);
  53   int nslots = TYPE_IS_WIDE (type) ? 2 : 1;
  54
  55   gcc_assert (slot >= 0 && (slot + nslots - 1 < max_locals));
  56
  57   type_map[slot] = type;
  58   while (--nslots > 0)
  59     type_map[++slot] = void_type_node;
  60 }
  61
  62 /* Convert an IEEE real to an integer type.  The result of such a
  63    conversion when the source operand is a NaN isn't defined by
  64    IEEE754, but by the Java language standard: it must be zero.  Also,
  65    overflows must be clipped to within range.  This conversion
  66    produces something like:
  67
  68       ((expr >= (float)MAX_INT)
  69        ? MAX_INT
  70        : ((expr <= (float)MIN_INT)
  71           ? MIN_INT
  72           : ((expr != expr)
  73              ? 0
  74              : (int)expr))) */
  75
  76 static tree
  77 convert_ieee_real_to_integer (tree type, tree expr)
  78 {
  79   tree result;
  80   expr = save_expr (expr);
  81
  82   result = fold_build3 (COND_EXPR, type,
  83                         fold_build2 (NE_EXPR, boolean_type_node, expr, expr),
  84                          convert (type, integer_zero_node),
  85                          convert_to_integer (type, expr));
  86
  87   result = fold_build3 (COND_EXPR, type,
  88                         fold_build2 (LE_EXPR, boolean_type_node, expr,
  89                                      convert (TREE_TYPE (expr),
  90                                               TYPE_MIN_VALUE (type))),
  91                         TYPE_MIN_VALUE (type),
  92                         result);
  93
  94   result = fold_build3 (COND_EXPR, type,
  95                         fold_build2 (GE_EXPR, boolean_type_node, expr,
  96                                      convert (TREE_TYPE (expr),
  97                                               TYPE_MAX_VALUE (type))),
  98                         TYPE_MAX_VALUE (type),
  99                         result);
 100
 101   return result;
 102 }
 103
 104 /* Create an expression whose value is that of EXPR,
 105    converted to type TYPE.  The TREE_TYPE of the value
 106    is always TYPE.  This function implements all reasonable
 107    conversions; callers should filter out those that are
 108    not permitted by the language being compiled.  */
 109
 110 tree
 111 convert (tree type, tree expr)
 112 {
 113   enum tree_code code = TREE_CODE (type);
 114
 115   if (!expr)
 116    return error_mark_node;
 117
 118   if (type == TREE_TYPE (expr)
 119       || TREE_CODE (expr) == ERROR_MARK)
 120     return expr;
 121   if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
 122     return error_mark_node;
 123   if (code == VOID_TYPE)
 124     return build1 (CONVERT_EXPR, type, expr);
 125   if (code == BOOLEAN_TYPE)
 126     return fold_convert (type, expr);
 127   if (code == INTEGER_TYPE)
 128     {
 129       if (type == char_type_node || type == promoted_char_type_node)
 130         return fold_convert (type, expr);
 131       if ((really_constant_p (expr) || ! flag_unsafe_math_optimizations)
 132           && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
 133         return convert_ieee_real_to_integer (type, expr);
 134       else
 135         {
 136           /* fold very helpfully sets the overflow status if a type
 137              overflows in a narrowing integer conversion, but Java
 138              doesn't care.  */
 139           tree tmp = fold (convert_to_integer (type, expr));
 140           if (TREE_CODE (tmp) == INTEGER_CST)
 141             TREE_OVERFLOW (tmp) = 0;
 142           return tmp;
 143         }
 144     }
 145   if (code == REAL_TYPE)
 146     return fold (convert_to_real (type, expr));
 147   if (code == POINTER_TYPE)
 148     return fold (convert_to_pointer (type, expr));
 149   error ("conversion to non-scalar type requested");
 150   return error_mark_node;
 151 }
 152
 153
 154 /* Return a data type that has machine mode MODE.
 155    If the mode is an integer,
 156    then UNSIGNEDP selects between signed and unsigned types.  */
 157
 158 tree
 159 java_type_for_mode (enum machine_mode mode, int unsignedp)
 160 {
 161   if (mode == TYPE_MODE (int_type_node))
 162     return unsignedp ? unsigned_int_type_node : int_type_node;
 163   if (mode == TYPE_MODE (long_type_node))
 164     return unsignedp ? unsigned_long_type_node : long_type_node;
 165   if (mode == TYPE_MODE (short_type_node))
 166     return unsignedp ? unsigned_short_type_node : short_type_node;
 167   if (mode == TYPE_MODE (byte_type_node))
 168     return unsignedp ? unsigned_byte_type_node : byte_type_node;
 169   if (mode == TYPE_MODE (float_type_node))
 170     return float_type_node;
 171   if (mode == TYPE_MODE (double_type_node))
 172     return double_type_node;
 173
 174   return 0;
 175 }
 176
 177 /* Return an integer type with BITS bits of precision,
 178    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
 179
 180 tree
 181 java_type_for_size (unsigned bits, int unsignedp)
 182 {
 183   if (bits <= TYPE_PRECISION (byte_type_node))
 184     return unsignedp ? unsigned_byte_type_node : byte_type_node;
 185   if (bits <= TYPE_PRECISION (short_type_node))
 186     return unsignedp ? unsigned_short_type_node : short_type_node;
 187   if (bits <= TYPE_PRECISION (int_type_node))
 188     return unsignedp ? unsigned_int_type_node : int_type_node;
 189   if (bits <= TYPE_PRECISION (long_type_node))
 190     return unsignedp ? unsigned_long_type_node : long_type_node;
 191   return 0;
 192 }
 193
 194 /* Thorough checking of the arrayness of TYPE.  */
 195
 196 int
 197 is_array_type_p (tree type)
 198 {
 199   return TREE_CODE (type) == POINTER_TYPE
 200     && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
 201     && TYPE_ARRAY_P (TREE_TYPE (type));
 202 }
 203
 204 /* Return the length of a Java array type.
 205    Return -1 if the length is unknown or non-constant. */
 206
 207 HOST_WIDE_INT
 208 java_array_type_length (tree array_type)
 209 {
 210   tree arfld;
 211   if (TREE_CODE (array_type) == POINTER_TYPE)
 212     array_type = TREE_TYPE (array_type);
 213   arfld = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type)));
 214   if (arfld != NULL_TREE)
 215     {
 216       tree index_type = TYPE_DOMAIN (TREE_TYPE (arfld));
 217       if (index_type != NULL_TREE)
 218         {
 219           tree high = TYPE_MAX_VALUE (index_type);
 220           if (TREE_CODE (high) == INTEGER_CST)
 221             return TREE_INT_CST_LOW (high) + 1;
 222         }
 223     }
 224   return -1;
 225 }
 226
 227 /* An array of unknown length will be ultimately given a length of
 228    -2, so that we can still have `length' producing a negative value
 229    even if found. This was part of an optimization aiming at removing
 230    `length' from static arrays. We could restore it, FIXME.  */
 231
 232 tree
 233 build_prim_array_type (tree element_type, HOST_WIDE_INT length)
 234 {
 235   tree index = NULL;
 236
 237   if (length != -1)
 238     {
 239       tree max_index = build_int_cst (sizetype, length - 1);
 240       index = build_index_type (max_index);
 241     }
 242   return build_array_type (element_type, index);
 243 }
 244
 245 /* Return a Java array type with a given ELEMENT_TYPE and LENGTH.
 246    These are hashed (shared) using IDENTIFIER_SIGNATURE_TYPE.
 247    The LENGTH is -1 if the length is unknown. */
 248
 249 tree
 250 build_java_array_type (tree element_type, HOST_WIDE_INT length)
 251 {
 252   tree sig, t, fld, atype, arfld;
 253   char buf[23];
 254   tree elsig = build_java_signature (element_type);
 255   tree el_name = element_type;
 256   buf[0] = '[';
 257   if (length >= 0)
 258     sprintf (buf+1, HOST_WIDE_INT_PRINT_DEC, length);
 259   else
 260     buf[1] = '\0';
 261   sig = ident_subst (IDENTIFIER_POINTER (elsig), IDENTIFIER_LENGTH (elsig),
 262                      buf, 0, 0, "");
 263   t = IDENTIFIER_SIGNATURE_TYPE (sig);
 264   if (t != NULL_TREE)
 265     return TREE_TYPE (t);
 266   t = make_class ();
 267   IDENTIFIER_SIGNATURE_TYPE (sig) = build_pointer_type (t);
 268   TYPE_ARRAY_P (t) = 1;
 269
 270   if (TREE_CODE (el_name) == POINTER_TYPE)
 271     el_name = TREE_TYPE (el_name);
 272   el_name = TYPE_NAME (el_name);
 273   if (TREE_CODE (el_name) == TYPE_DECL)
 274     el_name = DECL_NAME (el_name);
 275   {
 276     char suffix[23];
 277     if (length >= 0)
 278       sprintf (suffix, "[%d]", (int)length);
 279     else
 280       strcpy (suffix, "[]");
 281     TYPE_NAME (t)
 282       = TYPE_STUB_DECL (t)
 283       = build_decl (input_location, TYPE_DECL,
 284                     identifier_subst (el_name, "", '.', '.', suffix),
 285                              t);
 286     TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (t)) = true;
 287   }
 288
 289   set_java_signature (t, sig);
 290   set_super_info (0, t, object_type_node, 0);
 291   if (TREE_CODE (element_type) == RECORD_TYPE)
 292     element_type = promote_type (element_type);
 293   TYPE_ARRAY_ELEMENT (t) = element_type;
 294
 295   /* Add length pseudo-field. */
 296   fld = build_decl (input_location,
 297                     FIELD_DECL, get_identifier ("length"), int_type_node);
 298   TYPE_FIELDS (t) = fld;
 299   DECL_CONTEXT (fld) = t;
 300   FIELD_PUBLIC (fld) = 1;
 301   FIELD_FINAL (fld) = 1;
 302   TREE_READONLY (fld) = 1;
 303
 304   atype = build_prim_array_type (element_type, length);
 305   arfld = build_decl (input_location,
 306                       FIELD_DECL, get_identifier ("data"), atype);
 307   DECL_CONTEXT (arfld) = t;
 308   TREE_CHAIN (fld) = arfld;
 309   DECL_ALIGN (arfld) = TYPE_ALIGN (element_type);
 310
 311   /* We could layout_class, but that loads java.lang.Object prematurely.
 312    * This is called by the parser, and it is a bad idea to do load_class
 313    * in the middle of parsing, because of possible circularity problems. */
 314   push_super_field (t, object_type_node);
 315   layout_type (t);
 316
 317   return t;
 318 }
 319
 320 /* Promote TYPE to the type actually used for fields and parameters. */
 321
 322 tree
 323 promote_type (tree type)
 324 {
 325   switch (TREE_CODE (type))
 326     {
 327     case RECORD_TYPE:
 328       return build_pointer_type (type);
 329     case BOOLEAN_TYPE:
 330       if (type == boolean_type_node)
 331         return promoted_boolean_type_node;
 332       goto handle_int;
 333     case INTEGER_TYPE:
 334       if (type == char_type_node)
 335         return promoted_char_type_node;
 336     handle_int:
 337       if (TYPE_PRECISION (type) < TYPE_PRECISION (int_type_node))
 338         {
 339           if (type == short_type_node)
 340             return promoted_short_type_node;
 341           if (type == byte_type_node)
 342             return promoted_byte_type_node;
 343           return int_type_node;
 344         }
 345       /* ... else fall through ... */
 346     default:
 347       return type;
 348     }
 349 }
 350
 351 /* Parse a signature string, starting at *PTR and ending at LIMIT.
 352    Return the seen TREE_TYPE, updating *PTR. */
 353
 354 static tree
 355 parse_signature_type (const unsigned char **ptr, const unsigned char *limit)
 356 {
 357   tree type;
 358   gcc_assert (*ptr < limit);
 359
 360   switch (**ptr)
 361     {
 362     case 'B':  (*ptr)++;  return byte_type_node;
 363     case 'C':  (*ptr)++;  return char_type_node;
 364     case 'D':  (*ptr)++;  return double_type_node;
 365     case 'F':  (*ptr)++;  return float_type_node;
 366     case 'S':  (*ptr)++;  return short_type_node;
 367     case 'I':  (*ptr)++;  return int_type_node;
 368     case 'J':  (*ptr)++;  return long_type_node;
 369     case 'Z':  (*ptr)++;  return boolean_type_node;
 370     case 'V':  (*ptr)++;  return void_type_node;
 371     case '[':
 372       for ((*ptr)++; (*ptr) < limit && ISDIGIT (**ptr); ) (*ptr)++;
 373       type = parse_signature_type (ptr, limit);
 374       type = build_java_array_type (type, -1);
 375       break;
 376     case 'L':
 377       {
 378         const unsigned char *start = ++(*ptr);
 379         const unsigned char *str = start;
 380         for ( ; ; str++)
 381           {
 382             gcc_assert (str < limit);
 383             if (*str == ';')
 384               break;
 385           }
 386         *ptr = str+1;
 387         type = lookup_class (unmangle_classname ((const char *) start, str - start));
 388         break;
 389       }
 390     default:
 391       gcc_unreachable ();
 392     }
 393   return promote_type (type);
 394 }
 395
 396 /* Parse a Java "mangled" signature string, starting at SIG_STRING,
 397    and SIG_LENGTH bytes long.
 398    Return a gcc type node. */
 399
 400 tree
 401 parse_signature_string (const unsigned char *sig_string, int sig_length)
 402 {
 403   tree result_type;
 404   const unsigned char *str = sig_string;
 405   const unsigned char *limit = str + sig_length;
 406
 407   if (str < limit && str[0] == '(')
 408     {
 409       tree argtype_list = NULL_TREE;
 410       str++;
 411       while (str < limit && str[0] != ')')
 412         {
 413           tree argtype = parse_signature_type (&str, limit);
 414           argtype_list = tree_cons (NULL_TREE, argtype, argtype_list);
 415         }
 416       if (str++, str >= limit)
 417         abort ();
 418       result_type = parse_signature_type (&str, limit);
 419       argtype_list = chainon (nreverse (argtype_list), end_params_node);
 420       result_type = build_function_type (result_type, argtype_list);
 421     }
 422   else
 423     result_type = parse_signature_type (&str, limit);
 424   if (str != limit)
 425     error ("junk at end of signature string");
 426   return result_type;
 427 }
 428
 429 /* Convert a signature to its type.
 430  * Uses IDENTIFIER_SIGNATURE_TYPE as a cache (except for primitive types).
 431  */
 432
 433 tree
 434 get_type_from_signature (tree signature)
 435 {
 436   const unsigned char *sig = (const unsigned char *) IDENTIFIER_POINTER (signature);
 437   int len = IDENTIFIER_LENGTH (signature);
 438   tree type;
 439   /* Primitive types aren't cached. */
 440   if (len <= 1)
 441     return parse_signature_string (sig, len);
 442   type = IDENTIFIER_SIGNATURE_TYPE (signature);
 443   if (type == NULL_TREE)
 444     {
 445       type = parse_signature_string (sig, len);
 446       IDENTIFIER_SIGNATURE_TYPE (signature) = type;
 447     }
 448   return type;
 449 }
 450
 451 /* Ignore signature and always return null.  Used by has_method. */
 452
 453 static tree
 454 build_null_signature (tree type ATTRIBUTE_UNUSED)
 455 {
 456   return NULL_TREE;
 457 }
 458
 459 /* Return the signature string for the arguments of method type TYPE. */
 460
 461 tree
 462 build_java_argument_signature (tree type)
 463 {
 464   extern struct obstack temporary_obstack;
 465   tree sig = TYPE_ARGUMENT_SIGNATURE (type);
 466   if (sig == NULL_TREE)
 467     {
 468       tree args = TYPE_ARG_TYPES (type);
 469       if (TREE_CODE (type) == METHOD_TYPE)
 470         args = TREE_CHAIN (args);  /* Skip "this" argument. */
 471       for (; args != end_params_node; args = TREE_CHAIN (args))
 472         {
 473           tree t = build_java_signature (TREE_VALUE (args));
 474           obstack_grow (&temporary_obstack,
 475                         IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
 476         }
 477       obstack_1grow (&temporary_obstack, '\0');
 478
 479       sig = get_identifier (obstack_base (&temporary_obstack));
 480       TYPE_ARGUMENT_SIGNATURE (type) = sig;
 481       obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
 482     }
 483   return sig;
 484 }
 485
 486 /* Return the signature of the given TYPE. */
 487
 488 tree
 489 build_java_signature (tree type)
 490 {
 491   tree sig, t;
 492   while (TREE_CODE (type) == POINTER_TYPE)
 493     type = TREE_TYPE (type);
 494   MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
 495   sig = TYPE_SIGNATURE (type);
 496   if (sig == NULL_TREE)
 497     {
 498       char sg[2];
 499       switch (TREE_CODE (type))
 500         {
 501         case BOOLEAN_TYPE: sg[0] = 'Z';  goto native;
 502         case VOID_TYPE:    sg[0] = 'V';  goto native;
 503         case INTEGER_TYPE:
 504           if (type == char_type_node || type == promoted_char_type_node)
 505             {
 506               sg[0] = 'C';
 507               goto native;
 508             }
 509           switch (TYPE_PRECISION (type))
 510             {
 511             case  8:       sg[0] = 'B';  goto native;
 512             case 16:       sg[0] = 'S';  goto native;
 513             case 32:       sg[0] = 'I';  goto native;
 514             case 64:       sg[0] = 'J';  goto native;
 515             default:  goto bad_type;
 516             }
 517         case REAL_TYPE:
 518           switch (TYPE_PRECISION (type))
 519             {
 520             case 32:       sg[0] = 'F';  goto native;
 521             case 64:       sg[0] = 'D';  goto native;
 522             default:  goto bad_type;
 523             }
 524         native:
 525           sg[1] = 0;
 526           sig = get_identifier (sg);
 527           break;
 528         case RECORD_TYPE:
 529           if (TYPE_ARRAY_P (type))
 530             {
 531               t = build_java_signature (TYPE_ARRAY_ELEMENT (type));
 532               sig = ident_subst (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t),
 533                                  "[", 0, 0, "");
 534             }
 535           else
 536             {
 537               t = DECL_NAME (TYPE_NAME (type));
 538               sig = ident_subst (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t),
 539                                  "L", '.', '/', ";");
 540             }
 541           break;
 542         case METHOD_TYPE:
 543         case FUNCTION_TYPE:
 544           {
 545             extern struct obstack temporary_obstack;
 546             sig = build_java_argument_signature (type);
 547             obstack_1grow (&temporary_obstack, '(');
 548             obstack_grow (&temporary_obstack,
 549                           IDENTIFIER_POINTER (sig), IDENTIFIER_LENGTH (sig));
 550             obstack_1grow (&temporary_obstack, ')');
 551
 552             t = build_java_signature (TREE_TYPE (type));
 553             obstack_grow0 (&temporary_obstack,
 554                            IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
 555
 556             sig = get_identifier (obstack_base (&temporary_obstack));
 557             obstack_free (&temporary_obstack,
 558                           obstack_base (&temporary_obstack));
 559           }
 560           break;
 561         bad_type:
 562         default:
 563           gcc_unreachable ();
 564         }
 565       TYPE_SIGNATURE (type) = sig;
 566     }
 567   return sig;
 568 }
 569
 570 /* Save signature string SIG (an IDENTIFIER_NODE) in TYPE for future use. */
 571
 572 void
 573 set_java_signature (tree type, tree sig)
 574 {
 575   tree old_sig;
 576   while (TREE_CODE (type) == POINTER_TYPE)
 577     type = TREE_TYPE (type);
 578   MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
 579   old_sig = TYPE_SIGNATURE (type);
 580   if (old_sig != NULL_TREE && old_sig != sig)
 581     abort ();
 582   TYPE_SIGNATURE (type) = sig;
 583 #if 0 /* careful about METHOD_TYPE */
 584   if (IDENTIFIER_SIGNATURE_TYPE (sig) == NULL_TREE && TREE_PERMANENT (type))
 585     IDENTIFIER_SIGNATURE_TYPE (sig) = type;
 586 #endif
 587 }
 588
 589 /* Search in SEARCHED_CLASS and its superclasses for a method matching
 590    METHOD_NAME and signature METHOD_SIGNATURE.  This function will
 591    only search for methods declared in the class hierarchy; interfaces
 592    will not be considered.  Returns NULL_TREE if the method is not
 593    found.  */
 594 tree
 595 lookup_argument_method (tree searched_class, tree method_name,
 596                         tree method_signature)
 597 {
 598   return lookup_do (searched_class, 0,
 599                     method_name, method_signature,
 600                     build_java_argument_signature);
 601 }
 602
 603 /* Like lookup_argument_method, but lets the caller set any flags
 604    desired.  */
 605 tree
 606 lookup_argument_method_generic (tree searched_class, tree method_name,
 607                                 tree method_signature, int flags)
 608 {
 609   return lookup_do (searched_class, flags,
 610                     method_name, method_signature,
 611                     build_java_argument_signature);
 612 }
 613
 614
 615 /* Search in class SEARCHED_CLASS (and its superclasses) for a method
 616    matching METHOD_NAME and signature METHOD_SIGNATURE.  Return a
 617    FUNCTION_DECL on success, or NULL_TREE if none found.  (Contrast
 618    lookup_argument_method, which ignores return type.)  If
 619    SEARCHED_CLASS is an interface, search it too. */
 620 tree
 621 lookup_java_method (tree searched_class, tree method_name,
 622                     tree method_signature)
 623 {
 624   return lookup_do (searched_class, SEARCH_INTERFACE, method_name,
 625                     method_signature, build_java_signature);
 626 }
 627
 628 /* Return true iff KLASS (or its ancestors) has a method METHOD_NAME.  */
 629 int
 630 has_method (tree klass, tree method_name)
 631 {
 632   return lookup_do (klass, SEARCH_INTERFACE,
 633                     method_name, NULL_TREE,
 634                     build_null_signature) != NULL_TREE;
 635 }
 636
 637 /* Search in class SEARCHED_CLASS, but not its superclasses, for a
 638    method matching METHOD_NAME and signature SIGNATURE.  A private
 639    helper for lookup_do.  */
 640 static tree
 641 shallow_find_method (tree searched_class, int flags, tree method_name,
 642              tree signature, tree (*signature_builder) (tree))
 643 {
 644   tree method;
 645   for (method = TYPE_METHODS (searched_class);
 646        method != NULL_TREE;  method = TREE_CHAIN (method))
 647     {
 648       tree method_sig = (*signature_builder) (TREE_TYPE (method));
 649       if (DECL_NAME (method) == method_name && method_sig == signature)
 650         {
 651           /* If the caller requires a visible method, then we
 652              skip invisible methods here.  */
 653           if (! (flags & SEARCH_VISIBLE)
 654               || ! METHOD_INVISIBLE (method))
 655             return method;
 656         }
 657     }
 658   return NULL_TREE;
 659 }
 660
 661 /* Search in the superclasses of SEARCHED_CLASS for a method matching
 662    METHOD_NAME and signature SIGNATURE.  A private helper for
 663    lookup_do.  */
 664 static tree
 665 find_method_in_superclasses (tree searched_class, int flags,
 666                              tree method_name, tree signature,
 667                              tree (*signature_builder) (tree))
 668 {
 669   tree klass;
 670   for (klass = CLASSTYPE_SUPER (searched_class); klass != NULL_TREE;
 671        klass = CLASSTYPE_SUPER (klass))
 672     {
 673       tree method;
 674       method = shallow_find_method (klass, flags, method_name,
 675                                     signature, signature_builder);
 676       if (method != NULL_TREE)
 677         return method;
 678     }
 679
 680   return NULL_TREE;
 681 }
 682
 683 /* Search in the interfaces of SEARCHED_CLASS and its superinterfaces
 684    for a method matching METHOD_NAME and signature SIGNATURE.  A
 685    private helper for lookup_do.  */
 686 static tree
 687 find_method_in_interfaces (tree searched_class, int flags, tree method_name,
 688                            tree signature, tree (*signature_builder) (tree))
 689 {
 690   int i;
 691   tree binfo, base_binfo;
 692
 693   for (binfo = TYPE_BINFO (searched_class), i = 1;
 694        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 695     {
 696       tree iclass = BINFO_TYPE (base_binfo);
 697       tree method;
 698
 699       /* If the superinterface hasn't been loaded yet, do so now.  */
 700       if (!CLASS_LOADED_P (iclass))
 701         load_class (iclass, 1);
 702
 703       /* First, we look in ICLASS.  If that doesn't work we'll
 704          recursively look through all its superinterfaces.  */
 705       method = shallow_find_method (iclass, flags, method_name,
 706                                     signature, signature_builder);
 707       if (method != NULL_TREE)
 708         return method;
 709
 710       method = find_method_in_interfaces
 711         (iclass, flags, method_name, signature, signature_builder);
 712       if (method != NULL_TREE)
 713         return method;
 714     }
 715
 716   return NULL_TREE;
 717 }
 718
 719
 720 /* Search in class SEARCHED_CLASS (and its superclasses) for a method
 721    matching METHOD_NAME and signature SIGNATURE.  FLAGS control some
 722    parameters of the search.
 723
 724    SEARCH_INTERFACE means also search interfaces and superinterfaces
 725    of SEARCHED_CLASS.
 726
 727    SEARCH_SUPER means skip SEARCHED_CLASS and start with its
 728    superclass.
 729
 730    SEARCH_VISIBLE means skip methods for which METHOD_INVISIBLE is
 731    set.
 732
 733    Return the matched method DECL or NULL_TREE.  SIGNATURE_BUILDER is
 734    used on method candidates to build their (sometimes partial)
 735    signature.  */
 736 static tree
 737 lookup_do (tree searched_class, int flags, tree method_name,
 738            tree signature, tree (*signature_builder) (tree))
 739 {
 740   tree method;
 741   tree orig_class = searched_class;
 742
 743   if (searched_class == NULL_TREE)
 744     return NULL_TREE;
 745
 746   if (flags & SEARCH_SUPER)
 747     {
 748       searched_class = CLASSTYPE_SUPER (searched_class);
 749       if (searched_class == NULL_TREE)
 750         return NULL_TREE;
 751     }
 752
 753   /* First look in our own methods.  */
 754   method = shallow_find_method (searched_class, flags, method_name,
 755                                 signature, signature_builder);
 756   if (method)
 757     return method;
 758
 759   /* Then look in our superclasses.  */
 760   if (! CLASS_INTERFACE (TYPE_NAME (searched_class)))
 761     method = find_method_in_superclasses (searched_class, flags, method_name,
 762                                           signature, signature_builder);
 763   if (method)
 764     return method;
 765
 766   /* If that doesn't work, look in our interfaces.  */
 767   if (flags & SEARCH_INTERFACE)
 768     method = find_method_in_interfaces (orig_class, flags, method_name,
 769                                         signature, signature_builder);
 770
 771   return method;
 772 }
 773
 774 /* Search in class CLAS for a constructor matching METHOD_SIGNATURE.
 775    Return a FUNCTION_DECL on success, or NULL_TREE if none found. */
 776
 777 tree
 778 lookup_java_constructor (tree clas, tree method_signature)
 779 {
 780   tree method = TYPE_METHODS (clas);
 781   for ( ; method != NULL_TREE;  method = TREE_CHAIN (method))
 782     {
 783       tree method_sig = build_java_signature (TREE_TYPE (method));
 784       if (DECL_CONSTRUCTOR_P (method) && method_sig == method_signature)
 785         return method;
 786     }
 787   return NULL_TREE;
 788 }
 789
 790 /* Return a type which is the Binary Numeric Promotion of the pair T1,
 791    T2 and convert EXP1 and/or EXP2. See 5.6.2 Binary Numeric
 792    Promotion. It assumes that both T1 and T2 are eligible to BNP. */
 793
 794 tree
 795 binary_numeric_promotion (tree t1, tree t2, tree *exp1, tree *exp2)
 796 {
 797   if (t1 == double_type_node || t2 == double_type_node)
 798     {
 799       if (t1 != double_type_node)
 800         *exp1 = convert (double_type_node, *exp1);
 801       if (t2 != double_type_node)
 802         *exp2 = convert (double_type_node, *exp2);
 803       return double_type_node;
 804     }
 805   if (t1 == float_type_node || t2 == float_type_node)
 806     {
 807       if (t1 != float_type_node)
 808         *exp1 = convert (float_type_node, *exp1);
 809       if (t2 != float_type_node)
 810         *exp2 = convert (float_type_node, *exp2);
 811       return float_type_node;
 812     }
 813   if (t1 == long_type_node || t2 == long_type_node)
 814     {
 815       if (t1 != long_type_node)
 816         *exp1 = convert (long_type_node, *exp1);
 817       if (t2 != long_type_node)
 818         *exp2 = convert (long_type_node, *exp2);
 819       return long_type_node;
 820     }
 821
 822   if (t1 != int_type_node)
 823     *exp1 = convert (int_type_node, *exp1);
 824   if (t2 != int_type_node)
 825     *exp2 = convert (int_type_node, *exp2);
 826   return int_type_node;
 827 }