1 /* Handle types for the GNU compiler for the Java(TM) language.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003
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 2, 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 COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
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. */
26 /* Written by Per Bothner <bothner@cygnus.com> */
30 #include "coretypes.h"
36 #include "java-tree.h"
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
, tree
, tree
, tree
, tree (*)(tree
));
46 static tree
build_null_signature (tree
);
50 /* Set the type of the local variable with index SLOT to TYPE. */
53 set_local_type (slot
, type
)
57 int max_locals
= DECL_MAX_LOCALS(current_function_decl
);
58 int nslots
= TYPE_IS_WIDE (type
) ? 2 : 1;
60 if (slot
< 0 || slot
+ nslots
- 1 >= max_locals
)
63 type_map
[slot
] = type
;
65 type_map
[++slot
] = void_type_node
;
68 /* Convert an IEEE real to an integer type. The result of such a
69 conversion when the source operand is a NaN isn't defined by
70 IEEE754, but by the Java language standard: it must be zero. Also,
71 overflows must be clipped to within range. This conversion
72 produces something like:
74 ((expr >= (float)MAX_INT)
76 : ((expr <= (float)MIN_INT)
83 convert_ieee_real_to_integer (type
, expr
)
87 expr
= save_expr (expr
);
89 result
= build (COND_EXPR
, type
,
90 build (NE_EXPR
, boolean_type_node
, expr
, expr
),
91 convert (type
, integer_zero_node
),
92 convert_to_integer (type
, expr
));
94 result
= build (COND_EXPR
, type
,
95 build (LE_EXPR
, boolean_type_node
, expr
,
96 convert (TREE_TYPE (expr
), TYPE_MIN_VALUE (type
))),
97 TYPE_MIN_VALUE (type
),
100 result
= build (COND_EXPR
, type
,
101 build (GE_EXPR
, boolean_type_node
, expr
,
102 convert (TREE_TYPE (expr
), TYPE_MAX_VALUE (type
))),
103 TYPE_MAX_VALUE (type
),
109 /* Create an expression whose value is that of EXPR,
110 converted to type TYPE. The TREE_TYPE of the value
111 is always TYPE. This function implements all reasonable
112 conversions; callers should filter out those that are
113 not permitted by the language being compiled. */
119 register enum tree_code code
= TREE_CODE (type
);
122 return error_mark_node
;
125 return build1 (NOP_EXPR
, type
, expr
);
127 if (type
== TREE_TYPE (expr
)
128 || TREE_CODE (expr
) == ERROR_MARK
)
130 if (TREE_CODE (TREE_TYPE (expr
)) == ERROR_MARK
)
131 return error_mark_node
;
132 if (code
== VOID_TYPE
)
133 return build1 (CONVERT_EXPR
, type
, expr
);
134 if (code
== BOOLEAN_TYPE
)
135 return fold (convert_to_boolean (type
, expr
));
136 if (code
== INTEGER_TYPE
)
138 if (! flag_unsafe_math_optimizations
139 && ! flag_emit_class_files
140 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
141 && TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
142 return fold (convert_ieee_real_to_integer (type
, expr
));
144 return fold (convert_to_integer (type
, expr
));
146 if (code
== REAL_TYPE
)
147 return fold (convert_to_real (type
, expr
));
148 if (code
== CHAR_TYPE
)
149 return fold (convert_to_char (type
, expr
));
150 if (code
== POINTER_TYPE
)
151 return fold (convert_to_pointer (type
, expr
));
152 error ("conversion to non-scalar type requested");
153 return error_mark_node
;
158 convert_to_char (type
, expr
)
161 return build1 (NOP_EXPR
, type
, expr
);
165 convert_to_boolean (type
, expr
)
168 return build1 (NOP_EXPR
, type
, expr
);
171 /* Return a data type that has machine mode MODE.
172 If the mode is an integer,
173 then UNSIGNEDP selects between signed and unsigned types. */
176 java_type_for_mode (mode
, unsignedp
)
177 enum machine_mode mode
;
180 if (mode
== TYPE_MODE (int_type_node
))
181 return unsignedp
? unsigned_int_type_node
: int_type_node
;
182 if (mode
== TYPE_MODE (long_type_node
))
183 return unsignedp
? unsigned_long_type_node
: long_type_node
;
184 if (mode
== TYPE_MODE (short_type_node
))
185 return unsignedp
? unsigned_short_type_node
: short_type_node
;
186 if (mode
== TYPE_MODE (byte_type_node
))
187 return unsignedp
? unsigned_byte_type_node
: byte_type_node
;
188 if (mode
== TYPE_MODE (float_type_node
))
189 return float_type_node
;
190 if (mode
== TYPE_MODE (double_type_node
))
191 return double_type_node
;
196 /* Return an integer type with BITS bits of precision,
197 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
200 java_type_for_size (bits
, unsignedp
)
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
;
215 /* Return a type the same as TYPE except unsigned or
216 signed according to UNSIGNEDP. */
219 java_signed_or_unsigned_type (unsignedp
, type
)
223 if (! INTEGRAL_TYPE_P (type
))
225 if (TYPE_PRECISION (type
) == TYPE_PRECISION (int_type_node
))
226 return unsignedp
? unsigned_int_type_node
: int_type_node
;
227 if (TYPE_PRECISION (type
) == TYPE_PRECISION (byte_type_node
))
228 return unsignedp
? unsigned_byte_type_node
: byte_type_node
;
229 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_type_node
))
230 return unsignedp
? unsigned_short_type_node
: short_type_node
;
231 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_type_node
))
232 return unsignedp
? unsigned_long_type_node
: long_type_node
;
236 /* Return a signed type the same as TYPE in other respects. */
239 java_signed_type (type
)
242 return java_signed_or_unsigned_type (0, type
);
245 /* Return an unsigned type the same as TYPE in other respects. */
248 java_unsigned_type (type
)
251 return java_signed_or_unsigned_type (1, type
);
254 /* Mark EXP saying that we need to be able to take the
255 address of it; it should not be allocated in a register.
256 Value is true if successful. */
259 java_mark_addressable (exp
)
262 register tree x
= exp
;
264 switch (TREE_CODE (x
))
271 x
= TREE_OPERAND (x
, 0);
274 case TRUTH_ANDIF_EXPR
:
275 case TRUTH_ORIF_EXPR
:
277 x
= TREE_OPERAND (x
, 1);
281 return java_mark_addressable (TREE_OPERAND (x
, 1))
282 && java_mark_addressable (TREE_OPERAND (x
, 2));
285 TREE_ADDRESSABLE (x
) = 1;
289 /* We sometimes add a cast *(TYPE*)&FOO to handle type and mode
290 incompatibility problems. Handle this case by marking FOO. */
291 if (TREE_CODE (TREE_OPERAND (x
, 0)) == NOP_EXPR
292 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (x
, 0), 0)) == ADDR_EXPR
)
294 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
297 if (TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
299 x
= TREE_OPERAND (x
, 0);
309 TREE_ADDRESSABLE (x
) = 1;
310 #if 0 /* poplevel deals with this now. */
311 if (DECL_CONTEXT (x
) == 0)
312 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
320 /* Thorough checking of the arrayness of TYPE. */
323 is_array_type_p (type
)
326 return TREE_CODE (type
) == POINTER_TYPE
327 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
328 && TYPE_ARRAY_P (TREE_TYPE (type
));
331 /* Return the length of a Java array type.
332 Return -1 if the length is unknown or non-constant. */
335 java_array_type_length (array_type
)
339 if (TREE_CODE (array_type
) == POINTER_TYPE
)
340 array_type
= TREE_TYPE (array_type
);
341 arfld
= TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type
)));
342 if (arfld
!= NULL_TREE
)
344 tree index_type
= TYPE_DOMAIN (TREE_TYPE (arfld
));
345 if (index_type
!= NULL_TREE
)
347 tree high
= TYPE_MAX_VALUE (index_type
);
348 if (TREE_CODE (high
) == INTEGER_CST
)
349 return TREE_INT_CST_LOW (high
) + 1;
355 /* An array of unknown length will be ultimately given an length of
356 -2, so that we can still have `length' producing a negative value
357 even if found. This was part of an optimization amaing at removing
358 `length' from static arrays. We could restore it, FIXME. */
361 build_prim_array_type (element_type
, length
)
363 HOST_WIDE_INT length
;
369 tree max_index
= build_int_2 (length
- 1, (0 == length
? -1 : 0));
370 TREE_TYPE (max_index
) = sizetype
;
371 index
= build_index_type (max_index
);
373 return build_array_type (element_type
, index
);
376 /* Return a Java array type with a given ELEMENT_TYPE and LENGTH.
377 These are hashed (shared) using IDENTIFIER_SIGNATURE_TYPE.
378 The LENGTH is -1 if the length is unknown. */
381 build_java_array_type (element_type
, length
)
383 HOST_WIDE_INT length
;
385 tree sig
, t
, fld
, atype
, arfld
;
387 tree elsig
= build_java_signature (element_type
);
388 tree el_name
= element_type
;
391 sprintf (buf
+1, HOST_WIDE_INT_PRINT_DEC
, length
);
394 sig
= ident_subst (IDENTIFIER_POINTER (elsig
), IDENTIFIER_LENGTH (elsig
),
396 t
= IDENTIFIER_SIGNATURE_TYPE (sig
);
398 return TREE_TYPE (t
);
400 IDENTIFIER_SIGNATURE_TYPE (sig
) = build_pointer_type (t
);
401 TYPE_ARRAY_P (t
) = 1;
403 if (TREE_CODE (el_name
) == POINTER_TYPE
)
404 el_name
= TREE_TYPE (el_name
);
405 el_name
= TYPE_NAME (el_name
);
406 if (TREE_CODE (el_name
) == TYPE_DECL
)
407 el_name
= DECL_NAME (el_name
);
408 TYPE_NAME (t
) = build_decl (TYPE_DECL
,
409 identifier_subst (el_name
, "", '.', '.', "[]"),
412 set_java_signature (t
, sig
);
413 set_super_info (0, t
, object_type_node
, 0);
414 if (TREE_CODE (element_type
) == RECORD_TYPE
)
415 element_type
= promote_type (element_type
);
416 TYPE_ARRAY_ELEMENT (t
) = element_type
;
418 /* Add length pseudo-field. */
419 fld
= build_decl (FIELD_DECL
, get_identifier ("length"), int_type_node
);
420 TYPE_FIELDS (t
) = fld
;
421 DECL_CONTEXT (fld
) = t
;
422 FIELD_PUBLIC (fld
) = 1;
423 FIELD_FINAL (fld
) = 1;
424 TREE_READONLY (fld
) = 1;
426 atype
= build_prim_array_type (element_type
, length
);
427 arfld
= build_decl (FIELD_DECL
, get_identifier ("data"), atype
);
428 DECL_CONTEXT (arfld
) = t
;
429 TREE_CHAIN (fld
) = arfld
;
430 DECL_ALIGN (arfld
) = TYPE_ALIGN (element_type
);
432 /* We could layout_class, but that loads java.lang.Object prematurely.
433 * This is called by the parser, and it is a bad idea to do load_class
434 * in the middle of parsing, because of possible circularity problems. */
435 push_super_field (t
, object_type_node
);
441 /* Promote TYPE to the type actually used for fields and parameters. */
447 switch (TREE_CODE (type
))
450 return build_pointer_type (type
);
452 if (type
== boolean_type_node
)
453 return promoted_boolean_type_node
;
456 if (type
== char_type_node
)
457 return promoted_char_type_node
;
461 if (TYPE_PRECISION (type
) < TYPE_PRECISION (int_type_node
))
463 if (type
== short_type_node
)
464 return promoted_short_type_node
;
465 if (type
== byte_type_node
)
466 return promoted_byte_type_node
;
467 return int_type_node
;
469 /* ... else fall through ... */
475 /* Parse a signature string, starting at *PTR and ending at LIMIT.
476 Return the seen TREE_TYPE, updating *PTR. */
479 parse_signature_type (ptr
, limit
)
480 const unsigned char **ptr
, *limit
;
489 case 'B': (*ptr
)++; return byte_type_node
;
490 case 'C': (*ptr
)++; return char_type_node
;
491 case 'D': (*ptr
)++; return double_type_node
;
492 case 'F': (*ptr
)++; return float_type_node
;
493 case 'S': (*ptr
)++; return short_type_node
;
494 case 'I': (*ptr
)++; return int_type_node
;
495 case 'J': (*ptr
)++; return long_type_node
;
496 case 'Z': (*ptr
)++; return boolean_type_node
;
497 case 'V': (*ptr
)++; return void_type_node
;
499 for ((*ptr
)++; (*ptr
) < limit
&& ISDIGIT (**ptr
); ) (*ptr
)++;
500 type
= parse_signature_type (ptr
, limit
);
501 type
= build_java_array_type (type
, -1);
505 const unsigned char *start
= ++(*ptr
);
506 register const unsigned char *str
= start
;
515 type
= lookup_class (unmangle_classname (start
, str
- start
));
521 return promote_type (type
);
524 /* Parse a Java "mangled" signature string, starting at SIG_STRING,
525 and SIG_LENGTH bytes long.
526 Return a gcc type node. */
529 parse_signature_string (sig_string
, sig_length
)
530 const unsigned char *sig_string
;
534 const unsigned char *str
= sig_string
;
535 const unsigned char *limit
= str
+ sig_length
;
537 if (str
< limit
&& str
[0] == '(')
539 tree argtype_list
= NULL_TREE
;
541 while (str
< limit
&& str
[0] != ')')
543 tree argtype
= parse_signature_type (&str
, limit
);
544 argtype_list
= tree_cons (NULL_TREE
, argtype
, argtype_list
);
546 if (str
++, str
>= limit
)
548 result_type
= parse_signature_type (&str
, limit
);
549 argtype_list
= chainon (nreverse (argtype_list
), end_params_node
);
550 result_type
= build_function_type (result_type
, argtype_list
);
553 result_type
= parse_signature_type (&str
, limit
);
555 error ("junk at end of signature string");
559 /* Convert a signature to its type.
560 * Uses IDENTIFIER_SIGNATURE_TYPE as a cache (except for primitive types).
564 get_type_from_signature (tree signature
)
566 const unsigned char *sig
= (const unsigned char *) IDENTIFIER_POINTER (signature
);
567 int len
= IDENTIFIER_LENGTH (signature
);
569 /* Primitive types aren't cached. */
571 return parse_signature_string (sig
, len
);
572 type
= IDENTIFIER_SIGNATURE_TYPE (signature
);
573 if (type
== NULL_TREE
)
575 type
= parse_signature_string (sig
, len
);
576 IDENTIFIER_SIGNATURE_TYPE (signature
) = type
;
581 /* Ignore signature and always return null. Used by has_method. */
584 build_null_signature (type
)
585 tree type ATTRIBUTE_UNUSED
;
590 /* Return the signature string for the arguments of method type TYPE. */
593 build_java_argument_signature (type
)
596 extern struct obstack temporary_obstack
;
597 tree sig
= TYPE_ARGUMENT_SIGNATURE (type
);
598 if (sig
== NULL_TREE
)
600 tree args
= TYPE_ARG_TYPES (type
);
601 if (TREE_CODE (type
) == METHOD_TYPE
)
602 args
= TREE_CHAIN (args
); /* Skip "this" argument. */
603 for (; args
!= end_params_node
; args
= TREE_CHAIN (args
))
605 tree t
= build_java_signature (TREE_VALUE (args
));
606 obstack_grow (&temporary_obstack
,
607 IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
));
609 obstack_1grow (&temporary_obstack
, '\0');
611 sig
= get_identifier (obstack_base (&temporary_obstack
));
612 TYPE_ARGUMENT_SIGNATURE (type
) = sig
;
613 obstack_free (&temporary_obstack
, obstack_base (&temporary_obstack
));
618 /* Return the signature of the given TYPE. */
621 build_java_signature (type
)
625 while (TREE_CODE (type
) == POINTER_TYPE
)
626 type
= TREE_TYPE (type
);
627 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
628 sig
= TYPE_SIGNATURE (type
);
629 if (sig
== NULL_TREE
)
632 switch (TREE_CODE (type
))
634 case BOOLEAN_TYPE
: sg
[0] = 'Z'; goto native
;
635 case CHAR_TYPE
: sg
[0] = 'C'; goto native
;
636 case VOID_TYPE
: sg
[0] = 'V'; goto native
;
638 switch (TYPE_PRECISION (type
))
640 case 8: sg
[0] = 'B'; goto native
;
641 case 16: sg
[0] = 'S'; goto native
;
642 case 32: sg
[0] = 'I'; goto native
;
643 case 64: sg
[0] = 'J'; goto native
;
644 default: goto bad_type
;
647 switch (TYPE_PRECISION (type
))
649 case 32: sg
[0] = 'F'; goto native
;
650 case 64: sg
[0] = 'D'; goto native
;
651 default: goto bad_type
;
655 sig
= get_identifier (sg
);
658 if (TYPE_ARRAY_P (type
))
660 t
= build_java_signature (TYPE_ARRAY_ELEMENT (type
));
661 sig
= ident_subst (IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
),
666 t
= DECL_NAME (TYPE_NAME (type
));
667 sig
= ident_subst (IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
),
674 extern struct obstack temporary_obstack
;
675 sig
= build_java_argument_signature (type
);
676 obstack_1grow (&temporary_obstack
, '(');
677 obstack_grow (&temporary_obstack
,
678 IDENTIFIER_POINTER (sig
), IDENTIFIER_LENGTH (sig
));
679 obstack_1grow (&temporary_obstack
, ')');
681 t
= build_java_signature (TREE_TYPE (type
));
682 obstack_grow0 (&temporary_obstack
,
683 IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
));
685 sig
= get_identifier (obstack_base (&temporary_obstack
));
686 obstack_free (&temporary_obstack
,
687 obstack_base (&temporary_obstack
));
694 TYPE_SIGNATURE (type
) = sig
;
699 /* Save signature string SIG (an IDENTIFIER_NODE) in TYPE for future use. */
702 set_java_signature (type
, sig
)
707 while (TREE_CODE (type
) == POINTER_TYPE
)
708 type
= TREE_TYPE (type
);
709 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
710 old_sig
= TYPE_SIGNATURE (type
);
711 if (old_sig
!= NULL_TREE
&& old_sig
!= sig
)
713 TYPE_SIGNATURE (type
) = sig
;
714 #if 0 /* careful about METHOD_TYPE */
715 if (IDENTIFIER_SIGNATURE_TYPE (sig
) == NULL_TREE
&& TREE_PERMANENT (type
))
716 IDENTIFIER_SIGNATURE_TYPE (sig
) = type
;
720 /* Search in class SEARCHED_CLASS (and its superclasses) for a method
721 matching METHOD_NAME and signature SIGNATURE. If SEARCHED_INTERFACE is
722 not NULL_TREE then first search its superinterfaces for a similar match.
723 Return the matched method DECL or NULL_TREE. SIGNATURE_BUILDER is
724 used on method candidates to build their (sometimes partial)
728 lookup_argument_method (searched_class
, method_name
, method_signature
)
729 tree searched_class
, method_name
, method_signature
;
731 return lookup_do (searched_class
, NULL_TREE
, method_name
, method_signature
,
732 build_java_argument_signature
);
735 /* Search in class SEARCHED_CLASS (and its superclasses and
736 implemented interfaces) for a method matching METHOD_NAME and
737 argument signature METHOD_SIGNATURE. Return a FUNCTION_DECL on
738 success, or NULL_TREE if none found. (Contrast lookup_java_method,
739 which takes into account return type.) */
742 lookup_argument_method2 (searched_class
, method_name
, method_signature
)
743 tree searched_class
, method_name
, method_signature
;
745 return lookup_do (CLASSTYPE_SUPER (searched_class
), searched_class
,
746 method_name
, method_signature
,
747 build_java_argument_signature
);
750 /* Search in class SEARCHED_CLASS (and its superclasses) for a method
751 matching METHOD_NAME and signature METHOD_SIGNATURE. Return a
752 FUNCTION_DECL on success, or NULL_TREE if none found. (Contrast
753 lookup_argument_method, which ignores return type.) If
754 SEARCHED_CLASS is an interface, search it too. */
757 lookup_java_method (searched_class
, method_name
, method_signature
)
758 tree searched_class
, method_name
, method_signature
;
760 tree searched_interface
;
762 /* If this class is an interface class, search its superinterfaces
763 * first. A superinterface is not an interface's superclass: a super
764 * interface is implemented by the interface. */
766 searched_interface
= (CLASS_INTERFACE (TYPE_NAME (searched_class
)) ?
767 searched_class
: NULL_TREE
);
768 return lookup_do (searched_class
, searched_interface
, method_name
,
769 method_signature
, build_java_signature
);
772 /* Return true iff CLASS (or its ancestors) has a method METHOD_NAME. */
775 has_method (class, method_name
)
779 return lookup_do (class, class, method_name
,
780 NULL_TREE
, build_null_signature
) != NULL_TREE
;
783 /* Search in class SEARCHED_CLASS (and its superclasses) for a method
784 matching METHOD_NAME and signature SIGNATURE. Also search in
785 SEARCHED_INTERFACE (and its superinterfaces) for a similar match.
786 Return the matched method DECL or NULL_TREE. SIGNATURE_BUILDER is
787 used on method candidates to build their (sometimes partial)
791 lookup_do (searched_class
, searched_interface
, method_name
, signature
, signature_builder
)
792 tree searched_class
, searched_interface
, method_name
, signature
;
793 tree (*signature_builder
) (tree
);
797 if (searched_interface
)
801 TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (searched_interface
)) - 1;
803 for (i
= interface_len
; i
> 0; i
--)
806 TREE_VEC_ELT (TYPE_BINFO_BASETYPES (searched_interface
), i
);
807 tree iclass
= BINFO_TYPE (child
);
809 /* If the superinterface hasn't been loaded yet, do so now. */
810 if (CLASS_FROM_SOURCE_P (iclass
))
811 safe_layout_class (iclass
);
812 else if (!CLASS_LOADED_P (iclass
))
813 load_class (iclass
, 1);
815 for (method
= TYPE_METHODS (iclass
);
816 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
818 tree method_sig
= (*signature_builder
) (TREE_TYPE (method
));
820 if (DECL_NAME (method
) == method_name
&& method_sig
== signature
)
824 /* it could be defined in a supersuperinterface */
825 if (CLASS_INTERFACE (TYPE_NAME (iclass
)))
827 method
= lookup_do (iclass
, iclass
, method_name
,
828 signature
, signature_builder
);
829 if (method
!= NULL_TREE
)
835 while (searched_class
!= NULL_TREE
)
837 for (method
= TYPE_METHODS (searched_class
);
838 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
840 tree method_sig
= (*signature_builder
) (TREE_TYPE (method
));
841 if (DECL_NAME (method
) == method_name
&& method_sig
== signature
)
844 searched_class
= CLASSTYPE_SUPER (searched_class
);
850 /* Search in class CLAS for a constructor matching METHOD_SIGNATURE.
851 Return a FUNCTION_DECL on success, or NULL_TREE if none found. */
854 lookup_java_constructor (clas
, method_signature
)
855 tree clas
, method_signature
;
857 tree method
= TYPE_METHODS (clas
);
858 for ( ; method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
860 tree method_sig
= build_java_signature (TREE_TYPE (method
));
861 if (DECL_CONSTRUCTOR_P (method
) && method_sig
== method_signature
)
867 /* Return a type which is the Binary Numeric Promotion of the pair T1,
868 T2 and convert EXP1 and/or EXP2. See 5.6.2 Binary Numeric
869 Promotion. It assumes that both T1 and T2 are eligible to BNP. */
872 binary_numeric_promotion (t1
, t2
, exp1
, exp2
)
878 if (t1
== double_type_node
|| t2
== double_type_node
)
880 if (t1
!= double_type_node
)
881 *exp1
= convert (double_type_node
, *exp1
);
882 if (t2
!= double_type_node
)
883 *exp2
= convert (double_type_node
, *exp2
);
884 return double_type_node
;
886 if (t1
== float_type_node
|| t2
== float_type_node
)
888 if (t1
!= float_type_node
)
889 *exp1
= convert (float_type_node
, *exp1
);
890 if (t2
!= float_type_node
)
891 *exp2
= convert (float_type_node
, *exp2
);
892 return float_type_node
;
894 if (t1
== long_type_node
|| t2
== long_type_node
)
896 if (t1
!= long_type_node
)
897 *exp1
= convert (long_type_node
, *exp1
);
898 if (t2
!= long_type_node
)
899 *exp2
= convert (long_type_node
, *exp2
);
900 return long_type_node
;
903 if (t1
!= int_type_node
)
904 *exp1
= convert (int_type_node
, *exp1
);
905 if (t2
!= int_type_node
)
906 *exp2
= convert (int_type_node
, *exp2
);
907 return int_type_node
;