1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987, 1988, 1992, 1993, 1995 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC 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 GNU CC 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 GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* This file contains the functions for converting C expressions
23 to different data types. The only entry point is `convert'.
24 Every language front end must have a `convert' function
25 but what kind of conversions it does will depend on the language. */
35 #define NULL (char *)0
37 /* Change of width--truncation and extension of integers or reals--
38 is represented with NOP_EXPR. Proper functioning of many things
39 assumes that no other conversions can be NOP_EXPRs.
41 Conversion between integer and pointer is represented with CONVERT_EXPR.
42 Converting integer to real uses FLOAT_EXPR
43 and real to integer uses FIX_TRUNC_EXPR.
45 Here is a list of all the functions that assume that widening and
46 narrowing is always done with a NOP_EXPR:
47 In convert.c, convert_to_integer.
48 In c-typeck.c, build_binary_op_nodefault (boolean ops),
49 and truthvalue_conversion.
50 In expr.c: expand_expr, for operands of a MULT_EXPR.
51 In fold-const.c: fold.
52 In tree.c: get_narrower and get_unwidened.
54 C++: in multiple-inheritance, converting between pointers may involve
55 adjusting them by a delta stored within the class definition. */
57 /* Subroutines of `convert'. */
59 /* Build a thunk. What it is, is an entry point that when called will
60 adjust the this pointer (the first argument) by offset, and then
61 goto the real address of the function given by REAL_ADDR that we
62 would like called. What we return is the address of the thunk. */
64 build_thunk (offset
, real_addr
)
65 tree offset
, real_addr
;
67 if (TREE_CODE (real_addr
) != ADDR_EXPR
68 || TREE_CODE (TREE_OPERAND (real_addr
, 0)) != FUNCTION_DECL
)
70 sorry ("MI pointer to member conversion too complex");
71 return error_mark_node
;
73 sorry ("MI pointer to member conversion too complex");
74 return error_mark_node
;
77 /* Convert a `pointer to member' (POINTER_TYPE to METHOD_TYPE) into
78 another `pointer to method'. This may involved the creation of
79 a thunk to handle the this offset calculation. */
81 convert_fn_ptr (type
, expr
)
84 if (flag_vtable_thunks
)
86 tree intype
= TREE_TYPE (expr
);
87 tree binfo
= get_binfo (TYPE_METHOD_BASETYPE (TREE_TYPE (intype
)),
88 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)), 1);
89 if (binfo
== error_mark_node
)
91 error (" in pointer to member conversion");
92 return error_mark_node
;
94 if (binfo
== NULL_TREE
)
96 /* ARM 4.8 restriction. */
97 error ("invalid pointer to member conversion");
98 return error_mark_node
;
101 if (BINFO_OFFSET_ZEROP (binfo
))
102 return build1 (NOP_EXPR
, type
, expr
);
103 return build1 (NOP_EXPR
, type
, build_thunk (BINFO_OFFSET (binfo
), expr
));
106 return build_ptrmemfunc (type
, expr
, 1);
109 /* if converting pointer to pointer
110 if dealing with classes, check for derived->base or vice versa
111 else if dealing with method pointers, delegate
113 else if converting class, pass off to build_type_conversion
114 else try C-style pointer conversion */
116 cp_convert_to_pointer (type
, expr
)
119 register tree intype
= TREE_TYPE (expr
);
120 register enum tree_code form
;
122 if (TYPE_PTRMEMFUNC_P (type
))
123 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
124 if (TYPE_PTRMEMFUNC_P (intype
))
125 intype
= TYPE_PTRMEMFUNC_FN_TYPE (intype
);
127 form
= TREE_CODE (intype
);
129 if (form
== POINTER_TYPE
|| form
== REFERENCE_TYPE
)
131 intype
= TYPE_MAIN_VARIANT (intype
);
133 if (TYPE_MAIN_VARIANT (type
) != intype
134 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
135 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
137 enum tree_code code
= PLUS_EXPR
;
138 tree binfo
= get_binfo (TREE_TYPE (type
), TREE_TYPE (intype
), 1);
139 if (binfo
== error_mark_node
)
140 return error_mark_node
;
141 if (binfo
== NULL_TREE
)
143 binfo
= get_binfo (TREE_TYPE (intype
), TREE_TYPE (type
), 1);
144 if (binfo
== error_mark_node
)
145 return error_mark_node
;
150 if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type
))
151 || TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype
))
152 || ! BINFO_OFFSET_ZEROP (binfo
))
154 /* Need to get the path we took. */
157 if (code
== PLUS_EXPR
)
158 get_base_distance (TREE_TYPE (type
), TREE_TYPE (intype
), 0, &path
);
160 get_base_distance (TREE_TYPE (intype
), TREE_TYPE (type
), 0, &path
);
161 return build_vbase_path (code
, type
, expr
, path
, 0);
165 if (TREE_CODE (TREE_TYPE (intype
)) == METHOD_TYPE
166 && TREE_CODE (type
) == POINTER_TYPE
167 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)
168 return convert_fn_ptr (type
, expr
);
170 if (TREE_CODE (TREE_TYPE (type
)) == OFFSET_TYPE
171 && TREE_CODE (TREE_TYPE (intype
)) == OFFSET_TYPE
)
173 tree b1
= TYPE_OFFSET_BASETYPE (TREE_TYPE (type
));
174 tree b2
= TYPE_OFFSET_BASETYPE (TREE_TYPE (intype
));
175 tree binfo
= get_binfo (b1
, b2
, 1);
176 if (binfo
== NULL_TREE
)
177 binfo
= get_binfo (b2
, b1
, 1);
178 if (binfo
== error_mark_node
)
179 return error_mark_node
;
182 return build1 (NOP_EXPR
, type
, expr
);
185 my_friendly_assert (form
!= OFFSET_TYPE
, 186);
187 if (TYPE_LANG_SPECIFIC (intype
)
188 && (IS_SIGNATURE_POINTER (intype
) || IS_SIGNATURE_REFERENCE (intype
)))
189 return convert_to_pointer (type
, build_optr_ref (expr
));
191 if (IS_AGGR_TYPE (intype
))
194 rval
= build_type_conversion (CONVERT_EXPR
, type
, expr
, 1);
197 if (rval
== error_mark_node
)
198 cp_error ("conversion of `%E' from `%T' to `%T' is ambiguous",
204 if (integer_zerop (expr
))
206 if (type
== TREE_TYPE (null_pointer_node
))
207 return null_pointer_node
;
208 expr
= build_int_2 (0, 0);
209 TREE_TYPE (expr
) = type
;
213 if (INTEGRAL_CODE_P (form
))
215 if (type_precision (intype
) == POINTER_SIZE
)
216 return build1 (CONVERT_EXPR
, type
, expr
);
217 expr
= convert (type_for_size (POINTER_SIZE
, 0), expr
);
218 /* Modes may be different but sizes should be the same. */
219 if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr
)))
220 != GET_MODE_SIZE (TYPE_MODE (type
)))
221 /* There is supposed to be some integral type
222 that is the same width as a pointer. */
224 return convert_to_pointer (type
, expr
);
227 cp_error ("cannot convert `%E' from type `%T' to type `%T'",
229 return error_mark_node
;
232 /* Like convert, except permit conversions to take place which
233 are not normally allowed due to access restrictions
234 (such as conversion from sub-type to private super-type). */
236 convert_to_pointer_force (type
, expr
)
239 register tree intype
= TREE_TYPE (expr
);
240 register enum tree_code form
= TREE_CODE (intype
);
242 if (integer_zerop (expr
))
244 if (type
== TREE_TYPE (null_pointer_node
))
245 return null_pointer_node
;
246 expr
= build_int_2 (0, 0);
247 TREE_TYPE (expr
) = type
;
251 /* Convert signature pointer/reference to `void *' first. */
252 if (form
== RECORD_TYPE
253 && (IS_SIGNATURE_POINTER (intype
) || IS_SIGNATURE_REFERENCE (intype
)))
255 expr
= build_optr_ref (expr
);
256 intype
= TREE_TYPE (expr
);
257 form
= TREE_CODE (intype
);
260 if (form
== POINTER_TYPE
)
262 intype
= TYPE_MAIN_VARIANT (intype
);
264 if (TYPE_MAIN_VARIANT (type
) != intype
265 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
266 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
268 enum tree_code code
= PLUS_EXPR
;
270 int distance
= get_base_distance (TREE_TYPE (type
),
271 TREE_TYPE (intype
), 0, &path
);
275 cp_error ("type `%T' is ambiguous baseclass of `%s'", TREE_TYPE (type
),
276 TYPE_NAME_STRING (TREE_TYPE (intype
)));
277 return error_mark_node
;
281 distance
= get_base_distance (TREE_TYPE (intype
),
282 TREE_TYPE (type
), 0, &path
);
286 /* Doesn't need any special help from us. */
287 return build1 (NOP_EXPR
, type
, expr
);
291 return build_vbase_path (code
, type
, expr
, path
, 0);
293 return build1 (NOP_EXPR
, type
, expr
);
296 return cp_convert_to_pointer (type
, expr
);
299 /* We are passing something to a function which requires a reference.
300 The type we are interested in is in TYPE. The initial
301 value we have to begin with is in ARG.
303 FLAGS controls how we manage access checking.
304 CHECKCONST controls if we report error messages on const subversion. */
306 build_up_reference (type
, arg
, flags
, checkconst
)
308 int flags
, checkconst
;
311 int literal_flag
= 0;
312 tree argtype
= TREE_TYPE (arg
);
313 tree target_type
= TREE_TYPE (type
);
314 tree binfo
= NULL_TREE
;
316 my_friendly_assert (TREE_CODE (type
) == REFERENCE_TYPE
, 187);
317 if ((flags
& LOOKUP_PROTECT
)
318 && TYPE_MAIN_VARIANT (argtype
) != TYPE_MAIN_VARIANT (target_type
)
319 && IS_AGGR_TYPE (argtype
)
320 && IS_AGGR_TYPE (target_type
))
322 binfo
= get_binfo (target_type
, argtype
, 1);
323 if (binfo
== error_mark_node
)
324 return error_mark_node
;
325 if (binfo
== NULL_TREE
)
326 return error_not_base_type (target_type
, argtype
);
329 /* Pass along const and volatile down into the type. */
330 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
))
331 target_type
= cp_build_type_variant (target_type
, TYPE_READONLY (type
),
332 TYPE_VOLATILE (type
));
334 if (TREE_CODE (targ
) == SAVE_EXPR
)
335 targ
= TREE_OPERAND (targ
, 0);
336 while (TREE_CODE (targ
) == NOP_EXPR
337 && (TYPE_MAIN_VARIANT (argtype
)
338 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (targ
, 0)))))
339 targ
= TREE_OPERAND (targ
, 0);
341 switch (TREE_CODE (targ
))
344 /* This is a call to a constructor which did not know what it was
345 initializing until now: it needs to initialize a temporary. */
346 if (TREE_HAS_CONSTRUCTOR (targ
))
348 tree temp
= build_cplus_new (argtype
, TREE_OPERAND (targ
, 0), 1);
349 TREE_HAS_CONSTRUCTOR (targ
) = 0;
350 return build_up_reference (type
, temp
, flags
, 1);
352 /* Let &* cancel out to simplify resulting code.
353 Also, throw away intervening NOP_EXPRs. */
354 arg
= TREE_OPERAND (targ
, 0);
355 if (TREE_CODE (arg
) == NOP_EXPR
|| TREE_CODE (arg
) == NON_LVALUE_EXPR
356 || (TREE_CODE (arg
) == CONVERT_EXPR
&& TREE_REFERENCE_EXPR (arg
)))
357 arg
= TREE_OPERAND (arg
, 0);
359 /* in doing a &*, we have to get rid of the const'ness on the pointer
360 value. Haven't thought about volatile here. Pointers come to mind
362 if (TREE_READONLY (arg
))
364 arg
= copy_node (arg
);
365 TREE_READONLY (arg
) = 0;
368 rval
= build1 (CONVERT_EXPR
, type
, arg
);
369 TREE_REFERENCE_EXPR (rval
) = 1;
371 /* propagate the const flag on something like:
378 class Derived : public Base {
385 void func2(const Derived& d) {
389 on the d parameter. The below could have been avoided, if the flags
390 were down in the tree, not sure why they are not. (mrs) */
391 /* The below code may have to be propagated to other parts of this
393 if (TREE_READONLY (targ
) && !TREE_READONLY (arg
)
394 && (TREE_CODE (arg
) == PARM_DECL
|| TREE_CODE (arg
) == VAR_DECL
)
395 && TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
396 && (TYPE_READONLY (target_type
) && checkconst
))
398 arg
= copy_node (arg
);
399 TREE_READONLY (arg
) = TREE_READONLY (targ
);
401 literal_flag
= TREE_CONSTANT (arg
);
405 /* Get this out of a register if we happened to be in one by accident.
406 Also, build up references to non-lvalues it we must. */
407 /* For &x[y], return (&) x+y */
409 if (mark_addressable (TREE_OPERAND (targ
, 0)) == 0)
410 return error_mark_node
;
411 rval
= build_binary_op (PLUS_EXPR
, TREE_OPERAND (targ
, 0),
412 TREE_OPERAND (targ
, 1), 1);
413 TREE_TYPE (rval
) = type
;
414 if (TREE_CONSTANT (TREE_OPERAND (targ
, 1))
415 && staticp (TREE_OPERAND (targ
, 0)))
416 TREE_CONSTANT (rval
) = 1;
420 /* Could be a reference to a static member. */
422 tree field
= TREE_OPERAND (targ
, 1);
423 if (TREE_STATIC (field
))
425 rval
= build1 (ADDR_EXPR
, type
, field
);
431 /* We should have farmed out member pointers above. */
432 my_friendly_abort (188);
435 rval
= build_component_addr (targ
, build_pointer_type (argtype
),
436 "attempt to make a reference to bit-field structure member `%s'");
437 TREE_TYPE (rval
) = type
;
438 literal_flag
= staticp (TREE_OPERAND (targ
, 0));
442 /* Anything not already handled and not a true memory reference
443 needs to have a reference built up. Do so silently for
444 things like integers and return values from function,
445 but complain if we need a reference to something declared
451 TREE_ADDRESSABLE (targ
) = 1;
452 put_var_into_stack (targ
);
457 if (targ
== current_class_decl
)
459 error ("address of `this' not available");
461 /* This code makes the following core dump the compiler on a sun4,
462 if the code below is used.
466 typedef a_decl* a_ref;
471 void* append(a_ref& item);
475 a_decl (e_decl *parent);
489 a_decl::a_decl(e_decl *parent) {
490 parent->implementations.append(this);
494 TREE_ADDRESSABLE (targ
) = 1; /* so compiler doesn't die later */
495 put_var_into_stack (targ
);
498 return error_mark_node
;
505 if (DECL_REGISTER (targ
) && !TREE_ADDRESSABLE (targ
)
506 && !DECL_ARTIFICIAL (targ
))
507 cp_warning ("address needed to build reference for `%D', which is declared `register'",
509 else if (staticp (targ
))
512 TREE_ADDRESSABLE (targ
) = 1;
513 put_var_into_stack (targ
);
518 tree real_reference
= build_up_reference (type
, TREE_OPERAND (targ
, 1),
519 LOOKUP_PROTECT
, checkconst
);
520 rval
= build (COMPOUND_EXPR
, type
, TREE_OPERAND (targ
, 0), real_reference
);
521 TREE_CONSTANT (rval
) = staticp (TREE_OPERAND (targ
, 1));
525 case PREINCREMENT_EXPR
:
526 case PREDECREMENT_EXPR
:
530 tree real_reference
= build_up_reference (type
, TREE_OPERAND (targ
, 0),
531 LOOKUP_PROTECT
, checkconst
);
532 rval
= build (COMPOUND_EXPR
, type
, arg
, real_reference
);
533 TREE_CONSTANT (rval
) = staticp (TREE_OPERAND (targ
, 0));
538 return build (COND_EXPR
, type
,
539 TREE_OPERAND (targ
, 0),
540 build_up_reference (type
, TREE_OPERAND (targ
, 1),
541 LOOKUP_PROTECT
, checkconst
),
542 build_up_reference (type
, TREE_OPERAND (targ
, 2),
543 LOOKUP_PROTECT
, checkconst
));
545 /* Undo the folding... */
548 return build (COND_EXPR
, type
,
549 build (TREE_CODE (targ
) == MIN_EXPR
? LT_EXPR
: GT_EXPR
,
550 boolean_type_node
, TREE_OPERAND (targ
, 0),
551 TREE_OPERAND (targ
, 1)),
552 build_up_reference (type
, TREE_OPERAND (targ
, 0),
553 LOOKUP_PROTECT
, checkconst
),
554 build_up_reference (type
, TREE_OPERAND (targ
, 1),
555 LOOKUP_PROTECT
, checkconst
));
557 case WITH_CLEANUP_EXPR
:
558 return build (WITH_CLEANUP_EXPR
, type
,
559 build_up_reference (type
, TREE_OPERAND (targ
, 0),
560 LOOKUP_PROTECT
, checkconst
),
561 0, TREE_OPERAND (targ
, 2));
564 arg
= TREE_OPERAND (targ
, 1);
565 if (arg
== NULL_TREE
)
567 compiler_error ("({ ... }) expression not expanded when needed for reference");
568 return error_mark_node
;
570 rval
= build1 (ADDR_EXPR
, type
, arg
);
571 TREE_REFERENCE_EXPR (rval
) = 1;
578 if (TREE_ADDRESSABLE (targ
) == 0)
582 if (TREE_CODE (targ
) == CALL_EXPR
&& IS_AGGR_TYPE (argtype
))
584 temp
= build_cplus_new (argtype
, targ
, 1);
585 if (TREE_CODE (temp
) == WITH_CLEANUP_EXPR
)
586 rval
= build (WITH_CLEANUP_EXPR
, type
,
587 build1 (ADDR_EXPR
, type
, TREE_OPERAND (temp
, 0)),
588 0, TREE_OPERAND (temp
, 2));
590 rval
= build1 (ADDR_EXPR
, type
, temp
);
595 temp
= get_temp_name (argtype
, 0);
596 if (toplevel_bindings_p ())
598 /* Give this new temp some rtl and initialize it. */
599 DECL_INITIAL (temp
) = targ
;
600 TREE_STATIC (temp
) = 1;
601 cp_finish_decl (temp
, targ
, NULL_TREE
, 0, LOOKUP_ONLYCONVERTING
);
602 /* Do this after declaring it static. */
603 rval
= build_unary_op (ADDR_EXPR
, temp
, 0);
604 TREE_TYPE (rval
) = type
;
605 literal_flag
= TREE_CONSTANT (rval
);
610 rval
= build_unary_op (ADDR_EXPR
, temp
, 0);
611 if (binfo
&& !BINFO_OFFSET_ZEROP (binfo
))
612 rval
= convert_pointer_to (target_type
, rval
);
614 TREE_TYPE (rval
) = type
;
616 temp
= build (MODIFY_EXPR
, argtype
, temp
, arg
);
617 TREE_SIDE_EFFECTS (temp
) = 1;
618 return build (COMPOUND_EXPR
, type
, temp
, rval
);
623 rval
= build1 (ADDR_EXPR
, type
, arg
);
626 if (TYPE_USES_COMPLEX_INHERITANCE (argtype
)
627 || TYPE_USES_COMPLEX_INHERITANCE (target_type
))
629 TREE_TYPE (rval
) = build_pointer_type (argtype
);
630 if (flags
& LOOKUP_PROTECT
)
631 rval
= convert_pointer_to (target_type
, rval
);
634 = convert_to_pointer_force (build_pointer_type (target_type
), rval
);
635 TREE_TYPE (rval
) = type
;
636 if (TREE_CODE (rval
) == PLUS_EXPR
|| TREE_CODE (rval
) == MINUS_EXPR
)
637 TREE_TYPE (TREE_OPERAND (rval
, 0))
638 = TREE_TYPE (TREE_OPERAND (rval
, 1)) = type
;
640 TREE_CONSTANT (rval
) = literal_flag
;
644 /* For C++: Only need to do one-level references, but cannot
645 get tripped up on signed/unsigned differences.
647 DECL is either NULL_TREE or the _DECL node for a reference that is being
648 initialized. It can be error_mark_node if we don't know the _DECL but
649 we know it's an initialization. */
652 convert_to_reference (reftype
, expr
, convtype
, flags
, decl
)
657 register tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (reftype
));
658 register tree intype
= TREE_TYPE (expr
);
659 tree rval
= NULL_TREE
;
660 tree rval_as_conversion
= NULL_TREE
;
663 if (TREE_CODE (intype
) == REFERENCE_TYPE
)
664 my_friendly_abort (364);
666 intype
= TYPE_MAIN_VARIANT (intype
);
668 i
= comp_target_types (type
, intype
, 0);
670 if (i
<= 0 && (convtype
& CONV_IMPLICIT
) && IS_AGGR_TYPE (intype
)
671 && ! (flags
& LOOKUP_NO_CONVERSION
))
673 /* Look for a user-defined conversion to lvalue that we can use. */
675 rval_as_conversion
= build_type_conversion (CONVERT_EXPR
, type
, expr
, 1);
677 if (rval_as_conversion
&& rval_as_conversion
!= error_mark_node
678 && real_lvalue_p (rval_as_conversion
))
680 expr
= rval_as_conversion
;
681 rval_as_conversion
= NULL_TREE
;
687 if (((convtype
& CONV_STATIC
) && i
== -1)
688 || ((convtype
& CONV_IMPLICIT
) && i
== 1))
690 if (flags
& LOOKUP_COMPLAIN
)
692 tree ttl
= TREE_TYPE (reftype
);
696 int r
= TREE_READONLY (expr
);
697 int v
= TREE_THIS_VOLATILE (expr
);
698 ttr
= cp_build_type_variant (TREE_TYPE (expr
), r
, v
);
701 if (! real_lvalue_p (expr
) &&
702 (decl
== NULL_TREE
|| ! TYPE_READONLY (ttl
)))
705 /* Ensure semantics of [dcl.init.ref] */
706 cp_pedwarn ("initialization of non-const `%T' from rvalue `%T'",
709 cp_pedwarn ("conversion to `%T' from rvalue `%T'",
712 else if (! (convtype
& CONV_CONST
))
714 if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
715 cp_pedwarn ("conversion from `%T' to `%T' discards const",
717 else if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
718 cp_pedwarn ("conversion from `%T' to `%T' discards volatile",
723 return build_up_reference (reftype
, expr
, flags
,
724 ! (convtype
& CONV_CONST
));
726 else if ((convtype
& CONV_REINTERPRET
) && lvalue_p (expr
))
728 /* When casting an lvalue to a reference type, just convert into
729 a pointer to the new type and deference it. This is allowed
730 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
731 should be done directly (jason). (int &)ri ---> *(int*)&ri */
733 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
735 if (TREE_CODE (intype
) == POINTER_TYPE
736 && (comptypes (TREE_TYPE (intype
), type
, -1)))
737 cp_warning ("casting `%T' to `%T' does not dereference pointer",
740 rval
= build_unary_op (ADDR_EXPR
, expr
, 0);
741 if (rval
!= error_mark_node
)
742 rval
= convert_force (build_pointer_type (TREE_TYPE (reftype
)), rval
, 0);
743 if (rval
!= error_mark_node
)
744 rval
= build1 (NOP_EXPR
, reftype
, rval
);
748 tree rval_as_ctor
= NULL_TREE
;
750 if (rval_as_conversion
)
752 if (rval_as_conversion
== error_mark_node
)
754 cp_error ("conversion from `%T' to `%T' is ambiguous",
756 return error_mark_node
;
758 rval_as_conversion
= build_up_reference (reftype
, rval_as_conversion
,
762 /* Definitely need to go through a constructor here. */
763 if (TYPE_HAS_CONSTRUCTOR (type
)
764 && ! CLASSTYPE_ABSTRACT_VIRTUALS (type
)
765 && (rval
= build_method_call
766 (NULL_TREE
, constructor_name_full (type
),
767 build_tree_list (NULL_TREE
, expr
), TYPE_BINFO (type
),
768 LOOKUP_NO_CONVERSION
|LOOKUP_SPECULATIVELY
769 | LOOKUP_ONLYCONVERTING
)))
773 if (toplevel_bindings_p ())
775 extern tree static_aggregates
;
776 tree t
= get_temp_name (type
, toplevel_bindings_p ());
777 init
= build_method_call (t
, constructor_name_full (type
),
778 build_tree_list (NULL_TREE
, expr
),
780 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
781 | LOOKUP_ONLYCONVERTING
);
783 if (init
== error_mark_node
)
784 return error_mark_node
;
786 make_decl_rtl (t
, NULL_PTR
, 1);
787 static_aggregates
= perm_tree_cons (expr
, t
, static_aggregates
);
788 rval
= build_unary_op (ADDR_EXPR
, t
, 0);
792 init
= build_method_call (NULL_TREE
, constructor_name_full (type
),
793 build_tree_list (NULL_TREE
, expr
),
795 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
796 |LOOKUP_ONLYCONVERTING
);
798 if (init
== error_mark_node
)
799 return error_mark_node
;
801 rval
= build_cplus_new (type
, init
, 1);
802 rval
= build_up_reference (reftype
, rval
, flags
, 1);
807 if (rval_as_ctor
&& rval_as_conversion
)
809 cp_error ("ambiguous conversion from `%T' to `%T'; both user-defined conversion and constructor apply",
811 return error_mark_node
;
813 else if (rval_as_ctor
)
815 else if (rval_as_conversion
)
816 rval
= rval_as_conversion
;
817 else if (! IS_AGGR_TYPE (type
) && ! IS_AGGR_TYPE (intype
))
819 rval
= convert (type
, expr
);
820 if (rval
== error_mark_node
)
821 return error_mark_node
;
823 rval
= build_up_reference (reftype
, rval
, flags
, 1);
826 if (rval
&& ! TYPE_READONLY (TREE_TYPE (reftype
)))
827 cp_pedwarn ("initializing non-const `%T' with `%T' will use a temporary",
833 /* If we found a way to convert earlier, then use it. */
837 my_friendly_assert (TREE_CODE (intype
) != OFFSET_TYPE
, 189);
839 if (flags
& LOOKUP_COMPLAIN
)
840 cp_error ("cannot convert type `%T' to type `%T'", intype
, reftype
);
842 if (flags
& LOOKUP_SPECULATIVELY
)
845 return error_mark_node
;
848 /* We are using a reference VAL for its value. Bash that reference all the
849 way down to its lowest form. */
851 convert_from_reference (val
)
854 tree type
= TREE_TYPE (val
);
856 if (TREE_CODE (type
) == OFFSET_TYPE
)
857 type
= TREE_TYPE (type
);
858 if (TREE_CODE (type
) == REFERENCE_TYPE
)
859 return build_indirect_ref (val
, NULL_PTR
);
863 /* See if there is a constructor of type TYPE which will convert
864 EXPR. The reference manual seems to suggest (8.5.6) that we need
865 not worry about finding constructors for base classes, then converting
866 to the derived class.
868 MSGP is a pointer to a message that would be an appropriate error
869 string. If MSGP is NULL, then we are not interested in reporting
872 convert_to_aggr (type
, expr
, msgp
, protect
)
877 tree basetype
= type
;
878 tree name
= TYPE_IDENTIFIER (basetype
);
879 tree function
, fndecl
, fntype
, parmtypes
, parmlist
, result
;
881 enum access_type access
;
882 int can_be_private
, can_be_protected
;
884 if (! TYPE_HAS_CONSTRUCTOR (basetype
))
887 *msgp
= "type `%s' does not have a constructor";
888 return error_mark_node
;
891 access
= access_public
;
893 can_be_protected
= IDENTIFIER_CLASS_VALUE (name
) || name
== current_class_name
;
895 parmlist
= build_tree_list (NULL_TREE
, expr
);
896 parmtypes
= tree_cons (NULL_TREE
, TREE_TYPE (expr
), void_list_node
);
898 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
900 parmtypes
= tree_cons (NULL_TREE
, integer_type_node
, parmtypes
);
901 parmlist
= tree_cons (NULL_TREE
, integer_one_node
, parmlist
);
904 /* The type of the first argument will be filled in inside the loop. */
905 parmlist
= tree_cons (NULL_TREE
, integer_zero_node
, parmlist
);
906 parmtypes
= tree_cons (NULL_TREE
, TYPE_POINTER_TO (basetype
), parmtypes
);
909 method_name
= build_decl_overload (name
, parmtypes
, 1);
911 /* constructors are up front. */
912 fndecl
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0);
913 if (TYPE_HAS_DESTRUCTOR (basetype
))
914 fndecl
= DECL_CHAIN (fndecl
);
918 if (DECL_ASSEMBLER_NAME (fndecl
) == method_name
)
923 if (TREE_PRIVATE (fndecl
))
926 (basetype
== current_class_type
927 || is_friend (basetype
, current_function_decl
)
928 || purpose_member (basetype
, DECL_ACCESS (fndecl
)));
929 if (! can_be_private
)
932 else if (TREE_PROTECTED (fndecl
))
934 if (! can_be_protected
)
940 fndecl
= DECL_CHAIN (fndecl
);
944 /* No exact conversion was found. See if an approximate
946 fndecl
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0);
947 if (TYPE_HAS_DESTRUCTOR (basetype
))
948 fndecl
= DECL_CHAIN (fndecl
);
952 int saw_protected
= 0;
953 struct candidate
*candidates
=
954 (struct candidate
*) alloca ((decl_list_length (fndecl
)+1) * sizeof (struct candidate
));
955 struct candidate
*cp
= candidates
;
961 cp
->harshness
= (struct harshness_code
*)
962 alloca (3 * sizeof (struct harshness_code
));
964 compute_conversion_costs (fndecl
, parmlist
, cp
, 2);
965 if ((cp
->h
.code
& EVIL_CODE
) == 0)
967 cp
->u
.field
= fndecl
;
970 if (TREE_PRIVATE (fndecl
))
971 access
= access_private
;
972 else if (TREE_PROTECTED (fndecl
))
973 access
= access_protected
;
975 access
= access_public
;
978 access
= access_public
;
980 if (access
== access_private
981 ? (basetype
== current_class_type
982 || is_friend (basetype
, cp
->function
)
983 || purpose_member (basetype
, DECL_ACCESS (fndecl
)))
984 : access
== access_protected
986 || purpose_member (basetype
, DECL_ACCESS (fndecl
)))
989 if (cp
->h
.code
<= TRIVIAL_CODE
)
995 if (access
== access_private
)
1001 fndecl
= DECL_CHAIN (fndecl
);
1003 if (cp
- candidates
)
1005 /* Rank from worst to best. Then cp will point to best one.
1006 Private fields have their bits flipped. For unsigned
1007 numbers, this should make them look very large.
1008 If the best alternate has a (signed) negative value,
1009 then all we ever saw were private members. */
1010 if (cp
- candidates
> 1)
1011 qsort (candidates
, /* char *base */
1012 cp
- candidates
, /* int nel */
1013 sizeof (struct candidate
), /* int width */
1014 rank_for_overload
); /* int (*compar)() */
1017 if (cp
->h
.code
& EVIL_CODE
)
1020 *msgp
= "ambiguous type conversion possible for `%s'";
1021 return error_mark_node
;
1024 function
= cp
->function
;
1025 fndecl
= cp
->u
.field
;
1032 *msgp
= "only private and protected conversions apply";
1034 *msgp
= "only private conversions apply";
1035 else if (saw_protected
)
1036 *msgp
= "only protected conversions apply";
1038 *msgp
= "no appropriate conversion to type `%s'";
1040 return error_mark_node
;
1045 if (access
== access_private
)
1046 if (! can_be_private
)
1049 *msgp
= TREE_PRIVATE (fndecl
)
1050 ? "conversion to type `%s' is private"
1051 : "conversion to type `%s' is from private base class";
1052 return error_mark_node
;
1054 if (access
== access_protected
)
1055 if (! can_be_protected
)
1058 *msgp
= TREE_PRIVATE (fndecl
)
1059 ? "conversion to type `%s' is protected"
1060 : "conversion to type `%s' is from protected base class";
1061 return error_mark_node
;
1066 /* It will convert, but we don't do anything about it yet. */
1070 fntype
= TREE_TYPE (function
);
1071 function
= default_conversion (function
);
1073 result
= build_nt (CALL_EXPR
, function
,
1074 convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
1075 parmlist
, NULL_TREE
, LOOKUP_NORMAL
),
1077 TREE_TYPE (result
) = TREE_TYPE (fntype
);
1078 TREE_SIDE_EFFECTS (result
) = 1;
1082 /* Call this when we know (for any reason) that expr is not, in fact,
1083 zero. This routine is like convert_pointer_to, but it pays
1084 attention to which specific instance of what type we want to
1085 convert to. This routine should eventually become
1086 convert_to_pointer after all references to convert_to_pointer
1089 convert_pointer_to_real (binfo
, expr
)
1092 register tree intype
= TREE_TYPE (expr
);
1096 if (TREE_CODE (binfo
) == TREE_VEC
)
1097 type
= BINFO_TYPE (binfo
);
1098 else if (IS_AGGR_TYPE (binfo
))
1108 ptr_type
= build_pointer_type (type
);
1109 if (ptr_type
== TYPE_MAIN_VARIANT (intype
))
1112 if (intype
== error_mark_node
)
1113 return error_mark_node
;
1115 my_friendly_assert (!integer_zerop (expr
), 191);
1117 if (TREE_CODE (type
) == RECORD_TYPE
1118 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
1119 && type
!= TYPE_MAIN_VARIANT (TREE_TYPE (intype
)))
1123 = get_base_distance (binfo
, TYPE_MAIN_VARIANT (TREE_TYPE (intype
)),
1126 /* This function shouldn't be called with unqualified arguments
1127 but if it is, give them an error message that they can read. */
1130 cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
1131 TREE_TYPE (intype
), type
);
1134 cp_error ("because `%T' is an ambiguous base class", type
);
1135 return error_mark_node
;
1138 return build_vbase_path (PLUS_EXPR
, ptr_type
, expr
, path
, 1);
1140 rval
= build1 (NOP_EXPR
, ptr_type
,
1141 TREE_CODE (expr
) == NOP_EXPR
? TREE_OPERAND (expr
, 0) : expr
);
1142 TREE_CONSTANT (rval
) = TREE_CONSTANT (expr
);
1146 /* Call this when we know (for any reason) that expr is
1147 not, in fact, zero. This routine gets a type out of the first
1148 argument and uses it to search for the type to convert to. If there
1149 is more than one instance of that type in the expr, the conversion is
1150 ambiguous. This routine should eventually go away, and all
1151 callers should use convert_to_pointer_real. */
1153 convert_pointer_to (binfo
, expr
)
1158 if (TREE_CODE (binfo
) == TREE_VEC
)
1159 type
= BINFO_TYPE (binfo
);
1160 else if (IS_AGGR_TYPE (binfo
))
1164 return convert_pointer_to_real (type
, expr
);
1167 /* Same as above, but don't abort if we get an "ambiguous" baseclass.
1168 There's only one virtual baseclass we are looking for, and once
1169 we find one such virtual baseclass, we have found them all. */
1172 convert_pointer_to_vbase (binfo
, expr
)
1176 tree intype
= TREE_TYPE (TREE_TYPE (expr
));
1177 tree binfos
= TYPE_BINFO_BASETYPES (intype
);
1180 for (i
= TREE_VEC_LENGTH (binfos
)-1; i
>= 0; i
--)
1182 tree basetype
= BINFO_TYPE (TREE_VEC_ELT (binfos
, i
));
1183 if (BINFO_TYPE (binfo
) == basetype
)
1184 return convert_pointer_to (binfo
, expr
);
1185 if (binfo_member (BINFO_TYPE (binfo
), CLASSTYPE_VBASECLASSES (basetype
)))
1186 return convert_pointer_to_vbase (binfo
, convert_pointer_to (basetype
, expr
));
1188 my_friendly_abort (6);
1195 FLAGS indicates how we should behave. */
1198 cp_convert (type
, expr
, convtype
, flags
)
1200 int convtype
, flags
;
1202 register tree e
= expr
;
1203 register enum tree_code code
= TREE_CODE (type
);
1205 if (TREE_CODE (e
) == ERROR_MARK
1206 || TREE_CODE (TREE_TYPE (e
)) == ERROR_MARK
)
1207 return error_mark_node
;
1209 if (IS_AGGR_TYPE (type
) && (convtype
& CONV_FORCE_TEMP
))
1210 /* We need a new temporary; don't take this shortcut. */;
1211 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (e
)))
1212 /* Trivial conversion: cv-qualifiers do not matter on rvalues. */
1213 return fold (build1 (NOP_EXPR
, type
, e
));
1215 if (code
== VOID_TYPE
&& (convtype
& CONV_STATIC
))
1216 return build1 (CONVERT_EXPR
, type
, e
);
1219 /* This is incorrect. A truncation can't be stripped this way.
1220 Extensions will be stripped by the use of get_unwidened. */
1221 if (TREE_CODE (e
) == NOP_EXPR
)
1222 return convert (type
, TREE_OPERAND (e
, 0));
1225 /* Just convert to the type of the member. */
1226 if (code
== OFFSET_TYPE
)
1228 type
= TREE_TYPE (type
);
1229 code
= TREE_CODE (type
);
1233 if (code
== REFERENCE_TYPE
)
1234 return fold (convert_to_reference (type
, e
, convtype
, flags
, NULL_TREE
));
1235 else if (TREE_CODE (TREE_TYPE (e
)) == REFERENCE_TYPE
)
1236 e
= convert_from_reference (e
);
1239 if (TREE_CODE (e
) == OFFSET_REF
)
1240 e
= resolve_offset_ref (e
);
1242 if (TREE_READONLY_DECL_P (e
))
1243 e
= decl_constant_value (e
);
1245 if (INTEGRAL_CODE_P (code
))
1247 tree intype
= TREE_TYPE (e
);
1248 enum tree_code form
= TREE_CODE (intype
);
1249 /* enum = enum, enum = int, enum = float are all errors. */
1250 if (flag_int_enum_equivalence
== 0
1251 && TREE_CODE (type
) == ENUMERAL_TYPE
1252 && ARITHMETIC_TYPE_P (intype
)
1253 && ! (convtype
& CONV_STATIC
))
1255 cp_pedwarn ("conversion from `%#T' to `%#T'", intype
, type
);
1257 if (flag_pedantic_errors
)
1258 return error_mark_node
;
1260 if (IS_AGGR_TYPE (intype
))
1263 rval
= build_type_conversion (CONVERT_EXPR
, type
, e
, 1);
1266 if (flags
& LOOKUP_COMPLAIN
)
1267 cp_error ("`%#T' used where a `%T' was expected", intype
, type
);
1268 if (flags
& LOOKUP_SPECULATIVELY
)
1270 return error_mark_node
;
1272 if (code
== BOOLEAN_TYPE
)
1273 return truthvalue_conversion (e
);
1274 return fold (convert_to_integer (type
, e
));
1276 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
1277 || TYPE_PTRMEMFUNC_P (type
))
1278 return fold (cp_convert_to_pointer (type
, e
));
1279 if (code
== REAL_TYPE
)
1281 if (IS_AGGR_TYPE (TREE_TYPE (e
)))
1284 rval
= build_type_conversion (CONVERT_EXPR
, type
, e
, 1);
1288 if (flags
& LOOKUP_COMPLAIN
)
1289 cp_error ("`%#T' used where a floating point value was expected",
1292 return fold (convert_to_real (type
, e
));
1295 /* New C++ semantics: since assignment is now based on
1296 memberwise copying, if the rhs type is derived from the
1297 lhs type, then we may still do a conversion. */
1298 if (IS_AGGR_TYPE_CODE (code
))
1300 tree dtype
= TREE_TYPE (e
);
1301 tree ctor
= NULL_TREE
;
1302 tree conversion
= NULL_TREE
;
1304 dtype
= TYPE_MAIN_VARIANT (dtype
);
1306 /* Conversion of object pointers or signature pointers/references
1307 to signature pointers/references. */
1309 if (TYPE_LANG_SPECIFIC (type
)
1310 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
1312 tree constructor
= build_signature_pointer_constructor (type
, expr
);
1313 tree sig_ty
= SIGNATURE_TYPE (type
);
1316 if (constructor
== error_mark_node
)
1317 return error_mark_node
;
1319 sig_ptr
= get_temp_name (type
, 1);
1320 DECL_INITIAL (sig_ptr
) = constructor
;
1321 CLEAR_SIGNATURE (sig_ty
);
1322 cp_finish_decl (sig_ptr
, constructor
, NULL_TREE
, 0, 0);
1323 SET_SIGNATURE (sig_ty
);
1324 TREE_READONLY (sig_ptr
) = 1;
1329 /* Conversion between aggregate types. New C++ semantics allow
1330 objects of derived type to be cast to objects of base type.
1331 Old semantics only allowed this between pointers.
1333 There may be some ambiguity between using a constructor
1334 vs. using a type conversion operator when both apply. */
1336 if (IS_AGGR_TYPE (dtype
) && ! DERIVED_FROM_P (type
, dtype
)
1337 && TYPE_HAS_CONVERSION (dtype
))
1338 conversion
= build_type_conversion (CONVERT_EXPR
, type
, e
, 1);
1340 if (conversion
== error_mark_node
)
1342 if (flags
& LOOKUP_COMPLAIN
)
1343 error ("ambiguous pointer conversion");
1347 if (TYPE_HAS_CONSTRUCTOR (type
))
1348 ctor
= build_method_call (NULL_TREE
, constructor_name_full (type
),
1349 build_tree_list (NULL_TREE
, e
),
1351 (flags
& LOOKUP_NORMAL
) | LOOKUP_SPECULATIVELY
1352 | (convtype
&CONV_NONCONVERTING
? 0 : LOOKUP_ONLYCONVERTING
)
1353 | (conversion
? LOOKUP_NO_CONVERSION
: 0));
1355 if (ctor
== error_mark_node
)
1357 if (flags
& LOOKUP_COMPLAIN
)
1358 cp_error ("in conversion to type `%T'", type
);
1359 if (flags
& LOOKUP_SPECULATIVELY
)
1361 return error_mark_node
;
1364 if (conversion
&& ctor
)
1366 if (flags
& LOOKUP_COMPLAIN
)
1367 error ("both constructor and type conversion operator apply");
1368 if (flags
& LOOKUP_SPECULATIVELY
)
1370 return error_mark_node
;
1372 else if (conversion
)
1376 if (current_function_decl
)
1377 /* We can't pass 1 to the with_cleanup_p arg here, because that
1378 screws up passing classes by value. */
1379 ctor
= build_cplus_new (type
, ctor
, 0);
1382 register tree parm
= TREE_OPERAND (ctor
, 1);
1384 /* Initializers for static variables and parameters
1385 have to handle doing the initialization and
1386 cleanup themselves. */
1387 my_friendly_assert (TREE_CODE (ctor
) == CALL_EXPR
, 322);
1389 /* The following assertion fails in cases where we
1390 are initializing a static member variable of a
1391 particular instance of a template class with a
1392 call to a constructor of the given instance, as
1395 TMPL<int> object = TMPL<int>();
1397 Curiously, the assertion does not fail if we do
1398 the same thing for a static member of a
1399 non-template class, as in:
1403 I can't see why we should care here whether or not
1404 the initializer expression involves a call to
1405 `new', so for the time being, it seems best to
1406 just avoid doing this assertion. */
1407 my_friendly_assert (TREE_CALLS_NEW (TREE_VALUE (parm
)),
1410 TREE_VALUE (parm
) = NULL_TREE
;
1411 ctor
= build_indirect_ref (ctor
, NULL_PTR
);
1412 TREE_HAS_CONSTRUCTOR (ctor
) = 1;
1418 /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
1419 then the it won't be hashed and hence compare as not equal,
1421 if (code
== ARRAY_TYPE
1422 && TREE_TYPE (TREE_TYPE (e
)) == TREE_TYPE (type
)
1423 && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e
)), TYPE_DOMAIN (type
)))
1426 if (flags
& LOOKUP_COMPLAIN
)
1427 cp_error ("conversion from `%T' to non-scalar type `%T' requested",
1428 TREE_TYPE (expr
), type
);
1429 if (flags
& LOOKUP_SPECULATIVELY
)
1431 return error_mark_node
;
1434 /* Create an expression whose value is that of EXPR,
1435 converted to type TYPE. The TREE_TYPE of the value
1436 is always TYPE. This function implements all reasonable
1437 conversions; callers should filter out those that are
1438 not permitted by the language being compiled. */
1441 convert (type
, expr
)
1444 return cp_convert (type
, expr
, CONV_OLD_CONVERT
, LOOKUP_NORMAL
);
1447 /* Like convert, except permit conversions to take place which
1448 are not normally allowed due to access restrictions
1449 (such as conversion from sub-type to private super-type). */
1451 convert_force (type
, expr
, convtype
)
1456 register tree e
= expr
;
1457 register enum tree_code code
= TREE_CODE (type
);
1459 if (code
== REFERENCE_TYPE
)
1460 return fold (convert_to_reference (type
, e
, CONV_C_CAST
, LOOKUP_COMPLAIN
,
1462 else if (TREE_CODE (TREE_TYPE (e
)) == REFERENCE_TYPE
)
1463 e
= convert_from_reference (e
);
1465 if (code
== POINTER_TYPE
)
1466 return fold (convert_to_pointer_force (type
, e
));
1468 /* From typeck.c convert_for_assignment */
1469 if (((TREE_CODE (TREE_TYPE (e
)) == POINTER_TYPE
&& TREE_CODE (e
) == ADDR_EXPR
1470 && TREE_CODE (TREE_TYPE (e
)) == POINTER_TYPE
1471 && TREE_CODE (TREE_TYPE (TREE_TYPE (e
))) == METHOD_TYPE
)
1472 || integer_zerop (e
)
1473 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e
)))
1474 && TYPE_PTRMEMFUNC_P (type
))
1476 /* compatible pointer to member functions. */
1477 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), e
, 1);
1480 return cp_convert (type
, e
, CONV_C_CAST
|convtype
, LOOKUP_NORMAL
);
1483 /* Subroutine of build_type_conversion. */
1485 build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
)
1486 tree xtype
, basetype
;
1495 flags
= LOOKUP_PROTECT
|LOOKUP_ONLYCONVERTING
;
1497 flags
= LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
;
1499 rval
= build_method_call (expr
, typename
, NULL_TREE
, NULL_TREE
, flags
);
1500 if (rval
== error_mark_node
)
1504 return error_mark_node
;
1507 if (IS_AGGR_TYPE (TREE_TYPE (rval
)))
1511 && TREE_TYPE (xtype
)
1512 && (TREE_READONLY (TREE_TYPE (TREE_TYPE (rval
)))
1513 > TREE_READONLY (TREE_TYPE (xtype
))))
1514 warning ("user-defined conversion casting away `const'");
1515 return convert (xtype
, rval
);
1518 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1519 exists, return the attempted conversion. This may
1520 return ERROR_MARK_NODE if the conversion is not
1521 allowed (references private members, etc).
1522 If no conversion exists, NULL_TREE is returned.
1524 If (FOR_SURE & 1) is non-zero, then we allow this type conversion
1525 to take place immediately. Otherwise, we build a SAVE_EXPR
1526 which can be evaluated if the results are ever needed. */
1529 build_type_conversion (code
, xtype
, expr
, for_sure
)
1530 enum tree_code code
;
1534 /* C++: check to see if we can convert this aggregate type
1535 into the required type. */
1538 tree winner
= NULL_TREE
;
1540 if (expr
== error_mark_node
)
1541 return error_mark_node
;
1543 basetype
= TREE_TYPE (expr
);
1544 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1545 basetype
= TREE_TYPE (basetype
);
1547 basetype
= TYPE_MAIN_VARIANT (basetype
);
1548 if (! TYPE_LANG_SPECIFIC (basetype
) || ! TYPE_HAS_CONVERSION (basetype
))
1551 /* Do we have an exact match? */
1553 tree typename
= build_typename_overload (xtype
);
1554 if (lookup_fnfields (TYPE_BINFO (basetype
), typename
, 0))
1555 return build_type_conversion_1 (xtype
, basetype
, expr
, typename
,
1559 /* Nope; try looking for others. */
1560 for (conv
= lookup_conversions (basetype
); conv
; conv
= TREE_CHAIN (conv
))
1562 if (winner
&& TREE_PURPOSE (winner
) == TREE_PURPOSE (conv
))
1565 if (can_convert (xtype
, TREE_VALUE (conv
)))
1571 cp_error ("ambiguous conversion from `%T' to `%T'", basetype
,
1573 cp_error (" candidate conversions include `%T' and `%T'",
1574 TREE_VALUE (winner
), TREE_VALUE (conv
));
1584 return build_type_conversion_1 (xtype
, basetype
, expr
,
1585 TREE_PURPOSE (winner
), for_sure
);
1590 /* Convert the given EXPR to one of a group of types suitable for use in an
1591 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1592 which indicates which types are suitable. If COMPLAIN is 1, complain
1593 about ambiguity; otherwise, the caller will deal with it. */
1596 build_expr_type_conversion (desires
, expr
, complain
)
1601 tree basetype
= TREE_TYPE (expr
);
1603 tree winner
= NULL_TREE
;
1605 if (TREE_CODE (basetype
) == OFFSET_TYPE
)
1607 expr
= resolve_offset_ref (expr
);
1608 basetype
= TREE_TYPE (expr
);
1611 if (! IS_AGGR_TYPE (basetype
))
1612 switch (TREE_CODE (basetype
))
1615 if ((desires
& WANT_NULL
) && TREE_CODE (expr
) == INTEGER_CST
1616 && integer_zerop (expr
))
1618 /* else fall through... */
1621 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1623 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1625 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1627 return (desires
& WANT_POINTER
) ? expr
: NULL_TREE
;
1631 return (desires
& WANT_POINTER
) ? default_conversion (expr
)
1637 if (! TYPE_HAS_CONVERSION (basetype
))
1640 for (conv
= lookup_conversions (basetype
); conv
; conv
= TREE_CHAIN (conv
))
1644 if (winner
&& TREE_PURPOSE (winner
) == TREE_PURPOSE (conv
))
1647 switch (TREE_CODE (TREE_VALUE (conv
)))
1651 win
= (desires
& WANT_INT
); break;
1653 win
= (desires
& WANT_ENUM
); break;
1655 win
= (desires
& WANT_FLOAT
); break;
1657 win
= (desires
& WANT_POINTER
); break;
1666 cp_error ("ambiguous default type conversion from `%T'",
1668 cp_error (" candidate conversions include `%T' and `%T'",
1669 TREE_VALUE (winner
), TREE_VALUE (conv
));
1671 return error_mark_node
;
1679 return build_type_conversion_1 (TREE_VALUE (winner
), basetype
, expr
,
1680 TREE_PURPOSE (winner
), 1);
1685 /* Must convert two aggregate types to non-aggregate type.
1686 Attempts to find a non-ambiguous, "best" type conversion.
1688 Return 1 on success, 0 on failure.
1690 @@ What are the real semantics of this supposed to be??? */
1692 build_default_binary_type_conversion (code
, arg1
, arg2
)
1693 enum tree_code code
;
1699 case TRUNC_DIV_EXPR
:
1701 case FLOOR_DIV_EXPR
:
1702 case ROUND_DIV_EXPR
:
1703 case EXACT_DIV_EXPR
:
1704 *arg1
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg1
, 0);
1705 *arg2
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg2
, 0);
1708 case TRUNC_MOD_EXPR
:
1709 case FLOOR_MOD_EXPR
:
1715 *arg1
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, *arg1
, 0);
1716 *arg2
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, *arg2
, 0);
1721 tree a1
, a2
, p1
, p2
;
1724 a1
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg1
, 0);
1725 a2
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg2
, 0);
1726 p1
= build_expr_type_conversion (WANT_POINTER
, *arg1
, 0);
1727 p2
= build_expr_type_conversion (WANT_POINTER
, *arg2
, 0);
1729 wins
= (a1
&& a2
) + (a1
&& p2
) + (p1
&& a2
);
1732 error ("ambiguous default type conversion for `operator +'");
1735 *arg1
= a1
, *arg2
= a2
;
1737 *arg1
= a1
, *arg2
= p2
;
1739 *arg1
= p1
, *arg2
= a2
;
1745 tree a1
, a2
, p1
, p2
;
1748 a1
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg1
, 0);
1749 a2
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg2
, 0);
1750 p1
= build_expr_type_conversion (WANT_POINTER
, *arg1
, 0);
1751 p2
= build_expr_type_conversion (WANT_POINTER
, *arg2
, 0);
1753 wins
= (a1
&& a2
) + (p1
&& p2
) + (p1
&& a2
);
1756 error ("ambiguous default type conversion for `operator -'");
1759 *arg1
= a1
, *arg2
= a2
;
1761 *arg1
= p1
, *arg2
= p2
;
1763 *arg1
= p1
, *arg2
= a2
;
1774 tree a1
, a2
, p1
, p2
;
1777 a1
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg1
, 0);
1778 a2
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg2
, 0);
1779 p1
= build_expr_type_conversion (WANT_POINTER
| WANT_NULL
, *arg1
, 0);
1780 p2
= build_expr_type_conversion (WANT_POINTER
| WANT_NULL
, *arg2
, 0);
1782 wins
= (a1
&& a2
) + (p1
&& p2
);
1785 cp_error ("ambiguous default type conversion for `%O'", code
);
1788 *arg1
= a1
, *arg2
= a2
;
1790 *arg1
= p1
, *arg2
= p2
;
1794 case TRUTH_ANDIF_EXPR
:
1795 case TRUTH_ORIF_EXPR
:
1796 *arg1
= convert (boolean_type_node
, *arg1
);
1797 *arg2
= convert (boolean_type_node
, *arg2
);
1805 if (*arg1
== error_mark_node
|| *arg2
== error_mark_node
)
1806 cp_error ("ambiguous default type conversion for `%O'", code
);
1814 /* Implements integral promotion (4.1) and float->double promotion. */
1816 type_promotes_to (type
)
1819 int constp
= TYPE_READONLY (type
);
1820 int volatilep
= TYPE_VOLATILE (type
);
1821 type
= TYPE_MAIN_VARIANT (type
);
1823 /* bool always promotes to int (not unsigned), even if it's the same
1825 if (type
== boolean_type_node
)
1826 type
= integer_type_node
;
1828 /* Normally convert enums to int, but convert wide enums to something
1830 else if (TREE_CODE (type
) == ENUMERAL_TYPE
1831 || type
== wchar_type_node
)
1833 int precision
= MAX (TYPE_PRECISION (type
),
1834 TYPE_PRECISION (integer_type_node
));
1835 tree totype
= type_for_size (precision
, 0);
1836 if (TREE_UNSIGNED (type
)
1837 && ! int_fits_type_p (TYPE_MAX_VALUE (type
), totype
))
1838 type
= type_for_size (precision
, 1);
1842 else if (C_PROMOTING_INTEGER_TYPE_P (type
))
1844 /* Traditionally, unsignedness is preserved in default promotions.
1845 Otherwise, retain unsignedness if really not getting bigger. */
1846 if (TREE_UNSIGNED (type
)
1847 && (flag_traditional
1848 || TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
1849 type
= unsigned_type_node
;
1851 type
= integer_type_node
;
1853 else if (type
== float_type_node
)
1854 type
= double_type_node
;
1856 return cp_build_type_variant (type
, constp
, volatilep
);