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 (global_bindings_p ())
598 /* Give this new temp some rtl and initialize it. */
599 DECL_INITIAL (temp
) = targ
;
600 TREE_STATIC (temp
) = 1;
601 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 (global_bindings_p ())
775 extern tree static_aggregates
;
776 tree t
= get_temp_name (type
, global_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_SPECULATIVELY
)
842 else if (flags
& LOOKUP_COMPLAIN
)
843 cp_error ("cannot convert type `%T' to type `%T'", intype
, reftype
);
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
)
860 tree target_type
= TREE_TYPE (type
);
863 /* This can happen if we cast to a reference type. */
864 if (TREE_CODE (val
) == ADDR_EXPR
)
866 nval
= build1 (NOP_EXPR
, build_pointer_type (target_type
), val
);
867 nval
= build_indirect_ref (nval
, NULL_PTR
);
868 /* The below was missing, are other important flags missing too? */
869 TREE_SIDE_EFFECTS (nval
) = TREE_SIDE_EFFECTS (val
);
873 nval
= build1 (INDIRECT_REF
, target_type
, val
);
875 TREE_THIS_VOLATILE (nval
) = TYPE_VOLATILE (target_type
);
876 TREE_SIDE_EFFECTS (nval
) = TYPE_VOLATILE (target_type
);
877 TREE_READONLY (nval
) = TYPE_READONLY (target_type
);
878 /* The below was missing, are other important flags missing too? */
879 TREE_SIDE_EFFECTS (nval
) |= TREE_SIDE_EFFECTS (val
);
885 /* See if there is a constructor of type TYPE which will convert
886 EXPR. The reference manual seems to suggest (8.5.6) that we need
887 not worry about finding constructors for base classes, then converting
888 to the derived class.
890 MSGP is a pointer to a message that would be an appropriate error
891 string. If MSGP is NULL, then we are not interested in reporting
894 convert_to_aggr (type
, expr
, msgp
, protect
)
899 tree basetype
= type
;
900 tree name
= TYPE_IDENTIFIER (basetype
);
901 tree function
, fndecl
, fntype
, parmtypes
, parmlist
, result
;
903 enum access_type access
;
904 int can_be_private
, can_be_protected
;
906 if (! TYPE_HAS_CONSTRUCTOR (basetype
))
909 *msgp
= "type `%s' does not have a constructor";
910 return error_mark_node
;
913 access
= access_public
;
915 can_be_protected
= IDENTIFIER_CLASS_VALUE (name
) || name
== current_class_name
;
917 parmlist
= build_tree_list (NULL_TREE
, expr
);
918 parmtypes
= tree_cons (NULL_TREE
, TREE_TYPE (expr
), void_list_node
);
920 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
922 parmtypes
= tree_cons (NULL_TREE
, integer_type_node
, parmtypes
);
923 parmlist
= tree_cons (NULL_TREE
, integer_one_node
, parmlist
);
926 /* The type of the first argument will be filled in inside the loop. */
927 parmlist
= tree_cons (NULL_TREE
, integer_zero_node
, parmlist
);
928 parmtypes
= tree_cons (NULL_TREE
, TYPE_POINTER_TO (basetype
), parmtypes
);
931 method_name
= build_decl_overload (name
, parmtypes
, 1);
933 /* constructors are up front. */
934 fndecl
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0);
935 if (TYPE_HAS_DESTRUCTOR (basetype
))
936 fndecl
= DECL_CHAIN (fndecl
);
940 if (DECL_ASSEMBLER_NAME (fndecl
) == method_name
)
945 if (TREE_PRIVATE (fndecl
))
948 (basetype
== current_class_type
949 || is_friend (basetype
, current_function_decl
)
950 || purpose_member (basetype
, DECL_ACCESS (fndecl
)));
951 if (! can_be_private
)
954 else if (TREE_PROTECTED (fndecl
))
956 if (! can_be_protected
)
962 fndecl
= DECL_CHAIN (fndecl
);
966 /* No exact conversion was found. See if an approximate
968 fndecl
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0);
969 if (TYPE_HAS_DESTRUCTOR (basetype
))
970 fndecl
= DECL_CHAIN (fndecl
);
974 int saw_protected
= 0;
975 struct candidate
*candidates
=
976 (struct candidate
*) alloca ((decl_list_length (fndecl
)+1) * sizeof (struct candidate
));
977 struct candidate
*cp
= candidates
;
983 cp
->harshness
= (struct harshness_code
*)
984 alloca (3 * sizeof (struct harshness_code
));
986 compute_conversion_costs (fndecl
, parmlist
, cp
, 2);
987 if ((cp
->h
.code
& EVIL_CODE
) == 0)
989 cp
->u
.field
= fndecl
;
992 if (TREE_PRIVATE (fndecl
))
993 access
= access_private
;
994 else if (TREE_PROTECTED (fndecl
))
995 access
= access_protected
;
997 access
= access_public
;
1000 access
= access_public
;
1002 if (access
== access_private
1003 ? (basetype
== current_class_type
1004 || is_friend (basetype
, cp
->function
)
1005 || purpose_member (basetype
, DECL_ACCESS (fndecl
)))
1006 : access
== access_protected
1008 || purpose_member (basetype
, DECL_ACCESS (fndecl
)))
1011 if (cp
->h
.code
<= TRIVIAL_CODE
)
1017 if (access
== access_private
)
1023 fndecl
= DECL_CHAIN (fndecl
);
1025 if (cp
- candidates
)
1027 /* Rank from worst to best. Then cp will point to best one.
1028 Private fields have their bits flipped. For unsigned
1029 numbers, this should make them look very large.
1030 If the best alternate has a (signed) negative value,
1031 then all we ever saw were private members. */
1032 if (cp
- candidates
> 1)
1033 qsort (candidates
, /* char *base */
1034 cp
- candidates
, /* int nel */
1035 sizeof (struct candidate
), /* int width */
1036 rank_for_overload
); /* int (*compar)() */
1039 if (cp
->h
.code
& EVIL_CODE
)
1042 *msgp
= "ambiguous type conversion possible for `%s'";
1043 return error_mark_node
;
1046 function
= cp
->function
;
1047 fndecl
= cp
->u
.field
;
1054 *msgp
= "only private and protected conversions apply";
1056 *msgp
= "only private conversions apply";
1057 else if (saw_protected
)
1058 *msgp
= "only protected conversions apply";
1060 *msgp
= "no appropriate conversion to type `%s'";
1062 return error_mark_node
;
1067 if (access
== access_private
)
1068 if (! can_be_private
)
1071 *msgp
= TREE_PRIVATE (fndecl
)
1072 ? "conversion to type `%s' is private"
1073 : "conversion to type `%s' is from private base class";
1074 return error_mark_node
;
1076 if (access
== access_protected
)
1077 if (! can_be_protected
)
1080 *msgp
= TREE_PRIVATE (fndecl
)
1081 ? "conversion to type `%s' is protected"
1082 : "conversion to type `%s' is from protected base class";
1083 return error_mark_node
;
1088 /* It will convert, but we don't do anything about it yet. */
1092 fntype
= TREE_TYPE (function
);
1093 function
= default_conversion (function
);
1095 result
= build_nt (CALL_EXPR
, function
,
1096 convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
1097 parmlist
, NULL_TREE
, LOOKUP_NORMAL
),
1099 TREE_TYPE (result
) = TREE_TYPE (fntype
);
1100 TREE_SIDE_EFFECTS (result
) = 1;
1104 /* Call this when we know (for any reason) that expr is not, in fact,
1105 zero. This routine is like convert_pointer_to, but it pays
1106 attention to which specific instance of what type we want to
1107 convert to. This routine should eventually become
1108 convert_to_pointer after all references to convert_to_pointer
1111 convert_pointer_to_real (binfo
, expr
)
1114 register tree intype
= TREE_TYPE (expr
);
1118 if (TREE_CODE (binfo
) == TREE_VEC
)
1119 type
= BINFO_TYPE (binfo
);
1120 else if (IS_AGGR_TYPE (binfo
))
1130 ptr_type
= build_pointer_type (type
);
1131 if (ptr_type
== TYPE_MAIN_VARIANT (intype
))
1134 if (intype
== error_mark_node
)
1135 return error_mark_node
;
1137 my_friendly_assert (!integer_zerop (expr
), 191);
1139 if (TREE_CODE (type
) == RECORD_TYPE
1140 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
1141 && type
!= TYPE_MAIN_VARIANT (TREE_TYPE (intype
)))
1145 = get_base_distance (binfo
, TYPE_MAIN_VARIANT (TREE_TYPE (intype
)),
1148 /* This function shouldn't be called with unqualified arguments
1149 but if it is, give them an error message that they can read. */
1152 cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
1153 TREE_TYPE (intype
), type
);
1156 cp_error ("because `%T' is an ambiguous base class", type
);
1157 return error_mark_node
;
1160 return build_vbase_path (PLUS_EXPR
, ptr_type
, expr
, path
, 1);
1162 rval
= build1 (NOP_EXPR
, ptr_type
,
1163 TREE_CODE (expr
) == NOP_EXPR
? TREE_OPERAND (expr
, 0) : expr
);
1164 TREE_CONSTANT (rval
) = TREE_CONSTANT (expr
);
1168 /* Call this when we know (for any reason) that expr is
1169 not, in fact, zero. This routine gets a type out of the first
1170 argument and uses it to search for the type to convert to. If there
1171 is more than one instance of that type in the expr, the conversion is
1172 ambiguous. This routine should eventually go away, and all
1173 callers should use convert_to_pointer_real. */
1175 convert_pointer_to (binfo
, expr
)
1180 if (TREE_CODE (binfo
) == TREE_VEC
)
1181 type
= BINFO_TYPE (binfo
);
1182 else if (IS_AGGR_TYPE (binfo
))
1186 return convert_pointer_to_real (type
, expr
);
1189 /* Same as above, but don't abort if we get an "ambiguous" baseclass.
1190 There's only one virtual baseclass we are looking for, and once
1191 we find one such virtual baseclass, we have found them all. */
1194 convert_pointer_to_vbase (binfo
, expr
)
1198 tree intype
= TREE_TYPE (TREE_TYPE (expr
));
1199 tree binfos
= TYPE_BINFO_BASETYPES (intype
);
1202 for (i
= TREE_VEC_LENGTH (binfos
)-1; i
>= 0; i
--)
1204 tree basetype
= BINFO_TYPE (TREE_VEC_ELT (binfos
, i
));
1205 if (BINFO_TYPE (binfo
) == basetype
)
1206 return convert_pointer_to (binfo
, expr
);
1207 if (binfo_member (BINFO_TYPE (binfo
), CLASSTYPE_VBASECLASSES (basetype
)))
1208 return convert_pointer_to_vbase (binfo
, convert_pointer_to (basetype
, expr
));
1210 my_friendly_abort (6);
1216 cp_convert (type
, expr
, convtype
, flags
)
1218 int convtype
, flags
;
1220 register tree e
= expr
;
1221 register enum tree_code code
= TREE_CODE (type
);
1223 if (TREE_CODE (e
) == ERROR_MARK
1224 || TREE_CODE (TREE_TYPE (e
)) == ERROR_MARK
)
1225 return error_mark_node
;
1227 if (IS_AGGR_TYPE (type
) && (convtype
& CONV_FORCE_TEMP
))
1228 /* We need a new temporary; don't take this shortcut. */;
1229 else if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (e
)))
1230 /* Trivial conversion: cv-qualifiers do not matter on rvalues. */
1231 return fold (build1 (NOP_EXPR
, type
, e
));
1233 if (code
== VOID_TYPE
&& (convtype
& CONV_STATIC
))
1234 return build1 (CONVERT_EXPR
, type
, e
);
1237 /* This is incorrect. A truncation can't be stripped this way.
1238 Extensions will be stripped by the use of get_unwidened. */
1239 if (TREE_CODE (e
) == NOP_EXPR
)
1240 return convert (type
, TREE_OPERAND (e
, 0));
1243 /* Just convert to the type of the member. */
1244 if (code
== OFFSET_TYPE
)
1246 type
= TREE_TYPE (type
);
1247 code
= TREE_CODE (type
);
1251 if (code
== REFERENCE_TYPE
)
1252 return fold (convert_to_reference (type
, e
, convtype
, flags
, NULL_TREE
));
1253 else if (TREE_CODE (TREE_TYPE (e
)) == REFERENCE_TYPE
)
1254 e
= convert_from_reference (e
);
1257 if (TREE_CODE (e
) == OFFSET_REF
)
1258 e
= resolve_offset_ref (e
);
1260 if (TREE_READONLY_DECL_P (e
))
1261 e
= decl_constant_value (e
);
1263 if (INTEGRAL_CODE_P (code
))
1265 tree intype
= TREE_TYPE (e
);
1266 enum tree_code form
= TREE_CODE (intype
);
1267 /* enum = enum, enum = int, enum = float are all errors. */
1268 if (flag_int_enum_equivalence
== 0
1269 && TREE_CODE (type
) == ENUMERAL_TYPE
1270 && ARITHMETIC_TYPE_P (intype
)
1271 && ! (convtype
& CONV_STATIC
))
1273 cp_pedwarn ("conversion from `%#T' to `%#T'", intype
, type
);
1275 if (flag_pedantic_errors
)
1276 return error_mark_node
;
1278 if (IS_AGGR_TYPE (intype
))
1281 rval
= build_type_conversion (CONVERT_EXPR
, type
, e
, 1);
1284 cp_error ("`%#T' used where a `%T' was expected", intype
, type
);
1285 return error_mark_node
;
1287 if (code
== BOOLEAN_TYPE
)
1288 return truthvalue_conversion (e
);
1289 return fold (convert_to_integer (type
, e
));
1291 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
1292 || TYPE_PTRMEMFUNC_P (type
))
1293 return fold (cp_convert_to_pointer (type
, e
));
1294 if (code
== REAL_TYPE
)
1296 if (IS_AGGR_TYPE (TREE_TYPE (e
)))
1299 rval
= build_type_conversion (CONVERT_EXPR
, type
, e
, 1);
1303 cp_error ("`%#T' used where a floating point value was expected",
1306 return fold (convert_to_real (type
, e
));
1309 /* New C++ semantics: since assignment is now based on
1310 memberwise copying, if the rhs type is derived from the
1311 lhs type, then we may still do a conversion. */
1312 if (IS_AGGR_TYPE_CODE (code
))
1314 tree dtype
= TREE_TYPE (e
);
1315 tree ctor
= NULL_TREE
;
1316 tree conversion
= NULL_TREE
;
1318 dtype
= TYPE_MAIN_VARIANT (dtype
);
1320 /* Conversion of object pointers or signature pointers/references
1321 to signature pointers/references. */
1323 if (TYPE_LANG_SPECIFIC (type
)
1324 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
1326 tree constructor
= build_signature_pointer_constructor (type
, expr
);
1327 tree sig_ty
= SIGNATURE_TYPE (type
);
1330 if (constructor
== error_mark_node
)
1331 return error_mark_node
;
1333 sig_ptr
= get_temp_name (type
, 1);
1334 DECL_INITIAL (sig_ptr
) = constructor
;
1335 CLEAR_SIGNATURE (sig_ty
);
1336 finish_decl (sig_ptr
, constructor
, NULL_TREE
, 0, 0);
1337 SET_SIGNATURE (sig_ty
);
1338 TREE_READONLY (sig_ptr
) = 1;
1343 /* Conversion between aggregate types. New C++ semantics allow
1344 objects of derived type to be cast to objects of base type.
1345 Old semantics only allowed this between pointers.
1347 There may be some ambiguity between using a constructor
1348 vs. using a type conversion operator when both apply. */
1350 if (IS_AGGR_TYPE (dtype
) && ! DERIVED_FROM_P (type
, dtype
)
1351 && TYPE_HAS_CONVERSION (dtype
))
1352 conversion
= build_type_conversion (CONVERT_EXPR
, type
, e
, 1);
1354 if (conversion
== error_mark_node
)
1356 error ("ambiguous pointer conversion");
1360 if (TYPE_HAS_CONSTRUCTOR (type
))
1361 ctor
= build_method_call (NULL_TREE
, constructor_name_full (type
),
1362 build_tree_list (NULL_TREE
, e
),
1364 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
1365 | (convtype
&CONV_NONCONVERTING
? 0 : LOOKUP_ONLYCONVERTING
)
1366 | (conversion
? LOOKUP_NO_CONVERSION
: 0));
1368 if (ctor
== error_mark_node
)
1370 cp_error ("in conversion to type `%T'", type
);
1371 return error_mark_node
;
1374 if (conversion
&& ctor
)
1376 error ("both constructor and type conversion operator apply");
1377 return error_mark_node
;
1379 else if (conversion
)
1383 if (current_function_decl
)
1384 /* We can't pass 1 to the with_cleanup_p arg here, because that
1385 screws up passing classes by value. */
1386 ctor
= build_cplus_new (type
, ctor
, 0);
1389 register tree parm
= TREE_OPERAND (ctor
, 1);
1391 /* Initializers for static variables and parameters
1392 have to handle doing the initialization and
1393 cleanup themselves. */
1394 my_friendly_assert (TREE_CODE (ctor
) == CALL_EXPR
, 322);
1396 /* The following assertion fails in cases where we
1397 are initializing a static member variable of a
1398 particular instance of a template class with a
1399 call to a constructor of the given instance, as
1402 TMPL<int> object = TMPL<int>();
1404 Curiously, the assertion does not fail if we do
1405 the same thing for a static member of a
1406 non-template class, as in:
1410 I can't see why we should care here whether or not
1411 the initializer expression involves a call to
1412 `new', so for the time being, it seems best to
1413 just avoid doing this assertion. */
1414 my_friendly_assert (TREE_CALLS_NEW (TREE_VALUE (parm
)),
1417 TREE_VALUE (parm
) = NULL_TREE
;
1418 ctor
= build_indirect_ref (ctor
, NULL_PTR
);
1419 TREE_HAS_CONSTRUCTOR (ctor
) = 1;
1425 /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
1426 then the it won't be hashed and hence compare as not equal,
1428 if (code
== ARRAY_TYPE
1429 && TREE_TYPE (TREE_TYPE (e
)) == TREE_TYPE (type
)
1430 && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e
)), TYPE_DOMAIN (type
)))
1433 cp_error ("conversion from `%T' to non-scalar type `%T' requested",
1434 TREE_TYPE (expr
), type
);
1435 return error_mark_node
;
1438 /* Create an expression whose value is that of EXPR,
1439 converted to type TYPE. The TREE_TYPE of the value
1440 is always TYPE. This function implements all reasonable
1441 conversions; callers should filter out those that are
1442 not permitted by the language being compiled. */
1445 convert (type
, expr
)
1448 return cp_convert (type
, expr
, CONV_OLD_CONVERT
, 0);
1451 /* Like convert, except permit conversions to take place which
1452 are not normally allowed due to access restrictions
1453 (such as conversion from sub-type to private super-type). */
1455 convert_force (type
, expr
, convtype
)
1460 register tree e
= expr
;
1461 register enum tree_code code
= TREE_CODE (type
);
1463 if (code
== REFERENCE_TYPE
)
1464 return fold (convert_to_reference (type
, e
, CONV_C_CAST
, LOOKUP_COMPLAIN
,
1466 else if (TREE_CODE (TREE_TYPE (e
)) == REFERENCE_TYPE
)
1467 e
= convert_from_reference (e
);
1469 if (code
== POINTER_TYPE
)
1470 return fold (convert_to_pointer_force (type
, e
));
1472 /* From typeck.c convert_for_assignment */
1473 if (((TREE_CODE (TREE_TYPE (e
)) == POINTER_TYPE
&& TREE_CODE (e
) == ADDR_EXPR
1474 && TREE_CODE (TREE_TYPE (e
)) == POINTER_TYPE
1475 && TREE_CODE (TREE_TYPE (TREE_TYPE (e
))) == METHOD_TYPE
)
1476 || integer_zerop (e
)
1477 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e
)))
1478 && TYPE_PTRMEMFUNC_P (type
))
1480 /* compatible pointer to member functions. */
1481 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), e
, 1);
1484 return cp_convert (type
, e
, CONV_C_CAST
|convtype
, 0);
1487 /* Subroutine of build_type_conversion. */
1489 build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
)
1490 tree xtype
, basetype
;
1499 flags
= LOOKUP_PROTECT
|LOOKUP_ONLYCONVERTING
;
1501 flags
= LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
;
1503 rval
= build_method_call (expr
, typename
, NULL_TREE
, NULL_TREE
, flags
);
1504 if (rval
== error_mark_node
)
1508 return error_mark_node
;
1511 if (IS_AGGR_TYPE (TREE_TYPE (rval
)))
1515 && TREE_TYPE (xtype
)
1516 && (TREE_READONLY (TREE_TYPE (TREE_TYPE (rval
)))
1517 > TREE_READONLY (TREE_TYPE (xtype
))))
1518 warning ("user-defined conversion casting away `const'");
1519 return convert (xtype
, rval
);
1522 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1523 exists, return the attempted conversion. This may
1524 return ERROR_MARK_NODE if the conversion is not
1525 allowed (references private members, etc).
1526 If no conversion exists, NULL_TREE is returned.
1528 If (FOR_SURE & 1) is non-zero, then we allow this type conversion
1529 to take place immediately. Otherwise, we build a SAVE_EXPR
1530 which can be evaluated if the results are ever needed. */
1533 build_type_conversion (code
, xtype
, expr
, for_sure
)
1534 enum tree_code code
;
1538 /* C++: check to see if we can convert this aggregate type
1539 into the required type. */
1542 tree winner
= NULL_TREE
;
1544 if (expr
== error_mark_node
)
1545 return error_mark_node
;
1547 basetype
= TREE_TYPE (expr
);
1548 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1549 basetype
= TREE_TYPE (basetype
);
1551 basetype
= TYPE_MAIN_VARIANT (basetype
);
1552 if (! TYPE_LANG_SPECIFIC (basetype
) || ! TYPE_HAS_CONVERSION (basetype
))
1555 /* Do we have an exact match? */
1557 tree typename
= build_typename_overload (xtype
);
1558 if (lookup_fnfields (TYPE_BINFO (basetype
), typename
, 0))
1559 return build_type_conversion_1 (xtype
, basetype
, expr
, typename
,
1563 /* Nope; try looking for others. */
1564 for (conv
= lookup_conversions (basetype
); conv
; conv
= TREE_CHAIN (conv
))
1566 if (winner
&& TREE_PURPOSE (winner
) == TREE_PURPOSE (conv
))
1569 if (can_convert (xtype
, TREE_VALUE (conv
)))
1575 cp_error ("ambiguous conversion from `%T' to `%T'", basetype
,
1577 cp_error (" candidate conversions include `%T' and `%T'",
1578 TREE_VALUE (winner
), TREE_VALUE (conv
));
1588 return build_type_conversion_1 (xtype
, basetype
, expr
,
1589 TREE_PURPOSE (winner
), for_sure
);
1594 /* Convert the given EXPR to one of a group of types suitable for use in an
1595 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1596 which indicates which types are suitable. If COMPLAIN is 1, complain
1597 about ambiguity; otherwise, the caller will deal with it. */
1600 build_expr_type_conversion (desires
, expr
, complain
)
1605 tree basetype
= TREE_TYPE (expr
);
1607 tree winner
= NULL_TREE
;
1609 if (TREE_CODE (basetype
) == OFFSET_TYPE
)
1611 expr
= resolve_offset_ref (expr
);
1612 basetype
= TREE_TYPE (expr
);
1615 if (! IS_AGGR_TYPE (basetype
))
1616 switch (TREE_CODE (basetype
))
1619 if ((desires
& WANT_NULL
) && TREE_CODE (expr
) == INTEGER_CST
1620 && integer_zerop (expr
))
1622 /* else fall through... */
1625 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1627 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1629 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1631 return (desires
& WANT_POINTER
) ? expr
: NULL_TREE
;
1635 return (desires
& WANT_POINTER
) ? default_conversion (expr
)
1641 if (! TYPE_HAS_CONVERSION (basetype
))
1644 for (conv
= lookup_conversions (basetype
); conv
; conv
= TREE_CHAIN (conv
))
1648 if (winner
&& TREE_PURPOSE (winner
) == TREE_PURPOSE (conv
))
1651 switch (TREE_CODE (TREE_VALUE (conv
)))
1655 win
= (desires
& WANT_INT
); break;
1657 win
= (desires
& WANT_ENUM
); break;
1659 win
= (desires
& WANT_FLOAT
); break;
1661 win
= (desires
& WANT_POINTER
); break;
1670 cp_error ("ambiguous default type conversion from `%T'",
1672 cp_error (" candidate conversions include `%T' and `%T'",
1673 TREE_VALUE (winner
), TREE_VALUE (conv
));
1675 return error_mark_node
;
1683 return build_type_conversion_1 (TREE_VALUE (winner
), basetype
, expr
,
1684 TREE_PURPOSE (winner
), 1);
1689 /* Must convert two aggregate types to non-aggregate type.
1690 Attempts to find a non-ambiguous, "best" type conversion.
1692 Return 1 on success, 0 on failure.
1694 @@ What are the real semantics of this supposed to be??? */
1696 build_default_binary_type_conversion (code
, arg1
, arg2
)
1697 enum tree_code code
;
1703 case TRUNC_DIV_EXPR
:
1705 case FLOOR_DIV_EXPR
:
1706 case ROUND_DIV_EXPR
:
1707 case EXACT_DIV_EXPR
:
1708 *arg1
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg1
, 0);
1709 *arg2
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg2
, 0);
1712 case TRUNC_MOD_EXPR
:
1713 case FLOOR_MOD_EXPR
:
1719 *arg1
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, *arg1
, 0);
1720 *arg2
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, *arg2
, 0);
1725 tree a1
, a2
, p1
, p2
;
1728 a1
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg1
, 0);
1729 a2
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg2
, 0);
1730 p1
= build_expr_type_conversion (WANT_POINTER
, *arg1
, 0);
1731 p2
= build_expr_type_conversion (WANT_POINTER
, *arg2
, 0);
1733 wins
= (a1
&& a2
) + (a1
&& p2
) + (p1
&& a2
);
1736 error ("ambiguous default type conversion for `operator +'");
1739 *arg1
= a1
, *arg2
= a2
;
1741 *arg1
= a1
, *arg2
= p2
;
1743 *arg1
= p1
, *arg2
= a2
;
1749 tree a1
, a2
, p1
, p2
;
1752 a1
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg1
, 0);
1753 a2
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg2
, 0);
1754 p1
= build_expr_type_conversion (WANT_POINTER
, *arg1
, 0);
1755 p2
= build_expr_type_conversion (WANT_POINTER
, *arg2
, 0);
1757 wins
= (a1
&& a2
) + (p1
&& p2
) + (p1
&& a2
);
1760 error ("ambiguous default type conversion for `operator -'");
1763 *arg1
= a1
, *arg2
= a2
;
1765 *arg1
= p1
, *arg2
= p2
;
1767 *arg1
= p1
, *arg2
= a2
;
1778 tree a1
, a2
, p1
, p2
;
1781 a1
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg1
, 0);
1782 a2
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, *arg2
, 0);
1783 p1
= build_expr_type_conversion (WANT_POINTER
| WANT_NULL
, *arg1
, 0);
1784 p2
= build_expr_type_conversion (WANT_POINTER
| WANT_NULL
, *arg2
, 0);
1786 wins
= (a1
&& a2
) + (p1
&& p2
);
1789 cp_error ("ambiguous default type conversion for `%O'", code
);
1792 *arg1
= a1
, *arg2
= a2
;
1794 *arg1
= p1
, *arg2
= p2
;
1798 case TRUTH_ANDIF_EXPR
:
1799 case TRUTH_ORIF_EXPR
:
1800 *arg1
= convert (boolean_type_node
, *arg1
);
1801 *arg2
= convert (boolean_type_node
, *arg2
);
1809 if (*arg1
== error_mark_node
|| *arg2
== error_mark_node
)
1810 cp_error ("ambiguous default type conversion for `%O'", code
);
1818 /* Implements integral promotion (4.1) and float->double promotion. */
1820 type_promotes_to (type
)
1823 int constp
= TYPE_READONLY (type
);
1824 int volatilep
= TYPE_VOLATILE (type
);
1825 type
= TYPE_MAIN_VARIANT (type
);
1827 /* bool always promotes to int (not unsigned), even if it's the same
1829 if (type
== boolean_type_node
)
1830 type
= integer_type_node
;
1832 /* Normally convert enums to int, but convert wide enums to something
1834 else if (TREE_CODE (type
) == ENUMERAL_TYPE
1835 || type
== wchar_type_node
)
1837 int precision
= MAX (TYPE_PRECISION (type
),
1838 TYPE_PRECISION (integer_type_node
));
1839 tree totype
= type_for_size (precision
, 0);
1840 if (TREE_UNSIGNED (type
)
1841 && ! int_fits_type_p (TYPE_MAX_VALUE (type
), totype
))
1842 type
= type_for_size (precision
, 1);
1846 else if (C_PROMOTING_INTEGER_TYPE_P (type
))
1848 /* Traditionally, unsignedness is preserved in default promotions.
1849 Otherwise, retain unsignedness if really not getting bigger. */
1850 if (TREE_UNSIGNED (type
)
1851 && (flag_traditional
1852 || TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
1853 type
= unsigned_type_node
;
1855 type
= integer_type_node
;
1857 else if (type
== float_type_node
)
1858 type
= double_type_node
;
1860 return cp_build_type_variant (type
, constp
, volatilep
);