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