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.
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
, int, 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 (int slot
, tree type
)
55 int max_locals
= DECL_MAX_LOCALS(current_function_decl
);
56 int nslots
= TYPE_IS_WIDE (type
) ? 2 : 1;
58 if (slot
< 0 || slot
+ nslots
- 1 >= max_locals
)
61 type_map
[slot
] = type
;
63 type_map
[++slot
] = void_type_node
;
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:
72 ((expr >= (float)MAX_INT)
74 : ((expr <= (float)MIN_INT)
81 convert_ieee_real_to_integer (tree type
, tree expr
)
84 expr
= save_expr (expr
);
86 result
= build (COND_EXPR
, type
,
87 build (NE_EXPR
, boolean_type_node
, expr
, expr
),
88 convert (type
, integer_zero_node
),
89 convert_to_integer (type
, expr
));
91 result
= build (COND_EXPR
, type
,
92 build (LE_EXPR
, boolean_type_node
, expr
,
93 convert (TREE_TYPE (expr
), TYPE_MIN_VALUE (type
))),
94 TYPE_MIN_VALUE (type
),
97 result
= build (COND_EXPR
, type
,
98 build (GE_EXPR
, boolean_type_node
, expr
,
99 convert (TREE_TYPE (expr
), 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
;
121 return build1 (NOP_EXPR
, type
, expr
);
123 if (type
== TREE_TYPE (expr
)
124 || TREE_CODE (expr
) == ERROR_MARK
)
126 if (TREE_CODE (TREE_TYPE (expr
)) == ERROR_MARK
)
127 return error_mark_node
;
128 if (code
== VOID_TYPE
)
129 return build1 (CONVERT_EXPR
, type
, expr
);
130 if (code
== BOOLEAN_TYPE
)
131 return fold (convert_to_boolean (type
, expr
));
132 if (code
== INTEGER_TYPE
)
134 if (! flag_unsafe_math_optimizations
135 && ! flag_emit_class_files
136 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
137 && TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
138 return fold (convert_ieee_real_to_integer (type
, expr
));
141 /* fold very helpfully sets the overflow status if a type
142 overflows in a narrowing integer conversion, but Java
144 tree tmp
= fold (convert_to_integer (type
, expr
));
145 TREE_OVERFLOW (tmp
) = 0;
149 if (code
== REAL_TYPE
)
150 return fold (convert_to_real (type
, expr
));
151 if (code
== CHAR_TYPE
)
152 return fold (convert_to_char (type
, expr
));
153 if (code
== POINTER_TYPE
)
154 return fold (convert_to_pointer (type
, expr
));
155 error ("conversion to non-scalar type requested");
156 return error_mark_node
;
161 convert_to_char (tree type
, tree expr
)
163 return build1 (NOP_EXPR
, type
, expr
);
167 convert_to_boolean (tree type
, tree expr
)
169 return build1 (NOP_EXPR
, type
, expr
);
172 /* Return a data type that has machine mode MODE.
173 If the mode is an integer,
174 then UNSIGNEDP selects between signed and unsigned types. */
177 java_type_for_mode (enum machine_mode mode
, int unsignedp
)
179 if (mode
== TYPE_MODE (int_type_node
))
180 return unsignedp
? unsigned_int_type_node
: int_type_node
;
181 if (mode
== TYPE_MODE (long_type_node
))
182 return unsignedp
? unsigned_long_type_node
: long_type_node
;
183 if (mode
== TYPE_MODE (short_type_node
))
184 return unsignedp
? unsigned_short_type_node
: short_type_node
;
185 if (mode
== TYPE_MODE (byte_type_node
))
186 return unsignedp
? unsigned_byte_type_node
: byte_type_node
;
187 if (mode
== TYPE_MODE (float_type_node
))
188 return float_type_node
;
189 if (mode
== TYPE_MODE (double_type_node
))
190 return double_type_node
;
195 /* Return an integer type with BITS bits of precision,
196 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
199 java_type_for_size (unsigned bits
, int unsignedp
)
201 if (bits
<= TYPE_PRECISION (byte_type_node
))
202 return unsignedp
? unsigned_byte_type_node
: byte_type_node
;
203 if (bits
<= TYPE_PRECISION (short_type_node
))
204 return unsignedp
? unsigned_short_type_node
: short_type_node
;
205 if (bits
<= TYPE_PRECISION (int_type_node
))
206 return unsignedp
? unsigned_int_type_node
: int_type_node
;
207 if (bits
<= TYPE_PRECISION (long_type_node
))
208 return unsignedp
? unsigned_long_type_node
: long_type_node
;
212 /* Return a type the same as TYPE except unsigned or
213 signed according to UNSIGNEDP. */
216 java_signed_or_unsigned_type (int unsignedp
, tree type
)
218 if (! INTEGRAL_TYPE_P (type
))
220 if (TYPE_PRECISION (type
) == TYPE_PRECISION (int_type_node
))
221 return unsignedp
? unsigned_int_type_node
: int_type_node
;
222 if (TYPE_PRECISION (type
) == TYPE_PRECISION (byte_type_node
))
223 return unsignedp
? unsigned_byte_type_node
: byte_type_node
;
224 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_type_node
))
225 return unsignedp
? unsigned_short_type_node
: short_type_node
;
226 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_type_node
))
227 return unsignedp
? unsigned_long_type_node
: long_type_node
;
231 /* Return a signed type the same as TYPE in other respects. */
234 java_signed_type (tree type
)
236 return java_signed_or_unsigned_type (0, type
);
239 /* Return an unsigned type the same as TYPE in other respects. */
242 java_unsigned_type (tree type
)
244 return java_signed_or_unsigned_type (1, type
);
247 /* Mark EXP saying that we need to be able to take the
248 address of it; it should not be allocated in a register.
249 Value is true if successful. */
252 java_mark_addressable (tree exp
)
256 switch (TREE_CODE (x
))
263 x
= TREE_OPERAND (x
, 0);
266 case TRUTH_ANDIF_EXPR
:
267 case TRUTH_ORIF_EXPR
:
269 x
= TREE_OPERAND (x
, 1);
273 return java_mark_addressable (TREE_OPERAND (x
, 1))
274 && java_mark_addressable (TREE_OPERAND (x
, 2));
277 TREE_ADDRESSABLE (x
) = 1;
281 /* We sometimes add a cast *(TYPE*)&FOO to handle type and mode
282 incompatibility problems. Handle this case by marking FOO. */
283 if (TREE_CODE (TREE_OPERAND (x
, 0)) == NOP_EXPR
284 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (x
, 0), 0)) == ADDR_EXPR
)
286 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
289 if (TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
291 x
= TREE_OPERAND (x
, 0);
301 TREE_ADDRESSABLE (x
) = 1;
302 #if 0 /* poplevel deals with this now. */
303 if (DECL_CONTEXT (x
) == 0)
304 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x
)) = 1;
312 /* Thorough checking of the arrayness of TYPE. */
315 is_array_type_p (tree type
)
317 return TREE_CODE (type
) == POINTER_TYPE
318 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
319 && TYPE_ARRAY_P (TREE_TYPE (type
));
322 /* Return the length of a Java array type.
323 Return -1 if the length is unknown or non-constant. */
326 java_array_type_length (tree array_type
)
329 if (TREE_CODE (array_type
) == POINTER_TYPE
)
330 array_type
= TREE_TYPE (array_type
);
331 arfld
= TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type
)));
332 if (arfld
!= NULL_TREE
)
334 tree index_type
= TYPE_DOMAIN (TREE_TYPE (arfld
));
335 if (index_type
!= NULL_TREE
)
337 tree high
= TYPE_MAX_VALUE (index_type
);
338 if (TREE_CODE (high
) == INTEGER_CST
)
339 return TREE_INT_CST_LOW (high
) + 1;
345 /* An array of unknown length will be ultimately given an length of
346 -2, so that we can still have `length' producing a negative value
347 even if found. This was part of an optimization aiming at removing
348 `length' from static arrays. We could restore it, FIXME. */
351 build_prim_array_type (tree element_type
, HOST_WIDE_INT length
)
357 tree max_index
= build_int_2 (length
- 1, (0 == length
? -1 : 0));
358 TREE_TYPE (max_index
) = sizetype
;
359 index
= build_index_type (max_index
);
361 return build_array_type (element_type
, index
);
364 /* Return a Java array type with a given ELEMENT_TYPE and LENGTH.
365 These are hashed (shared) using IDENTIFIER_SIGNATURE_TYPE.
366 The LENGTH is -1 if the length is unknown. */
369 build_java_array_type (tree element_type
, HOST_WIDE_INT length
)
371 tree sig
, t
, fld
, atype
, arfld
;
373 tree elsig
= build_java_signature (element_type
);
374 tree el_name
= element_type
;
377 sprintf (buf
+1, HOST_WIDE_INT_PRINT_DEC
, length
);
380 sig
= ident_subst (IDENTIFIER_POINTER (elsig
), IDENTIFIER_LENGTH (elsig
),
382 t
= IDENTIFIER_SIGNATURE_TYPE (sig
);
384 return TREE_TYPE (t
);
386 IDENTIFIER_SIGNATURE_TYPE (sig
) = build_pointer_type (t
);
387 TYPE_ARRAY_P (t
) = 1;
389 if (TREE_CODE (el_name
) == POINTER_TYPE
)
390 el_name
= TREE_TYPE (el_name
);
391 el_name
= TYPE_NAME (el_name
);
392 if (TREE_CODE (el_name
) == TYPE_DECL
)
393 el_name
= DECL_NAME (el_name
);
394 TYPE_NAME (t
) = build_decl (TYPE_DECL
,
395 identifier_subst (el_name
, "", '.', '.', "[]"),
398 set_java_signature (t
, sig
);
399 set_super_info (0, t
, object_type_node
, 0);
400 if (TREE_CODE (element_type
) == RECORD_TYPE
)
401 element_type
= promote_type (element_type
);
402 TYPE_ARRAY_ELEMENT (t
) = element_type
;
404 /* Add length pseudo-field. */
405 fld
= build_decl (FIELD_DECL
, get_identifier ("length"), int_type_node
);
406 TYPE_FIELDS (t
) = fld
;
407 DECL_CONTEXT (fld
) = t
;
408 FIELD_PUBLIC (fld
) = 1;
409 FIELD_FINAL (fld
) = 1;
410 TREE_READONLY (fld
) = 1;
412 atype
= build_prim_array_type (element_type
, length
);
413 arfld
= build_decl (FIELD_DECL
, get_identifier ("data"), atype
);
414 DECL_CONTEXT (arfld
) = t
;
415 TREE_CHAIN (fld
) = arfld
;
416 DECL_ALIGN (arfld
) = TYPE_ALIGN (element_type
);
418 /* We could layout_class, but that loads java.lang.Object prematurely.
419 * This is called by the parser, and it is a bad idea to do load_class
420 * in the middle of parsing, because of possible circularity problems. */
421 push_super_field (t
, object_type_node
);
427 /* Promote TYPE to the type actually used for fields and parameters. */
430 promote_type (tree type
)
432 switch (TREE_CODE (type
))
435 return build_pointer_type (type
);
437 if (type
== boolean_type_node
)
438 return promoted_boolean_type_node
;
441 if (type
== char_type_node
)
442 return promoted_char_type_node
;
446 if (TYPE_PRECISION (type
) < TYPE_PRECISION (int_type_node
))
448 if (type
== short_type_node
)
449 return promoted_short_type_node
;
450 if (type
== byte_type_node
)
451 return promoted_byte_type_node
;
452 return int_type_node
;
454 /* ... else fall through ... */
460 /* Parse a signature string, starting at *PTR and ending at LIMIT.
461 Return the seen TREE_TYPE, updating *PTR. */
464 parse_signature_type (const unsigned char **ptr
, const unsigned char *limit
)
473 case 'B': (*ptr
)++; return byte_type_node
;
474 case 'C': (*ptr
)++; return char_type_node
;
475 case 'D': (*ptr
)++; return double_type_node
;
476 case 'F': (*ptr
)++; return float_type_node
;
477 case 'S': (*ptr
)++; return short_type_node
;
478 case 'I': (*ptr
)++; return int_type_node
;
479 case 'J': (*ptr
)++; return long_type_node
;
480 case 'Z': (*ptr
)++; return boolean_type_node
;
481 case 'V': (*ptr
)++; return void_type_node
;
483 for ((*ptr
)++; (*ptr
) < limit
&& ISDIGIT (**ptr
); ) (*ptr
)++;
484 type
= parse_signature_type (ptr
, limit
);
485 type
= build_java_array_type (type
, -1);
489 const unsigned char *start
= ++(*ptr
);
490 const unsigned char *str
= start
;
499 type
= lookup_class (unmangle_classname (start
, str
- start
));
505 return promote_type (type
);
508 /* Parse a Java "mangled" signature string, starting at SIG_STRING,
509 and SIG_LENGTH bytes long.
510 Return a gcc type node. */
513 parse_signature_string (const unsigned char *sig_string
, int sig_length
)
516 const unsigned char *str
= sig_string
;
517 const unsigned char *limit
= str
+ sig_length
;
519 if (str
< limit
&& str
[0] == '(')
521 tree argtype_list
= NULL_TREE
;
523 while (str
< limit
&& str
[0] != ')')
525 tree argtype
= parse_signature_type (&str
, limit
);
526 argtype_list
= tree_cons (NULL_TREE
, argtype
, argtype_list
);
528 if (str
++, str
>= limit
)
530 result_type
= parse_signature_type (&str
, limit
);
531 argtype_list
= chainon (nreverse (argtype_list
), end_params_node
);
532 result_type
= build_function_type (result_type
, argtype_list
);
535 result_type
= parse_signature_type (&str
, limit
);
537 error ("junk at end of signature string");
541 /* Convert a signature to its type.
542 * Uses IDENTIFIER_SIGNATURE_TYPE as a cache (except for primitive types).
546 get_type_from_signature (tree signature
)
548 const unsigned char *sig
= (const unsigned char *) IDENTIFIER_POINTER (signature
);
549 int len
= IDENTIFIER_LENGTH (signature
);
551 /* Primitive types aren't cached. */
553 return parse_signature_string (sig
, len
);
554 type
= IDENTIFIER_SIGNATURE_TYPE (signature
);
555 if (type
== NULL_TREE
)
557 type
= parse_signature_string (sig
, len
);
558 IDENTIFIER_SIGNATURE_TYPE (signature
) = type
;
563 /* Ignore signature and always return null. Used by has_method. */
566 build_null_signature (tree type ATTRIBUTE_UNUSED
)
571 /* Return the signature string for the arguments of method type TYPE. */
574 build_java_argument_signature (tree type
)
576 extern struct obstack temporary_obstack
;
577 tree sig
= TYPE_ARGUMENT_SIGNATURE (type
);
578 if (sig
== NULL_TREE
)
580 tree args
= TYPE_ARG_TYPES (type
);
581 if (TREE_CODE (type
) == METHOD_TYPE
)
582 args
= TREE_CHAIN (args
); /* Skip "this" argument. */
583 for (; args
!= end_params_node
; args
= TREE_CHAIN (args
))
585 tree t
= build_java_signature (TREE_VALUE (args
));
586 obstack_grow (&temporary_obstack
,
587 IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
));
589 obstack_1grow (&temporary_obstack
, '\0');
591 sig
= get_identifier (obstack_base (&temporary_obstack
));
592 TYPE_ARGUMENT_SIGNATURE (type
) = sig
;
593 obstack_free (&temporary_obstack
, obstack_base (&temporary_obstack
));
598 /* Return the signature of the given TYPE. */
601 build_java_signature (tree type
)
604 while (TREE_CODE (type
) == POINTER_TYPE
)
605 type
= TREE_TYPE (type
);
606 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
607 sig
= TYPE_SIGNATURE (type
);
608 if (sig
== NULL_TREE
)
611 switch (TREE_CODE (type
))
613 case BOOLEAN_TYPE
: sg
[0] = 'Z'; goto native
;
614 case CHAR_TYPE
: sg
[0] = 'C'; goto native
;
615 case VOID_TYPE
: sg
[0] = 'V'; goto native
;
617 switch (TYPE_PRECISION (type
))
619 case 8: sg
[0] = 'B'; goto native
;
620 case 16: sg
[0] = 'S'; goto native
;
621 case 32: sg
[0] = 'I'; goto native
;
622 case 64: sg
[0] = 'J'; goto native
;
623 default: goto bad_type
;
626 switch (TYPE_PRECISION (type
))
628 case 32: sg
[0] = 'F'; goto native
;
629 case 64: sg
[0] = 'D'; goto native
;
630 default: goto bad_type
;
634 sig
= get_identifier (sg
);
637 if (TYPE_ARRAY_P (type
))
639 t
= build_java_signature (TYPE_ARRAY_ELEMENT (type
));
640 sig
= ident_subst (IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
),
645 t
= DECL_NAME (TYPE_NAME (type
));
646 sig
= ident_subst (IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
),
653 extern struct obstack temporary_obstack
;
654 sig
= build_java_argument_signature (type
);
655 obstack_1grow (&temporary_obstack
, '(');
656 obstack_grow (&temporary_obstack
,
657 IDENTIFIER_POINTER (sig
), IDENTIFIER_LENGTH (sig
));
658 obstack_1grow (&temporary_obstack
, ')');
660 t
= build_java_signature (TREE_TYPE (type
));
661 obstack_grow0 (&temporary_obstack
,
662 IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
));
664 sig
= get_identifier (obstack_base (&temporary_obstack
));
665 obstack_free (&temporary_obstack
,
666 obstack_base (&temporary_obstack
));
673 TYPE_SIGNATURE (type
) = sig
;
678 /* Save signature string SIG (an IDENTIFIER_NODE) in TYPE for future use. */
681 set_java_signature (tree type
, tree sig
)
684 while (TREE_CODE (type
) == POINTER_TYPE
)
685 type
= TREE_TYPE (type
);
686 MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type
);
687 old_sig
= TYPE_SIGNATURE (type
);
688 if (old_sig
!= NULL_TREE
&& old_sig
!= sig
)
690 TYPE_SIGNATURE (type
) = sig
;
691 #if 0 /* careful about METHOD_TYPE */
692 if (IDENTIFIER_SIGNATURE_TYPE (sig
) == NULL_TREE
&& TREE_PERMANENT (type
))
693 IDENTIFIER_SIGNATURE_TYPE (sig
) = type
;
697 /* Search in SEARCHED_CLASS and its superclasses for a method matching
698 METHOD_NAME and signature METHOD_SIGNATURE. This function will
699 only search for methods declared in the class hierarchy; interfaces
700 will not be considered. Returns NULL_TREE if the method is not
703 lookup_argument_method (tree searched_class
, tree method_name
,
704 tree method_signature
)
706 return lookup_do (searched_class
, 0,
707 method_name
, method_signature
,
708 build_java_argument_signature
);
711 /* Like lookup_argument_method, but lets the caller set any flags
714 lookup_argument_method_generic (tree searched_class
, tree method_name
,
715 tree method_signature
, int flags
)
717 return lookup_do (searched_class
, flags
,
718 method_name
, method_signature
,
719 build_java_argument_signature
);
723 /* Search in class SEARCHED_CLASS (and its superclasses) for a method
724 matching METHOD_NAME and signature METHOD_SIGNATURE. Return a
725 FUNCTION_DECL on success, or NULL_TREE if none found. (Contrast
726 lookup_argument_method, which ignores return type.) If
727 SEARCHED_CLASS is an interface, search it too. */
729 lookup_java_method (tree searched_class
, tree method_name
,
730 tree method_signature
)
732 return lookup_do (searched_class
, SEARCH_INTERFACE
, method_name
,
733 method_signature
, build_java_signature
);
736 /* Return true iff CLASS (or its ancestors) has a method METHOD_NAME. */
738 has_method (tree
class, tree method_name
)
740 return lookup_do (class, SEARCH_INTERFACE
,
741 method_name
, NULL_TREE
,
742 build_null_signature
) != NULL_TREE
;
745 /* Search in class SEARCHED_CLASS, but not its superclasses, for a
746 method matching METHOD_NAME and signature SIGNATURE. A private
747 helper for lookup_do. */
749 shallow_find_method (tree searched_class
, int flags
, tree method_name
,
750 tree signature
, tree (*signature_builder
) (tree
))
753 for (method
= TYPE_METHODS (searched_class
);
754 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
756 tree method_sig
= (*signature_builder
) (TREE_TYPE (method
));
757 if (DECL_NAME (method
) == method_name
&& method_sig
== signature
)
759 /* If the caller requires a visible method, then we
760 skip invisible methods here. */
761 if (! (flags
& SEARCH_VISIBLE
)
762 || ! METHOD_INVISIBLE (method
))
769 /* Search in the superclasses of SEARCHED_CLASS for a method matching
770 METHOD_NAME and signature SIGNATURE. A private helper for
773 find_method_in_superclasses (tree searched_class
, int flags
,
775 tree signature
, tree (*signature_builder
) (tree
))
778 for (klass
= CLASSTYPE_SUPER (searched_class
); klass
!= NULL_TREE
;
779 klass
= CLASSTYPE_SUPER (klass
))
782 method
= shallow_find_method (klass
, flags
, method_name
,
783 signature
, signature_builder
);
784 if (method
!= NULL_TREE
)
791 /* Search in the interfaces of SEARCHED_CLASS and its superinterfaces
792 for a method matching METHOD_NAME and signature SIGNATURE. A
793 private helper for lookup_do. */
795 find_method_in_interfaces (tree searched_class
, int flags
, tree method_name
,
796 tree signature
, tree (*signature_builder
) (tree
))
800 TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (searched_class
)) - 1;
802 for (i
= interface_len
; i
> 0; i
--)
805 TREE_VEC_ELT (TYPE_BINFO_BASETYPES (searched_class
), i
);
806 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 /* First, we look in ICLASS. If that doesn't work we'll
816 recursively look through all its superinterfaces. */
817 method
= shallow_find_method (iclass
, flags
, method_name
,
818 signature
, signature_builder
);
819 if (method
!= NULL_TREE
)
822 method
= find_method_in_interfaces
823 (iclass
, flags
, method_name
, signature
, signature_builder
);
824 if (method
!= NULL_TREE
)
832 /* Search in class SEARCHED_CLASS (and its superclasses) for a method
833 matching METHOD_NAME and signature SIGNATURE. FLAGS control some
834 parameters of the search.
836 SEARCH_INTERFACE means also search interfaces and superinterfaces
839 SEARCH_SUPER means skip SEARCHED_CLASS and start with its
842 SEARCH_VISIBLE means skip methods for which METHOD_INVISIBLE is
845 Return the matched method DECL or NULL_TREE. SIGNATURE_BUILDER is
846 used on method candidates to build their (sometimes partial)
849 lookup_do (tree searched_class
, int flags
, tree method_name
,
850 tree signature
, tree (*signature_builder
) (tree
))
854 if (searched_class
== NULL_TREE
)
857 if (flags
& SEARCH_SUPER
)
859 searched_class
= CLASSTYPE_SUPER (searched_class
);
860 if (searched_class
== NULL_TREE
)
864 /* First look in our own methods. */
865 method
= shallow_find_method (searched_class
, flags
, method_name
,
866 signature
, signature_builder
);
870 /* Then look in our superclasses. */
871 if (! CLASS_INTERFACE (TYPE_NAME (searched_class
)))
872 method
= find_method_in_superclasses (searched_class
, flags
, method_name
,
873 signature
, signature_builder
);
877 /* If that doesn't work, look in our interfaces. */
878 if (flags
& SEARCH_INTERFACE
)
879 method
= find_method_in_interfaces (searched_class
, flags
, method_name
,
880 signature
, signature_builder
);
885 /* Search in class CLAS for a constructor matching METHOD_SIGNATURE.
886 Return a FUNCTION_DECL on success, or NULL_TREE if none found. */
889 lookup_java_constructor (tree clas
, tree method_signature
)
891 tree method
= TYPE_METHODS (clas
);
892 for ( ; method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
894 tree method_sig
= build_java_signature (TREE_TYPE (method
));
895 if (DECL_CONSTRUCTOR_P (method
) && method_sig
== method_signature
)
901 /* Return a type which is the Binary Numeric Promotion of the pair T1,
902 T2 and convert EXP1 and/or EXP2. See 5.6.2 Binary Numeric
903 Promotion. It assumes that both T1 and T2 are eligible to BNP. */
906 binary_numeric_promotion (tree t1
, tree t2
, tree
*exp1
, tree
*exp2
)
908 if (t1
== double_type_node
|| t2
== double_type_node
)
910 if (t1
!= double_type_node
)
911 *exp1
= convert (double_type_node
, *exp1
);
912 if (t2
!= double_type_node
)
913 *exp2
= convert (double_type_node
, *exp2
);
914 return double_type_node
;
916 if (t1
== float_type_node
|| t2
== float_type_node
)
918 if (t1
!= float_type_node
)
919 *exp1
= convert (float_type_node
, *exp1
);
920 if (t2
!= float_type_node
)
921 *exp2
= convert (float_type_node
, *exp2
);
922 return float_type_node
;
924 if (t1
== long_type_node
|| t2
== long_type_node
)
926 if (t1
!= long_type_node
)
927 *exp1
= convert (long_type_node
, *exp1
);
928 if (t2
!= long_type_node
)
929 *exp2
= convert (long_type_node
, *exp2
);
930 return long_type_node
;
933 if (t1
!= int_type_node
)
934 *exp1
= convert (int_type_node
, *exp1
);
935 if (t2
!= int_type_node
)
936 *exp2
= convert (int_type_node
, *exp2
);
937 return int_type_node
;