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.
5 This file is part of GCC.
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)
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.
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/>.
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. */
25 /* Written by Per Bothner <bothner@cygnus.com> */
29 #include "coretypes.h"
35 #include "java-tree.h"
41 static tree convert_ieee_real_to_integer (tree, tree);
42 static tree parse_signature_type (const unsigned char **,
43 const unsigned char *);
44 static tree lookup_do (tree, int, tree, tree, tree (*)(tree));
45 static tree build_null_signature (tree);
49 /* Set the type of the local variable with index SLOT to TYPE. */
52 set_local_type (int slot, tree type)
54 int max_locals = DECL_MAX_LOCALS(current_function_decl);
55 int nslots = TYPE_IS_WIDE (type) ? 2 : 1;
57 gcc_assert (slot >= 0 && (slot + nslots - 1 < max_locals));
59 type_map[slot] = type;
61 type_map[++slot] = void_type_node;
64 /* Convert an IEEE real to an integer type. The result of such a
65 conversion when the source operand is a NaN isn't defined by
66 IEEE754, but by the Java language standard: it must be zero. Also,
67 overflows must be clipped to within range. This conversion
68 produces something like:
70 ((expr >= (float)MAX_INT)
72 : ((expr <= (float)MIN_INT)
79 convert_ieee_real_to_integer (tree type, tree expr)
82 expr = save_expr (expr);
84 result = fold_build3 (COND_EXPR, type,
85 fold_build2 (NE_EXPR, boolean_type_node, expr, expr),
86 convert (type, integer_zero_node),
87 convert_to_integer (type, expr));
89 result = fold_build3 (COND_EXPR, type,
90 fold_build2 (LE_EXPR, boolean_type_node, expr,
91 convert (TREE_TYPE (expr),
92 TYPE_MIN_VALUE (type))),
93 TYPE_MIN_VALUE (type),
96 result = fold_build3 (COND_EXPR, type,
97 fold_build2 (GE_EXPR, boolean_type_node, expr,
98 convert (TREE_TYPE (expr),
99 TYPE_MAX_VALUE (type))),
100 TYPE_MAX_VALUE (type),
106 /* Create an expression whose value is that of EXPR,
107 converted to type TYPE. The TREE_TYPE of the value
108 is always TYPE. This function implements all reasonable
109 conversions; callers should filter out those that are
110 not permitted by the language being compiled. */
113 convert (tree type, tree expr)
115 enum tree_code code = TREE_CODE (type);
118 return error_mark_node;
120 if (type == TREE_TYPE (expr)
121 || TREE_CODE (expr) == ERROR_MARK)
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 (type, expr);
129 if (code == INTEGER_TYPE)
131 if (type == char_type_node || type == promoted_char_type_node)
132 return fold_convert (type, expr);
133 if ((really_constant_p (expr) || ! flag_unsafe_math_optimizations)
134 && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
135 return convert_ieee_real_to_integer (type, expr);
138 /* fold very helpfully sets the overflow status if a type
139 overflows in a narrowing integer conversion, but Java
141 tree tmp = fold (convert_to_integer (type, expr));
142 if (TREE_CODE (tmp) == INTEGER_CST)
143 TREE_OVERFLOW (tmp) = 0;
147 if (code == REAL_TYPE)
148 return fold (convert_to_real (type, expr));
149 if (code == POINTER_TYPE)
150 return fold (convert_to_pointer (type, expr));
151 error ("conversion to non-scalar type requested");
152 return error_mark_node;
156 /* Return a data type that has machine mode MODE.
157 If the mode is an integer,
158 then UNSIGNEDP selects between signed and unsigned types. */
161 java_type_for_mode (enum machine_mode mode, int unsignedp)
163 if (mode == TYPE_MODE (int_type_node))
164 return unsignedp ? unsigned_int_type_node : int_type_node;
165 if (mode == TYPE_MODE (long_type_node))
166 return unsignedp ? unsigned_long_type_node : long_type_node;
167 if (mode == TYPE_MODE (short_type_node))
168 return unsignedp ? unsigned_short_type_node : short_type_node;
169 if (mode == TYPE_MODE (byte_type_node))
170 return unsignedp ? unsigned_byte_type_node : byte_type_node;
171 if (mode == TYPE_MODE (float_type_node))
172 return float_type_node;
173 if (mode == TYPE_MODE (double_type_node))
174 return double_type_node;
179 /* Return an integer type with BITS bits of precision,
180 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
183 java_type_for_size (unsigned bits, int unsignedp)
185 if (bits <= TYPE_PRECISION (byte_type_node))
186 return unsignedp ? unsigned_byte_type_node : byte_type_node;
187 if (bits <= TYPE_PRECISION (short_type_node))
188 return unsignedp ? unsigned_short_type_node : short_type_node;
189 if (bits <= TYPE_PRECISION (int_type_node))
190 return unsignedp ? unsigned_int_type_node : int_type_node;
191 if (bits <= TYPE_PRECISION (long_type_node))
192 return unsignedp ? unsigned_long_type_node : long_type_node;
196 /* Mark EXP saying that we need to be able to take the
197 address of it; it should not be allocated in a register.
198 Value is true if successful. */
201 java_mark_addressable (tree exp)
205 switch (TREE_CODE (x))
212 x = TREE_OPERAND (x, 0);
215 case TRUTH_ANDIF_EXPR:
216 case TRUTH_ORIF_EXPR:
218 x = TREE_OPERAND (x, 1);
222 return java_mark_addressable (TREE_OPERAND (x, 1))
223 && java_mark_addressable (TREE_OPERAND (x, 2));
226 TREE_ADDRESSABLE (x) = 1;
230 /* We sometimes add a cast *(TYPE*)&FOO to handle type and mode
231 incompatibility problems. Handle this case by marking FOO. */
232 if (TREE_CODE (TREE_OPERAND (x, 0)) == NOP_EXPR
233 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (x, 0), 0)) == ADDR_EXPR)
235 x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
238 if (TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
240 x = TREE_OPERAND (x, 0);
250 TREE_ADDRESSABLE (x) = 1;
251 #if 0 /* poplevel deals with this now. */
252 if (DECL_CONTEXT (x) == 0)
253 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
261 /* Thorough checking of the arrayness of TYPE. */
264 is_array_type_p (tree type)
266 return TREE_CODE (type) == POINTER_TYPE
267 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
268 && TYPE_ARRAY_P (TREE_TYPE (type));
271 /* Return the length of a Java array type.
272 Return -1 if the length is unknown or non-constant. */
275 java_array_type_length (tree array_type)
278 if (TREE_CODE (array_type) == POINTER_TYPE)
279 array_type = TREE_TYPE (array_type);
280 arfld = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type)));
281 if (arfld != NULL_TREE)
283 tree index_type = TYPE_DOMAIN (TREE_TYPE (arfld));
284 if (index_type != NULL_TREE)
286 tree high = TYPE_MAX_VALUE (index_type);
287 if (TREE_CODE (high) == INTEGER_CST)
288 return TREE_INT_CST_LOW (high) + 1;
294 /* An array of unknown length will be ultimately given a length of
295 -2, so that we can still have `length' producing a negative value
296 even if found. This was part of an optimization aiming at removing
297 `length' from static arrays. We could restore it, FIXME. */
300 build_prim_array_type (tree element_type, HOST_WIDE_INT length)
306 tree max_index = build_int_cst (sizetype, length - 1);
307 index = build_index_type (max_index);
309 return build_array_type (element_type, index);
312 /* Return a Java array type with a given ELEMENT_TYPE and LENGTH.
313 These are hashed (shared) using IDENTIFIER_SIGNATURE_TYPE.
314 The LENGTH is -1 if the length is unknown. */
317 build_java_array_type (tree element_type, HOST_WIDE_INT length)
319 tree sig, t, fld, atype, arfld;
321 tree elsig = build_java_signature (element_type);
322 tree el_name = element_type;
325 sprintf (buf+1, HOST_WIDE_INT_PRINT_DEC, length);
328 sig = ident_subst (IDENTIFIER_POINTER (elsig), IDENTIFIER_LENGTH (elsig),
330 t = IDENTIFIER_SIGNATURE_TYPE (sig);
332 return TREE_TYPE (t);
334 IDENTIFIER_SIGNATURE_TYPE (sig) = build_pointer_type (t);
335 TYPE_ARRAY_P (t) = 1;
337 if (TREE_CODE (el_name) == POINTER_TYPE)
338 el_name = TREE_TYPE (el_name);
339 el_name = TYPE_NAME (el_name);
340 if (TREE_CODE (el_name) == TYPE_DECL)
341 el_name = DECL_NAME (el_name);
345 sprintf (suffix, "[%d]", (int)length);
347 strcpy (suffix, "[]");
350 = build_decl (input_location, TYPE_DECL,
351 identifier_subst (el_name, "", '.', '.', suffix),
353 TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (t)) = true;
356 set_java_signature (t, sig);
357 set_super_info (0, t, object_type_node, 0);
358 if (TREE_CODE (element_type) == RECORD_TYPE)
359 element_type = promote_type (element_type);
360 TYPE_ARRAY_ELEMENT (t) = element_type;
362 /* Add length pseudo-field. */
363 fld = build_decl (input_location,
364 FIELD_DECL, get_identifier ("length"), int_type_node);
365 TYPE_FIELDS (t) = fld;
366 DECL_CONTEXT (fld) = t;
367 FIELD_PUBLIC (fld) = 1;
368 FIELD_FINAL (fld) = 1;
369 TREE_READONLY (fld) = 1;
371 atype = build_prim_array_type (element_type, length);
372 arfld = build_decl (input_location,
373 FIELD_DECL, get_identifier ("data"), atype);
374 DECL_CONTEXT (arfld) = t;
375 TREE_CHAIN (fld) = arfld;
376 DECL_ALIGN (arfld) = TYPE_ALIGN (element_type);
378 /* We could layout_class, but that loads java.lang.Object prematurely.
379 * This is called by the parser, and it is a bad idea to do load_class
380 * in the middle of parsing, because of possible circularity problems. */
381 push_super_field (t, object_type_node);
387 /* Promote TYPE to the type actually used for fields and parameters. */
390 promote_type (tree type)
392 switch (TREE_CODE (type))
395 return build_pointer_type (type);
397 if (type == boolean_type_node)
398 return promoted_boolean_type_node;
401 if (type == char_type_node)
402 return promoted_char_type_node;
404 if (TYPE_PRECISION (type) < TYPE_PRECISION (int_type_node))
406 if (type == short_type_node)
407 return promoted_short_type_node;
408 if (type == byte_type_node)
409 return promoted_byte_type_node;
410 return int_type_node;
412 /* ... else fall through ... */
418 /* Parse a signature string, starting at *PTR and ending at LIMIT.
419 Return the seen TREE_TYPE, updating *PTR. */
422 parse_signature_type (const unsigned char **ptr, const unsigned char *limit)
425 gcc_assert (*ptr < limit);
429 case 'B': (*ptr)++; return byte_type_node;
430 case 'C': (*ptr)++; return char_type_node;
431 case 'D': (*ptr)++; return double_type_node;
432 case 'F': (*ptr)++; return float_type_node;
433 case 'S': (*ptr)++; return short_type_node;
434 case 'I': (*ptr)++; return int_type_node;
435 case 'J': (*ptr)++; return long_type_node;
436 case 'Z': (*ptr)++; return boolean_type_node;
437 case 'V': (*ptr)++; return void_type_node;
439 for ((*ptr)++; (*ptr) < limit && ISDIGIT (**ptr); ) (*ptr)++;
440 type = parse_signature_type (ptr, limit);
441 type = build_java_array_type (type, -1);
445 const unsigned char *start = ++(*ptr);
446 const unsigned char *str = start;
449 gcc_assert (str < limit);
454 type = lookup_class (unmangle_classname ((const char *) start, str - start));
460 return promote_type (type);
463 /* Parse a Java "mangled" signature string, starting at SIG_STRING,
464 and SIG_LENGTH bytes long.
465 Return a gcc type node. */
468 parse_signature_string (const unsigned char *sig_string, int sig_length)
471 const unsigned char *str = sig_string;
472 const unsigned char *limit = str + sig_length;
474 if (str < limit && str[0] == '(')
476 tree argtype_list = NULL_TREE;
478 while (str < limit && str[0] != ')')
480 tree argtype = parse_signature_type (&str, limit);
481 argtype_list = tree_cons (NULL_TREE, argtype, argtype_list);
483 if (str++, str >= limit)
485 result_type = parse_signature_type (&str, limit);
486 argtype_list = chainon (nreverse (argtype_list), end_params_node);
487 result_type = build_function_type (result_type, argtype_list);
490 result_type = parse_signature_type (&str, limit);
492 error ("junk at end of signature string");
496 /* Convert a signature to its type.
497 * Uses IDENTIFIER_SIGNATURE_TYPE as a cache (except for primitive types).
501 get_type_from_signature (tree signature)
503 const unsigned char *sig = (const unsigned char *) IDENTIFIER_POINTER (signature);
504 int len = IDENTIFIER_LENGTH (signature);
506 /* Primitive types aren't cached. */
508 return parse_signature_string (sig, len);
509 type = IDENTIFIER_SIGNATURE_TYPE (signature);
510 if (type == NULL_TREE)
512 type = parse_signature_string (sig, len);
513 IDENTIFIER_SIGNATURE_TYPE (signature) = type;
518 /* Ignore signature and always return null. Used by has_method. */
521 build_null_signature (tree type ATTRIBUTE_UNUSED)
526 /* Return the signature string for the arguments of method type TYPE. */
529 build_java_argument_signature (tree type)
531 extern struct obstack temporary_obstack;
532 tree sig = TYPE_ARGUMENT_SIGNATURE (type);
533 if (sig == NULL_TREE)
535 tree args = TYPE_ARG_TYPES (type);
536 if (TREE_CODE (type) == METHOD_TYPE)
537 args = TREE_CHAIN (args); /* Skip "this" argument. */
538 for (; args != end_params_node; args = TREE_CHAIN (args))
540 tree t = build_java_signature (TREE_VALUE (args));
541 obstack_grow (&temporary_obstack,
542 IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
544 obstack_1grow (&temporary_obstack, '\0');
546 sig = get_identifier (obstack_base (&temporary_obstack));
547 TYPE_ARGUMENT_SIGNATURE (type) = sig;
548 obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
553 /* Return the signature of the given TYPE. */
556 build_java_signature (tree type)
559 while (TREE_CODE (type) == POINTER_TYPE)
560 type = TREE_TYPE (type);
561 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
562 sig = TYPE_SIGNATURE (type);
563 if (sig == NULL_TREE)
566 switch (TREE_CODE (type))
568 case BOOLEAN_TYPE: sg[0] = 'Z'; goto native;
569 case VOID_TYPE: sg[0] = 'V'; goto native;
571 if (type == char_type_node || type == promoted_char_type_node)
576 switch (TYPE_PRECISION (type))
578 case 8: sg[0] = 'B'; goto native;
579 case 16: sg[0] = 'S'; goto native;
580 case 32: sg[0] = 'I'; goto native;
581 case 64: sg[0] = 'J'; goto native;
582 default: goto bad_type;
585 switch (TYPE_PRECISION (type))
587 case 32: sg[0] = 'F'; goto native;
588 case 64: sg[0] = 'D'; goto native;
589 default: goto bad_type;
593 sig = get_identifier (sg);
596 if (TYPE_ARRAY_P (type))
598 t = build_java_signature (TYPE_ARRAY_ELEMENT (type));
599 sig = ident_subst (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t),
604 t = DECL_NAME (TYPE_NAME (type));
605 sig = ident_subst (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t),
612 extern struct obstack temporary_obstack;
613 sig = build_java_argument_signature (type);
614 obstack_1grow (&temporary_obstack, '(');
615 obstack_grow (&temporary_obstack,
616 IDENTIFIER_POINTER (sig), IDENTIFIER_LENGTH (sig));
617 obstack_1grow (&temporary_obstack, ')');
619 t = build_java_signature (TREE_TYPE (type));
620 obstack_grow0 (&temporary_obstack,
621 IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
623 sig = get_identifier (obstack_base (&temporary_obstack));
624 obstack_free (&temporary_obstack,
625 obstack_base (&temporary_obstack));
632 TYPE_SIGNATURE (type) = sig;
637 /* Save signature string SIG (an IDENTIFIER_NODE) in TYPE for future use. */
640 set_java_signature (tree type, tree sig)
643 while (TREE_CODE (type) == POINTER_TYPE)
644 type = TREE_TYPE (type);
645 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
646 old_sig = TYPE_SIGNATURE (type);
647 if (old_sig != NULL_TREE && old_sig != sig)
649 TYPE_SIGNATURE (type) = sig;
650 #if 0 /* careful about METHOD_TYPE */
651 if (IDENTIFIER_SIGNATURE_TYPE (sig) == NULL_TREE && TREE_PERMANENT (type))
652 IDENTIFIER_SIGNATURE_TYPE (sig) = type;
656 /* Search in SEARCHED_CLASS and its superclasses for a method matching
657 METHOD_NAME and signature METHOD_SIGNATURE. This function will
658 only search for methods declared in the class hierarchy; interfaces
659 will not be considered. Returns NULL_TREE if the method is not
662 lookup_argument_method (tree searched_class, tree method_name,
663 tree method_signature)
665 return lookup_do (searched_class, 0,
666 method_name, method_signature,
667 build_java_argument_signature);
670 /* Like lookup_argument_method, but lets the caller set any flags
673 lookup_argument_method_generic (tree searched_class, tree method_name,
674 tree method_signature, int flags)
676 return lookup_do (searched_class, flags,
677 method_name, method_signature,
678 build_java_argument_signature);
682 /* Search in class SEARCHED_CLASS (and its superclasses) for a method
683 matching METHOD_NAME and signature METHOD_SIGNATURE. Return a
684 FUNCTION_DECL on success, or NULL_TREE if none found. (Contrast
685 lookup_argument_method, which ignores return type.) If
686 SEARCHED_CLASS is an interface, search it too. */
688 lookup_java_method (tree searched_class, tree method_name,
689 tree method_signature)
691 return lookup_do (searched_class, SEARCH_INTERFACE, method_name,
692 method_signature, build_java_signature);
695 /* Return true iff KLASS (or its ancestors) has a method METHOD_NAME. */
697 has_method (tree klass, tree method_name)
699 return lookup_do (klass, SEARCH_INTERFACE,
700 method_name, NULL_TREE,
701 build_null_signature) != NULL_TREE;
704 /* Search in class SEARCHED_CLASS, but not its superclasses, for a
705 method matching METHOD_NAME and signature SIGNATURE. A private
706 helper for lookup_do. */
708 shallow_find_method (tree searched_class, int flags, tree method_name,
709 tree signature, tree (*signature_builder) (tree))
712 for (method = TYPE_METHODS (searched_class);
713 method != NULL_TREE; method = TREE_CHAIN (method))
715 tree method_sig = (*signature_builder) (TREE_TYPE (method));
716 if (DECL_NAME (method) == method_name && method_sig == signature)
718 /* If the caller requires a visible method, then we
719 skip invisible methods here. */
720 if (! (flags & SEARCH_VISIBLE)
721 || ! METHOD_INVISIBLE (method))
728 /* Search in the superclasses of SEARCHED_CLASS for a method matching
729 METHOD_NAME and signature SIGNATURE. A private helper for
732 find_method_in_superclasses (tree searched_class, int flags,
733 tree method_name, tree signature,
734 tree (*signature_builder) (tree))
737 for (klass = CLASSTYPE_SUPER (searched_class); klass != NULL_TREE;
738 klass = CLASSTYPE_SUPER (klass))
741 method = shallow_find_method (klass, flags, method_name,
742 signature, signature_builder);
743 if (method != NULL_TREE)
750 /* Search in the interfaces of SEARCHED_CLASS and its superinterfaces
751 for a method matching METHOD_NAME and signature SIGNATURE. A
752 private helper for lookup_do. */
754 find_method_in_interfaces (tree searched_class, int flags, tree method_name,
755 tree signature, tree (*signature_builder) (tree))
758 tree binfo, base_binfo;
760 for (binfo = TYPE_BINFO (searched_class), i = 1;
761 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
763 tree iclass = BINFO_TYPE (base_binfo);
766 /* If the superinterface hasn't been loaded yet, do so now. */
767 if (!CLASS_LOADED_P (iclass))
768 load_class (iclass, 1);
770 /* First, we look in ICLASS. If that doesn't work we'll
771 recursively look through all its superinterfaces. */
772 method = shallow_find_method (iclass, flags, method_name,
773 signature, signature_builder);
774 if (method != NULL_TREE)
777 method = find_method_in_interfaces
778 (iclass, flags, method_name, signature, signature_builder);
779 if (method != NULL_TREE)
787 /* Search in class SEARCHED_CLASS (and its superclasses) for a method
788 matching METHOD_NAME and signature SIGNATURE. FLAGS control some
789 parameters of the search.
791 SEARCH_INTERFACE means also search interfaces and superinterfaces
794 SEARCH_SUPER means skip SEARCHED_CLASS and start with its
797 SEARCH_VISIBLE means skip methods for which METHOD_INVISIBLE is
800 Return the matched method DECL or NULL_TREE. SIGNATURE_BUILDER is
801 used on method candidates to build their (sometimes partial)
804 lookup_do (tree searched_class, int flags, tree method_name,
805 tree signature, tree (*signature_builder) (tree))
808 tree orig_class = searched_class;
810 if (searched_class == NULL_TREE)
813 if (flags & SEARCH_SUPER)
815 searched_class = CLASSTYPE_SUPER (searched_class);
816 if (searched_class == NULL_TREE)
820 /* First look in our own methods. */
821 method = shallow_find_method (searched_class, flags, method_name,
822 signature, signature_builder);
826 /* Then look in our superclasses. */
827 if (! CLASS_INTERFACE (TYPE_NAME (searched_class)))
828 method = find_method_in_superclasses (searched_class, flags, method_name,
829 signature, signature_builder);
833 /* If that doesn't work, look in our interfaces. */
834 if (flags & SEARCH_INTERFACE)
835 method = find_method_in_interfaces (orig_class, flags, method_name,
836 signature, signature_builder);
841 /* Search in class CLAS for a constructor matching METHOD_SIGNATURE.
842 Return a FUNCTION_DECL on success, or NULL_TREE if none found. */
845 lookup_java_constructor (tree clas, tree method_signature)
847 tree method = TYPE_METHODS (clas);
848 for ( ; method != NULL_TREE; method = TREE_CHAIN (method))
850 tree method_sig = build_java_signature (TREE_TYPE (method));
851 if (DECL_CONSTRUCTOR_P (method) && method_sig == method_signature)
857 /* Return a type which is the Binary Numeric Promotion of the pair T1,
858 T2 and convert EXP1 and/or EXP2. See 5.6.2 Binary Numeric
859 Promotion. It assumes that both T1 and T2 are eligible to BNP. */
862 binary_numeric_promotion (tree t1, tree t2, tree *exp1, tree *exp2)
864 if (t1 == double_type_node || t2 == double_type_node)
866 if (t1 != double_type_node)
867 *exp1 = convert (double_type_node, *exp1);
868 if (t2 != double_type_node)
869 *exp2 = convert (double_type_node, *exp2);
870 return double_type_node;
872 if (t1 == float_type_node || t2 == float_type_node)
874 if (t1 != float_type_node)
875 *exp1 = convert (float_type_node, *exp1);
876 if (t2 != float_type_node)
877 *exp2 = convert (float_type_node, *exp2);
878 return float_type_node;
880 if (t1 == long_type_node || t2 == long_type_node)
882 if (t1 != long_type_node)
883 *exp1 = convert (long_type_node, *exp1);
884 if (t2 != long_type_node)
885 *exp2 = convert (long_type_node, *exp2);
886 return long_type_node;
889 if (t1 != int_type_node)
890 *exp1 = convert (int_type_node, *exp1);
891 if (t2 != int_type_node)
892 *exp2 = convert (int_type_node, *exp2);
893 return int_type_node;