gcc/java/typeck.c

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