1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987, 1988, 1992, 1993 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 tree binfo
= get_binfo (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (expr
))),
85 TYPE_METHOD_BASETYPE (TREE_TYPE (type
)),
87 if (binfo
== error_mark_node
)
89 error (" in pointer to member conversion");
90 return error_mark_node
;
92 if (binfo
== NULL_TREE
)
94 /* ARM 4.8 restriction. */
95 error ("invalid pointer to member conversion");
96 return error_mark_node
;
98 if (BINFO_OFFSET_ZEROP (binfo
))
99 return build1 (NOP_EXPR
, type
, expr
);
100 return build1 (NOP_EXPR
, type
, build_thunk (BINFO_OFFSET (binfo
), expr
));
103 /* if converting pointer to pointer
104 if dealing with classes, check for derived->base or vice versa
105 else if dealing with method pointers, delegate
107 else if converting class, pass off to build_type_conversion
108 else try C-style pointer conversion */
110 cp_convert_to_pointer (type
, expr
)
113 register tree intype
= TREE_TYPE (expr
);
114 register enum tree_code form
= TREE_CODE (intype
);
116 if (form
== POINTER_TYPE
)
118 intype
= TYPE_MAIN_VARIANT (intype
);
120 if (TYPE_MAIN_VARIANT (type
) != intype
121 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
122 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
124 enum tree_code code
= PLUS_EXPR
;
125 tree binfo
= get_binfo (TREE_TYPE (type
), TREE_TYPE (intype
), 1);
126 if (binfo
== error_mark_node
)
127 return error_mark_node
;
128 if (binfo
== NULL_TREE
)
130 binfo
= get_binfo (TREE_TYPE (intype
), TREE_TYPE (type
), 1);
131 if (binfo
== error_mark_node
)
132 return error_mark_node
;
137 if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type
))
138 || TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype
))
139 || ! BINFO_OFFSET_ZEROP (binfo
))
141 /* Need to get the path we took. */
144 if (code
== PLUS_EXPR
)
145 get_base_distance (TREE_TYPE (type
), TREE_TYPE (intype
), 0, &path
);
147 get_base_distance (TREE_TYPE (intype
), TREE_TYPE (type
), 0, &path
);
148 return build_vbase_path (code
, type
, expr
, path
, 0);
152 if (TYPE_MAIN_VARIANT (type
) != intype
153 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
154 && TREE_CODE (type
) == POINTER_TYPE
155 && TREE_CODE (TREE_TYPE (intype
)) == METHOD_TYPE
)
156 return convert_fn_ptr (type
, expr
);
158 return build1 (NOP_EXPR
, type
, expr
);
161 my_friendly_assert (form
!= OFFSET_TYPE
, 186);
163 if (TYPE_LANG_SPECIFIC (intype
)
164 && (IS_SIGNATURE_POINTER (intype
) || IS_SIGNATURE_REFERENCE (intype
)))
165 return convert_to_pointer (type
, build_optr_ref (expr
));
167 if (IS_AGGR_TYPE (intype
))
170 rval
= build_type_conversion (CONVERT_EXPR
, type
, expr
, 1);
173 if (rval
== error_mark_node
)
174 cp_error ("conversion of `%E' from `%T' to `%T' is ambiguous",
180 if (integer_zerop (expr
))
182 if (type
== TREE_TYPE (null_pointer_node
))
183 return null_pointer_node
;
184 expr
= build_int_2 (0, 0);
185 TREE_TYPE (expr
) = type
;
189 if (INTEGRAL_CODE_P (form
))
191 if (type_precision (intype
) == POINTER_SIZE
)
192 return build1 (CONVERT_EXPR
, type
, expr
);
193 expr
= convert (type_for_size (POINTER_SIZE
, 0), expr
);
194 /* Modes may be different but sizes should be the same. */
195 if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr
)))
196 != GET_MODE_SIZE (TYPE_MODE (type
)))
197 /* There is supposed to be some integral type
198 that is the same width as a pointer. */
200 return convert_to_pointer (type
, expr
);
203 cp_error ("cannot convert `%E' from type `%T' to type `%T'",
205 return error_mark_node
;
208 /* Like convert, except permit conversions to take place which
209 are not normally allowed due to access restrictions
210 (such as conversion from sub-type to private super-type). */
212 convert_to_pointer_force (type
, expr
)
215 register tree intype
= TREE_TYPE (expr
);
216 register enum tree_code form
= TREE_CODE (intype
);
218 if (integer_zerop (expr
))
220 if (type
== TREE_TYPE (null_pointer_node
))
221 return null_pointer_node
;
222 expr
= build_int_2 (0, 0);
223 TREE_TYPE (expr
) = type
;
227 /* Convert signature pointer/reference to `void *' first. */
228 if (form
== RECORD_TYPE
229 && (IS_SIGNATURE_POINTER (intype
) || IS_SIGNATURE_REFERENCE (intype
)))
231 expr
= build_optr_ref (expr
);
232 intype
= TREE_TYPE (expr
);
233 form
= TREE_CODE (intype
);
236 if (form
== POINTER_TYPE
)
238 intype
= TYPE_MAIN_VARIANT (intype
);
240 if (TYPE_MAIN_VARIANT (type
) != intype
241 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
242 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
244 enum tree_code code
= PLUS_EXPR
;
246 int distance
= get_base_distance (TREE_TYPE (type
),
247 TREE_TYPE (intype
), 0, &path
);
251 cp_error ("type `%T' is ambiguous baseclass of `%s'", TREE_TYPE (type
),
252 TYPE_NAME_STRING (TREE_TYPE (intype
)));
253 return error_mark_node
;
257 distance
= get_base_distance (TREE_TYPE (intype
),
258 TREE_TYPE (type
), 0, &path
);
262 /* Doesn't need any special help from us. */
263 return build1 (NOP_EXPR
, type
, expr
);
267 return build_vbase_path (code
, type
, expr
, path
, 0);
269 return build1 (NOP_EXPR
, type
, expr
);
272 return cp_convert_to_pointer (type
, expr
);
275 /* We are passing something to a function which requires a reference.
276 The type we are interested in is in TYPE. The initial
277 value we have to begin with is in ARG.
279 FLAGS controls how we manage access checking.
280 CHECKCONST controls if we report error messages on const subversion. */
282 build_up_reference (type
, arg
, flags
, checkconst
)
284 int flags
, checkconst
;
287 int literal_flag
= 0;
288 tree argtype
= TREE_TYPE (arg
);
289 tree target_type
= TREE_TYPE (type
);
290 tree binfo
= NULL_TREE
;
292 my_friendly_assert (TREE_CODE (type
) == REFERENCE_TYPE
, 187);
293 if ((flags
& LOOKUP_PROTECT
)
294 && TYPE_MAIN_VARIANT (argtype
) != TYPE_MAIN_VARIANT (target_type
)
295 && IS_AGGR_TYPE (argtype
)
296 && IS_AGGR_TYPE (target_type
))
298 binfo
= get_binfo (target_type
, argtype
, 1);
299 if (binfo
== error_mark_node
)
300 return error_mark_node
;
301 if (binfo
== NULL_TREE
)
302 return error_not_base_type (target_type
, argtype
);
305 /* Pass along const and volatile down into the type. */
306 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
))
307 target_type
= cp_build_type_variant (target_type
, TYPE_READONLY (type
),
308 TYPE_VOLATILE (type
));
310 if (TREE_CODE (targ
) == SAVE_EXPR
)
311 targ
= TREE_OPERAND (targ
, 0);
312 while (TREE_CODE (targ
) == NOP_EXPR
313 && (TYPE_MAIN_VARIANT (argtype
)
314 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (targ
, 0)))))
315 targ
= TREE_OPERAND (targ
, 0);
317 switch (TREE_CODE (targ
))
320 /* This is a call to a constructor which did not know what it was
321 initializing until now: it needs to initialize a temporary. */
322 if (TREE_HAS_CONSTRUCTOR (targ
))
324 tree temp
= build_cplus_new (argtype
, TREE_OPERAND (targ
, 0), 1);
325 TREE_HAS_CONSTRUCTOR (targ
) = 0;
326 return build_up_reference (type
, temp
, flags
, 1);
328 /* Let &* cancel out to simplify resulting code.
329 Also, throw away intervening NOP_EXPRs. */
330 arg
= TREE_OPERAND (targ
, 0);
331 if (TREE_CODE (arg
) == NOP_EXPR
|| TREE_CODE (arg
) == NON_LVALUE_EXPR
332 || (TREE_CODE (arg
) == CONVERT_EXPR
&& TREE_REFERENCE_EXPR (arg
)))
333 arg
= TREE_OPERAND (arg
, 0);
335 /* in doing a &*, we have to get rid of the const'ness on the pointer
336 value. Haven't thought about volatile here. Pointers come to mind
338 if (TREE_READONLY (arg
))
340 arg
= copy_node (arg
);
341 TREE_READONLY (arg
) = 0;
344 rval
= build1 (CONVERT_EXPR
, type
, arg
);
345 TREE_REFERENCE_EXPR (rval
) = 1;
347 /* propagate the const flag on something like:
354 class Derived : public Base {
361 void func2(const Derived& d) {
365 on the d parameter. The below could have been avoided, if the flags
366 were down in the tree, not sure why they are not. (mrs) */
367 /* The below code may have to be propagated to other parts of this
369 if (TREE_READONLY (targ
) && !TREE_READONLY (arg
)
370 && (TREE_CODE (arg
) == PARM_DECL
|| TREE_CODE (arg
) == VAR_DECL
)
371 && TREE_CODE (TREE_TYPE (arg
)) == REFERENCE_TYPE
372 && (TYPE_READONLY (target_type
) && checkconst
))
374 arg
= copy_node (arg
);
375 TREE_READONLY (arg
) = TREE_READONLY (targ
);
377 literal_flag
= TREE_CONSTANT (arg
);
381 /* Get this out of a register if we happened to be in one by accident.
382 Also, build up references to non-lvalues it we must. */
383 /* For &x[y], return (&) x+y */
385 if (mark_addressable (TREE_OPERAND (targ
, 0)) == 0)
386 return error_mark_node
;
387 rval
= build_binary_op (PLUS_EXPR
, TREE_OPERAND (targ
, 0),
388 TREE_OPERAND (targ
, 1), 1);
389 TREE_TYPE (rval
) = type
;
390 if (TREE_CONSTANT (TREE_OPERAND (targ
, 1))
391 && staticp (TREE_OPERAND (targ
, 0)))
392 TREE_CONSTANT (rval
) = 1;
396 /* Could be a reference to a static member. */
398 tree field
= TREE_OPERAND (targ
, 1);
399 if (TREE_STATIC (field
))
401 rval
= build1 (ADDR_EXPR
, type
, field
);
407 /* We should have farmed out member pointers above. */
408 my_friendly_abort (188);
411 rval
= build_component_addr (targ
, build_pointer_type (argtype
),
412 "attempt to make a reference to bit-field structure member `%s'");
413 TREE_TYPE (rval
) = type
;
414 literal_flag
= staticp (TREE_OPERAND (targ
, 0));
418 /* Anything not already handled and not a true memory reference
419 needs to have a reference built up. Do so silently for
420 things like integers and return values from function,
421 but complain if we need a reference to something declared
427 TREE_ADDRESSABLE (targ
) = 1;
428 put_var_into_stack (targ
);
433 if (targ
== current_class_decl
)
435 error ("address of `this' not available");
437 /* This code makes the following core dump the compiler on a sun4,
438 if the code below is used.
442 typedef a_decl* a_ref;
447 void* append(a_ref& item);
451 a_decl (e_decl *parent);
465 a_decl::a_decl(e_decl *parent) {
466 parent->implementations.append(this);
470 TREE_ADDRESSABLE (targ
) = 1; /* so compiler doesn't die later */
471 put_var_into_stack (targ
);
474 return error_mark_node
;
481 if (DECL_REGISTER (targ
) && !TREE_ADDRESSABLE (targ
)
482 && !DECL_ARTIFICIAL (targ
))
483 cp_warning ("address needed to build reference for `%D', which is declared `register'",
485 else if (staticp (targ
))
488 TREE_ADDRESSABLE (targ
) = 1;
489 put_var_into_stack (targ
);
494 tree real_reference
= build_up_reference (type
, TREE_OPERAND (targ
, 1),
495 LOOKUP_PROTECT
, checkconst
);
496 rval
= build (COMPOUND_EXPR
, type
, TREE_OPERAND (targ
, 0), real_reference
);
497 TREE_CONSTANT (rval
) = staticp (TREE_OPERAND (targ
, 1));
501 case PREINCREMENT_EXPR
:
502 case PREDECREMENT_EXPR
:
506 tree real_reference
= build_up_reference (type
, TREE_OPERAND (targ
, 0),
507 LOOKUP_PROTECT
, checkconst
);
508 rval
= build (COMPOUND_EXPR
, type
, arg
, real_reference
);
509 TREE_CONSTANT (rval
) = staticp (TREE_OPERAND (targ
, 0));
514 return build (COND_EXPR
, type
,
515 TREE_OPERAND (targ
, 0),
516 build_up_reference (type
, TREE_OPERAND (targ
, 1),
517 LOOKUP_PROTECT
, checkconst
),
518 build_up_reference (type
, TREE_OPERAND (targ
, 2),
519 LOOKUP_PROTECT
, checkconst
));
521 case WITH_CLEANUP_EXPR
:
522 return build (WITH_CLEANUP_EXPR
, type
,
523 build_up_reference (type
, TREE_OPERAND (targ
, 0),
524 LOOKUP_PROTECT
, checkconst
),
525 0, TREE_OPERAND (targ
, 2));
528 arg
= TREE_OPERAND (targ
, 1);
529 if (arg
== NULL_TREE
)
531 compiler_error ("({ ... }) expression not expanded when needed for reference");
532 return error_mark_node
;
534 rval
= build1 (ADDR_EXPR
, type
, arg
);
535 TREE_REFERENCE_EXPR (rval
) = 1;
542 if (TREE_ADDRESSABLE (targ
) == 0)
546 if (TREE_CODE (targ
) == CALL_EXPR
&& IS_AGGR_TYPE (argtype
))
548 temp
= build_cplus_new (argtype
, targ
, 1);
549 if (TREE_CODE (temp
) == WITH_CLEANUP_EXPR
)
550 rval
= build (WITH_CLEANUP_EXPR
, type
,
551 build1 (ADDR_EXPR
, type
, TREE_OPERAND (temp
, 0)),
552 0, TREE_OPERAND (temp
, 2));
554 rval
= build1 (ADDR_EXPR
, type
, temp
);
559 temp
= get_temp_name (argtype
, 0);
560 if (global_bindings_p ())
562 /* Give this new temp some rtl and initialize it. */
563 DECL_INITIAL (temp
) = targ
;
564 TREE_STATIC (temp
) = 1;
565 finish_decl (temp
, targ
, NULL_TREE
, 0, LOOKUP_ONLYCONVERTING
);
566 /* Do this after declaring it static. */
567 rval
= build_unary_op (ADDR_EXPR
, temp
, 0);
568 TREE_TYPE (rval
) = type
;
569 literal_flag
= TREE_CONSTANT (rval
);
574 rval
= build_unary_op (ADDR_EXPR
, temp
, 0);
575 if (binfo
&& !BINFO_OFFSET_ZEROP (binfo
))
576 rval
= convert_pointer_to (target_type
, rval
);
578 TREE_TYPE (rval
) = type
;
580 temp
= build (MODIFY_EXPR
, argtype
, temp
, arg
);
581 TREE_SIDE_EFFECTS (temp
) = 1;
582 return build (COMPOUND_EXPR
, type
, temp
, rval
);
587 rval
= build1 (ADDR_EXPR
, type
, arg
);
590 if (TYPE_USES_COMPLEX_INHERITANCE (argtype
)
591 || TYPE_USES_COMPLEX_INHERITANCE (target_type
))
593 TREE_TYPE (rval
) = build_pointer_type (argtype
);
594 if (flags
& LOOKUP_PROTECT
)
595 rval
= convert_pointer_to (target_type
, rval
);
598 = convert_to_pointer_force (build_pointer_type (target_type
), rval
);
599 TREE_TYPE (rval
) = type
;
601 TREE_CONSTANT (rval
) = literal_flag
;
605 /* For C++: Only need to do one-level references, but cannot
606 get tripped up on signed/unsigned differences.
608 DECL is either NULL_TREE or the _DECL node for a reference that is being
609 initialized. It can be error_mark_node if we don't know the _DECL but
610 we know it's an initialization. */
613 convert_to_reference (reftype
, expr
, convtype
, flags
, decl
)
618 register tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (reftype
));
619 register tree intype
= TREE_TYPE (expr
);
620 register enum tree_code form
= TREE_CODE (intype
);
621 tree rval
= NULL_TREE
;
623 if (form
== REFERENCE_TYPE
)
624 intype
= TREE_TYPE (intype
);
625 intype
= TYPE_MAIN_VARIANT (intype
);
627 if (((convtype
& CONV_STATIC
) && comptypes (type
, intype
, -1))
628 || ((convtype
& CONV_IMPLICIT
) && comptypes (type
, intype
, 0)))
630 if (flags
& LOOKUP_COMPLAIN
)
632 tree ttl
= TREE_TYPE (reftype
);
635 if (form
== REFERENCE_TYPE
)
636 ttr
= TREE_TYPE (TREE_TYPE (expr
));
639 int r
= TREE_READONLY (expr
);
640 int v
= TREE_THIS_VOLATILE (expr
);
641 ttr
= cp_build_type_variant (TREE_TYPE (expr
), r
, v
);
644 if (! lvalue_p (expr
) &&
645 (decl
== NULL_TREE
|| ! TYPE_READONLY (ttl
)))
648 /* Ensure semantics of [dcl.init.ref] */
649 cp_pedwarn ("initialization of non-const `%T' from rvalue `%T'",
652 cp_pedwarn ("conversion to `%T' from rvalue `%T'",
655 else if (! (convtype
& CONV_CONST
))
657 if (! TYPE_READONLY (ttl
) && TYPE_READONLY (ttr
))
658 cp_pedwarn ("conversion from `%T' to `%T' discards const",
660 else if (! TYPE_VOLATILE (ttl
) && TYPE_VOLATILE (ttr
))
661 cp_pedwarn ("conversion from `%T' to `%T' discards volatile",
666 if (form
== REFERENCE_TYPE
)
668 tree type
= TREE_TYPE (expr
);
669 tree tmp
= copy_node (expr
);
670 TREE_TYPE (tmp
) = build_pointer_type (TREE_TYPE (TREE_TYPE (expr
)));
671 rval
= cp_convert (build_pointer_type (TREE_TYPE (reftype
)), tmp
,
673 TREE_TYPE (tmp
) = type
;
674 TREE_TYPE (rval
) = reftype
;
678 return build_up_reference (reftype
, expr
, flags
,
679 ! (convtype
& CONV_CONST
));
682 if ((convtype
& CONV_IMPLICIT
)
683 && IS_AGGR_TYPE (intype
)
684 && ! (flags
& LOOKUP_NO_CONVERSION
)
685 && (rval
= build_type_conversion (CONVERT_EXPR
, reftype
, expr
, 1)))
687 if (rval
== error_mark_node
)
688 cp_error ("conversion from `%T' to `%T' is ambiguous",
692 else if ((convtype
& CONV_REINTERPRET
) && lvalue_p (expr
))
694 /* When casting an lvalue to a reference type, just convert into
695 a pointer to the new type and deference it. This is allowed
696 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
697 should be done directly (jason). (int &)ri ---> *(int*)&ri */
699 /* B* bp; A& ar = (A&)bp; is legal, but it's probably not what they
701 if (form
== POINTER_TYPE
702 && (comptypes (TREE_TYPE (intype
), type
, -1)))
703 cp_warning ("casting `%T' to `%T' does not dereference pointer",
706 rval
= build_unary_op (ADDR_EXPR
, expr
, 0);
707 if (rval
!= error_mark_node
)
708 rval
= convert_force (build_pointer_type (TREE_TYPE (reftype
)), rval
, 0);
709 if (rval
!= error_mark_node
)
710 rval
= build1 (NOP_EXPR
, reftype
, rval
);
714 tree rval_as_conversion
= NULL_TREE
;
715 tree rval_as_ctor
= NULL_TREE
;
717 if (IS_AGGR_TYPE (intype
)
718 && (rval
= build_type_conversion (CONVERT_EXPR
, type
, expr
, 1)))
720 if (rval
== error_mark_node
)
723 rval_as_conversion
= build_up_reference (reftype
, rval
, flags
, 1);
726 /* Definitely need to go through a constructor here. */
727 if (TYPE_HAS_CONSTRUCTOR (type
)
728 && ! CLASSTYPE_ABSTRACT_VIRTUALS (type
)
729 && (rval
= build_method_call
730 (NULL_TREE
, constructor_name_full (type
),
731 build_tree_list (NULL_TREE
, expr
), TYPE_BINFO (type
),
732 LOOKUP_NO_CONVERSION
|LOOKUP_SPECULATIVELY
733 | LOOKUP_ONLYCONVERTING
)))
737 if (global_bindings_p ())
739 extern tree static_aggregates
;
740 tree t
= get_temp_name (type
, global_bindings_p ());
741 init
= build_method_call (t
, constructor_name_full (type
),
742 build_tree_list (NULL_TREE
, expr
),
744 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
745 | LOOKUP_ONLYCONVERTING
);
747 if (init
== error_mark_node
)
748 return error_mark_node
;
750 make_decl_rtl (t
, NULL_PTR
, 1);
751 static_aggregates
= perm_tree_cons (expr
, t
, static_aggregates
);
752 rval
= build_unary_op (ADDR_EXPR
, t
, 0);
756 init
= build_method_call (NULL_TREE
, constructor_name_full (type
),
757 build_tree_list (NULL_TREE
, expr
),
759 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
760 |LOOKUP_ONLYCONVERTING
);
762 if (init
== error_mark_node
)
763 return error_mark_node
;
765 rval
= build_cplus_new (type
, init
, 1);
766 rval
= build_up_reference (reftype
, rval
, flags
, 1);
771 if (rval_as_ctor
&& rval_as_conversion
)
773 cp_error ("ambiguous conversion from `%T' to `%T'; both user-defined conversion and constructor apply",
775 return error_mark_node
;
777 else if (rval_as_ctor
)
779 else if (rval_as_conversion
)
780 rval
= rval_as_conversion
;
781 else if (! IS_AGGR_TYPE (type
) && ! IS_AGGR_TYPE (intype
))
783 rval
= convert (type
, expr
);
784 if (rval
== error_mark_node
)
785 return error_mark_node
;
787 rval
= build_up_reference (reftype
, rval
, flags
, 1);
790 if (rval
&& ! TYPE_READONLY (TREE_TYPE (reftype
)))
791 cp_pedwarn ("initializing non-const `%T' with `%T' will use a temporary",
797 /* If we found a way to convert earlier, then use it. */
801 my_friendly_assert (form
!= OFFSET_TYPE
, 189);
803 if (flags
& LOOKUP_SPECULATIVELY
)
806 else if (flags
& LOOKUP_COMPLAIN
)
807 cp_error ("cannot convert type `%T' to type `%T'", intype
, reftype
);
809 return error_mark_node
;
812 /* We are using a reference VAL for its value. Bash that reference all the
813 way down to its lowest form. */
815 convert_from_reference (val
)
818 tree type
= TREE_TYPE (val
);
820 if (TREE_CODE (type
) == OFFSET_TYPE
)
821 type
= TREE_TYPE (type
);
822 if (TREE_CODE (type
) == REFERENCE_TYPE
)
824 tree target_type
= TREE_TYPE (type
);
827 /* This can happen if we cast to a reference type. */
828 if (TREE_CODE (val
) == ADDR_EXPR
)
830 nval
= build1 (NOP_EXPR
, build_pointer_type (target_type
), val
);
831 nval
= build_indirect_ref (nval
, NULL_PTR
);
832 /* The below was missing, are other important flags missing too? */
833 TREE_SIDE_EFFECTS (nval
) = TREE_SIDE_EFFECTS (val
);
837 nval
= build1 (INDIRECT_REF
, target_type
, val
);
839 TREE_THIS_VOLATILE (nval
) = TYPE_VOLATILE (target_type
);
840 TREE_SIDE_EFFECTS (nval
) = TYPE_VOLATILE (target_type
);
841 TREE_READONLY (nval
) = TYPE_READONLY (target_type
);
842 /* The below was missing, are other important flags missing too? */
843 TREE_SIDE_EFFECTS (nval
) |= TREE_SIDE_EFFECTS (val
);
849 /* See if there is a constructor of type TYPE which will convert
850 EXPR. The reference manual seems to suggest (8.5.6) that we need
851 not worry about finding constructors for base classes, then converting
852 to the derived class.
854 MSGP is a pointer to a message that would be an appropriate error
855 string. If MSGP is NULL, then we are not interested in reporting
858 convert_to_aggr (type
, expr
, msgp
, protect
)
863 tree basetype
= type
;
864 tree name
= TYPE_IDENTIFIER (basetype
);
865 tree function
, fndecl
, fntype
, parmtypes
, parmlist
, result
;
867 enum access_type access
;
868 int can_be_private
, can_be_protected
;
870 if (! TYPE_HAS_CONSTRUCTOR (basetype
))
873 *msgp
= "type `%s' does not have a constructor";
874 return error_mark_node
;
877 access
= access_public
;
879 can_be_protected
= IDENTIFIER_CLASS_VALUE (name
) || name
== current_class_name
;
881 parmlist
= build_tree_list (NULL_TREE
, expr
);
882 parmtypes
= tree_cons (NULL_TREE
, TREE_TYPE (expr
), void_list_node
);
884 if (TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
886 parmtypes
= tree_cons (NULL_TREE
, integer_type_node
, parmtypes
);
887 parmlist
= tree_cons (NULL_TREE
, integer_one_node
, parmlist
);
890 /* The type of the first argument will be filled in inside the loop. */
891 parmlist
= tree_cons (NULL_TREE
, integer_zero_node
, parmlist
);
892 parmtypes
= tree_cons (NULL_TREE
, TYPE_POINTER_TO (basetype
), parmtypes
);
894 method_name
= build_decl_overload (name
, parmtypes
, 1);
896 /* constructors are up front. */
897 fndecl
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0);
898 if (TYPE_HAS_DESTRUCTOR (basetype
))
899 fndecl
= DECL_CHAIN (fndecl
);
903 if (DECL_ASSEMBLER_NAME (fndecl
) == method_name
)
908 if (TREE_PRIVATE (fndecl
))
911 (basetype
== current_class_type
912 || is_friend (basetype
, current_function_decl
)
913 || purpose_member (basetype
, DECL_ACCESS (fndecl
)));
914 if (! can_be_private
)
917 else if (TREE_PROTECTED (fndecl
))
919 if (! can_be_protected
)
925 fndecl
= DECL_CHAIN (fndecl
);
928 /* No exact conversion was found. See if an approximate
930 fndecl
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype
), 0);
931 if (TYPE_HAS_DESTRUCTOR (basetype
))
932 fndecl
= DECL_CHAIN (fndecl
);
936 int saw_protected
= 0;
937 struct candidate
*candidates
=
938 (struct candidate
*) alloca ((decl_list_length (fndecl
)+1) * sizeof (struct candidate
));
939 struct candidate
*cp
= candidates
;
945 cp
->harshness
= (struct harshness_code
*)
946 alloca (3 * sizeof (struct harshness_code
));
948 compute_conversion_costs (fndecl
, parmlist
, cp
, 2);
949 if ((cp
->h
.code
& EVIL_CODE
) == 0)
951 cp
->u
.field
= fndecl
;
954 if (TREE_PRIVATE (fndecl
))
955 access
= access_private
;
956 else if (TREE_PROTECTED (fndecl
))
957 access
= access_protected
;
959 access
= access_public
;
962 access
= access_public
;
964 if (access
== access_private
965 ? (basetype
== current_class_type
966 || is_friend (basetype
, cp
->function
)
967 || purpose_member (basetype
, DECL_ACCESS (fndecl
)))
968 : access
== access_protected
970 || purpose_member (basetype
, DECL_ACCESS (fndecl
)))
973 if (cp
->h
.code
<= TRIVIAL_CODE
)
979 if (access
== access_private
)
985 fndecl
= DECL_CHAIN (fndecl
);
989 /* Rank from worst to best. Then cp will point to best one.
990 Private fields have their bits flipped. For unsigned
991 numbers, this should make them look very large.
992 If the best alternate has a (signed) negative value,
993 then all we ever saw were private members. */
994 if (cp
- candidates
> 1)
995 qsort (candidates
, /* char *base */
996 cp
- candidates
, /* int nel */
997 sizeof (struct candidate
), /* int width */
998 rank_for_overload
); /* int (*compar)() */
1001 if (cp
->h
.code
& EVIL_CODE
)
1004 *msgp
= "ambiguous type conversion possible for `%s'";
1005 return error_mark_node
;
1008 function
= cp
->function
;
1009 fndecl
= cp
->u
.field
;
1016 *msgp
= "only private and protected conversions apply";
1018 *msgp
= "only private conversions apply";
1019 else if (saw_protected
)
1020 *msgp
= "only protected conversions apply";
1022 *msgp
= "no appropriate conversion to type `%s'";
1024 return error_mark_node
;
1029 if (access
== access_private
)
1030 if (! can_be_private
)
1033 *msgp
= TREE_PRIVATE (fndecl
)
1034 ? "conversion to type `%s' is private"
1035 : "conversion to type `%s' is from private base class";
1036 return error_mark_node
;
1038 if (access
== access_protected
)
1039 if (! can_be_protected
)
1042 *msgp
= TREE_PRIVATE (fndecl
)
1043 ? "conversion to type `%s' is protected"
1044 : "conversion to type `%s' is from protected base class";
1045 return error_mark_node
;
1050 /* It will convert, but we don't do anything about it yet. */
1054 fntype
= TREE_TYPE (function
);
1055 if (DECL_INLINE (function
) && TREE_CODE (function
) == FUNCTION_DECL
)
1056 function
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), function
);
1058 function
= default_conversion (function
);
1060 result
= build_nt (CALL_EXPR
, function
,
1061 convert_arguments (NULL_TREE
, TYPE_ARG_TYPES (fntype
),
1062 parmlist
, NULL_TREE
, LOOKUP_NORMAL
),
1064 TREE_TYPE (result
) = TREE_TYPE (fntype
);
1065 TREE_SIDE_EFFECTS (result
) = 1;
1069 /* Call this when we know (for any reason) that expr is not, in fact,
1070 zero. This routine is like convert_pointer_to, but it pays
1071 attention to which specific instance of what type we want to
1072 convert to. This routine should eventually become
1073 convert_to_pointer after all references to convert_to_pointer
1076 convert_pointer_to_real (binfo
, expr
)
1079 register tree intype
= TREE_TYPE (expr
);
1083 if (TREE_CODE (binfo
) == TREE_VEC
)
1084 type
= BINFO_TYPE (binfo
);
1085 else if (IS_AGGR_TYPE (binfo
))
1095 ptr_type
= build_pointer_type (type
);
1096 if (ptr_type
== TYPE_MAIN_VARIANT (intype
))
1099 if (intype
== error_mark_node
)
1100 return error_mark_node
;
1102 my_friendly_assert (!integer_zerop (expr
), 191);
1104 if (TREE_CODE (type
) == RECORD_TYPE
1105 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
1106 && type
!= TYPE_MAIN_VARIANT (TREE_TYPE (intype
)))
1110 = get_base_distance (binfo
, TYPE_MAIN_VARIANT (TREE_TYPE (intype
)),
1113 /* This function shouldn't be called with unqualified arguments
1114 but if it is, give them an error message that they can read. */
1117 cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
1118 TREE_TYPE (intype
), type
);
1121 cp_error ("because `%T' is an ambiguous base class", type
);
1122 return error_mark_node
;
1125 return build_vbase_path (PLUS_EXPR
, ptr_type
, expr
, path
, 1);
1127 rval
= build1 (NOP_EXPR
, ptr_type
,
1128 TREE_CODE (expr
) == NOP_EXPR
? TREE_OPERAND (expr
, 0) : expr
);
1129 TREE_CONSTANT (rval
) = TREE_CONSTANT (expr
);
1133 /* Call this when we know (for any reason) that expr is
1134 not, in fact, zero. This routine gets a type out of the first
1135 argument and uses it to search for the type to convert to. If there
1136 is more than one instance of that type in the expr, the conversion is
1137 ambiguous. This routine should eventually go away, and all
1138 callers should use convert_to_pointer_real. */
1140 convert_pointer_to (binfo
, expr
)
1145 if (TREE_CODE (binfo
) == TREE_VEC
)
1146 type
= BINFO_TYPE (binfo
);
1147 else if (IS_AGGR_TYPE (binfo
))
1151 return convert_pointer_to_real (type
, expr
);
1154 /* Same as above, but don't abort if we get an "ambiguous" baseclass.
1155 There's only one virtual baseclass we are looking for, and once
1156 we find one such virtual baseclass, we have found them all. */
1159 convert_pointer_to_vbase (binfo
, expr
)
1163 tree intype
= TREE_TYPE (TREE_TYPE (expr
));
1164 tree binfos
= TYPE_BINFO_BASETYPES (intype
);
1167 for (i
= TREE_VEC_LENGTH (binfos
)-1; i
>= 0; i
--)
1169 tree basetype
= BINFO_TYPE (TREE_VEC_ELT (binfos
, i
));
1170 if (BINFO_TYPE (binfo
) == basetype
)
1171 return convert_pointer_to (binfo
, expr
);
1172 if (binfo_member (BINFO_TYPE (binfo
), CLASSTYPE_VBASECLASSES (basetype
)))
1173 return convert_pointer_to_vbase (binfo
, convert_pointer_to (basetype
, expr
));
1175 my_friendly_abort (6);
1181 cp_convert (type
, expr
, convtype
, flags
)
1183 int convtype
, flags
;
1185 register tree e
= expr
;
1186 register enum tree_code code
= TREE_CODE (type
);
1188 if (TREE_CODE (e
) == ERROR_MARK
1189 || TREE_CODE (TREE_TYPE (e
)) == ERROR_MARK
)
1190 return error_mark_node
;
1192 /* Trivial conversion: cv-qualifiers do not matter on rvalues. */
1193 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (e
)))
1194 return fold (build1 (NOP_EXPR
, type
, e
));
1196 if (code
== VOID_TYPE
&& (convtype
& CONV_STATIC
))
1197 return build1 (CONVERT_EXPR
, type
, e
);
1200 /* This is incorrect. A truncation can't be stripped this way.
1201 Extensions will be stripped by the use of get_unwidened. */
1202 if (TREE_CODE (e
) == NOP_EXPR
)
1203 return convert (type
, TREE_OPERAND (e
, 0));
1206 /* Just convert to the type of the member. */
1207 if (code
== OFFSET_TYPE
)
1209 type
= TREE_TYPE (type
);
1210 code
= TREE_CODE (type
);
1213 if (code
== REFERENCE_TYPE
)
1214 return fold (convert_to_reference (type
, e
, convtype
, flags
, NULL_TREE
));
1215 else if (TREE_CODE (TREE_TYPE (e
)) == REFERENCE_TYPE
)
1216 e
= convert_from_reference (e
);
1218 if (TREE_CODE (e
) == OFFSET_REF
)
1219 e
= resolve_offset_ref (e
);
1221 if (TREE_READONLY_DECL_P (e
))
1222 e
= decl_constant_value (e
);
1224 if (INTEGRAL_CODE_P (code
))
1226 tree intype
= TREE_TYPE (e
);
1227 enum tree_code form
= TREE_CODE (intype
);
1228 /* enum = enum, enum = int, enum = float are all errors. */
1229 if (flag_int_enum_equivalence
== 0
1230 && TREE_CODE (type
) == ENUMERAL_TYPE
1231 && ARITHMETIC_TYPE_P (intype
)
1232 && ! (convtype
& CONV_STATIC
))
1234 cp_pedwarn ("conversion from `%#T' to `%#T'", intype
, type
);
1236 if (flag_pedantic_errors
)
1237 return error_mark_node
;
1239 if (IS_AGGR_TYPE (intype
))
1242 rval
= build_type_conversion (CONVERT_EXPR
, type
, e
, 1);
1245 cp_error ("`%#T' used where a `%T' was expected", intype
, type
);
1246 return error_mark_node
;
1248 if (code
== BOOLEAN_TYPE
)
1250 tree newe
= truthvalue_conversion (e
);
1251 /* Avoid stupid (infinite) recursion from backend. */
1252 if (TREE_CODE (newe
) != NOP_EXPR
|| e
!= TREE_OPERAND (newe
, 0))
1254 if (TREE_TYPE (e
) == bool_type_node
)
1256 else if (TREE_CODE (e
) == INTEGER_CST
)
1258 if (e
== integer_zero_node
)
1264 return build1 (NOP_EXPR
, bool_type_node
, e
);
1266 return fold (convert_to_integer (type
, e
));
1268 if (code
== POINTER_TYPE
)
1269 return fold (cp_convert_to_pointer (type
, e
));
1270 if (code
== REAL_TYPE
)
1272 if (IS_AGGR_TYPE (TREE_TYPE (e
)))
1275 rval
= build_type_conversion (CONVERT_EXPR
, type
, e
, 1);
1279 cp_error ("`%#T' used where a floating point value was expected",
1282 return fold (convert_to_real (type
, e
));
1285 /* New C++ semantics: since assignment is now based on
1286 memberwise copying, if the rhs type is derived from the
1287 lhs type, then we may still do a conversion. */
1288 if (IS_AGGR_TYPE_CODE (code
))
1290 tree dtype
= TREE_TYPE (e
);
1291 tree ctor
= NULL_TREE
;
1292 tree conversion
= NULL_TREE
;
1294 dtype
= TYPE_MAIN_VARIANT (dtype
);
1296 /* Conversion of object pointers or signature pointers/references
1297 to signature pointers/references. */
1299 if (TYPE_LANG_SPECIFIC (type
)
1300 && (IS_SIGNATURE_POINTER (type
) || IS_SIGNATURE_REFERENCE (type
)))
1302 tree constructor
= build_signature_pointer_constructor (type
, expr
);
1303 tree sig_ty
= SIGNATURE_TYPE (type
);
1306 if (constructor
== error_mark_node
)
1307 return error_mark_node
;
1309 sig_ptr
= get_temp_name (type
, 1);
1310 DECL_INITIAL (sig_ptr
) = constructor
;
1311 CLEAR_SIGNATURE (sig_ty
);
1312 finish_decl (sig_ptr
, constructor
, NULL_TREE
, 0, 0);
1313 SET_SIGNATURE (sig_ty
);
1314 TREE_READONLY (sig_ptr
) = 1;
1319 /* Conversion between aggregate types. New C++ semantics allow
1320 objects of derived type to be cast to objects of base type.
1321 Old semantics only allowed this between pointers.
1323 There may be some ambiguity between using a constructor
1324 vs. using a type conversion operator when both apply. */
1326 if (IS_AGGR_TYPE (dtype
) && ! DERIVED_FROM_P (type
, dtype
)
1327 && TYPE_HAS_CONVERSION (dtype
))
1328 conversion
= build_type_conversion (CONVERT_EXPR
, type
, e
, 1);
1330 if (conversion
== error_mark_node
)
1332 error ("ambiguous pointer conversion");
1336 if (TYPE_HAS_CONSTRUCTOR (type
))
1337 ctor
= build_method_call (NULL_TREE
, constructor_name_full (type
),
1338 build_tree_list (NULL_TREE
, e
),
1340 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
1341 | (convtype
&CONV_NONCONVERTING
? 0 : LOOKUP_ONLYCONVERTING
)
1342 | (conversion
? LOOKUP_NO_CONVERSION
: 0));
1344 if (ctor
== error_mark_node
)
1346 cp_error ("in conversion to type `%T'", type
);
1347 return error_mark_node
;
1350 if (conversion
&& ctor
)
1352 error ("both constructor and type conversion operator apply");
1353 return error_mark_node
;
1355 else if (conversion
)
1359 if (current_function_decl
)
1360 /* We can't pass 1 to the with_cleanup_p arg here, because that
1361 screws up passing classes by value. */
1362 ctor
= build_cplus_new (type
, ctor
, 0);
1365 register tree parm
= TREE_OPERAND (ctor
, 1);
1367 /* Initializers for static variables and parameters
1368 have to handle doing the initialization and
1369 cleanup themselves. */
1370 my_friendly_assert (TREE_CODE (ctor
) == CALL_EXPR
, 322);
1372 /* The following assertion fails in cases where we
1373 are initializing a static member variable of a
1374 particular instance of a template class with a
1375 call to a constructor of the given instance, as
1378 TMPL<int> object = TMPL<int>();
1380 Curiously, the assertion does not fail if we do
1381 the same thing for a static member of a
1382 non-template class, as in:
1386 I can't see why we should care here whether or not
1387 the initializer expression involves a call to
1388 `new', so for the time being, it seems best to
1389 just avoid doing this assertion. */
1390 my_friendly_assert (TREE_CALLS_NEW (TREE_VALUE (parm
)),
1393 TREE_VALUE (parm
) = NULL_TREE
;
1394 ctor
= build_indirect_ref (ctor
, NULL_PTR
);
1395 TREE_HAS_CONSTRUCTOR (ctor
) = 1;
1401 /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
1402 then the it won't be hashed and hence compare as not equal,
1404 if (code
== ARRAY_TYPE
1405 && TREE_TYPE (TREE_TYPE (e
)) == TREE_TYPE (type
)
1406 && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e
)), TYPE_DOMAIN (type
)))
1409 cp_error ("conversion from `%T' to non-scalar type `%T' requested",
1410 TREE_TYPE (expr
), type
);
1411 return error_mark_node
;
1414 /* Create an expression whose value is that of EXPR,
1415 converted to type TYPE. The TREE_TYPE of the value
1416 is always TYPE. This function implements all reasonable
1417 conversions; callers should filter out those that are
1418 not permitted by the language being compiled. */
1421 convert (type
, expr
)
1424 return cp_convert (type
, expr
, CONV_OLD_CONVERT
, 0);
1427 /* Like convert, except permit conversions to take place which
1428 are not normally allowed due to access restrictions
1429 (such as conversion from sub-type to private super-type). */
1431 convert_force (type
, expr
, convtype
)
1436 register tree e
= expr
;
1437 register enum tree_code code
= TREE_CODE (type
);
1439 if (code
== REFERENCE_TYPE
)
1440 return fold (convert_to_reference (type
, e
, CONV_C_CAST
, LOOKUP_COMPLAIN
,
1442 else if (TREE_CODE (TREE_TYPE (e
)) == REFERENCE_TYPE
)
1443 e
= convert_from_reference (e
);
1445 if (code
== POINTER_TYPE
)
1446 return fold (convert_to_pointer_force (type
, e
));
1448 /* From typeck.c convert_for_assignment */
1449 if (((TREE_CODE (TREE_TYPE (e
)) == POINTER_TYPE
&& TREE_CODE (e
) == ADDR_EXPR
1450 && TREE_CODE (TREE_TYPE (e
)) == POINTER_TYPE
1451 && TREE_CODE (TREE_TYPE (TREE_TYPE (e
))) == METHOD_TYPE
)
1452 || integer_zerop (e
)
1453 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e
)))
1454 && TYPE_PTRMEMFUNC_P (type
))
1456 /* compatible pointer to member functions. */
1457 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), e
, 1);
1460 return cp_convert (type
, e
, CONV_OLD_CONVERT
|convtype
, 0);
1463 /* Subroutine of build_type_conversion. */
1465 build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
)
1466 tree xtype
, basetype
;
1475 flags
= LOOKUP_PROTECT
|LOOKUP_ONLYCONVERTING
;
1477 flags
= LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
;
1479 rval
= build_method_call (expr
, typename
, NULL_TREE
, NULL_TREE
, flags
);
1480 if (rval
== error_mark_node
)
1484 return error_mark_node
;
1486 if (TREE_CODE (TREE_TYPE (rval
)) == REFERENCE_TYPE
1487 && TREE_CODE (xtype
) != REFERENCE_TYPE
)
1488 rval
= default_conversion (rval
);
1491 && TREE_TYPE (xtype
)
1492 && (TREE_READONLY (TREE_TYPE (TREE_TYPE (rval
)))
1493 > TREE_READONLY (TREE_TYPE (xtype
))))
1494 warning ("user-defined conversion casting away `const'");
1495 return convert (xtype
, rval
);
1498 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1499 exists, return the attempted conversion. This may
1500 return ERROR_MARK_NODE if the conversion is not
1501 allowed (references private members, etc).
1502 If no conversion exists, NULL_TREE is returned.
1504 If (FOR_SURE & 1) is non-zero, then we allow this type conversion
1505 to take place immediately. Otherwise, we build a SAVE_EXPR
1506 which can be evaluated if the results are ever needed.
1508 If FOR_SURE >= 2, then we only look for exact conversions.
1510 TYPE may be a reference type, in which case we first look
1511 for something that will convert to a reference type. If
1512 that fails, we will try to look for something of the
1513 reference's target type, and then return a reference to that. */
1515 build_type_conversion (code
, xtype
, expr
, for_sure
)
1516 enum tree_code code
;
1520 /* C++: check to see if we can convert this aggregate type
1521 into the required scalar type. */
1522 tree type
, type_default
;
1523 tree typename
= build_typename_overload (xtype
), *typenames
;
1525 tree basetype
, save_basetype
;
1527 int exact_conversion
= for_sure
>= 2;
1530 if (expr
== error_mark_node
)
1531 return error_mark_node
;
1533 basetype
= TREE_TYPE (expr
);
1534 if (TREE_CODE (basetype
) == REFERENCE_TYPE
)
1535 basetype
= TREE_TYPE (basetype
);
1537 if (TYPE_PTRMEMFUNC_P (basetype
) && TREE_CODE (xtype
) == BOOLEAN_TYPE
)
1539 /* We convert a pointer to member function into a boolean,
1540 by just checking the index value, for == 0, we want false, for
1541 != 0, we want true. */
1542 return convert (xtype
, build_component_ref (expr
, index_identifier
, 0, 0));
1545 basetype
= TYPE_MAIN_VARIANT (basetype
);
1546 if (! TYPE_LANG_SPECIFIC (basetype
) || ! TYPE_HAS_CONVERSION (basetype
))
1549 if (TREE_CODE (xtype
) == POINTER_TYPE
1550 || TREE_CODE (xtype
) == REFERENCE_TYPE
)
1552 /* Prepare to match a variant of this type. */
1553 type
= TYPE_MAIN_VARIANT (TREE_TYPE (xtype
));
1554 for (n_variants
= 0; type
; type
= TYPE_NEXT_VARIANT (type
))
1556 typenames
= (tree
*)alloca (n_variants
* sizeof (tree
));
1557 for (n_variants
= 0, type
= TYPE_MAIN_VARIANT (TREE_TYPE (xtype
));
1558 type
; n_variants
++, type
= TYPE_NEXT_VARIANT (type
))
1560 if (type
== TREE_TYPE (xtype
))
1561 typenames
[n_variants
] = typename
;
1562 else if (TREE_CODE (xtype
) == POINTER_TYPE
)
1563 typenames
[n_variants
] = build_typename_overload (build_pointer_type (type
));
1565 typenames
[n_variants
] = build_typename_overload (build_reference_type (type
));
1569 save_basetype
= basetype
;
1572 while (TYPE_HAS_CONVERSION (basetype
))
1575 if (lookup_fnfields (TYPE_BINFO (basetype
), typename
, 0))
1576 return build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
);
1577 for (i
= 0; i
< n_variants
; i
++)
1578 if (typenames
[i
] != typename
1579 && lookup_fnfields (TYPE_BINFO (basetype
), typenames
[i
], 0))
1580 return build_type_conversion_1 (xtype
, basetype
, expr
, typenames
[i
], for_sure
);
1582 if (TYPE_BINFO_BASETYPES (basetype
))
1583 basetype
= TYPE_BINFO_BASETYPE (basetype
, 0);
1588 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1591 /* Only reference variable initializations can use a temporary; this
1592 must be handled elsewhere (like convert_to_reference and
1593 compute_conversion_costs). */
1595 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1596 typename
= build_typename_overload (type
);
1597 basetype
= save_basetype
;
1599 /* May need to build a temporary for this. */
1600 while (TYPE_HAS_CONVERSION (basetype
))
1602 if (lookup_fnfields (TYPE_BINFO (basetype
), typename
, 0))
1607 flags
= LOOKUP_PROTECT
|LOOKUP_ONLYCONVERTING
;
1609 flags
= LOOKUP_NORMAL
|LOOKUP_ONLYCONVERTING
;
1610 rval
= build_method_call (expr
,
1611 constructor_name_full (typename
),
1612 NULL_TREE
, NULL_TREE
, flags
);
1613 if (rval
== error_mark_node
)
1617 return error_mark_node
;
1620 return convert (xtype
, rval
);
1622 if (TYPE_BINFO_BASETYPES (basetype
))
1623 basetype
= TYPE_BINFO_BASETYPE (basetype
, 0);
1628 /* No free conversions for reference types, right?. */
1632 if (exact_conversion
)
1635 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
1637 tree as_int
= build_type_conversion (code
, long_long_unsigned_type_node
, expr
, 0);
1638 tree as_ptr
= build_type_conversion (code
, ptr_type_node
, expr
, 0);
1639 /* We are missing the conversion to pointer to member type. */
1640 /* We are missing the conversion to floating type. */
1641 if (as_int
&& as_ptr
&& for_sure
)
1643 cp_error ("ambiguous conversion from `%T' to `bool', can convert to integral type or pointer", TREE_TYPE (expr
));
1644 return error_mark_node
;
1648 as_int
= build_type_conversion (code
, long_long_unsigned_type_node
, expr
, for_sure
+exact_conversion
*2);
1649 return convert (xtype
, as_int
);
1653 as_ptr
= build_type_conversion (code
, ptr_type_node
, expr
, for_sure
+exact_conversion
*2);
1654 return convert (xtype
, as_ptr
);
1659 /* No perfect match found, try default. */
1660 #if 0 /* This is wrong; there is no standard conversion from void* to
1662 if (code
== CONVERT_EXPR
&& TREE_CODE (type
) == POINTER_TYPE
)
1663 type_default
= ptr_type_node
;
1666 if (type
== void_type_node
)
1670 tree tmp
= default_conversion (build1 (NOP_EXPR
, type
, integer_zero_node
));
1671 if (tmp
== error_mark_node
)
1673 type_default
= TREE_TYPE (tmp
);
1676 basetype
= save_basetype
;
1678 if (type_default
!= type
)
1680 type
= type_default
;
1681 typename
= build_typename_overload (type
);
1683 while (TYPE_HAS_CONVERSION (basetype
))
1685 if (lookup_fnfields (TYPE_BINFO (basetype
), typename
, 0))
1686 return build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
);
1687 if (TYPE_BINFO_BASETYPES (basetype
))
1688 basetype
= TYPE_BINFO_BASETYPE (basetype
, 0);
1694 if (TREE_CODE (type
) == POINTER_TYPE
&& TYPE_READONLY (TREE_TYPE (type
)))
1696 /* Try converting to some other const pointer type and then using
1697 standard conversions. */
1699 while (TYPE_HAS_CONVERSION (basetype
))
1701 if (CLASSTYPE_CONVERSION (basetype
, constptr_conv
) != 0)
1703 if (CLASSTYPE_CONVERSION (basetype
, constptr_conv
) == error_mark_node
)
1704 return error_mark_node
;
1705 typename
= DECL_NAME (CLASSTYPE_CONVERSION (basetype
, constptr_conv
));
1706 return build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
);
1708 if (TYPE_BINFO_BASETYPES (basetype
))
1709 basetype
= TYPE_BINFO_BASETYPE (basetype
, 0);
1714 if (TREE_CODE (type
) == POINTER_TYPE
)
1716 /* Try converting to some other pointer type and then using standard
1719 while (TYPE_HAS_CONVERSION (basetype
))
1721 if (CLASSTYPE_CONVERSION (basetype
, ptr_conv
) != 0)
1723 if (CLASSTYPE_CONVERSION (basetype
, ptr_conv
) == error_mark_node
)
1724 return error_mark_node
;
1725 typename
= DECL_NAME (CLASSTYPE_CONVERSION (basetype
, ptr_conv
));
1726 return build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
);
1728 if (TYPE_BINFO_BASETYPES (basetype
))
1729 basetype
= TYPE_BINFO_BASETYPE (basetype
, 0);
1735 /* Use the longer or shorter conversion that is appropriate. Have
1736 to check against 0 because the conversion may come from a baseclass. */
1737 if (TREE_CODE (type
) == INTEGER_TYPE
1738 && TYPE_HAS_INT_CONVERSION (basetype
)
1739 && CLASSTYPE_CONVERSION (basetype
, int_conv
) != 0
1740 && CLASSTYPE_CONVERSION (basetype
, int_conv
) != error_mark_node
)
1742 typename
= DECL_NAME (CLASSTYPE_CONVERSION (basetype
, int_conv
));
1743 return build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
);
1746 if (TREE_CODE (type
) == REAL_TYPE
1747 && TYPE_HAS_REAL_CONVERSION (basetype
)
1748 && CLASSTYPE_CONVERSION (basetype
, real_conv
) != 0
1749 && CLASSTYPE_CONVERSION (basetype
, real_conv
) != error_mark_node
)
1751 /* Only accept using an operator double() if there isn't a conflicting
1753 if (TYPE_HAS_INT_CONVERSION (basetype
))
1757 cp_error ("two possible conversions for type `%T'", type
);
1758 return error_mark_node
;
1764 typename
= DECL_NAME (CLASSTYPE_CONVERSION (basetype
, real_conv
));
1765 return build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
);
1768 /* THESE ARE TOTAL KLUDGES. */
1769 /* Default promotion yields no new alternatives, try
1770 conversions which are anti-default, such as
1772 double -> float or int -> unsigned or unsigned -> long
1775 if (type_default
== type
1776 && (INTEGRAL_TYPE_P (type
) || TREE_CODE (type
) == REAL_TYPE
))
1780 if (type
== double_type_node
)
1781 typename
= build_typename_overload (float_type_node
);
1782 else if (type
== integer_type_node
)
1783 typename
= build_typename_overload (unsigned_type_node
);
1784 else if (type
== unsigned_type_node
)
1785 typename
= build_typename_overload (long_integer_type_node
);
1788 basetype
= save_basetype
;
1789 while (TYPE_HAS_CONVERSION (basetype
))
1791 if (lookup_fnfields (TYPE_BINFO (basetype
), typename
, 0))
1792 return build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
);
1793 if (TYPE_BINFO_BASETYPES (basetype
))
1794 basetype
= TYPE_BINFO_BASETYPE (basetype
, 0);
1800 if (type
== integer_type_node
)
1802 typename
= build_typename_overload (long_integer_type_node
);
1808 typename
= build_typename_overload (integer_type_node
);
1815 /* Now, try C promotions...
1820 basetype
= save_basetype
;
1821 if (TREE_CODE (type
) == REAL_TYPE
)
1822 type
= integer_type_node
;
1823 else if (TREE_CODE (type
) == INTEGER_TYPE
)
1824 if (TYPE_HAS_REAL_CONVERSION (basetype
))
1825 type
= double_type_node
;
1831 typename
= build_typename_overload (type
);
1832 while (TYPE_HAS_CONVERSION (basetype
))
1834 if (lookup_fnfields (TYPE_BINFO (basetype
), typename
, 0))
1836 rval
= build_type_conversion_1 (xtype
, basetype
, expr
, typename
, for_sure
);
1839 if (TYPE_BINFO_BASETYPES (basetype
))
1840 basetype
= TYPE_BINFO_BASETYPE (basetype
, 0);
1848 /* Must convert two aggregate types to non-aggregate type.
1849 Attempts to find a non-ambiguous, "best" type conversion.
1851 Return 1 on success, 0 on failure.
1853 @@ What are the real semantics of this supposed to be??? */
1855 build_default_binary_type_conversion (code
, arg1
, arg2
)
1856 enum tree_code code
;
1859 tree type1
= TREE_TYPE (*arg1
);
1860 tree type2
= TREE_TYPE (*arg2
);
1862 if (TREE_CODE (type1
) == REFERENCE_TYPE
1863 || TREE_CODE (type1
) == POINTER_TYPE
)
1864 type1
= TREE_TYPE (type1
);
1865 if (TREE_CODE (type2
) == REFERENCE_TYPE
1866 || TREE_CODE (type2
) == POINTER_TYPE
)
1867 type2
= TREE_TYPE (type2
);
1869 if (TREE_CODE (TYPE_NAME (type1
)) != TYPE_DECL
)
1871 tree decl
= typedecl_for_tag (type1
);
1873 error ("type conversion nonexistent for type `%s'",
1874 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1876 error ("type conversion nonexistent for non-C++ type");
1879 if (TREE_CODE (TYPE_NAME (type2
)) != TYPE_DECL
)
1881 tree decl
= typedecl_for_tag (type2
);
1883 error ("type conversion nonexistent for type `%s'",
1884 IDENTIFIER_POINTER (decl
));
1886 error ("type conversion nonexistent for non-C++ type");
1890 if (!IS_AGGR_TYPE (type1
) || !TYPE_HAS_CONVERSION (type1
))
1892 if (!IS_AGGR_TYPE (type2
) || !TYPE_HAS_CONVERSION (type2
))
1893 cp_error ("no conversion from `%T' and `%T' to types with default `%O' ",
1894 type1
, type2
, code
);
1896 cp_error ("no conversion from `%T' to type with default `%O'",
1900 else if (!IS_AGGR_TYPE (type2
) || !TYPE_HAS_CONVERSION (type2
))
1902 cp_error ("no conversion from `%T' to type with default `%O'",
1907 if (code
== TRUTH_ANDIF_EXPR
1908 || code
== TRUTH_ORIF_EXPR
)
1910 *arg1
= convert (bool_type_node
, *arg1
);
1911 *arg2
= convert (bool_type_node
, *arg2
);
1913 else if (TYPE_HAS_INT_CONVERSION (type1
))
1915 if (TYPE_HAS_REAL_CONVERSION (type1
))
1916 cp_pedwarn ("ambiguous type conversion for type `%T', defaulting to int",
1918 *arg1
= build_type_conversion (code
, integer_type_node
, *arg1
, 1);
1919 *arg2
= build_type_conversion (code
, integer_type_node
, *arg2
, 1);
1921 else if (TYPE_HAS_REAL_CONVERSION (type1
))
1923 *arg1
= build_type_conversion (code
, double_type_node
, *arg1
, 1);
1924 *arg2
= build_type_conversion (code
, double_type_node
, *arg2
, 1);
1928 *arg1
= build_type_conversion (code
, ptr_type_node
, *arg1
, 1);
1929 if (*arg1
== error_mark_node
)
1930 error ("ambiguous pointer conversion");
1931 *arg2
= build_type_conversion (code
, ptr_type_node
, *arg2
, 1);
1932 if (*arg1
!= error_mark_node
&& *arg2
== error_mark_node
)
1933 error ("ambiguous pointer conversion");
1937 if (*arg2
== 0 && type1
!= type2
)
1938 cp_error ("default type conversion for types `%T' and `%T' failed",
1941 cp_error ("default type conversion for type `%T' failed", type1
);
1944 else if (*arg2
== 0)
1946 cp_error ("default type conversion for type `%T' failed", type2
);
1952 /* Must convert an aggregate type to non-aggregate type.
1953 Attempts to find a non-ambiguous, "best" type conversion.
1955 Return 1 on success, 0 on failure.
1957 The type of the argument is expected to be of aggregate type here.
1959 @@ What are the real semantics of this supposed to be??? */
1961 build_default_unary_type_conversion (code
, arg
)
1962 enum tree_code code
;
1965 tree type
= TREE_TYPE (*arg
);
1967 if (! TYPE_HAS_CONVERSION (type
))
1969 cp_error ("type conversion required for type `%T'", type
);
1973 if (code
== TRUTH_NOT_EXPR
)
1974 *arg
= convert (bool_type_node
, *arg
);
1975 else if (TYPE_HAS_INT_CONVERSION (type
))
1977 if (TYPE_HAS_REAL_CONVERSION (type
))
1978 cp_pedwarn ("ambiguous type conversion for type `%T', defaulting to int",
1980 *arg
= build_type_conversion (code
, integer_type_node
, *arg
, 1);
1982 else if (TYPE_HAS_REAL_CONVERSION (type
))
1983 *arg
= build_type_conversion (code
, double_type_node
, *arg
, 1);
1986 *arg
= build_type_conversion (code
, ptr_type_node
, *arg
, 1);
1987 if (*arg
== error_mark_node
)
1988 error ("ambiguous pointer conversion");
1990 if (*arg
== NULL_TREE
)
1992 cp_error ("default type conversion for type `%T' failed", type
);
1998 /* Implements integral promotion (4.1) and float->double promotion. */
2000 type_promotes_to (type
)
2003 int constp
= TYPE_READONLY (type
);
2004 int volatilep
= TYPE_VOLATILE (type
);
2005 type
= TYPE_MAIN_VARIANT (type
);
2007 /* bool always promotes to int (not unsigned), even if it's the same
2009 if (type
== bool_type_node
)
2010 type
= integer_type_node
;
2012 /* Normally convert enums to int, but convert wide enums to something
2014 else if (TREE_CODE (type
) == ENUMERAL_TYPE
2015 || type
== wchar_type_node
)
2017 int precision
= MAX (TYPE_PRECISION (type
),
2018 TYPE_PRECISION (integer_type_node
));
2019 tree totype
= type_for_size (precision
, 0);
2020 if (TREE_UNSIGNED (type
)
2021 && ! int_fits_type_p (TYPE_MAX_VALUE (type
), totype
))
2022 type
= type_for_size (precision
, 1);
2026 else if (C_PROMOTING_INTEGER_TYPE_P (type
))
2028 /* Traditionally, unsignedness is preserved in default promotions.
2029 Otherwise, retain unsignedness if really not getting bigger. */
2030 if (TREE_UNSIGNED (type
)
2031 && (flag_traditional
2032 || TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
2033 type
= unsigned_type_node
;
2035 type
= integer_type_node
;
2037 else if (type
== float_type_node
)
2038 type
= double_type_node
;
2040 return cp_build_type_variant (type
, constp
, volatilep
);